Archivi categoria: i miei allievi

Corso in presenza: Coding a scuola con BBC micro:bit

Ancora un altro corso sull’uso di BBC micro:bit questa volta in presenza a Torino presso il Laboratorio di Informatica dell’IIS Gobetti Marchesini Casale Arduino Via Figlie dei Militari, 25 Torino.

Gli argomenti svolti saranno i medesimi di quelli offerti per il corso in Webinar di Tecnica della Scuola, però con sperimentazioni pratiche “costruisci e programma”, tanta didattica della robotica, uso di micro:bit per effettuare sperimentazioni scientifiche ed utilizzo di micro:bit con altri linguaggi di programmazione.

Saranno ammessi uno/due docenti per Istituzione Scolastica fino ad esaurimento dei 15 posti disponibili.

L’elenco degli ammessi sarà pubblicato il 9/11/2018 sul sito http://www.necessitaeducativespeciali.it

Calendario degli incontri: 15/11, 22/11, 26/11, 28/11 dalle ore 15.00 alle 17.30

Il corso è gratuito.
Per le modalità di iscrizione seguire il link.

MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 3

Disegnare immagini statiche è divertente, ma ancora più divertente è farle muovere e fare questo con MicroPython è molto semplice, è sufficiente indicare un elenco di immagini, in questa lezione vedremo come fare.

Per capire come animare una serie di immagini abbiamo necessità di utilizzare le liste.

Lista della spesa:

Uova
Prosciutto
Pomodori

Questo è il modo per rappresentare una lista in Python:

spesa = ["Uova", "Prosciutto", "Pomodori" ]

Abbiamo creato un elenco chiamato spesa   che contiene tre elementi. Python sa che è un elenco perché è racchiuso tra parentesi quadre ([  e ] ). Gli elementi nella lista sono separati da una virgola (, ) e in questo caso gli elementi sono tre stringhe di caratteri: “Uova”, “Prosciutto” e “Pomodori”. Sappiamo che sono stringhe di caratteri perché sono racchiusi tra virgolette .

Nota

I numeri non hanno bisogno di essere inseriti all’interno delle doppie virgolette, in quanto rappresentano un valore (piuttosto che una stringa di caratteri).

Quindi 2  senza virgolette rappresenta il valore numerico 2 mentre 2 tra virgolette “2”  rappresenta il carattere/cifra che rappresenta il numero 2.

È possibile memorizzare elementi di diverso tipo all’interno della stessa lista:

lista_mista = [“ciao!”, 1.234, Image.HAPPY]

Notate che l’ultimo elemento è un’immagine!

E’ possibile dire a MicroPython di animare un elenco di immagini. Fortunatamente sono disponibili un paio di elenchi di immagini già integrate, si chiamano Image.ALL_CLOCKS  e Image.ALL_ARROWS :

from microbit import *

display.show(Image.ALL_CLOCKS, loop=True, delay=100)

Verrà visualizzata una lancetta che girerà in senso orario, l’intervallo di accensione dei tre LED è di 100 millisecondi.

Come abbiamo visto per la visualizzazione di una sola immagine usiamo display.show  per mostrarlo sul display del micro:bit. Quando diciamo a MicroPython di usare Image.ALL_CLOCKS  ci verranno mostrate in sequenza tutte le immagini della lista, inoltre nell’istruzione con il parametro loop=True  indichiamo che la lista delle immagini deve scorrere per sempre e con l’argomento delay=100  indichiamo che ogni immagine deve essere visualizzata per 100 millisecondi (1/10 di secondo).

  • Avete capito come animare la lista Image.ALL_ARROWS  ?
  • Come si evita il loop infinito?
    (suggerimento: l’opposto di True  è False  sebbene il valore predefinito per loop sia False )
  • Potete cambiare la velocità dell’animazione?

Vediamo come creare un’animazione di un’esplosione di luci, una sequenza che parte con l’accensione del LED centrale per espandersi verso il perimetro con differenti intensità luminose dei LED

from microbit import *

luce1 = Image("00000:"
"00000:"
"00900:"
"00000:"
"00000")

luce2 = Image("00000:"
"09990:"
"09590:"
"09990:"
"00000")

luce3 = Image("00000:"
"05550:"
"05350:"
"05550:"
"00000")

luce4 = Image("09590:"
"93339:"
"93039:"
"93339:"
"09590")

