Archivi tag: arduino

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.

Nel dettaglio

  • I caratteri iniziali che non sono cifre o sono numeri negativi vengono ignorati;
  • L’analisi si interrompe quando non sono stati letti caratteri per un valore di tempo di timeout che può essere configurato oppure viene letta una non cifra;
  • Se non sono state lette cifre valide quando si verifica il timeout (vedere Serial.setTimeout ()), viene restituito 0; Serial.parseInt () eredita dalla classe Stream.

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()

Fare didattica laboratoriale con EduRobot Home


Sarà un anno scolastico complicato per realizzare attività di laboratorio… distanziamento fisico, uso delle attrezzature che dovranno essere continuamente sanificate, didattica digitale integrata e mille altre cose che limitano le attività nei laboratori degli ITIS e dei Professionali.
Per i ragazzi di terza superiore, per le esercitazioni di TPSEE e Sistemi, in questi giorni pensavo ai miei soliti kit, soluzioni trasportabili che mi permettono di far svolgere le esperienze di laboratorio in qualsiasi luogo della scuola. Una parte delle esercitazioni vorrei declinarle ad aspetti di automazione civile (un primo passo verso la domotica) da svolgere in modo divertente e che appassioni.

Utilizzerò prima Arduino che tutti gli allievi di tutte le mie classi posseggono in kit, aggiungeremo poi un controllo remoto via smartphone e poi si passerà al controllo con PLC, probabilmente Siemens Logo8. L’intera attività è ancora nella mia testa ma sicuramente si farà insieme alle altre parti del programma.
Le specifiche del kit sempre le solite: che stia sul banco di lavoro (480mm x 277mm), facilmente trasportabile, economico, di facile realizzazione (assemblaggio con colla vinilica o viti), da assegnare ad ogni singolo studente (importante!) e di compensato, in modo che possa essere prodotto rapidamente con il taglio laser che abbiamo a scuola. Ho realizzato una bozza del progetto a cui ho aggiunto una maniglia in modo che il kit possa essere traportato da un laboratorio all’altro come una valigetta.

Nei prossimi giorni proverò a realizzare il primo prototipo pensando anche ad alcune esercitazioni di base che possano in qualche modo far appassionare ancor di più i ragazzi. Ovviamente se il progetto risulta presentabile condivido con voi.
Aggiungo quindi alla famiglia EduRobot il piccolo progetto: EduRobot Home.

MicroCon 2020


Il lockdown come ben sapete ha creato nella scuola numerose criticità che hanno mutato radicalmente il nostro modo di studiare ed insegnare. Come insegnate di materia tecnica che vive quotidianamente il laboratorio ho necessariamente bisogno di pensare e sviluppare diverse modalità di making elettronico/didattico che da settembre bisognerà adottare a scuola in una situazione in cui tempi e comportamenti del fare e costruire saranno da rimodulare.

Ma come fare tutto ciò?

Pensieri, progetti nascenti, sperimentazioni di nuove tecnologie questo ed altro il 9 maggio al MicroCon 2020, evento online in cui si parlerà di elettronica, microcontrollori e di nuove frontiere dell’apprendimento nel settore delle nuove tecnologie.

La conferenza online e organizzata da Paolo Aliverti e Pier Aisa entrambi maker che da anni svolgono in modo egregio la loro opera di divulgazione nel settore dell’elettronica.

Maggiori informazioni sul programma e i relatori che interverranno su: www.microcon.it
Per partecipare è indispensabile l’iscrizione gratuita al seguente link.

Ringrazio Paolo e Pier per l’invito 🙂

Vi aspettiamo all’evento.

Errori comuni nell’uso di Arduino – usare troppa memoria RAM

Nella collezione degli errori nell’uso di Arduino aggiungo l’uso improprio della memoria Flash (RAM) disponibile all’interno del microcontrollore. La dimensione della memoria RAM differisce sulle varie schede Arduino, nell’esempio prendo in considerazione la scheda Arduino UNO R3.

