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