Systèmes D'acquisitions Des Données

1
Module M11
 Architecture des systèmes à processeurs

(Cas des Microcontrôleurs PIC)
 Transmission et acquisition de données
 Eléments du Module Arduino
Lahoussine BOUHOUCH
l.bouhouch@uiz.ac.ma
2
Plan
PARTIE 1
• Systèmes de numération
• Introduction aux systèmes à processeurs
• Microsystèmes
• Microsystèmes simplifiés
• Modèle générique des microprocesseurs
• Notion de microcontrôleur
• Microcontrôleurs PIC
• Architectures des PIC
• Différentes familles de PIC
• Fonctions intégrées aux PIC
• Référence des µC PIC
• Architectures du PIC16F84
• Horloges, Mémoires, Registres du PIC16F84
3
Plan
PARTIE 2
• Interruptions
• Interfaces graphiques de MikroC for PIC
• Eléments de programmation MikroC for PIC
• Fonctions intégrées à MikroC for PIC
• Bibliothèques intégrées à MikroC for PIC
• Conversion Analogique Numérique (ADC)
• Contrôleur LCD
• Module USART (UART)
• Modules CCP (PWM)
• Timer & Interruptions
• Généralités sur les Bus d’acquisition et de transmission de données
• Bus RS232 (USART ou UART ou Port Série)
• Bus CAN
• Bus I2C
• Aperçu sur le module Arduino
4
Systèmes de numération
• Rappels :
Nombres Binaires Signés sur 8 Bits  C2
+7 0000 0111
+6 0000 0110
Avantage du C2 +5 0000 0101
par rapport aux +4 0000 0100

MSB = 0 pour les positifs
autres +3 0000 0011
+2 0000 0010
+1 0000 0001
Un seul '0' +0 0000 0000
est représenté -0 -----

-1 1111 1111
-2 1111 1110
-3 1111 1101
-4 1111 1100
-5 1111 1011
MSB = 1 pour les négatifs
-6 1111 1010
-7 1111 1001
-8 1111 1000
5
• Opérations en Binaire :
– Addition (Règle) :
0+0=0
0+1=1
1+0=1
1+1=0 avec Retenue = 1
– Exemple : (12 + 07)10 = (19)10

= (0000 1100)2
+ (0000 0111)2
= (0001 0011)2 = (13)16
Remarque : Pour les nombres signés, si le MSB = 1 alors
le nombre est Négatif
6
– Soustraction (Notion de Complément) :
• Complément à 1 : "C1"
C1(0) = 1
C1(1) = 0
• Complément à 2 : "C2"
C2(x) = C1(x) + 1
– Soustraction (Règle) :
• X–Y X + C2(Y)
IMPORTANT : Toujours travailler en 8, 16, 32 bits ou plus
7
– Soustraction (Exemple) :
(12 - 07)10 = (05)10 = (0000 1100 - (0000 0111))2
= (0000 1100 + C2(0000 0111))2
C2(0000 0111)2 = C1(0000 0111)2 + 1

= (1111 1000)2 + 1
= (1111 1001)2
 (12 - 07)10 = (0000 1100)2

+ (1111 1001)2
= 1 (0000 0101)2 = (05)10 & 16
8
Architecture des systèmes à processeurs
9
Introduction aux systèmes à processeurs
• Familles de processeurs :
Famille Fonction
Microprocesseur Généraliste
Microcontrôleur Applications Embarquées
Processeur de Signal (DSP) Spécialisé Traitement du signal
ASIC Spécifique à une application
FPGA Laboratoire configurable par l’utilisateur
10
Introduction aux systèmes à processeurs
• Où trouve-t-on les processeurs ?
11
Microsystèmes
Modem Interfaces
Écran
Horloge
Informatique
Clavier
Souris
µP RAM
Imprimante
Mémoire de masse ROM
Informatique Industrielle
Capteur Unité de transfert Interface de Moteur

TOR de donnée puissance
CNA Commande
Capteurs CAN
…
Bus CAN Commande
12
Microsystèmes
• Horloge
L'horloge marque le temps et toute l'activité du microprocesseur.
Le µp utilise l’horloge pour exécuter les tâches selon une séquence préétablie
programme
instruction
Cycle bus
Période d'horloge
Fréquence d'horloge, c’est la fréquence de l'horloge interne du µP, ce qui explique qu'on
l'appelle aussi parfois « Fréquence interne ».
Elle conditionne la rapidité à laquelle le processeur peut traiter les données.
13
Microsystèmes simplifié
Bus de contrôle Horloge
µP
(Interruption)
Bus d’adresses
16 bits
Coupleur
d’interface
Bus de Données
8 bits
Unité RAM ROM

Entrée/Sortie données programme
Autoroute assurant TRANSPORT de

Bus de données Bidirectionnel données vers Intérieur ou Extérieur du µP
Unidirectionnel  De l'UCT vers la
Bus d’adresses Unidirectionnel mémoire et organes d'entrées-sorties
Bus de Contrôle Mixte Contrôle le flux des données

14
Modèle générique des microprocesseurs
ALU ou UAL
Registres de données
Registres d’adresse
Pointeurs de pile
Pointeur de programme (PC)
Registre d’Etat (Status)
15
UAL : Unité Arithmétique et Logique
* Addition ;
* Soustraction ;
* Décalage ;
* ET logique ;
* OU logique ;
• …
16
PC : COMPTEUR PROGRAMME (ou Compteur Ordinal)
Le PC contient sous forme binaire l'adresse de la prochaine instruction à

exécuter.
Exemple :
1 0 1 1 0 0 1 1 1 1 0 1 0 0 0 1 PC
Bus d’adresses
Mémoire
Instructions du programme
centrale
17
Status : Registre d’ETAT

Associé au fonctionnement de l'UAL et a pour rôle d'enregistrer l' "état" de
certaines opérations.
Il contient des bits qui ont chacun une affectation bien particulière tel que :
… … … … … … Z DC C STATUS
* Indicateur de Retenue après Addition (C : Carry =1 s’il y a Retenue ) ou

bit de Signe après Soustraction (C=0 si Résultat Négatif)
* Indicateur de Zéro (Z : Zero, Résultat = 0  Z=1 )
* Indicateur de demi-Retenue (DC : Digit Carry)
*…
18
Notion de microcontrôleur
 Structure générale
Bus adresses
décodage
Micro- Sorties
Périphériques
Processeur ROM RAM (Interfaces)
Entrées
Bus données
Horloge
19
Microcontrôleurs PIC
– Gammes des PIC
20
Architectures des PIC
– Architecture matérielle Harvard :

• Un bus pour chaque Mémoire (Données et Programme).
• Occupation mémoire Fixe pour toutes les instructions.
Cas des PIC

21
Architectures des PIC
– Architecture Logicielle RISC (Reducted Instruction Set Computers) :

• Instructions simples (et rapides).
• Les instructions lisent leurs opérandes dans des registres.
• Beaucoup de registres.
• Instructions de longueur et de temps d'exécution fixes.
• Programmes plus longs.
• Machines simplifiées et plus rapide.
22
Différentes familles de PIC
– Il existe 3 familles de PIC :

• Base-Line :
– Instructions codées sur 12 bits
• Middle-Range :
• High-End :
23
Fonctions intégrées aux PIC
– Points communs à tous les µC :

• Timer 8 bits
• I/O (Entrées / Sorties)
• WDT (Watchdog Timer)
• Gestion du RESET
• Equipés d'un Oscillateur intégré
• Equipés de Résistances de Tirages internes
configurables par programme
• Surveillance d’alimentation …
24
Fonctions intégrées aux PIC
– Spécificités par µC :
• EEPROM (Mémoire reprogrammation) : Exemple PIC16C84
• 1 ou 2 Timer 16 bits
• ADC 8 ou 10 bits (Entrées Analogiques)
• DAC 8 bits
• Comparateur Analogique
• Tensions de référence
• CCP (Capture Compare PWM)
• ECCP (PWM à 4 canaux)
• Contrôleur de LCD
• Communications : I2C, SPI, USART, Bus CAN, USB, …
25
Référence des µC PIC
PIC16 F 84 - 4
Catégorles :
10, 12, 16, 17 ou 18
Fréquence Max
Type de Mémoire & d’Alimentation
 F Flash 4,5 à 6V
 C EEPROM ou EPROM 4,5 à 6V Référence à 2 à 4 chiffres
 CR ROM 4,5 à 6V
 LF Flash 2 à 6V
 LC EEPROM ou EPROM 2,5 à 6V
 LCR ROM 2,5 à 6V
26
Architectures du PIC16F84
• Introduction
– Le PIC16F84 de Microchip :
• Architecture Harvard.
• Famille Middle-Range (Instructions codées sur 14 bits).
• Type RISC :
– Jeu d 'instruction réduit : que 35 instructions, et
– Temps d'exécution réduit.
• Vitesse Typique 4 MHz.
• Données sur 8 bits.
• 13 Entrées - Sorties configurables individuellement.
27
• Architecture interne (Structure)
28
• Architecture externe
– Le microcontrôleur est réalisé en Technologie CMOS.
– Les signaux sont Compatibles TTL.
– Broches du PIC16F84 :
• Vss et Vdd alimentation :
– De 3 à 5,5 V.
• OSC1, OSC2 : signaux d’Horloge
– Circuit RC ou un Quartz.
• MCLR (Master CLear) : Reset ou Vpp.
• CLKIN peut être connectée à Horloge externe :
– 0 à 4 ou 20 MHz.
• RA0 ... RA4 :
– 5 Entrées/Sorties du Port A.
• RB0 ... RB7 :
– 8 E/S du port B.
• T0CKI : Entrée d’Horloge externe du Timer TMR0.
• INT : Entrée d’Interruption externe.
29
Horloges du PIC16F84
– 1 cycle machine ( = 4 coups d’horloge) pour exécuter 1

instruction.
 FQ: 0 à 4 MHz ou 0 à 20 MHz selon le type de µC

1. Horloge Interne
Résonateur Quartz ou Céramique. Circuit oscillant externe RC.

 FH = FQ/4  FH = 1/(4RC)
30
Horloges du PIC16F84
2. Horloge Externe
GBF, NE555,
Oscillateur 74LS...
Horloge externe pour synchroniser le PIC sur un processus particulier.

Broche OSC2 est alors inutilisée.
31
Mémoires du PIC16F84
• Mémoires du PIC16F84 :
– La Mémoire de programme (Mémoire non volatile) :
– Le PIC16F84 Intègre mémoire de programme du type "Flash EEPROM"  EEPROM rapide
("F"de 16F84):
– La Mémoire de données :
• La RAM (Mémoire Volatile) :
– Là où le µC, lorsque un programme "Tourne", stocke les résultats de calculs
intermédiaires (Exemple un décomptage pour une temporisation …).
• L'E2PROM (Mémoire non volatile) :

– Là où sont sauvegardés des événements survenant au cours d'un programme en
exécution (Exemple une alarme …).
32
• Mémoire de programme
– Contient le programme à exécuter.
– 1k "mots" = 1024 cases de 14 bits :

• De 000h à 3FFh (1024 lignes de programme)
Organisation de la mémoire
programme et de la pile.
33
• Mémoires de données (2 zones)
• Zone 1 : La RAM avec ces 2 parties :
– La 1ère : les SFR (Special Function Registers) :
Pour le contrôler les opérations sur le circuit.
– La 2ème : les GPR (General Purpose Registers)

ou registres généraux
 68 octets libres pour l'utilisateur
appelé A usage général.
• Zone 2 : 1 EEPROM :
– Contient 64 octets.
Organisation de la Zone 1
de mémoire de données.
34
Registres du PIC16F84
– Registres Spéciaux - SFR :
– Réparties sur 2 pages ("Bank") :

» "Bank 0" et
» "Bank 1".
35
Fonction de chacun des

bits de ces registres.
36
 STATUS : État de l’UAL + Bits de sélection des "Bank".

• État de l’UAL :
• Bit C : Retenue d’une opération d’ADDITION
ou Bit de SIGNE pour la SOUSTRACTION
• Bit DC : Retenue d’une opération sur 4 bits
• Bit Z : Mis à 1 si résultat d’une opération arithmétique et logique est nul.
• Sélection des "Bank" (Pages) : seul bits RP0 est utilisé RP1=0
• Bit RP0 = 0  Bank 0.
• Bit RP0 = 1  Bank 1.
37
• Ports d’entrée / sortie du PIC16F84

– Le PIC16F84 est équipé de 13 lignes d’E/S réparties en
2 Ports Parallèles Bidirectionnels.
• 5 lignes  Port A : RA4 ... RA0.
• 8 lignes  Port B : RB7 ... RB0.
•  2 registres de Travail PORTA & PORTB +

2 registres de Configuration TRISA & TRISB
38
Registres de Configuration des Ports
 Sens de direction des données (Entrée ou sortie)

 Registres TRISA (TRansfert Input Set port A) ou TRISB.
– TRISA  Direction de ligne RA4, … RA0

– TRISB  Direction de ligne RB7, … RB0
– Bit x = 0 dans TRISA ou TRISB  Sortie et

– Bit x = 1  Entrée.
39
40
41
Registres de Travail des Ports

• 5 lignes  Port A : RA4 ... RA0.
• 8 lignes  Port B : RB7 ... RB0.
• PORTA  Ligne RA4, … RA0

• PORTB  Ligne RB7, … RB0
 PORTA : Accès en lecture ou écriture au port A. Le bit 4 utilisé en entrée de comptage.

 PORTB : Accès en lecture ou écriture au port B. Le bit 0 utilisé en entrée d'interruption.
42
– Registres Spéciaux - SFR : registre OPTION_REG
 OPTION_REG : Bits de configuration pour divers périphériques.
• /RBPU (RB Pull Up) : Résistances de tirage à Vdd des entrées du port B (Validé par 0)
43
• /RBPU (RB Pull Up) : Résistances de tirage à Vdd des entrées du port B (Validé par 0)
Résistance de tirage ou de Pull-Up interne

SiNON Pull-Up externe
Activer la résistance de pull-up interne  /RBPU = 0
Si Appui  PB0=0
Si Relâché  PB0=1
/RBPU = 0 active toutes les résistances de pull-up des broches en Entrées du Port B.
Le Port A ne dispose pas de cette option.
44
• INTEDG (Interrupt Edge) : Front actif (1 pour montant) qui provoquera une interruption
sur la borne RB0 (si interruption activée).
• T0CS (TMR0 Clock Source) : Source utilisée par le Timer (0 : horloge interne, 1 : RA4).
• T0SE (TMR0 Source Edge) : Front actif sur RA4 qui fait avancer le compteur
(0 : front montant)
• PSA (Prescaler assignment) : 0 pour Timer0 et 1 pour chien de garde WDT.
• PS2 ... 0 (Prescaler) : Valeur du Diviseur de fréquence pour les Timers.
Valeur des Diviseur Diviseur Valeur des Diviseur Diviseur

Bits (TMR0) (WDT) Bits (TMR0) (WDT)
000 1:2 1:1 100 1 : 32 1 : 16
001 1:4 1:2 101 1 : 64 1 : 32
010 1:8 1:4 110 1 : 128 1 : 64
011 1 : 16 1:8 111 1 : 256 1 : 128
45
Interruptions
Interruption:
Mécanisme d'un microcontrôleur lui permettant de répondre à certains
événements au moment où ils se produisent, indépendamment de ce
qu’il fait à cette époque.
Exemple: Interruption externe sur la broche RB0/INT.
46
Interruptions
PIC16F84  4 sources d'interruption:
1. Fin d'écriture de données sur EEPROM.
2. Interruption TMR0  Cause débordement du Compteur/Temporisateur.
3. Interruption due aux transition sur les broches RB4, RB5, RB6 et RB7.
4. Interruption externe sur la broche RB0/INT.
47
Interruptions
– Registre INTCON
 INTCON : Masque d'interruptions.
* GIE (Global lnterrupt Enable)  Mis à 1  Autorise toutes les interruptions non
masquées par leur bit individuel.
* EEIE (EEprom write completed lnterrupt Enable)  Mis à 1  Autorise les
interruptions de fin d'écriture dans l'EEprom.
* T0IE (Timer 0 lntmupt Enable)  Mis à 1  Autorise les interruptions dues au
débordement du Timer 0.
* T0IF (Timer 0 lnterrupt Flag)  Mis à 1 si débordement du Timer 0.
* INTE (lNTerrupt Enable)  Mis à 1  Autorise les interruptions sur RB0/INT.
(Front montant si bit INTEDG du registre OPTION est à 1; sinon front descendant).
* INTF (lNTerrupt Flag)  Mis à 1 si interruption externe est générée sur RB0/INT.
* RBIE (RB lnterulpt Enable)  Mis à 1  Autorise les interruptions sur RB4 à RB7.
* RBIF (RB Interupt Flag)  Mis à 1 si changement d'état sur lignes RB4 à RB7.
48
Interfaces graphiques de MikroC for PIC
Accès rapide à un endroit Fenêtre principale de Barre des menus Explorateur
spécifique du code saisie du code source et d’outils de projet
Configurations de Liste de la majorité des

