Der perfekte Fahrroboter für Ihren Informatik- und Technikunterricht!
Bereichern Sie Ihren Informatik- und Technikunterricht mit Calle, einem kleinen, kompakten und kostengünstigen Fahrroboter für den Calliope mini V3. Dieses innovative Werkzeug motiviert Schülerinnen und Schüler, ihre Coding-Experimente auf einem fahrbaren Untersatz auszuprobieren und dabei spielerisch grundlegende Programmierkenntnisse zu erwerben.
Inhaltsangabe
Aufbau
Der Aufbau von Calle ist recht leicht. Es müssen nur die beiden Antriebsräder und die vordere Laufrolle montiert werden.
Vorher werden von der Platine noch die seitlichen Platinenränder entfernt. Diese werden bei der Produktion für die Stabilität benötigt und können einfach mit der Hand abgebrochen werden.
Wir starten mit den Antriebsrädern
Wir bringen die Motoren mithilfe der weißen Halterungen an der Unterseite an. Man achte darauf, dass der überstehende Teil der Halterung und die Achse des Motors nach außen zeigt.
Die Kabel der beiden Motoren werden durch die Öffnung in der Platine auf die Oberseite geführt. Hier werden die JST-Stecker der beiden Motoren in die dafür vorgesehenen Buchsen eingesteckt.
Die Ausrichtung der schwarzen und roten Kabel sind irrelevant, da die Stecker nur in einer Ausrichtung eingesteckt werden können.
Montage der vorderen Laufrolle
Die vordere Laufrollte funktioniert wie ein Stützrad. Es übernimmt alle Bewegungen, die durch die beiden Antriebsmotoren ausgelöst werden.
Zwischen Laufrolle und Platine werden mit zwei kurzen Nylonschrauben zwei Hexagon-Abstandshalter befestigt. Diese bringen die Laufrolle auf eine Höhe, die gut zu den Antriebsrädern passt. Danach wird die Rolle unter der Platine befestigt, indem zwei weitere Schrauben von der Oberseite der Platine durch die dafür vorgesehenen Löcher gesteckt und in den Hexagon-Abstandshaltern befestigt werden.
Komponenten
Die übrigen Komponenten, Linetracking-Sensoren und Ultraschallsensor werden abschließend auf der Oberseite der Platine eingesteckt.
Programmierung
Programmierplattform
Sicherlich kennst du schon von deinen vorherigen Versuchen mit dem Calliope die Programmierplattform MakeCode IDE. Wenn du bisher noch nie mit einem Calliope Mikrocontroller gearbeitet hast, solltest du dich zunächst damit auseinander setzen. Anleiten dazu findest du auf der gleichen Seite bei MakeCode.
Ein Projekt erstellen
Wenn wir ein neues Programm schreiben möchten, wird dies als ein „Projekt“ bezeichnet. Wir legen also ein neues Projekt an, indem wir auf „Neues Projekt“ klicken.
Wir geben diesem Projekt einen Namen. In diesem Beispiel nennen wir es einfach nur „Calle“ und klicken danach auf „Erstelle“.
Da der Calle-Roboter für den Calliope Mini V3 erstellt wurde, wählen wir hier den entsprechenden Mikrocontroller aus. Also „Calliope Mini V3“.
Der Ausgewählte Controller wird im linken Bereich angezeigt. Daneben ist eine Übersicht der möglichen Programmbefehle, die in Form von bunten Programmblöcken dargestellt wird.
Im großen mittleren Bereich befinden sich bereits die Blöcke „beim Start“ und „dauerhaft“. Diese Blöcke sind standardmäßig vorhanden.
Praxisaufgaben
In den folgenden Praxisaufgaben werden wie einzelnen Module des Calle Roboters der Reihe nach programmiert.
Frontscheinwerfer aktivieren / LED aktivieren
Die erste Aufgabe besteht darin, die beiden kleinen Scheinwerfer von Calle einzuschalten. Es handelt sich um zwei LEDs, die beide an den Pin C12 des Calliope angeschlossen.
Wir verwenden für das Aktivieren der LEDs den Befehl „schreibe digitalen Wert von Pin C12 auf 1“
Was bedeutet der Befehl?
„Schreiben“ heißt in der Informatik etwas ähnliches wie eine Statusveränderung. In unserem Fall soll sich der Status vom Kontakt C12 verändern. Ohne eine Programmierung hat der Kontakt C12 den Status „0“ und das bedeutet das dort „Null“ also „Nichts“ passiert. Der Kontakt C12 hat keine elektrische Spannung und daher leuchten die LEDs nicht. Mit dem Programmblock „schreibe digitalen Wert von Pin C12 auf 1“ verändern wir den Status vom Kontakt C12 von „Null“ auf „Eins“. In diesem Fall kann man das als „Einschalten“ verstehen. Eins bedeutet hier, dass eine Spannung ausgegeben wird. Beim Calliope sind das an den digitalen Kontakten 3,3V.
A) LEDs aktivieren
B) LEDs deaktivieren
C) LEDs blinken lassen
D) LEDs bei Knopfdruck blinken lassen
Das machen wir, indem wir mit Knopf A die LEDs einschalten und mit Knopf B ausschalten können. Also gehen wir jetzt zu „Fortgeschritten“ → „Pins“.
In der Digital-Sektion wählen wir „Schreibe digitalen Wert von Pin P0 auf 0“ und setzen diesen auf C12.
Das duplizieren wir und setzen bei Knopf A auf 1 und bei B auf 0. Das bedeutet, dass wenn C12 auf 1 gesetzt wird, die LED angeht, und wenn dieser auf 0 gesetzt wird, wird sie ausgehen.
Nun klicken wir auf „Herunterladen“.
Jetzt stecken wir das Kabel, das mit dem Calliope geliefert wird, an den Calliope und unseren Computer an und klicken auf „Weiter“.
Jetzt auf Koppeln klicken!
Nun erhalten wir ein Popup, in dem wir den Calliope auswählen. Jetzt sind wir verbunden.
Hinweis:
Wenn das nicht geklappt hat, ist es ziemlich wahrscheinlich ein Browserproblem. Browser wie Safari, Firefox und Internet Explorer unterstützen WebUSB nicht. WebUSB ist eine Funktion, die den Calliope mit dem Browser kommunizieren lässt.
Browser wie Chrome, Edge und Opera unterstützen WebUSB und damit sollte es funktionieren.
Jetzt können wir auf „Herunterladen“ klicken.
Dadurch können wir, wenn wir Knopf A klicken, die LED einschalten, und wenn wir Knopf B drücken, diese ausschalten.
Linienverfolger
Grundlegend ist das Prinzip der Linienverfolgung einfach erklärt. Wir möchten erzielen, dass der linke Motor von Calle immer dann betätigt wird, wenn Calle nach links von der Linie ab kommt.
Denn wenn sich der linke Motor alleine oder stärker dreht als der rechte Motor, dann fährt der Roboter eine Rechtskurve.
Wenn der Roboter aber rechts von der Linie ab kommt, dann soll sich der rechte Motor alleine oder stärker drehen als der linke Motor.
Um die Bewegungen der beiden Motoren korrekt zu steuern, ist es natürlich wichtig, dass der Roboter durchgehend die Linie erkennt. Daher werden wir nun zunächst die Liniensensoren programmieren und deren Sensorwerte auslesen.
Sensorwerte lesen
Die Liniensensoren geben je nachdem, ob sie eine dunkle Linie oder einen hellen Untergrund erkennen eine Spannung aus, oder eben nicht. Diese Spannung wird vom Calliope erkannt, wenn man einen Programmcode verwendet, der dafür vorgesehen ist, Spannungen an den Kontakten zu erkennen.
Wenn der Calliope vom Abstandssensor das digitale Signal „1“ erfasst, entspricht das einem weißen Untergrund.
Wenn der Calliope vom Abstandssensor das digitale Signal „0“ erfasst, entspricht das einem dunklen Untergrund, in unserem Fall also eine schwarze Linie.
Arbeiten mit Variablen
Mit dem folgenden Code können wir die Sensorwerte auslesen und prüfen. Die Sensorwerte brauchen in der Programmierung einen Speicherplatz, in dem wir den Messwert des Sensors ablegen bzw. speichern können. Dieser Speicherplatz wird „Variable“ genannt und hat eine genaue Bezeichnung. Diese Bezeichnung kann ein Buchstabe oder ein ganzes Wort sein.
Um eine Variable zu erstellen, gehen wir zunächst auf Variablen → Erstelle eine Variable
Wir geben dieser Variable einen Namen. In diesen Fall vergeben wir der Variable den Namen „LinienVerfolgerLinks“.
Im Programmier-Menü erscheinen jetzt drei neue Blöcke mit den Namen „setze LinienVerfolgerLinks“, „ändere LinienVerfolgerLinks“ und „LinienVerfolgerLinks“.
Wir verwenden jetzt „setze LinienVerfolgerLinks auf 0“, und ziehen ihn in den Block mit dem Namen „dauerhaft“. Der blaue Block mit dem Namen „dauerhaft“ ist das Grundgerüst für die Programmierung. Dieser Block wird später beim abspielen des Programms dauerhaft wiederholt.
Um den Status des linken Liniensensors in der Variable zu speichern, klicken wir auf die Unterkategorie Fortgeschritten → Digital → “digitale Werte von Pin P0” , und ziehen diesen Programmblock in das Feld an die Stelle, an der zuvor die „0“ war. Das sieht dann so aus:
Jetzt wird der Kontakt, der abgefragt wird, von P0 auf C15 verändert, da der linke Sensor mit dem Kontakt C15 verbunden ist.
Der Codeblock bedeutet dann übersetzt:
„Hey Calliope, schau mal nach, ob am Kontakt P0 eine Spannung ankommt oder nicht“.
Wenn eine Spannung dort ankommt, dann speichere unter der Variablen „LinienVerfolgerLinks“ den Wert 1. Wenn keine Spannung an Kontakt P0 ankommt, dann speichere unter der Variablen „LinienVerfolgerLinks“ den Wert 0.“
Kommunikation mit Calliope
Leider kann der Calliope nicht mit uns sprechen, um uns zu sagen, welchen Status der Sensor denn nun hat. Aber es gibt einen Weg, das herauszufinden. Der Calliope kann, während ein Programm verarbeitet wird, Textnachrichten versenden.
Der passende Programmbock dafür heißt „zeige Text“.
Um den Status des Sensors auszugeben, klicken wir auf den Programmblock „zeige Text „hi““, und ziehen uns den Block in das Programmierfeld.
Im letzten Schritt tauschen wir den vorgegebenen Text „hi“ gegen die Variable des Sensors aus. Also die Variable, unter der zuvor der Wert des Sensors abgespeichert wurde.
Motoren in Abhängigkeit der Sensoren steuern
Es gibt verschiedene Wege, einen Linienverfolger zu bauen. Auch die anzahle der verwendeten Sensoren spielt dabei eine Rolle. Calle verfügt über zwei Sensoren.
Je mehr Sensoren ein Roboter hat und programmiert sind, desto besser und schneller kann er einer Linie folgen. Denn, wenn beide Sensoren ein dunkles Signal erkennen, weiß man, dass sich der Roboter mitten auf der schwarzen Linie befindet und man kann „Vollgas“ geben.
Man unterscheidet in der Programmierung also vier Möglichkeiten:
A) linker Sensor erkennt „hell“, rechter Sensor erkennt „dunkel“
B) linker Sensor erkennt „dunkel“, rechter Sensor erkennt „hell“
C) linker Sensor erkennt „dunkel“, rechter Sensor erkennt „dunkel“
D) linker Sensor erkennt „hell“, rechter Sensor erkennt „hell“
Man erkennt, dass alleine die verschiedenen Voraussetzungen die Programmierung ein wenig schwierig machen. Daher entscheiden wir uns in dieser Anleitung dafür, dass wir zunächst nur mit einem Sensor arbeiten. Wir verwenden von nun an nur den rechten Line-Tracking-Sensor.
Man unterscheidet in der Programmierung nun nur noch zwei Möglichkeiten:
A) rechter Sensor erkennt „hell“
B) rechter Sensor erkennt „dunkel“
Die Abhängigkeit für die Ansteuerung der Motoren ist nun einfach erklärt:
A) Wenn der Sensor „dunkel“ erkennt, soll nur das rechte Rad vorwärts fahrenden
B) Wenn der Sensor „hell“ erkennt, soll nur das linke Rad vorwärts fahrenden
Der Roboter wird mit einem entsprechenden Programm auf einem permanenten „Zick-Zack“-Kurs fahren und verfolgt dabei die vorgegebene schwarze Linie.
Nun verwenden wir erneut zu Variablen, um die Werte von den Line-Tracking-Sensoren zu speichern.
Dazu gehen wir wieder auf die Blockauswahl, gehen unter „Variablen“ und erstellen eine Variable namens „LinienVerfolgerLinks“ und eine Variable namens „LinienVerfolgerRechts“.
Nun haben wir unter Variablen etwas mehr Auswahl, und zwar haben wir die Option, eine Variable zu setzen und zu lesen.
Nun nehmen wir zweimal „Setze LinienVerfolgerRechts“ und setzen einen davon auf „LinienVerfolgerLinks“.
Gehen wir jetzt wieder unter „Pins“ und nehmen zweimal „Digitale Werte von Pin P0“ und setzen einen auf C15 und den anderen auf C14. Den mit C15 packen wir auf „Setze LinienVerfolgerRechts“ und den mit C14 auf „Setze LinienVerfolgerLinks“.
Nachdem wir dies getan haben, sollte es so aussehen:
Unter „Logik“ nehmen wir uns „Wenn wahr, dann“ und „Ansonsten“.
Und klicken auf das Plus-Symbol unten am Block zweimal.
Was, uns diesen Block erschafft.
Jetzt gehen wir wieder unter „Logik“ und nehmen uns unter „Vergleich“ „0 = 0“ 4x und zweimal „Und“.
Nun gehen wir wieder unter „Variablen“ und nehmen uns „LinienVerfolgerLinks“ und „LinienVerfolgerRechts“.
Dann sollte dies so aussehen.
Hier überprüfen wir im ersten Fall, ob beide Sensoren eine Linie sehen. Im zweiten Fall prüfen wir, ob rechts eine Linie ist, und falls das auch nicht der Fall ist, schauen wir, ob links eine Linie ist. Falls das immer noch nicht der Fall ist, tritt der letzte Fall ein. Dieser tritt nur ein, wenn beide Sensoren die Linie verloren haben.
Wichtig dabei zu merken ist, dass wenn der Sensor eine Linie sieht, gibt er 1 aus, und 0 wenn keine da ist. Dies ist darauf bezogen, dass je nach Kalibrierung des Sensors, dieser ein Signal ausgeben wird, wenn die maximale Distanz überschritten wird.Nun nehmen wir uns nur als Beispiel unter „Grundlagen“ das Block „Zeige Symbol“ heraus und passen es unseren Fahrtrichtungen in diesen Fällen an.
Und hier findet man die Motoren.
Nun sollte es so aussehen, nachdem die Richtungen angepasst wurden. Der Grund, warum die Pfeile in eine andere Richtung zeigen als sie in Wirklichkeit sind, liegt darin, dass der Calliope anders montiert ist und man von der hinteren Pinleiste aus schauen muss, da dies bei demn Calliope vorne ist.
Zusätzlich ist die Motorensteuerung bereits integriert. Dabei ist der rechte Motor M0 und der linke M1. Man kann sich das recht leicht merken, da die 1 bei M1 ähnlich zu einem kleinen „L“ ist.
Wenn wir diesen Code hochladen, sollte es funktionieren. Was jedoch sein könnte, ist, dass die vorderen Sensoren nicht richtig kalibriert sind. Hierfür gibt es an den Sensoren eine blaue Box, die es erlaubt, den Sensor mit einem Schraubendreher anzupassen. Dazu stellen wir diesen auf eine dunkle Oberfläche, z.B. die Linie, und kalibrieren die Sensoren, wenn diese über der Linie sind. Wenn die LED ausgeht, ist er richtig kalibriert. Dieser sollte jedoch zwischen der Schwelle von an und aus bleiben.
Entfernung messen / Objekte erkennen
Calle hat an der Vorderseite einen Sensor mit zwei Zylindern. Das Modul sieht aus, als waren es die Augen von Calle. Es handelt sich jedoch um einen Ultraschallsensor. Wie funktioniert der Ultraschallsensor?
Der Ultraschallsensor zählt in der Mikroelektronik zu den bekanntesten Bauteilen. Mit Hilfe von Ultraschallsensoren können wir damit den Abstand von Objekten sehr genau messen. Du bist in deinem Alltag bestimmt auch schon Ultraschallsensoren begegnet: Die kleinen Sensoren werden zum Beispiel in Autos verbaut. Dort unterstützen Sie uns beim Einparken und warnen uns, wenn wir zu dicht an ein Hindernis (zum Beispiel an eine Wand) heranfahren.
Ultraschallsensoren kommen auch in der Natur vor. Und zwar bei der die Nahrungssuche einer Fledermaus. Eine Fledermaus sendet Ultraschallwellen, um herauszufinden, wie weit ein Objekt entfernt ist. Diese Ultraschallwellen werden von Objekten reflektiert und landen wie bei einem Echo wieder bei den Ohren der Fledermaus. Die Fledermaus erkennt anhand der Wartezeit, bis das Echo erscheint, wie weit Objekte von ihr entfernt sind.
Der Ultraschallsensor arbeitet dabei ähnlich. Sobald die Ultraschallwellen zum Modul zurückgekommen sind, sendet der Ultraschallsensor ein Spannungssignal an den Calliope. Aus der Zeit, in der die Ultraschallwelle unterwegs war, kann der Calliope die Entfernung zum Objekt
berechnen.
In der Programmieroberfläche müssen wir den Sensor erst hinzufügen. Denn externe Module sind nicht grundsätzlich in den Programmblöcken für den Calliope enthalten. Dazu klicken wir zunächst auf „Erweiterungen“.
Dort erscheint dann die folgende Seite, auf der Erweiterungsmodule und die passenden Programmblöcke zu finden sind.
Ganz oben befindet sich eine Suchleiste, in der man das zu programmierende Modul finden kann. Für den Sensor, den Calle verwendet, geben wir folgenden Text ein:
https://github.com/Funduino-GmbH/RCW0001/
Es handelt sich hierbei um den direkten Link zu den Programmblöcken des verwendeten Sensors.
Wenn wir Enter drücken, sehen wir, dass eine Karte aufgetaucht ist mit der Überschrift “RCW-0001”. Wenn wir nun auf diese Karte klicken, werden alle dazu passenden Programmblöcke installiert. Diese Sammlung von Programmblöcken wird auch „Bibliothek“, „Library“ oder „Programmbibliothek“ genannt.
Jetzt sehen wir, dass in den Kategorien eine neue Rubrik aufgetaucht ist.
In dieser Kategorie ist nur ein Block. Der Block hat den Namen “Ultraschallsensor (in cm) trigger auf C8 und echo auf C9”.
Mit diesem Block können wir die Distanz von Calles Ultraschallsensor zu einem davor befindlichen Gegenstand abrufen. Um dies zu tun, ziehen wir diesen Block in das mittige weiße Feld, fügen es jedoch noch nirgendwo ein.
Um die gemessene Distanz ausgeben zu können, klicken wir in Grundlagen auf „zeige Zahl 0“ und ziehen diesen Block in den blauen Programmblock „dauerhaft“.
Als letztes ziehen wir den Ultraschallsensor-Block in das Zahlenfeld des „zeige Zahl 0“ Blocks und tauschen damit die „0“ gegen den Messwert des Ultraschallsensors.
Serielle Kommunikation
Dies klappt zunächst hervorragend. Es gibt jedoch auch einen Nachteil. Es dauert immer eine ganze Weile, bis die Zahl für einige Zeit auf den LEDs des Calliope angezeigt wurde. Erst danach wird das Programm weiterhin ausgeführt.
Wenn es in einem Programm darum geht, Daten sehr schnell zu verarbeiten, sind die Programmblöcke „zeige Zahl“ und „zeige Text“ nicht gut geeignet.
Falls trotzdem etwas ausgegeben werden soll, kann man auf die serielle Kommunikation zurückgreifen. Diese finden wir unter Fortgeschritten → Seriell. Hier verwenden wir den Block “seriell umleiten auf USB”.
Die erfassten Messwerte wollen wir nun weiterverwenden. Daher erstellen wir eine Variable mit dem Namen „Distanz“.
Abhängigkeiten programmieren
Wir werden nun in Abhängigkeit von der gemessenen Entfernung einen Ton abspielen. Eine solche Abhängigkeit wird in der Informatik auch „If-Abfrage“ oder „Wenn-Dann Funktion“ genannt.
Dazu nehmen wir uns von der Kategorie Logik den Programmblock „wenn wahr dann“.
Zusätzlich benötigen wir aus den Programmblöcken im Logik-Bereich den „Größer als“-Vergleich.
Um dies ein wenig zu erweitern, können wir Calle vorwärts fahren lassen, wenn die Distanz über 30 ist. Er soll stoppen, wenn die Distanz kleiner als 30 ist. Dazu klicken wir auf das + in dem dunkelgrünen Programmbock der Abfrage.
Hier erkennt man, dass der dunkelgrüne Programmbock im unteren Bereich erweitert wurde.
Für die Erweiterung mit dem Fahrmodus nehmen wir uns unter Motoren den Programmblock „Motor“ heraus und stellen diesen von M0 auf M0 & M1.
Wenn der Messwert des Distanzsensors unter 30 gerät, stellen wir den Wert für den Motor auf 0. Ansonsten auf 50 %, damit er nicht zu schnell fährt.
Das vollständige Programm sieht dann folgendermaßen aus.
NeoPixel ansteuern / Lichteffekte erzeugen
Calle hat sechs besondere Lichtquellen. Es sind intelligente LEDs mit der Bezeichnung WS2812. Diese werden gelegentlich auch als Neopixel bezeichnet. Die Besonderheit der WS2812B LEDs
besteht darin, dass sie in tausenden Farben leuchten können. Das beste daran ist jedoch, dass sich mehrere hundert dieser LEDs eine einzige Datenleitung teilen können.
Bei Calle werden zwei Kontakte vom Calliope verwendet. Der Kontakt P2 steuert die drei LEDs auf der rechten Seite an und der Kontakt P3 steuert die LEDs auf der linken Seite an.
In dieser Anleitung möchten wir die Leuchtdioden in verschiedenen Farben leuchten lassen.
Um die NeoPixel-Funktionalität zu erreichen, klicken wir auf „Erweiterungen“ und suchen nach „NeoPixel“.
Dort lässt sich folgende Programmbibliothek finden.
Wir erhalten eine neue Kategorie mit dem Namen „NeoPixel“.
In der Kategorie NeoPixel klicken wir auf den Programmblock „Setze strip auf NeoPixels an Pin P0 mit 24 Pixeln im Modus RGB (GRB-Format)“.
Wir setzen den Pin auf P2, da auf dem Calle die Neopixel auf der rechten Seite alle an den Kontakt P2 angeschlossen sind. Für die LEDs auf der linken Seite müssen wir eine neue Variable erstellen. Wie das funktioniert, haben wir in früheren Aufgaben gelernt. Die weitere Variable für die Linke LED-Seite nennen wir „strip2“.
In der Kategorie Neopixel klicken wir erneut auf „setze strip…“ und erzeugen damit einen weiteren Programmblock für die LEDs auf der linken Seite, die an Kontakt P3 angeschlossen sind.
Der gesamte Block sieht dann folgendermaßen aus.
Danach legen wir die Farbe fest, mit der die LEDs leuchten sollen. Wir nehmen uns aus der Neopixel-Kategorie den Block „zeige Farbe“ heraus und wählen die Farbe Rot.
Wir setzen die Farben von den linken LEDs auf Rot und von den rechten auf Orange.
Damit die LEDs nicht die ganze Zeit über nur die Selbe Farbe haben, aufgrund dessen, das die Farbe zu schnell geändert wird, fügen wir eine pause hinzu. Diese finden wir unter der Kategorie Grundlagen→pausiere (ms) 1000.
Um nun die LEDS einzeln anzusteuern, klicken wir auf NeoPixel → mehr, und nehmen uns „strip setze Farbe von NeoPixel 0 auf rot“.
Nun haben wir im diesem Beispiel die vordere Farbe auf Blau, die mittleren auf grün und die hinteren auf rot gesetzt.
Hier ist die Nummerierung der Pixel in einer Top-down Ansicht. Die NeoPixel sind rot markiert. Die Dioden Links, und rechts starten jeweils mit der Nummer 0 ganz oben und enden hinten mit der 2 ganz unten. Alle Pixel auf der linken Seite werden vom Calliope mit dem Pin P3 angesteuert. Alle Pixel auf der rechten Seite werden über den Pin P2 angesteuert.
Dieser Artikel wird im Moment überarbeitet. 15.08.2024 08.50Uhr
