Display de 7 segmentos com ATmega 328P (avr sutudio)

aqui é usado o display catodo comum!


Esquemático :

Código fonte:

//************************************************************************/
//                             Display 7 segmento com Atmega328P
//  Version             : 1.0
//  microcontrolador : AVR ATMega328
//  Autor            : Aguivone
//  descrição        : usando display 7 segmento com avr studio
//  data             : 26/07/2012.
//
//************************************************************************/
#define F_CPU 16000000UL  // 16 MHz
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <util/delay.h>
#include <string.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 SEG_A   PD7
#define SEG_B   PB0
#define SEG_C   PB1
#define SEG_D   PB2
#define SEG_E   PB3
#define SEG_F   PB4
#define SEG_G   PB5
/////////////////////////////funçoes auxiliares /////////////////////////////
void  mostra_numero(int numero)
{
     switch(numero)
     {
     case 0:
                {
                 liga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 liga_pino(PORTB,SEG_E);
                 liga_pino(PORTB,SEG_F);
                 desliga_pino(PORTB,SEG_G);
                }break;
     case 1:
                {
                 desliga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 desliga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 desliga_pino(PORTB,SEG_F);
                 desliga_pino(PORTB,SEG_G);
                }break;
     case 2:
                {
                 liga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 desliga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 liga_pino(PORTB,SEG_E);
                 desliga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);
                }break;
     case 3:
                {
                 liga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 desliga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);
                }break;
     case 4:
                {
                 desliga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 desliga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 liga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);
                }break;
     case 5:
                {
                 liga_pino(PORTD,SEG_A);
                 desliga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 liga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);
                }break;
     case 6:
                {
                 liga_pino(PORTD,SEG_A);
                 desliga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 liga_pino(PORTB,SEG_E);
                 liga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);
                }break;
     case 7:
                {
                 liga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 desliga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 desliga_pino(PORTB,SEG_F);
                 desliga_pino(PORTB,SEG_G);
                }break;
     case 8:
                {
                 liga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 liga_pino(PORTB,SEG_E);
                 liga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);
                }break;
     case 9:
                {
                 liga_pino(PORTD,SEG_A);
                 liga_pino(PORTB,SEG_B);
                 liga_pino(PORTB,SEG_C);
                 liga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 liga_pino(PORTB,SEG_F);
                 liga_pino(PORTB,SEG_G);            
                }break; 
     case 10://desliga display
                {
                 desliga_pino(PORTD,SEG_A);
                 desliga_pino(PORTB,SEG_B);
                 desliga_pino(PORTB,SEG_C);
                 desliga_pino(PORTB,SEG_D);
                 desliga_pino(PORTB,SEG_E);
                 desliga_pino(PORTB,SEG_F);
                 desliga_pino(PORTB,SEG_G);            
                }break; 
     }
}

/////////////////////////////função principal////////////////////////////////
int main(void)
{
           DDRD = 0XFF;  //inicializa portD como saida
           DDRB = 0XFF;  //inicializa portB como saida
           
          //////////////////////////
           for(;;)
            {     
              mostra_numero(0);
              _delay_ms(1000);
               mostra_numero(1);
              _delay_ms(1000);
               mostra_numero(2);
              _delay_ms(1000);
               mostra_numero(3);
              _delay_ms(1000);
               mostra_numero(4);
              _delay_ms(1000);
               mostra_numero(5);
              _delay_ms(1000);
               mostra_numero(6);
              _delay_ms(1000);
               mostra_numero(7);
              _delay_ms(1000);
               mostra_numero(8);
              _delay_ms(1000);
               mostra_numero(9);
              _delay_ms(1000);
               mostra_numero(10);
              _delay_ms(1000);               
            }
            
}
//////////////////////////////////////////////////////////////////////////////

para contribuir com o blog colocando seus projetos aqui basta entrar em contato!

até a próxima!

Discadora com ATmega328P

vou demonstrar aqui como fazer uma simples discadora de pulsos,para isso você terá que montar o seguinte circuito :

veja o código fonte:

/*
 *                                                 Discagem por pulsos
 *   Version    : 1.0
 *   microcontrolador : AVR ATMega328
 *   descrição  : como montar uma discadora por pulso
 *   criado: 11/07/2012 
 *   autor: aguivone moretti fogia
 */


#define F_CPU 16000000  // 16 MHz
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdio.h>
#include <util/delay.h>
#include <string.h>
//#include <avr/eeprom.h>//usado para acessar memoria

