El objetivo de esta práctica es emular la iluminación de 2 semáforos para regular el tráfico de un cruce de calles.

Pulsa la bandera verde y comprueba el resultado.

int 1_rojo=12;
int 1_amarillo=11;
int 1_verde=10;
int 2_rojo=9;
int 2_amarillo=6;
int 2_verde=5;

void setup(){
    pinMode(1_rojo, OUTPUT);          // led rojo - pin de salida
    pinMode(1_verde, OUTPUT);         // led verde - pin de salida 
    pinMode(1_amarillo, OUTPUT);      // led amarillo - pin de salida 

    pinMode(2_rojo, OUTPUT);          // led rojo - pin de salida
    pinMode(2_verde, OUTPUT);         // led verde - pin de salida 
    pinMode(2_amarillo, OUTPUT);      // led amarillo - pin de salida 

} 
  
void loop() { // bucle infinito 

    digitalWrite(1_verde, HIGH);          // verde - rojo
    digitalWrite(2_rojo, HIGH);          
    delay(2000);

    digitalWrite(1_verde, LOW);           // amarillo - rojo
    digitalWrite(1_amarillo, HIGH);       
    delay(1000);                        
    digitalWrite(1_amarillo, LOW);        // rojo - verde 
    digitalWrite(1_rojo, HIGH);           
    digitalWrite(2_rojo, LOW);           
    digitalWrite(2_verde, HIGH);          
    delay(2000);

    digitalWrite(2_verde, LOW);           // rojo - amarillo
    digitalWrite(2_amarillo, HIGH);         
    delay(1000);

    digitalWrite(2_amarillo, LOW);           
    digitalWrite(1_rojo, LOW);            
}

Pulsa en el icono subir, y comprueba el resultado.

El objetivo de esta práctica es emular un semáforo que pasa a iluminarse en rojo cuando se presiona el pulsador.

A continuación el programa se queda esperando que se presione el pulsador conectado al pin 2.

Una vez presionado, se realiza el cambio de iluminación con la secuencia: amarillo, rojo, verde

int rojo=12;
int amarillo=9;
int verde=6;
int pulsador=2;

void setup(){
    pinMode(rojo, OUTPUT);          // led rojo - pin de salida
    pinMode(verde, OUTPUT);         // led verde - pin de salida 
    pinMode(amarillo, OUTPUT);      // led amarillo - pin de salida 
    pinMode(pulsador, INPUT);      // pulsador - pin de entrada
} 
  
void loop() { // bucle infinito 

    digitalWrite(verde, HIGH);          // se enciende el led verde
     
    if (digitalRead(pulsador)){
       digitalWrite(verde, LOW);           // se apaga el led verde 
       digitalWrite(amarillo, HIGH);       // se enciende el led amarillo
       delay(1000);                        // pausa 1 segundo
       digitalWrite(amarillo, LOW);        // se apaga el led amarillo 
       digitalWrite(rojo, HIGH);           // se enciende el led rojo
       delay(3000);
       digitalWrite(rojo, LOW);            // se apaga el led rojo 
    }
}

Pulsa en el icono subir, y comprueba el resultado.

El objetivo de esta práctica es emular la iluminación de un semáforo para vehículos que además emitirá un sonido cuando el tráfico esté detenido, dando paso a los peatones.

A continuación apagamos el led verde y encendemos el amarillo.

int rojo=12;
int amarillo=9;
int verde=6;
int zumbador=11;

void setup(){
    pinMode(rojo, OUTPUT);               // led rojo - pin de salida
    pinMode(verde, OUTPUT);              // led verde - pin de salida 
    pinMode(amarillo, OUTPUT);           // led amarillo - pin de salida 
    pinMode(zumbador, OUTPUT);           // zumbador - pin de salida 
} 
  
