#raspberry pi pico pinout

[elcereza]

Raspberry Pi Pico: Vale a pena aprender?

Aprenda como usar todos os periféricos do Raspberry Pi Pico, Como instalar bibliotecas no Thonny IDE e ainda veja um comparativo do Pico/Pico W com ESP32, tudo em um único post. Mais completo que isso somente o datasheet.

O Raspberry Pi Pico desde o lançamento vem sendo muito desejado por muitos projetistas, mas será que realmente vale a pena aprender? Neste post você vai aprender tudo sobre ele. 1 Surgimento do Raspberry Pi Pico Quem acompanha a empresa Raspberry Pi, sabe que todos seus lançamentos tem um preço base para um determinado produto e o propósito disso é democratizar ao máximo o acesso aos produtos…

Ver no WordPress

[draegerit]

Seeed Studio XIAO RP2040 - programmieren & Beispiele

In diesem Beitrag möchte ich dir den Mikrocontroller XIAO RP2040 vorstellen. Dieser kleine Mikrocontroller kommt mit dem Mikrochip RP2040 daher, welcher von der Raspberry Foundation veröffentlicht wurde.

Seeed Studio XIAO RP2040 - programmieren & Beispiele Den Raspberry Pi Pico & Raspberry Pi Pico W habe ich dir bereits in separaten Beiträgen vorgestellt. - Raspberry PI Pico #1 – Vorstellung - Raspberry Pi Pico W mit Wi-Fi Support Im letzten Beitrag Seeed Studio XIAO RP2040 – ein Zwerg mit großer Leistung habe ich dir bereits einiges zu der Technik und dem Pinout gezeigt, hier möchte ich dir nun ein paar kleine Beispiele zeigen.

Vorbereiten des Mikrocontrollers

Bevor wir den Mikrocontroller auf einem Steckbrett verwenden können, müssen wir noch die Stiftleisten anlöten.

Dem Mikrocontroller liegen leider keine bei, jedoch bekommst du diese recht günstig auf ebay.de schon ab 1,35 € zzgl. Versandkosten und sogar in diversen Farben. Alternativ kannst du auch Buchsenleisten mit langen Stiften verwenden, hier hast du dann den Vorteil, dass du von oben Breadboardkabel einstecken kannst und trotzdem diesen auf einem Steckbrett stecken kannst.

Stiftleisten zum Löten in den Farben rot, gelb, blau und schwarz

Buchsenleiste mit langen Stiften

Anschluss an den Computer

Für den Anschluss an den Computer, benötigst du ein USB-Typ-C Datenkabel, dieses ist wiederum bedauerlicherweise auch nicht enthalten, aber dieser Anschluss ist ja bei Handys, Tablets sehr verbreitet und somit sollte man ggf. eines bereits zu Hause haben. Wenn du den Mikrocontroller mit dem Computer verbunden hast, dann wird dieser zunächst eingerichtet, unter Microsoft Windows 10 erhältst du nachfolgende Push-Benachrichtigungen vom System.

Der Mikrocontroller wird als PicoArduino erkannt, aber dazu etwas mehr, wenn wir im nächsten Kapitel zur Programmierung kommen. Auf dem Mikrocontroller ist bereits ein kleines Programm installiert, welches die verbaute RGB LED in diversen Farben aufleuchten lässt.

Programmieren des Seeed Studio XIAO RP2040

Den Mikrocontroller kannst du in diversen IDEs programmieren, im Nachfolgenden möchte ich dir gerne zeigen, wie du diesen in der Thonny IDE programmierst. Thonny IDE Die Thonny IDE kannst du kostenfrei für macOS,Linux und auch Microsoft Windows herunterladen. Wie du diese IDE auf einem Linux System installierst, habe ich dir im Beitrag Thonny IDE auf Linux einrichten für den Raspberry Pi Pico W anhand des Raspberry Pi Pico W gezeigt. Damit du diesen Mikrocontroller in der Thonny IDE mit Micropython programmieren kannst, muss zunächst die passende Firmware installiert werden, damit dieses wiederum geschehen kann, musst du die Taste "Boot" gedrückt halten und den Stecker des Mikrocontrollers in die Buchse stecken. Im Anschluss sollte sich nun ein neues Laufwerk einbinden.

installieren der Firmware für Micropython über Thonny IDE Wenn der Installationsvorgang abgeschlossen ist, dann wird der Mikrocontroller als "Raspberry Pi Pico" erkannt. Das ist auch nicht sehr verwunderlich, denn immerhin ist auf diesem der Chip RP2040 verbaut. MicroPython v1.19.1 on 2022-06-18; Raspberry Pi Pico with RP2040 Type "help()" for more information. >>> Programmieren des NeoPixel Der verbaute NeoPixel liegt zwischen den beiden Tasten "RESET" und "Boot" und kann über den Pin 11 erreicht werden. Damit wir diese jedoch programmieren können, benötigen wir eine kleine Bibliothek, welche wir unter https://files.seeedstudio.com/wiki/XIAO-RP2040/img/micropython/ws2812.py herunterladen können. Wenn diese Datei heruntergeladen wurde, dann öffnen wir diese in der Thonny IDE und speichern diese auf dem Mikrocontroller. #importieren der benötigten Bibliotheken #für den NeoPixel from ws2812 import WS2812 #zum einlegen einer kleinen Pause import time #definieren der Farben im RGB Format #Rot RED = (255, 0, 0) #Gelb YELLOW = (255, 150, 0) #Grün GREEN = (0, 255, 0) #Weiß WHITE = (255, 255, 255) #Tupel mit den Farben und den dazugehörigen Namen COLORS = ((RED,"rot"), (YELLOW,"gelb"), (GREEN,"grün"), (WHITE,"weiß")) #WS2812(pinNum, ledCount) led = WS2812(12,1) #Endlosschleife while True: #Loop über das Tupel for color in COLORS: #erster Wert ist die RGB Farbe led.pixels_fill(color) led.pixels_show() #zweiter Wert ist der Name print(color) #eine kleine Pause einlegen time.sleep(1) https://youtu.be/AZ5lEsKyu1U LED per Taster EIN/AUS schalten Im nächsten Schritt zeige ich dir, wie du eine kleine LED per Taster EIN/AUS schalten kannst.

Hier nun der Code inkl. dem entprellen des Tasters. #importieren der benötigten Module #zum steuern der GPIOs from machine import Pin #zum einlegen von Pausen oder #dem auslesen von Zeit import time #die LED ist am Pin 3 (D10) angeschlossen led = Pin(3, Pin.OUT) #der Taster ist am Pin 7 (D5) angeschlossen button = Pin(7, Pin.IN) #Feld zum speichern des Zeitstempels der #letzten Ausführung last_action = 0 #Zeit welche zwischen zwei Ausführungen liegen soll #dient quasi dem entprellen des Tasters delay = 500 #Endlosschleife while True: #lesen der vergangenen Millisekunden #seitdem der Mikrocontroller gestartet wurde currentMillis = time.ticks_ms() #Wenn der Taster betätig wurde, dann... if button.value(): #Wenn der Zeitpunkt der letzten Ausführung kleiner #als der aktuelle Zeitpunkt - dem Delay liegt, dann... if(last_action < (currentMillis - delay)): #überschreiben des Wertes für die letzte Ausführung #mit dem aktuellen Wert last_action = currentMillis #Umkehren des Signales am Pin der LED led.toggle() https://youtu.be/0xauJsi6IeQ Read the full article

[onedirectdeals]

Waveshare RP2040-One 4MB Flash MCU Board Based On Raspberry Pi RP2040 Microcontroller Chip, Pico-like MCU board Onboard USB-A Plug, Support C/C++, MicroPython

Price: Buy Now Last Updated: Overview RP2040-One is a mini RP2040 development board. The onboard PCB USB-A connector makes it plug-and-play instantly. Mini body, 29 x multi-function GPIO pins (20 x via edge pinout, others via solder points), and the edge of the PCB adopt the castellated design, which can be easily and quickly integrated into your project. Features RP2040 microcontroller chip…

[ella-fan]

Uncovered Raspberry Pi Pico👇

Engineered by the Raspberry Pi company, the Raspberry Pi Pico stands as a distinctive microcontroller board within their range of offerings. In a manner akin to products like Arduino and ESP-32, the Pico was purposefully crafted for the management of electronic components, excelling in executing uncomplicated tasks within fundamental electronics projects, setting it apart from the comprehensive capabilities of a full-scale Raspberry Pi computer.

Unveiling the Essence of the Raspberry Pi Pico

The Raspberry Pi Pico emerges as a minimalist, economically-priced, and high-performance microcontroller board centered around the formidable RP2040 chip. Notably, the RP2040 constitutes an in-house microcontroller chip originating from Raspberry Pi Ltd., orchestrating the functionality of various other boards founded on the RP2040 architecture, alongside the Pico.

As the official RP2040 board from Raspberry Pi, the Pico boasts an embedded 2MB QSPI flash memory, catering to code writing and loading. Encompassing a total of 40 pins, the Pico offers seamless interaction with a diverse array of electronic components, with 26 of these pins assuming multifaceted roles as GPIO pins. A comprehensive exploration of the Raspberry Pi Pico's pinout is readily available for further scrutiny.

Diverse Iterations of the Raspberry Pi Pico board are on offer: the standard Pico (featuring unpopulated pin holes), the Pico H (with pre-soldered pin headers), the Raspberry Pi Pico W (equipped with Wi-Fi and Bluetooth capabilities), and the Pico WH (amalgamating wireless connectivity with pre-soldered headers).

Powering the Raspberry Pi Pico: A Deeper Insight

In contrast to its Raspberry Pi single-board computer counterparts, the Pico showcases a notably frugal power consumption profile. It demonstrates versatility in operation, sustaining voltage supply within the range of 1.8V to 5.5V DC. This adaptability enables utilization through either a 5V USB port on a computer or a pair of AA batteries, affording users the freedom to select their preferred power source. The Pico accommodates power input via both the micro-USB port on the board and GPIO pin 39 (VSYS), further amplifying its accessibility and ease of use.

[techcree]

Bluetooth für den Raspberry Pi Pico W

Der bliebte Microcontroller der Raspberry Pi Foundation erlaubt auch die Nutzung von Bluetooth. Jetzt gibt es mehr darüber...

Kaum ein Microcontroller steht wohl so in der Gunst der Nutzer, wie der Raspberry Pi Pico und dessen Wirelss Version Pico W. Der Pico W hat uns durch WLAN viele neue Anwendungsmöglichkeiten eröffnen. Doch was die Meißten so nicht auf dem Schirm hatten war, dass der Microcontroller von Beginn an auch über Bluetooth (BT) verfügte.

