Tutorial de componentes para principiantes de Raspberry Pi Pico W

Este tutorial de componentes para principiantes de Raspberry Pi Pico W le enseñará cómo interactuar con el microcontrolador para interactuar con componentes simples como LEDs, sensores ultrasónicos y muchos otros elementos que se encuentran en el kit de un principiante.

Si eres un completo principiante, este tutorial te ayudará a entender MicroPython para que puedas leer, escribir y modificar código. Con estos conocimientos, podrás combinar código y componentes para crear algo que tenga un caso de uso en el mundo real.

Si viene de un Pico, este tutorial le enseñará a controlar el Pico W de forma inalámbrica. Anteriormente, sólo se podía interactuar con el Pico a través de un interruptor, botón o algún dispositivo de interacción física. Ahora ya no. Ahora puede controlar los componentes con su teléfono o su ordenador de sobremesa.

Flujo tutorial

Introducción

1. Soldar pines de cabecera
2. Uso de Thonny
3. Actualización del firmware

El tutorial Hello World para el Pico W

1. Servir una página web que diga "Hola Mundo" en el Pico
2. Control inalámbrico de un LED

Un paso más

1. Control inalámbrico de LED RGB
2. Funcionamiento del zumbador en el Pico W

Formas básicas de transmitir datos desde un sensor

1. Sensor ultrasónico Pico W y HC-SR04
2. Transmitir una página web con los datos del sensor
3. Reducir la carga útil con AJAX
4. Pimoroni Phew agiliza la codificación de extremos

Conexión a servicios web

1. Registra los datos climáticos del sensor DHT22 en Google Sheets con IFTTT
2. Crea un mando a distancia para Spotify con funciones de reproducción, pausa y salto

Control GPIO sin código con PiCockpit

1. Instalación super sencilla de PiCockpit en Pico W
2. Control sencillo de LED con PiCockpit y Pico W
3. Pico W, ventilador de 5V y un transistor, controlado por PiCockpit

MQTT

1. Fotoresistencia de visualización mediante MQTT y Node-RED con Pico W

Índice

Resumen de los objetivos de la tutoría

• Aprender a interactuar con los componentes fundamentales que conforman proyectos de mayor envergadura.
• Controle todo esto de forma inalámbrica: sin interruptores, botones ni otros dispositivos de interacción.
• Conozca mejor los puntos fuertes de Pico W

Enlaces importantes

Repo de Github para el código del tutorial (excepto secrets.py)

Documentación sobre MicroPython

¿Errores, sugerencias, comentarios? Deja un comentario en la caja de comentarios de abajo, envíame un correo electrónico o Tweet.

OSError: [Errno 98] EADDRINUSE

Si obtiene este error, simplemente desconecte y conecte su Raspberry Pi Pico.

También puedes hacerlo escribiendo estos comandos en el Shell de Thonny:

import machine
machine.reset()

Resultado:

Soldar pines de cabecera

Cuando compras una Raspberry Pi Pico W, puede que no venga con cabezales que te permitan conectar componentes a tu Pico.

En el momento de escribir estas líneas, el Pico WH (H de cabecera) aún no ha salido al mercado. Nuestro megaartículo sobre el Pico W sigue de cerca su lanzamiento.

Sin embargo, si puedes encontrar un Pico W con cabezales pre-soldados, te aconsejo que lo compres.

Sin embargo, para el resto de nosotros, soldar cabezales en el Pico W es algo sencillo de hacer. Usted necesitará:

• Tablero de pruebas
• Soldador y soldadura
• Cabeceras

Cuando compres tus cabezales, asegúrate de comprar uno que sea para la Pico W. A diferencia de los cabezales para la serie Raspberry Pi Zero, los cabezales de la Pico W no están uno al lado del otro. Están en extremos opuestos de la placa.

Los pines tienen un lado largo y un lado corto. Querrás que los pines más largos estén en el lado donde ves las etiquetas GPIO (GP0, GP1, GND, VBUS, VSYS, etc.)

Por lo tanto, inserta las patillas más largas en la protoboard. Necesitarás cuatro agujeros y un espacio de un canalón entre ellos. Si no estás seguro, prueba con tu Pico W.

Soldar es fácil. Asegúrate de que el soldador está caliente y de utilizar la punta del soldador.

Lo que me resultó más eficaz fue acercar la punta del soldador a la patilla, hacer que la soldadura tocara la punta y ver cómo fluía por la patilla y creaba una conexión.

Después de soldar, asegúrate de que no hay ninguna soldadura extraña que pueda estar conectando dos pines GPIO o algún resto de soldadura sobrante en la placa.

Utiliza Thonny como editor de código

Thonny sigue siendo la forma más fácil de programar tu Raspberry Pi Pico W.

Si utilizas el sistema operativo Raspberry Pi, ya lo tendrás instalado.

Sin embargo, si utilizas Windows o Mac, tendrás que descargarlo y configurarlo.

Aquí tienes una guía que te guiará por los pasos a seguir.

Asegúrese también de consulte la guía sobre cómo cargar archivos en su Pico W.

Actualiza tu firmware cargando el último UF2

Cuando compraste tu Pico W, puede que ya tuvieras el firmware desactualizado.

Se avecinan muchos cambios en el Pico W, por lo que lo ideal es actualizar su firmware ahora.

Algunos cambios que he visto desde el día del lanzamiento son mejoras en la función de punto de acceso WLAN, y futuras actualizaciones podrían desbloquear la función Bluetooth en la placa.

¡Actualízate ya! Aquí hay una guía en nuestro mega-artículo.

1. Servir una página web que diga "Hola Mundo" en el Pico

Uno de los proyectos más fundamentales en todos los tutoriales de programación es el proyecto "Hello World".

El "Hola Mundo" de un microcontrolador suele consistir en el parpadeo de un LED. Es muy fácil. He aquí cómo.

Sin embargo, ya que el Pico W puede servir una página web, vamos a empezar por aprender a servir una página web que tiene un mensaje "Hola Mundo".

La configuración utilizada aquí constituirá la base fundamental para el resto de los tutoriales.

Hay dos formas de conectarse al Pico W. Puede hacer que se una a una red WiFi o puede emitir un punto de acceso SoftAP similar a lo que hace tu smartphone. Si quieres probar esto último, siga este enlace. Sin embargo, por coherencia a lo largo de este tutorial, siempre nos conectaremos a una red WiFi en lugar de emitir una desde el Pico W.

Así que, fundamentalmente, los pasos para servir una página web implican:

• Conectarse al WiFi
• Escribir código para servir index.html a cualquiera que se conecte a la dirección IP del Pico W.

Vamos a configurar algunos archivos. Guárdalos y cárgalos en tu Raspberry Pi Pico W. Aquí te explicamos cómo subir archivos, por si te lo perdiste.

wifi.py

wifi.py es un boilerplate destinado a ayudarte a conectarte a tu red WiFi. Crear un archivo separado e importarlo en main.py ayudará a reducir el código desordenado.

Tenga en cuenta que debe cambiar el código de su país en la línea rp2.country('DE') si su país no es Alemania.

import rp2
import network
import ubinascii
import machine
import urequests as requests
import time
from secrets import secrets


def init_wifi():
    # Set country to avoid possible errors
    rp2.country('DE')

    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)

    # Load login data from different file for safety reasons
    ssid = secrets['ssid']
    pw = secrets['pw']

    wlan.connect(ssid, pw)

    # Wait for connection with 10 second timeout
    timeout = 10
    while timeout > 0:
        if wlan.status() < 0 or wlan.status() >= 3:
            break
        timeout -= 1
        print('Waiting for connection...')
        time.sleep(1)

    # Define blinking function for onboard LED to indicate error codes    
    def blink_onboard_led(num_blinks):
        led = machine.Pin('LED', machine.Pin.OUT)
        for i in range(num_blinks):
            led.on()
            time.sleep(.2)
            led.off()
            time.sleep(.2)

    wlan_status = wlan.status()
    blink_onboard_led(wlan_status)

    if wlan_status != 3:
        raise RuntimeError('Wi-Fi connection failed')
    else:
        print('Connected')
        status = wlan.ifconfig()
        print('ip = ' + status[0])

secretos.py

wifi.py importaciones secretos.pydonde almacenas la información de tu red WiFi.

secretos.py es un simple archivo JSON que contiene tu SSID WiFi y contraseña.

secrets = {
    'ssid': 'SM-A520W9371',
    'pw': 'starting',
    }

serve_webpage.py

Como su nombre indica, esta página sirve sitios web a los usuarios que se conectan al Pico W.

Al recibir una conexión, el Pico W encuentra un archivo llamado index.html y lo envía al cliente conectado, como se ve en la línea response = get_html('index.html').

import socket

def serve_webpage():
    #Function to load in html page    
    def get_html(html_name):
        # open html_name (index.html), 'r' = read-only as variable 'file'
        with open(html_name, 'r') as file:
            html = file.read()
            
        return html

    # HTTP server with socket
    addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]

    s = socket.socket()
    s.bind(addr)
    s.listen(1)

    print('Listening on', addr)

    # Listen for connections
    while True:
        try:
            cl, addr = s.accept()
            print('Client connected from', addr)
            response = get_html('index.html')
            cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
            cl.send(response)
            cl.close()
            
        except OSError as e:
            cl.close()
            print('Connection closed')

Por último, tenemos que crear el index.html que se enviará a un cliente conectado.