void loop() { // bucle infinito 

    digitalWrite(verde, HIGH);          // se enciende el led verde
    delay(3000);                        // pausa 3 segundos

    digitalWrite(verde, LOW);           // se apaga el led verde 
    digitalWrite(amarillo, HIGH);       // se enciende el led amarillo
    delay(1000);                        // pausa 1 segundo

    digitalWrite(amarillo, LOW);        // se apaga el led amarillo 
    digitalWrite(rojo, HIGH);           // se enciende el led rojo

    for (int i=0; i<10; i++){           // bucle que se repite 10 veces
       digitalWrite(zumbador, HIGH);    // sonido
       delay(300);                      // pausa
       digitalWrite(zumbador, LOW);     // silencio 
       delay(300);                      // pausa
    }

    digitalWrite(rojo, LOW);            // se apaga el led rojo 
  
}

Pulsa en el icono subir, y comprueba el resultado.

 

Conectamos un zumbador y haremos que suene de forma intermitente

A continuación apagamos el led verde y encendemos el amarillo.

int rojo=12;
int amarillo=9;
int verde=6;

void setup(){
    pinMode(rojo, OUTPUT);               // led rojo - pin de salida
    pinMode(verde, OUTPUT);              // led verde - pin de salida 
    pinMode(amarillo, OUTPUT);           // led amarillo - pin de salida 
} 
  
void loop() { // bucle infinito 

    digitalWrite(verde, HIGH);          // se enciende el led verde
    delay(3000);                        // pausa 3 segundos
    digitalWrite(verde, LOW);           // se apaga el led verde 
    digitalWrite(amarillo, HIGH);       // se enciende el led amarillo
    delay(1000);                        // pausa 1 segundo
    digitalWrite(amarillo, LOW);        // se apaga el led amarillo 
    digitalWrite(rojo, HIGH);           // se enciende el led rojo
    delay(3000);                        // pausa 3 segundos
    digitalWrite(rojo, LOW);            // se apaga el led rojo 
  
}

Pulsa en el icono subir, y comprueba el resultado.

Conectamos un zumbador y haremos que suene de forma intermitente

void setup() { 
    pinMode(12, OUTPUT);               // zumbador - pin de salida 
} 
  
void loop() { // bucle infinito 

    digitalWrite(12, HIGH);          // se enciende el zumbador 
    delay(500);                     // pausa 
    digitalWrite(12, LOW);          // se apaga el zumbador 
    delay(500);                     // pausa 
  
}

Pulsa en el icono subir, y si el zumbador suena de forma intermitente … ¡Objetivo Conseguido!

 

Esta práctica consiste en utilizar un mismo pulsador para encender y apagar un led.

int estado=0;

void setup() { 
    pinMode(6, OUTPUT);               // Led - pin de salida 
    pinMode(2, INPUT);                // pulsador - pin de entrada 
} 
  
void loop() { // bucle infinito 

  if(digitalRead(2) && estado==0){  // si pulsador presionado y led apagado
    digitalWrite(6, HIGH);          // se enciende el led 
    delay(100); 
    estado=1;                       // guardamos el estado encendido   
  } 
  if(digitalRead(2) && estado==1){  // si pulsador presionado y led encendido

    digitalWrite(6, LOW);           // se apaga el led 
    delay(100); 
    estado=0;                       // guardamos el estado apagado   
  }
  
}

Pulsa en el icono subir, y si al presionar el pulsador se enciende el led y al volverlo a pulsar se apaga … ¡Objetivo Conseguido!

Esta práctica consiste en encender una luz con un pulsador y pasado un segundo se apague.

1. ¿Qué es un led?
2. ¿Qué es un pulsador?
3. Circuito: Cómo conectar un led y un pulsador a Arduino
4. Programación con Mblock
5. Programación con Arduino IDE

1.  ¿Qué es un diodo led?

En la práctica anterior os explicamos qué es un diodo led. Puedes leerlo en: Prácticas con Arduino: Luz intermitente

2.  ¿Qué es un pulsador?

Un pulsador es un operador digital que permite el paso de corriente eléctrica cuando está pulsado. Cuando lo conectamos a un pin digital de la placa Arduino, la placa recibe una señal digital 1 cuando el pulsador se ha presionado, y recibe la señal 0 cuando el pulsador no se ha presionado.

