Ensamble Configuracion Robot Arduino 4wd

Coloque el chasis inferior sobre un plano y monte el Dual H Bridge L298N sobre él (use 4 tornillos).

Tenga en cuenta la orientación del puente Dual H (ver imagen como referencia).

Monte el motor de CC 4 en el chasis usando el tornillo y la tuerca más largos (ver imagen como referencia).

Conecte los 4 motores de CC al puente H doble L298N siguiendo el esquema. Recuerde que el puente H doble L298N puede controlar 2 motores de CC y que debemos conectar los motores derecho e izquierdo.

Monte el módulo de seguimiento de 5 V de 5 vías en la parte frontal del chasis inferior utilizando el orificio (ver imagen como referencia). Para este paso, utilice los dos espaciadores impresos y dos tuercas/tornillos M2.

Atornille los 4 separadores M3 x 50 mm al chasis inferior con el tornillo M3 pequeño. Este separador se usará para fijar el chasis inferior al chasis superior.

Coloque el chasis superior sobre un plano y monte la placa Arduino sobre él (use 4 tornillos).

Coloque el Arduino Sensor Shield V5.0 en la parte superior de la placa Arduino teniendo cuidado de que los pines correspondientes estén acoplados entre sí.

Monte los dos sensores IR en el chasis con el tornillo. Utilice los soportes del chasis para orientar el sensor 30°. Este paso es importante porque los sensores IR se utilizan para detectar obstáculos a los lados derecho e izquierdo del robot.

Monte el Micro servo SG90 en el orificio cuadrado del chasis. Use 2 tornillos para fijarlo.

Monte el módulo del zumbador en el chasis con el tornillo. Utilice el soporte para la orientación correcta.

Monte el soporte de la batería en el chasis con los 2 tornillos. Utilice el soporte para la orientación correcta.

Ya has ensamblado los chasis superior e inferior. ¡Buen trabajo!

Continuemos con el otro paso.

Utilice el soporte facial impreso en 3D e inserte el sensor de ultrasonido HC-SR04 en los 2 orificios redondos.

A continuación monta el soporte en el micro servo que ya está instalado en el chasis.

Conecte el sensor de ultrasonido HC-SR04 utilizando 4 cables hembra-hembra.

Monte la cámara ESP32 en el soporte facial impreso en 3D.

Conecte la cámara ESP32 usando 2 cables hembra-hembra (5 V y GND).

Ahora podemos empezar a cablear el Smart Car.

Antes de ensamblar el chasis, tenemos que cablear el componente en la parte inferior del chasis para poder usar el orificio para pasar.

Conecte el módulo de seguimiento de 5 V y 5 vías en el chasis inferior utilizando un cable hembra-hembra de 5 pines.

Conecte el puente H doble L298N en el chasis inferior utilizando 6 cables hembra-hembra.

Conecte el puerto GND, 5V usando 2 cables macho-macho.

Conecte el puerto GND de 12 V del puente H doble al soporte de la batería. Importante: Apague el interruptor de encendido.

Ahora puedes usar el orificio del chasis superior para pasar el cable hembra-hembra que instalaste anteriormente. No olvides el cable del microservo.

Coloque el chasis superior en la parte superior y fíjelo con el chasis inferior usando un tornillo M3.

Ahora podemos continuar cableando el otro componente en el chasis superior.

Conecte ambos sensores IR en el chasis superior utilizando 3 cables hembra-hembra para cada uno.

Conecte el módulo del zumbador en el chasis superior utilizando 3 cables hembra-hembra.

Intente unir todos los cables usando un elástico o algo similar.

Detalle del cableado:

Controlador de motor L298N:

+12 V → Batería de lipo (+)

GND → Batería Lipo (- )  importante:  conectar el GND a la batería lipo (-) y a cualquier pin GND de la placa Arduino

+5 V →  Vin de Arduino

EnA → pin digital 3 de arduino

In1 → pin digital 4 de Arduino

In2 → pin digital 5 de Arduino

