Robot Móvil 4WD ESP32 Brazo Robótico Omnidireccional

Kit Robot Móvil 4WD ESP32 con Brazo Robótico Omnidireccional

Cod. Kit

¡Bienvenido al Kit Robot Móvil 4WD ESP32 con Brazo Robótico Omnidireccional!

En este proyecto construiremos un robot móvil avanzado capaz de desplazarse en diferentes direcciones, transmitir video de manera inalámbrica y manipular objetos por medio de un brazo robótico.

A diferencia de un vehículo convencional, que generalmente necesita avanzar o retroceder para cambiar de dirección, este robot utiliza cuatro ruedas Mecanum que le permiten moverse hacia adelante, hacia atrás, hacia los costados, en diagonal y girar sobre su propio eje.

Además, incorpora una cámara controlada mediante ESP32, capaz de transmitir video por medio de una conexión Wi-Fi hacia un teléfono celular. Esto permite observar el recorrido del robot desde su propia perspectiva, incluso cuando se encuentra alejado del usuario o fuera de su campo de visión.

Su brazo robótico utiliza tres servomotores para realizar distintos movimientos, brindándole la capacidad de levantar, transportar y cambiar de posición objetos pequeños.

¿Estás listo para construir un robot que puede desplazarse, observar su entorno y manipular objetos? ¡Comencemos!

Concepto base

¿Qué es un robot omnidireccional?

Un robot omnidireccional es un vehículo capaz de moverse en diferentes direcciones sin necesidad de cambiar primero la orientación de su estructura.

Un carrito tradicional puede avanzar, retroceder y girar hacia los lados. Sin embargo, para desplazarse lateralmente necesita realizar varias maniobras. En cambio, un robot omnidireccional puede moverse directamente hacia la izquierda o hacia la derecha sin tener que girar todo su cuerpo.

Esta capacidad resulta especialmente útil en espacios reducidos, recorridos con obstáculos o tareas que requieren movimientos precisos.

El robot puede realizar desplazamientos como:

Avanzar y retroceder.
Desplazarse lateralmente hacia la izquierda o la derecha.
Moverse en distintas direcciones diagonales.
Girar hacia ambos lados.
Rotar alrededor de su propio centro.
Combinar movimientos para realizar trayectorias más complejas.

Esta libertad de movimiento se consigue gracias al funcionamiento coordinado de sus cuatro motores y sus ruedas Mecanum.

El Kit cuenta con las siguientes características:

Altura: Aproximadamente 18.5 cm.
Ancho: 19.5 cm
Largo: 29 cm

El robot puede ser programado para diferentes funciones, entre las cuales tenemos:

Seguidor de Línea Blanca.
Seguidor de Línea Negra.
Evasor de Obstáculos.
Robot Sumo Autónomo sin limite de fondo
Robot Sumo Autónomo para fondo Blanco.
Robot Sumo Autónomo para fondo Negro.
Robot Sumo RC.

Antes de ensamblar el Kit verifica que el material este completo y en buen estado.

Materiales
El Kit incluye.

1pza. Chasis superior de acrílico color negro.
1pza. Chasis inferior de acrílico color negro.
1pza. Plantilla brazo de acrílico color negro.
1pza. 2 Bases para ESP32CAM de acrílico color negro.
12pzs. Bujes de acrílico negro.
4pzs. Soporte para motor de acrílico negro.
1pzs. Soporte de sensor ultrasónico de acrílico transparente.
1pza. Tarjeta ESP32 CH340 USB Tipo C.
1pza. ESP32 CAM OV2640 Wifi con cámara.
1pza. Tarjeta Shield ESP32 30 PINES AB4
4pzs. Motorreductor plástico 1:48 de doble eje con cables.
4pzs. Ruedas Ruedas Mecanum.
2pza. Modulo sensor de líneas TCRT5000.
3pzs. Servomotor Micro MG90S
1pza. HC-SR04 Sensor distancia Ultrasónico.
1pza. Portapilas para pilas 18650 con barril y division Y para puente H
20pzs. de cable puente 20cm Hembra-Hembra.
12 pzs. Tornillo M3 x 8 mm cabeza de gota.
12 pzs. Tornillo M3 x 12 mm cabeza de plana con tuerca
16 pzs. Tornillo M3 x 12 mm con tuerca.
8 pzs. Tornillo M3 x 30 mm con tuerca.
4 pzs. Tornillo M2.3 x 20 mm sin tuerca.
2 pzs. Tornillo 1/8″ x 1/2″ mm con tuerca.
25 pzs. Tornillo 1/8 x 3/8
4pzs. Soportes de plástico para ruedas mecanum.
6pzas. Separador Metálico M3x35mm.

Si detectas que el kit llego incompleto o algún componente dañado, puedes mandarnos un mensaje
Correo: contacto@robodacta.mx

A nuestro numero de WhatsApp: (56) 39661716

¿Cómo se arma?

Ensamble
Para ensamblar del robot observa el siguiente video en donde explicamos paso a paso el armado.

Notas:
Antes de iniciar con el ensamble remueve el plástico protector de las piezas de acrílico.
Es importante no apretar los tornillos de forma excesiva ya que podrías romper alguna de las piezas de acrílico.
No retirar los cinchos que sujetan los cables de los motores ya que estos evitan que se rompan sus terminales con el movimiento.

Diagrama de Conexiones
Una vez completado el ensamble del Robot, realiza las conexiones. A continuación te mostramos los diagramas de conexiones.

Descargar diagrama

Prueba de tu Kit
Para realizar esta tarea deberás colocar las pilas al Kit y encenderlo. Si el Kit realiza los siguientes movimientos es que tu ensamble esta correcto. El kit ya viene con este programa.

El robot se desplaza:

Adelante
Se detiene
Atras
Se detiene
Izquierda
Se detiene
Derecha
Se detiene
En diagonal hacia adelante por la izquierda
Se detiene
En diagonal hacia atrás por la derecha
Se detiene
En diagonal hacia adelante por la derecha
Se detiene
En diagonal hacia atrás por la izquierda
Rota a la derecha
Se detiene
Rota a la izquierda
Se detiene