3. Circuito: Cómo conectar un LED a Arduino

Para realizar este circuito necesitas los siguientes materiales:

• 1 Arduino UNO LOG 8431
• 1 Cable USB LOG 7509
• 1 Board LOG 886
• 1 LED LOG 722
• 1 Resistencia 220 Ohmios (rojo – rojo – marrón) LOG 748 220
• 1 Resistencia 10K Ohmios (marron – negro – naranja) LOG 748 10K
• 1 Pulsador LOG 542
• 2 Latiguillos board macho – macho LOG 7519

Para trabajar en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard.

Cuando pongas el pulsador en la board, dos patillas deben quedar en una mitad de la board y las otras dos patillas en la otra mitad, de tal forma que no estén conectadas entre sí.

El cátodo del led lo conectamos al pin 6 de Arduino y el ánodo a GND. El pulsador se conecta al pin digital 2.

¡Ya sólo nos queda programar!

Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones

• MBlock – programación basada en bloques
• Arduino IDE – programación basada en líneas de código

4. Programación con mBlock

El objetivo de este programa es muy sencillo: conseguir que el LED que hemos conectado al pin 6 se encienda cuando se presione el pulsador. El led se quedará un segundo encendido y se apagará automáticamente.

El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos«

Una vez configurada la tarjeta comenzamos con la programación. El primer bloque que necesitamos es un evento (pulsa en el círculo naranja para ver los eventos disponibles) , en este caso utilizaremos el evento «cuando clic en bandera verde«.

A continuación el programa analizará si has presionado el pulsador. Necesitamos utilizar un bloque condicional «si… entonces» que encontrarás dentro de los bloques de la sección control (círculo naranja):

La condición que debemos introducir en el bloque anterior es «haber pulsado el pulsador». Si entramos en los bloques de la sección azul Pin, verás un bloque con forma hexagonal: «lee pin digital 9«. La forma de ese bloque nos indica que podemos utilizarlo dentro de los huecos hexagonales que encontrarás en aquellos bloques que se ejecuten en base a una condición. La lectura del pin digital será verdadera si recibe un valor 1 por parte del dispositivo conectado a este pin, y será falsa si recibe un valor 0. En nuestro caso, debemos cambiar el pin 9 por el pin 2, y la condición será verdadera cuando el pin esté presionado (nos enviará un 1) y será falsa (nos enviará un valor 0) cuando no esté siendo presionado.

Si la condición es cierta, encendemos el led durante un segundo y después lo apagamos. Para encender y apagar el led utilizamos el bloque «pon el pin digital 9 en…» cambiando el número 9 por el 6:

Para que el programa funcione correctamente, la lectura del pulsador debe incluirse dentro de un bucle ya que de otra forma la ejecución del programa es tan rápida que no llegaríamos a detectar la pulsación:

Pulsa la bandera verde, y verás que funciona: cuando presiones el pulsador se enciende el led y pasado un segundo se apaga. ¡Objetivo conseguido!

5. Programación con Arduino IDE

El objetivo de este programa es muy sencillo: al presionar el pulsador el led se enciende y pasado un segundo el led se apaga … pero esta vez utilizando un lenguaje basado en líneas de código.

El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«.

Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.

Los programas en Arduino IDE constan de dos secciones: setup y loop.

En setup vamos a configurar los pines de la placa que vamos a utilizar.

pinMode(6, OUTPUT);	En el pin 6 conectamos un dispositivo de salida: el LED
pinMode(2, INPUT);	En el pin 12 conectamos un dispositivo de entrada: el pulsador

En loop vamos a introducir el código que se va a ejecutar continuamente. Puesto que el objetivo de nuestro programa es encender el led al presionar un pulsador, en este bucle infinito realizamos la lectura del pulsador dentro de un condicional. Para realizar una lectura de un pin digital utilizamos la instrucción digitalRead(nº_de_pin):

void setup() {
  pinMode(6, OUTPUT); // Led - pin de salida
  pinMode(2, INPUT);  // pulsador - pin de entrada
}

