quarta-feira, 7 de setembro de 2011

pHmetro

Para quem não conhece, pHmetro é o aparelho utilizado para medir pH de líquidos. Ele é composto de um dispositivo de leitura e uma ponta de prova. Para montar um pHmetro baseado em arduino compramos o kit pH-stamp, da Atlas Scientific. O kit é composto pelo pH-stamp, a ponta de prova e uma solução de calibração. O pH-stamp é um circuito que faz a interface entre uma ponta de prova de pH e o arduino:
Ele possui 6 conexões:
  • Vcc - alimentação da placa (tensão: 3,3 - 5,5v);
  • GND - o bom e o velho terra do arduino;
  • PRB - Sinal da ponta de prova;
  • GND - Terra da ponta de prova;
  • Tx e Rx - Estas duas conexões são responsáveis pela comunicação com o arduino.
As 2 primeiras conexões são conhecidas e não há nenhum mistério nelas. As outras duas, PRB e GND, são conectadas a um conector BNC (conector de cabo coaxial, o mesmo da figura abaixo), sendo que o conector central corresponde ao PRB e o externo ao GND.
As outras duas conexões, Tx e Rx, serão conectadas em portas digitais do arduino. É importante lembrar que a porta Tx do pH-stamp deve ser conectada a porta Rx do arduino e vice-versa. Até aqui, tudo o que eu falei está no manual que veio junto com o kit. No manual tem um código arduino para Duemilanove. Este código não funciona com o arduino MEGA. Fiquei duas horas tentando achar algum erro e estava prestes a desistir quando achei um fórum onde um usuário teve o mesmo problema.
O problema está na biblioteca utilizada no manual (NewSoftSerial) que não funciona com o arduino Mega. A solução é simples, basta fazer as conexões Tx/Rx nas outras portas de comunicação serial do Mega (o arduino mega tem 4 portas seriais). No meu caso, fiz a conexão utilizando a Serial1 do Mega (portas 18 e 19). O código está no final deste post.
Para ler os dados da porta serial eu estou usando um script em Python (estou abandonando o Processing) que lê os valores da porta e faz o gráfico do pH x tempo. O gráfico é atualizado constantemente e enquanto atualiza o gráfico o python salva os dados em um arquivo no computador (dados.dat). Abaixo tem uma imagem da janela do programa.

Para fazer esse script em python precisei aprender sobre dois módulos do python que eu não conhecia. O primeiro foi o pyserial, que faz a comunicação entre o python e o arduino, e o segundo é o pygame, responsável pela parte gráfica. O python tem diversas ferramentas para fazer gráficos e com certeza a pior delas é o pygame. Contudo o pygame tem outras funcionalidades que no futuro serão interessantes. Eu vou melhorar este script e adicionar botões para controle do pHmetro como, iniciar, pausar, salvar etc.

Segue um vídeo do resultado final:


Os dois códigos (arduino e python) você pode baixar clicando aqui!

Últimas considerações sobre este projeto:
Um pHmetro de bancada custa em média R$560,00. Nós precisamos importar o pH-stamp, já que não tem nacional. O custo total do projeto foi:
  • Arduino Mega - US$25,00
  • pH-stamp + ponta de prova + solução de calibração - US$80,00
  • TOTAL: US$105,00 (aproximadamente 180,00 reais)
Final da história, um equipamento equivalente e com as mesmas funcionalidades, por menos de 1/3 do preço.

sábado, 3 de setembro de 2011

Projeto: Harpa Laser

O Matheus Graciano está trabalhando numa harpa laser. O funcionamento é muito simples, um laser é apontado diretamente para um LDR (resistor dependente de luz) e fica-se monitorando o sinal vindo do LDR na porta analógica. Quando o laser é interrompido, o valor lido na porta analógica muda e então sabemos que nota deve ser tocada. Abaixo segue o vídeo da primeira versão da harpa, em breve faremos uma versão melhorada.




Nesta primeira versão da harpa usamos:

  • 7 Lasers vermelho;
  • 7 LDRs;
  • 8 Resistores de 100 Ohms;
  • 1 Botão push;
  • Fios, muitos fios;
  • Algumas peças da Atto.

Esta harpa é composta por 7 "cordas" que devem ser ligadas a 7 portas analógicas. Portanto, tivemos que usar o arduino Mega que tem 16 portas analógicas. Na figura abaixo eu mostro o esquema de como ligar o LDR, o botão e o Buzzer.

