EduShield Canarias

¿Qué es EduShield Canarias?

EduShield Canarias es un shield(placa que se pincha directamente) de Arduino que ha sido diseñada para tener una serie de elementos conectados directamente a un Arduino Uno R3, consiguiendo con esto no tener que realizar montajes electrónicos para la realización de ciertas prácticas. Evidentemente, esto produce un desvinculamiento de la parte electrónica, por lo que estas placas pueden ser usadas para cursos inferiores a 4º de la ESO. Con la finalidad de que no estén  limitadas, tienen 4 puertos para interconectar otros dispositivos, bien con señales digitales simples, señales analógicas o por protocolo I2C. EduShield es hardware libre y estará acompañado (aún se sigue mejorando…) por un firmware y una extensión para Mblock, así como una librería para el IDE de Arduino, cuya finalidad es simplificar al máximo la programación, convirtiéndola en un juego de niñ@s a precio económico (recuerdo que hay placas en el mercado que tienen la mayoría de las funciones de EduShield pero son relativamente caras)

Actualmente han visto la luz dos versiones y dentro de poco, espero tener la versión definitiva revisada.

EduShield Canarias 1.0

Se realizaron como prueba inicial del proyecto y forma la base de este. Tiene tres puertos semi-compatibles con los del mbot y un puerto incompatible (puerto 3). Como conectores se utilizan RJ12 6P-6C e incorpora un zumbador, un receptor de infrarrojos, una LDR y dos diodos leds RGB.

Esta placa ha sido utilizado con alumnado de 1º, 2º y 4º de la ESO con actividades para el desarrollo del currículo de la asignatura de tecnología, con bastante éxito.  Aunque desde un principio se pretendía que estas placas pudiesen ser utilizadas por alumnado de primaria.

Con el desarrollo de esta placa se realizó una placa con cuatro pulsadores en pull-down, presente en la imagen.

¿Qué elementos  incorpora la placa para trabajar directamente?

Sensor de luz LDR (resistencia variable con la luz)

Es una resistencia cuyo valor cambia en función de la cantidad de luz que entra en en su encapsulado. Está conectada en el pin A3 en serie con una resistenca de 47KΩ, creando un divisor de tensión.

Diodos led RGB

Son diodos leds que se controlar por un único pin (pin 13) y pueden tomar diferentes tonalidades de  rojo (R), verde (G) y azul (B). El color que emite cada diodo se puede controlar de forma independiente o  a la vez, según se necesite.

Zumbador

Dispositivo con el que se pueden emitir sonidos conectado en el pin 8.

Receptor IR

Dispositivo con el que se puede detectar señales infrarojas, utilizadas habitualmente por mandos a distancia. Este dispositivo está ubicado en el pin 2 del Arduino.

 

EduShield Canarias 2.0

La finalidad de este prototipo era mejorar la versión 1.0 cambiando los conectores de los puertos, sacar el pinout de estos con conectores Dupont a modo de fundino (para conectar fácilmente servomotores, etc…), agregar el máximo de dispositivos en placa posible, y que a través de pocos elementos se pueda utilizar la placa para la interconexión de los motores y dispositivos necesarios para la realización de los EduROVs del PLOCAN.

Por lo tanto, es un prototipo mejorado cuya configuración de puertos es la misma que la del EduShield Canarias 1.0, pero se utilizan conectores jtag-3×2 evitando el sistema de enganche de los RJ12 (se rompen con mayor facilidad). A parte de los elementos presentes en la placa Edushield Canarias 1.0, se le añade un tercer diodo rgb (dando la posibilidad de hacer prácticas tipo semáforo, etc…), dos pulsadores con codificación analógica enganchados en el pin A2 y un sensor de temperatura (en principio se diseñó para un LM35, pero por cuestiones prácticas se cambió por una DS18B20 que se conectó en el pin 3). Se añade también un puente en H para controlar un motor conectado a través de un doble conmutador al puerto 1 (cuando se utiliza el motor se deshabilita el uso de los pines 11 y 12 en el puerto 1 y viceversa).

Dos ejemplos que se utilizaron a la hora de realizar la parte software son:

Control de dos motores adicionales a través de placa de expansión con puente en H. Se controlaron tres motores DC a la vez.

Lectura del sensor de temperatura en placa y representación de dicha temperatura en LCD (emulación con mBlock)

 

¡Inmersión Total! El IES Carrizal Desafía las Profundidades con Robótica Submarina

¿Alguna vez has soñado con explorar las profundidades del océano sin mojarte? En el IES Carrizal, ¡estamos haciendo ese sueño realidad! Este curso académico, nos hemos sumergido en el fascinante mundo de la robótica submarina con el proyecto EduROV 2024-25. Nos olvidamos de las aulas aburridas y los libros llenos de polvo, para construir un robot que pueda navegar bajo el agua resolviendo desafíos técnicos. ¡Eso es EduROV!

Hoy, la emoción se sentía en el aire en la base de tierra del PLOCAN en Taliarte. Nuestros estudiantes se enfrentaron a la prueba definitiva: ajustar la flotabilidad, controlar motores rebeldes y perfeccionar los mandos de nuestro nuevo ROV. Cada ajuste y cada solución era un paso más hacia lo desconocido.

Montaje con rov y controles

¿Y el resultado? Un equipo de jóvenes ingenieros listos para conquistar las profundidades. Cuyos retos van desde el montaje de la estructura y diseño 3d de piezas usadas en el ensamblaje a la programación de un Arduino que controlas los puente en H de los motores del submarino, así como una sonda de temperatura y una pantalla LCD. Se nos ha quedado atrás el control por medio de Bluetooth, reto que si podemos, lo enfrentaremos el curso que viene.

Para allá vamos EduROVs 2024-25

El martes 17 el IES Carrizal participará en el encuentro organizado por PLOCAN sobre robótica submarina, con un nuevo EduROV (ya hace años que no participamos) y con ganas de ver que es lo que han realizado los alumnos y alumnas de otros centros, así como el poder compartir nuestro trabajo.

Casa domótica presentada en RetoTech

La participación del alumnado del IES CARRIZAL en el encuentro autonómico de Canarias de Retotech, ha estado enfocado en la presentación de una maqueta funcional de una vivienda domótica. Dicha maqueta integra sistemas de generación de energía renovable reales (con los que se alimentaron dos placa ZUM Core 2.0 a partir de un panel solar) y mejoras significativas en accesibilidad.

Se ha desarrollado una APP y los programas para dos placas microcontroladas Arduino ZUM Core 2.0 de BQ. Todo ello programado en BitBloq por alumnado de 4ºESO de Diversificación Curricular, utilizando una programación avanzada con respecto al estándar del encuentro. Se ha conseguido un software eficiente a lo misma vez que se ha desarrollado un protocolo donde se identifica a cada una de las placas para el posterior tratamiento de la información recibida en la APP y el envío de órdenes desde esta. Se han utilizado interruptores como los comúnmente usados en las viviendas y un sensor de movimiento PIR para automatizar una de las luces del garaje.

Un rasgo distintivo de nuestro proyecto reside en su operatividad real. Solo se necesitaría la implementación de acondicionadores de señal y los actuadores adecuados para ser directamente aplicada la programación implementada en la maqueta pudiendo funcionar de manera eficiente en una vivienda de tamaño real.

Agradecemos a RetoTech Fundación Endesa la oportunidad de haber participado en el evento y esperamos que nuestra contribución haya gustado y levantado bastante interés.

Código de la Bomba para gamificación

Como han solicitado el código que he realizado para hacer el proyecto, lo comparto en esta entrada. He cogido como base el código de Alexander Brevig para controlar una matriz de pulsadores y he añadido el código para controlar el LCD, el zumbador y el led.

/* 
** @version 1.0
** @author Roberto Suárez
**
** @description
** Programa que controla un lcd, zumbador y led, por medio de la entrada de datos de una teclado en matriz.
*/
#include <Keypad.h>
#include <LiquidCrystal_I2C.h>
#define CARACTERES 16


LiquidCrystal_I2C lcd(0x3F,CARACTERES,2); 

const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {3, 4, 5, 6}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {7, 8, 9}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

