Maker Omnidirecionais

This tutorial is not available in English

Maker Omnidirecional

O projeto Maker Omnidirecional nasceu a partir da base do robô omnidirecional, agora com uma nova identidade visual inspirada no Maker, mascote da Creality.

Além de ser um personagem bem carismático, o Maker recebeu uma sequência de movimentos divertida e diferente, combinando deslocamentos omnidirecionais, giros, expressơes nos olhos e movimentos nos braços.

Após seguir o tutorial anterior das rodas omnidirecionais e montar a base do robô, este projeto mostra como transformar essa estrutura em um novo robô-personagem. Para isso, serăo impressas as partes que compơem o Maker e uma nova tampa para fixá-lo sobre a base omnidirecional.

Vídeo do projeto

Visăo geral do Maker

Maker Omnidirecional montado sobre a base.

Funcionamento geral

O Maker Omnidirecional utiliza a mesma base mecânica do robô omnidirecional original, com três rodas omni posicionadas nos vértices da estrutura. Essa configuraçăo permite que o robô se desloque para frente, para trás, para os lados, em diagonais e também gire no próprio eixo.

Nesta nova versăo, foram adicionados dois displays redondos para formar os olhos do personagem e dois micro servos responsáveis pelo movimento dos braços. Os olhos exibem símbolos simples, no estilo emoji, enquanto os braços se movimentam em uma faixa curta de aproximadamente 35 graus.

O controle continua sendo feito por uma interface web acessada pelo navegador. Além dos comandos de movimentaçăo, o código inclui açơes especiais para controlar os braços e enviar comandos ao Arduino BlackBoard Uno, responsável pelos olhos e servomotores.

Olhos e expressơes

Os olhos do Maker săo formados por dois displays redondos IPS ligados em paralelo. Como os dois displays recebem os mesmos sinais, ambos exibem a mesma expressăo ao mesmo tempo.

As expressơes săo feitas com símbolos simples, criando um efeito visual direto e divertido. Alguns exemplos de expressơes possíveis săo:

0 0 - olhos abertos
- - - piscando
O O - surpreso
^ ^ - feliz
< < - olhando para um lado
> > - olhando para o outro lado

Para exibir expressơes diferentes em cada olho, como < >, seria necessário controlar os displays separadamente, usando ao menos pinos CS independentes.

Movimento dos braços

Os braços do Maker săo movimentados por dois micro servos SG90, um para cada lado. O corpo e a cabeça permanecem fixos; apenas os braços se movem.

Para manter o movimento suave e evitar esforço mecânico nas peças impressas, cada servo trabalha com um curso aproximado de 35 graus. Essa limitaçăo é suficiente para criar açơes como acenar, comemorar e acompanhar os movimentos do robô durante a sequência automática.

Detalhes da montagem

Detalhe da montagem do Maker Omnidirecional — Detalhe da montagem do Maker sobre a nova tampa da base omnidirecional.

Arquivos para impressăo 3D

As peças do Maker devem ser impressas em 3D e montadas sobre a nova tampa da base. Os arquivos abaixo correspondem às partes do personagem e à tampa utilizada para fixaçăo.

Corpo Frente do Maker (.3mf)

Costas do Maker (.stl)

Corpo com encaixe dos olhos (.3mf)

Peças miúdas do Maker (.3mf)

Tampa para fixaçăo do Maker

Lista de materiais

1x base do robô omnidirecional montada conforme o tutorial anterior: Rodas Omnidirecionais
2x Display IPS 1,28" Redondo RGB
2x Micro Servo 9g SG90 TowerPro
Peças impressas em 3D do Maker
Nova tampa para fixaçăo do Maker na base omnidirecional

Ligaçơes elétricas

A base do robô mantém as mesmas ligaçơes dos motores utilizadas no projeto omnidirecional original. Nesta versăo, săo adicionados dois displays para os olhos e dois servomotores para os braços.

O projeto utiliza duas placas: a BlackBoard Rocky como placa principal e um BlackBoard UNO R3 como placa auxiliar. A BlackBoard Rocky controla os motores, cria a rede Wi-Fi e disponibiliza a interface web. O BlackBoard UNO R3 recebe comandos pela comunicaçăo serial e fica responsável pelos olhos e pelos braços.