El brazo se moverá:

La pinza se cierra y abre.
El servo izquierdo levantara el brazo.
El servo derecho extenderá el brazo.
Repite el proceso desde el desplazamiento

A continuación te dejamos un video donde podrás ver como debe de comportarse tu robot para saber si tu robot esta correctamente armado.

Prueba de tu Kit
Para probar tu Kit deberás de seguir los siguientes pasos. De esta manera sabrás si tu ensamble es correcto y si tus conexiones están correctamente cableadas.

Es importante no remover los puentes jumper que se encuentran en el puente H

Nota importante

No pases a la siguiente sección hasta que verifiques que tu Kit esta correctamente ensamblado y cableado.

¿Cómo lo vamos a programar?

Instalación Programa Arduino
Antes de cargar el programa de tu elección, instala el entorno de programación con el cual podrás subir los códigos a tu robot.

Para esta sección preparamos un PDF el cual podrás descargar con el siguiente botón con las instrucciones detalladas de cada uno de los pasos con imágenes.

(El siguiente PDF incluye el paso 1, 2 y 3)

Descargar Manual de Instalación Arduino y Driver

En caso de que ya conozcas un poco de este proceso te dejamos a continuación la explicación corta.

Paso 1.- Descargar de driver CH341
Como uno de los pasos para la instalación de nuestro entorno será el de descargar e instalar el driver necesario para que nuestra computadora pueda reconocer el dispositivo Arduino.

Descargar Driver

Paso 2.- Descarga e instalación de Arduino
Descarga la aplicación de Arduino con el cual podrás editar, subir y abrir los códigos.

Descargar Arduino

Paso 3.- Subir un código
A continuación te dejamos los diferentes códigos con los que se puede programar el Kit 4WD Omnidireccional.

Antes de subir cualquier código, RETIRA EL MODULO BLUETOOTH.

Comportamiento del programa.

El Robot seguirá una serie de movimientos básicos que ayudarán a comprobar que las conexiones y el armado son correctos. Estos son:

Adelante
Se detiene
Atrás
Se detiene
Izquierda
Se detiene
Derecha
Se detiene
En diagonal hacia adelante por la izquierda
Se detiene
En diagonal hacia atrás por la derecha
Se detiene
En diagonal hacia adelante por la derecha
Se detiene
En diagonal hacia atrás por la izquierda
Rota a la derecha
Se detiene
Rota a la izquierda
Se detiene
Prueba servo pinza
Prueba servo izquierda
Prueba servo derecha
Regresa el brazo a posicion centro
Repite el proceso

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

#include <Arduino.h>
#include <ESP32Servo.h>

// Prueba automatica para ESP32 normal + 2 puentes H L298 + 3 servos.
// Sirve para que el cliente revise si armo bien las 4 ruedas mecanum y el brazo.
//
// Conexion usada en el kit:
//   L298 #1: D13, D12, D14, D27
//   L298 #2: D26, D25, D33, D32
//
// Como los ENA/ENB tienen jumper, las ruedas trabajan encendido/apagado.
// Si una rueda gira al reves, cambia su INVERTIR_… de false a true.

const int PIN_SERVO_PINZA = 23;
const int PIN_SERVO_IZQUIERDA = 21;
const int PIN_SERVO_DERECHA = 22;

const int PIN_MOTOR_FL_A = 13;  // rueda frontal izquierda
const int PIN_MOTOR_FL_B = 12;
const int PIN_MOTOR_FR_A = 14;  // rueda frontal derecha
const int PIN_MOTOR_FR_B = 27;
const int PIN_MOTOR_RL_A = 26;  // rueda trasera izquierda
const int PIN_MOTOR_RL_B = 25;
const int PIN_MOTOR_RR_A = 33;  // rueda trasera derecha
const int PIN_MOTOR_RR_B = 32;

const bool INVERTIR_FL = false;
const bool INVERTIR_FR = false;
const bool INVERTIR_RL = false;
const bool INVERTIR_RR = false;

const int PINZA_MIN = 1;
const int PINZA_MAX = 180;
const int IZQUIERDA_MIN = 70;
const int IZQUIERDA_MAX = 180;
const int DERECHA_MIN = 1;
const int DERECHA_MAX = 180;

const int PINZA_CENTRO = 90;
const int IZQUIERDA_CENTRO = 120;
const int DERECHA_CENTRO = 80;

const int SERVO_MIN_US = 500;
const int SERVO_MAX_US = 2400;

const int POTENCIA_PRUEBA = 180;
const unsigned long ESPERA_INICIO_MS = 4000;
const unsigned long TIEMPO_MOVIMIENTO_MS = 1000;
const unsigned long TIEMPO_DETENIDO_MS = 700;
const unsigned long TIEMPO_PAUSA_SERVO_MS = 600;
const int PASO_SERVO = 5;

struct Movimiento {
  const char* modo;
  const char* nombre;
};

Movimiento secuencia[] = {
  {"F", "Adelante"},
  {"B", "Atras"},
  {"L", "Izquierda"},
  {"R", "Derecha"},
  {"FL", "Diagonal hacia adelante por la izquierda"},
  {"BR", "Diagonal hacia atras por la derecha"},
  {"FR", "Diagonal hacia adelante por la derecha"},
  {"BL", "Diagonal hacia atras por la izquierda"},
  {"TR", "Rota a la derecha"},
  {"TL", "Rota a la izquierda"},
};

const int TOTAL_MOVIMIENTOS = sizeof(secuencia) / sizeof(secuencia[0]);

Servo pinzaServo;
Servo izquierdaServo;
Servo derechaServo;

int pinzaPos = PINZA_CENTRO;
int izquierdaPos = IZQUIERDA_CENTRO;
int derechaPos = DERECHA_CENTRO;

