JPN Cours RTOS STR912 Keil 21 Et 22 Novembre 2007

Microconotrôleur
RealTimeOperatingSystem
ARM
Cours ARM 21 et 22 novembre 2007
Introduction :
Beaucoup de choix dans les configurations pour les compilateurs, librairies, jeux
d’instructions…
Si on fait de mauvais choix, on peut aboutir à des différences de vitesse d’un facteur 50, avec
la même fréquence de clock.
Une des raisons de la migration des concepteurs vers les architectures ARM est le
développement des interfaces type CAN, Ethernet ou USB.
ARM : Advanced RISC Machines
- Commence en 1990
- 1991 conception de l’architecture ARM6
- 2000 : début de la production des chips
- 2004 : première année a dépasser le million de chips
- 2007 2.5 milliard de chips produits.
- 771 nouvelles versions de l’architecture développée en 2006
Les processeurs 32 bits sont entrain de prendre le dessus sur les autres, les 16 sont maintenant
plus chers sur le marché que les 32. Pour 7 euro, on peut obtenir un magnifique
microcontrôleur ARM.
On peut observer aussi au niveau du marché que la progression la plus importante est prévue
pour les chips embarqués (10x dans 5 ans)
Dans les applications qui demandent une faible consommation, l’objectif est de faire le
maximum de choses en un minimum de coups de clock et de repasser ensuite en mode basse
consommation.
Pour le choix d’un chip, on doit tenir compte de trois critères :

- Architecture ARM, quelle vitesse, quel mode, quel jeux d’instructions
- Construction du chip : vitesse de la mémoire et des bus.
- Compilation du code, vitesse et optimisation.
Dans la plupart des cas, une architecture ARM7 est suffisante, on peut utiliser l’architecture
ARM9, au-delà, (ARM11) c’est un peu lourd.
ARM est une architecture « chargement dans les registres »

La plupart des instructions se déroule en 1 cycle. On peut charger plusieurs registres en une
instruction, mais cela peut introduire un temps in-interruptible de 20 cycles ou plus, ce qui
peut être inacceptable pour un fonctionnement en temps réel. Il est préférable de réaliser cette
opération en plusieurs instructions (interruptibles).
Instructions conditionnelles : on peut crée des instructions conditionnelles qui remplacent
avantageusement un « if ». Plus rapide qu’un saut et permet un déroulement linéaire du
programme.
JPN 1/56 Novembre 2007

Microconotrôleur
ARM
Thumb
Le mode Thumb, on utilise un jeux d’instructions 32 bits diminué à 16 qui est
« décompressé » pour être utilisé par le core 32 bits.
Ce mode qui diminue la taille du code d’environ 30% et permet d’utiliser de la mémoire
extérieure 16 bits implique d’importantes limitations en terme de puissance d’instruction,
distance de saut, flexibilité de l’exécution conditionnelle du code, …
Ne pas utiliser sauf lors de l’utilisation de bus 16 bit ou d’une situation de restriction de
mémoire importante.
Thumb-2 est une norme ou le core « lit » directement les instructions 16 bits
Dans la terminologie ARM, on nomme Word les mots de 32 bits. Halfword les mots de 16
bits et byte les 8 bits.
Les variables de 32 bits sont systématiquement attribuées à des adresses multiples de 4. Dans
le cas de tailles de variables hétérogènes, il faut les classer par taille, ce qui évitera de définir
dans la mémoire des emplacements avec des trous entre les variables 8 et la prochaine de 32
p.exemple.
Comparaison entre les architectures ARM 7 et 9
Arm7 :
3 étapes dans le pipeline. Data et code sur le même bus interne, ce qui ralenti les transferts.
1.9 Clock Per Instruction
Jeux d’instruction ARM et Thumb
Arm 9 :
5 étapes dans le pipeline. Deux bus séparés pour data et instructions.
1.5 Clock Par Instruction
Jeux d’instruction ARM et Thumb

Microconotrôleur
ARM
Deux structures, la première orienté embarquée et la deuxième orientée application.
Cortex-M3 :
Semblable à l’ARM 3 mais avec un contrôleur d’interruption, le mode Thumb-2 et un temps
d’interruption réduit à la moitié du ARM 7. On peut assigner des zones mémoires utilisables
(et protéger le reste des action liées à l’interrupt) pour chaque interruption.
Interruptions :
Pas de contrôleur d’interruption.
Deux types d’interruptions :
- IRQ : interrution standard
- FIQ : interruption rapide, avec une plus haute priorité.
VIC Vectored Interrupt Controller

Microconotrôleur
ARM
L’architecture comporte un APB

