sábado, 25 de fevereiro de 2012

Potenciômetro - Leitura Analógica

Arduino by my Self

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);


Agora vamos mostrar como fazer a leitura de um componente analógico, ou seja que gera um sinal de saída usando toda a gama de valores entre 0 e 5V.
Para isto utilizaremos um potenciômetro como sensor.  O potenciômetro é um componente mecânico, que de acordo com uma variação angular em seu eixo central, varia sua resistência de saída de um 0 a um MÁX; quando conectado a uma fonte de tensão, significa que em seu terminal de saída, podemos então ler uma tensão proporcional a essa variação angular.





O Hardware:

1 x Placa Arduino UNO;
1 x Potenciômetro de 10KO;
Fios

O Circuito:
Imagem gerada usando Fritzing, veja o site oficial para download e tutoriais.
http://fritzing.org/

Usando a breadboard:
Conecte o terminal direito do potenciômetro ao positivo da alimentação;
Conecte o terminal esquerdo do potenciômetro ao negativo da alimentação;
Conecte o terminal central do potenciômetro à entrada analógica 0 do Arduino.



Internamente o Arduino tem um conversor analógico-digital, capaz de converter sinais que podem variar de 0 a 5 volts em um sinal digital de 10 bits variando de 0 a 1023.
Quando o cursor estiver girado todo em sentido ao 0V, isso significa valor 0; e quando o cursor estiver girado todo em sentido ao 5V, isso significa 1023; valores intermediários devem ser mapeados, para poderem ser exibidos....
A função utilizada para a leitura dos dados é:

analogRead(A0);

Que retornará um número proporcional a quantidade lida (entre 0 e 1023)
Sendo A0 o pino analógico de onde será lido o sinal.



O Código:

Abaixo o código completo e os comentários;


/*
  AnalogReadSerial
Lê uma entrada analógica 0, envia e mostra os resultados no monitor serial

Este código exemplo é de domínio público
 */


//inicialização do Arduino
void setup() {
  Serial.begin(9600);                                   //inicializa a comunicação serial USB com oPC
}


//Iteração principal do programa
void loop() {
  int sensorValue = analogRead(0);          //faz a leitura da porta analógica A0 e guarda o valor na variável
                                                                 //"sensorValue" de tipo inteiro.
  Serial.println(sensorValue, DEC);            //envia os dados da variável "sensorValue" para a porta de 
                                                                //comunicação serial em notação decimal.
} //Fim da Compilação

Consulte o site do Arduino para maiores informações: http://arduino.cc/en/Tutorial/AnalogReadSerial

Vídeos:





Conclusão:
Esta experiência também nível básico não teve maiores problemas.



Debouncing

Arduino by my Self

"BOUNCE"

Por definição, quando apertamos um botão, o qual possui um contato mecânico, é gerada uma série de ruidos aleatórios chamados de spikes. Ou seja, a tensão instantânea sobre o botão pode ser qualquer valor, entre os valores que seriam obtidos com o botão em repouso e com o botão ligado após um tempo longo.

Isto pode ser observado com um osciloscópio digital.



A duração desses spikes é pequena, geralmente na ordem de milisegundos, mas o efeito prático é o de que durante esses poucos milissegundos, uma leitura efetuada nesse botão pode interpretar que ele está ligado ou desligado, devido aos ruidos aleatórios que são gerados pelo contato mecânico.



Porém, para um microprocessador, alguns milissegundos são uma eternidade, ou seja, por exemplo, após detectar que o botão foi acionado, mediante UMA ÚNICA LEITURA DO BOTÃO, nosso programa pode executar as funções correspondentes e voltar ao mesmo ponto anterior da leitura do botão, EM MENOS DE 1 milissegundo !!!!

Assim, o efeito que temos é que em vez de o nosso programa interpretar que apertamos o botão APENAS 1 VEZ, ele pode acabar interpretando que apertamos o botão mais de 20 vezes em seguida !!!!!

Claro que dependendo do programa, o resultado pode ser catastrófico !

Na verdade, o termo "DEBOUNCING" significa uma técnica que nos dê certeza de que o botão apertado apenas uma vez seja interpretado corretamente como apenas UM aperto de botão.

Por outro lado, se apertarmos o mesmo botão por 5 vezes seguidas em um segundo, o nosso programa tem de conseguir ler corretamente 5 apertos de botão !


Quando trabalhando com Interrupções, não devemos colocar delay nas rotinas de tratamento das interrupções.  Então como podemos nos adequar a esta situação?