void loop() {                  // bucle infinito

  if(digitalRead(2)){          // si el pulsado se presiona
    digitalWrite(6, HIGH);     // se enciende el led 
    delay(1000);               // se mantiene 1 segundo encendido
    digitalWrite(6, LOW);      // se apaga el led
  }

}

Pulsa en el icono subir, y si al presionar el pulsador se enciende el led … ¡Objetivo Conseguido!

La primera práctica que os proponemos es muy sencilla, consiste en conseguir que un led parpadee.

1. ¿Qué es un diodo led?
2. Circuito: Cómo conectar un led a Arduino
3. Programación con Mblock
4. Programación con Arduino IDE

1.  ¿Qué es un diodo led?

 

De forma común, conocemos el diodo led como una pequeña fuente de luz con dos terminales, uno positivo y otro negativo.

Es un pequeño tubo en cuyo interior la conducción se da en el vacío. En su interior encontraremos dos pequeños filamentos: ánodo y cátodo. Correctamente conectados a una fuente de alimentación la corriente atravesará el diodo dando lugar a su iluminación.

Podemos identificar el terminal positivo y el negativo de dos maneras:

• Observando la longitud de los terminales: el más largo es el terminal positivo y el más corto es el terminal negativo. Este método no siempre es válido, puesto que hemos podido cortar los terminales para acoplar el led al circuito.

• En ese caso, la opción que nos queda es observar el led en su interior a trasluz. Veremos en el interior del led una plaquita y un filamento. El terminal que se une a la plaquita en el ánodo (-), y el terminal que se une al filamento es el cátodo (+).

 

2. Circuito: Cómo conectar un LED a Arduino

Para realizar este circuito necesitas los siguientes materiales:

• 1 Arduino UNO LOG 8431
• 1 Cable USB LOG 7509
• 1 Board LOG 886
• 1 LED LOG 722
• 1 Resistencia 220 Ohmios (rojo – rojo – marrón) LOG 748 220
• 2 Latiguillos board macho – macho LOG 7519

Para realizar los circuitos en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard

El cátodo se conecta al pin 12 y el ánodo a un pin GND de la placa Arduino.

¡Ya sólo nos queda programar!

Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones

• MBlock – programación basada en bloques
• Arduino IDE – programación basada en líneas de código

3. Programación con mBlock

El objetivo de este programa es muy sencillo: conseguir que el LED que hemos conectado al pin 12 parpadee.

El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos«

Una vez configurada la tarjeta comenzamos con la programación. El primer bloque que necesitamos en un evento (pulsa en el círculo naranja para ver los eventos disponibles) , en este caso utilizaremos el evento «cuando click en bandera verde«. Así, cada vez que se pulse la bandera verde nuestro led debería empezar a parpadear, y parará cuando se pulse el botón rojo.

Para que el led se encienda, utilizamos el bloque «pon el pin digital 9 en alto» que encontrarás si pulsas en el círculo azul «pin». Arrastramos este bloque justo debajo del evento y los juntamos para que se unan. Puesto que el led lo hemos conectado al pin 12 de la tarjeta Arduino, modificamos el bloque cambiando el 9 por un 12.

Así, tendremos en nuestro programa el bloque «pon el pin digital 12 en alto» cuya función es «encender» cualquier dispositivo digital que hayamos conectado al pin 12 de la tarjeta Arduino, en nuestro caso un LED.

Para que el led parpadee, después de encenderse debe apagarse. Utilizamos el mismo bloque, pero en lugar de poner «en alto» ponemos «en bajo«.

Hasta ahora hemos conseguido un parpadeo… que se realiza demasiado rápido, por lo que a penas podemos detectarlo. Introducimos un par de pausas en nuestro programa, de tal forma que después de encender el led, éste se queda encendido medio segundo, y después de apagarlo, se mantiene también medio segundo apagado. Si pulsas en el círculo naranja oscuro «control» encontrarás el bloque espera 1 segundo. Colócalo después de encender y apagar el led y modifica el 1 por 0.5.

