ARCH Sys Proce

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

ARCH Sys Proce

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

ARCH Sys Proce

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