Corso introduttivo sui microcontrollori A. S Programmare i PIC in C Richiami fondamentali sulla programmazione in C: le funzioni

Transcript

1 Corso introduttivo sui microcontrollori A. S Programmare i PIC in C Nicola Amoroso namoroso@mrscuole.net NA L14 1

2 Il C viene in genere indicato come un linguaggio di medio livello perché unisce elementi tipici dei linguaggi ad alto livello (Basic, Pascal, Fortran, etc ) con le funzionalità dell assembler. Essendo un linguaggio di medio livello, il C consente la gestione di bit, byte e indirizzi. Questa possibilità rende il C particolarmente adatto alla programmazione di sistemi in cui tali operazioni sono comuni (es. microcontrollori, microprocessori, etc ). Il C è anche molto semplice da usare infatti, possiede solo 32 parole chiave (27 standard iniziali + 5 aggiunte nello standard ANSI C); in questo senso il nostro compilatore CCS Pic-C compiler segue perfettamente questo standard [N.B.=> Il CCS pic-c compiler aggiunge delle built-in functions che agevolano la implementazione e realizzazione di progetti). A causa della sua similitudine con linguaggi strutturati (Pascal, Algol, ) di solito ci si riferisce al linguaggio C come ad un linguaggio strutturato, anche se non può essere considerato come linguaggio strutturato a blocchi; infatti il C non permette la dichiarazione di sottoprogrammi annidati. NA L14 2

3 La caratteristica che contraddistingue un linguaggio strutturato è la possibilità di definire in modo preciso, all interno di un programma, regole di visibilità dei dati e del codice necessarie all esecuzione di un compito specifico senza influenzare il resto del programma stesso. Il modo per definire queste regole è quello di utilizzare sottoprogrammi (soubroutines) autosufficienti [un sottoprogramma autosufficiente definisce dei dati di sua propietà (dati locali) che possono essere usati solo dal sottoprogramma stesso]. L uso di sottoprogrammi di questo tipo, consente di scrivere codice per il sottoprogramma stesso in modo che gli eventi che occorrono al loro interno non provocano alcun effetto collaterale su altre parti del programma. Sviluppando sottoprogrammi autosufficienti bisogna saper solo quello che i sottoprogrammi fanno e non come lo fanno. Il mattone fondamentale di questo tipo di programmazione strutturata è, per il C, la funzione. NA L14 3

4 In C, tutta l attività svolta da un programma viene eseguita per mezzo di funzioni. Tramite le funzioni è possibile scomporre un programma in blocchi più piccoli, ottenendo così un programma più modulare. Il C è un linguaggio di programmazione modulare! Una volta creata e provata una funzione, si può ricorrere ad essa anche in situazioni diverse rispetto a quella in cui era stata creata, con la certezza che eseguirà il compito previsto senza provocare effetti indesiderati sul resto del programma. Le funzioni create in specifici contesti possono essere raggruppate in opportune librerie e poi riutilizzate in contesti defferenti. NA L14 4

5 Tutti i compilatori C possiedono una libreria standard che fornisce le funzioni opportune per le operazioni di uso più comune (es. I/O). In alcuni casi la libreria è contenuta in un unico grosso file; altre volte, invece, è suddivisa in più files di piccole dimensioni in modo da risultare più efficiente e pratico all utilizzo. Quando nel codice sorgente viene chiamata una funzione che non fà parte del programma scritto, il compilatore prende nota del suo nome e in seguito, mediante il linker, và a cercare nella libreria inclusa, in testa al codice del programma, la funzione indicata e la aggiunge al codice stesso. Le funzioni sono per il C blocchi fondamentali in cui si svolge tutta l attività del programma. Un programma in C può essere formata da diversi blocchi (funzioni) e vi è sempre un blocco fondamentale [main] che governa la gestione di tutti gli altri blocchi. NA L14 5

6 Formato generale di una funzione: specificatore_di tipo nome_funzione(lista_argomenti) dichiarazione argomenti { corpo della funzione } specificatore_di tipo: dichiara il tipo di dato che la funzione restituisce attraverso una apposita istruzione (return) e che può essere un qualsiasi tipo di dato valido (bit1, int8, int16,...). Se non si specifica nessun tipo particolare, la funzione restituisce un intero se invece lo specificatore indicato è void (estensione ANSI C non necessariamente disponibile su tutti i compilatori) la funzione non restutuisce alcun valore. nome_funzione: il nome della funzione in oggetto, deve essere appropriato e attinente al compito che la funzione svolge NA L14 6

