Trabajando con pulsadores II.

Hola de nuevo.

Quedó pendiente de la anterior entrada dos ejercicios propuestos. Vamos a trabajar el segundo de ellos, pulsar para activar el ciclo y pararlo con otra pulsación sobre el mismo interruptor, que es donde reside la gracia.

Para poder activar y desactivar el led, necesitaremos recordar en qué estado se encontraba la salida, de manera que el Arduino cambie su valor en función de cual fuese su estado anterior.

Para almacenar este estado haremos uso de una variable. Las variables,se almacenan en la memoria del Arduino y pueden contener diferentes tipos de datos. Una variable puede ser del tipo número, texto, booleana, un array, etc. El tipo de contenido que quieres almacenar tienes que decidirlo antes de empezarla a usar, y es importante no sobredimensionarla, puesto que en el momento de declararla, reservará ese espacio en la memoria lo uses o no, y como ya hemos comentado nuestro Arduino tiene una memoria RAM realmente limitada.

Las variables de tipo numérico que se pueden utilizar son:

• byte: almacena un número natural entre 0 y 255 (1 byte).
• int: almacena un número entero entre -32768 y 32767 (2 bytes).
• unsigned int: almacena un número natural entre 0 y 65536 (2 bytes).
• long: almacena un número entero entre -2147483648 y 2147483647 (4 bytes).
• unsigned long: almacena un número entero entre 0 y 4294967295 (4 bytes).
• float: almacena un número decimal con un rango entre -3.4028235·1038 y 3.4028235·1038 (4 bytes).
• const: especifica que la variable definida no podrá ser cambiada durante el programa, siendo siempre un valor constante:

                                      const float pi=3.1415;

Para este ejemplo también usaremos otro tipo de constante de tipo boolean. La variable de tipo booleana solo puede contener dos estados TRUE o FALSE (verdadero o falso), en función de si se cumple o no la condición. La explicaremos más adelante.

Volviendo al ejemplo, debemos definir en este punto cual queremos que sea el comportamiento. Hemos decidido que ,

• El montaje empiece con el led apagado,
• El Arduino "vigila" la entrada en espera de una pulsación. Cuando se produce pone                  el LED a "1".
• A partir de aquí cambiará el estado del led en cada pulsación que se aplique sobre el pulsador.

Para conseguir este comportamiento, el Arduino debe recordar varias cosas. Una es el estado actual del pulsador. Necesitará comparar con el estado anterior, y comprobar si ha habido una pulsación( o si todavía durase la misma).
Y el estado del led, puesto que deberá apagarlo o encenderlo en función de cómo estaba anteriormente.
Por tanto las variables de nuestro montaje podrían ser las siguientes:

• valor_actual: leerá y almacenará el estado del pulsador
• valor_anterior: almacenará cada cambio de estado el estado previo
• estado_led: almacenará el estado del led, encendido o apagado

El sketch quedaría de la siguiente manera:

// Ejemplo 1_6 _Uso de un pulsador para ON-OFF
// Una pulsación activa el LED, que quedará enecendido
// hasta recibir otra pulsación

const int LED = 9; // pin de salida
const int PULSADOR = 2; //pin para el pulsador

int valor = 0; // variable que almacenará la lectura del pulsador
int old_valor = 0; //variable que almacenará la lectura anterior
// del pulsador. Comparandolas sabremos si ha cambiado
int estado_led = 0; // Variable que almacena el estado del LED
// de salida
void setup() 
{
pinMode(LED, OUTPUT); // Programamas el LED como salida
pinMode(PULSADOR, INPUT); // el PULSADOR como entrada
}
void loop()
{
valor = digitalRead(PULSADOR); // leemos el pulsador
// y comprobamos si ha habido un cambio de estado
// comparandolo con el valor anterior

if ((valor == HIGH) && (old_valor == LOW)){
estado_led = 1 - estado_led;
delay(10);
}
old_valor = valor; // El valor leído ahora ya es el "viejo"
// así que lo almacenamos para la siguiente pulsación

if (estado_led == 1)
{
digitalWrite(LED, HIGH); // Encendemos el led si el estado_led es "1"
} else {
digitalWrite(LED, LOW);
}
}

 Puedes descargar el sketch aquí.

El montaje es el habitual hasta ahora, pero lo recuerdo por si acaso:

La parte que tiene la"chicha" del programa es esta:

