Control Multiple LEDs With Different Delays with Arduino

En este tutorial, aprenderás información esencial sobre un diodo emisor de luz (LED) y cómo controlar varios LEDs con Arduino.

Utilizando una placa Arduino Uno, aprenderás a implementar un proyecto que controle múltiples LEDs con diferentes retardos.

Required Parts

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.

¿Qué es un diodo emisor de luz (LED)?

Un diodo emisor de luz (LED) es un pequeño dispositivo semiconductor, que puede emitir luz cuando una corriente eléctrica fluye a través de él. 

Cuando la corriente pasa por un LED, los electrones del semiconductor se recombinan con un electrón-hueco y liberan energía en forma de fotones.

Los LEDs permiten que la corriente fluya hacia adelante y bloquean la corriente en la dirección inversa.

Los LED se utilizan en muchas aplicaciones diferentes, como la retroiluminación de televisores, la iluminación de automóviles y la retroiluminación de teléfonos inteligentes.

Cómo controlar varias luces LED

Un Arduino puede controlar teóricamente tantos LEDs como necesites para tu diseño, sólo limitado por la corriente de alimentación disponible.

Sin embargo, si quieres controlar más LEDs que los pines digitales de tu placa Arduino, necesitas utilizar algún hardware adicional.

Estoy usando 3 LEDs con una placa Arduino Uno, como se muestra en el diagrama de cableado.

Diagrama de cableado

Paso 1: Conecta el ánodo (+) de los LEDs a un pin digital del Arduino mencionado en la tabla de abajo con una resistencia de 220 Ohm.

Conecte los LEDs según la siguiente tabla.

LED	Pin de Arduino
VERDE	Clavija digital 11
YELLOW	Clavija digital 10
ROJO	Pin digital 9

Paso 2: Conecte el cátodo de todos los LEDs (-) a GND.

Código Arduino

El siguiente código de Arduino se utiliza para controlar los tres LEDs con diferentes retrasos.

#define Blink_LED_1 11
#define Blink_LED_2 10
#define Blink_LED_3 9

void setup()
{
  Serial.begin(9600);
  pinMode(Blink_LED_1, OUTPUT);
  pinMode(Blink_LED_2, OUTPUT);
  pinMode(Blink_LED_3, OUTPUT);
}

void loop()
{
  digitalWrite(Blink_LED_1, HIGH);
  digitalWrite(Blink_LED_2, LOW);
  digitalWrite(Blink_LED_3, LOW);
  Serial.println("LED_1 ON");
  delay(3000);

  digitalWrite(Blink_LED_1, LOW);
  digitalWrite(Blink_LED_2, HIGH);
  digitalWrite(Blink_LED_3, LOW);
  Serial.println("LED_2 ON");
  delay(2000);

  digitalWrite(Blink_LED_1, LOW);
  digitalWrite(Blink_LED_2, LOW);
  digitalWrite(Blink_LED_3, HIGH);
  Serial.println("LED_3 ON");
  delay(1000);
}

Cómo funciona el código

Paso 1: Primero, defina el Pin digital para los LEDs según el diagrama de cableado.

#define Parpadeo_LED_1 11
#define Parpadeo_LED_2 10
#define Parpadeo_LED_3 9

Paso 2:

void setup()
{
  Serial.begin(9600);
  pinMode(Blink_LED_1, OUTPUT);
  pinMode(Blink_LED_2, OUTPUT);
  pinMode(Blink_LED_3, OUTPUT);
}

En la función void setup(), los LEDs se establecen como modo OUTPUT usando la función pinMode();. Inicializa la comunicación serial usando la función Serial.begin().

Paso 3: En la función void loop(), parpadea los LEDs, y el resultado se muestra en el terminal serie como se indica en la tabla.

Blink_LED_1	Blink_LED_2	Blink_LED_3	Duración	Mensaje de la terminal de serie
EN	OFF	OFF	3 segundos	LED_1 ON
OFF	EN	OFF	2 segundos	LED_2 ON
OFF	OFF	EN	1 segundo	LED_3 ON