Neste projeto, as portas utilizadas são diferentes da imagem acima. Portanto, se for fazer a sua harpa, verifique quais portas você utilizou. No vídeo acima, não utilizamos um buzzer e sim os auto-falantes do micro. Se quiser fazer o mesmo, basta trocar o buzzer do diagrama acima por um plug fêmea de fone de ouvido. Abaixo segue o código Arduino que foi utilizado:



////////////////////////////////////////////
// Harpa Laser
// Por Matheus Graciano
////////////////////////////////////////////

// Vetores com notas musicais
// A primeira posição é a nota normal
// A segunda é a nota sustenida
float notaA[] = {440.000, 466.164};
float notaB[] = {493.883, 523.251};
float notaC[] = {523.251, 554.365};
float notaD[] = {587.329, 622.254};
float notaE[] = {659.255, 698.456};
float notaF[] = {698.456, 739.989};
float notaG[] = {783.991, 830.609};

// Algumas variáveis
float notaAnterior = 0, notaNova = 0;
int dt = 0, t0, acidente = 0;

void setup(){
pinMode(21, INPUT); //Porta onde está ligado o botao sustenido
pinMode(7, OUTPUT); //Porta do Buzzer
}

void loop(){

//Verifica se o botao está apertado
acidente = digitalRead(21);
// Varre as portas analógicas de 0 a 7 e verifica a nova nota
if(analogRead(0)< 120) {
notaAnterior = notaC[acidente]/4;
}
if(analogRead(1)< 120) {
notaAnterior = notaD[acidente]/4;
}
if(analogRead(2)< 70) {
notaAnterior = notaE[acidente]/4;
}
if(analogRead(3)< 70) {
notaAnterior = notaF[acidente]/4;
}
if(analogRead(4)< 70) {
notaAnterior = notaG[acidente]/4;
}
if(analogRead(5)< 120) {
notaAnterior = notaA[acidente]/2;
}
if(analogRead(7)< 120) {
notaAnterior = notaB[acidente]/2;
}
//Se a nota mudar, ele para e envia a nova nota
if(notaAnterior != notaNova){
noTone(7); notaNova = notaAnterior; t0 = millis(); }
// A nota final dura 1 segundo
if(dt>1000)
{
noTone(7);
}
else{
tone(7, notaNova, 1000);
}
dt = millis()-t0;
}

Em breve postaremos a nova versão da harpa. Antes de finalizar este post, agradecemos a Atto Brinquedos (www.attobrinquedos.com.br) por nos ter doado um conjunto de peças. As peças combinam muito bem com arduino, tem auxiliado bastante nos projetos que estamos realizando.

terça-feira, 30 de agosto de 2011

Apostila do Curso de Introdução ao Arduino.

Como anunciado no post anterior sábado dia 27/08 eu dei um curso de introdução ao arduino. Ao preparar o curso eu escrevi algumas notas. No link abaixo tem o pdf dessas notas de aula.

http://dl.dropbox.com/u/16556959/curso.pdf

domingo, 21 de agosto de 2011

III Maratona de software livre de Volta Redonda

Pessoal, dia 26 e 27 de agosto o ICEx vai receber a III Maratona de Software Livre de Volta Redonda. Entre as atraçōes estão a palestra de abertura do Thadeu Penna, a minha palestra e o meu curso de Introdução ao arduino. Há muitas outras palestras e cursos. Para ver a programação e se inscrever basta acessar:
http://www.iaesmevr.org/maratona2011/

segunda-feira, 18 de julho de 2011

Projeto: Fazendo o jogo do Pong com o arduino


O jogo do Pong é o primeiro videogame com fins lucrativos. O jogo é composto de duas "raquetes" (uma para cada jogador) e o objetivo é rebater a bola, evitando o ponto do seu oponente.


A imagem acima dá uma idéia melhor de como o jogo funciona. A idéia deste projeto é utilizar dois potenciômetros ao arduino e enviar a posição angular do potenciômetro para o computador através da comunicação serial. Utilizando o processing, vamos ler a porta serial e utilizar os dados recebidos para definir a posição das raquetes. A montagem do circuito é trivial.
O código do arduino é igualmente simples. Vamos ler os valores das portas analógicas e passá-los através da comunicação serial, no seguinte formato: os dois valores dos potenciômetros separados por ";".


void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print(analogRead(A0));
Serial.print(";");
Serial.println(analogRead(A2));
}

Simples assim, sem nenhum mistério. Agora só precisamos fazer o código do processing para receber e interpretar as informações. Não irei colocar muitos comentários sobre o código, se alguém tiver alguma dúvida, pode postar nos comentários que eu respondo.


