Versão 1.0

O que é?

Um robô de fácil construção e montagem, que você pode fazer com materiais de baixo custo.

Como surgiu?

Do interesse de professores do IF-SC, Campus Florianópolis, em desenvolver uma plataforma robótica facilmente replicável, como meio de incentivo às ciências exatas e tecnológicas.

O desenvolvimento deste robô foi apoiado pelo Primeiro Edital de Apoio a Projetos de Extensão no IF-SC (I APROEX). A equipe executora é formada pelos professores Joel Lacerda (Coordenador), Fernando S. Pacheco e Charles B. de Lima, do Departamento Acadêmico de Eletrônica (DAELN) do Campus Florianópolis e pelo aluno Luciano Silva do Lago, do Curso Técnico em Eletrônica.

Características

Nessa versão 1.0, a plataforma microcontrolada escolhida, por sua facilidade de aquisição, programação e baixo custo é o Arduino (usa microcontrolador ATmega328, família AVR). O chassis é de material plástico (polietileno) e as conexões elétricas são feitas em uma barra Sindal. Também para manter o baixo custo, usamos pilhas de fácil aquisição (tamanhos AA e 9 V).

Materiais

clique para ampliar

• [A] Uma placa Arduino Duemilanove ou Arduino Uno
• [B] Dois servomotores (hobby servo) 9 g
• [C] Uma chapa de polietileno de alta densidade (PEAD ou HDPE, do nome em inglês). Aqui, usamos uma tábua de cortar carne :-)
• [D] Duas rodas. Aqui, são os rolos que puxam papel de uma impressora usada (rodas com diâmetro de 5 cm)
• [E] Pequeno pedaço de chapa de alumínio
• [F] Fios para conexões (AWG 26 a 30)
• [G] Dois elásticos de dinheiro
• [H]  Cabo e conector de alimentação para bateria 9 V
• [I] 1 bateria 9 V (quadrada)
• [J]  Um porta 4 pilhas tamanho AA
• [K] 4 pilhas AA
• [L] Uma barra de conectores Sindal (12 bornes, 4 mm)
• [M] Duas chaves (microswitch com haste)
• [N] Dois LDRs
Não mostrados na figura
• Dois espaçadores com rosca (de placa-mãe de computadores)
• Um palito
• Uma chave liga-desliga

Ferramentas

clique para ampliar

• [A] Arco de serra comum ou mini
• [B] Formão
• [C] Furadeira
• [D] Martelo
• [E] Lápis
• [F] Chave de fenda
• [G] Brocas 1 mm (não mostrada na figura), 2,5 mm e broca de madeira 5/8" (aprox. 15 mm)
• [H] Tesoura
• [I] Lixa
• [J] Régua
• Modelo para corte e furação (faça o download)

1. Faça o chassis

a. Imprima o modelo que está disponível acima (observe se escala está em 100%; confira com a marcação de 13,6 cm que existe no modelo). Recorte e marque sobre a placa de polietileno.

b. Usando o arco de serra, recorte a placa (na foto, estou fazendo um teste). Você deve levar aproximadamente 30 min nessa tarefa.

 

c. Faça os furos previstos com a broca menor.

d. Faça o recorte para as rodas com a broca maior (em uma furadeira de bancada, como mostrado na figura, fica mais fácil).

e. Com o formão, faça o acabamento dos recortes. Cuidado! Nunca direcione a lâmina para o seu corpo!

f. Lixe as bordas para um melhor acabamento.

2. Modifique os servomotores

a. Originalmente, um servo desse tipo tem o movimento limitado em 180 graus. Para transformá-lo em um servo de rotação contínua, siga as instruções (excelentes, com várias fotos) do blog de Tod E. Kurt, em http://todbot.com/blog/2009/04/11/tiny-servos-as-continuous-rotation-gearmotors/

Se tiver qualquer dúvida ou dificuldade, entre em contato com a gente.
b. Faça as ligações mostradas na figura seguinte para testar o funcionamento dos servos no próximo passo.

c. Carregue o programa seguinte na IDE do Arduino para testar os servos e ajustar a largura de pulso para que eles fiquem parados quando desejado.

/*****************************************************************************
 * ajuste_rotacao_direcao_servos
 *
 * Ajuste dos valores de pulso máximo (max.pulse) e mínimo (min.pulse) para
 * que o servo mantenha-se parado quando for enviado o comando de 90 graus
 *
 * Fernando S. Pacheco - 2011
 *****************************************************************************/

#include "SoftwareServo.h"

SoftwareServo servo;

void setup()
{
  servo.attach(2); //Num. do pino (Arduino) em que o servo está conectado.
  // Teste um servo, anote o valor do max. pulse, e depois teste o outro.

  //servoL.setMaximumPulse(XXX);// esse é o valor que será testado no loop.
  //   Depois de obtê-lo, coloque aqui em cima e tire o comentário.
  //servoL.setMinimumPulse(XXX);// para um dos servos que testamos, 
  //   não resolveu mexer só no max. pulse.
  //   Ficou muito baixo e, assim, a velocidade máxima era pequena.
  //   Foi necessário, então, ajustar também o min. pulse

  Serial.begin(9600);
  Serial.println("ServoAdjust/Ajuste do servo");
}

