mercoledì 25 dicembre 2019

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 ---------------------------------------------



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


Arduino N° 30


mercoledì 18 dicembre 2019

Arduino N° 28 - Azionamento relay per motoriduttori avanti / indietro

Arduino N° 27

 Achille De Santis

Arduino N° 29





Routine da utilizzare nel corpo del programma.
Nel programma vanno definiti i parametri di ingresso alla routine:   R1, L1, R2,
Rele1  è il comando per il primo relé;
Rele2  è il comando per il secondo relé;
LED1  è una 'spia di equilibrio'.


 /* -------------- Inizio Programma -----------------------------------------------------------------
 *  Azionamento relay per motoriduttori avanti / indietro
 *  Un potenziometro stabilisce la posizione angolare del motoriduttore;
 *  un sensore di posizione (a  potenziometro),  collegato "a ponte" con il primo, rivela il
 *  raggiunto equilibrio.
 */
// ------- I/O ---------------------------------------
#define rele1       11
#define rele2       12
#define Ledpin3  13
// ---------------------------------------------------

void titolo()
{
  Serial.println(" -          Tecnatron Creation                    - ");
  Serial.println(" -          tecnatron@gmail.com               - ");
  Serial.println(" - Azionamento relay per motoriduttori   ");
  Serial.println(" -  Avanti / Indietro                                 - ");
  Serial.println(" ----------------------------------------------- ");
}

void azionamento(bool R1, bool L1, bool R2) // routine ausiliaria non richiamata direttamente.
     {
       digitalWrite(rele1, R1);
       digitalWrite(Ledpin3, L1);         // Led equilibrio
       digitalWrite(rele2, R2);
     }     
 void fermo()       { azionamento (HIGH, HIGH, HIGH); }
 void sinistra()    { azionamento (HIGH, LOW, LOW);   }
 void destra()      { azionamento (LOW, LOW, HIGH);   }

void setup()
{
  Serial.begin(9600);             // velocità di comunicazione
  titolo();
  pinMode (rele1, OUTPUT);
  pinMode (rele2, OUTPUT);
  pinMode (Ledpin3, OUTPUT);
}

void loop()
{
               // inserire qui il programma
}

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


Nota:
Se non volete caricare troppo l'uscita di Arduino o del microcontrollore potete inserire uno stadio buffer a BJT sul piedino di uscita del canale di comando.



Simulazione: 

mercoledì 11 dicembre 2019

Arduino N° 27 - Pilotaggio di 2 motori con ponte ad H

Arduino N° 26

 Achille De Santis

Arduino N° 28




Utili sottoprogrammi per la gestione ed il controllo di motori in continua da utilizzare per la movimentazione  di robot, veicoli ecc...


/* ---------------------------- Inizio Programma -----------------------------
 *  Achille De Santis
 * Pilotaggio di 2 motori con ponte H
 * V5 del 09-07-2019
 * In questo modo è facile pilotare anche tre o più motori.
 * Base di lavoro per la gestione di ROBOT, veicoli telecomandati ed altro.
*/

// ---------- pin dell'asse X dei motori --------------
#define MOTOR_XA      13  // motore polo XA
#define MOTOR_XB      12  // motore polo XB
// ---------- pin dell'asse Y dei motori --------------
#define MOTOR_YA      11  // motore polo YA
#define MOTOR_YB      10  // motore polo YB
// --------------------------------------------------------

void motore(int MA,bool A, int MB, bool B)       // motore generico
{
  digitalWrite(MA, A);  // motore, pin A
  digitalWrite(MB, B);  // motore, pin B
}

// --------------------------------------------------------------------------
void avantiSX()   {motore(MOTOR_XA, 1, MOTOR_XB, 0);}
void avantiDX()   {motore(MOTOR_YA, 1, MOTOR_YB, 0);}
void avanti()     {avantiSX(); avantiDX();}
// --------------------------------------------------------------------------
void indietroSX() {motore(MOTOR_XA, 0, MOTOR_XB, 1);}
void indietroDX() {motore(MOTOR_YA, 0, MOTOR_YB, 1);}
void indietro()   {indietroSX(); indietroDX();}
// --------------------------------------------------------------------------
void fermoSX()    {motore(MOTOR_XA,0,MOTOR_XB,0); }
void fermoDX()    {motore(MOTOR_YA,0,MOTOR_YB,0); }
void fermo()      {fermoSX(); fermoDX();  }
// -----------------------------------------------------------------------------
void DXavanti() { fermoDX(); avantiSX(); delay(300); avanti(); }
void SXavanti() { fermoSX(); avantiDX(); delay(300); avanti();  }
// -----------------------------------------------------------------------------
void DXindietro() { fermo(); indietroSX(); delay(300); fermo(); }
void SXindietro() { fermo(); indietroDX(); delay(300); fermo(); }
// ----------------------------------------------------------------------------- 

