Arduino N° 47 - Estrazione numeri al Lotto

 

< Segue da Arduino N°  46

Achille De Santis

> Arduino N° 48

Programma di esempio di estrazione numeri su una base di 90.

Nell'esempio, non viene esclusa la possibilità di estrazione dello stesso numero, in sequenza, come invece avviene nei giochi della "Tombola" o del "Lotto". In queste ultime tipologie di gioco, infatti, non è possibile estrarre lo stesso numero durante una stessa sessione; una volta estratto, infatti, il numero (o la tessera) viene tolto dalla popolazione di numeri estraibili.

Il numero estratto sarà visualizzato su schermo LCD, da collegare opportunamente.



prof. De Santis


/* ----------------------------- Inizio Programma ---------------------------------------
 * Estrazione numeri.
 * Utilizzare un pulsante N.A. sul piedino D7 verso massa.
 * Achille De Santis - V2.0
 */

#include <LiquidCrystal.h>    // LIBRERIA LCD
// ----------- I/O -------------
#define pinLed    13
#define bottone   7
// -----------------------------
int statoBottone;
int numero_estrazione;

// COLLEGAMENTO DELLO SCHERMO LCD
const int rs=12, en=11, d4=5, d5=4, d6=3, d7=2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void intestazione()
  { Serial.begin(9600);        // velocità seriale di comunicazione
    Serial.println(" _________ Tecnatron Creation ___________");
    Serial.println(" Titolo: Estrazione numeri  _______________");
    Serial.println(" prof. Achille De Santis - 14-03-2020  V2.0 .--");
  }
void stampaintestazione() { Serial.print("\nTutorial Arduino:\tUtilizzo di LCD"); } // a monitor
void stampaEstrazione()   { Serial.print("\n NUM. VINCENTE: \t"); Serial.print(numero_estrazione); }

void setup()
{
  pinMode(bottone, INPUT_PULLUP);                 // evita incertezze
  pinMode(pinLed, OUTPUT);
  lcd.begin(16, 2);               // Indica che lo schermo è formato da 2 righe da 16 caratteri
  Serial.begin(9600);
  stampaintestazione();
}
void loop()
  {
    numero_estrazione = random(1,90);
    statoBottone=digitalRead(bottone);
   
    if (statoBottone == 1)              // Se il pulsante NON è premuto
      {
        lcd.setCursor(0, 0);            // posiziona a colonna zero, riga zero
        lcd.print("Tutorial Arduino");
        lcd.setCursor(0, 1);            // posiziona a colonna zero, riga uno
        lcd.print("Utilizzo di LCD");
      }
    else if (statoBottone == 0)         // Se il pulsante è premuto
      {
        lcd.setCursor(0, 0);
        lcd.print(" NUM. VINCENTE: ");
        lcd.setCursor(0,1);
        lcd.print(" ");
        lcd.println(numero_estrazione); // stampa numero estratto
        stampaEstrazione();                    // visualizza a monitor
        delay(4000);
      }
}
// ----------------------------- Fine Programma ---------------------------------------


Simulazione:

Argomenti correlati:
Dado Elettronico
Dado Elettronico V2


> Arduino N° 48

Arduino N° 46 - Control box per Rotore Azimutale Economico

< Segue da Arduino N° 45

Achille De Santis

> Arduino N° 47

Parte seconda

La versione V.9.2 del Firmware prevede l'inserimento di un semplice sensore a contatto reed sulla campana del rotore. In questo modo è possibile calibrare il rotore sempre nella posizione di riferimento, operando come segue.

Manuale d’uso

            Questo control-box è adatto a realizzare un piccolo rotore per antenne o a sostituire la parte di pilotaggio di alcuni rotori economici che, pur funzionando, non hanno quelle caratteristiche di stabilità e di precisione che si richiede ad un rotore di antenna, seppure piccolo e per antenne leggere.

Procedura di calibrazione

All’occorrenza, la calibrazione è molto semplice:

·         Si azzera il rotore sulla posizione di riferimento (nord);

·         Si controlla lo zero con l’accensione della spia;

·         La posizione del potenziometro ci suggerisce, nel caso, il disallineamento;

·        Si posiziona sullo zero il potenziometro di set-point (senza start!) e si resetta il control-box, in modo da far riconoscere al sistema la posizione di riferimento.

·         Fatto! Il rotore è allineato e calibrato.

            Ricordate! Una volta spento, il control box perde la memoria della posizione iniziale ma la riconosce all’accensione successiva quindi, assicuratevi che il potenziometro resti nella stessa posizione. Per sicurezza, spegnete sempre con il potenziometro nella posizione di zero centrale (riferimento sicuro); in questo modo avrete sempre un riferimento preciso per l’accensione e non vi saranno problemi di allineamento. Nel caso di piccoli ‘trimming’ che si dovessero rendere necessari dopo brevi movimentazioni ripetute, riferitevi alla procedura di calibrazione.

