Transparents Arduino LP Prog.pdf

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 industrielle
Différences avec l’informatique traditionnelle :
• Embarquée  doit être autonome et sûre
– Contrôle de l’énergie (éteindre ce qui ne sert pas ou plus, mise en veille …)
– Reprise en cas d’erreur (détection d’erreur, sauvegarde d’état, reprise en un point sûr)
– Auto contrôles (au démarrage, à temps perdu)
– Etats de mise en sécurité (arrêter totalement ou partiellement le système)
• Industrielle
– Travaille avec des phénomènes réels
• Imprécision des mesures ( image du système faussée)
• Imprécision du modèle (mal connu ou trop complexe  approché)
• Délais à respecter (à faire immédiatement, après ou avant un temps donné)
• Intervention humaine parfois impossible ou trop lente
• Grandes quantités de données mais éphémères (on ne stocke pas)
– Risques élevés
• Mise en danger des personnes, de l’environnement, etc.
• Détérioration du système lui-même

Informatique industrielle (risques)
En Informatique industrielle :
Au lieu de :
On risque d’avoir :

Principe (système en boucle)
Image
du
système
réel
capteurs
actionneurs
Système
réel
Valeurs
Commandes Modifier
Mesurer
Programme
CPU Contrôleurs
de
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

Principe (système en boucle)
Image
du
système
réel
capteurs
actionneurs
Système
réel
Valeurs
Commandes Modifier
Mesurer
Programme
CPU Contrôleurs
de
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

Le câblage
Contrôleurs
de
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)

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)

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)

Données et résultats
Informations reçues :
• Mesures prélevées par les capteurs
– Numérique (1 ou plusieurs bits, ex : présence / absence)
– Analogique (ex : température)  devra être numérisée (conversion)
– Temporelle (durée pendant séparant deux événements)
• Evénements détectés par les capteurs
– Répétitifs (ex : détection de rotation)
– Occasionnels (ex : arrêt d’urgence)
Informations produites :
• Commandes d’actionneurs
– Numérique (1 ou plusieurs bits, ex : marche/arrêt)
– Analogique (En pratique rarement utilisé, ex : vitesse)
– Temporelle (durée pendant laquelle un bit reste à 0 ou à 1 + période
ex : positionnement d’un servomoteur)

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

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)

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)

Auto contrôle
• Principe :
1. Donner une consigne à un actionneur
2. Vérifier par un capteur l’effet de cette consigne
3. Si la valeur mesurée n’est pas celle attendue ajuster la consigne
4. Recommencer au 2
• Problème :
– Comment ajuster la consigne ?
• Solutions :
– Ajuster très peu pour arriver petit à petit à la bonne valeur
• Marche bien mais risque de mettre beaucoup de temps si la valeur
mesurée est loin de la valeur voulue
– Ajuster au mieux rapidement
• Ajuster la consigne plus ou moins en fonction de l’éloignement entre la
valeur mesurée et la valeur voulue mais risque d’oscillations

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

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)

Auto contrôle (informatisation)
• Réalisation informatique :
– La valeur voulue est V
– À intervalles réguliers on relève la valeur mesurée Vm et on calcule
l'écart
e = V - Vm
Si l'erreur est dans de l'intervalle de marge d’erreur [-ε, +ε]
// La consigne n’est pas modifiée (elle est bonne)
Sinon
somme ← somme + e
différence ← eprec - e
consigne ← Kp * e + Ki * somme + Kd * différence
eprec ← e
• ATTENTION :
Il est important de faire les mesures à intervalles réguliers
sinon les sommes et les différences entre écarts ne veulent rien dire

Auto contrôle (ajustement)
Il ne reste plus qu’à trouver les coefficients Kp, Ki et Kd
• Influence des coefficients sur le comportement du système :
– Kp : permet de s’approcher de la valeur voulue mais pas de l’atteindre (si l’écart est nul Kp n’a
plus d’effet). Si Kp est trop grand ça oscille.
– Ki : permet d’atteindre la valeur voulue mais introduit des oscillations (on la dépasse puis on
revient en arrière plusieurs fois ou indéfiniment)
– Kd : accélère la convergence et atténue les oscillations (on anticipe)
• Méthodes de détermination
– On peut les déterminer par calcul mais cela suppose de connaître les équations régissant le
fonctionnement du système réel
• En général elles sont difficiles à trouver (pour une voiture ça dépend des temps
d’accélération du moteur selon son régime actuel, du poids de la voiture, des frottements
de l’air, du revêtement de la route, de l’état des pneus, de la pente …)
– On peut les obtenir par ajustements :
1. Mettre Ki et Kd à 0 et ajuster Kp pour que la correction proportionnelle amène la valeur
mesurée au plus près de celle attendue sans trop osciller
2. Introduire Ki dans la formule et l'ajuster pour arriver le plus précisément possible à la
valeur attendue sans trop osciller
3. Introduire Kd dans la formule et l’ajuster pour diminuer les oscillations

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 à rien
2. 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