Messages d’erreurs ou autres.
l.bouhouch@uiz.ac.ma base du µC choisi bibliothèques prédéfinies
Eléments de programmation MikroC for PIC49
– Structure du programme C :
Header de la bibliothèque standard in/out.
#include <stdio.h> (pour printf). Rarement utilisée pour les PIC
#define pi 3.14 Equivalence : Le préprocesseur
remplacera tous les pi par 3.14
float x, y ; Déclaration de deux variables réelles globales
En-tête du programme principal

void main()
Début de la fonction main
{
Calculs
x = 2.0 ;
Appel de la fonction puts (envoie une chaîne
y = pi*x ; de caractères sur le périphérique de sortie
puts("bonjour à tous\n") ; avec retour à la ligne)
printf("la circonférence est %f \n",c) ;
Appel de printf (affiche des chaînes
} formatés, ici y est affiché sous format réel)
Fin de la fonction main
– Autre programme C : Clignoter une LED
void LED() ;
Prototype : Déclaration d’une fonction après main():
void Init_Port() Il indique au compilateur le type de la fonction et ses
{ TRISB = 0 ; paramètres de passage (Ici pas de paramètres).
PORTB = 0 ;
}
En tête de la fonction principale (main)
void main()
{ Appel de la fonction Init_Port. (Pas de paramètre)
Init_Port() ;
while(1)
{ Appel de la fonction LED. (Mettre un bit à 0 puis à 1)
LED() ;
Delay_ms(1000) ; Appel de fonction interne. (Attente 1 seconde)
}
}
void LED() Fonction LED. (Pas de paramètres)
{
PORTB.F0 = ~PORTB.F0 ; Inversion de l’état du Bit 0 du Port B
}
– Types de données standard :
Type Longueur (bits) Domaine de valeurs
unsigned char
8 0 à 255
unsigned short (ou int)
char ou signed char
8 -128 à 127
signed short
(signed) int 16 -32768 à 32767
unsigned int 16 0 à 65535
long 32 -2 147 483 648 à 2 147 483 647
unsigned long 32 0 à 4 294 967 295
Float 32 ±3,4.10-38 à ±3,4.10+38
double 64 ±1,7.10-308 à ±1,7.10+308

– Séquences d'échappement (Escape Sequences) :
Caractères ASCII non imprimables.
Ou également en précisant son code hexadécimal, après une barre oblique inverse (\x).
Séquence
Valeur Hexa Caractère
d'échappement
\a 0x07 BEL (Sonne)
\b 0x08 BS (Backspace ou Retour arrière)
\t 0x09 HT (Tabulation horizontale)
\n 0x0A LF (Saut de ligne)
\v 0x0B VT (Tabulation verticale)
\f 0x0C FF (Saut de page)
\r 0x0D CR (retour chariot)
– Déclaration exemples :
char toto, tonton, blabla ; Trois caractères

int table[100] ; Tableau de 100 entiers non initialisés
char tableau[ ] = {10, 0x1C, ’A’, 55, 4} ; Tableau de 5 valeurs énumérés
char *p ; * Désigne un Pointeur sur un type défini

p pointe sur des caractères
Remarque:
- Nombre entier Hexadécimal est précédé de 0x ou 0X. (Exemple 0x1FB9)
- Nombre entier en Décimal n'a pas de préfixe.
- Nombre Réel se note 13.145 ou 1.3145e+1.
- Dans les compilateurs pour µC : Notation binaire 0b11010001
– Affectations et Auto-affectations :
Symbole Description Notation
= Affectation simple a=b;

*= Affectation produit a *= 2 ;  (a = a*2)
/= Affectation quotient a /= 2 ;  (a = a/2)
%= Affectation reste a %= 2 ;  (a = le reste de a/2)
+= Affectation somme a += 2 ;  (a = a+2)
&= Affectation ET entre bits a &= 5 ;  (a = a&5)
^= Affectation OU EX entre bits a ^= 5 ;  (a = a^5)
|= Affectation OU entre bits a |= 5 ;  (a = a|5)
<<= Affectation décalage gauche a <<= 5 ;  (a = a<<5)
>>= Affectation décalage droite a >>= 5 ;  (a = a>>5)
– Opérateurs binaires :
* Multiplication c = a*b ;
/ Division c = a/b ;
+ Plus binaire c = a+b ;
-= Moins binaire c = a-b ;
<< Décalage à gauche c = a<<b ;
>> Décalage à droite c = a>>b ;
& ET entre bits c=a&b;
^ OU exclusif entre bits c = a ^b ;
| OU entre bits c=a|b;
– Tests :
< Strictement inférieur if (a < b) ;

<= Inférieur ou égal if (a >= b) ;
> Strictement supérieur if (a > b) ;
>= Supérieur ou égal if (a >= b) ;
== Egal if (a ==b) ;
!= Différent if (a != b) ;
&& ET logique if ((a==5) && (b==2)) ;
|| OU logique if ((a==5) || (b==2)) ;
?: Condition z=(a>b)?a:b ; (Si a>b a z=a sinon z=b)
– Instruction conditionnelle : if … else
if (Condition) Action1 ;
Fausse
else Action2 ; Condition
?
Si la Condition est vrai Vrai
• Faire l’Action 1 Action 1 Action 2
• Sinon faire l’Action 2
– Instruction conditionnelle : if … else
Exemples :
Action1 et Action2 sont Action1 et Action2
une seule instruction sont un bloc d’instructions
if( a > b ) c=c–a; if( a > b )
else c = c- b ; { c=c–a;
d=c–a;
}
ELSE n’existe pas
else { c=c–b;
if( a > b )
d=c–b;
{ c=c–a;
}
d=c–a;
} Condition multiples
if( (a > b) && ( b > 0) ) c=c–a;
else c=c-b;
– Instruction conditionnelle : switch … case
Structure équivalente à la structure Si ... Alors … Sinon mais permet une
meilleur compacité du code.
Exemples :
Selon la valeur de (c ) switch (c )
Début Selon {
Si = '+' : resultat  a+b, Sort case '+' :resultat = a+b ; break ;
Si = '-' : resultat  a-b , Sort case '-' : resultat = a-b ; break ;
Si = '*' : resultat  a*b , Sort case '*' : resultat = a*b ; break ;
Si = '/' : resultat  a/b , Sort case '/' : resultat = a/b ; break ;
Par defaut : resultat  a+b default : resultat = a+b ;
Fin Selon }
– Boucle : for
Action(s) à effectuer en
dernier dans la boucle
Initialisation
Action(s) à effectuer dans la boucle
for ( Initialisation ; Condition ; Modification )

{
Condition
action ; ?
Sortie de
…; la boucle
}
Action
Action(s) de départ
Condition pour rester dans la boucle Modification
– Boucle : for
Exemples :
2 boucles identiques : Action exécutée 5 fois. // Version 2 simplifiée
// Version 1 // Version 2
for( x = 5 ; x ; x-- )
for( x = 0 ; x < 5 ; x++ ) for( x = 5 ; x > 0 ; x-- ) {
{ { action ;
action ; action; }
} } x est vrai si x > 0 donc
la boucle sera exécutée
Traduction Version 1 : tant que x>0
x0
Tant que (x < 5))
faire action
x  x+1
Répéter Tant que
– Boucle : while
Tant que condition vraie faire ...
while (condition)
{
action ;
…;
} Condition
?
Sortie de
while(1) : Boucle la boucle
exécutant indéfiniment
un bloc d’instructions. Action
while ( 1 )
{
action ;
…;
}
– Boucle : while
Exemples :
Boucle dont l’action ne sera jamais Boucle identique
exécutée car la condition est à une boucle FOR
fausse dès le départ. x=0;
x = 10 ; while ( x < 5 )
while ( x < 5 ) {
{ action ;
action ; x++ ;
x++ ; }
}
Soit un bouton poussoir donnant 0 s’il est appuyé. while ( bouton == 0 )

Ici on fait l’action tant que le poussoir est maintenu appuyé. {
On sort de la boucle quant le bouton n’est plus appuyé.
action ;
}
– Boucle : do … while
Faire ... tant que condition vraie Action toujours
exécutée au
moins une fois que
do la condition soit
vraie ou fausse.
{
Action
action ;
…;
Condition } while (condition) ;
?
x=0;
total = 0 ;
Nombre d’exécutions de la boucle : 5 do
Sortie de
la boucle A la sortie de la boucle total = 10 {
total = total + x ;
x++ ;
} while ( x < 5 ) ;
– Les fonctions :
void buzzer (void)
{
…
Début …
}
Initialisation
des ports void init_port (void)
{
Led1 éteinte …
…
}
BP
activé ?
void main (void)
{
init_port();
Led1 éteinte Led1 allumée Led1 = 0;
while(1)
{
Gestion du
if(bp == 0)
buzzer
{
Led1 = 1;
buzzer();
}
else Led1 = 0;
}
}
66
Fonctions intégrées à MikroC for PIC
– Quelques fonctions :
Fonction Description
Lo Renvoie le plus faible octets (bits 0 à 7) d’un nombre
Hi Renvoie le 2ème plus faible octets (bits 8 à 15) d‘un nombre
Higher Renvoie le 3ème plus faible octets (bits 16 à 23) d'un nombre
Highest Retourne le 4ème plus faible octets (bits 24 à 31) d'un nombre
Delay_us Crée le retard dans les unités de microseconde (10-6 s)
Delay_ms Crée le retard constant dans les unités de millisecondes (10-3 s)
Vdelay_ms Crée le retard en millisecondes en utilisant des variables de programme
Delay_Cyc Crée le retard basé sur l'horloge de microcontrôleur (10x le paramètre)
Clock_Khz Régler l’horloge de microcontrôleur en KHz
Clock_Mhz Régler l’horloge de microcontrôleur en MHz
67
– Utilisation de la fonction Delay_ms :
Exercices :
Une LED est connectée au PORTB (broche RB0) du µC PIC16F84A à travers
une résistance R de limitation de 220W.
Ecrire un programme qui fera clignoter la LED (ON et OFF) en permanence
dans un intervalle d'une seconde.
Procédure :
Une LED peut être connectée à un µC de deux façons : "Source de courant" et
"Absorption de courant".
En mode "Absorption de courant" (voir figure) une broche de la LED est reliée
à +5 V à travers la résistance R et l'autre broche est reliée à une broche du
port de sortie du µC. La LED sera allumée lorsque le port de sortie du µC est
au niveau logique 0 (0 V).
En mode "Source de courant" (voir figure) une broche de la LED est reliée au
port de sortie du µC et l'autre broche est reliée à la masse à travers la
résistance R. La LED sera allumé lorsque le port de sortie du µC est au niveau
logique 1 (+5 V).
68
Programme version 1 (LED Clignotante) :
/****************************************************
LED CLIGNOTANTE
================
Programme faisant clignoter une LED connectée au port RB0 du µC
PIC16F84A avec l’intervalle d’une seconde. La fonction intégré
Delay_ms  Crée un délai de 1 seconde entre les clignotements.
Oscillateur : XT, 4 Mhz
*****************************************************/
void main ()
{
TRISB = 0 ; // Configurer tout le PORTB en sortie
for (;;) // Boucle sans fin
{
PORTB.F0 = 1 ; // Allume la LED avec un « 1 »
Delay_ms (1000) ; // Retard 1 seconde
PORTB.F0 = 0 ; // Éteint la LED avec un « 0 »
Delay_ms (1000) ; // Retard de 1 seconde
}
}
69
Programme version 2 (LED Clignotante) :
/****************************************************
LED CLIGNOTANTE (PIC16F84A)
================
Utilisation des commandes du préprocesseur #define
==> Le programme est plus facile à suivre.
*****************************************************/
#define LED PORTB.F0 // LED reliée au port RB0 du PORTB
#define ON 0 // « 0 » allume la LED
#define OFF 1 // « 1 » éteint la LED
#define Retard Delay_ms(1000)
void main ()
{ TRISB = 0 ; // Configurer tout le PORTB en sortie
for (;;) // Boucle sans fin
{
LED = ON ; // LED allumée (ON)
Retard ; // Retard de 1 seconde
LED = OFF ; // LED éteinte (OFF)
Retard ; // Retard 1 seconde
}
}
70
Programme version 1 (Afficheur 7 segments) :
/****************************************************
Contrôle d'un afficheur 7 segments (PIC16F876A)
========================
Afficheurs AC (Anode Commune) et CC (Cathode Commune)
AC --> Diodes allumées par « 0 » et pour les CC par l'état « 1 »
==> Afficher un chiffre  Présenter sur les broches le code 7 segment
Sur MikroC ==> Code  Menu "Touls / Seven Segment Editor"
Pour Aff. AC
*****************************************************/
void main () Sorties
{
TRISB = 0x80 ; // Configuration PORTB (1000 0000)
while (1) // Boucle sans fin Entrée
{
PORTB = 0xB0 ; // Code 7 seg du chiffre 3
Delay_ms(300) ; // Temporisation
PORTB = 0x99 ; // Code 7 seg du chiffre 4
Delay_ms(300) ; // Temporisation
}
}
71
/***********************************************************
Contrôle d'afficheur 7 segments (AC) avec 2 boutons poussoir BP1 (RC0)
et BP2 (RC7). L’appuis sur BP1 ou sur BP2 affiche successivement 3 ou 4.
Si aucun --> Affiche 0. (PIC16F876A)
***********************************************************/
void main ()
{
PORTB = 0 ;
TRISC = 0x81 ; // (RC0, RC1) Entrées, les autres Sorties
PORTC = 0 ;
while (1) // Boucle sans fin
{
if (PORTC.F0 == 0) // Si BP1 est mis à la masse
PORTB = 0xB0 ; // Code 7 seg du chiffre 3
else if (PORTC.F7 == 0) // Sinon Si BP2 est mis à la masse
PORTB = 0x99 ; // Code 7 seg du chiffre 4
else PORTB =0xC0 ; // Si aucun ==> Affiche 0
}
}
72
/****************************************************
Contrôle d'afficheur 7 segments (AC) (PIC16F876A)
Afficher des chiffres de 0 à 9 à une cadence de 100ms, en déclarant un
tableau Tab[10] contenant les 10 codes 7 seg.
Boucle for repère dans table le code à envoyer au Port B toutes les 100 ms.
*****************************************************/
int i ;
char Tab[10] = {0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8, 0x80, 0x90} ;
void main ()
{
PORTB = 0 ;
{
for (i=0; i<=9; i++) // Boucle balayant les chiffres 0 à 9
{
PORTB = Tab[i] ; // Code 7 seg du chiffre i
delay_ms(100) ; // Temporisation
}
}
}
73
Bibliothèques intégrées à MikroC for PIC
– Bibliothèques fréquemment utilisées :
• ADC, LCD, UART, PWM, EEPROM, …
Bibliothèque Description
ADC Pour la Conversion Analogique / Numérique

LCD Pour manipuler un LCD standard
UART Pour manipuler la communication à travers le module UART
PWM Pour manipuler le module PWM
EEPROM Pour manipuler la mémoire EEPROM
One Wire Pour manipuler le bus 1-Wire
I2C Pour simuler le protocole I2C
CAN Pour le fonctionnement avec le module CAN
Keypad Pour manipuler un clavier
RS-485 Pour manipuler le module de communication série RS-485
SPI Pour manipuler le module de communication SPI
Manchester Code Pour les communications utilisant le codage type Manchester
74
– Fonctions essentielles des bibliothèques :
Bibliothèque Fonction Description

Lecture du résultat de conversion (10 ou 12 bits) à
ADC ADC_Read(x)
partir du canal spécifié x.
Lcd_Init() Initialisation du module LCD
Lcd_Cmd(x) Envoi de commande x au module LCD
Affiche une chaine de caractère sur l'écran LCD à la
Lcd_Out(l, c, "Chaine")
ligne l et la colonne c.
LCD Affiche une chaine de caractère sur l'écran LCD à la
Lcd_Out_Cp()
position actuelle du curseur.
Lcd_Chr(l, c, ‘y’) Affiche caractère y sur LCD à ligne l et colonne c.
Affiche le caractère y sur l'écran LCD à la position
Lcd_Chr_Cp(‘y’)
actuelle du curseur.
75
PWMx_Init(y) Choix de la fréquence y PWM en Hz sur le canal x.
PWMx_Start() Démarrage du module x PWM.

