collapse

* Links de Robótica

* Posts Recentes

Organizar fios por josecarlos
[Hoje às 12:19]


Pendentes de compras colectivas por Hugu
[Hoje às 00:51]


Preços e fabricantes de pcb por vasco
[Ontem às 23:18]


Palavras Cruzadas por LVirtual
[Ontem às 20:54]


[Projecto] Bomba Airsoft por jm_araujo
[Ontem às 19:01]


Apresentação por Tech_JA
[23 de Setembro de 2017, 09:19]


Medir Agua que está no Poço por filjoa
[21 de Setembro de 2017, 20:58]


URGENTE - display de 7 segmentos com backpack por helderjsd
[20 de Setembro de 2017, 12:30]


Isaac Asimov - I, Robot por senso
[18 de Setembro de 2017, 03:41]


ic SL440 da Plessey? por senso
[16 de Setembro de 2017, 13:11]

Autor Tópico: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"  (Lida 6367 vezes)

0 Membros e 1 Visitante estão a ver este tópico.

Offline samc

  • Mini Robot
  • *
  • Mensagens: 390
Uma das formas mais comuns de controlar o Arduino é utilizar interruptores ou botões de pressão. Neste pequeno tutorial, vamos explicar como utilizar botões de uma forma fácil, “profissional” e que necessite de poucas linhas de código escritas. Além disso, vão ser ainda introduzidos os seguintes conceitos básicos:
  • PWM
  • Constante INPUT_PULLUP
  • “Bounce” de um botão
  • Instalação automática de uma biblioteca externa no Arduino
  • Utilização da biblioteca Bounce.h
Para introduzir este tutorial, imaginemos uma situação prática em que pretendemos controlar o brilho de um LED através de dois botões (um botão para aumentar o brilho e outro para o diminuir). Os botões devem controlar o aumento de uma forma precisa (aumentar o valor do brilho em incrementos de uma unidade) e possibilitar um aumento mais rápido do valor caso se mantenha o botão premido.


Parte I - Hardware
Para se variar o brilho do LED é necessário utilizar uma porta com saída PWM. O que acontece de uma forma simples numa saída PWM é que o LED é ligado e desligado muito rapidamente (até aproximadamente 490 vezes por segundo). Variando o os valores deste pulso é possível “obter a sensação” que o LED não está com o brilho máximo (mais informações sobre PWM aqui ).
O pino escolhido para ligar o LED poderá ser qualquer um dos pinos do Arduino que suportem PWM, como por exemplo, o número 11. Visto que na saída dos pinos do Arduino a corrente máxima é de 40 mA a 5 V, deverá utilizar-se uma resistência ligada em série com o LED para o proteger (tipicamente utiliza-se uma resistência de 220 Ohms).
A ligação dos dois botões poderá ser realizada em qualquer uma das portas digitais do Arduino (neste caso vamos escolher os pinos 7 e 8). Na maioria dos tutoriais são utilizadas resistências de proteção em conjunto com os botões (chamadas de resistências pull-down), no entanto, para simplificar as ligações e o número de componentes usados, vamos utilizar as resistências internas do Arduino (chamadas de resistências de pull-up), e por isso a ligação será realizada diretamente entre a massa (ground ou GND) e o botão.

As nossas ligações ficariam assim:

Ou o esquema elétrico:


