martes, 12 de julio de 2022

El display de 7 segmentos I (IDE Arduino)

Se trata de un display de cuatro dígitos en el que, principalmente, podemos visualizar números y también algunas letras y símbolos. Cada uno de los dígitos está compuesto por 8 diodos LED, los 7 segmentos y el punto decimal. Estos diodos se encienden con un "0" y permanecen apagados cuando se les suministra un "1".

En la figura adjunta podemos apreciar el nombre de los segmentos, su orden y los códigos binarios de 7 segmentos correspondientes a algunos números y letras. 

   a b c d e f g p
2  0 0 1 0 0 1 1 0
8  0 0 0 0 0 0 0 0
L  1 1 1 0 0 0 1 0
A  0 0 0 1 0 0 0 0


Para encender el número "2". en el dígito más a la izquierda del shield multifunción, Arduino debe enviar dos códigos binarios, el de 7 segmentos del número "2" (00100101) y otro para indicar cual es el dígito que se enciende, en este caso, el situado a la izquierda (10000000). Estos códigos se envían en serie, un bit tras otro, a través del pin 8, utilizando la instrucción "siftOut" que se encarga de hacer todo el proceso. Además son necesarios dos pines más, el pin 4, (una especie de permiso que se activa cuando está en "0", tenemos que hacerlo nosotros) y el pin 7 (unos pulsos de reloj para indicar cuando son válidos cada uno de los bit); de este pin y de generar esos pulsos se encarga la propia instrucción "siftOut". En la imagen podemos ver este proceso:


En definitiva, el programa para visualizar el número 2 en el display de la izquierda quedaría de la siguiente manera:
/*
 * display2.ino
 * Visualiza el número 2 en el dígito más a la izquierda del display
 * de 7 segmentos.
 * Los leds del display se encienden con un cero y se apagan con un 1. 
 * El código del numero 2 sería: a b c d e f g p
 *                               0 0 1 0 0 1 0 1
 * Arduino envía los datos (DATA) al shield multifunción en serie, usando
 * el pin 7. A través del pin 8 manda unos pulsos de "reloj" (CLOCK)para 
 * indicar la validez de los datos presentes en el pin 7. Por último, el
 * pin 4 sirve de cerrojo (LATCH), para que el shield multifunción sepa
 * cuando empieza y termina la transmisión de datos.
 * Hay que enviar dos números: el primero se corresponde con el código
 * 7 segmentos que queremos visualizar, el segundo indica (con un 1) el
 * dígito que estará encendido.
 */

void setup (){
  pinMode(4,OUTPUT);     //LATCH, habilita recepción de datos
  pinMode(7,OUTPUT);     //DATA, para enviar los datos
  pinMode(8,OUTPUT);     //CLOK, indica cuando los datos son válidos
}
void loop(){
  digitalWrite(4,LOW);                   //Un 0 habilita la llegada de datos
  shiftOut(8, 7, LSBFIRST, B00100101);   //envía el código 7 segmentos
  shiftOut(8, 7, LSBFIRST, B10000000);   //envía el dígito que se enciende
  digitalWrite(4,HIGH);                  //Un 1 deshabilita la transmisión
}

Ahora vamos a mostrar el número "0134"; primero dígito a dígito y, posteriormente, con una pequeña modificación, los veremos los cuatro a la vez.

/*
 * display0134.ino
 * Vemos en el display los números 0, 1, 3 y 4, de uno en uno
 * a intervalos de 1 segundo. Cada número aparece en un dígito
 * diferente, el 0 en el más a la izquierda.
 * Para ver el número completo 0134 a la vez, tenemos que quitar
 * los retardos (delay) de 1 segundo. Se sigue encendiendo un solo
 * dígito, pero al no haber retardos y estar en un bucle que se
 * repite rapidísimamente nuestros ojos los ven todos encendidos.
 */

void setup (){
  pinMode(4,OUTPUT);     //LATCH
  pinMode(7,OUTPUT);     //DATA
  pinMode(8,OUTPUT);     //CLOCK
}

