Montando seu Robô Otto com Arduino Nano

Introdução

Nesse post, vamos continuar nossa viagem pelo mundo da robótica: montaremos um robô Otto. Esse robô é bastante utilizado em escolas para ensinar programação e outras matérias e, por isso, é tido como uma ótima ferramenta para STEM (Science, Technology, Engineering and Mathematics ou Ciências, Tecnologia, Engenharia e Matemática), sendo divertido e fácil de montar. O robô pode ser programado usando o Otto Blockly, um IDE com blocos similar ao Scratch, mas, neste tutorial, vamos programar utilizando o IDE do Arduino.

O que é o robô Otto?

O Otto é um robô interativo que qualquer pessoa pode construir!

O que robô Otto pode fazer?

Otto pode caminhar, dançar, emitir sons e evitar obstáculos.

Por que Otto é especial?

O Otto é totalmente Open-source e compatível com Arduino. Podemos imprimir suas partes em 3D e a missão do projeto é o impacto social para criar um ambiente inclusivo para todas as crianças. Foi inspirado no BoB o BiPed e programado usando código de outro robô bípede de código aberto, chamado Zowi.

As diferenças do Otto estão no tamanho (11cm x 7cm x 12cm), integração mais limpa de componentes e expressões, peças prontas e impressas em 3D, conexões eletrônicas simples (quase sem necessidade de soldagem) e habilidades básicas de codificação. Por ser um projeto Open-source, você pode editar e adicionar funções. Para mais informações, acesse o link do projeto Otto diy.

Materiais Necessários para Construir o Robô

Todos os materiais, com exceção do corpo do robô, podem ser comprados em nossa loja.

• 1x Nano V3.0 + Cabo Usb para Arduino
• 1x Shield de Expansão para Arduino Nano 3.0
• 1x Módulo Sensor de Distância Ultrassônico HC-SR04
• 4x Micro Servo 9g SG90 TowerPro (com os parafusos e acessórios)
• 1x Buzzer Ativo 3v
• 1x Push Button PS-22E85L – com Trava ou Chave SS12F46 – 3 terminais
• 1x Bateria de 3.7 V ou Bateria 9V Alcalina Philips
• 1x Módulo Regulador de Tensão Step Down Buck DC-DC Mini 360 3A
• Jumpers – Femea/Femea – 40 Unidades de 20cm
• Peças em 3D (Cabeça, Corpo, 2x Pernas, 2x Pés)

Montagem

Antes de começar a montagem, é necessário imprimir ou adquirir o corpo do robô. Para imprimir, basta acessar esse link do thingiverse. Nele, você pode fazer o download das parte do robô e imprimir com as configurações e cores que preferir. As configurações que utilizei foram:

1 – Montando o motor das pernas no corpo do robô

Para montar os motores ,utilize o parafuso com a cabeça maior. Cuidado ao apertar: não o force.2 – Montando as peças do motor e encaixando as pernas

Para encaixar o motor na perna, é necessário cortar a peça que tem 4 pontas (Mostrada na imagem).

Atente à posição do motor: ele deve está na posição de 90º (centralizado). Caso coloque errado, o robô ficará torto ou não andará.

3 – Montando os pés

Para parafusar as pernas, use os parafusos de cabeça arredondada. Encaixe a peça de uma ponta (mostrada na figura) no pé e, em seguida, parafuse.

4 – Montando o motor dos pés

Encaixe o motor, tomando o cuidado para mantê-lo na posição de 90º, e cheque se ele está na posição correta, como na imagem abaixo.

5 – Encaixando os pés nas pernas

Parafuse o motor aos pés e, em seguida, encaixe-os nas pernas. Preste atenção ao lado dos pés, passe os fios pelos buracos das penas e do corpo e, por fim, parafuse.

6 – Encaixando as parte na cabeça

Encaixe, primeiro, o buzzer e, depois, o sensor. Por fim, parafuse o shield com o Arduino na cabeça do robô.

7 – Ligação da bateria

Para energizar seu robozinho, vamos precisar “calibrar” a tensão que chega até o regulador. A bateria fornece 9V, e essa tensão não é compatível com o circuito, sendo necessário reduzi-la para 5V. Para essa etapa, siga os passos abaixo:

1- Carregue em seu Arduino o código a seguir:

void setup() {
  Serial.begin(115200); 
}

void loop() {
  static uint8_t i; static const uint8_t tamFiltro = 255;
  static unsigned leituraFiltrada, medicoes[tamFiltro];
  static unsigned long tempo, soma;

  for(i = 0, soma = 0; i < tamFiltro - 1; medicoes[i] = medicoes[i + 1], i ++)
    soma += medicoes[i];
  leituraFiltrada = (soma + (medicoes[tamFiltro - 1] = analogRead(A7))) / tamFiltro;

  if(millis() - tempo > 100) {
    tempo = millis();
    Serial.print(leituraFiltrada * 5.0 / 1024); Serial.flush(); Serial.println(" V");
  }
}

2- Com o código já carregado na placa e a mesma desconectada do computador, monte o circuito abaixo:

3- Com o circuito montado, conecte o Arduino à porta USB do seu computador e abra o monitor serial da Arduino IDE. Caso o valor retornado seja um punhado de caracteres sem sentido, altere a velocidade de comunicação para 115200.

4- Gire cuidadosamente o pequeno parafuso (trimpot) presente no regulador até que a tensão lida esteja entre 2V e 3V. Isso garantirá que você não irá danificar o Arduino na próxima etapa.

5- Assim que obtiver as leituras corretas, faça as ligações abaixo e gire o trimpot do regulador até obter 5V na saída. Tome muito cuidado nessa etapa, pois o Arduino não tolera tensões maiores que 5,2V em seus pinos, por isso, faça o ajuste lentamente e sempre observando o valor exibido no monitor serial.

