Programmeren van een Micro:Bit Robot & Joystick:Bit Controller met MicroPython - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Voor Robocamp 2019, ons zomerrobotkamp, solderen, programmeren en bouwen jongeren van 10 tot 13 jaar een op BBC micro:bit gebaseerde 'antweight robot', en programmeren ze een micro:bit om als afstandsbediening te gebruiken.

Als je momenteel bij Robocamp bent, ga dan naar stap 3, aangezien we de eerste twee stappen als groep hebben gedaan

Dit is een stapsgewijze handleiding om een micro:bit-robot te laten communiceren met een joystick:bit-controller.

Het duurt niet de snelste route om alles werkend te krijgen, maar probeert dingen in kleine stukjes, zodat je de code kunt testen terwijl je bezig bent, je eigen stempel erop kunt drukken en begrijpt waarom we de dingen doen die we doen !

Voor deze activiteit gebruiken we onze eigen aangepaste robot, maar deze werkt met elke robot die een vergelijkbare motordriver gebruikt, zoals een L9110s.

Ontwerpbestanden voor onze robot zijn hier te vinden:

Deze handleiding is geschreven voor beginners, maar als je nog nooit een micro:bit met MicroPython hebt gebruikt, raden we je aan eerst een eenvoudiger programma te proberen, zoals onze naambadge Instructable: https://www.instructables.com/id/Felt -Microbit-naam…

Benodigdheden

2x BBC micro:bit

Robot die werkt met een BBC micro:bit (zie uitleg hierboven)

joystick:bit-controller (die van ons hebben we van Cool Components)

Stap 1: Robot instellen

Je hebt een paar opties voor het schrijven van MicroPython-code voor je micro:bit:

• Mu, die u hier kunt downloaden en installeren:
• De online-editor, die u hier kunt vinden:

Deze instructies gaan ervan uit dat u Mu gebruikt

Open Mu en sluit je micro:bit aan op je computer. Mu zou moeten herkennen dat je een micro:bit gebruikt en micro:bit 'Mode' selecteren, maar als dit niet het geval is, wijzig het dan handmatig.

Download hier een kopie van de testcode van de robotmotor:

Als je Github niet gewend bent, kan het niet intuïtief zijn! Twee eenvoudige manieren om deze code te krijgen zijn:

1. Sla het Raw-bestand op uw computer op en laad het vervolgens in Mu:
2. Kopieer en plak alle gegeven code in een Nieuw bestand in Mu.

Klik nu op de 'Flash'-knop van Mu's werkbalk om je nieuwe code naar de micro:bit te sturen.

Dit werkt alleen als de micro:bit is aangesloten

Het gele lampje op de achterkant van de micro:bit begint te knipperen. Als het klaar is, is je code overgedragen.

DE MOTORRICHTING INSTELLEN

Dit programma zet de motoren in verschillende richtingen aan als je op de 'A'-knop op de micro:bit drukt.

Wat je wilt dat er gebeurt is:

• Als 'A' wordt weergegeven, motor links vooruit
• Wanneer 'B' wordt weergegeven, linker motor achteruit
• Wanneer 'C' wordt weergegeven, motor rechts vooruit
• Wanneer 'D' wordt weergegeven, rechts motor achteruit

Dit zal waarschijnlijk niet het geval zijn, omdat het afhangt van hoe je je robot hebt aangesloten!

Bovenaan de code vind je een lijst met variabelen, die bepalen welke pin op de micro:bit welke motorrichting aanstuurt.

Als je een van onze robots (bestanden) gebruikt, verwissel dan de namen van de variabelen om de robot in de juiste richting te laten bewegen:

Als u een eigen robot gebruikt, controleer dan op welke pinnen de motordriver is aangesloten voordat u de code bewerkt.

DE AANDRIJVING TESTEN

Controleer nu hoe uw robot rijdt door de testcode in de hoofdlus te vervangen door een eigen code.

Je vertelt de robot om te rijden door de functie drive() aan te roepen. Hiervoor zijn twee argumenten nodig: een waarde voor de linkermotor en een waarde voor de rechtermotoren, tussen 0 (uit) en 1023 (max. snelheid).

