OPERATORI BOOLEANI

Gli operatori booleani vengono utilizzati per combinare più condizioni: ad esempio per verificare se il valore di un sensore è compreso tra 1 e 5.  In questo caso basta scrivere:

if ( (sensore>=1) && (sensore<=5) ) { ... }

Esistono tre tipi di operazioni booleane:    && (And)  -  || (Or) -   ! (Not).

&& => AND => che corrisponde alla frase: "ed anche"
Condizione1 && Condizione2 => la combinazione delle 2 condizioni è vera se tutte e 2 le condizioni sono vere

|| => OR => che corrisponde alla frase: "oppure"
Condizione1 || Condizione2 =>  la combinazione delle 2 condizioni è vera se almeno una delle 2 condizioni è vere

! => NOT => che corrisponde alla frase: "non"
!Condizione1 => vera se la condizione1 è falsa

25 marzo 2014

Ricordarsi che la virgola, utilizzata nei numeri come separatore della parte decimale, nel C di arduino viene sostituita con il punto. Quindi 3,43 diventa:

3.43

LE FUNZIONI

La sintassi di una funzione è:

TipoDatoRestituito NomeFunzione(tipo parametro1, ... , tipo parametroN )
{
   CodiceFunzioneF
   return ValoreRestituito;
}

I parametri preceduti dalla parola Const sono quelli a sola lettura (ovvero non possono essere modificati dalla funzione stessa). Un esempio di funzione potrebbe essere la seguente:

int Somma(const int A , const int B , const int C  )
{
   int Z=A+B+C;
   return(Z);
}

Con l'istruzione return viene restituito il valore prodotto dalla funzione che deve essere dello stesso tipo tipo indicato nell'intestazione della funzione.

Vediamo ora come implementare (costruire) la funzione arrotonda(). Immaginiamo che la funzione si comporti in questo modo:

Arrotonda(3.5693,1); => 3.5
Arrotonda(3.5693,2); => 3.56
Arrotonda(3.5693,3); => 3.569

Un modo per ottenere tale risultato potrebbe essere il seguente:

1) immaginiamo di avere il seguente numero X=3.39291
2) lo moltiplico per la potenza n-esima di 10 dove n è il numero di cifre decimali che voglio mantenere. L'effetto di questa operazione è quello di spostare la virgola verso destra di n
posizioni. Se ad esempio poniamo n=2 il numero diventa X=339.291
3) successivamente assegno il valore ottenuto ad una variabile intera. Questo operazione determina la cancellazione della parte decimale per cui 339.291 diventa 339
4) adesso dividiamo il valore intero appena ottenuto per la stessa potenza di 10 utilizzata precedentemente. Chiaramente tratto il tutto come un numero con la virgola (float/double) e non come intero. Otteniamo come risultato finale X=3.39 che è l'obiettivo che ci eravamo proposti.

Quindi la funzione Arrotonda()potrebbe essere scritta in questo modo:

int x;
x=(int)(10.89*21.34);

Se non utilizzassi l'istruzione di cast

x=(int)(10.89*21.34);

alcuni compilatori potrebbero restituire un errore poiché si ritrovano ad assegnare un numero decimale ad una variabile intera che non gestisce la parte decimale.

L'operazioni di casting (int)(10.89*21.34) è il modo per il programmatore di segnalare al compilatore che la conversione da decimale ad intero è voluta!

Le funzioni possono non avere parametri oppure non restituire alcun valore:

Solitamente le funzioni che non restituiscono alcun valore vengono chiamate "Procedure". Se un parametro y presenta un & davanti nella chiamata alla funzione questo indica (per ora non entro nei dettagli!) che potrà essere modificato nel contenuto da parte della nostra procedura P e pertanto può essere sfruttato come un possibile valore di ritorno. In altre parole le due istruzioni sono equivalenti.

1 aprile 2014

LE COSTANTI

Se sappiamo che una variabile, utilizzata all'interno di un nostro programma, non viene mai modificata ma solo letta (ed è quindi una costante!) allora è opportuno anteporre alla sua dichiarazione la parola chiave const.

const int pigreco=3.14;