const int pinBuzzer=2;
const int pinLedR=11;
const int pinLedG=10;
const int PULSE= 500;
const int ALARM= 1000;
String clave="";
String pass="";
byte lengPass=4;
byte para=0;
unsigned long currentTime,finalTime, tempo, timeSound;
int timeSoundBoom=1000;

bool charIsNumber(char character){
    return (character>47 && character<58);
}
void keySound(){
  tone(pinBuzzer,PULSE, 50);
}
void alarmSound(){
  //digitalWrite(pinLedR,(!digitalRead(pinLedR)));
  tone(pinBuzzer,ALARM, 30);
  //if (timeSoundBoom<1000){tone(pinBuzzer,ALARM, 30);}
  digitalWrite(pinLedR,(!digitalRead(pinLedR)));
}

void clearLine(int line){
  lcd.setCursor(0,line);
  lcd.print("                ");
}

void centerPrint(String text, int line){
  int pos;
  pos=(CARACTERES-text.length())/2;
  lcd.setCursor(pos,line);
  lcd.print(text);
}

void centerPrintPass(String text, int line){
  int pos;
  int i;
  pos=(CARACTERES-text.length())/2;
  lcd.setCursor(pos,line);
  for (i=1; i<text.length();i++){
    lcd.print('*');
  }
  lcd.print(text[i-1]);
}

void inicioClave(){
  clearLine(1);
  lcd.setCursor(0,1);
  lcd.print("Clave: ");
}

void printTime(){
  long int t;
  int i=0;
  String timeText="";
  char buf[3]=" ";
  char* format="%02d";
  
    
  t=finalTime-currentTime;
  if (tempo>=3600){
    i=t/3600; // Calculo las horas
    sprintf(buf,format,(char) i);
    timeText=buf;
    timeText+=":";
  }
  i=((t-i*3600))/60; // Calculo los minutos restando las horas
  if (i>60){i=0;} //Verifico que no está a 60, esto significa que debe estar a 0 porque la unidad superior está completa
  sprintf(buf,format,(char) i);
  timeText+=buf;
  timeText+=":";
  i=t % 60; //Calculo los segundos
  //if (i>60){i=0;} //Verifico que no está a 60
  sprintf(buf,format,(char) i);
  timeText+=buf;
  centerPrint(timeText,0); //Imprimo el texto centrado en la línea 0
}

void solicitaClave(){
   char tecla;
   String aux="";
   lcd.clear();
   centerPrint("Introduce clave",0);
   tecla= keypad.getKey();
   lcd.cursor();
   while (tecla!='#'){
    /*Serial.print("La tecla es: ");
    Serial.print((byte)tecla);
    Serial.println(aux.length());*/
    if (tecla=='*'){
      keySound();
      aux="";
      clearLine(1);
    }
    else{
      
      if (aux.length()<4 && tecla>47 && tecla<58){
        keySound();
        aux+=tecla;
        centerPrintPass(aux,1);
      }
    }
   tecla= keypad.getKey();
  }
  keySound();
  lcd.noCursor();
  pass=aux;
}