Door bijvoorbeeld drive (500, 500) aan te roepen, laat u beide motoren met ongeveer halve snelheid in voorwaartse richting draaien.

Probeer een paar opties uit om een idee te krijgen hoe recht hij rijdt en hoe goed hij draait.

Hint: de motortests waren zowel een tijdje in een True-loop als een if-statement - de motoren zouden niet draaien totdat je op de A-knop op de micro:bit drukte, en het controleert altijd of je op de A-knop hebt gedrukt.

Tip: de motoren gaan pas uit als u dat zegt! Ze zullen altijd hun laatste instructie blijven doen.

OPTIONEEL: VERBETEREN RIJDEN IN EEN RECHTE LIJN

Als uw robot niet in een rechte lijn rijdt, draait een van uw motoren mogelijk sneller dan de andere.

Nadat u hebt gecontroleerd of er niets fysiek is dat het wiel ervan weerhoudt vrij te draaien, kunt u de code in de rijfunctie bewerken om de snelheid van de snellere motor te verlagen.

Blader omhoog om de definitie van de aandrijffunctie te vinden en bekijk de bovenste twee instructies:

def aandrijving (L, R):

# Hieronder vindt u een aanpassing om het verschil in motorsnelheid te corrigeren L = int(L*1) R = int(R*1)

Deze twee regels hebben momenteel de waarde van L en R, vermenigvuldig ze met 1 en zorg ervoor dat het nog steeds hele getallen zijn (int).

Als uw linkermotor bijvoorbeeld sneller is, verander dan de *1 op de regel in *0.9 en kijk of dat de zaken verbetert.

Je zult het niet perfect kunnen maken, maar je kunt blijven aanpassen totdat het rechter rijdt.

DE RADIO INSTELLEN

Stel nu de radio in door de volgende regels bovenaan je code toe te voegen:

radio importeren

radio.config(kanaal=7, groep=0, wachtrij=1) radio.on()

Hierdoor kan uw robot instructies ontvangen van een andere micro:bit, maar op dit moment ontvangt hij instructies van elke andere micro:bit.

Dit komt omdat kanaal 7 en groep 0 de standaardkanalen zijn.

Wijzig deze nummers, kies een kanaal tussen 0-82 en een groep tussen 0-255. Nu ontvangt uw micro:bit alleen instructies van anderen met dezelfde configuratie-informatie.

wachtrij=1 betekent dat de micro:bit slechts één inkomend bericht tegelijk zal bewaren - dit geeft een iets snellere responstijd dan de standaard, namelijk 3.

Nu moet u uw hoofdluscode bewerken om, in plaats van instructies uit te voeren wanneer u op een knop drukt, wacht op een binnenkomend radiobericht en op de juiste manier reageert.

Probeer de volgende code als test (deze zal niets doen totdat u de joystick hebt ingesteld in stap 2):

terwijl waar:

message = radio.receive() if message == 'forward': drive(500, 500)

Stap 2: Joystick instellen

Koppel de micro:bit van uw robot los en sluit in plaats daarvan de micro:bit van uw joystick aan

Download hier een kopie van de configuratiecode van de joystick:

Stel de radio in met dezelfde configuratie (kanaal en groepsnummer) als voor de robot - hierdoor kunnen de twee met elkaar communiceren.

Aan het einde van het programma start je je hoofdlus:

terwijl waar:

if button_a.was_pressed(): radio.send('forward')

Deze code maakt nog geen gebruik van de joystick:bit. Het gebruikt knop A op de micro:bit om een bericht te verzenden.

Zorg ervoor dat zowel je robot als de micro:bits van je controller stroom hebben en druk vervolgens op de knop om je bericht te verzenden.

Als het bericht succesvol is ontvangen en je robot beweegt… goed gedaan! U bent klaar met de installatie-instructies.

TIPS VOOR HET OPLOSSEN VAN PROBLEMEN

Als je een foutmelding krijgt op je controller micro:bit… debug je controllercode

