Arquivos de Categoria: eletrônica

Novo site

Este post pretende ser o último por aqui, todo o material daqui vai para o novo site no domínio http://jetersilveira.com.br. Saudações!

Anúncios

[SOLUÇÃO] LCD Nokia 5110 – Erro ‘class Adafruit_PCD8544’ has no member named ‘print

Compilando o programa de exemplo da biblioteca Adafruit PCD8544 para o display LCD do Nokia 5110 recebi várias vezes o erro acima, variando, conforme algumas alterações no código e no diretório (pasta) de bibliotecas (libraries), para o erro: int8_t RobotControl::keyboardRead()

A solução que encontrei foi a seguinte: criei uma pasta com o nome `tmp`na raiz do diretório arduino (que contém o diretório libraries), e movi o diretório Robot_Control de libraries para tmp, excluindo, portanto, essa biblioteca do diretório. Depois disso, o erro que dava era que não conseguia encontrar o arquivo “SPI.h“, que as bibliotecas da Adafruit tentavam incluir. Assim, copiei os dois arquivos SPI.cpp e SPI.h do diretório SPI (contido em libraries, também) para o interior da pasta PCD8544 (onde estão as bibliotecas Adafruit PCD8544 e Adafruit GDX).

Feito isso, fucionou perfeitamente. Segundo informações de desenvolvedores do arduino, no fórum, esse é um erro de incompatibilidade entre algumas bibliotecas que têm sido criadas para arduino, e que devem ser evitados pelos desenvolvedores das mesmas. Esperemos que, em breve, não necessitemos do workaround. 🙂

Saudações!

Installing Pronterface on Ubuntu and the error: Not a directory: ‘/usr/share/printrun/pronterface.py’

Hello, people! Installing PRONTERFACE on my machine, when I tried to run it, I got the error Not a directory: ‘/usr/share/printrun/pronterface.py’. So I’ve created my workaround 😀 I decided to write a small step-by-step to explain how to install this software through the available repository and also solve this error. Let’s go. Open a terminal, and get it done:

sudo apt-get install python python-serial python-wxgtk2.8 python-tk
sudo apt-add-repository ppa:richi-paraeasy/ppa
sudo apt-get update
sudo apt-get install pronterface skeinforge

After running these commands, you’re going to have Pronterface installed. Open the terminal again e try to execute the command “$ pronterface” (whithout the $). You’ll probably get the following error:

OSError: [Errno 20] Not a directory: ‘/usr/share/printrun/pronterface.py’

Ok. Once this happened, let’s go to the next steps. You will edit the files pronterface.py and pronsole.py. You’ll find them at the directory /usr/share/printrun/.

Open each file, as a superuser, with your favorite text editor (like Vim).

If you use gedit, as a text editor, you can execute:

sudo gedit /usr/share/printrun/pronterface.py

Inside the file, look for this line (it should be next to 24):

os.chdir(os.path.realpath(__file__))

And replace for this one:

os.chdir(os.path.realpath(‘./’))

Save and close the file. Next, open the second file:

sudo gedit /usr/share/printrun/pronsole.py

And make the same change in the same line (it should be next to 30, on this file). Then, save and close the file. You have to make this change in both pronterface.py e pronsole.py. Actually, all you are going to do is replace  __file__  for ‘./’  on these lines.

Once you’ve done that, you can run pronterface:

pronterface

If necessary, as superuser:

sudo pronterface

And happy printing!  😀

pronter

 

[RESOLVIDO] Instalando o Pronterface no Ubuntu para a RepRap e o erro Not a directory: ‘/usr/share/printrun/pronterface.py’

Salve, pessoal! Instalando o programa PRONTERFACE aqui na minha máquina, deparei com o erro Not a directory: ‘/usr/share/printrun/pronterface.py’. Criei o meu workaround 😀 Resolvi fazer um tutorialzinho para explicar como instalar esse programa através do repositório disponível e já resolver esse erro. Vamos lá. Abra um terminal e mande brasa:

sudo apt-get install python python-serial python-wxgtk2.8 python-tk
sudo apt-add-repository ppa:richi-paraeasy/ppa
sudo apt-get update
sudo apt-get install pronterface skeinforge

Depois de executar esses comandos, você vai ter o pronterface instalado. Abra um terminal e tente executar o comando “$ pronterface”. Você provavelmente vai receber o seguinte erro como resposta:

OSError: [Errno 20] Not a directory: ‘/usr/share/printrun/pronterface.py’

Certo. Verificado que está acontecendo este erro, faça o seguinte. Você vai precisar editar os arquivos pronterface.py e pronsole.py. Você irá encontrá-los no diretório /usr/share/printrun/

Abra um arquivo de cada vez, com permissões de superusuário, em seu editor de textos favorito (eu uso o Vim).

Se você usar gedit, como editor de texto, pode executar:

sudo gedit /usr/share/printrun/pronterface.py

Dentro do arquivo, procure a seguinte linha (deve estar próxima à linha 24):

os.chdir(os.path.realpath(__file__))

E substitua por essa outra:

os.chdir(os.path.realpath(‘./’))

Salve e feche o arquivo. Na sequência, abra o próximo:

sudo gedit /usr/share/printrun/pronsole.py

E faça a mesma modificação (deve estar próxima à linha 30). Depois, salve e feche o arquivo. Faça as mundanças na linha referida em cada um dos arquivos pronterface.py e pronsole.py. Na realidade você só vai precisar substituir  __file__  por ‘./’ nessas linhas.

Feito isto, execute o pronterface no terminal:

pronterface

Se for necessário, como superusuário:

sudo pronterface

E boas impressões! 😀

pronter

Biblioteca no Arduino para o Sensor de Cor TCS320 e TCS3200

color-sensor-TCS230-Color-Recognition-Sensor-Detector-Module-DC-3-5V-Input-Color-090541

Sensor de Cor TCS230/TCS3200 em uma breakout board

O sensor de reconhecimento de cor TCS230/3200 da AMS (antiga TAOS) possui um conjunto de 64 fotodiodos para detecção de cores: 16 com filtro para a frequencia de cor vermelha (Red), 16 com filtro para a frequencia de cor verde (Green), 16 com filtro para a frequencia de cor azul (Blue), e ainda 16 fotodiodos sem filtro de cores. Esse conjunto de fotodiodos permite ao circuito integrado fazer o que chama de transformação de luz-para-frequência (light-to-frequency). O que acontece é o seguinte: a saída do sensor é um pulso de 50% de duty cycle (isso significa que é um pulso quadrado “perfeito”, ou seja, metade do tempo em nível lógico alto e metade em nível lógico baixo), que varia a frequência conforme a intensidade da luz.

O TCS230/3200 possui quatro entradas: S0, S1, S2, e S3. As duas primeiras servem para selecionar uma escala de frequência (2%, 20% ou 100%), ou simplesmente desligar o sensor. As duas últimas servem para selecionar o conjunto de fotodiodos que você quer o resultado: como são dois bits, teremos exatamente quatro possiblidades, que são correspondentes aos quatro conjuntos de fotodiodos. Assim o sensor dará um resultado com a intensidade de cada cor que ele consegue medir, e a intensidade total, permitindo o desenvolvimento de uma aplicação que calcule o valor RGB para a cor detectada. Veja abaixo a tabela, extraída do datasheet:

tcs230Finalmente temos uma biblioteca para lidar com esse sensor no Arduino!!! A bilioteca MD_TCS230 está disponível para download no GitHub e no CodePlex. Vamos a um passo-a-passo para testar seu primeiro programinha com o sensor de cores no Arduino!!

1º passo –  Instalando a biblioteca MD_TCS230

