Gestire le stringhe con Arduino – approfondimenti


In passato ho già affrontato questo argomento e con questo post aggiungo alcuni approfondimento utili per i miei studenti.

Le stringhe sono una struttura di dati che viene utilizzata per memorizzare e gestire il testo. Le stringhe possono essere utilizzate per visualizzare del testo su un qualsiasi display connesso ad Arduino oppure più semplicemente sul monitor seriale di Arduino. Le stringhe possono essere utilizzate anche per memorizzare ad esempio i caratteri inseriti da tastiera connessa ad Arduino.

Possiamo distinguere due tipi di stringhe

  1. Array di caratteri, che sono le stesse delle stringhe utilizzate nella programmazione C.
  2. Il tipo di dato Sring di Arduino che permette di utilizzare un oggetto String in uno sketch.

Array di caratteri

Il primo tipo di stringa che impareremo ad utilizzare è la stringa costituita da una serie di caratteri memorizzati in un Array, cioè un vettore di caratteri il cui ultimo elemento è un carattere terminatore (o di fine stringa), codificato con il numero 0 e rappresentato in C dal carattere ‘\0’.

Nel programma che segue viene composta la stringa, un array di caratteri, il cui ultimo carattere è costituito dal terminatore 0, la stringa composta verrà poi stampata sulla Serial Monitor.

void setup() {
   char mia_stringa[8];    // un array di dimensione 8 costituito da 7 caratteri
   Serial.begin(9600);     // inizializzazione della Serial Monitor
   mia_stringa[0] = 'A';   // la stringa è formata da 5 caratteri più il terminatore
   mia_stringa[1] = 'r';
   mia_stringa[2] = 'd';
   mia_stringa[3] = 'u';
   mia_stringa[4] = 'i';
   mia_stringa[5] = 'n';
   mia_stringa[6] = 'o';
   mia_stringa[7] = 0;          // l'ottavo elemento dell’array è costituito dal terminatore
   Serial.println(mia_stringa); // stampa della stringa sulla Serial Monitor
}

void loop() { 
    // per ora nulla
}

Nell’esempio che segue utilizziamo un modo più comodo per creare le stringhe.
In questo caso il compilatore calcola la dimensione dell’array di caratteri ed inserisce automaticamente il terminatore di stringa costituito dal carattere 0. Un array composto da 8 elementi, 7 caratteri seguiti dal carattere 0.
Il risultato sarà il medesimo dello sketch precedente:

void setup() {
   char mio_sito[] = "Arduino";
   Serial.begin(9600);
   Serial.println(mio_sito);
}

void loop() {
    // per ora nulla
}

Manipolazione di Array di stringhe

La manipolazione di un’array di stringhe può essere effettuata nel seguente modo:

void setup() {
   char mia_stringa[] = "Salve mondo"; // creazione della stringa
   Serial.begin(9600);
   // stampa della stringa sulla Serial Monitor
   Serial.println(mia_stringa);
   // cancellazione di una parte della stringa
   mia_stringa[5] = 0;
   Serial.println(mia_stringa);
   // (3) sostituzione dei caratteri
   mia_stringa[5] = ' ';  // sostituzione con il carattere spazio
   mia_stringa[6] = 'M';  // inserimento della nuova parola
   mia_stringa[7] = 'i';
   mia_stringa[8] = 'k';
   mia_stringa[9] = 'y';
   mia_stringa[10] = '!';
   mia_stringa[11] = 0; // terminatore di stringa
   Serial.println(mia_stringa);
}

void loop() {
    // per ora nulla
}

Risultato:

Salve mondo
Salve
Salve Miky!

La stringa viene abbreviata sostituendo il 5′ carattere con il terminatore 0.
Quando la stringa viene stampata sulla Serial Monitor, tutti i caratteri dell’array vengono stampati fino al nuovo terminatore 0, quello che possiede l’indice 5 nell’array. I restanti caratteri non vengono cancellati sono ancora presenti in memoria, compreso il secondo terminatore 0 e l’array possiede ancora la stessa dimensione, però in questo caso se utilizziamo una funzione che legge l’array questa vedrà tutti i caratteri fino al nuovo terminatore (indice 5).

Successivamente viene sostituita la parola ” mondo” con la parola “Miky!” e questa operazione viene effettuato sostituendo il terminatore in posizione 5 con uno spazio in modo che la stringa venga ripristinata nel formato di origine.
L’inserimento della nuova parola viene eseguito inserendo in ogni posizione la lettera corrispondente alla nuova parola.

Funzioni per manipolare le stringhe

Lo sketch precedente permette di manipolare la stringa manualmente accedendo ai singoli caratteri memorizzati nell’array.
Per manipolare le stringhe possiamo scrivere noi delle nostre funzioni, oppure più semplicemente utilizzare le funzioni String presenti nella libreria del C.