Als je een foutmelding krijgt op je robot micro:bit… is je radiobericht succesvol verzonden! Maar de robot kan het niet begrijpen, dus controleer of het bericht dat je hebt verzonden en het bericht dat je de robot hebt laten luisteren, overeenkomen.

Als er helemaal niets gebeurt

• Zorg ervoor dat je de juiste code naar elke micro:bit hebt geflitst - het is gemakkelijk om per ongeluk de verkeerde te flashen!
• Zorg ervoor dat je kanaal- en groepsnummers overeenkomen op elke micro:bit

Stap 3: De joystickwaarden controleren

De volgende paar stappen gebruiken allemaal de controllercode

Voordat je de joystick op je controller kunt gebruiken, moet je weten wat voor soort waarden je krijgt als je op de stick drukt.

Vervang je hoofdlus door de volgende code:

terwijl waar:

joystick = joystick_push() print(joystick) sleep(500)

Flash deze code naar je micro:bit en klik vervolgens op de REPL-knop op de werkbalk van Mu. Dit opent een terminal onderaan de editor, die je een realtime link naar de micro:bit geeft.

Dit werkt alleen als de micro:bit is aangesloten

Met de REPL open, druk je op de resetknop op de achterkant van je micro:bit.

U zou moeten zien dat enkele waarden 'afgedrukt' op uw scherm verschijnen:

Duw op de joystick van de joystick en kijk wat er met de cijfers gebeurt.

Noteer de waarden die worden gegeven wanneer de joystick in de middenpositie staat - in mijn geval (518, 523).

Klik nogmaals op de REPL-knop op Mu's werkbalk om deze te sluiten - je kunt geen nieuwe code flashen naar de micro:bit terwijl deze open is.

Stap 4: De X- en Y-variabelen aanpassen

U wilt de waarden van de joystickfunctie wijzigen, zodat:

• in het midden is het nul
• omhoog is positief
• beneden is negatief.

Dit komt overeen met de instructies die de robot nodig heeft - een positief getal om vooruit te rijden en een negatief getal om achteruit te rijden.

Kijk naar de cijfers die je in de laatste stap hebt gekregen. Het eerste getal is x en het tweede getal is y.

Bewerk de joystick_push()-definitie die al in het programma staat, om uw waarden van het origineel te verminderen:

def joystick_push():

x = pin0.read_analog() - 518 y = pin1.read_analog() - 523 return x, y

Gebruik je eigen nummers, ze kunnen anders zijn dan de mijne

Flash je nieuwe code, open de REPL, druk op de resetknop van de micro:bit en controleer je waarden.

Krijg je (0, 0)?

Stap 5: X en Y omzetten in waarden voor de linker- en rechtermotor

Op dit moment zal deze joystick niet erg handig zijn om een robot mee te besturen. Helemaal naar voren geduwd, krijgt u een waarde zoals (0, 500).

Als je deze nummers aan de robot zou geven, zou hij de rechtermotor inschakelen, maar niet de linker, wat niet is wat je wilt dat er gebeurt!

Dit diagram laat zien wat er met de x- en y-waarden gebeurt als je de joystick beweegt, en wat we willen dat de robot doet als je de joystick beweegt.

Je moet wat wiskunde gebruiken om de x- en y-waarden te mixen, om je iets nuttigs te geven.

N

DE WISKUNDE

Laten we beginnen door de joystick helemaal naar voren te duwen.

Een voorbeeld van de waarden die u zou kunnen krijgen is:

x = 0

y = 500

Om nuttig te zijn voor de robot, wil je waarden als deze krijgen:

links = 500

rechts = 500

Laten we proberen x en y op verschillende manieren toe te voegen om te zien welke getallen we krijgen:

x + y = 0 + 500 = 500

x - y = 0 - 500 = -500 y + x = 500 + 0 = 500 y - x = 500 - 0 = 500

Laten we nu eens kijken wat er gebeurt als we de joystick helemaal naar rechts duwen.

Een voorbeeld van de waarden die u zou kunnen krijgen is:

