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° 42 - Selettore ad infrarosso - 8 canali

< Segue da Arduino N°  41

Achille De Santis

> Arduino N° 43

Questo circuito realizza un Selettore ad 8 canali, comandabile con un piccolo telecomando ad infrarosso.

Il selettore commuta una uscita per volta, a livello alto. La selezione iniziale è sul canale 1 ma è possibile cambiarla da software. Ancora meglio, basta predisporre l'attuatore prioritario sul canale 1 di uscita, senza modifiche al firmware.

Andate alla simulazione per avere un'idea più precisa del suo funzionamento.

Gli otto LED di uscita (rossi) segnalano il canale prescelto.
Un altro LED (arancione), connesso ad una linea di servizio (DCD), segnala l'arrivo del comando dal trasmettitore ad infrarosso.


Nel caso fosse necessario cambiare i codici sul ricevitore, agire come segue;

Fig. 1: Telecomando e modulo Arduino Nano;

Procedura:

• si apre il monitor seriale su Arduino 
• da telecomando, si invia un comando per volta, premendo i tasti da 1 a 8;
•  si copia il codice ricevuto a monitor, 
• si ripete il comando, per conferma del codice inviato;
• si incolla il codice sulla riga corrispondente, nelle opzioni "case" del firmware.
• si ripete la procedura per gli 8 canali;
• si verifica che la procedura sia andata a buon fine: se tutto è a posto, ad ogni comando si accenderà un solo LED  per volta, spegnendo il precedente. 

Una tabella dei codici in uso su molti telecomandi è disponibile all'indirizzo:

Stazione Radio - Telecomandi ad infrarosso

buon lavoro!

Simulazione: 

Selettore ad infrarosso - 8 canali

Argomenti correlati:

Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici
Ricevitore Infrarosso - 8 canali ON/OFF array
Telecomando ad Infrarosso_verifica codici
Stazione Radio - Telecomandi ad infrarosso
Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici
Arduino N° 50 - Modulo di prova per 6 uscite digitali

> Arduino N° 43

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° 40 - Ricevitore ad Infrarosso per attuatore ad 8 canali ON/OFF

< Segue da Arduino N°  39

Achille De Santis

> Arduino N° 41

In questo numero vi presento un comodo ricevitore da abbinare ad un telecomando ad infrarosso per l'attivazione digitale, ON/OFF, di 8 uscite che possono, a loro volta, essere interfacciate con gli attuatori per mezzo di circuiti di pilotaggio a transistori o a relais, a seconda delle esigenze applicative.


La logica di comando è, per ora, collegata ad 8 diodi LED opportunamente polarizzati, per una facile dimostrazione del funzionamento. Una uscita aggiuntiva provvede a visualizzare un impulso di rivelazione, per confermare la ricezione della "trama" proveniente dal piccolo telecomando ad infrarossi.
Naturalmente, non tutti i pulsanti del telecomando sono stati utilizzati, quindi, accertatevi di aver premuto i soli pulsanti da 1 a 8; gli altri non avranno effetto, sebbene segnalati dalla spia di ricezione.


Se avete un telecomando diverso dovrete ricavarne inizialmente i codici dei pulsanti corrispondenti alle cifre, da 1 a 8, e poi inserirli al posto di quelli preesistenti nel codice da me fornito, senza cambiare altro.

Niente paura! Ho già pubblicato qualcosa al riguardo, all'indirizzo che trovate in fondo, negli argomenti correlati.
La simulazione da me preparata vi darà un'idea sul funzionamento del circuito.

Simulazione:

Ricevitore ad Infrarosso_8_canali ON/OFF
Ricevitore ad Infrarosso con driver a BJT

Argomenti correlati:

Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici
Telecomandi ad infrarosso - Codici
Collegamento audio ad infrarossi
Arduino N° 50 - Modulo di prova per 6 uscite digitali


> Arduino N° 41

Arduino N° 39 - Telecomando ad Infrarosso con driver a BJT

< Segue da Arduino N° 38

Achille De Santis

> Arduino N° 40

Ricevitore per telecomando ad infrarosso. L'uscita  ON/OFF è interfacciata con transistore BJT.

