Robôs Autônomos para Armazéns Inteligentes: Integração Arduino e Motores BLDC

O desenvolvimento de protótipos de robôs móveis autônomos (AMR) para logística moderna e armazenamento inteligente pode ser efetivamente demonstrado com sistemas baseados em motores BLDC (Brushless DC) e controle via Arduino. Embora aplicações industriais robustas frequentemente empreguem controladores mais sofisticados, como ROS em conjunto com PLCs, a abordagem com Arduino oferece um caminho acessível para educação, automação em pequenas e médias empresas, e prototipagem ágil. Este documento explora os atributos cruciais, cenários de uso típicos e considerações técnicas essenciais para tais sistemas.

Características Fundamentais

Sistema de Propulsão de Alta Eficiência e Durabilidade

  • Vantagens dos Motores BLDC: Oferecem eficiências de 85% a 90%, superando motores com escovas, resultando em economia de energia em operações de armazém com partidas e paradas frequentes. São caracterizados por baixa dissipação de calor, mínima necessidade de manutenção e vida útil prolongada, adequando-se a ciclos operacionais contínuos.
  • Versatilidade de Movimento: Podem ser combinados com redutores planetários ou integrados em rodas motorizadas para movimentar bases mecanum ou diferenciais, permitindo deslocamento omnidirecional ou giros precisos.
  • Resposta Dinâmica: Suportam controle de velocidade via PWM ou FOC (Controle Vetorial de Campo), essencial para manobras ágeis de desvio de obstáculos e rastreamento de rota em corredores estreitos.

Capacidades Robustas de Identificação e Rastreamento de Cargas

  • Identificação por Tags: Leitura de etiquetas eletrônicas em paletes ou caixas usando RFID (UHF/HF), ou escaneamento de códigos QR/barras com câmeras ou módulos dedicados (ex: Zebra SE4500).
  • Visão Auxiliar (para Prototipagem Avançada): Emprego de OpenMV ou ESP32-CAM para reconhecimento de cores ou formas, auxiliando na localização de itens sem etiquetas.
  • Associação de Dados: O sistema Arduino vincula as informações de identificação com coordenadas de posição, enviando-as para um banco de dados local ou plataforma em nuvem.

Arquitetura para Navegação e Localização Interna

  • Estratégias de Posicionamento Custo-Benefício:
    • Navegação Guiada: Uso de fitas magnéticas ou coloridas no chão, com sensores Hall para detecção de caminho.
    • Marcos Visuais: Emprego de códigos QR fixados no teto ou chão, com câmeras para calibração periódica da pose do robô.
    • Fusão de Sensores Avançada: Combinação de UWB (Ultra-Wideband) ou ultrassom com IMU (Unidade de Medição Inercial) para precisão de ±10 cm (requer microcontroladores de maior desempenho como Teensy ou ESP32).
    • Odometria: Estimativa de deslocamento a partir de encoders dos motores BLDC ou feedback da velocidade da roda, complementada por uma IMU (ex: MPU6050) para compensar desvios.

Modularidade da Plataforma Arduino e Expansibilidade de Comunicação

  • Escolha do Microcontrolador:
    • Arduino Mega 2560: Ideal para múltiplos periféricos (RFID, GPS, Bluetooth) devido às suas múltiplas portas seriais.
    • ESP32: Inclui Wi-Fi/Bluetooth integrados, suportando protocolos como MQTT para transmissão do estado da carga a um WMS (Sistema de Gerenciamento de Armazém).
    • Teensy 4.1: Oferece alta performance em tempo real, adequada para aquisição síncrona de múltiplos sensores.
  • Conectividade Industrial: Suporte a protocolos como Modbus RTU, CAN e RS485 (via shields de expansão), permitindo integração com sensores de prateleira ou mecanismos de elevação.

Cenários Típicos de Implementação

  1. Coleta e Reposição Automatizadas em Armazéns de Pequeno a Médio Porte: O robô opera com base em instruções do WMS, transportando mercadorias de prateleiras designadas para áreas de embalagem. Adequado para ambientes com poucos SKUs e áreas de até 500 m², como centros de distribuição para e-commerce, farmácias ou depósitos de autopeças.
  2. Logística Interna em Linhas de Produção: Entrega de matérias-primas aos postos de trabalho em sincronia com o ritmo de produção. A operação silenciosa dos motores BLDC é vantajosa em ambientes de montagem sensíveis ao ruído.
  3. Plataformas de Treinamento em Automação Logística para Instituições de Ensino: Permite que estudantes programem algoritmos de planejamento de rota (A*, Dijkstra), alocação de tarefas para múltiplos robôs e gestão de enformações de carga (SQLite com cartão SD). Representa uma alternativa de baixo custo aos AMRs comerciais, ideal para propósitos educacionais.
  4. Sistemas Demonstrativos para Armazéns Temporários ou Feiras: Implantação rápida de unidades móveis para rastreamento de cargas, utilizadas em demonstrações de conceitos de logística inteligente. Possibilita o monitoramento em tempo real da posição e status da carga via aplicativo móvel.