void loop()
{
  for (int maxpulse=500; maxpulse!=3000; maxpulse+=10)  { 
    servoL.setMaximumPulse(maxpulse);
    servoL.write(90);
    Serial.println(maxpulse);
    SoftwareServo::refresh();
    delay(45);
    SoftwareServo::refresh();
    delay(45);
  }
  //Depois de ter um valor aproximado, diminua o incremento do laço e 
  //os valores inicial e final
  delay(500);
}

3. Conecte as rodas aos motores

a. Coloque o suporte do servo em cima da roda e marque o material que será retirado

b. Com a furadeira e/ou formão, retire parte do plástico até que o suporte fique encaixado e centralizado

c. Fure as rodas e fixe o suporte (aqui, para teste, não usei parafusos)

4. Fixe a placa Arduino e as chaves

a. Rosqueie os espaçadores no chassis

b. Coloque a placa do Arduino

c. Cole ou parafuse as chaves na frente do robô. Use a chapa de alumínio para fazer uma haste maior para as chaves

5. Faça as conexões elétricas

a. Siga o esquemático e faça as conexões elétricas na barra Sindal

6. Fixe as pilhas

a. Use os elásticos e o palito para fixar as pilhas
b. Coloque um pequeno pedaço de polietileno embaixo da bateria 9 V

7. Programe o microcontrolador

a. Use o programa exemplo abaixo.

/*****************************************************************************
 * robot_segue_luz_e_volta_quando_bate
 *
 * Robô vai para a direção com mais luminosidade, a partir da leitura de 
 *  dois LDRs (fotorresistores)
 * Também tem duas chaves na frente para detectar quando bate
 *
 * Código usa os resistores internos de pullup do ATmega
 *
 * Fernando S. Pacheco - 2011
 *****************************************************************************/
#include "SoftwareServo.h"
#define invON LOW
#define invOFF HIGH
#define leftColisionPin  11
#define rightColisionPin 10
#define leftLdrPin A0
#define rightLdrPin A1

SoftwareServo servoL;
SoftwareServo servoR;

int leftCol=invOFF;
int rightCol=invOFF;
int leftLight=0;
int rightLight=0;

void setup()
{
  Serial.begin(9600);
  servoL.attach(2);
  servoR.attach(3);
  servoL.setMinimumPulse(295); //coloque os valores que você obteve no 
  //  teste dos servos. (Insert here the values obtained during servo testing)
  servoL.setMaximumPulse(993);
  servoR.setMaximumPulse(1247);
  pinMode(leftColisionPin, INPUT);
  digitalWrite(leftColisionPin, HIGH); //habilitar os resistores internos de
  //  pullup. (To enable internal pullup resistor)
  pinMode(rightColisionPin, INPUT);
  digitalWrite(rightColisionPin, HIGH); //to enable internal pullup resistor
  pinMode(rightLdrPin, INPUT);
  digitalWrite(rightLdrPin, HIGH); //to enable internal pullup resistor
  pinMode(leftLdrPin, INPUT);
  digitalWrite(leftLdrPin, HIGH); //to enable internal pullup resistor
  //Wait 2 seconds to begin
  delay(2000);
  //Aumenta velocidade vagarosamente / Increment speed slowly
  for (int k=0; k!=90; ++k) {    
    servoL.write(90+k);   //forward/frente em 180 
    servoR.write(90-k); //forward/frente em 0
    SoftwareServo::refresh();
    delay(25);
  }
  }

void loop()
{
  //Segue para frente em velocidade máxima / Go forward at full speed
  servoL.write(180);
  servoR.write(0);
  SoftwareServo::refresh();

  //Lê LDRs / Read LDRs
  leftLight=analogRead(leftLdrPin);
  rightLight=analogRead(rightLdrPin);
  
  if (leftLight > rightLight)  {
    servoL.write(150); 
    servoR.write(70);
  }
  else  {
    servoL.write(110);
    servoR.write(30);
  }
  SoftwareServo::refresh();
  delay(45);  

  //Lê chaves de colisão / Read collision detection switches
  leftCol=digitalRead(leftColisionPin);
  rightCol=digitalRead(rightColisionPin);
  
  //Detecção de colisão / Collision detected
  if (leftCol == invON || rightCol == invON) {
    //Robô para trás / Reverse
    servoL.write(30);   //frente em 180 
    servoR.write(150); //frente em 0

    for (int k=0; k!=10; ++k) {    
      SoftwareServo::refresh();
      delay(45);
    }
    if (leftCol == invON)  {
      //Se bateu à esquerda, vira para a direita / Turn right to avoid collision
      for (int k=0; k!=17; ++k) {
        servoL.write(140);
        servoR.write(140);
        SoftwareServo::refresh();
        delay(45);
      }
    }
    else {
      if (rightCol == invON)  {
        //Se bateu à direta, vira para a esquerda / Turn left to avoid collision
        for (int k=0; k!=17; ++k) {
          servoL.write(40);
          servoR.write(40);
          SoftwareServo::refresh();
          delay(45);
        }
      }
    }
  }  
  SoftwareServo::refresh();
  delay(1);
}

Você pode fazer o download dos programas do robô aqui.
 
8. Teste

a. Divirta-se! Modifique! Comente o resultado!

9. Ideias para outras versões

a. Com sensores infravermelho, fazer um seguidor de linha

b. Incluir sensores para que o robô identifique limites de espaço (por exemplo, não cair de uma mesa)

c. Fazer acionamento remoto
d. Usar um pack de baterias LiPo (6 células; 7,2 V, por exemplo)