Esempio

void setup() {
   char mia_stringa[] = "Nel mezzo del cammin di nostra vita"; // creazione della stringa
   char mia_stringa_output[80]; // l’output verrà inserito in questa stringa
   int dimensione;
   Serial.begin(9600);

   // A. stampa la stringa 
   Serial.println(mia_stringa);

   // B. lettura della lunghezza della stringa.
   // Nel conteggio viene escluso il carattere
   // terminatore
   dimensione = strlen(mia_stringa);
   Serial.print("La lunghezza della stringa è: ");
   Serial.println(dimensione);

   // C. prende la lunghezza dell’array incluso il carattere terminatore
   dimensione = sizeof(mia_stringa); // sizeof() non è una funzione specifica per gestire le stringhe
   Serial.print("Dimensione dell'array: ");
   Serial.println(dimensione);

   // D. copiare una stringa
   strcpy(mia_stringa_output, mia_stringa);
   Serial.println(mia_stringa_output);

   // E. aggiungere una stringa alla fine di un’altra (append)
   strcat(mia_stringa_output, " mi ritrovai per una selva oscura");
   Serial.println(mia_stringa_output);
   dimensione = strlen(mia_stringa_output);
   Serial.print("La lunghezza della stringa è: ");
   Serial.println(dimensione);
   dimensione = sizeof(mia_stringa_output);
   Serial.print("Dimensione dell'array mia_stringa_output[ ] è: ");
   Serial.println(dimensione);
}

void loop() {
    // per ora nulla
}

Risultato:

Nel mezzo del cammin di nostra vita
La lunghezza della stringa è: 35
Dimensione dell'array: 36
Nel mezzo del cammin di nostra vita
Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura
La lunghezza della stringa è: 68
Dimensione dell'array mia_stringa_output[ ] è: 80

Come avete avuto modo già di imparare, per stampare una stringa sarà sufficiente richiamarla come argomento all’interno della funzione println. La funzione strlen(), che restituisce la lunghezza di una stringa, prende in considerazione solamente i caratteri che possono essere stampati (visualizzati) ad esclusione del terminatore 0.

L’operatore sizeof() prende come argomento un array e di questo ne restituisce la sua lunghezza, in questo caso però la lunghezza include anche il terminatore di stringa, pertanto il sizeof() restituirà un valore più grande di una unità rispetto alla funzione strlen().

sizeof() può essere confusa con una funzione, ma tecnicamente è un operatore. Non fa parte della libreria String del C, ma è stata utilizzata in questi esempio per mostrare la differenza tra la dimensione dell’array e la dimensione della stringa.

La funzione strcpy() viene usata, nello sketch sopra indicato, per copiare mia_stringa in mia_stringa_output quindi la funzione copia la seconda stringa nella prima attenzione che in questo caso la seconda stringa viene copiata in una stringa che ha dimensione più grande, 80, mentre mia_stringa ha una dimensione di 35, questo vuol dire che ci saranno 20 caratteri liberi in memoria che potranno essere utilizzati.

Domanda

Dopo la copia di mia_stringa in mia_stringa_output sei in grado di dimostrare con uno sketch cosa è presente in memoria dal 36’ al 80’ posizione di mia_stringa_output?

La concatenazione di stringhe viene eseguita con la funzione strcat() che permette di inserire la seconda stringa indicata nella funzione strcat() alla fine delle prima stringa indicata nella strcat(). Dopo la concatenazione viene mostrata la lunghezza della nuova stringa risultante costituita da 68 caratteri copiati in un array che ha una dimensione di 80.

Si ricorda che una stringa di 68 caratteri occupano nell’array 69 caratteri in quanto bisogna considerare il terminatore 0.

Attenzione

Se l’array fosse troppo piccolo e provassimo a copiare all’interno una una stringa più grande della dimensione dell’array, la stringa verrebbe copiata anche al di fuori dell’array. La memoria oltre la fine dell’array potrebbe contenere altri dati importanti utilizzati nello sketch, questi dati verrebbero quindi sovrascritti dalla nostra stringa. In questo caso se la memoria oltre la fine della stringa viene sovrascritto potrebbe far arrestare in modo anomalo il programma o causare comportamenti strani.

Per approfondire l’argomento e verificare come evitare di scrivere al di furi dello spazio di memoria assegnato ad uno specifico array, vi rimando a questi due post:

Arduino – lezione 07: lavorare con gruppi di valori e funzioni esterne
Arduino – Concatenare la stampa di stringhe e variabili

Questa voce è stata pubblicata in arduino, i miei allievi. Contrassegna il permalink.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.