Raspberry Pi steuert Fischertechnik-Roboter (Seite 3)

Abbildung 5: Testaufbau für den Motor mit Spindelantrieb.

Abbildung 6: Die Anschlüsse außerhalb der Platine.

Der zugehörige Schaltplan teilt sich in zwei Bereiche, die Input- und die Output-Bausteine. Die Output-Schaltung formiert sich um die zwei L293-Chips zum Ansteuern der Motoren (Abbildung 7). Jeder Ausgangsstrang enthält eine elektronische Sicherung mit 400 mA. Sie hält den Strom immer auf einem Level, bei dem die L293-Bausteine keinen Schaden nehmen. Die Eingänge der L293-Treiber verbinden Sie direkt mit der GPIO des Raspberry Pi.

Abbildung 7: Der Schaltplan für die Output-Teil.

Ansonsten findet sich im Output-Teil nur noch ein Pullup-Widerstand, der dazu dient, die Endstufen der Treiber zu aktivieren. Da die Elektromotoren Störungen in der Betriebsspannung verursachen, gibt es zusätzlich noch den Kondensator C1, der die Betriebsspannung der kompletten Schaltung stabilisiert.

Die Input-Schaltung bauen Sie rund um die zentralen CD4010-Bausteine auf (Abbildung 8). Die digitalen Eingänge für Schalter versehen Sie mit Pulldown-Widerständen und Kondensatoren. Die Widerstände sorgen dafür, dass die Eingänge immer einen definierten Zustand besitzen. Während des Schaltens erzeugen Schalter viele kurze Impulse, bis sie den Schaltungsvorgang endgültig abgeschlossen haben. Dieses für digitale Schaltungen problematische Verhalten nennt man Prellen. Die 0,1-µF-Kondensatoren filtern das Prellen der Taster heraus.

Abbildung 8: Der Schaltplan für den Input-Teil.

Bei den Counter-Eingängen finden sich jeweils Pullup-Widerstände, da die Impulsgeber in den Motoren einen Open-Collector-Ausgang nutzen. Die 9-Volt-Spannungsversorgung für die Taster und Impulsgeber ist mit einer PTC-Sicherung versehen, damit im Fall eines Verdrahtungsfehlers keine zu großen Ströme fließen und eine Komponente zerstören.

Alle Anschlüsse führen Sie über Schraubklemmen heraus: So lassen sie sich am einfachsten mit den Fischertechnik-Komponenten verbinden. Einen vollständiger Plan der Klemmen zeigt Abbildung 6. In der Tabelle “Teileliste” finden Sie alle für den Aufbau benötigten Teile, wobei sich die Preise auf das aktuelle Sortiment von Reichelt Elektronik beziehen. Zur Spannungsversorgung benötigen Sie noch ein beliebiges Netzteil, das etwa 1,5 bis 2 Ampere Strom bei 9 Volt Spannung liefert.

Das Projekt belegt fast alle GPIO-Anschlüsse des Raspberry Pi. Die Anschlüsse für das I²C-Interface des RasPi bleiben somit frei, um später Erweiterungen wie Sensoren, AD-Wandler oder Port-Erweiterungen anzuschließen.

Abbildung 9 zeigt die Rückseite der noch nicht vollständig verlöteten Projektplatine. Ein besonderes Augenmerk sollten Sie hier auf die großen Lötzinnflächen an den Motortreibern legen: Sie dienen der Kühlung der ICs. Achten Sie darauf, alle Leitungen, die etwas mehr Strom führen, mit höherem Querschnitt auszuführen. Abbildung 10 zeigt die vollständig bestückte Platine von vorne.

Abbildung 9: Die Platine von hinten.

Abbildung 10: Die Vorderseite der komplett bestückten Platine.

Um die Platine komplett zu testen, versorgen Sie sie idealerweise zunächst über ein Labornetzteil mit Spannung. Dann testen Sie jeden Ein- und Ausgang zuerst ohne Raspberry Pi durch. Das kostet zwar ein wenig Zeit, rettet dem an die Platine angeschlossenen RasPi jedoch unter Umständen das Leben.

Um die Eingänge zu überprüfen, schließen Sie jeden einzelnen Eingang an 9 Volt an und messen nach, ob an dem dazugehörigen GPIO-Anschluss auf der Platine 3,3 Volt ankommen. Bei den digitalen Ausgängen verwenden Sie ein ähnliches Verfahren: Legen Sie an den GPIO-Anschluss der Platine eine Spannung von 3,3 Volt an und überprüfen Sie mit einem Multimeter, ob am Ausgang die erwarteten 9 Volt ankommen. Sind Sie sich sicher, dass an keinem GPIO-Anschluss eine zu hohe Spannung anliegt, verbinden Sie die Platine mit dem Raspberry Pi.