// Importa a biblioteca de comunicação serial
import processing.serial.*;

Serial myPort; // Cria um objeto
float raio = 20; //Raio da bola
int X, Y; //Posição X e Y da bola
float vx=2, vy=2; // Componentes X e Y da velocidade da bola
float vx0=vx, vy0=vy; // Velocidades iniciais
int p1=0; //Pontuação do jogador 1 e 2
int p2=0;
int x1=15; // Posição X das duas "raquetes"
int x2=785;
float y1=0; // Posição Y das duas "raquetes"
float y2=0;
int tam=100; // tamanho da raquete
String[] vector;

void setup(){
size( 800, 400 ); //tamanho da janela
myPort = new Serial(this, Serial.list()[0], 9600); // Inicia a comunicação com a porta serial 0
PFont f = createFont("SansSerif", 40, true); //Define a fonte utilizada no placar
textFont(f,40);
strokeWeight( 1 ); // Largura das linhas
frameRate( 44 ); // Velocidade dos quadros
X = width / 2;
Y = (height-100) / 2;
myPort.bufferUntil('\n'); //Só inicia quando houver a primeira comunicação serial.
}


void draw(){
background( 255 ); //Define a cor de fundo
////////////////////////////////////////////////////
// Pega as informações recebidas pela porta
// serial e atribui as posições X e Y das raquetes
////////////////////////////////////////////////////
if(myPort.available()>1){
String inString= myPort.readString(); // Lê tudo que foi obtido pela porta serial
String[] teste =split(inString,"\n"); // Divide em linhas
String[] vector = split(teste[teste.length-2],";"); // pega a penúltima e separa num vetor
y1 = float(vector[0]);
y2 = float(vector[1]);
y1 = map(y1, 0, 1023, 0, height-tam-100); // renormaliza pelo tamanho útil da janela.
y2 = map(y2, 0, 1023, 0, height-tam-100);
}

fill( 0, 121, 184 );
ellipse( X, Y, raio, raio );
fill(255,0,0);
rect(x1,y1,-10,tam);
fill(0,0,255);
rect(x2,y2,10,tam);
X+=vx;
Y+=vy;
////////////////////////////////////
// Colisão com as raquetes
////////////////////////////////////
if(X < x1+raio/2 && (Y > y1 && Y < y1+tam)){
X-=vx;
vx*=-1.1;
}
if(X > x2-raio/2 && (Y > y2 && Y < y2+tam)){
X-=vx;
vx*=-1.1;
}
////////////////////////////////
//Fronteiras horizontais
////////////////////////////////
if(X > x2-raio/2 || X < x1-raio/2){
if(X > x2-raio/2){
p1++;
}
if(X < x1-raio/2){
p2++;
}
X = width / 2;
Y = (height-100) / 2;
vx0=-1*vx0;
vx=vx0;
vy=vy0;
fill( 0, 121, 184 );
ellipse( X, Y, raio, raio );
vx=vx0;
vy=vy0;
delay(2000);
}
/////////////////////////////////////////
// Fronteiras verticais
////////////////////////////////////////
if(Y > height-100-raio/2 || Y < raio/2){
Y-=vy;
vy*=-1;
}
/////////////////////////////////////////
// Placar
/////////////////////////////////////////
fill(0);
line(0,height-100,width,height-100);
text("Placar:",10,height-10);
fill(255,0,0);
text(p1, 350, height-10);
fill(0);
text("X",400,height-10);
fill(0,0,255);
text(p2, 450, height-10);
}


segunda-feira, 4 de julho de 2011

Resultado da segunda tarefa.

Bom, mais uma vez o Flávio Alvarenga fez o melhor trabalho. Quem será capaz de fazer um projeto melhor que ele hein? Abaixo segue o diagrama do Fritzing que ele fez e os dois códigos (Arduino + Processing):
Código Arduino


