Construye un Robot Cuadrúpedo Inteligente con Arduino: Guía Paso a Paso

Componentes y materiales

Arduino Mega 2560	1
Servomotor SG90 (9g)	12 unidades (3 por pata)
Sensor Ultrasonidos HC-SR04	1
LED 5mm Rojo	4
LED 5mm Verde	4
LED 5mm Azul	4
Conector Macho Header 40 pines	2
PCB Personalizada	1

Herramientas necesarias

• Soldador (genérico)

Aplicaciones y servicios

• Arduino IDE

Sobre el proyecto

Robot cuadrúpedo basado en Arduino. "Cuadrúpedo" = robot de cuatro patas, parecido a una araña. Aprendamos cómo camina una araña y repliquémoslo con Arduino.

Paso 1: Componentes requeridos

• 1x Arduino Mega o Arduino Uno
• 1x PCB perforada
• 12x Servomotores (9g)
• 1x Sensor ultrasónico HC-SR04
• 4x LED RGB
• Cartón

Paso 2: Mantener el Centro de Gravedad (CG)

El centro de gravedad es clave al caminar. Debe permanecer en el centro del cuerpo para mantener el equilibrio. Si el CG se desplaza fuera de ciertos límites, el robot cae.

Si todas las patas están a 45°, el CG está centrado. Pero al mover una pata, el CG se desplaza hacia ese lado. Para evitarlo, las patas opuestas se mantienen en ángulo >45° según tamaño del robot, formando un triángulo donde el CG permanece dentro, dejando la cuarta pata libre para moverse.

Paso 3: Procedimiento de caminata

1. Posición inicial: dos patas (C, D) extendidas a un lado, otras dos (A, B) recogidas
2. Pata superior derecha (B) se levanta y alcanza adelante
3. Todas las patas se desplazan atrás, moviendo el cuerpo adelante
4. Pata trasera izquierda (D) se levanta y avanza junto al cuerpo (imagen espejo)
5. Pata superior izquierda (A) se levanta y alcanza adelante
6. Todas las patas se desplazan atrás
7. Pata trasera derecha (C) se levanta y vuelve a posición inicial

Paso 4: Planos del cuadrúpedo

Archivos PDF: LEGS.pdf (patas), BODY.pdf (cuerpo)

Paso 5: Construcción del cuerpo

Construya el cuerpo según los planos PDF.

Paso 6: Conexión del circuito

Cree su propio shield según necesidades. Arduino Mega tiene 15 pines PWM: use 12 para servos, 3 para LED RGB y 2 para sensor ultrasónico.

Paso 7: Inicialización de servos

Suba el programa a Arduino Mega y empiece a montar las patas según la imagen.

#include <Servo.h>
Servo servo[4][3];
const int servo_pin[4][3] = { {10,11,2}, {3,4,5}, {6,7,8}, {9, 12, 13} };

void setup() {
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 3; j++) {
      servo[i][j].attach(servo_pin[i][j]);
      delay(20);
    }
  }
}

void loop(void) {
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 3; j++) {
      servo[i][j].write(90);
      delay(20);
    }
  }
}

Paso 8: Paso final

Código principal completo (cinemática inversa, caminata, giros, saludos, baile):

/* Includes ----------------------------------------------------------------*/
#include <Servo.h>
#include <FlexiTimer2.h>
#define ledred 46
#define ledblue 44
#define ledgreen 45

/* Servos ------------------------------------------------------------------*/
Servo servo[4][3];
const int servo_pin[4][3] = { {2, 3, 4}, {20, 6, 7}, {8, 9, 17}, {16, 12, 13} };

/* Dimensiones robot -------------------------------------------------------*/
const float length_a = 55;
const float length_b = 77.5;
const float length_c = 27.5;
const float length_side = 71;
const float z_absolute = -28;

/* Constantes movimiento ---------------------------------------------------*/
const float z_default = -50, z_up = -30, z_boot = z_absolute;
const float x_default = 62, x_offset = 0;
const float y_start = 0, y_step = 40;
const float y_default = x_default;

/* Variables movimiento ----------------------------------------------------*/
volatile float site_now[4][3];
volatile float site_expect[4][3];
float temp_speed[4][3];
float move_speed;
float speed_multiple = 1;
const float spot_turn_speed = 4;
const float leg_move_speed = 8;
const float body_move_speed = 3;
const float stand_seat_speed = 1;
volatile int rest_counter;
const float KEEP = 255;
const float pi = 3.1415926;