void loop(){
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B00000011);    //el 0
  shiftOut(8, 7, LSBFIRST, B10000000);    //en el dígito de la izquierda
  digitalWrite(4,HIGH);
  delay(1000);
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B10011111);    //el 1
  shiftOut(8, 7, LSBFIRST, B01000000);    //en el siguiente dígito
  digitalWrite(4,HIGH);
  delay(1000);
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B00001101);    //el 3
  shiftOut(8, 7, LSBFIRST, B00100000);    //en el siguiente dígito
  digitalWrite(4,HIGH);
  delay(1000);
  digitalWrite(4,LOW); 
  shiftOut(8, 7, LSBFIRST, B10011001);    //el 4
  shiftOut(8, 7, LSBFIRST, B00010000);    //en el último de la derecha
  digitalWrite(4,HIGH);
  delay(1000);                            //quitar todos los delay
                                          //para ver los cuatro a la vez
}

Ejercicios propuestos:

1.- Escribir un programa que haga aparecer en el display (en el dígito más a la derecha) los números del 0 al 5 a intervalos de un segundo.

2.- Mostrar en el display la palabra "HOLA".

3.- Hacer un programa que vaya encendiendo y apagando de uno en uno los segmentos exteriores del display, dándole la vuelta completa:






martes, 14 de junio de 2022

El potenciómetro (IDE Arduino)

La mayor parte de las magnitudes con las que hemos trabajado hasta ahora han sido magnitudes digitales o binarias; es decir, que sólo pueden tener dos estados: 0-1, encendido-apagado, presionado-liberado, cierto-falso. El potenciómetro multivuelta que incluye el Shield suministra, al pin A0 de Arduino, un voltaje comprendido entre 0 y 5 voltios, que podemos modificar girando su cursor y pasar por todos los valores posibles. Se trata de una magnitud analógica que será digitalizada por Arduino y transformada en un número entero entre 0 y 1023.

Para leer ese valor analógico usaremos la instrucción  analogRead(A0);

En el programa siguiente leemos el valor suministrado por el potenciómetro y lo mostramos en el Monitor Serie.

/*
 * potenciometro.ino
 * Este programa muestra en el Monitor Serie el valor leído en el pin A0
 * (el que está conectado al potenciómetro). La instrucción utilizada es
 * analogRead(A0);
 * El resultado será un número entero entre 0 y 1023, que se corresponde
 * con un voltaje entre 0 y 5 voltios.
 */

void setup() {
  pinMode(A0, INPUT);       //pin A0 como entrada
  Serial.begin(9600);
}

void loop() { 
  Serial.println(analogRead(A0));
  delay(500);
}

Ahora haremos que se encienda el Led D1 (pin 13) cuando el valor del potenciómetro esté comprendido entre 400y 450, quedando apagado en caso contrario.

/*
 * potenciometroLed.ino
 * Este programa enciende el LED D1 (pin 13) si el valor leido del
 * potenciómetro (pin A0) esté comprendido entre 400 y 450. En caso
 * contrario el LED permanecerá apagado.
 */

int valorPot;                     //variable para guardar el valor obtenido
                                  //en la lectura del potenciómetro
void setup() {
  pinMode(A0, INPUT);              //pin A0 como entrada
  pinMode(13, OUTPUT);             //pin 13 salida
  digitalWrite(13, HIGH);          //apagamos LED
  Serial.begin(9600);
}

void loop() { 
  valorPot = analogRead(A0);                    //leemos el pin A0
  if((valorPot > 400) && (valorPot < 450)) {    //si >400 y <450
    digitalWrite(13, LOW);                      //encendemos LED
  }else{                                        //en caso contrario
    digitalWrite(13, HIGH);                     //lo apagamos
  }
  Serial.println(valorPot);                     //motramos el valor leído
  delay(100);
}

Ejercicios propuestos:

1.- Realizar un programa que encienda el LED 4 cuando la lectura del potenciómetro sea mayor de 500 y, además, el LED 3 si supera 550.

2.- Ahora tenemos que encender los LEDs 3 y 4 si la lectura está comprendida entre 500 y 550. Además, añadimos los LEDs 1 y 2 entre 600 y 650 y, finalmente, hacemos sonar el zumbador si se superan los 700.










lunes, 6 de junio de 2022

Pulsadores (II). Variables (IDE Arduino)

En esta entrada vamos a hacer un programa que puede parecer sencillo, pero presenta algunas complicaciones. Se trata de cambiar (voltear) el estado de un LED cada vez que accionemos un pulsador; es decir, si estaba apagado se enciende y si estaba encendido se apaga.

Para cambiar o voltear el LED usaremos el operador lógico ! (lo contrario de...) y las instrucciones digitalWrite y digitalRead:

    digitalWrite(13, !digitalRead(13));            
   escribimos en el LED el estado contrario al que tenía

Vamos a ver un primer programa que no funciona correctamente, pero no ayudará a entender las dificultades del razonamiento lógico que tiene.