Kein Wunder, denn es gab dazu weder die nötige Software im Betriebssystem (OS/_SDK) noch Programmcode für Anwendungen, wie bspw. in Micropython. Damit liegt Bluetooth brach. Es war jedoch klar, dass sich dies ändern sollte und mit dem Update der SDK auf die Version 1.5.0, sollte sich hier etwas tun. Jetzt ist die neue Version erschienen und die ersten Beta für Bluetooths sind da.

Wir stehen jedoch im Bezug auf BT beim Pico W noch ganz am Anfang. Einige Tüfftler haben aber bereits erste Erfahrungen mit BT beim Pico W und es gibt in sofern auch bereits Code dafür. Wie das werdet ihr fragen? Die Lösung, welche das Warten auf die Onboard-BT-Funktion überbrückte war die Verwendung eines zusätzlichen BT-Modules HC-06, welches mit dem Pico W über dessen PinOuts verbunden werden konnte.

Dazu musste man vom Bluetooth Modul HC-06 den Kontakt RXD mit GP0/UART0 TX beim Pico herstellen, ferner TXD auf GP1/UART0 RX, GND auf 35(GND) und VCC auf 40/VBUS verbinden. Wenn wir von BT Verbindungen sprechen müssen wir uns auch mit dem Thema App auseinandersetze. Hier muss man nicht unbedingt eine eigene App programmieren, sondern kann ggf. sich bereits mit der Serial Bluetooth Terminal App aus dem Google PlayStore helfen.

Sicher wird es nun Anpassungen geben, die auf dem Code des HC-06 Moduls fußen und natürlich neuen Code, der im Laufe der nächsten Wochen entwickelt werden wird. Jetzt wo wir aber das Boardeigene BT des Raspberry Pi Pico nutzen können benötigen wir passende Anwendungen auf der Basis von Micropython und genau an diesem Punkt haben wir derzeit noch einen Showstopper.

Nachfolgende Links führen Dich auf Websites mit Details über BT beim PicoW und zur neuen SDK:

Doch was bringt es uns? Am Beispiel eine LED ein- und auszuschalten können wir dies beim Pico W aktuell ja sehr fein indem wir einen Webserver auf dem Pico ausführen. Jetzt könnten wir das auch über Bluetooth tun. Mhhh. Schön soweit. Steuern wir einen selbstgebauten Roboter, den wir mit einem PicoW antreiben könnte das natürlich viel nützlicher sein eine BT Verbindung dafür zu nutzen. Wir dürfen also hier ein paar neue Produkte erwarten, bei denen nun der Raspberry Pi Pico W ein wesentliches Bauteil sein wird, um beispielsweise Servos zu steuern.

[draegerit]

Raspberry Pi Pico 2: Maximale Leistung bei unverändertem Layout

Raspberry Pi Pico 2 - RP2350: Die Raspberry Foundation hat jetzt eine neue Version des Raspberry Pi Pico veröffentlicht. Diese erweiterte Version des ursprünglichen Pico verfügt über eine leistungsstärkere MCU. Zwar fehlen dem Mikrocontroller die Bluetooth und WiFi Schnittstelle, aber dennoch werde ich ihm eine Chance geben und ihn genauer unter die Lupe nehmen. https://youtu.be/rUWj13kCUMg Den Raspberry Pi Pico 2 habe ich mir auf der diesjährigen Maker Faire Hannover bei Berry Base für 5,5 € gekauft. Da ich diesen vor Ort gekauft habe, entfallen hier die üblichen Versandkosten und somit war es ein gutes Schnäppchen.

Technische Daten des Pi Pico 2 mit RP2350 MCU

Nachfolgend zunächst die technischen Daten des Pi Pico 2: Technische DatenBeschreibungProzessorenDual Arm Cortex-M33 oder Dual Hazard3 RISC-V Prozessoren @ 150MHzOn-Chip-Speicher520 KB SRAMKompatibilitätSoftware- und hardwarekompatibel mit Raspberry Pi Pico 1Schnittstellen2x UART, 2x SPI-Controller, 2x I2C-Controller, 24x PWM-Kanäle, 3x ADC-KanäleUSB1 × USB 1.1-Controller und PHY, mit Host- und GeräteunterstützungSDK und ProgrammiersprachenOpen-Source-C/C++ SDK, MicroPython CircuitPython, Arduino IDEBetriebstemperatur-20 °C bis +85 °CEingangsspannungUnterstützte Eingangsspannung: 1,8–5,5V DCAuszug aus der offiziellen Dokumentation zum Raspberry Pi Pico 2 Sicherheitsfunktionen Umfassende und vollständig dokumentierte Sicherheitsfunktionen: - ARM TrustZone für Cortex-M - Optionales Boot-Signing, durch On-Chip-Masken-ROM durchgesetzt, mit Schlüssel-Fingerprint in OTP - Geschützter OTP-Speicher für optionalen Boot-Entschlüsselungsschlüssel - Globales Bus-Filtering basierend auf Arm- oder RISC-V-Sicherheits-/Privilegienstufen - Peripheriegeräte, GPIOs und DMA-Kanäle einzeln Sicherheitsdomänen zuweisbar - Hardware-Maßnahmen gegen Fehlerinjektionsangriffe - Hardware SHA-256-Beschleuniger Unterschiede der verfügbaren Versionen zum RP2350 Es gibt insgesamt vier Versionen zu dieser neuen MCU. Unter dem Link »hier« findest du eine ausführliche Beschreibung in englischer Sprache vom Hersteller dazu. VersionInterner SpeicherGPIO-AnschlüsseAnaloge EingängeRP2350AKeiner304RP2350BKeiner488RP2354A2 MB Flash304RP2354B2 MB Flash488

Pinout der RP2350 MCU

Nachfolgend das Pinout des Raspberry Pi Pico 2. Da dieses zu 100 % mit dem Vorgängermodell kompatibel ist, wirst du hier keine Besonderheiten finden.

RPiPico2 RP2350 Pinout Die Grafik durfte ich mir mit freundlicher Genehmigung der Raspberry Pi Foundation von der Seite https://www.raspberrypi.com/documentation/microcontrollers/pico-series.html entnehmen.

Der XIAO RP2350 im Vergleich mit dem originalen Pi Pico 2

Neben dem originalen Pi Pico 2 habe ich mir den XIAO RP2350 aus China gekauft und dieser wurde recht schnell innerhalb von 5 Tagen geliefert. (Abzüglich der üblichen Probleme mit dem Zoll.) Dieser kleine Zwerg kommt mit etwas weniger Pins daher, hat jedoch den Vorteil, dass dieser zumindest über eine fortschrittliche USB-Typ-C Schnittstelle verfügt und sofort programmiert werden kann (dazu später mehr).

Dieser kleine Mikrocontroller besitzt zusätzlich eine RGB-LED, die über GPIO22 gesteuert werden kann. Zudem kann die als USER-LED bezeichnete LED über GPIO25 angesprochen werden. Die USER-LED wird ebenso verwendet, um den aktuellen Status anzuzeigen (UART Übertragung und POWER).

Einrichten und programmieren des originalen RP2350A

Der Mikrocontroller wird wie über die Micro-USB Buchse mit dem Computer verbunden und wird dort als RP2350 Boot erkannt.

In der Arduino IDE sowie Thonny wird dieser jedoch nicht erkannt und ich musste diesen Mikrocontroller erstmal flashen. Dazu habe ich mir die UF2-Datei von der Seite https://micropython.org/download/RPI_PICO2/ geladen und auf den Mikrocontroller kopiert. Der Mikrocontroller war dazu bereits im korrekten Modus versetzt gewesen, d.h. es war das Laufwerk RP2350 im Explorer sichtbar. Nachdem der Mikrocontroller selbständig neu gestartet ist, war dieser in Thonny einsatzbereit und man kann nun diesen mit MicroPython programmieren.

Raspberry Pi Pico 2 - RP2350 geflasht für MicroPython Nachrüsten der fehlenden Bluetoothschnittstelle mit dem seriellen HC-06 Modul Zumindest kann man die fehlende Bluetoothschnittstelle mit dem seriellen Bluetoothmodul HC-06 sehr einfach nachrüsten. Es gibt auch ESP8266 Module, welche ebenso via serieller Schnittstelle angeschlossen werden können (jedoch habe ich derzeit keines zur Hand, ist aber bestellt).

Für den Aufbau der Schaltung benötigst du: - einen Raspberry Pi Pico 2* - ein Micro-USB Datenkabel* - vier Breadboardkabel*, 10 cm - eine LED* - ein Bluetoothmodul HC-06* - ein 400 Pin Breadboard* Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung! Die Schaltung hierzu ist recht einfach, für die serielle Kommunikation benötigen wir lediglich zwei Breadboardkabel und für die Stromversorgung des Modules ebenso zwei. In meinem Fall verwende ich eine 10 mm LED, welche eine Spannungsversorgung von 3.3V hat, somit direkt mit dem Mikrocontroller verbunden werden kann (quasi ohne 220 Ohm Vorwiderstand).

Schaltung - Raspberry Pi Pico mit Bluetoothmodul HC-06 & LED Im Beitrag Raspberry Pi Pico W & Bluetooth habe ich dir erläutert, wie man das Vorgängermodell mit dem CYW43438 Chip über das HC-06 Modul Bluetoothfähig macht. Der Chip CYW43438 verfügt neben WiFi auch über Bluetooth, jedoch kam dieses erst mit einem Firmwareupdate und somit gab es eine Zeit wo der Pico W ohne Bluetooth geliefert wurde. # Import der benötigten Module # zum kommunizieren über # die serielle Schnittstelle from machine import Pin, UART # definieren der seriellen Schnittstelle # der Pi Pico verfügt über mehrere serielle Schnittellen # es wird hier die erste verwendet mit # einer Geschwindigkeit von 9600 baud uart = UART(0, 9600) # die LED ist am GPIO6 angeschlossen led = Pin(6, Pin.OUT) # starten der Endlosschleife while True: # Wenn Daten empfangen wurden, dann... if uart.any() > 0: # auslesen der Daten data = uart.read() # ausgeben der Daten auf der seriellen Schnittstelle # diese können via Putty oder # in der Shell von Thonny abgelesen werden print(data) # Wenn der gelesene Wert gleich 'on' ist, dann... if "on" in data: # aktivieren der LED led.value(1) # absenden der Zeichenkette an den Sender uart.write('LED on n') elif "off" in data: # Wenn der Wert 'off' ist, dann... # LED deaktivieren led.value(0) # absenden der Zeichenkette an den Sender print('LED off n') uart.write('LED off n') Read the full article