Un peu d’histoire

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

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

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

Le code
• Extrait du code de mise à feu :
# *********************************
# GENERAL PURPOSE IGNITION ROUTINES
# *********************************
BURNBABY TC PHASCHNG # GROUP 4 RESTARTS HERE
OCT 04024
CAF ZERO # EXTIRPATE JUNK LEFT IN DVTOTAL
TS DVTOTAL
TS DVTOTAL +1
TC BANKCALL # P40AUTO MUST BE BANKCALLED EVEN FROM ITS
CADR P40AUTO # OWN BANK TO SET UP RETURN PROPERLY
• Problème de temps réel :
– A l’alunissage, le nombre de données radar à traiter charge le CPU à 98%
– Aldrin demande l’affichage de l’altitude calculée  surcharge de 10%
– Le module de calcul n’a plus le temps de s’exécuter au rythme auquel le
radar envoie les données  le CPU produit une alarme (1202)
– Il est relancé par Houston (3 fois)
http://klabs.org/history/apollo_11_
alarms/eyles_2004/eyles_2004.htm

Capteurs et Actionneurs

Capteurs
• Principes
– Transforme une grandeur physique en :
• Une grandeur électrique : tension ou courant
ou
• Un temps : durée ou fréquence
– La transmet sous forme numérique (binaire) ou analogique (tension)
• Moyens :
– Mécanique (contact, résistance ou capacité variable)
– Piézoélectrique (tension induite par la déformation d’un cristal)
– Effet Hall (tension induite par un champ magnétique)
– Capacitif (tactile ou chimique)
– Rayonnement (radio, infrarouge, laser)
– Ultra sons (puissance, temps de propagation)
– Lumière (phototransistor ou photorésistance)
– Chimique (électrodes)

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)

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)

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

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)

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

• 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

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)

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

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

Programmation
• Langages :
– Assembleur (quand on ne peut pas faire autrement)
– C (le plus utilisé, souvent avec des variantes spécialisées)
– C++ (mais l’objet n’apporte pas grand-chose : peu d’objets, peu d’héritage)
– Java ou Python (mais parfois trop lents car interprétés)
• Les pièges :
– Valeurs physiques : unités (g, Kg, N)  conversions : En 1992, la sonde Mars
Observer est détruite car le logiciel développé par Lockheed envoie des mesures
en uinités anglosaxonne alors que celui qui les recevait supposait qu’elles étaient
en unités internationnales.
– Temps / Fréquences : unités (s, ms, μs / Hz, KHz, MHz)  conversions
– Valeurs numériques entières :
• 4 milliards est possible dans un entier non signé sur 32 bits
• Pas dans un entier normal (int) : -32767 à 32767
– Valeurs numériques réelles (float / double) :
(1.1 + 3.3) + 5.5 → 9.900000
Mais
1.1 + (3.3 + 5.5) → 9.900001
– Calculs
• Faits en fonction des types des opérandes pas du type du résultat

Langage C : types
uint64_t
unsigned long long
int64_t
long long
64 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
Pointeur
Booléen
Réel
Entier non signé
Entier
signé
Type
Taille
(1) A condition d’avoir mis : #include <stdbool.h> les valeurs sont true et false

Langage C : valeurs numériques
Une valeur numérique peut être affectée à une variable : x = 156;
Une valeur numérique peut être donnée à une constante: #define x 156
Sans précision supplémentaire les valeurs numériques sont considérées comme
des entiers signés (int)
• On peut préciser leur taille par L (long) ou LL (long long)
• On peut préciser l’absence de signe par U (non signé)
• Et on peut combiner les deux
• Pour les réels il suffit qu’apparaisse un . dans la valeur (15.0 et pas 15)
• Exemples :
– Entier signé : 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

Langage C : les bases
• Un nombre peut être écrit :
• En décimal
v = 4568;
u = -25478
• En hexadécimal
v = 0xA01E;
• En binaire
v = 0b01101101;

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

Opérations binaires
Les opérations binaires de ET, OU, NON et de décalage nous seront utiles.
• ET
11010111
& 01100110
01000110 0 & 0 = 0 , 0 & 1 = 0 , 1 & 0 = 0, 1 & 1 = 1
• OU
11010111
| 01100110
11110111 0 | 0 = 0 , 0 | 1 = 1 , 1 | 0 = 1, 1 | 1 = 1
• NON
11010111
~ 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 à gauche
11010111
<< 10101110 Décalage des bits vers la gauche et mise à 0 du bit de droite

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)))

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)

Interruptions
• Chaque contrôleur de périphérique peut générer des interruptions
• À une interruption est associée une fonction qui sera
immédiatement exécutée
• La prise en compte d’une interruption est très rapide (inférieur à la
microseconde)
Prise en compte d’une interruption :
Traitement
en cours
Interruption
Traitement associé
à l'interruption
Reprise,du
traitement
suspendu

Interruptions : préemption
• Que se passe t-il si une interruption survient pendant l’exécution
de la fonction associée à une interruption ?
Traitement
en cours
Interruption 1
Traitement associé
à l'interruption 1
Reprise,du
traitement
suspendu
Traitement associé
à l'interruption 2
Traitement
en cours
Interruption 1
Traitement associé
à l'interruption 1
Reprise,du
traitement
suspendu
Traitement associé
à l'interruption 2
Interruption 2
Interruption 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)

Interruptions : priorité
Exemple :
1. Un traitement est en cours
2. Une interruption (IT1) arrive
3. Le traitement est suspendu et la fonction associée à l’IT1 est démarrée
4. Pendant son exécution une interruption (IT2) arrive : elle est mise en attente
5. 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

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)

Entrées / Sorties numériques
du XMega 2560

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

Emetteur de
lumière
Récepteur de
lumière
Début du
passage
Fin du
passage
Nouveau
passage
Durée du
passage
Temps entre 2 passages
Faisceau lunineux
1
0
Information
du 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

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);

Exemple : Compteur de passage
Sur une chaîne de production on veut compter les objets produits par
une machine.
Ces objets sortent de la machine sur un tapis roulant.
• On place un faisceau lumineux en travers du tapis roulant
• Le faisceau est coupé quand quelque chose passe devant
• Le capteur est un capteur de lumière qui produit :
– Un niveau 1 quand il reçoit de la lumière
– Un niveau 0 quand il n’en reçoit pas
• On l’a relié à la ligne 4 du Port B (pourquoi pas ?)

Exemple : Solution
Le programme :
int main(void) {
CLR_BIT(DDRB, 4); // Capteur = entrée numérique
int compteur = 0; // Comptage des passages
while (true) { // Le programme fait ça indéfiniment (que ferait-il d’autre ?)
if (IS_CLR_BIT(PINB, 4)) { // Le faisceau est coupé
compteur++; // On compte un passage
printf("Nombre d’objets : %dn" , compteur); // Affichage
}
}
}

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éfiniment
if (IS_CLR_BIT(PINB, 4)) { // Le faisceau est coupé
printf("Nombre de tours : %dn" , compteur); // Affichage
while (IS_CLR_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 1
}
}

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) {
if (IS_SET_BIT(PINB, 4)) { // Le contact est appuyé
while (IS_SET_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 0
}
}
}

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 ?

Capteur mécanique
Utilisation d’une ligne comme entrée numérique
reliée à un capteur mécanique :
L'état de la ligne
est instable
L'état de le ligne est 0
L'état de le ligne est 1
Début du
délai de
flitrage
Fin du
délai de
flitrage
Délai de filtrage
La ligne est considérée comme étant à 0 La ligne est considérée
comme étant à 1
L'état de la
ligne est
instable L'état de le ligne est 0
Début du
délai de
flitrage
Fin du
délai de
flitrage
Délai de filtrage
La ligne est considérée
comme étant à 0
L'objet active
le contact
L'objet libère
le 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)

Capteur mécanique
Solution avec délai :
int main(void) {
if (IS_SET_BIT(PINB, 4)) { // Le contact est appuyé
// Attendre 20 à 50 ms
while (IS_SET_BIT(PINB, 4)) {} // Attendre que la ligne revienne à 0
// Attendre 20 à 50 ms
}
}
}

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);

