Solución al último Reto propuesto

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

Ampliaciones del proyecto láser-tag

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

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!

¡Que la suerte esté siempre de vuestra parte!

Juego láser-tag Básico

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

Comenzando el proyecto

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

¡Que la suerte esté siempre de vuestra parte!

Primeros proyectos con Arduino

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


void setup()
{    
     pinMode (rojo , OUTPUT);
     pinMode (amarillo , OUTPUT);
     pinMode (verde , OUTPUT);
}

Por último vamos a crear el cuerpo del bucle:


void loop()
{
     digitalWrite(LedRojo,HIGH);
     delay(2000);
     digitalWrite(LedRojo,LOW);
     delay(50);
     digitalWrite(LedVerde,HIGH);
     delay(2000);
     digitalWrite(LedVerde,LOW);
     delay(50);
     digitalWrite(LedAmarillo,HIGH);
     delay(500);
     digitalWrite(LedAmarillo,LOW);
     delay(50);
}

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

¿Qué material usaremos en esta edición del campus?

Lo prometido es deuda. Como hace una semana os adelantamos, vamos a publicar los materiales que usaremos en el campus para que las chicas que no sean seleccionadas para la parte presencial, también puedan realizar el proyecto junto con todas las demás de manera online y con apoyo de las monitoras.

Iconos de la creatividad | Vectores de dominio público
Este proyecto será muy creativo ¿te animas a montarlo?

Vamos a dejar una lista de materiales que necesitaremos, también algunos enlaces de donde conseguirlo pero si no os convencen los sitios donde los hemos comprado nosotras siempre podéis buscar por ahí porque hay un montón de tiendas donde podéis conseguirlos.

No os vamos a desvelar en que consiste el proyecto aún pero vais a tener unas cuantas pistas y podréis dejar volar la imaginación con el listado de materiales. Sólo os podemos contar un detallito, que tendrá una parte que montaremos con hardware que listare continuación y otra que será mas creativa en la que tu imaginación podrá volar y buscar los materiales de manualidades que tengas por casa para poder darle forma…

Venga, vamos al listado de materiales:

MaterialUnidades ¿Dónde lo hemos comprado?
Arduino uno r31Aquí
Cable Arduino1Aquí
Sensor fotoresistencia5Aquí
Pantalla LCD con I2C1Aquí
Led RGB2Aquí
Zumbador pasivo1Aquí
Protoboard 4001Aquí
Protoboard mini2Aquí
Cables m-h 30cm x402Aquí
Cables m-m 10cm x402Aquí
Led azul5Aquí
Led rojo5Aquí
Led verde5Aquí
Led amarillo5Aquí
Laser1Aquí
Resistencias 22020Aquí
Resistencias 10k5Aquí
Fichas empalme clic10Aquí
Cinta aislante1Aquí

Para la parte creativa piensa que puedes usar material reciclado, cartones que tengas por casa de cualquier tipo, goma eva, pinturas acrílicas, rotuladores, lápices o ceras de colores, folios, pegamento… ¡Imaginación al poder!

Si todavía no te has inscrito al campus ¿a qué esperas? ¡que se acaba el plazo! Aquí tienes el enlace al formulario

Horario VII Campus Seré Ingeniera

En unos días publicaremos la lista definitiva de chicas que podrán participar de forma semipresencial en el campus pero, os recordamos que todas las no seleccionadas podrán participar de manera online. Es una gran oportunidad para que conozcáis chicas con vuestros mismos intereses además de crear un proyecto súper chulo que os vamos a proponer las monitoras.

libre de regalías horario fotos descarga gratuita | Piqsels

En esta ocasión os escribimos para contaros cual será el horario del campus y qué haremos cada día pero aún no desvelaremos el proyecto que tenemos preparado. ¡Creedme os va a encantar!

Hablemos del horario que vamos a seguir en el campus:

