segunda-feira, 25 de outubro de 2010

Placar de truco :

este exemplo de codigo é uma contribuição de Rafael Varago para mais informação sobre este projeto
veja o link no final dessa postagem.

   visualização do projeto

codigo fonte :

/**************************************************************************
*                    Placar Eletronico de Truco                           *
***************************************************************************
* Rafael Varago de Aguiar                       Varago Automatics         *
***************************************************************************
* Versão: 2.0                                                             *
* Data: 19/10/2010                                                        *
*                                                                         *
* RAM: 6%   ROM: 7%                                                       *
***************************************************************************
* Controle de 4 Displays 7 segmentos para servir de placar de truco       *
* que vai de 0 a 12, sendo 2 displays para casa equipe                    *
* os pontos são computados através de 3 botões                            *
* DOWN: decrementa 1,UP: incrementa 1, TR: soma 3; o placar               *
* e salva na EEPROM os valores dos contadores para inicia-lo com eles     *
* na proxima vez que o circuito for ligado.                               *
**************************************************************************/
#include <16f877a.h> // Informa o PIC
#device adc=10 // Configura conversor AD para 10 bits
#fuses XT,NOWDT,NOPROTECT,PUT,BROWNOUT,NOLVP,NOCPD,NOWRT // Configs internas
#use delay (clock=4000000) // Seleciona delay para 4Mhz de clock
/**************************************************************************
**************************************************************************/
// Definições de pinos
#define dw1 pin_b0 // DOWN1 (decremeta 1 para a equipe 1)
#define up1 pin_b1 // UP1 (incrementa 1 para a equipe 1)
#define tr1 pin_b2 // TR1 (soma 3 para a equipe 1)
#define dw2 pin_b3 // DOWN2 (decremeta 1 para a equipe 2)
#define up2 pin_b4 // UP2 (incrementa 1 para a equipe 2)
#define tr2 pin_b5 // TR2 (soma 3 para a equipe 2)
/**************************************************************************
**************************************************************************/
// Variaveis globais
int pl1,pl2; // Armazanam o valor da contagem do placar
/**************************************************************************
**************************************************************************/
// Tabela para converter o valor da contagem para exibir no display
byte const tabela[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xe7};
/**************************************************************************
**************************************************************************/
main(){ // Rotina principal
   int1 max1,min1,max2,min2; // Sinalizadores para indicar contagem min e max
   port_b_pullups(true); // Ativa pull-ups do portb
   setup_adc_ports(no_analogs); // Configura todas as entradas como digitais
   pl1=0; // Garante que o contador da equipe 1 comece em 0
   pl2=0; //    "     "  o    "     da   "    2   "    em 0
   delay_ms(500); // Estabilização da EEPROM
   pl1=read_eeprom(1); // Carrega o ultimo valor da EEPROM salvo do contador 1
   pl2=read_eeprom(2); //    "    o   "      "   da   "      "   do    "     2
   while(1){ // Laço de repetição infinito
/**************************************************************************
**************************************************************************/
// Fragmento do software para a contagem da primeira equipe
      if(min1 == 0){ // Se o display não estiver em 0
         if(!input(dw1)){ // Se o botão DOWN1 for pressionado
            while(input(dw1) == 0){
            } // Laço para soltar botão
            max1=0; // Limpa o sinalizador de display igual a 12
            pl1--; // Decrementa 1 da variavel de contagem da equipe 1
            if(pl1 == 0) // Se a contagem da equipe 1 estiver em 0
               min1=1; // Joga 1 no sinalizador de display igual a 0
            write_eeprom(1,pl1); // Salva o valor do contador 1 na EEPROM
         }
      } // Fim do bloco
      if(max1 == 0){ // Se o display não estiver em 12
         if(!input(up1)){ // Se o botão UP1 for pressionado
            while(input(up1) == 0){
            } // Laço para soltar botão
            min1=0; // Limpa o sinalizador de display igual a 0
            pl1++; // Incrementa 1 da variavel de contagem da equipe 1
            if(pl1 == 12) // Se a contagem da equipe 1 estiver em 12
               max1=1; // Joga 1 no sinalizador de display igual a 12
         write_eeprom(1,pl1); // Salva o valor do contador 1 na EEPROM
         }
      } // Fim do bloco
      if(max1 == 0){ // Se o display não estiver em 12
         if(!input(tr1)){ // Se o botão TR1 for pressionado
            while(input(tr1) == 0){
            } // Laço para soltar botão
            min1=0; // Limpa o sinalizador de display igual a 0
            pl1=pl1+3; // Incrementa 3 da variavel de contagem da equipe 1
            if(pl1 > 12){ // Se a contagem da equipe 1 ultrapassar 12
               pl1=12; // Contador da equipe 1 igual a 12
               max1=1;  // Joga 1 no sinalizador de display igual a 12
            }
         write_eeprom(1,pl1); // Salva o valor do contador 1 na EEPROM
         }
      } // Fim do bloco
/**************************************************************************
**************************************************************************/
// Fragmento do software para a contagem da segunda equipe
      if(min2 == 0){ // Se o display não estiver em 0
         if(!input(dw2)){ // Se o botão DOWN2 for pressionado
            while(input(dw2) == 0){
            } // Laço para soltar botão
            max2=0; // Limpa o sinalizador de display igual a 12
            pl2--; // Decrementa 1 da variavel de contagem da equipe 2
            if(pl2 == 0) // Se a contagem da equipe 2 estiver em 0
               min2=1; // Joga 1 no sinalizador de display igual a 0
            write_eeprom(2,pl2); // Salva o valor do contador 2 na EEPROM
         }
      } // Fim do bloco
      if(max2 == 0){ // Se o display não estiver em 12
         if(!input(up2)){ // Se o botão IP2 for pressionado
            while(input(up2) == 0){
            } // Laço para soltar botão
            min2=0; // Limpa o sinalizador de display igual a 0
            pl2++; // Incrementa 1 da variavel de contagem da equipe 2
            if(pl2 == 12) // Se a contagem da equipe 2 estiver em 12
               max2=1; // Joga 1 no sinalizador de display igual a 12
            write_eeprom(2,pl2); // Salva o valor do contador 2 na EEPROM
         }
      } // Fim do bloco
      if(max2 == 0){ // Se o display não estiver em 12
         if(!input(tr2)){ // Se o botão TR2 for pressionado
            while(input(tr2) == 0){
            } // Laço para soltar botão
            min2=0; // Limpa o sinalizador de display igual a 0
            pl2=pl2+3; // Incrementa 3 da variavel de contagem da equipe 2
            if(pl2 > 12){ // Se a contagem da equipe 2 ultrapassar 12
               pl2=12; // Contador da equipe 2 igual a 12
               max2=1;  // Joga 1 no sinalizador de display igual a 12
            }
            write_eeprom(2,pl2); // Salva o valor do contador 2 na EEPROM
         }
      } // Fim do bloco
/**************************************************************************
**************************************************************************/
// Joga valores nos displays
      output_c(0xfe); // Seleciona display dezena equipe 1
      output_d(tabela[pl1/10]); // Joga o valor do contador
      delay_ms(10); // Tempo para display ligado
      output_c(0xfd); // Seleciona display unidade equipe 1
      output_d(tabela[pl1%10]); // Joga o valor do contador
      delay_ms(10); // Tempo para display ligado
      output_c(0xfb); // Seleciona display dezena equipe 2
      output_d(tabela[pl2/10]); // Joga o valor do contador
      delay_ms(10); // Tempo para display ligado
      output_c(0xf7); // Seleciona display unidade equipe 2
      output_d(tabela[pl2%10]); // Joga o valor do contador
      delay_ms(10); // Tempo para display ligado
   } // Fim do laço de repetição
} // Fim do programa

