Interrupção SPARKFUN Pro Micro 5V ATmega32U4

International Português
#1

Boa noite,

Estou tentando fazer a leitura de 4 displays de LEDS de 7 segmentos e enviar para um CLP uma tensão variavel de 0 a 5V. Estou utilizando uma placa da Sparkfun Pro Micro 5V com processador ATmega32U4, mas parece que ela não está funcionando.

Ao que parece as interrupções não estão funcionando, poderiam olhar se o meu código está correto?

int RXLED = 17;  // The RX LED has a defined Arduino pin

volatile int FlagLeDezena = 0;
volatile int FlagLeUnidade = 0;
volatile int FlagLeDecimo = 0;
volatile int FlagLeCentesimo = 0;

int Numero_Dezena, Numero_Unidade, Numero_Decimo, Numero_Centesimo = 0;
int Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G = 0;
int Numero = 0;

int PIN_a = 6;
int PIN_b = 7;
int PIN_c = 8;
int PIN_d = 9;
int PIN_e = 16;
int PIN_f = 14;
int PIN_g = 15;

int PIN_ANA_OUT = 10;

void setup()
{
 
 Numero = 0;
  
 pinMode(RXLED, OUTPUT);  // Set RX LED as an output
 
 pinMode(PIN_ANA_OUT, OUTPUT);
 
 attachInterrupt(2,LeDecimo,RISING);    //Pino 0
 attachInterrupt(3,LeUnidade,RISING);   //Pino 1
 attachInterrupt(1,LeDezena,RISING);    //Pino 2
 attachInterrupt(0,LeCentesimo,RISING); //Pino 3
 
 pinMode(PIN_a, INPUT);
 pinMode(PIN_b, INPUT);
 pinMode(PIN_c, INPUT);
 pinMode(PIN_d, INPUT);
 pinMode(PIN_e, INPUT);
 pinMode(PIN_f, INPUT);
 pinMode(PIN_g, INPUT);
}

void LeDezena()
{
    FlagLeDezena = 1;
}

void LeUnidade()
{
    FlagLeUnidade = 1; 
}

void LeDecimo()
{
     FlagLeDecimo = 1;
}
    
void LeCentesimo()
{
     FlagLeCentesimo = 1;
}

int SegToInt(int a, int b, int c, int d, int e, int f, int g)
{
  int Inteiro = 0;
  
  if((a==1) && (b==1) && (c==1) && (d==1) && (e==1) && (f==1) && (g==0))
    Inteiro = 0;
  else 
    if((a==0) && (b==1) && (c==1) && (d==0) && (e==0) && (f==0) && (g==0))
      Inteiro = 1;
    else
      if((a==1) && (b==1) && (c==0) && (d==1) && (e==1) && (f==0) && (g==1))
        Inteiro = 2;
      else 
        if((a==1) && (b==1) && (c==1) && (d==1) && (e==0) && (f==0) && (g==1))
          Inteiro = 3;
        else
          if((a==0) && (b==1) && (c==1) && (d==0) && (e==0) && (f==1) && (g==1))
            Inteiro = 4;
          else
            if((a==1) && (b==0) && (c==1) && (d==1) && (e==0) && (f==1) && (g==1))
              Inteiro = 5;
            else
              if((a==0) && (b==0) && (c==1) && (d==1) && (e==1) && (f==1) && (g==1))
                Inteiro = 6;
              else
                if((a==1) && (b==0) && (c==1) && (d==1) && (e==1) && (f==1) && (g==1))
                  Inteiro = 6;  
                else
                  if((a==1) && (b==1) && (c==1) && (d==0) && (e==0) && (f==0) && (g==0))
                    Inteiro = 7;
                  else
                    if((a==1) && (b==1) && (c==1) && (d==1) && (e==1) && (f==1) && (g==1))
                      Inteiro = 8;
                    else
                      if((a==1) && (b==1) && (c==1) && (d==0) && (e==0) && (f==1) && (g==1))
                        Inteiro = 9;
                      else
                        if((a==1) && (b==1) && (c==1) && (d==1) && (e==0) && (f==1) && (g==1))
                          Inteiro = 9;   
 
  return Inteiro;
}