luce5 = Image("03330:"
"30003:"
"30003:"
"30003:"
"03330")

luce6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

luci = [luce1, luce2, luce3, luce4, luce5, luce6]
display.show(luci, delay=200)

 

Questo è il modo con cui funziona il programma:

  • creiamo sei immagini luce  nello stesso modo descritto sopra.
  • Poi le inseriamo tutte in una lista chiamata luci .
  • Infine chiedo a display.show  di animare la lista con un ritardo di 200 millisecondi.
  • Poiché non abbiamo impostato loop=True  vedremo l’animazione una sola volta.

Proviamo ora a creare una sequenza che si ripete ciclicamente, in questo caso sarà sufficiente inserire il codice all’interno di un blocco while

from microbit import *

ritardo=100

luce1 = Image("00000:"
"00000:"
"00900:"
"00000:"
"00000")

luce2 = Image("00000:"
"09990:"
"09590:"
"09990:"
"00000")

luce3 = Image("00000:"
"05550:"
"05350:"
"05550:"
"00000")

luce4 = Image("09590:"
"93339:"
"93039:"
"93339:"
"09590")

luce5 = Image("03330:"
"30003:"
"30003:"
"30003:"
"03330")

luce6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

luci = [luce1, luce2, luce3, luce4, luce5, luce6]

while True:
    display.show(luci, delay=ritardo)

Come si nota è stato inserito all’interno di un loop infinito: while True  l’istruzione display.show(luci, delay=ritardo) . Rispetto alla versione precedente è stata anche parametrizzato il valore del delay , inserito come parametro ritardo  all’inizio del codice, ciò permetterà di variare ad inizio programma la velocità con cui apparirà la sequenza delle sei immagini.

L’esempio riportato sopra ripeterà ad ogni ciclo la sequenza delle immagini da luce1  a luce6 , nel caso in cui si voglia dare un’effetto di ribalzo sarà sufficiente creare due collezioni luciA  e luciB  i cui la sequenza delle immagini è invertita:

from microbit import *

ritardo=100

luce1 = Image("00000:"
"00000:"
"00900:"
"00000:"
"00000")

luce2 = Image("00000:"
"09990:"
"09590:"
"09990:"
"00000")

luce3 = Image("00000:"
"05550:"
"05350:"
"05550:"
"00000")

luce4 = Image("09590:"
"93339:"
"93039:"
"93339:"
"09590")

luce5 = Image("03330:"
"30003:"
"30003:"
"30003:"
"03330")

luce6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

luciA = [luce1, luce2, luce3, luce4, luce5, luce6]
luciB = [luce6, luce5, luce4, luce3, luce2, luce1]

while True:
    display.show(luciA, delay=ritardo)
    display.show(luciB, delay=ritardo)

Per avere una struttura compatta del codice, così come mostrato in precedenza, il codice può essere scritto in questo modo:

from microbit import *

ritardo=100

luce1 = Image("00000:00000:00900:00000:00000")
luce2 = Image("00000:09990:09590:09990:00000")
luce3 = Image("00000:05550:05350:05550:00000")
luce4 = Image("09590:93339:93039:93339:09590")
luce5 = Image("03330:30003:30003:30003:03330")
luce6 = Image("00000:00000:00000:00000:00000")

luciA = [luce1, luce2, luce3, luce4, luce5, luce6]
luciB = [luce6, luce5, luce4, luce3, luce2, luce1]

while True:
    display.show(luciA, delay=ritardo)
    display.show(luciB, delay=ritardo)

Buon Coding a tutti 🙂

L’ITIS Pininfarina alla 6° edizione del Festival dell’Innovazione e della Scienza.

L’edizione del Festival dell’Innovazione e della Scienza, che si svolge dal 14 al 21 di ottobre ha come focus: “pensa alla salute”.

Il calendario ricco ed articolato testimonia come la rassegna sia ormai diventata una delle più importanti del territorio nazionale a livello di divulgazione scientifica. Il record di presenze dello scorso anno testimonia come il Festival sia un vero e proprio motore di promozione del territorio. L’edizione 2018 consolida e rafforza le collaborazioni strette in area metropolitana rendendo protagonisti del Festival i comuni di Torino, Caselle Torinese, Castiglione Torinese, Collegno, Grugliasco, Leinì, Moncalieri, Nichelino, Rivoli e San Mauro Torinese.
Dal 14 al 21 ottobre, nella città di Settimo Torinese e nei principali luoghi di aggregazione culturale degli altri comuni coinvolti andrà in scena un programma ricchissimo di incontri, caffè scientifici, eventi, exhibit e laboratori finalizzati ad affrontare e valorizzare a tutto tondo le tematiche e i trend più attuali relativi al tema della salute. Dal corpo all’ambiente, dall’alimentazione alla medicina senza dimenticare lo sport, la prevenzione e il benessere della persona.