void configurarPinMotor(int pin) {
  pinMode(pin, OUTPUT);
  digitalWrite(pin, LOW);
}

void escribirMotor(int pinA, int pinB, int velocidad, bool invertir) {
  velocidad = constrain(velocidad, -255, 255);

  if (invertir) {
    velocidad = -velocidad;
  }

  if (velocidad > 0) {
    digitalWrite(pinA, HIGH);
    digitalWrite(pinB, LOW);
  } else if (velocidad < 0) {
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, HIGH);
  } else {
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, LOW);
  }
}

void escribirRuedas(int fl, int fr, int rl, int rr) {
  escribirMotor(PIN_MOTOR_FL_A, PIN_MOTOR_FL_B, fl, INVERTIR_FL);
  escribirMotor(PIN_MOTOR_FR_A, PIN_MOTOR_FR_B, fr, INVERTIR_FR);
  escribirMotor(PIN_MOTOR_RL_A, PIN_MOTOR_RL_B, rl, INVERTIR_RL);
  escribirMotor(PIN_MOTOR_RR_A, PIN_MOTOR_RR_B, rr, INVERTIR_RR);
}

void detenerMotores() {
  escribirRuedas(0, 0, 0, 0);
}

void escribirServos() {
  pinzaServo.write(pinzaPos);
  izquierdaServo.write(izquierdaPos);
  derechaServo.write(derechaPos);
}

void colocarBrazoCentro() {
  pinzaPos = PINZA_CENTRO;
  izquierdaPos = IZQUIERDA_CENTRO;
  derechaPos = DERECHA_CENTRO;
  escribirServos();
}

void moverCarro(const String& modo, int velocidad) {
  int fl = 0;
  int fr = 0;
  int rl = 0;
  int rr = 0;

  if (modo == "F") {
    fl = -velocidad;
    fr = velocidad;
    rl = -velocidad;
    rr = velocidad;
  } else if (modo == "B") {
    fl = velocidad;
    fr = -velocidad;
    rl = velocidad;
    rr = -velocidad;
  } else if (modo == "L") {
    fl = -velocidad;
    fr = -velocidad;
    rl = velocidad;
    rr = velocidad;
  } else if (modo == "R") {
    fl = velocidad;
    fr = velocidad;
    rl = -velocidad;
    rr = -velocidad;
  } else if (modo == "FL") {
    fl = -velocidad;
    fr = 0;
    rl = 0;
    rr = velocidad;
  } else if (modo == "FR") {
    fl = 0;
    fr = velocidad;
    rl = -velocidad;
    rr = 0;
  } else if (modo == "BL") {
    fl = 0;
    fr = -velocidad;
    rl = velocidad;
    rr = 0;
  } else if (modo == "BR") {
    fl = velocidad;
    fr = 0;
    rl = 0;
    rr = -velocidad;
  } else if (modo == "TL") {
    fl = -velocidad;
    fr = -velocidad;
    rl = -velocidad;
    rr = -velocidad;
  } else if (modo == "TR") {
    fl = velocidad;
    fr = velocidad;
    rl = velocidad;
    rr = velocidad;
  } else {
    detenerMotores();
    return;
  }

  escribirRuedas(fl, fr, rl, rr);
}

void moverServoPorPasos(Servo& servo, int& posicion, int destino, int minimo, int maximo) {
  destino = constrain(destino, minimo, maximo);

  while (posicion != destino) {
    if (posicion < destino) {
      posicion = min(posicion + PASO_SERVO, destino);
    } else {
      posicion = max(posicion – PASO_SERVO, destino);
    }

    servo.write(posicion);
    delay(80);
  }
}

void ejecutarMovimiento(const Movimiento& movimiento) {
  Serial.print("Movimiento: ");
  Serial.println(movimiento.nombre);

  moverCarro(movimiento.modo, POTENCIA_PRUEBA);
  delay(TIEMPO_MOVIMIENTO_MS);

  Serial.println("Se detiene");
  detenerMotores();
  delay(TIEMPO_DETENIDO_MS);
}

void probarServo(const char* nombre, Servo& servo, int& posicion, int centro, int minimo, int maximo, int recorrido) {
  Serial.print("Servo: ");
  Serial.println(nombre);

  moverServoPorPasos(servo, posicion, centro + recorrido, minimo, maximo);
  delay(TIEMPO_PAUSA_SERVO_MS);

  moverServoPorPasos(servo, posicion, centro – recorrido, minimo, maximo);
  delay(TIEMPO_PAUSA_SERVO_MS);

  moverServoPorPasos(servo, posicion, centro, minimo, maximo);
  delay(TIEMPO_PAUSA_SERVO_MS);
}

void probarBrazo() {
  Serial.println("Prueba de brazo");
  colocarBrazoCentro();
  delay(TIEMPO_PAUSA_SERVO_MS);

  probarServo("Pinza", pinzaServo, pinzaPos, PINZA_CENTRO, PINZA_MIN, PINZA_MAX, 20);
  probarServo("Izquierda", izquierdaServo, izquierdaPos, IZQUIERDA_CENTRO, IZQUIERDA_MIN, IZQUIERDA_MAX, 15);
  probarServo("Derecha", derechaServo, derechaPos, DERECHA_CENTRO, DERECHA_MIN, DERECHA_MAX, 15);

  colocarBrazoCentro();
  Serial.println("Brazo en posicion centro");
}

