Artikel | Reviews

Meccano Meccanoid G15


Open Source Programmierung mit Arduino

Der Meccanoid wurde in erster Linie für die Unterhaltung von Kindern konzipiert. Durch seine flexible Bauweise mit vielen Erweiterungsmöglichkeiten eignet sich der Roboter-Bausatz auch für die Open-Source-Programmierung. Der Hersteller stellt hierfür auf seiner Webseite die Protokolle für die Smart-Module sowie eine passende Arduino-Bibliothek zur Verfügung. Für die Open-Source-Programmierung benötigt man außerdem einen Mikrocontroller wie den Arduino UNO, einen Motortreiber oder ein Servo/Motor/Stepper-Shield sowie ein Steckbrett und verschiedene Kleinteile (Kabel und Bauelemente) zum verschalten. An dieser Stelle können wir das Franzis Arduino Maker Kit empfehlen, dass einen originalen Arduino UNO, zwei Steckbretter und verschiedene Kleinteile wie Widerstände, Dioden und Kabel enthält. Für die Ansteuerung der Servos reicht es aus, diese direkt mit dem Arduino zu verbinden. Dabei ist darauf zu achten, die Schaltung wie im Meccanoid-Protokoll mit Widerständen zu versehen.

Sollte es zu einem Spannungsabfall am Arduino-Board kommen, kann zusätzlich ein Kondensator von etwa 100-120 µF parallel dazugeschaltet werden, wobei diese Lösung unbedingt optimal ist. Denn direkt über das Arduino-Board können nur sehr kleine Servos mit einer geringen Stromaufnahme mit Spannung versorgt werden. Abhilfe schafft hier eine externe Spannungsversorgung, die im Vergleich zum Betrieb über ein USB-Kabel deutlich mehr Leistung liefert. Oder aber man nimmt lediglich die Servos mit einer externen Spannungsquelle in Betrieb, während der Arduino weiterhin am USB-Port hängt. Dabei sollte darauf geachtet werden, den Servos nur so viel Spannung zur Verfügung zu stellen, wie sie vertragen. Üblich sind hier etwa 5 bis 6V. Außerdem muss gewährleistet sein, dass trotz getrennter Spannungsversorgung der GND-Pin vom Arduino-Board mit dem Massepunkt der externen Spannungsversorgung verbunden ist. Der Grund ist der Steuersignalstrom vom Arduino zum Servo, der wieder zum Arduino zurück muss. Untenstehender Schaltplan zeigt die korrekte Verschaltung.

Eine weitere Methode ist das Verwenden eines Motortreibers. Diese ICs werden überwiegend für die Ansteuerung von DC-Motoren verwendet. Dabei wird durch den Stromfluss die Drehrichtung des Motors beeinflusst. DC-Motoren können somit in beide Richtungen drehen. Soll ein Motor lediglich in eine Richtung drehen, reicht in den meisten Fällen auch ein einfacher Transistor. Unser Meccanoid verwendet jedoch Servos, für die zwar kein Motortreiber benötigt wird, aber dennoch sinnvoll sein kann. Zum einen lassen sich damit mehrere Servos gleichzeitig ansteuern und zum anderen können wir diese durch eine externe Spannungsquelle betreiben. Gängiges Modell ist der L293D (siehe Datenblatt), der zwei Motoren unabhängig voneinander steuern kann. Dabei handelt es sich um einen IC im DIL16 Gehäuse. Wer die Richtung des Motors nur über einen einzigen Pin steuern möchte, der kann auch auf ein Servo-Shield zurückgreifen, da diese Platinen bereits logische Elemente dafür verbaut haben. Am Ende bleibt es einem selbst überlassen, für welche Methode man sich entscheidet.

Nachdem der technische Teil abgeschlossen ist, kann die Arduino-Bibliothek für den Meccanoid heruntergeladen werden. Denn die Servos können nicht über die Standard-Servo-Bibliothek angesteuert werden. Wer folgendes Programm verwendet, wird von den Servomotoren keine Rückmeldung erhalten:

#include <Servo.h>

Servo meinServo;  
int pos = 0;   

void setup() {
  myservo.attach(5);  
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) {  
    meinServo.write(pos);             
    delay(25);                  
  }
  for (pos = 180; pos >= 0; pos -= 1) { 
    meinServo.write(pos);             
    delay(25);                       
  }
}