Exemple : pilotage d’une DEL
On a relié une DEL à la ligne 6 du Port C et un bouton tactile
(sans rebonds) à la ligne 5 du Port C.
A chaque touché, le bouton allume/éteint la DEL en bascule
#define DEL 6
#define BOUTON 5
int main(void) {
SET_BIT(DDRC, DEL); // ligne de la DEL en sortie
CLR_BIT(PORTC, DEL); // initialement éteinte
CLR_BIT(DDRC, BOUTON); // ligne du bouton tactile en entrée
while (IS_CLR_BIT(PINC, BOUTON)) { // Attendre un touché du bouton
SET_BIT(PINC, DEL); // Allumer/éteindre la DEL
while (IS_SET_BIT(PINC, BOUTON)) { // Attendre bouton non touché
}
}

Evénements

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

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

Fonction d’interruption
• Association d’une fonction d’interruption à une ligne INT :
1. Mettre la ligne en entrée
Exemple : INT5 correspond à la ligne 5 du Port E
CLR_BIT(DDRE, 5);
2. Choisir le front de déclenchement par le registre EICRA (INT0 à 3) ou EICRB (INT4 à 7).
• Les bits 7 et 6 correspondent à INT3 (EICRA) ou 7 (EICRB)
Leur valeur définit le front :
– 01 : tous les fronts
– 10 : fronts descendants
– 11 : fronts montants
Exemple : INT5 en détection de front montant
EICRB = EICRB | 0b00001100;
3. Effacer les indicateurs d’interruption par le registre EIFR
Exemple : pour INT5 c’est le bit 5 de EIFR
SET_BIT(EIFR, 5); // ATTENTION : on efface le bit en y écrivant un 1
4. Autoriser le déclenchement de l’interruption par le registre EIMSK
Exemple : pour INT5 c’est le bit 5 de EIMSK
SET_BIT(EIMSK, 5);

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) {
…
}

Fonction d’interruption
• Association d’une fonction d’interruption à une ligne PCINT :
1. Mettre la ligne en entrée
Exemple : PCINT21 correspond à la ligne 5 du Port K
CLR_BIT(DDRK, 5);
2. Autoriser le déclenchement de l’interruption par le registre PCMSK0 (PCINT0 à
7) ou PCMSK1 (PCINT8 à 15) ou PCMSK2 (PCINT16 à 23)
Exemple : PCINT21 c’est le bit 5 de PCMSK2
SET_BIT(PCMSK2, 5);
Les interruptions sont regroupées : les lignes PCINT0 à 7 provoquent
l’interruption PCINT0, les lignes 8 à 15 l’interruption PCINT1 et les
lignes 16 à 21 l’interruption PCINT2
3. Effacer les indicateurs d’interruption par le registre PFICR
Exemple : pour PCINT21 (interruption 2) c’est le bit 2 de PFICR
SET_BIT(PFICR, 2);
4. Autoriser le déclenchement de l’interruption par le registre PCICR
Exemple : pour PCINT21 (interruption 2) c’est le bit 2 de PCICR
SET_BIT(PCICR, 2);

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.

Exemple : imprimante 3D
• Programme de l’imprimante
int main() {
Initialisations
while (true) {
if (carteSD) {
Lire une commande dans le fichier
if (fin de fichier) while(true) {} // se bloquer (fin d’impression)
}
else {
Attendre une commande sur le port série (relié à l’USB)
// On se bloque si aucune commande n’arrive (fin d’impression)
}
Exécuter la commande
if (! carteSD)
Signaler la fin d’exécution de commande sur le port série
}
}
}

Exemple : imprimante 3D
Interruption de changement de filament :
• On a relié un bouton sur la ligne 5 du Port E (INT5) que l’on a programmée pour
générer une interruption au front montant (appui sur le bouton)
• Fonction d’interruption :
ISR(INT5_vect) { // L’utilisateur a appuyé sur le bouton
CLR_BIT(EIMSK, 5); // interdire l’IT suivante (le prochain appui relance le programme)
while(IS_SET_BIT(PINE, 5)) {} // attendre que le bouton soit lâché
// L’utilisateur a lâché le bouton
// Il change le fil
// Puis il appuie à nouveau le bouton
while(IS_CLR_BIT(PINE, 5)) {} // attendre que le bouton soit appuyé à nouveau
SET_BIT(EIFR, 5); // Effacer l’indicateur d’IT
SET_BIT(EIMSK, 5); // autoriser l’IT suivante pour changement de filament suivant
}

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

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

