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)

 

Llega el ESP32-C3 Supermini a Edubótica Marina en Plocan

Desarrollando el proyecto Edubótica Marina (EduROV) durante el curso 2025-26

Dentro del proyecto de Edubótica Marina impulsado por PLOCAN, uno de los desarrollos más interesantes ha sido la creación de un mando de control inalámbrico para un ROV (Remotely Operated Vehicle) utilizando tecnología BLE (Bluetooth Low Energy).

El objetivo era claro: construir un sistema de control sencillo, económico y replicable en entornos educativos, permitiendo al alumnado comprender conceptos de electrónica, programación y comunicaciones inalámbricas aplicadas a la robótica submarina.

Para este desarrollo se eligió el ESP32-C3 SuperMini, una placa extremadamente compacta, eficiente y con conectividad BLE integrada, ideal para este tipo de aplicaciones. Sin embargo, debido a su reducido tamaño, trabajar directamente sobre ella puede resultar incómodo a nivel de prototipado. Por ello se utilizó una placa adaptadora tipo Funduino, que permite exponer todos sus pines de forma accesible y facilita enormemente la conexión con drivers, motores y sensores.

La experiencia de desarrollo fue muy positiva: el sistema respondió de forma estable, con baja latencia y gran fiabilidad durante las pruebas. Además, se diseñó una aplicación móvil personalizada mediante MIT App Inventor, integrando la librería BLE necesaria para enviar órdenes al ROV de manera intuitiva.


Arquitectura del sistema

Podríamos decir que el sistema se divide en tres elementos esenciales:

  • Móvil Android con APP desarrollada en App Inventor como interfaz de control.
  • ESP32-C3 SuperMini como receptor BLE y cerebro del sistema, con puentes en H para controlar los motores.
  • ROV con tres ejes de movimiento:
    • Eje X-Y (avance, retroceso y giro)
    • Eje Z (subida y bajada)

Para poder dar las órdenes de movimiento sobre el ROV, la APP envía un carácter por BLE, cada vez que se pulsa o libere los botones dispuestos en la pantalla:


F → Forward (avanzar)

B → Backward (retroceder)

L → Left (giro izquierda)

R → Right (giro derecha)

S → Stop horizontal

U → Up (subir)

D → Down (bajar)

V → Stop vertical

 

Programando el ESP32-C3 Supermini

¿Qué hacer cuando el dispositivo se conecta y desconecta por BLE?

Lo primero es definir las librería a usar para el BLE. Debes tener en cuenta que el ESP32 C3 Supermini no tiene BT normal por lo solo podemos usar BLE, que aunque es un pelín más complejo, nos permite tener un mundo de posibilidades.

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>

// UUIDs para la conexión BLE
#define SERVICE_UUID        "4fa124a6-9954-4697-97d1-5056f87f91ba"
#define CHARACTERISTIC_UUID "62fbd229-3c4f-4d94-a134-c09cfec6e56a"

Ya con las librerías y los UUIDs definidos, toca describir cómo reaccionará el ESP32 C3 cuando la aplicación móvil se conecte o desconecte.

class MisCallbacksServidor: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      Serial.println("App Conectada");
      digitalWrite(led, HIGH);
    }

    void onDisconnect(BLEServer* pServer) {
      Serial.println("App Desconectada - Motores detenidos por seguridad");
      digitalWrite(led, LOW);
      pararTodo();
      pServer->getAdvertising()->start();
    }
};

¿Qué hace este código tan loco?

Este fragmento crea una clase personalizada que hereda de BLEServerCallbacks, lo que permite capturar eventos importantes del Bluetooth.

onConnect()

Se ejecuta cuando la app se conecta correctamente:

  • Muestra un mensaje por monitor serie.
  • Enciende el LED integrado para indicar conexión activa.

Esto sirve como indicador visual y de depuración.

onDisconnect()