Der Programmcode bewegt einen Servomotor von 0 – 180 Grad und wieder zurück. Wie dem Smart Module Protokoll des Meccanoid zu entnehmen ist, sind die Servos "Daisy-Chain"-fähig. Das bedeutet, dass mehrerer Servos an einer Datenleitung in Form einer Kette geschaltet werden können. Der Ausgang eines Servos wird mit dem Eingang des nächsten Servos verbunden, was beim Meccanoid der Fall ist. Hier wird demnach nicht mit Kommandos, sondern mit Datenpaketen gearbeitet. Durch die Verwendung der Arduino-Bibliothek vom Hersteller Meccano sieht unser Programmcode jetzt wie folgt aus:

#include <MeccaBrain.h>

// Pins 5 und 6 für die Servos des rechten und linken Arms
const int chainPin1 = 5;
const int chainPin3 = 6;

MeccaBrain chain1(chainPin1); 
MeccaBrain chain3(chainPin3);

const byte LEFT_ARM_ROLL=0;
const byte LEFT_ARM_PITCH=1;
const byte LEFT_ARM_ELBOW=2;

const byte RIGHT_ARM_ROLL=5;
const byte RIGHT_ARM_PITCH=6;
const byte RIGHT_ARM_ELBOW=7;

//pos is 0...255
void setJoint(byte jointName, byte pos)
{
  switch(jointName){
    case LEFT_ARM_ROLL:
      chain1.setServoPosition(0, pos);
      chain1.communicate();
      break;
    case LEFT_ARM_PITCH:
      chain1.setServoPosition(1, pos);
      chain1.communicate();
      break;
    case LEFT_ARM_ELBOW:
      chain1.setServoPosition(2, pos);
      chain1.communicate();
      break;    
    case RIGHT_ARM_ROLL:
      chain3.setServoPosition(0, pos);
      chain3.communicate();
      break;
    case RIGHT_ARM_PITCH:
      chain3.setServoPosition(1, pos);
      chain3.communicate();
      break;
    case RIGHT_ARM_ELBOW:
      chain3.setServoPosition(2, pos);
      chain3.communicate();
      break;
  }
}

void setup() {
  pinMode(chainPin1, OUTPUT);
  pinMode(chainPin3, OUTPUT);
  Serial.begin(9600);

  for (int i = 0; i < 50; i++)
  {
    chain1.communicate();
    chain3.communicate();
  }
  delay(100);
}

void loop() {

  setJoint(LEFT_ARM_ROLL, 5);
  setJoint(LEFT_ARM_PITCH, 5);

  setJoint(RIGHT_ARM_ROLL, 250);
  setJoint(RIGHT_ARM_PITCH, 250);

  delay(100);

  setJoint(LEFT_ARM_ROLL, 127);
  setJoint(LEFT_ARM_PITCH, 127);

  setJoint(RIGHT_ARM_ROLL, 127);
  setJoint(RIGHT_ARM_PITCH, 127);
}

Diese Vorgehensweise ist auch auf die Antriebsmotoren sowie den LEDs übertragbar. Theoretisch sind damit keine Grenzen gesetzt.

Pros

  • einfache Konstruktion
  • Polykarbonat-Material
  • ausführliche Bauanleitung
  • viele Erweiterungsmöglichkeiten
  • Spaß/Unterhaltung
  • Open-Source-Programmierung

Cons

  • Batterien nicht enthalten
  • MeccaBrain nicht Open-Source geeignet

Meccano Meccanoid G15

Fazit

Der Meccano Meccanoid G15 aus dem Hause Spin Master sieht aus wie der Roboter „Nummer 5“ aus dem gleichnamigen Film und hat mich von der ersten Minute an unterhalten. Der Selbstbau-Roboter besteht aus Polykarbonat und ist dank der ausführlichen Anleitung schnell zusammengebaut. Mit über 1000 vorprogrammierten Sätze und den drei Programmierungsmethoden sorgt der kleine Freund für Spaß pur. 

Fortgeschrittene Anwender können den G15 außerdem Open-Source programmieren. Zwar lässt sich der 16-Bit-Mikrocontroller (Meccabrain) nicht direkt programmieren, aber mit der Anschaffung eines Arduino Uno-Boards und der vom Hersteller bereitgestellt Arduino-Bibliothek sind auch hier keine Grenzen gesetzt. Darüber hinaus sind die Polykarbonat-Teile zu 100% kompatibel mit dem klassischen Mecanno-Bausystem, wodurch auch andere Konstruktionen realisiert werden können. Oder aber man legt sich zwei Roboter zu und baut sich daraus einen großen Roboter mit mehr Servos und dadurch auch mehr Bewegungsmöglichkeiten. Daher gibt es von uns eine ganz klare Kaufempfehlung.

Gesamtwertung 88%
Readers Rating
476 votes
79

Leave a Comment

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.