[Ayuda] Cómo encender 3 LED's sin usar delay?

[NicaUnlock]

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. }

[planeta9999]

 
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. //***********************************

[NicaUnlock]

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 

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

Mil gracias por todo!!!

[planeta9999]

 
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. //***********************************

[NicaUnlock]

  Mil gracias nuevamente!! Me iré a estudiar los timers y llas interrupciónes!! Le puse RESUELTO al tema.

[Picuino]

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. }