Fazendo o "debouncing" de Hardware;

Antes:

Depois:

Aqui temos um circuito RC,o que gera uma constante de tempo data por T=R*C
com R em KO
C em uF
e T em segundos(s)
Assim, quando pressionado o botão, o sinal leva alguns milisegundos para estabilizar em um valor lógico e aí o processador pode identificar corretamente se o botão foi apertado ou não......
Porém temos o problema de delay, o tempo para o circuito reconhecer o sinal.



Valores típicos:
R = 10KO
C = 10uF
T = .1s





Para Solucionar o problemas encontrado com circuitos puramente RC, devemos colocar um Inversor Shimitt Trigger para eliminar esse tempo extranecessário  para reconhecimento de estádo lógico.
O circuito ao lado Simplismente gera uma onda quadrada na saída, não dependendo de tempo de pressionamento do botão.

Ideal para usar com microprocessadores rápidos.





Quando não temos problemas com Interrupções ou delay, podemos usar o "Debouncing" por software (ou simplesmente os dois em conjunto).
Abaixo um exemplo de código para este "Debouncing".



int switchPin = 2;
int ledPin = 13;
boolean lastButton = LOW;     //variável representando o último estado do botão
boolean ledOn = false;    //variável representando o estado do LED


void setup()
{
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}


void loop()
{
  Serial.println(digitalRead(switchPin));
  if (digitalRead(switchPin) == HIGH && lastButton == LOW)
    {    //se último estado do botão éra "baixo" e a leitura atual do botão indica "alto"
       ledOn = !ledOn;            //inverte estado do LED
       lastButton = HIGH;       //coloca último estado do botão como "alto"
    }
    else  //caso contrário:
    {
       //lastButton = LOW;                                 //coloca último estado do botão como "baixo"
       lastButton = digitalRead(switchPin);          //coloca o valor atual do botão na variável de último estado do                           botão
    }
  
    digitalWrite(ledPin, ledOn);    //escreve o valor de estado do LED no pino referente


}



Um programinha simples mas muito eficaz.

Visite: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1244509204/6 para informações sobre como fazer o "Debouncing" de um reed Switch.

http://www.arduino.cc/playground/Code/Bounce para informações sobre a biblioteca "Debounce"


Bom espero que este pequeno tutorial, possa ajudar com o problema de "Bounce" referente ao tratamento de informações provenientes de botões .


Até o próximo Post!

sexta-feira, 24 de fevereiro de 2012

Trabalhando com Botões

Arduino by my Self

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Esta experiência, têm como objetivo, mostrar o uso e como fazer a leitura de dados provenientes de botões.Ou seja:
Os modos de ligação de um botão no Arduino; como identificar se um botão foi pressionado; como usar essa informação para interagir em seu programa.
Vamos também aprender como monitorar a informação através da comunicação USB entre o Arduino e o computador, ou seja, fazer a leitura do botão e mostrar no PC os dados obtidos.

O Hardware Requerido:

Uma placa Arduino UNO, ou equivalente;
Um botão de contato momentâneo, o chamado "botão datilar";
Um Resistor de 10K ohm;
Uma Matriz de Contatos "Breadboard";
Fios.

O circuito:
Circuito 1: Caso o botão esteja pressionado, o pino de controle do Arduino terá nível baixo;
                 Caso o botão não esteja pressionado, o pino de controle do Arduino terá nível alto.


Ligar uma ponta do Botão ao negativo da alimentação, a outra ponta a um resistor de 10K ohm; o outro terminal do resistor, ligar ao positivo da alimentação.  O pino 2 de controle no Arduino deve ser ligado no terminal de junção do botão com o resistor.


Circuito 2: Caso o botão esteja pressionado, o pino de controle do Arduino terá nível alto;
                 Caso o botão não esteja pressionado, o pino de controle do Arduino terá nível baixo.




Ligar uma ponta do Botão ao positivo da alimentação, a outra ponta a um resistor de 10K ohm; o outro terminal do resistor, ligar ao negativo da alimentação.  O pino 2 de controle no Arduino deve ser ligado no terminal de junção do botão com o resistor.


O Código:

Primeiramente, deve-se inicializar a comunicação serial a 9600 bps, entre o arduino e computador;

Serial.begin(9600);

Em seguida inicialize o pino 2 do Arduino, que fará a leitura da informação do botão, como sendo um pino de entrada de informação.

