Progettare una nuova scuola – Corso gratuito on-line – Corso n. 2 – videolezione e ambienti di apprendimento

Come già segnalato in un precedente post, ho collaborato con Tecnica della Scuola al progetto: Progettare una nuova scuola, corsi di formazione a cui è possibile iscriversi gratuitamente. Il mio contributo copre aspetti di carattere tecnologico ed ho il piacere di informarvi che da qualche giorno potete iscrivervi al corso:

video lezione e ambienti di apprendimento

Il corso si propone di mostrare come configurare e gestire ambienti di apprendimento integrati on line per potenziare la didattica digitale a distanza e integrata. Ciò consente di realizzare dinamiche di lavoro collaborative, altamente inclusive permettendo il monitoraggio e la valutazione a distanza sulla classe o sul singolo allievo.
Il corso contiene anche situazioni didattiche reali gestite con le tecnologie esposte, mostrando tutto il processo di lavoro: dalla creazione della classe online alla realizzazione di videolezioni in modalità sincrona o asincrona, in particolare si forniscono le nozioni tecniche e le competenze per un’operatività avanzata nell’uso di software per la produzione di videolezioni, sistemi per il montaggio audio e video, scelte tecnologiche: microfoni, webcam, luci.

Per maggiori informazioni vi rimando alla pagina dedicata.

Ringrazio di cuore tutte le persone che stanno partecipando, sono tantissimi gli iscritti sia al primo che al secondo corso e preannuncio che sono in procinto di preparare nuovi corsi per i prossimi mesi, che rispondono a molte delle esigenze che negli scorsi mesi mi avete comunicato. L’ultimo corso: produrre e gestire contenuti online verrà pubblicato nel breve.

Grazie 🙂

Pubblicato in corsi | Contrassegnato , , , , | Lascia un commento

Arduino: cicli infiniti ed uscita da un ciclo infinito

Per rispondere ad un quesito che mi è stato posto questa mattina a lezione da alcuni allievi condivido questo breve approfondimento sulla gestione dei cicli infiniti.

Parliamo di un ciclo infinito quando il controllo entra nel corpo del ciclo e non esce mai da esso, ciò accade quando la condizione di test del loop non è mai false.

Possiamo realizzare un ciclo infinito in C in diversi modi:

for (int i = 0; i >= 0; )
{
    // corpo del ciclo in cui la variabile i non viene mai modificata
}

Nell’esempio la variabile i viene inizializzata a 0 e la condizione di controllo i>=0 all’inizio è vera. La variabile i non viene modificato in nessun punto del codice inoltre l’espressione di aggiornamento della variabile non è presente, ciò implica che i avrà sempre come valore 0 e la condizione di controllo i>=0 non è mai falsa e quindi il corpo del for viene eseguito ad ogni ciclo.

Un modo più sintetico per realizzare un ciclo infinito è quello di utilizzare una condizione sempre vera utilizzando l’istruzione while:

while (true)
{
    // corpo del while
}

Questo comportamento può essere realizzato anche scrivendo 1 per indicare “condizione sempre vera”.

while (1)
{
    // corpo del while ripetuto per sempre
}

o ancora utilizzando un’uguaglianza sempre vera:

while (3==3)
{
    // corpo del while ripetuto per sempre
}

che nella programmazione con Arduino può essere ottenuto anche con:

while (HIGH)
{
    // corpo del while ripetuto per sempre
}

E’ possibile realizzare un ciclo infinito anche con l’istruzione for omettendo la condizione di ripetizione del ciclo, cioè che bisognerebbe inserire tra i due punti e virgola.

for (;;)
{
    // corpo del for ripetuto per sempre
}

Terminare un ciclo infinito

Negli esempi visti precedentemente la condizione sempre vera causava la ripetizione infinita del corpo dell’istruzione, però esiste il modo per terminare un ciclo infinito utilizzando l’istruzione break usata appunto per uscire da un ciclo: for, while oppure do..while, ma anche per uscire da una istruzione switch case.

Poiché nelle nostre sperimentazioni utilizziamo Arduino vediamo come realizzare l’uscita da un loop infinito.

Lo scopo è quello di far lampeggiare ripetutamente un LED e bloccare il lampeggio con la pressione di un pulsante.

Realizzimo il seguente circuito:

Utilizzando l’istruzione while.

Esempio 1

/*
  Prof. Michele Maffucci
  Data: 16.11.2020
  Esempio1: Funzionamento dell'istruzione break
*/
const int pinPulsante = 8; // pin digitale 8

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT); // abilita il pin a cui è connesso il LED come output
  pinMode(pinPulsante, INPUT);  // abilita il pin a cui è connesso il pulsante come input
}
void loop()
{
  while (true) // ciclo infinito
  {
    if (digitalRead(pinPulsante) == HIGH)
    {
      break; // esce dal ciclo se si preme il pulsante
    }
    lampeggio(); // chiama la funzione che accende e spegne il LED
  }
}
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
}