Se ejecuta cuando se pierde la conexión:

  • Informa de la desconexión.
  • Apaga el LED.
  • Detiene todos los motores por seguridad.
  • Reinicia el advertising BLE para permitir nuevas conexiones.

Este punto es especialmente importante en un ROV: evita que los motores sigan activos sin control.


Callback de recepción de órdenes

Gracias a esta función somos capaces de recibir las órdenes del control remoto y llamar a una función en concreto para actuar en consecuencia.

class MisCallbacksCaracteristica: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      String valor = pCharacteristic->getValue();

      if (valor.length() > 0) {
        char comando = valor[0];

        Serial.print("Orden recibida: ");
        Serial.println(comando);

        switch(comando) {
          case 'F': avanzar();         break;
          case 'B': retroceder();      break;
          case 'L': girarIzquierda();  break;
          case 'R': girarDerecha();    break;
          case 'S': pararHorizontal(); break;
          case 'U': subir();           break;
          case 'D': bajar();           break;
          case 'V': pararVertical();   break;

          default: pararTodo();        break;
        }
      }
    }
};

¿Cómo funciona este código?

Esta función se ejecuta cada vez que la APP envía datos por medio de BLE.

Su funcionamiento es simple:

  1. Lee el dato recibido por BLE.
  2. Extrae el primer carácter.
  3. Lo interpreta como comando.
  4. Ejecuta la acción correspondiente. (Vamos, el switch actúa como traductor entre la app y el movimiento físico del ROV.)

 

Vemos un  ejemplo:

Si la app envía:

F

El ESP32 ejecuta:

avanzar();

Y activa los motores para mover el vehículo hacia delante.


Resultado del proyecto

Las pruebas realizadas fueron muy satisfactorias y el resultado es un sistema de control desde APP donde se puede destacar:

✅ Conexión BLE rápida y estable
✅ Respuesta inmediata a los comandos
✅ Bajo consumo energético
✅ Fácil integración con App Inventor
✅ Código modular y fácil de ampliar

El uso del ESP32-C3 SuperMini demostró ser una solución excelente para proyectos educativos de robótica submarina con pocas necesidades de pines, especialmente al combinarlo con una placa adaptadora que simplifica el montaje del cableado.

Estuvimos presentes en las IV Jornadas STEAM del CEP Las Palmas

Con gran satisfacción, anunciamos la participación del IES Carrizal en las IV Jornadas STEAM organizadas por el CEP Las Palmas, en la sesión celebrada el pasado sábado, 07 de marzo de 2026. En esta importante cita para la educación STEAM, nuestro centro estuvo representado con la presentación de las placas Edushield Canarias, una herramienta educativa innovadora que promueve el aprendizaje práctico y el desarrollo de habilidades tecnológicas entre nuestros estudiantes.

La participación del IES Carrizal se centró en la demostración de las capacidades pedagógicas de Edushield Canarias, explorando su aplicación en proyectos STEAM, analizando sus ventajas y como ha sido el desarrollo de estas, en función de las necesidades en el aula. Los asistentes tuvieron la oportunidad de conocer de primera mano cómo facilita la experimentación, la resolución de problemas y la creatividad en el aula, facilitando la docencia, pero sin perder capacidades prácticas a un precio moderado.

Agradecemos al CEP Las Palmas y nuestro compañero Eugenio la invitación a formar parte de este evento, que se ha consolidado como un espacio de encuentro e intercambio de experiencias entre docentes y profesionales de la educación STEAM. Además de nuestra participación, destacamos la alta calidad y el gran valor de las ponencias presentadas por otros expertos, como Soraya Díaz,  Simón Martín o Víctor R. Ruiz, entre otros. Estas iniciativas demuestran el compromiso y la innovación que caracterizan a la comunidad educativa canaria en el ámbito STEAM.

El IES Carrizal reafirma su compromiso con la promoción de la educación STEAM y continuará explorando nuevas herramientas y metodologías para enriquecer el aprendizaje de nuestros alumnos y alumnas, preparándolos para los retos del futuro.

¡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í: