Visualizzazione post con etichetta Infrarosso. Mostra tutti i post
Visualizzazione post con etichetta Infrarosso. Mostra tutti i post

mercoledì 9 giugno 2021

Arduino N° 98 - Comando proporzionale Ventola

< Arduino N° 97

 Achille De Santis

Arduino N°  99


Controllo di velocità per ventola, comandata con telecomando ad infrarosso.


Fig. 1: Layout dei componenti; driver a MOSFET;

Due coppie di codici permettono l'avanzamento UP/DOWN con passo LOW e FAST  attraverso i quattro pulsanti di avanzamento lento (< >) e veloce (<< >>).

i condensatori sulla linea di alimentazione servono per non avere brutte sorprese di malfunzionamenti.

Il diodo di "libera circolazione" è molto utile per la salvaguardia del MOSFET.

Il LED fornisce una indicazione visiva dell'attuazione dei comandi, peraltro visibili aprendo il monitor seriale.

Il MOSFET, nella configurazione a Source Comune, pilota la tensione da fornire alla ventola  e la relativa corrente.

Dalla disposizione dei componenti ricavate lo schema elettrico; vi aiuterà molto nella comprensione del circuito. 


In alternativa, è possibile pilotare il motore con un circuito driver a BJT, come in fig. 2. Il firmware resta lo stesso ma bisogna modificare l'interfaccia di comando motore per avere un pilotaggio in corrente.

Fig. 2: Comando ventola con infrarosso e driver a BJT;




Varianti: 

E' possibile collegare la ventola a tensione di 12 volt, scollegando il filo rosso che la alimenta e collegando ad una tensione di 12 Vcc, massa comune con il circuito.

Nota 1: 

Se avete un telecomando diverso è possibile cambiare facilmente i codici di attivazione leggendoli direttamente a monitor ed inserendoli nelle righe dei comandi.


Nota 2:

Il circuito è SOLO dimostrativo. L'uscita va ASSOLUTAMENTE collegata ad una sorgente di alimentazione separata. La figura la riporta collegata alla alimentazione di Arduino a puro titolo di esempio.


Simulazione: 

Comando proporzionale ventola con MOSFET_V5.3


Argomenti correlati: 

mercoledì 25 marzo 2020

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:

buon lavoro!


Simulazione: 

mercoledì 11 marzo 2020

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


mercoledì 4 marzo 2020

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: 


Argomenti correlati: 

mercoledì 4 dicembre 2019

Arduino N° 26 - Tachimetro ad infrarosso

Arduino N°  25

 Achille De Santis

Arduino N° 27




Tachimetro ad infrarosso, per misure di velocità angolare.

/* ---------------- Inizo Programma --------------------
 * Tachimetro
 * Modificato da Achille De Santis
 * V4 del 08-07-2019
 */
// ------------ I/O --------------------------------------
#define I    A0
#define U   13
// -------------------------------------------------------

int sensorvalue;               // variabile di ingresso
bool state1 = HIGH;
bool state2;
float rps;                        // velocità in giri/secondo
float rpm;                      // velocità in giri/minuto
long prevMillis = 0;
long interval = 200;
long currentTime;
long prevTime = 1;
long diffTime;
const int sensorthreshold = 30;   // indica la soglia "buio/luce" e "luce/buio"; provato; si può cambiare // in relazione alla distanza fisica dei led.
// per vedere quale valore sia adatto, prova il valore di "sensorvalue"
// come stampato da "serial monitor"

unsigned long currentMillis;

void test()                          //only for testing to determine the sensorthreshold value
                 {     delay(500);   Serial.println(sensorvalue);    }

void setup()
{
  Serial.begin(9600);
  pinMode(U, OUTPUT);      // assign pin "U" led as indicator because we cannot see the IR light
}

void loop()
{
  sensorvalue = analogRead(I);            // read from pin "I" (A0)
  if(sensorvalue < sensorthreshold)
    state1 = HIGH;
   else
    state1 = LOW;
   digitalWrite(U, state1);             // as iR light is invisible for us, the led on pin 13
                                                     // indicate the state of the circuit.
   if(state2!=state1)
   {                             // rileva quando lo stato cambia, "buio/luce" o
                                  // "luce/buio", ricorda che la luce IR è NON visibile all'occhio umano.
     if (state2>state1)
     {
       currentTime = micros();                      // Get the arduino time in microseconds
       diffTime = currentTime - prevTime;  // calculate the time diff from the last meet-up
       rps = 1000000/diffTime;                    // calculate how many rev per second, good to know
       rpm = 60000000/diffTime;                // calculate how many rev per minute
       currentMillis=millis();   
                                         // print to serial at every interval - defined at the variables declaration
       if(currentMillis-prevMillis>interval)
        {                              // see if now already an interval long
          prevMillis = currentMillis;     
          Serial.print(rps); Serial.print(" rps  "); Serial.print(rpm); Serial.println(" rpm");
        }     
       prevTime = currentTime;
     }
     state2 = state1;
   }
   // test();                        //prova per determinare il valore di soglia
}
// --------------------- Fine programma -----------------------------------------



Argomenti correlati:

Arduino N° 27

mercoledì 18 settembre 2019

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

lunedì 3 settembre 2018

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.

mercoledì 13 settembre 2017

Collegamento audio ad infrarossi


prof. De Santis


Estensore di collegamento audio senza fili, ad infrarossi.

E' possibile trasmettere il segnale in aria e riceverlo sul modulo ri ricezione:
In alternativa, potete provare ad "accoppiare" trasmettitore e ricevitore con un tubo di plastica, del tipo di quelli usati per impianti elettrici. Può essere una esperienza per i più piccoli o rappresentare una base di lavoro per i più esperti.