int V[3] = {6,5,3}; // 6, 5 e 3 escolhidas por serem saídas PWM, capazes de emular um sina analógico.
int PotRed = 0; // potenciometro que controla a cor vermelha
int PotGre = 1; // potenciometro que controla a cor verde
int PotBlu = 2; // potenciometro que controla a cor azul
int redVal = 0; //acumula o valor da luz vermelha
int greVal = 0; // acumula o valor da luz verde
int bluVal = 0; //acumula o valor da luz azul
void setup() {
for (int i=0; i<3; i++){ //declara os pinos 9, 6 e 3 como saída
pinMode(V[i], OUTPUT);
}
Serial.begin(9600);
}
void loop() {
redVal = (analogRead(PotRed)/4); // como o valor do potenciometro varia de 0 a 1023 dividindo o valor por 4 obtem-se valores entre 0 e 255* (Pois a variavel e um inteiro).
greVal = (analogRead(PotGre)/4); // Faz a leitura dos potenciometros e iguala ao acumulador da sua respectiva cor.
bluVal = (analogRead(PotBlu)/4);
redVal = map(redVal, 0, 1023, 0,255); //Ajusta o valor lido para ficar no intervalo [0,255]
gredVal = map(greVal, 0, 1023, 0,255);
bluVal = map(bluVal, 0, 1023, 0,255);
RGB(redVal,greVal,bluVal); // chama a função RGB
Serial.print("R");
Serial.println(analogRead(PotRed)/4); //importa para a porta Serial o valor lido na saida analogica 0 e atribui para a cor vermelha
Serial.print("G");
Serial.println(analogRead(PotGre)/4); //importa para a porta Serial o valor lido na saida analogica 1 e atribui para a cor verde
Serial.print("B");
Serial.println(analogRead(PotBlu)/4); //importa para a porta Serial o valor lido na saida analogica 2 e atribui para a cor azul
delay(100);
}
void RGB(int redVal,int greenVal, int blueVal){ // Transmite o valor lido pelo potenciometro para a porta PWM responsavel pelas cores red, green, blue.
analogWrite(V[0], redVal); // Escreve o valor do PWM do led vermelho
analogWrite(V[1], greenVal); // Escreve o valor do PWM do led verde
analogWrite(V[2], blueVal); // Escreve o valor do PWM do led azul
}


No código arduino ele definiu uma função chamada RGB() que define a cor do LED. Poderia ter feito uma função para mandar os dados para a porta serial.

Código Processing:



import processing.serial.*;
String buff = "";
int rval = 0, gval = 0, bval = 0;
int NEWLINE = 10;
Serial port;
void setup()
{
size(800, 800);
// Imprima uma lista no caso de a COM1 não funcionar
println("Portas seriais disponíveis:");
println(Serial.list());
//port = new Serial(this, "COM1", 9600);
// Use a primeira porta disponível
port = new Serial(this, Serial.list()[0], 9600);
}

void draw()
{
while (port.available() > 0) {
serialEvent(port.read());
}
background(rval, gval, bval);
}

void serialEvent(int serial)
{
// Se a variável "serial" não for igual ao valor de um caracter
// nova linha, inclua o valor à variável "buff". Se for igual,
// guarde o valor do buffer na variável "val".
if(serial != NEWLINE) {
buff += char(serial);
} else {
// O primeiro caractere diz-nos a qual cor se refere
char c = buff.charAt(0);
// Remova-o da string
buff = buff.substring(1);
// Descarte o retorno de carro ao final do buffer
buff = buff.substring(0, buff.length()-1);
// Converta a string para inteiro
if (c == 'R')
rval = Integer.parseInt(buff);
else if (c == 'G')
gval = Integer.parseInt(buff);
else if (c == 'B')
bval = Integer.parseInt(buff);
// Esvazie "buff"
buff = "";
}
}

quarta-feira, 29 de junho de 2011

ICExDuino no Youtube

Seguindo os nossos planos de expansão e dominação mundial abrimos um canal no youtube: http://www.youtube.com/ICExDuino
Avisem seus colegas, parentes e até seus inimigos.

Este é o nosso primeiro vídeo, o resultado da primeira tarefa. Quem fez este projeto foi o Daniel "Cayan" e o diferencial foi que ele adicionou um cronômetro ao semáforo. Logo mais vamos colocar o projeto deste semáforo no blog.


domingo, 26 de junho de 2011

Projeto: Usando microfone com o Arduino

Seguindo a série de projetos resolvemos estudar o CI LM386. O LM386 é um amplificador de aúdio de baixa potência. Ele é um CI com oito pinos e a função de cada pino está descrito abaixo. O funcionamento é simples, basicamente, você liga um microfone de eletreto nas portas 2 e 3 e tem o sinal amplificado na porta 5. Lembrando que na porta 2 devemos ligar o GND e na 6 o +5V do arduino.

Para aumentar a amplificação, podemos adicionar um capacitor ligando as portas 1 (+) e 8 (-). Para melhorar a qualidade do sinal, podemos adicionar alguns capacitores e resistores. Na rede há diversos circuitos que mostram como fazer a ligação com o arduino. O que achei mais simples foi esse aqui. Para seguir o padrão do nosso site, fiz o diagrama fritzing do circuito que montamos.


