Mientras trabajaba en la ruleta de tiras LED, se me ocurrió otra idea para utilizar estos dispositivos de iluminación universales. En un abrir y cerrar de ojos, convertí una tira LED de 1 m de longitud con 60 LED Neopixel en un termómetro. La estructura es tan sencilla que el proyecto es muy adecuado para principiantes en el tema de los microcontroladores: en el caso más simple, solo se necesitan cuatro piezas. Le mostraré el procedimiento en este nuevo episodio de la serie.
MicroPython en ESP8266, ESP32 y Raspberry Pi Pico
hoy
El termómetro con tira LED
El programa para el termómetro está escrito, por supuesto, en MicroPython, de tal manera que puede ejecutarse sin modificaciones en todos los controladores mencionados en el título. Con dos botones adicionales, que solo se necesitan para grabar el firmware, incluso el miembro más pequeño de la familia ESP8266, el ESP8266-01S, puede servir como unidad de control para la tira LED. El programa operativo del termómetro está diseñado para este controlador con sus dos pines GPIO: GPIO0 controla los LED de la tira, mientras que GPIO2 realiza la conexión del bus de un solo cable al DS18B20. Dado que la placa del ESP8266-01S no contiene un convertidor de tensión de 5 V a 3,3 V, necesitamos un circuito externo para ello. La conexión al USB también debe proporcionarse mediante un adaptador USB-TTL externo. Con esto ya tenemos todo el hardware.
Hardware
| 1 | ESP32 Dev Kit C V4 sin soldar o Módulo ESP32 NodeMCU Placa de desarrollo WiFi con CP2102 o ESP8266 01S esp-01S Módulo WiFi con adaptador para placa de pruebas o D1 Mini V3 NodeMCU con ESP8266-12F o NodeMCU Lua Lolin V3 Módulos ESP8266 ESP-12F WIFI Placa de desarrollo wifi con CH340 o NodeMCU Lua Amica Módulo V2 ESP8266 ESP-12F WIFI Placa de desarrollo wifi con CP2102 o D1 Mini V4 NodeMCU ESP8266EX Módulo WLAN con conexión USB-C compatible con Arduino o |
| 1 | |
| 1 | DS18B20 Sensor de temperatura digital TO92 o Cable de 1 m Sensor de temperatura digital DS18B20 de acero inoxidable |
| 1 | Resistencia 10 kΩ |
| 2 | Opcional para ESP8266-01S Botones, por ejemplo, módulo de botones KY-004 |
| 1 | si se utiliza un ESP8266-01S |
| 1 | si se utiliza un ESP8266-01S |
| 1 |
Como muestran los siguientes diagramas de circuitos, la estructura es más fácil de realizar con un ESP32 o un ESP8266. Con el ESP8266-01S, necesitará un convertidor de 5 V a 3,3 V y, además, para Grabar el firmware con dos botones, ya que la placa pequeña no dispone de un sistema de grabación automático como sus hermanas mayores, ni tampoco tiene un regulador de tensión integrado. A cambio, se puede prescindir de la resistencia pull-up en la línea de señal del DS18B20. Para la conexión al USB se necesita además un adaptador USB a TTL, pero solo durante el periodo de desarrollo del programa y después para grabar el programa operativo ledstrip_thermo.py.
La alimentación de la tira de LED debe realizarse con 5 V desde una fuente de alimentación enchufable para un funcionamiento prolongado. El consumo máximo de corriente del controlador y los LED es de aproximadamente 80 a 120 mA. Algunas de las placas ESP8266 aceptan tensiones externas a través de la conexión Vin, pero no suministran los 5 V de la conexión USB. En el caso de las placas ESP32 y la Raspberry Pi Pico , esto ya funciona. Por lo tanto, con estos controladores, la tira de LED se puede alimentar directamente desde el USB. Si se desea utilizar el dispositivo terminado independientemente del PC, es casi imprescindible utilizar una fuente de alimentación, a menos que se utilice una batería de litio junto con un soporte de batería adecuado. Este también ofrece 5 V y 3,3 V conuna capacidad de carga de 1 A cada uno. Con una carga, el circuito funciona durante aproximadamente 24 horas.
Aquí están los diagramas de circuitos.
Figura 1: Termómetro LED ESP8266 D1 mini
Imagen 2: Termómetro LED ESP32
Figura 3: Termómetro LED ESP8266-01S
Imagen 4: Termómetro LED - Raspi Pi Pico
Los diagramas de conexión también reflejan el tipo de estructura. La estructura con el ESP8266-01S es algo caótica debido a los componentes adicionales. El uso de un soporte de batería con batería de litio evita el uso del regulador de tensión de 5 V a 3,3 V. Todos los ESP tienen el firmware 19.1.
Ilustración 5: Estructura con ESP8266-01S
Esto queda muy claro con un ESP8266 NodeMcu V3.
Ilustración 6: Estructura con ESP8266-NodeMcu V3
El software
Para flashear y programar el ESP32:
Thonny o
Para representar señales de bus
SALEAE: software de análisis lógico (64 bits) para Windows 8, 10 y 11
Firmware utilizado para el ESP32:
Firmware utilizado para el ESP8266:
ESP8266_GENERIC-FLASH_1M-20220618-v1.19.1.bin
Firmware utilizado para el Raspberry Pi Pico (W):
RPI_PICO_W-20240602-v1.23.0.uf2
Los programas MicroPython para el proyecto:
ledstrip_thermo.py: programa operativo del termómetro
MicroPython - Lenguaje - Módulos y programas
Aquí encontrará instrucciones detalladas (versión en inglés) para instalar Thonny. También incluye una descripción de cómo instalar el firmware Micropython (versión del 25/01/2024) en el chip ESP quemado. Para saber cómo poner en marcha el Raspberry Pi Pico, consulte aquí.
MicroPython es un lenguaje interpretado. La principal diferencia con el IDE de Arduino, donde siempre se flashean programas completos, es que solo hay que flashear el firmware de MicroPython una vez al principio en el ESP32 para que el controlador entienda las instrucciones de MicroPython. Para ello, puede utilizar Thonny, µPyCraft o esptool.py. Para Thonny, he descrito el proceso aquí.
Una vez flasheado el firmware, puede comunicarse libremente con su controlador, probar comandos individuales y ver la respuesta de inmediato, sin tener que compilar y transferir todo un programa previamente. Eso es precisamente lo que me molesta del IDE de Arduino. Se ahorra mucho tiempo si se pueden comprobar de antemano desde la línea de comandos pruebas sencillas de sintaxis y hardware, hasta probar y perfeccionar funciones y partes completas del programa, antes de crear un programa a partir de ello. Para ello, me gusta crear pequeños programas de prueba. Como una especie de macro, agrupan comandos recurrentes. A partir de estos fragmentos de programa se desarrollan a veces aplicaciones completas.
Inicio automático
Si desea que el programa se inicie automáticamente al encender el controlador, copie el texto del programa en un archivo en blanco recién creado. Guarde este archivo como main.py en el espacio de trabajo y cárguelo en el chip ESP. El programa se iniciará automáticamente la próxima vez que se reinicie o se encienda el dispositivo.
Probar programas
Los programas se inician manualmente desde la ventana actual del editor en el IDE Thonny pulsando la tecla F5. Esto es más rápido que hacer clic con el ratón en el botón de inicio o a través del menú Ejecutar. Solo los módulos utilizados en el programa deben estar en la memoria flash del ESP32.
¿De vez en cuando vuelves a utilizar Arduino IDE?
Si más adelante desea volver a utilizar el controlador junto con el IDE de Arduino, simplemente actualice el programa como de costumbre. Sin embargo, el ESP32/ESP8266 habrá olvidado que alguna vez habló MicroPython. Por el contrario, cualquier chip Espressif que contenga un programa compilado desde el IDE de Arduino o el firmware AT o LUA o... puede equiparse sin problemas con el firmware MicroPython. El proceso es siempre el mismo que se describe aquí.
El programa operativo
El programa está diseñado de forma tan clara como las estructuras. Mediante Al seleccionar GPIO2 como conexión de bus de un solo cable y GPIO0 como línea de bus de control para la tira Neopixel, el programa se ejecuta en todos los controladores mencionados anteriormente sin necesidad de realizar modificaciones. Las unidades funcionales individuales se definen en forma de funciones.
En el caso de la familia ESP8266, he observado en varias ocasiones que el controlador se bloquea poco después del inicio. Esto parece deberse a que intenta establecer contacto con un punto de acceso a través de la unidad WLAN. Como solución alternativa, desactivo web-REPL inmediatamente después de actualizar un nuevo firmware. Esto ha estabilizado considerablemente el comportamiento de inicio.
Los GPIO de los 8266 también tienen las designaciones de LUA. En este contexto, una tabla de conversión resulta muy útil a la hora de programar, sobre todo en lo que respecta a los distintos niveles de tensión que deben mantenerse durante el arranque para que el proceso se desarrolle sin errores. Veamos ahora las partes del programa y su función.
# ledstrip_thermo.py
# Después de flashear el firmware en el ESP8266:
# import webrepl_setup
# > d para desactivar
# A continuación, RST; ¡reiniciar!
# Pintranslator para placas ESP8266
#Pines LUA D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
#Pines ESP8266 16 5 4 0 2 14 12 13 15 3 1
#Atención hi sc sd hihi lo hi hi
# used DSLE
from máquina import Pin
from tiempo importar sleep
from onewire importar OneWire
from ds18x20 importar DS18X20
from neopixel importar NeoPixel
from sys import exit, plataforma
En el negocio de importación, solo utilizamos módulos que están integrados de forma fija en el núcleo MicroPython. Queremos acceder a los pines GPIO, dejar el controlador un poco inactivo entretanto, necesitamos el bus One-Wire para el sensor de temperatura DS18B20 y NeoPixel nos proporciona una matriz para la información de color, así como la función write(), con la que enviamos el contenido del búfer a través del bus Neopixel.
dsPin=Pin(2) # ESP8266 (D4)
ds = DS18X20(OneWire(dsPin))
dispositivo = ds.scan()[0]
ds.convert_temp()
sleep(0,750)
imprimir(dispositivo,ds.read_temp(dispositivo))
GPIO2 será nuestra conexión de bus de un solo cable. OneWire(dsPin) Crea el objeto de bus, que pasamos inmediatamente al constructor de la clase DS18X20. La función scan() del objeto DS18X20 busca componentes en el bus y, con suerte, encontrará el nuestro, el DS18B20. La identificación ROM del componente es un objeto bytearray con ocho valores, que se cubre junto con otras posibles identificaciones en una lista.
>>> ds.scan()
[bytearray(b'(\xffd\x0ei\x0f\x01>')]
Como solo tenemos un DS18B20 en el bus, seleccionamos el elemento 0 de la lista.
>>> ds.scan()[0]
bytearray(b'(\xffd\x0ei\x0f\x01>')
El identificador se utiliza para acceder por separado a cada uno de los chips del bus. convert_temp() ordena a todos los chips que inicien una medición. Tras un mínimo de 750 ms, podemos obtener el resultado con ayuda de la función read_temp(). Se debe transferir el identificador correspondiente del componente. Lo hemos guardado en device.
led=Pin(0,Pin.OUT,valor =0) # ESP8266 (D3)
numOfPix=60
np=NeoPixel(led,numOfPix)
pos0 = 20
maxTemp=39
minTemp=-20
temp=[0 for i en range(60)]
Definimos la conexión del bus Neopixel GPIO0 como salida y establecemos el nivel en 0. El bus debe servir a numOfPix = 60 LED. El constructor de la clase NeoPixel nos genera el objeto np. El LED con el número 20 nos indica el punto cero de la escala del termómetro. Por lo tanto, nuestra escala va de -20 °C (LED número 0) a 39 °C (LED número 59). En la lista temp creamos 60 elementos con la ayuda de una comprensión de lista, que inicialmente tienen el valor 0. Más adelante, la lista incluirá la representación cromática de la escala.
de=(0,0,0)
verde=(0,64,0)
azul oscuro=(0,0,4)
azul claro=(0,0,128)
rojo oscuro=(4,0,0)
rojo claro=(128,0,0)
magenta =(2,0,2)
statered=0
stateblue=0
stategreen=0
Los valores de color para los LED Neopixel se indican mediantetripletas. Los tres valores representan las proporciones de rojo, verde y azul.
Los LED situados encima de la indicación de temperatura actual se borran (apagado = (0,0,0)), el punto cero se representa con un verde brillante. Las decenas en el rango positivo se iluminan en rojo brillante, en el rango negativo en azul brillante. Los valores intermedios se representan en colores más oscuros. Para facilitar la orientación, dejo que las unidades se iluminen en magenta oscuro. A temperaturas superiores a 40 °C, el LED superior debe parpadear; a temperaturas inferiores a -20 °C, parpadea el LED inferior. El punto cero siempre está iluminado. Para poder distinguir -1 °C de 0 °C, en este último caso parpadea el LED de cero grados. Para controlar estos estados, utilizo las tres variables de estado.
def setScale():
for i en rango(20):
temp[i]=azul oscuro
for i en rango(21,60):
temp[i]=rojo oscuro
for i en [0,10]:
temp[i]=azul claro
for i in [30,40,50]:
temp[i]=rojo claro
for i en rango(5,60,10):
temp[i]=magenta
temp[20]=verde
La función setScale() rellena la lista temp con los valores de color. El rango negativo se colorea primero de azul oscuro, y el positivo de rojo oscuro. Los límites del rango y los valores de la lista en las instrucciones for son los números de posición de los LED en la tira. A continuación, los niveles de 10 se sobrescriben en azul claro y rojo claro. Los niveles de 5, comenzando por el LED número 5, los sobrescribo en pasos de 10 hasta el número 55 en magenta oscuro. Por último, establezco la posición 20 en verde.
def fillAndShow(temperatura):
t=min(temperatura,maxTemp)
t=máx(minTemp,t)
maxpix = int(t) + pos0
for i en range(maxpix + 1):
np[i]=temp [i]
for i en rango(maxpix + 1,numOfPix):
np[i]=de
if t < 0:
np[pos0]=verde
np.escribir()
La función fillAndShow() es prácticamente el núcleo del programa, la indicación de la temperatura. En ella se transfieren los valores de color de la lista temp a la memoria intermedia np del objeto NeoPixel.
Información de fondo:
La memoria intermedia del objeto NeoPixel es en realidad una matriz de bytes con el identificador buf. En nuestro caso, se puede referenciar con np.buf. El contenido consiste en grupos consecutivos de tres para cada LED. Si se utiliza np[2]=(1,2,3) el valor de color para el LED número 2 como tupla, entonces la función oculta __setitem__() convierte la tupla en una secuencia de objetos bytes y escribe los valores en la matriz de bytes np.buf. Si observamos el contenido de np.buf, vemos que el orden de los bytes ha cambiado.
>>> np[2]=(1,2,3)
>>> np.buf
bytearray(b'\x00\x00\x80\x00\x00\x04\x02\x01\x03\x00\x00\x04\x00\x00\x04 …
Los valores RGB se aplican tal y como lo especifica el atributo np.ORDER.
>>> np.ORDER
(1, 0, 2, 3)
Si pasamos R=1, G=2 y B=3, los valores terminan como G, R, B en el búfer. Con 3 se pasaría un valor blanco, pero este no es compatible con el tipo de LED utilizado.
Pero veamos ahora más de cerca la función fillAndShow(). Al llamar a la función, se pasa al parámetro temperatura el valor de temperatura actual, que debe estar dentro del rango permitido para que el programa no se interrumpa con un error. t=min(temperatura,maxTemp) garantiza que t no supere la temperatura máxima que se puede mostrar. min() devuelve el mínimo de los valores transferidos. t=max(minTemp,t) es responsable de cumplir el límite inferior.
Ahora hay que determinar el número del LED correspondiente a la temperatura en t. Tomamos la parte entera del valor de la temperatura y nivelamos el punto cero de la escala Celsius en la posición 20 de la cadena de LED. < span lang="DE" style="font-size: 10.0pt; font-family: 'Courier New'; mso-fareast-font-family: 'Times New Roman'; color: black;">maxpix = int(t) + pos0
A continuación, llenamos el búfer hasta el límite calculado con el contenido de la escala.
for i en rango(maxpix + 1):
np [i]=temp[i]
El resto de los LED situados encima los ponemos en off=0,0,0.
for i en rango(maxpix + 1,numOfPix):
np[i]=de
Si la temperatura es negativa, activamos el punto cero. A continuación, enviamos el contenido del búfer a la pantalla.
if t < 0:
np[pos0]=verde
np.escribir()
Podemos apagar toda la tira de LED con la función clearStrip(). Describimos el búfer con tuplas (0,0,0) fuertes.
def clearStrip():
for i en rango(numOfPix):
np[i]=de
np.write()
Los tres eventos de parpadeo para temperaturas superiores e inferiores, así como para 0 °C, se gestionan con ayuda de las tres funciones binkRed(), blinkBlue() y blinkGreen(). Todas ellas tienen la misma estructura. Veamos más detenidamente la función blinkRed() a modo de ejemplo.
def blinkRed():
global statered
if statered == 1:
np[numOfPix-1]=de
np.escribir()
iniciado = 0
else:
np[numOfPix-1]=rojo oscuro
np.escribir()
statered = 1
El valor de la variable statered se modifica en el procedimiento y debe volver a estar disponible en la siguiente llamada. Una forma de conseguirlo es mediante variables globales. Sin la declaración global, la variable desaparecería al salir de la función. Otra forma de hacer que la variable sea estática sería utilizar un cierre. Siga el enlace si desea obtener más información al respecto. Para los principiantes, nos quedaremos con la primera solución, que es más sencilla.
Si statered es igual a 1, se debe apagar el LED superior. numOfPix tiene el valor 60. Por lo tanto, el LED superior tiene el número 59, porque la numeración comienza en 0. Enviamos el estado (¡de todos!) los LED con np.write() a la tira y establecemos statered en 0.
En la siguiente llamada se ejecuta la rama else. Establecemos el contenido del LED superior en rojo oscuro, enviamos el búfer y asignamos a statered el valor 1.
De forma análoga, tratamos el LED inferior (número 0) y el LED de punto cero en la posición pos0 = 20.
def blinkBlue():
global stateblue
if stateblue == 1:
np[0]=de
np.write()
stateblue = 0
else:
np[0]=azul claro
np.escribir()
stateblue = 1
def blinkGreen():
global stategreen
if stategreen == 1:
np[pos0]=de
np.write()
stategreen = 0
else:
np[pos0]=verde
np.escribir()
stategreen = 1
Mediante el uso de funciones, creamos una visión general en el programa principal, que solo tiene 15 líneas.
Generamos la escala del termómetro y borramos los LED, luego entramos en el bucle principal.
setScale()
clearStrip()
Se inicia la medición del valor actual de la temperatura. El controlador cuenta ovejas durante un segundo y, a continuación, determina el valor entero de la temperatura leída redondeándolo al alza.
while 1:
ds.convert_temp()
sleep(1)
t =int(ds.read_temp(dispositivo) + 0,5)
imprimir(t,«C»)
fillAndShow(t)
if t < minTemp:
blinkBlue()
if t > maxTemp:
blinkRed()
if t == 0:
blinkGreen()
Podemos eliminar el comando de impresión en la producción. fillAndShow() muestra la temperatura en la tira, como se ha descrito anteriormente. Con las construcciones if tratamos los casos especiales.
Aquí está el listado completo del programa ledstrip_thermo.py:
# ledstrip_thermo.py
# Después de flashear el firmware en el ESP8266:
# import webrepl_setup
# > d para desactivar
# A continuación, RST; ¡reiniciar!
# Pintranslator para placas ESP8266
#Pines LUA D0 D1 D2 D3 D4 D5 D6 D7 D8 RX TX
#ESP8266 Pines 16 5 4 0 2 14 12 13 15 3 1
#Atención hi sc sd hihi lo hi hi
# used OLED DS LE
from máquina import Pin
from tiempo importar sleep
from onewire importar OneWire
from ds18x20 importar DS18X20
from neopixel import NeoPixel
from sys importar exit, plataforma
botón=Pin(0,Pin.IN,Pin.PULL_UP)
dsPin=Pin(2) # ESP8266 (D4)
ds = DS18X20(OneWire(dsPin))
dispositivo = ds.scan()[0]ds.convert_temp()
sleep(0,750)
imprimir(dispositivo,ds.read_temp(dispositivo))
led= (0,Pin.OUT,valor=0) # ESP8266 (D3)
numOfPix=60
np=NeoPixel(led,numOfPix)
pos0 = 20
maxTemp=39
minTemp=-20
temp=[0 for i en range(60)]
de=(0,0,0)
verde=(0,64,0)
azul oscuro=(0,0,4)
azul claro=(0,0,128)
rojo oscuro=(4,0,0)
rojo claro=(128,0,0 )
magenta=(2,0,2)
statered=0
stateblue=0
stategreen=0
def setScale():
for i en rango(20):
temp[i]=azul oscuro
for i en rango(21,60):
temp[i]=rojo oscuro
for i en [0,10]:
temp[i]=azul claro
for i in [30,40,50]:
temp[i]=rojo claro
for i en rango(5 ,60,10):
temp[i]=magenta
temp[20]=verde
def fillAndShow(temperatura):
t=min(temperatura,maxTemp)
t=máx(minTemp,t)
maxpix = int(t) + pos0
for i en range(maxpix + 1):
np[i]=temp[i]
for i in range(maxpix + 1,numOfPix):
np[i]=de
if t < 0:
np [pos0]=gruen
np.escribir()
def clearStrip():
for i en rango(numOfPix):
np[i]=de
np.write()
def blinkRed():
global statered
if statered == 1:
np[numOfPix-1]=apagado
np.write()
iniciado = 0
else:
np [numOfPix-1]=rojo oscuro
np.escribir()
iniciado = 1
def blinkBlue():
global stateblue
if stateblue == 1:
np[0]=de
np.write()
stateblue = 0
else:
np[0]=azul claro
np.escribir()
stateblue = 1
def blinkGreen():
global stategreen
if stategreen == 1:
np[pos0]=de
np.write()
stategreen = 0
else:
np[pos0]=verde
np.escribir()
stategreen = 1
setScale ()
clearStrip()
while 1:
ds.convert_temp()
sleep(1)
t=int(ds.read_temp(dispositivo) + 0,5)
imprimir(t,«C»)
fillAndShow(t)
if t < minTemp:
blinkBlue()
if t > maxTemp:
blinkRed()
if t == 0:
blinkGreen()
Para independizarnos del PC y del USB, podemos cargar el programa con el nombre main.py en la memoria flash del controlador. Ahora basta con una alimentación de 5 V para que el programa se inicie automáticamente al reiniciar o después de un restablecimiento.
Así se ve la parte alrededor del cero en funcionamiento.
Ilustración 7: Indicador del termómetro de -6 °C a 2 °C
Perspectivas:
La elección del color de los LED nos deja algunas opciones abiertas. Por ejemplo, se podría conectar un segundo sensor para la temperatura exterior al bus de un solo cable y cambiar la pantalla cada cinco segundos. Utilizando colores diferentes para cada zona, se puede distinguir fácilmente entre la temperatura exterior y la interior.
Mediante el uso de un lector de tarjetas SD y un RTC, las mediciones se pueden registrar con precisión para su posterior evaluación.
Si utilizamos la capacidad WLAN de nuestros controladores, los datos de medición también se pueden transferir fácilmente a un teléfono móvil, una tableta o un servidor.
Disfruta investigando, creando y programando.
