Inleiding

De XMOS startKIT, verkrijgbaar via Farnell (of Newark) voor slechts £12 (BTW inbegrepen), biedt een compact, creditcard-groot platform dat naadloos past bij een Raspberry Pi. Met minimaal solderen – alleen een schroevendraaier, snoertang en tang – kunnen ontwikkelaars een functioneel robotica-prototype assembleren dat XMOS's multi-core, lage-jitter parallelle verwerking benut.

In dit artikel lopen we door de constructie van de XMP-1 (XMOS Mobile Platform), een simpel mobiel platform dat high-speed, bidirectionele communicatie demonstreert tussen de Raspberry Pi en een XMOS startKIT via een Serial Peripheral Interface (SPI). De XMP-1 toont ook hoe hobby-servo's via PWM direct gegenereerd vanaf het XMOS-bord te besturen, en hoe een web-gebaseerde gebruikersinterface de robot in real-time aanstuurt.

Videodemonstraties zijn in de originele post inbegrepen; de eerste toont de XMP-1 een route leren, terwijl de tweede de pogingen van de robot vastlegt om de route af te spelen met continuous-rotatie servo's. Deze video's illustreren zowel het potentieel als de beperkingen van de huidige hardware en firmware.

Wat Meer Detail

Dit bericht is de tweede in een reeks XMOS startKIT experimenten. Deel 1 bood een inleiding tot XMOS-terminologie, architectuur en een quick-start gids met voorbeeldprogramma's. Als je nieuw bent voor XMOS, zal het bekijken van Deel 1 helpen de concepten hier te begrijpen. Deel 3 (getiteld "XMOS startKIT: XMOS and Raspberry Pi Oscilloscope XAE 1000") herbezoekt het SPI-framework en introduceert ADC-gebruik en real-time browser-grafieken.

Voor diegenen die zich enkel richten op het bouwen en bedienen van de XMP-1, kun je de uitgebreide discussie overslaan en direct springen naar de codesekties aan het einde van dit artikel. De firmware kan gecompileerd en geflasht worden op de startKIT zoals beschreven in Deel 1, en de Raspberry Pi-code draait op Node.js.

Oplossing Overzicht – Hardware en Software

Figuur 1 (niet getoond) toont de voltooide XMP-1, gevoed via een 5 V-regelaar en aangedreven door twee continuous-rotatie hobby-servo's. De Raspberry Pi handelt alle netwerking, met een lichtgewicht webserver die index.html serveert en gebruikerscommando's interpreteert in motor snelheid/richting berichten.

De communicatiestroom is geïllustreerd in Figuur 2 (niet getoond). De Pi genereert een PWM-signaal voor de servo's door een SPI-pakket naar de XMOS startKIT te sturen. De startKIT, optredend als SPI-slave, decodeert het pakket en stuurt de servo's met de juiste PWM-pulsen.

Serial Peripheral Interface (SPI)

SPI berust op vier draden: SS, SCLK, MOSI, en MISO. In deze opstelling is de Raspberry Pi de master, die de klok levert en data op MOSI uitzendt. Het XMOS-bord ontvangt de data op MOSI en retourneert status of bevestiging op MISO. De SS-lijn is actief laag; de Pi's CE1-pin wordt gebruikt om de startKIT te selecteren.

Een oscilloscopetrace (opgenomen met een Tektronix MSO2024B) bevestigt de integriteit van de SPI-overdracht. Drie bytes data – 0x02, 0x00, en 0x10 – werden van de Pi naar de startKIT gezonden, met optionele nul-lengte respons.

Hobby Servomotoren Besturen

Hobby-servo's converteren een 1-tot-2 msec PWM-pulsbreedte in een 0–180° mechanische rotatie, met een 1,5 msec-puls die de as centreert. Continuous-rotatie servo's, een variant die de potentiometer en eindstops verwijdert, interpreteren pulsbreedtes als snelheidscommando's: 1,5 ms voor neutraal, 1 ms voor volle achteruit, en 2 ms voor volle vooruit.

Elk wiel op de XMP-1 wordt aangedreven door een continuous-rotatie servo. Hoewel deze opstelling de wiring vereenvoudigt – geen externe H-brug vereist – beperkt het de nauwkeurige snelheidscontrole vergeleken met DC-motoren.

Ontwikkeling Starten – De Borden Verbinden

Voor firmware-ontwikkeling zijn de Raspberry Pi en startKIT verbonden via een 26-pins lintkabel met IDC-connectors. Een reserve IDC-connector kan dienen als debug-interface voor het proberen van signalen met een multimeter of oscilloscoop.

SPI Implementeren (spi_process) op de XMOS startKIT

Met de xTIMEcomposer IDE wordt de ingebouwde SPI-slave bibliotheek geïmporteerd en de bronbestanden in de spi‑test/src map geplaatst. De volgende initialisatieroutine configureert de klokbron, MOSI/MISO-poorten en de 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; }

De spi_slave_interface structuur mapt de SPI-pinnen naar de XMOS-poorten:

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;

Binnenkomende SPI-data wordt in een buffer gelezen met de volgende routine, die een simpel tag-length-value (TLV) protocol implementeert om variabele-lengte berichten toe te staan:

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; } } }

De eerste byte van een pakket is een tag (0–255). De volgende twee bytes coderen de payload-lengte (tot 4096 bytes). Een oneven tag signaleert dat de Raspberry Pi een respons verwacht; een even tag geeft aan dat geen respons vereist is.

Inter-Process Communicatie

XMOS-kernen communiceren via transactie-gebaseerde interfaces in plaats van simpele kanalen. Deze benadering stelt meerdere datatypes en return-waarden binnen een enkele interface-aanroep toe, wat ideaal is voor het coördineren van de SPI-afhandelingscore, de data-verwerkingscore en de PWM-generatiecore.

Voorbeeld interface-definities:

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

De IPC-architectuur Ontwerpen om SPI-inhoud te Hanteren

De spi_process core vangt binnenkomende SPI-data in een 4099-byte buffer en stuurt een pointer naar de data_handler core via een movable-array transactie. Na verwerking kan data_handler de buffer vullen met een respons en spi_process signaleren dat data klaar is om terug te zenden bij de volgende SPI-wissel.

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

Core-logica fragmenten:

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; // lengte vq[2]=0x00; vq=move(vp); tosend=1; break; } if (tosend) { c.code(SEND); } }

Deze architectuur levert een algemeen-doel, bidirectioneel communicatiekanaal tussen de Raspberry Pi en de XMOS startKIT, wat aangepast kan worden voor een breed scala aan robotica of IoT-projecten.

PWM Implementeren (servo_handler) op de startKIT

De servo-besturingsroutine draait op een toegewijde XMOS-core en beheert tot acht servo's. Elke servo's PWM-signaal wordt gegenereerd door een uitgangspin te toggelen op de juiste duty-cycle elke 20 ms, met een microseconde-resolutie voor fijne snelheidsaanpassing. De initiële waarden zijn gecentreerd (of stationair voor continuous-rotatie servo's), en de core update het signaal op elke cyclus gebaseerd op het laatste commando ontvangen via het IPC-framework.

Hoewel de huidige XMP-1 slechts twee continuous-rotatie servo's gebruikt, ondersteunt de firmware uitbreiding naar extra motoren of DC-motor besturing via een H-brug-interface indien nodig.

Voor volledige broncode en compilatie-instructies, zie het einde van dit artikel.