Anche quest’anno l’ITIS Pininfarina parteciperà al festival nella giornata del 20 di ottobre con attività condotte da un gruppo di allievi di ogni specializzazione dell’istituto che saranno tutor per gli studenti di scuola media.
Io e l’amico Stefano Mercurio abbiamo la fortuna di essere gli insegnanti degli studenti del Pininfarina e coordineremo le attività.

I laboratori svolti dai nostri studenti metteranno in evidenza come la scuola possa diventare un laboratorio aperto, in cui la creatività dei singoli allievi possa esprimersi, un luogo in cui l’aggregazione e il vivere bene insieme favorisce l’apprendimento e la voglia di essere cittadini attivi.

Luogo

BIBLIOTECA ARCHIMEDE
Piazza Campidoglio 50

Settimo Torinese

Il programma

Due attività di Coding

Attività 1

Mattina dalle 10 alle 12
Titolo: Arduino primi circuiti
Descrizione: Gli studenti insegnano ai bambini a realizzare semplici circuiti con Arduino

Attività 2

Pomeriggio dalle 14 alle 16,30
Titolo: Coding a scuola con BBC micro:bit
Descrizione: Attività di Coding e Making con BBC micro:bit, un piccolo computer (4×5 cm), la piattaforma è ideale per lo sviluppo di attività di Coding con forte interazioni con il mondo reale.

All’interno dell’attività 2 sono previste due azioni

Attività 1: Coding con micro:bit e gare robotiche di caccia al tesore e sumo.
Attività 2: Montaggio ed esposizione di robot e sistemi di automazione realizzati con Arduino. Gare robotiche sumo.

La partecipazione  è gratuita ed è possibile prenotarsi fino ad esaurimento posti attraverso il form allegato.

Vi aspettiamo 🙂

MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 2

MicroPython è in grado di gestire la griglia di LED 5×5 (LED: light emitting diodes le lucine che si accendono sulla parte anteriore della scheda), inoltre permette il controllo sul display per creare una serie di effetti interessanti.

MicroPython è dotato di molte immagini incorporate che possono essere mostrate sul display. Ad esempio per mostrare un viso felice sul display potete digitare:

from microbit import *
display.show(Image.HAPPY)

Sicuramente ricorderete dalla lezione precedente cosa fa la prima linea. La seconda riga utilizza l’oggetto display  con il metodo show  per visualizzazione l’immagine incorporata di un viso felice chiamata HAPPY. Ciò che vogliamo mostrare è inserito tra parentesi tonde: ((  e ) ).

Ciò che segue è una lista di immagini incorporate all’interno di MicroPython che potete utilizzare all’interno dei vostri programmi:

Image.HEART
Image.HEART_SMALL
Image.HAPPY
Image.SMILE
Image.SAD
Image.CONFUSED
Image.ANGRY
Image.ASLEEP
Image.SURPRISED
Image.SILLY
Image.FABULOUS
Image.MEH
Image.YES
Image.NO
Image.CLOCK12, Image.CLOCK11, Image.CLOCK10, Image.CLOCK9, Image.CLOCK8, Image.CLOCK7, Image.CLOCK6, Image.CLOCK5, Image.CLOCK4, Image.CLOCK3, Image.CLOCK2, Image.CLOCK1
Image.ARROW_N, Image.ARROW_NE, Image.ARROW_E, Image.ARROW_SE, Image.ARROW_S, Image.ARROW_SW, Image.ARROW_W, Image.ARROW_NW
Image.TRIANGLE
Image.TRIANGLE_LEFT
Image.CHESSBOARD
Image.DIAMOND
Image.DIAMOND_SMALL
Image.SQUARE
Image.SQUARE_SMALL
Image.RABBIT
Image.COW
Image.MUSIC_CROTCHET
Image.MUSIC_QUAVER
Image.MUSIC_QUAVERS
Image.PITCHFORK
Image.XMAS
Image.PACMAN
Image.TARGET
Image.TSHIRT
Image.ROLLERSKATE
Image.DUCK
Image.HOUSE
Image.TORTOISE
Image.BUTTERFLY
Image.STICKFIGURE
Image.GHOST
Image.SWORD
Image.GIRAFFE
Image.SKULL
Image.UMBRELLA
Image.SNAKE