In3 → pin digital 6 de Arduino

In4 → pin digital 7 de Arduino

EnB → pin digital 11 de Arduino

OUT1 → Motor FWD+BWD Derecha

OUT2 → Motor FWD+BWD Derecha

OUT3 → Motor FWD+BWD Izquierda

OUT4 → Motor FWD+BWD Izquierda

 

Módulo zumbador:

GND → arduino G

VCC → arduino V

E/S → pin digital 13 de Arduino

Microservo:

GND → arduino G

VCC → arduino V

EN → pin digital 12 de arduino

Sensor IR derecho:

GND → arduino G

VCC → arduino V

SALIDA → pin digital 2 de arduino

Sensor IR izquierdo:

GND → arduino G

VCC → arduino V

SALIDA → pin digital 8 de arduino

HC-SR04 Ultrasónico

Sensor de sonar:

VCC → Arduino URF +5V

Trig → pin analógico 2 del URF de Arduino

Eco → pin analógico 3 del URF de Arduino

GND → Arduino URF GND

Módulo de seguimiento:

GND → arduino G

5 V → Arduino V

OUT2 → pin analógico 4 de Arduino

OUT3 → pin analógico 1 de Arduino

OUT4 → pin analógico 0 de Arduino

Módulo Bluetooth HC-06

GND → arduino G

5 V → Arduino V

TX → arduino RX

RX → TX de Arduino

Cámara ESP32

GND → arduino G

5 V → Arduino V

RX → arduino TX importante:  al conectarlo debes desconectar el Bluetooth

Monte la mini placa de pruebas en el chasis superior usando el adhesivo.

Conecte el puerto de 12 V del puente H dual a la placa de pruebas mediante un cable macho-macho.

Voltaje de la batería (conexión en serie con resistencia de 100k y 1M)

Resistencia de 100k → 12 V

Resistencia de 100 kJ/1 M → pin analógico 5 de Arduino

Resistencia de 1 M → arduino G

¡La mini placa de pruebas también se puede utilizar para tus propios experimentos!

Ahora ya puedes completar el trabajo ensamblando las 4 ruedas de plástico y agrupando todos los cables.

Descargue e instale el IDE de escritorio Arduino

ventanas - https://www.arduino.cc/es/Guide/Windows
Mac OS X: https://www.arduino.cc/en/Guide/MacOSX
Linux - https://www.arduino.cc/es/Guide/Linux




Cree una carpeta llamada Catosci_SmartCar y guarde todos los archivos .ino, .cpp y .h.

Abra el archivo Catosci_SmartCar.ino en Arduino IDE y cárguelo en la placa Arduino.




Importante: Recuerde desconectar el Bluetooth antes de conectar el cable USB







/**********************************************************************
  Nombre del archivo: Catosci_SmartCar.ino
  Producto: Coche 4x4 Catosci para UNO
  Descripción: Un control remoto Bluetooth multifuncional para automóvil.
  Autor: Carlo Iurisci
  Modificación: 25/03/2022
*************************************************************************/
#include "Coche Catosci 4x4 para Arduino.h"
#include "Modo_Automático_De_Evitación_De_Obstáculos.h"
#include "Modo_de_Línea_de_Seguimiento_Automático.h"
#include "BluetoothOrders.h"

#define TIEMPO_DE_VOLUMEN_DE_CARGA 3000
#define TIEMPO DE CARGA DE DATOS 500
#define CONTADOR_MÁXIMO_DE_COMANDOS 8
#define INTERVAL_CHAR '@'


//#define DEBUG


u32 último tiempo de voltaje de carga;
u32 últimoTiempoDeCargaDeDatos;
Cadena de entradaStringBLE = "";
bool stringComplete = falso;
int parámetros[CONTADOR_MÁXIMO_DE_COMANDOS], conteo_de_parámetros = 0;
int bleCarMode = MODO_NINGUNO;

configuración vacía() {
  pinsSetup();
  Serial.begin(9600);
  servoSetup();
// mientras (!strip.begin());
// tira.setAllLedsColor(0xFF0000);
}