void imprimirInicio() {
  Serial.println();
  Serial.println("=== Prueba de armado 4WD mecanum ===");
  Serial.println("Coloca el robot en el piso con espacio alrededor.");
  Serial.println("El brazo queda sosteniendose en posicion centro.");
  Serial.println("Primero se prueban las ruedas y despues los 3 servos.");
  Serial.println("La prueba inicia en 4 segundos y se repite automaticamente.");
  Serial.println();
}

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

  configurarPinMotor(PIN_MOTOR_FL_A);
  configurarPinMotor(PIN_MOTOR_FL_B);
  configurarPinMotor(PIN_MOTOR_FR_A);
  configurarPinMotor(PIN_MOTOR_FR_B);
  configurarPinMotor(PIN_MOTOR_RL_A);
  configurarPinMotor(PIN_MOTOR_RL_B);
  configurarPinMotor(PIN_MOTOR_RR_A);
  configurarPinMotor(PIN_MOTOR_RR_B);

  detenerMotores();

  ESP32PWM::allocateTimer(0);
  ESP32PWM::allocateTimer(1);
  ESP32PWM::allocateTimer(2);
  ESP32PWM::allocateTimer(3);

  pinzaServo.setPeriodHertz(50);
  izquierdaServo.setPeriodHertz(50);
  derechaServo.setPeriodHertz(50);

  pinzaServo.attach(PIN_SERVO_PINZA, SERVO_MIN_US, SERVO_MAX_US);
  izquierdaServo.attach(PIN_SERVO_IZQUIERDA, SERVO_MIN_US, SERVO_MAX_US);
  derechaServo.attach(PIN_SERVO_DERECHA, SERVO_MIN_US, SERVO_MAX_US);
  colocarBrazoCentro();

  imprimirInicio();
  delay(ESPERA_INICIO_MS);
}

void loop() {
  for (int i = 0; i < TOTAL_MOVIMIENTOS; i++) {
    ejecutarMovimiento(secuencia[i]);
  }

  probarBrazo();

  Serial.println("Proceso completo. Repitiendo…");
  Serial.println();
  delay(1500);
}

Descarga Código

Comportamiento del programa.

El Robot deberá seguir una Línea Blanca en un fondo negro a través de los sensores de línea.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional Seguidor de línea blanca
#include <SoftwareSerial.h>
//  Declaración de pinas RX y TX
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
//  Librería para la tarjeta de expansión de motores
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
//  Declaración de sensores de línea
int sd = A2;
int si = A3;
//  Declaración de sensor ultrasónico
int echo = A4;
int triger = A5;
//  Velocidad de las ruedas
int vel=200;
//  Variables de almacenamiento
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
int l1;
int l2;
int f1;
int f2;
long cont1=0;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
  pinMode(sd,INPUT);
  pinMode(si,INPUT);
  pinMode(echo,INPUT);
  pinMode(triger,OUTPUT);
  digitalWrite(triger,LOW);
}
void loop()
{
  l1 = digitalRead(sd);     
  l2 = digitalRead(si);
  if ((l1 == 1 && l2 == 1)&&cont1>0) //Feedback cuando todos los sensores están en blanco
  {
    l1 = f1;
    l2 = f2;
    cont1=cont1-1;
  }  
  else if(l1 == 1 && l2 == 0){
    gizq();
    }
  else if(l1 == 0 && l2 == 1){
    gder();
    }
  else if(l1 == 0 && l2 == 0){
    adelante();
    cont1=60000;
    }
  else if(l1 == 1 && l2 == 1){
    alto();
    }
  f1 = l1;
  f2 = l2;
}
long distancia()
{
  long t;
  long d;
  digitalWrite(triger,HIGH);
  delayMicroseconds(10);
  digitalWrite(triger,LOW);
  t=pulseIn(echo,HIGH);
  d=t/59;
  delay(10);
  return d;
}
void adelante()//adelante 
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()//atras
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

Comportamiento del programa.

El Robot deberá seguir una Línea Negra en un fondo Blanco a través de los sensores de línea.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional Seguidor de Linea Negra
#include <SoftwareSerial.h>
//  Declaración de pines RX y TX
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
//  Librería para la tarjeta de expansión de motores
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
//  Declaración de sensores de línea
int sd = A2;
int si = A3;
//  Declaración de sensor ultrasónico
int echo = A4;
int triger = A5;
//  Velocidad de las ruedas
int vel=200;
//  Variables de almacenamiento
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
int l1;
int l2;
int f1;
int f2;
long cont=0;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
  pinMode(sd,INPUT);
  pinMode(si,INPUT);
  pinMode(echo,INPUT);
  pinMode(triger,OUTPUT);
  digitalWrite(triger,LOW);
}
void loop()
{
  l1 = digitalRead(sd);     
  l2 = digitalRead(si);
  if ((l1 == 0 && l2 == 0)&&cont>0) //Feedback cuando todos los sensores están en blanco
  {
    l1 = f1;
    l2 = f2;
    cont=cont-1;
  }  
  else if(l1 == 0 && l2 == 1){
    gizq();
    }
  else if(l1 == 1 && l2 == 0){
    gder();
    }
  else if(l1 == 1 && l2 == 1){
    adelante();
    cont=60000;
    }
  else if(l1 == 0 && l2 == 0){
    alto();
    }
  f1 = l1;
  f2 = l2;
}
long distancia()
{
  long t;
  long d;
  digitalWrite(triger,HIGH);
  delayMicroseconds(10);
  digitalWrite(triger,LOW);
  t=pulseIn(echo,HIGH);
  d=t/59;
  delay(10);
  return d;
}
void adelante()//adelante 
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()//atras
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

Comportamiento del programa.

El Robot deberá evadir obstáculos los cuales podrá detectar de frente, haciendo que cambie de dirección.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional Evasor de Obstaculos
#include <SoftwareSerial.h>
//  Declaración de pines RX y TX
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
//  Librería para la tarjeta de expansión de motores
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
//  Declaración de sensores de línea
int sd = A2;
int si = A3;
//  Declaración de sensor ultrasónico
int echo = A4;
int triger = A5;
//  Velocidad de las ruedas
int vel=200;
//  Variables de almacenamiento
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
  pinMode(sd,INPUT);
  pinMode(si,INPUT);
  pinMode(echo,INPUT);
  pinMode(triger,OUTPUT);
  digitalWrite(triger,LOW);
}
void loop()
{
  if(distancia()>= 20)
  {
  adelante(); 
  }
  else if(distancia()<= 20){
  alto();
  delay(500);
  der();
  delay(1000);
  if (distancia()>= 20){
  adelante(); 
  }
  else if(distancia()<= 20){
  rder();
  delay(700);
  adelante();
  }  
  }
}
long distancia()
{
  long t;
  long d;
  digitalWrite(triger,HIGH);
  delayMicroseconds(10);
  digitalWrite(triger,LOW);
  t=pulseIn(echo,HIGH);
  d=t/59;
  delay(10);
  return d;
}
void adelante()//adelante 
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()//atras
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