Faça o download da biblioteca nesse link (aconselho utilizar este link direto para a página de download no CodePlex, pois a MD_TCS230 possui uma dependencia que está incluída neste pacote zip). Depois de completar o download, abra o pacote zip com o descompactador e extraia as pastas FreqCount e MD_TCS230 no dentro do diretório ~/sketchbook/libraries (ou /home/[SEU_USUARIO/sketchbook/libraries ou, se usar Windows – sério que vc faz isso??? :O – você irá encontrar a pasta libraries dentro da pasta sketchbook provavelmente no sua pasta de usuário – c:\Users\[SEU_USUARIO]\sketchbook\libraries – não mudou nada, né? rs). Feche todas as janelas da Arduino IDE (isso é importante! – em alguns casos só funciona se fizer isso – wtf?) e depois abra o Arduino IDE novamente. Pronto! As bibliotecas MD_TCS230 e FreqCount estão instaladas (a FreqCount é uma dependência da MD_TCS230).

2º passo – Carregando o programa de exemplo da biblioteca

Vamos utilizar aqui o mais simples programa de exemplo disponível na biblioteca, que simplesmente irá retornar no Serial Monitor as leituras realizadas em um código RGB. Se tudo deu certo no passo anterior, você poderá acessar o programa de exemplo da MD_TCS230 através do menu: File -> Sketchbook -> libraries -> MD_TCS230 -> Simple_NB_TCS230. Quando você clicar aí, carregará o seguinte código:

// TCS230 sensor reading example
//
// This is just to show basic functionality without calibration.
// Utilises the non-blocking version of the reading function.
// Output uses the Serial console.
//
#include <MD_TCS230.h>
#include <FreqCount.h>

// Pin definitions
#define  S2_OUT  12
#define  S3_OUT  13
#define  OE_OUT   8    // LOW = ENABLED 

MD_TCS230  CS(S2_OUT, S3_OUT, OE_OUT);

void setup()
{
  Serial.begin(57600);
  Serial.println("[TCS230 Simple NON_BLOCKING Example]");
  Serial.println("\nMove the sensor to different color to see the RGB value");
  Serial.println("Note: These values are being read in without sensor calibration");
  Serial.println("and are likely to be far from reality");

  CS.begin();
}

void readSensor()
{
  static  bool  waiting;
 
  if (!waiting)
  {
    CS.read();
    waiting = true;
  }
  else
  {
    if (CS.available())
    {
      colorData  rgb;
      
      CS.getRGB(&rgb);
      Serial.print("RGB [");
      Serial.print(rgb.value[TCS230_RGB_R]);
      Serial.print(",");
      Serial.print(rgb.value[TCS230_RGB_G]);
      Serial.print(",");
      Serial.print(rgb.value[TCS230_RGB_B]);
      Serial.println("]");
      
      waiting = false;
    }
  }
}

void loop()
{
  readSensor();
}

 

 

Pronto! Esse programa aí você carregará para a memória do Arduino em breve (é aconselhável montar todo o hardware antes de carregar o programa pro Arduino, o que faremos no próximo passo).

3º passo – Montando o hardware: ligações com o Arduino

120_1_H

Arduino UNO

Nesse primeiro programa de exemplo, que é bastante simples, você precisará fazer apenas quatro conexões além do VCC e GND, que são a alimentação do sensor: S2, S3, OE, e OUT. Até mesmo OE (Output Enable), se quiser, você pode simplesmente ligar o pino OE do sensor ao GND, sem conectar no Arduino, mas é aconselhável seguir o projeto do programa, já que estamos aprendendo e poderá ser importante, no futuro, desabilitar temporariamente a saída do sensor.

É fácil descobrir as conexões para S2, S3, e OE simplesmente verificando as linhas de código dentro do programa:

// Pin definitions
#define  S2_OUT  12
#define  S3_OUT  13
#define  OE_OUT   8    // LOW = ENABLED

Mas… e onde vou conectar OUT no Arduino?? Como é que eu sei onde vou conectar a saída do meu sensor de cores RGB no Arduino? Então, tive um trabalho aqui, mas foi apenas falta de ler a documentação da bilioteca. Se  você observar na descrição da biblioteca aqui, perceberá uma NOTA IMPORTANTE onde o autor da biblioteca avisa sobre uma limitação da dependencia FreqCount, que permite a utilização apenas de determinados pinos para a contagem da frequencia e limita o uso de outros pinos, conforme a tabela abaixo:

Board         Input Pin   Pins Unusable with analogWrite()
-----------   ---------   --------------------------------
Arduino Uno   5           3, 9, 10, 11
Arduino 2009  5           3, 9, 10, 11
Arduino Mega  47          9, 10, 44, 45, 46
Sanguino      1           12, 13, 14, 15

Logo, sabemos que o pino para a conexão da saída do sensor (pino OUT), é o pino 5 do Arduino. Ficam então as conexões:

SENSOR     ARDUINO UNO
------     -----------
 VCC           5V
 GND           GND
 S2            12
 S3            13
 OE            2
 OUT           5

Uma vez terminadas as conexões, carregue o programa para dentro do Arduino e teste seu programa! Assim que carregar o programa (você verá ver a mensagem “Done uploading.” na barra de status da Arduino IDE), pressione Ctrl+Shift+M ou vá em Tools -> Serial Monitor. Quando abrir o Serial Monitor, selecione a taxa de transferência de 57600 baud no canto inferior direito, senão você apenas enxergará caracteres malucos em sua tela… rs. Aproxime uma folha branca de papel do sensor para ver como ele marca perfeitamente: [255,255,255] no Serial Monitor. Outras cores ficarão aproximadas, o preto é bastante difícil de detectar. Cores mais “claras” são mais fáceis por terem uma SATURAÇÃO  maior e também maior INTENSIDADE de luz, permitindo assim que o software tenha mais informações com que trabalhar. Deixe seu comentário e até a próxima!!

Interface Web para Controle da Porta Paralela (LINUX)

Salve, pessoal! Nesse post de hoje quero compartilhar um projeto que fiz há uns oito anos atrás… rs um pouco “velho”, portanto, em termos de tecnologia. Além disso, claro, eu o estou compartilhando aqui na exata mesma versão de então (a última alteração consta de 18 de abril de 2007), existem alguns problemas nele de desempenho e certamente que hoje eu já não o faria da mesma forma, mas ele é ótimo para quem quiser se divertir um pouco com um PC e uma porta paralela. Até hoje esse sistema está disponível nos servidores do Robótica Livre, um projeto do professor Danilo César, que à época interessou-se em disponibilizar o sistema em seu site.

Importante! Leia o AVISO contido no final dessa postagem.

O sistema é web, isto é, o usuário acessa através de um navegador, uma página completamente simples, e controla o status dos bits do registrador de dados da porta paralela, onde os sinais variam de 0 a 5V (nivel lógico baixo – zero – e alto – um -, respectivamente). Seguem algumas screenshots (feio pra caramba.. haha):

lpt1

lpt2  lpt3

Mas é isso. Vamos lá!

 

Um pouco sobre porta paralela

A porta paralela possui três registradores: dados, controle e status. Desses, apenas o registrador de dados tem correspondência física nos pinos da porta paralela de todos os seus 8 bits, e pode funcionar como entrada e saída. Os outros (também são de 8 bits) têm apenas algumas correspondências, e o de controle funciona apenas como saída, e status apenas como entrada. Não vou me aprofundar nesses registradores, porque em nosso sisteminha apenas utilizamos o registrador de dados, na sua configuração padrão (como saída). Mais informações sobre a porta paralela e seus registradores você pode encontrar no site rogercom.com (esse artigo de lá foi uma base didática para mim à época, apenas fiz adaptações para usar no linux). Vou utilizar aqui algumas imagens do rogercom.com, e recomendo que você visite o site e aproveite o excelente conteúdo disponível por lá.

Esse é um esquema da pinagem do DB25:

Projeto3

Como dá pra perceber, os pinos de 2 a 9 são correspondentes aos 8 (oito) bits do registrador de dados da porta paralela. Os pinos de 18 a 25 são todos GND (isto é, ground, id est, terra, ou seja, NEGATIVO.. rs). É recomendável que, quando montar o circuito do nosso projeto, você utilize todos os pinos de GND do DB25, por uma questão de distribuição da corrente, para não sobrecarregar nenhum deles.

 

O que você vai precisar

– Um servidor Apache e o PHP rodando na sua máquina (veja sobre isso aqui)

– Uma máquina com porta paralela (por quê será?? rs)

– Uma implementação de hardware (veja abaixo)

 

Uma implementação de hardware

Quando montei esse projeto (na verdade ainda tenho guardado isso em algum lugar…) foi um pouco diferente do que será mostrado aqui. Vou aqui compartilhar os circuitos sugeridos pelo rogercom.com mesmo. Se você apenas quer montar um circuitinho para ver que a paradinha funciona, monte apenas um circuito com 8 leds para que você possa visualizar o byte do registrador de dados, como esse:

Projeto4

Caso você queira, por exemplo, controlar realmente lâmpadas, ventiladores, aparelhos de som, cafeteira, enfim, equipamentos elétricos de sua residência – ligar e desligar apenas, claro -, você pode montar um circuito com um buffer para proteger a porta paralela, e adaptação de potência com transistores e relés para controlar uma carga de, digamos, até 10 ou 20 ampères (depende da corrente suportada pelos contatos do relé que você utilizar). É possível (e no meu projeto eu fiz isso) usar o mesmo CI (circuito integrado) que é buffer, como adaptação de potência para acionar diretamente o(s) relé(s) em 12V, dispensando o uso dos transistores (o BD137, que é utlizado aí). No entanto, vou ficar devendo esse circuito no momento (prometo encontrar meu projeto velho e compartilhar aqui fotos dele e os esquemáticos), e vou usar nesse post o circuito sugerido pelo mestre Antônio Rogério Messias:

Projeto2

As instruções para instalação do “LTP Web Controller” (apelido que dei pro projeto.. rs) estão contidas no arquivo README, o qual transcrevo:

 

PARA FAZER FUNCIONAR O LPT Web controller # 29-Novembro-2006
============================================================

ultima alteracao: 18/04/2007

1. Extraia o pacote em seu diretório Web (“public_html”, por exemplo);
2. Mude o dono do arquivo fazer.txt para o usuario do servidor web (no meu caso, é “www-data”; para descobrir se o seu também é, digite “$ cat /etc/passwd | grep www”).
Para mudar o dono do arquivo, digite (no diretorio lpt/):

$ sudo chown nome_de_usuario_do_servidor_web fazer.txt

Se o usuario do servidor web for www-data, como o meu, fica:

$ sudo chown www-data fazer.txt

3. Inicie a execução do daemon com o comando (no diretório “lpt”):

$ sudo ./daemon

4. Se quiser deixar o daemon rodando em ‘background’, digite o comando e mais o
&, como abaixo:

$ sudo ./daemon &

5. E pronto! Acesse depois a página e boa sorte!

Qualquer problema entre em contato!!!

Jéter Vaz – jetervaz (a) gmail.com
https://jetervaz.wordpress.com

 

Baixe o LTP Web Controller aqui (clique com o botão direito e vá em “Salvar link como”): lpt.tar.gz

Duvídas? Fique à vontade para usar os comentários para questionamentos, tentarei responder assim que possível.

AVISO! Se você decidir montar esse projeto, FAÇA POR SUA PRÓPRIA CONTA E RISCO! Tenha responsabilidade de ter alguma noção do que está fazendo, e mentalize que esse sistema é completamente inseguro e apenas tem finalidade didática.

Introdução à Eletrônica de Potência

image Começou ontem, 1º de setembro de 2014, o curso Introdução à Eletrônica de Potência, provido pela Universidade do Colorado, com o Dr Robert Erickson, através do site Coursera.org. O curso é gratuito, com direito a certificado de acompanhamento, e não há limite para o número de alunos (trata-se de um MOOC – Massive Open Online Course). Se o estudante quiser um certificado autenticado, pode optar por pagar um valor de aproximadamente US$ 50, enviar seus documentos, e receber um certificado reconhecido e autenticado pela Universidade do Colorado.

É recomendado um conhecimento prévio sobre dispositivos eletrônicos analógicos e digitais e análise de circuitos eletroeletrônicos. Não há prazo limite para entrar no curso, embora a primeira atividade avaliativa tenha prazo limite para entrega até o final da segunda semana do curso. É uma opção válida para quem deseja aumentar ou atualizar seus conhecimentos e incrementar o currículo. O curso é em inglês, com vídeo-aulas legendadas também em inglês.

Veja o vídeo de apresentação do curso:

Acesse o curso em: https://class.coursera.org/powerelectronics-002

Debouncing via software com Arduino sem usar delay – millis()

Nesse post quero compartilhar minha tradução (com algumas alterações) do código de debounce da documentação do Arduino. Primeiro, para quem desconhece o que significa debounce em eletrônica digital, aconselho a leitura desse excelente artigo do site Embarcados, autoria do Rodrigo Almeida, que trata desde o conceito de bouncing (com excelentes ilustrações), até as formas de debouncing através de hardware e software (o exemplo do artigo é para o PIC). Lembrando que o ideal é utilizar uma combinação das duas formas, para que o tempo de resposta seja o maior possível; pois, como veremos adiante, o tratamento do bouncing por software implica um delay (atraso) na resposta ao comando.

Em um outro post que fiz aqui, utilizei como método de debouncing por software a própria função delay() – nessa postagem também não testo se o estado da chave foi modificado, de forma que se o usuário mantiver pressionado o botão por tempo superior ao delay() o comando será executado repetidas vezes.  Mas utilizar a função delay() não é a forma correta. Por quê? Simplesmente porque ela congela a execução do programa pelo microcontrolador (Arduino), atrasando todos as demais tarefas que sua rotina deve fazer, por exemplo, atualizar uma amostragem de algum dado num display LCD. A forma de contornar isso é utilizando instruções condicionais if que testam se já passou um determinado tempo (cria um delay apenas para essa tarefa, digamos assim, de verificar a alteração de estado da chave), a partir de comparação com o tempo total e absoluto de execução do programa no Arduino, que é obtido em milissegundos através da função millis().

        OBS.: Em um código que encontrei na internet, o programador usou uma instrução while para testar se o tempo havia passado, e isso resolve… NADA! Por quê? Simplesmente porque a execução do programa ficará nesse while [tempo_não_passa] até que o tempo realmente tenha passado, o que equivale a usar a função delay()! Se for para fazer isso, melhor usar delay(), em vez de ficar declarando e configurando novas variáveis apenas para a estrutura do while [tempo_nao_passa] nao_faz_nada funcionar…

        OBS. 2: A principal alteração que fiz no código da documentação está na retirada do resistor de PULL DOWN (previsto no circuito da documentação). Como ficou então nosso circuito? Optei por utilizar o resistor de PULL UP interno do próprio Arduino, tendo para que funcionasse assim apenas de inverter a lógica da detecção de alteração de estado da chave ou do botão de entrada. Atenção: Importante lembrar que a maneira mais simples e enxuta de habilitar o resistor de PULL UP interno do Arduino é declarando explicitamente em “pinMode(pinodeentrada, INPUT_PULLUP)“, dessa forma. É possível também declarar “pinMode(pinodeeentrada, INPUT)” e na outra linha “digitalWrite(pinodeentrada, HIGH)“. Isso também irá habilitar o resistor interno de PULL UP do Arduino, mas o ideal é enxugar o código e usar apenas as instruções necessárias, ocupando menos espaço em ambas as memórias e por isso mesmo otimizando a execução do programa.

Mais informações nos próprios comentários do código. Segue abaixo também o desenho da montagem do circuito, feito no Fritzing.

/*
Debounce – Estabilizacao

Cada vez que o pino de entrada vai de HIGH para LOW (e.g. devido ao pressionamento
do botao), o pino de saida eh alternado de LOW para HIGH ou de HIGH para LOW. Existe
um pequeno atraso entre essas alternancias para estabilizar o circuito (i.e. para
ignorar o ruido).

O circuito:
* LED do pino 13 ao GND (terra ou negativo)
* botao pulsante (pushbutton) do pino 2 ao GND (terra ou negativo)

* Nota: Na maioria das placas Arduino, jah existe um LED na placa conectado
ao pino 13, assim vc nao precisa adicionar nenhum componente neste circuito.
Ateh mesmo o botao pulsante pode ser substituido por um mero ‘jumper’ (um ‘fiozinho’)
com o qual vc podera simular o pressionamento do botao fazendo contato entre
o pino 2 e qualquer GND do Arduino.

criado em 21 Nov 2006
por David A. Mellis
modificado em 30 Ago 2011
por Limor Fried
modificado em 28 Dez 2012
por Mike Walters
modificado e traduzido em 31 Ago 2014
por Jeter Silveira

Esse codigo foi copiado e alterado para disponibilizacao gratuita na internet em:
http://www.jetersilveira.com.br

O original tambem eh dominio publico e pode ser encontrado na pagina oficial de
documentacao do Arduino no endereco abaixo:

http://www.arduino.cc/en/Tutorial/Debounce

*/

// as constantes nao mudam. Elas sao usadas aqui
// para ‘setar’ os numeros dos pinos
const int buttonPin = 2; // o numero do pino do botao pulsante (“pushbutton”)
const int ledPin = 13; // o numero do pino do LED

// Variaveis sofrerao mudancaso
int ledState = HIGH; // o atual estado do pino de saida (LED)
int buttonState; // a leitura atual do pino de entrada
int lastButtonState = HIGH; // a leitura anterior do pino de entrada

// as variaveis seguintes sao to tipo ‘long’ porque o tempo, medido em milissegundos
// rapidamente se tornara um numero maior do que o que cabe em uma ‘int’.
long lastDebounceTime = 0; // a ultima vez que o pino de saida foi modificado (toggled)
long debounceDelay = 50; // o tempo de estabilizacao (debounce);
// aumente se houver oscilacao na saida.

void setup() {
pinMode(buttonPin, INPUT_PULLUP); // habilita o resistor de PULL UP interno do Arduino
pinMode(ledPin, OUTPUT);

// ‘seta’ estado inicial do LED
digitalWrite(ledPin, ledState);
}

void loop() {
// le o estado do botao em uma variavel local
int reading = digitalRead(buttonPin);

// testa para ver se voce recem acaba de apertar o botao
// (i.e. a entrada foi de LOW para HIGH, e vc esperou tempo suficiente
// desde o ultimo pressionamento para ignorar qualquer ruido).

// Se o estado do botao mudou, seja por pressionamento ou por ruido
if (reading != lastButtonState) {
// ‘reseta’ o temporizador de debounce
lastDebounceTime = millis();
}

if ((millis() – lastDebounceTime) > debounceDelay) {
// seja qual for o valor da leitura, ele esta lah a mais tempo que
// o tempo de debounce (debounceDelay), entao podemos utilizar o valor:

// verifica se o botao mudou
if (reading != buttonState) {
buttonState = reading;

// apenas muda o estado (toggle) do LED se buttonState for LOW
if (buttonState == LOW) {
ledState = !ledState;
}
}
}

// ‘seta’ o LED
digitalWrite(ledPin, ledState);

// salva a leitura. Na proxima vez que passar no loop
// essa leitura sera o ultimo estado do botao (lastButtonState).
lastButtonState = reading;
}

 

Diagrama de montagem do circuito. O LED que deverá ser observado é incluido na placa. Observe que é há LED SMD próximo dos LEDS indicadores de TX e RX e do pino 13, indicado pela letra L. Esse LED tem em praticamente todas as placas Arduino e está ligado ao pino 13, para indicar seu status. Daí porquê esse circuito tem apenas o botão, com o objetivo de agilizar e facilitar seu aprendizado da técnica de debouncing por software. Lembre que no início do artigo falamos sobre a importância do debouncing via hardware também. No entanto, para a grande maioria das aplicações a técnica de software que aqui demonstramos é suficiente.

debounce_pullup