[Solucionado] ¡Error!, mi interrupción ocurre solo una vez.

[Usuario]

Un cordial saludo a todos.

Hace algunas semanas inicie con Arduino y tengo algunas dudas con respecto a las interrupciones.

Estoy escribiendo un código para poder aumentar o disminuir la frecuencia que maneja la función tone() (trabajo sobre un Arduino UNO).

He dispuesto del PIN_2 y del PIN_3 para disminuir y aumentar la frecuencia respectivamente.

Como el rango de frecuencias de la función tone(), varia de 31Hz a 65535Hz; he usado los pines del 4 al 7, para realizar aumentos por 10, 100, 1000 y 10000.

He usado en la función setup(), las siguientes lineas para definir las interrupciones de incremento y decremento.

attachInterrupt(digitalPinToInterrupt(_I_PIN_2_IN_), _FI_Decremento_, RISING);
attachInterrupt(digitalPinToInterrupt(_I_PIN_3_IN_), _FI_Aumento_, RISING);

Cuando ocurre alguna de las interrupciones, pregunto (con digitalRead) si algún pin tiene voltaje y asi puedo aumentar la frecuencia en la escala correspondiente.

He dispuesto de un LCD 2x16 para mostrar la frecuencia en ese momento.

El código que tengo hasta el momento es el siguiente...

Código: C