Considerações Essenciais para o Desenvolvimento

  1. Capacidade de Processamento e Limitações em Tempo Real do Arduino:
    • Microcontroladores padrão como Arduino Uno são insuficientes para tarefas complexas como SLAM, planejamento de rota avançado ou fusão de múltiplos sensores.
    • Recomendação: Simplificar algoritmos de localização (ex: correção por QR code + odometria) e delegar tarefas de alta carga computacional (como reconhecimento de imagem) a coprocessadores (ex: Raspberry Pi Zero), utilizando o Arduino apenas para controle de movimento de baixo nível.
  2. Gestão de Alimentação e Drivers BLDC:
    • Compatibilidade do Driver: Para motores BLDC tipo hub, são necessários ESCs (Controladores Eletrônicos de Velocidade) ou drivers FOC (ex: SimpleFOC Shield). É crucial assegurar a compatibilidade da frequência PWM com o ESC (geralmente 20–30 kHz).
    • Projeto da Alimentação: Recomenda-se um pack de baterias de lítio de 24V (ex: 6S LiFePO₄) com capacidade de 10 Ah ou superior. Implementar um BMS (Sistema de Gerenciamento de Bateria) para prevenir descarga excessiva e utilizar reguladores de tensão independentes para os motores e a lógica de controle do Arduino, evitando reinícios por quedas de tensão.
  3. Adaptação Ambiental e Precisão da Localização:
    • Fatores como reflexos no piso, poeira e variações de iluminação podem comprometer a precisão da localização visual ou via QR code.
    • Estratégias de Melhoria: Empregar fusão de múltiplas fontes (ex: UWB + odometria + QR codes), configurar pontos de recalibração para corrigir o erro acumulado e instalar sensores infravermelhos/ultrassônicos em pontos-chave para auxiliar no alinhamento.
  4. Confiabilidade na Identificação de Cargas:
    • RFID pode sofrer interferência de metais e líquidos, exigindo o uso de etiquetas anti-metal.
    • Códigos QR devem ser protegidos contra sujeira e obstruções, e é aconselhável o uso de códigos com tolerância a falhas, como Data Matrix.
    • O reconhecimento visual tem seu desempenho drasticamente reduzido em condições de baixa luminosidade, necessitando de iluminação suplementar ou câmeras infravermelhas.
  5. Segurança e Interação Humano-Robô:
    • É imperativa a integração de sistemas como LiDAR (ex: RPLIDAR A1) ou arrays de ultrassom para detecção dinâmica de obstáculos.
    • Instalar botões de parada de emergência e sistemas de alarme visual/sonoro.
    • Implementar limites de velocidade diferenciados para operação com e sem carga.
    • Garantir a conformidade com os requisitos básicos da norma ISO 3691-4:2020 para segurança de veículos industriais.
  6. Estabilidade da Comunicação e Integridade dos Dados:
    • A comunicação Wi-Fi em ambientes com estantes metálicas pode resultar em perda de pacotes.
    • Alternativas e Melhorias: Utilizar LoRa ou Zigbee como canais de comunicação de backup, implementar cache local para filas de tarefas com retransmissão automática após a recuperação da rede, e adicionar verificação CRC para atualizações de status de carga a fim de evitar corrupção de dados.

Os seguintes exemplos ilustram abordagens com Arduino e motores BLDC, servindo como ponto de partida para o desenvolvimento de sistemas de automação em armazéns. Eles foram reestruturados para demonstrar princípios técnicos sem replicar diretamente os códigos originais.

Exemplo 1: Robô AMR com Navegação por Odometria e Sensores Ultrassônicos

#include <Arduino.h>
#include <NewPing.h> // Para sensores ultrassônicos
#include <Adafruit_MotorShield.h> // Biblioteca para o Adafruit Motor Shield V2

// Configurações do sensor ultrassônico
#define PINO_TRIGGER_US 7
#define PINO_ECHO_US 8
#define DISTANCIA_MAX_CM 200 
NewPing sensorDistancia(PINO_TRIGGER_US, PINO_ECHO_US, DISTANCIA_MAX_CM);

// Configurações da ponte H/shield do motor
// O Adafruit Motor Shield V2 usa o endereço I2C 0x60 por padrão
Adafruit_MotorShield escudosMotores = Adafruit_MotorShield(0x60);
Adafruit_DCMotor *motorEsquerdo = escudosMotores.getMotor(1);
Adafruit_DCMotor *motorDireito = escudosMotores.getMotor(2);

// Posição estimada e orientação do robô
float posX_global = 0.0f; 
float posY_global = 0.0f;
float anguloOrientacaoRad = 0.0f; // Em radianos

// Constantes para controle
const int VELOCIDADE_PADRAO = 150; // 0-255
const int LIMITE_OBSTACULO_CM = 30; // Distância mínima para evitar obstáculo
const unsigned long INTERVALO_CONTROLE_MS = 100; // Período de atualização do controle

void pararMotores() {
  motorEsquerdo->run(RELEASE);
  motorDireito->run(RELEASE);
}

