Arduino N° 92 - Elettrovalvola bistabile con comando bluetooth

< Arduino N° 91

Achille De Santis

> Arduino N°  93

  

Sul post Arduino n° 90 ho presentato una guida dimostrativa dell'applicazione di una elettrovalvola bistabile a comando impulsivo.
In questo post vi presento un'altra applicazione di Arduino per il comando di una elettrovalvola bistabile, con comando impulsivo in bassa tensione, pilotato attraverso un collegamento Bluetooth.

Fig. 1: schema generale dei collegamenti; 

Naturalmente, per operare il comando via bluetooth serve un terminale di comando, nella fattispecie un telefono Android o un tablet; in alternativa, si potrebbe utilizzare un telefono I-phone o un I-pad, con piccole modifiche dal lato bluetooth.

    Il dispositivo è stato da me ideato e realizzato per applicazioni domotiche ma viene qui presentato come dispositivo di comando di piccole pompe per circolazione di acqua, come è possibile vederne gli effetti negli impianti di irrigazione, nei plastici di vario genere, compresi quelli dei presepi.

Lascio, qui, al lettore il piacere della ricerca delle applicazioni possibili. 

Le caratteristiche del dispositivo si possono riassumere nelle seguenti:

• Comando "locale" START/STOP, da quadro comandi;
• Comando "remoto" START/STOP da interfaccia bluetooth; 
• Funzionamento "bistabile": lo stato attuale viene mantenuto anche in assenza di alimentazione. 

    Entrambi i comandi sono impulsivi e necessitano di un attuatore bistabile a comando impulsivo. Questa scelta è stata operata per ridurre la corrente di attuazione ed è molto adatta ad interventi saltuari nel tempo.

In mancanza di energia elettrica l'elettrovalvola mantiene lo stato precedente (aperto/chiuso) ma la pompa ad essa associata si blocca, interrompendo il flusso idrico.

 

    L'alimentazione del dispositivo può andare da 9 Volt a 12 Volt C.C. Al di sotto di 6-7 Volt l'attuatore potrebbe avere delle incertezze o non funzionare. La pila da 9 volt può essere sostituita da un piccolo alimentatore, adatto a pilotare anche la logica di controllo, attraverso il ponte ad H con L298N, predisponendo in esso gli opportuni cavallotti.

La piccola resistenza da 10 Ohm, posta sui piedini di uscita della configurazione a ponte (v. fig. 1), rappresenta il carico e deve essere scollegata quando si collegherà al suo posto la bobina dell'elettrovalvola a 5 volt.

    Una variante allo schema presentato potrebbe essere costituita dall'uso di un modulo "ponte ad H" di maggiore potenza, con l'integrato L298N che trovate facilmente già montato.

Nello schema presentato manca soltanto il collegamento della scheda Bluetooth HC-05/HC06 ai piedini 0 e 1 per i comandi via seriale bluetooth.

    Volutamente, questa volta non presento lo sketch ma lascio al lettore l'onere del suo sviluppo. Vedremo come va a finire! Lo sketch ed il dispositivo sono stati comunque provati e collaudati, con esito positivo. Una buona guida è rappresentata da quanto già pubblicato e che trovate negli Argomenti correlati.

Nota:

I componenti presenti nello schema servono tutti! Cominciate ad applicare le regole basilari dell'Elettronica, per non dover poi dire: "Questo circuito è instabile e l'ho abbandonato"! 

Nota importante:

La pila da 9 volt è soltanto dimostrativa e non può alimentare tutto il circuito per lunghi periodi; l'ho messa soltanto per prova perché qualcuno pretendeva di far funzionare tutto con tensione di 5 volt scarsi! Ovvio che non funzionava nulla! Peggio, il funzionamento era incerto!

La legge di Murphy è sempre in agguato ma vediamola in senso positivo!

Ricordate di lavorare sempre in sicurezza!

Simulazione: 

Elettrovalvola bistabile

Argomenti correlati: 

Pilotaggio di motori in CC

Arduino N° 6 - Comando Bluetooth 2 canali 3 effetti
Arduino N° 29 - Selettore bluetooth, 2 canali

Arduino N° 90 - Elettrovalvola bistabile (con comando impulsivo)

Buon lavoro a tutti!

>Arduino N°  93

Arduino N° 53 - Modulo bluetooth 9 CH + 3 Servo

< Arduino N°  52

Achille De Santis

> Arduino N°  54

Foto 1: Il modulo bluetooth, su shield, e scheda Arduino;