Bonne solution (suite)
volatile bool arret;
int main() {
Initialisations
arret = false; // L’impression va démarrer
while (true) {
if (carteSD) {
Lire une commande dans le fichier
if (fin de fichier) while(true) {} // se bloquer (fin d’impression)
}
else {
attendre une commande sur le port série (relié à l’USB)
// On se bloque si aucune commande n’arrive (fin d’impression)
}
Exécuter la commande
if (arret) { // L’impression a été suspendue par l’utilisateur
while(IS_SET_BIT(PINE, 5)) {} // attendre que le bouton soit lâché
while(IS_CLR_BIT(PINE, 5)) {} // attendre que le bouton soit appuyé à nouveau
SET_BIT(EIFR, 5); // Effacer l’indicateur d’IT
SET_BIT(EIMSK, 5); // autoriser l’IT suivante
arret = false; // L’impression reprend
}
if (! carteSD) {
Signaler la fin d’exécution de commande sur le port série
}
}
}
ISR(INT5_vect) { // L’utilisateur a appuyé sur le bouton
CLR_BIT(EIMSK, 5); // interdire l’IT suivante
arret = true;
}

Le temps

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

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

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)

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 LIM
LIM-1
LIM-2
Evénement
Tops d'horloge
Tu
Valeur du compteur
…
Tu = temps entre 2 tops = 1/ fréquence horloge

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

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
– 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,194304
1,048576
262,114
32,768
4,096
Timers 1, 3, 4 et 5
16,384
4,096
2,048
1,024
512
128
16
Timer 2
16,384
4,096
1,024
128
16
Timer 0
1024
64
256
16
128
8
64
4
32
2
8
1/2
1
1/16
Division
Tu (µ
µ
µ
µs)

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,194304
1,048576
262,114
32,768
4,096
Timers 1, 3, 4 et 5
16,384
4,096
2,048
1,024
512
128
16
Timer 2
16,384
4,096
1,024
128
16
Timer 0
1024
64
256
16
128
8
64
4
32
2
8
1/2
1
1/16
Division
Tu (µ
µ
µ
µs)

Timers : Registres
Les timers 1, 3, 4 et 5 ont 10 registres (les timers 0 et 2 en ont moins
ce sont des versions simplifiées)
• TCCRiA :
– 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

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

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 à θ.

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.

• Lancement du Timer (par choix d’une horloge)
– TCCRiB ←
←
←
← TCCRiB | 00000hhh
• hhh =
• 001 : division d’horloge par 1
• 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

• 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 :
}
• Associer une fonction d’interruption à la fin du délai :
ISR(TIMERi_OVF_Vect) { … }
ISR(TIMERi_COMPA_Vect) { … }

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 C2
Pour savoir si une touche est appuyée :
1. On met au niveau 0 la ligne Li (les autres sont à 1)
2. On regarde si on trouve un niveau 0 sur une colonne
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

Clavier : solution 1
• On écrit un programme qui scrute le clavier en boucle :
int main() {
// init des 4 lignes en sortie
// init des 3 lignes en entrée avec maintien à 1 quand non connectées
while (true) {
for(int i = 0; i < 3; i++) { // balayer les lignes
mettre toutes les lignes à 1
mettre la ligne i à 0
for(int j = 0; j < 2; j++) { // tester les colonnes
si la colonne i est à 0 traiter la touche (i,j)
}
}
}
}
• L’inconvénient c’est que le programme ne fait que ça
• En réalité il n’est pas utile de scruter le clavier en boucle il suffirait de le faire
de temps en temps (assez vite par rapport au temps d’appui d’une touche
par l’utilisateur)

• 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

Timer 1 pour un délai de 1/40 s = 25 ms (on a 4 lignes à
scruter chaque 1/10s) :
void initTimer() {
TCCR1A = 0;
TCCR1B = 0b00001010; // Limite de comptage dans OCR1A,
// div par 8 pour arriver à 25 ms (Tu = ½ µs)
OCRiA = 25000*2; // Durée de 25 ms avec Tu = ½ µs
TIFRi = 0b00011111; // Effacer les indicateurs
TIMSKi ← 00000010 // IT chaque 25 ms (OCR1A)
sei(); // autoriser la prise en compte des IT par le processeur
}

Fonction d’interruption :
volatile bool toucheAppuyee; // Indicateur pour le programme
volatile uint8_t ligne, colonne; // N°de ligne et de colonne pour le programme
uint8_t ligneScrutee; // Dernière ligne scrutée
ISR(TIMERi_COMPA_Vect) { // Fonction d’IT chaque 1/40 s
Mettre à 1 toutes les lignes
Mettre à 0 la ligne de n° « ligneScrutee »
ligneScrutee = (ligneScrutee +1) % 4; // passer à la ligne suivante
Si l’une des 3 colonnes est à 0
ligne ← ligneScrutee
colonne ← n° de la colonne qui est à 0
toucheAppuyee ← true
}
}

Et le programme devient :
int main() {
// init des 4 lignes en sortie
// init des 3 lignes en entrée avec maintien à 1 quand non connectées
ligneScrutee = 0; // Pour démarrer par la 1ère ligne
toucheAppuyée = false; // Pas de touche appuyée au départ
while (true) {
// Traitements divers
if (toucheAppuyee) { // Quand on veut traiter la dernière touche appuyée
toucheAppuyee = false; // Pour détecter la prochaine touche
traiter la touche (ligne, colonne)
}
}
}

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

Timers (mesure de durée)
La mesure d’une durée correspond à mesurer le temps qui
sépare deux événements.
• Il y 2 façons de procéder :
1. Par programme :
Le programme attend le 1er événement ou il y a une interruption associée à cet événement
Lors de cet événement le timer est démarré
Le programme attend le second événement ou il y a une interruption associée à cet
événement
Lors de cet événement on relève la valeur du timer et on le remet à 0 pour la mesure suivante
2. Par capture :
Le programme attend le 1er événement ou il y a une interruption associée à cet événement
Lors de cet événement le timer est démarré
Le second événement provoque une copie automatique de la valeur du timer dans le registre
ICRi (capture)
Le programme attend cette capture ou il y a une interruption associée à la capture
Lors de cet événement on relève la valeur du timer et on le remet à 0 pour la mesure suivante
Remarque : La seconde méthode ne peut être utilisée que si l’événement 2 est un
changement d’état (front montant ou descendant) d’une ligne associée au timer

Mesure de durée sans capture
Initialisation d’un Timer :
– TCCRiA ← 00000000
– TCCRiB ← 000xx000
• xx =
• 00 si la durée maximale est 65 535
• 01 si la durée maximale est définie par la valeur de OCRiA
– OCRiA ← durée maximale si xx = 01
– TIMSKi ← 000000yz

– TCCRiB ←
←
←
← TCCRiB | 00000xxx
• xxx =
• 001 : division d’horloge par 1 (Tu = 1/16 µs)
• 011 : division d’horloge par 64 (Tu = 4 µs)
– TCCRiB ←
←
←
← TCCRiB & 11111000
– TCNTi ←
←
←
← 0
• Lecture de la mesure (par lecture du compteur)
– uint16_t mesure = TCNTi;

• Savoir si la durée maximale est dépassée :
}
}
• Associer une fonction d’interruption au dépassement de la durée maximale :

Mesure de durée par capture
• Une ligne physique est associée à chaque Timer
• On choisit le changement d’état (front montant ou descendant) de cette ligne
qui provoquera la capture du Timer
• Pour éviter les déclenchements parasites (si la ligne est instable) on peut
demander à ce que la capture n’ait lieu que si ce changement a duré au
moins 4 périodes de l’horloge du Timer (4 * Tu)
• Lors de cet événement, la valeur du compteur est copiée dans le registre ICRi
et une interruption peut être générée. Mais le Timer continue de compter
• Lignes associées aux timers
– Timer 1 : ligne 4 du Port D
– Timer 3 : ligne 7 du Port E
– Timer 4 : ligne 0 du Port L
– Timer 5 : ligne 1 du Port L

Initialisation d’un Timer :
– TCCRiA ← 00000000
– TCCRiB ← ab0xx000
• a = 1 si le changement d’état doit durer au moins 4 périodes d’horloge du Timer (4*Tu)
• b = 0 capture au front descendant, b = 1 capture au front montant
• xx =
• 00 si la limite de comptage est la valeur maximale (65 535)
• 01 si la limite de comptage est la valeur de OCRiA
– OCRiA ← durée maximale si xx = 01
– TIMSKi ← 00c000yz
• c = 1 si on veut une interruption au moment de la capture

