Con application maestro è possibile utilizzare moduli firmware preconfezionati all’interno di una qualsiasi applicazione basata sui pic16/pic18.
Vedremo come utilizzare Application Maestro per generare moduli integrabili con un progetto d’esempio sviluppato tramite MPLAB IDE. Application Maestro è un applicativo stand-alone facente parte dei tool di sviluppo di Microchip per i microcontrollori delle famiglie PIC16/18. Esso permette di usare dei moduli firmware preconfezionati da Microchip e di configurarli tramite un’interfaccia grafica in modo da utilizzarli all’interno di una qualsiasi applicazione. I moduli firmware riguardano per lo più l’utilizzo di molte delle periferiche dei PIC16/PIC18, e sono disponibili nella maggior parte dei casi nel linguaggio Assembly. Alcuni moduli sono disponibili nel linguaggio C, sebbene in questo caso l’esistenza di librerie già fornite con i vari compilatori (in particolare il C18 per i PIC18) li rendano meno utili. Un elenco dei moduli principali attualmente resi disponibili da Microchip è riportato nella tabella in figura 1.
Figura 1: principali moduli disponibili in Application Maestro.
L’utilizzo di moduli preconfezionati ed adeguatamante testati può rappresentare un notevole risparmio di tempo oltre a garantire il riutilizzo del codice tipico delle librerie. Alcune delle periferiche per le quali sono stati sviluppati dei moduli sono in effetti non molto semplici da usare, come l’interfaccia I2C od il modulo CAN. Rispetto alle librerie di codice di uso comune, con Maestro si ha il vantaggio di poterle configurare tramite una GUI, permettendo di selezionare ad esempio la velocità di clock dell’applicazione, le dimensioni dei buffer e altri parametri a seconda del modulo specifico.
Utilizzo di Microchip Application Maestro
Nella subdirectory Modules di Maestro sono presenti i file dei vari moduli installati. Per ogni modulo sono presenti diversi file, tra cui uno o più file Assembly o C, i relativi file di definizione.inc o.h rispettivamente, un pdf con le istruzioni per l’utilizzo del modulo nelle nostre applicazioni con dei file di esempio. Se viene generato un file linker sarà presente un file di esempio di utilizzo, denominato <nome_modulo>.lkr.txt. Per ogni modulo è presente inoltre un file con estensione .cls nel quale sono compilate le informazioni usate dalla GUI riguardo a nome e versione del modulo, parametri configurabili e file prodotti. Possiamo aggiungere nuovi moduli a quelli forniti con l’installazione di Maestro, mano a mano che questi vengono resi disponibili sul sito di Microchip. Per aggiungere un modulo basta copiare i suoi file nella subdirectory Modules, quindi lanciare la GUI e selezionare File>Open Module(s): nella finestra di dialogo selezioniamo il file.cls del nuovo modulo e premiamo OK. Vediamo ora come si seleziona e configura un modulo di Maestro in modo da poterlo utilizzare in un’applicazione. Dalla GUI di Maestro facciamo click & drag sul modulo che vogliamo utilizzare presente nel pannello di sinistra (Available Modules): rilasciamo l’icona del modulo nel pannello superiore destro (Selected Modules). Alter nativamente possiamo usare la voce di menu Edit>Add od il tasto Ins, od ancora l’icona relativa della toolbar. Come vediamo è possibile utilizzare più moduli all’interno di una singola applicazione (ma solo uno di un certo tipo). Nel pannello inferiore di destra compariranno i parametri configurabili del modulo. Per modificare i valori di un dato parametro facciamo doppio click sullo stesso: comparirà una finestra di dialogo in cui potremo selezionare un valore da una lista o immettere un valore numerico a seconda del tipo di parametro. Non dimentichiamo di immettere la velocità di clock della nostra applicazione nella casella Clock presente nella toolbar. Infine, per generare il codice selezioniamo la voce di menu Tools>Generate Code o l’icona relativa presente nella toolbar. Nella finestra che apparirà verrà richiesta la directory in cui salvare i file generati: scegliamo la directory dell’applicazione se questa esiste già, od una directory a scelta.
Un esempio di progetto con Application Maestro
Vediamo ora un esempio pratico di utilizzo di Application Maestro all’interno di una applicazione sviluppata con MPLAB IDE. Per fare un esempio pratico con una periferica ben nota, sceglieremo di utilizzare il modulo di Maestro per la gestione dell’USART in linguaggio Assembly. Questo modulo fornisce un insieme di funzioni ed altre risorse con cui è possibile gestire l’USART dei PIC tramite funzioni di alto livello semplificandone l’utilizzo.
Tra le caratteristiche di questo modulo menzioniamo le seguenti:
➤ gestione della trasmissione e ricezione dati tramite interrupt, permettendo così l’esecuzione di altri task da parte del PIC
➤ uso di buffer FIFO (First In-First Out) sia per la trasmissione che per la ricezione;
➤ codice rilocabile e linkabile, in modo da facilitare l’integrazione con il resto dell’applicazione;
➤ Supporto sia dei PIC16 che dei PIC18. Generiamo innanzitutto un nuovo progetto tramite il Project wizard di MPLAB (dalla voce di menu Project>Project Wizard). Selezioniamo PIC16F876 (ma possiamo facilmente adattare il codice per un qualsiasi altro PIC dotato di USART) come processore e scegliamo una nuova directory in cui generare i file del progetto, ad esempio M_USART. Una volta creato il progetto, aggiungiamo dal pannello del Workspace il file linker 16F876.lkr (click di destra su Linker Scripts, quindi click su Add file) ed il file principale dell’applicazione d’esempio M_USART.asm (click di destra su Source Files, quindi click su Add file).
Figura 2: GUI di Application Maestro.
list p=16f876
include <P16f876.INC>
; CONFIG WORD
__CONFIG _HS_OSC & _WDT_OFF
& _LVP_OFF & _BODEN_ON & _CP_OFF
& _CPD_OFF & _PWRTE_ON
include “UARTInt.inc”
;*** variabili
; salvataggio del contesto
ISR_CS UDATA_SHR
ISR_W RES 01
ISR_STATUS RES 02
#define ISR_PCLATH ISR_STATUS+1
;*******************************
;*** CODICE
;*******************************
; RESET routine
Reset CODE 0x00
goto Main
; Interrupt vector
INTserv CODE 0x04
nop
;*******************************
; INTERRUPT SERVICE ROUTINES
;*******************************
ISRV CODE 0x05
ISR
; salva il contesto
movwf ISR_W
swapf STATUS,W
movwf ISR_STATUS
movfw PCLATH
movwf ISR_PCLATH
; ISR relativa all’USART
pagesel UARTIntISR
call UARTIntISR
;restore del contesto
movfw ISR_PCLATH
movwf PCLATH
swapf ISR_STATUS,W
movwf STATUS
swapf ISR_W,f
swapf ISR_W,W
retfie
;*******************************
; FINE ISR
;*******************************
; routine principale
;*******************************
START CODE
Main
; inizializzazioni porte ecc.
; [...]
pagesel UARTIntInit
call UARTIntInit
; Stringa di benvenuto tramite USART
movlw ‘F’
pagesel UARTIntPutCh
call UARTIntPutCh
movlw ‘W’
call UARTIntPutCh
movlw ‘2’
call UARTIntPutCh
movlw ‘2‘
call UARTIntPutCh
; Loop principale
MainRXLoop
;Controlla se il buffer RX è pieno
banksel vUARTIntStatus
btfss vUARTIntStatus,UARTIntRxBufFul
; qui può eseguire altri task, grazie alla ISR
; [...]
goto MainRXLoop
;Legge i dati ricevuti nel buffer RX
MainReadCh
Pagesel UARTIntGetCh
call UARTIntGetCh
;ECHO del carattere letto dal buffer
banksel vUARTIntStatus
; attende che il buffer TX sia vuoto
MainWaitForTxBufEmpty
btfsc vUARTIntStatus,UARTIntTxBufFul
goto MainWaitForTxBufEmpty
; trasmette il carattere (in W)
Pagesel UARTIntPutCh
call UARTIntPutCh
;Se ci sono altri caratteri nel buffer li legge
banksel vUARTIntStatus
btfss vUARTIntStatus,UARTIntRxBufEmpty
goto MainReadCh
; altrimenti rifà il loop principale
goto MainRXLoop
END
| Listato 1 |
Uso di Application Maestro per generare il modulo USART
Dobbiamo configurare e generare il codice del modulo USART tramite Application Maestro: selezioniamo il modulo USART dal pannello dei moduli disponibili. Clicchiamo sulla voce di menu Edit>Add (o premiamo Ins) per ritrovare il modulo nel pannello di destra, tra i moduli selezionati. Nel pannello inferiore sono visualizzati i parametri configurabili del modulo (si faccia riferimento alla figura 3).
Figura 3: configurazione del modulo USART in Application Maestro.
Maestro può essere installato come applicazione standalone, una volta scaricato il file MpAMvx.y.z.exe dal sito di Microchip, www.microchip.com. I file dell’applicazione verranno installati normalmente nella directory C:\Programmi\Microchip\MpAM. Maestro è anche fornito di default nelle distribuzioni complete dell’ambiente di sviluppo MPLAB IDE di Microchip. In figura 2 vediamo come appare la GUI di Maestro al lancio dell’applicazione.
Facciamo doppio click sul parametro Baud Rate per poterlo modificare: nella finestra di dialogo che appare immettiamo ad esempio il valore 38400. Cambiamo anche la dimensione dei buffer in modo da portarli a 16 bit. Selezioniamo una velocità di clock del PIC di 20 MHz dalla toolbar. Alla fine dovremo avere la configurazione raffigurata in figura 3. Premiamo infine Tools>Generate Code per generare il codice configurato del modulo: alla richiesta della directory in cui copiare i file selezioniamo la directory del progetto MPLAB, M_USART.
Integrazione del modulo nell’applicazione
A questo punto possiamo anche chiudere Application Maestro. Torniamo all’IDE di MPLAB e dal pannello del progetto aggiungiamo il file sorgente UARTInt.asm. Questo è il file di codice principale del modulo USART. Alla fine dovremo avere la configurazione di progetto raffigurata in figura 4.
Figura 4: configurazione del progetto in MPLAB IDE.
Per poter utilizzare le funzioni e le altre risorse definite nel modulo USART, dobbiamo includere il file di intestazione nel nostro codice sorgente:
in M_USART.asm ad esempio troveremo la riga:
include “UARTInt.inc” Osserviamo che il file UARTInt.asm includerà automaticamente a sua volta il file 16UARTI.asm o 18UARTI.asm a seconda che il micro selezionato appartenga alla famiglia PIC16 o PIC18. Questi due file contengono le implementazioni delle funzioni del modulo specifiche per le diverse famiglie.
Uso delle funzioni del modulo USART
Il modulo USART definisce diverse funzioni per la ricezione e trasmissione tramite USART, oltre a delle macro utili per gestire i bit di configurazione della periferica. Infine alloca dello spazio nella memoria RAM dedicato ai buffer di RX e TX ed ad altre variabili. Per i particolari si veda il pdf UARTInt.ReadMe.pdf, una copia del quale è presente nella directory di generazione del modulo.
Le funzioni definite dal modulo sono le seguenti:
➤ UARTIntInit: inizializza l’USART (baud rate, interrupt) ed azzera i buffer.
➤ UARTIntISR: è la routine di gestione dell’interrupt dell’USART. Questa routine viene richiamata quando è presente un dato nel buffer HW dell’USART in ricezione, oppure quando il registro di trasmissione dell’UART è disponibile.
➤ UARTIntPutCh: scrive il contenuto del registro W nel buffer di trasmissione.
➤ UARTIntGetCh: scrive in W un carattere letto dal buffer di ricezione.
Nel file principale della nostra applicazione M_USART.asm (si veda il listato 1), dopo aver incluso il file di definizione del PIC16F876, definiamo i bit di configurazione del PIC con la direttiva __CONFIG. Notiamo che il file è del tipo rilocabile in modo da poter essere linkato con i sorgenti del modulo USART. In particolare osserviamo come viene definito il vettore di interruzione: questo deve essere necessariamente collocato all’indirizzo 0x04 (per i PIC16), cosa che viene fatta tramite la direttiva code:
INTserv CODE 0x04 NOP ISRV CODE 0x05 ISR ; salva il contesto movwf ISR_W ;[...]
Normalmente l’istruzione presente all’indirizzo 0x04 è una GOTO <ind. routine ISR>. In questo caso però abbiamo a che fare con codice rilocabile, per cui è possibile che l’indirizzo della ISR richieda un valore di PCLATH diverso dall’attuale. Poiché il file linker 16F876.lkr riserva una sola locazione al vettore, se usiamo una NOP siamo sicuri che la successiva istruzione che verrà eseguita sarà quella presente alla locazione 0x05, dove abbiamo stabilito l’inizio dell’ISR. Al momento l’unica routine di interrupt definita è quella for nita con il modulo USART, così richiamata:
pagesel UARTIntISR call UARTIntISR
Ancora, osserviamo che avendo a che fare con codice rilocabile, è necessario usare la direttiva Assembler pagesel.
Il codice prosegue con l’inizializzazione del PIC (porte e quant’altro), dopodichè viene inizializzata l’USART con la chiamata seguente:
call UARTIntInit
Per inviare un carattere usiamo il codice seguente:
movlw ‘F’
pagesel UARTIntPutCh call UARTIntPutCh
Nel loop principale MainRXLoop, viene controllato se il buffer RX è pieno: in questo caso si leggono i caratteri del buffer uno alla volta tramite la funzione UAR-TIntGetCh. Se ne fa l’echo via USART e così via finchè il buffer RX non risulta vuoto. Si noti che all’inter no del loop principale il PIC può svolgere altri task nell’attesa che il buffer di ricezione venga riempito grazie all’ausilio della routine di interrupt UARTIntISR.
