Nota

Ciao, benvenuto nella community SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasts su Facebook! Approfondisci le tue conoscenze su Raspberry Pi, Arduino ed ESP32 insieme ad altri appassionati.

Perché unirsi?

  • Supporto Esperti: Risolvi problemi post-vendita e sfide tecniche con l’aiuto della nostra community e del nostro team.

  • Impara & Condividi: Scambia suggerimenti e tutorial per migliorare le tue competenze.

  • Anteprime Esclusive: Ottieni accesso anticipato a nuovi annunci di prodotti e anteprime esclusive.

  • Sconti Speciali: Approfitta di sconti esclusivi sui nostri nuovi prodotti.

  • Promozioni e Giveaway Festivi: Partecipa a promozioni festive e giveaway.

👉 Sei pronto a esplorare e creare con noi? Clicca [Qui] e unisciti subito!

23. Dado Cibernetico

In questa lezione, intraprenderemo un entusiasmante viaggio attraverso due progetti che coinvolgono l’elettronica digitale e la programmazione.

_images/23_dice.jpg

Inizialmente, esploreremo il funzionamento di un display a 7 segmenti, imparando a controllarlo per mostrare i numeri passo dopo passo. Successivamente, creeremo un dado elettronico! Premendo semplicemente un pulsante, apparirà un numero casuale compreso tra 1 e 6 sul display a 7 segmenti, offrendo una svolta digitale ai dadi tradizionali.

Durante questa lezione imparerai:

  • I principi del funzionamento di un display a 7 segmenti e come farlo funzionare.

  • L’uso delle istruzioni switch-case per semplificare la logica del codice.

  • Come utilizzare un ciclo while per mantenere lo stato corrente fino a quando non è necessario un cambiamento.

  • Come costruire il progetto Dado Cibernetico, integrando elettronica semplice con programmazione interattiva per un’applicazione pratica.

L’origine dei Dadi

I dadi sono tra gli strumenti di gioco d’azzardo più antichi al mondo, con una storia che risale a migliaia di anni prima dell’era comune. Sono stati originati intorno al 3000 a.C. nell’antico Egitto, tipicamente realizzati con ossa, avorio o altri materiali naturali. Questi primi dadi erano spesso irregolari nella forma e talvolta non del tutto simmetrici.

_images/23_dice.png

I dadi sono stati trovati anche nell’antica Mesopotamia (l’attuale Iraq) all’incirca nello stesso periodo. Gli antichi indovini e leader religiosi usavano i dadi per prendere decisioni o prevedere il futuro, sottolineando la loro importanza nei riti religiosi e mistici.

Col tempo, la forma e le tecniche di produzione dei dadi si sono standardizzate. Entro il I secolo a.C., i dadi erano ampiamente utilizzati nell’Impero Romano, non solo per il gioco d’azzardo, ma anche per scopi sociali e di intrattenimento.

In Asia, in particolare in India, l’uso dei dadi è documentato nell’antico poema epico, il Mahabharata, in cui una partita di dadi gioca un ruolo cruciale nella trama.

Durante il Rinascimento, la produzione di dadi divenne più raffinata e i materiali si diversificarono includendo legno, osso, avorio e persino metallo. Oggi, i dadi non sono solo strumenti per l’intrattenimento e il gioco d’azzardo, ma vengono utilizzati anche nell’educazione, nel supporto alle decisioni e in vari giochi da tavolo. La loro storia e diversità riflettono l’evoluzione della cultura e della tecnologia umana, offrendo una finestra affascinante sull’esplorazione del caso e della fortuna.

Comprensione del Display a 7 Segmenti

  1. Trova un display a 7 segmenti.

Un display a 7 segmenti è un componente a forma di 8 che racchiude 7 LED. Ognuno dei LED nel display è collegato a un segmento posizionale con uno dei suoi pin di connessione che esce dal pacchetto di plastica rettangolare. Questi pin LED sono etichettati da «a» a «g», rappresentando ogni singolo LED. Un ulteriore ottavo LED è utilizzato all’interno dello stesso pacchetto, consentendo così l’indicazione di un punto decimale (DP) quando due o più display a 7 segmenti sono collegati insieme per mostrare numeri maggiori di dieci.

_images/23_7_segment.png