void setup()
{
  pinMode (MOTOR_XA, OUTPUT);
  pinMode (MOTOR_XB, OUTPUT);
  pinMode (MOTOR_YA, OUTPUT);
  pinMode (MOTOR_YB, OUTPUT);
}

void loop()
{
    // inserire qui il programma
}

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


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ì 27 novembre 2019

Arduino N° 25 - Termometro LCD














Arduino N°  24

 Achille De Santis

Arduino N° 26




Termometro a cristalli liquidi LCD, con sensore di temperatura TMP36 e display LCD 16x2 (2 righe x 16 colonne).


/* ------------------ Inizio Programma ------------------------------------------------
 * Termometro a cristalli liquidi LCD.
 * Elementi utilizzati:
 * display LCD 16x2  
 * potenziometro  
 * Sensore TMP36  
 * breadboard
 * Il sensore è un TMP36, incluso nello starter kit Ufficiale di Arduino,
 *  e va collegato al pin analogico A0.
 * modificato da Achille De Santis il 04/07/2019
 * V2.1

#include <LiquidCrystal.h>        // Include la libreria driver LCD
// ---------- I/O --------------
#define tempPin  A0                   // piedino analogico di ingresso
// -----------------------------
float tempC=0;                           // Variabile per memorizzare la temperatura in Celsius
float samples[100];                    // Array che contiene 100 esempi di calcolo di temperatura media
int   i;
float x ;                                               
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);       // Inizializzo la libreria con i numeri dei pin dell'interfaccia

void predisponedisplay()
  { lcd.clear(); lcd.setCursor(0,0);   }   // Cancello LCD

void setup()
{
  lcd.begin(16, 2);                          // Imposto il numero di colonne e righe (rispettivamente) del LCD
  predisponedisplay();   
  lcd.print("Attendere! Sto calcolando la temperatura");
  delay(600);
  for (int i=0; i<23; i++)
    {
      delay(400);
      lcd.scrollDisplayLeft();
    }
}

void loop()

  tempC=0 ;
  for(i=0; i<=99; i++)
  {
    x= analogRead(tempPin);
    samples[i]=(x-100)-((x-100)/2);  // (L'equazione è: 0 Celsius=100, 100 Celsius=300)
    tempC = tempC + samples[i];
    lcd.setCursor(int(i/10),1);
    delay(20);
  }
  tempC = tempC/100;
  predisponedisplay();           // predispone la posizione del cursore del LCD (colonna 0, riga 0)
  lcd.print("Temperatura");   // visualizza la stringa "Temperatura" sul LCD
  lcd.setCursor(0,1);             // vai a riga nuova: elimina gli spazi andando a capo (colonna 0, riga 1)
  lcd.print("corrente: ");      // scrive la stringa "corrente " (da colonna 0, riga 1)
  lcd.setCursor(10,1);          // mette il cursore del LCD in posizione (colonna 10, riga 1)
  lcd.print(tempC, " C");     // visualizza la temperatura corrente nel LCD
  lcd.noCursor();
//  tempC = 0;                // imposta la temperatura a 0 per ripetere la misura
}
// ------------------------ Fine programma ---------------------------------------------------------------



Arduino N° 26

mercoledì 20 novembre 2019

Arduino N° 24 - Pilotaggio di posizione angolare servo

Arduino N° 23

 Achille De Santis

Arduino N° 25




/* ------------------------------------ Inizio Programma ------------------------------------------

 Controlla la posizione angolare (escursione) di un servo attraverso un potenziometro
 by Michal Rinott <http://people.interaction-ivrea.it/m.rinott>

 modified on 8 Nov 2013 by Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Knob

 Aggiunta routine da Achille De Santis - 26-02-2019
 usare una resistenza in serie al potenziometro di uguale valore.
 In questo modo si riduce la corrente nel potenziometro e si limita l'escursione di tensione.
*/

