XMP-1 bauen: Kostengünstige XMOS-Raspberry Pi Mobile Plattform

Einführung

Das XMOS startKIT, erhältlich über Farnell (oder Newark) für nur 12 £ (inkl. MwSt.), bietet eine kompakte, kreditkartengroße Plattform, die nahtlos mit einem Raspberry Pi zusammenarbeitet. Mit minimalem Löten – nur Schraubendreher, Seitenschneider und Zange – können Entwickler einen funktionalen Robotik-Prototypen zusammenbauen, der XMOS' Multi-Core-, Low-Jitter-Parallelverarbeitung nutzt.

In diesem Artikel durchlaufen wir den Bau der XMP-1 (XMOS Mobile Platform), einer einfachen mobilen Plattform, die hochgeschwindige, bidirektionale Kommunikation zwischen Raspberry Pi und XMOS startKIT via Serial Peripheral Interface (SPI) demonstriert. Die XMP-1 zeigt auch, wie Hobby-Servos durch PWM, direkt vom XMOS-Board generiert, gesteuert werden, und wie eine webbasierte Benutzeroberfläche den Roboter in Echtzeit steuert.

Videodemos sind im Originalbeitrag enthalten; das erste zeigt die XMP-1 beim Erlernen einer Route, das zweite die Versuche des Roboters, die Route mit Continuous-Rotation-Servos wiederzugeben. Diese Videos illustrieren sowohl das Potenzial als auch die Grenzen der aktuellen Hard- und Firmware.

Mehr Details

Dieser Beitrag ist der zweite in einer Serie von XMOS-startKIT-Experimenten. Teil 1 bot eine Einführung in XMOS-Terminologie, Architektur und einen Quick-Start-Guide mit Beispielprogrammen. Falls Sie neu bei XMOS sind, hilft Teil 1 beim Verständnis der hier diskutierten Konzepte. Teil 3 (betitelt „XMOS startKIT: XMOS and Raspberry Pi Oscilloscope XAE 1000“) revisited das SPI-Framework und führt ADC-Nutzung und Echtzeit-Browser-Grafiken ein.

Für diejenigen, die sich ausschließlich auf Bau und Betrieb der XMP-1 konzentrieren, können die erweiterte Diskussion überspringen und direkt zu den Code-Abschnitten am Ende springen. Die Firmware kann wie in Teil 1 beschrieben kompiliert und auf das startKIT geflasht werden, und der Raspberry-Pi-Code läuft auf Node.js.

Lösungsüberblick – Hardware und Software

Abbildung 1 (nicht gezeigt) zeigt die fertige XMP-1, gespeist über einen 5-V-Regler und angetrieben von zwei Continuous-Rotation-Hobby-Servos. Der Raspberry Pi übernimmt das gesamte Networking und betreibt einen leichten Webserver, der index.html ausliefert und Benutzerbefehle in Motorgeschwindigkeits-/Richtungsnachrichten interpretiert.

Der Kommunikationsfluss ist in Abbildung 2 (nicht gezeigt) illustriert. Der Pi erzeugt ein PWM-Signal für die Servos, indem er ein SPI-Paket an das XMOS startKIT sendet. Das startKIT als SPI-Slave dekodiert das Paket und treibt die Servos mit den passenden PWM-Pulsen an.

Serial Peripheral Interface (SPI)

SPI basiert auf vier Leitungen: SS, SCLK, MOSI und MISO. In diesem Setup ist der Raspberry Pi Master, liefert den Takt und sendet Daten auf MOSI. Das XMOS-Board empfängt Daten auf MOSI und sendet Status oder Bestätigung auf MISO zurück. Die SS-Leitung ist Low-aktiv; der Pi's CE1-Pin wählt das startKIT aus.

Ein Oszilloskop-Trace (aufgenommen mit Tektronix MSO2024B) bestätigt die Integrität der SPI-Übertragung. Drei Bytes Daten – 0x02, 0x00 und 0x10 – wurden vom Pi an das startKIT gesendet, mit optionaler nulllanger Antwort.

Hobby-Servomotoren steuern

Hobby-Servos wandeln eine 1- bis 2-msec PWM-Pulsbreite in eine 0–180°-mechanische Rotation um, wobei 1,5 msec die Welle zentriert. Continuous-Rotation-Servos, eine Variante ohne Potentiometer und Endanschläge, interpretieren Pulsbreiten als Geschwindigkeitsbefehle: 1,5 ms für Neutral, 1 ms für volle Rückwärts-, 2 ms für volle Vorwärtsbewegung.

Jedes Rad der XMP-1 wird von einem Continuous-Rotation-Servo angetrieben. Obwohl dies die Verkabelung vereinfacht – kein externer H-Brücke nötig – limitiert es die präzise Geschwindigkeitskontrolle im Vergleich zu DC-Motoren.

Entwicklung starten – Boards verbinden

Für Firmware-Entwicklung sind Raspberry Pi und startKIT über ein 26-poliges Flachbandkabel mit IDC-Steckern verbunden. Ein reservierter IDC-Stecker kann als Debugging-Interface für Signalmessung mit Multimeter oder Oszilloskop dienen.