7 Formato generale di una funzione: specificatore_di tipo nome_funzione(lista_argomenti) dichiarazione argomenti { corpo della funzione } Lista_argomenti: è una lista di nomi di variabili separati da virgola che ricevono i nomi degli argomenti quando la funzione viene chiamata. E possibile che non esista una lista argomenti, cioè la lista è vuota. dichiarazione argomenti: specifica il tipo degli argomenti che compaiono nella lista. corpo della funzione: blocchi di codice compresi tra le due parentesi graffe Int16 quadrato_numero(x) //La funzione quadrato_numero ritorna un dato di tipo int16 Int8 x; //Il parametro (argomento) è di tipo int8 Int16 y; //Variabile locale, conterrà il valore riportato alla funzione chiamante { //Inizio Corpo della funzione y = (x*x); //Calcola il quadrato del numero return(y); //Ritorna il valore alla funzione chiamante } //Fine Corpo della funzione NA L14 7

8 Ritorno da una funzione Ci sono due modi per concludere l esecuzione di una funzione ed effettuare il ritorno al programma chiamante. Il primo modo è quello che si realizza quando nel codice si incontra la fine delle istruzioni della funzione, che corrisponde alla parentesi graffa conclusiva (la parentesi graffa non appare nel codice oggetto è presente solo nel codice sorgente). // --- Beep Buzzer void beep(void) //La funzione beep non ritorna nessun valore e non riceve nessun argomento { //Inizio corpo della funzione output_high(pin_d2); //Pin_D2 livello alto delay_ms(50); //Attendi 50 ms output_low(pin_d2); //PIN_D2 livello basso } //Fine corpo della funzione NA L14 8

9 Ritorno da una funzione Ci sono due modi per concludere l esecuzione di una funzione ed effettuare il ritorno al programma chiamante. Il secondo modo è attraverso la istruzione return; questa istruzione consente due possibilità: 1) la prima è quella di forzare la fine immediata della funzione nella riga di codice in cui l istruzione si trova, ritornando al programma chiamante nel momento in cui l istruzione si incontra; 2) la seconda è quella di restituire un valore al programma chiamante. Int16 quadrato_numero(x) //La funzione quadrato_numero ritorna un dato di tipo int16 Int8 x; //Il parametro (argomento) è di tipo int8 Int16 y; //Variabile locale, conterrà il valore riportato alla funzione chiamante { //Inizio Corpo della funzione y = (x*x); //Calcola il quadrato del numero if ( y > 100) { //Se il risultato supera 100 beep(); //Beep di avviso return (0) //Ritorna il valore 0 alla funzione chiamante Fine esecuzione } return(y); //Normalmente (risultato minore 100) ritorna il valore alla funzione chiamante } //Fine Corpo della funzione NA L14 9

10 Valori restituiti da una funzione Tutte le funzioni, eccetto quelle dichiarate di tipo void (estensione proposta dallo standard ANSI non necessariamente presente su tutti i compilatori), restituiscono un valore che può essere specificato esplicitamente nella istruzione return; se non si usa l istruzione return la funzione restituisce il valore 0. Un modo corretto per la chiamata di una funzione All interno della funzione main viene chiamata la funzione quad(t) e il valore restituito dalla funzione viene assegnato alla variabile y1 Nella fase di chiamata di una funzione la stessa deve apparire sul lato destro della assegnazione, mai sul lato sinistro Int16 quad(x) //La funzione quad è di tipo int16 (ritorna un valore a 16 bit) int8 x; //dichiarazione del parametro formale int16 y; //Variabile locale { //Inizio corpo della funzione y= x*x; //Calcolo quadrato Il valore di x viene modificato return(y); //Ritorna il valore calcolato } //Fine corpo della funzione /* La funzione main non ritorna nessun valore (tipo Void) e non presenta alcun argomento_funzione (void per argomenti_funzione) */ Void main(void) { //Dichiarazione funzione main int8 t=10; //Variabile locale 8 bit int16 y1; //Variabile locale 16 bit y1 = quad(t) //A y1 viene assegnato il valore che ritorna la funzione quad // quad(t) = y1; Modo scorretto per la chiamata di una funzione } /*Si noti che alla funzione quad viene passato il parametro attuale t=10 e una copia del valore passato viene assegnato al parametro formale x in quad */ NA L14 10