La stessa cosa potrebbe essere fatta nel caso aveste un segnale radio di riferimento, con azimuth noto.

Simulazione:


Argomenti correlati:

Control box per rotore azimutale economico.

Arduino N° 14 - Control Box per Rotore azimutale

> Arduino N° 47

Arduino N° 45 - Luci psichedeliche a LED V2.0

< Segue da Arduino N°  44

Achille De Santis

> Arduino N° 46

            






Con questo sketch è possibile pilotare una striscia LED RGB alimentata a 12 volt.
Potete provare il funzionamento del programma predisponendo un solo LED RGB a catodo comune, opportunamente polarizzato, su una piccola breadboard. Un potenziometro in ingresso al segnale di bassa frequenza serve a regolare la sensibilità del dispositivo e ad adattarlo al livello audio.

Poiché molte strisce LED operano a logica negata, serve uno stadio separatore a transistori in configurazione invertente, a tre canali. Il positivo di alimentazione a 12 volt sarà collegato alla linea di ingresso, mentre le tre linee RGB andranno collegate alle uscite (open collector) del driver a BJT.




/* ----------------------------- Inizio Programma ---------------------------------------
 * prof. Achille De Santis  19-01-2020
 * Variazione continua del colore di un LED RGB a catodo comune
 * o di una striscia LED ad anodo comune con driver a BJT
 * Luci psichedeliche a LED V2.0
 * le uscite utilizzate DEVONO essere PWM.
 * -------------------------------------------------------------------------------------------
*/

// ------------ Ingresso analogico ---------------
#define BF   A2
// -----------------------------------------------
// -------- uscite PWM per il LED RGB -----------------
#define ROSSO   10
#define VERDE   11
#define BLU     9
// --------------------------------------------------------------

const int T1=200;                       // tempo di transizione colore
int segnale=0,     segnale2=0;          // inizializza le variabili
int soglia1=20,    soglia2=30;          // ------ valori di soglia per i colori ---------
// -------------------------------------------------------------------------------------------

void coefficienti(int a,int b,int c)  { analogWrite(ROSSO,a); analogWrite(VERDE,b); analogWrite(BLU,c); }

void test()             // routine di prova dei colori.
  {
    coefficienti(255,0,0); delay(500);   coefficienti(0,255,0); delay(500);
    coefficienti(0,0,255); delay(500);   coefficienti(0,0,0); delay(1000);
  }

void intestazione()
  { Serial.println(" ----------------------------------------------\n - Autore: Tecnatron - ing. Achille De Santis -");
    Serial.println(" - Variazione continua della luminosità       -\n - per LED RGB a catodo comune CK             -");
    Serial.println(" - ingresso analogico: A2                     -\n - uscite PWM usate:  D11, D10, D9   V2.0     -");
    Serial.println(" ----------------------------------------------");
  }

void setup()
  {
    Serial.begin(9600);                                         // velocità seriale di comunicazione
    pinMode(BF, INPUT),                                   // imposta il pin come input per il segnale audio
    pinMode(VERDE, OUTPUT), (BLU, OUTPUT), (ROSSO, OUTPUT);   // imposta i pin di uscita
    digitalWrite (VERDE, LOW), (BLU, LOW), (ROSSO, LOW);      // inizialmente, led RGB spento;
    intestazione();    test();
  }

void loop()
  {
    segnale=analogRead(A2);
    segnale2=map(segnale,0,1023,0,255); //
    if (segnale2<soglia1)                      { analogWrite(ROSSO, segnale2); }
    if (segnale2>=soglia1 & segnale2<soglia2)  { analogWrite(VERDE, segnale2); }
    if  (segnale2>=soglia2)                    { analogWrite(BLU, segnale2); }
    // delay(100);
    coefficienti(0,0,0);
 }
// ----------------------------- Fine Programma ---------------------------------------



Simulazione:


Argomenti correlati:

• 
  
  Polarizzazione del BJT nelle tre zone di lavoro: interdizione, attiva, saturazione
• Dimensionamento Transistore BJT in commutazione
• Arduino N° 43 - VU Meter 8 canali

> Arduino N° 46

Arduino N° 44 - Sensore digitale di livello

< Segue da Arduino N°  43

Achille De Santis

> Arduino N° 45

Un misuratore analogico di livello si può implementare con il vecchio sensore 4-20 mA, che ha le sue peculiarità.

In alternativa, si può realizzare un misuratore di livello con tecnica digitale; quello qui presentato rileva 4 livelli ed indica anche una "riserva", quando il livello è al di sotto di un quarto di serbatoio.

/* ----------------------------- Inizio Programma ---------------------------------------
  Sensore digitale di livello, a cinque stati: 0%, 25%, 50%, 75%, 100%
  I pulsanti vanno sostituiti con 4 interruttori di livello, a galleggiante.
  by prof. Achille De Santis V4 del 12-02-2020.
*/

