Código do robô

Iremos dividir o código abaixo em funções para que fique melhor organizado. O código abaixo foi testado e funciona perfeitamente:

/*
Atenção para que o robô possa funcionar corretamente as seguintes regras devem valer:

 1. Se fótoscópio norte é o 1 (ligado na serial 0) servo do norte é o 2 (ligado na digital pwm 5);
 2. Se fótoscópio sul é o 2 (ligado na serial 1) servo do sul é o 1 (ligado na digital pwm 3);
 3. Se fótoscópio leste é o 3 (ligado na serial 3) servo do leste é o 4 (ligado na digital pwm 9);
 4. Se fótoscópio oeste é o 4 (ligado na serial 4) servo do oeste é o 3 (ligado na digital pwm 6);
*/

#include <Servo.h>                 //Esta biblioteca contem as operações para manuseio e reconhecimento dos servos
Servo servo[4];                    //Cria um vetor do tipo servo para os 4 servos (o tipo servo é tipo importado da biblioteca servo.h)

//cria constantes inteiras relativas as portas de entrada analógicas
const int pinLDRtower1 = 0;       //pino do fótoscópio 1 na porta 0, etc...
const int pinLDRtower2 = 1;
const int pinLDRtower3 = 2;
const int pinLDRtower4 = 3;

//criação das variáveis
int LDRtower[5];                   //variável do tipo número inteiro que irá receber a tensão do circuito do fotoscópio
int sensibilidade = 390;           //variável do tipo número inteiro indicando a quantidade mínima de bits recebidos pela porta analógica quando ha presença e luz
int contador;                      //variável do tipo número inteiro que servirá de contador. Será usado para comparar qual fótoscópio recebeu sinal maior
int daVez;                         //variável que irá definir qual fótoscópio o robô tem que seguir (qual é o da vez)
int fonteLuzDetectada;             //variável do tipo número inteiro que servirá de semáforo para dar inicio aos movimentos do robô caso haja uma fonte emisora de fótons

void setup(){
  //mostrar para o CI onde estão ligados os Servos
  servo[0].attach(3); //servo 0 corresponde ao primeiro servo ligado na porta 3, assim por diante...
  servo[1].attach(5);
  servo[2].attach(6);
  servo[3].attach(9);

  //inicializo cada valor do vetor que recebe os valores do fótoscópio com 0
  for(contador = 1; contador < 5; contador++){
    LDRtower[contador] = 0;
  }

  //inicializo o funcionamento da porta serial com leitura 9600bps (bps = bites por segundo)
  Serial.begin(9600);
}

void zerarVarDeControle(int daVez, int fonteLuzDetectada){
  //zerar as variáveis que iram definir qual lado o robô deve seguir
  daVez = 0;
  fonteLuzDetectada = 0;
}

void receberLeiturasAssociandoFotoscopioaPino(int LDRtower[4], int pinLDRtower1, int pinLDRtower2, int pinLDRtower3, int pinLDRtower4){
  //faz com que cada valor do vetor de fótoscopios receba as medidas de suas respectivas portas
  LDRtower[1] = analogRead(pinLDRtower1); //A torre do LDR 1 recebe os valores da porta analógica 0 (pinLDRtower1), e assim por diante...
  LDRtower[2] = analogRead(pinLDRtower2);
  LDRtower[3] = analogRead(pinLDRtower3);
  LDRtower[4] = analogRead(pinLDRtower4);
}

void funcaoDeixarRobodePe(Servo servo[4]){
  //deixa o robô em pé colocando todos os servos num angulo de 90º
  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
}

int verificaRecepcaoLuminosa(int contador, int LDRtower[4], int sensibilidade, int fonteLuzDetectada){
  //verifica se algum fotoscopio recebeu sinal luminoso
  for (contador = 1; contador < 5; contador++){
    if (LDRtower[contador] > sensibilidade) fonteLuzDetectada = 1;
  }
  return(fonteLuzDetectada);
}

int achaMaior(int daVez, int contador, int LDRtower[4]){
  //verifica qual fotoscopio recebeu sinal maior e taxa-o como daVez
  daVez = 1;
  for (contador = 2; contador < 5; contador++) if (LDRtower[daVez] < LDRtower[contador]) daVez = contador;
  return(daVez);
}

void irEmDirecaoAoFotoscopio1(Servo servo[4]){
  //movimento de sincrono que inicia a movimentação do robô em direção ao fotoscopio 1:
 
  //deita uma perna
  servo[0].write(45);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  servo[0].write(0);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  //deita a outra
  servo[0].write(0);
  servo[1].write(135);
  servo[2].write(135);
  servo[3].write(135);
  delay(500);

  servo[0].write(0);
  servo[1].write(180);
  servo[2].write(180);
  servo[3].write(180);
  delay(100);

  //pula!
  servo[0].write(180);
  servo[1].write(0);
  servo[2].write(180);
  servo[3].write(180);
  delay(500);

  //levanta uma perna
  servo[0].write(135);
  servo[1].write(0);
  servo[2].write(135);
  servo[3].write(135);
  delay(500);

  servo[0].write(90);
  servo[1].write(0);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  //levanta a outra
  servo[0].write(90);
  servo[1].write(45);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);
}

void irEmDirecaoAoFotoscopio2(Servo servo[4]){
  //movimento de sincrono que inicia a movimentação do robô em direção ao fotoscopio 2:
 
  //deita uma perna
  servo[0].write(90);
  servo[1].write(45);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  servo[0].write(90);
  servo[1].write(0);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  //deita a outra
  servo[0].write(135);
  servo[1].write(0);
  servo[2].write(135);
  servo[3].write(135);
  delay(500);

  servo[0].write(180);
  servo[1].write(0);
  servo[2].write(180);
  servo[3].write(180);
  delay(100);

  //pula!
  servo[0].write(0);
  servo[1].write(180);
  servo[2].write(180);
  servo[3].write(180);
  delay(500);

  //levanta uma perna
  servo[0].write(0);
  servo[1].write(135);
  servo[2].write(135);
  servo[3].write(135);
  delay(500);

  servo[0].write(0);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  //levanta a outra
  servo[0].write(45);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);
}

void irEmDirecaoAoFotoscopio3(Servo servo[4]){
  //movimento de sincrono que inicia a movimentação do robô em direção ao fotoscopio 3:
 
  //deita uma perna
  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(45);
  servo[3].write(90);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(0);
  servo[3].write(90);
  delay(500);

  //deita a outra
  servo[0].write(135);
  servo[1].write(135);
  servo[2].write(0);
  servo[3].write(135);
  delay(500);

  servo[0].write(180);
  servo[1].write(180);
  servo[2].write(0);
  servo[3].write(180);
  delay(100);

  //pula!
  servo[0].write(180);
  servo[1].write(180);
  servo[2].write(180);
  servo[3].write(0);
  delay(500);

  //levanta uma perna
  servo[0].write(135);
  servo[1].write(135);
  servo[2].write(135);
  servo[3].write(0);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(0);
  delay(500);

  //levanta a outra
  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(45);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);
}

void irEmDirecaoAoFotoscopio4(Servo servo[4]){
  //movimento de sincrono que inicia a movimentação do robô em direção ao fotoscopio 4:
 
  //deita uma perna
  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(45);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(0);
  delay(500);

  //deita a outra
  servo[0].write(135);
  servo[1].write(135);
  servo[2].write(135);
  servo[3].write(0);
  delay(500);

  servo[0].write(180);
  servo[1].write(180);
  servo[2].write(180);
  servo[3].write(0);
  delay(100);

  //pula!
  servo[0].write(180);
  servo[1].write(180);
  servo[2].write(0);
  servo[3].write(180);
  delay(500);

  //levanta uma perna
  servo[0].write(135);
  servo[1].write(135);
  servo[2].write(0);
  servo[3].write(135);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(0);
  servo[3].write(90);
  delay(500);

  //levanta a outra
  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(45);
  servo[3].write(90);
  delay(500);

  servo[0].write(90);
  servo[1].write(90);
  servo[2].write(90);
  servo[3].write(90);
  delay(500);
}

//função padrão do Arduino, pode ser interpretada como principal, e fica em constante loop
void loop(){
  //zerar as variáveis que iram definir qual lado o robô deve seguir
  zerarVarDeControle(daVez, fonteLuzDetectada);

  //faz com que cada valor do vetor de fótoscopios receba as medidas de suas respectivas portas
  receberLeiturasAssociandoFotoscopioaPino(LDRtower, pinLDRtower1, pinLDRtower2, pinLDRtower3, pinLDRtower4);

  //deixa o robô em pé colocando todos os servos num angulo de 90º
  funcaoDeixarRobodePe(servo);

  //verifica se algum fótoscópio recebeu o sinal luminoso
  fonteLuzDetectada = verificaRecepcaoLuminosa(contador, LDRtower, sensibilidade, fonteLuzDetectada);

  //se recebeu quem recebeu o sinal maior
  if (fonteLuzDetectada == 1){
    daVez = achaMaior(daVez, contador, LDRtower);
    //uma vez que se sabe qual é o maior sinal luminoso de acordo com a variável daVez, executa-se seu respectivo movimento de acordo com o valor de daVez.
    switch (daVez) {
      case 1:    //verifica se o fotoscópio da vez é o 3
        while(daVez == 1){    //executa as funções abaixo até que o daVez não seja mais o 1
          //faz o robô andar em direção da luz recebida pelo fótoscópio 1 até que ela suma ou outro fótoscópio receba luminosidade maior
          irEmDirecaoAoFotoscopio1(servo);
 
          //zerar as variáveis que iram definir qual lado o robô deve seguir
          zerarVarDeControle(daVez, fonteLuzDetectada);

          //faz com que cada valor do vetor de fótoscopios receba as medidas de suas respectivas portas
          receberLeiturasAssociandoFotoscopioaPino(LDRtower, pinLDRtower1, pinLDRtower2, pinLDRtower3, pinLDRtower4);

          //verifica se algum fótoscópio recebeu o sinal luminoso
          fonteLuzDetectada = verificaRecepcaoLuminosa(contador, LDRtower, sensibilidade, fonteLuzDetectada);
         
          //verifica qual fotoscopio recebeu sinal maior no case de deteccao de luz
          if (fonteLuzDetectada == 1){
            daVez = achaMaior(daVez, contador, LDRtower);
          }
        }
        break;
      case 2:    //verifica se o fotoscópio da vez é o 2
        while(daVez == 2){    //executa as funções abaixo até que o daVez não seja mais o 2
          //faz o robô andar em direção da luz recebida pelo fótoscópio 2 até que ela suma ou outro fótoscópio receba luz maior
          irEmDirecaoAoFotoscopio2(servo);
 
          //zerar as variáveis que iram definir qual lado o robô deve seguir
          zerarVarDeControle(daVez, fonteLuzDetectada);
 
          //faz com que cada valor do vetor de fótoscopios receba as medidas de suas respectivas portas
          receberLeiturasAssociandoFotoscopioaPino(LDRtower, pinLDRtower1, pinLDRtower2, pinLDRtower3, pinLDRtower4);
 
          //verifica se algum fótoscópio recebeu o sinal luminoso
          fonteLuzDetectada = verificaRecepcaoLuminosa(contador, LDRtower, sensibilidade, fonteLuzDetectada);
   
          //verifica qual fotoscopio recebeu sinal maior no case de deteccao de luz
          if (fonteLuzDetectada == 1){
            daVez = achaMaior(daVez, contador, LDRtower);
          }
        }
        break;
      case 3: //verifica se o fotoscópio da vez é o 3
        while(daVez == 3){    //executa as funções abaixo até que o daVez não seja mais o 3
          //faz o robô andar em direção da luz recebida pelo fótoscópio 3 até que ela suma ou outro fótoscópio receba luminosidade maior
          irEmDirecaoAoFotoscopio3(servo);

          //zerar as variáveis que iram definir qual lado o robô deve seguir
          zerarVarDeControle(daVez, fonteLuzDetectada);
 
          //faz com que cada valor do vetor de fótoscopios receba as medidas de suas respectivas portas
          receberLeiturasAssociandoFotoscopioaPino(LDRtower, pinLDRtower1, pinLDRtower2, pinLDRtower3, pinLDRtower4);
 
          //verifica se algum fótoscópio recebeu o sinal luminoso
          fonteLuzDetectada = verificaRecepcaoLuminosa(contador, LDRtower, sensibilidade, fonteLuzDetectada);
   
          //verifica qual fotoscopio recebeu sinal maior no case de deteccao de luz
          if (fonteLuzDetectada == 1){
            daVez = achaMaior(daVez, contador, LDRtower);
          }
        }
        break;
      case 4: //verifica se o fotoscópio da vez é o 4
        while(daVez == 4){ //executa as funções abaixo até que o daVez não seja mais o 4
          //faz o robô andar em direção da luz recebida pelo fótoscópio 4 até que ela suma ou outro fótoscópio receba luz maior
          irEmDirecaoAoFotoscopio1(servo);
 
          //zerar as variáveis que iram definir qual lado o robô deve seguir
          zerarVarDeControle(daVez, fonteLuzDetectada);
   
          //faz com que cada valor do vetor de fótoscopios receba as medidas de suas respectivas portas
          receberLeiturasAssociandoFotoscopioaPino(LDRtower, pinLDRtower1, pinLDRtower2, pinLDRtower3, pinLDRtower4);
   
          //verifica se algum fótoscópio recebeu o sinal luminoso
          fonteLuzDetectada = verificaRecepcaoLuminosa(contador, LDRtower, sensibilidade, fonteLuzDetectada);
         
          //verifica qual fotoscopio recebeu sinal maior no case de deteccao de luz
          if (fonteLuzDetectada == 1){
            daVez = achaMaior(daVez, contador, LDRtower);
          }
        }
      break;
    default:
      //se nada acontecer deixa o robô de pé escrevendo um angulo de 90º em todos os servos
      funcaoDeixarRobodePe(servo);
      break;
    }
    delay(180); //tempo em microssegundos que a aplicação é repedida
  }
}

Ultima apresentação

Esses são os slides da nossa ultima apresentação. Já que na ultima apresentação nós ficamos durante 30 minutos falando sobre os princípios físicos e o funcionamento de cada componente do robô e as dificuldades que encontramos durante o desenvolvimento do mesmo não havia muito o que se falar nesta ultima apresentação:

Projeto Arduino

View more presentations or Upload your own.

Breve estaremos aperfeiçoando o poster e postando novamente.

Poster

Segue abaixo a publicação do poster do projeto:

LDR

O Light Dependent Resistor (LDR), como o nome já da uma dica, é um resistor que varia sua resistividade de acordo com a incidência luminosa.

Um LDR quando não está em contato com a luz costuma ter uma resistividade de 1000000Ω, esta resistividade diminui com incidência da luz obedecendo a formula R = LCA, onde L é a luminosidade em Lux, A é o valor da corrente que passa por ele e C é a constante que depende do material que foi usado para construir o LDR. A resistência mínima do LDR sobre incidência de luz é de 100Ω.

O LDR que também é conhecido como fotoresistência ou célula fotocondutiva é constituído de um material fotossensível conectado a dois eletrodos metálicos, esse material pode ser sulfeto ou seleneto de Cádmio ou sulfeto de Chumbo (Obs: material também usado nos filmes das antigas maquinas fotográficas).

Mas como funciona?

O LDR é um semicondutor, quando existe a incidência de luz, os fótons levam os elétrons da camada de valência para a camada de condução que é mais longe da zona proibida. O aumento do número de elétrons na camada de condução é o que diminui a resistividade (não entendeu? Veja + sobre semicondutores).

Quem usa o LDR?

Um bom exemplo do uso de LDR são os postes de iluminação, a luzes das praças, sensores de luminosidade e o incrível instrumento a laser dos nossos amigos do projeto Projeto de Física para Computação.

O que isso ajuda para nós?

(Já agradecendo ao Enio Benatti da comunidade Laboratório de Garagem e a nossa querida professora Mariza Cavalcante por ter nos avisado de antemão)

Os eletroscópios por nós criados nesse projeto, apresentam uma inconveniência na funcionalidade de nosso robô.

Pois o mesmo possui muita variação e interferência, mesmo utilizando um algoritmo para filtragem dos valores recebidos pelo Arduino (breve postaremos os códigos) ainda assim o FET de vez em quando muda o valor da sua resistividade. Exemplo: Se o circuito deverá ascender uma lâmpada na presença de um campo, as vezes a lâmpada ascende e as vezes apaga.

Sendo assim nosso robô não poderia caçar fantasmas :P.

A solução foi mudar o componente FET para uma fotocélula.

Então modificamos o circuito da seguinte maneira:

Desta maneira não há muita influência na programação do nosso robô (pois a tensão aplicada é a mesma) e tendo em vista que alguns “espectros” produzem fótons o nome do robô será o mesmo.

(OBS: Não acreditamos em fantasmas, o nome do robô foi dado devido a forma que ele se comporta, brincadeiras aparte ;)

Links de pesquisa:

Toni Eletrônica
Feira de Ciencias
Mundo Educacao
Technology Student
LDR - Light Dependent Resistor

Robô ghost hunter prototype

No dia 10/05 foi apresentado um prototipo do nosso robô. Ele foi montado da seguinte maneira:

 Os servos são as caixinhas azuis na imagem acima, e os pontos cinza são as pernas dos servos (pernas unidirecionais, neste caso posicionadas em 90º). Se verificarmos a posição dos servos, observamos que as paletas (pernas) estão em linha reta em direção a paleta oposta.
Esta montagem possibilita que o robô salte de maneira instavel pra qualquer direção, apartir do campo detectado. Para ficar mais claro é só olhar o modelo de movimento do robô.

Como trata-se de uma montagem para apresentar nossos resultados, montamos o robô em uma caixa de papelão e "socamos" uma protoboard dentro para usar apenas um trilho para alimentação de todos os componentes (exagero, mas a idéia é usar um protoshield ou um trilho feito a mão mesmo)

Servo motores (pernas do nosso robô)

Nas postagens anteriores ouvimos falar muito sobre os Servo motores, e neste post estaremos explicando um pouco sobre seu funcionamento.

O servo motor é constituído de um CI de controle, que tem a função de receber o sinal do controlador, monitorar a posição na qual ele se encontra, e trabalhar com o potenciômetro para mover o motor.

O servo motor é, um potenciômetro, um motor elétrico, engrenagens que reduzem a rotação do motor e transferem mais força para o eixo, tudo isso numa caixinha de plástico (buniteenha).

Para alimentar o servo é preciso no mínimo, 4.8 volts. Nosso controlador, o Arduino, pode mandar para o servo uma tensão de 0 até 5 volts em um intervalo de 1 milissegundo até 2 milissegundos

A velocidade do sinal que o Arduino manda para o servo é o que determina a posição pra qual o servo vai se mover, é ai que entra o CI de controle do servo e o potênciometro ;)

Um sinal de 1ms corresponde a uma posição do braço do servo todo a esquerda ou 0º
Um sinal de 1,5ms é o que chamamos de posição central do servo ou 90º
Um sinal de 2ms corresponde a uma posição do braço do servo todo a direita ou 180º

 Detalhe! O Servo motor não roda mais que 180º, existem racks que fazer eles girarem continuamente, mas isso lobotomiza o servo e você não terá mais controle sobre ele, muito menos sobre o sentido de sua rotação.

Potenciômetro

Potenciômetros são resistores com uma variação central e a resistência entre seus dois extremos é fixa em seu valor nominal. Já o valor de resistência entre uma das extremidades depende do posicionamento do cursor.

Cria-se, então, uma estrutura que pode ser compreendida como dois resistores em série:

As informações sobre Servo motores foram retiradas do site Asas Elétricas
E as informações sobre Potenciômetro do site Saber Eletrônica Online

Esquema técnico do Ardumoto

Qualé eu não podia ficar devendo essa imagem:

A imagem acima foi retirada do link: Ardumoto v12 (PDF)

Ponte H

Queridos leitores, não vamos utilizar ponte H no projeto. Simplismente achamos que o entendimento desse cirquito pode ajudar a outras pessoas tbm (e claro não foje do nosso contexto, já que nossa primeira idéia era usar motores DC normais)

Como dito na postagem anterior para fazer um motor elétrico mover para os dois lados é necessário inverter sua polaridade.

Pois bem, mas se vc também é noob como projetista e quer montar um robô automático assim como o nosso, deve estar se perguntando "Como vou fazer isso sem por a mão no motor ou nos fios?!".
Após algumas conversas com o pessoal de eletrônica do laboratório de física da nosso campi (aquém aqui vai um agradecimento), descobrimos um circuito chamado Ponte H.

O nome parece ser devido ao “skemão” do circuito (assim como nas figuras do post anterior, considere a posição do motor como deitado sendo apontado para você):

Bom, com a imagem acima já deu pra deixar bem claro, mas explicando melhor: Observando as quatro chaves, dentre as chaves eletrônicas, o uso de transistores é o mais adequado. De acordo com a combinação das chaves uma tensão diferente será aplicada nas escovas do motor, alterando a polaridade do eletroímã e o movimento do motor.

Para a salvação de nós projetistas entusiastas, existe um shield para Arduino que já vem com um esquema de ponte H pronto e pode gerenciar até 2 motores elétricos, chama-se Ardumoto e pode ser encontrado no site da robocore.

As imagens e algumas informações são do link: Montagem de uma ponte h (PDF)

Motores elétricos

O Motor elétrico é um dos componentes do Servo motor (pode se dizer que o servo motor é um motor elétrico com algumas funcionalidades adicionais). O principio de movimentação do motor elétrico baseia-se no magnetismo.
No começo desse semestre de física, estudamos eletroímãs e força eletromagnética, por isso achamos interessante citar o funcionamento do mesmo na apresentação e estamos colocando um post aqui sobre ele:


O motor elétrico usa imas e eletro-imas como principio de seu movimento. Uma peça de metal localizada no centro do motor chamada de rotor (ou eixo) e é acoplada a umas “orelhas/asas” chamada de armadura. A armadura é uma peça de metal envolvida por bobinas de cobre que é um eletroímã (vamos explicar um pouco de eletroímã mais abaixo), essa peça é a peça roda dentro do motor e faz o motor elétrico girar.

A imagem abaixo trata-se de um esquema simples para se entender um motor elétrico, neste caso o motor está deitado com a parte que gira (eixo) apontando para você.

Próximo ao eixo existem duas terminações das bobinas chamadas de comutadores, elas estão posicionadas envolvendo o rotor, de forma a deixar um espaço diagonal vazio.
Este esquema de posicionamento do comutador foi feito estrategicamente para que o motor possa girar para os dois lados dependendo da polaridade da bobina.
São as escovas que levam energia para as bobinas e a polaridade é mutável de acordo com a posição da bateria (polaridade da fonte de energia).

Mas o segredo do movimento está nestes dois imas posicionados de forma circular nas paredes internas da armadura chamados de imas de campo.

Já que os pólos dos imas (eletroima e ima de campo) se atraem quando diferentes e se repelem quando iguais o motor elétrico usa essas forças de repulsão e atração na forma de um movimento de rotação (que lindo :D).

O gif abaixo deixa um pouco mais claro:

 
Experiência

Se nao tiver nada pra fazer tente fazer a experiência abaixo:

O traço preto trata-se de um eixo as bobinas formam um eletroíma, entenda o ima em forma de ferradura como o ima de campo, vc vera que o prego ira começar a rodar :D.
Porém há a possibilidade de ele enganchar (quando o polo negativo do eletroímã cola no polo positivo do ima de campo e vice-versa), por isso os eletroímas possuem sempre 3 polos na sua armadura (que nesse caso é o prego da imagen acima) sendo assim impossivel de ocorrer um "enrosco". Motores elétricos mais potentes, como por exemplo, o motor de arranque de um carro possuem maior número de polos.

As imagens e algumas informações foram retiradas do link abaixo (link muito bom por sinal, é recomendado ver outras coisas legais que tem lá ^^):
Howstuffworks

Apresentação do dia 10/05

No dia 10/05 fizemos uma apresentação de todos os resultados que obtivemos até agora. A apresentação não visava apenas explicar o que conseguimos fazer e o que ainda falta fazer, mas também explicar os principios físicos de cada componente e de cada operação executada durante o funcionamento do robô.

Os slides da apresentação não possuem texto, somente imagens. Pois o grupo decidiu que a melhor forma de apresentar alguma coisa é utilizando apenas imagens.

Porém nas postagens a seguir estaremos explicando o conteúdo da apresentação.

Projeto arduino reta final:

Projeto Arduino

View more presentations or Upload your own.

Curiosidades Arduino

Robô controlado por Kinect
Alunos da universidade UCL criaram uma mão mecânica que responde aos movimentos do usuário frente ao Kinect, utilizando um CI Arduino.

Construa seu proprio projeto com Arduino
Uma variedade de shields e versões do CI Open Source que está ganhando a preferência de projetistas e entusiastas em todo mundo.

Top 40 projetos com Arduino
Vejam a capacidade do CI Arduino na mão de pessoas com talento e criatividade, com certeza irão se surpreender.

Reta final

Queridos leitores, pedimos desculpas pelo tempo que ficamos sem falar nada sobre o projeto. Nas ultimas semanas estávamos estudando para as provas de quase todas as matérias do curso.
Achamos que o projeto deveria ser entregue em junho porém já temos que entrega-lo quase pronto na semana que vem.

Então devido a pressa tivemos que fazer algumas modificações no projeto:

1. Não usaremos mais o ardumoto shield arduino, mas sim um arduino protoshield. Mas como ninguém recebeu ainda provavelmente não vai dar tempo de apresentar nosso robô com a protoshield já implementada. Mas vamos usar uma improvisação provisória.

2. Não vamos usar servos hackeados, vamos usar servos normais.

3. Não usaremos mais rodas mas sim pernas, em uma movimentação alias a movimentação vai ficar bem engraçada ^^!

O material para a base que suportará os periféricos do robô não será mais uma placa de acrilico pois não temos tempo para modela-la. O novo material para acoplar o Arduino e os demais componentes será uma caixa de papelão.

Futuramente estaremos implementando o robô para que ele fique mais bonito, com armadura de acrílico e caixinhas para os eletroscópios que ficaram ao redor.
Na caixa de papelão ele ficará mais ou menos assim:

As paletas que vem junto com os servo motores serão as pernas. Esse modo de estruturar o robô, nos trouxe uma grande dificuldade quanto a movimentação do robô. As pernas não tem flexibilidade então ele não ira andar, mas ira saltar para cima do campo elétrico como se fosse um grilo.

A movimentação das pernas será sincronizada, o robô irá recolher uma perna, depois a outra, as pernas nas laterais as que terão que fazer o movimento de pulo irão auxiliar no equilibrio do robo. A imagem abaixo tenta explicar um pouco como será o movimento, o traço preto é a posição da perna controlada pelo servo motor:

O processo no qual o robô senta (na imagem onde todas as barras pretas estão na horizontal) antes de saltar para o lado onde está a fonte de campo elétrico é um processo mais cuidadoso e é feito mais devagar do que o pulo (quando as pernas giram bruscamente para a direção contraria a do campo, o que vai fazer o robô saltar na direção do campo).

Os eletroscópios colados nas laterais da caixa (primeira imagem) serão feitos em tilhos feitos de madeira que nossa professora forneceu:

Notem que o esquema de montagem acima é o mesmo apresentado na postagem anterior. Como iremos fazer uma apresentação daqui a poucos dias, vamos deixar nosso blog com um gostinho de "quero mais" e parar por aqui.

Na próxima postagem iremos postar os videos dos testes que fizemos ao longo da montagem do robô, e também a apresentação que foi mostrada em sala de aula.

Grande abraço a todos e nos desejem sorte.

Transistor FET e Eletroscópio

Em todas as imagens que postei aqui onde aparece o projeto do robô citei um tal de “transistor” que geralmente é representado por um risco saindo do robô como se fosse uma antena.

Vou explicar um pouco mais sobre esse transistor e como pretendo trabalhar com ele no projeto.

O transistor tão citado, trata-se de um transistor FET (Field Effect Transistor/Transistor de efeito a campo). Não vou falar muito sobre ele, a intenção aqui é falar como vou usá-lo, mas vai uma breve e resumida explicação:

O FET é dividido em três partes: a porta (gate) a fonte e o dreno, quando se aproxima uma carga negativa (tipo um campo eletromagnético) ele aumenta a resistência, cortando assim a corrente que outrora passava da fonte pro dreno. Se quiser saber mais sobre o FET recomendo que leiam o artigo que nossa querida professora Marisa nos mandou.

Ok, o objetivo do FET é usar-lo para criar um eletroscópio de alta sensibilidade. O eletroscópio é um dispositivo que detecta a presença de um corpo carregado (carga negativa, tipo eletricidade estática), geralmente em proximidade com o corpo energisado faz alguma coisa do tipo ascender um led ou girar um ponteiro, enfim, igual aquele aparelho que o Dean e o Sam da serie Supernatural usam pra caçar fantasmas.

O eletroscópio que vi em sala apresentado pela professora Marisa, que foi o que originou a idéia desse projeto é esse ae:

O skemão dele é esse aqui:

Ué não entendeu???? Então vou simplificar, é mais ou menos assim ó (salve o paint):

Nesse caso quem recebe o sinal é um led, porém no nosso caso quem tem que receber o sinal é o Arduino então o esquema vai ser mais ou menos assim para cada eletroscópio (lembrando são 4: norte, sul, leste e oeste):

O código disso vai ficar tipo assim:

const int PinoEletroscopio = 0; // indica o pino onde foi ligado o eletroscópio
int Eletroscopio = 0; // inicializa a variavel Eletroscopio com o valor 0

void setup(){ // função pré-definida do Arduino usada para declaração de valores
  Serial.begin(9600); // carrega a biblioteca para porta serial com velocidade 9600bps
}

void loop(){ // função pré-definida do Arduino que executa um loop infinito
  Eletroscopio = analogRead(PinoEletroscopio);

/* lê os valores que entram na entrada PinoEletroscópio (que é 0) e guarda na variavel Eletroscopio*/

  if (Eletroscopio > 290){

/* Como se tratava de um teste este condicional foi posto pois no local onde estavamos fazendo o experimento havia muitos computadores e fios, observando as medidas percebemos que se a medida fosse acima de 290 seria util para nós, se não seria irrelevante (mas depende do ambiente).

*/

    funcaoRodar();

/* função que ainda não criamos mas estamos estudando, seria a função que moveria a rodinha*/

  }
}

Explicando melhor o circuito é tipo assim:
A porta do transistor é a que vai servir de antena.
Se nenhuma tensão é aplicada nela a base do transistor BC337 fica em estado de corte (pode se observar que nesse caso está sendo envidada uma carga negativa diretamente ao gate do BC337 o que aumenta sua resistividade) e não será enviado sinal elétrico para a porta 2 do Arduino. Então nessa hora o circuito que funciona é esse aqui:

Quando um campo eletrostático se aproximar da porta do transistor 2N3819 o mesmo entrará em estado de corte (transistores FET aumentam a resistividade sobre o efeito de um campo negativo, o que deixa ele em curto-circuito). Uma vez o transistor 2N3819 estando em estado de corte o transistor BC337 entrara em estado de condução, o que ira enviar um sinal elétrico para a porta 2 do Arduino que ativara a função para mover o motor. Nessa hora este circuito é o que funcionara (colocamos um led para melhor entendimento):

Pesquisa rapida sobre eletroscópio:

Artigo que a professora Marisa nos mandou

Física e Meio-Ambiente

Eletroscópio eletrônico (Detetor de cargas e campos)

Eletroscópio de Alta Sensibilidade

Como construir um eletroscopio no hard

Não clique no "vc é o milhonésimo visitante!"

Mudança na estrutura do robô

Com base nos estudos que fiz e com a ajuda dos colegas de outros grupos e do pessoal da Robôcore, decidi mudar a estrutura de nosso robô.
Tendo em vista que se eu for usar o shield controlador de motores para Arduino, só posso utilizar 2 motores e não 4 (ou 8 no caso de usar perninhas). Mesmo que fosse montar o circuito em um protoshield sem ajuda de um controlador, programar a funcionalidade de 4 motores ou mais simultaneamente exigiria muito mais do código e do hardware (não tanto assim, mas por que não melhorar?).
Então o novo desenho do robô ficou assim:

Deste modo controlarei apenas 2 motores: Um deles ira girar na horizontal e o outro ira girar na vertical.
Parece que com este desenho o problema dos motores está quase resolvido (depois de lobotomizar o único servo que eu tinha a toa :P), pois se por algum motivo eu não conseguir fazer os servo motores girarem 360º para os dois lados terei a opção de adicionar um motor na rodinha paralela à que já possui um motor, assim o motor de uma rodinha impulsionara o carrinho para um lado enquanto o motor da outra impulsionará para o outro lado(motores DC nesse caso).

Logo vou parar de falar e desenhar, e vou por a mão na massa.
Dia 5 de abril, a professora vai organizar uma oficina na sala de aula para estarmos iniciando nosso projeto.
Antes desse dia estarei fazendo alguns testes em casa para estar preparado, provavelmente estarei postando as fotos aqui no blog.
Assim irei utilizar essa aula para tirar duvidas sobre programação com a ajuda de nosso professor de programação Daniel Couto Gatti, e sobre as leituras de campo elétrico com a professora de física Marisa Cavalcante.

Slides da primeira apresentação no dia 15/03/11

Projeto arduino:

Projeto Arduino

View more presentations or Upload your own.

Conhecendo hardware e software:

Conhecendo o Hardware e o Software

View more presentations or Upload your own.

Curiosidades Arduino

Adaptações à parte?

A imagem acima trata-se de uma versão compacta do Arduino, resultante de um dos projetos de Kimio Kosaka, que diz respeito a arte do não usável, como ele prefere chamar. O Projeto não é novidade, pois existe um circuito chamado Arduino Mini. Porém o que chama a atenção é a forma artezanal no qual ele foi criado, o que destaca a flexibilidade do hardware.

Para esse e outros projetos de Kimio Kosaka envolvendo o Arduino clique AQUI

+ Peças

Tendo como base a pesquisa sobre motores eletricos + arduino, estou vendo se há a possibilidade de termos que fazer mais uma visitinha na loja virtual da RoboCore (de onde todas as informações abaixo sobre os equipamentos foram retiradas). Estou de olho em:

1.) Um Protoshield (adoro esse nome) pra arduino:

Esse dispositivo trata-se de uma protoboard para ser adaptada na face do Arduino. Esse dispositivo facilita muito a montagen do circuito e tbm alivia o fato de eu nunca ter trabalhado com um ferro de solda :P

O Kit Inclui:

1 x Proto PCB vermelha
2 x Conector empilhável 6 pinos
2 x Conector empilhável 8 pinos
2 x LED amarelos
2 x Resistor 330 Ohm
1 x Resistor 10k Ohm
2 x Botões
2 x Capacitor cerâmico 0.1uF

Características:

Tamanho: 5,5cm x 6,5cm
Todos os pinos do Arduino são trazidos para o nível superior
Soquete BlueSMiRF para comunicação sem fio entre os Arduinos
2 LEDs de uso geral
1 botão de uso geral
Botão Reset trazido para o nível superior

2.) Um (ou dois) shield - Ardumoto (se nossos testes com a protoshield derem certo ele será descartado):

Trata-se de um controlador de motores para arduino (estamos estudando a possibilidade do mesmo excluir o protoshield). O problema que só controla 2 motores :(

3.) Um (um agora só pra teste, se der certo serão 4) Servo motor:

Especificações:

Tamanho: 21x12x22 mm
Tensão de operação: 3 à 6V
Peso: 9g
Velocidade: 0.12s/60º (em 4.8V)
Torque: 1.6 Kg*cm (0.16 Nm)
Temperatura de operação: -30 à 60ºC
Buchas de teflon
Comprimento do cabo: 15cm
Braços e parafusos incluídos

De acordo com a pesquisa que fizemos no post anterior, o servo motor só gira em 180º, porêm existem alguns hacks para faze-lo girar em 360º (que estou estudando).

4.) Rodas para servo motor:

Esta roda de plástico é perfeita para ser usada junto aos Servo Motores da Futaba e possue diâmetro de 2-5/8”. Cada roda tem um pneu de silicone e 64 dentes para leitura de um encoder.

Características: Diametro: 69mm
Largura do pneu: 7,62mm
Pneus: moldados com silicone termoplástico

Pesquisa sobre motores

Links de pesquisa sobre motores eletricos conectados ao Arduino:

1.) O primeiro passo rumo ao robô

2.) Carrinho controle remoto + java + arduino = cool

3.) Tutorial de como trabalhar com Servo

4.) Controlar um motor DC com arduino

5.) Shield Motor Arduino (SMA) e plataforma 4 rodas

6.) Tutorial 05 for Arduino: Motors and Transistors (Youtube)

7.) Arduino arreglo de servos (Youtube)

8.) Robô caseiro 1 motor só (Youtube)

9.) Servo 360º (Youtube)

10.) 360 degree Continuous Rotation servo from BotBuilder.co.uk (Youtube)

11.) Fine Tuning Servo (Youtube)

12.) Motor shield (how to rev up)

13.) Shinajaran

14.) Conversão servo 360º (Youtube)

15.) Não é sobre motores mais é tão util quanto (Youtube)
Esses são os mais interessantes por enquanto.

Projeto Arduino: Robô Ghosthunter

A idéia mais firme até agora, é de criar um robô "caça fantasmas”. Fantasmas à parte, é um robô que segue campo elétrico.

O robô funcionara da seguinte maneira: serão colocados 4 transistores nas pontas norte, sul, leste e oeste, que servirão de antenas para nosso robô. O robô ira se movimentar na direção da antena que recebeu um sinal de campo elétrico. Para o caso de dois campos serem detectados, o robô seguira o que tem mais intensidade mas "lembrará" do outro campo detectado.
Se o campo mais forte sumir, o robô andara alguns paços (isso é, se eu for fazê-lo com pernas) na direção do segundo campo encontrado, procurando achar um novo campo elétrico.

Material para esse projeto: Estou ainda pensando na estrutura dele, mas já consegui algumas coisas úteis: Além dos materiais que vem junto com o kit Arduino, já consegui algumas estruturas de acrílico onde o circuito (que serão as vísceras do robô) vai ficar posicionado, também consegui rodinhas (um pouco grandes), motores elétricos (pequenos e grandes) e peças de lego.

A duvida sobre a estrutura do robô é quanto ao meio de locomoção. Se for utilizar rodas estou pensando em colocá-las em diagonal, de modo que ele consiga se mover para todos os lados.

A posição das antenas tbm é fundamental para a movimentação do robô:

Do primeiro modo até da pra fazer, mas as pernas deverão ter uma estrutura mecânica que coloque um par de rodinhas no chão de cada vez, de modo que as rodinhas na posição horizontal às que estiverem se movimentando não travem o movimento. Discordando da imagem, não é bem o jeito errado, mas sim o mais complicado que talvez vou tentar fazer futuramente para deixar o robô mais interessante (se for realmente usar rodas).

Se for montá-lo com pernas, a estrutura seria a seguinte

A o motor da base levantaria a perna do robô, e o motor da perna “puxaria o corpo do robô pra frente” num movimento sistemático, parecido com o de uma aranha.

O robô na forma de aranha, deverá ter 4 pernas desse tipo.

Brincadeiras a parte estou levando esse projeto muito a sério e esperamos ótimos resultados para ele.
Essa idéia do robô ghosthunter é com base em uma demonstração mostrada em sala de aula por nossa querida professora Dra. Marisa Almeida Cavalcante (PUC/SP).
Por enquanto estou só no papel, mas em breve novidades virão. Um abraço a todos os leitores.

Compra do equipamento

Onde achar o Arduino?
Percorri a rua Santa Efigênia (um dos maiores mercados de tecnologia de São Paulo) em busca do Arduino, porêm o mesmo não pode ser encontrado tão facilmente.

De acordo com o site oficial do Arduino, só existem 3 revendedores do produto no Brasil, que são: Multilógistica-shop, a Unite e a Robocore, todas lojas virtuais. Escolhi comprar o Kit para iniciante da Robocore, composto por:

1 x Arduino UNO
1 x Protoboard
1 x Cabo USB AB
1X Sensor de Temperatura (Termistor NTC 10k)
1x Sensor de Luminosidade (LDR 5mm)
1x Potenciômetro 10kΩ
4x Chave Momentânea (PushButton)
5x LEDs Amarelos
5x LEDs Verdes
5x LEDs Vermelhos
1x LED alto brilho
15x Resistores 330Ω
5x Resistores 10kΩ
1x Buzzer
20x fios Jumper Premium de 6"
10x fios Jumper Premium de 3"
2x Adaptador para fixacao de PaperSketches em Protoboard
1x CD com o manual completo + drivers + programas
10x PaperSketches com os seguintes projetos, juntamente com seus módulos de aprendizagem:


O site oficial disponibiliza os links para as lojas revendedoras.
http://arduino.cc/en/Main/Buy