Michele Maffucci

ROB-O-COD un evento da replicare a scuola – lo racconterò a Fossano (Cn) il 6 giugno prossimo

Pubblicato il Aprile 25, 2019 da admin

Come ebbi modo di scrivere qualche tempo fa su Facebook, pur essendo docente di scuola superiore ho avuto la fortuna di insegnare a studenti e insegnanti di ogni ordine di scuola. Ogni nuova attività di formazione mi offre la possibilità di sperimentare tecnologie e modalità di comunicazione che poi se efficaci assemblo per costruire gli strumenti per le future lezioni.

Credo che uno dei momenti più ricchi per la mia formazione sia stata quella derivante dalle attività di laboratorio con gli studenti di scuola elementare, la loro creatività, il loro stupirsi ed il loro punto di vista richiede una progettazione completamente diversa da quella con allievi di scuola superiore.

In questi mesi sto dedicando alcune ore pomeridiane alla formazione di studenti di 4 elementare, gli obiettivi sono quelli che amo di più: Coding e Robotica.

Gli strumenti che utilizziamo sono molti: carta, matite, BBC micro:bit, Lego WeDo e anche Lego Mindstorms EV3 e proprio su quest’ultima tecnologia, anche se non ne era stato programmato l’utilizzo, ho avuto forte richiesta da parte degli studenti da quando, per aumentare il loro interesse nelle attività proposte, ho dato notizia della trasmissione ROB-O-COD:

“MICHELE anche noi vogliamo partecipare!
Costruiamo i campi, con il cartone e facciamo noi i mondi e ci insegni!”

Ora come rispondere a questa necessità?
Ai bambini bisogna rispondere! 🙂

La trasmissione ha un traget per ragazzi di scuola media con l’uso di tecnologie non proprio adatte ai più piccoli delle scuole elementari…

pensare pensare e ripensare…

Di seguito vi condivido una primissima bozza di attività da perfezionare, per velocità di scrittura inserisco direttamente quanto scritto nei miei appunti su Evernote spero che queste idee possano servire anche ad altri:

Bozza di progetto:

vediamo la prima puntata di ROB-O-COD in classe, al termine ne faccio nascere un confronto tra gli allievi per immaginare attività di gara e modalità di costruzione campi e robot.
I campi gara avranno una forma geometrica particolare (nota per il lettore: non ne posso parlare in questo post per non svelare troppe cose ma potreste intuire la forma dei tavoli dalla grafica della trasmissione 😉 ).
Spiego come costruire su carta questa specifica forma geometrica.
Con le dimensioni reali usate per realizzare i campi gara in trasmissione, replichiamo la forma con dello nastro di carta posto sul pavimento dell’aula, all’interno del perimetro dovranno gareggiare i robot programmati dai bambini.
Le dinamiche di gioco saranno molto simili a quelle della trasmissione: presenza di un pubblico, di tecno-disturbatori che dovranno creare difficoltà alla movimentazione dei robot, ecc…
Tecnologia dei robot: primo girone realizzazione di robot basati su BBC micro:bit la cui struttura sarà di cartone, secondo girone robot realizzati con Lego WeDo. I primi classificati potranno utilizzare il Lego Mindstorms EV3 messo a disposizione del Prof. (Io) per realizzare una gara su un singolo campo di gioco.
Scrivere le storie. Le storie potranno essere realizzate prendendo spunto da quanto proposto di giorno in giorno nella trasmissione oppure inventate dagli studenti (valutare attività da far svolgere durante le attività al mattino).
Come realizzare la scenografia? Scatole di cartone, bottiglie e bicchieri di plastica, mattoncini Lego.

Cercherò nelle prossime settimane condividere una versione aggiornata dell’attività. L’intero percorso sarà presentato ad un gruppo di insegnanti durante l’evento di Coding e Robotica per scuole medie organizzato dall’IIS Vallauri di Fossano il prossimo 6 giugno.

e ricordare: #ROB_O_COD è tutto un programma!

🙂

Articoli simili:

Pubblicato in programmazione, robotica | Contrassegnato coding, game show, kids, lego, micro:bit, mindstorms, programmazione, rai gulp, rai ragazzi, ROBOCOD, robot, robotica, rob_o_cod, teens, WeDo | Lascia un commento

Appunti di programmazione su Arduino: esercizi di approfondimento su istruzione switch..case, display a 7 segmenti, Serial.read

Pubblicato il Aprile 24, 2019 da admin

Durante le scorse settimane ho svolto una serie di esercitazioni di laboratorio che avevano l’obiettivo di insegnare l’uso dell’istruzione switch…case e la modalità di ricezione dati seriali in Arduino.

La prima lezione è introdotta nel post:

Appunti di programmazione su Arduino: controllo di flusso – istruzione switch..case

Nell’articolo trovate due link che fanno riferimento a due guide sul sito Arduino in cui viene mostrato come utilizzando l’istruzione switch…case:

per inviare un output specifico sulla Serial monitor in funzione del valore letto dal sensore;
usare la Serial input per accendere uno specifico LED.

La seconda lezione è basata sul tutorial:

Arduino – lezione 08: display a 7 segmenti e creazione di librerie

