¿Qué tal el inicio de año? Para nosotras esta siendo movidito porque tenemos muchísimas ganas de organizar y decidir todo lo que vamos a hacer en la VIII edición del campus tecnológico para chicas Seré Ingeniera. Y claro, la organización del campus no sería posible sin la financiación que las empresas nos proporcionan.

Es por eso que queremos hacer una llamada para empresas o entidades patrocinadoras. Las condiciones de patrocinio de este año, están disponibles en esta misma web en https://sereingeniera.ugr.es/index.php/patrocinadores-2021/ y te las puedes descargar desde http://sl.ugr.es/SereIngenieraPatrocinio2021.

Si nos sigues en las redes sociales o has mirado alguna vez este blog, sabrás que este campus se realiza con la intención de

fomentar las vocaciones tecnológicas en chicas de secundaria, para que conozcan que hacemos las ingenieras pero desde dentro, es decir, con nosotras mano a mano realizando un proyecto al que cada una le dará su toque diferente. Además en el campus Seré Ingeniera creamos comunidad de tal forma que las chicas sepan que no son las únicas interesadas en la tecnología facilitamos que todas las participantes puedan pasar tiempo junto a chicas de su edad y sus mismos intereses.

El campus se realiza durante dos semanas a principios de julio. Durante ese tiempo las monitoras proponen un proyecto con un hardware determinado y muestran un ejemplo de lo que se puede hacer con esos componentes y posteriormente les enseñan todo lo necesario para comprender como conectar los componentes y como programarlos. Además se les proponen una serie de retos diarios para que puedan practicar lo aprendido. Las monitoras son o han sido estudiantes de la Escuela Técnica Superior de Ingeniería Informática y Telecomunicación de Granada, sede del campus.

Para que las chicas puedan participar en el campus, buscamos financiación y de este modo, el coste para ellas sea cero. También nos encargamos de buscar a las monitoras que lo imparten y buscamos los proyectos que desarrollan, y que os iremos presentando poco a poco en este blog.

Cuando finaliza el campus, cada chica ha terminado su proyecto y ha podido ver que es capaz de hacer lo que se proponga. Además ha conocido a otras chicas interesadas en la tecnología y aunque no tenga aún claro el camino que elegirá para continuar su formación, nosotras esperamos que sepan que si quieren pueden y que la ingeniería es una de las opciones que tienen para elegir si les apasiona crear y probar cosas nuevas.

¿Quiénes nos han financiado ya en ediciones anteriores?

Esta actividad se financia con la aportación de empresas que colaboran con la Oficina de Software Libre, como lo han sido Esero , Novatec Software, PC Componentes, Unit4, Seven solutions, Nazaries IT, Conecta 13,  Financial Force,  Createc3D, y entidades como el Instituto de la Mujer y para la Igualdad de Oportunidades, además como varias unidades de la Universidad de Granada como la Unidad de Igualdad, la Escuela Técnica Superior de Ingeniería Informática y Telecomunicación de Granada, la Facultad de Educación, Economía y Tecnología de Ceuta y la Delegación de la Rectora para la Universidad Digital en su conjunto. Desde aquí, nuestro más profundo agradecimiento.

¡Síguenos también en twitter (@sereIngeniera) y mantente al tanto de las actualizaciones en nuestra web!

Como ya sabéis esta edición del campus ha sido online, la verdad es que creemos que ha sido todo un éxito. Era todo un reto para nosotras preparar el campus con tan poco tiempo, la incertidumbre de la nueva situación y con esta modalidad semipresencial pero, como ingenieras que somos, ¡hemos dado la talla!

Finalmente seleccionamos a 15 chicas para las partes presenciales en la ETSIIT que eran: la inauguración y el cierre del campus, pero hubo muchísimas más participantes que nos acompañaron durante todo el campus de manera online.

Además se retransmitieron el inicio del campus y la clausura en directo y os los dejamos por aquí por si queréis verlos.

Todas las chicas cumplieron el objetivo de, en 7 días, montar el proyecto del láser tag con arduino y la verdad es que ¡hicieron auténticas maravillas! Aquí os dejamos un vídeo con la presentación de todos y cada uno de los proyectos que hicieron las chicas de manera individual.

Además gracias al patrocinador principal de este año Esero cuatro de nuestras chicas y las tres monitoras pudieron asistir como invitadas a la final de cansat2020 y en tan solo 3 días, desde que finalizó el campus hasta el día del lanzamiento, prepararon su pequeño proyecto de satélite enlatado que fue lanzado a 1km de altura en un cohete.

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

• 

En definitiva, este año ha sido una edición un tanto especial pero, como todas las anteriores ¡ha salido genial! Las chicas estaban súper motivadas, tenían muchísimas ganas de participar. Aunque hayan estado online, desde la organización se creó un grupo de telegram con el que todas las chicas se conocieron unos días antes del inicio del campus, preguntaban dudas a las monitoras y en algunos casos se las resolvían unas a otras.

Estamos de vacaciones, pero ¡volveremos!

Feliz verano 😉

• 

Solución del RETO 4:

Antes de ayer nos quedamos con las 2 (dos) ampliación que proponía el reto diario. La primera parte del reto consistía en simplificar el bucle loop() y dejarlo así:

void loop(){
 if (escaparon < 5){
    jugar();       
  } else{
    game_over();
  }
} 

Para eso tenemos que crear dos funciones, jugar() y game_over(), y dentro de cada función poner el código que había en su lugar.

Dentro de jugar():

void jugar(){
  disparando();  
    if (contador > 5000)  {
      contador = 0;
      encenderapagarLEDaleatorio();
      }
}  

Dentro de game_over():

void game_over(){
  apagarLED(led0);
  apagarLED(led1);
  apagarLED(led2);
  apagarLED(led3);
  //Más la música de la derrota!
}

La segunda parte del reto consistía en programar la victoria, de forma similar a como hemos programado la derrota.

Para ello, y siguiendo con la lógica de las funciones, vamos a crear la función win():

void win(){
  encenderLED(led0);
  encenderLED(led1);
  encenderLED(led2);
  encenderLED(led3);
  //Más la música de la victoria!
} 

¿Cuándo llamamos a esta función? Cuando una nueva variable llamada bajas, que cuente el numero de disparos que hemos acertado, llegue a 20.

Cada vez que disparemos y consigamos apagar un led hay que aumentar el contador de bajas. A la vez que aumentamos el contador de bajas en la función disparando() vamos a aprovechar para solucionar un problema que tenía y que hasta este momento no era importante:

Cuando disparamos a una fotoresistencia con el laser, el valor de la fotoresistencia pasa el límite que le hemos fijado y automáticamente se apaga el LED:

//Dentro de void disparando():

if (analogRead(foto0) > limite){
       apagarLED(led0);
       encendido0 = false;
    }

¿Qué pasaría si el LED ya estuviera apagado? Que el programa entraría de todas formas en la función e intentaría apagarlo de nuevo, añadiendo una baja cuando realmente no se a producido.

Para solucionar esto hay que añadir la condición de que el LED esté encendido, además de la condición de que la fotoresistencia supere el límite, para no apagar un LED que ya está apagado.

Quedando de esta forma la función disparando():

void disparando(){
  if (analogRead(foto0) > limite && encendido0){
       apagarLED(led0);
       encendido0 = false;
       bajas++;
    }
  if (analogRead(foto1) > limite && encendido1){
       apagarLED(led1);
       encendido1 = false;
       bajas++;
    }
  if (analogRead(foto2) > limite && encendido2){
       apagarLED(led2);
       encendido2 = false;
       bajas++;
    }
  if (analogRead(foto3) > limite && encendido3){
      apagarLED(led3);
      encendido3 = false;
      bajas++;
    }
  contador++;
}

Podemos poner cualquier valor en el lugar del 20 (veinte), que dice el enunciado que son el número de enemigos que hay que derrotar para ganar el juego. Y para que sea más fácil modificar el código, podemos crear una variable bajas_para_ganar. De esta forma, si queremos aumentar el número de bajas necesarias para ganar solo tenemos que modificar ese número sin tener que buscarlo en el código.

NOTA: Esto también se puede hacer con la derrota y escaparon_para_perder en lugar del número 5 (cinco) que pusimos ayer.

//Recordatorio: Las variable se inicializan al principio. Antes del setup().
.
.
.

const int bajas_para_ganar = 20;
const int escaparon_para_perder = 5;

int contador = 0;
int escaparon = 0;
int bajas = 0;

.
.
.

void loop(){
  if (bajas >= bajas_para_ganar){
    win();
  } else if (escaparon <= escaparon_para_perder){
    jugar();       
  } else{
    game_over();
  }
} 

---

¿Estáis preparadas para MEJORAR el juego?

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:

void setup() {
  pinMode(rgbR,OUTPUT);
  pinMode(rgbG,OUTPUT);
  pinMode(rgbB,OUTPUT);
}
 
void loop() {
  analogWrite(rgbR, 0);
  analogWrite(rgbG, 0);
  analogWrite(rgbB, 255);
}

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.

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.

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.

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!

¡Que la suerte esté siempre de vuestra parte!

¿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.

void setup() {
.
.
.
  //Encendemos los LEDs.  
  digitalWrite(led0,HIGH);
  digitalWrite(led1,HIGH);
  digitalWrite(led2,HIGH);
  digitalWrite(led3,HIGH);
}

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().

void loop(){
  disparando();  
  if (contador > 5000)  {
    contador = 0;
    encenderapagarLEDaleatorio();
    }          
} 

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:

bool encendido0 = false;
bool encendido1 = false;
bool encendido2 = false;
bool encendido3 = false;

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;
    }
  }
}

RETO DIARIO :

RETO 4.1: Simplificar el bucle loop().

Dejar el bucle loop() así:

void loop(){
 if (escaparon < 5){
    jugar();       
  } else{
    game_over();
  }
} 

RETO 4.2: Programar la victoria.

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.

¡Que la suerte esté siempre de vuestra parte!

¿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:

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:

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:

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.

¡Que la suerte esté siempre de vuestra parte!