In questo modo è possibile comandare direttamente un relay con un "contatto puro" per il collegamento ad una qualsivoglia alimentazione per l'attuatore, sia a 12 o 24 volt in continua, sia anche a 230 volt c.a, separando la logica di comando dalla rete di attuazione.

Il pulsante serve soltanto per prova e va eliminato.
tecnatronATgmail.com

Simulazione: 

Telecomando ad Infrarosso con driver a BJT

Argomenti correlati: 

Telecomandi ad infrarosso - Codici

> Arduino N° 40

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° 15 - Prova telecomandi ad infrarosso e rivelatore di codici

< Arduino N° 14

Achille De Santis

> Arduino N° 16

Molto spesso ci ritroviamo a dover lavorare con dei telecomandi ad infrarosso o a doverne provare soltanto l'efficienza.
Per la prova di funzionamento ci sono due metodi adatti alla maggior parte degli utenti:

1. Fare uso di una radiolina ad onde medie: attivando i pulsanti del telecomando dovreste ascoltare il treno di impulsi sul ricevitore radio;
2. Fare uso di un moderno telefono cellulare: premendo i pulsanti del telecomando si dovrebbero vedere a video, sullo schermo del telefono, gli impulsi di luce emessi.

Il problema, soprattutto se stiamo realizzando un progetto IoT, è conoscere i codici del telecomando, in modo da utilizzarli sul ricevitore per implementare le funzioni che a noi servono: Avvio/Arresto di motori, luci, servo, attuatori a relé ed altro. Infatti, non tutti i telecomandi hanno gli stessi codici.

Questo programma vi aiuta in questa ricerca e facilita la visualizzazione a monitor dei suddetti codici.
Successivamente, basta copiarli, memorizzarli in un file "DOC" o "TXT" e tenerli in evidenza per ogni ulteriore uso.

Ricordate! Ogni famiglia di telecomandi lavora in modo diverso ed è quindi molto utile conoscerne i codici ed il funzionamento. Alcuni ripetono il comando se si indugia sul pulsante, altri trasmettono codici diversi.
Per un corretto caricamento del programma, scollegare il pin RX e ricollegarlo a fine caricamento.

Buon lavoro!

/*----------------------------------------------- Inizio Programma -------------------------------
 * Arduino con test di ricezione Infrarosso.
 * Programma elaborato da Achille De Santis 27-10-2019.
 *
 * Utile per riconoscere a monitor i codici di comando del trasmettitore/telecomando.
 * Rileva gli impulsi sul LED connesso al piedino 13, senza aggiunta di altri componenti;
 * Rivela e visualizza a monitor i codici dei comandi.
 * A causa dei ritardi e del tipo di telecomando potremmo riceverli in due modi diversi;
 * niente paura: il comando viene trasmesso a "burst", l'importante è che uno (il primo) sia giusto.
 * Scegliere i codici dei comandi ed inserirli nelle istruzioni degli attuatori.
 * Collegare la seriale, avviare il programma ed aprire il monitor seriale.
 * I codici ricevuti verranno visualizzati a monitor.
 * Per "sincronizzare" al meglio i comandi agire sul delaytime.
 * Per una corretta decodifica, i comandi devono essere impulsivi. Si risparmia anche sul consumo della pila!
*/

#include <IRremote.h>    // usa la libreria
// ------------------ I/O -----------------------------
#define RX        0     // pin 1 (segnale) del ricevitore IR; ad Arduino, digital pin 0
#define U          13     // rivelatore dei comandi
// ----------------------------------------------------

IRrecv irrecv(RX);       // creo una istanza di 'irrecv'
decode_results results;

void setup()
{
  Serial.begin(9600);            // serial monitor output
  irrecv.enableIRIn();           // abilita la ricezione IR
  pinMode(U, OUTPUT);   // Pin di monitor output; segnala l'arrivo dei codici di comando
  visualizza(U);                   // accende una volta il LED, come test di uscita.
}

void visualizza(int p)
  {    digitalWrite(p, HIGH); delay(100); digitalWrite(p, LOW);     }