Come si può notare viene utilizzata l’istruzione break per uscire dal ciclo. Fino a quando il pulsante non sarà premuto la condizione: digitalRead(pinPulsante) == HIGH sarà falsa, pertanto non verrà eseguito il corpo dell’if e quindi non potrà essere eseguito il break, in questa condizione ciò che segue l’if è la chiamata della funzione lampeggia().

Nel caso in cui il pulsante viene premuto, la condizione digitalRead(pinPulsante) == HIGH risulta vera, pertanto viene eseguito il corpo dell’if che contiene l’istruzione break che causerà l’uscita dal ciclo while.

Il codice sopra indicato funziona anche se nel while viene sostituito true con HIGH:

...
while (true) // ciclo infinito
  {
       // corpo del while
  }
...

con

...
while (HIGH) // ciclo infinito
  {
       // corpo del while
  }
...

Come spiegato ad inizio lezione, un ciclo infinito può essere ottenuto anche con un’istruzione for quindi si ottiene il medesimo risultato se si utilizza il codice che segue.

Esempio 2

/*
  Prof. Michele Maffucci
  Data: 16.11.2020
  Funzionamento dell'istruzione break
*/
const int pinPulsante = 8; // pin digitale 8

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT); // abilita il pin a cui è connesso il LED come output
  pinMode(pinPulsante, INPUT);  // abilita il pin a cui è connesso il pulsante come input
}
void loop()
{
  for (;;) // ciclo infinito
  {
    if (digitalRead(pinPulsante) == HIGH)
    {
      break; // esce dal ciclo se si preme il pulsante
    }
    lampeggio(); // chiama la funzione che accende e spegne il LED
  }
}
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
}

Differenze tra ciclo for e ciclo while

  • Il ciclo for ha necessità di una variabile al suo interno, mente il ciclo while può utilizzare qualsiasi variabile definita prima dell’istruzione while.
  • L’uso del ciclo do-while permette di realizzare sempre una volta il corpo delle istruzioni in esso contenuto (indipendentemente dall’espressione condizionale) e ciò non può essere fatto con un  ciclo for.

Esercizio per i miei studenti

Esercizio 1

Realizzare le stesse funzionalità dell’esempio precedente (usando un ciclo infinito nel loop()) aggiungendo la stampa sequenziale crescente di un numero n = n + 1 sulla Serial Monitor. Alla pressione del pulsante si interrompe il lampeggio del LED e si azzera il contatore.

Buon Coding a tutti 🙂

Pubblicato in arduino, i miei allievi | Contrassegnato , , , | Lascia un commento

5 minuti da Maker: porta rasoio

Sulla mia pagina Facebook pubblico spesso alcuni brevi post che ho intitolato: 5 minuti da Maker, attività di Making familiare che risolvono qualche piccola necessità, che rispondono a piccole problemi del vivere quotidiano. E’ un esercizio che mi piace svolgere quando ho il bisogno di distrarmi un momento da un lavoro che mi stanca parecchio. L’idea nasce da una sperimentazione di qualche tempo fa che feci con alcuni allievi: una challenge di breve durata, non più di 30 minuti, in cui bisogna risolvere un problema pratico. Tipicamente si tratta di riparare o inventare un oggetto da stampare in 3D oppure riadattare oggetti per usi diversi o ancora migliorare le caratteristiche di un oggetto secondo le necessità specifiche dell’utente sia dal punto di vista meccanico che elettronico.

L’ultima challenge svolta su me stesso nasce dal seguente fatto:

Figlio: papà perché mi rubi le lamette da barba!
Io: No giovane figlio! Sei tu che rubi le MIE lamette!
Figlio: No no diversamente giovane! Sei tu tu tu tu tuuuuu!!!!
Moglie: forse essere più ordinati aiuterebbe? Visto che siete in bagno a chi tocca pulirlo oggi?
Io: Shhh Matty… pace pace pace …. ci penso io faccio due supporti per rasoio

🙂

Per prelevare i file per la stampa 3D seguire il link sulla mia pagina su Thingiverse.

Buon Making a tutti 🙂

Pubblicato in Stampa 3D | Contrassegnato , , | Lascia un commento

Arduino: strutturare il codice in blocchi funzionali

Molto spesso durante le prime fasi di realizzazione di uno sketch Arduino si tende a non strutturare il proprio programma in blocchi funzionali separati, tutto il codice viene inserito all’interno del loop(). Questo tipo di approccio, soprattutto se siamo in presenza di un codice molto lungo, rende difficoltosa la lettura del programma da parte di altre persone e non permette una facile comprensione del funzionamento o l’identificazione di possibili errori.