//funçoes basicas dos pinos
#define alterna_pino(x,y) x ^= _BV(y)   
#define liga_pino(x,y) x |= _BV(y)
#define desliga_pino(x,y) x &= ~(_BV(y))
#define estado_pino(x,y) ((x & _BV(y)) == _BV(y)) //o pino deve estar como entrada ,testa se está em nivel logico 1

 #define PULSO    PC1  //no rele de discagem deve ser colocado um resistor de 470R para não curto circuitar a linha telefonica 

void numero(int valor)
{
    int xis=0;
     while(xis < valor)
     {
      desliga_pino(PORTC,PULSO);
      _delay_ms(35);
      liga_pino(PORTC,PULSO);
      _delay_ms(65); 
      xis++;
     }
     _delay_ms(400);//espaço necessario entre cada digito
}
 
//////////////////////////////////////////////função principal///////////////////////////////////////////
int main(void)
{
           DDRC = 0XFF;  //inicializa portC como saida;
           
           for(;;)
           {
            // os numeros deve ser de 1 a 9, para o zero use o numero "10"
            //vamos supor que vai ligar para o numero 1234 5670
            liga_pino(PORTC,PULSO);
            _delay_ms(200); //espera para dar linha para discar 
            numero(1);
            numero(2);
            numero(3);
            numero(4);
            numero(5);
            numero(6);
            numero(7);
            numero(10);//zero             
            _delay_ms(10000); //espera para chamar por 10s
            desliga_pino(PORTC,PULSO);
            _delay_ms(10000);//espera 10s e liga denovo

           }
}

Usando interrupções externas do ATMEGA328P:

           O grande diferencial deste exemplo é que aqui vou demonstrar como usar as interrupções externas de modo que vocês possam usar todas( 23 interrupções no total),tempos atrás postei aqui como usar as interrupções INT0 e INT1 para o ATMEGA8 mas é se você precisar de mais interrupções como fazer ?.Para responder a essa pergunta monte o seguinte circuito na proto-o-board("coloque um led em qualquer pino do PORTB") ou no simulador virtual :

           E agora vamos ao código fonte :

//************************************************************************
//                             usando interrupção externa
//  Version    : 1.0
//  microcontrolador : AVR ATMega328P
//  Autor        : Aguivone
//  descrição  : usando interrupção externa int8 pra usar as outras interrupções é do mesmo modo
//                                                    pino C0(int8)
//  data : 10/07/2012.
//
//************************************************************************
#define F_CPU 16000000UL  // 1 MHz deve vir antes das interrupçoes
#include <avr/io.h>
#include <avr/interrupt.h>

/*
ISR(PCINT0_vect) //interrupçoes e 0 a 7
  {
  PORTB = ~PORTB;
  }*/

ISR(PCINT1_vect) //interrupçoes e 8 a 14
  {
  PORTB = ~PORTB;//neste exemplo vamos usar a interrupção no pino C0(int8)
  }
/*
ISR(PCINT2_vect) //interrupçoes e 16 a 23
  {
  PORTB = ~PORTB;
  }*/

/////////////////////////////////////////////////Funções usadas/////////////////////////////////////////////
void inicializa_interrupcoes(void)
{

  // PCICR = 0X01;//habilita interrupções de 0 a 7 
    PCICR = 0X02;//habilita interrupções de 8 a 14 //no exemplo vou usar  a interrup~ção 8
//   PCICR = 0X04;//habilita interrupções de 16 a 23 ,depende do modelo do microcontrolador

//   pode ainda fazer conbinaçõe pra usar todas as interrupçoes simultâneas

    //PCMSK0 = 0X00//aqui coloca qual pino vai gerar a interrupçoes,pode se usar mais de um.  
      PCMSK1 = 0X01;//selecionei somente o pino de interrupção 8 (PC0)
    //PCMSK2 = 0X00//aqui coloca qual pino vai gerar a interrupçoes,pode se usar mais de um. 
   sei(); //habilita interrupções
}

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

 contribua com o blog postando seus exemplos aqui também

Usando o watchdog do pic 16F877A

       Neste exemplo vou demostrar como usar o watchdog do pic, você vai precisar montar o seguinte circuito para testes:

      Note que se você manter o botão pressionado o watchdog não estoura mas se ficar com o botão livre ele irá reiniciar o pic a aproximadamente  2,3 segundos.Veja o código-fonte: 

///////////////////////////////////////////////////////////////////////////////
//projeto : usando o watchdog do pic
//autor : aguivone
//data : 09/07/2012
//versão: 1
//////////////////////////////////////////////////////////////////////////////

#include <16F877A.h>
#fuses XT,WDT,NOPROTECT,NOLVP // deve se habilitar aqui o watchdog(WDT)
#use delay(clock=4M)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)