bucle vacío() {
  // invia misura Vbatteria all'App ogni UPLOAD_VOL_TIME
  subirVoltajeDeCargaAApp();
  // invia lettura sensori all'App ogni UPLOAD_DATA_TIME
  cargarYLeerSonarValueToApp();
  
  if (stringComplete) { //da eseguiro solo en la preparación de un comando
    Cadena inputCommandArray[CONTADOR_MÁXIMO_DE_COMANDOS];


    Cadena inputStringTemp = inputStringBLE;
    para (u8 i = 0; i < CONTADOR_MÁXIMO_DE_COMANDOS; i++) {
      int índice = inputStringTemp.indexOf(INTERVAL_CHAR);
      si (índice < 0) {
        romper;
      }
      parámetroCount = i; //
      inputCommandArray[i] = inputStringTemp.substring(0, índice);
      inputStringTemp = inputStringTemp.substring(índice + 1);
      parámetros[i] = inputCommandArray[i].toInt();
    }
    cadenaCompleta = falso;
    cadena de entradaBLE = "";


    char commandChar = inputCommandArray[0].charAt(0);
    interruptor (comandoChar)
    {
      caso ACCION_MOVE:
        si (parámetroCount == 2) {
          motorRun(parámetros[1], parámetros[2]); //la aplicación controla que la velocidad del motor sea 0 ~ 100, pwm sea 0 ~ 255
        }
        romper;
      caso ACTION_CAR_MODE:
        si (parámetroCount == 1) {
          bleCarMode = parámetros[1];
          interruptor (bleCarMode)
          {
            caso MODO_NINGUNO: caso MODO_GRAVEDAD:
              reiniciarAccionDeCoche();
              escribirServo(OA_SERVO_CENTER);
              romper;
            caso MODO_ULTRASONICO: 
              oa_CalculateVoltageCompensation();
              romper;
            caso MODO_ULTRASONICO_NOIR:
              oa_CalculateVoltageCompensation();
              romper;
            caso MODO_SEGUIR:
              oa_CalculateVoltageCompensation();
              romper;           
            caso MODO_SEGUIMIENTO:
              tk_CalculateVoltageCompensation();
              romper;
            por defecto:
              romper;
          }
        }
        romper;
      caso ACTION_BUZZER:
        si (parámetroCount == 1) {
          setBuzzer(parámetros[1]);
        }
        romper;
      por defecto:
        romper;
    }
  }


  switch (bleCarMode) //bucle para modalidad de control
  {
    caso MODO_NINGUNO: caso MODO_GRAVEDAD:
      romper;
    caso MODO_ULTRASONICO: 
      actualizarEvitaciónAutomáticaDeObstáculos();
      romper;
    caso MODO_ULTRASONICO_NOIR:
      actualizarAutomaticObstacleAvoidanceNoInfrared();
      romper;
    caso MODO_SEGUIR:
      Seguimiento ultrasónico();
      romper;           
    caso MODO_SEGUIMIENTO:
      actualizarAutomaticTrackingLine();
      romper;
    por defecto:
      romper;
  }

anular upLoadVoltageToApp() {
  int voltaje = 0;
  si (milis() - últimoTiempoDeVoltajeDeCarga > TIEMPO_DE_VOLUMEN_DE_CARGA) {
    si (obtenerVoltajeDeBatería()) {
      voltaje = VoltajeBatería * 1000;
    }
    Cadena sendString = Cadena(ACCION_OBTENER_VOLTAJE) + Cadena(INTERVAL_CHAR) + Cadena((voltaje)) + Cadena(INTERVAL_CHAR);
    Serial.println(enviarCadena);
    
    últimoTiempoDeVoltajeDeCarga = millis();
  }
}

anular upLoadAndReadSonarValueToApp() {
  // invia lettura sensori all'App
  si (milis() - lastUploadDataTime > TIEMPO_DE_DATOS_DE_CARGA) {
    Cadena sendString = Cadena(ACCIÓN_ULTRASONIC)+Cadena(INTERVAL_CHAR)+Cadena(getSonar());
    sendString += String(INTERVAL_CHAR)+ String(digitalRead(IR_AVOIDANCE_RIGHT_PIN));
    sendString += String(INTERVAL_CHAR) + String(digitalRead(IR_AVOIDANCE_LEFT_PIN)) + String(INTERVAL_CHAR);
    Serial.println(enviarCadena);
    
    lastUploadDataTime = millis();
  }
}


void serialEvent() {
  mientras (Serial.disponible()) {
    char inChar = (char)Serial.read();
    inputStringBLE += inChar;
    si (inChar == 'n') {
      cadenaCompleta = verdadero;
      Serial.println(inputStringBLE);
    }
  }
}

Cuando se complete la carga, el código comenzará a ejecutarse.

El mini servo se posicionará a 90°.

Importante: vuelva a colocar el soporte facial en el servo si es necesario.

Ahora puedes probar el movimiento del robot y el modo de acción con el comando serial.

Siguiendo instrucciones para los comandos seriales:

#define ACTION_MOVE 'A' //controla el movimiento del smartcar A#speedl#speedr#
#define ACTION_CAR_MODE 'H' //modo coche inteligente. 
                  // H#MODE_NONE->detener
                  // H#MODO_GRAVEDAD->detener
                  // H#MODE_ULTRASONIC->evitación de obstáculos con sonar e infrarrojos
                  // H#MODE_ULTRASONIC_NOIR->evitación de obstáculos con sonar y no-ir
                  // H#MODE_TRACKING->seguimiento con ir          
                  // H#MODE_FOLLOW->seguir con sonar e ir   
#define ACTION_BUZZER 'D' //controlar timbre D#1# timbre activado / D#0# timbre desactivado

#define MODO_NINGUNO 0
#define MODO_GRAVEDAD 1
#define MODO_ULTRASONICO 2
#define MODO_ULTRASONIDO_NEGRO 3
#define MODO_SEGUIMIENTO 4
#define MODO_SEGUIMIENTO 5

Ahora es momento de programar la ESP32 CAM para transmitir video en tiempo real. Sigue este tutorial para conectar la ESP32 CAM al puerto USB de tu laptop/computadora usando un programador FTDI.

https://randomnerdtutorials.com/codigo-de-carga-de-programa-esp32-cam/

Cree una carpeta llamada esp32cam-robot y guarde app_httpd.cpp,esp32cam-robot.ino.

Abra el archivo esp32cam-robot.ino en Arduino IDE.

Antes de cargar el código, debes insertar tus credenciales de red en las siguientes variables:

const char* ssid = "REEMPLAZAR_CON_SU_SSID";
const char* contraseña = "REEMPLAZAR_CON_SU_CONTRASEÑA";

Luego, haga clic en el  botón Cargar  en su IDE de Arduino

Cuando comience a ver algunos puntos en la ventana de depuración, presione el botón RST integrado del ESP32-CAM.

Después de unos segundos, el código debería cargarse exitosamente en su tablero.

Cuando vea el mensaje “ Carga finalizada ”, deberá quitar GPIO 0 de GND y presionar el botón RST para ejecutar su nuevo código.

En el monitor serie debería ver algo similar a esto. Anote la dirección IP del ESP32 .

20:43:13.775 -> ..........
20:43:18.265 -> WiFi conectado
20:43:18.265 -> ¡Cámara lista! Usa "http://192.168.1.27" para conectarte.
20:43:18.359 -> Iniciando servidor web en el puerto: '80'
20:43:18.359 -> Iniciando servidor de transmisión en el puerto: '81'

Ahora puedes usar la App desarrollada para controlar el Robot vía bluetooth y ver vídeo en tiempo real vía wifi.

Descargue el archivo apk de GitHub https://github.com/catosci/CatosciApp/blob/main/release/catosci.apk

¡Felicidades! ¡Tu robot ya es un FPV!