Ho parlato in passato come strutturare il codice in blocchi funzionali nel post:
Arduino – lezione 07: lavorare con gruppi di valori e funzioni esterne, ma in quella lezione utilizzavo istruzioni che in questa fase dell’anno scolastico non sono ancora conosciute da alcuni allievi soprattutto del 3′ anno, che iniziano ad utilizzare Arduino, pertanto la presente lezione dovrebbe chiarire in modo più semplice l’argomento.

Le funzioni vengono utilizzate per organizzare le azioni eseguite dal vostro programma. Ogni funzione può essere identificata da un’azione specifica richiamata dal programma principale loop(), oppure richiamate da altre funzioni sempre all’interno del nostro sketch.

Senza saperlo quando avete iniziato a programmare con Arduino avete utilizzato delle funzioni: loop() e setup() le due funzioni sempre presenti in ogni sketch.

Per creare una funzione bisogna:

  • definire il tipo di valore restituito dalla funzione;
  • assegnare un nome alla funzione;
  • e opzionalmente impostare una serie di parametri che la funzione riceverà quando viene chiamata (si dice anche invocata).

Creiamo una semplice funzione che permette di fare lampeggiare un LED, non possiede parametri e non restituisce nessun valore.
Assegnare alla funzione il tipo void vuol dire che non restituisce nulla e non inserire nulla tra le parentesi tonde indica che la funzione non accetta nessun parametro.

Esempio 1

// Prof. Michele Maffucci
// Es.01 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  lampeggia();
}

// blink LED una volta
void lampeggia()
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(1000); // pausa di 1 secondo
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(1000); // pausa di 1 secondo
}

Ogni volta che il loop() chiama (invoca) la funzione esterna lampeggia() viene effettuato il blink del LED sulla scheda.

Esempio 2

Realizziamo ora un secondo esempio in cui la funzione “lampeggia” accetta come parametro un valore intero che definisce il delay da impostare all’interno del funzione.

// Prof. Michele Maffucci
// Es.02 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  lampeggia(250);
}

// blink LED una volta
// per far si che la funzione accetti un parametro in input
// bisogna dichiarare il tipo del parametro in ingresso
// nella funzione lampeggia: int pausa

void lampeggia(int pausa)
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(pausa); // pausa: valore inserito nella variabile "pausa"
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(pausa); // pausa: valore inserito nella variabile "pausa"
}

Esempio 3

Realizziamo ora un terzo sketch in cui i parametri di ingresso per la funzione lampeggia() sono due, uno che definisce il tempo di accensione del LED ed uno che definisce il tempo di spegnimento del LED:

// Prof. Michele Maffucci
// Es.03 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  lampeggia(250, 1000);
}

// blink LED una volta
// per far si che la funzione accetti duen parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn e int pausaOff

void lampeggia(int pausaOn, int pausaOff)
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(pausaOn); // delay LED ON
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(pausaOff); // delay LED OFF
}

Esempio 4

Definiamo ora una funzione che ha 3 parametri di ingresso: il tempo in cui il LED rimane acceso, il tempo in cui il LED rimane spento e il numero di volte (cicli) che deve ripetersi il lampeggio, al termine del numero di cicli il LED non lampeggerà più. Come specificato nei commenti la variabile chiave verrà utilizzata per eseguire una volta sola la chiamata della funzione lampeggio:

// Prof. Michele Maffucci
// Es.04 - Usare le funzioni
// Data: 15.11.2020

// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  if (chiave == 0) {
    chiave = 1;
    lampeggia(250, 1000, 5);
  }
}

// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio

void lampeggia(int pausaOn, int pausaOff, int contatore)
{
  for (int i = 0; i < contatore; i++) {
    digitalWrite(LED_BUILTIN, HIGH); // accende il LED
    delay(pausaOn); // delay LED ON
    digitalWrite(LED_BUILTIN, LOW); // spegne il LED
    delay(pausaOff); // delay LED OFF
  }
}

All’interno dello sketch precedente la funzione lampeggio utilizza un ciclo for per ripetere, per il numero di volte specificato dalla variabile contatore, il codice di accensione e spegnimento (corpo del for).

Esempio 5

Per completezza e per richiamare il modo con cui utilizzare l’istruzione while, di seguito trovate lo sketch che realizza la medesima funzionalità dello sketch precedente in cui il ciclo for viene sostituito da un while:

// Prof. Michele Maffucci
// Es.05 - Usare le funzioni
// Data: 15.11.2020

// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  if (chiave == 0) {
    chiave = 1;
    lampeggia(250, 1000, 5);
  }
}

// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio

void lampeggia(int pausaOn, int pausaOff, int contatore)
{
  while (contatore > 0) {
     digitalWrite(LED_BUILTIN, HIGH); // accende il LED
    delay(pausaOn); // delay LED ON
    digitalWrite(LED_BUILTIN, LOW); // spegne il LED
    delay(pausaOff); // delay LED OFF
    contatore = contatore - 1; // decremento del contatore
  }
}