#include <Servo.h>
// --------------------------------
#define U          9        // uscita servo
#define potpin  0        // piedino analogico usato per collegare il potenziometro
// --------------------------------
Servo myservo;          // crea l'oggetto servo per controllare un servomotore
int     val;                    // variabile per leggere il valore dall'ingresso analogico

void setup()
{
  myservo.attach(U);    // associa il servo al pin di uscita (9)
  Serial.begin(9600);
}

void muoviservo(Servo x, int v, int p)
{ // questa routine può essere convenientemente usata per altri servo
  v=analogRead(p);          // legge il livello del potenziometro (tra 0 e 1023)
    Serial.print(v); Serial.print(' ');
  v=map(v, 0, 900, 0, 180); // scala il valore in gradi, per usarlo con il servo (valore tra 0° e 180°)
  x.write(v);               // assegna la posizione al servo, in gradi
    Serial.println(v);
  delay(15);                // ritarda
}

void loop()
  {      muoviservo(myservo, val, potpin);     }

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

venerdì 15 novembre 2019

Arduino - Routine di Intestazione



prof. A. De Santis


Se non ricordate quale sia il programma o la versione di software che avete caricato sulla vostra scheda Arduino, e soprattutto se ne avete più di una in lavorazione, questa risorsa può essere molto utile.



Ho messo a punto questa piccola routine nella quale potete inserire alcune info per il vostro sketch.

La routine va inserita nel vostro FW e con essa, aprendo il monitor seriale, sarà possibile risalire alle info sul programma; la routine "Intestazione" è depositata sulla cartella "file" all'indirizzo: https://www.facebook.com/groups/197979647635131/permalink/573106700122422/ 

ed è visibile anche sulla pagina di simulazione.


Potete copiarla e "richiamarla" nel setup del programma; non occupa molto spazio ed è comoda per riconoscere immediatamente il vostro lavoro, aprendo il monitor seriale; serve soltanto qualche riga di commento.


Simulazione: "Intestazione"


Graditi feedback.

mercoledì 13 novembre 2019

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

mercoledì 6 novembre 2019

Umoristicamente sulle Radiosonde e i loro cacciatori

Fig. 2: Vetusta radiosonda RS 80-15; foto A. De Santis;


Fig. 1: Targa originale: il primo grande pallone a idrogeno;
 Parigi - giardini di  Champ de Mars (Campo di Marte); foto A. De Santis;





















"Sondosi" (sondosis) (codice ICD U.41.92) appartiene ad un gruppo di malattie incurabili derivanti dalle singole caratteristiche degli individui esposti alla sua azione. Non v'è alcuna chiara eziologia, tuttavia, abbiamo trovato un alto grado di suscettibilità alla malattia nell'ambiente dei radioamatori ed appunto in questo ambiente si dovrebbe cercare le cause di questa malattia.
Fig. 3: MySondy-GO,
Moderno apparato per tracking di radiosonde;


Al momento non vi è cura per questa patologia, si può soltanto agire sulla sintomatologia.



Esistono vari tipi di sondosi:

- Sondosi comune (s. vulgaris) - individui monitorano costantemente il movimento delle sonde in atmosfera, hanno gli strumenti statici e mobili di rilevamento in diverse configurazioni; attaccano, pur senza costrizione, gli oggetti fino a 25 km dal luogo di residenza abituale, casi non pericolosi per chi li circonda: parenti, amici.





- Sondosi presunta (s. suspicatis) – forma lieve della malattia, caratterizzata da sintomi che si notano periodicamente e scompaiono rapidamente, simile alla forma di sondosi comune, i sintomi spesso si innescano in modo non specifico.

Fig. 4: MySondyGO, versione sperimentale;


- Sondosi acuta (s. acuta) - individui affetti da questa variante della sondosi costantemente monitorano il movimento della sonda nell'atmosfera, non si fanno sfuggire alcuna possibilità di attacco. Per seguire la sonda, possono percorrere oltre 100 km solo all’andata. Non saranno fermati da alcun problema meteorologico o ostacoli del terreno. Possono subire attacchi improvvisi della malattia come descritto in letteratura; l'individuo colpito dal sondosi acuta si è svegliato urlando di notte: "la sonda è in volo" e poi è scappato di casa. È stato trovato mezzo nudo a circa 40 km da casa tenendo in mano una sonda. Si è rifiutato di indossare abiti e tornare a casa, sostenendo che "tra 2 ore ci sarà una seconda sonda e forse anche una terza";


