TODOPIC

Otros Microcontroladores / Dispositivos programables => Arduino => Mensaje iniciado por: NicaUnlock en 21 de Abril de 2018, 19:16:38

Título: [Ayuda] Cómo encender 3 LED's sin usar delay?
Publicado por: NicaUnlock en 21 de Abril de 2018, 19:16:38
Buenas tardes compañeros,lo que quiero en pocas palabras es encender 3 led's a diferentes tiempos por ej. LED1 = 300ms, LED2 = 500ms, LED3 = 800ms lo más que he logrado es lo que ven ahí abajo y veo que es muy largo el código no se como hacerlo de forma sencilla encontré un ejemplo en youtube pero utiliza muchas cosas que no entiendo aún. Si prueban el código los LED's encienden a diferentes tiempos pero no se cumplen los que quiero q les mencioné en la primer línea. :(

De antemano les agradezco mucho su ayuda como siempre!!

Código: C
  1. int       estado        = LOW;
  2. const int       LED1          = 3;
  3. const int       LED2          = 5;
  4. const int       LED3          = 6;
  5. const int       intervalo     = 300;
  6. const int       intervalo1    = 500;
  7. const int       intervalo2    = 800;
  8. unsigned long   guardaMillis  = 0;
  9. unsigned long   guardaMillis1 = 0;
  10. unsigned long   guardaMillis2 = 0;
  11.      
  12. void setup (){
  13.  
  14.      pinMode(LED1,OUTPUT);
  15.      pinMode(LED2,OUTPUT);
  16.      pinMode(LED3,OUTPUT);
  17. }
  18.  
  19. void loop () {
  20.  
  21. unsigned long actualMillis = millis();
  22.      
  23.     if  (actualMillis - guardaMillis >= intervalo)
  24.       {
  25.         guardaMillis = actualMillis;
  26.  
  27.      if(estado == LOW)
  28.      {
  29.         estado = HIGH;
  30.      }
  31.  
  32.      else
  33.      {
  34.         estado = LOW;
  35.      }
  36.  
  37.      digitalWrite (LED1,estado);
  38.     }
  39.  
  40.     if  (millis() - guardaMillis1 >= intervalo1)
  41.       {
  42.         guardaMillis1 = millis();
  43.  
  44.      if(estado == LOW)
  45.      {
  46.         estado = HIGH;
  47.      }
  48.  
  49.      else
  50.      {
  51.         estado = LOW;
  52.      }
  53.  
  54.      digitalWrite (LED2,estado);
  55.     }
  56.  
  57.     if  (millis() - guardaMillis2 >= intervalo2)
  58.       {
  59.         guardaMillis2 = millis();
  60.  
  61.      if(estado == LOW)
  62.      {
  63.         estado = HIGH;
  64.      }
  65.  
  66.      else
  67.      {
  68.         estado = LOW;
  69.      }
  70.  
  71.      digitalWrite (LED3,estado);
  72.     }
  73. }

Disculpen compañeros ya lo he logrado pero sigo con el descontento de que el código es muy grande, me gustaría saber como hacer eso mismo en algo mas pequeño. Mil gracias nuevamente!!!

Este es el código ya con los tiempos correctos:

Código: C
  1. int       estado        = LOW;
  2.       int       estado1       = LOW;
  3.       int       estado2       = LOW;
  4. const int       LED1          = 3;
  5. const int       LED2          = 5;
  6. const int       LED3          = 6;
  7. const int       intervalo     = 300;
  8. const int       intervalo1    = 500;
  9. const int       intervalo2    = 800;
  10. unsigned long   guardaMillis  = 0;
  11. unsigned long   guardaMillis1 = 0;
  12. unsigned long   guardaMillis2 = 0;
  13.      
  14. void setup (){
  15.  
  16.      pinMode(LED1,OUTPUT);
  17.      pinMode(LED2,OUTPUT);
  18.      pinMode(LED3,OUTPUT);
  19. }
  20.  
  21. void loop () {
  22.  
  23. unsigned long actualMillis = millis();
  24.      
  25.     if  (actualMillis - guardaMillis >= intervalo)
  26.       {
  27.         guardaMillis = actualMillis;
  28.  
  29.      if(estado == LOW)
  30.      {
  31.         estado = HIGH;
  32.      }
  33.  
  34.      else
  35.      {
  36.         estado = LOW;
  37.      }
  38.  
  39.      digitalWrite (LED1,estado);
  40.     }
  41.  
  42.     if  (millis() - guardaMillis1 >= intervalo1)
  43.       {
  44.         guardaMillis1 = millis();
  45.  
  46.      if(estado1 == LOW)
  47.      {
  48.         estado1 = HIGH;
  49.      }
  50.  
  51.      else
  52.      {
  53.         estado1 = LOW;
  54.      }
  55.  
  56.      digitalWrite (LED2,estado1);
  57.     }
  58.  
  59.     if  (millis() - guardaMillis2 >= intervalo2)
  60.       {
  61.         guardaMillis2 = millis();
  62.  
  63.      if(estado2 == LOW)
  64.      {
  65.         estado2 = HIGH;
  66.      }
  67.  
  68.      else
  69.      {
  70.         estado2 = LOW;
  71.      }
  72.  
  73.      digitalWrite (LED3,estado2);
  74.     }
  75. }

Título: Re:[Ayuda] Cómo encender 3 LED's sin usar delay?
Publicado por: planeta9999 en 21 de Abril de 2018, 20:14:20
 
En principio lo ideal es que uses timers con interrupciones, pero si te empeñas en hacerlo en plan artesanal con la función millis(), te comento tu error.

Crea tres variables de estado (estado1, estado2 y estado3), y asigna cada una a un led. Ahora estás usando la misma variable de estado para los tres led, por eso no te funcionan bien los tiempos de encendido/apagado de cada led.

Documenta tus programas para que sean más legibles o puede ser de pesadilla, sobre todo si retomas un fuente en un futuro próximo. Eso de escribir lineas de código sin un miserable comentario, sin agrupar y estructurar el fuente solo te traerá complicaciones y pérdidas de tiempo.

Puede quedar algo así.

Código: C
  1. //***************************************************
  2. //***************************************************
  3. //*** Intermitencia de 3 led  a intervalos   ********
  4. //*** de 300, 500 y 800ms    ************************
  5. //***************************************************
  6. //***************************************************  
  7. // Constantes
  8. const int       LED1          = 3;
  9. const int       LED2          = 5;
  10. const int       LED3          = 6;
  11. const int       intervalo1    = 300;
  12. const int       intervalo2    = 500;
  13. const int       intervalo3    = 800;
  14.  
  15. // Variables globales
  16. int  estado1  = LOW;
  17. int  estado2  = LOW;
  18. int  estado3  = LOW;
  19. unsigned long   guardaMillis1  = 0;
  20. unsigned long   guardaMillis2 = 0;
  21. unsigned long   guardaMillis3 = 0;
  22.      
  23. //********************************
  24. //*** Configuración   ************
  25. //********************************
  26. void setup (){
  27.  
  28.      pinMode(LED1,OUTPUT);
  29.      pinMode(LED2,OUTPUT);
  30.      pinMode(LED3,OUTPUT);
  31. }
  32.  
  33. //********************************
  34. //*** Programa principal   *******
  35. //********************************
  36. void loop ()
  37. {
  38.  
  39. // LED1, 300ms
  40.     if  (millis() - guardaMillis1 >= intervalo1)
  41.       {
  42.         guardaMillis1 = millis();
  43.         if(estado1 == LOW) estado1 = HIGH; else  estado1 = LOW;
  44.         digitalWrite (LED1, estado1);
  45.       }
  46.  
  47.  
  48. // LED2, 500ms
  49.     if  (millis() - guardaMillis2 >= intervalo2)
  50.       {
  51.         guardaMillis2 = millis();
  52.         if(estado2 == LOW) estado2 = HIGH; else  estado2 = LOW;
  53.         digitalWrite (LED2, estado2);
  54.       }
  55.  
  56.  
  57. // LED3, 800ms
  58.     if  (millis() - guardaMillis3 >= intervalo3)
  59.       {
  60.         guardaMillis3 = millis();
  61.         if(estado3 == LOW) estado3 = HIGH; else  estado3 = LOW;
  62.         digitalWrite (LED3, estado3);
  63.       }
  64.  
  65. }
  66. //***********************************
  67. //***********************************
  68. //***********************************
Título: Re:[Ayuda] Cómo encender 3 LED's sin usar delay?
Publicado por: NicaUnlock en 21 de Abril de 2018, 20:29:44
Muchas gracias por su respuesta! pues aún no llego a los timers e interrupciónes pero me acabas de dar un alegrón bueno ya te imaginás yo pensando que tendría que hacerlo siempre de forma artesanal  :oops:

Crees vos que se podría hacer eso mismo con una lógica distinta? Un código mas reducido?

Mil gracias por todo!!! ((:-))
Título: Re:[Ayuda] Cómo encender 3 LED's sin usar delay?
Publicado por: planeta9999 en 21 de Abril de 2018, 20:42:43
 
Ahí lo tienes más reducido, pero si te vas a los timers y las interrupciones, lo reducirás a la mínima expresión, que además es lo ideal para estas cosas.


Código: C
  1. //***************************************************
  2. //***************************************************
  3. //*** Intermitencia de 3 led  a intervalos   ********
  4. //*** de 300, 500 y 800ms    ************************
  5. //***************************************************
  6. //***************************************************  
  7.  
  8. int estado[3] = {0, 0, 0};
  9. int led[3] = {3, 5, 6};
  10. int intervalo[3] = {300, 500, 800};
  11. unsigned long guardamillis[3]={0, 0, 0};
  12.      
  13. //********************************
  14. //*** Configuración   ************
  15. //********************************
  16. void setup ()
  17. {
  18.      pinMode(LED1,OUTPUT);
  19.      pinMode(LED2,OUTPUT);
  20.      pinMode(LED3,OUTPUT);
  21. }
  22.  
  23. //********************************
  24. //*** Programa principal   *******
  25. //********************************
  26. void loop ()
  27. {
  28.  
  29. for (int i = 0; i < 3; i++)
  30.  {
  31.     if(millis() - guardaMillis[i] >= intervalo[i])
  32.       {
  33.         guardaMillis[i] = millis();
  34.         if(estado[i] == 0) estado[i] = 1; else  estado[i] = 0;
  35.         digitalWrite (led[i], estado[i]);
  36.       }
  37.   }
  38.  
  39. }
  40. //***********************************
  41. //***********************************
  42. //***********************************
Título: [RESUELTO].Re:[Ayuda] Cómo encender 3 LED's sin usar delay?
Publicado por: NicaUnlock en 21 de Abril de 2018, 20:47:20
 ((:-)) Mil gracias nuevamente!! Me iré a estudiar los timers y llas interrupciónes!! Le puse RESUELTO al tema. :)
