MU4IN108 / FPGA1
SYSTEMES PROGRAMMABLES
EXAMEN
Durée : 1h30
SANS DOCUMENTS – SANS CALCULATRICES
Exercice 1: Mise en conformité sanitaire du campus
L’histoire
La Faculté des Sciences et d’Ingénierie met Campus
en place tout un ensemble de mesures pour Pierre & Marie
adapter la vie du campus Pierre et Marie Curie SAS 2
Curie aux conditions sanitaires. Gel Hydroalcoolique
Parmi ces mesures, on trouve l’installation
d’un sas à l’entrée du campus, pour ne
laisser entrer sur le site que les étudiants SAS 1
autorisés (suite à une jauge de présence à Contrôle
Place Numéro Etudiant
50% par exemple), et s’assurer du respect Jussieu
des gestes barrière.
Le principe de ce sas est présenté ci-contre.
Personnels, Etudiants
Le sas est composé de deux parties :
- Une première zone où la personne doit entrer son numéro d’étudiant, pour vérifier qu’elle est bien
autorisée à rentrer sur le campus. Si tel est le cas, la personne peut pénétrer dans la deuxième zone.
- Une deuxième zone où la personne doit recevoir une dose de gel hydroalcoolique avant que la
porte ne s’ouvre et qu’elle puisse rentrer sur le campus.
Nous allons étudier la réalisation de ce dispositif, contrôlé par un système implémenté sur un FPGA, autour
d’un processeur Microblaze.
Le cahier des charges
Le système de contrôle du sas est 3 LED
présenté ci-contre. Le processeur (2 vertes
Microblaze dispose de trois 1 rouge)
périphériques : 1 GPIO et deux MICRO
périphériques custom.
RAM BLAZE GPIO
1) Le GPIO dispose d’un port de sortie
sur 3 bits pour commander des LED
qui serviront à indiquer à l’utilisateur BUS AXI
quand il peut entrer dans les
différentes zones du sas. IP
IP
TELEMETRE
2) Le périphérique IP CHIFFRE permet CHIFFRE + PWM
d’acquérir le numéro d’étudiant de la
personne voulant entrer sur le
campus. Clavier Alphanumérique Retour_Tele Cmd_Tele PWM_Out
- Les chiffres sont rentrés à l’aide d’un clavier alphanumérique
- On supposera que les numéros d’étudiants sont compris entre 0 et 99999 et que l’étudiant rentrera
dans tous les cas 5 chiffres (ainsi, si son numéro est 0, il appuiera 5 fois sur la touche 0).
- Ce périphérique est cadencé par une horloge de 100 MHz fournie par le Microblaze via le bus AXI.
Elle est donc bien supérieure à la fréquence d’appui sur les touches du clavier par un utilisateur.
- La communication entre IP CHIFFRE et le Microblaze se fait via deux registres d‘interface.
31 87 0 Le REGISTRE CHIFFRE propose sur son octet de
poids faible le code ASCII du dernier chiffre entré
N/A CHIFFRE
au clavier par l’utilisateur (Rappel : le code ASCII en
REGISTRE CHIFFRE hexadécimal du caractère 0 est 30, celui du
caractère 1 est 31, atc…)
31 30 0
N N/A Le REGISTRE CONTROLE indique quand son bit de
poids fort est à 1 qu’un nouveau chiffre vient d’être
REGISTRE CONTROLE entré au clavier. Ce bit repasse automatiquement à
0 sur une lecture du REGISTRE CHIFFRE.
NB : Le reste du REGISTRE CONTROLE est positionné à une valeur non connue, correspondant à d’autres
configurations que nous n’étudierons pas.
3) Le périphérique IP TELEPMETRE + PWM, cadencé par l’horloge à 100 MHz fournie par le bus AXI, permet
de commander deux dispositifs externes au FPGA :
- Un télémètre à ultra-sons situé au niveau du présentoir de gel
hydroalccolique (voir ci-contre). Il permettra de mesurer la
distance entre le distributeur et le déversoir. Lorsqu’une personne
place sa main sous le distributeur, la distance mesurée va diminuer Télémètre
et permettra de déclencher la distribution d’une dose de gel.
- Un moteur permettant de libérer une dose de gel. Ce moteur
est commandé par un signal PWM généré par le périphérique.
Le signal PWM à fournir est un signal périodique de rapport
cyclique 50% avec une période de 16000 cycles d’horloge. Il doit
être généré pendant 1 seconde.
Ce périphérique est commandé via un unique registre d’interface : REGISTRE CTRL/CPT
31 30 29 28 0 Bit 30 – R : Signal de retour du télémètre. Il passe à
T R P COMPTEUR 1 dès que le flux réfléchi des ultra-sons est détecté
par le télémètre. Il repasse automatiquement à 0 à
REGISTRE CTRL/CPT chaque nouvelle activation du télémètre.
Bit 31 – T : Commande du télémètre. Active à 1, Bit 29 – P : Commande de la PWM. Quand le bit est
elle déclenche l’envoi ponctuel d’un flux d’ultra- à 1, le signal PWM est généré sur la sortie
sons. Le bit est ensuite automatiquement remis à 0. PWM_Out. Quand il est à 0, PWM_Out est à 0.
Bits 28-0 : Renvoie la valeur d’un compteur interne au périphérique. Ce compteur permet de mesurer (en
nombre de cycles d’horloge) la distance parcourue par le flux d’ultra-sons jusqu’à ce que le bit R du registre
soit passé à 1. Il permet aussi de mesurer la durée de génération du signal PWM.
Architecture du Périphérique IP TELEMETRE+PWM
Le cœur de l’IP TELEMETRE + PWM est présenté ci-dessous. En plus du registre d’interface, on trouve une
machine à états (MAE) et un compteur.
La MAE, en plus de générer la sortie PWM et les signaux d’interaction avec le télémètre, permet de piloter le
compteur (incrémentation, remise à zéro, etc…). Le compteur renvoie deux bits à la MAE. Change_PWM quand il
faut inverser le niveau logique de la sortie PWM, et Fin_PWM quand il faut arrêter la génération du signal.
La MAE réalise les tâches suivantes :
REGISTRE CTL/CPT BUS AXI
1) Attendre une demande
Go_PWM
Go_Tele
Fin_Tele
d’activation du télémètre.
2) Envoyer un flux d’ultra-sons
(mise à 1 de Cmd_Tele)
3) Incrémenter le compteur jusqu’à
MAE Fin_PWM COMPTEUR
Change PWM
la détection du retour du flux
d’ultra-sons, moment auquel il Retour Cmd IP TELEMETRE + PWM
faut arrêter le compteur. Tele Tele
PWM
4) Attendre une nouvelle activation Out TELEMETRE
du télémètre (en ce cas, refaire
les étapes 2 et 3) ou de la PWM.
5) En cas d’activation de la PWM, il faut générer le signal avec les caractéristiques et la durée indiquées ci-
dessus, puis revenir à l’état initial. Il faudra pour cela s’aider des informations envoyées par le compteur.
Question
1) Donner le graphe d’états de la machine à états de Moore du périphérique IP TELEMETRE +
PWM. Pour chaque état, on précisera la valeur des 3 sorties de la MAE, ainsi que la
fonction à appliquer au compteur.
On souhaite écrire le code VHDL du cœur de l’IP, soit la partie MAE + compteur, (le registre d’interface est lui généré
automatiquement par Vivado dans son wrapper AXI). Une version partielle du code est proposée ci-dessous :
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
entity TELEMETRE_PWM_CTRL is
port(
CLK,RESET: in std_logic; -- Horloge, Reset Asynchrone
-- PORTS VERS L'EXTERIEUR DU SYSTEME
CMD_TELE: out std_logic; -- Commande Activation Télémètre
RETOUR_TELE: in std_logic; -- Signal de Retour du Télémètre
PWM_OUT: out std_logic; -- Sifgnal PWM (Commande Moteur)
-- PORTS A RELIER AUX SLAVE_REGISTERS DE L'IP
GO_TELE,GO_PWM: in std_logic; -- Démarrage Télémètre / PWM
FIN_TELE; out std_logic; -- Indicateur de Fin du Télémètre
COMPTEUR: out std_logic_vector(28 downto 0) -- Valeur du Compteur
);
end TELEMETRE_PWM_CTRL;
architecture ARCHI of TELEMETRE_PWM_CTRL is
-- Etats de la MAE
Type ETAT is ( *** A COMPLETER ***);
signal EP,EF: ETAT; -- Etat Présent et Etat Futur de la MAE
signal CPT: std_logic_vector(28 downto 0); -- Compteur Télémètre et PWM
signal FIN_PWM; std_logic; -- Commande d'Arrêt de la PWM
signal CHANGE_PWM; std_logic; -- Commande Changement Niveau de la PWM
begin
-- MACHINE A ETATS : ON SUPPOSE QUE LE CODE EST DEJA ECRIT
-- COMPTEUR TELEMETRE / PWM : *** A COMPLETER ***
-- GENERATION DES COMMANDES CHANGE_PWM ET FIN_PWM : *** A COMPLETER ***
end ARCHI ;
Questions
2) Compléter les déclarations du code VHDL en ajoutant le nom des états correspondant au
graphe de la question précédente.
3) En vous basant sur la valeur de l’état présent de la MAE, écrire en VHDL le comportement
du compteur et des commandes CHANGE_PWM et FIN_PWM.
Code C du Microblaze
Vivado a généré un fichier drivers.h contenant les drivers des deux périphériques IP CHIFFRE et IP
TELEMETRE+PWM
/****************** Include Files ********************/
#include "xil_types.h"
#include "xstatus.h"
#define ADR_BASE_CHIFFRE_IP ... // Adresse de Base de IP CHIFFRE
#define ADR_BASE_TELE_PWM_IP ... // Adresse de Base de IP TELEMETRE+PWM
#define CHIFFRE_REG 0 // Offset des Registres d’interface des IP
#define CTRL_REG 4 // par rapport aux adresses de base
#define TELE_PWM_REG 0 // des périphériques
/*********** Alias pour Fonctions de Lecture/Ecriture ************/
/** C-style signature:
* void CHIFFRE_IP_WriteReg(u32 BaseAddress, unsigned RegOffset, u32 Data)
*/
#define CHIFFRE_IP_WriteReg(BaseAddress, RegOffset, Data) \
Xil_Out32((BaseAddress) + (RegOffset), (u32)(Data))
/** C-style signature:
* u32 CHIFFRE_IP_ReadReg(u32 BaseAddress, unsigned RegOffset)
*/
#define CHIFFRE_IP_ReadReg(BaseAddress, RegOffset) \
Xil_In32((BaseAddress) + (RegOffset))
/** C-style signature:
* void TELE_PWM_IP_WriteReg(u32 BaseAddress, unsigned RegOffset, u32 Data)
*/
#define TELE_PWM_IP_WriteReg(BaseAddress, RegOffset, Data) \
Xil_Out32((BaseAddress) + (RegOffset), (u32)(Data))
/** C-style signature:
* u32 TELE_PWM_IP_ReadReg(u32 BaseAddress, unsigned RegOffset)
*/
#define TELE_PWM_IP_ReadReg(BaseAddress, RegOffset) \
Xil_In32((BaseAddress) + (RegOffset))
L’application logicielle réalisée par le système s’appuie sur un tableau TAB_ACCESS de 100000 octets stocké
en mémoire. Chaque case correspond à un numéro d’étudiant (le numéro d’étudiant i correspond à la case i)
et indique si l’étudiant a le droit d’accéder au campus ou non (s’il a le droit, la case est à 1, sinon elle est à 0).
Voici une version partielle du code de l’application
/****************** Include Files ********************/
#include "xparameters.h"
#include "xgpio.h"
#include "drivers.h"
#define ADR_DEBUT_TAB ... // Adresse de la 1ère case de TAB_ACCESS
int i = 0;
unsigned char CHIFFRE = 0; // Chiffre récupéré dans l’IP CHIFFRE
unsigned int NUM_ETU; // Numéro d’étudiant à Vérifier
unsigned char ACCESS_OK; // Indicateur d’Autorisation d’Accès au Campus
unsigned char * PTR_TAB = ADR_DEBUT_TAB; // Pointeur sur TAB_ACCESS
// Fonction de Démarrage du Télémaètre
void Start_Telemetre() { ... } // On Suppose le Code déjà écrit
// Fonction de Démarrage de la PWM
void Start_PWM() { *** CODE A COMPLETER *** }
// Récupération du code ASCII du dernier chiffre tapé au clavier.
// La fonction retourne 0 si aucun nouveau chiffre n’a été entré
unsigned char Get_New_Chiffre(){ ... } // On Suppose le Code déjà écrit
// Détection d’une main sous le distributeur de gel hydroalcoolique
unsigned char Enable_Gel(){ *** CODE A COMPLETER *** }
int main()
{
// Configuration du Périphérique GPIO
XGpio LED;
XGpioInitialiez(&LED,GPIO_LED_DEVICE_ID);
XGpioSetDataDirection(&LED,1,0);
while(1)
{
NUM_ETU = 0;
// RECUPERATION DU NUMERO D’ETUDIANT
// *** CODE A COMPLETER ***
ACCESS_OK = *(PTR_TAB + NUM_ETU) //
// Si l’étudiant n’a pas accès au campus…
if !(ACCESS_OK) XGpioDiscreteWrite(&LED,0,1);
// Sinon…
else
{
XGpioDiscreteWrite(&LED,0,2);
Start_Telemetre();
// ATTENTE DETECTION D’UNE MAIN SOUS LE DITRIBUTEUR
// DE GEL HYDROALCCOLIQUE *** A COMPLETER ***
Start_PWM();
XGpioDiscreteWrite(&LED,0,4);
}
}
return 0;
}
Questions
4) Ecrire le code des fonctions suivantes :
o Start_PWM(), qui doit déclencher la génération du signal PWM.
o unsigned char Enable_Gel(), dans laquelle il faut tester si le flux d’ultra-sons a été
réfléchi ou non sur le télémètre et si tel est le cas, que le compteur de l’IP est
inférieure à 100000. Si ces conditions sont remplies, la fonction renvoie 1. Elle
renvoie 0 sinon.
5) En vous aidant éventuellement des fonctions décrites avant le programme principal de
l’application, compléter la fonction main() en écrivant la partie de code permettant de
reconstituer le numéro d’étudiant de la personne voulant entrer sur le campus
6) Compléter également main() pour ajouter les instructions permettant d’attendre la
détection du passage d’une main sous le distributeur de gel, pour déclencher la
distribution d’une dose de gel.
NB : Les questions portant sur le matériel (questions 1 à 3) et celles sur le logiciel
(questions 4 à 6) peuvent être traitées de manière indépendante.