Com o ajuste feito corretamente, você já pode montar o circuito definitivo:

8 – Ligações dos componentes e encaixe da cabeça no corpo

Temos um post explicando bem o shield para Arduino Nano, neste link.

Conecte todos os servos, buzzer, capacitore e sensor nos respectivos pinos. Verifique as polaridades e cabos de alimentação e sinal.

Como ficou a instalação:

Código e Explicação

Para programar o robô, precisamos da biblioteca OttoDiy. Você pode a baixar neste link ou no Github.
Código que faz o robô detectar obstáculos a 15 cm e desviar.

/**
 * @file Meu_Robo_Otto.ino
 * Modificado por: Saulo Aislan
 * Baseado no código exemplo - Otto avoid obstacles with ultrasonic sensor
 * Otto DIY - https://www.ottodiy.com/
 * @brief Firmware para detectar obstáculos e fazer o robô desviar.
 * @version 0.1
 * 
 * @copyright Copyright (c) 2022
 * 
*/

#include <Otto.h> // Disponível em: https://github.com/OttoDIY/OttoDIYLib
Otto Otto;

#define PernaEsq 2 
#define PernaDir 3
#define PeEsq 4 
#define PeDir 5 
#define Buzzer  13 
#define Trigger 8 // Pino trigger do sensor utrassonico
#define Echo 9 // Pino echo do sensor utrassonico

/**
 * @brief Emite um onda ultrassônico para medir a distância
 * @return long distância
 */
long ultrasound()
{
   long duration, distance;
   digitalWrite(Trigger,LOW);
   delayMicroseconds(2);
   digitalWrite(Trigger, HIGH);
   delayMicroseconds(10);
   digitalWrite(Trigger, LOW);
   duration = pulseIn(Echo, HIGH); // Duração do pulso(ms) do pino Echo.
   distance = duration/58; // Tempo em microssegundos dividido pelo dobro da distância que o som percorre por microssegundo(cm)
   return distance;
}

/**
 * @brief setup
 */
void setup() {
  Otto.init(PernaEsq, PernaDir, PeEsq, PeDir, true, Buzzer); // Inicializa os pinos dos servos e Buzzer
  pinMode(Trigger, OUTPUT); 
  pinMode(Echo, INPUT); 
  Otto.swing(2, 1000, 20); // Balançando de um lado para o outro
  Otto.shakeLeg (1,2000,-1); // Chacoalhar a perna direita
}

/**
 * @brief setup
 */
void loop()
{
    if (ultrasound() <= 15) // Se a distância for menor ou igual a 15cm
    {
      Otto.sing(S_surprise); // Emite um som de surpresa
      Otto.walk(2,1000,-1); // Volta dois passo
      Otto.turn(4,1000,1); // Faz uma curva pela esqueda em 3 passos
    }
    Otto.walk(1,1000,1); // Anda um passo para frente
}

Entendendo algumas funções

Otto.swing(float steps, int T, int h)

Funções que faz o Otto: balançar de um lado para o outro
Parâmetros: steps – Número de passos, T – Período(ms), h – Quantidade de balanços (0 a 50 aproximadamente).

Otto.shakeLeg(int steps,int T,int dir)

Função que faz o Otto: Agitar ou chacoalhar uma perna
Parâmetros: steps – Número de agitação, T – Período de um agito(ms), dir – Qual perna agitada 1 esquerda ou -1 para a direita.

Otto.sing(S_surprise)

Emite um som de surpresa, para mais sons consulte o arquivo principal da biblioteca ou o arquivo Otto_sounds.h

Otto.walk(float steps, int T, int dir)

Função que faz o Otto: Andar (para frente ou para trás)
Parâmetros: steps – Número de passos, T – Período(ms), dir – Direção: 1 para frente e –1 para trás.

Otto.turn(float steps, int T, int dir)

Função que faz o Otto: Virar para a esquerda ou direita
Parâmetros: steps – Número de passos, T – Período(ms), dir – Direção: 1 para a direita e –1 para a esquerda.

Resultado e Demonstração

Conclusão

Nesse tutorial, aprendemos a montar o robô Otto. Esse projeto é totalmente Open-source e você pode modificar o que quiser, adicionar ou remover componentes e deixar sua imaginação fluir. Para mais material como este, continue acompanhando as postagens semanais do blog e não deixe de visitar nossa loja. Lá, você encontra todos os componentes necessários para desenvolver esse e muitos outros projetos!

Que a força estejam com vocês e até mais!

Referências

Referências utilizadas no artigo:

• https://www.instructables.com/BoB-the-BiPed/
• https://github.com/OttoDIY/OttoDIYLib
• https://www.thingiverse.com/thing:1568652
• https://www.ottodiy.com/blog/calibration
• https://bit.ly/3u3hRxP
• https://hackaday.io/project/11776/instructions
• https://www.ottodiy.com
• https://wikifactory.com/+OttoDIY/otto-diy
• https://create.arduino.cc/projecthub/cparrapa/otto-diy-build-your-own-robot-in-one-hour-5f2a1c

Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!

Sobre o Autor

Saulo Aislan Graduando em Tecnologia em Telemática pelo IFPB – Campus de Campina Grande – PB. Tenho experiência com os microcontroladores da família Arduino, ESP8266, ESP32, STM32 e microprocessador Raspberry Pi. Tenho projetos na áreas de IoTs voltada para a indústria 4.0, agroindústria e indústria aeroespacial civil utilizando LoRa, Bluetooth, ZigBee e Wi-Fi. Atualmente estudando e desenvolvendo em FreeRTOS para sistemas em tempo real com ESP32 e LoRaWan para Smart City e compartilhando alguns projetos no blog da Eletrogate.