Arduino n° 115 - Shield DI PROGRAMMAZIONE PER ARDUINO PRO MINI

 

< Arduino N° 114

Achille De Santis

> Arduino N°  116

Shield di programmazione (v. fig. 1) per Arduino ProMini.

Radiorama n° 132 pag. 89

Fig. 1: Shield di programmazione del Pro-Mini con Arduino UNO;

Una volta preparata questa scheda ausiliaria non avrete più bisogno di cavetti di collegamento per inoculare uno sketch su Arduino ProMini.

Basta posizionare il ProMini (con striscia di contatti maschio) sul connettore ZIF o sul pettine corrispondente (se contatti femmina).

Arduino - Interfaccia con MosFet IRF520

 

Note sull’uso del modulo MOSFET IRF520.

Achille De Santis

Fig. 1: schema elettrico e layout del modulo;

    Da quello che si legge in rete ho notato la scarsità di documentazione fornita e la conseguente incertezza nell’uso del modulo soprattutto da parte dei meno avvezzi all’uso di queste interfacce.

Il problema riscontrato da molti sta nel far funzionare correttamente il modulo!

Niente paura! Cercherò di spiegare il tutto in modo che sia facilmente comprensibile anche agli inesperti.

Il modulo, visibile in fig. 1, sia come “layout” che come schema elettrico, non è altro che un interruttore elettronico a MOSFET in configurazione “Source Comune”.

La diversa tensione di pilotaggio e di attuazione del carico permette un buon isolamento tra le parti.

In pratica, il comando è dell’ordine di 5 Volt mentre la tensione di funzionamento dell’attuatore può andare da 12 a 60 Volt continui.

Prova

1.      Prova a vuoto

a.      Collegare la tensione di 5 volt sull’ingresso (Vcc/GND, v. fig. 1);

b.      Con un cavetto volante, collegare l’ingresso segnale (SIGnal, n.d.a.) al +5 Volt; deve accendersi il led sul modulo, che assicura il comando di Gate. L’ingresso di Gate è ad alta impedenza e non carica l’eventuale uscita di Arduino. Una corrente di circa 3,5 mA è richiesta per alimentare il led, per un totale di circa 8 mA di assorbimento.

2.      Prova a carico

a.      Collegare l’alimentazione del carico (tipicamente 12 volt) su Vin/GND (v. fig. 2);

b.      Sul piedino V+ si deve misurare la tensione Vin di ingresso;

c.      Il piedino V- (del carico, n.d.a.) è collegato al Drain del Mosfet e chiude a massa quando si manda "alto" l’ingresso di segnale, (SIGnal, n.d.a.).

d.      Il carico va inserito tra V+ & V-

3.      Fatto! Provate con un Led opportunamente polarizzato o con un piccolo motorino in CC.

Fig. 2: particolare del layout del modulo, con i piedini di I/O;

    Il modulo (v. fig. 2) si presta anche ad interfacciare segnali PWM. Basta inserire in ingresso un segnale ad impulsi rettangolari 0V/5Volt con duty-cycle variabile. L’uscita avrà un andamento “chopper” in opposizione di fase con il segnale di ingresso. Pilotando un motore con questa tensione si ottiene una velocità “modulabile” entro un ampio margine. Allo stesso modo, pilotando un led si ottiene una luce ad intensità “modulabile”.

Nota: I morsetti Vin e V+  normalmente sono in contatto; se non lo sono spostate il carico da V+ a Vin, lasciando l’altro terminale su V-.

Se siete esperti di SMD potete sostituire la resistenza di pull-down da 1KOhm con altra da 10KOhm, in modo da ridurre la corrente richiesta nella fase di ON. Se non siete esperti... lasciate tutto così com'è!

Fig. 3: interfaccia, tre linee parallele a BJT;

Se volete, potete realizzare questa interfaccia su una piccola piastrina "protoboard" già forata.

In alternativa, al posto del MOSFET potete utilizzare un BJT NPN, in configurazione ad "Emettitore Comune" modificando l'ingresso per il pilotaggio "in corrente" del BJT.

