Raspberry Pi Pico W tutorial voor beginners

In deze Raspberry Pi Pico W Beginnershandleiding voor onderdelen leer je hoe je met de microcontroller kunt communiceren met eenvoudige onderdelen zoals LED's, ultrasone sensoren en vele andere dingen die je in een beginnerskit kunt vinden.

Als je een complete beginner bent, zal deze tutorial je helpen MicroPython te begrijpen zodat je code kunt lezen, schrijven en aanpassen. Met deze kennis kun je code en componenten combineren om iets te maken dat een echte use case heeft.

Als je van een Pico komt, leer je in deze tutorial hoe je de Pico W draadloos kunt bedienen. Voorheen kon je de Pico alleen bedienen met een schakelaar, knop of ander fysiek interactie-apparaat. Maar nu niet meer! Je kunt de onderdelen nu bedienen met je telefoon of desktop.

Lesstroom

Inleiding

1. Soldeer koppennen
2. Thonny gebruiken
3. Uw firmware bijwerken

De Hello World-tutorial voor de Pico W

1. Serveer een webpagina met de tekst "Hello World" op de Pico
2. Een LED draadloos aansturen

Een stap omhoog

1. RGB LED draadloos bedienen
2. Zoemer op de Pico W

Basismanieren om gegevens van sensor te verzenden

1. Pico W en HC-SR04 ultrasone sensor
2. Een webpagina met sensorgegevens verzenden
3. De payload verlagen met AJAX
4. Pimoroni Phew om codering van eindpunten te stroomlijnen

Verbinding maken met webhulpprogramma's

1. Klimaatgegevens van DHT22-sensor loggen in Google Sheets met IFTTT
2. Bouw een Spotify-afstandsbediening met play/pauze/skip-functies

GPIO-besturing zonder code met PiCockpit

1. Super eenvoudige PiCockpit-installatie op Pico W
2. Eenvoudige LED-bediening met PiCockpit en Pico W
3. Pico W, 5V ventilator en een transistor, bestuurd door PiCockpit

MQTT

1. Fotoresistor weergeven met MQTT en Node-RED met Pico W

Inhoudsopgave

Lesdoelen samengevat

• Leren omgaan met fundamentele componenten die deel uitmaken van grotere projecten
• Bedien ze allemaal draadloos - zonder schakelaars, knoppen of andere interactieapparaten.
• Een beter begrip krijgen van de sterke punten van de Pico W

Belangrijke links

Github repo voor zelfstudiecode (behalve secrets.py)

MicroPython documentatie

Fouten, suggesties, opmerkingen? Laat een reactie achter in het commentaarvak hieronder, e-mail mij of Tweet mij.

OSError: [Errno 98] EADDRINUSE

Als je deze foutmelding krijgt, koppel je Raspberry Pi Pico dan los en sluit hem weer aan.

Je kunt dit ook doen door deze commando's in Thonny's Shell te typen:

import machine
machine.reset()

Resultaat:

Soldeer koppennen

Als je een Raspberry Pi Pico W koopt, wordt deze mogelijk niet geleverd met headers waarmee je componenten op je Pico kunt aansluiten.

Op het moment van schrijven is de Pico WH (H voor headers) nog niet uitgebracht. Ons mega-artikel over de Pico W houdt de release bij.

Als je echter een Pico W met voorgesoldeerde headers kunt vinden, zou ik je aanraden die te kopen.

Voor de rest van ons is het solderen van headers op de Pico W echter heel eenvoudig. Je hebt nodig:

• Breadboard
• Soldeerbout en soldeer
• Koppen

Als je headers koopt, zorg er dan voor dat je er een koopt die bedoeld is voor de Pico W. In tegenstelling tot headers voor de Raspberry Pi Zero-serie, zitten de headers op de Pico W niet naast elkaar. Ze zitten aan tegenovergestelde uiteinden van het bord.

De pinnen hebben een lange en een korte kant. Je wilt de langere pinnen aan de kant hebben waar je de GPIO-labels ziet (GP0, GP1, GND, VBUS, VSYS, enzovoort).

Steek daarom de langere pinnen in het breadboard. Je hebt vier gaatjes nodig en een gootje ruimte ertussen. Als je het niet zeker weet, test het dan met je Pico W.

Solderen is eenvoudig. Zorg dat je soldeerbout goed heet is en gebruik de punt van de soldeerbout.

Wat ik het meest effectief vond, was om de punt van de soldeerbout dicht bij de pin te brengen, het soldeer de punt te laten raken en te zien hoe het langs de pin naar beneden stroomt en een verbinding maakt.

Controleer na het solderen of er geen soldeerresten zijn die twee GPIO-pinnen met elkaar verbinden of soldeerresten op je printplaat.

Gebruik Thonny als je code editor

Thonny blijft de eenvoudigste manier om je Raspberry Pi Pico W te programmeren.

Als je het Raspberry Pi OS gebruikt, heb je het al geïnstalleerd.

Als je echter Windows of Mac gebruikt, moet je het downloaden en configureren.

Hier is een gids die je door de stappen leidt.

Zorg er ook voor dat je raadpleeg de handleiding voor het uploaden van bestanden naar je Pico W.

Werk uw firmware bij door de nieuwste UF2 te uploaden

Als je je Pico W koopt, heb je misschien al de verouderde firmware.

Er komen veel veranderingen aan voor de Pico W, dus het is ideaal om je firmware nu te updaten.

Enkele veranderingen die ik heb gezien sinds de dag van de release zijn verbeteringen in de WLAN toegangspunt functie, en toekomstige updates zouden de Bluetooth functie op het bord kunnen ontgrendelen.

Nu bijwerken! Hier is een gids in ons mega-artikel.

1. Serveer een webpagina met de tekst "Hello World" op de Pico

Een van de meest fundamentele projecten in alle tutorials over programmeren is het "Hello World"-project.

Een "Hallo Wereld" van een microcontroller bestaat meestal uit het knipperen van een LED. Het is supermakkelijk. Zo doe je het.

Maar aangezien de Pico W een webpagina kan serveren, laten we beginnen met te leren hoe we een webpagina kunnen serveren met een "Hello World" bericht.

De hier gebruikte opstelling vormt de meest fundamentele bouwsteen voor de rest van de tutorials.

Er zijn twee manieren om verbinding te maken met de Pico W. Je kunt hem laten deelnemen aan een WiFi-netwerk of je kunt een SoftAP-hotspot uitzenden, vergelijkbaar met wat je smartphone doet. Als je dat laatste wilt proberen, volg deze link. Voor de consistentie in deze tutorial zullen we echter altijd verbinding maken met een WiFi-netwerk in plaats van er een uit te zenden vanaf de Pico W.

De stappen voor het serveren van een webpagina bestaan dus uit:

• Verbinding maken met WiFi
• Code schrijven om index.html te serveren aan iedereen die verbinding maakt met het IP-adres van de Pico W

Laten we een paar bestanden opzetten. Sla deze op en upload ze naar je Raspberry Pi Pico W. Hier lees je hoe je bestanden uploadt, mocht je het gemist hebben.

wifi.py

wifi.py is een boilerplate bedoeld om je te helpen verbinding te maken met je WiFi-netwerk. Een apart bestand maken en importeren in main.py bestand later zal helpen om rommelige code te verminderen.

Merk op dat je de code van je land moet veranderen in de regel rp2.land('DE') als je land niet Duitsland is.

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])

secrets.py

wifi.py import secrets.py, waar je de informatie over je WiFi-netwerk opslaat.

secrets.py is een eenvoudig JSON-bestand dat je WiFi-SSID en wachtwoord bevat.

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

pagina serveren.py

Zoals de naam al aangeeft, serveert deze pagina websites aan gebruikers die verbinding maken met de Pico W.

Na ontvangst van een verbinding vindt de Pico W een bestand met de naam index.html en stuurt het naar de verbonden client, zoals te zien is in de regel antwoord = 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')

Ten slotte moeten we de index.html bestand dat naar een verbonden client wordt gestuurd.

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

Dit is een eenvoudige HTML-ketelplaat met twee wijzigingen: één aan de <title>tag met de titel "Pico W" en de tag <h1> met de tekst "Hello World".

main.py

Omdat we alle code elders hebben geplaatst, is onze main.py bestand hoeft alleen maar deze functies te importeren en aan te roepen om de Hello World webpagina te serveren.

Zoals je kunt zien, initialiseren we eerst WiFi voordat we de webpagina serveren.

from wifi import init_wifi
from serve_webpage import serve_webpage

init_wifi()
serve_webpage()

Je bent er bijna!

Controleer aan de hand van de onderstaande schermafbeelding:

• Je hebt vijf bestanden geüpload naar je Raspberry Pi Pico W (zie het rode vak linksonder)
• Zorg ervoor dat je interpreter is ingesteld op MicroPython (Raspberry Pi Pico) (zie kader rechtsonder)
• Markeer vervolgens de main.py in je code editor en klik op de groene run knop (linksboven in het rode vak)
• Zodra je dit hebt uitgevoerd, zie je je IP-adres in de Shell. Ga naar je browser en typ dit adres in en je ziet de Hello World webpagina.
• Als je Shell niet open is, ga dan naar Beeld -> Shell.

Als alles goed is gegaan, ziet u de onderstaande pagina.

2. Een LED draadloos aansturen

Nu je de basis hebt ingesteld, gaan we een stap vooruit.

Een van de meest fundamentele Raspberry Pi-projecten bestaat uit het laten knipperen van een LED.

Laten we een stapje verder gaan door de LED draadloos te besturen. We willen de LED kunnen laten knipperen, aan- en uitzetten.

Om dit te doen, moet je een circuit en een webserver instellen met drie knoppen - AAN, UIT, KNIPPEREN.

Voor dit project heb je een LED, een weerstand van 330 ohm, een brugdraad en een breadboard nodig.

We gebruiken een rode LED omdat de meeste kits deze hebben. Als je een LED van een andere kleur gebruikt, moet je de weerstand aanpassen.

Zo sluit je de onderdelen aan

• GPIO 2 -> lange poot van LED (anode/positief)
• GND -> weerstand van 330 ohm -> kort been van LED (kathode/negatief)

Code om LED op Pico W te bedienen

Laten we voortbouwen op wat we in de vorige tutorial hebben gedaan. De enige twee bestanden die we moeten aanpassen zijn index.html om knoppen toe te voegen en main.py om te communiceren met de LED op basis van de input van index.html.

De vetgedrukte delen geven de nieuwe regels aan die zijn toegevoegd aan index.html. Ze voegen drie knoppen toe en een paragraaf met de tekst "Bedien de 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>

Als je op de knoppen drukt, zie je dat er een parameter wordt toegevoegd aan het IP-adres van je Pico W (bijv. http://192.168.43.134/%22?led=blink\). Deze parameters worden opgevangen door de backend van de Pico W en sturen de LED aan.

We gaan verhuizen pagina serveren.pycode in de main.py dossier.

Hier is 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')

Het eerste en belangrijkste segment staat hieronder:

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()

Als de variabele "request" wordt afgedrukt, wordt het eerste blok tekst hieronder afgedrukt. De laatste drie regels zijn de afdrukinstructies die controleren of de LED aan, uit of knippert:

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

De bovenstaande code probeert te zoeken naar specifieke tekenreeksen zoals "led=aan". Als het bestaat, zal de waarde meer dan -1 zijn, waardoor de relevante als verklaring.

Als bijvoorbeeld led=on bestaat in de parameters, dan zal de variabele led_on meer dan -1 zijn, daarom zal de als led_on > -1 statement triggert en draait led.aan();

Het enige ingewikkelde hier is de led_knipperen functie die de functie activeert:

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

Tot slot is dit hoe je GPIO 2 initialiseert om de LED te bedienen:

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

We importeren machine om te communiceren met de GPIO-pin. Zoals je kunt zien in de variabele ledWe willen dat de Pico W GPIO 2 van stroom voorziet.

We importeren tijd zodat we een pauze van 0,2 seconden kunnen hebben in knipperen_led().

3. RGB-LED op Pico W

Om je RGB LED te verlichten, heb je het volgende nodig:

• Drie weerstanden van 330 ohm
• Eén RGB-LED
• Een startkabel

Op de RGB-LED vind je vier pootjes. Eén poot is het langst. Dat is een kathode (negatief) of anode (positief). Mijn RGB LED had een gedeelde kathode, dus hier is de aansluiting:

• GPIO 15 -> weerstand van 330 ohm -> rode LED
• GPIO 17 -> weerstand -> groene LED
• GPIO 16 -> weerstand -> blauwe LED

Hier is wat code om te zien of je het goed hebt aangesloten:

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)

In dit voorbeeld gebruiken we PWM, waarmee je de helderheid van de R, G, B LED's kunt variëren.

Je kunt de waarden die worden doorgegeven aan [color].duty_u16 wijzigen in een waarde tussen 0 en 65534. Theoretisch zou je 65535 moeten kunnen doorgeven, maar op de een of andere manier lijkt dat bij mij niet te werken.

Als je "0" doorgeeft, wil je zeggen dat je nul procent helderheid wilt. Als je 65534 doorgeeft, wil je 100 procent helderheid.

Als je 65534 doet voor één kleur en nul voor de rest, kun je zien of je de juiste GPIO-pinnen op de juiste LED-kleur hebt aangesloten.

Waarom gebruiken we dan PWM? Omdat je dan meer kleuren krijgt. Als je gewoon een "aan-en-uit" methode gebruikt, kun je rood, groen, blauw, witachtig en geen licht krijgen. Met PWM kun je de intensiteit van de R, G, B LED variëren en zoveel kleuren maken als je maar kunt bedenken.

Laten we nu iets maken dat je draadloos kunt bedienen!

index.html

De belangrijkste verandering hier is om een <form> die drie schuifregelaars heeft. Deze schuifregelaars hebben een waarde tussen nul en 100.

Door waarden van nul tot 100 te gebruiken, kun je helderheid visualiseren als een percentage. Het vermindert ook de hoeveelheid code die nodig is om de waarde uit de parameters te halen (later te zien in main.py)

Wanneer je de waarden voor de R, G, B LED's hebt ingesteld, druk je op submit en worden deze gegevens door de Pico W vastgelegd.

<!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')

Als je op verzenden drukt op de index.html webpagina, zal de Pico W de parameters aannemen en verwerken.

Laten we eens kijken naar enkele belangrijke punten in de code, vetgedrukt in het codeblok hierboven.

functie vind_intensiteit

Deze functie neemt twee params: kleur en verzoek_str. kleur neemt "rood", "groen" of "blauw" en vindt de waarde na het gelijkteken (=).

Bijvoorbeeld, je URL nadat je het formulier hebt verzonden is "http://192.168.1.142/?red=89&green=50&blue=50".

Als u "red" doorgeeft aan find_intensity, geeft dit 89 terug.

intensiteitsparser

Het tweede vetgedrukte blok code is de code die de GPIO van de Pico W vertelt hoeveel helderheid je van elke LED wilt.

Eerst moeten we ervoor zorgen dat de params bestaan in de URL. Dit wordt gedaan door de als verklaring request_str.find('red') > -1. Ik gebruikte gewoon rood omdat de params 100% de string 'red' bevatten als je het formulier gebruikt.

Als je het IP-adres van je Pico W (bijv. http://192.168.1.142/) voor de eerste keer bezoekt, heb je de params niet, dus zal het programma crashen als je vind_intensiteit.

Als er params zijn, vinden we de intensiteit voor elke LED op basis van de opgegeven waarden. Laten we eens kijken naar rood_intensiteit.

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

vind_intensiteit geeft een geheel getal nul tot 100. We delen dit door 100 zodat je een percentage krijgt. Dit percentage deelt de maximale waarde die de plicht_u16 methode kan gebruiken.

We hebben echter een int functie om dit in te pakken omdat je soms een float krijgt en plicht_u16 heeft een int. Stel bijvoorbeeld dat je 41% helderheid wilde - 41% van 65534 is 26.868,94. Je kunt deze float niet doorgeven omdat het programma dan vastloopt.

4. Zoemer op de Pico W

Een zoemer is een vrij belangrijk onderdeel voor basismeldingen, net zoals een LED je kan vertellen wat de status van iets is, geeft een zoemer je een auditieve melding.

In plaats van mijn eigen code te implementeren, heb ik ervoor gekozen om het volgende te gebruiken Giuseppe Cassibba's implementatie. Als je zijn code op de Pico W hebt uitgevoerd, hoor je piepjes op je buzzer.

Maar omdat deze code bedoeld is voor de Pico, zal het geen draadloze interactiviteitsfuncties hebben.

Dus, laten we de vork eruit halen!

Laten we eerst de index.html om de knoppen te implementeren. Laten we een knop maken voor "AAN", "UIT", "SCHAAL", "MUZIEK".

De eerste twee knoppen spreken voor zich. De derde knop speelt een C-schaal en de laatste speelt een muziekstuk.

<!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>

Net als voorheen maken we een paar <button> tags met <a> tags eromheen. Wanneer er op de knoppen wordt geklikt, zal de URL een parameter hebben zoals /buzzer=aan. De Pico W leest dit en schakelt de zoemer in.

Laten we nu eens kijken naar Giuseppe's code voor de 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()

Zijn code speelt een C-schaal af wanneer deze wordt uitgevoerd met de functie zoemer(), die vier parameters opneemt: Buzzer object, frequentie in Hertz, geluidsduur en pauzetijd voordat het volgende geluid wordt afgespeeld.

Laten we de code aanpassen zodat we de AAN, UIT, SCHAAL en MUZIEK.

Zo integreren we Giuseppe's code in onze 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')

In de bovenstaande implementatie hebben we de code voor MUZIEK.

De code lijkt erg op de rode LED-tutorial hierboven, waarbij de Pico W de parameters na het IP-adres van de Pico W vastlegt. Als de param zoemer=AAN, zal het een 440Hz geluid afspelen. Als zoemer=schaaldan wordt de toonladder uit Giuseppe's code afgespeeld.

Hoe zit het met het implementeren van muziek? Muziek implementeren is iets ingewikkelder, dus we moeten een nieuw bestand maken met de naam constanten.py en voeg een paar regels toe aan onze main.py.

Deze code is een vork van De Arduino-code van Rowan Packard.

constanten.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 (vetgedrukte toevoegingen)

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')

Zoals je kunt zien, zijn er twee matrices, muzieknoten en ritme. Je zou dan een for-lus uitvoeren om deze waarden in de zoemer() functie. Ook importeren we bovenaan de code alle variabelen van constanten.py.

De zoemer() functie gebruikt ook twee nieuwe variabelen - t en pauze. Met deze twee variabelen kun je het tempo van de muziek afstemmen. t bepaalt hoe lang elke noot moet worden gespeeld en pauze Bepaalt hoe lang de stilte tussen de noten moet zijn.

5. Pico W en HC-SR04 ultrasone sensor

In de vorige tutorials hebben we de Pico W gebruikt om commando's naar de LED's en zoemers te sturen.

Maar wat als we de Pico W gebruiken om informatie te ontvangen?

In dit geval hebben we het over de HC-SR04 ultrasone afstandssensor.

Wanneer je je ultrasone sensor aansluit, moet je weten of het een 5V of 3,3V component is. Ik sloot mijn 5V versie aan op de 3.3V pin en kreeg geen reactie van het programma, die ik hieronder zal delen. Toen ik de voedingsbron naar de 5V pin verplaatste, kreeg ik meteen een reactie.

Blijkbaar kunnen sommige nieuwere versies van de HC-SR04 zowel 3,3V als 5V aan. Misschien is het het beste om eerst de 3,3V pin te proberen en te kijken of je resultaat krijgt. Zo niet, probeer dan de 5V.

Hier is het schema en het programma dat je kunt uitvoeren in Thonny. Als je een reactie krijgt, betekent dit dat je alles op de juiste manier hebt aangesloten, inclusief de spanning.

Bedrading

De bedrading van de gelabelde pinnen van de HC-SR04 sensoren is als volgt:

• VCC naar 3,3V of 5V pin (probeer bij twijfel eerst 3,3V)
• TRIG naar GPIO 16
• ECHO naar GPIO 15
• GND naar GND

Testprogramma voor HC-SR04

Om te testen of je bedrading correct is, kun je deze code proberen die de afstand op de Thonny Shell afdrukt.

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)

Je uitvoer zou moeten zijn:

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

Als het programma draait en stopt zonder enige output, dan heb je waarschijnlijk iets verkeerd aangesloten. Toen ik de sensor aansloot op een 3,3V pin in plaats van een 5V, stopte het programma zonder reactie.

Gegevens naar je browser sturen

Laten we de bestanden die we hebben gebruikt om een webpagina te serveren eens oppakken en aanpassen zodat we de afstandswaarden kunnen zien.

Hier is de uiteindelijke code:

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>

Laten we enkele fragmenten van de code bekijken om te begrijpen wat er gebeurt.

Code voor ultrasone afstand

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

Het bovenstaande codeblok activeert het uitzenden van een ultrasone golf. De tijd.slaap tussen de lage en hoge waarden zijn noodzakelijk voor de werking van de ultrasone sensor.

Om te meten hoeveel tijd er verstrijkt tussen de uitzending van de ultrasone golf en de tijd die de geluidsgolf nodig heeft om terug te keren, gebruiken we tijd.tikken_u om de tijd van emissie en de tijd voor het detecteren van de echo te meten.

tijd.tikken_u is een willekeurig getal, dus moeten we hiervan aftrekken sein op van signaaluit om de tijd voorbij te laten gaan.

Om de afstand te berekenen, gebruiken we de formule afstand = (verstreken tijd * geluidssnelheid) / 2. Geluidssnelheid is 340m/s, wat dus 0,0340 is.

De reden waarom we het door twee moeten delen is omdat de geluidsgolf naar het object reist en terugkomt.

Code om webpagina met afstandswaarde te tonen

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())

Deze functie is een beetje gewijzigd ten opzichte van de vorige tutorials, waarbij een extra parameter is toegevoegd afstanddie loopt ultrasoon().

De functie opent de index.html bestand normaal maar gebruikt de vervangen methode om de <h2> en voegt de afstand variabel.

index.html pingt server elke 500ms om nieuwe waarde te krijgen

De hoofdwebpagina krijgt een functie die de webpagina elke 500 ms opnieuw laadt. Bij elke herlaadbeurt wordt de Pico W gepingd om de nieuwe ultrasone afstandswaarde op te halen.

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

6. Ultrasone gegevens, maar laten we AJAX gebruiken om de payload te verminderen

De vorige tutorial werkt door de Raspberry Pi Pico W een hele nieuwe index.html bestand elke keer dat er een verbinding is.

Dit werkt, maar het is ongelooflijk inefficiënt omdat de hele index.html opnieuw wordt verzonden wanneer u alleen de ultrasone afstandsgegevens hoeft bij te werken.

We willen dezelfde resultaten als in de vorige tutorial, maar zonder de zware belasting van de vorige methode.

Dus moeten we de client (je telefoon of PC) een eindpunt laten pingen dat alleen zal reageren met de ultrasone gegevens.

De nieuwe methode is als volgt: als mensen de root URL bezoeken, bijvoorbeeld 192.168.1.119, dan krijgen ze de index.html.

index.html bevat JavaScript dat de /gegevens eindpunt, dat de Pico W activeert om ultrasone afstandsgegevens op te halen en daarmee te reageren.

Dan, index.html ontvangt deze gegevens en werkt de webpagina bij.

Het verzoek van de klant splitsen

Onthoud dat in de main.pyis er altijd een regel die zegt requests = cl.recv(1024). Het request object ziet er ongeveer zo uit:

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

Eerst moeten we deze muur van tekst uitfilteren.

We gebruiken de vinden() methode om te achterhalen of de verzoek variabele "/data" heeft. Als dat zo is, antwoord dan met de ultrasone afstandsgegevens. Als er geen "/data" is, reageer dan met 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())

Als je /data in je browser hebt bezocht, zie je de afstandswaarde afgedrukt, zoals hieronder.

Voorheen werd bijna alles afgehandeld door de backend. De ultrasone afstand werd aangepast voordat deze werd geserveerd als index.html.

Nu, index.html de sensorgegevens van de Pico W ophaalt, dus moeten we enkele wijzigingen aanbrengen in het JavaScript in het HTML-bestand. De wijzigingen zijn vetgedrukt.

<!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>

Centraal in de code hier is de API ophalen en de nieuwste async/await syntax hier.

De functie getData() pingt het /data eindpunt van de Pico W en de Pico W antwoordt. We zorgen ervoor dat het programma niet verder gaat voordat we een volledig antwoord krijgen met de vraag om wacht op.

Fetch wordt een Response-object dat je nodig hebt om de Response.text()-methode te gebruiken om bij de inhoud van het antwoord te komen. Vandaar de regels const distance = await data.text();

Zodra we de ultrasone gegevens hebben, veranderen we de <h2 id="”ultrasonic”"> De binnenste HTML van een element, die leeg begint, met de afstandsgegevens. Je kunt een element targeten met een id direct zonder de getElementById() of querySelector() methoden.

Als alle code klaar is, willen we getData() opnieuw uitvoeren. Waarom heb ik een instelinterval om een interval van 100 ms in te stellen?

Wat ik ontdekte is dat als je getData() aanroept zonder interval, je meer pauzes krijgt tussen de uitgangen. Je krijgt een opeenvolging van snelle updates en dan een pauze. Met de 100 ms ademruimte loopt de Pico W iets beter en lijken updates nog steeds min of meer real-time.

Als je wilt begrijpen wat er onder de motorkap gebeurt, raadpleeg dan de Fetch API-documentatie en de async/await documentatie.

7. Pimoroni Pfoe voor schonere code

In de vorige sectie hebben we de AJAX-methode behandeld om de gegevens van de ultrasone sensor bij te werken.

Maar is er een nog betere manier om dit te doen?

Pimoroni's Phew is een bibliotheek die je helpt om eenvoudig veel te netwerken, omdat je veel drughandel kunt vermijden.

De doelen zijn hetzelfde:

• Ultrasone gegevens ophalen en weergeven op index.html
• Houd de payload zo laag mogelijk.

Dit is hoe main.py lijkt.

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()

Zoals je kunt zien, is de code veel leesbaarder omdat je eindpunten kunt instellen en ze kunt koppelen aan functies die specifieke gegevens retourneren.

In plaats van te rommelen met code om de sockets uit te voeren, zou je gewoon een functie uit de bibliotheek van Phew aanroepen.

Enkele dingen die leuk zijn aan Phew zijn:

• Geen gebruik meer van verzoek.vinden() om een eindpunt te maken
• Niet meer get_html() functie om de index.html bestand, gebruik dan gewoon Phew's render_template()
• main.py is veel gemakkelijker te lezen, met minimale extra inspanning!
• Phew voegt ook logboekfunctionaliteit toe waarmee je je code gemakkelijker kunt debuggen.

Het enige nadeel is dat Phew nog steeds "een heel nieuw project is en in het beste geval moet worden beschouwd als een alfa-fase". Je kunt dus soms onverwachte wegversperringen tegenkomen.

Bekijk het.

In de vorige tutorials is besproken hoe je kunt communiceren met je Pico W via je PC/mobiele telefoon.

Laten we een stapje verder gaan en de Pico W laten communiceren met een cloudservice.

Laten we hiervoor een temperatuur- en vochtigheidslogger maken met een DHT22-sensor die gegevens naar Google Sheets stuurt via IFTTT.

8. De DHT22 temperatuur- en vochtigheidssensor instellen op de Pico W

Al deze stappen werken voor de DHT11 en DHT22. Het belangrijkste verschil tussen de twee is de nauwkeurigheid van de metingen. DHT11 is blauw van kleur terwijl DHT22 wit is.

Als je een DHT11 hebt, moet je verwijzingen naar de DHT22 in de code veranderen in DHT11. Bijvoorbeeld,

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

Als je naar het onderstaande schema kijkt, van boven naar beneden van de DHT22, sluit je 3,3V aan op de eerste pin.

De tweede pin is de datapin. Die moet je van stroom voorzien. Sluit dus een weerstand van 10K ohm aan op de voedingsspanning en verbind vervolgens een andere draad met GPIO 16 op de Raspberry Pi Pico.

GND gaat naar GND.

Voer dit uit om de sensor te testen:

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())

Als je OSError: [Errno 110] ETIMEDOUT betekent dat je het script te snel uitvoert. De DHT22 heeft een pauze van twee seconden nodig voordat het een andere waarde kan teruggeven. DHT11 heeft één seconde nodig.

IFTTT en Google Sheets verbinden

De eenvoudigste manier om gegevens van de Pico W naar Google Sheets te krijgen is via IFTTT.

Eerst, aanmelden voor IFTTT account.

Klik vervolgens op de knop "Create" om het applet te maken.

U ziet dit scherm:

Klik op "Als dit" en zoek naar Webhooks. Klik op "Een webverzoek ontvangen". Kies niet de JSON. Geef de eventnaam "dht22". De naam van de gebeurtenis is belangrijk omdat IFTTT zo weet welke applet moet worden geactiveerd.

Wat je hier doet, is een eindpunt maken dat je kunt pingen met de sensorgegevens van de DHT22.

Klik dan op "Dan dat". Kies "Google Sheets". Kies dan "Rij aan spreadsheet toevoegen". Je moet je Google Sheets-account koppelen.

Verander de "Spreadsheet name" en "Drive folder path" in wat je maar wilt. Het enige kritieke punt hier is de "Opgemaakte rij", waar je die wilt hebben

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

Nu moet je het eindpunt ophalen waar de Pico W sensorgegevens naartoe kan sturen.

Ga naar https://ifttt.com/maker_webhooks en klik op "Documentatie".

De documentatie vertelt je wat je sleutel is, naar welk eindpunt je gegevens moet sturen en hoe je de JSON body moet structureren.

Aangezien je "dht22" hebt gebruikt als naam voor je gebeurtenis, is je eindpunt:

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

Je zult je JSON body ook als volgt willen structureren:

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

De Pico W coderen om DHT22-gegevens te krijgen en deze naar IFTTT te sturen

Hier is hoe.

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()

Als je deze code gaat kopiëren, zorg er dan voor dat je het volgende vervangt [uw_sleutel_hier]. herberg de verzoek_url variabel.

Je zou elke minuut een nieuwe meting moeten krijgen die wordt opgeslagen in Google Sheet, zoals hieronder.

Merk op dat de gelogde temperatuur in Celcius is. Als je het in Fahrenheit wilt, is hier de formule:

fahrenheit = dht22.temperature() * 1.8000 + 32.00

Als je wilt dat gegevens vaker (of minder vaak) worden gelogd, verander dan de waarde in tijd.slaap().

Gebruik IFTTT om je te waarschuwen als er een fout optreedt

Natuurlijk is deze code nog steeds erg kwetsbaar.

Stel dat er iets niet goed gaat. Je kat heeft bijvoorbeeld aan de 3,3V jumper draad getrokken terwijl je op de vloer lag om de temperatuur te loggen.

Het programma zal afsterven, maar je krijgt geen melding totdat je merkt dat je gegevens niet worden gelogd.

Hoe los je dit op?

Laat IFTTT je een melding sturen als dat gebeurt!

Je hebt de IFTTT app nodig op je telefoon. Download deze dus.

Vervolgens maak je een nieuwe applet.

Voor de "Als dit" deel, Kies Webhooks -> Een webverzoek ontvangen. Geef je evenement een naam "fout".

Voor de "Dan Dit" deel, kies "Meldingen" en "Stuur een notificatie vanuit de IFTTT app".

Ik heb het bericht eenvoudig gemaakt

Error: {{Value1}}

Laten we nu de try-error blokken bouwen.

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)

Probeer het eens. Haal de 3,3V draad uit je DHT22 en je zult een melding krijgen:

9. Bouw een fysieke Spotify-afstandsbediening met Raspberry Pi Pico W

Voortbouwend op het vorige project zullen we IFTTT gebruiken om Spotify aan te sturen.

We maken een apparaat met een knop voor afspelen, pauzeren en nummers overslaan.

Het grootste voordeel van het gebruik van IFTTT om je Spotify te bedienen is hoe makkelijk het is.

Het nadeel is dat je een betaalde Spotify-account nodig hebt en dat de reacties traag zijn. Dat betekent dat als je op de skip-knop drukt, je een tijdje moet wachten voordat je het resultaat ziet.

Het mooie van een speciale Spotify-afstandsbediening is dat je je muziek kunt wijzigen zonder je telefoon mee te nemen of de Spotify-app te hoeven openen.

Als je ooit in een moderne auto hebt gereden, weet je hoe fijn stuurwielbediening is.

Een Spotify-afstandsbediening aansluiten

Je hebt nodig...

• 7x startkabels
• 3x knoppen
• Raspberry Pi Pico W
• Spotify betaald account

Er lopen veel draden kriskras door elkaar in de afbeelding, dus hier is een tekstuele uitleg.

De drukknoppen zijn als schakelaars. Je moet de 3V3 pin met elk van hen verbinden, wat betekent dat je de positieve kolom op het breadboard moet gebruiken. Daarom:

3V3 -> positieve kolom van het breadboard -> drukknop (aan de ene kant van de goot van het breadboard) -> GPIO (aan de andere kant)

Mijn code gebruikt GPIO 16 voor de afspeelknop, GPIO 2 voor de pauzeknop en GPIO 15 voor de skip track-knop.

IFTTT instellen om Spotify te bedienen

We moeten drie applets maken, één voor de afspeel-, pauze- en skipfunctie.

Als je de premium versie van IFTTT hebt, zou je waarschijnlijk de JavaScript-filters kunnen gebruiken om alles in één app te bevatten. Maar omdat we dat niet hebben, hebben we elk een applet nodig.

Als je bent ingelogd, klik je op "Maken" rechtsboven in het hoofdmenu.

Klik op de balk "Als dit" en zoek naar Webhooks.

Klik vervolgens op "Een webverzoek ontvangen" (niet op de andere optie met "met een JSON payload").

Typ voor evenementnaam spotify_skip.

Je moet deze stap nog twee keer herhalen voor spotify_pauze en spotify_play als je klaar bent met het maken van deze applet.

Zodra dat is gebeurd, gaat u naar de "Dan dat" balk en klik erop. Zoek naar "Spotify".

Je moet IFTTT eenmalig machtigen om verbinding te maken met Spotify.

Als je de spotify_skip actie, zul je op "Skip track" willen klikken. Maar als je een applet maakt om een andere actie uit te voeren, laat de bovenstaande afbeelding zien welke je moet gebruiken.

Als je alle drie de applets hebt gemaakt, is het tijd om te coderen!

De Spotify-afstandsbediening coderen voor de Pico W

Allereerst moet je weten welk eindpunt je moet bereiken.

Ga naar deze pagina en klik op de Documentatie.

Daar ziet u uw sleutel. Als u alle bovenstaande stappen hebt gevolgd, is het verschil tussen uw eindpunt en het mijne uw sleutel. Vandaar,

Eindpunt afspelen: https://maker.ifttt.com/trigger/spotify_play/with/key/[your_key_here]

Pauze: https://maker.ifttt.com/trigger/spotify_pause/with/key/[your_key_here]

Skip: https://maker.ifttt.com/trigger/spotify_skip/with/key/[your_key_here]

Code

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)

Laten we de code doornemen.

Merk op dat u het volgende moet vervangen [uw_sleutel_hier]. met uw echte sleutel, zoals verkregen via de Documentatie link.

Eerst declareren we variabelen voor de drukknoppen.

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)

Als je momenteel niet op de knop drukt, heeft je variabele een waarde van 0. Als je erop drukt, wordt het 1. Dit is wat we gebruiken om de afspelen() , pauze() en overslaan() functies.

Vervolgens maken we functies voor de eindpunten afspelen, pauzeren en overslaan. Het algemene sjabloon is als volgt:

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)

Het is vrij eenvoudig. Als deze functie wordt uitgevoerd, zal het een POST-verzoek naar IFTTT sturen. Een GET-verzoek verzenden zal niet werken.

Dan hebben we het try/except-blok.

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)

Als er op een knop wordt gedrukt, zal de code de relevante functie uitvoeren. Als je bijvoorbeeld op de knop skip drukt, wordt de functie overslaan().

A time.sleep(0,25) pauzeert de functie voor 250 ms. Zonder dit kan zelfs een korte druk de Pico W overbelasten en crashen.

De behalve Het blok is optioneel, maar ik heb het gedaan omdat ik al een "error" applet had op IFTTT. Als je de vorige tutorial hebt gevolgd, heb je deze misschien al gebruikt.

In principe stuurt het de foutmelding, enaar IFTTT, zodat je de foutmelding krijgt als een app-melding op je telefoon.

Waarom werkt het niet?

IFTTT gebruiken als medium om je Spotify te bedienen is gemakkelijk, maar het heeft wel een paar nadelen.

Je moet de muziek eerst op de normale manier starten

Als je op de afspeelknop van je Pico W hebt gedrukt en verwacht dat er muziek wordt afgespeeld... nou, dan gebeurt er niets.

De oplossing is om de muziek op je computer of telefoon normaal te starten. Je moet naar je app gaan en op play drukken.

Ik denk dat dit aangeeft welk apparaat het actieve apparaat is. Als je dit gedaan hebt, kun je je Pico W Spotify-afstandsbediening gebruiken.

Trage reacties

Het duurt een paar seconden tussen het indrukken van de knop en de reactie. Helaas is dit niet anders.

Je zou kunnen betalen voor een IFTTT upgrade om snellere reactiesnelheden te krijgen. Tenminste, dat is wat ze beloven voor je geld.

Is er een directe manier om Spotify aan te sluiten?

Ja! Spotify heeft een API waarmee je verbinding kunt maken.

Het geeft je aanzienlijk meer controle. Je kunt een draaiknop toevoegen om het volume te regelen. Je kunt een LCD-scherm toevoegen om te laten zien wat er wordt afgespeeld. Bekijk Spotify's console hier.

Verbazingwekkend, maar ook veel moeilijker te programmeren, vooral op een Pico W.

IFTTT maakt het allemaal gemakkelijk omdat zij al het zware werk doen. Als jij het zware werk wilt doen, bekijk dan de authenticatiestroom.

Natuurlijk, wij zijn Raspberry Pi-liefhebbers. Iemand zal het doen. Moet jij het zijn? Of ik? Reageer hieronder.

Bedien je Pico W draadloos met PiCockpit!

Met PiCockpit kunt u uw Pico W draadloos besturen en gegevens opvragen.

Met PiCockpit kunt u waarden krijgen, controleren en PWM gebruiken via een GUI via zijn GPIO applet.

U kunt de statistieken van uw Pico W ook bekijken via de PiStats applet.

PiCockpit integreren in je Pico W is super eenvoudig.

Volg deze handleiding.

Nog minder code schrijven met PiCockpit en de Pico W

PiCockpit maakt het u gemakkelijk om uw GPIO-pinnen aan te sturen zonder code te hoeven schrijven.

Als je kijkt naar handleiding nummer 2Merk op hoeveel code er nodig is om een LED te laten knipperen.

Met onze nieuwe Pico W integratie maakt PiCockpit het zo veel gemakkelijker omdat u helemaal niets hoeft te programmeren. Zelfs niet de WiFi configuratie - dat wordt gedaan met onze setup wizard.

10. Eenvoudige LED-bediening met PiCockpit en Pico W

Als je je LED precies zo hebt geconfigureerd als in tutorial 2, dan hoef je hem alleen nog maar in PiCockpit in te stellen.

Als je het uit codeert, geef je aan op welke pin je LED zit met behulp van led = machine.Pin(2, machine.Pin.OUT)

Op PiCockpit ga je naar je GPIO applet, en scroll je naar "GPIO Output (On/Off)".

Kies BCM02 uit het dropdown menu omdat uw LED op GPIO 2 staat.

Zet vervolgens in de kolom "Controle" de schakelaar om om de LED aan te zetten.

U kunt ook gemakkelijk het Software PWM-gedeelte hieronder gebruiken om de helderheid van uw LED te regelen.

Merk op dat u de vorige instelling moet verwijderen omdat u geen twee uitgangen op dezelfde GPIO kunt hebben.

Als u de regelaar "Control" verschuift, ziet u de helderheid van de LED veranderen.

11. Pico W, 5V ventilator en een transistor, bestuurd door PiCockpit

Laten we iets uitgebreider proberen, maar met dezelfde GPIO Output toggle.

Om enkele praktijkgevallen te illustreren zal ik een 5V ventilator van stroom voorzien met PiCockpit.

Dit is een 5V-ventilator met laag vermogen, afkomstig van mijn Raspberry Pi 4, dus hij valt ruim binnen de uitgangscapaciteit van de Raspberry Pi Pico W.

Maar omdat het een 5V ventilator is, kan ik geen GPIO pin gebruiken. In minder energie-intensieve componenten, zoals een LED, kun je de GPIO een dubbele taak laten vervullen door de component van stroom te voorzien en de "schakelaar" te zijn die hem in- en uitschakelt.

Maar de 5V ventilator zou een te hoge spanning vereisen. Dus, de volgende beste manier is om een transistor in het midden te plaatsen.

Hierdoor kan ik de ventilator van 5V voorzien, terwijl ik er zeker van ben dat ik hem aan en uit kan zetten.

Nogmaals, vanwege PiCockpit heb ik nul programmering gedaan. Ik heb alleen de hardware gedaan, die als volgt bedraad is:

De ventilator is een 5V/0,12A ventilator, aangesloten op 5V aan de positieve kant (rode draad), en de negatieve draad gaat naar het emitterbeen van de transistor.

De transistor is een PN2222 (NPN) transistor, wat betekent dat hij inschakelt wanneer hij een hoog signaal ontvangt.

Van links naar rechts, met het halfronde deel van u af gericht, zijn de benen de Emitter, Base en Collector.

Het basisdeel wordt verbonden met een weerstand van 1K en vervolgens verbonden met GPIO 15.

De collector poot is verbonden met massa.

PiCockpit configureren om met transistor te werken

Nogmaals, super makkelijk.

Ga naar het dropdown menu in de GPIO Output sectie en voeg BCM15 toe.

Als het eenmaal binnen is, kunt u op de pijl naar beneden klikken en de Staatsnamen veranderen in "ventilator uit" en "ventilator aan".

Schakel de schakelaar om en u zou moeten zien dat de ventilator aangaat.

U kunt PiStats ook gebruiken om de temperatuurdaling op uw bord te zien.

Fotoresistor weergeven met behulp van MQTT en Node-RED met Pico W.

Het hoofddoel van deze tutorial is om MQTT te introduceren.

In de vorige tutorials heb ik laten zien hoe je je Pico W kunt gebruiken om gegevens te leveren, maar wat als je een centrale opslagplaats van gegevens in de cloud wilt?

HiveMQ Cloud is een gratis dienst die we kunnen gebruiken om dit doel te bereiken. Door de computers van iemand anders te gebruiken, kunnen we ook de belasting op de Pico W verlichten.

Bovendien heeft MQTT grote voordelen ten opzichte van de eerder gebruikte methoden. Ten eerste is het veel efficiënter in het verzenden van kleine gegevens. De headers van het MQTT-protocol zijn 2 bytes groot. HTTP is ongeveer 4000 keer groter.