para mais informação escreva para  rafaelvarago@yahoo.com.br .


quinta-feira, 16 de setembro de 2010

sequencial de 22 leds com atmega8 (avr)

Olá ,aqui está um exemplo de codigo para quem precisar fazer um sequencial de leds

//************************************************************************
//                             usando sequencial
//  Version : 1.0
//  microcontrolador : AVR ATMega8
//  Autor     : Aguivone
//  descrição  : acesso individual usando define
//  data : 16/09/2010.
//
//************************************************************************
#define F_CPU 1000000UL  // 1 MHz deve vir antes das interrupçoes
#include <avr/io.h> //standard include for ATMega16 # Include <avr/io.h> / padrão para incluir ATMEGA16
#include <util/delay.h>
#define liga_pino(x,y) x |= _BV(y)
#define desliga_pino(x,y) x &= ~(_BV(y))
#define alterna_pino(x,y) x ^= _BV(y)
#define pino_alto(x,y) ((x & _BV(y)) == _BV(y)) //o pino deve estar como entrada ,testa se está em nivel logico 1

///* _BV(a) is a macro which returns the value in hex corresponding to 2 to the power 'a'. / * _BV (A) é uma macro que retorna o valor em hexadecimal correspondente a 2 elevado à potência 'a'. Thus _BV(PX3) would be 0x08 or 0b00001000 */ Assim _BV PX3 () seria 0x08 ou 0b00001000 * /
int main (void)
{
    unsigned int valor = 50;
   // DDRB= 0xf7 ; //PORTB as OUTPUT DDRB = 0xff; / PORTB / as OUTPUT
    DDRB = 0xFF;
    DDRC = 0xFF;
    DDRD = 0xFF;
    PORTB = 0x00 ; //All pins of PORTB LOW PORTB = 0x00 / / Todos os pinos do PORTB LOW
    PORTC = 0x00 ; //All pins of PORTB LOW PORTB = 0x00 / / Todos os pinos do PORTB LOW
    PORTD = 0x00 ; //All pins of PORTB LOW PORTB = 0x00 / / Todos os pinos do PORTB LOW
    while (1)
    {
    //////////////////////////////////////////////
       liga_pino(PORTB,PB0);
    _delay_ms(1);
       desliga_pino(PORTC,PC5);
        _delay_ms(valor);
       liga_pino(PORTB,PB1);
    _delay_ms(1);
       desliga_pino(PORTB,PB0);
        _delay_ms(valor);
  liga_pino(PORTB,PB2);
  _delay_ms(1);
       desliga_pino(PORTB,PB1);
        _delay_ms(valor);
       liga_pino(PORTB,PB3);
    _delay_ms(1);
       desliga_pino(PORTB,PB2);
        _delay_ms(valor);
     
     liga_pino(PORTB,PB4);
  _delay_ms(1);
       desliga_pino(PORTB,PB3);
        _delay_ms(valor);
       liga_pino(PORTB,PB5);
    _delay_ms(1);
       desliga_pino(PORTB,PB4);
        _delay_ms(valor);
  liga_pino(PORTB,PB6);
  _delay_ms(1);
        desliga_pino(PORTB,PB5);
        _delay_ms(valor);
        liga_pino(PORTB,PB7);
     _delay_ms(1);
        desliga_pino(PORTB,PB6);
        _delay_ms(valor);
       ///////////////////////////////////////////////////////////
     liga_pino(PORTD,PD0);
    _delay_ms(1);
       desliga_pino(PORTB,PB7);
        _delay_ms(valor);
       liga_pino(PORTD,PD1);
    _delay_ms(1);
       desliga_pino(PORTD,PD0);
        _delay_ms(valor);
  liga_pino(PORTD,PD2);
  _delay_ms(1);
       desliga_pino(PORTD,PD1);
        _delay_ms(valor);
       liga_pino(PORTD,PD3);
    _delay_ms(1);
       desliga_pino(PORTD,PD2);
        _delay_ms(valor);
     
     liga_pino(PORTD,PD4);
  _delay_ms(1);
       desliga_pino(PORTD,PD3);
        _delay_ms(valor);
       liga_pino(PORTD,PD5);
    _delay_ms(1);
       desliga_pino(PORTD,PD4);
        _delay_ms(valor);
  liga_pino(PORTD,PD6);
  _delay_ms(1);
        desliga_pino(PORTD,PD5);
        _delay_ms(valor);
        liga_pino(PORTD,PD7);
     _delay_ms(1);
        desliga_pino(PORTD,PD6);
        _delay_ms(valor);
  ///////////////////////////////////////////
  liga_pino(PORTC,PC0);
    _delay_ms(1);
       desliga_pino(PORTD,PD7);
        _delay_ms(valor);
       liga_pino(PORTC,PC1);
    _delay_ms(1);
       desliga_pino(PORTC,PC0);
        _delay_ms(valor);
  liga_pino(PORTC,PC2);
  _delay_ms(1);
       desliga_pino(PORTC,PC1);
        _delay_ms(valor);
       liga_pino(PORTC,PC3);
    _delay_ms(1);
       desliga_pino(PORTC,PC2);
        _delay_ms(valor);
     
     liga_pino(PORTC,PC4);
  _delay_ms(1);
       desliga_pino(PORTC,PC3);
        _delay_ms(valor);
       liga_pino(PORTC,PC5);
    _delay_ms(1);
       desliga_pino(PORTC,PC4);
        _delay_ms(valor);

       }
}