BlackBoard Rocky: controle dos motores, rede Wi-Fi e interface web
BlackBoard UNO R3: controle dos dois servomotores e dos dois displays dos olhos
Olhos: dois displays GC9A01A ligados em paralelo
Motores: portas A, B e C da BlackBoard Rocky

A comunicaçăo entre as placas é feita pela serial. Como a BlackBoard Rocky trabalha com nível lógico de 3,3 V e o BlackBoard UNO R3 trabalha com 5 V, foi utilizado um conversor de nível lógico entre o TX da Rocky e o RX do BlackBoard.

Caso os servos apresentem tremores ou a placa reinicie durante os movimentos, verifique a alimentaçăo, pois servomotores podem exigir picos de corrente durante o acionamento.

Código

O código do Maker Omnidirecional foi dividido em duas partes. O primeiro código deve ser gravado na BlackBoard Rocky, que atua como placa principal do robô. Ela cria a rede Wi-Fi, exibe a interface de controle no navegador, controla os movimentos da base e envia comandos pela comunicaçăo serial para o BlackBoard Uno.

O segundo código deve ser gravado no BlackBoard Uno. Ele recebe os comandos enviados pela BlackBoard Rocky e controla os dois servomotores dos braços e os dois displays dos olhos do Maker.

Código da BlackBoard Rocky

/************************************************************************************
 * Projeto: Maker Omnidirecional - Controle Web e Motores
 *
 * Autor: Alexandre Casemonstro        -      24/01/2026
 *
 * Placa: BlackBoard Rocky
 *
 * A BlackBoard Rocky fica responsavel por:
 * - Criar a rede Wi-Fi do robo;
 * - Disponibilizar a interface Web;
 * - Controlar os 3 motores da base omnidirecional;
 * - Receber os comandos dos botoes da pagina;
 * - Enviar comandos pela Serial para o BlackBoard Uno.
 *
 * O BlackBoard Uno fica responsavel por:
 * - Controlar os 2 displays redondos dos olhos;
 * - Controlar os 2 servomotores dos bracos.
 ************************************************************************************/

#include <WiFi.h>
#include <WebServer.h>
#include <RoboCore_Rocky.h>

RockyMotors motors;
WebServer server(80);

const char* AP_SSID = "Maker";
const char* AP_PASS = "Case007";

const int SPEED = 100;
const int DIAG_SPEED = SPEED / 1;
const uint32_t TEST_STEP_MS = 2000;
const uint32_t SERIAL_BAUD = 115200;

bool bracoDireitoAlto = false;
bool bracoEsquerdoAlto = false;

String ultimoMovimentoEnviado = "";
String ultimoBracoDireitoEnviado = "";
String ultimoBracoEsquerdoEnviado = "";

enum Command : uint8_t {
  CMD_NONE = 0,
  CMD_FWD,
  CMD_BACK,
  CMD_LEFT,
  CMD_RIGHT,
  CMD_FWD_LEFT,
  CMD_FWD_RIGHT,
  CMD_BACK_LEFT,
  CMD_BACK_RIGHT,
  CMD_ROT_CW,
  CMD_ROT_CCW
};

volatile Command activeCmd = CMD_NONE;

bool testRunning = false;
uint8_t testStep = 0;
uint32_t testStepStartMs = 0;

const char INDEX_HTML[] PROGMEM = R"HTML(
<!doctype html>
<html lang="pt-br">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
<title>Maker Controle</title>

