marina prats tudó equip didÀctic per a la mÀquina...

Marina Prats Tudó

EQUIP DIDÀCTIC PER A LA MÀQUINA SENZILLA

TREBALL DE FI DE GRAU

Dirigit pel Dr. Nicolau Cañellas Alberich

Grau d’Enginyeria de Sistemes i Serveis de Telecomunicacions

Tarragona

2018

Agraïments

2

Agraïments

En finalitzar aquest treball que he desenvolupat durant els últims mesos vull agrair a totes les persones que l’han fet possible i que m’han ajudat i donat el seu suport en aquesta etapa.

En primer lloc, vull agrair al Nicolau Cañellas, el tutor del treball, la dedicació i la feina que ha fet per ajudar-me a realitzar-lo, però sobretot li vull donar les gràcies per ensenyar-me i explicar-me en tot moment el que he necessitat.

També vull agrair tant al tutor com al departament la oportunitat de poder desenvolupar un treball de suport a la docència, que em permet ajudar d’alguna manera als futurs estudiants de l’escola en la que jo m’he format com a enginyera i també deixar a la universitat els fruits del que he après com a estudiant els quatre anys que he sigut alumna a la Universitat Rovira i Virgili.

Finalment, als meus companys, amics i família, que m’han animat sempre a seguir endavant i a aconseguir els meus objectius.

Moltes gràcies a tots.

Índex

3

Índex

Agraïments ............................................................................................................................ 2

Índex ...................................................................................................................................... 3

Índex de Figures .................................................................................................................... 6

1 Introducció ..................................................................................................................... 8

1.1 Antecedents ............................................................................................................. 8

1.2 Objectiu ................................................................................................................... 8

1.3 ISE Design Suite de Xilinx ..................................................................................... 9

1.4 Llenguatge VHDL .................................................................................................. 9

1.4.1 Estructura de Programa en VHDL .................................................................. 9

1.5 Concepte d’FPGA ................................................................................................. 10

1.6 Placa BASYS 2 ..................................................................................................... 10

1.7 Registre de Desplaçament ..................................................................................... 12

2 Conceptes Teòrics........................................................................................................ 14

2.1 La Màquina Senzilla ............................................................................................. 14

2.1.1 Unitat Central de Procés (CPU)..................................................................... 15

2.1.2 Memòria ........................................................................................................ 15

2.1.3 Unitat d’Entrada i Sortida .............................................................................. 15

2.1.4 Busos ............................................................................................................. 15

2.2 El Microcontrolador PIC16F877 .......................................................................... 16

2.2.1 Format i Repertori d’Instruccions ................................................................. 17

2.3 Tria de les Instruccions de la Màquina Senzilla ................................................... 18

2.3.1 Primer Programa Dissenyat amb el Joc d’Instruccions ................................. 19

2.3.2 Segon Programa Dissenyat amb el Joc d’Instruccions .................................. 19

3 Disseny de la Màquina Senzilla per a l’Entrenador Didàctic ...................................... 20

3.1 Disseny de la Unitat de Procés ............................................................................. 21

3.1.1 Unitat Aritmeticològica (ALU) ..................................................................... 21

3.1.2 Registre d’Instruccions (RI) .......................................................................... 23

3.1.3 Registre Comptador de Programa (PC) ......................................................... 23

3.1.4 Registre d’Adreces (RA) ............................................................................... 23

3.1.5 Multiplexor entre el RA i el PC ..................................................................... 23

3.1.6 Registre Acumulador (W) ............................................................................. 24

Índex

4

3.1.7 Registre del Flag Zero (FZ) ........................................................................... 24

3.2 Disseny de la Unitat de Control ............................................................................ 25

3.2.1 Estats i Fases d’Execució de les Instruccions ................................................ 26

3.2.2 Simplificació del Graf d’Estats ..................................................................... 29

3.3 Disseny de la Memòria ......................................................................................... 31

3.3.1 Programes Escrits en Memòria ...................................................................... 31

3.4 Disseny de la Temporització ................................................................................. 32

4 Implementació de la Màquina Senzilla de 8 bits amb Xilinx ISE ............................... 33

4.1 Implementació de la Unitat de Procés .................................................................. 33

4.1.1 Unitat Aritmeticològica (ALU) ..................................................................... 35

4.1.2 Registre d’Instruccions (RI) .......................................................................... 35

4.1.3 Registre Comptador de Programa (PC) ......................................................... 36

4.1.4 Registre d’Adreces (RA) ............................................................................... 36

4.1.5 Multiplexor entre el RA i el PC ..................................................................... 37

4.1.6 Registre Acumulador (W) ............................................................................. 37

4.1.7 Registre del Flag Zero (FZ) ........................................................................... 38

4.2 Implementació de la Unitat de Control ................................................................. 39

4.3 Implementació de la Memòria .............................................................................. 40

4.3.1 Col·locació dels Valors Inicials a la Memòria .............................................. 41

4.4 Connexió de la Unitat de Procés amb la Memòria ............................................... 44

4.5 Implementació de la Temporització ..................................................................... 45

4.5.1 Bloc Divisor ................................................................................................... 45

4.5.2 Bloc Rellotge ................................................................................................. 46

5 Comunicació de la Màquina Senzilla amb l’Entrenador ............................................. 49

5.1 Disseny de la Comunicació amb l’Entrenador...................................................... 49

5.1.1 Disseny del Registre de Desplaçament Intern ............................................... 49

5.1.2 Disseny del Registre de Desplaçament Físic ................................................. 50

5.2 Implementació del la Comunicació amb l’Entrenador ......................................... 51

5.2.1 Implementació del Registre de Desplaçament Intern .................................... 52

5.2.2 Implementació del Controlador dels Registres de Desplaçament ................. 53

6 Disseny de l’Entrenador .............................................................................................. 57

6.1 Circuït de Control del Registre de Desplaçament Físic ........................................ 57

6.2 Circuït d’Il·luminació per als LEDS ..................................................................... 58

Índex

5

7 Referències .................................................................................................................. 59

8 Annexos ....................................................................................................................... 60

8.1 Codis VHDL ......................................................................................................... 60

8.1.1 ALU.vhdl ....................................................................................................... 60

8.1.2 RI.vhdl ........................................................................................................... 60

8.1.3 PC.vhdl .......................................................................................................... 61

8.1.4 RA.vhdl ......................................................................................................... 61

8.1.5 MUX.vhdl ...................................................................................................... 62

8.1.6 W.vhdl ........................................................................................................... 62

8.1.7 FZ.vhdl .......................................................................................................... 63

8.1.8 UC.vhdl ......................................................................................................... 64

8.1.9 divisor50kHz.vhdl ......................................................................................... 66

8.1.10 divisor20.vhdl ................................................................................................ 66

8.1.11 Rellotge.vhdl ................................................................................................. 67

8.1.12 comptador.vhdl .............................................................................................. 68

8.1.13 controller.vhdl ............................................................................................... 69

8.2 Pràctiques de Laboratori ....................................................................................... 71

8.2.1 Pràctica de Laboratori 1: LA MÀQUINA SENZILLA ................................. 71

8.2.2 Pràctica de Laboratori 2: REGISTRES DE DESPLAÇAMENT .................. 73

Índex de Figures

6

Índex de Figures

Figura 1. Placa Basys 2. ...................................................................................................... 10

Figura 2. Diagrama de blocs de la placa Basys 2. ............................................................... 11

Figura 3. Registre de desplaçament SISO de 4 bits. ............................................................ 12

Figura 4. Registre de desplaçament SIPO de 4 bits. ............................................................ 12

Figura 5. Registre de desplaçament PISO de 4 bits. ............................................................ 13

Figura 6. Registre de desplaçament PIPO de 4 bits. ............................................................ 13

Figura 7. Estructura bàsica d’un computador. ..................................................................... 14

Figura 8. PIC16F877. .......................................................................................................... 16

Figura 9. Joc d’instruccions del PIC16F877. ...................................................................... 17

Figura 10. Joc d’instruccions codificades amb 4 bits. ......................................................... 18

Figura 11. Estructura general de la màquina senzilla. ......................................................... 20

Figura 12. Diagrama de blocs de la unitat de procés amb senyals de control i la memòria.21

Figura 13. Taula d’instruccions realitzades per l’ALU. ...................................................... 22

Figura 14. Disseny de la unitat aritmeticològica. ................................................................ 22

Figura 15. Disseny del multiplexor entre el RA i el PC. ..................................................... 23

Figura 16. Disseny de la unitat de control cablejada. .......................................................... 25

Figura 17. Graf d’estats de la unitat de control. .................................................................. 28

Figura 18. Taula de valors de sortida de la UC segons l’estat............................................. 29

Figura 19. Taula de valors de sortida de la UC segons l’estat per al graf simplificat. ........ 29

Figura 20. Graf d’estats de la unitat de control simplificat. ................................................ 30

Figura 21. Estructura de la memòria. .................................................................................. 31

Figura 22. Disseny de la temporització. .............................................................................. 32

Figura 23. Símbol de la unitat de procés en Xilinx. ............................................................ 33

Figura 24. Esquemàtic intern de la unitat de procés. ........................................................... 34

Figura 25. Símbol de la unitat aritmeticològica. ................................................................. 35

Figura 26. Símbol del registre d’instruccions. ..................................................................... 35

Figura 27. Símbol del registre comptador de programa. ..................................................... 36

Figura 28. Símbol del registre d’adreces. ............................................................................ 36

Figura 29. Taula d’adreces segons el valor d’entrada del multiplexor. ............................... 37

Figura 30. Símbol del multiplexor entre el RA i el PC. ...................................................... 37

Figura 31. Símbol del registre acumulador. ........................................................................ 37

Figura 32. Símbol de registre del flag zero. ........................................................................ 38

Figura 33. Símbol de la unitat de control en Xilinx. ........................................................... 39

Figura 34. Memòria RAMB16_S9. ..................................................................................... 40

Figura 35. Taula de valors en binari i hexadecimal del primer programa. .......................... 41

Figura 36. Valors del primer programa introduïts a la memòria. ........................................ 42

Figura 37. Taula de valors en binari i hexadecimal del segon programa. ........................... 43

Figura 38. Valors del segon programa introduïts a la memòria. ......................................... 43

Figura 39. Connexions amb Bus Tap entre la UP i la memòria. ......................................... 44

Figura 40. Blocs que formen el rellotge de la màquina senzilla. ........................................ 45

Índex de Figures

7

Figura 41. Implementació del bloc divisor. ......................................................................... 45

Figura 42. Símbol del bloc Rellotge. ................................................................................... 46

Figura 43. Esquemàtic de tots els elements que formen el bloc màquina senzilla. ............. 47

Figura 44. Símbol del bloc MaqSenz. ................................................................................. 48

Figura 45. Disseny del registre de desplaçament intern. ..................................................... 50

Figura 46. Diagrama lògic del registre de desplaçament MC74HC595N. .......................... 50

Figura 47. Muntatge de l’esquemàtic que realitza la comunicació. .................................... 51

Figura 48. Símbol del bloc Comunicacio. ........................................................................... 51

Figura 49. Registre de desplaçament SR16RLE. ................................................................ 52

Figura 50. Muntatge del registre de desplaçament intern. ................................................... 53

Figura 51. Graf d’estats del controlador dels registres de desplaçament. ........................... 54

Figura 52. Símbol del bloc controller. ................................................................................. 55

Figura 53. Símbol del bloc comptador. ............................................................................... 56

Figura 54. Muntatge del bloc Intern. ................................................................................... 56

Figura 55. Control del registre de desplaçament físic. ........................................................ 57

Introducció

8

1 Introducció

1.1 Antecedents

Aquest projecte neix a partir dels coneixements adquirits en les assignatures Fonaments de Computadors, Electrònica Bàsica i Microcontroladors i Sistemes

Embedded.

Per a desenvolupar-lo utilitzaré com a referents principalment la pràctica Despertador VHDL de l’assignatura Electrònica Bàsica, els materials teòrics i pràctics dels temes sobre la màquina senzilla d’Electrònica Bàsica i Microcontroladors i Sistemes Embedded i també els materials teòrics i pràctics dels temes sobre el microcontrolador PIC16F877, a més a més de la teoria inicial sobre el llenguatge màquina de Fonaments de Computadors.

Concretament, les instruccions que s’utilitzaran per al disseny de la màquina senzilla estan inspirades en el joc d’instruccions bàsiques de la màquina senzilla explicada a classe, però ampliades i adaptades mitjançant el joc d’instruccions del microcontrolador PIC.

1.2 Objectiu

L’objectiu del treball és crear un entrenador per a la màquina senzilla, amb el qual els alumnes de primer curs seran capaços d’entendre de manera més fàcil i efectiva el funcionament d’un microprocessador.

En primer lloc, aquest entrenador es dissenyarà per a permetre als alumnes visualitzar les parts més interessants i didàctiques de la màquina senzilla amb leds que les representaran a l’entrenador que s’utilitzarà a classe.