Anschließend bietet es sich an, mithilfe des GPIO-Tools der WiringPi-Bibliothek durchzutesten, ob vielleicht einige Ein- oder Ausgänge versehentlich gebrückt wurden. Alternativ schließen Sie einfach einige LEDs an die Ausgänge an. Bei 9 Volt bietet sich als Vorwiderstand für die LEDs 1 kOhm an – das ist zwar nicht optimal dimensioniert, klappt aber ausgezeichnet.

Testprogramm

Die Artikelreihe zielt in der nächsten Ausgabe darauf ab, einen kompletten Fischertechnik-Roboter anzusteuern. Daher halten wir das Testprogramm knapp: Es dient dazu, den Positionierungsbereich der Spindelmutter zu ermitteln und diese dann in die Mitte des Bereichs zu fahren. Trennen Sie jedoch zunächst den Motor mechanisch von der Spindel. Damit verhindern Sie, dass etwas an dem Aufbau kaputtgeht, falls sich der Motor sich in die falsche Richtung dreht. Später lässt sich das Programm weiterverwenden, um eine Achse des Roboters zu initialisieren.

Das Programm in Listing 1 besteht im Wesentlichen aus drei Interrupt-Handlern und dem Hauptprogramm. Der Handler counterInterrupt(void) zählt abhängig von der Bewegungsrichtung die Variable position herauf oder herunter. Weist sie denselben Wert wie die Variable target auf, schaltet das Programm die Motoren ab.

# init.cc
#include <stdio.h>
#include <stdlib.h>
#include <wiringPi.h>
#define BUTTON_LEFT_PIN 0
#define BUTTON_RIGHT_PIN 1
#define COUNTER_PIN 10
#define ENGINE_PIN_0 21
#define ENGINE_PIN_1 22
volatile int position = 0;
int direction = 0; // 0 to left side, 1 to right side
int target = 99999;
volatile int maxPosition = -1;
void stopEngine(void) {
  digitalWrite (ENGINE_PIN_0, LOW);
  digitalWrite (ENGINE_PIN_1, LOW);
}
void counterInterrupt(void) {
  if (direction == 0) {
    position -- ;
  }
  else {
    position ++ ;
  }
  if (position == target) {
     stopEngine();
  }
}
void buttonLeftInterrupt(void) {
  stopEngine();
  position = 0;
}
void buttonRightInterrupt(void) {
  stopEngine();
  maxPosition = position;
}
int main(void) {
  wiringPiSetup ();
  pinMode(BUTTON_LEFT_PIN, INPUT);
  pinMode(BUTTON_RIGHT_PIN, INPUT);
  pinMode(COUNTER_PIN, INPUT);
  pinMode(ENGINE_PIN_0, OUTPUT);
  pinMode(ENGINE_PIN_1, OUTPUT);
  // install interrupt handler
  wiringPiISR(BUTTON_LEFT_PIN, INT_EDGE_RISING, &buttonLeftInterrupt);
  wiringPiISR(BUTTON_RIGHT_PIN, INT_EDGE_RISING, &buttonRightInterrupt);
  wiringPiISR(COUNTER_PIN, INT_EDGE_FALLING, &counterInterrupt);
  // move to left position
  printf("Move to left\n");
  direction = 0;
  digitalWrite(ENGINE_PIN_0, HIGH);
  delay(10000);
  stopEngine();
  // move to right position
  printf("Move to right\n");
  direction = 1;
  digitalWrite(ENGINE_PIN_1, HIGH);
  delay(10000);
  stopEngine();
  // move to middle position
  printf("Move to middle\n");
  direction = 0;
  target=maxPosition/2;
  digitalWrite(ENGINE_PIN_0, HIGH);
  delay(10000);
  stopEngine();
}

Die zwei Handler buttonLeftInterrupt(void) und buttonRightInterrupt(void) starten, sobald der dem Namen entsprechende Button eine Aktion meldet. Beide stoppen den Motor. Der Handler für den linken Button setzt die Variable position auf null. Der Handler für den rechten Button setzt die Variable maxPosition auf den Wert von position. Damit lässt sich der maximal mögliche Fahrweg der Spindel ermitteln.