void girar(int direcao) { // direcao: 1 para direita, -1 para esquerda
  motorEsquerdo->setSpeed(VELOCIDADE_PADRAO);
  motorDireito->setSpeed(VELOCIDADE_PADRAO);
  if (direcao == 1) { // Virar para a direita (motor esquerdo para frente, direito para trás)
    motorEsquerdo->run(FORWARD);
    motorDireito->run(BACKWARD);
  } else { // Virar para a esquerda (motor esquerdo para trás, direito para frente)
    motorEsquerdo->run(BACKWARD);
    motorDireito->run(FORWARD);
  }
  delay(300); // Gira por um curto período
  pararMotores();
}

void moverParaFrente() {
  motorEsquerdo->setSpeed(VELOCIDADE_PADRAO);
  motorDireito->setSpeed(VELOCIDADE_PADRAO);
  motorEsquerdo->run(FORWARD);
  motorDireito->run(FORWARD);
}

void atualizarPosicaoOdometria(float distPercorrida, float anguloGirado) {
  // Simulação de odometria - em um sistema real, usaria encoders
  float anguloNovo = anguloOrientacaoRad + anguloGirado;
  posX_global += distPercorrida * cos(anguloNovo);
  posY_global += distPercorrida * sin(anguloNovo);
  anguloOrientacaoRad = fmod(anguloNovo, 2 * PI);
}

void setup() {
  Serial.begin(9600);
  escudosMotores.begin();
  motorEsquerdo->setSpeed(0);
  motorDireito->setSpeed(0);
  pararMotores();
  Serial.println("Sistema de Navegação AMR iniciado.");
}

void loop() {
  static unsigned long ultimoTempoControle = 0;

  if (millis() - ultimoTempoControle > INTERVALO_CONTROLE_MS) {
    ultimoTempoControle = millis();

    int distanciaAtualCM = sensorDistancia.ping_cm();
    Serial.print("Distância: "); Serial.print(distanciaAtualCM); Serial.println(" cm");

    if (distanciaAtualCM > 0 && distanciaAtualCM < LIMITE_OBSTACULO_CM) {
      Serial.println("Obstáculo detectado! Evitando...");
      girar(1); // Gira para a direita para evitar
      // Em um sistema real, envolveria um planejamento de rota mais sofisticado
    } else {
      Serial.println("Caminho livre. Seguindo em frente.");
      moverParaFrente();
      // Simula atualização de odometria para demonstração
      atualizarPosicaoOdometria(0.1, 0); // Avança 0.1 unidade, sem giro
    }
    Serial.print("Posição Estimada: X="); Serial.print(posX_global); 
    Serial.print(", Y="); Serial.print(posY_global); 
    Serial.print(", Orientação="); Serial.println(anguloOrientacaoRad * 180 / PI);
  }
}

Exemplo 2: Robô de Classificação Guiado por Visão

#include <Arduino.h>
// Simulação de uma biblioteca para câmera (ArduCAM/OpenMV) via Serial
// Em um cenário real, seria uma biblioteca específica ou comunicação serial com uma câmera inteligente.

// Configuração do motor para um braço ou plataforma de movimentação
// Usando SimpleFOC para controle BLDC mais avançado
#include <SimpleFOC.h>

BLDCMotor motorBraco(7); // Pin PWM do motor
BLDCDriver3PWM driverBraco(9, 10, 11, 8); // Pinos do driver (PWM_U, PWM_V, PWM_W, Enable)
Encoder sensorPosicao(2, 3, 500); // Encoder (pino A, pino B, pulsos por revolução)

// Estrutura para dados de objetos detectados pela câmera
struct DetalhesObjeto {
  int idItem;
  int centroX;
  int centroY;
  int largura;
  int altura;
};

DetalhesObjeto objetoDetectado;
bool temObjetoNaArea = false;

// Pinos para comunicação serial com módulo de visão (ex: OpenMV)
#define SERIAL_VISAO Serial1 

void receberDadosVisao(String dadosBrutos) {
  // Formato esperado: "OBJ:id:x:y:w:h" ou "PERDIDO"
  if (dadosBrutos.startsWith("OBJ:")) {
    int valores[5];
    int inicio = 4; // Pular "OBJ:"
    for (int i = 0; i < 5; i++) {
      int fim = dadosBrutos.indexOf(':', inicio);
      valores[i] = dadosBrutos.substring(inicio, fim == -1 ? dadosBrutos.length() : fim).toInt();
      inicio = fim + 1;
    }
    objetoDetectado.idItem = valores[0];
    objetoDetectado.centroX = valores[1];
    objetoDetectado.centroY = valores[2];
    objetoDetectado.largura = valores[3];
    objetoDetectado.altura = valores[4];
    temObjetoNaArea = true;
  } else if (dadosBrutos == "PERDIDO") {
    temObjetoNaArea = false;
    Serial.println("Objeto perdido da visão.");
  }
}