Esempio 6

Nello sketch che segue realizziamo una funzione che accetta un parametro e restituisce un valore. Il parametro che viene passato alla funzione definisce la durata dei tempi di accensione e spegnimento del LED (in millisecondi). La funzione continua a far lampeggiare un LED fino a quando non viene premuto un pulsante. Il valore restituito dalla funzione è il numero di lampeggi effettuati, questo valore verrà stampato sulla Serial Monitor:

// Prof. Michele Maffucci
// Es.06 - Usare le funzioni
// Data: 15.11.2020

const int pinPulsante = 8; // pin a cui colleghiamo il pulsante

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinPulsante, INPUT);
  Serial.begin(9600);
}

void loop() {
  Serial.println("Premere il pulsante per interrompere il lampeggio");
  int contatore = lampeggia(500); // lampeggio del LED: 500 ms ON e 500 ms OFF
  Serial.print("Il numero di volte in cui il LED ha lampeggiato è stato di: ");
  Serial.println(contatore);
  while (digitalRead(pinPulsante) == HIGH)
  {
    // non viene fatto nulla fino a quando non rilascio il pulsante
  }
}

// la funzione fa lampeggiare il LED per un periodo specificato (int periodo)
// e restituisce il numero di volte in cui il LED ha lampeggiato

int lampeggia(int periodo)
{
  int contatoreLampeggio = 0;

  while (digitalRead(pinPulsante) == LOW)
    // ripetere finché non viene premuto il pulsante
    // cicla fino a quando il pulsante non viene premuto
  {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(periodo);
    digitalWrite(LED_BUILTIN, LOW);
    delay(periodo);
    contatoreLampeggio = contatoreLampeggio + 1; // incrementa il contatore
  }
  // in questo punto vuol dire che pinPulsante è HIGH
  // ciò vuol dire che il pulsante è premuto

  // contatoreLampeggio è il valore che viene restituito alla funzione chiamante
  return contatoreLampeggio;
}

Il tipo di dato che precede in nome della funzione:

int lampeggia()

indica il tipo di dato restituito dalla funzione. Ricordarsi che nella funzione chiamante, nel nostro caso il loop(), quando chiamiamo la funzione questa deve terminare con un punto e virgola:

int contatore = lampeggia(500);

Errori comuni che vengono commessi nella chiamata di funzioni

Rimando a queste due brevi note che mostrano alcuni errori tipici:

Buon Making a tutti 🙂

Esercizi per i miei studenti

Esercizio 1

Realizzare un circuito costituito da 4 pulsanti e 4 led, connessi ad Arduino.

  • Alla pressione del pulsante P1 il LED1 effettua il blink con un tempo di 200 ms
  • Alla pressione del pulsante P2 il LED2 effettua il blink con un tempo di 400 ms
  • Alla pressione del pulsante P3 il LED3 effettua il blink con un tempo di 600 ms
  • Alla pressione del pulsante P4 il LED4 effettua il blink con un tempo di 800 ms

Fare in modo tale che ci sia una funzione esterna, chiamata dal loop(), che effettui il blink dei led.

Esercizio 2

Aggiungere all’esercizio 1 un pulsante che se premuto accende in sequenza ripetuta i 4 led. L’accensione in sequenza deve avvenire chiamando una funzione esterna al loop().

Pubblicato in arduino, i miei allievi | Contrassegnato , | Lascia un commento

Arduino: tipi di dati – ripasso

Noto che durante le sperimentazioni condotte dagli allievi, l’uso dei tipi di dati provoca alcune incertezze, pertanto ho pensato di aggiungere a quanto già pubblicato in passato, una tabella riepilogativa da prendere come riferimento durante le eseritazioni aggiungendo inoltre qualche precisazione. Noto che nella dichiarazione di variabili la scelta più comune del tipo di dato utilizzato è l’int (intero), però molto spesso può essere non necessario o addirittura può aggiungere imprecisioni o errori.

Sebbene il tipo di dati int (abbreviazione di intero) sia la scelta più comune per valori numerici incontrati nelle applicazioni Arduino, è possibile utilizzare le tabelle che segue per determinare il tipo di dati più opportuno, che si adatta all’intervallo di valori previsto dal vostro programma. La tabella mostra i tipi di dati per le schede a 8 bit come Arduino UNO R3.

Tipo di dato

Byte

Intervallo

Uso