In figura 3 potete vedere la piccola interfaccia realizzata su protoboard con tre linee indipendenti di segnale e BJT in contenitore TO220. Sugli ingressi di base trovate le  rispettive e necessarie resistenze di polarizzazione.

 Se opportuno, potete aggiungere tre piccoli dissipatori per TO220, prima di effettuare le saldature. Lo spazio previsto ne permette un facile montaggio.

Con questa piccola scheda, assemblata su protoboard, potete comandare tre canali indipendenti, sia in modalità ON/OFF, sia lineare,  sia in modalità PWM.

  

Porte Logiche - Simulazione

 Simulazione di porte logiche con integrato TTL SN7400, quadruplo NAND a due ingressi.

Fig. 1: funzioni logiche realizzate con porte SN7400;

Simulazione:

Simulazione porte logiche TTL

Argomenti correlati: 

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

prof. Achille De Santis

Arduino N° 83 - Prova Monitor seriale

 

< Arduino N° 82

Achille De Santis

> Arduino N°  84

Avere una risposta del sistema, come stringa su "monitor seriale", può fare comodo in molti casi pratici.

In questo caso, è possibile controllare visivamente il valore PWM di uscita su un opportuno LED e verificare a monitor il valore attribuito alla variabile.

L'uscita, ovviamente, deve essere del tipo PWM altrimenti non si riesce ad ottenere un valore pseudo-analogico.

Il valore corrispondente viene letto in uscita, secondo la gradinata 0-255; opportunamente "mappato", viene visualizzato anche in percentuale.

Nell'esempio mostrato, ruotando il potenziometro si agisce sull'ingresso analogico in modo continuo.

Il valore corrispondente, in uscita, può essere letto aprendo il  monitor seriale.

Ad evitare inutili scorrimenti delle righe del monitor seriale, che ne renderebbe difficoltosa la lettura, i valori PWM vengono aggiornati soltanto quando si rilevi una variazione rispetto al valore precedente. Si risparmia anche sui tempi di scrittura a monitor e la lettura risulta molto agevole.

                         

Lo sketch e la simulazione del circuito sono disponibili per l'analisi e il download.

• Il potenziometro, collegato sul piedino A0, fornisce la tensione analogica di ingresso
• il LED verde segnala l'accensione del circuito;
• il LED rosso segnala visivamente il valore analogico raggiunto. 

Simulazione:

Prova monitor seriale

Argomenti correlati:  

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

Arduino N° 41 - Bluetooth BLE 4.0 per IPhone

Arduino N° 29 - Selettore bluetooth, 2 canali

tecnatronATgmail.com

> Arduino N°  84

Arduino N° 82 - Charlieplexing 12 LED

< Arduino N° 81

Achille De Santis

> Arduino N°  83

Charlieplexing! 

Ovvero, multiplazione di 12 LED utilizzando soltanto 4 uscite. 

  

/* ---------- Inizio programma ------------------------------------------

 *  Charlieplexing 12 LEDs

 *  Comando di 12 LED con 4 linee di uscita.

 *  Achille De Santis V2.1 del 15-02-2018

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

Row 1 (R1): Arduino Pin 13

Row 2 (R2): Arduino Pin 12

Row 3 (R3): Arduino Pin 11

Row 4 (R4): Arduino Pin 10

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

variable    pinMode      state

 L           OUTPUT       LOW 

 H           OUTPUT       HIGH

 Z           INPUT        LOW

 Z           INPUT        LOW

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

      R1(Pin 13)     R2(Pin 12)     R3(Pin 11)  R4(Pin 10)

L1      L                H               Z            Z

L2      H                L               Z            Z

L3      Z                L               H            Z

L4      Z                H               L            Z

L5      L                Z               H            Z

L6      H                Z               L            Z

L7      L                Z               Z            H

L8      H                Z               Z            L

L9      Z                L               Z            H

L10     Z                H               Z            L

L11     Z                Z               L            H

L12     Z                Z               H            L

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

LED    Cathode     Anode       LED      Cathode      Anode

1       R2          R1          2         R1          R2

3       R3          R2          4         R2          R3         

5       R3          R1          6         R1          R3 

7       R1          R4          8         R4          R1 

9       R2          R4          10        R4          R2 

11      R3          R4          12        R4          R3 

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

*/