PWM
PWMx_Stop() Arrêt du module x PWM.
Choix du rapport cyclique PWM (Entre 0 pour 0%
PWMx_Set_Duty(y)
et 255 pour 100%) sur le canal x
Spécifie le débit x de communication série choisi.
UARTx_Init(x)
C’est la première fonction appelée.
Reçoit 1 octet à partir de la broche Rx du port
UARTx_Read
série.
UART
Transmet 1 octet à travers la broche Tx du port
UARTx_Write
configuré en série.
=1 Si données prêtes pour la lecture
UART_Data_Ready()
=0 Si pas de données dans le registre de réception
76
Conversion Analogique Numérique
– Utilisation de l’ADC :
Programme :
/***********************************************************
CONVERTISSEUR A/D du PIC16F876A
=========================
Signal analogique variable appliqué à la broche AN0 du PIC16F876, tandis que le résultat
de conversion sur 10 bits est visible sur les PORTB et PORTC (8 LSB sur le PORTB et 2 MSB
sur le PORTC). Ou uniquement 8 bits sur le PORTB. (Vref- --> GND et Vref+ --> 5V)
Oscillateur : HS, 8 Mhz
***********************************************************/
int temp_res ;
void main()
{
ADCON1 = 0x00 ; // AN0 … AN4(A), Vref+(Vdd), Vref-(Vss)
TRISB = 0 ; // PORTB en sortie
TRISC = 0 ; // PORTC en sortie
while(1) // Boucle sans fin
{
temp_res = ADC_Read(0) ; // Résultat de conversion copié dans temp_res
PORTB = temp_res ; // Envoyer 8 bits LSB au PORTB
PORTC = temp_res >> 8 ; // 2 bits MSB copiés sur RC1, RC0 du PORTC
// Ou PORTB = (int)(temp_res/4) ; // Envoyer les 8 bits sur le PORTB sans PORTC
}
}
77
Paramètres du contrôleur LCD
– Signaux du contrôleur LCD HD44780 (14 broches) :
Broche Appellation Fonction
1 VSS Masse
2 VDD +5 V
3 VEE Contraste
4 RS Registre de sélection
5 R/W Lecture / Ecriture
6 EN Validation
7 D0 bit 0 (Donnée)
78
Paramètres du contrôleur LCD
– Commandes les plus courantes LCD :
Commande LCD Description
_LCD_CLEAR Effacer l'affichage

_LCD_RETURN_HOME Remettre le curseur aux premières ligne et colonne
_LCD_FIRST_ROW Déplacer le curseur vers la première ligne
_LCD_SECOND_ROW Déplacer le curseur vers la deuxième ligne
_LCD_THIRD_ROW Déplacer le curseur vers la troisième ligne
_LCD_FOURTH_ROW Déplacer le curseur vers la quatrième ligne
_LCD_CURSOR_OFF Cacher le curseur
_LCD_BLINK_CURSOR_ON Clignotement du curseur
_LCD_MOVE_CURSOR_LEFT Déplacer le curseur à gauche
_LCD_MOVE_CURSOR_RIGHT Déplacer le curseur à droite
_LCD_SHIFT_LEFT Décaler l'affichage à gauche
_LCD_SHIFT_RIGHT Décaler l'affichage à droite
79
Contrôleur LCD
– Utilisation de l’afficheur LCD :
Programme :
/*********************************************************
AFFICHAGE D'UN TEXTE A L’ECRAN LCD
=========================
Afficheur LCD relié au PIC16F876A (RS-4, EN-5, D4-0, D5-1, D6-2, D7-3).
Programme affichant textes "AFFICHAGE" sur 1 ère ligne et
"display_LCD_4bit" sur 2ème ligne.
Oscillateur : HS, 8 Mhz
*********************************************************/
// Connections du LCD
sbit LCD_RS at RB4_bit ;
sbit LCD_EN at RB5_bit ;
sbit LCD_D4 at RB0_bit ;
sbit LCD_RS_Direction at TRISB4_bit ;
sbit LCD_EN_Direction at TRISB5_bit ;
sbit LCD_D4_Direction at TRISB0_bit ;
// Fin de connections
80
Contrôleur LCD
– Utilisation de l’afficheur LCD :
Programme (Suite) :
…
char txt1[] = "--- AFFICHAGE ---" ;
char txt2[] = "Display_LCD_4bit" ;
void main ()
{
TRISB = 0 ; // Tout le PORTB en sortie
PORTB = 0xFF ;
Lcd_Init() ; // Initialisation du LCD
Lcd_Cmd(_LCD_CLEAR) ; // Effacer l’écran LCD
Lcd_Cmd(_LCD_CURSOR_OFF) ; // Curseur est Off
Lcd_Out(1, 1, txt1) ; // Ecrire 1ier texte sur l-c. 1-2
//Ou Lcd_Out(1, 2, "-- AFFICHAGE --") ;
Lcd_Out(2, 1, txt2) ; // Ecrire 2ème texte sur l-c. 2-1
//Ou Lcd_Out(2, 1, “Display_LCD_4bit") ;
}
81
Paramètres du module USART
– Signaux du Port série (Protocole RS232) :
Un port série en RS232 utilise le connecteur DB9 (9 voies).
Broche Nom Sens Signification

Data Carrier Detect. Active à l'état haut.
1 DCD Entrée
Signale au PC qu'une liaison a été établie avec un correspondant.
Receive Data
2 RxD Entrée
Où transitent les informations du correspondant vers le PC.
Transmit Data
3 TxD Sortie
Ici transitent les données du PC vers le correspondant.
Data Terminal Ready. Active à l'état haut. Le PC signale au
4 DTR Sortie
correspondant que le port série a été libéré et peut être utilisé.
5 GND - Masse.
Data Set Ready. Active à l'état haut.
6 DSR Entrée
Le correspondant signale qu'une donnée est prête.
Request To Send. Active à l'état haut.
7 RTS Sortie
Indique au correspondant que le PC veut transmettre des données.
Clear To Send. Active à l'état haut.
8 CTS Entrée
Indique au PC que le correspondant est prêt à recevoir des données
Ring Indicator. Active à l'état haut. Permet au PC de savoir qu'un
9 RI Entrée
l.bouhouch@uiz.ac.ma correspondant veut initier une communication avec lui.
82
– Paramètres du Protocole RS232 :
USART  Interface de communication (Full duplex) séries entre 2 appareils.
2 fils (Rx et Tx) plus la Masse sont nécessaires.
Format des données envoyées (Trames) en série (bit par bit) :

• Transmission commence lorsque le niveau logique passe de 1 à 0.
• Débit  Vitesse de communication (Bauds ou Bps) : 110, 300, 600,
1200, 2400, 4800, 9600, 19200, 38400, etc.
• Start  1ier bits envoyés (1) : Bit(s) de départ de niveau logique 0.
• Data  Suite de 7 ou 8 bits de données envoyées suivie par 1 ou 0 bit
de parité Parity.
• Stop  Dernier bit envoyé : 1 ou 2 bit d'arrêt de niveau logique 1.
83
 Exemple de trame de caractère "A" envoyée en série :
1 Start + 8 Data + 0 ou 1 Parity + 1 Stop.
(01000001)2 = 0x41 = Code ASCII de "A"
Après "Start", le bit envoyé = le LSB de la donnée "01000001".
Parité
<Non>
Parité
Paire
Parité
Impaire
84
Module USART
– Utilisation de l’UART :
Programme :
/*************************************************************
LECTURE ET ÉCRITURE DE PORT SERIE
=========================
PIC16F876A : Tx  RC6 et Rx  RC7. Débit de transmission = 9600 Bps.
Caractère reçu à partir du terminal est renvoyé vers le terminal.
En plus Led sur RC0 s’allume puis s’éteint pour chaque frappe au clavier.
Oscillateur HS : 8 Mhz
*************************************************************/
char Octet_Lu ; // Variables globales
void main()
{
TRISC = 0x80 ; // 1000 0000 --> PORTC en sortie sauf bit 7
PORTC.F0 = 1 ; // Led reliée à RC0 éteinte
UART1_Init(9600) ; // Configuration RS232  9600 Bps

Delay_ms(100) ; // Petite pause pour établir la communication
UART1_Write_Text("Connexion etablie") ; // Envoi du texte vers l’UART

UART1_Write(13) ; // Retour chariot (CR  0x0D)
UART1_Write(10) ; // Début de ligne (LF  0x0A)
85
Module USART
Programme (Suite) :
…
while(1) // Boucle infinie
{
if (UART1_Data_Ready() == 1) // Si la connexion est établie
{
PORTC.F0 = 0 ; // Led reliée à RC0 allumée
Delay_ms(100) ;
Octet_Lu = UART1_Read() ; // Données reçues via UART
UART1_Write(0x20) ; // Espace (SP  0x20)
UART1_Write(Octet_Lu) ; // Renvoyer la donnée reçus
UART1_Write(0x0D) ; // Retour chariot (CR  0x0D)
} // Fin de If
Delay_ms(100) ;
} // Fin de Boucle while
} // Fin du main
86
Modules CCPx
– Utilisation du PWM :
Programme :
/*************************************************************
Utilisation du module CCP1 du PIC16F876A en mode PWM
====================================
Générateur du signal PWM par le module CCP1.
La largeur des impulsions à la sortie du CCP1 (RC2) peut être variée avec le
bouton poussoir BP marqué "AUGMENTER".
Oscillateur HS : 8.0000 Mhz
*************************************************************/
void main()
{
unsigned short RappCyclique ; // Déclaration de variable RappCyclique
TRISC = 0x80; // PORTC configuré en sortie sauf le bit 7
PWM1_Init(2000); // Initialisation du module PWM (2 KHz)
RappCyclique = 100 ; // Initialisation de variable RappCyclique
PWM1_Start() ; // Démarrage du module CCP1
…
87
Modules CCPx
– Utilisation du PWM :
Programme (Suite) :
…
{
// Si le BP est pressé ==> Incrémente RappCyclique
if (PORTC.F7 == 0) RappCyclique++ ;
// Ou bien if (Button(&PORTC, 7,1,0)) RappCyclique++ ;
PWM1_Set_Duty(RappCyclique) ; // Charger PWM avec nvlle. valeur
if (RappCyclique > 255) RappCyclique=0 ; // Raz de RappCyclique
Delay_ms(20); // Tempos de 20ms
} // Fin de boucle while
} // Fin de main
88
Rappels sur Interruption Timer
PIC16F84  Sources d'interruption TMR0
 Cause débordement du Compteur/Temporisateur.
89
– Registres OPTION_REG
• INTEDG (Interrupt Edge) : Front actif (1 pour montant) qui provoquera une interruption
sur la borne RB0 (si interruption activée).
• T0CS (TMR0 Clock Source) : Source utilisée par le Timer (0 : horloge interne, 1 : RA4).
• T0SE (TMR0 Source Edge) : Front actif sur RA4 qui fait avancer le compteur
(0 : front montant)
• PSA (Prescaler assignment) : 0 pour Timer0 et 1 pour chien de garde WDT.
• PS2 ... 0 (Prescaler) : Valeur du Diviseur de fréquence pour les Timers.
Valeur des Diviseur Diviseur Valeur des Diviseur Diviseur

Bits (TMR0) (WDT) Bits (TMR0) (WDT)
000 1:2 1:1 100 1 : 32 1 : 16
001 1:4 1:2 101 1 : 64 1 : 32
010 1:8 1:4 110 1 : 128 1 : 64
011 1 : 16 1:8 111 1 : 256 1 : 128
90
– Registre INTCON
 INTCON : Masque d'interruptions.
* GIE (Global lnterrupt Enable)  Mis à 1  Autorise toutes les interruptions non
masquées par leur bit individuel.
* T0IE (Timer 0 lntmupt Enable)  Mis à 1  Autorise les interruptions dues au
débordement du Timer 0.
* T0IF (Timer 0 lnterrupt Flag)  Mis à 1 si débordement du Timer 0.
91
Timer & Interruptions
– Utilisation de TMR0 :
Programme :
/**********************************************************************
Chenille à LEDs (PIC16f876A - Version AVEC INTERRUPTIONS)
===================================
8 LEDs connectées au PORTC et qui s'allument en alternance. Oscillateur XT : 4 Mhz
**********************************************************************/
unsigned short cmpt=0 , J = 1 ; // 128 si Décalage Droite

void interrupt() // Fonction d’Interruption
{
INTCON.T0IF = 0 ; // Raz du Flag dû au débordement de TMR0
cmpt++ ; // Compteur des débordements du TMR0
if (cmpt == 50)
{
PORTC = J ; // Envoyer J au PORTC
J = J << 1 ; // Décalage Gauche de J (>> Si Déc. Droit)
if (J == 0) J = 1 ; // Si Led8  RUN de J  Allume Led1 (128 si Décalage Droite)
cmpt=0 ;
}
}
92
Timer & Interruptions
– Utilisation de TMR0 :
Programme (Suite) :
…
void main()
{
TRISC = 0 ; // PORTC en sortie
PORTC = 0 ; // Eteindre Leds
// Autoriser Interruptions Timer (GIE PEIE T0IE INTE RBIE T0IF INTF R0IF)
INTCON = 0b10100000 ;
// Pré-diviseur Tmr0 = 16 (RBPU INTEDG T0CS T0SE PSA PS2 PS1 PS0 )
OPTION_REG = 0b00000011 ;
while (1)
{ /* effectuer ce qu’on veut */ }
}
93
Acquisition et Transmission Série de données
94
Généralités
– Exemples de Bus Série :

SATA, Ethernet , RS485, RS232, I2C, SPI, CAN, USB, 1 WIRE, …
Multipoints
Point à Point
95
Généralités
– Bus courants dans les systèmes embarqués :

RS232 :
- Bus Lent (9600 – 115200 bps), Full-duplex, Point à Point
- Courant dans les systèmes embarqués
RS485 :
- Rapide, Différentiel, Half-duplex, Multipoints
CAN :
- Bus Semi-rapide (1 Mbps), Multi-maîtres, …
- Peu sensible au bruit, …
- Variante : LIN, FlexRay, …
I2C (Philips) :
- Relativement Lent (400 Kbps), Half-duplex, Multi-Maîtres,
Multipoint, …
- Variante : SMBUS, DDC, TWI, …
96
Généralités
– Bus courants dans les systèmes embarqués :
SPI :
- Bus Assez rapide (10 Mbps), Full-duplex, …
- 1 Maitre - n Esclaves (Mélange Point à Point & Multipoints), …
- Variante : I2S, …
- Utilisation : Flash EEPROM, EEPROM, MMC/SD, Ethernet, Son,
LCD, Capteurs, …
1 WIRE (Dallas Semiconductor) :
- Bus Lent (16 ou 144 Kbps), Half-duplex, …
- 1 Maitre - n Esclaves (Mélange Point à Point & Multipoints), …
- peu sensible au bruit, …
- Utilisation : Domotique, Thermométries, Instruments de mesure
météorologiques, Horloge temps-réel, Circuits de gestion de l'énergie,
Batteries, Onduleurs, …
USB :
- Bus multi-vitesse (LS, FS, HS), Différentiel, …
- 1 Maitre - n Esclaves, …
- Très courant
97
RS232
– Signaux du Port série (Protocole RS232) :
Un port série en RS232 utilise le connecteur DB9 (9 voies).
Broche Nom Sens Signification

Data Carrier Detect. Active à l'état haut.
1 DCD Entrée
Signale au PC qu'une liaison a été établie avec un correspondant.
Receive Data
2 RxD Entrée
Où transitent les informations du correspondant vers le PC.
Transmit Data
3 TxD Sortie
Ici transitent les données du PC vers le correspondant.
Data Terminal Ready. Active à l'état haut. Le PC signale au
4 DTR Sortie
correspondant que le port série a été libéré et peut être utilisé.
5 GND - Masse.
Data Set Ready. Active à l'état haut.
6 DSR Entrée
Le correspondant signale qu'une donnée est prête.
Request To Send. Active à l'état haut.
7 RTS Sortie
Indique au correspondant que le PC veut transmettre des données.
Clear To Send. Active à l'état haut.
8 CTS Entrée
Indique au PC que le correspondant est prêt à recevoir des données
Ring Indicator. Active à l'état haut. Permet au PC de savoir qu'un
9 RI Entrée
l.bouhouch@uiz.ac.ma correspondant veut initier une communication avec lui.
98
RS232
USART (Port Série)  Interface de communication (Asynchrone) séries entre 2 app.
2 fils (Rx et Tx) plus la Masse sont nécessaires.
• Repos (Mark) : 1, -3 V à -15 V

• Actif (Space) : 0, +3 V à +15 V
Format des données envoyées (Trames) en série (bit par bit) :

• Transmission commence lorsque le niveau logique passe de 1 à 0.
• Débit  Vitesse de communication (Bauds ou Bps) : 110, 300, 600, 1200,
2400, 4800, 9600, 19200, 38400, 57600, 115200, etc.
• Start  1ier bits envoyés : Bit de départ de niveau logique 0.
• Data  Suite de 7 ou 8 bits de données envoyées suivie par 1 bit de parité
• Parity   Détection d’erreur : 0 ou 1 bit.
• Stop  Dernier(s) bit(s) envoyé(s) : 1 ou 2 bits d'arrêt de niveau logique 1.
99
RS232
 Exemple de trame envoyée en série :
