Löten und basteln
Programierung
Bonus: Mit zusätzlichen Batterien mehr Power für die Motoren

Published October 19, 2017 © CC BY-NC

Calliope Mini - Ferngesteuertes Auto

In diesem Beispiel wird mithilfe von 2 Calliope und 2 Motoren ein ferngesteuertes Auto gebaut

IntermediateFull instructions provided5 hours13,907

Things used in this project

Hardware components

Calliope mini

Autofahrgestell mit Motoren

Software apps and online services

pxt.calliope.cc

Hand tools and fabrication machines

Soldering iron (generic)

Story

Der Calliope Mini verfügt über zwei spannende Funktionen und Hardwarebauteile, die es ermöglichen ein ferngesteuertes Auto zu bauen. Auf der einen Seite ist es das Funkmodul und auf der anderen Seite der Motortreiber, mit dem zwei Motoren mit bis zu 9V gesteuert werden können.

Für das ferngesteuerte Calliope-Auto muss sowohl eine Software entwickelt, als auch die Bauteile für das Auto gelötet und zusammengebaut werden. Wir beginnen hier mit dem Hardware-Teil der Beschreibung. Du kannst aber auch zuerst die Software entwickeln und zumindest die Fernbedienung testen.

Löten und basteln:

Als erstes muss der Calliope, der auf dem Auto ist und die Motoren ansteuert, vorbereitet werden. Dafür löten wir eine Buchsenleiste mit fünf Anschlüssen auf den Calliope. Du könntest stattdessen auch die Kabel direkt auf den Calliope löten. Die Variante mit der Buchsenleiste ist aber eleganter, da du so die Motoren später auch wieder abstecken kannst, wenn du sie nicht mehr an deinem Calliope benutzen willst, oder etwas anderes anbauen möchtest.

Danach werden Kabel an die Motoren angelötet, falls sie noch keine haben, oder zu kurz sind. Überlege die vorher schon grob, wo später in deinem Auto der Calliope sitzen wird, und wo die Motoren, damit die Kabel auch lang genug sind. Am anderen Ende der Kabel werden Steckerleisten angelötet. Du kannst auch statt für jeden Motor eine Leiste mit 2 Pins, auch eine größere mit 5 Pins (Motoren + Batterie) nutzen.

Die Anschlüsse der Steckerleiste am Calliope sind von links nach rechts: GND, Motor B, Motor A, GND, V_in. Du musst also deine Motoren so an die Steckerleiste löten, dass der eine Motor an Pin 1 und Pin 2 ist, der andere an Pin 3 und 4. Der Anschluss ganz rechts kann erstmal frei bleiben. Hier kann später die zusätzliche Batterie angeschlossen werden.

Jetzt kannst du dein Auto zusammenbauen. Falls du kein fertiges Chassis hast, reicht auch eine einfache Holzplatte. Wir haben ein 10 cm x 13 cm großes Stück aus einer Sperrholzplatte ausgesägt und verwendet. Die Motoren kannst du einfach mit Heißkleber an der Platte befestigen.

Den Calliope kannst du notfalls auch mit etwas Heißkleber befestigen. Achte aber darauf, nur so wenig Kleber wie möglich zu benutzen und nur an den Spitzen des Controllers. So bekommst du ihn möglichst unbeschadet später wieder vom Holzbrett gelöst. Besser ist es, ein paar Löcher in die Holzplatte zu bohren und den Calliope mit Schrauben und Muttern zu befestigen. Schrauben mit 4mm Durchmesser passen perfekt durch die Spitzen am Calliope.

Nun brauchst du noch ein drittes Rad. Wir haben dafür eine Möbelrolle benutzt. Die sind super, da sie sich problemlos in alle Richtungen bewegen und gleichzeitig wenig Widerstand beim Fahren bilden. Notfalls kannst du aber auch einen Tischtennisball benutzen, falls du nur auf Glatten Oberflächen wie Parkett oder einer Tischplatte fahren möchtest.

Nun solltest du deine Motoren testen. Schreibe dafür ein einfaches Programm. Beispielsweise unendlich oft die Motoren nacheinander für je eine Sekunde einschalten und dann beide wieder für eine Sekunde aus. Drehen sich beide Motoren so, dass das Auto nach vorne fährt?

