Arduino N° 16 - Luci sequenziali 8 canali - avanti/indietro

< Arduino N° 15

Achille De Santis

> Arduino N° 17

Questo sketch fa accendere in sequenza le uscite, una per volta, avanti e indietro.

Per commutazioni rapide, in continua, si consiglia l'uso di moduli MOSFET in uscita.

Per carichi maggiori, a corrente alternata, è possibile inserire in uscita un banco di 8 relé sulle cui uscite collegare i carichi di potenza.
Attenzione all'isolamento!


/* ---------------------Inizio Programma ----------------------------------------
  Comando luci sequenziali 8 canali, avanti/indietro
  30-12-2018 V.2.1
  Programma di Achille De Santis
*/

// uscite: da D2 a D9

const int T= 100;
int i;

void setup()
  {
    for(i=2; i<=9; i++)
    {pinMode(i, OUTPUT);}
  }

void accendi(int pin)  {digitalWrite(pin, HIGH);    }       // eccito il relè collegato al pin
void spegni(int pin)   {digitalWrite(pin, LOW);    }        // rilascio il relè collegato al pin
void commuta(int k)  { accendi(k); delay(T); spegni(k);  }

void sequenza_avanti()
  {  for (i=2; i<=9; i++)  {commuta(i);}    delay(T);  }
void sequenza_indietro()
  {  for (i=9; i>=2; i--)   {commuta(i);}    delay(T);  }

void loop()
  {
    sequenza_avanti();
    sequenza_indietro();
  }

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



Simulazione: 

Luci sequenziali 8 canali - avanti/indietro  - LED Rotanti

Argomenti correlati:

Arduino - giochi di luce

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

> Arduino N° 17

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

Arduino N° 14 - Control Box per Rotore azimutale

< Arduino N° 13

Achille De Santis

> Arduino N° 15

Lavoro scaturito dalla collaborazione tra Achille De Santis - IU0EUF e Dario Francesconi - IW0DYI.

  Come recuperare un vecchio ed economico rotore ex TV ed aggiornarlo con una scheda di controllo Arduino. 

La descrizione del "Control-box per Rotore azimutale" è già stata pubblicata su RadioRama N° 88 pag. 45. Buona lettura e buona sperimentazione!

Fig. 1 : Il pannello frontale con display 

Fig. 2: l'interno del control box

Fig. 4: il pannello posteriore

Fig. 3: vista d'insieme

Foto 5: Particolare del display LCD

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

Nota finale:
Se il vostro rotore usa un motore "sincrono" si può evitare di modificare  il rotore stesso inserendo il potenziometro come sensore di posizione. Basta calcolare il tempo necessario ad effettuare un giro completo di 360° e rapportare il tempo di alimentazione del motore alla posizione da far assumere all'angolo rispetto al nord geografico, preso a riferimento. Naturalmente, il programma va opportunamente modificato. Esempio: Se il rotore impiega 360 secondi per effettuare la rotazione completa, la sua velocità sarà di 1 grado/sec; se volessimo far spostare la posizione angolare di 10 gradi dovremmo comandare il rotore con la sua tensione nominale per 10 secondi. Naturalmente, questa procedura semplifica la meccanica ma globalmente il risultato è meno preciso. Ogni tanto serve ricontrollare ed azzerare la posizione iniziale sul NORD geografico.

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

Per il programma rivolgersi all'autore: tecnatronATgmail.com.

Un interessante aggiornamento è in via di pubblicazione su RadioRama (dopo il n° 101).

v. anche:

Control-box per rotore azimutale - RadioRama N° 88 pag. 45

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

> Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici

Arduino N° 13 - Pilotaggio motoriduttore in DC con ponte ad "H"

< Arduino N° 12

Achille De Santis

> Arduino N° 14

/* ---------------------- Inizio programma -------------------------------------
    Pilotaggio motore in DC con ponte H
    Subroutine per motore avanti ed indietro.
  */

  #define switchPin   2    // switch input
  #define motor1Pin   3    // H-bridge leg 1 (pin 2, 1A)
  #define motor2Pin   4    // H-bridge leg 2 (pin 7, 2A)
  #define enablePin   9    // H-bridge enable pin
  #define ledPin      13      // LED

  void setup()
  {
    pinMode(switchPin, INPUT);  // set the switch as an input:
            // set all the other pins you're using as outputs:
    pinMode(motor1Pin, OUTPUT);
    pinMode(motor2Pin, OUTPUT);
    pinMode(enablePin, OUTPUT);
    pinMode(ledPin, OUTPUT);
 
    digitalWrite(enablePin, HIGH); // set enablePin high so that motor can turn on:
  }
         
 void MOTORE(int M1, int M2)    // predispone il motore generico
   {
     digitalWrite(M1, LOW);         // set leg 1 of the H-bridge low
     digitalWrite(M2, HIGH);        // set leg 2 of the H-bridge high
   }
 
  void avanti()         {     MOTORE(motor1pin, motor2pin);   }      // fa girare il motore in avanti
  void indietro()      {     MOTORE(motor2pin, motor1pin);   }      // fa girare il motore all'indietro

  void loop()
  {
    if (digitalRead(switchPin) == HIGH)          // se lo switch è "alto" il motore girerà in una direzione
    {      avanti();    }
      else                                                       // se lo switch è "basso" il motore girerà nell'altra direzione
      {      indietro();     }
  }

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

Con lo stesso principio informatore è possibile inserire il comando di "fermo" motore.

Lascio al lettore l'onore e l'onere di sviluppare la piccola routine.


Argomenti correlati:
Pilotaggio motoriduttore con accelerazione

Arduino - Modulo driver motori con ponte ad “H”


> Arduino N° 14