#RaspberryPiPicoW

[draegerit]

Raspberry Pi Pico W - Webseite mit Login absichern

In diesem Beitrag möchte ich dir zeigen, wie du eine Webseite auf dem Raspberry Pi Pico W mit einem Login Dialog absichern kannst.

Wie du eine Webseite auf dem Raspberry Pi Pico W programmierst und veröffentlichst, habe ich dir bereits im Beitrag Raspberry Pi Pico W – Webseite ins Internet veröffentlichen erläutert.

Programmieren einer kleinen Seite mit einem Login Dialog

Erstellen wir zunächst eine kleine Webseite mit den Feldern für Benutzername & Passwort und einer Schaltfläche "Login".

Login Dialog für den Raspberry Pi Pico W Das Styling in CSS und die JavaScript-Dateien lege ich auf einem Server ab: - http://progs.ressourcen-draeger-it.de/raspberrypipicow/login/css/style.css - http://progs.ressourcen-draeger-it.de/raspberrypipicow/login/js/jquery-3.6.3.min.js - http://progs.ressourcen-draeger-it.de/raspberrypipicow/login/js/functions.js Die Webseite schreibe ich zunächst in einem normalen Texteditor wie dem Notepad++. Das macht das Testen der Seite deutlich einfacher, da man nicht immer das Programm neu auf den Mikrocontroller schreiben muss. Da wir später den HTML-Code in eine Variable im MicroPython-Code ablegen wollen, dürfen wir innerhalb des Codes nur die doppelten Anführungszeichen verwenden! Wenn der HTML-Code fertig ist, dann muss dieser noch mit einem Tool komprimiert werden, dazu werden die unnötigen Leerzeilen & Zeilenumbrüche entfernt, hier nutze ich TextFixer. Nachfolgend nun die kleine Seite mit dem formatierten Login Dialog für den Raspberry Pi Pico W. Die Felder "{serverIP}" & "{messages}" werden später im MicroPyton-Code durch die IP-Adresse des Mikrocontrollers bzw. der Meldungen ersetzt. Raspberry Pi Pico W

Anmelden

{messages} Wenn wir diesen HTML-Code nun mit TextFixer komprimieren, erhalten wir folgende reduzierten Text: Raspberry Pi Pico W

Anmelden

JavaScript Funktion zum Absenden der Formulardaten Wenn der Benutzer die Schaltfläche "Login" betätigt, wird eine JavaScript-Funktion ausgeführt. Hier nutzte ich wieder jQuery dieses JavaScript Framework ist sehr leichtgewichtig und vor allem sehr gut Dokumentiert. Wenn die Seite fertig geladen ist, dann binden wir an den Login Button die Funktion "click" welche wiederum die Daten aus den Feldern "inpUsername" & "inpPassword" entnimmt und diese wiederum zu einer Adresszeile zusammenfügt. $( document ).ready(function() { $('#loginBtn').on( "click", function() { var username = $("#inpUsername").val(); var password = $("#inpPassword").val(); window.open("http://"+serverIp+"?username="+username+"&password="+password,'_self'); }); }); Hier finden wir auch wieder unser Feld "serverIp" selcher im HTML-Code als JavaScript Block eingefügt wurde. Styling per CSS Das Styling des Dialoges habe ich in einer separaten CSS Datei abgelegt, dieses hält den eigentlichen HTML-Code sehr schlank und belegt nicht zusätzlich Speicher auf dem Mikrocontroller. h2{text-align:center;} input{border-radius: 4px;border: 1px solid gray;height: 26px;padding: 3px;} input:focus{background-color:#FEF9E7;outline: none !important;border: 1px solid gray;} input{transition-duration: 0.4s;border-radius: 8px;padding: 10px 24px; background-color: white; color: black; border: 2px solid #008CBA;} input:hover {background-color: #008CBA; color: white;} input, input{width:200px} label{display: inline-block;width: 95px;text-align: right;padding-right: 10px;} .outer{width:250px;margin:0px auto;border:1px solid #BFC9CA;padding:25px;box-shadow: #E5E8E8 6px 6px 2px; margin-top: 60px;border-radius:2px;} .messages{color:red;}

Programmieren in MicroPython auf dem Pi Pico W

Da wir das Frontend soeben fertiggestellt haben, müssen wir das passende Backend entwickeln. Gerne möchte ich dir hier meine Lösung präsentieren. Die Werte für Benutzername & Passwort werden als GET Parameter an die URL gehängt, dies ist ein kleines Sicherheitsrisiko da jeder dieses Passwort lesen kann. Exkurs - Aufbau einer WLAN-Verbindung am Pi Pico W Schauen wir uns zunächst einmal kurz an wie man eine WLAN-Verbindung am Pi Pico W aufbaut. Den nachfolgenden Code habe ich bereits im Beitrag Raspberry Pi Pico W – Webseite ins Internet veröffentlichen vorgestellt und erläutert. Jedoch dient dieser als Ausgangsbasis für unser Login Dialog. import network import socket import time from machine import Pin ssid = '***' password = '****' wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect(ssid, password) html = 'Raspberry Pi Pico W

Hello World!

' print('waiting for connection...') max_wait = 10 while max_wait > 0: if wlan.status() < 0 or wlan.status() >= 3: break max_wait -= 1 print('.', end='') time.sleep(1) print('') if wlan.status() != 3: raise RuntimeError('network connection failed') else: print('connected') status = wlan.ifconfig() print('ip = ' + status) addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) print('listening on', addr) while True: try: cl, addr = s.accept() print('client connected from', addr) cl.send('HTTP/1.0 200 OKrnContent-type: text/htmlrnrn') cl.send(html) cl.close() except OSError as e: cl.close() print('connection closed')

Login Dialog einbauen

Zunächst legen wir ein Feld für den HTML-Code unserer Seiten an. Zum einen für den Login Dialog und eine Seite, wenn der Benutzer erfolgreich eingeloggt wurde. htmlPage = 'Raspberry Pi Pico W

Anmelden

{messages}' loggedInPage = "Raspberry Pi Pico W

Hallo {username}

" Dictionary mit Benutzern Die Benutzer speichern wir in einem Dictionary, wobei der Key der Benutzername ist. users = { "sdraeger": { "password":"draeger" }, "mmustermann": { "password":"mustermann" } } Auslesen der GET Parameter Wenn wir die Schaltfläche Login betätigen, dann wird der HTTP-Request zusammengebaut mit den Benutzername & Passwort aus den entsprechenden Feldern. Diese Werte finden wir in unserem Code wieder, wenn wir uns das Request Objekt ausgeben: cl, addr = s.accept() print('client connected from', addr) request = cl.recv(1024) request = str(request) print(request) Diesen Text können wir nun parsen und die Werte entnehmen. b'GET /?username=sdraeger&password=draeger HTTP/1.1rnHost: Parsen des Requests Wie man erkennt, beginnen die Parameter am Index 8 und enden mit " HTTP". Hier können wir recht einfach mit Python Logik an diesen Substring gelangen. Dann prüfen wir, ob die Schlüsselwörter "username" und "password" darin enthalten sind. Wenn dieses nicht der Fall ist, soll der Login Dialog ausgeliefert werden. params = request if "username" in params and "password" in params: values = params.split("&") username = values.split("=") password = values.split("=") Wenn diese Schlüsselwörter enthalten sind, werden die Werte geparst. Im nächsten Schritt muss nun geprüft werden ob der Benutzername als Key im Dictionary "users" hinterlegt ist. if username in users: messages.append("user found") Wenn der Benutzername hinterlegt wurde, dann wird eine Message gespeichert und das Passwort geprüft. Wenn wiederum das Passwort korrekt ist, dann wird die Variable "loginOK" auf True gesetzt andernfalls verbleibt diese auf False. if users ==password: messages.append("login OK") loginOk = True else: messages.append("login fail")

Auswerten des Login Prozesses und ausliefern der Seite

Wenn die Werte geprüft wurden, dann soll eine entsprechende Seite ausgeliefert werden. if loginOk: cl.send(loggedInPage.format(username=username)) else: if messages: loginMessages = messages else: loginMessages = "" cl.send(htmlPage.format(serverIp=serverIpAdress, messages=loginMessages)) In meinem Fall zeige ich dem angemeldeten Benutzer lediglich eine kleine Seite mit einer Begrüßung an.

Wenn der Login nicht erfolgreich war, dann wir im Dialog eine entsprechende Meldung ausgegeben.

fertiger MicroPython-Code

Hier nun der komplette MicroPython-Code zum einfachen Download als ZIP-Datei oder zum kopieren. Pi Pico W - Login DialogHerunterladen import network import socket import time from machine import Pin ssid = '***' password = '***' users = { "sdraeger": { "password":"draeger" }, "mmustermann": { "password":"mustermann" } } htmlPage = 'Raspberry Pi Pico W

Anmelden

{messages}' loggedInPage = "Raspberry Pi Pico W

Hallo {username}

" wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect(ssid, password) html = 'Raspberry Pi Pico W

Hello World!

' print('waiting for connection...') max_wait = 10 while max_wait > 0: if wlan.status() < 0 or wlan.status() >= 3: break max_wait -= 1 print('.', end='') time.sleep(1) print('') if wlan.status() != 3: raise RuntimeError('network connection failed') else: print('connected') status = wlan.ifconfig() print('ip = ' + status) addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) print('listening on', addr) while True: try: cl, addr = s.accept() print('client connected from', addr) request = cl.recv(1024) request = str(request) print(request) params = request serverIpAdress = status messages = loginOk = False cl.send('HTTP/1.0 200 OKrnContent-type: text/htmlrnrn') if "username" in params and "password" in params: values = params.split("&") username = values.split("=") password = values.split("=") if username in users: messages.append("user found") if users ==password: messages.append("login OK") loginOk = True else: messages.append("login fail") else: messages.append("user not found") if loginOk: cl.send(loggedInPage.format(username=username)) else: if messages: loginMessages = messages else: loginMessages = "" cl.send(htmlPage.format(serverIp=serverIpAdress, messages=loginMessages)) cl.close() except OSError as e: cl.close() print('connection closed') Read the full article

[briantw]

Raspberry Pi Pico W Gets Official Bluetooth Support In another stride toward enhancing the functionality of the Raspberry Pi Pico W, CEO Eben Upton has announced that the wireless-enabled variant of the Pico platform, official Bluetooth support has been successfully integrated. You won’t need to buy a new board, either, as the existing ones can now harness the power of Bluetooth: https://elektor.link/PicoWOfficialBT

#RaspberryPiPico #RaspberryPi #Bluetooth #RaspberryPiPicoW

[draegerit]

Gruseliges Raspberry Pi Pico Projekt: Die Spooky Box für Halloween

Passend zur kommenden Halloween-Zeit möchte ich dir heute ein passendes kleines Projekt vorstellen, welches du easy an einem Wochenende erstellen kannst, es ist eine Spooky Box mit Soundausgabe. Als Mikrocontroller verwende ich den Raspberry Pi Pico in der Ausführung mit WiFi / Bluetooth.

Die Idee dazu bekam ich vom Leser meines Blogs, welcher mir per Mail ein ähnliches Projekt vorgestellt hat. Dieses war jedoch mit dem weniger verbreiteten Calliope Mini. Der Vorteil des Calliope Mini ist jedoch, dass dieser besonders für Anfänger einfacher zu programmieren ist. Jedoch auch die Programmierung in MicroPython ist, wie du gleich sehen wirst, nicht allzu schwierig.

Teileliste für die Spooky Box mit einem Raspberry Pi Pico

Wenn du die Spooky Box nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico oder Pico W, - ein Micro-USB-Datenkabel, - eine Lochrasterplatine, - zwei 40 Pin Buchsenleisten, - zwei LEDs mit Vorwiderstände (220 Ohm), - einen Taster, - einen Servomotor Typ SG90, - einen Piezo Buzzer

Für den Aufbau auf der Lochrasterplatine benötigst du noch zusätzlich: - einen Lötkolben, - Lötzinn & Lötfett, - eine hitzebeständige Unterlage - einen kleinen Seitenschneider, - Litze / Draht in unterschiedlichen Farben

Spooky Box

Die Box selber habe ich aus dem örtlichen Tedi Mark für 3 € gekauft, zusätzlich noch Acrylfarbe und Pinsel, somit ergab dieses genau 6 €. Wenn du das ganze online suchst, dann findest du hier eine kleine Liste: - eine kleine Schatzkiste aus Holz, - Acrylfarbe, - Pinselset, Der Vorteil an der Acrylfarbe ist, dass diese recht schnell trocknet. Du kannst deine Spooky Box natürlich nach Belieben anders bemalen und bekleben.

Aufbau der Schaltung am Raspberry Pi Pico

Nachdem die Box fertig bemalt ist und trocknen muss, kümmern wir uns um die Schaltung am Raspberry Pi Pico.

Programmieren

Das Programm erstellen wir wie erwähnt in MicroPython, dafür nutze ich die Thonny IDE. Das Gute gleich vorweg, wir benötigen keine zusätzliche Bibliothek für dieses Projekt, d.h. du könntest auch rein theoretisch den MU-Editor verwenden. Nachfolgend folgt nun eine Schritt-für-Schritt-Anleitung, wie du das Programm aufbaust. Schritt 1 - Abspielen des Halloween Sounds am Raspberry Pi Pico Die Spooky Box soll bei Aktivierung einen Sound abspielen, diesen habe ich jedoch lediglich für ein Arduino Programm gefunden, dieses habe ich für MicroPython umgeschrieben. #Module zum ansteuern der GPIOs und #erzeugen eines PWM Signals from machine import Pin, PWM from utime import sleep #der Buzzer ist am GPIO1 angeschlossen buzzer = PWM(Pin(1)) #Tonname & Frequenz in einem Dictionary mappen tones = { "cs6": 1109, "fs5" : 740, "d6" : 1175, "c6" : 1047, "f5" : 698, "b5" : 988, "e5" : 659, "bf5" : 932, "ef5" : 622, "b4" : 494, "g5" : 784, } #Töne vom Lied song = #Spielt einen Ton in einer Frequenz ab def playtone(frequency): buzzer.duty_u16(1000) buzzer.freq(frequency) #Verstummt den Buzzer def bequiet(): buzzer.duty_u16(0) #Spielt das Lied ab def playsong(mysong): #läuft über die Liste mit den Tönen for i in range(len(mysong)): #abspielen eines Tones aus der Liste mit dem Index i playtone(tones]) #kleine Pause von 200 Millisekunden sleep(0.2) #verstummen des Buzzers bequiet() #Abspielen des Liedes playsong(song) Der Code bewirkt lediglich das, dass Lied auf dem Piezo Buzzer abgespielt wird. Schritt 2 - Auslesen des Fotowiderstandes Der Fotowiderstand ist am ADC0 / GP26 angeschlossen und wird als analoger Wert ausgelesen. #Module für das auslesen des LDR from machine import Pin, ADC from utime import sleep #der LDR ist am GPIO26 / ADC0 angeschlossen adc = ADC(0) #Starten einer Endlosschleife while True: #auslesen des LDR und #ausgeben auf der seriellen Schnittstelle print(adc.read_u16()) #kleine Pause von 300 Millisekunden sleep(0.3) Wenn du den obrigen Code ausführst, dann wird kontinuierlich die Helligkeit gemessen und ausgegeben. Solltest du deinen Finger auf diesen Sensor legen, so ändert sich der Wert in der Konsole entsprechend. Auf diesen Wert können wir jetzt reagieren und somit erkennen, ob der Deckel unserer Spooky Box geöffnet wurde. Schritt 3 - Taster interrupt erstellen Wenn der Taster betätigt wird, soll der Sound aufhören zu spielen und die kleine Pappfigur soll abgesenkt werden. Dazu müssen wir einen Interrupt erstellen, der Pi Pico bietet an jeden der GPIOs die Möglichkeit ein Interrupt anzuhängen. #Module zum ansteuern der GPIOs from machine import Pin #der Taster ist am GPIO5 angeschlossen, #zusätzlich wird dieser über den internen PullUp #Widerstand verbunden button = Pin(5, Pin.IN, Pin.PULL_UP) #Funktion welche ausgeführt werden soll #wenn der Taster betätigt wird. def button_handler(pin): print("Hello, world!") #konfigurieren eines Interrupts button.irq(trigger = machine.Pin.IRQ_RISING, handler = button_handler) #Starten einer Endlosschleife, #diese wird benötigt damit das Programm sich nicht selbstständig beendet while True: pass Wenn du den Taster betätigst, wird die Funktion "button_handler" ausgeführt. Egal, was gerade parallel auf dem Mikrocontroller ausgeführt wird. Schritt 4 - Steuern des Servomotors Der Servomotor wird per PWM Signal gesteuert, hier musst du noch zusätzlich ins Datenblatt des verwendeten Servos schauen. Wenn du wie ich den Servo SG90 verwendest, dann hat dieser die Frequenz von 50 Hz für einen Schritt. #Module zum steuern der GPIOs from machine import Pin, PWM from utime import sleep #Servomotor am GPIO0 angeschlossen servo = PWM(Pin(0)) #der Servomotor arbeitet mit einer #Frequenz von 50 Hz servo.freq(50) #0° hat ein Dutycycle von.. grad0 = 500000 #90° hat ein Dutycycle von.. grad90 = 1500000 #Starten einer Endlosschleife while True: #Servo auf 90° bewegen servo.duty_ns(grad90) #kleine Pause von 500 Millisekunden sleep(0.5) #Servo auf 0° bewegen servo.duty_ns(grad0) #kleine Pause von 500 Millisekunden sleep(0.5) Der Code lässt den Servomotor immer zwischen den Winkeln 0° und 90° bewegen. Probleme mit zwei unterschiedliche PWM Signale Der Piezo Buzzer & der Servomotor werden beide über PWM Signale gesteuert. Das Problem, welches wir haben ist, dass der Pi Pico lediglich ein Signal zulässt. Wir müssen also nun etwas herumtricksen, dass der Piezo Buzzer das Lied abspielt, aber der Servo auch gesteuert werden kann. Meine Lösung hierzu ist, dass ich den jeweils nicht benötigten Aktor auf einen GPIO zuweise, welcher nicht belegt ist, somit ist der Aktor quasi deaktiviert. Bevor ich diesen wieder verwende, muss dieser dann lediglich wieder korrekt zugewiesen werden. from machine import Pin, PWM from utime import sleep servo = None buzzer = None grad0 = 500000 grad90 = 1500000 tones = { "cs6": 1109, "fs5" : 740, "d6" : 1175, "c6" : 1047, "f5" : 698, "b5" : 988, "e5" : 659, "bf5" : 932, "ef5" : 622, "b4" : 494, "g5" : 784, } song = def playtone(frequency): if isinstance(buzzer, Pin): initBuzzer() buzzer.duty_u16(1000) buzzer.freq(frequency) def bequiet(): if isinstance(buzzer, Pin): initBuzzer() buzzer.duty_u16(0) def playsong(mysong): for i in range(len(mysong)): if (mysong == "P"): bequiet() else: playtone(tones]) sleep(0.2) bequiet() #GPIO des Servomotor initialisieren def initServo(): global servo servo = PWM(Pin(0)) servo.freq(50) #konfigurierten Pin ändern def resetServo(): global servo servo = Pin(8, Pin.IN, Pin.PULL_UP) #GPIO Buzzer initialisieren def initBuzzer(): global buzzer buzzer = PWM(Pin(1)) #konfigurierten Pin ändern def resetBuzzer(): global buzzer buzzer = Pin(9, Pin.IN, Pin.PULL_UP) while True: initServo() servo.duty_ns(grad90) sleep(0.5) servo.duty_ns(grad0) sleep(0.5) resetServo() sleep(0.2) initBuzzer() sleep(0.2) playsong(song) sleep(0.2) resetBuzzer() sleep(0.2) Im Video siehst du nun das zunächst der Servo von 0° zu 90° wechselt und danach wird das Lied abgespielt. Das fertige Programm für die Spooky Box am Raspberry Pi Pico Hier jetzt das fertige Programm zum Download: MicoPython Code für die Halloween SpookyBox Read the full article

[draegerit]

Raspberry Pi Pico BASIC #5 – Sensordaten loggen

In diesem Beitrag zeige ich dir, wie du am Raspberry Pi Pico mit BASIC (Picomite) Sensordaten auf eine SD-Karte loggen kannst.

Wie du eine SD-Karte an den Raspberry Pi Pico anschließen kannst und auf dem Dateisystem navigierst, habe ich dir bereits im Beitrag Raspberry Pi Pico BASIC #4 – SD-Karte anschließen gezeigt.

Benötigte Ressourcen für dieses Projekt

Wenn du das kleine Beispiel nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro USB-Datenkabel, - ein SD-Karten Modul, - ein DS18B20 Temperatursensor, - diverse Breadboardkabel, männlich-weiblich, 10 cm

Bauteile für die Schaltung In meinem Fall nutze ich für den Temperatursensor DS18B20 ein kleines Board, auf welchem die korrekte Schaltung bereits verdrahtet ist, somit ist der Anschluss an den Mikrocontroller deutlich einfacher.

Temperatursensor DS18B20 auf Adapterplatine

Aufbau der Schaltung

Für den Aufbau der Schaltung verwende ich zusätzlich ein Dual GPIO Expander für den Raspberry Pi Pico / Pico W. Alternativ kannst du den Pi Pico auch auf ein 400 Pin Breadboard stecken und von dort die Pins abgreifen.

Schaltung - Raspberry Pi Pico mit SD-Karten Modul & Temperatursensor DS18B20 Der Schaltung können wir folgenden Anschlussplan entnehmen: KomponenteRaspberry Pi PicoDS18B20GNDGNDDATAGP15VCC5V / VBUSSD-KartenleserGNDGND+5V5V / VBUSCSGP22MOSIGP19SCKGP18MISOGP16

Aufbau der Schaltung und programmieren auf dem Mikrocontroller

Im nachfolgenden YouTube-Video erläutere ich dir, wie du die Schaltung aufbaust und das kleine Programm zum Loggen der Sensordaten auf dem Mikrocontroller schreibst. https://youtu.be/umfOHjo7Az8

Programmieren im Full-Screeneditor in Picomite

Den Code erstellen wir in zwei Schritten, zum einen das Auslesen der Temperatur vom Sensor und danach das Schreiben in eine Datei auf der SD-Karte. Programmieren des Temperatursensors DS18B20 in Picomite Starten wir zunächst damit, den Temperatursensor DS18B20 zu programmieren. TEMPR START GP15 PRINT "Temperatur: " TEMPR(GP15) " C" Wenn wir den Code nun in eine kleine For-Schleife schreiben, dann können wir mehrere Werte nacheinander messen und auf der Konsole ausgeben.

Schreiben einer Datei auf der SD-Karte Nachdem wir soeben die Sensordaten ausgelesen haben, möchten wir diese auf die SD-Karte schreiben. Im ersten Schritt müssen wir eine Datei erzeugen und diese öffnen, dabei müssen wir darauf achten, dass wir den Modus zum Anfügen von Daten verwenden, denn sonst werden die alten immer überschrieben. Open "b:/sensordaten.txt" For output As #1 TEMPR START GP15 For i = 0 To 10 Step 1 Print #1, "Temperatur: " TEMPR(GP15) " C" Next i Close #1 Die Daten sind jetzt auf der SD-Karte und können vom Computer (ein entsprechendes Lesegerät vorausgesetzt) gelesen werden.

Schreiben einer CSV Datei und importieren in Excel

Wenn wir die Sensordaten weiterverarbeiten möchten, dann ist es sinnvoll diese in einem lesbaren Format zu speichern. Das einfachste Format ist hier das CSV Format. Bei diesem werden die Daten Zeilenweise und mit einem Zeichen separiert getrennt gespeichert. Normalerweise trennt man diese Daten mit einem Komma. In meinem Fall möchte ich jedoch das Semikolon nutzen ";", denn der Temperaturwert wird in Deutsch mit einem Komma dargestellt. Natürlich könnte man auch die Temperaturwerte mit doppelten Anführungszeichen umgeben und somit trotzdem das Komma nutzen. TEMPR START GP15 Dim value As Float Open "b:/sensordaten.csv" For output As #1 For i = 0 to 100 Step 1 value = TEMPR(GP15) Print #1, i ";" value Print i "-" value Next i Close #1 Als Ergebnis erhalten wir eine Datei mit den Werten des Temperatursensors. In dem Code gebe ich zusätzlich noch den Wert auf der Konsole aus, damit man den Fortschritt des Schreibens sieht.

CSV-Datei mit Sensordaten vom DS18B20 Sensor Read the full article

[draegerit]

WisdPi ArduPico - Raspberry Pi Pico Adapter

In diesem Beitrag möchte ich dir den Raspberry Pi Pico Adapter ArduPico von der Firma WisdPi vorstellen und aufzeigen, was du damit anstellen kannst.

Für den Raspberry Pi Pico & Pico W habe ich dir bereits einige Beiträge auf diesem Blog veröffentlicht. - Raspberry Pi Pico W – Webseite ins Internet veröffentlichen - Raspberry Pi Pico W – Zeit aus dem Internet lesen und auf einem Display anzeigen - Raspberry Pi Pico W – Taster mit Interrupts in Micropython - Raspberry Pi Pico W & Bluetooth Hier möchte ich dir eine Adapterplatine zeigen, um den Raspberry Pi Pico noch universeller einsetzen zu können.

Bezug der Adapterplatine ArduPico

Diese Platine habe ich im Onlineshop von WisdPi für 9,9 $ zzgl. Versandkosten erstanden. Leider bietet der Shop nur Bezahlung per VISA oder Mastercard an. Lieferumfang Zum Lieferumfang gehört neben der Platine, welche bereits mit den Buchsenleisten bestückt ist, noch zwei Sätze Stift sowie Buchsenleisten.

Besonderheiten des ArduPico

Zunächst einmal ist der ArduPico für das Vorgängermodell Raspberry Pi Pico ausgelegt. Das erkennt man vor allem daran, dass die Debug Pins am Ende der Markierung angebracht sind. Beim neuen Pi Pico W sind diese vor dem WLAN-Chip.

Auf der Platine des ArduPico findest du einen RGB NeoPixel sowie einen Taster für RESET.

Anschluss eines Raspberry Pi Pico an ArduPico

Den Raspberry Pi Pico kannst du entweder direkt auf die Platine löten oder du nutzt die Stift & Buchsenleisten. In meinem Fall habe ich mir einen zusätzlichen Raspberry Pi Pico W gekauft, welchen ich via Stiftleisten mit dem ArduPico verbinde.

Das Löten am ArduPico gestaltete sich recht schwierig, ich denke die Lötaugen auf der Platine sind entweder von geringer Qualität oder aber mein Lötzinn war nicht geeignet. Das Problem während des Lötens waren das, dass Lötzinn nicht gehalten hat.

Durch den Formfaktor des Arduino UNOs kann man prima zbsp. ein Prototype Shield auf diesen stecken oder auch andere wie das MP3 Shield, Motodriver Shield etc.

Dem ArduPico spendiere ich zusätzlich noch einen gedruckten Rahmen inkl. 400 Pin Breadboard. Dieses erleichtert den Aufbau von Schaltungen deutlich.

ArduPico mit Raspberry Pi Pico W und Breadboard

Programmieren mit dem ArduPico und Raspberry Pi Pico W

Wie du den Raspberry Pi Pico & Pico W programmierst, habe ich dir bereits in diversen Beiträgen auf meinem Blog vorgestellt. Hier möchte ich zunächst einmal eine kleine Schaltung zeigen und später werde ich dir ein paar Beiträge mit Sensoren & Aktoren zeigen, welche über ein Base Shield v2 angeschlossen werden. - Raspberry Pi Pico W – Zeit aus dem Internet lesen und auf einem Display anzeigen - Raspberry Pi Pico W & Bluetooth - Raspberry Pi Pico W – Taster mit Interrupts in Micropython

Beispiel - "Hello World!"

Starten wir zunächst mit einem typischen Beispiel, der Ausgabe von "Hello World!" auf der seriellen Schnittstelle. from time import sleep while True: print("Hello World!") sleep(0.5) Wenn man den Code nun in der Datei code.py auf dem Raspberry Pi Pico speichert und ausführt, dann sollte auf der Konsole die Ausgabe "Hello World!" erscheinen.

Damit haben wir auch nun validiert, dass der Pi Pico korrekt mit dem ArduPico verbunden ist.

Beispiel - RGB Neopixel steuern

Auf dem ArduPico ist ein NeoPixel vom Typ WS2812 verbaut, welcher an dem GPIO13 / Pin 17 angeschlossen ist. Die RGB Farbcodes kannst du dir von der Webseite https://www.color-hex.com/ ausgeben lassen, natürlich sind die Farben nicht zu 100 % identisch, aber diese kommen schon sehr dich dran. import neopixel from time import sleep colors = ( (14,30,236), #blau (52,201,130), #gruen (255,72,91), #rot (251,255,0), #gelb ) p = machine.Pin(13) n = neopixel.NeoPixel(p, 1) while True: for color in colors: n = color n.write() sleep(0.5) Der Code erzeugt nun ein wechsel der Farben an dem NeoPixel. Read the full article

[draegerit]

Raspberry Pi Pico BASIC #6 – RealTimeClock programmieren

In diesem Beitrag möchte ich dir gerne zeigen, wie du eine RealTimeClock (kurz RTC) am Raspberry Pi Pico mit Picomite in BASIC programmierst.

Den Raspberry Pi Pico mit Picomite habe ich dir bereits in diversen Beiträgen vorgestellt. - BASIC Programmierung am Raspberry Pi Pico W, - Raspberry Pi Pico BASIC #1 – Überblick - Raspberry Pi Pico BASIC #2 – Quellcode organisieren - Raspberry Pi Pico BASIC #3 – Autostart - Raspberry Pi Pico BASIC #4 – SD-Karte anschließen In meinem letzten Beitrag habe ich dir auch gezeigt, wie man Sensordaten von einem Temperatursensor auf eine SD-Karte schreiben kann. In diesem Beitrag möchte ich gerne an diesen Beitrag anknüpfen und die Sensordaten mit einem Zeitstempel speichern. Im Handel erhältst du die RTCs bereits ab 3 € welche meist für den Arduino angepriesen werden.

Auf der RTC ist eine Batterie verbaut, welche die interne Uhr weiterlaufen lässt und so auch ein Zeitstempel ausgelesen werden kann, wenn der Mikrocontroller mal eine Zeit X ohne Strom war.

Benötigte Ressourcen für dieses Projekt

Wenn du die Schaltung nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro-USB-Datenkabel, - eine RTC DS3231 mit I2C Schnittstelle, - vier Breadboardkabel, weiblich-weiblich, 10 cm, - optional ein GPIO Dual Expanderboard

Aufbau der Schaltung

Mit den vier Breadboardkabeln schließen wir die RealTimeClock an den Raspberry Pi Pico wie folgt an.

Raspberry Pi Pico mit RealTimeClock (RTC) An den Raspberry Pi Pico kannst du an mehreren Pins ein I2C Device anschließen. Nachfolgend findest du das Pinout.

Pinout des Raspberry PI Pico

Einrichten der RTC in Picomite auf dem Raspberry Pi Pico

Bevor wir den Zeitstempel (Datum & Uhrzeit) von der RTC lesen können, müssen wir diese einrichten. Zunächst müssen wir die I2C Pins aktivieren. OPTION SYSTEM I2C 1, 0 oder OPTION SYSTEM I2C GP0, GP1 Nachdem die ENTER Taste betätigt wurde, startet der Pi Pico neu und danach setzen wir den initialen Zeitstempel mit dem nachfolgenden Befehl. RTC SETTIME Jahr, Monat, Tag, Stunde, Minute, Sekunde zbsp. RTC SETTIME 2023, 4, 29, 18, 0, 0 Mit dem Befehl nachfolgenden Befehl kannst du die RTC beim Starten und jede Stunde

Auslesen von Datum & Uhrzeit von der RealTimeClock

Nachdem wir nun den Zeitstempel gesetzt haben, können wir die beiden Werte Datum & Uhrzeit von dieser lesen. RTC GETTIME Print DATE$ Print TIME$

Ausgabe von Datum & Uhrzeit auf dem Pi Pico mit einer RTC Damit wir aus den Feldern DATE$ und TIME$ die Werte lesen können, müssen die mit dem Befehl "RTC GETTIME" befüllt werden. Wir können dieses jedoch etwas automatisieren, indem wir die nachfolgende Option für die RTC setzen. OPTION RTC AUTO ENABLE

Beispiel - Sensordaten mit Zeitstempel auf SD-Karte schreiben

Im letzten Beitrag hatte ich dir gezeigt, wie du die Sensordaten von einem einfachen digitalen Temperatursensor DS18B20 auf eine SD-Karte schreiben kannst. Jetzt möchte ich statt des Index einen Zeitstempel zu jedem Wert speichern. Aufbau der Schaltung - RTC, DS28B20 & SD-Kartenleser Die RTC lässt sich wie nachfolgend gezeigt in die ggf. bereits bestehende Schaltung integrieren.

Schaltung - Pi Pico mit DS18B20, RTC & SD-Kartenleser Für den Temperatursensor DS18B20 habe ich ein kleines Board auf welchem bereits die Schaltung mit dem 4,7 kOhm Widerstand verbaut ist.

Aufbau der Schaltung - Raspberry Pi Pico mit Realtimeclock, Temperatursensor DS18B20 und SD-Kartenleser

Programmieren im Fullscreen-Editor in Picomite

Erweitern wir jetzt das Programm um den Zeitstempel. TEMPR START GP15 Dim value As Float Open "b:/sensordaten.csv" For output As #1 RTC GETTIME For i = 0 to 100 Step 1 value = TEMPR(GP15) Print #1, DATE$ " " TIME$ ";" value Print i DATE$ " " TIME$ "-" value Next i Close #1 Die CSV Datei auf der SD-Karte enthält nun den Zeitstempel sowie die Sensordaten getrennt durch ein Semikolon.

Read the full article

[draegerit]

Raspberry Pi Pico W - programmieren einer Wetterstation mit ChatGPT

In diesem Beitrag möchte ich dir zeigen, wie du eine Wetterstation am Raspberry Pi Pico W mit der Hilfe von ChatGPT programmieren kannst.

Zum Raspberry Pi Pico W habe ich dir bereits einige Beiträge verfasst und eine Wetterstation habe ich dir ebenfalls bereits mit dem Arduino & ESP32 gezeigt. Hier soll es nun darum gehen, wie die Daten eines DHT22 Sensors auf einem OLED-Display angezeigt werden. Dieses kann man sich sehr einfach zu Recht googeln und hätte auch sehr wahrscheinlich innerhalb weniger Sekunden einen fertigen Beitrag gefunden, wo man den Code 1:1 kopieren könnte. Jedoch möchte ich ebenfalls probieren, ob ChatGPT in der Lage ist ein Entwickler zu unterstützen. Im nachfolgenden YouTube-Video erläutere ich dir ausführlich, wie du die Schaltung aufbaust und dabei ChatGPT nutzen kannst. https://youtu.be/xeMgLC2KiYw

Aufbau der Schaltung

Fangen wir zunächst an und bauen die Schaltung auf. Dazu müssen wir ermitteln, welche Bauteile / Komponenten wir benötigen.

Die nächste Frage wäre nun, wie man diese Komponenten miteinander verbindet. Das Problem war hier, dass die Antwort von ChatGPT falsch war und die falschen Pins für SDA & SCL benannt wurden. Aber nach einer kurzen Erläuterung meinerseits im Chat wurde eine korrekte Tabelle mit den Anschlüssen ausgegeben.

Wenn wir die Komponenten wie in der Tabelle beschrieben angeschlossen haben, dann sollte die Schaltung wie folgt aussehen.

Flashen des Raspberry Pi Pico W

Zunächst flashen wir den Raspberry Pi Pico W mit dem aktuellen Flash-File von https://www.raspberrypi.com/documentation/microcontrollers/micropython.html. Auf der genannten Seite bekommst du die beiden UF2-Dateien für das Model, mit und ohne WiFi Support, je nach Model musst du die eine oder andere Datei wählen! Die heruntergeladene UF2-Datei wird per Drag'n Drop auf den Mikrocontroller kopiert, dazu muss dieser jedoch in einem speziellen Modus gestartet werden. Auf dem Mikroconroller Raspberry Pi Pico W befindet sich ein Taster welcher mit "BOOTSEL" beschriftet ist, dieser wird gedrückt gehalten und dann der Mikrocontroller mit dem Computer verbunden wird. Wenn der Mikrocontroller dann erkannt und das Laufwerk eingebunden wurde, kann dieser Taster losgelassen werden.

Code für den Sensor und das OLED-Display erzeugen lassen

Wenn wir nun die Schaltung aufgebaut haben, benötigen wir noch den Code zum DHT22 Sensor und zum OLED-Display. Mit der nachfolgenden Anfrage erhalte ich den Code für diese Komponenten.

Die Schlüsselwörter sind hier unter anderem "Micropython" & "Raspberry Pi Pico W". Wenn wir einen anderen Mikrocontroller verwenden würden oder eine andere Sprache, dann müssten wir dieses hier logischerweise entsprechend anpassen. Code für den DHT22 Sensor Für den DHT22 Sensor benötigen wir keine zusätzliche Bibliothek, diese ist bereits in Micropython enthalten. Der nachfolgende Code erzeugt auf der Console die Ausgabe von der Temperatur sowie für die rel. Luftfeuchtigkeit. import machine import dht d = dht.DHT22(machine.Pin(26)) d.measure() temperature = d.temperature() humidity = d.humidity() print("Temperature: ", temperature) print("Humidity: ", humidity) Code für das OLED-Display Für die Ausführung / Kompilierung des Codes benötigen wir zusätzlich noch eine Bibliothek. Diese können wir in der Thonny IDE installieren, in dem über Extras > Verwaltete Pakete... navigieren und dort nach "ssd1306" (1) suchen. In den Suchergebnissen wählen wir den ersten Punkt "micropython-ssd1306" (2) und im nächsten Dialog die Schaltfläche "Installieren". Wenn der Vorgang abgeschlossen ist, dann können wir den Dialog über die Schaltfläche "Schließen" (4) verlassen.

Nachdem die Bibliothek erfolgreich installiert wurde, kann der nachfolgende Code auf dem Mikrocontroller ausgeführt werden. import machine import ssd1306 i2c = machine.I2C(0, scl=machine.Pin(21), sda=machine.Pin(20)) display = ssd1306.SSD1306_I2C(128, 64, i2c) display.fill(0) display.text("Temperature: ", 0, 0) display.text(str(temperature), 0, 10) display.text("Humidity: ", 0, 20) display.text(str(humidity), 0, 30) display.show()

Kumulierter Code von ChatGPT für die Wetterstation am Raspberry Pi Pico W

Wenn wir nun die beiden Codestücke zusammenfügen, dann ergibt dieser nachfolgender Code: import machine import ssd1306 import dht from time import sleep d = dht.DHT22(machine.Pin(26)) i2c = machine.I2C(0,scl=machine.Pin(21), sda=machine.Pin(20)) display = ssd1306.SSD1306_I2C(128, 64, i2c) while True: d.measure() temperature = d.temperature() humidity = d.humidity() display.fill(0) display.text("Temperature: ", 0, 0) display.text(str(temperature)+"C", 20, 10) display.text("Humidity: ", 0, 25) display.text(str(humidity)+"%", 20, 35) display.show() sleep(5) Wenn der obige Code auf dem Raspberry Pi Pico W ausgeführt wird, dann erhalten wir die Daten für die Temperatur sowie für die relative Luftfeuchtigkeit.

fertige Schaltung mit ausgeführten Code für die Wetterstation Read the full article

[draegerit]

Raspberry Pi Pico W & Bluetooth

In diesem Beitrag möchte ich dir zeigen, wie du das Bluetooth Modul HC-06 am Raspberry Pi Pico W mit Micropython programmiert wird.

Raspberry Pi Pico W & Bluetooth Eigentlich bräuchten wir kein zusätzliches Modul, denn der Mikrocontroller verfügt über den Chip CYW43438 von Infineon (siehe Beitrag Raspberry Pi Pico W mit Infineon CYW43438 Chip). Aber die Bluetooth-Funktionalität sind auf diesem Softwareseitig deaktiviert worden, somit müssen uns einem zusätzlichen Modul behelfen.

Pinout des Bluetooth Modules HC-06

Das hier verwendete Bluetooth Modul HC-06 habe ich dir bereits im Beitrag Arduino Lektion 21: Bluetooth Modul HC-06 für den Arduino vorgestellt.

Rückseite des HC-06 Moduls mit Pinbeschriftung

Vorderseite des HC-06 Moduls Es gibt neben dem HC-06 Modul noch das HM10 Modul, welches über Bluetooth 4.0 & BLE verfügt und somit deutlich schneller arbeitet.

Bluetooth Modul HC06 (links) und HM10 (rechts) Hier, in diesem Beitrag, möchte ich das Modul HC-06 mit Bluetooth verwenden, denn dieses kannst du auch mit einem alten Handy steuern und kannst somit ggf. alte Geräte wiederverwenden.

Anschluss des HC-06 Moduls an den Raspberry Pi Pico W

Das Bluetooth Modul HC-06 wird per UART am Raspberry Pi Pico W programmiert. Das macht den Anschluss recht easy, denn wir brauchen nur einen der beiden UART Schnittstellen und die Stromversorgung von 5V inkl. GND. Bluetooth Modul HC-06Raspberry Pi Pico WRXDGP0, UART0 TXTXDGP1, UART0 RXGND35, GNDVCC40, VBUSPinzuordnung des HC-06 Moduls zum Raspberry Pi Pico W

Bluetooth Modul HC-06 am Raspberry Pi Pico

Eine kleine Schaltung

Im nachfolgenden Beispiel möchte ich dir zeigen, wie du per Bluetooth zwei kleine LEDs schalten kannst.

Schaltung - Bluetooth Modul HC-06 am Raspberry Pi Pico In der Grafik von Fritzing verwende ich das Vorgängermodell Raspberry Pi Pico (also ohne WiFi Support), jedoch sind beide Modul von der Pinbelegung gleich und somit ist diese Grafik auch für den neuen Pico W gültig. Die beiden LEDs sind jeweils an GPIO14 & 15 angeschlossen.

Android App zum Senden von Daten per Bluetooth

Für die nachfolgenden Beispiele verwende ich die Android-App Serial Bluetooth Terminal. Diese App ist sehr einfach zu bedienen und bietet die Grundfunktionalitäten, welche wir benötigen, um Daten per Bluetooth an den Pico W zu senden.

Android-App Serial Bluetooth Terminal im Google Play Store Es gibt für Apple Geräte sicherlich ein äquivalent, da mir jedoch kein solches Gerät zur Verfügung steht, bleibt dieser Test jedoch aus.

Programmieren des Bluetooth Moduls per UART

Aus der Schaltung kannst du übernehmen, dass wir das Modul per UART (RX & TX) programmieren werden. Im ersten Schritt wollen wir zunächst eine Verbindung mit dem Handy aufbauen und Text versenden. Für die # Bibliothek zum steuern der UART Kommunikation from machine import Pin,UART # beginn der UART Kommunikation auf dem ersten Kanal # GP0 & GP1 mit 9600 baud uart = UART(0,9600) # Endlosschleife while True: # pruefen ob irgendwelche Daten empfangen wurden if uart.any(): # lesen der Daten und speichern in # der Variablen command command = uart.readline() # ausgeben der Variablen command auf # der seriellen Schnittstelle print(command) Dieses kleine Programm bewirkt, dass wir wie erwähnt Daten mit einer Bluetooth-Terminal-App versenden und empfangen können. https://youtu.be/FyUQB_BghbM In dem Video siehst du, dass die Daten in der Konsole nach folgendem Muster ausgegeben werden. MicroPython v1.19.1 on 2022-06-18; Raspberry Pi Pico with RP2040 Type "help()" for more information. >>> %Run -c $EDITOR_CONTENT b'H' b'a' b'l' b'l' b'o' b'r' b'n' Damit wir die Daten von Byte in String konvertieren, müssen wir beim Ausgeben oder später beim Auswerten der Variable command die Funktion "decode()" aufrufen. print(command.decode()) Wenn wir nun den Funktionsaufruf decode verwenden, so entfallen die zusätzlichen Zeichen. MicroPython v1.19.1 on 2022-06-18; Raspberry Pi Pico with RP2040 Type "help()" for more information. >>> %Run -c $EDITOR_CONTENT H a l l o

Steuern von LEDs per Bluetooth am Raspberry Pi Pico W

Im nächsten Schritt wollen wir jedoch per Bluetooth unsere beiden LEDs steuern, dazu senden wir für die grüne LED den Buchstaben g und für die rote den Buchstaben r ab. Den Quellcode passen wir an und implementieren die beiden Pins für die LEDs sowie die beiden If-Statements für den Check auf die empfangenen Daten. # Bibliothek zum steuern der UART Kommunikation from machine import Pin,UART # beginn der UART Kommunikation auf dem ersten Kanal # GP0 & GP1 mit 9600 baud uart = UART(0,9600) # rote LED am Pin GPIO14 angeschlossen led_rot = Pin(14, Pin.OUT) # gruene LED am Pin GPIO15 angeschlossen led_gruen = Pin(15, Pin.OUT) # Variablen zum speichern das Status der LEDs led_rot_status = False led_gruen_status = False # Endlosschleife while True: # pruefen ob irgendwelche Daten empfangen wurden if uart.any(): # lesen der Daten und speichern in # der Variablen command command = uart.readline() # ausgeben der Variablen command auf # der seriellen Schnittstelle wenn # diese nicht leer ist if len(command.decode()) > 0: print(command.decode()) else # wenn ein leerer String empfangen wurde # dann soll die Funktion beendet werden return # Wenn der Buchstabe r empfangen wurde UND # die Variable led_rot_status ist False, dann ... if command.decode() == 'r' and not led_rot_status: # Ausgeben der Zeile auf der seriellen Schnittstelle print('LED rot ein') # umkehren des Signals auf dem Pin der LED led_rot.toggle() # setzen der Variable led_rot_status auf True led_rot_status = True # Wenn der Buchstabe r empfange wurde UND # die Variable led_rot_status ist True, dann ... elif command.decode() == 'r' and led_rot_status: # Ausgeben der Zeile auf der seriellen Schnittstelle print('LED rot aus') # umkehren des Signals auf dem Pin der LED led_rot.toggle() # setzen der Variable led_rot_status auf False led_rot_status = False # Wenn der Buchstabe g empfangen wurde UND # die Variable led_gruen_status ist False, dann ... if command.decode() == 'g' and not led_gruen_status: # Ausgeben der Zeile auf der seriellen Schnittstelle print('LED gruen ein') # umkehren des Signals auf dem Pin der LED led_gruen.toggle() # setzen der Variable led_gruen_status auf True led_gruen_status = True elif command.decode() == 'g' and led_gruen_status: # Ausgeben der Zeile auf der seriellen Schnittstelle print('LED gruen aus') # umkehren des Signals auf dem Pin der LED led_gruen.toggle() # setzen der Variable led_gruen_status auf False led_gruen_status = False Wenn wir nun den Code auf den Pi Pico laden, dann können wir mit den Buchstaben r & g die entsprechenden LEDs steuern.

Quellenangabe

Für diesen Beitrag habe ich den englischen Beitrag https://www.instructables.com/Bluetooth-ModuleHC-05-With-Raspberry-Pi-Pico/ als Grundlage verwendet. Dieser Beitrag geht jedoch nur so weit, dass die Daten aus dem Bluetooth Terminal in die Konsole geschrieben wird. Read the full article

[draegerit]

Raspberry Pi Pico W - visualisieren von Sensorwerten in Diagramme - Teil 1

In diesem Beitrag möchte ich dir zeigen, wie du Sensordaten am Raspberry Pi Pico W in Diagramme visualisieren kannst.

Raspberry Pi Pico W - visualisieren von Sensorwerten in Diagramme - Teil 1 Im ersten Beitrag soll es darum gehen, wie diese Daten auf einer Webseite veröffentlicht werden, dazu verwende ich die JavaScript-Bibliothek Google Charts, welche gut dokumentiert und kostenfrei unter https://developers.google.com/chart zu finden ist.

Rückblick

Wie du einen Raspberry Pi Pico W in ein lokales Wi-Fi Netzwerk einbindest und eine Webseite auslieferst, habe ich dir bereits in nachfolgenden Beiträgen ausführlich gezeigt. - Raspberry Pi Pico W – Webserver programmieren - Raspberry Pi Pico W – Webseite ins Internet veröffentlichen

Ziele

Das Ziel dieses Beitrages ist es, dass du erfährst, wie die Sensorwerte eines DHT11 Sensors (Temperatur & rel. Luftfeuchtigkeit) auf einem Liniendiagramm angezeigt werden.

Pi Pico Diagramme visualisieren

Besonderheiten bei Google Charts

Für die Darstellung der Diagramme verwende ich wie bereits erwähnt die Google Charts. Diese haben jedoch bei der Verwendung eine Besonderheit, denn diese darf man nicht lokal hosten. Das bedeutet, dass wir diese vom Google Server laden müssen. Somit haben wir als Bedingung, dass unser kleines Projekt einen Zugriff auf das Internet benötigt.

Benötigte Ressourcen für dieses Projekt

Für den Nachbau dieses Projektes benötigst du: - einen Raspberry Pi Pico W, - ein Micro-USB Datenkabel, - einen DHT11 Sensor, - ein 400 Pin Breadboard, - diverse Breadboardkabel, männlich - männlich, 10 cm Den DHT11 Sensor gibt es in 2 Varianten, zum einen als einfachen Baustein und zum anderen auf einer Platine.

Varianten des DHT11 Sensors Die Unterschiede zwischen diesen Varianten liegen darin, dass bei der Variante mit Platine die Schaltung mit dem benötigten Widerstand bereits vorhanden ist. Solltest du also den einfachen Baustein verwenden (welcher nebenbei auch nicht günstiger oder teurer ist) so musst du zusätzlich noch einen 10 kOhm Widerstand in die Schaltung einbauen.

Aufbau der Schaltung

Zunächst bauen wir die Schaltung mit dem DHT11 Sensor auf. DHT11 SensorRaspberry Pi Pico WGNDGND, Pin 38DATAGP15, Pin 20VCCVBUS Hier nun die beiden Schaltungen mit den beiden Varianten des DHT11 Sensors.

Schaltung - Raspberry Pi Pico mit DHT11 Sensor

Schaltung - Raspberry Pi Pico mit Bauteil DHT11 & Widerstand In den Grafiken verwende ich das Vorgängermodell, den Raspberry Pi Pico, dieser ist jedoch baugleich dem neuen Pico W und hat das gleiche Pinout.

Raspberry Pi Pico W mit DHT11 Sensor auf 400 Pin Breadboard Pinout des DHT11 Sensors Hier der vollständigkeitshalber das Pinout der Varianten des DHT11 Sensors.

DHT11 Sensor Pinout

Pinout des DHT11 Sensors Die Varianten auf einer Platine unterscheiden sich darin, dass DATA & VCC vertauscht sind, jedoch ist der Pin DATA auf der Platine mit einem "S" wie Signal gekennzeichnet. Technische Daten des DHT11 Sensors DHT11 Messbereich relative Luftfeuchtigkeit 20% bis 90% Toleranz relative Luftfeuchtigkeit ±5% Messbereich der Temperatur 0°C bis 60°C Toleranz des Messbereiches für die Temperatur ±2°C Betriebsspannung 5V Technische Daten des DHT11 Sensors

Programmieren des Raspberry Pi Pico W in der Thonny IDE

Zum Programmieren des Pi Pico W nutze ich hier die Thonny IDE welche du kostenfrei unter https://thonny.org/ für Linux, macOS und Microsoft Windows herunterladen kannst.

IDE Thonny - erster Start Wie du die Thonny IDE unter Linux für den Pi Pico W einrichtest, habe ich dir im gleichnamigen Beitrag Thonny IDE auf Linux einrichten für den Raspberry Pi Pico W ausführlich an Linux Mint erläutert. Den nachfolgenden kleinen Code habe ich aus der offiziellen englischen Dokumentation von Micropython. import dht import machine d = dht.DHT11(machine.Pin(15)) d.measure() print("Temperatur:", d.temperature(), "°C", sep=" ") print("rel. Luftfeuchtigkeit:",d.humidity(), "%", sep=" ") Wenn wir diesen Code ausführen, dann wird aus der Konsole nachfolgende Meldung ausgegeben. MicroPython v1.19.1-88-g74e33e714 on 2022-06-30; Raspberry Pi Pico W with RP2040 Type "help()" for more information. >>> %Run -c $EDITOR_CONTENT Temperatur: 18 °C rel. Luftfeuchtigkeit: 70 % >>> Diese beiden Messwerte wollen wir nun auf einer Webseite in Diagramme anzeigen. Aufbau einer Webseite für die Anzeige der Messwerte Im ersten Schritt haben wir die beiden Messwerte des DHT11 Sensors ausgelesen und in der Konsole angezeigt. Jetzt möchte ich dir zeigen, wie eine kleine Webseite aufgebaut wird, um diese Daten in Diagramme angezeigt werden. Wie du eine Webseite am Raspberry Pi Pico W erstellst und auslieferst, habe ich dir bereits im Beitrag Raspberry Pi Pico W – Webseite ins Internet veröffentlichen ausführlich gezeigt.

Webseite mit Messdaten vom DHT11 Sensor Im Nachfolgenden erstelle ich jeweils für den Sensor sowie für die Seite eigene Dateien, welche in den Hauptcode importiert werden, das hat den Vorteil, dass wir so unseren Code recht übersichtlich halten. Der DHT11 Sensor liefert alle 1,5 Sekunden einen neuen Wert, daher lese ich auch nur in diesen Abständen die Messdaten aus. Hier kannst du auch locker auf ein Intervall von 5 Minuten (300000 Millisekunden) wechseln. # importieren der zusätzlichen Module from dht_sensor import DHT11 from website import * # importieren der Module für den Aufbau # der Netzwerkverbindung und die Möglichkeit # eine Webseite auszuliefern import network import socket # Modul welches Funktionen zur Zeiten bereithält # zbsp. wieviele Millisekunden seit dem Start # vergangen sind import time # Modul für das steuern der GPIOs am Mikrocontroller from machine import Pin # erzeugen einer Instanz des DHT11 Sensors sensor = DHT11() # Zugangsdaten zum WiFi Netzwerk ssid = '****' password = '****' # Aufbauen einer WiFi Verbindung wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect(ssid, password) print('Verbindung wird aufgebaut...') max_wait = 10 while max_wait > 0: if wlan.status() < 0 or wlan.status() >= 3: break max_wait -= 1 print('.', end='') time.sleep(1) print('') if wlan.status() != 3: raise RuntimeError('Aufbau der Verbindung fehlgeschlagen!') else: print('Erfolgreich mit dem WiFi Netzwerk ', ssid, ' verbunden!' ) status = wlan.ifconfig() print('aktuelle IP-Adresse ist: ' + status) addr = socket.getaddrinfo('0.0.0.0', 80) s = socket.socket() s.bind(addr) s.listen(1) # print('', addr) # Variablen für das speichern der letzten Ausführung # zum lesen der Messdaten vom Sensor last_action = 0 # Wert in Millisekunden delay = 1500 # ein Zähler welcher hochgezählt wird data_index = 0 # Variable für das halten der Webseite html_data = "" # Endlosschleife while True: # Wenn der Zeitpunkt der letzten Ausführung länger zurück liegt, # als der jetzige Zeitpunkt - dem gesetzen delay, dann... if last_action < (time.ticks_ms()-delay): last_action = time.ticks_ms() data_index = data_index + 1 # lesen der Sensordaten sensor.readSensordata(data_index) line_data = "," sensor_data = "" # loop über die bisher gespeicherten Daten for data in sensor.recorded_data: # ein Eintrag aus der Liste enthält: # - einen Index, # - die Temperatur, # - die rel. Luftfeuchtigkeit index, temp, hum = data # formatieren der Daten sensor_data = sensor_data + line_data.format(i=index, t=temp, h=hum) # verbinden der Webseite Teil1 & Teil2 inkl. Daten html_data = html_part1 + sensor_data + html_part2 try: # Wenn ein Client verbunden wurde dann die Daten ausliefern. cl, addr = s.accept() print('Mit dem Client ', addr, ' verbunden.', addr) cl.send('HTTP/1.0 200 OKrnContent-type: text/htmlrnrn') cl.send(html_data) cl.close() except OSError as e: cl.close() print('Verbindung geschlossen') Das Lesen und speichern der Messwerte vom DHT11 Sensor erledigen wir in der Klasse "DHT11". import dht import machine # der DHT11 Sensor ist am GPIO15 angeschlossen d = dht.DHT11(machine.Pin(15)) # Klasse um die Daten des Sensors # auszulesen und die gelesenen # Daten zu halten. class DHT11: temperature = 0 humidity = 0 recorded_data = # lesen und speichern der Messdaten def readSensordata(self, index): d.measure() self.temperature = d.temperature() self.humidity = d.humidity() self.recorded_data.append() Die Webseite halten wir in zwei Variablen, damit dieses den Hauptcode nicht unnötig lang macht, lagere ich diese in einer extra PY-Datei aus und importiere diese lediglich. Im HEADER der Webseite laden wir die JavaScript-Datei von Google, welche die Funktionen enthält, um ein Diagramm zu zeichnen. Des Weiteren enthält dieser Abschnitt noch einen META-TAG, um die Seite alle 30 Sekunden neu zuladen. # erster Teil der Webseite html_part1 = ''' Raspberry Pi Pico W

Aufzeichnung der Messdaten des DHT11 am Raspberry Pi Pico W

''' html = html_part1 + html_part2 Damit du diesen Code auf deinem Mikrocontroller ausführen kannst, musst du zusätzlich deine Wi-Fi-Daten (ssid & password) eingeben. Wenn alles korrekt eingeben und auf dem Mikrocontroller gespielt wurde, dann wird dir in der Konsole die IP-Adresse des Gerätes angezeigt, welche du nun im Browser eingeben musst, um zur Webseite zu gelangen. MicroPython v1.19.1-88-g74e33e714 on 2022-06-30; Raspberry Pi Pico W with RP2040 Type "help()" for more information. >>> %Run -c $EDITOR_CONTENT Verbindung wird aufgebaut... Erfolgreich mit dem WiFi Netzwerk FRITZBox7590GI_EXT verbunden! aktuelle IP-Adresse ist: 192.168.178.70 Read the full article

[draegerit]

Raspberry Pi Pico - Programme automatisch starten

In diesem kurzen Beitrag möchte ich dir zeigen, wie du Programme auf den Raspberry Pi Pico / Pico speichern kannst, welche automatisch starten, wenn dieser unter Spannung steht.

Raspberry Pi Pico - Programme automatisch starten Den Raspberry Pi Pico und das neue Modell, den Raspberry Pi Pico W mit WiFi Chip habe ich dir bereits in diversen Beiträgen vorgestellt, wie zbsp.: - Raspberry PI Pico #1 – Vorstellung - Raspberry PI Pico #2 – LEDs steuern - Raspberry PI Pico #4 – Taster mit PullDown & PullUp abfragen - Raspberry Pi Pico W – Creator Display erstellen - Raspberry Pi Pico W – Zeit aus dem Internet lesen und auf einem Display anzeigen - Raspberry Pi Pico W – Webserver programmieren

Mikrocontroller - XIAO RP2040 & Raspberry Pi Pico Dieser Beitrag funktioniert auch mit anderen Mikrocontroller, welche den Chip RP2040 haben wie zbsp. der XIAO RP2040 (siehe Bild). In diesem Beitrag verwende ich jedoch den originalen Raspberry Pi Pico.

Eine kleine Schaltung

Hier nun zunächst eine kleine Schaltung mit zwei 10 mm LEDs, welche im Wechsel blinken sollen, wenn der Raspberry Pi Pico unter Spannung steht.

Raspberry PI Pico - Wechselblinken zweier LEDs Diese Schaltung habe ich dir bereits im Beitrag Raspberry PI Pico #2 – LEDs steuern gezeigt.

Programmieren in der Thonny IDE

Zum Programmieren nutze ich die Thonny IDE welche du kostenfrei unter https://thonny.org/ für Windows, macOS oder Linux herunterladen kannst.

IDE Thonny - erster Start Wie du die Thonny IDE auf Linux für den Raspberry Pi Pico einrichten kannst, zeige ich dir im Beitrag Thonny IDE auf Linux einrichten für den Raspberry Pi Pico W. Erstellen der Datei boot.py um Programme automatisch starten zu lassen am Raspberry Pi Pico Damit wir ein Programm automatisch auf dem Raspberry Pi Pico starten können, legen wir die Datei boot.py an. Diese Datei erstellen wir über die Toolbar der Thonny IDE.

Thonny IDE - neuen Reiter anlegen In diesem bisher unbenannten Tab & Reiter schreiben wir nun entweder unseren Code, welcher automatisch gestartet werden soll, oder wir importieren die Datei code.py. import code Wenn dieses geschehen ist, dann speichern wir die Daten auf dem Raspberry Pi Pico als boot.py wie nachfolgend gezeigt.

Im Abschluss kannst du jetzt deinen Mikrocontroller an eine Powerbank, USB-Ladegerät etc. anschließen und dein Code wird ausgeführt.

Hinweis

Wenn du den Code ändern möchtest, dann musst du deinen Mikrocontroller neu flashen, in meinem Fall musste ich zunächst diesen Mikrocontroller auf CircuitPython flashen und danach für MicroPython. Das ist recht umständlich, aber klappt innerhalb von knapp 3min. - CircuitPython > https://circuitpython.org/board/raspberry_pi_pico/ - MicroPython > https://micropython.org/download/rp2-pico/ Der gesamte Code auf dem Mikrocontroller geht dabei verloren, d.h. speichere deine Daten noch extern auf deinem Computer. Read the full article

[draegerit]

Zeichnen einfache geometrische Figuren auf dem TFT-Display mit Pi Pico W

In diesem Beitrag möchte ich dir zeigen, wie du geometrische Figuren am Raspberry Pi Pico W auf einem TFT-Display zeichnen bzw. programmieren kannst.

Zeichnen einfache geometrische Figuren auf dem TFT-Display mit Pi Pico W In meinem letzten Beitrag Raspberry Pi Pico W mit TFT Display habe ich dir bereits gezeigt, wie du dieses TFT-Display an den Pi Pico anschließen und einen Text ausgeben kannst. Hier soll es nun darum gehen wie du Kreise, Rechtecke usw. zeichnen kannst.

Rückblick

Für diesen Beitrag verwende ich das Modul ILI9431 vom Git Hub Repository https://github.com/jeffmer/micropython-ili9341 dieses habe ich um einige Funktionen erweitert und als Fork, ebenso auf GitHub unter https://github.com/StefanDraeger/micropython-ili9341 veröffentlicht. Du kannst dir dieses recht einfach als ZIP-Datei herunterladen und auf dem Computer entpacken.

Label auf dem GitHub Repository Wie du dieses Modul auf dem Pi Pico W einrichtest und Text anzeigen kannst, habe ich dir im YouTube Video Raspberry Pi Pico W - TFT-Display via SPI anschließen und programmieren gezeigt. Anschluss des TFT-Displays per SPI an den Raspberry Pi Pico W Das Display wird wie folgt am Pi Pico / Pi Pico W angeschlossen: TFT-DisplayRaspberry Pi Pico / Pico WGNDGNDVCCVBUSSCKGP6SDAGP7RESGP14RSGP15CSGP16LED_A3v3(OUT)Anschluss eines TFT-Displays per SPI an den Raspberry Pi Pico / Pico W

Anschluss eines TFT Displays via SPI an den Raspberry Pi Pico

Schaltung - RP2040 mit TFT Display

Zeichnen von geometrischen Figuren

Mit dem hier verwendeten Modul können von Hause aus nicht direkt einfache geometrische Figuren gezeichnet werden. Das Modul bietet lediglich die Funktion zum Zeichnen eines Punktes, gefülltes Rechteck sowie eines Textes. Mit der Funktion zum Zeichnen eines Punktes / Pixels können wir uns jedoch die Funktionen für Kreise, Rechtecke etc. selber programmieren, was wir hier nun machen wollen. Wenn du die erweiterte Version von meinem GitHub Repository verwendest, dann hast du die nachfolgenden Funktionen bereits enthalten! https://youtu.be/417scPNXLE8 Natürlich könnten wir auch ein Modul von Adafruit verwenden und hätten somit diese Funktionen onboard, aber das wäre ja zu einfach :) Linie Die Logik zum Zeichnen einer Linie habe ich mir aus dem Wiki Artikel Line drawing algorithm entnommen. def draw_line(self, x0, y0, x1, y1, color): dx = x1 - x0 dy = y1 - y0 for x in range(x0, x1): y = y1 + dy * (x - x1) / dx self.pixel(int(x), int(y), color) Kreise Die Funktion, wie man einen Kreis zeichnet, habe ich mir vom Blog "Hello Raspberry Pi" kopiert. def draw_circle(xpos0, ypos0, rad, color): x = rad - 1 y = 0 dx = 1 dy = 1 err = dx - (rad = y: display.pixel(xpos0 + x, ypos0 + y, color) display.pixel(xpos0 + y, ypos0 + x, color) display.pixel(xpos0 - y, ypos0 + x, color) display.pixel(xpos0 - x, ypos0 + y, color) display.pixel(xpos0 - x, ypos0 - y, color) display.pixel(xpos0 - y, ypos0 - x, color) display.pixel(xpos0 + y, ypos0 - x, color) display.pixel(xpos0 + x, ypos0 - y, color) if err 0: x -= 1 dx += 2 err += dx - (rad Read the full article

[draegerit]

Raspberry Pi Pico W - Taster mit Interrupts in Micropython

In diesem Beitrag möchte ich dir zeigen, wie du Interrupts an Taster am Raspberry Pi Pico W mit Hilfe von Micropython programmieren kannst.

Raspberry Pi Pico W - Taster mit Interrupts in Micropython Wie du einen Taster am Raspberry Pi Pico programmieren kannst, habe ich dir bereits im Beitrag Raspberry PI Pico #4 – Taster mit PullDown & PullUp abfragen gezeigt. Das Vorgängermodell Raspberry Pi Pico ist dem neuen Modell vom Pinout gleich und daher kannst du diesen Beitrag auch mit dem "alten" Modell nachbauen.

Benötigte Ressourcen für den Nachbau des Projektes

Wenn du das nachfolgende kleine Projekt nachbauen möchtest, dann benötigst du: - einen Raspberry Pi Pico W oder Raspberry Pi Pico, - ein Micro-USB Datenkabel, - einen Printtaster, - ein 10 kOhm Widerstand, - eine 5 mm, LED, - ein 220 Ohm Widerstand, - ein 400 Pin Breadboard, - vier Breadboardkabel, männlich-männlich, 10 cm

Aufbau der Schaltung

Die Schaltung ist recht einfach, denn man muss lediglich den Taster mit einem Pull Down Widerstand über 5V gem. der Zeichnung verbinden. In meinem Beispiel möchte ich eine LED mit dem Taster steuern und daher sieht meine Schaltung wie folgt aus.

Aufbau der Schaltung - Taster & LED am Raspberry Pi Pico W

Programm zum Steuern einer LED über einen Taster mit Micropython

Zuerst möchte ich dir das Stückchen Code zeigen, wie das in der Regel gemacht wird. Wenn wir den Taster betätigen, so wird die LED aktiviert und bleibt auch solange aktiviert, bis wir den Taster erneut betätigen. Am Schluss der Aktion legen wir eine kleine Pause von 500ms ein, damit wird der Taster entprellt. # importieren der Module from machine import Pin import time # definieren der Pins an welche # unsere Bauteile angeschlossen sind led = Pin(15, Pin.OUT) # LED als Ausgang button = Pin(16, Pin.IN) # Taster als Eingang # Variable zum speichern des letzten Zustands # der LED 0 = AUS, 1 = EIN last_led_state = 0 # Endlosschleife while True: # Wenn der Taster betätigt wurde, dann... if button.value(): # Wenn die LED deaktiviert ist, dann... if last_led_state == 0: # LED aktivieren led.on() # merken das die LED aktiviert ist last_led_state = 1 else: # Wenn der Wert der Variable # last_led_state nicht 0 ist, dann... # LED deaktivieren led.off() # merken das die LED deaktiviert ist last_led_state = 0 # eine Pause von 500ms # damit wird der Taster entprellt time.sleep(0.5)

Erstellen des Programmes "Taster mit Interrupts in Micropython"

Wenn wir das ganze mit einem Interrupt lösen wollen, so benötigen wir etwas mehr Code. Zunächst definieren wir unseren Taster & die LED, wie bereits bekannt. from machine import Pin last_led_state = 0 led = Pin(15, Pin.OUT) button = Pin(16, Pin.IN) Neu dazu kommt, dass wir mit der Funktion irq einen Trigger an den Pin hängen, welcher eine Funktion ausführt, wenn sich der Status ändert. Den Parameter trigger belegen wir mit der Aktion des Pins, welche für das Aufrufen der Funktion welche über den Parameter handler gesetzt wird. def button_handler(pin): global last_led_state if pin == button: last_led_state = not last_led_state led.value(last_led_state) button.irq(trigger = machine.Pin.IRQ_RISING, handler = button_handler) Hier nun der gesamte Code: # importieren der benötigen Module from machine import Pin # definieren das die LED initial deaktiviert ist last_led_state = False # LED am GP15 angeschlossen, als Ausgang definiert led = Pin(15, Pin.OUT) led.value(last_led_state) # Taster am GP16 angeschlossen, als Eingang definiert button = Pin(16, Pin.IN) # Funktion welche aufgerufen wird, wenn ein Pin an welchem # ein Taster hängt seinen Status ändert # Parameter pin ist der Pin welcher seinen Status geändert hat. def button_handler(pin): # für den Zugriff auf die globale Variable global last_led_state # Wenn der Pin gleich unserem Taster ist, dann... if pin == button: # umkehren des Wertes für den letzten Status # der LED last_led_state = not last_led_state # setzen des Wertes # ein Boolean Wert True/False, kann auch als # 1/0 interpretiert werden led.value(last_led_state) # dem Pin / Taster einen Interrupt anhängen, # Parameter # trigger # - wenn das Signal "hochgezogen" wird > machine.Pin.IRQ_RISING # - wenn das Signal "nach unten gezogen" wird > machine.Pin.IRQ_FALLING # handler # - die Funktion welche aufgerufen werden soll, # die Funktion muss einen Parameter haben button.irq(trigger = machine.Pin.IRQ_RISING, handler = button_handler) In der offiziellen Dokumentation zur Programmiersprache Micropython https://mpython.readthedocs.io/en/master/library/micropython/machine/machine.Pin.html#Pin.Pin.irq findest du weitere Informationen zu der hier verwendeten Funktion. Read the full article

[draegerit]

Vergleich Raspberry Pi Pico W & MAKER Pi Pico

In diesem Beitrag möchte ich einen Vergleich zwischen dem Raspberry Pi Pico W und MAKER Pi Pico aufstellen und zeigen wo die Unterschiede liegen.

Vergleich - Raspberry Pi Pico W & MAKER Pi Pico Den Mikrocontroller MAKER Pi Pico habe ich von der Firma Cytron kostenfrei erhalten und bereits im Beitrag Maker Pi Pico von Cytron vorgestellt. Dieser Mikrocontroller ist auf Basis des Vorgängermodells des Pi Pico (also ohne WiFi Chip).

Raspberry Pi Pico W

MAKER Pi Pico Die beiden Mikrocontroller habe ich schon in diversen Beiträgen behandelt und kann somit recht gut über die Features sprechen, wobei der Raspberry Pi Pico W noch neu in meinem Sortiment ist. Der neue Raspberry Pi Pico W hat nur zwei zusätzliche Features gegenüber dem Vorgängermodell, nämlich die WiFi-Schnittstelle und 2 MB Flash Speicher. - MAKER Pi Pico #1 – senden von Sensordaten an ThingSpeak - MAKER Pi Pico #2 – Sensordaten auf einer SD-Card speichern - Raspberry Pi Pico W mit Wi-Fi Support - Raspberry Pi Pico W mit Infineon CYW43438 Chip - Raspberry Pi Pico W – Zeit aus dem Internet lesen und auf einem Display anzeigen

Vergleich der Features

Da der MAKER Pi Pico einen Raspberry Pi Pico verbaut hat (also direkt auf die Platine gelötet) ist zumindest das Pinout und der Chip (Typ RP2040) derselbe, jedoch hat dieser Mikrocontroller noch ein paar sehr nette Features. Features des MAKER Pi Pico - SD – Card, - AUDIO Ausgang, - Piezo Buzzer, - 3 frei programmierbare Taster, - Buchse für einen ESP01*, - 6 Grove Adapter für Sensoren / Aktoren, - eine RGB LED, - an jedem GPIO Ausgang eine SMD LED**, - Stiftleiste zum Abgreifen der Debug Pins

Features des Raspberry Pi Pico W Der Raspberry Pi Pico W verfügt über: - eine Micro-USB Schnittstelle, - eine Debug Schnittstelle (SWD - Serial Wire Debug), - einen RP2040 Chip mit Dual Core Arm Cortex-M0+ mit bis zu 133 MHz, - einen internen Speicher von 264 kB SRAM für dein Programm, - 2MB QSPI Flash Speicher für zusätzliche Dateien, - 40 Pins, davon- 26 multifunktionale GPIOs - 3 analoge Eingänge - Schnittstellen- 2x I²C, 2x SPI, 2x UART Zusätzlich verfügt dieser neue Mikrocontroller über eine 2.4 GHz WiFi Schnittstelle, welche im Standard 802.11n arbeitet. (siehe Raspberry Pi Pico W mit Infineon CYW43438 Chip)

Preisvergleich

Der Preis für den MAKER Pi Pico liegt derzeit bei 12 $ (ca. 11,83 €) und für den Raspberry Pi Pico W lediglich 6,99 € zzgl. Versandkosten bei reichelt.de. Dadurch das der MAKER Pi Pico ein paar zusätzliche Features hat, ist der höhere Preis gerechtfertigt. Jedoch ist die Unterstützung von Wi-Fi noch nicht ausgeprägt, sodass der Pi Pico W hier deutlich die Nase vorne hat.

Programmieren der beiden Mikrocontroller

Beide Mikrocontroller lassen sich mit der Arduino IDE in C/C++ programmieren. Aber du kannst dir diese auch Flashen und dann mit CircuitPython programmieren, was wie ich finde deutlich mehr Spaß macht. Zu beiden Mikrocontroller habe ich bereits einige Beiträge veröffentlicht, wo ich dir gezeigt habe wie diese programmiert werden. Maker Pi Pico - Maker Pi Pico von Cytron - MAKER Pi Pico #1 – senden von Sensordaten an ThingSpeak - MAKER Pi Pico #2 – Sensordaten auf einer SD-Card speichern Raspberry Pi Pico W - Raspberry Pi Pico W – Webserver programmieren - Thonny IDE auf Linux einrichten für den Raspberry Pi Pico W - Raspberry Pi Pico W – Zeit aus dem Internet lesen und auf einem Display anzeigen - Raspberry Pi Pico W – Creator Display erstellen

Fazit

Beide Mikrocontroller haben Ihre Daseinsberechtigung, jedoch finde ich den neuen Pi Pico W mit seiner Wi-Fi Schnittstelle und seinem kleinen Formfaktor etwas besser. Jedoch vermisse ich bei diesem so nette Features wie Groove Schnittstellen zum einfachen Anschließen von Sensoren / Aktoren. Für das Vorgängermodell des Raspberry Pi Pico W hatte ich mir ein kleines Board entworfen, welches über ein paar Groove Schnittstellen verfügt.

Raspberry Pi Pico W auf DIY Expansionboard Read the full article

[draegerit]

Raspberry Pi Pico W - Creator Display erstellen

In diesem Beitrag möchte ich dir zeigen, wie du deinen Raspberry Pi Pico W mit einem OLED Display in ein Creator Display verwandeln kannst und dort deine Social-Media Attribute anzeigen lässt. Natürlich kannst du dieses Beispiel auch recht einfach adaptieren und dort andere Daten von APIs anderer Dienste anzeigen, wie zbsp. vom Deutschen Wetterdienst, Umrechnungskurse, Aktienkurse etc. Da wir das spätere Programm in MicroPython schreiben, können wir auch einen anderen Mikrocontroller als den Raspberry Pi Pico W verwenden. Jedoch ist dieser derzeit meine erste Wahl und wird für dieses kleine Projekt eingesetzt.

Was soll das Creator Display anzeigen?

Ziel soll es sein, auf einem Display die Aufrufe und Abos anzeigen zu lassen. https://youtu.be/YE9z9fq-dnc Da mein YoutTube Kanal Draeger-IT noch recht klein ist, habe ich noch nicht so viele Abos und auch nicht die Masse an Aufrufe, aber trotzdem möchte ich die YouTube API ansprechen, um die Daten zu empfangen und auszuwerten. Hier eine kleine Auflistung der APIs zu welchen man recht einfach Zugriff bekommt: - YouTube, - Instagram, - Pinterest, - Facebook, - TikTok In diesem Beitrag möchte ich mich zunächst auf die YouTube API beschränken. Die anderen Social-Media-Plattformen werden ggf. in separaten Beiträgen behandelt.

Benötigte Ressourcen für dieses Projekt

Damit du Zugriff auf die YouTube API bekommst, benötigst du einen Google Account und einen API Key. Den API Key kannst du dir nur mit einem Google Developer Account anlegen und unter https://console.cloud.google.com/apis/ anlegen. Um einen API Key zu generieren, klicken wir zunächst im Navigationsmenü auf der linken Seite auf "Anmeldedaten" (1) und können dann auf "+ CREATE CREDENTIALS" (2) klicken. Im neu geöffneten Untermenü kannst du den ersten Eintrag "API-Schlüssel" (3) wählen und ein allgemeingültiger API-Schlüssel wird erzeugt.

Schritt 1 - erstellen eines API Keys im Google Developer Account Nach einer kurzen Wartezeit wird dir der API Key in einem Dialog angezeigt, welchen du dir in die Zwischenablage kopieren kannst.

Schritt 2 - neu generierter API Key Achtung: Mit dem API Key kannst du auf einfache Weise auf deinen Account zugreifen und Daten hinzufügen und auch ändern. Den hier dargestellten API Key habe ich gegen Missbrauch unkenntlich gemacht und auch nach der Erstellung von diesem Beitrag wieder gelöscht.

Aufruf der YouTube API per HTTP Request

Am Einfachsten kannst du über einen simplen HTTP Request auf die YouTube API zugreifen, du benötigst also keine zusätzlichen Module, welche du importieren musst. Du kannst mit deinem zuvor generierten API Key somit recht einfach eine URL zusammensetzen und wie hier die aktuelle Kanalstatistik als JSON abrufen. https://www.googleapis.com/youtube/v3/channels?id=UCUoqALbWy__4Blgfztg4sKg&key=AIzaSyD*********F3AJHs&part=statistics { "kind": "youtube#channelListResponse", "etag": "MozCK4S3NxXniTguDkimSgach7g", "pageInfo": { "totalResults": 1, "resultsPerPage": 5 }, "items": } Im letzten Beitrag Raspberry Pi Pico W – Zeit aus dem Internet lesen und auf einem Display anzeigen habe ich dir bereits gezeigt, wie du eine Zeit von einem Server als JSON Response anfordern und auswerten kannst. Jedoch müssen wir auf die API per SSL zugreifen und daher müssen wir etwas umschreiben.

Aufbau einer SSL Verbindung mit dem Modul ussl

Das nachfolgende Beispiel habe ich von der Seite Python ussl.wrap_socket() Examples entnommen und dieses hat auf Anhieb quasi ohne Änderungen funktioniert. Der Vorteil ist an der erweiterten Funktion, dass diese mit HTTP & HTTPS arbeiten kann. Damit wir die SSL Verbindung aufbauen können, müssen wir zunächst das Modul ussl in die Thonny IDE einbinden. Über das Hauptmenü "Extras" > "Verwalte Pakete..." erreichst du den Dialog zum Installieren neuer Module. In diesem Dialog suchst du zunächst nach "ussl" (1), mit der Schaltfläche "Suche auf PyPi" (2) aus den Suchergebnissen wählst du den Eintrag "pycopy-cpython-ussl" (3) aus. Nach dem Selektieren des Eintrages aus den Suchergebnissen kannst du dann die Schaltfläche "Installieren" (4) betätigen und das Modul wird hinzugefügt.

installieren des Modules "ussl" in der Thonny IDE Schritt 1

installieren des Modules "ussl" in der Thonny IDE Schritt 2 Im Ordner "lib" des Mikrocontrollers findest du nun die Datei "ussl.py".

Installierte Module auf dem Pi Pico W Hier die angesprochene Funktion zum Absenden eines HTTP / HTTPS Request und liefern des Response. import ussl # Funktion zum absenden eines HTTP / HTTPS Request und # Rückgabe des Response # Quelle: https://www.programcreek.com/python/example/96165/ussl.wrap_socket def http_get(url): print("Fetching:", url) proto, _, host, path = url.split('/', 3) if proto == "http:": port = 80 elif proto == "https:": port = 443 addr = socket.getaddrinfo(host, port) s = socket.socket() s.connect(addr) if proto == "https:": s = ussl.wrap_socket(s, server_hostname=host) s.write(bytes('GET /%s HTTP/1.0rnHost: %srnrn' % (path, host), 'utf8')) result = '' while True: data = s.read(100) if data: result = result + str(data, 'utf8') else: break s.close() return result Die Rückgabe ist nicht nur ein einfacher HTTP/HTTPS Response, sondern auch die gesamten Header Daten. Waiting to connect: ('192.168.178.70', '255.255.255.0', '192.168.178.1', '192.168.178.1') Fetching: https://www.googleapis.com/youtube/v3/channels?id=UCUoqALbWy__4Blgfztg4sKg&key=AI******3AJHs&part=statistics HTTP/1.0 200 OK Content-Type: application/json; charset=UTF-8 Vary: X-Origin Vary: Referer Date: Sun, 31 Jul 2022 09:25:38 GMT Server: scaffolding on HTTPServer2 Cache-Control: private X-XSS-Protection: 0 X-Frame-Options: SAMEORIGIN X-Content-Type-Options: nosniff Accept-Ranges: none Vary: Origin,Accept-Encoding Alt-Svc: h3=":443"; ma=2592000,h3-29=":443"; ma=2592000,h3-Q050=":443"; ma=2592000,h3-Q046=":443"; ma=2592000,h3-Q043=":443"; ma=2592000,quic=":443"; ma=2592000; v="46,43" { "kind": "youtube#channelListResponse", "etag": "nJfSIGqHLEeyYpfTt3arnG3kax0", "pageInfo": { "totalResults": 1, "resultsPerPage": 5 }, "items": }

Funktion zum Extrahieren des JSON Response

Wie du erkennen kannst, liefert die Funktion noch zusätzliche Daten, welche wir in diesem Fall nicht benötigen. Mit einfachen nachfolgenden Funktion können wir den JSON Response extrahieren. # Ermitteln des JSONs aus dem HTTP Response def findJson(response): return response Als Parameter übergeben wir das Result der Funktion "http_get(url)" und erhalten unser JSON. { "kind": "youtube#channelListResponse", "etag": "nJfSIGqHLEeyYpfTt3arnG3kax0", "pageInfo": { "totalResults": 1, "resultsPerPage": 5 }, "items": }

Auswerten des JSON Response

Wenn du die Adresse im Browser ausgeführt / abgesendet wird, erhält man wie erwähnt eine Antwort mit einem JSON aus welchem man die nachfolgenden Werte entnehmen kann: - viewCount - Anzahl der gesamten Klicks auf Videos - subscriberCount - Anzahl der Abos - videoCount - Anzahl der Videos Zunächst wandeln wir das JSON Objekt in ein Dictionary um, denn so können wir ganz einfach auf die Werte zugreifen. import json aDict = json.loads(jsonData) {'pageInfo': {'resultsPerPage': 5, 'totalResults': 1}, 'kind': 'youtube#channelListResponse', 'etag': 'nJfSIGqHLEeyYpfTt3arnG3kax0', 'items': } Dun kann man mit dem Key "statistics" auf die oben aufgeführten Werte zugreifen. aDict = json.loads(jsonData) statistics = aDict subscriberCount = statistics videoCount = statistics viewCount = statistics print('subscriberCount', subscriberCount, sep=" ") print('videoCount', videoCount, sep=" ") print('viewCount', viewCount, sep=" ") subscriberCount 342 videoCount 301 viewCount 122093

Programmieren des Raspberry Pico W Creator Display

Nachdem wir die Daten ermittelt haben, wollen wir diese jetzt auf einem OLED Display anzeigen lassen. Für den Arduino, ESPx sowie natürlich für den Raspberry Pi / Pico / Pico W bekommst du diverse OLED Displays in verschiedene Auflösungen und auch Farben.

Auswahl an OLED Displays für den Arduino, ESPx und Raspberry Pi Im nachfolgenden Beispiel verwende ich das 0,96" OLED Display mit einer Auflösung von 128 x 64 Pixel. Anschließen eines OLED Displays per I²C an den Pi Pico / Pico W Zunächst schließen wir unser OLED Display per I²C an den Pi Pico W an. Hier verwende ich die folgende Pinbelegung: - GND - Pin 38, GND - VCC - Pin 40, VBUS - SCL - Pin 1, GP1 - SDA - Pin 0, GP0

Schaltung - OLED Display am Raspberry Pi Pico

Installieren des Modules für das OLED Display mit SSD1306 Chip

Auf dem OLED Display ist ein Chip vom Typ SSD1306 verbaut, für die Programmierung benötigen wir das Modul "micropython-ssd1306" welches wir ebenfalls wie zuvor das "ussl" Modul über "Extras" > "Verwalte Pakete..." installieren. Wir suchen somit nach "ssd1306" (1) mit der Schaltfläche "Suche auf PyPi" (2) oder betätigen einfach die Return taste. In den Suchergebnissen wählen wir den ersten Eintrag "micropyhton-ssd1306" aus und wählen im nächsten Dialog die Schaltfläche "Installieren", wenn der vorgang

Thony IDE - installieren des Modules "micropython SSD1306"

Ausgabe der Zeile "Hello World!" auf dem OLED Display

In der offiziellen Dokumentation zum Modul "micropython-ssd130" unter Using a SSD1306 OLED display findest du weitere Informationen, wie man ein OLED Display in MicroPython programmiert. Hier nun ein kleines Beispiel, wie man die Textzeile "Hello World!" ausgibt. from machine import Pin, I2C import ssd1306 import time i2c = I2C(0, sda=Pin(0), scl=Pin(1)) time.sleep(3) display = ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3c) display.fill(0) display.text('Hello World!', 0, 0, 1) display.show()

Textzeile "Hello World!" auf dem OLED Display via I²C am Raspberry Pi Pico W angeschlossen Das Display kann maximal 6 Zeilen mit jeweils 16 Zeichen vernünftig anzeigen.

Anzeige der maximalen Zeilenzahl am 128x64 Pixel OLED Display

Fertiges Skript "Raspberry Pi Pico W Creator Display"

Hier nun das fertige Skript zum Laden der YouTube Statistik zu einem Kanal mithilfe der API und einem generierten API_KEY. import network import socket import time import json import ssl import ussl from machine import Pin, I2C import ssd1306 i2c = I2C(0, sda=Pin(0), scl=Pin(1)) time.sleep(3) display = ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3c) #Zugangsdaten zum WLAN Netzwerk ssid = '*****' password = '******' #Adresse welche uns das JSON mit den Zeitdaten liefert CHANNEL_NAME = 'Draeger-IT' CHANNEL_ID = 'UCUoqALbWy__4Blgfztg4sKg' API_KEY = 'AIz****AJHs' url = "https://www.googleapis.com/youtube/v3/channels?id={}&key={}&part=statistics".format(CHANNEL_ID, API_KEY) # Aufbau einer WiFi Verbindung def wifiConnect(): wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect(ssid, password) print("Waiting to connect:") while not wlan.isconnected() and wlan.status() >= 0: print(".", end="") time.sleep(1) print("") print(wlan.ifconfig()) # Funktion zum absenden eines HTTP / HTTPS Request und # Rückgabe des Response # Quelle: https://www.programcreek.com/python/example/96165/ussl.wrap_socket def http_get(url): print("Fetching:", url) proto, _, host, path = url.split('/', 3) if proto == "http:": port = 80 elif proto == "https:": port = 443 addr = socket.getaddrinfo(host, port) s = socket.socket() s.connect(addr) if proto == "https:": s = ussl.wrap_socket(s, server_hostname=host) s.write(bytes('GET /%s HTTP/1.0rnHost: %srnrn' % (path, host), 'utf8')) result = '' while True: data = s.read(100) if data: result = result + str(data, 'utf8') else: break s.close() return result # Ermitteln des JSONs aus dem HTTP Response def findJson(response): txt = '{' return response def displayYouTubeStatistics(text, value): display.fill(0) display.text('YouTube channel', 0, 0, 1) display.text(CHANNEL_NAME, 0, 15, 1) display.text(text, 0, 30, 1) display.text(str(value), 0, 45, 1) display.show() # Main Funktion def main(): # Aufbau der Wifi-Verbindung wifiConnect() # Auslesen des HTTP Response response = http_get(url) #print(response) # ermitteln des JSONs jsonData = findJson(response) # umwandeln des JSONs in ein Dictionary aDict = json.loads(jsonData) statistics = aDict subscriberCount = statistics videoCount = statistics viewCount = statistics print('subscriberCount', subscriberCount, sep=" " ) print('videoCount', videoCount, sep=" " ) print('viewCount', viewCount, sep=" " ) pause = 2.5 displayYouTubeStatistics('subscriberCount', subscriberCount) time.sleep(pause) displayYouTubeStatistics('videoCount', videoCount) time.sleep(pause) displayYouTubeStatistics('viewCount', viewCount) time.sleep(pause) # Aufrufen der Funktion main() while True: main() # eine Pause von 5 Minuten einlegen # Der Server leht die Verbindung ab wenn der Intervall # des Zugriffs zu klein ist. time.sleep(300) Read the full article

[draegerit]

Raspberry Pi Pico W - Zeit aus dem Internet lesen und auf einem Display anzeigen

Wie man die Zeit von Time Server aus dem Internet lädt und mit dem neuen Raspberry Pi Pico W auf einem LCD-Display per I²C anzeigen lassen kann, möchte ich dir in diesem ausführlichen Beitrag zeigen.

Den neuen Raspberry Pi Pico W mit WiFi Support habe ich dir bereits in folgenden Beiträgen vorgestellt und einige kleine Projekte gezeigt. - Raspberry Pi Pico W mit Wi-Fi Support - Raspberry Pi Pico W – Webserver programmieren - Raspberry Pi Pico W mit Infineon CYW43438 Chip - Raspberry Pi Pico W – anzeigen von Sensordaten auf einer Webseite - Raspberry Pi Pico W – Webseite ins Internet veröffentlichen

Benötigte Ressourcen für dieses Projekt

Für dieses Projekt benötigst du, bzw. habe ich verwendet: - einen Raspberry Pi Pico W,- ein Micro-USB Datenkabel, - ein 2x16 Zeichen LCD-Display mit I²C Schnittstelle, - diverse Breadboardkabel

Aufbau der Schaltung, Raspberry Pi Pico W mit LCD-Display

In diesem Beitrag verwende ich ein einfaches 2x16 Zeichen LCD-Display mit I²C Schnittstelle. Es gibt jedoch auch größere Displays mit mehr Zeilen & Zeichen, wo du dann auch mehr Informationen anzeigen lassen kannst.

Raspberry Pi Pico mit LCD-Display via I²C Der Raspberry Pi Pico W hat 2 I²C Schnittstellen, welche du über die nachfolgenden Pins erreichen kannst: - I²C 0- SDA – GP0, GP8, GP12, GP16, GP20 - SCL – GP1, GP9, GP13, GP17, GP21 - I²C 1- SDA – GP2, GP6, GP10, GP14, GP18, GP26 - SCL – GP3, GP7, GP11, GP15, GP19, GP27

Auf der Schaltung - Raspberry Pi Pico W mit 2x20 Zeichen LCD-Display

Pinout des Raspberry Pi Pico (W)

Der neue Raspberry Pi Pico W ist mit dem Vorgängermodell von den Pins identisch, d.h. du kannst deine bestehenden Projekte recht einfach um die WiFi Fähigkeit erweitern.

Pinout des Raspberry PI Pico Erweiterungsplatine für den Raspberry Pi Pico Für das Vorgängermodell dem Raspberry Pi Pico von 2021 habe ich ein kleines Board entwickelt welches mit die I²C Pins sowie ein paar GPIOs auf Groove Konnektoren bereitstellt.

Raspberry Pi Pico W auf DIY Expansionboard

I²C Adapter für LCD-Display

Das verwendete LCD-Display hat einen kleinen I²C Adapter auf der Rückseite verbaut. Dieser Adapter verfügt über die Pins SDA, SCL, VCC und GND sowie über einen Drehpotentiometer (blaues Bauteil im Bild) über welchen die Helligkeit der Schrift gesteuert werden kann.

I²C Adapter für das LCD-Display

Programmieren des LCD-Displays in der Thonny IDE mit MicroPython

Für die Programmierung nutze ich die Thonny IDE welche kostenfrei unter https://thonny.org/ für Microsoft Windows, macOS & auch Linux heruntergeladen werden kann. Download & kopieren des Modules für das LCD-Display Für die Programmierung des LCD-Displays verwende ich ein Modul, welches vom GitHub Repository dhylands/python_lcd geladen werden kann. Von diesem Repository benötigen wir jedoch nur die beiden Dateien: - https://github.com/dhylands/python_lcd/blob/master/lcd/lcd_api.py - https://github.com/dhylands/python_lcd/blob/master/lcd/machine_i2c_lcd.py Diese beiden Dateien müssen wir auf dem Pi Pico im Ordner "lib" speichern. Da wir jedoch keinen direkten Zugriff auf diesem Ordner haben, müssen wir die beiden Dateien in einem Editor öffnen (zbsp. Notepad++). Im geöffneten Editor markieren und kopieren, wir den gesamten Text in einem geöffneten Tab in der Thonny IDE und speichern dieses in den Ordner "lib" unter den jeweiligen Dateinamen. Troubleshooting Beim Programmieren sind mir einige Fehlermeldungen ausgegeben worden, welche ich dir hier gerne zeigen möchte. OSError 28 Diesen Fehler erhältst du, wenn der Speicher des Mikrocontrollers aufgebraucht ist. D.h. du musst Speicher freigeben, um diesen Fehler zu beheben. Dieses können zbsp. nicht benötigte Bibliotheken sein, welche auf dem Mikrocontroller abgelegt wurden. ValueError: bad SCL pin / bad SDA pin Die konfigurierte I²C Verbindung ist nicht lesbar. Hier musst du deine Verkabelung und die verwendete Adresse prüfen. Quellcode - "Hello World!" auf dem LCD-Display Schreiben wir zunächst in jede Zeile des Displays ein paar Zeichen. from time import sleep from machine import I2C, Pin from machine_i2c_lcd import I2cLcd i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=100000) lcd = I2cLcd(i2c, 0x27, 2, 16) zeile1 = 'Hello World!'; zeile2 = 'from Pi Pico W' lcd.putstr(zeile1 + "n" + zeile2) sleep(2)

Auf der Schaltung - Raspberry Pi Pico W mit 2x20 Zeichen LCD-Display Auslesen einer Zeit vom Server Als Dienst nutze ich den Server http://worldtimeapi.org welchen wir in der URL die Zeitzone übergeben wie zbsp. http://worldtimeapi.org/api/timezone/Europe/Berlin und als Antwort ein JSON mit den Daten erhalten.

Damit wir diesen HTTP Request absenden und einen Response vom Server empfangen können, müssen wir uns zu einem bestehenden WLAN Netzwerk verbunden haben. Wie du das machst, habe ich dir bereits im Beitrag Raspberry Pi Pico W – Webserver programmieren gezeigt. Hier der Vollständigkeit der Code zum Herstellen einer Verbindung zu einem WLAN Netzwerk. import network import time ssid = '*****' password = '*******' wlan = network.WLAN(network.STA_IF) wlan.active(True) wlan.connect(ssid, password) print("Waiting to connect:") while not wlan.isconnected() and wlan.status() >= 0: print(".", end="") time.sleep(1) print("") print(wlan.ifconfig()) Wenn diese Verbindung aufgebaut ist, dann müssen wir einen Request an die oben genannte Adresse senden und den Response (ein JSON) auswerten. Die Funktion zum Absenden des HTTP Requests und Empfangen des HTTP Response habe ich aus der offiziellen Dokumentation unter https://docs.micropython.org/en/latest/esp8266/tutorial/network_tcp.html entnommen. # Funktion zum absenden eines HTTP Request und # Rückgabe des HTTP Response # Quelle: https://docs.micropython.org/en/latest/esp8266/tutorial/network_tcp.html def http_get(url): result = '' _, _, host, path = url.split('/', 3) addr = socket.getaddrinfo(host, 80) s = socket.socket() s.connect(addr) s.send(bytes('GET /%s HTTP/1.0rnHost: %srnrn' % (path, host), 'utf8')) while True: data = s.recv(100) if data: result = result + str(data, 'utf8') else: break s.close() return result # Ermitteln des JSONs aus dem HTTP Response def findJson(response): txt = 'abbreviation' return response Aus diesem JSON Response können wir nun diverse Informationen entnehmen. In meinem Fall interessiere ich mich für den UNIX Timestamp "unixtime". { "abbreviation":"CEST", "client_ip":"80.128.77.199", "datetime":"2022-07-25T14:22:21.415593+02:00", "day_of_week":1, "day_of_year":206, "dst":true, "dst_from":"2022-03-27T01:00:00+00:00", "dst_offset":3600, "dst_until":"2022-10-30T01:00:00+00:00", "raw_offset":3600, "timezone":"Europe/Berlin", "unixtime":1658751741, "utc_datetime":"2022-07-25T12:22:21.415593+00:00", "utc_offset":"+02:00", "week_number":30 } Damit die Daten aus dem JSON (eigentlich ein einfacher String) ausgelesen werden kann, wandeln wir dieses in ein Dictionary um. import json aDict = json.loads(jsonData) Nun können wir auf die Werte recht einfach mit dem entsprechenden Key zugreifen und den UNIX Timestamp in ein Tupel mit den Datum & Zeit Werten umwandeln. # parsen des Zeitstempels # Parameter ist das JSON als Dictionary def parseDateTimeStr(responeDict): # umwandeln des UNIX Timestamp in eine Liste aus Datum & Zeit Werten dateTime = time.localtime(int(responeDict)) year = dateTime month = dateTime dayOfMonth = dateTime # Wenn der Monat kleiner als 10 ist, # dann eine führende Null anhängen if month < 10: month = str('0' + str(month)) if dayOfMonth < 10: dayOfMonth = str('0' + str(dayOfMonth)) dateStr = str(dayOfMonth)+'.'+str(month)+'.'+str(year) hour = dateTime minutes = dateTime # offset für die Uhrzeit auslesen timeOffset = responeDict # Wenn der Offset mit einem Minus beginnt # dann soll der Wert abgezogen werden if timeOffset == '-': hour = hour - int(timeOffset) elif timeOffset == '+': # beginnt der Offset mit einem "+" # dann soll die Zeit addiert werden hour = hour + int(timeOffset) if hour < 10: hour = str('0' + str(hour)) if minutes < 10: minutes = str('0' + str(minutes)) timeStr = str(hour)+':'+str(minutes) # auslesen der Zeitzone timezone = responeDict # zurückgeben der Zeitzone, des Datums sowie der Uhrzeit return timezone, dateStr, timeStr Die ermittelten Werte für timezone, dateStr und timeStr speichern wir uns in einer Variable welche wir auf dem Display dann mit der Funktion "displayDateTime" anzeigen lassen wollen. In der Funktion wird die Zeichenkette für die Timezone in min. 16 Zeichen umgewandelt bzw. es werden entsprechende Leerzeichen ergänzt. Der Hintergrund ist das wenn es weniger Zeichen sind, dann wird kein vernünftiger & zuverlässiger Zeilenumbruch gemacht. Das ist vor allem beim Aktualisieren des LCD-Displays aufgefallen. # parsen des Zeitstempels aus dem Dictionary timezone, dateStr, timeStr = parseDateTimeStr(aDict) # ausgeben der Werte auf dem LCD-Display displayDateTime(timezone, dateStr, timeStr) # Anzeigen der Daten auf dem Display # Hinweis: Wenn die Zeichen der Zeitzone # länger als 16 Zeichen ist, dann wird # diese automatisch umgebrochen! def displayDateTime(timezone, dateStr, timeStr): timezone = "{: Read the full article

[draegerit]

Next Project is to create code a OLED Display at Raspberry Pi Pico W to show YouTube statistics First step coding OLED Display in Micropython via i2c #raspberrypi #pico #pipico #RaspberryPIPico #raspberrypipicow #oled #display #programming #coding #maker #diy #tech #techy #technology #electronic #components #microcontroller #draegerit (hier: Stefan Draeger Software) https://www.instagram.com/p/Cgv6gyYLY4B/?igshid=NGJjMDIxMWI=