Título: Re:[Ayuda] Cómo encender 3 LED's sin usar delay?
Publicado por: Picuino en 22 de Abril de 2018, 11:41:42
Con un RTOS también puedes hacer temporizaciones independientes de manera sencilla:

Librería RTOS: https://github.com/fabriceo/SCoop/tree/master/SCoop

Ejemplo:
Código: C
  1. #include <SCoop.h>
  2.  
  3. int led1 = 13;
  4. int led2 = 12;
  5. int led3 = 11;
  6.  
  7.  
  8. void setup() {
  9.   // Setup the 3 pins as OUTPUT
  10.   pinMode(led1, OUTPUT);
  11.   pinMode(led2, OUTPUT);
  12.   pinMode(led3, OUTPUT);
  13.  
  14.   // Start RTOS SCoop
  15.   mySCoop.start();
  16. }
  17.  
  18.  
  19. void loop() {
  20.    // main loop. Do anything
  21.    yield();
  22. }
  23.  
  24.  
  25. // Task 1: blink LED with 0.3 second delay
  26. defineTaskLoop(task1) {
  27.    digitalWrite(led1, HIGH);
  28.    sleep(300);
  29.    digitalWrite(led1, LOW);
  30.    sleep(300);
  31. }
  32.  
  33.  
  34. // Task 2: blink LED with 0.5 second delay
  35. defineTaskLoop(task2) {
  36.    digitalWrite(led2, HIGH);
  37.    sleep(500);
  38.    digitalWrite(led2, LOW);
  39.    sleep(500);
  40. }
  41.  
  42.  
  43. // Task 3: blink LED with 0.8 second delay
  44. defineTaskLoop(task3) {
  45.    digitalWrite(led3, HIGH);
  46.    sleep(800);
  47.    digitalWrite(led3, LOW);
  48.    sleep(800);
  49. }