[draegerit]

RP2040 Mikrocontroller: Klein, stark und direkt im USB-Port einsatzbereit

In diesem Beitrag möchte ich dir einen kleinen Mikrocontroller mit RP2040 Chip vorstellen. Das Besondere an diesem ist, dass dieser direkt in den USB-Port gesteckt wird. Du benötigst somit kein extra Datenkabel für den betrieb. https://youtu.be/4SJ7pc-i9P8 Diesen kleinen Mikrocontroller habe ich über aliexpress.com für knapp 5 € inkl. Versandkosten erworben. Der Preis ist gemessen an der Leistung sowie dem Umfang okay, aber auch nicht besonders günstig. Wenn man diesen direkt mit dem originalen Raspberry Pi Pico vergleicht (nicht die Variante mit WiFi) dann ist dieser gleich teuer / günstig.

Aufbau des RP2040 Mikrocontrollers für den USB-Port

Dieser kleine Mikrocontroller verfügt über den RP240 Chip, welcher nachfolgende Daten hat: - Dual ARM Cortex-M0+ @ 133MHz - 264 kB SRAM - 16 MB Flash-Speicher

Zusätzlich findest du auf diesem Mikrocontroller noch eine RGB LED, welche du frei programmieren kannst. Ebenso findest du eine Qwiic Schnittstelle, an welche du via I2 Sensoren & Aktoren anschließen kannst. Wenn du das Arduino Plug & Make Kit hast, dann kannst du von diesem Kit diese Komponenten auch an den Mikrocontroller anschließen.

Natürlich findest du noch zwei Taster RESET & BOOT. Die Taste BOOT benötigst du zum Beispiel, wenn du deinen Mikrocontroller mit einer anderen Firmware Version flashen möchtest. Pinout des Mikrocontrollers Auf der Rückseite des Mikrocontrollers sind die Pins gekennzeichnet. Aufgrund der kompakten Größe sind nicht alle vom RP2040 bereitgestellten Pins am Mikrocontroller zugänglich. Meistens können die Pins direkt über Stiftleisten erreicht werden, zudem stehen zusätzliche Lötpunkte zur Verfügung.

Die Lötaugen für die Zusätzlichen Pins sind nett gemeint, finde ich persönlich jedoch weniger gut geeignet. Hier wäre ggf. eine zweite Reihe mit Stiftleisten deutlich vorteilhafter. Nachfolgend das Pinout des originalen Raspberry Pi Pico, die Pinbeschriftungen 0 bis 29 findest du ebenso auf dem Mini USB Mikrocontroller.

Pinout des Raspberry PI Pico

Vergleich mit dem originalen Raspberry Pi Pico

Der Raspberry Pi Pico ist bereits seit mehreren Jahren auf dem Markt und bietet seit 2023 sogar Unterstützung für WiFi und Bluetooth. Im Vergleich dazu schneidet der kleine Mikrocontroller für die USB-Buchse schlechter ab. Trotz der netten RGB-LED halte ich es für wichtiger, viele Pins für Projekte zur Verfügung zu haben.

Für kleinere Projekte ist der Mini USB RP2040 jedoch besser geeignet, sodass die Wahl des besten Mikrocontrollers letztlich vom jeweiligen Anwendungsfall abhängt.

Programmieren des Mini USB RP2040 Development Board in der Arduino IDE

Der kleine Mikrocontroller ist für die Programmierung in der Arduino IDE vorbereitet / geflasht. D.h. du musst dir lediglich den passenden Boardtreiber installieren und kannst dann sofort loslegen. Installieren des Boardtreibers Über den internen Boardverwalter (1) der Arduino IDE suchst du zunächst nach RP2040 (2) und aus der Ergebnisliste wählst du am Eintrag "Arduino Mbed OS RP2040 Boards" die Schaltfläche INSTALLIEREN (3). Da ich bereits diesen installiert habe, steht bei mir die Schaltfläche ENTFERNEN.

Wenn der Boardtreiber erfolgreich installiert wurde, dann findest du diesen unter Werkzeuge > Board: xyz > Arduino Mbed OS RP2040 Boards > Raspberry Pi Pico (siehe Grafik).

Programmieren der RGB LED Die RGB LED ist am GPIO 22 angeschlossen und kann mit der Adafruit NeoPixel Bibliothek sehr einfach programmiert werden. #include #define PIN 22 //RGB LED am GPIO22 angeschlossen #define NUMPIXELS 1 //Anzahl der verbauten RGB LEDs //Objekt instanz erzeugen mit der Konfiguration Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); uint32_t colors = { pixels.Color(0, 150, 0), //grün pixels.Color(150, 0, 0), //rot pixels.Color(0, 0, 150), //blau pixels.Color(150, 150, 0), //gelb pixels.Color(255, 255, 255) //weiß }; void setup() { //begin der Kommunikation mit den NeoPixels pixels.begin(); } void loop() { //löschen der gesetzten Farbe pixels.clear(); //Schleife von 0 bis 4 //Da Arrays mit dem Index 0 beginnen muss hier mit dem //Index 0 angefangen werden und bis max. 4 durchlaufen werden. for (int i = 0; i < 5; i++) { //setzen der Farbe aus dem Array mit der Laufvariable i an dem //Index 0 der LED Stripe. pixels.setPixelColor(0, colors); //anzeigen der Farbe pixels.show(); //eine kleine Pause von 500 Millisekunden delay(500); } } Flammensensor programmieren Auf meinem Blog habe ich dir den Flammensensor bereits für den Arduino vorgestellt. Dieser reagiert, wie die Bezeichnung es erahnen lässt auf eine Flamme wie zum Beispiel von einem Feuerzeug. Der Sensor hat zwei Pins (einen analogen sowie einen digitalen) und zwei für die Stromversorgung. Im nachfolgenden Code verwende ich den digitalen Ausgang des Sensors und wenn dieser auf HIGH ist, dann ändere ich die Farbe der LED von grün auf rot. #include #define PIN 22 #define NUMPIXELS 1 #define flammeSensor 0 Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); void setup() { Serial.begin(9600); pinMode(flammeSensor, INPUT_PULLDOWN); pixels.begin(); } void loop() { pixels.setPixelColor(0, pixels.Color(0, 150, 0)); pixels.show(); if (digitalRead(flammeSensor) == 1){ Serial.println("Flamme erkannt"); pixels.setPixelColor(0, pixels.Color(150, 0, 0)); pixels.show(); delay(500); } }

Ausblick zum Mikrocontroller mit RP2040 Chip für den USB-Port

Im nächsten Beitrag möchte ich dir ein kleines Projekt mit diesem Mini USB Mikrocontroller vorstellen, sei also gespannt... Read the full article

[draegerit]

MicroPython mit ESP32: Einführung in den ESP32 D1 R32

In diesem und kommende Beiträge möchte ich dir eine Einführung in die Programmierung des ESP32 mit MicroPython bieten. Bevor wir jedoch diesen kleinen Kurs starten können, müssen wir diesen Mikrocontroller etwas näher kennenlernen und flashen. https://youtu.be/l0HLbqQlHEY

Was ist besonders am ESP32 D1 R32?

Dieser Mikrocontroller mit einem ESP-WROOM-32 Chip hat den Formfaktor eines Arduino UNO R3/R4 und damit ist das Layout bekannt und besonders für Anfänger geeignet da man sich wenig umstellen muss.

ESP32 D1 R32

ESP32 D1 R32

ESP-WROOM-32 Chip auf dem ESP32 D1 R32 Vor allem hat man den Vorteil das man ein Multifunktionales Shield aufstecken und so mit der Programmierung starten kann ohne sich um eine Schaltung kümmern zu müssen.

ESP32 D1 R32 mit Rich Shield von Open Smart Technische Daten des ESP32 D1 R32 Der ESP32 D1 R32 ist ein leistungsstarkes Entwicklungsboard mit folgenden technischen Spezifikationen: Technische DatenSpezifikationenBetriebsspannung5V-12V DCStromstärke250mA (maximal)Mindest-Betriebsstrom20mA (ohne WiFi)WiFi802.11 b/g/n/e/i (bis zu 150 Mbps)AnschlussMikro-USB mit CH340-TreiberSpeicher4 MB Flash-SpeicherTaktfrequenz240 MHzAbmessungen68 mm x 53 mmDigitale Ein-/Ausgänge20 (3,3 V)Analoge Eingänge6 Wichtig: Der ESP32 hat an seinen digitalen Ein-/Ausgängen eine Spannung von 3,3V, dieses ist deutlich weniger als beim Arduino UNO R3 und daher muss man dieses bei seinen geplanten Schaltungen beachten!

Aufbau & Pinout des Mikrocontrollers

Der Mikrocontroller verfügt über eine Micro-USB Buchse, über welche dieser mit dem Computer für die Programmierung verbunden werden kann, alternativ kann daran auch eine Power Bank angeschlossen werden, um diesen mobil mit Strom zu versorgen.

Pinout des ESP32 D1 R32

Verbinden des Mikrocontrollers mit dem PC

Über die Micro-USB Buchse wird der Mikrocontroller mit dem PC verbunden. Auf dem Gerät ist ein seriell-USB Konverter vom Typ CH340 verbaut, damit wir den Mikrocontroller korrekt einbinden können, müssen wir einen Treiber installieren. Es gibt diverse CH340 Treiber, mit dem bereitgestellten Treiber von Wemos konnte ich diesen korrekt installieren.

eingerichteter ESP32 DE1 R32 in Windows

Flashen des ESP32 D1 R32 für die Programmierung in MicroPython

Damit wir den Mikrocontroller in MicroPython programmieren können, müssen wir diesen mit einer neuen Firmware flashen. Wir können dazu entweder das Kommandozeilentool esptool verwenden, oder man nutzt die einfache Entwicklungsumgebung Thonny. Im Nachfolgenden erläutere ich dir, wie du den ESP32 D1 R32 in MicroPython mit der Thonny IDE flasht. Im ersten Schritt wählen wir in der Thonny IDE unten rechts "Konfiguriere den Interpreter ..." aus.

Um anschließend den Interpreter auf "MicroPython (ESP32)" sowie den korrekten Port einzustellen. Wenn du mehrere serielle Geräte am PC angeschlossen hast, so solltest du vorher im Geräte-Manager prüfen, an welchem COM-Port der ESP32 angeschlossen ist. Abschließend klickst du unten rechts auf den Link "MicroPython installieren oder aktualisieren..." Hier musst du die nachfolgenden Einstellungen treffen (siehe Grafik). Diese Anleitung funktioniert auch für andere Geräte wie dem Raspberry Pi Pico / Pico W, du musst lediglich die Daten für MicroPython family & variant anpassen. Mit der Schaltfläche "Installieren" wird dann der Vorgang gestartet.

