Cours Systeme Embarque Master

SYSTÈME EMBARQUÉ
Mamadou Lamine NDIAYE
École Supérieure Polytechnique de DAKAR
Master 2016-2017
Dakar 2017
1
SYSTÈME EMBARQUÉ
OBJECTIF GENERAL
30 heures de cours 40 BE
! Comprendre l’architecture et le fonctionnement des
systèmes embarqués
o Connaître l'architecture interne des systèmes
embarqués
o Mettre en œuvre un système embarqué
o Gérer des interfaces entrées – sorties
! Maîtriser l’implémentation de système d’exploitation
pour l’embarqué
o Etre capable d’installer un OS pour l’embarqué
o Etre capable de développer des applications sur
l’OS
2
SYSTÈME EMBARQUÉ
1ière Partie : Introduction aux circuits logiques à architecture
programmable
o
o
INTRODUCTION AUX CIRCUIT FPGA
INTRODUCTION AU VHDL
2ième Partie : ARCHITECTURE DES CALCULATEURS
o
o
Exemple d’architecture CISC le 68HC11
Exemple d’architecture RISC le PIC 16F887
3ième Partie : Introduction aux systèmes embarqués
o
o
o
o
Qu’est ce qu’un système embarqué
Exemple de la Nintendo DS
Programmation des SE
Evolution des processeurs dans les SE
4ième Partie : Processeurs ARM
o STM32 Nucleo F401RE
3
1ième Partie : Introduction aux circuits
logiques à architecture programmable
4
Classification des familles des circuits numériques
5
Introduction aux circuits à architecture
programmable
! Circuits logiques à architecture programmables
o
o
o
o
Ciruits intégrés logiques programmables au sens de sa
reconfiguration.
Cellules logiques librement assemblagbles
Possibilités de modification des connexions par progrmmation.
Plusieurs sigles existent pour désigner ces circuits.
! Quelques Circuits à architecture programmable
o
o
o
o
o
Circuit PAL(Programmable Array Logic) où seules les fonctions
ET sont programmables
Circuit FPLA (Field Programmable Logic Array) est un circuit PAL
dans lequel les fonctions ET et OU sont programmables
Cirduit CPLD (Complex Progrmmable Logic Device) est un circuit
logique programmable complexe
Cirduit EPLD (Erasabe Progrmmable Logic Device) est un circuit
logique programmable et effeçable
Cirduit FPGA (Field Progrmmable Gate Array) est un réseau de
ciruits programmables à la demande
6
Les circuits FPGA
! Les circuits logiques programmables de type FPGA sont de plus en
plus utilisés dans la conception des circuits numériques.
! Matrices de fonctions logiques (cellules logiques SRAM)
! Programmation des interconnexions (reconfiguration de l’architecture)
in situ
! Reprogrammables à volonté
! Temps de développement très court.
! Grande souplesse pour des évolutions rapides à moindre coût
7
Les circuits FPGA
! Densités d’intégration pouvant atteindre plus de 10 millions de portes
logiques.
! Possibilités de traitement parallèle des données (augmentation de la
vitesse de calcul).
! Blocs logiques configurables constitués d’arbres de multiplexeurs
connectés à des points mémoires.
! Capacité limitée par le nombre de blocs logiques configurables (non la
complexité).
8
Carte DE0 NANO
Specifications FPGA
• Altera MAX II EPM2210F324 FPGA device
I/O Devices
• Built-in USB Blaster for FPGA configuration
Switches, LEDs, Displays, and Clocks
• 1 DIP switche
• 4 pushbutton switches
• 2 red user LEDs,
• 2 yellow user LEDs,
• 2 blue user LEDs,
• 2 green user LEDs
• 50-MHz oscillator for clock sources
• Powered by USB
Prototyping Areas
• A 40-pin expansion port area compatible with Altera
DE2/DE1 expansion ports.
• Prototyping Area A with 68 GPIO, 6 3.3V, 2 5V and
8 GND pins
• Prototyping Area B with 20 GPIO, 2 3.3V, and 2
GND pins
9
CARTE DE2 POUR LES TP (ALTERA)
Specifications FPGA
• Cyclone II EP2C35F672C6 FPGA
I/O Devices
• Built-in USB Blaster for FPGA configuration
• 10/100 Ethernet, RS-232, Infrared port
• Video Out (VGA 10-bit DAC)
• Video In (NTSC/PAL/Multi-format)
• USB 2.0 (type A and type B)
• PS/2 mouse or keyboard port
• Line-in, Line-out, microphone-in
(24-bit audio CODEC)
• Expansion headers (76 signal pins)
Memory
• 8-MB SDRAM, 512-KB SRAM, 4-MB Flash
• SD memory card slot
Switches, LEDs, Displays, and Clocks
• 18 toggle switches
• 4 debounced pushbutton switches
• 18 red LEDs, 9 green LEDs
• Eight 7-segment displays
• 16 x 2 LCD display
• 27-MHz and 50-MHz oscillators, external SMA clock
10
input
CARTE DE2 POUR LES TP (ALTERA)
11
VHDL introduction
! VHDL signifie VHSIC Hardware Description Language
! VHSIC = Very High Speed Integrated Circuit.
! VHDL est un langage international défini par la norme IEEE qui
permet de décrire de manière non ambiguë le comportement
d’un circuit ou d’un système numérique.
! Les objectifs du langage VHDL
o Conception de circuits intégrés reconfigurables ou non (ASIC, FPGA…) :
SYNTHESE
o Mise au point de modèle de simulations numériques (circuits virtuels) :
MODELISATION
VHDL introduction
! Ce langage à la différence des autres langages informatiques,
n’est pas destiné à être exécuté, l’aboutissement étant la
synthèse de circuits logiques
! La synthèse est le processus qui permet d’obtenir
automatiquement une organisation matérielle à partir du
codage des spécifications dans un langage de haut niveau
(VHDL, VERILOG, VHDL-AMS, VERILOG-AMS).
! Le langage est capable de DECRIRE
o des composants (ENTITY + ARCHITECTURE)
o des comportements CONCURRENTS ( // )
o des comportements séquentiels
Méthodologie de conception des FPGA (CPLD)
Méthodologie de conception des FPGA (CPLD)
Niveaux de description
! Comportemental ou fonctionnel
o Le modèle est décrit par, sa fonction, son algorithme. Il s’agit de
décrire comment cela fonctionne.
! Structurel (RTL « Register Transfert Logic »)
o Le modèle est décrit sous forme d'éléments séquentiels
o Prend en compte la notion d’horloge, de cycle;
! Porte logique (Structurel)
o Le modèle est décrit par sa topologie (netlist) de portes logiques, de
registres, de composants
! Décomposition du cahier des charges en fonctions simples
o Fonctions combinatoires (instructions concurrentes)
o Fonctions séquentielles (process)
Introduction au VHDL
Introduction au VHDL
Nom du cours
Prof. Mamadou Lamine NDIAYE
Introduction au VHDL
● VHDL signifie VHSIC Hardware Description Language
● VHSIC = Very High Speed Integrated Circuit
● VHDL est un langage international défini par la norme IEEE qui permet
● Synthèse logique des circuits numériques
● Synthèse physique des circuits numériques
● Les objectifs du langage VHDL
●
●
Conception de circuits intégrés reconfigurables ou non (ASIC, FPGA…) : SYNTHESE
Mise au point de modèle de simulations numériques (circuits virtuels) : MODELISATION
Enseignes et afficheurs à LED ! Synthèse de circuits
combinatoires
VHDL : Les concepts de base
Unités de conception : deux parties dépendantes (obligatoires)
● L’entité (Entity) qui représente la vue extérieure du composant
o Déclare les modes des ports en entrée et/ou sortie (in, out, inout, buffer)
o IN port à lecture seule
o OUT port à écriture seule
o INOUT port à lecture/écriture
o BUFFER écriture/lecture sur un port
● L’architecture (Architecture) qui décrit le fonctionnement du composant
o Représente la vue interne du composant
o Décrit le comportement de la fonction à synthétiser
o Décrit les signaux internes, les composants, les constantes, les types d’objets, les
déclarations de sous programmes dans la partie dite déclarative (début)
o A une entité peut correspondre plusieurs architectures
Enseignes et afficheurs à LED ! Synthèse de circuits
combinatoires
Structure générale d’un programme VHDL
Entity Nom_entite is
-- déclarations de paramètres, ports..
Begin
End Nom_entite;
Architecture Nom_archi of Nom_entite is
-- Zone déclarative...
Begin
--instructions concurrentes...
P1: process
-- déclarations...
Begin
--instructions séquentielles...
end process P1;
-- instructions concurrentes...
P2: process
-- déclarations...
Begin
--instructions séquentielles...
end process P2;
-- instructions concurrentes...
End Nom_archi ;
Structure générale d’un programme VHDL
Exemple :
Multiplexeur 2 vers 1
Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Déclaration des
bibliothèques
-- multiplexeur 2 vers 1 (commentaire)
e1
e2
sel
mux2
s
Entity mux2 is
-- commentaire
Commentaires en VHDL
Port( e1, e2 : in std_logic;
sel : std_logic;
-- par défaut le mode in est pris
en compte
s : out std_logic
-- mode out à préciser
);
end mux2;
Déclaration de
-- Déclaration de l’architecture (commentaire) l’entité du
multiplexeur
architecture archi_mux2 of mux2 is
Déclaration de
begin
l’architecture du
with sel select
multiplexeur
s <= e1 when ’1’,
-- s recopie e1 lorsque sel
= 1
e2 when others;
-- recopie e2 dans tous les autres
cas
end archi_mux2;
Objets et types de base
Quatre objets « typés »
● Les constantes (CONSTANT), objet dont la valeur ne change pas
durant la simulation.
● Les variables (VARIABLE) objet dont la valeur peut changer par
affectation au cours de la simulation. Une variable n’existe que
dans un PROCESS.
● Les signaux (SIGNAL) désignent des signaux internes qui ne
sortent pas du composant.
● Les fichiers (FILE) permettent l'échange de données entre
l'extérieur et le simulateur VHDL.
Objets et types de base
Quelques exemples
CONSTANT cte : INTEGER :=10;
VARIABLE vari : BIT_VECTOR(3 DOWNTO 0):= "0000";
VARIABLE n : INTEGER range 0 to 65535;
SIGNAL sig : std_logic;
SIGNAL a : bit_vector (3 downto 0);
FILE fich : TEXT IS IN "entree.txt";
Objets et types de base
Quelques exemples
Bit : peut prendre les valeurs `0´ ou `1´.
Bit_vector : groupe de bits défini entre " "
Boolean: peut prendre les valeurs true ou false.
Integer : Valeur entière codée sur 32 bits (de - 2.147.483.648 à 2.147.483.647)
Std_logic, std_ulogic : Similaires au bit mais avec 9 états possibles.
Time : comptage du temps sur 64 bits, en ps, ns, us, ms, sec, min, hr (non
synthétisable) ;
Opérateurs en VHDL
Les opérateurs arithmétiques et logiques
VHDL manipule six opérateurs hiérarchisés
● 1 Opérateurs divers :
● 2 Opérateurs de multiplication :
● 3 Opérateurs d’addition :
● 4 Opérateurs relationnels :
● 5 Opérateurs de décalage :
● 6 Opérateurs logiques :
**, abs, not
*, /, mod, rem
+, -, &
=, /=, < , <= , >, >=
sll, srl , sla,sra,rol,ror
and , or, nand, nor, xor, xnor
Littéraux en VHDL
Les littéraux (valeurs explicites)
● Caractères :
● Chaînes :
● Chaînes de bits :
● Décimaux :
● Basés :
1 , c , b , #
"10110100", "bonjour", "x@&"
B"0010_1101", X "2F", O "265"
27, -5, 4e3, 76_562, 4.25
2#1001#, 8#65_07, 16#C5#e2
● Une chaine de bit est représenté par un vecteur de bits
● std_logic_vector( 7 downto 0);
● std_logic_vector( 0 to 7);
-- bit poids fort => poids faible
-- bit faible poids => poids fort
Tableaux en VHDL
Les tableaux (ARRAY)
● Les tableaux sont des collections de données de même type
● Les données sont rangées suivant un index (entier) ou des
énumérés
type bus is array (0 to 31) of bit;
type COULEURS is (ROUGE, JAUNE, BLEU, VERT, ORANGE);
-- type énuméré
TYPE memoire IS ARRAY(0 TO 31) OF STD_LOGIC_VECTOR(7 DOWNTO 0);
-- déclaration du tableau mémoire
type TABLEAU1 is array(0 to 31) of bit_vector(7 downto 0);
type TABLEAU2 is array(0 to 31, 0 to 7) of bit;
SIGNAL Tab_Mem: memoire; -- création d’un tableau de type memoire
Signal S1 : TABLEAU1;
Signal S2 : TABLEAU2;
Begin
S1(0) <="01101011 »;
-- Modification des bits de la première ligne
S1 (31)(5) <= '1';
-- Modification du bit la 32ieme ligne 6ime colonne de S1
S2(4,7) <= '0';
-- Modification du bit la 5ieme ligne 8ime colonne de S2
Concepts de base du VHDL : instructions
concurrentes
Nom du cours
Prof. Mamadou Lamine NDIAYE
VHDL : Les instructions concurrentes
Logique combinatoire : Instructions concurrentes
●Décomposition en fonction simple (concurrente), ensemble de
composants ou d’algorithmes travaillant en parallèle et agissant
les uns sur les autres.
●Chaque instruction effectue donc un traitement en parallèle avec
les autres instructions.
●L’ordre d’écriture des instructions est sans importance.
Affectation simple
signal <=
● Connexion de deux signaux
● Utilise l’opérateur <=
Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;
Entity fonction_simple is
Port( e1, e2 : in std_logic;
s1, s2 : out std_logic
);
End fonction_simple;
Architecture archi_simple of
fonction_simple is
Begin
s1 <= e1 and e2;
-- ordre d écriture indiff
s2 <= e1 or e2;
-- ordre d écriture indiff
end archi_simple;
signal1
Affectation conditionnelle
signal <=
signal1 when expresion1 else
………
signal2 when expresion2 else
signal3 ;
● Affectation conditionnelle WHEN / ELSE
o C’est une instruction qui a une seule cible mais peut avoir plusieurs expressions.
o Les conditions sont évaluées séquentiellement, si une condition est vraie alors
l’expression correspondante est exécutée.
Affectation conditionnelle
signal <=
signal1 when expresion1 else
………
signal2 when expresion2 else
signal3 ;
● Affectation conditionnelle WHEN / ELSE
o C’est une instruction qui a une seule cible mais peut avoir plusieurs expressions.
o Les conditions sont évaluées séquentiellement, si une condition est vraie alors
l’expression correspondante est exécutée.
Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;
Entity mux2 is
Port( e1, e2 , sel : in std_logic;
s : out std_logic
architecture archi_mux2 of
mux2 is
begin
s <= e1 when sel=’0’ else
e2;
);
end mux2;
end archi_mux2;
Affectation sélective
with expression select
signal
<= signal1 when valeur1,
signal2 when valeur2,
signal 3 when others ;
● Affectation sélective WITH ……SELECT
o C’est une affectation d’une valeur suivant l’état de l’expression testée.
o Exemple : Décodeur 7 segment
Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;
entity Bcd7Segment is
Port ( data : in STD_LOGIC_VECTOR (3 downto 0);
7Segment : out STD_LOGIC_VECTOR (0 to 6));
end Bcd7Segment;
Affectation sélective
with expression select
signal
<= signal1 when valeur1,
signal2 when valeur2,
signal 3 when others ;
architecture comportement of
Bcd7Segment is
begin
with data select
7Segment <=
"0000001" when x"0" ,
"1001111" when x"1" ,
"0010010" when x"2" ,
"0000110" when x"3" ,
"1001100" when x"4" ,
"0100100" when x"5" ,
"0100000" when x"6" ,
"0001111" when x"7" ,
"0000000" when x"8" ,
"0000100" when x"9" ,
"1111111" when others;
end comportement;
Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;
entity Bcd7Segment is
Port ( data : in STD_LOGIC_VECTOR
(3 downto 0);
7Segment : out
STD_LOGIC_VECTOR (0 to 6));
end Bcd7Segment;
Component
Les Composants (component)
● Le mot COMPONENT permet de déclarer un prototype (modèle) de composant
● L’instanciation du composant se fait alors dans le corps de l’architecture
● <NOM_INSTANCE>:<NOM_COMPOSANT> port map (LISTE DES CONNEXIONS);
ARCHITECTURE Structure OF Decodeur_7seg IS
LIBRARY ieee;
USE ieee.std_logic_1164.all;
COMPONENT Bcd7Segment
PORT (data : IN STD_LOGIC_VECTOR(3 DOWNTO 0);
ENTITY Decodeur_7seg IS
HEX
PORT (SW : IN STD_LOGIC_VECTOR(15
DOWNTO 0);
BEGIN
LEDR : OUT STD_LOGIC_VECTOR(15
DOWNTO 0);
-- red LEDs
HEX3, HEX2, HEX1, HEX0 : OUT
STD_LOGIC_VECTOR(0 TO 6));
-- 7-segs
END Decodeur_7seg ;
: OUT
STD_LOGIC_VECTOR(0 TO 6));
END COMPONENT;
LEDR <= SW;
digit3: Bcd7Segment PORT MAP (SW(15 DOWNTO 12),
HEX3);
digit2: Bcd7Segment PORT MAP (SW(11 DOWNTO 8), HEX2);
digit1: Bcd7Segment PORT MAP (SW(7 DOWNTO 4), HEX1);
digit0: Bcd7Segment PORT MAP (SW(3 DOWNTO 0), HEX0);
END Structure;
Génération conditionnelle
label : if (condition) generate
● Génération conditionnelle : GENERATE
o
o
o
o
-- suite d’instructions concurrentes
end generate label;
Permet l’exécution conditionnelle d’instructions concurrentes
label : for i in 0 to x generate
Permet l’exécution itérative d’instructions concurrentes
Les instructions ne seront prises en compte que si la condition est vraie. -- suite d’instruction concurrente
End generate label ;
s’utilise avec for (itérative) ou if (conditionnelle)
Génération conditionnelle
● Génération conditionnelle : GENERATE
o
s’utilise avec for (itérative) ou if (conditionnelle)
label : if (condition) generate
-- suite d’instructions concurrentes
end generate label;
label : for i in 0 to x generate
-- suite d’instruction concurrente
End generate label ;
--librairie pour inclure type std_logic
Library ieee;
Use ieee.std_logic_1164.all;
entity Additionneur4bit is
Port(
ri : IN std_logic ;
A, B : IN
std_logic_vector(3 downto 0) ;
s : OUT
std_logic_vector(3 downto 0) ;
r : OUT std_logic
);
end Additionneur4bit;
architecture Structure of
Additionneur4bit is
-- declaration du composant
additionneur1bit
component additionneur1bit is
port( ri : IN std_logic ;
a,b :IN std_logic ;
So,r : OUT std_logic ) ;
end component additionneur1bit ;
-- declaration des signaux internes
pour le report des retenues ci
signal C : std_logic_vector( 3
downto 0 );
Begin
C(0) <= ri ;
-- Création des 4 aditionneurs
A : for i IN 0 to 3 GENERATE
LSB : if i = 0 GENERATE
b0 : additionneur1bit port map
(C(i) , A(i) , B(i) , s(i) , C(i) );
End GENERATE LSB
MSB : if i > 0 GENERATE
b3 : additionneur1bit port map
(C(i-1) , A(i) , B(i) , s(i) , C(i) );
End GENERATE MSB;
End GENERATE A;
r <= C(3) ;
end Structure;
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY additionneur1bit IS
PORT ( ri, a, b : IN
STD_LOGIC;
So, r : OUT STD_LOGIC);
END additionneur1bit;
ARCHITECTURE Archi OF
additionneur1bit IS
BEGIN
r <= (a AND b) OR (ri AND (a
XOR b));
So <= a XOR b XOR ri;
END Archi;
Concepts de base du VHDL : Instructions
séquentielles
Nom du cours
Prof. Mamadou Lamine NDIAYE
VHDL : Les concepts de base
Logique séquentielle : Mot clè PROCESS
! Les instructions séquentielles du VHDL sont très évoluées à
l’image des langages de haut niveau.
o On les utilise souvent dans un process, les instructions s’exécutent suivant l’ordre
d’écriture.
o Plusieurs process peuvent s’exécuter en parallèle dans une même architecture;
o le déroulement est SEQUENTIELLE (ordre d’écriture des instructions).
o Un process peut contenir des parties combinatoires, des parties séquentielles.
o Un process est activé lors d’un changement d’état d’un des signaux de la liste de
sensibilité
o Les instructions utilisables dans un PROCESS sont SPECIFIQUE ( pas de when/
else par exemple)
o Les signaux sont mis à jour uniquement à la fin du process
SYNTHAXE
Process
begin
q <= d;
wait until Reloj = 1 ;
end process;
Process
begin
c <= a and b;
wait on a, b;
end process;
Process(a,b)
begin
c <= a and b;
end process;
Les Process
Les instructions séquentielles du VHDL sont très évoluées à
l’image des langages de haut niveau :
o Utilisation d’un process ou un sous-programme
o Déroulement séquentiel (ordre d’écriture des instructions)
o Possibilité d’exécution de plusieurs Process en parallèle
o Un Process peut contenir des parties combinatoires et des parties séquentielles
o Un Process est activé lors d’un changement d’état d’un des signaux de la liste de
sensibilité
o Les instructions utilisables dans un Process sont spécifiques
o Les signaux sont mis à jour uniquement à la fin du Process
Les Process
Les règles de fonctionnement :
o Boucle infinie
o Synchronisation par des points d’arrêt
Process (S1, S2)
Begin
SYNTHAXE
…............
end process;
Process
Begin
…............
Wait …....;
…............
end process;
Les Process
L’instruction séquentielle wait peut prendre plusieurs formes :
o wait on signal
o wait for temps
SYNTHAXE
o wait until conditions
o wait on signal until conditions for temps
-- liste de
sensibilité
wait on S1, S2;
-- délai
wait for 100ns;
-- conditions
wait until ck = ‘1’;
-- conditions
wait on S1, S2 until
ck = ‘1’;
-- forme générale
wait on S1, S2 until ck = ‘1’ for
100ns;
Instructions de contrôle
● Instruction IF
if
elsif
else
end if;
o If … then …; [ elsif …then] ; [ else …] ; end if;
o Toute instruction if doit se terminer par un end if;
expression1 then action1 ;
expression2 then action2 ;
….......
action3 ;
Instructions de contrôle
●Instruction CASE…IS
CASE
WHEN
WHEN
selecteur IS
condition1
=> instructions 1;
condition2
=> instructions 2;
…............
WHEN OTHERS
=>
instructions N
END CASE;
o Permet de sélectionner une séquence d’instructions en fonction de la valeur d’une
expression.
o Tous les cas doivent être traités, on utilisera ainsi la directive when others pour lister
les différents cas possibles.
o Souvent utilisée pour la description de machines d’état ou toute fonction de type
table de vérité.
Instructions de contrôle
●Instructions de boucle
o Mot clé LOOP.
o Possibilité d’utiliser Next
o Possibilité d’utiliser Exit
-- boucle for
-- la variable de boucle est i de 1 à 100
etiquette: FOR i IN 1 TO 100 LOOP
-- instruction répétitive
…..........
END LOOP etiquette;
-- boucle while
etiquette: WHILE conditions LOOP – boucle tant que
-- instruction répétitive
…..........
END LOOP etiquette;
-- boocle générale
etiquette: LOOP – boucle infinie
-- instruction répétitive
…..........
END LOOP etiquette;
Synthèse des bascules
● Bascule RS
Enseignes et afficheurs à LED ! Synthèse de circuits
combinatoires
Synthèse des bascules
● Bascule RS
o Activé sur front montant de l'horloge (Ck)
ARCHITECTURE Archit OF BasculeRS IS
SIGNAL Sr, Ss, Qa, Qb: STD_LOGIC ;
BEGIN
PROCESS(Ck, R, S) -- liste de sensibilité
BEGIN
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY BasculeRS IS
PORT (Ck, R, S : IN STD_LOGIC;
Q : OUT STD_LOGIC);
END BasculeRS;
-- validation du front montant
IF Ck'event and Ck = '1' then
-- rising_edge(Ck) front montant
-- falling_edge(Ck) descendant
Sr <= R;
Ss <= S;
Qa <= NOT ( Sr OR Qb);
Qb <= NOT ( Ss OR Qa);
END IF;
END PROCESS;
Q <= Qa;
END Archit;
Synthèse des bascules
● Bascule D
o La sortie Q prend l'état de l'entrée D sur front montant de l'horloge (Ck)
Synthèse des bascules
● Bascule D
o La sortie Q prend l'état de l'entrée D sur front montant de l'horloge (Ck)
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY BasculeD IS
PORT (Ck, D : IN
STD_LOGIC;
Q : OUT STD_LOGIC);
END BasculeD;
ARCHITECTURE Structural OF BasculeD IS
SIGNAL Qa: STD_LOGIC ;
BEGIN
PROCESS(Ck, D) -- liste de sensibilité
BEGIN
-- validation du front montant
IF RISING_EDGE(Ck) then
Qa <= D;
ELSE Qa <=Qa ;
END IF;
END PROCESS;
Q <= Qa;
END Structural;
Synthèse des bascules
● Bascule D avec entrées de forçage SET et RESET
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY BasculeD IS
PORT (Ck, D, R, S : IN STD_LOGIC;
Q : OUT STD_LOGIC);
END BasculeD;
ARCHITECTURE Structural OF BasculeD IS
SIGNAL Qa: STD_LOGIC ;
BEGIN
PROCESS(Ck, D, R, S) -- liste de sensibilité
BEGIN
IF R = ‘1’ THEN
Qa <= ‘0’;
ELSIF S = ‘1’ THEN Qa <= ‘1’;
ELSIF Ck’EVENT AND Ck = '1’ THEN
Qa <= D;
-- validation du front montant
ELSE Qa <=Qa ;
END IF;
END PROCESS;
Q <= Qa;
END Structural;
Synthèse des bascules
● Bascule JK
J
K
Q
0
0
1
1
0
1
0
1
Inchangée
0
1
Opposée
Synthèse des bascules
● Bascule JK
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY BasculeJK IS
Port ( Ck, J, K : in std_logic;
Q : out std_logic);
End BasculeJK;
ARCHITECTURE Structural OF BasculeJK IS
SIGNAL Qa : std_logic;
BEGIN
PROCESS (Ck, J, K)
BEGIN
IF Ck'event and Ck='1’
then
IF J=‘0’ and K='0’
then Qa <= Qa;
ELSIF J=‘0’ and K=’1'
then Qa <= ‘0’ ;
ELSIF J=‘1’ and K=’0'
then Qa <= ‘1’ ;
ELSE
Qa <= (NOT) Qa ;
END IF;
END IF;
END PROCESS;
Q <= Qa;
END Strctural;
Synthèse des compteurs
● Compteur modulo 10
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY Compteur IS
PORT (Ck, R : IN
STD_LOGIC;
Q: OUT STD_LOGIC_VECTOR (3 downto
0));
END Compteur;
ARCHITECTURE Structural OF Compteur IS
SIGNAL Qa: STD_LOGIC_VECTOR (3 downto 0);
BEGIN
PROCESS(Ck, R) -- liste de sensibilité
BEGIN
IF R = ‘0’ then
Qa <= "0000";
-- validation du front montant
ELSIF Ck'event and Ck = '1' then
Qa <= STD_LOGIC_VECTOR (UNSIGNED(Qa)+ 1);
IF Qa=”1001" THEN Qa <= "0000";
END IF;
END IF;
END PROCESS;
Q <= Qa;
END Structural;
Synthèse des compteurs
● Compteur modulo 10
● Fréquence du comptage
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY Compteur IS
PORT (Ck, R : IN
STD_LOGIC;
Qh: OUT STD_LOGIC_VECTOR (23 downto 0);
Q: OUT STD_LOGIC_VECTOR (3 downto 0));
END Compteur;
ARCHITECTURE Structural OF Compteur IS
SIGNAL Qa: STD_LOGIC_VECTOR (3 downto 0) ;
SIGNAL Qha: STD_LOGIC_VECTOR (23 downto 0) ;
BEGIN
PROCESS(Ck, R) -- liste de sensibilité
BEGIN
IF R = ‘1’ THEN Qa <= "0000";
ELSIF (Ck'event and Ck = '1’) THEN
Qha <= STD_LOGIC_VECTOR (UNSIGNED(Qha)+ 1);
IF (Qha ="100110001001011010000000") THEN
IF Qa=”1010" THEN
Qa <= "0000";
ELSE
Qa <= STD_LOGIC_VECTOR (UNSIGNED( Qa) + 1);
END IF;
ELSE
Qa <= Qa;
END IF;
END IF;
END PROCESS;
Q <= Qa;
END Structural;
Synthèse des compteurs
● Compteur modulo N
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY Compteur IS
PORT (Ck, R : IN
STD_LOGIC;
Q0: OUT STD_LOGIC_VECTOR (3 downto 0);
Q1: OUT STD_LOGIC_VECTOR (3 downto 0);
Q2: OUT STD_LOGIC_VECTOR (3 downto 0));
END Compteur;
ARCHITECTURE Structural OF Compteur IS
SIGNAL Qa0, Qa1, Qa2: STD_LOGIC_VECTOR (3 downto
0) ;
BEGIN
PROCESS(Ck, R) -- liste de sensibilité
VARIABLE Qh : INTEGER RANGE 0 TO 50000000;
BEGIN
IF R = ‘1’ THEN
Qa0 <= "0000"; Qa1 <= "0000"; Qa2 <= "0000";
ELSIF (Ck'event and Ck = '1’) THEN
Qh := Qh + 1;
IF (Qh = 50000000) THEN
Qa0 <= Qa0 + 1;
IF Qa0 =“1001” then Qa1 <= Qa1 + 1;
Qa0 <=
“0000“;
IF Qa1 =“1001” then Qa2 <= Qa2 + 1;
Qa1 <= “0000“;
END IF;
END IF;
ELSE
Qa0 <= Qa0; Qa1 <= Qa1; Qa2 <= Qa2;
END IF;
END IF;
END PROCESS;
Q0 <= Qa0; Q1 <= Qa1; Q2 <= Qa2;
END Structural;
Synthèse des regitres
● Registre à décalage série parallèle
Synthèse des regitres
● Registre à décalage série parallèle
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY BasculeD IS
PORT (Ck, D : IN STD_LOGIC;
Q : OUT STD_LOGIC);
END BasculeD;
ARCHITECTURE Structural OF BasculeD IS
SIGNAL Qa: STD_LOGIC ;
BEGIN
PROCESS(Ck, D) -- liste de sensibilité
BEGIN
-- validation du front montant
IF Ck'event and Ck = '1' then
Qa <= D;
ELSE Qa <=Qa ;
END IF;
END PROCESS;
Q <= Qa;
END Structural;
Synthèse des regitres
● Registre à décalage série parallèle
ARCHITECTURE Structural OF RegistreSP IS
COMPONENT BasculeD
PORT (Ck, D : IN
Library ieee;
Use ieee.std_logic_1164.all;
ENTITY RegistreSP IS
PORT (Ck, ES : IN
STD_LOGIC;
SS : OUT
STD_LOGIC;
SP : OUT
STD_LOGIC_VECTOR (0 TO 3));
END RegistreSP;
Q : OUT
STD_LOGIC;
STD_LOGIC);
END COMPONENT ;
SIGNAL Qa, Qb, Qc, Qd: STD_LOGIC ;
BEGIN
U1:
BasculeD PORT MAP (Ck, ES, Qa);
U2:
BasculeD PORT MAP (Ck, Qa, Qb);
U3:
BasculeD PORT MAP (Ck, Qb, Qc);
U4:
BasculeD PORT MAP (Ck, Qc, Qd);
SP(0) <= Qa; SP(1) <= Qb; SP(2) <= Qc;
SP(3) <= Qd;
END Structural;
Application au contrôle d’une matrice à LED
Nom du cours
Prof. Mamadou Lamine NDIAYE
Matrice à LED RGB 16X32 de Adafruit
Matrice 16X32(Adafruit)
● 512 Led RGB rangées sous forme de matrice 16X32 (existe aussi en 32X32)
● Nécessite 12 pins (6 données et 6 contrôle) et une alimentation de 5V (2A
minimum suggérée)
● Contrôle par Arduino et carte FPGA
● Adafruit à developper des bibliothèses pour Aduino
Cette version de la matrice RGB 16x32 à
des LEDs placées tous les 6mm. La matrice
est composée de 512 LEDs RGB brillantes
arrangées en grille de 16x32 à l'avant.
L'arrière est équipé de deux connecteurs
IDC (un pour le signal d'entrée (input) et un
pour la sortie (output)). En théorie, ces
panneaux sont chainables et 12 latchs 16bit permettent de piloter l'afficheur avec un
taux de rafraîchissement de 1:8.
La matrice est divisée en 8 sections. La
première section est constitué de la 1ère
ligne et de la 9ième ligne, la 2ième section de
la 2ième ligne et de la 10ième , …..la dernière
section de la 8ième ligne et de la 16ième.
Ces af ficheur s sont techniquement
'chaînable' - connectez la sortie de l'un à
l'entrée de l'autre. Ces panneaux
nécessitent une bonne alimentation 5V.
Chaque panneau peut consommer jusque 2
Ampères. Nous vous recommandons une
alimentation (minimum) 5V intégrant un
régulateur.
Matrice à LED RGB 16X32 de Adafruit
Alimentation
● Existe en 2 types de connecteur pour l’alimentation
Input pins
Output pins
Input pins
Matrice à LED RGB 16X32 de Adafruit
Connecteur IDC
● Existe 2 connecteurs (input et output)
D pin ou Masse
Input pins
Matrice à LED RGB 16X32 de Adafruit
Spécifications des pins IDC
● Les pins R1, G1 and B1 délivrent les données de couleurs pour
la première moitiée des leds (1-8x32). Si nous utilisons Arduino
pour la commande: les connecter sur les pins 2, 3, 4 (UNO) ou
24,25,26 (MEGA)
●Les pins R2, G2 and B2 délivrent les données de couleurs pour
la deuxième moitiée des leds (9-16x32). Si nous utilisons Arnuino
pour la commande: les connecter sur les pins 5, 6, 7 (UNO) ou
27,28,29 (MEGA)
● Les pins A, B, C permettent de sélectionner les 8 sections de
leds à commander. Si vous utiliser un 16X32 D doit être à la
masse. A, B, C seront connectés sur les pins A0, A1 et A2 et D à
A3 ou à la masse
●LAT (latch) signale la fin de la ligne des données, il sera
connecté au pin A3
●CLK (clock) rythme le contrôle de chaque bit de données. il sera
connecté au pin 8 (UNO) ou 11(MEGA)
●OE (output enable) permet de commuter les LEDs pour aller
d’une ligne au suivant. il sera connecté au pin 9.
D pin ou Masse
Matrice à LED RGB 16X32 de Adafruit
Assignation des pins IDC pour Ardiono
IDC pin
R1
G1
UNO
MEGA
2 3
24 25
B1
R2
G2
B2
A
B
C
LAT
CLK
OE
4
26
5
27
6
28
7
29
A0
A0
A1
A1
A2
A2
A3
A3
8
11
9
9
D pin ou Masse
Matrice à LED RGB 16X32 de Adafruit
Library Arduino
● Deux Librairies à télécharger :
o RGB Matrix Panel Library: https://github.com/adafruit/RGB-matrix-Panel
o Adafruit GFX Library : https://github.com/adafruit/Adafruit-GFX-Library
●Des exemples de codes disponibles en téléchargement :
https://learn.adafruit.com/arduino-tips-tricks-and-techniques/arduino-libraries
● La librairie offre plusieurs fonctions permettant de manipuler plus simplement la matrice.
Présentation de la matrice à LED
Présentation de la matrice à LED
Matrice 32x32
● 1024 Led RGB rangées sous forme de matrice 32X32
● Résolution : 32 x 32 pixels, 3 couleurs par pixel (rouge, vert, bleu)
● Distance entre deux pixels : 6mm
● Longueur d’onde :
o
o
o
Rouge : 625±5nm
Vert
: 520±5nm
Bleu
: 470±5nm
● Tension d’alimentation : 5V DC (régulé)
● Consommation max : 4A
● Dimensions: 190.5mm x 190.5mm x 14mm
● Nécessite 13 pins (6 données et 7 contrôle) et une alimentation de 5V (4A
minimum suggérée)
● Contrôle par Microcontrôleur et carte FPGA
Présentation de la matrice à LED
Matrice 32X32(fonctionnement)
32x32
Présentation de la matrice à LED
Matrice 32x32 (fonctionnement)
16x32
32x32
16x32
Présentation de la matrice à LED
o
o
o
o
o
Matrice 32x32 (Chargement des données)
Trois registres à décalages 32 bits
3 registres pour chaque moitié
Synchronisés par la même horloge
Chargement en série des données de couleurs
32 bits par couleur (Rouge, Vert, Bleu)
Présentation de la matrice à LED
Matrice 32x32 (Registre de chargement)
Présentation de la matrice à LED
Matrice 32x32 (Seléction des lignes )
Présentation de la matrice à LED
Matrice 32x32 (Sélection des lignes )
D
C
B
A
Ligne
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0
1
0 et 16
1 et 17
2 et 18
3 et 19
4 et 20
5 et 21
6 et 22
7 et 23
8 et 24
9 et 25
10 et 26
11 et 27
12 et 28
13 et 29
14 et 30
15 et 31
Contrôle de la Matrice à LED RGB 32x32
Spécifications des pins IDC
● Les pins R1, G1 et B1 délivrent les données de couleurs pour la
première moitiée des leds (1-16x32).
● Les pins R2, G2 et B2 délivrent les données de couleurs pour la
deuxième moitiée des leds (17-32x32).
● Les pins A, B, C, D permettent de sélectionner les 16 sections
de leds à commander.
● CLK (clock) rythme le contrôle de chaque bit de données.
● LAT (latch) permet le transfère des données à la fin du
chargement.
● OE (output enable) permet d’activer ou de verrouiller l’affichage.
Contrôle de la Matrice à LED RGB 32x32
Assignation des pins IDC pour test sur DE0 ALTERA
Matrix Pin FPGA Pin Pin Name
R1
G1
B1
R2
G2
B2
A
B
C
D
CLK
OE
LAT
PIN_E7
PIN_E10
PIN_E8
PIN_F9
PIN_D9
PIN_C9
PIN_E11
PIN_D11
PIN_C11
PIN_B11
PIN_A12
PIN_D12
PIN_B12
GPIO 18
GPIO 27
GPIO 20
GPIO 22
GPIO 24
GPIO 25
GPIO 26
GPIO 31
GPIO 28
GPIO 29
GPIO 30
GPIO 32
GPIO 33
Contrôle de la Matrice à LED RGB 32x32
Assignation des pins IDC pour test sur DE0 ALTERA
Matrix Pin FPGA Pin Pin Name
R1
G1
B1
R2
G2
B2
A
B
C
D
CLK
OE
LAT
PIN_E7
PIN_E10
PIN_E8
PIN_F9
PIN_D9
PIN_C9
PIN_E11
PIN_D11
PIN_C11
PIN_B11
PIN_A12
PIN_D12
PIN_B12
GPIO 18
GPIO 27
GPIO 20
GPIO 22
GPIO 24
GPIO 25
GPIO 26
GPIO 31
GPIO 28
GPIO 29
GPIO 30
GPIO 32
GPIO 33
Contrôle de la Matrice à LED RGB 32x32
Structure du projet
● Matrix32x32rgb
ohorloge
oscan_matrice
Matrix32x32rgb.vhd
Horloge.vhd
scan_matrice.vhd
Contrôle de la Matrice à LED RGB 32x32
o Entité de Matrix32x32rgb.vhd.
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
entity Matrix32x32rgb is
port (
horloge_in : in std_logic;
rst_n
: in std_logic;
r1
: out std_logic;
g1
: out std_logic;
b1
: out std_logic;
r2
: out std_logic;
g2
: out std_logic;
b2
: out std_logic;
ck_ser
: out std_logic;
-- clk
ck_par
: out std_logic;
-- lat
oe_n
: out std_logic;
-- oe
ligne_sel : out std_logic_vector(3
downto 0) );
end Matrix32x32rgb ;
Contrôle de la Matrice à LED RGB 32x32
o Architecture de
Matrix32x32rgb.vhd.
Architecture Behavioral of
Matrix32x32rgb is
signal rst_p
: std_logic;
signal horloge_bit : std_logic;
Begin
-- Le bouton reset est activé niveau bas
rst_p <= not rst_n;
-- Horloge (diviseur de frequence)
MON_HORLOGE : entity work.horloge
port map (
rst
=>
rst_p,
clk_in
=>
horloge_in,
clk_out =>
horloge_bit
);
-- Raffraichssement de la matrice
SCAN_MATRICE : entity
work.scan_matrice
port map (
rst
=> rst_p,
clk_in
=> horloge_bit,
matrice_r1
=> r1,
matrice_g1
=> g1,
matrice_b1
=> b1,
matrice_r2
=> r2,
matrice_g2
=> g2,
matrice_b2
=> b2,
matrice_ck_ser => ck_ser,
matrice_ck_par => ck_par,
matrice_oe_n
=> oe_n,
matrice_abcd => ligne_sel
);
end Behavioral ;
Contrôle de la Matrice à LED RGB 32x32
o Entité de horloge.vhd.
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity horloge is
port (
clk_in
: in std_logic;
clk_out
: out std_logic;
rst : in std_logic
);
end entity horloge;
architecture bhv of horloge is
constant clk_in_freq
: integer := 50000000;
constant clk_out_freq
: integer := 10000000;
constant OUT_PERIOD_COUNT : integer :=
(clk_in_freq / clk_out_freq)-1;
begin
Contrôle de la Matrice à LED RGB 32x32
o Architecture de horloge.vhd
Process (clk_in , rst)
variable count : integer range 0 to OUT_PERIOD_COUNT;
begin
if( rst = '1') then
count := 0;
clk_out <= '0';
elsif (rising_edge( clk_in )) then
if( count = OUT_PERIOD_COUNT) then count := 0;
else count := count + 1;
end if;
if( count > OUT_PERIOD_COUNT / 2) then clk_out <= '1';
else clk_out <= '0';
end if;
end if;
end process;
end bhv;
Contrôle de la Matrice à LED RGB 32x32
o Entité de scan_matrice.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity scan_matrice is
port (
clk_in
rst
matrice_r1
matrice_g1
matrice_b1
matrice_r2
matrice_g2
matrice_b2
matrice_ck_ser
matrice_ck_par
matrice_oe_n
matrice_abcd
);
end entity scan_matrice;
: In std_logic;
: In std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic_vector (3 downto 0)
Contrôle de la Matrice à LED RGB 32x32
o Entité de scan_matrice.vhd
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
entity scan_matrice is
port (
clk_in
rst
matrice_r1
matrice_g1
matrice_b1
matrice_r2
matrice_g2
matrice_b2
matrice_ck_ser
matrice_ck_par
matrice_oe_n
matrice_abcd
);
end entity scan_matrice;
: In std_logic;
: In std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic_vector (3 downto 0)
Contrôle de la Matrice à LED RGB 32x32
o Architecture de scan_matrice.vhd
Architecture archi of scan_matrice is
signal ck_ser : std_logic;
signal ck_par : std_logic;
signal oe
: std_logic;
signal count : std_logic_vector (9 downto 0);
signal ligne : std_logic_vector (3 downto 0);
Begin
Process (clk_in, rst, count, ligne)
begin
if( rst = '1') then
count <= (others => '0');
ligne <= (others => '0');
Contrôle de la Matrice à LED RGB 32x32
o Architecture de scan_matrice.vhd (suite)
elsif ( rising_edge( clk_in )) then
if( count = "1111111111") then
count <= (others => '0');
if ( ligne = "1111") then
ligne <= (others => '0');
else
ligne <= std_logic_vector( unsigned ( ligne ) + 1 );
end if;
else
count <= std_logic_vector( unsigned ( count ) + 1 );
end if;
end if;
if (unsigned (count) < 32) then ck_ser <= '1'; else
if (unsigned (count) = 32) then ck_par <= '1'; else
if (unsigned (count) > 32) then oe
<= '1'; else
end if;
end process;
end archi;
ck_ser <= '0'; end if;
ck_par <= '0'; end if;
oe
<= '0';
Contrôle de la Matrice à LED RGB 32x32
o Architecture de scan_matrice.vhd suite
Réalisation de motifs fixes avec AND
process( clk_in )
begin
-- Chargement des données de couleurs
matrice_r1
<= count (0) and ligne (0) and
matrice_g1
<= count (1) and ligne (1) and
matrice_b1
<= count (2) and ligne (2) and
matrice_r2
<= count (0) and ligne (0) and
matrice_g2
<= count (1) and ligne (1) and
matrice_b2
<= count (2) and ligne (2) and
-- Génération des signaux de contrôle
matrice_ck_ser
matrice_ck_par
matrice_oe_n
matrice_abcd
end process;
<=
<=
<=
<=
ck_ser and clk_in;
ck_par and clk_in;
not oe;
ligne;
(not
(not
(not
(not
(not
(not
oe);
oe);
oe);
oe);
oe);
oe);
Contrôle de la Matrice à LED RGB 32X32 de
Adafruit
Contrôle de la Matrice à LED RGB 32X32 de
Adafruit
Réalisation de motifs fixes avec XOR
process( clk_in )
begin
-- chargement des données de couleurs
matrice_r1
<= ( count (0) xor ligne (0)) and (not oe);
matrice_g1
<= ( count (1) xor ligne (1)) and (not oe);
matrice_b1
<= ( count (2) xor ligne (2)) and (not oe);
matrice_r2
<= ( count (0) xor ligne (0)) and (not oe);
matrice_g2
<= ( count (1) xor ligne (1)) and (not oe);
matrice_b2
<= ( count (2) xor ligne (2)) and (not oe);
-- Génération des signaux de contrôle
matrice_ck_ser
<=
ck_ser and clk_in;
matrice_ck_par
<=
ck_par and clk_in;
matrice_oe_n <=
not oe;
matrice_abcd
<=
ligne;
end process;
Simulation des signaux de Contrôle
Simulation des signaux de Contrôle
Test sur la matrice RGB 32x32
Contrôle de la Matrice à LED RGB 32x32
Ajout d’une mémoire
● Matrix32x32rgb
ohorloge
oscan_matrice
omemoire_vive
Matrix32x32rgb.vhd
horloge.vhd
scan_matrice.vhd
memoire_vive.vhd
Contrôle de la Matrice à LED RGB 32x32
o Architecture de Matrix32x32rgb.vhd.
Architecture Behavioral of Matrix32x32rgb
is
signal
signal
signal
0);
signal
0);
rst_p
: std_logic;
horloge_bit : std_logic;
adresse : std_logic_vector(8 downto
donnee : std_logic_vector (5 downto
begin
-- Le bouton reset est activé niveau bas
rst_p <= not rst_n;
-- Memoire
MEMOIRE_VIVE : entity work.memoire
port map (
rst
=> rst_p,
clk_rd
=> horloge_bit,
addr
=> adresse,
output => donnee
);
-- Raffraichssement de la matrice
SCAN_MATRICE : entity
work.scan_matrice
port map (
rst
=> rst_p,
clk_in
=>
horloge_bit,
matrice_r1
=> r1,
matrice_g1
=> g1,
matrice_b1
=> b1,
matrice_r2
=> r2,
matrice_g2
=> g2,
matrice_b2
=> b2,
matrice_ck_ser => ck_ser,
matrice_ck_par => ck_par,
matrice_oe_n
=> oe_n,
matrice_abcd => ligne_sel ,
addr
=> adresse,
data
=> donnee
);
end Behavioral ;
Contrôle de la Matrice à LED RGB 32x32
o Entité de scan_matrice.vhd
entity scan_matrice is
port (
clk_in
rst
matrice_r1
matrice_g1
matrice_b1
matrice_r2
matrice_g2
matrice_b2
matrice_ck_ser
matrice_ck_par
matrice_oe_n
matrice_abcd
addr
data
);
end entity scan_matrice;
: In std_logic;
: In std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic;
: out std_logic_vector (3 downto 0) ;
: out std_logic_vector (8 downto 0);
: in std_logic_vector (5 downto 0)
Contrôle de la Matrice à LED RGB 32x32
o Architecture de scan_matrice.vhd
Architecture archi of scan_matrice is
signal ck_ser : std_logic;
signal ck_par : std_logic;
signal oe : std_logic;
signal count : std_logic_vector (10 downto 0);
signal ligne : std_logic_vector (3 downto 0);
Begin
Process (clk_in, rst, count, ligne)
begin
if( rst = '1') then
count <= (others => '0');
ligne <= (others => '0');
Contrôle de la Matrice à LED RGB 32X32
o Architecture de scan_matrice.vhd (suite)
elsif ( rising_edge( clk_in )) then
if( count = "11111111111") then
count <= (others => '0');
if ( ligne = "1111") then
ligne <= (others => '0');
else
ligne <= std_logic_vector( unsigned ( ligne ) + 1 );
end if;
else
count <= std_logic_vector( unsigned ( count ) + 1 );
end if;
end if;
if (unsigned (count) < 32) then ck_ser
if (unsigned (count) = 32) then ck_par
if (unsigned (count) > 32) then oe
end process;
end archi;
<= '1'; else ck_ser <= '0'; end if;
<= '1'; else ck_par <= '0'; end if;
<= '1'; else oe
<= '0'; end if;
Contrôle de la Matrice à LED RGB 32X32
Chargement des données et génération des signaux de contrôle
process( clk_in )
begin
-- Gestion des adresses
addr(0) <= count(0);
addr(1) <= count(1);
addr(2) <= count(2);
addr(3) <= count(3);
addr(4) <= count(4);
addr(5) <= ligne(0);
addr(6) <= ligne(1);
addr(7) <= ligne(2);
addr(8) <= ligne(3);
-- chargement des données de couleurs
matrice_r1
matrice_g1
matrice_b1
matrice_r2
matrice_g2
matrice_b2
<= data(0);
<= data(1);
<= data(2);
<= data(3);
<= data(4);
<= data(5);
-- Génération des signaux de contrôle
matrice_ck_ser <= ck_ser and clk_in;
matrice_ck_par <= ck_par and clk_in;
matrice_oe_n <= not oe;
matrice_abcd <=
ligne;
end process;
Contrôle de la Matrice à LED RGB 32x32
o Entité de memoire.vhd
entity memoire is
port (
rst
clk_rd
addr
output
);
end entity memoire ;
: In std_logic;
: In std_logic;
: in std_logic_vector (8 downto 0);
: out std_logic_vector (5 downto 0)
Contrôle de la Matrice à LED RGB 32x32
o Architecture de memoire.vhd
architecture archi1 of memoire is
type ram is array (511 downto 0) of std_logic_vector (5 downto 0);
signal mem : ram;
begin
process ( clk_rd, rst )
begin
if ( rst = '1') then
-- initialisation des données de la memoire
elsif ( falling_edge ( clk_rd )) then
-- chargement des données de la memoire
end if;
end process;
process( clk_rd )
begin
if( falling_edge( clk_rd )) then
output <= mem (conv_integer ( addr ));
end if;
end process;
end archi1;
Matrice à LED RGB 16X32 de Adafruit
Exemples : Testcolors
#include <Adafruit_GFX.h>
// Core graphics library
#include <RGBmatrixPanel.h>
// Hardware-specific library
#define CLK 8
// si vous utilisez UNO
#define LAT A3
#define OE 9
#define A A0
#define B A1
#define C A2
RGBmatrixPanel matrix(A, B, C,
CLK, LAT, OE, false);
void loop() {
// Ne fait rien
}
void setup() {
matrix.begin();
uint8_t r=0, g=0, b=0;
// Déssine la première moitié
for (uint8_t x=0; x < 32; x++) {
for (uint8_t y=0; y < 8; y++) {
matrix.drawPixel(x, y,
matrix.Color333(r, g, b));
r++;
if (r == 8) {
r = 0;
g++;
if (g == 8) {
g = 0;
b++;
}
}
}
}
// Déssine la deuxième moitié
for (uint8_t x=0; x < 32; x++) {
for (uint8_t y=8; y < 16; y++) {
matrix.drawPixel(x, y,
matrix.Color333(r, g, b));
r++;
if (r == 8) {
r = 0;
g++;
if (g == 8) {
g = 0;
b++;
}
}
}
}
}
2ième Partie : ARCHITECTURE DES
CALCULATEURS
100
Architecture des calculateurs
1.
2.
3.
4.
5.
Architecture de base
Les mémoires
Le microprocesseur
Les échanges de données
Exemple du microcontrôleur 68HC11
101
Architecture des calculateurs
1. Architecture de Von Neumann
Architecture de base des systèmes à microprocesseurs
!
Les bus :
• Données: bidirectionnel pour le transfert des informations entre le
microprocesseur et son environnement
• Adresses: unidirectionnel qui permet la sélection des informations à traiter
dans un espace mémoire (ou espace adressable) qui peut avoir 2n
emplacements et
• Commande: constitué par quelques conducteurs qui assurent la synchronisation
des flux d'informations sur les bus des données et des adresses
102
Architecture des calculateurs
2. Architecture de Harvard
Architecture de base des systèmes à
microprocesseurs
Les bus :
L’architecture Harvard est souvent utilisée dans :
• les processeurs numériques de signal (DSP) ;
• les microcontrôleurs, notamment les PIC de Microchip et les AVR d'Atmel.
103
Architecture des calculateurs
3. Architecture de Von Neumann vs Harvard
104
Architecture des calculateurs
1. Architecture de Von Neumann
Architecture de base des systèmes à microprocesseurs
Mémoire de
programme
(ROM)
Mémoire de
donnée
(RAM)
Unité de commande
microprocesseur
Unité Arithmétique et Logique
Horloge
Coupleurs d’E/
S
Etc..
Périphériques
105
Architecture des calculateurs
1. Architecture de base : Von Neumann
Architecture de base des systèmes à microprocesseurs
Unité Centrale
• Composée essentiellement du microprocesseur
• Interpréter et exécuter les instructions d’un programme
• Lire et écrire à la mémoire
•
Communiquer avec les entrées sorties.
Mémoire Principale
• Contenir les instructions du programme et les données associées
•
Mémoires ROM et RAM
Entrées sorties
• Assurer la communication entre le microprocesseur et les périphériques
Bus
• Ensemble de fils qui assurent la transmission des informations.
• Bus : données, adresse et commande
106
Architecture des calculateurs
1. Architecture de base : Décodage d’adresse
La multiplicité des périphériques autour du microprocesseur oblige la présence d’un
décodeur d’adresse pour éviter les conflits (bus, sélection, ).
!
Chaque périphérique est associé à une zone d’adresse; une fonction de décodage
d’adresse est nécessaire pour la sélection de chaque composants.
107
Architecture des calculateurs
1. Architecture de base : Décodage d’adresse
La multiplicité des périphériques autour du microprocesseur oblige la présence d’un
décodeur d’adresse pour éviter les conflits (bus, sélection, ).
Exemple de cartographie mémoire
Espace adressable
du µP (65536@)
$0003
$0000
Périphérique
1
Espace
Libre
$2000
$FFFF
RAM
ROM
$4FFF
Espace
Libre
$3FFF
108
Architecture des calculateurs
2. Les mémoires
Avec une adresse de n bits (nombre de fil du bus d’adresse) il est possible de référencer
2n cases mémoire. Chaque case est remplie par un mot de longueur m qui est toujours
une puissance de 2.
Le nombre de fils de données définit la taille des données que l’on peut sauvegarder
dans chaque case mémoire.
Caractéristique d’une mémoire
!
Capacité: Quantité de données max de la mémoire
Format des données: nombre de bits mémorisable par case mémoire
Temps d’accès : temps entre le lancement et la disponible sur bus de données.
Temps de cycle : intervalle minimum qui doit séparer deux opérations successives.
Débit : nombre maximum d'informations lues ou écrites par seconde.
Volatilité : permanence des informations dans la mémoire.
109
Architecture des calculateurs
2. Les mémoires : différents types
! Mémoires Vives : RAM
o Volatile
o Stockage temporaire des données
o Temps de cycle court
! Mémoires mortes: ROM
o
o
o
o
Non volatile
Stockage permanente des données
Mémoire à lecture seule.
Type : ROM, PROM, EPROM, EEPROM FLASH EPROM
110
Architecture des calculateurs
2. Les mémoires : Mémoire cache
Une mémoire cache est motivée par l’écart de performance entre la vitesse du microprocesseur et
celle de la mémoire.
!Problèmes d’accès à la mémoire
o décodage des adresses et la lecture/écriture d’une donnée sont des étapes
difficiles à accélérer
o Le temps de cycle processeur décroît plus vite que le temps d’accès mémoire
o La mémoire n’est pas en mesure de délivrer des informations aussi rapidement
que le processeur est capable de les traiter
!Solutions : mémoire cache
o disposer une mémoire très rapide entre le microprocesseur et la mémoire
o SRAM de taille réduite (à cause du coût)
o stocker les informations les plus récentes ou les plus souvent utilisées par le
microprocesseur
111
Architecture des calculateurs
2. Les mémoires : Mémoire cache
le microprocesseur n’a pas conscience de sa présence et lui envoie toutes ses requêtes comme s’il
agissait de la mémoire principale
!
112
Architecture des calculateurs
2. Les mémoires : Hiérarchie Mémoire
Les mémoires de grande capacité sont souvent très lentes et les mémoires rapides sont
très chères. Le temps d’accès conditionne dans une large mesure les performances.
!
Les registres sont interne au processeur et servent au stockage intermédiaires.
La mémoire cache destinée à accélérer l’accès à la mémoire centrale.
La mémoire principale est l’organe principal de rangement des informations.
La mémoire d’appui elle joue le même rôle que la mémoire cache.
La mémoire de masse est une mémoire périphérique de grande capacité utilisée pour
le stockage permanent magnétiques (disque dur, ZIP) ou optiques (CDROM, DVDROM).
113
Architecture des calculateurs
3. Microprocesseur
Un microprocesseur est construit autour de
deux éléments principaux : unité de
commande et unité de traitement.
5-1 L’unité de commande assure la
recherche et le décodage de l'instruction.
" Compteur de programme
" Registre d'instruction et le décodeur
d'instruction :
" Bloc logique de commande (ou
séquenceur) :
5-2 L’unité de traitement est le cœur du microprocesseur
"L’Unité Arithmétique et Logique (UAL)
"Le registre d'état est généralement composé de 8 bits à considérer
individuellement.On les appelle indicateur d’état ou flag ou drapeaux.
On peut citer par exemple les indicateurs de :
• retenue (carry : C)
• retenue intermédiaire (Auxiliary-Carry : AC)
• signe (Sign : S)
• débordement (overflow : OV ou V)
• zéro (Z)
• parité (Parity : P)
!
114
Architecture des calculateurs
BUS DE DONNEES
3. Microprocesseur : Architecture
Registre de données
Bus interne de données
R0
Rn
Registre d instruction
Registre auxiliaire
Code Op.
Adresse
ALU
Registre d état
Signaux internes
de commande
Décodeur
R
E
G
I
S
T
R
E
D
I
N
D
E
X
SP
PC
Bus interne d adresses
A
C
C
U
M
U
L
A
T
E
U
R
BLOC LOGIQUE DE COMMANDE (CU)
Horloge
Bus de commande
Registre d adresses
BUS D ADRESSES
115
Architecture des calculateurs
3. Microprocesseur : composants
! ALU : C'est un circuit complexe qui assure les fonctions:
o arithmétiques: addition et soustraction
o logiques: ET, OU, OU exclusif
o comparaison, décalage à droite ou à gauche, incrémentation,
décrémentation, mise à 1 ou à 0 d'un bit, test de bit.
! Bloc logique de de commande: Il organise l'exécution des instructions au
rythme d une horloge. Il élabore tous les signaux de synchronisation
internes ou externes (bus des commandes) du microprocesseur
! Registre et décodeur d instructions: Chacune des instructions à exécuter
est rangée dans le registre instruction dont le format est 24 bits. Le premier
octet ( 8 bits) est toujours le code de l'opération que le décodeur d'instruction
doit identifier.
! Pointeur de pile ou stack pointeur: C'est un registre compteur de 16 bits
qui contient l'adresse du sommet de la pile. La pile est externe au
microprocesseur. C'est une certaine partie de la mémoire RAM. Elle est
utilisée pour sauvegarder les contenus des différents registres, lors de l'appel
à un sous-programme ou lors de la gestion d'une interruption, par exemple.
116
Architecture des calculateurs
3. Microprocesseur : composants
! Registre de données: Ce registre de 8 bits est un registre tampon qui
assure l'interfaçage entre le microprocesseur et son environnement ou
inversement. Il conditionne le bus externe ou le bus interne des données.
! Registre d adresses : Ce registre de 16 bits est un registre tampon qui
assure l' interfaçage entre le microprocesseur et son environnement. Il
conditionne le bus externe des adresses.
! Accumulateur :
Un accumulateur est un registre de travail de 8 ou 16 bits qui sert:
o à stocker une opérande au début d'une opération arithmétique et le
résultat à la fin de l'opération.
o à stocker temporairement des données en provenance de l'extérieur du
microprocesseur avant leur reprise pour être rangées en mémoire.
o à stocker des données provenant de la mémoire ou de l'UAL pour les
présenter vers l'extérieur du microprocesseur.
! Registre d état : Chacun de ces bits est un indicateur dont l'état dépend du
résultat de la dernière opération effectuée. On les appelle indicateur d état
ou flag ou drapeaux. Dans un programme le résultat du test de leur état
conditionne souvent le déroulement de la suite du programme.
117
Architecture des calculateurs
3. Microprocesseur : composants
! Registre d’indexe : Le contenu de ce registre de 16 bits est une adresse. Il
est utilisé dans le mode d'adressage indexé
! Registres auxiliaires : Ils permettent de stocker le résultat des instructions
exécuter par l ALU
118
Architecture des calculateurs
3. Microprocesseur
La puissance d’un microprocesseur est caractérisée par le nombre
d’instructions qu’il est capable de traiter par seconde. Elle est définie par :
! le CPI (Cycle Par Instruction) qui représente le nombre moyen de cycles
d’horloge nécessaire pour l’exécution d’une instruction pour un
microprocesseur donné.
! le MIPS (Millions d'Instructions Par Seconde) qui représente la puissance de
traitement du microprocesseur.
FH
MIPS =
CPI
! Pour augmenter les performances d’un microprocesseur, on peut donc soit
augmenter la fréquence d'horloge (limitation matérielle), soit diminuer le CPI
(choix d'un jeu d'instruction adapté).
119
Architecture des calculateurs
3. Microprocesseur : les accumulateurs
120
!
Architecture des calculateurs
3. Le microprocesseur : Cycle d’exécution d’une instruction
Le traitement d’une instruction se fait en 3 phases :
! Phase 1: Recherche de l'instruction
o Le PC contient l'adresse de l'instruction suivante
o Au bout d'un certain temps, le contenu de la case mémoire sélectionnée
est disponible sur le bus des données.
o L'instruction est stockée dans le registre instruction du processeur.
! Phase 2: Décodage de l'instruction et recherche de l’opérande
o L'unité de commande transforme l'instruction en une suite de commandes
élémentaires nécessaires au traitement de l'instruction.
o
Si l'instruction nécessite une donnée en provenance de la mémoire,
l'unité de commande récupère sa valeur sur le bus de données.
o L’opérande est stockée dans un registre.
! Phase 3: Exécution de l'instruction
o Le micro-programme réalisant l'instruction est exécuté.
o Les drapeaux sont positionnés (registre d'état).
o L'unité de commande positionne le PC pour l'instruction suivante.
121
Architecture des calculateurs
3. Le microprocesseur : Le jeu d’instruction
Ensemble des opérations élémentaires que le microprocesseur pourra
exécuter. Il détermine architecture
Type d’instructions
Les instructions peuvent être classées en 4 groupes :
" Transfert de données pour charger ou sauver en mémoire, effectuer des
transferts de registre à registre, etc…
" Opérations arithmétiques : addition, soustraction, division, multiplication
" Opérations logiques : ET, OU, NON, NAND, comparaison, test, etc…
" Contrôle de séquence : branchement, test, etc…
Chaque instruction est toujours codée sur un nombre entier d’octets afin de
faciliter son décodage par le processeur. Une instruction est composée de
deux champs :
" le code instruction, qui indique au processeur quelle instruction réaliser
" le champ opérande qui contient la donnée, ou la référence à une donnée en
mémoire (son adresse).
122
Architecture des calculateurs
3. Le microprocesseur : Le mode d’adressage
Un mode d'adressage définit la manière dont le microprocesseur va accéder
à l’opérande. Les différents modes d'adressage dépendent des
microprocesseurs mais on retrouve en général :
! l'adressage immédiat où l’opérande est située immédiatement après
l’instruction
! l'adressage direct où la donnée est située à l’adresse dont la partie basse
est indiquée après l’instruction, la partie haute étant égale à $00.
! l'adressage indexé de registre où la donnée est située à l’adresse
correspondant à la somme du registre utilisée et de la valeur numérique
qui suit l’instruction
! l'adressage étendu où la donnée est située à l’adresse indiquée après
l’instruction
! l’adressage inhérent ou implicite où l’instruction se suffit à elle même
! L’adressage relatif où la donnée est située à l’adresse correspondant à
l’étiquette donnée
123
Architecture des calculateurs
3. Le microprocesseur : Langage de programmation
Niveau 1 : Le langage machine : Langage de plus bas niveau. C’est le seul
langage que comprend la machine car toutes les instructions et données sont
codées en binaire. C’est le rôle des compilateurs de générer ce code. C’est ce code
là qui est transférer dans la machine.
Niveau 2 : Langage assembleur : Les instructions ne sont pas représentés par
des nombres mais par des mnémoniques. Un mnémonique est une abréviation du
langage parlé afin de décrire une exécution exécutable par le µP
(ex : movlw 7 veut dire mettre la valeur litéralle « 7 » dans le registre W)
Ce langage est propre à chaque µProcesseur.
Niveau 3 : Langage évolué : Afin de facilité la programmation on a mis au point
des langages de haut niveau proche de celui de l’homme : FORTRAN, PASCAL, C,
BASIC, COBOL dont la principale caractéristique est d’être indépendant du
microprocesseur utilisé.
124
Architecture des calculateurs
3. Le microprocesseur : Langage de
programmation
Le langage machine est le langage compris par le
microprocesseur. La taille d’une instruction
(nombre de bits nécessaires pour la représenter
en mémoire) dépend du type d’instruction et aussi
du type d’opérande. L’assembleur est le langage
le plus proche de la machine.
! Chaque instruction est codée en une séquence
de bits sur un nombre entier d’octets afin de
faciliter son décodage par le processeur,
chaque instruction représente un code machine
différent.
! Chaque microprocesseur peut posséder un
assembleur différent
! Forte dépendance avec la machine.
! Langage de Haut niveau : nécessité d’un
compilateur
!
125
Architecture des calculateurs
3. Le microprocesseur : Architecture CISC et RISC
Le sigle CISC signifie Complex Instruction Set Computer.
L’architecture CISC est caractérisée par :
! Grand nombre d’instructions et tâches complexes par une instruction unique
! Instructions complexes pour mieux gérer le temps d’accès mémoire très lent
! Problèmes de compilation pour les langages de haut niveau
! Décodeur d’instruction complexe.
Le sigle RISC signifie Reduce Instruction Set Computer.
L’architecture RISC est motivé par :
! Plus de 80% des traitements des langages de haut niveau faisaient appel à
moins de 20% des instructions du microprocesseur.
! les compilateurs se contentaient le plus souvent d'affectations, d'additions et
de multiplications par des constantes
L’architecture RISC est caractérisée par :
! Instructions simples et en nombre très réduit
! Simplicité du séquenceur libérant ainsi de l’espace permet d’augmenter les
registres.
! Instructions complexes seront réalisées à partir d’instruction élémentaires.
126
Architecture des calculateurs
3. Le microprocesseur : Architecture CISC et RISC
Architecture RISC
instructions simples ne prenant qu’un
seul cycle
instructions au format fixe
décodeur simple (câblé)
beaucoup de registres
seules les instructions LOAD et STORE
ont accès à la mémoire
peu de modes d’adressage
compilateur complexe
Architecture CISC
instructions complexes prenant plusieurs
cycles
instructions au format variable
décodeur complexe (microcode)
peu de registres
toutes les instructions sont susceptibles
d’accéder à la mémoire
beaucoup de modes d’adressage
compilateur simple
127
Architecture des calculateurs
3. Le microprocesseur spéciaux : Le processeur de signal
!Le processeur de signal conçu pour une application spécifique
!Le processeur DSP (Digital Signal Processor) est optimisé pour effectuer du
traitement numérique du signal (calcul de FFT, convolution, filtrage numérique,
etc...).
!Les domaines d’application des D.S.P sont :
o les télécommunications
o le secteur militaire
o Le multimédia (lecteur CD, MP3, etc..)
o l’électronique grand public (télévision numérique, téléphone portable,
etc…),
o l’automatique,
o l’instrumentation,
o l’électronique automobile,
128
Architecture des calculateurs
3. Le microprocesseur spéciaux : Le microcontrôleur
!Un microcontrôleur est un circuit intégré contenant sur une sele puce un
CPU, de la RAM, de la ROM et des ports d’Entrée/Sorties (parallèles, séries,
I2C, etc..).
!Il peut intègrer aussi des fonctions spécifiques comme des compteurs
programmables (mesures de durées), des CAN voir des CNA (chaînes
d’acquisition), des interfaces de communication
!Les domaines d’application des microcontrôleurs sont nombreux :
o applications embarquées
o appareil électroménagers,
o chaîne d’acquisition,
o lecteur carte à puce,
o multimédia (lecteur CD, MP3, etc..)
o l’instrumentation,
o l’électronique automobile,
o Etc.
129
Architecture des calculateurs
4. Les échanges de données
!Un calculateur est équipé d’une ou plusieurs interfaces d’entrées/sorties pour
communiquer avec le monde extérieur.
!Chaque périphérique sera relié au système par l’intermédiaire d’une interface
(ou contrôleur) pour connecter et gérer les échanges
!L’interface est constituée par :
o Un registre de commande dans lequel le processeur décrit le travail à
effectuer (sens de transfert, mode de transfert).
o Un ou plusieurs registres de données qui contiennent les mots à
échanger entre le périphérique et la mémoire.
o Un registre d’état qui indique si l’unité d’échange est prête, si
l’échange s’est bien déroulé, etc…
!Il existe 2 modes d’échange d’information :
o Le mode programmé par scrutation ou interruption où le
microprocesseur sert d’intermédiaire entre la mémoire et le
périphérique
o Le mode en accès direct à la mémoire (DMA) où le microprocesseur ne
se charge pas de l’échange de données.
130
Architecture des calculateurs
4. Les échanges de données : mode programmé scrutation ou
interruption
!le microprocesseur interroge l’interface pour savoir si des transferts sont prêts
!tant que des transferts ne sont pas prêts, le microprocesseur attend
!:
o Un registre de commande dans lequel le processeur décrit le travail à
effectuer (sens de transfert, mode de transfert).
o Un ou plusieurs registres de données qui contiennent les mots à
échanger entre le périphérique et la mémoire.
o Un registre d’état qui indique si l’unité d’échange est prête, si l’échange
s’est bien déroulé, etc…
131
Architecture des calculateurs
4. Les échanges de données : mode programmé
Par scrutation
! le microprocesseur interroge l’interface pour savoir si des transferts sont prêts
! tant que des transferts ne sont pas prêts, le microprocesseur attend
! Le microprocesseur est souvent occupé par les interfaces d’entrées sorties
! Echanges lents et dépend du programme, il faut que le microprocesseur se
trouve dans la boucle de scrutation
Par interruption
! Une interruption est un signal asynchrone au programme en cours
! Un microprocesseur dispose d’une ou de plusieurs entrées d’interruption
! Un signal sur l’une de ces entrées peut interrompre le travail du
microprocesseur et forcer l’exécution d’un programme prioritaire.
! Avant chaque exécution d’instructions, le microprocesseur examine si il y a eu
une requête sur sa ligne d’interruption
! On peut donc interdire ou autoriser certaines sources d’interruptions, on les
appelle les interruptions masquables
! Les interruptions sont classées par ordre de priorité. Si plusieurs interruptions
se présentent en même temps, le microprocesseur traite d’abord celle avec la
priorité la plus élevée
132
Architecture des calculateurs
4. Les échanges de données : mode programmé
!
133
Architecture des calculateurs
4. Les échanges de données : mode direct avec la mémoire
Ce mode permet le transfert de blocs de données entre la mémoire et un
périphérique sans passer par le microprocesseur
!un circuit appelé contrôleur de DMA (Direct Memory Access) prend en charge
les différentes opérations
!Le microprocesseur contribue dans ce transfert à :
o initialiser l’échange en donnant au DMA l’identification du périphérique
concerné
o donner le sens du transfert
o fournir l’adresse du premier et du dernier mot concernés par le transfert
!Un contrôleur de DMA dispose
o d’un registre d’adresse, d’un registre de donnée, d’un compteur et d’un
dispositif de commande (logique câblée).
o Pour chaque mot échange, le DMA demande le contrôle du bus, effectue
la lecture ou l'écriture mémoire dans son registre et libère le bus.
o Il incrémente le registre d’adresse et décrémente son compteur. Lorsque
le compteur atteint zéro, le dispositif informe le processeur de la fin du
transfert par une ligne d'interruption
134
Architecture des calculateurs
4. Les échanges de données : mode direct avec la mémoire
Avantage
! Pendant toute la durée du transfert, le processeur est libre d'effectuer un
traitement quelconque.
Inconvénient
! Limitation des accès mémoire au processeur pendant toute la durée de
l'opération
135
!
Architecture des calculateurs
5.1 Exemple d’architecture CISC le 68HC11 : Présentation
Le 68HC11 série E est un microcontrôleur développé par Motorola construit
autour d’une unité centrale 8 bits. Il possède:
!un espace adressable de 64 Ko (bus d’adresses de 16 bits).
!un convertisseur analogique/numérique 8 bits multiplexé sur 8 canaux.
!une interface de communication série asynchrone(RS232)
!une interface de communication série synchrone
!Des timers très complets
!Chien de garde
!Générations d’interruptions (internes et externes)
!Ports paralèlles.
!Jusqu’à 12 Ko de ROM ou d’EPROM
!Jusqu’à 1 Ko de RAM
!Jusqu’à 8 Ko d’EEPROM
!Le 68 HC11 est disponible en plusieurs versions
136
Architecture des calculateurs
5.1 Exemple le 68HC11 : Structure interne
137
Architecture des calculateurs
5.1 Exemple le 68HC11 : Mode de fonctionnement
Durant la phase reset, deux broche MODA et MODB définissent le mode de
fonctionnement:
!UC seul : fonctionnement autonome, tous les ports du microcontrôleurs sont
disponibles mais la mémoire est limitée à la capacité interne.
!Etendu : Extension de la capacité mémoire ainsi que les périphériques par
ajout de boitiers externes. L’ensemble devient plus puissant mais on perd deux
ports.
!Bootstrap : Lors du reset un programme BOOTLOADER télécharge en RAM un
programme provenant SCI (liaison série asynchrone
!Special Test: Mode destiné pour des tests, le développement en particulier
l’émulateur.
138
Architecture des calculateurs
5.1 Exemple le 68HC11 : Cartographie mémoire
139
Architecture des calculateurs
5.1 Exemple le 68HC11 : Les registres
140
Architecture des calculateurs
5.1 Exemple le 68HC11 : Registres d’état
C’est un registre 8 bits, chaque bit change d’état en fonction du dernier traitement
du microcontrôleur :
!C(0) Carry, retenue: Le résultat de la dernière opération a causé une retenue.
!V(1) Overflow, débordement: le résultat de la dernière opération a provoqué un
débordement.
!Z(2) Zéro: le résultat de la dernière opération est nulle
!N(3) Négatif : le résultat de la dernière opération est négatif
!I(4) masque d’interruption: Les interruptions sont ignorées quand ce bit est à 1.
!H(5) Half Carry, demi-retenue: Utilisé en représentation décima codé en binaire
!X(6) masque d’interruption: Les interruptions XIRQ sont ignorées quand ce bit
est à 1.
!S(7) Ignorer Stop : L’instruction STOP est ignorée lorsque ce bit est à 1.
141
Architecture des calculateurs
5.1 Exemple le 68HC11 : Les différents ports
Le 68HC11 ayant de multiples versions la composition des entrées-sorties est
variable. La série 68HC11A1 ou E1 comporte 38 lignes entrées-sorties réparties
en 5 Ports ( PORTA....PORTE ), Certains sont bidirectionnels et d’autres
unidirectionnels :
! PORT A : Le port A est un port à usage général qui peut être partagé avec le «
Timer » et l’accumulateur d’impulsions.
! PORT B : Le port B est un port à usage général orienté uniquement en sortie.
le tableau ci-dessous montre le registre intervenant sur l’utilisation du Port B.
142
Architecture des calculateurs
5.1 Exemple le 68HC11 : Les différents ports
! PORT C : Le port C est un port à usage général. DDRC est le registre de
contrôle de direction du Port C. PORTCL n’est utile que lorsque le port C est
en entrée, dans ce cas les états logiques présents sur les broches du port C
sont mémorisés dans ce registre à l’instant d’un front actif sur la broche STRA.
143
Architecture des calculateurs
5.1 Exemple le 68HC11 : Les différents ports
! PORT D : Le port D est un port à usage général de 6 bits partagé avec la
communication Série. DDRD est le registre de contrôle de direction du Port D,
il permet de configurer le sens de transfert des données sur les lignes PDO à
PD5 : 0 pour une entrée, 1 pour une sortie.
! PORT E : Le port E est un port à usage général orienté uniquement en entrée,
partagé avec le Convertisseur Analogique Numérique,
144
Architecture des calculateurs
5.1 Exemple le 68HC11 : Le convertisseur Analogique numérique
! PORT D : Le 68HC11 est équipé́ d’un Convertisseur Analogique Numérique à
8 entrées multiplexées. Le multiplexage des 8 entrées se fait en 2 temps c’està-dire 2*4entrées. Il peut également ne faire la conversion que d’une seule
voie par action sur le registre de contrôle du convertisseur ADCTL.
! Les registres qui interviennent dans le fonctionnement du convertisseur
analogique numérique.
145
Architecture des calculateurs
5.1 Exemple le 68HC11 : Le convertisseur Analogique numérique
! ADCTL est le registre de contrôle du convertisseur numérique analogique :
o MUX : 1 le convertisseur réalise les 4 conversions suivant le bit 0 le
convertisseur réalise une conversion suivant les bits CA,CB,CC.
o SCAN: 0 le convertisseur ne réalise qu’une salve de conversion. 1 le
convertisseur réalise les conversions en continu.
o CCF : 1 Indicateur de fin conversion, il est remis à 0 par écriture dans
ADCTL, ce qui provoque une nouvelle conversion quand SCAN = 0
146
Architecture des calculateurs
5.1 Exemple le 68HC11 : La liaison série SCI
! Cette interface permet la communication avec un autre équipement, terminal
ou ordinateur. Les données sont transmises et reçues sous forme série. La
norme RS232 impose des niveaux qui ne sont pas ceux de la logique TTL, il
faut faire appel à un circuit spécialisé́ qui réalise la mise à niveau (MAX232).
Les deux lignes TXD et RXD sont les lignes PD0 et PD1 du 68HC11.
! La mise en service de la SCI va ignorer les valeurs des bits de DDRD0 et
DDRD1 qui fixent le rôle (entrée ou sortie) des lignes PD0 et PD1 et imposer
une sortie pour TXD (PD1) et une entrée pour RXD (PD0). Dès que la SCI ne
sera plus utilisée, les deux lignes reprendront le rôle correspondant DDRD
($1009).
! Les registres qui interviennent dans le fonctionnement de la liaison série
asynchrone.
147
Architecture des calculateurs
5.1 Exemple le 68HC11 : La liaison série SCI
! Les registres qui interviennent dans le fonctionnement de la liaison série
asynchrone.
! SCDR: registre de données
! BAUD: permet de choisir la vitesse de transmission
! SCCR1: configuration de format des données dont les bits les plus
couramment utilisés sont: M = l 9 bits de données. 0 donne 8 bits de données.
! T8 Ecriture du 9ème bit de données. R8 Lecture du 9ème bit de données.
148
Architecture des calculateurs
5.1 Exemple le 68HC11 : La liaison série SCI
!SSCR2 registre de contrôle de la liaison série asynchrone SCI dont les bits les
plus couramment utilisés sont:
o
o
o
o
RE 1 Réception activé, 0 récepteur déconnecté
TE 1 Emetteur activé, 0 emetteur déconnecté
RIE 1 active interruption RDRF-OR, 0 les inhibe
TIE 1 active interruption TDRE, 0 l’inhibe
o
o
o
o
FE 1 Erreur de format de données.
OR 1 Débordement, réception d’une donnée avant utilisation de la précédente.
RDRF 1 Registre de réception plein
149
TDRE 1 Registre d’émission vide
!SCSR registre d’état de la liaison série, bits couramment utilisés:
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Mode d’adressage
!Inhérent: Il n’y a pas d’opérande. Exemple INCA, LSLA, RTI, RTS, etc.
!Immédiat : L’opérande suit immédiatement le code de l’instruction. Exemple LDAA
#20
!Etendu : 16 bits, l’adresse de l’opérande se trouve dans les deux octets qui suivent le
code de l’instruction. Exemple LDAA $1024
!Direct: 8 bits, l’adresse de l’opérande se trouve dans l’octet qui suit le code de
l’instruction. Exemple LDAA $0020
!Relatif : Adressage réservé aux instructions de branchement. Adresse de
branchement = adresse instruction diminuée jusqu’à -128 ou augmentée jusqu’ +127.
Exemple : BNE TEMPO
!Indexé : L’adresse est calculé par le contenu du registre d’index en ajoutant une
valeur comprise entre $00 à $FF qui se trouve dans l’octet qui suit le code de
l’instruction. Exemple LDAA $10, X
!Manipulation de bit: BCLR PORTB, %00110001 Mise à 0 de PB5, PB4 et PB0
BSET $1C,%1110 0100 Mise à 1 de Bit7, 6, 5, 2 de la donnée à l’@
$001C
!Branchement sur test Bit d’1 variable: BRCLR ADCTL,%1000
0000 ,TEMPO Le programme fait un saut à l’étiquette TEMPO si le bit
7 du registre ADCTL vaut 0
150
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Directives d’assemblage
Elles n’ont aucune influence sur le programme proprement dit mais elles orientent le
processus d’assemblage. Processus d’assemblage : Passage du programme texte en
programme binaire compréhensible par le 68HC11
Directive ORG $@ Indique le début ( origine ) du programme
! Directive EQU Equivalence : Associe un nom à une donnée ou une adresse.
Ex :
REGBAS EQU $1000
PORTC EQU $03
! Directive FDB, FDD, FCC Form Constant Byte, Double Byte, Character.
Allocation et mise en place d’octets dans une zone précise en mémoire.
Exemple :CHAINE FCC « VIVE » ici CHAINE correspond à une chaîne de
caractères qui est situé en mémoire.
! Directive RMB Reserve Memory Byte : Réserver un Octet en Mémoire. Exemple
CAPT RMB 2
2 Octets alloués pour une variable appelée CAPT dont on ne
connaît pas la valeur.
151
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Structure d’un programme
Définition des étiquettes « symboles » utilisées
**** EQU ****
Optionnel
ORG $@
Origine RAM si l’on veut affecter des variables de traitement
**** RMB $****
Optionnel
**** FDB $****
Optionnel
ORG $@
Origine RAM du programme
Emplacement des variables de travail
**** Programme ****
END
152
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Instructions de chargement
153
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Instructions Arithmétique et logique
154
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Instructions de décalage et de rotation
155
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Instructions opérations sur des bits
Instructions sur les registres d’index
156
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Instructions de branchement et de contrôle
157
Architecture des calculateurs
5.1 Exemple le 68HC11 : Jeux d’instruction
Instructions de branchement et de contrôle
158
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Présentation du PIC (pages 3,4,8,9,17,20-22)
159
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Présentation du PIC (pages 3,4,8,9,17,20-22)
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Les éléments essentiels du PIC 16F887 sont :
Une mémoire programme de type EEPROM flash de 8K mots de 14 bits,
Une RAM donnée de 368 octets,
Une mémoire EEPROM de 256 octets,
Cinq ports d'entrée sortie, A (8 bits), B (8 bits), C (8 bits), D (8 bits), E(4bits)
Convertisseur Analogiques numériques 10 bits à 14 canaux,
USART, Port série universel, mode asynchrone (RS232) et mode synchrone
SSP, Port série synchrone supportant I2C
Trois TIMERS avec leurs Prescalers, TMR0, TMR1, TMR2
Deux modules de comparaison et Capture CCP1 et CCP2
Un chien de garde,
13 sources d'interruption,
Générateur d'horloge, à quartz (jusqu’ à 20 MHz) ou à Oscillateur RC
Protection de code,
Fonctionnement en mode sleep pour réduction de la consommation,
Programmation par mode ICSP (In Circuit Serial Programming) 12V ou 5V,
Possibilité aux applications utilisateur d’accéder à la mémoire programme,
Tension de fonctionnement de 2 à 5V,
Jeux de 35 instructions
160
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Présentation du PIC (pages 3,4,8,9,17,20-22)
161
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Présentation du PIC (pages 3,4,8,9,17,20-22)
162
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Cartographie mémoire (pages 23-24,26, 28-30)
163
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Cartographie mémoire (pages 23-24,26, 28-30)
164
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Mode d’adressage (pages 39-40)
o Mode d’adressage direct
• on précise dans l’instruction la valeur de l’adresse à laquelle on
veut accéder. Exemple MOVWF 20h.
o Mode d’adressage indirect
• Pour accéder à une position de la RAM en utilisant l’adressage
indirect, on passe toujours par une position fictive appelée INDF
(Indirect File).
• INDF est la case mémoire pointée par le pointeur IRP/FSR.
• IRP est un bit qui se trouve dans STATUS et FSR est un registre
accessible dans tous les bancs.
•
165
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Mode d’adressage (pages 39-40)
166
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Quelques registres de configuration
167
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Ports I/O (page 41-71)
• Le PIC 16F887 dispose de 36 broches d’entrée sortie regroupés dans
5 ports PORTA(8 bits), PORTB(8 bits), PORTC(8 bits), PORTD(8 bits)
et PORTE(4 bits). Chaque broche d’un port peut être configurée soit en
entrée soit en sortie à l’aide des registres de direction TRISA, TRISB,
TRISC et TRISD et TRISE:
• Bit k de TRISx = 0 broche k de PORTx = SORTIE
• Bit k de TRISx = 1 broche k de PORTx = ENTRÉE
• ANSEL: ANALOG SELECT REGISTER pour configurer les
entrées analogiques
168
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Résumé des registres associés au portA
169
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Jeu d’instructions (pages 227-228, 229-235)
o {W,F?d} signifie résultat dans W si d=0 ou w, dans F si d=1 ou f
170
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Jeu d’instructions (pages 227-228, 229-235)
171
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Jeu d’instructions (pages 227-228, 229-235)
172
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Jeu d’instructions (pages 227-228, 229-235)
173
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! ADC (pages 101-111)
174
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! ADC (pages 101-111)
o Ce module est constitué d'un convertisseur Analogique Numérique 10
bits dont l'entrée analogique peut être connectée sur l'une des 14
entrées analogiques externes.
o Les entrées analogiques doivent être configurées en entrée à l'aide
des registres TRISX et/ou ANSEL.
o Les tensions de références permettant de fixer la dynamique du
convertisseur. Elles peuvent être choisies parmi Vdd, Vss, Vref+ ou
Vrefo Le control du module se fait par les deux registres ADCON0 et
ADCON1
175
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! ADC (pages 101-111)
176
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! ADC (pages 101-111)
177
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! ADC (pages 101-111) Programmation
o 1) Configurer les E/S en Analogique/Numérique/Référence (ADCON1)
o 2) Configurer les entrées analogiques en entrées (ANSEL, TRISX)
o 3) Définir l'horloge de conversion à l'aide du diviseur dans ADCON0
o 4) Choisir le canal à convertir et valider le module(ADCON0)
o 5) Attendre le temps d’acquisition(12µs)
o 6) Lancer la conversion, GO=1(ADCON0)
o 7) Attendre fin de conversion,GO=0 ou drapeau ADIF=1
o 8) Traiter le résultat
o 9) Si l'on désire prendre d'autres mesures, recommencer au point 7 en
faisant attention aux timings
178
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! TIMER 0 (pages 75-77) est un compteur 8 bits
! Il est incrémenté́ en permanence soit par l’horloge interne Fosc/4 (mode
timer) soit par une horloge externe appliquée à la broche RA4 du port A
(mode compteur). Le choix de l'horloge se fait à l'aide du bit T0CS du
registre OPTION_REG
o T0CS=0horloge interne
o T0CS=1horloge externe appliquée à RA4
! Dans le cas de l'horloge externe, Le bit T0SE du registre OPTION_REG
permet de choisir le front sur lequel le TIMER s'incrémente.
o T0SE=0incrémentation sur fronts montants
o T0SE=1incrémentation sur fronts descendants
! Quelque soit l'horloge choisie, on peut la passer dans un diviseur de
fréquence programmable (prescaler) dont le rapport est fixé par les bits
PS0, PS1 et PS2 du registre OPTION_REG. L'affectation ou non du
prédiviseur se fait à l'aide du bit PSA du registre OPTION_REG
o PSA=0onutiliseleprédiviseur
o PSA=1pas de prédiviseur(affecté au chien de garde)
! Le contenu du timer TMR0 est accessible par le registre qui porte le
même nom.
179
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! TIMER 0 (pages 75-77)
180
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! TIMER 0 (pages 75-77)
181
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
! L'USART (Universal Synchronous Asynchronous Receiver Transmitter) est
l'un des deux modules de communication série dont dispose le PIC.
! La communication se fait sur les deux broches RC6/TX et RC7/RX qui
doivent être configurés toutes les deux en ENTREE par TRISC.
! Les registres de configuration
• Transmit Status and Control(TXSTA)
• Receive Status and Control(RCSTA)
• Baud Rate Control(BAUDCTL)
!
182
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
! Si on place le bit SYNC du registre TXSTA à 0, l'USART fonctionne dans le
mode asynchrone standard, 10 (ou 11) bits sont transmis ou reçus dans
l'ordre ci-dessous :
- 1 bit de START (toujours 0)
- 8 ou 9 bits de donnée (LSB d'abord)
- 1 bits de STOP (toujours 1)
! La transmission se fait sur RC6/TX et la réception sur RC7/RX
! La configuration et le control du port par les registres TXSTA et RCSTA
! La vitesse de communication par le registre SPBRG et le bit TXSTA.BRGH
! L'accès au port en lecture ou écriture se fait par les registres tampon
RCREG et TXREG. La transmission et la réception se font par deux
registres à décalage, un pour la transmission (TSR) et un pour la réception
(RSR). L'accès au registres tampon peut se faire alors que les registre à
décalage sont en train de transmettre/recevoir une donnée.
! Les drapeaux PIR1.RCIF et PIR1.TXIF sont très utiles pour gérer la lecture/
écriture dans le port. RCIF est positionné quand le port a terminé une
réception et TXIF est positionné quand le buffer de transmission TXREG est
"vide".
183
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
184
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
185
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
! Les étapes de transmission (sans interruption, mode 8 bits)
• 1) S’assurer que l’interruption TXI n’est pas validée
• 2) Configurer la broche TX/RC6 en entrée
• 3)Configurer le registre TXSTA (mode 8bits, valider transmission,
asynchrone, BRGH)
• 4) Initialiser le registre SPBRG pour définir la vitesse de transmission
• 5) Valider le port avec le bit RCSTA.SPEN
• 6) Vérifier que le drape au PIR1.TXIF=1 c.à.d TXREG est vide
• 7) Placer la donnée à transmettre dans le registre TXREG
• 8) recommencer au point 6) tant qu’on a des données à transmettre
186
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
USART (pages 153-166)
La réception est validée par le bit CREN
La réception d'un octet démarre à la réception du bit START
A la réception du bit stop le contenu du registre à décalage RSR est recopié
dans le registre tampon de réception RCREG. Le drapeau RCIF (PIR1.5)
est positionné, l'interruption associée est déclenchée si elle est validée. Le
drapeau RCIF est remis à zéro automatiquement à la lecture dans RCREG.
! Le registre RCREG est un registre double (FIFO à 2 positions). On peut
donc avoir 2 octets en attente dans ce registre et être en train de recevoir
un 3ème dans le registre RSR. A la fin de la réception du 3ème octet, si RCREG
est toujours plein, alors le dernier octet reçu est perdu et le bit OERR
(Overrun ERRor bit) est positionné ce qui provoque l'arrêt des transfert du
registre RSR vers le buffer RCREG. Pour reprendre la réception il faut
réinitialiser le module de réception en mettant à 0 puis à 1 le bit CREN.
! Le drapeau PIR1.RCIF ne passe à 0 que quand la pile RCREG est vide
! Si on reçoit un 0 à la position du bit STOP qui doit être toujours à 1, alors le
bit FERR (Framing ERRor) est positionné. Ce bit ainsi que le 9ème bit (si
utilisé) sont bufferisés, Il doivent être lu dans le registre RCSTA avant la
lecture du registre RCREG.
187
!
!
!
!
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
188
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
189
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
! Les étapes de réception (sans interruption, mode 8 bits)
• 1) S’assurer que l’interruption RCI n’est pas validée
• 2) Configurer la broche RX/RC7 en entrée
• 3) Initialiser le registre SPBRG pour définir la vitesse de
communication
• 4)Configurer le registre TXSTA (asynchrone, BRGH)
• 5)Configurer le registre RCSTA (validation port, mode 8bits, valider
réception continue)
• 6) Attendre que drapeau RCIFpasse à 1 ce qui annonce la fin de
réception d'un octet
7) Lire l’octet reçu dans le registre RCREG
8) recommencer au point 6) tant qu’on a des données à recevoir
190
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
! La gestion de la vitesse de communication
• 1) La vitesse de communication est déterminée par le générateur de
rythme BRG (Baud Rate Generator) qui est dédié au port série. La
vitesse de communication est définie à l'aide du registre de control
SPBRG et du bit BRGH (TXSTA.2) qui quadruple la vitesse quand il est
positionné. Il préférable d'utiliser le mode haute vitesse (BRGH=1) car
permet d'obtenir une meilleur précision sur la fréquence.
191
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! USART (pages 153-166)
! La gestion de la vitesse de communication
192
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Interruption (pages 218-221)
! Une interruption provoque l’arrêt du programme principal pour aller
exécuter une procédure d'interruption. A la fin de cette procédure, le
microcontrôleur reprend le programme principal à l’endroit où il l’a laissé. A
chaque interruption sont associés deux bits, un bit de validation et un
drapeau. Le premier permet d'autoriser ou non l'interruption, le second
permet au programmeur de savoir de quelle interruption il s'agit.
! Sur le 16F887, l'es interruptions sont classées en deux catégories, les
interruptions primaires et les interruptions périphériques. Elles sont gérées
par les registres :
193
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Interruption (pages 218-221)
194
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Interruption (pages 218-221)
! Déroulement d'une interruption
! Lorsque l'événement déclencheur d'une interruption intervient, alors son
drapeau est positionné à 1 (levé). Si l'interruption a été validée (bits de
validations = 1), elle est alors déclenchée : le programme arrête ce qu'il est
en train de faire et va exécuter la procédure d'interruption qui se trouve à
l'adresse 4 en exécutant les étapes suivantes :
o l'adresse contenue dans le PC (Program Counter) est sauvegardée
dans la pile, puis remplacée par la valeur 0004 (adresse de la routine
d'interruption)
o Le bit GIE est placé "0" pour inhiber toutes les interruptions (afin que le
PIC ne soit pas dérangé́ pendant l'exécution de la procédure
d'interruption).
! A la fin de la procédure d'interruption :
o le bit GIE est remis à 1 (autorisant ainsi un autre événement)
o le contenu du PC est rechargé à partir de la pile ce qui permet au
programme de reprendre là où il s'est arrêté
195
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Interruption (pages 218-221)
! Déroulement d'une interruption
! Deux remarques importantes sont à faire :
o Le drapeau reste à l’état haut même après le traitement de
l’interruption. Par conséquent, il faut toujours le remettre à "0" à la fin
de la routine d'interruption sinon l'interruption sera déclenchée de
nouveau juste après la routine d’interruption.
o Seul le PC est empilé automatiquement. Si cela est nécessaire, les
registres W et STATUS doivent être sauvegardés en RAM puis
restaurés à la fin de la routine pour que le microcontrôleur puisse
reprendre le programme principal dans les mêmes conditions où il l'a
laissé.
196
Architecture des calculateurs
5.2 Exemple d’architecture RISC le PIC 16F887 :
! Interruption (pages 218-221)
! Déroulement d'une interruption
! Les sources d'interruption :
197
3ième Partie : SYSTÈME EMBARQUÉ
198
Qu’est ce qu’un système embarqué ?
o Traditionnelement
o
o
o
o
Contrôleurs de machines à laver
Régulateurs de température du frigo
Vidéocassettes
...
o ASICs ou microcontrôleurs simples
(8-bit PIC MB95F204K ou famille de 16-bit PIC)
199
Qu’est ce qu’un système embarqué ?
o Maintenant les systèmes embarqués sont partout
o Caméras, console de jeux, SmartPhones, etc.
o ...
200
Qu’est ce qu’un système embarqué ?
o Le business ultime : la convergence digitale
o
Un dispositif avec plusieurs fonctions
o Microprocesseurs 32 bits
o Plus de mémoire, plus de versatilité
o 75% du marché sont des cœurs ARM (Advanced Risc Machines)
201
Conception des systèmes embarqués
o Les systèmes embarqués sont très complexes
o Microprocesseurs 32 bit, plusieurs types de mémoires, etc.,
oLes ingénieurs doivent travailler avec tous les composants de
ces nouveaux systèmes
o Limités en capacités de mémoire et de performance
o Valeur dans l’ensemble: compréhension et optimisation globale du système
complet!
202
Conception des systèmes embarqués
o Étudier les systèmes embarqués en détail:
o Microprocesseurs de 32 bit, mémoires, Bluetooth, boutons, touch-pad, écran
tactile, wifi, son, etc.
o Utiliser un « système réel »: Nintendo Development System (DS) par
exemple
203
Contenu de cette partie
o Introduction aux systèmes embarqués microprogrammés
o Plate-forme physique de la Nintendo DS (NDS)
o Introduction au logiciel de compilation et GUI
oMicroprocesseur et hiérarchie de mémoire
o Architecture des microprocesseurs et mémoire dans la Nintendo DS
o Programmation combinée C-assembleur
o Gestion des E/S et des circuits périphériques
o Description des périphériques et des E/S dans la Nintendo DS
o Contrôleurs d’interruption simple
o Interface et gestion des boutons, clavier, écrans (LCD et tactile) et son
o Développement de « solutions complètes » sur la NDS
o Utiliser un « système réel »: Nintendo Development System (DS) par
exemple
204
Contenu de cette partie
o Introduction aux systèmes embarqués microprogrammés
o Système embarqué microprogrammé : quoi, pourquoi et quand
o Comparaisons avec les systèmes embarqués traditionnels
o Principaux domaines d'application et les contraintes de conception
o Différents niveaux d’architectures : matériel et logiciel
o Développement en C
o Etude de cas: Nintendo DS (NDS) Lite
o Architecture matérielle
o Conception de logiciels - compilation basée sur C
o Travaux pratiques 2: Se familiariser avec l'environnement et en commençant par C
pour NDS
205
Qu’est ce qui a changé dans les s. e ?
oDéfinition du système embarqué (traditionnel):
o Système informatique conçu pour exécuter un (ou quelques) fonctions dédiées,
souvent avec la complexité de calcul limitée, mais avec des contraintes de calcul
en temps réel. Il fait partie d'un dispositif complet typiquement y compris le matériel
et les pièces mécaniques.
o Caractéristiques et fonctionnalités obligatoires : ARMS
o Availability A(t) : Disponibilité = probabilité du système à travailler à l'instant t
o Reliability R(t) : Fiabilité = probabilité du système à travailler correctement à
l'instant t
o Maintainability M(d) : Maintenabilité = probabilité du système à travailler
correctement d unités de temps après la survenue d’une erreur.
o Safety : Sécurité
oContraintes obligatoires de conception:
o De petite taille, mais à faible coût (grand volume de production)
o Utilisation de faible puissance
206
Clé du développement de l’electronique automobile
oQu'est-ce que "l'électronique automobile»?
o fonctions de véhicules mis en œuvre avec des systèmes embarqués
• l'électronique de carrosserie
• Electronique système: châssis, moteur
• Information / divertissement
70% des futures innovations dans nos véhicules sera possible que grâce à
l'amélioration des systèmes électroniques embarqués
207
Dernières électronique automobile
oensemble complexe de systèmes embarqués microprogrammés
o Les dernières BMW contiennent plus de 150 microprocesseurs embarqués
208
Convergence numérique, l'exemple du SmartPhone
oQuels sont les principaux nouveaux composants de ces systèmes
embarqués microprogrammés?
o Un dispositif, de multiples fonctions
o Centre des médias omniprésents et les réseaux sociaux
o SmartPhone : la prochaine commande pour semi-conducteurs. Industrie
209
Qu’est ce qui a changé dans les s. e ?
oDéfinition du système embarqué microprogrammé:
o Système informatique conçu pour exécuter un ensemble de fonctions (y
compris la vidéo, la communication et un grand ensemble de dispositifs
d'E / S) spécifique au domaine, mais avec calcul limité et des contraintes
souples en temps réel. Il est un appareil portable qui comprend le
matériel, les logiciels et les pièces mécaniques.
o Dispose de fonctionnalités ARMS importants, mais pas essentiel
o Pas vraiment à risque, seuls les clients malheureux
o
Pas d’usage général en informatique! Nécessité de gérer les
contraintes dans la conception des s.e pour ne pas perdre le marché
o
Petite taille / poids, le coût plus faible possible (moyenne production
vol.)
o L'intégration de puissance faible est la contrainte la plus importante:
o "Les téléphones 3G actuels peuvent difficilement être utilisés de nos jours
pour plus d'une heure, si les données sont vraiment en cours de
transmission" en 2010. Alors qu’avec la 4G en 2015, certains SmartPhone
peuvent tenir 8 heures.
210
Architecture matérielle des s.e
oQuatre composantes fondamentales du matériel
o 1. Unité centrale de traitement / s (CPU): 32 bits Reduced Instruction Set Computer
(RISC)
o 2. Hiérarchie de mémoire: 1-2 niveau de cache, rapide et principaux mémoires à
semi-conducteurs externes
o 3. Interconnexions: un ou plusieurs bus multiples (nombre différent de largeurs ou
vitesses bits)
o 4. Dispositifs E/S : Multiple, personnalisé par domaine
oArchitecture NDS Lite
o
o
2 processeurs: ARM9 et ARM7
mémoire Cache, 4MB mem
principale., 656KB de VRAM,
deux 16KB RAM rapide
o 17 bus 16 bits et 8 bus 32 bits
o 1 LCD TFT, 1 écran tactile TFT,
8 boutons, 4 directions,
microphone, haut-parleur, Wifi et
GBA sur chariot carte flash,
211
NDS : Traitement et gestion des E/S
oDeux noyaux asymétriques Advanced RISC Microprocesseurs 32 bits
o 946E-S ARM: traitement des logiciels utilisateur et différents périphériques d'E /S
o ARM 7TDMI-S: dédié I / O support (son, wifi et des clés spécifiques)
212
NDS : Cartographie mémoire
213
Contrôle et Programmation des s.e
o Plusieurs niveaux d'abstraction possible, le choix dépend de
l'efficacité requise I / O et la complexité générale de la validation des
systèmes embarqués
o
Bas niveau = Assemblée Langue, chaque ligne est une opération fondamentale
minimum à faire par le microcontrôleur / microprocesseur
o Haut niveau : langues d'abstraction de haut niveau
214
Java and C: trendiest languages for
Java et C lesmicroprogrammed
langages les plus embedded
utilisés dans
les s.e
systems
Very
different très
objectives,
but both
foundont
their
reason
be there
o Objectifs
différents,
maishave
les deux
trouvé
leurtoraison
d'être là
• Java:
most solution
retargettable
machine),
interpreted
language
o Java:
la plus solution
reciblable(Virtual
(machine
virtuelle), langage
interprété
• C: o
closest
to HW
language,
verymachine,
optimized
compilation
technologytrès optimisée
C: la plus
proche
des langage
technologie
de compilation,
“For infrastructure technology, C will
be hard to displace” [Dennis Ritchie, 1972]
Source: http://www.tiobe.com/
“Java will be the next wave in computing: no
worries about portability” [James A. Gosling, 1995]
Source: http://dev.langpop.com/
©ESL/EPFL
17
215
Environnement de développement des s.e
o Systèmes embarqués microprogrammé sont des dispositifs avec des
ressources limitées, et ne sont généralement pas assez puissant pour
exécuter un compilateur, un système de fichiers ou un environnement
de développement.
oL’environnement
de développement permet
la séparation de
l'environnement de construction du système et l'environnement cible
o Avantages
o
o
Compilation rapide des applications
Mise au point et les tests avec plus de ressources que disponibles sur cible
embarquée système
216
Outils de développement des s.e basé sur C
o Le flux complet pour générer le binaire final pour la plate-forme cible
et sa validation pour la cible microprogrammé systèmes embarqués
nécessite des outils de développement et de compilation croisée.
o Il s’agit d’un ensemble d'outils en cours d'exécution sur une machine
hôte, utilisé pour:
o Les fichiers pré-process tête (#include) et macros (#define) et Compiler du
code de haut niveau source (.c) le code objet cible (.o) - Possibilité d'obtenir
une sortie de montage comme étape intermédiaire (.s)
o Lier
les collections ou bibliothèques de fichiers objets (.o) pré-existantes
pour obtenir un objet exécutable final (.elf) avec tout le code objet
nécessaire
o Formater
l'objet exécutable dans un format qui peut fonctionner avec la
hiérarchie de mémoire cible et I / O sous-système (.nds)
217
Outils de développement des s.e basé sur C
218
Compilation pour NDS: 2 processeurs - 2 flux
219
Compatibilité dans la compilation pour les
systèmes embarqués microprogrammés
o Deux phases ont été séparées
o
1. Le code source est facile
de migrer langue source
standard (par exemple, ANSI
C) ● bibliothèques multi-plateforme standard (par exemple,
stdio, stdlib, etc.)
o
2. Code de l'objet n’est pas
portable, pas même parmi les
compilateurs pour la même
architecture ● code objet tiers
lié à la plate-forme.
220
Example: compilation en C de source code pour NDS
221
Assemblage des fichiers selon le s.e et les E/S
o Outil
pour emballer les binaires
dans 1 fichier (file.nds) pour le
format de cartouche NDS: ndstool
o Outil
additionnel à permet le
démarrage.
222
Pratique 1 : Se familiariser avec l’environnement
o Partie A: Premiers pas avec la machine virtuelle pour la NDS
o Utilisation de VirtualBox: http://www.virtualbox.org
223
Pratique 2 : Se familiariser avec l’environnement
o Partie A: Premiers pas avec la machine virtuelle pour la NDS
o Utilisation de VirtualBox: http://www.virtualbox.org
oPartie B:
Prise en main avec du C dans le NDS: "Hello World"
224
Evolution des processeurs dans les S.E
o Les microprocesseurs ont beaucoup évolué depuis 1971
o plus de fonctionnalité et de performance
o Plus de consommation aussi en énergie.
225
Processeurs ARM dans tous les S.E
o
Reduced Instruction Set Informatique (RISC) pour l'efficacité
énergétique des systèmes microprogrammés
o Instructions
avec minimum de sémantique (déplacer les données, opération
arithmétique et logique, ....)
o ARM2 [1986], probablement plus simple processeur 32 bits : 30K transistors,
pas de mémoire cache
o Large gamme d’architecture ARM conçu: toujours architecture RISC de base +
extensions
o Business model
o Licence
ARM pour les
entreprises partenaires qui
conçoivent et fabriquent "à la
carte" pour des clients
226
Processeurs ARM dans tous les S.E
o
Reduced Instruction Set Informatique (RISC) pour l'efficacité
énergétique des systèmes microprogrammés
o Instructions
avec minimum de sémantique (déplacer les données, opération
arithmétique et logique, ....)
o ARM2 [1986], probablement plus simple processeur 32 bits : 30K transistors,
pas de mémoire cache
o Large gamme d’architecture ARM conçu: toujours architecture RISC de base +
extensions
Business model
Licence ARM pour les entreprises
partenaires qui conçoivent et
fabriquent "à la carte" pour des
clients
90% de tous les systèmes
embarqués microprogrammés
utiliser un ou plusieurs
processeurs ARM!
o15 milliards de cœurs ARM expédiés, Meilleures ventes: ARM9 et ARM7TDMI
227
Historique des processeurs Nintendo DS (NDS)
o Précurseur : Game Boy Advance (GBA), Mar. 2001
o Ecran: 2.9 pouces, TFT LCD (240x160 pixels)
o Processeurs
• ARM 7TDMI, 16.78 MHz: user sw processing
• Z80, 8MHz: microcontroller pour les E/S
o Nintendo DS, Nov. 2004; et DS Lite, Mar. 2006
o Ecarn: 3 vs 3.1 pouces, TFT LCD (256 x 192 pixels)
o Processeurs
• ARM 946E-S, 67.028 MHz: user software
•
processing and main I/O peripherals
ARM 7TDMI-S,16.78 MHz: dedicated I/O support
(sound, wifi and specific keys)
o Nintendo DSi, Nov. 2008, and DSi XL, Oct. 2009
o Ecran: 3.2 vs. 4.2 pouces, TFT LCD (256 x 192 pixels)
o Processeurs
• ARM 946E-S, 133 MHz: user software processing
•
and main I/O peripherals
ARM 7TDMI-S, 16.78 MHz: dedicated I/O support
(sound, wifi and specific keys)
228
Traitement et contrôle des E/S de (NDS)
oDeux processeurs 32-bit Advanced RISC Microprocessors (ARM)
o ARM 946E-S: user software processing and main I/O peripherals
o ARM 7TDMI-S: dedicated I/O support (sound, wifi and specific keys)
229
Cartographie mémoire de (NDS)
o 1 Go
oC a r t r i d g e
ROM:
0x08000000 - 0x09ffffff
(32MB)
oM a i n R A M :
0x02000000 - 0x023fffff
(4MB)
oBIOS (Basic Input/
Output System) in
ROM,
Adresses
Memoire
00000000
Octet 3
Octet 2
Octet 1
Octet 0
00000004
Octet 7
Octet 6
Octet 5
Octet 4
.
.
.
.
.
.
.
.
FFFFFFFC
o ARM9:
0xffff0000 0xffff7fff (32KB);
o ARM7: 0x00000000 0x00003fff (16KB)
230
Architecture des processeurs ARM
oProcesseurs RISC 32-bit (instruction 32-bit = mot)
o 37 registres de 32-bits (16 disponible)
o Avec UAL, Multiplieur, Shiffer et (often) caches
o Architecture Von Neuman (ARM7) et Harvard (ARM9)
o 8- / 16- / 32-bit de données (bus)
231
Allocation des données et instructions
oT a i l l e
d e s d o n n é e s Adresse
possible dans un uP ARM
00000000
o Mot 32 bits (4 octets)
o Demi-mot 16bits (2 octets)
o Octets (8 bits)
oDeux types d’instructions ,
o Instruction régulières (32bits)
o Instruction compacte (16bits)
00000004
.
.
.
.
Demi-mot #2
Demi-mot #0
Octet 3
Octet 2
Octet 1
Octet 0
Octet 7
Octet 6
Octet 5
Octet 4
Demi-mot #6
.
Demi-mot #4
.
.
.
FFFFFFFC
232
Registres et Mode d’adressage
oLes processeurs ARM intégrent 37 régistres de 32 bits
o 1 compteur de programme (PC)
o 1 registre d’état
o 5 registres pour store the program state when we switch operation mode in
the processor
o 30 registres à usage général
oRegidtre de base + offset / deplacement (ex. LDR r0,[r1,#8] )
233
Organisation des différents registres
oThe System mode uses the User mode register set
234
Registres d’état (cpsr)
Drapeaux disponibles dans le NDS
oCondition code flags (or bits)
o Z = Zero result from ALU
o N = Negative result from ALU
o C = ALU operation Carried out
o V = ALU operation oVerflowed
oInterrupt Disable bits.
o I = 1: Disables the IRQ.
o F = 1: Disables the FIQ.
oMode bits
o Specify the processor mode
oSticky overflow flag - Q flag
o Architecture 5TE/J only (ARM9)
o Indicates if saturation has
occurred
oT Bit
o Architecture xT only
o T = 0: Processor in ARM state
o T = 1: Processor in Thumb state
oJ bit
o Architecture 5TEJ only (ARM9)
o J = 1: Processor in Jazelle state
235
Jeu d’instruction des processeurs ARM
o5 types d’instructions Assembleur
o 3 types d’instruction RISC fondemantales
•
•
•
Instructions d’accés à la mémoire
Instructions arithmétiques et logiques
Instructions de branchement (jump)
o 2 types d’instruction RISC étendues pour le controle du processeur
•
•
Instructions spéciales de manipulation du registre d’atat (cpsr)
Instructions de changement du mode d’éxecution
236
Instruction d’accés à la mémoire
o2 opérations basiques
o LDR : charger le contenu d’un registre avec la valeur provenant de la
mémoire
o STR : stocker dans un registre la valeur provenant de la mémoire
o Syntaxe:
• LDR{<cond>}{<size>} Rd, <address>
• STR{<cond>}{<size>} Rd, <address>
• Examples: LDR r0,[r1,#8]
STR r0,[r1,#8]
o La mémoire doit prendre en charge toutes les tailles (par défaut la taille
est un mot)
•
•
<size> = Signed (S) and then Byte (B), Halfword (H)
Examples: LDR STR
LDRB STRB
LDRH STRH
LDRSB Load
LDRSH Load
Word
Byte
Halfworld
byte with sign
halfword with sign
237
Instructions arithmetiques et logiques
oElles ne s’appliquent qu’entre des registres
o Arithmétique : ADD ADC SUB MUL SBC RSB RSC
o Logique :
AND ORR EOR BIC
o Comparaisons : CMP CMN TST TEQ
o Mouvement: MOV MVN
oSyntax: <Operation>{<cond>}{S} Rd, Rn, Operand2
o Example: ADD r0, r1, r2
o Remarques :
o Comparisons only fix the flags (or bits) of cpsr (not the Rd value)
o Example: CMP r3,#0
o Data movements do not specify Rn
o Example: MOV r0,#0xFF
238
Instructions de branchement
oB <Label>
o Jump fait un saut relatif jusqu’à ± 32Mo par rapport au contenu du PC
oBL <subroutine>
o Stockage du contenu du PC dans le registre LR(r14)
o Rechargement du contenu du PC depuis le resitre LR aprés l’execution de
subroutine
239
Exécution conditionnelle
oLes
instructions conditionnelles permettent d’améliorer la
densité de code et les performances en réduisant le nombre
d'instructions de branchement.
o Example: ADD{<cond>} Rd, Rn, Operand2
240
Exécution conditionnelle
oLes instructions conditionnelles possibles dans les processeurs
ARM
241
Equivalence entre C et assembleur dans ARM
oInstruction if
oUtilisation
: if(cond) {instTrue;} else {instFalse;}
de l’instruction de comparison (CMP) et le branchement conditionnel
(Bcond)
oExample
if (a==7) {count+=1;}
else {count-=1;}
…..
o a est stocké dans r0 ;
o count est stocké dans r1
oSolution
CMP r0, #7
BNE caseFalse
ADDS r1,r1,#1
B regroup
caseFalse:
SUBS r1,r1,#1
regroup:
…..
242
Equivalence entre C et assembleur dans ARM
oInstruction compacte
: instruction conditionnelle
oUtilisation de l’instruction de if-else
if (a==7) {count+=1;}
else {count-=1;}
o a est stocké dans r0 ; count est stocké dans r1
oSolution
CMP
ADDEQ
SUBNE
r0, #7
r1, r1, #1
r1, r1, #1
; compare a avec 7
; faire count = count++, si a==7
; faire count= count--, si a !=7
243
Equivalence entre C et assembleur dans ARM
oInstruction While loop : instruction conditionnelle
o Utilisation de l’instruction ; while (cond) {instructsTrue;} after_loop_instructs
oExample
while (a<3) {
count+=1;
a++;
}
…..
o a est stocké dans r0 ;
o count est stocké dans r1
oSolution
Loop:
CMP
BGE
ADD
ADD
B loop
caseFalse:
…..
r0, #3
caseFalse
r1,r1,#1
r0,r0,#1
244
Equivalence entre C et assembleur dans ARM
oInstruction for
: instruction itérative
oExample
count = 0;
for (i=10; i > 0; i--)
count+=1;
o a est stocké dans r0 ;
o count est stocké dans r2
oSolution
MOV
MOV
Loop:
CMP
BLE
ADD
SUBS
B loop
caseFalse:
r2, #0
r0, #10
r0,#0
caseFalse
r2,r2, #1
r0, r0, #1
245
Développement d’un programme Assembleur
1. Declaration de variables et
adresses
2.Definition de la fonction
principale (.global)
3.Debut du code (.text)
4.Fin du programme (.end)
246
Intégration de code Assembleur dans un code C
oDirectement dans un programme C
o
o
utilisé pour chaque code assembleur
asm(“assembly Instruct.");
oUtilisation
dans du code C des
fichiers assembleur externes
o Déclarer
en C l'utilisation de fonctions
extérieur: EXTERN Prototype_funct;
o
Déclaration de fonctions assembleur
comme symbol global .GLOBAL
Name_funct
o
Implementation de fonctions dans le
texte : .text du programme :
Name_funct:
247
4ième Partie : PROCESSEUR ARM
248
STM32 : Présentation
• MicroContrôleur ST basé sur le processeur ARM Cortex M4
• Processeur RISC
• Architecture Harvard : bus instructions et données séparés
• Mode de gestion de la consommation
249
Processeur ARM : Présentation
Processeurs(RISC(32(bits((ARM1(à(ARM7)(
et(64(bits((ARM8..)(développées(par(
ARM(Ltd
Architecture)simple
Faible)consomma3on
Très(employés(en(électronique(
embarquée.
ARM(ne(fabrique(pas(de((puce.(ARM(
vend(des(architectures(sous(licence(de(
propriété(intellectuelle(aux(concepteurs
Famille(nombreuse,(de(ARM6(à(ARM11(
(muOPcoeurs)
ARM- CORTEX
• Les SoC CORTEX (systèmes on chip CPU + GPU + DSP +
mémoires + périphériques) sont équipés de processeurs ARM
• CORTEX A pour l’informatique
• CORTEX R pour les applications temps réel
• CORTEX M pour les applications embarquées
• Le CORTEX M3 est équipé d’un processeur ARM7 cadencé à
100MHz
• (prix : 11€ à l’unité et moins de 5€ par 2000).
• Plus de 10 milliards de licences vendues
STM32 : Nucleo – F401RE(
STM32F401RET6 in LQFP64 package
ARM®32-bit Cortex®-M4 CPU with FPU
84 MHz max CPU frequency
VDD from 1.7 V to 3.6 V
512 KB Flash
96 KB SRAM
GPIO (50) with external interrupt
capability
12-bit ADC with 16 channels
RTC
Advanced-control Timer
General Purpose Timers (7)
Watchdog Timers (2)
USART/UART (4)
I2C (3)
SPI (3)
SDIO
USB 2.0 OTG FS
STM32 : Nucleo – F401RE(
Connecteurs Arduino Uno. (Tous les
shields sont compatibles)
Connecteurs STMicroelectronics Morpho
mbed-enabled (http://mbed.org)
ST-LINK/V2-1 debugger/programmer
intégré
Une LED utilisateur
Deux boutons poussoirs USER et RESET
USB supportant trois modes :
Virtual Com port
Memoire USB
Debug port
Adapté à tous les EDI ex : IAR™, Keil®,
AC6-GCC
9€((Farnell)
STM32 : Nucleo – F401RE(
STM32F401RET6 in LQFP64 package
ARM®32-bit Cortex®-M4 CPU with FPU
84 MHz max CPU frequency
VDD from 1.7 V to 3.6 V
512 KB Flash
96 KB SRAM
GPIO (50) with external interrupt
capability
12-bit ADC with 16 channels
RTC
Advanced-control Timer
General Purpose Timers (7)
Watchdog Timers (2)
USART/UART (4)
I2C (3)
SPI (3)
SDIO
USB 2.0 OTG FS
NUCLEO)32,)64,)144)
Tous(les(microcontrôleurs(STM32(ont(été(implantés(sur(des(
cartes(NUCLEO(
Cartes(NUCLEOP64(avec(connecOque(ARDUINO(et(ST(
Cartes(NUCLE0P32(pour(le(prototypage(sur(support(DIP((
STM32 : Nucleo – F401RE(
STM32 : Nucleo – F401RE(
STM32 : ARM - MBED
http://developer.mbed.org/
• Projet(libre(,(licence(GNU,(
plus(de(45(plateformes(
cibles.(
• Environnement(de(
développement(C/C++(en(
ligne,(un(navigateur(suffit.(
• Pas$de$debug(
• Bibliothèques(intégrées(
• DocumentaOon(et(
communauté(importante(
• Plate(forme(collaboraOve(
• Pour(le(bebug,(exportaOon(
vers(KeilPµVision,(Eclipse...(
(
STM32 : KEIL µVision
OS Windows
Simulateur
intégré
Version gratuite
limitée à 32KO
de code
ST offre une
licence gratuite
illimité pour les
STM32 CORTEX
M0
STM32 : AC6 System Workbench
OS
Windows,
Linux,
MacOS
Logiciel
« libre »
Licence
GNU
STM32 : Cube
Générateur de
code d’initialisation
de périphériques.
STM32 Cube
facillite
(grandement) la
configuration des
périphériques.
Il crée un projet
(exAC6, µVision
avec un « main() »
vide.
STM32 : Registres des ARM Cortex-M
262
STM32 : Memory MAP
263
STM32 : Memory MAP
264
STM32 : Memory MAP
265
STM32 : Memory MAP peripherals
RM0368
266
STM32 : Memory MAP peripherals
RM0368
267
STM32: GPIO
268
STM32 : GPIO MAP
o Un port d'entrée/sortie communique avec l'extérieur du micro-contrôleur par le
biais de plusieurs fils (broches), en général regroupés par paquets de 16.
o Tout périphérique possède en son sein un certain nombre de registres
accessibles en lecture ou écriture pour configurer et d'utiliser le périphérique.
o Chaque port GPIO dispose de 4 régistres 32 bits de configuration
(GPIOx_MODER, GPIOx_OTYPER, GPIOx_OSPEEDR and GPIOx_PUPDR), 2
registres 32 bits de données (GPIOx_IDR and GPIOx_ODR), 1 registre 32-bit
set/reset (GPIOx_BSRR), 1 registre 32-bit locking register (GPIOx_LCKR) et 2
registre 32-bit alternate function selection (GPIOx_AFRH and GPIOx_AFRL).
o The GPIOx_MODER register is used to select the I/O direction (input,
output, AF, analog).
o The GPIOx_OTYPER and GPIOx_OSPEEDR registers are used to select
the output type (push-pull or open-drain) and speed (the I/O speed pins are
directly connected to the corresponding GPIOx_OSPEEDR register bits
whatever the I/O direction).
o The GPIOx_PUPDR register is used to select the pull-up/pull-down
whatever the I/O direction.
269
STM32 : GPIO CONFIGURATION
RM0368
270
STM32 : GPIO REGISTRE DE CONFIGURATION
RM0368
271
STM32 : GPIO REGISTRE DE CONFIGURATION
272
STM32 : GPIO REGISTRE DE CONFIGURATION
273
STM32 : GPIO REGISTRE DE CONFIGURATION
0x4002 03FF
0x4002 0024
0x4002 0020
0x4002 03FF
0x4002 0000
GPIOA(1 KB)
0x4002 001C
0x4002 0018
0x4002 0014
0x4002 0010
0x4002 000C
0x4002 0008
0x4002 0004
0x4002 0000
AFR[1]
AFR[0]
LCKR
BSRR
ODR
IDR
PUPDR
OSPEEDR
OTYPER
MODER
274
STM32 : GPIO REGISTRE DE CONFIGURATION
0x4002 0017
1 mot (32 bits)
ODR
0x4002 0014
0x4002 0017
0x4002 0016
4 octets (32 bits)
0x4002 0015
0x4002 0014
32
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
1
275
0
STM32 : GPIO DESCRIPTION FONCTIONNEL
276
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie, 4 registres de configuration (GPIOx_ODR, GPIOx_MODER,
GPIOx_OTYPER and GPIOx_PUPDR)
277
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie, 4 registres de configuration (GPIOx_ODR, GPIOx_MODER,
GPIOx_OTYPER and GPIOx_PUPDR)
278
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie, 4 registres de configuration (GPIOx_ODR, GPIOx_MODER,
GPIOx_OTYPER and GPIOx_PUPDR)
279
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie, 4 registres de configuration (GPIOx_ODR, GPIOx_MODER,
GPIOx_OTYPER and GPIOx_PUPDR)
280
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie
281
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie
00 = Input,
10 = AF,
01 = Ouput
11 = Analog(default)
282
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie
0 = Output push-pull (default)
1 = Ouput open-drain
00 = Input,
10 = AF,
01 = Ouput
11 = Analog(default)
283
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie
00 = No pull-up, no Pull-down,
10 = Pull-down,
01 = Pull-up
11 = Reserved
0 = Output push-pull (default)
1 = Ouput open-drain
00 = Input,
10 = AF,
01 = Ouput
11 = Analog(default)
284
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En sortie : Push Pull et Open Drain
En mode Push-Pull, c'est le port d'E/S qui impose le niveau logique d'une broche,
que ce soit un niveau '1' ou '0'. Il est le maître, le circuit extérieur est l'esclave,
récepteur.
En mode Open Drain (Drain est le nom de la broche du transistor MOS reliée à la
broche : Drain laissé ouvert), le port d'E/S ne peut imposer que le niveau logique '0'.
Le niveau '1' est fixé par le circuit extérieur. Le port d'E/S n'est donc pas le seul
maître du potentiel sur la broche. Le circuit extérieur l'est aussi.
285
STM32 : GPIO DESCRIPTION FONCTIONNEL
286
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En entrée, il y a trois modes : Mode entrée flottante (floating input),
Mode entrée tirée au niveau bas (Pull Down input) et Mode entrée
tirée au niveau haut (Pull up input)
287
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En entrée, il y a trois modes : Mode entrée flottante (floating input),
Mode entrée tirée au niveau bas (Pull Down input) et Mode entrée
tirée au niveau haut (Pull up input)
288
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En entrée, il y a trois modes : Mode entrée flottante (floating input),
Mode entrée tirée au niveau bas (Pull Down input) et Mode entrée
tirée au niveau haut (Pull up input)
289
STM32 : GPIO DESCRIPTION FONCTIONNEL
o En entrée, il y a trois modes : Mode entrée flottante (floating input),
Mode entrée tirée au niveau bas (Pull Down input) et Mode entrée
tirée au niveau haut (Pull up input)
290
STM32 : GPIO DESCRIPTION FONCTIONNEL
o GPIO Mode Register (GPIOx_MODER)
o 32 bits (16 pins, 2 bits par pin)
00 = Input mode
01 = Ouput mode
10 = Alternate Function mode (PMW, ..),
11 = Analog mode (default)
291
STM32 : GPIO DESCRIPTION FONCTIONNEL
o GPIO Pull-Up / Pull-Down Register (GPIOx_PUPDR)
o 32 bits (16 pins, 2 bits par pin)
00 = No Pull-Up, no pull down
01 = Pull-Up
10 = Pull-down
11 = Reserved
292
STM32 : GPIO DESCRIPTION FONCTIONNEL
o GPIO Ouput Type Register (GPIOx_OTYPE)
o 16 bits réservés, 16 bits de données, 1 bits par pin
0 = Output push-pull (default)
1 = Open drain
293
STM32 : GPIO DESCRIPTION FONCTIONNEL
o GPIO Output Data Register (GPIOx_ODR)
o 16 bits réservés, 16 bits de données, 1 bits par pin
294
STM32 : GPIO DESCRIPTION FONCTIONNEL
o GPIO Input Data Register (GPIOx_IDR)
o 16 bits réservés, 16 bits de données, 1 bits par pin
295
STM32 : GPIO CONFIGURATION
296
STM32: TIMER
297
STM32 : TIMER
o Compteur/Decompteur électronique 16bits rechargeable automatiquement.
o Prédiviseur 16 bits programmable
o Jusqu’à 4 canaux indépendants permettant :
o La capture d’événements
o La comparaison avec le compteur
o Un mode PWM
o Mode on-Pulse
o Cirduit de synchronisation externe et chainage des différents timers possible
o Générateur d’interruption ou de requête DMA sur différents événements
o Recyclage du compteur, initialisation du compteur
o Déclenchement (Start, Stop, initialisation ou déclenchement interne /externe)
o Capture d’événement
o Comparaison
298
STM32 : TIMER
299
STM32 : Description Fonctionnelle
o Unité de base
o
o
o
o
Le Composant principal : un compteur 16 bits
Mode décompteur/compteur – auto chargement
Prédiviseur de l’horloge du compteur
Les registres
o Registre du compteur :
TIMx_CNT
o Registre du prediviseur :
TIMx_PSC
o Registre autochargement :
TIMx_ARR
o Registre de repetition
TIMx_RCR
o Fonctionnement
o Le registre d’auto-chargement (ARR) est préchargé
o Lire ou écrire dans le registre d’autochargement revient à accéder au
régitre de préchargement
o Le contenu du registre de préchargement est transférer dans le
registre d’auto-chargement (Shadow) soit de façon permanente ou à
charque événement de mise à jour (bit UEV) en fonction du bit ARPE
dans le registre CR1.
o L’événement de mise à jour est généré quand le compteur recycle (ou
logiciellement) et que le bit UDIS du registre CR1 est à 0.
300
STM32 : Description Fonctionnelle
o Prédiviseur
o Le compteur est piloté par une horloge prédivisé CK_CNT
o Cette horloge est activée uniquement si le bit CEN du registre CR1 est à 1
o Remarque : le signal CNT EN relié à CK CNT passe à 1 après 1 cycle
d’horloge suite à la mise à 1 du bit CEN.
o Il peut diviser l’horloge d’un facteur compris entre 1 et 65536
o C’est un compteur 16 bits contrôler par le registre 16 bits PSC
o Sa valeur peut être changée au fil de l’eau elle sera alors prise en compte
au prochain événement de mise à jour
o Mode Compteur
o Bit CMS=00 et bit DIR=0 (registre CR1)
o Dans ce mode le compteur compte de 0 à la valeur du registre d’autochargement (registre ARR)
o Arrivée à la valeur du registre ARR il recycle en redémarrant un cycle de
comptage de 0
o Au recyclage un événement de dépassement de capacité est généré
(Overflow)
o Un événement de mise à jour peut être généré à chaque recyclage ou en
positionnant le bit UG du registre EGR
301
STM32 : Description Fonctionnelle
o Mode Compteur
o L’ événement de mise à jour peut être désactivé via le bit UDIS du registre
CR1
o Si le bit URS (registre CR1) est à 1, positionner le bit UG génére un
événement de mise à jour sans générer d’interruption
o Quand un événement de mise à jour survient, tous les registres sont mise
à jour et le bit d’interruption IUF du registre SR est mis à 1 en fonction de
la valeur du bit URS.
o Mode Compteur – Mise à jour
o Le registre tampon du prédiviseur est rechargé avec la valeur du registre
PSC
o Le registre d’auto-chargement est rechargé avec la valeur du registre
ARR.
302
STM32 : TIMER
303
STM32 : TIMER
304
STM32 : Description Fonctionnelle
o Mode décompteur
o Bit CMS=00 et bit DIR=0 (registre CR1)
o Idem mode compteur sauf que comptage de la valeur du registre de
préchargement à 0.
o Mode Compteur – Mise à jour
o Bit CMS = 01,10 ou11 (registre CR1)
o Dans un premier temps mode compteur de 0 à valeur d’auto-chargement
o Puis recyclage
o Dans un second temps mode décompteur de valeur d’auto-chargement à 0
o Puis recyclage
o et reprise en mode compteur et ainsi de suite
305
STM32 : TIMER
306
STM32 : Description Fonctionnelle
o Selection horloge
o L’horloge du compteur peut provenir de
o L’horloge interne par défaut CK INT qui est générée par :
o HSI par défaut Oscillateur 8 MHz (bits SW = 00 registre
CFGR unité CRR)
o HSE oscillateur externe (bits SW = 01 registre CFGR unité
CRR)
o PLL (bits SW = 10 registre CFGR unité CRR)
o Une première horloge externe sur une broche TIx
o Horloge
o Une seconde horloge externe sur une entrée de déclenchement ETR
o Un signal de déclenchement interne (ITRx) utilisant un timer comme
prédiviseur pour un autre timer. Par exemple le Timer1 sert de prédiviseur
au Timer2.
o Sélection de CK_INT quand le champs SMS=000 dans le registre SMCR
o Sélection première horloge externe quand SMS=111
o Sélection seconde horloge externe quand ECE=1 dans le registre SMCR
307
STM32 : TIMER
o Mode compteur
Period =(1+ARR)*Clock Period = 7* Clock Period
308
STM32 : TIMER
o Mode décompteur
Period =(1+ARR)*Clock Period = 7* Clock Period
309
STM32 : TIMER
o Mode alterné
Period =2*Clock Period = 12* Clock Period
310
STM32 : TIMER-PWM
o Mode 1: PWM
o TIMER Ouput =1 si counter < CCR
o TIMER Ouput =0 si counter >= CCR
311
STM32 : TIMER-PWM
o Mode 1: PWM
o TIMER Ouput =1 si counter < CCR
o TIMER Ouput =0 si counter >= CCR
312
STM32 : TIMER-PWM
o Mode 1: PWM
o TIMER Ouput =1 si counter < CCR
o TIMER Ouput =0 si counter >= CCR
313
STM32 : TIMER-PWM
o Mode 2: PWM
o TIMER Ouput =0 si counter < CCR
o TIMER Ouput =1 si counter >= CCR
314
STM32 : TIMER-PWM
o Mode 2: PWM
o TIMER Ouput =0 si counter < CCR
o TIMER Ouput =1 si counter >= CCR
315
STM32 : TIMER-PWM
o Mode 2: PWM
o TIMER Ouput =0 si counter < CCR
o TIMER Ouput =1 si counter >= CCR
316
STM32 : TIMER-PWM
o Mode 2: PWM
o TIMER Ouput =0 si counter < CCR
o TIMER Ouput =1 si counter >= CCR
317
STM32 : TIMER (Différents registres)
318
STM32 : TIMER (Différents registres)
319
STM32 : TIMER (Différents registres)
320
STM32 : TIMER (Différents registres)
o Détails des régitres voir à partir de la page 243 du document
Manual RM0368.
o Les unités TIMx du STM32 ont hormis le mode minuteur basique
deux autres mode d’utilisation :
o Le mode Capture-Compare. Dans ce mode il est possible d’une part
de capturer en fonction d’un événement la valeur du compteur du
Timer, d’autre part de comparer la valeur du compteur à une valeur
préalablement charger dans le registre Capture-Compare.
o Le mode PWM : Pulse Width Modulation, qui permet de générer des
signaux périodiques ayant un rapport cyclique variable.
o Ces fonctions sont mises en œuvre à l’aide de 4 canaux
indépendants.
321
STM32 : TIMER (Différents registres)
o Capture
o En mode capture, le registre TIMx_CCRx copie la valeur du compteur
après la détection d’une transition sur le signal ICx
o Quand une capture est réalisée, le drapeau correspondant CCxIF du
registre TIMx_SR est mis à 1
o Une interruption ou une requête DMA peut être prise en compte si elle
est autorisée (bits CCxIE et CCxDE du registre TIMx_DIER).
o Si une capture intervient alors que le drapeau CCxIF est à 1, alors le
drapeau CCxOF (over-capture) du registre TIMx_SR est mis à 1.
o Le drapeau CCxIF est mis à 0 soit par logiciel, soit en lisant la valeur
du registre TIMx CCR.
o Le drapeau CCxOF est mis 0 par logiciel.
322
STM32 : TIMER (Différents registres)
o Capture
o Ce mode permet de générer un signal périodique de fréquence fixé
par le registre TIMx_ARR et de rapport cyclique fixé par le registre
TIMx_CCRx.
o Les 4 canaux peuvent être indépendamment initialisés dans ce mode
en mettant les valeurs ”110” ou ”111” dans les bits OCxM du registre
TIMx_CCMRx.
o Il faut autoriser la sortie via le bit OCxPE du registre TIMx_CCMRx
o Possibilité d’utiliser le mode Capture pour spécifier la valeur de la
fréquence et du rapport cyclique
323
STM32: ADC
324
STM32 : ADC
o Structure générale, et fonctionnement d'un périphérique ADC
325
STM32 : ADC
o Structure générale, et fonctionnement d'un périphérique ADC
o le mode single conversion : l'utilisateur lance une conversion
et récupère le résultat dans le registre associé, soit en scrutant
le drapeau EOC, soit en attendant l'entrée en interruption.
o Le mode auto conversion : l'utilisateur lance une conversion,
et dès que l'ADC finit sa conversion, il en lance une autre,
éventuellement sur un autre canal, et ce de manière cyclique.
Les résultats sont donc à lire régulièrement, sinon ils sont
perdus. Selon le microcontrôleur les résultats peuvent être
stockés dans une table de registres internes au périphérique,
ou directement dans une table en RAM. On parle alors de DMA
(Direct Memory Access).
326
STM32 : ADC
o Tensions et durées importantes dans la conversion A/N
o
o
Temps d'acquisition, tacq : durée pendant laquelle l'échantillonneur est fermé.
La tension e(t) évolue de manière exponentielle à cause du condensateur. Il
est donc nécessaire, de tenir l'échantillonneur fermé un certain temps, tacq.
Temps de conversion, tconv : Lorsque l'échantillonneur est ouvert, la tension
e(t) reste constante, et la conversion peut commencer. Elle dure un temps lié à
l'horloge d'entrée de l'ADC et à la technologie de l'ADC.
327
STM32 : ADC
o Caractéristiques
o Résolution : Amplitude de la plus petite variation. Correspond au LSB
(Least Significant Bit)
o Temps de conversion : Temps de stabilisation de la donnée en sortie
o Erreur de Quantification : Incertitude du à la conversion
o Pleine Echelle : Etendue de la grandeur Analogique d’entrée
328
STM32 : ADC
o ADC STM32 : Caractéristiques principales
o
o
o
o
o
o
o
o
o
o
o
o
o
Résolution de 12 bits
Interruption de fin de conversion
Mode simple conversion ou conversion continue
Mode de balayage multi-canal
Auto-Calibration
Alignement des données sur 16 bits (droite ou gauche)
Temps de conversion programmable canal par canal
Déclenchement par signal externe
Mode de conversion discontinue lors de balayage
Chainage de convertisseur (si le circuit en posséde au moins 2)
Tension requise entre 2,4 V et 3,6V
Plage de conversion entre Vref − <= Vin <= Vref +
Requête DMA pour la conversion régulière
329
STM32 : ADC
o ADC STM32 : Schéma
330
STM32 : ADC
o Mise sous tension
Mise sous tension via la mise à 1 du bit ADON (registre CR2 de l’ADC)
La première mise à 1 du bit ADON met sous tension l’ADC
La seconde mise à 1 du bit ADON démarre la conversion
La mise hors tension et l’arrêt de la conversion s’effectue en mettant à
0 le bit ADON
o En mode hors tension l’ADC ne consomme que quelques µA
o
o
o
o
o Horloge
o l’horloge ADCCLK du convertisseur est synchrone avec celle du bus
APB2, l’horloge PCLK2
o Il est possible de programmer un prédiviseur, par rapport à PCLK2,
pour l’horloge ADCCLK dans le contrôleur RCC
331
STM32 : ADC
o Sélection des canaux
o Il y a 16 canaux de conversions multiplexés
o Organisation possible en deux groupes : réguliers et injectés
o Un groupe est une séquence de conversions (16 au plus pour
réguliers, 4 au plus pour injectés)
o Une séquence peut-être réalisée dans un ordre aléatoire
o Le nombre de conversions, l’ordre de conversion sont fixés via les
registres SQRx et ISQR
o Horloge
o Capteur de Température interne connecté au canal 16
o Une tension Vrefint interne est connectée au canal 17
o Accessible avec l’ADC1.
332
STM32 : ADC
o Mode simple conversion
o Bit CONT à 0 (registre CR2)
o Démarrage par bit ADON uniquement pour groupe réguliers
o Une fois le canal converti
o La donnée convertie est stockée dans le registre 16 bits DR
o Le drapeau EOC est positionnée
o Une interruption est générée si le bit EOCIE est à 1.
o Mode Conversion continue
o Bit CONT à 1 (registre CR2)
o Démarrage par bit ADON uniquement pour groupe réguliers
o Une fois le canal converti
o La donnée convertie est stockée dans le registre 16 bits DR
o Le drapeau EOC est positionnée
o Une interruption est générée si le bit EOCIE est à 1.
333
STM32 : ADC
o Mode simple conversion : Diagramme Temporel
334
STM32 : ADC Description Fonctionnelle
o Balayage Multi-Canaux
oBit SCAN à 1 (registre CR1)
oConversion des canaux sélectionnés via les registres SQRx et JSQR
oUne conversion est effectuée pour chaque canal du groupe
oAprés la fin de la conversion d’un canal, le canal suivant est directement
traité
oNécesité d’utiliser le DMA pour récupérer les données
oUne interruption est générée, si EOCIE est à 1, aprés la dernière
conversion.
oMode Discontinu
oBit DISCEN à 1 (registre CR1)
oConversion d’un sous ensemble de canaux d’un groupe
oTaille du sous ensemble n <= 8
oTaille spécifiée via les bits DISCNUM[2:0] (registre CR1)
oPiloté par un événement externe
oLors de l’événement, conversion des n canaux parmi le groupe
335
STM32 : ADC Description Fonctionnelle
o Calibration
o Procédure d’auto-calibration
o Réduction des erreurs de précision du aux variations des capacités
internes
o Calcul de l’erreur pour chaque capacité
o Démarrage par mise à 1 du bit CAL (registre CR2)
o Remise à zéro automatique du bit CAL après calibration
o Procédure recommandée à la mise sous tension de l’ADC.
o Alignement des données
o Bit ALIGN (registre CR2)
o Alignement à droite si ALIGN = 0
o Alignement à gauche si ALIGN = 1
336
STM32 : ADC Description Fonctionnelle
o Temps de Conversion
o Échantillonnage sur n ADCCLK cycles
o n modifiable
o bits SMPx[2:0] pour le canal x (registres SMPR1 et SMPR2)
o Différenciation du temps par canal
o Temps Total
o Tconv = Tps Rchant. + 12,5 cycles
oDéclenchement externe
o Conversion pilotage par événement externe
o Entrée EXTI
o bits EXTSEL [2:0] pour séléctionner le type de l’événement
337
STM32 : ADC Description Fonctionnelle
o Déclenchement externe
338
STM32 : Memory MAP peripherals
RM0368
339
STM32 : ADC Les registres
o Cartographie mémoire du CAN
340
STM32 : ADC Les registres
o Cartographie mémoire du CAN
341
STM32 : ADC Les registres
o Cartographie mémoire du CAN
342
STM32 : ADC Les registres
o Cartographie mémoire du CAN
343
STM32 : ADC Les registres
o Cartographie mémoire du CAN
344
STM32 : ADC Les registres
o Registre Horloge RCC
345
STM32 : ADC Les registres
o Registre Horloge RCC
346
STM32: Interruptions
347
STM32 : INTERRUPTIONS
o Qu’est ce qu’une interruption ?
o C’est un évenement qui provoque
oL’arrêt de l’exécution normale d’un programme : le programme est
interrompu
ola sauvegarde de l’état du programme en cours d’exécution : le contexte
d’exécution
ol’exécution d’une routine spécifique liée à cet événement : la routine de
service de l’interruption
ola restauration du contexte d’exécution
ole retour à l’exécution du programme interrompu
o Elle survient de de façonn asynchrones. Elle est commandée par le
matériel (interruption externe) ou par le systéme (interruption
systéme ou exception). Aucune relation avec les instructions en
cours d’exécution.
348
STM32 : INTERRUPTIONS
o Qu’est ce qu’une interruption ?
349
STM32 : INTERRUPTIONS
o Qu’est ce qu’une interruption ?
350
STM32 : INTERRUPTIONS
o Interruptions STM32
o Les interruptions du STM32 sont dites vectorisées
o A chaque source d’interruption correspond un vecteur
d’interruption sur 32 bits
o Le vecteur d’interruption contient l’adresse de la routine de
service de l’interruption
o Pour l’exception système reset, la valeur du vecteur est la valeur
initiale du compteur de programme
o Les vecteurs d’interruption sont contenus dans une table qui est
relogeable
351
STM32 : INTERRUPTIONS
o Interruptions STM32
o Pour la gestion des interruptions le microcontrôleur STM32 via le
CortexM4 fournit
o Sauvegarde et restauration automatique du contexte
d’exécution.
o Le processeur empile les registres avant de servir
l’interruption et les dépile après exécution de la routine de
service de l’interruption. Pas de nécessité d’instruction
spécifique, c’est automatique et transparent pour le
programmeur.
o Lecture automatique d’une table dite de table de vecteur qui
contient les adresses des routines de service des interruptions.
o Effectué en parallèle de la sauvegarde de contexte.
352
STM32 : INTERRUPTIONS
o Interruptions STM32
o Le microcontrôleur STM32 a deux types d’interruptions :
o les exceptions système
o les interruptions externes numérotées de 0 à 59
o le numéro de l’interruption en cours de service peut-être connue
par :
o le registre spécial IPSR (Interrupt Program Status Register)
o le registre ICSR (Interrupt Control State Register) du NVIC
(Nested Vectored Interrupt Controller) dans le champs
VECTACTIVE
o les interruptions ont des priorités permettant d’avoir un systéme
préemptif
353