1 Start + 8 Data + 0 Parity + 1 Stop.
100
 Exemple de trame de caractère "A" envoyée en série :
1 Start + 8 Data + 0 ou 1 Parity + 1 Stop.
(01000001)2 = 0x41 = Code ASCII de "A"
Après "Start", le bit envoyé = le LSB de la donnée "01000001".
Parité
<Non>
Parité
Paire
Parité
Impaire
101
Bibliothèque UART de MikroC for PIC
Spécifie le débit y de communication série choisi.
UARTx_Init(y)
C’est la première fonction appelée sur le module x.
Le module x Reçoit 1 octet à partir de la broche Rx
UARTx_Read()
du port série.
UART
Le module x Transmet un octet à travers la broche
UARTx_Write
Tx du port configuré en série.
=1 Si données prêtes pour la lecture
UART_Data_Ready()
=0 Si pas de données dans le registre de réception
Programme de l’UART en MikroC 102
Programme :
/*************************************************************
LECTURE ET ÉCRITURE DE PORT SERIE
=========================
PIC16F876A : Tx  RC6 et Rx  RC7. Débit de transmission = 9600 Bps.
Caractère reçu à partir du terminal est renvoyé vers le terminal.
En plus Led sur RC0 s’allume puis s’éteint pour chaque frappe au clavier.
Oscillateur HS : 8 Mhz
*************************************************************/
char Octet_Lu ; // Variables globales
void main()
{
TRISC = 0x80 ; // 1000 0000 --> PORTC en sortie sauf bit 7
UART1_Init(9600) ; // Configuration RS232  9600 Bps

Delay_ms(100) ; // Petite pause pour établir la communication
UART1_Write_Text("Connexion etablie") ; // Envoi du texte vers l’UART

UART1_Write(13) ; // Retour chariot (CR  0x0D)
UART1_Write(10) ; // Début de ligne (LF  0x0A)
Programme (Suite) :
…
while(1) // Boucle infinie
{
if (UART1_Data_Ready() == 1) // Si la connexion est établie
{
PORTC.F0 = 0 ; // Led reliée à RC0 allumée
Delay_ms(100) ;
Octet_Lu = UART1_Read() ; // Données reçues via UART
UART1_Write(0x20) ; // Espace (SP  0x20)
UART1_Write(Octet_Lu) ; // Renvoyer la donnée reçus
UART1_Write(0x0D) ; // Retour chariot (CR  0x0D)
} // Fin de If
Delay_ms(100) ;
} // Fin de Boucle while
} // Fin du main
Bus CAN 105
– Introduction au Bus CAN :

Bus CAN (Controller Area Network) :
Bus de communication série développé à la fin des années 80 par
l'entreprise Robert Bosch.
Objectif :
Fournir à l'industrie automobile un Bus peu coûteux pour
l'électronique embarquée (éviter les encombrants des câbles).
Efficacité et Robustesse du protocole Bus CAN :
Utilisé dans plusieurs applications industrielles nécessitant un débit
important jusqu'à 1 Mbits/s avec un très faible taux d'erreur.
Bus CAN devenu un standard international reconnu par l'ISO en 1994.

Protocole et paramètres électriques de ligne de transmission :
Fixés par la Norme 11898.
Transmission physique :
par Paire Torsadée ou
par liaison Infrarouge, Hertzienne ou par Fibre Optique.
Bus CAN 106
– Introduction au Bus CAN :

Contrôle Suspension
Moteur Clim
Réduction des Sièges
coûts de câblage Tableau
et de maintenance de Bord Plafonnier
Boite de
ABS Centralisation
Vitesses
Tableau
Contrôle Suspension de Bord
Moteur Clim Sièges
Contrôleur Contrôleur
Contrôleur CAN Contrôleur CAN CAN CAN Contrôleur CAN Contrôleur CAN
CAN high speed CAN low speed

Contrôleur CAN Contrôleur CAN Contrôleur CAN Contrôleur CAN
Boite de Centralisation Plafonnier
ABS
Vitesses
Question câblage :
 R25 (fin 80’s) : 2 km de câbles cuivre ! >80kg
Conséquences de réduction du câblage
 40% de poids pour une portière Mercedes
 40% de longueur de câble pour les Peugeot 306 et 307
Bus CAN 107
– Description :
Bus CAN : Stations de mêmes droits (organes de commande,

capteurs ou actionneurs) sont reliées par un Bus série.
Le protocole CAN de base permet d'échanger 2048 variables.

Bus CAN 108
– Topologie du réseau :
• Topologie d'un réseau CAN : Le BUS

• Résistances de Terminaison RT (120 à 180 W) : placées aux
extrémités du câble de transmission.
• A 1 Mbits/s les dérivations (Stubs) ne dépassent pas 30 cm.
Bus CAN 109
 Longueur du médium
• Longueur max. dépend du retard accumulé lors de transmission :
Temps de Propagation + Temps de Traitement matériel.
Débit ou Vitesse de propagation Longueur

1 Mbit/s 40 m
500 Kbit/s 100 m
250 Kbit/s 250 m
100 Kbit/s 500 m
20 Kbit/s 1000 m
Configurations recommandées
en fonction de la Vitesse de transmission.
Bus CAN 110
 Nombre de nœuds fonction de :

• Technologie du driver de ligne et
• Type de câble
Type de câble n = 32 n = 64 n = 100

Thin cable L = 200 m L = 170 m L = 150 m
Thick cable L = 800 m L = 690 m L = 600 m
AWG 20/ 0.5 mm² L = 360 m L = 310 m L = 270 m
AWG 18/0.75 mm² L = 550 m L = 470 m L = 410 m
n = Nombre de nœuds
L = Longueur maximum du support de transmission.
Bus CAN 111
– Format des Trames de données du Bus CAN :

 Norme CAN  2 formats de protocole :
 Standard (Version 2.0 A) et
 Extended (Version 2.0 B).
• Différence :
 longueur ID (Identificateur) : 11 bits de base
 18 bits supplémentaires en mode Extended.
 Augmenter le nombre de variables échangées, et
 Nombre de stations sur le réseau.
Bus CAN 112
 Composition de la trame :
Bus CAN 113

 Composition de la trame :
2.0A
2.0B
 SOF (Start Of Frame) :

 1 Bit de Début de Trame.
 Mis à 0 par la station débutant la transmission Si Bus libre.
Bus CAN 114
2.0A
2.0B
Zone d’Arbitrage :
 Format « Standard » (Version 2.0A) :
 11 Bits +
 1 Bit RTR (Remote Transmission Request) :
• RTR = 0 Si Trame de Données ou
• RTR = 1 Si Trame de Demande de message.
Bus CAN 115

2.0A
2.0B
Zone d’Arbitrage :
 Format « Étendu » (Version 2.0B) :
 29 Bits (11+18) +
 1 Bit SRR (Substitute Remote Request) ;
se substitue au bit RTR en Standard.
 1 Bit RTR (Remote Transmission Request).
Bus CAN 116

2.0A
2.0B
 Champ de Contrôle :
 1 Bit IDE : Distinction entre formats Standard et Étendu

• IDE = 0 Si Format Standard ou
• IDE = 1 Si Format Étendu.
 4 Bits DLC (en Standard & Étendu) :
Taille en Nombre d’Octets contenus dans la zone de Données +
 1 Bit r0 = 0 (en Standard & Étendu) : Réservé pour utilisation Future.
 1 Bit r1 = 0 (en Étendu) : Réservé pour utilisation Future.
Bus CAN 117

2.0A
2.0B
 Champ de Données :
 0 à 8 Octets : Longueur de Donnée
 Champ du CRC (Cyclic Redundancy Code) :
 16 Bits Recalculés à la Réception et Comparés aux bits Reçus.
Si différents  Erreur CRC est déclarée.
 Champ ACK (ACKnowledge) ou ACQ (ACQuitement) :
 1 Bit à l'état récessif +
 1 Bit séparateur ou Délimiteur.
 Champ EOF (End Of Frame) :
 7 Bits identifiant la Fin de Trame.
Bus CAN 118
– Principe d’Arbitrage :
 Traiter les données en Temps réel  Transmission rapide.
 Voie physique de transmission atteignant 1 Mbit/s +
Assignation rapide du bus s’il y a des conflits.
 L’Urgence d’informations Échangées sur Bus peut être très diverse :

 Valeur Variant rapidement (État d'un Capteur, Asservissement d'un
moteur, …) : transmission avec un retard moindre,
 Autres valeurs Évoluent lentement (Température d’un moteur, …).
 Nécessité d’un Arbitrage pour libérer ou occuper le Bus.
 Identificateur de message (11 bits ou 29 bits), détermine sa Priorité.
Bus CAN 119
 Procédé d'attribution du bus :

 Basé sur le principe de L’ "Arbitrage bit à bit".
 Nœuds en Compétition, émettant simultanément sur le bus,
 Comparent bit à bit l’Identificateur de leur message avec celui
des messages concurrents.
 Stations de Priorité Moins Élevées Perdrons la compétition
face à celle qui a la Priorité la Plus Élevée.
Bus CAN 120
 Définitions :
 "État Dominant" : État logique 0
 "État Récessif" : État logique 1
 En cas de Conflit ( Émission Simultanée) : 0 écrase 1.
 Lors de l’Arbitrage bit à bit,

 Dès qu'une station Émettrice en État Récessif, si elle
 Détecte un État Dominant, elle Perd la compétition
 Arrête d'émission.
 Tous les Perdants deviennent des Récepteurs (Listening only),

Ne tentent à nouveau d’Émettre que lorsque le Bus se libère.
Bus CAN 121
 Exemple : 3 stations émettent en même temps :
 Qui gagne l’arbitrage ?
Station 1 1 1 0 0 1 0 1 1 1 0écoute
1 1
Station 2 1 1 0 0 1 1 0 0 écoute
1 0 1 0
Station 3 1 1 0 0 1 0 1 1 0 1 0 1
Signal
sur le 1 1 0 0 1 0 1 1 0 1 0 1
bus
La station 2 perd la compétition

La station 1 perd la compétition
La station 3 gagne la compétition donc l’accès au bus
Bus CAN 122
 Autre exemple :
1
0
 Station en Etat Récessif qui Détecte un État Dominant,

Perd la compétition
 Elle Arrête d'émettre.