Fig. 5: Nodo/Gateway  per tracking di radiosonde;

- Sondosi malevola (s. malicious) - individui con sintomi caratteristici delle sondosi riportate sopra; tuttavia, coloro che sono affetti da questa forma agiscono in modo segreto come i cosiddetti "sordomuti" e spesso, nella fase di caccia, sottraggono la sonda ad altri individui. Questa variante include anche individui che disabilitano deliberatamente la propria stazione di localizzazione quando la sonda scende al di sotto di 2000 m, in modo che nessuno, tranne lui stesso, possa trovare l'oggetto.


E tu a quale forma di sondosi appartieni?:) 



tecnatronATgmail.com


Arduino N° 22 - Stampa seriale in vari formati

Arduino N° 21

 Achille De Santis

Arduino N° 23



Questo sketch è utile per familiarizzarsi con la scrittura seriale e con le basi delle numerazioni usate in Elettronica ed Informatica.


/* ----------------------------- Inizio Programma --------------------------------------------
 * Uses a FOR loop for data and prints a number in various formats.
 * Modificato da Achille De Santis 07-04-2019
 * Per vedere la stampa, aprire il monitor seriale.
*/

int x = 0;    // variable

void setup()
  { Serial.begin(9600); }   // open the serial port at 9600 bps: 

void loop()
{                           // print labels - stampa le etichette, tabulando opportunamente.
  Serial.print("NO FORMAT\t", "DEC\t", "HEX\t", "OCT\t", "BIN\n" );

  for(x=0; x<64; x++)
  {   // only part of the ASCII chart, change to suit
      // print it out in many formats: stampa, tabulando, in vari firmati
    Serial.print(x, "\t",x,DEC, "\t",x,HEX, "\t",x,OCT, "\t",x,BIN );  // print as an ASCII-encoded decimal
    delay(200);             // delay 200 milliseconds
  }
  Serial.println("");       // prints another carriage return
  delay(500);
}
// -------------------------------- Fine Programma ----------------------------------------------

Arduino N° 23

mercoledì 30 ottobre 2019

Arduino N° 21 - Dado elettronico con display 7 segmenti

Arduino N° 20

 Achille De Santis

Arduino N° 22




Estrazione numeri da un Dado a sei facce (1-6).


Aggiunto un impulso di "strobe" per indicare l'esecuzione del comando.  

/* -------------------------- Inizio Programma -----------------------------------------------------------
  Achille De Santis - 28-04-2018
  V2.0 del 02-07-2019
  dado elettronico con display a 7 segmenti.
  Uso di funzioni per la definizione dei numeri con display 7-segmenti a "catodo comune".
*/

// --------------- I/O ------------------------
#define LED_A     5
#define LED_B     6
#define LED_C     7
#define LED_D     8       //Associo ad ogni segmento il proprio piedino
#define LED_E     9
#define LED_F     10
#define LED_G     11
#define DP            12
#define buttonPin   2
// --------------------------------------------

int buttonState;
long ran;
const int time = 1000;

void setup ()
{
  // ----------------------------------------------
  pinMode(buttonPin, INPUT_PULLUP);
 // -----------------------------------------------

  pinMode(LED_A, OUTPUT);
  pinMode(LED_B, OUTPUT);
  pinMode(LED_C, OUTPUT);    // INDIRIZZO I LED IN USCITA E IL PULSANTE IN ENTRATA
  pinMode(LED_D, OUTPUT);
  pinMode(LED_E, OUTPUT);
  pinMode(LED_F, OUTPUT);
  pinMode(LED_G, OUTPUT);
  pinMode(DP, OUTPUT);           // impulso di strobe sul "dot point"

  randomSeed(analogRead(0));
}

void strobe() // Impulso di "strobe" per indicare l'immissione del comando
{
  digitalWrite(DP, HIGH);  delay(100);
  digitalWrite(DP, LOW);         // delay(100);
}

void UNO()
{
  digitalWrite(LED_B, HIGH);
  digitalWrite(LED_C, HIGH);
}

void DUE()
{
   digitalWrite(LED_A, HIGH);
   digitalWrite(LED_B, HIGH);
   digitalWrite(LED_D, HIGH);
   digitalWrite(LED_E, HIGH);
   digitalWrite(LED_G, HIGH);
}