if ((valor == HIGH) && (old_valor == LOW)){
estado_led = 1 - estado_led;

Que estamos haciendo, comparamos la lectura del pulsador con la anterior lectura realizada. Si la lectura actual es "1", y la anterior "0", hay una transición o flanco de subida, por lo tanto una pulsación.

Cómo queremos que a cada pulsación conmute el estado de nuestra salida  usamos un truco de programación para  invertir esa variable. Es la línea:

estado_led = 1 - estado_led;

¿Cómo actuaría si sustituyes estado_led por 0 o por 1?,¿o viceversa? Verás que la fórmula invierte, el valor en los dos casos.

¿Funciona? Sí, este programa lo puedes encontrar muy parecido en algún libro sobre el Arduino. Pero hay una forma más "elegante" de hacerlo. Para ello explicaremos las variables Booleanas.

Variables tipo boolean

Este tipo de variable, que ocupa un byte, sólo puede tomar dos valores TRUE o FALSE, (verdadero o falso). Como en nuestro caso  el led solo puede estar encendido o apagado , podríamos definir la variable estado_led como boolena y reescribir el código de la siguiente manera:

// Ejemplo 1_6boolean _Uso de un pulsador para ON-OFF
// Una pulsación activa el LED, que quedará encendido
// hasta recibir otra pulsación

const int LED = 9; // pin de salida
const int PULSADOR = 2; //Entrada para el pulsador

int valor = 0; // variable que almacenará la lectura del pulsador

int old_valor = 0; //variable que almacenará la lectura anterior
// del pulsador. Comparandolas sabremos si ha cambiado

boolean estado_led = false;//En este caso cambiamos la variable int por
// una del tipo boolean. Es la que almacena el estado del LED.La ponemos

// =, o FALSE

void setup() 
{
pinMode(LED, OUTPUT); // Programamas el LED como salida
pinMode(PULSADOR, INPUT); // el PULSADOR como entrada
}
void loop()
{
valor = digitalRead (PULSADOR); // leemos el pulsador
// y comprobamos si ha habido un cambio de estado
// comparandolo con el valor anterior

if ((valor == HIGH) && (old_valor == LOW)){
estado_led = !estado_led;// El símbolo ! invierte el estado
//de la bariable de tipo boolean
delay(20);
}
old_valor = valor; // El valor leído ahora ya es el "viejo"
// así que lo almacenamos para la siguiente pulsación

if ( estado_led == true)//El otro cambio, ahora verificamos si el 
//estado es TRUE que equivale a "1" o HIGH
{
digitalWrite(LED, HIGH); // Enecendemos el led si estado_led TRUE
} 

else {
digitalWrite(LED, LOW);
}
}

Lo puedes descargar desde aquí.

¿Donde están las diferencias?
1.- En la definición de las variables, ahora estado_led es boolean.
      boolean estado_led = false;
2.- En como se invierte la variable estado_led, ahora sé usa el simbolo !.
      estado_led = !estado_led;
3.- Cuando se analiza la condición, ahora se comprueba si es TRUE or FALSE. en lugar de "1" o "0".
      if ( estado == true)

Una nota más antes de dejaros con el video.

Veréis que hay un delay por ahí en medio. Este delay hace las veces de condensador en el montaje de las resistencias PULL-DOWN. Es decir, si lo montáis sin condensador, y no ponéis este delay, notaréis que tiene un funcionamiento errático, puesto que el Arduino es tan rápido en la ejecución del programa que puede leer los rebotes del pulsador. Por tanto lo "entretenemos" con un delay para que pase el rebote del pulsador antes de la siguiente lectura. Si queréis comprobarlo, anular el delay o bajar el tiempo y lo podréis valorar.

Yo he tenido rebotes con valores de delay por debajo de 10ms.

Ahora sí, hasta la siguiente entrada. Nos vemos.

Otro ejemplo con PWM. Fade-in y fade-out en un led.

Veamos otro ejemplo con el uso de PWM.

El enunciado del ejemplo sería programar un bucle que encienda un led de manera progresiva hasta su máxima luminosidad y lo apague de la misma manera. Pretendemos simular algo parecido al comportamiento de un led en standby de un portátil.

Para ello, utilizaremos el bucle for que ya vimos en pasadas entradas y la función analogWrite().

Usaremos el mismo montaje de la entrada anterior.

El algoritmo del programa  sería algo como esto:

• Inicializar entradas y salidas.
• Hacer un bucle ascendente de 0 a 255 (valor máximo y mínimo) que incremente la salida analógica.
• Hacer un bucle descendente que de 255 a 0 que vaya apagando el led.
• Repetir indefinidamente...

El programa, perdón el sketch, quedaría:

//Ejemplo 1_5. Encendido y apagado progresivo de un led
// Modificaremos su luminosidad actuando sobre el ciclo de carga
// de la seña de salida

const int LED = 9; // Pin conectado al LED
int i = 0; // Variable que usaremos para el bucle for

void setup() 
{
  pinMode(LED, OUTPUT); // Configuramos el pin como salida
}
void loop()
{
  for (i = 0; i < 255; i++) // bucle de 0 a 254 (fade in).Vamos
                            // incrementando el ciclo de trabajo
  {                         //de 0 a 255     
  analogWrite(LED, i); // esta línea configura el brillo del LED
  delay(10); // Colocamos una espera de 10ms para poder apreciar
             // el efecto. De otro modo sería tan inmediato que
             //no lo veríamos
  }//fin del primer for.   
  for (i = 255; i > 0; i--) { // bucle de 255 a 1 (fade out)
  analogWrite(LED, i); // esta línea configura el brillo del LED
  delay(10); // Espera de 10ms
  }
}

Lo podéis encontrar para descargarlo aquí:

El código es bastante sencillo, así que vamos a añadir un mínimo de complejidad. Vamos a modificar el ejemplo para que sea la activación de un pulsador la que inicie el ciclo.

Cómo sería el algoritmo en esta ocasión:

• Inicializar entradas y salidas.
• Leer el estado del pulsador e iniciar el ciclo si se pone a “1”, (se pulsa)
• Hacer un bucle ascendente de 0 a 255 (valor máximo y mínimo) que incremente la salida analógica.
• Hacer un bucle descendente que de 255 a 0 que vaya apagando el led.
• Repetir indefinidamente…

Ok, sencillo ¿no? Solo hemos añadido una línea  en el algoritmo, y ¿en el sketch? Dad le una vuelta antes de seguir leyendo…

…Una vuelta más…

… ¿Ya? Bien pues aquí mi propuesta:

//Ejemplo 1_5b. Encendido y apagado progresivo de un led
// modificando su luminosidad actuando sobre el ciclo de carga
// de la seña de salida. El ciclo lo inicia una pulsación

const int LED = 9; // Pin conectado al LED
const int pulsador = 2 ; //Pin conectado al pulsador
int i = 0; // Variable que usaremos para el bucle for

void setup() 
{
  pinMode(LED, OUTPUT); // Configuramos el pin como salida
  pinMode(pulsador, INPUT); //Configuramos el pin como entrada
}
void loop()
{
    digitalWrite (LED, LOW); //Fijamos la condición inicial del LED
if ( digitalRead(pulsador) == HIGH ) 
  {
    for (i = 0; i < 256; i++) // bucle de 0 a 255 (fade in).Vamos
                            // incrementando el ciclo de trabajo
    {                         //de 0 a 255     
    analogWrite(LED, i); // esta línea configura el brillo del LED
    delay(10); // Colocamos una espera de 10ms para poder apreciar
               // el efecto. De otro modo sería tan inmediato que
               //no lo veríamos
     }//fin del primer for.   
     for (i = 255; i > 0; i--) 
     { // bucle de 255 a 1 (fade out)
     analogWrite(LED, i); // esta línea configura el brillo del LED
     delay(10); // Espera de 10ms
     } // fin del segundo for
    }//Fin condición de la pulsación
    digitalWrite (LED, LOW); //Apagamos el LED en espera de otro pulso
}

¿En qué varía el código? Bien de entrada fijamos que cuando se ejecuta el bucle, el LED esté apagado en espera de recibir una pulsación.

       digitalWrite (LED, LOW);

Seguidamente ponemos una condición con un IF, (ya lo trabajamos aquí), para detectar un flanco positivo en la entrada, (vamos una pulsación):

        if ( digitalRead (pulsador == HIGH ))

Y pasamos a copiar el código anterior. Tan solo debemos recordar salir del bucle volviendo a apagar el LED en espera de otra pulsación.

         digitalWrite (LED, LOW);

El sketch para descarga lo puedes encontrar aquí.

Este montaje tiene muchas posibilidades. Podríamos intentar por que tras la pulsación repita el ciclo n número de veces y se apague.

Otra aún más interesante, que una pulsación comience el ciclo y otra lo apague (con un solo pulsador).  Os dejo con el vídeo del funcionamiento de los dos ejemplos, y en la próxima entrada la solución a estas dos propuestas. Nos vemos.

Resistencias pull-up y pull-down

Hola de nuevo,

Después de unas entregas de toma de contacto, es hora de avanzar un paso más. Hasta ahora, hemos conseguido que nuestra placa haga lo que le hemos dicho, pero no ha habido interactuación. Le cargamos un programa, y desde el momento que lo recibe lo ejecuta indefinidamente, hasta que la desconectamos de la alimentación. Es decir, no podemos decidir cuándo ejecutar o parar la aplicación.

En esta entrada veremos cómo comunicarnos con el Arduino a través de unos pulsadores.

Pero antes de nada… sí exacto, un poco de teoría.

Cuando queremos comunicarnos a través de un pulsador, lo que acaba recibiendo nuestra placa son “0” ó “1”.  Pero conseguir esto no es tan sencillo como conectar un pulsador entre la alimentación y nuestra entrada, puesto que cuando no estuviese pulsado nuestro Arduino no recibiría un “0”, sino un estado indeterminado que lo haría inestable e impredecible.

Por lo tanto, necesitamos fijar un valor en la entrada digital para tener un valor por defecto. Para tal fin se usan dos tipos de montaje.

La resistencia “pull-up”, que establece un nivel alto (1) en reposo. Veamos el montaje:

En este caso, con el pulsador abierto, no hay paso de corriente y la entrada digital ve directamente la fuenta de alimentación, es decir los 5V (1).

Cuando pulsamos el interruptor, cerramos el circuito y por tanto la entrada digital está directamente conectada a masa (0). La resistencia es necesaria en este montaje para no cortocircuitar la fuente.

La resistencia “pull-down”, que establece un nivel bajo (0) en la entrada digital en estado de reposo y un nivel alto (1) cuando pulsamos. Este es el montaje más habitual. Un ejemplo:

El funcionamiento en reposo, con el interruptor abierto no hay paso de corriente, por tanto no hay caída de potencial en la resistencia y la entrada digital “ve” masa, es decir está a “0”. Cuando pulsamos y cerramos el circuito, se produce una caída de tensión en R1 por el paso de la corriente. Esta caída de tensión , que son los 5V directos de la fuente es lo que ve nuestra entrada digital, y por tanto estará a “1” mientras esté pulsado.

En este tipo de montajes se suele usar resistencias de 10K para controlar el consume de corriente del circuito.

El pulsador es una chapa metálica, que al pulsarla flexa y toca los contactos cerrando el circuito. Pero al liberarlo normalmente se producen unos rebotes, que en aplicaciones de precisión puede provocar “falsos positivos”. Para estos casos, se mejora el circuito añadiendo un pequeño condensador entre la entrada y masa. De esta forma:

En este montaje el condensador se carga cuando pulsamos, y al dejar de pulsar “filtra” los rebotes del contacto metálico. El inconveniente es que deberá descargarse el condensador para que el Arduino pueda obedecer a otra pulsación.

Se puede considerar que la entrada estará otra vez a un nivel 0, después de 5 veces la constante de tiempo de descarga del condensador. Si usamos una R de 10K y un condensador de 100nF, sería:

T = R x C = 10.000 x 0.00000001 = 0,1 ms Constante de carga

                5 T = 0,5 ms  Tiempo necesario entre pulsaciones

Obviamente, 0,5 milisegundos entre pulsaciones es un tiempo más que aceptable y que podemos dar por válido.

De todas maneras para nuestros ejemplos no montaremos ningún condensador, puesto que los tiempos de ejecución del programa superan el posible transitorio producido por el rebote del pulsador.

En la próxima entrada programaremos el Arduino para leer entradas.

Uso de bucles. La instrucción for

Ejemplo 1_2

En esta entrada quiero explicar un tipo de bucle muy típico en programación. Se trata del bucle

for.

Este tipo de recurso se usa cuando queremos repetir n  número de veces un evento dentro del programa. Repetirlo a base de copiar el mismo código n veces cómo el día anterior tiene varios inconvenientes:

-        Es muy pesado, efectivamente, y aunque uses el clásico copiar y pegar,

-        También es ineficiente desde un punto de vista de programación, puesto que hace el código más largo, y la memoria de nuestro Arduino está muy limitada.

¿Cómo quedaría la secuencia de encendido, nuestro  void loop, con este recurso? Primero un vistazo al código anterior:

void loop()

{

  digitalWrite(2,HIGH);

  delay(d);

  digitalWrite(2,LOW);

  digitalWrite(3,HIGH);

  delay(d);

  digitalWrite(3,LOW);

  digitalWrite(4,HIGH);

  delay(d);

  digitalWrite(4,LOW);

  digitalWrite(5,HIGH);

  delay(d);

  digitalWrite(5,LOW);

}

Y ahora usando el for,  el ejemplo completo:

//Ejemplo1.2 versión para explicar el uso del for para realizar procesos repetitivos

//sobre el ejemplo anterior de "la ola ". La declaración de entradas y salidas es la misma

//el cambio será a la hora de encenderlas que lo haremos usando la instrucción for

int d=1000; // constante de tipo integer, que define el tiempo de delay

void setup()

{

  pinMode(2,OUTPUT); //Pin 2 conectado al led 1, definido como salida

  pinMode(3,OUTPUT); //Pin 3 conectado al led 2, definido como salida

  pinMode(4,OUTPUT); //Pin 4 conectado al led 5, definido como salida

  pinMode(5,OUTPUT); //etc...

}

Void loop()

{

For ( int a = 2;  a < 6; a++)

{

digitalWrite(a,HIGH);

delay (d);

digitalWrite(a,LOW);

delay (d);

}

}

                 

Analicemos el bucle:

for ( int a = 2; a < 6 ; a++ )

   {

digitalWrite(a, HIGH);

delay(d);

digitalWrite(a, LOW);

delay(d);

   }

}

