Projet Architec Projet Architecture hitecture
publicité
Université Gaston Berger de Saint-Louis UFR de sciences appliquées et Technologies Section Informatique Projet Architecture Licence Informatique (2012-2013) Conception d’un microprocesseur pour la gestion d’une pompe à essence (station de service EDK) Présenter par : OUMAR HAMID OUMAR MAHAMAT ASSADICK HASSANE SAYAR Sous la direction de : Dr. CHERIF DIALLO Sommaire I. Introduction .................................................................................................................................... 3 II. Description fonctionnelle d’une pompe à essence. ..................................................................... 3 III. Les interfaces d’entrées et sorties ............................................................................................. 3 IV. Architecture et fonctionnement du microprocesseur............................................................... 5 V. Jeux d’instructions .......................................................................................................................... 6 VI. Mode d’adressage des instructions ........................................................................................... 6 VII. Unité arithmétique et logique.................................................................................................... 8 VIII. Unite de contrôle ........................................................................................................................ 9 IX. Cycle d’exécution d’une instruction........................................................................................... 9 X. Programmation microprocesseur ................................................................................................ 10 XI. Conclusion................................................................................................................................. 11 I. Introduction La conception d'un micro-processeur impose d'incessants allers-retours entre le niveau fonctionnel (ce que la machine sera capable de faire), et le niveau matériel, qui spécifie comment elle le fera. Nous avons choisi de suivre partiellement la même démarche. D’abord, nous aborderons notre description du microprocesseur par le niveau fonctionnel, car c'est à ce niveau que seront définies les caractéristiques les plus générales. Il nous sera cependant impossible de définir totalement ce niveau fonctionnel en l'absence de définition matérielle. Cette première étape nous permettra de proposer une première ébauche d'architecture, en particulier en termes de constituants élémentaires. Ce n'est qu'ensuite que nous pourrons revenir sur le niveau fonctionnel et proposer, par exemple, un jeu d'instructions précis. II. Description fonctionnelle d’une pompe à essence. On désire réaliser un microprocesseur capable de gérer une pompe à essence d’une station de service (cas de l’EDK). Celui-ci fonctionne comme suit : Un bouton Volume est activé (v=1) lorsque la commande est en fonction de la quantité(le nombre de litre). Un bouton Montant est actif (m=1) lorsque la commande est fonction du Montant. Pour envoyer une commande on appuie sur Envoyer(e=1), qui se trouve juste derrière le clavier. On peut aussi annuler une commande en tapant sur Annuler (a=1). Lors que nous souhaitons commander par volume (par exemple 30 L), la première chose à faire c’est d’initialiser le système de telle sorte qu’il accepte le nombre de litre, en appuyant sur la touche Volume du clavier de bord ci-dessus. C’est le même principe si on veut commander par Montant, il suffit juste de commencer en tapant avant tout sur la touche Montant et continuer la saisie. En bref, une fois le mode de commande est choisi, l’utilisateur entre une valeur, puis il appuie sur le bouton envoyer pour valider la commande ou sur annuler, en cas d’erreur, afin de pouvoir recommencer l’opération. Lors d’un envoi, un test est effectué pour savoir l’état du réservoir (r=1 si le réservoir contient du carburant). Si r=1 un signal est émis pour envoyer le carburant et afficher le Montant et le volume commandés. Si r=0 un signal indiquant que le réservoir est vide et qu’il faut réapprovisionner, est alors envoyer. Lors d’une annulation de commande (a=1) le système est réinitialisé. III. Les interfaces d’entrées et sorties On dispose d’un clavier contenant des touches numériques et des touches de commande dont nous avons besoin pour lancer une commande, ce clavier sera lié a un décodeur d’adresse qui va décoder le code saisi au clavier et par la suite l’envoyer à un microprocesseur qui va traiter l’information ,c’est à dire effectuer la commande et en fin afficher le Montant et le volume dans les afficheurs LEDS.(voir figure ci-dessous) IV. Architecture et fonctionnement du microprocesseur Notre microprocesseur est organisé autour des deux composants fondamentaux qui sont l'ALU (Arithmetic and Logic Unit) et l'Unité de Contrôle (CU). Schématiquement, l'ALU est l'entité de calcul d'un microprocesseur tandis que l'UC est son entité de synchronisation. Ces deux composants sont reliés entre eux et avec les éléments de mémorisation par trois bus principaux : les bus A et B sont les bus d'entrée de l'ALU tandis que le bus C correspond a son bus de sortie (dans notre cas, les mots seront de 16 bits ; ce sera donc la taille de nos bus ). Schématiquement, l'ALU va réaliser des calculs sur les valeurs des bus A et B et mettre les résultats a disposition sur le bus C tandis que l'unité de contrôle sera chargée de décoder les instructions machines. Celles-ci, une fois décodées, vont correspondre a une suite d'ouvertures et de fermetures de commandes de façon à ce que les valeurs désirées soient placées sur les bons bus de données et que le résultat soit acheminé au bon endroit. C'est aussi l'Unite de Contrôle qui fixe l'opération effectuée par l'ALU (signaux Add, Comp, Shl, Shr, And, TrA et TrB) et qui choisit les registres d'index (signaux ID0 et ID1) lorsqu'ils sont utilises. Dans un microprocesseur, les unités de mémorisation sont des registres dont les temps d'accès sont beaucoup plus rapides que le temps d'accès mémoire (entre autre parce qu'un registre n'a pas à être adressé). Notre microprocesseur comprend des registres dédies a l'adressage (IDX1, IDX2 et IDX3) et des registres spécifiques (program counter, Instruction Register et Accumulateur). Dans le cas particulier du microprocesseur, on trouve aussi trois registres spécifiques destinés aux entrées sorties mémoire (AR, MW-R et MR-R) et trois constantes (NULL, +1 et -1). Le tableau suivant présente les différents registres de notre microprocesseur. Acronyme PC Nom Program Counter IR Instruction Register Acc Accumulateur AR Address Register MW-R Memory Write Register MR-R Memory Read Register IDX1 IDX2 IDX3 NULL Index 1 Index 2 index 3 Null register +1 Plus one register -1 Minus one register Schéma logique de l’application Fonction Contient l'adresse mémoire de la prochaine instruction à exécuter. Contient le code machine de l'instruction en cours d'exécution. Registre destiné à recevoir le résultat des opérations de calcul. Lors d'un accés mémoire (en lecture ou en écriture), ce registre contient l'adresse mémoire utilisée. Lors d'une opération d' ecriture en mémoire, ce registre contient le mot à transferer du bus vers la memoire. Lors d'une lecture mémoire, ce registre contient le mot a transférer de la mémoire vers le bus. Premier registre d'index. Deuxième registre d'index. Troisième registre d'index. Constante 0x0000 (utilisé pour spécifier les modes d'adressage non-index es). Constante 0x0001. Constante 0xFFFF Le microprocesseur qui a été développé en simulation par logiciel LogicWorks V. Jeux d’instructions Notre Microprocesseur dispose d'un ensemble d'instructions relativement étendu dans lequel on trouvera quatre instructions arithmétiques (addition, complément a deux, multiplication par deux et division par deux, ET logique), des instructions de saut (en fait deux sauts conditionnels et un saut inconditionnel), des instructions de manipulation d'index (lecture/ écriture d'index, incrément /décrément d'index) et deux instructions d'entrée-sortie (Read et Write). A ces instructions, il faudra naturellement ajouter deux instructions de lecture/ écriture mémoire (load et store). Nous obtenons donc un total de 16 instructions assembleur 16 bits (le code opération OpCode sera donc codé sur 4 bits). Celles-ci peuvent être, classiquement, regroupées en 4 types : Les instructions d'accès mémoire, les instructions arithmétiques, les instructions de branchement (conditionnelles ou inconditionnelles), les instructions d'entrée-sortie VI. Mode d’adressage des instructions Instruction OpCode Description Fonction LDA mem 0000 LoaD Accumulator STA mem 0001 STore Accumulator ADD mem 0010 TCA 0011 AND mem 0100 BRU mem 0101 Charge dans la mémoire, à l'adresse « mem » le contenu de l'accumulateur ADD Accumulator Ajoute a l'accumulateur le contenu de la mémoire lu a l'adresse « mem ». Le résultat de l'addition est stocke dans l'accumulateur Two Complement Complément a deux de l'accumulateur. Accumulator Le résultat de l'addition est stock e dans l'accumulateur AND Accumulator AND bit a bit entre l'accumulateur et le contenu de la mémoire lu a l'adresse « mem ». Le résultat est stock e dans l'accumulateur BRanchUnconditional Saut inconditionnel a l'adresse « mem ». BIP mem 0110 Branch If Positive Saut conditionnel. Saute a l'adresse « mem » si ACC>0. BIN mem 0111 Branch If Negative RWD 1000 Read a WorD WWD 1001 Write a WorD Saut conditionnel. Saute à l'adresse « mem » si ACC<0. Lit un mot sur la console et le charge dans l'accumulateur Ecrit sur l’afficheur LED , le contenu de l'accumulateur SHL 1010 SHift Left Décalage a gauche du contenu de l’accumulateur. Equivaut à une multiplication par deux. SHR 1011 SHift Right LDX mem 1100 LoaD indeX STX mem 1101 STore indeX Décalage à droite du contenu de l'accumulateur (avec conservation du signe). Equivaut à une division par deux. Charge dans un registre d'index le contenu de la mémoire lu à l'adresse « mem ». Charge dans la mémoire, à l'adresse « mem », le contenu de l'index TIX mem 1110 Test Incremented indeX Charge dans l'accumulateur le contenu de la mémoire lu a l'adresse « mem ». Incrémente le registre d'index et effectue un saut a l'adresse « mem » si le contenu du registre est nul. TDX mem VII. 1111 Test Decremented indeX Décrémente le registre d'index et effectue un saut a l'adresse « mem » si le contenu du registre est non nul Unité arithmétique et logique L'Unité Arithmétique et Logique (Arithmetic and Logic Unit ALU) est l'élément de calcul d'un microprocesseur. Elle comporte trois entrées : deux bus de données (Bus A et Bus B) et un bus de commande indiquant quelle opération l'ALU doit effectuer. Elle comporte une seule sortie correspondant au résultat de l'opération en cours (Bus C). Les trois bus de données (entrées et sorties) sont tous de la même taille (16 bits puisqu'il s'agit de la taille des mots manipulés par le microprocesseur). La taille du bus de commande dépend du nombre d'opérations réalisées par l'ALU. Dans le cas de notre microprocesseur, l'ALU va permettre l'exécution de calculs arithmétiques. De plus, un simple coup d'œil au schéma global de notre microprocesseur nous montre que l'ALU devra aussi permettre de transferer des informations de l'un de ses bus d'entrée (Bus A ou B) vers le bus C. C'est pourquoi, outre les cinq opérations nécessaires pour réaliser les instructions de calcul (addition, décalages à gauche ou à droite, ET logique et complément), l'ALU est dotée de deux opérations de transfert permettant de placer, sur le bus C, le contenu du bus A (opération TrA) ou du bus B (opération TrB). Finalement, notre ALU comporte sept opérations : Addition : le contenu du bus A est ajouté au contenu du bus B et le résultat est placé sur le bus C. On note : Bus C = ADD (Bus A, Bus B). And : ET logique entre le contenu du bus A et le contenu du bus B. Le résultat est placé sur le bus C. On note : Bus C = AND (Bus A, Bus B). Complément à 1 : le contenu du Bus A est complémenté et le résultat est placé sur le bus C. On note : Bus C=COMP (Bus A). Décalage à droite : le contenu du Bus A est décalé à droite d’un bit et le résultat est placé sur le Bus C (ce qui équivaut à une division par deux). On note: Bus C=SHR (Bus A). Décalage à gauche : le contenu du Bus A est décalé gauche de un bit et le résultat est placé sur le bus C (ce qui équivaut à une multiplication par deux). On note: Bus C=SHL (Bus A). Transfert A : le contenu du Bus A est place sur le Bus C. On note : Bus C=TrA (Bus A). Transfert B : le contenu du Bus B est placé sur le Bus C. On note : Bus C=TrB (Bus B). Schéma de l’Unité Arithmétique et Logique : VIII. Unite de contrôle L'unité de contrôle (UC) parfois appelée en français « séquenceur » constitue le cœur d'un microprocesseur : c'est elle qui régule les interactions entre les différents éléments en distribuant, suivant une synchronisation précise, les signaux de commande aux diverses unités participant à l'exécution d'une instruction (registres, ALU, bus, mémoires, ...). Elle lit une instruction et la charge dans le registre de lecture de la PROM (IR), Elle modifie la valeur stockée dans le PC pour permettre la lecture de l’instruction suivante (il peut s'agir d'une incrémentation ou d'un saut en fonction des informations dont dispose l’UC sur l'état du microprocesseur), Elle décode l’instruction de façon à fournir les signaux de contrôle au microprocesseur. Cette deuxième tache n'est pas toujours effectuée car certaines instructions sont destinées uniquement à la gestion interne de l'UC. Lorsqu'elle est nécessaire, cette opération est effectuée par un module spécifique : le décodeur. Le cycle d'exécution des instructions est cadencé par une horloge externe (CLK). On notera que, lorsque l'UC fournit les signaux de contrôle au microprocesseur, elle doit respecter une synchronisation précise (afin de garantir, par exemple, que l'ALU aura le temps d'exécuter les calculs demandés avant que les registres ne stockent le résultat). La figure ci-dessous présente l'architecture générale d'une UC micro-programmée. IX. Cycle d’exécution d’une instruction Afin d'assurer la bonne exécution de ces trois taches, l'exécution d'une instruction par le microprocesseur est divisée en trois phases distinctes : FETCH, DEFER (éventuellement) et EXECUTE. Le cycle FETCH correspond aux opérations de chargement de l'instruction à exécuter de la mémoire vers le registre MR-R puis vers IR (Cette opération devant être précédée du transfert de l'adresse de l'instruction (stockée dans le registre PC) vers le registre AR) et d'incrémentation du compteur ordinal (registre PC). DEFER n'est exécuté que lorsque le microprocesseur est utilisé en mode d'adressage indirect EXECUTE : l'UC doit donc décoder le code opératoire (OPCODE charge lors du cycle FETCH) pour savoir quelles instructions exécuter. De plus, la séquence des instructions peut aussi, suivant les instructions assembleurs, être dépendante de signaux de contrôle calculés en fonction de l'état de l'accumulateur ou d'un registre d'index. X. Programmation microprocesseur adr 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b commentaire FETCH type 0 0 0 0 0 1 0 2 3 0 0 5 instruction AR <- PC READ PC <- PC + 1 IR <- MR-R AR <-IR0-8 Si instr. non-indexable, saut a la ADDRESS 0x07 AR <-IR0-8 + IdX Saut vers (OPCODE +1)*8 Si IR13=1, saut vers DEFER ( ADDRESS 0x83) READ ACC <-MR-R Saut vers FETCH ( ADDRESS 0x00) valeur 0x08210 0x00004 0x08f30 0x009a0 0x06210 0x10700 0x06630 0x20000 0x38300 0x00004 0x008a0 0x50000 0x10 0x11 0x12 0x13 Exec. STA 3 0 0 5 Si IR13=1, saut vers DEFER (ADDRESS 0x83) MW-R <- ACC WRITE Saut vers FETCH (ADDRESS 0x00) 0x38300 0x02290 0x00008 0x50000 0x18 0x19 0x1a 0x1b Exec. ADD 3 0 0 5 Si IR13=1, saut vers DEFER (ADDRESS 0x83) READ ACC <- MR-R + ACC Saut vers FETCH (ADDRESS 0x00) 0x38300 0x00004 0x028b0 0x50000 0x20 0x21 0x22 Exec. TCA 0 0 5 ACC <- COMP(ACC) ACC <- ACC + 1 Saut vers FETCH (ADDRESS 0x00) 0x020c0 0x02cb0 0x50000 0x28 0x29 0x2a 0x2b Exec. AND 3 0 0 5 Si IR13=1, saut vers DEFER (ADDRESS 0x83) READ ACC <- AND (MR-R,ACC) Saut vers FETCH (ADDRESS 0x00) 0x38300 0x00004 0x028f0 0x50000 0x30 0x31 0x32 Exec. BRU 3 0 5 Si IR13=1, saut vers DEFER (ADDRESS 0x83) PC <-AR Saut vers FETCH (ADDRESS 0x00) 0x38300 0x04310 0x50000 0x38 0x39 0x3a 0x3b Exec. BIP 6 3 0 5 Si ACC <= 0, Saut vers FETCH (ADDRESS 0x00) Si IR13=1, saut vers DEFER (ADDRESS 0x83) PC <- AR Saut vers FETCH (ADDRESS 0x00) 0x60000 0x38300 0x04310 0x50000 0x40 0x41 Exec. BIN 7 5 Si ACC >= 0, Saut vers FETCH (ADDRESS 0x00) Saut vers la ADDRESS 0x39 0x70000 0x53900 Indexage Goto Exec Exec. LDA XI. Conclusion Actuellement la tendance est à la simplification des jeux d’instructions des machines et les ordinateurs micro-programmés sont moins diffusées. Toutefois, il faut remarquer que la programmation en assembleur se rapproche davantage de la conception de microprogramme que de l’écriture de programme en langage d’assemblage. En outre, la conception de circuits à la demande fait davantage appel à l’utilisation de systèmes en tranches pour lesquels l’utilisation du micro-contrôle est indispensable.