terça-feira, 14 de setembro de 2010

usando lcd 4 bits com atmega8 AVR STUDIO

Aqui a proposta é controlar um lcd de forma facil e sem biblioteca :
///************************************************************************/
//                             usando LCD
//  Version    : 1.0
//  microcontrolador : AVR ATMega8
//  Autor        : Aguivone
//  descrição  : usando lcd interface de 8 bits
//  data : 02/09/2010.
//
//************************************************************************/
#define F_CPU 4000000UL  // 4 MHz
#include <avr/io.h>
#include <util/delay.h>
#include <string.h> 

/////////////////////////////////////variaveis usada no lcd ///////////////////////////////////////////
//#define LCD PORTC //define qual porta vai usar neste caso port C
#define LCD PORTD //define qual porta vai usar neste caso port D
//o pino r/w é conectado ao terra pois não é feita nenhuma leitura no display
//configuração:
//
// pino display  / pino da porta selecionada
//
// D4 = bit 0 da porta
// D5 = bit 1 da porta
// D6 = bit 2 da porta
// D7 = bit 3 da porta
//
// RS = bit 4 da porta
// EN = bit 5 da porta
//
/////////////////////////////////////////////////Funções usadas no LCD/////////////////////////////////////////////

void inicializa_LCD(void)
{
    _delay_ms(15);//tempo para estabilizar a tensão e preparar o display
    // o primeiro digito é de controle e o segundo configuração

    LCD = 0X22;//nesse momento o display ainda está em modo 8bits solicita modo de 4 bits
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X02;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);
                // é preciso colocar este comando pelo menos 2 vezes para que funcione o display
    LCD = 0X22;//nesse momento o display  está em modo 4bits 
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X02;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);

    LCD = 0X28;//nesse momento o display  está em modo 4bits,manda usar 2 linhas 
    _delay_ms(1);//tempo estabilizar o pino
    LCD =0X08;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);

    LCD = 0X20;//manda limpar o display
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X00;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);//substitui a leitura do busy flag 

    LCD = 0X21;//segundo nibble (limpa display)
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X01;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);//substitui a leitura do busy flag 
    
     LCD = 0X20;//manda deslocar a direita (0x06)
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X00;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);

     LCD = 0X26;//segundo nibble (desloca a direita)
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X06;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);//substitui a leitura do busy flag 

    LCD = 0X20;//cursor desligado (0X0C)
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X00;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);//substitui a leitura do busy flag 

    LCD = 0X2C;//segundo nibble (cursor deligado)
    _delay_ms(1);//tempo estabilizar o pino
    LCD = 0X0C;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_ms(15);//substitui a leitura do busy flag 
    
}
// escreve nibble
void escr(unsigned char crt,int vlr)
{
    if(vlr == 1)
    {
    LCD = crt | 0X30 ;//escreve dados
    _delay_us(30);//tempo estabilizar o pino
    LCD = crt | 0X10;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_us(30);
    }
    else
    {
    LCD = crt | 0X20 ;//escreve comando
    _delay_us(30);//tempo estabilizar o pino
    LCD = crt | 0X00;//ao passar do nivel alto para o nivel baixo ele faz leitura
    _delay_us(30);
    }
}
// escreve caracter ou comando
void escreve(unsigned char carac,int val)
{
    unsigned char temp=carac;
    carac = ((carac >> 4) & 0X0F);
    temp  = temp & 0X0F;
    escr(carac,val);  //escreve primeiro nibble
    escr(temp,val);  //escreve segundo nibble
}