Díasjueves 2/7viernes 3/7lunes 6/7martes 7/7miercoles 8/7jueves 9/7viernes 10/7
9:30Recepción de participantes e inauguraciónExplicación dinámica de
como será cada día
en el campus. Propuesta 1º reto
Resumen día anterior. Resolución del 1º reto. Planificación del día. Propuesta 2º retoResumen día anterior. Resolución del 2º reto. Planificación del día. Propuesta 3º retoResumen día anterior. Resolución del 3º reto. Planificación del día. Propuesta 4º retoResumen día anterior. Resolución del 4º reto. Planificación del día.Recepción de
participantes
10:30CharlasExplicación proyecto
1ª parte
Explicación proyecto
2ª parte
Explicación proyecto
3ª parte
Explicación proyecto
4ª parte
Preparar video con el proyecto terminadoClausura
11:30Reparto de materialTrabajar en el proyecto Trabajar en el proyecto Trabajar en el proyecto Trabajar en el proyecto Taller de nuestro patrocinador: NOVATECCharlas
12:30Grabar y mandar
videos de resolución del reto del día
Grabar y mandar
videos de resolución del reto del día
Grabar y mandar
videos de resolución del reto del día
Grabar y mandar
videos de resolución del reto del día
NOVATEC hasta las 13:30
17:30Resolución de dudasResolución de dudasResolución de dudasResolución de dudasResolución de dudas
18:30Resolución de dudasResolución de dudasResolución de dudasResolución de dudasResolución de dudas

Como podéis ver hay cosas muy interesantes en el horario, como los talleres que nos han preparado algunos de los patrocinadores del campus o los retos diarios que os propondremos las monitoras a todas vosotras.

Precisamente sobre eso quería hablaros, ya que entre todas las que resolváis los retos se realizará una votación en la que elegiréis cual de todas las soluciones os ha gustado más y al final del campus gracias a nuestro patrocinador pricipal ESERO, el premio es que las 4 elegidas formarán un equipo y podrán participar con un Cansat que montarán junto a una de las monitoras del campus. ¿No os parece chulo?

Buscamos futuras ingenieras y futuras amantes de la tecnología. ¿Quieres participar?

Inscripciones aquí

¿Cómo será el campus este año?

Lady DiY proyecto de la edición 2019

¡Buenas chicas! no se si ya lo habéis visto en nuestras redes sociales… pero mientras cerramos todo lo necesario para la realización del campus, estos días de atrás os hemos dejado un formulario de interés en el campus para que sepamos cuantas estáis interesadas en participar en esta edición.

Cómo ya sabéis, esta edición va a ser un poco diferente a las anteriores por la situación de alarma sanitaria que existe, pero eso no hará que sea menos divertido, ni que dejemos de intentar llevaros la tecnología a vuestro entorno.

Este año el proyecto será individual y aunque aún no os hemos hablado del él, en los próximos días os pondremos la lista de materiales que vamos a emplear para que lo construyáis vosotras mismas, ya sea con nuestra ayuda uniéndoos a nuestras sesiones virtuales o simplemente por vuestra cuenta.

Lo único que os vamos a contar por ahora, son algunos detalles para que os animéis, como que todas haréis el mismo proyecto pero… ¡no será el mismo! ¿qué cómo puede ser eso? pues fácil, porque el hardware que utilizaréis, es decir,los componentes electrónicos serán los mismos para todas, pero cada una podrá emplear toda su creatividad para que, a partir del proyecto final que os mostraremos las monitoras, ¡inventéis cómo queréis que sea el vuestro! es decir, el proyecto que hemos elegido para vosotras es altamente personalizable y al final, cada una tendrá su propia versión del proyecto. ¿No os parece chulo? y además, … podréis jugar con él.

¿Más detalles sobre el campus que os podemos adelantar ? que tendréis a tres monitoras que os ayudarán durante la mañana y algunas horas de la tarde para que las chicas que no tengáis el ordenador disponible por la mañana, podáis consultar las dudas o curiosidades que tengáis con alguna de las monitoras por la tarde.

Otro cambio será el número de asistentes, que seréis poquitas, solo 15, pero todas las demás podréis participar simplemente comprando los componentes y uniéndoos a las sesiones de todas las mañanas para avanzar en los proyectos, es decir, este año ¡Todas podréis participar!

Si, eso es lo que hemos ganado en esta edición, el poder ampliar horizontes y admitir a chicas de todas partes. Porque las sesiones virtuales serán para todo el mundo que se quiera unir, y que se inscriba AQUÍ.

Las sesiones presenciales, para las chicas que seleccionemos serán en la Escuela Técnica Superior de Ingenierías Informática y de Telecomunicación y las chicas no seleccionadas podrán seguirla online. y por supuesto sin ningún coste para las chicas ni para sus familias.

Fotos gratis : juguete, robot, diseño, tecnología, máquina ...

Estad atentas porque las novedades las tendréis disponibles aquí y en nuestras redes sociales. twitter, sereIngeniera, facebook , youtube e instagram

