Arduino - Sistema de Segurança, Controle de Acesso

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

Este projeto têm como objetivo, mostrar um uso prático do Arduino.

Um sistema de segurança para fazer o controle de acesso, por exemplo, da entrada de pessoas a um determinado ambiente seguro.

O sistema consta de um teclado para a entrada de uma senha, e um display LCD para visualizar mensagens.

A simulação é feita com LEDs, porém facilmente implementado para relés ou solenóides.

Como funciona:

Ao iniciar o sistema, um LED vermelho indica que o sistema está pronto, e neste caso não adianta digitar números no teclado, pois os mesmos não será processados; a não ser a tecla "#", que indicará ao sistema que alguém irá digitar uma senha.

Ao digitar "#"o sistema libera o teclado para a entrada da senha, e um LED amarelo sinaliza esta funcionalidade, bem como, será mostrado uma mensagem no display informar ao usuário que é necessário digitar a senha.

Digitando números no teclado (para cada um será emitido uma sinalização acústica), o sistema processará os dados.  

Se a quantidade de números digitar for igual a 4 e corresponder exatamente a senha do sistema, então será habilitato o relé ou o solenóide de acionamento (indicado por um LED verde, que irá piscar por cerca de 5 segundos, e o sistema estará liberado; durante esse período um som será emitido para sinalização; uma mensagem será mostrada no display, para informar ao usuário que o acesso foi liberado).

Se a quantidade de números digitados for 4 e não corresponder a senha esperado para o sistema, então o sistema não será liberado e voltará ao estado inicial.  O mesmo acontece se for pressionado a tecla "#" novamente.

O HARDWARE:

1 x Arduino UNO

1 x Teclado numérico 3x4

1 x Display LCD 2x16 I2C

1 x Buzzer

1 x Breadboard

4 x Resistores de 220O 1/8W

1 x LED verde 3mm

1 x LED Amarelo 3mm

1 x LED Vermelho 3mm

Fios e cabos para conexões

O CIRCUITO:

Utilize a breadboard para fazer as ligações:

Mini BreadBoard

BreadBoard

Para cada LED associar um resistor de 220O em série conectado ao terminal Anodo e o terminal catodo ligado diretamente ao negativo da alimentação. O outro terminal do resistor vai ligado ao Arduino, conforme abaixo:

Para o LED verde, terminal do resistor ligado ao pino 10  

Para o LED amarelo, terminal do resistor ligado ao pino 11

Para o LED vermelho, terminal do resistor ligado ao pino 12

Para o Buzzer, associar um resistor de 220O ao teminal positivo, sendo o terminal negativo do mesmo, ligado ao negativo da alimentação.  O outro terminal do resistor deve ser ligado ao pino 9 do Arduino.

Tipos variados de Buzzers

Buzzer soldável em placa

O teclado deve ser ligado da seguinte maneira:

Linha 1, ligada ao pino 5 do Arduino

Linha 2, ligada ao pino 4 do Arduino

Linha 3, ligada ao pino 3 do Arduino

Linha 4, ligada ao pino 2 do Arduino

Coluna 1, ligada ao pino 6 do Arduino

Coluna 2, ligada ao pino 7 do Arduino

Coluna 3, ligada ao pino 8 do Arduino

Detalhe da conexão flexível linhas x colunas

Teclado 4x3 flexível

Display I2C

Ligar o Vcc do dispositivo ao positivo da alimentação

Ligar o GND do dispositivo ao negativo da alimentação

Ligar o SDA do dispositivo ao pino A4 (analógico 4) do Arduino

Ligar o SCL do dispositivo ao pino A5 (analógico 5) do Arduino

Detalhe do adaptador I2C

Display I2C com BackLight azul e caracteres brancos

Diagrama:

Diagrama em fritzing

O Display LCD utilizado é um display I2C.

O SOFTWARE:

Abaixo o Software utilizado, com todos os comentários necessários (veja também o vídeo).

Este projeto foi baseado no projeto do Marcelo Rocha

http://www.fisicarduino.com/index.php/projetos/5-keypad-teclado-matricial-controle-de-acesso-com-arduino

Algumas modificações foram feitas para adequação somente.

Procurei deixar bem explicado, para que outras pessoas possam reproduzir com sucesso o experimento.