int 2 –32768 a 32767 Rappresenta valori interi positivi e negativi.
unsigned int 2 0 a 65535 Rappresenta solo valori interi positivi.
long 4 –2147483648 a 2147483647 Rappresenta un intervallo di interi negativi e positivi molto più estesa rispetto agli int.
unsigned long 4 0 a 4294967295 Rappresenta solo valori interi positivi con intervallo più ampio degli unsigned int.
float 4 3.4028235E+38 a –3.4028235E+38 Rappresenta numeri con la virgola, da utilizzare per rappresentare e approssimare valori che giungono dal mondo reale.
double 4 Come i float In Arduino, double ha lo stesso utilizzo e significato di float, un sinonimo (ciò non è vero per schede a 32 bit).
bool 1 TRUE (1) o FALSE (0) Rappresenta valori veri o falsi.
char 1 –128 a 127 Rappresenta un singolo carattere. Può anche rappresentare un intero con segno compreso tra –128 e 127.
byte 1 0 a 255 Simile al tipo char, ma per valori senza segno.
String Rappresenta una sequenza di caratteri tipicamente utilizzata per contenere il una stringa di testo.
void Utilizzato solo nelle dichiarazioni di funzione in cui non viene restituito alcun valore.

In generale, come potete vedere anche negli sketch di esempio presenti nell’IDE di Arduino, gran parte delle variabli utilizzate è di tipo int, inoltre se non è richiesta la massima efficienza della memoria di Arduino l’uso di int non è un errore, ma ovviamente il tipo int può essere utilizzato solo se i valori che state gestendo non superano l’intervallo degli int e non è necessario lavorare con numeri decimali.

Certamente molto spesso è necessario utilizzare un tipo di dato specifico per la propria applicazione, ciò accade quando ad esempio utilizziamo specifiche funzioni di libreria che restituiscono valori che non appartengono all’intervallo del tipo int.

A scopo di esempio considerate la funzione millis che restituisce il numero di millisecondi trascorsi dall’avvio del programma.

unsigned long ora;

void setup() {
  // inizializzazione della erial Monitor
  Serial.begin(9600);
}
void loop() {
  Serial.print("Ora: ");
  ora = millis();

  Serial.println(ora); // stampa l'ora (in millisecondi) dall'avvio dello sketch
  delay(1000);         // attesa di un secono, viene utilizzato per non stampare
                       // velocemente una grande quantità di valori sulla Serial Monitor
}

Il tipo di valore restituito, come indicato nel reference, è un unsigned long valori compresi tra 0 e 4294967295.

Se usate un tipo int su una scheda a 8 bit per memorizzare un valore restituito da millis() non riceverete un messaggio di errore dal compilatore, ma verranno restituiti valori numerici sbagliati perché un int non è abbastanza grande da contenere il valore massimo di un unsigned long. Se provate a cambiare tipo nello sketch indicato sopra vedrete che dopo aver raggiunto il valore 32.767, il conteggio passerà a -32768.

Se invece provate a sostituire un long, –2147483648 a 2147483647 con un
unsigned int (intero senza segno) 0 a 65535, tornerete a zero dopo aver superato il massimo massimo (65535).

Alcune precisazioni

  • Durante le vostre sperimentazioni avrete bisogno a volte di valori con segno e a volte no, ecco perché sono stati resi disponibili tipi di dati con segno (signed) e senza segno (unsigned). I valori senza segno sono sempre positivi;
  • tutti i tipi che NON recano davanti la parola: unsigned possono assumere valori negativi e positivi;
  • una variabile senza segno (unsigned) può memorizzare il doppio dei valori numerici di una variabile con segno (signed);
  • nella notazione è esplicitato sempre quando la variabile è di tipo unsigned perché in questo modo viene reso evdente che quella variabile non assume valori negativi.

Dalla tabella si può notare che i tipi bool (booleani) hanno due possibili valori: vero o falso. Questo tipo di dato viene utilizzato in genere per memorizzare valori che rappresentano una condizione ON/OFF oppure in altro modo SI/NO.

Potresete vedere tipi booleani utilizzati al posto delle costanti HIGH e LOW utilizzati all’interno ad esempio di una digitalWrite() per impostare l’uscita di un pin digitale, qundi le scritture:

digitalWrite(pinLed,HIGH);
e
digitalWrite(pinLed,1);

digitalWrite(pinLed,LOW);
e
digitalWrite(pinLed,0);

Indicano la stessa cosa.

La stessa cosa accade per una digitalRead() nel caso in cui noi si debba leggere lo stato di un pin digitale. Potete qundi utilizzare true o false al posto di HIGH e LOW o ancora 1 o 0.

Esercizi per i miei studenti

Esercizio 1
Partendo dall’esempio indicato in questa lezione sulla stampa del valore restituito dalla funzione millis(), realizzare un programma che restituisca i valori di millis() memorizzati in tre variabili di tipo diverso:

unsigned long ora1;
int ora2;
unsigned int ora3;

stampare il valore delle tre variabili sulla Serial Monitor per dimostrare quanto affermato in questa lezione.

Esercizio 2
Realizzare le stese funzionalità dell’esercizio precedete aggiungendo un pulsante che se premuto azzera le tre variabili e fa ripartire (partendo da zero) la stampa sulla Serial Monitor.

