Controle de Motores com a Rocky

Introdução

A mais nova placa da RoboCore, a BlackBoard Rocky, é perfeita para projetos que precisam do controle independente de três motores DC, como os robôs de combate da categoria Cupim, que dependem de dois motores para a locomoção e um motor para a arma.

Neste tutorial veremos como controlar os motores, em um primeiro projeto mostrando como utilizar dois dos motores para locomoção, e em um segundo projeto como acionar os três motores individualmente.

Este tutorial é uma continuação do tutorial Primeiros Passos com a BlackBoard Rocky, portanto sugerimos que siga todos os seus passos antes de seguir este tutorial.

Lista de Materiais

Para este tutorial você precisará dos seguintes itens:

Lista completa de produtos

comprar

BlackBoard Rocky

R$ 123,40 no PIX

Conversor USB x UART

R$ 44,55 no PIX

Motor DC 3-6V com Caixa de Redução e Eixo Duplo

R$ 7,50 no PIX

Bateria Li-Ion 18650 3,7V 2600mAh

R$ 37,90 no PIX

Suporte para 2 Baterias Li-Ion 18650

R$ 9,97 no PIX

Cabo USB Micro B 80cm

R$ 9,40 no PIX

Atenção: os motores DC 3-6V com Caixa de Redução e Eixo Duplo, quando comprados separadamente como na lista acima, não são enviados com fios soldados, portanto será necessário fazer a solda dos terminais dos motores usando cabos elétricos, como este (independente da cor).

Observação: as baterias 18650 recomendadas e listadas acima são recarregáveis, mas devem ser carregadas utilizando um carregador adequado (como este, por exemplo).

Acionamento de Motores para Locomoção

A biblioteca da Rocky possui uma série de funções que acionam em conjunto dois motores, para facilitar a locomoção dos robôs, e veremos estas funções neste projeto.

Circuito

Para o acionamento de dois motores da Rocky para locomoção, monte o circuito a seguir.

Atenção: como a BlackBoard Rocky está sendo alimentada pelas baterias neste circuito, o conversor USB-UART não pode alimentar a placa também, senão poderá haver um dano permanente na placa ou no conversor. Para evitar isso, remova o jumper seletor de tensão do conversor, e guarde-o.

Código

Com circuito montado, carregue o código a seguir na sua BlackBoard Rocky. Lembrando novamente que o jumper seletor de tensão do conversor USB-UART deve estar desconectado do mesmo.

/****************************************************************
 * RoboCore - Controle de Motores com a Rocky - Locomocao
 * Faz o robo executar uma sequencia de movimentos infinitamente.
****************************************************************/

//adiciona a biblioteca de controle dos motores ao codigo
#include <RoboCore_Rocky.h>

//configura o objeto "motores" a partir da biblioteca
RockyMotors motores;

void setup() {
  //nao ha nada para ser configurado no codigo
}

void loop() { //acoes que serao executadas infinitamente

  //aciona os dois motores para frente com velocidade maxima
  motores.forward(100);
  delay(1000); //mantem os motores girando pelo tempo determinado
  motores.stop(); //para os motores para a nova acao

  //aciona o motor da esquerda com 90% da velocidade maxima e o motor da direita com 30%, girando o robo para a direita
  motores.turn(90,30);
  delay(1000); //mantem os motores girando pelo tempo determinado
  motores.stop(); //para os motores para a nova acao
  
  //aciona o motor da esquerda com 30% da velocidade maxima e o motor da direita com 90%, girando o robo para a esquerda
  motores.turn(30,90);
  delay(1000); //mantem os motores girando pelo tempo determinado
  motores.stop(); //para os motores para a nova acao

  //aciona os dois motores para tras com velocidade maxima
  motores.backward(100);
  delay(1000); //mantem os motores girando pelo tempo determinado
  motores.stop(); //para os motores para a nova acao

  //aciona o motor da esquerda com 30% da velocidade maxima para tras e o motor da direita com 90% para tras, girando o robo para a esquerda
  motores.turn(-30,-90);
  delay(1000); //mantem os motores girando pelo tempo determinado
  motores.stop(); //para os motores para a nova acao;

  //aciona o motor da esquerda com 90% da velocidade maxima para tras e o motor da direita com 30% para tas, girando o robo para a direita
  motores.turn(-90,-30);
  delay(1000); //mantem os motores girando pelo tempo determinado
  motores.stop(); //para os motores para a nova acao

}

