Em diversos lugares, por todo mundo, estão se organizando em eventos, os chamados Hackdays, geralmente acontecem durante um dia todo, de manhã até de tarde/noite…. e por isso – Hackday

Pensando em como disseminar a idéia do Arduino aqui na região, resolvi “agitar” o pessoal de Sta. Barbara D’Oeste (meus alunos) a fazer uma noide no estilo do Hackday. Ainda que o tempo seja curto, a idéia é plantar a semente.

Para o primeiro Hackday, atividades simples na parte eletrônica, mostrando basicamente como o Arduino funciona, alguns acionamentos (leds/servos), coisas simples mais que todos os participantes poderão fazer.

Infelizmente há uma falta de placas pra todos, porém irei disponibilizar duas delas, de forma que 2 grupos possam atuar simultanemante.

Pro evento ficar mais legal, se o tempo permitir, conversaremos sobre programação, e tentaremos montar uma lógica para aplicar no projeto do “Carrinho de Controle Remoto” (que agora tem um super controle e virou um tanque [em breve posto aqui]).

A data do evento ficou para dia 07/out/2k11 na FAC de Sta Barbara D’Oeste, evento somente para alunos.

Conteúdo

• O arduino
• Possibilidades
• Vídeos
• Mão na massa

Se tudo ocorrer bem, posto aqui o relatório do evento!

Conferi a alguns dias que o pessoal do core team do arduino soltou a vesão beta da IDE, como as coisas que eu faço são testes, resolvi ver as novidades, de cara, uma interface mais clean, vejam:

Além da mudança do visual, agora os arquivos passam a ter a extenção .INO, o que ao meu ver, é uma mudança legal, pra mim, .INO faz muito mais sentido do que .PDE …

O pessoal do Laboratório de garagem foi mais afundo e comentou que as mudanças aconteceram principalmente nas bibliotecas de rede e em algumas outras, porém na maioria das vezes o programa ficará com o mesmo tamanho.

Porém faço aqui um adendo, nos meus projetos, como tenho aquelas bibliotecas de terceiro, como a pro sensor ultrasonico HC-SR04 que utilizo no meu carrinho, ao compilar a primeira vez ele me deu falha, não estava encontrando a WProgram.h, observando como as bibliotecas Ethernet, Servo e algumas outras do próprio projeto do Arduino, constatei que a Wprogram não está mais sendo usada, porém (até aonde testei…) ela foi substituida por 2 outras:

#include <Arduino.h>
#include <inttypes.h>

Bastou então para o programa passar a compilar, comentar a WProgram.h e incluir essas dudas.

Como não achei nenhuma informação na internet (forum do arduino) resolvi escrever aqui pra ajudar os que também tiverem esse problema.

A primeira idéia foi criar logo o carrinho, sem muita idéia de como ele iria detectar objetos, ou fazer algum tipo de interação, nesse momento idéias fervilhavam na cabeça, em mãos tinha um controle remoto (que veio no meu starter kit)  e alguns botões vindos dos CDRoms desmontados.
O escolhido nesse momento foi, “controle remoto”, mais simples e aparentemente menos problemático, montei o  circuito e mãos a massa.

Codifiquei todas as ações que desejava para o carrinho (código), tudo parecia simples, porém… como não poderia ser diferente… alguns acertos foram necessários na configuração dos motores, acertos feitos, robo feliz e contente, andando porém longe do objetivo.. que era fazer algo autônomo (robô).

Mais alguns finais de semana, resolvo então implementar o para choque com os botões de fim de curso, com um pouco de dificuldade na parte mecânica da coisa, porém ainda assim, no final de tudo, funcional. Imagine que o carrinho tinha na frente um botão de fim de curso, quando esse botão era acionado (batida) então o carrinho voltava, mas era extremamente difícil do carrinho bater de forma a pressionar o botão (mais uma vez, falha no projeto com relação as partes mecanicas ).

Nesse meio tempo, no fervilhão de idéias, existia também o leitor de RFID, que por essa limitação do botão não ser pressionado com “qualquer” batida, resolvi implementar uma chave de liga/desliga, aonde ao bater, o carrinho daria marcha-ré e viraria, depois ficaria esperando um “Ligar” proveniente do RFID (código). Como na primeira parte do vídeo(logo abaixo)

Já em data mais próxima aos dias atuais (cerca de 4 semanas) chegou o sensor ultrasônico HC-SR04, ai a coisa começou a ficar mais “profissa”. Sensorzinho porreta, e mais barato do que o Ping))) da Parallax (deve existir algum motívo para isso), capaz de medir até 4 metros de distãncia. (Diz o manual que é 4 e meio ). Essa caracteristica me permitiria não precisar mais do para-choque, pois antes mesmo de bater, já saberia da existência de um objeto na frente do carrinho. Porém nem tudo são flores… mas deixamos as flores pra depois.