Sono tantissime! Provate a modificare il codice che visualizza un viso felice, è sufficiente sostituire Image.HAPPY  con una delle immagini incorporate nell’elenco sopra indicato.

 Gestire i pixel

Potete impostare la luminosità di uno specifico LED sul display utilizzando il metodo set_pixel :

from microbit import *

display.set_pixel(1,2,9)

Ricordando che la coordinata 0, 0 specifica il LED che si trova in alto a sinistra, l’istruzione indicata nel codice sopra, imposta il LED in colonna 1 e riga 2  con luminosità 9 . La luminosità può assumere un valore compreso tra 0 e 9, con 0 indichiamo spegnimento del LED e 9 massima luminosità del LED.

Allo stesso modo nel caso in cui desiderate accendere alla massima luminosità il LED che si trova in basso a sinistra, l’istruzione da utilizzare sarà:

from microbit import *

display.set_pixel(0,4,9)

Per l’accensione del LED che si trova in alto a sinistra:

from microbit import *

display.set_pixel(0,0,9)

Vediamo ora come accendere tutti i LED alla massima luminosità:

Potete utilizzare un ciclo for , così come indicato nel programma che segue:

from microbit import *

display.clear()
for x in range(0, 5):
    for y in range(0, 5):
        display.set_pixel(x,y,9)

Il ciclo for  esegue le istruzioni in esso contenuto per un numero di volte specificato, nel nostro caso nell’intervallo da   0   a 5, questa operazione viene eseguita con la funzione  range(0,5)  che restituisce la lista di interi da 0   a 4  escludendo il massimo, in questo caso il valore 5:

for x in range(0,5)

il ciclo for  sarà eseguito 5 volte, ogni volta la variabile x sarà sostituita dai valori che vanno   0   a 4  (5 valori). Si uscirà dal loop quando sarà raggiunto il valore finale dell’intervallo.

All’interno del primo for  troviamo un secondo ciclo:

for y in range(0,5):

Anche in questo caso il ciclo sarà eseguito 5 volte e la variabile y  sarà sostituita dai 5 valori da 0   a 4  . Si uscirà dal loop quando sarà raggiunto il valore finale dell’intervallo.

Vediamo ora come accendere e spegnere l’intera matrice di LED:

from microbit import *

# accensione e spegnimento di tutta la matrice di led
# dall'alto verso il basso partendo dal LED in alto a sinistra
# di coordinate (0, 0)

display.clear()
for x in range(0, 5):
    for y in range(0, 5):
        display.set_pixel(x,y,9)
        sleep(100)
for x in range(0,5):
    for y in range(0, 5):
        display.set_pixel(x,y,0)
        sleep(100)

Si noti che l’azione di spegnimento è simile a quella dell’accensione dove l’unica differenza risiede nell’istruzione: display.set_pixel(x,y,0) in cui impostiamo la luminosità a 0  .

Vediamo ora come effettuare l’accensione del display partendo dal LED situato in basso a destra alle coordinate (5, 5):

from microbit import *

# accensione e spegnimento dei LED partendo in modo orizzontale
# dal LED in posizione (5, 5) spostandosi per righe
# da destra verso sinistra

# Poiche' la funzione range restituisce una serie di valori da un
# valore minimo a un valore massimo per effettuare un decremento
# dell'indice si utilizzano le operazioni: y=4-y e x=4-x

display.clear()

for y in range(0, 5):
    y=4-y
    for x in range(0, 5):
        x=4-x
        display.set_pixel(x,y,9)
        sleep(100)

for y in range(0, 5):
    y=4-y
    for x in range(0, 5):
        x=4-x
        display.set_pixel(x,y,0)
        sleep(100)

display.clear()

Poichè la funzione range restituisce una serie di valori da un valore minimo a un valore massimo, per effettuare un decremento dell’indice si utilizzano le operazioni: y=4-y e x=4-x

Vedremo nella lezione successiva come realizzare dei cicli infiniti per realizzare giochi di luce accendendo e spegnendo i LED in modo sequenziale.