void solicitaTiempo(){
   char tecla;
   char aux[6];
   int i; 
   
   for (i=0;i<6;i++){aux[i]='0';}
   i=1;
   lcd.clear();
   centerPrint("Introduce tiempo",0);
   centerPrint("00:00:00",1);
   lcd.setCursor(5,1);
   lcd.cursor();
   tecla= keypad.getKey();
   while (tecla!='#'){
    if (tecla=='*'){
       keySound();
       for (i=0;i<6;i++){aux[i]='0';}
       i=1;
       centerPrint("00:00:00",1);
       lcd.setCursor(5,1);
    }
    else{
      
      if (i<6 && tecla>47 && tecla<58){
        keySound();
        if (!(i%2)){if (tecla-48>5){tecla='5';}}  //No se puede poner números superiores al 5 en la segunda cifra de segundos y minutos
        aux[i]=tecla;
        lcd.print(aux[i]);       
        if (i==1){lcd.setCursor(7,1);}   //Si el indice es 1 o 3 tengo que reubicar el cursor
        else if (i==3){lcd.setCursor(10,1);}
        i++;
        //clearLine(1);
      }
    }
   tecla= keypad.getKey();
  }
  lcd.noCursor();
  tempo=((aux[0]-48)*10+(aux[1]-48))*3600+((aux[2]-48)*10+(aux[3]-48))*60+(aux[4]-48)*10+(aux[5]-48);
  keySound();
}
void setup(){
  Serial.begin(115200);

  pinMode(pinLedG, OUTPUT);
  pinMode(pinLedR, OUTPUT);
  digitalWrite(pinLedR,HIGH);
  delay(200);
  digitalWrite(pinLedR,LOW);
  digitalWrite(pinLedG,HIGH);
  lcd.init();                      // initialize the lcd 
  // Print a message to the LCD.
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Bomba gamificada");
  lcd.setCursor(0,1);
  lcd.print("ROBERTO J.SUAREZ");
  delay(2000);
  solicitaTiempo();
  Serial.print("El tiempo fijado es: ");
  Serial.println(tempo);
  solicitaClave();
  Serial.println("La clave es: "+pass);
  currentTime=millis()/1000; 
  finalTime=currentTime+tempo;
  lcd.clear();
  timeSound=millis()+timeSoundBoom;
  digitalWrite(pinLedG,LOW);
}
  
void loop(){
  char key = keypad.getKey();
  if (!para){
    if (finalTime-currentTime<21){timeSoundBoom=400;}
    if (finalTime-currentTime<11){timeSoundBoom=300;}
    currentTime=millis();     //No lo divido por 1000 aún para utilizarlo en las lineas siguientes
    if (currentTime>timeSound){
      timeSound=currentTime+timeSoundBoom;
      alarmSound();
    }
    currentTime/=1000; //Guardo el inicio en segundos.
    printTime();
    if (finalTime<=currentTime){ //Se acabo el tiempo
      digitalWrite(pinLedR,HIGH);   //Dejo fijo el color rojo en el led
      para=1; // Se acaba el juego, perdiendo el jugador
      //Secuencia de exploción
    }
    
    if (key){
      if (charIsNumber(key)){
        if (clave==""){
          inicioClave();
        }
        keySound();
        clave+=key;
        lcd.setCursor(7,1);
        lcd.print(clave);
        if (clave.length()==lengPass){
         delay(500); 
         if (clave==pass){
            para=2;// Se acaba el juego, ganando el jugador
            digitalWrite(pinLedR,LOW);
            digitalWrite(pinLedG,HIGH);
         }
         else {
          clave="";
          clearLine(1);
          centerPrint("Clave incorrecta",1); //Imprimo en la línea 1 la frase centrada
          delay(500);
          inicioClave();
         }   
        }
      }
    }
  }
  else{
    lcd.clear();
    delay(500);
    //if (tempo>3600){centerPrint("00:00:00",0);}
    //else {centerPrint("00:00",0);}
    if (para==1){
      centerPrint("JUEGO FINALIZADO",0);
      centerPrint("BOMBA DETONADA",1);  
    }
    else{
      centerPrint("BOMBA",0);
      centerPrint("DESACTIVADA",1);
      delay(2000);
    }
    delay(1000);
  }
}