#define R1  13     // Riga 1

#define R2  12     // Riga 2    

#define R3  11     // Riga 3

#define R4  10     // Riga 4

void intestazione()

{ Serial.println(" ---------------------------------------------- ");

  Serial.println(" - Tecnatron - ing. Achille De Santis         - ");

  Serial.println(" - tecnatron@gmail.com                        - "); 

  Serial.println(" - Charlieplexing 12 LEDs                     - "); 

  Serial.println(" - D13  R1  13      Riga 1                    - "); 

  Serial.println(" - D12  R2  12      Riga 2                    - "); 

  Serial.println(" - D11  R3  11      Riga 3                    - "); 

  Serial.println(" - D10  R4  10      Riga 4                    - "); 

  Serial.println(" ---------------------------------------------- ");

}

void setup() 

  {              

          // il set-up è variabile! 

          // il setup fisso può essere questo

    Serial.begin(9600);      // stabilisco la velocità di comunicazione

    intestazione();          // intestazione, inviata alla seriale

  }

void charlie(int L1, int L2, int L3, int L4)         // Routine per la gestione dei Led

{             // Basso,  Alto,  Z,  Z)

  // accende il LED generico

  pinMode(L1, OUTPUT);   digitalWrite(L1, LOW);  // Riga 1

  pinMode(L2, OUTPUT);   digitalWrite(L2, HIGH); // Riga 2

  

  pinMode(L3, INPUT);    digitalWrite(L3, LOW);  // Riga 3

  pinMode(L4, INPUT);    digitalWrite(L4, LOW);  // Riga 4

  

  delay(500);

}

void loop()

{

  charlie(R1, R2, R3, R4);    //turn on LED1

  charlie(R2, R1, R3, R4);    //turn on LED2

  

  charlie(R2, R3, R1, R4);    //turn on LED3

  charlie(R3, R2, R1, R4);    //turn on LED4

  

  charlie(R1, R3, R2, R4);    //turn on LED5

  charlie(R3, R1, R2, R4);    //turn on LED6

  

  charlie(R1, R4, R2, R3);    //turn on LED7

  charlie(R4, R1, R2, R3);    //turn on LED8

  

  charlie(R2, R4, R1, R3);    //turn on LED9

  charlie(R4, R2, R1, R3);    //turn on LED10

  

  charlie(R3, R4, R1, R2);    //turn on LED11

  charlie(R4, R3, R1, R2);    //turn on LED12  

}

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

Lo sketch e la simulazione del circuito sono disponibili per l'analisi e il download.

Simulazione:

Charlieplexing con 6 LED

Argomenti correlati:  

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

Arduino N° 5 - LED rotanti

Arduino - giochi di luce

tecnatronATgmail.com

> Arduino N°  83

Arduino N° 81 - Stazione meteo con TMP36

< Arduino N° 80

Achille De Santis

> Arduino N°  82

Stazione meteo per misure di temperatura e di umidità, con il circuito integrato TMP36 ed un sensore di umidità relativa.

Regolare la simulazione di temperatura con il cursore  e l'umidità con il potenziometro rotativo.

Lo sketch e la simulazione del circuito sono disponibili perl'analisi e il download.

tecnatronATgmail.com

Lo sketch e la simulazione del circuito sono disponibili per l'analisi e il download.

Simulazione:

Stazione meteo con TMP36

Argomenti correlati:  

Arduino N° 41 - Bluetooth BLE 4.0 per IPhone

Arduino N° 29 - Selettore bluetooth, 2 canali

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

> Arduino N°  82

Arduino N° 80 - Commutazione di tre LED con i rispettivi pulsanti.

< Arduino N° 79

Achille De Santis

> Arduino n° 81

Per accendere e spegnere dei LED bastano dei semplici pulsanti. L'uso di un microcontrollore permette di sviluppare altre funzionalità.

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

Commutazione di tre LED con i rispettivi pulsanti. 

I comandi sono di tipo "Toggle"; un impulso accende la corrispondente lampada,  un altro la spegne quindi è possibile accendere e spegnere le tre uscite mantenendone lo stato.