Programma per la gestione con bluetooth di 9 canali digitali (ON/OFF) e di 3 canali per il comando di servomotori.

Le uscite digitali possono essere interfacciate con un modulo relais ad 8+1 canali, per il comando di altrettanti attuatori.

I tre canali "servo" possono comandare direttamente tre piccoli servomotori del tipo SG90 o similari, per un controllo a tre assi.

1. Per il funzionamento con telefono Android occorre predisporre un modulo bluetooth ricevitore (HC06 o HC05) ed una opportuna APP sul telefono.
2. Per il funzionamento con telefono IoS è consigliabile l'uso di un modulo bluetooth BLE 4.0 

Le uscite servo sono predisposte per effettuare una rotazione lenta di 90 gradi (in circa 10 secondi).

Foto 2: collaudo del comando servomotore;

In questo caso, dopo le prove operate su Arduino UNO, ho utilizzato una scheda Arduino Pro-Mini, sulla quale ho caricato lo sketch, una volta per tutte. 

Si tratta, quindi, di un modulo che può essere finalizzato ad applicazioni con un massimo di 9 canali di comando digitale e 3 canali di comando per servomotori. 

Le applicazioni possono essere numerose.

Per applicazioni a bassa potenza, sui canali "digitali" basta un semplice modulo relais.
Per i canali servo vale lo stesso principio ma con uscita "proporzionale", interfacciata con transistori.

Per applicazioni a tensioni diverse dai 5 volt della scheda Arduino, i "contatti puri" dei relais offrono la possibilità di separazione galvanica e di interfacciamento con tensioni continue o alternate, più o meno alte.

Al fine di soddisfare le richieste di alcuni lettori ho reso disponibile la scheda di controllo Pro-mini già programmata con firmware. Basta collegare la scheda, l'interfaccia bluetooth e l'interfaccia Relais per essere operativi. 

Naturalmente, per comandare da telefono occorre una opportuna APP, facilmente scaricabile.

Nota importante: 

In ogni caso, fino a 48 volt state lavorando con "tensioni di sicurezza". Oltre questo valore è necessario adottare tutte le ulteriori misure di sicurezza che le Norme richiedono.

---------------------------------------------------------------------------------------

Simulazione: 

Argomenti correlati:

Arduino N° 41 - Bluetooth BLE 4.0 per IPhone

Arduino N° 29 - Selettore bluetooth, 2 canali

Arduino N° 11 -  Movimento servomotore

Arduino N° 50 - Modulo di prova per 6 uscite digitali

tecnatronATgmail.com

> Arduino N°  54

Arduino N° 41 - Bluetooth BLE 4.0 per IPhone

< Segue da Arduino N°  40

Achille De Santis

> Arduino N° 42

La serie di bluetooth HC05/HC06 è stata usata più volte per applicazioni nel settore Android.

Purtroppo, non funziona con dispositivi IoS e telefoni Iphone.

Facendo delle ricerche e delle prove  ho trovato un modulo funzionante per applicazioni IoS; si tratta del modulo BLE 4.0 (Bluetooth Low Energy 4.0), visibile nelle foto 1 e 2.

Il modulo funziona perfettamente, come dimostra il video allegato, e ve ne posso consigliare l'uso.

Un altro problema è rappresentato dalla difficoltà di trovare una idonea App ma, niente paura: basta scegliere tra la miriade di App presenti nell' "App store". Alcune non funzionano con i telefoni più vecchi, altre funzionano molto bene.

BLE Terminal funziona bene.

Il modulo "Master/Slave" è l' HM-10 e HM-11 serie modulo Bluetooth

Fig. 1: il modulo BLE 4.0

Fig. 2: BLE 4.0 - disposizione piedini

Per le prove di laboratorio posso consigliare una APP con tastiera di terminale; per l'uso operativo, invece, va bene una App con tasti sensibili da programmare con gli opportuni caratteri, una volta per tutte. In questo caso i comandi sono solamente tre: ON, OFF, IMPULSO.

Sulla APP utilizzata è possibile programmare il comando ed editarne la funzione sul tasto sensibile, per un facile e corretto uso.

Video 1: Prova di funzionamento con idonea APP; 

Nel video è mostrato il funzionamento di un interruttore ON/OFF (a due tasti) e di un comando impulsivo (il terzo tasto). Le immagini valgono più di cento parole.

Buon lavoro!

Argomenti correlati:  