<!DOCTYPE html>
<html>
    <head>
        <title>Pico W</title>
    </head>
    <body>
        <h1>Hello World</h1>
    </body>
</html>

Se trata de una simple plantilla HTML con dos cambios: uno en el elemento <title>que pone como título "Pico W" y la etiqueta <h1> que pone "Hola Mundo".

main.py

Como hemos colocado todo el código en otro lugar, nuestro main.py sólo tiene que importar y llamar a estas funciones para servir la página web Hola Mundo.

Como puedes ver, primero inicializamos WiFi antes de servir la página web.

from wifi import init_wifi
from serve_webpage import serve_webpage

init_wifi()
serve_webpage()

¡Ya casi está!

Refiriéndose a la captura de pantalla a continuación, asegúrese:

• Has cargado cinco archivos en tu Raspberry Pi Pico W (ver cuadro rojo abajo a la izquierda)
• Asegúrese de que su intérprete está configurado para MicroPython (Raspberry Pi Pico) (véase el recuadro inferior derecho)
• A continuación, resalte main.py en tu editor de código, y pulsa el botón verde de ejecutar (recuadro rojo superior izquierdo)
• Una vez que ejecutes esto, verás tu dirección IP en el Shell. Ve a tu navegador y escribe esta dirección y verás la página web Hello World.
• Si su Shell no está abierto, vaya a Ver -> Shell.

Si todo va bien, verá la página siguiente.

2. Control inalámbrico de un LED

Ahora que ya tienes lo básico, vamos a dar un paso más.

Uno de los proyectos más fundamentales de Raspberry Pi consiste en hacer parpadear un LED.

Subamos un peldaño más controlando el LED de forma inalámbrica. Queremos poder parpadear, encender y apagar el LED.

Para ello, tendrás que configurar un circuito y un servidor web con tres botones: ON, OFF, BLINK.

Para este proyecto necesitarás un LED, una resistencia de 330 ohmios, un cable de puente y una protoboard.

Utilizaremos un LED rojo porque la mayoría de los kits lo tienen. Ten en cuenta que si utilizas un LED de otro color, tendrás que ajustar la resistencia.

Así se conectan los componentes

• GPIO 2 -> Pata larga del LED (ánodo/positivo)
• GND -> resistencia de 330 ohm -> pata corta del LED (cátodo/negativo)

Código para controlar el LED de Pico W

Vamos a partir de lo que hicimos en el tutorial anterior. Los dos únicos archivos que tendremos que modificar son index.html para añadir botones y main.py para interactuar con el LED basándose en la entrada de index.html.

Las partes que aparecen en negrita indican las nuevas líneas que se han añadido a index.html. Añaden tres botones y un párrafo que dice "Controla el LED".

<!DOCTYPE html>
<html>
    <head>
        <title>Pico W</title>
    </head>
    <body>
        <h1>Pico W</h1>
        <p>Control the LED</p>
        <a href=\"?led=on\"><button>ON</button></a>&nbsp;
        <a href=\"?led=off\"><button>OFF</button></a>
        <a href=\"?led=blink\"><button>BLINK</button></a>
    </body>
</html>