– TCCRiB ←
←
←
• xxx =
– TCCRiB ←
←
←
← TCCRiB & 11111000
– TCNTi ←
←
←
← 0
• Lecture de la mesure (par lecture du registre de capture)
– uint16_t mesure = ICRi;

• Savoir si la durée est dépassée :
}
}
• Associer une fonction d’interruption au dépassement de la durée :
• Associer une fonction d’interruption à la capture :
ISR(TIMERi_CAPT_Vect) { … }

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

Mesure de vitesse : choix des valeurs
• Il faut choisir une vitesse d’horloge et une limite du Timer correctes :
– La vitesse d’horloge définit la précision de la mesure de vitesse du moteur
– La limite définit le temps maximum mesurable donc la vitesse minimale
mesurable du moteur
• Formules de calcul de la vitesse :
– D = durée entre 2 passages d’une raie (en µs)
– T = temps d’un tour = D * 360/6 = 60*D (en µs)
– V = vitesse du moteur = 60*1000000 / T = 1000000 / D (en tours / min)
• La vitesse minimale à mesurer Vmin est de 50 tr/min
 Dmin = 100000/50 = 20000 µs = 20 ms
 On va choisir une division d’horloge par 8 (max = 32,768 ms)  Tu = ½ µs
Le temps unitaire est de ½ µs donc la limite sera 40000
• La vitesse maximale à mesurer Vmax est de 10000 tr/min
 Dmax = 1000000/10000 = 100 µs
Le temps unitaire est de ½ µs donc on comptera jusqu’à 200 (précision 0,5%)

Mesure de vitesse (inits)
Remarque : Pour cet exemple on n’utilisera pas le mode capture
void initTimer() {
TCCR1A = 0; // Pas de capture : on mesure par programme
TCCR1B = 0b00001000; // Limite de comptage dans OCR1A, timer arrêté
OCRiA = 40000; // Durée pour 50 tr/min avec Tu = ½ µs
TIFRi = 0b00011111; // Effacer les indicateurs
TIMSKi ← 00000010 // IT si débordement (OCR1A)
sei(); // autoriser les IT du processeur
}

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 (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/minn" , 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 lenten");
}

Commandes temporelles

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ée
du 0
durée
du 1
période
0
1

Génération de signaux : utilisation
Servomoteur :
• Un servomoteur est un moteur que l’on peut faire tourner pour le placer à
un angle précis.
• Ils sont utilisés en robotique (mouvements de bras de robots par exemple),
en modélisme (dérive d’un avion), etc.
• Un servomoteur reçoit un signal temporel :
– La période du signal est imposée (20 ms pour la plupart des servomoteurs)
– La durée du 1 (ou du 0 selon le modèle) définit l’angle que doit prendre le moteur
(relation linéaire)
– Exemple :
• Le moteur peut se placer entre -90°et +90°
• La période est de 20 ms
• Si le signal reste à 0 pendant 600 μs le moteur se place à -90°
• Si le signal reste à 0 pendant 2400 μs le moteur se place à +90°
• Donc si le signal reste à 0 pendant 1500 μs le moteur se place à 0°

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).

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 5
Port L ligne 4
Port L ligne 3
5
Port H ligne 5
Port H ligne 6
Port H ligne 7
4
Port E ligne 5
Port E ligne 4
Port E ligne 3
3
Port B ligne 7
Port B ligne 6
Port B ligne 5
1
OCC
OCB
OCA
Timer

• Principe de fonctionnement:
1. Le compteur du Timer compte (incrémenté) à partir de 0
2. Lorsqu’il atteint la valeur contenue dans OCRiA la ligne OCA passe à 1 (ou à 0
selon la programmation choisie)
3. Il en va de même pour les lignes OCB et OCC en fonction des valeurs de
OCRiB et OCRiC et de leur programmation
4. Le compteur arrive à la valeur limite
5. Le compteur repart de cette valeur limite en décomptant (décrémenté)
6. Lorsqu’il atteint la valeur contenue dans OCRiA la ligne OCA passe à 0 (ou à 1
selon la programmation choisie)
7. Il en va de même pour les lignes OCB et OCC en fonction des valeurs de
OCRiB et OCRiC et de leur programmation
8. Lorsque le compteur arrive à 0 (fin de la période du signal) , si une interruption a
été autorisée, elle se produit
9. Il recommence en 1
• Valeurs :
• La période du signal est 2*Limite*Tu
• En mode direct la durée du 1 est 2*OCRiA ou 2*OCRiB ou 2*OCRiC
• En mode inverse la durée du 0 est 2*OCRiA ou 2*OCRiB ou 2*OCRiC