Bridge qui permet au core de passer
à l’instruction suivante sans attendre
la fin de l’instruction p.ex d’écriture
sur le bus d’I/O plus lent. Ceci peut
générer des comportements non
désirés, si on masque une
interruption et qu’avant que cette
instruction soit complètement
effectuée, on passe à l’instruction
suivante et un interrupt peut arriver à
ce moment, alors que l’on avait en
principe protégé cette partie du code
contre elle.
TCM : Tidy Coupled Memory
On trouve des architectures multi-bridges qui permettent de multiplier les transferts

simultanés de données entre ethernet et un bloc mémoire, le DMA et un autre bloc, le core et
la flash, etc. tout cela dans le même temps.
Compilateurs :
Il existe de multiples distributions sous licence GNU, mais comme la plupart des concepteurs
de ces programmes viennent du monde 32 bits, ils sont souvent moins performants dans les
applications 16 bits (Thumb mode). Sinon, ils sont évidemment moins bons que Keil. (Si le
vendeur le dit, c’est que cela doit être vrai…)
Pour les compilateurs payants, on remarque des différences notoires, notamment dans les
vitesses d’exécution et taille du code produit.
Il est chaudement recommandé de ne pas faire d’assembleur dans les structures ARM
car on s’expose à une foule d’écueils et chausse-trappe pas piqués des vers.
Les choix d’architecture influencent les performances d’un facteur 1.5
Les choix de compilateur, options et code écrit peuvent diminuer dramatiquement les
performances d’un bon microcontrôleur facteur 50...

Microconotrôleur
ARM
Pratique :
Ne pas installer le Jtec avant d’avant d’avoir installé le software.
Copie du répertoire c:\Keil_ARM\ARM\Boards\Keil\MCBSTR9\ sur le bureau
Branchement des deux prises USB
Chargement du programme exemple : Blinky.Uv2
Compilation, chargement : Les leds doivent faire un chenillard mignon comme tout.
Program Size: Code=2264 RO-
data=96 RW-data=4 ZI-data=1292
Code: taille du code
RO-data : Read only (typiquement
écrit en flash)
RW data: Read Write écrit en
Flash et dans la ram
ZI-data : Zero initialized : variables
non initialisées.
modification des options de compilation :
ARM mode :
Switch global de la génération de
code
On peut choisir pour chaque
fonction __arm ou __thumb
Ex : viod wait(viod) __arm
Les blocs de mémoire

additionnels doivent être
déclarés dans ces cases

Microconotrôleur
ARM
Permet de spécifier des fichiers batch à lancer avant ou après la compilation.

Microconotrôleur
ARM
Permet le changement de
mode Thumb / ARM
Empêche la copie groupée de

valeur dans les registres, rend le
code plus « interruptible »
Liste des options qu’il faut mettre

pour lancer le simulator depuis le
mode dos dans cette configuration.
Le niveau d’optimisation permet le meilleur débuggage au niveau 0

Au niveau 3, le mode pas à pas n’est plus utilisable.

Microconotrôleur
ARM
Les options de débbuging en simulation sont plus étendues qu’en débbuging « hardware »
(p.ex. 2 « breakpoint » seulement)

Microconotrôleur
ARM
bouton de configuration de l’environnement de compilation.
Ces fenêtres permettent de

mofier les options de
placement de programme
(flash, …) de quel compilateur
on utilise (GNU p.ex mais non
consillé…)
Et des différents chemins des

programmes utilisés et produits de
compilation.

Microconotrôleur
ARM
Comparaison entre les modes de simulation et de « hardware debbuging ».

On peut acheter des cartes très chères qui ont du matériel de debuggage intégré, mais il est
beaucoup plus facile de le faire en soft.

Microconotrôleur
ARM
Commencer de zéro
Pour commencer un programme de zéro, il faut : Commencer un nouveau projet
Donner un nom.
Choisir la famille …

Microconotrôleur
ARM
Et le micro.

Microconotrôleur
ARM
Répondre oui à la question. Si on ne le fait pas, il va modifier la librairie originale, ce qui est
rarement une bonne idée.

Microconotrôleur
ARM

Microconotrôleur
ARM
On copie le code que l’on trouve dans « bloc 1 » du fichier read_me.txt:
On peut configurer toutes les options de compilation de manière différente pour chacun de
chips

Microconotrôleur
ARM
Création d’un répertoire pour nos fichiers de code
Ajout d’un fichier au projet : add file et choix de notre fichier

Microconotrôleur
ARM

Microconotrôleur
ARM
Option de debugging (baguette magique..)
On limite la vitesse à la vitesse du hard
Créer un répertoire opt dans l’onglet « ouput » et lst dans « listing »

Microconotrôleur
ARM
On peut ensuite compiler et lancer le débugger
La fonction clic droit Ö execution profiling Ö time peut afficher le temps d’exécution pour
chaque instruction.
Le compilateur indique, en mode simulation, le