Nesse interim chegou também o resto dos meus servo motores, dessa forma os projetos “poderiam” ganhar várias possibilidades, porém tudo que o carrinho ganhou foi a possibilidade de olhar pra “todos os lados”, melhor dizendo, com o servo motor e o sensor ultrasonico, poderia medir a distancia ao redor do carrinho, bem pratico. Porém pra que isso funciona-se, foi necessário refazer o código e então, como vocês podem ver no vídeo abaixo depois de alguns ajustes relacionados a distância de detecção e então a coisa começou a andar (e sem bater … o que é mais importante)

… As flores …

Os para choques ainda são necessários, pois alguns objetos não são detectados a tempo, as vezes são muito fino ou algo aonde o sensor ultrasonico não da conta, e então o robô estava batendo. Aumentei a distancia de detecção, o que melhorou bastante porém ainda assim é necessário implementar um para choque.

Dependendo do piso, o pneu do carrinho escorrega, prejudicando assim o “bom andar” dele. breve substituirei a rodinha tradicional pela longarina (roda de tanque) para ver se esse problema é amenizado.

Algumas fotos (incluindo o fritzing):

No site tem até versão para possível tradução, se alguém quiser arriscar traduzir pra português, seria muito legal.

O link é http://mightyohm.com/blog/2011/04/soldering-is-easy-comic-book/

O que significou que agora poderia começar a brincadeira de fazer o arduino ser um carrinho, depois de transformar um monte de plasticos (img 02) em uma caixa de redução (img 03) poderia finalmente desenrolar a idéia de fazer um carrinho e no decorrer do processo, ir dando liberdades a ele.

Imagem 01 - Caixa de Redução desmontada

Imagem 2 - Caixa de Redução Montada

A outra opção era utilizar de servos motor (configurados para rotação continua – vídeo abaixo) , eu até comprei alguns servos, porém os produtos da china tem demorado uma eternidade pra chegar (encomendei no começo de fevereiro) acabei optando óbvio,  que já estava em mãos.
Como mostrei a listinha de compras da sparkfun, comprei também uma base, rodas e a esteira de tanque (que um dia aparecerá por aqui também) , tudo isso produziu o carrinhoDU versão 0.2:

Segunda versão do carrinhoDU

(breve mais fotos, com qualidade melhor)

O “super código” que está fazendo o motor funcionar é esse:

/*
const int motor1Pin = 6;    // H-bridge leg 1 (pin 2, 1A)
const int motor2Pin = 7;    // H-bridge leg 2 (pin 7, 2A)
const int enablePin = 10;    // H-bridge enable pin

const int motor3Pin = 2;    // H-bridge leg 1 (pin 2, 1A)
const int motor4Pin = 3;    // H-bridge leg 2 (pin 7, 2A)
const int enable2Pin = 11;    // H-bridge enable pin
*/

int motor_left[]  = {6,7};
int motor_right[] = {3,2};
int motor1en      = 10;
int motor2en      = 11;
int contador;

const int ledPin = 13;      // LED

void setup() {
    // set all the other pins you're using as outputs:
    Serial.begin(115200);

    pinMode(motor1en,OUTPUT);
    pinMode(motor2en,OUTPUT);
    for(int i = 0; i < 2; i++){
        pinMode(motor_left[i], OUTPUT);
        pinMode(motor_right[i], OUTPUT);
    }

    Serial.println("Comecando em 10 secs");

    // blink the LED 3 times. This should happen only once.
    // if you see the LED blink three times, it means that the module
    // reset itself,. probably because the motor caused a brownout
    // or a short.
    blink(ledPin, 7, 1000);
    blink(ledPin, 7,  425);
    liga();
}