Esercizio 3
Realizzare le stesse funzionalità dell’eserizio 2 aggiungendo 3 LED, ciascuno indicherà per un tempo di accensione di 10 secondi il superamento del limite del range del tipo di variabile a cui si riferisce es.:

LED1 -> ora1
LED2 -> ora2
LED3 -> ora3

Buon Making a tutti 🙂

Pubblicato in arduino, i miei allievi | Contrassegnato | Lascia un commento

Arduino: utilizzo del metodo parseInt() per la conversione di un stringa di testo che rappresenta un numero in un numero

Nel primo esercizio della lezione: Arduino: Stepper 28BYJ-48 – AccelStepper library veniva chiesto di impostare i parametri di azionamento del motore passo paso da Serial Monitor, questa operazione può essere svolta usando la classe toInt(), ma in modo più efficace e semplice possiamo usare la classe parseInt(). In questa breve lezione un esempio di controllo del lampeggio di un LED da Serial Monitor mediante l’uso di parseInt().

È possibile ricevere numeri con più di una cifra utilizzando i metodi parseInt e parseFloat che semplificano l’estrazione di valori numerici da seriale. (Funziona anche con Ethernet e altri oggetti derivati dalla classe Stream)

Serial.parseInt() e Serial.parseFloat() leggono i caratteri seriali e restituiscono la loro rappresentazione numerica.

I caratteri non numerici prima del numero vengono ignorati e il numero termina con il primo carattere che non è una cifra numerica (o “.” Se si utilizza parseFloat). Se non ci sono caratteri numerici nell’input, le funzioni restituiscono 0, quindi bisogna controllare i valori zero e gestirli in modo appropriato.

Se avete la Serial Monitor configurata per inviare una nuova riga o un ritorno a capo (o entrambi) quando fate clic su invia, parseInt o parseFloat proveranno ad interpretare il return come numero, ma poiché il ritorno a capo non è un numero il valore restituito da parseInt o parseFloat sarà zero.

Nell’esempio che segue un invio imposta blinkRitardo a zero il che implica che il LED non lampeggia.

// Prof. Maffucci Michele
// 10.11.2020
// Impostazione del delay del Blink da tastiera

int lampeggioRitardo = 0;
int chiave = 0;
void setup()
{
  Serial.begin(9600); // inizializzazione della serial monitor
  pinMode(LED_BUILTIN, OUTPUT); // imposta il pin come output
}
void loop()
{
  // ritardo per evitare una doppia scrittura
  // della prima stampa a monitor
  delay(1000);

  // consente di visualizzare sulla Serial Monitor
  // una sola stampa delle stringa
  if (chiave == 0) {
    Serial.print("Inserisci il ritardo in millisecondi: ");
    chiave = 1;
  }

  // Controlla se è disponibile almeno un carattere sulla seriale
  // La Serial.available() restituisce
  // 1 se presente un cattere,
  // 0 se non è presente un carattere
  
  if (Serial.available())
  {
    int r = Serial.parseInt(); // in r viene memorizzato il valore inserito in numero
    if (r != 0) {
      lampeggioRitardo = r;
      Serial.println(lampeggioRitardo);

      // abilita alla stampa di una nuova stringa:
      // "Inserisci il ritardo in millisecondi: "
      chiave = 0;
    }
  }
  lampeggio(); // funzione che fa lampeggiare il LED su Arduino
}

// il LED lampeggia con i tempi di
// accensione e spegnimento determinati da lampeggioRitardo
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(lampeggioRitardo); // il delay dipende dal valore in lampeggioRitardo
  digitalWrite(LED_BUILTIN, LOW);
  delay(lampeggioRitardo);
}

Esercizio 1
Dato un LED RGB connesso ad Arduino, realizzare un selettore che da Serial Monitor consente di controllare l’accensione e lo spegnimento del rosso, del verde e del blu

Esercizio 2
Svolgere l’esercizio 1 della lezione Stepper 28BYJ-48 – AccelStepper library usando la parseInt()

Pubblicato in arduino, elettronica, i miei allievi | Contrassegnato , , | Lascia un commento

Installare Raspberry Pi Desktop su VirtualBox

Questa Didattica Digitale Integrata ci costringe e favorisce modalità di attività di laboratorio assolutamente diverse, fare laboratorio senza poter toccare gli strumenti  è complicato, ma certamente ai ragazzi possono essere fornite competenze che risulteranno utilissimi nei mesi prossimi durante le attività laboratoriali in presenza, quando come si spera la situazione didattica ritornerà alla normalità. Ho la fortuna di avere nelle mie classi molti studenti in cui: “brilla la luce del maker” 🙂 e quindi molto disposti alla sperimentazione anche personale a casa. Alcuni mi condividono le registrazioni video delle loro sperimentazione o mi mostrano in presenza online i circuiti realizzati.

