Telechargé par Seydina Mouhamed Fall

Informatique embarquée Temps réel

publicité
Informatique embarquée
Temps réel
Informatique embarquée
• Caractéristiques :
– Ressources limitées (mémoire, CPU, stockage)
– Energie limitée (pile, batterie, panneaux solaires …)
– Interaction avec l’environnement physique (capteurs, actionneurs)
• Types :
– Mobile (smartphones, tablettes, liseuses, GPS, …)
•
•
•
•
Accès à des ressources sur réseau (3G, wifi, Bluetooth)
Accès à l’énergie facile (chargeur)
Très orientée utilisateur (interface)
Ressemble beaucoup à de l’informatique classique (sauf pour les interfaces)
– Industrielle (microcontrôleurs)
•
•
•
•
Parfois énergie très limitée
Rôle de l’utilisateur faible (écran LCD, boutons) ou inexistant
Centrée sur des systèmes physiques ou sur la robotique
Réseaux spécialisés (CAN)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
2
Informatique industrielle
Différences avec l’informatique traditionnelle :
•
Embarquée  doit être autonome et sûre
–
–
–
–
•
Contrôle de l’énergie (éteindre ce qui ne sert pas ou plus, mise en veille …)
Reprise en cas d’erreur (détection d’erreur, sauvegarde d’état, reprise en un point sûr)
Auto contrôles (au démarrage, à temps perdu)
Etats de mise en sécurité (arrêter totalement ou partiellement le système)
Industrielle
– Travaille avec des phénomènes réels
• Imprécision des mesures ( image du système faussée)
• Imprécision du modèle (mal connu ou trop complexe  approché)
• Délais à respecter (à faire immédiatement, après ou avant un temps donné)
• Intervention humaine parfois impossible ou trop lente
• Grandes quantités de données mais éphémères (on ne stocke pas)
– Risques élevés
• Mise en danger des personnes, de l’environnement, etc.
• Détérioration du système lui-même
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
3
Informatique industrielle (risques)
En Informatique industrielle :
Au lieu de :
On risque d’avoir :
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
4
Principe (système en boucle)
Valeurs
Programme
•
actionneurs
Modifier
Microcontrôleur
Système réel
–
–
–
•
Contrôleurs
de
périphériques
Mesurer
Système
réel
Commandes
CPU
capteurs
Image
du
système
réel
Caractéristiques (ce qu’il doit faire, ce qu’il peut faire)
Temps de réaction
Limites (sécurité)
Contrôleurs de périphériques + CPU = microcontrôleur
–
–
–
Capacités (ce qu’il peut faire)
Vitesse (du CPU et des contrôleurs de périphériques)
Limites (valeurs minimales et maximales, précision des mesures et des calculs)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
5
Principe (système en boucle)
Valeurs
Programme
•
actionneurs
Modifier
Contrôleurs
de
périphériques
Capteurs = image du système réel
–
–
–
•
Mesurer
Système
réel
Commandes
CPU
capteurs
Image
du
système
réel
Précision, sensibilité, fiabilité, limites
Temps de capture
Nombre, positions
Actionneurs = modification du système réel
–
–
–
Précision, sensibilité, fiabilité, limites
Temps de réaction
Nombre, positions
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
6
Le câblage
Adaptation de niveau
capteurs
Contrôleurs
de
périphériques
actionneurs
Adaptation de puissance
•
Choisir à quel contrôleur de périphérique relier chaque capteur et chaque actionneur
•
Adaptation de niveau : l’information produite par un capteur peut être transmise par un
signal électrique de valeur trop faible ou trop élevée pour le contrôleur de périphériques
(il existe des CI prévus pour ça)
•
Adaptation de puissance : le signal électrique produit par le contrôleur de périphériques
peut ne pas permettre d’activer l’actionneur (il existe des CI prévus pour ça)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
7
Informatisation : les éléments
•
Système réel
– Cas d’utilisation (quoi faire ? Quels risques ?)
– Temps de réaction (à quelle vitesse ?)
– Limites (erreurs, sécurité)
•
Microcontrôleur
– Modèle (puissance, vitesse, prix, disponibilité, consommation)
– Contrôleurs de périphériques (nombre, types, précision, limites)
•
Capteurs
– Nombre et placement (image du système suffisante)
– Type (précision, sensibilité, fiabilité, limites, prix, type de connexion)
•
Actionneurs
– Nombre et placement (modification du système possible)
– Type (précision, sensibilité, fiabilité, limites, prix, type de connexion)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
8
Informatisation : le programme
•
Défauts (des capteurs, des actionneurs, des contrôleurs de périphériques)
 L’image du système réel n’est ni complète ni exacte ni actuelle