Entendendo o Código

O código se inicia com a inclusão da biblioteca da Rocky que instalamos anteriormente, e a criação do objeto motores como instância de RockyMotors da biblioteca. Com este objeto conseguiremos controlar os motores como desejamos.

Como todas as configurações necessárias para o controle dos motores pela placa são feitas internamente pela biblioteca, não é necessário realizar nada na configuração do código (função void setup()).

Já na repetição do código, temos as funções para acionamento dos motores pela placa. A primeira delas é o comando motores.forward(), que aciona os motores A e B com a velocidade máxima (o valor pode ser entre 0 e 100 %), para que o robô ande para frente. Após manter os motores girando durante 1 segundo, os motores são parados através do comando motores.stop(). Em seguida, através do comando motores.turn(90,30) fazemos com que o robô gire para a direita, acionando o motor da esquerda com uma velocidade maior que o da direita graças à função turn(velocidade_esquerda, velocidade_direita). Após manter o robô girando durante 1 segundo e pará-los novamente, o robô é girado para a direita invertendo o acionamento da função turn() anterior, gerando o comando motores.turn(30,90). Em seguida, acionamos os motores para que o robô se mova para trás usando o comando motores.backward(100). Por fim, giramos o robô novamente o robô para ambos os lados, porém agora girando os motores para trás, usando números negativos nas funções turn().

//aciona os dois motores para frente com velocidade maxima
motores.forward(100);
delay(1000); //mantem os motores girando pelo tempo determinado
motores.stop(); //para os motores para a nova acao

//aciona o motor da esquerda com 90% da velocidade maxima e o motor da direita com 30%, girando o robo para a direita
motores.turn(90,30);
delay(1000); //mantem os motores girando pelo tempo determinado
motores.stop(); //para os motores para a nova acao
  
//aciona o motor da esquerda com 30% da velocidade maxima e o motor da direita com 90%, girando o robo para a esquerda
motores.turn(30,90);
delay(1000); //mantem os motores girando pelo tempo determinado
motores.stop(); //para os motores para a nova acao

//aciona os dois motores para tras com velocidade maxima
motores.backward(100);
delay(1000); //mantem os motores girando pelo tempo determinado
motores.stop(); //para os motores para a nova acao

//aciona o motor da esquerda com 30% da velocidade maxima para tras e o motor da direita com 90% para tras, girando o robo para a esquerda
motores.turn(-30,-90);
delay(1000); //mantem os motores girando pelo tempo determinado
motores.stop(); //para os motores para a nova acao;

//aciona o motor da esquerda com 90% da velocidade maxima para tras e o motor da direita com 30% para tas, girando o robo para a direita
motores.turn(-90,-30);
delay(1000); //mantem os motores girando pelo tempo determinado
motores.stop(); //para os motores para a nova acao

O Que Deve Acontecer

Assim que o código for gravado corretamente para a placa, os motores A e B serão acionados seguindo a sequência de movimentos mencionados anteriormente, como no GIF abaixo:

Resultado Final

Acionamento Independente dos Três Motores

Para aproveitar ao máximo o potencial da Rocky, precisamos aproveitar os três drivers de motores da placa, e veremos como controlá-los individualmente neste projeto.

Circuito

Para o acionamento dos três motores da Rocky monte o circuito a seguir.

Atenção: como a BlackBoard Rocky está sendo alimentada pelas baterias neste circuito, o conversor USB-UART não pode alimentar a placa também, senão poderá haver um dano permanente na placa ou no conversor. Para evitar isso, remova o jumper seletor de tensão do conversor, e guarde-o.

Código

Com circuito montado, carregue o código a seguir na sua BlackBoard Rocky. Lembrando novamente que o jumper seletor de tensão do conversor USB-UART deve estar desconectado do mesmo.