void loop() {

    blink(ledPin,2, 900);
    drive_forward();
    delay(4000);
    blink(ledPin,2, 1000);
    motor_stop();

    delay(1000);
    blink(ledPin,2, 900);
    drive_backward();

    delay(3000);motor_stop();
    blink(ledPin,2, 900);
    turn_left();

    delay(560);motor_stop();
    blink(ledPin,2, 900);
    drive_forward();

    delay(10000);motor_stop();
    blink(ledPin,2, 900);
    turn_left();

    delay(560);motor_stop();
    blink(ledPin,2, 900);

    motor_stop();

    /*
    drive_forward();
    delay(1000);
    turn_left();
    delay(560);
    motor_stop();
    blink(ledPin, 5, 100);
    turn_right();
    delay(560);
    motor_stop();
    */

    desliga();
    delay(20000);

    /*
    contador = 1;
    while(contador < 3) {
        blink(ledPin, 3, 100);
        delay(1000); drive_forward();
        delay(1000); turn_left();
        delay(1000); drive_forward();
        delay(1000); turn_right();
        delay(1000); drive_forward();
        delay(1000); turn_right();
        delay(1000); drive_forward();
        delay(1000); turn_right();
        delay(1000); drive_forward();
        delay(1000); turn_left();
        delay(1000); motor_stop();
        delay(1000); drive_backward();
        delay(5000);
        blink(ledPin, 5, 400);
        contador++;
    } */
}

/*
blinks an LED
*/
void blink(int whatPin, int howManyTimes, int milliSecs) {
    int i = 0;
    for ( i = 0; i < howManyTimes; i++) {
        digitalWrite(whatPin, HIGH);
        delay(milliSecs/2);
        digitalWrite(whatPin, LOW);
        delay(milliSecs/2);
    }
}

void liga(void) {
    digitalWrite(motor1en, HIGH);
    digitalWrite(motor2en, HIGH);
}
void desliga(void) {
    digitalWrite(motor1en, LOW);
    digitalWrite(motor2en, LOW);
}

// Funcoes do Motor
// ————————————————————————— Drive
void motor_stop(){
    Serial.println("StopA");
    digitalWrite(motor_left[0], HIGH);
    digitalWrite(motor_left[1], HIGH);
    digitalWrite(motor_right[0], HIGH);
    digitalWrite(motor_right[1], HIGH);

    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], LOW);
}
void drive_forward(){
    digitalWrite(motor_left[0], HIGH);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], HIGH);
    digitalWrite(motor_right[1], LOW);
}
void drive_backward(){
    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], HIGH);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], HIGH);
}

void  turn_right(){
    digitalWrite(motor_left[0], LOW);
    digitalWrite(motor_left[1], HIGH);
    digitalWrite(motor_right[0], HIGH);
    digitalWrite(motor_right[1], LOW);
}

void turn_left(){
    digitalWrite(motor_left[0], HIGH);
    digitalWrite(motor_left[1], LOW);
    digitalWrite(motor_right[0], LOW);
    digitalWrite(motor_right[1], HIGH);
};

Retirado da página que foi a inspiração e o modelo que segui para fazer o controle de motores DC usando uma Ponte H: DC Motor Control Using an H-Bridge

Os códigos fontes agora ficam no meu repositório no GitHub - esse é o _2motores_OK.

Próximos passos:

Entender como funciona o Delay, já que o tempo de resposta do motor é diferente, e controlar com delays não está assim “muito trivial”.

Chegou um leitor de RFID, já está funcionando no Arduino (GitHub – robofiles/rfid), e ganhará alguma função no carrinho também (chave de ligar/desligar ?)

Extra:

Vídeo mostrando como modificar servo motor para rotação continua:

Depois disso tudo vim a descobrir que existe uma relalção direta entre torque, velocidade, peso e tamanho da roda, então estava comprovado que minha Gambiarra estava muito longe de funcionar, porém já tive a alegria de ver alguns conceitos funcionando, o Controle remoto já estava controlando os motores, ainda que com vários “por menores” pra coisa funcionar. Já que apesar dos pesares a parte mecânica é a que estava dando problemas resolvi tirar os escorpiões e partir para as compras, veja:

Quando chegar ai então será mais produtivo os robos, já que poderei montar de cara 2 tipos de robo, um com esteira tipo Tank (Tank Treads) e outro mais universal, utilizando o Universal Plate Set, junto de tudo isso comprei também outros acessórios aonde destaco o Dual Motor Gearbox, uma caixa de redução, ou melhor, 2 caixas, 2 motores, unidos, possibilitando assim que cada motor vire independente, e assim o robo consiga virar.

Além dessas compras, ainda tem alguns servos e até um leitor de RFID, que assim que estiverem em mãos crio algo e compartilho.

Por enquanto é isso

Obs: Os itens descritos foram comprados na Sparkfun, os servos no DealExtreme e o RFID na RobotShop

Porém tenho que me explicar aqui, já que comentei no post anterior do “Semáforo” que o próximo projeto era colocar o GLCD pra funcionar no semáforo, o projeto foi “completado” porém ainda estava fazendo alguns acertos quando ele resolveu dar algum mal contato no “ninho de rato” (fios) ai então resolvi abortar a idéia, e partir pro motor, testes realizados com sucesso (pretendo postar algo depois apenas sobre o motor DC e a ponte H.

E já que o motor funcionou, porque não colocar uma roda e fazer ele andar ? Afinal é tão legal quando alguém pergunta… – E além de acender as luzes, isso faz mais alguma coisa ?

O Infra Vermelho

Tendo em base que iria fazer um carrinho, era necessário então ter algum tipo de controle sobre ele, no Kit que adquiri vinha um receptor de Infra Vermelho, então esse seria o controle, abaixo o fritzing do controle:

Observações sobre o IR.

- Procurei diversas bibliotecas para facilitar o serviço, algumas eram pra controles especificos e tinha um entendimento não muito favorável, foi então que descobri a IRremote, uma biblioteca sensacional, pois ela é multi-protocolo, ou seja, independente do controle que você colocar la na frente ele irá dar alguma resposta (ou não), e o mais interessante, a biblioteca não só cuida da recepção de IR, mas também envia IR através de um LED, o que torna a coisa ainda mais interessante, veja um trecho de código:

/* enviando algo */
#include <irremote .h>
IRsend irsend;

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

void loop() {
  if (Serial.read() != -1) {
    for (int i = 0; i < 3; i++) {
      irsend.sendSony(0xa90, 12); // Sony TV power code
      delay(100);
    }
  }
}

/* recebendo algo */
#include <IRremote.h>

int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

void loop() {
  if (irrecv.decode(&amp;results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
  }
}

Como visto, o uso da biblioteca é meio que trivial, então já que seria fácil a implementação do controle remoto do carrinho, o próximo passo é botar os motores pra funcionar:

O motor

Vasculhando meus antigos projetos, descobri que tinha 1 (eu juro que era 2, mas só achei 1 ) motorzinho DC, e fiz os testes baseados nele, seguindo a ajuda e indicações do site: ipt physical computing, onde o autor do tutorial sugeriu a utilização de um CI de ponte-H para fazer a inversão das fases no motor, possibilitando que o motor vá pra frente e para tras, veja o fritizing:

Logo apos montar o projeto acima, testei e Voilá, tudo funcionou na perfeição, motorzinho girando de um lado e do outro, uma beleza, mas, todavia, no entanto, nem tudo são flores,  depois que resolvi desmonta-lo para fazer outra coisa, na remontagem (processo que estou fazendo nesses dias) o danado não quer funcionar, acho que porque coloquei os 2 motores, e alguma coisa eu fiz errado.

Assim que acertar eles, volto a comentar nesse post o andamento da construção

A base

Uma história a parte em projetos robóticos é sem dúvidas a parte mecânica das coisas, algo que pode arruinar o projeto, pensando nisso (até aparece) resolvi utilizar uma caixinha slim de CD como base, coloquei os 2 motores na lateral (mais abaixo a história dos motores), fixados com fita dupla face e fita crepe estão a espera da parte eletrônica.

Observações da base: No momento como roda estou utilizando 2 CDs, daqueles da AOL que todo mundo tem, guardado e no saquinho, porém o buraco do CD é grande, foi necessário então uma operação cirurgica para adicionar ao CD uma engrenagem centralizada,  para logo depois encaixa-la no eixo do motor. Tudo isso feito com muito silicone, aparentemente estão razoavelmente certas as rodas, porém essa bomba saberei só quando os motores funcionar.
Mais detalhes quando as fotos aparecerem por aqui.

A história do Motor

Alguém lembra do Creative Infra Red? Existia um desse, parado em casa, já parcialmente canibalizado, porém os motores ali estavam, intactos, 3 ou 4, esperando a hora do abate… essa hora chegou, desmotei-o todo e retirei dele os motores, 2 sensores que eu ainda não sei como utilizar, mas que imagino eu, serão os olhos do robô (será?). Além dos motores, sobraram várias engrenagens, de diversos tamanhos, 2 delas estão na história, lá em cima quando falo que precisei fazer uma brasilidade para encaixar os CDs nos motores.
Surfando pela internet já ouvi falar que da pra utilizar esses motores, incluindo um motor de passo que nele há, porém não li nada, só extrai os 2 motores DC que me interessavam, vi que eles são razoavelmente iguais, apesar de um deles ser mais esperto que o outro. Porém, verifiquei que existe a possibilidade de controlar via PWM a velocidade dos motores, dessa maneira pretendo sincro niza-los, assim que as cosias funcionarem, relato o ocorrido.

Por enquanto é isso… o primeiro passo rumo ao robô foi dado!!!!