fbpixel
Etiquetas: , , , ,

Uma funcionalidade muito interessante para desenvolver no seu robô é o controlo remoto através do smartphone. Um robô controlado por telemóvel pode ser facilmente construído utilizando o Arduino e um módulo Bluetooth.

Hardware

  • Robô móvel Rovy
  • 4x TTGM
  • Motor DC (aqui estamos a usar um shield de prototipagem Arduino Mega e 2x SN754410 H-bridge)
  • Bateria de 7,4V
  • Módulo Bluetooth HC-06
  • Arduino Mega
  • Smartphone Android

Estrutura

Neste projeto, estamos a utilizar o robô móvel Rovy, mas esta solução pode ser aplicada a qualquer tipo de robô programável.

rovy-assembled-scaled Robô controlado por smartphone

Hardware

  • Microcontrolador

O cartão deve ter entradas suficientes.

  • Condutor

Para controlar a velocidade e a direção de um motor DC, são frequentemente utilizadas pontes H como a SN754410.

  • HC-06

Para comunicar sem fios com o robot, um dos métodos mais simples é utilizar um módulo Bluetooth HC-06 ligado ao Arduino.

Esquema de montagem

rovy-arduino-bt-sketch Robô controlado por smartphone

Interface

Pode ser criada uma aplicação simples utilizando o Processing ou o App Inventor 2. A aplicação inclui quatro botões que representam as direcções do robô, um botão e um ecrã para gerir a ligação Bluetooth. Pode descarregar o projeto da aplicação aqui.

appinventor2-rovy-interface Robô controlado por smartphone

Quando um botão de direção é premido, o comando correspondente é enviado via Bluetooth sob a forma de um carácter.

Botão

Encomendar

Movimento

Topo

“F”

Avançar

Esquerda

“L”

Virar à esquerda

Certo

“R”

Virar à direita

Baixa

“B”

Para trás

 

“S”

Parar

Si aucun bouton n’est pressé la commande “S” est envoyée.

Software

O programa a ser implementado no Arduino pode ser dividido em passos simples. Ler o comando do módulo Bluetooth, selecionar uma função a partir do comando recebido e controlar os motores de acordo com o movimento selecionado.

Ler o comando do módulo HC-06

Na placa Arduino Mega, estão predefinidas 3 portas série. Com outra placa, teria de utilizar a biblioteca SoftwareSerial.h. Para mais informações, leia o tutorial sobre o módulo HC-06.

  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);

Selecionar a função de movimento correspondente ao comando

Saiba como utilizar a palavra-chave switch.

   movementEnable();
   switch(state){
     case 'F':
      GoAvançar(Power);
      Serial.println("Robot walking");
      break;
    case 'B':
      GoPara trás(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
      Parar();
      Serial.println("resting");
    break;
  }

Verificação dos motores de corrente contínua

Veja como acionar um motor DC aqui.

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 GoAvançar(int Power){
  analogWrite(MotorAvançar1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorAvançar2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorAvançar3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorAvançar4,Power);
  analogWrite(MotorReverse4,0);
}

void GoPara trás(int Power){
  analogWrite(MotorAvançar1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorAvançar2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorAvançar3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorAvançar4,0);
  analogWrite(MotorReverse4,Power);
}

void TurnRight(int Power){
  analogWrite(MotorAvançar1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorAvançar2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorAvançar3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorAvançar4,0);
  analogWrite(MotorReverse4,Power);
}

void TurnLeft(int Power){
  analogWrite(MotorAvançar1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorAvançar2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorAvançar3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorAvançar4,Power);
  analogWrite(MotorReverse4,0);
}

void Parar(){
  analogWrite(MotorAvançar1,0);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorAvançar2,0);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorAvançar3,0);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorAvançar4,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 MotorAvançar1 = 11;
const int MotorReverse1 = 10;
const int MotorAvançar2 = 8;
const int MotorReverse2 = 9;
const int MotorAvançar3 = 7;
const int MotorReverse3 = 6;
const int MotorAvançar4 = 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':
      GoAvançar(Power);
      Serial.println("Robot walking");
      break;
    case 'B':
      GoPara trás(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
      Parar();
      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: GoAvançar
*
* PARAMETERS:
* ~ int Power motor velocity
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
*        
\*****************************************************************/


void GoAvançar(int Power){
  analogWrite(MotorAvançar1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorAvançar2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorAvançar3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorAvançar4,Power);
  analogWrite(MotorReverse4,0);
}

/******************************************************************\
* PRIVATE FUNCTION: GoPara trás
*
* PARAMETERS:
* ~ int Power motor velocity
*
* RETURN:
* ~ void
*
* DESCRIPTIONS:
*        
\*****************************************************************/

void GoPara trás(int Power){
  analogWrite(MotorAvançar1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorAvançar2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorAvançar3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorAvançar4,0);
  analogWrite(MotorReverse4,Power);
}

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

void TurnRight(int Power){
  analogWrite(MotorAvançar1,Power);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorAvançar2,0);
  analogWrite(MotorReverse2,Power);
  analogWrite(MotorAvançar3,Power);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorAvançar4,0);
  analogWrite(MotorReverse4,Power);
}

void TurnLeft(int Power){
  analogWrite(MotorAvançar1,0);
  analogWrite(MotorReverse1,Power);
  analogWrite(MotorAvançar2,Power);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorAvançar3,0);
  analogWrite(MotorReverse3,Power);
  analogWrite(MotorAvançar4,Power);
  analogWrite(MotorReverse4,0);
}

void Parar(){
  analogWrite(MotorAvançar1,0);
  analogWrite(MotorReverse1,0);
  analogWrite(MotorAvançar2,0);
  analogWrite(MotorReverse2,0);
  analogWrite(MotorAvançar3,0);
  analogWrite(MotorReverse3,0);
  analogWrite(MotorAvançar4,0);
  analogWrite(MotorReverse4,0);
  movementDisable();
}



Resultados

Se desejar obter mais informações sobre este projeto, deixe um comentário ou envie-nos uma mensagem.

Fontes