Si pulsas en la bandera verde observarás que sólo parpadea 1 vez. Nosotros queremos que ese parpadeo sea continuo. Para ello necesitamos un bucle que haga que nuestro programa se ejecute constantemente. En los bloques de la sección control, encontrarás «para siempre«. Incorpóralo en tu programa.

Pulsa en la bandera verde y verás como tu led parpadea. ¡Objetivo conseguido!

4. Programación con Arduino IDE

El objetivo de este programa es muy sencillo: conseguir que el LED que hemos conectado al pin 12 parpadee… pero esta vez utilizando un lenguaje basado en líneas de código.

El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«.

Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.

Los programas en Arduino IDE constan de dos secciones: setup y loop.

En setup vamos a configurar los pines de la placa que vamos a utilizar.

pinMode(12, OUTPUT);	Establece que en el pin 12 vamos a conectar un dispositivo de salida (ej, un LED)
pinMode(12, INPUT);	Establece que en el pin 12 vamos a conectar un dispositivo de entrada (ej, un pulsador)

En nuestro caso vamos a configurar el pin 12 como un pin de salida:

En loop vamos a introducir el código que se va a ejecutar continuamente. Puesto que el objetivo de nuestro programa es que el led parpadee vamos a utilizar las siguientes líneas:

digitalWrite(12, HIGH);	Enciende el Led conectado al pin 12
digitalWrite(12, LOW);	Apaga el Led conectado al pin 12
delay(500);	Realiza una pausa de medio segundo

Como comentamos anteriormente, el programa realizará la siguiente secuencia:

• Encenderemos el led
• Realizamos una pausa de medio segundo donde el led se mantiene encendido
• Apagaremos el led
• Realizaremos una pausa de medio segundo durante la cual el led se mantendrá apagado
• Este código lo incluimos en un bucle infinito (loop)

Aquí tienes el código completo, introdúcelo en tu placa y pruébalo:

void setup() {
    pinMode(12, OUTPUT);
}

void loop() {
  digitalWrite(12, HIGH);
  delay(500);
  digitalWrite(12, LOW);
  delay(500);
}

Pulsa en el icono subir, y si tu led parpadea … ¡Objetivo Conseguido!

Cuando trabajamos con una protoboard tenemos que tener claras las conexiones que hay entre sus perforaciones. La placa está divida en dos como marca la línea morada de la siguiente imagen:

Las perforaciones de la mitad inferior no están comunicadas con las perforaciones de la mitad superior. Centrándonos en la mitad inferior, las perforaciones de una misma columna están comunicadas mientras que perforaciones de columnas diferentes no. Así, si conectas dos latiguillos en una misma columna, estarán conectados como si estuviesen unidos por ese extremo.

Las filas + y -, al contrario que en las columnas numeradas, están unidas en horizontal. Se utilizan para conectar las tomas GND y 5V de la placa Arduino con los componentes del circuito.

Si en algún momento necesitamos unir las perforaciones de ambas mitades, tendremos que introducir algún cable que una las columnas que queremos conectar:

Si conectamos un latiguillo desde una perforación de la columna 5 a la columna 6, todas las perforaciones de ambas columnas quedarán unidas.

Para programar Arduino UNO con el software Arduino IDE debemos seguir estos pasos:

• Conecta la tarjeta al puerto USB del ordenador y abre el programa Arduino IDE
• A continuación pulsa en el menú herramientas > placa y selecciona Arduino Genuino / Uno

• Después selecciona el puerto COM correspondiente a la placa Arduino Uno. (Herramientas < Puerto)

• Probamos que el ordenador está reconociendo bien la tarjeta. Para ello Pulsamos el botón Subir (segundo icono debajo del menú: la flechita).

 

Si la placa se comunica correctamente con el ordenador, aparecerá en la parte inferior de la pantalla, sobre la franja verde, el mensaje «Subido«. Si hay algún problema de comunicación obtendremos un mensaje de error sobre una franja roja.