Os capacitores C1, C2 e C3 são capacitores de 10microF e o C4 é de 100nF. O resistor de 10K pode ser substituído por um potenciômetro, o potenciômetro funcionará como um botão de volume.

Este é o esquema para um microfone, o que nós fizemos foi montar dois circuitos iguais a esse e ligar no mesmo arduino. Um microfone foi ligado na porta analógica 0 (como mostrado no diagrama) e o outro ligamos na porta 2.






Abaixo segue o código arduino para enviar o sinal dos microfones para o computador. Enviamos uma string com os valores lido nas duas portas analógicas, separados por ";".

int A0 = 0;
int A1 = 2;
int var0, var1;
int passo=1;
void setup(){
Serial.begin(9600);
}
void loop(){
var0=var1=0;
for(int i=0; i
var0+=analogRead(0);
var1+=analogRead(2);
}
Serial.print(int(var0/passo));
Serial.print(";");
Serial.println(int(var1/passo));
}

Agora que o computador está recebendo os dados do arduino, usamos o Processing para pegar este sinal e fazer um gráfico do sinal do microfone em função do tempo.


// Importa a biblioteca de comunicação serial
import processing.serial.*;
// Cria um objeto para comunicação
Serial myPort;
float xPos = 1;
float yPos0 = 1;
float yPos1 = 1;
float dt=1;
int i=0;
float inY0, inY1;
void setup () {
// Define o tamanho da janela
size(800, 300);
//Conecta-se com o primeiro dispositivo da lista
myPort = new Serial(this, Serial.list()[0], 9600);
// Espera receber o primeiro sinal da usb
myPort.bufferUntil('\n');
// Define a cor de fundo da janela
background(255);
}
void draw () {
// Nada será feito aqui
}
void serialEvent (Serial myPort) {
// Pega a primeira linha recebida na porta serial
String inString = myPort.readStringUntil('\n');
// Se a linha não estiver em branco
if (inString != null) {
// remove os espaços em branco
inString = trim(inString);
// Divide a string num vetor separado por ;
String[] vector = split(inString,';');
// converte para int e muda os limites (map):
inY0 = map(float(vector[0]), 0, 1023, 0, 350);
inY1 = map(float(vector[1]), 0, 1023, 0, 350);
// Desenha as linhas:
stroke(255,0,0);
line(xPos,yPos0, xPos+dt, height - inY0);
yPos0=height-inY0;
stroke(0,0,0);
line(xPos,yPos1, xPos+dt, height - inY1);
yPos1=height-inY1;
// Se chegar no final da janela, volta para o início
if (xPos >= width) {
xPos = 0;
background(255);
}else {
xPos+=dt;
}
}
}




O resultado desse código é um gráfico como este abaixo.




Terceira Tarefa

A tarefa dessa semana é bem simples. Ligar um motor servo ao arduino e utilizar o computador para controlar a posição do motor.
Funções utilizadas:
  • analogRead();
  • incluir a biblioteca Servo.h;
  • map();
  • Servo.write();
A explicação de como ligar um potenciômetro ao motor servo está aqui. Na tarefa anterior tem a explicação de como interagir o arduino com o computador.

Nível 2
Conectar dois motores servos no carrinho e fazer ele descrever um quadrado e depois um oito.

sexta-feira, 24 de junho de 2011

Tutorial: Entendendos os transistores.

Existem diversos tipos de transistores: NPN, PNP, FET, MOSFET etc. Neste post vou explicar como funcionam os transistores do tipo NPN e PNP e montar uma ponte-H diferente desta.
Em termos gerais estes dois transistores funcionam como interruptores. Todos os dois possuem 3 conectores: 1-Emissor, 2-Base e 3-Coletor. Na ligação a corrente deve circular no sentido do Coletor para o Emissor. O sinal da base é que vai determinar se o circuito está fechado (passando corrento) ou aberto (sem passar corrente). No transistor NPN, o circuito fica aberto enquanto a tensão na base for 0V e fica fechado se na base houver uma tensão maior que 0V (mesmo uma tensão de mV é o suficiente para fechar o circuito). O transistor PNP funciona ao contrário do NPN (fechado se a Base for igual a 0V e aberto se for maior que 0V).
Não sou um "expert" em eletrônica, basicamente quando preciso de um transistor do tipo NPN eu compro o BC548 e quanto quero um PNP compro o BC558. A regra geral é, transistores do tipo BC54X são NPN e BC55X são PNP. O X é um número qualquer, para cada número existe uma tensão máxima de funcionamento (no caso do BC548 a tensão máxima é 20V). Existem outros detalhes mais técnicos sobre os transistores, mas chega de conversa fiada e vamos para um exemplo prático utilizando arduino. Observe o circuito abaixo:
O transistor P é um transistor PNP e N um NPN. Ao ligarmos esse circuito, o led amarelo, que está ligado ao transistor P, ficará aceso e o led verde desligado. Quando enviarmos um sinal de +5V para a porta 11 (digitalWrite(11,HIGH)) o led amarelo irá apagar e se enviarmos um sinal para a porta 3 o led verde irá acender.