/*
 * pulsadorPulsadoFallido.ino
 * Al accionar el pulsador, si el LED estaba apagado se enciende y si
 * estaba encendido se apaga.
 * Para cambiar el LED utilizaremos el operador ! que viene a significar
 * lo contrario de ...
 * Tal como está hecho no funcionará correctamente, como se podrá
 * comprobar al cargarlo en nuestra placa Arduino, lo solucionaremos
 * en el siguiente programa.
 */

void setup() {
  pinMode(13, OUTPUT);      //pin 13 como salida
  pinMode(A1, INPUT);       //pin A1 como entrada
  digitalWrite(13, HIGH);   //Led D1 apagado
}

void loop() { 
  if((digitalRead(A1)==LOW)){             //si pulsador presionado
    digitalWrite(13, !digitalRead(13));   //volteamos el LED
  }                                       //Esto no funcionará, ya que,
  delay(50);                              //mientras lo tengamos presionado,
}                                         //el LED estará cambiando y no
                                          //sabremos como quedará al soltar

No nos vale únicamente con saber si el pulsador está presionado, tenemos que detectar el momento inicial en el que se presiona; es decir, el paso de liberado a presionado. Para ello, vamos a utilizar una variable, que no es más que un "lugar" donde podemos guardar cosas. A las variables hay que darles un nombre e indicar el tipo de datos que almacenan (números, letras, estados lógicos, etc.). En nuestro caso, se tratará de una variable de tipo booleano, capaz de guardar estados lógicos; es decir, cero o uno, alto o bajo, cierto o falso. Veamos una nueva versión del programa.

/*
 * pulsadorPulsado.ino
 * Al accionar el pulsador, si el LED estaba apagado se enciende y si
 * estaba encendido se apaga.
 * Vamos a crear una variable que pueda tomar los valores cierto y falso,
 * se denominan booleanas, para saber si el pulsador está o no liberado.
 * También usaremos el operador && (y) para hacer una pregunta doble.
 */

bool liberado = false;     //variable para saber si el pulsador estaba
                           //liberado antes de presionarlo 
 
void setup() {
  pinMode(13, OUTPUT);      //pin 13 como salida
  pinMode(A1, INPUT);       //pin A1 como entrada
  digitalWrite(13, HIGH);   //Led D1 apagado
}

void loop() { 
                                                   //Si hemos presionado y
  if((digitalRead(A1)==LOW) && (liberado==true)){  //antes estaba liberado
    digitalWrite(13, !digitalRead(13));            //volteamos el LED.
    liberado = false;                              //Ya no está liberado
  }                                                //y no hay más volteos.
  if(digitalRead(A1)==HIGH){                       //Si pulsador liberado,
    liberado = true;                               //liberado es cierto y
  }                                                //podemos volver a voltear
  delay(50);                                       //cuando presionemos
}

Es un programa corto pero un poco complicado de entender, es necesario pensar en su lógica detenidamente para comprenderlo completamente, ya que el uso de variables es necesario en la realización de muchos programas.

En el siguiente programa iremos incrementando un número (se mostrará en el Monitor Serie) cada vez que accionemos un pulsador; teniendo en cuenta que cuando sea mayor de 20 tenemos que volver a cero. Será necesario crear una variable de tipo entero (int) para guardar el número.


/*
 * pulsadorNumero.ino
 * Cada vez que accionemos el pulsador se incrementará un número en el
 * Monitor serie. Cuando se llega a 20 se reinicia en cero.
 * Vamos a utilizar una variable capaz de guardar números eneros, es decir,
 * de tipo integer y le damos el valor inicial de cero.
 * Seguiremos usando el operador && (y) para hacer una pregunta doble.
 */

bool liberado = false;
int numero = 0;            //variable que guarda el nº de veces  que
                           //accionamos el pulsador.

void setup() {
  pinMode(A1, INPUT);       //pin A1 como entrada
  Serial.begin(9600);
}

void loop() { 
  if((digitalRead(A1)==LOW)&& (liberado==true)){
    numero++;                                         //incrementamos numero
    liberado = false;
  }
  if(digitalRead(A1)==HIGH){
    liberado = true;
  }
  if(numero > 20){                    //si mayor que 20
    numero = 0;                       //empezamos de nuevo en cero
  }
  Serial.println(numero);             //mostramos el contenido de la variable
  delay(50);
}

Ejercicios propuestos:

1.- Modificar y ampliar el programa anterior para utilizar dos pulsadores, uno para incrementar (numero++) y otro para decrementar (numero--). El numero no debe ser mayor (>) que 20 ni menor (<) que 0.

2.- Ahora queremos ir encendiendo de uno en uno los diodos LEDs cada vez que accionemos un pulsador.

lunes, 16 de mayo de 2022

El monitor serie (IDE Arduino)

Controlar el display de la tarjeta multifunción sin ninguna ayuda es complicado; por ello, de momento, utilizaremos el monitor serie que tiene el IDE Arduino para visualizar datos. Arduino se comunica con el ordenador a través del cable USB utilizando un puerto serie y podemos transmitir datos del uno al otro.

Para activar el monitor serie hay que tener conectada la tarjeta y seleccionarlo en el menú herramientas, se abrirá la ventana adjunta:


El siguiente programa envía al monitor serie el número 1, después de un segundo la palabra "Hola" y pasados dos segundos se repite el ciclo.
/*
 * monitorSerie.ino
 * Escribimos en el monitor Serie del IDE Arduino el número 1
 * seguido de la palabra Hola, a intervalos de tres segundos.
 */


void setup() {
  Serial.begin(9600);   //fijamos la velocidad de transmisión
                        //en 9600 baudios (bits por segundo)
}

void loop() {
  Serial.print(1);            //escribimos 1
  delay(1000);
  Serial.println("  Hola");   //escribimos y pasamos línea
  delay(2000);
}


Ahora visualizaremos en el monitor serie el estado de los tres pulsadores; es decir, si están presionados o liberados.

/*
 * monitorSeriePulsadores.ino
 * Monitorizamos el estado de los pulsadores en el monitor
 * serie,indicando si están presionados o liberados.
 * Usamos un variante de la instrucción if
 * if condición        si se cumple se ejecutan instruciones1
 *    instrucciones1
 * else                en caso contrario se ejecutan instruciones2
 *    instrucciones2
 */

void setup() {
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  Serial.begin(9600);

}

void loop() {
  if(digitalRead(A1) == LOW) {        //si pulsador presionado
    Serial.print("D1 presionado");    //   escribe D1 presionado
  }else{                              //en caso contrario  
    Serial.print("D1 liberado");      //   escribe D1 liberado
  }
  if(digitalRead(A2) == LOW) {
    Serial.print("   D2 presionado");
  }else{
    Serial.print("   D2 liberado");
  }
  if(digitalRead(A3) == LOW) {
    Serial.println("   D3 presionado");  
  }else{
    Serial.println("   D3 liberado");
  }
  delay(1000);
}



Ejercicios propuestos:

1.- Hacer un programa que visualice en el monitor serie vuestro nombre, transcurridos 5 segundos,  la edad (en la misma línea) y pasados otros 5 segundos la dirección (en la línea siguiente). Tras 5 segundos más en ciclo se repite.




domingo, 6 de marzo de 2022

Pulsadores (IDE Arduino)

El shield multifunción dispone de tres pulsadores: S1, S2 y S3, conectados a los pines A1, A2 y A3. Para usarlos tenemos que detectar si están presionados o liberados, eso lo podemos hacer con la instrucción digitalRead, que nos devuelve el nivel de voltaje (LOW o HIGH) existente en el pin. Cuando un pulsador está presionado dicho voltaje es LOW y cuando está liberado HIGH. En el programa adjunto, al presionar el pulsador S1 se enciende el LED D1 y al liberarlo se apaga.
/* 
 * pulsadorS1LedD1.ino
 * Al presionar el pulsador S1 (en el pin A1) se
 * enciende el LED D1 (pin 13) y se apaga al liberarlo.
 * Cuando se presiona un pulsador estamos poniendo un
 * voltaje bajo, LOW, en el pin al que está conectado,
 * al liberarlo se queda un voltaje alto, HIGH.
 */
 
void setup() {
  pinMode(13, OUTPUT);      //pin 13 como salida
  pinMode(A1, INPUT);       //pin A1 como entrada
  digitalWrite(13, HIGH);   //apagamos el Led D1
}

void loop() { 
  digitalWrite(13, digitalRead(A1));   //digitalRead(A1) será LOW si
                                       //el pulsador está presionado
                                       //o HIGH si está liberado
}

En este caso, vamos a encender D1 y D2 al presionar el pulsador S1 y los vamos a apagar cuando presionemos el pulsador S2. Para realizar el programa es necesario usar la instrucción if (si), que nos va a servir para comparar dos valores y ejecutar unas determinadas instrucciones sólo en el caso de que sean iguales.