temps total d’exécution du code. Un clic droit
dans la case du timer permet de le remettre à zéro
en tout temps lors de l’exécution pas à pas.

Microconotrôleur
ARM
Pour positionner un bit sur un port, on peut utiliser le registre IOSET avec les « 1 » qui vont
mettre les bits considérés à un et IOCLR « 1 » qui vont mettre les bits considérés à zéro.
On utilise la plupart du temps des

variables statiques pour faciliter le
debbuging (variables globales au
lieu de locales, elles seront ainsi
accessibles en tout temps.)

Microconotrôleur
ARM
On peut visualiser les signaux en appuyant sur le bouton « logic analyzer ».

Microconotrôleur
ARM
On peut modifier avec un clic sur « setup » les options d’affichage

Microconotrôleur
ARM
On peut ensuite lancer le programme et on voit alors le signal au cours du temps et on peut en
positionnant la souris sur le signal pour voir à quel moment du déroulement on se trouve, le
temps entre la position de la souris et le curseur.

Microconotrôleur
ARM
Pour insérer des Breakpoints conditionnels, on va dans le menu « Debug »
On indique la variable en question et la valeur à

laquelle on veut que le programme fasse un break.
!! Cette opération fait planter Keil
magistralement !!
Nous aurons des informations ultérieures pour
expliquer ce comportement hautement non
professionnel. L’info est arrivée et il semble que
l’on doit mettre _break_=1. Personnellement, cela
n’a pas marché.
Retarget.c : permet de re-spécifier des fonctions déjà présentes dans les une librairie.
(exemple : on peut se faire un printf() personnel pour envoyer les messages sur CAN bus.)

Microconotrôleur
ARM
RTOS : Real Time Operating System
Les développements :
La plupart du temps, les développements se font sur des microcontrôleurs normaux et c’est
après coup que l’on va faire évoluer le système vers du temps réel, car le temps de cycle du
microcontrôleur qui paraissait négligeable et « visitait » suffisamment souvent les entrées
pour que le process « ait l’air » temps réel, devient trop important.(A force d’ajouter des
fonctions.)
Pour palier à ces problèmes, et avoir un comportement « temps réel » on ajoute une couche
d’abstraction qui va gérer les évènements et gérer le temps de calcul pour chacune des tâches
à exécuter en fonction des priorités qu’on leur a attribuées.
Le moindre système temps réel a une hiérarchisation de 255 positions pour les tâches (8 bits
min).
Définitions :
Soft realtime : système qui supporte qu’il y ait des retard et erreurs
Hard real time : système qui doit assurer un service impeccable sous peine de mort.
Le RTOS peut souvent dialoguer avec les tâches via une mailbox où chacun dépose des
messages que l’autre lit lorsqu’il est actif.
Toute tâche est définie par le RTOS avec un identifiant et un niveau de priorité.
Elle peut être dans plusieurs états :
- En attente (d’un évènement, interrupt, donnée, …)
- Prête à être exécutée (attend le contrôleur)
- En cours (consomme du temps contrôleur)
Mise en œuvre du temps réel :
Description des différentes manières de gérer le temps processeur :
Simple :
Les tâches s’exécutent jusqu’à leur fin dans l’ordre de leur priorité.
Coopératif :
Les tâches sont coresponsables de l’exécution de toutes. Le RTOS possède des instructions
qui permettent aux tâches de se mettre en veille et de laisser du temps de calcul aux autres.
Préemptif :
Le mode préemptif permet à une tâche de s’exécuter tant qu’aucune autre de priorité
supérieure ne demande du temps de calcul. Aussitôt qu’une interruption ou une tâche de plus
haute priorité pointe son nez, la tâche en cours se met en pause et cède la main aux tâches plus
importantes. C’est le système qui permet la plus grande vitesse d’exécution globale du travail.
Place mémoire :
Les tâches sont stockées en RAM avec chacune sa pile, cela génère à chaque fois de la place
occupée pour chacune d’elle.

Microconotrôleur
ARM
Temps de cycle pour la gestion du temps réel :
Le tableau suivant permet de se faire une idée des temps de commutation d’une tâche à l’autre
et des temps de passage d’une tâche à l’autre due à un interrupt pour différents fabriquants.
Librairies :
Chez Keil,(par opposition aux autres fournisseurs moins bons…) on achète un pack qui
contient toutes les librairies pour toutes les interfaces (TCP/IP, USB, file system, CAN
driver,…)
Sur les deux premières lignes, on voit les interrupts

simulés sur les deux premières lignes qui commandent
les deux tâches en rouge et bleu.