• 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)

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.

– TCCRiB ←
←
←
• xxx=
• 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

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

Moteur : intialisations
• Programmation du générateur de signal :
– La période est de 50 µs on peut donc prendre une division par 1 (maxi 4 ms)
– Le temps unitaire (temps entre 2 tops) est donc de 1/16 μs
– La valeur pour 50 µs est alors : 50*16 = 800 donc la limite sera de 400
– Une variation de 1 du seuil correspondra à une variation de 1/400 = 0,25% de la
vitesse
– On a connecté le moteur sur la ligne 4 du Port E qui est la sortie OCB du Timer 2 :
– Initialisation :
SET_BIT(DDRE,4); // ligne en sortie
TCCR3A = 0b00100001; // sortie OCB directe (OCA et OCC non utilisées)
TCCR3B = 0b00010001; // Mode génération de signal, H div 1
ICR3 = 400; // Période de 50 µs
OCR3B = 200; // Réglage initial à 50% de la vitesse
TIFR3 = 0b00011111; // pour effacer les indicateurs d’événements
TIMSK3 = 0b00000000; // Pas d’IT de période

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

Entrées analogiques

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

Conversion A/N par rampe
• Fonctionnement :
– Simple rampe :
• On génère un signal dont la tension V part de 0 et augmente régulièrement (selon une droite
de pente fixe p) on a donc : V = p * t
• On mesure le temps θ que met ce signal pour atteindre la tension à mesurer Vx
La tension à mesurer est Vx = p * θ et p est fixe et connu
– Double rampe
• C’est une amélioration du précédent où on mesure un temps sur une droite de pente p1
positive pour arriver à V puis le temps sur une droite de pente p2 négative pour revenir à 0 
plus précis
• 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 = p
0
V=pt

Conversion A/N par dichotomie
– 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

Conversion A/N rapide
– 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

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

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é

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

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)

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

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)

Mesures d’accélération
• Initialisation du convertisseur A/N :
– Temps de conversion court (3,25 µs) pour suivre au plus près l’évolution de
l’accélération mais pas trop court (1,625 µs) pour éviter les imprécisions
– Mode déclenché par programme pour suivre l’évolution de l’accélération
aussi vite que le permet le programme
– Donc pas d’interruptions
– La tension maximale renvoyée par l’accéléromètre est de 2,5 + 6*0,206 =
3,736 V (pour 6G) on prendra donc une tension de référence (Vmax) de 5 V
– Le capteur est connecté à la ligne 2 du Port K (entrée 10 du convertisseur)
ADMUX = 0b01000010; // Vmax = 5V, cadré à droite, entrée 10
ADCSRA = 0b10010010; // Marche, non lancé, décl par prog,
// effac indic IT, pas d’IT, conv en 3,25 µs
ADCSRB = 0b00001000; // entrée 10, inutilisé (le bit 5 de ADCRA est à 0)

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 4
2 6
2,5
Tension de sortie
(V)
Accélération
(G)

Mesures d’accélération :
programme
int main() {
ADMUX = 0b01000010; // Vmax = 5V, cadré à droite, entrée 10
ADCSRA = 0b10010010; // Marche, non lancé, décl par prog,
// effac indic IT, pas d’IT, conv en 3µs
ADCSRB = 0b00001000; // entrée 10, inutilisé (bit 5 de ADCRA à 0)
while(true) {
SET_BIT(ADCSRA, 6); // Lancer une conversion par programme
while(IS_CLR_BIT(ADCSRA, 5)) { } // attendre que la conversion soit finie
SET_BIT(ADCSRA, 5); // effacer l’indicateur de fin de conversion
uint16_t mesure = ADC; // Récupérer la mesure
// La convertir en accélération en G
float acc = ( (1000.0 * (mesure * 5.0 / 1024.0)) – 250.0) / 206.0;
…
}
}

Transparents Arduino LP Prog.pdf

Transparents Arduino LP Prog.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à Transparents Arduino LP Prog.pdf

Similaire à Transparents Arduino LP Prog.pdf (20)

Dernier

Dernier (20)

Transparents Arduino LP Prog.pdf