TigerJython4Kids
HomeTurtlegrafikRobotikDatenbanken
appendix

ANHANG: 7-SEGMENT DIGITALANZEIGE

 

 

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 I2C). Es gibt viele Bezugsquellen (Arduino/Raspberry Pi-Lieferanten, 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.

 
Zur Ansteuerung der Anzeige wird eine Pythonmodul mb7seg verwendet, das den Programmierer von der trickreichen Kommunikation mit der Anzeige isoliert und ihm einige einfache Darstellungsfunktionen zur Verfügung stellt (siehe API Dokumentation). Du kannst mb7seg.zip von hier hinunterladen. Es enthält mb7seg.py und eine Minimalversion mb7segmin.py, die du dann verwenden kannst, wenn du wegen der Programmgrösse den Fehler "memory allocation failed" kriegst.  Du musst das eine oder andere Modul dann im Menü von TigerJython unter Tools | Modul hinunterladen auf den micro:bit kopieren.

 

 

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)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

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() stellst du den Messzyklus ein, 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)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

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/s2 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)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)


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")
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

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 I2C-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 Code Decimal). Du kannst dich im Internet orientieren, was man darunter versteht.

 


from microbit import *

s = 0 # Sekunden
m = 33 # Minuten
h = 15 # Stunden
w = 2 # Wochentag (Sonntag = 1)
dd = 3 # Tag
mm = 11 # Monat
yy = 2018 # Jahr

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)) 
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

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)
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

API DOKUMENTATION MODUL mb7seg

 

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

Klasse FourDigit

 Konstruktoren/Methoden  Aktion
 FourDigit()  erzeugt eine Displayinstanz mit Standardwerten:
 Clock-Anschluss: P0, Data-Anschluss: P1, Helligkeit: 4
 FourDigit(clk = pin0,
 dio = pin1, lum = 4)
 erzeugt eine Displayinstanz mit gegebenen Werten für den Clock-
 Anschluss, Data-Anschluss und die Helligkeit
 show(text, pos = 0)  schreibt text mit ersten Zeichen an der gegebenen Position (0: Ziffer
 ganz links, 3: Ziffer ganz rechts). Der Text kann beliebig lang sein,
 aber es werden nur 4 Zeichen angezeigt. Der Text wird gespeichert und kann mit  toLeft() und toRight() verschoben werden.  Integer werden linksbündig dargestell
 setColon(True)  zeigt den Doppelpunkt beim Ausschreiben von Text
 (*)erase()  löscht den Text und den Doppelpunkt

 (*)toLeft()  verschiebt den Text um eine Stelle nach links  und gibt die Anzahl
 Zeichen zurück, da auf der rechten Seite noch zur Verfügung stehen
 (0: wenn der ganze Text durchgelaufen ist)
 (*)toRight()  verschiebt den Text um eine Stelle nach rechts und gibt die Anzahl
 Zeichen zurück, die auf der linken Seite noch zur Verfügung stehen
 (0: wenn der ganze Text durchgelaufen ist)
 (*)toStart()  setzt den Text an die Position, an dem er sich beim Aufruf von
 show()  befand
 (*)scroll(text)  schreibt text mit dem ersten Zeichen an Position 0 aus und scrollt
  dann den Text nach links, bis alle Zeichen angezeigt wurden
 (blockierende Methode)
 (*)setLuminosity(lum)  setzt die Helligkeit auf den gegebenen Wert (0..7)

 

11-1
Fachliche Hinweise:

Zeichensatz Siebensegmentanzeige:

Display-mapping.pdf

3-2
Fachliche Hinweise:

Aus den drei Beschleunigungskomponenten kannst du die Winkel Pitch und Roll berechnen. Starte das folgende Programm und kippe das Board seitwärts bzw. nach vorne und hinter. Im Terminalfenster werden die Drehwinkel in Grad ausgeschrieben.

from microbit import *
from math import *

def getPitch():
    a = accelerometer.get_values()
    pitch = atan2(a[1], -a[2])
    return int(degrees(pitch))

def getRoll():
    a = accelerometer.get_values()
    anorm = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2])
    roll = asin(a[0] / anorm)
    return int(degrees(roll))
   
while True:
    pitch = getPitch()
    roll = getRoll()
    print("p: " + str(pitch))
    print("r: " + str(roll))
    print()
    sleep(100)