¿Prefieres programar en Python? Si es así, Zerynth es un conjunto de herramientas de desarrollo profesional que admite el desarrollo de firmware en Python o híbrido C/Python para microcontroladores de 32 bits y las placas de prototipado más comunes: Arduino DUE, ST Nucleo, Particle Photon y Electron, Flip&Click, ESP32, ESP8266, y más.

En esta guía exploraremos el desarrollo de código en Python dentro de Zerynth Studio y cómo visualizar tus resultados utilizando la simplicidad de la visualización de datos de Ubidots.

Zerynth no es solo otra biblioteca de programación para kits de sensores asociados a Arduino. Zerynth es un conjunto de herramientas de desarrollo profesional desarrolladas desde cero para permitirte acceder al mundo embebido en solo unos pocos clics. Zerynth va más allá de los desarrolladores embebidos profesionales para ofrecer también a programadores web, diseñadores de productos e integradores de sistemas IoT un conjunto completo de herramientas de desarrollo de alta calidad para programar microcontroladores y desarrollar soluciones IoT.

Zerynth es compatible con múltiples placas y permite una rápida integración con sensores, actuadores y servicios en la nube, reduciendo el tiempo y esfuerzo de desarrollo del producto.

En la siguiente guía te presentaremos la plataforma Zerynth utilizando un ESP32 DevKitC conectado a la nube de Ubidots. Al finalizar esta guía, podrás visualizar los datos del sensor de tu placa en Ubidots y controlar un LED utilizando un código de muestra proporcionado.

Requisitos

Paso a Paso

Configuración de Zerynth
Enviando (POST) Datos a Ubidots
Recibiendo (GET) Datos de Ubidots
Resumen

1. Configuración de Zerynth

1. Descarga e instala el Zerynth Studio utilizando la guía de instalación para asistencia adicional si es necesario.

2. A continuación, continúa con la guía de Introducción prestando especial atención a la sección "Conectar, Registrar y Virtualizar tu Dispositivo".

Una vez que tu dispositivo esté correctamente virtualizado en Zerynth, estarás listo para continuar con esta guía.

Preguntas Frecuentes y Solución de Problemas: Para usuarios de Windows y Mac, si recibes errores al crear la Máquina Virtual, verifica que los últimos controladores estén instalados. Para usuarios de Linux, permite el acceso a los puertos seriales añadiendo el usuario al grupo y otorgando el acceso de lectura/escritura requerido:

Distribución Ubuntu –> grupo dialout
Distribución Arch Linux –> grupo uucp

2. Enviando (POST) Datos a Ubidots

1. Crea un nuevo Proyecto Zerynth. Para hacer esto, presiona Navegador de Proyectos –> Nuevo Proyecto y luego asigna el título del proyecto y la carpeta del proyecto. Para finalizar, presiona "Crear".

2. A continuación, tu nuevo Proyecto Zerynth se abrirá automáticamente en el archivo "main.py". Este main.py es donde se escribirá el código principal de Zerynth en Python o híbrido C/Python. Aquí es donde vamos a desarrollar la lógica de cualquier script.

4. Una vez que el proyecto esté correctamente creado, copia y pega el código de muestra proporcionado a continuación en el archivo "main.py". Después de pegar el código, asigna tu Ubidots TOKEN, y credenciales de WiFi donde se indica en el código.

Si no sabes cómo encontrar tu TOKEN de Ubidots, consulta el Centro de Ayuda de Ubidots.

NOTA DE DESPLIEGUE: En este código de muestra, la etiqueta del dispositivo se establece como "ESP32" y la etiqueta de la variable como "temperatura". Esto significa que tu solicitud se enviará con estos parámetros a Ubidots. Si deseas alterar este código de muestra, hazlo según sea necesario.

