MicroPython

StackyPi

StackyPi ist ein kompaktes auf dem RP2040-Mikrocontroller aufbauendes Board mit einer Raspberry Pi-kompatiblen Stiftleiste (Header), die den Anschluss der sogenannten Raspberry Pi HATs ermöglicht.

Dadurch erschliessen sich dem Anwender weitere, im Raspberry Pi-Umfeld bereits etablierte Peripherie-Erweiterungen

Für die Verbindung mit einem pHAT ist die Belegung der Stiftleiste und die Zuordnung der Pins des RP2040 besonders wichtig.

Weitere Informationen finden Sie auf der SB-Components Website. Wichtig ist ausserdem, die Zuordnung der Pins an Hand des Schemas zu verifizieren.

Ich teste die Peripherie-Erweiterung mit dem Coral Environmental Sensor Board von Google.

Das Board weist die folgenden Komponenten auf:

● 128×32 OLED Display
● Umgebungslichtsensor OPT3002
● Drucksensor BMP280
● Temperatur- und Feuchtesensor HDC2010
● Cryptoprocessor ( ATECC608A) with Google keys
● Grove connectors: 1x UART, 1x I2C, 1x PWM, 1x 3.3/5V analog
● General purpose button
● General purpose LED

Ein Datenblatt finden Sie hier.

Mit einer Reihe von MicroPython Code Snippets werde ich die peripheren Komponenten in Betrieb nehmen. Die dokumentierten Queltextes finden Sie auf Github.

StackyPi Internals

Über das Programm StackyPi_Internals.py werden einige Interna preisgegeben. Es wird mit der aktuellen Firmware v1.18 gearbeitet, allerdings weist die Angabe der On-Chip Temperatur noch einen Fehler auf.

OLED Display

Das OLED Display hat eine Auflösung von 128 x 32 Pixeln und wird mit einem SSD1306 Controller über SPI0 betrieben. Mit dem Programm StackyPi_ESB_OLED.py wird die folgende Ausgabe auf dem Display erzeugt.

2022-05-06/CK

pyBase for MicroPython

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.

Zu beziehen sind die Komponenten zu attraktiven Preisen beispielsweise über Aliexpress.de.

Hardware-Unterstützung für Raspberry Pi Pico

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 (I²C) für Pimoroni-Breakouts, Motortreiber, analoge Eingänge, GPIO, einen Piezo-Lautsprecher und ein Mini-Breadboard für individuelle Schaltungserweiterungen

Beim Pico Breakout Garden stehen vier I²C- und zwei SPI-Schnittstellen für Pimoroni-Breakouts zur Verfügung.

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.

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.

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.

Raspberry Pi Pico OLED Thermometer

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 I²C-Schnittstelle
Auslesen des BME280 über das I²C-Interface
Ersatz des Pico Displays von Pimoroni durch eine OLED 128 x 64 mit I²C-Interface

Die erforderlichen Komponenten sind schnell zusammengesteckt.

Da die GPIO des Pi Pico nicht 5 V-tolerant sind werden beide I²C-Devices mit 3.3 V versorgt. Der Pi Pico weist zwei I²C-Busse auf. Verwendet wird hier I²C(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 I²C-Adresse 0x76 und das SSD1306 OLED mit der I²C-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.

Die erwähnten MicroPython-Programme sind in meinem MicroPython-Repository zu finden.

2021-02-09/ck

MicroPython @ Raspberry Pi Pico

Das erste Raspberry Pi Pico Board und das Pimoroni Pico Display Pack sind eingetroffen. Grund genug schon mal erste Tests zu unternehmen.

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.

Die Programmbeispiele werden im Repository unter der URL https://github.com/ckuehnel/MicroPython abgelegt.

2021-02-05/ck

Migration auf Python 3

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.

MicroPython auf RISC-V (Kendryte K210)

SiPEED MAiX BiT ist ein low-cost Development Board mit den folgenden Spezifikationen:

SoC – Kendryte K210 dual core 64-bit RISC-V processor @ 400 MHz (overclockable up to 800 MHz) with
- KPU CNN hardware accelerator
- APU audio hardware accelerator with support for up to 8 mics, up to 192 KHz sample rate
- FPIOA (Field Programmable IO Array) mapping 255 functions to all 48 GPIOs on the chip.
- 8 MB general purpose SRAM including 5.9MB usable as AI SRAM memory
- AXI ROM to load user program from SPI flash
Storage – micro SD card slot, 8MB SPI flash
Display I/F – MCU LCD FPC connector for optional 2.4″ display
Camera I/F – DVP camera FPC connector
USB – 1x USB type-C port for power and programming
Expansion – Breadboard friendly headers with UART, IIC, SPI, I2S, PWM, etc…
Misc – 2x buttons, RGB LED
Power Supply – Via USB type-C port
Performance + Power Consumption – 0.25TOPS @ 0.3W ,400MHz. 0.5 TOPS @ 800 MHz
Dimensions – 5.08 x 2.54 mm

Bei Seeedstudio ist das SiPEED MAiX BiT Board für USD 12.90 erhältlich. Eine Variante mit OV2640 Kamera und LCD kostet ganze USD 20.90.

MAiX wird durch ein Standalone-SDK, auf der Basis von FreeRTOS und C/C++, unterstützt.

Ein MicroPython Port ist ebenfalls verfügbar.

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.

Die Resultate des Pystome_lowmem Benchmarks nach einen Reset zeigt das folgende Bild.

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.

PyBoard ADC & DAC

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.

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.

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.

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.

MicroPython – Python für Embedded Systems

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:

Ich freue mich auf Euer Interesse. Beiträge zum Blog sind willkommen.

Hier entsteht ein MicroPython Blog…

…in den nächsten Tagen mehr.