NOTA: no esquema é utiliza um botão de pressão simples de dois terminais, os botões de 4 terminais que devem ser ligados da seguinte forma ( http://arduino.cc/en/uploads/Tutorial/inputPullupButton.png ).

Parte II - Software
Algo que pode passar despercebido ao principiante na eletrónica é que os interruptores mecânicos não funcionam de uma forma totalmente “limpa”. De uma forma simples, quando se pressiona um botão, os contactos metálicos não fecham o circuito imediatamente devido às condições microscópicas das superfícies de contacto e ocorre um ligeiro oscilar (Bounce) entre estados durante breves microssegundos entre. A figura abaixo esquematiza este pormenor ao representar a variação de estado de um botão ao longo do tempo:


Como os microcontroladores são muito rápidos a processar os sinais, conseguem detetar esta oscilação no estado do botão e em determinadas aplicações tal facto pode ser problemático. Existem diversas formas de contornar este problema. A mais comum é utilizar algumas linhas de código que recorrem à função millis() do Arduino (tutorial aqui). No entanto, vamos aprender a utilizar a biblioteca Bounce que foi escrita para este efeito e que adiciona algumas funcionalidades interessantes de uma forma muito simples e sem ser necessário utilizar muitas linhas de código.

1- Instalar a biblioteca automaticamente
1- Fazer download da biblioteca (comprimida em zip) aqui http://playground.arduino.cc/uploads/Code/Bounce.zip
2- Na IDE do Arduino, navegar até ao menu Sketch -> Importar Biblioteca… -> Adicionar Biblioteca… e escolher o ficheiro descarregado anteriormente
NOTA: caso deseje instalar a biblioteca manualmente poderá utilizar as instruções disponíveis aqui

2- Escrever o programa
O código inicia com a chamada da biblioteca e a definição dos pinos de ligação. Definir os pinos utilizados é uma boa prática que simplifica a alteração das ligações elétricas sem ser necessário rever todo o código escrito.
Citar
#include <Bounce.h> // biblioteca utilizada

// definição dos pinos de ligação
#define LED_PIN 11
#define AUMENTAR_PIN 8
#define DIMINUIR_PIN 7
É criada uma variável do tipo byte (valores entre 0 e 255) que irá armazenar o valor do brilho do LED.
Citar
byte brilho = 0; // valor do brilho do LED entre 0 e 255
Os dois botões utilizados são declarados como objetos da seguinte forma Bounce(byte pin, unsigned long debounce_interval) sendo que o intervalo de debouce é definido em milissegundos (5 milissegundos é um valor tipicamente utilizado).
Citar
#define DEBOUNCE_TIME 5 // tempo em ms
Bounce aumentar = Bounce(AUMENTAR_PIN, DEBOUNCE_TIME);
Bounce diminuir = Bounce(DIMINUIR_PIN, DEBOUNCE_TIME);
O pino do LED é definido como pino de saída e os pinos dos botões são definidos como entrada com o argumento INPUT_PULLUP que possibilita o uso das resistências internas de pull-up. Esta definição inverte o comportamento do pino no sentido que um valor HIGH ou ligado significa que o sensor está desligado e vice-versa.
De forma a monitorizar o valor da variável que define o brilho do LED é iniciada uma comunicação série que pode ser controlada através do Monitor Série integrado na IDE Arduino (Menu Ferramentas -> Monitor Série).
Citar
void setup()  {
  pinMode(LED_PIN, OUTPUT); // define o pino como saída
  pinMode(AUMENTAR_PIN, INPUT_PULLUP);
  pinMode(DIMINUIR_PIN, INPUT_PULLUP);
 
  Serial.begin(9600);
  Serial.println("Tutorial Botao v.1.0.0");
}
O código da função principal do programa começa com a escrita do valor da variável brilho (um valor de 0 corresponde a sempre desligado e um valor de 255 corresponde a sempre ligado). O estado dos botões é detetado através da função update, caso este valor seja verdadeiro (o que corresponde a uma mudança de estado do botão), é verificado se o botão encontra-se premido. Note que devido à utilização da resistência interna de pull-up a lógica dos botões inverte-se e o valor 0 ou LOW corresponde ao estado em que o botão se encontra premido.
A função rebounce força o sinal do estado do botão a alterar mesmo que o estado real permaneça imutável. Neste caso é utilizada esta função para repetir o estado do botão a cada 250 milissegundos enquanto o botão estiver a ser premido (o que é útil para alterar mais rapidamente o valor). O valor da variável brilho pode ser lido no monitor série de forma a se comprovar o correto funcionamento do programa (a função Serial.println(valor) escreve o valor da variável seguido de uma quebra de linha ou “parágrafo”).
Citar
void loop()  {
  analogWrite(LED_PIN, brilho);
 
  if (aumentar.update() ) {
    if (aumentar.read() == LOW ) {
      aumentar.rebounce(250);
     
      if (brilho < 255)
        brilho ++;
       
      Serial.print("Aumentar brilho LED: ");
      Serial.println(brilho);
    }
  }
 
  if (diminuir.update() ) {
    if (diminuir.read()== LOW ) {
      diminuir.rebounce(250);
     
      if (brilho > 0)
        brilho --;
       
      Serial.print("Diminuir brilho LED: ");
      Serial.println(brilho);
    }
  }               
}


Aconselhamos a uma revisão cuidada do código e das ligações elétricas antes de fazer o upload do código. Uma configuração errada dos pinos de entrada pode danificar permanente o Arduino.
Caso o upload seja realizado com sucesso poderão utilizar o Monitor Série (atalho: CTRL+SHIFT+M) para observar a alteração do valor da variável que controla o brilho e comprovar o correto funcionamento do programa.


Com este pequeno tutorial foi possível aprender alguns conceitos básicos mas bastante úteis para todos aqueles que se desejam iniciar no fantástico mundo do Arduino.

Código fonte disponível para download em anexo

Referências: http://playground.arduino.cc/code/bounce ; http://arduino.cc/en/Guide/Libraries ; Esquemas desenhados no Fritzing: http://fritzing.org/download/
« Última modificação: 22 de Setembro de 2013, 03:18 por samc »

Offline samc

  • Mini Robot
  • *
  • Mensagens: 390
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #1 em: 22 de Setembro de 2013, 00:27 »
Deixo aqui o meu primeiro tutorial no lusorobotica. O título não está muito "inspirado" porque o tutorial aborda diversos temas (embora especificamente seja sobre utilizar a biblioteca Bouce.h), mas estou aberto a sugestões e comentários.

Espero que seja de ajuda a alguns iniciados visto que a temática abordada envolve conceitos muito simples.

Offline dio123

  • Mini Robot
  • *
  • Mensagens: 927
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #2 em: 22 de Setembro de 2013, 00:31 »
quando tiver tempo vou ler com atenção,

 mas muitos parabens pela a iniciativa.

Offline almamater

  • Mini Robot
  • *
  • Mensagens: 1.505
    • GrcByte - Projectos
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #3 em: 22 de Setembro de 2013, 00:51 »
Aprende-se sempre alguma coisa, obrigado pela contribuição!

Offline Alfredo Garcia

  • Mini Robot
  • *
  • Mensagens: 400
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #4 em: 22 de Setembro de 2013, 12:34 »
É sempre bom ver alguém utilizar seu tempo para ajudar os outros.
Parabéns pela iniciativa.
PDI

Offline Kristey

  • Mini Robot
  • *
  • Mensagens: 753
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #5 em: 01 de Junho de 2014, 17:04 »
Explica-me aqui umas coisas:
quote
#define DEBOUNCE_TIME 5 // tempo em ms
Bounce aumentar = Bounce(AUMENTAR_PIN, DEBOUNCE_TIME);
Bounce diminuir = Bounce(DIMINUIR_PIN, DEBOUNCE_TIME);
fim quote

aqui estas a criar um objecto aumentar e um objecto diminuir, essas variaveis sao “preenchidas com uma funfção tambem com o mesmo nome “Bonce(PIN,Tempo de bonce).
Qual foi a razão de teres de fazer desta maneira?
aquilo que vejo é um tipo de objecto chemado Bouce e uma função com o mesmo nome isto é possivel?
Não está a fazer sentido para mim, e queria perceber em vez de simplesmente copiar.

depois a  função update ve se o objecto aumentar/diminuir teve uma alteração de estado e dá um intervalo de 250 ms para verificar o estado novamente, é isso?
Estes 250 ms podem ser ajustados perante teste ao bouce do botão ou é o mais indicado para qualquer situação?

Offline tarquinio

  • Mini Robot
  • *
  • Mensagens: 529
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #6 em: 01 de Junho de 2014, 23:24 »
Parabéns pelo tutorial, tá tudo bem explicadinho. :)

