|
Le multitàąche avec pic18f452 a l'aide d'un noyau temps réel( Télécharger le fichier original )par Abdnour YOUBI Université des Sciences et Techniques d' Oran - ingénieur d'état en electronique 2007 |
Chapitre VLes ressource « Software » de PICOS18 1- L'environnement de développement 1-1 Les sources du projet les fichiers sources du noyau et de l'application sont représenté comme la figure indique. Voici à quoi correspond chacun de ces fichiers
1- 1-1 Include Comme son nom l'indique ce répertoire contient l'ensemble des headers du noyau PICos18. Les headers propres à l'application et aux drivers se trouveront dans les répertoires propres aux applications (sous Project). Il existe un header spécifique pour chaque sous-ensemble du noyau : alarmes, événements, interruption et processus. Le fichier device.h contient les définitions génériques du noyau comme les définitions des valeurs de retour des fonctions du noyau. 1-1-2 Kernel Vous trouverez sous ce répertoire toutes les sources du noyau. Les fichiers C correspondent aux services du noyau (l'API), et le fichier kernel.asm, seul fichier assembleur de PICos18, réunit l'ensemble des fonctions propres au noyau, c'est-à-dire les algorithmes de scheduler, l'ordonancement des tâches et le gestionnaire d'erreurs. Les sources sont fournies à titre d'information ou si vous souhaitez les modifier pour vos besoins propres. Pour vous permettre d'utiliser PICos18 plus facilement, nous y avons ajouter le noyau sous forme de librairie : picos18.lib. De plus les codes d'amorce du compilateur (runtime) fournis par Microchip ne sont pas adaptés à PICos18, nous avons donc choisi de les adapter en conséquence. Ils sont fournis sous forme de fichier .o (comme PICos18iz.o). Vous n'avez pas à vous souciez de la librairie picos18.lib et des fichiers d'amorce, ils sont automatiquement associés à votre projet par PICos18 ! 1-1-3 Linker Lorsque vous construisez votre application avec PICos18, vous écrivez votre code en language C. Par la suite il convient de compiler votre application avec C18 (créer chaque fichier .o correspondant à chaque fichier .c) puis de les lier entre eux à l'aide du linker. La façon de lier les fichiers .o est paramétrable, et elle est décrite dans les fichiers .lkr de ce répertoire. Pour chaque type de processeurs remarquables dans la famille PIC18, il est fourni un fichier lkr pour vous éviter de gérer cette partie délicate de l'étape de compilation. Pour chaque nouveau PIC18 géré par un PICos18, un nouveau script de linker se verra ajouter à ce répertoire au fil du temps. 1-1-4 Project/MyApp Ce répertoire contient les fichiers nécessaires à la création de tout projet avec PICos18. Comme vous pouvez le constater il n'y a que très peu de fichiers : le main.c qui est le premier fichier applicatif exécuté par PICos18, le fichier int.c qui rassemble les routines d'interruptions et d'interruptions rapides, le fichier taskdesc.c qui décrit précisément tous les éléments de votre application (alarmes, compteurs, caractéristiques de vos tâches, ...), et un fichier C par tâche de l'application. 1-1-5 Project/Tutorial Le tutorial s'appuie sur la réalisation d'une application type sous PICos18. Tout au long des différents chapitres vous allez découvrir comment programmer sous PICos18 et comment construire vos applications. Les fichiers présents sous ce répertoire sont ceux de l'application finale, une fois terminée. Ceci apporte un support concrêt à ce tutorial en vous fournissant le code source de l'application de test. 2- La chaîne de compilation Microchip Vousavons programmer notre application en C sous PICos18. Toutefois le noyau luimême composé de fichiers en C pour les services par exemple et de fichiers écrits en assembleur comme fichier kernel.asm. Ces différents fichiers devront être compilés ou assemblés puis liés afin d'obtenir un seul fichier final : le fichier HEX qui pourra être chargé dans le PIC18.
La chaîne de compilation Microchip se décompose en 3 éléments : l'assembleur MPASM qui permet de transformer un fichier ASM en fichier O le compilateur MCC18 qui permet de transformer un fichier C en un fichier O le linkeur MPLINK qui permet de fusionner tous les fichiers O en un unique fichierHEX Le fichier dit «script du linkeur» (File.lkr sur le schéma ci-dessus) est essentiel pour permettre de générer le fichier HEX. En effet le contenu des fichiers O ne permet pas encore de savoir où va être logé le code en mémoire. Par exemple la fonction main() a été traduite en un langage compréhensible par le PIC18 mais pas encore positionné à un endroit précis de la mémoire. C'est le rôle du script du linkeur que de préciser les emplacements de chaque portion de code en ROM et chaque portion de variable en RAM. PICos18 est fourni avec des scripts de linker pré-établi pour les PIC les plus utilisés de la famille PICos18. Vous pouvez vous en inspirer pour réaliser votre propre script ou bien pour l'adapter à un nouveau PIC18. Il existe d'autres types de fichiers générés pendant la compilation et l'assemblage des fichiers du projet (*.map, *.lst, *.cod). Référez vous aux documents Microchip pour de plus amples informations. Ce tutorial est destiné à la compréhension et la prise en main du logiciel PICos18. Pour des raisons techniques, il a été réalisé sous MPLABÒ et compilé avec le compilateur C18 pour cible PIC18F452. Nous tenons à préciser que ce tutorial a été entièrement réalisé et testé sous le système d'exploitation Microsoft WindowsÔ 98/NT/2K/XP, ainsi qu'avec l'environnement de développement MPLABÒ v7.00 et le compilateur C18 v2.40 de Microchip (version gratuite). Ces différents logiciels peuvent être téléchargés depuis le site web de Microchip Technology Inc. : www.microchip.com. 3- les fichiers source : Les fichiers sources du noyau nécessaires à l'application sont (Source Files.*c) :
3- 1 Le fichier « INT.C » : Ce fichier prend en charge la gestion de la totalité des interruptions. Il faut savoir que le PIC18 gère 2 types d'interruptions : les interruptions de basses priorités (IT_vector_low) et celles de hautes priorités (IT_vector_high). A quoi cela peut-il bien servir....?! En fait il faut considérer que le noyau PICos18 effectue parfois des opérations délicates sur les tâches et qu'il n'est pas souhaitable qu'il soit interrompu par une IT pendant son traitement (par exemple pendant la préemption d'une nouvelle tâche sur la tâche courante). Du coup pour faire simple on a choisi de rendre le noyau non-interruptible. Or on a vu que le déterminisme de PICos18 était de 50us (ce qu'on appelle le temps de latence), donc il existe une zone d'ombre, un black-out de 50 us pendant laquelle une IT ne sera pas détectée. Pour éviter cela on utilise les interruptions rapides ("fast interrupts") du PIC18, qui utilise un mécanisme hardware pour la sauvegarde des registres élémentaires (comme WREG, STATUS, ...). Hélas pour utiliser les interruptions rapides du PIC18, il faut écrire un code C excrément léger, presque trivial. Si l'on a besoin d'un code plus complexe, qui appelle par exemple d'autres fonctions C, il faut impérativement utiliser les interruptions lentes... avec toutefois le risque d'être mis en attente pendant 50uS ! . (6) 3- 2 Le fichier MAIN.C : Selon la norme OSEK ce fichier main ne fait pas partie de l'OS mais il est bel et bien de la partie applicative, et c'est à lui que revient le rôle de lancer le noyau (car il est en effet possible de stopper et de lancer le noyau depuis le fichier main). Dans le fichier main on trouve une fonction Init () qui va nous permettre de paramétrer la fréquence de fonctionnement sans avoir besoin d'ouvrir la datasheet du PIC18 : Void Init (void) { FSR0H = 0; FSR0L = 0; /* User setting: actual PIC frequency */ Tmr0.lt = _40MHZ; /* Timer OFF - Enabled by Kernel */ T0CON = 0x08; TMR0H = Tmr0.bt [1]; TMR0L = Tmr0.bt [0]; } La ligne en gras permet de régler la fréquence INTERNE du PIC18. En effet celui-ci possède une PLL par 4, que nous pouvons activer ou non. Une utilisation classique des PIC18 consiste à les équiper d'un quartz externe de 10 MHz et de 2 capacités de 15 pF, puis d'activer la PLL interne afin d'obtenir une fréquence interne de 40 MHz. Le pipeline interne du processeur étant de niveau 4, le pire cas de fonctionnement du PIC18 est de 10 MIPS, soit 10 millions d'instructions par secondes (voir la datasheet du composant). Cela en fait un microcontrôleur 8 bits faible cout puissant et bien armé en périphérique. (6) 3-3 Taskdesc.c : Ce fichier contient tout ce qui concerne notre application on trouve dans ce fichier, comme par exemple : l'identifiant de la tâche, sa priorité, sa pile logicielle, les alarmes nécessaires au projet, ... 3-3-1 On trouve tout d'abord la liste des alarmes de l'application: AlarmObject Alarm_list [ ] = { * First task *******************************************************************/ {
} }; Ce tableau constitue la liste des alarmes, chaque alarme étant représentée par une structure. Une alarme est une sorte d'objet TIMER géré de façon logicielle par le noyau. En fait PICos18 possède une référence de temps de 1ms, générée de façon hardware et logicielle. De cette façon il est possible de créer une alarme logicielle basée sur cette base de temps de 1ms : les alarmes. Une alarme est associé à un compteur (ici Counter_kernel qui est la référence de 1ms) et une tâche (dont l'identifiant est TASK0_ID). Lorsque l'alarme atteint une valeur de seuil elle peut poster un événement à cette tâche (ALARM_EVENT dans cet exemple) ou bien appeler une fonction en C. 3-3-2 - On trouve ensuite la liste des ressources de l'application: /****************************************************************** * COUNTER & ALARM DEFINITION ******************************************************************/ Resource Resource_list[] = { { 10, /* priority */ 0, /* Task prio */ 0, /* lock */ } }; Une ressource est un autre objet géré par le noyau. Une ressource est généralement un périphérique partagé par plusieurs tâches, par exemple un port 8 bits du PIC18. Elle possède une priorité (priority) et peut être verrouillée (lock) par une tâche (Task- prio). Ainsi lorsqu'une tâche veut avoir accès à la ressource (e.g un port 8 bits) elle y accède via la ressource définie et empêche ainsi pendant un cours instant à toute autre tâche d'y avoir accès. La priorité de la ressource sera égale à une valeur supérieure à celle de la tache la plus prioritaire des taches qui utiliseront la ressource. (6) 3-3-3-3 On trouve ensuite la liste des piles logicielles de l'application: Il existe 2 types de variables : les variables statiques et les variables automatiques...de façon plus compréhensible nous parlerons de variables globales et de variables locales, même si la correspondance n'est pas tout à fait exacte. Les variables globales (c'est-à-dire placées en dehors de toutes fonctions C) sont placées en RAM à une adresse absolue, adresse qui ne change jamais. Les variables locales (déclarées au sein de fonctions C) sont elles compilées par MCC18 de sorte de se retrouver stockées dans une zone mémoire dite pile logicielle. Une pile logicielle est une zone mémoire dynamique, vivante en quelques sortes. Lorsque l'on rentre dans une fonction C, on commence par empiler sur cette zone les variables locales, et lorsque l'on quitte la fonction C, on dépile l'espace réservé aux variables locales libérant ainsi de la mémoire. Ce type de fonctionnement permet de gagner beaucoup de place mémoire lorsqu'il existe de nombreuses fonctions écrites en C, au prix d'un surplus de code minimal. PICos18 est compatible avec la gestion de la pile logicielle faite par MCC18. Chaque tâche possède alors sa propre pile logicielle, si bien que chacune des tâches de l'application peut travailler de façon autonome dans son propre espace de travail, sans perturber les autres tâches. De plus PICos18 possède un mécanisme de détection de débordement mémoire, ce qui arrive lorsqu'une pile logicielle commence à déborder sur celle d'une autre tâche. /********************************************************************** * TASK & STACK DEFINITION **********************************************************************/ #define DEFAULT_STACK_SIZE 128 DeclareTask (TASK0); volatile unsigned char stack0[DEFAULT_STACK_SIZE]; Chaque fois que nous ajoutons une tâche à notre application, il faut ajouter une pile en copiant la ligne ci-dessus et en changeant le nom de la nouvelle pile (par stack1 par exemple). . Une taille de pile minimale sous PICos18 est 64. . Une taille de pile maximale est 256. . Une taille de pile raisonnable est 128. Seules ces 3 valeurs sont possibles, il ne faut pas essayer d'utiliser une taille de valeur intermédiaire, la compilateur MCC18 ne pourrait pas la gérer. De plus une pile doit toujours se trouver sur une même bank, et pas à cheval sur 2 banks. (6) 3-3-4 On trouve ensuite la liste des tâches de l'application: /********************************************************************** * task 0 **********************************************************************/ rom_desc_tsk rom_desc_task0 = { TASK0_ PRIO, /* prioinit from 0 to 15 */ stack0, /* stack address (16 bits) */ TASK0, /* start address (16 bits) */ READY, /* state at init phase */ TASK0_ ID, /* id_tsk from 1 to 15 */ sizeof(stack0) /* stack size (16 bits) */ }; Nous avons déjà abordé le descripteur de tâche, voici plus en détail le sens de chaque champ : prioinit : c'est la priorité de la tâche comprise entre 1 et 15 inclus. 1 est la priorité la plus faible et 15 la plus forte. La priorité 0 est réservée au noyau lui-même. stack address : c'est la pile logicielle de la tâche. Chaque tâche possède une pile logicielle sur laquelle seront stockée les variables locales au cours de l'exécution, mais aussi tout le contexte du PIC18 (registres, pile hardware) lorsque la tâche n'est pas en cours d'exécution. start address : c'est le nom de notre tâche, ou encore le nom de la fonction d'entrée de notre tâche. Le compilateur le traduit en une adresse, utilisée par le noyau pour accéder la première fois à notre tâche. state init : c'est l'état initial de la tâche. Dans ce cas il vaut READY ce qui signifie que la tâche est opérationnelle au démarrage de l'application. stack size : c'est la taille de la pile logicielle attribuée. Cela sert au noyau afin de vérifier à tout moment qu'il n'y a aucun débordement mémoire d'une pile sur l'autre. (6) 4- Les fichiers d'inclusion (Header File * .h) Comme son nom l'indique ce répertoire contient l'ensemble des headers du noyau PICos18. Les headers propres à l'application et aux drivers se trouveront dans les répertoires propres aux applications (sous Project). Il existe un header spécifique pour chaque sous-ensemble du noyau : alarmes, événements, interruption et processus. Les fichiers d'inclusion ou d'en tête *.h (header) contiennent pour l'essentiel cinq types d'informations :
|
|
