Controle de Motores com a Rocky

This tutorial is not available in English

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 gravar códigos na Rocky e 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.

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,88 no PIX

Bateria Li-Ion 18650 3,7V 2500mAh 2C

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

Biblioteca

Para controlar a Rocky de maneira simples, desenvolvemos uma biblioteca que pode ser instalada diretamente pelo "Gerenciador de Bibliotecas" da Arduino IDE. Para instalá-la, basta digitar "Rocky" na barra de pesquisa do gerenciador, e então pressionar o botão "Instalar" da opção "RoboCore - Rocky". Após alguns instantes a biblioteca estará instalada e pronta para ser usada com a placa, como mostrado na imagem abaixo.

Se preferir, você pode baixar o arquivo compactado em nosso repositório no GitHub e instalar a biblioteca manualmente.

Gravação do Primeiro Código

Antes de vermos o controle dos motores da placa, vamos ver como carregar um código na Rocky, e nada melhor do que começar com o famoso Blink, que inclusive é um dos exemplos da biblioteca da Rocky.

Conexão USB-UART

Antes de conectar o conversor USB-UART no seu computador e na Rocky, altere o jumper seletor de tensão de 5V (padrão) para 3,3V, e então conecte-o à Rocky. Neste momento, atente-se à polaridade do módulo e da placa. O pino de GND do conversor deve estar conectado no pino de GND da placa (o pino mais próximo do botão BOOT), como mostrado na imagem abaixo.

conexao-conversor-usb-uart — Conexão Conversor USB-UART

Após a conexão do conversor à placa, conecte o conversor ao seu computador utilizando o cabo USB Micro.

Atenção: para que o conversor USB-UART seja reconhecido no seu computador, pode ser necessária a instalação do driver USB seguindo os passos deste tutorial.

Configuração da IDE

Com o conversor USB-UART conectado à Rocky e ao seu computador, configure a Arduino IDE para que ela programe a porta COM correspondente ao conversor no seu computador, e o modelo de placa "ESP32 Dev Module", como na imagem abaixo.

ide-configurada-gravacao-codigo — IDE Configurada para Gravação de Código

Código

Como mencionado anteriormente, a própria biblioteca da Rocky já possui um exemplo "Blink" preparado para acionar o LED interno da placa a cada um segundo. Para acessá-lo, basta abrir o exemplo disponível da biblioteca, como na imagem abaixo.

caminho-exemplo-blink — Caminho para o Exemplo Blink

Se preferir você pode copiar o código abaixo:

/*******************************************************************************
* RoboCore - Blink (v1.0)
* 
* Blink the LED of the Rocky Board.
* 
* Based on the example "Blink" by the Arduino team.
* 
* 
* This file is part of the Rocky library by RoboCore ("RoboCore-Rocky-lib").
* 
* "RoboCore-Rocky-lib" is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* "RoboCore-Rocky-lib" is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
* 
* You should have received a copy of the GNU Lesser General Public License
* along with "RoboCore-Rocky-lib". If not, see <https://www.gnu.org/licenses/>
*******************************************************************************/

// --------------------------------------------------
// Variables

const int PIN_LED = 15;
const int PAUSE_TIME = 1000; // [ms]

// --------------------------------------------------

void setup() {
  // set the pin as an output
  pinMode(PIN_LED, OUTPUT);
}

// --------------------------------------------------

void loop() {
  digitalWrite(PIN_LED, HIGH);
  delay(PAUSE_TIME);
  digitalWrite(PIN_LED, LOW);
  delay(PAUSE_TIME);
}

// --------------------------------------------------

O Que Deve Acontecer

Com o código aberto e a sua IDE configurada, pressione o botão para carregar o código para a placa. Você verá que os LEDs RX e TX do conversor irão piscar durante a gravação e, assim que ela estiver concluída, o LED L da placa piscará de 1 em 1 segundo, como no GIF abaixo.

Resultado Final

Você deve ter notado e se perguntado sobre o segundo exemplo "Blink_Rocky" da biblioteca da placa. Ele é uma alternativa que executa a mesma função do exemplo visto acima, porém utilizando um objeto para facilitar o piscar do LED da placa em códigos mais complexos e que não podem ter interrupções de execução de código (causadas pela função delay()). Abra-o para ver como ele é estruturado, se tiver curiosidade.

Acionando 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 os primeiros passos de uso da Rocky, e como 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 Vespa 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.