void setup() {
  Serial.begin(115200); // Para comunicação com PC
  SERIAL_VISAO.begin(9600); // Para comunicação com módulo de visão (OpenMV, etc.)

  // Inicialização do motor BLDC
  sensorPosicao.init();
  motorBraco.linkSensor(&sensorPosicao);
  driverBraco.init();
  motorBraco.linkDriver(&driverBraco);
  motorBraco.controller = MotionControlType::velocity; // Controle de velocidade
  motorBraco.init();
  motorBraco.initFOC(); // Inicializa FOC
  
  SERIAL_VISAO.println("CMD:INICIAR_RASTREAMENTO_CORES"); // Comando de inicialização para câmera
  Serial.println("Robô de classificação BLDC iniciado.");
}

void loop() {
  // Verifica se há dados da câmera
  if (SERIAL_VISAO.available()) {
    String dadosVisao = SERIAL_VISAO.readStringUntil('\n');
    receberDadosVisao(dadosVisao);
    Serial.print("Dados Visão: "); Serial.println(dadosVisao);
  }

  if (temObjetoNaArea) {
    // Lógica de controle guiada pela visão
    int centro_camera_x = 160; // Assumindo resolução de 320x240, centro X
    int erro_horizontal = objetoDetectado.centroX - centro_camera_x;

    // Controle P simples para girar em direção ao objeto
    // Mapeia erro de -160 a 160 para velocidade de giro de -3.0 a 3.0 rad/s
    float velocidadeGiro = map(erro_horizontal, -160, 160, -30.0, 30.0) / 10.0f; // Ajusta escala

    // O robô avança se o objeto estiver aproximadamente centralizado
    float velocidadeAvanco = (abs(erro_horizontal) < 20) ? 10.0 : 0.0; // rad/s

    // Define a velocidade do motor (simples, para demonstração)
    // Em um sistema real, esta lógica seria mais complexa (cinemática inversa, etc.)
    motorBraco.move(velocidadeGiro + velocidadeAvanco);

    Serial.print("Erro X: "); Serial.print(erro_horizontal);
    Serial.print(", Velocidade Braco: "); Serial.println(velocidadeGiro + velocidadeAvanco);
  } else {
    motorBraco.move(0); // Para o motor se nenhum objeto for detectado
  }
  motorBraco.loopFOC(); // Essencial para SimpleFOC
}

Exemplo 3: Sistema de Despacho de Robôs Colaborativos (via Ethernet)

#include <Arduino.h>
#include <Ethernet.h> // Para comunicação de rede
#include <SimpleFOC.h> // Para controle BLDC