11 Regole di visibilità delle funzioni Le regole di visibilità di un linguaggio sono le regole che decidono se una parte di codice ha accesso a un altra parte di codice o a dei dati. In C, il codice di ogni funzione è una entità privata, cui non è possibile accedere da altre parti di codice (ad es. Con una istruzione goto tipico del basic,...) se non attraverso una chiamata al nome della funzione. Due funzioni non possono interagire direttamente perchè hanno visibilità di ambienti diversi. Le variabili definite all interno di una funzione vengono dette variabili locali. Una variabile locale comincia ad esistere quando inizia l esecuzione della funzione che la definisce e viene distrutta al termine della funzione stessa. Le variabili locali non mantengono il loro valore tra una chiamata di funzione e la successiva, vengono sempre riinizializzate (ricreate) ad ogni inizio della funzione. Questa regola viene infranta se si utilizza lo specificatore static nella dichiarazione della variabile (es. static int8 k); in tal caso il compilatore tratta la variabile come se fosse globale cioè la variabile non viene distrutta quando termina la funzione ma mantiene il suo valore e alla successiva chiamata della funzione la variabile non viene riinizializzata. In termini di visibilità questa variabile è comunque visibile solo all interno della funzione di utilizzo. In C tutte le funzioni hanno lo stesso livello di visibilità cioè non è possibile definire una funzione all interno di un altra funzione. NA L14 11

12 Parametri delle funzioni Le funzioni che accettano argomenti devono predisporre un insieme di variabili che ricevono i valori passati; tali variabili sono dette parametri formali della funzione e si comportano come qualsiasi altra variabile locale. Nel seguente esempio la funzione sum calcola e stampa su display la somma di due numeri, questa funzione non restituisce alcun valore. //Calcola e mostra la somma di 2 numeri Void sum(a,b) //La funzione non restituisce alcun valore Int8 a, int8 b; //La funzione riceve due parametri formali(a e b) di tipo int8 { lcd_gotoxy(1,1); printf(lcd_putc, %d, a+b); //Mostra la somma dei valori passati } //Esempio di come la funzione viene chiamata Void main(void) { sum(5,33); //Mostra la somma di 5 e 33 (5 e 33 Parametri attuali) sum(10,56); //Mostra la somma di 10 e 56 (10 e 56 Parametri attuali). } NA L14 12

13 Parametri delle funzioni Le funzioni che accettano argomenti devono predisporre un insieme di variabili che ricevono i valori passati; tali variabili sono dette parametri formali della funzione e si comportano come qualsiasi altra variabile locale. Un modo più sintetico ma altrettanto semplice, comprensibile e valido per la dichiarazione degli argomenti di una funzione: i parametri e il tipo vengono dichiarati entro le parentesi tonde della funzione. E importante che il tipo di parametri formali coincida con quello dei parametri attuali al momento della chiamata. //Calcola e mostra la somma di 2 numeri Void sum(int8 a, int8 b) { } //La funzione non restituisce alcun valore e //riceve due parametri formali(a e b) di tipo int8 lcd_gotoxy(1,1); printf(lcd_putc, %d, a+b); //Mostra la somma dei valori passati //Esempio di come la funzione viene chiamata Void main(void) { sum(5,33); //Mostra la somma di 5 e 33 (5 e 33 Parametri attuali) sum(10,56); //Mostra la somma di 10 e 56 (10 e 56 Parametri attuali). } NA L14 13

14 Passaggio dei parametri per valore Durante la chiamata di una funzione nel passaggio dei parametri per valore, il valore del parametro attuale viene ricopiato nella variabile che costituisce il parametro formale, modifiche eseguite sul parametro formale non ha effetto sul parametro attuale (il parametro formale è una variabile locale). //Calcola e mostra il quadrato di un numero int16 sum(int8 t) { //La funzione restituisce un valore int16 t = t+2; return(t*t); //ritorna il quadrato del valore t+2 } //Esempio di come la funzione viene chiamata Void main(void) { unsigned int16 y1, y2; int8 t=8; y1=quad(t); y2=quad(t+2); lcd_gotoxy(1,13); printf(lcd_putc %lu %lu, y1, y2); //Mostra i valori: } NA L14 14