/* Constantes giro ---------------------------------------------------------*/
const float temp_a = sqrt(pow(2 * x_default + length_side, 2) + pow(y_step, 2));
const float temp_b = 2 * (y_start + y_step) + length_side;
const float temp_c = sqrt(pow(2 * x_default + length_side, 2) + pow(2 * y_start + y_step + length_side, 2));
const float temp_alpha = acos((pow(temp_a, 2) + pow(temp_b, 2) - pow(temp_c, 2)) / 2 / temp_a / temp_b);
const float turn_x1 = (temp_a - length_side) / 2;
const float turn_y1 = y_start + y_step / 2;
const float turn_x0 = turn_x1 - temp_b * cos(temp_alpha);
const float turn_y0 = temp_b * sin(temp_alpha) - turn_y1 - length_side;

/* Setup -------------------------------------------------------------------*/
void setup() {
  pinMode(ledred,OUTPUT); pinMode(ledblue,OUTPUT); pinMode(ledgreen,OUTPUT);
  Serial.begin(115200);
  Serial.println("Robot starts initialization");

  set_site(0, x_default - x_offset, y_start + y_step, z_boot);
  set_site(1, x_default - x_offset, y_start + y_step, z_boot);
  set_site(2, x_default + x_offset, y_start, z_boot);
  set_site(3, x_default + x_offset, y_start, z_boot);
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 3; j++)
      site_now[i][j] = site_expect[i][j];

  FlexiTimer2::set(20, servo_service);
  FlexiTimer2::start();
  Serial.println("Servo service started");
  servo_attach();
  Serial.println("Servos initialized");
  Serial.println("Robot initialization Complete");
}

void servo_attach(void) {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 3; j++) {
      servo[i][j].attach(servo_pin[i][j]);
      delay(100);
    }
}

void servo_detach(void) {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 3; j++) {
      servo[i][j].detach();
      delay(100);
    }
}

/* Loop --------------------------------------------------------------------*/
void loop() {
  analogWrite(ledred,255); Serial.println("Stand"); stand(); delay(2000);
  analogWrite(ledred,0); analogWrite(ledblue,255); Serial.println("Step forward"); step_forward(5); delay(2000);
  analogWrite(ledblue,0); analogWrite(ledgreen,255); Serial.println("Step back"); step_back(5); delay(2000);
  analogWrite(ledgreen,0); analogWrite(ledred,255); analogWrite(ledblue,255); Serial.println("Turn left"); turn_left(5); delay(2000);
  analogWrite(ledgreen,255); analogWrite(ledred,0); analogWrite(ledblue,255); Serial.println("Turn right"); turn_right(5); delay(2000);
  analogWrite(ledgreen,255); analogWrite(ledred,255); analogWrite(ledblue,0); Serial.println("Hand wave"); hand_wave(3); delay(2000);
  Serial.println("Hand shake"); hand_shake(3); delay(2000);
  
  int x=100;
  for(int i=0;i<5;i++) {
    analogWrite(ledgreen,255); analogWrite(ledred,255); analogWrite(ledblue,255); delay(x); // blanco
    analogWrite(ledgreen,255); analogWrite(ledred,255); analogWrite(ledblue,0); delay(x);   // amarillo
    analogWrite(ledgreen,255); analogWrite(ledred,0); analogWrite(ledblue,255); delay(x);   // cyan
    analogWrite(ledgreen,0); analogWrite(ledred,255); analogWrite(ledblue,255); delay(x);   // magenta
    analogWrite(ledgreen,0); analogWrite(ledred,255); analogWrite(ledblue,0); delay(x);     // rojo
    analogWrite(ledgreen,0); analogWrite(ledred,0); analogWrite(ledblue,255); delay(x);     // azul
    analogWrite(ledgreen,255); analogWrite(ledred,0); analogWrite(ledblue,0); delay(x);     // verde
  }
  analogWrite(ledgreen,0); analogWrite(ledred,0); analogWrite(ledblue,0);
}

/* Funciones de movimiento (sit, stand, turn_left, turn_right, step_forward, step_back, hand_wave, hand_shake, head_up, head_down, body_dance, servo_service, set_site, wait_reach, wait_all_reach, cartesian_to_polar, polar_to_servo) - Ver código completo en el archivo original */

Conecte los pines de los LED. ¡Listo! Su cuadrúpedo está listo.

• Suba el programa.
• Conecte los servos según pines definidos.

Código adicional

spider_fix.ino (Posición inicial patas)

// Localizar posición inicial de patas - RegisHsu 2015-09-09
#include <Servo.h>
Servo servo[4][3];
const int servo_pin[4][3] = { {10,11,2}, {3,4,5}, {6,7,8}, {9, 12, 13} };

void setup() {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 3; j++) {
      servo[i][j].attach(servo_pin[i][j]);
      delay(20);
    }
}

void loop(void) {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 3; j++) {
      servo[i][j].write(90);
      delay(20);
    }
}

Partes personalizadas y cajas

Esquemáticos