Wenn der Prozess erfolgreich abgeschlossen ist und die Fenster geschlossen wurden, dann solltest du in der Kommandozeile nachfolgende Ausgabe sehen. Natürlich kann es sein, dass die Versionsnummer zum Zeitpunkt, wenn du diesen Beitrag liest, erhöht wurde, aber die Informationen bleiben gleich.

Thonny IDE im Überblick

Schauen wir uns die Anwendung Thonny nachfolgend etwas genauer an.

In der Titelleiste finden wir den Dateinamen der derzeit geöffneten Datei / des gewählten Tabs sowie die Cursor-Position. In der Toolbar finden wir die Schaltflächen zum Starten und Stoppen von Skripten. Wenn wir uns den linken Bereich ansehen, dann finden wir einen kleinen Datei Explorer mit welchem wir Datei öffnen und auch über das Kontextmenü diese auf den Mikrocontroller kopieren können. Im Feld welches mit "Ausgabe" gelabelt wurde, werden dir die Ausgaben aus dem Code angezeigt. Zusätzlich kannst du da auch Eingaben tätigen.

Ausblick

Dieses war nun der erste Teil zu meiner Reihe "MicroPython mit ESP32" im nächsten Beitrag möchte ich dir die Programmiersprache näher zeigen und kleine Programme damit vorstellen. Bleib also gespannt... Read the full article

[draegerit]

Raspberry Pi Pico Pinout: Eine ausführliche Übersicht

Der Raspberry Pi Pico hat eine bemerkenswerte Historie und ist seit mehreren Jahren auf dem Markt. Ab Juli 2022 wurde er sogar mit integriertem WiFi ausgestattet, und in diesem Jahr kam die Bluetooth-Funktion hinzu. Trotz dieser Hardware-Upgrades bleibt eines konstant: das Pinout. In diesem Artikel werde ich detailliert auf das Pinout des Raspberry Pi Pico eingehen und es ausführlich erklären.

Der Raspberry Pi Pico (im nachfolgenden einfach nur als Pi Pico bezeichnet) verfügt über 40 Pins, an welchen diversen Funktionen anliegen.

Pinout des Raspberry Pi Pico

Hier nun zunächst das Pinout des Pi Pico.

Pinout des Raspberry PI Pico GPIOs Die Pins, welche in der Grafik mit GP gekennzeichnet sind, dienen als Ein- und Ausgang. Du findest an deinem Pi Pico von GP0 bis GP28 wobei die Pin GP 23,24,25 und 29 extern nicht verfügbar sind. ADCx Pins Zusätzlich findest du noch drei Pins, welche mit ADCx gekennzeichnet sind. Diese Pins sind an einen Analog-Digital-Wandler angeschlossen und somit dienen diese als Analog-IN. Stromversorgung von externen Sensoren / Aktoren Für die Stromversorgung hast du am Pi Pico acht GND Pins sowie einen 3.3V (3V3(OUT)) Pin und einen 5V Pin (VBUS) zur Verfügung. Über diese beiden Pins kannst du externe Sensoren und Aktoren mit Spannung versorgen, jedoch musst du beachten, dass maximal 300 mA am 3V3(OUT) Pin anliegen dürfen. Stromversorgung des Pi Pico Der Pi Pico kann über die Micro-USB Schnittstelle mit Strom versorgt werden, oder aber auch über den Pin VSYS. An den Pin VSYS kannst du eine Spannung zwischen 1,8 V und 5,5 V anlegen. Jedoch kannst du dann den zuvor genannten Pin VBUS welcher eigentlich 5 V liefert nicht mehr benutzen! Pins zum Ein-Ausschalten und RESET des Pi Pico Wenn du den Pin 3V3_EN mit GND verbindest, dann wird der Mikrocontroller ausgeschaltet. Um an deinem Pi Pico einen RESET durchzuführen, musst du lediglich den Pin RUN mit GND verbinden.

Anlegen einer externen Spannungsversorgung an den Raspberry Pi Pico via VSYS

Über den Pin VSYS kannst du wie erwähnt eine externe Stromversorgung anschließen, diese darf lediglich zwischen 1,8 V und maximal 5,5 V liegen.

Neustarten des Pi Pico mit einem Taster über Pin RUN

Wenn du deinen Pi Pico neu starten möchtest, dann musst du dir einen kleinen Taster zwischen GND und RUN schalten. Denn der Mikrocontroller verfügt leider über keinen eigenen RESET Taster, wie es andere Mikrocontroller hat.

Schaltung - Raspberry Pi Pico mit RESET Taster Read the full article

[draegerit]

Programmierung des 2fach Joystickshield HU-M16 am Raspberry Pi Pico mit CircuitPython

In diesem Beitrag möchte ich dir zeigen, wie du das 2fach Joystickshield HU-M16 am Raspberry Pi Pico via CircuitPython programmiert. Das Shield habe ich dir bereits für den Arduino UNO vorgestellt und auch am Arduino Leonardo gezeigt, wie du mit diesem Shield deine Maus ersetzen kannst. Hier möchte ich dir nun gerne zeigen, wie dieses Shield ebenso am Pi Pico programmiert wird. https://youtu.be/M9l6msFhADQ Die Idee zu diesem Beitrag kommt von einem Kommentar zum YouTube-Video Arduino Joystick Shield Basics: Programmierung leicht gemacht für Anfänger wo ich gefragt wurde, wie dieses für den Pico bzw. ESP32 in Python umgesetzt wird.

ArduPico für den Formfaktor des Arduino UNO

Es gibt mit dem ArduPico von der Firma WisdPi die Möglichkeit den Raspberry Pi Pico in das Format des Arduino UNO R3 zu bringen.

Der Vorteil an diesem Board ist, dass du somit das Shield nicht mit Breadboardkabel anschließen musst, sondern einfach wie am Arduino dieses aufstecken und verwenden kannst. Der Preis für dieses Modul ist mit derzeit 9,51 $ (ca. 8,69 €) zzgl. Versandkosten recht erschwinglich. Der WisdPi ArduPico verfügt ausschließlich über die analogen Pins A0 bis A2, was bedeutet, dass ein analoger Pin für die X-Koordinate des rechten Joysticks fehlt. Dennoch ist das Shield so konzipiert, dass es mit beiden Händen oder mit den Daumen bedient werden kann. In diesem Fall ist es akzeptabel, jeweils nur eine Achse mit einem Daumen zu steuern, wodurch auf die fehlende Achse verzichtet werden kann. Auf der Vorderseite des ArduPico findest du die Beschriftungen für den Arduino und auf der Rückseite diese für den Pi Pico.

Programmieren des Shields HU-M16 in CircuitPython

Damit wir dieses Shield programmieren können, schauen wir uns zunächst das Pinout an.

Aufbau des Joystick Shields für den Arduino Nachfolgend eine Tabelle mit den Pins am Raspberry Pi Pico. HU-M16Arduino UNO R3Raspberry Pi PicoJoystick (links)XA0GP26YA1GP27TasterD2GP2Joystick (rechts)XA3YA2GP28TasterD4GP4LEDD3GP3 Einrichten des Pi Pico für die Programmierung in CircuitPython Bevor wir das eigentliche Programm schreiben können, müssen wir unseren Mikrocontroller für CircuitPython flashen. In meinem Fall habe ich den Raspberry Pi Pico W und müsste nun die passende UF2 Datei suchen, herunterladen und auf den Mikrocontroller spielen. Die Entwicklungsumgebung Thonny bietet hier einen sehr einfachen Weg den Mikrocontroller für CircuitPython zu flashen und das mit wenigen Klicks. Bevor wir jedoch eine neue Firmware auf den Mikrocontroller flashen können, müssen wir diesen zunächst in den Modus bringen. Dazu trennen wir zunächst den Pi Pico vom Computer und halten den Taster BOOTSEL gedrückt und verbinden diesen erneut mit dem Computer. Es sollte jetzt im Explorer ein neues Laufwerk erscheinen. In dem Tool Thonny wählen wir unten rechts aus der Auswahlliste den Eintrag "Konfiguriere den Interpreter...".

Im neuen Dialog wählen wir als erstes "CircuitPython (generic)" (1) und unter Port das korrekte Board (2) aus. Um nun das Board für CircuitPython zu flashen, müssen wir unten rechts auf den Hyperlink "CircuitPython installieren oder aktualisieren (UF2)" (3) klicken. Jetzt müssen wir das Laufwerk auswählen (4) sollte ggf. bereits vorlegt sein und danach die Variante des Pi Pico wählen. In meinem Fall nutze ich den Raspberry Pi Pico mit WiFi Chip und wähle daher den Pico W aus. Zum Schluss nun noch die Version wählen (6) und auf die Schaltfläche "Installieren" (7) klicken. Wenn der Vorgang abgeschlossen ist, sollte der Text "Done" bei der Position (8) erscheinen.

Wenn wir jetzt zur IDE zurückkehren, dann sollte der in der Grafik angezeigte Text erscheinen (ggf. einmal oben in der Menüleiste auf Stopp klicken). Download des Moduls Adafruit HID Zum Steuern des Mauszeigers habe ich sehr gute Erfahrung mit dem Modul Adafruit Mouse gesammelt, es gibt dazu auch eine sehr ausführliche Dokumentation mit einigen Beispielen. Zu den Beispielen findet man auch immer gleich das Modul und somit muss man nicht lange suchen, sondern lädt sich einfach das Beispiel als ZIP-Datei herunter und kann dann aus dem entpackten Ordner das Modul auf den Mikrocontroller kopieren.

Auslesen der aktuellen Position der Joysticks Im ersten Abschnitt habe ich dir bereits gezeigt, an welche Pins die Joysticks und auch die LED angeschlossen sind. Zunächst lesen wir die x-Achse aus und geben die Werte in der Konsole aus. import board from analogio import AnalogIn from time import sleep joystickLeftX = AnalogIn(board.A0) while True: print(joystickLeftX.value) sleep(0.125) Wenn wir den Code ausführen und den linken Joystick nach rechts / links bewegen, dann ändert sich der gelesene analoge Wert, welchen wir aus dem Reiter Kommandozeile auslesen können.

