Arduino digitalRead(), num botão e um LED
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
digitalRead(pin) olha a tensão num pino e retorna HIGH (1) ou LOW (0). Primeiro configure o pino com pinMode(pin, INPUT_PULLUP) e ligue um botão do pino ao terra: ele lê HIGH até o botão ser apertado e LOW enquanto está segurado. Isso é tudo o que há para ler um botão.
O circuito acima é exatamente isso: um botão no pino 2 e um LED no pino 13 de um Uno. Aperte Rodar e depois segure o botão. O pino 2 fica em 5 V até o botão puxá-lo para 0 V, digitalRead() vê LOW, e o LED acende. Solte e ele apaga.
Abaixo está por que o pull-up importa, o que lê um pino sem nada ligado, a tensão em que LOW vira HIGH e por que um aperto pode ser lido milhares de vezes, cada coisa testada num Uno no Mokxi com o que ele imprimiu.
Quer a versão passo a passo? A aula "Ler um pino e o pull-up" percorre isso com checkpoints.
Abrir a aulaO sketch: pinMode e depois digitalRead
Aqui está o sketch rodando acima. pinMode(BUTTON_PIN, INPUT_PULLUP) torna o pino 2 uma entrada e liga um resistor dentro do chip que o puxa para 5 V. No loop(), digitalRead(BUTTON_PIN) == LOW é verdadeiro enquanto o botão está segurado, e o LED acompanha.
É por isso que apertado lê LOW, o que surpreende todo mundo na primeira vez. O botão conecta o pino ao terra; o pull-up é o que faz ele ler HIGH o resto do tempo. Se você prefere pensar em "apertado é verdadeiro", escreva bool pressed = digitalRead(2) == LOW; uma vez e use pressed daí em diante.
const int BUTTON_PIN = 2;
void setup() {
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
bool pressed = digitalRead(BUTTON_PIN) == LOW;
digitalWrite(LED_BUILTIN, pressed ? HIGH : LOW);
delay(5);
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Um pino sem nada ligado lê ruído
Com pinMode(2, INPUT) simples e nada puxando o pino para qualquer lado, ele flutua, e qualquer carga perdida por perto decide o que ele lê. Vinte leituras, dez milissegundos de intervalo, imprimiram 00111111010100110100. Uma placa real faz o mesmo, e um botão ligado sem resistor nenhum se comporta assim sempre que não está apertado: apertos aleatórios que ninguém deu.
Ligue o pull-up e as mesmas vinte leituras imprimiram 11111111111111111111. Use INPUT_PULLUP com o botão ao terra, como acima, ou INPUT com seu próprio resistor, 10 k do pino para 5 V ou para o terra. A página do resistor de pull-up desenha os dois.
void setup() {
Serial.begin(9600);
pinMode(2, INPUT);
for (int i = 0; i < 20; i++) {
Serial.print(digitalRead(2));
delay(10);
}
Serial.println();
pinMode(2, INPUT_PULLUP);
for (int i = 0; i < 20; i++) {
Serial.print(digitalRead(2));
delay(10);
}
Serial.println();
}
void loop() {
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
O que conta como HIGH
Um pino digital responde sim ou não, mas a tensão nele pode ser qualquer coisa de 0 a 5 V. O datasheet do ATmega328P garante LOW abaixo de 1,5 V e HIGH acima de 3 V num Uno de 5 V, e deixa o espaço entre os dois por conta do chip. Colocamos um potenciômetro no pino 2 e no A0 e giramos devagar para baixo e de volta para cima. Descendo, o pino virou LOW a 2184 mV; subindo de volta, só virou HIGH de novo a 2619 mV.
Essa faixa é proposital. Um pino que mudasse de estado em uma tensão exata ficaria oscilando para frente e para trás com um sinal que varia devagar; com a faixa, ele muda de ideia uma única vez. Ela também mostra que o HIGH de um sensor de 3,3 V, bem acima de 3 V, é lido como HIGH em um Uno de 5 V, e que um sinal fraco de 2 V é uma loteria. Para qualquer coisa no meio, leia com analogRead().
void setup() {
Serial.begin(9600);
pinMode(2, INPUT);
}
void loop() {
static int last = -1;
int v = digitalRead(2);
if (v != last) {
last = v;
long mv = analogRead(A0) * 5000L / 1023;
Serial.print(mv);
Serial.print(" mV -> ");
Serial.println(v);
}
delay(2);
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Um aperto, lido milhares de vezes
O loop() roda muito mais rápido do que um dedo. Seguramos o botão por meio segundo e contamos: cerca de 47.800 passagens pelo loop() viram o pino em LOW. Um sketch que soma pontos à pontuação sempre que o pino está LOW soma cerca de 47.800 pontos por aperto. Para contar apertos, guarde a última leitura e aja apenas quando ela mudar de HIGH para LOW.
Até isso contou 4 apertos para o nosso único. Os contatos de um botão de pressão oscilam por alguns milissegundos quando fecham e abrem, e o botão do Mokxi oscila como um de verdade faria, então o sketch viu o pino ir para LOW quatro vezes separadas. A página de debounce do botão mostra como esperar a oscilação passar com millis().
const int BUTTON = 2;
long held = 0;
int presses = 0;
int last = HIGH;
void setup() {
Serial.begin(9600);
pinMode(BUTTON, INPUT_PULLUP);
}
void loop() {
int now = digitalRead(BUTTON);
if (now == LOW) held++;
if (now == LOW && last == HIGH) presses++;
last = now;
if (millis() >= 1500) {
Serial.print("loops that saw LOW: ");
Serial.println(held);
Serial.print("presses: ");
Serial.println(presses);
while (true) {
}
}
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Pinos de saída, pinos analógicos e um = errado
O digitalRead() funciona em qualquer pino. Em um pino configurado como OUTPUT, ele lê de volta o que você escreveu por último: depois de digitalWrite(13, HIGH) imprimiu 1, depois de LOW imprimiu 0. Essa é uma forma rápida de inverter um pino: digitalWrite(13, !digitalRead(13));. Os pinos analógicos de um Uno também são pinos digitais: A0 ligado a 5 V imprimiu 1 e A1 ligado ao terra imprimiu 0.
HIGH e LOW são simplesmente 1 e 0, e Serial.println(digitalRead(2)) imprime o número. Compare com dois sinais de igual. if (digitalRead(2) = HIGH) interrompe a compilação: o clang do Mokxi diz expression is not assignable, e o GCC da IDE do Arduino diz lvalue required as left operand of assignment.
Abra este circuito no editor. Arduino Uno: um botão no pino 2 acende o LED do pino 13, ligado como no exemplo que roda no topo desta página. Troque um componente ou um valor e rode de novo.
Perguntas
Por que o digitalRead retorna LOW quando o botão está pressionado?
Porque o botão liga o pino ao terra, e o INPUT_PULLUP mantém o pino em 5 V o resto do tempo. Pressionado é LOW, solto é HIGH. Compare com LOW, ou escreva bool pressed = digitalRead(pin) == LOW;.
Por que o meu digitalRead muda aleatoriamente?
O pino está flutuando: nada o mantém em HIGH ou LOW. Use pinMode(pin, INPUT_PULLUP) com o botão ligado ao terra, ou adicione um resistor de 10 k do pino para 5 V ou para o terra.
Posso usar digitalRead em um pino analógico?
Sim. Em um Uno, A0 a A5 também são pinos digitais, e digitalRead(A0) retorna HIGH ou LOW. (Em um Nano, A6 e A7 são apenas analógicos.)
Que tensão o digitalRead considera HIGH?
Em um Uno de 5 V, qualquer coisa acima de 3 V é garantidamente HIGH e qualquer coisa abaixo de 1,5 V é garantidamente LOW. No meio, o pino mantém por um tempo a última resposta: no nosso teste ele caiu para LOW a cerca de 2,2 V e subiu para HIGH de novo a cerca de 2,6 V.
Preciso de pinMode antes do digitalRead?
Os pinos começam como entradas, então digitalRead funciona sem ele, mas o pino fica flutuando. Chame pinMode(pin, INPUT_PULLUP) ou pinMode(pin, INPUT) no setup() para deixar claro para que serve o pino e como ele é mantido.
Continuar
De onde vêm as informações desta página
Monte isto de verdade
Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.