Ya podemos decir que nuestro proyecto está completo.
Pero… ¿Por qué no personalizarlo un poco más? ¿Por qué no aprovechar lo que ya tenemos hecho para conseguir que sea todavía mejor?
Hoy vamos a conocer dos nuevos componente que pueden servir para que nuestro proyecto sea más visual:
No teneis que utilizarlos si no quereis o podeis utilizarlos de forma distinta a los ejemplos.
¿Qué es y cómo funciona un LED RGB?
¿Qué es y cómo funciona una pantalla LCD?
¡Sois libres de crear todo lo que se os ocurra!
Para cuando termine el día de hoy teneis que tener montado el proyecto final, con la parte artística incluida, y tiene que funcionar todo.
¿Qué es y cómo funciona un LED RGB?
Como ya dijimos el DÍA 3, un LED es un diodo que nos permite emitir luz.
¿Qué tiene de especial un LED RGB? Que puede lucir en cualquier color.
Para conseguir que el LED RGB pueda lucir en cualquier color se utiliza la física y en modelo aditivo de colores primarios, gracias al cual podemos formar cualquier color combinando los colores R (Red), G (Green) y B (Blue) con distintas intensidades.
Por eso el LED RGB tiene cuatro patillas: La primera es la pantilla del rojo (R). La segunda, y más larga, es la patilla que tenemos que conectar a tierra (GND). La tercera es la patilla del azul (B). La cuarta es la patilla del verde (G).
Para que funcione hay que conectar el LED RGB a pines digitales PWM (los que tienen el símbolo ~ al lado) para poder controlar la intensidad con la que lucen.
const int rgbR 9
const int rgbG 10
const int rgbB 11
Estos pines, aunque son digitales, los llamamos con la función analogWrite(led, intensidad) porque el PWM se encarga de que los pines digitales (que solo pueden indicar si/no o todo/nada) funcionen de forma similar a un analógico (que puede indicar valores intermedios)
Los valores que puede tomar cada uno de los colores de los LEDs es de 0 a 255. En este ejemplo solamente luciría la luz azul:
Si queremos que se apague el LED tenemos que poner los tres colores a 0.
¿Qué es y cómo funciona una pantalla LCD?
Una pantalla LCD es una pantalla de retroilumnación LED que permite mostrar dos filas de 16 carácteres con los que podemos escribir texto.
LCD delantera
Realmente no vamos a aprender a conectar la pantalla LCD directamente, ya que tiene muchos pines y si la conectáramos nos quedaríamos sin pines en el Arduino para todo lo demás. Por eso vamos autilizar un controlador I2C.
LCD con I2C
El controlador I2C nos permite controlar la pantalla utilizando solamente dos cables de control (además del cable de 5v y la toma a tierra GND) a través de un tipo de comunicación entre placas llamada I2C.
Los dos cables utilizados son SCL, que se conecta al pin analógico A5, y SDA, que se conecta al pin analógico A4:
SCL envía señales de reloj (clock), que se encargan de decidir quién habla en cada momento, para evitar conflictos y SDA envía los datos.
Esquemático de conexión LCD a Arduino uno
Para poder utilizar al pantalla con I2C tenemos que descargarnos una librería de Arduino llamada <LiquidCrystal_I2C.h> que tenecesita otra llamada <Wire.h>. Podéis descargarla aquí.
NOTA: Las librerías son como funciones creadas por otras personas y que nosotras podemos aprovechar y utilizar siempre que lo necesitemos.
Al trabajar con funciones de la líbrería descargada, a las que no les hemos puesto el nombre nosotras, tenemos que acostrumbrarnos y entnecer lo que hacen. Un ejemplo de cómo utilizar el código sería:
//Incluimos las librerias
#include
#include
//Inicializamos la pantalla. Tiene 16 caracteres y 2 líneas.
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
.
.
.
//Activar pantalla
lcd.init();
//Encender luz
lcd.backlight();
}
void loop(){
.
.
.
pantalla();
.
.
.
}
pantalla (){
//Colocar el cursor en la primera posición de la primera fila
lcd.setCursor(0, 0);
//Escribimos
lcd.print("Bajas: ");
//Colocar el cursor en la octaba posición de la primera fila.
lcd.setCursor(8, 0);
//Se escribirá lo que valga la variable bajas.
lcd.print(bajas);
//Colocar el cursor en la primera posición de la segunda fila
lcd.setCursor(0, 1);
//Escribimos
lcd.print("Escaparon: ");
////Colocar el cursor en la onceava posición de la segunda fila.
lcd.setCursor(11, 1);
//Se escribirá lo que valga la variable escaparon.
lcd.print(escaparon);
delay(2500);
lcd.clear();
}
¡Dónde, cómo y qué escribir en el código de la función pantalla() es cosa vuestra!
RETO DIARIO
Hoy no hay más reto diario que el que vosotras mismas os propongais.
¿Mi recomendación? Dejadlo todo preparado y bonito, grabad un vídeo en el que se vea lo bien que funciona todo y LUEGO añadidle cosas nuevas. ¿Por qué? Porque mañana vais a tener que preparar los vídeos que luego expondréis el viernes y ¡tienen que quedar perfectos!
¡En informática es normal que un día funcione todo y que al hacer una pequeña modificación de repente TODO deje de funcionar, y no queremos que eso ocurra sin que nos quede tiempo para solucionarlo!
¿Estáis preparadas para dejar lista una versión básica del juego?
Ayer nos quedamos con la ampliación que proponía el reto diario: Hacer funcionar 4 LEDs y 4 fotoresistencias a la vez.
Solución del RETO 2.1:
//Inicializamos los LEDs en los pines digitales 7, 8, 12, 13.
const int led0 = 7;
const int led1 = 8;
const int led2 = 12;
const int led3 = 13;
//Inicializamos las fotoresistencia en los pines analógicos A0, A1, A2, A3.
const int foto0 = A0;
const int foto1 = A1;
const int foto2 = A2;
const int foto3 = A3;
//Creamos una variable límite que es la que va decidir cual es el límite entre estar recibiendo luz o no. El valor del límite depende del la luz que haya en el ambiente, así que tendremos que hacer pruebas.
const int limite = 100;
//Inicializamos el zumbador en el pin digital con pwm (~) 9.
cont int zumb = 9;
// Recordatorio: setup() solo lo va a leer el arduino cuando se encienda, nunca más.
void setup() {
Serial.begin(9600);
// Definimos los pines de los LEDs como pines de salida (OUTPUT), porque les vamos a mandar la información de que se enciendan o se apaguen.
pinMode(led0 , OUTPUT);
pinMode(led1 , OUTPUT);
pinMode(led2 , OUTPUT);
pinMode(led3 , OUTPUT);
// Definimos los pines de las fotoresistencias como pines de entrada (INPUT), porque les van a mandar información sobre como se encuentran al arduino.
pinMode(foto0 , INPUT);
pinMode(foto1 , INPUT);
pinMode(foto2 , INPUT);
pinMode(foto3 , INPUT);
//Encendemos los LEDs.
digitalWrite(led0,HIGH);
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
}
// Recordatorio: loop() lo lee el arduino en bucle hasta que se apague.
void loop(){
//Si el valor que leemos de la fotoresistencia es mayor que el límite es porque le está dando la luz del laser y por tanto queremos que se apague.
if (analogRead(foto0) > limite)
{
// Escribimos en el pin digital de nuestro LED el valor LOW, que hace que se apague.
digitalWrite(led0,LOW);
// Hacemos sonar durante 300ms el tono de 523Hz.
tone(zumb, 523, 300);
}
if (analogRead(foto1) > limite)
{
digitalWrite(led1,LOW);
tone(zumb, 523, 300);
}
if (analogRead(foto2) > limite)
{
digitalWrite(led2,LOW);
tone(zumb, 523, 300);
}
if (analogRead(foto3) > limite)
{
digitalWrite(led3,LOW);
tone(zumb, 523, 300);
}
}
Vídeo de solución del reto 2.1:
Hoy vamos hacer dos cosas, la segunda será programar la lógica base del juego:
¿Cómo se van a encender y apagar os LEDs? Hasta ahora todos los LEDs se encendían al principio y se apagaban cuando les disparábamos, pero vamos a pasar a que se enciendan y apaguen de forma aleatoria.
¿Cuándo vamos a perder? Cuando se nos escapen 5 enemigos.
Pero la primera va a consistir en dejar más bonito nuestro código (y también más facil de leer y de entender) gracias a la magia de las funciones.
¿Cómo vamos a hacer todo esto? Muy sencillo:
La magia de las funciones
Primero un ejemplo muy sencillo de funciones: Vamos a crear unas funciónes llamadas apagarLED(led_que_queremos_apagar) y encenderLED(led_que_queremos_encender) para no tener que utilizar digitalWrite(led,HIGH) y digitalWrite(led,LOW) siempre.
¿Cómo funcionan las funciones? Cada vez que necesitemos utilizar la función digitalWrite(led,HIGH) escribiremos apagarLED(led_que_queremos_apagar) en su lugar.
¿Cómo sabe el programa lo que tiene que tiene que hacer al leer apagarLED(led_que_queremos_apagar)? Porque en la parte final del código, debajo del loop(), tenemos que describir lo que hacen las funciones que vayamos creando.
// La función encenderLED enciende el LED que le digamos entre paréntesis.
void encenderLED(int led){
digitalWrite(led,HIGH);
}
//La función apagarLED apaga el LED que le digamos entre paréntesis.
void apagarLED(int led){
digitalWrite(led,LOW);
}
El cambio de digitalWrite(led,LOW) a apagarLED(led) es muy pequeño, solo nos ha servido para traducir a una línea de código, pero las funciones están pensadas para poder simplificar grandes códigos escribiéndolos en sitios que no sean el bucle principal, de esta forma el código es más facil de enteder.
Ahora vamos a cambiar toda la parte del loop(), que en la resolución del reto se ve bastante grande, por esto:
void loop(){
disparando();
}
Ese disparando() es una función.
Y todo lo que antes estaba en el Ioop() ahora va a estar dentro de la función disparando() que vamos a escribir al final del código (debajo de loop).
void disparando(){
if (analogRead(foto0) > limite){
apagarLED(led0);
tone(zumb, 523, 300);
}
if (analogRead(foto1) > limite){
apagarLED(led1);
tone(zumb, 523, 300);
}
if (analogRead(foto2) > limite){
apagarLED(led2);
tone(zumb, 523, 300);
}
if (analogRead(foto3) > limite){
apagarLED(led3);
tone(zumb, 523, 300);
}
}
¿Cómo se van a encender y apagar los LEDs?
Hasta ahora todos los LEDs se encendían al principio y se apagaban cuando les disparábamos, pero vamos a pasar a que se enciendan y apaguen de forma aleatoria.
Para eso vamos a utilizar la función random(min,max), una función que devuelve un valor entre el valor mínimo y el máximo que le indiquemos. Por ejemplo: Si yo pongo int numero =random(0,100), en la variable numero se va a guardar un número entre el 0 y el 100.
Así que, lo primero que tendremos que hacer para poder encender los LEDs de forma aleatoria, es borrar el trozo de código que hacía que se encendieran todos los LEDs al principio.
Después creamos un contador, podemos llamarle contador, que se va a encargar de que no se encienda o apague un led cada vez que el arduino lea el blucle loop(), porque tenemos que recordar que el arduino lee el código de loop() muchas veces en un segundo.
Cada vez que el arduino entre en el código disparando() vamos a aumentar el valor del contador al final.
void disparando(){
if (analogRead(foto0) > limite){
apagarLED(led0);
}
if (analogRead(foto1) > limite){
apagarLED(led1);
}
if (analogRead(foto2) > limite){
apagarLED(led2);
}
if (analogRead(foto3) > limite){
apagarLED(led3);
}
//Poner contador++ es equivalente a poner contador=contador+1. Aumentando así el valor del contador en una unidad.
contador++;
}
NOTA: El contador hay que inicializarlo al principio del código.
int contador = 0;
¿Cómo quedaría el bucle loop()? Al entrar en él, lo primero que haría el programa es leer lo que pone en la función disparando(). Depués miraría el contador, y si el valor que tiene es mayor que 5000 ponemos el contador a 0, para que todo vuelva a empezar, y el programa lee la función encenderapagarLEDaleatorio().
¿Qué pasa si el contador es menor que 5000? No pasa nada, el bucle vuelve a empezar y el programa vuelve a leer lo que haya dentro de la función disparando().
De esta forma, solo 1 de cada 5000 veces que se lea el bucle loop() se va a entrar en la función que permite encender y apagar los LEDs. Si en vez de 5000 ponemos un número más grande, los LEDs se encenderán y apagarán más despacio.
Ahora vamos a programar la función encenderapagarLEDaleatorio() que va a encargarse de encender y apagar los LEDs de forma aleatoria. [El nombre es bastante descriptivo].
¿Cómo va a funciónar? Le vamos a decir que elija un número aleatorio entre 0 y 4 (para que de de resultado los números que tienen asignados nuestros leds y nuestras fotoresistencias): Si el led elegido está encendido, queremos que lo apague. Si el led elegido está apagado, queremos que lo encienda.
Pero, ¿cómo sabemos si el led está encendido o apagado? Con un tipo de dato llamado bool, que puede estar a true o a false, inicializamos una variable para cada LED:
Lo ponemos a false al inicializarlo porque al principio los LEDs van a estar apagados.
NOTA: Cada vez que encendamos un LED hay que escribir encendidoX=true y cada vez que apaguemos un LED hay que escribir encendidoX=false, para que la lógica de todo el juego tenga sentido.
¿Cómo quedaría la función disparando()?
void disparando(){
if (analogRead(foto0) > limite){
apagarLED(led0);
encendido0 =false;
}
if (analogRead(foto1) > limite){
apagarLED(led1);
encendido1 =false;
}
if (analogRead(foto2) > limite){
apagarLED(led2);
encendido2 =false;
}
if (analogRead(foto3) > limite){
apagarLED(led3);
encendido3 =false;
}
//Poner contador++ es equivalente a poner contador=contador+1
contador++;
}
¿Cómo quedaría el código de la función encenderapagarLEDaleatorio()?
Al empezar la función se tiene que generar un número aleatorio, que es el que va a decidir qué led se enciende o apaga. Una vez decidido el led, si está encendido se apaga y si esta apagado se enciende.
void encenderapagarLEDaleatorio(){
//Elegimos el LED de forma aleatoria.
int n = random(0,4);
// Si toca el LED 0:
if (n == 0){
if (encendido0){
apagarLED(led0);
encendido0 = false;
}else {
encenderLED(led0);
encendido0 = true;
}
}
// Si toca el LED 1:
if (n == 1){
if (encendido1){
apagarLED(led1);
encendido1 =false;
}else {
encenderLED(led1);
encendido1 = true;
}
}
// Si toca el LED 2:
if (n == 2){
if (encendido0){
apagarLED(led2);
encendido2 =false;
}else {
encenderLED(led2);
encendido2 = true;
}
}
// Si toca el LED 3:
if (n == 3){
if (encendido3){
apagarLED(led3);
encendido3 =false;
}else {
encenderLED(led3);
encendido3 = true;
}
}
}
¿Cuándo vamos a perder?
Cuando se nos escapen 5 enemigos.
¿Cómo vamos a saber cuántos enemigos se han escapado? Vamos a tener una variable parecida a contador llamada «escaparon» y cada vez que el programa apague un LED de forma aleatoria, y no porque nosotras le hayamos disparado, va a aumentar en uno (1) el valor de «escaparon«.
int escaparon = 0;
¿Cómo le decimos al programa que el juego termina cuando se escapen cinco (5) enemigos? Al principio del bucle loop() ponemos la condición de que solo se pueda jugar si el número de enemigos es menor a cinco (5).
Si el número de enemigos que se han escapado es mayor que 5 (cinco) los LEDs se apagan y termina el juego.
Código final:
const int led0 = 7;
const int led1 = 8;
const int led2 = 12;
const int led3 = 13;
const int foto0 = A0;
const int foto1 = A1;
const int foto2 = A2;
const int foto3 = A3;
const int limite = 100;
const int zumb = 9;
int contador = 0;
int escaparon = 0;
bool encendido0 = false;
bool encendido1 = false;
bool encendido2 = false;
bool encendido3 = false;
// Recordatorio: setup() solo lo va a leer el arduino cuando se encienda, nunca más.
void setup() {
Serial.begin(9600);
pinMode(led0 , OUTPUT);
pinMode(led1 , OUTPUT);
pinMode(led2 , OUTPUT);
pinMode(led3 , OUTPUT);
pinMode(foto0 , INPUT);
pinMode(foto1 , INPUT);
pinMode(foto2 , INPUT);
pinMode(foto3 , INPUT);
}
// Recordatorio: loop() lo lee el arduino en bucle hasta que se apague.
void loop(){
// ¿Estamos disparando a nuestros enemigos? Pues tenemos una función que se encarga de apagar el LED que corresponda en caso de que acertemos en el enemigo.
if (escaparon < 5){
disparando();
if (contador > 5000) {
contador = 0;
encenderapagarLEDaleatorio();
}
} else{
apagarLED(led0);
apagarLED(led1);
apagarLED(led2);
apagarLED(led3);
}
}
void disparando(){
if (analogRead(foto0) > limite){
apagarLED(led0);
tone(zumb, 523, 300);
encendido0 = false;
}
if (analogRead(foto1) > limite){
apagarLED(led1);
tone(zumb, 523, 300);
encendido1 = false;
}
if (analogRead(foto2) > limite){
apagarLED(led2);
tone(zumb, 523, 300);
encendido2 = false;
}
if (analogRead(foto3) > limite){
apagarLED(led3);
tone(zumb, 523, 300);
encendido3 = false;
}
contador++;
}
void encenderLED(int led){
digitalWrite(led,HIGH);
}
//La función apagarLED apaga el LED que le digamos entre paréntesis y hace sonar el zumbador.
void apagarLED(int led){
digitalWrite(led,LOW);
}
void encenderapagarLEDaleatorio(){
int n = random(0,4);
if (n == 0){
if (encendido0){
apagarLED(led0);
escaparon ++;
encendido0 =false;
}else {
encenderLED(led0);
encendido0 = true;
}
}
if (n == 1){
if (encendido1){
apagarLED(led1);
encendido1 =false;
escaparon ++;
}else {
encenderLED(led1);
encendido1 = true;
}
}
if (n == 2){
if (encendido0){
apagarLED(led2);
encendido2 =false;
escaparon ++;
}else {
encenderLED(led2);
encendido2 = true;
}
}
if (n == 3){
if (encendido3){
apagarLED(led3);
encendido3 =false;
escaparon ++;
}else {
encenderLED(led3);
encendido3 = true;
}
}
}
De la misma forma que se pone una variable escaparon para contar hasta 5 (cinco) y poder decir que hemos perdido, también se puede añadir una variable victoria que cuente hasta 20 (veinte).
Tenéis para entregar las soluciones de los retos hasta hoy antes de las 21:30 en el drive como todos los días.
¿Estáis preparadas para empezar con el proyecto? Pero antes:
Solución del RETO 1:
El reto propuesto consistía en que nuestro semáforo tenía que durar en verde un tiempo proporcional al número de coches que hay esperando: Si había muchos coches esperando el semáforo tiene que estar mucho rato en verde para que puedan pasar todos.
int rojo = 6;
int amarillo = 7;
int verde = 8;
// Inicializamos la variable coches, en la que vamos a escribir los coches que hay esperando.
int coches = 0;
void setup() {
pinMode (rojo , OUTPUT);
pinMode (amarillo , OUTPUT);
pinMode (verde , OUTPUT);
//Inicializamos la semilla del random al valor que se lea del pin analogico 0, para que sea distinta cada vez que empiece el programa.
randomSeed(analogRead(0));
}
void loop()
{
// Guardamos en la variable coches el valor resultante de hacer el random.
coches = random(1,6);
digitalWrite(rojo,HIGH);
delay(2000);
digitalWrite(rojo,LOW);
delay(50);
digitalWrite(verde,HIGH);
// Multiplicamos el numero de coches que hay esperando a que el semáforo se ponga en verde por el tiempo que tarda en pasar un coche, para que puedan pasar todos.
delay(2000*coches);
digitalWrite(verde,LOW);
delay(50);
digitalWrite(amarillo,HIGH);
delay(500);
digitalWrite(amarillo,LOW);
delay(50);
}
Hoy vamos a aprender cómo funcionana cada unos de los componentes que vamos a utilizar luego en el proyecto:
¿Qué es y cómo funciona un LED?
¿Qué es y cómo funciona una fotoresistencia?
¿Qué es y cómo funciona un zumbador?
Además, cuando termine el día ya podremos desarrollar un primer mini-programa en el que se va a basar el Laser Tag definitivo. Este primer mini-programa va a encender 4 LEDs y para que nosotras los apaguemos, con efecto musical incluido, con nuestro laser .
¿Cómo vamos a hacer todo esto? Muy sencillo:
¿Qué es y cómo funciona un LED?
Ya estuvimos viendo como funciona un led en la entrada anterior, pero aquí teneis la información un poco más detallada:
Un LED es un diodo que nos permite emitir luz.
¿Por qué es importante saber que es un diodo? Porque una característica de los diodos es que tiene polaridad, lo que significa que solo deja pasar la corriente en un sentido. Por eso una de las patillas del LED es más larga que la otra.
La patilla larga se debe conectar al pin que le va a proporcionar la información al LED de cuándo tiene que encenderse o apagarse, y la otra a tierra (GND) .
Pero no podemos conectar directamente la patilla larga del LED al pin de arduino porque ese pin le va a aportar demasiada intensidad y el LED, y con el tiempo la placa Arduino, podrían estropearse. Para que no le llegue tanta intensidad utilizamos resistencias.
Una vez que hayamos colocado el led y la resistencia de 220 ohm, nos quedaré un circuito parecido a este:
conexión de un led a Arduino
Podemos ver paso a paso como se hace en el siguiente video:
Programando un LED:
Cuando escribimos código, todo lo que está puesto detrás de // son notas que el programa se salta y que nosotras podemos aprovechar para añadirle información a nuestro código.
Este ejemplo enciende y apaga el led.
//Inicializamos el led en el pin 2.
const int led = 2;
// Recordatorio: setup() solo lo va a leer el arduino cuando se encienda, nunca más.
void setup() {
// Tenemos que inicializar el puerto serie, es el que permite enviar la información al monitor serie de arduino.
Serial.begin(9600);
// Definimos el pin del LED como pin de salida (OUTPUT), porque le vamos a mandar la información de que se encienda o se apague.
pinMode(led , OUTPUT);
}
// Recordatorio: loop() lo lee el arduino en bucle hasta que se apague.
void loop(){
// Escribimos en el pin digital de nuestro LED el valor HIGH, que hace que se encienda.
digitalWrite(led , HIGH);
// delay(tiempo) hace que el arduino se espere un tiempo antes de seguir.
delay(1000);
// Luego escribimos el valor LOW, que hace que se apague.
digitalWrite(led , LOW);
delay(1000);
}
video programando un led
¿ Qué es y cómo funciona una fotoresistencia?
Una fotorresistencia es un dispositivo al que le varia la resistencia dependiendo de la cantidad de luz que reciba.
Nosotras vamos a aprovecharnos de eso utilizándolo como un interruptor. Un interruptor especial que solo podemos activar con luz, es decir, con nuestro láser.
Las fotorresistencias tienen las dos patillas igual de largas porque da igual cual de las dos usemos para proporcionarle energía y cual para conectarla a tierra (GND), porque funciona exactamente igual que las resistencias que hemos utilizado para los LEDs.
De hecho, para poder conectar una fotorresistencia también vamos a necesitar una resistencia extra, pero mucho mayor que la utilizada para los LEDs, esta va a ser de 10 Kohm.
Una vez que hayamos colocado la fotorresistencia y la resistencia de 10 Kohm, nos quedará un circuito parecido a este:
conexión fotorresistencia
Podemos ver el proceso de conexión en el siguiente vídeo:
Programando una fotorresistencia o sensor de luz:
Este ejemplo apaga el led cuando detecta luz en la fotorresistencia.
//Inicializamos el led en el pin digital 2.
const int led = 2;
//Inicializamos la fotorresistencia en el pin analógico A0.
const int foto = A0;
//Creamos una variable límite que es la que va decidir cual es el límite entre estar recibiendo luz o no. El valor del límite depende de la luz que haya en el ambiente, así que tendremos que hacer pruebas.
const int limite = 100;
// Recordatorio: setup() solo lo va a leer el arduino cuando se encienda, nunca más.
void setup() {
Serial.begin(9600);
// Definimos el pin del LED como pin de salida (OUTPUT), porque le vamos a mandar la información de que se encienda o se apague.
pinMode(led , OUTPUT);
// Definimos el pin de la fotorresistencia como pin de entrada (INPUT), porque le va a mandar información sobre como se encuentra al arduino.
pinMode(foto , INPUT);
}
// Recordatorio: loop() lo lee el arduino en bucle hasta que se apague.
void loop(){
//Esperamos un segundo y encendemos el led para poder probar el programa más de una vez.
delay(1000);
digitalWrite(led,HIGH);
//Si el valor que leemos de la fotorresistencia es mayor que el límite es porque le está dando la luz del láser y por tanto queremos que se apague.
if (analogRead(foto) > limite)
{
// Escribimos en el pin digital de nuestro LED el valor LOW, que hace que se apague.
digitalWrite(led,LOW);
}
}
Aquí tenéis un vídeo de como se programa y de la ejecución final:
¿Qué es y cómo funciona un zumbador?
Los zumbadores, buzzers o altavoces pasivos permiten convertir una señal eléctrica en una onda de sonido.
Nuestro zumbador va a tener 3 patillas:
La primera, y mas cercana al dibujito de una S, es la que le manda la información al buzzer, y va a tener que estar conectada a un pin digital que tenga pwm (~).
La siguiente es la que le proporciona energía, y va a tener que estar conectada a los 5V.
La última es la toma a tierra (GND).
Una vez que hayamos colocado cada uno de los pines en su lugar correspondiente, nos quedaré un circuito parecido a este:
Conexión Zumbador o buzzer
Programando un zumbador:
Este ejemplo apaga el led cuando detecta luz en la fotorresistencia y hace que suene el zumbador.
//Inicializamos el led en el pin digital 2.
const int led = 2;
//Inicializamos la fotorresistencia en el pin analógico A0.
const int foto = A0;
//Creamos una variable límite que es la que va decidir cual es el límite entre estar recibiendo luz o no. El valor del límite depende del la luz que haya en el ambiente, así que tendremos que hacer pruebas.
const int limite = 100;
//Inicializamos el zumbador en el pin digital con pwm (~) 9.
cont int zumb = 9;
// Recordatorio: setup() solo lo va a leer el arduino cuando se encienda, nunca más.
void setup() {
Serial.begin(9600);
// Definimos el pin del LED como pin de salida (OUTPUT), porque le vamos a mandar la información de que se encienda o se apague.
pinMode(led , OUTPUT);
// Definimos el pin de la fotorresistencia como pin de entrada (INPUT), porque le va a mandar información sobre como se encuentra al arduino.
pinMode(foto , INPUT);
}
// Recordatorio: loop() lo lee el arduino en bucle hasta que se apague.
void loop(){
//Esperamos un segundo y encendemos el led para poder probar el programa más de una vez.
delay(1000);
digitalWrite(led,HIGH);
//Si el valor que leemos de la fotorresistencia es mayor que el límite es porque le está dando la luz del láser y por tanto queremos que se apague.
if (analogRead(foto) > limite)
{
// Escribimos en el pin digital de nuestro LED el valor LOW, que hace que se apague.
digitalWrite(led,LOW);
// Hacemos sonar durante 300ms el tono de 523Hz.
tone(zumb, 523, 300);
}
}
Vídeo de programación del buzzer:
RETO DIARIO
¡El reto de hoy consiste en unir todo lo que hemos aprendido!
Hasta ahora solo tenemos un led, un zumbador y una fotorresistencia funcionado juntas, pero si nuestro juego solo tiene un posible enemigo va a ser muy aburrido.
RETO 2.1: Hacer funcionar el juego con 4 LEDs y 4 fotorresistencias.
Cada LED va a estar unido a una fotorresistencia de manera que acertando con el láser en la fotorresistencia 1 se apague el LED 1.
RETO 2.2: Hacer una canción de la victoria y otra de la derrota con el zumbador (buzzer).
Esta parte del reto la podremos utilizar mañana para cuando en nuestro juego se pueda ganar y perder.
Tenéis para entregar las soluciones de los retos hasta hoy antes de las 21:30 en la carpeta del Drive que creásteis el otro día con el nombre de Reto2.
¡Voy a hacer mi primer proyecto con Arduino! Pero… ¿Por dónde empiezo?
No te preocupes, al igual que pasa con muchas otras cosas en nuestro día a día, la pregunta de ¿Por dónde empiezo? es común a la hora de ponernos a programar.
Lo bueno es que la respuesta es bien sencilla: Por el final.
¿Qué quiero que haga mi programa?
Esta es la primera pregunta que tenemos que hacernos cuando vamos a programar, y aunque la pregunta es sencilla no es fácil de responder. ¿Por qué? Porque tenemos que dejar claro absolutamente todo lo que queremos que haga el programa, cómo queremos que lo haga y cuál es la mejor forma para conseguirlo.
Después de haber elaborado un guión de todo lo que hay que hacer para que nuestro proyecto funcione solo queda ir pasito a pasito (función a función) creando nuestro código.
Descarga e instalación del IDE de Arduino
Antes de meternos en faena con la programación necesitamos la herramienta básica para poder escribir nuestro programa. Sigue los pasos del siguiente vídeo y ¡estarás lista para comenzar!
PRIMER PROGRAMA: SEMÁFORO.
Vamos a crear un semáforo, así que pensamos en la primer pregunta que tenemos que hacernos cuando empezamos un programa, ¿qué va a hacer mi programa?
Lógica: Primero tendremos encendida la luz roja durante unos segundos, luego se apagará y se encenderá la luz verde durante otros cuantos segundos, después se apagará también para que se encienda la naranja durante un par de segundos, y por último volverá a lucir la luz roja.
Estructura: Como las luces se van a ir encenciendo y apagando una detrás de otra lo único que tenemos que tener en cuenta de la estructura es que primero va la luz roja, luego la verde y finalmente la naranja, antes de volver a la rojal.
Ya tenemos la lógica y también sabemos cómo lo vamos a hacer, toca pensar en los materiales que utilizaremos.
Materiales: Siempre vamos a necesitar la placa, en este caso Arduino uno, el cable para poder programarla y cables para poder conectar los componentes a los pines. Además, y esto ya específico de nuestro mini-proyecto, nesitaremos tres LEDs (rojo, amarillo y verde).
Ya hemos pensado suficiente cómo va a ser nuestro proyecto, es hora de implementarlo:
El primer paso es nombrar las variables que vamos a utilizar y asignarles el pin al que las hemos conectado. IMPORTANTE: Ya que les estamos poniendo nombre, vamos a intentar que estos nombres tengan sentido porque, aunque es gracioso ponerle patata a una variable, también es muy probable que se nos olvide que nos estábamos refiriendo a la variable LedRojo.
int LedRojo = 6;
int LedAmarillo = 7;
int LedVerde = 8;
El siguiente paso es inicializarlas dentro del setup().
Inicializamos como pines OUTPUT los pines a los que la placa les tiene que enviar información. Como ejemplo perfecto tenemos el LED, porque la placa tiene que mandarle la información de si le toca estar encendido o apagado.
Inicializamos como pines INPUT los pines de los que la placa recibe información. Un ejemplo perfecto sería un sensor, porque la placa recibe de él la información y actua en consecuencia.
Para encender y apagar los LEDs utilizamos la función digitalWrite(nombre_led, HIGH/LOW), HIGH para encenderlo y LOW para apagarlo.
Las funciones delay(tiempo) nos permiten elegir el tiempo que está encendido o apagado cada uno de los LEDs.
RETO DIARIO
Tal y como indica el nombre de este apartado cada día se propondrán unos retos para que comprobéis, no solo si habéis entendido toda la explicación, sino para además poner a prueba algo muy importante: vuestra capacidad para buscar información. Constantemente utilizamos conocimientos que otras personas aprendieron antes que nosotros y tenemos que aprovechar la gran ventaja que es tener internet para aprender cosas de forma autodidacta.
Todos los retos se resolverán mañana y si vuestras propuestas con correctas podríais terminar ganando alguna que otra recompensa.
Reto 1: Nuestro semáforo durará en verde un tiempo proporcional al número de coches que hay esperando.
Hemos colocado una cámara que nos dice cuantos coches hay esperando a que el semáforo se ponga en verde. Para que les de tiempo a pasar, el semáforo permanecerá en verde dos segundos por cada coche que haya esperando, pero no más de 10 segundos porque sino los peatones se cabrean.
Para saber cuantos coches hay esperando se utiliza una función llamada random(), busca información sobre ella.
Teneis para tentregar las soluciones de los retos hasta hoy antes de las 21:30 en el correo osl@ugr.es