################################################################################# Ubidots POST ESP32DevKitC## Creado el 2017-10-09 22:15:06.348664# Autores: M. Hernandez################################################################################import streams  # importar streamsimport json     # importar jsonimport adc      # importar el módulo adcimport requests # importar el módulo httpfrom wireless import wifi # importar la interfaz wififrom espressif.esp32net import esp32wifi as wifi_driver # controlador de red para el módulo wifi# asignar parámetros de Ubidotsdevice_label = "esp32" # etiqueta del dispositivo Ubidotsvariable_label = "temperature" # etiqueta de la variable Ubidots token = "Ubidots_TOKEN_here" # TOKEN de ubidots# crear un flujo de puerto serie con parámetros predeterminadosstreams.serial()# definir el pin analógico (A0) para leer el valor inputAnalog = A0# establecer el pin como entrada con INPUT_ANALOG,pinMode(inputAnalog,INPUT_ANALOG)# inicializar el controlador wifiwifi_driver.auto_init()print("Estableciendo conexión...")try:    # cambiar el nombre de la red "ssid-name", seguridad y contraseña "ssid-pass" según sea necesario    wifi.link("ssid-name",wifi.WIFI_WPA2,"ssid-pass")    print("¡Conectado!")except Exception as e:    print("Algo salió mal durante la conexión. Verifica tus credenciales de WiFi", e)    while True:        sleep(1000)# construir el directorio JSON a ser enviadodef build_json(variable, value):    try:        data = {variable: {"value": value}}        return data    except:        return None# enviar la solicitud POST HTTP a Ubidots# referencia a la API REST de Ubidots para más información (https://ubidots.com/docs/api/)def post_var(device_label, variable_label, value, token):    # acceso a la API de Ubidots    url = "http://industrial.api.ubidots.com/api/v1.6/devices/" + device_label + "/?token=" + token    # datos a ser enviados    data = build_json(variable_label, value)    # envía la solicitud    response = requests.post(url, json=data)    # imprime el estado y el contenido de la solicitud    print("Estado Http:",response.status)    print("Contenido Http:",response.content)    print("---------------------------------")    return response    while True:    try:        # leer la entrada en el pin analógico 0        sensorValue = adc.read(inputAnalog)        # enviar la solicitud POST HTTP a Ubidots        print("Publicando variables a Ubidots")        post_var(device_label, variable_label, sensorValue, token)            except Exception as e:        print(e)    sleep(2000)

Este código de muestra realiza una solicitud POST HTTP a Ubidots actualizando una variable que contiene la lectura del pin analógico (A0) del ESP32 DevKitC. Para enviar más valores, utiliza tu referencia de dispositivo API REST de Ubidots para aprender cómo construir tus propias solicitudes HTTP.

5. Con el código pegado y actualizado con tus credenciales, debes a continuación verificar.
Para verificar, presiona el ícono de "marca de verificación" que se puede encontrar a continuación:

6. Una vez que el script esté correctamente verificado, es hora de Subir el script al ESP32DevKitC. Para subir el script, presiona el ícono de "flecha hacia arriba" que se encuentra a continuación:

Espera un par de segundos hasta que el script se suba a la placa. Una vez que la subida finalice, recibirás el mensaje "Subida completada" en el registro de terminal de Zerynth Studio.

7. Abre la consola para depurar el estado de la solicitud; presiona el ícono de "terminal" que se encuentra a continuación para abrir la consola:

Al principio, tu consola informará el estado de la conexión. Luego comenzarás a recibir el estado de la solicitud HTTP a Ubidots.

Preguntas Frecuentes y Solución de Problemas: Si abres la consola y no puedes visualizar los mensajes de depuración, presiona el botón de reinicio del ESP32 DevKitC para comenzar a recibir mensajes.

8. Ve a la sección Dispositivo de tu cuenta de Ubidots para verificar que el mensaje ha sido recibido:

3. Recibiendo (GET) Datos de Ubidots

1. Ve a la sección Dispositivo de tu cuenta de Ubidots y abre el dispositivo llamado "ESP32" creado en los pasos anteriores.

2. Crea una nueva Variable Cruda llamada "control" presionando "Agregar Variable"

3. Sigue el constructor de aplicaciones punto y clic en pantalla para poblar tus nuevas variables. Una vez que la variable esté creada, el panel de control de tu dispositivo debería verse como a continuación:

3. Ve a tu Panel de Control principal de Ubidots y crea un widget de control. Haz clic en el ícono amarillo más(+) y sigue las opciones en pantalla para desplegar nuevos widgets en el panel de control. Selecciona Control –> Interruptor –> ESP32 –> control(variable recién creada) –> Finalizar.

Después de construir tu nuevo widget, el Panel de Control se recargará y se poblará con tu nuevo widget.

Este widget "Interruptor" enviará su estado al ESP32DevKitC para controlar el estado de un LED.