SPI implementieren (spi_process) auf XMOS startKIT

Mit der xTIMEcomposer IDE wird die eingebaute SPI-Slave-Bibliothek importiert und die Quelldateien in spi-test/src platziert. Die folgende Initialisierungsroutine konfiguriert Taktquelle, MOSI/MISO-Ports und SPI-Slave-Interface:

void spi_slave_init(spi_slave_interface &spi_if) {
 int clk_start;
 set_clock_on(spi_if.blk);
 configure_clock_src(spi_if.blk, spi_if.sclk);
 configure_in_port(spi_if.mosi, spi_if.blk);
 configure_out_port(spi_if.miso, spi_if.blk, 0);
 start_clock(spi_if.blk);
 return; }

Die spi_slave_interface-Struktur mappet SPI-Pins auf XMOS-Ports:

typedef struct spi_slave_interface {
 clock blk;
 in port ss;
 in buffered port:8 mosi;
 out buffered port:8 miso;
 in port sclk;
 } spi_slave_interface;

Eingehende SPI-Daten werden via folgende Routine in einen Puffer eingelesen, die ein einfaches Tag-Length-Value (TLV)-Protokoll für variable Nachrichtenlängen implementiert:

void spi_slave_in_buffer(spi_slave_interface &spi_if, unsigned char buffer[], int num_bytes) {
 unsigned int data;
 unsigned int vlen=0;
 clearbuf(spi_if.miso);
 clearbuf(spi_if.mosi);
 for (int i = 0; i < num_bytes; i++) {
  spi_if.mosi :> data;
  data=data<<24;
  buffer[i]=bitrev(data);
  if (i==2) {
   vlen=((unsigned int)buffer[1])<<8 | (unsigned int)buffer[2];
   if (vlen==0) break;
  }
  if (i >= vlen+2) { break; }
 }
 }

Das erste Byte eines Pakets ist ein Tag (0–255). Die nächsten zwei Bytes kodieren die Payload-Länge (bis 4096 Bytes). Ein ungerades Tag signalisiert, dass der Raspberry Pi eine Antwort erwartet; ein gerades Tag bedeutet, dass keine Antwort erforderlich ist.

Inter-Prozess-Kommunikation

XMOS-Kerne kommunizieren über transaktionsbasierte Interfaces statt simpler Kanäle. Dies erlaubt mehrere Datentypen und Rückgabewerte innerhalb eines einzelnen Interface-Aufrufs, ideal für Koordination der SPI-Handling-, Datenverarbeitungs- und PWM-Generierungs-Cores.

Beispiel-Interface-Definitionen:

interface program_display {
 void backlight(int state, int color);
 void plot(int x, int y, int color);
 }

IPC-Architektur designen für SPI-Inhalt-Handling

Der spi_process-Core fängt eingehende SPI-Daten in einen 4099-Byte-Puffer und leitet einen Pointer an den data_handler-Core via movable-array-Transaktion weiter. Nach Verarbeitung kann data_handler den Puffer mit einer Antwort füllen und spi_process signalisieren, dass Daten für den nächsten SPI-Austausch bereit sind.

interface to_rpi { void code(unsigned char c); };
interface from_rpi { unsigned char* movable array_data(unsigned char* movable bufp); };

Core-Logik-Ausschnitte:

void spi_process(interface to_rpi server s, interface from_rpi client c) {
 unsigned char storage[4099];
 unsigned char* movable buf=storage;
 buf=c.array_data(move(buf));
 select {
  case s.code(unsigned char c):
   if (c==SEND) {
    spi_slave_out_buffer(spi_sif, buf, 4099);
   }
   break;
 }
 }

void data_handler(interface to_rpi client c, interface from_rpi server s) {
 select {
  case s.array_data(unsigned char* movable vp) -> unsigned char* movable vq:
   vq[0]=0x22; // tag
   vq[1]=0x00; // length
   vq[2]=0x00;
   vq=move(vp);
   tosend=1;
   break;
 }
 if (tosend) { c.code(SEND); }
 }

Diese Architektur liefert einen allgemeinen, bidirektionalen Kommunikationskanal zwischen Raspberry Pi und XMOS startKIT, anpassbar für diverse Robotik- oder IoT-Projekte.

PWM implementieren (servo_handler) auf startKIT

Die Servo-Steuerroutine läuft auf einem dedizierten XMOS-Core und managt bis zu acht Servos. Jedes Servos PWM-Signal wird durch Toggeln eines Output-Pins bei passendem Duty Cycle alle 20 ms generiert, mit Mikrosekunden-Auflösung für feine Geschwindigkeitsanpassung. Startwerte sind zentriert (oder stationär für Continuous-Rotation-Servos), und der Core aktualisiert das Signal jedes Zyklus basierend auf dem neuesten Befehl via IPC-Framework.

Obwohl die aktuelle XMP-1 nur zwei Continuous-Rotation-Servos nutzt, unterstützt die Firmware Erweiterung auf zusätzliche Motoren oder DC-Motor-Kontrolle via H-Brücke-Interface bei Bedarf.

Für vollständigen Quellcode und Kompilieranweisungen siehe Ende dieses Artikels.