<style>
*{box-sizing:border-box;}
body{margin:0;background:#111;color:#eee;font-family:Arial,Helvetica,sans-serif;overscroll-behavior:none;}
.wrap{min-height:100vh;display:grid;grid-template-columns:1fr auto 1fr;align-items:center;gap:24px;padding:16px;}
.left{height:100%;display:flex;align-items:flex-end;justify-content:flex-start;}
.center{display:flex;justify-content:center;align-items:center;}
.right{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:20px;}
.btn{background:#1f1f1f;border:2px solid #444;color:#eee;font-size:18px;font-weight:bold;display:flex;justify-content:center;align-items:center;cursor:pointer;user-select:none;touch-action:none;-webkit-user-select:none;}
.btn.active,.btn:active{background:#f3c600;border-color:#f3c600;color:#111;}
.btnTest{width:120px;height:48px;border-radius:12px;}
.dpad{width:280px;height:280px;display:grid;grid-template-columns:1fr 1fr 1fr;grid-template-rows:1fr 1fr 1fr;gap:10px;}
.upLeft{grid-column:1;grid-row:1;}
.up{grid-column:2;grid-row:1;}
.upRight{grid-column:3;grid-row:1;}
.leftBtn{grid-column:1;grid-row:2;}
.mid{grid-column:2;grid-row:2;opacity:.25;}
.rightBtn{grid-column:3;grid-row:2;}
.downLeft{grid-column:1;grid-row:3;}
.down{grid-column:2;grid-row:3;}
.downRight{grid-column:3;grid-row:3;}
.rotatePanel{display:flex;gap:16px;}
.ball{width:120px;height:120px;border-radius:50%;font-size:38px;}
.armPanel{width:240px;padding:14px;border:2px solid #333;border-radius:16px;background:#181818;}
.armTitle{text-align:center;font-size:20px;font-weight:bold;margin-bottom:14px;}
.armGroup{margin-bottom:16px;}
.armGroup:last-child{margin-bottom:0;}
.armLabel{text-align:center;margin-bottom:8px;font-size:16px;}
.armRow{display:grid;grid-template-columns:1fr 1fr;gap:10px;}
.armBtn{height:56px;border-radius:10px;}
@media(max-width:850px){
  .wrap{grid-template-columns:1fr;grid-template-rows:auto auto auto;justify-items:center;}
  .left{width:100%;justify-content:center;order:3;}
  .center{order:1;}
  .right{order:2;}
}
</style>
</head>

<body>
<div class="wrap">

  <div class="left">
    <div class="btn btnTest" id="btnTest">TESTE</div>
  </div>

  <div class="center">
    <div class="dpad">
      <div class="btn upLeft" id="btnFwdLeft">↖</div>
      <div class="btn up" id="btnFwd">▲</div>
      <div class="btn upRight" id="btnFwdRight">↗</div>
      <div class="btn leftBtn" id="btnLeft">◀</div>
      <div class="btn mid">●</div>
      <div class="btn rightBtn" id="btnRight">▶</div>
      <div class="btn downLeft" id="btnBackLeft">↙</div>
      <div class="btn down" id="btnBack">▼</div>
      <div class="btn downRight" id="btnBackRight">↘</div>
    </div>
  </div>

  <div class="right">
    <div class="rotatePanel">
      <div class="btn ball" id="btnRotCCW">↺</div>
      <div class="btn ball" id="btnRotCW">↻</div>
    </div>

    <div class="armPanel">
      <div class="armTitle">Braços</div>

      <div class="armGroup">
        <div class="armLabel">Braço direito</div>
        <div class="armRow">
          <div class="btn armBtn" id="btnArmRightUp">BD ▲</div>
          <div class="btn armBtn active" id="btnArmRightDown">BD ▼</div>
        </div>
      </div>

      <div class="armGroup">
        <div class="armLabel">Braço esquerdo</div>
        <div class="armRow">
          <div class="btn armBtn" id="btnArmLeftUp">BE ▲</div>
          <div class="btn armBtn active" id="btnArmLeftDown">BE ▼</div>
        </div>
      </div>
    </div>
  </div>

</div>

<script>
async function sendCommand(name,state){
  try{
    await fetch(`/cmd?name=${name}&state=${state}`,{cache:"no-store"});
  }
  catch(error){}
}

function bindMomentary(element,command){
  const press=event=>{
    event.preventDefault();
    element.classList.add("active");
    sendCommand(command,1);
  };

  const release=event=>{
    if(event){event.preventDefault();}
    element.classList.remove("active");
    sendCommand(command,0);
  };

  element.addEventListener("mousedown",press);
  element.addEventListener("mouseup",release);
  element.addEventListener("mouseleave",release);
  element.addEventListener("touchstart",press,{passive:false});
  element.addEventListener("touchend",release,{passive:false});
  element.addEventListener("touchcancel",release,{passive:false});
}

function setRightArmVisual(isUp){
  btnArmRightUp.classList.toggle("active",isUp);
  btnArmRightDown.classList.toggle("active",!isUp);
}

function setLeftArmVisual(isUp){
  btnArmLeftUp.classList.toggle("active",isUp);
  btnArmLeftDown.classList.toggle("active",!isUp);
}

function sendArmCommand(command,updateVisual){
  sendCommand(command,1);
  updateVisual();
}

bindMomentary(btnFwd,"FWD");
bindMomentary(btnBack,"BACK");
bindMomentary(btnLeft,"LEFT");
bindMomentary(btnRight,"RIGHT");
bindMomentary(btnFwdLeft,"FWD_LEFT");
bindMomentary(btnFwdRight,"FWD_RIGHT");
bindMomentary(btnBackLeft,"BACK_LEFT");
bindMomentary(btnBackRight,"BACK_RIGHT");
bindMomentary(btnRotCW,"ROT_CW");
bindMomentary(btnRotCCW,"ROT_CCW");

btnArmRightUp.onclick=()=>sendArmCommand("ARM_RIGHT_UP",()=>setRightArmVisual(true));
btnArmRightDown.onclick=()=>sendArmCommand("ARM_RIGHT_DOWN",()=>setRightArmVisual(false));
btnArmLeftUp.onclick=()=>sendArmCommand("ARM_LEFT_UP",()=>setLeftArmVisual(true));
btnArmLeftDown.onclick=()=>sendArmCommand("ARM_LEFT_DOWN",()=>setLeftArmVisual(false));

btnTest.onclick=()=>fetch("/teste?go=1",{cache:"no-store"});
</script>
</body>
</html>
)HTML";

void stopAll(){
  motors.setSpeedA(0);
  motors.setSpeedB(0);
  motors.setSpeedC(0);
}

void frente(){
  motors.setSpeedA(+SPEED);
  motors.setSpeedB(0);
  motors.setSpeedC(-SPEED);
}

void reh(){
  motors.setSpeedA(-SPEED);
  motors.setSpeedB(0);
  motors.setSpeedC(+SPEED);
}

void direita(){
  motors.setSpeedA(0);
  motors.setSpeedB(+DIAG_SPEED);
  motors.setSpeedC(-DIAG_SPEED);
}

void esquerda(){
  motors.setSpeedA(0);
  motors.setSpeedB(-DIAG_SPEED);
  motors.setSpeedC(+DIAG_SPEED);
}

void DiagFroDir(){
  motors.setSpeedA(-SPEED / 2);
  motors.setSpeedB(+SPEED);
  motors.setSpeedC(-SPEED / 2);
}

void DiagFroEsq(){
  motors.setSpeedA(+DIAG_SPEED);
  motors.setSpeedB(-DIAG_SPEED);
  motors.setSpeedC(0);
}

void DiagRehDir(){
  motors.setSpeedA(-DIAG_SPEED);
  motors.setSpeedB(+DIAG_SPEED);
  motors.setSpeedC(0);
}

void DiagRehEsq(){
  motors.setSpeedA(0);
  motors.setSpeedB(-DIAG_SPEED);
  motors.setSpeedC(+DIAG_SPEED);
}

void rotCW(){
  motors.setSpeedA(+SPEED);
  motors.setSpeedB(+SPEED);
  motors.setSpeedC(+SPEED);
}

void rotCCW(){
  motors.setSpeedA(-SPEED);
  motors.setSpeedB(-SPEED);
  motors.setSpeedC(-SPEED);
}

Command toCmd(String nome){
  if(nome=="FWD")return CMD_FWD;
  if(nome=="BACK")return CMD_BACK;
  if(nome=="LEFT")return CMD_LEFT;
  if(nome=="RIGHT")return CMD_RIGHT;
  if(nome=="FWD_LEFT")return CMD_FWD_LEFT;
  if(nome=="FWD_RIGHT")return CMD_FWD_RIGHT;
  if(nome=="BACK_LEFT")return CMD_BACK_LEFT;
  if(nome=="BACK_RIGHT")return CMD_BACK_RIGHT;
  if(nome=="ROT_CW")return CMD_ROT_CW;
  if(nome=="ROT_CCW")return CMD_ROT_CCW;
  return CMD_NONE;
}

bool comandoEhMovimento(Command comando){
  return comando != CMD_NONE;
}

void handleRoot(){
  server.send(200,"text/html; charset=utf-8",INDEX_HTML);
}

void handleCmd(){
  String nome=server.arg("name");
  String estado=server.arg("state");

  if(nome=="ARM_RIGHT_UP" && estado=="1"){
    bracoDireitoAlto=true;
    server.send(200,"text/plain","OK");
    return;
  }

  if(nome=="ARM_RIGHT_DOWN" && estado=="1"){
    bracoDireitoAlto=false;
    server.send(200,"text/plain","OK");
    return;
  }

  if(nome=="ARM_LEFT_UP" && estado=="1"){
    bracoEsquerdoAlto=true;
    server.send(200,"text/plain","OK");
    return;
  }

  if(nome=="ARM_LEFT_DOWN" && estado=="1"){
    bracoEsquerdoAlto=false;
    server.send(200,"text/plain","OK");
    return;
  }

  Command comando=toCmd(nome);

  if(!comandoEhMovimento(comando)){
    server.send(400,"text/plain","COMANDO INVALIDO");
    return;
  }

  if(estado=="1"){
    testRunning=false;
    activeCmd=comando;
  }
  else{
    if(activeCmd==comando){
      activeCmd=CMD_NONE;
    }
  }

  server.send(200,"text/plain","OK");
}

void handleTeste(){
  if(activeCmd==CMD_NONE){
    testRunning=true;
    testStep=0;
    testStepStartMs=millis();
  }

  server.send(200,"text/plain","OK");
}

void applyCommand(){
  stopAll();

  switch(activeCmd){
    case CMD_FWD: frente(); break;
    case CMD_BACK: reh(); break;
    case CMD_LEFT: esquerda(); break;
    case CMD_RIGHT: direita(); break;
    case CMD_FWD_RIGHT: DiagFroDir(); break;
    case CMD_FWD_LEFT: DiagFroEsq(); break;
    case CMD_BACK_RIGHT: DiagRehDir(); break;
    case CMD_BACK_LEFT: DiagRehEsq(); break;
    case CMD_ROT_CW: rotCW(); break;
    case CMD_ROT_CCW: rotCCW(); break;
    case CMD_NONE:
    default: break;
  }
}

void updateTest(){
  if(!testRunning){
    return;
  }

  if(activeCmd!=CMD_NONE){
    testRunning=false;
    stopAll();
    return;
  }

  if(millis()-testStepStartMs>TEST_STEP_MS){
    testStep++;
    testStepStartMs=millis();

    if(testStep>2){
      testRunning=false;
      stopAll();
      return;
    }
  }

  stopAll();

  if(testStep==0)motors.setSpeedA(+SPEED);
  if(testStep==1)motors.setSpeedB(+SPEED);
  if(testStep==2)motors.setSpeedC(+SPEED);
}

String nomeMovimentoAtual(){
  switch(activeCmd){
    case CMD_FWD: return "FWD";
    case CMD_BACK: return "BACK";
    case CMD_LEFT: return "LEFT";
    case CMD_RIGHT: return "RIGHT";
    case CMD_FWD_LEFT: return "FWD_LEFT";
    case CMD_FWD_RIGHT: return "FWD_RIGHT";
    case CMD_BACK_LEFT: return "BACK_LEFT";
    case CMD_BACK_RIGHT: return "BACK_RIGHT";
    case CMD_ROT_CW: return "ROT_CW";
    case CMD_ROT_CCW: return "ROT_CCW";
    case CMD_NONE:
    default: return "STOP";
  }
}

void enviarMovimentoArduino(const String &movimento){
  Serial.print("MOV:");
  Serial.println(movimento);
}

void enviarBracoDireitoArduino(bool alto){
  Serial.print("ARM_R:");
  Serial.println(alto ? "UP" : "DOWN");
}

void enviarBracoEsquerdoArduino(bool alto){
  Serial.print("ARM_L:");
  Serial.println(alto ? "UP" : "DOWN");
}

void atualizarComunicacaoArduino(){
  String movimentoAtual=nomeMovimentoAtual();
  String estadoDireito=bracoDireitoAlto ? "UP" : "DOWN";
  String estadoEsquerdo=bracoEsquerdoAlto ? "UP" : "DOWN";

  if(movimentoAtual!=ultimoMovimentoEnviado){
    enviarMovimentoArduino(movimentoAtual);
    ultimoMovimentoEnviado=movimentoAtual;
  }

  if(estadoDireito!=ultimoBracoDireitoEnviado){
    enviarBracoDireitoArduino(bracoDireitoAlto);
    ultimoBracoDireitoEnviado=estadoDireito;
  }

  if(estadoEsquerdo!=ultimoBracoEsquerdoEnviado){
    enviarBracoEsquerdoArduino(bracoEsquerdoAlto);
    ultimoBracoEsquerdoEnviado=estadoEsquerdo;
  }
}

void enviarEstadoInicialArduino(){
  ultimoMovimentoEnviado="";
  ultimoBracoDireitoEnviado="";
  ultimoBracoEsquerdoEnviado="";
  atualizarComunicacaoArduino();
}

void imprimirDadosDaRede(){
  Serial.println("--------------------------------------------------");
  Serial.println("DADOS DA REDE DO ROBO");
  Serial.print("Nome da rede: ");
  Serial.println(AP_SSID);
  Serial.print("Senha: ");
  Serial.println(AP_PASS);
  Serial.print("IP para acessar o controle: ");
  Serial.println(WiFi.softAPIP());
  Serial.println("--------------------------------------------------");
}

void setup(){
  Serial.begin(SERIAL_BAUD);
  delay(1000);

  WiFi.mode(WIFI_AP);
  WiFi.softAP(AP_SSID,AP_PASS);

  imprimirDadosDaRede();

  server.on("/",handleRoot);
  server.on("/cmd",handleCmd);
  server.on("/teste",handleTeste);
  server.begin();

  stopAll();
  activeCmd=CMD_NONE;

  enviarEstadoInicialArduino();
}

void loop(){
  server.handleClient();
  updateTest();

  if(!testRunning){
    applyCommand();
  }

  atualizarComunicacaoArduino();
}

Conexăo entre BlackBoard Rocky e BlackBoard Uno — Conexăo entre a BlackBoard Rocky e o BlackBoard Uno usando conversor de nível lógico.

Código do BlackBoard Uno

/************************************************************************************
 * Projeto: Maker Omnidirecional - Olhos e Bracos
 *
 * Autor: Alexandre Casemonstro        -      24/01/2026
 *
 * Placa: BlackBoard Uno R3 
 *
 * Este codigo faz parte do projeto Maker Omnidirecional.
 *
 * A BlackBoard Rocky fica responsavel por:
 * - Criar a rede Wi-Fi;
 * - Disponibilizar a interface Web;
 * - Controlar os motores da base omnidirecional;
 * - Enviar comandos pela Serial para o BlackBoard Uno.
 *
 * O BlackBoard Uno fica responsavel por:
 * - Controlar os 2 displays redondos dos olhos;
 * - Controlar os 2 servomotores dos bracos;
 * - Receber comandos pela Serial;
 * - Alterar as expressoes dos olhos conforme o movimento do robo;
 * - Levantar e abaixar os bracos conforme os botoes da interface.
 *
 * Comunicacao:
 * - Baud rate: 115200
 * - Comandos recebidos:
 *
 *   MOV:FWD
 *   MOV:BACK
 *   MOV:LEFT
 *   MOV:RIGHT
 *   MOV:FWD_LEFT
 *   MOV:FWD_RIGHT
 *   MOV:BACK_LEFT
 *   MOV:BACK_RIGHT
 *   MOV:ROT_CW
 *   MOV:ROT_CCW
 *   MOV:STOP
 *
 *   ARM_R:UP
 *   ARM_R:DOWN
 *   ARM_L:UP
 *   ARM_L:DOWN
 *
 * Observacao importante:
 * Como os dois displays dos olhos estao ligados em paralelo,
 * ambos exibem a mesma expressao ao mesmo tempo.
 ************************************************************************************/

/************************************************************************************
 * BIBLIOTECAS NECESSARIAS
 *
 * Instale pela IDE Arduino:
 *
 * 1. Adafruit GFX Library
 *    Biblioteca grafica base utilizada pelos displays.
 *
 * 2. Adafruit GC9A01A
 *    Biblioteca especifica para o display redondo GC9A01A.
 *
 * 3. Servo
 *    Biblioteca usada para controlar os servomotores SG90.
 ************************************************************************************/

#include <SPI.h>
#include <Servo.h>
#include <Adafruit_GFX.h>
#include <Adafruit_GC9A01A.h>

// ==================================================================================
// PINOS DOS DISPLAYS
//
// Os dois displays GC9A01A estao ligados em paralelo.
// Isso significa que os dois recebem os mesmos sinais e exibem a mesma imagem.
// ==================================================================================

#define TFT_CS   10
#define TFT_DC   9
#define TFT_RST  8
#define TFT_BL   7

// ==================================================================================
// PINOS DOS SERVOMOTORES
// ==================================================================================

#define SERVO_BRACO_DIREITO   5
#define SERVO_BRACO_ESQUERDO  6

// ==================================================================================
// OBJETOS
// ==================================================================================

Adafruit_GC9A01A tft(TFT_CS, TFT_DC, TFT_RST);

Servo servoDireito;
Servo servoEsquerdo;

// ==================================================================================
// AJUSTE DOS ANGULOS DOS BRACOS
//
// Cada braco se move apenas cerca de 35 graus.
// Ajuste estes valores conforme a posicao fisica dos servos na montagem.
//
// Dica:
// - Se o braco subir quando deveria descer, inverta os valores UP e DOWN.
// - Se o movimento estiver forcando a peca impressa, reduza a diferenca dos angulos.
// ==================================================================================

const int DIR_DOWN = 90;
const int DIR_UP   = 125;

const int ESQ_DOWN = 90;
const int ESQ_UP   = 55;

// ==================================================================================
// VARIAVEIS DE CONTROLE
// ==================================================================================

String linhaSerial = "";
String movimentoAtual = "STOP";

unsigned long ultimoPisca = 0;
bool piscando = false;

// ==================================================================================
// DESENHA UM SIMBOLO NO DISPLAY
//
// Como os dois displays estao em paralelo, essa funcao desenha o mesmo simbolo
// nos dois olhos ao mesmo tempo.
// ==================================================================================

void desenharOlho(const char* simbolo) {

  tft.fillScreen(GC9A01A_BLACK);

  tft.setTextColor(GC9A01A_CYAN);
  tft.setTextSize(8);

  int16_t x1, y1;
  uint16_t w, h;

  tft.getTextBounds(simbolo, 0, 0, &x1, &y1, &w, &h);

  int x = (240 - w) / 2;
  int y = (240 - h) / 2;

  tft.setCursor(x, y);
  tft.print(simbolo);
}

// ==================================================================================
// EXPRESSOES DOS OLHOS
// ==================================================================================

void expressaoNormal() {

  // Olhos abertos: 0 0
  desenharOlho("0");
}

void expressaoPiscando() {

  // Olhos piscando: - -
  desenharOlho("-");
}

void expressaoSurpreso() {

  // Olhos surpresos: O O
  desenharOlho("O");
}

void expressaoFeliz() {

  // Olhos felizes: ^ ^
  desenharOlho("^");
}

void expressaoEsquerda() {

  // Olhando para um lado: < <
  desenharOlho("<");
}

void expressaoDireita() {

  // Olhando para o outro lado: > >
  desenharOlho(">");
}

// ==================================================================================
// MOVIMENTO DOS BRACOS
// ==================================================================================

void bracoDireitoAlto() {

  servoDireito.write(DIR_UP);
}

void bracoDireitoBaixo() {

  servoDireito.write(DIR_DOWN);
}

void bracoEsquerdoAlto() {

  servoEsquerdo.write(ESQ_UP);
}

void bracoEsquerdoBaixo() {

  servoEsquerdo.write(ESQ_DOWN);
}

// ==================================================================================
// TRATA COMANDOS DE MOVIMENTO RECEBIDOS DA BLACKBOARD ROCKY
//
// A BlackBoard Rocky envia comandos no formato:
//
// MOV:NOME_DO_MOVIMENTO
//
// Exemplo:
// MOV:FWD
// MOV:LEFT
// MOV:STOP
// ==================================================================================

void tratarMovimento(String mov) {

  movimentoAtual = mov;

  if (mov == "LEFT") {

    expressaoEsquerda();
  }
  else if (mov == "RIGHT") {

    expressaoDireita();
  }
  else if (mov == "ROT_CW" || mov == "ROT_CCW") {

    expressaoSurpreso();
  }
  else if (mov == "STOP") {

    expressaoNormal();
  }
  else {

    expressaoFeliz();
  }
}

// ==================================================================================
// TRATA QUALQUER COMANDO RECEBIDO PELA SERIAL
//
// Comandos esperados:
//
// MOV:...
// ARM_R:UP
// ARM_R:DOWN
// ARM_L:UP
// ARM_L:DOWN
// ==================================================================================

void tratarComando(String comando) {

  comando.trim();

  if (comando.startsWith("MOV:")) {

    tratarMovimento(comando.substring(4));
  }
  else if (comando == "ARM_R:UP") {

    bracoDireitoAlto();
  }
  else if (comando == "ARM_R:DOWN") {

    bracoDireitoBaixo();
  }
  else if (comando == "ARM_L:UP") {

    bracoEsquerdoAlto();
  }
  else if (comando == "ARM_L:DOWN") {

    bracoEsquerdoBaixo();
  }
}

// ==================================================================================
// LEITURA DA SERIAL
//
// O comando e montado caractere por caractere.
// Quando chega uma quebra de linha '\n', o comando e interpretado.
// ==================================================================================

void lerSerial() {

  while (Serial.available()) {

    char c = Serial.read();

    if (c == '\n') {

      tratarComando(linhaSerial);

      linhaSerial = "";
    }
    else if (c != '\r') {

      linhaSerial += c;
    }
  }
}

// ==================================================================================
// PISCADA AUTOMATICA
//
// Quando o robo esta parado, os olhos piscam automaticamente de tempos em tempos.
// Durante o movimento, a expressao e definida pelo comando recebido.
// ==================================================================================

void piscarAutomatico() {

  if (movimentoAtual != "STOP") {

    return;
  }

  unsigned long agora = millis();

  if (!piscando && agora - ultimoPisca > 3500) {

    piscando = true;
    ultimoPisca = agora;

    expressaoPiscando();
  }

  if (piscando && agora - ultimoPisca > 180) {

    piscando = false;
    ultimoPisca = agora;

    expressaoNormal();
  }
}

// ==================================================================================
// SETUP
// ==================================================================================

void setup() {

  // Inicia a comunicacao serial com a BlackBoard Rocky.
  Serial.begin(115200);

  // Liga a iluminacao de fundo dos displays.
  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);

  // Inicia o display GC9A01A.
  tft.begin();
  tft.setRotation(0);

  // Expressao inicial.
  expressaoNormal();

  // Conecta os servomotores aos pinos definidos.
  servoDireito.attach(SERVO_BRACO_DIREITO);
  servoEsquerdo.attach(SERVO_BRACO_ESQUERDO);

  // Posicao inicial dos bracos.
  bracoDireitoBaixo();
  bracoEsquerdoBaixo();
}

// ==================================================================================
// LOOP
// ==================================================================================

void loop() {

  // Verifica se chegou algum comando da BlackBoard Rocky.
  lerSerial();

  // Faz os olhos piscarem automaticamente quando o robo esta parado.
  piscarAutomatico();
}

Boas práticas

Teste os movimentos dos braços antes de fechar o corpo do Maker.
Limite o curso dos servos para evitar esforço nas peças impressas.
Verifique se os cabos dos displays e servos năo interferem no movimento da base.
Teste os movimentos do robô com ele suspenso antes de colocá-lo no chăo.
Confira se a alimentaçăo suporta os motores, displays e servos funcionando juntos.
Use o tutorial anterior como referência para a montagem da base omnidirecional.