Rodas Omnidirecionais

This tutorial is not available in English

Robô Omnidirecional

O projeto Robô Omnidirecional nasceu da proposta de explorar, de forma visual e conceitual, as possibilidades de movimento proporcionadas pelas rodas omnidirecionais. Utilizando uma base triangular e três rodas omni, o robô é capaz de se deslocar em múltiplas direçơes sem a necessidade de alterar sua orientaçăo.

O robô foi concebido como uma plataforma de testes. Seu objetivo principal é permitir que o usuário observe, experimente e se divirta com os diferentes tipos de movimento possíveis, servindo também como base para projetos futuros mais complexos.

A estrutura do robô é totalmente fechada, com aproximadamente 10 cm de altura quando montado. Cada vértice da base triangular abriga uma roda omnidirecional, garantindo estabilidade e liberdade de movimento.

Visăo geral do robô

Robô Omnidirecional (vista superior) — Robô Omnidirecional

Funcionamento geral

O robô é controlado via interface web, acessível por navegador em celular ou computador. Os movimentos săo momentâneos, ocorrendo apenas enquanto o botăo correspondente estiver pressionado.

O projeto prioriza a demonstraçăo visual dos movimentos, especialmente os deslocamentos diagonais e os giros no próprio eixo, todos executados em velocidade fixa.

Ao ligar o robô, ele cria automaticamente uma rede Wi-Fi própria. Para evitar que o celular tente alternar para a internet do chip durante o uso, desative os dados móveis e conecte-se diretamente à rede do robô.

Rede Wi-Fi: ROCKY_CONTROLE
Senha: 12345678
Endereço para acesso: http://192.168.4.1
Tempo médio para a rede aparecer: ~5 segundos após ligar
Internet: năo é necessário (o controle funciona apenas conectado à rede do robô)

Ligaçơes elétricas

A montagem foi pensada para ficar limpa e fácil de replicar. O próprio corpo impresso do robô possui, internamente, marcaçơes nos cantos indicando as posiçơes A, B e C. Assim, basta posicionar cada motor no canto correspondente e conectar na porta correta da BlackBoard Rocky.

Motor A - Porta A da BlackBoard Rocky
Motor B - Porta B da BlackBoard Rocky
Motor C - Porta C da BlackBoard Rocky

A alimentaçăo é feita por um pack de bateria Li-Ion 7,4 V conectado à BlackBoard Rocky. Um dos fios da bateria vai direto para a alimentaçăo da placa, enquanto o outro passa por uma chave liga/desliga (chave gangorra) instalada no próprio corpo do robô. A partir da placa, a BlackBoard Rocky é responsável por alimentar e controlar os motores.

A ligaçăo na placa é feita com cabo. O corpo do robô já foi modelado com o encaixe para a chave gangorra.

Rodas Omnidirecionais

As rodas omnidirecionais săo o elemento central deste projeto e săo responsáveis pela liberdade de movimento do robô. Elas permitem que o robô deslize lateralmente graças aos pequenos tambores distribuídos ao redor da roda.

Cada roda omnidirecional é constituída por:

14 pequenos tambores
2 plataformas estruturais, cada uma responsável por fixar 7 tambores
1 conector central, responsável por acoplar a roda ao eixo do motor

Cada pequeno tambor possui em seu interior um pequeno prego de aço. Esse prego foi cortado ligeiramente maior que o comprimento do tambor, sendo fixado na base para garantir alinhamento e rigidez.

Após a fixaçăo do prego, foi utilizada uma caneta 3D para fechar o encaixe do tambor, impedindo que o pino se solte durante o uso. Esse cuidado reduz vibraçơes, melhora a eficiência do movimento e aumenta a durabilidade da roda.

Pinos e parafusos usados na roda

Para montar os tambores da roda, foi utilizado um prego de aço comum (o mesmo tipo usado em acabamento de portas de madeira), facilmente encontrado em loja de material de construçăo. A cabeça do prego é removida e o corpo é cortado no comprimento correto.

Pino (eixo) dos tambores: prego de aço com 1,7 mm de diâmetro
Comprimento do pino: entre 18,8 mm e 20 mm

Na montagem da roda, săo utilizados parafusos e porcas M3, sem necessidade de arruelas.

Rodas: 9 parafusos M3 x 22 mm + 9 porcas M3
Tampa: 3 parafusos M3 x 15 mm + 3 porcas M3 (estas porcas săo coladas na tampa, em encaixes já previstos no modelo)
Motores: fixaçăo com parafusos M3 x 25 mm

