Construction du XMP‑1 : Plateforme mobile XMOS‑Raspberry Pi à faible coût

Introduction

Le XMOS startKIT, disponible chez Farnell (ou Newark) pour seulement 12 £ (TVA incluse), offre une plateforme compacte, format carte de crédit, qui s'associe parfaitement à un Raspberry Pi. Avec un minimum de soudure – seulement un tournevis, coupe‑fil et pinces – les développeurs peuvent assembler un prototype robotique fonctionnel exploitant le traitement parallèle multi‑cœur à faible gigue de XMOS.

Dans cet article, nous parcourons la construction du XMP‑1 (XMOS Mobile Platform), une plateforme mobile simple démontrant une communication bidirectionnelle haute vitesse entre le Raspberry Pi et un XMOS startKIT via une interface SPI (Serial Peripheral Interface). Le XMP‑1 montre aussi comment piloter des servos de modélisme via PWM généré directement depuis la carte XMOS, et comment exposer une interface utilisateur web pilotant le robot en temps réel.

Des démonstrations vidéo sont incluses dans l'article original ; la première montre le XMP‑1 apprenant un parcours, la seconde capture les tentatives du robot pour rejouer le parcours avec des servos à rotation continue. Ces vidéos illustrent à la fois le potentiel et les limites du matériel et firmware actuels.

Un peu plus de détails

Ce billet est le second d'une série d'expériences sur le XMOS startKIT. La partie 1 proposait une introduction à la terminologie XMOS, son architecture, et un guide de démarrage rapide avec programmes d'exemple. Si vous découvrez XMOS, relire la partie 1 aidera à saisir les concepts discutés ici. La partie 3 (intitulée « XMOS startKIT : XMOS and Raspberry Pi Oscilloscope XAE 1000 ») revisite le cadre SPI et introduit l'usage de l'ADC et des graphiques temps réel dans le navigateur.

Pour ceux focalisés uniquement sur la construction et l'exploitation du XMP‑1, vous pouvez passer la discussion étendue et aller directement aux sections de code en bas de l'article. Le firmware peut être compilé et flashé sur le startKIT comme décrit en partie 1, et le code Raspberry Pi tourne sous Node.js.

Vue d'ensemble de la solution – Matériel et Logiciel

La figure 1 (non montrée) représente le XMP‑1 complet, alimenté via un régulateur 5 V et entraîné par deux servos de modélisme à rotation continue. Le Raspberry Pi gère tout le réseau, exécutant un serveur web léger qui sert index.html et interprète les commandes utilisateur en messages vitesse/direction moteurs.

Le flux de communication est illustré en figure 2 (non montrée). Le Pi génère un signal PWM pour les servos en envoyant un paquet SPI au XMOS startKIT. Le startKIT, agissant en esclave SPI, décode le paquet et pilote les servos avec les impulsions PWM appropriées.

Interface SPI (Serial Peripheral Interface)

Le SPI repose sur quatre fils : SS, SCLK, MOSI, et MISO. Dans ce montage, le Raspberry Pi est le maître, fournissant l'horloge et transmettant les données sur MOSI. La carte XMOS reçoit les données sur MOSI et renvoie un statut ou acquittement sur MISO. La ligne SS est active basse ; la broche CE1 du Pi sélectionne le startKIT.

Une capture oscilloscope (réalisée avec un Tektronix MSO2024B) confirme l'intégrité du transfert SPI. Trois octets – 0x02, 0x00, et 0x10 – ont été transmis du Pi au startKIT, avec réponse optionnelle de longueur nulle.

Contrôle des servos de modélisme

Les servos de modélisme convertissent une largeur d'impulsion PWM de 1‑2 ms en rotation mécanique 0‑180°, une impulsion de 1,5 ms centrant l'arbre. Les servos à rotation continue, variante sans potentiomètre ni butées, interprètent les largeurs d'impulsion comme commandes de vitesse : 1,5 ms pour neutre, 1 ms pour marche arrière max, et 2 ms pour marche avant max.

Chaque roue du XMP‑1 est entraînée par un servo à rotation continue. Cette configuration simplifie le câblage – pas de pont en H externe – mais limite le contrôle précis de vitesse comparé à des moteurs CC.

Démarrage du développement – Connexion des cartes

Pour le développement firmware, le Raspberry Pi et le startKIT sont reliés par un câble ruban 26 broches avec connecteurs IDC. Un connecteur IDC de secours peut servir d'interface de debug pour sonder les signaux au multimètre ou oscilloscope.

Implémentation SPI (spi_process) sur le XMOS startKIT

Avec l'IDE xTIMEcomposer, la bibliothèque esclave SPI intégrée est importée et les fichiers sources placés dans spi‑test/src. La routine d'initialisation suivante configure la source d'horloge, ports MOSI/MISO, et l'interface esclave SPI :

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

La structure spi_slave_interface mappe les broches SPI aux ports XMOS :

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;

Les données SPI entrantes sont lues dans un tampon via la routine suivante, qui implémente un protocole simple tag‑longueur‑valeur (TLV) pour permettre des messages de longueur variable :

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

Le premier octet d'un paquet est un tag (0‑255). Les deux octets suivants encodent la longueur de la charge utile (jusqu'à 4096 octets). Un tag impair signale que le Raspberry Pi attend une réponse ; un tag pair indique qu'aucune réponse n'est requise.

Communication inter‑processus

Les cœurs XMOS communiquent via des interfaces basées sur transactions plutôt que de simples canaux. Cette approche permet plusieurs types de données et valeurs de retour dans un seul appel d'interface, idéal pour coordonner le cœur de gestion SPI, le cœur de traitement de données, et le cœur de génération PWM.

Exemples de définitions d'interfaces :

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

Architecture IPC pour gérer le contenu SPI

Le cœur spi_process capture les données SPI entrantes dans un tampon de 4099 octets et transmet un pointeur au cœur data_handler via une transaction de tableau mobile. Après traitement, data_handler peut peupler le tampon avec une réponse et signaler à spi_process que les données sont prêtes pour être transmises au prochain échange SPI.

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

Extraits de logique des cœurs :

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

Cette architecture fournit un canal de communication bidirectionnel à usage général entre le Raspberry Pi et le XMOS startKIT, adaptable à une large gamme de projets robotiques ou IoT.

Implémentation PWM (servo_handler) sur le startKIT

La routine de contrôle servo s'exécute sur un cœur XMOS dédié et gère jusqu'à huit servos. Le signal PWM de chaque servo est généré en basculant une broche de sortie au cycle de travail approprié toutes les 20 ms, avec une résolution microseconde pour un réglage fin de vitesse. Les valeurs initiales sont centrées (ou arrêt pour servos à rotation continue), et le cœur met à jour le signal à chaque cycle selon la dernière commande reçue via le cadre IPC.

Bien que le XMP‑1 actuel n'utilise que deux servos à rotation continue, le firmware supporte l'extension à des moteurs supplémentaires ou au contrôle de moteurs CC via une interface pont en H si nécessaire.

Pour le code source complet et instructions de compilation, voir la fin de cet article.