void loop()
{
  if (irrecv.decode(&results))          // se riceve un segnale IR
     {
      Serial.println(results.value, HEX); // lo mostra sul serial monitor in esadecimale
      // visualizza(U);                   // il piedino 13 è monitorato dal suo LED "a bordo" ma se si cambia                                                      // uscita... un LED può servire.
      delay(50);                           // IMPORTANTE! Blocca segnali spuri e "sincronizza". Da verificare                                                    // ed adattare. Con LG è perfetto!!!
      irrecv.resume();                  // si predispone a ricevere il codice successivo.
     } 
}

// ------------------------------- fine programma ---------------------------------------------



Simulazione: telecomando ad infrarosso-verifica codici

> Arduino N° 16

Telecomandi ad infrarosso - Codici

Per chi lavora con i telecomandi ad infrarosso, riporto alcune utili tabelle per la gestione dei codici.
Il lavoro è stato svolto per ricercare le cause dei malfunzionamenti di alcune realizzazioni.
        I piccoli telecomandi sono economici ed utili in tante applicazioni ma sono anche molto delicati. Fate attenzione a premere dolcemente i "contatti a bolla" ed a sostituire con attenzione e delicatezza la pila a bottone; all'interno c'è un delicato sistema a molla che salta facilmente.

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

Fig. 1: semplice circuito di prova

Telecomandi IR-LG
--------------------
Avanti B4B4E21D
Indietro   B4B412ED
Destra B4B45AA5
Sinistra B4B49A65
AV SX B4B44CB3
AV DX B4B42CD3
STOP B4B41AE5

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

Codici dei piccoli telecomandi IR

              CAR          KEYES

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

1 AV-SX FF30CF         FF6897

2 AV         FF18E7         FF9867

3 AV-DX FF7A85         FFB04F

4 SX         FF10EF         FF30CF

5 STOP FF38C7         FF18E7

6 DX         FF5AA5         FF7A85

7 --         FF42BD         FF10EF

8 --         FF4AB5         FF38C7

9 --         FF52AD         FF5AA5

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

     

           Per un uso corretto consiglio un comando impulsivo e non lunghe sequenze di codici.

Se il codice viene interpretato correttamente non c'è bisogno di insistere sul telecomando; anzi, dalle prove da me effettuate risulta che se la sequenza  è lunga i codici inviati possono essere: validi, erronei, giusti/sbagliati (uno si e uno no), completamente errati. 

Analizzando i codici, risulta:

• codici validi:  funziona tutto a dovere!  
• errati: bisogna trovare la causa dell'errore casuale (sincronismo dei dati in arrivo);
• validi/errati: (uno si e uno no): va ancora bene se il codice errato è sempre lo stesso e diverso da altri codici di comando;
• completamente errati: bisogna effettuare la ricerca dell'errore, analizzare il sincronismo, il baud-rate, gli stati logici. 

       Bisogna mettere d'accordo hardware e software, con piccoli trucchetti; lascio a voi il piacere e l'onere di scoprirli.

       Telecomandi migliori ma più costosi sono quelli associati alle apparecchiature elettrodomestiche di un certo valore.

I telecomandi HP sono ottimi. Oggi ho provato un telecomando IR della LG. Dopo alcuni settaggi al software vanno entrambi "come una spada!"

       Per gli altri, serve un po' più di pazienza ma si riesce ad avere un codice sicuro e deciso.

Per le prove, oltre al "metodo spannometrico" (poco consigliabile se non avete idea della possibile causa di errore), vi consiglio di utilizzare un semplice programma "tester" con Arduino, con cui rilevare a monitor i codici ricevuti e passare, poi, al "sincronismo" TX/RX.

Sull'IDE di Arduino troverete uno sketch di esempio che sarà la vostra base di lavoro.
In fig. 1 potete vedere il circuito di prova, ridotto al solo sensore IR collegato ad una scheda Arduino Nano su cui è stato caricato lo sketch di test.

DALEK - Maker Faire 2017

Lavoro completo.

Pronti per il Maker Faire 2017 con il DALEK

Link a foto e video