Observe que al pulsar los botones, verá que se añade un parámetro a la dirección IP de su Pico W (p. ej. http://192.168.43.134/%22?led=blink\). Estos parámetros son capturados por el backend del Pico W y controla el LED.

Vamos a movernos serve_webpage.pyen el main.py archivo.

Aquí está main.py:

from wifi import init_wifi
import socket
import machine
import time

init_wifi()


#LED controls
led = machine.Pin(2, machine.Pin.OUT)
      
def blink_led():
    led.on()
    time.sleep(0.2)
    led.off()
    time.sleep(0.2)

#Function to load in html page    
def get_html(html_name):
    # open html_name (index.html), 'r' = read-only as variable 'file'
    with open(html_name, 'r') as file:
        html = file.read()
        
    return html

# HTTP server with socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]

s = socket.socket()
s.bind(addr)
s.listen(1)

print('Listening on', addr)

# Listen for connections
while True:
    try:
        cl, addr = s.accept()
        print('Client connected from', addr)
        request = cl.recv(1024)
        print(request)
        
        request = str(request)
        led_on = request.find('?led=on')
        led_off = request.find('?led=off')
        led_blink = request.find('?led=blink')
        print('led_on = ', led_on)
        print('led_off = ', led_off)
        print('led_blink = ', led_blink)
        if led_on > -1:
            print('LED ON')
            led.on()
            
        if led_off > -1:
            print('LED OFF')
            led.off()
            
        if led_blink > -1:
            print('LED BLINK')
            blink_led()
            
        response = get_html('index.html')
        cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
        cl.send(response)
        cl.close()
        
    except OSError as e:
        cl.close()
        print('Connection closed')

El primer segmento, y clave, está a continuación:

request = cl.recv(1024)
        print(request)
        
        request = str(request)
        led_on = request.find('?led=on')
        led_off = request.find('?led=off')
        led_blink = request.find('?led=blink')
        print('led_on = ', led_on)
        print('led_off = ', led_off)
        print('led_blink = ', led_blink)
        if led_on > -1:
            print('LED ON')
            led.on()
            
        if led_off > -1:
            print('LED OFF')
            led.off()
            
        if led_blink > -1:
            print('LED BLINK')
            blink_led()

La variable "request", cuando se imprime, produce el primer bloque de texto de abajo. Las tres últimas líneas son las sentencias de impresión que comprueban si el LED está encendido, apagado o parpadea:

b'GET /%22?led=blink\\%22 HTTP/1.1\r\nHost: 192.168.43.134\r\nConnection: keep-alive\r\nCache-Control: max-age=0\r\nUpgrade-Insecure-Requests: 1\r\nUser-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9\r\nReferer: http://192.168.43.134/%22?led=on\\%22\r\nAccept-Encoding: gzip, deflate\r\nAccept-Language: en-US,en;q=0.9,es;q=0.8,zh-TW;q=0.7,zh-CN;q=0.6,zh;q=0.5\r\n\r\n'
led_on =  456
led_off =  -1
led_blink =  10

El código anterior intentará buscar cadenas específicas como "led=encendido". Si existe, el valor será superior a -1, por lo que se activará el correspondiente si declaración.

Por ejemplo, si led=on existe en los parámetros, entonces la variable led_on será mayor que -1, por lo tanto el si led_on > -1 desencadena y ejecuta led.on();

Lo único complicado aquí es el led_blink que activará la función:

    def blink_led():
        led.on()
        time.sleep(0.2)
        led.off()
        time.sleep(0.2)

Finalmente, así es como se inicializa el GPIO 2 para operar el LED:

import machine
import time
    
#LED controls
led = machine.Pin(2, machine.Pin.OUT)

Importamos la máquina para interactuar con el pin GPIO. Como puedes ver en la variable ledqueremos que el Pico W alimente el GPIO 2.

Importamos tiempo para que podamos tener una pausa de 0,2 segundos en blink_led().

3. LED RGB en Pico W

Para encender tu LED RGB, necesitas:

• Tres resistencias de 330 ohmios
• Un LED RGB
• Un cable de puente

En el LED RGB encontrarás cuatro patas. Una de ellas será la más larga. Es el cátodo (negativo) o el ánodo (positivo). Mi LED RGB tenía un cátodo compartido así que aquí está la conexión:

• GPIO 15 -> resistencia de 330 ohmios -> LED rojo
• GPIO 17 -> resistencia -> LED verde
• GPIO 16 -> resistencia -> LED azul

Aquí tienes un código para ver si lo has cableado bien:

import machine

red_led = machine.PWM(machine.Pin(15))
green_led = machine.PWM(machine.Pin(17))
blue_led = machine.PWM(machine.Pin(16))

red_led.duty_u16(65534)
green_led.duty_u16(65534)
blue_led.duty_u16(65534)

En este ejemplo, estamos utilizando PWM, que permite variar el brillo de los LEDs R, G, B.

Puede cambiar los valores pasados a [color].duty_u16 a un valor entre 0 y 65534. Teóricamente, deberías poder pasar 65535, pero de alguna manera eso no parece funcionar para mí.

Piensa que si le pasas "0" quieres un cero por ciento de brillo. Si le pasas 65534, quieres un 100% de brillo.

Si haces 65534 para un color y cero para el resto, podrás saber si has conectado los pines GPIO correctos al color de LED correcto.

¿Por qué usamos PWM? Porque te ayudará a obtener más colores. Si sólo utilizas un método de "encendido y apagado", puedes obtener luz roja, verde, azul, blanquecina y ninguna luz. Con PWM, puedes variar la intensidad del LED R, G, B y crear tantos colores como puedas imaginar.

Ahora, ¡a crear algo que puedas controlar de forma inalámbrica!

index.html

El principal cambio aquí es tener un <form> que tiene tres deslizadores. Estos deslizadores tienen un valor entre cero y 100.

El uso de valores de cero a 100 ayuda a visualizar el brillo como un porcentaje. También reduce la cantidad de código necesario para analizar el valor de los parámetros (visto más adelante en main.py)

Cuando haya configurado los valores para los LED R, G, B, pulse enviar, y estos datos serán capturados por el Pico W.

<!DOCTYPE html>
<html>
    <head>
        <title>Pico W</title>
    </head>
      <body>
        <h1>Pico W RGB LED</h1>
        <form id="form">
            
            <input type="range" min="0" max="100" value="slider_value" name="red" id="red">
            <label for="red">R</p>
            
            <input type="range" min="0" max="100" value="slider_value" name="green" id="green">
             <label for="green">G</p>
            
            <input type="range" min="0" max="100" value="slider_value" name="blue" id="blue">
            <label for="blue">B</p>
            
            <input type="submit" id="submit">
        </form>
        <script>
        
            submit.addEventListener('click', function ()  {
                form.submit();
            }, false);
        
        </script>
</html>

main.py

from wifi import init_wifi
import socket
import machine
import time

init_wifi()

#LED controls
red_led = machine.PWM(machine.Pin(15))
green_led = machine.PWM(machine.Pin(17))
blue_led = machine.PWM(machine.Pin(16))

#Function to load in html page    
def get_html(html_name):
    # open html_name (index.html), 'r' = read-only as variable 'file'
    with open(html_name, 'r') as file:
        html = file.read()
    return html

def find_intensity(color, request_str):
    index = request_str.find(color) + len(color)
    offset = 0
    if request_str[index].isdigit():
        offset = 1
        if request_str[index+1].isdigit():
            offset = 2
            if request_str[index+2].isdigit():
                offset = 3

    intensity = int(request_str[index:index+offset])
    return intensity
    
    
# HTTP server with socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]

s = socket.socket()
s.bind(addr)
s.listen(1)

print('Listening on', addr)

# Listen for connections
while True:
    try:
        cl, addr = s.accept()
        print('Client connected from', addr)
        request = cl.recv(1024)
        
        request_str = str(request)
       
        #find intensity ONLY if the params exist in request
        if request_str.find('red') > -1 :
            #int = get rid of decimal
            #/100*65534 = find_intensity returns something 0 to 100,
            # so x/100 = proportion of 65534 that you want to send to LED
            # 65534 = max number you can use for PWM
            red_intensity = int(find_intensity('red=', request_str) /100 * 65534)
            green_intensity = int(find_intensity('green=', request_str) /100 * 65534)
            blue_intensity = int(find_intensity('blue=', request_str) /100 * 65534)
            
            #print('r=' + str(red_intensity))
            #print('g=' + str(green_intensity))
            #print('b=' + str(blue_intensity))
            
            red_led.duty_u16(red_intensity)
            green_led.duty_u16(green_intensity)
            blue_led.duty_u16(blue_intensity)
                        
        response = get_html('index.html')
        cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
        cl.send(response)
        cl.close()
        
    except OSError as e:
        cl.close()
        print('Connection closed')

Al pulsar enviar en el botón index.html página web, el Pico W tomará los parámetros y los procesará.

Veamos algunos puntos clave del código, en negrita en el bloque de código anterior.

función encontrar_intensidad

Esta función recibe dos parámetros: color y cadena_solicitud. color toma "rojo", "verde" o "azul" y encuentra el valor después del signo igual (=).

Por ejemplo, su URL después de enviar el formulario es "http://192.168.1.142/?red=89&green=50&blue=50".

Si pasa "rojo" a find_intensity, devolverá 89.

analizador sintáctico de intensidad

El segundo bloque de código en negrita representa el código que indica al GPIO del Pico W cuánto brillo quieres para cada LED.

En primer lugar, debemos asegurarnos de que los parámetros existen en la URL. Esto se hace mediante la función si declaración request_str.find('red') > -1. Acabo de usar rojo porque los parámetros 100% contendrán la cadena 'red' si utiliza el formulario.

Si está visitando la dirección IP de su Pico W (por ejemplo, http://192.168.1.142/) por primera vez, no tendrá los parámetros, por lo que el programa se bloqueará si ejecuta encontrar_intensidad.

Si existen params, encontramos la intensidad para cada LED según los valores enviados. Veamos intensidad_roja.

red_intensity = int(find_intensity('red=', request_str) /100 * 65534)
...
red_led.duty_u16(red_intensity)

encontrar_intensidad devuelve un entero de cero a 100. Lo dividimos por 100 para obtener un porcentaje. Este porcentaje divide el valor máximo que el duty_u16 método puede tomar.

Sin embargo, necesitamos un int para envolver esto porque a veces se puede obtener un flotador y duty_u16 necesita un int. Por ejemplo, digamos que quieres 41% de brillo - 41% de 65534 es 26.868,94. Usted no puede pasar este flotador como el programa se bloqueará.

4. Funcionamiento del zumbador en el Pico W

Un zumbador es un componente bastante importante para las notificaciones básicas, al igual que un LED puede informarte sobre el estado de algo, un zumbador te da una notificación auditiva.

En lugar de implementar mi propio código, he optado por utilizar Aplicación de Giuseppe Cassibba. Si ejecutó su código en el Pico W, oirá pitidos en su zumbador.

Pero como este código está pensado para el Pico, no tendrá ninguna función de interactividad inalámbrica.

Así que, ¡a sacar el tenedor!

En primer lugar, modifiquemos el index.html para implementar los botones. Vamos a tener un botón para "ON", "OFF", "ESCALA", "MÚSICA".

Los dos primeros botones se explican por sí solos. El tercer botón reproduce una escala de Do y el último, una pieza musical.

<!DOCTYPE html>
<html>
    <head>
        <title>Pico W</title>
    </head>
    <body>
        <h1>Pico W Buzzer</h1>
        <p>Control the buzzer</p>
        <a href=\"?buzzer=on\"><button>ON</button></a>&nbsp;
        <a href=\"?buzzer=off\"><button>OFF</button></a>
        <a href=\"?buzzer=scale\"><button>SCALE</button></a>
        <a href=\"?buzzer=music\"><button>MUSIC</button></a>
    </body>
</html>

Al igual que antes, creamos unos <button> etiquetas con <a> que los rodean. Al hacer clic en los botones, la URL tendrá un parámetro como /buzzer=on. El Pico W lo lee y enciende el zumbador.

Ahora, veamos el código de Giuseppe para el Pico:

from machine import Pin, PWM
from time import sleep

buzzerPIN=16
BuzzerObj=PWM(Pin(buzzerPIN))

def buzzer(buzzerPinObject,frequency,sound_duration,silence_duration):
    # Set duty cycle to a positive value to emit sound from buzzer
    buzzerPinObject.duty_u16(int(65536*0.2))
    # Set frequency
    buzzerPinObject.freq(frequency)
    # wait for sound duration
    sleep(sound_duration)
    # Set duty cycle to zero to stop sound
    buzzerPinObject.duty_u16(int(65536*0))
    # Wait for sound interrumption, if needed 
    sleep(silence_duration)


# Play following notes by changing frequency:
#C (DO)
buzzer(BuzzerObj,523,0.5,0.1)

#D (RE)
buzzer(BuzzerObj,587,0.5,0.1)

#E (MI)
buzzer(BuzzerObj,659,0.5,0.1)

#F (FA)
buzzer(BuzzerObj,698,0.5,0.1)

#G (SOL)
buzzer(BuzzerObj,784,0.5,0.1)

#A (LA)
buzzer(BuzzerObj,880,0.5,0.1)

#B (SI)
buzzer(BuzzerObj,987,0.5,0.1)

#Deactivates the buzzer
BuzzerObj.deinit()

Su código reproduce una escala C cuando se ejecuta utilizando la función zumbador()que recibe cuatro parámetros: Objeto zumbador, frecuencia en hercios, duración del sonido y duración de la pausa antes de reproducir el siguiente sonido.

Modifiquemos el código para poder activar la función ON, OFF, ESCALA y MÚSICA.

Así es como integramos el código de Giuseppe en nuestro main.py:

from wifi import init_wifi
import socket
import machine
import time

init_wifi()

# Buzzer
buzzerPIN = 16
BuzzerObj = machine.PWM(machine.Pin(buzzerPIN))


def buzzer(buzzerPinObject, frequency, sound_duration, silence_duration):
    # Set duty cycle to a positive value to emit sound from buzzer
    buzzerPinObject.duty_u16(int(65536*0.2))
    # Set frequency
    buzzerPinObject.freq(frequency)
    # wait for sound duration
    time.sleep(sound_duration)
    # Set duty cycle to zero to stop sound
    buzzerPinObject.duty_u16(int(65536*0))
    # Wait for sound interrumption, if needed
    time.sleep(silence_duration)

# Function to load in html page


def get_html(html_name):
    # open html_name (index.html), 'r' = read-only as variable 'file'
    with open(html_name, 'r') as file:
        html = file.read()

    return html


# HTTP server with socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]

s = socket.socket()
s.bind(addr)
s.listen(1)

print('Listening on', addr)

# Listen for connections
while True:
    try:
        cl, addr = s.accept()
        print('Client connected from', addr)
        request = cl.recv(1024)

        request = str(request)
        buzzer_on = request.find('?buzzer=on')
        buzzer_off = request.find('?buzzer=off')
        buzzer_scale = request.find('?buzzer=scale')
        buzzer_music = request.find('?buzzer=music')

        if buzzer_on > -1:
            BuzzerObj.duty_u16(int(65536*0.2))
            BuzzerObj.freq(440)

        if buzzer_off > -1:
            BuzzerObj.duty_u16(0)

        if buzzer_scale > -1:
            #C (DO)
            buzzer(BuzzerObj, 523, 0.5, 0.1)

            #D (RE)
            buzzer(BuzzerObj, 587, 0.5, 0.1)

            #E (MI)
            buzzer(BuzzerObj, 659, 0.5, 0.1)

            #F (FA)
            buzzer(BuzzerObj, 698, 0.5, 0.1)

            #G (SOL)
            buzzer(BuzzerObj, 784, 0.5, 0.1)

            #A (LA)
            buzzer(BuzzerObj, 880, 0.5, 0.1)

            #B (SI)
            buzzer(BuzzerObj, 987, 0.5, 0.1)

            BuzzerObj.deinit()

        if buzzer_music > -1:
            pass

        response = get_html('index.html')
        cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
        cl.send(response)
        cl.close()

    except OSError as e:
        cl.close()
        print('Connection closed')

En la implementación anterior, no hemos escrito el código para MÚSICA.

El código es muy similar al tutorial del LED rojo anterior, donde el Pico W captura los parámetros después de la dirección IP del Pico W. Si el param buzzer=ON, reproducirá un sonido de 440 Hz. Si buzzer=escalareproducirá la escala extraída del código de Giuseppe.

¿Qué pasa con la implementación de la música? Implementar música es un poco más complicado, así que deberíamos crear un nuevo archivo llamado constantes.py y añadir unas líneas en nuestro main.py.

Este código es una bifurcación de Código Arduino de Rowan Packard.

constantes.py

A3F = 208  # 208 Hz
B3F = 233  # 233 Hz
B3 = 247  # 247 Hz
C4 = 261  # 261 Hz MIDDLE C
C4S = 277  # 277 Hz
E4F = 311  # 311 Hz
F4 = 349  # 349 Hz
A4F = 415  # 415 Hz
B4F = 466  # 466 Hz
B4 = 493  # 493 Hz
C5 = 523  # 523 Hz
C5S = 554  # 554 Hz
E5F = 622  # 622 Hz
F5 = 698  # 698 Hz
F5S = 740  # 740 Hz
A5F = 831  # 831 Hz

main.py (añadidos en negrita)

from wifi import init_wifi
import socket
import machine
import time
from constants import *

init_wifi()

# Buzzer
buzzerPIN = 16
BuzzerObj = machine.PWM(machine.Pin(buzzerPIN))


def buzzer(buzzerPinObject, frequency, sound_duration, silence_duration):
    # Set duty cycle to a positive value to emit sound from buzzer
    buzzerPinObject.duty_u16(int(65536*0.2))
    # Set frequency
    buzzerPinObject.freq(frequency)
    # wait for sound duration
    time.sleep(sound_duration)
    # Set duty cycle to zero to stop sound
    buzzerPinObject.duty_u16(int(65536*0))
    # Wait for sound interrumption, if needed
    time.sleep(silence_duration)

# Function to load in html page


def get_html(html_name):
    # open html_name (index.html), 'r' = read-only as variable 'file'
    with open(html_name, 'r') as file:
        html = file.read()

    return html


# HTTP server with socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]

s = socket.socket()
s.bind(addr)
s.listen(1)

print('Listening on', addr)

# Listen for connections
while True:
    try:
        cl, addr = s.accept()
        print('Client connected from', addr)
        request = cl.recv(1024)

        request = str(request)
        buzzer_on = request.find('?buzzer=on')
        buzzer_off = request.find('?buzzer=off')
        buzzer_scale = request.find('?buzzer=scale')
        buzzer_music = request.find('?buzzer=music')

        if buzzer_on > -1:
            BuzzerObj.duty_u16(int(65536*0.2))
            BuzzerObj.freq(440)

        if buzzer_off > -1:
            BuzzerObj.duty_u16(0)

        if buzzer_scale > -1:
            #C (DO)
            buzzer(BuzzerObj, 523, 0.5, 0.1)

            #D (RE)
            buzzer(BuzzerObj, 587, 0.5, 0.1)

            #E (MI)
            buzzer(BuzzerObj, 659, 0.5, 0.1)

            #F (FA)
            buzzer(BuzzerObj, 698, 0.5, 0.1)

            #G (SOL)
            buzzer(BuzzerObj, 784, 0.5, 0.1)

            #A (LA)
            buzzer(BuzzerObj, 880, 0.5, 0.1)

            #B (SI)
            buzzer(BuzzerObj, 987, 0.5, 0.1)

            BuzzerObj.deinit()

        if buzzer_music > -1:
            pause = 0.05
            # pauses between notes
            t = 0.125
            # time that music note plays

            music_notes = [B4F, B4F, A4F, A4F,
                           F5, F5, E5F, B4F, B4F, A4F, A4F, E5F, E5F, C5S, C5, B4F,
                           C5S, C5S, C5S, C5S,
                           C5S, E5F, C5, B4F, A4F, A4F, A4F, E5F, C5S,
                           B4F, B4F, A4F, A4F,
                           F5, F5, E5F, B4F, B4F, A4F, A4F, A5F, C5, C5S, C5, B4F,
                           C5S, C5S, C5S, C5S,
                           C5S, E5F, C5, B4F, A4F, A4F, A4F, E5F, C5S, C5S]

            rhythm = [1, 1, 1, 1,
                      3, 3, 6, 1, 1, 1, 1, 3, 3, 3, 1, 2,
                      1, 1, 1, 1,
                      3, 3, 3, 1, 2, 2, 2, 4, 8,
                      1, 1, 1, 1,
                      3, 3, 6, 1, 1, 1, 1, 3, 3, 3, 1, 2,
                      1, 1, 1, 1,
                      3, 3, 3, 1, 2, 2, 2, 4, 8, 4]

            for i in range(len(music_notes)):
                buzzer(BuzzerObj, music_notes[i], rhythm[i]*t, pause)

        response = get_html('index.html')
        cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
        cl.send(response)
        cl.close()

    except OSError as e:
        cl.close()
        print('Connection closed')

Como puede ver, hay dos matrices, notas_musicales y ritmo. A continuación, se ejecutaría un bucle for para introducir estos valores en el campo zumbador() función. Además, en la parte superior del código, importamos todas las variables de constantes.py.

El zumbador() también utiliza dos nuevas variables - t y pausa. Estas dos variables te ayudan a afinar el tempo de la música. t define la duración de cada nota y pausa define la duración del silencio entre las notas.

5. Sensor ultrasónico Pico W y HC-SR04

En los tutoriales anteriores, hemos estado utilizando el Pico W para enviar comandos a los LEDs y zumbadores.

Pero, ¿y si utilizamos el Pico W para recibir información?

En este caso, hablamos del sensor de distancia ultrasónico HC-SR04.

Cuando conectes tu sensor ultrasónico, asegúrate de saber si es un componente de 5V o de 3,3V. Enchufé mi versión de 5V en el pin de 3,3V y no obtuve respuesta del programa, que compartiré a continuación. Una vez que moví la fuente de alimentación al pin de 5V, inmediatamente obtuve una respuesta.

Aparentemente, algunas versiones más recientes del HC-SR04 pueden aceptar tanto 3,3V como 5V. Quizás lo mejor sea probar primero con el pin de 3,3V y ver si obtienes algún resultado. Si no, prueba con el de 5V.

Aquí tienes el esquema y el programa que puedes ejecutar en Thonny. Si obtienes respuesta, significa que has enchufado todo correctamente, incluido el voltaje.

Cableado

El cableado de los pines etiquetados de los sensores HC-SR04 es el siguiente:

• VCC a clavija de 3,3 V o 5 V (en caso de duda, pruebe primero con 3,3 V)
• TRIG a GPIO 16
• ECHO a GPIO 15
• GND a GND

Programa de pruebas para HC-SR04

Para comprobar si su cableado es correcto, pruebe este código que imprimirá la distancia en el Thonny Shell.

from machine import Pin
import time
trigger = Pin(16, Pin.OUT)
echo = Pin(15, Pin.IN)
def ultrasonic():
   trigger.low()
   time.sleep_us(1)
   trigger.high()
   time.sleep_us(10)
   trigger.low()
   while echo.value() == 0:
       signaloff = time.ticks_us()
   while echo.value() == 1:
       signalon = time.ticks_us()
   timepassed = signalon - signaloff
   distance = (timepassed * 0.0340) / 2
   print("Distance = ",distance,"cm")
while True:
   ultrasonic()
   time.sleep(1)

Su salida debe ser:

Distance =  9.707001 cm
Distance =  9.707001 cm
Distance =  8.619 cm
Distance =  8.415001 cm
Distance =  8.551001 cm
Distance =  8.551001 cm
Distance =  8.619 cm

Si el programa se ejecuta y se cierra sin ninguna salida, es probable que algo esté mal conectado. Cuando conecté el sensor a un pin de 3.3V en lugar de 5V, el programa se detuvo sin respuesta.

Obtención de datos enviados al navegador

Vamos a montar los archivos que utilizamos para servir una página web y modificarlos para que podamos ver los valores de distancia.

Aquí está el código final:

main.py

from wifi import init_wifi
import socket
from machine import Pin
import time

init_wifi()

# ultrasonic sensor pins and functions
trigger = Pin(16, Pin.OUT)
echo = Pin(15, Pin.IN)


def ultrasonic():
    trigger.low()
    time.sleep_us(1)
    trigger.high()
    time.sleep_us(10)
    trigger.low()
    while echo.value() == 0:
        signaloff = time.ticks_us()
    while echo.value() == 1:
        signalon = time.ticks_us()
    timepassed = signalon - signaloff
    distance = (timepassed * 0.0340) / 2
    return distance

# Function to load in html page

def get_html(html_name, distance):
    # open html_name (index.html), 'r' = read-only as variable 'file'
    with open(html_name, 'r') as file:
        html = file.read()
    content = html.replace(
        "<h2 id=\"ultrasonic\"></h2>", f"<h2 id=\"ultrasonic\">{distance}cm</h2>")

    return content


# HTTP server with socket
addr = socket.getaddrinfo('0.0.0.0', 80)[0][-1]

s = socket.socket()
s.bind(addr)
s.listen(1)

print('Listening on', addr)

# Listen for connections
while True:
    try:
        cl, addr = s.accept()
        print('Client connected from', addr)
        request = cl.recv(1024)
        print(ultrasonic())
        response = get_html('index.html', ultrasonic())
        cl.send('HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n')
        cl.send(response)
        cl.close()

    except OSError as e:
        cl.close()
        print('Connection closed')

index.html

<!DOCTYPE html>
<html>
    <head>
        <title>Pico W</title>
    </head>
      <body>
        <h1>Pico W Ultrasonic Distance</h1>
        <h2 id="ultrasonic"></h2>
        <script>
            setInterval(() => location.reload(), 500)
        </script>
</html>

Veamos algunos fragmentos del código para entender lo que ocurre.

Código para obtener la distancia ultrasónica

def ultrasonic():
    trigger.low()
    time.sleep_us(1)
    trigger.high()
    time.sleep_us(10)
    trigger.low()
    while echo.value() == 0:
        signaloff = time.ticks_us()
    while echo.value() == 1:
        signalon = time.ticks_us()
    timepassed = signalon - signaloff
    distance = (timepassed * 0.0340) / 2
    return distance

El bloque de código anterior activa la emisión de una onda ultrasónica. La dirección time.sleep entre los mínimos y los máximos son necesarios para el funcionamiento del sensor ultrasónico.

Para medir el tiempo que transcurre entre la emisión de la onda ultrasónica y el tiempo de retorno de la onda sonora, utilizamos tiempo.ticks_us para medir el tiempo de emisión y el tiempo de detección del eco.

tiempo.ticks_us es un número arbitrario, por lo que tendremos que restar signalon de signalaloff para que pase el tiempo.

Para obtener la distancia, utilizamos la fórmula distancia = (tiempo transcurrido * velocidad del sonido) / 2. La velocidad del sonido es de 340 m/s, lo que equivale a 0,0340.

La razón por la que tenemos que dividirlo por dos es porque la onda sonora viaja hasta el objeto y vuelve.

Código para servir página web con valor de distancia

def get_html(html_name, distance):
    # open html_name (index.html), 'r' = read-only as variable 'file'
    with open(html_name, 'r') as file:
        html = file.read()
    content = html.replace(
        "<h2 id=\"ultrasonic\"></h2>", f"<h2 id=\"ultrasonic\">{distance}cm</h2>")

    return content

...

response = get_html('index.html', ultrasonic())

Esta función se ha modificado un poco con respecto a los tutoriales anteriores, incorporando un parámetro adicional distanciaque se ejecuta ultrasónico().

La función abre el index.html normalmente, sino que utiliza el sustituir para encontrar el <h2> e inserta el distancia variable.

index.html hace un ping al servidor cada 500ms para obtener el nuevo valor

La página web principal recibe una función que recarga la página web cada 500ms. Cada recarga hace un ping al Pico W para obtener el nuevo valor de distancia ultrasónica.

    <script>
            setInterval(() => location.reload(), 500)
        </script>

6. Datos ultrasónicos, pero usemos AJAX para reducir la carga útil

El tutorial anterior funciona haciendo que la Raspberry Pi Pico W envíe un nuevo index.html cada vez que haya una conexión.

Esto funciona, pero es increíblemente ineficiente porque todo el index.html cuando sólo es necesario actualizar los datos de la distancia ultrasónica.

Queremos obtener los mismos resultados que en el tutorial anterior, pero sin la pesada carga del método anterior.

Por lo tanto, tenemos que hacer que el cliente (su teléfono o PC) haga ping a un punto final que responderá sólo con los datos ultrasónicos.

La nueva metodología es la siguiente: si la gente visita la URL raíz, por ejemplo 192.168.1.119, se les servirá la URL index.html.

index.html tendrá JavaScript que hace ping al /datos que activa el Pico W para obtener datos de distancia ultrasónica y responder con ellos.

Entonces, index.html recibirá estos datos y actualizará la página web.

Empalmar la solicitud del cliente

Recuerde que en el main.pysiempre hay una línea que dice peticiones = cl.recv(1024). El objeto de solicitud tiene un aspecto similar al siguiente:

b'GET /data HTTP/1.1
Host: 192.168.1.119
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://192.168.1.119/data
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9,es;q=0.8,zh-TW;q=0.7,zh-CN;q=0.6,zh;q=0.5

En primer lugar, tenemos que filtrar este muro de texto.

Utilizamos el encontrar() para averiguar si el solicitar variable tiene "/data". Si lo tiene, responde con los datos de la distancia ultrasónica. Si no tiene "/data", responde con index.html.

request = cl.recv(1024)
        print(ultrasonic())
        response = get_html('index.html', ultrasonic())

 request = cl.recv(1024)
        request = str(request)
        print (request.find('/data'))
        if (request.find('/data') > -1):
            #if string is found, respond with data.
            response = str(ultrasonic())
        else:
            response = get_html('index.html', ultrasonic())

Si ha visitado /data en su navegador, verá impreso el valor de la distancia, como se muestra a continuación.

Antes, el backend se encargaba de casi todo. La distancia ultrasónica se modificó antes de que se sirviera como index.html.

Ahora, index.html está obteniendo los datos del sensor de Pico W, por lo que tendríamos que hacer algunos cambios en el JavaScript que está dentro del archivo HTML. Los cambios están resaltados en negrita.

<!DOCTYPE html>
<html>
    <head>
        <title>Pico W</title>
    </head>
      <body>
        <h1>Pico W Ultrasonic Distance</h1>
        <h2 id="ultrasonic"></h2>
        <script>
            //instead of hardcoding, use address which browser accessed Pico W.
            const PicoAddress = window.location.href

            const getData = async () => {
                //there is a slash at the end of PicoAddress, so don't use "/data". use "data"
                const data = await fetch(`${PicoAddress}data`);
                //response is just a string, so use data.text() to decode the Response's body
                const distance = await data.text();
                //target ultrasonic id and change its inner HTML
                ultrasonic.innerHTML = `${distance} cm`;
                //run getData() again.
                setInterval(getData,100)
                //you can run getData() but it seems more optimized if you give it some time to breathe
            };

            getData();
           
        </script>
</html>

El elemento central del código es Obtener API y el último async/await sintaxis aquí.

La función getData() hace un ping al punto final /data del Pico W, y el Pico W responde. Nos aseguramos de que el programa no salta antes de obtener una respuesta completa pidiéndole que await.

Fetch se convierte en un objeto Response que necesitará utilizar el método Response.text() para llegar al cuerpo de la respuesta. De ahí las líneas const distancia = await datos.texto();

Una vez que tenemos los datos ultrasónicos, cambiamos el <h2 id="”ultrasonic”"> HTML interno del elemento, que comienza vacío, con los datos de la distancia. Puede apuntar a un elemento con un id directamente sin utilizar el getElementById() o querySelector() métodos.

Una vez que todo el código está hecho, queremos ejecutar getData() de nuevo. ¿Por qué he utilizado un setInterval ¿para fijar un intervalo de 100 ms?

Lo que he encontrado es que si se llama getData() sin un intervalo, obtendrá más pausas entre las salidas. Obtendrá una secuencia de actualizaciones rápidas, luego una pausa. Con el respiro de 100ms, el Pico W funciona un poco mejor y las actualizaciones parecen más o menos en tiempo real todavía.

Si quiere entender lo que ocurre bajo el capó, consulte la página Documentación sobre la API Fetch y el async/await documentación.

7. Pimoroni Uf por un código más limpio

En la última sección, cubrimos el método AJAX para actualizar los datos del sensor ultrasónico.

Pero, ¿hay una forma aún mejor de hacerlo?

Pimoroni's Phew es una librería que te ayuda a hacer un montón de networking fácilmente porque puedes evitar un montón de drugery.

Los objetivos son los mismos:

• Obtener datos ultrasónicos y mostrarlos en index.html
• Mantener la carga útil lo más baja posible.

He aquí cómo main.py parece.

from wifi import init_wifi
from phew import server
from phew.template import render_template
from machine import Pin
import time

init_wifi()

# ultrasonic sensor pins and functions
trigger = Pin(16, Pin.OUT)
echo = Pin(15, Pin.IN)


# Function to load in html page

@server.route("/data", methods=["GET"])
def ultrasonic(request):
    trigger.low()
    time.sleep_us(1)
    trigger.high()
    time.sleep_us(10)
    trigger.low()
    while echo.value() == 0:
        signaloff = time.ticks_us()
    while echo.value() == 1:
        signalon = time.ticks_us()
    timepassed = signalon - signaloff
    distance = (timepassed * 0.0340) / 2
    return str(distance), 200


@server.catchall()
def catchall(request):
    return render_template("index.html")


server.run()

Como puedes ver, el código es mucho más legible ya que puedes establecer puntos finales y enlazarlos con funciones que devuelven datos específicos.

En lugar de complicarse con el código para ejecutar los sockets, basta con llamar a una función de la biblioteca de Phew.

Algunas cosas que me gustan de Phew son:

• No más uso de request.find() para crear un punto final
• No más get_html() para abrir el index.html basta con utilizar el archivo render_template()
• main.py es mucho más fácil de leer, ¡con un mínimo esfuerzo adicional!
• Phew también incorpora funciones de registro que le permitirán depurar su código más fácilmente.

El único inconveniente es que Phew es todavía "un proyecto muy nuevo y debe considerarse, en el mejor de los casos, en fase alfa". Así que a veces puedes encontrarte con bloqueos inesperados.

Compruébalo.

Los tutoriales anteriores hablaban de cómo interactuar con su Pico W con su PC/teléfono móvil.

Demos un paso más allá y hagamos que el Pico W interactúe con un servicio en la nube.

Para ello, vamos a hacer un registrador de temperatura y humedad con un sensor DHT22 que envía datos a Google Sheets a través de IFTTT.

8. Configuración del sensor de temperatura y humedad DHT22 en el Pico W

Todos estos pasos funcionan para el DHT11 y el DHT22. La principal diferencia entre ambos es la precisión de las lecturas. La DHT11 es de color azul, mientras que la DHT22 es blanca.

Si tiene un DHT11, tenga en cuenta que las referencias al DHT22 en el código deben cambiarse por DHT11. Por ejemplo,

import dht
#dht22 = dht.DHT22(Pin(16))
#should be
dht11 = dht.DHT11(Pin(16))

Mirando el diagrama de abajo, de arriba a abajo del DHT22, conectarías 3.3V al primer pin.

El segundo pin es el pin de datos. Necesitarías alimentarlo. Por lo tanto, conecte una resistencia de 10K ohm desde el carril de alimentación a él, y luego conecte otro cable de puente a GPIO 16 en la Raspberry Pi Pico.

GND va a GND.

Para probar el sensor, ejecuta esto:

from machine import Pin
import dht

# ultrasonic sensor pins and functions
dht22 = dht.DHT22(Pin(16))

print(dht22.measure())
print(dht22.temperature())
print(dht22.humidity())

Si consigues OSError: [Errno 110] ETIMEDOUT significa que está ejecutando el script demasiado pronto. El DHT22 requiere una pausa de dos segundos antes de que pueda devolver otro valor. El DHT11 requiere un segundo.

Conectar IFTTT y Google Sheets

La forma más fácil de obtener datos del Pico W a Google Sheets es a través de IFTTT.

Primero, Regístrese para obtener una cuenta IFTTT.

A continuación, pulse el botón "Crear" para crear el applet.

Verá esta pantalla:

Haga clic en "Si esto" y busque Webhooks. Haz clic en "Recibir una petición web". No elijas la de JSON. Nombra el evento "dht22". El nombre del evento es crítico porque así es como IFTTT sabe qué applet activar.

Lo que estás haciendo aquí es crear un punto final al que puedes hacer ping con los datos del sensor del DHT22.

A continuación, haz clic en "Luego eso". Elige "Hojas de cálculo de Google". A continuación, elige "Añadir fila a la hoja de cálculo". Tendrás que vincular tu cuenta de Google Sheets.

Cambia el "Nombre de la hoja de cálculo" y la "Ruta de la carpeta Drive" a lo que quieras. Lo único crítico aquí es la "Fila con formato", donde querrás que esté

{{OccurredAt}} ||| {{Value1}} ||| {{Value2}}

Ahora, tendrás que ir a buscar el punto final al que el Pico W puede enviar los datos del sensor.

Dirígete a https://ifttt.com/maker_webhooks y haga clic en "Documentación".

La documentación le indicará su clave, el endpoint al que debe enviar los datos y cómo estructurar el cuerpo JSON.

Dado que ha utilizado "dht22" como nombre del evento, su punto final es:

ttps://maker.ifttt.com/trigger/dht22/with/key/[your_key_here]

También querrás estructurar tu cuerpo JSON así:

{'value1': *** temperature data *** , value2': *** humidity data *** }

Codificación del Pico W para obtener datos DHT22 y enviarlos a IFTTT

He aquí cómo.

from machine import Pin
from wifi import init_wifi
import urequests
import ujson
import dht
import time

init_wifi()

dht22 = dht.DHT22(Pin(16))


def send_data():
    #tell dht22 to take a reading
    dht22.measure()
    #find temp & humidity data and then jsonify data.
    dht_data = {'value1': str(dht22.temperature()),
                'value2': str(dht22.humidity())}
    post_data = ujson.dumps(dht_data)
    request_url = 'https://maker.ifttt.com/trigger/dht22/with/key/[your_key_here]'
    res = urequests.post(request_url, headers={
                         'content-type': 'application/json'}, data=post_data)
    #log response from IFTTT.
    print(res.text)
    #sleep for a minute before running send_data again
    time.sleep(1*60)
    send_data()


send_data()

Si va a copiar este código, asegúrese de sustituir [tu_clave_aquí] en el URL_solicitud variable.

Deberías obtener una nueva lectura cada minuto que se registra en Google Sheet, como se muestra a continuación.

Tenga en cuenta que la temperatura registrada está en grados Celsius. Si la quieres en Fahrenheit, aquí tienes la fórmula:

fahrenheit = dht22.temperature() * 1.8000 + 32.00

Si desea que los datos se registren con mayor (o menor) frecuencia, cambie el valor en time.sleep().

Utiliza IFTTT para que te avise si se produce un error

Por supuesto, este código sigue siendo bastante frágil.

Supongamos que algo no va bien. Por ejemplo, tu gato ha tirado del cable puente de 3,3 V mientras tú te colocabas en el suelo para registrar la temperatura.

El programa morirá, pero no recibirás ninguna notificación hasta que notes que tus datos no se están registrando.

¿Cómo se resuelve esto?

Pues haz que IFTTT te envíe una notificación cuando eso ocurra.

Necesitarías la aplicación IFTTT en tu teléfono. Así que descárgatela.

A continuación, crearía un nuevo applet.

Para el "Si esto" parte, Elija Webhooks -> Recibir una petición web. Nombre su evento "error".

Para el "Entonces esto" seleccione "Notificaciones" y "Enviar una notificación desde la app IFTTT".

He simplificado el mensaje

Error: {{Value1}}

Ahora, construyamos los bloques try-error.

from machine import Pin
from wifi import init_wifi
import urequests
import ujson
import dht
import time

init_wifi()

dht22 = dht.DHT22(Pin(16))


def send_data():
    # tell dht22 to take a reading
    dht22.measure()
    # find temp & humidity data and then jsonify data.
    dht_data = {'value1': str(dht22.temperature()),
                'value2': str(dht22.humidity())}
    post_data = ujson.dumps(dht_data)
    request_url = 'https://maker.ifttt.com/trigger/dht22/with/key/[your-key-here]'
    res = urequests.post(request_url, headers={
                         'content-type': 'application/json'}, data=post_data)
    # log response from IFTTT.
    print(res.text)
    # sleep for a minute before running send_data again
    time.sleep(1*60)
    send_data()


try:
    send_data()
except Exception as e:
    print(e)
    request_url = 'https://maker.ifttt.com/trigger/error/with/key/[your-key-here]'
    post_data = ujson.dumps({"value1": str(e)})
    urequests.post(request_url, headers={
        'content-type': 'application/json'}, data=post_data)

Pruébalo. Desconecta el cable de 3.3V de tu DHT22 y recibirás una notificación como tal:

9. Construye un mando a distancia físico de Spotify con Raspberry Pi Pico W

Basándonos en el proyecto anterior, utilizaremos IFTTT para controlar Spotify.

Crearemos un dispositivo que tenga un botón de reproducción, pausa y salto de pista.

La principal ventaja de utilizar IFTTT para controlar tu Spotify es lo fácil que resulta.

El inconveniente es que necesitas una cuenta de Spotify de pago y las respuestas son lentas. Es decir, si pulsas el botón de saltar, tendrás que esperar un rato antes de ver el resultado.

Lo bueno de tener un mando a distancia específico para Spotify es que puedes cambiar de música sin tener que llevar el móvil encima ni abrir la aplicación de Spotify.

Si alguna vez has conducido un coche moderno, sabrás lo agradable que es tener mandos en el volante.

Conectar un mando a distancia de Spotify

Necesitarás...

• 7x cables de puente
• 3x botones
• Raspberry Pi Pico W
• Cuenta de pago de Spotify

En la imagen hay muchos cables entrecruzados, así que aquí tienes una explicación textual.

Los pulsadores son como interruptores. Tienes que conectar el pin 3V3 a cada uno de ellos, lo que significa utilizar la columna positiva de la protoboard. Por lo tanto:

3V3 -> Columna positiva de la protoboard -> Pulsador (en un lado del canal de la protoboard) -> GPIO (en el otro lado)

Mi código utilizará GPIO 16 para el botón de reproducción, GPIO 2 para el botón de pausa y GPIO 15 para el botón de salto de pista.

Configurar IFTTT para controlar Spotify

Tenemos que crear tres applets, uno para cada una de las funciones de reproducción, pausa y salto.

Si tienes la versión premium de IFTTT, probablemente podrías usar los filtros JavaScript para contenerlo todo en una app. Pero como nosotros no, necesitamos un applet cada uno.

Una vez conectado, haga clic en "Crear" en la parte superior derecha del menú principal.

En la barra "Si esto", haz clic en ella y busca Webhooks.

A continuación, haga clic en "Recibir una solicitud web" (no la otra opción que tiene "con una carga útil JSON").

Para el nombre del evento, escriba spotify_skip.

Tendrá que repetir este paso dos veces más para spotify_pause y spotify_play una vez que haya terminado de crear este applet.

Una vez hecho esto, vaya a "Entonces" y haga clic en él. Busque "Spotify".

Tendrás que autorizar a IFTTT a conectarse a Spotify una vez.

Si está realizando el spotify_skip querrá hacer clic en "Saltar pista". Pero si usted está haciendo un applet para hacer alguna otra acción, la imagen de arriba le mostrará cuál usar.

Una vez creados los tres applets, ¡es hora de codificar!

Codificación del mando a distancia de Spotify para el Pico W

En primer lugar, deberá conocer el punto final al que debe llegar.

Ir a esta página y haga clic en el botón Documentación.

Allí verás tu clave. Si has seguido todos los pasos anteriores, la diferencia entre tu endpoint y el mío es tu clave. Por lo tanto,

Play endpoint: https://maker.ifttt.com/trigger/spotify_play/with/key/[tu_clave_aquí]

Pausa: https://maker.ifttt.com/trigger/spotify_pause/with/key/[tu_clave_aquí]

Saltar: https://maker.ifttt.com/trigger/spotify_skip/with/key/[tu_clave_aquí]

Código

from machine import Pin
from wifi import init_wifi
import urequests
import time

init_wifi()

play_btn = Pin(16, Pin.IN, Pin.PULL_DOWN)
pause_btn = Pin(2, Pin.IN, Pin.PULL_DOWN)
skip_btn = Pin(15, Pin.IN, Pin.PULL_DOWN)


def play():
    request_url = 'https://maker.ifttt.com/trigger/spotify_play/with/key/[your_key_here]'
    res = urequests.post(request_url)
    # print response from IFTTT.
    print(res.text)


def pause():
    request_url = 'https://maker.ifttt.com/trigger/spotify_pause/with/key/[your_key_here]'
    res = urequests.post(request_url)
    # print response from IFTTT.
    print(res.text)


def skip():
    request_url = 'https://maker.ifttt.com/trigger/spotify_skip/with/key/[your_key_here]'
    res = urequests.post(request_url)
    # print response from IFTTT.
    print(res.text)


try:
    while True:
        if play_btn():
            print('play btn')
            play()
            time.sleep(0.25)
        if pause_btn():
            print('pause btn')
            pause()
            time.sleep(0.25)
        if skip_btn():
            skip()
            print('skip')
            time.sleep(0.25)

except Exception as e:
    print(e)
    request_url = 'https://maker.ifttt.com/trigger/error/with/key/[your_key_here]'
    post_data = ujson.dumps({"value1": str(e)})
    urequests.post(request_url, headers={
        'content-type': 'application/json'}, data=post_data)

Repasemos el código.

Tenga en cuenta que tendrá que sustituir [tu_clave_aquí] con su clave real, obtenida a través del Documentación enlace.

En primer lugar, declaramos variables para los pulsadores.

play_btn = Pin(16, Pin.IN, Pin.PULL_DOWN)
pause_btn = Pin(2, Pin.IN, Pin.PULL_DOWN)
skip_btn = Pin(15, Pin.IN, Pin.PULL_DOWN)

Actualmente, si no pulsa el botón, su variable tendrá un valor de 0. Si lo pulsas, se convierte en 1. Esto es lo que utilizaremos para activar la función play() , pausa() y saltar() funciones.

A continuación, creamos funciones para los puntos finales de reproducción, pausa y salto. El modelo general es el siguiente:

def play():
    request_url = 'https://maker.ifttt.com/trigger/spotify_play/with/key/[your_key_here]'
    res = urequests.post(request_url)
    # print response from IFTTT.
    print(res.text)

Es bastante simple. Si se ejecuta esta función, enviará una solicitud POST a IFTTT. El envío de una solicitud GET no funcionará.

A continuación, tenemos el bloque try/except.

try:
    while True:
        if play_btn():
            print('play btn')
            play()
            time.sleep(0.25)
        if pause_btn():
            print('pause btn')
            pause()
            time.sleep(0.25)
        if skip_btn():
            skip()
            print('skip')
            time.sleep(0.25)

except Exception as e:
    print(e)
    request_url = 'https://maker.ifttt.com/trigger/error/with/key/[your_key_here]'
    post_data = ujson.dumps({"value1": str(e)})
    urequests.post(request_url, headers={
        'content-type': 'application/json'}, data=post_data)

Si se pulsa un botón, el código ejecutará la función correspondiente. Por ejemplo, si se pulsa el botón de salto se ejecutará la función saltar().

A time.sleep(0.25) pausará la función durante 250 ms. Sin esto, incluso una pulsación corta puede sobrecargar y bloquear el Pico W.

El excepto es opcional, pero yo lo hice porque ya tenía un applet de "error" en IFTTT. Si has seguido el tutorial anterior, es posible que lo hayas utilizado.

Básicamente, envía el mensaje de error, ea IFTTT, para que recibas el mensaje de error como una notificación de la aplicación del teléfono.

¿Por qué no funciona?

Utilizar IFTTT como medio para controlar tu Spotify es fácil, pero tiene algunos inconvenientes.

Primero debes iniciar la música de la forma habitual

Si has intentado pulsar el botón de reproducción de tu Pico W y esperabas que empezara a sonar la música... pues no pasa nada.

La solución es iniciar la música en tu ordenador o teléfono normalmente. Tienes que ir a tu aplicación y pulsar play.

Creo que esto declara qué dispositivo es el dispositivo activo. Una vez hecho esto, podrás utilizar tu mando a distancia Pico W Spotify.

Respuestas lentas

Pasan unos segundos entre la pulsación del botón y la respuesta. Por desgracia, así son las cosas.

Podrías pagar por una actualización de IFTTT para obtener velocidades de respuesta más rápidas. Al menos, eso es lo que prometen por tu dinero.

¿Hay alguna forma directa de conectar Spotify?

Sí. Spotify tiene una API a la que puedes conectarte.

Te da mucho más control. Podrías añadir un codificador giratorio para controlar el volumen. Podrías añadir una pantalla LCD para mostrar lo que se está reproduciendo. Consulta la consola de Spotify aquí.

Increíble, pero también mucho más difícil de programar, especialmente en un Pico W.

IFTTT lo hace todo fácil porque ellos hacen todo el trabajo pesado. Si quieres hacer tú el trabajo pesado, echa un vistazo al flujo de autenticación.

Por supuesto, somos entusiastas de Raspberry Pi. Alguien lo hará. ¿Deberías ser tú? ¿O yo? Comenta más abajo.

¡Controla tu Pico W de forma inalámbrica con PiCockpit!

Puede controlar y obtener datos de su Pico W de forma inalámbrica utilizando PiCockpit.

PiCockpit le permite obtener valores, controlar y utilizar PWM a través de una GUI mediante su applet GPIO.

También puedes ver las estadísticas de tu Pico W a través del applet PiStats.

Integrar PiCockpit en tu Pico W es superfácil.

Sigue este tutorial.

Escribir aún menos código con PiCockpit y Pico W

PiCockpit te facilita el control de tus pines GPIO sin tener que escribir ningún código.

Si mira tutorial número 2fíjate en la cantidad de código que se necesita para encender un LED.

Con nuestra nueva integración de Pico W, PiCockpit te lo pone mucho más fácil, ya que no tienes que programar nada en absoluto. Ni siquiera la configuración WiFi, que se realiza con nuestro asistente de configuración.

10. Control sencillo de LED con PiCockpit y Pico W

Si tienes tu LED configurado exactamente como yo lo he hecho en el tutorial nº 2, entonces sólo queda configurarlo en PiCockpit.

Si lo estás codificando, declararás en qué pin está tu LED usando led = machine.Pin(2, machine.Pin.OUT)

En PiCockpit, irás a tu applet GPIO, y te desplazarás hasta "GPIO Output (On/Off)".

Elige BCM02 en el menú desplegable porque tu LED está en GPIO 2.

A continuación, en la columna "Control", activa el interruptor para encender el LED.

También puede utilizar fácilmente la sección de Software PWM a continuación para controlar el brillo de su LED.

Ten en cuenta que tendrás que eliminar la configuración anterior porque no puedes tener dos salidas en el mismo GPIO.

A medida que desplaces el control deslizante "Control", verás cómo cambia el brillo del LED.

11. Pico W, ventilador de 5V y un transistor, controlado por PiCockpit

Intentemos algo un poco más completo pero usando el mismo conmutador de salida GPIO.

Para ilustrar algunos casos de uso en el mundo real, alimentaré un ventilador de 5V usando PiCockpit.

Este es un ventilador de 5V de baja potencia tomado de mi Raspberry Pi 4, por lo que está bien dentro de las capacidades de salida de la Raspberry Pi Pico W.

Dicho esto, como es un ventilador de 5V, no puedo usar un pin GPIO. En componentes que consumen menos energía, como un LED, puedes hacer que el GPIO cumpla la doble función de suministrar energía al componente y ser el "interruptor" que lo enciende y lo apaga.

Pero el ventilador de 5V requeriría un voltaje demasiado alto. Por lo tanto, la siguiente mejor manera es poner un transistor en el medio.

Esto me permite suministrar 5V al ventilador, a la vez que me aseguro de que puedo encenderlo y apagarlo.

Una vez más, gracias a PiCockpit, hice cero programación. Sólo hice el hardware, que está cableado de la siguiente manera:

El ventilador es un ventilador de 5V/0,12A, conectado a 5V en el extremo positivo (cable rojo), y el cable negativo va a la pata emisora del transistor.

El transistor es un transistor PN2222 (NPN), lo que significa que se pone en ON cuando recibe una señal alta.

De izquierda a derecha, con la parte semicircular de espaldas a ti, las patas son el Emisor, la Base y el Colector.

La pata Base se conecta a una resistencia de 1K, y luego se conecta a GPIO 15.

La pata del colector está conectada a masa.

Configuración de PiCockpit para trabajar con transistor

Una vez más, súper fácil.

Ve al menú desplegable de la sección GPIO Output y añade BCM15.

Una vez dentro, puedes hacer clic en la flecha hacia abajo y cambiar los Nombres de Estado a "ventilador apagado" y "ventilador encendido".

Activa el interruptor de control y verás que el ventilador se enciende.

También puedes usar PiStats para ver la caída de temperaturas en tu placa.

Fotoresistencia de pantalla utilizando MQTT y Node-RED con Pico W.

El objetivo principal de este tutorial es presentar MQTT.

En los tutoriales anteriores, te he mostrado cómo puedes utilizar tu Pico W para entregar datos, pero ¿y si quieres un repositorio central de datos en la nube?

HiveMQ Cloud es un servicio gratuito que podemos utilizar para lograr este objetivo. Al utilizar los ordenadores de otra persona, también podemos aligerar la carga del Pico W.

Además, MQTT tiene grandes ventajas en comparación con los métodos utilizados anteriormente. Para empezar, es mucho más eficiente en el envío de datos pequeños. Las cabeceras del protocolo MQTT tienen un tamaño de 2 bytes. HTTP es unas 4000 veces mayor.

La reducción de la carga de procesamiento local y de la carga de red se traduce en una mayor duración de la batería de su Pico W, lo que resulta perfecto para proyectos alimentados por batería o energía solar.

Conexión de la fotorresistencia con el Pico W

Una fotorresistencia (fotocélula) es muy fácil de conectar.

Coloca la fotorresistencia en el canal central de la protoboard.

A continuación, conecta el pin 3V3 a un lado de la fotorresistencia.

Querrás conectar un pin ADC al otro lado de la fotorresistencia, así que conecta GPIO 26.

Por último, conecta una resistencia de 10K ohmios de masa a la fotocélula.

HiveMQ Cloud y codificación del Pico W

En primer lugar, regístrese en HiveMQ Cloud aquí.

Ir a través de la configuración y crear un clúster. Se le pedirá que elija AWS o Azure. Para nuestros propósitos, no hay diferencia.

A continuación, haga clic en "Gestionar clúster".

Tome nota de la URL de su Cluster, y haga clic en Access Management para crear un nuevo usuario. Siga los pasos y cree un nuevo usuario.

Con estos datos, ya puedes programar tu Pico W para que envíe datos allí.

Codificación del Pico W para recibir datos de fotocélulas y MQTTClient

from machine import Pin, ADC
from wifi import init_wifi
import time
from umqtt.simple import MQTTClient

init_wifi()

photoresistor = ADC(Pin(26))


def readLight():
    light = photoresistor.read_u16()
    return light


# Connect MQTT

def connectMQTT():
    client = MQTTClient(client_id=b"[your_client_id]",
                        server=b"[your-host-name]",
                        port=0,
                        user=b"[your-user]",
                        password=b"[your-pw]",
                        keepalive=7200,
                        ssl=True,
                        ssl_params={
                            'server_hostname': '[your-host-name]'}
                        )

    client.connect()
    return client


client = connectMQTT()


def publish(topic, value):
    print(topic)
    print(value)
    client.publish(topic, value)
    print("data published")


while True:
    brightness = str(readLight()) #to publish, must send string

    print(brightness)

    publish('picow/brightness', brightness)

    time.sleep(0.1)

En primer lugar, pongamos en orden nuestras importaciones.

from machine import Pin, ADC
from wifi import init_wifi
import time
from umqtt.simple import MQTTClient

El wifi importación proviene de los tutoriales anteriores.

Necesitará la biblioteca umqtt.simple, que puede descargarse aquí.

Una vez descargado, puedes subirlo a tu tablero (guía aquí).

Deberías tener estos archivos en tu Pico W.

A continuación, crea una función para obtener una lectura de la fotorresistencia:

photoresistor = ADC(Pin(26))

def readLight():
    light = photoresistor.read_u16()
    return light

Esto devuelve un valor hasta 65535. Cuanto más brillante sea, mayor será el valor.

Conexión a HiveMQ

Para conectarse a HiveMQ, necesitará enviar algunos parámetros a la clase MQTTClient.

# Connect MQTT

def connectMQTT():
    client = MQTTClient(client_id=b"[your_client_id]",
                        server=b"[your-host-name]",
                        port=0,
                        user=b"[your-user]",
                        password=b"[your-pw]",
                        keepalive=7200,
                        ssl=True,
                        ssl_params={
                            'server_hostname': '[your-host-name]'}
                        )

    client.connect()
    return client


client = connectMQTT()

Sustituye [tu-nombre-de-host] por la dirección que aparece en tu panel de control. Tendrá que hacerlo dos veces, una para server y otro para server_hostname. Sustituye también [your_client_id] por un nombre para tu dispositivo, como "your_picow".

A continuación, sustituya [your-user] y [your-pw] con el usuario que ha creado en la página Gestión de acceso (captura de pantalla de la página Gestión de acceso a continuación).

Como referencia, esta función envía datos a HiveMQ:

def publish(topic, value):
    print(topic)
    print(value)
    client.publish(topic, value)
    print("data published")

Llamémoslo en nuestro while bucle:

while True:
    brightness = str(readLight()) #to publish, must send string

    print(brightness)

    publish('picow/brightness', brightness)

    time.sleep(0.1)

Al publicar, debe enviar cadenas, razón por la cual brightness = str(readLight()) está ahí.

Si envías enteros o flotantes, el programa morirá.

En la función de publicación, dale un nombre a tu tema. Diga, picow/brightnessy añada el valor que desea enviar. En este caso, queremos enviar la lectura de luz stringificada, brightness.

Debería poder ver los datos publicados cuando acceda a la pestaña Cliente web.

Nodo-RED

Son sólo números en línea que pueden parecer un galimatías. Y si quisieras acceder a los datos en HiveMQ Cloud y presentarlos gráficamente?

En lugar de crear tu propio sistema, puedes utilizar Node-RED.

Node-RED facilita enormemente la obtención de datos de HiveMQ y su presentación mediante representaciones gráficas.

Vamos a hacer un medidor usando Node-RED.

Para empezar, necesitará nodejs. Consulte la documentación de HiveMQ para ver qué versión se recomienda.

Una vez que tengas Node instalado, tendrás que abrir un símbolo del sistema/Terminal y ejecutar estos comandos (excluye sudo si estás en Windows):

sudo npm install -g --unsafe-perm node-red

Esto utilizará el gestor de paquetes node (npm) para instalar Node-RED globalmente.

A continuación, ejecute Node-RED escribiendo node-red en el Terminal/comando.

Abra su navegador y vaya a http://127.0.0.1:1880 o la dirección que figure en su terminal.

Construyamos el flujo. Arrastra un "mqtt in" al lienzo. Lo encontrarás en la pestaña "red" de la barra lateral izquierda.

Tendremos que configurar la pestaña, así que haz doble clic en el rectángulo y haz lo siguiente:

En el campo "tema", asegúrese de añadir brilloya que eso es lo que publicaste del Pico W.

En "servidor", añada uno nuevo haciendo clic en el icono del lápiz y accederá al siguiente menú.

Pon una nueva dirección de servidor y cambia el puerto a 8883. Marca "Usar TLS" pero no te molestes en añadir una nueva tls-config.

A continuación, ve a la pestaña de seguridad e introduce tus credenciales de acceso.

Todos estos detalles los encontrarás en tu código cuando inicialices MQTTClient.

Añadir un indicador

Para añadir un calibrador, debe tener la función node-red-dashboard.

En la barra lateral izquierda, si no los ve:

A continuación, vaya al menú (botón superior derecho) -> Administrar paleta. A continuación, vaya a la pestaña Instalar y busque node-red-dashboard. Haga clic en "Instalar".

Arrastre y suelte un "indicador" a la derecha de la casilla mqtt en rectángulo, y conéctelos arrastrando una línea desde mqtt en al manómetro.

Haz doble clic en el rectángulo del indicador y cambia la etiqueta a "brillo" y el "rango" máximo a 65535.

Muy bien. Ahora pulsemos "Desplegar".

Si tus ajustes eran correctos, verás un círculo verde y "conectado" debajo del rectángulo. Si no, tu terminal te dará más detalles de por qué hay un error.

Con su Pico W entregando datos a HiveMQ Cloud, ahora es el momento de comprobar el panel de control. Visite http://127.0.0.1:1880/ui y deberías ver que el indicador se actualiza con frecuencia.

Sus sugerencias son bienvenidas.

Deje un comentario en la casilla de abajo.