In questi giorni ho pensato di realizzare questo tutorial introduttivo, ritengo utile per chi non è pratico nell’uso di Raspberry Pi, ma soprattutto utile per i miei studenti che mi hanno espresso la volontà di realizzare a distanza un sistema domotico su Raspberry Pi. Prima di cominciare con l’acquisto dell’hardware, ritengo indispensabile conoscere il sistema operativo Raspberry Pi Desktop. La modalità più semplice per prendere subito dimestichezza con il sistema operativo è quella di utilizzare l’ambiente di virtualizzazione gratuito: VirtualBox su cui sperimentare.
Raspbian è un derivato del sistema operativo Debian. Sul sito ufficiale, raspberrypi.org è possibile prelevare l’ISO del sistema operativo che può essere installato su computer Mac e Windows. L’uso di Raspberry Pi Desktop mi ha permesso in passato di recuperare computer obsoleti permettendo a molti studenti di continuare ad utilizzare i loro vecchi PC.

Installare VirtualBox

Dal sito di riferimento di VirtualBox prelevate l’ultima versione per il vostro sistema operativo (Windows, Linux, Mac).

Nella cartella di download ritroverete l’installatore di VirtualBox, avviate l’installazione e seguite passo passo le fasi installazione. Le immagini che seguono mostrano esattamente la sequenza delle finestre mostrate in fase di installazione:

Passo 1
Doppio click sul file scaricato

Passo 2
clic su “Avanti”

Passo 3
Non effettuate nessuna modifica, clic su “Avanti”

Passo 4
Io ho lasciato tutte le impostazioni selezionate, decidete secondo le vostre necessità Continua a leggere

Pubblicato in i miei allievi, Raspberry Pi | Contrassegnato , , , , , | Lascia un commento

Arduino: Stepper 28BYJ-48 – AccelStepper library

La libreria Stepper Arduino è ottima per controllare un solo stepper, ma quando si desidera controllare velocità e accelerazione dello stepper oppure è necessario controllare contemporaneamente più stepper bisogna utilizzare la libreria AccelStepper.

In questo breve tutorial vedremo come controllare velocità e accelerazione ed in una successiva lezione controlleremo più stepper.

AccelStepper aggiunge le seguenti funzionalità:

  • accelerazione e decelerazione;
  • supporta il mezzo passo;
  • controllo di più stepper simultaneamente e simultaneamente si possono far fare passi indipendenti su ogni stepper.

AccelStepper non è inclusa nell’IDE di Arduino, bisognerà installarla.

Installazione della libreria

Per installare la libreria, andare in Sketch > Include Library > Manage Libraries…

Nel campo di ricerca inserire “AccelStepper”. Selezionare la prima voce che compare e procedere con l’installazione

Lo schema elettrico di collegamento è il medesimo visto nella lezione precedente, potete utilizzare entrambi gli schemi proposti, con alimentazione presa direttamente da Arduino o con alimentazione esterna che vi consiglio.

Codice Arduino

Di seguito lo sketch di esempio “Bounce”, che permette l’accelerazione del motore passo-passo in una direzione per decelerare e poi fermarsi. Trovate lo sketch “Bounce” tra gli esempi a corredo della libreria, su questo programma ho apportato alcune modifiche inserendo i commenti che ne spiegano il funzionamento.

// Bounce
// Prof. Maffucci Michele
//
// Una sola rotazione in accelerazione da 0 a 2048 e viceversa

// inclusione della libreria AccelStepper
#include <AccelStepper.h>

// definizione di una costante
// funzionamento:
// in fullstep  impostare 4
// in halfstemp impostare 8
#define FULLSTEP 4

// creazione dell'istanza della classe mioStepper
/*
   IN1 -> 8
   IN2 -> 9
   IN3 -> 10
   IN4 -> 11
*/
AccelStepper mioStepper(FULLSTEP, 8, 10, 9, 11);

void setup() {

  // impostare la velocità massima,
  // accelerazione,
  // velocità iniziale
  // numero di passi da compiere

  mioStepper.setMaxSpeed(1000);
  mioStepper.setAcceleration(50);
  mioStepper.setSpeed(100);
  mioStepper.moveTo(2048);
}

void loop()
{

  // distanceToGo restituisce il numero di passi compiuti.
  // Se distanceToGo raggiunge lo zero, cioè numero di passi è uguale a zero
  // inverte il senso di rotazione assegnando un valore negativo al numero di passi
  // da compiere.

  if (mioStepper.distanceToGo() == 0)
    mioStepper.moveTo(-mioStepper.currentPosition());

  // se non è stato raggiunto il valore zero, muove lo stepper di un passo
  mioStepper.run();
}

Per maggiori informazioni vi rimando alla pagina di riferimento della libreria

Esercizi per i miei studenti

Esercizio 1
Realizzare uno sketch che da serial monitor permetta all’avvio di Arduino l’impostazione di:

  • velocità massima;
  • accelerazione;
  • velocità iniziale;
  • numero di passi da compiere;