Il pin comune del display solitamente ne indica il tipo. Esistono due tipi di connessioni: una con i catodi collegati e un’altra con gli anodi collegati, indicando Catodo Comune (CC) e Anodo Comune (CA). Come suggerisce il nome, un display CC ha tutti i catodi dei 7 LED collegati, mentre un display CA ha tutti gli anodi dei 7 segmenti collegati.

Nota

Solitamente, c’è un’etichetta sul lato del display a 7 segmenti, xxxAx o xxxBx. In generale, xxxAx sta per catodo comune e xxxBx per anodo comune. I display nel nostro kit sono a catodo comune.

_images/23_segment_cathode_1.png

Per determinare se un display a 7 segmenti è a catodo comune o anodo comune, puoi utilizzare un multimetro. Puoi anche utilizzare un multimetro per testare se ogni segmento del display funziona correttamente, come segue:

  1. Imposta il multimetro in modalità test diodi. Il test diodi è una funzione del multimetro utilizzata per controllare la conduzione diretta dei diodi o di dispositivi semiconduttori simili (come i LED). Il multimetro fa passare una piccola corrente attraverso il diodo. Se il diodo è intatto, permetterà il passaggio della corrente.

_images/multimeter_diode.png
  1. Inserisci il display a 7 segmenti in una breadboard, notando che il punto decimale è in basso a destra e assicurati che attraversi la fessura centrale. Inserisci un filo nella stessa fila del pin 1 del display e toccalo con il cavo rosso del multimetro. Inserisci un altro filo nella stessa fila di qualsiasi pin «-» del display e toccalo con il cavo nero.

_images/23_7_segment_test.png
  1. Osserva se si accende un segmento LED. In tal caso, indica che il display è a catodo comune. In caso contrario, scambia i cavi rosso e nero; se un segmento si accende dopo lo scambio, significa che il display è ad anodo comune.

  2. Se un segmento si accende, fai riferimento a questo diagramma per annotare il numero del pin del segmento e la posizione approssimativa nella tabella del Manuale.

_images/23_segment_2.png

Pin

Numero del Segmento

Posizione

1

a

Il segmento superiore

2

3

4

5

6

7

8

  1. Ripeti i passaggi precedenti, mantenendo il cavo nero sul pin «-», e collega il cavo rosso agli altri pin per scoprire i pin di controllo corrispondenti ai segmenti LED del display.

Domanda

Dai test precedenti, si sa che il display nel kit è a catodo comune, il che significa che è sufficiente collegare il pin comune a GND e fornire una tensione alta agli altri pin per accendere i segmenti corrispondenti. Se vuoi che il display mostri il numero 2, quali pin dovrebbero ricevere una tensione alta? Perché?

_images/23_segment_2.png

Costruzione del Circuito

Componenti Necessari

1 * Arduino Uno R3

1 * Display a 7 segmenti

1 * Resistenza da 220Ω

1 * Resistenza da 10KΩ

list_uno_r3

list_7segment

list_220ohm

list_10kohm

1 * Pulsante

1 * Breadboard

Fili di collegamento

1 * Cavo USB

list_button

list_breadboard

list_wire

list_usb_cable

1 * Multimetro

list_meter

Passaggi per la Costruzione

Segui il diagramma di collegamento o i passaggi seguenti per costruire il tuo circuito.

_images/23_segment_5v.png
  1. Inserisci il display a 7 segmenti nella breadboard con il punto decimale nell’angolo in basso a destra.

_images/23_segment_segment.png
  1. Inserisci un’estremità di una resistenza da 220Ω nel terminale negativo (“-”) del display a 7 segmenti, e l’altra estremità nel binario negativo della breadboard. Quindi collega il binario negativo della breadboard al pin GND dell’Arduino Uno R3 con un filo di collegamento.

_images/23_segment_resistor_gnd.png
  1. Collega i pin che controllano i segmenti a, b, c del LED ai pin 2, 3 e 4 dell’Arduino Uno R3.

_images/23_segment_abc.png
  1. Collega i pin che controllano i segmenti d, e, f, g del LED ai pin 5, 6, 7 e 8 dell’Arduino Uno R3.

_images/23_segment_defg.png
  1. Ora inserisci un pulsante nella breadboard.