Inoltre, dalla logica utilizzata risulta che tenendo premuto un pulsante si ottiene il lampeggio del relativo LED con periodo di circa un secondo,

Lo sketch e la simulazione del circuito sono disponibili per l'analisi e il download.

Simulazione:

Commutazione di tre LED con i rispettivi pulsanti.

Argomenti correlati:  

Commutazione momentanea di un LED con tre pulsanti di comando

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

Arduino N° 29 - Selettore bluetooth, 2 canali

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

tecnatronATgmail.com

> Arduino N°  81

Arduino N° 79 - Commutazione momentanea di un LED con tre pulsanti di comando

< Arduino N°  78

Achille De Santis

> Arduino N°  80

Selettore momentaneo per commutare l'uscita ON/OFF da tre punti di comando.

L'uscita è collegata, come esempio, su un LED opportunamente polarizzato.

Gli ingressi sono usati in modalità "pull-up", quindi vanno comandati con un segnale "attivo basso", forzando a massa temporaneamente, tramite pulsante.

L'uscita, normalmente bassa, commuta all'arrivo del comando.

Si può associare il dispositivo alla funzione di Multivibratore Monostabile.

Ovvio che in elettronica cablata basterebbe un circuito con qualche porta logica o con un Timer NE555. Di contro, questa soluzione sarebbe comoda nel caso si disponesse già del microcontrollore. Basterebbe integrare il firmware con questa semplice procedura.

Lo sketch e la simulazione del circuito sono disponibili per l'analisi e il download.

Simulazione:

Commutazione momentanea di un LED con tre pulsanti di comando

Argomenti correlati:  

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

Arduino N° 29 - Selettore bluetooth, 2 canali

tecnatronATgmail.com

> Arduino N°  80

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° 23 - Fader per canali RGB

< Arduino N° 22

Achille De Santis

> Arduino N° 24

Gestione proporzionale PWM dei colori per un LED RGB a "catodo comune".
Lo sketch produce lo spegnimento progressivo dei LED (affievolimento).

Con facili modifiche è possibile ottenere l'accensione progressiva di ogni colore, lo spegnimento progressivo, il lampeggio, la miscelazione dei colori primari ecc...
I colori "primari" Rosso, Verde, Blu permettono di generare tutti gli altri colori, compreso il bianco, con opportuni coefficienti.

/* ------------------- Inizio Programma ----------------------------------------------------------------
 * Achille De Santis
 * fader per canali RGB  - V2.0 del 02-07-2019
 * collegare i LED con una resistenza, in serie, da 470 Ohm.
*/

// ------------- I/O -----------
#define VERDE   9
#define BLU     10
#define ROSSO   11
// -----------------------------

int delayTime = 20;

void setup()
  {
    pinMode(VERDE, OUTPUT);
    pinMode(BLU, OUTPUT);
    pinMode(ROSSO, OUTPUT);
 
  }

void accenditutto()
  {
    analogWrite(VERDE, 255);
    analogWrite(BLU, 255);
    analogWrite(ROSSO, 255);
  }

void spegni(int colore)
  {
    for (int i=0; i<255; i++)
     {
      analogWrite(colore, 255-i);
      delay (delayTime);
     } 
  }
 
void loop()
   { 
      accenditutto();
      spegni(VERDE); 
      spegni(BLU);
      spegni(ROSSO);
   }
 // ---------------------- Fine Programma -------------------------------------------------------------


Simulazione:
Fader per RGB a catodo comune
Fader per RGB ad anodo comune
Controllo di accelerazione per motore in DC con PWM


Arduino N° 24

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

Arduino N° 12 - Beacon per ARDF - selezionabile

< Arduino N° 11

Achille De Santis

> Arduino N° 13

Foto 1: il modulo beacon su 
Arduino Nano;

Beacon  selezionabile - 5 banchi di memoria.