4. Siguiendo los mismos pasos proporcionados en el paso anterior (Publicando valores a Ubidots), configura un nuevo proyecto en Zerynth y titula el proyecto a tu preferencia. Luego, copia y pega el script a continuación en el archivo "main.py" asignando tu TOKEN de Ubidots, y credenciales de WiFi en el camino.

################################################################################# Ubidots GET ESP32DevKitC## Creado el 2017-10-09 22:15:06.348664# Autores: M. Hernandez################################################################################import streams  # importar streamsimport json     # importar jsonimport adc      # importar el módulo adcimport requests # importar el módulo httpfrom wireless import wifi # importar la interfaz wifi# Controlador WiFi ESP32 (Sparkfun Esp32 Thing, Olimex Esp32, ...)from espressif.esp32net import esp32wifi as wifi_driver # controlador de red para el módulo wifi# asignar parámetros de ubidotsdevice_label = "esp32" # etiqueta del dispositivo ubidotsvariable_label = "control" # etiqueta de la variable ubidots token = "your_ubidots_TOKEN_here" # TOKEN de ubidots# crear un flujo de puerto serie con parámetros predeterminadosstreams.serial()# inicializar el controlador wifiwifi_driver.auto_init()# establecer el pin como SALIDApinMode(D3,OUTPUT)print("Estableciendo Conexión...")try:    # cambiar el nombre de la red "ssid-name", seguridad y contraseña "ssid-pass" según sea necesario    wifi.link("ssid-name",wifi.WIFI_WPA2,"ssid-pass")    print("Conectado")except Exception as e:    print("Algo salió mal durante la conexión. Verifica tus credenciales de WiFi", e)    while True:        sleep(1000)# enviar la solicitud GET HTTP a Ubidotsdef get_value(device_label, variable_label, token):    # acceso a la API de Ubidots    url = "http://industrial.api.ubidots.com/api/v1.6/devices/" + device_label + "/" + variable_label + "/lv?token=" + token    # envía la solicitud    response = requests.get(url)    # verifica el estado de la solicitud    if response.status != 200:        return None    print("---------------------------------")    print("Estado Http:",response.status)    # devuelve el último valor obtenido    return response.contentwhile True:    # obteniendo el último valor de Ubidots    last_value = get_value(device_label, variable_label, token)    # verifica si el último valor recibido no es 'None'    if last_value is not None:        last_value  = float(last_value) * 1.0        # control del led        if last_value >= 1.0:            print("LED ENCENDIDO")            digitalWrite(D3, HIGH)  # enciende el LED estableciendo el voltaje en ALTO        else:            print("LED APAGADO")            digitalWrite(D3, LOW)   # apaga el LED estableciendo el voltaje en BAJO    sleep(1500) # tiempo mínimo de sueño permitido

Este script de muestra controla un LED conectado al Pin D3 del ESP32DevKitC.

5. Una vez que los parámetros estén modificados, verifica y sube el script al ESP32DevKitC.

6. Cuando la subida finalice, abre la consola. Al principio, una vez que se abra la consola, recibirás el estado de conexión, luego comenzarás a recibir el estado de la solicitud HTTP a Ubidots y el estado del LED.

Preguntas Frecuentes y Solución de Problemas: Si abres la consola y no puedes visualizar los mensajes de depuración, presiona el botón de reinicio del ESP32 DevKitC para comenzar a recibir los mensajes.

7. Cambiar el estado del widget "Interruptor" desde tu Panel de Control de Ubidots resultará en el cambio de estado del LED en la consola y en la vida real:

4. Resumen

En solo unos minutos has realizado una solicitud HTTP a la nube de Ubidots utilizando código Python subido con Zerynth a un ESP32 DevKitC. Además, utilizando los códigos de muestra con cualquier microcontrolador de 32 bits compatible con Zerynth, puedes simplemente asignar el controlador WiFi adecuado basado en tu microcontrolador para prototipos y despliegues rápidos. Para información adicional sobre la plataforma de firmware Python de Zerynth, consulta la Documentación de Zerynth.

Ahora es el momento de reingenierizar este código para desplegar tus propias aplicaciones. Para aprender más sobre cómo crear widgets y eventos en Ubidots, consulta estos tutoriales en video.

Otros lectores también han encontrado útil...