Chap Introduction à la programmation des

Microcontrôleurs Arduino

1. Cycle de développement d’un projet

2. Diagramme de flux
3. Organigramme
4. Langage Arduino

13/11/2023 2020-2021 32
33

1 Informatique embarquée
• Caractéristiques :
1.1
– Ressources limitées (mémoire, CPU, stockage)
– Energie limitée (pile, batterie, panneaux solaires …)
– Interaction avec l’environnement physique (capteurs, actionneurs)

• 1.2 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 –

11/13/2023
34

Informatique industrielle (risques)

En Informatique industrielle :

Au lieu de :

On risque d’avoir :

Informatique embarquée et temps réel – 4

11/13/2023
35

2 Principe (système en boucle)

capteurs
Valeurs Mesurer
Image
du
Programme Système
système
réel
actionneurs réel
Commandes Modifier

CPU Contrôleurs
de
périphériques Microcontrôleur
• Système réel
– Caractéristiques (ce qu’il doit faire, ce qu’il peut faire)
– Temps de réaction
– Limites (sécurité)
• Contrôleurs de périphériques + CPU = microcontrôleur
– Capacités (ce qu’il peut faire)
– Vitesse (du CPU et des contrôleurs de périphériques)
– Limites (valeurs minimales et maximales, précision des mesures et des calculs)

Informatique embarquée et temps réel –

11/13/2023
36

2 Principe (système en boucle)

Valeurs capteurs
Mesurer
Image
du
Programme système Système
réel réel
Commandes actionneurs Modifier

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
Informatique embarquée et temps réel –
11/13/2023
37

3 Le câblage
Adaptation de niveau

capteurs
Contrôleurs
de
périphériques

actionneurs

Adaptation de puissance

• Choisir à quel contrôleur de périphérique relier chaque capteur et chaque actionneur

• Adaptation de niveau : l’information produite par un capteur peut être transmise par un
signal électrique de valeur trop faible ou trop élevée pour le contrôleur de périphériques
(il existe des CI prévus pour ça)

• Adaptation de puissance : le signal électrique produit par le contrôleur de périphériques

peut ne pas permettre d’activer l’actionneur (il existe des CI prévus pour ça)

Informatique embarquée et temps réel –

11/13/2023
4 Informatisation
38

4.1 Les éléments à considérer

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 – 8

11/13/2023
 4 Informatisation
39

