Este apartado está extraído de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
Una placa Imagina TdR STEAM versión 2.0 como la de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/tdr-steam.png) Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA Una placa ESP32 Plus STEAMakers. [](https://libros.catedu.es/uploads/images/gallery/2022-12/esp32-steamakers.png) Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA Mando de control remoto por infrarrojos para utilizar en conjunto con el sensor de infrarrojos integrado en la placa TdR-STEAM.{{@2936#bkmrk-%C2%BFsab%C3%ADas-que....-%3F%C2%A0un}}
##### **Segundo ¿Qué es un microcontrolador?** {{@2936#bkmrk-es-un-circuito-integ}} {{@2936#bkmrk-arduino-utiliza-la-m}} ##### **Tercero ¿Arduino tiene wifi?** {{@7069#bkmrk-resumiendo-brevement}} {{@7069#bkmrk-resumiendo-brevement-0}} {{@7069#bkmrk-el-esp8266-se-vende-}} [](https://libros.catedu.es/uploads/images/gallery/2022-08/esp01-1.png) *Fuente Luis Llamas CC-BY-NC-SA [ver](https://www.luisllamas.es/arduino-wifi-esp8266-esp01/)*{{@7069#bkmrk-por-eso-se-habla-ind}}
{{@7069#bkmrk-su-bajo-precio-y-su-}} {{@7069#bkmrk-pero...-%28por-qu%C3%A9-sie}} {{@7069#bkmrk-nuestro-consejo-si-p}} {{@7069#bkmrk-nodemcu-que-se-ha-ut}} ##### **Cuarto: ¿El ESP32 es ....?** Es una placa sucesora del ESP8266 de bajo coste y consumo que tiene el microprocesador Tensilica 32bits (variante el Xtensa LX6) que tiene Wifi y Bluetooth integrados. Como dice Luis Llamas en [https://www.luisllamas.es/esp32/](https://www.luisllamas.es/esp32/) el ESP32 es el hermano mayor del ESP8266 con Wifi y Bluetooth. *[](https://libros.catedu.es/uploads/images/gallery/2022-12/esp32.png)* *Módulo ESP32 Fuente Luis Llamas CC-BY-NC-SA [https://www.luisllamas.es/esp32/](https://www.luisllamas.es/esp32/)* Es posible programarlo usando código IDE de Arduino, pero también se puede programar con MicroPython.Su principal característica es su potencial de uso en aplicaciones IoT
- Para saber más - Consideraciones sobre ESP32 [https://fgcoca.github.io/ESP32-STEAMakers/conesp32/](https://fgcoca.github.io/ESP32-STEAMakers/conesp32/) > Evolucion de búsquedas en Google de Arduino, Raspberry PI, ESP32 y MicroBit > > -Arduino y Rpi tuvieron máximo en 2017-18. Desde entonces bajan. > -Arduino aguanta tipo > -Rpi cuesta abajo sin frenos > -ESP32 despega 👍👍 > -Microbit no, pese a que tuvo buen arranque (inmerecido?) [pic.twitter.com/A2Pl18qecZ](https://t.co/A2Pl18qecZ) > > — Luis Llamas (@LuisLlamas) [August 9, 2023](https://twitter.com/LuisLlamas/status/1689370030184472577?ref_src=twsrc%5Etfw) # Hardware ESP32 Plus STEAMakers Esta placa está basado en el ESP32 que hemos visto que tiene : - Wifi integrado - Bluetooth integrado - Puede trabajar con el código IDE de Arduino Pero, esta [versión de Innova Didactic](https://shop.innovadidactic.com/es/standard-placas-shields-y-kits/1567-placa-esp32-steamakers.html) además incorpora : - Zócalo para tarjetas microSD para almacenamiento de datos. - Conexiones iguales que cualquier tarjeta Arduino UNOEsto permite usar cualquier Shield de Arduino, como la TDR STEAM Imagina de este curso. Para saber las diferentes Shields de Arduino mira esta página [https://libros.catedu.es/books/programa-arduino-mediante-codigo/page/hardware](https://libros.catedu.es/books/programa-arduino-mediante-codigo/page/hardware)
En la figura ¿Puedes localizar el ESP32 famoso? [](https://libros.catedu.es/uploads/images/gallery/2022-12/placa-esp32-steamakers.jpg) *Imagen Fuente Innovadidactic*El contenido mostrado a continuación es de [la web de Federico Coca](https://fgcoca.github.io/ESP32-STEAMakers/hsteamakers/) Licencia CC-BY-SA
La placa ESP32 Plus STEAMakers nos ofrece una gran cantidad de prestaciones al estar basada en un microcontrolador de 32 bits con conectividad WiFi y Bluetooth integradas en la propia placa y también un zócalo para tarjetas µSD para el almacenamiento de datos. También dispone de conexiones para todas las entradas y salidas con posibilidad de tener la alimentación adjunta y puertos de expansión I2C para poder conectar diferentes dispositivos directamente en la placa. La placa está basada en el microcontrolador ESP32-WROOM-32 y sus principales especificaciones técnicas son: - Microcontrolador Tensilica Xtensa 32-bit LX6 a 160MHz. - Conectividad WiFi 802.11 b/g/n/e/i. - Conectividad Bluetooth 4.2 y modo BLE. - Zócalo para tarjetas µSD. - 14 entradas y salidas digitales con alimentación. - Conector serie hembra con alimentación. - Conector I2C para conectar hasta 5 dispositivos a la vez sobre la misma placa. - Conector hembra I2C para conexión de una pantalla OLED. - Botón de Reset. - Conector de 5V - Conector de 3.3V - Interruptor 3.3-5V para cambiar entre estas dos tensiones en algunos pines de alimentación. - Entradas y salidas analógicas. - Sensor Hall y de temperatura integrado. - 2 convertidores Digital-Analógico (DAC) de 8 bits. - 16 convertidores Analógico-Digital (ADC) de 12 bits. - 16 canales PWM. - 2 UART. - 2 canales I2C. - 4 canales SPI. - 448Kb ROM. - 520 KB SRAM. - 8KB+8KB SRAM en RTC. - 1kbit eFUSE. - 512 bytes Memoria Flash (EEPROM). - 10 sensores táctiles. - 4 temporizadores internos de 64 bits. No están disponibles todas las características del controlador ESP-WROOM-32, ya que algunos pines tienen funciones dobles y se utilizan en la placa de forma específica (como, por ejemplo, para controlar la tarjeta SD). Pero la mayoría de funciones se pueden utilizar, además de disponer la placa ESP32 Plus STEAMakers de una mejor conexión de elementos debido a los pines para conectores tipo Dupont de entrada y salida, de I2C y de alimentación. Además, algunos pines de alimentación pueden cambiar su valor (3,3V o 5V) mediante un interruptor en función de nuestras necesidades. A continuación vemos una imagen en la que se compara el potencial de la placa ESP32 Plus STEAMakers En la figura siguiente vemos los elementos que componen la placa ESP32 Plus STEAMakers: [](https://libros.catedu.es/uploads/images/gallery/2022-12/elementos.png) *Imagen [Federico Coca](https://fgcoca.github.io/ESP32-STEAMakers/hsteamakers/) CC-BY-SA*Las conexiones de la placa Imagina TDR STEAM con la placa ESP32 Plus STEAMakers son las mismas que si utilizamos cualquier placa compatible con Arduino UNO.
**Importante**: Todos los pines IOxx son entradas y salidas digitales, algunas con más funciones. Utilizando la comunicación WiFi no funciona el ADC2. En la tabla siguiente tenemos relacionados todos los pines entre los tipos de placas UNO, Imagina TdR STEAM y ESP32 STEAMakers.| UNO | TdR STEAM | ESP32 | ||
|---|---|---|---|---|
| Pin | Función | Pin | Función | Ampliación |
| D0 | Rx | IO03 | Rx | UART 0 RX |
| D1 | Tx | IO01 | Tx | UART 0 TX |
| D2 | Pulsador SW1 | IO26 | ADC2 CH9 | DAC2 |
| D3 | Libre | IO25 | ADC2 CH8 | DAC1 |
| D4 | DHT11 | IO17 | UART 2 TX | |
| D5 | Libre | IO16 | UART 2 RX | |
| D6 | Color rojo del LED RGB | IO27 | ADC2 CH7 | ADC2-7 / TOUCH7 |
| D7 | Pulsador SW2 | IO14 | ADC2 CH6 | ADC2-6 / TOUCH6 |
| D8 | Zumbador o buzzer | IO12 | ADC2 CH5 | ADC2-5 / TOUCH5 |
| D9 | Color verde del LED RGB | IO13 | ADC2 CH4 | ADC2-4 / TOUCH4 |
| D10 | Color azul del LED RGB | IO05 | VSPI CSO | |
| D11 | Sensor IR | IO23 | VSPI MOSI | |
| D12 | LED rojo | IO19 | VSPI MISO | |
| D13 | LED azul | IO18 | VSPI CLK | |
| GND | GND | |||
| AREF | Reset | |||
| SDA | I2C | IO21 | ||
| SCL | I2C | IO22 | ||
| A0 | Potenciómetro | IO02 | ADC2 CH2 | |
| A1 | Sensor de luz (LDR) | IO04 | ADC2 CH0 | |
| A2 | Sensor de temperatura (LM35) | IO36 | ADC1 CH0 | |
| A3 | Libre | IO34 | ADC1 CH6 | |
| A4 | I2C | IO38 | ||
| A5 | I2C | IO39 | ADC1 CH3 | |
| VIN | VIN | |||
| GND | GND | |||
| GND | GND | |||
| 5V | 5V | |||
| 3.3V | 3.3V | |||
| RST | Reset | |||
| 5V | 5V | |||
| IO00 | ¡ No conectar ! | |||
| - | IO32 | D0 - uSD | ||
| - | IO15 | CLK - uSD | ||
| - | IO33 | CMD - uSD | ||
| - | IO35 | IOUT | Medidor de corriente | |
| - | IO37 | VOUT | Medidor de tensión |
Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
La placa ESP32 Plus STEAMakers se basa en el microcontrolador ESP32-WROOM-32 que dispone de dos sensores internos. Se trata de un **sensor de efecto hall** y un **sensor de temperatura.** La placa ESP32 Plus STEAMakers lleva implementado un **medidor de tensión e intensidad** con el que podemos saber la tensión de alimentación en todo momento. Si la tensión de alimentación baja de aproximadamente 4,8V la placa no funcionará correctamente (sobre todo la transmisión WiFi). Es recomendable realizar una verificación de la tensión que está entregando el puerto USB del ordenador. Si la tensión no es próxima a 5V deberemos cambiar el cable USB, alimentar el puerto USB de forma externa o alimentar la placa con una fuente de alimentación. Es decir, dispone de un sistema para poder medir el consumo de energía. Los bloques para trabajar con estos sensores están en 'Sensores`, entrada 'Integrados', y son los que vemos en la figura siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/sint.png) # Software Hemos visto que el ESP32 acepta código IDE Arduino, por lo tanto puede programarse como un Arduino, (acepta microPython, mBlock, etc... ) pero nuestra recomendación es programarlo con **bloques gráfico** con dos opciones : - **STEAMAKERSBLOCKS** (antes ARDUINOBLOCKS) es el programa que se usa en este tutorial - 😒 es **lento** cargando el programa y hay que tener bien instalado Connector - 😒sólo online - 😍permite programas **IoT** - 😍 tiene una buena **gestión de alumnado** ideal para envío de proyectos y corregirlos - 😍 tiene un canal de Telegram de apoyo al docente [https://t.me/innovadidactic\_comunidad](https://t.me/innovadidactic_comunidad) - **MICROBLOCKS** El tutorial recomendado es: [https://pedroruizf.github.io/steamakersmicroblocks](https://pedroruizf.github.io/steamakersmicroblocks) - 😒 no permite muchos programas IoT - 😍es muy rápido al ejecutar y no da problemas de configuración - 😍local o online Si quieres saber más sobre las diferencias entre programar con código, con bloques gráficos, en vivo, en carga... [aquí](https://libros.catedu.es/books/programa-arduino-mediante-codigo/page/software) # STEAMAKERBLOCKS # ¿Qué es Steamakerblocks? {{@5126}} # Crear cuenta en STEAMAKERBLOCKS {{@5973}} # Cuentas alumnos {{@5127}} # Connector {{@5128}} # Empezando un proyecto {{@5129}} ##### **Con Imagina TdR STEAM ¿Qué tipo de proyecto elijo?** Para aclarar, las dos opciones son válidas para nuestros proyectos, pero la específica con Imagina TdR STEAM es más cómoda: - - **La placa sola (ESP32 STEAMakers)** donde te aparecerán todos los sensores y salidas con todas las posibilidades de entradas y salidas (E/S) de la placa (Arduino o ESP32) - **La placa (ESP32 STEAMakers) + Imagina TdR STEAM** donde aparecen: - Los sensores y salidas específicas de la placa TdR STEAM ya conectadas en sus respectivos pines E/S del ESP32. - En contra, algunos sensores ya no aparecen todas las E/S del Arduino que están ocupadas por los elementos de la placa TdR STEAM. ##### **Vamos a poner un ejemplo: Hacer una intermitencia con el LED AZUL del TdR STEAM** Si lo hacemos con el tipo de proyecto **ESP32 STEAMaker** tenemos que poner el Actuador LED y en el pin elegir el 13 porque el led Azul está conectado en el 13. Fíjate que en el desplegable del Pin están todas las E/S del ESP32 [](https://libros.catedu.es/uploads/images/gallery/2022-08/ejemploplacaarduino.png) En cambio si elegimos un proyecto tipo **ESP32 STEAMaker+ Imagina TdR STEAM** veremos que tenemos añadidos unos actuadores específicos para esta placa TDR STEAM que es más fácil usarlos, donde en el desplegable sólo aparece ROJO o AZUL y el alumno **no necesita recordar** que ROJO es el 12 y AZUL es el 13Pero si elegimos un led del desplegable de actuadores, veremos que en su desplegable de pines sólo aparece los números 3, 5 y A3 **porque son los que tiene libres, el resto están ocupados por la placa TdR STEAM**
[](https://libros.catedu.es/uploads/images/gallery/2022-08/ejemploplacatdr.png) Está claro que el tipo de proyecto **ESP32STAMaker+ Imagina TdR STEAM** es más cómodo por que los bloques ya tienen fijados qué pines tienen cada sensor y si eliges un sensor no incluido en la placa, ya no muestra los pines que están ocupados.Si eliges **ESP32STEAMaker + Imagina TdR STEAM** es muy cómoda la programación y se evitan muchos errores.
Si eliges **ESP32STEAMaker utilizas un entorno de programación como si la placa Imagina TdR STEAM no existiera y los alumnos se acostumbran a usar los elementos propios de ESP32, los pines, etc.... pero tienen que saber en cada momento qué pin utilizar. Aconsejamos en este caso que los alumnos tengan impresa la página [Componentes de la placa TdR STEAM](https://libros.catedu.es/books/arduino-en-el-aula/page/componentes-de-la-placa-imagina-tdr-steam).
En los apuntes de este libro vamos a utilizar el proyecto indistintamente las dos formas de trabajar. # Prácticas con sensores digitales # Actividad-01. LEDPágina extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** Realizar un programa que encienda y apague el LED rojo conectado al pin D12 DE LA PLACA STEAMMAKER. ##### **Teoría** El diodo LED (Light Emitting Diode) es un diodo semiconductor capaz de emitir luz, lo mas usuales dentro del espectro visible aunque también pueden ser de infrarrojos, laser, etc. Su uso mas habitual es como indicador y, últimamente cada vez mas frecuentes en iluminación. Sus principales ventajas frente a luces incandescentes son: - Menor consumo de energía - Mayor vida útil - Menor tamaño - Gran durabilidad y fiabilidad En la imagen siguiente vemos el aspecto físico que tiene y su símbolo electrónico. [](https://libros.catedu.es/uploads/images/gallery/2022-12/led.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* El color de la cápsula es simplemente orientativo de la longitud de onda que define realmente el color de la luz emitida. Por ello el LED con la cápsula transparente puede emitir en cualquiera de los colores del espectro visible. El LED es un dispositivo que tiene polaridad siendo su comportamiento el siguiente: En polarización directa (ánodo a positivo y cátodo a negativo) el LED emite luz y en polarización inversa (ánodo negativo y cátodo positivo) se comporta prácticamente como un interruptor abierto. Para su correcto funcionamiento el diodo LED se polariza poniéndole en serie una resistencia que limita la corriente que pasa a través del mismo y, por tanto, determina el nivel de brillo de la luz emitida. Sin entrar en detalles en la tabla siguiente se dan los valores de tensión directa (VF) y corriente directa (IF) para los colores mas habituales de LEDs. A partir de estos valores y el valor de tensión de alimentación de nuestro LED podemos calcular el valor de la resistencia serie sin mas que aplicar la formula indicada. [](https://libros.catedu.es/uploads/images/gallery/2022-12/colores-calculo-r.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* *Si quieres saber más de cómo calcular la Resistencia para un led [mira esta hoja de cálculo ](https://docs.google.com/spreadsheets/d/1bmlsaV8fV8TT1LySV2Mka2byHtnHI3b8/edit?usp=sharing&ouid=103474539184416151174&rtpof=true&sd=true)pero sustituye la Vcc por 5 V* #### **En la TdR STEAM** La placa Imagina TDR STEAM dispone de un LED rojo conectado al pin D12 tal y como se indica en la serigrafía de la propia placa y que podemos ver en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/led-d12.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la Actividad** Entramos en ArduinoBlocks y nos identificamos convenientemente. Vamos a crear un nuevo proyecto para la placa ESP32 STEAMakers + TdR STEAM. Escogemos el bloque LED de TDR STEAM y lo colocamos en el bucle, quedando algo similar a la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/led-rojo-on.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Bloque LED de TDR STEAM Podemos comprobar haciendo clic sobre las flechas como podemos cambiar de LED y también como podemos cambiar de estado al LED. Si solamente dejamos este bloque el LED permanecerá encendido de forma permanente y para que se acabe debemos ponerlo en estado OFF. En la imagen siguiente vemos el programa como quedaría. [](https://libros.catedu.es/uploads/images/gallery/2022-12/led-d12-on-off.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* LED D12 a ON y OFF Pero este programa no nos permite ver el efecto de encendido y apagado del LED debido a la velocidad de procesamiento que tiene la placa UNO que típicamente trabaja a 16 MHz. Esto supone que el micro tarda en ejecutar una instrucción algo mas de 0,06 microsegundos que es mucho menor que la persistencia visual humana de 0,1 segundo aproximadamente. Es decir, en realidad el LED se enciende y se apaga, pero nuestro ojo no puede apreciarlo y lo verá siempre encendido debido a la persistencia visual. Tenemos por tanto que dejar el diodo un tiempo encendido y otro apagado (pueden ser el mismo tiempo) y para ello vamos a colocar un bloque Esperar desde el bloque de Tiempo. Si dejamos el tiempo por defecto en 100 milisegundos el diodo se encenderá y apagará cada segundo (1000 ms = 1s). El programa final queda como vemos en la imagen siguiente y lo tenemos disponible en el enlace [ESP32-SM-Actividad-01.](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-01.abp) [](https://libros.catedu.es/uploads/images/gallery/2022-12/led-rojo-ok.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Programa final para el LED rojoColoca la placa Imagina TDR STEAM encima del ESP32
Conectamos nuestra placa a un puerto USB del ordenador, ponemos en marcha el programa Connector y cargamos el programa. Podemos observar como el diodo LED rojo parpadea con un intervalo de un segundo. De esta forma el programa queda grabado en la memoria de programa del microcontrolador y el ciclo se repetirá por tiempo indefinido o hasta que quitemos la alimentación a la placa. Si alimentamos la placa externamente con una fuente de alimentación se ejecutará el programa en memoria. ##### **Retos de ampliación** R1.A1. Cambiar los tiempos para que el parpadeo sea más rápido, mas lento y que los tiempos de encendido y apagado no coincidan. R2.A1. Repetir el ejercicio A1 utilizando el LED azul conectado al pin D13. [](https://libros.catedu.es/uploads/images/gallery/2022-12/led-d13.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* # Actividad-02. LEDs rojo y azulPágina extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### Enunciado Como ya hemos visto anteriormente la placa dispone de dos LED (uno rojo y otro azul). Vamos a realizar un programa para que se vayan alternando en su encendido y apagado. ##### **Teoría** Vamos a ver como se hacen los ciclos de repetición o bucles en ArduinoBlocks. - **Repetir**. En el menú de Control existe el bloque 'Repetir (valor) veces hacer…', como el de la imagen siguiente:[](https://libros.catedu.es/uploads/images/gallery/2022-12/cKtrepetir.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Lo que pongamos en hacer se va a repetir tantas veces como indiquemos en el número de veces, que por defecto estará a 10. En realidad lo que estamos haciendo es lo que en programación se conoce como bucle for. - **Repetir según condición.** En la imagen siguiente vemos dos bloques que repiten su interior mientras, o hasta, que se cumpla una condición. [](https://libros.catedu.es/uploads/images/gallery/2022-12/repetir-hasta.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* - **Contador**. Realiza un bucle contando con un variable índice (normalmente i o j). Se define un valor de inicio, una valor de fin y los incrementos que se realizarán en cada iteración del bucle. Dentro del bucle podremos usar esta variable índice. [](https://libros.catedu.es/uploads/images/gallery/2022-12/contar.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2022-12/rojo-azul.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Los dos LEDs de la TdR-STEAM #### **Programando la Actividad** Vamos a hacer que ambos diodos se enciendan y apaguen de forma simultanea con un programa como el siguiente, que lo tenemos disponible en [Actividad-02. LED-rojo-azul](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-02.abp) [](https://libros.catedu.es/uploads/images/gallery/2022-12/reto02-rojo-azul.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Intermitencia LEDs rojo y azul ##### **Retos de ampliación** A2.R1. Hacer que los LEDs rojo y azul se enciendan simultáneamente con tiempos de espera de 300ms y 150ms respectivamente. A2.R2. Realizar 4 intermitencias de 500ms con el LED azul y cuando estas acaben dejar el LED rojo encendido durante 1.5 segundos. Esperar un segundo para iniciar de nuevo el proceso. A2.R3. Realiza 5 intermitencias de 500ms con el LED azul cada vez que el LED rojo lo hace 3 veces a intervalos de 150ms. Esperar un segundo para iniciar de nuevo el proceso. **Solución A22.R2** El Programa es el de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/reto02-a2.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* **Solución A2.R3** El Programa es el de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/Byareto02-a3.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* # Actividad-03. Parpadeo intermitente. MultitareaPágina extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
#### **Enunciado** Ya hemos visto como hacer funcionar a los LEDs de diferentes formas, pero ahora vamos a introducir un concepto que nos puede resultar bastante útil en el futuro, se trata de la multitarea en ArduinoBlocks. ##### Teoría Este apartado se extrae de ArduinoBlocks - FreeBook disponible en Free Book (online & updated). ArduinoBlocks nos permite utilizar una capa para implementar un sistema multitarea avanzado basado en FreeRTOS (del inglés Real Time Operating System), que es un sistema operativo de tiempo real kernel para dispositivos embebidos para plataformas de microcontrolador que se distribuye bajo licencia MIT. Este sistema permite crear tareas que se ejecutarán de forma paralela (virtualmente). En microcontroladores modestos como el Arduino UNO, Nano o incluso MEGA la multitarea con FreeRTOS es bastante limitada y consume gran parte de los recursos de nuestro Arduino, en caso de necesitar de un sistema multitarea más potente podemos optar por usarlo en placas basadas en ESP8266 o ESP32 con mucha más potencia y recursos (especialmente el ESP32 con doble núcleo y gran potencia de procesamiento y memoria interna) Los sistemas software de multitarea utilizan un planificador o scheduler que se encarga de repartir el tiempo de procesamiento entre las distintas tareas, de forma que a cada una le toca un tiempo de microcontrolador para ejecutar un poquito de su parte de programa. En las web de freeRTOS, en su entrada de menú Kernel podemos encontrar los conceptos básicos de multitarea y de programación que vamos a extractar seguidamente. ##### **Conceptos básicos de multitarea** Un procesador convencional como el de Arduino UNO solo puede ejecutar una tarea a la vez, pero al cambiar rápidamente entre tareas, un sistema operativo multitarea puede hacer que parezca que cada tarea se ejecuta simultáneamente. Esto es lo que se representa en el diagrama de la Figura siguiente que muestra el patrón de ejecución de tres tareas con respecto al tiempo. Los nombres de las tareas están codificados por colores y escritos a la izquierda. El tiempo se mueve de izquierda a derecha y las líneas de colores muestran qué tarea se está ejecutando en un momento determinado. El diagrama superior demuestra el patrón de ejecución concurrente percibido, y el inferior el patrón de ejecución multitarea real. [](https://libros.catedu.es/uploads/images/gallery/2022-12/patron.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Patrón de ejecución de tres tareas con respecto al tiempo ##### **Programación** El programador es quien debe decidir qué tarea debe ejecutarse en un momento determinado. El kernel o núcleo puede suspender y luego reanudar una tarea muchas veces durante el tiempo de vida de la tarea. Además de ser suspendida involuntariamente por el núcleo o kernel, una tarea puede optar por suspenderse a sí misma. Hará esto si desea retrasar (**dormir**) por un período fijo o esperar (**bloquear**) a que un recurso (por ejemplo, un puerto serie) esté disponible, o que ocurra un evento (por ejemplo, presionar una pulsador). Una tarea bloqueada o inactiva no se puede ejecutar y no se le asignará ningún tiempo de procesamiento. En la Figura siguiente vemos un posible diagrama de ejecución de tres tareas analizado punto por punto en distintos instantes de tiempo. En los círculos se representan los instantes de tiempo t1 a t10. [](https://libros.catedu.es/uploads/images/gallery/2022-12/diagrama.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Diagrama de ejecución de tres tareas en el tiempo t1: la tarea 1 se está ejecutando. t2: en el kernel se suspende, o mejor dicho se intercambia, la tarea 1 . t3: se reanuda la tarea 2. t4: mientras se ejecuta la tarea 2 el procesador bloquea el puerto serie para su acceso exclusivo. t5: el kernel suspende la tarea 2. t6: el kernel reanuda la tarea 3. t1: la tarea 3 intenta acceder al puerto serie y lo encuentra bloqueado por lo que no puede continuar y se suspende. t8: el kernel reanuda la tarea 1 . t9: al ejecutarse de nuevo la tarea 2 se desbloquea el puerto serie. t10: la tarea 3 ahora si puede acceder al puerto serie y se ejecuta al completo ##### **Planificadores** Los planificadores de multitarea permiten asignar a cada tarea una prioridad, para así darle preferencia a las tareas más críticas o que necesitan más tiempo de procesamiento. Si creamos muchas tareas con “alta” prioridad puede que afectemos a las demás dejando poco tiempo de procesamiento para ellas. En la Figura siguiente vemos un esquema de varias tareas con distintas prioridades, variando así su tiempo de microprocesador asignado. [](https://libros.catedu.es/uploads/images/gallery/2022-12/planificadores.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Distintas prioridades en tres tareas Cada tarea tiene su propio espacio de memoria, por lo que crear demasiadas tareas también puede dejarnos el procesador sin memoria. Si la memoria asignada a las tareas tampoco es suficiente para almacenar los datos se podría reiniciar de forma inesperada el Arduino, o funcionar incorrectamente, es decir que como siempre, hay que ser consciente de los limitados recursos de los que disponemos. ##### **Semáforos** Con la introducción teórica a la multitarea vista, debemos hacernos otra pregunta: ¿Qué pasa si una tarea accede a un recurso o variable, y el sistema multitarea le da el control a otra tarea y por tanto ese proceso falla o quizás otra tarea acceda al mismo recurso y se solapen? Para ese problema de convivencia entre tareas se inventaron los “semáforos”, en concreto el que más nos interesa es el semáforo “mutex” o de exclusión mutua, que permite que bloqueemos el sistema multitarea, hagamos lo que tengamos que hacer crítico, y luego liberemos el control. Por supuesto estas tareas críticas deben ser lo más cortas y atómicas posibles: una escritura crítica en una variable, un envío de un dato, una actualización de una pantalla LCD,... siempre cosas simples. Los semáforos debemos usarlos en casos que tengamos claro que se pueden crear conflictos, pues su abuso puede hacer que el sistema multitarea empiece a fallar. En la Figura siguiente vemos el esquema de acceso a un recurso desde dos tareas diferentes. [](https://libros.catedu.es/uploads/images/gallery/2022-12/semaforo.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Esquema de acceso a un mismo recurso por parte de 2 tareas diferentes ##### **En la ESP32 STEAMakers** Una ventaja que posee la ESP32 Plus STEAMakers es que, al estar basado en un ESP32 con dos microcontroladores internos, podemos hacer que cada microcontrolador trabaje en una tarea y esto si sería multitarea real, o en varias tareas mezclando la multitarea real con la simulada. Esto también se puede hacer en las placas Arduino UNO, pero con el ESP32 tenemos más potencia para realizar estas tareas. Esquema de acceso a un mismo recurso por parte de 2 tareas diferentes ##### **Bloques esperar** ¿Qué pasa con los bloques tipo “esperar” que estaban tan prohibidos en la programación de Arduino cuando queríamos simular una multitarea antes de tener estos bloques? Pues seguimos teniéndoles bastante tirria. Aunque en teoría podríamos usarlos, un bloque esperar hace pensar al microcontrolador que está haciendo algo útil, cuando en realidad no es así, por lo que el sistema multitarea querrá asignarle tiempo de procesamiento a la tarea, aunque sea para eso, ¡para no hacer nada! Tenemos una solución, tenemos un nuevo bloque de esperar “task friendly” que en lugar de esperar sin hacer nada le dice al sistema: ¡voy a estar un rato sin hacer nada, permite ejecutar otras tareas mientras y luego vuelves! ….Mucho más “friendly”, claro que sí. ##### **Bloques** Con toda esta información pasamos a ver los bloques disponibles para poner todo ésto en marcha. *Imagenes Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA*| Bloque | Descripción |
|---|---|
|  | Permite crear una nueva tarea con su bloque de “inicializar” y su “bucle” al igual que la tarea original de Arduino. Debemos asignar una prioridad a cada tarea, por defecto dejaría todas a “baja” y luego iría ajustando si hace falta. Para gestionar mejor las prioridades, es recomendable en algunos casos no utilizar el “inicializar” y “bucle” propio de Arduino que suele tener preferencia sobre todas estas tareas y es más difícil de equilibrar las prioridades. |
|  | El bloque esperar óptimo para tareas, pues deja funcionar al resto de tareas de forma más óptima mientras se espera en ésta. Este bloque tiene menos precisión que el bloque “esperar” original, si necesitamos hacer esperas muy precisas (o de menos de 20 ms) debemos usar el “esperar” tradicional. Pero nos servirá en la mayoría de casos. |
|  | Si tenemos que hacer alguna acción crítica que no queremos que sea interrumpida internamente por el planificador del sistema multitarea podemos poner este bloque y dentro los bloques críticos. (no utilizar si no es estrictamente necesario) |
|  | Cada tarea tiene su propio espacio de memoria reservado, esta es la cantidad por defecto para las tareas (192 bytes), si necesitamos ajustarla podemos utilizar este bloque en el “inicializar” principal y se ajustará para todas las tareas. Un mal ajuste puede provocar reinicios del microcontrolador o mal funcionamiento. |
|  | Las tareas en principio, igual que el bucle de Arduino, están pensadas para ejecutarse de forma indefinida, si en un caso una tarea deja de ser necesaria la forma de terminarla es con este bloque que parará la ejecución y liberará la memoria de la tarea en la que se ejecuta. |
Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** La actividad básics consistirá en ver los colores primarios y su mezcla mediante el uso del LED RGB y también habrá una actividad secundaria sobre el control de intensidad mediante PWM. #### **Teoría** ##### **LED RGB** Un LED RGB es en realidad un encapsulado que incorpora tres diodos LED, uno por cada color fundamental. Los colores primarios en óptica son el rojo, el verde y el azul y la correcta combinación, en términos de intensidad, de ellos originará cualquiera de los colores secundarios. Las siglas RGB son el acrónimo de Red, Green y Blue. En el caso de la TDR-STEAM se utiliza un LED RGB con los tres LEDs unidos por su cátodo o terminal negativo, es decir es un LED RGB de cátodo común. En la imagen siguiente vemos el modelo aditivo de los colores rojo, verde y azul. [](https://libros.catedu.es/uploads/images/gallery/2023-01/rgb.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* El símbolo y la representación mas comunes de este componente lo vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/simbolo.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Teóricamente en Arduino, cada uno de esos LEDs podría adoptar 256 (valores entre 0 y 255) colores diferentes, es decir, un total de 16.777.216 posibles colores diferentes con un LED RGB. ##### **PWM** PWM son siglas en inglés que significan Pulse Width Modulation y que lo podemos traducir a español como Modulación de ancho de pulso. Los pines PWM permiten generar una señal analógica mediante una salida digital mapeada con 8 bits, o lo que es lo mismo, valores del 0 al 255, es decir mediante una salida PWM podemos emular una señal analógica. En realidad una placa tipo UNO no es capaz de generar una salida analógica y lo que se hace es emplear un truco que consiste en activar una salida digital durante un tiempo y el resto del tiempo del ciclo mantenerla desactivada. El valor promedio de la salida es el valor analógico. En el tipo de modulación PWM mantendremos constante la frecuencia, o lo que es lo mismo, el tiempo entre pulsos y lo que se hace es variar la anchura del pulso. La proporción de tiempo que está encendida la señal, respecto al total del ciclo, se denomina ciclo de trabajo o Duty cycle, y generalmente se expresa en tanto por ciento. En la imagen siguiente vemos señales con distintos ciclos de trabajo.Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
#### **Enunciado** Trabajaremos con el buzzer o zumbador partiendo de la reproducción de sonidos básicos hasta llegar a la reproducción de melodías completas. #### **Teoría** El buzzer, zumbador o altavoz es un transductor electroacústico (convierte una señal eléctrica en una onda de sonido) que produce un determinado zumbido o sonido. Existen de dos tipos: - Pasivos: no disponen de electrónica interna, por lo que tenemos que proporcionar una señal eléctrica para conseguir el sonido deseado. - Activos: disponen de un oscilador interno, por lo que únicamente tenemos que alimentar el dispositivo para que se produzca el sonido. El zumbador que incorpora la placa TdR STEAM es de tipo pasivo y está conectado al pin D8. Una de los parámetros que caracterizan a un sonido es su frecuencia de emisión, siendo la frecuencia el número de veces que se repite por unidad de tiempo (segundo). La transmisión del sonido se realiza por ondas a través en cualquier medio (sólido, líquido o gaseoso) excepto en el vacío. La frecuencia de un sonido nos indica cuantos ciclos por segundo tiene una onda. En la imagen y la tabla siguientes vemos un dibujo con un fragmento de las teclas de un piano estando todo referido a una nota estándar, la nota "La" central que tiene una frecuencia de 440 Hz. Podemos ver la nota musical que reproduce, en las dos notaciones más comunes de los sonidos (Inglés: C D E F G A B, Alemán: C D E F G A H, Español, italiano y francés: Do Re Mi Fa Sol La Si) y además se encuentra la frecuencia que produce esa nota musical. [](https://libros.catedu.es/uploads/images/gallery/2023-01/piano.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Bloques de programación** En ArduinoBlocks disponemos de un bloque que nos permite reproducir cualquier melodía RTTTL (del inglés, Ring Tone Text Transfer Language) y es el que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/reproducir-rtttl.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Este bloque permite reproducir una melodía a partir de un texto con formato RTTTL, formato desarrollado por Nokia para ser usado para transferir tonos de llamada a teléfonos móviles. El formato RTTTL es una cadena dividida en tres secciones: nombre, valor predeterminado y datos. Por ejemplo, la siguiente cadena de texto se corresponde con la Intro de Donkey Kong: Lo único que tenemos que hacer para reproducir la melodía es pegar esta cadena en la zona de texto del bloque. ``` d=4,o=5,b=140:8a#,8p,8d6,16p,16f.6,16g.6,16f.6,8a#,8p,8d6,16p,16f.6,16g.6,16f.6,8a#,8p,8d6,16p,16f.6,16g.6,16f.6,8a#,8p,8d6,16p,16f.6,16g.6,16f.6 ``` ArduinoBlocks nos suministra información y enlaces referentes al tema accediendo desde nuestro proyecto a herramientas y escogiendo RTTTL Info, tal y como vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/acceso-herramientas.png)*Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* En la imagen siguiente tenemos desplegada la información que nos ofrece esta herramienta. [](https://libros.catedu.es/uploads/images/gallery/2023-01/T1Brtttl-info.png) Información RTTTL *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* También podemos acceder a esta información haciendo clic derecho sobre el bloque y escogiendo la opción "Ayuda" de entre las mostradas en la ventana emergente. ##### **Zumbador activo** Existe otro tipo de zumbador que incluye un oscilador que genera una frecuencia audible fija y que se conoce como zumbador pasivo y en realidad es el que de forma correcta se puede denominar como zumbador. Este es mucho mas sencillo de usar ya que basta con conectarlo a un pin digital y cuando pongamos a nivel alto este pin el zumbador generará su zumbido característico durante el tiempo que establezcamos. Con este tipo de zumbador no se pueden generar melodías. Cuando está nuevo se distingue del zumbador pasivo o altavoz por la pegatina de protección que lo acompaña, pero esta hay que quitarla para oir el zumbido y sin ella es difícil distinguir un tipo del otro, así que en este caso deberemos crear un programa con alguna melodía y si no se reproduce correctamente es que tenemos conectado el zumbador activo en lugar del pasivo. Lo mejor es marcar alguno de los dos cuando podemos distinguirlos. Una buena idea puede ser utilizar la propia pegatina en el lateral del mismo. ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2023-01/buzzer-tdr.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la actividad** Los cuatro bloques destinados a trabajar con el zumbador los vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/bloques-buzzer.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* En el bloque Zumbador podemos modificar dos parámetros, el tiempo que dura cada sonido expresado en milisegundos (campo Ms) y la frecuencia en Hz a la que reproducirá el sonido el zumbador (campo Hz). Vamos a comenzar haciendo un programa que reproduzca tres de las notas de la escala musical vista anteriormente. La solución al reto la tenemos disponible en [Actividad-05](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-05.abp). [](https://libros.catedu.es/uploads/images/gallery/2023-01/actividad-05.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Retos de ampliación** A5.R1. Reproducir la escala musical con las notas básicas utilizando los bloques Zumbador y Tono A5.R2. Reproducir la melodía de la imagen siguiente sabiendo que las negras tienen una duración de 500ms, las negras con un puntito 750ms y las blancas 1000ms. [](https://libros.catedu.es/uploads/images/gallery/2023-01/partitura.png) *Himno a la alegría Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* A5.R3. Reproducir diferentes melodías a partir de los bloques RTTTL (Ring Tone Text Transfer Language o lenguaje de tonos de llamada). A5.R4. Reproducir alguna otra melodía que descarguemos de las páginas web propuestas. # Actividad-06. PulsadoresPágina extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
#### **Enunciado** Utilizaremos uno, o ambos pulsadores, para llevar a cabo determinadas tareas como respuesta al accionamiento de los mismos. #### **Teoría** ##### **El pulsador** En la tabla siguiente vemos la simbología y algunos ejemplos del aspecto físico de estos elementos. [](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-pulsadores.png) Símbolos y aspecto real de un pulsador *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Se trata de un dispositivo que es capaz de abrir o cerrar el paso de la corriente eléctrica mientras permanece accionado, es decir, su función no queda anclada como por ejemplo en los interruptores de la luz de casa, en donde el accionamiento permanece hasta que no se vuelve a accionar. En un pulsador, por contra, su activación dura mientras lo mantenemos pulsado y vuelve a su estado de reposo en cuanto dejemos de pulsarlo. Mediante la configuración adecuada podemos convertir un pulsador en un elemento de entrada a algún pin de nuestra placa UNO. Las configuraciones más básicas posibles con pulsadores las podemos ver en la imagen siguiente. [](https://libros.catedu.es/uploads/images/gallery/2023-01/circuitos-pulsador.png) Configuración circuito elemental con pulsador *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA**Esto lo hemos dado en **Sensores**, son dos configuraciones: la primera PULL DOWN o lógica normal y la segunda PULL UP o lógica inversa. Los pulsadores Tdr Steam son PULL DOWN o lógica normal.*
En el caso de la TdR STEAM los pulsadores se han configurado para que en reposo pongan a cero su entrada digital correspondiente y que se ponga a uno cuando son accionados. ##### **Concepto de variable y de contador** El concepto de variable en programación consiste simplemente en asignarle un nombre significativo a un espacio de memoria donde almacenar determinada informa ción durante la ejecución normal del programa. El concepto es muy amplio y complejo y en nuestro caso no vamos a entrar en detalles sobre el mismo, pero si indicar que no se debe confundir con el concepto de variable matemática, ya que una expresión como x = x + 1 que es una aberración en matemáticas tiene todo el sentido en programación. Lógicamente en matemáticas no se puede cumplir pero en programación significa que a la variable x se le sume uno y el resultado se vuelva a guardar en la misma variable. En ArduinoBlocks podemos crear tres tipos de variables, numéricas, de texto o booleanas. En la animación siguiente podemos ver como se pueden crear, eliminar y renombrar variables. [](https://libros.catedu.es/uploads/images/gallery/2023-01/variables.gif) Crear, renombrar y eliminar variables *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* En programación, llamamos contador a una variable cuyo valor se incrementa o decrementa en un valor fijo para cada iteración del bucle para el que se ha definido. El uso habitual de un contador es simplemente contar el número de veces que itera un bucle en general o de forma mas extensa contar, solamente, aquellas iteraciones en las que se cumpla una determinada condición. Por ejemplo, supongamos que tenemos una variable de nombre Estado de valor inicial cero y que se incremente cada vez que accionamos un pulsador, de esta forma si en un bucle vamos incrementando la variable de uno en uno, tenemos: - Estado = 0 // valor inicial - Estado = 1 // Estado = Estado + 1 - Estado = 2 // Estado = Estado + 1 - ... ##### **Condicionales** Las sentencias condicionales son aquellas que nos permiten tomar decisiones en función de si ocurre o no ocurre determinada cosa. En el caso de ArduinoBlocks estas las podemos encontrar en el bloque lógica. Este bloque contiene los elementos que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/bloque-logica.png) Bloques de lógica *Imagen Federico Coca Notas sobre ESP32 STEAMakers CC-BY-SA* El funcionamiento es el siguiente: se evalúa la condición que ponemos en "si" y si el resultado es verdadero, o sea condición cierta, se realizan las acciones que pongamos en "hacer" y si no es cierta dichas acciones no se realizan. En el apartado condición se pueden poner infinidad de factores como pueden ser el estado de sensores, realizar comparaciones, hacer operaciones matemáticas, etc. Lógicamente el resultado de evaluar la condición debe ser verdadero o falso lo que se resuelve en el caso de la programación en Arduino diciendo que si el resultado es 0, el resultado de la evaluación es falso y si es 1 o cualquier otro valor es verdadero. Si hemos sido observadores hemos visto en los bloques "si" de "Lógica" un signo mas (+) en la parte superior izquierda tanto del condicional "if" como la del "if ... else" tal y como se destaca en la imagen siguiente. [](https://libros.catedu.es/uploads/images/gallery/2023-01/agregar-sinosi.png) *Añadir opciones else if Imagen Federico Coca Notas sobre ESP32 STEAMakers CC-BY-SA* Cada vez que pulsemos sobre el signo mas se añadirá una cláusula "else if" a la principal y podemos añadir tantas como necesitemos. Esta cláusula nos va a permitir establecer una nueva condición.En la imagen siguiente vemos añadidas dos para el caso de "if ... else". En la imagen observamos el código equivalente y las distintas condiciones que se pueden establecer. [](https://libros.catedu.es/uploads/images/gallery/2023-01/ifelseifelse.png) Clausula if...else con dos else if *Imagen Federico Coca Notas sobre ESP32 STEAMakers CC-BY-SA* El signo menos (-) que aparece en la imagen sirve para eliminar la correspondiente cláusula "else if". ##### **En la TdR STEAM** La placa TdR STEAM dispone de dos pulsadores denominados SW1 y SW2 y conectados a los pines digitales D2 y D7 respectivamente. [](https://libros.catedu.es/uploads/images/gallery/2023-01/pulsadores-tdr.png) *Imagen Federico Coca Notas sobre ESP32 STEAMakers CC-BY-SA* ##### **Programando la actividad** La aplicación de un pulsador para hacer algo requiere saber si este esta pulsado o no lo está y para ello vamos a necesitar de las sentencias condicionales que hemos visto anteriormente. Vamos a hacer un programa en el que preguntemos si el pulsador SW1 (D2) está o no pulsado y si lo está que se encienda el LED rojo (D12) y si no lo pulsamos que permanezca apagado. La solución al reto la tenemos disponible en [Actividad-06](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-06.abp). A modo de comentario se ha colocado otra forma de realizar la misma programación que podemos probar simplemente arrastrando el bloque que hay en bucle fuera del mismo y colocando el otro en su lugar. [](https://libros.catedu.es/uploads/images/gallery/2023-01/actividad-06.png) *Imagen Federico Coca Notas sobre ESP32 STEAMakers CC-BY-SA* ##### **Ampliación sobre programación de la actividad** Ya se ha explicado el funcionamiento del signo mas (+) de la parte superior izquierda tanto del condicional "if" como la del "if ... else". Cada vez que pulsemos sobre el signo mas se añadirá una cláusula "else if" a la principal y podemos añadir tantas como necesitemos. Esta cláusula nos va a permitir establecer una nueva condición. El signo menos (-) que aparece en la imagen sirve para eliminar la correspondiente cláusula "else if". Vamos a hace un programa similar a la Actividad-06 para hacer que si pulsamos SW2 se encienda el LED azul y si no está pulsado permanecerá apagado. La solución la tenemos disponible en [Actividad-06-ampliación-1.](https://fgcoca.github.io/ESP32-STEAMakers/programas/Actividad-06-ampliacion-1.abp) [](https://libros.catedu.es/uploads/images/gallery/2023-01/ampliacion-1.png) *Actividad-06-ampliacion-1 Imagen Federico Coca Notas sobre ESP32 STEAMakers CC-BY-SA* El siguiente programa hará que se encienda el LED azul al pulsar SW1 y el LED rojo al pulsar SW2 se encienda el rojo permaneciendo apagados si no están pulsados. Observese la primera condición AND (Y) que impide que si pulsamos ambos pulsadores al mismo tiempo se enciendan los LEDs. La solución la tenemos disponible en [Actividad-06-ampliación-2](https://fgcoca.github.io/ESP32-STEAMakers/programas/Actividad-06-ampliacion-2.abp).Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
#### **Enunciado** Introducir el uso de las entradas analógicas para visualizar los cambios que hagamos con el potenciómetro en el terminal serie o consola serie. Cuando hablamos de lecturas analógicas suele ser muy útil el uso del mapeo, concepto que también vamos a introducir y que veremos en la segunda parte del reto. ##### **Teoría** Antes de nada ya hemos indicado que el potenciómetro va conectado a un pin analógico y es en este momento cuando vamos a establecer la diferencia entre los conceptos de analógico y de digital. Una clasificación de los circuitos electrónicos es dividirlos en dos grandes categorías: digitales y analógicos. - La electrónica digital utiliza magnitudes con dos valores discretos conocidos como 0 - 1, alto - bajo, on - off, etc, y que se corresponden con la presencia o no de tensión en un determinado punto. - La electrónica analógica emplea magnitudes con valores continuos. En concreto en las placas En la ESP32 Plus STEAMakers, las entradas analógicas pueden tener 2^12 valores (12 bits de resolución = 4.096 valores), es decir, valores comprendidos entre 0 y 4.095. Estos valores se pueden expresar de forma numérica o de forma porcentual, correspondiendo el 0 a un 0% y el 4.095 al 100%. ##### **El potenciómetro** En la imagen siguiente vemos el aspecto de un modelo concreto de potenciómetro así como los símbolos habituales del mismo. La numeración indica lo siguiente: Terminales 1 y 3 son los contactos unidos a los extremos de la resistencia fija o resistencia total del potenciómetro. Terminal 2 es el contacto que va unido al cursor o parte móvil que se desliza sobre la resistencia fija haciendo que la resistencia entre un terminal y el cursor varíe en función de la posición de este. [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* La posición del cursor se determina de forma mecánica y son adecuados para usarlos como elementos de control de tensión (conexión en serie) o de corriente (conexión en paralelo). Los potenciómetros del tipo que estamos viendo (existen de otros muchos tipos) tienen un funcionamiento en forma de rotación con un ángulo de unos 270 grados entre los puntos mas extremos. ##### **El terminal o consola serie** Sirve para visualizar en un ordenador los datos recibidos a través del puerto serie y en realidad es una aplicación que controla las comunicaciones bidireccionales a través de la UART integrada en el microcontrolador. Es muy importante tener siempre presente que el puerto serie es el que se utiliza para "subir" el firmware o programa a la placa, tarea que se realiza a través de una aplicación pregrabada en el microcontrolador y que se denomina "bootloader". En ArduinoBlocks es posible usar la consola serie solamente si tenemos instalada y en funcionamiento la aplicación ArduinoBlocks-Connector que es la encargada de establecer las comunicaciones locales de nuestra placa con las remotas de la aplicación. En la imagen siguiente vemos el aspecto de la consola. [](https://libros.catedu.es/uploads/images/gallery/2023-01/consola.png) *Aspecto de la Consola en AB* [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* A la hora de establecer una conexión serie los dos extremos que intervienen en la conexión (placa ESP32 STEAMakers y ordenador) deben establecer el mismo valor en la velocidad de la conexión. Por defecto esta velocidad es de 115200 baudios o bits por segundo en el bloque inicializar y otras velocidades comunmente utilizadas son: 4800, 9600, 19200, 38400, 57600. Es por lo tanto imprescindible incluir en el bloque "Inicializar" el bloque "Iniciar" y establecer la velocidad de comunicación. ##### **Serial Plotter - Datalogger** Es otra funcionalidad relacionada con la comunicación serie que nos permite visualizar información en forma de gráfica en tiempo real. Además el “Serial Plotter” implementa un sencillo datalogger con el que podemos ir grabando los datos para exportarlos posteriormente. En ArduinoBlocks existen bloques que nos permiten trabajar con el serial plotter. El serial plotter + datalogger se activa haciendo clic en la flecha a la derecha de Consola y tiene el aspecto que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/plotter.png) *Serial Plotter + Datalogger* [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Mapeo** Hemos indicado que las entradas analógicas trabajan con 12 bits, o sea valores comprendidos entre 0 y 4095 (2^12) y también que las salidas digitales trabajan con 8 bits, o sea valores entre 0 y 255 (28), por lo que si queremos combinar en nuestro programa entradas analógicas con salidas digitales debemos realizar un ajuste de escala en los datos. A este ajuste se le conoce como "mapear" y es un bloque disponible en el menú Matemáticas con el aspecto de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/mapear.png) [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2023-01/por-tdr.png) [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la actividad** **Parte 1.** Vamos a guardar los datos leídos del potenciómetro en una variable y mostrarlos a través de la consola serie. La solución la tenemos disponible en [Actividad-07: Parte 1](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-07-P1.abp) que es el programa que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a07-parte-1.png) [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Si cargamos el programa en nuestra placa y posteriormente activamos la consola y conectamos ArduinoBlocks con nuestro ordenador podemos ver un resultado similar al de la imagen siguiente que se corresponde con variaciones de extremo a extremo del potenciómetro. [](https://libros.catedu.es/uploads/images/gallery/2023-01/consola-parte-1.png) *Aspecto de la consola* [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Para entender el significado del check "salto de linea" del bloque "Enviar" podemos desactivarlo y volver a hacer el mismo proceso.**¡MUY IMPORTANTE!** cuando terminemos de manipular el potenciómetro que el mismo esté totalmente girado a la posición izquierda (hacia el reset), ya que comparte la conexión A0 (GPIO02) con el sistema de grabación del programa. Si no está en esa posición se producirá un error en el envío del siguiente programa.
**Parte 2.** Vamos a modificar el programa de la parte 1 del reto para mapear los datos antes de enviarlos a la consola serie. La solución la tenemos disponible en [Actividad-07: Parte 2](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-07-P2.abp) que es el programa que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a07-parte-2.png) Parte 2 de la actividad 7 [*Imagen Federico Coca* ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)*[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* El resultado ahora lo vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/consola-parte-2.png) *Aspecto de la consola [Imagen Federico Coca ](https://libros.catedu.es/uploads/images/gallery/2023-01/aspecto-simbolo.png)[Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **ENVIO DE DATOS SERIE PERO EN VEZ DE CONSOLA POR PLOTTER** *(Autor Javier Quintana)* Ahora vamos a cambiar el "**Enviar**" serie por "**Plotter**" [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-22-13-07-56-formaciones-enero-smart-home-y-esp32-pdf-xchange-viewer.png) Y además vamos a mapear el valor del potenciómetro de 0-4095 a 0-255 y lo almacenaremos en una variable "**brillo**" que nos servirá para que el RGB se ilumine más o menos: [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-22-13-11-00-formaciones-enero-smart-home-y-esp32-pdf-xchange-viewer.png)**Es importante** poner un retardo (en este caso 1000 mseg) si no lo ponemos, saturamos el puerto serie
Abrimos el plotter y jugamos: [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-22-13-12-47-formaciones-enero-smart-home-y-esp32-pdf-xchange-viewer.png){{@8395#bkmrk-%C2%A1muy-importante%21-cua}}
##### **Retos de ampliación** - **A7.R1.** Utilización del bloque "crear texto con ..." del menú "Texto". Utilizaremos cualquiera de los programas vistos en la actividad y configuraremos el nuevo bloque para que en cada línea nos muestre el mensaje "El valor del potenciometro es: ", a continuación nos muestre el valor y tras el mismo el símbolo % porque configuraremos la lectura en porcentaje. Dejaremos transcurrir un tiempo de 3s entre cada muestra de salida por consola. - **A7.R2.** Control del LED RGB con el potenciometro. Vamos a dividir el rango total en 8 partes y asignarle a cada una de ellas uno de los colores RGB según vemos en la tabla siguiente:| Color | Rango | R | G | B |
|---|---|---|---|---|
| Rojo | 0 a 512 | 255 | 0 | 0 |
| Verde | 513 a 1023 | 0 | 255 | 0 |
| Azul | 1024 a 1536 | 0 | 0 | 255 |
| Amarillo | 1537 a 2048 | 255 | 255 | 0 |
| Cian | 2049 a 2560 | 0 | 255 | 255 |
| Magenta | 2561 a 3072 | 255 | 0 | 255 |
| Blanco | 3073 a 3584 | 255 | 255 | 255 |
| Naranja | 3584 a 4096 | 255 | 127 | 0 |
Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** Utilizaremos la consola serie para mostrar los valores de luz detectados por la resistencia LDR o fotocélula. ##### **Teoría** Una fotorresistencia o fotorresistor es un componente electrónico cuya resistencia disminuye de forma exponencial con el aumento de la intensidad de luz incidente. Las siglas LDR vienen de su nombre en inglés, que es Light Dependent Resistor. En la imagen siguiente tenemos el símbolo, el aspecto real de una LDR y su curva característica de variación de resistencia con la iluminación. [](https://libros.catedu.es/uploads/images/gallery/2023-01/simbolo-aspecto-curva.png) Símbolo y aspecto de la LDR y curva característica *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2023-01/ldr-tdr.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la actividad** Dado que en el menú TDR STEAM de ArduinoBlocks tenemos disponible un bloque que nos devuelve el nivel de luz en porcentaje o de forma numérica, resolver la actividad es sumamente sencillo. La solución la tenemos disponible en[ ESP32-SM-Actividad-08](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-08.abp) que es el programa que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a08.png) Actividad-08 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Esto nos generará algo como lo de la imagen siguiente en la consola: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a08-consola.png) Consola que produce la actividad 8 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Opción Plotter gráfico** Es más visual y dinámico [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-20-37-49-manual-actividades-esp32-steamakers-2022-junio-pdf-xchange-viewer.png) [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-20-38-26-manual-actividades-esp32-steamakers-2022-junio-pdf-xchange-viewer.png) Extraido de la página 167 Manual Steam Maker ESP32 - [Descarga desde libros.catedu..es Manual Actividades ESP32 SteaMakers 2022\_Junio.pdf](https://libros.catedu.es/attachments/248) - [Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) ##### **Retos de ampliación** **A8.R1.** Detectar el nivel de iluminación de la sala y condiciones de iluminación en las que estemos utilizando la LDR y enviar el resultado a la consola. **A8.R2.** Programar un interruptor crepuscular utilizando la LDR y uno de los LEDs para simular el farol. El nivel de luz mínimo permitido antes de encender el farol dependerá del resultado obtenido en la reto 1, de forma que con un valor menor o igual se encienda el LED y con un valor mayor permanezca apagado. **A8.R3.** Hacer el interruptor crepuscular utilizando como farol en LED RGB que se encenderá en color blanco. # Actividad-09. El sensor de temperatura LM35DPágina extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** Utilizaremos este sensor de temperatura para medir la temperatura de la habitación en la que estemos resolviendo el reto mostrando el resultado en la consola. #### **Teoría** ##### **LM35** El LM35 es un circuito integrado de medida de temperatura de precisión con una tensión de salida lineal y proporcional a la temperatura en grados centígrados. Algunas de las características que se pueden extraer de la hoja de datos del LM35 son: - Directamente calibrado en grados Celsius (Centígrados) - Factor de escala lineal de +10-mV/°C - Resolución asegurada de 0.5°C - Rango de medida de −55°C a 150°C En la imagen siguiente vemos su representación en circuito y el aspecto físico que tiene en uno de sus encapsulados mas usual. [](https://libros.catedu.es/uploads/images/gallery/2023-01/represeta-aspecto.png) Representación esquemática y aspecto *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Bloques de tiempo** Para esta actividad vamos a explicar los bloques de tiempo que se implementan en ArduinoBlocks. Las funciones de tiempo o retardo nos permiten realizar pausas y obtener información sobre el tiempo transcurrido dentro del microcontrolador. 1.- **Bloques esperar.** Realizan una pausa del tiempo que establezcamos hasta seguir con la ejecución del siguiente bloque. Se corresponden con las instrucciones delay(1000) y delayMicroseconds(1000). Tenemos disponibles los dos de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/bloques-esperar.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* **2.- Tiempo transcurrido**. Obtiene un valor con el tiempo transcurrido desde el inicio o reset del microcontrolador de la placa ESP32 STEAMakers. Se trata de las funciones millis() y micros(). El valor puede ser en milisegundos o microsegundos, tal y como vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/b-tiempo-transcurrido.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* # Actividad-10. El sensor de temperatura y humedad DHT-11 ##### **Visualización humedad y temperatura por el display LCD** El clásico es visualizar por el LCD la temperatura y la humedad instantánea. - Más adelante veremos el LCD y por qué hay que inicializarlo con la dirección 0x27 - Fíjate que hay que formatear el valor que devuelve la función DHT-11 como decimal, la explicación [lo vimos aquí en sensores DHT11](https://libros.catedu.es/link/8291#bkmrk-sensor-dht11-%28temper) [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-18-38-46-connector-v6-0.png)**Haz un pequeño experimento:** Sustituye la instrucción de temperatura DHT11 por el LM35 ¿Sale el mismo valor?¿Cual crees que es el verdadero? [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-18-39-18-connector-v6-0.png)
**Convierte el ESP32 EN ESTACIÓN METEROLÓGICA** En la página 158 del Manual actividades ESP32 tienes un ejemplo de grabar la temperatura y la humedad en un fichero texto en una tarjeta microsim (la placa ESP32 incorpora un lector)
- [Descarga desde libros.catedu..es Manual Actividades ESP32 SteaMakers 2022\_Junio.pdf](https://libros.catedu.es/attachments/248) - [Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view)Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** Realizar un programa básico de medida de temperatura y humedad relativa de la habitación en la que estamos trabajando con nuestra TdR STEAM. #### **Teoría** ##### **DHTxx** El DHT11 es un modelo de sensor que permiten realizar la medición simultánea de temperatura y humedad. Dispone de un procesador interno que es el encargado de realizar la medición entregando la información mediante una señal digital. Se presenta en un encapsulado plástico típico de color azul. Sus principales características son: - Rango de temperatura: 0 a 50ºC - Precisión de la medida de temperatura: ±2ºC - Rango de humedad: 20 a 80% - Precisión en la medida de humedad: ±5%. - Frecuencia de muestreo: 1 muestra por segundo (1 Hz) El DHT11 es un sensor bastante limitado que podemos usar con fines de formación, pruebas, o en proyectos que realmente no requieran una medición precisa. Si necesitamos mayor precisión y rango podemos recurrir al DHT22 que es de la misma familia y lo único que cambia es sus características y el precio. Sus características son: - Rango de temperatura: -40 a 125ºC - Precisión de la medida de temperatura: ±0.5ºC - Rango de humedad: 0 a 100% - Precisión en la medida de humedad: ±2 a 5% - Frecuencia de muestreo: 2 muestras por segundo (2 Hz) En la imagen siguiente vemos el aspecto de ambos sensores: [](https://libros.catedu.es/uploads/images/gallery/2023-01/dhtxx.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Estado de confort** En la web[ ARQUITECTURA & ENERGÍA ](http://www.arquitecturayenergia.cl/home/el-confort-termico/)podemos encontrar un artículo donde se nos explica con bastante profundad el tema del confort térmico. Puede definirse confort térmico, o más propiamente comodidad higrotérmica, como la ausencia de malestar térmico. En fisiología, se dice que hay confort higrotérmico cuando no tienen que intervenir los mecanismos termorreguladores del cuerpo para una actividad sedentaria y con una indumentaria ligera. Esta situación puede registrarse mediante índices que no deben ser sobrepasados para que no se pongan en funcionamiento los sistemas termorreguladores (metabolismo, sudoración y otros). En la imagen siguiente vemos los valores de temperatura y humedad que delimitan las zonas de confortabilidad. [](https://libros.catedu.es/uploads/images/gallery/2023-01/zonas-confort.png) *Confort térmico en función de temperatura y humedad Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Sobre el gráfico vamos a delimitar zonas de temperatura y humedad para establecer su color. Por motivos de simplicidad lo vamos a hacer delimitando zonas rectangulares, pero comprobamos que no cometemos grandes errores y para nuestro propósito nos sirve. **1.- Zona Roja**: en la imagen siguiente tenemos delimitadas las zonas: - Humedad Relativa: superior al 85% e inferior al 20% - Temperatura: superior a 27ºC e inferior a 16ºC [](https://libros.catedu.es/uploads/images/gallery/2023-01/confort-rojo.png) Delimitación color rojo zona de confort *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* **2.- Zona Amarilla:** en la imagen siguiente tenemos delimitadas las zonas: - Humedad Relativa: entre el 20% y el 40% y entre el 65% y el 85% - Temperatura: entre 16ºC y 18ºC y entre 24ºC y 27ºC [](https://libros.catedu.es/uploads/images/gallery/2023-01/confort-amarillo.png) Delimitación color amarillo zona de confort *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* **3.- Zona Verde, rojo y amarillo:** en la imagen siguiente tenemos delimitadas todas las zonas, correspondiendo a la verde los siguientes datos: - Humedad Relativa: entre el 40% y el 65% - Temperatura: entre 18ºC y 24ºC [](https://libros.catedu.es/uploads/images/gallery/2023-01/confort-todos.png) Delimitación colores zona de confort *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Con este[ enlace al archivo colores-A10.svg ](https://fgcoca.github.io/ESP32-STEAMakers/img/img/Reto-09/colores-R9.A1.svg)puedes descargarte el archivo vectorial, editarlo con [Inkscape ](https://inkscape.org/)y ver como se han realizado estos gráficos. ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2023-01/dht11-en-tdr.png)*Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la actividad** De nuevo realizaremos la programación como en las actividades anteriores, utilizando el monitor serie para mostrar los datos. El programa[ ESP32-SM-Actividad-10 l](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-10.abp)o vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a10.png) *Actividad-10 Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Esto nos generará algo como lo de la imagen siguiente en la consola: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a10-consola.png) Consola que produce la actividad 10 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Retos de ampliación** **A10.R1.** Realizar un programa que nos muestre el estado de confort según las explicaciones vista y la idea de un semáforo que utilice el LED RGB para componer esos colores rojo, verde y amarillo. Para resolver la actividad vamos a necesitar varios bloques del menú "Lógica" y especialmente combinando funciones AND y OR múltiples. Si necesitamos, por ejemplo, aumentar el número de operadores AND dentro de un bloque simplemente tenemos que combinarlo como vemos en la imagen siguiente, donde se han combinado cuatro bloques AND. [](https://libros.catedu.es/uploads/images/gallery/2023-01/cuantro-and.png)Combinación de 4 bloques AND *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* El Programa es el de la imagen siguiente y está disponible en [ESP32-SM-Reto-1-A10](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-10-Reto-1.abp). [](https://libros.catedu.es/uploads/images/gallery/2023-01/a10-r1.png) Reto 1 de la actividad 10 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* **A10.R2**. Idear un método para probar de forma completa la funcionalidad del programa anterior, aunque se requiera modificarlo. También se pide explicar la misión de la función "limite-confort" creada en el reto 1 de la actividad 10. # Actividad-11. Emisor y receptor de infrarrojosPágina extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** Enviaremos códigos desde el control remoto por infrarrojos que serán recibidos por el LED de infrarrojos para actuar según el código recibido. #### **Teoría** ##### **¿Qué son los infrarrojos?** Son una clase de radiación electromagnética con una longitud de onda que resulta superior a la longitud de onda de la luz visible, siendo su frecuencia superior a las microondas. Dentro del espectro electromagnético, la radiación infrarroja se encuentra comprendida entre el espectro de luz visible y las microondas. Tiene longitudes de onda mayores o más largas que el rojo. En la imagen siguiente, obtenida del blog de Mercedes González Mas vemos caracterizados los infrarrojos dentro del espectro. [](https://libros.catedu.es/uploads/images/gallery/2023-01/ir-blog.png)**TRUCO** En las prácticas con Infrarrojos, cuando las cosas no van, es muy útil saber si el problema es que el emisor de infrarrojos funciona o no funciona para descartar otros problemas. El truco es simple, y sirve **para cualquier mando:** Como las cámaras de los móviles **si** detectan el Infrarrojo no visible, utiliza la cámara de tu móvil hacia el led del emisor del infrarrojos y aprieta cualquier botón, si se enciende el led (visto desde la cámara de tu móvil) el emisor **funciona**.
##### **Bloques en ArduinoBlocks** El sensor receptor de infrarrojos permite obtener la cadena de texto con el código en formato hexadecimal correspondiente al tren de pulsos de IR generado al pulsar una determinada tecla. El bloque es el que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-10-09-44-22-window.jpg) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* El valor devuelto por el bloque de recepción será una cadena de texto con valor vacío en caso de no detectar ningún código. Al devolver el bloque una cadena de texto debemos recordar que lo tenemos que almacenar en una variable de tipo texto. Si utilizamos mandos genéricos RC5 como el modelo de Keyestudio, podemos usar el bloque de la imagen siguiente para comparar los códigos recibidos y así identificar fácilmente cada tecla. [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-10-09-44-57-window.jpg) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2023-01/ir-tdr.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la actividad** Vamos a realizar un programa en el que si pulsamos la tecla Ok del control remoto se nos encienda el diodo LED rojo. La solución la tenemos disponible en [ESP32-SM-Actividad-11 ](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-Actividad-11.abp)que es el programa que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/a11.png) *Solución Actividad 11 Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Sabemos que el diodo IR está recibiendo un código porque junto al mismo hay un diodo LED rojo que parpadea. ##### **Retos de ampliación** - **A11.R1.** Realizar un programa que encienda el LED RGB en los colores establecidos a continuación y según la tecla flecha pulsada. - Flecha arriba = Rojo - Flecha izquierda = Verde - Flecha derecha = Amarillo - Flecha abajo = azul - **A11.R2.** Realizar un programa que nos muestre por consola el código hexadecimal correspondiente a cada una de las teclas pulsadas junto a un texto descriptivo indicador de la tecla pulsada en cada caso, es decir, que mantenga una estructura del tipo: El CODIGO se corresponde con la tecla TECLA pulsada. # Prácticas con otros elementos del kit # Actividad 12 Puerto de expansión I2C. La LCD de 2x16Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Enunciado** Utilizaremos las comunicaciones I2C para mostrar textos en la pantalla LCD I2C incluida en el kit. #### **Teoría** ##### **Las comunicaciones I2C** Dado que la placa TdR STEAM dispone de un puerto de expansión I2C (del inglés Inter-Integrated Circuit = Circuito inter-integrado) vamos a explicar un poco en que consiste este sistema de conexionado. Bus conocido por las siglas I2C, IIC o I²C, es un bus serie de datos desarrollado en 1982 por Philips Semiconductors (hoy NXP Semiconductors, parte de Qualcomm). Se utiliza principalmente internamente para la comunicación entre diferentes partes de un circuito, por ejemplo, entre un controlador y circuitos periféricos integrados. Posteriormente fue adoptado progresivamente por otros fabricantes hasta convertirse en un estándar del mercado con miles de circuitos integrados de diferentes fabricantes. I2C también se denomina TWI (Two Wired Interface) únicamente por motivos de licencia, denominación introducida por Atmel. No obstante, la patente caducó en 2006, por lo que actualmente no hay restricción sobre el uso del término I2C. El bus I2C requiere únicamente dos cables o lineas de señal para su funcionamiento, uno para la señal de reloj (SCL, Serial Clock) y otro para el envío de datos (SDA, Serial Data). Ambas líneas precisan resistencias de pull-up hacia Vcc. Cualquier dispositivo conectado a estas líneas es de drenador o colector abierto (Open Collector), lo cual en combinación con las resistencias pull-up, crea un circuito Wired-AND. En la imagen siguiente vemos el diagrama básico de conexionado del bus con algunos ejemplos de dispositivos. La señal de reloj siempre es generada por el circuito que actúa como Master. [](https://libros.catedu.es/uploads/images/gallery/2023-01/diagrama-iic.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Para ser reconocido en el bus, cada dispositivo dispone de una dirección física, que se emplea para acceder a cada uno de ellos de forma individual. Esta dirección puede ser fijada por hardware, en cuyo caso se pueden modificar los últimos 3 bits mediante “jumpers” o microinterruptores (ejemplo de la matriz de 8x8), o por software. En general, cada dispositivo conectado al bus debe tener una dirección única. Si tenemos varios dispositivos similares tendremos que cambiar la dirección o, en caso de no ser posible, implementar un bus secundario. El bus I2C tiene una arquitectura de tipo master-slave, lo que indica que el master es el encargado de controlar al resto de dispositivos tipo slave con los que se comunica y que se comunican con el, teniendo siempre el marte prioridad absoluta. El dispositivo master es el que inicia la comunicación con los slaves. Los slaves no pueden iniciar la comunicación (el master tiene que preguntarles), ni hablar entre si directamente. El bus I2C debe ser por lo tanto síncrono, es decir debe existir una señal de reloj que controle las comunicaciones. Es el master el que proporciona la señal de reloj, que mantiene sincronizados a todos los dispositivos del bus. De esta forma, se elimina la necesidad de que cada dispositivo tenga su propio reloj, de tener que acordar una velocidad de transmisión y mecanismos para mantener la transmisión sincronizada como en UART o SPI. En la imagen vemos un cronograma ejemplo del funcionamiento del sistema. [](https://libros.catedu.es/uploads/images/gallery/2023-01/crono-iic.png) Cronograma trabajo bus I2C *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* El protocolo de comunicación I2C sigue la siguiente secuencia: - Primero, el master genera la señal de reloj del bus (SCL). - Se inicia la comunicación por orden del master al establecer la condición de START, que se produce cuando SDA pasa de uno a cero y se mantiene en cero durante un tiempo. - El master direcciona a los slaves. - El master indica si se va a leer o escribir. - El slave direccionado responde con una señal de conformidad ACK (acknowledge). - Se transmite los datos byte a byte desde SDA al receptor. Por cada pulso desde SCL se transmite un bit de información. - El destinatario de la información responde con una señal de conformidad ACK. - Se acaba la comunicación cuando el master establece la condición de STOP, que se produce cuando SDA, por orden del master pasa de cero a uno y se mantiene en uno durante un tiempo. Son muchos los dispositivos I2C que se pueden direccionar por este bus I2C, siendo lo más común en los dispositivos para I2C que utilicen direcciones de 7 bits, aunque existen dispositivos de 10 bits, pero es un caso raro. Una dirección de 7 bits implica que se pueden poner hasta 128 (27) dispositivos sobre un bus I2C. Hemos visto que las direcciones son de 8 bits y esto es porque el bit extra de los 7 de la dirección lo emplea el master para informar al slave si va a leer o escribir. Si el bit de lectura/escritura es cero, el dispositivo master está escribiendo en el slave. Si el bit es 1 el master está leyendo desde el slave. La dirección de 7 bit se coloca en los 7 bits más significativos del byte y el bit de lectura/escritura es el bit menos significativo. ##### **La LCD 1602** Una pantalla LCD (del ingés, Liquid Cristal Display) de 2 líneas de 16 caracteres tiene el aspecto y la distribución de pines que vemos en la imagen siguiente. [](https://libros.catedu.es/uploads/images/gallery/2023-01/16x2.png) LCD 2x16 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Es evidente que deberíamos utilizar bastantes patillas de nuestra placa tipo UNO (es el formato que tiene la ESP32 STEAMakers) para su control. En la imagen siguiente se muestra el conexionado mínimo necesario en una pantalla de este tipo: 4 bits para datos y dos señales de control En (Enable) y Rs (Register select). La conexión RW la ponemos a GND. Además se debe añadir una resistencia ajustable o un potenciómetro para regular el contraste de la pantalla. [](https://libros.catedu.es/uploads/images/gallery/2023-01/conex-lcd.png) Conexionado mínimo LCD 2x16 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Es preferible utilizar alguna de las que tienen el aspecto que vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/16x2-i2c.png) LCD 2x16 con módulo I2C *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* En realidad el conjunto que vemos en la imagen anterior no es mas que una LCD 2x16 a la que se ha incorporado un módulo adaptador de LCD a I2C. Este modulo está especialmente diseñado para poder soldarlo directamente a la LCD y convertirla así en un dispositivo I2C que además ya lleva incorporado el potenciómetro de ajuste de contraste en alguno de los casos. Este tipo de pantalla requiere cuatro cables para establecer las conexiones, dos cables SDA (datos) y SCL (reloj) para el bus de comunicaciones I2C y los dos cables de alimentación VCC y GND. La dirección I2C por defecto de este tipo de módulos puede ser 0x3F o en otros casos 0x27, e incluso hay modelos en los que se puede cambiar. Para un correcto control es muy importante identificar correctamente la dirección I2C de nuestro modulo pues de otra forma nuestro programa no funcionará correctamente. Una LCD 1602 I2C es muy sencilla de controlar a partir de los bloques que nos proporciona ArduinoBlocks. En la imagen siguiente ponemos como ejemplo los bloques para imprimir un texto o variable en un par fila-columna determinado. [](https://libros.catedu.es/uploads/images/gallery/2023-01/bloques-impresion-x-y.png) Bloques para imprimir en un par fila-columna *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* En la siguiente figura se muestra el sistema de distribución de filas y columnas. [](https://libros.catedu.es/uploads/images/gallery/2023-01/sistema-x-y.png) Sistema de coordenadas en una LCD 1602 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Escanear dispositivos I2C** Si no conocemos la dirección especifica de nuestro módulo podemos utilizar un pequeño programa que llamaremos [Escaner-I2C](https://fgcoca.github.io/ESP32-STEAMakers/programas/Escaner-I2C.abp) y que se encargará de identificar la dirección I2C y todos los dispositivos I2C conectados a nuestra placa. Debemos crear un proyecto, en esta ocasión, de tipo "Arduino UNO" para tener disponible el menú I2C que nos de acceso al bloque "Escanear dispositivos I2C..." tal y como vemos en la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/menu-i2c.png) Menu I2C *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Un sencillo programa como el de la imagen siguiente nos permite ver los dispositivos I2C conectados y su dirección física asociada. El programa está disponible como [Escaner-I2C.](https://fgcoca.github.io/ESP32-STEAMakers/programas/Escaner-I2C.abp) [](https://libros.catedu.es/uploads/images/gallery/2023-01/escaner-i2c.png) Programa Escaner-I2C *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Si conectamos la consola el resultado de tener la placa TdR STEAM con una LCD I2C conectada debe ser similar al de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/consola-escaner-i2c.png) Consola para el programa Escaner-I2C *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA***IMPORTANTE** En el caso de la placa ESP32 STEAMakers no ocurre como en las tipo Arduino, que cuando conectamos la consola se efectúa un reset automático de la placa por lo que es muy posible que el programa de escaneo nos muestre una consola sin resultado alguno o en blanco. Simplemente, con la consola ya conectada, **hacemos un reset físico en la placa** y el problema quedará solucionado.
En la figura siguiente tenemos el resultado que se muestra con el programa anterior cargado, conectar la consola y hacer reset. En este caso vemos los cinco dispositivos conectados a través de un hub y la placa TdR STEAM. [](https://libros.catedu.es/uploads/images/gallery/2023-01/consola-escaner-i2c-5.png) Consola para el programa Escaner-I2C con 5 dispositivos *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Otra opción para hacer un escáner I2C que no necesita el reset es el programa que vemos en la figura siguiente y que lleva al bucle la orden de escaneo que se va a ejecutar cada 10 segundos, aunque este tiempo puede ser otro cualquiera. [](https://libros.catedu.es/uploads/images/gallery/2023-01/escaner-i2c-bucle.png) Programa Escaner-I2C en el bucle con 5 dispositivos *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* En la figura siguiente vemos el resultado en la consola y como coincide con el anterior. [](https://libros.catedu.es/uploads/images/gallery/2023-01/consola-escaner-i2c-5-bucle.png) Consola para el programa Escaner-I2C en el bucle con 5 dispositivos *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* #### **Cambiar la dirección física del dispositivo I2C** Esta tarea nos va a resultar especialmente útil si disponemos de LCDs I2C con una dirección fijada de fábrica y queremos conectar varias de ellas en nuestro proyecto. ##### **LCD SIN micro interruptores** La parte posterior de la LCD 1602 de Keyestudio tiene el aspecto de la imagen siguiente. Nos fijaremos especialmente en los tres grupos de agujeros enmarcados en rojo. Aunque en este caso no vienen nombrados los vamos a denominar A0, A1 y A2 de izquierda a derecha. [](https://libros.catedu.es/uploads/images/gallery/2023-01/posterior.png)| A2 | A1 | A0 | Dirección |
|---|---|---|---|
| 0 | 0 | 0 | 0x27 |
| 0 | 0 | 1 | 0x26 |
| 0 | 1 | 0 | 0x25 |
| 0 | 1 | 1 | 0x24 |
| 1 | 0 | 0 | 0x23 |
| 1 | 0 | 1 | 0x22 |
| 1 | 1 | 0 | 0x21 |
| 1 | 1 | 1 | 0x20 |
| TdR STEAM | LCD 1602 | Color cable |
|---|---|---|
| GND | GND | Negro |
| Vcc | Vcc | Rojo |
| SDA | SDA | Amarillo |
| SCL | SCL | Blanco |
Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
##### **Actividad 13 bis Enunciado** Realizaremos pruebas básicas de detección de nivel de sonido añadiendo esta opción externa al pin analógico A3 disponible en el conector correspondiente. #### **Teoría** Un micrófono es un transductor (dispositivo que convierte energía de una forma a otra) que convierte la energía sonora en señales eléctricas. Micrófonos hay una amplia diversidad tanto en formas como tamaños. Dependiendo de la aplicación, un micrófono puede utilizar diferentes tecnologías para convertir sonidos en señales eléctricas. Para el caso de aplicaciones con placas tipo Arduino suelen usarse sensores basados en el micrófono de condensador electret que es un condensador de placas paralelas y trabaja como una capacitancia variable. Se forma con una placa fija (placa trasera) y una movible (diafragma) con una pequeña separación entre ellas. Cuando el sonido golpea al diafragma este se mueve cambiando así la capacitancia entre las placas. El sensor microfónico de keyestudio se utiliza normalmente para detectar el nivel de ruido en el ambiente. El pin S del mismo es una salida analógica, es decir, una tensión de salida en tiempo real del micrófono. El sensor viene con un potenciómetro que permite ajustar la ganancia de la señal dentro de un determinado rango. Su aspecto es el de la imagen siguiente: [](https://libros.catedu.es/uploads/images/gallery/2023-01/sensor-micro.png) Sensor de sonido con micrófono KS0035 con potenciómetro *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **En la TdR STEAM** [](https://libros.catedu.es/uploads/images/gallery/2023-01/micro-tdr.png) El conector micrófono externo en A3 *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Programando la actividad** Como programa sencillo inicial vamos simplemente a enviar a la consola el nivel de sonido que detecte nuestro micrófono. El programa de la imagen siguiente esta disponible como [ESP32-SM-micro-inicial](https://fgcoca.github.io/ESP32-STEAMakers/programas/ESP32-SM-micro-inicial.abp). [](https://libros.catedu.es/uploads/images/gallery/2023-01/RgXactividad-inicial.png) Actividad inicial con el micro *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **Retos de ampliación** **Micro.R1.** Modificar el programa de la actividad inicial para que muestre los datos por la LCD. **Micro.R2.** Partiendo del programa del reto 2 de la actividad LCD (LCD.R2) modificarlo para que muestre los datos del micrófono tanto al final de la cuenta ascendente como de la descendente. # Actividad 14 Sensores internos de ESP32 Ya vimos en [SENSORES ESP32 ](https://libros.catedu.es/books/esp32-en-el-aula/page/sensores-en-la-placa-esp32-plus-steamakers "Sensores en la placa ESP32 plus STEAMakers")que esta placa tiene internamente unos sensores que podemos utilizar Nuestra propuesta para experimentar es con los sensores de potencia. Vamos a ver este experimento consistente en encender y apagar diferentes elementos de TDR STEAM Imagina y ver las variaciones: [experimentoenergia.abp](https://libros.catedu.es/attachments/247) [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-15-04-55.png) Se puede observar las variaciones de tensión cuando se apaga y se enciende [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-15-06-20-greenshot.png) Y también se puede ver como el consumo va a aumentando cada ver que encendemos y apagamos [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-18-15-07-39-greenshot.png)🤔¿No tendría que subir linealmente? Pues por lo visto el consumo en los cambios es mucho mayor y los sensores lo detectan y en los estados estacionarios o los sensores no lo detectan
Página extraída de Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA
#### **A1. Leer valor de tensión de alimentación** Un programa para verificar la tensión de alimentación de la placa ESP32 Plus STEAMakers lo vemos en la figura siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/vcc.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Medir la tensión de alimentación Que nos arroja un resultado en la consola como el que vemos en la figura siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/consola-vcc.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **A.2. Graficar todos los parámetros del 'Medidor de energía'** El programa [SP-medidor-energia ](https://fgcoca.github.io/ESP32-STEAMakers/programas/SP-medidor-energia.abp)de la figura siguiente realiza la captura en variables de los cuatro parámetros disponibles y los envía al Serial Plotter. Para modificar el valor de los mismos se han creado las funciones encender y apagar que encienden y apagan los diodos LEDs de la TdR STEAM y de la tira de 8 LEDs **(NO PROPORCIONADO POR CATEDU)** [](https://libros.catedu.es/uploads/images/gallery/2022-12/medidor.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Programa Serial Plotter En la figura siguiente vemos el resultado de forma gráfica. [](https://libros.catedu.es/uploads/images/gallery/2022-12/spmedidor.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* ##### **A.3. Sensores internos** Un programa como el de la figura siguiente nos va a mostrar por consola los valores leídos por los sensores internos. [](https://libros.catedu.es/uploads/images/gallery/2022-12/internos.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* Sensores internos El resultado en consola lo vemos en la figura siguiente: [](https://libros.catedu.es/uploads/images/gallery/2022-12/cinternos.png) *Imagen Federico Coca [Notas sobre ESP32 STEAMakers](https://fgcoca.github.io/ESP32-STEAMakers/) CC-BY-SA* #### **Retos** R1. Realizar la actividad A2 mostrando los datos por consola. R2. Realizar la actividad A2 mostrando los datos en la LCD. R3. Hacer una captura de datos en formato CSV de alguno de los parámetros del 'Medidor de energía'. # Avanzado: Multitarea, interrupciones, memoria Flash y tarjeta SD ##### **Multitarea** Las placas convencionales y ordenadores antiguos que sólo tienen un núcleo en el microprocesador, sólo pueden hacer una tarea. Se puede hacer por software que el microprocesador realice varias tareas simplemente dando tiempo a cada una de ellas e ir saltando de una a otra, es decir, no es una programación en paralelo, y si el micro no es potente, acaba por saturarse. ESP32 Plus Steammaker tiene un microprocesador pero tiene dos núcleos. Tiene capacidad para hacer algunas tareas en paralelo. Como estos conceptos pertenecen a un perfil más avanzado, se escapa de los propósitos de este curso. Si se quiere trabajar con ellos recomendamos el siguiente [Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) Aquí están las páginas y los retos para más información: ``` 7.17 Reto A17. Multitarea. ..................................................... 177 7.17.1 Reto A17.1. Multitarea I. .................................................... 182 7.17.2 Reto A17.2. Multitarea II. ................................................... 183 7.17.3 Reto A17.3. Multitarea III. .................................................. 184 7.17.4 Reto A17.4. Multitarea IV. .................................................. 185 7.17.5 Reto A17.5. Multitarea V. ................................................... 188 ``` ##### **Interrupciones** Una interrupción es un evento (por ejemplo pulsar un pulsador) y hace que el micro deje lo que estaba haciendo y salte a realizar una tarea concreta. En la placa TDR STEAM hay dos pulsadores, en D3 y en D5 que pueden realizar interrupciones al ESP32. Aquí están los retos y las páginas en - [Descarga desde libros.catedu..es Manual Actividades ESP32 SteaMakers 2022\_Junio.pdf](https://libros.catedu.es/attachments/248) - [Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) ``` 7.18 Reto A18. Interrupciones. ............................................... 189 7.18.1 Reto A18.1. Control de interrupciones. ................................... 190 ``` ##### **Memoria Flash** El ESP32 Plus STEMaker tiene una memoria Flash que puede mantener los datos incluso después de apagar la placa. Su capacidad es muy limitada y no se almacenan eternamente.[ ](https://libros.catedu.es/attachments/248)[Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) ``` 7.19 Reto A19. Memoria FLASH/EEPROM. ................................... 192 7.19.1 A19.1. Lectura/escritura en la memoria EEPROM I. .................... 195 7.19.2 A19.2. Lectura/escritura en la memoria EEPROM II. .................... 198 ``` ##### **Tarjeta SD** El ESP32 Plus STEAMaker tiene un zócalo para insertar tarjetas microSD. Tiene que estar formateada a FAT32 y admite hasta 2 Teras con archivos máximos de 2G. Aquí están los retos y las páginas en[ ](https://libros.catedu.es/attachments/248)[Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) ``` 7.13 Reto A13. Tarjeta SD. ..................................................... 155 7.13.1 Reto A13.1. Almacenar datos: Datalogger. ............................... 157 7.13.2 Reto A13.2. Leer datos almacenados. ..................................... 159 7.13.3 Reto A13.3. Escribir y leer datos. .......................................... 160 ``` # Bluetooth # Un poco de teoría Bluetooth {{@7221}} # APP Serial Bluetooth Terminal {{@13598}} # Actividad 15 APP->ESP32APP Serial Bluetooth Terminal ##### **Preliminar** {{@13536}} ##### **Enunciado** Si recibe un código, que encienda un led. Por ejemplo: - si recibe un 1 que se encienda el led rojo. - si recibe otro código, apaga el led rojo Este enunciado parecido[ a este programa en Arduino con Bluetooth ](https://libros.catedu.es/books/arduino-en-el-aula/page/app-tdr-steam-programa-en-arduinoblocks) ##### **Programa** El programa es sencillo: [http://www.arduinoblocks.com/web/project/1013787](http://www.arduinoblocks.com/web/project/1013787) [](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-24-08-37-02-mattermost-desktop-app.png) [](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-24-08-38-12-greenshot.png) ##### **Opción con texto** Podemos poner en vez de una variable numérica un texto, pero el Bluetooth añade un carácter al final que no siempre se lee bien por o que recomendamos usar en la condicional "empieza con" en vez de "=" [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-14-01-12-whatsapp.png) con la palabra ROJO se enciende pero también con cualquiera que empiece con R # ACTIVIDAD 15 con otra APP: Arduino Bluetooth Control {{@7223}}Recuerda que para que funcione el Bluetooth tienes que poner el interruptor alejado del borde. Ver [https://libros.catedu.es/books/esp32-en-el-aula/page/bluetooth-en-el-esp32](https://libros.catedu.es/books/esp32-en-el-aula/page/ojo-hacer-esto-en-imagina-tdr-steam)
##### **El resultado** ##### **Reto** ¿Te atreves a hacerlo con voz? Por ejemplo si dices AZUL que encienda el led AZUL si dices ROJO que encienda el ROJO y si dices APAGAR que los apague # Actividad 16 APP<->ESP32 Enunciado y programa STEAMAKERBLOCKS ##### **Enunciado** Ahora vamos a realizar la comunicación bidireccional. El propósito es que si recibe un código, que encienda y apague los leds, pero además vamos añadir comunicación hacia la APP del móvil, que nos envíe información de los sensores. Un ejemplo de enunciado sería: - APP->ES`32 - si recibe un R que se encienda el led rojo y apague el led azul. - si recibe un A que se encienda el led azul y apague el led rojo. - APP<-ESP32: - Que envíe a la APP el valor de la temperatura del DHT11. - Que envíe a la APP el valor de la humedad del DHT11. - Que envíe a la APP el valor de la luz del LDR. Además lo vamos a complicar un poco más: que visualice los valores de temperatura y luz en el display LCD para que se vea que corresponden a los que muestra en la APP (no se muestra el de la humedad pues no cabe en el LCD). Este enunciado parecido al programa en Arduino [https://libros.catedu.es/books/arduinoblocks-en-el-aula/page/app-tdr-steam-arduinoblocks](https://libros.catedu.es/books/arduino-en-el-aula/page/app-tdr-steam-arduinoblocks) ##### **Programa** El programa ya es más complejo: [http://www.arduinoblocks.com/web/project/1050441](http://www.arduinoblocks.com/web/project/1050441) [](https://libros.catedu.es/uploads/images/gallery/2023-01/arduinoblocks-1674036272627.png) # Actividad 16 con la APP Serial Bluetooth Terminal # Actividad 16 con APP INVENTOR ##### **La APP en el móvil** {{@7230}} {{@7231}} ##### **La APP a tu móvil** {{@11546}} ##### **El resultado** # Que es IoTEl **Internet de las cosas** (Internet of Thing IoT) describe objetos físicos —o grupos de estos— con sensores, capacidad de procesamiento, software y otras tecnologías que se conectan e intercambian datos con otros dispositivos y sistemas a través de internet u otras redes de comunicación. El Internet de las cosas se ha considerado un término erróneo porque los dispositivos no necesitan estar conectados a la Internet pública. Sólo necesitan estar conectadas a una red y ser direccionables individualmente
[Fuente Wikipedia IoT Internet de las cosas CC-BY-SA](https://es.wikipedia.org/wiki/Internet_de_las_cosas)  [De Drawed by Wilgengebroed on FlickrTranslated by Prades97 CC BY-SA 3.0](https://commons.wikimedia.org/w/index.php?curid=32745149) Estamos hablando de dispositivos que se conectan a internet de forma desatendida, por vía hardware (o mejor dicho firmware) a diferencia de un ordenador, tablet o móvil, donde tienes que configurar por software el dispositivo y hay un diálogo entre usuario y dispositivo sobre el uso de Internet (el software solicita tal página web, tales datos etc por voluntad del usuario o por diálogo con el usuario) Aquí los dispositivos están ya configurados de los datos que se comunican. Es decir "conectar y olvidar". Piensa en la diferencia entre un enchufe inteligente y un ordenador, el primero es lo que se considera dentro de IoT**Desventajas**: El acceso a Internet de dispositivos caseros puede generar problemas a nivel mundial: [- el caso Mirai](https://hipertextual.com/2016/10/mirai-ddos-internet-cosas) [- aspiradores que nos espían](https://laboratoriolinux.es/index.php/-noticias-mundo-linux-/software/38838-desarrollador-descubre-una-puerta-trasera-en-su-aspiradora-inteligente-posible-espionaje-y-control-remoto.html)
##### **IoT en los cursos de Aularagón** - **Blynk:** lo que nos gusta de esta herramienta es que es casi "instantánea" o "síncrona". Esto es imprescindible con ciertos robots como el **Rover Marciano con Arduino**. Necesitamos que "gire" para evitar un obstáculo, no podemos esperar !!!. Veremos con **BLYNK** un protocolo que entre el dispositivo electrónico (nuestro robot) y nosotros (en ordenador, en una APP en el móvil) la comunicación es instantánea, gracias a un servidor que hará de intermedio, que puede ser local (BLYNK LEGACY) o en Internet (BLYNK IoT). - **Blynk legacy** es la que se va a trabajar en - **[Rover Marciano con Arduino ](https://libros.catedu.es/link/7229#bkmrk-en-este-caso-a%C3%B1adire)** - **[Arduinoblocks en el aula](https://libros.catedu.es/books/arduino-en-el-aula)** - **[ESP32 en el aula](https://libros.catedu.es/books/esp32-en-el-aula)** - **Blynk IoT** es la que se va a trabajar con - **[En ESP32 en el aula](https://libros.catedu.es/books/esp32-en-el-aula)** - [**En Smart Home ESP32**](https://libros.catedu.es/books/smart-home-esp32) - **ThinkSpeak y SmartioSpace** - [Smart Agriculture Kit para Micro:bit](https://libros.catedu.es/books/smart-agriculture-kit-microbit/page/led-neopixel) - **MQTT** El emisor envía datos, se almacenan en un servidor, y cuando puede, lo vuelca al cliente. Cliente y emisor pueden ser el dispositivo electrónico y nosotros o viceversa. Veremos que esto es lo que hace el protocolo **MQTT** y está tremendamente extendido por lo barato y fácil que es. Hace que los servidores no estén tan ocupados, por lo tanto hay varios proveedores que ofrecen este servicio gratuitamente. Hay robots como los que tienen la placa **TDR STEAM IMAGINA** que envía datos de temperatura, humedad, .. y pueden recibir datos pero no precisan de esta exigencia instantánea como un rover. - [ESP32 EN EL AULA](https://libros.catedu.es/books/esp32-en-el-aula) - [**En Smart Home ESP32**](https://libros.catedu.es/books/smart-home-esp32) - **TELEGRAM** - [ESP32 EN EL AULA](https://libros.catedu.es/books/esp32-en-el-aula) - [**En Smart Home ESP32**](https://libros.catedu.es/books/smart-home-esp32) - **Arduino cloud IoT** - **[Arduino Alvik](https://libros.catedu.es/books/arduino-alvik)** - **Cyberpi y mBot2** - [Iot con Cyberpi](https://libros.catedu.es/books/cyberpi-y-mbot2/page/iot) # IoT-Wifi-Telegram # Crear bot en Telegram [](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-37-46-botfather-68.jpg) Entramos en nuestro Telegram y chateamos con el creador de los bots: **@BotFather** y nos saldrá esta pantalla: [](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-32-01-botfather-68.jpg) Si tecleamos **/start** nos sale las diferentes opciones [](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-33-30-botfather-68.jpg) Para crear un nuevo bot, tecleamos **/newbot** y nos preguntará el nombre del bot Por cierto, el nombre tiene que acabar con las letras **bot,**NOS PROPORCIONARÁ EL **TOKEN** DEL ROBOT, QUE TOMAREMOS NOTA
[](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-39-59-botfather-68.jpg) Si tecleamos **/mybots** nos sale los diferentes bots creados y al pulsar en uno de ellos nos salen sus opciones [](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-36-25-botfather-68.jpg) # Encontrar tu ID en Telegram #### **Buscar tu ID : chat privado** En este caso para que mi Bot me envié mensajes a mi usuario de Telegram directamente busco mi ID. Vamos a chatear con **@myidbot** [](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-54-31-idbot-68.jpg) y le preguntamos por nuestro identificador con **/getid**TOMAMOS NOTA DE NUESTRO IDENTIFICADOR **ID**
**[](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-14-47-06.jpg)** #### **Buscar ID de un grupo** En este caso tendríamos que añadir a **@myidbo**t al grupo y ejecutar el comando en el chat del grupo **/getgroupid** saldrá un identificador **negativo** Una vez conseguido el ID podemos eliminar **@myidbot** del grupo # Código para enviar y recibir #### **Bucle Inicio** 1. Lo primero es conectar con la wifi 2. Y lo segundo conectar con el **Bot** que hemos creado, gracias al **TOKEN** con la instrucción **INICIAR API TOKEN** 3. Enviamos al **ID** un mensaje de bienvenida con las instrucción **Enviar a Chat ID .... Mensaje ... Formato ....** [](https://libros.catedu.es/uploads/images/gallery/2023-05/owEconectartelegram.jpg) Hemos añadido algunos elementos de control, como el LCD y un zumbador**ATENCIÓN** si en el mensaje a enviar pones carácteres no standard, puede ser que no funcione. Por ejemplo a mi no me ha funcionado enviar ºC
#### **Enviar y recibir** En el evento **TELEGRAM - NUEVO MENSAJE RECIBIDO** se puede utilizar el comando **TELEGRAM MENSAJE** en el siguiente programa se puede ver como en la pantalla del LCD aparecerá quien es el remitente y qué mensaje Luego envía la temperatura si el usuario de Telegram envía la palabra *temp* [](https://libros.catedu.es/uploads/images/gallery/2023-05/envioyrecepciontelegram.jpg) # Actividad 17 Telegram Este es el resultado [](https://libros.catedu.es/uploads/images/gallery/2023-05/2023-05-30-19-55-39-javierarduino-72.jpg) [https://youtube.com/shorts/Uaan2VYEHcM?feature=share](https://youtube.com/shorts/Uaan2VYEHcM?feature=share) Puedes probarlo en [t.me/JavierArduinobot](https://t.me/JavierArduinobot) ##### **Ampliemos con avisos de alarma** Puedes hacer que ante un evento, te envíe un mensaje por ejemplo el pulsador 1 [](https://libros.catedu.es/uploads/images/gallery/2026-02/2026-02-20-22-18-36-javierarduino-at-javier-quintana-1825.png) El resultado es: Imagina que el pulsador está conectado a una ventana, entonces por Telegram te puede avisar si ha entrado un ladrón**RETO AVISO TEMPERATURA ELEVADA** Suponte que tienes vacunas en una nevera, y quieres se te avise de forma remota que se supera un valor determinado para tomar medidas antes de que se estropeen. Haz un programa que te envíe un aviso por Telegram si la temperatura alcanza un determinado valor.
# IoT-Wifi-Blynk IoT # ¿Qué es Blynk.io? Blynk nació como software libre como **Blynk legacy** y en Catedu aprovechamos este servicio para realizar[ Rober Marciano con Arduino](https://libros.catedu.es/books/rover-marciano-con-arduinoblocks-e-internet-de-las-cosas-iot). La idea era sencilla: Programabas en **STEAMAKERBLOCKS** y el robot se comunicaba con el servidor **Blynk legacy** y con escritorio **Dashboard** via web (**Panel Web**) o APP BLYNK ponías **Gadgets** y controlabas el robot:  [En junio 2022](https://www.blynk.io/blog/what-will-happen-to-the-legacy-blynk-platform) Blynk legacy deja de dar servicio y pasa a**[ Blynk.io, ](https://www.blynk.io/)**una plataforma de pago pero que tiene **Gadgets** gratuitos suficientes para nivel educativo**Sabías que...?** Blynk legacy al ser software libre te lo puedes descargar y montar tu propio servidor Blynk legacy con lo que tendrías recursos y gadgets ilimitados. Esto lo trataremos en un capítulo aparte.
#### **Registro en Blynk.io** Entramos en la página [https://blynk.io/](https://blynk.io/) de y nos registramos en LOG IN [](https://libros.catedu.es/uploads/images/gallery/2023-01/paginablynk.png) Nos pide un email. Cuando lo ponemos, nos llega este mensaje que tenemos que dar al botón "Complete setup". Nos saldrá un diálogo para elegir la contraseña, una pequeña encuesta   ##### **CONCEPTOS CLAROS** - En BLYNK se crea el **Dispositivo o Device** ESP32 que contendrá el programa realizado en **STEAMAKERBLOCKS** y en el programa se insertan estos datos que nos proporciona BLYNK : - ID DE LA PLANTILLA - NOMBRE DE LA P LANTILLA - TOCKEN - Se definen en BLYNK las variables de flujo, **flujo de datos o Datastream** que son **variables virtuales** V1 V2, ..... tú en tu programa de STEAMAKERBLOCKS almacenas o recoges la información - Y finalmente nuestro objetivo: un **Panel Web o Dashboard** que es un panel donde controlas online tu ESP32 y cada **gadjet** que pones esa asociado a una variable virtual [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-22-34-22-presentacion1-powerpoint.png) # Crear DASHBOARD en Blynk.io Vamos a crear un DASHBOARD o PANEL DE CONTROL para controlar nuestro ESP32. ##### **AÑADIR DEVICE** 1. Vamos a **Devices** 2. **Create New** [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-16-48-26-greenshot.png) 3. Buscamos **ESP32** 4. Elegimos **Quick start** [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-16-49-59.png) Nos saldrá un código que tiene **tres cosas importantes** que tienes que guardar (En download te lo baja en formato .ino que lo puede leer el bloc de notas) 1.**ID DE LA PLANTILLA**
2.**NOMBRE DE LA P LANTILLA**
3.**TOCKEN**
[](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-23-22-07-24-devices-blynk-console-mozilla-firefox.png)En el siguiente diálogo quiere meter el código en el ESP32, dar a **CANCELAR** pues eso lo hará Steamakersblocks
##### **DATASTREAMS O FLUJO DE DATOS** Una vez creado el **Device**, le damos dos clicks y nos sale el **Template**. Al darle a **EDIT** tenemos opción de ir añadiendo las variables asociadas a los pines virtuales, TE RECOMIENDO BORRAR LAS QUE TE PONE Y AÑADIR TÚ LOS PINES VIRTUALES por ejemplo en este caso DE ESP32 KEYSTUIDIO TDR STEAM IMAGINA| NOMBRE | PIN VIRTUAL | TIPO | UNIDAD | MIN | MAX |
| LED ROJO | V1 | entero | 0 | 1 | |
| SIMPSON | V2 | entero | 0 | 1 | |
| LCD | V3 | CADENA | |||
| PULSADOR | V4 | entero | 0 | 1 | |
| TEMPERATURA LM35 | V5 | entero | ºC | 0 | 100 |
| TEMPERATURA DHT11 | V6 | entero | ºC | 0 | 100 |
| HUMEDAD | V7 | entero | % | 0 | 100 |
| SONIDO | V8 | entero | 0 | 4095 |
Ves añadiendo las variables que quieras visualizar o gobernar, dándoles las unidades, valores min, max correspondientes
**No utilices ni el potenciómetro ni el sensor de luz**, tal y como vimos en [Sensores y actuadores de la placa Imagina TDR STEAM](https://libros.catedu.es/books/esp32-en-el-aula/page/sensores-y-actuadores-de-la-placa-imagina-tdr-steam), cuando hay comunicación Wifi, están inutilizados.
[](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-21-27-09-greenshot.png) #### **TEMPLATE PANEL WEB** Una vez creado el **Device**, le damos dos clicks **[](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-23-22-10-43-devices-blynk-console-mozilla-firefox.png)** Si le damos dos clicks sale el **Template** - En los tres puntos horizontales le podemos cambiar el nombre - En el Edit podemos poner nuestros elementos **[](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-23-22-11-48-devices-blynk-console-mozilla-firefox.png)** Vamos a ir añadiendo **WIDGETS ASOCIADOS A ESOS DATASTREAMS** para crear tu panel de control, algunos son de pago 😣 [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-21-54-28.png) Los puedes redimensionar, borrar, etc... En el botón de la rueda dentada vas asociando el Widget con el pin virtual V1, V2, ... V8 [](https://libros.catedu.es/uploads/images/gallery/2023-01/blynk-gif.gif) *Fuente [https://blynk.io/](https://blynk.io/)* #### **APP BLYNK IOT** Hay una APP sencilla, que al loguearse YA APARECE EL DEVICE lo único que hay que hacer es el TEMPLATE asociado, y es muy sencillo [](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-23-22-27-43-greenshot.png) Podemos visualizar y crear las plantillas en el móvil, para ello sigue las instrucciones ##### **CASO ESP32 SMART HOME [](https://libros.catedu.es/uploads/images/gallery/2025-10/smart-home.png)** **ESP32 SMARTHOME** he puesto de pines virtuales - **TEMPERATURA** asociado al pin virtual **V1** entero unidades ºC minimo 0 máximo 100 (por ejemplo) - VENTILADOR asociado al pin virtual V2 - HUMEDAD asociado al pin virtual V3 [](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-23-22-19-22.png) Podemos poner multitud de widgets, vamos a simplificar con - ESP32 al Template: Temperatura y humedad - Template al ESP32 un botón para encender y apagar el ventilador [](https://libros.catedu.es/uploads/images/gallery/2025-10/2025-10-23-22-22-02-greenshot.png) # Crear programa en STEAMAKERBLOCKS Actividad18 Blynk IoT #### **Programa Steamakerblocks: Al inicializar...** Tiene que cargar los siguientes datos de la Wifi y de la conexión con Blynk.io - El nombre de la red wifi y su contraseña para conectarse - El **ID de la plantilla** creada - El nombre del **Device** - El **token** para dar acceso a esa plantilla y deviceSi no te acuerdas de los tres últimos, mira más abajo cómo puedes localizarlos
De paso hemos inicializado el LDC para que nos muestre datos [](https://libros.catedu.es/uploads/images/gallery/2023-01/blynk-arduinoblocks-1.png) #### **A programar de Dashboard ->ESP32.** Vamos a hacer que si se pulsa en el dashboard el interruptor asociado al pin virtual V1 que se encienda el led rojo [](https://libros.catedu.es/uploads/images/gallery/2023-01/blynk-arduinoblocks-4.png) Luego si se pulsa en el dashboard el pin 2 que suene los simpsons 😍 [](https://libros.catedu.es/uploads/images/gallery/2023-01/blynk-arduinoblocks-5.png) Luego si se introduce texto en V3 que en la pantalla LCD lo diga [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-19-22-10-33.png) #### **A programar de ESP32 ->Dashboard.** Vamos a crear un programa que vaya recogiendo los valores de ESP32 cada 3 segundos (para no agobiar al servidor Blynk) y los vuelque al Dashboard [](https://libros.catedu.es/uploads/images/gallery/2023-01/blynk-arduinoblocks-7.png) - V4 tiene los valores 0 o 1 según el valor del pulsador 1 de la placa TDR SteaMaker por lo tanto enciende el LED del dashboard de Blynk.io si se pulsa. - V5 capta la temperatura del LM35, da un valor más exacto que es que visualiza el DHT11 - V6 copia la temperatura del DHT11 - V7 tiene los datos de la humedad del DHT11 - V8 registra los datos del nivel de sonido del sensor micrófono incorporado y conectado en el A3 - Para ver que realmente los valores de V8 no siguen fielmente a los reales, vamos a poner en el bucle esta instrucción para que visualice los valores de sonido registrados: [](https://libros.catedu.es/uploads/images/gallery/2023-01/blynk-arduinoblocks-8.png) ##### **ESTE ES EL RESULTADO** ##### **No me acuerdo de estas tres cosas: TOKEN -ID PLANTLLA - NAME PLANTILLA ¿Dónde puedo encontrarlo?** Primero Entras en **[Blynk.io](https://blynk.io)** y Te logueas **Log in** y luego : 1. Entras en **Depeloper Zone/Zona de desarrollador** 2. **My Templates/Mis plantillas** 3. Haz dos clicks en la **plantilla** [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-22-15-07-05-whatsapp.png) - Con dos cliks en **Authtoken** ya se queda copiado en el portapapeles para que lo pegues en tu programa **STEAMAKERBLOCKS** - Más a la derecha hay una ventana Firmware configuration/Configuración de firmware donde puedes encontrar el ID de la plantilla y su nombre: Copiar y pegar el trozo de código, pegarlo en un editor y copiar sólo el **ID** y el **NAME** para pegarlo en tu código **STEAMAKERBLOCKS** [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-22-15-09-19-whatsapp.png) # Avanzado: Blynk Legacy local # Raspberry: Qué hay que hacer para empezar {{@5144}} # Rasbperry: Poner un Sistema Operativo {{@4308}} # Raspberry: Cambiar usuario y contraseña {{@4311}} # Raspberry: Conectarlo a la red {{@4309}} # Raspberry: Conexión SSH {{@4310}} # Raspberry: Apagar {{@4312}} # Raspberry: VNC {{@4313}} # Raspberry: Instalar Java 8 {{@5145}} # Raspberry: Instalar y ejecutar el servidor Blynk local {{@5146}} # En Windows Instalar Java 11 {{@7126}} # En Windows Instalar Blynk local {{@7127}} # En Windows Ejecutar Blynkserver {{@7128}} # En Linux: Insyalar Blynk Legay local {{@7149}} # Blynk Legacy: La APP {{@7054}} # Blynk Legacy: Crear cuentas {{@5134}} # Blynk Legacy: El panel de control {{@5147}} # Blynk Legacy: En la APP {{@5148}} # Blynk Legacy: Poner el TOKEN en Steamakerblocks {{@5149}} # Blynk Legacy: 1programa: Encender los pines rojo y verde {{@7176}} # Blynk Legacy: 2programa RGB y el potenciómetro {{@7188}} # Blynk Legacy: 3programa Medir la luz del LDR {{@7177}} # Blynk Legacy: 4programa: Medir T y H con el DHT11 {{@5138}} # Blynk Legacy: 5programa: Lectura sensor LM35 y receptor IR {{@7186}} # Blynk Legacy: 6programa Leer eventos del TDR Steam {{@7189}} # Blynk Legacy: 7programa: El timbre {{@7190}} # Blynk Legacy: ¿Todo junto? {{@7191}} # Muro # Para saber más ... ##### **PROYECTOS** [https://content.innovadidactic.com/](https://content.innovadidactic.com/) ##### **PROGRAMAR ESP32 STEAMAKER TDR STEAM CON MICROBLOCKS** [https://pedroruizf.github.io/steamakersmicroblocks](https://pedroruizf.github.io/steamakersmicroblocks) [](https://libros.catedu.es/uploads/images/gallery/2026-01/2026-01-14-17-37-56-whatsapp.png) ##### **APP ARDUTALLER** App [Ardutaller WB Control ](https://play.google.com/store/apps/details?id=appinventor.ai_websoldado.ARDUTALLER_CONTROL)y manual en [https://www.ardutaller.com.es/apps-by-ardutaller/manuales-app-ardutaller-wb-control](https://www.ardutaller.com.es/apps-by-ardutaller/manuales-app-ardutaller-wb-control) ##### **MALETA DE LA INNOVACIÓN 4.0 IOT** Tarjeta micro SD, HID, servidor HTTP, cliente HTTP, Alexa, Telegram Bot, Wifimesh ... [https://drive.google.com/file/d/1XZrXIEV3WdbZwsugKRka3MhwACDJvYUg/view](https://drive.google.com/file/d/1XZrXIEV3WdbZwsugKRka3MhwACDJvYUg/view) [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-24-14-50-24-maleta-de-la-innovacion-4-0-iot-con-esp32-steamakers-y-arduinoblocks-pdf-googl.jpg) ##### **ESP32 PLUS STEAMMaker Imagina TDR STeam ArduinoBlocks** - [https://drive.google.com/file/d/11OVVUzdMhZLwt6nxMWmzSioArvtdOict/view](https://drive.google.com/file/d/11OVVUzdMhZLwt6nxMWmzSioArvtdOict/view) - [https://fgcoca.github.io/ESP32-STEAMakers/](https://fgcoca.github.io/ESP32-STEAMakers/) - [Descarga desde el drive del autro tutorial Manual de Actvidades ESP32 SteamMaker 2022\_Junio](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) - [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-24-14-51-39-manual-actividades-esp32-steamakers-2022-junio-pdf-xchange-viewer.jpg) Carpeta con los programas, circuitos, etc... [https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view](https://drive.google.com/file/d/1HObvv4gBn-TB4pDG4W-JYIBScPXaXpMs/view) [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-24-14-53-19-esp32-steamakers-1.jpg) #### **Arduino Free Book** Servidor HTTP, cliente HTTP, WifiMesh... [https://docs.google.com/document/u/1/d/e/2PACX-1vQSrOKHpbLQHVbGFdAvp7DcndoftoHDI20nvwGMaxu\_7bGc1bUCmi4U6DZrJWRSudc2iXBg43QMuzCT/pub#h.35h2u46mzlaq](https://docs.google.com/document/u/1/d/e/2PACX-1vQSrOKHpbLQHVbGFdAvp7DcndoftoHDI20nvwGMaxu_7bGc1bUCmi4U6DZrJWRSudc2iXBg43QMuzCT/pub#h.35h2u46mzlaq) [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-24-14-54-37-arduinoblocks-freebook-es.jpg) ##### **Manuales EducaconTic** En este manual, puedes encontrar prácticas de MQTT usando **THINGSPEAK** Y **THINGVIEW** [https://sites.google.com/view/educacont/documentaci%C3%B3n/hist%C3%B3rico/manuales?pli=1](https://sites.google.com/view/educacont/documentaci%C3%B3n/hist%C3%B3rico/manuales?pli=1) [](https://libros.catedu.es/uploads/images/gallery/2023-01/2023-01-24-14-58-38-educacont-manuales.jpg) # Créditos ## **Autoría y licencias** - **Federico Coca** [GitHub](https://github.com/fgcoca) [Twitter](https://twitter.com/fgcoca) [Instagram](https://www.instagram.com/cocafederico/?hl=es) [Mas información](https://fgcoca.github.io/Como-documento/about/). Autor de los siguientes capítulos con licencia Creative Commons Atribución-CompartirIgual 4.0 International ("[CC BY-SA](https://creativecommons.org/licenses/by-sa/4.0/deed.es)"). Ver Notas sobre ESP32 STEAMakers - Miscelanea-Licencias[ https://fgcoca.github.io/ESP32-STEAMakers/Miscelanea/lic/](https://fgcoca.github.io/ESP32-STEAMakers/Miscelanea/lic/) - **Prácticas con sensores digitales** - **Prácticas con sensores analógicos** - **Prácticas con otros elementos del kit** - **Javier Quintana Peiró** CATEDU. Maquetador de todo el libro y autor de los siguientes capítulos con licencia Attribution-NonCommercial-ShareAlike 4.0 International ([CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/)) - **Introducción** - **Bluetooth** - **IoT-Wifi-MQTT** - **IoT-Wifi - Blynk** - **IoT-Wifi - Blynk Legacy** - **Cómo montar un servidor Blynk Legacy Local** Cualquier observación o detección de error en [soporte.catedu.es](https://catedu.es/soporte-catedu/) [](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648462225402.gif) [](https://libros.catedu.es/uploads/images/gallery/2022-03/image-1648462299882.png)