Thonny - lesen von analogen Werten Bewegen des Mauszeigers mit den Joysticks Die Funktion move für das Bewegen des Mauszeigers erwartet 3 ganzzahlige Parameter. move(x: int = 0, y: int = 0, wheel: int = 0) Wenn wir nun den Mauszeiger in der X & Y Achse bewegen wollen, dann übergeben wir für die Bewegung nach oben eine 1 und nach unten eine -1, wenn wir jedoch die Achse nicht bewegen wollen eine 0. Die Joysticks sind in der Mittelposition und wir lesen einen Wert zwischen 45000 & 48000 (jedenfalls bei meinem Modell). Ich definiere jetzt, dass Werte, kleiner als 45000 als -1 interpretiert werden und größer als 48000 als 1. import board from analogio import AnalogIn from time import sleep import usb_hid from adafruit_hid.mouse import Mouse joystickLeftX = AnalogIn(board.A0) joystickRightY = AnalogIn(board.A2) m = Mouse(usb_hid.devices) while True: if joystickLeftX.value > 48000: posX = 1 elif joystickLeftX.value < 44000: posX = -1 else: posX = 0 if joystickRightY.value > 49000: posY = 1 elif joystickRightY.value < 45000: posY = -1 else: posY = 0 m.move(posX, posY, 0) sleep(0.01) Taster der Joysticks auswerten Beide analoge Joysticks haben jeweils einen zusätzlichen Taster, diese beiden Taster können wir als Maustasten einsetzen, jeweils als linke und rechte Maustaste. Wir benötigen dazu zwei Funktionsaufrufe, zum einen um den Taster zu drücken und zum anderen um diese wieder loszulassen. - Mouse.press, - Mouse.release Hintergrund ist, dass wir theoretisch per Drag'n Drop Objekte wie Dateien, Ordner verschieben können und dabei halten wir die Maustaste gedrückt. In meinem Fall möchte ich jedoch lediglich einen einfachen Klick ausführen. import board from time import sleep import usb_hid from adafruit_hid.mouse import Mouse import digitalio led = digitalio.DigitalInOut(board.GP3) led.direction = digitalio.Direction.OUTPUT joystickLeftButton = digitalio.DigitalInOut(board.GP2) joystickLeftButton.switch_to_input(pull=digitalio.Pull.UP) joystickRightButton = digitalio.DigitalInOut(board.GP4) joystickRightButton.switch_to_input(pull=digitalio.Pull.UP) m = Mouse(usb_hid.devices) while True: if not joystickLeftButton.value: led.value = True m.press(Mouse.LEFT_BUTTON) sleep(0.010) m.release(Mouse.LEFT_BUTTON) if not joystickRightButton.value: led.value = True m.press(Mouse.RIGHT_BUTTON) sleep(0.010) m.release(Mouse.RIGHT_BUTTON) led.value = False sleep(0.01) Fertiges Programm zum Steuern des Mauszeigers mit dem Joystickshield HU-M16 in CircuitPython import board from analogio import AnalogIn from time import sleep import usb_hid from adafruit_hid.mouse import Mouse import digitalio led = digitalio.DigitalInOut(board.GP3) led.direction = digitalio.Direction.OUTPUT joystickLeftX = AnalogIn(board.A0) joystickRightY = AnalogIn(board.A2) joystickLeftButton = digitalio.DigitalInOut(board.GP2) joystickLeftButton.switch_to_input(pull=digitalio.Pull.UP) joystickRightButton = digitalio.DigitalInOut(board.GP4) joystickRightButton.switch_to_input(pull=digitalio.Pull.UP) m = Mouse(usb_hid.devices) while True: if not joystickLeftButton.value: led.value = True m.press(Mouse.LEFT_BUTTON) sleep(0.010) m.release(Mouse.LEFT_BUTTON) if not joystickRightButton.value: led.value = True m.press(Mouse.RIGHT_BUTTON) sleep(0.010) m.release(Mouse.RIGHT_BUTTON) led.value = False if joystickLeftX.value > 48000: posX = 1 elif joystickLeftX.value < 44000: posX = -1 else: posX = 0 if joystickRightY.value > 49000: posY = 1 elif joystickRightY.value < 45000: posY = -1 else: posY = 0 m.move(posX, posY, 0) sleep(0.01)

Fazit

Die Programmierung des Joystickshield HU-M16 in CircuitPython ist mit dem Modul von Adafruit deutlich einfacher als beim Arduino. Eine Erweiterung des Codes könnte nun die Funktionalität für Drag'n Drop sein. Solltest du Fragen zu diesem Programm / Beitrag haben, so kannst hier einen Kommentar hinterlassen oder mir eine E-Mail an info@draeger-it.blog senden. Read the full article

[draegerit]

Arduino I2C-Scanner für ESP8266 & ESP32 anpassen: Eine Schritt-für-Schritt-Anleitung

In diesem Beitrag möchte ich dir eine Schritt-für-Schritt-Anleitung geben, wie du den I2C Scanner von Arduino.cc für die ESP8266 & ESP32 Mikrocontroller anpassen kannst.

Arduino I2C-Scanner für ESP8266 & ESP32 anpassen: Eine Schritt-für-Schritt-Anleitung Die Idee zu diesem Beitrag kam von einem Leser meines Blogs, welcher Probleme mit dem ESP8266 speziell den von Ideaspark hatte und keine Geräte mit dem IC2 Scanner von Arduino.cc gefunden hat.

Wie funktioniert die I2C Kommunikation?

Um das Beispiel von Arduino.cc für den I2C-Scanner auf ESP8266 und ESP32 anzupassen, ist es zunächst wichtig zu verstehen, wie die I2C-Kommunikation funktioniert. Die I2C-Kommunikation ermöglicht es, verschiedene Geräte wie Sensoren und Aktoren mit einem Mikrocontroller zu verbinden. Hierbei erfolgt die Verbindung über zwei Drähte, die als Bus bezeichnet werden und an die Pins des Mikrocontrollers angeschlossen sind. Die I2C-Geräte, die an den Bus angeschlossen sind, verfügen über eindeutige Adressen. Diese Adressen bestehen aus 7 Bits und ermöglichen die eindeutige Identifikation jedes angeschlossenen Geräts. Durch diese Adressierung ist es möglich, mehrere Geräte an einer I2C-Schnittstelle anzuschließen und gleichzeitig zu betreiben. Die I2C-Schnittstelle nutzt zwei Signalleitungen: eine für die Datenübertragung (SDA) und eine für die Taktfrequenz (SCL). Die Kommunikation erfolgt über ein Master-Slave-Prinzip, wobei der Mikrocontroller als Master agiert und die angeschlossenen Geräte als Slaves. Der Master initiiert die Kommunikation, sendet Befehle und fordert Daten von den Slaves an.

Master / Slave auf dem I2C-Bus Nachdem das Grundverständnis für die I2C-Kommunikation etabliert ist, können wir das Beispiel von Arduino.cc für den I2C-Scanner anpassen, um die Geräte auf ESP8266 und ESP32 Mikrocontrollern zu erkennen.

I2C Adressen der verschiedenen Mikrocontroller

Zunächst möchte ich dir eine Tabelle geben, mit den Pins SDA & SCL für die I2C Schnittstellen der verschiedenen Mikrocontroller. MikrocontrollerSDASCLArduino UNO, Arduino NanoA5A4Arduino MicroD2D3Arduino Mega 2560 R3D20D21Arduino DUED20D21Wemos D1 Mini - ESP8266D2 (GPIO04)D1 (GPIO05)ESP8266 - IdeasparkD6 (GPIO12)D5 (GPIO14)ESP32GPIO21GPIO21ESP32 S3GPIO08GPIO09 Den Mikrocontroller Raspberry Pi Pico / Pico W kannst du ebenso in der Arduino IDE programmieren, dieser hat zwei I2C Schnittstellen (I2C0 & I2C1) und diese sind an allen 26 GPIOs verfügbar.

Pinout des Raspberry PI Pico

Suchen nach I2C Geräte

Nachdem wir ermittelt haben an welche Pins die I2C Schnittstellen anliegen, möchten wir nun nach Geräten an diesen Pins suchen. Dazu nutze ich zunächst wie erwähnt den I2C Scanner von Arduino.cc. #include byte error, address; int nDevices = 0; void setup() { Wire.begin(); Serial.begin(9600); while (!Serial) ; Serial.println("nI2C Scanner"); } void loop() { Serial.println("Scanning..."); nDevices = 0; for (address = 1; address < 127; address++) { Wire.beginTransmission(address); error = Wire.endTransmission(); if (error == 0 || error == 4) { if (error == 0) { Serial.print("I2C device found at address 0x"); nDevices++; } else { Serial.print("Unknown error at address 0x"); } Serial.print((address < 16 ? "0" : "") + String(address, HEX) + "!"); } } if (nDevices == 0) { Serial.println("No I2C devices found"); } else { Serial.println("done"); } delay(5000); }

Ausgabe der I2C Adresse eines Displays vom I2C Scanner I2C Scanner für ESP8266 & ESP32 umschreiben Um die Suche nach Geräten auf anderen Pins des I2C-Busses zu ermöglichen, ist es erforderlich, der Funktion "begin" des Wire-Objekts die entsprechenden SDA- und SCL-Pins zu übergeben. Das kann man aber nur, wenn die Implementierung es zulässt und das ist abhängig vom gewählten Mikrocontroller! Daher muss geprüft werden, welcher Mikrocontroller / welches Board in der Arduino IDE ausgewählt wurde. #if defined(ARDUINO_ESP8266_GENERIC) #define otherBoard //Boardconfiguration for Heltec HTIT-W8266 board with oboard OLED Display BoardConfiguration bc = { "Generic ESP8266 Module", 1, { { 16, 24 } } }; #endif Eine Liste an den möglichen Werten findest du in der Datei boards.txt im Ordner zum Mikrocontroller bzw. zum Boardtreiber. %user%AppDataLocalArduino15packagesesp8266hardwareesp82663.1.2 Aus dieser Datei können wir den Namen entnehmen und das Board welches dann später erkannt wird. generic.name=Generic ESP8266 Module generic.build.board=ESP8266_GENERIC Wo kommt der Präfix "ARDUINO_" her? Wenn du den Code gelesen hast, dann siehst du, dass die Bezeichnung immer den Präfix "ARDUINO_" trägt. Diese kommt daher, dass dieses als Parameter übergeben wird. Datei "platform.txt" -DARDUINO_{build.board} Prüfen des gewählten Boards In der Funktion loop wird nun geprüft, ob ein Feld "otherBoard" oder "arduinoBoard" existiert. Diese wurden zuvor abhängig vom Board erzeugt. Das funktioniert mit dem precompile Befehl #define. Danach wird dann abhängig vom Board entweder eine For-Schleife oder der default gestartet. void loop() { Serial.print("An "); Serial.print(bc.boardname); Serial.println(" was recognized!"); #if defined(otherBoard) uint8_t numI2CInterfaces = bc.numI2CInterfaces; Serial.println("The microcontroller has " + String(numI2CInterfaces, DEC) + " I2C Interfaces!"); for (int pair = 0; pair < numI2CInterfaces; pair++) { uint8_t(*i2cPins) = bc.i2cPins; uint8_t sda = i2cPins; uint8_t scl = i2cPins; Serial.println("t SDA: " + String(SDA, DEC) + ", SCL: " + String(SCL, DEC)); Wire.begin(sda, scl); Serial.println("tScanning..."); findDevices(); } #else #ifdef defined(notDeclaredBoard) Serial.println("Boardtype not found, try default!"); #endif Wire.begin(); Serial.println("tScanning..."); findDevices(); #endif Serial.println("End."); delay(10000); } Wenn die Suche ausgeführt wird, dann erhalten wir wie beim Original im seriellen Monitor die Ausgabe der gefundenen I2C Adressen.