Salida en el terminal de serie

Uso de la función millis () para controlar varios LEDs

Usando la función millis(), puedes establecer el retardo requerido. El siguiente código le ayudará a entender cómo utilizar millis() para controlar múltiples LEDs.

Código Arduino

Este código genera los diferentes retardos utilizando la función millis() para controlar los múltiples LEDs a diferentes ritmos.

// Which pins are connected to which LED
#define Blink_LED_1 11
#define Blink_LED_2 10
#define Blink_LED_3 9

// Assign flags for status of LEDs
volatile int blink_LED_1_flag = 0;
volatile int blink_LED_2_flag = 0;
volatile int blink_LED_3_flag = 0;

//Assign delays intervals for different LEDs
const unsigned long Blink_LED_1_interval = 1000;
const unsigned long Blink_LED_2_interval = 2000;
const unsigned long Blink_LED_3_interval = 3000;

// Declaring the variables holding the timer values for each LED.
unsigned long Blink_LED_1_timer = 0;
unsigned long Blink_LED_2_timer = 0;
unsigned long Blink_LED_3_timer = 0;

// Setting 3 digital pins direction as output
void setup() {
  Serial.begin(9600);
  pinMode(Blink_LED_1, OUTPUT);
  pinMode(Blink_LED_2, OUTPUT);
  pinMode(Blink_LED_3, OUTPUT);
}

void toggle_LED1() {
  if (blink_LED_1_flag == 0) {
    digitalWrite(Blink_LED_1, HIGH);
    blink_LED_1_flag = 1;
  } else {
    digitalWrite(Blink_LED_1, LOW);
    blink_LED_1_flag = 0;
  }
  Serial.println("LED_1 Toggle");
  Blink_LED_1_timer = millis();  // stores current value of millis()
}

void toggle_LED2() {
  if (blink_LED_2_flag == 0) {
    digitalWrite(Blink_LED_2, HIGH);
    blink_LED_2_flag = 1;
  } else {
    digitalWrite(Blink_LED_2, LOW);
    blink_LED_2_flag = 0;
  }
  Serial.println("LED_2 Toggle");
  Blink_LED_2_timer = millis();  // stores current value of millis()
}

void toggle_LED3() {
  if (blink_LED_3_flag == 0) {
    digitalWrite(Blink_LED_3, HIGH);
    blink_LED_3_flag = 1;
  } else {
    digitalWrite(Blink_LED_3, LOW);
    blink_LED_3_flag = 0;
  }
  Serial.println("LED_3 Toggle");
  Blink_LED_3_timer = millis();  // stores current value of millis()
}

void loop() {
  if ((millis() - Blink_LED_1_timer) >= Blink_LED_1_interval) {
    toggle_LED1();
  }
  if ((millis() - Blink_LED_2_timer) >= Blink_LED_2_interval) {
    toggle_LED2();
  }
  if ((millis() - Blink_LED_3_timer) >= Blink_LED_3_interval) {
    toggle_LED3();
  }
}

Cómo funciona el código

En este código, usando la función millis() el LED se encenderá y se apagará. Aquí no hay ninguna condición de bloqueo.

First, define the digital pins for LEDs as per the wiring diagram.

#define Parpadeo_LED_1 11
#define Parpadeo_LED_2 10
#define Parpadeo_LED_3 9

Next, I will use variables for different LEDs to store the current status LEDs.

// Assign flags for status of LEDs
volatile int blink_LED_1_flag = 0;
volatile int blink_LED_2_flag = 0;
volatile int blink_LED_3_flag = 0;

Then define the variable to store the value of different delays for LEDs.

const unsigned long Blink_LED_1_interval = 1000;
const unsigned long Blink_LED_2_interval = 2000;
const unsigned long Blink_LED_3_interval = 3000;

Followed by declaring the variables holding the timer values for each LED, initializing with zero.