Detrás de la instrucción for, entre paréntesis expresamos las condiciones del bucle.

Primero definimos una variable, a, y le asignamos un valor inicial.  Seguidamente le decimos cual es la condición que debe cumplir esa variable para salir del bucle, que sea más pequeña que 6, y cuanto tiene que incrementar en cada repetición, en este caso contar de 1 en 1, a++.

Después entre corchetes se encuentra las acciones que se realizarán todas las veces que se ejecute el bucle. Cómo tenemos los leds conectados entre los pines 2 y 6 lo que hacemos es dar una variable, el valor inicial de 2 e ir incrementándolo hasta llegar al último. Este código es equivalente al anterior, pero se aprecia rápidamente que incrementar el nº de leds es muchísimo más sencillo. También observamos que incrementar el número de salidas no incrementa la longitud del código.

El ejemplo para descarga, lo tienes en el enlace. Como siempre, intenta teclearlo tú:

Ejercicio 1.2 de arduino práctico

Los bucles también se pueden definir para realizar una cuenta regresiva. En ese caso utilizaremos el valor a--. En nuestro ejemplo, el bucle podría quedar de la siguiente manera:

for ( int a = 6; a <  2 ; a-- )

   {

digitalWrite(a, HIGH);

delay(d);

digitalWrite(a, LOW);

delay(d);

   }

}