Se per errore, nel codice del nostro programma,  scriviamo un'istruzione di assegnamento come questa:

allora il compilatore, durante la fase di compilazione, ci avviserà mediante un messaggio di errore:

int Elenco[4]={0};
Elenco[2]=12; // assegno 12 al terzo elemento di Elenco

Ad esempio per registrare i valori letti da un sensore durante l'arco delle 24 ore posso utilizzare un array di questo tipo:
int ValoriLetti[24] => quindi un elenco di 24 celle che conterranno le letture rilevate dal sensore nell'arco delle 24 ore.

int ValoriLetti[2]=analogRead(A1); => leggo sul pin del sensore il valore e se sono le 3.00 di notte lo registro nel terzo elemento dell'array ValoriLetti. Ricordatevi che la prima cella dell'array è ValoriLetti[0] e l'ultima è ValoriLetti[n-1] dove n è la dimensione dell'array.

DIVERSE CODIFICHE CHE DETERMINANO LA STESSA ESECUZIONE

In classe abbiamo visto che la seguente codifica (esempio del JOYSTICK)

void setup()
{
   Serial.begin(9600);
}
void loop()
{
   unsigned int X = analogRead(A0);
   unsigned int Y = analogRead(A4);
   Serial.print("(X,Y) = (");
   Serial.print(X);
   Serial.print(", ");
   Serial.print(Y);
   Serial.println(")");
   delay(10);
}

produce questo output

lo stesso risultato poteva essere ottenuto con questa sequenza

oppure con quest'altra sequenza

- A0

- String

Con l''istruzione String Frase dico ad Arduino che nella variabile Frase metterò una sequenza di simboli ASCII. Quando invece scrivo String(23)dico ad Arduino che il numero 23 deve essere trattato come stringa quindi "23". Pertanto se scrivo:

23+12 => il risultato sarà: 35
String(23)+String(12)=> il risultato sarà "2312" e quindi concateno

- snprintf

La funzione snprintf(s,n,"formato",var1,...) compone una stringa utilizzando le stesse regole della "maschera di formato" della funzione C++ printf ma invece di stamparla a video la riversa nell'area di memoria (con capacità massima n) puntata dalla variabile s. Ad esempio la seguente istruzione

snprintf(Linea, 32, "(X,Y)=(%d,%d)", X, Y);

sostituisce i simboli %d con i valori contenuti nelle variabili X e Y. La stringa così ottenuta viene riversata fino ad un massimo di 32 caratteri nella variabile char [] Linea. Il simbolo %d è un esempio di "maschera di formato" ed indica che verrà sostituito con un numero. Se il formato fosse stato %s allora questo verrà sostituito con una variabile o costante di tipo stringa.

8 aprile 2014

15 aprile 2014

Per gestire il display LCD occorre utilizzare la libreria fornita dallo stesso sistema di sviluppo di Arduino <LiquidCristal.h>.  Questa sequenza di istruzioni:

LCD.print("AVE ");
LCD.print("STUDENTS");

è equivalente a

LCD.print("AVE STUDENTS");

poiché il metodo print, dopo aver scritto il testo, si posiziona automaticamente sulla cella successiva all'ultimo carattere scritto. Il comando setcursor(colonna,riga) permette di posizionare il cursore sul prossimo punto da cui partire a scrivere. La numerazione delle righe e delle colonne parte da 0 per cui LCD.setcursor(0,0) corrisponde alla prima lettera in alto a sinistra del display LCD.

Per gestire il display occorre definire una variabile oggetto di tipo LiquidCrystal. .

GLI OGGETTI

Nella programmazione ad oggetti si immaginano le variabili come dotate di proprietà (Attributi) ed azioni (Metodi) capaci di rilevare il verificarsi di determinati accadimenti (Eventi).

Ad esempio pensando di applicare la programmazione ad oggetti relativamente ad una una persona abbiamo:

- Attributi: Cognome, Nome, Data di nascita, Altezza, Peso, ...
- Metodi: Alzarsi, Fermarsi, Studiare, Programmare, Dormire, ...
- Eventi: Suona la sveglia, semaforo rosso, Inizia il periodo degli esami,mi regalano Arduino, scende la notte, ...