Comportamiento del programa.

El Robot girará en busca de un contrincante, en el momento en que detecte un objetivo, lo embestirá gracias al sensor ultrasónico.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional Sumo Autónomo
#include <SoftwareSerial.h>
//  Declaración de pines RX y TX
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
//  Librería para la tarjeta de expansión de motores
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
//  Declaración de sensores de línea
int sd = A2;
int si = A3;
//  Declaración de sensor ultrasónico
int echo = A4;
int triger = A5;
//  Velocidad de las ruedas
int vel=200;
//  Variables de almacenamiento
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
  pinMode(sd,INPUT);
  pinMode(si,INPUT);
  pinMode(echo,INPUT);
  pinMode(triger,OUTPUT);
  digitalWrite(triger,LOW);
}
void loop()
{
   if(distancia()>=20)
  {
      gder();
    }
    else 
    {
      adelante();
    }
  }
long distancia()
{
  long t;
  long d;
  digitalWrite(triger,HIGH);
  delayMicroseconds(10);
  digitalWrite(triger,LOW);
  t=pulseIn(echo,HIGH);
  d=t/59;
  delay(10);
  return d;
}
void adelante()//adelante 
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()//atras
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

Comportamiento del programa.

El Robot girará en busca de un contrincante, en el momento en que detecte un objetivo, lo embestirá gracias al sensor ultrasónico, siempre y cuando el kit se encuentre en algún área con fondo Blanco, esto es gracias a los sensores de línea.

Si alguno de los sensores de línea se encuentra en alguna área con fondo negro, el robot retrocederá y girará con el fin de evitar salirse del área con fondo Blanco, posteriormente volverá a buscar algún objetivo.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional Sumo Fondo Blanco
#include <SoftwareSerial.h>
//  Declaración de pines RX y TX
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
//  Librería para la tarjeta de expansión de motores
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
//  Declaración de sensores de línea
int sd = A2;
int si = A3;
//  Declaración de sensor ultrasónico
int echo = A4;
int triger = A5;
//  Velocidad de las ruedas
int vel=200;
//  Variables de almacenamiento
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
  pinMode(sd,INPUT);
  pinMode(si,INPUT);
  pinMode(echo,INPUT);
  pinMode(triger,OUTPUT);
  digitalWrite(triger,LOW);
}
void loop()
{
   if(distancia()<=20)
  { 
    if(digitalRead(si)==1 || digitalRead(sd)==1)//
    { 
      //cambiar los 1 por 0 fondo negro
      vel=180;
      alto();
      delay(100);
      atras();
      delay(400);
      alto();
      delay(500);
      rder();
      delay(500);
      alto();
      delay(500);
      adelante();
      vel=180;
    }
    else 
    {
      adelante();
    }
  }
  else {
    if(digitalRead(si)==1 || digitalRead(sd)==1)
    //cambiar los 1 por 0 fondo negro
    { 
      vel=180;
      alto();
      delay(100);
      atras();
      delay(400);
      alto();
      delay(500);
      rder();
      delay(700);
      alto();
      delay(500);
      adelante();
    }
    else 
    {
      adelante();
    }
    }
  }
long distancia()
{
  long t;
  long d;
  digitalWrite(triger,HIGH);
  delayMicroseconds(10);
  digitalWrite(triger,LOW);
  t=pulseIn(echo,HIGH);
  d=t/59;
  delay(10);
  return d;
}
void adelante()//adelante 
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()//atras
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

Comportamiento del programa.

Si alguno de los sensores de línea se encuentra en alguna área con fondo blanco, el robot retrocederá y girará con el fin de evitar salirse del área con fondo Negro, posteriormente volverá a buscar algún objetivo.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional Sumo Fondo Negro
#include <SoftwareSerial.h>
//  Declaración de pines RX y TX
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
//  Librería para la tarjeta de expansión de motores
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
//  Declaración de sensores de línea
int sd = A2;
int si = A3;
//  Declaración de sensor ultrasónico
int echo = A4;
int triger = A5;
//  Velocidad de las ruedas
int vel=200;
//  Variables de almacenamiento
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
  pinMode(sd,INPUT);
  pinMode(si,INPUT);
  pinMode(echo,INPUT);
  pinMode(triger,OUTPUT);
  digitalWrite(triger,LOW);
}
void loop()
{
   if(distancia()<=20)
  {
    if(digitalRead(si)==0 || digitalRead(sd)==0)//
    { 
      //cambiar los 0 por 1 fondo blanco
      alto();
      delay(100);
      atras();
      delay(400);
      alto();
      delay(500);
      rder();
      delay(500);
      alto();
      delay(500);
      adelante();
    }
    else 
    {
      adelante();
    }
  }
  else {
    if(digitalRead(si)==0 || digitalRead(sd)==0)
    //cambiar los 0 por 1 fondo blanco
    { 
      alto();
      delay(100);
      atras();
      delay(400);
      alto();
      delay(500);
      rder();
      delay(700);
      alto();
      delay(500);
      adelante();
    }
    else 
    {
      adelante();
    }
    }
  }
long distancia()
{
  long t;
  long d;
  digitalWrite(triger,HIGH);
  delayMicroseconds(10);
  digitalWrite(triger,LOW);
  t=pulseIn(echo,HIGH);
  d=t/59;
  delay(10);
  return d;
}
void adelante()//adelante 
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()//atras
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