Arduino N° 6 - Comando Bluetooth 2 canali - 3 effetti

Arduino N° 29 - Selettore bluetooth, 2 canali

Arduino N° 50 - Modulo di prova per 6 uscite digitali

> Arduino N° 42

Arduino N° 31 - Antenna switch bluetooth 2 canali

< Arduino N° 30

Achille De Santis

> Arduino N° 32

Selettore di antenna, 2 canali indipendenti, con uscite 1 via / 2 posizioni
Il primo canale viene usato per commutare due antenne; il secondo canale viene usato per commutare un preamplificatore di ricezione.


/* ---------------- Inizio Programma ----------------------------------------- 
 *  Programma di Achille De Santis    22-03-2018 V.2.2
 *  Selettore "2 vie/2 posizioni" a relé tramite collegamento Bluetooth
 *  Piedini usati per seriale bluetooth:  TX=>0, RX=>1 
 *  Linee di uscita: D2 = antenne,  D3 = preamplificatore
 *  Commuta 2 Antenne su una unica discesa in cavo coassiale.
 *  Un comando indipendente per preamplificatore di ricezione.
 *
 *  Comandi: 
 *  A = seleziona antenna A 
 *  B = seleziona antenna B 
 *  P = inserisce preamplificatore su linea antenna 
 *  p = disinserisce preamplificatore antenna   
 *  c = comandi
 *  t = titolo
*/

// ------------------- I/O -----------------------
#define i   2       // uscita comando relay
#define p3  3     // preamplificatore
// -----------------------------------------------

char dato;

void titolo()
  { 
    Serial.println("\n-           Tecnatron Creation   ");
    Serial.println("-          tecnatron@gmail.com     ");
    Serial.println("- Selettore:  2 canali - 1 via/2 posizioni");
    Serial.println("- posizione iniziale: Uscita A     ");
    Serial.println("- ---------------------------------------------");
  }

void comandi()
  {
    Serial.println(" - Comandi: -");
    Serial.println(" - A = antenna A ");
    Serial.println(" - B = antenna B ");
    Serial.println(" - P = inserisce preamplificatore ");
    Serial.println(" - p = disinserisce preamplificatore");
    Serial.println(" - c = comandi ");
    Serial.println(" - t = titolo ");
    Serial.println('  ------------------------------------------ ');
  }

void accendi(int pin)
  { digitalWrite(pin, HIGH); // eccito il relè collegato al pin
    scrivi(pin); Serial.println(" ON");
  }
void spegni(int pin)
  { digitalWrite(pin, LOW); // rilascio il relè collegato al pin
    scrivi(pin-1); delay(10); Serial.println(" ON");
  }
void scrivi(int pin)
  { Serial.print("Antenna ");
    Serial.print(pin);
  }
void accendiPRE(int pin)
  { digitalWrite(pin, HIGH); // eccito il relè collegato al pin
    Serial.println("Preampli RF: ON");
    // Serial.println();
  }
void spegniPRE(int pin)
  { digitalWrite(pin, LOW); // rilascio il relè collegato al pin 
    Serial.println("Preampli RF: OFF");
    // Serial.println();
  }

void setup()
  {
     pinMode(i, OUTPUT);              // comando switch antenna
     pinMode(p3, OUTPUT);            // comando preamplificatore
     Serial.begin(9600);                    // velocità di comunicazione
     accendi(i); delay(500); spegni(i);  // controllo iniziale
     accendiPRE(p3); delay(500); spegniPRE(p3);
     titolo();
  }

void loop()
  {while (Serial.available())
   {   dato= Serial.read();              // carattere che viene ricevuto dalla seriale
       Serial.print(dato); Serial.print(' ');
       switch(dato)
       { case 'A':  spegni(i);      break;       //
         case 'B':  accendi(i);     break;       //
         case 'P':  accendiPRE(p3); break; //
         case 'p':  spegniPRE(p3);  break;  //
         case 'c':  comandi();      break;      //
         case 't':  titolo();       break;           //
         default:   comandi();       
       }     
   }
  }

// ------------------------- Fine programma ------------------------------------

Simulazione: Antenna switch bluetooth

Argomenti correlati: 

Arduino N° 29 - Selettore bluetooth, 2 canali

Arduino N° 50 - Modulo di prova per 6 uscite digitali

> Arduino N° 32

Arduino N° 29 - Selettore bluetooth, 2 canali

< Arduino N° 28

Achille De Santis

> Arduino N° 30

