(di nuovo…) Alla scoperta di Arduino

Quasi tutti, almeno per sentito dire, sappiamo cosa è Arduino; una piattaforma hardware Open Source realizzata dall’italiano Massimo Banzi (www.arduino.cc).
E’ sicuramente una cosa di cui l’elettronica e l’informatica di casa nostra possono andare orgogliose.
Di Arduino si è detto di tutto e si è fatto di tutto; dal semplice lampeggiare di un led, a sistemi molto complessi (centraline domotiche, meteorologiche) fino al controllo di droni.
Uno dei tanti vantaggi di questa piattaforma è il basso costo, la semplicità di programmazione (sul sito ufficiale e su moltissimi altri siti dedicati, si possono trovare una moltitudine di esempi e guide) e, cosa non secondaria, l’architettura Open Source. Questo ha contribuito a creare una comunità di sviluppatori decisamente invidiabile, sempre pronta a rispondere a chi si trova in difficoltà.
Dal sito ufficiale si può scaricare l’ambiente di sviluppo (disponibile per tutte le principali piattaforme) che comprende anche molti esempi perfettamente fuzionanti per cominciare a divertirsi con questa piattaforma.

A cosa serve Arduino? Il limite è la fantasia e la necessità che si deve risolvere. C’è chi ha completamente automatizzato la distribuzione di cibo dell’acquario (https://www.youtube.com/watch?v=ec7COnXJWLA), chi lo usa come centralina di irrigazione (https://www.youtube.com/watch?v=EOFGDANXZMI) e chi lo usa per comandare stampanti 3D.

Printer3D

Per usare Arduino senza problemi, è sicuramente utile avere delle basi di elettronica, oltre che di informatica. È praticamente all’ordine del giorno avere a che fare con componenti elettronici, saldatore a stagno ecc.

Anche noi stiamo esplorando il mondo di Arduino.

Prima di cimentarci con progetti faraonici (per ora non abbiamo in programma di lanciare sonde su comete 🙂 ), ci stiamo divertendo con lavoretti poco più che accademici.

Mi ha molto incuriosito un articolo che spiega come poter gestire 3 pulsanti usando solo 2 canali di entrata di Arduino (potete leggere l’articolo qui http://www.leonardomiliani.com/2014/gestire-3-pulsanti-con-2-soli-pin/)

Mi sono chiesto: quanti pulsanti potremmo gestire con 3 pin (canali in entrata).
La risposta è 7. Sono necessari, inoltre, 8 diodi, per sfruttare la loro caratteristica di condurre solo in un verso.

Ho quindi preso l’esempio molto ben fatto nell’articolo citato prima e ho cominciato a modificarlo.

Ecco lo schema elettrico risultante:

Schema 8 pulsanti

Proviamo il circuito. C’è bisogno di:

– una breadboard
– 8 diodi (vanno benissimo diodi comuni)
– 7 pulsanti di tipo da montaggio superficiale
– cavetti
– una scheda Arduino (UNO, Yun o simile)

Qui vedete lo schema fatto con Fritzing

Schema con Fritzing

Il sistema usato è il seguente: i pin sono messi in stato HIGH (con l’opzione PULLUP per usare la resistenza interna evitando così di usare resistenze esterne.
Con i diodi opportunamente collegati, la pressione dei pulsanti porta allo stato LOW i pin (uno, due o tutti e tre).

Dalla tabella della verità vediamo le combinazioni:

 ---------------------------------
  PIN5 | PIN6 | PIN7 | BUTTON
 ---------------------------------
 |  1  |   1  |   0  | button 1 ON
 |  1  |   0  |   1  | button 2 ON
 |  1  |   0  |   0  | button 3 ON
 |  0  |   1  |   1  | button 4 ON
 |  0  |   1  |   0  | button 5 ON
 |  0  |   0  |   1  | button 6 ON
 |  0  |   0  |   0  | button 7 ON


Il circuito di test.

breadboard

Il circuito di test.

Ed ecco lo sketch:

——————————————————–

/* HOW TO READ 7 BUTTONS USING JUST 3 PIN
  Edited by Paolo Duina ( https://www.voxart.it )
  Based on the original from Leonardo Miliani
http://www.leonardomiliani.com


---------------------------------
 PIN5 | PIN6 | PIN7 | BUTTON ON
---------------------------------
|  1  |   1  |   0  | button 1 ON
|  1  |   0  |   1  | button 2 ON
|  1  |   0  |   0  | button 3 ON
|  0  |   1  |   1  | button 4 ON
|  0  |   1  |   0  | button 5 ON
|  0  |   0  |   1  | button 6 ON
|  0  |   0  |   0  | button 7 ON

  Code released under the Creative Commons License
  CC-BY-SA 3.0 or any newer 

  V. 1.0 - 20141229
*/

//pins declaration - use any pin you like
const byte IN1 = 5;
const byte IN2 = 6;
const byte IN3 = 7;
byte oldreading;

//setup function
void setup() {
  //setting the mode of the pins
  pinMode(IN1, INPUT_PULLUP);
  pinMode(IN2, INPUT_PULLUP);
  pinMode(IN3, INPUT_PULLUP);

  Serial.begin(9600); //opening the serial
  delay(2000); //a little delay to let the user open the serial monitor
  Serial.println(F("Begin"));
}

//main loop
void loop() {
  byte reading = readButtons(IN1, IN2, IN3); //read the buttons
  if (reading) { //a button has been pressed
    if (reading != oldreading)
    {
    switch(readButtons(IN1, IN2, IN3)) {
      case 1: //button 1 pressed
        Serial.println(F("Button 1 pressed"));
        break;
      case 2: //button 2 pressed
        Serial.println(F("Button 2 pressed"));
        break;
      case 3: //button 3 pressed
        Serial.println(F("Button 3 pressed"));
        break;
      case 4: //button 4 pressed
        Serial.println(F("Button 4 pressed"));
        break;
      case 5: //button 5 pressed
        Serial.println(F("Button 5 pressed"));
        break;
      case 6: //button 6 pressed
        Serial.println(F("Button 6 pressed"));
        break;
      case 7: //button 7 pressed
        Serial.println(F("Button 7 pressed"));
        break;
    }
    

    }
  }
   oldreading = reading;
  delay(100); //a little delay - remove if unnecessary
}

//read the buttons
byte readButtons(byte inputPin1, byte inputPin2, byte inputPin3) {
  byte response = 0;

  //I'm using the inverted logic so I do a "not" (!) to the digital read
  //then I combine the readings in a sngle bit using the 2 binary digits
  response = (((!digitalRead(inputPin1))<<2) | ((!digitalRead(inputPin2))<<1)| !digitalRead(inputPin3));
//   Serial.println(response);
  return response;
}

——————————————————–

 

Premendo i vari pulsanti, sul monitor seriale compare il numero del pulsante premuto.

La variabile oldreading, come avrete sicuramente già capito, serve ad evitare scritture multiple sul monitor seriale, a fronte di una sola pressione di un pulsante (che il ciclo di loop legge molte volte velocemente).