// Configurações de rede
byte enderecoMAC[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ipServidorCentral(192, 168, 1, 100);
int portaServidor = 80; // Ou porta Modbus TCP padrão
EthernetClient clienteRobo; // Cliente para comunicação com o servidor

// Configuração dos motores BLDC diferenciais
BLDCMotor motorEsq(7);
BLDCDriver3PWM driverEsq(9, 10, 11, 8);
Encoder encoderEsq(2, 3, 500);

BLDCMotor motorDir(6);
BLDCDriver3PWM driverDir(4, 5, 6, 7);
Encoder encoderDir(A0, A1, 500);

// Estrutura para uma tarefa recebida
struct DadosTarefa {
  uint16_t idTarefa;
  float alvoX;
  float alvoY;
  uint8_t nivelPrioridade;
  bool concluida;
};
DadosTarefa tarefaAtual;

const int ID_ROBO = 1; // ID deste robô na frota
unsigned long ultimoReporte = 0;
const unsigned long INTERVALO_REPORTE_MS = 5000; // A cada 5 segundos

void analisarTarefaRecebida(String mensagem) {
  // Formato esperado: "TAREFA:ID:ALVO_X:ALVO_Y:PRIORIDADE"
  if (mensagem.startsWith("TAREFA:")) {
    int idx1 = mensagem.indexOf(':', 7); // Pula "TAREFA:"
    int idx2 = mensagem.indexOf(':', idx1 + 1);
    int idx3 = mensagem.indexOf(':', idx2 + 1);

    tarefaAtual.idTarefa = mensagem.substring(7, idx1).toInt();
    tarefaAtual.alvoX = mensagem.substring(idx1 + 1, idx2).toFloat();
    tarefaAtual.alvoY = mensagem.substring(idx2 + 1, idx3).toFloat();
    tarefaAtual.nivelPrioridade = mensagem.substring(idx3 + 1).toInt();
    tarefaAtual.concluida = false;
    Serial.print("Tarefa recebida: ID="); Serial.println(tarefaAtual.idTarefa);
  }
}

void enviarStatusRobo() {
  if (clienteRobo.connected()) {
    clienteRobo.print("STATUS_ROBO:");
    clienteRobo.print(ID_ROBO);
    clienteRobo.print(":");
    clienteRobo.print(tarefaAtual.idTarefa);
    clienteRobo.print(":");
    clienteRobo.print(tarefaAtual.concluida ? "COMPLETA" : "EM_EXECUCAO");
    clienteRobo.println(); // Envia nova linha
  }
}

void executarMovimentoRobo(float velLinear, float velAngular) {
  // Cálculos simplificados para robô diferencial
  float velEsquerda = velLinear - velAngular;
  float velDireita = velLinear + velAngular;

  motorEsq.move(velEsquerda);
  motorDir.move(velDireita);
}

void setup() {
  Serial.begin(115200);
  Ethernet.begin(enderecoMAC);
  delay(1000); // Espera a rede inicializar
  Serial.print("Endereço IP do Robô: "); Serial.println(Ethernet.localIP());

  // Inicialização dos motores BLDC
  encoderEsq.init(); encoderDir.init();
  motorEsq.linkSensor(&encoderEsq); motorDir.linkSensor(&encoderDir);
  driverEsq.init(); driverDir.init();
  motorEsq.linkDriver(&driverEsq); motorDir.linkDriver(&driverDir);
  motorEsq.controller = MotionControlType::velocity;
  motorDir.controller = MotionControlType::velocity;
  motorEsq.init(); motorDir.init();
  motorEsq.initFOC(); motorDir.initFOC();
  
  tarefaAtual.concluida = true; // Nenhuma tarefa inicialmente
  Serial.println("Sistema de despacho multi-robô iniciado.");
}

void loop() {
  // Tenta conectar ao servidor se não estiver conectado
  if (!clienteRobo.connected()) {
    Serial.println("Tentando conectar ao servidor...");
    if (clienteRobo.connect(ipServidorCentral, portaServidor)) {
      Serial.println("Conectado ao servidor.");
    } else {
      Serial.println("Falha na conexão.");
      delay(5000); // Tenta novamente após 5 segundos
      return;
    }
  }

  // Receber comandos do servidor
  while (clienteRobo.available()) {
    String dadosRecebidos = clienteRobo.readStringUntil('\n');
    analisarTarefaRecebida(dadosRecebidos);
  }

  // Enviar status periodicamente
  if (millis() - ultimoReporte > INTERVALO_REPORTE_MS) {
    enviarStatusRobo();
    ultimoReporte = millis();
  }

  // Executar a tarefa atual
  if (!tarefaAtual.concluida) {
    // Simples controle para demonstrar movimento em direção ao alvo
    // Em um sistema real, usaria um algoritmo de navegação (A*, etc.)
    float velocidadeLinear = 5.0; // Velocidade constante para demonstração
    float velocidadeAngular = 0.0; // Sem giro por padrão

    // Simulação de "alcançar" o alvo
    // Isto seria calculado com base na posição atual do robô e alvo
    if (random(0, 100) < 5) { // 5% de chance de "completar" a tarefa
      tarefaAtual.concluida = true;
      Serial.print("Tarefa "); Serial.print(tarefaAtual.idTarefa); Serial.println(" concluída!");
      // Enviar status de conclusão imediatamente
      enviarStatusRobo(); 
    }
    executarMovimentoRobo(velocidadeLinear, velocidadeAngular);
  } else {
    executarMovimentoRobo(0, 0); // Robô parado se não houver tarefa
  }
  motorEsq.loopFOC(); // Essencial para SimpleFOC
  motorDir.loopFOC();
}

Exemplo 4: Robô Seguidor de Carga com Posicionamento UWB

#include <Arduino.h>
#include <DW1000Ng.h> // Biblioteca para o módulo UWB
#include <DW1000NgRanging.h> // Funções de ranging específicas
#include <SimpleFOC.h> // Para controle BLDC

// Configurações dos dispositivos UWB
// Endereços curtos (Short Address) são usados para simplicidade no código
const uint16_t ENDERECO_TAG_ROBO_CURTO = 0x7D00; // Endereço deste robô (TAG)
const uint16_t ENDERECO_ANCORA_1_CURTO = 0x0001; // Endereço de uma âncora
const uint16_t ENDERECO_ANCORA_2_CURTO = 0x0002; // Endereço de outra âncora

// Pinos para o módulo DW1000 (SPI)
const uint8_t PINO_DW_SS = 4;   // Chip Select
const uint8_t PINO_DW_RST = 5;  // Reset
const uint8_t PINO_DW_IRQ = 6;  // Interrupt

// Configuração do motor BLDC
BLDCMotor motorPropulsao(7); // Pino PWM
BLDCDriver3PWM driverPropulsao(9, 10, 11, 8); // Pinos do driver (PWM_U, PWM_V, PWM_W, Enable)
Encoder encoderMotor(2, 3, 500); // Pinos do encoder

// Variáveis de posicionamento e controle
float posicaoAlvoX = 0.0f, posicaoAlvoY = 0.0f; // Posição desejada
float posicaoAtualX = 0.0f, posicaoAtualY = 0.0f; // Posição estimada do robô
float distanciaSeguirMetros = 1.5f; // Distância ideal para seguir a carga

// Variáveis para armazenar as distâncias das âncoras
float distanciaAncora1 = 0.0f;
float distanciaAncora2 = 0.0f;

// Funções de callback (podem ser simples ou mais complexas, dependendo do uso)
void onNewRangingResult() {
  // Nada a fazer aqui para este exemplo, DW1000NgRanging processa internamente
}

void onRangingFailed() {
  Serial.println("Falha no processo de ranging UWB.");
}

void setup() {
  Serial.begin(115200);

  // Inicialização do módulo UWB
  DW1000Ng.begin(PINO_DW_IRQ, PINO_DW_RST);
  DW1000Ng.setNetworkId(ENDERECO_TAG_ROBO_CURTO); // Este robô (Tag) pertence a esta rede
  DW1000Ng.setDeviceAddress(ENDERECO_TAG_ROBO_CURTO); // Define o endereço do próprio robô
  DW1000Ng.setAntennaDelay(16436); // Valor típico para calibração da antena

  DW1000NgRanging.initiateAsTag(false); // Configura o dispositivo como TAG, no modo polling (não-interruptivo)
  DW1000NgRanging.setRangingTagCallbacks(onNewRangingResult, onRangingFailed); // Configura callbacks
  
  // Adiciona as âncoras que o robô irá tentar localizar
  DW1000NgRanging.addTag(ENDERECO_ANCORA_1_CURTO, "Ancora1");
  DW1000NgRanging.addTag(ENDERECO_ANCORA_2_CURTO, "Ancora2");
  DW1000NgRanging.startRanging(); // Inicia o processo de medição de distâncias
  
  Serial.println("Módulo UWB inicializado.");

  // Inicialização do motor BLDC
  encoderMotor.init();
  motorPropulsao.linkSensor(&encoderMotor);
  driverPropulsao.init();
  motorPropulsao.linkDriver(&driverPropulsao);
  motorPropulsao.controller = MotionControlType::velocity;
  motorPropulsao.init();
  motorPropulsao.initFOC();
  Serial.println("Motor BLDC inicializado.");
}

void loop() {
  // Processamento contínuo de dados UWB. Isso atualiza as distâncias internamente.
  DW1000NgRanging.loop();

  // Obtenção das distâncias mais recentes das âncoras
  distanciaAncora1 = DW1000NgRanging.getDistance(ENDERECO_ANCORA_1_CURTO);
  distanciaAncora2 = DW1000NgRanging.getDistance(ENDERECO_ANCORA_2_CURTO);

  // Somente procede com o controle se houver distâncias válidas de ambas as âncoras
  if (distanciaAncora1 > 0 && distanciaAncora2 > 0) { 
    // Algoritmo de trilateração simplificado (para 2D com 2 âncoras na linha X)
    // Assumindo Âncora 1 em (0,0) e Âncora 2 em (L,0), onde L = 5m
    const float L_ANCORAS = 5.0f; 
    posicaoAtualX = (sq(distanciaAncora1) - sq(distanciaAncora2) + sq(L_ANCORAS)) / (2 * L_ANCORAS);
    posicaoAtualY = sqrt(abs(sq(distanciaAncora1) - sq(posicaoAtualX))); // 'abs' para evitar sqrt de negativos

    // Definir um alvo fixo para demonstração
    posicaoAlvoX = 2.5f; 
    posicaoAlvoY = 1.0f;

    // Cálculo do erro de posição e controle de velocidade (P-control)
    float erroX = posicaoAlvoX - posicaoAtualX;
    float erroY = posicaoAlvoY - posicaoAtualY;
    float distanciaAoAlvo = sqrt(sq(erroX) + sq(erroY));
    
    float velocidadeControlada = 0.0f;
    if (distanciaAoAlvo > distanciaSeguirMetros) {
        // Aumenta a velocidade proporcionalmente à distância extra a ser percorrida
        velocidadeControlada = constrain((distanciaAoAlvo - distanciaSeguirMetros) * 5.0f, -5.0f, 5.0f); 
    } else {
        velocidadeControlada = 0.0f; // Parado ou muito lento se próximo o suficiente
    }
    
    motorPropulsao.move(velocidadeControlada);

    Serial.print("Posição UWB: X="); Serial.print(posicaoAtualX); 
    Serial.print(", Y="); Serial.print(posicaoAtualY);
    Serial.print(" Distância ao Alvo: "); Serial.print(distanciaAoAlvo);
    Serial.print(" Velocidade: "); Serial.println(velocidadeControlada);
  } else {
      motorPropulsao.move(0); // Parar o motor se não houver dados de ranging válidos
  }
  motorPropulsao.loopFOC(); // Essencial para o controle FOC
  delay(10); // Pequeno atraso para estabilidade
}

Exemplo 5: Coordenação Multi-Robô para Manuseio de Carga (via LoRa)

#include <Arduino.h>
#include <SPI.h>
#include <LoRa.h> // Biblioteca LoRa para comunicação sem fio de longo alcance
#include <SimpleFOC.h> // Para controle BLDC

// Configurações para o módulo LoRa
#define PINO_LORA_SS 10
#define PINO_LORA_RST 9
#define PINO_LORA_DIO0 2
#define FREQUENCIA_LORA 433E6 // Frequência de operação do LoRa em Hz

const int ID_ROBO_ATUAL = 1; // Identificador único para este robô na frota

// Configuração dos motores BLDC para uma plataforma diferencial
BLDCMotor motorTracaoEsq(7);
BLDCDriver3PWM driverTracaoEsq(8, 9, 10, 11);
Encoder encoderTracaoEsq(2, 3, 500);

BLDCMotor motorTracaoDir(6);
BLDCDriver3PWM driverTracaoDir(4, 5, 6, 7);
Encoder encoderTracaoDir(A0, A1, 500);

// Estrutura de dados para uma missão de transporte
struct MissaoTransporte {
  int idMissao;
  float coordenadaX_destino;
  float coordenadaY_destino;
  bool estadoConcluida;
};
MissaoTransporte missaoAtiva;

// Posição atual do robô (apenas para simulação de navegação)
float robo_posX = 0.0f;
float robo_posY = 0.0f;

void parsePacketLoRa(int tamanhoPacote) {
  if (tamanhoPacote == 0) return; // Nenhum pacote recebido

  String mensagemRecebida = "";
  while (LoRa.available()) {
    mensagemRecebida += (char)LoRa.read();
  }

  Serial.print("Recebido: "); Serial.println(mensagemRecebida);

  // Exemplo de formato da mensagem de missão: "MISSAO:ID:X:Y"
  if (mensagemRecebida.startsWith("MISSAO:")) {
    int idx1 = mensagemRecebida.indexOf(':', 7); // Pula "MISSAO:"
    int idx2 = mensagemRecebida.indexOf(':', idx1 + 1);

    missaoAtiva.idMissao = mensagemRecebida.substring(7, idx1).toInt();
    missaoAtiva.coordenadaX_destino = mensagemRecebida.substring(idx1 + 1, idx2).toFloat();
    missaoAtiva.coordenadaY_destino = mensagemRecebida.substring(idx2 + 1).toFloat();
    missaoAtiva.estadoConcluida = false; // A missão é nova, então não está concluída
    Serial.print("Nova missão: ID "); Serial.print(missaoAtiva.idMissao);
    Serial.print(" para ("); Serial.print(missaoAtiva.coordenadaX_destino);
    Serial.print(", "); Serial.print(missaoAtiva.coordenadaY_destino); Serial.println(")");
  }
}

void setup() {
  Serial.begin(115200);

  // Inicialização LoRa
  LoRa.setPins(PINO_LORA_SS, PINO_LORA_RST, PINO_LORA_DIO0);
  if (!LoRa.begin(FREQUENCIA_LORA)) {
    Serial.println("Falha ao inicializar LoRa!");
    while (true); // Trava se o LoRa não iniciar
  }
  Serial.println("LoRa inicializado.");

  // Inicialização dos motores BLDC
  encoderTracaoEsq.init(); encoderTracaoDir.init();
  motorTracaoEsq.linkSensor(&encoderTracaoEsq); motorTracaoDir.linkSensor(&encoderTracaoDir);
  driverTracaoEsq.init(); driverTracaoDir.init();
  motorTracaoEsq.linkDriver(&driverTracaoEsq); motorTracaoDir.linkDriver(&driverTracaoDir);
  motorTracaoEsq.controller = MotionControlType::velocity;
  motorTracaoDir.controller = MotionControlType::velocity;
  motorTracaoEsq.init(); motorTracaoDir.init();
  motorTracaoEsq.initFOC(); motorTracaoDir.initFOC();
  Serial.println("Motores BLDC inicializados.");

  missaoAtiva.estadoConcluida = true; // Nenhuma missão ativa no início
}

void loop() {
  // Processa pacotes LoRa recebidos
  parsePacketLoRa(LoRa.parsePacket());

  if (!missaoAtiva.estadoConcluida) {
    // Simulação de movimento em direção ao alvo
    // Em um sistema real, usaria um controle PID ou algoritmo de navegação (e.g., A*)
    float velocidadeFrente = 1.5f; // Velocidade linear constante para demonstração
    float velocidadeRotacao = 0.0f; // Velocidade angular

    // Para fins de demonstração, o robô "completa" a missão aleatoriamente
    if (random(0, 200) == 1) { // Uma pequena chance de 0.5% a cada loop de "completar" a missão
      missaoAtiva.estadoConcluida = true;
      Serial.print("Missão "); Serial.print(missaoAtiva.idMissao); Serial.println(" concluída!");

      // Envia confirmação de conclusão da missão via LoRa
      LoRa.beginPacket();
      LoRa.print("CONFIRMACAO:");
      LoRa.print(ID_ROBO_ATUAL);
      LoRa.print(":");
      LoRa.print(missaoAtiva.idMissao);
      LoRa.endPacket();
    }
    
    // Calcula velocidades individuais dos motores para movimento diferencial
    motorTracaoEsq.move(velocidadeFrente - velocidadeRotacao);
    motorTracaoDir.move(velocidadeFrente + velocidadeRotacao);
  } else {
    // Robô parado se a missão estiver concluída ou não houver missão ativa
    motorTracaoEsq.move(0);
    motorTracaoDir.move(0);
  }
  motorTracaoEsq.loopFOC(); // Essencial para o controle FOC do motor esquerdo
  motorTracaoDir.loopFOC(); // Essencial para o controle FOC do motor direito
  delay(10); // Pequeno atraso para evitar sobrecarga do processador
}

Exemplo 6: Robô de Classificação por Visão com OpenMV (Via Serial)

#include <Arduino.h>
#include <SimpleFOC.h> // Para controle BLDC

// Configuração do motor BLDC para controle de movimento (ex: plataforma móvel ou braço)
BLDCMotor motorControle(7);
BLDCDriver3PWM driverControle(9, 10, 11, 8);
Encoder encoderControle(2, 3, 500);

// Estrutura para os dados do objeto capturados pela câmera OpenMV
struct DadosObjetoVisual {
  int identificador;
  int coordX_pixel;
  int coordY_pixel;
  int dimensaoLargura;
  int dimensaoAltura;
};

DadosObjetoVisual objetoDetectadoAtual;
bool objetoVisivel = false;

// Configuração da comunicação serial com o módulo OpenMV
#define SERIAL_OPENMV Serial1 

void processarDadosVisao(String pacoteDados) {
  // Formato esperado do OpenMV: "OBJETO:ID:X:Y:L:A" ou "AUSENTE"
  if (pacoteDados.startsWith("OBJETO:")) {
    int valores[5];
    int inicio = 7; // Pular "OBJETO:"
    for (int i = 0; i < 5; i++) {
      int fim = pacoteDados.indexOf(':', inicio);
      // Se não encontrar mais ':', pegue o resto da string
      valores[i] = pacoteDados.substring(inicio, fim == -1 ? pacoteDados.length() : fim).toInt();
      inicio = fim + 1;
    }
    objetoDetectadoAtual.identificador = valores[0];
    objetoDetectadoAtual.coordX_pixel = valores[1];
    objetoDetectadoAtual.coordY_pixel = valores[2];
    objetoDetectadoAtual.dimensaoLargura = valores[3];
    objetoDetectadoAtual.dimensaoAltura = valores[4];
    objetoVisivel = true;
  } else if (pacoteDados == "AUSENTE") {
    objetoVisivel = false;
    Serial.println("Objeto não detectado ou perdido.");
  }
}

void setup() {
  Serial.begin(115200);     // Comunicação com o monitor serial do PC
  SERIAL_OPENMV.begin(9600); // Comunicação com o módulo OpenMV

  // Inicialização do motor BLDC
  encoderControle.init();
  motorControle.linkSensor(&encoderControle);
  driverControle.init();
  motorControle.linkDriver(&driverControle);
  motorControle.controller = MotionControlType::velocity;
  motorControle.init();
  motorControle.initFOC();
  Serial.println("Motor BLDC e comunicação com OpenMV iniciados.");

  // Enviar comando de inicialização para o OpenMV (se necessário)
  SERIAL_OPENMV.println("INICIAR_DETECCAO");
}

void loop() {
  // Ler dados da OpenMV se disponíveis
  if (SERIAL_OPENMV.available()) {
    String dadosVisaoBrutos = SERIAL_OPENMV.readStringUntil('\n');
    processarDadosVisao(dadosVisaoBrutos);
    Serial.print("Dados OpenMV: "); Serial.println(dadosVisaoBrutos);
  }
  
  // Controle do robô baseado nos dados visuais
  if (objetoVisivel) {
    // Assumimos que a câmera OpenMV está centralizada na resolução de 320x240 (OpenMV H7)
    int centroHorizontalCamera = 160; 
    int desvioHorizontal = objetoDetectadoAtual.coordX_pixel - centroHorizontalCamera;
    
    // Mapeamento P simples para velocidade de giro
    // Convertendo o desvio em pixels para uma velocidade angular em rad/s
    float velocidadeAngular = map(desvioHorizontal, -160, 160, -30.0, 30.0) / 10.0f; // Ex: +-3 rad/s
    
    // Velocidade linear (para frente) é aplicada apenas se o objeto estiver aproximadamente alinhado centralmente
    float velocidadeLinear = (abs(desvioHorizontal) < 20) ? 2.0 : 0.0; // Se o desvio for menor que +-20 pixels
    
    // Comando de movimento combinado: a velocidade total é a soma da linear e angular
    motorControle.move(velocidadeLinear + velocidadeAngular); 

    Serial.print("X Objeto: "); Serial.print(objetoDetectadoAtual.coordX_pixel);
    Serial.print(", Desvio: "); Serial.print(desvioHorizontal);
    Serial.print(", Velocidade Total: "); Serial.println(velocidadeLinear + velocidadeAngular);
  } else {
    motorControle.move(0); // Para o motor se nenhum objeto for detectado ou se perdeu de vista
  }
  motorControle.loopFOC(); // Essencial para o controle FOC
}

Tags: Arduino BLDC AMR Robótica Armazém Inteligente

Publicado em 8-29 05:05

Tags em Destaque

©2026 Doido Dev