Microconotrôleur
ARM
Options des programmes :
On peut « sortir » des constantes dans un onglet « configuration Wisard » elles sont
disponibles dans un tableau de configuration qui modifie les valeurs des #define du code et on
peut même attribuer des facteurs de démultiplication entre les valeurs entrées et le #define en
question. Nous ne savons par contre pas comment les créer…

Microconotrôleur
ARM
L’onglet fonction permet une

navigation entre les tâhes

Microconotrôleur
ARM
__task indique au processeur qu’une fonction est une tâche et pas une fonction normale.

Microconotrôleur
ARM
Cette tâche s’exécute tous les 22 tics Ö toutes les 22 ms.

Microconotrôleur
ARM
Dans le menu périphérique RTX Kernel, on peut voir les tâches en cours, leur état, leur
priorité, la charge de la pile, ...
Dans cette fenêtre on peut également voir la charge du système et les signaux générés en
cours de déroulement de la simulation.
Les informations de la fenête RTX Kernel ne sont mises à jour en temps réel que lors d’une
simulation, si on fait tourner le soft sur le uP, elle n’est mise à jour que lors de l’arrêt du
programme.

Microconotrôleur
ARM
Dans la fenêtre « performance », on peut voir la charge du micro pour chacune des tâches.
On peut ainsi déterminer que durant 37% du temps, le processeur attend dans une boucle
« for » à la ligne OS_idle_demon. Ce temps serait normalement utilisé pour mettre le CPU en
pause et économiser de l’énergie.

Microconotrôleur
ARM

Microconotrôleur
ARM
Un bouton « Trace Record » permet d’enregistrer la manière d’arriver au point d’arrêt et
également les instructions qui vont suivre. Le bouton « view Trace record » affiche ensuite
une fenêtre qui montre le code et l’assembleur avant/après le point d’arrêt.

Microconotrôleur
ARM
Une fois compilé et en simulation, on peut voir les périphériques du contrôleur dans
« peripherals ». Nous avons ici sorti le panneau « ADC » « GPIO4 » et « GPIO7 »
Comme le port « LED » est le port 7, on peut modifier les valeurs des leds dans le panneau
« GPIO 7 » (en mode « Debug/simulation »)

Microconotrôleur
ARM
Nouveau projet pour notre carte.
Project Ö new project.
Choix du microcontroleur
STR912FW44
Ajout d’un fichier que l’on nomme p.ex.

main.c
On introduit ensuite la librairie qui correspond de ST en mettant un include, la librairie en

question est décrite dans ce répertoire : C:\Keil_ARM\ARM\INC\ST\91x\91x_lib.h

Microconotrôleur
ARM
Pour utiliser un port, on doit aller le configurer dans le fenêtre qui s’ouvre lors de la sélection
de « STR91x.s » et « configuration wisard » les ports dans le mode « not in reset ».
Pour positionner un bit sur un port, on doit définir les options de « peripheral reset register » à
« not in reset » pour les ports concernés et on doit activer le clock sur le « Peripheral clock
gatering ».
Apès quoi ce code permet de faire un joli petit

chenillard sur les leds

Microconotrôleur
ARM
Agent Temps Réel
L’agent temps réel est un bout de code qui envoi des informations sur le fonctionnement du
micro, il tourne sur le micro et un include « RTA_config.c » permet de l’ajouter au code que
l’on implante dans le uP.
On va ouvrir le fichier mesure.uv2 dans le répertoire
C:\Keil_ARM\ARM\RT Agent\MCBSTR9\Measure\
On peut alors afficher les valeurs envoyées par l’agent temps réel du CPU sur l’écran en
tapant « d ».
On trouve cette librairie dans le répertoire … des librairies.

