Icono del sitio AranaCorp

Robot controlado con teléfono

Xukyo

Una de las mejores aplicaciones de la robótica o internet de las cosas(IoT) es controlar un robot con un smartphone. La construcción de un robot controlado a distancia se puede lograr fácilmente con Arduino y un módulo Bluetooth.

Material

Estructura

En este proyecto, utilizamos un robot móvil de 4 ruedas Rovy, pero este proyecto se puede aplicar a cualquier robot móvil programable.

Hardware

La placa debe tener suficientes entradas / salidas para conducir 4 motores de CC con puente H. Aquí usamos un Arduino Mega pero un UNO sería suficiente.

Para poder controlar la velocidad y la dirección de un motor de CC, generalmente se utilizan puentes H como SN754410.

Para comunicarnos con el robot necesitamos un puerto serie. Podríamos usar un cable USB para controlar el robot desde la computadora, pero como el robot es móvil, es mucho mejor usar un dispositivo inalámbrico.

Esquemas

Interfaz

Se puede crear una interfaz de teléfono inteligente simple usando Processing or App Inventor 2. La interfaz tiene cuatro botones que representan las direcciones del robot y un botón para seleccionar el dispositivo Bluetooth. Puede descargar el proyecto de la aplicación en este enlace.

When pushing on a button a corresponding command is sent via Bluetooth.

Botón

Mando

Movimiento

Flecha superior

«F»

Adelante

Flecha izquierda

«L»

Girar a la izquierda

Flecha derecho

«R»

Girar a la derecha

Flecha inferior

«B»

Hacia atrás

“S”

Detener

Si no se presiona ningún botón, la interfaz envía el comando «S» (Detener).

Software

El software se puede dividir en pasos más simples: leer el comando de bluetooth, seleccionar la funcionalidad del robot según el comando y aplicar el control de motores según la funcionalidad.

Lea el comando del módulo Bluetooth

Para saber cómo conectarse y usar HC-06, consulte esta página.

  if (Serial3.available()>=MESSAGE_BYTES)
   { // If data is available to read
    delay(3);
    if( Serial3.read() == HEADER)
    {
     state = (char)Serial3.read(); // read it and store it in val
    }
   }
   Serial.print("Recieved : ");
   Serial.println(state);

Seleccione la función del robot según el comando recibido

Note on Arduino code and keayword switch.

   movementEnable();
   switch(state){
     case 'F':
      GoForward(Power);
      Serial.println("Robot walking");
      break;
    case 'B':
      GoBackward(Power);
      Serial.println("Robot backing");
      break;
    case 'R':
      TurnRight(Power);
      Serial.println("turn right");
      break;  
    case 'L':
      TurnLeft(Power);
      Serial.println("turn left");
      break;  
    default://S
      Stop();
      Serial.println("resting");
    break;
  }

Controle DC Motors para realizar el movimiento seleccionado

Aprenda a conducir un motor de CC here.

void movementEnable(){
    digitalWrite(enableBridge1,HIGH); 
    digitalWrite(enableBridge2,HIGH);
    digitalWrite(enableBridge3,HIGH);
    digitalWrite(enableBridge4,HIGH);
}

void movementDisable(){
    digitalWrite(enableBridge1,LOW); 
    digitalWrite(enableBridge2,LOW);
    digitalWrite(enableBridge3,LOW);
    digitalWrite(enableBridge4,LOW);
}


void GoForward(int Power){
  analogWrite(MotorForward1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorForward3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorForward4,Power);
  analogWrite(MotorReverse4,0);
}

void GoBackward(int Power){
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorForward2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorForward3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorForward4,0);
  analogWrite(MotorReverse4,Power);
}

void TurnRight(int Power){
  analogWrite(MotorForward1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorForward3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorForward4,0);
  analogWrite(MotorReverse4,Power);
}

void TurnLeft(int Power){
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorForward2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorForward3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorForward4,Power);
  analogWrite(MotorReverse4,0);
}

void Stop(){
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward2,0);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorForward3,0);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorForward4,0);
  analogWrite(MotorReverse4,0);
  movementDisable();
}

