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.
Conectamos los componentes a los siguientes pines de la placa Arduino:
12 – Led rojo
A0 – LDR
¡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
2. Programación con mBlock
El objetivo de este programa es muy sencillo: conseguir que los leds emulen la secuencia de un semáforo y emita un sonido cuando el tráfico esté detenido.
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.
Utilizamos el bloque «cuando clic en bandera» para iniciar el programa. Dentro ubicaremos el bloque «para siempre» para crear un bucle infinito. En él introducimos un condicional «Si… entonces…sino…» para evaluar el nivel de luz. La lectura de la LDR se realiza a través de un pin analógico, por lo que utilizaremos el bloque «leer pin analógico» para conocer la luz que está detectando. Si la lectura del pin analógico es menor que 200, encendemos el led, y si no lo mantenemos apagado.
Pulsa la bandera verde y comprueba el resultado.
3. Programación con Arduino IDE
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
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!.
void setup(){
pinMode(12, OUTPUT); // led rojo - pin de salida
}
void loop() { // bucle infinito
if (analogRead(A0)<200){ // si ldr < 200
digitalWrite(12, HIGH); // enciende el led
}
else {
digitalWrite(12, LOW); // si no apaga el led
}
}
Pulsa en el icono subir, y comprueba el resultado.
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.
Conectamos los componentes a los siguientes pines de la placa Arduino:
12 – Led rojo
11 – Led amarillo
10 – Led verde
9 – Led rojo
6 – Led amarillo
5 – Led verde
¡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
2. Programación con mBlock
El objetivo de este programa es muy sencillo: conseguir que los leds emulen la secuencia de un semáforo y emita un sonido cuando el tráfico esté detenido.
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.
Os recomendamos el uso de variables para facilitar la identificación de pines.
Utilizamos dos bloques evento «cuando clic en bandera». De cada bloque colgará el conjunto de bloques encargado de iluminar cada semáforo.
Guardamos en las variables el número del pin al que se conectó cada led. A continuación, dentro de un bucle «por siempre» introducimos los bloques que iluminarán el primer semáforo en secuencia: verde – amarillo – rojo.
A continuación en un segundo evento «al presionar bandera» introducimos la secuencia del segundo semáforo «rojo – verde – amarillo»
Sólo falta revisar las pausas para que los semáforos estén correctamente coordinados.
Pulsa la bandera verde y comprueba el resultado.
3. Programación con Arduino IDE
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
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!.
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.
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.
Conectamos los componentes a los siguientes pines de la placa Arduino:
12 – Led rojo
9 – Led amarillo
6 – Led verde
2 – Pulsador
¡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
2. Programación con mBlock
El objetivo de este programa es muy sencillo: conseguir que los leds emulen la secuencia de un semáforo y emita un sonido cuando el tráfico esté detenido.
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«.
Utilizamos un bucle infinito con el bloque «para siempre» que localizarás en la sección naranja control. Así nuestro programa se ejecutará continuamente
Dentro del bucle introducimos el bloque que encenderá el led verde.
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
Pulsa la bandera verde y comprueba el resultado.
3. Programación con Arduino IDE
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
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);
En el pin 12 conectamos un dispositivo de salida: el LED rojo
pinMode(9, OUTPUT);
En el pin 9 conectamos un dispositivo de salida: el LED amarillo
pinMode(6, OUTPUT);
En el pin 6 conectamos un dispositivo de salida: el LED verde
pinMode(2, INPUT);
En el pin 2 conectamos un dispositivo de entrada: el pulsador
Configuración de pines
En loop vamos a introducir el código que se va a ejecutar continuamente.
digitalWrite – Con esta instrucción encenderemos y apagaremos los leds
digitalRead – Con esta instrucción evaluaremos si el pulsador conectado al pin 2 se pulsó.
Podemos utilizar variables que identifiquen los pines de los leds y del pulsador para facilitar el seguimiento del código escrito.
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.
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.
Conectamos los leds y el zumbador a los siguientes pines de la placa Arduino:
12 – Led rojo
9 – Led amarillo
6 – Led verde
11 – Zumbador
¡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 los leds emulen la secuencia de un semáforo y emita un sonido cuando el tráfico esté detenido.
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«.
Utilizamos un bucle infinito con el bloque «para siempre» que localizarás en la sección naranja control. Así nuestro programa se ejecutará continuamente
La secuencia de iluminación será:
Encender el led verde durante 3 segundos
Apagar el led verde y encender el led amarillo durante 1 segundo
Apagar el led amarillo y encender el led rojo
Emitir un sonido intermitente durante 3 segundos
Apagar el led rojo
Dentro del bucle, empezamos encendiendo el led verde.
A continuación apagamos el led verde y encendemos el amarillo.
El siguiente paso es apagar el led amarillo y encender el led rojo. Añadimos un bucle para generar el sonido intermitente con el zumbador. El último paso será apagar el led rojo y volver a empezar.
Pulsa la bandera verde y comprueba el resultado.
4. Programación con Arduino IDE
Vamos a programar con líneas de código. El objetivo consiste en iluminar los leds siguiendo la secuencia de un semáforo.
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);
En el pin 12 conectamos un dispositivo de salida: el LED rojo
pinMode(9, OUTPUT);
En el pin 9 conectamos un dispositivo de salida: el LED amarillo
pinMode(6, OUTPUT);
En el pin 6 conectamos un dispositivo de salida: el LED verde
pinMode(11, OUTPUT);
En el pin 11 conectamos un dispositivo de salida: el zumbador
Configuración de pines
En loop vamos a introducir el código que se va a ejecutar continuamente. Utilizando la instrucción digitalWrite encenderemos y apagaremos los leds para conseguir la secuencia de un semáforo. Además mientras que el led rojo esté encendido, se ejecutará un bucle encargado de emitir un sonido intermitente. Podemos utilizar variables que identifiquen los pines de los leds y del zumbador para facilitar el seguimiento del código escrito.
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.
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.
Conectamos los leds a los siguientes pines de la placa Arduino:
12 – Led rojo
9 – Led amarillo
6 – Led verde
¡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 los leds emulen la secuencia de un semáforo.
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«.
Utilizamos un bucle infinito con el bloque «para siempre» que localizarás en la sección naranja control. Así nuestro programa se ejecutará continuamente
La secuencia de iluminación será:
Encender el led verde durante 3 segundos
Apagar el led verde y encender el led amarillo durante 1 segundo
Apagar el led amarillo y encender el led rojo durante s segundos
Apagar el led rojo
Dentro del bucle, empezamos encendiendo el led verde.
A continuación apagamos el led verde y encendemos el amarillo.
El siguiente paso es apagar el led amarillo y encender el led rojo.
El último paso será apagar el led rojo y volver a empezar.
Pulsa la bandera verde y comprueba que los leds emulan la secuencia de un semáforo. ¡Objetivo conseguido!
4. Programación con Arduino IDE
Vamos a programar con líneas de código. El objetivo consiste en iluminar los leds siguiendo la secuencia de un semáforo.
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);
En el pin 12 conectamos un dispositivo de salida: el LED rojo
pinMode(9, OUTPUT);
En el pin 9 conectamos un dispositivo de salida: el LED amarillo
pinMode(6, OUTPUT);
En el pin 6 conectamos un dispositivo de salida: el LED verde
Configuración de pines
En loop vamos a introducir el código que se va a ejecutar continuamente. Utilizando la instrucción digitalWrite encenderemos y apagaremos los leds para conseguir la secuencia de un semáforo. Podemos utilizar variables que identifiquen los pines de los leds para facilitar el seguimiento del código escrito.
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.
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.
Conectamos el zumbador al pin digital 12 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 zumbador suene de forma intermitente.
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«.
Utilizamos un bucle infinito con el bloque «para siempre» que localizarás en la sección naranja control. Así nuestro programa se ejecutará continuamente.
Dentro del bucle, introducimos los bloques para activar y desactivar el pin 12.
Sólo nos queda incluir una pausa para que el sonido se escuche durante un determinado tiempo.
Pulsa la bandera verde y comprueba que el zumbador suena de forma intermitente. ¡Objetivo conseguido!
4. Programación con Arduino IDE
Vamos a programar con líneas de código. El objetivo consiste en encender y apagar el zumbador de forma intermitente para que emita un sonido.
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);
En el pin 12 conectamos un dispositivo de salida: el Zumbador
Configuración de pines
En loop vamos a introducir el código que se va a ejecutar continuamente y consiste en activar y desactivar el pin 12 con una pausa después de cada acción
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!
Un pulsador es un operador digital que permite el paso de corriente eléctrica cuando está pulsado. Puedes leer más información en: Prácticas con Arduino: Luz con pulsador.
3. Circuito: Cómo conectar un LED a Arduino
Para realizar este circuito necesitas los siguientes materiales:
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 y se apague cuando se presione el pulsador. Al presionar el pulsador el led se enciende, y se mantiene encendido hasta que se vuelva a presionar el pulsador.
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«.
Utilizamos un bucle infinito con el bloque «para siempre» que localizarás en la sección naranja control. Así nuestro programa se ejecutará continuamente, para que podamos encender y apagar la luz tantas veces como queramos
A continuación utilizamos el bloque «esperar hasta que…» que localizarás entre los bloques naranjas de la sección control. La finalidad de este bloque es generar una pausa en el programa que se mantenga hasta que se cumpla la condición indicada en este bloque. En el caso de nuestro programa, la condición será que se presione el pulsador. Introducimos en la condición la lectura del pin digital 2. Dentro de la sección azul pin, localizamos el bloque «pin digital 2».
Una vez que se ha pulsado el pulsador del pin 2 procedemos a encender el Led:
A continuación el programa ser quedará esperando que se vuelva a presionar el pulsador para proceder a apagar el led:
Conviene poner dos bloques de pausa para que la placa no detecte varias pulsaciones si tardamos un poco en levantar el dedo del pulsador:
Pulsa la bandera verde, y verás que funciona: cuando presiones el pulsador se enciende el led y cuando lo vuelves a presionar 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 al pulsar de nuevo el pulsador, el led se apaga … pero esta vez utilizando un lenguaje basado en líneas de código.
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
Configuración de pines
Para realizar este programa vamos a utilizar una variable «estado» donde guardaremos el estado del led:
1 – Si el led está encendido
0 – Si el led está apagado
Esta variable la definimos antes del bloque setup.
En loop vamos a introducir el código que se va a ejecutar continuamente. En este caso tendremos dos condicionales «if»:
Si pulsas el pulsador y el led estaba apagado (led = 0), encendemos el led y cambiamos la variable de estado por 1
Si pulsas el pulsador y el led esta encendido (led = 1), apagamos el led y cambiamos la variable de estado por 0
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!
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:
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.
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
Configuración de pines
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!
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:
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.
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
Instrucciones – pin digital
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:
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.