PATRIE Thomas CARLIER Julien E2 Groupe A23 Projet conception de circuits Le jeu de la souris 2006 Semestre S3
Sommaire PRÉSENTATION... 4 1. LE PROTOCOLE PS2...4 PÉRIPHÉRIQUE VERS SYSTÈME MAÎTRE...5 SYSTÈME MAÎTRE VERS PÉRIPHÉRIQUE...5 2. GÉNÉRALITÉ SUR LA SOURIS PS2...6 II. RÉALISATION...8 1. CAHIER DES CHARGES... 8 2. MÉTHODOLOGIE...9 3. ARCHITECTURE... 10 4. DÉTAILS DE CODAGE...11 5. SIMULATIONS... 16 TEST_DEPLACEMENT :... 18 A CHAQUE NOUVELLE TRAME REÇUE, TEST_DEPLACEMENT FAIT LA SOMME DU DÉPLACEMENT INSTANTANÉ ET DU DÉPLACEMENT GLOBAL PRÉCÉDENT. UNE DÉTECTION DU SIGNE DU DÉPLACEMENT GLOBAL PERMET DE DONNER LA DIRECTION DE CELUI-CI....18 III. CONCLUSION...19
Présentation 1.Le protocole PS2 1Le protocole PS/2 permet une communication synchrone, bidirectionnelle et bits en série entre un système et un périphérique (couramment clavier, souris ou touchpad de portable). Chaque coté est susceptible d envoyer des commandes ou des données mais un seul coté ne pourra transmettre à la fois puisque la liaison se fait sur un seul fil. C est un connecteur mini-din-6 qui comporte 6 broches incluant masse, alimentation, la donnée série DATA et l horloge CLK. Deux broches sont inutilisées. Figure 1 : vue du connecteur mâle PS/2 C est le système maître qui alimente le périphérique PS/2. Les signaux DATA et CLK sont bidirectionnels et à sortie collecteur ouvert. Une résistance de 10K ohm environ doivent être placées entre ces deux signaux et l alimentation ce qui garantie un niveau haut hors de toute transaction. Le système maître est susceptible d envoyer au périphérique (ici la souris) des ordres de commande (tableau 1) mais à un autre moment c est le périphérique (ici la souris) qui va émettre des messages (tableau 2) ou retourner des données. Les octets de commandes et messages sont transmis de façon synchrone et série sur 11 /12bits (les 8 bits à transmettre, LSB en premier, précédés d un bit start ( 0 ) et suivi d un bit de parité et d un bit stop ( 1 ). Le bit de parité impaire vaut 1 si le nombre total de 1 dans l octet et le bit de parité lui-même est impair. PATRIE Thomas/CARLIER Julien Page 4 dd/11/yyyy
Durant la transmission, c est le périphérique qui fournit l horloge en la positionnant à un niveau bas (front descendant) tandis que l émetteur (système ou périphérique) place data à un niveau bas pour un bit 0 ou le laisse inactif pour un bit 1. La fréquence d horloge est au maximum de 33 khz mais le plus couramment de 15 khz. Entre les transmissions, le bus peut être : Idle : CLK et DATA sont tous les deux au niveau haut. Il n y a pas d activité. Inhibit : Le système maintient CLK au niveau bas Request to send : Le maître maintient DATA au niveau bas mais laisse CLK flotter. Il est prêt à émettre. Périphérique vers système maître Il peut transmettre un octet vers le système à condition que le bus soit préalablement «idle». L octet est transmis sous forme série avec l horloge (impulsions négatives). Le périphérique change les données sur front montant alors que le système est censé les lire pendant que CLK est à 0 (ou sur le front descendant). Figure 2 : transmission de la donnée F4 L ordre de grandeur de la période d horloge CLK est de 60 à 100 µs. Système maître vers périphérique Le système maître indique qu il souhaite émettre une commande en maintenant CLK au niveau bas pendant au moins 100 µs, puis forçant DATA au niveau bas (état du bus Request to send) tout en libérant CLK. Dès que le périphérique reconnaît (en moins de10 ms) ce signal bas, il va émettre son horloge et échantillonner la donnée. Le système est censé changer les données tant que CLK est au niveau bas (sur front descendant) tandis que le périphérique échantillonne chaque bit pendant que clk est haut (donc sur front montant). Figure 3 : transmission de la commande F4 PATRIE Thomas/CARLIER Julien Page 5 dd/11/yyyy
Après la reconnaissance du bit stop, le périphérique force DATA à 0 et fournie une impulsion d horloge supplémentaire. Ceci permet éventuellement au maître d inhiber l horloge tant qu il n est pas prêt à émettre de nouveau. L ordre de grandeur de la période d horloge CLK est de 60 à 100 µs. 2.Généralité sur la souris PS2 a.principe de fonctionnement La souris mécanique contient une boule qui roule sur deux axes de roues. Ces roues sont en fait des codeurs optiques qui traduisent les mouvements en X ou en Y en nombres par comptage d impulsions. La souris fonctionne par défaut avec une résolution de 200 CPI (Counts Per Inch), ce qui correspond à un pas de 125 µm environ. La souris contient aussi 2 ou 3 boutons poussoirs. L ensemble est géré par un microcontrôleur interne qui, outre la transmission des déplacements X (gauche/droite) et Y (bas/haut) et de l état des boutons, est aussi capable d interpréter des commandes ou de transmettre des messages. Dans les échanges, c est toujours la souris qui fournie l horloge CLK. Le maître peut cependant, s il le désire inhiber cette horloge en maintenant son niveau à bas. b.fonctionnement courant Il convient d envoyer à la souris la commande F4 pour valider le mode transmission en continu. La souris répond à cette commande par l octet d acquittement FA, puis envoie alors les données au système par paquet de trois octets contenant les informations de déplacement et d état des boutons. MSB LSB Bit 7 6 5 4 3 2 1 0 Octet 1 Yo Xo Ys Xs 1 M R L Octet 2 X7 X6 X5 X4 X3 X2 X1 X0 Octet 3 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 L = Left key status bit (1 appuyé, 0 relâche) M = Middle Key status bit R = Right Key status bit X7-X0 = déplacement en X en complément à 2 (négatif à gauche, positif à droite) Y7-Y0 = déplacement en Y en complément à 2 (négatif en bas, positif en haut) Xo = bit d overflow sur X Yo = bit d overflow sur Y Xs = Signe de X (1 = négatif) Ys = Signe de Y (1 = négatif) Les compteurs de mouvement sont des mots de 9 bits en complément à 2. Le MSB est le bit de signe qui se retrouve dans l octet 1 de la trame et les autres 8 bits dans les octets 2 ou 3. Ces compteurs sont mis à jour lorsque la souris détecte un mouvement. Ils contiennent la somme de tous les mouvements effectués depuis le dernier transfert de trame vers le système. Ils ont une valeur comprise entre +255 et 256. S il y a dépassement, les bits d overflow de l octet 1 sont activés et aucun incrément ou décrément n est possible jusqu à l émission de la trame et le reset des compteurs qui s en suit. PATRIE Thomas/CARLIER Julien Page 6 dd/11/yyyy
Quant à la durée d une trame, il faut compter l émission des trois octets espacés d environ 350 µs, cela donne environ 3,6 ms. Si on rajoute une durée d au moins 6,4 ms entre trames, alors la souris pourra envoyer jusqu à 100 trames par seconde. c.exploitation Sur un ordinateur, la souris sert à réaliser un curseur vidéo. Chaque fois que la souris émet une nouvelle trame, il faut rajouter à la position courante du curseur les mouvements H et V correspondants. Le curseur sera initialisé au centre de l écran au départ. On constate qu il suffit de deux registres d accumulation pour mémoriser la position du curseur en H ainsi que celle en V. L idéal est que la résolution de la souris (plus petit déplacement) corresponde à la résolution de l écran (un pixel). PATRIE Thomas/CARLIER Julien Page 7 dd/11/yyyy
II.Réalisation 1.Cahier des charges Les exigences du projet se décomposent en 3 sous parties : a) Piloter une souris : Création du composant «pilote_souris» gérant l'initialisation, et capable d'extraire les informations de déplacements (entité fournie). b) Identifier les déplacements d'une souris : Création d'un composant «test déplacement» donnant, a chaque arret de la souris, la direction (haut, bas, gauche, droite) du dernier déplacement continu. c) Création d'un test de motricité: Création d'un composant «test_motricité» permettant de signaler un écart entre la position de la souris et un parcours prédéfini à une tolérance près. PATRIE Thomas/CARLIER Julien Page 8 dd/11/yyyy
2.Méthodologie Debut INIT Tempo 100us CLK= 0' Fin tempo Request_to_send CLK= Z' DATA= 0' Emission F4 Fin_emission Confirmation Réception FA Fin_reception Affiche FA Réception 3 trames Fin_reception Calcul Debut_cycle Tempo : Le pilote force la CLK a 0 pendant 100us pour communiquer des commande a la souris. PATRIE Thomas/CARLIER Julien Page 9 dd/11/yyyy
Request_to_send (RTS) : le pilote force DATA a 0 et libère CLK. Emission F4 : le pilote indique a la souris qu elle peut commencer a envoyer des données. Confirmation : le pilote attend la commande retour de la souris (F4 si elle a bien «compris» la commande) Affiche FA : le pilote affiche FA pour indiquer l étape active (inutile dans le cas d une utilisation réelle) Réception 3 trames : le pilote reçoit les données de la souris (chacune codée sur 3 trames) Calcul : le pilote effectue le traitement des données reçues. 3.Architecture INIT Clk_24MHz 0 0 V c c1 V c c2 b1 5 CLK 1 a1 b2 6 DATA 2 a2 Souris Pilote b1 5 b2 6 9 9 b3 7 Boutons L, M, R Déplacements X et Y b1 5 Unité de traitement b2 b3 6 7 Afficheurs b4 8 X : Bus de 8 Bits informant sur la coordonnée X du déplacement Y : Bus de 8 Bits informant sur la coordonnée Y du déplacement L : Bit valant 1 si un appui sur le bouton gauche de la souris est détecté M : Bit valant 1 si un appui sur le bouton milieu de la souris est détecté R : Bit valant 1 si un appui sur le bouton droit de la souris est détecté Init : Initialisation du pilote Clk_24MHz : horloge de la CM PATRIE Thomas/CARLIER Julien Page 10 dd/11/yyyy
CLK : ligne bidirectionnelle de l'horloge souris. DATA : ligne bidirectionnelle de donnée. Afficheurs : 6 bus de 7(/8) bits correspondants à chacun des afficheurs disponibles sur la CM la souris est un composant qui à été conçu uniquement dans le but d'éprouver le pilote dans des conditions les plus fidèles possibles à la réalité. Sa réalisation aurait pu faire l'objet d'une étude similaire à celle du pilote, avec un comportement dynamique prenant en compte les réactions de ce dernier, mais cela n'avançant en rien le projet, on choisira une description temporelle figée de ce composant pour tester notre pilote. Le composant interfaçage sert uniquement à concrétiser par un affichage sur la carte mère une séquence de test adapté apte à prouver le bon fonctionnement du composant «pilote_souris». 4.Détails de codage Composant pilote_souris Le séquenceur enchaîne les différentes étapes et boucle sur la réception des trames et leur traitement. Tous les états sont conditionnés par des variables internes de pilote_souris. Dans la fonction case on a par exemple : WHEN état_1 => IF fin_état_1 = '1' THEN etat <= état_2 Cela se traduit par : Quand on est à etat = état_1, si fin_état_1 passe à 1 alors on passe à etat = état_2 sinon on reste à etat = état_1. sequenceur: PROCESS (horloge_24mhz) BEGIN -- PROCESS sequenceur IF horloge_24mhz= '1' THEN -- synchrone IF initialiser = '1' THEN etat <= debut; ELSE CASE etat IS WHEN debut => etat <= tempo; WHEN tempo => IF fin_tempo = '1' THEN etat <= rts; WHEN rts => etat <= emission; WHEN emission => IF fin_emission = '1' THEN etat <= reception1; WHEN reception1 => IF fin_octet = '1' THEN etat <= debut_trame ; WHEN debut_trame => etat <= reception2; WHEN reception2 => IF fin_trame = '1' THEN etat <= calcul; WHEN calcul => IF fin_calcul= '1' THEN etat <= reception2; END CASE; END PROCESS sequenceur; PATRIE Thomas/CARLIER Julien Page 11 dd/11/yyyy
Actions liées aux états du séquenceur : init_tempo <= (etat = debut); direction_horloge <= (etat = tempo); emettre <= (etat = emission); direction_donnee <= (etat = emission) OR (etat = rts) ; recevoir <= (etat = reception1) OR (etat = reception2); calculer <= (etat = calcul); Tout d'abord il faut définir les entrées/sorties du composant pilote_souris ainsi que les bibliothèques nécessaires au projet ce qui correspond au code VHDL suivant : LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.numeric_std.all; ENTITY pilote_souris IS PORT ( horloge_24mhz : IN std_ulogic; -- horloge systeme initialiser : IN std_ulogic; -- reset general du circuit donnee_souris : INOUT std_logic; -- bidirectionnel horloge_souris : INOUT std_logic; bouton_gauche : OUT std_ulogic; -- indique un appui bouton_milieu : OUT std_ulogic; -- indique un appui bouton_droit : OUT std_ulogic; -- indique un appui deplacement_x : OUT signed (8 DOWNTO 0); -- excursion -256 +255 deplacement_y : OUT signed (8 DOWNTO 0); -- excursion -256 +255 reponse_souris : OUT std_logic_vector(7 DOWNTO 0)); -- sortie vers les afficheur, pour le test sur la carte memec END pilote_souris; Ensuite on définit l'architecture de pilote_souris que l'on va utiliser ainsi que tous les signaux internes et les "états" que peut prendre t_etat qui vont nous être utiles plus tard. ARCHITECTURE denous OF pilote_souris IS SIGNAL recevoir, emettre, calculer : boolean; SIGNAL init_tempo, direction_donnee: boolean; SIGNAL direction_horloge : boolean; SIGNAL droit : std_ulogic; SIGNAL gauche : std_ulogic; SIGNAL milieu : std_ulogic; SIGNAL mouvement_h : signed(8 DOWNTO 0); SIGNAL mouvement_v : signed(8 DOWNTO 0); SIGNAL x0, y0 : std_ulogic; TYPE t_etat IS (debut, tempo, rts, emission, reception1, debut_trame, reception2,calcul); SIGNAL etat : t_etat; SIGNAL fin_tempo : std_ulogic; PATRIE Thomas/CARLIER Julien Page 12 dd/11/yyyy
BEGIN SIGNAL fin_octet : std_ulogic; SIGNAL fin_emission : std_ulogic; SIGNAL fin_trame : std_ulogic; SIGNAL fin_calcul : std_ulogic; SIGNAL fin_init : std_ulogic; SIGNAL donnee_e : std_ulogic; SIGNAL donnee_s : std_ulogic; SIGNAL horloge_e : std_ulogic; Ici on va gérer le passage de donnee_souris à 'Z' pour que le système maître puisse envoyer des données à la souris. On gère également le passage de horloge_souris à '0' ou à 'Z' ainsi que celui de horloge_e à la valeur de horloge_souris. -- separation des donnes en entree et sortie donnee_e <= donnee_souris; donnee_souris <= donnee_s WHEN direction_donnee ELSE 'Z'; -- separation des horloges en entree et sortie horloge_souris <= '0' WHEN direction_horloge ELSE 'Z'; horloge_e <= horloge_souris ; La temporisation sert à maintenir l'horloge souris pendant 100 us environ lorsque le système veut commander la souris ce qui est représenté par le code VHDL du process suivant : temporisation: PROCESS (horloge_24mhz) CONSTANT duree : natural := 2400; -- 100 us a 24Mhz VARIABLE decompteur : natural RANGE 0 TO duree; BEGIN -- PROCESS temporisation IF horloge_24mhz= '1' THEN -- synchrone IF init_tempo THEN decompteur := duree; fin_tempo <= '0'; ELSIF decompteur /= 0 THEN decompteur := decompteur -1; ELSE fin_tempo <= '1'; END PROCESS temporisation; Le process émission ne sert qu'à émettre la commande "stream mode". On crée ensuite le process emiss qui se déclanche sur un changement de emettre ou de horloge_souris. emiss: PROCESS(emettre, horloge_souris) VARIABLE nb_bits : natural RANGE 0 TO 11; VARIABLE registre_emission : std_logic_vector(11 DOWNTO 0); CONSTANT mot_f4 : std_logic_vector(11 DOWNTO 0) := "010111101000"; BEGIN -- PROCESS emission IF emettre = false THEN -- asynchrone registre_emission := mot_f4; nb_bits := 0; ELSIF falling_edge(horloge_souris) THEN -- synchrone registre_emission := '0' & registre_emission(11 DOWNTO 1); PATRIE Thomas/CARLIER Julien Page 13 dd/11/yyyy
nb_bits := nb_bits + 1; IF nb_bits = 11 THEN fin_emission <= '1'; ELSE fin_emission <= '0'; donnee_s <= registre_emission(0); -- On émet le premier bit de registre_emission END PROCESS emiss; Dans ce process on effectue un décalage de registre_emission à droite et on émet le premier bit de registre_emission (i.e. registre_emission(0)) tout en incrémentant nb_bits à chaque bit émis. Le process réception sert soit à recevoir l'acquittement du mot de commande précédant soit à recevoir une trame complète. Le process reception ne se déclanche que sur un changement de recevoir ou de horloge_souris reception : PROCESS(recevoir, horloge_souris) VARIABLE nb_bits : natural RANGE 0 TO 34; VARIABLE registre_reception : std_logic_vector(32 DOWNTO 0); BEGIN -- PROCESS reception IF recevoir = false THEN -- asynchrone nb_bits := 0; ELSIF falling_edge(horloge_souris) THEN -- synchrone registre_reception := donnee_e & registre_reception(32 DOWNTO 1) ; nb_bits := nb_bits + 1; IF nb_bits = 11 and etat = reception1 THEN fin_octet <= '1'; reponse_souris <= registre_reception(31 DOWNTO 24); ELSE fin_octet <= '0'; IF nb_bits = 34 THEN fin_trame <= '1'; ELSE fin_trame <= '0'; mouvement_v <= signed(registre_reception(6) & Ys registre_reception(30 DOWNTO 23)); deplacement vertical Y7->Y0 mouvement_h <= signed(registre_reception(5) & Xs registre_reception(19 DOWNTO 12)); deplacement horizontal X7->X0 gauche <= registre_reception(1); milieu <= registre_reception(3); droit <= registre_reception(2); x0 <= registre_reception(7); y0 <= registre_reception(8); END PROCESS reception; --bit de signe --Octet de --bit de signe --Octet de Si on est dans le cas recevoir, on rempli le registre_reception avec la trame à envoyer tout en incrémentant nb_bits. On met dans mouvement_v et mouvement_h respectivement l'octet de déplacement vertical et horizontal ainsi que leur bit de signe respectif. PATRIE Thomas/CARLIER Julien Page 14 dd/11/yyyy
Pour finir on crée un process calcule qui affecte aux différentes variables internes les datas reçues de la souris. calcule : PROCESS(calculer, horloge_24mhz) BEGIN -- PROCESS calcule IF (calculer=true) THEN -- and (falling_edge(horloge_souris)=true)) THEN bouton_gauche <= gauche; bouton_milieu <= milieu; bouton_droit <= droit; if X0 = '0' THEN deplacement_x <= mouvement_h; IF Y0 = '0' THEN deplacement_y <= mouvement_v; fin_calcul <= '1'; ELSE fin_calcul <= '0'; END PROCESS calcule; Composant test_deplacement On commence ici par définir le composant test_deplacement avec ses entrées/sorties notamment HBGD qui contient le résultat du déplacement global de la souris. LIBRARY ieee; USE ieee.std_logic_1164.all; USE ieee.numeric_std.all; ENTITY test_deplacement IS PORT ( horloge_24mhz : IN std_ulogic; -- horloge systeme horloge_souris : IN std_logic HBGD : OUT std_logic_vector(3 DOWNTO 0); deplacement_x : IN signed(8 DOWNTO 0); deplacement_y : IN signed(8 DOWNTO 0)); END test_deplacement; Ensuite on défini l'architecture de test_deplacement avec les variables internes qui sont global_x, global_y qui contiennent les déplacements en x et en y de la souris puis de stop qui indique que la souris est fixe. ARCHITECTURE test OF test_deplacement IS SIGNAL global_x, global_y : signed(8 DOWNTO 0) := (OTHERS => 'Z'); SIGNAL stop : std_ulogic; BEGIN On crée donc un process deplacement qui se déclenche sur un changement de horloge_souris et qui va faire la somme de chaque déplacement instantané. Ensuite les deux premiers bits de HBGD sont conditionnés en fonction du signe de global_x et les deux derniers par celui de global_y comme est défini dans le code VHDL ci-dessous. PATRIE Thomas/CARLIER Julien Page 15 dd/11/yyyy
END test; deplacement : PROCESS (horloge_souris) BEGIN IF (deplacement_x(7 DOWNTO 0) = "00000000" AND deplacement_y(7 DOWNTO 0) = "00000000") THEN stop <= '1'; IF global_x(8)='0' THEN HBGD(1 DOWNTO 0) <= "01"; ELSE HBGD(1 DOWNTO 0) <= "10"; IF global_y(8)='0' THEN HBGD(3 DOWNTO 2) <= "10"; ELSE HBGD(3 DOWNTO 2) <= "01"; global_x <= "000000000"; global_y <= "000000000"; ELSE stop <= '0'; global_x <= global_x + deplacement_x; global_y <= global_y + deplacement_y; END PROCESS deplacement; 5.Simulations Pour la simulation de notre pilote, nous avons programmé un test bench en temporel. En effet, la programmation d un test bench réaliste est très lourde, et pourrai faire l objet d un projet a part entière. Le test bench en temporel permet un bon débogage, mais ne garantie pas le bon fonctionnement lors de l utilisation dans des conditions réelles. Simulation globale du pilote (sur 5ms) Nous allons expliquer chaque partie de cette simulation. Request to send : Cette simulation correspond aux 200us du début. On remarque l horloge souris clk_s qui est en Z, et est forcé à 0 pendant 100us par le pilote. Le pilote force ensuite donnee à 0 jusqu'à ce que l horloge souris redémarre. Au premier front descendant de clk_s, le pilote commence à envoyer la commande (ici F4) PATRIE Thomas/CARLIER Julien Page 16 dd/11/yyyy
Envoi F4 : Au premier front descendant de clk_s, le pilote commence l envoi de la commande F4, dont la trame est 00010111101. Pendant ce temps, le test bench met donnee en haute impedance. Réception FA : Lorsque la souris a reçu la commande F4, elle renvoi FA sur donnee. Le pilote doit alors mettre donnee en haute impédance (ce qui est bien le cas ici puisqu il n y a pas de conflits). La trame de FA est : 00101111111. Affichage FA : Pour vérifier le fonctionnement du système, nous avons rajouté une sortie affiche, qui renvoi sur des afficheurs la commande reçu par le pilote. Ici, la sortie affiche renvoie la commande FA, réponse de la souris a la commande précédente. PATRIE Thomas/CARLIER Julien Page 17 dd/11/yyyy
Réception des données souris (3 trames) : Une fois que la souris à envoyer la confirmation (FA), elle commence a envoyer les données. Elle envoi 3 trames (33 bits) contenant des informations sur le déplacement, et l appui sur les boutons. Ici, la trame est envoyée par le test bench. Le pilote est bien en réception, puisque donnee est bien en haute impédance. Renvoi des données reçues : A chaque trame reçue par le pilote, celui-ci en extrait les informations, et les renvoi sur ses sorties (gauche, milieu, droit pour les boutons, et x et y pour les déplacements). Test_deplacement : On fait un test du composant test_deplacement seul. A chaque nouvelle trame reçue, test_deplacement fait la somme du déplacement instantané et du déplacement global précédent. Une détection du signe du déplacement global permet de donner la direction de celui-ci. PATRIE Thomas/CARLIER Julien Page 18 dd/11/yyyy
III.Conclusion Ce projet nous a permis de nous familiariser avec le VHDL. Il nous a aussi appris à toujours garder a l esprit que chaque ligne de commande doit correspondre a une réalité physique. En effet, des commande tel que wait until ne sont pas synthétisable. Bien que notre programme ne marche pas sur le Xilinx, ce projet nous a permis d aller jusqu au bout de la mise en œuvre des FPGA, en implantant notre programme dans le puce. PATRIE Thomas/CARLIER Julien Page 19 dd/11/yyyy