Esta versión la tienes disponible en el siguiente enlace:

Ejercicio 1.2b de Arduino práctico

En este caso, los leds describirían la secuencia en sentido inverso, y con la sentencia a— en cada paso restaremos 1, hasta llegar a 2.

Pincha en el video para apreciar la diferencia:

Ejemplo 1_1. “La ola”

Para el siguiente montaje usaremos unos Leds como salida de nuestro circuito. Un led es un tipo de semiconductor pasivo que emite luz al paso de una corriente. LED, es la abreviación del inglés de Light-emitting diode. El símbolo que se usa en electrónica para representarlo es el siguiente:

El diodo led no puede ir conectado directamente a la salida del arduino, pues aunque es da baja potencia, lo acabaría fundiendo. Por lo tanto se ha interponer una resistencia para limitar la corriente que lo atraviesa. Haremos el cálculo sencillo del valor de la resistencia, y de paso repasamos un poco la ley de Ohm.

Para un diodo standard , supondremos una caída de potencial entre el ánodo y el cátodo de 1,7V. La corriente máxima admisible dependerá también del modelo, para este caso utilizaremos un valor inferior a los 20mA, en concreto 15mA.

La caída de tensión en la resistencia será por tanto :

Vr = Vcc-Vled = 5 - 1.7= 3.3V