1. #include <LiquidCrystal.h>
2.  
3. int _I_PIN_2_IN_ = 2;                   // PIN_2 entrada [Interrupción decremento]
4. int _I_PIN_3_IN_ = 3;                   // PIN_3 entrada [Interrupción aumento]
5.  
6. int I_PIN_4_IN = 4;                     // PIN_4 entrada [Aumento     x10]
7. int I_PIN_5_IN = 5;                     // PIN_5 entrada [Aumento    x100]
8. int I_PIN_6_IN = 6;                     // PIN_6 entrada [Aumento  x1 000]
9. int I_PIN_7_IN = 7;                     // PIN_7 entrada [Aumento x10 000]
10.  
11. int I_PIN_10_OUT = 10;                  // PIN_10 salida [Pulso]
12.  
13. unsigned long UL_Tiempo_millis = 0;
14. unsigned long UL_Tiempo_ms = 10000.0;   // 600000 EQU 10min
15. float F_Frecuencia = 31.0;              // Min 31Hz - Max 65535Hz
16.  
17. int I_Aumento = 1;
18. int I_Decremento = 1;
19.  
20. unsigned int UI_Frecuencia_minima = 31;
21. unsigned int UI_Frecuencia_maxima = 65535;
22.  
23. bool B_Acceso = false;
24.  
25. const int RS=1, E=0, D4=13, D5=12, D6=11, D7=9;
26. LiquidCrystal lcd(RS, E, D4, D5, D6, D7);
27.  
28.  
29. void setup(void) {
30.   // Por defecto las I/O digitales están configuradas como INPUT
31.   // put your setup code here, to run once:
32.  
33.   pinMode(_I_PIN_2_IN_, INPUT);         // Pin 2, entrada [Interrupción decremento]
34.   pinMode(_I_PIN_3_IN_, INPUT);         // Pin 3, entrada [Interrupción aumento]
35.  
36.   pinMode(I_PIN_4_IN, INPUT);           // Pin 4, entrada [Aumento     x10]
37.   pinMode(I_PIN_5_IN, INPUT);           // Pin 5, entrada [Aumento    x100]
38.   pinMode(I_PIN_6_IN, INPUT);           // Pin 6, entrada [Aumento  x1 000]
39.   pinMode(I_PIN_7_IN, INPUT);           // Pin 7, entrada [Aumento x10 000]
40.  
41.   pinMode(I_PIN_10_OUT, OUTPUT);        // Pin 10, salida [Pulso]
42.  
43.   // Habilita interrupcion
44.   // MODO: Activa la interrupcion...
45.   //       [LOW]     Siempre que el pin esté bajo.
46.   //       [CHANGE]  Cada vez que el pin cambia de valor.
47.   //       [RISING]  Cuando el pasador va de bajo a alto.
48.   //       [FALLING] Cuando el pasador va de alto a bajo.
49.   //    ARDUINO DUE permite también...
50.   //       [HIGH]    Siempre que el pin esté alto.
51.   attachInterrupt(digitalPinToInterrupt(_I_PIN_2_IN_), _FI_Decremento_, RISING);   // attachInterrupt(digitalPinToInterrupt(PIN_que_realizara_la_interrupcion), Funcion_interrupcion, Modo)
52.   attachInterrupt(digitalPinToInterrupt(_I_PIN_3_IN_), _FI_Aumento_, RISING);
53.  
54.   lcd.begin(16, 2);
55.   lcd.clear();
56.   // Print a message to the LCD.
57.   lcd.setCursor(0, 0);
58.   lcd.print("[ON] Frecuencia");
59.  
60.   lcd.setCursor(0, 1);
61.   lcd.print(F_Frecuencia);
62. }
63.  
64.  
65. void _FI_Aumento_(void) {
66.  
67.   if(digitalRead(I_PIN_4_IN)){     // Si PIN_4 posee voltaje [Aumento     +10]
68.     B_Acceso = true;
69.     F_Frecuencia += 10.0;
70.   }
71.  
72.   if(digitalRead(I_PIN_5_IN)){     // Si PIN_5 posee voltaje [Aumento    +100]
73.     B_Acceso = true;
74.     F_Frecuencia += 100;
75.   }
76.  
77.   if(digitalRead(I_PIN_6_IN)){     // Si PIN_6 posee voltaje [Aumento   +1000]
78.     B_Acceso = true;
79.     F_Frecuencia += 1000;
80.   }
81.  
82.   if(digitalRead(I_PIN_7_IN)){     // Si PIN_7 posee voltaje [Aumento +10 000]
83.     B_Acceso = true;
84.     F_Frecuencia += 10000;
85.   }
86.  
87.   if(B_Acceso == false){
88.     F_Frecuencia += I_Aumento;
89.   } else {
90.     B_Acceso = false;
91.   }
92.  
93.   if(F_Frecuencia > 65535.0) {
94.     F_Frecuencia = UI_Frecuencia_minima;
95.   }
96.  
97.   //lcd.clear();
98.   lcd.setCursor(0, 1);
99.   lcd.print("                ");
100.   lcd.setCursor(0, 1);
101.   lcd.print(F_Frecuencia);
102.  
103.   UL_Tiempo_ms += UL_Tiempo_millis;
104. }
105.  
106.  
107. void _FI_Decremento_(void) {
108.  
109.   if(digitalRead(I_PIN_4_IN)){     // Si PIN_4 posee voltaje [Aumento     +10]
110.     B_Acceso = true;
111.     F_Frecuencia = F_Frecuencia-10.0;
112.   }
113.  
114.   if(digitalRead(I_PIN_5_IN)){     // Si PIN_5 posee voltaje [Aumento    +100]
115.     B_Acceso = true;
116.     F_Frecuencia -= 100;
117.   }
118.  
119.   if(digitalRead(I_PIN_6_IN)){     // Si PIN_6 posee voltaje [Aumento   +1000]
120.     B_Acceso = true;
121.     F_Frecuencia -= 1000;
122.   }
123.  
124.   if(digitalRead(I_PIN_7_IN)){     // Si PIN_7 posee voltaje [Aumento +10 000]
125.     B_Acceso = true;
126.     F_Frecuencia -= 10000;
127.   }
128.  
129.   if(B_Acceso == false){
130.     F_Frecuencia -= I_Decremento;
131.   } else {
132.     B_Acceso = false;
133.   }
134.  
135.   if(F_Frecuencia < 31.0) {
136.     F_Frecuencia = UI_Frecuencia_maxima;
137.   }
138.  
139.   //lcd.clear();
140.   lcd.setCursor(0, 1);
141.   lcd.print("                ");
142.   lcd.setCursor(0, 1);
143.   lcd.print(F_Frecuencia);
144.  
145.   UL_Tiempo_ms += UL_Tiempo_millis;
146. }
147.  
148.  
149.  
150. void loop(void) {
151.  
152.   UL_Tiempo_millis = millis();
153.  
154.   if(UL_Tiempo_millis <= UL_Tiempo_ms){
155.    
156.     tone(I_PIN_10_OUT, F_Frecuencia);
157.  
158.   } else {
159.    
160.     noTone(I_PIN_10_OUT);
161.    
162.     lcd.clear();
163.     lcd.setCursor(0, 0);
164.     lcd.print("[OFF] Please...");
165.     lcd.setCursor(0, 1);
166.     lcd.print("   disconnect.");
167.    
168.     delay(10000);
169.    
170.   }
171.  
172. }