```

Trabajando con la tarjeta Zum Core 2 de BQ

Toca trabajar con la tarjeta Zum Core 2 del kit Zum KIT ADVANCED. Estos kits han sido cedidos por la Fundación Endesa a través del proyecto RetoTech, por lo que han venido genial para enseñar alumnado de Diversificación Curricular, algo de programación de microcontroladores y a su vez se han desarrollado aplicaciones para dispositivos móviles (APP).

La placa en sí es un Arduino UNO R3, donde se le han incluido pines funduino para la conexión rápida de dispositivos con tres pines (GND, Vcc y Pin del Arduino), lo que facilita conexiones y las hace más robustas. Las dos ventajas principales que tiene es que a nivel de hardware incorpora un módulo bluetooth, lo que hace menos tedioso que el Arduino se pueda comunicar con dispositivos inalámbricos (la programación es similar a un ESP32) y la otra ventaja es la utilización de la plataforma bitbloq, que aunque es de pago, resulta bastante intuitiva para el alumnado, lo que evidentemente deriva en que también tenga algunas limitaciones.

Un lector de tarjetas sin contacto con ESP32

Vamos a desarrollar un proyecto de lector sin contacto con un ESP32 y una tarjeta RC522. Siguiendo este conexionado, pero en un a placa Wemos Mini R1 D32.

Quedando una cosa tal que así:

Código para leer una tarjeta RFID

Para utilizar el módulo RC522 RFID utilizamos la librería SPI.h que nos permitirá establecer la comunicación entre la tarjeta ESP32 y el módulo, así como y la librería MFRC522.h que nos permitirá dialogar con el módulo.

/*
 * --------------------------------------------
 * Ejemplo de lectura de tarjeta rFID con ESP32
 * --------------------------------------------
 * 
 * Conexión dispositivos:
 * ---------------------------------
 *             MFRC522      ESP32  
 *             Reader/PCD   Mini R1
 * Signal      Pin          Pin    
 * ---------------------------------
 * RST/Reset   RST          15 (TDO)      
 * SPI SS      SDA(SS)      5 
 * SPI MOSI    MOSI         19 
 * SPI MISO    MISO         23 
 * SPI SCK     SCK          18 
 * 
 * Buzzer en pin 27
 *         R   G   B
 * Led rgb 22, 21, 17
 */

#include <SPI.h>
#include <MFRC522.h>

#define SS_PIN 10
#define RST_PIN 9
 
MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class

MFRC522::MIFARE_Key key; 

// Init array that will store new NUID 
byte nuidPICC[4];

void setup() { 
  Serial.begin(115200);
  SPI.begin(); // Init SPI bus
  rfid.PCD_Init(); // Init MFRC522 

  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF;
  }

  Serial.println(F("This code scan the MIFARE Classsic NUID."));
  Serial.print(F("Using the following key:"));
  printHex(key.keyByte, MFRC522::MF_KEY_SIZE);
}
 
void loop() {

  // Reset the loop if no new card present on the sensor/reader. This saves the entire process when idle.
  if ( ! rfid.PICC_IsNewCardPresent())
    return;

  // Verify if the NUID has been readed
  if ( ! rfid.PICC_ReadCardSerial())
    return;

  Serial.print(F("PICC type: "));
  MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
  Serial.println(rfid.PICC_GetTypeName(piccType));

  // Check is the PICC of Classic MIFARE type
  if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&  
    piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
    piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
    Serial.println(F("Your tag is not of type MIFARE Classic."));
    return;
  }

  if (rfid.uid.uidByte[0] != nuidPICC[0] || 
    rfid.uid.uidByte[1] != nuidPICC[1] || 
    rfid.uid.uidByte[2] != nuidPICC[2] || 
    rfid.uid.uidByte[3] != nuidPICC[3] ) {
    Serial.println(F("A new card has been detected."));

    // Store NUID into nuidPICC array
    for (byte i = 0; i < 4; i++) {
      nuidPICC[i] = rfid.uid.uidByte[i];
    }
   
    Serial.println(F("The NUID tag is:"));
    Serial.print(F("In hex: "));
    printHex(rfid.uid.uidByte, rfid.uid.size);
    Serial.println();
    Serial.print(F("In dec: "));
    printDec(rfid.uid.uidByte, rfid.uid.size);
    Serial.println();
  }
  else Serial.println(F("Card read previously."));

  // Halt PICC
  rfid.PICC_HaltA();

  // Stop encryption on PCD
  rfid.PCD_StopCrypto1();
}


/**
 * Helper routine to dump a byte array as hex values to Serial. 
 */
void printHex(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], HEX);
  }
}

/**
 * Helper routine to dump a byte array as dec values to Serial.
 */
void printDec(byte *buffer, byte bufferSize) {
  for (byte i = 0; i < bufferSize; i++) {
    Serial.print(buffer[i] < 0x10 ? " 0" : " ");
    Serial.print(buffer[i], DEC);
  }
}

¿Cúal es el reto?

¿Seremos capaces de modificar el programa para imprimir por puerto serie solo el código de identificación de la tarjeta?

Probando chasis de mBot con la placa Edushield Canarias ESP32 Mini R1

Hoy he puesto en marcha una placa Edushield Canarias ESP32 Mini R1, sobre un chasis de aluminio comprado en China similar a los que utilizan los mBot. Solo soldé dos drivers para motores, ya que el chasis utiliza solo dos motores.

Puedes ver una pequeña prueba de control con BT en este Tweet

Placa EduShield Canarias doble display de 7 segmentos

Uno de los dispositivos interesantes para la realización de prácticas, tanto de programación como de electrónica digital es sin duda alguna el display 7 segmentos. No son más que 8 diodos leds, con sus catados o ánodos unidos y dispuestos físicamente de tal forma que se puede crear con ellos algunas letras y números. Pero el gran problema de los puertos de las placas como la EduShield Canarias, es que solo tienen 2 pines digitales y un puerto I2C (aparte de la alimentación). En consecuencia he diseñado una placa que gracias a un expansor de puertos PCF8574, nos permitirá enviar los datos que queremos que aparezca en los displays y con los dos pines digitales podremos controlar el encendido o apagado de cada uno de los displays gracias a unos transistores PNP en configuración emisor común. Al funcionar, el PCF8574, como salidas en drenador abierto, nos surge el problema de la falta de corriente cuando insertamos un «1» lógico, por lo que se ha paliado realizando un pull-up sobre los catados de los segmentos de los display. En este caso el display es doble y se comparten los pines de los cátodos de ambos, por lo que para representar números en los dos dígitos es necesario multiplexar en tiempo. Para una representación a 50 Hz es necesario un tiempo de 20 ms, por lo que el encendido de cada display multiplexado no debe ser superior a 10 ms.

En el diseño se han puesto pines de 2,55mm tanto para las señales de control (para poder utilizarlo con cualquier placa microcontrolada, como un Arduino UNO R3), como para las señales de salida, con lo que se puede usar con otros dispositivos (diodos leds externos, etc…). En caso de no poder fabricar esta placa puedes comprar una genérica y montar en protoboard el display. En cambio, si tienes posibilidad de fabricarla te dejo el archivo GERBER aquí.

Aquí tienes enlaces a placas genéricas en Amazon o en Aliexpress.

Para facilitar el uso de la placa he creado una librería que contiene ejemplos de usos a distintos niveles. El objeto creado para el control de la placa contiene los siguientes métodos:

· byteWrite (short valor) -> Escribe un byte sobre los displays.
· clearDisplayNumber(int display) -> Pone a cero las variables internas del display 1 y del display 2.
· displaysOFF() -> Apaga ambos displays.
· setSegmentDigit1 (int segmento, bool valor) -> añade a la variable del display 1 el valor del segmento indicado.
· setSegmentDigit2 (int segmento, bool valor) -> añade a la variable del display 2 el valor del segmento indicado.
· selectDigitDisplay (int display) -> activa el display indicado y apaga el otro.
· writeBCD (short valor) -> Escribe sobre los displays el valor indicado codificado a 7 segmentos desde BCD.
· writeDigit (short valor) -> Escribe un byte sobre los displays.

Puedes acceder a la librería en https://github.com/rsuagued/EduShield2Display7Seg. y ver un ejemplo de funcionamiento aquí:

EduShield Canarias ESP32 Mini R1

Hoy presento el nuevo escudo diseñado para conectar una placa Wemos D1 mini ESP32 con un montón de sensores y actuadores, así como con puertos para que facilite el conexionado con otras placas actuadoras u otros sensores. Actualmente se está trabajando en una librería para que sea más sencillo programar el dispositivo y se está realizando pruebas del hardware.

¿Por qué esta placa?

Sin duda alguna el uso del ESP32 es cada vez más común. Su bajo coste y sus altas prestaciones como microcontrolador, hace que su uso sea muy atractivo. Como es normal, en eduación tenemos poco tiempo, y si de lo que se trata es de aprender a programar este tipo de dispositivo es interesante tener todos los sensores y actuadores posibles conectados en una placa y si además tenemos conectores que nos faciliten conectar placas comerciales o placas construidas por nosotros, pues mejor aún. Esta placa tiene como idea principal la filosofía de la placa mCore de Makeblock, a la cual se le ha unido la de Escarnabot, para conseguir así una placa polivalente y potente que nos permitirá realizar muchísimos proyectos sin limitación de nivel educativo.

¿Qué nos ofrece la placa EduShield Canarias ESP32 mini R1?

La idea es tener muchos dispositivos en placa por lo que se ha diseñado para que esté equipada con:

  • 1 sensor de temperatura DS18B20 de Dallas Instrument. La salida se conecta a un puerto para poder conectar más de estos dispositivos de forma externa.
  • 1 sensor de luz (LDR).
  • 1 Buzzer.
  • 1 Receptor de IR.
  • 1 Emisor de IR.
  • 4 diodos led RGB Neopìxel.
  • 5 Pulsadores.
  • 4 salidas para motores DC o para 2 motores paso a paso (Driver de 10V, por lo que se recomienda alimentación máxima de 9V).
  • 2 conectores I2C de 2,54mm.
  • 1 conector para UART o sensor de ultrasonidos.
  • Conectores de los pines restantes en configuración Funduino, ideal para conectar servomotores u otros dispositivos.
  • 2 puertos RJ11 6p-6c con alimentación, I2C y 2 pines digitales.

Conexionado con el ESP32

Puerto 1: Compuesto por pines I2C, Vcc, Gnd, S1 (Pin digital 1) 33 y S2 (Pin digital 2) 18.

Puerto 2: Compuesto por pines I2C, Vcc, Gnd, S1 (Pin digital 1) 32 y S2 (Pin digital 2) 27.

Los pines digitales de estos dos puertos quedan presentes también en conectores tipo Funduino para conexión rápida con lo típicos cables de Arduino en configuración GND, Vcc y el Pin. Del mismo modo esta presente el pin número 02 del ESP32 y el pin 14 que está conectado al sensor de temperatura, con lo que se pueden conectar más sondas DS18B20 en el bus de transmisión.

Hay que tener en cuenta que el puerto de los pines 12 y 36 puede ser usado como pines normales, como UART o para conectar un sensor de distancia por ultrasonido, pero se tiene que tener muy presente que el GPIO 36 se tiene que usar solo en modo de entrada y no de salida. Estos conectores han sido pensado para el uso del típico HC-SR04, por lo que la alimentación dispuesta es de 5 voltios.

Librería y Gerberb

Se está desarrollando una librería para que sea más sencillo programar los diversos dispositivos. También se están realizando pruebas hardware para comprobar el correcto funcionamiento de la placa. Desde que estén terminadas las pruebas se publicará el archivo Gerberb para poder fabricarla, así como la librería en GitHub.

Ejemplos de usos

Bomba para Gamificación (Scape Room) con Arduino Nano

¿Qué es lo que vamos a hacer?

Estaba dispuesto a realizar una bomba para utilizarla en clase a modo de juego Scape Room, dando otra perspectiva a los contenidos a través de gamificación . Me decidí a realizar un modelo super chulo con un TFT táctil, utilizando un maletín y un montón de luces led, pero se me ocurrió hacer una versión más austera con material de sobra que tenía por aquí antes de meterme en ese otro modelo.

En este documento vamos a ver como desarrollar una maqueta de bomba con cuenta atrás, realizada con Arduino, un LCD y un teclado matricial. Adicionalmente utilizaremos un led bicolor y un zumbador para mejorar el proyecto y para alimentarlo utilizaremos una batería de ion-litio 18650, con un cargador y un step-up que nos proporcionará los 5 voltios de alimentación, cortados por un interruptor (en mi caso utilice un mini-conmutador que tenía por aquí).

Para el atrezo utilizaré cartón, para imitar la carga de C4, y realizaré una caja como detonador donde irá toda la electrónica reutilizando cartón, el contrachapado de una caja de fresas y un par de tornillos con sus tuercas M4. Esto habrá que pegarlo con silicona termofusible, aunque también utilizaré cola de carpintero. Además, aplicaré pasta de relleno para madera si hay que tapar imperfeccione y un poco de pintura para el acabado.

El material electrónico necesario

Cantidad Nombre Foto
1 Arduino Nano Arduino Nano
1 LCD 16×2 I2C LCD 16x2 I2C
1

BUZZER

1

TECLADO MATRICIAL DE MEMBRANA

1

LED BICOLOR

1

BATERÍA ION-LITIO 18650

1

PORTA BATERÍAS

1

CARGADOR BATERÍA TP4056

1

STEP-UP 5V MT3608

1

INTERRUPTOR/CONMUTADOR

Como material adicional será necesario un poco de estaño para soldar, cables y en mi caso utilizaré una pcb perforada para soldar el buzzer y el led con su resistencia limitadora (solo utilizo una resistencia en el común porque solo enciendo un led a la vez).

Circuito electrónico

La pantalla LCD se conecta por I2C, por lo que solo hace falta conectar 4 cables (Vcc, GND, SDA y SCL). El teclado de membrana se conecta en pines digitales consecutivos, del 3 al 9. Se debe tener en cuenta que en un Arduino Nano los pines quedan consecutivos por un lado de la placa. El buzzer lo conectaré en el pin digital 2 y los diodos en el 10 y 11, quedando el esquema de la siguiente forma. El cargador queda conectado al step-up por medio del conmutador y la salida del step-up, irá conectada a Vcc del Arduino, mientras que las masas se conectan entre sí como indica la imagen.

Recuerdo que en el diodo led bicolor se ha puesto una sola resistencia limitadora porque solo estará encendido un led a la vez, ya que si quisiera encender los dos de forma simultánea tendría que disponer de una resistencia limitadora para cada uno de ellos.

Con respecto al circuito de carga hay que tener en cuenta dos cuestiones:

  1. Si conectamos el Arduino por USB para programarlo, el conmutador de la batería debe estar abierto (al step-up no debe llegarle corriente).
  2. Es preferible realizar la carga de la batería sin que el circuito esté funcionando. Carga completamente la batería y luego enciende el Arduino sin que esté conectado la entrada USB al cargador.

Programación del Arduino

El programa debe realizar las siguientes subrutinas:

  1. Configurar el LCD.
  2. Establecer la variable del teclado.
  3. Establecer los pines de los leds y del buzzer como salida.
  4. Solicitar el tiempo en el que comenzará la cuenta atrás. Pulsando # se guardará el dato y saldrá de la subrutina, mientras que con * se borrará y volverá a pedir el tiempo.
  5. Solicitar la clave de desactivación de 4 dígitos. Pulsando # se guardará el dato y saldrá de la subrutina, mientras que con * se borrará y seguirá pidiéndola. Solo será visible el último dígito, el resto estará representado por *.
  6. Cuenta atrás donde se evaluará:
    • Si se introducen números comprobando si la clave es correcta al introducir el 4ª dígito. Se finaliza el programa con un mensaje de desactivación de bomba, si la clave es correcta y si es incorrecta se borra el dato y se espera la entrada de la nueva clave (se imprime un mensaje indicando que la clave es incorrecta).
    • Si se ha llegado a cero en la cuenta atrás. Se finaliza el programa con un mensaje de detonación de la bomba.

Por lo que el diagrama de flujo sería algo parecido a este:

Para programar el uso de los dispositivos utilizaré dos librerías:

Keypad para el uso simplificado del teclado en matriz de membrana, disponible en https://github.com/Chris–A/Keypad

LiquidCrystal_I2C para el control del display LCD 16×2 I2C. Se puede instalar por medio del Gestor de librerías del IDE de Arduino o descargarla desde https://github.com/johnrickman/LiquidCrystal_I2C

Otra característica del programa es que usaré al comienzo del programa una variable que estable el momento en el que el contador llega a cero a partir del momento en el que comienza la cuenta atrás, por lo que realmente no hay contador, sino que se compara el momento actual, dado por la función millis(), con el momento en el cual detonará la bomba.

Ve como funciona el proyecto