@Kristey: o intervalo depende dos interruptores, mas pode ser bem mais pequeno que 250ms. Eu costumo usar 10ms e geralmente podia usar bem menos. E se vires bem, os 250ms são outra coisa, o debounce time que ele está a usar são 5ms. 250ms é uma feature da library para repetir o clique automaticamente quando se fica a carregar no botão (tipo quando ficas a carregar numa letra num teclado e a letra vai repetindo automaticamente. Isto é uma feature da library e não tem nada a ver com o debounce. :P

Bounce aumentar = Bounce(AUMENTAR_PIN, DEBOUNCE_TIME);
aqui estas a criar um objecto aumentar e um objecto diminuir, essas variaveis sao “preenchidas com uma funfção tambem com o mesmo nome “Bonce(PIN,Tempo de bounce).
Ele está a criar uma variável chamada aumentar do tipo Bounce, e depois a inicializá-la com o construtor da mesma classe, é o normal.
ClasseXPTO nome = ClasseXPTO (parametro1, parametro2, etc...);
É uma maneira normal de inicializar classes com parâmetros.


Offline Kristey

  • Mini Robot
  • *
  • Mensagens: 753
Re: [Tutorial] Como ligar botões ao Arduino de uma forma "profissional"
« Responder #7 em: 02 de Junho de 2014, 05:27 »
Obrigado tarquinio.