Tutorial C18 - Sviluppo di un task base per PIC18

Embedded Software – Sviluppo di uno task base per PIC18
Tutorial
Embedded Software
Sviluppo di uno task base per PIC18
Pagina 1
Embedded Software – Sviluppo di uno task base per PIC18
Sommario
1.
INTRODUZIONE .................................................................................................................................................. 3
2.
COSA CI SERVE? .................................................................................................................................................. 3
3.
LED BLINKING ..................................................................................................................................................... 4
4.
CREAZIONE DEL TASK ......................................................................................................................................... 4
Pagina 2
Embedded Software – Sviluppo di uno task base per PIC18
1. Introduzione
Questa guida si propone di illustrare lo sviluppo di un semplicissimo task adatto a girare sulla
struttura di scheduler proposta nel tutorial “Sviluppo di uno scheduler di base per PIC18”.
L’esempio ci illustrerà come lo scheduler ci fornisca i servizi di base per gestire il nostro task. In
questa guida si farà uso di MPLab IDE 8.87 come ambiente di sviluppo e di MPLab C18 Student
Edition come compilatore. Entrambi i prodotti sono free e liberamente scaricabili dal sito web
della Microchip Technology.
2. Cosa ci serve?
Come nel caso del tutorial citato nell’introduzione, lo sviluppo di questa applicazione di esempio è
basato sul PIC18F8722. Non mi dilungherò nella descrizione delle periferiche del micro, dato che
sono state già elencate in tutorial precedenti e nel caso specifico non è di interesse. Per fare girare
l’esempio in esame occorre una scheda con un PIC18F8722, oppure è possibile usare MPLAB SIM,
il simulatore integrato in MPLAB IDE.
Le risorse hardware necessari invece sono:
-
MPLab IDE 8.87 o superiore,
MPLab C18 Student Edition 3.40 o superiore.
Potete scaricare entrambi i prodotti dal sito della Microchip (www.microchip.com).
Figura 2.1 Logo di MPLab IDE
Pagina 3
Embedded Software – Sviluppo di uno task base per PIC18
3. LED Blinking
Nel tutorial “Sviluppo di uno scheduler di base per PIC18” è stato presentato il progetto di un
semplicissimo scheduler per PIC18 di tipo FCFS. Su questo primordiale oggetto baseremo lo
sviluppo di un semplice task per far lampeggiare un LED alla frequenza di un Hertz. Molti si
chiederanno come mai generare una simile impalcatura per far semplicemente lampeggiare un
LED, risultato che si può facilmente ottenere con un while e poche istruzioni all’interno.
Chiaramente quest’esempio è puramente didattico, ma una volta generato anche il secondo task
apparirà molto più chiaro come mai questo tipo di approccio è preferibile, specialmente se ciò che
si intende fare è più che un semplice lampeggio di LED.
4. Creazione del Task
Il task in esame è talmente semplice che si può esaminare direttamente l’implementazione. Il task
che ci proponiamo di realizzare è costituito dalla seguente coppia di file:
• LedTask.c
• LedTask.h
Partiamo dalla descrizione del file di intestazione. Ricordiamoci che in ogni progetto ben
strutturato ad un file .c dovrebbe sempre corrispondere un file .h (con l’eccezione di main.c).
L’header contiene tutte le inclusioni relative al componente, le define, tutti i tipi e le strutture e
l’elenco delle variabili e delle funzioni esportate verso l’esterno.
Il listato 4.1 riporta l’header file del task LedTask. Analizziamone la struttura partendo dall’inizio.
Per prima cosa vengono importati all’interno del componente i vari servizi di base: le definizioni
specifiche della famiglia di microcontrollore (pic18cxxx.h), i servizi dello scheduler e i servizi del
componente di inizializzazione. Successivamente viene definita, tramite direttiva per il
preprocessore, una costante che ci servirà all’interno dell’implementazione: BLINK_PERIOD_MS,
che costituisce il periodo base per il lampeggio in ms. Notate che le costanti temporali sono
sempre riferite al tempo di scheduling, in modo da poter utilizzare valori coerenti con l’unità di
misura dichiarata nel nome (questo dovrebbe essere, in linea di principio, fatto sempre, anche per
le costanti non temporali). A questo punto l’header dichiara l’esportazione di una variabile e di
una funzione. La variabile è la variabile di stato del task, che verrà utilizzata nel task di controllo,
mentre la funzione è l’implementazione del task stesso.
Passiamo adesso alla effettiva implementazione in c. Il listato 4.2 riporta la funzione base del task
che genera il lampeggio. L’implementazione è estremamente semplice: dopo aver transitato dalla
fase di inizializzazione (dove di fatto non si inizializza nulla, dato che le uniche inizializzazione
necessarie a questo task sono già eseguite in fase di startup), si passa subito allo stato di running.
Pagina 4
Embedded Software – Sviluppo di uno task base per PIC18
#ifndef _LED_TASK_
#define _LED_TASK_
/************************************************************************
* Includes
************************************************************************/
#include <p18cxxx.h>
#include "Source\inc\Scheduler.h"
#include "Source\inc\SystemInit.h"
/************************************************************************
* Defines
************************************************************************/
/* Blinking period */
#define BLINK_PERIOD_MS
(unsigned int)((1000)/SCHEDULING_TIME_MS)
/************************************************************************
* Typedef
************************************************************************/
/************************************************************************
* Global Variables
************************************************************************/
/* Task State Variable */
extern TaskStateType LedTaskState;
/************************************************************************
* Function
************************************************************************/
/* Led task */
void LedTask (void);
#endif
Listato 4.1 Header file del task LedTask.
Qui viene gestito il contatore BlinkCounter (intero senza segno, static alla funzione stessa), per
capire, basandosi sulla base tempi dello scheduler, ogni quando è trascorso un tempo pari alla
costante di blinking (in questo caso un second). Arrivati a questa condizione si inverte lo stato del
LED e si azzera il contatore, in modo da far partire un nuovo ciclo.
Pagina 5
Embedded Software – Sviluppo di uno task base per PIC18
void LedTask (void)
{
/* Led blink Counter */
static unsigned int BlinkCounter = 0;
switch (MainSystemState)
{
/* Initialization phase fo LedTask */
case InitializationState:
/* Initialization Complete */
LedTaskState = InitializationComplete;
break;
/* System Normal operaion Phase */
case RunningState:
/* Increment Counter */
BlinkCounter++;
/* If the counter overflows */
if (BlinkCounter >= BLINK_PERIOD_MS)
{
/* Reset Counter */
BlinkCounter = 0;
/* Toggle LED2 */
LED2 = !LED2;
}
break;
/* System low consumption Phase */
case LowPowerState:
break;
/* Default */
default:
break;
}
}
Listato 4.2 Funzione LedTask.
Pagina 6
Embedded Software – Sviluppo di uno task base per PIC18
A questo punto non rimane altro da fare che inserire la chiamata al task all’interno dello scheduler
(in scheduler.c, MainScheduler) e gestire opportunamente la variabile di stato del task nella
funzione di controllo (SystemTask).
Per testare il funzionamento, se non avete a disposizione una demoboard, è possibile utilizzare
anche il simulatore integrato in MPLab (MPLAB SIM). Per farlo è sufficiente selezionare la relativa
opzione dalla voce Debugger nel menù di MPLab e selezionare MPLab SIM, come illustrato in
figura 4.1.
Figura 4.1 Attivazione di MPLab SIM
Pagina 7