Arduino LP Prog - IUT de Bayonne et du Pays Basque

213
Informatique embarquée Temps réel

Transcript of Arduino LP Prog - IUT de Bayonne et du Pays Basque

Informatique embarquée

Temps réel

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 20

Un peu d’histoire

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 25

Capteurs et Actionneurs

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 31

Contrôleurs de périphériques

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 62

Evénements

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 74

Le temps

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 107

Commandes temporelles

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 119

Entrées analogiques

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 138

Bus de données

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 152

Système temps réel

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 156

Free RTOS

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 185

Chien de garde(Watchdog)

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 189

Mise au point des programmes

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 196

Un exemple de code

Informatique embarquée et temps réel – M. Dalmau – IUT de Bayonne 197

Réseau industriel

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 207

Les autres microcontrôleurs

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

C’est fini