V - Escola Brasileira de Ensino de Física

V - Escola Brasileira de Ensino de Física

Casa Nova

Como estou me mudando de Volta Redonda/RJ (UFF) para Blumenau/SC (UFSC), eu vou criar um novo blog:  TeachDuino . Estou começando um novo projeto, baseado em Arduino, e vou documentar tudo que estou fazendo nesse novo blog. 

O que começou como uma brincadeira agora ficou sério. Nesse novo site eu estou desenvolvendo um framework para experiências de física, química, biologia, matemática e robótica. Para sentir um gostinho do que está por vir, deixo aqui para vocês o screenshot do primeiro programa que eu desenvolvi para a coleta de dados e gráficos. 

O próximo será uma adaptação do Ardublock para experiências de Física.

Fazendo gráficos com os dados do Arduino

É comum ver pessoas querendo fazer gráficos com as informações obtidas pelo Arduino. Quando fizemos o pHmetro, algumas pessoas gostaram do gráfico do pH que era mostrado no computador durante a experiência. Vejo muitos artigos explicando como fazer isso através do Processing e do Python, mas todos eles tem suas especificidades e exigem algumas modificações que nem sempre são simples.
Seus problemas acabaram! Com o super programa...
Para facilitar a vida de todos, criamos um programa/script em Python que, de forma simples, permite qualquer pessoa fazer gráficos sem precisar saber programar nada. A única coisa que você precisa é ter instalado o Python (>2.6), a biblioteca Matplotlib e fazer o download do nosso programa CLICANDO AQUI.

Como usar o programa:
Para quem usa Linux é simples, basta abrir um terminal e dar o comando "python grafico.py". O programa vai perguntar em qual porta o Arduino está conectado, tipicamente é a porta 0 (zero). Depois de informar a porta o programa fica esperando os dados chegarem do Arduino. O programa pode mostrar o gráfico deixo o eixo X "fixo" ou movendo o eixo X junto com os dados. No modo "fixo" o eixo X começa em X=0 e vai aumentando o X final conforme os dados vão chegando. No outro modo ele modifica o X inicial e final de forma que a diferença (DX) seja constante. Para alternar entre os modos, você precisa abrir o programa em um editor de texto e modificar a primeira linha do programa. Se você usar DX=0 o programa roda em modo fixo e se DX for diferente de 0 ele vai ajustar o X inicial e final conforme os dados forem sendo recebidos.  O programa aceita até 6 gráficos simultâneos.

Como enviar os dados do Arduino para o programa:
A comunicação entre o programa e o Arduino é feita por comunicação serial. Você deve usar o comando Serial.print() e Serial.println() para enviar seus dados do Arduino. Os dados devem estar formatados da seguinte forma:gráfico; valor em x; valor em y , onde "gráfico" é o número do gráfico que você enviar os dados (o programa aceita fazer até 6 gráficos simultaneamente). Note que os dados são separados por ponto e vírgula. Abaixo temos um código que envia os valores das portas analógicas 0 e 1 como o dado em Y e o tempo como o dado em X.

void setup(){

  Serial.begin(9600);

}

void loop(){

  Serial.print('1');

  Serial.print(";");

  Serial.print(millis());

  Serial.print(";");

  Serial.print(analogRead(0));

  Serial.println("");

  delay(50);

  Serial.print('2');

  Serial.print(";");

  Serial.print(millis());

  Serial.print(";");

  Serial.print(analogRead(1));

  Serial.println("");

  delay(50);

}

 Usando o Ardublock:

ICExduino contribuindo na comunidade Open Source

O Daniel Girardi está ajudando a desenvolver o projeto Ardublock. Este projeto consiste da criação de uma interface de programação (IDE) para o Arduino, voltada para não programadores (crianças e adultos). A IDE usa uma estrutura de blocos, onde você simplesmente arrasta blocos de instruções que vão se conectando para formar o código do Arduino. Abaixo há dois exemplos clássicos, o primeiro é o código para piscar um LED e o segundo é um código para controlar o brilho do LED através do potenciômetro.

Pisca o Led a cada 1 segundo.

Controla a intensidade do brilho do LED através de um potenciômetro.

Veja como a programação é muito mais simples e intuitiva. O projeto está sob a licença GNU-GPL que permite que qualquer pessoa pode copiar, distribuir e modificar livremente. O código fonte do projeto pode ser baixado em https://github.com/danielfsc/ardublock e o código fonte original pode ser baixado em https://github.com/taweili/ardublock .

Para quem quiser apenas utilizar o Ardublock, pode baixar o programa AQUI - ardublock-all.jar. O processo de instalação é o mesmo para qualquer sistema operacional:

1. Abra o Arduino e vá em File > Preferences;
2. Na janela que abrir, localize a informação "Sketchbook location:";
3. Abra o navegador de arquivos e dentro da pasta que está indicada em "Sketchbook location:" crie as seguintes pastas: tools>ArduBlockTool>tool;
4. Dentro da pasta "tool" (a última pasta da árvore) salve o arquivo ardublock-all.jar;
5. Agora é só fechar e abrir novamente o arduino. Para acessar o Ardublock, há um link na aba Tools.

Onde fica o atalho para abrir o Ardublock.

 O Ardublock é completamente integrado a interface do Arduino. Ao clicar em "Enviar" ele converte a estrutura de blocos para a linguagem Wire (a linguagem de programação do Arduino), coloca o código no programa do Arduino e faz o Upload para a placa Arduino. A única coisa que o Ardublock faz é traduzir a estrutura de blocos para Wire, portanto, as configurações de "Board" e "Serial Port" precisam ser feitas no próprio Arduino.

A vantagem do Ardublock frente as outras IDEs no formato de bloco, é que ela é de código aberto e gratuita. Além disso, ela permite que você veja o código em Wire, nenhum outro software permite isso. Para finalizar, deixo mais um código feito no Ardublock, esse é para o brilho do LED ir aumentando gradativamente.

Um programa para aumentar o brilho do LED gradativamente.

CLIQUE AQUI PARA BAIXAR!

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.

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.

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

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/

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);
}



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 = "";
}
}

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.

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.

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.

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.

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.

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.

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.

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