In cui viene mostrato come pilotare un display a 7 segmenti realizzando un contatore da 0 a 9, e cicli di visualizzazione di numeri pari e numeri dispari. Nella parte finale del tutorial viene mostrato come realizzare una libreria dedicata alla gestione del display a 7 segmenti.

La terza lezione mostra come ricevere dati dalla seriale in Arduino.

Per questa parte è indispensabile svolgere le esercitazioni che trovate nelle slide:

Alfabeto di Arduino – Lezione 3 da pagina 53 a pagina 62

Successivamente aggiungo gli esercizi che di seguito condivido, in cui riprendendo la gestione del display a 7 segmenti, però questa volta inviamo dati dal computer mediante la tastiera al display comandato da Arduino.

Per lo svolgimento di questa parte è necessario effettuare una piccola variazione rispetto al circuito mostrato in: Arduino – lezione 08: display a 7 segmenti e creazione di librerie in questa lezione volutamente utilizzo tra tutti i pin il piedino 1 di Arduino che viene utilizzato normalmente come pin TX e ciò provoca un comportamento anomalo di accensione del LED e del display, ciò mi permette di spiegare l’utilizzo dei pin 0 e 1 di Arduino.

Il circuito da realizzare per la terza lezione è il seguente (i pin di controllo di Arduino sono presi in maniera sequenziale dal pin 6 al pin 12)

Esercitazione 1

Realizzare un contasecondi da 0 a 9 utilizzando un display 7 segmenti a catodo comune

Soluzione

// Prof. Michele Maffucci
// 14.04.2019

// Conteggio 9 secondi con display 7 segmenti a catodo comune

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a=12;
const int b=11;
const int c=10;
const int d=9;
const int e=8;                           
const int f=7;
const int g=6;

// variabile che definisce la velocità con cui appaiono i numeri
const int pausa = 1000;

void setup()
{
  // inizializzazione dei pin ad OUTPUT
  for (int i=6; i<13; i++) {
    pinMode(i, OUTPUT); 
  }
}

void loop ()
{
  for (int i=0;i<10;i++) 
  {
    LedAcceso(i);
    delay (pausa);
  }
}

void LedAcceso(int n)
{
  switch(n)
  {
  case 0:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, LOW);
    break;

  case 1:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;

  case 2:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, LOW); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;
  case 3:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;

  case 4:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 5:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 6:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 7:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;

  case 8:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 9:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

// Prof. Michele Maffucci

// 14.04.2019

// Conteggio 9 secondi con display 7 segmenti a catodo comune

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a=12;

const int b=11;

const int c=10;

const int d=9;

const int e=8;

const int f=7;

const int g=6;

// variabile che definisce la velocità con cui appaiono i numeri

const int pausa = 1000;

void setup()

