Am 21.01.2021 wurde der Raspberry Pi Pico von der Raspberry Pi Foundation vorgestellt, ein Mikrocontrollerboard im Arduino-Nano-Format, dessen Herzstück der RP2040-Mikrocontroller mit zwei ARM Cortex-M0+ Kernen ist und bis zu 133 MHz getaktet werden kann. Dieser kann in MicroPython oder C/C++ programmiert werden.
| Mikrocontroller: | RP2040 (32-Bit) mit zwei ARM Cortex-M0+ Kernen |
|---|---|
| Taktfrequenz: | bis zu 133 MHz (variabel/übertaktbar) |
| Speicher: | 256kB on-chip SRAM; 2MB on-board QSPI Flash |
| USB: | On-board USB v1.1 (als device oder host) |
| Stromversorgung: | USB (5V) oder ~1,8V bis 5,5V (z.B. Lithium-Ionen-Zelle mit 3,7V oder 2-3 AA-Batterien in Reihe) |
| Anschlüsse: |
26 GPIO-Pins (inkl. 3 analogen Eingängen) bei 3,3V ADC: 12-bit 500ksps |
| Schnittstellen: |
2× UART 2× I2C 2× SPI 16× PWM-Kanäle 1× Timer mit 4 Alarmen 1× Real time counter |
| Betriebstemperatur: | -20°C bis 85°C (empfohlen sind max. 70°C) |
| Sonstiges: |
|
Durch das Arduino-Nano-Format passt das Board gut auf Breadboards zum einfachen Schaltungsaufbau.
Detailliertere Spezifikationen können aus dem offiziellen
Datenblatt für
den Raspberry Pi Pico entnommen werden.
| GPIO (General Purpose IO) |
GP0 - GP22: rein digitale Eingabe/Ausgabe-Pins GP26 - GP28: digitale oder analoge (ADC) Eingabe/Ausgabe-Pins |
|---|---|
| GND | Ground/Masse-Anschlüsse |
| #40 (VBUS) | VBUS entspricht der Eingangsspannung des Mikro-USB-Eingangs. Dies sind entweder 5V oder 0V, falls der USB-Eingang nicht angeschlossen ist. |
| #39 (VSYS) | VSYS ist die Eingangsspannung des Boards und kann zwischen 1,8V und 5,5V liegen. |
| #37 (3V3_EN) | 3V3_EN ist mit dem SMPS des Boards verbunden und besitzt einen internen Pullup-Widerstand von 100kΩ zu VSYS. Um die 3,3V zu deaktivieren, muss dieser Pin auf LOW geschaltet werden (dies hat auch zur Folge, dass der RP2040 ausgeschaltet wird). |
| #36 (3V3) | 3V3 entspricht einer Spannung von 3,3V, die sowohl intern verwendet wird, als auch für externe Schaltungen verwendet werden kann. Es sollte aber darauf geachtet werden, dass nicht mehr als 300mA fließen. |
| #35 (ADC_VREF) | ADC_VREF entspricht der Betriebs- bzw. Referenzspannung für den ADC. Über eine externe Spannungsquelle an diesem Pin kann die Genauigkeit des ADC verbessert werden. |
| #33 (AGND) | AGND ist die Ground-Referenz für GPIO 26-29. Wenn der ADC nicht verwendet wird oder dessen Leistung unkritisch ist, dann kann dieser Pin auch mit dem digitalen GND verbunden werden. |
| #30 (RUN) | RUN ist der Enable-Pin für den RP2040 und ist mit einem 50kΩ-Pullup-Widerstand mit 3,3V verbunden. Um den RP2040 zu resetten, muss der Pin auf LOW (GND) geschaltet werden. |
Um den Raspberry Pi Pico im Programmierungs-Modus an den PC (hier: Microsoft Windows) anzuschließen,
benötigt man ein Micro-USB-Kabel, welches zunächst in das Board gesteckt wird. Dann hält man den Knopf
BOOTSEL auf dem Board gedrückt und schließt das USB-Kabel am PC an. Nun sollte nach kurzer
Zeit ein neues USB-Laufwerk RPI-RP2 im Dateimanager auftauchen. Falls dies nicht geschieht, sollte
man überprüfen, ob das verwendete USB-Kabel auch Datenleitungen hat und nicht nur ein simples Ladekabel ist.
MicroPython ist eine Implementierung der Programmiersprache Python 3 für Embedded Hardware, wie
den Raspberry Pi Pico. Dabei steht eine interaktive Konsole (sog. REPL) zur Verfügung, um Befehle via USB auszuführen,
aber auch ein eingebautes Dateisystem. Der Port von MicroPython für den Raspberry Pi Pico stellt zusätzlich Module
zur Verfügung, die Zugriff auf die unteren Ebenen der Hardware des Pico ermöglichen.
(Detaillierte Informationen:
micropython/wiki
bzw.
micropython.org)
Zur Programmierung wird von der Raspberry Foundation die Entwicklungsumgebung "Thonny" empfohlen. Diese kann unter thonny.org für die gängigen Betriebssysteme kostenlos heruntergeladen werden. Ich habe für Microsoft Windows die portable-Version verwendet, da hierbei keine Installation notwendig ist. Man startet einfach die thonny.exe und kann sofort loslegen.
Im Menüpunkt "Run" → "Select interpreter..." wird dann noch MicroPython (Raspberry Pi Pico) ausgewählt und man muss den Anweisungen folgen, damit die Firmware richtig installiert werden kann:
Nach wenigen Sekunden ist die Firmware installiert und man kann direkt beginnen, den Pico zu programmieren.
(Aktuelle Firmware auch verfügbar unter Firmware for Raspberry Pi Pico)
Es können nun direkt Python-Befehle in die Shell eingegeben werden, die sofort vom Pico interpretiert werden, z.B. eine simple Ausgabe:
Das folgende Programm lässt die interne LED (als SMD-Bauteil direkt auf dem Board verbaut) des Raspberry Pi Pico mit der Frequenz von 1 Hz blinken. Die LED besitzt im Gegensatz zum Arduino keinen physischen Pin, kann aber intern genauso angesprochen werden.
Sobald der Code fertig geschrieben ist, kann man ihn (entweder auf dem PC oder direkt auf dem
Pico) speichern und dann mit F5 oder dem kleinen Play-Button auf der
Menüleiste ausführen lassen.
import machine
import utime
led = machine.Pin(25, machine.Pin.OUT)
while True:
led.toggle()
utime.sleep(0.5)Datenblatt besitzt der RP2040 einen eingebauten Temperatursensor, der sich relativ leicht auslesen lässt. In Kapitel 4.9.4. Temperature Sensor wird die Formel beschrieben, wie man aus den ausgelesenen Daten eine Temperatur erhält. Diese wird durch den folgenden Sketch einmal pro Sekunde ausgegeben:
from machine import Pin
from utime import sleep
sensor = machine.ADC(4)
while True:
val = sensor.read_u16() * 3.3 / (65535)
temp = 27 - (val - 0.706)/0.001721
print (str(round(temp, 2)) + " °C")
sleep(1)
Weitere Informationen über MicroPython gibt es hier:
Getting started with MicroPython
Für dieses Experiment wird eine LED (z.B. 5mm) mit einem Vorwiderstand (R1 = 330Ω) am Pin GP15 des Pico angeschlossen, wie folgender Schaltplan zeigt:
Als Sketch könnten wir denselben verwenden, wie in Sketch I gezeigt, wobei nur der Pin für die
LED auf 15 angepasst werden müsste, jedoch benutzen wir dieses Mal eine andere Art der Zeitgebung
für den Blink-Takt: einen sogenannten Timer.
from machine import Pin, Timer
led = Pin(15, Pin.OUT)
timer = Timer()
def blinkLed(timer):
led.toggle()
timer.init(freq=5, mode=Timer.PERIODIC, callback=blinkLed)
Hier wird ein periodischer Timer mit einer Frequenz von 5 Hz gestartet, welcher bei jedem Takt die
Callback-Funktion blinkLed aufruft, die letztendlich die LED zum Blinken bringt, d.h.
in jedem Durchgang entweder zum Leuchten oder Erlöschen bringt.
Der folgende Sketch prüft auf den Zustand am Eingang eines angeschlossenen Tasters und reagiert
mit dem An- bzw. Ausschalten der LED an Pin GP15. Wichtig ist, dass darauf zu achten, dass
der Taster mit dem internen Pulldown-Widerstand in der Deklaration verbunden wird, da er ja
mit 3V3 angeschlossen ist. Es ist jedoch auch möglich, den Taster stattdessen mit
GND zu verbinden, allerdings muss dann ein Pullup-Widerstand in der Deklaration
verwendet werden.
from machine import Pin
import time
led = Pin(15, Pin.OUT)
button = Pin(14, Pin.IN, Pin.PULL_DOWN)
while True:
if button.value():
led.toggle()
time.sleep(0.5)Mit diesem Versuch werden zwei Funktionen ausprobiert: Das Einlesen analoger Daten mittels eines Potentiometers und das Dimmen einer LED mittels PWM. Dafür verwenden wir folgenden Aufbau:
Da der Raspberry Pi Pico im Gegensatz zum Arduino einen höher auflösenden ADC besitzt, so können Werte
zwischen 0 und 65535 erreicht werden. Diese kann man dann mit read_u16() vom vorbereiteten
Pin auslesen.
Mit PWM(Pin(15)) definiert man den Pin GP15 als PWM-Ausgang und legt mit freq(1000)
eine Frequenz von 1000 Hz fest, wie oft an diesem Ausgang das Signal zwischen HIGH und LOW wechseln soll.
Mit duty_u16() wird festgelegt, zu wieviel Prozent der Zeit das PWM-Signal pulsen soll, z.B.
würden 100% (duty=65025) die LED permanent leuchten und 0% (duty=0) die LED vollständig erlöschen lassen.
Alle Werte dazwischen ergeben durch die hohe Schaltgeschwindigkeit den bekannten Dimm-Effekt der LED.
from machine import Pin, PWM, ADC
led = PWM(Pin(15))
led.freq(1000)
potentiometer = ADC(Pin(26))
while True:
duty = potentiometer.read_u16()
led.duty_u16(duty)Will man den Pico betreiben, ohne dass er am PC angeschlossen ist (z.B. über eine Powerbank), dann muss man noch ein paar Dinge beachten:
main.py lauten, denn nur so weiß der Pico, dass genau
dieser Sketch ausgeführt werden soll.
main.py wird nun automatisch
vom Pico ausgeführt, sobald er an eine Stromquelle angeschlossen wird.
Eine Variante für die Programmierung mit Python ist das von Adafruit entwickelte CircuitPython. Wer schon mit dieser Sprache/Plattform Erfahrung hat, für den empfiehlt sich, in dieser Richtung weiterzulesen: Getting Started with Raspberry Pi Pico and CircuitPython
Mit dem offiziellen Raspberry Pi Pico C/C++ SDK lassen sich Programme in C++ schreiben und dann auf dem Pico ausführen. Diese Möglichkeit habe ich bisher nicht ausprobiert. Weitere Informationen: Getting started with C/C++
Es ist auch möglich, den Raspberry Pi Pico innerhalb der Arduino-IDE zu programmieren. Dafür wurde ein inoffizieller Port für den RP2040 in das Arduino-Ökosystem zur Verfügung gestellt und kann unter https://github.com/earlephilhower/arduino-pico heruntergeladen werden. Um den Raspberry Pi Pico nun in der Arduino-IDE zu laufen zu bringen, sind folgende Schritte notwendig:
https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
Um das erste Mal einen Sketch hochzuladen, drückt man BOOTSEL während man
das Board per USB-Kabel an den PC anschließt. Nun kann man den Sketch wie üblich in
der Arduino-IDE auf das Board laden.
Nach diesem ersten Upload kann man im Menü "Werkzeuge" → "Port"
den erkannten Port auswählen und es sollte jedes weitere Upload ohne Probleme funktionieren.
Dies hat bei mir nicht funktioniert und so musste ich für jeden Upload die Prozedur mit
dem Drücken von BOOTSEL wiederholen.
Analog zum ersten Sketch, den wohl jeder Arduino-Einsteiger ausprobiert, wird hier die interne LED mit der Frequenz von 1 Hz zum Blinken gebracht. Diese LED besitzt im Gegensatz zum Arduino keinen physischen Pin, kann aber intern genauso angesprochen werden, wie der folgende Sketch zeigt:
#define INT_LED_PIN 25
void setup()
{
pinMode(INT_LED_PIN, OUTPUT);
}
void loop()
{
digitalWrite(INT_LED_PIN, HIGH);
delay(500);
digitalWrite(INT_LED_PIN, LOW);
delay(500);
}Hinweis: Da der Raspberry Pi Pico noch ziemlich neu auf dem Markt ist, ist dieser Port noch nicht fertig entwickelt und unterliegt häufigen Änderungen. Außerdem ist noch keine 100%ige Kompatibilität erreicht, d.h. nicht alle Funktionen sind verfügbar. Man sollte sich also regelmäßig über Updates und Bugfixes informieren.
zurück