Qual a diferença entre esse tal transistor e fazer a ligação diretamente na porta digital?

A resposta é bem simples, vamos supor que você tenha um motor (corrente contínua) que precise de uma tensão de 12V (como a maioria dos motores) para funcionar. Se você fizer a ligação diretamente na porta digital o motor não irá funcionar, as portas digitais só tem 5V. Então você vai precisar uma fonte externa ligada ao motor e vai querer usar o arduino para controlar o motor.
Um recurso interessante ao se ligar os motores DC é a ponte-H. Ela permite, utilizando duas portas digitais, controlar o sentido de rotação do motor. Um exemplo de ponte-H, utilizando apenas transistores NPN pode ser vista aqui. O que vou apresentar agora é uma outra ponte-H, que utiliza transistores NPN (2x) e PNP (2x).
Uma dúvida comum ao se trabalhar com motores no arduino é como fazer a alimentação do arduino. É muito comum ver alguém ligando um motor na porta digital e o motor não funcionar (principalmente motor servo). Neste diagrama, vou mostrar como devemos ligar o motor a uma fonte de energia externa.



















Aqui Q1N e Q2N são transistores do tipo NPN e Q1P e Q2P transistores do tipo PNP. Note que no diagrama não conectamos a porta +5V do arduino, pois a energia virá de uma fonte externa. Contudo, precisamos conectar o GND (ground ou terra) do arduino no GND ou Negativo da fonte externa. Isso serve para informar ao arduino uma referência.

terça-feira, 21 de junho de 2011

Resultado da primeira tarefa.



Aí está o resultado comentado da primeira tarefa. O projeto é do Flávio Alvarenga. Veja que ele ligou os 3 LEDs ao mesmo resistor.

Abaixo está o código fonte do arduino, feito pelo Leandro Bitencourt.













//Atribuindo o valor 0 ao potenciômetro, posteriormente será a porta de leitura analógica utilizada para o potenciômetro.

int pot=0;

//Iniciando a variável utilizada para controlar o tempo do delay dos leds com o potenciômetro

int val=0;

//Declarando as portas 2, 4, e 6 como "green", "yellow" e "red"

int green=4;
int yellow=5;
int red=6;

void setup(){
//O comando pinMode configura as portas digitais como entrada ou saída. Neste caso, configura-se as portas green, yellow e red como saída.

pinMode(green, OUTPUT);
pinMode(yellow, OUTPUT);
pinMode(red, OUTPUT);
}

void loop(){
//O comando analogRead lê os dados de entrada de uma porta analógica. Aqui será lida a porta pot (0), e o valor lido será atribuído à variável val.

val=analogRead(pot);
//O comando digitalWrite atribui um valor binário a uma porta digital de saída, sendo HIGH = 1 e LOW = 0. Nesse caso HIGH envia uma corrente de 5V, que acende o led conectado à porta.
digitalWrite(green, HIGH);

//O comando delay atrasa a execução do próximo comando, em milissegundos.
delay(60*val);

digitalWrite(green, LOW);
digitalWrite(yellow, HIGH);
delay(2000);
digitalWrite(yellow, LOW);
digitalWrite(red, HIGH);
delay(60*val);
digitalWrite(red, LOW);
}

Urgente! Oficina sobre lousa digital

Pessoal, amanhã (22/06) haverá uma oficina sobre a lousa digital. A oficina será as 14hs na sala 212c. O legal dessa lousa é que ela utiliza apenas um software e um controle de Wii para funcionar.

segunda-feira, 20 de junho de 2011

Projeto: Manipulando um motor DC no arduino.