A versão 2 é ainda básica, somente para os primeiros passos, mais adiante versões mais completas.

/*

#################################################################################

#   Arquivo:            Tranca_Eletronica_v2.pde                                             

#       Micro-processador:  Arduino UNO         

#   Linguagem:    Wiring / C /Processing /Fritzing / Arduino IDE          

#

# Objetivo:           Tranca Eletrônica para controlede acesso

#  

# Funcionamento:    Ao pressionar #, libera para ser digitado a senha;

#                           se a senha estiver errada, volta ao estado inicial;

#                           Se a senha estiver correta, libera a porta;

#                           Simulação através de LEDs, porém adaptável a relés e travas

#                           Tons audíveis para orientação

#                           Display com as mensagens

#

#   Autor:              Marcelo Moraes 

#   Data:               20/02/12

#   Local:              Sorocaba - SP

#

#################################################################################

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

 */

//Bibliotecas 

#include <Wire.h>

#include <LiquidCrystal_I2C.h>        //Esta biblioteca tem 2 versões uma está apropriada para o IDEv1.0

#include <Keypad.h>

//Inicialização do Display I2C

LiquidCrystal_I2C lcd(0x27,16,2);

int count = 0;                                              //Contador de uso geral

char pass [4] = {'1', '9', '7', '1'};                 //Senha

const int yellowPin = 11;                             //Definição do pino do LED Amarelo

const int redPin = 12;                                 //Definição do pino do LED Vermelho

const int greenPin = 10;                              //Definição do pino do LED Verde

const int audioPin = 9;                                //Definição do pino do Buzzer

const int duration = 200;                             //Duração das sons tocados

const byte ROWS = 4;                              //Quatro linhas

const byte COLS = 3;                               //Três colunas

//Mapeamento de teclas

char keys[ROWS][COLS] = {

  {'1','2','3'},

  {'4','5','6'},

  {'7','8','9'},

  {'*','0','#'}

};

byte rowPins[ROWS] = {5, 4, 3, 2};                    //Definição de pinos das linhas

byte colPins[COLS] = {6, 7, 8};                          //Definição de pinos das colunas

//Cria o teclado

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

//Programa inicial 

void setup(){

  lcd.init();                                              //Inicializa o LCD

  lcd.backlight();                                     //Com Backlight

  Serial.begin(9600);                              //Inicializa a comunicação serial a 9600 bps

  

  //Deifinição de modo dos pinos

  pinMode(audioPin, OUTPUT);

  pinMode(yellowPin, OUTPUT);

  pinMode(redPin, OUTPUT);

  pinMode(greenPin, OUTPUT);

  lcd.clear();                                        //Limpa LCD

  key_init();                                         //Inicializa o sistema

}

//Loop Principal do Programa 

void loop(){

  char key = keypad.getKey();                         //Obtém tecla pressionada

  if (key != NO_KEY){                                  //Se foi pressionada uma tecla:

    if (key == '#') {                                          //Se a tecla é '#'

      code_entry_init();                                    //Então espera que seja inserida uma senha

      int entrada = 0;

      while (count < 4 ){                                  //Conta 4 entradas/teclas

        char key = keypad.getKey();                //Obtém tecla pressionada

        if (key != NO_KEY){                          //Se foi pressionada uma tecla:

          entrada += 1;                                     //Faz entrada = entrada + 1

          tone(audioPin, 1080, 100);                 //Para cada dígito emite um som de indicação

          delay(duration);                                 //Duração do som

          noTone(audioPin);                            //Para de emitir som

          if (key == pass[count])count += 1;       //Se a tecla pressionada corresponde ao dígito 

                                                                      //da senha correspondente, soma 1 no contador

          if ( count == 4 ) unlocked();                 //Se contador chegou a 4 e com dígitos corretos, 

                                                                     //desbloqueia siatema

          if ((key == '#') || (entrada == 4)){        //Se foi pressionada a tecla "#' ou foram feitas

                                                                     //4 entradas,

             key_init();                                         //Inicializa o sistema

            break;                                               //Para o sistema e espera por uma tecla

          }

        }

      }

    }

  }

}

//Inicializar o Sistema 