x = 500

y = 0

Om de robot naar rechts te laten draaien, wil je dat de linkermotor vooruit rijdt en de rechtermotor achteruit:

links = 500

rechts = -500

Laten we onze formule nog eens uitproberen:

x + y = 500 + 0 = 500

x - y = 500 - 0 = 500 y + x = 0 + 500 = 500 y - x = 0 - 500 = -500

Vergelijk de twee sets formules om uit te zoeken welke optie u de juiste linkerwaarde geeft en welke optie u de juiste rechterwaarde geeft.

Probeer het eens met enkele van de waarden die u van uw eigen joystick krijgt, om er zeker van te zijn dat de formule die u kiest altijd werkt.

N

DE JOYSTICK-FUNCTIE UITBREIDEN

Breid de joystickfunctie uit en bewerk deze om twee nieuwe variabelen voor links en rechts te maken en om die waarden terug te geven in plaats van x en y:

def joystick_push():

x = pin0.read_analog() - 518 y = pin1.read_analog() - 523 left = right = return links, rechts

Flash je nieuwe code, open de REPL, druk op de resetknop van de micro:bit en controleer je waarden.

Krijg je de waarden die je verwacht?

Als je meer hulp nodig hebt, bekijk dan hier onze voorbeeldcode:

Stap 6: De waarden verzenden als radioberichten

Nu heb je enkele waarden klaar om naar je robot te sturen.

Bewerk uw hoofdlus, zodat deze de waarden van de joystick controleert, maar in plaats van de waarden af te drukken, worden ze gereed gemaakt om als radiobericht te verzenden.

terwijl waar:

joystick = joystick_push() bericht = str(joystick[0]) + " " + str(joystick[1])

Hiermee wordt het bericht nog niet daadwerkelijk verzonden!

Wat gebeurt er in deze nieuwe regel code?

• joystick[0] betekent het eerste stukje informatie dat uit de joystickfunctie komt (links)
• joystick[1] is het volgende stukje informatie (rechts)
• str() converteert beide getallen naar stringformaat (tekst in plaats van getallen) - dit is nodig om de informatie over de radio te kunnen verzenden.

Je zult gewend zijn om + te zien als optellen - het kan zowel getallen bij elkaar optellen als strings samenvoegen, wat betekent dat het de twee stukjes informatie aan elkaar plakt.

Voorbeeld:

150 + 100 = 250

str(150) + str(100) = 150100

Dus aaneenschakeling zal uw linker- en rechterwaarden bij elkaar houden.

Om een scheiding tussen de twee informatiebits te forceren (zodat de robot weet dat het twee informatiebits zijn), voegt u een extra string ertussen toe met behulp van " ". De spraakmarkeringen rond de spatie betekenen dat het al een string is.

Breid tot slot uw code uit om dit nieuw gemaakte bericht via de radio te verzenden:

radio.verzenden(bericht)

slapen(10)

De slaap vertraagt het verzenden van berichten zodat de ontvangende micro:bit niet overladen wordt met te veel informatie!

Flash deze code naar je controller micro:bit en debug eventuele fouten voordat je doorgaat naar de volgende stap

Stap 7: De berichten op uw robot ontvangen

Ga vanaf het begin terug naar je robotcode - vergeet niet om je controller micro:bit los te koppelen, zodat je niet per ongeluk de robotcode erop flitst

Scrol omlaag naar je hoofdlus - verwijder de testcode en voeg deze in plaats daarvan toe:

terwijl waar:

message = radio.receive() print(message) sleep(100)

Dit stelt een variabele in die gelijk is aan het inkomende bericht en drukt het bericht af naar de REPL - om te controleren of de berichten doorkomen zoals verwacht.

Flash uw nieuwe code, verbonden met de REPL, en druk vervolgens op de joystick.

Je zou zoiets als dit moeten krijgen:

TIPS VOOR HET OPLOSSEN VAN PROBLEMEN

Als je een foutmelding krijgt op je controller micro:bit… debug je controllercode