Sabem aqueles motores de carrinho a pilha? Pois então, estes são os motores DC direct current ou corrente contínua em português. Basicamente é um motor que gira em apenas um sentido. Contudo, se a polaridade nos terminais é invertida a rotação ocorre no sentido oposto.
O que vamos mostrar neste projeto é uma forma de usar o arduino para controlar o sentido de rotação do motor. A idéia é construir um circuito que permita inverter o sentido da corrente, como na figura abaixo. Este circuito é conhecido como Ponte-H (H-Bridge) devido a configuração das chaves.
Veja que na figura acima o sentido da corrente é determinado através de chaves que abrem ou fecham o circuito. Para fazer esse chaveamento iremos utilizar quatro transistores do tipo NPN (BC547). Esse transistor funciona mais ou menos como um interruptor. Ele é composto de 3 pinos (1-Emissor, 2-Base e 3-Coletor) como mostrado na figura ao lado. A "grosso modo" a conexão entre os terminais 1 e 3 é feita se e somente se for aplicada uma tensão no terminal 2.
Para montar uma ponte-H com este transistor são necessários:
  • 4x transistores NPN BC547 (pode-se utilizar outro transistor NPN);
  • 2x resistores de 10kOhms;
  • 2x LEDs;
  • Motor DC;
  • Fios.
O diagrama abaixo mostra como deve ser montado o circuito na protoboard. Repare que os dois LEDs estão ligados com polaridade invertidas, eles funcionam como indicadores do sentido de rotação do motor e podem ser retirados do projeto.
Não fiz a conexão no arduino para poupar espaço. Essa montagem permite que as portas PWMs sejam utilizadas para controlar a velocidade do motor. O código que faz o motor rotacionar nos dois sentidos está descrito abaixo.




int D0=10; //Porta que comando o sentido horario
int D1=6; //Porta que comanda o sentido anti-horario

void setup(){
pinMode(D0,OUTPUT);
pinMode(D1,OUTPUT);
}
void loop(){
//Gira no sentido horario
digitalWrite(D0,HIGH);
delay(2000);
// Para de Girar
digitalWrite(D0,LOW);
delay(2000);
//Gira no sentido anti-horario
digitalWrite(D1,HIGH);
delay(2000);
// Para de Girar
digitalWrite(D1,LOW);
delay(2000);
}

Futuramente iremos falar sobre o L293D, um circuito integrado que tem a mesma função da ponte-H e permite controlar mais de um motor.


domingo, 19 de junho de 2011

Concurso: Logotipo do IcexDuino

Estão abertas as inscrições para o concurso do logotipo e mascote do grupo IcexDuino.
As inscrições são individuais e cada candidato poderá concorrer com mais de uma proposta.
Ambas as propostas, logotipo e mascote, deverão ser originais.
Os desenhos deverão ser enviados para o email do Daniel Girardi (girardi1309@gmail.com) até o dia 30 de julho de 2011.
O vencedor ganhará um kit básico de arduino duemilanove.
TODOS os alunos, funcionários e professores do Icex poderão participar do concurso.

Dúvidas, críticas e sugestões poderão ser feitas respondendo este anúncio aqui no blog do icexduino.

Boa sorte a todos.

sábado, 18 de junho de 2011

Indicação de site.

Pessoal,
Neste site, Jeremy Blum, um estudante da universidade de Cornell tem colocado diversos tutoriais sobre arduino (em inglês). O que tem de especial nesses tutoriais? Não sei, só sei que o o pessoal do blog oficial do arduino elogiou bastante e comentou no blog. Vale a pena dar uma conferida.

sexta-feira, 17 de junho de 2011

Uso do Material do Laboratório

Olá Pessoal,

Quero escrever umas poucas linhas sobre o uso do material do laboratório.

Em primeiro lugar, já comentado antes, é o usar e guardar após o uso.
Vai ser interessante para cada um de nós poder encontrar facilmente o material que procura, já que cada coisa estará em seu lugar.

Em segundo lugar, use sem medo de ser feliz!! Não deixe de montar um experimento com o receio de que poderá dar errado e por conta disso estragar algo, queimar uma peça etc! Arriscar faz parte do processo de aprendizado.
Entretanto, é bom adquirir o hábito de pesquisar os manuais dos compontentes, buscar exemplos de como usá-los etc. A internet está cheia disso. ;)

Por último, a boa notícia de que estamos aguardando a chegada de mais material, arduinos, fios, peças etc, que deverá ocorrer em até um mês.
Acho que teremos, em média, um arduino para cada dois membros do grupo.

Abraços a todos e façam os experimentos!

Aquino

Sincronizando arquivos.