Detalhes da roda omnidirecional

Roda omnidirecional - vista em perspectiva — Roda omnidirecional (detalhes de montagem)

Lista de materiais

1x BlackBoard Rocky
3x Motor DC 3-6 V com caixa de reduçăo
Os encaixes do projeto săo compatíveis tanto com o motor amarelo quanto com o motor azul com engrenagens metálicas. Ambos funcionam corretamente no robô.
1x Pack de bateria Li-Ion 7,4 V 2500 mAh com BMS
1x Chave gangorra (liga/desliga) KCD1-101-2T
1x Mini carregador para bateria de lítio 2S
Este carregador é indicado para baterias 2S (7,4 V). Para carregar, remova o pack do robô e conecte diretamente no carregador.
1x Fonte chaveada 9 V 1 A
Utilizada para alimentar o carregador 2S durante o carregamento do pack de bateria.
3x Rodas omnidirecionais (impressas em 3D)
É possível imprimir o robô e as rodas usando apenas um rolo de filamento. Caso queira economizar, imprima tudo na mesma cor.
Filamento PLA Creality Prateado
Todo o projeto foi impresso em PLA.
Cabo JST-RCY 2 pinos
Cabo adaptador que eh fixo na Rock.

Arquivos para impressăo 3D

Use o botăo abaixo para fazer o download do arquivo STL/3mf do Robô e da roda omnidirecional.

Arquivo STL Roda Omnidirecional (.zip)

Corpo Do Robo

Configuraçơes de impressăo 3D

Para equilibrar resistência, peso e economia de material, algumas partes do projeto foram impressas com configuraçơes diferentes. Os pequenos tambores foram feitos com preenchimento total para aumentar rigidez e reduzir vibraçăo, enquanto as demais peças usam preenchimento moderado.

Material: PLA
Tambores (rolinhos): 100% de preenchimento
Demais peças: 15% de preenchimento
Camadas de tampa/perímetro: 3 camadas

Um rolo de filamento foi suficiente para imprimir o robô e as rodas.

Código

O código do projeto foi desenvolvido com foco em clareza e reutilizaçăo, servindo como base para testes de movimento omnidirecional. A estrutura permite fácil adaptaçăo para novos robôs e futuras expansơes.

O controle é feito via navegador: conecte-se à rede Wi-Fi do robô (ROCKY_CONTROLE) e acesse o endereço 192.168.4.1. Os botơes săo momentâneos, ou seja, o movimento ocorre apenas enquanto o botăo estiver pressionado.

/************************************************************************************
 * Projeto: Controle Web (Momentâneo) ? BlackBoard Rocky (ESP32) - Motores A/B/C
 *
 * Autor: Alexandre Casemonstro        -      24/01/2026 
 *
 * Baseado no código original:
 *   "Motors_3x.ino" - Francois (RoboCore) - 17/01/2024
 *
 * Confirmado no robô:
 * Frente: A +100 | B 0 | C -100
 * Ré: A -100 | B 0 | C +100
 * Direita: A 0 | B +DIAG_SPEED | C -DIAG_SPEED
 * Esquerda: A 0 | B -DIAG_SPEED | C +DIAG_SPEED
 * DiagFroDir: A -50 | B +100 | C -50
 * DiagFroEsq: A +DIAG_SPEED | B -DIAG_SPEED | C 0
 * DiagRehDir: A -DIAG_SPEED | B +DIAG_SPEED | C 0
 * DiagRehEsq: A 0 | B -DIAG_SPEED | C +DIAG_SPEED
 *
 * Em sua construcao sera necessarios Ajuste Manuais, porem deixei bem comentado, para facilitar.
 * Direita /Esquerda, controlando sentido de cada motor e velocidade
 ************************************************************************************/

// ==================================================================================
// APRESENTACAO (int e tudo feito sem precisar criar Void)
// ==================================================================================

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

// ==================================================
// Objetos
RockyMotors motors;
WebServer server(80);

// ==================================================
// Wi-Fi (AP)
const char* AP_SSID = "ROCKY_CONTROLE";
const char* AP_PASS = "12345678";

// ==================================================
// Configuraçơes
const int SPEED = 100;
const int DIAG_SPEED = SPEED / 1;     // <<< NOVO: diagonais pela metade
const uint32_t TEST_STEP_MS = 2000;

// ==================================================
// Comandos
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;

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

