Controle de um robô Roomba com Arduino e dispositivo Android

Aplicativos e serviços online

Sobre este projeto

Etapa 1:lista de materiais

• iRobot Create2

• Arduino UNO

• Módulo Bluetooth HC-06

• Botão de pressão

Etapa 2:Roomba Create2

• Limpo

• Spot

• Dock

• Aviso / Cheque

• Sujeira / detritos

• Detector de penhasco (4 na frente)

• detectores de aumento (2 na frente)

• Codificadores de roda

• Ao enviar o comando Iniciar ou qualquer um dos comandos do modo de limpeza (por exemplo, Spot, Clean, Seek Dock), o OI entra no modo Passivo. Quando o OI está no modo Passivo, você pode solicitar e receber dados do sensor usando qualquer um dos comandos do sensor, mas não pode alterar os parâmetros de comando atuais para os atuadores (motores, alto-falante, luzes, drivers de baixo, saídas digitais) para outra coisa .

• Carregador conectado e ligado.

• Detecção de queda de roda (em qualquer roda).

• Detecção de um penhasco enquanto se move para frente (ou para trás com um pequeno raio de giro, menos de um raio de robô).

• Se uma das condições relacionadas à segurança acima ocorrer enquanto o OI está no modo de segurança, o Roomba para todos os motores e retorna ao modo passivo.

• Dá a você controle total sobre o Roomba, todos os seus atuadores e todas as condições relacionadas à segurança que são restritas quando o OI está no modo de segurança, já que o modo completo desliga o penhasco, queda da roda e recursos de segurança do carregador interno .

Etapa 3:a conexão serial

• Ao desligar o Roomba, continue pressionando o botão Clean / Power depois que a luz se apaga. Após cerca de 10 segundos, o Roomba toca uma melodia de tons decrescentes. O Roomba se comunicará a 19.200 baud até que o processador perca a energia da bateria ou a taxa de baud seja explicitamente alterada por meio da OI.

• Use o pino de alteração da taxa de transmissão (pino 5 no conector Mini-DIN) para alterar a taxa de transmissão do Roomba. Depois de ligar o Roomba, aguarde 2 segundos e, em seguida, pressione a alteração da taxa de baud três vezes. Cada pulso deve durar entre 50 e 500 milissegundos. O Roomba se comunicará a 19200 baud até que o processador perca a energia da bateria ou a taxa de baud seja explicitamente alterada por meio do OI.

Etapa 4:iniciar o Roomba

• "Acorde" o robô

