Ik beschrijf hier de gewone PyBoard, niet de PyBoard D.
Pyboard
Zoals de naam suggereert, moet de pyboard geprogrammeerd worden met Python. Het bord is zo opgezet, dat Python als het ware het besturingssysteem is. Het werkt als volgt: als je de pyboard aansluit op een Windows computer, dan lijkt het alsof je een schijf hebt aangesloten, met daarop de bestanden waaronder README.txt, pybcdc.inf, boot.py en main.py. Volgens het README.txt bestand zou je een pybcdc.inf moeten installeren onder Windows, maar dat lukt niet en is ook niet nodig. Zodra een pyboard zonder SD kaart wordt aangesloten op een spanningsbron zal boot.py worden uitgevoerd en vervolgens main.py. In boot.py kun je het gedrag van de pyboard na opstarten veranderen, bijvoorbeeld zo dat deze zich als een muis gaat gedragen. Veel mensen laten boot.py zoals deze is en maken de programma's in main.py. Ik vind dat niet verstandig, onder andere omdat je de programma's toch ergens anders moet bewaren onder een betekenisvolle naam. En pas op: als er iets mis gaat, hoe klein ook, dan zal de pyboard teruggaan in de beginstaat en dan ben je alle opgeslagen bestanden kwijt. Het is dan ook de bedoeling dat je niet het intern flash geheugen gebruikt voor de opslag van een programma, maar een micro SD kaart. Zodra de pyboard een micro SD kaartje ontdekt, gaat hij kijken of daar boot.py of main.py op staat en voert dat dan uit. Als je zo'n kaartje hebt aangesloten dan zie je in de Windows verkenner de inhoud van de SD kaart, niet die van het intern geheugen. Als je meerdere partities hebt op de SD kaart dan zie je die wel. Let op: het kaartje moet FAT of FATxx geformatteerd zijn, niet exFat.
Je kunt boot.py goed gebruiken als je niet al je programmacodes in main.py wilt maken. Je kunt dan de volgende regels in boot.py op te nemen:
import pyb
pyb.main("Blink.py")
Meer hoeft er niet in boot.py te staan.
In de tweede regel zet je de naam van het programma dat moet worden uitgevoerd zodra de pyboard opstart. Deze regel verander je dus als je een ander programma wilt gaan gebruiken. Zet deze boot.py op de SD kaart. Je kunt nu al je programma's onder een goede naam op de SD kaart opslaan en er kan eigenlijk nooit iets mis gaan. Verderop staat een programma waarmee je een opstartmenu kunt maken!
MicroPython
Als je de hardware van het pyboard programmeert, dan gebruik je bijna altijd de bibliotheek pyb. Hierdoor kun je nooit programma's maken die zowel op een ESP module als op de pyboard draaien. Ook verschilt de syntaxis in dat geval nogal veel van de versie voor de ESP.
Gelukkig zijn er op internet verschillende voorbeelden te vinden.
Hoe programmeer je de pyboard?
Je kunt op verschillende manieren programmeren:
- Door met een willekeurige editor main.py te veranderen. Ik gebruik vaak notepad++. Zodra notepad++ weet dat het een Python bestand is gebruikt hij gekleurde syntaxis. Als je liever programma's maakt met veelzeggende namen (zoals blink.py), dan kan dat ook gemakkelijk met Notepad++. Pas dan boot.py aan zoals boven beschreven.
- Door met een terminal programma als PuTTY of Tera Term verbinding te maken met de poort waarop de pyboard is aangesloten. Je kunt nu direct opdrachten geven die worden uitgevoerd door de pyboard. Dit is handig voor het testen. Men noemt dit systeem REPL (Read Evaluate Print Loop), ook wel interactieve interpreteer modus. Je kunt zo een programma regel voor regel intypen, maar een programma runnen vanuit de REPL kan - voor zover ik weet - niet.
Hieronder zie je hoe je in PuTTY een heel programma intypt. Er wordt automatisch ingesprongen. Er gebeurt pas wat als je na de while lus enkele returns geeft.
Bij mij blijkt de regel met import pyb niet nodig te zijn, maar misschien is dat bij andere MicroPython versies anders...
>>> import pyb
>>> led = pyb.LED(2)
>>> while True:
... led.toggle()
... pyb.delay(500)
...
...
...
Op dit moment staat PuTTY te wachten tot er iets gebeurt. Om het programma af te breken kunt je Ctrl-c intoetsen. Je kunt ook Ctrl-d intoetsen voor een zachte herstart van de PyBoard, maar veel terminal programma's sluiten of herstellen de verbinding dan niet goed. Als dat zo is dan kan je niet opnieuw een verbinding leggen. Bij PuTTY kun je na Ctrl-d enige tijd later op Ctrl-c drukken om de verbinding te herstellen.
- Met een IDE, zoals uPyCraft. Ik raad dit echter niet aan, want ik heb diverse hier diverse problemen mee ondervonden.
In Linux werkt dit alles ongeveer hetzelfde, maar ik heb dit niet kunnen testen.
Gebruik van software bibliotheken
Bibliotheken zijn gewone python bestanden, die je op je SD kaart, of in het flash geheugen kunt opnemen. Ik kan me voorstellen dat je het handig vindt om alle bibliotheken in een aparte map te zetten. Dat kan, want de pyboard houdt een pad bij. Hoe dat pad in jouw geval is ingesteld kun je als volgt achterhalen:
>>> import sys
>>> sys.path
['', '/sd', '/sd/lib', '/flash', '/flash/lib']
Dit is de standaardsituatie als je een SD kaartje gebruikt. Je ziet dat een map genaamd lib automatisch wordt opgenomen in het pad. Uiteraard kun je dit pad zelf veranderen.
Voorbeeldprogramma's
Ik maak zelf de programma's vanuit Notepad++ en ik houd het kleurenschema van Notepad++ aan (behalve haakjes, die laat ik zwart). Ook nu weer kun je de programma's gewoon kopiëren met selecteren van de code, kopiëeren (Ctrl-c) en plakken in je eigen tekstverwerker of bestand (Ctrl-v). De kleurcode gaat niet mee. Je hoeft dus nooit programmacode te downloaden.
Een programma dat uitvoer genereert
Vaak zul je het resultaat van een berekening of meting willen laten zien.
Ik begin daar daarom mee. Uiteraard moet je een programma zoals PuTTY of Tera Term hebben verbonden met de pyboard. Bij PuTTY blijkt het volgende handig:
Verbind PuTTY met de poort waar de pyboard op is aangesloten (bijvoorbeeld COM4 bij een Windows computer).
Je opent het programma main.py in Notepad++ of een andere tekst editor. Als je iets verandert hebt aan main.py, sla die dan op. Type in Putty op Ctrl-c en vervolgens op Ctrl-d. De PyBoard start dan opnieuw en gaat de nieuwe main.py uitvoeren. De verbinding met PuTTY wordt op deze manier niet verbroken.
Ik heb ervoor gekozen een eenvoudig programma te maken, zonder specifieke PyBoard bibliotheken. Het zou dus ook op een ander systeem moeten werken. Het programma telt met een snelheid van een per seconde en laat het resultaat als een hexadecimaal getal zien. Om alles op een lijn te krijgen kun je end = ' ' in het print statement opnemen. Om na precies 16 getallen naar de volgende regel te gaan kun je de modulus operator % gebruiken.
import time
i = 0
while True:
print(hex(i), end = ' ')
if i % 16 == 15:
print('') # Ga naar een nieuwe regel
i += 1
time.sleep(1)
En de uitvoer in PuTTY:
0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf
0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f
0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f
0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f
0x40 0x41 0x42 0x43 0x44 0x45 0x46 0x47 0x48 0x49 0x4a 0x4b 0x4c 0x4d 0x4e 0x4f
0x50 0x51 0x52 0x53 0x54 0x55 0x56 0x57 0x58 0x59 0x5a 0x5b 0x5c 0x5d 0x5e 0x5f
0x60 0x61 0x62 0x63 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f
0x70 0x71 0x72 0x73 0x74 0x75 0x76 0x77 0x78 0x79 0x7a 0x7b 0x7c 0x7d 0x7e 0x7f
0x80 0x81 0x82 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f
0x90 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 0x9d 0x9e 0x9f
0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 0xab 0xac 0xad 0xae 0xaf
0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 0xb9 0xba 0xbb 0xbc 0xbd 0xbe 0xbf
0xc0 0xc1 0xc2 0xc3 0xc4 0xc5 0xc6 0xc7 0xc8 0xc9 0xca 0xcb 0xcc 0xcd 0xce 0xcf
0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 0xd7 0xd8 0xd9 0xda 0xdb 0xdc 0xdd 0xde 0xdf
0xe0 0xe1 0xe2 0xe3 0xe4 0xe5 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec 0xed 0xee 0xef
0xf0 0xf1 0xf2 0xf3 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff
0x100 0x101 0x102 0x103 0x104 0x105 0x106 0x107 0x108 0x109 0x10a 0x10b 0x10c 0x10d 0x10e 0x10f
0x110 0x111 0x112 0x113 0x114 0x115 0x116 0x117 0x118 0x119 0x11a 0x11b 0x11c 0x11d 0x11e 0x11f
0x120 0x121 0x122 0x123 0x124 0x125 0x126 0x127 0x128 0x129 0x12a 0x12b 0x12c 0x12d 0x12e 0x12f
Lezen en schrijven van een bestand
Je kunt alleen schrijven naar het intern flash geheugen of naar de SD kaart, niet naar je harde schijf bijvoorbeeld.
Lezen en schrijven gaat op de standaard Python manier: maak een bestand aan door te openen met als extra parameter 'w' (van write). Schrijf hierin via write(). Deze functie geeft het aantal geschreven tekens terug, in dit geval 13.
Sluit een bestand altijd netjes af. Het bestand is niet direct te zien in verkennerweergave, daarvoor moet je eerst de reset knop indrukken. Open een bestand dat je wilt lezen met de functie open(), met alleen de bestandsnaam. De functie read() leest het hele bestand in een keer uit.
>>> bestand = open('Groet.tekst', 'w')
>>> bestand.write('Hallo Wereld!')
13
>>> bestand.close()
>>>
>>> leesbestand = open('Groet.tekst')
>>> leesbestand.read()
'Hallo Wereld!'
>>>
Als je wilt zien welke bestanden er op je pyboard staan type dan in:
import os
os.listdir()
Als het goed is staat het zojuist aangemaakte bestand daar ook in.
Opstartmenu
Vooral als je aan het experimenteren bent kan het handig zijn om een opstartmenu te hebben. Als je dit in boot.py opneemt, of onderdeel maakt van main.py dan begin je steeds met een menu.
Ik heb het heel eenvoudig gehouden: programmas is een lijst van de programma's die in het menu moeten komen, zonder de extensie .py. De rest doet Python automatisch.
programmas = 'Blink', 'Acceleratie', 'RTC', 'TelHex' # Zet hier je eigen programma's
i = 0
X = -1
for p in programmas:
print('Typ', i, 'voor', p)
i += 1
while X < 0 or X > len(programmas):
X = int(input('Maak uw keuze: '))
execfile(programmas[X] + '.py')
Als in toekomstige versies van Python dit niet meer werkt, vervang de laatste regel dan door exec(open(programmas[X] + '.py').read(),globals()).
Hier is de uitvoer:
Typ 0 voor Blink
Typ 1 voor Acceleratie
Typ 2 voor RTC
Typ 3 voor TelHex
Maak uw keuze: 2
zondag 24 januari 2021
12:40:19
Opnieuw opstarten doe je met Ctrl-C, Ctrl-D
Opstartvraag
Vooral voor testen kan het handig zijn de naam van het uit te voeren bestand in te typen. Je typt de naam in zonder de extensie .py. Hou rekening met hoofd- en kleine letters.
Naam = input('Geef de naam op van het programma dat je wil testen: ')
execfile(Naam + '.py')
Neem dit op in main.py, of start het op via boot.py.
Geef de naam op van het programma dat je wil testen: RTC
zondag 24 januari 2021
13:24:02
Als je een ander programma hebt lopen kun je dat met Ctrl-c afbreken. Je kun dan vanaf de prompt (>>>) ook direct een willekeurig bestand opstarten via execfile("naam.py"). Bovenstaand script is dan niet nodig.
De ingebouwde drukschakelaar
Elk PyBoard heeft een ingebouwde schakelaar, met de tekst USR erbij. USR staat voor USER, de gebruiker dus. Deze knop kun je altijd gemakkelijk uitlezen.
Hieronder staat een voorbeeld van hoe je de knop kunt uitlezen. Dat is op zich erg gemakkelijk, maar het probleem (met bijna alle knoppen) is dat ze na erop drukken een aantal keer snel aan- en uitgaan ("jitter"). Om dat op te lossen wordt vaak een wachttijd van bijvoorbeeld een halve seconde ingelast, maar een wachttijd is vaak ongewenst. In dit voorbeeld wacht ik tot de knop de stand "uit" aangeeft, maar ook dat werkt niet goed (al is het beter dan niets doen). Als je op de knop drukt dan gaat de volgende led branden.
import pyb
knop = pyb.Switch()
i = 0
leds = [pyb.LED(1), pyb.LED(2), pyb.LED(3), pyb.LED(4)]
leds[0].toggle()
while True:
if knop():
while knop():
pass # probeer 'jitter' van de knop te onderdrukken
leds[i].toggle()
i += 1
if i > 3:
i = 0
leds[i].toggle()
I²C scanner
Als je niet weet wat het adres is van een I²C apparaat, dan kun je dat vinden via dit programma. Je kunt de hardware pinnen gebruiken, maar ook willekeurige andere pinnen zoals in dít voorbeeld
from machine import I2C, SoftI2C
i2c = SoftI2C(scl = 'X1', sda = 'X2', freq = 100000) # software I2C
A = i2c.scan()
if A == []:
print('Geen i2c apparaten gevonden')
else:
print('Adres (in hex) van de gevonden apparaten:', end = ' ')
for i in A:
print(hex(i), end = ' ')
print()
Vervang de tweede regel door i2c = I2C('X', freq = 400000) als je de hardware I2C pinnen X9 en X10 wil gebruiken.
Hieronder zie je de uitvoer in PuTTY, na een zachte herstart:
Adres (in hex) van de gevonden apparaten: 0x27
MicroPython v1.8.7-478-gbfb48c1 on 2017-03-24; PYBv1.1 with STM32F405RG
Type "help()" for more information.
>>>
De pyboard geeft dus ook na afloop aan welke versie van het Python systeem gebruikt wordt.
Als je geen zin hebt om een een volledig programma te kopiëren in main.py, dan kun je ook de volgende regels intypen achter de prompt bij Putty:
from machine import I2C
i2c = I2C(scl = 'X1', sda = 'X2', freq = 100000)
i2c.scan()
Je krijgt dan het adres in decimale vorm terug of [] als er geen apparaten gevonden zijn.
Uitlezen van de ingebouwde accelerator
De pyboard heeft een ingebouwde accelerator voor elk van de drie richtingen x, y en z en voor tilt. De getallen liggen in tussen -30 en +30. Als je de pyboard snel beweegt dan zie je toch soms hogere waarden. Erg nauwkeurig is dit niet en ook niet stabiel. Toch lijkt me dit systeem goed genoeg om bijvoorbeeld beweging te detecteren om een dobbelsteen te simuleren. Hieronder zie je een simpel voorbeeld:
import pyb
acc = pyb.Accel()
while True:
print('x: {0:>3} y: {1:>3} z: {2:>3} tilt: {3:>3}'.format(acc.x(), acc.y(), acc.z(), acc.tilt()))
pyb.delay(500)
Uitleg over de formatstring met een voorbeeld: in {2:>3} geeft 2 het nummer van het te printen getal, hier acc.z(), want je begint te tellen bij 0; >3 geeft aan dat het getal rechts moet worden uitgelijnd op een afstand van minimaal 3 posities van het vorige getal.
Hier zie je de uitvoer in PuTTY:
x: 5 y: 0 z: 19 tilt: 1
x: 8 y: 0 z: 19 tilt: 1
x: -19 y: 5 z: 8 tilt: 153
x: -7 y: 19 z: 1 tilt: 5
x: 17 y: -11 z: 7 tilt: 21
x: -19 y: 10 z: 0 tilt: 26
x: 15 y: -14 z: 2 tilt: 22
Ingebouwde Real Time Clock
Pyboard met SD kaart en back-up batterij
Toelichting: bij rtc.datetime() geef je in deze volgorde de volgende gegevens op: jaar, maand, dag, dag in de week, uur, minuten, seconden, onderverdeling van seconden (telt van 255 terug naar 0). De laatste twee zul je meestal op 0 zetten.
Afstandsmeting met de HC-SR04 ultrageluid module
De HC-SR04 in actie
Voor de fijnproevers: de fout die in veel bibliotheken wordt gemaakt is dat men aanneemt dat de functie machine.time_pulse_us() een zogenaamde Exception geeft als er een timeout optreedt. Dit is echter bij de pyboard niet het geval. Alle code in de try...except zal daardoor niet correct werken. In werkelijkheid geeft de functie bij een foutsituatie -1 of -2 terug. Ik geef dit door aan het hoofdprogramma, zodat de gebruiker zelf kan bepalen wat hij/zij iets doet met dit gegeven.
Je moet het programma beginnen met init(), waarbij je door jou gebruikte pinnen opgeeft. Ik heb X1 en X2 gebruikt, maar de meeste andere pinnen werken ook. Je kunt voor de veiligheid tussen de echopin en de bijbehorende pyboard-pin een weerstand van ca. 1 kΩ aanbrengen.
De tijd die je terugkrijgt moet je door 2 delen (want het geluid gaat heen en weer) en je moet het vermenigvuldigen met geluidssnelheid. De geluidssnelheid is 343 m/s = 34300 cm/1000000 microseconden. Alles bij elkaar vermenigvuldig je met 0,01715.
import time, machine
from pyb import Pin
def init(Trigger_Pin, Echo_Pin):
global TriggerPin, EchoPin
TriggerPin = Pin(Trigger_Pin, Pin.OUT)
EchoPin = Pin(Echo_Pin, Pin.IN)
TriggerPin.off()
def afstand():
global TriggerPin, EchoPin
TriggerPin.on() # maak een puls van 10 microseconden
time.sleep_us(10)
TriggerPin.off() # de HC-SR04 zendt nu acht pulsen uit
Tijd = machine.time_pulse_us(EchoPin, 1, 23324) # timeout bij > 4 m afstand
if Tijd < 0: # -1 of -2: er is een fout is opgetreden of het voorwerp is te ver weg
return Tijd
return Tijd * 0.01715 # zie tekst voor uitleg
init('X1', 'X2')
while True:
Afstand = round(afstand(), 1)
if Afstand > 0:
print('Afstand:', Afstand, 'cm')
else:
print('Afstand te groot')
time.sleep(0.5)
Laat je pyboard praten, fluisteren of zingen...
De Emic 2 is een geweldig apparaatje, dat tekst omzet in spraak (of zang).
Hij heeft twee nadelen: hij is duur (van 35 tot meer dan 100 euro) en hij wil soms zijn eigen gang gaan. Je kunt hem aansluiten op pinnen van de pyboard, die seri&ele communicatie ondersteunen. Bij uart1 zijn dat de pinnen X9 en X10. Sluit dus SIN van de module aan op pin X9 en SOUT op pin X10 van de pyboard. Je kunt SOUT ook niet aansluiten als je het antwoord van de module niet gebruikt, zoals in het eerste voorbeeld hieronder. Let op: de pinnen van de pyboard kunnen niet goed tegen 5 volt. Op de Emic zie je bij de voeding 5 volt staan. Volgens de specificaties moet hij dit minimaal 3,6 volt zijn, maar hij blijkt toch ook te werken op 3,3 volt. Sluit de Emic gewoon aan op een 3,3 volt uitgang van de pyboard. Hij zal dan maximaal 3,3 volt op SOUT zetten en gaat alles goed. Als je de Emic 2 toch op 5 volt aansluit, zorg dan dat de uitgang SOUT wordt teruggebracht tot 3,3 volt. Sluit een luidsprekertje aan tussen SP+ en SP- of gebruik een koptelefoon met een 3,5 mm plug.
Het programmeren is in principe vrij simpel. Je stuurt een zin naar de module. De eerste letter van de zin bepaalt wat er gebeurt. Als dat een S is, dan verwacht de module dat er een zin volgt die moet worden uitgesproken. Deze zin moet met een leesteken eindigen, anders raakt de Emic in de war. De zinnen mogen samen maximaal 1024 bytes lang zijn. Voor die tijd moet je de string hebben afgesloten met een linefeed of een carriage return. Je doet dat makkelijk door de zin te eindigen met \r of \n. In het voorbeeld laat ik enkele mogelijkheden zijn van deze module. Andere voorbeelden zijn gemakkelijk op internet te vinden.
Een parser is de software die de zinnen en instructies analyseert. Als je de spraak wilt verbeteren dan kun je een alternatieve parser gebruiken, maar dat valt buiten het kader van deze pagina. Ook de standaard parser kent een aantal handige opties, waarvan ik er een in het tweede programma laat zien: woorden die worden voorafgegaan door ## zullen gefluisterd worden.
from pyb import UART
EMIC = UART(1, 9600) # uart1 gebruikt de pinnen X9 en X10
EMIC.init(9600, bits=8, parity=None, stop=1) # gebruik deze instellingen
EMIC.write('D1\n') # zing een liedje
Dit programma speelt de aanwezige demo 1 af: een liedje
Hieronder zie je een programma dat laat zien hoe je iets kunt fluisteren. Helaas gebeurt dit per woord, waardoor de tekst langzaam wordt uitgesproken.
from pyb import UART
from time import sleep
EMIC = UART(1, 9600) # uart1 gebruikt de pinnen X9 en X10; uart6 de pinnen Y1 en Y2
EMIC.init(9600, bits=8, parity=None, stop=1) # gebruik deze instellingen
print('Ik wacht tot de EMIC klaar is')
EMIC.write('\n') # De Emic moet antwoorden met een dubbele punt
sleep(3) # Zonder dit delay doet de EMIC het de eerste keer niet goed
while EMIC.any() == 0: # Nog niets ontvangen
pass
while EMIC.any() > 1: # De emic verzendt ook andere tekens dan ":" dus ...
EMIC.readchar() # ... lees alle andere tekens maar doe daar niets mee
if EMIC.read(1) == b':':
print('De Emic 2 is klaar voor gebruik')
else:
print('Er is iets mis met de (aansluitingen van de) Emic 2')
EMIC.write('V16\n'); # Zet het volume maximaal
while EMIC.read(1) != b':':
pass
EMIC.write('SHello everybody.\n')
while EMIC.read(1) != b':':
pass
sleep(1)
EMIC.write('SWhat is your name?\n')
while EMIC.read(1) != b':':
pass
sleep(2)
EMIC.write('S##I##wisper##something##in##your##ear.\n')
while EMIC.read(1) != b':':
pass
Dit programma laat zien hoe je kunt fluisteren
Ik heb ook een programma gemaakt dat alle stemmen laat horen in het Engels en in het Spaans. Er is ook nog Latijns Spaans mogelijk (kies L2 i.p.v. L1).
Normaal stel je een andere spreker in met Emic.write('N2\n'), maar de Emic parser accepteert ook :-) in een zin, met daarachter het nummer van de stem. Dat is erg handig en het scheelt veel code.
from pyb import UART
from time import sleep
Emic = UART(1, 9600) # uart1 gebruikt de pinnen X9 en X10; uart6 gebruikt Y1 en Y2
Emic.init(9600, bits=8, parity=None, stop=1) # gebruik deze instellingen
def wachtOpEmic():
while Emic.read(1) != b':':
pass
print('Ik wacht tot de Emic klaar is')
Emic.write('\n')
sleep(3) # Zonder dit delay doet de Emic het de eerste keer niet goed
while Emic.any() == 0: # Nog niets ontvangen
pass
while Emic.any() > 1: # De emic verzendt ook andere tekens dan ":" dus ...
Emic.readchar() # ... lees alle andere tekens maar doe daar niets mee.
if Emic.read(1) == b':':
print('De Emic 2 is klaar voor gebruik')
else:
print('Er is iets mis met de (aansluitingen van de) Emic 2')
Emic.write('V8\n') # Zet het volume NIET maximaal (dus kleiner dan 18)
wachtOpEmic()
while True:
print('U moet nu Perfect Paul horen')
Emic.write('S:-)0Hi, I am Perfect Paul.\n')
wachtOpEmic()
sleep(1)
print('U moet nu Huge Harry horen')
Emic.write('S:-)1Hi, I am Huge Harry.\n')
wachtOpEmic()
sleep(1)
print('U moet nu Beautiful Betty horen')
Emic.write('S:-)2Hi, I am Beautiful Betty.\n')
wachtOpEmic()
sleep(1)
print('U moet nu Uppity Ursula horen')
Emic.write('S:-)3Hi, I am Uppity Ursula\n')
wachtOpEmic()
sleep(1)
print('U moet nu Doctor Dennis horen')
Emic.write('S:-)4Hi, I am Doctor Dennis\n')
wachtOpEmic()
sleep(1)
print('U moet nu Kit the Kid horen')
Emic.write('S:-)5Hi, I am Kid the Kid\n')
wachtOpEmic()
sleep(1)
print('U moet nu Frail Frank horen')
Emic.write('S:-)6Hi, I am Frail Frank\n')
wachtOpEmic()
sleep(1)
print('U moet nu Rough Rita horen')
Emic.write('S:-)7Hi, I am Rough Rita\n')
wachtOpEmic()
sleep(1)
print('U moet nu Whispering Wendy horen')
Emic.write('S:-)8Hi, I am Whispering Wendy\n')
wachtOpEmic()
sleep(2)
print('We schakelen over naar Spaans')
Emic.write('L1\n') # Ga over op Spaans
wachtOpEmic()
print('U moet nu Perfect Paulo horen')
Emic.write('S:-)0Hola soy t Paulo.\n')
wachtOpEmic()
sleep(1)
print('U moet nu Francisco horen')
Emic.write('S:-)1Hola soy Francisco.\n')
wachtOpEmic()
sleep(1)
print('U moet nu Betty horen')
Emic.write('S:-)2Hola soy Betty.\n')
wachtOpEmic()
sleep(1)
print('U moet nu Ursula horen')
Emic.write('S:-)3Hola soy Ursula\n')
wachtOpEmic()
sleep(1)
print('U moet nu Enrique horen')
Emic.write('S:-)4Hola soy Enrique\n')
wachtOpEmic()
sleep(1)
print('U moet nu Kit the Kid horen')
Emic.write('S:-)5Hola soy Kid the Kid\n')
wachtOpEmic()
sleep(1)
print('U moet nu Frank horen')
Emic.write('S:-)6Hola soy Frank\n')
wachtOpEmic()
sleep(1)
print('U moet nu Rita horen')
Emic.write('S:-)7Hola soy Rita\n')
wachtOpEmic()
sleep(1)
print('U moet nu Beatriz horen')
Emic.write('S:-)8Hola soy Beatriz\n')
wachtOpEmic()
Emic.write('L0\n') # Terug naar Engels
wachtOpEmic()
sleep(10)
Dit programma laat alle stemmen horen in het Engels en in het Spaans
Al mijn bovenstaande programma's werken in deze vorm bij mij correct, maar ik ben vaak tegen problemen aangelopen, zoals dat de Emic zinnen niet uitsprak of ging herhalen zonder duidelijke reden. Dit leek iets te maken te hebben met het wachten op de reactie van de Emic. In ieder geval is het goed om altijd te beginnen met een wachttijd van ca. 3 seconden.
Numeriek display TM1637
Het display in actie
import tm1637, time
from machine import Pin
tm = tm1637.TM1637(clk=Pin('X6'), dio=Pin('X8'))
tm.brightness(0) # 7 is maximum
print('Schrijf 0x06, 0x5B, 0x4F, 0x66 = 1234')
tm.write([0x06, 0x5B, 0x4F, 0x66])
time.sleep(1)
print('Schrijf 0x06, 0x5B, 0x4F, 0x66 = 1.234')
tm.write([0x06 | 128, 0x5B, 0x4F, 0x66])
time.sleep(1)
print('Schrijf 12.34')
tm.write([0x06, 0x5B | 128, 0x4F, 0x66])
time.sleep(1)
print('Schrijf 1.2.3.4.')
tm.write([0x06 | 128, 0x5B | 128, 0x4F | 128, 0x66 | 128])
time.sleep(1)
print('Schrijf HELP')
tm.show('help')
Numeriek display met 8 cijfers, met MAX7219
Het display in actie
#clk gaat naar X6; dio (= mosi) gaat naar X8
from machine import Pin, SPI
import max7219_8digit
spi = SPI(1)
ss = Pin("X5", Pin.OUT)
disp = max7219_8digit.Display(spi, ss)
disp.setintensity(7)
disp.write_to_buffer('12345678')
disp.display()
Er zijn andere, uitgebreidere bibliotheken voor dit display, maar die heb ik niet uitgeprobeerd.