/*
 * pulsadorS1enciendeS2apaga.ino
 * Al presionar el pulsador S1 (pin A1)se encienden D1 (pin 13) y
 * D2 (pin 12), al presionar el pulsador S2 (pin A2) se apagan.
 */
 
void setup() {
  pinMode(13, OUTPUT);        //pin 13 como salida
  pinMode(12, OUTPUT);        //pin 12 como salida
  pinMode(A1, INPUT);         //pin A1 como entrada
  pinMode(A2, INPUT);         //pin A2 como entrada
  digitalWrite(13, HIGH);     //apagamos el Led D1
  digitalWrite(12, HIGH);     //apagamos el Led D2
}

void loop() { 
  if(digitalRead(A1)==LOW) {   //si pulsador S1 presionado
    digitalWrite(13, LOW);     //Led D1 encendido
    digitalWrite(12, LOW);     //Led D2 encendido
  }
  if(digitalRead(A2)==LOW) {   //si pulsador S2 presionado
    digitalWrite(13, HIGH);    //Led D1 apagado
    digitalWrite(12, HIGH);    //Led D2 apagado
  }
}




Ejercicios propuestos:

1.- Escribir un programa para que al presionar el pulsador 1 se encienda el LED 4, al presionar el pulsador 2 suene el  zumbador y al presionar el pulsador 3 se apague el LED y finalice el sonido.

2.- Ahora haremos que los diodos 1 y 2 se enciendan al mantener presionado el pulsador 1 y se apaguen al liberarlo. Además, los diodos 3 y 4 se encenderán al presionar el pulsador 2 y se apagarán al presionar el pulsador 3.




jueves, 3 de marzo de 2022

El zumbador (IDE Arduino)

El shield multifunción lleva incorporado un zumbador, conectado al pin 3 de Arduino, con el que podemos emitir sonidos; para ello se utiliza la instrucción tone, indicando el numero del pin y la frecuencia del mismo. También necesitaremos la instrucción noTone para silenciarlo. Además, si no queremos que el zumbador haga ruido es conveniente mantener el pin 3 con un nivel de voltaje alto. El siguiente programa hace que el zumbador suene durante 1 segundo con una frecuencia de 440 Hz y después queda en silencio 5 segundos.

/* zumbador
 * Emite un sonido (nota La) durante 1 segundo,
 * después permanece en silencio 5 segundos.
 * El zumbador está conectado al pin 3 de Arduino.
 * Para evitar que emita ruidos hay que poner un
 * nivel de voltaje alto (HIGH) en dicho pin.
 */

void setup() {
  pinMode(3, OUTPUT);      //pin 3 como salida
  digitalWrite(3, HIGH);   //zumbador sin ruido
}

void loop() { 
  tone(3, 440);            //nota La, frecuencia 440Hz
  delay(1000);             //esperamos 1 segundo
  noTone(3);               //silencio
  digitalWrite(3, HIGH);
  delay(5000);             //esperamos 5 segundos
}

En la siguiente lista tenemos las frecuencias de las notas musicales básicas:

Ahora haremos que suenen las notas Do, Re y Mi durante medio segundo cada una, después permanecerá en silencio 2 segundos y se repetirá el ciclo.

/* zumbadorDoReMi
 * Suenan las notas Do, Re y Mi durante medio
 * segundo cada una, después 2 segundos en silencio
 */

void setup() {
  pinMode(3, OUTPUT);
  digitalWrite(3, HIGH);

}

void loop() {
  tone(3, 262);             //Do
  delay(500);
  tone(3, 294);             //Re
  delay(500);
  tone(3, 330);             //Mi
  delay(500);
  noTone(3);                //silencio
  digitalWrite(3, HIGH);
  delay(2000);
}

En el siguiente programa suenan las mismas notas pero dando un pitido corto de 0'1 segundos.

/* zumbadorDoReMiCorto
 * Suenan unos pitidos cortos (100 mseg) de las notas
 * Do, Re y Mi. Posteriormente, pasados 2 segundos
 * se vuelve a repetir el ciclo.
 */

void setup() {
  pinMode(3, OUTPUT);      //pin 3 como salida
  digitalWrite(3, HIGH);   //zumbador sin sonido
}

