El Raspberry Pi Pico es el primer microcontrolador de la fundación Raspberry Pi y viene con mucho que ofrecer por su tamaño. El procesador de doble núcleo Arm Cortex-M0+ RP2040 con 264KB de RAM interna le da a este microcontrolador la capacidad de manejar múltiples hilos a una increíble velocidad de reloj de hasta 133 MHz. La gran cantidad de pines GPIO seguramente será útil para aplicaciones de IoT donde muchos sensores se juntan.
Esta placa es programable con MicroPython y también es compatible con Arduino IDE. Por ahora, esta guía mostrará cómo conectar el Raspberry Pi Pico con el módulo WiFi ESP8266 para enviar y recibir datos.
En este artículo aprenderás cómo leer el valor del sensor de temperatura interno del Raspberry Pi Pico y enviarlo a Ubidots a través de TCP.
NOTA IMPORTANTE: Es muy importante saber que vamos a manejar dos códigos, uno para el registrador (Raspberry Pi Pico) y un segundo para la unidad de telemetría (ESP8266).
Requisitos
Raspberry Pi Pico
Módulo ESP8266 independiente
Dispositivo UART a USB
Cuenta activa de Ubidots
Tabla de contenido
1. Configuración de Thonny IDE
Un gran IDE para trabajar con Python y MicroPython es Thonny, ya que es intuitivo de usar y proporciona una serie de beneficios que aceleran tu codificación.
Para instalar y configurar Thonny IDE para Raspberry Pi, sigue estos pasos:
Primero necesitarás instalar el Thonny IDE.
Después de instalar, al abrir el IDE, aparecerá la siguiente ventana. Puedes elegir el idioma que deseas que tenga el IDE, pero asegúrate de dejar la "Configuración inicial:" establecida en Estándar.
Una vez que tengas el IDE abierto, para configurarlo para trabajar con el Raspberry Pi, ve a
Ejecutar > Seleccionar intérprete...
Después de eso, selecciona "MicroPython (Raspberry Pi Pico)" del menú desplegable.
Finalmente, selecciona el puerto donde tienes conectado tu Raspberry Pi Pico.
2. Configuración de Arduino IDE
Para el ESP8266 utilizaremos la biblioteca Ubidots ESP8266 Serial, que permite enviar cargas útiles TCP desde cualquier registrador de datos (en este caso el Raspberry Pi Pico) al módulo ESP8266 a través de serie.
1. Para poder trabajar con la plataforma ESP8266 en el Arduino IDE, necesitarás instalar la placa ESP8266 utilizando el Administrador de Placas preconfigurado de Arduino. Si no estás familiarizado con agregar una placa en el Arduino IDE, consulta este artículo para obtener orientación adicional.
2. Con la plataforma ESP8266 instalada, selecciona el dispositivo ESP8266 con el que estás trabajando. En este caso, estamos trabajando con un “Módulo ESP8266 Genérico”. Para seleccionar tu placa desde el Arduino IDE, selecciona Herramientas > Placa “Módulo ESP8266 Genérico”.
3. Descarga e instala el Ubidots ESP8266 Serial. Para una explicación detallada de cómo instalar bibliotecas utilizando el Arduino IDE, consulta esta guía.
3. Firmware de ESP8266
Para flashear el código en el ESP8266 necesitarás cualquier dispositivo UART a USB. Puedes usar un Arduino Mega (para más información consulta este artículo), un UartSBee, o un adaptador ESP8266 a USB como el siguiente:
Una vez que el módulo esté listo para flashear, configura tus credenciales de WiFi, tu Token de Ubidots y luego sube el siguiente código al ESP8266:
/**************************************** * Incluir bibliotecas ****************************************/#include "UbidotsESP8266.h"/**************************************** * Definir constantes ****************************************/namespace { const char * WIFISSID = "..."; // Asigna tu SSID de WiFi const char * PASSWORD = "..."; // Asigna tu contraseña de WiFi const char * TOKEN = "..."; // Asigna tu TOKEN de Ubidots}Ubidots client(TOKEN);/**************************************** * Funciones principales ****************************************/void setup() { Serial.begin(115200); client.wifiConnection(WIFISSID, PASSWORD);}void loop() { client.readData(); // Lee el comando del registrador delay(1000);}4. Configuración de hardware
Para hacer que tu Raspberry Pi Pico sea compatible con el entorno de MicroPython, sigue los pasos que se muestran en el sitio web de Raspberry para Comenzar con MicroPython.
Después de eso, la conexión entre el Raspberry Pi Pico y el ESP8266 es la siguiente:
Raspberry Pi Pico | ESP8266 |
3V3 | 3V3 |
GND | GND |
GP01 | RX |
GP02 | TX |
NOTA IMPORTANTE: Asegúrate de conectar el ESP8266 a 3.3V, ya que conectarlo a 5V podría dañar permanentemente el chip. Además, la distribución de pines para el ESP8266 puede ser diferente a la que se muestra en la imagen, así que verifica la documentación de tu marca.
5. Enviar datos a través de TCP
Para enviar datos a Ubidots utilizando TCP, utiliza el siguiente código. Simplemente cópialo y pégalo en tu ventana de Thonny IDE. Además, define las siguientes constantes;
Establece el user_agent (cualquier cadena aleatoria ascii, se recomienda 25 caracteres)
Asigna tu TOKEN de Ubidots
Agrega las variables y sus valores que se enviarán dentro del
variables_to_send dictionary
from machine import UART, Pinimport machineimport timeuart0 = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1)) # UART tx/rxprint('-- UART Serial --')print('>', end='')USER_AGENT = "UbidotsESP8266" # Asigna el user agentVERSION = "1.0" # Asigna la versiónTOKEN = "..." # Asigna tu TOKEN de UbidotsDEVICE_LABEL = "..." # Asigna la etiqueta del dispositivo#ejemplo de carga útil#init#USER_AGENT/VERSION|POST|TOKEN|DEVICE_LABEL:DEVICE_NAME=>VARIABLE:VALUE|end#final####### definición de función #######def temperatureC(): reading_temp = sensor_temp.read_u16() * conversion_factor temperature = 27 - (reading_temp - 0.706)/0.001721 return temperaturedef post_payload_builder(**variables): body = "" for key,value in variables.items(): body += f"{key}:{value}," body = body[:-1] payload = f"init#{USER_AGENT}/{VERSION}|POST|{TOKEN}|{DEVICE_LABEL}=>{body}|end#final" return payload def send_message(msg): uart0.write(msg) return def read_post_response(): rxData = bytes() while uart0.any() > 0: rxData += uart0.read(1) if len(rxData): rxData = rxData.decode('utf-8') print(f"Server response: {rxData}") return rxData else: return None####### configuración para leer la temperatura del sensor interno #######sensor_temp = machine.ADC(4)conversion_factor = 3.3 / (65535)####### código principal #######while True: #lectura de temperatura tempC = temperatureC() tempF = tempC * 9/5 + 32 #formato de variables_to_send = {<VAR_LABELZ>: VALUE,....} #ejemplo de variables_to_send = {"humidity": 34, "temperature": 54, "pressure": 23,....} variables_to_send = {"tempC":tempC, "tempF":tempF} payload = post_payload_builder(**variables_to_send) print(payload) print(f"Temperature read was: {tempC} °C ({tempF} °F)") send_message(payload) response = read_post_response() time.sleep(5)NOTA IMPORTANTE: Recuerda que este código debe sincronizarse con el código en el ESP8266, es decir, no puede tener una frecuencia de bucle mayor que la frecuencia de bucle del ESP8266.
Para guardar el código anterior en el Raspberry Pi Pico, ve a Archivo > Guardar como... y selecciona la opción para guardar el código en el Raspberry Pi Pico y no en la computadora.
NOTA IMPORTANTE: es crucial que nombres este código "main.py", ya que este es el archivo que el Raspberry Pi Pico intentará ejecutar una vez encendido.
Finalmente, una vez que ejecutes el código, puedes verificar nuestra cuenta de Ubidots para confirmar que los datos se están enviando correctamente. En este caso, hemos etiquetado este dispositivo como “rpi-pico” con dos variables etiquetadas como “tempC” y "tempF".
La carga útil enviada a Ubidots se muestra en la consola de Thonny. Esto es útil para fines de depuración.
6. Obtener el último valor de una variable a través de TCP
Para recuperar el último valor de una variable utilizando TCP, utiliza el siguiente código. Simplemente cópialo y pégalo en tu ventana de Thonny IDE. Además, define las siguientes constantes;
Establece el user_agent (cualquier cadena aleatoria ascii, se recomienda 25 caracteres)
Asigna tu TOKEN de Ubidots
Agrega la etiqueta de la variable para recuperar los datos de
from machine import UART, Pinimport machineimport timeuart0 = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1)) # UART tx/rxprint('-- UART Serial --')print('>', end='')USER_AGENT = "UbidotsESP8266" # Asigna el user agentVERSION = "1.0" # Asigna la versiónTOKEN = "..." # Asigna tu TOKEN de UbidotsDEVICE_LABEL = "..." # Asigna la etiqueta del dispositivo#ejemplo de carga útil#init#USER_AGENT/VERSION|LV|TOKEN|DEVICE_LABEL:variable_label|end#final####### definición de función #######def get_lv_payload_builder(variable_label): payload = f"init#{USER_AGENT}/{VERSION}|LV|{TOKEN}|{DEVICE_LABEL}:{variable_label}|end#final" return payload def send_message(msg): uart0.write(msg) return def read_get_response(): rxData = bytes() while uart0.any() > 0: rxData += uart0.read(1) if len(rxData): rxData = rxData.decode('utf-8') if rxData[:2] == "OK": # si los datos comienzan con "OK", entonces solo devuelve los caracteres después de "OK|" return rxData[3:] print(f"Server response: {rxData}") # si los datos no comienzan con "OK" entonces devuelve la respuesta completa return rxData else: return None####### código principal #######while True: get_command = get_lv_payload_builder("tempc") send_message(get_command) time.sleep (2) #permitir que la API responda y que el ESP8266 haga el bucle lv = read_get_response() print(lv) time.sleep(3)NOTA IMPORTANTE: es crucial que nombres este código "main.py", ya que este es el archivo que el Raspberry Pi Pico intentará ejecutar una vez encendido.
Desde la consola de Thonny, podemos verificar el valor que se está recuperando de la variable "tempc"
7. Resumen
Ahora hemos enviado y recuperado datos con éxito a Ubidots a través de TCP, es hora de aplicar este nuevo microcontrolador en aplicaciones de IoT donde se necesita alta potencia y un pequeño factor de forma.