pinMode(2, INPUT);

Este é um pino digital e irá variar de 0V (LOW) a 5V (HIGH) somente, sem nenhum estado intermediário.
A leitura no programa será então "0" ou "1", "Desligado" ou "Ligado", "não Pressionado" ou "Pressionado", etc...

Definir uma variável para conter o valor lido no botão.  Efetuando a leitura digital deste botão que foi definido no pino 2.

int sensorValue = digitalRead(2);

Uma vez lido e armazenado o valor, é possível enviar esse dado para a porta serial e imprimir no PC (em decimal).

Serial.println(sensorValue, DEC);

Agora sim vejamos o código completo:



Conclusão:
Nenhuma dificuldade com esta experiência de nível básico
Como observação vale lembrar que existe o problema de instabilidade no pressionamento de botões, ou seja, quando pressionado e tem um período de variação de transições entre "0" e "1" (o chamado "Bouncing", que ocorre durante um pequeno intervalo de tempo antes de estabilizar) um ruído que pode fazer o Arduino entender errado um pressionamento do botão ou entender que o botão foi pressionado mais de uma vez quando não o foi.



O "Debouncing" pode ser feito por hardware, colocando-se um capacitor em paralelo com o botão, ou pode ser feito por software, esperando 20 ms depois de pressionado o botão para certificar que o botão foi realmente pressionado e passar o período de transições "Bouncing".



...

if(botao = 1)
 {
   delay(20);
     if(botão = 1)
       {
          // Rotina para botão acionado.
        }
    else if(botão = 1)
        {
          // não esperou tempo suficiente
         }
  }

...


Isto tudo será estudado mais detalhadamente em um outro post.




Vídeo:

Agora, vejamos o vídeo desta experiência.



Visite, para maiores informações:

http://arduino.cc/en/Tutorial/DigitalReadSerial




Até o próximo Post.

sábado, 18 de fevereiro de 2012

Primeiro Teste com o LED Blink

Arduino by my Self

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);




No primeiro teste, não foi encontrada nenhuma dificuldade, fazer um LED piscar a aprtir do ARDUINO é muito simples; alguns comandinhos e o LED está piscando no pino desejado e com a "velocidade" (temporização) desejada.

Fiz uma pequena modificação no código original para que o mesmo fique mais dinâmico (as vezes você quer mudar rapidamente de pino ou de "velocidade", e o código original, apesar de pequeno, não permite isto; uma vez que você tem que mudar o pino ou o tempo diretamente no código em alguns lugares), quanto mais referência ao pino e ao tempo desejado, mais linhas tem que ser editada.  Com a mudança feita, você pode editar em um único lugar, uma única vez.

Visite; http://arduino.cc/en/Tutorial/Blink, para maiores informações.

Veja abaixo o código original e o modificado.

ORIGINAL:

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
 */


void setup() {                
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode(13, OUTPUT);     
}


void loop() {
  digitalWrite(13, HIGH);   // set the LED on
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // set the LED off
  delay(1000);              // wait for a second
}


MODIFICADO:

/*
##################################################################################
#   Arquivo:                     Blink.pde
#   Micro-processador:   Arduino UNO
#   Linguagem:                Wiring / C
#                                           
# Objetivo:                   Rotina para Piscar um LED         
#     
# Funcionamento:           Usa pino digital do Arduino para piscar um LED          
#                                   Liga o LED por um tempo, e então desliga por um tempo 
#                                   O tempo deverá ser deteminado por linha de código       
#
#   Autor:              Marcelo Moraes  
#   Data:               18/02/12     
#   Local:              Sorocaba - SP
#     
##################################################################################

  Este exemplo é um código de domínio público.
 */


 // Definição de variáveis.
 int ledPin = 13; // define o pino onde será ligado o LED.
 int Tempo = 1000; // define o tempo em que o LED permenecerá aceso/apagado.


// Esta parte do programa executa uma vez só, na inicialização do Arduino.
void setup() {                
  // inicializar o pino digital
  // que tem o LED conectado no Arduino, como saída.
  pinMode(ledPin, OUTPUT); //     
}


// Esta parte do programa executa repetidamente.
void loop() {
  digitalWrite(ledPin, HIGH);   // seta o LED para on (ligado)
  delay(Tempo);              // espera por um tempo
  digitalWrite(ledPin, LOW);    // seta o LED para off (desligado)
  delay(Tempo);              // espera por um tempo
}


// Fim da compilação.