En segon lloc es desenvoluparan amb el programa Xilinx ISE Design Suite els codis VHDL i els esquemàtics necessaris que posteriorment es gravaran a la FPGA de la placa BASYS 2 de DIGILENT.

Finalment, es realitzarà el muntatge físic per a obtenir l’entrenador amb la FPGA que permeti representar el que passa a l’interior del microprocessador, amb els elements de comunicació necessaris per a fer-ho possible.

Aquest projecte s’aplicarà a les classes de l’assignatura Electrònica Digital per als graus d’Enginyeria de Sistemes i Serveis de Telecomunicacions i Enginyeria Biomèdica.

Introducció

9

1.3 ISE Design Suite de Xilinx

ISE Design Suite és l’entorn de disseny que permet dur un disseny a la programació de dispositiu de Xilinx. ISE (Integrated Synthesis Environment) és una eina de programari creada per a la síntesi i l’anàlisi de dissenys HDL que permet compilar els dissenys creats, realitzar anàlisis de temps, examinar diagrames RTL, simular la reacció del disseny a diferents estímuls i configurar el dispositiu de destí amb el programador. Aquest entorn de disseny és complementari als productes FPGA de Xilinx, amb l’arquitectura dels quals està ben connectat.

Amb aquest programa es durà a terme la implementació de la màquina senzilla en llenguatge VHDL i es gravarà a la FPGA de la placa BASYS 2 de DIGILENT.

1.4 Llenguatge VHDL

Aquest llenguatge definit per l’IEEE (Institut d’Enginyers Elèctrics i Electrònics) i utilitzat per a dissenyar circuits digitals és fruit de la combinació de VHSIC i HDL. VHSIC representa un circuit integrat de molt alta velocitat i HDL (Hardware Description

Language) és el llenguatge màquina que permet documentar les interconnexions i el comportament d’un circuit electrònic sense utilitzar diagrames esquemàtics.

Aquesta combinació resulta en un llenguatge, el procediment de disseny del qual consisteix en els següents passos:

- Construcció del diagrama de blocs del sistema. - Elaboració del codi VHDL per a cadascun dels mòduls necessaris. - Compilació del codi. El compilador analitza el codi, determina els errors de

sintaxi i comprova la compatibilitat entre mòduls, creant la informació necessària per a la simulació.

- Simulació, que estableix estímuls a cada mòdul i n’observa la resposta. - Verificació de que el circuit treballa com es desitja. - Síntesi, que converteix els codis en VHDL en components. - Ajust (fiting) dels components a la capacitat del dispositiu que es vol utilitzar. - Verificació temporal per evitar elements paràsits.

1.4.1 Estructura de Programa en VHDL

Per a crear un nou fitxer en el disseny el primer pas és crear l’entitat. Es comença per donar-li un nom i declarar les senyals (entrades i sortides) que ha de tenir, així com les dimensions d’aquestes.

A continuació es crea l’arquitectura del fitxer, on s’escriu el què es vol que el bloc que s’està creant realitzi. Abans, però, es fan les declaracions de tipus, senyals, constants, components, funcions i procediments necessaris.

Introducció

1.5 Concepte d’FPGA

Una FPGA (Field Programmable Gate Array

conté blocs lògics als que se’ls pot configurar al moprogramació especialitzat la interconnexió i funcionalitat.

Les FPGAs són reprogramables, tenen costos baixos de desenvolupament i adquisició en petites quantitats i el seu temps de desenvolupament també és baix. Altres avantatges de les FPGAs són el gran nombre d’elements lògics programables que tenen, les funcions d’alt nivell i els blocs de memòria que es poden trobar en la seva matriu d’interconnexions i la seva arquitectura, que es basa en un gran nombre de petits blorealitzen operacions lògiques senzilles i que tenen biestables síncrons. També disposen d’una gran flexibilitat deguda a la llibertat en la interconnexió dels blocs.flexibilitat també fa que les modificacions malicioses que hi pugui haver dfabricació siguin de menor risc.

Les FPGAs s’utilitzen en qualsevol àrea o algorisme que pugui fer ús de paral·lelisme. També s’utilitzen cada cop més en aplicacions d’alt rendiment convencionals on els nuclis computacionals són implprocessador d’ús general.

La FPGA que s’utilitzarà per dur a terme aquest projecte és la Spartan 3ECP132 que conté la placa Basys 2 de DIGILENT.

1.6 Placa BASYS 2

La placa Basys 2 és una plataforma de disseny i implementacióque qualsevol pot utilitzar per a adquirir experiència en la construcció de circuits digitals reals. Aquesta placa proporciona un maquinari complet i preparatque van des de dispositius lògics bàsics fins a conde dispositius i circuits inclosos que permeten crear una àmplia quantitat de dissenys sense la necessitat de components externs.

10

Field Programmable Gate Array) és un dispositiu semiconductor que conté blocs lògics als que se’ls pot configurar al moment i utilitzant un llenguatge de programació especialitzat la interconnexió i funcionalitat.

reprogramables, tenen costos baixos de desenvolupament i adquisició en petites quantitats i el seu temps de desenvolupament també és baix. Altres vantatges de les FPGAs són el gran nombre d’elements lògics programables que tenen, les

funcions d’alt nivell i els blocs de memòria que es poden trobar en la seva matriu d’interconnexions i la seva arquitectura, que es basa en un gran nombre de petits blorealitzen operacions lògiques senzilles i que tenen biestables síncrons. També disposen d’una gran flexibilitat deguda a la llibertat en la interconnexió dels blocs.flexibilitat també fa que les modificacions malicioses que hi pugui haver dfabricació siguin de menor risc.

Les FPGAs s’utilitzen en qualsevol àrea o algorisme que pugui fer ús de paral·lelisme. També s’utilitzen cada cop més en aplicacions d’alt rendiment convencionals on els nuclis computacionals són implementats en la FPGA i no en un

La FPGA que s’utilitzarà per dur a terme aquest projecte és la Spartan 3ECP132 que conté la placa Basys 2 de DIGILENT.

La placa Basys 2 és una plataforma de disseny i implementació que qualsevol pot utilitzar per a adquirir experiència en la construcció de circuits digitals reals. Aquesta placa proporciona un maquinari complet i preparat, adequat per a circuits que van des de dispositius lògics bàsics fins a controladors complexos. Té un gran nombre de dispositius i circuits inclosos que permeten crear una àmplia quantitat de dissenys sense la necessitat de components externs.

Figura 1. Placa Basys 2.

) és un dispositiu semiconductor que ment i utilitzant un llenguatge de

reprogramables, tenen costos baixos de desenvolupament i adquisició en petites quantitats i el seu temps de desenvolupament també és baix. Altres vantatges de les FPGAs són el gran nombre d’elements lògics programables que tenen, les

funcions d’alt nivell i els blocs de memòria que es poden trobar en la seva matriu d’interconnexions i la seva arquitectura, que es basa en un gran nombre de petits blocs que realitzen operacions lògiques senzilles i que tenen biestables síncrons. També disposen d’una gran flexibilitat deguda a la llibertat en la interconnexió dels blocs. Aquesta flexibilitat també fa que les modificacions malicioses que hi pugui haver durant la

Les FPGAs s’utilitzen en qualsevol àrea o algorisme que pugui fer ús d’un alt grau de paral·lelisme. També s’utilitzen cada cop més en aplicacions d’alt rendiment

ementats en la FPGA i no en un

La FPGA que s’utilitzarà per dur a terme aquest projecte és la Spartan 3E-100

de circuits senzilla que qualsevol pot utilitzar per a adquirir experiència en la construcció de circuits digitals

adequat per a circuits troladors complexos. Té un gran nombre

de dispositius i circuits inclosos que permeten crear una àmplia quantitat de dissenys sense

Introducció

11

Està construïda al voltant de la FPGA Spartan 3E-100 CP132 i d’un controlador Atmel AT90USB2. I a més a més conté els següents elements:

- Plataforma Xilinx Flash ROM per emmagatzemar configuracions FPGA. - 8 LEDs. - 4 displays de 7 segments. - 4 polsadors. - 8 conmutadors. - Port PS/2 i port VGA. - Rellotge configurable per l’usuari (25/50/100 MHz). - 4 connectors d’expansió de capçalera de 6 pins. - Protecció ESD i de curtcircuit en totes les entrades i sortides de senyal.

Figura 2. Diagrama de blocs de la placa Basys 2.

Per al projecte de l’equip didàctic per a la màquina senzilla s’utilitzaran alguns elements de la placa per a realitzar les proves de funcionament prèvies a la creació de l’entrenador, que quan aquest funcioni no seran visibles a la placa sinó a l’entrenador; són els LEDs, els polsadors i els commutadors.

L’entrada de rellotge a 50 MHz que proporciona la placa és la que s’utilitzarà per a la màquina senzilla, tot i que la seva freqüència es farà menor amb blocs divisors.

Introducció

12

1.7 Registre de Desplaçament

Un registre de desplaçament és un circuït digital seqüencial que consisteix en un conjunt de biestables -generalment de tipus D- en cascada, que comparteixen la mateixa senyal de rellotge i que s’encadenen per a desplaçar les dades, depenent de com siguin les connexions entre els biestables es desplaçaran cap a la dreta o cap a l’esquerra.

Hi ha quatre tipus de registres de desplaçament segons el tipus d’entrades i sortides que tinguin. Són els següents:

SISO: Registre de desplaçament d’entrada sèrie i sortida sèrie. Només són accessibles externament l’entrada del primer flip-flop i la sortida de l’últim. S’utilitzen principalment com a línies de retard digitals i en tasques de sincronització.

Figura 3. Registre de desplaçament SISO de 4 bits.

SIPO: Registre de desplaçament d’entrada sèrie i sortida paral·lel. És molt semblant a l’anterior tipus però amb la diferència que en aquest cas cada biestable té una sortida cap a l’exterior, permetent obtenir totes les dades alhora i també una sortida sèrie des de qualsevol biestable. S’utilitza per a convertir dades en sèrie a paral·lel.

Figura 4. Registre de desplaçament SIPO de 4 bits.

Introducció

13

PISO: Registre de desplaçament d’entrada paral· lel i sortida sèrie. En aquest cas totes les entrades de cadascun dels flip-flops són accessibles però només es mostra una sortida en sèrie, per tant, s’utilitza per a convertir dades en paral·lel a sèrie.

Figura 5. Registre de desplaçament PISO de 4 bits.

PIPO: Registre de desplaçament d’entrada paral·lel i sortida paral·lel. Degut a tenir aquest tipus d’entrada i sortida es pot utilitzar també com qualssevol dels tres tipus de registres de desplaçament anteriors. Es sol utilitzar per a realitzar càlculs aritmètics.

Figura 6. Registre de desplaçament PIPO de 4 bits.

Conceptes Teòrics

14

2 Conceptes Teòrics

2.1 La Màquina Senzilla

Una màquina senzilla és un computador. Aquest, pot resoldre problemes executant un programa de manera seqüencial amb instruccions que descriuen com executar una tasca determinada.

L’estructura bàsica a nivell físic d’un computador segueix el model de von Neumann, descrita el 1945 pel matemàtic i físic John von Neumann i altres, quan es va crear una estructura de disseny per un computador digital electrònic format per les següents parts: una unitat de processament que contenia una unitat aritmeticològica i registres del processador, una unitat de control que contenia un registre d’instruccions i un comptador de programa, una memòria que emmagatzemava dades i instruccions, emmagatzematge massiu extern i mecanismes d’entrada i sortida.

El concepte de computador ha evolucionat en les últimes dècades i actualment parlem d’un computador les parts del qual són una unitat central de procés (CPU), una memòria, una unitat d’entrada/sortida i busos.

Figura 7. Estructura bàsica d’un computador.

Conceptes Teòrics

15

2.1.1 Unitat Central de Procés (CPU)

La unitat central de procés s’encarrega d’executar els programes emmagatzemats a la memòria i es divideix en dues parts, la unitat de procés i la unitat de control.

Unitat de procés (UP): S’encarrega de realitzar operacions sobre les dades i consta de dues parts, la unitat aritmeticològica (ALU) que realitza operacions aritmètiques i lògiques; i els registres.

- Registres generals: Memòria d’alta velocitat utilitzada per emmagatzemar resultats entremitjos.

- Registres específics: Tenen funcions especials i són el comptador de programa (PC) que conté la direcció de la paraula en memòria on es troba la següent instrucció a executar, el registre d’instruccions (RI) que conté el codi de la instrucció a executar i el registre d’estat (SR) que memoritza en els seus bits algunes situacions específiques com el zero o el carry.

Unitat de control (UC): S’encarrega de governar la resta del computador i decideix quines operacions han de realitzar la unitat de procés i la resta de blocs del computador per a cada instrucció del programa.

2.1.2 Memòria

És la part del computador que s’encarrega d’emmagatzemar les instruccions d’un programa i les seves dades relacionades quan s’executen. Els dos tipus de memòria són els següents:

RAM: Memòria d’accés aleatori que s’encarrega d’emmagatzemar dades de programa i d’usuari.

ROM: Memòria només de lectura que s’encarrega d’emmagatzemar dades i programes propis del computador.

2.1.3 Unitat d’Entrada i Sortida

És la part del computador que s’encarrega d’establir les connexions necessàries amb l’exterior. Per exemple teclat, pantalla o discs.

2.1.4 Busos

Els busos són les vies de comunicació que té un computador entre els seus blocs. Té busos de dades, d’adreces i de control.

Bus de dades: A través del bus de dades es fa la transferència de dades i d’instruccions des de la memòria cap a la CPU amb el procés anomenat lectura. També fa la transferència de dades i d’instruccions des de la CPU cap a la memòria amb el procés anomenat escriptura. És un bus bidireccional.

Conceptes Teòrics

16

Bus d’adreces: A través del bus d’adreces la CPU envia les adreces de memòria on es troben les instruccions que s’han de llegir o les adreces de memòria o perifèrics on s’han de llegir o escriure les dades. És un bus unidireccional.

Bus de control: A través del bus de control es transmeten senyals de control com lectura, escriptura o rellotge. És un bus bidireccional.

2.2 El Microcontrolador PIC16F877

Els microcontroladors de PIC, fabricats per Microchip Technology es referien inicialment als microcontroladors de connexió perifèrics (Peripheral Interface Controller), però més tard es van passar a anomenar Programable Intelligent Computer.

El model de PIC en el que s’han inspirat algunes parts d’aquest projecte és el PIC16F877, les característiques del qual són les següents:

- Freqüència d’operació: DC – 20 MHz - RESETS (i Delays): POR, BOR, (PWRT, OST) - Memòria FLASH de programa (paraules de 14 bits): 8K - Memòria de dades: 368 Bytes - Memòria de dades EEPROM: 256 Bytes - Ports I/O: Ports A, B, C, D, E - Temporitzadors: 3 - Mòduls Capture/Compare/PWM: 2 - Comunicacions sèrie: MSSP, USART - Comunicacions paral·lel: PSP - Mòdul de 10 bits Analog-to-Digital: 8 canals d’entrada - Joc d’instruccions: 35 instruccions

Figura 8. PIC16F877.

Conceptes Teòrics

17

L’arquitectura del PIC16F877 consta de:

- Bus de dades de 8 bits - Màquina RISC - Memòria de programa diferent de la de dades - 3 Modes de direccionament: Immediat (valor dins la instrucció, -literal-),

Directe (7 bits d’adreça dins de la instrucció) i Indirecte (FSR, File Select

Register) - Registre acumulador - ALU + registre d’estats (STATUS) amb 3 banderes: Zero, Carry i Digital

Carry - 1 cicle per instrucció (2 per a les instruccions de salt) - Freqüència de 20 MHz

2.2.1 Format i Repertori d’Instruccions

Figura 9. Joc d’instruccions del PIC16F877.

Conceptes Teòrics

18

2.3 Tria de les Instruccions de la Màquina Senzilla

A partir del joc d’instruccions bàsiques de la màquina senzilla explicada a classe, que consta de les instruccions ADD, MOV, CMP i BEQ, i del joc d’instruccions del PIC16F877 s’ha desenvolupat un joc d’instruccions amb l’objectiu de ser més proper al PIC16F877, que té la característica d’un acumulador al mig. El joc consta de 9 instruccions que fan possible la codificació a baix nivell de dos programes senzills que realitzen dues operacions simples: una multiplicació i un sumatori; i que fan possible als alumnes seguir els passos interns del microprocessador en l’entrenador per al laboratori. Són les següents:

CLRF F: Posa a zero els 8 bits de l’adreça de memòria F.

INCF F: Suma 1 al valor de l’adreça de memòria F i el resultat es guarda a l’acumulador W.

MOVF F: Guarda el valor de l’adreça de memòria F a l’acumulador W.

MOVWF F: Guarda el valor de l’acumulador W a l’adreça de memòria F.

ADDWF F: Suma el valor de l’adreça de memòria F a l’acumulador W i el total es guarda en aquest.

XORWF F: Fa una OR exclusiva (XOR) entre el valor que hi ha a l’adreça de memòria F i el de l’acumulador W, i guarda el resultat a l’acumulador W. El resultat de la XOR és 1 quan els dos valors són diferents i és 0 quan són iguals. En aquest últim cas, el flag de zero es posa a 1.

CMPWF F: Fa una comparació dels valors que hi ha a l’adreça de memòria F i a l’acumulador W, i si tenen el mateix valor el flag de zero es posa a 1.

BZ D: Si el flag de zero està a 1, salta a l’adreça de memòria D. En canvi, si el flag de zero està a 0 es continua amb la següent instrucció del programa.

GOTO D: Salta a l’adreça de memòria D.

El codi d’operació de cada instrucció és de 4 bits, però realment, les instruccions són de 8 bits (en omplir la memòria s’ha tingut en compte).

CO3 CO2 CO1 CO0 OPERACIÓ 0 0 0 0 CLRF 0 0 0 1 INCF 0 0 1 0 MOVF 0 0 1 1 MOVWF 0 1 0 0 ADDWF 0 1 0 1 XORWF 0 1 1 0 CMPWF 0 1 1 1 BZ 1 0 0 0 GOTO

Figura 10. Joc d’instruccions codificades amb 4 bits.

Conceptes Teòrics

19

2.3.1 Primer Programa Dissenyat amb el Joc d’Instruccions

El primer programa realitza la multiplicació de dos nombres anomenats a i b, que es guarda en c.

begin

c := 0;

i := 0;

while (i<b) do

begin

c := c + a;

i := i + 1;

end

end

Codi 1. Algorisme d’alt nivell del primer programa.

begin CLRF c

CLRF i

bucle MOVF i

XORWF b

BZ end

MOVF c

ADDWF a

MOVWF c

INCF i

MOVWF i

XORWF i

BZ bucle

end

Codi 2. Algorisme de baix nivell del primer programa.

2.3.2 Segon Programa Dissenyat amb el Joc d’Instruccions

El segon programa fa un sumatori de l’1 al 9, el resultat del qual es guarda en s.

begin

i := 0;

s := 0;

for(i=1; i<10; i++) do

s := s + i;

end

end

Codi 3. Algorisme d’alt nivell del segon programa.

begin CLRF s

CLRF i

INCF i

MOVWF i

bucle CMPWF a

BZ end

ADDWF s

MOVWF s

INCF i

MOVWF i

GOTO bucle

end

Codi 4. Algorisme de baix nivell del segon programa.

Disseny de la Màquina Senzilla per a l’Entrenador Didàctic

20

3 Disseny de la Màquina Senzilla per a l’Entrenador Didàctic

L’entrenador didàctic que s’ha dissenyat per a ser utilitzat en els laboratoris de l’assignatura Fonaments de computadors té la funció de mostrar amb leds els continguts dels registres de la màquina senzilla, el bus d’adreces d’entrada a la memòria, els bits del bus de control de sortida de la unitat de control, i el valor de la unitat aritmeticològica.

Per a fer-ho possible, s’ha decidit crear una màquina senzilla amb tres grans blocs diferenciats que són la unitat de procés (UP), la unitat de control (UC) i la memòria. A banda, s’ha incorporat un bloc temporitzador per a facilitar la visualització didàctica als laboratoris del funcionament del microprocessador.

Figura 11. Estructura general de la màquina senzilla.


21

3.1 Disseny de la Unitat de Procés

La unitat de procés dissenyada s’ha dividit en dos grans parts, la unitat aritmeticològica (ALU) i els registres interns. Els registres que s’han necessitat per a completar la unitat de procés són el registre d’instruccions, el registre comptador de programa, el registre d’adreces, el registre acumulador i el registre del flag zero. A banda, per a completar la unitat de procés s’ha dissenyat un multiplexor entre el comptador de programa i el registre d’adreces.

Figura 12. Diagrama de blocs de la unitat de procés amb senyals de control i la memòria.

3.1.1 Unitat Aritmeticològica (ALU)

L’ALU s’ha dissenyat com un multiplexor de 6 a 1 controlat per tres senyals. Les entrades a l’ALU són l’acumulador W(7:0), la sortida de la memòria A(7:0) i el codi d’instrucció ALU(2:0), que és de 3 bits perquè indica 6 instruccions diferents a realitzar per la unitat aritmeticològica. Les dues instruccions restants també donen com a resultat els 8 bits a 0 per evitar errors, tot i que no s’utilitzen. Això és a causa de que de les 9 instruccions que formen el joc d’instruccions d’aquesta màquina, algunes necessiten la mateixa funció de l’ALU i s’han pogut reduir a 6. A continuació s’expliquen.

CLRF: No necessita operand.

MOVF: Necessita l’ALU transparent.

XORWF: Necessita una porta XOR (OR exclusiva).

BZ: És un salt, no utilitza l’ALU.


22

ADDWF: Necessita un sumador.

MOVWF: Necessita l’ALU transparent.

INCF: Necessita un sumador.

CMPWF: Necessita una porta XOR (OR exclusiva).

GOTO: És un salt, no utilitza l’ALU.

ALU2 ALU1 ALU0 INSTRUCCIÓ 0 0 0 W + A 0 0 1 A xor W 0 1 0 A + 1 0 1 1 W 1 0 0 A 1 0 1 00000000 1 1 0 00000000 1 1 1 00000000

Figura 13. Taula d’instruccions realitzades per l’ALU.

Figura 14. Disseny de la unitat aritmeticològica.


23

3.1.2 Registre d’Instruccions (RI)

Registre de 8 bits que s’ha dissenyat perquè a partir de la sortida de la memòria, que és una de les seves entrades, enviï a la unitat de control els bits corresponents al codi d’operació CO(3:0), que indica quina de les 9 operacions s’ha d’executar. Aquest registre té una altra entrada de control RIc provinent de la unitat de control, a banda de les entrades clk i reset.

3.1.3 Registre Comptador de Programa (PC)

Registre de 8 bits que guarda l’adreça de la següent instrucció que s’executarà. Aquesta adreça la rep com a entrada, des de la sortida del multiplexor del mateix registre amb el registre d’adreces. Les instruccions s’emmagatzemen de manera seqüencial en memòria i cadascuna ocupa una posició; per aquest motiu, el PC incrementa en 1 el seu contingut cada vegada que s’executa una instrucció. S’ha dissenyat també amb una entrada de control PCc provinent de la unitat de control, una entrada clk i un reset.

3.1.4 Registre d’Adreces (RA)

Registre de 8 bits que indica a la memòria en quina adreça ha de treballar. El valor que rep d’entrada és la sortida de 8 bits de la memòria, i la seva sortida de 8 bits va al multiplexor entre aquest registre i el registre comptador de programa. També s’ha dissenyat amb una entrada de control RAc provinent de la unitat de control, una entrada clk i un reset.

3.1.5 Multiplexor entre el RA i el PC

Multiplexor de 8 bits que envia l’adreça corresponent a la memòria provinent del registre d’adreces o del comptador de programa. S’ha dissenyat també amb una entrada de control MXc provinent de la unitat de control. La sortida d’aquest multiplexor és el contingut del comptador de programa quan l’entrada MXc és 0; i és el contingut del registre d’adreces quan l’entrada MXc és 1.

Figura 15. Disseny del multiplexor entre el RA i el PC.


24

3.1.6 Registre Acumulador (W)

Registre de 8 bits que emmagatzema temporalment el valor de la sortida de l’ALU i envia el valor a l’entrada W d’aquesta. També s’ha dissenyat amb una entrada de control Wc provinent de la unitat de control, una entrada clk i una entrada reset.

3.1.7 Registre del Flag Zero (FZ)

S’ha dissenyat un registre d’1 bit que s’activa quan la seva entrada Din té un valor de 8 bits a zero -ja que això significa que la sortida de l’ALU és zero- i que és necessari per indicar a la unitat de control que el flag zero està activat, dada que s’utilitza per a les instruccions de salt BZ i GOTO. Disposa d’una entrada de control FZc provinent de la unitat de control, d’una entrada clk i d’una entrada reset.


25

3.2 Disseny de la Unitat de Control

La unitat de control s’ha dissenyat per a controlar la lògica de la unitat de procés. Els senyals que habiliten la unitat de procés de la màquina senzilla arriben des de la unitat de control. Per al disseny de la màquina senzilla s’ha escollit una unitat de control cablejada, que consisteix en un sistema seqüencial definit per un graf d’estats associats a les diferents fases d’execució de les instruccions.

Les entrades de la unitat de control són els 4 bits del codi d’operació provinent del registre d’instruccions, el bit del flag de zero, el de reset i el del senyal de rellotge (provinent del bloc de temporització que s’explica al punt 3.4). Les 10 sortides de la unitat de control corresponen als bits d’habilitació de cadascun dels registres de la unitat de procés (MUXc, PCc, RIc, RAc, Wc i FZc), als 3 bits de selecció de l’ALU i a l’habilitació de lectura de la memòria (L/E).