void loop() {
  tone(3, 262);           //Do
  delay(100);
  noTone(3);              //silencio
  digitalWrite(3, HIGH);
  delay(400);
  tone(3, 294);           //Re
  delay(100);
  noTone(3);              //silencio
  digitalWrite(3, HIGH);
  delay(400);
  tone(3, 330);           //Mi
  delay(100);
  noTone(3);              //silencio
  digitalWrite(3, HIGH);
  delay(400);
  delay(2000);            //dos segundos de pausa
}


Ejercicios propuestos:

1.- Realizar un programa que haga parpadear un LED y, a la vez, emita dos pitidos cortos.


2.- Conseguir que suene la escala musical completa en el zumbador.


3.- Ampliar el programa del semáforo de la entrada anterior de manera que el zumbador emita unos pitidos cortos para avisar que el tiempo de paso de los peatones se está acabando.


domingo, 27 de febrero de 2022

Los diodos LED (IDE Arduino)

El shield multifunción cuenta con cuatro diodos LED, D1, D2, D3 y D4, que están conectados a los pines 13, 12, 11 y 10 de Arduino. Para controlarlos es necesario programar dichos pines como salidas con la instrucción pinMode y, posteriormente, encenderlos o apagarlos con la instrucción digitalWrite, suministrando un voltaje bajo (LOW del orden de 0 voltios) o alto (HIGH unos 5v).

Nuestro primer programa sirve para encender el LED D1. En él vamos a utilizar las instrucciones comentadas anteriormente.

/* 
 * encendidoLedD1
 * Este programa enciende el Led D1, conectado al pin13.
 * Por la manera en la que están conectados en el shield, los
 * diodos Led se encienden con un nivel de voltaje bajo LOW
 * y se apagan con un voltaje alto HIGH.
 */

void setup() {
  pinMode(13, OUTPUT);      //programamos pin 13 como salida
  digitalWrite(13, LOW);    //ponemos un voltaje bajo en pin 13
}

void loop() {                          

}

Ahora vamos a hacer que el LED D1 parpadee a intervalos de 1 segundo. Usaremos la instrucción delay para detener el programa durante el tiempo que deseemos, expresado en milisegundos (1 seg = 1000 mseg).

/* 
 * parpadeoD1
 * Este programa hace parpadear el Led D1, pin 13,
 * a intervalos de 1 segundo.
 * El tiempo hay que expresarlo en milisegundos
 * 1 seg = 1000 mseg.
 */

void setup() {
  pinMode(13, OUTPUT);      //programamos pin 13 como salida
}

void loop() {                          
  digitalWrite(13, LOW);    //encendemos Led D1
  delay(1000);              //esperamos 1 segundo
  digitalWrite(13, HIGH);   //apagamos Led D1
  delay(1000);              //esperamos 1 segundo
}


En el siguiente programa vamos a ir encendiendo los LED de uno en uno a intervalos de 1 segundo. Después se apagan todos durante 2 segundos y vuelve a iniciarse el ciclo.

/*
 * encendidoProgresivoLED
 * Los LED se van encendiendo de uno en uno a intervalos
 * de un segundo. Después se apagan durante dos segundos
 * y vuelve a iniciarse el ciclo.
 */

void setup() {
  pinMode(13, OUTPUT);     //todos los pines salidas
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(13, HIGH);  //apagamos todos los LED
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);  
}

void loop() {
  digitalWrite(13, LOW);   //encendemos D1
  delay(1000);
  digitalWrite(12, LOW);   //encendemos D2
  delay(1000);
  digitalWrite(11, LOW);   //encendemos D3
  delay(1000);
  digitalWrite(10, LOW);   //encendemos D4
  delay(1000);
  digitalWrite(13, HIGH);  //apagamos todos los LED
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);  
  delay(2000);
}
Ejercicios propuestos:

1.- Hacer un programa que provoque el parpadeo alternativo de los LEDs 1-2 y los LEDs 3-4. Es decir, se encienden los LEDs 1 y 2 mientras que los LEDs 3 y 4 permanecen apagados durante medio segundo, posteriormente, se apagan los LEDs 1 y 2 y se encienden los LEDs 3 y 4 durante medio segundo. El ciclo se repite permanentemente.

2.- Ahora tenemos que conseguir un movimiento rápido de sube-baja con un único LED encendido.

3.- Programar un semáforo para coches. El LED D1 sería el rojo, el D2 el ambar y el D3 el verde. Posteriormente, se podría ampliar el programa usando el LED D4 para los peatones, encendido no se puede pasar y apagado si, incluso se puede hacer parpadear para avisar que el tiempo de paso se agota antes de ponerse en rojo.