• Defina o modo (seguro ou completo)

  void wakeUp (void) {setWarningLED (ON); digitalWrite (ddPin, HIGH); atraso (100); digitalWrite (ddPin, LOW); atraso (500); digitalWrite (ddPin, HIGH); atraso (2000);}  

  void startSafe () {Roomba.write (128); // Iniciar Roomba.write (131); // Atraso do modo de segurança (1000);}  

Etapa 5:Ligando os LEDs e a tela

• Power / Clean (bicolor vermelho / verde e intensidade controlada)

• Spot (Verde, intensidade fixa)

• Dock (verde, intensidade fixa)

• Aviso / Verificar (laranja, intensidade fixa)

• Sujeira / detritos (azul, intensidade fixa)

• Verde =0

• laranja =128

• vermelho =255

• Baixo =0

• Máx =255

  void setDigitLEDs (byte dígito1, byte dígito2, byte dígito3, byte dígito4) {Roomba.write (163); Roomba.write (digit1); Roomba.write (dígito2); Roomba.write (digit3); Roomba.write (digit4);}  

  setPowerLED (128, 128);  

  setDebrisLED (ON); setDockLED (ON); setSpotLED (ON); setWarningLED (ON);  

  void setDebrisLED (bool ativar) {debrisLED =ativar; Roomba.write (139); Roomba.write ((debrisLED? 1:0) + (spotLED? 2:0) + (dockLED? 4:0) + (warningLED? 8:0)); Roomba.write (cor (byte)); Roomba.write ((byte) intensidade);}  

  debrisLED =ativar;  

• Código [163]:LEDs de dígitos brutos (numéricos)

• Código [164]:Dígitos LEDs ASCII (Aproximação de letras e códigos especiais)

  void setDigitLEDs (byte dígito1, byte dígito2, byte dígito3, byte dígito4) {Roomba.write (163); Roomba.write (digit1); Roomba.write (dígito2); Roomba.write (digit3); Roomba.write (digit4);}  

  setDigitLEDs (1, 2, 3, 4);  

  void setDigitLEDFromASCII (byte dig, char letter) {switch (dig) {case 1:digit1 =letter; pausa; caso 2:dígito 2 =letra; pausa; caso 3:dígito3 =letra; pausa; caso 4:dígito4 =letra; pausa; } Roomba.write (164); Roomba.write (digit1); Roomba.write (dígito2); Roomba.write (digit3); Roomba.write (digit4);}  

  void writeLEDs (char a, char b, char c, char d) {setDigitLEDFromASCII (1, a); setDigitLEDFromASCII (2, b); setDigitLEDFromASCII (3, c); setDigitLEDFromASCII (4, d);}  

  writeLEDs ('s', 't', 'o', 'p');  

Etapa 6:mover o Roomba

• Código [137]:Drive ==> Deve enviar +/- Velocidade em mm / se +/- Raio em mm

• Código [145]:Drive Direct ==> Deve enviar Velocidade Esquerda / Direita em mm / s (+ para Avançar e - para Retroceder)

• Código [146]:Drive PWM ==> Deve enviar +/- dados PWM para as rodas esquerda e direita

  drive vazio (velocidade interna, raio interno) {grampo (velocidade, -500, 500); // def velocidade máxima e mínima em mm / s clamp (raio, -2000, 2000); // def raio máximo e mínimo em mm Roomba.write (137); Roomba.write (velocidade>> 8); Roomba.write (velocidade); Roomba.write (raio>> 8); Roomba.write (radius);} // ---------------------------------------- ----------------------- vazio driveWheels (int right, int left) {clamp (right, -500, 500); braçadeira (esquerda, -500, 500); Roomba.write (145); Roomba.write (direita>> 8); Roomba.write (à direita); Roomba.write (esquerdo>> 8); Roomba.write (à esquerda); } // ----------------------------------------------- ---------------- vazio driveWheelsPWM (int rightPWM, int leftPWM) {clamp (rightPWM, -255, 255); braçadeira (leftPWM, -255, 255); Roomba.write (146); Roomba.write (rightPWM>> 8); Roomba.write (rightPWM); Roomba.write (leftPWM>> 8); Roomba.write (leftPWM);}  

  #define clamp (value, min, max) (value  max? max:value)  

  / ------------------------------------------- -------------------- vazio turnCW (velocidade curta sem sinal, graus curtos sem sinal) {drive (velocidade, -1); braçadeira (velocidade, 0, 500); atraso (6600); drive (0,0);} // ---------------------------------------- ----------------------- vazio turnCCW (velocidade curta sem sinal, graus curtos sem sinal) {drive (velocidade, 1); braçadeira (velocidade, 0, 500); atraso (6600); drive (0,0);} // ---------------------------------------- ----------------------- void driveStop (void) {drive (0,0);} // ----------- -------------------------------------------------- --void driveLeft (int left) {driveWheels (left, 0);} // ------------------------------- -------------------------------- void driveRight (int right) {driveWheels (0, right);}  

  turnCW (40, 180); // gira 180 graus no sentido horário e stopdriveWheels (20, -20); // girar driveLeft (20); // virando à esquerda  

  #include "roombaDefines.h" #include  // Roomba Create2 connectionint rxPin =10; int txPin =11; SoftwareSerial Roomba (rxPin, txPin); // ------ --------------------------------------- void setup () {Roomba.begin (19200); pinMode (ddPin, OUTPUT); pinMode (buttonPin, INPUT_PULLUP); // conectado ao pino 12 do Arduino e usado para "iniciar" o atraso (2000); acordar (); // Wake-up Roomba startSafe (); // Iniciar o Roomba no modo de segurança while (digitalRead (buttonPin)) {} // esperar que o botão seja pressionado para executar código de execução contínua turnCW (40, 180); // teste o Roomba gire 180 graus no sentido horário e pare} // ----------------------------------- ---------- void loop () {}  

Etapa 7:controle do Roomba via Bluetooth

• w:para frente

• s:para trás

• d:Certo

• a:Esquerda

• f:Pare

• p:ON / OFF (não usado nesta primeira parte)

• m:Manual / Automático (usado para reiniciar o Roomba se um obstáculo como um penhasco for encontrado no Modo de segurança)

• +:Velocidade +

• -:Velocidade -

  void loop () {checkBTcmd (); // verifique se um comando é recebido do controle remoto BT manualCmd ();}  

  void checkBTcmd () // verifica se um comando é recebido do controle remoto BT {if (BT1.available ()) {command =BT1.read (); BT1.flush (); }}  

  void manualCmd () {switch (command) {case 'm':startSafe (); Serial.print ("Roomba em modo de segurança"); BT1.print ("Roomba BT Ctrl OK - Modo de segurança"); BT1.println ('\ n'); comando ='f'; playSound (3); pausa; case 'f':driveStop (); // desligar ambos os motores writeLEDs ('s', 't', 'o', 'p'); estado =comando; pausa; caso 'w':drive (motorSpeed, 0); writeLEDs ('', 'g', 'o', ''); estado =comando; pausa; caso 'd':driveRight (motorSpeed); writeLEDs ('r', 'i', 'g', 'h'); pausa; caso 'a':driveLeft (motorSpeed); writeLEDs ('l', 'e', ​​'f', 't'); pausa; case 's':drive (-motorSpeed, 0); writeLEDs ('b', 'a', 'c', 'k'); estado =comando; pausa; caso '+':if (estado =='w') {motorSpeed ​​=motorSpeed ​​+ 10; if (motorSpeed> MAX_SPEED) {motorSpeed ​​=MAX_SPEED; } comando ='w'; } else {command =state;} break; case '-':if (state =='w') {motorSpeed ​​=motorSpeed ​​- 10; } if (motorSpeed ​​ 

Etapa 8:Conclusão

O código Arduino completo usado aqui e documentos relacionados podem ser encontrados em meu GITHUB:Roomba_BT_Ctrl.

Observe que nem todos os atuadores Roomba foram comentados neste tutorial. Existem outros motores, usados ​​para limpeza, outros LEDs usados ​​para programação, botões, sensores, etc.

Várias das funções que criei em meu programa foram baseadas na biblioteca Create 2 desenvolvida por Dom Amato. Você pode baixar a biblioteca completa em: https://github.com/brinnLabs/Create2 .

Minha intenção aqui era manter a simplicidade e dar a você uma plataforma inicial para começar a jogar com o Roomba. No futuro, pretendo publicar outros tutoriais, usando um Raspberry-Pi, conectar o Roomba à internet, ler seus sensores, etc.

Como sempre, espero que este projeto possa ajudar outras pessoas a encontrar seu caminho no emocionante mundo da eletrônica e da robótica!

Para mais projetos, visite meu blog (em português):

MJRoBot.org

Saludos do sul do mundo!

Vejo vocês no meu próximo tutorial!

Obrigada

Marcelo