Arduino LP Prog - IUT de Bayonne et du Pays Basque
Transcript of Arduino LP Prog - IUT de Bayonne et du Pays Basque
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 2
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 3
Informatique industrielleDiffé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 4
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 5
Principe (système en boucle)
Imagedu
systèmeréel
capteurs
actionneurs
Systèmeréel
Valeurs
Commandes Modifier
Mesurer
Programme
CPU Contrôleursde
périphériques
• 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)
Microcontrôleur
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 6
Principe (système en boucle)
Imagedu
systèmeréel
capteurs
actionneurs
Systèmeréel
Valeurs
Commandes Modifier
Mesurer
Programme
CPU Contrôleursde
périphériques
• 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 7
Le câblage
Contrôleursde
périphériques
capteurs
actionneurs
Adaptation de niveau
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 8
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 9
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 10
Données et résultatsInformations 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 11
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 12
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 13
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 14
Auto contrôle• Principe :
1. Donner une consigne à un actionneur2. Vérifier par un capteur l’effet de cette consigne3. Si la valeur mesurée n’est pas celle attendue ajuster la consigne4. 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 valeurmesuré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 15
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 16
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 17
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 + edifférence ← eprec - econsigne ← 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 18
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 osciller2. Introduire Ki dans la formule et l'ajuster pour arriver le plus précisément possible à la
valeur attendue sans trop osciller3. Introduire Kd dans la formule et l’ajuster pour diminuer les oscillations
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 19
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. 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 à rien2. 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 21
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 22
Le premier système embarqué
• 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
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
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 23
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 24
Le code• Extrait du code de mise à feu :
# *********************************# GENERAL PURPOSE IGNITION ROUTINES# *********************************BURNBABY TC PHASCHNG # GROUP 4 RESTARTS HERE
OCT 04024CAF ZERO # EXTIRPATE JUNK LEFT IN DVTOTALTS DVTOTALTS DVTOTAL +1TC BANKCALL # P40AUTO MUST BE BANKCALLED EVEN FROM ITSCADR 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)
http://klabs.org/history/apollo_11_alarms/eyles_2004/eyles_2004.htm
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 26
Capteurs• Principes
– Transforme une grandeur physique en :• Une grandeur électrique : tension ou courantou• 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 27
Types de capteurs• Déplacement
– 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– Passage, mouvement, vibration (laser, IR ou radar)– Proximité, distance (laser, IR ou ultra sons par mesure de temps)
• Position– Roue codeuse (contact)– GPS (réception de satellites)– Accélération (capacitif mécanique ou effet piézoélectrique)– Inclinaison (capacitif mécanique)
• Rayonnement– 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 28
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 29
Types d’actionneurs• Mouvement
– 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)
• Indicateur– 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 30
Caractéristiques des capteurs/actionneurs• Précision
– 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 ?
• Sensibilité– 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 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 supporte-t-il une température de 100°? De 1000°?– Un servomoteur peut-il soulever une charge de 500 g ? De 10 Kg ?
• Prix– 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– 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 32
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 33
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 34
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 35
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 36
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 37
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
Mais1.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 38
Langage C : types
uint64_t
unsigned long longint64_t
long long64 bits
float
double
uint32_t
unsigned long
int32_t
long
32 bits
type *
void *
uint16_t
unsigned int
int16_t
int
16 bits
bool (1)uint8_t
unsigned char int8_t
char 8 bits
PointeurBooléenRéelEntier non signéEntier signé
Type
Taille
(1) 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 39
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 156Sans 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é : int16_t val = 25; #define val 25– Entier long signé : int32_t val = 1000000L; #define val 1000000L– Entier long long signé : int64_t val = 1000000000LL; #define val 1000000000LL– Entier non signé : uint16_t val = 3252U; #define val 3252U– Entier long non signé : uint32_t val = 1000000UL; #define val 1000000UL– Entier long long non signé : uint64_t val = 1000000000ULL; #define val 1000000000ULL– Réel : float val = 15.0; #define val 15.0
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 40
Langage C : les bases
• Un nombre peut être écrit :
• En décimalv = 4568;u = -25478
• En hexadécimalv = 0xA01E;
• En binairev = 0b01101101;
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 41
Langage C : opérations• Opérations logiques (dans une condition (if, while, …)) :
– ET : a && b– OU : a || b– NON : !a– Egalité : a == b– Non égalité : a != b– Inégalités : 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 42
Opérations binairesLes opérations binaires de ET, OU, NON et de décalage nous seront utiles.
• ET11010111
& 0110011001000110 0 & 0 = 0 , 0 & 1 = 0 , 1 & 0 = 0, 1 & 1 = 1
• OU11010111
| 0110011011110111 0 | 0 = 0 , 0 | 1 = 1 , 1 | 0 = 1, 1 | 1 = 1
• NON11010111
~ 00101000 ~ 0 = 1 , ~ 1 = 0• Décalage à droite
11010111>> 01101011 Décalage des bits vers la droite et mise à 0 du bit de gauche
• Décalage à gauche11010111
<< 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 43
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) (reg = reg | (1<<num))#define CLR_BIT(reg, num) (reg = reg | (~(1<<num)))
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 44
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 45
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 :Traitementen cours
Interruption
Traitement associéà l'interruption
Reprise,dutraitementsuspendu
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 46
Interruptions : préemption• Que se passe t-il si une interruption survient pendant l’exécution
de la fonction associée à une interruption ?
Traitementen cours
Interruption 1
Traitement associéà l'interruption 1
Reprise,dutraitementsuspendu
Traitement associéà l'interruption 2
Traitementen cours
Interruption 1
Traitement associéà l'interruption 1
Reprise,dutraitementsuspendu
Traitement associéà l'interruption 2
Interruption 2Interruption 2
Comportement 1 Comportement 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 47
Interruptions : prioritéExemple :
1. Un traitement est en cours2. Une interruption (IT1) arrive3. Le traitement est suspendu et la fonction associée à l’IT1 est démarrée4. Pendant son exécution une interruption (IT2) arrive : elle est mise en attente5. Puis une interruption (IT3) arrive : elle est mise en attente 6. 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 48
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 49
Entrées / Sorties numériquesdu XMega 2560
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 50
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 51
Emetteur delumière
Récepteur delumière
Début dupassage
Fin dupassage
Nouveaupassage
Durée dupassage
Temps entre 2 passages
Faisceau lunineux
1
0
Informationdu récepteur
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
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 52
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 53
Exemple : Compteur de passageSur 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 54
Exemple : SolutionLe 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 55
Exemple : test• On teste ce programme :
– On le lance : il n’affiche rien (normal)– Un objet passe devant le faisceau– Le programme affiche : 1548798 lignes (inattendu !)
• Pourquoi ?– 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éfinimentif (IS_CLR_BIT(PINB, 4)) { // Le faisceau est coupé
compteur++; // On compte un passageprintf("Nombre de tours : %d\n" , compteur); // Affichagewhile (IS_CLR_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 1
}}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 56
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 57
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 58
Capteur mécanique
Utilisation d’une ligne comme entrée numérique reliée à un capteur mécanique :
L'état de la ligneest instable
L'état de le ligne est 0
L'état de le ligne est 1
Début dudélai deflitrage
Fin dudélai deflitrage
Délai de filtrage
La ligne est considérée comme étant à 0 La ligne est considéréecomme étant à 1
L'état de laligne estinstable L'état de le ligne est 0
Début dudélai deflitrage
Fin dudélai deflitrage
Délai de filtrage
La ligne est considéréecomme étant à 0
L'objet activele contact
L'objet libèrele contact
Pour résoudre ce problème on doit ignorer les oscillations pendant un délai de quelques ms :
• 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.
• On utilisera dans ce but un Timer (vu plus loin)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 59
Capteur mécaniqueSolution 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 mscompteur++; // 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 60
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 61
Exemple : pilotage d’une DELOn 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 sortieCLR_BIT(PORTC, DEL); // initialement éteinteCLR_BIT(DDRC, BOUTON); // ligne du bouton tactile en entrée
while (true) { // Le programme fait ça indéfinimentwhile (IS_CLR_BIT(PINC, BOUTON)) { // Attendre un touché du boutonSET_BIT(PINC, DEL); // Allumer/éteindre la DELwhile (IS_SET_BIT(PINC, BOUTON)) { // Attendre bouton non touché
}}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 63
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 64
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 65
Fonction d’interruption• Association d’une fonction d’interruption à une ligne INT :
1. Mettre la ligne en entréeExemple : 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 montantEICRB = EICRB | 0b00001100;
3. Effacer les indicateurs d’interruption par le registre EIFRExemple : 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 EIMSKExemple : 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 66
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 67
Fonction d’interruption• Association d’une fonction d’interruption à une ligne PCINT :
1. Mettre la ligne en entréeExemple : 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 PFICRExemple : 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 PCICRSET_BIT(PCICR, 2);
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 68
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 69
Exemple : imprimante 3D• Programme de l’imprimante
int main() {Initialisationswhile (true) {
if (carteSD) {Lire une commande dans le fichierif (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 commandeif (! 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 70
Exemple : imprimante 3DInterruption 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 71
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 72
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 73
Bonne solution (suite)volatile bool arret;
int main() {Initialisationsarret = false; // L’impression va démarrerwhile (true) {
if (carteSD) {Lire une commande dans le fichierif (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 commandeif (arret) { // L’impression a été suspendue par l’utilisateurwhile(IS_SET_BIT(PINE, 5)) {} // attendre que le bouton soit lâché
while(IS_CLR_BIT(PINE, 5)) {} // attendre que le bouton soit appuyé à nouveauSET_BIT(EIFR, 5); // Effacer l’indicateur d’ITSET_BIT(EIMSK, 5); // autoriser l’IT suivantearret = false; // L’impression reprend
}if (! carteSD) {
Signaler la fin d’exécution de commande sur le port série}
}}
ISR(INT5_vect) { // L’utilisateur a appuyé sur le boutonCLR_BIT(EIMSK, 5); // interdire l’IT suivantearret = true;
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 75
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 76
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 77
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 78
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
0 1 2 3 LIMLIM-1LIM-2
Evénement
Tops d'horloge
Tu
Valeur du compteur…
Tu = temps entre 2 tops = 1/ fréquence horloge
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 79
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 80
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):
4,1943041,048576262,11432,7684,096Timers 1, 3, 4 et 5
16,3844,0962,0481,02451212816Timer 2
16,3844,0961,024 128 16 Timer 0
1024
64
256
16
128
8
64
4
32
2
8
1/2
1
1/16
Division
Tu (µµµµs)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 81
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
– 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.
4,1943041,048576262,11432,7684,096Timers 1, 3, 4 et 5
16,3844,0962,0481,02451212816Timer 2
16,3844,0961,024 128 16 Timer 0
1024
64
256
16
128
8
64
4
32
2
8
1/2
1
1/16
Division
Tu (µµµµs)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 82
Timers : RegistresLes timers 1, 3, 4 et 5 ont 10 registres (les timers 0 et 2 en ont moins
ce sont des versions simplifiées)
• TCCRiA :– Pilotage de lignes en sortie (génération de signaux par le timer)– 2 derniers bits du choix du mode de fonctionnement
• TCCRiB :– 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 :– Permet de provoquer par programme une comparaison de valeur (rarement utilisé)
• ICRi :– 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 83
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 84
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 85
Programmation de Timers (délais)Initialisation d’un Timer pour générer un délai :
– TCCRiA ← 00000000
– TCCRiB ← 000xx000• 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 ← limite de comptage 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 86
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 87
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 88
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 C2Pour 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
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 89
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éeswhile (true) {
for(int i = 0; i < 3; i++) { // balayer les lignesmettre toutes les lignes à 1mettre la ligne i à 0for(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 90
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 91
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 = ½ µsTIFRi = 0b00011111; // Effacer les indicateursTIMSKi ← 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 92
Clavier : solution 2
Fonction d’interruption :
volatile bool toucheAppuyee; // Indicateur pour le programmevolatile uint8_t ligne, colonne; // N°de ligne et de colonne pour le programmeuint8_t ligneScrutee; // Dernière ligne scrutée
ISR(TIMERi_COMPA_Vect) { // Fonction d’IT chaque 1/40 sMettre à 1 toutes les lignes Mettre à 0 la ligne de n° « ligneScrutee »ligneScrutee = (ligneScrutee +1) % 4; // passer à la ligne suivanteSi l’une des 3 colonnes est à 0
ligne ← ligneScruteecolonne ← n° de la colonne qui est à 0toucheAppuyee ← true
}}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 93
Clavier : solution 2Et le programme devient :
int main() {// init des 4 lignes en sortie// init des 3 lignes en entrée avec maintien à 1 quand non connectéesligneScrutee = 0; // Pour démarrer par la 1ère lignetoucheAppuyée = false; // Pas de touche appuyée au départ
while (true) {// Traitements diversif (toucheAppuyee) { // Quand on veut traiter la dernière touche appuyée
toucheAppuyee = false; // Pour détecter la prochaine touchetraiter la touche (ligne, colonne)
}}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 94
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 95
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énementLors 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énementLors 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énementLors 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 captureLors 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 96
Mesure de durée sans captureInitialisation 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 97
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 98
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 99
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 ICRiet 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 100
Mesure de durée par captureInitialisation 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 si on veut une interruption au moment de la capture• 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 101
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 102
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 103
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 104
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 = ½ µsLe temps unitaire est de ½ µs donc la limite sera 40000
• La vitesse maximale à mesurer Vmax est de 10000 tr/min Dmax = 1000000/10000 = 100 µsLe 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 105
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 programmeTCCR1B = 0b00001000; // Limite de comptage dans OCR1A, timer arrêté
OCRiA = 40000; // Durée pour 50 tr/min avec Tu = ½ µsTIFRi = 0b00011111; // Effacer les indicateursTIMSKi ← 00000010 // IT si débordement (OCR1A)sei(); // autoriser les IT du processeur
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 106
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 108
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 :
duréedu 0
duréedu 1
période
0
1
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 109
Génération de signaux : utilisationServomoteur :• 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 110
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 111
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)
• 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
Port L ligne 5Port L ligne 4Port L ligne 35
Port H ligne 5Port H ligne 6Port H ligne 74
Port E ligne 5Port E ligne 4Port E ligne 33
Port B ligne 7Port B ligne 6Port B ligne 51
OCCOCBOCATimer
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 112
Générateurs de signaux• Principe de fonctionnement:
1. Le compteur du Timer compte (incrémenté) à partir de 02. 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 programmation4. Le compteur arrive à la valeur limite5. 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 programmation8. Lorsque le compteur arrive à 0 (fin de la période du signal) , si une interruption a
été autorisée, elle se produit9. 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 113
Générateurs de signaux• Les signaux produits :
OCRiA
OCRiC
OCRiB
OCA
OCC
OCB
Période - 2*OCRiA
Période - 2*OCRiC
Période - 2*OCRiB
compteur du timer
Limite
Période = 2*Limite
IT
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 114
Programmation de Timers (signaux)Initialisation d’un Timer pour générer des signaux :• TCCRiA ← aa’bb’cc’01
– aa’ = • 00 signal OCA non utilisé• 10 signal OCA direct : durée du 1 proportionnelle à 2*OCRiA• 11 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 115
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 116
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 117
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 sortieTCCR3A = 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 vitesseTIFR3 = 0b00011111; // pour effacer les indicateurs d’événementsTIMSK3 = 0b00000000; // Pas d’IT de période
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 118
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 120
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 121
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 p1positive pour arriver à V puis le temps sur une droite de pente p2 négative pour revenir à 0 plus précis
• Avantages :– Précis (ne dépend que de la précision de la mesure du temps)– Simple donc peu cher
• 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
pente = p0
V=pt
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 122
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 123
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 124
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 125
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 126
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 127
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 128
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 1,625 µs• 010 3,25 µs• 011 6,5 µs• 100 13 µs• 101 26 µs• 110 52 µs• 111 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 129
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
• Ce capteur mesure des accélérations maximales de 6 G :
• La tension varie alors de 206 mV par G
Gmin Gmax
2,5 V
Tension de sortie(V)
Accélération(G)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 130
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 µsADCSRB = 0b00001000; // entrée 10, inutilisé (le bit 5 de ADCRA est à 0)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 131
Mesures d’accélération : calculs• Conversion de la tension de sortie du capteur en accélération positive ou
négative :
– 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
0-2-4-6 42 6
2,5
Tension de sortie(V)
Accélération(G)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 132
Mesures d’accélération : programme
int main() {
ADMUX = 0b01000010; // Vmax = 5V, cadré à droite, entrée 10ADCSRA = 0b10010010; // Marche, non lancé, décl par prog,
// effac indic IT, pas d’IT, conv en 3µsADCSRB = 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 133
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 134
Déclenchement par TimerExemple
• 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 135
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 1ADCSRA = 0b10111110; // Marche, non lancé, décl par timer,
// effac indic IT, avec d’IT, conv en 33 µsADCSRB = 0b00000101; // entrée 1, Timer 1 atteint OCR1B
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 136
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 OCR1BDivision d’horloge par 256 (Tu = 16 µs) pour atteindre 1sLa 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 signalTCCR1B = 0b00011100; // Pas de capture, limite dans ICR, div par 256ICR1 = 62500UL; // limite = 1 sOCR1A = 62500UL; // Déclenchement du convertisseur chaque sTIFR1 = 0b00011111; // Effacement des indicateursTIMSK1 = 0b00000000; // Pas d’IT du Timer
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 137
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 procheif (temp > 190) {
// Déclencher l’alarme}
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 139
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 140
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 141
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 142
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 143
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 : 100 Kbits/s– Fast : 400 Kbits/s– Fast plus : 1 MB/s– High-speed : 3,4 Mb/s– Ultra High-speed : 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 144
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 145
I2C : ProtocoleLa 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 146
I2C : protocole3. Envoi de message :
– Envoyer un octet– Attendre qu’il soit envoyé– Regarder si l’esclave a répondu par ACK – Recommencer pour chaque octet
OURéception de message :
– Préparer le périphérique pour répondre • 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
3. Fin de connexion :– Envoyer un bit de STOP
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 147
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 148
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 149
I2C du 2560Etats 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 150
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 151
I2C du 2560Etats 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 153
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 154
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 155
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 157
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 158
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 159
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 :– 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
• Les interruptions (ISR) restent gérées par le programme (sauf celle du Timer 0 qui, chaque 5 ms, relance l’ordonnanceur)
– 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 160
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 161
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 162
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 163
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 164
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 165
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 166
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 167
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édenttempsPrecedent = xTaskGetTickCount();// date du 1er démarragewhile (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 168
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 boutonwhile(true) {
while (IS_CLR_BIT(PINB,0)) {} // attendre bouton appuyé// Faire le traitementwhile (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 programmewhile(true) {
while (IS_CLR_BIT(ADCSRA, 4)) {} // attendre mesureSET_BIT(ADCSRA, 4); // Effacer l’indicateur// Faire le traitement de la valeur lue dans ADCvTaskDelay(100/5); // attendre 1/10 s
}}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 169
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 170
Exemple : le programme
Le programme crée les 2 tâches puis se transforme en ordonnanceur :
#define PRIORITE_TACHE_1 ( tskIDLE_PRIORITY + 1 )#define PRIORITE_TACHE_2 ( tskIDLE_PRIORITY + 2 )
int main() {// Création des 2 tâchesxTaskCreate(bouton, "Bouton", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_1, NULL); // pas de paramètrexTaskCreate(entree, "Entree", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_2, NULL); // pas de paramètre
// Démarrage de l’ordonnanceurvTaskStartScheduler(); while(true) {} // On n’arrive ici que si l’ordonnanceur se plante
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 171
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 programmewhile(true) {
…}
}
• Le passage du paramètre est fait dans le programme :
int main() {// Création des 2 tâchesxTaskCreate(bouton, "Bouton", configMINIMAL_STACK_SIZE,
NULL, PRIORITE_TACHE_1, NULL); // pas de paramètreuint16_t limite = 300; // Seuil à donner à la tâche 2xTaskCreate(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 172
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 173
Pipes : lectureLecture 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 174
Pipes : écritureEcriture 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 175
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 programmeuint16_t prec = 1024; // Pour envoyer la 1ère mesurewhile(true) {
while (IS_CLR_BIT(ADCSRA, 4)) {} // attendre une mesureSET_BIT(ADCSRA, 4); // Effacer l’indicateuruint16_t val = ADC; // relever la mesureif (val != prec) { // Si elle est différente l’envoyer
xQueueSendToBack(tube, &val, portMAX_DELAY);}prec = val; // mesure précédentevTaskDelay(1000/5); // attendre 1 s
}}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 176
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 pipexQueueReceive(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 globalint main() {
// Création du pipetube = xQueueCreate(5, sizeof(uint8_t)); // Création du pipe on prévoit de la place pour 5 données// création des 2 tâchesxTaskCreate(mesure, "M", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_1, NULL); // pas de paramètrexTaskCreate(traitement, "T", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_2, NULL); // pas de paramètre
// Démarrage du schedulervTaskStartScheduler();
}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 177
Sémaphores : rappel• Un sémaphore est un compteur qui ne connaît que 2 opérations :
– Opération P (fermeture) :1. Si le compteur est à 0 se bloquer jusqu’à ce qu’il ne soit plus à 0 2. le décrémenter
– Opération V (ouverture) :1. 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 178
SémaphoresLes 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 179
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_tLes 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 180
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 181
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 à surveillerwhile(true) {
while(IS_CLR_BIT(PIND,0)) {} // Attendre que la ligne passe à 0xSemaphoreGive( sem); // Débloquer T1while(IS_SET_BIT(PIND,0)) {} // Attendre que la ligne revienne à 1
}}
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 182
Sémaphores : exemplevoid tache3(void * param) {
// init du convertisseur en mode déclenché par programmeuint16_t prec = 1024; // Pour envoyer la 1ère mesurewhile(true) {
while (IS_CLR_BIT(ADCSRA, 4)) {} // attendre une mesureSET_BIT(ADCSRA, 4); // Effacer l’indicateuruint16_t val = ADC; // relever la mesureif (val != prec) { // Si elle est différente l’envoyer
xSemaphoreGive( sem); // Débloquer T1}prec = val; // mesure précédentevTaskDelay(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 183
Sémaphores : exempleLes 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émaphoresem = xSemaphoreCreateBinary(); // Création du sémaphore (il est fermé)// création des 3 tâchesxTaskCreate(tache1, "T1", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_1, NULL); // pas de paramètrexTaskCreate(tache2, "T2", configMINIMAL_STACK_SIZE, NULL,
PRIORITE_TACHE_2, NULL); // pas de paramètrexTaskCreate(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 184
Sémaphores : exempleLa 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éeEICRA = 0b00000011; // Détection de front montantSET_BIT(EIFR,0); // Effacement de l’indicateur d’ITSET_BIT(EIMSK,0); // IT autorisée sur INT0sei(); // 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 186
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 187
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 188
Chien de garde : programmation• Un seul registre suffit à programmer le chien de garde :
WDTCSR ← imdvmdddi : 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 seuldddd : 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 190
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 191
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éeLorsque 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 192
Eviter le débogageAvant 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 193
Eviter le débogageLors 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 194
Une partie du projet (168 fichiers)
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 195
Un des fichiers de configuration
Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 198
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 199
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 200
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 201
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 202
CAN : prioritésLe 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 111100001. A émet 11102. B émet 1111 mais voit que sur le bus il y a eu 1110 il s’arrête3. A continue avec 11014. 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. A émet 11102. B émet 1111 en raison du retard il ne voit pas que sur le bus il y a eu 1110 il continue3. A continue avec 14. B continue avec 0 il s’aperçoit maintenant que sur le bus il y a eu 1110 il s’arrête5. 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 203
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 204
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 205
CAN : Gestion des erreurs• Le contrôleur de réseau CAN teste les erreurs :
– Erreur de CRC– Trame de format incorrect– Problème de ligne : quand on émet un 0 on doit toujours relire un 0
• Il gère deux compteurs d’erreur TEC (émission) et REC (réception) initialement à 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 -1sinon 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 206
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 208
Autres microcontrôleursIl 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 209
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 210
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 211
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 212
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