Robô quadrúpede - Modelo 1

Os robôs bípedes e quadrúpedes são quase tão legais quanto as aranhas robô. O único problema com o robô aranha é que vai servo demais, mas ainda vou montar uma.

Nesse post vou mostrar meu mais novo brinquedo, um robô quadrúpede que, nessa primeira fase, farei apenas seu funcionamento básico e dicas de montagem. Tenho outro robô mais simples, com menos servos, mas não fica tão bonito quanto esse feito em impressão 3D pelo Italo (visite a página no face). Em outro artigo vou mostrar um outro quadrupede de madeira cortado a laser que utiliza apenas 8 servos. Não tem o movimento gracioso desse quadrupede impresso pelo Italo e nem o mesmo design, mas pode ser um ponto de partida se seu orçamento estiver limitado.

Pretendo também fazer a introdução do código migrado para utilização com I²C invés de utilizar todos os GPIOs, mas nesse primeiro artigo vamos utilizar um Arduino Nano com um expansor próprio para nossa finalidade.

Do mesmo modo, é possível fazê-lo com Arduino UNO/Leonardo, mas acabei de adquirir um shield que não I²C e levará alguns dias até a entrega.

Posicionamento do servo motor

Caso você ainda não saiba, o servo comum desses SG90 vai de -45 à 45 graus. Isso significa que 0 fica no ponto de alinhamento do braço do servo com o corpo do servo. Baseie-se nisso para o primeiro passo.

Não será necessário o alinhamento manual, mas para o próximo robô essa pode ser a solução mais simples, então apenas aprecie o procedimento ou então pule para o código logo após.

Para colocá-los na posição central, encaixe o braço e gire-o suavemente até o final no sentido horário. Depois, remova o braço e coloque-o na perpendicular, então gire-o no sentido anti-horário até que se alinhe no ponto 0 do servo.

A montagem é simples também, basta seguir as ilustrações do manual de montagem, caso resolva adquirir um robô desses.

A segunda opção é montar todo o robô mas não encaixar os braços dos servos ainda. Então, suba um sketch simples para posicionar os motores.

// Locate the initial position of legs 
// RegisHsu 2015-09-09

#include <Servo.h>   

Servo servo[4][3];

//define servos' ports
const int servo_pin[4][3] = { {2, 3, 4}, {5, 6, 7}, {8, 9, 10}, {11, 12, 13} };

void setup()
{
  //initialize all servos
  for (int i = 0; i < 4; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      servo[i][j].attach(servo_pin[i][j]);
      delay(100);
    }
  }
  while (1);
}

void loop(void)
{
  
}

O exemplo acima é para o caso de você estar utilizando os pinos de GPIO invés de um shield I²C. Para o shield I²C, faça como abaixo e após os motores pararem de rotacionar, desligue a controladora e posicione os braços ao centro.

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#if defined(ARDUINO_ARCH_SAMD)  
    #define Serial SerialUSB
#endif

int i = 0;
int t = 0;

void setup() {
#ifdef ESP8266
    Wire.pins(2, 14);   
#endif
    Serial.begin(9600);
    Serial.println("Alinhando servos...");
    pwm.begin();
    pwm.setPWMFreq(50);

#ifdef TWBR    
    //uint8_t twbrbackup = TWBR;
    //TWBR = 12; // upgrade to 400KHz!
#endif
uint8_t twbrbackup = TWBR;
    TWBR = 12; // upgrade to 400KHz!
}

void loop() {
  for (i = 0; i< 16;i++){
    pwm.setPWM(i,0,t);
  }
  t = t > 256 ? 256 : t +=8;
  delay(40);
}

Eu vi a montagem desse robô no instructables. A partir do código padrão faremos alguns adendos posteriormente, incluindo um pouco de visão computacional. Nesse artigo vamos apenas "dar vida" a ele.

Guie-se por essa imagem para fazer  a conexão dos servos.

Claro que você precisará de um meio para fazer o controle desses 12 servos. Uma opção é um shield I²C para Arduino, como esse da imagem:

Ou pode simplesmente utilizar os pinos digitais, mas aí não sobra mais nada pra futuras implementações. Vou fornecer o código para utilização com I²C também (em outro artigo, porque não será muito simples portar o código desse robô), baseado no código que está na instructables, mas dessa vez a implementação será nesse cara aqui:

Somente serão utilizados 12 pinos, de 2 à 13, sendo os pinos da direita, acompanhando pela imagem. Os pinos estão devidamente numerados e farei referência a eles na montagem.

Após fazer o alinhamento, parafuse os braços dos servos e as presilhas nessa posição.

Depois disso, vem as "perfumarias". Arranje os cabos à gosto para deixar seu robô com uma boa aparência. Minha dica é que seu desprendimento seja facilitado para os que desejam incluir as implementações futuras. Certamente a visão computacional será adicionada com Raspberry e/ou Onion Omega. No Onion Omega é mais provável porque já tenho a expansão para servos.

Alimentação