4.2 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 à temps (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 – 9

11/13/2023
 40
5 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 ou 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 – 10

11/13/2023
 6 Informations prises en compte
41

• 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 – 11

11/13/2023
42

7 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 – 12
11/13/2023
43

8 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 – 13

11/13/2023
44

9 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

Informatique embarquée et temps réel – 14

11/13/2023
 Auto contrôle (Approche intuitive)
45

• 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 sur une montée ... 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 – 15

11/13/2023
46
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 –

11/13/2023
47
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'ecart est dans l'intervalle de marge d’erreur [-ε, +ε]
// La consigne n’est pas modifiée (elle est bonne)
Sinon
somme ← somme + e
différence ← eprec - e
consigne ← Kp * e + Ki * somme + Kd * différence
eprec ← e

• ATTENTION :
Il est important de faire les mesures à intervalles réguliers
sinon les sommes et les différences entre écarts ne veulent rien dire

Informatique embarquée et temps réel –

11/13/2023
48
Auto contrôle (ajustement)
Il ne reste plus qu’à trouver les coefficients Kp, Ki et Kd
• Influence des coefficients sur le comportement du système :
– Kp : permet de s’approcher de la valeur voulue mais pas de l’atteindre (si l’écart est nul Kp n’a
plus d’effet). Si Kp est trop grand ça oscille.
– Ki : permet d’atteindre la valeur voulue mais introduit des oscillations (on la dépasse puis on
revient en arrière plusieurs fois ou indéfiniment)
– Kd : accélère la convergence et atténue les oscillations (on anticipe)

• Méthodes de détermination
– On peut les déterminer par calcul mais cela suppose de connaître les équations régissant le
fonctionnement du système réel
• En général elles sont difficiles à trouver (pour une voiture ça dépend des temps
d’accélération du moteur selon son régime actuel, du poids de la voiture, des frottements
de l’air, du revêtement de la route, de l’état des pneus, de la pente …)

– On peut les obtenir par ajustements :

1. Mettre Ki et Kd à 0 et ajuster Kp pour que la correction proportionnelle amène la valeur
mesurée au plus près de celle attendue sans trop osciller
2. Introduire Ki dans la formule et l'ajuster pour arriver le plus précisément possible à la
valeur attendue sans trop osciller
3. Introduire Kd dans la formule et l’ajuster pour diminuer les oscillations

Informatique embarquée et temps réel –

11/13/2023
49
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 mésures

→ 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

Informatique embarquée et temps réel – 1

11/13/2023
50

Rappels
historique

Informatique embarquée et temps réel –

11/13/2023
Cycle de développement de produit
• Specifications
• Constraints
• Block diagrams
Analyze Design • Data flow graphs
Requirements
the
Constraints
problem
Development
New requirements
New constraints
• Hardware
Deployment Testing • Software
Done

•Mise en œuvre (réelle)

•Analyse (Quoi?) •Matérielle ou logicielle
•Exigences -> Spécifications
•Essais (fonctionne ?)
•Conception (Comment?) •Validation: Justesse
•Haut-niveau : Diagrammes de blocs
•Performance: Efficacité
•Niveau Ingénierie: Algorithme,
Structures de données, Interfaces •Maintenance (Améliorer)

13/11/2023 2020-2021 51
Diagramme de flux de données

•Lab: Système de mesure de position

Position Voltage Sample

0 to 2 cm 0 to +3.3V 0 to 4095
Sample
Position ADC ADC 0 to 4095
Sensor hardware driver
SysTick
ISR
SysTick
hardware Mailbox

LCD main
LCD
display driver Fixed-point
0 to 2.000
Diagramme de flux des appels

Système de mesure de position

main SysTick
ISR

SysTick ADC LCD

init driver driver

SysTick ADC LCD

hardware hardware hardware
 Organigramme et Programmation
structurée
• Constructions usuelles (en organigramme)
Sequence Conditional While-loop

Block 1

Block 1 Block 2 Block

Block 2

Parallel Distributed Interrupt-driven concurrent

Fork main Trigger
main1 main2 interrupt
Init1 Init2 Init

Join Body1 Body2 Body

Return from
interrupt

13/11/2023 2020-2021 54
Organigramme
Four pour pain tranché (Toast) :

main Cook

Output heat
Input from is on
switch Too cold

Not pressed Input toast

Start temperature
Pressed
toast < desired
Cook toast  desired
Output heat
is off

return

Codage en assembleur et/ou en langage de haut niveau (C)

13/11/2023 2020-2021 55
Automates finis

• Machines à états finis

• Machines à états étendues
• Automate périodique

13/11/2023 2020-2021 56
Machines à états finis

• FSM : Définition Les Machines à états finis (FSM en anglais) sont

utilisées pour décrire des comportements séquentiels liés au
contrôle des parties opératives Cet aspect séquentiel fait intervenir la
notion d’état interne implémentés dans les circuits sous forme de
registres

13/11/2023 2020-2021 57
Représentation d’une FSM

• On représente de manière équivalente une FSM Soit par un

diagramme d’états Soit par une table de vérité correspondant aux
fonctions de transitons et de générations

13/11/2023 2020-2021 58
Modélisaton des FSM
• Utilisation de registres d’états
• Explicite : énumération des états
• Implicite : dépend de la structure du modèle
• Introduction d’une méthode d’initialisation
• Reset synchrone Ou
• asynchrone
• Encodage des états
• La façon de coder les états à un impact direct sur la complexité de la fonction de
transition, donc sur les performances du circuit
• Choix Mealy / Moore
• Moore, plus de maîtrise sur le comportement
• Mealy, plus de flexibilité puisque les sorties peuvent changer au sein d’un même état
• Transitions
• La transition d’un état à l’autre est synchronisée sur signal d’horloge implicite qui n’est
représenté ni dans la table d’états ni dans les diagrammes d’états

13/11/2023 2020-2021 59
Types de machines

• Machine de Moore : Codage des sorties directement dans les états

• Machine de Mealy : Codage des sorties sur les transitions

2020-2021 60
13/11/2023
 FSM de Moore

• Les sorties sont définies uniquement par l’état présent

Inputs Next State

function
Next State Present State
clock Present State
reset register

Output Outputs
function

13/11/2023 2020-2021 61
FSM MEALY
• La sortie est une fonction de l’état présent et des
entrées
Inputs Next State
function
Next State Present State
clock Present State
reset register

Output Outputs
function

13/11/2023 2020-2021 62
Actions: Machines Moore vs Mealy

13/11/2023 2020-2021 63
 Machines à états étendues
• Chaque transition a des conditions/actions
• Pour traverser un arc, la condition doit se réaliser
• Lors de la traversée d’un arc, une action est entreprise
• Il existe un ensemble fini de variables (bornées) associées à la machine
• Les conditions peuvent référencer ces variables
• La condition peut être
• un événement
• Un délai
• Expression sur les variables
• Combinaison des précédentes

13/11/2023 2020-2021 64
 Machines à états étendues
• Actions
• Peut accéder et changer les variables
• Peut être {var: = expression; …}
• Déclencher une tache externe (appeler une fonction)
• Lorsqu’aucune condition n’est vraie
• Ne pas changer d’état
• Lorsque plusieurs conditions sont vraies
• Qu'est-ce qui devrait être fait
• Non déterminisme
• Autoriser la spécification de priorité
• Refuser

13/11/2023 2020-2021 65
Machines à états étendues

13/11/2023 2020-2021 66
Machines à états étendues

3
4

13/11/2023 2020-2021 67
Exercice d’application
❑ Exemple . Proposer un organigramme pour un système qui réalise deux tâches
indépendantes. La première tâche délivre un signal carré de 20 kHz sur le PORTA
en temps réel (période 50 ms). La seconde tâche lit une valeur sur le PORTB,
divise cette valeur par 4, ajoute 12 et délivre le résultat sur le PORTD. La
seconde tâche se répète indéfiniment.

main A
void SysTick_Handler(void){
Clock PORTA = PORTA^0x01; E
Input n from B < } >
PORTB
PORTA = E void main(void){ A
PORTA^1 unsigned long n;
n = (n/4)+12 C while(1){
> n = PORTB; B
n = (n/4)+12; C
PORTD = n; D
Output n to }
PORTD D
}

2020-2021
Exercice d’application
Exemple . Proposer un graphe d’états puis un programme en C pour un système qui
possède un bouton poussoir en entrée et trois LED en sortie. Le bouton permet à
chaque pression d’allumer une LED à la fois.
Les LEDs s’allument dans l’ordre Vert, Orange, Rouge.

Vert

BP Orange

Rouge

2020-2021
Graphe d’état

13/11/2023 2020-2021 70
#define GREEN_PIN 3
#define YELLOW_PIN 4 Code Arduino
#define RED_PIN 5 case orange2:*R=0;*V=0;*O=1;if (btn==1)
#define BTN_PIN 2 etat=rouge1;break;
case rouge1 : *R=1;*V=0;*O=0;if (btn==0)
typedef enum states {repos, etat=rouge2;break; case rouge2 :
vert1,vert2,orange1, orange2, *R=1;*V=0;*O=0;if (btn==1)
rouge1,rouge2,eteints} state_t; etat=eteints;break; case eteints :
state_t etat=repos; *R=0;*V=0;*O=0;if (btn==0)
etat=repos;break; default : etat=repos; } } void
void mae(int btn, int *V, int *O, int *R) sortie(int V, int O, int R)
{ switch(etat) { digitalWrite(GREEN_PIN,V);
{ case repos : *R=0;*V=0;*O=0; digitalWrite(YELLOW_PIN,O);
if(btn==1) etat=vert1;break; digitalWrite(RED_PIN,R);}
void setup(){ pinMode(GREEN_PIN,OUTPUT);
case vert1 : *R=0;*V=1;*O=0;if (btn==0) pinMode(YELLOW_PIN,OUTPUT);
etat=vert2;break; pinMode(RED_PIN,OUTPUT);
pinMode(BTN_PIN,INPUT); }
case vert2 : *R=0;*V=1;*O=0;if (btn==1)
etat=orange1;break; void loop(){ int btn; //valeur du bouton int
Rouge,Vert,Orange;
case orange1:*R=0;*V=0;*O=1;if (btn==0) btn=digitalRead(BTN_PIN);
etat=orange2;break; Serial.print("btn= " +btn);
mae(btn,&Vert, &Orange, &Rouge);
sortie(Vert,Orange, Rouge); }

13/11/2023 2020-2021 71
Automate temporisé
• Les automates temporisés constituent un des
modèle de systèmes réactifs à temps continu
proposé par Alur et Dill en 1991
• Automate fini + ensemble d’horloges à valeurs
réelles
• Qui avancent simultanément,
• Qui peuvent être réinitialisées indépendamment
• Chaque horloge mesure le temps écoulé depuis sa
dernière initialisation
• Mesure d’intervalles entre deux événements
• Dans le modèle de base, pas de dérive d’horloges

13/11/2023 2020-2021 72
Automates Temporisés
• Idée basique
• Machine à états finis étendue
• Ajouter la notion de variables de minuterie
• Les variables de minuterie peuvent être définies explicitement
• Toutes les variables de la minuterie sont périodiquement
incrémentées
• incrémentées chaque k millisecondes
• Ou incréementées en continu
• Les variables de minuterie peuvent être utilisées dans des conditions
• Aucune contrainte de temps ad-hoc

13/11/2023 2020-2021 73
Principe Automates temporisé (1)
• Chaque automate possède un nombre fini de places (états).
• Les transitions entre états sont instantanées.
• Dans chaque état, le temps peut s’écouler:
• à tout instant, la valeur d’une horloge x est le temps écoulé depuis la
dernière mise à 0 de x.

13/11/2023 2020-2021 74
Principe Automates temporisé (2)
• Les transitions entre états sont conditionnées par des contraintes sur
les horloges, appelés gardes, et peuvent remettre certaines horloges
à 0.
• A chaque place est associée une contrainte sur les horloges, appelée
invariant.
• Les transitions sont
1. soit des transitions de temps,
2. ou des transitions d’action.

13/11/2023 2020-2021 75
 Modélisation d’un train / barrière
Train:

approach Near
Far
x := 0 x ≤5

exit x > 2,in

Af ter In
x ≤5 out x ≤5

– p.1
Exemple 1: Train || barrière || contrôleur
Barrière:

lower t1
t0
y := 0 y≤1

y ≥ 1,up down

t3 y := 0
t2
y≤ 2 raise

– p.1
Contrôleur:

raise approach,
u2 z:=0 u1
z ≤1 u0 z ≤1

exit, z := 0 z = 1,lower

– p.1
Exemple 2
Exemple: une zone de traitement, avec deux robots
et des boites sur un tapis roulant.

Tapis convoyeur

point d’inspection

D−Robot G−Robot

station de traitement

Figure 1: Une usine simple.

– p.2
 D-robot
x := 0 s-ready d-pick
x := 0 D-Pick
5 ≤x ≤6 1 ≤x ≤2
D-Wait
d-turn-l x := 0
x ≤2
D-Turn-L D-Turn-R

x ≤6 x ≤6
D-Put
x := 0 d-turn-r
1 ≤x ≤2 5 ≤x ≤6
x ≤2
d-put x := 0

– p.2
 G-robot g-picked
middle 3 ≤y ≤8
G-Pick G-Turn-R
y := 0 y := 0
G-Inspect
y ≤8 y ≤ 10

g-turned-l g-turned-r
8 ≤ y ≤ 10 6 ≤ y ≤ 10
y := 0 y := 0
G-Put
G-Turn=L
G-Wait
y := 0 s-empty
y ≤ 10 y ≤2
1 ≤y ≤2 y := 0
g-put

– p.2
 Zone de traitement
g-put
z := 0 S-Busy
-empty S-Empty
z ≤ 10

z := 0 s-busy
d-pick 8 ≤ z ≤ 10
z := 0
s-ready S-Ready

– p.2
 Boîte b-mov
133 ≤ b ≤ 134 20 ≤ b ≤ 21
B-Mov b := 0 B-Inspect b-fall
B-Fall
b ≤ 134 b ≤ 21
g-pick
d-put
b := 0 middle

B-on-D B-on-S B-on-G

d-pick g-put

– p.2
Autre exemple : bouton de souris

13/11/2023 2020-2021 84
 Arduino
• Une plate-forme matérielle open-source
basée sur un microcontrôleur Atmel AVR 8
bits et un IDE basé sur C ++
•
Plus de 300 000 cartes ont été fabriquées
•
Arduino Due est basé sur un ARM Cortex
32 bits
Carte Arduino type
Langage Arduino

• Le langage Arduino est basé sur le C/C++.

• Le langage de programmation d'Arduino est en effet une
implémentation de Wiring (une plateforme open source
similaire de physical computing qui proposait elle-même une
bibliothèque appelée Wiring qui simplifie les opérations
d'entrée/sortie).
• Un programme Arduino est aussi appelé un sketch.

13/11/2023 2020-2021 87
Arduino le code minimal
• Le code minimal Avec Arduino, nous devons utiliser
un code minimal lorsque l'on crée un programme.
Ce code permet de diviser le programme que nous
allons créer en deux grosses parties.
void setup() //fonction d'initialisation de la carte
{ //contenu de l'initialisation }
void loop() //fonction principale qui se répète (s’exécute) à l'infini
{ //contenu du programme }

13/11/2023 2020-2021 88
Exécution du code Arduino
• Langage proche du C.
• ➢ Programme structuré :
• ➢ Une section déclaration
• ➢ une section « setup » 1 seule exécution après RàZ ;
• ➢ une section « loop » exécutée indéfiniment en boucle
• Finalement similaire au code suivant sur PC
int main() Setup
{ setup();
while(true) loop();
}
Loop

13/11/2023 2020-2021 89
Arduino types de variables

13/11/2023 2020-2021 90
Arduino type enum
Declaration
enum ternary {
unknown,
true,
false
};

Création de variable et utilisation

ternary variable = unknown;
if (variable==unknown){
//do code
variable = (condition ? true : false);
}

13/11/2023 2020-2021 91
Arduino utilisation de variables
• Déclaration
• int i;
• Boolean btn
• int y,x=5;
• float t=1.54f;

• Utilisation
• y= 4*x;
• btn=digitalRead(2);

13/11/2023 2020-2021 92
Arduino Listes et tableaux

• int x[4]; //liste de 4 éléments

• Byte b[8]={7,16,110,75,60,0,0,78};
• int releves [20,3]; //tableau de 20 lignes et 3 colonnes
• Exemples
• if (b[1]==16) Serial.println(’’Trouvé’’);
• « «

13/11/2023 2020-2021 93
 Instruction Conditionelle

if (someCondition) {
// do stuff if the condition is true
} else {
// do stuff if the condition is false
modelect.wordpress.com }

13/11/2023 2020-2021 94
 Conditional Statement int printMessage = 1;
void setup()
{ Serial.begin(9600);
int printMessage = 1; }
void setup() void loop()
{ Serial.begin(9600); {
}
if (printMessage == 1) {
Serial.println("Message");
void loop()
printMessage= 0;
{
}
if (printMessage == 1) {
else {
Serial.println("Message");
Serial.println("NO Message");
printMessage= 0;
printMessage= 1;
}
}
} 13/11/2023
}
2020-2021 95
 while Loop

while(expression){
statement(s);
}

Example
int var = 0;
while (var < 200) {
// do something repetitive 200 times
var = var + 1;
}

13/11/2023 2020-2021 96
while Loop
void setup()
{ Serial.begin(9600);
int count = 0;
while (count < 5) {
Serial.println("Hello world!");
count = count +1;
}
}

void loop()
{
}
13/11/2023 2020-2021 97
 for loop

13/11/2023 2020-2021 98
for Loop
void setup()
{
Serial.begin(9600);
for (int count = 0; count < 5; count++) {
Serial.println("Hello world!");
}
}

void loop()
{
}

13/11/2023 2020-2021 99
 switch - case
void setup() {
// initialize serial communication: switch (inByte) {
Serial.begin(9600); case 'a':
// initialize the LED pins: digitalWrite(2, HIGH);
for (int thisPin = 2; thisPin < 7; thisPin++) { break;
pinMode(thisPin, OUTPUT); case 'b': digitalWrite(3, HIGH);
} break;
} case 'c':
digitalWrite(4, HIGH);
void loop() { break;
// read the sensor: case 'd':
if (Serial.available() > 0) { digitalWrite(5, HIGH);
int inByte = Serial.read(); break;
// do something different depending on the case 'e':
character received. digitalWrite(6, HIGH);
// The switch statement expects single number break;
values for each case; in this default:
// turn all the LEDs off:
for (int thisPin = 2; thisPin < 7; thisPin++) {
digitalWrite(thisPin, LOW);
}
}
}
}
13/11/2023 2020-2021 100
Modèle Proteus Arduino +Terminal virtuel
+Bargraph

R8
330

13/11/2023 2020-2021 101

Functions
• loop() and setup() sont des fonctions
• Vous pouvez créer vos propres fonctions

void setup() {
}
void loop() {
}

Both setup() and loop()

have no parameters and
return no values

13/11/2023 arduino.cc 2020-2021 102

Functions: Example 1

13/11/2023 2020-2021 103

learn.parallax.com
Functions: Example 2

13/11/2023 2020-2021 104

learn.parallax.com
Digital Input (Utilisation des boutons et
interruteurs)

Bouton poussoir

www.ladyada.net/

Create the circuit above and then run File -> Examples ->
Digital -> Button

13/11/2023 2020-2021 105

L’interface matérielle du microcontrôleur

Intéressons-nous de plus près à l'ATmega 328P-PU :

10
L’interface matérielle du Microcontroleur : Arduino et AVR

L’interface matérielle du microcontrôleur et correspondance avec la carte UNO

:

11
L’interface matérielle du Microcontroleur : Arduino et AVR

Après analyse et simplification, cela donne :

11
Résumé des la connectique ATMEGA 328P-PU

● 1 alimentation pour les E/S numérique;

● 9 entrées / sorties numériques;

● 1 alimentation + référence pour les E/S analogique;

● 6 entrées / sorties analogiques;

● 1 entrée + 1 sortie oscillateur (20 Mhz);

● 1 ''port'' série (Universal Asynchronous Receiver Transmitter);

● 3 lignes pour mettre à jour le micrologiciel (BIOS);

12
● 1 ligne pour le RESET.
 Système Arduino AVR ATMEGA 328

13/11/2023 2020-2021 110

LES E/S AVEC ARDUINO

• Courant de sortie des broches, PULL-UP

• Registres d’accès aux broches
• Exemples d’instructions

13/11/2023 2020-2021 111

Caractéristiques Electriques des E/S Arduino

• Note : les broches analogiques peuvent être utilisées en tant que

broches numériques : elles sont numérotées en tant que broches
numériques de 14 à 19.

13/11/2023 2020-2021 112

IDE Arduino
Premier programme et communication série

todbot.com/blog/bionicarduino
13/11/2023 2020-2021 114
13/11/2023 2020-2021 115
todbot.com/blog/bionicarduino
Communication série

• Compiling turns your program into

binary data (ones and zeros)
• Uploading sends the bits through
USB cable to the Arduino
• The two LEDs near the USB
connector blink when data is
transmitted
• RX blinks when the Arduino is
receiving data
• TX blinks when the Arduino is
transmitting data
13/11/2023 2020-2021 116
todbot.com/blog/bionicarduino
Premier programme
/*
* Hello World!
* It shows how to send data to the computer
*/
void setup() // run once, when the sketch starts
{
Serial.begin(9600); // set up Serial library at 9600 bps
Serial.println("Hello world!"); // prints hello with a line break
}
void loop() // run over and over again
{ // do nothing!
}
13/11/2023 2020-2021 117
Ouvrir le moniteur série et télécharger le
programme dans la carte

13/11/2023 2020-2021 118

 Modifier le programme (chaque puce
indiqe une modif différente)
• Déplacer Serial.println("Hello world!"); dans loop()
• Ajouter la fonction setup():
int a = 5;
int b = 10;
Serial.print("a + b = ");
Serial.println(a + b);
• Remplacer le code ci-dessus avec ce qui suit :

13/11/2023 2020-2021 119

 Fonctions Importantes

Serial.println(value);
•
– Affiche « value » sur le moniteur série et
insère un retour chariot
• pinMode(pin, mode);
– Configure une broche E/S en lecture (INPUT)
écriture (OUTPUT)
•
digitalRead(pin);
• digitalWrite(pin, value);
–
Principales fonctions Arduino
• ENTRÉES/SORTIES • ENTRÉES/SORTIES
NUMÉRIQUES AVANCÉES
• pinMode(broche, mode) • tone()
• digitalWrite(broche, valeur) • noTone()
• int digitalRead(broche)
• shiftOut(broche,
• ENTRÉES ANALOGIQUES BrocheHorloge, OrdreBit,
• int analogRead(broche) valeur)
• SORTIES "ANALOGIQUES" • unsigned long
(GÉNÉRATION pulseIn(broche, valeur)
D'IMPULSION)
• analogWrite(broche, valeur)
- PWM
13/11/2023 2020-2021 121
Principales fonctions Arduino
• TEMPS
• unsigned long millis()
• unsigned long micros() • NOMBRES RANDOMISÉS
• delay(ms) (HASARD)
• delayMicroseconds(us) • randomSeed(seed)
• long random(max)
• INTERRUPTIONS EXTERNES • long random(min, max)
• attachInterrupt(interruption,
fonction, mode) • COMMUNICATION
• detachInterrupt(interruption) • Serial
• INTERRUPTIONS
• interrupts()
• noInterrupts()

13/11/2023 2020-2021 122

Principales fonctions Arduino
• MATH • tan(rad)
• min(x, y) • degrees(rad)
• max(x, y) • radians(deg)
• abs(x) • PI
• constrain(x, a, b)
• map(valeur, fromLow, fromHigh,
toLow, toHigh)
• pow(base, exposant)
• sq(x)
• sqrt(x)
• TRIGONOMÉTRIE
• sin(rad)
• cos(rad)

13/11/2023 2020-2021 123

Utilisation de millis()
• La fonction millis() renvoie le nombre de
milliseconde écoulées depuis le démarrage de la
carte Arduino. Elle permet de mesurer une durée
écoulée //programme tempo pour utiliser millis()
• Exempe unsigned long t1,t2;
boolean tempo(unsigned int duree){
• t2=millis();
if ((t2-t1)>=duree) {t1=t2;
return true;}
return false;}
void setup() { Serial.begin(9600);
t1=millis();//initialiser la tempo }
void loop() { int x;
if (tempo(1000)) x++; //incrémente x toutes les 1000 ms
Serial.println("nombre de secondes =" + String(x)); }

13/11/2023 2020-2021 124

Utilisation des LEDs
void setup()
{
pinMode(6, OUTPUT); //configure pin 6 as output
}
// blink an LED once
void blink1()
{
digitalWrite(6,HIGH); // turn the LED on
delay(500); // wait 500 milliseconds
digitalWrite(6,LOW); // turn the LED off
delay(500); // wait 500 milliseconds
}
 Création de boucle infinie
void loop() //blink a LED repeatedly
{
digitalWrite(77,HIGH); // turn the
LED on
delay(500); // wait 500 milliseconds
digitalWrite(77,LOW); // turn the LED
off
delay(500); // wait 500 milliseconds
}
Utilisation des interrupteurs et des boutons
poussoirs
const int inputPin = 2; // choose the input pin
void setup() {
pinMode(inputPin, INPUT); // declare pushbutton as input
}
void loop(){
int val = digitalRead(inputPin); // read input value
}
 Lecture des entrées analogiques
et mise à l'échelle

const int potPin = 0; // select the input pin for the

potentiometer
void loop() {
int val; // The value coming from the sensor
float percent; // The mapped value
val = analogRead(potPin); // read the voltage on the pot
(val ranges from 0 to 1023)

percent = map(val,0,1023,0,100); // percent will range

from 0 to 100.
Création d'un barregraph à partir de LED
const int NoLEDs = 8;
const int ledPins[] = { 3, 4, 5, 6, 7, 8, 9, 10};
const int analogInPin = 0; // Analog input pin const int
wait = 30;
const boolean LED_ON = HIGH;
const boolean LED_OFF = LOW;
int sensorValue = 0; // value read from the sensor
int ledLevel = 0; // sensor value converted into LED
'bars'
void setup() {
for (int i = 0; i < NoLEDs; i++)
{
pinMode(ledPins[i], OUTPUT); // make all the LED pins
outputs
}
}
Création d'un barregraph à partir de LED
void loop() {
sensorValue = analogRead(analogInPin); // read the analog
in value
ledLevel = map(sensorValue, 0, 1023, 0, NoLEDs); // map to
the number of LEDs
for (int i = 0; i < NoLEDs; i++)
{
if (i < ledLevel ) {
digitalWrite(ledPins[i],LED_ON); // turn on pins less
} than the level
else {
digitalWrite(ledPins[i], LED_OFF);}
} // turn off pins higher
} than the level:
 Firmware Arduino Avr
const int ledPins[] = { 2,3, 4, 5, 6, 7, 8, 9}; void loop(){
int NoLEDs = 8; // read the analog in value
sensorValue = analogRead(analogInPin);
const int analogInPin = 0; // Analog input // map to the number of the LEDs level:
pin const ledLevel = map(sensorValue, 0, 1023, 0,
NoLEDs);
int wait =30;
const boolean LED_ON = HIGH; for (int i = 0; i < NoLEDs; i++)
const boolean LED_OFF = LOW; {
int sensorValue = 0; // value read from if (i < ledLevel ) {
the sensor // turn on pins less than the level
int ledLevel=0 ; // sensor value digitalWrite(ledPins[i],LED_ON);
converted into LED 'bars' }
else {// turn off pins higher than
void setup(){ digitalWrite(ledPins[i], LED_OFF);
for (int i = 0; i < NoLEDs; i++) }}
{// make all the LED outputs }
pinMode(ledPins[i], OUTPUT);
} 13/11/2023 2020-2021 131
}
 Utilisation de nombre aléatoire
• exemple

long randNumber;
void setup() { Serial.begin(9600);
// si la broche d'entrée analogique 0 n'est pas connectée,
//un bruit analogique aléatoire entraînera lors de l'appel à randomSeed ()
//pour générer des nombres de départ différents à chaque exécution de du
programme.
randomSeed(analogRead(0)); }
void loop() {
// print a random number from 0 to 299
randNumber = random(300);
Serial.println(randNumber); // print a random number from 10 to 19
randNumber = random(10, 20); Serial.println(randNumber);
delay(50); }
13/11/2023 2020-2021 132
Exercice

• Proposer une application qui • Fonctions à implémenter

contrôle un bargraph soit du • Check_serial()
port serie, soit d’un capteur
(potentiomètre) • Check_pot()
• Update_bargraph()

13/11/2023 2020-2021 133

Solution exercice les fonctions

void check_serial()
if (serial.available()<>0)
sensorValue=serial.Read();
ledLevel=map(sensorValue,0,255,0,NoLEDs);
Ser_FLAG=1;
}}

13/11/2023 2020-2021 134

Solution exercice les fonctions
void check_pot(){
sensorValue=analogRead(analogInPin);
ledLevel=map(sensorValue,0,1023,0,NoLEDs);
If (oldLevel!=ledLevel) {
pot_FLAG=1;
oldLevel=ledLevel;
}
}

13/11/2023 2020-2021 135

Solution exercice les fonctions
void update_baregraph(){
If(ser_FLAG==1||(pot_FLAG==1){
for (int i = 0; i < NoLEDs; i++)
{
if (i < ledLevel )
{digitalWrite(ledPins[i],LED_ON);
}
else {
digitalWrite(ledPins[i],LED_OFF);
}
ser_FLAG=0;pot_FLAG=0;}
}

13/11/2023 2020-2021 136

 Solution exercice les fonctions
Barregraph commandé par UART et Potentiomètre
const int NoLEDs = 8;
const int ledPins[] = { 3, 4, 5, 6, 7, 8, 9, 10};
const int analogInPin = 0; // Analog input pin
Const int ATTENTE = 30;
const boolean LED_ON = HIGH;
const boolean LED_OFF = LOW;
int sensorValue =0; // value read from the sensor
int ledLevel=0; // sensor value converted into LED ‘bars’
int oldLevel=0; // pour la MAJ du potentiomètre
int ser_FLAG=0,pot_FLAG=0; // traquer la source de
l’évènement
void setup(){
for (int i =0; i< NoLEDs; i++)
{pinMode(ledPins[i], OUTPUT); // make all the LED outputs
Serial.begin(9600);

}
}
Solution dans Proteus 8.6

11/13/2023 138
Les fonctions
void loop(){

Check_serial();
If (ser_FLAG!=1)
check_pot();
Update_bargraph();
delay(ATTENTE);
}

13/11/2023 2020-2021 139

Mesure de la temperature
const int inPin = 0; // analog pin
void setup()
{
Serial.begin(9600);

}
void
loop(){
int value = analogRead(inPin);
float millivolts = (value / 1024.0) * 5000; //5.0V analog input
float celsius = millivolts / 10; // sensor output Celsius is 10mV per degree
delay(1000);
Serial.println("Temperarure="+String(celsius)+ " Celcius");

}
Lecture des données à partir d’Arduino
void setup()
{
Serial.begin(9600);
}
void serialtest()
{
int i;
for(i=0; i<10; i++)
Serial.println(i);
}
Envoie des données du PC vers programme Arduino

int incomingByte = 0;
void setup() {
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}
void loop() {
if (Serial.available() > 0) {
incomingByte = Serial.read(); // read the incoming byte:
Serial.print(" I received:");
Serial.println(incomingByte);
}
}
Connecter un LCD
 Utiliser LCDs
#include <LiquidCrystal.h> // include the library code
//constants for the number of rows and columns in the LCD
const int numRows = 2;
const int numCols = 16;
// initialize the library with the numbers of the interface
pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
lcd.begin(numCols, numRows);
lcd.print("hello, world!"); // Print a message to the LCD.
}
Utiliser le détecteur de mouvement PIR
 Utiliser le détecteur de mouvement PIR
const int ledPin = 77; // pin for the LED
const int inputPin = 2; // input pin (for the PIR sensor)
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inputPin, INPUT); // declare pushbutton as input
}
void loop(){
int val = digitalRead(inputPin); // read input value
if (val == HIGH) // check if the input is HIGH
{
digitalWrite(ledPin, HIGH); // turn LED on if motion
detected
delay(500);
digitalWrite(ledPin, LOW); // turn LED off
}
}
 Utiliser le capteur à ultrason
• L'impulsion sonore «ping» est générée lorsque le niveau de trigPin
devient ÉLEVÉ pendant dix microsecondes.
• Le capteur générera alors une impulsion qui se termine lorsque le son
revient.
• La largeur de l'impulsion est proportionnelle à la distance parcourue par
le son
• La vitesse du son est de 340 mètres par seconde, soit 29 microsecondes
par centimètre. La formule pour la distance du trajet aller-retour est la
suivante: Aller-retour = microsecondes / 29
Schéma de câblage capteur ultra-son HC-SR04
• Version 4 broches

13/11/2023 2020-2021 148

Programme Arduino capteur ultrason
const int trigPin = 5;
Const int echoPin = 7; pin connected to LED
const int ledPin = 13; //
void setup()
{ Serial.begin(9600);
pinMode(ledPin, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}
void loop()
{
int cm = ping(trigPin,echoPin) ;
Serial.println(cm);
digitalWrite(ledPin, HIGH);
delay(cm * 10 ); // chaque cm ajoute un délai de 10 ms

digitalWrite(ledPin, LOW);
delay( cm * 10);
}
Utiliser le capteur à ultrason
int ping(int trigP, int echoP)
{
long duration, cm;
digitalWrite(trigP,LOW);
delayMicroseconds(2);
digitalWrite(trigP,HIGH);
delayMicroseconds(10);
digitalWrite(trigP,LOW);
duration = pulseIn(echoP, HIGH);
// convert the time into a distance
cm = microsecondsToCentimeters(duration);
return cm ;
}
long microsecondsToCentimeters(long microseconds)
{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return microseconds / 29 / 2;
}
 Sortie Audio
tone(speakerPin, frequency, duration); // play the
tone
delay(duration); //wait for the tone to finish
 Exemple
• Ecrivez un programme qui joue une note
A (440Hz) pendant 1 seconde lorsqu'un
capteur de mouvement détecte un
mouvement.
Les interruptions
• Introduction
• Définitions
• Vecteurs d’interruption
• principe
• Sources d’interruption
• Utilisation
• Traitant d’Interruption (ISR)
• Communication entre IT et programme principal

13/11/2023 2020-2021 153

Introduction
• Une interruption, c’est un événement externe ou interne au système qui Interrompt le
déroulement du programme En cours et oblige le système à exécuter une routine
particulière.
• Événement externe:
• Changement sur une entrée spécifique appelée entrée d’interruption. (tout μC en
a au moins une)
• Changement sur un bit de port. (sur le Arduino Uno, tous les ports A0 à A5, D0 à
D13 peuvent déclencher une interruption.)
• Événement interne:
• Division par zero
• Adresse mémoire incorrect
• Évènements sur les périphériques internes
• Fin de conversion A/N
• Événement sur le bus série (fin d’émission, réception …)
• Événement I²C ou SPI
• Débordement Timer

13/11/2023 2020-2021 154

I Les interruptions : définitions

• Interruptions : évènements qui surviennent de façon asynchrones.

Elles sont commandées par le matériel (interruption externe) ou par
le système
• (interruption système ou exception). Aucune relation avec les
instructions en cours d'exécution.
• Exceptions : elles sont déclenchées par des "accidents" dans
l'exécution du programme : débordement arithmétique, erreur de
bus, tentative d'utilisation d'instructions réservées, erreur
d'adressage, défaut de cache, défaut de page...

13/11/2023 2020-2021 155

 I-1 Principe des Interruptions

• Une interruption est un événement interne ou

externe au microcontrôleur qui va provoquer:
• Une suspension du programme principal en cours d’exécution

• L’exécution d’un sous programme dit d’interruption

• Interrupt Service Routine (ISR)

• La reprise – à l’endroit où il a été interrompu – de l’exécution du

programme principal lorsque le sous programme d’interruption est
terminé

13/11/2023 2020-2021 156

 I-2 Vecteurs d’interuptions
• Un microcontrôleur possède de
nombreux vecteurs d'interruption,
qui sont rassemblés dans son
tableau des vecteurs d’interruption.
Normalement seule une partie de
ces vecteurs est utilisée par votre
programme (Timer, interface série
et peut-être encore deux ou trois
ports IRQ) alors que la grande partie
restante ne l’est pas.

13/11/2023 2020-2021 157

I-2 Vecteurs d’interuptions
• Vecteurs pour Arduino UNO

13/11/2023 2020-2021 158

I-2• Vecteurs d’interuptions
Vecteurs pour Arduino (suite)

13/11/2023 2020-2021 159

 I-3 Intérêt des Interruptions

• Permet de lancer une tâche sur un périphérique

(externe ou interne) et de récupérer le résultat sans
avoir à attendre et bloquer le reste du programme

• Pas besoin de boucles de scrutation (polling) qui bloque

le programme

• Permet de consacrer le temps d’exécution du processeur

à d’autres tâches plus utiles

13/11/2023 2020-2021 160

 I-4 Déroulement dans le µP
• Sauvegarde des registres du µP dans la pile mémoire
• Notamment le registre PC (Program Counter)
• Sauvegarde de contexte

• Le PC va indiquer l’adresse de début du sous programme

d’interruption

• Exécution du sous programme d’interruption

• Restauration des registres

• Récupération de contexte
• Le registre PC indique l’adresse de l’instruction où s’est arrêté le
programme principal

• Reprise du programme principal

13/11/2023 2020-2021 161

Retenons

• Les interruptions sont un moyen pour un microcontrôleur d’arrêter

temporairement ce qu’il fait pour gérer une autre tâche.
• Le programme en cours d’exécution est suspendu, une routine de
service d’interruption (ISR) est exécutée, puis votre programme
continue, le cas échéant.

13/11/2023 2020-2021 162

 II Sources d’interruptions
• Il y a 26 interruptions différentes sur un Arduino Uno
• 1 réinitialiser
• 2 demande d’interruption externe 0 (broche D2)
• 3 demande d'interruption externe 1 (broche D3)
• 4 Demande d'interruption de changement sur broches 0 (broches D8 à D13)
• 5 Demande d'interruption de changement sur broches 1 (broches A0 à A5)
• 6 Demande d'interruption de changement sur broches 2 (broches D0 à D7)
• 7 interruption du délai d'attente du chien de garde(WatchDog Timer)
• 8 Minuterie / Compteur2 Comparer le match A
• …
• 18 Transfert série SPI terminé
• 19 USART Rx Complete
• …
• 25 Interface série à 2 fils (I2C)
• …

13/11/2023 2020-2021 163

II-1 Utilisation des interruptions
• Les interruptions peuvent détecter de brèves
impulsions sur les broches d’entrée. La scrutation
peut manquer l'impulsion pendant que vous
effectuez d'autres calculs.
• Les interruptions sont utiles pour réveiller un
processeur en veille.
• Les interruptions peuvent être générées à un
intervalle fixe pour un traitement répétitif.
• Et plus …

13/11/2023 2020-2021 164

Exemple 1 (sans interruption)

const byte LED = 13, SW = 2;

void setup() {
pinMode(LED, OUTPUT);
pinMode(SW, INPUT_PULLUP);
}

void handleSW() {
digitalWrite(LED, digitalRead(SW));
}

void loop() {
handleSW();
}

13/11/2023 2020-2021 165

Montage sous Proteus

13/11/2023 2020-2021 166

Exemple 2 (sans interruption)
const byte LED = 3, SW void setup() {
= 2; pinMode(LED,
OUTPUT);
void handleSW() { pinMode(SW,
digitalWrite(LED, INPUT_PULLUP);
digitalRead(SW)); }
}
void loop() {
void handleSW();
handleOtherStuff() {
delay(250); handleOtherStuff();
} }

13/11/2023 2020-2021 167

 Exemple 3 (avec interruption)
const byte LED = 13, SW OUTPUT);
= 2; pinMode(SW,
INPUT_PULLUP);
void handleSW() { // ISR
digitalWrite(LED, attachInterrupt(INT0,
digitalRead(SW)); handleSW, CHANGE);
} }

void handleOtherStuff() void loop() {

{ // handleSW(); 
delay(250); commenté
} handleOtherStuff();
void setup() { }
pinMode(LED,

13/11/2023 2020-2021 168

 Exemple 3i (avec interruption)
const byte LED = 13, SW = 2; pinMode(SW,
INPUT_PULLUP);
void handleSW() { // ISR attachInterrupt(INT0,
handleSW, CHANGE);
int press;
}
press= digitalRead(SW);
If (press==1)
attachInterrupt(INT0, void loop() {
handleSW2, FALLING); // handleSW(); 
commenté
} handleOtherStuff();
}
void handleOtherStuff() {
delay(250);
}

void setup() {
pinMode(LED,
13/11/2023
OUTPUT); 2020-2021 169
II-2 Traitant d’interruption (ISR)

• Les routines de traitement d'interruption doivent être courtes. Les

interruptions étant désactivées lors de l'appel de l'ISR, les autres
interruptions sont reportées.
• Ne pas appeler millis () ou delay () ou Serial ou…
• Cette routine est correct :
void myISR () {
count++;
}

13/11/2023 2020-2021 170

Retenons

• AVR ATMega328p a 2 interruptions externes

• INT0 (sur la broche Arduino 2) et INT1 (sur la broche
Arduino 3).
• Utilisez attachInterrupt (int #, nom ISR, mode) pour
attacher un ISR à une interruption externe.
• Assurez-vous de fournir une définition de fonction
pour l’ISR
• Choisissez le mode LOW, CHANGE, RISING, FALLING

13/11/2023 2020-2021 171

Communication entre ISR et Programme
principal
Nous voulons quelques fois savoir ce qui se passe lors de l’appel d’un
ISR. Comment partageons-nous cette information?

13/11/2023 2020-2021 172

 Exemple 4
const byte LED = 13, SW = 2;

volatile unsigned char count = 0;

void handleSW () {
digitalWrite(LED, digitalRead(SW));
count++;
}

unsigned char lastCount = -1;

void handleOtherStuff() {
if (count != lastCount) { void setup () {
Serial.print("Count "); //Start up the serial port
Serial.println(count); Serial.begin(9600);
lastCount = count; Serial.println(F(“Example4"));
}
} pinMode (LED, OUTPUT);
pinMode (SW, INPUT_PULLUP);
void loop () { attachInterrupt(INT0,
handleOtherStuff(); handleSW, CHANGE);
} }

13/11/2023 2020-2021 173

13/11/2023 2020-2021 174
 III Le partage des données
• Une interruption peut arriver à tout moment.

• Si vous partagez une valeur multi-octets (par exemple, short int) entre un ISR
et votre code, vous devez prendre des précautions supplémentaires.
volatile short count;
if (count == 256) …

1fa: 80 91 10 01 lds r24, 0x0110 ; count lower

1fe: 90 91 11 01 lds r25, 0x0111 ; count upper
202: 80 50 subi r24, 0x00
204: 91 40 sbci r25, 0x01
206: 69 f5 brne .+90

13/11/2023 2020-2021 175

Le partage des données (suite)

// Désactiver les interruptions et copier

noInterrupts();
short int myCount = count;
interrupts();
if (myCount == 256) …

1fa: f8 94 cli
1fc: 80 91 10 01 lds r24, 0x0110
200: 90 91 11 01 lds r25, 0x0111
204: 78 94 sei
206: 80 50 subi r24, 0x00
208: 91 40 sbci r25, 0x01
20a: 69 f5 brne .+90

13/11/2023 2020-2021 176

Retenons
• Nous devons prendre des précautions lors du partage de données entre
une ISR et le code principal
• Si le code principal utilise une variable qui est définie dans l’ISR, assurez-
vous que cette variable est volatile
• interrupts (); et noInterrupts (); active/désactive toutes les interruptions
• detachInterrupt (int #) est également disponible pour désactiver une ISR

13/11/2023 2020-2021 177

IV-1 Interruption lors du changement sur
broche
• La broche 2 pour INT0
• La broche 3 pour INT1
• Que se passe t’il pour les broches 0,1,4,5,6,…
• Les interruptions lors d’un changement sur une broche peuvent
survenir sur toutes les broches

13/11/2023 2020-2021 178

Pin change interrupts

• Sur les cartes Arduino Uno, ces interruptions peuvent être activées
depuis n'importe quel broche, et même la totalité des 20 broches de
l'Arduino (A0 à A5 et D0 à D13). Elles sont regroupées sous trois
vecteurs d'interruption PCINT0, PCINT1 et PCINT2 pour l'intégralité
des 20 broches.

13/11/2023 2020-2021 179

Pin change interrupts

• Pin Change Interrupt Request 0 (connecteurs D8 à D13)

(PCINT0_vect)
• Pin Change Interrupt Request 1 (connecteurs A0 à A5) (PCINT1_vect)
• Pin Change Interrupt Request 2 (connecteurs D0 à D7) (PCINT2_vect)
• Utiliser la librairie PinChangeInt.h

13/11/2023 2020-2021 180

Exemple 5 avec PinChangeInt.h
#include <PinChangeInterrupt.h>
const byte LED = 13, SW = 5;

volatile unsigned char count = 0;

void handleSW () {
digitalWrite(LED, digitalRead(SW)); count++;
}
void setup () {
unsigned char lastCount = -1;
void handleOtherStuff() { //Start up the serial port
if (count != lastCount) { Serial.begin(9600);
Serial.print("Count "); Serial.println(F(“Example4"));
Serial.println(count);
lastCount = count;
} pinMode (LED, OUTPUT);
} pinMode (SW, INPUT_PULLUP);
attachPCINT(digitalPinToPCINT(SW),
void loop () { handleSW, CHANGE);
handleOtherStuff();
}
}

attachPCINT(digitalPinToPCINT(SW), handleSW, CHANGE);

13/11/2023 2020-2021 181

Sans Librairie

• La routine d'interruption devra être définie avec la macro ISR et le nom

du vecteur d'interruption souhaité, comme ISR(PCINT0_vect)
ISR(PCINT0_vect) .
• les macros sei() et cli() pour activer et désactiver les interruptions

13/11/2023 2020-2021 182

 Nom des sources d'interruption dans un
programme Arduino (pré-définis)
• #define INT0_vect _VECTOR(1) /* External Interrupt Request 0 */
• #define INT1_vect _VECTOR(2) /* External Interrupt Request 1 */
• #define PCINT0_vect _VECTOR(3) /* Pin Change Interrupt Request 0 */
• #define PCINT1_vect _VECTOR(4) /* Pin Change Interrupt Request 1 */
• #define PCINT2_vect _VECTOR(5) /* Pin Change Interrupt Request 2 */
• #define WDT_vect _VECTOR(6) /* Watchdog Time-out Interrupt */
• #define TIMER2_COMPA_vect _VECTOR(7) /* Timer/Counter2 Compare Match A */
• #define TIMER2_COMPB_vect _VECTOR(8) /* Timer/Counter2 Compare Match A */
• #define TIMER2_OVF_vect _VECTOR(9) /* Timer/Counter2 Overflow */
• #define TIMER1_CAPT_vect _VECTOR(10) /* Timer/Counter1 Capture Event */ #define
TIMER1_COMPA_vect _VECTOR(11) /* Timer/Counter1 Compare Match A */
• #define TIMER1_COMPB_vect _VECTOR(12) /* Timer/Counter1 Compare Match B */

13/11/2023 2020-2021 183

 Nom des sources d'interruption dans un
programme Arduino (pré-définis)
• #define TIMER1_COMPB_vect _VECTOR(12) /* Timer/Counter1 Compare Match B */
• #define TIMER1_OVF_vect _VECTOR(13) /* Timer/Counter1 Overflow */
• #define TIMER0_COMPA_vect _VECTOR(14) /* TimerCounter0 Compare Match A */
• #define TIMER0_COMPB_vect _VECTOR(15) /* TimerCounter0 Compare Match B */
• #define TIMER0_OVF_vect _VECTOR(16) /* Timer/Couner0 Overflow */
• #define SPI_STC_vect _VECTOR(17) /* SPI Serial Transfer Complete */
• #define USART_RX_vect _VECTOR(18) /* USART Rx Complete */
• #define USART_UDRE_vect _VECTOR(19) /* USART, Data Register Empty */
• #define USART_TX_vect _VECTOR(20) /* USART Tx Complete */
• #define ADC_vect _VECTOR(21) /* ADC Conversion Complete */
• #define EE_READY_vect _VECTOR(22) /* EEPROM Ready */
• #define ANALOG_COMP_vect _VECTOR(23) /* Analog Comparator */
• #define TWI_vect _VECTOR(24) /* Two-wire Serial Interface */

13/11/2023 2020-2021 184

Retenons

• Nous pouvons surveiller n'importe quelle broche et la faire générer

une interruption
• Différentes broches peuvent avoir différents ISR

13/11/2023 2020-2021 185

Exemple 6
#include <avr/sleep.h>
#include <PinChangeInterrupt.h>

void wake() { // ISR

sleep_disable(); // first thing after waking from sleep:
detachPCINT(digitalPinToPCINT(SW)); // stop LOW interrupt
}

void sleepNow()
{
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
noInterrupts(); // stop interrupts
sleep_enable(); // enables sleep bit in MCUCR
attachPCINT(digitalPinToPCINT(SW), wake, LOW);
interrupts(); // allow interrupts
sleep_cpu(); // here the device is put to sleep
}

13/11/2023 2020-2021 186

Exercice
• Proposer un programme entièrement fonctionnel utilisant
les interruptions.
• Tandis qu’il est éveillé, le voyant LED clignote à environ 2 Hz.
Comme auparavant, handleSW est l'ISR pour une
interruption.
• Lorsque nous appuyons sur le bouton poussoir, la variable
count est incrémenté. Dans la fonction loop() lorsque count>
10 nous appelons sleepNow ().

13/11/2023 2020-2021 187

Exercie correction
#include <avr/sleep.h>
#include <PinChangeInterrupt.h>
const byte LED = 13, SW = 5;
volatile unsigned char count = 0;
void wake() { // ISR sleep_disable(); // Serial.println(count);
first thing after waking from sleep:
detachPCINT(digitalPinToPCINT(SW)); // if
stop LOW interrupt }
void sleepNow()
{ set_sleep_mode(SLEEP_MODE_PWR Serial.begin(9600);
_DOWN);
noInterrupts(); // stop
interrupts sleep_enable(); // enables
sleep bit in MCUCR
attachPCINT(digitalPinToPCINT(SW),
wake, LOW); interrupts(); // allow
interrupts
sleep_cpu(); // here the device is put to
sleep }
void handleSW () { //digitalWrite(LED,
digitalRead(SW)); count++; }
unsigned
13/11/2023
char lastCount = -1;
void handleOtherStuff() { noInterrupts();
int mycount=count;
interrupts();
if (count != lastCount)
{ Serial.print("Count ");
lastCount =
count;
(mycount>=10){sleepNow();count=0;} } }
void setup () { //Start up the serial port
Serial.println("Example4");
pinMode (LED, OUTPUT);
pinMode (SW, INPUT_PULLUP);
attachPCINT(digitalPinToPCINT(SW),
handleSW, CHANGE); }
void loop ()
{ handleOtherStuff(); digitalWrite(LED,
HIGH);
delay(1000); digitalWrite(LED,LOW);
delay(1000); }
2020-2021 188
Mesure du temps avec Arduino

• Les fonctions natives pour la mesure du temps

• Les interruptions Timer

13/11/2023 2020-2021 189

Les fonctions natives

• La fonction void delay();

• La fonction void delayMicroseconds();
• La fonction unsigned long millis();
• La fonction unsigned long micros();

13/11/2023 2020-2021 190

Utilisation de la fonction delay( int duree_ms)

• Cette fonction permet de créer une attente dans le

programme de duree_ms millisecondes
• Exemple pour faire clignoter une DEL branchée sur
la broche 13
• digitalWrite(13,HIGH);
• delay(500);
• digitalWrite(13,LOW);
• Delay(500);

13/11/2023 2020-2021 191

Utilisation de millis()
• La fonction millis() renvoie le nombre de
milliseconde écoulées depuis le démarrage de la
carte Arduino. Elle permet de mesurer une durée
écoulée //programme tempo pour utiliser millis()
• Exempe unsigned long t1,t2;
boolean tempo(unsigned int duree){
• t2=millis();
if ((t2-t1)>=duree) {t1=t2;
return true;}
return false;}
void setup() { Serial.begin(9600);
t1=millis();//initialiser la tempo }
void loop() { int x;
if (tempo(1000)) x++; //incrémente x toutes les 1000 ms
Serial.println("nombre de secondes =" + String(x)); }

13/11/2023 2020-2021 192

 OLED Display
• 128x32 pixels
• Chaque pixel pixel peut être
ON(illuminated) ou off (not
illuminated)
•
L’afficheur est un périphérique serie
• utilisant l’interface SPI en mode
write-only
 Utilisation de l’afficheur OLED

• Initialisation
• Mode select
– Character
– Graphic
– Drawing
 Exemple
void setup()
{
IOShieldOled.begin();
}

void loop()
{
char toprint;

IOShieldOled.clearBuffer();
IOShieldOled.setCursor(0, 0);

toprint = ‘A’;

IOShield0led.putChar(toprint);
}
13/11/2023 2020-2021 196
 Programme Exemple
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 //
OLED display width, in pixels
#define SCREEN_HEIGHT 64 //
OLED display height, in pixels
// declare an SSD1306 display
object connected to I2C
Adafruit_SSD1306
oled(SCREEN_WIDTH,
SCREEN_HEIGHT, &Wire, -1);
void setup() {
Serial.begin(9600); //
initialize OLED display with
address 0x3C for 128x64 if
(!oled.begin(SSD1306_SWITCHCAPV
CC, 0x3C)) {
13/11/2023
Serial.println(F("SSD1306
allocation failed")); while
(true); } delay(2000); // wait
for initializing
oled.clearDisplay(); // clear
display oled.setTextSize(1); //
text size
oled.setTextColor(WHITE); //
text color oled.setCursor(0,
10); // position to display
oled.println("Hello World!");
// text to display
oled.display(); // show on OLED
}
2020-2021 197
 Programme
void loop() { }
Exemple number
Fonctions utilisées pour afficher du texte •oled.println(number, HEX): print
sur ecran OLED: a number IN hex format
•oled.clearDisplay(): all pixels are •oled.display(): call this method for
off the changes to make effect
•oled.drawPixel(x,y, color): •oled.startscrollright(start,
plot a pixel in the x,y coordinates stop): scroll text from left to right
•oled.setTextSize(n): set the font •oled.startscrollleft(start, s
size, supports sizes from 1 to 8 top): scroll text from right to left
•oled.setCursor(x,y): set the •oled.startscrolldiagright(sta
coordinates to start writing text rt, stop): scroll text from left bottom
•oled.setTextColor(WHITE): set corner to right upper corner
the text color •oled.startscrolldiagleft(star
•oled.setTextColor(BLACK, t, stop): scroll text from right bottom
WHITE): set the text color, background corner to left upper corner
color •oled.stopscroll(): stop scrolling
•oled.println(“message”): print
Arduino Code - Drawing on OLED
the characters
•oled.println(number): print a
13/11/2023 2020-2021 198
EEPROM

• L'EEPROM est très limitée. Alors qu'un disque dur peut stocker jusqu'à plusieurs téraoctets
de données, vous ne pouvez stocker que quelques octets, parfois des kilo-octets sur
l'EEPROM.
• Toutes les cartes Arduino n'ont pas d'EEPROM. Sur Arduino Uno et Mega, vous avez 1024
octets, mais si vous avez un Arduino Zero, vous n'avez pas d'EEPROM disponible.
• Il y a une limite au nombre de fois où vous pouvez écrire à un seul emplacement de la
mémoire EEPROM. Après environ 100 000 opérations d'écriture, l'emplacement mémoire
peut être mort. C’est pourquoi vous devez manipuler cette mémoire avec précaution.
• Pour stocker des nombres sur plusieurs octets (int, long, double,…), vous devez savoir
combien d'octets chaque valeur prendra, afin de pouvoir loger les valeurs en conséquence
dans la mémoire.

13/11/2023 2020-2021 199

EEPROM Exemples
• Stocker des données
• Tout d'abord, vous devez inclure la bibliothèque EEPROM
dans votre sketch
#include <EEPROM.h>
• Nous écrivons ici 2 valeurs dans la mémoire EEPROM:
void setup() {
• valeur 7 à l'adresse numéro 0
• Valeur 50 à l'adresse numéro 3 EEPROM.write(0, 7);
• Désormais, les valeurs sont stockées, et même si vous EEPROM.write(3, 50);
redémarrez votre carte Arduino avec un programme }
totalement différent, ces valeurs seront toujours là, aux void loop() { }
adresses 0 et 3.
• N'écrivez pas de valeur dans l'EEPROM à l'intérieur d'une
boucle infinie sans délai ou sans vérification des entrées
utilisateur.

• Vous ne disposez que d'environ 100 000 cycles d'écriture par

adresse. Si vous écrivez simplement dans l'EEPROM dans la
fonction loop () sans autre code, vous risquez de détruire
votre stockage EEPROM assez rapidement.

13/11/2023 2020-2021 200

EEPROM Exemples
• Lecture des données #include <EEPROM.h>
• Tout d'abord, vous devez inclure la bibliothèque void setup() {
EEPROM dans votre sketch Serial.begin(9600);
• Après avoir écrit certaines valeurs dans l'EEPROM, vous int value1 = EEPROM.read(0);
pouvez maintenant redémarrer votre Arduino ou Serial.println(value1);
simplement réinitialiser votre programme. Les valeurs int value2 = EEPROM.read(3);
seront toujours là, et leur lecture est assez facile.
Serial.println(value2);
}
• Notez que la règle des 100 000 est uniquement void loop() { }
destinée à l'écriture. Vous pouvez lire à partir
d'EEPROM autant que vous le souhaitez sans aucun
problème.

• Si vous avez enregistré un nombre qui nécessite plus

d’un octet (ex: double), vous devrez alors lire toutes
les adresses de ce nombre et reconstruire le nombre
avec tous les octets.

13/11/2023 2020-2021 201

PRESENTATION DES CAPTEURS
• Capteur et actionneurs

13/11/2023 2020-2021 203

 Définition
• Un dispositif qui reçoit un stimulus et
répond avec un signal électrique.
• Un type spécial de transducteur
(dispositif qui convertit un type d’énergie
en un autre
 Les capteur, actionneur et microcontrôleur

Les capteurs

Une fois connectés à l'Arduino, les capteurs peuvent fournir des

informations sur le monde extérieur en saisissant des grandeurs
physiques.

Ces informations sont traduites au format numérique et on peut ainsi

capter des phénomènes physiques tel que la lumière, le vent, la
température, la pression, la distance, …

Les capteurs sont répartis en deux familles, les capteurs logiques et les
capteurs analogiques.

Le capteur logique renvoie deux états 0 ou 1 (eg. un clavier est une

matrice de capteur logique) alors que le capteur analogique renvoie
une valeur proportionnelle à la grandeur mesurée.
41
 Capteurs courants
• Mechanical
– Accelerometers
– Gyroscopes
• Optical
– Photodetectors
– Infrared
• Semiconductor
– Gas
– Temperature
– Magnetic
 Exemple: capteur de
temperature
• Un RTD est un capteur de température
thermorésistif. C'est un élément métallique
(dans un tube en céramique) dont la résistance
augmente typiquement avec la température,
selon une fonction connue.
Une approximation linéaire est donnée
• par

• Où a est le coefficient de température, T

est la température en Kelvin et R0 la
résistance à une température connue
 Exemple
Calculer la température de la pièce pour un
RTD de cuivre si

R0 = 500Ω et α= 0.0043.

La résistance mesurée est de 500.43Ω

 Exemple
Calculer la température de la pièce pour un
RTD de cuivre si

R0 = 500Ω et α= 0.0043.

La résistance mesurée est de 500.43Ω

T= (𝑅 − 𝑅0)/α𝑅0 °C=T+273

11/13/2023 209
 Sensor Characteristics (1/4)
• Range
– Full Scale Range
– Operating Voltage Range
• Accuracy
• Transfer Function
– S=F(x), where x is the measurand and S the
electrical signal (commonly Voltage)
• Sensitivity
– The change in input required to generate a
unit change in output
 Sensor Characteristics (2/4)
• Accuracy
• Precision
 Sensor Characteristics (3/4)
• Error: the difference between the
measured value and true value
• Systematic errors are reproducible
inaccuracies that can be corrected with
compensation methods
– Interference errors
– Operator errors etc.
• Random error
– Noise
 Sensor Characteristics (4/4)
• Hysterysis: the difference in output
between the rising and falling output
values for a given input
Exemple Capteur de fumée (1/2)
• An MQ-2 smoke sensor reports smoke by
the voltage level it puts out.
• The more smoke there is, the higher the
voltage.
• built-in potentiometer for adjusting
sensitivity
• Three pins:
– Vdd input
– Ground input
– Analog output
 Capteur de fumée (2/2)
const int smokePin = 54; //sensor input
void setup() {
pinMode(smokePin, INPUT);
Serial.begin(9600);
}
void loop() {
int smoke_level = analogRead(smokePin); //read sensor
Serial.println(smoke_level);
if(smoke_level > 120) { //calibrate accordingly
Serial.println("Smoke detected");
}
delay(100); // ms
}
 Références
• M.J. McGrath, C. N. Scanaill and D. Nafus,
“Sensor Technologies Healthcare, Wellness and
Environmental Applications”, Apress, 2013
• C.W. de Silva, “Sensors and Actuators: Control
System Instrumentation”, 2nd Edition, CRC
Press, 2015
• T. Karvinen and K. Karvinen, ” Make: Sensors: A
Hands-On Primer for Monitoring the Real World
with Arduino and Raspberry Pi”, Maker Media,
Inc, 2014
Actionneurs
 Actuators
• Device that turns energy (typically
electrical) to motion
• Features
– Force
– Speed
– Torque
– Power
– Efficiency
 DC motor
• Force is produced
(F=ILB) due to the
electric current in a
wire inside a
magnetic field.
• Proportional to the
current, therefore
can be controlled by
potentiometer
• Hard to control
precisely
 Servo motors
• A DC motor with a
control circuit
Servo motors are
• controlled by PWM
through the control pin
Il existe trois grandes
familles de servomoteurs :
positionnement angulaire,
rotation continue,
déplacement linéaire.
La librairie Servo.h
• Pour piloter vos servomoteurs, vous aurez besoin de la librairie servo.h qui fait
partie des librairies de base de l’environnement Arduino. Parmi les fonctions
proposées par la librairie servo.h, deux sont les plus utilisées :
• attach(pin) : permet d’attacher le servomoteur au Pin d’asservissement
• write(angle) : envoi le servo à l’angle spécifié
• Ces quatre autres fonctions pourront être utiles pour gérer plus finement les
servomoteurs
• writeMicroseconds(us) : permet d’ajuster les positions limites si votre
servomoteur n’est pas standard.
• read(pin) : permet de lire l’angle sur lequel est actuellement positionné le servo
• attached(pin) : permet de savoir sur un servomoteur est attaché au Pin spécifié
• detach(pin) : pour détacher votre servomoteur du Pin spécifié.

13/11/2023 2020-2021 221

 Servo motor control
#include <Servo.h>
Servo myservo; // create servo object to control a servo
void setup() {
int val = 180; // variable to control servo
myservo.attach(9); // pin 9 is a PWM pin
}
void loop() {
myservo.write(val); // constant servo speed
delay(15); // waits for the servo to get there
}
Servo moteur 9g Tower Pro

Description
Caractéristiques:
- Tension de fonctionnement: 3,0 - 7,2 V
- Angle de rotation: 180 degrés
- Vitesse: 0,12 sec / 60 degrés (4,8 V) sans charge
- Couple: 1,2 kg.cm (4,8 V) et 1,6 kg.cm (6,0 V)
- Température de fonctionnement: -30C ~ + 60C
- Type d'engrenage: Nylon
- Taille du câble: 245 mm
- Dimensions: 32 x 30 x 12 mm
13/11/2023 2020-2021 223
Servo connection

• Rouge : alimentation +5V.

• Noir ou marron : commun à relier
au Pin GND de la carte de
développement (Arduino, ESP32,
ESP8266)
• Orange, jaune ou blanc : signal de
positionnement envoyé par
l’Arduino.

13/11/2023 2020-2021 224

 Moteur pas à pas
• motor controlled by a series of electromagnetic coils.
• The center shaft has a series of magnets mounted on it
• the coils are alternately given current or not, creating
magnetic fields which repulse or attract the magnets on
the shaft, causing the motor to rotate.
• allows for very precise control of the motor. it can be
turned in very accurate steps of set degree increments
• two basic types
– unipolar
– bipolar
Exemple: Unipolar stepper motor
• Four digital pins
required to
control the motor
• Darlington
transistor array
used for
supplying the
power required
 Stepper motor control
#include <Stepper.h> //the control sequence is in this library

const int stepsPerRevolution = 200; // motor-dependent

Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11); //pins used

void setup() {
// set the speed at 60 rpm:
myStepper.setSpeed(60); //actually sets the delay between steps
}

void loop() {
// step one revolution in one direction:
myStepper.step(stepsPerRevolution);
delay(500);
}
INTERNET OF THINGS WITH
ARDUINO
 Arduino with GPS (1/4)
• Three modes:
– Stand-alone: GPS obtains information such as position and
altitude with only the signal of the satellites
• slowest of the three modes
• AT+CGPSINFO command brings directly latitude, logtitude,
date, UTC time, altitude and speed
– S-GPS: module connects to a GPS server
• module calculates the position
– A-GPS: Three modes
• MS-Assisted: Server sends data and calculates position
• MS-based: Server sends aiding data, module calculates
position
• Stand-Alone: Module demodulates GPS data and calculates
position
 Arduino with GPS (2/4)
• AT+CGPSINFO returns the GPS info in a string:
• [<latitude>],[<N/S>],[<longitude>],[<E/W>],[<date>],[<UT
C_time>],[<altitude>],[<speedOG>],[<course>]
 Arduino with GPS (3/4)
int8_t answer;
int onModulePin= 2;
char gps_data[100]; //will perform 100 GPS data reads
int counter;
void setup(){
pinMode(onModulePin, OUTPUT);
Serial.begin(115200);
Serial.println("Starting...");
power_on();
delay(5000); // starts GPS session in stand alone mode
}
}
void power_on(){ //void power_on() should be placed AFTER void loop(), used here for lecture
digitalWrite(onModulePin,HIGH); //GPS module requires a 3 sec pulse on onModulePin
delay(3000);
digitalWrite(onModulePin,LOW);
}
 Arduino with GPS (4/4)
void loop(){
answer = sendATcommand("AT+CGPSINFO","+CGPSINFO:",1000);
// request info from GPS
if (answer == 1) {
counter = 0;
do{
while(Serial.available() == 0); //reading GPS data
gps_data[counter] = Serial.read();
counter++;
}
}
Serial.print("GPS data:"); //printing GPS data
Serial.print(gps_data);
}
 Connecting through 3G (1/2)
int8_t answer;
int onModulePin = 2, aux;
char aux_str[50];
void setup(){
pinMode(onModulePin, OUTPUT);
Serial.begin(115200);
Serial.println("Starting...");
power_on();
delay(3000); //sets the PIN code
sprintf(aux_str, "AT+CPIN=%s", pin_number);
sendATcommand(aux_str, "OK", 2000);
delay(3000);
 Connecting through 3G (2/2)
while( (sendATcommand("AT+CREG?", "+CREG: 0,1",
500) || sendATcommand("AT+CREG?", "+CREG: 0,5",
500)) == 0 ); // sets APN, user name and password
sprintf(aux_str, "AT+CGSOCKCONT=1,\"IP\",\"%s\"", apn);
sendATcommand(aux_str, "OK", 2000);
sprintf(aux_str, "AT+CSOCKAUTH=1,1,\"%s\",\"%s\"",
user_name, password);
sendATcommand(aux_str, "OK", 2000);
}
Les Timers / compteurs avec Arduino et
ATMEGA 328P
• Les Timers / compteurs avec Arduino et ATMEGA 328P

13/11/2023 2020-2021 235

• Il y a trois minuteries sur un Arduino Uno. Deux sont en
8 bits et l’autre en 16 bits. Les timers peuvent générer
une interruption lorsqu'ils débordent ou lorsqu'ils
correspondent à une valeur définie.
• La fréquence de l'incrément de minuterie est
programmable
• Arduino utilise les timers pour le PWM et pour la
mesure du temps (delay (), millis (), micros ())

13/11/2023 2020-2021 236