Nell’esempio che segue, un semplice Blink, viene dichiarato un array di interi che in fase di compilazione provocherà un errore di dimensione troppo grande dell’array:

// laMiaCollezione è un array di interi che ha una dimensione di:
// (20000x16)/8=40kB
// superiore alla RAM disponibile in un Arduino UNO R3 che è di 32kB
// si faccia riferimento al seguente link:
// https://www.arduino.cc/en/tutorial/memory

int laMiaCollezione[20000];

void setup() {
  Serial.begin (9600);
  Serial.println ("Avvio programma");
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

Dovreste rilevare l’errore indicato nell’immagine che segue:

Se non vedete il led L (connesso al pin13) lampeggiare o rilevate un errore simile a quello indicato nell’immagine sopra, vuol dire che state utilizzando troppa memoria RAM. Fate attenzione che molte librerie utilizzano la RAM (ad es. Libreria di schede SD, librerie LCD, ecc.).

Nel link allegato nello sketch di esempio potete consultare la pagina specifica di Arduino.cc in cui viene spiegato come viene usata la memoria sull’Arduino UNO R3:

  • Flash 32k byte (di cui 0.5k usato per il bootloader)
  • SRAM 2k byte
  • EEPROM 1k byte

Nel dettaglio:

  • 32kB (1024×32=32768bit) di memoria Flash di cui 0,5 kB (equivalenti a 512 bit) sono dedicati al bootloader.
    Il microcontrollore presente sull’Arduino UNO R3 è un ATmega328P. All’interno della memoria Flash (RAM) del microcontrollore è presente una zona di memoria riservata in cui viene allocato il Bootloader, un programma che ha il compito di controllare se dopo il reset della scheda vie è la possibilità di caricare in memoria, tramite la USB, un nuovo programma creato dall’utente. Se non è presente nessun nuovo programma il controllo passa all’inizio del programma presente in memoria, quello precedentemente caricato e viene eseguito e il controllo non ritorna più al Bootloader fino a quando non si esegue un nuovo reset della scheda, reset che avviene quando viene caricato una nuovo programma dell’utente.
  • 2 KB di SRAM (2048 bit), è una RAM statica volatile utilizzata per gestire le variabili contenute nel programma (sketch) creato dall’utente e i dati che servono al microcontrollore per funzionare.
  • 1KB di EEPROM (1024 bit) memoria i cui valori vengono mantenuti anche quando la scheda viene spenta.

Esercizio

Nello sketch riportato sopra quel è il numero massimo di interi che può ospitare l’array laMiaCollezione affinché non si incorri nell’errore di memoria RAM piena?

Errori comuni nell’uso di Arduino – inizializzazione di più variabili

La tentazione di risparmiare linee di codice è sempre in agguato e tentare di inizializzare più variabili su una sola riga è forte, però alcune volte ciò che intendiamo fare non corrisponde a ciò che correttamente intende il compilatore.

Con la scrittura:

int x, y, z = 67;

non viene assegnato il valore 67 ad ogni singola variabile, ma solamente la variabile z viene inizializzata a 67.

L’errore quindi non risiede nella scrittura, il compilatore non restituirà errore, ma nel modo in cui il programmatore intende l’assegnamento credendo che tutte le variabili vengano inizializzate a 67.

La scrittura

int x = 67, y = 67, z = 67;

permette l’assegnamento del valore 67 ad ogni singola variabile. Si ricordi di separare ogni assegnamento da una virgola, ciò accade solo e soltanto se si indicano tipo e assegnamento su stessa linea.

Per l’assegnamento di valori diversi scriveremo:

int x = 99, y = 3, z = 67;

Io in genere preferisco una scrittura di questo tipo:

int x = 99;
int y = 3;
int z = 67;

che permette di visualizzare meglio le variabili utilizzate, non favorisce fraintendimenti nell’assegnamento e permette inoltre di scrivere chiaramente un commento a lato di ogni assegnamento.

Esercizio (semplice semplice 🙂 ) per i miei studenti:

Realizzare uno sketch che dimostra quanto esposto in questo post.

Buon Coding 🙂