15 Dichiarazione delle funzioni prima del loro utilizzo Tutte le funzioni devono essere dichiarate prima del loro utilizzo! Negli esempi precedenti tutte le funzioni con i rispettivi corpi sono state implementate prima del loro utilizzo da parte della funzione chiamante. //La funzione sum viene implementata prima del suo utilizzo da parte della //funzione principale main //Calcola e mostra il quadrato di un numero int16 sum(int8 t) { //La funzione restituisce un valore int16 t = t+2; return(t*t); //ritorna il quadrato del valore t+2 } //Esempio di come la funzione viene chiamata Void main(void) { unsigned int16 y1, y2; int8 t=8; y1=quad(t); y2=quad(t+2); lcd_gotoxy(1,13); printf(lcd_putc %lu %lu, y1, y2); //Mostra i valori: } NA L14 15

16 Dichiarazione delle funzioni prima del loro utilizzo Tutte le funzioni devono essere dichiarate prima del loro utilizzo! Vi è un altra possibilita per dichiarare una funzione prima del suo utilizzo anche se la funzione viene implementata dopo la funzione chiamante, la dichiarazione del prototipo di funzione prima della funzione chiamante //Dichiarazione del prototipo della funzione Int16 sum(int8 ); //Dichiarazione del prototipo della funzione prima del suo utilizzo //Esempio di come la funzione viene chiamata Void main(void) { unsigned int16 y1, y2; int8 t=8; y1=quad(t); y2=quad(t+2); lcd_gotoxy(1,13); printf(lcd_putc %lu %lu, y1, y2); //Mostra i valori: } //La funzione sum viene implementata dopo il suo utilizzo da parte della funzione principale main //Calcola e mostra il quadrato di un numero int16 sum(int8 t) { //La funzione restituisce un valore int16 t = t+2; return(t*t); //ritorna il quadrato del valore t+2 } NA L14 16

17 un semplice esempio Dopo questi semplici richiami introduttivi sulle funzioni applichiamo quanto introdotto riesaminando degli esempi svolti e risolvendoli con l ausilio delle funzioni. Un semplice esempio già visto alla lezione 13 a cui rimandiamo per tutte le considerazioni Si vogliono visualizzare su display dei semplici elementari messaggi di benvenuto attivando contemporaneamente il led e il Buzzer (Autooscillante) presenti sulla Demo-Board; ricordiamoci che il display è attivato in modalità sola scrittura quindi, i PIN RD3 e RD2 vengono utilizzati per pilotare il Led e il Buzzer on board (ricordarsi di configurare opportunamente i relativi jumpers). Sviluppare l esercizio seguendo le semplici fasi già viste nella lezione 13; non ci soffermeremo nella analisi e progettazione bensì vedremo una soluzione leggermente diversa con l ausilio dei semplici richiami introduttivi sulle funzioni appena viste. NA L14 17

18 un semplice esempio Lo schema elettrico NA L14 18

19 un semplice esempio Il codice sorgente Main function Dall analisi del codice si evince che il programma è molto più fruibile e può essere compreso agevolmente Nella sezione iniziale del programma vengono inclusi i file di intestazione (.h) per le definizioni hardware del nostro controllore (CCS Pic-Wizard Tools) e i files di libreria per i driver del display LCD e della demo-board anxapic4. Ricordiamo che i files di libreria non sono altro che una raccolta di funzioni indispensabili per il funzionamento del programma che possono essere inclusi e richiamati all occorrenza al momento del loro utilizzo. I files di libreria vengono inclusi nella parte iniziale del programma in quanto in C le funzioni devono essere implementate (o dichiarate mediante opportuni prototipi di funzione ) prima del loro utilizzo. In na_iodevice.c sono raccolte le funzioni personalizzate per pilotare opportunamente i device hardware della nostra demo-board (Buzzer, Led, presentazioni su display, I2C, 1-Wire, etc ). In lcd_4x20.c sono raccolte le funzioni fondamentali per pilotare il text-display LCD 4x20 con controller Hitachi HD44780 compatibile; le funzioni presenti sono una rielaborazione del file originale proposto dalla CCS Inc. opportunamente riadattato alle nostre esigenze hardware. NA L14 19

20 un semplice esempio Il codice sorgente Main function Pic Wizard Tool Messaggio di avviso su display Messaggio presentazione su display Alla funzione che scrive il messaggio di avviso su display viene passato come parametro attuale il valore della variabile i NA L14 20

21 un semplice esempio Il codice sorgente na_iodevice library-function - 1 Si notino i due define relativi al Led e al Buzzer di sistema NA L14 21

22 un semplice esempio Il codice sorgente na_iodevice library-function - 2 NA L14 22

23 un semplice esempio Il codice sorgente na_iodevice library-function - 3 NA L14 23