Microconotrôleur
ARM
Choix technologiques
On trouve sur le marcher plusieurs fabricants pour les chips ARM, notemment Atmel, ST,
NXP
NXP a un peu plus de ram (Ethernet est très gourmand)
Ils ont tous des contrôleurs d’interruption différents.
Si on veut une image claire des options du marché, pour les configuration matérielles on peut
demander aux distributeurs (EBV p.ex)
On peut prendre comme point de départ, l’étendue des pilotes de périphériques qui détermine
la polyvalence du microcontrôleur.
La consommation de courant est également un critère de choix, mais il est difficile de
découvrir la consommation réelle derrière les chiffres marketing.
On trouve tout de même des chiffres qui vont de quelques uA en mode « endormi » à plus de
100 mA pour le mode « pleine vitesse » avec tous les périphériques qui communiquent à tout
va.
Ram :
plusieurs implémentations différentes, avec une implémentation DMA qui n’est pas présente
sur tous les chips.
Flash :
Les accès à la flash sont lents, 1 ms pour lire/ écrire, 100 ms pour effacer. La plupart du
temps, le CPU ne fait rien durant les accès à la flash (il existe forcément des exceptions).
On voit par contre que certaines implémentations imposent d’écrire un minimum de 8 Word
par accès.
Comme les accès flash sont plus lents que les accès ram tous les fabricants ont élaboré des
stratégies pour accélérer le flux de données et garantir pour certains des débits qui sont
compatibles avec le travail à pleine vitesse du contrôleur. Cela ne marche évidemment pas
dans tous les cas et il faudra géger des effets de bord.
Contrôleur d’interruptions
Dans l’ARM, on a un fonctionnement des interruptions différent où on ne met pas l’état des
registres dans la pile (et l’interrupt qui arrive avant la fin du code de la première interruption
va ajouter une occurrence supplémentaire de ces registres). Dans l’ARM, c’est dans des
registres dédiés que l’on stock les informations, ce qui interdirait des interruptions
imbriquées.
En fait il y a des stratégies de contournement de ce problème et on peut évidemment
imbriquer des interruptions.
ST a la structure d’interrupt controler la plus élaborée.
Un temps de latence de 1 us (60cycles à 60 MHz) peut être facilement atteint, on peut
diminuer ce temps, mais cela demande des efforts supplémentaires.
Le FIQ « Fast Interruption » permet d’arrêter le process entre 6 dans le meilleur des cas et 24
cycles dans le pire.

Microconotrôleur
ARM
Bus interne :
NXP est le seul qui offre une architecture avec plusieurs bus internes, ce qui permet un
écoulement des informations fluides et un gain de temps pour le traitement de quantité
importantes de données.
Timers :
On touve des compteurs 16 bits dans toutes les configurations, mais NXP fournit des
compteurs 32 bits que l’on peut chaîner et ainsi avoir un compteur 64 bits. Cela peut être
séduisant, mais il faut prendre garde à la portabilité d’applications qui sont développées sur
une particularité d’un seul fabricant.
USB :
Ils ont en général 16 ports logiques, mais Atmel est un peu plus léger sur ce point. Lors de
l’énumération, les différences de taille de buffer sont communiquées et ce n’est pas un
problème en soit, un buffer plus important va, bien sûr fluidifier le flux de données.
On trouve actuellement les USB 1.0 et 2.0, avec un supplément à 2.0 : OTG On The Go qui
permet une connexion directe entre deux périphériques (sans Hub).
L’énumération est la procédure qui va permettre la reconnaissance des périphériques par le
gestionnaire de bus.
Les hubs peuvent (si tout est implémenté) dire aux périphériques connectés, combien
d’énergie ils ont le droit de consommer.
Pour One The Go, un élément peut être soit host, soit périphérique.
Le signal est sous forme NRZ (zéro Ö change, 1 Ö ne change pas). Pour des raisons de
synchronisation, on a de toute manière un zéro tous les 6 « 1 ».

Microconotrôleur
ARM
Device : par exemple clavier+souris, ou imprimante+scanner

Fonction : clavier,souris,imprimante,scanner.
Endpoint : est déterminé par le type de flux (data streaming, interrupt driven, …) et direction.
Procédure de connexion d’un nouveau périphérique :
- le host lit les premiers 8 bytes de la description
- il lui assigne une adresse
- il lit la description complète
o configuration (info pour le fonctionnement)
o description (info sur fabricant, annexes)
- envoie la commande « Set_configuration »
- charge les drivers.
Type de transfert :
Il y a 4 types de transfert :
- Control (configuration), permet des échanges « sécurisés » de données en
bidirectionnel.
- Interrupt (clavier, souris) unidirectionnel.
- Synchrone (audio vidéo) pas de contrôle d’erreur, unidirectionnel.
- Bulk (scanner, printer) contrôle d’erreur unidirectionnel.
Tampon d’entrée :
Pour pouvoir bénéficier du débit total USB, on doit avoir un buffer d’entrée suffisant pour
pouvoir contenir le flux d’entrée (1023 byte/ms).

Microconotrôleur
ARM
Exercice USB :
8 bytes suffisent, car nous

allons lire deux switch et
écrire un byte de leds
On trouve dans le fichier usbdesc.c les numéro d’identification du fabricant

« WBVAL(0x1601), /* idProduct */ », la puissance requise en mA
« USB_CONFIG_POWER_MA(100) », la description du périphérique (son mon)
« USB_STRING_DESCRIPTOR_TYPE »
Si on compile et charge le code, on peut ensuite en retirant et remettant la prise USB de la
carte, la faire reconnaître comme périphérique et voir
l’application.c:\Keil_ARM\ARM\Utilities\HID_Client1\Release\hidclient.exe afficher les
actions sur les boutons S2, S3 et allumer les leds sur la carte.
La question est posée de trouver une manière de passer un message (8 bits) au périphérique.
On peut faire un compteur sur les cases à cocher en écrivant :
byte count ;
…
InReport |= count <<2 ;
count++;