Con l’inserimento dell’ultimo parametro ed il successivo invio si avvia lo stepper.

Esercizio 2
Eseguire le stesse funzionalità dell’esercizio precedente, ma l’avvio dello Stepper avviene solamente alla pressione di un pulsante.

Esercizio 3
Aggiungere all’esercizio precedente un pulsante di stop che permetta di interrompe in qualsiasi momento la rotazione dello stepper.

Pubblicato in arduino | Contrassegnato , , , , | Lascia un commento

Modificare un motore passo passo 28BYJ-48 da unipolare a bipolare

Scrivo questo breve tutorial perché in questi giorni sto progettando i prototipi delle attività didattiche che spero potranno essere realizzati dai miei studenti nel mese di febbraio prossimo durante le attività di PCTO. Tra le future attività la realizzazione di più bracci robot da controllare con Arduino e PLC Siemens. Il braccio robot che sto realizzando è costituito da 3 motori passo passo 28BYJ-48 ed un servomotore. La scelta del 28BYJ-48 rispetto ai più potenti NEMA 17 risiede semplicemente nei costi di realizzazione per me e i miei studenti che vorranno replicare il progetto.

Poiché ho l’esigenza di aumentare il numero di grammi al centimetro che possono essere spostati/sollevati dal braccio ho convertito il passo passo 28BYJ-48 da unipolare a bipolare.

Questo motore passo passo è molto piccolo ma ha una potenza sufficiente per realizzare diverse sperimentazioni. Nello scorso anno scolastico, sempre durante le attività di PCTO, alcuni miei studenti hanno sviluppato l’automazione di un’ascensore la cui struttura portante era da me stata realizzata e tagliata a laser, mente i ragazzi si sono occupati dell’assemblaggio delle parti e della programmazione.

Il 28BYJ-48, come detto nel mio precedente post, è disponibile in due versione, con alimentazione a 5V e a 12V, le due versioni sono identiche, differiscono ovviamente per l’impedenza interna. In questo breve tutorial userò la versione a 12V, ma la procedura è la medesima per la versione a 5V.

Il motore passo passo possiede un riduttore incorporato da 1/64 ciò implica un passo molto piccolo del motore 0,087890625 gradi per passo. Il riduttore ha però un aspetto negativo, ne riduce la velocità di rotazione, ma possiamo sopportare questa sua lentezza considerando il fatto che il prezzo dei questo motore è estremamente contenuto, la versione a 5V può essere acquistata online a non più di 2,5 € e quindi per piccole sperimentazioni è più che sufficiente.

In funzione della modo con cui viene pilotato questo passo passo può raggiungere i 300 gcm in half step, per raggiunge i 380 gcm quando si passa a full step.

Gli stepper bipolari sono più efficienti di quelli unipolari in essi viene alimentata una sola bobina per volta (1/2 una bobina per essere precisi) mentre per i bipolare entrambe le bobine sono alimentate, quindi si ottiene una coppia maggiore.

L’immagine di seguito mostra ciò che accade in un passo passo bipolare.

Sono presenti due avvolgimenti anziché quattro rispetto ad uno stepper unipolare. Entrambi gli avvolgimenti possono essere attivi in qualsiasi momento ma la polarità viene commutata su quattro fasi, ciò vuol dire che questo motore ha solo quattro fili anziché 5 (o 6 o 8).

Per convertire un 28BYJ-48 da unipolare a bipolare bisogna interrompere la connessione indicata in rosso nell’immagine, quella contrassegnata con 2 + 3 + 6 + 7. La configurazione diventerebbe come quella rappresentata nell’immagine di sinistra.

Per effettuare questa conversione è sufficiente un cutter ed un cacciavite. Come indicato nell’immagine che segue, utilizzate il cacciavite per sollevare il cappuccio azzurro che protegge un piccolo circuito elettronico in cui noterete 11 punti di saldatura, questo circuito non fa altro che collegare le varie bobine del passo passo.

Interrompete la pista centrale come indicato nell’immagine in questo modo renderemo il passo passo bipolare.
Questa modifica potrà farvi raggiungere gli 800 gcm che è almeno il doppio rispetto all’unipolare in full step (380 gcm) e quasi 3 volte di più per un unipolare half step (300 gcm).

A questo punto avremo bisogno di un driver che consenta il pilotaggio del motore, per questo potreste utilizzare L293D oppure un ULN2003 o ancora un A4988.

Fate riferimento agli articoli passati.

Non dimenticare di regolare al minimo la corrente del vostro driver A4988 / DRV8825, in quanto per questi motori non è possibile fornire più di 100 mA per fase, se superate questo valore potreste distruggere il motore.

Buon Making a tutti. 🙂

Pubblicato in arduino, i miei allievi | Contrassegnato , , , , | Lascia un commento