// ==================================================
// HTML
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">
<title>Rocky Controle</title>
<style>
body{margin:0;background:#111;font-family:Arial;color:#eee;}
.wrap{height:100vh;display:grid;grid-template-columns:1fr 1fr 1fr;align-items:center;}
.left{height:100%;display:flex;align-items:flex-end;padding:16px;}
.center{display:flex;justify-content:center;}
.right{display:flex;flex-direction:column;align-items:center;gap:14px;}

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

.ball{width:120px;height:120px;border-radius:50%;font-size:28px;}

.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;}
</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 style="display:flex;gap:16px">
      <div class="btn ball" id="btnRotCCW">?</div>
      <div class="btn ball" id="btnRotCW">?</div>
    </div>
  </div>

</div>

<script>
async function sendCmd(c,s){
  fetch(`/cmd?name=${c}&state=${s}`).catch(()=>{});
}
function bind(el,c){
  el.onmousedown=e=>{e.preventDefault();sendCmd(c,1);}
  el.onmouseup=e=>{e.preventDefault();sendCmd(c,0);}
  el.onmouseleave=e=>sendCmd(c,0);
  el.ontouchstart=e=>{e.preventDefault();sendCmd(c,1);}
  el.ontouchend=e=>{e.preventDefault();sendCmd(c,0);}
}

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

btnTest.onclick=()=>fetch("/teste?go=1");
</script>
</body>
</html>
)HTML";

// ==================================================================================
// COMPLEMENTO (void setup)
// ==================================================================================

void setup(){
  WiFi.mode(WIFI_AP);
  WiFi.softAP(AP_SSID,AP_PASS);
  server.on("/",handleRoot);
  server.on("/cmd",handleCmd);
  server.on("/teste",handleTeste);
  server.begin();
  stopAll();
}

// ==================================================================================
// FUNCOES (void Loop + voids necessarias)
// ==================================================================================

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

// ==================================================
// 8 MOVIMENTOS (calibracao manual motor a motor)
//
// Em cada funcao voce pode mudar:
// - Sentido do giro (sinal): + ou -
// - Velocidade (valor): 0 ate SPEED
// ==================================================

// ==================================================
// Frente
void frente(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(+SPEED);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(0);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(-SPEED);
}

// ==================================================
// Reh
void reh(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(-SPEED);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(0);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(+SPEED);
}

// ==================================================
// Direita
void direita(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(0);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(+DIAG_SPEED);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(-DIAG_SPEED);

}

// ==================================================
// Esquerda
void esquerda(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(0);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(-DIAG_SPEED);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(+DIAG_SPEED);
}

// ==================================================
// Diagonal Frontal Direita = DiagFroDir
void DiagFroDir(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(-SPEED/2);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(+SPEED);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(-SPEED/2);
}

// ==================================================
// Diagonal Frontal Esquerda = DiagFroEsq
void DiagFroEsq(){
  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(+DIAG_SPEED);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(-DIAG_SPEED);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(0);
}

// ==================================================
// Diagonal Reh Direita = DiagRehDir
void DiagRehDir(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(-DIAG_SPEED);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(+DIAG_SPEED);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(0);
}

// ==================================================
// Diagonal Reh Esquerda = DiagRehEsq
void DiagRehEsq(){

  // Motor A
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedA(0);

  // Motor B
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedB(-DIAG_SPEED);

  // Motor C
  // Sentido: + ou -
  // Velocidade: 0 ate SPEED
  motors.setSpeedC(+DIAG_SPEED);
}

// ==================================================
// Giro (mantido)
void rotCW(){
  motors.setSpeedA(+SPEED);
  motors.setSpeedB(+SPEED);
  motors.setSpeedC(+SPEED);
}
void rotCCW(){
  motors.setSpeedA(-SPEED);
  motors.setSpeedB(-SPEED);
  motors.setSpeedC(-SPEED);
}

// ==================================================
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;
    default: break;
  }
}

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

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

void handleCmd(){
  Command c = toCmd(server.arg("name"));
  if(server.arg("state")=="1"){ testRunning=false; activeCmd=c; }
  else if(activeCmd==c) 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 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);
}

// ==================================================
void loop(){
  server.handleClient();
  updateTest();
  if(!testRunning) applyCommand();
}

Boas práticas

Dica, interface web super minimalista, intuitiva, aceita um comando por vez

Interface Web — Roda omnidirecional (detalhes de montagem)

Fixar corretamente os motores e rodas
Garantir alinhamento adequado das rodas omnidirecionais
Organizar bem os cabos internos
Testar os movimentos com o robô suspenso antes do uso no solo
Utilizar bateria adequada para os motores DC
Para carregar o pack, remova a bateria do robô e conecte no mini carregador 2S