void TRE()
{
  digitalWrite(LED_A, HIGH);
  digitalWrite(LED_B, HIGH);
  digitalWrite(LED_D, HIGH);
  digitalWrite(LED_C, HIGH);
  digitalWrite(LED_G, HIGH);
}

void QUATTRO()
{
  digitalWrite(LED_B, HIGH);
  digitalWrite(LED_C, HIGH);
  digitalWrite(LED_F, HIGH);
  digitalWrite(LED_G, HIGH);
}

void CINQUE()
{
  digitalWrite(LED_A, HIGH);
  digitalWrite(LED_C, HIGH);
  digitalWrite(LED_D, HIGH);
  digitalWrite(LED_F, HIGH);
  digitalWrite(LED_G, HIGH);
}

void SEI()
{
   digitalWrite(LED_A, HIGH);
   digitalWrite(LED_C, HIGH);
   digitalWrite(LED_D, HIGH);
   digitalWrite(LED_E, HIGH);
   digitalWrite(LED_F, HIGH);
   digitalWrite(LED_G, HIGH);
}

void AZZERA()
{
   digitalWrite(LED_A, LOW);
   digitalWrite(LED_B, LOW);
   digitalWrite(LED_C, LOW);  // RESETTO TUTTI I segmenti
   digitalWrite(LED_D, LOW);
   digitalWrite(LED_E, LOW);
   digitalWrite(LED_F, LOW);
   digitalWrite(LED_G, LOW);
}

void loop()
{
  buttonState=digitalRead(buttonPin);
  if (buttonState==LOW)                     // attivo basso!
  { strobe(); AZZERA();
    ran=random(1,7);
    switch(ran)
      {
        case 1:     UNO();          break;
        case 2:     DUE();           break;
        case 3:     TRE();            break;
        case 4:     QUATTRO(); break;
        case 5:     CINQUE();    break;
        case 6:     SEI();             break;
        // case 7:     break;
       default: ;
      }
    delay (time);
  }
}
// ------------------------ Fine programma --------------------------------------------------------


Simulazione: Dado elettronico

Per utilizzare i display ad "anodo comune" si possono prevedere dei transistori invertitori di fase, in uscita, o "complementare le uscite sulle routines di definizione delle cifre, aggiungendo anche gli opportuni valori iniziali. Il corpo del programma resta lo stesso.
Invece delle routine così definite, per il pilotaggio del display si potrebbe fare uso di un array a 7 elementi.



Argomenti correlati:
Dado elettronico V2
Estrazione numeri al Lotto



Arduino N° 22

mercoledì 23 ottobre 2019

Arduino N° 20 - Controllo motore CC con PWM

Arduino N° 19

 Achille De Santis

Arduino N° 21




Controllo di velocità per motori in Corrente Continua attraverso comando PWM.
Due pulsanti UP/DOWN permettono di regolare la velocità in modo "proporzionale" con una "gradinata" di 256 valori diversi.
Uno stadio driver a transistore BJT accoppia/separa lo stadio finale attuatore.
Dimensionando opportunamente lo stadio è anche possibile alimentare un motore  a tensioni nominali diverse (es. 12 V o 24 volt).


/* ------------------------------Inizio Programma -------------------------------------
 *  26/5/2015
 *  PWM per comando dei motori in CC (controllo UP/DOWN)
 *  L'uscita va disaccoppiata con uno stadio driver.
 *  Modificato da Achille De Santis il 07-07-2019
 *
*/

// -------------------------- I/O .------------------------
#define UP           2     
#define DOWN    3   
#define USCITA  9           // Uscita PWM
// --------------------------------------------------------

bool S1;                         // variabili booleane interne
bool S2;
const int PAUSA=10;   // Costante pausa. Serve a dare comandi progressivi non troppo veloci.
int pwm;                       // variabile di uscita

void setup()
{
  // Impostazione di pull-up interna ad Arduino
  pinMode(UP, INPUT_PULLUP);            // il pulsante va collegato verso massa
  pinMode(DOWN, INPUT_PULLUP);    // il pulsante va collegato verso massa
  pinMode(USCITA, OUTPUT);               // uscita per comando motore
  pwm = 0;
}

void loop()
{
  S1=digitalRead(UP);
  S2=digitalRead(DOWN);

  if(S1=LOW && pwm<255) pwm++;
    else if(S2=LOW && pwm>0) pwm--;
  analogWrite(USCITA, pwm);
  delay(PAUSA);
}

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