123
Bus I2C : Présentation
I2C (Inter-Integrated Circuit-Communication)  Bus de communication série synchrone.
Electriquement :
2 fils (SCL "Serial Clock" / SDA "Serial Data"), collecteur ouvert.
Repos (Etat 1) : 3.3 à 5V Niveau électrique Récessif.
Actif (Etat 0) : 0V Niveau électrique Dominant.
Bus libre : Les 2 fils sont au Niveau 1.
124
Bus I2C : Protocole
Le maître impose l'horloge sur la ligne SCL et transmet les adresses
Condition de départ et d’Arrêt :
- Si Transition sur SDA lorsque SCL = 1  Start ou Stop
Remarque :
Les conditions de départ et d’arrêt sont toujours générées par le maître du bus.
125
Bus I2C : Protocole
Echange de trames de données:
- Transition possible sur SDA uniquement lorsque SCL = 0  Donnée
Les esclaves ne font que répondre par le mécanisme de requête/réponse.
Après Start  7 bits d’Adresse unique
Ensuite le 8ème bit = R/W : Indique la direction du transfert
Adresse : Partie fixe (Firmware) + Partie configurable (User Address)
R/W = 0  Ecriture  Maitre Parleur et Esclave Écouteur : Donnée envoyée à
esclave par le Maître.
R/W = 1  Lecture  Maitre Écouteur et Esclave Parleur : Esclave revoie une
donnée au Maître.
La transmission se fait MSB first.
126
Bus I2C : Protocole
Exemple :
En général chaque CI possède 3 broches A2, A1 et A0 de sélection d‘adresse basse.
Broches de sélection  Placer jusqu'à 8 CI de fonction identique sur le bus.
Cas d'EEPROM I2C 64 Kbits type 24C64 possède l'adresse 1010xxx.
Adresse choisie en fonction des niveaux logiques appliqués sur broches A2, A1, A0.
Exemple : En reliant A0 à 5V et A1 et A2 à 0V, le CI répondra à l'adresse I2C
1010001.
(Firmware) (User Address)
127
Bus I2C : Cas général de Communication
– Transmission d'un octet :
A chaque impulsion sur SCL, 1 bit est transmis correspondant au niveau de SDA.
Cette opération est répétée pour les 8 bits.
Le bit de poids fort est transmis en premier.
128
– Acquittement :
Après les 8 bits transmis, le récepteur acquitte la transmission au 9ème bit.
L’émetteur met sa ligne SDA au niveau Haut.
Le récepteur met sa ligne au niveau Bas.
Or sorties à collecteur ouvert  Le récepteur l’emporte, SDA sera au niveau Bas.
Au coup d’horloge suivant, 2 possibilités :
- Le maitre voit un niveau Bas  Octet bien reçu.
- Le maitre voit un niveau Haut  Erreur de transmission donc arrêt.
129
– Exemple de Trame :
Envoi de l’octet 0xB5 = (1011 0101)
1 0 1 1 0 1 0 1
SDA doit être stable aussi longtemps que le signal SCL est actif.
Changement d'état de SDA pendant que SCL est au niveau Haut  Condition de
départ ou d'arrêt.
130
– Transmission d'une adresse :
1ier octet transmis est une adresse correspondant à l’esclave choisi.
Bit A0 de l’adresse est réservé :
- Si R/W = 1  Maître demande une Lecture à l'esclave.
- Si R/W = 0  Maître demande une Ecriture à l'esclave.
131
– Écriture d'une donnée :
Si bit R/W de l’adresse = 0  Maître doit transmettre 1 ou plusieurs octets de
données.
Après chaque bit ACK valide, le maître peut soit :
- Continuer d'envoyer des octets à l'esclave.
- Décider de terminer le dialogue par une condition d'arrêt.
132
– Lecture d'une donnée :
Si bit R/W de l’adresse = 1  Maître veut lire des données issues de l'esclave.
Toujours maître génère signal d'horloge SCL.
Esclave prend le contrôle de la ligne SDA.
Après que l'esclave ait transmis les 8 bits de données  Maître génère le bit ACK.
2 possibilités d’acquittement :
- Bit ACK = 0  Maître désire lire des octets supplémentaires.
- Bit ACK = 1  Maître décide que lecture terminée.
(ACK = 1  Pas d'erreur mais fin de transfert).
133
– Restart :
Possible d'enchaîner écriture et lecture de l'esclave sans passer par condition arrêt.
Restart permet de lire une donnée après écriture sans générer de stop entre les 2.
– Conflits et prise de contrôle du bus :

Si 2 maitres parlent en même temps, il y a possibilité de conflits.
Un maitre relit à chaque fois le bit qu’il cherche à imposer sur le bus.
S’il impose un 0, il relira obligatoirement un 0.
S’il impose un 1  2 cas :
- S’Il relit un 1  il continue à transmettre.
- S’il relit un 0  un autre maitre a pris la parole, il perd le contrôle du bus.
Cas rare: Si divers maitres envoient mêmes données simultanément  Pas de conflit
Bus I2C : Exemple d’Esclave EEPROM 134
– Présentation et connexions :
Certains PIC possèdent une interface I2C intégrée.
Lignes SCL et SDA sont connectées respectivement à RC3 et RC4.
– Exemple de circuit 24C04 :

24C04 : EEPROM série constituée de 2 blocs de 256 Ko utilisant le protocole I2C.
Bus I2C - Exemple d’Esclave EEPROM 135
– Eléments constitutifs de la trame I2C :

 devsel : Octet d'identification
 1ier octet émis par le maître : Permet de sélectionner le circuit ainsi que la nature
des opérations à effectuer (R/W).
- Bits 7 à 2 : ID du circuit (partie fixe = 1010 (bits 7 à 4) et
partie variable (bits 3 et 2) fixée par les états logiques des broches E2 et E1.
- Bit 1 : Accès à un des 2 blocs de 256 Ko.
- Bit 0 : Sélectionne le mode Lecture (1) ou mode Ecriture (0).
Exemple :
Soit à écrire dans le bloc 0 d'un circuit 24C04 dont les pattes E2 et E1 sont
connectées respectivement à 1 et à 0.  1ier mot à envoyer sera 10101000.
 addr : Octet d'adresse

- Mot indiquant l'adresse à laquelle doivent s'effectuer la lecture ou l’écriture.
 data : Octet de donnée
- Mot indiquant la donnée à lire ou écrire.
– Algorithme d'écriture (mode direct) :

Donnée rangée à l'adresse spécifiée par l'octet addr
 Trame envoyée par le maître :
– Algorithme d'écriture (mode séquentiel) :

Une fois l'adresse spécifiée, les données ont inscrites aux adresses
suivantes tant que la condition de stop n'est pas envoyée.
– Algorithme de lecture (mode direct) :

 Lecture : D’abord envoyer l'adresse au circuit en mode écriture. Puis
repositionner le circuit en mode lecture afin d'obtenir la (les) donnée(s).
– Algorithme de lecture (mode séquentiel) :

En mode séquentiel, après réception d'une donnée, le bit ACK est forcé à 0
par le maître lorsqu'il désire une nouvelle donnée.
138
Module Arduino
139
Généralités sur les modules Arduino
 Les modules Arduino™ sont des plates-formes de prototypage micro
contrôlées "open-source".
 Programmables via un langage proche du "C" (disponible en libre
téléchargement), les modules Arduino™ peuvent fonctionner de façon
autonome.
 Leur taille physique est standardisée.
 Un nombre important de cartes filles sont disponibles

(Shield).
 Le logiciel de programmation : gratuit et open source, développé en

Java doté d’une grande simplicité d'utilisation.
 Le matériel : cartes électroniques dont les schémas sont en libre
circulation sur internet.
140
Arduino UNO
Microcontrôleur : ATmega328P
Tension de fonctionnement : 5V
Tension d'alimentation (Recommandée) : 7-12V
Tension d'alimentation (Limites) : 6-20V
Broches E/S numériques : 14 (dont 6 disposent de sortie PWM)
Broches d'entrées analogiques : 6
Intensité maxi disponible par broche E/S (5V) : 20 mA
Intensité maxi disponible par broche E/S (3.3V) : 50 mA
Mémoire Programme Flash : 32 KB dont 0.5 KB utilisés par le Bootloader
Mémoire SRAM (mémoire volatile) : 2 KB
Mémoire EEPROM (mémoire non volatile) : 1 KB
Vitesse d’horloge : 16 MHz
Dimensions : 53 mm x 68 mm
Broches d’Arduino UNO 141
* SPI : Interface Série pour périphérique D10 : /SS D11 : MOSI D12 : MISO et D13 : SCLK.
AREF
Tension de
Port SPI*
référence
analogique D10 – D13
Port Série
E/S digitales D0 – D13 D0 – D1
(Tx & Rx)
Port USB de Programmation

permettant d’alimenter
l’Arduino. Max 500 mA
Port de
Programmation
ISP
Port I2C*
A4 – A5
Entrée DC 7-12 V
2,1 mm
* I2C : A4 (SDA), A5 (SCL)
Alimentations Entrées Analogiques A0 – A5
142
Description E/S : ATMEGA 328
143
IDE de programmation Arduino
L’IDE (Espace de développement Intégré)
permet d’écrire, compiler et Barre de Menu
transférer un programme (Sketch) Barre de Boutons
vers la carte Arduino par l’USB. Onglets des fichiers ouverts
Logiciel gratuit disponible à :

http://arduino.cc/en/Main/Software
Extensions de fichier, selon les versions:

o .PDE
Fenêtre d’édition
o .INO
des programmes
Vérifier / Compiler
Nouveau code
Sauver fichier
Zone de messages des actions en cours

Ouvrir Moniteur Série
Ouvrir fichier Console d’affichage des
messages de compilation
Transférer programme
vers la carte Arduino
144
Programmation Arduino
Fonctions du code Arduino :
Essentiellement dans le code Arduino on trouve 2 fonctions :
 Configuration
 La fonction setup() exécutée en 1ier, une seule fois dès que le programme fonctionne.
On appelle cette fonction : "Fonction d'initialisation ou de configuration".
 Mise en place des différentes Entrées et/ou Sorties et autres réglages.
void setup()
{
// Insérer ici votre code de configuration ou d’initialisation
 Boucle infinie – Programme pricncipal

 La fonction loop() où l'on écrit le contenu du programme.
Cette fonction est bouclée infiniment.
void loop()
{
// Insérer ici le code de la fonction principale bouclante
}
145
Types de variables les plus répandus :
Quel nombre il Valeurs maximales Nombre de Nombre
Type
stocke ? du nombre stocké X bits d'octets
int Entier -32 768 à +32 767 16 2
long Entier -2 147 483 648 à +2 147 483 647 32 4
char Entier -128 à +127 8 1
float Décimale -3.4 x 1038 à +3.4 x 1038 32 4
double Décimale -3.4 x 1038 à +3.4 x 1038 32 4
Si une variable ne prend jamais de valeur négative, alors utiliser un type non-signé.
 unsigned
Quel nombre il Valeurs maximales Nombre de Nombre
Type
stocke ? du nombre stocké X bits d'octets
unsigned char Entier non négatif 0 à 255 8 1
unsigned int Entier non négatif 0 à 65 535 16 2
unsigned long Entier non négatif 0 à 4 294 967 295 32 4
byte Entier non négatif 0 à 255 8 1
word Entier non négatif 0 à 65 535 16 2
boolean Entier non négatif 0à1 8 1
146
– Références :
Structure
Fonctions de base : Opérateurs arithmétiques : Opérateurs de comparaison :
2 fonctions obligatoires dans tout • = (égalité) • == (égal à)
programme en C Arduino: • + (addition) • != (différent de)
• void setup() • - (soustraction) •< (inférieur à)
• void loop() • * (multiplication) •> (supérieur à)
• / (division) • <= (inférieur ou égal à)
Structures de contrôle : • % (modulo) • >= (supérieur ou égal à)
• if
• if ... else Opérateurs booléens :
•
Opérateurs composés :
for • && (ET booléen)
• switch … case • ++ (incrémentation)
• || (OU booléen)
• while • -- (décrémentation) (à revoir)
• ! (NON booléen)
• do ... while • += (addition composée)
• break Opérateurs bit à bit : • -= (soustraction composée)
• continue • *= (multiplication composée)
• return • & (ET bit à bit)
• /= (division composée)
• goto • | (OU bit à bit)
• &= (ET bit à bit composée)
• ^ (OU Exc. bit à bit)
• |= (OU bit à bit composée)
Syntaxe de base : • ~ (NON bit à bit)
• ; (point virgule) • << (décalage à gauche)
• {} (accolades) • >> (décalage à droite)
• // (commentaire sur 1 ligne)
• /* … */ (commentaire sur
plusieurs lignes)
• #define
• #include
147
– Références (Suite) :
Variables et constantes Types des variables
Variables utilisées pour stocker des valeurs Peuvent être de type variés décrits ci-dessous :
Exemple: Tension de sortie d'un capteur présente • boolean
sur une broche analogique. • char
• byte
Constantes prédéfinies du langage Arduino : • int
Valeurs particulières ayant • unsigned int
une signification spécifique. • long
• unsigned long
• float (nombres à virgules)
• HIGH | LOW
• double (nombres à virgules)
• INPUT | OUTPUT
• Chaînes de caractères
• true | false
• Tableaux de variables
• void (fonctions)
Conversion de types
• char()
• byte()
• int()
• long()
• float()
148
– Références (Suite) :
Fonctions
Entrées/Sorties Numériques Temps Trigonométrie
• pinMode(broche, mode) • unsigned long millis() • sin(rad)
• digitalWrite(broche, valeur) • unsigned long micros() • cos(rad)
• int digitalRead(broche) • delay(ms) • tan(rad)
• delayMicroseconds(us)
Entrées analogiques Nombres randomisés
• int analogRead(broche) Math (hasard)
• min(x, y) • randomSeed(seed)
Sorties "analogiques" • max(x, y) • long random(max)
(Génération d'impulsion PWM) • abs(x) • long random(min, max)
• constrain(x, a, b)
• analogWrite(broche, valeur)
• map(valeur, fromLow, toLow, Communication
fromHigh, toHigh) • Serial
Entrées/Sorties Avancées • pow(base, exposant)
• tone() • sq(x)
• noTone() • sqrt(x)
• shiftOut(broche, BrocheHorloge,
OrdreBit, valeur)
• unsigned long pulseIn(broche,
valeur)
149
– Libraires (Micros programmes) :
Pour chaque interface il existe des librairies facilitant l’élaboration d’applications.
Librairies à télécharger et copier dans le dossier arduino/libraries/
Exemple : Librairie pour lire ou écrire sur une carte SD.
#include <byteordering.h>
#include <fat.h>
#include <FAT16.h>
#include <fat_config.h>
#include <partition.h>
#include <partition_config.h>
#include <sd-reader_config.h>
#include <sd_raw.h>
#include <sd_raw_config.h>
150
– Exemple : Lecture d’Entrées digitales avec
Ecriture sur des Sorties digitales
const int Led1 = 2 ; // Broche 2 nommée Led1
const int BP1 = 12 ; // Broche 12 nommée BP1
void setup()
{
pinMode(Led1, OUTPUT) ; // Led1 est une broche de sortie
pinMode(BP1, INPUT); // BP1 est une broche d’entrée
}
void loop()
{
if(digitalRead(BP1)==HIGH) digitalWrite(Led1, LOW) ; // Si BP1 est enfoncé  Allume Led1
else digitalWrite(Led1, HIGH) ; // Sinon on éteint Led1


// Temporisation de 50 millisecondes
delay(50) ;
}
151
– Exemple : Ecriture sur une sortie analogique pour commander une
LED Tricolore
// Définition des broches utilisée
const int led_verte = 9 ;
const int led_bleue = 10 ;
const int led_rouge = 11 ;
// Variable permettant de changer de couleur

int compteur_defilement = 0 ;
void setup()
{
// Définition des broches en sortie
pinMode(led_rouge, OUTPUT) ;
pinMode(led_verte, OUTPUT) ;
pinMode(led_bleue, OUTPUT) ;
}
void loop()
{
couleur(compteur_defilement) ; // Appel de la fonction d'affichage
compteur_defilement++ ; // Incrémentation de la couleur à afficher
if(compteur_defilement > 6)
compteur_defilement = 0 ; // Raz Si le compteur dépasse 6 couleurs
delay(500);
}
152
LED multicolore (SUITE)
void couleur(int numeroCouleur)
{
switch(numeroCouleur)
{
case 0 : // Rouge
analogWrite(led_rouge, 0); // Rapport cyclique au minimum pour une meilleure luminosité de la LED
// qui est commandée en "inverse"
// (0  LED Allumée ; 255  LED Eteinte)
analogWrite(led_verte, 255);
analogWrite(led_bleue, 255);
break;
case 1 : // Vert
analogWrite(led_rouge, 255);
break;
case 2 : // Bleu
break;
case 3 : // Jaune
break;
153
LED multicolore (SUITE)
case 4 : // Violet
break;
case 5 : // Bleu ciel
break;
case 6 : // Blanc
break;
default : // "Noir"
break;
}
}
154
– Exemple : Lecture de tension appliquée sur une broche analogique
const int potar = 0 ; // Potentiomètre branché sur la broche analogique 0
int valeurLue ; // Variable pour stocker la valeur lue après conversion AN
float tension ; // On convertit cette valeur en une tension
void setup()
{
// Démarrage de la liaison série pour visualiser la valeur
Serial.begin(9600) ;
}
void loop()
{
// On convertit en nombre binaire la tension lue en sortie du potentiomètre
valeurLue = analogRead(potar) ;
// On traduit la valeur brute en tension

tension = valeurLue * 5.0 / 1024 ;
// On affiche la valeur lue sur la liaison série

Serial.print("valeurLue = ") ;
Serial.println(valeurLue) ;
// On affiche la tension calculée

Serial.print("Tension = ") ;
Serial.print(tension,2) ;
Serial.println(" V") ;
Serial.println() ; // Sauter une ligne entre deux affichages

delay(500) ; // Attendre ½ seconde pour avoir un affichage non trop rapide
}
155
Affichage sur écran LCD (16x2)
L'afficheur LCD utilise 6 à 10 broches ((D0 à D7) ou (D4 à D7) + RS + E) et 2 pour
l'alimentation (+5V et masse).
Les 6 ou 10 broches de données peuvent être placées sur n'importe quelles

entrées/sorties numériques de l'Arduino.
Montage à 10 broches : 8 bits de données + 2 bits de commande
On utilise la bibliothèque "LiquidCrystal.h" et les lignes de configuration :

LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7) ; // rs numéro de broche où "RS" est relié
// enable numéro de broche où "E" et relié …
Dans setup() démarrer l'écran en spécifiant nombre de colonnes et de lignes par la fonction :
begin(colonnes,lignes).
156
– Exemple 1 : Affichage sur écran LCD (16x2)
#include "LiquidCrystal.h" // Librairie du LCD
// Configuration du branchement
LiquidCrystal lcd(11,10,5,4,3,2) ; // Liaison 4 bits data OU (11,10,9,8,7,6,5,4,3,2) pour 8 bits
// (RS, E,d0, … ,d4, … ,d7)
void setup()
{
lcd.begin(16,2) ; // Utilisation d'un écran 16 colonnes et 2 lignes
lcd.write("Salut !") ; // Test de vérification
}
void loop() {} // Fonction principale

157
– Exemple 2 : Affichage sur écran LCD (16x2)
// Affichage des nombres 0, 1, 2, …, 9 sur la 2eme ligne du LCD de manière infinie.
#include "LiquidCrystal.h" // Librairie du LCD
int i ;
// Configuration du branchement
LiquidCrystal lcd(11,10,5,4,3,2) ; // Liaison 4 bits data OU (11,10,9,8,7,6,5,4,3,2) pour 8 bits
// (RS, E,d0, … ,d4,…, d7)
void setup()
{
lcd.begin(16,2) ; // Utilisation d'un écran 16 colonnes et 2 lignes
}
void loop() // Fonction principale

{
lcd.clear() ; // Efface l'Ecran LCD
lcd.write("Salut !") ; // Affiche texte
delay(500) ;
lcd.setCursor(0,1); // Place le curseur en 2eme ligne et colonne 0
for(i=0; i<10 ; i++)
{
lcd.print(i) ; // Ecrire valeur de i a la colonne 0 et 2eme ligne
delay(500) ;
}
}
158
UNIVERSITE IBN ZOHR Année Universitaire
ECOLE SUPERIEURE DE TECHNOLOGIES 2023-2024
D’AGADIR
GE2
TD 1 d'Informatique Industrielle
Exercice 1 :
Convertir les nombres décimaux suivants en binaire et en hexadécimal :
1- 18
2- 35
3- 243
4- 356
Exercice 2 :
Convertir les nombres binaires suivants en décimal et en hexadécimal :
1- 1010
2- 10010
3- 1010001
4- 111100100
Exercice 3 :
Convertir les nombres hexadécimaux suivants en binaire et en décimal :
1- 10
2- FA
3- 95
4- 48D
5- 1C5
Exercice 4 :
Les nombres négatifs sont représentés à l’aide de leur complément à 2. Le complément à 2 est obtenu en calculant
le complément à 1 et en rajoutant 1 au résultat. Le bit de poids fort indique le signe du nombre.
Sachant que l’on dispose de 8 bits pour écrire les nombres avec leur signe, donner les expressions binaire et
hexadécimale des nombres décimaux suivants : -35, -43, -56 et -14.
Exercice 5 :
Effectuer les opérations suivantes sur 8 bits :
1- 0010 1011 + 0100 1110
2- 0111 1001 + 0101 0111
3- 1010 0101 + 1101 1011
Exercice 6 :
Effectuer les opérations suivantes sur 16 bits, en hexadécimal sans passer par le binaire :
1- 4B3 + F7F
2- EAC8 + 22AC
3- 2B03 + 13C
4- B2F + CA7F
Exercice 7 :
Calculer les expressions suivantes par addition du complément à 2 :
1- 1101 1011 - 110 1011
2- 1011 - 11
3- 110 1011 - 1101 1011
4- A30F - 1234
5- 32A - 82C
6- F0E1 - 4E
7- E1 - 16A
D’AGADIR
GE2
Q1. Citer les éléments principaux d'un microsystème informatique.
Q2. Quel est le rôle de l'horloge ?
Q3. Citer les bus existants dans un microsystème en précisant le rôle de chacun d'entre eux et leurs
sens. Donner un exemple de leurs tailles.
Q4. Quel sont les éléments composant le modèle générique d'un microprocesseur ?
Q5. Quel est le rôle d'un pointeur de pile ?
Q6. Quel est le rôle du PC ?
Q7. Quel est le rôle du registre STATUS ?
Q8. Qu'est-ce qu'un microcontrôleur ?
Q9. Quelle différence y'a-t-il entre les appellations PROM, EPROM et EEPROM ?
Q10. Dans le monde des processeurs PIC il existe principalement deux architectures. Comment les
appelle-t-on ? Expliciter-les.
Q11. Citer les familles des microcontrôleurs PIC ? Expliciter en quoi diffèrent-elles.
Q12. En utilisant un quartz oscillant à 8 MHz, quelle sera la fréquence horloge du PIC16F84 ?
Q13. Décrivez comment est structurée la RAM du PIC16F84.
Q14. Dans le cas des microcontrôleurs PIC16F84, quelles sont les différentes mémoires disponibles ?
Q15. Citez les différentes horloges qu’on peut utiliser dans le cas des microcontrôleurs PIC.
Q16. Soit un CAN de 8 bits de résolution. Quelle sera la sensibilité (en mV) de ce CAN, pour chacune
des plages de tension (0 V à +2,5 V) et (-2,5 V à +2,5 V) ?
Questions à choix multiple
1. Dans un processeur donné l'UAL permet de :

a- Faire une addition.
b- Faire une soustraction.
c- Activer une entrée/sortie TOR.
d- Communique avec l'horloge.
e- Faire un OU Exclusif.
f- Les réponses a), b), d) & e).
g- Les réponses a), b) & e).
1
2. Dans un processeur donné :
a- Le Bus de données est unidirectionnel.
b- Le Bus d'adresse est unidirectionnel.
c- Le Bus de contrôle est monodirectionnel.
d- Le Bus de données est bidirectionnel.
e- Le Bus d'adresse est bidirectionnel.
f- Le Bus de contrôle est bidirectionnel.
g- Les réponses a), c) & e).
h- Les réponses b) & d).
3. On trouve un ADC (convertisseur analogique numérique) dans :

