HOWTO · Arduino
Arduino Attendi input
È possibile impostare Arduino in modo che attenda l'input utilizzando la funzione Serial.available() e la funzione digitalRead().
In questa pagina
Scegli la sorgente di input in base al segnale: usa l’input seriale per i byte inviati da un computer o da un altro dispositivo, digitalRead() per un pin con due stati, come quello di un pulsante, e analogRead() per confrontare la lettura di un sensore con una soglia. Gli sketch Arduino seguenti usano l’API standard di Arduino. I relativi harness portabili in C++ usano sostituti deterministici dell’hardware della scheda, così puoi compilare e seguire la logica di gestione dell’input senza una scheda Arduino; non verificano il comportamento elettrico.
Scegli la sorgente di input: seriale, digitale o analogica
Usa la comunicazione seriale quando un dispositivo host invia caratteri o comandi tramite USB o una connessione UART. Usa un pin digitale quando il segnale ha due stati. Usa un ingresso analogico quando il sensore produce una tensione variabile da campionare e confrontare. Scegli il pin di ingresso e il collegamento elettrico in base alla scheda e al sensore; gli esempi usano il pin 2 per un pulsante e A0 per un sensore analogico.
Attendi dati seriali con Serial.available()
Serial.available() indica quanti byte sono in attesa nel buffer di ricezione. Controlla questo valore prima di chiamare Serial.read(), così lo sketch non tenta di leggere quando non è pronto alcun byte. Questo esempio legge e restituisce un byte alla volta, una soluzione adatta a un semplice comando costituito da un carattere. Non compone una riga completa: per i comandi basati su righe, raccogli i byte fino al carattere di nuova riga e gestisci esplicitamente il terminatore.
Esegui questo harness portabile per osservare il modello di gestione dei byte. In uno sketch Arduino, mantieni setup() e loop() e usa l’oggetto Serial della scheda al posto del piccolo sostituto mostrato qui.
#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
Imposta il monitor seriale o il dispositivo di invio alla stessa velocità di trasmissione. Poiché Serial.read() restituisce il valore intero di un byte, l’esempio stampa un rapporto numerico del byte con etichetta: l’etichetta Received byte: seguita dal valore numerico del byte; converti il valore in char se vuoi stampare il carattere corrispondente.
Attendi un input digitale con digitalRead()
Un input digitale si legge dal suo pin, non dalla porta seriale. Se colleghi un pulsante tra il pin 2 e la massa, configura INPUT_PULLUP: quando il pulsante è rilasciato lo stato letto è HIGH, mentre quando è premuto è LOW. Il ciclo qui sotto attende prima la pressione e poi il rilascio. Questa attesa tramite polling sospende le altre attività di loop() finché non si verifica la condizione attesa.
Questo harness portabile fornisce una sequenza di stati del pin alla stessa logica di attesa. Nello sketch Arduino, sostituisci le funzioni sostitutive con le API pinMode() e digitalRead() della scheda.
#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
La resistenza di pull-up interna mantiene l’ingresso a un livello definito quando il pulsante è aperto. Se invece il circuito collega il pulsante all’alimentazione positiva e usa una resistenza esterna di pull-down, usa INPUT e verifica HIGH quando il pulsante è premuto. Assicurati che la polarità nel codice corrisponda al circuito, per evitare un ingresso flottante o una risposta invertita.
Attendi il superamento di una soglia analogica con analogRead()
analogRead() campiona la tensione su un pin analogico e restituisce una lettura numerica. Confronta questa lettura con una soglia scelta in base al sensore e alla scheda. Questo sketch segnala quando una lettura campionata supera la soglia, anche già al primo passaggio se la condizione è vera. Dopo averla segnalata, attende che un campione successivo sia pari o inferiore alla soglia prima di poterla segnalare di nuovo.
Questo harness portabile fornisce due letture: la prima è superiore alla soglia e la successiva è pari o inferiore. Sulla scheda, il core Arduino mette a disposizione A0 e analogRead(); i pin disponibili e l’intervallo delle letture dipendono dalla scheda.
#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
L’intervallo numerico e la tensione rappresentata da analogRead() dipendono dalla scheda. Consulta la relativa documentazione e calibra threshold in base alle letture del sensore. Si tratta di campionare e confrontare ripetutamente, non di attendere byte seriali.
Evita di bloccare il resto dello sketch
Un ciclo while stretto continua a controllare l’input, ma impedisce al resto di loop() di essere eseguito finché la condizione non cambia. È utile quando lo sketch deve fermarsi in quel punto, ma ritarda altre attività, come aggiornare un display o controllare un altro ingresso. Se lo sketch deve continuare a lavorare, controlla l’input una volta per passaggio e memorizzane lo stato, invece di attendere dentro un ciclo. Per esempio, usa if (Serial.available() > 0) per elaborare i byte disponibili e poi proseguire con il resto di loop().
Se lo sketch sembra non rispondere, verifica che il pin scelto corrisponda al cablaggio, che l’ingresso digitale abbia un livello definito, che il dispositivo seriale trasmetta alla velocità configurata e che la soglia analogica sia compatibile con l’intervallo di lettura della scheda. Inoltre, un’attesa bloccante non termina finché lo stato controllato non cambia.