/****************************************************************
 * RoboCore - Controle de Motores com a Rocky - Independente
 * Aciona gradativamente os 3 motores em sequencia.
****************************************************************/

//adiciona a biblioteca de controle dos motores ao codigo
#include <RoboCore_Rocky.h>

//configura o objeto "motores" a partir da biblioteca
RockyMotors motores;

void setup() {
  //nao ha nada para ser configurado no codigo
}

void loop() { //acoes que serao executadas infinitamente

  //rampa de aceleracao do motor A no sentido horario
  for(int i = 0; i < 101; i++){
    motores.setSpeedA(i); //aciona o motor A com o valor de i (0 -> 100)
    delay(10);
  }
  delay(500);
  motores.setSpeedA(0); //para o motor A
  delay(500);

  //rampa de aceleracao do motor B no sentido anti-horario
  for(int i = 0; i > -101; i--){
    motores.setSpeedB(i); //aciona o motor A com o valor de i (0 -> -100)
    delay(10);
  }
  delay(500);
  motores.setSpeedB(0); //para o motor B
  delay(500);

  //rampa de aceleracao do motor C no sentido horario
  for(int i = 0; i < 101; i++){
    motores.setSpeedC(i); //aciona o motor C com o valor de i (0 -> 100)
    delay(10);
  }
  delay(500);
  motores.setSpeedC(0); //para o motor C
  delay(500);

}

Entendendo o Código

O código deste projeto se inicia da mesma forma que o código do projeto anterior, onde incluímos a biblioteca da placa e criamos o objeto motores para o controle dos motores da placa.

Já na repetição do código, temos o laço for(int i = 0; i < 101; i++) que incrementa a variável interna i de 0 até 100. Então, a cada repetição deste laço, acionamos o motor A com o valor da variável interna através do comando motores.setSpeedA(i). Ao sair do laço, o motor se mantém girando em velocidade máxima durante meio segundo, e então ele é parado. Após o acionamento do motor A, temos o acionamento do motor B, que é feito da mesma forma, porém variando a variável interna entre 0 e -100 para que ele gire no sentido oposto do motor A. Por fim, o motor C é acionado da mesma forma que o motor A.

//rampa de aceleracao do motor A no sentido horario
for(int i = 0; i < 101; i++){
  motores.setSpeedA(i); //aciona o motor A com o valor de i (0 -> 100)
  delay(10);
}
delay(500);
motores.setSpeedA(0); //para o motor A
delay(500);

//rampa de aceleracao do motor B no sentido anti-horario
for(int i = 0; i > -101; i--){
  motores.setSpeedB(i); //aciona o motor A com o valor de i (0 -> -100)
  delay(10);
}
delay(500);
motores.setSpeedB(0); //para o motor B
delay(500);

//rampa de aceleracao do motor C no sentido horario
for(int i = 0; i < 101; i++){
  motores.setSpeedC(i); //aciona o motor C com o valor de i (0 -> 100)
  delay(10);
}
delay(500);
motores.setSpeedC(0); //para o motor C
delay(500);

O Que Deve Acontecer

Com o código gravado, os três motores da Rocky serão adicionados gradativamente em sequência, como no GIF abaixo.

Resultado Final

Indo Além

Outra funcionalidade importante da placa é que ela possui monitoramento de tensão da bateria, o que é fundamental para evitar que as suas baterias descarreguem além do mínimo permitido, quando são perdidas. Você pode entender melhor como essa funcionalidade funciona através do exemplo "SupplyVoltage" da biblioteca da placa.

Conclusão

Neste tutorial vimos como usar a BlackBoard Rocky para controlar os seus três motores de forma independente.

Solução de Problemas

Um ou os dois motores estão girando no sentido oposto ao esperado

Se, na execução da função forward(), um dos motores, ou os dois, estiver girando no sentido horário ao invés do anti-horário, é sinal que ele está com a polaridade invertida, portanto apenas desconecte e conecte os fios deste motor na ordem invertida.

LED vermelho aceso

Se a Rocky acender um LED vermelho e não executar o código ao ligar a placa, verifique a conexão do suporte de baterias, pois é sinal que ele foi conectado com a polaridade invertida.