a- Uniquement la famille Base-Line.
b- Tous les microcontrôleurs PICs.
c- Certains microcontrôleurs PICs.
d- Uniquement la famille High-End.
4. Dans le cas d’un microcontrôleur PIC le programme s’écrit dans :

a- La RAM.
b- La flash EEPROM.
c- La ROM.
d- L’EEPROM.
5. Dans le cas des références de type PIC 16 xx yyy, la partie xx représente :

a- L'architecture RISC.
b- Le type de mémoire et d’alimentation.
c- La famille du microcontrôleur.
6. On trouve un registre Timer 8 bits dans :

a- Uniquement la famille Base-Line.
b- Tous les microcontrôleurs PICs.
c- Certains microcontrôleurs PICs.
d- Uniquement la famille High-End.
7. Le microcontrôleur PIC16F84 appartient à la famille :

a- Base-Line.
b- Middle-Range.
c- High-End.
8. Les instructions de la famille des microcontrôleurs PICs, appelée Middle-Range, sont codées sur :
a- 08 bits.
b- 16 bits.
c- 14 bits.
d- 13 bits.
9. Un microcontrôleur PIC renferme le module CCP qui permet de faire :

a- La communication série.
b- La génération d'un signal PWM.
c- La conversion numérique analogique.
d- La conversion analogique numérique.
e- Les réponses c) & d).
10. Un microcontrôleur PIC renferme le module USART qui permet de faire :

a- La communication série Synchrone.
b- La communication série Asynchrone.
c- La conversion analogique numérique.
e- Les réponses a) & b).
2
11. Le microcontrôleur PIC16F84 dispose des ports d'entrées/sorties :
a- A.
b- B.
c- C.
d- Les réponses a) & b).
e- Les réponses a), b) & c).
12. Dans le cas du microcontrôleur PIC16F84 l'entrée T0CKI :
a- Permet d'alimenter le µC.
b- Peut recevoir une horloge externe pour l'UAL.
c- Peut recevoir une horloge externe pour le TMR0.
d- Peut faire le RESET.
13. Dans le cas du microcontrôleur PIC16F84 l'entrée RB0 :

a- Peut-être une entrée/sortie TOR.
b- Peut recevoir l'horloge de l'UAL.
c- Peut recevoir l'horloge du TMR0.
d- Peut recevoir une interruption externe.
14. Dans le cas du microcontrôleur PIC16F84 le registre STATUS :

a- Appartient à la Bank 0.
b- Appartient à la Bank 1.
c- Appartient à la fois à la Bank 0 et 1.
d- Est de taille 8 bits.
e- Est de taille 16 bits.
f- Les réponses a) & e).
g- Les réponses c) & d).
15. Dans le cas des processeurs PICs :
a- La majorité des entrées / sorties sont de type série.
b- La majorité des entrées / sorties sont de type parallèle.
c- Toutes les entrées / sorties sont de type parallèle.
16. Dans le cas des processeurs PICs, après l'opération d'addition 0x6D + 0xD7 :
a- Le bit C du registre STATUS est égal à 0.
b- Le bit DC du registre STATUS est égal à 1.
c- Le bit C du registre STATUS est égal à 1.
d- Le bit Z du registre STATUS est égal à 1.
e- Les réponses b) & c).
17. Dans le cas des processeurs PICs, après l'opération d'addition 11 1010 + 1100 0110 :
c- Le bit Z du registre STATUS est égal à 0.
18. Dans le cas des processeurs PICs, après l'opération de soustraction 1000 1010 - 101 1100 :
19. Dans le cas des processeurs PICs, après l'opération de soustraction 0x3A - 0xB2 :
e- Les réponses a) & c).
3
20. Dans le cas du microcontrôleur PIC16F84 le registre TRISB permet de :
a- Configurer le TMR0.
b- Configurer le Port B en entrée ou en sortie.
c- Forcer les broches du Port B à l'état haut.
d- Forcer les broches du Port B à l'état bas.
21. Dans le cas du microcontrôleur PIC16F84 le registre OPTION_REG permet de configurer :

a- Les résistances de tirage du Port A.
b- Les résistances de tirage du Port B.
c- Les entrées/sorties TOR.
d- Le TMR0.
e- Le WDT.
22. Dans le cas du microcontrôleur PIC16F84 grâce au bits PS0, …, PS2 du registre OPTION_REG :
a- On configure les résistances de tirage du Port B.
b- On configure l'horloge du TMR0.
c- On choisit la valeur du diviseur de fréquence (Prescaler) du TMR0.
d- On configure les interruptions.
e- On choisit la valeur du diviseur de fréquence (Prescaler) du WDT.
23. Dans le cas du microcontrôleur PIC16F84 les interruptions sont configurées par le registre :
a- TRISA ou TRISB.
b- TMR0.
c- INTCON.
d- PORTB ou PORTA.
24. Dans le cas du microcontrôleur PIC16F84 le registre INTCON permet de configurer :

a- Les interruptions.
b- L'horloge externe.
c- Les résistances de tirage du Port B.
d- L'interruption due au TMR0.
e- L'interruption due à l'EEPROM.
25. Dans le cas du microcontrôleur PIC16F84 grâce au bit GIE du registre INTCON :
a- L'interruption sur RB0 est autorisée.
b- Les résistances de tirage du Port B sont activées.
c- L'interruption due au TMR0 est autorisée.
d- Le WDT peut fonctionner.
4
D’AGADIR
GE2
Exercice 1
Le microcontrôleur étant alimenté par 5 V, nous allons essayer de dimensionner la résistances R1 dans les montages ci-
dessous, selon les valeurs normalisées données au tableau suivant :
Microcontrôleur : Source de courant Microcontrôleur : Absorbe le courant
Une Led verte ( = 565 nm à 10 mA, VD = 2.09 V) est montée sur RA2. Calculer la résistance R1 pour avoir un courant ne
dépassant pas 4 mA.
Exercice 2
Soit un CAN de 8 bits de résolution. Quelle sera la sensibilité (en mV) de ce CAN, pour chacune des plages de
tension :
a ) 0 V à +2,5 V)
b ) -2,5 V à +2,5 V
Exercice 3
1. Avec PORTA = 23 et PORTB = 44, évaluer les expressions suivantes :
 PORTA &= PORTB
 PORTA ^= PORTB
 PORTA = PORTA | PORTB
2. Avec POARTA = 16 et PORTB = 37, évaluer les expressions suivantes :
 PORTA = PORTA >> 1 (ou PORTA >>= 1)
 PORTA = PORTA >> 2 (ou PORTA >>= 2)
 PORTB = PORTB << 1 (ou PORTB <<=1)
 PORTB = PORTB << 2 (ou PORTB <<=2)
3. Quelles sont alors les opérations arithmétiques réalisées par ces décalages ?
Exercice 4
Écrire un programme pour mettre tous les bits du PORTB du PIC16F84 au niveau logique 1, puis à la logique 0, et répéter
ce procédé dix fois avec des retards de ½ s entre les commutations. Nous supposons l'utilisation de l’instruction for pour créer
une boucle qui répète les opérations requises dix fois.
1. Proposer la version standard du programme C.
2. Proposer la version du programme C utilisant la complémentation du PORTB.
1
D’AGADIR
GE2
Exercice 1
Soit un µC contenant un ADC de 10 bits de résolution.
a- Si les tensions de référence Vref- et Vref+ sont respectivement -5 V et +5 V, cet ADC est utilisé pour effectuer
une CAN de la tension analogique de 3 V, cela entrainera dans le ou les registres donnant le résultat de conversion
une valeur décimale d'environ combien ?
b- Si les tensions de référence Vref- et Vref+ sont respectivement 0 V et +5 V, cet ADC est utilisé pour effectuer
une CAN d'une tension analogique U, à calculer. Cela entrainera dans le ou les registres donnant le résultat de
conversion une valeur décimale de 614.
Exercice 2
Nous disposons de 8 LEDs qui sont connectées au PORTB du µC PIC16F84 ou au PORTC du µC PIC16F876A
utilisant par un quartz de 4 MHz.
Lorsqu'on initialise le microcontrôleur, les LEDs s'allument en alternance ("Chenillard") avec un délai d’une
seconde, en utilisant une temporisation logicielle grâce à la fonction Delay_ms(), de sorte qu’une LED peut être
en ON et puis en OFF.
Proposer un programme qui réalise ce "Chenillard" en utilisant une variable qui sera décalée soit à gauche soit à
droite à chaque cycle d'allumage.
Exercice 3
Proposer un programme qui fait clignoter une LED connectée au PORTB du PIC16F84A cadencé par un quartz
de 4 MHz. La temporisation d'environ 2,5 s sera réalisée grâce au Watchdog. Utiliser la directive #define LED …
Nous précisons que, sans pré-diviseur, le Watchdog du PIC16F84A stoppe son fonctionnement (endorme) pendant
18 ms.
1
Exercice4
Génération d'un signal PWM (MLI) par le µC PIC16F876A cadencé par un quartz de 4 MHz.
Proposer un programme qui permet de changer le rapport cyclique du module PWM-1, de 0% à 100% grâce à une
variable qui s'incrémente. Le signal généré est de 5 KHz de fréquence.
Si une LED est connectée à la sortie de ce module (RC2), nous observons un changement graduel de l'illumination
de cette LED. Nous pouvons également mesurer les changements par un oscilloscope.
Remarque : Afin de visualiser les changements de l'éclairement de la LED, nous introduisons un retard de 20 ms
entre chaque cycle de changement du rapport cyclique.
Donner 2 versions : une qui utilise un seul programme et l'autre utilisant un programme principal et un sous-
programme d'initialisation.
2
D’AGADIR
GE2
Exercice 1
En vous inspirant de l'annexe, appliquer la technique dite "Bit Stuffing" ou "Bits de bourrage", à la trame ci-
dessous.
Exercice 2
Sachant qu'une trame du Bus CAN standard est composée des bits schématisés à l'annexe. Déterminer les
longueurs minimale et maximale en bits, d'une trame de données circulant sur le bus CAN sans "Bit Stuffing".
Exercice 3
Nous rappelons que le principe d'arbitrage bit à bit repose sur le procédé d'attribution du bus, selon lequel les
nœuds en compétition, émettant simultanément sur le bus, comparent bit à bit l'identificateur de leur message
avec celui des messages concurrents. Les stations de priorité moins élevée perdront la compétition face à celle
qui a la priorité la plus élevée.
Les stations sur le bus sont câblées par le principe du « ET câblé » et en cas de conflit (émission simultanée),
l'état dominant (0) écrase l'état récessif (1).
Exemple : les stations 1, 2 et 3 demandent le bus en même temps. Les stations ou nœuds ont respectivement les
identificateurs ID1=011…, ID2=01001101…, ID3=0100111…
Pour les départager, on applique la méthode d'arbitrage et les premières stations à émettre un bit récessif sont
exclues et devront attendre que la station qui a pris le bus libère la ligne.
1. Dans cet exemple, lesquelles des stations vont perdre la compétition et laquelle va la gagner ?
2. Dans cet exemple, attribuer les priorités pour les 3 nœuds, en fonction de leur rôle :
 Un capteur de température.
 Un capteur d'anti-patinage.
 L'ABS.
Exercice 4
Nous rappelons (voir annexe) que le champ de contrôle ou de commande est composé de 6 bits dont 2 réservés
pour des évolutions futures. Les 4 derniers bits permettent de déterminer le nombre d'octets de données contenus
dans le champ de données (Data Field) ne dépassant pas 8 octets.
Compléter la trame (sans champ CRC) dans le cas où un nœud émet les données 'B' (0x42) suivi de 6.
1
Exercice 5
Le chronogramme ci-dessous visualise la première partie d'une trame CAN émise par le calculateur d'une
automobile (Ici la base de temps, axe des x, est = 20 μs).
1. Donner en le justifiant le type de format (standard ou étendu).
2. Compléter le cadre au-dessus des chronogrammes en précisant l'état des différents bits et le réécrire ci-dessous.
3. Donner la durée d'un bit.
4. Quel est le débit de la transmission ?
5. Donner l'identificateur contenu dans cette trame en binaire et en hexadécimal.
6. Quel est le nombre d'octets de données ?
Exercice 6
Dans un véhicule, le bus CAN permet de transmettre de nombreuses informations. Lors d'un test, les 3
informations suivantes sont retenues : l'appui sur la pédale de frein, l'état de charge de la batterie et la détection
de la fenêtre ouverte côté conducteur.
1. Attribuer une priorité 1, 2 ou 3 (1 pour forte et 3 pour faible), pour ces 3 informations en fonction de leurs
rôles.
2. Grâce à un module d'acquisition, nous relevons ces 3 informations. Les identificateurs leurs correspondant
relevés lors de l'acquisition sont, en hexadécimal : 0x58E, 0x60E et 0x70E.
D'après ces identifiants, s'agit-il de trames de requêtes ou de données. Justifier votre réponse.
3. Selon ce qui précède, indiquer les identificateurs associés à chacune des fonctionnalités ; le freinage, la
détection de la fenêtre ouverte côté conducteur et le taux de charge de la batterie. Justifier votre réponse.
4. La trame relevée sur le bus CAN fournie en annexe permet, entre autres, de connaître le taux de charge
(exprimé en %) des batteries du véhicule. Sa valeur est donnée par le 5ème octet des données. La valeur du taux
de charge en %, codée sur un octet, est représentée par un nombre entier avec une précision de 1.
Relever, sur la trame en annexe, la valeur en hexadécimal du « taux de charge batterie » et en déduire sa valeur
en %.
2
Exercice 7
Soit un circuit 24C04 dont les broches E2 et E1 sont reliées à la masse.
On désire écrire la donnée 0xF9 à l'adresse 00 du bloc 0 en mode direct. Donner la trame.
On désire écrire les données 0xF9, 0xE0, 0x12 respectivement aux adresses 0x10, 0x11, 0x12 du bloc 1 en mode
séquentiel. Donner la trame.
Exercice 8
Le champ CRC est calculé hors "Bits Stuffing" (voir technique de calcul en annexe). Dans le cas du bus CAN,
selon la norme, le polynôme, appelé fonction génératrice, utilisé lors des calculs est de la forme :
x15+x14+x10+x8+x7+x3+1, il correspond à la suite binaire : 1100010110001001
Remarque : Selon les domaines, il existe des polynômes (Fonction génératrice) normalisés tels que :
CRC-12 G(x) = x12 + x11 + x3 + x2 + x1 + 1
CRC-16 G(x) = x16 + x15 + x2 + 1
CRC-CCITT G(x) = x16 + x12 + x5 + 1
Selon la technique de calcul du CRC décrite en annexe et avec G(x) = x5 + x2 + 1, déterminer le message à
envoyer M' correspondant au message M = 1110011010. Effectuer la vérification que la réception de ce message
est correcte.
3
Annexes
 Description des trames Bus CAN
 Quelques paramètres du Bus CAN
 "Bit stuffing" ou "Bits de bourrage"

Nous rappelons que la méthode de "Bit Stuffing" ou "Bits de bourrage" consiste, dès que l'on a émis 5 bits de
même polarité sur le bus, à insérer un bit de polarité inverse pour casser des chaînes trop importantes de bits
identiques. On obtient ainsi dans le message un plus grand nombre de transitions, ce qui permet de faciliter la
synchronisation en réception des nœuds. On parle de "Stuffer" une trame. Cette technique est active sur les
champs de SOF, d'arbitrage, de contrôle et de CRC.
Données 1 1 0 0 0 0 0 0 1 1 0 1 1 1 1 1 0
Bits émis 1 1 0 0 0 0 0 1 0 1 1 0 1 1 1 1 1 0 0
 Technique de construction de message avec CRC :