Foto 1: a sinistra Arduino Pro-Mini,
a destra modulo bluetooth;

Selettore  bluetooth, 2 canali, 1 via / 2 posizioni; si può utilizzare in vari ambiti, dove necessiti un collegamento  senza fili a 1 via/2 posizioni, per comando di 2 canali indipendenti.

Può servire una interfaccia a 2 relé, reperibile tra quelle in uso con Arduino, oppure se ne può assemblare una "ad hoc". Il relé permette di disporre di un "contatto puro", in uscita, che può essere collegato in vario modo e con tensioni diverse sul carico.

Il comando può essere impartito attraverso idonea APP da installare su telefono(Android o IoS).

Per l'uso con telefoni Android è idoneo un modulo bluetooth HC05 o HC06 ("slave" o "master/slave").

Per il funzionamento con telefoni IoS consiglio di utilizzare un modulo bluetooth BLE 4.0.

In fig. 1 potete vedere il montaggio di prova, su breadboard, dei due moduli, sufficienti per un idoneo assemblaggio minimale. Dopo le valutazioni con una scheda Arduino UNO o Nano, per un montaggio definitivo ho preferito programmare un modulo Pro-mini (a sinistra sulla foto). 

Il modulo bluetooth in foto è un BLE 4.0 compatibile con IoS ma può essere sostituito con un HC05 o HC06 compatibile con Android; attenzione al verso della piedinatura.  

/* ----------------------------- Inizio Programma -----------------------------------
  Programma di Achille De Santis    22-03-2018 V.2.2
  Selettore "1 via 2 posizioni" a relé tramite collegamento Bluetooth
  Piedini usati per seriale bluetooth:  TX=>0 RX=>1
  Linee di uscita:         D2 = canale 1,    D3 = canale 2
  Commuta 2 canali di uscita, ognuno su due posizioni.

  Comandi:
    A = seleziona uscita A
    B = seleziona uscita B
    P = inserisce la linea A1
    p = inserisce la linea B1
    c = comandi
// -------------------------------------------------------------------------------------------
*/

#define i     2       // uscita comando relay
#define p3  3      //  uscita

char dato;

void setup()
{
     pinMode(i, OUTPUT);               // comando switch 1
     pinMode(p3, OUTPUT);            // comando switch 2
     Serial.begin(9600);             // velocità di comunicazione
     titolo();
     accendi(i);   delay(500);  spegni(i);  // controllo iniziale
     accendiPRE(p3);  delay(500);  spegniPRE(p3);
}

void titolo()
{
  Serial.println(" -          Tecnatron Creation                    - ");
  Serial.println(" -          tecnatron@gmail.com               - ");
  Serial.println(" - Selettore bluetooth 2 canali               - ");
 Serial.println(" -  1 via / 2 posizioni                               - ");
  Serial.println(" - posizione iniziale su A                       - ");
  Serial.println(" --------------------------------------------------- ");
}

void comandi()
{
   Serial.println(" -  Comandi:               - ");
   Serial.println(" -  A = uscita A           - ");
   Serial.println(" -  B = uscita B           - ");
   Serial.println(" -  P = uscita A1         - ");
   Serial.println(" -  p = uscita B1         - ");
   Serial.println(" -  c = comandi          - ");
   Serial.println("  ------------------------- ");
}

void accendi(int pin)
{
   digitalWrite(pin, HIGH); // eccito il relè collegato al pin
   scrivi(pin);    Serial.println(" ON");
}

void spegni(int pin)
{
    digitalWrite(pin, LOW); // rilascio il relè collegato al pin
    scrivi(pin-1);    delay(10);    Serial.println(" ON");
}

void scrivi(int pin)
{
   Serial.print("Uscita ");   Serial.print(pin);
}

void accendiPRE(int pin)
{
   digitalWrite(pin, HIGH); // eccito il relè collegato al pin
   Serial.print("AUX  :  ON \n");
   // Serial.println(' ');
}

void spegniPRE(int pin)
{
   digitalWrite(pin, LOW); // rilascio il relè collegato al pin 
   Serial.print("AUX :  OFF \n");
   // Serial.println(' ');
}

void loop()
  {   while (Serial.available())
   {   dato= Serial.read(); // carattere che viene ricevuto dalla seriale
       Serial.print(dato); Serial.print(' ');
       switch(dato)
       { case 'A':  { spegni(i);      break;}       // Se ricevo "A"
         case 'B':  { accendi(i);     break;}       // Se ricevo "B"
         case 'P':  { accendiPRE(p3); break;} // Se ricevo "P"
         case 'p':  { spegniPRE(p3);  break;}  // Se ricevo "p"
         case 'c':  { comandi();      break;}      // Se ricevo "c"
         default: comandi();       
       }     
   }
  }