Si tenemos el valor de la caída de tensión y la corriente que atraviesa la malla, despejando la R, de la fórmula V=IxR, quedaría:

R= V/I = 3,3/0.15 = 220Ω

En este caso, como coincide con un valor normalizado, usaremos para el montaje resistencias de 220Ω.

¡Qué coincidencia! Son justamente las que tengo en casa. Bueno en cualquier caso, podemos usar “cualquier valor” por encima de los 220Ω, con la única limitación del brillo que emitirá el led, pero ser razonables, no pongáis resistencias de 100kΩ, y preguntéis por qué no se enciende el led si hemos seguido el montaje al dedillo.

Valores por debajo, son contraproducentes, porque elevarán el consumo de nuestro diseño, y fundirán leds constantemente.

Está bien, una vez hemos explicado el por qué de los valores que hemos escogido pasaremos a definir el proyecto de hoy.

Encendido secuencial de leds. “La ola”

Este proyecto es un ejercicio muy común de inciación. Pero nos debería ayudar a planificar como enfrentarnos a cualquier proyecto a partir de ahora, con unas pautas que facilitarán enormemente el conseguir el objetivo final.

•      Definir un objetivo. Es básico saber qué queremos conseguir. Cualquier modificación sustancial        durante la ejecución del proyecto seguramente nos obligue a volver al punto 1, y alargue el plazo y    aumente los costes. A lo mejor sólo es tu hobby, pero aplica todos los aspectos de la vida.