24 un semplice esempio Il codice sorgente na_iodevice library-function - 4 Messaggio di avviso con visualizzazione del numero di volte che il messaggio è stato visualizzato. Il parametro formale k contiene questo numero passato dalla funzione chiamante. NA L14 24

25 un semplice esempio: Read 2 Channel ADC Un semplice esempio già visto alla lezione 13 a cui rimandiamo per tutte le considerazioni Due trimmer, sono collegati tra 5 V e GND sui pin estremi mentre il terzo pin (centrale) è collegato con RA0 per uno e RA1 per l altro; le tensioni in ingresso dei Pin RA0 e RA1 possono variare tra 0 e 5 V quando il perno centrale del trimmer viene ruotato tra 0 e 270. Leggere, convertire e visualizzare su display LCD il valore delle tensioni ai capi dei trimmer [Input pin RA0 e RA1]; se il valore letto in ingresso a RA0 oppure su RA1 supera i 4 volt visualizzare un opportuno messaggio di avviso. Questo esempio è stato gia sviluppato nella lezione 13 e lì rimandiamo per tutte le considerazioni del caso; vogliamo invece qui presentare il codice sorgente con le novità introdotte in questa lezione, si noti come il programma è molto più leggibile e comprensibile rispetto al caso precedente. Non vengono riportati né le analisi progettuali e neanche i relativi flow-chart, riportiamo solo il flow-chart del main program per evidenziare la differenza con quanto visto nella lezione 13. I commenti sul codice sono ridotti al minimo, pensiamo che a questo punto si sia acquisita la autonomia necessaria per comprendere quanto proposto. NA L14 25

26 un semplice esempio: Read 2 Channel ADC Lo schema elettrico NA L14 26

27 un semplice esempio: Read 2 Channel ADC Il codice sorgente Main function NA L14 27

28 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 1 File di libreria na_iodevice.c: la funzione beep NA L14 28

29 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 2 File di libreria na_iodevice.c: la funzione led Buzzer NA L14 29

30 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 3 File di libreria na_iodevice.c: la funzione presentation NA L14 30

31 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 4 File di libreria na_iodevice.c: la funzione testata NA L14 31

32 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 5 File di libreria na_iodevice.c: la funzione avviso se valore supera i 4 volt NA L14 32

33 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 6 File di libreria na_iodevice.c: la funzione leggi valore su canale 1 ADC, calcola e verifica ampiezza NA L14 33

34 un semplice esempio: Read 2 Channel ADC Il codice sorgente na_iodevice library-function - 7 File di libreria na_iodevice.c: la funzione leggi valore su canale 2 ADC, calcola e verifica ampiezza NA L14 34

35 In questa lezione abbiamo richiamato, in modo elementare e solo parzialmente, uno dei blocchi fondamentali per la costruzione modulare di un programma in C: la funzione; abbiamo visto che è fondamentale (indispensabile!) per la costruzione di un programma strutturato che può essere tendenzialmente privo di errori e facilmente correggibile. Il C permette di scrivere funzioni che possono essere richiamati in modo semplice ogni qual volta se ne presenti la necessità, in questo modo l uso delle funzioni semplifica i programmi. Le funzioni personali o quelle scritte da altri, possono essere riunite in una biblioteca (librerie) accessibile a più persone, che pertanto possono usarle senza doversi preoccupare di conoscere i dettagli implementativi. Consiglio a questo punto di rivedere quanto esposto sinora sul linguaggio C, in particolare ritornare sulla lezione 10 e riprendere tutta la presentazione introduttiva sul linguaggio C; cosiglio anche di riprendere tutti gli esempi sin qui svolti o proposti e riformularli in modo strutturato con l ausilio delle funzioni. NA L14 35

36 Un esercizio propsto Un pulsante, normalmente aperto, viene collegato ai capi del PIN RB1 del nostro micro (ricordarsi la condizione di collegamento pul-up attivo), visualizzare su display la scritta Pulsante close quando viene premuto il tasto e visualizzare anche il numero di volte in cui è stato premuto sino all istante attuale. Sviluppare l esercizio seguendo le semplici fasi di sviluppo: 1. Analisi del problema, schematizzazione a blocchi (se necessario), con schema elettrico finale operativo 2. Impostazione del Software e relativo Flow Chart 3. Codice sorgente in linguaggio C [CCS Pic PCWH Compilator] 4. Simulazione in ambiente Proteus VSM interfaccia ISIS 5. Presentazione del lavoro finale su demo-board opportuna (Gp_Mbus. AnxaPic4) 6. Opportuna documentazione conclusiva NA L14 36