Código completo

#include <Servo.h>
#include <SoftwareSerial.h>                              
//SoftwareSerial HC06(2,3);                              // If board different from Mega
// Motors definition
const int enableBridge1 = 22;
const int enableBridge2 = 23;
const int enableBridge3 = 24;
const int enableBridge4 = 25;

const int MotorForward1 = 11;
const int MotorReverse1 = 10;
const int MotorForward2 = 8;
const int MotorReverse2 = 9;
const int MotorForward3 = 7;
const int MotorReverse3 = 6;
const int MotorForward4 = 4;
const int MotorReverse4 = 5;

//Serial port
#define HEADER        '|'
#define MESSAGE_BYTES  2  // the total bytes in a message
char state='S';

// Parameters
int Power = 80; //Motor velocity


/******************************************************************\
* PRIVATE FUNCTION: setup
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
* Initiate inputs/outputs
*
\******************************************************************/

void setup(){
  Serial3.begin(9600);
  Serial.begin(9600);
  delay(500);
}

/******************************************************************\
* PRIVATE FUNCTION: loop
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
* Main Function of the code 
\******************************************************************/

void loop(){
 
  if (Serial3.available()>=MESSAGE_BYTES)
   { // If data is available to read
    delay(3);
    if( Serial3.read() == HEADER)
    {
     state = (char)Serial3.read(); // read it and store it in val
    }
   }
   Serial.print("Recieved : ");
   Serial.println(state);

   movementEnable();
   switch(state){
     case 'F':
      GoForward(Power);
      Serial.println("Robot walking");
      break;
    case 'B':
      GoBackward(Power);
      Serial.println("Robot backing");
      break;
    case 'R':
      TurnRight(Power);
      Serial.println("turn right");
      break;  
    case 'L':
      TurnLeft(Power);
      Serial.println("turn left");
      break;  
    default://S
      Stop();
      Serial.println("resting");
    break;
  }
     
}


/******************************************************************\
* PRIVATE FUNCTION: movementEnable
*
* PARAMETERS:
* ~ void
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
*   Enable motor control   
\*****************************************************************/
void movementEnable(){
    digitalWrite(enableBridge1,HIGH); 
    digitalWrite(enableBridge2,HIGH);
    digitalWrite(enableBridge3,HIGH);
    digitalWrite(enableBridge4,HIGH);
}

void movementDisable(){
    digitalWrite(enableBridge1,LOW); 
    digitalWrite(enableBridge2,LOW);
    digitalWrite(enableBridge3,LOW);
    digitalWrite(enableBridge4,LOW);
}

/******************************************************************\
* PRIVATE FUNCTION: GoForward
*
* PARAMETERS:
* ~ int Power motor velocity
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
*        
\*****************************************************************/


void GoForward(int Power){
  analogWrite(MotorForward1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorForward3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorForward4,Power);
  analogWrite(MotorReverse4,0);
}

/******************************************************************\
* PRIVATE FUNCTION: GoBackward
*
* PARAMETERS:
* ~ int Power motor velocity
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
*        
\*****************************************************************/

void GoBackward(int Power){
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorForward2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorForward3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorForward4,0);
  analogWrite(MotorReverse4,Power);
}

/******************************************************************\
* PRIVATE FUNCTION: TurnRight
*
* PARAMETERS:
* ~ int Power motor velocity
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
*        
\*****************************************************************/

void TurnRight(int Power){
  analogWrite(MotorForward1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorForward3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorForward4,0);
  analogWrite(MotorReverse4,Power);
}

void TurnLeft(int Power){
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorForward2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorForward3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorForward4,Power);
  analogWrite(MotorReverse4,0);
}

void Stop(){
  analogWrite(MotorForward1,0);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorForward2,0);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorForward3,0);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorForward4,0);
  analogWrite(MotorReverse4,0);
  movementDisable();
}

Resultados

Si desea más información sobre este proyecto, no dude en dejar un comentario o enviarnos un mensaje.

Fuentes

Apprende la programación con Arduino

Controla un motor CC con Arduino

Arduino y el modulo HC-06

Rovy
Salir de la versión móvil