HOWTO · Arduino

Arduino espera por entrada

Pode-se configurar o Arduino para esperar pela entrada usando a função Serial.available() e a função digitalRead().

Nesta página

Escolha a fonte de entrada que corresponde ao sinal: use a entrada serial para bytes enviados por um computador ou outro dispositivo, digitalRead() para um pino ligado ou desligado, como o de um botão, e analogRead() para comparar a leitura de um sensor com um limite. Os sketches Arduino abaixo usam a API padrão do Arduino. Os harnesses portáveis em C++ que os acompanham usam substitutos determinísticos para o hardware da placa, permitindo compilar e acompanhar a lógica de tratamento da entrada sem uma placa Arduino; eles não testam o comportamento elétrico.

Escolha a fonte de entrada: serial, digital ou analógica

Use a entrada serial quando um dispositivo host enviar caracteres ou comandos por USB ou por uma conexão UART. Use um pino digital quando o sinal tiver dois estados. Use uma entrada analógica quando o sensor produzir uma tensão variável que você precise amostrar e comparar. Escolha o pino de entrada e a configuração elétrica adequados à sua placa e ao sensor; os exemplos usam o pino 2 para um botão e A0 para um sensor analógico.

Aguarde dados seriais com Serial.available()

Serial.available() informa quantos bytes estão aguardando no buffer de recepção. Verifique esse valor antes de chamar Serial.read() para que o sketch não tente ler quando nenhum byte estiver pronto. Este exemplo consome e ecoa um byte por vez, o que serve para um comando simples de caractere. Ele não monta uma linha completa; para comandos baseados em linhas, acumule os bytes até uma quebra de linha e trate explicitamente o terminador da linha.

Execute este harness portátil para observar o padrão de tratamento de bytes. Em um sketch Arduino, mantenha setup() e loop() e use o objeto Serial da placa no lugar do pequeno substituto mostrado aqui.

#include <iostream>

class SerialPort {
 public:
  void begin(int) {}
  int available() const { return next_ < 1; }
  int read() { ++next_; return 65; }
  void print(const char* text) { std::cout << text; }
  void println(int value) { std::cout << value << '\n'; }

 private:
  int next_ = 0;
};

SerialPort Serial;

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (Serial.available() > 0) {
    int incomingByte = Serial.read();
    Serial.print("Received byte: ");
    Serial.println(incomingByte);
  }
}

int main() {
  setup();
  loop();
}
Received byte: 65

Configure o monitor serial ou o dispositivo transmissor para usar a mesma taxa de transmissão. Como Serial.read() retorna o valor inteiro de um byte, o exemplo imprime um relatório numérico do byte com rótulo: o rótulo Received byte: seguido do valor numérico do byte; converta-o para char quando quiser imprimir o próprio caractere.

Aguarde uma entrada digital com digitalRead()

Uma entrada digital é lida pelo pino, não pela porta serial. Para um botão ligado entre o pino 2 e o terra, configure INPUT_PULLUP: quando o botão não está pressionado, a leitura é HIGH; quando está pressionado, a leitura é LOW. O loop abaixo aguarda o pressionamento e, em seguida, a liberação. Essa espera por consulta repetida pausa as outras tarefas de loop() enquanto aguarda qualquer uma dessas condições.

Este harness portátil fornece uma sequência de estados do pino para a mesma lógica de espera. No sketch Arduino, substitua as funções auxiliares pelas APIs pinMode() e digitalRead() da placa.

#include <iostream>

const int INPUT_PULLUP = 2;
const int HIGH = 1;
const int LOW = 0;
const int buttonPin = 2;
int pinStates[] = {HIGH, LOW, LOW, HIGH};
int stateIndex = 0;

void pinMode(int, int) {}
int digitalRead(int) { return pinStates[stateIndex++]; }

class SerialPort {
 public:
  void begin(int) {}
  void println(const char* text) { std::cout << text << '\n'; }
};

SerialPort Serial;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  while (digitalRead(buttonPin) == HIGH) {
  }

  Serial.println("Button pressed");

  while (digitalRead(buttonPin) == LOW) {
  }
}

int main() {
  setup();
  loop();
}
Button pressed

O resistor pull-up interno mantém a entrada em um nível definido quando o botão está aberto. Se, em vez disso, o circuito ligar o botão à alimentação positiva e usar um resistor pull-down externo, use INPUT e verifique se o estado é HIGH quando o botão estiver pressionado. Ajuste a polaridade do código ao circuito para evitar uma entrada flutuante ou uma resposta invertida.

Aguarde um limite analógico com analogRead()

analogRead() amostra a tensão em um pino analógico e retorna uma leitura numérica. Compare essa leitura com um limite escolhido para o seu sensor e a sua placa. Este sketch informa quando uma leitura amostrada está acima do limite, inclusive na primeira passagem, se essa condição já for verdadeira. Depois de informar, ele aguarda até que uma leitura posterior esteja no limite ou abaixo dele para poder informar novamente.

Este harness portátil fornece duas leituras: uma acima do limite e a seguinte no limite ou abaixo dele. Na placa, o núcleo do Arduino fornece A0 e analogRead(); os pinos disponíveis e o intervalo de leitura dependem da placa.

#include <iostream>

const int A0 = 0;
const int sensorPin = A0;
const int threshold = 500;
int readings[] = {600, 450};
int readingIndex = 0;

int analogRead(int) { return readings[readingIndex++]; }

class SerialPort {
 public:
  void begin(int) {}
  void println(const char* text) { std::cout << text << '\n'; }
};

SerialPort Serial;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(sensorPin);

  if (sensorValue > threshold) {
    Serial.println("Threshold exceeded");

    while (analogRead(sensorPin) > threshold) {
    }
  }
}

int main() {
  setup();
  loop();
}
Threshold exceeded

O intervalo numérico e a tensão representados por analogRead() dependem da placa. Consulte a documentação dela e calibre threshold com base nas leituras do sensor. Isso é amostragem e comparação repetidas, não uma espera por bytes seriais.

Evite bloquear o restante do sketch

Um loop while apertado continua verificando a entrada, mas impede que o restante de loop() seja executado até que a condição mude. Isso é útil quando o sketch deve parar naquele ponto, mas atrasa outras tarefas, como atualizar um visor ou verificar outra entrada. Se o sketch precisar continuar funcionando, verifique a entrada uma vez por passagem e registre o estado em vez de esperar dentro de um loop. Por exemplo, use if (Serial.available() > 0) para processar os bytes disponíveis e continuar com o restante de loop().

Se o sketch parecer não responder, confira se o pino escolhido corresponde à fiação, se a entrada digital tem um nível definido, se o transmissor serial usa a taxa de transmissão configurada e se o limite analógico corresponde ao intervalo de leitura da placa. Uma espera bloqueante também não terminará até que o estado verificado mude.