Quando all'interno di un programma troviamo 2 nomi separati dal punto probabilmente abbiamo a che fare con un  metodo o un attributo applicato ad una variabile di tipo oggetto. Vediamo un esempio

Persona p;

p.Cognome="Sechi";
p.eta=50;
p.Spiega(); // chiama la routine che gestisce questa azione

Non è nostro obiettivo costruire oggetti. L'importante è solo riconoscerli quando usiamo le librerie.

STRUTTURE ITERATIVE

Nei linguaggi di programmazione il construtto FOR consente di implementare,  all'interno di un programma, la capacità umana di ripetere un'operazione un numero di volte noto a priori.

Sintassi construtto FOR:

for (IstruzioniIniziali ; Condizione; IstruzioniIncremento )
{
    IstruzioniIterate; // vengono ripetute un certo numero di volte
}

Il FOR viene eseguito in questo modo (Il nostro algoritmo, che risolve un determinato problema, dovrà quindi adattarsi a queste regole di funzionamento!)

1) Esegue l'IstruzioniIniziale (se più di una vanno separate con la virgola)
2) Valuta la Condizione e se falsa passa al punto 6)
3) Esegue l' IstruzioniIterate (ripetute)
4) Esegue l'IstruzioniIncremento (solitamente è l'incremento o decremento del contatore - se più di una vanno separate con la virgola)
5) Salta al punto 2)
6) Termina il FOR e continua con le istruzioni successive

Ecco il flowchar relativo al FOR:

Il for e l'array risultano spesso abbinati poiché l'accesso indicizzato (per posizione!) agli elementi dell'array si adatta bene alle modalità di funzionamento del FOR.
Supponiamo di dover riempire un array di 10000 elementi con valori progressivi da 1 a 10000. Senza il for dovrei scrivere:

int x[10000]={1,2,3,..., 9999}

oppure:

int x[10000];
x[0]=1;
x[1]=2;
...
x[9999]=9999;
x[10000]=10000;

quindi un numero esorbitante di righe. Invece con il FOR mi bastano 3 righe:

int x[10000];
for (int i=0; i<10000 ; i++)
   x[i]=i+1;
 

Si noti che la sequenza

void setup() { }

void loop()
{
   lcd.print("Ave");
   delay(1000);
}

può essere riscritta utilizzando il for in questo modo:

void setup()
{
   for ( ; ; ) // loop infinito
   {
      lcd.print("Ave");
      delay(1000);
   }
}

void loop() { }

Nei linguaggi di programmazione il construtto WHILE consente di implementare,  all'interno di un programma, la capacità umana di ripetere un'operazione più volte fino a ché una condizione risulta soddisfatta.

Sintassi construtto WHILE:

Il WHILE viene eseguito in questo modo (Il nostro algoritmo, che risolve un determinato problema, dovrà quindi adattarsi a queste regole di funzionamento!)

1) Valuto la Condizione e se falsa passa al punto 4)
2) Eseguo le IstruzioniIterate (ripetute)
5) Salta al punto 1)
6) Termina il WHILE e continua con le istruzioni successive

Ecco il flowchar relativo al WHILE:

Nel C++ le strutture iterative FOR e WHILE sono equipotenti ovvero qualsiasi programma scritto in FOR può essere riscritto con il WHILE e viceversa.

In altre parole quando dobbiamo implementare un'iterazione possiamo usare uno o l'altro construtto. Generalmente i programmatori preferiscono utilizzare l'istruzione FOR poichè più compatta (richiede un numero di righe limitato). E' comunque preferibile utilizzare il WHILE tutte le volte in cui non conosco a priori il numero di iterazioni che verrà svolto (esempio continuo a chiedere un numero finchè non mi si fornisce un valore uguale a 0).

#include <Servo.h> 
 
Servo myservo;  
int pos = 0;    
 