Iniciamos #Sereingeniera20

Iniciamos el 2020 de Sereingeniera y ya tenemos muchas cosas que contaros. La primera y la más importante es que este año habrá de nuevo Campus Tecnológico y para ello estamos buscando ya financiación, así que abrimos llamada a 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-2020-2/ y te las puedes descargar desde https://sl.ugr.es/patrocinioSereingeniera2020.

Como ya sabrás, si eres asidua de este blog, esta actividad sirve para fomentar las vocaciones tecnológicas en chicas de secundaria, para que conozcan qué hacemos las ingenieras y para que conozcan a otras chicas con la misma edad, las mismas inquietudes y las mismas dudas.

Proyecto realizado por las chicas en la edición 2019

Todo esto se lo intentamos aclarar y enseñar durante dos semanas, a principios de julio, en las que las chicas desarrollan en grupos un proyecto tecnológico completo guiadas por monitoras en la Escuela Superior de Ingeniería Informática y Telecomunicación de la Universidad de Granada.

Para que las chicas puedan hacer esto, buscamos financiación y de este modo, el coste para ellas es cero. Buscamos a la gente que lo imparte y buscamos los proyectos que desarrollan y que os iremos presentando poco a poco en este blog.

Al final de las dos semanas, las chicas tienen su proyecto terminado, han visto que son capaces de hacerlo, han conocido a otras chicas que como ellas les interesa la tecnología, pero no tienen claro todavía por qué camino seguir su formación y nosotras esperamos que todas sus dudas sobre si una ingeniería es útil y es su profesión de futuro se hayan esfumado y se sientan mucho más cerca de ese camino.

¿Quieres nos han financiado ya en ediciones anteriores?

Pues esta actividad se financia con la aportación de empresas que colaboran con la Oficina de Software Libre para ello como son PC Componentes, Financial Force, Novatec Software, Unit4, Createc3D, Conecta 13 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.

Finalizan los campus #SereIngeniera19

Durante estas dos semanas hemos ido avanzando con trabajo y entusiasmo en los campus #SereIngeniera19, hasta llegar a su emotiva clausura el pasado viernes 14 de julio con la presentación por parte de todas las chicas participantes de todos los proyectos realizados y la recogida de certificados.

Este acto final donde pudimos ver el resultado final de los proyectos así como una breve descripción de cada grupo de cómo se habían desarrollado estos campus, fue presidido por la excelentísima rectora de la Universidad de Granada, Pilar Aranda, junto a Maribel García Arenas (directora de la OSL y coordinadora de los campus), Nuria Rico (responsable del proyecto «quiero ser ingeniera» del Ministerio de la Presidencia), Joaquín F. Valdivia director de la ETSIIT y los responsables de la sede de Ceuta (FEETCE).

Han sido muchas las cosas que hemos aprendido y compartido: clases de programación, de electrónica, placas y cables, talleres prácticos, desarrollo de proyectos, trabajo en equipo y muchas, muchas emociones.

Parte de esa experiencia se puede ver en los vídeos sobre el desarrollo de los proyectos que presentó cada grupo de chicas y que podéis ver en el post anterior en este mismo blog «Los vídeos Campus Tecnológico #Sereingeniera 2019«.

En las siguientes imágenes hemos intentando recoger algunos de los momentos más emocionantes y significativos de la clausura.

Sin duda unos campus que han superado las expectativas que desde la organización se habían planteado. 8 grupos de chicas, 8 proyectos diferentes, 6 monitoras, 2 sedes…eran cifras más ambiciosas que en pasadas ocasiones, lo que también implicaba una mayor responsabilidad. Nos lo cuentan en este vídeo Maribel García Arenas, Nuria Rico, las monitoras y las protagonistas de estos campus:

Al final de estos campus nos quedamos con la emoción y el buen sabor de boca de esa clausura, con el orgullo de ver a nuestras chicas felices con la experiencia y convencidas de su vocación, y con la satisfacción del trabajo bien hecho.

Queremos despedir estos campus dando las gracias de nuevo a todas las personas, entidades y empresas colaboradoras, invitándolas a volver a participar en próximas ediciones de #SereIngeniera19.

Y en ese sentido nos hacemos eco del compromiso que la rectora de la Universidad de Granada, Pilar Aranda, manifestó el pasado viernes en el cierre de estos campus:

«El compromiso propio y de la Universidad de Granada para crear personas críticas y construir una sociedad más igualitaria.»

¡Hasta la próxima!