Figura 16. Disseny de la unitat de control cablejada.

La unitat de control s’ha dissenyat amb un diagrama d’estats que en primer lloc ha estat de 12 estats però s’ha acabat simplificant amb 10 estats, que duu a terme l’execució de cadascuna de les instruccions de la màquina senzilla.


26

3.2.1 Estats i Fases d’Execució de les Instruccions

Totes les instruccions que s’han decidit per a formar part del joc d’instruccions de la màquina senzilla tenen en comú les tres primeres fases; que són Fetch1, Fetch2 i Decode (descodificació). La següent fase, depenent de la instrucció és Execute (execució), retorn al Fetch1 -en el cas de la instrucció GOTO- o consulta del FZ i retorn al Fetch1 -en el cas de BZ-. Es detallen seguidament les fases d’execució de cada instrucció de la màquina senzilla.

CLRF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S5 Execute F ⇐ 0 FZ ⇐ Z

INCF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S7 Execute W ⇐ (RA) + 1 FZ ⇐ Z

MOVF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S8 Execute W ⇐ (RA) FZ ⇐ Z

MOVWF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S9 Execute F ⇐ W FZ ⇐ Z

ADDWF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S3 Execute W ⇐ (RA) + W FZ ⇐ Z


27

XORWF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S6 Execute W ⇐ (RA) xor W FZ ⇐ Z

CMPWF

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S4 Execute FZ ⇐ Z

BZ

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S10 Consulta FZ S11 Fetch1 IR ⇐ (RA) PC ⇐ (RA) + 1

GOTO

S0 Fetch1 IR ⇐ (PC) PC = PC + 1 S1 Fetch2 RA ⇐ (PC) PC = PC + 1 S2 Decode Avaluar CO0, CO1, CO2 i CO3 S11 Fetch1 IR ⇐ (RA) PC ⇐ (RA) + 1

El graf d’estats resultant per a la unitat de control -sense simplificacions- és un graf de 12 estats que permet diferenciar les 9 instruccions corresponents al joc d’instruccions de la màquina senzilla.

Les transicions entre els estats d’aquest graf es controlen amb els senyals d’entrada de la unitat de control CO0, CO1, CO2, CO3 i FZ.


28

Figura 17. Graf d’estats de la unitat de control.

estat CO0 CO1 CO2 CO3 FZ

0/S0

8/S8

7/S7 2/S2

4/S4

3/S3

5/S5

6/S6

1/S1

9/S9

11/S11 10/S10

XXXXX

10000

XXXXX

0100X

0110X

XXXXX

XXXXX

0101X

XXXXX

XXXXX

0000X

0010X

0001X

0011X

XXXXX

XXXXX

XXXXX

0111X

10001

XXXX1

XXXX0

XXXXX

ADDWF

INCF

MOVF

XORWF

CLRF

CMPWF

MOVWF

BZ/GOTO


29

Els valors binaris de sortida de cada senyal de la unitat de control en cadascun dels estats definits es mostren a continuació.

S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 S10 S11

MUXC 0 0 X 1 1 1 1 1 1 1 X 1 ALU2 X X X 0 0 1 0 0 1 0 X X ALU1 X X X 0 0 0 0 1 0 1 X X ALU0 X X X 0 1 1 1 0 0 1 X X

LE 0 0 0 0 0 1 0 0 0 1 0 0 PCC 1 1 0 0 0 0 0 0 0 0 0 1 RIC 1 0 0 0 0 0 0 0 0 0 0 1 RAC 0 1 0 0 0 0 0 0 0 0 0 0 WC X X 0 1 0 0 1 1 1 0 0 0 FZC 0 0 0 1 1 1 1 1 1 1 0 0

Figura 18. Taula de valors de sortida de la UC segons l’estat.

3.2.2 Simplificació del Graf d’Estats

Després de realitzar el graf d’estats anterior s’han aplicat algunes condicions que han permès simplificar-lo i dissenyar el graf d’estats definitiu de 10 estats de la unitat de control.

La primera simplificació del graf s’ha realitzant aplicant la condició següent: el segon fetch i la descodificació es poden unir en un únic estat. Aquest nou estat s’ha anomenat S12, ja que consisteix en la unió dels estats S1 i S2.

La segona simplificació s’ha aconseguit en eliminar l’estat S10, ja que s’ha considerat que la funció que realitza de consultar el registre FZ es pot fer en el nou estat S12 que ha aparegut amb la simplificació anterior.

L’estat nou S12 té els valors de sortida de tots els senyals de la unitat de control iguals que els de l’estat que s’ha tingut anteriorment anomenat S1. Per tant, els valors binaris de sortida de cada senyal de la unitat de control en cadascun dels estats definits en la simplificació del graf d’estats són els següents:

S0 S3 S4 S5 S6 S7 S8 S9 S11 S12

MUXC 0 1 1 1 1 1 1 1 1 0 ALU2 X 0 0 1 0 0 1 0 X X ALU1 X 0 0 0 0 1 0 1 X X ALU0 X 0 1 1 1 0 0 1 X X

LE 0 0 0 1 0 0 0 1 0 0 PCC 1 0 0 0 0 0 0 0 1 1 RIC 1 0 0 0 0 0 0 0 1 0 RAC 0 0 0 0 0 0 0 0 0 1 WC X 1 0 0 1 1 1 0 0 X FZC 0 1 1 1 1 1 1 1 0 0

Figura 19. Taula de valors de sortida de la UC segons l’estat per al graf simplificat.


30

Figura 20. Graf d’estats de la unitat de control simplificat.

CO0 CO1 CO2 CO3 FZ estat 3/S3

4/S4

5/S5

6/S6

7/S7

8/S8

9/S9

11/S11

12/S12 0/S0 XXXXX

0110X

0000X

0101X

0001X

0010X

0011X

01111 1000X

XXXXX

XXXXX

XXXXX

01110

XXXXX

XXXXX 0100X

XXXXX

XXXXX

XXXXX

ADDWF

INCF

MOVF

XORWF

CLRF

CMPWF

MOVWF

BZ/GOTO


31

3.3 Disseny de la Memòria

Per a la màquina senzilla s’ha decidit utilitzar una memòria síncrona d’accés aleatori (RAM) de 256 posicions. La memòria ha de contenir el programa que es vol executar amb la màquina senzilla, i s’ha dissenyat amb una entrada de lectura/escriptura L/E, una entrada d’adreça @ i una entrada i una sortida de dades (Ent i Sor respectivament), com es pot veure en la figura següent:

Figura 21. Estructura de la memòria.

3.3.1 Programes Escrits en Memòria

Tenint en compte que la memòria és de 256 posicions, s’han escrit els dos programes dissenyats a les adreces corresponents de memòria, tenint en compte que són programes senzills que no han necessitat omplir tota la capacitat de la memòria. Per aquest motiu els programes s’han emmagatzemat a partir de l’adreça @0 i les dades a partir de l’adreça @64.

(begin) @0 CLRF c @64 c

@1 CLRF i @65 a

(bucle) @2 MOVF i @66 b

@3 XORWF b @67 i

@4 BZ end

@5 MOVF c

@6 ADDWF a .

@7 MOVWF c .

@8 INCF i .

@9 MOVWF i

@10 XORWF i

@11 BZ bucle

(end) @12 @255

Codi 5. Primer programa en memòria.

(begin) @0 CLRF s @64 s

@1 CLRF i @65 i

@2 INCF i @66 a

@3 MOVWF i

(bucle) @4 CMPWF a

@5 BZ end .

@6 ADDWF s .

@7 MOVWF s .

@8 INCF i

@9 MOVWF i

@10 GOTO bucle

(end) @11 @255

Codi 6. Segon programa en memòria.


32

3.4 Disseny de la Temporització

Per a aconseguir que tota la màquina senzilla funcioni correctament s’ha vist la necessitat de fer el disseny d’un mòdul de temporització, que ha permès no només sincronitzar tots els blocs del computador i evitar rebots, sinó que ha resolt la necessitat de controlar l’execució dels programes pas a pas i de manera externa per a estudiar el funcionament a nivell de cicle de rellotge del microcontrolador dissenyat.

Per a fer més didàctic l’entrenador s’ha decidit permetre a l’usuari activar i aturar el senyal de rellotge de la manera que es vulgui amb els següents polsadors:

- Polsador que permet enviar només un impuls de rellotge per a veure pas a pas l’execució del programa en memòria.

- Polsador que permet executar una instrucció del programa sencera, amb els impulsos de rellotge necessaris per a fer-ho.

- Polsador que fa un reset per a tornar a començar l’execució del programa quan es vulgui.

L’entrada de rellotge que arriba externament des de la placa és de 50 MHz i primer és dividida per a aconseguir dues freqüències de rellotge diferents: 1 kHz i 50 Hz, que han sigut necessàries per a diferents elements del disseny general de la màquina senzilla.

El bloc de temporització principal, anomenat rellotge, s’ha dissenyat com un graf d’estats que fa que la màquina senzilla funcioni amb els senyals que s’envien a través dels polsadors. Aquest bloc també serveix per evitar rebots i contactes falsos provocats pels polsadors.

A banda de disposar de la sortida que fa de rellotge per al sistema, al bloc temporitzador se li ha afegit una altra sortida que dona l’ordre de passar tots els bits que es representen amb leds a l’entrenador des de la FPGA i els actualitza. Aquesta senyal és fonamental per al registre de desplaçament, que s’explica a continuació.

Figura 22. Disseny de la temporització.

Implementació de la Màquina Senzilla de 8 bits amb Xilinx ISE

33

4 Implementació de la Màquina Senzilla de 8 bits amb Xilinx ISE

Després d’haver realitzat el disseny de tots els elements necessaris per a fer eficient i didàctic l’entrenador, s’ha procedit a desenvolupar els codis necessaris per a fer-lo possible i a implementar tots els blocs de la màquina senzilla amb el programa Xilinx ISE.

4.1 Implementació de la Unitat de Procés

La unitat de procés s’ha creat amb Xilinx com un bloc format per les connexions dels blocs que la formen i que es detallen seguidament.

Figura 23. Símbol de la unitat de procés en Xilinx.

Les entrades i sortides que s’han donat a la unitat de procés són:

clk: Senyal de rellotge general del sistema provinent del bloc de temporització.

reset: Reset general del sistema.

PCc: Entrada d’1 bit de control del registre comptador de programa.

MXc: Entrada d’1 bit de control del multiplexor.

RAc: Entrada d’1 bit de control del registre d’adreces.

RIc: Entrada d’1 bit de control del registre d’instruccions.


34

Wc: Entrada d’1 bit de control del registre acumulador.

FZc: Entrada d’1 bit de control del registre del flag zero.

sortMEM [7:0]: Bus de dades d’entrada provinent de la memòria.

ALU [2:0]: Codi d’operació de la unitat aritmeticològica provinent de la unitat de control.

FZ: Sortida d’1 bit que va cap a la unitat de control i li indica si el flag de zero està activat o no.

adrMEM [7:0]: Bus de dades de sortida que indica a la memòria amb quina adreça ha de treballar.

CO [3:0]: Bus de dades de sortida que indica a la unitat de control quin és el codi d’operació que ha d’utilitzar.

entMEM [7:0]: Bus de dades de sortida que indica a la memòria el valor de sortida de la unitat aritmeticològica.

Per a obtenir el símbol de la unitat de procés, primer s’han implementat cadascun dels blocs que la formen, que són la unitat aritmeticològica (ALunit) i els registres interns, concretament el registre d’instruccions (RegistreInstruccions), el registre comptador de programa (ProgramCounter), el registre d’adreces (RegistreAdreces), un multiplexor entre aquests dos últims (MX), el registre acumulador i el registre del flag zero (FlagZero).

A continuació es mostren i s’expliquen les implementacions de tots els blocs de la unitat de procés i les seves corresponents connexions. El funcionament detallat de cadascun d’aquests blocs es troba al capítol 3.

Figura 24. Esquemàtic intern de la unitat de procés.


35

4.1.1 Unitat Aritmeticològica (ALU)

L’ALU s’ha implementat amb Xilinx amb les següents entrades i sortides:

W [7:0]: Bus de dades d’entrada provinent de l’acumulador.

A [7:0]: Bus de dades d’entrada provinent de la memòria.

ALU [2:0]: Codi d’instrucció de 3 bits que indica quina s’ha de realitzar de les del joc d’instruccions creat.

sortida [7:0]: Sortida de 8 bits que porta el resultat de l’ALU cap a la memòria.

Figura 25. Símbol de la unitat aritmeticològica.

4.1.2 Registre d’Instruccions (RI)

Aquest registre de 8 bits s’ha implementat amb Xilinx amb les entrades i sortides que es detallen a continuació:

RIc: Bit de control del registre que s’envia des de la unitat de control.