A grande porcaria em fazer robô é que sempre se faz necessário alimentação por bateria e eu sou muito preguiçoso. O Arduino vai ficar em uma fonte com cabo e o servos precisam obrigatoriamente de uma alimentação que forneça até 3A em 5V, por isso coloquei um uma fonte step-down DC-DC seguida da fonte AC-DC 12Vout para derrubar pra 5V. Utilizar o Arduino da MBZ também é uma boa opção, mas seria necessário adicionar alguns pontos de solda e quero evitar mais mão de obra nesse momento. A propósito, em alguns dias deve sair um outro artigo com esse Arduino (desse link - e esgota muito rápido, sério. Se não encontrar no link, aguarde a disponibilidade).

Biblioteca

O shield é uma cópia quase idêntica ao da Adafruit. Não importa a marca desde que o projeto seja bom. Mas a biblioteca que utilizaremos, essa sim é da Adafruit mesmo. Baixa do git nesse link. Ou você clona, ou faz download do arquivo zip, não importa. Só é importante que você coloque o diretório da biblioteca dentro do diretório de bibliotecas do Arduino (~/Arduino/libraries ou ~/arduino-x.y.z/libraries) e renomeie o diretório substituindo o sinal "-" por "_". Após isso, abra a IDE do Arduino e em "File->Examples" você encontrará o respectivo diretório.

Shield I²C para servos motor

O shield não vem com o capacitor para qual o local está designado. Porém, não será necessário utilizá-lo a menos que os servos se comportem estranhamente, o que indicará um possível ruído, de modo que pode ser uma boa ideia colocar um capacitor de 470uF ou algo próximo a isso.

à direita você vê os endereçadores do I²C. O endereço padrão é 0x40 e você não precisa se preocupar com isso, exceto deseje utilizar outros dispositivos I²C simultaneamente e aí pode ser necessário endereçar um deles. Esses indicadores "A0" etc se referem a "Address", não a "Analog", portanto não faz referência nenhuma aos pinos analógicos do Arduino.

Os pinos de 0 a 15 enfileirados de 4 em 4 são os conectores dos servos. Normalmente os SG90 vem com o fio laranja, vermelho, marrom. O marrom é GND, devendo ficar para baixo. Aqueles 3 pontos de solda no canto indicando "Power Select", não faço ideia pra que seja. Não fiquei seguindo trilha com multimetro, apenas liguei os servos, verifiquei os GND entre o Arduino e o shield e peguei os 3 pontos pra ver se tinha alimentação. Sim, todos os 3 estão alimentados, então não sei. Não faça nada, preferencialmente.

Teste inicial com shield I²C

Pode ser que eu esteja cometendo algum erro aqui, então se for o caso, me perdoe. Só que o sketch padrão do exemplo pwmtest vem com uma frequência de 1600Hz. Eu fiz vários testes com um Arduino Leonardo e só funcionou direito com 300 e 400 Hz utilizando o PWM de 12bits. Fui mexendo muito , então passei os valores pra 512 e a frequência para 50Hz, que foi o que vi nesse datasheet. Também adicionei um delay de 40ms porque não estava dando tempo do servo voltar à posição inicial. A modificação do código foi tênue, mas fundamental.

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#if defined(ARDUINO_ARCH_SAMD)  
    #define Serial SerialUSB
#endif

int i = 0;
int t = 0;

void setup() {
#ifdef ESP8266
    Wire.pins(2, 14);   
#endif
    Serial.begin(9600);
    Serial.println("Alinhando servos...");
    pwm.begin();
    pwm.setPWMFreq(50);

#ifdef TWBR    
    //uint8_t twbrbackup = TWBR;
    //TWBR = 12; // upgrade to 400KHz!
#endif
}

void loop() {
  for (i = 0; i< 16;i++){
    pwm.setPWM(i,0,t);
  }
  t = t > 512 ? 0 : t +=8;
  delay(40);
}

Estou testando enquanto escrevo, portanto algo pode mudar até o final do artigo, mas gostaria de deixar alguns pontos claros, os quais não me são fontes de dúvidas. O pulso para o servo fica entre 1ms e 2ms, sendo que 1.5ms é o centro; para menos, gira no sentido anti-horário. Para mais, gira no sentido horário.

Achei um ótimo exemplo no google images para figurar o que estou dizendo:

setPWM(channel,on,off)

Achei importante deixar claro esse método. O canal, obviamente se refere ao ao canal cujo servo deve ser controlado. Depois, "on" é um valor entre 0 e 4095 (pela resolução do módulo), que é o momento em que o sinal passa de LOW para HIGH. Por último e também entre 0 e 4095, o momento que o sinal vai de HIGH para LOW.

Montagem do robô com o Arduino Nano

E como nesse momento o importante é apenas fazer o "hello world" com esse robô quadrúpede, tentarei seguir a receita do criador o mais fielmente possível, para nos próximos artigos fazer as minhas implementações e compartilhá-las com você. Mas adianto, essa fase já é motivadora.

Tendo montado o robô, você deverá apenas se preocupar com a alimentação. Não adianta tentar nada menos que os 5V@3A porque vai dar problema. Eu tentei com um power bank, com uma fonte 5V ordinária e nada funcionou. Com certeza não tem graça deixar o robô pendurado em fios de alimentação, mas é o que tenho pra agora.

Suba esse sketch para o Arduino, depois deixe-o apenas com a fonte de alimentação. O resultado será algo como o desse video a seguir:

https://youtu.be/6SHiPDw0Qds

Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.