_images/23_segment_button.png
  1. Collega il pin in basso a destra del pulsante al pin 9 di R3 con un filo.

_images/23_segment_pin9.png
  1. Collega una resistenza pull-down da 10K al pulsante in modo che quando il pulsante non viene premuto, il pin 9 rimanga a un livello basso e non vi sia rimbalzo.

_images/23_segment_10k_resistor.png
  1. Collega il pin in basso a sinistra del pulsante al pin 5V sull’Arduino Uno R3.

_images/23_segment_5v.png

7-segment Display

Arduino UNO R3

a

2

b

3

c

4

d

5

e

6

f

7

g

8

Creazione del Codice - Visualizzazione dei Numeri

  1. Apri l’IDE di Arduino e avvia un nuovo progetto selezionando “New Sketch” dal menu “File”.

  2. Salva il tuo sketch con il nome Lesson23_Show_Number utilizzando Ctrl + S o cliccando su “Save”.

  3. Definisci i pin collegati al display a 7 segmenti e imposta tutti i pin come output.

// Definizione dei pin collegati al display a 7 segmenti
int pinA = 2;
int pinB = 3;
int pinC = 4;
int pinD = 5;
int pinE = 6;
int pinF = 7;
int pinG = 8;

void setup() {
    // Imposta tutti i pin come output
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
    pinMode(pinC, OUTPUT);
    pinMode(pinD, OUTPUT);
    pinMode(pinE, OUTPUT);
    pinMode(pinF, OUTPUT);
    pinMode(pinG, OUTPUT);
}
  1. Ora scrivi il codice per far visualizzare al display a 7 segmenti un numero, come il numero 2. Per visualizzare il numero 2, imposta i segmenti F e C su LOW (spenti), mentre gli altri segmenti su HIGH (accesi).

  // Definizione dei pin collegati al display a 7 segmenti
  int pinA = 2;
  int pinB = 3;
  int pinC = 4;
  int pinD = 5;
  int pinE = 6;
  int pinF = 7;
  int pinG = 8;

  void setup() {
      // Imposta tutti i pin come output
      pinMode(pinA, OUTPUT);
      pinMode(pinB, OUTPUT);
      pinMode(pinC, OUTPUT);
      pinMode(pinD, OUTPUT);
      pinMode(pinE, OUTPUT);
      pinMode(pinF, OUTPUT);
      pinMode(pinG, OUTPUT);
  }

  void loop() {
      // Imposta i segmenti F e C su LOW (spenti), gli altri su HIGH (accesi)
      digitalWrite(pinA, HIGH);
      digitalWrite(pinB, HIGH);
      digitalWrite(pinC, LOW);
      digitalWrite(pinD, HIGH);
      digitalWrite(pinE, HIGH);
      digitalWrite(pinF, LOW);
      digitalWrite(pinG, HIGH);
  }
  1. Ora puoi caricare il codice sull’Arduino Uno R3 e vedrai il numero 2 visualizzato sul display a 7 segmenti.

  2. Se hai bisogno di visualizzare altri numeri, ad esempio scorrendo da 1 a 6, utilizzare digitalWrite() per impostare ogni segmento renderebbe il codice molto lungo e la logica meno chiara. Qui utilizziamo invece un metodo di creazione di funzione.

  3. Crea una funzione con un parametro - displayDigit(), che prima spegne tutti i segmenti LED del display a 7 segmenti.

void displayDigit(int digit) {
    // Spegne tutti i segmenti
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, LOW);
    digitalWrite(pinC, LOW);
    digitalWrite(pinD, LOW);
    digitalWrite(pinE, LOW);
    digitalWrite(pinF, LOW);
    digitalWrite(pinG, LOW);
}
  1. Successivamente, controlla i vari segmenti LED per visualizzare i numeri. Qui potremmo usare istruzioni if-else, ma ciò potrebbe risultare ingombrante. Pertanto, una dichiarazione switch fornisce un modo più chiaro e organizzato per scegliere tra più comportamenti diversi rispetto a molteplici istruzioni if-else.

Nel linguaggio di programmazione, un’istruzione switch è una struttura di controllo utilizzata per eseguire diversi blocchi di codice in base al valore di una variabile.

La sintassi di base di una dichiarazione switch è la seguente:

