Pulsante PCB Mini, 6x6x5 mm, 2 pin, normalmente aperto, 12V 50mA

Questo tutorial utilizza la scheda Arduino Uno R3, perché un pulsante a 2 pin non può funzionare da solo. Esso apre o chiude un contatto, e un microcontrollore deve leggere lo stato di questo contatto. Il pulsante tattile PCB Mini 6x6x5 mm è un interruttore SPST normalmente aperto, con due pin per il montaggio su foro passante o su breadboard. Lo userete in progetti per l'accensione, il reset, la selezione di una modalità, la conferma di un'impostazione o il comando manuale di una funzione.

Come funziona:

A riposo, i due pin del pulsante non sono collegati tra loro. Quando premete il cappuccio, un contatto metallico interno li collega elettricamente e, finché tenete premuto, la corrente può passare da un pin all'altro. Al rilascio, una molla riporta il contatto in posizione aperta. I pin non hanno polarità, quindi qualsiasi pin può andare a una qualsiasi delle due connessioni.

Un contatto aperto lasciato scollegato non fornisce un valore logico sicuro, e il pin Arduino leggerebbe rumore. Per questo usiamo la resistenza pull-up interna del microcontrollore ATmega328P, attivata con pinMode(2, INPUT_PULLUP). Questa resistenza, di circa 20 - 50 kohm, porta il pin D2 verso 5 V. Con il pulsante libero, il pin legge HIGH. Quando premete, il pulsante collega D2 a GND e il pin legge LOW. La logica è quindi invertita: premuto significa LOW.

La corrente attraverso il pulsante è molto piccola. Con 5 V e una resistenza interna di 20 kohm passa al massimo 5 V / 20 kohm = 0.25 mA, ben al di sotto del limite di 50 mA a 12 V DC dei pulsanti tattili di questo tipo.

I contatti metallici non si chiudono in modo netto, ma vibrano per alcuni millisecondi (effetto bounce). Senza protezione, una sola pressione può essere letta come più pressioni. Il programma del tutorial ignora le variazioni più brevi di 30 ms, un intervallo sufficiente per i piccoli pulsanti tattili.

Collegamento:

Alimentate la scheda Arduino Uno R3 tramite il cavo USB A-B collegato al computer, a 5 V. Non avete bisogno di una resistenza esterna, di un convertitore di livello o di un'altra alimentazione. Non collegate il pulsante a 5 V o a 3.3 V, ma solo al pin D2 e a GND. Se usate una breadboard, posizionate il pulsante in modo che i due pin si trovino su file diverse.

I numeri 1 e 2 sono solo etichette nello schema, sul pulsante i pin non sono contrassegnati e possono essere usati in qualsiasi ordine.

Pulsanti, regolazioni e indicatori:

Il pulsante non ha potenziometri, jumper o interruttori di regolazione. La posizione di partenza è il pulsante libero, con il LED L spento e il pin D2 su HIGH.

Per verificare il funzionamento, premete il pulsante. Il LED L sulla scheda deve accendersi immediatamente, e il monitor seriale deve mostrare un messaggio di pressione. Al rilascio, il LED si spegne e compare un messaggio di rilascio.

La pressione breve e quella lunga non hanno significati diversi in questo programma, il pulsante si limita a segnalare lo stato in tempo reale.

Scheda e librerie:

In Arduino IDE selezionate da Tools > Board la scheda Arduino Uno, dal pacchetto Arduino AVR Boards. Questo pacchetto è installato insieme ad Arduino IDE, e se manca lo installate da Boards Manager. In Tools > Port scegliete la porta COM della scheda.

Il programma usa solo le funzioni di base di Arduino, quindi non è necessario installare alcuna libreria.

Il codice:

Il programma controlla il pulsante sul pin D2, filtra le vibrazioni dei contatti, accende il LED L finché il pulsante è premuto e conta le pressioni.