Ausgabe der gefundenen I2C Adressen im seriellen Monitor

Download vom GitHub Repository

Das Programm findest du auf meinem GitHub Repository StefanDraeger/universal-I2C-Scanner. Dort kannst du dir dieses dann als ZIP-Datei herunterladen. Es gibt derzeit sehr viele Mikrocontroller auf dem Markt, daher ist die Implementierung aller Konfigurationen sehr aufwändig. Jedoch habe ich begonnen, bereits einige einzutragen. Sollte dir ein Mikrocontroller fehlen, so schreibe mir eine Mail an info@draeger-it.blog. Read the full article

[draegerit]

Ardu2040M unter der Lupe: Der leistungsstarke Mikrocontroller mit RP2040 und NeoPixel Matrix

In diesem Beitrag möchte ich dir den neuen Mikrocontroller Ardu2040M von der Firma WisdPi vorstellen. Dieser Mikrocontroller kommt mit dem Chip RP2040 daher und du hast damit quasi einen Raspberry Pi Pico im Formfaktor eines Arduino UNO R3/R4 in der Hand.

Ardu2040M unter der Lupe Disclaimer: Ein Teil des Preises vom Ardu2040M Mikrocontrollers wurde großzügigerweise von der Firma WisdPi gesponsert. Dieser Beitrag wurde unterstützt, um dir den Mikrocontroller vorzustellen!

Vorderseite des Ardu2040M Mikrocontrollers

Rückseite des Ardu2040M

Aufbau des Mikrocontrollers Ardu2040M mit RP2040 Chip

Wie erwähnt ist der Mikrocontroller im Formfaktor eines Arduino UNO R3/R4. Du bekommst als Feature neben einem RP2040 Chip noch eine 5x5 RGB Matrix und viele zusätzliche digitale Pins für deine Projekte.

Zusätzlich verfügt dieser noch über eine USB-C Schnittstelle und einen Jack-Adapter (2,1 mm center-positiv) für die Stromversorgung von 7 bis 15V. Um die Firmware neu zu bespielen, musst du die Taste BOOTSEL Taste gedrückt halten und diesen mit dem Computer verbinden.

Technische Daten & Features des Ardu2040M Auf dem Ardu2040M arbeitet ein RP2040 Chip, welchen ich dir bereits mit dem Raspberry Pi Pico / Pico W ausgiebig vorgestellt habe. Der Vollständigkeit halber hier jedoch trotzdem noch die technischen Daten: MCURP2040, Dual ARM Cortex-M0+ mit bis zu 133 MHzSpeicher264 kB SRAM, 2 MB FlashGPIOs29 GPIOs, davon 3x analog, 3fach SWD PinsSpannung2x 3.3V Pins, 1x 5 V Pins, 2x GNDTasterBootsel, ResetFeaturesFormfaktor eines Arduino UNO R3/R4, 5x5 RGB MatrixVersorgungsspannung7 bis 15 V über Jack Adapter, 5 V über USB-C Schnittstelle Pinout des Ardu2040M Nachfolgend das Pinout des Mikrocontrollers.

Pinout des Mikrocontrollers Ardu2040M

Kosten & Bezug des Mikrocontrollers Ardu2040M mit RP2040 Chip

Diesen Mikrocontroller bekommst du derzeit exklusiv im offiziellen Shop von WisdPi für knapp 12 $ zzgl. Versandkosten.

Du erhältst bei deiner Bestellung lediglich den Mikrocontroller, du musst dir also noch ein passendes USB-C Datenkabel separat erwerben. Dieses Datenkabel kannst du bei zum Beispiel ebay.de bereits ab 3 € kaufen.

Programmieren des Mikrocontrollers

Den RP2040 kannst du in der Arduino IDE sowie in Micropython / Circuitpython in Thonny oder dem MU-Editor programmieren. Das Gerät wird im Geräte-Manager als "Serielles USB-Gerät" erkannt und dort kannst du dann auch den COM-Port ablesen, an welchen dieser angeschlossen ist.

Ardu2040M als Serielles Gerät im Geräte-Manager erkannt.

Ardu2040M mit aktiver SMD LED & 5x5 RGB Matrix Auf dem Mikrocontroller findest du nicht nur die GPIOs, sondern auch eine 5x5 RGB Matrix und eine SMD LED, welche wir beliebig programmieren können. Auf den Mikrocontroller kannst du diverse Shields stecken welche eigentlich für den Arduino UNO entwickelt wurden, jedoch musst du beachten, dass die GPIOs lediglich 3V liefern! Diese Shields eignen sich vor allem für Anfänger, da man hier diverse Sensoren & Aktoren auf einer Platine bestückt erhält.

multifunktionale Shields für den Arduino UNO R3 Wenn du den Ardu2040M das erste Mal mit dem Computer verbindest, dann läuft ein kleines Programm ab, welches die 5x5 RGB Matrix in den Farben Rot, Blau und Grün aufleuchten lässt. Dabei blinkt die kleine grüne SMD LED. Arduino IDE Bevor du den Ardu2040M programmieren kannst, musst du einen entsprechenden Boardtreiber installieren.

Im ersten Schritt klickst du auf das Boardsymbol links in der Menüleiste. Danach suchst du nach "rp2040" und am Eintrag "Arduino Mbed OS RP2040 Boards" klickst du auf die Schaltfläche "INSTALL". Wenn dieser Treiber erfolgreich installiert wurde, ändert sich diese Schaltfläche in "REMOVE".

Du findest danach das Board unter Werkzeuge > Board: xyz > Arduino Mbed OS RP2040 Boards > Raspberry Pi Pico. Wenn du das erste Mal ein Programm auf den Mikrocontroller aufspielen möchtest, dann wird das Gerät neu eingebunden und ist danach an einem anderem COM-Port erreichbar! Als Testprogramm verwende ich gerne das Beispiel, welches für so ziemlich jede Programmiersprache genutzt wird, die Ausgabe von dem Text "Hello, world!". void setup() { Serial.begin(9600); } void loop() { Serial.println("Hello, world!"); delay(500); } Auf dem seriellen Monitor der Arduino IDE siehst du dann die Ausgabe von dem Text.

Programmieren mit Micropython oder Circuitpython Den Mikrocontroller bzw. die MCU RP2040 kannst du auch mit Micropython oder Circuitpython programmieren. Dafür musst du den Mikrocontroller für die entsprechende Programmiersprache flashen, d.h. du musst eine spezielle Firmware auf diesen aufspielen. Nachfolgend findest du die Seiten, wo du die entsprechende UF2-Datei herunterladen kannst. - Micropython - Circuitpython Wenn du diese Datei heruntergeladen hast, dann musst du deinen Mikrocontroller vom PC trennen und die Taste BOOTSEL gedrückt halten. Danach verbindest du diesen wieder mit dem PC und lässt dann die Taste BOOTSEL lost. Update Firmware and test Micropython via Putty Thonny / MU-Editor Mit den beiden Tools Thonny und MU-Editor kannst du deinen Ardu2040M auch in Micropython bzw. Circuitpython programmieren. Im Abschnitt zuvor habe ich dir gezeigt wie dieser geflasht wird, in den Tools musst du dann nur deinen Mikrocontroller auswählen und kannst dann mit der Programmierung starten. Ob du nun Micropython oder Circuitpython verwendest, hängt meist davon ab, welche externen Sensoren / Aktoren oder Funktionen du verwenden möchtest, denn hier gibt es diverse Module, welche für jede Sprache spezielle Funktionen bieten. Kleines Beispiel zum Programmieren der 5x5 RGB Matrix in Micropython Die 5x5 RGB Matrix vom Typ WS2812 ist am GPIO13 angeschlossen und können wir in Micropython recht einfach programmieren. #Importieren der benötigten Module from neopixel import NeoPixel from machine import Pin import time #Anzahl der NeoPixel Num_Pixels = 25 #Initialisieren eines Objektes vom Typ NeoPixel #am Pin GP13 als Ausgang pixel = NeoPixel(Pin(13, Pin.OUT), Num_Pixels) #Schleife über die NeoPixel for i in range(Num_Pixels): #setzen der Farbe Blau pixel = (0, 0, 255) #schreiben / anzeigen pixel.write() #kleine Pause von 125 Millisekunden time.sleep(0.125) #setzen der Farbe schwarz / deaktivierne des NeoPixel pixel = (0, 0, 0) #schreiben / anzeigen pixel.write() Der Code lässt jedes NeoPixel einmal in Blau aufleuchten und danach wird dieses wieder deaktiviert.

Ideen für Projekte mit dem Ardu2040M

Durch die vielen GPIOs und die Möglichkeit der externen Stromversorgung von 7 bis 15V können wir so einige coole Projekte mit diesem machen. Und auch wenn diesem einen drahtlose Schnittstelle fehlt, kann diese recht günstig nachgerüstet werden. Mögliche Projekte wären: - ein Astroid Game auf der 5x5 RGB Matrix, - Wetterstation mit Sensoren (Temperatur, rel. Luftfeuchtigkeit, Luftdruck, Helligkeit, etc.), - steuern eines 2WD / 4WD Chassis

Fazit & Ausblick

Der Mikrocontroller Ardu2040M mit dem RP2040 ist ein guter Ersatz, wenn man mit dem Raspberry Pi Pico herumspielen möchte. Was diesem jedoch fehlt, ist die WiFi Schnittstelle, welche beim Pi Pico W dabei ist. Der Preis mit knapp 12 $ zzgl. Versandkosten ist okay, jedoch auch nicht besonders günstig. Read the full article

[draegerit]

Ein erster Blick auf den Melopero Cookie RP2040: Raspberry Pi Pico meets micro:bit