Microconotrôleur
ARM
On trouve deux variables outreport et inreport dans les fichier hiduser et demo.
Deux fonctions SetOutReport et GetInReport permettent d’envoyer le contenu des deux
variables ci-dessus.
L’exemple memory.uv2 permet d’utiliser la ram du microcontrôleur comme une clé USB…
de 30kb…
Can Bus :
ST a un seul port Can alors que les autres on 2 ou 4 ports. NXP n’a pas de buffer d’entrée
pour la réception des messages.
On a une distance maximum de transmission, pour les distances supérieures à 10m, on doit
déjà diminuer le taux max (1Mbps).
On utilise un signal différentiel pour la communication, qui donne une forte immunité au bruit
des communications Can bus.
Ce bus a une configuration à plusieurs maîtres, si deux émettuers parlent en même temps,
l’émetteur qui a la plus grande priorité va faire passer son message.

Microconotrôleur
ARM
Structure du message sur le bus CAN.
Le « zéro » a une priorité sur le « 1 » dans la physique du bus.

La priorité est donc donnée à l’émetteur qui a le plus de « zéro » dans son adresse
d’identification, lors du démarrage de la séquence d’émission, on commence par l’ID, ce qui
va induire, pour un émetteur, une incohérence entre son émission et la valeur qu’il peut
constater sur l’état du bus.
Il existe des messages de synchonisation qui vont, p.exemple donner le « top départ » à des
actions qui ont été transmises à plusieurs actuateurs de manière sérielles.
Tous les messages sont envoyés à tous (Broadcast), les récepteurs trient.
Tous les récepteurs peuvent signaler une incohérence (CRC) d’un message et l’annuler.
50% de la bande passante est occupée par de la sécurisation des données.
CAN a près de 20 définitions des structures de communication (haut niveau) différentes.
On peut citer : CanKingdom, Devicenet, SDS, J1939, CANopen.
Can In Automotive (CIA) recommande l’utilisation de CANOpen.

Microconotrôleur
ARM
Il y a un « heartbeat » qui informe le réseau de la présence des interfaces. L’adresse de ce
message est une des plus faible priorités (0x700), ce qui permet à ces messages de pas
empêcher la transmissions des messages data importants.
Voici une liste des identifiants de messages, auxquels on va ajouter l’ID de l’émetteur.
Il existe une version MicroCanOpen qui peut être utilisé librement (pour l’éducation) et
permet de se frotter à Can open sans bourse délier. www.microcanopen.com

Microconotrôleur
ARM
Exemple d’implémentation de microcanopen dans un micro. Si on veut implémenter un can
open dans un chip (st), il faut demander à Olaf qui nous donne un fichier de configuration.
Les trois fonction nécessaires sont une fonction d’initialisation, push, pull, un timer d’une
milliseconde et c’est tout.
Vitesse Si on met 0x185 au lieu de

Node ID zéro, on ne tiendra compte que
des messages émanant de ce
Heartbeat
nœud.
Si les données changent, on

envoie au max toutes les 20 ms, si
elles ne changent pas, toutes les
300 ms

Microconotrôleur
ARM
On peut sortir dans le menu « peripherals » les fenêtres qui montrent les messages de Can et
les sorties sur le port1.
Heartbeat avec l’adresse

du device (9)
On trouve chez www.esacademy.com des outils (Can open magic prods) qui permettent de
définir la structure d’un réseau Can, simuler des nœud, envoyer des messages, …
TCP/IP
On trouve dans TCP-IP les couches traditionnelles des protocoles de communication.
On n’est (dieu merci) pas obligé d’implémenter tous les protocoles dérivés de TCP/IP.
Au-dessus de la couche physique (souvent 100baseTX RJ45), on trouve Ethernet (souvent

802.3).
On peut utiliser l’adresse MAC 48 bits pour identifier les interfaces des périphériques.

Microconotrôleur
ARM
On pourrait utiliser ethernet seul pour réaliser des échanges entre capteurs et contrôleur, mais
il faut se souvenir que ces paquets ne comportent pas d’entête IP, ce qui rend possible leur
passage par des hubs (en voie de disparition), mais en aucun cas des switch ou routeurs.
La couche suivante est bien sûr la couche IP qui permet de router (ou switcher) des paquets
dans un réseau grâce à l’adresse IP source et cible.
On trouve ensuite TCP qui permet de définir un numéro de port source et cible et ainsi définir
des canaux de communication indépendants sur une même adresse IP.
Des outils permettent de dépanner un réseau TCPIP :
- ping [adresse cible] permet de tester la communication entre deux interfaces (IP
adress)
- nslookup : permet de connaître la configuration d’un serveur de noms pour un
domaine (DNS)
- traceroute : permet de connaître le chemin parcouru par un paquet dans le réseau.
Ethernet pour du temps réel ?