Din [7:0]: Bus de dades d’entrada.

clk: Senyal de rellotge general del sistema.

reset: Reset general del sistema que posa el valor de tots els bits del registre a zero quan s’activa.

RI [3:0]: Sortida de 4 bits del registre que porta el codi d’operació a la unitat de control.

Figura 26. Símbol del registre d’instruccions.


36

4.1.3 Registre Comptador de Programa (PC)

Registre de 8 bits que s’ha implementat amb les entrades i sortides següents:

PCc: Bit de control del registre que s’envia des de la unitat de control.


clk: Senyal de rellotge general del sistema.


PC [7:0]: Sortida de 8 bits del registre que anirà al multiplexor entre aquest registre comptador de programa i el registre d’adreces.

Figura 27. Símbol del registre comptador de programa.

4.1.4 Registre d’Adreces (RA)

Registre de 8 bits que indica a la memòria en quina adreça ha de treballar. Les entrades i sortides d’aquest registre es detallen a continuació:

RAc: Bit de control del registre que s’envia des de la unitat de control.

Din [7:0]: Bus de dades d’entrada que correspon a la sortida de la memòria.

clk: Rellotge del sistema.


RA [7:0]: Sortida de 8 bits del registre que anirà al multiplexor entre aquest registre d’adreces i el registre comptador de programa.

Figura 28. Símbol del registre d’adreces.


37

4.1.5 Multiplexor entre el RA i el PC

Les entrades i sortides d’aquest multiplexor es detallen a continuació:

PC [7:0]: Entrada de 8 bits corresponent a la sortida del registre comptador de programa.

RA [7:0]: Entrada de 8 bits corresponent a la sortida del registre d’adreces.

MUXc: Bit de control del registre que s’envia des de la unitat de control.

MUX [7:0]: Sortida de 8 bits del multiplexor que va cap a l’entrada d’adreça de la memòria i cap al registre comptador de programa. La taula d’adreces que s’ha utilitzat en implementar-lo es mostra a continuació.

MUXc @ 0 PC 1 RA

Figura 29. Taula d’adreces segons el valor d’entrada del multiplexor.

Figura 30. Símbol del multiplexor entre el RA i el PC.

4.1.6 Registre Acumulador (W)

Les entrades i sortides que s’han implementat en l’acumulador són les següents:

Wc: Bit de control del registre que s’envia des de la unitat de control.




W [7:0]: Sortida de 8 bits del registre que va a la unitat aritmeticològica.

Figura 31. Símbol del registre acumulador.


38

4.1.7 Registre del Flag Zero (FZ)

Aquest registre s’ha implementat amb les entrades i sortides que es detallen a continuació:

FZc: Bit de control del registre que s’envia des de la unitat de control.

Din [7:0]: Bus de dades d’entrada provinent de l’ALU.



FZ: Sortida d’1 bit del registre que indica a la unitat de control si el flag zero està activat o no.

Figura 32. Símbol de registre del flag zero.


39

4.2 Implementació de la Unitat de Control

A partir del disseny de la unitat de control realitzat -explicat en el capítol 3.2-, s’ha procedit a implementar amb Xilinx aquest bloc de la màquina senzilla.

Figura 33. Símbol de la unitat de control en Xilinx.

Les entrades i sortides que s’han donat a la unitat de control són:

FZ: Entrada d’1 bit que arriba des de la unitat de procés i indica a la unitat de control si el flag de zero està activat o no.

clk: Senyal de rellotge general del sistema provinent del bloc de temporització.


RI [3:0]: Bus de dades d’entrada, provinent de la unitat de procés, que indica a la unitat de control quin és el codi d’operació que s’ha d’utilitzar.

MUXc: Sortida d’1 bit per a controlar el multiplexor entre el PC i el RA de la UP.

LE: Sortida d’1 bit que envia a la memòria l’habilitació de lectura.

PCc: Sortida d’1 bit per al control del registre comptador de programa de la UP.

RIc: Sortida d’1 bit per al control del registre d’instruccions de la UP.

RAc: Sortida d’1 bit per al control del registre d’adreces de la UP.

Wc: Sortida d’1 bit per al control del registre acumulador de la UP.

FZc: Sortida d’1 bit per al control del registre del flag zero de la UP.

ALU [2:0]: Bus de dades de 3 bits de sortida que indica el codi d’instrucció per a la unitat aritmeticològica, que es troba a la unitat de procés, segons l’estat de la UC en el que es troba l’execució del programa.


40

4.3 Implementació de la Memòria

En l’elecció de la memòria per a la màquina senzilla dissenyada amb Xilinx ISE Design Suite, primer s’han avaluat les memòries que el programa té disponibles per decidir quina és la més adient, i la memòria que s’ha escollit és la RAMB16_S9, una memòria d’accés aleatori amb habilitació d’escriptura, síncrona, de 16384 bits de dades (2048 bits per 8 bits d’ample) que addicionalment té 2048 bits per 1 bit d’ample de paritat. El seu bus d’adreces és d’11 bits, el bus de dades és de 8 bits i el bus de paritat d’1 bit.

Figura 34. Memòria RAMB16_S9.

Les entrades i sortides de la memòria escollida es detallen a continuació:

WE: Entrada d’habilitació d’escriptura.

EN: Entrada d’habilitació que s’ha connectat a VCC perquè la memòria sempre estigui en funcionament.

SSR: Entrada de set/reset síncrona per a la memòria que s’ha connectat al reset general de la màquina senzilla.

CLK: Entrada del senyal de rellotge que s’ha connectat al senyal de rellotge general de la màquina senzilla provinent del bloc de temporització. Davant d’aquesta entrada s’ha afegit un inversor per a sincronitzar la memòria amb la resta de la màquina senzilla, ja que la memòria és síncrona i si no es feia amb aquest mètode, els seus valors de sortida no anaven sincronitzats amb la resta de valors mostrats de la màquina senzilla.

ADDR [10:0]: Entrada d’adreça d’11 bits. Només s’han necessitat els 8 bits de menys pes d’aquesta entrada, que s’han connectat a una sortida de la unitat de procés que multiplexa el comptador de programa i el registre d’adreces. Els 3 bits de més pes s’han connectat a massa perquè sempre tinguin valor 0. La separació dels bits del bus d’adreces s’ha fet amb bus taps -es detalla en l’apartat 4.4-.

DI [7:0]: Entrada de dades de 8 bits que arriben des la unitat de procés.

DIP [0:0]: Entrada del bit de paritat. No és necessària i s’ha connectat a VCC.

DOP [0:0]: Sortida del bit de paritat. No es necessita i s’ha deixat a l’aire.

DO [7:0]: Sortida de dades de 8 bits, que s’ha connectat a la unitat de procés.


41

4.3.1 Col·locació dels Valors Inicials a la Memòria

Tot i que l’estructura d’aquesta memòria permet utilitzar més bytes, només s’han utilitzat els dels atributs INIT_00 a INIT_07, perquè només tenim disponibles els 8 bits de menys pes del bus d’adreces; els 3 bits de més pes del bus d’adreces s’han connectat a massa com s’ha explicat anteriorment.

Cadascun d’aquests atributs està format per 32 posicions on es guarden dades hexadecimals; de la posició 00 -la primera a la dreta- fins a la posició 1F, la de més a l’esquerra de cada atribut. Les posicions de cada atribut també s’han omplert amb valors hexadecimals, ja que així ho requereix la memòria.

Per a col·locar els valors inicials del primer programa a la memòria s’ha començat escrivint el programa en binari i passant-lo després a hexadecimal. S’han donat els següents valors per a ser multiplicats: a = 4, b = 3.

Programa 1 binari hexadecimal (begin) @0 CLRF c 0000 0000 0100 0000 00 40 @1 CLRF i 0000 0000 0100 0011 00 43 (bucle) @2 MOVF i 0000 0010 0100 0011 02 43 @3 XORWF b 0000 0101 0100 0010 05 42 @4 BZ end 0000 0111 0000 1100 07 0C @5 MOVF c 0000 0010 0100 0000 02 40 @6 ADDWF a 0000 0100 0100 0001 04 41 @7 MOVWF c 0000 0011 0100 0000 03 40 @8 INCF i 0000 0001 0100 0011 01 43 @9 MOVWF i 0000 0011 0100 0011 03 43 @10 XORWF i 0000 0101 0100 0011 05 43 @11 BZ bucle 0000 0111 0000 0010 07 02 (end) @12 . . . @64 c 0000 0000 00 @65 a 0000 0100 04 @66 b 0000 0011 03 @67 i 0000 0000 00 . . . @255

Figura 35. Taula de valors en binari i hexadecimal del primer programa.

Quan ja s’han tingut els valors hexadecimals de cada adreça de memòria per al programa s’han col·locat en la memòria de dreta a esquerra. Això significa que en la posició que es troba més a la dreta, la 00, hi ha el valor de la instrucció de l’adreça @0 (CLRF = 000000002 = 0016). En la posició 01 hi ha l’adreça al valor de la qual se li aplica la instrucció (lletra c en l’adreça @64 = 010000002 = 40h). En la posició 02 hi ha el valor de la instrucció de l’adreça @1 (CLRF = 000000002 = 0016). En la posició 03, l’adreça on


42

hi ha la variable “i”(adreça @67 = 010000112 = 43h) i així successivament fins arribar a la posició 17 on hi ha l’adreça amb el valor de “bucle” (000000102 = 02h) que és la última adreça del programa abans de les destinades a les constants.

Els valors en hexadecimal de les constants del programa s’han col·locat a partir de l’atribut INIT_02 de la mateixa manera que els anteriors, de dreta a esquerra. En el cas de les constants, però, aquestes només ocupen una posició de la memòria, ja que ocupen 8 bits cadascuna.

Per al primer programa només s’han utilitzat els atributs INIT_00 i INIT_02 amb valors diferents de zero. En INIT_00 s’hi han introduït els valors del programa de les adreces @0 fins a @12 i en INIT_02 s’hi han introduït els valors de les adreces @64 fins a @67.

Figura 36. Valors del primer programa introduïts a la memòria.

Com es veu en la imatge, els valors que hi ha en les posicions de l’atribut INIT_00 són les corresponents als continguts de les adreces de la @0 a la @15 del primer programa, tot i que les adreces de la @12 a la @15 tenen tots els valors a 0 perquè no s’han necessitat per aquest primer programa. Totes les posicions de l’atribut INIT_01 estan a zero perquè no són necessàries per al primer programa; i els valors de les constants del primer


43

programa es troben en l’atribut INIT_02, ocupant només les posicions de la 00 a la 07. La resta de posicions de l’atribut es mantenen amb valors zero perquè no ha sigut necessari guardar més constants.

La col·locació dels valors inicials a la memòria del segon programa s’ha fet de la mateixa manera que s’ha explicat anteriorment per al primer.

Com es veu a continuació, la constant a té el valor inicial a 10 perquè el sumatori que fa el programa és de 1 a 9. Per saber que el sumatori s’ha fet, el valor de i ha d’arribar a 10.

Programa 2 binari hexadecimal (begin) @0 CLRF s 0000 0000 0100 0000 00 40 @1 CLRF i 0000 0000 0100 0001 00 41 @2 INCF i 0000 0001 0100 0001 01 41 @3 MOVWF i 0000 0011 0100 0001 03 41 (bucle) @4 CMPWF a 0000 0110 0100 0010 06 42 @5 BZ end 0000 0111 0000 1011 07 0B @6 ADDWF s 0000 0100 0100 0000 04 40 @7 MOVWF s 0000 0011 0100 0000 03 40 @8 INCF i 0000 0001 0100 0001 01 41 @9 MOVWF i 0000 0011 0100 0001 03 41 @10 GOTO bucle 0000 1000 0000 0100 08 04 (end) @11 . . . @64 s 0000 0000 00 @65 i 0000 0000 00 @66 a 0000 1010 0A . . . @255

Figura 37. Taula de valors en binari i hexadecimal del segon programa.

Un cop escrit el segon programa en hexadecimal, s’ha escrit a la memòria com es mostra a continuació, perquè pugui ser executat per la màquina senzilla.

Figura 38. Valors del segon programa introduïts a la memòria.


44

4.4 Connexió de la Unitat de Procés amb la Memòria

Com ja s’ha iniciat en el punt 4.3, les connexions que s’han necessitat entre aquests dos blocs de la màquina senzilla són tres. Dues d’elles s’han pogut fer directament i no han presentat problemes, però l’altra -degut a la diferència de bits dels busos d’entrada i de sortida dels dos blocs- ha donat problemes que a continuació es detalla la manera com s’han solucionat.

Les connexions directes, que no han donat problemes, són: la sortida de 8 bits de l’ALU que en la unitat de procés s’anomena entMEM i que va a l’entrada DI (també de 8 bits) de la memòria; i la sortida DO de 8 bits de la memòria que va a l’entrada de la unitat de procés anomenada sortMEM, també de 8 bits, que correspon a l’entrada de l’ALU i dels registres d’adreces i d’instruccions.