Creiamo le nostre immagini

Volete creare un’immagine personalizzata da visualizzare sul display del micro:bit?
E’ molto semplice.

La luminosità di ogni LED sul display, così come detto ad inizio lezione, può essere impostata con un valore da spento  ( 0 )  a luminosità massima  (9).

from microbit import *

luce = Image("09590:"
             "93339:"
             "93039:"
             "93339:"
             "09590")

display.show(luce)

Quando il programma è in esecuzione il dispositivo visualizza un’immagine circolare con i LED con diversa intensità luminosa:

Sicuramente avrete notato che ogni riga del display fisico è rappresentato da una linea di numeri che terminano con :  il tutto racchiuso tra doppie virgolette

Ogni numero rappresenta la luminosità del LED a cui fa riferimento, quindi potrete specificare la luminosità per ogni LED.

Tutto molto semplice! 🙂

In realtà, non è necessario scrivere su più righe il comando per l’accensione dei LED, potete scrivere tutto su una linea sola:

luce = Image(“09590:93339:93039:93339:09590”)

Buon Coding a tutti 🙂

Esperienza di laboratorio: verifica della tabella di verità del Flip Flop SR (Set-Reset) con integrato 7402 ed Arduino

Il più semplice circuito digitale di memoria è il flip-flop Set-Reset. Esso è costituito da due ingressi identificati con il nome Set e Reset ed una uscita indicata con .
Accade spesso che i flip flop sono dotati, anche dell’uscita .

In un dispositivo di memoria l’uscita dipende:

  • dalla particolare combinazione che assumono le variabili di ingresso
  • dallo stato precedente assunto dall’uscita Q.

Lo stato precedente dell’uscita lo indichiamo con .

Flip-flop SR con porte NOR

Il simbolo logico, la tabella della verità e la soluzione circuitale a porte logiche NOR di un flip-flop S-R sono indicate nell’immagine che segue:

Combinazioni

Combinazione SR=00

Combinazione di riposo in quanto l’uscita conserva lo stato precedente (Q=Qo).

Combinazione SR=01

Posto R=1, l’uscita Q si porta a 0 indipendentemente dallo stato precedente.

Combinazione SR=10

Posto S=1, l’uscita Q si porta a 1 indipendentemente dallo stato precedente.

Combinazione SR=11

Questa combinazione è da evitare in quanto dal punto di vista logico risulta incongruente, non ha alcun senso comandare il flip-flop per memorizzare lo 0 (R=1) oppure l’1 (S=1).

Modalità di memorizzazione di 1 bit

Per memorizzare 1:

  • Passo 1: impostare S=1 e R=0.
  • Passo 2: impostare lo stato di riposo: S=0 e R=0.

l’uscita conserva lo stato precedente: Q=Qo=1

Per memorizzare 0:

  • Passo 1: S=0 e R=1.
  • Passo 2: impostare lo stato di riposo: S=0 e R=0.

l’uscita conserva lo stato precedente: Q=Qo=0


Ripasso sul funzionamento della porta NOR

L’operazione può essere effettuata su due o più variabili di ingresso. Se chiamiamo con A e B le variabili di ingresso e con Y la variabile di uscita, la somma logica negata assumerà lo stato logico 1 solo se tutte le variabili di ingresso sono allo stato 1, in tutti gli altri casi l’uscita assumerà il valore 1.

La somma logica negata corrisponde al collegamento di una OR seguita da una porta NOT.

si legge A NOR B

Nella figura che segue è mostrata la tabella della verità con le quattro possibili combinazioni delle variabili di ingresso A e B è il simbolo logico corrispondente. Nella colonna Y sono indicati i valori della variabile di uscita Y che soddisfa la definizione della porta logica NOR.


Verifica funzionamento come Flip-Flop S-R

Passo 1

Impostare S=0 e R=1.

L’uscita Q=0, infatti l’uscita Q della porta 2 va a 0 perché l’ingresso R=1.

Su tutti e due gli ingressi della porta 1 abbiamo 0 per cui la sua uscita va ad 1.
Dovreste aver notato che le due uscite sono complementari tra loro.

Passo 2

Impostare la combinazione di riposo: R=0 e S=0.

L’uscita Q nella fase precedente era stata portata a 0 (Qo=0), l’uscita della porta 1 resta ad 1 come conseguenza l’uscita della porta 2 rimane a 0 (Q=0).