Il n’est pas conçu pour cela et on sait que les temps de latence pour un message (à cause de
collisions ou de buffer dans les switchs) peuvent être très important.
On trouve une multitude de solutions pour faire du temps réel sur ethernet en le faisant « à la
mode CanOpen ». Avec des systèmes de jetons ou de fenêtre temporelle pour définir qui parle
et quand afin d’éviter à tout prix les collisions.
Choix de l’adresse IP

Microconotrôleur
ARM
Configuration de la page HTML
Rafraichie toutes les secondes
Variable à afficher qui modifie la

largeur d’une case du tableau
On a ensuite un affichage sous forme « pseudo graphique » de l’information.
Pour modifier la valeur, on recherche la chaine AD7% dans le paquet TCP/IP et on le

remplace par la valeur de la variable.

Microconotrôleur
ARM
Exercice Blinky ADC 2300 Carte NXP.
La toolbox est définie dans le fichier Sim.ini, ou on voit la configuration des boutons et
l’assignation des valeurs aux entrées ad00 et ad01.

Microconotrôleur
ARM
Timer :
On peut configurer des timers pour déterminer des interruptions, on doit tout d’abord
configurer le décimateur (prescaler) qui va indiquer tous les combien de coups de clock on
incrémente le compteur principal (1 tic), après quoi on charge le ou les registres qui vont
générer des interruptions quand le compteur aura atteint leur valeur.
On peut définir les priorités des interruptions avec l’instruction VICVectCntl4 et les lire dans
la fenêtre « Vectored Interrupt Controller). Donner les valeurs du prescaler et des valeurs pour
le compteur avec les instruction s T0xx et les lire dans la fenêtre du timer concerné.
La procédure T0ISR() change la valeur d’affichage des
leds et remet les compteurs à zéro.

Microconotrôleur
ARM
Trucs et astuces RTOS
Banque de registre
Dans l’architecture ARM, chaque mode de fonctionnement du processeur a des registres
dédiés.
Link register, contient l’adresse

de retour pour les interrptions
Entrée dans une procédure d’interruptions :

Microconotrôleur
ARM
Sortie d’une procédure d’interruptions.

Microconotrôleur
ARM
Registre d’état :
Le registre d’état n’est pas modifiable depuis le C, si on veut modifier les valeurs de ce
registre, c’est par le contrôleur d’interruption qu’il faut le faire, ou via ASM, ce qui n’est
jamais recommandé.
Interactions entre IRQ et variables globales

Comme les opérations sur des variables globales utilisent les registres (et pas directement la
mémoire) on peut être confronté à une interruption qui modifie le registre en question
pendant l’opération de changement de valeur de la variable.
On peut désactiver les interruptions durant la séquence ou utiliser des architectures (Cortex-
M3) qui inhibent les interrupts automatiquement durant ce genre d’opération.
GNU :
Plusieurs exemples où les logiciels libres sont moins bons que les logiciels payant, si le
vendeur nous le dit…
Choix d’une carte pour nos besoins.

On doit s’occuper en priorité des périphériques dont on a besoin. Il faut ensuite considérer que
les cartes les plus simples ont un seul clock et l’écriture sur une led va être fait en positionnant
la direction (lecture écriture) et en écrivant dans un registre.
NXP semble plus adaptée à nos besoins, car on est en ARM7 (au lieu de 9) et que l’on a un
slot d’extension mémoire standard documenté chez ARM.com.