void key_init (){

  lcd.clear();                                                //Limpa o LCD

  lcd.print("Aguardando...");                        //Emite mensagem

  lcd.setCursor(0,1);                                   //Muda de linha

  lcd.print("Tecle #");                                  //Emite mensagem

  

  count = 0;                                                //Variável count é zero na inicialização

  

  //Emite som e acende LED Vermelho, indicando Sistema Iniciado

  digitalWrite(redPin, HIGH);

  digitalWrite(yellowPin, LOW);

  digitalWrite(greenPin, LOW);

  tone(audioPin, 1080, 100);

  delay(duration);

  noTone(audioPin);

  tone(audioPin, 980, 100);

  delay(duration);

  noTone(audioPin);

  tone(audioPin, 770, 100);

  delay(duration);

  noTone(audioPin);

}

//Subrotina de Entrada da Senha 

void code_entry_init(){

  lcd.clear();                                                //Limpa LCD

  lcd.print("Entre a Senha:");                        //Emite mensagem

  

  count = 0;                                                //Variável count é zero na entrada de senha

  

  //Emite som e acende LEDs

  tone(audioPin, 1500, 100);

  delay(duration);

  noTone(audioPin);

  tone(audioPin, 1500, 100);

  delay(duration);

  noTone(audioPin);

  tone(audioPin, 1500, 100);

  delay(duration);

  noTone(audioPin);

  digitalWrite(redPin, LOW);                            //Apaga LED Vermelho

  digitalWrite(yellowPin, HIGH);                      //Acende LED Amarelo

  digitalWrite(greenPin, LOW);                        //Apaga LED Verde

}

//Subrotina para Acesso Liberado 

void unlocked(){

  lcd.clear();                                                    //Limpa LCD

  lcd.print("Acesso Liberado!");                       //Emite mensagem

  

  digitalWrite(redPin, LOW);                           //Apaga LED Vermelho

  digitalWrite(yellowPin, LOW);                      //Apaga LED Amarelo

  

  //Executa 20 vezes +- 5 segundos, emite som e pisca LED verde

  for (int x = 0; x < 20; x++){ 

  digitalWrite(greenPin, HIGH);

  tone(audioPin, 2000, 100);

  delay(duration);

  noTone(audioPin);

  digitalWrite(greenPin, LOW);

  tone(audioPin, 2000, 100);

  delay(duration);

  noTone(audioPin);

  delay(250);

  }

}

As bibliotecas deste projeto bem como as versões mais elaboradas estão disponibilizadas em:
https://github.com/Arduinobymyself/ElectronicDoorLock

VÍDEO:

Agora podemos ver o projeto completo

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

Bom!, espero ter mostrado, o quanto o Arduino é flexível, fácil e dinâmico na realização de projetos.

Até o próximo post.

Como muitos visitantes pediram:

Agora temos uma Atualização do Sistema de Segurança com Arduino.
Sendo possível entar como uma nova senha via teclado.
Lembrando que ela permanece enquanto o sistema estiver ligado (em caso de perda de energia, a senha volta para a senha padrão).

;-)

Abaixo o código completo e uma nova versão da biblioteca LCD via I2C para a IDE 1.0 e da biblioteca keypad

https://github.com/Arduinobymyself/ElectronicDoorLock

25/01/2019 - ATUALIZAÇÃO

NOVA VERSÃO DA TRANCA ELETRÔNICA:

Agora com LCD normal 16x2 e LCD I2C, no mesmo SW você pode escolher entre um e outro somente tirando o comentário de algumas linhas;
Lendo e gravando as passwords diretamente na EEPROM do arduino;
Agora o sistema não perde mais a password  em caso de ser desernergizado;
Conhecendo o password antigo, é possível configurar um novo password que será gravado na EEPROM;
Para efeitos mais práticos de simulção, foi adicionado um servo-motor para fazer o acionamento da tranca;
Os comentários e as Telas do SW agora estão no idioma Inglês (devido a esse projeto estar também hospedado em sites estrangeiros;
quando digitado o password, um máscara com * irá aparecer para não divulgar os números (somente para efeitos especiais, pois os numeros do password não são mostrados enquanto digitados);
Nessa nova edição o teclado foi alterado para o tamanho 4x4, ou seja as senhas agora podem ter letras e números, o comprimento da senha também pode ser alterado na programação inicial do sistema.
Foi acrescentado um RTC Real Time Clock, para mostrar a hora no display na tela principal.
Conta com um temporizador; caso a pessoa não entre a senha correta em 5 segundos, volta para a tela inicial.

Dessa forma algumas mudanças na pinagem e interconexão foram necessárias; siga no próprio software a pinagem para as conexões do sistema.

Todos os arquivos podem ser obtidos diretamente no GitHub da ArduinoByMySelf; incluindo as versões anteriores:
https://github.com/Arduinobymyself/ElectronicDoorLock

BREVE POSTAREI UM VÍDEO RELACIONADO COM ESSA NOVA VERSÃO, AGUARDE!

Qualquer dúvida e ou sugestão entre em contato:
arduinobymyself@gmail.com

PWM - LED Fading

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

Este tutorial tem como objetivo mostar o uso do PWM para controlar o brilho de um LED causando efeito de desvanecimento contínuo da luz emitida.

Usaremos a função analogWrite() para escrever um sinal com modulação por pulso no LED; esta função comuta um sinal "on" "off" rapidamente no pino digital, com diferentes proporções, causando o efeito de "fading".

Vamos fazer um parenteses para entender melhor o PWM.

(

Modulação largura, ou PWM, é uma técnica para obter resultados analógicos com meios digitais. 

O controle digital é usado para criar uma onda quadrada, um sinal alternado entre ligada e desligada.

Este padrão on-off pode simular tensões entre plenos (5 volts) até (0 volts), alterando a porção do

tempo que o sinal passa ligado em relação ao tempo que o sinal passa desligado. 

A duração de "tempo" é chamado de largura de pulso.

Para obter diferentes valores analógicos, você muda, ou modula, a largura de pulso. 

Se você repetir esse padrão on-off rápido o suficiente com um LED, por exemplo, 

o resultado é como se o sinal fosse uma tensão estável entre 0 e 5v, controlando o brilho do LED.

No gráfico abaixo, as linhas verdes representam um tempo regular, um período. 

Esta duração ou período é o inverso da frequência de PWM.

Em outras palavras, como a freqüência de PWM do Arduino é cerca de 500Hz,as linhas verdes mediriam 2 milissegundos cada. 

Uma chamada para analogWrite () é uma escala de 0 - 255; analogWrite(255) indica que se solicita um ciclo de trabalho de 100%

ciclo (sempre ligado), e analogWrite (127) é um ciclo de 50% (metade do tempo), e assim por diante.

PWM

Texto extraído do site: http://arduino.cc/en/Tutorial/PWM, visite!

)

O hardware:

1 x Placa Arduino UNO
1 x Resistor 220O
1 x LED
1 x Breadboard
Fios

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

Usando a Breadboard:
Connecte o terminal "Anodo" do LED ao resistor;
O terminal "Catodo" do LED, conecte ao negativo da alimentação;
O outro terminal do resistor, conecte ao pino 9 do Arduino.

O Programa:

Abaixo o código comentado.


/*
 Fade

 Este exemplo mostra como desvanecer um LED conectado ao pino 9
 usando a função analogWrite().

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


int brightness = 0;                                  // quantidade de brilho do LED
int fadeAmount = 5;                              // quantos pontos o LED irá desvanecer


//inicialização
void setup()  { 
   pinMode(9, OUTPUT);                   // declara o  pino 9 como saída
} 


//programa inicial
void loop()  { 
  analogWrite(9, brightness);                //determina o brilho do LED   
  brightness = brightness + fadeAmount;                // troca o brilho para a próxima iteração do loop
  if (brightness == 0 || brightness == 255) {           // reverte a direção do desvanecimento ao fim do mesmo
    fadeAmount = -fadeAmount ; 
  }     
  delay(30);                                         // espera 30 milisegundos para ver o efeito de escurecimento
}


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

Vídeo:

Conclusão:




Mais uma experiência de nível básico, sem maiores problemas em sua execução.
Hardware simples e Software descomplicado.
Básico.


Espero ter ajudado com mais este POST, até o próximo!

Potenciômetro - Leitura Analógica

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

"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.

E 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!

Trabalhando com Botões

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.

Primeiro Teste com o LED Blink

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!
-->

Arduino "O Início"

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!