void setup() 
{ 
  myservo.attach(9);  
  myservo.write(0);   
  delay(15);         
 
 
void loop() 
{ 
  for(pos = 0; pos < 180; pos++)  
  { 
    myservo.write(pos);              
    delay(15);                      
  } 
  for (pos = 180; pos>=1; pos-=1)    
  {                                
    myservo.write(pos);            
    delay(15);                      
  } 
}

12 gennaio 2015

PASSAGGIO DEI PARAMETRI ALLE FUNZIONI

Analizziamo ora alcuni esempi che riguardano la manipolazione di variabili da parte di funzioni presenti in un nostro programma. Chiameremo funzione chiamante la funzione fm() che nel suo corpo presenta una chiamata ad un altra funzione fs() detta funzione chiamata. Ad esempio:

variabili globali del programma;
...
tipo fm(parametri di fm)
{
   variabili di fm;
   // Corpo di fm()
   ...
   fs(parametri di fm passati a fs);
   ...
}

tipodato fs(parametri di fs)
{
   variabili di fs;
   // Corpo di fs();
   ...
}

Negli esempi successivi considereremo come fm() la funzione di sistema setup() e come funzione fs() la funzione incrementa() da noi sviluppata e che si  limita ad incrementare il contenuto del nostro parametro di un'unità. Per mia comodità, rifacendomi alle specifiche dei compilatori standard del C, ho posto a 4 byte la dimensione sia delle variabili int che quelle dei puntatore. In realtà in Arduino la dimensione in byte di una variabile  int e di tipo puntatore è pari a 2 byte. Segue che la dimensione massima di RAM indirizzabile è 2¹⁶ ovvero 64Kb mentre il range ammesso per il tipo int è +/- 2¹⁵ = +/-32768.

Caso 1: la funzione chiamata non riceve alcun parametro ma manipola il contenuto di una variabile globale.

int x=7;
void setup()
{
  Serial.begin(9600);
  char c='A'; // istruzione fittizia per creare un'altra variabile
  Serial.println("Valore di X PRIMA della chiamata Incrementa(): x="+String(x));
  Incrementa();
  Serial.println("Valore di X DOPO della chiamata Incrementa() : x="+String(x));
}
void Incrementa()
{
   char S[3]={'\0'}; // istruzione fittizia per creare un'altra variabile
   x=x+1;
}

void loop() {}

Analizziamo l'output prodotto sul serial monitor. Notiamo che la nostra funzione incrementa() è in grado di modificare il contenuto della variabile globale X. 

Vediamo di capirne il motivo in dettaglio.

1.a) Appena il programma di Arduino viene avviato subito vengono istanziate tutte le variabili definite all'esterno di una qualsiasi funzione. Tali variabili sono dette globali. Viene quindi creata in memoria la variabile x (dall'indirizzo 00 fino a 03)

1.b) Successivamente viene avviata la funzione  setup() che immediatamente genera in memoria la variabile locale c (all'indirizzo 42) .

1.c) Quando viene richiamata la funzione incrementa() abbiamo la creazione nella memoria ram di uno spazio dedicato in modo esclusivo alla nostra funzione incrementa(). In tale spazio vengono messe le variabili locali dichiarate all'interno della funzione chiamata. Verrà quindi allocato lo spazio per la variabile s[3] (dall'indirizzo 65 all'indirizzo 67).

1.d) L'esecuzione prosegue con l'istruzione di incremento x=x+1 all'interno della funzione incrementa(). La variabile x non è definita all'interno di incrementa() per cui verrà utilizzata la variabile globale x.

1.e) Terminata l'esecuzione della funzione incrementa() tutto lo spazio di memoria ad essa riservato viene deallocato e la variabile locale s[3] viene distrutta (sostanzialmente se ne perde il contenuto!). L'esecuzione prosegue con l'istruzione successiva alla chiamata incrementa(); (all'interno della funzione setup()) quindi con la scrittura del contenuto della variabile globale x sul serial monitor. Abbiamo visto che la variabile globale x ha subito l'incremento del suo contenuto da parte della funzione incrementa() per cui stampa il valore 8.

RIASSUMENDO: In C le funzioni modificano il contenuto delle variabili globali

Caso 1 bis: la funzione chiamata non riceve alcun parametro ma manipola il contenuto di una variabile locale il cui nome è uguale a quello di una variabile globale.