unsigned long Blink_LED_1_timer=0;
unsigned long Blink_LED_2_timer=0;
unsigned long Blink_LED_3_timer=0;

In the void setup() function, LEDs are set as an OUTPUT mode using pinMode() function.

También he inicializado el monitor serie con una velocidad de 9600 baudios.

La función millis() de Arduino devuelve el número de milisegundos que el programa ha comenzado a ejecutar.

Aquí, asigna los valores de millis (); en la variable del temporizador.

void setup ()
{
  Serial.begin(9600);
  pinMode(Blink_LED_1, OUTPUT);
  pinMode(Blink_LED_2, OUTPUT);
  pinMode(Blink_LED_3, OUTPUT);
}

Finally, I have used the toggle LED function to check the current status of the LED with the help of the flag variable.

Si la bandera es cero, encenderá el LED; de lo contrario, si la bandera es uno, apagará el LED.

Al final, el temporizador LED respectivo también se actualiza a la hora actual.

void toggle_LED1() {
  if (blink_LED_1_flag == 0) {
    digitalWrite(Blink_LED_1, HIGH);
    blink_LED_1_flag = 1;
  } else {
    digitalWrite(Blink_LED_1, LOW);
    blink_LED_1_flag = 0;
  }
  Serial.println("LED_1 Toggle");
  Blink_LED_1_timer = millis();  // stores current value of millis()
}

void toggle_LED2() {
  if (blink_LED_2_flag == 0) {
    digitalWrite(Blink_LED_2, HIGH);
    blink_LED_2_flag = 1;
  } else {
    digitalWrite(Blink_LED_2, LOW);
    blink_LED_2_flag = 0;
  }
  Serial.println("LED_2 Toggle");
  Blink_LED_2_timer = millis();  // stores current value of millis()
}

void toggle_LED3() {
  if (blink_LED_3_flag == 0) {
    digitalWrite(Blink_LED_3, HIGH);
    blink_LED_3_flag = 1;
  } else {
    digitalWrite(Blink_LED_3, LOW);
    blink_LED_3_flag = 0;
  }
  Serial.println("LED_3 Toggle");
  Blink_LED_3_timer = millis();  // stores current value of millis()
}

In void loop(), The LED will toggle when the condition is true.

Aquí, la función millis(); almacena la hora actual.

La variable Blink_LED_2_timer se guarda la última vez que parpadeó el LED2.

Estoy utilizando la variable de tiempo Blink_LED_2_interval , un retraso predefinido para el LED2.

No hay condiciones de bloqueo. Muchas veces este código se ejecutará en un segundo. Los LEDs cambiarán según las variables de intervalo de tiempo.

void loop () {
  if ( (millis () - Blink_LED_1_timer) >= Blink_LED_1_interval)
    toggle_LED1 ();

  if ( (millis () - Blink_LED_2_timer) >= Blink_LED_2_interval)
    toggle_LED2 ();

  if ( (millis () - Blink_LED_3_timer) >= Blink_LED_3_interval)
    toggle_LED3 ();
}

Salida en el monitor de serie

¿Cómo se hace parpadear dos LEDs a diferente velocidad?

Puede hacer parpadear dos LEDs a diferentes velocidades utilizando la función de retardo o millis(). Puede establecer diferentes retardos para ambos LEDs.

Por ejemplo, para el LED1, puedes utilizar delay(1000), y para el LED2, delay(2000).

Así, con diferentes retardos, ambos LEDs parpadearán a diferente velocidad. 

Conclusión

This article shows you how to control 3 LEDs with different delay functions and without delays. You will have noticed that it is actually quite complex to blink LEDs independently.

However, instead of writing your own code, you could also use existing libraries such as ezOutput, that simplify this task. For more details have a look at the our tutorial: Blink LEDs with different Frequencies.

Si tienes alguna duda o sugerencia o crees que faltan cosas en este tutorial, deja un comentario abajo.