Avec un message M = 1101011011 et la fonction génératrice G(x) = x4 + x + 1, nous procédons à la construction
du message M'' = 1101011011 0000 (4 zéro en poids faible sont ajouté car G est de degré 4).
Ensuite nous calculons le reste de M''/G(x) cela peut se faire simplement par des OUX (ou exclusifs).
Le calcul du CRC produit le message M' = 1101011011 1110 qui sera envoyé.
A la réception, le message reçu Mr = M' = 1101011011 1110, le récepteur recalcule le reste, s'il n'y a pas d'erreur
Mr/G(x) = 0000 ==> Message correcte (On montre que cela est vrai avec une probabilité de 98,5%).
Démarche utilisant XOR pas à pas : G(x) = x4 + x + 1 10011 Message M : 1101011011
1101011011 0000 1101011011 1110
10011 10011
010011 010011
10011 10011
000001011 0 000001011 1
10011 10011
00101 00 00100 11
100 11 100 11
001 11 0 CRC 000 00 0 OK correcte
Donc le message résultant à envoyer sera M' = 1101011011 1110
4
 Exemple de relevé de trames Bus CAN correspondant au taux de charge batterie
5
D'AGADIR
GE2
Exercice 1
Pour transmettre des caractères, nous exploitons une interface série utilisant le protocole RS232 qui est
paramétrée selon les valeurs suivantes :
Débit : 115 200 Bauds ; Données : 8 bits ; Parité : Impaire ; Stop : 2 bits ;
1. Sachant que le code Ascii du caractère 'A' est 0x41, dessiner la trame dans le cas de l'envoi du caractère 'G'.
2. On suppose à transmettre un fichier de taille 10 Mo :
a. En supposant que tous les caractères sont transmis, quel est le nombre de caractère contenu dans ce fichier ?
b. Quelle sera la durée (en minutes) nécessaire à la transmission, sans aucune compression de ce fichier, en
utilisant la ligne série dont les paramètres sont définis comme ci-avant ?
Exercice 2
Dans le cas du protocole I2C, les trames SDA1 et SDA2 ci-dessous sont transmises simultanément par 2 maitres.
Selon le principe d'arbitrage bit à bit identique à celui utilisé dans le cas du Bus CAN, lequel des maitres va
garder le contrôle du bus I2C ?
Exercice 3
1. Soient les chronogrammes I2C ci-dessous, sachant qu'il s'agit de l'envoi d'un octet d'adresse, repérez les
différents éléments.
- Chronogramme 1 -
- Chronogramme 2 -
2. Retrouvez le message émis par le maître sur le bus I2C à partir de ces chronogrammes.
3. Décrivez et justifiez la différence essentielle que vous avez repéré sur ces deux premiers chronogrammes.
Exercice 4
Sachant que le circuit PCF8574 utilisé dans le décodage I2C vers 8 bits I/O est adressé par un code sur 7 bits
dont les 4 bits MSB constituent la partie fixe (Firmware), déchiffrez les trames ci-dessous :
1. Start 01001111 Ack 11001111 Ack Stop
2. Start 01000000 Ack 11001111 Ack Stop
1
Questions à choix :
1- Le microcontrôleur utilisé sur l'Arduino Uno est :
a. ATmega32u4 b. ATmega328
c. ATmega2560 d. ATmega168
2- Pour mettre la broche 5 en entrée on écrit :
a. digitalWrite(5, LOW) ; b. digitalWrite(5, HIGH) ;
c. pinMode(5, INPUT) ; d. pinMode(5, OUTPUT) ;
3- Si l'entrée A0 du CAN 10 bits de l'Arduino Uno, si les tensions de référence sont 0 et 5 V, alors la fonction
analogRead(0) fournit la valeur décimale pour une entrée de 2.7 V :
a. Environ 552 b. Environ 553
c. Environ 1894 d. Environ 1895
4- Le programme suivant :
void setup() { pinMode(13, OUTPUT) ; }
void loop() {
digitalWrite(13, HIGH) ;
delay(250) ;
digitalWrite(13, LOW) ;
delay(750) ; }
a. Allume la LED 13 durant 250 millisecondes et l'éteint durant 750 millisecondes, une seule fois.
b. Eteint la LED 13 durant ¼ de seconde et l'allume durant ¾ de seconde, répété à l'infini.
c. Allume la LED 13 durant ¼ de seconde et l'éteint durant ¾ de seconde, une seule fois.
d. Allume la LED 13 durant 250 millisecondes et l'éteint durant 750 millisecondes, répété à l'infini.
e. Ne fonctionne pas car il contient une erreur.
5- Le programme suivant :
void setup() { pinMode(13, OUTPUT) ; }
void loop() {
digitalWrite(13, HIGH) ;
delay(1000) ;
digitalWrite(13, LOW) ;
delay(1000) ; }
fait clignote une LED a une fréquence de :
a. 1 Hz. b. 1.5 Hz.
c. 0.5 Hz. d. 2 Hz.
6- Pour piloter un afficheur LCD par l'Arduino, il faut :
a. Simplement connecter ses 8 fils à la carte Arduino.
b. Connecter uniquement ses 4 fil, le reste pouvant être alimenté par une pile ou un générateur externe.
c. Connecter ses 4 ou 8 fils et vérifier que le générateur externe, le LCD et la carte Arduino partagent la même
masse.
7- La commande serial.print("Test") permet de :
a. Envoyer sur la liaison série un texte.
b. Ecrire sur l'Arduino.
c. Ecrire dans un tableau.
d. Imprimer le programme.
8- Pour le PWM, la FAUSSE proposition est :
a. Une sortie PWM permet de faire varier le rapport cyclique du signal de sortie.
b. Une sortie PWM permet de faire varier la tension d'une sortie digitale.
c. Pour piloter une sortie en PWM on utilise la fonction : analogWrite().
d. On donne une valeur comprise en 0 et 255 au paramètre de la fonction de (c).
9- Pour régler l'éclairement d'une LED on utilise les méthodes ci-dessous. Choisir la FAUSSE proposition.
a. On diminue le courant en rajoutant une résistance variable en série.
b. On pilote la LED avec un signal PWM.
c. On monte plusieurs LED en série.
d. On connecte la LED sur la broche A0, et on utilise la fonction analogWrite().
2
ANNEXE
Code Ascii
3
D'AGADIR
DEPARTEMENT GENIE ELECTRIQUE
GE2
TP1 - Visual C# express

Eléments de programmation en C# (C Sharp)
EXERCICE :
1/ Création de l'interface graphique
Réaliser l'interface graphique de la fenêtre principale Form1 de gauche, comportant les 9 objets suivants : 1 zone de
texte modifiable à liste déroulante (ComboBox : Choix de l'opération), 4 Labels (Valeur 1, Valeur 2, Résultat et
"vide"), 2 zones de texte (TexteBox : "Val_1" et "Val_2" et 2 boutons (Calculer et Quitter).
2/ Code du programme
Proposer le code associé à cette application composée de 4 fonctions :

- Fonction associée au clique sur le bouton "Quitter" (événement Click) en utilisant Application.Exit ou
this.Close.
- Fonction associée au chargement de la Form1 (événement Load) : Cet événement permet en utilisant la
méthode. Items.Add, l'ajout dans le ComboBox des 4 éléments pour le choix des opérations "Addition",
"Multiplication", "Soustraction", "Division" et "Factorielle".
1
- Fonction associée à l'évènement de sélection du "ComboBox" (événement SelectedIndexChanged) : Si on
sélectionne (Propriété SelectedIndex) une opération différente de "Factorielle" alors la zone de texte "Val_2"
est visible (méthode Show). Par contre si on sélectionne l'opération "Factorielle" alors la zone de texte
"Val_2" ainsi que le label en dessus sont masqué (méthode Hide).
- Fonction (à compléter) associée au clique sur le bouton "Calculer" (événement Click) : Si on clique dessus
alors la machine procéde au calcul selon l'opération choisie et selon les valeurs entrées V1 et V2
respectivement dans les zones de texte "Val_1" et "Val_2".
private void CmdCalculer_Click(object sender, EventArgs e)

{
…………………………………………………………………………………… // Déclaration des variables de type entier codé sur 64 bits
…………………………………………………………………………………… // Obtention de V1 en utilisant la fonction Convert.ToInt64
…………………………………………………………………………………… // Test du choix sélectionné si différent de 4

{
…………………………………………………………………………………… // Obtention de V2 en utilisant la fonction Convert.ToInt64
……………………………………………………………………………………………………………… // Test du choix sélectionné si ………………

Resultat.Text = (V1 + V2).ToString(); // Calcul de V2+V1 et son affichage dans son label
………………………………………………………………………………………………… // Soustraire V2 de V1 et affichage
………………………………………………………………………………………………… // Multiplier V2 par V1 et affichage
………………………………………………………………………………………………… // Diviser V1 par V2 en les forçant aux réels

}
else
{
N = V1 ;
………………………………………………………………………………………………… // Boucle for en variant I de 1 à N
…………………………………………………………………………………… // Calcul de la factorielle F de N
………………………………………………………………………………………………… // Affichage de F
}
}
2
D'AGADIR
DEPARTEMENT GENIE ELECTRIQUE
GE2
TP2 Visual C# express (C Sharp)

Communication Sérielle RS232
Afin d'émuler 2 ports série sur PC, il faudra exécuter et configurer le logiciel "Virtual Serial Ports Emulator"
(VSPE).
EXERCICE : Simulation de la communication sérielle C# ↔ Isis

Cette application émule un périphérique par l'intermédiaire du logiciel Isis (Fichier "CommRS232-C_Isis.dsn").
1/ Création de l'interface
Réaliser l'interface graphique de gauche comportant : 4 Labels ("Choix du port", "Choix du Débit", "Tapez la
chaine à envoyer" et celui au-dessus du bouton "Exit", il est Vide), 2 zones de liste (ComboBox : Propriété Items =
respectivement COM1, COM2, COM3, COM4 et 2400, 4800, 9600, 19200, 38400, …), 1 zone de texte (TextBox),
1 barre de progression (progressBar), 5 boutons ("Connexion", "Envoi", "Reception", "Stop" et "Exit") et enfin le
composant serialPort.
1
2/ Code du programme
Commentaire :
Pour exploiter les ressources offertes concernant les ports séries, nous allons utiliser la classe IO.Ports par
l'intermédiaire de directive ci-dessous à la suite des différente directives using :
using System.IO.Ports ;
Proposer le code associé à cette application composée de 6 fonctions :

a. Fonction associée au bouton "Exit" permettant de mettre fin à l'application.
…………………………………………………………………………………………………………………………
b. Fonction associée à l'événement Load du Form1 : Elle se charge de fermer (Méthode Close) le port série
s'il est déjà ouvert (Propriété IsOpen).
………………………………………………………………… //Si Port série 1 ouvert alors le fermer
c. Fonction associée à l'événement Click du bouton "Connexion" : Elle permet de :

* Récupérer le nom du port (Propriété PortName) choisi ainsi que la valeur de son débit (Propriété
BaudRate) dans les 2 zones de liste prévues à cet effet ; pour la 1ère (propriété SelectedItem et méthode
ToSting) et pour la 2ème (propriété SelectedItem et fonction Convert:ToInt32) ;
* Fixer le nombre de bits de la donnée à 8 (Propriété DataBits) pour le port série choisi ;
* Travailler sans parité (Propriété Parity de valeur Parity.None) pour le port série choisi ;
* Fixer le nombre de bits de stop à 1 (Propriété StopBits de valeur StopBits.One) pour le port série choisi ;
* Ouvrir (Méthode Open) le port série choisi ;
* Lançant une barre de progression (progressBar) en fixant sa valeur à 100 ;
* Désactiver le bouton "Connecter" (Propriété Enabled).
…………………………………………………………………………………….. //Avoir le nom du COM de Combo1
……………………………………………………………………………………... //Avoir le débit du Combo2
…………………………………………………………………………………….. //8 bits pour la donnée
…………………………………………………………………………………….. //Pas de parité
…………………………………………………………………………………….. //1 seul bit de Stop
…………………………………………………………………………………….. //Ouverture du port
……………………………………………………………………………… //Lancement de barre de progression
……………………………………………………………………………… //Désactiver le bouton Connecter
d. Fonction associée à l'événement Click du bouton "Envoi" : Elle permet d'écrire (Méthode Write) sur le
port série choisi, les caractères à transmettre avec retour chariot ("\r") et retour à la ligne ("\n"). Ces
caractères proviennent de la listeBox juste en dessus.
………………………………………………………………………… //Ecriture sur COM les carac. à envoyer
e. Fonction, ci-dessous à compléter, associée à l'événement Click du bouton "Reception" : Elle permet de :
* Lire les données qui arrivent dans la mémoire tampon du port série choisi (Méthode ReadExisting) et
* les afficher dans le label juste en dessous.
string ch ; //Déclaration de chaine de caractère
………………………………………………………………………… //Vider la zone d'affichage (un Label)
// Lecture des données entrantes dans la mémoire tampon du port série
ch = …………………………………………………………………………
………………………………………………………………………… //Affichage de la chaîne reçue
f. Fonction associée à l'événement Click du bouton " Stop" : Elle permet de :

* Elle se charge de fermer (Méthode Close) le port série s'il est déjà ouvert (Propriété IsOpen) et
* remet à 0 la barre de progression tout en activant le bouton "Connecter".
………………………………………………………………………… //Test d'ouverture du port
………………………………………………………………………… //Raz de la barre de progression
………………………………………………………………………… //Activer le bouton Connecter
2
D'AGADIR
GE2
TP3 d'Informatique Industrielle
Commande de Led reliées au Port B du PIC16F84
I. Objectif du TP
La fiche de TP décrite ci-dessous a pour but de permettre à l'utilisateur, d'établir le schéma d'une application et la
simuler par le logiciel ISIS ensuite de programmer en C le PIC16F84A utilisant un quartz de 4 MHz.
Dans cette application, voir le schéma ci-dessous, nous allons programmer et simuler la commande de 4 Leds,
par l'interrupteur SW du Port A. Les 4 Leds D1, D2, D3 et D4 sont reliées au Port B.
* Si le switch SW, relié à RA2, est Ouvert (RA2=1) alors les 4 Leds du PORTB clignotent toutes les 500 ms.
* Sinon (SW Fermé : RA2=0) alors les 4 Leds s'allument une après l'autre selon le cycle suivant :
- D1 s'allume pendant 400 ms puis s'éteint, ensuite
- D2 s'allume pendant 800ms puis s'éteint, ensuite
- D3 s'allume pendant 1200ms puis s'éteint, ensuite
- D4 s'allume pendant 1600ms puis s'éteint, ensuite le cycle reboucle indéfiniment.
II. Travail à faire

1- Créer votre dossier de travail dans le bureau,
2- Lancer le logiciel Isis de PROTEUS, réaliser et compléter le schéma donné ci-dessous. Les terminaux : Masse (Ground)
et Vcc (Power) sont accessibles via la barre d'outils .

3- Enregistrer votre schéma dans votre dossier de travail.
4- Lancer MikroC PRO for PIC, puis créer un nouveau projet dans votre dossier (Processeur 16F84A, Quartz 4 MHz).
5- Compiler le programme afin de générer le fichier xxxx.HEX.
6- Embarquer dans le microcontrôleur du schéma le fichier xxxx.HEX, tester enfin l'application en la simulant par ISIS.
7- Dans votre compte rendu, expliquer les différentes étapes et procédure en donnant une conclusion.
III. Schéma du circuit de commande des LEDs.
1
IV. Squelette du programme en C associé à cette application
/ TP_LED.c sous MikroC PRO for PIC ************************************************************
Commande de LED
==============
L'interrupteur SW (RA2) commande les 4 Leds du Port B
Si SW est Ouvert (RA2=1) alors les 4 Leds du PORTB clignotent toutes les 500 ms.
Sinon (SW Fermé : RA2=0) alors les 4 Leds s'allument une après l'autre selon le cycle :
D1 s'allume pendant 400ms puis s'éteint.
PIC16F84A, Oscillateur : XT, 4 Mhz
*******************************************************************************************/
void main()
{
……………………………………… // RA2 en entrée les autres en sorties
……………………………………… // PORTB en sortie
……………………………………… // LED éteintes
{
if (PORTA.F2 == 1) // Si RA2 = 1 (SW Ouvert) ==> Faire clignoter les 4 Led
{
……………………………………… // Allume les 4 Led
……………………………………… // Temporisation
……………………………………… // Eteindre les Led
……………………………………… // Temporisation
}
else // Sinon (RA2=0: SW Fermé) ==> Allume D1, D2, D3 et D4 selon le cycle donné
{
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
…………………………………………
}
}
}
2
D'AGADIR
GE2
Compteur-Décompteur sur afficheur 7 segments
I. Objectif du TP
La fiche de TP décrite ci-dessous a pour but de permettre à l'utilisateur, de programmer en C le PIC16F84A
ensuite d'établir le schéma d'une application et la simuler par le logiciel ISIS. Dans cette application nous
simulons la commande d'un afficheur 7 segments par le Port A. Selon l'état du switch SW1 relié à RA0, une
variable est incrémentée (1 sur RA0) ou décrémentée (0 sur RA0), de manière infinie, entrainant le comptage (0,
1, 2, …, 9, 0, …) ou le décomptage (9, 8, 7, …, 0, 9, …). Les affichages sont séparés par une temporisation de
500 ms.