/*
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Libraries: none needed, only the core Arduino functions are used
  Wiring:
    Button pin 1 -> GND (the GND pin next to AREF)
    Button pin 2 -> D2
  The internal pull-up resistor is used, so no external resistor is needed.
*/
const uint8_t BUTTON_PIN = 2;               // Digital pin connected to the button
const uint8_t LED_PIN = 13;                 // Built-in LED "L" on the Arduino Uno
const unsigned long DEBOUNCE_MS = 30;       // Time a new state must stay stable
int lastReading = HIGH;                     // Last raw reading of the button pin
int stableState = HIGH;                     // Last confirmed (debounced) state
unsigned long lastChangeTime = 0;           // Moment of the last raw change
unsigned long pressCount = 0;               // Number of confirmed presses
void setup() {
  Serial.begin(9600);                       // Start the serial monitor at 9600 baud
  pinMode(BUTTON_PIN, INPUT_PULLUP);        // Enable the internal pull-up: released = HIGH, pressed = LOW
  pinMode(LED_PIN, OUTPUT);                 // LED pin as output
  digitalWrite(LED_PIN, LOW);               // Start with the LED off
  Serial.println("Button test started");
  Serial.println("Button on pin D2, internal pull-up enabled");
  Serial.println("Button released (idle)");
}
void loop() {
  int reading = digitalRead(BUTTON_PIN);    // Read the raw state of the button
  // If the raw reading changed, restart the debounce timer
  if (reading != lastReading) {
    lastChangeTime = millis();
    lastReading = reading;
  }
  // Accept the new state only if it stayed unchanged longer than DEBOUNCE_MS
  if ((millis() - lastChangeTime) > DEBOUNCE_MS && reading != stableState) {
    stableState = reading;
    if (stableState == LOW) {
      // LOW means the contacts are closed: the button is pressed
      digitalWrite(LED_PIN, HIGH);          // Turn the LED on
      pressCount++;                         // Count the press
      Serial.print("Button PRESSED - LED on - press count: ");
      Serial.println(pressCount);
    } else {
      // HIGH means the contacts are open: the button is released
      digitalWrite(LED_PIN, LOW);           // Turn the LED off
      Serial.println("Button released - LED off");
    }
  }
}

Come funziona il codice:

All'inizio definiamo le costanti. BUTTON_PIN è il pin 2, dove è collegato il pulsante, LED_PIN è il pin 13 del LED L sulla scheda, e DEBOUNCE_MS è il tempo di 30 ms in cui una variazione deve rimanere stabile per essere accettata.

Le variabili lastReading e stableState memorizzano l'ultima lettura grezza e l'ultimo stato confermato, entrambe partendo da HIGH, cioè pulsante libero. La variabile lastChangeTime memorizza il momento dell'ultima variazione grezza, mentre pressCount conta le pressioni confermate.

In setup() avviamo il monitor seriale a 9600 baud, attiviamo la resistenza interna con pinMode(BUTTON_PIN, INPUT_PULLUP), impostiamo LED_PIN come uscita e lo spegniamo, quindi visualizziamo i messaggi di avvio.

In loop() leggiamo il pin con digitalRead(). Se la lettura grezza è diversa da lastReading, riavviamo il cronometro con millis(). Quando lo stato resta invariato per più di DEBOUNCE_MS e differisce da stableState, lo consideriamo confermato. Se è LOW, accendiamo il LED, aumentiamo pressCount e visualizziamo il numero della pressione. Se è HIGH, spegniamo il LED e visualizziamo il messaggio di rilascio.

Risultato:

Aprite il monitor seriale di Arduino IDE a 9600 baud. All'avvio compaiono i messaggi di start, poi un messaggio per ogni pressione e rilascio del pulsante.

Button test started
Button on pin D2, internal pull-up enabled
Button released (idle)
Button PRESSED - LED on - press count: 1
Button released - LED off
Button PRESSED - LED on - press count: 2
Button released - LED off
Button PRESSED - LED on - press count: 3
Button released - LED off

Problemi frequenti:

Non appare nulla sul monitor seriale. La causa è di solito la porta o la velocità sbagliata. Selezionate la porta corretta da Tools > Port e impostate il monitor seriale a 9600 baud.

Il pulsante sembra premuto sempre o non reagisce. La causa può essere un pin collegato a un pin diverso da D2 o GND, oppure un pulsante montato sulla breadboard con entrambi i pin sulla stessa fila, nel qual caso il contatto è in cortocircuito. Spostate un pin su un'altra fila e controllate i collegamenti.

Una sola pressione viene contata più volte. La causa è la vibrazione dei contatti. Mantenete il filtraggio nel programma e, se il pulsante è molto usurato, portate DEBOUNCE_MS a 50 ms.

I valori sembrano invertiti. Con il pull-up interno, il pulsante libero legge HIGH e quello premuto legge LOW. Questo è il comportamento normale e non un guasto.

Le letture sono instabili quando i fili sono lunghi. La causa è il rumore captato dai fili. Accorciate i fili e mantenete la massa comune sul percorso più breve.

Limiti e consigli:

I contatti del pulsante supportano 12 V DC e 50 mA, quindi sono destinati ai segnali di comando. Per carichi più grandi, comandate un relè o un transistor dal microcontrollore, non direttamente tramite il pulsante. Non usate il pulsante per la tensione di rete.

Con lo stesso montaggio potete costruire un contatore di pressioni, un interruttore con memoria che cambia lo stato del LED a ogni pressione, un menu con più pulsanti o un rilevamento della pressione lunga, misurando con millis() per quanto tempo il pin resta su LOW.