In diesem Beitrag möchte ich mit dir zusammen einen ersten Blick auf den Melopero Cookie RP2040 werfen. Dieser Mikrocontroller ist ein Mix aus Raspberry Pi Pico, BBC micro:bit und auch der Calliope Mini findet sich irgendwie hier wieder.

Diesen Mikrocontroller habe ich im Onlineshop von Botland.de für knapp 16 € zzgl. Versandkosten erstanden. In diesem Shop bekommst du diesen Mikrocontroller derzeit zum besten Preis.

Warum noch ein Klon?

Die große Frage, welche man sich zunächst stellen kann, ist "Warum noch ein Klon?". Diese Frage ist berechtigt, denn, dieser Mikrocontroller mit dem RP2040 Chip, einigen Anschlüssen und einer LED-Matrix ist jetzt nicht das neueste und bringt auch nicht soviel zusätzlichen Spaß. Theoretisch könnte hier der Beitrag enden, jedoch möchte ich diesem eine Chance geben und einmal ins Detail schauen.

Pins & Anschlüsse

Vor allem, wenn man sich das Format etwas genauer betrachtet, dann finden wir die Pins rings um den Mikrocontroller angeordnet, welche man mit Krokodilklemmen oder Bananenstecker (3 mm) abgreifen kann.

Batterieanschluss & USB-C Schnittstelle

Am Mikrocontroller findest du den Pin VBAT über diesen kannst du deinen Mikrocontroller via Batterie zu betreiben. Der Hersteller gibt hier an, dass die gleichzeitige Verwendung beider Stromanschlüsse dazu führen kann, dass entweder deine Batterie oder dein PC zerstört werden kann. Ich würde sogar so weit gehen, dass eher der Mikrocontroller zerstört wird!

Features des Melopero Cookie RP2040

Der Mikrocontroller bietet wie erwähnt einige Features, welche wir bei anderen bereits finden. Zu diesen Features zählen: - eine 5x5 RGB LED Matrix, - zwei Taster, - eine USB-C-Schnittstelle, - einen Qwii-Anschluss, - Kontakte Abgreifbar via Krokodilklemme& Bananenstecker, - zwei Löcher zur Montage Abmaße des Mikrocontrollers sind Ø 50,8 mm. Technische Daten des RP2040 Chips Verbaut ist ein RP2040 Chip von der Raspberry Pi Foundation, welcher nachfolgenden technischen Daten hat: MikrochipRP2040, Dual-Core Arm Cortex M0+ mit bis zu 133 MHzSpeicher SRAM264 KBFlash2 MBSchnittstellenUSB 1.1 2x SPI, 2x I²C, 2x UART 3x 12-bit ADC (Analog Digital Converter)En/Ausgänge26 Pins 16x PWM ChannelSensoren & AktorenTemperatursensor Timer

Pinout & Aufbau des Melopero Cookie RP2040

Auf dem Mikrocontroller findest du diverse Aktoren, welche du recht einfach programmieren kannst. Die LED ist als einzige von diesen mit "21" beschriftet.

Aufbau des Melopero Cookie RP2040 Qwiic / Stemma Anschluss Über den Qwiic / Stemma Anschluss kannst du spezielle Sensoren und Aktoren in Reihe schalten und einzeln adressieren. Die Kommunikation läuft dabei über I2C. Jedoch sind derzeit die Sensoren & Aktoren für dieses Ökosystem recht teuer, sodass sich ein Wechsel, nach meiner Meinung noch nicht lohnt.

Einrichten und Programmieren des Melopero Cookie RP2040

Wie üblich, kannst du deinen Mikrocontroller in MicroPython, CircuitPython sowie in der Arduino IDE programmieren. Ich möchte im Nachfolgenden den Mikrocontroller in MicroPython programmieren. https://youtu.be/3M3b8clU-FU Der Hersteller hat zu diesem Mikrocontroller eine offizielle, englische Dokumentation bereitgestellt, wo gezeigt wird, wie dieser geflasht und für MicroPython eingerichtet wird. Flashen des Mikrocontrollers für MicroPython Das Flashen des Melopero Cookie RP2040 für MicroPython ist sehr einfach, unterscheidet sich jedoch deutlich vom Raspberry Pi Pico. Denn man muss bei verbundenem Gerät die Taste "BT" (grüner Kreis) & "RS" (roter Kreis) drücken und die Taste "RS" loslassen, dann wird das Laufwerk eingebunden und wir können die Taste "BT" loslassen. Also eigentlich sehr einfach.

Wenn das Laufwerk eingebunden ist, dann musst du nun die entsprechende UF2-Datei mit der neuen Firmware auf diesen kopieren. Die Firmware bekommst du unter http://www.melopero.com/Melopero_Cookie_RP2040.zip. In der ZIP-Datei findest du die Firmware für CircuitPython und MicroPython sowie eine Bibliothek mit Beispielen für C++.

Programmieren in der Thonny IDE

Den Mikrocontroller kannst du nach dem Flashen dann zum Beispiel in der Thonny IDE programmieren. Dazu musst du zunächst den Interpreter einrichten.

Im Programm klickst du unten rechts auf den derzeit ausgewählen Mikrocontroller und wählst aus dem Menü "Konfiguriere den Interpreter ...".

Im neuen Dialog wählst du dann als Erstes den Eintrag "MicroPython (RP2040)" (1) aus. Danach den Port (2). Solltest du mehrere serielle Geräte an deinem PC angeschlossen haben, so schaue einmal in den Geräte-Manager, um den passenden zu finden. Die Auswahl bestätigen wir mit der Schaltfläche "OK" (3). Wenn du nun in der Taskleiste auf die Schaltfläche "Stopp/Restart ausführen" klickst, dann sollte in der Kommandozeile die nachfolgende Ausgabe erscheinen.

Programmieren der Taster & LED

Wie oben gezeigt findest du auf dem Mikrocontroller zwei Taster und eine kleine SMD LED. Als erstes möchte ich dir zeigen, wie diese programmiert wird. Mit den Tastern A & B möchte ich zunächst die LED AN & AUS schalten. #aus dem Modul machine die Klasse Pin laden from machine import Pin #Modul time importieren import time #die LED ist am GPIO 21 angeschlossen #und wird als Ausgang definiert led = Pin(21, Pin.OUT) #die Taster sind an den GPIOs 10 & 11 #angeschlossen und werden als Eingang #definiert buttonA = Pin(10, Pin.IN) buttonB = Pin(11, Pin.IN) #starten einer Endlosschleife while True: #Wenn der Taster A gedrückt wird, dann... if buttonA.value() == 1: #LED aktivieren led.on() #einlegen einer kleinen Pause, #damit entprellen wir den Taster time.sleep(0.5) #Wenn der Taster B gedrückt wird, dann... if buttonB.value() == 1: #LED deaktivieren led.off() #einlegen einer kleinen Pause, #damit entprellen wir den Taster time.sleep(0.5) Wenn wir den Code auf dem Mikrocontroller ausführen, dann können wir mit den beiden Tastern die kleine SMD LED Ein- und Ausschalten.

Programmieren der 5x5 RGB LED Matrix

Mit der Firmware zu MicroPython bekommst du Module zum Abfragen der Taster sowie für die RGB LED-Matrix. Diese Module müssen nicht zusätzlich installiert werden und du brauchst diese lediglich importieren und kannst diese verwenden. Für die Programmierung der 5x5 RGB LED-Matrix hast du fertige, kleine Funktionen um entweder einzelne LEDs anzusteuern oder auch Scrolltext auf dieser auszugeben. Das finde ich besonders gut gelungen. #Importen der Klasse Cookie_RP2040 aus dem Modul melopreo_cookie from melopero_cookie import Cookie_RP2040 #Text für den Scrolltext msg = "Hallo Welt!" #erzeugen eines Objektes vom Typ Cookie_RP2040 cookie=Cookie_RP2040() #LEDs löschen cookie.clear_screen() #setzen der Textfarbe als RGB Wert #Der letzte Wert bildet die Helligkeit ab! cookie.set_rgb_color(0, 0, 255,0.05) #setzen der Hintergrundfarbe cookie.set_rgb_background(0,0,0, 0.1) #anzeigen / abspielen des Scrolltextes cookie.show_message(msg) Mit diesem kleinen Code erzeugen wir nun die Laufschrift "Hallo Welt!" auf der LED-Matrix. Die Farbe für den Text habe ich in Blau gesetzt. Read the full article

[draegerit]

Raspberry Pi Pico RESET-Taster: So fügst du ihn hinzu

Der Raspberry Pi Pico verfügt leider über keinen RESET-Taster, diesen können wir jedoch ganz einfach in unsere Schaltung hinzufügen und wie du das machst, zeige ich dir hier nun in diesem kurzen Beitrag.

Im letzten Beitrag Raspberry Pi Pico Pinout: Eine ausführliche Übersicht habe ich dir bereits eine kleine Schaltung gezeigt, wie du diesen Taster an den Pi Pico anschließt, an diesen möchte ich anknüpfen und etwas mehr in die Tiefe gehen.

Warum sollte man einen RESET-Taster an den Raspberry Pi Pico anschließen?

Mit einem RESET-Taster kann man den Mikrocontroller neu starten und so alle Variablen, Felder und Objekte neu initialisieren. Dieses ist besonders wichtig, wenn das Programm bei einem Fehler in einem unbestimmten Zustand ist. Des Weiteren kann es je nach Anwendungsfall auch vorkommen, dass der Speicher ausgeht und so der Mikrocontroller ebenso in einen unbestimmten Zustand geht. Du siehst also, der RESET-Taster ist gar nicht so unnütz.

Was passiert bei einem RESET des Mikrocontrollers?

Wenn du einen RESET am Mikrocontroller durchführst, werden alle Daten im flüchtigen Speicher gelöscht. Zu diesen Daten gehören die bereits aufgezählten Variablen, Felder und auch Objekte. Ein Problem kann hier auftreten, wenn du Motoren, Servos etc. angeschlossen hast und diese Zustände verlierst, hier musst du bei der Programmierung im Voraus handeln.

RESET bei Verbindung zu einer Entwicklungsumgebung

Eine Besonderheit ist der RESET bei aktiver Verbindung zu einer Entwicklungsumgebung wie der Thonny IDE. Wenn du aus der Entwicklungsumgebung das Programm gestartet hast und dann den RESET-Taster betätigst, dann verliert die IDE die Verbindung und du musst dann das Programm manuell starten. Um dieses zu umgehen, musst du dein Programm in den Autostart legen und als boot.py speichern. Jedoch kommst du dann leider nicht mehr an deinen Code, da dein Programm sozusagen dauerhaft läuft.