1- Créer votre dossier de travail dans le bureau.

III. Schéma du circuit de comptage - décomptage sur l'afficheur 7 segments.
1
IV. Organigramme du compteur - décompteur sur un afficheur 7 segments
D
Déclaration de variables k et SEG

Configurer le port A en entrée et le port B
en sortie. Afficheur éteint
Oui
RA0 = 1
Non Afficher la valeur
du compteur k
Afficher la valeur
du compteur k
Délai & incrémentation
de k et si ce dernier est >9
Délai & décrémentation alors l'initialiser
de k et si ce dernier est <0
alors l'initialiser à 9
Fin
V. Squelette de programme en C associé au comptage - décomptage sur l'afficheur 7 segments

/ TP4_7Seg.c sous MikroC PRO for PIC ********************************************************
Compteur-Décompteur sur 7 segments
===================================
Le programme compte (0 à 9) ou décompte (9 à 0) puis affiche chaque valeur sur un afficheur
7 segments de type cathode commune, connecté au PORTB du PIC16F84A (Oscillateur : XT, 4 Mhz).
Un état 1 sur RA0 entrainera le comptage, alors qu'un 0 provoque le décomptage
Une temporisation logicielle de 500ms est introduite entre les affichages.
*******************************************************************************************/
void main()
{
int k = 0 ; // Variable servant au Comptage - Décomptage
unsigned char SEG[] = {………………………………………………………………………..} ;
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
…………………………………………………………………
}
2
D'AGADIR
GE2
Chenillard commandé par Interruption sur RB0
I. Objectif du TP
La fiche de TP décrite ci-dessous a pour but de permettre à l'utilisateur, d'établir le schéma d'une application et la
simuler par le logiciel ISIS ensuite de programmer en C le PIC16F84A. L'application permet de simuler
l'allumage, à tours de rôle, d'une seule LED parmi celles reliées au Port B, grâce à l'interruption générée par le
bouton poussoir BP1 relié à la broche RB0 (voir schéma). Au départ aucune Led n'est allumée et dès la 1ère
interruption la Led reliée à RB7 s'allume puis l'interruption qui suit allume la Led reliée à RB6, …, jusqu'à RB0
et le cycle se répète. Le sous-programme d'interruption se charge d'allumer les Leds une après l'autre en
effectuant un décalage à droite du Port B, (voir les organigrammes).

1- Créer votre dossier de travail dans le bureau.

III. Schéma du circuit de commande de Leds par l'interruption RB0.
1
IV. Organigrammes associés à la commande de LEDs par l'interruption sur RB0
D
Début S-prg. Interruption
Configurer la broche RB0 du Port B en
entrée et les autres broches en sortie RAZ du Flag d'interruption
Configurer OPTION_REG : Oui

Résistances de tirage Interne & Choix du PORTB=0
Front Montant pour les interruptions sur RB0
Non PORTB=0x80
Configurer INTCON :
Activer les Interruptions générales & Décalage à droite
celle venant de la broche RB0 & d'un bit du PORTB
RAZ du Flag d'interruption
Oui
Eteindre LEDs PORTB=1
Attente Non PORTB=0x80

Attente infinie d'interruption
Fin Fin S-prg. Interruption
V. Squelette de programme en C associé à la commande de Leds par l'interruption sur RB0

/* TP5_InterRB0.c sous MikroC PRO for PIC ************************************************************
Programme utilisant un sous-programme associé à l'interruption RB0 du PIC16F84A.
Ce programme assure l'allumage, par l'état 1, d'une seule Led à tour de rôle parmi les 7 reliées à RB7, RB6, …, RB1.
Le passage de l'allumage de la Led (RB7) à la Led suivante (RB6), …, est déclenché par une interruption venant de RB0
provoquant le décalage du port B.
Oscillateur : XT, 4 MHz.
***************************************************************************************************/
/***************************************************************************************************
Sous-Programme d'interruption
***************************************************************************************************/
void Interrupt()
{
……………………………………………….
……………………………………………….
……………………………………………….
……………………………………………….
……………………………………………….
}
/***************************************************************************************************
Programme Principal
***************************************************************************************************/
void main()
{ // Bits de OPTION_REG : RBPU - INTEDG - T0CS - T0SE - PSA - PS2 - PS1 - PS0
// Bits de INTCON : GIE - REIE - T0IE - INTE - RBIE - T0IF – INTF - R0IF
……………………………………………………………
……………………………………………………………
……………………………………………………………
……………………………………………………………
……………………………………………………………
……………………………………………………………
……………………………………………………………
……………………………………………………………
……………………………………………………………
}
2
D'AGADIR
GE2
Programmation des modules : CAN, UART, CCP et LCD – Cas du PIC16F876A
I. Objectif du TP :
La fiche de TP décrite ci-dessous a pour but de permettre à l'utilisateur, d'une part de manipuler l'outil de développement
MikroC PRO for PIC, afin de programmer en langage C, respectivement les modules ADC, UART, CCP et un LCD dans le
cas des microcontrôleurs PIC. D'autre part, établir le schéma d'une application utilisant ces modules, dans le cas du
microcontrôleur PIC16F876A pour simuler par le logiciel ISIS la commande de la vitesse de rotation d'un moteur DC.
II. Cahier des charges et travail à faire :

1- Sachant que la résolution du CAN intégré au PIC16F876 est de 10 bits et que les tensions de références sont :
Vref- = 0 V et Vref+ = 5 V, déterminer les valeurs décimales M4, M3, M2 et M1 correspondantes respectivement aux
tensions seuils 5 V, 3.75 V, 2.5 V et 1.25 V.
2- Sachant que les seuils précédents vont être exploiter pour générer un signal PWM dont les rapports cycliques sont
respectivement 100%, 75%, 50% et 25%, déterminer les valeurs respectives à envoyer au module CCP.
3- Le programme à compiler (voir organigramme à compléter) assure les tâches suivantes :
- Divers configurations de l'ADC, de l'UART et du CCP.
- La conversion AN d'une tension, Va, appliquée sur une de ses entrées analogiques et puis l'affichage du résultat de la
conversion AN sur un barographe.
- Ensuite, si l'on envoi sur l'interface série (Tx, Rx) le caractère 'A' alors le module CCP est arrêté,
- Si le caractère est 'D' alors le module CCP démarre pour générer un signal dont le rapport cyclique i est de valeur
correspondant à l'un des 4 intervalles choisies de cette tension Va, fixant une vitesse i de rotation d'un moteur DC.
4- Le programme affichera en permanence, sur un LCD, la valeur de la tension après sa conversion en numérique et sa
mise en forme pour qu'elle s'affiche de nouveau comme s'il s'agissait de valeur réelle.
5- Sous ISIS, établir et simuler le schéma du circuit ainsi mis au point.
III. Schéma du circuit de commande :
1
IV. Organigrammes associés au programme :
D
Configuration des broches LCD

Déclaration des variables globales res_CAN et
Conv_res_CAN de type float puis txt[10] de type char
Configuration du CAN (voir annexe)

& du Port C en sortie sauf le RC7
& Port C éteint
Initialisation du LCD (voir annexe) +

Son effacement + Masquer le curseur
Initialiser l'UART à 9600 bps (voir annexe) &

Écrire le message "Connexion établie" avec
retour chariot (0x0D) et retour à la ligne (0x0A)
Initialiser le PWM1 à une fréquence de

1 kHz (voir annexe)
Lecture du résultat de CAN (voir annexe) de la

tension appliquée à l'entrée 0. Puis l'adapter à
l'intervalle 0-5V. Puis le convertir en chaine de
caractère puis l'afficher sur le LCD en le
concaténant avec une chaine vide 4 car.
Appel, avec passage d'argument res_CAN, du

sous-programme Generer_MLI assurant la
génération du signal MLI.
2
Début du Sous-prg.
Generer_MLI
Déclaration des variables RCycl

de type int et Octet_Lu de type char
Oui
Réception Ok
Lire le caractère reçu. Si = 'D', alors démarrer

le PWM si ='A' alors l'arrêter. Puis écrire sur
l'UART, successivement un espace (0x20) et
l'Octer_Lu suivi du retour chariot
Oui
Mesure …….
Non
RCycl ………
Oui
Mesure …….
Non RCycl ………

Oui
Mesure …….
Non
RCycl ………
RCycl ………
Envoi de RCycl au module

CCP (voir annexe)
Retard de 20 ms
Fin Sous-prg.
Generer_MLI
V. Squelette du programme en C :
/***************************************************************************************************
Convertisseur A/D et modules UART et CCP du PIC16F876A ; (8 Mhz), Pour le CAN : Vref- → GND et Vref+ → 5V
============================================
Un signal analogique variable est appliqué à la broche AN0 (RA0) du PIC16F876, tandis que le résultat de conversion après
sa mise en forme pour qu'il s'affiche de nouveau comme s'il s'agissait de valeur réelle est visible sur l'afficheur LCD.
Selon le caractère x envoyé sur la ligne série (Tx et Rx), s'il correspond à 'A' alors arrêter le CCP1 s'il correspond à 'D', alors
démarrer le signal PWM qui fera tourner un moteur DC à une vitesse i fixée par le rapport cyclique i, défini ci-après.
On prévoit 4 seuils de mesure de Va : M1 : [0v, 1.25v[ ; M2 : [1.25v, 2.5v[ ; M3 : [2.5v, 3.75v[ et M4 : [3.75v, 5v]).
Si la mesure est < 1.25v ==> Faire tourner le moteur DC à la vitesse 1 (rapport cyclique 1 de 25%)
Sinon ==> Faire tourner le moteur DC à la vitesse 4 (rapport cyclique 4 de 100%)
***************************************************************************************************/
3
// Configuration du brochage du LCD
sbit LCD_RS at RB4_bit ;
sbit LCD_EN at RB5_bit ;
// Direction des broches pour le LCD
sbit LCD_RS_Direction at TRISB4_bit ;
sbit LCD_EN_Direction at TRISB5_bit ;
// Fin de configuration du brochage LCD
Variable globale
//*****************************************************************************************
float res_CAN, Conv_res_CAN ; // Déclaration de la variable globale de mesure de tension
char txt[10] ;
/***************************************************************************************************
Sous-Programme
***************************************************************************************************/
void Generer_MLI(int Mesure)
{
int RCycl ; // Déclaration de la variable correspondant au Rapport Cyclique
char Octet_Lu ; // Déclaration de la variable correspondant au caractère saisie
……………………………………………….
……………………………………………….
……………………………………………….
……………………………………………….
}
/***************************************************************************************************
Programme Principal
***************************************************************************************************/
void main()
{
ADCON1 = …………………… ; // AN4(A), AN3(A), AN2(A), AN1(A), AN0(A), Vref+(Vdd) et Vref-(Vss)
……………………………………………………
……………………………………………………
……………………………………………………
……………………………………………………
{
……………………………………………….
Conv_res_CAN = res_CAN * 5/1024 ; // Adapter le résultat dans l'intervalle 0-5V
floatToStr(Conv_res_CAN, txt) ; // Conversion du Réel en Chaine de caractères
………………………………………………. // Retardement de 20ms
……………………… (1, 1, strcat(txt, " ")) ; // Ecrire la Chaine sur colonne 1 et ligne 1
………………………………………………. // Retardement de 20ms
………………………………………………. // Appel de la fonction Generer_MLI avec passage de res_CAN
}
}
4
Annexe PIC16F876
Brochage
Module de conversion A/N
Ce module est constitué d'un CAN (Convertisseur Analogique Numérique) 10 bits dont l'entrée
analogique peut être connectée sur l'une des 5 entrées analogiques externes.
Les tensions de références permettant de fixer la dynamique du convertisseur. Elles peuvent être
choisies parmi Vdd, Vss, Vref+ ou Vref-.
Registres du résultat de conversion sur 10 bits :
A la fin de la conversion, le résultat de conversion est recopié dans les registres ADRESH et
ADRESL.
Registre ADCON1 de configuration des E/S et des tensions de références :
Le contrôle du module ADC se fait par les deux registres ADCON0 et ADCON1 (en MikroC
uniquement ADCON1).
En fait, pour la configuration des entrées analogiques ou digitales du PORTA ainsi que les tensions
de références, en MikroC seuls 4 bits LSB (PCFG3:PCFG0) du registre ADCON1 seront utilisés.
5
Programmation des modules ADC, CCP1, UART ete LCD n MikroC :
Lecture du résultat de conversion A/D sur l'entrée x : ADC_Read(x)

Initialisation du module CCP1 à la fréquence x en Hz : PWM1_Init(x)
Démarrage du module CCP1 : PWM1_Start()
Arrêt du module CCP1 : PWM1_Stop()
Envoi de la valeur x au module CCP1 : PWM1_Set_Duty(x)
Initialisation du module UART1 avec débit x en bps : UART1_Init(x)
Test de réception sur l'UART1 (si oui 1, sinon 0) : UART1_Data_Ready()
Lecture du caractère reçu sur l'UART1 : UART1_Read()
Emission de caractère x sur l'UART1 : UART1_Write(x)
Emission de chaine de caractère x sur l'UART1 : UART1_Write_Text("x")
Initialisation du module LCD : Lcd_Init()
Envoi de commande x au module LCD : Lcd_Init(x)
Affiche chaine sur LCD à la ligne l et la colonne c : Lcd_Out(l, c, "Chaine")
Commande d'effacement de l'écran LCD : _LCD_CLEAR
Commande masquant le curseur sur le LCD : _LCD_CURSOR_OFF

Systèmes D'acquisitions Des Données

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Systèmes D'acquisitions Des Données

Transféré par

Droits d'auteur :

Formats disponibles

1

 Architecture des systèmes à processeurs

 Transmission et acquisition de données

 Eléments du Module Arduino

Avantage du C2 +5 0000 0101

par rapport aux +4 0000 0100

Un seul '0' +0 0000 0000

est représenté -0 -----

– Exemple : (12 + 07)10 = (19)10

IMPORTANT : Toujours travailler en 8, 16, 32 bits ou plus

C2(0000 0111)2 = C1(0000 0111)2 + 1

 (12 - 07)10 = (0000 1100)2

Architecture des systèmes à processeurs

Capteur Unité de transfert Interface de Moteur

Bus CAN Commande

Unité RAM ROM

Autoroute assurant TRANSPORT de

Bus de Contrôle Mixte Contrôle le flux des données

Pointeur de programme (PC)

Registre d’Etat (Status)

UAL : Unité Arithmétique et Logique

PC : COMPTEUR PROGRAMME (ou Compteur Ordinal)

Le PC contient sous forme binaire l'adresse de la prochaine instruction à

Status : Registre d’ETAT

* Indicateur de Retenue après Addition (C : Carry =1 s’il y a Retenue ) ou

– Gammes des PIC

– Architecture matérielle Harvard :

Cas des PIC

– Architecture Logicielle RISC (Reducted Instruction Set Computers) :

– Il existe 3 familles de PIC :

– Points communs à tous les µC :

– 1 cycle machine ( = 4 coups d’horloge) pour exécuter 1

 FQ: 0 à 4 MHz ou 0 à 20 MHz selon le type de µC

Résonateur Quartz ou Céramique. Circuit oscillant externe RC.

Horloge externe pour synchroniser le PIC sur un processus particulier.

• L'E2PROM (Mémoire non volatile) :

– Contient le programme à exécuter.

– 1k "mots" = 1024 cases de 14 bits :

– La 2ème : les GPR (General Purpose Registers)

– Réparties sur 2 pages ("Bank") :

Fonction de chacun des

– Registres Spéciaux - SFR :

 STATUS : État de l’UAL + Bits de sélection des "Bank".

• Ports d’entrée / sortie du PIC16F84

•  2 registres de Travail PORTA & PORTB +

Registres de Configuration des Ports

 Sens de direction des données (Entrée ou sortie)

– TRISA  Direction de ligne RA4, … RA0

– Bit x = 0 dans TRISA ou TRISB  Sortie et

– Registres Spéciaux - SFR :

– Registres Spéciaux - SFR :

Registres de Travail des Ports

• PORTA  Ligne RA4, … RA0

 PORTA : Accès en lecture ou écriture au port A. Le bit 4 utilisé en entrée de comptage.

 OPTION_REG : Bits de configuration pour divers périphériques.

 OPTION_REG : Bits de configuration pour divers périphériques.

Résistance de tirage ou de Pull-Up interne

Valeur des Diviseur Diviseur Valeur des Diviseur Diviseur

Exemple: Interruption externe sur la broche RB0/INT.

Configurations de Liste de la majorité des

En-tête du programme principal

(signed) int 16 -32768 à 32767

unsigned int 16 0 à 65535

char p ; Désigne un Pointeur sur un type défini