•    .     Escribe tu algoritmo. No confundir con escribir el código del programa. El algoritmo son las   instrucciones que deberá seguir el flujo del programa, paso a paso. Intenta en este punto contemplar   todas las incidencias posibles.

•       Selecciona el hardware necesario, ahora ya sabes cuantas entradas y salidas necesitas y cómo        puedes conectarlas.

•     Escribe el código. Ahora ya puedes transformar tu algoritmo en el programa. El algoritmo viene a     ser como un boceto de un dibujo, y el programa el arte final.

•      Crea el circuito, conecta todos los elementos de tu hardware con tu Arduino    

•          Puesta en marcha y depuración de fallos. ¿Funciona tal y cómo esperabas? ¿No? Es momento de localizar los errores en el hardware o la programación.

Volviendo a nuestro proyecto de hoy. ¿Qué queremos conseguir? El encendido y apagado de 4  leds de manera secuencial.

El algoritmo podría ser algo parecido:

  1.- Encender el led 1

  2.- Esperar 1 segundo, y apagarlo

  3.- Encender el led 2

  4.- Esperar 1 segundo, y apagarlo

  5.- Continuaría así hasta el led 4 , momento en que saltaríamos al led 1

  6.- Repetir el bucle indefinidamente.

El hardware necesario:  

•     4 leds de colores
•     4 resistencias de 220Ω
•     Una protoboard y cablecillo rígido
•     Un arduino y su cable USB

Siguiente paso, escribir nuestro código:

  

// Ejemplo 1 - Secuencia de ON-OFF de 4 Leds "La ola"

// Definimos las salidas de nuestro proyecto en el setup

void setup()

{

  pinMode(2,OUTPUT); //Pin 2 conectado al led 1, definido como salida

  pinMode(3,OUTPUT); //Pin 3 conectado al led 2, definido como salida

  pinMode(4,OUTPUT); //Pin 4 conectado al led 5, definido como salida

  pinMode(5,OUTPUT); //etc...

}

void loop()

{

  digitalWrite(2,HIGH);// Encendemos el Led 1 poniendo su salida en 1, HIGH

  delay(1000); //Espera de un segundo

  digitalWrite(2,LOW);//Apagamos el Led 1 poniendo su pina a 0, o LOW

  digitalWrite(3,HIGH);//Repetimos los mismo pasos hasta el led 4

  delay(1000);

  digitalWrite(3,LOW);

  digitalWrite(4,HIGH);

  delay(1000);

  digitalWrite(4,LOW);

  digitalWrite(5,HIGH);

  delay(1000);

  digitalWrite(5,LOW);

 //final del Loop, ahora volverá al incicio del bucle,

 //y se repetirá indefinidamente

}

Seguidamente tocará cablear nuestro prototipo, siguiendo el siguiente esquema:

Una propuesta para el conexionado en la protoboard podría ser esta, donde minimizamos la cantidad de cable a emplear.

Podéis hacer copy-paste sobre el programa y pegarlo en Arduino. De todas maneras yo recomiendo entrarlo a mano e ir aprendiendo de nuestros errores. Por si algo os falla, os dejo un enlace directo al sketch ya depurado y comprobado.

Programa Ejemplo 1_1

Deberíais obtener un resultado similar al que muestra el video del siguiente enlace.

La modificación del sketch corresponde a la siguiente entrada, así que no desmontéis el circuito, que lo usaremos en la siguiente entrada.