// ------------------ I/O --------------------------
#define U0  7  // livello inferiore al 25%
#define U1  6  // livello 25%
#define U2  5  // livello 50%
#define U3  4  // livello 75%
#define U4  3  // livello 100%
// ------------------ Sensori -------------------
#define P1  13  // livello 25%
#define P2  12  // livello 50%
#define P3  11  // livello 75%
#define P4  10  // livello 100%
// -------------------------------------------------

int L;

void intestazione()
  { // Serial.begin(9600);        // velocità seriale
    Serial.println(" ________ Tecnatron Creation ___________");
    Serial.println(" Sensore digitale di livello                           --");
    Serial.println(" prof. Achille De Santis - 27-10-2019 --------");
  }

void livello(int u)  {Serial.print("Serbatoio: "); digitalWrite(u, HIGH);}   // indicatore di livello


void setup()
{
  pinMode(P1, INPUT);  // interruttori di livello, a galleggiante.
  pinMode(P2, INPUT);
  pinMode(P3, INPUT);
  pinMode(P4, INPUT);

  pinMode(U0, OUTPUT);  // uscite per i led di livello o per attuatori
  pinMode(U1, OUTPUT);
  pinMode(U2, OUTPUT);
  pinMode(U3, OUTPUT);
  pinMode(U4, OUTPUT);
  Serial.begin(9600);
  intestazione();
}

// ------------------------------------------------------------------------------------------------------

void loop()
{
  digitalWrite(U0, LOW);               L=digitalRead(P4); 
  if (L==HIGH)           {Serial.println("100%"); livello(U4); }   
    else
    {digitalWrite(U4, LOW);            L=digitalRead(P3);
      if(L==HIGH)        {Serial.println("75%"); livello(U3); }   
       else
       { digitalWrite(U3, LOW);         L=digitalRead(P2);
        if(L==HIGH)      {Serial.println("50%"); livello(U2); }   
         else
          { digitalWrite(U2, LOW);      L=digitalRead(P1);
           if(L==HIGH)  {Serial.println("25%"); livello(U1); }   
              else     
              {
                digitalWrite(U1, LOW);
                Serial.println("quasi vuoto"); livello(U0);     
              }                     
          }
       }
    }
delay(500);
}

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

Simulazione:

Sensore digitale di livello
Sensore digitale di livello, V4

Argomenti correlati:

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

> Arduino N° 45

Arduino N° 43 - VU Meter 8 canali

< Segue da Arduino N°  42

Achille De Santis

> Arduino N° 44

Il seguente programma, ridotto all'essenziale, può essere utilizzato come "VU meter" o come comando per "Luci psichedeliche" ad 8 canali.

Da schema, eliminare il filo blu dopo il collaudo e collegare l'ingresso marrone alla BF con una capacità di accoppiamento (v. simulazione) o con un piccolo trasformatore di accoppiamento, del tipo dei trasformatori di ingresso o di uscita per stadi a transistori, magari recuperati da una radiolina a transistori o da un vecchio modem.

/* -------------------------------- Inizio Programma -------------------------------------------------
  VU-meter con Barra LED. V4.0 del 12-01-2020
  prof. Achille De Santis.
  Collegare 8 led dal pin 2 al 9 con resistenza da 220 Ω, catodo comune.
  Inserire un potenziometro da 10 KΩ sull'ingresso segnale A0.
*/

// ----------------------------------------------------
#define BF  A0    // ingresso analogico di BF
// ----------------------------------------------------

const int tempo=50;
const int soglia=30;
int valore=0;

// int led[]= {2,3,4,5,6,7,8,9};  // sequenza diretta
int led[]= {9,8,7,6,5,4,3,2};     // sequenza invertita

void setup()
{
  Serial.begin(9600);
  intestazione();
  pinMode (BF, INPUT);
  for (int i=0; i<=7; i++)  { pinMode (led[i], OUTPUT); }
  provaLed(); // si può escludere
}

void intestazione()
{ Serial.println(" -------------------------------------------------------- ");
  Serial.println(" - Autore: Tecnatron - ing. Achille De Santis    - ");
  Serial.println(" - Sketch: VU meter - 8 canali                           - ");
  Serial.println(" - Versione: V4.1  12-01-2020                           - ");
  Serial.println(" - Comandi: Ingresso analogico su canale A0   - ");
  Serial.println(" -                                                                        - ");
  Serial.println(" -------------------------------------------------------- ");
}
void provaLed()     { for (int i=0; i<=7; i++) { digitalWrite(led[i],1); delay(tempo); digitalWrite(led[i],0);}; }
void spegni()       { for (int i=0; i<=7; i++)  digitalWrite(led[i],0); }
void accendi(int p) { digitalWrite(led[p], 1); }

void loop()
{
  spegni();
  valore = analogRead(BF);
  for(int i=1; i<=8; i++)  {     if (valore>soglia*i)  accendi(i-1);  } 
}

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

Simulazione:

VU meter V4.0 
VU meter V4.1

Argomenti correlati:

VU-meter con Arduino

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

> Arduino N° 44