switch (espressione) {
    case valore1:
        // codice
        break;
    case valore2:
        // codice
        break;
    default:
        // codice
}
  • espressione: Questa è un’espressione che in genere restituisce un intero o un carattere, in base al quale l’istruzione switch decide quale case eseguire.

  • case: Ogni parola chiave case è seguita da un valore che può corrispondere al risultato dell’espressione. Se la corrispondenza è corretta, il codice viene eseguito da questo punto fino al raggiungimento di un’istruzione break.

  • break: L’istruzione break viene utilizzata per uscire dal blocco switch. Senza break, il programma continuerebbe a eseguire il codice del case successivo, indipendentemente dalla corrispondenza, questo è noto come «fall-through».

  • default: La parte default è opzionale e viene eseguita se nessun case corrisponde, simile a else in una struttura if-else.

_images/23_flow_swtich.png
  1. Usa lo switch-case nella funzione displayDigit() per completare la visualizzazione dei numeri sul display a 7 segmenti. Ad esempio, per visualizzare 1, solo i segmenti B e C devono essere impostati su HIGH; per visualizzare 2, i segmenti F e C devono essere impostati su LOW, mentre gli altri su HIGH.

void displayDigit(int digit) {
    // Spegne tutti i segmenti
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, LOW);
    digitalWrite(pinC, LOW);
    digitalWrite(pinD, LOW);
    digitalWrite(pinE, LOW);
    digitalWrite(pinF, LOW);
    digitalWrite(pinG, LOW);

    // Imposta su HIGH i segmenti necessari per visualizzare il numero desiderato
    switch (digit) {
        case 1:
            digitalWrite(pinB, HIGH);
            digitalWrite(pinC, HIGH);
            break;
        case 2:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinE, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 3:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 4:
            digitalWrite(pinB, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinF, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 5:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinF, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 6:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinE, HIGH);
            digitalWrite(pinF, HIGH);
            digitalWrite(pinG, HIGH);
            break;
    }
}
  1. Ora puoi chiamare displayDigit() all’interno di void loop() per visualizzare numeri specifici, come alternare tra il 3 e il 6 con un intervallo di un secondo.

void loop() {

    displayDigit(3);  // Visualizza il numero 3 sul display a 7 segmenti
    delay(1000);
    displayDigit(6);  // Visualizza il numero 6 sul display a 7 segmenti
    delay(1000);
}
  1. Di seguito è riportato il tuo codice completo. Ora puoi caricare il codice sull’Arduino Uno R3 e vedrai il display a 7 segmenti alternare la visualizzazione tra il numero 3 e il numero 6.

// Definizione dei pin collegati al display a 7 segmenti
int pinA = 2;
int pinB = 3;
int pinC = 4;
int pinD = 5;
int pinE = 6;
int pinF = 7;
int pinG = 8;

void setup() {
    // Imposta tutti i pin come output
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
    pinMode(pinC, OUTPUT);
    pinMode(pinD, OUTPUT);
    pinMode(pinE, OUTPUT);
    pinMode(pinF, OUTPUT);
    pinMode(pinG, OUTPUT);
}

void loop() {

    displayDigit(3);  // Visualizza il numero 3 sul display a 7 segmenti
    delay(1000);
    displayDigit(6);  // Visualizza il numero 6 sul display a 7 segmenti
    delay(1000);
}

void displayDigit(int digit) {
    // Spegne tutti i segmenti
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, LOW);
    digitalWrite(pinC, LOW);
    digitalWrite(pinD, LOW);
    digitalWrite(pinE, LOW);
    digitalWrite(pinF, LOW);
    digitalWrite(pinG, LOW);

    // Accende i segmenti necessari per visualizzare il numero desiderato (HIGH accende i segmenti per catodo comune)
    switch (digit) {
        case 1:
            digitalWrite(pinB, HIGH);
            digitalWrite(pinC, HIGH);
            break;
        case 2:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinE, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 3:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinB, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 4:
            digitalWrite(pinB, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinF, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 5:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinF, HIGH);
            digitalWrite(pinG, HIGH);
            break;
        case 6:
            digitalWrite(pinA, HIGH);
            digitalWrite(pinC, HIGH);
            digitalWrite(pinD, HIGH);
            digitalWrite(pinE, HIGH);
            digitalWrite(pinF, HIGH);
            digitalWrite(pinG, HIGH);
            break;
    }
}

