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, emhttp://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)

Estimativa de custos do robô V. 1.0

Material	Preço (R$)	Observação
Uma placa Arduino Duemilanove ou Arduino Uno	74,00	Preço no Brasil (Brasilrobotics); se quiser fazer uma comprar internacional, no Ebay você encontra mais barato
Dois servomotores (hobby servo) 9 g	26,00	2 unidades no Brasil (Brasilrobotics); pode encontrar também em lojas de modelismo
Uma chapa de polietileno de alta densidade (PEAD ou HDPE, do nome em inglês)	4,00	Com uma tábua de cortar carne com aprox. 19x30 cm, é possível construir dois chassis
Duas rodas	0,00	Aproveitamento de sucata (impressora); caso não consiga, pode fazer de madeira, MDF ou com o polietileno
Pequeno pedaço de chapa de alumínio	0,00	Também pode ser obtido de sucata
Fios para conexões (AWG 26 a 30)	5,00	A melhor opção é comprar já com as pontas feitas (Brasilrobotics)
Dois elásticos de dinheiro	0,00	Para fixar as pilhas
Cabo e conector de alimentação para bateria 9 V	1,00	Peça quando comprar o Arduino
Uma bateria 9 V (quadrada)	7,00	Você também tem a opção de comprar uma recarregável
Um porta 4 pilhas tamanho AA	1,00	Facilmente encontrado em lojas de produtos eletrônicos
4 pilhas tamanho AA	5,00	Recarregáveis são uma ótima alternativa
Uma barra de conectores Sindal (12 bornes, 4 mm)	3,00	Em lojas de produtos eletrônicos ou elétricos
Duas chaves (microswitch com haste)	3,00	Opcionais, mas importantes para indicar quando o robô bate em um objeto
Dois LDRs	1,50	Opcionais; para fazer o robô seguir ou se afastar da luz
Dois espaçadores com rosca	0,00	De placa-mãe de computadores
Um palito	0,00
Uma chave liga-desliga	1,00
TOTAL	131,50