Falls nicht, musst du die Motoren umpolen. Vertausche dabei einfach die Pins an der Steckerleiste in dem du sie kurz rausziehst und an der benachbarten Stelle wieder einsteckst. Also für Motor B die Pins 1 und 2 vertauschen und für Motor A die Pins 3 und 4 vertauschen.

Falls es schon funktioniert, können wir nun an die Programmierung gehen.

Programierung:

Fernbedienung:

Der Calliope, der als Fernbedienung dient, wandelt den Wert des Bewegungssensors in Zahlen zur Geschwindigkeit der Motoren um. Die X-Achse bestimmt die Lenkung links und recht, die Y-Achse die Geschwindigkeit. So kann der Calliope einfach nach vorne gekippt werden, um das Auto zu beschleunigen und nach hinten, um abzubremsen. Nach links, bzw. rechts kippen, lenkt das Auto entsprechend.

Wir speichern also als erstes die Werte des Lagesensors in eine Variable. Das können wir gleich in eine "dauerhaft"-Schleife packen. Die X-Achse betimmt später die Richtung des Autos, die Y-Achse die Geschwindigkeit. Hierbei ist der Block "Verteile ... von niedrig ... von hoch ... bis niedrig ... bis hoch ..." sehr hilfreich. So wird der große Wertebereich des Sensors gleich auf einen gewünschten Zahlenbereich umgerechnet. Der Sensor gibt jeweils Werte von -1023 bis 1023 aus. Für die Richtung wollen wir Werte von -50 bis 50 und für die Geschwindigkeit von 0 bis 100. Denn die Motorgeschwindigkeiten werden später in Prozent angegeben.

Um das ganze erst einmal mit einem Calliope zu testen, zeigen wir uns die Werte mit einem Trick auf dem Display an. Ein LED-Punkt zeigt uns die Richtung an, in dem er nach links und rechts, beziehungsweise die Geschwindigkeit, indem er nach vorne/oben (schnell) und hinten/unten (langsam) wandert. Hierbei hilft wieder der "Verteile"-Block. Wir verteilen die Werte der Richtung (-50 bis 50) auf eine X-Koordinate der LED-Matrix (0 bis 5) und die Werte der Geschwindigkeit (0 bis 100) auf die Y-Koordinate der LED-Matrix (5 bis 0). Achtung! Für die Y-Koordinate müssen wir von 5 bis 0 zählen! Da bei den LEDs der Punkt 0/0 linksoben ist, nicht wie gewohnt linksunten. Sonst steht deine Anzeige auf dem Kopf.

Nun schalten wir zu Beginn der Schleife die LED aus, und nach unseren Berechnungen die neue LED ein. Jetzt kannst du bereits testen, ob der LED-Punkt durch kippen des Calliopes über das Display wandert!

Damit die Fernbedienung fertig ist, müssen unsere beiden Werte der Richtung und der Geschwindigkeit noch per Funk gesendet werden. Denke außerdem daran, beim Programmstart eine Gruppe für den Funk zu setzen. Auch die Übertragungsstärke kannst du auf "7" setzen. Dann ist die Reichweite etwas höher. Das fertige Programm sieht dann etwa so aus:

Auto:

Das Programm auf dem Auto empfängt nur die Daten und steuert entsprechend die Motoren mit unterschiedlichen Geschwindigkeiten.

Als erste müssen wir natürlich erst einmal die empfangenen Daten speichern. Verwende für "richtung" und "geschwindigkeit" unterschiedliche Variablen. Außerdem musst du auch hier die passende Gruppe einstellen.

Damit du siehst, ob die Übertragung ordentlich funktioniert, solltest du auch hier einen LED-Punkt einschalten, der über das Display wandert, genauso wie bei der Fernbedienung.

Wenn das funktioniert, kannst du nun auch die Motoren ansteuern. Berechne die Geschwindigkeiten der einzelnen Motoren wie folgt:

Linker Motor = "geschwindigkeit" + "richtung"

Rechter Motor = "geschwindigkeit" - "richtung".