Vi que muita gente está carregando seus trabalhos em pendrives. Uma boa solução para ter a sincronia entre os documentos do seu micro privado e o do laboratório é o DROPBOX. Basicamente o dropbox é um serviço de back-up na nuvem.
Ao se cadastrar e instalar o programa no seu micro ele irá criar uma pasta chamada Dropbox. Tudo que você colocar dentro dessa pasta ele irá copiar o arquivo para um servidor na rede (o tamanho máximo da pasta é 2Gb). Sempre que você alterar/deletar um arquivo ele faz o mesmo no servidor. A idéia é vocês instalarem no micro da casa de vocês e no micro do laboratório (já está instalado, apenas configure a sua conta). Assim, tudo que vocês fizerem em casa ou no laboratório estará sincronizado via Dropbox. Podem dar adeus as suas pendrives.
O Dropbox funciona com qualquer sistema operacional, inclusive sistemas móveis (celulares) e possui um sistema via browser que você pode pegar pela internet um arquivo específico em qualquer micro que não tenha o programa instalado. Se você fizer a sua conta pelo link postado acima, você ganha 250Mb de espaço adicionais.

Apostila

O Thadeu me mandou essa apostila e estou disponibilizando aqui para todos. O autor da apostila é o Álvaro Justen, aluno do curso de Engenharia de Telecomunicações da UFF/Niterói. A apostila é bem didática, vale a pena ler (vale a pena ler = os alunos de IC tem que ler).
Se houver interesse, podemos organizar um mini-curso baseado nessa apostila. A ideia é que o curso seja dois dias a noite ou nas manhãs de sábado. Quem tiver interesse, deixe um comentário dizendo se prefere a noite ou no sábado pela manhã.

quinta-feira, 16 de junho de 2011

Segunda Tarefa

Agora vamos aprender a nos comunicar com o computador e usar os valores lidos pelo arduino para controlar a cor de um LED RGB e a cor de fundo de uma janela no computador.
Nesse projeto haverão 3 potenciômetro, um para cor vermelha (R), verde (G) e azul (B). A posição de cada potenciômetro irá determinar a intensidade de cada cor e a soma de cada uma será a cor final que será mostrada no LED e no monitor.

Funções utilizadas:
  • Serial.begin();
  • Serial.println();
  • Serial.print();
  • analogRead();
  • map();
  • ** Um código PROCESSING **
Passo-a-Passo:
  1. Controlar as cores do LED RGB (exemplo aqui);
  2. Ligar os 3 potenciômetros (veja a tarefa anterior);
  3. Usar a comunicação serial para integrar o valor dos potenciômetros com o programa processing (exemplo aqui).

Segunda Tarefa (Nível 2):

Agora as tarefas serão acompanhadas de dois ou mais níveis. O primeiro é para todos fazerem, o segundo é só para quem é bom (Isso é uma provocação, vão deixar barato?)!

Fazer o controle inverso, fazer um programa em processing que você controla a cor do LED através do computador. Um exemplo inicial está aqui.


Não esqueça de documentar (diagrama Fritzing e código) o seu trabalho.

Primeira Tarefa

A primeira tarefa é criar um semáforo em que o tempo de alternância entre o vermelho e o verde é definido por um potenciômetro. A luz amarela fica acesa por 2 segundos.

Para realizar esta tarefa será necessário usar algumas funções básicas do arduino:
  • pinMode();
  • digitalWrite();
  • analogRead();
  • delay();
Vamos dividir a tarefa em três partes:
  1. Fazer um LED acender e apagar (exemplo aqui), repetir isso para as 3 cores do semáforo;
  2. Usar um potenciômetro para controlar o tempo do LED aceso (exemplo aqui);
  3. Juntar o que foi aprendido nos itens 1 e 2 para fazer o semáforo.
Use o programa Fritzing para fazer o diagrama da montagem do circuito. Para fixar o aprendizado, escreva um parágrafo explicando cada uma das 4 funções utilizadas. A melhor solução será colocada no site com créditos para o autor.

Para quem estiver muito, muito perdido, aqui está o site (em português) do arduino com várias informações importantes: AQUI!

Apresentação.

Olá Todos,

Esse é o blog que o grupo de arduino do Instituto de Ciências Exatas - ICEx da UFF usará para se comunicar e passar as informações das atividades do grupo. O que você vai encontrar nesse blog é:
  • Tutoriais - Nesta seção iremos postar as tarefas e os manuais para estudo e realização das tarefas;
  • Notícias - Diversas notícias sobre o grupo e o mundo do arduino;
  • Projetos - Vamos colocar os diferentes projetos que estão sendo realizados em paralelo;
  • Avisos - Quadro de avisos gerais (reuniões).
Logo mais irei "voluntariar" alguns alunos para ajudar a alimentar o blog.