Creazione del Codice - Cyber Dice

Ora che sappiamo come visualizzare i numeri da 1 a 6 sul display a 7 segmenti, come possiamo ottenere l’effetto di un Cyber Dice?

Questo coinvolge la pressione di un pulsante per far ciclicare il display attraverso i numeri da 1 a 6 e il rilascio del pulsante per mostrare un numero stabile. Vediamo come possiamo ottenere questo effetto con il codice.

  1. Apri lo sketch salvato in precedenza, Lesson23_Show_Number.

  2. Clicca su “Salva come…” dal menu “File” e rinominalo in Lesson23_Cyber_Dice. Clicca su «Salva».

  3. Definisci il pin del pulsante e impostalo come input.

// Definisci i pin collegati ai segmenti del display a 7 segmenti
int pinA = 2;
int pinB = 3;
int pinC = 4;
int pinD = 5;
int pinE = 6;
int pinF = 7;
int pinG = 8;

// Definisci il pin collegato al pulsante
int buttonPin = 9;

void setup() {
    // Imposta tutti i pin come output
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
    pinMode(pinC, OUTPUT);
    pinMode(pinD, OUTPUT);
    pinMode(pinE, OUTPUT);
    pinMode(pinF, OUTPUT);
    pinMode(pinG, OUTPUT);

    // Imposta il pin del pulsante come input
    pinMode(buttonPin, INPUT);
}
  1. Verifica se il pulsante è premuto nel momento in cui viene eseguita la funzione void loop(). Se il pulsante non è premuto, il codice all’interno del blocco if viene saltato.

void loop() {
    // Verifica se il pulsante è premuto
    if (digitalRead(buttonPin) == HIGH) {
    }
}
  1. In Arduino o in programmazione su microcontrollori simili, un problema comune quando si lavora con input da pulsante è assicurarsi che ogni pressione generi una sola azione, soprattutto quando si generano eventi o comandi (come generare un numero casuale). Per risolvere questo, possiamo usare una tecnica chiamata «attendere il rilascio».

attendere il rilascio

L’idea principale di questo metodo è che, dopo che il pulsante è stato premuto e un’azione è stata eseguita, il programma entra in un ciclo che continua a monitorare lo stato del pulsante fino al suo rilascio. Questo serve per garantire che non vengano attivate ulteriori azioni a causa di rimbalzi del pulsante o perché l’utente lo tiene premuto.

Possiamo implementare questo comportamento con un ciclo while nel codice.

_images/while_loop.png
void loop() {
    // Verifica se il pulsante è premuto
    if (digitalRead(buttonPin) == HIGH) {
        // Attendi che il pulsante venga rilasciato prima di continuare
        while (digitalRead(buttonPin) == HIGH) {
        }
    }
}
  1. Ora, usa la funzione random() per generare un numero casuale tra 1 e 6, e usa displayDigit() per visualizzare questo numero sul display a 7 segmenti. Vedrai il display scorrere rapidamente tra numeri diversi mentre il pulsante è tenuto premuto.

void loop() {
    // Verifica se il pulsante è premuto
    if (digitalRead(buttonPin) == HIGH) {
        // Attendi che il pulsante venga rilasciato prima di continuare
        while (digitalRead(buttonPin) == HIGH) {
            // Genera un numero casuale tra 1 e 6
            int num = random(1, 7);

            // Visualizza il numero casuale sul display a 7 segmenti
            displayDigit(num);
            // Ritardo per permettere aggiornamenti visibili del display
            delay(100);
        }
    }
}
  1. Infine, aggiungi un ritardo per evitare il rimbalzo del pulsante e prevenire ingressi multipli rapidi.

void loop() {
    // Verifica se il pulsante è premuto
    if (digitalRead(buttonPin) == HIGH) {
        // Attendi che il pulsante venga rilasciato prima di continuare
        while (digitalRead(buttonPin) == HIGH) {
            // Genera un numero casuale tra 1 e 6
            int num = random(1, 7);

            // Visualizza il numero casuale sul display a 7 segmenti
            displayDigit(num);
            // Ritardo per consentire aggiornamenti visibili del display
            delay(100);
        }
        // Aggiungi un ritardo per evitare il rimbalzo del pulsante e prevenire ingressi multipli rapidi
        delay(500);
    }
}
  1. Il codice completo dovrebbe essere simile a questo, e ora puoi caricare il codice sull’Arduino Uno R3. Una volta caricato, se tieni premuto il pulsante, i numeri sul display scorreranno rapidamente, e al rilascio verrà mostrato un numero.