Per altra banda, la sortida del multiplexor entre el RA i el PC de la unitat de procés, anomenada adrMEM, i l’entrada ADDR de la memòria no coincideixen en número de bits, ja que la primera és de 8 bits i la segona és d’11 bits. Per a solucionar-ho, s’han separat ambdós busos mitjançant l’eina bus tap.

S’han col·locat tants bus taps en cada bus de dades com bits té aquest i després s’han uneit els bus taps necessaris. En el cas de la connexió de adrMEM amb ADDR s’han unit els 8 bus taps provinents de la sortida de la unitat de procés (adrMEM) amb els 8 bus taps de menys pes provinents de l’entrada de la memòria (ADDR). Els tres bus taps restants de l’entrada de la memòria s’han connectat a massa (GND).

Figura 39. Connexions amb Bus Tap entre la UP i la memòria.


45

4.5 Implementació de la Temporització

Per a implementar la temporització dissenyada de la màquina senzilla s’han utilitzat tres blocs connectats entre sí per a aconseguir en primer lloc dividir la freqüència externa de 50 MHz i obtenir una senyal de 1 kHz i una altra de 50 Hz; en segon lloc fer possible a l’usuari la utilització dels tres polsadors CLK, Instrucció i reset; i finalment, proporcionar un rellotge eficient a tota la màquina senzilla.

Els tres blocs utilitzats són un bloc divisor (divisorOK) que divideix la freqüència de rellotge externa de 50 MHz i en proporciona dues de més baixes; el bloc anomenat Rellotge i un biestable tipus D que s’hi ha col·locat darrera i que conjuntament amb el bloc Rellotge s’han encarregat de fer funcionar la màquina senzilla amb el senyal de rellotge que l’usuari marca a través dels polsadors externs.

La sortida clock del bloc Rellotge va cap al biestable tipus D, al qual també li arriba la freqüència de 50 Hz des del bloc divisor. La sortida d’aquest biestable sincronitza les dues entrades i és utilitzada com a senyal de rellotge (clk) per la unitat de control, la unitat de procés i la memòria. La sortida envia dona l’ordre de passar tots els bits que es representen amb leds a la placa des de la FPGA i actualitzar-los al bloc de comunicació.

Figura 40. Blocs que formen el rellotge de la màquina senzilla.

4.5.1 Bloc Divisor

El bloc divisor és un disseny que s’ha implementat per a proporcionar al sistema freqüències diferents a la de 50 MHz que arriba a través de la placa BASYS 2. Per fer-ho, consta de dos divisors de diferents valors. En primer lloc hem col·locat el bloc divisor50kHz que, agafant la freqüència externa i dividint-la entre 50000 obté una freqüència d’1 kHz. A partir d’aquesta freqüència resultant, el bloc divisor20 la divideix entre 20 i obté una freqüència de 50 Hz. Per tant, aquest bloc proporciona dues sortides de freqüències 1 kHz, utilitzada pel bloc del registre de desplaçament, i 50 Hz, que va cap al bloc Rellotge i cap al biestable tipus D.

Figura 41. Implementació del bloc divisor.


46

4.5.2 Bloc Rellotge

Aquesta última freqüència de 50 Hz obtinguda amb el bloc divisor és la senyal de rellotge que utilitza el bloc Rellotge. Aquest bloc funciona amb un graf d’estats dissenyat per a que la màquina senzilla funcioni amb els senyals que s’envien a través dels polsadors. També serveix per evitar rebots i contactes falsos provocats pels polsadors. Hi ha dues opcions de fer funcionar la màquina senzilla amb el rellotge:

- Executar pas a pas cada una de les instruccions. S’aconsegueix generant un impuls de rellotge cada vegada que es prem el polsador de clock: Pclk.

- Executar una instrucció sencera. Passa quan es prem el polsador d’instrucció Pins i controlant que el bit de control RIc està a zero.

Les entrades i sortides que s’han donat al bloc Rellotge són les següents:

Pclk: Entrada que envia la senyal del polsador de clock. Quan aquest polsador està pitjat envia un 1 i quan no ho està envia un 0. En rebre un 1 s’envia un impuls de rellotge.

Pins: Entrada que envia la senyal del polsador d’instrucció. Quan aquest polsador està pitjat envia un 1 i quan no ho està envia un 0. Quan es rep un 1 es van enviant els impulsos de rellotge necessaris per executar una instrucció sencera. Per saber quants són es necessita la senyal RIc.

RIc: Entrada provinent de la unitat de control que indica que quan està a 1 es troba en l’estat S0 o S11 i que, per tant, ja s’han enviat els impulsos de rellotge necessaris per executar una instrucció sencera.

clk: Entrada de rellotge de 50 Hz.


clock: Sortida d’1 bit que quan està a 1 indica que s’ha d’enviar un impuls de rellotge i que va cap al biestable tipus D.

envia: Sortida d’1 bit que dona l’ordre de passar tots els bits que es representen amb leds a la placa des de la FPGA i actualitzar-los.

Figura 42. Símbol del bloc Rellotge.


47

Finalment, després de la implementació de totes les parts explicades en aquest capítol, s’ha obtingut el bloc que ajuntant-les totes conté la màquina senzilla dissenyada, anomenat MaqSenz.

Figura 43. Esquemàtic de tots els elements que formen el bloc màquina senzilla.

Com es veu en l’esquemàtic de la figura 43, MaqSenz té 4 entrades i dues sortides que s’expliquen a continuació, a banda dels 47 bits de sortida que s’envien als leds de l’entrenador i que s’expliquen en el capítol 5.

reset: Entrada general que reseteja el sistema.

clk: Entrada de rellotge de 50 MHz.

Pclk: Entrada corresponent al polsador Pclk que arriba al bloc Rellotge.

Pins: Entrada corresponent al polsador Pins que arriba al bloc Rellotge.

envia: Sortida que envia el bit que marca quan s’han d’enviar cap a l’entrenador tots els bits que s’hi volen mostrar.

CLK1kHz: Sortida de senyal de rellotge d’1 kHz provinent del bloc divisor que va cap al bloc que controla la comunicació i que s’explica en el capítol 5.


48

Figura 44. Símbol del bloc MaqSenz.

Comunicació de la Màquina Senzilla amb l’Entrenador

49

5 Comunicació de la Màquina Senzilla amb l’Entrenador

Un cop dissenyada i implementada amb Xilinx la màquina senzilla, s’ha hagut de pensar una manera per a connectar-la amb l’exterior i obtenir la informació que hi ha gravada en la FPGA per a representar-la externament en els leds de la placa de l’entrenador. Per a comunicar ambdues parts s’ha decidit utilitzar registres de desplaçament, tant implementats en Xilinx a la FPGA com externament en l’entrenador.

5.1 Disseny de la Comunicació amb l’Entrenador

En primer lloc, s’ha necessitat un registre de desplaçament intern -amb un controlador programat amb Xilinx- del tipus PISO (parallel-in, serial-out), que rep en paral·lel tots els bits que s’han de visualitzar i els transmet en sèrie cap a l’exterior de la FPGA, arribant al registre de desplaçament físic del tipus SIPO (serial-in, parallel-out), que transmet aquests bits que rep en sèrie cap als diferents leds de l’entrenador en paral·lel.

Els bits que es transmeten per a ser mostrats amb leds a l’entrenador són els que s’han considerat més útils per a la òptima comprensió del funcionament de la màquina senzilla als alumnes, un total de 47 leds que corresponen als següents bits:

- 3 bits corresponents al codi d’instrucció de la unitat aritmeticològica: ALU(2:0) - 4 bits del codi d’operació del registre d’instruccions: CO(3:0) - 1 bit de control del registre d’instruccions: RIc - 8 bits de contingut del comptador de programa: PC(7:0) - 1 bit de control del registre comptador de programa: PCc - 8 bits de contingut del registre d’adreces: RA(7:0) - 1 bit de control del registre d’adreces: RAc - 1 bit de control del multiplexor entre PC i RA: MUXc - 8 bits que porten el contingut de l’adreça a la memòria: adrMEM(7:0) - 1 bit de control de l’habilitació de lectura/escriptura de la memòria: LE - 8 bits de contingut del registre acumulador: W(7:0) - 1 bit de control del registre acumulador: Wc - 1 bit de contingut del registre del flag zero: FZ - 1 bit de control del registre del flag zero: FZc

5.1.1 Disseny del Registre de Desplaçament Intern

Per a extreure aquests 47 bits de la FPGA cap al registre de desplaçament de l’entrenador ha sigut necessari utilitzar un registre de desplaçament de 48 bits, un dels quals no és necessari. A aquest registre li arriben en paral·lel els 47 bits que volem mostrar i surten en sèrie per la sortida de l’últim biestable.

A banda del registre de desplaçament, s’ha necessitat un controlador per als dos registres de desplaçament (intern i físic), que es detalla en el punt 5.2.2.


50

Figura 45. Disseny del registre de desplaçament intern.

El funcionament d’aquest registre de desplaçament consisteix en copiar primer els bits que arriben en paral·lel a dins del registre per l’entrada de 48 bits Qin i després fer el desplaçament dels bits en ordre cap al port de sortida Qout que els envia cap a l’exterior de la FPGA en sèrie.

5.1.2 Disseny del Registre de Desplaçament Físic

El registre de desplaçament que s’ha escollit per a col·locar a l’entrenador de la màquina senzilla és del tipus SIPO (serial-in, parallel-out) com s’ha esmentat anteriorment, perquè rep els bits procedents de la FPGA en sèrie i els mostra pels diferents leds de l’entrenador en paral·lel.

En concret, s’ha escollit el model MC74HC595N 8-Bit Serial-Input/Serial or Parallel-Output Shift Register de ON Semiconductor, ja que és el model que s’adapta a les necessitats del treball i està disponible. Com que aquest registre de desplaçament és de 8 bits, se n’han utilitzat 6 encadenats per a realitzar la funció d’un registre de desplaçament de 48 bits. Aquest model disposa d’una entrada sèrie, una sortida sèrie i 8 bits que formen la sortida en paral·lel. Està format per un registre de desplaçament (shift register) i un registre de tancament (latch register). Els bits que arriben per l’entrada sèrie es carreguen a aquest registre durant els 47 impulsos de rellotge generats pel bloc de control (explicat en el punt 5.2.2), i un cop estan tots carregats es passen alhora al latch register, del qual surten també alhora cap als leds i es visualitzen.

Figura 46. Diagrama lògic del registre de desplaçament MC74HC595N.


51

5.2 Implementació del la Comunicació amb l’Entrenador

El bloc Comunicacio és el que realitza l’enviament de la senyal provinent de la FPGA que en arribar al registre de desplaçament físic aquest el transmet als leds de l’entrenador. Està format pel bloc controller, el bloc comptador i els registres de desplaçament interns encadenats. Les entrades i sortides que té es detallen seguidament:

Figura 47. Muntatge de l’esquemàtic que realitza la comunicació.

Figura 48. Símbol del bloc Comunicacio.

envia: Entrada d’1 bit provinent del bloc Rellotge.


Pin2 [15:0]: Entrada de 16 bits del registre de desplaçament pel qual surt la senyal sèrie que va cap a l’exterior.

Pin1 [15:0]: Entrada de 16 bits del registre de desplaçament que es troba al mig dels tres que s’utilitzen per crear l’intern.

Pin0 [15:0]: Entrada de 16 bits de l’últim registre de desplaçament, que només rep 15 bits i la seva entrada en la posició 15 es posa a 0 connectant-la a GND.

clk1kHz: Entrada de rellotge provinent del bloc divisor.


52

CS: Chip Select. Sortida de control per al registre de desplaçament físic.

RW: Read/Write. Sortida de control per al registre de desplaçament físic.

SHCP: Shift Clock Pulse. Sortida de control per al registre de desplaçament físic.

STCP: Store Clock Pulse. Sortida de control per al registre de desplaçament físic.

Sout: Sortida que va cap a l’exterior i porta els 47 bits en sèrie per ser mostrats pels leds de l’entrenador.

5.2.1 Implementació del Registre de Desplaçament Intern

El programa Xilinx que s’ha utilitzat per a desenvolupar aquest projecte només té disponibles registres de desplaçament de 4, 8 o 16 bits. Per tant, per a extreure els 47 bits de la FPGA cap al registre de desplaçament de l’entrenador s’ha optat per utilitzar tres registres de desplaçament de 16 bits encadenats, obtenint d’aquesta manera un equivalent a un registre de desplaçament de 48 bits.

El model escollit ha sigut el SR16RLE, un registre de desplaçament de 16 bits del tipus shift-left (desplaçament cap a l’esquerra) Serial/Parallel-In Parallel-Out que disposa de les següents entrades i sortides:

SLI: Entrada sèrie de desplaçament cap a l’esquerra.

D [15:0]: Entrada en paral·lel de 16 bits.