Achtung, im Moment kann es noch passieren, dass die Geschwindigkeit eines Motors größer als 100 werden kann. Überprüfe dies, und setze sie gegebenenfalls einfach auf 100. Außerdem kann sie auch kleiner als 0 werden. Überprüfe auch das, und setze sie gegebenenfalls auf 0.

Dieses Problem entsteht beispielsweise wenn du den Fernsteuerungs-Calliope ganz nach rechts vorne kippst. Dann ist der Wert für die Richtung 50 und für die Geschwindigkeit 100. Für den linken Motor würde sich ein Wert von 150 ergeben. Das müssen wir korrigieren, da ein Motor höchstens mit 100% drehen kann.

Wenn du das alles hast, sieht dein Programm etwa so aus:

Bonus: Mit zusätzlichen Batterien mehr Power für die Motoren

Dein Calliope-Auto sollte inzwischen fahren und auch mit der Fernsteuerung gesteuert werden. Allerdings fahren die Motoren nur mit den 3V, die die beiden Batterien am Calliope haben. Du kannst eine zusätzlcihe Batterie anschließen um die Spannung zu erhöhen und so das Auto schneller fahren zu lassen.

An der Steckerleiste ist noch ein Pin (V_in) frei. Dort musst du den Pluspol deiner zusätzlichen Batterie (max. 9V, also maximal sechs AA-Batterien) anlöten. Den Minupol schließt du an GND an. Also direkt an einen der beiden GND-Pins an denen deine Motoren angeschlossen sind, oder am Minuspol deines Calliope (Die Spitze mit dem "-").

So sieht das Auto dann in Aktion aus:

Code

let motor_rechts = 0
let motor_links = 0
let led_y_wert = 0
let led_x_wert = 0
let geschwindigkeit = 0
let richtung = 0
radio.onDataPacketReceived(({receivedString: signal, receivedNumber: wert}) => {
    if (signal == "richtung") {
        richtung = wert
    } else {
        geschwindigkeit = wert
    }
})
basic.forever(() => {
    led.unplot(led_x_wert, led_y_wert)
    led_x_wert = pins.map(
        richtung,
        -50,
        50,
        0,
        5
    )
    led_y_wert = pins.map(
        geschwindigkeit,
        0,
        100,
        5,
        0
    )
    led.plot(led_x_wert, led_y_wert)
    motor_links = geschwindigkeit + richtung
    motor_rechts = geschwindigkeit - richtung
    if (motor_links > 100) {
        motor_links = 100
    }
    if (motor_links < 0) {
        motor_links = 0
    }
    if (motor_rechts > 100) {
        motor_rechts = 100
    }
    if (motor_rechts < 0) {
        motor_rechts = 0
    }
    motors.dualMotorPower(Motor.A, motor_links)
    motors.dualMotorPower(Motor.B, motor_rechts)
})
radio.setGroup(1)
radio.setTransmitPower(7)

let geschwindigkeit = 0
let y_achse = 0
let richtung = 0
let x_achse = 0
let led_y_wert = 0
let led_x_wert = 0
basic.forever(() => {
    led.unplot(led_x_wert, led_y_wert)
    x_achse = pins.map(
        input.acceleration(Dimension.X),
        -1023,
        1023,
        -50,
        50
    )
    richtung = x_achse
    y_achse = pins.map(
        input.acceleration(Dimension.Y),
        1023,
        -1023,
        0,
        100
    )
    geschwindigkeit = y_achse
    led_x_wert = pins.map(
        richtung,
        -50,
        50,
        0,
        5
    )
    led_y_wert = pins.map(
        geschwindigkeit,
        0,
        100,
        5,
        0
    )
    led.plot(led_x_wert, led_y_wert)
    radio.sendValue("geschwindigkeit", geschwindigkeit)
    radio.sendValue("richtung", richtung)
})
radio.setGroup(1)
radio.setTransmitPower(7)

Credits

Mario Pesch

0 projects • 4 followers

Junge Tueftler

2 projects • 9 followers

Junge Tüftler offers children a playful access to electronics and programming and provides them with the right tools to create the world of tomorrow.

Calliope Mini - Ferngesteuertes Auto