•
Temps réel (le temps du système réel prime)
– Réagir assez vite (ne pas laisser le système réel dériver)
– Ne pas réagir trop vite (laisser le temps au système réel pour réagir)
– Tenir compte :
• du temps de mesure des capteurs
• du temps de réaction des actionneurs et du système réel
•
Logique
– Ordre des traitements (précédence)
– Durée des traitements (respect du temps réel)
– Priorités des traitements (urgence)
•
Sécurité
– Cas d’utilisation liées à la sécurité
– Limites (du système réel et du système informatique)
– Pannes (du système réel, des capteurs, des actionneurs)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
9
Données et résultats
Informations reçues :
•
Mesures prélevées par les capteurs
– Numérique (1 ou plusieurs bits, ex : présence / absence)
– Analogique (ex : température)  devra être numérisée (conversion)
– Temporelle (durée pendant séparant deux événements)
•
Evénements détectés par les capteurs
– Répétitifs (ex : détection de rotation)
– Occasionnels (ex : arrêt d’urgence)
Informations produites :
•
Commandes d’actionneurs
– Numérique (1 ou plusieurs bits, ex : marche/arrêt)
– Analogique (En pratique rarement utilisé, ex : vitesse)
– Temporelle (durée pendant laquelle un bit reste à 0 ou à 1 + période
ex : positionnement d’un servomoteur)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
10
Informations prises en compte
•
Valeurs liées aux caractéristiques du système réel (constantes ou courbes)
– Marges d’erreur acceptées
– Temps (temps de réaction)
– Limites (valeurs min/max)
•
Constantes liées à l’image du système réel
– Connexion des capteurs et actionneurs aux contrôleurs de périphériques (quoi, où)
– Conversions (mesuré ↔ réel et unités)
•
Informations reçues des capteurs
– Mesures
– Evénements
•
Temps
– Délais
– Rythme de prélèvement des mesures
– Temps mesurés entre événements
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
11
Analyse du problème
•
Modèle logique du système réel (ce qu’il doit faire)
– Automate
– Algorithme
•
Modèle mathématique du système réel (comment il marche)
– Géométrique (robotique)
– Physique (équations de la mécanique, …)
– …
•
Ordonnancement des tâches
–
–
–
–
•
Tâche de fond (en permanence)
Tâches répétitives (à intervalles réguliers ou liées à des événements répétitifs)
Tâches exceptionnelles (cas d’erreurs, …)
Tâches urgentes (liées à des événements urgents, des alarmes, …)
Adaptation des calculs
– Durée (algorithme plus rapide, algorithme approché)
– Précision (inutile de calculer plus précis que ce que le système peut faire mais
pas moins non plus)
– Fiabilité (preuve de programme, jeux d’essai, plusieurs méthodes de calcul
comparées, vérification en temps réel sur le système)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
12
Pilotage du système réel
•
En aveugle
– On agit sur un actionneur et on suppose que le système réagira correctement.
– Exemple :
• Contrôle de vitesse d’un ventilateur de refroidissement :
– Quand le système chauffe on accélère le ventilateur à 5000 tr/min
– S’il tourne en réalité à 4800 ou 5200 tr/min ça n’a pas d’importance
– Cas d’utilisation :
• On n’a pas besoin d’une grande précision
• La commande n’est pas critique
•
Auto contrôlé
– On agit sur un actionneur et on contrôle la réaction du système par un capteur.
– Exemple :
• Contrôle de vitesse d’un moteur :
– On met le moteur à 5000 tr/min
– On a un capteur de vitesse couplé au moteur et on vérifie qu’il soit bien à 5000 tr/min
– Si ce n’est pas le cas on ajuste sa commande de vitesse jusqu’à y arriver
– Cas d’utilisation :
• On a besoin de précision
• La commande est critique (sécurité, panne)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
13
Auto contrôle
• Principe :
1.
2.
3.
4.
Donner une consigne à un actionneur
Vérifier par un capteur l’effet de cette consigne
Si la valeur mesurée n’est pas celle attendue ajuster la consigne
Recommencer au 2
• Problème :
– Comment ajuster la consigne ?
• Solutions :
– Ajuster très peu pour arriver petit à petit à la bonne valeur
• Marche bien mais risque de mettre beaucoup de temps si la valeur
mesurée est loin de la valeur voulue
– Ajuster au mieux rapidement
• Ajuster la consigne plus ou moins en fonction de l’éloignement entre la
valeur mesurée et la valeur voulue mais risque d’oscillations
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
14
Auto contrôle (Approche intuitive)
•
Exemple de la conduite automobile :
– La position de l'accélérateur (consigne) produit une vitesse de la voiture
– Par exemple à mi course on est normalement à 80
– Mais s'il y a du vent, si ça monte ... ce n'est plus vrai
•
Ce que l'on fait quand on constate qu'on est tombé à 70 au lieu de 90 :
1. On accélère proportionnellement à l'écart (20) çàd que l'on accélèrerait
moins si on n’était tombé qu’à 80
2. Puis on surveille le compteur (en le regardant à intervalles réguliers) pour
voir comment l'écart se réduit. S’il se réduit trop peu on accélère plus
3. Quand on voit que les écarts avec la la vitesse voulue (90) diminuent on
relâche l'accélérateur pour y arriver doucement sans la dépasser
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
15
Auto contrôle (Approche moins intuitive)
– La consigne dépend :
– De l’écart entre la valeur mesurée et la valeur voulue (présent : on tient compte de l’écart actuel)
– Des écarts précédents (passé : on tient compte des écarts passés)
– De la différence entre l’écart actuel et l’écart précédent (futur : on suppose que si l’écart se réduit il
continuera à se réduire et que s’il augmente il continuera à augmenter)
– Formule :
e = écart entre la valeur mesurée et la valeur voulue
consigne = Kp * e + Ki * (somme des e) + Kd (e - eprec)
Kp, Ki et Kd sont des coefficients constants à déterminer
– Vision mathématique :
– L’écart est une fonction du temps : e(t)
– La consigne est aussi une fonction du temps : c(t)
– La formule est donc :
c(t) = Kp * e(t) + Ki * ∫ e(t).dt + Kd * de(t)/dt
On parle de correction PID (Proportionnelle Intégrale Différentielle)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
16
Auto contrôle (informatisation)
•
Réalisation informatique :
– La valeur voulue est V
– À intervalles réguliers on relève la valeur mesurée Vm et on calcule
l'écart
e = V - Vm
Si l'erreur est dans de l'intervalle de marge d’erreur [-ε, +ε]
// La consigne n’est pas modifiée (elle est bonne)
Sinon
somme ← somme + e
différence ← eprec - e
consigne ← Kp * e + Ki * somme + Kd * différence
eprec ← e
•
ATTENTION :
Il est important de faire les mesures à intervalles réguliers
sinon les sommes et les différences entre écarts ne veulent rien dire
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
17
Auto contrôle (ajustement)
Il ne reste plus qu’à trouver les coefficients Kp, Ki et Kd
• Influence des coefficients sur le comportement du système :
– Kp : permet de s’approcher de la valeur voulue mais pas de l’atteindre (si l’écart est nul Kp n’a
plus d’effet). Si Kp est trop grand ça oscille.
– Ki : permet d’atteindre la valeur voulue mais introduit des oscillations (on la dépasse puis on
revient en arrière plusieurs fois ou indéfiniment)
– Kd : accélère la convergence et atténue les oscillations (on anticipe)
• Méthodes de détermination
– On peut les déterminer par calcul mais cela suppose de connaître les équations régissant le
fonctionnement du système réel
•
En général elles sont difficiles à trouver (pour une voiture ça dépend des temps
d’accélération du moteur selon son régime actuel, du poids de la voiture, des frottements
de l’air, du revêtement de la route, de l’état des pneus, de la pente …)
– On peut les obtenir par ajustements :
1. Mettre Ki et Kd à 0 et ajuster Kp pour que la correction proportionnelle amène la valeur
mesurée au plus près de celle attendue sans trop osciller
2. Introduire Ki dans la formule et l'ajuster pour arriver le plus précisément possible à la
valeur attendue sans trop osciller
3. Introduire Kd dans la formule et l’ajuster pour diminuer les oscillations
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
18
Auto contrôle (vitesse)
A quel rythme faut-il faire les mesures de contrôle ?
•
Si on va trop lentement on risque de dépasser la valeur voulue entre 2 mesures  on va
osciller autour de la valeur sans jamais l’atteindre.
•
Si on va vite ce problème ne se pose plus mais …
1.
2.
•
La somme des écarts augmente vite  Il faut diminuer Ki pour en limiter l’effet. Si on va
vraiment trop vite Ki va devenir nul et ne servira plus à rien
La différence entre 2 écarts sera très faible car la valeur mesurée n’aura pas beaucoup
changé entre 2 mesures . Si on va vraiment trop vite la différence eprec-e sera la plupart du
temps nulle et Kd ne servira plus à rien
Le rythme de mesure dépend du système réel et de la précision de la mesure. Il doit être
tel que la différence entre 2 mesures soit petite mais non nulle.
Sur l’exemple de la voiture on ne va pas regarder le compteur :
–
–
Chaque 10 minutes sinon on aura largement dépassé le 90
Chaque seconde sinon on aura l’impression que l’aiguille ne monte pas et on aura tendance à
accélérer de plus en plus
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
19
Un peu d’histoire
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
20
Le premier système embarqué
Apollo Guidance Computer (AGC)
•
Embarqué sur le module lunaire (LEM) d’Apollo 11
•
Pilote la descente sur la lune du LEM le 20 juillet 1969 :
– Détermine périodiquement la position et la trajectoire réelle du LEM à partir des
informations issues :
• Des accéléromètres de la centrale inertielle (positionnement au début de l’alunissage)
• Du radar d'atterrissage (descente à la fin de l’alunissage)
– Calcule la trajectoire à suivre et pilote les moteurs du LEM
•
Le pilote du LEM peut
– Consulter les résultats des calculs
– Corriger les valeurs à tout moment
– Reprendre complètement la main sur les commandes des moteurs mais
l’alunissage à vue est très difficile
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
21
Le premier système embarqué
Réalisé au MIT pour un contrat avec la NASA de 4M
de $ en 1961 (30M de $ actuels)
•
•
•
Direction : Charles Stark Drapper
Hardware : Eldon C. Hall
Software : Margaret Heafield Hamilton
Taille : 61 x 32 x 17 cm, poids : 32 kg
• Le processeur
– Réalisé à partir de 2800 CI contenant chacun 2 nor à 3 entrées
– 16 800 transistors (proc d’un smartphone actuel : 1 milliard)
– Horloge à 2,048 MHz
• La mémoire :
– 2K de RAM et 36K de ROM
– Mots de 15 bits + 1 bit de parité
– Temps d’accès 11,75 µs
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
22
La programmation
• Langage assembleur
–
–
–
–
4 registres 16 bits.
34 instructions
4 interruptions
Mode veille (de 70W à 10W)
• Interface :
– Commandes sous la forme action (VERB) + paramètre (NOUN).
– L’affichage est le contenu de 3 des 4 registres du processeur
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
23
Le code
• Extrait du code de mise à feu :
#
*********************************
#
GENERAL PURPOSE IGNITION ROUTINES
#
*********************************
BURNBABY
TC
PHASCHNG # GROUP 4 RESTARTS HERE
OCT 04024
CAF
ZERO
# EXTIRPATE JUNK LEFT IN DVTOTAL http://klabs.org/history/apollo_11_
TS
DVTOTAL
alarms/eyles_2004/eyles_2004.htm
TS
DVTOTAL +1
TC
BANKCALL
# P40AUTO MUST BE BANKCALLED EVEN FROM ITS
CADR P40AUTO
# OWN BANK TO SET UP RETURN PROPERLY
• Problème de temps réel :
– A l’alunissage, le nombre de données radar à traiter charge le CPU à 98%
– Aldrin demande l’affichage de l’altitude calculée  surcharge de 10%
– Le module de calcul n’a plus le temps de s’exécuter au rythme auquel le
radar envoie les données  le CPU produit une alarme (1202)
– Il est relancé par Houston (3 fois)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
24
Capteurs et Actionneurs
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
25
Capteurs
• Principes
– Transforme une grandeur physique en :
• Une grandeur électrique : tension ou courant
ou
• Un temps : durée ou fréquence
– La transmet sous forme numérique (binaire) ou analogique (tension)
• Moyens :
–
–
–
–
–
–
–
–
Mécanique (contact, résistance ou capacité variable)
Piézoélectrique (tension induite par la déformation d’un cristal)
Effet Hall (tension induite par un champ magnétique)
Capacitif (tactile ou chimique)
Rayonnement (radio, infrarouge, laser)
Ultra sons (puissance, temps de propagation)
Lumière (phototransistor ou photorésistance)
Chimique (électrodes)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
26
•
Déplacement
–
–
–
•
Roue codeuse (contact)
GPS (réception de satellites)
Accélération (capacitif mécanique ou effet piézoélectrique)
Inclinaison (capacitif mécanique)
Rayonnement
–
–
–
•
Passage, mouvement, vibration (laser, IR ou radar)
Proximité, distance (laser, IR ou ultra sons par mesure de temps)
Position
–
–
–
–
•
Interrupteur, potentiomètre, joystick (contact ou résistance mécanique)
Tactile (contact ou décharge capacitive par contact)
Pression, Force, Flexion (résistance variable ou effet piézoélectrique)
Présence
–
–
•
Types de capteurs
Magnétisme (effet Hall)
Ondes (radio, IR)
Lumière, couleur et UV (phototransistor, photorésistance)
Environnement
–
–
–
–
–
–
Température (résistance variable)
Humidité (capacitif chimique)
Anémomètre (mécanique + magnétique)
Caméra (phototransistors)
Son, US (capacitif mécanique ou effet piézoélectrique)
Chimique (électrodes pour gaz ou liquides)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
27
Actionneurs
•
Principe
Transforme une information reçue sous forme :
• numérique (binaire)
ou
• analogique (tension)
ou
• temporelle (durée et fréquence)
en :
• Un mouvement (translation, rotation)
• Un affichage (écran, témoin lumineux ou sonore)
• Une émission (ondes, lumière, IR, chaleur)
•
Moyens
–
–
–
–
Mécanique et magnétique (moteur, électroaimant)
Piézoélectrique (vibreur)
Emission de rayonnements (radio, infrarouge, laser)
Lumière (DEL, écran)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
28
Types d’actionneurs
•
Mouvement
–
–
–
–
–
•
Indicateur
–
–
•
Electroaimant, Electrovanne, Relais (magnétique)
Moteur à courant continu (contrôle de vitesse par courant ou temporelle)
Moteur linéaire (comme le précédent mais déplacement linéaire)
Moteur pas à pas (position définie par commande binaire)
Servomoteur (position asservie par commande temporelle)
Haut parleur, vibreur (mécanique ou piézoélectrique)
Ecran (texte ou graphique), DEL ou afficheur (optoélectronique)
Emetteur
–
–
–
–
–
Radio
Infra Rouge
Ultra sons
Laser
Chaleur
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
29
Caractéristiques des capteurs/actionneurs
•
Précision
–
–
•
Sensibilité
–
–
•
Très lié à la précision, la sensibilité, la fiabilité et les limites. Par exemple on trouve des servomoteurs à
4€ et d’autres à 2000€
Type d’information envoyée/reçue
–
–
–
•
Un capteur de température supporte-t-il une température de 100°? De 1000°?
Un servomoteur peut-il soulever une charge de 500 g ? De 10 Kg ?
Prix
–
•
Un capteur de température qui mesure 14,1°pour 14°donnera-t-il toujours 14,1°une heure plus tard ?
Le lendemain ? Dans un an ?
Limites
–
–
•
Un capteur de température donne-t-il une mesure différente si la température change de ½°? de 1/10°?
Un servomoteur bouge-t-il si on veut le déplacer de 1°? de ½°?
Fiabilité
–
•
Un capteur de température donne-t-il une mesure au ½°? au 1/10°?
Un servomoteur peut-il être placé au ½°près ? Au degré près ?
Numérique
Analogique
Temporelle
Connexion
–
–
Directe
Par connexion spécialisé (SPI, I2C, I2S)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
30
Contrôleurs de périphériques
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
31
Contrôleurs de périphériques
• Entrées (capteurs)
– Numériques
• Lignes binaires en entrée (lecture 0 ou 1)
– Analogiques
• Convertisseurs A/N : tension de 0 à V1 → entier de 0 à N
• Comparateurs de tensions
– Evénements
• Détection de changement de ligne binaire : passe de 0 à 1 ou de 1 à 0
• Sorties (actionneurs)
– Numériques
• Lignes binaires en sortie (écriture 0 ou 1)
– Analogiques
• Convertisseurs N/A : entier de 0 à N → tension de V1 à V2
– Temporelles
• Lignes binaires en sortie avec choix de période et durée du 0 ou du 1
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
32
Contrôleurs de périphériques
• Temps
– Chronomètres (Timers)
• Choix de la vitesse de comptage
• Choix de la limite de comptage
• Communication
– Avec des capteurs ou des actionneurs
• Bus de données spécialisés (SPI, I2C, I2S)
– Avec d’autres dispositifs numériques
• Connexions réseau (RS232, Ethernet, CAN)
• USB (USART)
• Mémoire SD (SPI)
• Energie
– Mise hors tension de périphériques
– Détection de baisse d’alimentation
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
33
Contrôleurs de périphériques du 2560
• Capteurs/Actionneurs
– Numériques : 85 lignes d’E/S
– Analogiques :
• 1 Convertisseur A/N à 16 entrées + 2 entrées fixes (0V et 1,1V)
– Temporelles : 16 lignes de signaux périodiques
• Temps
– 2 Timers sur 8 bits (très limités)
– 4 Timers sur 16 bits
• Energie
– Possibilité d’allumer/éteindre chaque contrôleur de périphérique
individuellement
• Communication
– 4 USART (série asynchrone) ou SPI (Serial Peripheral Interface)
– 1 I2C (Inter-Integrated Circuit)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
34
Contrôleurs de périphériques du 2560
• Architecture et utilisation :
– Chaque contrôleur de périphériques contient des registres :
• De commande pour définir le fonctionnement du contrôleur
• D’état pour connaître l’état actuel du contrôleur
• De données pour envoyer/recevoir des données depuis/vers le capteur ou
l’actionneur piloté par le contrôleur
– Les registres sont sur 8 ou 16 bits
– Ils sont accessibles par le CPU comme des mots mémoire placés à des
adresses fixes
– Les registres sont découpés en champs de 1 ou plusieurs bits :
• Chaque champ a un rôle ou un sens particulier
• Le rôle ou le sens d’un champ peut dépendre du contenu d’un autre champ
– La programmation d’un contrôleur de périphériques consiste à :
• En définir le fonctionnement en remplissant les divers champs des registres
de contrôle
• En connaître l’état en consultant les divers champs des registres d’état
• Echanger des données par les registres de données
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
35
CPU du 2560
•
•
Processeur RISC à 16 MHz
Mémoire :
– 256 Ko de flash
– 4Ko EEPROM (sauvegardes)
– 4Ko RAM extensible à 64Ko
•
Interruptions :
– Contrôleur d’interruptions (priorités fixes pas de préemption)
•
Etats du processeur :
– Actif
– En sommeil (réveillé par interruption)
•
Energie :
– 1 Contrôleur d'alimentation (mise en/hors tension de chaque contrôleur de
périphérique)
•
Sécurité :
– 1 Chien de garde (détection de pannes)
•
Débogage :
– Sonde JTAG
– Moniteur de boot configurable par fusibles
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
36
Programmation
•
Langages :
–
–
–
–
•
Assembleur (quand on ne peut pas faire autrement)
C (le plus utilisé, souvent avec des variantes spécialisées)
C++ (mais l’objet n’apporte pas grand-chose : peu d’objets, peu d’héritage)
Java ou Python (mais parfois trop lents car interprétés)
Les pièges :
– Valeurs physiques : unités (g, Kg, N)  conversions : En 1992, la sonde Mars
Observer est détruite car le logiciel développé par Lockheed envoie des mesures
en uinités anglosaxonne alors que celui qui les recevait supposait qu’elles étaient
en unités internationnales.
– Temps / Fréquences : unités (s, ms, μs / Hz, KHz, MHz)  conversions
– Valeurs numériques entières :
• 4 milliards est possible dans un entier non signé sur 32 bits
• Pas dans un entier normal (int) : -32767 à 32767
– Valeurs numériques réelles (float / double) :
(1.1 + 3.3) + 5.5 → 9.900000
Mais
1.1 + (3.3 + 5.5) → 9.900001
– Calculs
• Faits en fonction des types des opérandes pas du type du résultat
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
37
Langage C : types
Type
Taille
Entier
signé
Entier non signé
8 bits
int8_t
char
uint8_t
unsigned char
16 bits
int16_t
int
uint16_t
unsigned int
32 bits
int32_t
long
uint32_t
unsigned long
64 bits
int64_t
long long
uint64_t
unsigned long long
(1)
Réel
Booléen
Pointeur
bool (1)
type *
void *
float
double
A condition d’avoir mis : #include <stdbool.h> les valeurs sont true et false
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
38
Langage C : valeurs numériques
Une valeur numérique peut être affectée à une variable : x = 156;
Une valeur numérique peut être donnée à une constante: #define x 156
Sans précision supplémentaire les valeurs numériques sont considérées comme
des entiers signés (int)
•
•
•
•
On peut préciser leur taille par L (long) ou LL (long long)
On peut préciser l’absence de signe par U (non signé)
Et on peut combiner les deux
Pour les réels il suffit qu’apparaisse un . dans la valeur (15.0 et pas 15)
•
Exemples :
–
–
–
–
–
–
–
Entier signé :
Entier long signé :
Entier long long signé :
Entier non signé :
Entier long non signé :
Entier long long non signé :
Réel :
int16_t val = 25;
int32_t val = 1000000L;
int64_t val = 1000000000LL;
uint16_t val = 3252U;
uint32_t val = 1000000UL;
uint64_t val = 1000000000ULL;
float val = 15.0;
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
#define val 25
#define val 1000000L
#define val 1000000000LL
#define val 3252U
#define val 1000000UL
#define val 1000000000ULL
#define val 15.0
39
Langage C : les bases
• Un nombre peut être écrit :
• En décimal
v = 4568;
u = -25478
• En hexadécimal
v = 0xA01E;
• En binaire
v = 0b01101101;
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
40
Langage C : opérations
•
Opérations logiques (dans une condition (if, while, …)) :
–
–
–
–
–
–
•
ET :
OU :
NON :
Egalité :
Non égalité :
Inégalités :
a && b
a || b
!a
a == b
a != b
a < b , a > b , a <= b , a >= b
Opérations binaires (entre mots binaires) :
–
–
–
–
–
–
ET :
x&y
OU :
x|y
OU Exclusif :
x^y
NON :
~x
Décalage logique à gauche N fois : x << N
Décalage logique à droite N fois : x >> N
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
41
Opérations binaires
Les opérations binaires de ET, OU, NON et de décalage nous seront utiles.
•
ET
&
•
0 | 0 = 0 , 0 | 1 = 1 , 1 | 0 = 1, 1 | 1 = 1
11010111
00101000
~0=1,~1=0
Décalage à droite
>>
•
11010111
01100110
11110111
NON
~
•
0 & 0 = 0 , 0 & 1 = 0 , 1 & 0 = 0, 1 & 1 = 1
OU
|
•
11010111
01100110
01000110
11010111
01101011
Décalage des bits vers la droite et mise à 0 du bit de gauche
Décalage à gauche
<<
11010111
10101110
Décalage des bits vers la gauche et mise à 0 du bit de droite
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
42
Positionner un bit d’un registre
• Positionner le bit 4 du registre R à 1 sans modifier les autres :
– R = R | 0b00010000;
• Positionner le bit 4 du registre R à 0 sans modifier les autres :
– R = R & 0b11101111;
• Positionner le bit N du registre R à 1 sans modifier les autres :
– R = R | (1 << N);
• Positionner le bit N du registre R à 0 sans modifier les autres :
– R = R & (~(1<<N));
• Macros :
#define SET_BIT(reg, num)
#define CLR_BIT(reg, num)
(reg = reg | (1<<num))
(reg = reg | (~(1<<num)))
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
43
Tester un bit d’un registre
• Tester si le bit 4 du registre R est à 0 :
– if( (R & 0b00010000) == 0)
• Tester si le bit 4 du registre R est à 1 :
– if( (R & 0b00010000) != 0)
• Tester si le bit N du registre R est à 0 :
– if( (R & (1 << N)) == 0)
• Tester si le bit N du registre R est à 1 :
– if( (R & (1 << N)) != 0)
• Macros :
#define IS_CLR_BIT(reg, num) ((reg & (1<<num)) == 0)
#define IS_SET_BIT(reg, num) ((reg & (1<<num)) != 0)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
44
Interruptions
• Chaque contrôleur de périphérique peut générer des interruptions
• À une interruption est associée une fonction qui sera
immédiatement exécutée
• La prise en compte d’une interruption est très rapide (inférieur à la
microseconde)
Prise en compte d’une interruption :
Traitement
en cours
Interruption
Reprise,du
traitement
suspendu
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
Traitement associé
à l'interruption
45
Interruptions : préemption
• Que se passe t-il si une interruption survient pendant l’exécution
de la fonction associée à une interruption ?
Comportement 1
Comportement 2
Traitement
en cours
Traitement
en cours
Interruption 1
Interruption 1
Reprise,du
traitement
suspendu
Interruption 2
Traitement associé
à l'interruption 1
Traitement associé
à l'interruption 2
Reprise,du
traitement
suspendu
Interruption 2
Traitement associé
à l'interruption 1
Traitement associé
à l'interruption 2
• Dépend du niveau de préemption des interruptions 1 et 2 :
– Si le niveau de préemption de l’interruption 2 est inférieur à celui de la 1 :
comportement 1
– Si le niveau de préemption de l’interruption 2 est supérieur ou égal à celui de la 2 :
comportement 2
Le 2560 n’a pas de préemption (comportement 2)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
46
Interruptions : priorité
Exemple :
1.
2.
3.
4.
5.
6.
Un traitement est en cours
Une interruption (IT1) arrive
Le traitement est suspendu et la fonction associée à l’IT1 est démarrée
Pendant son exécution une interruption (IT2) arrive : elle est mise en attente
Puis une interruption (IT3) arrive : elle est mise en attente
La fonction associée à l’IT1 se termine …
Que va t-il se passer ?
– Comportement 1 : on exécute la fonction associée à l’IT2 puis celle associée à
l’IT3
– Comportement 2 : on fait le contraire
• Dépend du niveau de priorité des interruptions IT2 et IT3 :
– Si le niveau de priorité de l’interruption 2 est inférieur à celui de la 3 : comportement 1
– Si le niveau de priorité de l’interruption 2 est supérieur à celui de la 3 : comportement 2
Le 2560 a des priorités fixes
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
47
Interruptions : utilisation
•
Comment utiliser les interruptions ?
– Si on a le choix (timers par exemple) choisir le contrôleur de périphérique en
fonction de la priorité des ses événements (par exemple le timer 1 est plus
prioritaire que le timer 3)
– Associer à un événement du contrôleur de périphérique une fonction à exécuter
lorsque l’interruption se produit
•
Syntaxe :
ISR(xxx_vect) {
…
}
– xxx dépend du périphérique par exemple ADC pour le convertisseur
analogique/numérique
•
Quand utiliser les interruptions ?
–
–
–
–
Evénement urgent (pour le traiter immédiatement)
Evénement qui ne dure pas (pour ne pas le louper)
Traitement à faire à des instants précis (pour respecter précisément ces dates)
Evénement exceptionnel (pour ne pas avoir à surveiller sans arrêt s’il se produit)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
48
Entrées / Sorties numériques
du XMega 2560
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
49
Lignes d’entrées/sorties numériques
•
85 lignes pilotées par 11 contrôleurs de périphériques (Ports)
•
Chaque contrôleur de périphérique pilote plusieurs lignes :
–
–
–
–
•
Ports A,B,C,D,E,F,H, K, L : 8 lignes
Port G : 6 lignes
Port J : 7 lignes
Le Port I n’existe pas
Une ligne peut être programmée :
– Comme entrée reliée à un capteur numérique (lecture 0 ou 1)
– Comme sortie reliée à un actionneur numérique (écriture 0 ou 1)
– Comme fonction reliée à un autre contrôleur de périphériques
• En entrée : (mesure de temps, commande de périphérique , entrée analogique)
• En sortie : (commande temporelle d’actionneur)
•
Une ligne en entrée peut générer une interruption lorsqu’elle change d’état :
– Passage de 0 à 1 = front montant
– Passage de 1 à 0 = front descendant
– Tout changement
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
50
Capteur numérique
• Un capteur numérique produit une information numérique de type 0
ou 1
• Exemple :
– Un capteur de lumière produit 1 quand il reçoit de la lumière et 0 sinon
– On peut l’utiliser pour détecter un passage
Faisceau lunineux
Emetteur de
lumière
Récepteur de
lumière
1
Information
du récepteur
0
Durée du
passage
Temps entre 2 passages
Début du
passage
Fin du
passage
Nouveau
passage
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
51
Lignes en entrées numériques
• Utilisation d’une ligne comme entrée numérique binaire :
– Programmation de la ligne en entrée :
• Mettre à 0 le bit correspondant du registre DDRx
• Exemple : programmer la ligne 2 du Port C en entrée :
CLR_BIT(DDRC, 2);
– Lecture de l’état de la ligne :
• Tester la valeur du bit correspondant du registre PINx
• Exemple : tester si la ligne 2 du Port C est à 1 :
if (IS_BIT_SET(PINC, 2)) …
– Etat d’une ligne non connectée :
• Quand une ligne n’est pas connectée son état est indéterminé. Si on veut
imposer que cet état soit à 1 on peut, à l’initialisation, mettre à 1 le bit
correspondant du registre PORTx
• Exemple : imposer un niveau 1 sur la ligne 2 du Port C si elle n’est pas
connectée :
SET_BIT(PORTB, 2);
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
52
Exemple : Compteur de passage
Sur une chaîne de production on veut compter les objets produits par
une machine.
Ces objets sortent de la machine sur un tapis roulant.
• On place un faisceau lumineux en travers du tapis roulant
• Le faisceau est coupé quand quelque chose passe devant
• Le capteur est un capteur de lumière qui produit :
– Un niveau 1 quand il reçoit de la lumière
– Un niveau 0 quand il n’en reçoit pas
• On l’a relié à la ligne 4 du Port B (pourquoi pas ?)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
53
Exemple : Solution
Le programme :
int main(void) {
CLR_BIT(DDRB, 4); // Capteur = entrée numérique
int compteur = 0; // Comptage des passages
while (true) { // Le programme fait ça indéfiniment (que ferait-il d’autre ?)
if (IS_CLR_BIT(PINB, 4)) { // Le faisceau est coupé
compteur++; // On compte un passage
printf("Nombre d’objets : %d\n" , compteur); // Affichage
}
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
54
Exemple : test
•
On teste ce programme :
–
–
–
•
Pourquoi ?
–
–
•
On le lance : il n’affiche rien (normal)
Un objet passe devant le faisceau
Le programme affiche : 1548798 lignes (inattendu !)
On lance le programme : il boucle en trouvant la ligne à 1  il n’affiche rien
Un objet coupe le faisceau 
• il trouve la ligne à 0, incrémente le compteur et affiche
• Au tour de boucle suivant la ligne est toujours à 0 : l’objet n’a pas fini de
passer  il incrémente le compteur et affiche …
Que faire ?
–
Attendre que l’objet soit passé c’est-à-dire que la ligne revienne à 1 :
while (true) { // Le programme fait ça indéfiniment
if (IS_CLR_BIT(PINB, 4)) { // Le faisceau est coupé
compteur++; // On compte un passage
printf("Nombre de tours : %d\n" , compteur); // Affichage
while (IS_CLR_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 1
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
55
Exemple : nouveau capteur
•
•
On remplace le faisceau par un contact mécanique placé au bord
du tapis roulant
Il est appuyé par chaque objet qui passe
•
Que faut-il modifier ?
–
Le niveau de sortie du capteur est maintenant 1 au contact et non 0
comme pour le faisceau
int main(void) {
CLR_BIT(DDRB, 4); // Capteur = entrée numérique
int compteur = 0; // Comptage des passages
while (true) { // Le programme fait ça indéfiniment (que ferait-il d’autre ?)
if (IS_SET_BIT(PINB, 4)) { // Le contact est appuyé
compteur++; // On compte un passage
printf("Nombre d’objets : %d\n" , compteur); // Affichage
while (IS_SET_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 0
}
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
56
Exemple : test
• On teste ce programme :
– Un objet passe devant le contact
– Le programme affiche : 15 passages
• Pourquoi ?
– Les capteurs mécaniques ne produisent pas une valeur stable quand ils sont activés :
• Le contact est ouvert  sa sortie est à 0
• L’objet ferme le contact  sa sortie oscille entre 0 et 1 plusieurs fois (et pas
toujours le même nombre de fois) avant de se stabiliser à 1
• Quand l’objet est passé sa sortie oscille entre 1 et 0 plusieurs fois (et pas toujours
le même nombre de fois) avant de se stabiliser à 0
Ceci est dû aux vibrations mécaniques du contact mécanique
Ces oscillations sont rapides (quelques ms) mais le microcontrôleur est plus
rapide encore  il va détecter plusieurs actions successives sur le contact et
non une seule (comme si on était passé plusieurs fois très très vite)
Que faire ?
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
57
Capteur mécanique
Utilisation d’une ligne comme entrée numérique
reliée à un capteur mécanique :
L'objet libère
le contact
L'objet active
le contact
L'état de le ligne est 1
L'état de le ligne est 0
L'état de la
ligne est
instable
L'état de la ligne
est instable
Délai de filtrage
L'état de le ligne est 0
Délai de filtrage
Pour résoudre ce problème on doit ignorer les oscillations pendant un délai de
Fin du
Fin du
du
Début du
quelques msDébut
:délai de
délai de
délai
de
délai de
•
•
flitrage
flitrage
flitrage
flitrage
En général une valeur de 20 à 50 ms est suffisante mais le mieux c’est
encore de faire des mesures ou de tester quelques valeurs.
La ligne est considérée comme étant à 0
La ligne est considérée
comme étant à 1
On utilisera dans ce but un Timer (vu plus loin)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
La ligne est considérée
comme étant à 0
58
Capteur mécanique
Solution avec délai :
int main(void) {
CLR_BIT(DDRB, 4); // Capteur = entrée numérique
int compteur = 0; // Comptage des passages
while (true) { // Le programme fait ça indéfiniment (que ferait-il d’autre ?)
if (IS_SET_BIT(PINB, 4)) { // Le contact est appuyé
// Attendre 20 à 50 ms
compteur++; // On compte un passage
printf("Nombre d’objets : %d\n" , compteur); // Affichage
while (IS_SET_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 0
// Attendre 20 à 50 ms
}
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
59
Lignes en sorties numériques
• Utilisation d’une ligne comme sortie numérique binaire :
– Programmation de la ligne en sortie :
• Mettre à 1 le bit correspondant du registre DDRx
• Exemple : programmer la ligne 2 du Port C en sortie :
SET_BIT(DDRC, 2);
– Modification de l’état de la ligne :
• Modifier la valeur du bit correspondant du registre PORTx
• Exemple : mettre à 1 la ligne 2 du Port C :
SET_BIT (PORTC, 2)) …
– Basculement de l’état de la ligne :
• Pour basculer l’état de la ligne mettre à 1 le bit correspondant du registre PINx
• Exemple : basculer la ligne 2 du Port C :
SET_BIT(PINB, 2);
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
60
Exemple : pilotage d’une DEL
On a relié une DEL à la ligne 6 du Port C et un bouton tactile
(sans rebonds) à la ligne 5 du Port C.
A chaque touché, le bouton allume/éteint la DEL en bascule
#define DEL
6
#define BOUTON 5
int main(void) {
SET_BIT(DDRC, DEL); // ligne de la DEL en sortie
CLR_BIT(PORTC, DEL); // initialement éteinte
CLR_BIT(DDRC, BOUTON); // ligne du bouton tactile en entrée
while (true) { // Le programme fait ça indéfiniment
while (IS_CLR_BIT(PINC, BOUTON)) { // Attendre un touché du bouton
SET_BIT(PINC, DEL); // Allumer/éteindre la DEL
while (IS_SET_BIT(PINC, BOUTON)) { // Attendre bouton non touché
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
61
Evénements
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
62
Evénement exceptionnel
•
•
Sur une imprimante 3D on prévoit un bouton de changement de filament pour pouvoir
imprimer des objets multicolores. Ce bouton permet de suspendre/reprendre
l’impression.
L’événement produit par ce bouton :
–
–
Peut se produire à tout moment
Est exceptionnel
•
La façon la plus simple de gérer ce genre d’événement est de lui associer une fonction
d’interruption qui sera automatiquement exécutée quand on appuiera le bouton
•
Cette fonction :
–
–
–
•
Interrompra le programme en cours où qu’il en soit
Arrêtera l’imprimante jusqu’à ce qu’on ait changé le filament et appuyé à nouveau le bouton
Quand ce bouton aura été activé une deuxième fois, la fonction d’interruption se termine et le
programme reprend où il en était.
De cette façon :
–
–
La prise en compte du bouton est faite immédiatement quoi que fasse le programme à ce
moment
Après changement du filament l’impression reprend où elle en était
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
63
Interruptions externes
• Le 2560 permet d’associer des interruptions aux changements
d’état d’une ligne (passage de 0 à 1 = front montant ou de 1 à 0 =
front descendant)
• Certaines lignes (INT0 à INT7) permettent de choisir le front de
déclenchement de l’interruption (front montant ou front descendant
ou tous les fronts)
– Lignes INT 0 à 7 :
• Lignes 0 à 3 du Port D et lignes 4 à 7 du Port E
• D’autres lignes (PCINT0 à PCINT23) déclenchent l’interruption sur
tous les fronts sans choix possible
– Lignes PCINT 0 à 23:
• Lignes 0 à 7 du Port B, ligne 0 du Port E, lignes 0 à 6 du Port J et
lignes 0 à 7 du Port K
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
64
Fonction d’interruption
•
Association d’une fonction d’interruption à une ligne INT :
1. Mettre la ligne en entrée
Exemple : INT5 correspond à la ligne 5 du Port E
CLR_BIT(DDRE, 5);
2. Choisir le front de déclenchement par le registre EICRA (INT0 à 3) ou EICRB (INT4 à 7).
• Les bits 7 et 6 correspondent à INT3 (EICRA) ou 7 (EICRB)
• Les bits 5 et 4 correspondent à INT2 (EICRA) ou 6 (EICRB)
• Les bits 3 et 2 correspondent à INT1 (EICRA) ou 5 (EICRB)
• Les bits 1 et 0 correspondent à INT0 (EICRA) ou 4 (EICRB)
Leur valeur définit le front :
– 01 : tous les fronts
– 10 : fronts descendants
– 11 : fronts montants
Exemple : INT5 en détection de front montant
EICRB = EICRB | 0b00001100;
3. Effacer les indicateurs d’interruption par le registre EIFR
Exemple : pour INT5 c’est le bit 5 de EIFR
SET_BIT(EIFR, 5); // ATTENTION : on efface le bit en y écrivant un 1
4. Autoriser le déclenchement de l’interruption par le registre EIMSK
Exemple : pour INT5 c’est le bit 5 de EIMSK
SET_BIT(EIMSK, 5);
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
65
Ecriture de la fonction d’interruption
• Autoriser la prise en compte des interruptions par le microcontrôleur :
sei();
• Ecrire la fonction d’interruption :
ISR(INTx_vect) {
…
}
La prise en compte de l’interruption efface automatiquement l’indicateur
correspondant dans le registre EIFR
• Pour l’exemple précédent (INT5) :
ISR(INT5_vect) {
…
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
66
Fonction d’interruption
• Association d’une fonction d’interruption à une ligne PCINT :
1. Mettre la ligne en entrée
Exemple : PCINT21 correspond à la ligne 5 du Port K
CLR_BIT(DDRK, 5);
2. Autoriser le déclenchement de l’interruption par le registre PCMSK0 (PCINT0 à
7) ou PCMSK1 (PCINT8 à 15) ou PCMSK2 (PCINT16 à 23)
Exemple : PCINT21 c’est le bit 5 de PCMSK2
SET_BIT(PCMSK2, 5);
Les interruptions sont regroupées : les lignes PCINT0 à 7 provoquent
l’interruption PCINT0, les lignes 8 à 15 l’interruption PCINT1 et les
lignes 16 à 21 l’interruption PCINT2
3. Effacer les indicateurs d’interruption par le registre PFICR
Exemple : pour PCINT21 (interruption 2) c’est le bit 2 de PFICR
SET_BIT(PFICR, 2);
4. Autoriser le déclenchement de l’interruption par le registre PCICR
Exemple : pour PCINT21 (interruption 2) c’est le bit 2 de PCICR
SET_BIT(PCICR, 2);
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
67
Ecriture de la fonction d’interruption
•
Autoriser la prise en compte des interruptions par le microcontrôleur par
l’instruction :
sei();
•
Ecrire la fonction d’interruption :
ISR(PCINTx_vect) {
…
}
•
Pour l’exemple précédent (PCINT21) c’est l’interruption 2 :
ISR(PCINT2_vect) {
…
}
La prise en compte de l’interruption efface automatiquement l’indicateur
correspondant dans le registre PFICR
Remarque : Comme la même interruption correspond à 8 lignes il faudra
éventuellement tester l’état de ces lignes pour savoir laquelle a produit
l’interruption.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
68
Exemple : imprimante 3D
•
Programme de l’imprimante
int main() {
Initialisations
while (true) {
if (carteSD) {
Lire une commande dans le fichier
if (fin de fichier) while(true) {} // se bloquer (fin d’impression)
}
else {
Attendre une commande sur le port série (relié à l’USB)
// On se bloque si aucune commande n’arrive (fin d’impression)
}
Exécuter la commande
if (! carteSD)
Signaler la fin d’exécution de commande sur le port série
}
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
69
Exemple : imprimante 3D
Interruption de changement de filament :
•
On a relié un bouton sur la ligne 5 du Port E (INT5) que l’on a programmée pour
générer une interruption au front montant (appui sur le bouton)
•
Fonction d’interruption :
ISR(INT5_vect) { // L’utilisateur a appuyé sur le bouton
CLR_BIT(EIMSK, 5); // interdire l’IT suivante (le prochain appui relance le programme)
while(IS_SET_BIT(PINE, 5)) {} // attendre que le bouton soit lâché
// L’utilisateur a lâché le bouton
// Il change le fil
// Puis il appuie à nouveau le bouton
while(IS_CLR_BIT(PINE, 5)) {} // attendre que le bouton soit appuyé à nouveau
SET_BIT(EIFR, 5); // Effacer l’indicateur d’IT
SET_BIT(EIMSK, 5); // autoriser l’IT suivante pour changement de filament suivant
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
70
Critique
• Le programme peut être suspendu à n’importe quel moment
• Pendant l’exécution de le fonction d’interruption rien d’autre ne peut
être pris en compte :
– Le programme ne tourne plus
– Aucune autre interruption n’est prise en compte (pas de préemption sur
le 2560)
• Par exemple si le programme est suspendu en plein milieu de
l’exécution d’une commande et que cette commande à démarré un
moteur il ne s’arrêtera plus …
De façon générale il vaut mieux éviter qu’une fonction d’interruption ne
dure trop longtemps
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
71
Bonne solution
• Prévoir des points où le programme peut être arrêté puis
repris
– Dans notre exemple se serait à la fin de chaque exécution de
commande avant de passer à la suivante.
• Positionner une variable dans la fonction d’interruption
que le programme testera en chacun de ces points.
• Cette variable doit être globale et volatile pour pouvoir
être partagée (lue / modifiée) par le programme ET par
la fonction d’interruption
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
72
volatile bool arret;
Bonne solution (suite)
int main() {
ISR(INT5_vect) { // L’utilisateur a appuyé sur le bouton
Initialisations
CLR_BIT(EIMSK, 5); // interdire l’IT suivante
arret = false; // L’impression va démarrer
arret = true;
while (true) {
}
if (carteSD) {
Lire une commande dans le fichier
if (fin de fichier) while(true) {} // se bloquer (fin d’impression)
}
else {
attendre une commande sur le port série (relié à l’USB)
// On se bloque si aucune commande n’arrive (fin d’impression)
}
Exécuter la commande
if (arret) { // L’impression a été suspendue par l’utilisateur
while(IS_SET_BIT(PINE, 5)) {} // attendre que le bouton soit lâché
while(IS_CLR_BIT(PINE, 5)) {} // attendre que le bouton soit appuyé à nouveau
SET_BIT(EIFR, 5); // Effacer l’indicateur d’IT
SET_BIT(EIMSK, 5); // autoriser l’IT suivante
arret = false; // L’impression reprend
}
if (! carteSD) {
Signaler la fin d’exécution de commande sur le port série
}
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
73
Le temps
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
74
Le temps (délais)
• Respecter les temps du système réel
•
Exemple :
– Mesure de distance par ultra sons :
•
•
•
•
Un émetteur produit des ultra sons
Ces ultra sons se reflètent sur une surface (mur)
Un récepteur capte les ultra sons
En mesurant le temps de parcours (aller-retour) des US on connaît la distance (vitesse
des US dans l’air = 340 m/s)
– Mais
• S’il n’y a pas d’obstacle on va attendre indéfiniment que le capteur reçoive
– Solution :
• Quand on commence à attendre que le capteur reçoive on déclenche un délai
• Si ce délai se termine avant que le capteur n’ait reçu c’est qu’il n’y a pas d’obstacle (ou
qu’il est trop loin)  on peut arrêter d’attendre
• Le délai pourra être :
– Celui correspondant à la distance à partir de laquelle l’obstacle peut être ignoré
– Celui correspondant à la portée de l’émetteur US
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
75
Le temps (répétition)
• Déclencher une opération à intervalles réguliers
• Exemple :
– Régulateur de vitesse :
• Un capteur permet de connaître la vitesse du véhicule
• Un actionneur pilote la pompe à injection
– Principe :
• En boucle
– Contrôler la vitesse
– Si elle n’est pas celle voulue augmenter ou diminuer le débit de la
pompe
– Si on utilise un algorithme de type PID :
• Il faut mesurer la vitesse à intervalles réguliers
• On utilisera des délais précis et répétitifs pour faire les mesures
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
76
Le temps (mesure)
• Mesurer des temps du système réel
• Exemple :
– ABS :
• Un capteur sur chaque roue indique sa vitesse de rotation
• Un actionneur sur chaque roue pilote la pression du liquide de freinage
– Principe :
• Si une roue tourne moins vite que les autres c’est qu’elle dérape
 diminuer sa pression de freinage pour retrouver l’adhérence
– Comment marche un capteur de vitesse de roue ?
• Contact mécanique appuyé à chaque tour (usure trop rapide)
• Faisceau lumineux coupé à chaque tour (trop fragile, humidité, poussière)
• Un capteur magnétique activé par le passage d’un aimant à chaque tour
– Mesure de la vitesse :
• Par mesure du temps entre 2 détections de l’aimant par le capteur
• La vitesse se calcule en fonction du périmètre de la roue (fixe)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
77
Timers (principe)
•
Le temps est géré par des Timers qui permettent :
– De générer des délais répétitifs
– De mesurer des durées
– De lancer des mesures à intervalles réguliers (conversion A/N)
•
Le 2560 possède 6 Timers (2 comptent sur 8 bits : Timer 0 et Timer 2, les 4
autres comptent sur 16 bits : Timer 1 et Timers 3 à 5)
•
Principe de fonctionnement :
– Un Timer contient un compteur qui change au rythme d’une horloge, il produit un
événement quand ce compteur atteint une valeur limite (LIM) ou quand il arrive à
sa valeur maximale (256 ou 65535). Puis le compteur repart de 0
Tu
Tops d'horloge
0
1
2
3
…
LIM-2
LIM-1
Tu = temps entre 2 tops = 1/ fréquence horloge
LIM
Valeur du compteur
Evénement
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
78
Timers (manipulations)
• On peut programmer :
– La fréquence de l’horloge (donc le temps entre 2 tops : Tu)
– La valeur limite (LIM)
• On peut (re)lancer/arrêter le Timer
• On peut savoir s’il a atteint la limite ou associer une fonction d’interruption à
l’événement d’atteinte de la limite
• On peut savoir s’il a débordé (255 ou 65535) ou associer une fonction d’interruption à
l’événement de débordement du compteur
• On peut modifier la limite même en cours de fonctionnement
• On peut lire / modifier le compteur même en cours de fonctionnement
• On peut obtenir automatiquement une copie de la valeur du timer lors d’un événement
• On peut utiliser le timer pour générer des signaux périodiques sur des lignes
numériques
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
79
Paramétrage des Timers
•
L’horloge de comptage est obtenue à partir de celle du CPU (16 MHz) ou d’une
horloge externe.
•
On peut utiliser comme horloge du compteur :
–
–
–
–
–
–
–
–
•
Celle du CPU : tu = 1/16 µs
Le 1/8ème de celle du CPU : tu = 1/2 µs
Le 1/32ème de celle du CPU seulement sur le Timer 2 : tu = 2 µs
Le 1/64ème de celle du CPU : tu = 4 µs
Le 1/128ème de celle du CPU seulement sur le Timer 2 : tu = 8 µs
Le 1/256ème de celle du CPU : tu = 16 µs
Le 1/1024ème de celle du CPU : tu = 64 µs
Une horloge externe de fréquence maximale 16 MHz
Le compteur est un entier non signé sur 8 bits (0 à 255) ou sur 16 bits (0 à 65535).
Durées maximales possibles (en µs / en ms / en s):
Division
Tu (µ
µs)
1
1/16
8
1/2
Timer 0
16
128
Timer 2
16
128
Timers 1, 3, 4 et 5
4,096
32,768
32
2
64
4
128
8
1,024
512
1,024
2,048
262,114
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
256
16
1024
64
4,096
16,384
4,096
16,384
1,048576
4,194304
80
Timers : calculs
•
On veut générer un délai de 0,1 s (100 ms) ou mesurer une durée ne
dépassant pas 0,1 s :
– Choix de l’horloge
Division
Tu (µ
µs)
1
1/16
8
1/2
Timer 0
16
128
Timer 2
16
128
Timers 1, 3, 4 et 5
4,096
32,768
32
2
64
4
128
8
1,024
512
1,024
2,048
262,114
256
16
1024
64
4,096
16,384
4,096
16,384
1,048576
4,194304
– On va prendre une division par 64 (la durée maximale est de 262,114 ms)
– Le temps unitaire Tu est de 4 μs
– Nombre de tops d’horloge correspondant au délai ou au temps :
• 0,1 s (0,1 106 μs) correspondent au comptage de :
0,1 106 / 4 = 25 000 tops d’horloge
• Lors d’une mesure de temps, si le Timer a compté N tops d’horloge c’est que le
temps mesuré est de N * 4 μs.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
81
Timers : Registres
Les timers 1, 3, 4 et 5 ont 10 registres (les timers 0 et 2 en ont moins
ce sont des versions simplifiées)
•
TCCRiA :
–
–
•
TCCRiB :
–
–
–
•
Permet de provoquer par programme une comparaison de valeur (rarement utilisé)
ICRi :
–
•
Choix de l’événement de capture (copie automatique de la valeur du compteur)
2 premiers bits du choix du mode de fonctionnement
Choix de la division d’horloge / arrêt du timer
TCCRiC :
–
•
Pilotage de lignes en sortie (génération de signaux par le timer)
2 derniers bits du choix du mode de fonctionnement
Registre recevant la valeur du compteur lors d’une capture et pouvant servir de limite de
comptage
OCRiA, OCRiB et OCRiC :
–
–
Valeurs en permanence comparées au contenu du compteur.
Seul OCRiA peut aussi servir de limite de comptage
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
82
Timers : Registres (suite)
• TIMSKi :
– Autorisation / interdiction des interruptions :
•
•
•
•
•
Lors d’une capture
Lorsque le compteur atteint la valeur contenue dans OCRiA
Lorsque le compteur atteint la valeur contenue dans OCRiB
Lorsque le compteur atteint la valeur contenue dans OCRiC
Lorsque le compteur déborde
• TIFRi :
– Indicateurs d’événements (les 5 événements ci-dessus)
• Mis à 1 lors de l’événement
• Mis à 0 par écriture d’un 1 dans le bit correspondant ou lors de la prise en
compte de l’interruption
• TCNTi :
– Valeur du compteur du timer
– Peut être lue ou modifiée même en cours de comptage
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
83
Utilisation des Timers (délai)
• Pour générer un délai de durée θ ou répéter une opération
chaque θ il faut :
– Choisir une vitesse d’horloge permettant de pouvoir atteindre cette
valeur θ avec une précision maximale.
– Calculer le nombre de tops d’horloge correspondant le plus
exactement possible à θ.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
84
Programmation de Timers (délais)
Initialisation d’un Timer pour générer un délai :
– TCCRiA ← 00000000
– TCCRiB ← 000xx000
• xx =
• 00
• 01
si la limite de comptage est la valeur maximale (65 535)
si la limite de comptage est la valeur de OCRiA
– OCRiA ← limite de comptage si xx = 01
– TIFRi ← 00011111 pour effacer les indicateurs d’événements
– TIMSKi ← 000000yz
• y=1
• z=1
si on veut une interruption quand le compteur atteint la valeur de OCRiA
Cette interruption est utilisable quelle que soit la valeur de xx.
si on veut une interruption quand le compteur atteint la valeur 65535.
Cette interruption n’est utilisable que si xx = 00.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
85
Programmation de Timers (délais)
• Lancement du Timer (par choix d’une horloge)
– TCCRiB ← TCCRiB | 00000hhh
• hhh =
•
•
•
•
•
•
•
001 : division d’horloge par 1
010 : division d’horloge par 8
011 : division d’horloge par 64
100 : division d’horloge par 256
101 : division d’horloge par 1024
110 : horloge externe sur fronts descendants
111 : horloge externe sur fronts montants
• Arrêt du Timer (par arrêt de l’horloge)
– TCCRiB ← TCCRiB & 11111000
• Mise à 0 du Timer (par écriture du compteur)
– TCNTi ← 0
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
86
Programmation de Timers (délais)
•
Savoir si le délai est terminé :
– Si la limite est 65 535 :
if(IS_BIT_SET(TIFRi, 0)) { // Indicateur de débordement
SET_BIT(TIFRi, 0); // Pour le remettre à 0
}
–
Si la limite est la valeur de OCRiA :
if(IS_BIT_SET(TIFRi, 1)) { // Indicateur de débordement
SET_BIT(TIFRi, 1); // Pour le remettre à 0
}
•
Associer une fonction d’interruption à la fin du délai :
– Si la limite est 65 535 :
ISR(TIMERi_OVF_Vect) { … }
–
Si la limite est la valeur de OCRiA :
ISR(TIMERi_COMPA_Vect) { … }
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
87
Exemple : Clavier
• Pour un digicode on
utilise un clavier à 12
touches organisé en une
matrice de 4 lignes et 3
colonnes
L0
L1
L2
L3
C0
C1
Pour savoir si une touche est appuyée :
1. On met au niveau 0 la ligne Li (les autres sont à 1)
2. On regarde si on trouve un niveau 0 sur une colonne
C2
Par exemple : si quand on met à 0 la ligne L2 on trouve un 0 sur
la colonne C1 c’est que la touche à l’intersection de la ligne 2
et de la colonne 1 est appuyée
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
88
Clavier : solution 1
•
On écrit un programme qui scrute le clavier en boucle :
int main() {
// init des 4 lignes en sortie
// init des 3 lignes en entrée avec maintien à 1 quand non connectées
while (true) {
for(int i = 0; i < 3; i++) { // balayer les lignes
mettre toutes les lignes à 1
mettre la ligne i à 0
for(int j = 0; j < 2; j++) { // tester les colonnes
si la colonne i est à 0 traiter la touche (i,j)
}
}
}
}
•
•
L’inconvénient c’est que le programme ne fait que ça
En réalité il n’est pas utile de scruter le clavier en boucle il suffirait de le faire
de temps en temps (assez vite par rapport au temps d’appui d’une touche
par l’utilisateur)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
89
Clavier : solution 2
• On programme un timer pour scruter le clavier à intervalles réguliers.
Par exemple 10 fois par seconde
• On va utiliser une fonction d’interruption associée au timer
• A chaque interruption on scrute une ligne
• La fonction d’interruption positionne des variables globales que le
programme pourra tester quand il veut
– 1 booléen indique si une touche a été appuyée
– 2 entiers indiquent le numéro de ligne et de colonne de cette touche
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
90
Clavier : solution 2
Timer 1 pour un délai de 1/40 s = 25 ms (on a 4 lignes à
scruter chaque 1/10s) :
void initTimer() {
TCCR1A = 0;
TCCR1B = 0b00001010;
// Limite de comptage dans OCR1A,
// div par 8 pour arriver à 25 ms (Tu = ½ µs)
OCRiA = 25000*2; // Durée de 25 ms avec Tu = ½ µs
TIFRi = 0b00011111; // Effacer les indicateurs
TIMSKi ← 00000010 // IT chaque 25 ms (OCR1A)
sei(); // autoriser la prise en compte des IT par le processeur
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
91
Clavier : solution 2
Fonction d’interruption :
volatile bool toucheAppuyee; // Indicateur pour le programme
volatile uint8_t ligne, colonne; // N°de ligne et de colonne pour le programme
uint8_t ligneScrutee; // Dernière ligne scrutée
ISR(TIMERi_COMPA_Vect) { // Fonction d’IT chaque 1/40 s
Mettre à 1 toutes les lignes
Mettre à 0 la ligne de n° « ligneScrutee »
ligneScrutee = (ligneScrutee +1) % 4; // passer à la ligne suivante
Si l’une des 3 colonnes est à 0
ligne ← ligneScrutee
colonne ← n° de la colonne qui est à 0
toucheAppuyee ← true
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
92
Clavier : solution 2
Et le programme devient :
int main() {
// init des 4 lignes en sortie
// init des 3 lignes en entrée avec maintien à 1 quand non connectées
ligneScrutee = 0; // Pour démarrer par la 1ère ligne
toucheAppuyée = false; // Pas de touche appuyée au départ
while (true) {
// Traitements divers
if (toucheAppuyee) { // Quand on veut traiter la dernière touche appuyée
toucheAppuyee = false; // Pour détecter la prochaine touche
traiter la touche (ligne, colonne)
}
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
93
Timers (mesure de durée)
•
Pour mesurer une durée il faut :
– En connaître la valeur maximale θ
– Choisir une vitesse d’horloge permettant de ne pas avoir de débordement
du compteur pour cette valeur θ tout en ayant une précision maximale. Ce
choix détermine la durée du temps unitaire Tu
– Lors de la mesure, on pourra calculer la durée exacte à partir du nombre
de tops d’horloge que le Timer a comptés (durée = nbre de tops * Tu).
– Lors de la mesure, on pourra également détecter un dépassement de cette
limite maximale θ par débordement du temps limite
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
94
Timers (mesure de durée)
La mesure d’une durée correspond à mesurer le temps qui
sépare deux événements.
• Il y 2 façons de procéder :
1. Par programme :
Le programme attend le 1er événement ou il y a une interruption associée à cet événement
Lors de cet événement le timer est démarré
Le programme attend le second événement ou il y a une interruption associée à cet
événement
Lors de cet événement on relève la valeur du timer et on le remet à 0 pour la mesure suivante
2. Par capture :
Le programme attend le 1er événement ou il y a une interruption associée à cet événement
Lors de cet événement le timer est démarré
Le second événement provoque une copie automatique de la valeur du timer dans le registre
ICRi (capture)
Le programme attend cette capture ou il y a une interruption associée à la capture
Lors de cet événement on relève la valeur du timer et on le remet à 0 pour la mesure suivante
Remarque : La seconde méthode ne peut être utilisée que si l’événement 2 est un
changement d’état (front montant ou descendant) d’une ligne associée au timer
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
95
Mesure de durée sans capture
Initialisation d’un Timer :
– TCCRiA ← 00000000
– TCCRiB ← 000xx000
• xx =
• 00 si la durée maximale est 65 535
• 01 si la durée maximale est définie par la valeur de OCRiA
– OCRiA ← durée maximale si xx = 01
– TIFRi ← 00011111 pour effacer les indicateurs d’événements
– TIMSKi ← 000000yz
• y = 1 si on veut une interruption quand le compteur atteint la valeur de OCRiA
Cette interruption est utilisable quelle que soit la valeur de xx.
• z = 1 si on veut une interruption quand le compteur atteint la valeur 65535.
Cette interruption n’est utilisable que si xx = 00.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
96
Mesure de durée sans capture
•
Lancement du Timer (par choix d’une horloge)
– TCCRiB ← TCCRiB | 00000xxx
• xxx =
•
•
•
•
•
•
•
001 : division d’horloge par 1 (Tu = 1/16 µs)
010 : division d’horloge par 8 (Tu = 1/2 µs)
011 : division d’horloge par 64 (Tu = 4 µs)
100 : division d’horloge par 256 (Tu = 16 µs)
101 : division d’horloge par 1024 (Tu = 64 µs)
110 : horloge externe sur fronts descendants
111 : horloge externe sur fronts montants
•
Arrêt du Timer (par arrêt de l’horloge)
– TCCRiB ← TCCRiB & 11111000
•
Mise à 0 du Timer (par écriture du compteur)
– TCNTi ← 0
•
Lecture de la mesure (par lecture du compteur)
– uint16_t mesure = TCNTi;
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
97
Mesure de durée sans capture
•
Savoir si la durée maximale est dépassée :
– Si la limite est 65 535 :
if(IS_BIT_SET(TIFRi, 0)) { // Indicateur de débordement
SET_BIT(TIFRi, 0); // Pour le remettre à 0
}
–
Si la limite est la valeur de OCRiA :
if(IS_BIT_SET(TIFRi, 1)) { // Indicateur de débordement
SET_BIT(TIFRi, 1); // Pour le remettre à 0
}
•
Associer une fonction d’interruption au dépassement de la durée maximale :
– Si la limite est 65 535 :
ISR(TIMERi_OVF_Vect) { … }
–
Si la limite est la valeur de OCRiA :
ISR(TIMERi_COMPA_Vect) { … }
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
98
Mesure de durée par capture
•
Une ligne physique est associée à chaque Timer
•
On choisit le changement d’état (front montant ou descendant) de cette ligne
qui provoquera la capture du Timer
•
Pour éviter les déclenchements parasites (si la ligne est instable) on peut
demander à ce que la capture n’ait lieu que si ce changement a duré au
moins 4 périodes de l’horloge du Timer (4 * Tu)
•
Lors de cet événement, la valeur du compteur est copiée dans le registre ICRi
et une interruption peut être générée. Mais le Timer continue de compter
•
Lignes associées aux timers
–
–
–
–
Timer 1 : ligne 4 du Port D
Timer 3 : ligne 7 du Port E
Timer 4 : ligne 0 du Port L
Timer 5 : ligne 1 du Port L
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
99
Mesure de durée par capture
Initialisation d’un Timer :
– TCCRiA ← 00000000
– TCCRiB ← ab0xx000
• a=1
si le changement d’état doit durer au moins 4 périodes d’horloge du Timer (4*Tu)
• b=0
capture au front descendant, b = 1 capture au front montant
• xx =
• 00 si la limite de comptage est la valeur maximale (65 535)
• 01 si la limite de comptage est la valeur de OCRiA
– OCRiA ← durée maximale si xx = 01
– TIFRi ← 00011111 pour effacer les indicateurs d’événements
– TIMSKi ← 00c000yz
• c=1
• y=1
• z=1
si on veut une interruption au moment de la capture
si on veut une interruption quand le compteur atteint la valeur de OCRiA
Cette interruption est utilisable quelle que soit la valeur de xx.
si on veut une interruption quand le compteur atteint la valeur 65535.
Cette interruption n’est utilisable que si xx = 00.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
100
Mesure de durée par capture
•
Lancement du Timer (par choix d’une horloge)
– TCCRiB ← TCCRiB | 00000xxx
• xxx =
•
•
•
•
•
•
•
001 : division d’horloge par 1 (Tu = 1/16 µs)
010 : division d’horloge par 8 (Tu = 1/2 µs)
011 : division d’horloge par 64 (Tu = 4 µs)
100 : division d’horloge par 256 (Tu = 16 µs)
101 : division d’horloge par 1024 (Tu = 64 µs)
110 : horloge externe sur fronts descendants
111 : horloge externe sur fronts montants
•
Arrêt du Timer (par arrêt de l’horloge)
– TCCRiB ← TCCRiB & 11111000
•
Mise à 0 du Timer (par écriture du compteur)
– TCNTi ← 0
•
Lecture de la mesure (par lecture du registre de capture)
– uint16_t mesure = ICRi;
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
101
Mesure de durée par capture
•
Savoir si la durée est dépassée :
– Si la limite est 65 535 :
if(IS_BIT_SET(TIFRi, 0)) { // Indicateur de débordement
SET_BIT(TIFRi, 0); // Pour le remettre à 0
}
–
Si la limite est la valeur de OCRiA :
if(IS_BIT_SET(TIFRi, 1)) { // Indicateur de débordement
SET_BIT(TIFRi, 1); // Pour le remettre à 0
}
•
Associer une fonction d’interruption au dépassement de la durée :
– Si la limite est 65 535 :
ISR(TIMERi_OVF_Vect) { … }
–
Si la limite est la valeur de OCRiA :
ISR(TIMERi_COMPA_Vect) { … }
•
Associer une fonction d’interruption à la capture :
ISR(TIMERi_CAPT_Vect) { … }
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
102
Exemple : mesure de vitesse
• Moteur couplé à un disque transparent
• Le disque possède des raies noires chaque 6°
• Un faisceau lumineux détecte les raies
• En mesurant le temps entre 2 passages de raies on
peu connaître la vitesse de rotation du moteur
• Contraintes du système :
– Vitesse maximale du moteur : 10000 tr/min
– Vitesse minimale à mesurer : 50 tr/min
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
103
Mesure de vitesse : choix des valeurs
•
Il faut choisir une vitesse d’horloge et une limite du Timer correctes :
– La vitesse d’horloge définit la précision de la mesure de vitesse du moteur
– La limite définit le temps maximum mesurable donc la vitesse minimale
mesurable du moteur
•
Formules de calcul de la vitesse :
– D = durée entre 2 passages d’une raie (en µs)
– T = temps d’un tour = D * 360/6 = 60*D (en µs)
– V = vitesse du moteur = 60*1000000 / T = 1000000 / D (en tours / min)
•
La vitesse minimale à mesurer Vmin est de 50 tr/min
 Dmin = 100000/50 = 20000 µs = 20 ms
 On va choisir une division d’horloge par 8 (max = 32,768 ms)  Tu = ½ µs
Le temps unitaire est de ½ µs donc la limite sera 40000
•
La vitesse maximale à mesurer Vmax est de 10000 tr/min
 Dmax = 1000000/10000 = 100 µs
Le temps unitaire est de ½ µs donc on comptera jusqu’à 200 (précision 0,5%)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
104
Mesure de vitesse (inits)
Remarque : Pour cet exemple on n’utilisera pas le mode capture
void initTimer() {
TCCR1A = 0; // Pas de capture : on mesure par programme
TCCR1B = 0b00001000; // Limite de comptage dans OCR1A, timer arrêté
OCRiA = 40000; // Durée pour 50 tr/min avec Tu = ½ µs
TIFRi = 0b00011111; // Effacer les indicateurs
TIMSKi ← 00000010 // IT si débordement (OCR1A)
sei(); // autoriser les IT du processeur
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
105
Mesure de vitesse (programme)
int main(void) {
initTimer(); // Initialisation du Timer
CLR_BIT(DDRB, 0); // Capteur du faisceau lumineux
// Lancer le timer pour la 1ère mesure (la 1ère mesure sera fausse)
TCCR1B = TCCR1B | 0b00000010; // Div par 8
while (true) { // Le programme fait ça indéfiniment
while (IS_CLR_BIT(PINB, 0)) {} // Attendre un passage de raie
uint16_t D = TCNT1; // Récupérer la mesure
TCNT1 = 0; // Remettre le timer à 0 pour la prochaine mesure
uint16_t vitesse = 100000UL / D;
printf("Vitesse = %d tr/min\n" , vitesse);
while (IS_SET_BIT(PINB,0)) {} // Attendre la fin du passage de la raie
}
}
ISR(TIMER1_OVF_Vect) { // Cas de débordement du Timer
printf("Vitesse trop lente\n");
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
106
Commandes temporelles
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
107
Génération de signaux : principe
• Certains actionneurs (moteurs, servomoteurs, …) sont pilotés par
des signaux temporels
• Les Timers du 2560 peuvent être utilisés comme générateurs de
signaux capables de créer des signaux temporels
• Principe des signaux temporels :
1
0
durée
du 0
durée
du 1
période
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
108
Génération de signaux : utilisation
Servomoteur :
• Un servomoteur est un moteur que l’on peut faire tourner pour le placer à
un angle précis.
•
Ils sont utilisés en robotique (mouvements de bras de robots par exemple),
en modélisme (dérive d’un avion), etc.
•
Un servomoteur reçoit un signal temporel :
– La période du signal est imposée (20 ms pour la plupart des servomoteurs)
– La durée du 1 (ou du 0 selon le modèle) définit l’angle que doit prendre le moteur
(relation linéaire)
– Exemple :
•
•
•
•
•
Le moteur peut se placer entre -90°et +90°
La période est de 20 ms
Si le signal reste à 0 pendant 600 μs le moteur se place à -90°
Si le signal reste à 0 pendant 2400 μs le moteur se place à +90°
Donc si le signal reste à 0 pendant 1500 μs le moteur se place à 0°
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
109
Génération de signaux : utilisation
Moteur à courant continu :
• Un moteur à courant continu est un moteur dont la vitesse de rotation dépend
du courant qu’on lui fournit
•
Pour en régler la vitesse on peut :
– Régler le courant qui lui est fourni (difficile à faire)
– L’alimenter avec un courant constant mais pendant un temps limité
•
Régulation de vitesse :
– Le moteur reçoit du courant  il tourne
– On coupe le courant  il continue sur son élan mais ralentit
– Si on coupe/renvoie le courant suffisamment vite (10000 à 40000 fois par seconde),
le moteur ne fait pas des phases successives d’accélération/ralentissement mais
reste à une vitesse constante (inertie du moteur)
– On peut donc contrôler sa vitesse par un signal temporel (la durée du 1 donc du
passage du courant définit la vitesse du moteur).
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
110
Générateurs de signaux
• Les Timers du 2560 sont reliés à 3 lignes chacun (OCA, OCB et OCC) :
– La vitesse d’horloge et la limite de comptage définissent la période du signal
– Chaque ligne peut produire un signal temporel direct (pilotage de la durée du 1)
– Ou un signal temporel inversé (pilotage de la durée du 0)
Timer
OCA
OCB
OCC
1
Port B ligne 5
Port B ligne 6
Port B ligne 7
3
Port E ligne 3
Port E ligne 4
Port E ligne 5
4
Port H ligne 7
Port H ligne 6
Port H ligne 5
5
Port L ligne 3
Port L ligne 4
Port L ligne 5
• Possibilité de modifier la période et la durée du 1 (ou du 0) pendant que le
Timer fonctionne.
• Possibilité de générer une interruption à chaque fin de période
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
111
Générateurs de signaux
•
Principe de fonctionnement:
1. Le compteur du Timer compte (incrémenté) à partir de 0
2. Lorsqu’il atteint la valeur contenue dans OCRiA la ligne OCA passe à 1 (ou à 0
selon la programmation choisie)
3. Il en va de même pour les lignes OCB et OCC en fonction des valeurs de
OCRiB et OCRiC et de leur programmation
4. Le compteur arrive à la valeur limite
5. Le compteur repart de cette valeur limite en décomptant (décrémenté)
6. Lorsqu’il atteint la valeur contenue dans OCRiA la ligne OCA passe à 0 (ou à 1
selon la programmation choisie)
7. Il en va de même pour les lignes OCB et OCC en fonction des valeurs de
OCRiB et OCRiC et de leur programmation
8. Lorsque le compteur arrive à 0 (fin de la période du signal) , si une interruption a
été autorisée, elle se produit
9. Il recommence en 1
•
Valeurs :
•
•
•
La période du signal est 2*Limite*Tu
En mode direct la durée du 1 est 2*OCRiA ou 2*OCRiB ou 2*OCRiC
En mode inverse la durée du 0 est 2*OCRiA ou 2*OCRiB ou 2*OCRiC
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
112
Générateurs de signaux
• Les signaux produits :
Limite
compteur du timer
OCRiB
OCRiC
OCRiA
Période = 2*Limite
OCA
OCB
OCC
Période - 2*OCRiA
IT
Période - 2*OCRiB
Période - 2*OCRiC
OCA programmé en inverse (durée du 1 = Période – 2*OCRiA  durée du 0 = 2*OCRiA)
OCB programmé en inverse (durée du 1 = Période – 2*OCRiB  durée du 0 = 2*OCRiB)
OCC programmé en direct (durée du 0 = Période – 2*OCRiC  durée du 1 = 2*OCRiC)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
113
Programmation de Timers (signaux)
Initialisation d’un Timer pour générer des signaux :
•
TCCRiA ← aa’bb’cc’01
– aa’ =
• 00
• 10
• 11
signal OCA non utilisé
signal OCA direct : durée du 1 proportionnelle à 2*OCRiA
signal OCA inverse : durée du 0 proportionnelle à 2*OCRiA
– bb’ = idem pour OCB
– cc’ = idem pour OCC
•
TCCRiB ← 00010000
•
ICRi ← limite de comptage : la période est proportionnelle à 2*ICRi
•
OCRiA/B/C ← durée du 0 ou du 1 : la durée est proportionnelle à 2*OCRiA/B/C
•
TIFRi ← 00011111 pour effacer les indicateurs d’événements
•
TIMSKi ← 0000000z
– z=1
si on veut une interruption quand le compteur atteint la valeur 0
donc en fin de période.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
114
Programmation de Timers (délais)
• Lancement du Timer (par choix d’une horloge)
– TCCRiB ← TCCRiB | 00000xxx
• xxx=
•
•
•
•
•
•
•
001 : division d’horloge par 1 (Tu = 1/16 µs)
010 : division d’horloge par 8 (Tu = 1/2 µs)
011 : division d’horloge par 64 (Tu = 4 µs)
100 : division d’horloge par 256 (Tu = 16 µs)
101 : division d’horloge par 1024 (Tu = 64 µs)
110 : horloge externe sur fronts descendants
111 : horloge externe sur fronts montants
• Changement de la période (en général pas utilisé)
– ICRi ← nouvelle demi période
• Modification de la durée du 1 ou du 0
– OCRiA/B/C ← nouvelle demi durée
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
115
Exemple : vitesse de moteur
•
Contrôle de la vitesse d’un moteur à courant continu
•
La vitesse maximale du moteur est de 6800 tr/min
•
On va le piloter par un générateur de signal qui créera des cycles
marche/arrêt du moteur très rapides
•
Signal à générer :
– Fréquence :
• Il faut qu’elle soit suffisamment rapide pour que le moteur n’ait pas le temps
de faire des cycles démarrage/arrêt mais tourne en continu à vitesse réduite :
dépend du moteur mais en général de l’ordre de 10 à 30 KHz.
On prendra 20 KHz (période = 50 µs)
– Durée du 1 :
• Plus la durée du 1 sera grande plus la vitesse sera grande.
•
On veut écrire une fonction qui règle la vitesse à une valeur en tours/min
donnée en paramètre
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
116
Moteur : intialisations
•
Programmation du générateur de signal :
– La période est de 50 µs on peut donc prendre une division par 1 (maxi 4 ms)
– Le temps unitaire (temps entre 2 tops) est donc de 1/16 μs
– La valeur pour 50 µs est alors : 50*16 = 800 donc la limite sera de 400
– Une variation de 1 du seuil correspondra à une variation de 1/400 = 0,25% de la
vitesse
– On a connecté le moteur sur la ligne 4 du Port E qui est la sortie OCB du Timer 2 :
– Initialisation :
SET_BIT(DDRE,4); // ligne en sortie
TCCR3A = 0b00100001; // sortie OCB directe (OCA et OCC non utilisées)
TCCR3B = 0b00010001; // Mode génération de signal, H div 1
ICR3 = 400; // Période de 50 µs
OCR3B = 200; // Réglage initial à 50% de la vitesse
TIFR3 = 0b00011111; // pour effacer les indicateurs d’événements
TIMSK3 = 0b00000000; // Pas d’IT de période
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
117
Moteur : réglage de vitesse
•
Lorsque OCR3B est à 0 la durée du 1 est nulle donc le signal est toujours à 0 et
le moteur est arrêté
•
Lorsque OCR3B est à 400 le signal est toujours à 1 donc le moteur est à sa
vitesse maximale (6800 tr/min)
•
La relation entre la vitesse du moteur (V) et la valeur de OCR3B (S) est donnée
par une droite d’équation : V = a*S+b
– S = 0  V = 0 donc b = 0
– S = 400  V = 6800 donc a = 6800/400 = 17
•
L’équation donnant la valeur à mettre dans OCR3B en fonction de la vitesse
désirée V en tr/min est : S = V / 17
•
Précision :
– On ne peut pas régler la vitesse du moteur à 1 tr/min près mais seulement à 6800/400
= 17 tr/min près
– C’est-à-dire à 0,25% près, généralement ce sera bien suffisant
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
118
Entrées analogiques
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
119
Lignes d’entrées analogiques
•
Certains capteurs produisent une information à valeurs continues (ex :
température entre -55°et 125°)
•
Cette information est transmise par une tension électrique comprise entre 2
valeurs V1 et V2 (dépendant du capteur)
•
Le 2560 accepte, sur ses lignes d’entrées analogiques, des tensions
comprises, selon sa configuration, entre 0 et 5V ou 0 et 2,56V ou 0 et 1,1V
ou 0 et une valeur définie par une ligne externe ne pouvant pas dépasser 5V
•
Si le capteur dépasse ces limites (V1<0 ou V2>5V) il faudra faire une
adaptation externe (décalage et/ou division de la tension)
•
Pour pouvoir être traités par un programme ces informations doivent être
transformées en valeurs numériques (un entier entre 0 et N)
•
C’est le rôle du convertisseur analogique/numérique que contient le
microcontrôleur
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
120
Conversion A/N par rampe
• Fonctionnement :
– Simple rampe :
• On génère un signal dont la tension V part de 0 et augmente régulièrement (selon une droite
de pente fixe p) on a donc : V = p * t
• On mesure le temps θ que met ce signal pour atteindre la tension à mesurer Vx
La tension à mesurer est Vx = p * θ et p est fixe et connu
– Double rampe
• C’est une amélioration du précédent où on mesure un temps sur une droite de pente p1
positive pour arriver à V puis le temps sur une droite de pente p2 négative pour revenir à 0 
plus précis
pt
V=
• Avantages :
– Précis (ne dépend que de la précision de la mesure du temps)
– Simple donc peu cher
0
pente = p
• Inconvénients :
– Lent (plusieurs dizaines à plusieurs centaines de ms)
– La double rampe est plus précise mais plus lente que la simple rampe
• Utilisé dans les appareils de mesure car la précision prime sur la vitesse
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
121
Conversion A/N par dichotomie
•
Fonctionnement :
– Dichotomie
• La tension à mesurer est comparée à 1/2 de la valeur maximale mesurable
Vmax (par ex 5 V)
• Selon qu’elle est au dessus ou au dessous de la moitié on la compare avec
1/4 ou (1/2 + 1/4) de la valeur maximale mesurable
• On continue avec 1/8 puis 1/16 etc. jusqu’à la précision souhaitée
•
Avantages :
– Rapide (de l’ordre de la µs) car chaque comparaison donne un bit supplémentaire
du résultat
– Pour un résultat sur 12 bits il faut faire 12 étapes de comparaison alors qu’avec la
simple rampe il faut compter jusqu’à 212 (et avec la double rampe encore plus).
•
Inconvénient :
– La précision dépend de celle des références Vmax/2, Vmax/4, … etc.
•
Utilisé dans les microcontrôleurs, les cartes son, etc. car vitesse adaptée à
celle de processeurs
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
122
Conversion A/N rapide
• Fonctionnement :
– Parallèle (flash)
• La tension à mesurer est comparée en parallèle à toutes les valeurs
possibles c’est-à-dire que pour un résultat sur n bits il faut la
comparer à toutes les tensions Vk = k * Vmax/2n pour k = 0 à 2n -1
• Avantages :
– Très rapide (de l’ordre de la ns) car les comparaisons se font en
parallèle
• Inconvénients :
– Complexité liée à la précision (il faut 2n valeurs de référence exactes)
– Cher (peut dépasser 1000 €)
• Utilisé dans les radars, la vidéo, etc. car la vitesse prime
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
123
Convertisseur A/N : caractéristiques
• Un convertisseur A/N est caractérisé par :
– Sa précision (nombre de bits de l’entier correspondant à la mesure)
– Son temps de conversion (généralement réglable)
• Equation d’un convertisseur A/N
–
–
–
–
La tension d’entrée doit être comprise entre 0 et Vmax
Le résultat de la conversion est un entier naturel sur N bits
Une entrée à 0 V produit une mesure de 0
Un entrée à Vmax produirait une mesure de 2N
– L’équation qui donne la tension V en entrée en fonction du résultat de la
mesure M est : V = (M * Vmax) / 2N
– L’équation qui donne le résultat de la mesure M en fonction de la
tension V en entrée est : M = (V * 2N) / Vmax
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
124
Convertisseur A/N du 2560
•
Le convertisseur A/N du 2560
– Possède 18 entrées :
•
•
•
•
•
8 sont reliées aux lignes 0 à 7 du Port F (entrées 0 à 7)
8 sont reliées aux lignes 0 à 7 du Port K (entrées 8 à 15)
1 est reliée à une tension fixe de 1,1 V (entrée 16)
1 est reliée à une tension fixe de 0 V (entrée 17)
Fonctionnement du convertisseur A/N du 2560
– Entrées :
• On peut convertir la tension présente sur l’entrée de son choix
– Début de conversion :
• La conversion d’une entrée peut être démarrée par programme (quand c’est fini le
convertisseur s’arrête)
• La conversion d’une entrée peut être lancée en continu (quand c’est fini le convertisseur
recommence)
• La conversion d’une entrée peut être démarrée par un Timer (à intervalles réguliers)
– Fin de conversion :
• Chaque fois que la conversion d’une entrée est terminée le convertisseur produit un
événement qui peut être testé ou génère une interruption et on peut récupérer la valeur
mesurée sous forme d’un entier non signé
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
125
Convertisseur A/N du 2560
•
Le convertisseur A/N du 2560 est caractérisé par :
– Une précision sur 10 bits
– Un temps de conversion réglable entre 1,625 et 104 μs
– La tension d’entrée doit être comprise entre 0 et la tension de référence choisie
(5V , 2,56V , 1,1V ou externe mais ≤ 5V)
– Une entrée à 0 V produit une mesure de 0
•
Equation du convertisseur A/N du 2560 :
– Avec une tension de référence de 5V :
• L’équation qui donne la tension V en entrée en fonction du résultat de la mesure M est :
V = (M * 5) / 1024
• L’équation qui donne le résultat de la mesure M en fonction de la tension V en entrée est :
M = (V * 1024) / 5
– Avec une tension de référence de X (X = 2,56V ou 1,1V ou référence externe) :
• L’équation qui donne la tension V en entrée en fonction du résultat de la mesure M est :
V = (M * X) / 1024
• L’équation qui donne le résultat de la mesure M en fonction de la tension V en entrée est :
M = (V * 1024) / X
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
126
Convertisseur A/N (initialisation)
•
ADMUX ← aa’cuwxyz
–
•
–
•
aa’ = Choix de la tension de référence (Vmax)
• 00
Vmax définie par une référence externe (≤ 5 V)
• 01
Vmax = 5 V
• 10
Vmax = 1,1 V
• 11
Vmax = 2,56 V
c = 0 pour que la valeur soit cadrée à droite (1 elle est cadrée à gauche)
uwxyz = Choix de la ligne d’entrée
• 00000 à 00111
pour les entrées 0 à 7 ou 8 à 15 (selon le bit 3 de ADCSRB)
• 01110
pour l’entrée 16 qui est toujours à 1,1 V (le bit 3 de ADCRB doit être à 1)
• 01111
pour l’entrée 17 qui est toujours à 0V (le bit 3 de ADCRB doit être à 1)
ADCSRB ← 0000eabc
–
–
e = Complément du choix de l’entrée
• 0
pour les entrées 0 à 7
• 1
pour les entrées 8 à 17
abc = Choix du déclenchement des conversions (si le bit 5 de ADCRA est à 1 sinon inutile)
• 000
dès qu’une conversion est terminée la suivante démarre automatiquement
• 010
conversion lancé par les fronts montants de INT0 (ligne 0 du Port D)
• 011
conversion lancé quand le Timer 0 atteint la valeur de OCR0A
• 100
conversion lancé quand le Timer 0 atteint la valeur 255
• 101
conversion lancé quand le Timer 1 atteint la valeur de OCR1A
• 110
conversion lancé quand le Timer 1 atteint la valeur 65535
• 111
conversion lancé lors d’une capture sur le Timer 1 (ligne 4 du Port D)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
127
Convertisseur A/N (initialisation)
•
ADCSRA ← mpeitabc
– m = 1 pour que le convertisseur marche, si m = 0 il est arrêté
– p ← 1 pour lancer une conversion par programme
– e = 0 pour que le convertisseur soit déclenché par programme
1 pour que le convertisseur soit déclenché par la ligne INT0 ou par un timer
– i : passe à 1 quand une conversion est terminée, revient à 0 quand l’interruption
de fin de conversion est prise en compte ou si on le met à 1
– t = 1 pour autoriser l’interruption de fin de conversion
– abc = temps de conversion
•
•
•
•
•
•
•
•
000
010
011
100
101
110
111
1,625 µs
3,25 µs
6,5 µs
13 µs
26 µs
52 µs
104 µs
ADC : registre sur 16 bits contenant le résultat de la dernière conversion
(entier non signé). La valeur sur 10 bits est cadrée à droite ou gauche selon
le bit c de ADMUX
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
128
Exemple : mesures d’accélération
• Pour la maintenance on veut suivre les
accélérations et décélérations subies par un robot
• On a choisi un capteur accéléromètre qui produit une tension qui :
– Augmente quand il subit une accélération
– Diminue quand il subit une décélération
• Comme la tension peut diminuer, au repos elle est au milieu : 5/2 = 2, 5 V
Tension de sortie
(V)
• Ce capteur mesure des accélérations
maximales de 6 G :
• La tension varie alors de 206 mV par G
2,5 V
Gmin
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
Gmax
Accélération
(G)
129
Mesures d’accélération
• Initialisation du convertisseur A/N :
– Temps de conversion court (3,25 µs) pour suivre au plus près l’évolution de
l’accélération mais pas trop court (1,625 µs) pour éviter les imprécisions
– Mode déclenché par programme pour suivre l’évolution de l’accélération
aussi vite que le permet le programme
– Donc pas d’interruptions
– La tension maximale renvoyée par l’accéléromètre est de 2,5 + 6*0,206 =
3,736 V (pour 6G) on prendra donc une tension de référence (Vmax) de 5 V
– Le capteur est connecté à la ligne 2 du Port K (entrée 10 du convertisseur)
ADMUX = 0b01000010; // Vmax = 5V, cadré à droite, entrée 10
ADCSRA = 0b10010010; // Marche, non lancé, décl par prog,
// effac indic IT, pas d’IT, conv en 3,25 µs
ADCSRB = 0b00001000; // entrée 10, inutilisé (le bit 5 de ADCRA est à 0)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
130
Mesures d’accélération : calculs
•
Conversion de la tension de sortie du capteur en accélération positive ou
négative :
Tension de sortie
(V)
2,5
-6
-4
-2
0
2
4
6
Accélération
(G)
– La fonction : tension de sortie → accélération est une droite de type :
accélération = a * tension + b
• accélération = 0  tension = 2,5
donc b = -2,5 a
• accélération = 1  tension = 2,5+0,206
donc 2,706 a + b = 1
• D’où l’on tire a = 1/0,206 = 1000/206 et b = -2,5 a = -250/206
– L’équation du capteur est donc :
accélération = ((1000 * tension) - 250) / 206
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
131
Mesures d’accélération :
programme
int main() {
ADMUX = 0b01000010; // Vmax = 5V, cadré à droite, entrée 10
ADCSRA = 0b10010010; // Marche, non lancé, décl par prog,
// effac indic IT, pas d’IT, conv en 3µs
ADCSRB = 0b00001000; // entrée 10, inutilisé (bit 5 de ADCRA à 0)
while(true) {
SET_BIT(ADCSRA, 6); // Lancer une conversion par programme
while(IS_CLR_BIT(ADCSRA, 5)) { } // attendre que la conversion soit finie
SET_BIT(ADCSRA, 5); // effacer l’indicateur de fin de conversion
uint16_t mesure = ADC; // Récupérer la mesure
// La convertir en accélération en G
float acc = ( (1000.0 * (mesure * 5.0 / 1024.0)) – 250.0) / 206.0;
…
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
132
Pilotage par Timer : échantillonnage
• L’utilisation du convertisseur A/N piloté par un Timer permet :
– De ralentir le rythme des mesures :
• Quand il n’est pas utile d’avoir des mesures très rapprochées (rythme
compatible avec le temps de réaction du système réel)
• Pour alléger le CPU
– De déclencher les mesures après un délai
• Respect du temps de réaction du système réel
– Exemple : on active un actionneur qui déclenche une émission de
chaleur et on veut en vérifier l’efficacité par un capteur de température.
– Il faut laisser le temps au système réel de chauffer.
– D’obtenir un échantillonnage régulier du signal
• Indispensable pour les méthodes de type PID
• Permet de faire des mesures ou des traitements liés au temps :
–
–
–
–
Temps de variation d’une valeur V1 à une valeur V2
Période du signal (temps entre 2 passages successifs à une valeur V)
Filtrage numérique (suppression de bruits, …)
Transformations mathématiques (Fourier, …)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
133
Déclenchement par Timer
Exemple
•
Dans un processus chimique on doit surveiller la température d’une cuve
et déclencher une alarme si elle dépasse 190°
•
Dans la cuve il y a un capteur de température capable de mesurer entre 0
et 250° qui renvoie une tension de 10 mV / °
•
Comme la température n’évolue pas vite (la cuve est grande) on peut ne la
contrôler que 1 fois par seconde  convertisseur démarré par Timer
•
Le programme devant faire d’autres choses on utilisera une IT de fin de
conversion
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
134
Déclenchement par Timer
• Initialisation du convertisseur A/N :
– Temps de conversion moyen (33 µs) pour une bonne précision et
puisqu’on ne mesure que chaque seconde
– Mode déclenché par Timer (quand le Timer 1 atteint la valeur contenue
dans OCR1B)
– Avec interruptions
– La tension maximale renvoyée par le capteur est de 250*10 mV = 2,5 V
on prendra donc une tension de référence (Vmax) de 2,56 V
– Une mesure M correspondra à 2,56*M/1024 Volts soit à une température
de (2,56*M/1024)/(0,01) = M/4 °(précision au ¼°)
– Le capteur est connecté à la ligne 1 du Port F (entrée 1 du convertisseur)
ADMUX = 0b11000001; // Vmax = 2,56V, cadré à droite, entrée 1
ADCSRA = 0b10111110; // Marche, non lancé, décl par timer,
// effac indic IT, avec d’IT, conv en 33 µs
ADCSRB = 0b00000101; // entrée 1, Timer 1 atteint OCR1B
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
135
Déclenchement par Timer
• Initialisation du Timer :
– Déclenchement du convertisseur chaque seconde par le fait que le
compteur du Timer 1 atteint la valeur contenue dans OCR1B
 Division d’horloge par 256 (Tu = 16 µs) pour atteindre 1s
 La limite sera la valeur de ICR1 = 1000000/16 = 62500 (délai de 1 s)
 OCR1B aura la même valeur (62500) pour déclencher le convertisseur à
chaque fin de délai
TCCR1A = 0b00000000; // Pas de sorties de signal
TCCR1B = 0b00011100; // Pas de capture, limite dans ICR, div par 256
ICR1 = 62500UL; // limite = 1 s
OCR1A = 62500UL; // Déclenchement du convertisseur chaque s
TIFR1 = 0b00011111; // Effacement des indicateurs
TIMSK1 = 0b00000000; // Pas d’IT du Timer
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
136
Déclenchement par Timer
•
Fonction d’interruption :
ISR(ADC_Vect) { // Fin de conversion
// Comme le Timer ne génère pas d’IT il faut effacer ses indicateurs
// Sinon le convertisseur ne démarrera qu’une fois !
TIFR1 = 0b00011111; // Effacement des indicateurs
// (en fait seul l’effacement du bit 1 est nécessaire)
// Comme le convertisseur génère une IT de fin de conversion
// On n’a pas besoin d’effacer l’indicateur de fin de conversion
uint16_t mesure = ADC; // récupérer la mesure
// La convertir en température en °
uint16_t temp = mesure / 4; // la mesure est au ¼°
if ((mesure % 4) >= 2) temp++; // arrondi au plus proche
if (temp > 190) {
// Déclencher l’alarme
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
137
Bus de données
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
138
Bus de données
•
Certains capteurs et actionneurs "intelligents" envoient ou reçoivent des
valeurs numériques par des connexions série spécialisées (bus de
données).
•
Les plus répandus sont (dans l’ordre) :
– I2C (Inter Integrated Circuit) ou TWI (Two Wire Interface)
– SPI (Serial Peripheral Interface)
– I2S (Inter IC Sound) réservées aux capteurs/actionneurs de son
•
Plusieurs capteurs ou actionneurs peuvent être connectés sur la même
connexion (bus)
•
Le périphérique concerné doit être désigné :
– Par une adresse (I2C)
– Par une ligne séparée (SPI)
•
Le 2560 possède :
– 1 contrôleur de communication I2C
– 4 contrôleurs de communication SPI
– Pas de contrôleur de communication I2S
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
139
Bus de données
• Avantages
– Permet d’utiliser des capteurs ou actionneurs plus complexes :
• Un capteur GPS envoie 4 valeurs en réels
• Un écran LCD graphique reçoit des coordonnées d’écran et des couleurs
– Permet de relier N capteurs ou actionneurs par peu de fils (intéressant
en automobile, aviation, robotique, …)
– Communication standard (il existe des bibliothèques)
• Inconvénients
– Programmation plus complexe :
• Il faut programmer le contrôleur de bus du microcontrôleur
• Puis programmer les contrôleurs de chaque capteur/actionneur attaché
– Pilotage des capteurs/actionneurs plus complexe :
• Pour modifier le comportement d’un capteur/actionneur il faut lire/écrire dans
ses registres via le contrôleur de bus
– Pas de liaison directe
• Moins rapide
• On ne peut pas associer une fonction d’interruption à un capteur mais
seulement au contrôleur de bus donc à tous les capteurs qui y sont reliés.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
140
Bus de données
• Chaque capteur/actionneur possède un contrôleur
interne accessible par des registres :
– Registres de commande pour en piloter le fonctionnement
– Registre d’états pour en contrôler le fonctionnement
– Registres de données pour échanger des valeurs avec le
capteur ou l’actionneur
• Le dialogue avec le capteur/actionneur connecté se
limite à :
– Ecrire dans un registre interne de l’actionneur ou du capteur
(envoi de commandes ou de valeurs)
– Lire un registre interne de l’actionneur ou du capteur
(récupération d’états ou de valeurs)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
141
SPI
•
La communication SPI utilise 3 fils :
– Horloge (SCLK)
– 2 lignes de transmission de données
(une dans chaque sens MOSI et MISO)
•
Elle fonctionne en full-duplex : émission et réception
peuvent se faire simultanément
•
La vitesse maximale est de 180 Mbits/s
•
Principe de communication :
– Activation de la ligne correspondant au périphérique (SS)
– Envoi / réception de données sur 8 bits en série (MOSI / MISO)
Chaque bit est accompagné d’un changement d’état de la ligne d’horloge (SCLK)
•
Il faut utiliser des lignes en sortie numérique pour désigner le périphérique (SS1, …).
Et les mettre à 0 ou à 1 en fonction du périphérique désigné.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
142
I2C
•
La communication I2C utilise 2 fils :
– Horloge
– Données
•
Elle fonctionne en half-duplex : émission et réception se font en alternance
•
Les vitesses sont :
–
–
–
–
–
•
Standard :
Fast :
Fast plus :
High-speed :
Ultra High-speed :
100 Kbits/s
400 Kbits/s
1 MB/s
3,4 Mb/s
5 Mb/s
Principe de communication :
– Maître / Esclave
– Le maître :
•
•
•
•
•
Ouvre la communication
Désigne l’esclave par son adresse
Choisit le sens de communication (émission ou réception)
Envoie ou reçoit les données
Ferme la communication
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
143
I2C
• Chaque capteur/actionneur (esclave) a une adresse
(sur 7 ou 10 bits)
– Cette adresse est fixée par le constructeur
– Il est parfois possible de choisir une adresse
parmi un ensemble prédéfini
•
La vitesse d’horloge est définie par le maître (microcontrôleur)
•
Le périphérique doit s’y adapter mais peut imposer un ralentissement en forçant la
ligne d’horloge à 0 plus longtemps
•
Les bits d’acquittement (adresse et données) sont mis à 1 par l’émetteur mais forcés
à 0 par le récepteur :
–
–
•
Correspondant à cette adresse pour le premier
Ayant correctement reçu la donnée pour le second
L’émetteur teste l’état des ces bits pour savoir si la communication a fonctionné
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
144
I2C : Protocole
La connexion est toujours ouverte et fermée par le maître et l’esclave
se contente de répondre.
1. Ouverture de connexion :
– Envoyer un bit de START
– Attendre qu’il soit envoyé
– Vérifier que l’envoi du START s’est bien passé (correspond au cas où
la ligne ne serait pas disponible : multi maîtres)
2. Envoi de l’adresse :
– Envoyer l’adresse (7 ou 10 bits) complété à droite par 0 (émission) ou
1 (réception)
– Attendre qu’elle soit envoyée
– Regarder si l’esclave a répondu par ACK (l’absence de réponse
correspond à un NACK)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
145
I2C : protocole
3.
Envoi de message :
–
–
–
–
Envoyer un octet
Attendre qu’il soit envoyé
Regarder si l’esclave a répondu par ACK
Recommencer pour chaque octet
OU
Réception de message :
–
Préparer le périphérique pour répondre
•
•
–
–
–
3.
ACK si ce n’est pas le dernier octet à recevoir
NACK si c’est le dernier octet à recevoir
Attendre d’avoir reçu l’octet
Récupérer l’octet
Recommencer pour chaque octet
Fin de connexion :
–
Envoyer un bit de STOP
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
146
I2C du 2560
• Vitesse de communication
La fréquence Fcomm correspond au nombre de bits/s
– Elle est définie par la formule :
Fcomm = Fcpu / (16 + 2 * B * 4D) Fcpu = 16 MHz pour le 2560
– Registres du 2560 :
• TWBR ← B; // Le terme B de la formule
• TWSR ← xxxxxxdd’
– xxxxxx = code d’état (décrit plus loin)
– dd’ = facteur de division 0 à 3 // le terme D de la formule
– TWDR : registre dans lequel on met les octets à envoyer et on lit
les octets reçus
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
147
I2C du 2560
•
Programmation :
– TWCR ← frSsemoi
• f : (fin d’opération)
– passe à 1 quand une opération est terminée
– remis à 0 en y écrivant un 1. Sa remise à 0 lance l’opération suivante
• r : (fin de réception décidée par le maître)
– Mis à 1 pour indiquer que l’octet attendu n’est pas le dernier
– Mis à 0 pour indiquer que l’octet attendu sera le dernier (l’esclave arrêtera l’émission)
• S : (début de communication)
– Mis à 1 pour envoyer un bit de START
– Mis à 0 dès que le START a été envoyé (pour ne pas en envoyer un autre)
• s : (fin de communication)
– Mis à 1 pour envoyer un bit de STOP
– Revient automatiquement à 0 quand le STOP a été envoyé
• e : (débordement)
– Passe à 1 si l’on envoie une donnée alors qu’une opération est en cours (bit f)
• m : Mis à 1 pour que le contrôleur fonctionne (à 0 il est arrêté)
• o : non utilisé
• i : Mis à 1 pour autoriser la génération d’une IT chaque fois que le bit f passe à 1
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
148
I2C du 2560
Etats en mode maître :
• Il sont présents dans les bits 7 à 2 du registre TWSR.
• Leur valeur dépend de l’opération effectuée et permet de savoir si
cette opération s’est bien déroulée :
– Envoi du START :
• 00001 : START correctement envoyé
– Envoi de l’adresse pour émission :
• 00011 : l’esclave a répondu
• 00100 : aucun esclave n’a répondu
– Envoi de l’adresse pour réception :
• 01000 : l’esclave a répondu
• 01001 : aucun esclave n’a répondu
– Envoi d’une donnée :
• 00101 : l’esclave a acquitté la donnée
• 00110 : l’esclave n’a pas acquitté la donnée
• Dans tous les cas le code 00111 indique une perte de connexion
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
149
I2C du 2560
• Registres pour le mode esclave :
– TWAR ← aaaaaaab
• aaaaaaa = adresse de l’esclave (7 bits)
• b mis à 1 si l’esclave doit répondre au broadcast
– TWAMR ← mmmmmmm0
• mmmmmmm = masque d’adresse de l’esclave (7 bits) : les bits à 1
indiquent les bits d’adresse à ignorer.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
150
I2C du 2560
Etats en mode esclave :
•
Il sont présents dans les bits 7 à 2 de TWSR. Leur valeur permet de savoir
si une opération s’est bien déroulée :
– Réception d’adresse :
• 01100 : adresse pour émission reçue
• 10101 : adresse pour réception reçue
• 11110 : adresse de broadcast reçue
– Envoi d’une donnée :
• 10111 : le maître a acquitté la donnée (qui n’est pas la dernière)
• 11000 : le maître n’a pas acquitté la donnée
• 11001 : le maître acquitté la dernière donnée
– Réception d’une donnée :
• 100x0 : donnée reçue et ACK envoyé (x = 1 si réception en broadcast)
• 100x1 : donnée reçue et NACK envoyé (x = 1 si réception en broadcast)
– Fin de communication (STOP reçu) :
• 10100 : STOP reçu
•
Dans tous les cas les codes 01101, 01111 ou 10110 indiquent une perte de
connexion
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
151
Système temps réel
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
152
Systèmes d’exploitation
• Un système simple n’a pas besoin de système d’exploitation
– Au mieux il a un mini système (moniteur) qui :
• Gère la connexion USB
• Permet le téléchargement de programmes
• Permet le débogage par sonde JTag
• Dans un système complexe :
– Les microcontrôleurs qui pilotent les capteurs et actionneurs peuvent ne
pas avoir de SE
– Ceux qui supervisent peuvent en avoir un.
• Exemple : robot autonome
– Le ou les microcontrôleurs qui pilotent les capteurs et actionneurs du
robot n’ont pas de SE
– Le microcontrôleur qui calcule la trajectoire en fonction de la position du
robot, du plan du lieu et des obstacles a un SE
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
153
Système d’exploitation
• Deux grandes familles :
– Systèmes classiques adaptés au microcontrôleur :
• Noyau Linux allégé (pas d’utilisateurs, pas de disque, etc.)
• Drivers pour les contrôleurs de périphériques
• Eventuellement surcouche de type Android
– Systèmes "temps réel" :
• Noyau multitâche avec priorités :
– Tâches exécutées l’une après l’autre ou en temps partagé
(tâches de fond)
– Tâches exécutées à intervalles réguliers (tâches répétitives)
– Tâches déclenchées par des interruptions (tâches
exceptionnelles ou urgentes)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
154
Système temps réel
•
Un système temps réel permet :
– De définir des tâches avec des priorités entre-elles
– De définir des tâches ayant des dates d’exécution imposées qui deviendront
prioritaires quand la date s’approchera
– De définir des tâches déclenchées par des interruptions :
• Avec un niveau de préemption entre elles
• Avec un niveau de préemption vis-à-vis du SE lui-même (ordonnanceur)
– De bloquer/activer les interruptions du CPU (dangereux mais efficace en cas
d’extrême urgence)
– De créer et gérer des sémaphores et des Mutex
– De communiquer entre tâches par :
• Files (pipes)
• Boîtes à lettres
• Mémoire partagée
– De communiquer par réseau industriel (type CAN)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
155
Free RTOS
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
156
FreeRTOS
• Il s’agit d’un système temps réel simple adaptable à la plupart des
microcontrôleurs
• Il permet :
–
–
–
–
–
–
–
–
–
–
De lancer / arrêter des processus en parallèle
De donner des priorités à ces processus
De les mettre en sommeil pour une durée donnée
De leur permettre de passer leur tour (yield)
De les faire communiquer par des pipes
De les synchroniser par des sémaphores
De gérer les accès concurrents aux ressources par des Mutex
De créer des Timers logiciels
De gérer des signaux
…
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
157
Free RTOS
•
Le système est « open source »
– Permet de le paramétrer
– Permet de le personnaliser
– Permet de l’adapter à de nouveaux microcontrôleurs
•
Le système est modulaire
– On ne charge pas en mémoire les parties que l’on n’utilise pas  gain de place
en mémoire
•
Le système se présente sous la forme d’une simple bibliothèque à inclure
au projet
•
Le programme principal n’a plus de boucle infinie mais devient
l’ordonnanceur de système
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
158
FreeRTOS pour le 2560
•
L’ordonnanceur utilise le Timer 0 pour le temps partagé.
•
Le système n’utilise aucun autre contrôleur de périphérique qui sont donc disponibles
pour le programme.
•
Le quota de temps des processus (tâches) est de 5 ms :
–
–
–
•
Les interruptions (ISR) restent gérées par le programme (sauf celle du Timer 0 qui,
chaque 5 ms, relance l’ordonnanceur)
–
–
•
Changement de processus chaque 5 ms
Mise en sommeil de processus pour une durée multiple de 5 ms
Les Timers logiciels ont un temps unitaire Tu de 5 ms
Le programme reste « temps réel »
L’API du système propose des versions spéciales des fonctions pour être utilisées dans les
fonctions d’interruption
Le programmeur est sensé « savoir faire » :
–
–
–
–
–
On peut facilement planter le système (blocages des ITs, arrêt du timer 0, mauvaise gestion
de sémaphores, …)
Un processus peut empêcher les autres de tourner (famine) ou de démarrer
Les processus peuvent se bloquer indéfiniment
La mémoire et la pile peuvent déborder
…
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
159
Le programma principal
• Le programme principal (main) :
– Initialise les contrôleurs de périphériques partagés par plusieurs
tâches ou devant être initialisés dès le démarrage
– Initialise les variables globales
– Crée les sémaphores et les initialise
– Crée les pipes
– Crée les tâches et en définit les priorités
– Se transforme en ordonnanceur
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
160
Les tâches
• Les tâches (processus) :
– Initialisent les contrôleurs de périphériques qui leur sont propres
– Entrent dans une boucle infinie dans laquelle elles :
• Effectuent leur traitement
• Envoient des données par pipe à d’autres tâches
• Attendent des données dans des pipes ou testent si des données y
sont arrivées
• Se bloquent sur des sémaphores ou testent si des sémaphores sont
ouverts
• Bloquent ou débloquent d’autres tâches par des sémaphores
• Se mettent en sommeil pour un temps donné
• Passent leur tour et laissent d’autres tâches s’exécuter
• Manipulent des variables globales
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
161
Les fonctions d’interruption
• Les fonctions d’interruption :
–
–
–
–
Effectuent les traitements urgents
Envoient des données par pipe à des tâches
Bloquent ou débloquent des tâches par des sémaphores
Manipulent des variables globales
• Contraintes :
– Les fonctions d’interruption doivent être de courte durée pour ne pas
empêcher les tâches et l’ordonnanceur lui-même de fonctionner
– Les fonctions d’interruption ne doivent pas se bloquer (sinon tout se
bloque !)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
162
Pourquoi un STR ?
• Pourquoi utiliser un système temps réel ?
–
–
–
–
–
Simplification d’écriture (tâches bien identifiées)
Modularité (chaque tâche s’occupe d’une seule chose)
Evolutivité (ajouter des tâches dans les version futures)
Parallélisme (faire plusieurs chose en même temps)
Sécurité du code (priorités, synchronisation)
• Quand ne pas l’utiliser ?
– S’il est inutile (le problème est simple)
– S’il est inefficace (5 ms c’est trop long)
– S’il consomme trop de ressources (trop de mémoire, charge le
CPU, …)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
163
Ordonnanceur
• Démarrage de l’ordonnanceur :
– vTaskStartScheduler()
• Arrêt/reprise des tâches :
– vTaskSuspendAll()
– xTaskResumeAll()
• Nombre de tâches :
– uTaskGetNumberOfTasks()
• Durée écoulée depuis le lancement de l’ordonnanceur :
– xTaskGetTickCount()
– TaskGetTickCountFromISR()
Renvoie la durée dans un uint16_t (en nombre de ticks de 5 ms modulo
65536)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
164
Tâches
• Création d’une tâche :
– xTaskCreate(fct, nom, pile, param, priorité, descripteur)
• fct : fonction exécutant la tâche.
• nom : nom de la tâche, ce nom ne sert pas au fonctionnement de la tâche
mais peut être utile pour des traces
• pile : taille de la pile, peut être : configMINIMAL_STACK_SIZE
• param : paramètre passé à la tâche lors de sa création, pointeur de type
void * qui peut être NULL
• priorité : priorité de la tâche peut être défini par tskIDLE_PRIORITY + k (k =
1 à 3), tskIDLE_PRIORITY = 0 est la priorité de la tâche idle.
• descripteur : descripteur de la tâche déclaré par TaskHandle_t *. Il sera
initialisé par xTaskCreate et permettra par la suite de désigner la tâche (il
peut être NULL si on n’a plus besoin de désigner cette tâche).
La valeur de retour est pdPASS si la tâche a été créée et
errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY sinon.
• Tâche :
– Elle doit être de la forme : void fct(void *param) { … }
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
165
Opérations sur les tâches
•
Destruction d’une tâche :
– vTaskDelete(descripteur)
•
Récupération de la priorité d’une tâche
– uxTaskPriorityGet(descripteur)
• Renvoie la priorité de la tâche (de 0 à 4, 0 est la priorité de la tâche idle)
•
Changement de la priorité d’une tâche :
– vTaskPrioritySet(descripteur, priorité)
•
Nom de la tâche :
– pcTaskGetName(descripteur)
• renvoie le nom de la tâche (2ème paramètre de xTaskCreate)
•
Suspendre une tâche
– vTaskSuspend(descripteur)
•
Reprendre une tâche
– vTaskResume(descripteur) ou vTaskResumeFromISR(descripteur)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
166
Cycle de vie d’une tâche
•
Attende d’une durée donnée en nombre de ticks de 5ms :
– vTaskDelay(nbrTicks)
•
Attente jusqu’à une date précise :
– vTaskDelayUntil(datePrec, nbrTicks)
Exemple :
TickType tempsPrecedent; // date du démarrage précédent
tempsPrecedent = xTaskGetTickCount();// date du 1er démarrage
while (0==0) {
vTaskDelayUntil( & tempsPrecedent, periode); // tempsPrecedent est mis à jour
// faire quelque chose chaque ‘periode’ (exprimé en unités de 5ms)
}
•
Arrêt d’une attente
– xTaskAbortDelay(descripteur)
•
Passer son tour
– vTaskYIELD()
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
167
Exemple de tâches
•
Un programme doit :
–
–
•
Déclencher un traitement chaque fois que l’on appuie sur un bouton
Traiter une entrée analogique 10 fois par seconde
Tâche qui gère le bouton :
void bouton(void * param) {
CLR_BIT(DDRB, 0); // ligne du bouton
while(true) {
while (IS_CLR_BIT(PINB,0)) {} // attendre bouton appuyé
// Faire le traitement
while (IS_SET_BIT(PINB,0)) {} // attendre bouton lâché
}
}
•
Tâche qui gère l’entrée analogique :
void entree(void * param) {
// init du convertisseur en mode déclenché par programme
while(true) {
while (IS_CLR_BIT(ADCSRA, 4)) {} // attendre mesure
SET_BIT(ADCSRA, 4); // Effacer l’indicateur
// Faire le traitement de la valeur lue dans ADC
vTaskDelay(100/5); // attendre 1/10 s
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
168
Exemple : les priorités
• Priorité des tâches
– Si la tâche 1 (bouton) a une priorité supérieure à celle de la tâche 2, la
tâche 2 ne s’exécutera jamais car la tâche 1 ne s’arrête jamais (boucles
sur l’état de la ligne)
– Si elles ont la même priorité, la tâche 1 s’exécutera dès que la tâche 2 se
met en sommeil et la tâche 2 s’exécutera au moins toutes les 5 ms.
Les mesures analogiques pourront être retardées de 5 ms si au bout de
1/10s ce n’est pas au tour de la tâche 2 de démarrer (ce ne sera pas la
cas ici car il n’y a que 2 tâches et que la tâche 1 vient de tourner mais
dans le cas général c’est vrai !)
– Si la tâche 2 a une priorité supérieure à celle de la tâche 1, les 2 tâches
s’exécuteront car la tâche 2 se met en sommeil pour 1/10 s ce qui permet
à la tâche 1 de tourner.
Les mesures analogiques seront bien faites toutes les 1/10s puisque chaque
5 ms la tâche 2 sera prioritaire pour démarrer
On prendra donc une priorité plus élevée pour la tâche qui
surveille le signal analogique
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
169
Exemple : le programme
Le programme crée les 2 tâches puis se transforme en
ordonnanceur :
#define PRIORITE_TACHE_1
#define PRIORITE_TACHE_2
( tskIDLE_PRIORITY + 1 )
( tskIDLE_PRIORITY + 2 )
int main() {
// Création des 2 tâches
xTaskCreate(bouton, "Bouton", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_1, NULL); // pas de paramètre
xTaskCreate(entree, "Entree", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_2, NULL); // pas de paramètre
// Démarrage de l’ordonnanceur
vTaskStartScheduler();
while(true) {} // On n’arrive ici que si l’ordonnanceur se plante
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
170
Passage de paramètre
• Si la tâche 2 devait comparer l’entrée analogique à une valeur de
seuil qui lui est donnée en paramètre lors de sa création :
void entree(void * pseuil) {
uint16_t seuil = (uint16_t) *pseuil; // Récupération du seuil de comparaison
// init du convertisseur en mode déclenché par programme
while(true) {
…
}
}
• Le passage du paramètre est fait dans le programme :
int main() {
// Création des 2 tâches
xTaskCreate(bouton, "Bouton", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_1, NULL); // pas de paramètre
uint16_t limite = 300; // Seuil à donner à la tâche 2
xTaskCreate(entree, "Entree", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_2, (void *) &limite); // passage du paramètre
…
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
171
Pipes : manipulations
•
Déclaration :
– QueueHandle_t descripteur;
•
Création :
– xQueueCreate(nbrElements, tailleElement)
Retourne un descripteur de type QueueHandle_t. La taille est exprimée en octets (utiliser sizeof).
•
Suppression :
– vQueueDelete(descripteur)
•
Vidage :
– xQueueReset(descripteur)
•
Taille :
– xQueueMessagesWaiting(descripteur) ou xQueueMessagesWaitingFromISR(descripteur)
Retourne le nombre d’éléments dans la file
– uxQueueSpacesAvailable(descripteur)
Retourne la place disponible en nombre d’éléments
– xQueueIsQueueEmptyFromISR(descripteur)
Indique si la file est vide (renvoie pdFALSE si la file est vide)
– xQueueIsQueueFullFromISR(descripteur)
Indique si la file est pleine (renvoie pdFALSE si la file n’est pas pleine)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
172
Pipes : lecture
Lecture bloquante ou avec délai maximum d’attente :
– xQueueReceive(descripteur, element, nbrTicksAttente) ou
– xQueueReceiveFromISR(descripteur, element)
• La valeur de retour est pdPASS si une donnée a été récupérée et
errQUEUE_EMPTY si la file est vide
• element est un pointeur vers la variable où sera mise la donnée lue
• nbrTicksAttente est la durée maximale d’attente pour récupérer la donnée
en nombre d’unités de 5 ms. La valeur portMAX_DELAY provoque une
attente infinie
– xQueuePeek(descripteur, element, nbrTicksAttente) ou
– xQueuePeekFromISR(descripteur, element)
• L’élément n’est pas enlevé de la file
• La valeur de retour est pdPASS si une donnée a été récupérée et
errQUEUE_EMPTY si la file est vide
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
173
Pipes : écriture
Ecriture bloquante ou avec délai maximum d’attente :
– xQueueSendToBack(descripteur, element, nbrTicksAttente) ou
– xQueueSendToBackFromISR(descripteur, element, NULL)
• écriture en fin de file. La valeur de retour est pdPASS si une donnée a été
déposée et errQUEUE_FULL si la file est pleine
• element est un pointeur vers la variable contenant la donnée
• nbrTicksAttente est la durée maximale d’attente pour déposer la donnée en
nombre d’unités de 5 ms. La valeur portMAX_DELAY provoque une attente
infinie
– xQueueOverwrite(descripteur, element) ou
– xQueueOverwriteFromISR(descripteur, element, NULL)
• écriture en fin de file avec remplacement du dernier élément
– xQueueSendToFront(descripteur, element, nbrTicksAttente) ou
– xQueueSendToFront FromISR(descripteur, element, NULL)
• écriture en début de file. La valeur de retour est pdPASS si une donnée a
été déposée et errQUEUE_FULL si la file est pleine
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
174
Pipes : exemple
•
Une tâche fait une mesure sur une entrée analogique chaque seconde. Si
la valeur a changé depuis la mesure précédente elle l’envoie à une autre
tâche par un pipe :
void mesure(void * param) {
// init du convertisseur en mode déclenché par programme
uint16_t prec = 1024; // Pour envoyer la 1ère mesure
while(true) {
while (IS_CLR_BIT(ADCSRA, 4)) {} // attendre une mesure
SET_BIT(ADCSRA, 4); // Effacer l’indicateur
uint16_t val = ADC; // relever la mesure
if (val != prec) { // Si elle est différente l’envoyer
xQueueSendToBack(tube, &val, portMAX_DELAY);
}
prec = val; // mesure précédente
vTaskDelay(1000/5); // attendre 1 s
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
175
Pipes : exemple
•
L’autre tâche récupère les mesures envoyées dans le pipe et les traite :
void traitement(void * param) {
while(true) {
uint16_t mesure; // mesure récupérée dans le pipe
xQueueReceive(tube, & mesure , portMAX_DELAY); // Attente de donnée dans le pipe
// Traiter mesure
}
}
•
Le programme qui lance ces 2 tâches :
QueueHandle_t tube; // Le pipe est déclaré en global
int main() {
// Création du pipe
tube = xQueueCreate(5, sizeof(uint8_t)); // Création du pipe on prévoit de la place pour 5 données
// création des 2 tâches
xTaskCreate(mesure, "M", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_1, NULL); // pas de paramètre
xTaskCreate(traitement, "T", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_2, NULL); // pas de paramètre
// Démarrage du scheduler
vTaskStartScheduler();
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
176
Sémaphores : rappel
•
Un sémaphore est un compteur qui ne connaît que 2 opérations :
–
Opération P (fermeture) :
1.
2.
–
Opération V (ouverture) :
1.
•
Si le compteur est à 0 se bloquer jusqu’à ce qu’il ne soit plus à 0
le décrémenter
Incrémenter le compteur sans dépasser la valeur maximale
Un sémaphore dont la valeur maximale est 1 ne peut être qu’à 0
ou à 1 (sémaphore binaire ou Mutex). C’est un verrou qui est
ouvert ou fermé.
–
–
On ne peut le fermer que s’il est ouvert (opération P)
On peut l’ouvrir plusieurs (opération V) plusieurs fois mais seule la
1ère ouverture est utile puisque sa valeur reste à 1
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
177
Sémaphores
Les sémaphores permettent de bloquer/débloquer les tâches
• Ils seront utilisés :
– Pour synchroniser des traitements (une tâche ne doit s’exécuter son
traitement T qu’après qu’une autre tâche ait exécuté son traitement T’
– Pour attendre un événement détecté par une interruption
– Pour protéger des variables ou des ressources partagées (ne pas les
modifier pendant qu’une autre tâche les utilise).
• Free RTOS propose 3 types de sémaphores :
– Sémaphore binaire : ne peut être qu’ouvert ou fermé
– Mutex : c’est un sémaphore binaire mais qui appartient à une tâche qui
est la seule à pouvoir le manipuler
– Sémaphore compteur : peut être ouvert plusieurs fois d’avance (avec un
maximum), peut être fermé sans blocage autant de fois qu’il a été
ouvert
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
178
Sémaphores : manipulations
•
Déclaration :
–
•
SemaphoreHandle_t descripteur;
Création
–
Sémaphores binaires :
• xSemaphoreCreateBinary()
renvoie un descripteur de type SemaphoreHandle_t (le sémaphore est créé fermé)
–
Mutex :
• xSemaphoreCreateMutex()
renvoie un descripteur de type SemaphoreHandle_t (le sémaphore est créé fermé)
–
Sémaphores compteurs:
• xSemaphoreCreateCounting(valeurMax, valeurInitiale)
renvoie un descripteur de type SemaphoreHandle_t
Les paramètres définissent la valeur initiale et maximale du compteur
•
Suppression :
–
•
vSemaphoreDelete(descripteur)
Etat :
– uxSemaphoreGetCount(descripteur)
renvoie la valeur actuelle du sémaphore
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
179
Sémaphores : opérations
• Opération P :
– xSemaphoreTake(descripteur, nbrTicksAttente)
Renvoie pdPASS si le sémaphore a bien été fermé et pdFail s’il ne
l’a pas été à la fin du délai.
nbrTicksAttente : limite l’attente au nombre d’unités de 5 ms indiqué.
En y mettant portMAX_DELAY l’attente est infinie, dans ce cas la
valeur de retour ne pourra être que pdPASS puisque sinon la tâche
est bloquée.
• Opération V :
– xSemaphoreGive(descripteur)
– xSemaphoreGiveFromISR(descripteur, NULL)
Renvoie pdPASS si le sémaphore a bien été ouvert et pdFAIL s’il ne
l’a pas été parce qu’il l’était déjà.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
180
Sémaphores : exemple
• Une tâche T1 doit s’exécuter chaque fois qu’une ligne passe à 0 ou
qu’une entrée analogique a changé.
• On va utiliser 2 tâches supplémentaires :
– T2 surveille la ligne et débloque T1 quand elle passe à 0
– T3 fait une mesure par seconde et débloque T1 quand la valeur a
changé
void tache2(void * param) {
CLR_BIT(DDRD, 0); ligne à surveiller
while(true) {
while(IS_CLR_BIT(PIND,0)) {} // Attendre que la ligne passe à 0
xSemaphoreGive( sem); // Débloquer T1
while(IS_SET_BIT(PIND,0)) {} // Attendre que la ligne revienne à 1
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
181
Sémaphores : exemple
void tache3(void * param) {
// init du convertisseur en mode déclenché par programme
uint16_t prec = 1024; // Pour envoyer la 1ère mesure
while(true) {
while (IS_CLR_BIT(ADCSRA, 4)) {} // attendre une mesure
SET_BIT(ADCSRA, 4); // Effacer l’indicateur
uint16_t val = ADC; // relever la mesure
if (val != prec) { // Si elle est différente l’envoyer
xSemaphoreGive( sem); // Débloquer T1
}
prec = val; // mesure précédente
vTaskDelay(1000/5); // attendre 1 s
}
}
void tache1(void * param) {
while(true) {
xSemaphoreTake(sem, portMAX_DELAY); // Se bloquer
// Traitement
}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
182
Sémaphores : exemple
Les priorités :
–
–
–
T1 exécute un traitement puis se bloque
T2 ne se bloque jamais (donc ne peut pas être de priorité > autres)
T3 se met en sommeil pour 1s
On doit prendre : priorité de T1 ≥ priorité de T3 > priorité de T2
Le programme :
#define PRIORITE_TACHE_1
( tskIDLE_PRIORITY + 3 )
#define PRIORITE_TACHE_2
( tskIDLE_PRIORITY + 1 )
#define PRIORITE_TACHE_3
( tskIDLE_PRIORITY + 2 )
SemaphoreHandle_t sem; // Le sémaphore est déclaré en global
int main() {
// Création du sémaphore
sem = xSemaphoreCreateBinary(); // Création du sémaphore (il est fermé)
// création des 3 tâches
xTaskCreate(tache1, "T1", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_1, NULL); // pas de paramètre
xTaskCreate(tache2, "T2", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_2, NULL); // pas de paramètre
xTaskCreate(tache2, "T3", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_3, NULL); // pas de paramètre
vTaskStartScheduler(); // Démarrage du scheduler
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
183
Sémaphores : exemple
La tâche T2 ne sert pas à grand-chose à part attendre qu’une ligne passe à 1.
Elle occupe du temps processeur pour rien même si on lui a donné la
priorité minimale.
Comme la ligne à surveiller est la ligne 0 du Port D on pourrait utiliser une
interruption (INT0) :
•
Au début du programme principal on initialise la ligne pour générer une IT au front
montant :
CLR_BIT(DDRD, 0); // Ligne en entrée
EICRA = 0b00000011; // Détection de front montant
SET_BIT(EIFR,0); // Effacement de l’indicateur d’IT
SET_BIT(EIMSK,0); // IT autorisée sur INT0
sei(); // Prise en compte des ITs
•
On garde les tâches T1 et T3 et on remplace T2 par :
ISR(INT0_Vect) {
xSemaphoreGiveFromISR(sem, NULL); // Débloquer T1 par une fonction d’IT
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
184
Chien de garde
(Watchdog)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
185
Chien de garde
•
Compteur piloté par une horloge à 128 KHz :
– Durées possibles : 2i * 16 ms avec i = 0 à 9
(soit de 16 ms à 8 s)
•
Fonctionnement :
– Mode interruption :
• A la fin du délai le chien de garde provoque une interruption
– Mode Reset :
• A la fin du délai le chien de garde provoque un Reset du CPU
– Mode mixte :
• A la fin du premier délai le chien de garde provoque une interruption
• A la fin du second délai le chien de garde fait un Reset du CPU
•
Utilisation :
– Au début du programme
• Définition d'une durée
• Lancement
– En cours de programme
•
Réinitialisation en des points choisis du programme par l’instruction WDR
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
186
Chien de garde
• Utilité :
Détection des pannes ou de défauts du programme
– Panne : le programme se plante  il ne réinitialise pas le chien
de garde qui arrive à terme
– Cas de boucle infinie ou de blocage (dead lock) : le programme
est bloqué  il ne réinitialise pas le chien de garde qui arrive à
terme.
Dans tous ces cas le chien de garde :
– Soit génère une interruption qui peut corriger le défaut
– Soit fait un RESET du CPU qui redémarre et peut corriger le
défaut
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
187
Chien de garde : programmation
• Un seul registre suffit à programmer le chien de garde :
WDTCSR ← imdvmddd
i : indicateur de fin de délai
– passe à 1 quand le délai est dépassé si le watchdog a été mis en mode IT
– passe à 0 quand l’IT est prise en compte ou par écriture d’un 1 dans ce bit
mm : mode de fonctionnement
–
–
–
–
00 : chien de garde arrêté
01 : le délai provoque une IT
10 : le délai provoque un RESET
11 : le 1er délai provoque une IT
si l’IT est prise en compte le suivant provoque un RESET
v : bit de sécurité
– Doit être mis à 1 quand on modifie les bits dddd, revient à 0 tout seul
dddd : durée du délai (de 16 ms à 8 s)
– La durée est 2x+4 ms où x est la valeur binaire de dddd
– Par exemple dddd = 0101 correspond à un délai de 25+4 = 512 ms
• Il est réarmé par la fonction C : wdt_reset() définie dans <avr/wdt.h>
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
188
Mise au point
des programmes
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
189
Mise au point
• La mise au point des programmes peut être délicate :
– Difficulté de placer le système réel dans certaines situations qu’il pourra
rencontrer (humidité, parasites, température …)
– Difficulté de tester toutes les pannes possibles du système réel
– Difficulté de tester les problèmes liées au temps (événement qui arrive
un peu trop tôt ou trop tard)
– Difficulté de tester les cas d’interblocage ou de mauvais enchaînement
de tâches (sémaphores, priorités)
– Difficulté de tester les cas de débordement de mémoire
– Difficulté de tester les cas de saturation du processeur
• On peut utiliser :
– Des traces par des actionneurs (DEL, écran)
– Des traces par printf mais le temps d’exécution de printf est
relativement long  peut induire ou cacher des erreurs
– Des sondes spécialisées (Jtag)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
190
Débogage (Jtag)
•
Certaines lignes d’E/S peuvent être connectées
à une sonde (Jtag) pour :
– Placer des points d’arrêt dans le programme
– Exécuter les instructions en pas à pas
– Surveiller le contenu de variables
•
Pour cela le CPU contient des registres permettant de l’arrêter quand :
– Une instruction est lue en mémoire à une adresse donnée
– Une donnée est lue/écrite en mémoire à une adresse donnée
– Une donnée lue/écrite en mémoire a une valeur donnée
Lorsque le CPU s’arrête les Timers s’arrêtent aussi et redémarrent avec lui
•
Les lignes d’E/S permettent, via la sonde :
– De placer des valeurs dans ces registres (adresse d’instruction ou de donnée ou
valeur de donnée)
– De lire/modifier le contenu des registres du CPU
– De lire/modifier le contenu de la mémoire
– De consulter/modifier les registres des contrôleurs de périphériques
– De relancer le programme
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
191
Eviter le débogage
Avant de commencer
• Analyse détaillée :
– De la demande (ce qu’il faut faire)
– Du système physique (ce qu’il peut faire, ses contraintes, ses limites, …)
– Du système informatique (placement et caractéristiques des
capteurs/actionneurs, adaptation de signaux, choix du microcontrôleur, ..)
– Des versions et évolutions possibles du matériel et du logiciel
• Tests unitaires des éléments :
– Ce que renvoie réellement un capteur (valeurs, délais, précision, …)
– Comment réagit réellement un actionneur (délais, précision, …)
– Positionnement des capteurs/actionneurs
• Tests partiels du système complet :
– Découpage en sous parties et test de chacune seule si possible
– Ajout de dispositifs temporaires pour mettre le système réel dans des
états de test
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
192
Eviter le débogage
Lors de la programmation
•
Paramétrage du programme :
– Définition de constantes (#define) (le plus possible)
– Définition de fonctions ou de tâches simples avec paramètres
– Utilisation de la compilation conditionnelle (#ifdef #else #endif)
Pour :
– Ajuster le fonctionnement (lors des tests, lors du changement d’un élément, …)
– Gérer des versions (écrans différents, pas d’écran, …)
– Prévoir les évolutions futures (capteurs supplémentaires/différents, …)
•
Sécurité du programme :
– Dans le code vérifier les valeurs, les paramètres, …
– Test des algorithmes (valeurs limites, précision des calculs, temps, …)
– Conserver des traces vérifiables a posteriori en cas de problème (logs)
•
Lisibilité / maintenabilité :
–
–
–
–
Découpage en modules (fichiers .c et .h) par fonctionnalités
Fichiers ne contenant que des constantes et des conditions de compilation
Fichiers inclus ou pas selon le paramétrage ou la version
Documentation (à quoi sert telle constante, dans quelle formule elle est utilisée, à
quoi sert telle condition de compilation, que contient chaque fichier, …)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
193
Une partie du projet (168 fichiers)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
194
Un des fichiers de configuration
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
195
Un exemple de code
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
196
Réseau industriel
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
197
Réseau industriel CAN
(Controller Area Network)
• Permet de relier plusieurs microcontrôleurs devant
échanger des informations :
– Partage de la charge CPU dans les système rapides
– Distribution du contrôle dans les systèmes complexes par :
• Fonctions
• Zones géographiques
– Distribution du contrôle pour sécurité (automobile par exemple)
• la panne d’un microcontrôleur ne compromet pas le fonctionnement
de tout
– Redondance pour sécurité (dans les avions par exemple) :
• Plusieurs (3) microcontrôleurs exécutent la même tâche (parfois
avec des algorithmes différents pour plus de fiabilité) :
On compare leurs résultats et élimine celui qui commet des erreurs
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
198
Réseau industriel : principes
• Principes :
– Transmettre des informations très courtes (quelques octets)
– Débits peu élevés pour éviter les erreurs (de l’ordre du Mb/s)
– On ne désigne pas le destinataire du message mais le contenu du
message :
• Ceux qui sont intéressés par ce contenu le lisent
• Exemple :
– Un microcontrôleur relève les valeurs d’un capteur C et en fait la moyenne
sur N valeurs
– Chaque N valeurs, il envoie cette moyenne désignée comme la valeur de C
– Les microcontrôleurs du réseau qui ont besoin de la valeur de C la
récupèrent
– Les autres l’ignorent
– Le protocole permet de demander à recevoir un message désigné par
son contenu : un microcontrôleur ayant besoin d’une valeur peut la
demander, celui qui la détient l’enverra
– La qualité du réseau est testée en permanence
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
199
Réseau CAN : caractéristiques
• Topologie et débit du CAN :
– Topologie : Bus en câble de type paire torsadée
– Débit 1Mb/s jusqu’à 40m au-delà le débit doit être diminué en fonction
de la longueur (50Kb/s pour 1Km mais de telles longueurs sont rares)
• Protocole :
– Type producteur/consommateurs
– Priorité des messages :
• L’indication de contenu de message correspond à une priorité
• Exemple :
– Un microcontrôleur envoie une information désignée par ID1
– Un autre microcontrôleur envoie une information désignée par ID2
– S’ils émettent au même moment et que ID1 est plus prioritaire que ID2
– L’information désignée par ID1 sera envoyée et celle désignée par ID2
ne le sera pas
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
200
CAN : priorités
• Dans un réseau classique il n’y a pas de priorité. Par
exemple Ethernet utilise CSMA/CD :
– Lorsque 2 ordinateurs émettent en même temps :
• Le message est brouillé (collision)
• Les 2 s’en aperçoivent et s’arrêtent (Collision Detection)
• Ils recommencent après un délai aléatoire
• Dans un réseau industriel il n’y a pas de collisions. Par
exemple CAN utilise CSMA/CA :
– Lorsque 2 microcontrôleurs émettent en même temps :
• Ils envoient l’identifiant du contenu du message en même temps
• Les propriétés physiques du bus font que si l’un émet un 1 et l’autre
un 0, le bus est à 0 (Collision Avoidance)
• Celui qui a émis le 1 voit qu’il n’est pas prioritaire  il s’arrête
• Celui qui a émis le 0 ne voit rien de particulier  il continue
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
201
CAN : priorités
Le choix de l’identifiant de contenu de message fixe la priorité du message :
•
Plus l’identifiant contient de bits à 0 en début plus il est prioritaire :
–
Exemple :
11101101 est plus prioritaire que 11110000
1.
2.
3.
4.
•
A émet 1110
B émet 1111 mais voit que sur le bus il y a eu 1110  il s’arrête
A continue avec 1101
Sur le bus on a eu 11101101 (l’identifiant de A)
Ce mécanisme limite le débit en fonction de la longueur du bus car la
surcharge d’un bit à 1 par un bit à 0 doit être détectée dans un délai inférieur
à la durée d’un bit pour que l’émetteur moins prioritaire s’arrête à temps :
–
Si ce n’était pas le cas dans l’exemple précédent :
1.
2.
3.
4.
5.
A émet 1110
B émet 1111 en raison du retard il ne voit pas que sur le bus il y a eu 1110  il continue
A continue avec 1
B continue avec 0 il s’aperçoit maintenant que sur le bus il y a eu 1110  il s’arrête
A continue avec 1 il s’aperçoit que sur le bus il y a eu 11100  il s’arrête
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
202
CAN : trames
• Trames très courtes : 0 à 8 octets de données + 11 ou 29 bits
d’identification de contenu + 33 bits de contrôle (max 126 bits) :
– L’identification de contenu (priorité) est codée sur 11 (CAN) ou sur 29
bits (CAN étendu)
– 1 bit indique s’il s’agit d’une information ou d’une demande d’information
– 2 bits sont réservés à l’acquittement de la trame
• Acquittement :
– L’émetteur met les 2 bits d’acquittement à 1
– Les récepteurs qui acceptent l’information forcent le second bit à 0
– L’émetteur sait si son information a été prise en compte par un
récepteur quand il voit le second bit est à 0 alors qu’il l’a mis à 1
– Remarque : Cette méthode ne permet pas de savoir si tous ont reçu
mais seulement si au moins un a reçu l’information.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
203
CAN : Types de trames
• Il existe 4 types de trames :
– Données :
• Trame normale avec un identifiant et 1 à 8 octets de données
– Demande de donnée :
• Trame sans octets de données mais un identifiant (celui de la
donnée demandée)
– Erreur :
• Quand un microcontrôleur détecte une erreur sur le réseau il force
la trame en cours par un code d’erreur
• Les autres reconnaissent ce code d’erreur et ignorent la trame
• L’émetteur de la trame reconnaît ce code d’erreur et réémet la
trame
– Remplissage :
• Trames permettant de laisser un délai entre 2 trames
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
204
CAN : Gestion des erreurs
•
Le contrôleur de réseau CAN teste les erreurs :
–
–
–
•
Il gère deux compteurs d’erreur TEC (émission) et REC (réception) initialement à 0 :
–
–
–
–
•
Erreur de CRC
Trame de format incorrect
Problème de ligne : quand on émet un 0 on doit toujours relire un 0
À chaque émission sans erreur :
si (TEC > 0) TEC ← TEC -1
À chaque émission avec erreur :
TEC ← TEC +1 ou +8 selon la gravité de l’erreur
À chaque réception sans erreur :
si (0 < REC < 127) REC ← REC -1
sinon REC ← 126
À chaque réception avec erreur :
REC ← REC +1 ou +8 selon la gravité de l’erreur
États du contrôleur de CAN :
–
–
–
REC ≤ 127 et TEC ≤ 127 : fonctionnement normal
REC > 127 et 255 > TEC > 127 : fonctionnement dégradé (attente entre émissions de trames
et envoi de trames spéciales pour indiquer son état aux autres)
TEC ≥ 255 : arrêt des émissions, le contrôleur n’est que récepteur
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
205
CAN : Mise en œuvre
• Déterminer les valeurs à partager
– Qui les calcule
– Qui en a besoin
• Associer à chacune un identifiant
– Choisi en fonction de la priorité
• Les émetteurs :
– Envoient à chaque obtention de la valeur
– Envoient à intervalles réguliers
– Envoient à la demande
• Les récepteurs :
– Indiquent quels identifiants les intéressent
– Demandent des données
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
206
Les autres microcontrôleurs
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
207
Autres microcontrôleurs
Il existe des microcontrôleurs plus simples que le 2560 (PIC, AVR AtMega128, …)
Mais aussi d’autres plus performants (Cortex SAM, STM, …).
Selon le type d’application et le coût on choisit le microcontrôleur le plus adapté.
Microcontrôleurs performants :
• Processeur :
– Plus rapide : 72 à 400 MHz (84 MHz pour le SAM3)
– Plus puissant : 16 ou 32 bits, jeu d’instructions étendu.
– Gestion des interruptions plus complète :
• Choix des priorités
• Choix des préemptions
– Mémoire interne plus grande (512Ko flash + 100 Ko RAM pour le SAM3)
– Mémoire externe statique ou SDRAM (16Mo pour le SAM3) :
• Vitesse programmable
• Détection d’erreurs
• Protection par zones pour multiprocesseur
– Sauvegarde :
• Registres sauvegardés même hors tension pour reprise d’erreurs par sauvegarde d’un état
– Sécurité :
• Instructions privilégiées (modes privilégié / normal)
• Plusieurs chiens de garde permettant chacun de définir un délai minimal et maximal de
remise à 0.
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
208
Autres microcontrôleurs
• Périphériques :
– Marche/arrêt et reset des périphériques par programme
– Possibilité de protection contre l’écriture des registres des contrôleurs par
clé (sécurité).
– Lignes numériques :
• Nombreuses (103 sur le SAM3)
• Détection de fronts programmables avec IT sur toutes les lignes avec filtrage
anti-rebond intégré programmable sur toutes les lignes
– Timers :
• Rapides : (42 MHz sur le SAM3)
• Performants :
–
–
–
–
–
–
comptage sur 32 bits
division d’horloge par N
chaînage de timers
commandes externes (marche/arrêt, sens de comptage)
Génération de signaux pour moteurs pas à pas
double capture, …
• Nombreux : (9 sur le SAM3)
• Un timer supplémentaire est prévu pour les systèmes temps réel
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
209
Autres microcontrôleurs
• Périphériques :
– Convertisseur A/N
• Performants :
–
–
–
–
Conversion sur 12 bits
Amplification d’entrée programmable
Scan automatique d’entrées
Contrôle programmable de seuils automatique (fenêtre)
• Nombre : 2 sur le STM32 synchronisables entre eux
– Convertisseur N/A
• Sur 12 bits
• Plusieurs lignes de sortie (4 sur le SAM3)
• File d’attente de valeurs à convertir pour génération de signaux analogiques
– Générateurs de signaux (PWM)
• Indépendants des timers (8 sur le SAM3) avec horloge *M et /N
• Synchronisables entre eux
• Sorties directes et sorties inverses sur lignes séparées
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
210
Autres microcontrôleurs
•
Communication :
–
–
–
–
–
–
–
–
–
•
Contrôleurs série synchrone (UART) / asynchrone (USART) (4 sur SAM3)
Contrôleurs SPI (6 sur SAM3) avec gestion de sélection de périphérique
Contrôleurs I2C (2 sur SAM3) adresses sur 7 ou 10 bits
Contrôleurs USB (2 sur SAM3)
Contrôleur I2S pour le son (1 sur SAM3)
Contrôleur de carte SD (HSMCI) (1 sur SAM3 contrôlant jusqu’à 30 cartes SD)
Contrôleur Ethernet (1 sur SAM3 10/100Mb/s)
Générateur de nombres aléatoires (1 sur SAM3)
Contrôleurs CAN (2 sur SAM3)
Temps :
– Horloge temps réel avec calendrier intégrée peut générer des ITs à une date ou
périodiques
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
211
Autres microcontrôleurs
• Interconnexions :
– Choix des lignes de sortie des périphériques plus souple :
• Plusieurs possibilités pour chaque ligne
– Possibilité d’interconnecter les contrôleurs de périphériques entre eux :
• Pilotage automatique de l’un par d’autres
• Matrice d’interconnexion programmable (quoi pilote quoi)
• DMA (Direct Memory Acces) :
– Transferts automatiques de données entre mémoire et contrôleurs de
périphériques programmables :
•
•
•
•
Transferts dans les 2 sens
IT de fin de transfert
Double buffer programmable (évite les pertes des données)
Plusieurs canaux simultanés (17 sur le SAM3)
• Paramétrage :
– Horloge du CPU et des périphériques programmable
– Horloge de l’USB programmable indépendamment
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne
212
C’est fini
Téléchargement