int x=7;
void setup()
{
  Serial.begin(9600);
  char c='A'; // istruzione fittizia per creare un'altra variabile
  Serial.println("Valore di X PRIMA della chiamata Incrementa(): x="+String(x));
  Incrementa();
  Serial.println("Valore di X DOPO della chiamata Incrementa() : x="+String(x));
}
void Incrementa()
{
   char S[3]={'\0'}; // istruzione fittizia per creare un'altra variabile
   int x=7;
   x=x+1;
}

void loop() {}

Analizziamo l'output prodotto sul serial monitor. Notiamo che la nostra funzione incrementa() non modifica il contenuto della variabile globale X.

Vediamo di capirne il motivo in dettaglio.

1bis.a) Appena il programma viene avviato vengono subito istanziate tutte le variabili definite all'esterno di una qualsiasi funzione. Tali variabili sono dette globali. Viene quindi allocata in memoria la variabile x (dall'indirizzo 00 fino a 03)

1bis.b) Successivamente viene avviata la funzione  setup(). che immediatamente alloca in memoria la variabile c (all'indirizzo 42) .

1bis.c) Successivamente viene chiamata la funzione incrementa(). Questo determina la creazione nella memoria ram di uno spazio dedicato in modo esclusivo alla nostra funzione incrementa(). In tale spazio verranno messe le variabili locali dichiarate all'interno della funzione chiamata. Verrà quindi allocato lo spazio per le variabili locali s[3] (dall'indirizzo 63 all'indirizzo 65) e x (dall'indirizzo 66 all'indirizzo 69). Quest'ultima ha il nome uguale a quello di una variabile globale.

1bis.d) L'esecuzione prosegue con l'istruzione di incremento x=x+1 all'interno della funzione incrementa(). La variabile locale x, definita all'interno di incrementa(), verrà utilizzata nell'operazione di incremento poichè "nasconde" (si dice shadowing) la variabile globale che resta quindi inalterata.

1bis.e) Terminata l'esecuzione della funzione incrementa() tutto lo spazio di memoria ad essa riservato viene deallocato e le variabili locali s[3] e x vengono distrutte (sostanzialmente se ne perde il contenuto!). L'esecuzione prosegue con l'istruzione successiva e quindi con la scrittura del contenuto della variabile globale x all'interno del serial monitor. Abbiamo visto che la variabile non ha subito alcuna modifica per cui stampa il valore originale 7.

RIASSUMENDO: In C le funzioni non riescono a modificare il contenuto delle variabili globali se hanno al loro interno delle variabili locali con lo stesso nome.

Caso 2: la funzione chiamata manipola il contenuto di una variabile passata come parametro (non è quindi presente il simbolo * nella definzione dei parametri).

void setup()
{
  Serial.begin(9600);
  char c='A'; // istruzione fittizia per creare un'altra variabile
  int x=7;
  Serial.println("Valore di X PRIMA della chiamata Incrementa(x): x="+String(x));
  Incrementa(x);
  Serial.println("Valore di X DOPO della chiamata Incrementa(x) : x="+String(x));
}
void Incrementa(int x)
{
   char S[3]={'\0'}; // istruzione fittizia per creare un'altra variabile
   x=x+1;
}

void loop() {}

Analizziamo l'output prodotto sul serial monitor. Notiamo che la nostra funzione incrementa() non è riuscita a modificare il contenuto della variabile originale X dentro setup().

Vediamo di capire come mai questo accada.

2.a) Appena il programma viene avviato viene lanciata la funzione  setup() che immediatamente alloca in memoria le variabili richieste c (all'indirizzo 00) e x (all'indirizzo 01 fino a 04)

2.b) Successivamente viene richiamata la funzione incrementa() alla quale viene passato come parametro la variabile x definita nella funzione setup(). Questo determina la creazione nella memoria ram di uno spazio dedicato in modo esclusivo alla nostra funzione incrementa(). In tale spazio verranno messe le variabili locali dichiarate all'interno della funzione chiamata più  il parametro che verrà inizializzato con il valore contenuto nella variabile x di setup()  (quindi il valore 7). Verrà quindi allocato lo spazio per la variabile x (dall'indirizzo 73 all'indirizzo 76 poichè abbiamo supposto che il tipo int occupi 4 byte!) e s[3] (dall'indirizzo 77 all'indirizzo 79).