// Definisci i pin collegati ai segmenti del display a 7 segmenti
int pinA = 2;
int pinB = 3;
int pinC = 4;
int pinD = 5;
int pinE = 6;
int pinF = 7;
int pinG = 8;

// Definisci il pin collegato al pulsante
int buttonPin = 9;

void setup() {
    // Imposta tutti i pin come output
    pinMode(pinA, OUTPUT);
    pinMode(pinB, OUTPUT);
    pinMode(pinC, OUTPUT);
    pinMode(pinD, OUTPUT);
    pinMode(pinE, OUTPUT);
    pinMode(pinF, OUTPUT);
    pinMode(pinG, OUTPUT);

    // Imposta il pin del pulsante come input
    pinMode(buttonPin, INPUT);
}

void loop() {
    // Verifica se il pulsante è premuto
    if (digitalRead(buttonPin) == HIGH) {
        // Attendi che il pulsante venga rilasciato prima di continuare
        while (digitalRead(buttonPin) == HIGH) {
            // Genera un numero casuale tra 1 e 6
            int num = random(1, 7);

            // Visualizza il numero casuale sul display a 7 segmenti
            displayDigit(num);
            // Ritardo per consentire aggiornamenti visibili del display
            delay(100);
        }
        // Aggiungi un ritardo per evitare il rimbalzo del pulsante e prevenire ingressi multipli rapidi
        delay(500);
    }
}


void displayDigit(int digit) {
    // Spegni tutti i segmenti
    digitalWrite(pinA, LOW);
    digitalWrite(pinB, LOW);
    digitalWrite(pinC, LOW);
    digitalWrite(pinD, LOW);
    digitalWrite(pinE, LOW);
    digitalWrite(pinF, LOW);
    digitalWrite(pinG, LOW);

    // Accendi i segmenti necessari per il numero desiderato (LOW accende i segmenti per catodo comune)
    switch (digit) {
        case 1:
        digitalWrite(pinB, HIGH);
        digitalWrite(pinC, HIGH);
        break;
        case 2:
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, HIGH);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinG, HIGH);
        break;
        case 3:
        digitalWrite(pinA, HIGH);
        digitalWrite(pinB, HIGH);
        digitalWrite(pinC, HIGH);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinG, HIGH);
        break;
        case 4:
        digitalWrite(pinB, HIGH);
        digitalWrite(pinC, HIGH);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, HIGH);
        break;
        case 5:
        digitalWrite(pinA, HIGH);
        digitalWrite(pinC, HIGH);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, HIGH);
        break;
        case 6:
        digitalWrite(pinA, HIGH);
        digitalWrite(pinC, HIGH);
        digitalWrite(pinD, HIGH);
        digitalWrite(pinE, HIGH);
        digitalWrite(pinF, HIGH);
        digitalWrite(pinG, HIGH);
        break;
    }
}
  1. Infine, ricorda di salvare il codice e di riordinare la tua area di lavoro.

Riepilogo

In questa lezione, abbiamo completato con successo il progetto del Cyber Dice, permettendoti di partecipare a competizioni amichevoli con i tuoi amici per vedere chi riesce a ottenere il numero più alto. Durante questa lezione, abbiamo esplorato il funzionamento di un display a 7 segmenti, imparando a controllarlo efficacemente. Abbiamo semplificato il nostro codice utilizzando dichiarazioni switch-case, migliorando la leggibilità e l’efficienza.

Inoltre, abbiamo implementato la logica per controllare la visualizzazione di numeri casuali sul display a 7 segmenti in base allo stato di pressione di un pulsante, aggiungendo un’interazione dinamica al nostro progetto. Questa esperienza pratica non solo ti ha familiarizzato con i componenti elettronici di base e le strategie di codifica, ma ha anche illustrato le applicazioni pratiche di queste competenze nella creazione di progetti coinvolgenti e interattivi.