RETIRA EL MÓDULO BLUETOOTH PARA SUBIR EL CÓDIGO.

Comportamiento del programa.

Podrás controlar el Robot por medio de conexión bluetooth a través de una aplicación compatible con Android.

Nota: Esta aplicación solo sirve para dispositivos con sistema operativo ANDROID

Descarga Aplicación

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

//  4WD Omnidireccional RC 
#include <SoftwareSerial.h>
#define RX_PIN A0
#define TX_PIN A1
SoftwareSerial BTSerial(RX_PIN, TX_PIN);
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
int vel = 255;
char valorBoton;
char penultimo = ‘s’; 
char antepenultimo = ‘s’; 
char v=’s’;
void setup()
{
  BTSerial.begin(9600);
  motor1.setSpeed(vel);
  motor2.setSpeed(vel);
  motor3.setSpeed(vel);
  motor4.setSpeed(vel);
}
void loop()
{
  if (BTSerial.available() > 0)
  {
    valorBoton = BTSerial.read();
    
       if(antepenultimo== ‘w’ && penultimo== ‘q’ && valorBoton == ‘r’){// wqr
        v = ‘w’;
        adelante();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘w’ && penultimo== ‘a’ && valorBoton == ‘f’){// waf 
        v = ‘w’;
        adelante();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘w’ && penultimo== ‘d’ && valorBoton == ‘h’){// wdh
        v = ‘w’;
        adelante();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘w’ && penultimo== ‘e’ && valorBoton == ‘y’){// wey
        v = ‘w’;
        adelante();
        penultimo = ‘s’;
        antepenultimo== ‘s’;; 
      }
      else if(antepenultimo== ‘q’ && penultimo== ‘w’  && valorBoton == ‘t’){// qwt
        v = ‘q’;
        diu();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘q’  && penultimo== ‘a’ && valorBoton == ‘f’){// qaf
        v = ‘q’;
        diu();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘a’ && penultimo==’w’ && valorBoton == ‘t’){//awt
        v = ‘a’;
        izq();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
       else if(antepenultimo== ‘a’ && penultimo==’q’ && valorBoton == ‘r’){//aqr
        v = ‘a’;
        izq();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
       else if(antepenultimo== ‘a’ && penultimo==’z’ && valorBoton == ‘v’){//azv
        v = ‘a’;
        izq();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
       else if(antepenultimo== ‘a’ && penultimo==’x’ && valorBoton == ‘b’){//axb
        v = ‘a’;
        izq();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
       else if(antepenultimo== ‘z’ && penultimo==’a’ && valorBoton == ‘f’){//zaf
        v = ‘z’;
        did();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘z’ && penultimo==’x’ && valorBoton == ‘b’){//zxb
        v = ‘z’;
        did();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
       else if(antepenultimo== ‘x’ && penultimo==’a’ && valorBoton == ‘f’){//xaf
        v = ‘x’;
        atras();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘x’ && penultimo==’z’ && valorBoton == ‘v’){//xzv
        v = ‘x’;
        atras();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘x’ && penultimo==’c’ && valorBoton == ‘n’){//xcn
        v = ‘x’;
        atras();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘x’ && penultimo==’d’ && valorBoton == ‘h’){//xdh
        v = ‘x’;
        atras();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
       else if(antepenultimo== ‘c’ && penultimo==’x’ && valorBoton == ‘b’){//cxb
        v = ‘c’;
        ddd();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘c’ && penultimo==’d’ && valorBoton == ‘h’){//cdh
        v = ‘c’;
        ddd();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘d’ && penultimo==’x’ && valorBoton == ‘b’){//dxb
        v = ‘d’;
        der();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘d’ && penultimo==’c’ && valorBoton == ‘n’){//dcn
        v = ‘d’;
        der();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘d’ && penultimo==’e’ && valorBoton == ‘y’){//dey
        v = ‘d’;
        der();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘d’ && penultimo==’w’ && valorBoton == ‘t’){//dwt
        v = ‘d’;
        der();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘e’ && penultimo==’w’ && valorBoton == ‘t’) {//ewt
        v = ‘e’;
        ddu();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }
      else if(antepenultimo== ‘e’ && penultimo==’d’ && valorBoton == ‘h’){//edh
        v = ‘e’;
        ddu();
        penultimo = ‘s’;
        antepenultimo== ‘s’;
      }

      
      else if(v == ‘w’){//Validacion no se suelta w
        adelante();
        if(valorBoton == ‘t’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //wq
        gizq();    
        }
        else if(valorBoton == ‘a’) { //wa
        rizq();    
        }
        else if(valorBoton == ‘z’) { //wz
        alto();    
        }
        else if(valorBoton == ‘x’) { //wx
        alto();     
        }
        else if(valorBoton == ‘c’) { //wc
        alto();     
        }
        else if(valorBoton == ‘d’) { //wd
        rder();    
        }
        else if(valorBoton == ‘e’) { //we
        gder();    
        }
      }
      else if(v == ‘q’){//Validacion no se suelta  q
        diu();
        if(valorBoton == ‘r’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //qw
        gder();    
        }
        else if(valorBoton == ‘a’) { //qa
        gizq();    
        }
        else if(valorBoton == ‘z’) { //qz
        alto();    
        }
        else if(valorBoton == ‘x’) { //qx
        alto();     
        }
        else if(valorBoton == ‘c’) { //qc
        alto();     
        }
        else if(valorBoton == ‘d’) { //qd
        alto();    
        }
        else if(valorBoton == ‘e’) { //qe
        alto();    
        }
      }
      else if(v == ‘a’){//Validacion no se suelta  a
        izq();
        if(valorBoton == ‘f’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //aq
        gder();    
        }
        else if(valorBoton == ‘w’) { //aw
        rder();    
        }
        else if(valorBoton == ‘z’) { //az
        aizq();    
        }
        else if(valorBoton == ‘x’) { //ax
        ader();     
        }
        else if(valorBoton == ‘c’) { //ac
        alto();     
        }
        else if(valorBoton == ‘d’) { //ad
        alto();    
        }
        else if(valorBoton == ‘e’) { //ae
        alto();    
        }
      }
      else if(v == ‘z’){//Validacion no se suelta  z
        did();
        if(valorBoton == ‘v’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //zq
        alto();    
        }
        else if(valorBoton == ‘a’) { //za
        aizq();    
        }
        else if(valorBoton == ‘w’) { //zw
        alto();    
        }
        else if(valorBoton == ‘x’) { //zx
        ader();     
        }
        else if(valorBoton == ‘c’) { //zc
        alto();     
        }
        else if(valorBoton == ‘d’) { //zd
        alto();    
        }
        else if(valorBoton == ‘e’) { //ze
        alto();    
        }
      }
      else if(v == ‘x’){//Validacion no se suelta  x
        atras();
        if(valorBoton == ‘b’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //xq
        alto();    
        }
        else if(valorBoton == ‘w’) { //xw
        alto();    
        }
        else if(valorBoton == ‘z’) { //xz
        aizq();    
        }
        else if(valorBoton == ‘a’) { //xa
        rder();     
        }
        else if(valorBoton == ‘c’) { //xc
        ader();     
        }
        else if(valorBoton == ‘d’) { //xd
        rizq();    
        }
        else if(valorBoton == ‘e’) { //xe
        alto();    
        }
      }
      else if(v == ‘c’){//Validacion no se suelta  c
        ddd();
        if(valorBoton == ‘n’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //cq
        alto();    
        }
        else if(valorBoton == ‘a’) { //ca
        alto();    
        }
        else if(valorBoton == ‘w’) { //cw
        alto();    
        }
        else if(valorBoton == ‘x’) { //cx
        aizq();     
        }
        else if(valorBoton == ‘z’) { //cz
        alto();     
        }
        else if(valorBoton == ‘d’) { //cd
        ader();    
        }
        else if(valorBoton == ‘e’) { //ce
        alto();    
        }
      }
      else if(v == ‘d’){//Validacion no se suelta  d
        der();
        if(valorBoton == ‘h’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //dq
        alto();    
        }
        else if(valorBoton == ‘a’) { //da
        alto();    
        }
        else if(valorBoton == ‘w’) { //dw
        rizq();    
        }
        else if(valorBoton == ‘x’) { //dx
        rder();     
        }
        else if(valorBoton == ‘z’) { //dz
        alto();     
        }
        else if(valorBoton == ‘c’) { //dc
        ader();    
        }
        else if(valorBoton == ‘e’) { //de
        gizq();    
        }
      }
      else if(v == ‘e’){//Validacion no se suelta  e
        ddu();
        if(valorBoton == ‘y’){
         v = ‘s’;
         alto();
         }
        else if(valorBoton == ‘q’) { //eq
        alto();    
        }
        else if(valorBoton == ‘a’) { //ea
        alto();    
        }
        else if(valorBoton == ‘w’) { //ew
        gizq();    
        }
        else if(valorBoton == ‘x’) { //ex
        alto();     
        }
        else if(valorBoton == ‘z’) { //ez
        alto();     
        }
        else if(valorBoton == ‘d’) { //ed
        gder();    
        }
        else if(valorBoton == ‘c’) { //ec
        alto();    
        }
      }
      
     
      else if(penultimo==’w’ && valorBoton == ‘q’){// wq
        gizq();
      }
      else if(penultimo==’w’ && valorBoton == ‘a’){// wa
        rizq();
      }
      else if(penultimo==’w’ && valorBoton == ‘d’){// wd
        rder();
      }
      else if(penultimo==’w’ && valorBoton == ‘e’){// we
        gder();
      }
      else if(penultimo==’w’ && valorBoton == ‘z’){// wz 
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’w’ && valorBoton == ‘x’){// wx
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’w’ && valorBoton == ‘c’){// wc
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’q’ && valorBoton == ‘w’){// qw
        gder();
      }
      else if(penultimo==’q’ && valorBoton == ‘a’){// qa
        gizq();
      }
      else if(penultimo==’q’ && valorBoton == ‘e’){// qe
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’q’ && valorBoton == ‘d’){// qd
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’q’ && valorBoton == ‘c’){// qc
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’q’ && valorBoton == ‘x’){//qx
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’q’ && valorBoton == ‘z’){//qz
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’a’ && valorBoton == ‘w’){//aw
        rder();
      }
      else if(penultimo==’a’ && valorBoton == ‘q’){//aq
        gder();
      }
      else if(penultimo==’a’ && valorBoton == ‘z’){//az
        aizq();
      }
      else if(penultimo==’a’ && valorBoton == ‘x’){//ax
        rizq();
      }

      else if(penultimo==’a’ && valorBoton == ‘c’){//ac
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’a’ && valorBoton == ‘d’){//ad
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’a’ && valorBoton == ‘e’){//ae
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
      }     
      else if(penultimo==’z’ && valorBoton == ‘a’){ //za
        aizq();
      }
      else if(penultimo==’z’ && valorBoton == ‘x’){ //zx
        ader();
      }
      else if(penultimo==’z’ && valorBoton == ‘q’){//zq
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’z’ && valorBoton == ‘w’){//zw
        antepenultimo== ‘s’;
        alto();
      }
      else if(penultimo==’z’ && valorBoton == ‘e’){//ze
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’z’ && valorBoton == ‘d’){//zd
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’z’ && valorBoton == ‘c’){//zc
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }   
      else if(penultimo==’x’ && valorBoton == ‘a’){ //xa
        rder();
      }
      else if(penultimo==’x’ && valorBoton == ‘z’){ //xz
        aizq();
      }
      else if(penultimo==’x’ && valorBoton == ‘c’){ //xc
        ader();
      }
      else if(penultimo==’x’ && valorBoton == ‘d’){ //xd
        rizq();
      }
      else if(penultimo==’x’ && valorBoton == ‘q’){//xq
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’x’ && valorBoton == ‘w’){//xw
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’x’ && valorBoton == ‘e’){//xe
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }    
      else if(penultimo==’c’ && valorBoton == ‘x’){ //cx
        aizq();
      }
      else if(penultimo==’c’ && valorBoton == ‘d’){ //cd
        ader();
      }
      else if(penultimo==’c’ && valorBoton == ‘z’){//cz
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’c’ && valorBoton == ‘a’){//ca
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’c’ && valorBoton == ‘q’){//cq
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’c’ && valorBoton == ‘w’){//cw
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      } 
      else if(penultimo==’c’ && valorBoton == ‘e’){//ce
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }  
      else if(penultimo==’d’ && valorBoton == ‘w’){ //dw
        rizq();
      }
      else if(penultimo==’d’ && valorBoton == ‘e’){ //de
        gizq();
      }
      else if(penultimo==’d’ && valorBoton == ‘c’){ //dc
        ader();
      }
      else if(penultimo==’d’ && valorBoton == ‘x’){ //dx
        rder();
      }
      else if(penultimo==’d’ && valorBoton == ‘q’){//dq
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’d’ && valorBoton == ‘a’){//da
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’d’ && valorBoton == ‘z’){//dz
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }     
      else if(penultimo==’e’ && valorBoton == ‘w’){ //ew
        gizq();
      }
      else if(penultimo==’e’ && valorBoton == ‘d’){ //ed
        gder();
      }
      else if(penultimo==’e’ && valorBoton == ‘q’) {//eq
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’e’ && valorBoton == ‘a’){//ea
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’e’ && valorBoton == ‘z’){//ez
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’e’ && valorBoton == ‘x’){//ex
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }
      else if(penultimo==’e’ && valorBoton == ‘c’){//ec
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
      }


      else if(valorBoton == ‘w’) { // w
       adelante();
      }
      else if(valorBoton == ‘q’) { // q
      diu();
      }
      else if(valorBoton == ‘a’) { // a
      izq();
      }
      else if(valorBoton == ‘z’) { // z
      did();
      }
      else if(valorBoton == ‘x’) { // x
      atras();
      }
      else if(valorBoton == ‘c’) { // c
      ddd();
      }
      else if(valorBoton == ‘d’) { // d
      der();
      }
      else if(valorBoton == ‘e’) { // e
      ddu();
      }
        else if(penultimo==’w’ && valorBoton == ‘t’){// wt
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
        }
        else if(penultimo==’q’ && valorBoton == ‘r’){// qr
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
        }
        else if(penultimo==’a’ && valorBoton == ‘f’){//af
        penultimo = ‘s’;
        antepenultimo== ‘s’;
        alto();
        }
        else if(penultimo==’z’ && valorBoton == ‘v’){//zv
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
        }
        else if(penultimo==’x’ && valorBoton == ‘b’){//xb
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
        }
        else if(penultimo==’c’ && valorBoton == ‘n’){//cn
        antepenultimo== ‘s’;
        penultimo = ‘s’;
        alto();
        }  
        else if(penultimo==’d’ && valorBoton == ‘h’){//dh
        penultimo = ‘s’;
        alto();
        }
        else if(penultimo==’e’ && valorBoton == ‘y’){//ey
        penultimo = ‘s’;
        alto();
        }      
   antepenultimo = penultimo;   
   penultimo = valorBoton;
  }
}
void adelante() {
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void atras()
{
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void izq() //Lateral izquierda
{
  motor1.run(BACKWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(FORWARD);
}
void der()  //Lateral derecha
{
  motor1.run(FORWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(BACKWARD);
}
void ddu() { // Diagonal Derecha Superior
  motor1.run(FORWARD);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(RELEASE);
}
void ddd() { // Diagonal Derecha Inferior
  motor1.run(RELEASE);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(BACKWARD);
}
void diu() { //Diagonal Izquierda Superior
  motor1.run(RELEASE);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(FORWARD);
}

void did() { //Diagonal Izquierda Inferior
  motor1.run(BACKWARD);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(RELEASE);
}
void gizq()  //Giro a la izquierda adelante
{
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void gder()  //Giro a la derecha adelante
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void aizq() { //Giro a la derecha atras
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}
void ader() { //Giro a la derecha atras
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void rder() { //rotacion a la derecha
  motor1.run(BACKWARD);
  motor2.run(BACKWARD);
  motor3.run(FORWARD);
  motor4.run(FORWARD);
}
void rizq() { //rotacion a la izquierda
  motor1.run(FORWARD);
  motor2.run(FORWARD);
  motor3.run(BACKWARD);
  motor4.run(BACKWARD);
}
void alto() //Paro total
{
  motor1.run(RELEASE);
  motor2.run(RELEASE);
  motor3.run(RELEASE);
  motor4.run(RELEASE);
}

Descarga Código

Robot Móvil 4WD ESP32 Brazo Robótico Omnidireccional

¿Qué es un robot omnidireccional?

¿Qué son las ruedas Mecanum?

Sistema de tracción 4WD

Control mediante ESP32

Transmisión de video por Wi-Fi

Brazo robótico con tres servomotores

Integración de desplazamiento, visión y manipulación

¿Cómo se arma?

¿Cómo lo vamos a programar?

Antes de subir cualquier código, RETIRA EL MODULO BLUETOOTH.

Robot Móvil 4WD ESP32 Brazo Robótico Omnidireccional

¿Qué es un robot omnidireccional?

¿Qué son las ruedas Mecanum?

Sistema de tracción 4WD

Control mediante ESP32

Transmisión de video por Wi-Fi

Brazo robótico con tres servomotores

Integración de desplazamiento, visión y manipulación

¿Cómo se arma?

¿Cómo lo vamos a programar?

Antes de subir cualquier código, RETIRA EL MODULO BLUETOOTH.

Acceder

Registrarse