Construindo o XMP‑1: Plataforma Móvel XMOS-Raspberry Pi de Baixo Custo

Introdução

O XMOS startKIT, disponível pela Farnell (ou Newark) por apenas £12 (IVA incluído), oferece uma plataforma compacta do tamanho de um cartão de crédito que se encaixa perfeitamente com um Raspberry Pi. Com solda mínima — apenas chave de fenda, alicate de corte e alicate — desenvolvedores podem montar um protótipo de robótica funcional que aproveita o processamento paralelo multi-core de baixo jitter da XMOS.

Neste artigo, percorremos a construção do XMP‑1 (XMOS Mobile Platform), uma plataforma móvel simples que demonstra comunicação bidirecional de alta velocidade entre o Raspberry Pi e um XMOS startKIT via Interface Serial Periférica (SPI). O XMP‑1 também mostra como controlar servos hobby através de PWM gerado diretamente da placa XMOS e como expor uma interface de usuário baseada na web que controla o robô em tempo real.

Demonstrações em vídeo estão incluídas no post original; a primeira mostra o XMP‑1 aprendendo uma rota, enquanto a segunda captura as tentativas do robô de repetir a rota usando servos de rotação contínua. Esses vídeos ilustram tanto o potencial quanto as limitações do hardware e firmware atuais.

Um Pouco Mais de Detalhe

Este post é o segundo de uma série de experimentos com XMOS startKIT. A Parte 1 forneceu uma introdução à terminologia XMOS, arquitetura e um guia de início rápido com programas de exemplo. Se você é novo em XMOS, revisar a Parte 1 ajudará a compreender os conceitos discutidos aqui. A Parte 3 (intitulada "XMOS startKIT: XMOS and Raspberry Pi Oscilloscope XAE 1000") revisita o framework SPI e introduz uso de ADC e gráficos de navegador em tempo real.

Para aqueles focados apenas na construção e operação do XMP‑1, você pode pular a discussão estendida e ir direto às seções de código no final deste artigo. O firmware pode ser compilado e gravado no startKIT conforme descrito na Parte 1, e o código do Raspberry Pi roda em Node.js.

Visão Geral da Solução – Hardware e Software

A Figura 1 (não mostrada) retrata o XMP‑1 concluído, alimentado via regulador de 5 V e acionado por dois servos hobby de rotação contínua. O Raspberry Pi gerencia toda a rede, executando um servidor web leve que serve index.html e interpreta comandos do usuário em mensagens de velocidade/direção do motor.

O fluxo de comunicação é ilustrado na Figura 2 (não mostrada). O Pi gera um sinal PWM para os servos enviando um pacote SPI ao XMOS startKIT. O startKIT, agindo como escravo SPI, decodifica o pacote e aciona os servos com os pulsos PWM apropriados.

Interface Serial Periférica (SPI)

SPI depende de quatro fios: SS, SCLK, MOSI e MISO. Nesta configuração, o Raspberry Pi é o mestre, fornecendo o clock e transmitindo dados no MOSI. A placa XMOS recebe os dados no MOSI e retorna status ou confirmação no MISO. A linha SS é ativa baixa; o pino CE1 do Pi é usado para selecionar o startKIT.

Um traço de osciloscópio (capturado com Tektronix MSO2024B) confirma a integridade da transferência SPI. Três bytes de dados — 0x02, 0x00 e 0x10 — foram transmitidos do Pi para o startKIT, com resposta opcional de comprimento zero.

Controlando Motores Servo Hobby

Servos hobby convertem largura de pulso PWM de 1 a 2 mseg em rotação mecânica de 0–180°, com pulso de 1,5 mseg centralizando o eixo. Servos de rotação contínua, uma variação que remove o potenciômetro e fins de curso, interpretam larguras de pulso como comandos de velocidade: 1,5 ms para neutro, 1 ms para ré total e 2 ms para frente total.

Cada roda do XMP‑1 é acionada por um servo de rotação contínua. Embora essa configuração simplifique a fiação — sem H‑bridge externo necessário — ela limita controle preciso de velocidade comparado a motores DC.

Iniciando Desenvolvimento – Conectando as Placas

Para desenvolvimento de firmware, o Raspberry Pi e o startKIT são ligados via cabo flat de 26 pinos com conectores IDC. Um conector IDC sobressalente pode servir como interface de depuração para sondar sinais com multímetro ou osciloscópio.

Implementando SPI (spi_process) no XMOS startKIT

Usando o IDE xTIMEcomposer, a biblioteca built-in de slave SPI é importada e os arquivos de origem são colocados no diretório spi‑test/src. A rotina de inicialização a seguir configura a fonte de clock, portas MOSI/MISO e a interface slave 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; }

A estrutura spi_slave_interface mapeia os pinos SPI para as portas 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;

Dados SPI de entrada são lidos em um buffer usando a rotina a seguir, que implementa um protocolo simples tag-length-value (TLV) para permitir mensagens de comprimento variável:

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

O primeiro byte de um pacote é uma tag (0–255). Os próximos dois bytes codificam o comprimento do payload (até 4096 bytes). Uma tag ímpar sinaliza que o Raspberry Pi espera uma resposta; uma tag par indica que nenhuma resposta é necessária.

Comunicação Entre Processos

Núcleos XMOS comunicam via interfaces baseadas em transação em vez de canais simples. Essa abordagem permite múltiplos tipos de dados e valores de retorno dentro de uma única chamada de interface, ideal para coordenar o núcleo de manipulação SPI, o núcleo de processamento de dados e o núcleo de geração PWM.

Definições de interface de exemplo:

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

Projetando a Arquitetura IPC para Lidar com Conteúdo SPI

O núcleo spi_process captura dados SPI de entrada em um buffer de 4099 bytes e encaminha um ponteiro para o núcleo data_handler via transação de array móvel. Após processamento, data_handler pode popular o buffer com uma resposta e sinalizar spi_process que os dados estão prontos para serem transmitidos de volta na próxima troca SPI.

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

Trechos de lógica do núcleo:

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

Esta arquitetura entrega um canal de comunicação bidirecional de propósito geral entre o Raspberry Pi e o XMOS startKIT, que pode ser adaptado para uma ampla gama de projetos de robótica ou IoT.

Implementando PWM (servo_handler) no startKIT

A rotina de controle de servo roda em um núcleo XMOS dedicado e gerencia até oito servos. O sinal PWM de cada servo é gerado alternando um pino de saída no ciclo de trabalho apropriado a cada 20 ms, com resolução de microssegundo para ajuste fino de velocidade. Os valores iniciais são centralizados (ou estacionários para servos de rotação contínua), e o núcleo atualiza o sinal a cada ciclo com base no comando mais recente recebido via framework IPC.

Embora o XMP‑1 atual use apenas dois servos de rotação contínua, o firmware suporta expansão para motores adicionais ou controle de motor DC através de interface H‑bridge, se necessário.

Para código fonte completo e instruções de compilação, veja o final deste artigo.