mercoledì 16 ottobre 2019

Arduino N° 19 - Prova di 2 motori in DC usando un Ponte H

Arduino N° 18

 Achille De Santis

Arduino N° 20





Prova di due motori in DC, o di due motoriduttori, per controllare la giusta funzione dei comandi.

Si tratta, qui, di piccoli motori a magneti permanenti.

Per motori ad eccitazione indipendente il programma va adeguatamente adattato.
E' possibile cambiare i piedini di uscita per i motori, per adattarli a quelli disponibili ed al dispositivo utilizzato.


/* -----------------------------Inizio programma --------------------------------------------
 * Controllo di 2 motori in DC usando un Ponte H a due canali con L298N
 * Autore: Achille De Santis
*/

// --------------------------- I/O ---------------------------------------------------------------
//Definizione piedini Arduino collegati all'entrata del Ponte H
// ---------------- M1 --------
#define IN1 4
#define IN2 5
// ---------------- M2 -------
#define IN3 6
#define IN4 7
// ----------------------------------------------------------------------------------------------

  const int T1= 2000;   // tempo di ON
  const int T2= 500;    // tempo di OFF

void setup()
  {                           //Definisce i piedini di uscita
    pinMode(IN1, OUTPUT);
    pinMode(IN2, OUTPUT);
    pinMode(IN3, OUTPUT);
    pinMode(IN4, OUTPUT);
  }

void MOTORE(int A, boolean a, int B, boolean b) // azionamento motore generico
  {    digitalWrite(A, a);       digitalWrite(B, b);  }

void AVANTI (int A, int B)     {  MOTORE(A, HIGH, B, LOW);  }    // azionamento motore avanti
void DIETRO (int A, int B)    {  AVANTI(B, A);  }                            // azionamento motore indietro
void FERMO(int A, int B)      {  MOTORE(A, LOW, B, LOW);    }   // arresto motore generico

void loop()
  {
    AVANTI(IN1, IN2); delay(T1);    // Ruota Motore A in senso orario
    FERMO(IN1, IN2);  delay(T2);   // Ferma motore A 
    AVANTI(IN3, IN4); delay(T1);    // Ruota Motore B in senso orario
    FERMO(IN3, IN4);  delay(T2);   // Ferma motore B
    DIETRO(IN1, IN2); delay(T1);   // Ruota Motore A in senso anti-orario
    FERMO(IN1, IN2);  delay(T2);   // Ferma motore A
    DIETRO(IN3, IN4); delay(T1);   // Ruota Motore B in senso anti-orario
    FERMO(IN3, IN4);  delay(T2);   // Ferma motore B
  }
// ------------------------------ Fine programma -----------------------------------------------------



Riferimenti: Pilotaggio di motoriduttore in DC

Argomenti correlati: 

Arduino - Modulo driver motori con ponte ad “H”


mercoledì 9 ottobre 2019

Arduino N° 18 - Pilotaggio motore in DC

Arduino N° 17

 Achille De Santis

Arduino N° 19

 


Il  pilotaggio di motori in corrente continua è una delle applicazioni usate nell'IoT per la movimentazione di oggetti, robot ed altro.
Naturalmente, per effettuare in modo conveniente e con tecnica "generale" il pilotaggio dei motori in DC occorre predisporre un "Ponte ad H". Il ponte ad H è chiamato così per la sua tipica configurazione, a forma di H, dove il carico occupa una diagonale. Con opportuni comandi si può inviare al carico una tensione positiva o negativa.

Come al solito, il programma è "strutturato" e presenta delle routine che, svolgendo le operazioni ripetitive, semplificano l'implementazione di tutti i comandi.

Lascio all'utente l'onere e l'onore di prevedere un comando con funzione di ARRESTO MOTORE.
Prima di invertire il senso di marcia è sempre consigliabile passare per il comando di arresto!

Nota importante: questo programma NON è adatto per i motori che hanno una eccitazione indipendente ma, nel caso. si potrebbe adattare facilmente.


/* -------------------- Inizio Programma --------------------------
    Pilotaggio motore in DC con ponte H
    Achille De Santis - V3 del 27-06-2019
    Subroutine per motore avanti/indietro.
  */
