Der Postbote brachte Post aus Penang, Malaysia mit dem pyBase Board und einigen Komponenten. Wenn Sie sich für die Programmierung in MicroPython interessieren und nach einer geeigneten Spielwiese suchen, dann sollten Sie sich mal bei 01Studio.org umschauen.
Neben dem Basisboard werden verschiedene weitgehend pyBoard-kompatible Controllerboards aber auch TFT- und OLED-Display angeboten. Das Basisboard weist darüberhinaus noch einige Sensoren (DS18B20, DHT11) und Steckverbinder auf, die leider nicht Grove-kompatibel sind.
pyBase mit pyBoard Mini & 1.77″ TFT
Zu beziehen sind die Komponenten zu attraktiven Preisen beispielsweise über Aliexpress.de.
Bei der Erschliessung eines neuen Mikrocontrollers muss man sich mit dem Mikrocontroller selbst und einer passenden Entwicklungsumgebung incl. Programmiersprache auseinandersetzen. Kann man auf Entwicklungsboards o.ä. zurückgreifen, dann ist wenigstens von Seiten der Hardware erst mal die Basis gesichert.
Natürlich ist es möglich mit einem konventionellen Breadboard zu arbeiten. Im letzten Blogbeitrag bin ich so vorgegangen. Wird der Aufbau etwas komplexer, dann nehmen der Drahtverhau und die damit verbundenen Fehlermöglichkeiten zu und die Inbetriebnahme kann auf ungewollte Bahnen gelenkt werden.
Verschiedene Anbieter haben auf die Situation reagiert und erleichtern die Einarbeitung mit ihren Produkten wesentlich. Ohne Anspruch auf Vollständigkeit möchte ich hier einige Beispiele zeigen.
Um möglichen Diskussionen vorn vornherein zu begegnen – ich bin unabhängig von diesen Anbietern und bezahle diese Komponenten selbst.
Der Pico Explorer von Pimoroni ist ein klassisches Entwicklungsboard, welches ein 240×240 Pixel IPS-LCD mit vier Tastern (A, B, X, Y), zwei Breakout Garden-Steckplätze (I2C) für Pimoroni-Breakouts, Motortreiber, analoge Eingänge, GPIO, einen Piezo-Lautsprecher und ein Mini-Breadboard für individuelle Schaltungserweiterungen
Pico Explorer
Beim Pico Breakout Garden stehen vier I2C- und zwei SPI-Schnittstellen für Pimoroni-Breakouts zur Verfügung.
Pico Breakout Garden
Von Pimoroni werden auch sogenannte Pack angeboten, die direkt mit einem Pi Pico kontaktiert werden können. Das Pico Display Pack hatte ich bereits in einem Blogbeitrag vorgestellt. Will man mehrere dieser Packs mit dem Pi Pico verbinden, dann bieten sich die verschiedenen Pico Expander an.
Pico Expander
Nicht nur Pimoroni hat die Situation erkannt. Seeedstudio bietet mit dem Grove Shield für den Pi Pico die Verbindung in das Grove-Universum an.
Grove Shield für Pi Pico
Wichtig ist bei aller Hardware-Unterstützung auch die Verfügbarkeit entsprechender microPython Libraries. Zahlreiche Libraries sind in Python geschrieben und auf Raspberry Pi (o.a. Linux-Devices) lauffähig, aber nicht in einer microPython-Umgebung. Google hilft hier, eine passende microPython Library zu finden.
Ich habe das Thermometer-Programm aus dem letzten Blogpost aufgegriffen und auf den Pico Explorer mit BME280-Breakout portiert. Im Slot BREAKOUT1 steckt ein BME280 und im BREAKOUT2 eine 11×7 LED Matrix, die hier aber nicht weiter von Belang ist.
Die beiden folgenden Bilder zeigen die Ausgaben der „Wetterstation“.
Das Programm Pi_Pico_BME280.py und die Library BME280.py finden Sie wieder im Repository.
In meinem letzten Blogbeitrag hatte ich unter anderem den internen Temperatursensor des Pi Pico abgefragt und auf die zu erwartenden Abweichungen hingewiesen.
Hier habe ich mit dem Pi Pico ein „Thermometer“ aufgebaut, welches die von einem BME280 gemessene Temperatur der des internen Sensors gegenüberstellt.
Ziel war also:
Inbetriebnahme der I2C-Schnittstelle
Auslesen des BME280 über das I2C-Interface
Ersatz des Pico Displays von Pimoroni durch eine OLED 128 x 64 mit I2C-Interface
Die erforderlichen Komponenten sind schnell zusammengesteckt.
Da die GPIO des Pi Pico nicht 5 V-tolerant sind werden beide I2C-Devices mit 3.3 V versorgt. Der Pi Pico weist zwei I2C-Busse auf. Verwendet wird hier I2C(0), der an verschiedenen GPIO-Pins zur Verfügung steht. Hier ist SDA = GPIO0 = Pin1 und SCL = GPIO1 = Pin2.
Bevor es an das Thermometer-Programm geht sollte das I2C-Interface überprüft werden. Mit Hilfe des Programms Pi_Pico_I2CScan.py werden alles am Interface I2C(0) angeschlossenen Devices detektiert:
from machine import Pin, I2C
sda=Pin(0)
scl=Pin(1)
i2c=I2C(0,sda=sda, scl=scl, freq=400000)
devices = i2c.scan()
if len(devices) == 0:
print("No I2C device found!")
else:
print('{:2d} I2C device(s) found.'.format(len(devices)))
for device in devices:
print('Device address: {0:3d} dec and {1:2s} hex'.format(device, hex(device)))
Erwartungsgemäss werden die beiden angeschlossenen Devices, der Sensor BME280 mit I2C-Adresse 0x76 und das SSD1306 OLED mit der I2C-Adresse 0x77, erkannt.
BME280 und SSD1306 OLED am I2C-Bus detektiert
Das Programm Pi_Pico_OLED_Temp.py vereint nun die Abfrage beider Temperatursensoren und die Ausgabe der Resultate über Console und OLED.
#
# Pi_Pico_OLED_Temp.py
#
# Compare internal temperature w/ temperature measured by BME280
# and display results on OLED and Console
#
# 2021-02-08 Claus Kühnel info@ckuehnel.ch
#
from machine import I2C, Pin
from bme280_float_mod import *
from utime import sleep, sleep_ms
import ssd1306
led = Pin(25, Pin.OUT) # external LED on Pi Pico
sensor_temp = machine.ADC(4) # internal temperature sensor
conversion_factor = 3.3 / (65536)
def blink():
led(1)
sleep_ms(20) # LED on for 20 milliseconds
led(0)
# Display size
oled_width = 128
oled_height = 64
# Pi Pico assignement
sda=Pin(0)
scl=Pin(1)
i2c=I2C(0)
bme280 = BME280(i2c=i2c)
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
oled.text('Thermometer', 0, 20)
oled.text('using BME280 and', 0, 30)
oled.text('on-chip sensor', 0,40)
oled.show()
sleep(2)
oled.fill(0)
oled.show()
while True:
blink()
reading = sensor_temp.read_u16() * conversion_factor
intTemp = 27 - (reading - 0.706)/0.001721
extTemp = float(bme280.temperature)
print('On-Chip temperature is {:3.1f} °C'.format(intTemp))
print('External temperature is {:3.1f} °C'.format(extTemp), end='')
print('\t\tTemperature difference is {:3.1f} °C'.format(extTemp - intTemp))
oled.fill(0)
oled.show()
unit = ' *C'
msg = 'BME280 ' + str(round(extTemp, 1)) + unit
oled.text(msg, 0, 20)
msg = 'On-Chip ' + str(round(intTemp, 1)) + unit
oled.text(msg, 0, 30)
msg = 'Delta ' + str(round((extTemp- intTemp), 1)) + unit
oled.text(msg, 0, 45)
oled.show()
sleep(10)
Nach einem Startscreen erfolgt die Anzeige der beiden gemessenen Temperaturen und deren Differenz. Dass die Temperatur des On-Chip Sensors leicht höher liegt, kann durch die Eigenerwärmung erklärt werden.
Das erste Raspberry Pi PicoBoard und das Pimoroni Pico Display Pack sind eingetroffen. Grund genug schon mal erste Tests zu unternehmen.
Raspberry Pi PicoPimoroni Pico Display Pack
Die Installation der Firmware ist denkbar einfach, weil sich der Pi Pico im Bootmode (BOOTSEL gedrückt, Verbinden mit USB) als Laufwerk meldet und die als UF2-File vorliegende Firmware einfach dahin kopiert wird. Nach einem Restart meldet sich das Board mit dem REPL. Als Editor bzw. IDE habe ich erstmal den empfohlenen Thonny verwendet.
Nach den zahlreichen Diskussionen im Netz beim Erscheinen dieses Boards habe ich zuerst den Pystone Benchmark laufen lassen, um einen Vergleich zu anderen Boards mit MicroPython zu bekommen.
MicroPython f5d0ca0 on 2021-01-24; Raspberry Pi Pico with RP2040
Type "help()" for more information.
>>> %Run -c $EDITOR_CONTENT
Pystone(1.2) time for 500 passes = 505ms
This machine benchmarks at 990 pystones/second
Die erste Zeile zeigt die Version der Firmware an. Hier verwendet habe ich die Firmware von Pimoroni, die die Pimoroni Hardware unterstützt. Die Firmware der Raspberry Pi Foundation erzielte ein leicht besseres Benchmark-Resultat.
In meinem Beitrag zum MaixPy RISC-V Controller hatte ich eine Übersicht zu den Resultaten dieses Benchmarks für sehr unterschiedliche Controller. Vom Benchmark-Resultat reiht sich der Pi Pico mit 990 Pystone/sec bei ESP32, PyBoard Lite und Teensy 3.5 ein.
Mit zwei kleinen Programmbeispielen möchte ich den ersten Eindruck abschliessen. Das Programm Pi_Pico_Internals.py zeigt einige Merkmale des Pi Pico über die Console und das Display an.
Der interne Temperatursensor kann über den ADC ausgelesen werden und kann so leicht zur Anzeige der Temperatur in einem Thermostaten verwendet werden. Die zu erwartende Genauigkeit sollte nicht überbewertet werden. Das Programm Pi_Pico_Thermometer.py zeigt die gemessene Temperatur auf dem Display an und signalisiert über die RGB-LED Bereichsüber- bzw. -unterschreitung und die Einhaltung des Messbereichs an.
An dieser Stelle werde ich weitere Ergebnisse mit dem Pi Pico präsentieren, zumal der Pi Pico mit den PIOs und dem Dual-Core Merkmale aufweist, die nicht so verbreitet sind.
Da das 2008 veröffentlichte Python 3 nicht abwärtskompatibel zu Python 2 ist, wurde in der Regel bestehender Code in Python 2 weiterentwickelt und neuer Code direkt in Python 3 geschrieben.
Diese Parallel-Existenz nimmt am 1.1.2020 ein abruptes Ende: Der Support von Python 2 wird eingestellt. Die Migration der Codebasis von Python 2 nach Python 3 ist daher unvermeidlich, bedeutet aber einige signifikante Änderungen. Einige der Wichtigsten im Überblick im Beitrag der Elektronikpraxis.
Ich habe hier MicroPython auf dem kompakten MAiX BiT Board installiert und ausprobiert. Die Benchmarkergebnisse habe ich im MicroPython Forum unter Benchmark comparison of MicroPython boards nach getragen.
MAiX BiT Back
MAiX Bit Front
Die Resultate des Pystome_lowmem Benchmarks nach einen Reset zeigt das folgende Bild.
Benchmark Pystone_lowmem
Die Daten aus dem o.a. Benchmarkvergleich sind in der folgenden Grafik zusammengefasst.
WiPy und Lopy Boards weisen einen ESP32-Mikrocontroller auf. Die Teensy Boards sind mit Kinetis K20 bis K66 (Cortex-M4) ausgestattet. Das Original-Pyboard (v1.1) hat einen STM32F405RGT6 (Cortex-M4F). Beim MAiX BiT ist der Kern ein RISC-V Kendryte K210.
Nachdem ich in einem Post das ESP32 AD-DA-Sbsystem analysiert hatte, wollte ich das PyBoard diesbezüglich untersuchen.
Der im PyBoard v1.1 eingesetzte STM32F405RGT6 besitzt drei 12-bit ADCs. 16 analoge Eingänge stehen am PyBoard v1.1 an den Header-Leisten zur Verfügung.
Außerdem stehen zwei 12-bit DACs zur Verfügung, die hier aber vorerst nur als 8-bit-DAC eingesetzt werden.
Anschlussbild PYBv1.1
Für einen ersten Test des DAC-ADC-Subsystems ist es am einfachsten, den DAC an Pin X5 mit dem ADC-Eingang an Pin X19 zu verbinden.
Verbindung DAC(X5) – ADC(X19)
Das MicroPython Testprogramm weist keine Besonderheiten auf und zeigt vor allem, wie DAC und ADC angesprochen werden können. Auf Github steht es zum Download zur Verfügung.
# PYB_adda_test.pyb # PyBoard Test of DAC & ADC # (c) Claus Kuehnel 2019-02-17 info@ckuehnel.ch # PyBoard v1.1 has two DAC channels, connected to X5 and X6 # There are 16 ADC channels. The ADC channel connected to X19 is used here. # Connect X5 & X19 for this test.
import time from pyb import Pin,DAC, ADC
dac = DAC(Pin('X5')) adc = ADC(Pin('X19'))
print('\nTesting ADDA subsystem of PyBoard\n') print('DAC\t ADC\t Diff') print('-----------------------')
for i in range(256): dac.write(i) time.sleep_ms(100) adcvalue = adc.read() time.sleep_ms(50) diff = 16 * i diff = adcvalue - diff print('{0:3d}\t{1:4d}\t{2:4d}'.format(i, adcvalue, diff))
Die seriellen Ausgaben habe ich geloggt, um diese für die folgenden Grafiken aufzubereiten.
PYBv1.1 DAC-ADC-Characteristics
PYBv1.1 DAC-ADC-Accuracy
Aus der dargestellten DAC-ADC-Charakteristik kann man deutlich erkennen, dass sich das analoge Subsystem erwartungsgemäss verhält. Fehler, wie beim ESP32 sind hier nicht zu erkennen.
Erst im zweiten Plot kann man Abweichungen von maximal +9 und -7 LSB erkennen. Ausserdem ist ein Gain-Error von 5 LSB zu erkennen.
Bei der Bewertung dieser Eigenschaften muss man sich davon vergewissern, dass 1 LSB einer Spannung von 3300 mV/4096 = 0.806 mV und die max. 9 LSB somit 7.25 mV entsprechen. Für den hier gezeigten Messaufbau sind das respektable Werte, die durchaus denen im Datenblatt veröffentlichten entsprechen.
Wird der DAC mit seiner vollen Auflösung als 12-bit DAC betrieben (PYB_adda_test_1.py), ergeben sich praktisch kaum Änderungen.
Python hat sich im Desktop-Bereich und bei Web-Anwendungen etabliert und erobert sich nun mit MicroPython den Bereich der Embedded Systems. Die MicroPython Dokumentation ist hier zu finden.
Pythons übersichtlicher und lesbarer Codierstils und die Vielzahl vorhandener Libraries kommen gerade dem Maker für den Bau von Embedded Systems entgegen. Python gibt Entwicklern die Möglichkeit, sehr schnell Prototypen ihrer Anwendungen zu schreiben.
Ich werde mich hier mit MicroPython auf dem PyBoard sowie Ports für STM32 und ESP32 befassen. Die STM32 von ST sind in industriellen Anwendungen weit verbreitet und der ESP32 ist gerade bei Makern und für das Prototyping sehr beliebt.
Mit den folgenden Boards arbeite ich:
PYBv1.1
NUCLEO-L476RG
ESP32 DevKit
Ich freue mich auf Euer Interesse. Beiträge zum Blog sind willkommen.