{

// inizializzazione dei pin ad OUTPUT

for (int i=6; i<13; i++) {

pinMode(i, OUTPUT);

}

void loop ()

{

for (int i=0;i<10;i++)

{

LedAcceso(i);

delay (pausa);

}

void LedAcceso(int n)

{

switch(n)

{

case 0:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case 1:

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case 2:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case 3:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case 4:

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 5:

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 6:

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 7:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case 8:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case 9:

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

}

Esercitazione 2

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviene quando si preme invio.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;
      
    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviene quando si preme invio.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

}

Esercitazione 3

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f 

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  for (int i = 0; i < 6; i++) {
      digitalWrite(a, HIGH);
      delay(intervallo);
      digitalWrite(a, LOW);
      delay(intervallo);
      digitalWrite(b, HIGH);
      delay(intervallo);
      digitalWrite(b, LOW);
      delay(intervallo);      
      digitalWrite(c, HIGH);
      delay(intervallo);
      digitalWrite(c, LOW);
      delay(intervallo);      
      digitalWrite(d, HIGH);
      delay(intervallo); 
      digitalWrite(d, LOW);
      delay(intervallo);      
      digitalWrite(e, HIGH);
      delay(intervallo);
      digitalWrite(e, LOW);
      delay(intervallo);      
      digitalWrite(f, HIGH);
      delay(intervallo);
      digitalWrite(f, LOW);
      delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void roll() {

for (int i = 0; i < 6; i++) {

digitalWrite(a, HIGH);

delay(intervallo);

digitalWrite(a, LOW);

delay(intervallo);

digitalWrite(b, HIGH);

delay(intervallo);

digitalWrite(b, LOW);

delay(intervallo);

digitalWrite(c, HIGH);

delay(intervallo);

digitalWrite(c, LOW);

delay(intervallo);

digitalWrite(d, HIGH);

delay(intervallo);

digitalWrite(d, LOW);

delay(intervallo);

digitalWrite(e, HIGH);

delay(intervallo);

digitalWrite(e, LOW);

delay(intervallo);

digitalWrite(f, HIGH);

delay(intervallo);

digitalWrite(f, LOW);

delay(intervallo);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

}

Esercitazione 4

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display
Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  for (int i = 0; i < 6; i++) {
      digitalWrite(a, HIGH);
      delay(intervallo);
      digitalWrite(a, LOW);
      delay(intervallo);
      digitalWrite(b, HIGH);
      delay(intervallo);
      digitalWrite(b, LOW);
      delay(intervallo);      
      digitalWrite(c, HIGH);
      delay(intervallo);
      digitalWrite(c, LOW);
      delay(intervallo);      
      digitalWrite(d, HIGH);
      delay(intervallo); 
      digitalWrite(d, LOW);
      delay(intervallo);      
      digitalWrite(e, HIGH);
      delay(intervallo);
      digitalWrite(e, LOW);
      delay(intervallo);      
      digitalWrite(f, HIGH);
      delay(intervallo);
      digitalWrite(f, LOW);
      delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      digitalWrite(a, LOW);
      digitalWrite(b, LOW);
      digitalWrite(c, LOW);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void roll() {

for (int i = 0; i < 6; i++) {

digitalWrite(a, HIGH);

delay(intervallo);

digitalWrite(a, LOW);

delay(intervallo);

digitalWrite(b, HIGH);

delay(intervallo);

digitalWrite(b, LOW);

delay(intervallo);

digitalWrite(c, HIGH);

delay(intervallo);

digitalWrite(c, LOW);

delay(intervallo);

digitalWrite(d, HIGH);

delay(intervallo);

digitalWrite(d, LOW);

delay(intervallo);

digitalWrite(e, HIGH);

delay(intervallo);

digitalWrite(e, LOW);

delay(intervallo);

digitalWrite(f, HIGH);

delay(intervallo);

digitalWrite(f, LOW);

delay(intervallo);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

digitalWrite(a, LOW);

digitalWrite(b, LOW);

digitalWrite(c, LOW);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

roll();

}

Esercitazione 5

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display.
Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}


void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  // spegnimento di tutti i led del display
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int i = 0; i < 6; i++) {
    digitalWrite(a, HIGH);
    delay(intervallo);
    digitalWrite(a, LOW);
    delay(intervallo);
    digitalWrite(b, HIGH);
    delay(intervallo);
    digitalWrite(b, LOW);
    delay(intervallo);
    digitalWrite(c, HIGH);
    delay(intervallo);
    digitalWrite(c, LOW);
    delay(intervallo);
    digitalWrite(d, HIGH);
    delay(intervallo);
    digitalWrite(d, LOW);
    delay(intervallo);
    digitalWrite(e, HIGH);
    delay(intervallo);
    digitalWrite(e, LOW);
    delay(intervallo);
    digitalWrite(f, HIGH);
    delay(intervallo);
    digitalWrite(f, LOW);
    delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

void roll() {

// spegnimento di tutti i led del display

digitalWrite(a, LOW);

digitalWrite(b, LOW);

digitalWrite(c, LOW);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

// ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f

for (int i = 0; i < 6; i++) {

digitalWrite(a, HIGH);

delay(intervallo);

digitalWrite(a, LOW);

delay(intervallo);

digitalWrite(b, HIGH);

delay(intervallo);

digitalWrite(b, LOW);

delay(intervallo);

digitalWrite(c, HIGH);

delay(intervallo);

digitalWrite(c, LOW);

delay(intervallo);

digitalWrite(d, HIGH);

delay(intervallo);

digitalWrite(d, LOW);

delay(intervallo);

digitalWrite(e, HIGH);

delay(intervallo);

digitalWrite(e, LOW);

delay(intervallo);

digitalWrite(f, HIGH);

delay(intervallo);

digitalWrite(f, LOW);

delay(intervallo);

}

void LedAcceso(int n)

{

switch (n)

{

case '0':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

roll();

}

Esercitazione 6

Realizzare le stesse funzionalità dell’esercizio 5 ma ottimizzare la funzione roll() in modo che lo spegnimento iniziale dei LED sia costituito da un ciclo for e l’accensione e lo spegnimento sequenziale sia realizzato da due cicli for annidati.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione in cui la funzione roll() è stata ottimizzata
// Lo spegnimento iniziale dei LED è costituito da un ciclo for e l'accensione e lo spegnimento sequenziale
// è realizzato da due cicli for annidati.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}


void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

// funzione per gioco di luci
void roll() {

  // spegnimento di tutti i led del display
  for (int i = 6; i < 13; i++) {
    digitalWrite(i, LOW);
  }

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int m = 0; m < 6; m++) {
    for (int p = 12; p > 6; p--) {
      digitalWrite(p, HIGH);
      delay(intervallo);
      digitalWrite(p, LOW);
      delay(intervallo);
    }
  }
}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display
// prima che venga stampato il numero viene eseguita la funzione roll()
void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione in cui la funzione roll() è stata ottimizzata

// Lo spegnimento iniziale dei LED è costituito da un ciclo for e l'accensione e lo spegnimento sequenziale

// è realizzato da due cicli for annidati.

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

// funzione per gioco di luci

void roll() {

// spegnimento di tutti i led del display

for (int i = 6; i < 13; i++) {

digitalWrite(i, LOW);

}

// ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f

for (int m = 0; m < 6; m++) {

for (int p = 12; p > 6; p--) {

digitalWrite(p, HIGH);

delay(intervallo);

digitalWrite(p, LOW);

delay(intervallo);

}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display

// prima che venga stampato il numero viene eseguita la funzione roll()

void LedAcceso(int n)

{

switch (n)

{

case '0':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

roll();

}

Esercitazione 7

Realizzare le stesse funzionalità dell’esercizio 6 realizzando una libreria di gestione “LedAcceso.h” richiamata dallo sketch principale. Per l’esecuzione di questo esercizio seguire le indicazioni fornite al fondo del tutorial: Arduino – lezione 08: display a 7 segmenti e creazione di librerie

Soluzione

LedAcceso.cpp

/* display_sette_segmenti.cpp
libreria che consente il controllo di un display a 7 segmenti a catodo comune
del tipo HDSP 5503
*/

#include "Arduino.h"

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

// funzione per gioco di luci
void roll() {

  // spegnimento di tutti i led del display
  for (int i = 6; i < 13; i++) {
    digitalWrite(i, LOW);
  }

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int i = 0; i < 6; i++) {
    for (int j = 12; j > 6; j--) {
      digitalWrite(j, HIGH);
      delay(intervallo);
      digitalWrite(j, LOW);
      delay(intervallo);
    }
  }
}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display
// prima che venga stampato il numero viene eseguita la funzione roll()
void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

/* display_sette_segmenti.cpp

libreria che consente il controllo di un display a 7 segmenti a catodo comune

del tipo HDSP 5503

#include "Arduino.h"

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

// funzione per gioco di luci

void roll() {

// spegnimento di tutti i led del display

for (int i = 6; i < 13; i++) {

digitalWrite(i, LOW);

}

// ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f

for (int i = 0; i < 6; i++) {

for (int j = 12; j > 6; j--) {

digitalWrite(j, HIGH);

delay(intervallo);

digitalWrite(j, LOW);

delay(intervallo);

}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display

// prima che venga stampato il numero viene eseguita la funzione roll()

void LedAcceso(int n)

{

switch (n)

{

case '0':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, LOW);

break;

case '1':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '2':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, LOW);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '3':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, HIGH);

break;

case '4':

roll();

digitalWrite(a, LOW);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '5':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '6':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, LOW);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '7':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, LOW);

digitalWrite(e, LOW);

digitalWrite(f, LOW);

digitalWrite(g, LOW);

break;

case '8':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, HIGH);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

case '9':

roll();

digitalWrite(a, HIGH);

digitalWrite(b, HIGH);

digitalWrite(c, HIGH);

digitalWrite(d, HIGH);

digitalWrite(e, LOW);

digitalWrite(f, HIGH);

digitalWrite(g, HIGH);

break;

default:

roll();

}

LedAcceso.h

/* LedAcceso.h
   header file della libreria LedAcceso
*/
 
#include "Arduino.h"
 
void LedAcceso(int n);  // prototipo della funzione
void roll();            // prototipo della funzione

/* LedAcceso.h

header file della libreria LedAcceso

#include "Arduino.h"

void LedAcceso(int n); // prototipo della funzione

void roll(); // prototipo della funzione

sketch

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione con inclusione della libreria di gestione dell'accensione del display

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

#include "LedAcceso.h"

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  // verifica se sulla serial monitor è presente un carattere,
  // se la condizione è vera viene letto il carattere presente sulla serial monitor
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

// Prof. Michele Maffucci

// 14.04.2019

// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9

// La scrittura avviena quando si preme invio.

// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f

// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione con inclusione della libreria di gestione dell'accensione del display

// definizione delle variabili a cui collegare ogni segmento del display

// la lettera rappresenta il segmento del display il numero il pin

// digitale di Arduino a cui è collegato il corrispondente pin del display

#include "LedAcceso.h"

const int a = 12;

const int b = 11;

const int c = 10;

const int d = 9;

const int e = 8;

const int f = 7;

const int g = 6;

const int intervallo = 10;

void setup()

{

// inizializzazione della seriale

Serial.begin(9600);

// inizializzazione dei pin ad OUTPUT

for (int i = 6; i < 13; i++) {

pinMode(i, OUTPUT);

}

roll();

}

void loop()

{

// verifica se sulla serial monitor è presente un carattere,

// se la condizione è vera viene letto il carattere presente sulla serial monitor

if (Serial.available()) {

int selettore = Serial.read();

LedAcceso(selettore);

}

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi | Contrassegnato 7 segment, arduino, C, case, display, libraries, libreria, switch | Lascia un commento

ROB-O-COD… tanto tempo fa era un LegoDuino

Pubblicato il Aprile 23, 2019 da admin

Mi è stato chiesto qualche giorno fa quale piattaforma fosse stata scelta per la realizzazione dei Robot per le gara per la trasmissione ROB-O-COD.

La scelta è stata attentamente valutata, anche con sperimentazioni pratiche che mi hanno coinvolto in prima persona.

Nel “brodo primordiale delle idee” 🙂 circa 1 anno fa, erano state considerate diverse tecnologie: BBC micro:bit, robot basati su Arduino e dopo tanto sperimentare e progettare, si è giunti a Lego Mindstorms EV3, i motivi di questa scelta, condivisi tra tutte le persone che hanno partecipato alla realizzazione della trasmissione sono stati molti, i principali: rapidità di assemblaggio e modifica dei robot in un ambito di studio televisivo, personalizzazione delle strutture, interfaccia grafica di programmazione intuitiva… e molto altro.

Nelle prime fasi di progetto ho valutato e sperimentato soluzioni miste, interfacciando, motori Lego Mindstorms con Arduino.
In passato avevo realizzato LegoDuino (seguendo il link potrete vedere un video dimostrativo) l’obiettivo era quello di realizzare dei robot Sumo, su di essi avevo inserito sensori ad ultrasuoni ed infrarossi.

Per ROB-O-COD, ho variato la versione Sumo in una versione cingolato su cui ho svolto le primissime sperimentazioni:

Ma come realizzare una soluzione mista?

Poiché mi è stato chiesto espressamente da alcuni colleghi, di seguito propongo un breve tutorial per la realizzazione di una struttura mista (Lego+Arduino) in modo che possiate poi da soli replicare le modalità di gara così come le potrete vedere nella trasmissione ROB-O-COD.

Il motore Lego Mindstorms, sia nella versione NXT che EV3 funziona ad una tensione di 9V e possiede al suo interno un encoders rotativo con una risoluzione di 1 grado, il controllo avviene mediante i cavi gialli e blu, nel tutorial che mostro però non utilizzerò l’encoder, ma solamente i due cavi bianco e nero utilizzati per l’invio del segnale PWM questi pin vengono chiamati MA0 e MA1 (tabella pin indicata di seguito).

Per effettuare il collegamento tra motore ed Arduino potete utilizzare una piccola interfaccia che permette di collegare i cavi BrickLink (noto anche come RJ12) in dotazione ai kit Lego Mindstorms, con la breadboard, i connettori si chiamano:

Breadboard Connector Kit for NXT or EV3 (seguite il link)

Nel caso non riusciste a procuravi questo adattatore, tagliate il cavo BrickLink ed utilizzate solamente i cavi bianco e nero, saranno questi che verranno collegati direttamente ad Arduino.

Di seguito la mappatura del cavo, per la numerazione fate riferimento a quanto indicato nell’immagine in cui è rappresentato il motore:

PIN    Colore    Nome
 1     Bianco    MA0
 2     Nero      MA1
 3     Rosso     GND
 4     Verde     4.3V dal mattoncini Lego
 5     Giallo    Tach01 (Encoder rotativo)
 6     Blu       Tach02 (Encoder rotativo)

PIN Colore Nome

1 Bianco MA0

2 Nero MA1

3 Rosso GND

4 Verde 4.3V dal mattoncini Lego

5 Giallo Tach01 (Encoder rotativo)

6 Blu Tach02 (Encoder rotativo)

Per procedere nella sperimentazione dovete munirvi di:

Scheda Arduino UNO R3 o simili
Scheda motore L298N
Breadboard Connector Kit for NXT or EV3 (in alternativa tagliate i cavi)
Uno o due motori Lego NXT o EV3

Il principio di funzionamento, inclusi i collegamenti, la programmazione e il funzionamento della scheda motori L298N sono identici a quelli che trovate nella lezione:

EduRobot – ASL (Alternanza Scuola Lavoro) – Manuale di costruzione – 2/3

Seguendo la lezione sarete in grado di realizzare un robot costituito da elementi Lego, scheda Arduino e sensori, tutto facilmente reperibile on-line a costi contenuti.

Aggiungo a quanto già indicato nella lezione segnalata sopra, gli schemi di collegamenti con la presenza dei motori Lego alimentati mediante una batteria esterna a 9V.

E se poi siete “puristi Lego” 🙂 allora partendo dai tutorial che trovate nell’ambiente di programmazione della versione LEGO MINDSTORMS EV3 Home Edition potrete realizzare qualcosa di molto simile a quanto mostrato nell’immagine che segue…

e ricordare: #ROB_O_COD è tutto un programma!

🙂

Articoli simili:

Pubblicato in arduino, robotica | Contrassegnato coding, game show, kids, lego, micro:bit, mindstorms, programmazione, rai, rai gulp, rai ragazzi, ROBOCOD, robot, robotica, rob_o_cod, teens | Lascia un commento

ROB-O-COD

Pubblicato il Aprile 16, 2019 da admin

Per tutti gli amici, studenti, colleghi interessati al mondo del Coding e della robotica, sono felice di comunicarvi la messa in onda del nuovo programma televisivo di Rai ragazzi su Rai Gulp: ROB-O-COD il game-show dove il coding diventa una sfida.

Ho avuto l’onore di collaborare, insieme ad altre fantastiche persone, nella progettazione dei campi gara immaginando percorsi e meccanismi che aggiungono gradi di difficoltà diversi in ogni campo gara.

Il programma, sarà in onda dal 29 Aprile al 30 Maggio, dal lunedì al sabato, alle ore 17.55 su RAI GULP (canale 42 – DTT) e dal giorno dopo sarà visibile su Raiplay www.raiplay.it

Sedici squadre di ragazzi, divise in quattro gironi, partecipano al torneo di coding che si sviluppa in 28 puntate.

In uno studio con un allestimento fantascientifico, due team composti da una coppia di giovanissimi programmatori di 12 anni, i Robocoder, provenienti dalle scuole di tutta Italia, si sfidano con i loro robot su campi di gara ispirati a mondi fantastici, dal medioevale al post apocalittico, dalla fantascienza all’horror.

L’obiettivo finale del game è quello di portare a termine il percorso, affrontando gli ostacoli e le prove e cercando di guadagnare il maggior numero di punti necessari per vincere la puntata.
Per riuscirci hanno a disposizione un tempo limitato per testare i campi gara e programmare le stringhe di coding che ritengono più adatte a superare gli ostacoli.
Terminata la fase di coding, inizia la sfida in cui le squadre attivano i propri robot, per le due robo challenges di gara.
I team che nel proprio girone si aggiudicano più bitpoint accedono alle semifinali e i vincitori si sfidano per il titolo di campione del torneo.

Protagonisti del programma, oltre alle squadre di Robocoder, i ragazzi del pubblico, studenti di scuola secondaria di primo grado divisi in tifoserie, ciascuna schierata per l’una o l’altra squadra, tra cui vengono scelti due tecno-assistenti, che si occupano di controllare la correttezza della gara, e due tecno-disturbatori, con il compito di ostacolare i robot durante il percorso.

ROB-O-COD è un programma di Armando Traverso e Mario Bellina.
Con la Consulenza di Michele Maffucci e Andrea Angiolino
per il Centro Ricerche Innovazione Tecnologica e Sperimentazione RAI Luca Vignaroli
Regia di Paolo Severini.
Produttrice Esecutiva Cristina Cuzzupoli.
Una produzione originale Rai Ragazzi

Potete seguire gli eventi collegati alla trasmissione anche sui canali social Rai:

SITO: www.rai.it/raigulp/

Pagina di presentazione

Se desiderate potete condividere i vostri pensieri sul programma su Instagram con il #rob_o_cod e taggando @rai_gulp, potete mandare video e foto dei vostri migliori momenti di coding a scuola e a casa.

Ricordate:

#rob_o_cod è tutto un programma!

🙂

[Comunicato stampa]

Articoli simili:

Pubblicato in news, programmazione, robotica | Contrassegnato bitpoint, coding, lego, rai, rai gulp, rai ragazzi, rob-o-cod, Robocoder, robotica, rob_o_cod | Lascia un commento

Appunti di programmazione su Arduino: controllo di flusso – istruzione switch..case

Pubblicato il Aprile 6, 2019 da admin

Nella scorsa settimana e in quella che verrà, con gli allievi di 3A e 3B Automazione ho svolto e svolgerò alcune esercitazioni sul controllo di flusso per gestire valori provenienti da sensori e controllare l’attivazione di motori elettrici mediante tastiera del computer e tastierino numerico esterno. Al fine di approfondire l’uso in C del controllo di flusso aggiungo alcune informazioni aggiuntive sull’uso dell’istruzione switch..case, per le altre istruzioni sul controllo di flusso si consulti su questo sito la sezione: Usare Arduino -> Appunti di Programmazione -> controllo di flusso

Come accade per l’istruzione if, l’istruzione switch…case, che viene chiamata anche istruzione di selezione multipla, permette il controllo di flusso dei vostri programmi permettendo di specificare porzioni diverse di codice da eseguire in funzione di una serie di condizioni impostate.

In particolare, l’istruzione switch (interruttore) confronta il valore intero costante con i valori specificati nelle etichetta case (caso). Quando viene trovata un’istruzione case il cui valore corrisponde a quello passato dallo switch, viene eseguito il codice contenuto nel case.

Nel caso in cui non venga riscontrata nessuna occorrenza del valore passato dalla switch, sarà eseguita la sezione default.

L’istruzione break consente l’uscita dall’istruzione switch e viene in genere utilizzata alla fine di ogni case, portando il controllo del programma a continuare con la prima istruzione dopo l’istruzione switch.

Nel caso in cui il break non venga inserita all’interno del case, l’istruzione switch continuerà ad eseguire le istruzioni che seguono, comportamento che viene chiamato “falling-through”, fino all’interruzione o alla fine dell’istruzione switch.

Nel caso in cui il break non fosse inserito in ognuno dei case, ogni volta che fosse incontrata una corrispondenza con uno dei case, verrebbero eseguite anche tutte le istruzioni dei case rimanenti, nel caso in cui non venga riscontrata nessuna occorrenza del valore passato dalla switch, sarà eseguita la sezione default e successivamente visualizzato un messaggio di errore.

Si faccia attenzione che quando si utilizza il comando switch, ogni singolo case può essere utilizzato solamente per controllare una espressione intera costante, cioè ogni combinazione di costanti di carattere e interi che possono essere valutati come valori interi, le costanti intere sono semplicemente dei valori interi ed una variabile di tipo carattere è rappresentata con il carattere specifico posto tra apici singoli, come ‘M’. Si ricordi che i caratteri sono in realtà dei valori interi memorizzati in un byte.

Sintassi

switch (variabile) { 
   case label:
   // istruzioni
   break;
}
case label: { 
   // istruzioni
   break;
}
default: { 
   // istruzioni
   break;
}

switch (variabile) {

case label:

// istruzioni

break;

}

case label: {

// istruzioni

break;

}

default: {

// istruzioni

break;

}

Vi rimando al reference on-line sul sito di Arduino per analizzare alcuni esempi che svilupperemo con ulteriori esercitazioni tratte dalle mie slide e che svolgeremo a lezioni:

Buon lavoro 🙂

Articoli simili:

Pubblicato in arduino, i miei allievi, programmazione | Contrassegnato arduino, case, controllo di flusso, programmazione, switch | Lascia un commento

Supporto a T per profilati in alluminio 20×20 per sensore ad ultrasuoni HC-SR04

Pubblicato il Aprile 4, 2019 da admin

Sto sviluppando da qualche tempo una struttura robotica realizzata con profililati in alluminio. Originariamente il tutto doveva essere realizzato con dei Makerbeam, ma poiché ho aumentato le dimensioni del robot, altezza di circa 1 m, sono passato a profilati in alluminio 20×20 mm con sedi a T come quelli che potete vedere nelle immagini che seguono.

La prima versione del sistema di orientamento del robot sarà costituita da 8 sensori ad ultrasuoni che disporrò sui 4 angoli, così come indicato nell’immagine che segue.

Per rendere più agevole la costruzione e future modifiche ho pensato di realizzare dei supporti angolari con fissaggio a vite M3 e su di essi una struttura a slitta su cui collocare il sensore ad ultrasuoni

Rendo pubblico su Thingiverse i file per la stampa 3D dei due elementi, in modo che anche altri possano utilizzarli.

Un saluto a tutti i Robot Maker 🙂

Articoli simili:

Pubblicato in Stampa 3D | Contrassegnato HC-SR04, robot, T-slot, ultrasonic sensor | Lascia un commento

EduRobot – ASL V02 per Arduino e BBC micro:bit

Pubblicato il Aprile 4, 2019 da admin

Rendo pubblica la versione 2 di EduRobot ridisegnata completamente. Il kit di sperimentazione può accogliere indifferentemente una scheda Arduino oppure una scheda BBC micro:bit. La struttura può essere realizzata, come indicato nell’immagine che segue, da due ruote e una ball caster, oppure può essere trasformato in un rover a 4 ruote.
Nel caso fosse necessario alloggiare più elettronica, è possibile impilare più piattaforme di legno.

Di seguito i file vettoriali che potete utilizzare per la realizzazione del taglio laser, oppure se disponete di una stampante 3D con piatto sufficientemente grande potrete stampare la base.

EduRobot – V02 – illustrator ed eps

Le parti stampate in 3D sono elementi derivati dalla versione precedente: EduRobot – ASL (Alternanza Scuola Lavoro) – 2019

Seguendo il link che segue troverete tutti i riferimenti per la stampa di tutti gli elementi della versione 2 sia per BBC micro:bit che per Arduino a 2 o 4 ruote in cui trovate tutti gli elementi per la stampa 3D aggiornati.

EduRobot – ASL – V02

Nei prossimi giorni fornirò i dettagli costruttivi meccanici, elettronici e di Coding sia per micro:bit che per Arduino, in ogni caso dalle foto allegate si evincono una serie di dettagli costruttivi per la versione micro:bit.

Mi scuso con i molti colleghi e studenti a cui avevo promesso questo lavoro mesi fa e che in diverse occasioni mi hanno manifestato la necessità di una piattaforma facilmente modificabile ed adattabile alle diverse esigenze didattiche per ogni ordine di scuola.

Alcuni amici, nel vedere il prototipo mi hanno chiesto anche una versione per Raspberry Pi, pertanto ci sarà anche questa evoluzione del kit.

Sarà quasi certamente questa la versione che farò diventare uno standard nelle mie lezioni di laboratorio di sistemi e tpsee.

Spero che questo lavoro possa servire anche ad altri.

Come sempre liberi di condividere e modificare.
Buona sperimentazione a tutti 🙂

Di seguito alcuni dettagli costruttivi (click sull’immagine per l’ingrandimento):

Coding a scuola con BBC micro:bit – non toccare il filo metallico!

Pubblicato il Aprile 2, 2019 da admin

Propongo una scheda didattica che ho utilizzato durante i miei corsi di formazione per scuole medie ed elementari e durante la formazione per docenti. Questa proposta laboratoriale di Coding è la variante di una sperimentazione che spesso viene proposta durante i laboratori con micro:bit, nella scheda che vi propongo ho effettuato delle variazioni sulle modalità costruttive e sugli esercizi proposti.

Scheda di lavoro: non toccare il filo metallico!

OBIETTIVO: realizziamo un gioco in cui dovete percorrere un percorso costituito da un filo metallico senza toccare il filo. Ogni volta che toccate il filo sarà visualizzata una X e successivamente il numero di errori che avrete totalizzato.

PASSO 1

Per realizzare questa esercitazione avrete bisogno:

due fili di metallo di lunghezza variabile tra i 30 cm e i 50 cm
due mollette per biancheria
due cavi con morsetti a coccodrillo
batterie per micro:bit

PASSO 2

Realizziamo il programma che permette di impostare inizialmente il numero di errori a 0. Dall’area di programmazione cancellare le istruzioni: “on start” e “forever”

PASSO 3

Dalla sezione Input selezionare l’istruzione “on button A pressed” e trascinarla nell’area di programma

PASSO 4

Dalla sezione Variables selezionare “Make a Variables” e create la variabile errori

PASSO 5

Trascinare l’istruzione “set errori to 0” l’istruzione “on button A pressed”

PASSO 6

Trascinare l’istruzione “show number 0” dalla sezione “Basic” e inserirla dopo l’istruzione “set errori to 0”

PASSO 7

Dalla sezione “Variables” trascinare la variabile errori all’interno del valore 0 in “show number 0”

PASSO 8

Realizzare il programma che permette di aggiungere una unità ognivolta che viene fatto un errore.
Dalla sezione “Input” selezionare l’istruzione “on pin P0 pressed” e trascinarla nell’area di programma:

PASSO 9

Aggiungere due blocchi che permettono di visualizzare una X per 1 secondo:

PASSO 10

Quando tocchiamo il filo bisogna sommare 1 alla variabile errori per fare questo aggiungere un’istruzione “change errori by 1” come indicato nell’immagine:

PASSO 11

Aggiungere con un’istruzione “show number 0” e al posto del valore 0 inserire la variabile “errori”, in modo che venga visualizzato sul display il numero di errori ogni volta che viene toccato il filo:

PASSO 12

Fate click su “Download” per trasferire il programma sul micro:bit

PASSO 13

Costruire l’anello avvolgendo uno pezzo di filo:

PASSO 14

Costruire il percorso con il secondo pezzo di filo ed utilizzare le due mollette per costruire il supporto per reggere il filo:

PASSO 15

Inserire l’anello all’interno del percorso:

PASSO 16

Collegare un morsetto a coccodrillo sull’anello ed uno ad uno dei due capi del percorso:

PASSO 17

Collegare i cavi dell’anello e del percorso rispettivamente ai pin 0 e GND

Proposte di esercizio

Prerequisiti

Utilizzando il circuito precedente spostare il coccodrillo dal pin 0 al pin 1 e modificare il programma precedente in modi che abbia il medesimo funzionamento. Aggiungere un piccolo altoparlante, in alternativa le cuffie del cellulare e collegarlo come riportato nell’immagine che segue tra il contatto 0 e il contatto GND del micro:bit

Esercizi

Far emettere una melodia musicale quando si avvia il micro:bit
Far emettere una nota musicale quando l’anello tocca il filo

Suggerimento

Per rendere più agevole l’utilizzo in classe, allego questa scheda di lavoro impaginata in formato PDF.

scheda di lavoro – non toccare il filo metallico! (PDF)

Buon Coding a tutti 🙂

Articoli simili:

Pubblicato in corsi, micro:bit | Contrassegnato coding, elementare, laboratorio, pensiero computazionale, scheda, scuola media, scuola primaria | Lascia un commento

I miei corsi per La Tecnica della Scuola – Didattica laboratoriale con la stampa 3D – 2ª ed.

Pubblicato il Marzo 31, 2019 da admin

Domani parte la seconda edizione del corso di stampa 3D dedicato ai docenti di ogni ordine e grado, per chi fosse interessato è possibile ancora iscriversi.

Saranno svolti 3 incontri di 2 ore ciascuno per un totale di 6 ore

Lunedì 1 aprile 2019 – dalle 17.00 alle 19.00
Lunedì 8 aprile 2019 – dalle 17.00 alle 19.00
Lunedì 15 aprile 2019 – dalle 17.00 alle 19.00

Il corso si prefigge di fornire tutti gli strumenti necessari per la prototipazione rapida tramite stampante 3d mostrando esempi e schede applicative per un utilizzo in un contesto didattico.

Il corso è introduttivo e di base ed indirizzato a tutti i docenti, è pensato per essere semplice ed immediato, di facile apprendimento volto all’apprendimento del know-how di base per comprendere il funzionamento di una stampante 3D, valutare software necessari per la modellazione di oggetti tridimensionali e gestire l’intero processo di stampa 3D.

Verranno inoltre fornite indicazioni in merito:

alla modalità di valutazione del tipo di stampante da acquistare in funzione delle attività didattiche da svolgere
valutazioni caratteristiche delle stampanti 3D in funzione del budget disponibile
analisi costi di mantenimento
scelta dei software di moderazione 3D da utilizzare con gli allievi in funzione dell’ordine di scuola
proposte didattiche laboratoristi con schede di lavoro

Per maggiori informazioni seguire il LINK

Articoli simili:

Pubblicato in corsi, Stampa 3D | Contrassegnato 3d print, corso, modellazione, stampa 3d, Tecnica della Scuola | Lascia un commento

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Scheda di lavoro: non toccare il filo metallico!

Condividi:

Mi piace:

Articoli simili:

Condividi:

Mi piace:

Articoli simili:

Dove mi trovi?

Iscriviti al blog tramite email

Cerca

Categorie

Vuoi aiutare la mia attività di divulgazione?

Domande

Arduino che passione

WebApp Arduino

BBC micro:bit

Stampa 3D

DotBot

EduRobot

Raspberry Pi

Corso di Elettronica

Micro corso di elettronica per principianti

Saldare è semplice

Robot Pet Therapy

BiblioBox

Pillole di tecnologia didattica

Instagram

Seguimi su Twitter

Articoli recenti

Ultimi commenti

Tag

Foto Flickr

Pubblicità