Braço Robótico Inteligente Controlado por Arduino: Tutorial DIY Fácil

Componentes e Materiais

Componente	Descrição	Qtd
Arduino UNO	–	1
Micro Servos	–	5
Potenciômetros	–	5
Protoboard (genérica)	–	1

Sobre o Projeto

Neste tutorial, construo um braço robótico simples controlado por um "braço mestre". O braço grava movimentos e os reproduz em sequência. A ideia não é nova – inspirei-me no "mini robotic arm" do Stoerpeak. Queria fazer isso há tempos, mas era iniciante total. Agora, finalmente construí um, mantendo-o simples, barato e compartilhando com todos.

Passo 1: O que Você Vai Precisar

• 5 Motores servo (link Amazon)
• 5 Potenciômetros (link Amazon)
• Arduino UNO (link Amazon)
• Fonte de alimentação (usei adaptador 5V)
• Protoboard (link Amazon)
• Papelão / Madeira / Sun-board / Acrílico – o que tiver à mão
• Arduino IDE instalado

Passo 2: Construindo o Braço

Usei palitos de picolé para o braço. Use qualquer material disponível e experimente designs mecânicos melhores – o meu não é muito estável. Colei os servos nos palitos com fita dupla-face e prensei com parafusos.

Para o braço mestre, colei potenciômetros em palitos e montei o braço. As fotos dão melhor ideia. Montei tudo em uma placa de tela A4 como base.

Passo 3: Fazendo as Conexões

1. Conecte todos os servos em paralelo à fonte: fio vermelho no +, preto/marrom no GND.
2. Fios de sinal (amarelo/laranja) nos pinos PWM do Arduino.
3. Potenciômetros: terminais laterais no +5V e GND do Arduino (paralelo); terminal central nos pinos analógicos.

Mapeamento:

• Pinos digitais PWM 3, 5, 6, 9, 10 → controlam servos 0 a 4
• Pinos analógicos A0 a A4 → leem potenciômetros 0 a 4
• Servo no pino 3 ↔ Pot no A0; Servo no pino 5 ↔ Pot no A1; e assim por diante.

Importante: Mesmo que servos não sejam alimentados pelo Arduino, conecte o GND dos servos ao GND do Arduino, senão o braço não funciona.

Passo 4: Programação

A lógica é simples: valores dos potenciômetros são armazenados em array; na reprodução, um loop for percorre o array e move os servos conforme os valores gravados. Referência: tutorial "Arduino Potentiometer Servo Control & Memory".

Variáveis Globais

#include <Servo.h>
// Objetos Servo
Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4;
// Potenciômetros
int Pot_0, Pot_1, Pot_2, Pot_3, Pot_4;
// Posições dos servos
int Servo_0_Pos, Servo_1_Pos, Servo_2_Pos, Servo_3_Pos, Servo_4_Pos;
// Posições anteriores
int Prev_0_Pos, Prev_1_Pos, Prev_2_Pos, Prev_3_Pos, Prev_4_Pos;
// Posições atuais
int Current_0_Pos, Current_1_Pos, Current_2_Pos, Current_3_Pos, Current_4_Pos;
int Servo_Position; // armazena ângulo
int Servo_Number;   // armazena nº do servo
int Storage[600];   // array para gravar dados (aumentar consome mais memória)
int Index = 0;      // índice do array
char data = 0;      // dado da serial

setup()

void setup() {
  Serial.begin(9600);
  Servo_0.attach(3); Servo_1.attach(5); Servo_2.attach(6);
  Servo_3.attach(9); Servo_4.attach(10);
  // Posição inicial 100
  Servo_0.write(100); Servo_1.write(100); Servo_2.write(100);
  Servo_3.write(100); Servo_4.write(100);
  Serial.println("Pressione 'R' para Gravar e 'P' para Reproduzir");
}

Função Map_Pot()

void Map_Pot() {
  // Servos giram 180°, mas limite 1-179 evita zumbido contínuo
  Pot_0 = analogRead(A0);
  Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179);
  Servo_0.write(Servo_0_Pos);

  Pot_1 = analogRead(A1);
  Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179);
  Servo_1.write(Servo_1_Pos);

  Pot_2 = analogRead(A2);
  Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179);
  Servo_2.write(Servo_2_Pos);

  Pot_3 = analogRead(A3);
  Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179);
  Servo_3.write(Servo_3_Pos);

  Pot_4 = analogRead(A4);
  Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179);
  Servo_4.write(Servo_4_Pos);
}