// ------------------------- Fine Programma ---------------------------------------------

Argomenti correlati: 

Arduino N° 6 - Comando Bluetooth 2 canali 3 effetti

Arduino N° 50 - Modulo di prova per 6 uscite digitali

RadioRama n°91 pag 40

Selettore di antenna 2 posizioni_PRE _parte_seconda_Firmware RadioRama n°91 pag 40

> Arduino N° 30

Arduino N° 8 - Comando LED lampeggiante, con Bluetooth V3

< Arduino N° 7

Achille De Santis

> Arduino N° 9

Con un modulo bluetooth HC06 unito ad una scheda Arduino possiamo realizzare un attuatore utilizzando il nostro telefono cellulare come telecomando; basta scaricare una idonea APP.

I comandi possono essere impartiti utilizzando i tasti sensibili da uno a cinque oppure, in modalità "terminale", premendo i tasti da uno a cinque sulla tastiera.

In caso di errore verrà visualizzato a monitor un messaggio di commento.







/*
  Comando LED lampeggiante con Bluetooth
  ideato da Achille De Santis il 28-12-2017
  V3.0 del 07-03-2018

  comandi:
  -1 effettua un lampeggio
  -2 effettua 2 lampeggi
  -3 effettua 3 lampeggi
  -4 effettua 4 lampeggi
  -5 effettua 5 lampeggi
 
*/

#define pin   13          // piedino usato come uscita comando

char data;
const int T=250;

void setup()
{
  Serial.begin(9600);             // baud-rate per la trasmissione seriale
  pinMode(pin, OUTPUT);   // pin del led di uscita
  lampeggia(pin, 1);              // prova iniziale LED; lampeggia 1 volta
}

void lampeggia(int p, int n) // lampeggia n volte
{
  for(int i=1; i<=n; i++)
  {
    digitalWrite(p, HIGH);  delay (T);
    digitalWrite(p, LOW);   delay (T);
  }
}
 
void loop()
{
  while(Serial.available())
  {
    data = Serial.read();      // Legge il dato in arrivo e lo mette in data
    Serial.print(data);  // Stampa il valore del dato nel Serial monitor (per vederlo ricordate di impostare il baud rate a 38400)
   
    switch (data)
    {         // Se il dato ricevuto è:
      case '1': {lampeggia(pin, 1); Serial.println(); break;}   // 1, lampeggia 1 volta ...
      case '2': {lampeggia(pin, 2); Serial.println(); break;}   // 2, effettua 2 lampeggi in sequenza;
      case '3': {lampeggia(pin, 3); Serial.println(); break;}   // 3, effettua 3 lampeggi in sequenza;
      case '4': {lampeggia(pin, 4); Serial.println(); break;}   // 4, effettua 4 lampeggi in sequenza;
      case '5': {lampeggia(pin, 5); Serial.println(); break;}   // 5, effettua 5 lampeggi in sequenza;
      default: Serial.println("  Comando NON ammesso! \n");    // negli altri casi
    }
  }
}

// ---------------- Fine Programma ------------------------


Nota: questo bluetooth funziona bene con telefono Android!

> Arduino N° 9

Arduino N° 7 - Comando LED lampeggiante, con Bluetooth

< Arduino N° 6

Achille De Santis

> Arduino N° 8

 

Per questa realizzazione occorre un modulo ricevitore bluetooth HC05 / HC06 ed opportuna APP su telefono Android / IoS con i comandi da 1 a 5 (in modalità "terminale").




/* ---------------- Inizio Programma ------------------------
  Comando LED lampeggiante con Bluetooth
  ideato da Achille De Santis il 28-12-2017
  V3.0 del 07-03-2018

  comandi:
  -1 effettua un lampeggio
  -2 effettua 2 lampeggi
  -3 effettua 3 lampeggi
  -4 effettua 4 lampeggi
  -5 effettua 5 lampeggi
*/

#define pin 10       // piedino usato come uscita comando

char data = 0;

void setup()
{
  Serial.begin(9600);              // baud-rate per la trasmissione seriale
  pinMode(pin, OUTPUT);   // pin del led di uscita
  lampeggia(pin, 1);              // prova iniziale LED; lampeggia 1 volta
}