Microconotrôleur
ARM
Table des matières
Cours ARM 21 et 22 novembre 2007...................................................................................... 1
Introduction : .......................................................................................................................... 1
Thumb .................................................................................................................................... 2
Comparaison entre les architectures ARM 7 et 9....................................................................... 2
Arm7 : .................................................................................................................................... 2
Arm 9 : ................................................................................................................................... 2
Cortex-M3 : ............................................................................................................................ 3
Interruptions : ..................................................................................................................... 3
VIC Vectored Interrupt Controller..................................................................................... 3
Compilateurs : ........................................................................................................................ 4
Pratique : .................................................................................................................................... 5
Commencer de zéro.................................................................................................................. 11
RTOS : Real Time Operating System ...................................................................................... 25
Les développements : ........................................................................................................... 25
Définitions :...................................................................................................................... 25
Mise en œuvre du temps réel : ............................................................................................. 25
Simple : ............................................................................................................................ 25
Coopératif :....................................................................................................................... 25
Préemptif : ........................................................................................................................ 25
Place mémoire :.................................................................................................................... 25
Temps de cycle pour la gestion du temps réel : ................................................................... 26
Librairies : ............................................................................................................................ 26
Options des programmes :.................................................................................................... 27
Nouveau projet pour notre carte............................................................................................... 36
Agent Temps Réel.................................................................................................................... 38
Choix technologiques............................................................................................................... 39
Ram : .................................................................................................................................... 39
Flash : ................................................................................................................................... 39
Contrôleur d’interruptions.................................................................................................... 39
Bus interne : ......................................................................................................................... 40
Timers : ................................................................................................................................ 40
USB : .................................................................................................................................... 40
Device : ............................................................................................................................ 41
Fonction :.......................................................................................................................... 41
Endpoint : ......................................................................................................................... 41
Type de transfert : ............................................................................................................ 41
Exercice USB : ..................................................................................................................... 42
Can Bus : .............................................................................................................................. 43
TCP/IP.................................................................................................................................. 47

Microconotrôleur
ARM
Exercice Blinky ADC 2300 Carte NXP................................................................................... 50
Timer : .................................................................................................................................. 51
Trucs et astuces RTOS ............................................................................................................. 52
Banque de registre................................................................................................................ 52
Entrée dans une procédure d’interruptions : ........................................................................ 52
Sortie d’une procédure d’interruptions. ............................................................................... 53
Registre d’état : .................................................................................................................... 54
Interactions entre IRQ et variables globales ........................................................................ 54
GNU : ................................................................................................................................... 54
Choix d’une carte pour nos besoins. .................................................................................... 54
Un cours www.Redacom.ch donné par Olaf Pfeiffer.

JPN Cours RTOS STR912 Keil 21 Et 22 Novembre 2007

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

JPN Cours RTOS STR912 Keil 21 Et 22 Novembre 2007

Hochgeladen von

Copyright:

Verfügbare Formate

Microconotrôleur

Pour le choix d’un chip, on doit tenir compte de trois critères :

ARM est une architecture « chargement dans les registres »

JPN 1/56 Novembre 2007

JPN 2/56 Novembre 2007

VIC Vectored Interrupt Controller

JPN 3/56 Novembre 2007

L’architecture comporte un APB

On trouve des architectures multi-bridges qui permettent de multiplier les transferts

JPN 4/56 Novembre 2007

modification des options de compilation :

Les blocs de mémoire

JPN 5/56 Novembre 2007

JPN 6/56 Novembre 2007

Empêche la copie groupée de

Liste des options qu’il faut mettre

Le niveau d’optimisation permet le meilleur débuggage au niveau 0

JPN 7/56 Novembre 2007

JPN 8/56 Novembre 2007

Ces fenêtres permettent de

Et des différents chemins des

JPN 9/56 Novembre 2007

Comparaison entre les modes de simulation et de « hardware debbuging ».

JPN 10/56 Novembre 2007

JPN 11/56 Novembre 2007

JPN 12/56 Novembre 2007

JPN 13/56 Novembre 2007

JPN 14/56 Novembre 2007

On copie le code que l’on trouve dans « bloc 1 » du fichier read_me.txt:

JPN 15/56 Novembre 2007

Ajout d’un fichier au projet : add file et choix de notre fichier

JPN 16/56 Novembre 2007

JPN 17/56 Novembre 2007

Créer un répertoire opt dans l’onglet « ouput » et lst dans « listing »

JPN 18/56 Novembre 2007

Le compilateur indique, en mode simulation, le

JPN 19/56 Novembre 2007

On utilise la plupart du temps des

JPN 20/56 Novembre 2007

On peut visualiser les signaux en appuyant sur le bouton « logic analyzer ».

JPN 21/56 Novembre 2007

JPN 22/56 Novembre 2007

JPN 23/56 Novembre 2007

On indique la variable en question et la valeur à

JPN 24/56 Novembre 2007

JPN 25/56 Novembre 2007

Sur les deux premières lignes, on voit les interrupts

JPN 26/56 Novembre 2007

JPN 27/56 Novembre 2007

L’onglet fonction permet une

JPN 28/56 Novembre 2007

JPN 29/56 Novembre 2007

JPN 30/56 Novembre 2007

JPN 31/56 Novembre 2007

JPN 32/56 Novembre 2007

JPN 33/56 Novembre 2007

JPN 34/56 Novembre 2007

JPN 35/56 Novembre 2007

Ajout d’un fichier que l’on nomme p.ex.

On introduit ensuite la librairie qui correspond de ST en mettant un include, la librairie en

JPN 36/56 Novembre 2007

Apès quoi ce code permet de faire un joli petit

JPN 37/56 Novembre 2007