Als je een foutmelding krijgt op je robot micro:bit… is je radiobericht succesvol verzonden! Maar de robot kan het niet begrijpen, dus controleer of het bericht dat je hebt verzonden en het bericht dat je de robot hebt laten luisteren, overeenkomen.

Als er helemaal niets gebeurt

• Zorg ervoor dat je de juiste code naar elke micro:bit hebt geflitst - het is gemakkelijk om per ongeluk de verkeerde te flashen!
• Zorg ervoor dat je kanaal- en groepsnummers overeenkomen op elke micro:bit

Stap 8: De inkomende berichten gebruiken om de motoren van de robot te besturen

U krijgt nu twee nummers die als een string over de radio worden verzonden.

U moet dit bericht in twee strings splitsen, de strings vervolgens weer omzetten in cijfers en dit doorgeven aan de drive-functie. Er gebeurt veel tegelijk!

Voordat u dit doet, moet u controleren of het bericht dat u ontvangt de juiste indeling heeft.

Als er geen berichten worden verzonden, ontvangt u in plaats daarvan 'Geen'. Als je dit probeert te splitsen, krijg je een foutmelding.

terwijl waar:

message = radio.receive() als bericht niet Geen is: message = message.split() drive(int(message[0]), int(message[1]))

Wat gebeurt hier?

• De nieuwe code wordt uitgevoerd als het bericht iets anders is dan 'Geen'.
• message.split() zoekt naar een spatie in het bericht (die we in de laatste stap hebben toegevoegd) en gebruikt dit om het bericht in tweeën te splitsen.
• int(message[0]), int(message[1]) doet het tegenovergestelde van wat we in de vorige stap deden - haalt elk stukje informatie afzonderlijk op en zet het om in een geheel getal (een geheel getal).
• int(message[0]) wordt gebruikt als de waarde voor de linkermotor in de aandrijffunctie, en int(message[1]) wordt gebruikt als de waarde voor de rechtermotor.

Controleer of het werkt - draaien de motoren als u op de joystick drukt?

Zo niet - tijd voor wat debuggen!

Zo ja, fantastisch! Je hebt een werkende robot met afstandsbediening!

Besteed wat tijd aan het oefenen met uw robot voordat u doorgaat naar de volgende stap. Rijdt hij zoals je verwacht?

De volgende stappen laten u zien hoe u de knoppen op de joystick gebruikt om extra functionaliteit aan uw robot toe te voegen

Als je onze versie van deze code tot nu toe wilt zien:

• Robot:
• Controller:

Stap 9: De knoppen gebruiken -- Extra berichten ontvangen

Op dit moment probeert uw code elk bericht dat geen Geen is, te splitsen. Dit betekent dat als hij bijvoorbeeld 'hallo' ontvangt, je een foutmelding krijgt.

Om uw micro:bit in staat te stellen andere berichten te interpreteren, moet het eerst elk verwacht bericht controleren en vervolgens het bericht alleen splitsen als er niets anders mee is gedaan.

Breid je code als volgt uit:

als het bericht geen Geen is:

if message == 'hallo': display.show(Image. HAPPY) elif message == 'duck': display.show(Image. DUCK) else: message = message.split() drive(int(message[0]), int(bericht[1]))

Ten eerste controleert het of het het bericht 'hallo' heeft ontvangen. Als dit het geval is, wordt er een vrolijk beeld weergegeven, ga dan terug naar de bovenkant van de lus en controleer op het volgende bericht.

Als het bericht geen hallo is, wordt vervolgens gecontroleerd of het bericht 'duck' is.

Als het bericht niet 'hallo' OF 'eend' is, zal het het laatste op de lijst doen, namelijk het bericht splitsen en de motoren aanzetten. Het zal niet proberen het bericht te splitsen als het 'hallo' of 'duck' heeft ontvangen, wat betekent dat je geen foutmelding krijgt van een van deze twee berichten.

Het dubbele gelijkteken is belangrijk - het betekent 'is gelijk aan', vergeleken met een enkel gelijkteken, dat iets instelt (dus message = 'hello' betekent dat we de variabele op 'hello' zetten, message == 'hello' betekent dat we vragen of bericht gelijk is aan 'hallo').