// ------------------------- I/O ----------------------------------------
  #define switchPin    2    // comando verso di rotazione
  #define motor1Pin   3    // H-bridge morsetto 1 (pin 2, 1A)
  #define motor2Pin   4    // H-bridge morsetto 2 (pin 7, 2A)
  #define enablePin    9    // H-bridge enable pin
  #define ledPin        13   // LED
  //----------------------------------------------------------------------

  void blink(int whatPin, int howManyTimes, int milliSecs)         //    blinks an LED
  {
    int i=0;
    for (i=0; i<howManyTimes; i++)
    {
      digitalWrite(whatPin, HIGH); delay(milliSecs/2);
      digitalWrite(whatPin, LOW);  delay(milliSecs/2);
    }
  }

 void motore(boolean M1, boolean M2)                              // comanda il motore
   {
     digitalWrite(motor1Pin, M1);   // predispone il morsetto 1 del ponte H
     digitalWrite(motor2Pin, M2);   // predispone il morsetto 2 del ponte H
   }

  void avanti()   {  motore(0,1); }   // fa girare il motore in avanti
  void indietro() {  motore(1,0); }  // fa girare il motore all'indietro

  void setup()
  {
    pinMode(switchPin, INPUT);     // predispone switch come input, gli altri pin in uso come output.
    pinMode(motor1Pin, OUTPUT);
    pinMode(motor2Pin, OUTPUT);
    pinMode(enablePin, OUTPUT);
    pinMode(ledPin, OUTPUT);
 
    digitalWrite(enablePin, HIGH);  // inizializza enablePin alto, abilita ponte H:

    // lampeggia LED 3 volte. Questo succede una sola volta.
    // Se vedi lampeggiare il LED 3 volte, il modulo si è resettato,
    // probabilmente perché il motore ha causato un brown-out o un cortocircuito.

    blink(ledPin, 3, 100);
  }
       
  void loop()
  {
    boolean x = digitalRead(switchPin); 
    switch (x)                         
    {
      case 1: avanti();   break;       //  se lo switch è "alto" il motore girerà in una direzione,
      case 0: indietro(); break;      // se lo switch è "basso" il motore girerà in direzione opposta.
    }
  }
// ------------- Fine programma ---------------------------------------------------------------------------



Simulazione: Pilotaggio Motore in DC

Argomenti correlati: 

martedì 8 ottobre 2019

Multivibratore astabile con NE555 e driver a BJT

prof. De Santis

Multivibratore astabile con integrato NE555. Generatore di impulsi rettangolari.
Utile come temporizzatore  o come circuito di clock.

Simulazione

Dopo aver aperto il collegamento, avviare la simulazione.

Argomenti correlati: Multivibratore Monostabile

mercoledì 2 ottobre 2019

Arduino N° 17 - Sirena bitonale

Arduino N° 16

 Achille De Santis

Arduino N° 18









Sirena "Bitonale" tipo francese.
Collegare in uscita un piccolo altoparlante attraverso un condensatore di accoppiamento.

Nota:
Arduino non può fornire eccessiva potenza in uscita. Nel caso fosse necessario, bisogna prevedere un piccolo amplificatore di B.F. da collegare sull'uscita. Un altoparlante a "tromba" può sostituire efficacemente il piccolo altoparlante di prova.





/* --------------- Inizio Programma ------------------
  Achille De Santis  2014/2015 "Sirena bitonale"
  Versione 1.1.1 in data 30/01/15.
*/

// ----------- I/O ----------
#define Led_Red     11
#define Led_Green 10
#define out              13
// --------------------------
const int f1 = 660;
const int f2 = 392;
// --------------------------
  // non è richiesta la dichiarazione di variabili int o long per la funzione "tone"

void setup()
{
  pinMode(Led_Red, OUTPUT);
  pinMode(Led_Green, OUTPUT);
  // non richiede setup la funzione "tone"
}

void tono(int F, int LED)  // generazione tono e lampeggio LED
{
  tone(out, F); digitalWrite(LED, HIGH);  delay(500);
  noTone(out); digitalWrite(LED, LOW);
}

void loop()
{
  tono(f1, Led_Red);         // Primo tono a 660 Hz
  tono(f2, Led_Green);     // Secondo tono a 392 Hz
}
// ---------------------- Fine programma -----------------------------------


Simulazione: Sirena Bitonale

Argomenti correlati: Sirena Italiana

Arduino N° 18