Benötigte Ressourcen für den Anschluss eines RESET-Tasters an den Pi Pico

Für den Anschluss eines RESET-Tasters an den Pi Pico benötigst du lediglich zwei Kabel und einen Taster.

Taster & Breadboardkabel für den RESET-Taster

Aufbau einer Schaltung mit RESET-Taster

Um den RESET-Taster zu demonstrieren habe ich eine kleine Schaltung aufgebaut, an welcher ein OLED-Display angeschlossen ist, auf welchem die Zahlen von 1 bis 99 im Sekundentakt angezeigt werden.

Das eigentlich interessante an dieser Schaltung sollte hier jedoch nur der Taster sein, welcher zwischen RUN & GND geschaltet ist.

Funktion des RESET-Tasters

Für den RESET-Taster benötigen wir keine einzige Zeile Code, denn dieser zieht lediglich den PIN RUN gegen Ground (GND). Im nachfolgenden kleinen Video siehst du die Funktion. In der Schaltung ist ein kleines OLED-Display integriert, auf welchem die Zahlen von 1 bis n durchlaufen. Wenn man nun den blauen RESET-Taster betätigt, dann wird der Index wieder von 1 begonnen. Programm in Micropython auf dem Raspberry Pi Pico Der Vollständigkeit halber hier das Programm, welches auf dem Pi Pico abläuft. from machine import Pin, I2C import time import ssd1306 i2c = I2C(1, sda=Pin(26), scl=Pin(27)) display = ssd1306.SSD1306_I2C(70, 40, i2c) index = 0 while True: display.fill(0) display.show() index = index + 1 display.text(str(index), 20, 18, 1) display.show() time.sleep(1)

Alternative mit dem ArduPico

Wenn du den WisdPi ArduPico – Raspberry Pi Pico Adapter benutzt, dann hast du bereits einen RESET-Taster (sowie weitere Features) zur Hand.

ArduPico von WisdPi Auf diese Platine, welche den Formfaktor des Arduino UNO hat, kannst du den Pi Pico, mit und ohne WiFi Support anbringen. Read the full article

[draegerit]

MicroPython und das Mapping von Sensorwerten: So funktioniert's

Herzlich willkommen zu meinem neuesten Blogbeitrag, in dem es um das Mapping von Sensorwerten mit MicroPython geht! Heute werde ich euch eine Funktion vorstellen und erklären, mit der ihr einen Messbereich von einem Sensor auf einen anderen umwandeln könnt. Diese Funktion ist besonders nützlich beim Visualisieren von Umweltsensoren und anderen Messwerten. Ich werde euch Schritt für Schritt durch den Prozess führen und euch zeigen, wie ihr diese Funktion unter Verwendung von MicroPython in euren Projekten nutzen könnt.

Wie man Sensorwerte am Mikrocontroller Calliope Mini im Open Roberta Lab mappt habe ich dir bereits im Beitrag Open Roberta Lab – analoges Signal auf PWM mappen erläutert. Hier greife ich auf die gesammelte Erkenntnis zurück und schreibe den Code für MicroPython um.

Wozu benötigen wir das Mapping von Sensorwerten in MicroPython?

Nehmen wir an du hast einen Temperatursensor welcher einen Messbereich von 0 °C bis 125 °C hat und eine LED Balkenanzeige mit 24 Segmenten. Dann könntest du nun den Messbereich des Sensors (0-125) auf die 24 LEDs mappen und somit je nach Temperatur die LEDs aktivieren. Ein anderer Fall wäre ein Servomotor mit einem maximalen Winkel von 180° welchen du mit einem analogen Sensor (Drehpotentiometer, Joystick etc.) bewegen möchtest. Dann musst du in diesem Fall den Drehbereich des Servos 0° bis 180° auf die möglichen analogen Werte 0 bis, 65535 mappen.

Ein kleiner Aufbau mit dem Raspberry Pi Pico

Damit wir unsere Funktion testen können, benötigen wir einen Mikrocontroller, auf welchen MicroPython läuft. Hier kann man sich selber einen ESP32 flashen oder man verwendet einen Raspberry Pi Pico / Pico W welcher das ganze schon von hause aus kann. Ich möchte das zuletzt genannte Beispiel aufgreifen und einen Servomotor mit einem Drehpotentiometer steuern. Ein recht kleines Projekt, welches jedoch sehr gut verdeutlicht, wie die Funktion map welche wir schreiben, möchten funktioniert.

Schaltung - Raspberry Pi Pico mit Servomotor SG90 & Drehpotentiometer Was benötigen wir für den Aufbau der Schaltung? Für den Nachbau der Schaltung benötigst du: - einen Raspberry Pi Pico / Pico W, - ein Micro-USB Datenkabel, - einen Servomotor SG90, - einen Drehpotentiometer, - sechs Breadboardkabel, - ein 400 Pin Breadboard Pinout des Raspberry Pi Pico Für die Unterstützung beim Aufbau der Schaltung gebe ich dir hier noch das Pinout des Raspberry Pi Pico an die Hand.

Pinout des Raspberry PI Pico

Programmieren der Funktion map in MicroPython zum Erzeugen eines Mapping von Sensorwerten

In der Arduino IDE gibt es bereits die Funktion map welche genau das macht, was wir hier nachbauen möchten. Die Parameter sind: - value - der Wert, welcher verarbeitet werden soll, - fromLow - die untere Grenze des aktuellen Bereichs des Werts, - fromHigh - die obere Grenze des aktuellen Bereichs des Wertes, - toLow - die untere Grenze des Zielbereichs für den Wert, - toHigh - die obere Grenze des Zielbereichs des Wertes Dieses übernehmen wir für die neue Funktion. def map(value, fromLow, fromHigh, toLow, toHigh): return round((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow) Hier ist eine schrittweise Erklärung der Funktionsweise: - (value - fromLow): Dieser Ausdruck berechnet die Differenz zwischen dem Eingabewert und dem unteren Grenzwert des Eingabebereichs (fromLow). Dieser Schritt normalisiert den Eingabewert auf den Bereich von 0 bis (fromHigh - fromLow). - (toHigh - toLow): Dieser Ausdruck gibt die Größe des Ausgabebereichs an, also die Differenz zwischen dem oberen und unteren Grenzwert des Ausgabebereichs. Dieser Schritt bestimmt die Skalierung des transformierten Werts. - (fromHigh - fromLow): Dieser Ausdruck gibt die Größe des Eingabebereichs an, also die Differenz zwischen dem oberen und unteren Grenzwert des Eingabebereichs. Dieser Schritt bestimmt die relative Position des Eingabewerts innerhalb des Eingabebereichs. - ((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow): Dieser Ausdruck führt die eigentliche Transformation durch. Zuerst wird der normalisierte Eingabewert mit der Skalierung des Ausgabebereichs multipliziert, um den transformierten Wert zu erhalten. Dann wird der untere Grenzwert des Ausgabebereichs (toLow) zum Ergebnis addiert, um den endgültigen transformierten Wert zu erhalten. - round(...): Die Funktion round() rundet den transformierten Wert auf die nächstgelegene ganze Zahl.

Steuern eines Servomotors mit einem Drehpotentiometer in MicroPython

Hier nun das kleine Programm, um mit einem Drehpotentiometer einen Servomotor zu steuern. #import des Moduls um #den analogen Pin auszulesen #und den Servo per PWM zu steuern from machine import ADC, Pin, PWM #import des Moduls um eine #kleine Pause im Code einzulegen from time import sleep #wir benutzen in der Schaltung #den ADC0 Pin / GP26 für den Drehpotentiometer adc = ADC(Pin(26)) #der Servomotor ist am GP15 angeschlossen pwm = PWM(Pin(15)) pwm.freq(50) #untere & obere Grenze des Servomotors servoMin = 100 servoMax = 8000 #untere & obere Grenze des Drehpotentiometers drehpotiMin = 224 drehpotiMax = 65535 # Funktion zum setzen eines Winkels # als Parameter wird die Position erwartet def setServoCycle(position): pwm.duty_u16(position) sleep(0.01) #Funktion zum mappen eines Wertes mit einer oberen und unteren Grenze def map(value, fromLow, fromHigh, toLow, toHigh): return round((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow) + toLow) #starten der Endlosschleife while True: #auslesen des Wertes vom Drehpotentiometer value = adc.read_u16() #ermitteln der Servoposition servoPosition = map(value, drehpotiMin, drehpotiMax, servoMin, servoMax) #zuweisen der Servoposition setServoCycle(servoPosition) #eine kleine Pause von 125 Millisekunden sleep(0.125) Im Video erkennst du, dass der Servo sich je nach Position des Drehpotentiometers bewegt. Ein Problem ist jedoch, dass der analoge Wert nicht konstant gleich ist, d.h. wenn du den Drehpotentiometer nicht bewegst, dass der Servo trotzdem zuckt.

Ermitteln der Grenzen des Sensors & Aktors

Hier jetzt der vollständigkeitshalber die beiden Programme um die untere & obere Grenze des Drehpotentiometers & des Servomotors zu ermitteln. Die Werte des Servomotors habe ich selbst durch Trial-and-Error ermittelt, diese können je nach Modell variieren. Auslesen des Drehpotentiometers am Raspberry Pi Pico Zunächst einmal lesen wir den Drehpotentiometer aus, um die untere und obere Grenze zu ermitteln. #import des Moduls um #den analogen Pin auszulesen from machine import ADC, Pin #import des Moduls um eine #kleine Pause im Code einzulegen from time import sleep #wir benutzen in der Schaltung #den ADC0 Pin / GP26 adc = ADC(Pin(26)) #starten der Endlosschleife while True: #auslesen des Wertes value = adc.read_u16() #ausgeben des Wertes print("Drehpotentiometer Wert: "+ str(value)) #eine kleine Pause von 125 Millisekunden sleep(0.125) Mit dem Code habe ich jetzt ermittelt das die untere Grenze 224 und die obere Grenze 65535 ist. Steuern des Servomotors per PWM Signal Im Beitrag Raspberry PI Pico #3 – PWM Signale erzeugen habe ich dir bereits gezeigt, wie man einen Servomotor vom Typ SG90 per PWM Signal steuern kann. Mit dem nachfolgenden Code können wir diesen jetzt von 0° bis 180° drehen. from time import sleep from machine import Pin from machine import PWM pwm = PWM(Pin(15)) pwm.freq(50) # Funktion zum setzen eines Winkels # als Parameter wird die Position erwartet def setServoCycle(position): pwm.duty_u16(position) sleep(0.01) while True: for pos in range(100, 8000,50): setServoCycle(pos) for pos in range(8000, 100,-50): setServoCycle(pos) Read the full article