2.c) L'esecuzione prosegue con l'istruzione di incremento x=x+1 all'interno della funzione incrementa().

2.d) Terminata l'esecuzione della funzione incrementa() tutto lo spazio di memoria ad essa riservato viene deallocato e le variabili locali x  e s[3] vengono distrutte (sostanzialmente se ne perde il contenuto!). L'esecuzione prosegue con l'istruzione successiva alla chiamata incrementa(x); all'interno della funzione setup() e quindi con la scrittura del contenuto della variabile x di setup()all'interno del serial monitor. Abbiamo visto che la variabile non ha subito alcuna modifica da parte della nostra funzione chiamata per cui stampa il valore originale 7.

RIASSUMENDO: In C le funzioni non sono in grado di modificare i  parametri passati. Nel prossimo esempio vedremo come ovviare al problema.

Caso 3: la funzione chiamata manipola il contenuto di una variabile passata mediante l'utilizzo di un puntatore (è quindi presente il simbolo * nella definzione dei parametro).

Consideriamo il seguente programma che nella funzione di sistema setup() richiama la funzione Incrementa() alla quale passa come parametro l'indirizzo della variabile X. di setup() mediante la notazione &x.

void setup()
{
  Serial.begin(9600);
  char c='A'; // istruzione fittizia per creare un'altra variabile
  int x=7;
  Serial.println("Valore di X PRIMA della chiamata Incrementa(&x): x="+String(x));
  Incrementa(&x);
  Serial.println("Valore di X DOPO della chiamata Incrementa(&x) : x="+String(x));
}
void Incrementa(int *x)
{
   char S[3]={'\0'}; // istruzione fittizia per creare un'altra variabile
   *x=*x+1;
}

void loop() {}

Analizziamo l'output prodotto sul serial monitor. Notiamo che la nostra funzione incrementa() in questo caso è riuscita a modificare il contenuto della variabile originale X dentro setup().

Vediamo di capire il motivo.

3.a) Appena il programma viene avviato viene lanciata la funzione  setup() che immediatamente alloca in memoria le variabili richieste c (all'indirizzo 00) e x (all'indirizzo 01 fino a 04)

3.b) Successivamente viene richiamata la funzione incrementa() alla quale viene passato come parametro l'indirizzo della variabile x definita nella funzione setup(). Questo determina la creazione nella memoria ram di uno spazio dedicato in modo esclusivo alla nostra funzione incrementa(). In tale spazio verranno messe le variabili locali dichiarate all'interno della funzione chiamata compresa quella relativa parametro (che non è di tipo intero ma puntatore ad intero!) che verrà inizializzata con l'indirizzo in memoria della variabile x di setup() passata come parametro (quindi con il valore 01). Verrà quindi allocato lo spazio per la variabile x (dall'indirizzo 73 all'indirizzo 76 poichè il tipo puntatore abbiamo supposto occupare 4 byte!) e s[3] (dall'indirizzo 77 all'indirizzo 79).

3.c) L'esecuzione prosegue con l'istruzione di incremento *x=*x+1 all'interno della funzione incrementa(). La scrittura *x non deve essere intesa come "puntatore ad x", come avviene nella dichiarazione int *x, ma come "contenuto della cella che in memoria si trova all'indirizzo contenuto nel puntatore x". Pertanto l'istruzione di incremento non opera nello spazio di memoria dedicato alla funzione incrementa() ma direttamente sulla variabile il cui indirizzo è stato passato come parametro (la x della funzione setup()).

3.d) Terminata l'esecuzione della funzione incrementa() tutto lo spazio di memoria ad essa riservato viene deallocato e le variabili locali *x  e s[3] vengono distrutte (sostanzialmente se ne perde il contenuto!). L'esecuzione prosegue con l'istruzione successiva alla chiamata incrementa(&x); quindi con la scrittura del contenuto della variabile x di setup()all'interno del serial monitor. Abbiamo visto che la variabile ha subito un incremento per effetto dell'esecuzione della funzione chiamata per cui stampa il valore successivo 8.

