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.

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.

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

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.

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

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.

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

Pin |
Numero del Segmento |
Posizione |
---|---|---|
1 |
a |
Il segmento superiore |
2 |
||
3 |
||
4 |
||
5 |
||
6 |
||
7 |
||
8 |
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é?

Costruzione del Circuito
Componenti Necessari
1 * Arduino Uno R3 |
1 * Display a 7 segmenti |
1 * Resistenza da 220Ω |
1 * Resistenza da 10KΩ |
1 * Pulsante |
1 * Breadboard |
Fili di collegamento |
1 * Cavo USB |
1 * Multimetro |
|||
Passaggi per la Costruzione
Segui il diagramma di collegamento o i passaggi seguenti per costruire il tuo circuito.

Inserisci il display a 7 segmenti nella breadboard con il punto decimale nell’angolo in basso a destra.

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.

Collega i pin che controllano i segmenti a, b, c del LED ai pin 2, 3 e 4 dell’Arduino Uno R3.

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

Ora inserisci un pulsante nella breadboard.

Collega il pin in basso a destra del pulsante al pin 9 di R3 con un filo.

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.

Collega il pin in basso a sinistra del pulsante al pin 5V sull’Arduino Uno R3.

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
Apri l’IDE di Arduino e avvia un nuovo progetto selezionando “New Sketch” dal menu “File”.
Salva il tuo sketch con il nome
Lesson23_Show_Number
utilizzandoCtrl + S
o cliccando su “Save”.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);
}
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);
}
Ora puoi caricare il codice sull’Arduino Uno R3 e vedrai il numero 2 visualizzato sul display a 7 segmenti.
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.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);
}
Successivamente, controlla i vari segmenti LED per visualizzare i numeri. Qui potremmo usare istruzioni
if-else
, ma ciò potrebbe risultare ingombrante. Pertanto, una dichiarazioneswitch
fornisce un modo più chiaro e organizzato per scegliere tra più comportamenti diversi rispetto a molteplici istruzioniif-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 qualecase
eseguire.case
: Ogni parola chiavecase
è 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’istruzionebreak
.break
: L’istruzionebreak
viene utilizzata per uscire dal bloccoswitch
. Senzabreak
, il programma continuerebbe a eseguire il codice del case successivo, indipendentemente dalla corrispondenza, questo è noto come «fall-through».default
: La partedefault
è opzionale e viene eseguita se nessun case corrisponde, simile aelse
in una strutturaif-else
.

Usa lo
switch-case
nella funzionedisplayDigit()
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;
}
}
Ora puoi chiamare
displayDigit()
all’interno divoid 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);
}
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.
Apri lo sketch salvato in precedenza,
Lesson23_Show_Number
.Clicca su “Salva come…” dal menu “File” e rinominalo in
Lesson23_Cyber_Dice
. Clicca su «Salva».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);
}
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 bloccoif
viene saltato.
void loop() {
// Verifica se il pulsante è premuto
if (digitalRead(buttonPin) == HIGH) {
}
}
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.

void loop() {
// Verifica se il pulsante è premuto
if (digitalRead(buttonPin) == HIGH) {
// Attendi che il pulsante venga rilasciato prima di continuare
while (digitalRead(buttonPin) == HIGH) {
}
}
}
Ora, usa la funzione
random()
per generare un numero casuale tra 1 e 6, e usadisplayDigit()
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);
}
}
}
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);
}
}
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;
}
}
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.