Passo 3

Impostare S=1 e R=0.

L’uscita della porta 1 va a 0 come conseguenza, poiché R=0, l’uscita della porta 2 commuta ad 1: Q=1.

Passo 4

Impostare la combinazione di riposo: R=0 e S=0.

L’uscita Q nella fase precedente era stata portata a 1 (Qo=1), l’uscita della porta 1 resta a 0 come conseguenza l’uscita della porta 2 rimane a 1 (Q=1).

Passo 5

Impostare S=1 e R=1 (combinazione proibita)

Le uscite di entrambe le porte NOR commuteranno a 0.
In questo caso, le due uscite non saranno più complementari tra loro.
Inoltre se impostate contemporaneamente R=0 e S=0 entrambe le uscite si porteranno ad 1 e poi a 0 e così via.

Accadrà inoltre che per i diversi tempi di ritardo di propagazione del segnale elettrico in ciascuna porta, uno delle due porte NOR propagherà l’1 in uscita prima dell’altra porta.

Diventa aleatorio il valore dell’uscita Q che, pertanto, potrà trovarsi a 0 oppure a 1. Anche per questo motivo è da evitare la combinazione della tabella della verità: S=1 e R=1.


Fase 1: Verifica tabella di verità del Flip-Flop SR con integrato 7402

Realizzare il circuito e verificare la tabella di verità del Flip-Flop SR.

Lista componenti:

  • IC 7402 (Quad 2 Input NOR)
  • N. 2 R: 10 KOhm
  • N. 2 R: 180 Ohm
  • N. 1 LED Rosso
  • N. 1 LED Verde
  • N 2. Switch

Schema elettrico

Schema di montaggio

Pinout 7402


Fase 2: Realizzare un simulatore di Flip-Flop SR con Arduino

Dato lo sketch Arduino che segue, non commentato, comprenderne il funzionamento, commentare ogni parte e derivare il circuito elettronico di montaggio.

Fasi operative:

  • realizzare lo schema di montaggio in Fritzing;
  • realizzazione pratica del circuito;
  • verifica del funzionamento del circuito;
  • segnalare eventuali correzioni/miglioramenti da effettuare allo sketch.
int pinQ = 10;
int pinQneg = 9;
int pinSet = 8;
int pinReset = 7;

int pinLedSet = 5;
int pinLedReset = 4;

int statoOutNorReset = 0;
int statoOutNorSet = 0;

int statoOutNorResetSuc = 0;
int statoOutNorSetSuc = 0;

boolean statoQ = 0;
boolean statoQneg = 0;
  
void setup()
{
  pinMode(pinSet, INPUT);
  pinMode(pinReset, INPUT);

  pinMode(pinQ, OUTPUT);
  pinMode(pinQneg, OUTPUT);

  pinMode(pinLedSet, OUTPUT);
  pinMode(pinLedReset, OUTPUT);
}

void loop()
{
  boolean statoSet = digitalRead(pinSet);
  boolean statoReset = digitalRead(pinReset);

  if (statoSet == 1) {
    digitalWrite(pinLedSet, HIGH);
  } else {
    digitalWrite(pinLedSet, LOW);
  }

  if (statoReset == 1) {
    digitalWrite(pinLedReset, HIGH);
  } else {
    digitalWrite(pinLedReset, LOW);
  }

  statoOutNorSet = statoQneg;
  statoOutNorReset = statoQ;
  
  statoOutNorResetSuc = !(statoReset || statoOutNorSet);
  statoOutNorSetSuc = !(statoSet || statoOutNorReset);
  
  digitalWrite(pinQ, statoOutNorReset);
  digitalWrite(pinQneg, statoOutNorSet);

  statoQneg = statoOutNorSetSuc;
  statoQ = statoOutNorResetSuc;
}

Si ricorda è obbligatorio:

  • inserire un’intestazione come indicato nell’immagine che segue, in cui indicare:
    • Cognome e Nome
    • Classe
    • Esercizio/Sommario funzionamento
  • tutto il codice deve essere commentato;
  • tutto il codice deve essere correttamente indentato;
  • ogni allievo dovrà utilizzare 1 singola scheda Arduino;
  • il codice dovrà essere consegnato al docente su Google Classroom secondo le indicazioni date a lezione.

Buon lavoro 🙂