RIASSUMENDO: In C le funzioni che ricevono come parametri un puntatore sono in grado di modificare il contenuto delle variabili originali il cui indirizzo è passato come argomento.

Caso 4: la funzione chiamata manipola il contenuto di una variabile passata come parametro (non è quindi presente il simbolo * nella definzione dei parametro) e lo restituisce alla funzione chiamante mediante un return.

Consideriamo il seguente programma che nella funzione di sistema setup() richiama l'istruzione di assegnamento x=Incrementa(x) alla quale viene passata come parametro la variabile X di setup().

void setup()
{
  Serial.begin(9600);
  char c='A'; // istruzione fittizia per creare un'altra variabile
  int x=7;
  Serial.println("Valore di X PRIMA della chiamata x=Incrementa(x): x="+String(x));
  x=Incrementa(x);
  Serial.println("Valore di X DOPO della chiamata x=Incrementa(x) : x="+String(x));
}
int Incrementa(int x)
{
   char S[3]={'\0'}; // istruzione fittizia per creare un'altra variabile
   x=x+1;
   return x;
}

void loop() {}

Analizziamo l'output prodotto sul serial monitor. Notiamo che la nostra istruzione x=incrementa(x) è riuscita a modificare il contenuto della variabile originale X dentro setup().

Vediamo di capire come mai questo accada.

4.a) Appena il programma viene avviato viene lanciata la funzione  setup() che immediatamente alloca in memoria le variabili richieste c (all'indirizzo 00) e x (all'indirizzo 01 fino a 04)

4.b) Successivamente viene richiamata l'istruzione x=incrementa(x) alla quale viene passato come parametro la variabile x definita nella funzione setup(). Questo determina la creazione nella memoria ram di uno spazio dedicato in modo esclusivo alla nostra funzione incrementa(). In tale spazio verranno messe le variabili locali dichiarate all'interno della funzione chiamata più  il parametro che verrà inizializzato con il valore contenuto nella variabile x di setup()  (quindi il valore 7). Verrà quindi allocato lo spazio per la variabile x (dall'indirizzo 73 all'indirizzo 76 poichè abbiamo supposto che il tipo int occupi 4 byte!) e s[3] (dall'indirizzo 77 all'indirizzo 79).

4.c) L'esecuzione prosegue con l'istruzione di incremento x=x+1 all'interno della funzione incrementa().

4.d) L'esecuzione della funzione incrementa() termina con la restituzione del contenuto della variabile locale x mediante l'istruzione return;.

4.e) Terminata l'esecuzione della funzione incrementa() tutto lo spazio di memoria ad essa riservato viene deallocato e le variabili locali x  e s[3] vengono distrutte (sostanzialmente se ne perde il contenuto!). Però "prima di morire" Incrementa() ha scaricato il valore modificato nella variabile x di setup()per cui la stampa all'interno del serial monitor stamperà il valore originale 8.

RIASSUMENDO: In C le funzioni che restituiscono un valore non possono modificare direttamente il parametro passato a meno che il valore restituito dalla funzione non venga assegnato alla variabile passata come parametro (che dovrà quindi comparire a sinistra del simbolo di assegnamento =)

TO DO (Prossimo corso):

A) Costruire con un KEYPAD un timer che mantiene l'ora dopo averla settata e fa scattare degli allarmi ogni tot. Sul Display LCD appare l'ora e con un buzz simulo l'allarme. Alla base utilizzare la funzione millis()
B) LCD con scrolling automatico in base a quello che scrivo sul Monitor Seriale.
C) Mostrare esempi Servo Motore
D) Mostrare esempi IR
E) esempio_LED.htm - Sorgente B
F) esempio_TILT.htm
 

Note in sospeso .....

Link suggeriti:
 

http://www.raspibo.org/wiki/index.php?title=Ardubottino

CORSO: http://www.maffucci.it/area-studenti/arduino/