void impri_lcd(char frase[17])
{
      unsigned int indice=0;
      unsigned int tamanho = strlen(frase);
      while(indice<tamanho)
       {         
            if(frase[indice]=='\n')//linha 1 
            {
                 escreve(0X80,0);
            }
            if(frase[indice]=='\r')//linha2
            {
               escreve(0XC0,0);
            }
            if((frase[indice]!='\r') && (frase[indice]!='\n') && (indice<18))//dados
            {
               escreve(frase[indice],1);
            }   
       indice++;
       }
} 

//////////////////////////////////////////////função principal///////////////////////////////////////////
int main(void)
{
           DDRC = 0XFF;  //inicializa portC
           DDRD = 0XFF;  //inicicializa portD como saida
           inicializa_LCD();
           impri_lcd("\n   teste de lcd ");
           impri_lcd("\r      AGUIVONE  ");
          for(;;)
            {
              //faz nada                
            }
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


quarta-feira, 8 de setembro de 2010

Interrupção externa com atmega8 - avr studio

//************************************************************************
// usando interrupção externa
// Version : 1.0
// microcontrolador : AVR ATMega8
// Autor : Aguivone
// descrição : usando interrupção externa int0 e int1
// data : 25/08/2010.
//
//************************************************************************
#define F_CPU 1000000UL // 1 MHz deve vir antes das interrupçoes
#include
#include

//////////////////////////interrupções externas ///////////////////////////////////
ISR(INT0_vect ) //int0
{
PORTC = ~PORTC;
}
ISR(INT1_vect ) //int1
{
PORTB = ~PORTB;
}

/////////////////////////////////////////////////Funções usadas/////////////////////////////////////////////
void inicializa_interrupt(void)
{
MCUCR = 0X07;//configura a interrupção 1 para qualquer mudança de estado no pino e int0 para borda de subida
GICR = 0xC0;//habilita int1 e int0
sei(); //habilita interrupções
}

//////////////////////////////////////////////função principal///////////////////////////////////////////
int main(void)
{
DDRC = 0xFF; //inicializa portd
PORTC = 0;
DDRB = 0xFF; //inicializa portd
PORTB = 0; inicializa_interrupt();
for(;;)
{
//faz nada!
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

PWM com o atmega8 - avr studio

//************************************************************************
// usando o PWM
// Version : 1.0
// microcontrolador : AVR ATMega8
// Autor : Aguivone
// descrição : PWM
// data : 30/08/2010.
//
//************************************************************************
#define F_CPU 1000000UL // 1 MHz deve vir antes das interrupçoes
#include

/////////////////////////////////////////////////Funções usadas/////////////////////////////////////////////
void PWM_CTC(void)
{
TCCR2 = 0X55;// toggle OC2 / usar modo CTC / preescaler(1/128) // // aqui se define a frequencia.
OCR2 = 0X40;//valor a ser comparado com o TCNT2 (aqui é mudado a largura do pulso)

//pinos de pwm PB1,PB2,PB3(OC1,2,3).
}

void PWM_NORMAL(void)// o valor da largura de pulso é sempre 50%
{
TCCR2 = 0X15;// toggle OC2 / usar modo normal / preescaler(1/128) // // aqui se define a frequencia.
//pinos de pwm PB1,PB2,PB3(OC1,2,3).
}

void PWM_FAST(void)// o valor da largura de pulso é sempre 50%
{
TCCR2 = 0X7D;// modo invertido OC2 / usar modo fast pwm / preescaler(1/128) // // aqui se define a frequencia.
//pinos de pwm PB1,PB2,PB3(OC1,2,3).

// neste modo gera um pulso muito rapido se no modo invertido a largura do pulso é proximo de 99%
// modo não invertido a largura do pulso é proximo de 1%
}

void PWM_FASE(void)// o valor da largura de pulso é sempre 50%
{
TCCR2 = 0X3F;// seta OC2 quando comparado/ usar modo fase pwm / preescaler(1/128) // // aqui se define a frequencia.
//pinos de pwm PB1,PB2,PB3(OC1,2,3).
// a verificar
}

Usando serial com atmega8 - avr studio

//************************************************************************


// usando a porta serial
// Version : 1.0
// microcontrolador : AVR ATMega8 UART
// Autor : Aguivone
// descrição : exemplo de uso da serial
//
//************************************************************************

#include <avr/io.h>
#define F_CPU 1000000UL // 1 MHz deve vir antes das interrupçoes
#include <avr/interrupt.h>
#include <stdio.h>
///////////////////////////////////////////////funçoes usadas////////////////////////////////////////////////

int uart_putchar(char c, FILE *stream)

{
if (c == '\n')
uart_putchar('\r', stream);
loop_until_bit_is_set(UCSRA, UDRE);
UDR = c;
return 0;
}

int uart_getch(FILE *stream)
{
unsigned char ch;
while (!(UCSRA & (1<<RXC)));
ch=UDR;
return ch;
}

/* assimila I/O stream á UART */

FILE uart_str = FDEV_SETUP_STREAM(uart_putchar, uart_getch, _FDEV_SETUP_RW);

void ini_serial(int BAUD_RATE)
{
UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8; // calcula o ubrr da comunicação
UBRRL = (((F_CPU/BAUD_RATE)/16)-1);
UCSRB = (1<<RXEN)
(1<<TXEN); //habilita tx e rx

UCSRC = (1<<URSEL)
(1<<UCSZ1)
(1<<UCSZ0);//programa para 8bit ,sem paridade,1 stop bit
sei(); // habilita interrupçoes geral
}

void Delay(unsigned int count) // conta tempo

{
while(count>0)
{
count--;
}
}



//////////////////////////////////////////função principal///////////////////////////////////

int main(void)
{
stdout = stdin = &uart_str; /* inicializa a UART */
ini_serial(4800); /* inicializa serial para 4800 bps */
DDRD = 0xFF; // configura o portd
PORTD = 0; // inicializa o portd

for(;;)
{
printf("teste de serial \n\r");
Delay(12000);
}

}

///////////////////////////////////////////fim//////////////////////////////////////////////

Pisca pisca com timer0 - avr studio

//************************************************************************
// usando os timers
// Version : 1.0
// microcontrolador : AVR ATMega8
// Autor : Aguivone
// descrição : interrupção dos timer
// data : 24/08/2010.
//
//************************************************************************
#define F_CPU 1000000UL // 1 MHz deve vir antes das interrupçoes
#include
#include

//////////////////////////interrupções do timer0 ///////////////////////////////////
ISR(TIMER0_OVF_vect )
{ //interrupção overflow
PORTD =~ PORTD; //nessa interrupção não é preciso ler ou zerar o TCNT0
}

/////////////////////////////////////////////////Funções usadas/////////////////////////////////////////////
void inicializa_timer0(void)
{
TCCR0 = 0x05; //pre escaler dividido por 8
TIMSK = 0x01; //habilita interrupção do timer 0(estouro do contador)
sei(); //habilita interrupções
}

//////////////////////////////////////////////função principal///////////////////////////////////////////
int main(void)
{
DDRD = 0xFF; //inicializa portd
PORTD = 0;
inicializa_timer0();
for(;;)
{
//faz nada!
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

usando a eeprom do atmega8 - avr studio


 1:  //************************************************************************
   2:  //                             usando a memoria do atmel
   3:  //  Version    : 1.0
   4:  //  microcontrolador : AVR ATMega8
   5:  //  Autor        : Aguivone
   6:  //  descrição  : escrevendo e lendo a memoria
   7:  //  data : 01/09/2010.
   8:  //
   9:  //************************************************************************
  10:  #define F_CPU 4000000UL  // 4 MHz deve vir antes das interrupçoes
  11:  #include <avr/io.h>
  12:  #include <avr/interrupt.h>
  13:  #include <util/delay.h>
  14:  #include <string.h>
  15:  #include <avr/eeprom.h>
  16:   
  17:   
  18:  #define liga_pino(x,y) x |= _BV(y)
  19:  #define desliga_pino(x,y) x &= ~(_BV(y))
  20:   
  21:  unsigned char temp;
  22:   
  23:   unsigned char caracter;//
  24:   unsigned int  tam_buffer;//usado para contar o tamanho do buffer de recepção
  25:   unsigned char buffer_serial[14];//buffer da serial
  26:   volatile char rec_buffer ='S';//usado para ler o buffer de recepção (volatile para funcionar pois sempre ira retornar mesmo valor)
  27:   
  28:  ///////////////////////////////////////////////funçoes usadas pela usart////////////////////////////////////////////////
  29:   
  30:  void serial_inicializa(unsigned int BAUD)
  31:  {
  32:  unsigned int valor = F_CPU/16/BAUD-1; //é recomendavel ver o data sheet para ter certeza se está formula irá funcionar na sua mcu
  33:  /* baud rate */
  34:  UBRRH = (unsigned char)(valor>>8);
  35:  UBRRL = (unsigned char)valor;
  36:  UCSRA = 0X20;
  37:  /* habilita receiver and transmitter buffers */
  38:  UCSRB = 0X98;//deve se habilitar somente a interrupção de recepção para não travar o microcontrolador
  39:  /* 8 bits , 1 stop bit, assincrono , sem paridade */
  40:  UCSRC = 0X86;
  41:  }
  42:  void impri_serial(const char frase[80])
  43:  {
  44:        unsigned int indice=0;
  45:        unsigned int tamanho = strlen(frase);      
  46:        while(indice<=tamanho)///veja que o programa pode travar se aqui não tiver as duas aspas
  47:         {
  48:             while ( !( UCSRA & (1<<UDRE)) ); //espera transmitir para enviar um novo
  49:             UDR =frase[indice];
  50:             indice++;
  51:         }
  52:  }
  53:  void put_serial(unsigned char *carac)
  54:  {
  55:             while ( !( UCSRA & (1<<UDRE)) ); //espera transmitir para enviar um novo
  56:             UDR = *carac;
  57:  }
  58:  //////////////////////////interrupções requerida para usar a serial///////////////////////////////////
  59:  ISR(USART_RXC_vect)
  60:  {                                            // # caracter *
  61:   caracter = (char)UDR;
  62:    if(caracter == '*')
  63:     {
  64:          if(tam_buffer<14)//max do display
  65:            {
  66:              rec_buffer ='F';
  67:             }
  68:             else
  69:             {
  70:              rec_buffer ='E';//tamanhoa incompativel
  71:             }
  72:     }
  73:    if((caracter != '*')&&(rec_buffer == 'I'))
  74:     {
  75:      buffer_serial[tam_buffer]=caracter;
  76:      tam_buffer++;
  77:      }
  78:    if(caracter == '#')
  79:     {
  80:     rec_buffer ='I';
  81:     tam_buffer=0;
  82:     }
  83:  }
  84:   
  85:   
  86:  ////////////////////////////////////////////////função principal///////////////////
  87:   
  88:  int main(void)
  89:  {
  90:    DDRC = 0x00;  //inicializa portc como entrada
  91:    DDRD = 0XFE;  //inicializa portD
  92:    DDRB = 0xFF;  //inicializa portb como saida
  93:    serial_inicializa(4800);//não importa frequencia e 4800
  94:    sei();
  95:    impri_serial("Inicializado ... \n\r");
  96:    while (1)
  97:        {
  98:             if(rec_buffer == 'F')//tem dados para ler ?
  99:                       {
 100:                        impri_serial("recebeu primeiro caracter :");
 101:                        impri_serial(&buffer_serial[0]);
 102:                        impri_serial("\n\r");
 103:                        if(buffer_serial[0] == 'E')//houve interrupção
 104:                               {
 105:                                   impri_serial("comparou");
 106:                                   temp='n';
 107:                                   _EEPUT(5,buffer_serial[1]);//endereço/dado
 108:                                   _EEGET(temp,5);//local a ser escrito/endereço
 109:                                   impri_serial(& temp); 
 110:                                   liga_pino(PORTB,PB0);
 111:                                   _delay_ms(500);
 112:                                   desliga_pino(PORTB,PB0);
 113:                               }
 114:                        rec_buffer = 'S';
 115:                       } 
 116:                    if(rec_buffer == 'E')//deu erro ?
 117:                       {
 118:                        impri_serial("tamanho inconpativel");
 119:                        rec_buffer = 'S';
 120:                       }
 121:             
 122:   
 123:        }
 124:  }
 125:   
 126:   
 127:  //para usar float é necessario adiconar a biblioteca