Probeer het nu met slechts twee opties, om het te testen - je kunt later zoveel andere berichten toevoegen als je wilt.

Link naar werkende code:

Stap 10: Extra berichten verzenden met de knoppen van de controller

Koppel de micro:bit van uw robot los en sluit in plaats daarvan de micro:bit van uw joystick aan

Ga terug naar je controllercode om te bewerken.

Net als bij de robotcode willen we dat de controller controleert of u andere berichten probeert te verzenden, voordat de joystickwaarden worden verzonden.

Bovenaan de lus willen we nog steeds dat het de huidige waarden van de joystick controleert, maar we willen ook dat het controleert of er momenteel op een knop wordt gedrukt:

terwijl waar:

joystick = joystick_push() knop = button_press()

button_press() retourneert een waarde A, B, C, D, E of F, afhankelijk van de knop die momenteel wordt ingedrukt (als er niets wordt ingedrukt, wordt Geen geretourneerd).

Nu kunnen we een if-elif-else-statement maken, zoals we deden voor de robotcode - met twee knoppen en de joystickwaarde verzenden als er geen knop wordt ingedrukt.

if-knop == 'A':

radio.send('hello') sleep(500) elif-knop == 'B': radio.send('duck') sleep(500) else: message = str(joystick[0]) + " " + str(joystick [1]) radio.send(bericht) slaap (10)

Wanneer er op een knop wordt gedrukt, verzendt u een van de berichten waar u de robot in de vorige stap op heeft laten letten.

Het bericht wordt verzonden wanneer de knop wordt ingedrukt, en computers zijn veel sneller dan mensen! Het kan dus zijn dat het bericht vaak wordt verzonden voordat u uw vinger van de knop hebt kunnen halen.

De slaapstand na het verzenden van het bericht vertraagt het, zodat het de knop niet zo snel opnieuw zal controleren - probeer hier een paar cijfers om de perfecte hoeveelheid tijd voor je te krijgen - te langzaam en het zal ook niet reageren snel en uw robot zal zoveel knopberichten ontvangen dat hij misschien niet meer reageert op de joystick!

Werkt het?

Als u foutmeldingen krijgt, denk dan goed na over wat u zojuist hebt gewijzigd en wat er gebeurt.

Als je een foutmelding krijgt op de robot wanneer je op een knop op je controller drukt, weet je dat de boodschap overkomt, maar het verwart de robot. Controleer of het bericht dat u hebt verzonden en het bericht dat u de robot heeft laten zoeken, hetzelfde zijn.

Link naar werkende code:

Stap 11: Volgende stappen

Je hebt nu de kennis die je nodig hebt om met de motoren van je robot en met je joystick:bit-controller te werken

Gebruik deze kennis om de twee programma's te verbeteren en ze eigen te maken. Enkele ideeën hieronder!

Je hebt zes knoppen op je controller! wat wil je dat ze doen?

• Hoe zit het met het programmeren van een dansroutine voor je robot om op commando te doen? Schrijf een algoritme van drive()-commando's, gescheiden door sleep()-commando's!
• Wil je de richting waarin de robot beweegt veranderen, zodat hij gemakkelijk ondersteboven kan rijden? Denk aan de x- en y-waarden van uw joystick. Wat stellen ze voor en hoe zou je ze kunnen manipuleren?
• Heeft jouw robot (of zou je die kunnen toevoegen!) extra features zoals leds, een speaker of sensoren?

Ideeën om de code te verbeteren

• Kun je je robot helpen om onbekende berichten af te handelen door de try/behalve-code te gebruiken?
• De wiskunde die wordt gebruikt om de linker- en rechterwaarden van de joystick te berekenen, geeft ons niet het volledige waardenbereik (de aandrijving van de robot kan een getal tot 1023 accepteren). Kun je deze code bewerken om een beter bereik te krijgen?
• Er zijn andere methoden om de joystickwaarden te mixen - kunt u een betere manier bedenken om dit te doen?