loop()

void loop() {
  Map_Pot(); // lê potenciômetros e move servos em tempo real

  while (Serial.available() > 0) {
    data = Serial.read();
    if (data == 'R') Serial.println("Gravando movimentos...");
    if (data == 'P') Serial.println("Reproduzindo movimentos gravados...");
  }

  if (data == 'R') { // GRAVAÇÃO
    // Salva posições anteriores
    Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos;
    Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos;
    Prev_4_Pos = Servo_4_Pos;

    Map_Pot(); // lê novamente para comparar

    // Para cada servo: se posição mudou, grava no array
    if (abs(Prev_0_Pos - Servo_0_Pos) > 0) { // nota: código original usa abs(Prev==Curr) que sempre true se iguais; aqui corrigido para diferença
      if (Current_0_Pos != Servo_0_Pos) {
        Storage[Index] = Servo_0_Pos + 0; Index++;
      }
      Current_0_Pos = Servo_0_Pos;
    }
    if (abs(Prev_1_Pos - Servo_1_Pos) > 0) {
      if (Current_1_Pos != Servo_1_Pos) {
        Storage[Index] = Servo_1_Pos + 100; Index++;
      }
      Current_1_Pos = Servo_1_Pos;
    }
    if (abs(Prev_2_Pos - Servo_2_Pos) > 0) {
      if (Current_2_Pos != Servo_2_Pos) {
        Storage[Index] = Servo_2_Pos + 200; Index++;
      }
      Current_2_Pos = Servo_2_Pos;
    }
    if (abs(Prev_3_Pos - Servo_3_Pos) > 0) {
      if (Current_3_Pos != Servo_3_Pos) {
        Storage[Index] = Servo_3_Pos + 300; Index++;
      }
      Current_3_Pos = Servo_3_Pos;
    }
    if (abs(Prev_4_Pos - Servo_4_Pos) > 0) {
      if (Current_4_Pos != Servo_4_Pos) {
        Storage[Index] = Servo_4_Pos + 400; Index++;
      }
      Current_4_Pos = Servo_4_Pos;
    }

    // Imprime posições no monitor serial
    Serial.print(Servo_0_Pos); Serial.print(" \t ");
    Serial.print(Servo_1_Pos); Serial.print(" \t ");
    Serial.print(Servo_2_Pos); Serial.print(" \t ");
    Serial.print(Servo_3_Pos); Serial.print(" \t ");
    Serial.println(Servo_4_Pos);
    Serial.print("Index = "); Serial.println(Index);
    delay(50);
  }

  if (data == 'P') { // REPRODUÇÃO
    for (int i = 0; i < Index; i++) {
      Servo_Number = Storage[i] / 100;     // identifica servo (0-4)
      Servo_Position = Storage[i] % 100;   // posição do servo
      switch (Servo_Number) {
        case 0: Servo_0.write(Servo_Position); break;
        case 1: Servo_1.write(Servo_Position); break;
        case 2: Servo_2.write(Servo_Position); break;
        case 3: Servo_3.write(Servo_Position); break;
        case 4: Servo_4.write(Servo_Position); break;
      }
      delay(50);
    }
  }
}

Nota: O código original continha uma lógica de comparação com abs(Prev == Curr) que não funciona como esperado. A versão acima corrige para abs(Prev - Curr) > 0.

Carregue o código no Arduino.

Passo 5: Testando

1. Abra o Monitor Serial (Ferramentas → Monitor Serial). O Arduino resetará.
2. Controle o braço robótico usando o braço mestre. Nada é gravado ainda.
3. Digite 'R' no monitor para iniciar gravação. Faça os movimentos desejados.
4. Digite 'P' para reproduzir os movimentos gravados. Os servos repetirão enquanto o board não for resetado.

Espero que gostem do projeto. Sugestões e melhorias nos comentários!

Código (Arquivos Separados)

O código completo está dividido em snippets para facilitar leitura. O arquivo principal Record-Play.ino está disponível para download.

Esquemático