BESCHAFFUNG UND ANSCHLUSS

Die Anzeigeeinheit verwendet den Treiberbaustein TM1637 und eine 4-stellige Siebensegmentanzeige mit einem Doppelpunkt  in der Mitte. Zur Ansteuerung sind neben der Stromversorgung mit 3V und GND  lediglich 2 Leitungen mit den Bezeichnungen Clock (CLK) und Data (DIO) nötig.

Es wird ein spezielles Protokoll verwendet (ähnlich, aber nicht gleich wie I²C). Es gibt viele Bezugsquellen (Arduino/Raspberry Pi-Lieferanten, Seed/Grove, eBay, der Preis schwankt zwischen $1 und $10). Es ist darauf zu achten, dass der Display auf für 3V spezifiziert ist, einige funktionieren nur mit einer Versorgungsspannung von  5V.

Die 4 Leitungen werden mit Kabeln am micro:bit angeschlossen. Für CLK und DIO können irgendwelche Ports P0, P1, P2, P8, P12, P16 verwendet werden, üblich sind aber P0 für CLK und P1 für DIO. Auf einer Siebensegmentanzeige kann nur ein beschränkter Zeichensatz dargestellt  werden. O►

TYPISCHE BEISPIELE

1. Von 0 bis 9999 hochzählen

Zuerst wird mit d = FourDigit(pin0, pin1) ein Displayobjekt  (eine Instanz) erzeugt. Dabei werden die Anschlussports für CLK und DIO angegeben. (Lässt du die Parameter weg, so wird pin0 für CLK und pin1 für DIO angenommen.) Die Methode show(text) kann auch direkt Integers anzeigen.

from mb7seg import FourDigit
from microbit import *
 
d = FourDigit(pin0, pin1)

for n in range(10000):
    d.show(n)

Du erkennst, dass für die Anzeige einer einzelnen Zahl ungefähr 30 ms benötigt wird. Mit einer Formatangabe, kannst du die Zahlen rechtsbündig ausschreiben: d.show("%4d" %n).

2. Die Beschleunigung anzeigen

Die Digitalanzeige wird vielfach eingesetzt, um Messwerte eines Sensors anzuzeigen, beispielweise die x-Komponente der Beschleunigung. Dazu pollst du in einer Endlosschleife den Sensorwert und schreibt in aus. Mit einem sleep() wählst du die Periode des Messzyklus, musst aber beachten, dass auch die anderen Aufrufe im Schleifenkörper Prozessorzeit benötigen.

from mb7seg import FourDigit
from microbit import *
 
d = FourDigit()
while True:
    acc = accelerometer.get_x()
    d.show(acc)
    sleep(100)

Hier wird der Displayinstanz ohne Parameterwerte erstellt und dabei vorausgesetzt, dass sich die Anschlüsse CLK und DIO bei P0 und P1 befinden.

Für Dezimalzahlen wird zuerst mit einer Formatangabe eine vierziffrige Zahl mit 2 Dezimalstellen und Vornullen angefordert (in der Längenangabe wird der Dezimalpunkt mitgezählt). Dann  muss der Dezimalpunkt entfernt werden, da dieser ja mit dem Doppelpunkt simuliert wird. Im Programm wird die Beschleunigung in m/s² ausgeschrieben.

from mb7seg import FourDigit
from microbit import *
 
d = FourDigit()
d.setColon(True)
while True:
    acc = accelerometer.get_x() / 100
    v = "%05.2f" %acc
    v1 = v.replace(".", "")
    d.show(v1)
    sleep(100)

3. Eine Eingabeaufforderung anzeigen

Nach dem Start bleibt das Programm in einer  Wiederholschleife hängen, bis der Benützer den Button A klickt. Dabei wird der Prompt-Text in Laufschrift ausgeschrieben. Es wäre dabei ungünstig, die blockierende Methode scroll() zu verwenden, da der Benützer nach dem Klicken des Buttons warten müsste, bis der ganze Text fertig angezeigt ist. Vielmehr ist es angebracht, mit toLeft() den Text zu Scrollen, damit du immer wieder prüfen kannst, ob der Buttonklick erfolgt ist. Um aus den Wiederholschleifen "auszubrechen", verwendest du zweimal break.

from mb7seg import FourDigit
from microbit import *
 
d = FourDigit()
d.show("Press A to start")
while True:
     while d.toLeft() > 0 and not button_a.is_pressed():
        sleep(300)
     if button_a.is_pressed():
        break   
     d.toStart()   
     sleep(500)
d.show("Go")

Hier darfst du nicht button_a.was_pressed() verwenden, da du damit nicht zweimal hintereinander True erhältst, wenn du nur einmal klickst.

4. Die Uhrzeit anzeigen

Mit einem billigen Clock-Module (Real Time Clock, RTC), kannst du aus deinem micro:bit eine präzis laufende digitale Uhr machen. Das Modul verwendet ein Board mit dem DS3231 Chip. Es gibt viele Bezugsquellen (Arduino/Raspberry Pi-Lieferanten, Grove, eBay, der Preis schwankt zwischen $1 und $10). Das Module verwendet das I²C-Protokoll mit den 4 Anschlüssen GND, VCC, SCL und SDA.

Du  schliesst es am micro:bit wie folgt an: GND ⇒ GND VCC ⇒ 3V SCL ⇒ P19 SDA ⇒ P20 Nach dem Einsetzen der Batterie musst du zuerst Datum und Uhrzeit  mit einem Programm einstellen. Das Modul arbeitet im BCD-Format (Binary Coded Decimal). Du kannst dich im Internet orientieren, was man darunter versteht.

from microbit import *

s = 0 # Seconds
m = 33 # Minutes
h = 15 # Hours
w = 2 # Day of week (Sunday = 1)
dd = 3 # Day
mm = 11 # Month
yy = 2018 # Year

def dec2bcd(dec):
    tens, units = divmod(dec, 10)
    return (tens << 4) + units
 
addr = 0x68
t = bytes([s, m, h, w, dd, mm, yy - 2000])
for i in range(0,7):
    i2c.write(addr, bytes([i, dec2bcd(t[i])]))
print("Datetime set to %d-%d-%d %d:%d:%d" %(dd, mm, yy, h, m, s)) 

Dein Uhrenprogramm sendet mit i2c.write() dem RTC-Modul den Befehl, die Datumszeit zurück zu geben und liest sie mit buf = i2c.read() wiederum im BCD-Format in einen Buffer. Nach der Umwandlung ins Dezimalformat stellst du Stunden und Minuten auf der Siebensementanzeige dar und lässt noch ungefähr alle Sekunden den Doppelpunkt blinken.

from mb7seg import FourDigit
from microbit import *

def bcd2dec(bcd):
    return ((bcd & 0xf0) >> 4) * 10 + (bcd & 0x0f)
 
d = FourDigit()
showColon = False
while True:
    addr = 0x68
    i2c.write(addr, b'\x00')
    buf = i2c.read(addr, 7)
    mm = bcd2dec(buf[1])
    hh = bcd2dec(buf[2])
    d.show("%02d%02d"  %(hh, mm)) # show leading zeros
    if showColon:
        d.setColon(False)
        showColon = False
    else:
        d.setColon(True)
        showColon = True
    sleep(1000)

API DOKUMENTATION MODUL mb7seg

Modul import:
from mb7seg import FourDigit
(*) im Modul mb7segmin nicht enthalten

Klasse FourDigit