Hace muy poco tiempo inicie con Arduino, y me pregunto... ¿porque las interrupciones solo ocurren una vez? (Al menos en este caso.)

Lo he simulado en proteus, y puedo aumentar la frecuencia solo una vez; puedo disminuirla, pero solo una vez. Después de la primera vez ya sea aumentando o disminuyendo las interrupciones "dejan de funcionar". No logro saber porque, he consultado pero no encuentro algo como lo que me ocurre.

Desconozco si estoy cometiendo algún error en el código o en el montaje.

Les dejo la imagen del montaje que realice ( https://ibb.co/itHcK5 ).


Agradecería sus comentarios al respecto. Muchas gracias.

[Sispic]

quizas asi .

 if(digitalRead(I_PIN_4_IN)){     // Si PIN_4 posee voltaje [Aumento     +10]
    B_Acceso = true;
    F_Frecuencia =  F_Frecuencia + 10.0 ;
  }

aunque creo es lo mismo

[Usuario]

Gracias Sispic por tu respuesta, la he modificado tal como sugieres. Pero el error continua.

También he cambiado las variables que se usan en la interrupción por volatile. Extraje las comparaciones de la función de interrupción, para hacer la interrupción mas liviana (corta y rápida).

Código: C

1. #include <LiquidCrystal.h>
2.  
3. const byte _I_PIN_2_IN_ = 2;                     // PIN_2 entrada [Interrupción decremento]
4. const byte _I_PIN_3_IN_ = 3;                     // PIN_3 entrada [Interrupción aumento]
5.  
6. const byte I_PIN_4_IN   = 4;                       // PIN_4 entrada [Aumento     x10]
7. const byte I_PIN_5_IN   = 5;                       // PIN_5 entrada [Aumento    x100]
8. const byte I_PIN_6_IN   = 6;                       // PIN_6 entrada [Aumento  x1 000]
9. const byte I_PIN_7_IN   = 7;                       // PIN_7 entrada [Aumento x10 000]
10.  
11. const byte I_PIN_10_OUT = 10;                    // PIN_10 salida [Pulso]
12.  
13.  
14. unsigned long UL_Tiempo_millis  = 0;
15. unsigned long UL_Tiempo_ms      = 10000.0;   // 600000 EQU 10min
16. float F_Frecuencia              = 31.0;              // Min 31Hz - Max 65535Hz
17.  
18.  
19. int I_Aumento     = 1;
20. int I_Decremento  = 1;
21.  
22. const unsigned int UI_Frecuencia_minima = 31;
23. const unsigned int UI_Frecuencia_maxima = 65535;
24.  
25.  
26. bool B_Acceso               = false;
27. volatile bool B_Decremento  = false;
28. volatile bool B_Incremento  = false;
29. volatile bool flagLCD       = false;
30.  
31.  
32. const int RS=1, E=0, D4=13, D5=12, D6=11, D7=9;
33. LiquidCrystal lcd(RS, E, D4, D5, D6, D7);
34.  
35.  
36.  
37.  
38. void setup(void) {
39.   // Por defecto las I/O digitales están configuradas como INPUT
40.   // put your setup code here, to run once:
41.  
42.   pinMode(_I_PIN_2_IN_, INPUT);         // Pin 2, entrada [Interrupción decremento]
43.   pinMode(_I_PIN_3_IN_, INPUT);         // Pin 3, entrada [Interrupción aumento]
44.  
45.   pinMode(I_PIN_4_IN, INPUT);           // Pin 4, entrada [Aumento     x10]
46.   pinMode(I_PIN_5_IN, INPUT);           // Pin 5, entrada [Aumento    x100]
47.   pinMode(I_PIN_6_IN, INPUT);           // Pin 6, entrada [Aumento  x1 000]
48.   pinMode(I_PIN_7_IN, INPUT);           // Pin 7, entrada [Aumento x10 000]
49.  
50.   pinMode(I_PIN_10_OUT, OUTPUT);        // Pin 10, salida [Pulso]
51.  
52.  
53.   lcd.begin(16, 2);
54.   lcd.clear();
55.   // Print a message to the LCD.
56.   lcd.setCursor(0, 0);
57.   lcd.print("[ON] Frecuencia");
58.  
59.   lcd.setCursor(0, 1);
60.   lcd.print(F_Frecuencia);
61.  
62.  
63.   // Habilita interrupcion
64.   // MODO: Activa la interrupcion...
65.   //       [LOW]     Siempre que el pin esté bajo.
66.   //       [CHANGE]  Cada vez que el pin cambia de valor.
67.   //       [RISING]  Cuando el pasador va de bajo a alto.
68.   //       [FALLING] Cuando el pasador va de alto a bajo.
69.   //    ARDUINO DUE permite también...
70.   //       [HIGH]    Siempre que el pin esté alto.
71.   attachInterrupt(digitalPinToInterrupt(_I_PIN_2_IN_), _Interrupcion_Decremento_, RISING);   // attachInterrupt(digitalPinToInterrupt(PIN_que_realizara_la_interrupcion), Funcion_interrupcion, Modo)
72.   attachInterrupt(digitalPinToInterrupt(_I_PIN_3_IN_), _Interrupcion_Incremento_, RISING);
73.  
74. }
75.  
76.  
77. void _Interrupcion_Incremento_(void) {
78.   flagLCD = true;
79.   B_Incremento = true;
80. }
81.  
82.  
83. void _Interrupcion_Decremento_(void) {
84.   flagLCD = true;
85.   B_Decremento = true;
86. }
87.  
88.  
89. void _F_Incremento_(void) {
90.  
91.   if(digitalRead(I_PIN_4_IN)){     // Si PIN_4 posee voltaje [Aumento     +10]
92.     B_Acceso = true;
93.     F_Frecuencia = F_Frecuencia + 10;
94.   }
95.  
96.   if(digitalRead(I_PIN_5_IN)){     // Si PIN_5 posee voltaje [Aumento    +100]
97.     B_Acceso = true;
98.     F_Frecuencia = F_Frecuencia + 100;
99.   }
100.  
101.   if(digitalRead(I_PIN_6_IN)){     // Si PIN_6 posee voltaje [Aumento   +1000]
102.     B_Acceso = true;
103.     F_Frecuencia = F_Frecuencia + 1000;
104.   }
105.  
106.   if(digitalRead(I_PIN_7_IN)){     // Si PIN_7 posee voltaje [Aumento +10 000]
107.     B_Acceso = true;
108.     F_Frecuencia = F_Frecuencia + 10000;
109.   }
110.  
111.   if(B_Acceso == false){
112.     F_Frecuencia = F_Frecuencia + I_Aumento;
113.   } else {
114.     B_Acceso = false;
115.   }
116.  
117.   if(F_Frecuencia > 65535.0) {
118.     F_Frecuencia = UI_Frecuencia_minima;
119.   }
120.  
121.   UL_Tiempo_ms = UL_Tiempo_ms + UL_Tiempo_millis;
122. }
123.  
124.  
125. void _F_Decremento_(void) {
126.  
127.   if(digitalRead(I_PIN_4_IN)){     // Si PIN_4 posee voltaje [Aumento     +10]
128.     B_Acceso = true;
129.     F_Frecuencia = F_Frecuencia - 10;
130.   }
131.  
132.   if(digitalRead(I_PIN_5_IN)){     // Si PIN_5 posee voltaje [Aumento    +100]
133.     B_Acceso = true;
134.     F_Frecuencia = F_Frecuencia - 100;
135.   }
136.  
137.   if(digitalRead(I_PIN_6_IN)){     // Si PIN_6 posee voltaje [Aumento   +1000]
138.     B_Acceso = true;
139.     F_Frecuencia = F_Frecuencia - 1000;
140.   }
141.  
142.   if(digitalRead(I_PIN_7_IN)){     // Si PIN_7 posee voltaje [Aumento +10 000]
143.     B_Acceso = true;
144.     F_Frecuencia = F_Frecuencia - 10000;
145.   }
146.  
147.   if(B_Acceso == false){
148.     F_Frecuencia = F_Frecuencia - I_Decremento;
149.   } else {
150.     B_Acceso = false;
151.   }
152.  
153.   if(F_Frecuencia < 31.0) {
154.     F_Frecuencia = UI_Frecuencia_maxima;
155.   }
156.  
157.   UL_Tiempo_ms = UL_Tiempo_ms + UL_Tiempo_millis;
158. }
159.  
160.  
161.  
162. void loop(void) {
163.  
164.   UL_Tiempo_millis = millis();
165.  
166.   if(flagLCD) {
167.    
168.       if(B_Decremento){
169.         _F_Decremento_();
170.         B_Decremento = false;
171.       } else if(B_Incremento){
172.         _F_Incremento_();
173.         B_Incremento = false;
174.       }
175.    
176.       lcd.setCursor(0, 1);
177.       lcd.print("                ");
178.       lcd.setCursor(0, 1);
179.       lcd.print(F_Frecuencia);
180.  
181.      
182.       flagLCD = false;
183.   }
184.  
185.   if (UL_Tiempo_millis <= UL_Tiempo_ms){
186.    
187.       tone(I_PIN_10_OUT, F_Frecuencia);
188.  
189.   } else {
190.    
191.       noTone(I_PIN_10_OUT);
192.      
193.       lcd.clear();
194.       lcd.setCursor(0, 0);
195.       lcd.print("[OFF] Please...");
196.       lcd.setCursor(0, 1);
197.       lcd.print("   disconnect.");
198.  
199.       delay(10000);
200.   }  
201. }

Incluso con el ejemplo más básico la interrupción solo funciona una vez...

Código: C

1. const int PIN_2_IN = 2;
2. const int PIN_10_OUT = 10;
3.  
4.  
5. volatile int Estado = HIGH;
6.  
7. void setup() {
8.   pinMode(PIN_2_IN, INPUT);
9.   pinMode(PIN_10_OUT, OUTPUT);
10.  
11.   attachInterrupt(digitalPinToInterrupt(PIN_2_IN), _ON_OFF_, RISING);
12. }
13.  
14.  
15. void loop() {
16.   digitalWrite(PIN_10_OUT, Estado);
17. }
18.  
19.  
20. void _ON_OFF_() {
21.   //Estado = !Estado;
22.  
23.   if(Estado==HIGH) {
24.     Estado = LOW;
25.   } else {
26.     Estado = HIGH;
27.   }
28.  
29. }

No se que pueda estar sucediendo... ahora tengo dudas sobre todo (hasta existenciales jajjaja ), no se si sea el IDE de arduino o el proteus. (Adjunto los archivos de la simulación de proteus) (El PIN_2 decrementa y el PIN_3 incrementa)

Estoy atento a vuestras sugerencias. Muchas gracias.

[Usuario]

Para descartar un error del IDE de Arduino o de proteus, he realizado el montaje en www.tinkercad.com.

He corrido el siguiente código (lo copie de aquí):

Código: C

1. const int PIN_2_IN = 2;
2. const int PIN_10_OUT = 10;
3.  
4.  
5. volatile int Estado = HIGH;
6.  
7. void setup() {
8.   pinMode(PIN_2_IN, INPUT);
9.   pinMode(PIN_10_OUT, OUTPUT);
10.  
11.   attachInterrupt(digitalPinToInterrupt(PIN_2_IN), _ON_OFF_, RISING);
12. }
13.  
14.  
15. void loop() {
16.   digitalWrite(PIN_10_OUT, Estado);
17. }
18.  
19.  
20. void _ON_OFF_() {
21.   //Estado = !Estado;
22.  
23.   if(Estado==HIGH) {
24.     Estado = LOW;
25.   } else {
26.     Estado = HIGH;
27.   }
28.  
29. }

El montaje a quedado así: Montaje
Anexo el archivo que se genera en TinkerCAD.

Después de esto ¡Tampoco funciona!

Ya no se que más he de probar...  ::smile_suicidandose::


Estoy atento a vuestros comentarios. Gracias.

[KILLERJC]

si se tuviera el ASM generado de ese ultimo ejemplo para ver donde es que falla seria bueno. Para ver si el codigo generado es el correcto.

[pablomanieri]

Hola. Como tienes montado el pulsador, la entrada nunca se pone a nivel bajo (si el pulsador esta presionado, la entrada se pone a 5v, pero si no está presionado queda flotante).
Creo que por ahí viene el problema.
Saludos

[Usuario]

Muchas gracias por comentar...

KILLERJC ya me pongo a la tarea del ensamblador...

pablomanieri este es el montaje que realice en proteus: Imágen_montaje

Me pregunto si es adecuado, si no lo es... ¿como debería ir el pulsador?

[Usuario]

He dispuesto una resistencia entre el PIN_2 y el pulsador, (dicha resistencia va a tierra) quedando así: Nuevo montaje

La interrupción funciona. No se si es adecuado el montaje o se puede mejorar... (Pido excusas ya que mi área no es la electrónica, eso se nota).

Si ese montaje es valido... la pregunta obligatoria ¿porque se necesita llevar a tierra esa linea?

Tengo entendido que al pulsar, la corriente entraría... el arduino toma esa corriente y produce la interrupción (parece que quedara guardada esa información en el pin).

[KILLERJC]

Si ese montaje es valido... la pregunta obligatoria ¿porque se necesita llevar a tierra esa linea?

Tengo entendido que al pulsar, la corriente entraría... el arduino toma esa corriente y produce la interrupción (parece que quedara guardada esa información en el pin).

Nunca se me ocurrio mirar el diagrama. Pense que era problema de software por eso te pedi el ensamblador. Respecto a tu pregunta.

Tu pin esta como entrada se encuentra en estado de alta impedancia, como una resistencia infinita o como si el cable del boton al pin no estuviera conectado a nada. Es decir no esta 0V ni esta a 5V, no tiene un valor definido. Por eso te dijeron que estaba flotando el pin ( cualquier tension que encuentre por ahi puede estar presente ). Al momento de presionar el boton, es el unico momento donde tenias definido el valor del pin. Que sabias que era 5V si o si.

Una salida es distinta, lo que hace el micro en una salida, es unir VCC con el pin ( un 1), o unir VSS con el pin (un 0 ). Pero como entrada ocurre lo antes comentado, no esta unido a nada. Por lo tanto uno debe usar resistencias para que tenga una tension definida. Algunos pines de algunos micros poseen internamente resistencias de pull-up o pull-down, para que cuando lo uses de entrada no tengas que agregarlas externamente como en este caso.

Una cosa mas el arduino lo que lee, es el voltaje. Es cierto que toma un poco de corriente pero como entrada si uno pensara que es como una resistencia casi infinita, se encuentra que la corriente es muy muy pequeña, imagino que del orden de los nA.

Si no me equivoco el ATmega328P tiene resistencias de PULL-UP, por lo que si activas la resistencia de pull-up,  lo pones como entrada y tu boton en ves de conectar a VCC lo conectas a GND, vas a poder lograr hacer todo, sin siquiera agregar resistencias.

Código: C

1. pinMode(PIN_2_IN, INPUT_PULLUP);

y conecta el boton, un terminal a 2, y el otro terminal a GND

De esa forma con el pull-up interno, la entrada esta a 5V, y cuando presionas el boton se va a 0V. La resistencia de pull-up es de entre 20K y 50K, por lo que la corriente es muy poca y no necesitas de otra resistencia externa.

[Usuario]

Perfecto. Muchas gracias.