Het verminderen van de lokale verwerkingsbelasting en netwerkbelasting betekent een langere batterijlevensduur voor je Pico W, wat perfect is voor projecten op batterijen of zonne-energie.

Fotoresistoraansluiting met de Pico W

Een fotoweerstand (fotocel) is supergemakkelijk aan te sluiten.

Plaats de fotoresistor over de centrale goot van het breadboard.

Verbind vervolgens de 3V3-pin met één kant van de fotoresistor.

Je wilt een ADC-pin aansluiten op de andere kant van de fotoweerstand, dus sluit GPIO 26 aan.

Sluit tenslotte een weerstand van 10K ohm aan van massa naar de fotocel.

HiveMQ Cloud en codering van de Pico W

Als eerste, Meld je hier aan voor HiveMQ Cloud.

Doorloop de setup en maak een cluster aan. Het zal je vragen om AWS of Azure te kiezen. Voor onze doeleinden is er geen verschil.

Klik vervolgens op "Cluster beheren".

Noteer uw Cluster URL en klik op Toegangsbeheer om een nieuwe gebruiker aan te maken. Doorloop de stappen en maak een nieuwe gebruiker aan.

Met deze gegevens kun je nu je Pico W programmeren om gegevens daarheen te sturen.

Codering van de Pico W om fotocelgegevens en MQTTClient te ontvangen

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)

Laten we eerst onze import op orde brengen.

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

De wifi importeren komt uit de vorige tutorials.

Je hebt de umqtt.simple bibliotheek nodig, die kan hier worden gedownload.

Zodra dat is gedownload, kun je het uploaden naar je bord (gids hier).

Je zou deze bestanden op je Pico W moeten hebben.

Maak vervolgens een functie om een waarde te krijgen van de fotoresistor:

photoresistor = ADC(Pin(26))

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

Dit geeft een waarde tot 65535. Hoe helderder, hoe hoger de waarde.

Verbinden met HiveMQ

Om verbinding te maken met HiveMQ, moet je een aantal parameters naar de MQTTClient klasse sturen.

# 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()

Vervang [uw-host-naam] door het adres op uw dashboard. Je moet dit twee keer doen, één keer voor server en een andere voor server_hostname. Vervang [your_client_id] ook door een naam voor je apparaat, zoals "your_picow".

Vervang vervolgens [your-user] en [your-pw] met de gebruiker die je hebt aangemaakt op de pagina Toegangsbeheer (screenshot van de pagina Toegangsbeheer hieronder).

Ter referentie: deze functie stuurt gegevens naar de HiveMQ:

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

Laten we het in onze while lus:

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

    print(brightness)

    publish('picow/brightness', brightness)

    time.sleep(0.1)

Bij het publiceren moet je strings versturen, daarom is brightness = str(readLight()) is er.

Als je gehele getallen of zweven stuurt, zal het programma sterven.

Geef je onderwerp een naam in de functie Publiceren. Zeg, picow/brightnessen voeg dan de waarde toe die je wilt verzenden. In dit geval willen we de stringified lichtwaarde verzenden, brightness.

Je zou de gepubliceerde gegevens moeten kunnen zien wanneer je inlogt op het tabblad Web Client.

Node-RED

Dit zijn gewoon getallen die online staan en op wartaal lijken. Wat als je toegang wilt krijgen tot de gegevens op HiveMQ Cloud en deze grafisch wilt presenteren?

In plaats van je eigen versie te ontwikkelen, kun je ook Node-RED gebruiken.

Met Node-RED kun je heel eenvoudig gegevens uit HiveMQ halen en deze vervolgens presenteren met grafische weergaven.

We gaan een meter maken met Node-RED.

Om te beginnen heb je het volgende nodig nodejs. Bekijk de documentatie van HiveMQ om te zien welke versie wordt aanbevolen.

Zodra je Node hebt geïnstalleerd, moet je een opdrachtprompt/Terminal openen en deze commando's uitvoeren (sluit sudo uit als je op Windows zit):

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

Dit zal node package manager (npm) gebruiken om Node-RED wereldwijd te installeren.

Voer vervolgens Node-RED uit door te typen node-red in de Terminal/opdrachtprompt.

Open je browser en ga naar http://127.0.0.1:1880 of welk adres er ook in je Terminal staat.

Laten we de stroom opbouwen. Sleep een "mqtt in" naar het canvas. Je vindt het onder het tabblad "network" in de linker zijbalk.

We moeten het tabblad configureren, dus dubbelklik op de rechthoek en doe het volgende:

Zorg ervoor dat u in het veld "onderwerp" het volgende toevoegt helderheidaangezien dat is wat je hebt gepubliceerd van de Pico W.

Voeg in "server" een nieuwe toe door op het potloodpictogram te klikken en je komt in het volgende menu.

Vul een nieuw serveradres in en verander de poort in 8883. Vink "Use TLS" aan maar doe geen moeite om nieuwe tls-config toe te voegen.

Ga vervolgens naar het tabblad beveiliging en voeg je aanmeldingsgegevens toe.

Al deze details zijn te vinden in je code wanneer je MQTTClient initialiseert.

Een meter toevoegen

Om een meter toe te voegen, moet je de knooppunt-rood-dashboard.

Op de linkerzijbalk, als u deze niet ziet:

Ga dan naar het menu (rechterbovenknop) -> Palet beheren. Ga dan naar het tabblad Installeren en zoek naar node-red-dashboard. Klik op "Installeren".

Sleep een "meter" naar de rechterkant van de mqtt in rechthoek en verbind ze door een lijn te slepen van mqtt in naar de meter.

Dubbelklik op de rechthoek van de meter en verander het label in "brightness" en het "range" max in 65535.

Geweldig. Laten we nu op "Deploy" drukken.

Als je instellingen correct waren, zie je een groene cirkel en "connected" onder de rechthoek. Zo niet, dan zal je terminal je meer details geven over waarom er een fout is.

Nu je Pico W gegevens levert aan HiveMQ Cloud, is het tijd om het dashboard te bekijken. Bezoek http://127.0.0.1:1880/ui en je zou moeten zien dat de meter regelmatig wordt bijgewerkt.

Uw suggesties zijn welkom.

Laat een reactie achter in het commentaarvak hieronder!