void loop()
{
  
 //------------ FAZ A LEITURA DE QUAL NUMERO ESTA SENDO ESCRITO -----------//
 if((FlagLeDezena==1) || (FlagLeUnidade==1) || (FlagLeDecimo==1) || (FlagLeCentesimo==1))
 {      
    if(digitalRead(PIN_a)==HIGH)
      Seg_A = 1;
    else
      Seg_A = 0;
   
    if(digitalRead(PIN_b)==HIGH)
      Seg_B = 1;
    else
      Seg_B = 0;  
   
    if(digitalRead(PIN_c)==HIGH)
      Seg_C = 1;
    else
      Seg_C = 0;  
 
    if(digitalRead(PIN_d)==HIGH)
      Seg_D = 1;
    else
      Seg_D = 0;
 
    if(digitalRead(PIN_e)==HIGH)
      Seg_E = 1;
    else
      Seg_E = 0;
 
    if(digitalRead(PIN_f)==HIGH)
      Seg_F = 1;
    else
      Seg_F = 0;
 
    if(digitalRead(PIN_g)==HIGH)
      Seg_G = 1;
    else
      Seg_G = 0;
 
    //Faz a multiplexacao dos 4 canais de displays 7 seg
    if(FlagLeDezena==1)
    {
       Numero_Dezena = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);     
       FlagLeDezena = 0;
    }

    if(FlagLeUnidade==1)
    {
       Numero_Unidade = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);
       FlagLeUnidade = 0;
    }
       
    if(FlagLeDecimo==1)
    {
       Numero_Decimo = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);
       FlagLeDecimo = 0;
    }
       
    if(FlagLeCentesimo==1)
    {
       Numero_Centesimo = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);
       FlagLeCentesimo = 0;
    }  
 }   
 
 Numero = Numero_Dezena*1000 + Numero_Unidade*100 + Numero_Decimo*10 + Numero_Centesimo;  
 
 analogWrite(PIN_ANA_OUT, Numero/40);
 
 digitalWrite(RXLED, FlagLeDezena);   // set the LED on/off
 
 
}
#2

os comentarios estao errados... mas tambem pode ser o caso dos comentarios estarem correctos e ai esta uma fonte de problemas.

Como ligaste os inputs? Nao precisas dum pull-up?

Os pinos 0 e 1 nao serao os pinos onde estao o RX e TX??

Tambem nao tens um unico serial.print para te ajudar a fazer debug... como chegaste a conclusao que as interrupcoes nao funcionam?

#3

@Bubulindo,

Acredito que o problema não sejam os comentários, pois retirei todos os comentários e continua igual.

Os inputs eu ainda não liguei, estou simulando primeiro as interrupções. O que seria um "pull-up"?

Sim, os pinos 0 e 1 são os pinos RX e TX, mas como não tenho declarada nenhum uso de serial, acredito que automaticamente possa utilizar as interrupções, correto? Ou preciso colocar algum comando que desabilite a serial?

Não estou utilizando serial, justamente para não interferir nos pinos 0 e 1. Através do pino 10, estou medindo a tensão da saída analógica com um multímetro. Para acionar as interrupções estou pegando um pedaço de fio e dando "toques" nos pinos 0, 1, 2 e 3 fechando com o pino Vcc (5V).

Sei que as interrupções não estão funcionando pois utilizo a variavel "int" chamada "Numero" para simular, ou seja, quando aciono o pino 2 aciono a interrupção que seta a variável "FlagDezena=1", então a variavel "Numero" deveria receber 1000 e automaticamente gerar 0,5V na saida analógica do pino 10. Para zerar a saida analógica, bastaria dar um toque no pino 3, que executaria a interrupção que seta a variavel "FlagLeCentesimo=1" que executa a função correspondente e zera a variavel "Numero", logo a saida análogica deveria ir para zero.

O que parece é que o chip está "louco". Consegue ver se estou fazendo algo errado?

OBS: O código completo está na minha primeira mensagem

if(FlagLeDezena==1)
    {
       Numero_Dezena = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);     
       FlagLeDezena = 0;
       Numero = 1000;    //Somente para simular as interrupções
    }

    if(FlagLeUnidade==1)
    {
       Numero_Unidade = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);
       FlagLeUnidade = 0;
    }
       
    if(FlagLeDecimo==1)
    {
       Numero_Decimo = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);
       FlagLeDecimo = 0;
    }
       
    if(FlagLeCentesimo==1)
    {
       Numero_Centesimo = SegToInt(Seg_A, Seg_B, Seg_C, Seg_D, Seg_E, Seg_F, Seg_G);
       FlagLeCentesimo = 0;
       Numero = 0;
    }  
 }   
 
 analogWrite(PIN_ANA_OUT, Numero/40);
#4

Sim... Usar fios para simular botões.

Os pinos podem estar no sitio errado. E mais uma vez não usas a porta serie para fazer debug.

Pesquisaste por pull up na net? De momento não me é possivel dizer mais do que pull up e uma resistencia entre os 5V e o pino. Cerca de 1.5k chega normalmente.

#5