Q [15:0]: Sortida en paral·lel de 16 bits.

CE: Entrada de control d’un bit d’habilitació de rellotge.

L: Entrada de control d’un bit d’habilitació de càrrega.

R: Entrada de control d’un bit de reset síncron.

C: Entrada de rellotge.

Figura 49. Registre de desplaçament SR16RLE.


53

El funcionament d’aquest registre de desplaçament consisteix en el següent: el registre ignora les transicions del rellotge quan L i CE estan a 0 i no hi ha canvis en la sortida del registre. Quan R està a 1 i hi ha una transició de rellotge es sobreescriuen totes les altres entrades i reseteja tots els bits de Q a 0. Si L està a 1 i R a 0 durant una transició de rellotge, es carreguen al registre (a la sortida Q) els bits que hi ha a l’entrada D. Finalment, quan CE està a 1 i L i R estan a 0, durant la transició de rellotge es carreguen les dades que hi ha a SLI al primer bit de la sortida Q; en les següents transicions de rellotge amb aquests mateixos valors de les entrades de control, les dades es desplacen a la següent posició de sortida successivament a mida que es van carregant noves dades en Q0.

Tot i així, no és exactament d’aquesta manera com s’ha utilitzat aquest registre de desplaçament, perquè com que es vol una sortida sèrie només s’ha utilitzat el bit Q0 de sortida. Per tant, quan CE està a 1 i L i R estan a 0 durant la transició de rellotge, la dada que hi ha en SLI es carrega a Q0, però en les següents transicions de rellotge amb aquests mateixos valors de les entrades de control les dades de SLI es desplacen a Q0 successivament, i la dada que hi havia a Q0 segueix avançant en el muntatge (cap al següent registre de desplaçament o cap a la sortida sèrie que va cap a l’exterior si ja surt de l’últim dels tres registres de desplaçament de 16 bits).

Figura 50. Muntatge del registre de desplaçament intern.

5.2.2 Implementació del Controlador dels Registres de Desplaçament

Per a controlar els dos registres de desplaçament explicats s’ha necessitat un bloc controlador que té la funció d’indicar, segons un diagrama d’estats, els valors que han de tenir les entrades dels registres de desplaçament, intern i físic.

El diagrama d’estats que segueix aquest bloc de control consta de 6 estats que permeten controlar i sincronitzar ambdós registres de desplaçament, dues entrades: envia i FiCompta i 9 sortides: conta, R, L, CE, C, CS, RW, SHCP i STCP. La sortida conta va cap


54

a un comptador que s’ha creat per controlar quan ja s’han passat els 47 bits que volem enviar cap a l’exterior. Les sortides R, L, CE i C són per al control del registre de desplaçament intern; i les sortides CS, RW, SHCP i STCP són per a controlar el registre de desplaçament físic. Aquestes quatre senyals de control del registre de desplaçament físic s’utilitzen combinades amb alguns elements lògics que realitzen el funcionament del registre físic tal com es vol. Es detalla l’explicació en el capítol 6 del treball.

Figura 51. Graf d’estats del controlador dels registres de desplaçament.


55

En l’estat inicial S0 els dos registres de desplaçament (intern i físic) estan en repòs i no s’inicia el comptador mentre l’entrada envia esta a 0; quan envia passa a estar a 1 s’avança a l’estat S1, en el que el registre de desplaçament intern copia els valors que li arriben en paral·lel mentre el físic segueix en espera.

S’avança a l’estat S2 independentment de les entrades, l’únic estat en el que la sortida conta es posa a 1 per a iniciar el comptador; el registre de desplaçament intern no varia i el físic fa shift right (desplaça els valors cap al registre d’emmagatzematge).

Seguidament, sempre s’avança cap a l’estat S3, on conta torna a estar a 0, el registre de desplaçament intern fa shift left (desplaça cap a l’esquerra) de la dada que entra per SLI i la desplaça a la sortida Q; el registre de desplaçament físic acaba el shift right, ja que necessita dos estats per completar la baixada del flag de rellotge.

A continuació, si l’entrada FiCompta, provinent del bloc comptador, està a 0 es torna enrere cap a l’estat S2; si pel contrari FiCompta està a 1 significa que el comptador ha acabat i s’ha fet shift de les dades 47 vegades, aleshores s’avança cap a l’estat S4 en el que el registre de desplaçament intern no canvia i l’extern fa parallel load (càrrega en paral·lel) per a passar les dades de tots els bits que han arribat al registre de desplaçament cap als leds perquè es visualitzin tots alhora.

Després s’avança cap a l’estat S5 en el que el registre de desplaçament intern segueix sense variar i el físic acaba el parallel load completant la baixada del flag de rellotge.

Finalment, es torna a l’estat S0 inicial on s’espera a rebre un senyal d’envia per a començar de nou el procés per mostrar nous valors als leds de l’entrenador.

Figura 52. Símbol del bloc controller.


56

El bloc comptador, com el seu nom indica, és un bloc que serveix exclusivament per saber quan s’han passat els 47 bits que es volen passar.

Figura 53. Símbol del bloc comptador.

Finalment, ajuntant el bloc de la màquina senzilla i el bloc de comunicació hem obtingut el bloc final que hem anomenat Intern. Aquest té les 4 entrades del bloc MaqSenz: reset, clk, Pclk i Pins; i les sortides del bloc Comunicacio: CS, RW, SHCP, STCP i Sout. També es pot veure que un dels bits d’entrada de Pin0 està connectat a GND, ja que es tracta de l’entrada Pin0(15) que és la que no hem necessitat.

Figura 54. Muntatge del bloc Intern.

Disseny de l’Entrenador

57

6 Disseny de l’Entrenador

En la placa protoboard que s’ha utilitzat com a entrenador, s’hi ha col·locat els 6 registres de desplaçament MC74HC595N encadenats, el circuït de control per a aquests, 47 leds per a representar els registres i senyals que es volen visualitzar i que s’han enumerat anteriorment i les resistències limitadores necessàries.

6.1 Circuït de Control del Registre de Desplaçament Físic

A continuació es mostra el circuït de control del registre de desplaçament físic, que consisteix en els següents senyals:

- Davant de l'entrada OUTPUT ENABLE: NAND de Store Clock Pulse (STCP), Read/Write (R/W) i Chip Select (CS) negat.

- L’entrada SERIAL INPUT no està alterada pel circuït de control. - Davant de l'entrada de SHIFT CLOCK: AND de Chip Select (CS) negat i Store

Clock Pulse (SHCP). - Davant de l'entrada de LATCH CLOCK: NAND de Chip Select (CS) negat,

Read/Write (R/W) negat i Store Clock Pulse (STCP).

Figura 55. Control del registre de desplaçament físic.

SHIFT CLOCK

OUTPUT ENABLE

SERIAL INPUT

LATCH CLOCK

Disseny de l’Entrenador

58

6.2 Circuït d’Il·luminació per als LEDS

S’ha col·locat entre cada led de la placa i la massa una resistència limitadora per a regular la intensitat dels leds. El càlcul per a determinar la resistència limitadora que necessita cada led s’ha fet per a leds de 5 mm, el model RC201-02 vermell i el GC081-05 verd. S’ha considerat una alimentació de 5V.

En el cas de cada led vermell RC201-02, el voltatge típic és de 2.0 V i el corrent és de 20 mA. Per tant, la resistència limitadora que es necessita és:

R =

. = 150 Ω (1)

I pel cas de cada led verd GC081-05, el voltatge típic és de 2.5 V i el corrent és de 20 mA. Per tant, la resistència limitadora que es necessita és:

R = .

. = 125 Ω (2)

Referències

59

7 Referències

M. Morris Mano i Charles R. Kime, Fundamentos de diseño lógico y de computadoras, Editorial PEARSON Prentice Hall, Any 2004.

Diapositives de teoria de les assignatures Fonaments de computadors, Electrònica bàsica i Microcontroladors i sistemes

embedded.

Gerard Bofill Carnicé, Disseny lògic amb FPGA. Projecte final de carrera, Universitat Rovira i Virgili, Any 1997.

https://reference.digilentinc.com/reference/programmable-logic/basys-2/reference-manual. [Consultes del disseny i del funcionament de la placa utilitzada]. Juny de 2018.

https://www.xilinx.com/products/design-tools/ise-design-suite.html. [Obtenció del programa utilitzat]. Febrer de 2018.

https://www.xilinx.com/support/documentation/sw_manuals/xilinx11/data2mem.pdf. [Consultes del disseny i funcionament de la memòria utilitzada]. Juny de 2018.

https://www.microchip.com/wwwproducts/en/PIC16F877. [Consultes del funcionament i de les instruccions del microcontrolador PIC16F877]. Març 2018.

https://info.pcboard.ca/led-specifications/5mm-led-technical-specifications/. [Consultes de característiques dels LEDS utilitzats]. Juliol de 2018.

Annexos

60

8 Annexos

8.1 Codis VHDL

8.1.1 ALU.vhdl

entity ALunit is

Port ( W : in STD_LOGIC_VECTOR (7 downto 0);

A : in STD_LOGIC_VECTOR (7 downto 0);

ALU : in STD_LOGIC_VECTOR (2 downto 0);

sortida : out STD_LOGIC_VECTOR (7 downto 0));

end ALunit;

architecture Behavioral of ALunit is

begin

sortida <= std_logic_vector(unsigned(W)+unsigned(A)) when ALU="000" else

A xor W when ALU = "001" else

std_logic_vector(unsigned(A) + 1) when ALU = "010" else

W when ALU = "011" else

A when ALU = "100" else

"00000000";

end Behavioral;

8.1.2 RI.vhdl

entity RegistreInstruccions is

Port ( RIc : in STD_LOGIC;

Din : in STD_LOGIC_VECTOR (7 downto 0);

clk : in STD_LOGIC;

reset : in STD_LOGIC;

RI : out STD_LOGIC_VECTOR (3 downto 0));

end RegistreInstruccions;

architecture Behavioral of RegistreInstruccions is

begin

process(reset,clk)

begin

if (reset = '1') then RI <= "0000";

elsif clk'event and clk = '1' then

if RIc = '1' then

RI <= Din(3 downto 0);

end if;

end if;

end process;

end Behavioral;

Annexos

61

8.1.3 PC.vhdl

entity ProgramCounter is

Port ( PCc : in STD_LOGIC;


clk : in STD_LOGIC;


PC : out STD_LOGIC_VECTOR (7 downto 0));

end ProgramCounter;

architecture Behavioral of ProgramCounter is

begin

process(reset,clk)

begin

if (reset = '1') then PC <= "00000000";


if PCc = '1' then

PC <= std_logic_vector(unsigned(Din) + 1);

end if;

end if;

end process;

end Behavioral;

8.1.4 RA.vhdl

entity RegistreAdreces is

Port ( RAc : in STD_LOGIC;


clk : in STD_LOGIC;


RA : out STD_LOGIC_VECTOR (7 downto 0));

end RegistreAdreces;

architecture Behavioral of RegistreAdreces is

begin

process(reset,clk)

begin

if (reset = '1') then RA <= "00000000";


if RAc = '1' then

RA <= Din;

end if;

end if;

end process;

end Behavioral;

Annexos

62

8.1.5 MUX.vhdl

entity MX is

Port ( PC : in STD_LOGIC_VECTOR (7 downto 0);

RA : in STD_LOGIC_VECTOR (7 downto 0);

MUXc : in STD_LOGIC;

MUX : out STD_LOGIC_VECTOR (7 downto 0));

end MX;

architecture Behavioral of MX is

begin

MUX <= PC when MUXc = '0' else RA;

end Behavioral;

8.1.6 W.vhdl

entity acumulador is

Port ( Wc : in STD_LOGIC;


clk : in STD_LOGIC;

reset : STD_LOGIC;

W : out STD_LOGIC_VECTOR (7 downto 0));

end acumulador;

architecture Behavioral of acumulador is

begin

process(reset,clk)

begin

if (reset = '1') then W <= "00000000";


if Wc = '1' then

W <= Din;

end if;

end if;

end process;

end Behavioral;

Annexos

63

8.1.7 FZ.vhdl

entity FlagZero is

Port ( FZc : in STD_LOGIC;


clk : in STD_LOGIC;


FZ : out STD_LOGIC);

end FlagZero;

architecture Behavioral of FlagZero is

signal or_result: std_logic;

begin

or_result <= '1' when Din = "00000000" else '0';

process(reset,clk)

begin

if (reset = '1') then FZ <= '0';


if FZc = '1' then

FZ <= or_result;

end if;

end if;

end process;

end Behavioral;

Annexos

64

8.1.8 UC.vhdl

entity UC is

Port ( RI : in STD_LOGIC_VECTOR (3 downto 0);

FZ : in STD_LOGIC;

clk : in STD_LOGIC;


MUXc : out STD_LOGIC;

ALU : out STD_LOGIC_VECTOR (2 downto 0);

LE : out STD_LOGIC;

PCc : out STD_LOGIC;

RIc : out STD_LOGIC;

RAc : out STD_LOGIC;

Wc : out STD_LOGIC;

FZc : out STD_LOGIC;

estat : out STD_LOGIC_VECTOR (7 downto 0));