Questo identificatore telegrafico trasmette una nota di bassa frequenza, direttamente ricevibile con Apparati in AM o FM a banda stretta.
I messaggi impostati per la radiocaccia sono MO1... MO5, selezionabili a piacere.
La selezione del beacon si opera mettendo a massa, con un dip-switch, il piedino associato (beaconsetX).
In questo caso, la selezione della memoria può essere fatta anche "a caldo", senza bisogno di resettare il modulo. Viene terminato il beacon in riproduzione ed inserito in loop il nuovo beacon.
La temporizzazione è calcolata in modo da avere sempre un rapporto 1-3-5, come da standard del codice Morse.

/* --------------- Inizio programma --------------------------
  Achille De Santis V2.0 del 12-12-2014 V3.0 del 13-12-2015
  Beacon RDF CW Multiplo, con 5 messaggi pre-selezionabili.
  1 linea di uscita per il comando di PTT
  1 linea di uscita per il testo CW_BF
  5 testi beacon, in uscita, selezionabili alternativamente;
  il pin 13 è l'uscita del testo beacon;
  il pin 12 è il comando di PTT.
*/

// --------------------------- I/O ------------------------------------------
#define pin 13                 // Uscita testo beacon sul piedino 13.
#define ptt 12                 // comando ptt sul piedino 12.
#define beaconset1 11
#define beaconset2 10
#define beaconset3 9
#define beaconset4 8
#define beaconset5 7
// ------------------------------------------------------------------------

const int T = 100;   // Definizione costante base tempi T.
const int T3=3*T;
const int T4=4*T;
const int T10=10*T;
const int freq = 1000;

void genera(int T1)
{
  tone(pin, freq); delay(T1);
  noTone(pin);     delay(T);
}

void punto()  {   genera(T);   }
void linea()  {   genera(T3);   }

void MO()
{
  linea(); linea();                 delay (4*T);            // M
  linea(); linea(); linea();        delay (4*T);         // O
}

void beacon1()    {    MO();    punto(); linea(); linea(); linea(); linea(); delay (T4);     }   //MO1   
void beacon2()    {    MO();    punto(); punto(); linea(); linea(); linea(); delay (T4);    }   //MO2 
void beacon3()    {    MO();    punto(); punto(); punto(); linea(); linea(); delay (T4);   }   //MO3 
void beacon4()    {    MO();    punto(); punto(); punto(); punto(); linea(); delay (T4);  }   //MO4 
void beacon5()    {    MO();    punto(); punto(); punto(); punto(); punto(); delay (T4); }   //MO5
void setup()
{
 pinMode(pin, OUTPUT);                            //Variabile di uscita tono
 pinMode(ptt, OUTPUT);                             //Variabile di uscita PTT
 pinMode(beaconset1, INPUT_PULLUP);
 pinMode(beaconset2, INPUT_PULLUP);
 pinMode(beaconset3, INPUT_PULLUP);
 pinMode(beaconset4, INPUT_PULLUP);
 pinMode(beaconset5, INPUT_PULLUP);
}

void loop()
{ digitalWrite(ptt, 1);     delay (T);     // attiva PTT
  if (digitalRead(beaconset1)==0)                  { beacon1();  // delay (T3);   }
    else if (digitalRead(beaconset2)==0)                { beacon2();   // delay (T3);         }
           else if (digitalRead(beaconset3)==0)                 { beacon3();   // delay (T3);     }
                 else if (digitalRead(beaconset4)==0)                    { beacon4();  // delay (T3);   }
                     else if (digitalRead(beaconset5)==0)                         {beacon5();  // delay (T3);       } 

  digitalWrite(ptt, 0);    // disattiva PTT
  delay (T10);
 }

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

Nota: inserendo il comando di "portante" all'interno del beacon scelto si evita di far partire la trasmissione se non c'è alcun messaggio beacon selezionato.
In questo modo si ha anche una indicazione, sullo stesso LED, dell'attivazione di un qualunque messaggio beacon. Nel primo caso, comandando la portante "a priori" e non selezionando lo specifico messaggio si avrebbe l'emissione della sola portante non modulata (che può avere comunque un significato, n.d.a.).

Simulazione:

Beacon per ARDF - selezionabile
Esempio di beacon modulato in BF

Argomenti correlati:

Arduino N° 4 - Beacon CW modulato in BF


> Arduino N° 13