void main()
{ 
    setup_wdt(WDT_2304MS);//programa pra estourar a cada 2,3 segundos
    printf("Iniciando teste de watch dog! \r\n");
    for(;;)
    {
      delay_ms(1800);
      if(INPUT(PIN_B0))
        {
          RESTART_WDT();// reinicia contagem,é mais usual 
          //#fuses NOWDT   se usar esta linha desliga watchdog        
          printf("Não estourou ainda! \r\n");
        }
        else
        {
         printf("Vai estourar em breve! \r\n");
        } 
    }
}

/*valores possiveis:

 WDT_18MS 
 WDT_36MS 
 WDT_72MS 
 WDT_144MS 
 WDT_288MS 
 WDT_576MS 
 WDT_1152MS 
 WDT_2304MS 
*/

contribua com o blog mande seus exemplos também!

ATMEGA328 gerando DTMF !

            A forma mais simples de gerar tom DTMF é por meio de CIS que fazem isso(exemplo: MV5089, EF71189, LC7365, MT8880, TP5088) aqui vou demonstrar como usar o chip da holtek HT9200A este chip é de fácil montagem visto que necessita de poucos componentes externos(dois capacitores e um crital),observado a figura abaixo que foi retirada do datasheet do fabricante é fácil perceber como é simples  sua utilização:

            Para comunicar é preciso envia um pacote de pulsos(clock) e então colocar os dados de forma serial , lembrando que o pino de habilitação do chip "CE" deve ser colocado em nível baixo para comuinicar   veja a figura:

            Bom então vamos ao código fonte:

/*
 *                                                 usando gerador de DTMF HT9200
 *   Version    : 1.0
 *   microcontrolador : AVR ATMega328
 *   descrição  : exemplo usando o HT9200, neste exemplo gera tom de 0 a 9 ao iniciar e depois o programa para.
 *   criado: 07/07/2012 
 *   autor: aguivone moretti fogia
 */
//sempre deixar as otimizações em 01 pra não ter surpresas em teu codigo

#define F_CPU 16000000  // 16 MHz
#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>
#include <string.h>

#define alterna_pino(x,y) x ^= _BV(y)   
#define liga_pino(x,y) x |= _BV(y)
#define desliga_pino(x,y) x &= ~(_BV(y))


 //SERIAL DTMF

 #define DTMF_DADOS PD2 //gera sinal de dados
 #define DTMF_CLOCK PD3 // gera sinal de clock
 #define DTMF_HABILITA PD4//habilita chip HT9200



//////////////////////////////////////////////////////////////////////////////////////////////////////////
//DTMF

void DTMF_envia(int DT)
{
      int X=1;
      desliga_pino(PORTD,DTMF_HABILITA);//habilita chip
      _delay_ms(10);//espera oscilador do chip estabilizar
      while(X > 0)
      {
          if((DT & X) > 0)
            {// igual a 1
             liga_pino(PORTD,DTMF_DADOS);//nivel um            
            }
            else
            {///igual a zero
            desliga_pino(PORTD,DTMF_DADOS);//nivel zero
            }
            X=X*2;//o mesmo que rotacionar
            _delay_ms(5);//espera estabilizar pinos
            desliga_pino(PORTD,DTMF_CLOCK);//habilita leitura de dados 
            _delay_ms(10);//espera ler
            liga_pino(PORTD,DTMF_CLOCK);//mantem clock en nivel alto

      }
      desliga_pino(PORTD,DTMF_DADOS);//sem dados
      

}
  
//////////////////////////////////////////////função principal///////////////////////////////////////////
int main(void)
{
           DDRD = 0XFE;  //inicializa portD,somente D0 é entrada
           DDRC = 0XFF;  //inicializa portD,somente D0 é entrada
          //////////////////////////

          liga_pino(PORTD,DTMF_HABILITA);//desabilita chip
          liga_pino(PORTD,DTMF_CLOCK);//mantem clock en nivel alto
          desliga_pino(PORTD,DTMF_DADOS);//sem dados

          for(;;)
            { 
                  DTMF_envia(10);//o zero é 10 em DTMF
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(1);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(2);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(3);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(4);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(5);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(6);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(7);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(8);
                  _delay_ms(500);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)

                  DTMF_envia(9);
                  _delay_ms(2000);//tempo para reconhecer o dtmf(simula aperta da tecla do telefone)
                    DTMF_envia(31);//Stop bit//manda para o som dtmf
                  liga_pino(PORTD,DTMF_HABILITA);//desabilita chip    
          
                  _delay_ms(2000);                        
            }
                 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

até a próxima pessoal!