end UC;

architecture Behavioral of UC is

type state_type is (S0, S12, S3, S4, S5, S6, S7, S8, S9, S11);

signal estat_present,estat_seguent: state_type;

begin

process(clk, reset)

begin

if (reset = '1') then

estat_present <= S0;

elsif (clk'event and clk = '1') then

estat_present <= estat_seguent;

end if;

end process;

process(estat_present, RI)

begin

case estat_present is

when S0 => MUXc <= '0'; ALU <= "---"; LE <= '0'; PCc

<= '1'; RIc <= '1'; RAc <= '0'; Wc <= '-'; FZc <= '0'; estat <=

"00000000";

estat_seguent <= S12;

when S12 => MUXc <= '0'; ALU <= "---"; LE <= '0'; PCc

<= '1'; RIc <= '0'; RAc <= '1'; Wc <= '-'; FZc <= '0'; estat <=

"00000001";

case RI is

when "0100" => estat_seguent <= S3;








when "0111" =>

if (FZ = '1') then


else estat_seguent <= S0;

end if;

Annexos

65

when others => estat_seguent <= S0;

end case;

when S3 => MUXc <= '1'; ALU <= "000"; LE <= '0'; PCc <=

'0'; RIc <= '0'; RAc <= '0'; Wc <= '1'; FZc <= '1'; estat <= "00000010";




















when S11 => MUXc <= '-'; ALU <= "---"; LE <= '0'; PCc

<= '1'; RIc <= '1'; RAc <= '0'; Wc <= '0'; FZc <= '0'; estat <=

"00001001";


when others => MUXc <= '-'; ALU <= "---"; LE <= '-';

PCc <= '-'; RIc <= '-'; RAc <= '-'; Wc <= '-'; FZc <= '-'; estat <=

"00000000";


end case;

end process;

end Behavioral;

Annexos

66

8.1.9 divisor50kHz.vhdl

entity divisor50kHz is

Port ( clk50MHz : in STD_LOGIC;

clk1kHz : out STD_LOGIC);

end divisor50kHz;

architecture Behavioral of divisor50kHz is

signal cnt: integer:= 0;

signal tmp: std_logic:= '0';

begin

process(clk50MHz)

begin

if(clk50MHz'event and clk50MHz = '1') then

if cnt >= 24999 then

tmp <= not(tmp);

cnt <= 0;

else

tmp <= tmp;

cnt <= cnt+1;

end if;

clk1kHz <= tmp;

end if;

end process;

end Behavioral;

8.1.10 divisor20.vhdl

entity divisor20 is

Port ( clk1kHz : in STD_LOGIC;

clk50Hz : out STD_LOGIC);

end divisor20;

architecture Behavioral of divisor20 is

signal cnt: integer:= 0;

signal tmp: std_logic:= '0';

begin

process(clk1kHz)

begin

if(clk1kHz'event and clk1kHz = '1') then

if cnt >= 9 then

tmp <= not(tmp);

cnt <= 0;

else

tmp <= tmp;

cnt <= cnt+1;

end if;

clk50Hz <= tmp;

end if;

end process;

end Behavioral;

Annexos

67

8.1.11 Rellotge.vhdl

entity Rellotge is

Port ( Pclk : in STD_LOGIC;

Pins : in STD_LOGIC;

RIc : in STD_LOGIC;

clk : in STD_LOGIC;


clock : out STD_LOGIC;

envia : out STD_LOGIC);

end Rellotge;

architecture Behavioral of Rellotge is

type state_type is (S0, S1c, S1i, S2i, Senvia);


begin

process(clk, reset)

begin





end if;

end process;

process(estat_present, Pins)

begin


when S0 => clock <= '0'; envia <= '0';

if (Pins = '0') then

if (Pclk = '0') then


else estat_seguent <= S1c;

end if;

else estat_seguent <= S1i;

end if;

when S1c => clock <= '1'; envia <= '0';

if (Pclk = '0') then

estat_seguent <= Senvia;

else estat_seguent <= S1c;

end if;

when S1i => clock <= '1'; envia <= '0';

if (RIc = '1') then

estat_seguent <= Senvia;

else estat_seguent <= S2i;

end if;

when S2i => clock <= '0'; envia <= '0'; estat_seguent

<= S1i;

when others => clock<='1'; envia<='1';

estat_seguent<=S0;

end case;

end process;

end Behavioral;

Annexos

68

8.1.12 comptador.vhdl

entity comptador is

Port ( reset : in STD_LOGIC;

conta : in STD_LOGIC;

FiCompta : out STD_LOGIC);

end comptador;

architecture Behavioral of comptador is

signal Q: unsigned (5 downto 0);

begin

FiCompta <= '1' when Q = "101110"

else '0';

process(reset,conta)

begin

if reset = '1' then Q <= "000000";

elsif conta = '1' then

if Q >= "101110" then Q <= "000000";

else Q <= Q + 1;

end if;

end if;

end process;

end Behavioral;

Annexos

69

8.1.13 controller.vhdl

entity controller is

Port ( envia : in STD_LOGIC;

FiCompta : in STD_LOGIC;


conta : out STD_LOGIC;

R : out STD_LOGIC;

L : out STD_LOGIC;

CE : out STD_LOGIC;

C : out STD_LOGIC;

CS : out STD_LOGIC;

RW : out STD_LOGIC;

SHCP : out STD_LOGIC;

STCP : out STD_LOGIC);

end controller;

architecture Behavioral of controller is

type state_type is (S0, S1, S2, S3, S4, S5);


begin

process(clk, reset)

begin





end if;

end process;

process(estat_present, envia, FiCompta)

begin


when S0 => conta <= '0'; R <= '0'; L <= '0'; CE <= '0';

C <= '-'; CS <= '1'; RW <= '-'; SHCP <= '0'; STCP <= '-';

if (envia = '1') then


else estat_seguent <= estat_present;

end if;

when S1 => conta <= '0'; R <= '0'; L <= '1'; CE <= '-';

C <= '1'; CS <= '1'; RW <= '-'; SHCP <= '0'; STCP <= '-';


when S2 => conta <= '1'; R <= '0'; L <= '0'; CE <= '0';

C <= '-'; CS <= '0'; RW <= '-'; SHCP <= '1'; STCP <= '0';


when S3 => conta <= '0'; R <= '0'; L <= '0'; CE <= '1';

C <= '1'; CS <= '0'; RW <= '-'; SHCP <= '0'; STCP <= '0';

if (FiCompta = '1') then


else estat_seguent <= S2;

end if;

Annexos

70

when S4 => conta <= '0'; R <= '0'; L <= '0'; CE <= '0';

C <= '-'; CS <= '0'; RW <= '1'; SHCP <= '1'; STCP <= '1';


when S5 => conta <= '0'; R <= '0'; L <= '0'; CE <= '0';

C <= '-'; CS <= '0'; RW <= '1'; SHCP <= '0'; STCP <= '1';


end case;

end process;

end Behavioral;

Annexos

71

8.2 Pràctiques de Laboratori

Per a completar aquest treball s’han creat 2 pràctiques de laboratori per a ser desenvolupades durant l’assignatura Electrònica Digital, per a reforçar i adquirir conceptes diversos, tots utilitzats en el desenvolupament del treball.

La Pràctica de laboratori 1 està pensada per fer-se quan s’hagi explicat la màquina senzilla a classe de teoria i consta de sues parts. L’objectiu de la primera part és que els alumnes entenguin el funcionament de la màquina senzilla explicada a classe. La segona part consisteix en crear una nova unitat de control per a la màquina senzilla inicial i aconseguir que aquesta faci més instruccions.

La Pràctica de laboratori 2 està pensada per realitzar-se quan prèviament s’hagi explicat la teoria dels registres de desplaçament a classe, ja que consisteix en consolidar el concepte i aprendre a controlar un registre de desplaçament.

8.2.1 Pràctica de Laboratori 1: LA MÀQUINA SENZILLA

OBJECTIUS DE LA PRÀCTICA:

- Entendre el funcionament de la màquina senzilla explicada a classe i experimentar com funciona amb un programa simple guardat en memòria.

- Assimilar les diferents parts de la màquina senzilla i el seu funcionament. - Modificar la màquina senzilla per a que realitzi més instruccions.

MATERIAL NECESSARI:

- Un entrenador de la màquina senzilla per a cada grup. - Codis VHDL de la màquina senzilla.

ESTUDI PREVI:

Estudiar i entendre les diapositives que s’han explicat a classe de la màquina senzilla.

PART 1:

1. Observa l’entrenador de la màquina senzilla que se t’ha facilitat. Els leds que hi ha representen els bits dels registres i senyals de control més importants de la màquina senzilla. Identifica a quina part de la màquina senzilla correspon cada grup de leds.

2. Un cop ja has entès com es representa la informació, aquí tens el programa escrit en alt nivell que hi ha a la memòria. Consisteix en una multiplicació de dos nombres a i b que es guarda en c:

begin

c := 0; i := 0;

while (i<b) do

begin

c := c + a; i := i + 1;

end

end

Annexos

72

Escriu aquest programa en baix nivell amb les instruccions que se’t faciliten a continuació i amb l’ajuda de les imatges que seguidament et mostren com són la unitat de procés i la unitat de control de la màquina senzilla:

CLRF F: Posa a zero els 8 bits de l’adreça de memòria F. INCF F: Suma 1 al valor de l’adreça de memòria F i el resultat es guarda a l’acumulador W. MOVF F: Guarda el valor de l’adreça de memòria F a l’acumulador W. MOVWF F: Guarda el valor de l’acumulador W a l’adreça de memòria F. ADDWF F: Suma el valor de l’adreça de memòria F a l’acumulador W i el total es guarda en aquest. XORWF F: Fa una OR exclusiva (XOR) entre el valor que hi ha a l’adreça de memòria F i el de l’acumulador W, i guarda el resultat a l’acumulador W. El resultat de la XOR és 1 quan els dos valors són diferents i és 0 quan són iguals. En aquest últim cas, el flag de zero es posa a 1. BZ D: Si el flag de zero està a 1, salta a l’adreça de memòria D. En canvi, si el flag de zero està a 0 es continua amb la següent instrucció del programa.

3. Comprova en l’entrenador el funcionament de la màquina senzilla quan executa aquest programa.

PART 2:

4. Ara has d’aconseguir que la màquina que has estat analitzant faci més instruccions de les que t’hem proporcionat en un principi. Per a aconseguir-ho has de modificar els elements que la formen inicialment utilitzant el codi VHDL (se’t proporcionen els codis inicials). Busca instruccions semblants a les proporcionades però que aportin algun valor afegit a les ja existents i dissenya quins canvis serien necessaris en la màquina senzilla per a que les realitzés. Afegeix-los als codis VHDL donats.

RESULTATS D’APRENENTATGE:

- L’alumne aplica metodologies de disseny i anàlisi de sistemes digitals. - L’alumne coneix el funcionament bàsic d’un microprocessador. - L’alumne utilitza el llenguatge VHDL per descriure circuits lògics digitals.

Annexos

73

8.2.2 Pràctica de Laboratori 2: REGISTRES DE DESPLAÇAMENT

OBJECTIUS DE LA PRÀCTICA:

- Consolidar el concepte de registre de desplaçament. - Aprendre a controlar un registre de desplaçament.

MATERIAL NECESSARI:

- Programa Xilinx ISE Design Suite. - Una placa Basys 2 de DIGILENT per a cada grup. - Projecte VHDL simple que proporcioni una sortida de 8 bits.

ESTUDI PREVI:

1. Estudiar i entendre les diapositives que s’han explicat a classe dels registres de desplaçament.

2. Buscar informació i entendre el funcionament de l’eina Bus Tap que proporciona Xilinx ISE.

PRÀCTICA:

1. Obre el projecte VHDL que trobaràs al Moodle de l’assignatura amb el programa Xilinx ISE Design Suite i observa el que fa. Veuràs que l’esquemàtic general d’aquest projecte té un bus de sortida de 8 bits Sout(7:0).

2. Utilitzant els registres de desplaçament que té disponibles Xilinx has d’aconseguir visualitzar cadascun dels bits del bus de sortida pels diferents leds que té la placa BASYS 2 de DIGILENT. Tingues en compte que hauràs d’utilitzar l’eina Bus Tap.

3. Observa el resultat en la placa BASYS 2 i treu conclusions sobre el funcionament dels registres de desplaçament i de la seva utilitat.

RESULTATS D’APRENENTATGE:

- L’alumne utilitza el llenguatge VHDL per descriure circuits lògics digitals. - L’alumne aplica metodologies de disseny i anàlisi de sistemes digitals.

Annexos

74

marina prats tudó equip didÀctic per a la mÀquina...

Documents