void lampeggia(int p, int n) // lampeggia n volte
{
  for(int i=1; i<=n; i++)
  {
    digitalWrite(p, HIGH);  delay (500);
    digitalWrite(p, LOW);   delay (500);
  }
}

void loop()
{
  while(Serial.available())
  {
    data = Serial.read();   // dato in arrivo
    Serial.print(data);     // Stampa il valore del dato nel Serial monitor (per vederlo ricordate di impostare il baud-rate a 9600)
 
    switch (data)
    {         // Se il dato ricevuto è:
      case ('1'):   {lampeggia(pin, 1); break;}   // 1,  ... 1 impulso; lampeggia 1 volta ...
      case ('2'):   {lampeggia(pin, 2); break;}   // 2,  ... 2 impulsi in sequenza;
      case ('3'):   {lampeggia(pin, 3); break;}   // 3,  ... 3 impulsi in sequenza;
      case ('4'):   {lampeggia(pin, 4); break;}   // 4,  ... 4 impulsi  in sequenza;
      case ('5'):   {lampeggia(pin, 5); break;}   // 5,  ... 5 impulsi in sequenza;
    }
  }
}

//  ---------------- Fine Programma ------------------------

Nota: questo bluetooth funziona bene con telefono Android!

> Arduino N° 8

Arduino N° 6 - Comando Bluetooth 2 canali - 3 effetti

< Arduino N°5

Achille De Santis

> Arduino N° 7

Con un modulo Bluetooth  HC05 / HC06  possiamo realizzare un telecomando a due canali attivabili via telefono;
una qualunque APP a due canali è sufficiente. Dipende dal sistema telefonico utilizzato: Android/IoS.

Comandi da telefono (dopo aver installato idonea APP):

0 - USCITA 1 spenta
1 - USCITA 1 accesa - comando a tenuta
2 - USCITA 2 - comando impulsivo ACCESO/SPENTO

Il primo canale (D10) ha un effetto di tipo "Toggle", cioè cambia stato ad ogni comando; Il secondo canale (D11) ha un effetto "impulsivo", cioè genera un impulso ad ogni comando.





/* ----------------- Inizio Programma ---------------------
  Comando  2 canali, 3 effetti, con Bluetooth
  Accende/Spegne/Impulso
  Achille De Santis il 15-11-2018
*/

// ------------------- I/O --------------------------------------------------------
#define pin1       10  // uscita 1; piedino usato come uscita comando
#define pin2       11  // uscita 2;
// --------------------------------------------------------------------------------

unsigned const T = 500;
char data = 0;

void impulso(int p)
  {
    digitalWrite(p, HIGH);  delay(T); 
    digitalWrite(p, LOW);
    Serial.print(" impulso \n");
  }
  void spegni(int p)  { digitalWrite(p, LOW); Serial.print(" OFF \n"); }
  void accendi(int p) { digitalWrite(p, HIGH); Serial.print(" ON \n"); }

void setup()
{
  Serial.begin(9600);                   // baud-rate per la trasmissione seriale
  pinMode(pin1, OUTPUT);      // pin del 1^ canale (led) di uscita
  pinMode(pin2, OUTPUT);      // pin del 2^ canale (led) di uscita
  impulso(pin2);                         // prova iniziale con LED; si può escludere
}

void loop()
{
  while (Serial.available() )
  {
    data = Serial.read();      // Legge il dato in arrivo e lo mette in data
    Serial.print(data);        // Stampa il valore del dato nel Serial monitor
                                        // (per vederlo ricordate di impostare il baud-rate a 9600)
    switch(data)                // Se il dato ricevuto è...
    {               
      case '0': spegni(pin1);    break;  // comando a tenuta: //disattiva l'uscita e invia il messaggio "OFF"
      case '1': accendi(pin1);   break; // comando a tenuta; // attiva l'uscita e invia il messaggio "ON"
      case '2': impulso(pin2);  break;  // comando impulsivo;
      default: Serial.print (" Comando NON ammesso! \n");    // negli altri casi
    }
  }
}

// ---------------------- Fine Programma -------------------------------------------------------------------------


Nota:
il modulo Bluetooth HC05/HC06 funziona bene con telefono Android!
Per telefoni IoS occorre un bluetooth BLE V.4.0.


schema; manca il modulo bluetooth
v. anche: http://tecnatron.blogspot.com/

Arduino N° 41  - Bluetooth BLE 4.0 per IPhone 

> Arduino N° 7