A execução do circuito foi feita na breadboard, foi usado, 1 x resistor de 220 ohms, 1 x LED 3mm Amarelo e fios para conexão.



Veja abaixo o vídeo com o resultado.




Este pequeno exemplo usa a função "delay()" para gerar uma temporização em milisegundos, porém há uma outro maneira de se obter o mesmo resultado, usando uma outra função chamada "milis()".
Porém o código fica um pouco mais complicado.


Visite: http://arduino.cc/en/Tutorial/BlinkWithoutDelay, para maiores informações.

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Até a próxima experiência!
-->

quinta-feira, 9 de fevereiro de 2012

Arduino "O Início"

Arduino by my Self

Finalmente chegou a minha encomenda.

O Arduino UNO Crazy Kit...

Feito o desempacotamento e o primeiro teste.  Tudo funcionando perfeitamente.!


Vamos a alguns detalhes, vejam as figuras abaixo:

O Pacote
Este meu primeiro modelo, decidi comprar da China mesmo, devido a minha falta de experiência e do fator custo.
Este Kit custou $86, e vem com muitos componentes importantes, que aqui no Brasil certamente custariam muito mais do que isso.
Hoje a China tem uma grande participação e relação comercial com o Brasil, o que torna mais confiável efetuar a compra de um produto.
Relacionado à qualidade!?
O Arduino é um hardware "open-source", o que facilita muito a qualquer fabricante a produção de placas fiéis as originais (devido ao próprio avanço tecnológico), ou pelo menos com uma grande qualidade (padronizações e controle de qualidade),.... então não me parece um inconveniente comprar este produto "não original".

Se eu tiver algum problemas com este produto irei postar para que outras pessoas possam ter orientação.

Pacote já aberto o conteúdo
Como  podem ver o produto vem acondicionado em sacos anti-estática e envolto com uma grande quantidade de plástico bolha (não aparece nas fotos) para evitar problemas durante o transporte.

Conteúdo devidamente acondicionado
Acondicionei o conteúdo num organizador (desses para costua, bijouterias, trabalhos manuais, coleções, etc...), pretendo colocar aí mais componentes exclusivos para o uso com as experiências com o Arduino, tais como:
LEDs, resistores, capacitores, LDR, Transistores, motores, servo-motores, displays,
Receptores e Transmissores infra-vermelho, sensor ultra-sônico, módulos de TX/RX de RF, sensores de umidade, temperatura, presença, movimento, etc..

Num futuro próximo, devo comprar mais componentes e alguns Shields (Ethernet, Bluetooth, Xbee, GPS,... etc...), aí deverei obter um organizador maior e melhor.



Fiz o download e instalei a IDE do Arduino, versão 1.0;  disponível no site www.arduino.cc
Este site deve ser usado como referência para o Arduino.

Descomprimi o arquivo no meu Desktop.

Fiz também o primeiro teste da plaquinha do Arduino.


Visite também outros sites interessantes:
Wiring - http://wiring.org.co/ - é um ambiente para programação de microcontroladores (open-source, envolvendo Hardware e software (assim como o Arduino, do qual ele foi baseado; programação C e Wiring)
Fritizing - http://fritzing.org/ - é uma iniciativa open-source para apoiar designers, artistas, pesquisadores e entusiastas para trabalhar criativamente com eletrônicos interativos.
Processing - http://processing.org/ - é uma linguagem de programação open source e meio ambiente para as pessoas que querem criar imagens, animações e interações. Inicialmente desenvolvido para servir como um caderno de desenho de software e para ensinar os fundamentos da programação de computadores dentro de um contexto visual,



Particularidades

Durante a conexão do Arduino com o computador, foi necessário instalar o driver de comunicação;
Como já é sabido, acontece um erro na instalação (o sistema não reconhece o Arduino como um hardware plug and play) assim foi necessário fazer a instalação manual do driver (o driver encontra na pasta do software da IDE do Arduino, na caminho: C:\Users\<seu usuário>\Desktop\arduino-1.0\drivers).

Ao abrir a IDE, localizar o sketch do Blink LED, e enviar para o Arduino;
Não esqueça de selecionar no menu  "Tools", o tipo de placa do Arduino UNO e a porta USB onde ele está plugado para a comunicação.

Sketch exemplo usado para primeiro teste do Arduino UNO
Seleção do tipo de Placa Arduino

Seleção da porta USB de comunicação

Veja o vídeo abaixo para maiores informações.




..... o vídeo será postado em breve!