Diseno Sistemas Digitales VHDL

DiseodesistemasdigitalesconVHDL FelipeMachado,SusanaBorromeo,CristinaRodrguez Versin1.00creadael28deoctubrede2011 EstaversindigitaldeDiseodesistemasdigitalesconVHDLhasidocreadaylicenciadapor FelipeMachadoSnchez,SusanaBorromeoLpezyCristinaRodrguezSnchezconuna licenciadeCreativeCommons.Estalicenciapermitelosusosnocomercialesdeestaobra entantoencuantoseatribuyaautoraoriginal.
inal.Estalicencianopermitealterar, transformarogenerarunaobraderivadaapartirdeestaobra Conestalicenciaereslibredecopiar,distribuirycomunicarpblicamente estaobrabajolascondicionessiguientes: Reconocimiento:debesreconocerycitaralosautoresdeestaobra Nocomercial:nopuedesutilizarestaobraparafinescomerciales Sinobrasderivadas:nopuedesalterar,transformarogenerarunaobra derivadaapartirdeestaobra Paramsinformacinsobrelalicencia,visitaelsiguienteenlace: http://creativecommons.org/licenses/byncnd/3.0/ EstaobraestdisponibleenelarchivoabiertodelaUniversidadReyJuanCarlos: http://eciencia.urjc.es/dspace/handle/10115/5700 http://hdl.handle.net/10115/5700 Paramsinformacinsobrelosautores: http://gtebim.es/ http://gtebim.es/~fmachado
Diseo de sistemas digitales con VHDL

Versin1.00creadael28deoctubrede2011 FelipeMachadoSnchez SusanaBorromeoLpez CristinaRodrguezSnchez DepartamentodeTecnologaElectrnica UniversidadReyJuanCarlos Mstoles,Madrid,Espaa http://gtebim.es/
Agradecimientos
QueremosagradeceralDepartamentodeTecnologaElectrnicadelaUniversidadReyJuanCarlos porfomentarladocenciadecalidadysuapoyoconstanteennuestraslaboresdocentes. Tambin queremos agradecer a los alumnos de Ingeniera de Telecomunicacin de la Universidad Rey Juan Carlos por su inters generalizado en aprender y sus comentarios sobre nuestra docencia yprcticas LosAutores
DiseodesistemasdigitalesconVHDL
ndice
ndice ............................................................................................................................................. 1 Lista de acrnimos ........................................................................................................................ 5 ndice de figuras ............................................................................................................................ 7 ndice de cdigo VHDL................................................................................................................ 11 ndice de tablas ........................................................................................................................... 14 1. Introduccin ............................................................................................................................. 15 2. Repaso de VHDL para sntesis ............................................................................................... 19
2.1. Puerta AND ..................................................................................................................................... 20 2.2. Varias puertas ................................................................................................................................. 21 2.3. Multiplexor ....................................................................................................................................... 22 2.4. Multiplexor de 2 bits de seleccin.................................................................................................... 23 2.5. Elementos de memoria: latch .......................................................................................................... 23 2.6. Elementos de memoria: biestables activos por flanco..................................................................... 24 2.7. Actualizacin de los valores de las seales .................................................................................... 25 2.8. Contadores...................................................................................................................................... 27 2.9. Registros de desplazamiento .......................................................................................................... 28 2.10. VHDL estructural ........................................................................................................................... 28
3. Funcionamiento bsico de las tarjetas electrnicas ............................................................... 33

3.1. Tarjetas XUPV2P y Nexys2............................................................................................................. 33
3.1.1. La tarjeta XUPV2P ...................................................................................................................................... 33 3.1.2. La tarjeta Nexys2......................................................................................................................................... 35
3.2. Encender los leds ............................................................................................................................ 37

3.2.1. Implementacin en la tarjeta XUPV2P ........................................................................................................ 46 3.2.2. Implementacin en la tarjeta Nexys2 .......................................................................................................... 50
3.3. Cambiar el tipo de FPGA de un proyecto ........................................................................................ 53 3.4. Las restricciones del circuito ........................................................................................................... 54
4. Utilizacin del reloj y circuitos secuenciales ........................................................................... 57

4.1. Segundero (primera versin) ........................................................................................................... 57 4.2. Segundero (segunda versin) ......................................................................................................... 60
5. Simulacin con Modelsim........................................................................................................ 63 6. Constantes, genricos y paquetes.......................................................................................... 71

6.1. Uso de constantes........................................................................................................................... 71 6.2. Uso de genricos............................................................................................................................. 72 6.3. Uso de paquetes ............................................................................................................................. 73
7. Transmisin en serie por RS-232............................................................................................ 77

7.1. Desarrollo de la prctica.................................................................................................................. 77 7.2. Consideraciones para el diseo de un circuito ................................................................................ 78 7.3. Funcionamiento de una UART ........................................................................................................ 78 7.4. Diseo del transmisor...................................................................................................................... 80
7.4.1. Divisor de frecuencia ................................................................................................................................... 82
7.4.1.1. Uso de funciones ........................................................................................................................................................ 85 7.4.1.2. Operaciones con constantes y con seales en VHDL................................................................................................. 87 7.4.1.3. Uso de funciones dentro del mismo paquete .............................................................................................................. 88 7.4.1.4. Ms funciones .......................................................................................................................................................... 89
7.4.2. Bloque de control......................................................................................................................................... 90 7.4.3. Registro de desplazamiento y multiplexor................................................................................................... 92
7.5. Simulacin del transmisor ............................................................................................................... 93

7.5.1. Proceso que modela la orden de enviar un dato......................................................................................... 94 7.5.2. Comprobacin de la simulacin .................................................................................................................. 96 7.5.3. Proceso que modela las rdenes de enviar varios datos.......................................................................... 102 7.5.4. Autocomprobacin en el banco de pruebas .............................................................................................. 105 7.5.5. Bancos de pruebas que terminan por s mismos ................................................................................... 111
7.6. Implementacin en la FPGA: diseo estructural ........................................................................... 113

7.6.1. Diseo del interfaz con los pulsadores...................................................................................................... 114 7.6.2. Banco de pruebas del interfaz con los pulsadores.................................................................................... 116 7.6.3. Diseo estructural: unidad de ms alto nivel............................................................................................. 117 7.6.4. Cuando la sntesis no funciona ............................................................................................................... 121
7.6.4.1. Comprueba que todo est bien conectado................................................................................................................ 121
Departamento de Tecnologa Electrnica
Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011
7.6.4.2. Comprueba el fichero .ucf ...................................................................................................................................... 121 7.6.4.3. Comprueba el reset del circuito................................................................................................................................. 122 7.6.4.4. Simula el circuito completo........................................................................................................................................ 122 7.6.4.5. Revisa las advertencias del sintetizador.................................................................................................................... 122 7.6.4.6. Muestra informacin del circuito por los leds............................................................................................................. 129 7.6.4.7. Crea un nuevo proyecto en el ISE............................................................................................................................. 129
7.7. Diseo del receptor de la UART.................................................................................................... 129

7.7.1. Registro de desplazamiento ...................................................................................................................... 131 7.7.2. Registro de entrada ................................................................................................................................... 131 7.7.3. Divisor de frecuencia ................................................................................................................................. 131 7.7.4. Bloque de control ....................................................................................................................................... 132
7.8. Banco de pruebas del receptor de la UART.................................................................................. 132 7.9. Implementacin de la UART completa.......................................................................................... 133
8. Circuitos aritmticos .............................................................................................................. 135

8.1. Paquetes matemticos.................................................................................................................. 136 8.2. Tipos unsigned y signed ............................................................................................................... 136 8.3. Conversin de tipos numricos ..................................................................................................... 137
8.3.1. Asignacin de bits...................................................................................................................................... 137 8.3.2. Conversiones ............................................................................................................................................. 138
8.4. Uso de constantes numricas ....................................................................................................... 139 8.5. Suma de nmeros positivos.......................................................................................................... 139
8.5.1. Informe de sntesis..................................................................................................................................... 140 8.5.2. Esquema RTL ............................................................................................................................................ 141
8.6. Resta de nmeros positivos.......................................................................................................... 143 8.7. Suma y resta de nmeros enteros ................................................................................................ 143
8.7.1. Aumento del rango de la suma en complemento a dos............................................................................. 144 8.7.2. Aumento del rango usando funciones y atributos * ................................................................................... 145 8.7.3. Breve repaso del complemento a dos * ..................................................................................................... 146
8.8. Multiplicacin ................................................................................................................................ 147

8.8.1. Algoritmo de la multiplicacin .................................................................................................................... 148 8.8.2. Implementacin de un multiplicador combinacional .................................................................................. 149 8.8.3. Implementacin de un multiplicador combinacional genrico * ................................................................. 150
8.8.3.1. La sentencia generate * ......................................................................................................................................... 151 8.8.3.2. Multiplicacin con sentencia generate * ................................................................................................................. 151 8.8.3.3. Banco de pruebas para el multiplicador genrico *.................................................................................................... 152
8.8.4. Implementacin de un multiplicador estructural * ...................................................................................... 153 8.8.5. Implementacin del multiplicador estructural genrico *............................................................................ 155
8.9. Diseo considerando las prestaciones.......................................................................................... 156

8.9.1. Anlisis de las prestaciones....................................................................................................................... 156
8.9.1.1. Paralelizacin............................................................................................................................................................ 158 8.9.1.2. Segmentacin ........................................................................................................................................................... 158 8.9.1.3. Compartir recursos.................................................................................................................................................... 159 8.9.1.4. Diseo secuencial ..................................................................................................................................................... 160
8.9.2. Anlisis del multiplicador combinacional.................................................................................................... 161 8.9.3. Multiplicador segmentado .......................................................................................................................... 163 8.9.4. Implementacin del multiplicador secuencial............................................................................................. 166 8.9.5. Comparacin de los multiplicadores .......................................................................................................... 169
8.10. Divisin ....................................................................................................................................... 171
9. Controlador de pantalla VGA ................................................................................................ 175

9.1. Funcionamiento del estndar VGA ............................................................................................... 175 9.2. Conversores digital-analgico para VGA ...................................................................................... 177
9.2.1. Conversor VGA de la XUPV2P.................................................................................................................. 178 9.2.2. Conversor VGA de la Nexys2 .................................................................................................................... 178
9.3. Mdulo de sincronizacin.............................................................................................................. 179 9.4. Implementacin de un controlador VGA sencillo .......................................................................... 183
10. Videojuego de tenis ............................................................................................................. 187

10.1. Control de los jugadores ............................................................................................................. 188 10.2. Pelota que rebota........................................................................................................................ 190 10.3. Videojuego .................................................................................................................................. 191
11. Puerto PS/2 ......................................................................................................................... 193

11.1. Teclado PS/2............................................................................................................................... 193
11.1.1. Cdigos scan ........................................................................................................................................... 195
11.2. Ratn PS/2.................................................................................................................................. 196

11.2.1. Funcionamiento del ratn ........................................................................................................................ 196 11.2.2. Protocolo PS/2 para transmitir desde la computadora ............................................................................ 198 11.2.3. Puertos bidireccionales............................................................................................................................ 200 11.2.4. Puertos bidireccionales en VHDL ............................................................................................................ 201
12. Memorias............................................................................................................................. 203

12.1. Bloques de memoria RAM (BRAM)............................................................................................. 203 12.2. Dibujar una imagen guardada en una ROM................................................................................ 205
Universidad Rey Juan Carlos
12.2.1. Memoria ROM de un bit de ancho de palabra......................................................................................... 206 12.2.2. Circuito que dibuja la imagen de la ROM de un bit de ancho ................................................................. 207 12.2.3. Mejoras y variantes del circuito que dibuja la imagen de la ROM........................................................... 210
12.2.3.1. Retraso de las salidas de la VGA............................................................................................................................ 210 12.2.3.2. Clculo de las direcciones sin multiplicador ............................................................................................................ 212 12.2.3.3. Dibujar la imagen en otro lugar de la pantalla ......................................................................................................... 212 12.2.3.4. Repeticin de la imagen.......................................................................................................................................... 212 12.2.3.5. Ampliacin por dos.................................................................................................................................................. 213 12.2.3.6. Uso de las potencias de dos ................................................................................................................................... 214
12.2.4. Memoria ROM de varios bits de ancho de palabra ................................................................................. 215 12.2.5. Memoria ROM para imagen con mayor profundidad de color................................................................. 218 12.2.6. Memorias ROM grandes: convertir imgenes ......................................................................................... 220
12.3. Memorias RAM............................................................................................................................ 220 12.4. Uso de memorias usando el Coregen *....................................................................................... 222 12.5. Guardar y mostrar una imagen que llega por el puerto serie ...................................................... 224
12.5.1. Conversin de la imagen......................................................................................................................... 225 12.5.2. Envo de la imagen.................................................................................................................................. 226
13. Mostrar caracteres por pantalla........................................................................................... 227

13.1. Memoria ROM ............................................................................................................................. 228 13.2. Memoria RAM.............................................................................................................................. 229 13.3. Control del texto .......................................................................................................................... 229 13.4. Bloque que escribe los caracteres en la pantalla ........................................................................ 230
14. Procesamiento digital de imgenes .................................................................................... 235

14.1. Procesamiento de imgenes ....................................................................................................... 235 14.2. Circuito que procesa una imagen guardada en una ROM........................................................... 236 14.3. Circuito que procesa una imagen que llega por la UART............................................................ 239 14.4. Acelerar el procesamiento........................................................................................................... 239
14.4.1. Disminuir los accesos a memoria............................................................................................................ 240 14.4.2. Procesamiento "al vuelo"......................................................................................................................... 240 14.4.3. Uso de un bfer circular .......................................................................................................................... 243
15. Videojuego Pac-Man ........................................................................................................... 247

15.1. Videojuego Pac-Man ................................................................................................................... 247 15.2. El campo de juego....................................................................................................................... 248 15.3. El jugador sin rostro..................................................................................................................... 249 15.4. El pac-man .................................................................................................................................. 250 15.5. El laberinto .................................................................................................................................. 252 15.6. Recorrer el laberinto .................................................................................................................... 253 15.7. Control del movimiento del pac-man *......................................................................................... 254 15.8. La comida y los puntos................................................................................................................ 254 15.9. Las paredes del laberinto *.......................................................................................................... 255 15.10. El tamao del pac-man * ........................................................................................................... 258 15.11. Movimiento continuo del pac-man *........................................................................................... 259 15.12. El pac-man comiendo * ............................................................................................................. 260 15.13. Los fantasmas ........................................................................................................................... 261 15.14. Otras mejoras *.......................................................................................................................... 261 15.15. Conclusiones ............................................................................................................................. 262
Referencias ............................................................................................................................... 263
Lista de acrnimos
ALU BRAM CAD CLB CPLD DCSE DTE ED1 ED2 ETSIT FIFO FPGA FSM IEEE ISE JTAG LED LSB LUT ArithmeticLogicUnit UnidadAritmticoLgica BlockRAM BloquedememoriaconfigurabledelasFPGAsdeXilinx ComputerAidedDesgin Diseoasistidoporordenador ConfigurableLogicBlock Bloquelgicoconfigurable:sonlosbloquesprincipalesdeunaFPGAdondese implementauncircuito ComplexProgrammableLogicDevice Dispositivodelgicaprogramablecomplejo DiseodeCircuitosySistemasElectrnicos AsignaturadelatitulacindeIngenieradeTelecomunicacindelaURJC DepartamentodeTecnologaElectrnica ElectrnicaDigitalI AsignaturadelatitulacindeIngenieradeTelecomunicacindelaURJC ElectrnicaDigitalII AsignaturadelatitulacindeIngenieradeTelecomunicacindelaURJC EscuelaTcnicaSuperiordeIngenieradeTelecomunicacin EscueladelaUniversidadReyJuanCarlos FirstInFirstOut Tipodepilaenlaqueelprimerelementoquehaentradoeselprimeroensalir FieldProgramableGateArray Dispositivodelgicaprogramable,demayoresprestacionesquelosCPLD FiniteStateMachine Mquinadeestadosfinitos InstituteofElectricalandElectronicsEngineers InstitutodeIngenierosElctricosyElectrnicos IntegratedSoftwareEnvironment EntornodediseoelectrnicodeXilinx.Estelibrousalaversin9.2. JointTestActionGroup NombrecomnutilizadoparadesignarlanormaIEEE1149.1tituladaStandardTest AccessPortandBoundaryScanArchitecture LightEmittingDiode Diodoemisordeluz.Estapalabrasehalexicalizadoenespaolyseusaenminsculas. Aunqueelplurarcorrectoseraledes,enestelibroseemplearleds. LeastSignificantBit Bitmenossignificativo LookUpTable
MSB PISO PWM RAM RGB ROM RTL SIPO UART URJC UUT VHDL VHSIC
Tabladeconsulta,enelcasodelasFPGAseutilizanparaimplementarfunciones lgicasyseconstruyenenhardwareconmultiplexoresyelementosdememoria MostSignificantBit Bitmssignificativo ParallelInSerialOut Registrodedesplazamientoenelquelosdatosentranenparaleloysalenenserie PulseWidthModulation Modulacinporanchodepulso RandomAccessMemory Memoriadeaccesoaleatorio.EngeneralseconsideranRAMalasmemoriasvoltiles RedGreenBlue Rojo,verdeyazul.Sistemadecodificacindelcolorbasadoenlamezcladeestostres colores ReadOnlyMemory Memoriadeslolectura. RegisterTransferLevel Nivel(deabstraccin)detransferenciaderegistros(otransferenciaentreregistros) SerialInParallelOut Registrodedesplazamientoenelquelosdatosentranenserieysalenenparalelo UniversalAsynchronousReceiverTransmitter TransmisorReceptorAsncronoUniversal UniversidadReyJuanCarlos UniversidadpblicadeMadrid,Espaa UnitUnderTest Unidadbajoprueba VHSICHardwareDescriptionLanguage Untipodelenguajededescripcindehardware VeryHighSpeedIntegratedCircuit Circuitointegradodemuyaltavelocidad
ndice de figuras
Figura2.1:ListadepalabrasreservadasdelVHDL............................................................................................................................19 Figura2.2:RepresentacindelaentidadVHDL .................................................................................................................................20 Figura2.3:RepresentacindelaarquitecturaVHDL.........................................................................................................................21 Figura2.4:RepresentacindelaarquitecturaVHDL.........................................................................................................................21 Figura2.5:RepresentacindelaarquitecturaVHDL.........................................................................................................................21 Figura2.6:RepresentacindelaarquitecturaVHDL.........................................................................................................................22 Figura2.7:Representacindelmultiplexor..........................................................................................................................................23 Figura2.8:LatchdetipoD ......................................................................................................................................................................24 Figura2.9:LatchdetipoDconreset .....................................................................................................................................................24 Figura2.10:BiestabledetipoDconreset .............................................................................................................................................25 Figura2.11:Dosbiestablesencascada ..................................................................................................................................................25 Figura2.12:Esquemadeldiseodelcdigo2.16 ................................................................................................................................27 Figura2.13:Cronogramadeldiseodelcdigo2.16..........................................................................................................................27 Figura2.14:Esquemadelcircuitoestructural......................................................................................................................................29 Figura3.1:PlacaXUPVirtexIIPro(XUPV2P)utilizadaenlaasignatura ......................................................................................34 Figura3.2:Conexionesdelospulsadores,interruptoresyLEDdepropsitogeneralenlaplacaXUPV2P ............................35 Figura3.3:PlacaNexys2conlaquedemaneraalternativasepuedeseguirestemanual ...........................................................36 Figura3.4:Conexionesdelospulsadores,interruptoresyLEDdepropsitogeneralenlaplacaNexys2 ..............................36 Figura3.5:Ventanaparacrearunnuevoproyecto .............................................................................................................................38 Figura3.6:InterpretacindeltextodelencapsuladodelaFPGAdelaXUPV2P ..........................................................................38 Figura3.7:InterpretacindeltextodelencapsuladodelaFPGAdelaNexys2 ............................................................................38 Figura3.8:Ventanaparalaseleccindeldispositivodelnuevoproyecto .....................................................................................39 Figura3.9:Seleccindeltipodelanuevafuentequevamosacrear ...............................................................................................39 Figura3.10:Definicindelospuertos ...................................................................................................................................................40 Figura3.11:Aparienciadelaherramientaalaadirlanuevafuenteled1.vhd .............................................................................41 Figura3.12:Aparienciadelaherramientaalaadirlanuevafuenteled1.vhd .............................................................................42 Figura3.13:EsquemadelaentidadparalaXUPV2P .........................................................................................................................43 Figura3.14:EsquemadelaentidadparalaNexys2 ...........................................................................................................................43 Figura3.15:Comprobarlasintaxis:SynthesizeXSTCheckSyntax ............................................................................................44 Figura3.16:HerramientaPACE .............................................................................................................................................................45 Figura3.17:AsignacindelospinesenlaherramientaPACEparalaXUPV2P ...........................................................................46 Figura3.18:AsignacindelospinesenlaherramientaPACEparalaNexys2 .............................................................................46 Figura3.19:LlamadaalaherramientaiMPACTparaprogramarlaFPGAdelaXUPV2P .........................................................47 Figura3.20:ConfigurandoelcableUSBparaprogramarlaFPGAdelaXUPV2P........................................................................48 Figura3.21:DispositivosJTAGidentificadosenlaXUPV2P ............................................................................................................48 Figura3.22:ProgramacindelaFPGAdelaXUPV2P.......................................................................................................................49 Figura3.23:ProgramacinexitosadelaFPGA....................................................................................................................................50 Figura3.24:ProgramacinfallidadelaFPGA.....................................................................................................................................50 Figura3.25:PantallainicialdelAdept,sindispositivosconectados................................................................................................51 Figura3.26:PantalladelAdeptquehadetectadoalgndispositivoconectado............................................................................52 Figura3.27:PantalladelAdeptquehadetectadolacadenaJTAGdedispositivos(FPGAyPROM) .......................................52 Figura3.28:ProcedimientoparacambiarlascaractersticasdelaFPGA........................................................................................53 Figura3.29:Edicindelficheroderestricciones .................................................................................................................................54 Figura4.1:EsquemadelsegunderoparalaXUPV2P .........................................................................................................................58 Figura4.2:EsquemadelsegunderoparalaNexys2 ...........................................................................................................................58 Figura4.3:XilinxConstraintsEditor .....................................................................................................................................................59 Figura5.1:Creacindeunnuevobancodepruebas ..........................................................................................................................63 Figura5.2:Estructuradelbancodepruebas ........................................................................................................................................64 Figura5.3:AadiendoficherosalproyectodeModelsim .................................................................................................................66 Figura5.4:CompilandolosficherosdelproyectodeModelsim .......................................................................................................67 Figura5.5:Comienzodelasimulacinyseleccindelficherodelbancodepruebasparasimular ..........................................67 Figura5.6:Aadiendolaventanadelasformasdeonda(Wave)....................................................................................................68 Figura5.7:Aadiendolassealesdeuncomponente........................................................................................................................68 Figura5.8:Indicacindeltiempodesimulacinyordenparaempezarlasimulacin................................................................69 Figura5.9:Resultadodelasimulacin..................................................................................................................................................69 Figura6.1:Cmoverelpaqueteincluidoenelproyecto...................................................................................................................74 Figura7.1:EsquemadelaconexinRS232 ..........................................................................................................................................79 Figura7.2:ConectorDB9hembradelaplacaylospinesutilizados ...............................................................................................79
Figura7.3:TramadeunenvoenRS232con8bits,bitdeparidadyunbitdefin....................................................................... 80 Figura7.4:Entradasysalidasdeltransmisor...................................................................................................................................... 80 Figura7.5:DiagramadebloquespreliminardeltransmisordelaUART ..................................................................................... 82 Figura7.6:Divisordefrecuenciade100MHza9600Hz.................................................................................................................. 83 Figura7.7:Cronogramadelcontadordeldivisordefrecuenciaenelfinaldelacuenta............................................................. 84 Figura7.8:Cronogramaenlatransicinacero .................................................................................................................................. 84 Figura7.9:Usodelvalordevueltoporlafuncinlog2iparalaobtencindelrangodeunnaturalyununsigned ........... 86 Figura7.10:DiagramadeestadospreliminardeltransmisordelaUART .................................................................................... 90 Figura7.11:Diagramadeestadosconlaindicacindelassealesquehacencambiardeestado ............................................ 91 Figura7.12:Diagramadebloquesdefinitivodeltransmisor ........................................................................................................... 91 Figura7.13:Capturadeeventosdelresetbasadosentiemposoeneventos.ReferenciadoalaXUPV2P ............................... 95 Figura7.14:SimulacinpordefectoenelISE ..................................................................................................................................... 96 Figura7.15:AadirsealesenelISESimulator ................................................................................................................................. 97 Figura7.16:Simulacindeltransmisorconsealesinternasdurante88s.................................................................................. 97 Figura7.17:Formadeondadelasealfpga_txdespusdesimular88s................................................................................ 98 Figura7.18:Formasdeondaparalatransicinalosbitsdedatos ................................................................................................. 99 Figura7.19:Formasdeondaparalatransicinalbitdefin........................................................................................................... 100 Figura7.20:Esperarportiemposyluegoporeventospuedeproducirsealesdeanchomuyinferioralciclodereloj ..... 104 Figura7.21:Solucinalaesperaportiemposseguidadeesperaporeventos(figura7.20) ..................................................... 105 Figura7.22:Esquemadelbancodepruebasdeltransmisorqueincluyeunprocesoquemodelaelreceptordescritoa altonivelyverificaqueelenvoescorrecto ................................................................................................................ 107 Figura7.23:Esperaparasituarnosenmediodelbitdeinicio........................................................................................................ 107 Figura7.24:Esperaparasituarnosenmediodelbit0deldato ..................................................................................................... 108 Figura7.25:AvisosdelosassertenModelsim ............................................................................................................................. 110 Figura7.26:EsquemaestructuraldeltransmisordelaUARTqueimplementaremosenlaFPGA......................................... 113 Figura7.27:Esquemainternodeinterfazconlospulsadores ........................................................................................................ 115 Figura7.28:Cmoindicarelmdulodemayornivel ..................................................................................................................... 116 Figura7.29:Representacinesquemticadelaentidaddemsaltonivel .................................................................................. 117 Figura7.30:Representacinesquemticadelaarquitecturaestructural,conloscomponentesreferenciadosysus conexiones ......................................................................................................................................................................... 118 Figura7.31:ExplicacindelareferenciaoinstanciadeuncomponenteenVHDL ................................................................... 119 Figura7.32:Nuevaconexindelhiperterminal ............................................................................................................................... 120 Figura7.33:Conexinalpuertoserie ................................................................................................................................................. 121 Figura7.34:Caractersticasdelaconexin ........................................................................................................................................ 121 Figura7.35:ResumendeldiseoenelISE ........................................................................................................................................ 122 Figura7.36:Asignacindelasealdato_tx_rg ............................................................................................................................ 123 Figura7.37:Asignacindelpuertodesalidacaracter ................................................................................................................ 124 Figura7.38:Esquemadeuncircuitoconunasealquenodavalor ............................................................................................ 125 Figura7.39:Esquemadeuncircuitoconunasealquenoharecibidovalor............................................................................. 125 Figura7.40:EsquemadeuncircuitoconlazocombinacionalyelcdigoVHDLqueloforma............................................... 126 Figura7.41:Esquemaquemuestracmosepuederomperellazocombinacionaldelafigura7.40 ...................................... 126 Figura7.42:Esquemadeejemplodecircuitoestructuralparamostrarlazoscombinacionalesentremdulos.................... 127 Figura7.43:Procesosenmdulosdistintosqueformanunlazocombinacionalconlassealestransmitey tranmitiendo. ............................................................................................................................................................... 127 Figura7.44:ElprocesodeltransmisorcomomquinadeMoorepararomperellazocombinacional................................... 128 Figura7.45:Entradasysalidasdelreceptor ...................................................................................................................................... 130 Figura7.46:Cronogramadesalidasdelreceptoralterminarlarecepcinyelcomienzodeunanueva ............................... 130 Figura7.47:Diagramadebloquespreliminardelreceptor ............................................................................................................ 131 Figura7.48:Cronogramadeldivisordefrecuencia ......................................................................................................................... 132 Figura7.49:Esquemadelbancodepruebasdelreceptor,queincluyeunprocesoquemodelaeltransmisordescritoa altonivel............................................................................................................................................................................. 132 Figura7.50:Esquemadelbancodepruebasdelreceptor,queincluyeeltransmisorsintetizable........................................... 133 Figura7.51:CircuitoquetransmiteloquerecibeconprotocoloRS232 ...................................................................................... 134 Figura8.1:Desbordamientoenlasumadenmerossinsigno...................................................................................................... 140 Figura8.2:Informedesntesis ............................................................................................................................................................. 141 Figura8.3:EsquemaRTL...................................................................................................................................................................... 142 Figura8.4:EsquemaRTLdelsumador .............................................................................................................................................. 142 Figura8.5:Ejemplosdeloscasosdedesbordamientoenlasumaencomplementoados ....................................................... 147 Figura8.6:Ejemplosdemultiplicacinenteraendecimalyenbinario ....................................................................................... 148 Figura8.7:Esquemadelmultiplicadorcombinacional ................................................................................................................... 149 Figura8.8:Sumasparcialesparalamultiplicacin .......................................................................................................................... 150 Figura8.9:Componentebsicodelmultiplicador ........................................................................................................................... 154 Figura8.10:Curvasdeprestacionesreatiempoparaalgoritmos ............................................................................................... 158 Figura8.11:Paralelizacin.................................................................................................................................................................... 158
ndice de figuras
Figura8.12:Segmentacin.....................................................................................................................................................................159 Figura8.13:Compartirrecursos ...........................................................................................................................................................160 Figura8.14:Tresopcionesdediseo.A:combinacional.B:Segmentado.C:Secuencial ...........................................................160 Figura8.15:Algortimoparacalcularunmultiplicadorde4x4apartirde4multiplicadoresde2x2........................................163 Figura8.16:Esquemadelmultiplicadorsegmentado ......................................................................................................................164 Figura8.17:Esquemticodelmultiplicadorsecuencialde4bits ...................................................................................................167 Figura8.18:UtilizacindereadelaNexys2paraimplementarlosdistintosmultiplicadoresrespectoalnmerode bitsdelmultiplicador .......................................................................................................................................................170 Figura8.19:FrecuenciamximadelaNexys2paralosdistintosmultiplicadoresrespectoalnmerodebitsdel multiplicador......................................................................................................................................................................170 Figura8.20:Ejemplodedivisinenteraendecimalyenbinario ...................................................................................................171 Figura8.21:Paso1deladivisin:clculodeldesplazamientoinicial...........................................................................................172 Figura8.22:Paso2deladivisin .........................................................................................................................................................172 Figura8.23:Paso3deladivisin .........................................................................................................................................................172 Figura8.24:Paso4deladivisin .........................................................................................................................................................172 Figura8.25:Paso5deladivisin .........................................................................................................................................................173 Figura8.26:Paso6deladivisin .........................................................................................................................................................173 Figura9.1:ConectorVGA .....................................................................................................................................................................175 Figura9.2:Pxelesenunapantallaconresolucinde640x480 .......................................................................................................176 Figura9.3:Sealesdesincronismoparaunafrecuenciaderefrescode60Hzy640x480pxeles.............................................176 Figura9.4:Cronogramadeunalneaenpxeles ...............................................................................................................................177 Figura9.5:Entradasysalidasdelsincronizador ...............................................................................................................................179 Figura9.6:Esquemadelsincronizador ...............................................................................................................................................180 Figura9.7:CronogramadelcontadordeciclosderelojparalaXUPV2P(100MHz) .................................................................181 Figura9.8:CronogramadelcontadordeciclosderelojparalaNexys2(50MHz) .....................................................................181 Figura9.9:Cronogramadelacuentadepxelescomenzandodesdelospxelesvisibles ..........................................................183 Figura9.10:EsquemadebloquesdelcontroladorVGAsencillo....................................................................................................184 Figura9.11:CartadeajustequedebemostrarseporpantallaparalaXUPV2P...........................................................................186 Figura10.1:Campodejuego ................................................................................................................................................................187 Figura10.2:Esquemadebloquesdeljuegodeteniscontroladoporlospulsadores ..................................................................188 Figura10.3:Coordenadasymedidasdeljugadorizquierdoenelcampo ....................................................................................189 Figura10.4:cuatrodireccionesdelapelota .......................................................................................................................................191 Figura10.5:Ejemplosdecambiosdetrayectoriadelapelotaalchocarconlasparedes ...........................................................191 Figura11.1:ConectorPS/2.....................................................................................................................................................................193 Figura11.2:CronogramageneraldelatransmisindelpuertoPS/2.............................................................................................194 Figura11.3:Ejemplodelcronogramaparaunatransmisindelteclado ......................................................................................194 Figura11.4:Entradasysalidasdelreceptordelteclado ..................................................................................................................195 Figura11.5:Cdigosscandeuntecladoinglsnorteamericano ....................................................................................................195 Figura11.6:Contenidodelostresbytesdeinformacinenviadosporelratn ..........................................................................197 Figura11.7:CronogramadelatransmisindedatosentrelacomputadoraoFPGA(rojo)yelratn(azul).........................199 Figura11.8:Cronogramasseparadosdelatransmisindedatosdesdelacomputadorahaciaelratn ................................199 Figura11.9:EsquemasimplificadodelaconexinendrenadorabiertodelPS/2 ........................................................................200 Figura11.10:Funcionamientodeuntransistorendrenadorabiertoconresistenciadepullup ..............................................201 Figura11.11:Funcionamientodedostransistoresconectadosendrenadorabiertoconresistenciadepullup....................201 Figura11.12:Buffertriestado ..............................................................................................................................................................202 Figura11.13:Separacindeunpuertodeentradaysalidaenseales..........................................................................................202 Figura12.1:BloquedememoriaRAMdedoblepuerto...................................................................................................................205 Figura12.2:EsquemadebloquesdelcircuitoquepintaenlapantallaunaimagenguardadaenunaROM.........................206 Figura12.3:ImagendelaROMdelcdigo12.1 ................................................................................................................................208 Figura12.4:ClculodeladireccindememoriaatravsdelnmerodepxelynmerodelneadelaVGA .....................209 Figura12.5:EsquemadebloquesdelcircuitoquepintaenlapantallaunaimagenguardadaenunaROMretrasando lassealesdelaVGA........................................................................................................................................................211 Figura12.6:Eliminacindetransicionesespuriasconunbiestable...............................................................................................212 Figura12.7:Clculodeladireccindememoriaparapintarunaimageneldobledegrande .................................................214 Figura12.8:Esquemadelclculodeladireccindememoriaparaimgenesde16x16............................................................215 Figura12.9:Clculodeladireccindememoriaaprovechandoquelaimagentieneunnmerodecolumnaspotencia dedos ..................................................................................................................................................................................215 Figura12.10:Clculodeladireccindememoriaydelndicedelpxelenmemoriasqueguardantodalafilaenuna direccin..............................................................................................................................................................................217 Figura12.11:CreacindeunIP............................................................................................................................................................222 Figura12.12:SeleccindeBlockMemoryGenerator .......................................................................................................................222 Figura12.13:Seleccindeopcionesdelamemoria(I) .....................................................................................................................223 Figura12.14:Seleccindeopcionesdelamemoria(II)....................................................................................................................223 Figura12.15:Seleccindeopcionesdelamemoria(III)...................................................................................................................223
Figura12.16:CronogramadeconlalecturayescrituradelaBRAM(modowritefirst)........................................................... 224 Figura12.17:CronogramadeconlalecturayescrituradelaBRAM(modoreadfirst) ............................................................ 224 Figura12.18:Diagramadebloquesdelaprctica ............................................................................................................................ 224 Figura12.19:Primeraversindelcircuito ......................................................................................................................................... 225 Figura13.1:MapadebitsdelaA,laBylai............................................................................................................................. 227 Figura13.2:Diagramadebloquesdelcircuitoqueescribeloscaracteresporpantalla ............................................................. 228 Figura13.3:ConfiguracindelaROMparaguardarlainformacindelospxelesdelos128caracteresASCII ................. 229 Figura13.4:Divisindelapantallaencuadrculasynumeracindelascuadrculas ............................................................... 231 Figura13.5:ClculodelafilaycolumnadelacuadrculaapartirdelafilaycolumnadelaVGA ....................................... 232 Figura13.6:Esquemadelosclculosdelasdireccionesdememoriaparalaobtencindelcolordelpxel.......................... 233 Figura14.1:Distintosoperadoresdeconvolucin ........................................................................................................................... 235 Figura14.2:AplicacindeloperadorhorizontaldePrewittalpxel(1,1).................................................................................... 235 Figura14.3:Numeracindelospxelesdelaventana..................................................................................................................... 236 Figura14.4:DiagramadebloquesdelcircuitoqueprocesaymuestraunaimagenguardadaenunaROM ........................ 236 Figura14.5:EntradasysalidasdelmduloProcVentanaquerealizalaconvolucindeventana3x3 ............................... 238 Figura14.6:Esquemadelasoperacionesdelaconvolucin3x3dePrewitt ............................................................................... 238 Figura14.7:DiagramadebloquesdelcircuitoqueprocesaymuestraunaimagenrecibidaporlaUART ........................... 239 Figura14.8:Pxelesrepetidosenelclculodelaconvolucin3x3paraelprocesamientodedospxelesconsecutivos ..... 240 Figura14.9:Registrosqueguardantresfilasdelaimagen............................................................................................................. 241 Figura14.10:DesplazamientodelosregistrosalrecibirunnuevopxeldelaUART ............................................................... 241 Figura14.11:Desplazamientodelosregistros:llegadadeunpxeldelborde............................................................................ 242 Figura14.12:Desplazamientodelosregistros:salidadeunpxeldelborde .............................................................................. 242 Figura14.13:Diagramadebloquessimplificadodelmdulodelosregistrosdedesplazamiento ......................................... 243 Figura14.14:Esquemadelaescrituradetreselementosenelbfercircular.............................................................................. 243 Figura14.15:Llenadodelbfercircularyescrituraconelbferlleno......................................................................................... 244 Figura14.16:Bfercircularconunnicopuntero ........................................................................................................................... 244 Figura14.17:Funcionamientodelbfercircularconunnicopunterocuandoestlleno ...................................................... 245 Figura14.18:Variantedelcircuitodelafigura14.9implementadoconbferes ........................................................................ 245 Figura14.19:DiagramadebloquesdelaFIFO ................................................................................................................................. 246 Figura15.1:VideojuegoPacMan........................................................................................................................................................ 247 Figura15.2:VersindelPacManparaAtari .................................................................................................................................... 247 Figura15.3:Cuadrculadelcampodejuegoysurelacinconlapantallade640x480.............................................................. 248 Figura15.4:Paredesrellenasconunslocolor ................................................................................................................................ 256 Figura15.5:Paredesrellenascondibujos .......................................................................................................................................... 256 Figura15.6:Tiposdeceldasparapintarlasparedesdellaberinto................................................................................................ 256 Figura15.7:Obtencindeltipodeceldaparapintarlasparedesapartirdelasceldasadyacentes ....................................... 257 Figura15.8:Tamaodelpacmancomparadoconelantiguoyelnuevopasillo ....................................................................... 258 Figura15.9:Pacmanampliadoparaqueocupelamayorpartedelpasillo ................................................................................ 258 Figura15.10:Coordenadasdelpacmanampliado.......................................................................................................................... 259 Figura15.11:Movimientodelpacmanpxelapxelhastallegaralaposicinfinal ................................................................. 260
10
ndice de cdigo VHDL

Cdigo2.1:EntidadenVHDL................................................................................................................................................................20 Cdigo2.2:ArquitecturaenVHDL .......................................................................................................................................................21 Cdigo2.3:ArquitecturaenVHDL .......................................................................................................................................................21 Cdigo2.4:ArquitecturaenVHDL .......................................................................................................................................................21 Cdigo2.5:Arquitecturaequivalentealadelcdigo2.4 ..................................................................................................................21 Cdigo2.6:ArquitecturadeunmultiplexorenVHDL......................................................................................................................22 Cdigo2.7:ArquitecturaequivalentedeunmultiplexorenVHDL ................................................................................................22 Cdigo2.8:Descripcindelmultiplexorequivalentealadelcdigo2.7utilizandolasentenciacase......................................22 Cdigo2.9:Multiplexorde2bitsdeseleccin.....................................................................................................................................23 Cdigo2.10:Procesoequivalenteparaelmultiplexorde2bitsdeseleccindelcdigo2.9 .......................................................23 Cdigo2.11:LatchdetipoDactivopornivelalto ..............................................................................................................................24 Cdigo2.12:LatchdetipoDactivopornivelaltoconreset .............................................................................................................24 Cdigo2.13:BiestabledetipoDactivoporflancodesubida ...........................................................................................................25 Cdigo2.14:Dosbiestablesencascada.................................................................................................................................................25 Cdigo2.15:Diseoequivalentealcdigo2.14...................................................................................................................................26 Cdigo2.16:Circuitodetectordeflanco...............................................................................................................................................26 Cdigo2.17:Contadormdulo8 ...........................................................................................................................................................27 Cdigo2.18:Registrodecargaparaleloysalidaserie........................................................................................................................28 Cdigo2.19:Ejemplodediseoestructural .........................................................................................................................................31 Cdigo3.1:PaquetespordefectoqueponeelISE ..............................................................................................................................42 Cdigo3.2:Paquetesrecomendados .....................................................................................................................................................42 Cdigo3.3:CdigodelaentidadparalaXUPV2P.............................................................................................................................43 Cdigo3.4:CdigodelaentidadparalaNexys2 ...............................................................................................................................43 Cdigo3.5:Cdigodelaarquitecturadeled1.vhdenlaXUPV2P ..................................................................................................43 Cdigo3.6:Cdigodelaarquitecturadeled1.vhdenlaNexys2.....................................................................................................43 Cdigo4.1:Cdigodelaprimeraversin(confallos)delsegunderoparalaXUPV2P ..............................................................58 Cdigo4.2:Cdigodelaprimeraversin(confallos)delsegunderoparalaNexys2 ................................................................59 Cdigo4.3:declaracindeunrangoincorrectaparasntesis .......................................................................................................61 Cdigo4.4:declaracionescorrectadeunrango ..................................................................................................................................61 Cdigo4.5:ladeclaracindeunasealsinrangoimplementaunasealde32bits ...................................................................61 Cdigo4.6:Declaracindesealunsigned .......................................................................................................................................61 Cdigo4.7:EntidaddelasegundaversindelsegunderoparalaXUPV2P..................................................................................61 Cdigo4.8:EntidaddelasegundaversindelsegunderoparalaNexys2....................................................................................61 Cdigo4.9:Declaracindelassealesusadasparacontar ...............................................................................................................61 Cdigo5.1:ProcesoquesimulaelrelojdelaXUPV2P ......................................................................................................................65 Cdigo5.2:ProcesoquesimulaelrelojdelaNexys2.........................................................................................................................65 Cdigo5.3:ProcesoquesimulalasealderesetparalaXUPV2P ..................................................................................................65 Cdigo5.4:ProcesoquesimulalasealderesetparalaNexys2.....................................................................................................65 Cdigo6.1:Sentenciaconlgicadirecta ...............................................................................................................................................71 Cdigo6.2:Sentenciaequivalentealcdigo6.1peroconlgicainversa........................................................................................71 Cdigo6.3:Aadiendo_nalassealesqueusanlgicainversa ...................................................................................................72 Cdigo6.4:Invirtiendolospuertosquetrabajanconlgicainversa ...............................................................................................72 Cdigo6.5:Usandoconstantesparaindependizarelcircuitodeltipodelgicadelasentradas...............................................72 Cdigo6.6:Declaracinyusodegenricos .........................................................................................................................................72 Cdigo6.7:Ejemplodelatransmisindelosgenricosenunareferenciaacomponente ..........................................................73 Cdigo6.8:InclusindelpaqueteSTD_LOGIC_1164delabibliotecaIEEE .................................................................................73 Cdigo6.9:Paqueteconladefinicindelasconstantes ....................................................................................................................73 Cdigo6.10:Entidadyarquitecturaqueusanelpaquetedelcdigo6.9 .......................................................................................74 Cdigo7.1:Paqueteconladeclaracindeconstantes........................................................................................................................81 Cdigo7.2:ConstanteparaelclculodelfindecuentadedivisordefrecuenciadelaUART...................................................84 Cdigo7.3:Rangodelasealcuentabasadoenlaconstantedefindecuenta .............................................................................84 Cdigo7.4:Declaracindeunafuncinparaelclculodellogaritmo ...........................................................................................85 Cdigo7.5:CuerpodelpaqueteUART_PKGycuerpodelafuncinlog2i ..................................................................................86 Cdigo7.6:Ejemplodelautilizacindelresultadodelafuncinlog2iparalosrangosdelasseales.................................86 Cdigo7.7:Constantequerepresentaelnmerodebitsmenosunodelcontadordeldivisordefrecuencia .........................87 Cdigo7.8:Declaracindelasea,paraelcasodetipounsigned,quecuentaconelrangodeterminadoporla constantecalculada .............................................................................................................................................................87 Cdigo7.9:Declaracindelaseal,paraelcasodetiponatural,conelrangodeterminadoporlaconstantecalculada......87
11
Cdigo7.10:ProcesodeldivisordefrecuenciadeltransmisordelaUART.................................................................................. 87 Cdigo7.11:Elusodefuncionesdentrodelmismopaquetedaproblemasenalgunasherramientas .................................... 88 Cdigo7.12:Usodeconstantesdiferidasparaevitarproblemasporusarfuncionesdentrodelmismopaquete(cdigo 7.11).NovaleparaelISE................................................................................................................................................... 89 Cdigo7.13:Funcinparaelredondeo ............................................................................................................................................... 90 Cdigo7.14:Constanteconelperiododelrelojennanosegundos ................................................................................................. 93 Cdigo7.15:Modificacindelprocesodelrelojparaquesufrecuenciadependadeconstantes .............................................. 94 Cdigo7.16:Esperaraquehayaunflancodesubidadelreloj......................................................................................................... 95 Cdigo7.17:Nombredelanuevaentidadparaelbancodepruebas........................................................................................... 102 Cdigo7.18:Declaracindeuntipodedatosqueesunvectordestd_logic_vector(slv)ylaconstanteconlos datosaprobar ................................................................................................................................................................... 102 Cdigo7.19:Asignacindelvalordelndicecerodelaconstante................................................................................................ 102 Cdigo7.20:Negamoslosbitsdelsegundoenvo ........................................................................................................................... 103 Cdigo7.21:Tiempoquetranscurreenenviarunbit ..................................................................................................................... 104 Cdigo7.22:Esperaalflancodebajadadelasealfpga_tx ....................................................................................................... 107 Cdigo7.23:Ejemplodeunasentenciaassert .............................................................................................................................. 108 Cdigo7.24:Sentenciaassertparaelbit0delprimerenvo ...................................................................................................... 109 Cdigo7.25:Bucleforparacomprobartodoslosbitsdeldato.................................................................................................... 109 Cdigo7.26:Modificacindelcdigo7.25paraquecomparelosbitssegnelnmerodeenvo .......................................... 110 Cdigo7.27:DeclaracindelavariablenumenviodentrodelprocesoP_Receptor ............................................................. 111 Cdigo7.28:Incrementodelavariablenumenvio.......................................................................................................................... 111 Cdigo7.29:Modificacindelprocesodelreceptordelbancodepruebasparaquesedetengaenlaltimarecepciny generelasealdeavisodelfindelasimulacin ........................................................................................................ 112 Cdigo7.30:Modificacindelprocesodelrelojparadetenerlasimulacin............................................................................... 112 Cdigo7.31:Asignacindeunhexadecimalaunvectorde8bits................................................................................................ 115 Cdigo7.32:Declaracindeentidadydiferenciasconladeclaracindecomponente............................................................. 118 Cdigo7.33:Declaracindecomponenteydiferenciasconladeclaracindeentidad............................................................. 118 Cdigo8.1:Llamadaalpaquetenumeric_std,recomendado.................................................................................................... 136 Cdigo8.2:Llamadaalospaquetesstd_logic_arithystd_logic_unsigned,norecomendado,usaremosel delcdigo8.1 .................................................................................................................................................................... 136 Cdigo8.3:Comparacinentretiposunsigned,signedystd_logic_vector ................................................................. 137 Cdigo8.4:Conversindirectaentreelementos(bits)devectoresyconstd_logic ............................................................. 137 Cdigo8.5:Conversincastentresignedyunsignedconstd_logic_vector(delmismorango) .............................. 138 Cdigo8.6:Funcionesdeconversinentresignedyunsignedainteger,usandoelpaquetenumeric_std............. 138 Cdigo8.7:Conversinentreintegerystd_logic_vector.................................................................................................. 139 Cdigo8.8:Asignacindeconstantesaununsignedyusodeconstantesenoperaciones ................................................... 139 Cdigo8.9:Sumadetiposunsigned sinconsiderarelacarreo.................................................................................................. 139 Cdigo8.10:Sumadetiposunsigned considerandoelacarreodemaneraerrnea .............................................................. 140 Cdigo8.11:Sumaconsiderandoelacarreodetiposunsigned .................................................................................................. 140 Cdigo8.12:Sumadeunsignedconavisodedesbordamiento .................................................................................................. 140 Cdigo8.13:Restadenmerospositivos .......................................................................................................................................... 143 Cdigo8.14:Sumadenmerosenteros ............................................................................................................................................. 144 Cdigo8.15:Restadenmerosenteros ............................................................................................................................................. 144 Cdigo8.16:Sumadetipossignedconsiderandoelacarreo....................................................................................................... 145 Cdigo8.17:Sumadetipossignedconsiderandoelacarreoyutilizandolafuncinresize .............................................. 145 Cdigo8.18:Sumadetipossignedconsiderandoelacarreoyutilizandolafuncinresizeconelatributolength.... 145 Cdigo8.19:Productodedosunsignedproduceununsignedconunnmerodebitsresultadodelasumadel nmerodebitsdelosfactores........................................................................................................................................ 147 Cdigo8.20:Productoporunaconstantederangomayor.Errneo ............................................................................................ 148 Cdigo8.21:Productoporunaconstantederangomayor.Correcto ........................................................................................... 148 Cdigo8.22:Multiplicacincombinacionalconsentenciasconcurrentes.................................................................................... 150 Cdigo8.23:Asignacininvirtiendoelordendelosbits................................................................................................................ 151 Cdigo8.24:Asignacininvirtiendoelordendelosbitsusandolasentenciagenerate ....................................................... 151 Cdigo8.25:Multiplicadorcombinacionalgenrico ....................................................................................................................... 152 Cdigo8.26:Bancodepruebasparaelmultiplicadorcombinacionalgenrico.......................................................................... 153 Cdigo8.27:Multiplicadorestructural .............................................................................................................................................. 155 Cdigo8.28:Multiplicadorestructuralgenrico .............................................................................................................................. 156 Cdigo8.29:Multiplicadorsegmentadogenrico............................................................................................................................ 165 Cdigo8.30:Multiplicadorsecuencialgenrico ............................................................................................................................... 169 Cdigo9.1:PaqueteconladefinicindelasconstantesdelcontroladorVGA........................................................................... 182 Cdigo9.2:Procesoqueasignacoloressegnelpxel .................................................................................................................... 185 Cdigo12.1:MemoriaROMde256posicionesyunbitdeanchodepalabra ............................................................................ 207 Cdigo12.2:Clculodeladireccindememoriaconmultiplicacin .......................................................................................... 210 Cdigo12.3:Dibujarlaimagendemanerarepetida........................................................................................................................ 213
12
Cdigo12.4:MemoriaROMde16posicionesy16bitsdeanchodepalabra ..............................................................................216 Cdigo12.5:MemoriaROMde10x10y256coloresgrises .............................................................................................................218 Cdigo12.6:Asignacindelvalordeldatodelamemoriade8bitsdegrisaloscoloresdelaXUP ......................................219 Cdigo12.7:Asignacindelvalordeldatodelamemoriade8bitsdegrisaloscoloresdelaNexys2 .................................219 Cdigo12.8:MemoriaROMde10x10y256colores.........................................................................................................................219 Cdigo12.9:Asignacindelvalordeldatodelamemoriade8bitsdecoloraloscoloresdelaXUP(enproceso secuencial) ..........................................................................................................................................................................220 Cdigo12.10:Asignacindelvalordeldatodelamemoriade8bitsdecoloraloscoloresdelaNexys2.............................220 Cdigo12.11:MemoriaRAMdedoblepuerto,unodeescrituraylectura(modowritefirst)yelotrodeslolectura.......221 Cdigo12.12:ProcesodelamemoriaRAMdedoblepuerto,unodeescrituraylectura(modoreadfirst)yelotrode slolectura .........................................................................................................................................................................221 Cdigo15.1:ConstantedelaROMparadibujarelpacmanadoscolores ..................................................................................251 Cdigo15.2:ConstantedelaROMparadibujarellaberinto(mitad)............................................................................................252
13
ndice de tablas
Tabla2.1:Valoresdelstd_logic ........................................................................................................................................................ 20 Tabla7.1:PuertosdelRS232queusaremosylospinesenlasplacas ............................................................................................ 79 Tabla7.2:ConstantesdelaUARTparasuconfiguracin................................................................................................................. 81 Tabla7.3:PuertosdeltransmisordelaUART .................................................................................................................................... 81 Tabla7.4:Tabladeestados,entradasysalidasdeltransmisordelaUART .................................................................................. 92 Tabla7.5:PuertosdeINTERFAZ_PBysucorrespondenciaconlospulsadoresdelastarjetasyeldatoquetienenque enviaraltransmisor ......................................................................................................................................................... 114 Tabla7.6:PuertosdelreceptordelaUART....................................................................................................................................... 130 Tabla8.1:Nmerosencomplementoadosde4bitsysucorrespondientedecimal ................................................................. 146 Tabla8.2:Variacindereayretardosconelnmerodebitsdelosfactoresdelmultiplicadorcombinacionaldel apartado8.8.3paralaNexys2 ........................................................................................................................................ 162 Tabla8.3:Variacindereayretardosconelnmerodebitsdelosfactoresdelosmultiplicadoresembebidosdela Nexys2(cdigo8.19) ........................................................................................................................................................ 162 Tabla8.4:Variacindereayretardosconelnmerodebitsdelosfactoresdelosmultiplicadoressegmentados (cdigo8.29) ...................................................................................................................................................................... 166 Tabla8.5:Variacindereayretardosconelnmerodebitsdelosfactoresdelosmultiplicadoressecuenciales (cdigo8.30) ...................................................................................................................................................................... 169 Tabla9.1:Valoresparadiversasresolucionesdepantalla .............................................................................................................. 177 Tabla9.2:PuertosdelconversorVGAdelaXUPV2P ..................................................................................................................... 178 Tabla9.3:PuertosdelconversorVGAdelaNexys2........................................................................................................................ 179 Tabla9.4:Caractersticasdelospuertosdelmdulodesincronizacin.Elrestodepuertosestnenlastablas9.2y9.3... 180 Tabla11.1:ComunicacinentreelratnylaFPGAhastahabilitarlatransmisindedatosdelratn .................................. 198 Tabla12.1:ConfiguracionesdelasBRAM......................................................................................................................................... 203 Tabla12.2:TamaomximodelamemoriausandotodaslasBRAMdelaFPGAsegnelanchodepalabra..................... 203 Tabla12.3:TamaomximodelasimgenessegnelnmerodeimgenesquesevanaguardarenlasBRAM.Para imgenesde8bitsporpxel. .......................................................................................................................................... 204 Tabla12.4:ListadodepuertosdelaBRAMdedoblepuerto ......................................................................................................... 205
14
1. Introduccin
El objetivo de este manual es ensear a disear circuitos y sistemas digitales de cierta complejidad usando VHDL y dispositivos lgicos programables (CPLD o FPGA). El enfoqueesaprenderadiseardemaneraprctica,yquelanecesidadderealizaralgonos haga tener curiosidad por los distintos mtodos y tcnicas para una eficiente implementacindelcircuito. EstemanualsehadesarrolladoenelDepartamentodeTecnologaElectrnica[9dte]dela Universidad Rey Juan Carlos para la asignatura Diseo de Circuitos y Sistemas Electrnicos (DCSE [10dcse]) de la titulacin de Ingeniera de Telecomunicacin1. Previamente,losalumnosdeestacarrerahancursadolasasignaturasElectrnicaDigitalI (ED1),ElectrnicaDigitalII(ED2[11ed2])ySistemasElectrnicosDigitales(SED),adems deotrasasignaturasdeelectrnicabsicayelectrnicaanalgica2. En ED1 los alumnos adquirieron los conceptos bsicos de la electrnica digital y realizaron diseos tanto con componentes discretos como con dispositivos lgicos programables.LasprcticasrealizadasconFPGAdeED1estnguiadasenelmanualdela referencia[19mach].Endichasprcticasseenseaadisearcircuitoselectrnicosdigitales con esquemticos y FPGA. As que para seguir este manual suponemos que ya has adquirido los conceptos bsicos de los sistemas de numeracin y electrnica digital: diseo con puertas lgicas, bloques combinacionales, elementos de memoria, registros y contadores.RealizarlasprcticasdeED1[19mach]esunabuenabaseparaesto. Un ao ms tarde, en ED2 los alumnos aprendieron a disear circuitos digitales ms complejos,teniendoquedominarelempleodemquinasdeestadosfinitos(FSM3)parael diseo y anlisis de los circuitos digitales. En la prctica, se pas de disear con esquemticosadisearconellenguajededescripcindehardwareVHDL.Losdiseosde los circuitos digitales de este curso estn recogidos en el manual de la asignatura [17mach]. Ejemplos de los diseos de dicho manual son: cronmetros, el control de mquinasexpendedoras,controldemotores,claveselectrnicas,etc. Por tanto, para seguir este manual con una mayor comprensin se recomienda haber realizado los diseos propuestos en manual de ED2 [17mach]. Este manual est disponible en el archivo abierto de la Universidad Rey Juan Carlos. De todos modos, si slo necesitas un breve repaso de VHDL, el manual que ests leyendo incluye una pequeaintroduccinaestelenguajededescripcindehardware. Como seguramente recuerdes, el VHDL es un estndar del Instituto de Ingenieros Elctricos y Electrnicos4 (IEEE [13ieee]). Existen otros lenguajes de descripcin de hardware como el Verilog o el SystemC. Histricamente, la existencia simultnea del VHDL y Verilog ha dividido a la comunidad de diseadores, lo que ha provocado
1
Esteplandeestudiosempezaextinguirseapartirdelcurso20092010conlaimplantacindelosgradosde Boloniaenelprimercurso Enlareferencia[12educ]seresumeelcurrculumenelectrnicaqueadquierenlosalumnosendichoplande estudios FSM:acrnimodelingls:FiniteStateMachine:Mquinadeestadosfinitos InstituteofElectricalandElectronicsEngineers
3 4
15
dificultades en el intercambio de diseos y a las empresas que fabrican herramientas informticasdeayudaaldiseo(CAD). El VHDL es un lenguaje muy amplio que fue creado para modelar circuitos. Ms tarde se empez a utilizar para disear circuitos, utilizando para ello slo un conjunto reducido del VHDL, lo que se llama VHDL para sntesis [25rtl]. La transformacin de un circuito descrito en VHDL a su esquema en puertas lgicas y biestables se llama sntesis. Esta sntesis la realizan automticamente las herramientas CAD, lo que hace ahorrar mucho tiempo a los diseadores de circuitos. De la misma manera que en el manual de ED2 [17mach], en este manual no aprenderemos a utilizar la totalidad del VHDL, sino que usaremos un conjunto restringido del lenguaje orientado a sntesis. Lo que es ms, tampoco usaremos todo el conjunto de VHDL para sntesis, sino que utilizaremos lo que vayamos necesitando. Por suerte o por desgracia, en VHDL una cosa se puede describir de muchas maneras distintas. Por lo general, en este manual propondremos slo una de ellas. Para realizar las prcticas propuestas en este manual se utilizarn dos tarjetas basadas en FPGAdeXilinx[29xilinx]:laXUPVirtexIIpro[31xup]ylaNexys2[21nexys].Actualmente Xilinx es el mayor fabricante de FPGA seguido de Altera. Xilinx proporciona una herramienta de diseo asistido por ordenador (CAD) gratuita: el ISE Webpack [16ise] que ser la que se use en este manual. Para la simulacin, se utilizar el propio simulador del ISEoelModelsim[20model].Sinembargo,aunqueconunesfuerzomayor,podrsseguir este manual usando herramientas y tarjetas diferentes si te abstraes de las particularidadesdestas. Al realizar este manual hemos intentado buscar un punto intermedio entre dar una solucin a cada prctica planteada, y dejarte slo y sin ayuda para que encuentres tu propia solucin. As que hemos intentado dar un nmero de pautas suficientes para que puedas realizar el diseo por ti mismo sin que te sobrepase la dificultad, o que por el contrario, copies y pegues la solucin propuesta sin que te suponga un reto o que no te estsdandocuentadeloqueestshaciendo.Encontraresepuntointermedionoesfcil,y puede ser que a veces te parezca que el grado de detalle es excesivo, o que por el contrario, necesites ms ayuda. En ambos casos, te pedimos que entiendas la dificultad que nos supone encontrar ese punto medio, y que adems no es el mismo para todos los quevanaleerestemanual. Las primeras prcticas son ms detalladas y conforme se avanza se proporciona menos informacin de detalle y se incide en los aspectos ms generales de cmo abordar el diseo. Las prcticas son de dificultad incremental y por este motivo te recomendamos que sigas el orden establecido. A veces se incluyen apartados opcionales, que puedes saltrtelossiaslodeseas.Estosapartadossehansealadoconelsmbolo. Esmuyimportantequeparaseguirestemanualrealiceslasprcticasylasimplementes,y no te limites a leerlas. Ya sabes que la prctica no siempre es igual que la teora. Tambin te recomendamos que intentes pensar un tu propia solucin antes de mirar las guas ofrecidas para abordar el diseo. Pensar en una solucin y compararla con la que aqu se proponeteayudaraaprenderadisear. Por ltimo, con el fin de que este manual pueda llegar al mayor nmero de personas y con el objetivo de generar material educativo abierto, hemos publicado este manual bajo una licencia Creative Commons [5cc] que permite su copia y distribucin. Hemos puesto el
16
1. Introduccin
libro en el archivo abierto de la Universidad Rey Juan Carlos y se puede acceder a l desde el siguiente enlace http://hdl.handle.net/10115/5700, en donde adems de este libro puedes descargar algunos ficheros VHDL de las prcticas de este libro. Estos ficheros tambinestndisponiblesenelenlace[28web] Esperamos que disfrutes de su lectura y que te ayude a aprender a disear circuitos y sistemas electrnicos digitales. Para ir mejorando el manual, agradeceremos la comunicacin de comentarios, sugerencias y correcciones a las direcciones de correo electrnicodelosautores. felipe.machado@urjc.es,susana.borromeo@urjc.esycristina.rodriguez.sanchez@urjc.es
17
2. Repaso de VHDL para sntesis

En este captulo repasaremos descripciones simples de VHDL sintetizable. Aunque suponemos que se conocen los conceptos aqu explicados, este captulo se podr usar como referencia para algunas de las construcciones VHDL ms tpicas. Si tienes dudas o quieres repasar con ms profundidad lo que aqu se dice te recomendamos un manual msbsico[17mach]. El VHDL es un lenguaje muy amplio y fue concebido inicialmente para modelado y simulacin,noparasntesis.Portanto,notodaslasdescripcionesVHDLsonsintetizables, estoes,notodaslasdescripcionestienenunaequivalenciaenelniveldepuertas.Porotro lado,unamismafuncionalidadpuededescribirsedemuchasmaneras. Es por esto que este captulo no pretende ser un manual exhaustivo del VHDL, sino dar recetas para facilitar el diseo en VHDL. Todos los ejemplos de este manual se pueden describirdeotramanera. Antes de empezar con los ejemplos recordemos que el VHDL no distingue entre maysculas y minsculas. De todos modos, por claridad se recomienda mantener una misma forma de escribir. Esto es, si por ejemplo se ponen los operadores en maysculas, sera recomendable que se mantuviesen as entodo el diseo, lo mismo es vlido para los nombresdeseales. Hay un conjunto de palabras reservadas que no se deben usar para otros propsitos (por ejemploparanombresdeseales).stasson:
Figura 2.1: Lista de palabras reservadas del VHDL
A continuacin veremos una serie de ejemplos de diseos VHDL de dificultad incremental.
19
2.1. Puerta AND

Para disear un circuito en VHDL lo mnimo que se necesita es una entidad y una arquitectura. La entidad define el circuito como una caja, con sus puertos de entrada y salida. Mientras que la arquitectura describe el interior del circuito. Una misma entidad puedetenervariasarquitecturas. As,siqueremosdescribirunapuertaANDenVHDL,crearemoslaentidad:
library IEEE; use IEEE.STD_LOGIC_1164.ALL; entity PUERTA_AND is port ( A : in std_logic; B : in std_logic; C : out std_logic ); end;
A C B
PUERTA_AND PUE RTA_AND
Figura 2.2: Representacin de la entidad VHDL
Cdigo 2.1: Entidad en VHDL
Hayvariascosasquesedebenresaltar: LaentidadnosepodrallamarANDyaqueesunapalabrareservada(verfigura2.1). Aunque la entidad se llame PUERTA_AND, simplemente representa su nombre, pero no su funcionalidad. Que tenga ese nombre no significa que vaya a tener que funcionar como una puerta AND. Depender de lo que se describa en la arquitectura. Sin embargo, comoes lgico,noesrecomendableponerleunnombrequenodescribasufuncionalidad. Lospuertosdeentradasehandeclaradodetipostd_logic.Esteesuntipodedatosdeun solo bit que puede tener valores distintos de 0 y 1. Y se usan as para tener ms informacinenlasimulacin.Losvaloresquepuedetenerunstd_logicson:
'X':Harecibidovaloresdistintos(desconocidofuerte) 'Z':Altaimpedancia 'H':Unodbil '0':Cerolgico(cerofuerte) 'W':Desconocidodbil '-':Noimporta
'U':Noharecibidovalor '1':Unolgico(unofuerte) 'L':Cerodbil
Tabla 2.1: Valores del std_logic
Alternativamente se podan haber declarado como tipo bit. El tipo bit slo tiene los valores 0 y 1. Sin embargo es ms recomendable utilizar el tipo std_logic, pues en simulacin, es importante saber si la seal no ha recibido valor ('U'), si est recibiendo valoresdistintosenunmismotiempo('X')ositomaelvalordealtaimpedancia('Z')que veremosenelapartado11.2.4. Parapoderusareltipostd_logichayqueindicarqueseusaelpaquetestd_logic_1164,y estosehaceconlasdoslneasqueestnantesdelaentidad(vercdigo2.1). Como hemos dicho, por ahora nuestra entidad no hace nada, simplemente hemos definidosusentradasysalidas.Paradescribirsufuncionalidadusamoslaarquitectura:
20
architecture BEHAVIORAL of PUERTA_AND is begin C <= A and B; end BEHAVIORAL;
PUERTA_AND A C B
Cdigo 2.2: Arquitectura en VHDL
Figura 2.3: Representacin de la arquitectura VHDL
El nombre de la arquitectura es BEHAVIORAL (comportamental). Normalmente se pone un nombre que describa el nivel de abstraccin de la descripcin, que puede ser dataflow, functional,RTL,...Peronotieneporquserunodeestos. Delcdigopodemosdeducirquelaasignacindesealesserealizamedianteeloperador: <=".
2.2. Varias puertas

LaspuertasdisponiblesenVHDLson:AND,NAND,OR,NOR,XOR,XNOR,NOT. Para implementar un circuito con varias puertas, stas se pueden poner en la misma expresin. Por ejemplo, en el cdigo 2.3 se muestra una arquitectura que tiene una nica sentencia con todas las puertas. Para simplificar, en el cdigo no se ha incluido la entidad (yasseharenlosejemplossucesivosanoserqueseanecesario).
architecture UNO of PUERTAS is begin Z <= (not(A or B)) xor C; end UNO;
A B C Z
Existen reglas de precedencia entre los operadores, pero lo ms seguro es poner parntesis, puesto que adems de facilitar la lectura, nos aseguramos que lo estamos describiendocorrectamente. Se puede realizar un circuito equivalente al cdigo 2.3 en dos sentencias, para ello es necesariousarsealesauxiliares:
architecture DOS of PUERTAS is signal AUX : std_logic; begin AUX <= not(A or B); Z <= AUX xor C; end DOS;
A B C
AUX
Un concepto muy importante en hardware y por tanto en VHDL es la concurrencia. Esto implica que no importa el orden de las sentencias que estn en el cuerpo de una arquitectura, ya que el hardware se ejecuta concurrentemente: El hardware siempre se estejecutando.Asqueelcdigo2.4esequivalentealsiguientecdigo:
architecture TRES of PUERTAS is signal AUX : std_logic; begin Z <= AUX xor C; -- Ahora esta sentencia se ha puesto antes que la siguiente AUX <= not(A or B); -- en VHDL el orden de sentencias concurrentes es indiferente end TRES;
Cdigo 2.5: Arquitectura equivalente a la del cdigo 2.4
Antesdeseguir,asegratequeentiendesporquloscdigos2.4y2.5sonequivalentes.
21
2.3. Multiplexor
El multiplexor selecciona entre varias alternativas segn el valor de la seal de seleccin. ParaelloelVHDLofrecevariasconstruccionesposibles. Sepuederealizarmedianteunasentenciaconcurrenteenlaqueseincluyacondicin:
architecture UNO of MUX is
A
begin Z <= A when Sel='1' else B; end UNO;
1 Z 0
Cdigo 2.6: Arquitectura de un multiplexor en VHDL
Sel
Otra manera de realizar un multiplexor es mediante el uso de procesos. Dentro de un procesolaejecucindelassentenciasessecuencial:

architecture DOS of MUX is begin P_MUX: process (A,B,Sel) begin if Sel='1' then Z <= A; else Z <= B; end if; end process; end DOS; -- (A,B,Sel) es la lista de sensibilidad
Cdigo 2.7: Arquitectura equivalente de un multiplexor en VHDL
En el cdigo 2.7 se muestra un multiplexor equivalente. Para ello se ha usado un proceso, que como se ha dicho, se ejecutan de forma secuencial. Los procesos tienen una lista de sensibilidad,enlaquesetienenqueincluirtodaslassealesledasdentrodelproceso.En estecaso,lassealesledassonA,BySel. Hemosrealizadoelmultiplexorconlasentenciaif,aunqueesmshabitualhacerlaconla sentenciacase.Enestecasonoesmuyimportanteporquelasealdeseleccin(Sel)esde unsolobit.
architecture DOS of MUX is begin P_MUX: process (A,B,Sel) begin case Sel is -- en el case tienen que estar presentes todas las alternativas when '1' => Z <= A; when others => -- si no pongo todas las alternativas, pongo "others" Z <= B; end case; end process; end DOS;
Cdigo 2.8: Descripcin del multiplexor equivalente a la del cdigo 2.7 utilizando la sentencia case
En el cdigo 2.8 se ha descrito un multiplexor con una sentencia case. La sentencia case tienequetenertodaslasalternativas,pudiendohaberunaalternativapordefectollamada "others". Esta alternativa engloba a todas las que faltan. En este caso, como estamos usando datos de tipo std_logic, tenemos que usar el others, ya que hay ms alternativas que0y1(vertabla2.1).
22
2.4. Multiplexor de 2 bits de seleccin

El VHDL permite usar tipos de datos de ms de un bit (vectores). Para los vectores se puede emplear el tipo std_logic_vector. Los vectores se declaran desde el bit ms significativo(demayorndice)hastaelmenossignificativo(alqueseledaelndicecero5). En el cdigo 2.9 se muestra la descripcin de un multiplexor de 2 bits de seleccin (con datosdeunbit).Fjateenladeclaracindelasealdeseleccin:Sel.Paraestasealseusa unstd_logic_vectorcuyorangovade1a0.Elbit1eselmssignificativo.
entity MUX_2B_SEL is port ( A : in std_logic; B : in std_logic; C : in std_logic; Sel : in std_logic_vector (1 downto 0); Z : out std_logic ); end; architecture UNO of MUX_2B_SEL is begin P_MUX: process (A,B,C,SEL) begin case Sel is when "00" => Z <= A; when "01" | "10" => -- mismo valor para Z <= B; -- las 2 opciones when others => Z <= C; end case; end process; end UNO;

A 00 01 B 10 C 11 Z
Sel(1:0)
Figura 2.7: Representacin del multiplexor
Cdigo 2.9: Multiplexor de 2 bits de seleccin
Tambin es interesante ver en el cdigo 2.9 cmo se indica en una sentencia case que dos opcionesdanelmismoresultado.Paraelloseutilizaeloperador|. El proceso del mismo multiplexor descrito con una sentencia if en vez de case quedar como se muestra en el cdigo 2.10.Este cdigoproduce un multiplexor equivalente al del cdigo2.9.
P_MUX_2: process (A,B,C,Sel) begin if Sel = "00" then Z <= A; elsif (Sel = "01") OR (Sel = "10") then Z <= B; else Z <= C; end if; end process;
Cdigo 2.10: Proceso equivalente para el multiplexor de 2 bits de seleccin del cdigo 2.9
2.5. Elementos de memoria: latch6

Para describir un elemento de memoria podemos utilizar un proceso con sentencias condicionalesenelqueenalgunasalternativasdejemoslasealsinasignar.Debidoaque en dichas condiciones no se asigna ningn valor a la seal, sta tendr que guardar el
5 6
Aunquesepuedeponerunndicedistintodecero,noesrecomendable. Unlatchesunelementodememoriacondosposiblesestados(biestable)queesactivopornivel.Lasealque hacequeellatchestactivosesueledenominarenable(habilitacin).
23
valor que anteriormente tena. Para guardar el valor ser necesario utilizar un elemento dememoria. En el cdigo 2.11 se muestra la descripcin de un latch de tipo D activo por nivel alto. Cuando la seal Enable vale 0, la seal Z no recibe valor, y por lo tanto tendr que guardareldatoquetenaantes.
entity LATCH is port ( Enable : in A : in Z : out ); end;
std_logic; std_logic; std_logic

LATCH D A Z
architecture BEHAVIORAL of LATCH is begin P_LATCH: process (Enable, A) begin if Enable = '1' then Z <= A; end if; end process; end BEHAVIORAL;
Enable
Figura 2.8: Latch de tipo D
Cdigo 2.11: Latch de tipo D activo por nivel alto
Esmuyimportantetenerestopresente,yaquecuandohaycondicionesenlasquenosele asigna valor a una seal se genera un latch. A veces stos se generan por error del diseador,quenoseha fijadoqueenalgunaalternativano haasignadoningnvalorala seal. Elcdigo2.11sepuedemodificarparaincluirunasealderesetasncrono(cdigo2.12).
entity LATCH2 is port ( ResetN : in std_logic; Enable : in std_logic; A : in std_logic; Z : out std_logic ); end; architecture BEHAVIORAL of LATCH2 is begin LATCH: process (ResetN, Enable, A) begin if ResetN = '0' then -- activo por nivel bajo Z <= '0'; elsif Enable = '1' then Z <= A; end if; end process; end BEHAVIORAL;

LATCH D A Z
Enable
ResetN
Figura 2.9: Latch de tipo D con reset
Cdigo 2.12: Latch de tipo D activo por nivel alto con reset
FjatequeelresetsehallamadoResetN.ConlaNsehaqueridoindicarqueesactivopor nivelbajo,estoes,quecuandoelresetvalecero,sereseteaellatch.
2.6. Elementos de memoria: biestables activos por flanco

Para describir un elemento de memoria activo por flanco se utilizan las siguientes expresiones:

Parabiestableactivoporflancodesubida:clk'event and clk = '1' Parabiestableactivoporflancodebajada:clk'event and clk = '0'
24
En el cdigo 2.13 se muestra la descripcin de un biestable D activo por flanco de subida. En la lista de sensibilidad de los biestables se puede poner solamente las seales que se asignan (o sean condicin) antes de la sentencia de reloj. No es un error poner todas las seales que influyen, sin embargo puede ser ms cmodo evitarnos poner todas, adems dequehacemosquelasimulacinseamsrpida.
entity BIESTABLE is port ( ResetN : in std_logic; Clk : in std_logic; A : in std_logic; Z : out std_logic ); end; architecture BEHAVIORAL of BIESTABLE is begin P_BIEST:process (ResetN, Clk) --solo reset y clk begin if ResetN = '0' then Z <= '0'; elsif Clk'event and Clk = '1' then Z <= A; end if; end process; end BEHAVIORAL;

FF D A Z
Clk ResetN
Figura 2.10: Biestable de tipo D con reset
Cdigo 2.13: Biestable de tipo D activo por flanco de subida
2.7. Actualizacin de los valores de las seales

En un proceso, el valor de la seal se actualiza al finalizar el proceso y no durante la secuenciadeasignaciones.Enelcdigo2.14,encadaflancodesubidadelreloj,alasealB seleasignaA,yaZseleasignaB.Sinembargo,ZnorecibeelvalordeAdirectamente,sino que recibe el valor que tena B cuando se entr en el proceso y no el que va a recibir. Esto es,aZlellegaelvalordeAconunretardodeunciclodereloj.
entity DETECTA_FLANCO is port ( ResetN : in std_logic; Clk : in std_logic; A : in std_logic; Z : out std_logic ); end; architecture UNO of DETECTA_FLANCO is signal B : std_logic; begin P_DETECTA: process (ResetN, Clk) begin if ResetN = '0' then B <= '0'; Z <= '0'; elsif Clk'event and Clk = '1' then B <= A; Z <= B; -- B no toma el valor de A -- inmediatamente end if; end process; end UNO;

FF D A B FF D Z
Clk ResetN
Figura 2.11: Dos biestables en cascada
Cdigo 2.14: Dos biestables en cascada
En la figura 2.11 se muestra el circuito generado por el cdigo 2.14. Este cdigo es equivalente asignar las seales en diferentes procesos. Esto se muestra en el cdigo 2.15 (sloaparecelaarquitectura).
25
architecture DOS of DETECTA_FLANCO is signal B : std_logic; begin P_BIEST_1: process (ResetN, Clk) begin if ResetN = '0' then B <= '0'; elsif Clk'event and Clk = '1' then B <= A; end if; end process; P_BIEST_2: process (ResetN, Clk) begin if ResetN = '0' then Z <= '0'; elsif Clk'event and Clk = '1' then Z <= B; end if; end process; end DOS;
Cdigo 2.15: Diseo equivalente al cdigo 2.14
A continuacin se muestra cmo con unas pequeas modificaciones del circuito anterior sepuedecrearuncircuitodetectordeflancodesubida7.
entity DETECTA_FLANCO is port ( ResetN : in std_logic; Clk : in std_logic; A : in std_logic; FlancoUp : out std_logic ); end; architecture TRES of DETECTA_FLANCO is -- ahora Z no es de salida signal B, Z : std_logic; begin P_BIEST_1: process (ResetN, Clk) begin if ResetN = '0' then B <= '0'; elsif Clk'event and Clk = '1' then B <= A; end if; end process; P_BIEST_2: process (ResetN, Clk) begin if ResetN = '0' then Z <= '0'; elsif Clk'event and Clk = '1' then Z <= B; end if; end process; FlancoUp <= '1' when Z='1' and B='0' else '0'; end TRES;
Cdigo 2.16: Circuito detector de flanco
Loscircuitosdetectoresdeflancoseexplicanenlareferencia[17mach]
26
FlancoUp
FF D A B
FF D
Clk ResetN
Figura 2.12: Esquema del diseo del cdigo 2.16

clk
A B Z FlancoUp
Figura 2.13: Cronograma del diseo del cdigo 2.16
2.8. Contadores
Para contar podemos utilizar tipos de datos enteros (integer) o naturales (natural). Es muyimportantedefinir elrangodel nmero,porquesinose sintetizarunnmerode32 bits, lo que implica 32 cables. Es tambin importante hacer que el rango sea un nmero potencia de 2. Para que coincida el rango que definimos con el que se sintetizar. Por ejemplo, si creamos un rango de 0 a 13, el sintetizador crear un nmero de 4 bits (de 0 a 15),yporlotanto,nuestronmeropodrtomarvaloresquequedarnfueradelrangoque hemosespecificado(14y15). Uncontadordemdulo8semuestraenelcdigo2.17
entity CONTADOR is port ( rst_n : in std_logic; clk : in std_logic; cuenta : out natural range 0 to 7 ); end CONTADOR; architecture BEHAVIORAL of CONTADOR is signal cuentaaux : natural range 0 to 7; -- rango potencia de 2: 8 (de 0 a 7) begin cuenta <= cuentaaux; -- Se conecta cuentaaux a cuenta P_CONT: Process (rst_n, clk) begin if rst_n = '0' then cuentaaux <= 0; elsif clk'event and clk='1' then if cuentaaux = 7 then -- cuenta no se podria leer por ser puerto de salida cuentaaux <= 0; -- por eso se usa cuentaaux else cuentaaux <= cuentaaux + 1; -- Aqui se lee cuentaaux otra vez end if; end if; end process; end BEHAVIORAL;
Cdigo 2.17: Contador mdulo 8
Enelcdigo2.17hayunnuevoconceptoquesedebetenerencuentaaldisearenVHDL: Los puertos de salida no se pueden leer. Por esto se ha tenido que crear la seal auxiliar
27
cuentaaux. Con cuentaaux se realizan las operaciones, y en una sentencia concurrente se
conectaconlasealcuenta. Para ms una explicacin ms detallada de los contadores se recomienda la referencia [17mach].
2.9. Registros de desplazamiento

Unregistro dedesplazamientosepuededescribir comose muestraenelcdigo2.18.Este circuitocargaenparaleloeldatodatoincuandocarga='1'.Ydesplazaeldatoatravsdel bit0enserie. Una vez ms se recomienda la referencia [17mach] para profundizar en los registros de desplazamiento.
entity REG_DESPLZ is port ( rst_n : in clk : in carga : in desplz : in datoin : in serieout : out ); end REG_DESPLZ; std_logic; std_logic; std_logic; std_logic; std_logic_vector (7 downto 0); std_logic
architecture BEHAVIORAL of REG_DESPLZ is signal datoreg : std_logic_vector (7 downto 0); begin serieout <= datoreg(0); REG_DESPLZ:Process (rst_n, clk) begin if rst_n='0' then datoreg <= (others=>'0'); elsif clk'event and clk='1' then if carga = '1' then datoreg <= datoin; -- Carga paralelo elsif desplz ='1' then -- Desplazamiento datoreg(6 downto 0) <= datoreg(7 downto 1); end if; end if; end process; end architecture;
Cdigo 2.18: Registro de carga paralelo y salida serie
2.10. VHDL estructural

Para disear un circuito grande es conveniente separarlo en bloques funcionales. Cada uno de estos bloques se disea como hemos visto hasta ahora (entidad y arquitectura). Y estos bloques se juntan en una arquitectura que hace referencia a estos bloques. Habitualmente este tipo de arquitectura se denomina Estructural. En un diseo grande puedehabervariosnivelesdejerarqua,dondeunasarquitecturasestructuralescontienen aotras.Lasventajasderealizareldiseodeestamanerasonvarias: Permite dividir el circuito en partes ms sencillas, haciendo que el diseo sea ms manejableyentendible.Estoademsfacilitaeltrabajoenequipo. Esfcilmodificaralgnbloquedeldiseo,mientrasquesedejaelrestoigual. Puedepasarqueenundiseosenecesiteusarvariosbloquesiguales,realizandoeldiseo estructural, no hace falta volver a repetir el bloque, sino que basta con describir varias referenciasaesebloque.
28
Permitelareutilizacinyaquepuedequeunbloquedeundiseolonecesitemosparaotro diseo. Podemos ir probando cada uno de los bloques al irlos diseando y una vez comprobado quefuncionanbien,irlosuniendo.
Para explicar cmo se describe una arquitectura estructural en VHDL lo haremos con un ejemplo.Supongamosquevamosarealizaruncircuitoconlossiguientescomponentes: Elmultiplexordelafigura2.6(elcdigodelaarquitecturaestenelcdigo2.7) Dosbiestablescomoeldelafigura2.10(cdigo2.13) Elregistrodedesplazamientodelcdigo2.18.
Elesquemadelcircuitoestructuralquequeremosrealizarsemuestraenlafigura2.14.En ste se han dibujado los bloques internos del circuito como cajas. Cada bloque tiene un nombre REFERENCIA:ENTIDAD. El primer nombre (REFERENCIA) indica el nombre nico que identifica a ese bloque en particular. El segundo nombre indica el componente al que se refiere (el nombre de la entidad). Puede que un componente se utilice ms de una vez, entonces este nombre estar repetido (como es el caso del BIESTABLE). Por tanto, la referencia ser nica, aunque un mismo componente se utilice ms de una vez. La referencia a veces se llama instancia o instanciacin, ya que en ingls se llama component instantiation.
TOP_1 COMP_REG_DESPLZ:REG_DESPLZ
Carga
Carga
Desplz Dato8bIn(7:0)
8
Desplz Dato8bIn(7:0) Clk RstN SerieOut RegDesplzOut
nombre de la referencia (nombre nico) nombre de la entidad a la que hace referencia

COMP_MUX:MUX A Z B
BIEST_DATO:BIESTABLE
Dato1bIn Clk RstN
A Clk ResetN Z
Dato1bReg
Salida
BIEST_SEL:BIESTABLE
Sel
A Clk ResetN
SelReg SEL
Figura 2.14: Esquema del circuito estructural
El cdigo VHDL del circuito de la figura 2.14 se muestra en el cdigo 2.19. Dentro de la parte declarativa de la arquitectura (antes de su begin) se declaran los componentes que se van a utilizar. Esta declaracin de los componentes es similar a la descripcin de la entidaddelcomponente.Fjatequesedeclarantrescomponentesenvezdecuatro,yaque hay uno (BIESTABLE) que se usa dos veces. En esta parte declarativa se declaran tambin lassealesinternasqueharnlasconexiones(SelReg,Dato1bReg,RegDezplzOut). En la partede sentencia de la arquitectura (despus del begin) se ponenlas referencias de los componentes. Estas referencias especifican las conexiones de los puertos del componente con las seales y puertos de la arquitectura. En la referencia al componente,
29
su nombre debe ser nico: COMP_REG_DESPLZ, BIEST_DATO, BIEST_SEL, COMP_MUX. Y a continuacin, despus de dos puntos, va el nombre del componente (entidad). Encaso de que se utilice un mismo componente dos veces (como ocurre con BIESTABLE) este nombre estarrepetido. En VHDL se puede utilizar un componente con un nombre distinto a la entidad a la que se refiere. Para ello hay sentencias que lo especifican. Sin embargo, no todos los sintetizadores contemplan esta posibilidad, y lo ms recomendable es declarar los componentes(ysuspuertos)conelmismonombrequesuentidad. El VHDL tambin permite especificar qu arquitectura elegir para el componente (si hubiese ms de una), sin embargo, muchas herramientas cogen automticamente la ltimaarquitecturacompiladaindependientementedesiseespecificaotraarquitectura.
entity TOP_1 port ( RstN Clk Carga Desplz Sel Dato1bIn Dato8bIn Salida ); end TOP_1; is : : : : : : : : in in in in in in in out std_logic; std_logic; std_logic; std_logic; std_logic; std_logic; std_logic_vector (7 downto 0); std_logic
architecture ESTRUCTURAL of TOP_1 is -- Declaracion del componente registro de deplazamiento component REG_DESPLZ port ( RstN : in std_logic; Clk : in std_logic; Carga : in std_logic; Desplz : in std_logic; DatoIn : in std_logic_vector (7 downto 0); SerieOut : out std_logic ); end component; -- Declaracion component MUX port ( A : in B : in Sel : in Z : out ); end component; del componente multiplexor
std_logic; std_logic; std_logic; std_logic
-- Declaracion del componente biestable component BIESTABLE port ( ResetN : in std_logic; Clk : in std_logic; A : in std_logic; Z : out std_logic ); end component; -- Declaracion de las signal RegDesplzOut signal Dato1bReg signal SelReg senales que realizan las interconexiones : std_logic; : std_logic; : std_logic;
30
begin -- Referencia al componente RG_DESPLZ, la referencia se llama COMP_REG_DESPLZ COMP_REG_DESPLZ: REG_DESPLZ port map ( --(Puerto interno del componente) => (Senal o puerto de arquitectura) RstN => RstN, Clk => Clk, Carga => Carga, Desplz => Desplz, DatoIn => Dato8bIn, SerieOut => RegDesplzOut ); -- Referencia al componente Biestable BIEST_DATO: BIESTABLE port map ( ResetN => RstN, Clk => Clk, A => Dato1bIn, Z => Dato1bReg ); -- Segunda referencia al componente Biestable BIEST_SEL: BIESTABLE port map ( ResetN => RstN, Clk => Clk, A => Sel, Z => SelReg ); COMP_MUX: MUX port map ( A => B => Sel => Z => ); end architecture;
RegDesplzOut, Dato1bReg, SelReg, Salida
Cdigo 2.19: Ejemplo de diseo estructural
Enelapartado7.6.3veremosotroejemplodediseoestructural.
31
3. Funcionamiento bsico de las tarjetas electrnicas

El objetivo de esta prctica guiada es introducir y empezar a usar la placa XUP VirtexII Pro (XUPV2P) [31xup] y la placa Nexys 2 [21nexys] mediante el uso de funcionalidad elementalyautilizadaenotrasasignaturas,comosonlospulsadores,interruptoresyLED. En el apartado siguiente veremos las caractersticas generales de estas dos tarjetas. Posteriormente implementaremos un diseo sencillo para asegurarnos de que llevamos a cabo todo el proceso de diseo con normalidad. Este paso es importante antes de seguir condiseosmscomplejos.
3.1. Tarjetas XUPV2P y Nexys2

La tarjeta utilizada en clase ser la XUPV2P de la empresa Digilent [8digi]. A fecha de la redaccin de este manual, esta tarjeta ha dejado de producirse aunque se sigue vendiendo. Esta tarjeta tiene un importante descuento importante si se va a utilizar con finesacadmicos. Tambin explicaremos cmo utilizar la tarjeta Nexys2, que es ms sencilla, tiene un precio msasequibleysigueenproduccin. Cuando tengas las tarjetas, debes evitar tocar los componentes metlicos y conexiones para no daar los circuitos por la electricidad esttica de nuestro cuerpo, ni siquiera estandodesconectadadelafuente.
3.1.1. La tarjeta XUPV2P

Antes de iniciar la prctica se recomienda observar la placa y se identificar fsicamente cadaunadeloscomponentessealadosenlafigura3.1. La tarjeta XUPV2P tiene una FPGA de Xilinx de modelo VirtexII Pro 30. Esta FPGA tiene 30816celdaslgicas8ymsde500pinesdisponiblesparaelusuario,apartedebloquesde memoria,multiplicadoresyotrosbloques. A medida que vayamos avanzando, iremos viendo los componentes de la placa, as como algunosdelosbloquesinternosdelaFPGA.
UnaceldalgicaconsisteenunaLUT(LookUpTable)de4entradas,unbiestableylgicadeacarreo
33
Alimentacin Interruptor de alimentacin Puerto de video XSGA Platform flash para guardar la configuracin USB2 para configuracin Tarjeta compact flash Interruptores de configuracin Puertos de ratn y teclado PS/2 Puerto serie RS-232
Conectores SATA para E/S serie gigabit 10/100 Ethernet MAC/PHY Estereo Audio via AC97 codec Pulsadores, interruptores y leds
Figura 3.1: Placa XUP Virtex-II Pro (XUPV2P) utilizada en la asignatura
En las prcticas de este captulo se utilizarn los pulsadores, interruptores y LED que la XUPV2P dispone para uso general. La placa adems dispone de otros pulsadores, interruptores y LED que tienen una funcionalidad especfica. En la parte baja de la figura 3.1,bajoelepgrafePulsadores,interruptoresyledspuedesverdndeestnlosquevamos autilizar. En la figura 3.2 se muestran las conexiones en la placa de los pulsadores, interruptores, y LED. Analizando la figura podemos observar que al pulsar o conectar un interruptor enviamos un 0 al pin de la FPGA, y de manera anloga, los LED se encienden al poner un0enelpindelaFPGAcorrespondiente.Porlotanto,enlatarjetaXUPV2Psetrabaja con lgica negada con los pulsadores, interruptores y LED. Veremos que esto es muy importantetenerloencuenta,sobretodositrabajamossimultneamenteconlaNexys,que notienelgicanegada. En la figura tambin se indican los pines de la FPGA que se conectan a los pulsadores, interruptores y LED. Como se puede apreciar, los pulsadores no tienen circuitera de anulacinderebotes9,porloquehabruntransitorioantesderecibirelvalordefinitivo.
Laanulacinderebotesseexplicaenelmanual[17mach]
34
Pulsadores
3,3V
SW2 SW3 SW4 SW5 SW6 Virtex-II Pro
Interrruptores
2,5V
SW7
LED
3,3V
D7 D8 D9 D10
Virtex-II Pro 3,3K
AG5: AH4: AG3: AH1: AH2:
PB_ENTER PB_UP PB_DOWN PB_LEFT PB_RIGHT
3,3K
on
AC11: AD11: AF8 : AF9 :
SW_0 SW_1 SW_2 SW_3
130 Virtex-II Pro
AC4: AC3: AA6: AA5:
LED_0 LED_1 LED_2 LED_3
Sin pulsar -> 1 Pulsado -> 0
OFF -> 1 ON -> 0
1 -> Apagado 0 -> Encendido
Figura 3.2: Conexiones de los pulsadores, interruptores y LED de propsito general en la placa XUPV2P
3.1.2. La tarjeta Nexys2

La tarjeta Nexys2 [21nexys] se parece a la tarjeta Basys [3basys] (explicada en la referencia [17mach]).Enlafigura3.3semuestranalgunosdesuscomponentesmsimportantes. La Nexys2 contiene una FPGA de Xilinx modelo Spartan3E XC3S500E XC3S1200E con encapsulado FG320. Estas FPGA tienen respectivamente 500000 1200000 puertas lgicasequivalentes. La placa Nexys2 tiene algunos perifricos similares a la XUP2P, por ejemplo: 8 LED (XUPV2P tiene 4), 4 pulsadores (XUPV2P tiene 5), 8 interruptores (XUPV2P tiene 4), un puerto PS/2 (XUPV2P tiene 2), un puerto VGA (XUPV2P tiene uno de mejores caractersticas) y un puerto de alta velocidad. Ambas tienen memoria pero de distinto tipo. LaXUPV2PtienepuertoparaconectarEthernet,unatarjetaCompactFlash,audioySATA, que son puertos que no tiene la Nexys2. Por otro lado, la Nexys2 tiene cuatro displays de sietesegmentosyconectoresPMOD10.
10
AlosconectoresPMODselepuedenconectardispositivosmuyvariados:pantallasdecristallquido, circuitoscontroldemotores,antenas,joysticks,amplificadoresdeaudio,micrfonos,etc.Sepuedenveren http://www.digilentinc.com/Products/Catalog.cfm?NavPath=2,401&Cat=9
35
Jumpers de seleccin alimentacin
Interruptor para encender la tarjeta
Conectores PMOD
memoria
Jumpers de seleccin ROM-JTAG
VGA
FPGA
Puerto serie
Puerto de expansin de alta velocidad
USB
LEDs Displays 7 segmentos
PS/2
Interruptores
Pulsadores
Figura 3.3: Placa Nexys2 con la que de manera alternativa se puede seguir este manual
En la figura 3.4 se muestran las conexiones en la placa de los pulsadores, interruptores y LED. Analizando la figura podemos observar que al pulsar o conectar un interruptor enviamos un 1 al pin de la FPGA, y de manera anloga, los LED se encienden al poner un 1 en el pin de la FPGA correspondiente. Por lo tanto, en la tarjeta Nexys2 se trabaja con lgica directa con los pulsadores, interruptores y LED. Esto es lo contrario que ocurreconlaXUPV2P(recuerdalafigura3.2). Como se puede apreciar, los pulsadores tampoco tienen circuitera de anulacin de rebotes.EnlafiguratambinseindicanlospinesdelaFPGAqueseconectanastos.
Pulsadores
3,3V 10 k Spartan3E PIN pulsador B18 BTN0 D18 BTN1 E18 BTN2 H13 BTN3 3,3V 10 k
Interruptores
Spartan3E PIN G18 H18 K18 K17 L14 L13 N17 R17 interruptor SW0 SW1 SW2 SW3 SW4 SW5 SW6 SW7 390
LED
Spartan-3E PIN J14 J15 K15 K14 E17 P15 F4 R4 LED LD0 LD1 LD2 LD3 LD4 LD5 LD6 LD7
10 k
Pulsado '1' Sin pulsar '0'
ON '1' OFF '0'
'1' Encendido '0' Apagado
Figura 3.4: Conexiones de los pulsadores, interruptores y LED de propsito general en la placa Nexys2
36
3.2. Encender los leds

En esta primera prctica se realizar un circuito muy simple para asegurarnos de que funcionael procesode programacindelaFPGAylaplaca,yasdescartarposiblesfallos del diseo. Los leds nos mostrarn si nuestro circuito funciona correctamente. Aunque esta prctica se explica con cierto detalle, si ves que te cuesta seguirla te recomendamos que consultes antes la referencia [17mach], donde se explica con ms profundidad todo el proceso. Para este ejemplo se detallar el proceso de diseo con la herramienta ISE de Xilinx, usandolaversin9.2delISEWebPACK11. Para comenzar crearemos un proyecto nuevo, primero arrancamos el programa Xilinx Project Navigator, que se encuentra en InicioTodos los ProgramasXilinx ISE 9.2iProject Navigator. Nos puede aparecer una ventana con el Tip of the day que son indicaciones que hace la herramientas cada vez que la arrancamos. Pinchamos en OK, con lo que se cierra dicha ventana. Normalmente la herramienta abre el ltimo proyecto con que se ha estado trabajando, si esas,locerramospinchandoen:FileClose Project. Para crear el nuevo proyecto, se pincha en FileNew Project. y nos saldr la ventana New ProjectWizardCreateNewProjectcomolamostradaenlafigura3.5.Enellapondremosel nombre del proyecto, que lo llamaremos led1, indicamos la ruta donde guardaremos el proyecto (Project location), que ser C:/practicas/dcse/tunombre. Respecto al nombre y a laruta,esconveniente: NotrabajardesdeundispositivodememoriaUSB12. No incluir espacios en la ruta, por tanto, esto incluye no trabajar en el "Escritorio" ni en
"Mis documentos"
No incluir en la ruta o en el nombre acentos ni ees, ni caracteres extraos, ni nombres muylargos,lomsconvenienteeslimitarseacaracteresalfanumricos,yusarelguinbajo envezdelespacio.
Para el ltimo recuadro de la ventana, donde pone TopLevel Source Type seleccionaremos
HDL, ya que nuestro diseo lo haremos mediante lenguajes de descripcin de hardware13. UnavezrellenadoslostresrecuadrospinchamosenNext.
11
Puedeserquealgunadelasventanasmostradasseandelaversin8.2.Estadiferencianodeberadeser transcendente Sieststrabajandoenellaboratorio,alterminarlasesinnoolvidescopiarlosficherosconextensin.vhd y.ucfentumemoriaUSBoentucorreoelectrnico(ocupanmuypoco).Delocontrario,elprximoda puedeserquelosficheroshayandesaparecido. HDL:delingls:HardwareDescriptionLanguage
12
13
37
Figura 3.5: Ventana para crear un nuevo proyecto
A continuacin aparecer otro cuadro de dilogo en el que se pregunta por el tipo de dispositivoquesevaausaryporlasherramientasquesevanautilizaralolargodelflujo dediseo.Segnlaplacaqueutilicemos,laFPGAvaaserdistinta,asquetendremosque distinguir si utilizamos la XUPV2P o la Nexys2. En las figura 3.6 y 3.7 se muestra cmo interpretar las caractersticas de las FPGA de las placas XUPV2P y Nexys2 a partir de sus encapsulados.
tipo de dispositivo encapsulado velocidad
XC2VP30TM FF896 7C
tipo de dispositivo encapsulado velocidad rango de operacin C: comercial
XC3S500ETM FGG320 4C
cdigo de fecha cdigo de lote
Figura 3.6: Interpretacin del texto del encapsulado de la FPGA de la XUPV2P
Figura 3.7: Interpretacin del texto del encapsulado de la FPGA de la Nexys2
A partir de la informacin de los encapsulados de las FPGA tendremos que rellenar la ventanadelafigura3.8. Paralaseleccindelaherramientadesntesisnotenemosalternativa,yparaelsimulador enestaprcticanoesimportanteylodejamosenISE Simulator (VHDL/Verilog),aunquesilo tienes instalado, podras poner el Modelsim. En el lenguaje de descripcin de hardware preferido (Preferred Language) se deja el VHDL, que es el que usaremos. Al terminar pinchamosenNext.
38
XUPV2P Family Device Package Speed Virtex2P XC2VP30 FF896 -7
Nexys2 Spartan3E XC3S500E FG320 -4
Figura 3.8: Ventana para la seleccin del dispositivo del nuevo proyecto
En las dos siguientes ventanas pinchamos en Next sin rellenar nada y en la ltima pinchamosenFinish. Ya tenemos el proyecto creado y ahora nos disponemos a crear nuestro diseo. Para ello creamos una nueva fuente (fichero) para el proyecto pinchando en ProjectNew Source o haciendodobleclicen Create New Source,queseencuentraenlasubventanaProcesses. Con esta aparecer una nueva ventana que nos pedir el tipo de fuente que queremos crear. Como estamos trabajando enVHDL, seleccionamos VHDL Module, y nombramos al ficheroled1.Estepasosemuestraenlafigura3.9,acontinuacinpinchamosenNext.
Figura 3.9: Seleccin del tipo de la nueva fuente que vamos a crear
39
Ahora nos saldr una ventana como la mostrada en la figura 3.10. Por defecto, el nombre de la arquitectura (Architecture Name) es Behavioral (comportamental). ste se puede cambiar, pero por ahora, lo dejamos as. En esta ventana podemos indicar los puertos de nuestra entidad. En la figura 3.10 se han creado cinco puertos de entrada14 (PB_ENTER, PB_UP, PB_RIGHT, SW_0, SW_1) y cuatro de salida (LED_0, LED_1, LED_2, LED_3). Otra alternativa es crear los puertos directamente en VHDL. Para terminar pinchamos en Next yluegoenFinish.
Figura 3.10: Definicin de los puertos
Si al terminar el proceso la herramienta nos muestra la siguiente imagen (figura 3.11), debemos seleccionar el fichero que hemos creado (led1.vhd), ya sea pinchando en su pestaa,oenWindowled1.vhd.
14
LospuertossehannombradosiguiendolosnombresdelospulsadoresdelaplacaXUPV2P,encasodeque estsusandolaplacaNexys2,puedesnombrarlospulsadorescomoPB_0(envezdePB_ENTER),PB_1(en vezdePB_UP)yPB_2 (envezdePB_RIGHT).Elrestomantienesusnombres.
40
Figura 3.11: Apariencia de la herramienta al aadir la nueva fuente led1.vhd
Como muestra la figura 3.12, podemos ver que no slo nos ha creado la entidad, sino que sehanincluidounascabeceras,bibliotecas,paquetesyladeclaracindelaarquitectura. La cabecera es un apartado con comentarios para que lo rellenemos nosotros, para que tengamosuncontroldelautor,lafechayladescripcindeldiseo,entreotrainformacin. RecuerdaqueenVHDLloscomentariosseidentificancondosguiones--.Esinteresante que lo rellenes, especialmente si trabajas en grupo. Pero incluso si trabajas solo es conveniente rellenarlo porque es comn olvidarse de lo que se hace una vez que ha transcurridociertotiempo.
41
Cabecera
Bibliotecas y paquetes
Entidad
Arquitectura
Figura 3.12: Apariencia de la herramienta al aadir la nueva fuente led1.vhd
Despus de la cabecera se incluyen las referencias a los paquetes de la biblioteca15 del IEEE16,quesonnecesariasparapoderutilizarlostiposdedatosqueemplearemos.Eneste ejemplo nos basta con utilizar el paquete IEEE.STD_LOGIC_1164. Los otros paquetes no son necesariosenesteejemplo. En general, recomendamos utilizar el paquete NUMERIC_STD (cdigo 3.2) en vez el STD_LOGIC_ARITH(cdigo3.1).NoesobligatoriousarlaNUMERIC,peroloimportanteesusar siemprelasmismasenunmismodiseo.Enelcaptulo8seprofundizaenestospaquetes.
library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.NUMERIC_STD.ALL;
Cdigo 3.1: Paquetes por defecto que pone el ISE
Cdigo 3.2: Paquetes recomendados
Despus de las referencias a las bibliotecas y paquetes hay unos comentarios que puedes quitar. A continuacin est la entidad. La entidad tiene el aspecto mostrado en el cdigo 3.3 o el cdigo 3.4 segn estemos usando la placa XUPV2P o la Nexys2 (si hemos cambiadolosnombresdelospuertoscomodecalanotalapie14).
15
Tambinllamadaslibrerasporsuparecidoconeltrminooriginalinglslibrary,querealmentesignifica biblioteca.Eninglsunalibrerasetraducecomobookstore. ElIEEE(InstituteofElectricalandElectronicsEngineers)eslaasociacinquehaestandarizadoelVHDL.
16
42
entity led1 is Port ( PB_ENTER : PB_UP : PB_RIGHT : SW_0 : SW_1 : LED_0 : LED_1 : LED_2 : LED_3 : end led1;
in in in in in out out out out
STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC);
entity led1 is Port ( PB_0 : PB_1 : PB_2 : SW_0 : SW_1 : LED_0 : LED_1 : LED_2 : LED_3 : end led1;
in in in in in out out out out
STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC; STD_LOGIC);
Cdigo 3.3: Cdigo de la entidad para la XUPV2P
Cdigo 3.4: Cdigo de la entidad para la Nexys2
La representacin esquemtica de estas entidades se muestra en las figuras 3.13 y 3.14. La entidaddefinelasentradasysalidasdelcircuito,peronohacereferenciaacmofunciona osuestructurainterna.Escomosifueseunacajanegra.
LED1 (XUPV2P) PB_ENTER PB_UP PB_RIGHT SW_0 SW_1 LED_0 LED_1 LED_2 LED_3 LED1 (NEXYS2) PB_0 PB_1 PB_2 SW_0 SW_1 LED_0 LED_1 LED_2 LED_3
Figura 3.13: Esquema de la entidad para la XUPV2P
Figura 3.14: Esquema de la entidad para la Nexys2
Para describir el funcionamiento o la estructura interna del circuito se utiliza la arquitectura. En la figura 3.12 vemos que solo aparece la definicin de la arquitectura, de modoque,comoeslgico,elrestotenemosquedescribirlonosotros. Para este ejemplo, despus del begin de la arquitectura, incluiremos el cdigo 3.5 (si ests usandolaNexys2sigueelcdigo3.6):
LED_0 LED_1 LED_2 LED_3 <= <= <= <= '0'; '1'; PB_ENTER and SW_0; PB_UP when (SW_1 = '1') else PB_RIGHT; LED_0 LED_1 LED_2 LED_3 <= <= <= <= '0'; '1'; PB_0 and SW_0; PB_1 when (SW_1 = '1') else PB_2;
Cdigo 3.5: Cdigo de la arquitectura de led1.vhd en la XUPV2P
Cdigo 3.6: Cdigo de la arquitectura de led1.vhd en la Nexys2
Una vez que hayas incluido el cdigo 3.5, guarda el fichero y comprobamos si hemos tenidoalgnerrordesintaxispinchandoenSynthesize - XSTCheck Syntax.Estoestenla subventanadeProcesses.Observalafigura3.15paralocalizarlo.
43
Synthesize - XST
Check Syntax
Subventana de Processes
Figura 3.15: Comprobar la sintaxis: Synthesize - XSTCheck Syntax
Si tienes algn error, localzalo y corrgelo. Cuando no tengas errores, puedes pinchar directamenteenSynthesize - XSTparasintetizar. Una vez que hayamos sintetizado tenemos que indicar los pines de la FPGA que vamos a utilizarysucorrespondenciaconlospuertosdelaentidad. En la ventana de fuentes (Sources) verifica que el componente y el fichero que hemos creado est seleccionado: led1-Behavioral (led1.vhd). Pincha en l una vez si no estuviese seleccionado. Para indicarle a la FPGA qu pines vamos a utilizar y con qu puertos de nuestro diseo los vamos a conectar deberemos lanzar la herramienta PACE. Esto lo hacemos desde la ventana de Processes, en ella despliega la seccin que dice User Constraints, pincha dos veces en Assign Package Pins. Posteriormente nos saldr una ventana de aviso que nos indica que para este proceso se requiere aadir al proyecto un fichero del tipo UCF. Este tipo de ficheros son los que se usan para definir las conexiones delospinesdelaFPGAconlospuertosdenuestrodiseo,yportantopinchamosenYes. Ahora nos aparecer la herramienta Xilinx PACE. En ella podemos distinguir tres subventanas, la de la derecha, tiene 2 pestaas en su parte inferior, en una se muestra la arquitecturadelaFPGAyenlaotralaasignacindelospines(verfigura3.16).
44
Figura 3.16: Herramienta PACE
Alaizquierda,enlaventanaDesignObjectListestnlospuertosdeentradasalida17.Yque asignaremos segn se mostr en la figura 3.2 para la XUPV2P o figura 3.4 para la Nexys2. En la 3.17 se muestra la asignacin de los pines para la XUPV2P. Aunque en la columna Loc salga un men desplegable con los bancos, es un error y tienes que introducir el pin correspondiente con el teclado. La columna de los Bancos (Bank) no tienes que rellenarla, larellenaautomticamentelaherramientaalintroducirelpin. Para saber el cdigo de los pines puedes consultar los manuales de referencia de las placas (referencias [31xup] y [21nexys]). En el caso de la Nexys2, algunos de los pines estn impresos en la propia placa entre parntesis, sin embargo, algunos de ellos son errneos,comolosdelospulsadoresquelostieneintercambiados:ElBTN0porelBTN3,yel BTN1porelBTN2.
17
Avecesnosalenlospuertoscorrectamente.Cuandoestoocurrarevisaquenotengasningnespacioo carcterextraoenlarutadetuproyecto.Revisatambinqueeldiseosesintetizacorrectamente.
45
Figura 3.17: Asignacin de los pines en la herramienta PACE para la XUPV2P
LospinesparalaNexys2seranlossiguientes(figura3.18).
Figura 3.18: Asignacin de los pines en la herramienta PACE para la Nexys2
Una vez que hayas incluido los pines, guardamos y cerramos la herramienta PACE. Seguramente nos salga un aviso que nos pregunta cmo queremos guardar el fichero .ucf. Para nosotros es indiferente y pondremos la primera de las opciones (XST Default <>"). AhorapinchamosdosvecesenGenerate Programming FiledentrodelaventanaProcesses,y esperamos a que termine el proceso de sntesis e implementacin, viendo si hay algn erroroadvertenciadeimportancia(warning). Si todo ha ido bien ya podemos implementar el circuito en las placas. Como el proceso es diferente segn estemos usando la XUPV2P o la Nexys2, cada una de ellas se explicar en unapartadodiferente.
3.2.1. Implementacin en la tarjeta XUPV2P

Antes de programar la placa ponemos el interruptor SW9 (CONFIG SOURCE) de manera que seleccione JTAG (ponemos ambos en OFF). Enchufamos el cable de alimentacin y encendemos la placa (SW11). El led verde JTAG CONFIG (D20) deber estar encendido y el ledD11(Error System ACE)podrestarparpadeando(estonoesunerror).
46
Enchufamos el cable USB al PC y a la placa. Esto podr provocar un aviso en nuestro PC que nos indicar acerca de un nuevo hardware detectado. Si es la primera vez que lo enchufamos, necesitar instalar unos drivers y para ello necesitaramos ser administrador, enestecasoesnormalquevuelvaaaparecerelmismomensaje,yvolvemosadecirquelo instale. En la herramienta ISE dentro de la subventana Processes pulsamos dos veces en Generate Programming File ConfigureDevice (iMPACT),verlafigura3.19.
Figura 3.19: Llamada a la herramienta iMPACT para programar la FPGA de la XUPV2P
Con esto, internamente estamos llamando a la herramienta iMPACT, con la que vamos a programarlaFPGA.AparecerunaventanaenlaquepinchamosenFinish. Puede pasar que salga un mensaje de error diciendo que no encuentra el cable, en este caso hay que revisar la configuracin del cable de comunicacin y comprobar que los pasos se han seguido bien (placa encendida e interruptores correctamente posicionados). PinchandoenOutput Cable SetupsedebeseleccionardentrodeCommunicationModeel Platform Cable USBypincharenOK(verfigura3.20).
47
Figura 3.20: Configurando el cable USB para programar la FPGA de la XUPV2P
Si todo ha salido bien, saldrn tres ventanas para seleccionar un fichero y en todas seleccionamos Cancel. Veremos una ventana donde aparecen tres dispositivos, que indicanlosdispositivosJTAGquelaherramientahaidentificadoenlaplaca(figura3.21).
Figura 3.21: Dispositivos JTAG identificados en la XUPV2P
48
El ltimo de la derecha es la FPGA que queremos programar (xc2vp30), sobre ella pinchamos con el botn derecho del ratn18 y seleccionamos la opcin Assign New Configuration File y escogemos el fichero led1.bit, que es el fichero de configuracin de la FPGAconnuestrocircuitosintetizado.LedamosaOKenlasiguienteventana. Volvemos a pinchar con el botn derecho para indicarle que la queremos programar, seleccionamos Programm..., y en la ventana que aparece pinchamos en OK (sin poner la opcindeverificar).
Figura 3.22: Programacin de la FPGA de la XUPV2P
Por ltimo, iMPACT nos indicar si ha realizado la programacin correctamente (figura 3.23)ohahabidoalgnerror(figura3.24).Encasodeque hayahabidoalgnerrorpuede serquetehayasequivocadoeneltipodeFPGAseleccionadoconsultaelapartado3.3para sabercmosehace.
18
Avecesseatascaelratn,siesaspinchaconelbotnizquierdodelratnfueradelostresdispositivos(en laparteblanca),despusdeestoseguramenteyapuedaspincharconelbotnderechosobreeldispositivo.
49
Figura 3.23: Programacin exitosa de la FPGA
Figura 3.24: Programacin fallida de la FPGA
SitodohasalidaEnesecaso,seencenderelledrojoDONE(debajodelverdequeyaestaba encendido).YseencenderelLED0,yaquecomolehabamosasignadoun'0'hacequese encienda.ElLED1estarapagado. El LED2 (LED_2 <= PB_ENTER and SW_0;) estar apagado ('1') cuando SW_0='1' (OFF) y PB_ENTER='1'. Presionando PB_ENTER o/y poniendo SW_0 a ON, se nos encender el led. De manera parecida podemos ver si el LED3 funciona cuando presionamos el PB_UP si SW_1 estenOFF;ycuandopresionamosPB_RIGHTsiSW_1estenON. Fjatequeestoesasporquelospulsadores,interruptoresyleddelaXUPV2Ptrabajancon lgicanegada.
3.2.2. Implementacin en la tarjeta Nexys2

Aunque la tarjeta Nexys2 se puede programar con el conector JTAG, viene con un puerto USBquepermiteprogramarlademaneramscmoda.Elnicoinconvenienteesquehay queinstalarelprogramagratuitoAdept[1adept]. Antes de conectar nada, lo primero que tenemos que hacer es situar el jumper de configuracin en la posicin JTAG (en la parte derecha). El jumper de configuracin lo puedes localizar en la figura 3.3 (jumpers de seleccin ROMJTAG). Pon la caperuza azul en los dos pines de la derecha, donde dice JTAG. Esto es para que la FPGA se programe desde el JTAG y no se programe a partir de lo que haya grabado en la memoria ROM (en realidadesunamemoriaflash).DebidoaqueestasFPGAsonvoltiles,siqueremosquese guarde un circuito de manera permanente en la tarjeta, lo guardaremos en la memoria flash (no voltil). Si al encender la tarjeta el jumper est en la posicin ROM, la FPGA se programar con el circuito que se haya grabado en dicha memoria flash. Como nosotros vamos a probar circuitos de manera continua, y no queremos grabar de manera permanenteningncircuito,loponemosenlaotraposicin.
50
Pon tambin los jumpers de POWER SELECT (figura 3.3: jumpers de seleccin alimentacin)enlaposicinUSB. A continuacin se explica cmo se programa la tarjeta Nexys2 con la versin 2 del Adept. Ejecuta el programa Adept: InicioTodos los ProgramasDigilentAdept. En la figura 3.25 se muestra la pantalla inicial cuando no hay ningn dispositivo conectado. Esto se puede verenlapartederechadelaventana.
Figura 3.25: Pantalla inicial del Adept, sin dispositivos conectados
Ahora conectamos la tarjeta Nexys2 al ordenador mediante el cable USB y ponemos el interruptor de alimentacin en la posicin ON. Transcurrido un tiempo, en la ventana del Adept aparecer que se ha conectado una tarjeta, en la parte derecha pondr Onboard USB (ver figura 3.26). Si no saliese nada, prueba a pinchar en el men que pone No Devices Connected a ver si cambia. Si no cambiase, prueba a cerrar el Adept y volverlo a arrancar. La primera vez que conectemos la tarjeta puede ser que Windows haya detectado un nuevohardwareytengamosquedarpermisoparalainstalacindelosdriversquevienen con la tarjeta (no tenemos que introducir un disco, la propia tarjeta le proporciona los drivers).
51
Figura 3.26: Pantalla del Adept que ha detectado algn dispositivo conectado
Ahora pinchamos en Initialize Chain y, como se ve en la figura 3.27, aparecern dos componentes: uno es la FPGA y otro la memoria (PROM). Indicar tambin el modelo de FPGA,queennuestroeslaXC3S500E.
Figura 3.27: Pantalla del Adept que ha detectado la cadena JTAG de dispositivos (FPGA y PROM)
Acontinuacinpinchamosenelbotnbrowse...correspondientealaFPGA,ybuscamosel fichero led1.bit que hemos generado en nuestro proyecto. Aparecer una advertencia (warning) indicando el mensaje:Startup clock for this file isCCLK instead ofJTAG CLK. Problems will likely occur. Associate config file with device anyway?. A este mensaje contestamosS.
52
Otra cosa es que salga un mensaje de error indicando: Unable to associate file with device due to IDCODE conflict. Esto es un error que indica que la FPGA que hemos escogido no es la misma que la que est en la placa. En este caso, tendremos que verificar que el modelo de FPGA sea el mismo. Si no fuese as, lo tendremos que cambiar. Consulta el apartado3.3sinosabescmoserealizaestaoperacin. Si todo ha salido bien, slo tenemos que pinchar en Program y se programar la FPGA. El resultado ser que se encender el led LD1, y el led LD0 estar apagado. Observa que es justo lo contrario que ocurra en la XUPV2P. El comportamiento de los otros led es tambindiferenteportenerlgicadirecta.Compruebaquefuncionacomodeberaser.
3.3. Cambiar el tipo de FPGA de un proyecto

Este apartado se incluye por si en un proyecto queremos modificar el tipo de FPGA, ya sea porque vamos a cambiar de placa (por ejemplo de la XUPV2P a la Nexys2) o porque noshemosequivocadoalprincipioponiendolascaractersticas(recuerdalafigura3.8),en cualquier momento podemos realizar el cambio. Para ello, tenemos que seleccionar la FPGA en la subventana Sources, y pinchar con el botn derecho del ratn. En el men desplegable que aparece tendremos que pinchar en Properties (figura 3.28). Tras esta operacin aparecer la ventana de la figura 3.8 que nos permitir cambiar el modelo y las caractersticasdelaFPGA.
Figura 3.28: Procedimiento para cambiar las caractersticas de la FPGA
Ten en cuenta que segn el cambio que hayamos realizado, quiz tambin tengamos que cambiarelfichero.ucf,puesenlseindicanlospines,ystospuedenserdistintosconel modelo de la FPGA (incluso pueden haber cambiado de nombre). Otras cosas que podemos necesitar cambiar son otras caractersticas del funcionamiento: la frecuencia de
53
reloj puede haber cambiado, la lgica de los pulsadores, perifricos,... por tanto a veces el cambionoestanfcil.
3.4. Las restricciones del circuito

Hemos visto que dentro de la subventana Processes est el apartado User Constraints. En donde, mediante la herramienta PACE hemos asignado los pines de la FPGA. En el apartado4.1veremosquetambinsepuedenponerrestriccionestemporales. Gran parte de esta informacin se guarda en un fichero de texto, con extensin .ucf, que se puede visualizar y modificar con cualquier editor de texto, y tambin se puede editar directamente desde la herramienta ISE pinchando dentro de la subventana Processes en User Constraints Edit Constraints (Text).Verfigura3.29.
Figura 3.29: Edicin del fichero de restricciones
Enelficheropodemosverlaasociacindepuertos(NET)conpines(LOC).Estainformacin se extrae de la gua de usuario de la placa. Como estamos trabajando con una placa ya fabricada, los pines tienen una localizacin fija en la placa, y por tanto siempre que usemos los mismos pines podemos usar el mismo fichero .ucf. En la pgina web de la placaestndisponibles estosficherosparaquesimplementetengamosquecopiary pegar ennuestrodiseo19. Para el caso de la XUPV2P, dentro del fichero comprimido hay distintos ficheros .ucf agrupados por la funcionalidad de los pines (botones, leds, puerto serie,...). En estos
19
DelaXUPV2P:http://www.xilinx.com/univ/XUPV2P/UCF_Files/UCF_FILES.zip
DelaNexys2:http://www.digilentinc.com/Data/Products/NEXYS2/Nexys2_500General.zip
54
ficheroshaymsinformacin,queindicaeltipodelgicadecadapin(LVTTL,LVCMOS,...)y, enelcasodel.ucfdelosrelojes(CLOCKS.UCF)lafrecuenciadecadareloj. Por tanto, para evitar equivocarnos al asignar los pines, en vez de utilizar la herramienta PACEpodemoscopiarypegardelosficheros.ucf.Esos,lospuertosdebenllamarseigual queenelfichero.ucfysino,cambiarlosnosotrosconeleditor.
55
4. Utilizacin del reloj y circuitos secuenciales

En la prctica anterior diseamos un circuito combinacional, que no tena reloj. Ahora realizaremos una prctica con un circuito secuencial sencillo para recordar cmo se hace. Esta es una prctica de repaso, si tienes dudas te recomendamos que mires el manual [17mach]. Los ejemplos sern sencillos y servirn para repasar. Tambin comprobaremos que los relojes de las placas funcionan bien y nos ayudar a entender las diferencias entre las dos placas.
4.1. Segundero (primera versin)

En este ejercicio haremos que uno de los led parpadee. El led estar un segundo apagado y el siguiente segundo permanecer encendido. Para ello utilizaremos el reloj de la placa. Sinembargo,lafrecuenciadelrelojdelatarjetaXUPV2PesdiferentealadelaNexys2.El reloj de la XUPV2P va a 100 MHz mientras que el de la Nexys2 va a 50MHz. Este es un dato muy importante a tener en cuenta en los diseos que tengas que realizar a lo largo delcurso. EnlaXUPV2P,elrelojentraporelpinAJ15delaFPGA,enlaNexys2elrelojlotenemosen elpinB8. Como seguramente recuerdes, para implementar un segundero podemos utilizar un divisordefrecuencia(uncontador)quecadavezquelleguealfinaldesucuentadaruna sealdeavisodequehapasadounsegundo. Adems aadiremos una seal de reset que se corresponder con un pulsador. En la XUPV2P utilizaremos el pulsador del medio (ENTER, pin: AG5), mientras que en la Nexys2 utilizaremoselpulsadordeladerecha(BTN0,pin: B18). Anteriormente hemos visto que los pulsadores de la XUPV2P envan un cero cuando estn pulsados, por tanto, el reset sera a nivel bajo (se resetea cuando recibe un cero). Sin embargoenlaNexys2,lospulsadoresenvanununocuandoestnpulsados. Losledsdelasplacastambinfuncionandeformainversa,sinembargo,comovanaestar lamitaddeltiempoencendidosylaotramitadapagados,probablementenonosdaremos cuenta. Porlotantotenemosdosdiferenciasimportantesalusarlasplacas: Tienenfrecuenciaderelojdiferente La lgica de los pulsadores, interruptores y leds es diferente (lgica directa y lgica negada).
Siguiendo los pasos de la prctica anterior, crearemos un nuevo proyecto llamado SEG1. Enestecasoslotendremos3puertos,dosdeentrada(clk,rst)yunodesalida(led0).Sin embargo, debido a las diferencias entre las placas podra ser conveniente nombrar a los puertosdedistintamaneraparadistinguirlosdiseos.As,lasealderelojdelaXUPV2P lapodemosllamarclk_100mhzyladelaNexys2lallamaramosclk_50mhz.
57
Porotrolado,lassealesderesetsondiferentes,porquealpulsarelresetenlaXUPV2Pse recibeuncero,yenlaNexys2serecibeununo.Portanto,elresetdelaXUPV2Pesactivoa nivel bajo, y eso se puede representar ponindole una _n (de negado) al final de su nombre:rst_n. Enlasfiguras4.1y4.2semuestranlasrepresentacionesesquemticasdeestasentidades.
SEG1_XUPV2P
SEG1_NEXYS2
led0 clk_100mhz rst_n

clk_50mhz rst
led0
Figura 4.1: Esquema del segundero para la XUPV2P
Figura 4.2: Esquema del segundero para la Nexys2
Si has realizado las prcticas de Electrnica Digital II [17mach] seguramente recuerdes cmosehaceunsegundero.Loidealseraqueintentasesrealizarloportimismo.Anas, acontinuacinsemuestraunejemplodecdigoparaqueloimplementes.Obsrvalobien e intenta descubrir si es correcto, ya que tiene algn fallo. En el cdigo 4.1 se muestra la versinparalaXUPV2P.
entity SEG1_XUP Port ( rst_n clk_100mhz led0 ); end SEG1_XUP; is : in : in : out std_logic; std_logic; std_logic
architecture BEHAVIORAL of SEG1_XUP is signal contseg : natural range 0 to 100000000; -- XUPV2P: 100MHz a 1 segundo signal led0aux : std_logic; begin led0 <= led0aux; P_Conta: Process (rst_n, clk_100mhz) begin if rst_n = '0' then -- XUPV2P: reset activo a nivel bajo contseg <= 0; led0aux <= '0'; elsif clk_100mhz'event and clk_100mhz='1' then contseg <= contseg + 1; if (contseg = 0) then led0aux <= not led0aux; end if; end if; end process; end BEHAVIORAL;
Cdigo 4.1: Cdigo de la primera versin (con fallos) del segundero para la XUPV2P
Recuerdaquesehatenidoquecrearlasealauxiliarled0aux yaquelospuertosdesalida nosepuedenasignar. Enelcdigo4.2semuestralaversin(tambinconalgnfallo)paralaNexys2.
58
entity SEG1_NEXYS is Port ( rst : in clk_50mhz : in led0 : out ); end SEG1_NEXYS;
std_logic; std_logic; std_logic
architecture BEHAVIORAL of SEG1_NEXYS is signal contseg : natural range 0 to 50000000; -- Nexys2: 50MHz a 1 segundo signal led0aux : std_logic; begin led0 <= led0aux; P_Conta: Process (rst, clk_50mhz) begin if rst = '1' then -- Nexys2: Reset activo a nivel alto contseg <= 0; led0aux <= '0'; elsif clk_50mhz'event and clk_50mhz='1' then contseg <= contseg + 1; if (contseg = 0) then led0aux <= not led0aux; end if; end if; end process; end BEHAVIORAL;
Cdigo 4.2: Cdigo de la primera versin (con fallos) del segundero para la Nexys2
Una vez creado el fichero VHDL comprobamos su sintaxis. Para ello seleccionamos el fichero en la ventana Sources, y en la ventana Processes, hacemos doble clic en SynthesizeCheck Syntax. Si el resultado es correcto, ahora debemos indicar las restricciones temporales que tenemos. Entonces hacemos doble clic dentro de la ventana Processes, en User ConstraintsCreate Timing Constraints.Nospodrsalirunavisodequevaacrearunfichero .ucf, le damos a aceptar, pues en estos ficheros se guardan las restricciones y las asignaciones de los pines. Aparecer la herramienta Xilinx Constraints Editor (figura 4.3) en ella seleccionamos la pestaa Global y en el reloj le indicamos su periodo: 10 (en nanosegundos) para el caso de la XUPV2P y 20ns para Nexys2. Guardamos y cerramos, y volvemosalaventanadelISE.
Figura 4.3: Xilinx Constraints Editor
59
En cuanto a las restricciones temporales, es importante sealar que las restricciones del reloj, son precisamente restricciones de nuestra placa, y le estamos indicando a la herramienta a qu frecuencia va nuestro reloj. Con este dato, la herramienta intentar ajustar la implementacin del diseo a esas restricciones, y en caso de que no sea posible, nosotros debemos o bien usar un reloj con menor frecuencia (mediante el uso de componentesdelaFPGAquegeneranrelojesmslentos)uoptimizarnuestrodiseopara queseamsrpido. Ahora asignaremos los pines, nos aseguramos que el mdulo seg1 est seleccionado en la subventana Sources, y en la subventana Processes, pinchamos en User ConstraintsAssing Package Pins. Asignamos los pines de manera similar a la prctica anterior, en este caso para la XUPV2P: clk_100mhzAJ15 ; rst_nAG5 ; led0AC4. Y para la Nexys2: clk_50mhzB8;rstB18;led0J14. Guardamos y cerramos, puede pasar que la herramienta pregunte por el formato del fichero.ucf,puedesercualquiera,asqueponemoselprimerodeellos. Ahora, en la subventana Processes hacemos doble clic en el apartado Implement Design. Vemos si hay algn error o advertencia. Posteriormente, en la subventana central seleccionamos la primera pestaa Design Summary, y en ella localizamos Performance Summary, donde debe indicar si se han cumplido las restricciones temporales. Debe aparecer All Contraints Met y se puede pinchar en ella para analizar el informe con mayor detalle. Para este ejemplo tan sencillo, las restricciones temporales no iban a suponer ningnproblema. Ahora se puede generar el fichero de programacin (.bit) y cargarlo en laFPGA mediante eliMPACToelAdept,segnlaplacaquetengamos. Como resultado deberamos ver parpadear el LED0 cada segundo, si pulsamos el botn central se reinicia el parpadeo y si lo mantenemos pulsado, en la XUPV2P el led se queda encendido,yaqueseleasignauncero,quehacequeseilumineelled.EnlaNexys2ocurre locontrarioalpulsarelreset.
4.2. Segundero (segunda versin)

Has descubierto el fallo del anterior circuito? Te has fijado si el led permaneca encendidoexactamenteunsegundo? El circuito anterior tena algn fallo. Cuando se crea un circuito para sntesis y se declara una seal entera con un rango se est especificando el ancho que tendr dicha seal, es decirelnmerodebits.Yportanto,sintetizarundiseoquetieneunasealconunrango quenoespotenciade2puedecrearnosproblemas. Por ejemplo, supongamos que necesitamos una seal con un rango de 0 a 9. Para representarestasealenbinarionecesitamoscuatrobits.Siladeclaramossegnelcdigo 4.3, independientemente de que hayamos indicado que su rango llega hasta 9, al sintetizarlasealvaatener4bits,yportanto,surangorealvaaserde0a15.Ysianas quisisemoslimitarelrango,tendramosnosotrosquegenerarelhardwareadecuado(con comparadoresyotroscomponentes)paraquenuncasepasede9. Por tanto, la manera adecuada de declarar la seal sera la mostrada en el cdigo 4.4. Siendo la declaracin de dec2 la ms adecuada, pues con ella, al usar la operacin
60
potencia (**) estamos especificando el nmero de bits. No debemos olvidar restar uno, puessino,estaramosusandounbitms.
signal dec0 : natural range 0 to 9;
Cdigo 4.3: declaracin de un rango "incorrecta" para sntesis
signal dec1 : natural range 0 to 15; signal dec2 : natural range 0 to 2**4-1;
Cdigo 4.4: declaraciones correcta de un rango
Es importante tener en cuenta que si declaramos una seal entera o natural sin rango (cdigo 4.5), el sintetizador implementar la seal con 32 bits (32 cables). Si no necesitamostantosbitsparalasealestaremosdesperdiciandorecursosdelaFPGA.
signal sin_rango : natural; -- por no tener rango se sintetiza con 32 bits
Cdigo 4.5:la declaracin de una seal sin rango implementa una seal de 32 bits
Una opcin recomendable en el uso de seales, es el empleo del tipo unsigned en vez de natural, y el uso de signed en vez de integer. El uso de estos tipos se explic en el captulo 6 de la referencia [17mach], tambin se ver con ms detalle en el captulo 8. Un ejemplodedeclaracindesealunsignedsemuestraenelcdigo4.6.
signal dec_us : unsigned (3 downto 0);
Cdigo 4.6: Declaracin de seal unsigned
Es probable que con esta informacin ya sepas por qu no funciona correctamente la versinanteriordelsegundero. En el cdigo 4.1 creamos la seal contseg con un rango de 100 millones ( 50 millones para la Nexys2, cdigo 4.2). Esto lo hicimos porque tenamos dividir la frecuencia entre 100 millones ( 50 millones) para pasar de 100 MHz ( 50 MHz) a 1 Hz. Sin embargo, como acabamos de ver, indicar que una seal tiene un rango de 100 millones no nos asegura que fsicamente esa seal tenga ese rango. De hecho, el rango de esa seal ser la potencia de 2 inmediatamente superior, en este caso, algo ms de 134 millones (227). Para el caso de la Nexys2 el rango sera algo ms de 67 millones (226). Por lo tanto, nuestro led vaaestarencendidoalgomsde1,34segundosenvezdeestarunsegundoluciendo. Para comprobarlo, creamos un nuevo proyecto SEG2 (no cambies el proyecto anterior porque lo vamos a usar), que ser una ampliacin del diseo de la anterior prctica. En esteproyectovamosacontarsegundosdetresmanerasdiferentes,portanto,envezdeun ledusaremostresparamostrarlastrescuentas.LaentidadparalaXUPV2Psemuestraen elcdigo4.7yparalaNexys2semuestraenelcdigo4.8:
entity SEG2_XUP is Port ( rst_n : in clk_100mhz : in led0 : out led1 : out led2 : out ); end SEG2_XUP; std_logic; std_logic; std_logic; std_logic; std_logic entity SEG2_NEXYS is Port ( rst : in clk_50mhz : in led0 : out led1 : out led2 : out ); end SEG2_NEXYS; std_logic; std_logic; std_logic; std_logic; std_logic
Cdigo 4.7: Entidad de la segunda versin del segundero para la XUPV2P
Cdigo 4.8: Entidad de la segunda versin del segundero para la Nexys2
Portanto,enlaarquitecturausaremostrescontadores,cuyassealesdeclararemosas:
architecture Behavioral of SEG2_XUP signal cont0 : natural range 0 to signal cont1 : natural range 0 to signal cont2 : natural range 0 to .... is 100000000; (2**27)-1; (2**27)-1;
Cdigo 4.9: Declaracin de las seales usadas para contar
61
La seal cont0 tiene un rango de 108, mientras que la seal cont1 y cont2 tienen un rango mayorquesecorrespondeconlapotenciade2inmediatasuperiora108. Vamosaimplementarloscontadoresvanacontardelasiguientemanera:
cont0vaahacerparpadearaled0delamismamaneraqueenlaprcticaanterior. cont1 va a hacer parpadear a led1 de la misma manera que en la prctica anterior, la
diferenciaconcont1eselrango.Elrangodecont0esmenorqueeldecont1.
cont2 va a hacer parpadear a led2 pero no se va a desbordar, sino que controlaremos que
cuando llegue a 1081 se inicialice. En caso de la Nexys2, cuando el contador llegue a 50 millones. Unavezquetenemoseldiseoyhemoscomprobadosusintaxis,loimplementamosenla FPGA, y vemos si cont0 parpadea a la frecuencia de cont1 o de cont2. Si parpadea a la frecuencia de cont1 significa que ha superado el rango que le habamos impuesto en la declaracin y que imponer rangos que no sean potencias de dos nos puede llevar a errores.
62
5. Simulacin con Modelsim

En este captulo vamos a ver cmo simular con Modelsim20. En el manual de prcticas de ED2 [17mach] se explic cmo simular con el simulador del ISE (captulo 8). Es conveniente que repases ese captulo, pues describe los fundamentos de los bancos de pruebas. Hasta ahora hemos realizado circuitos simples que en el caso de que hayamos tenido algn error, no era muy difcil de corregir. Sin embargo casi nunca es as, y conviene simularelcircuitoparacomprobarsihayalgnerrorantesdeimplementarloenlaFPGA. De hecho, lo habitual es que los diseos no funcionen a la primera, y por tanto, la simulacinseconvierteunpasoimprescindible. Vamos a crear un banco de pruebas (en ingls test bench) dentro del proyecto anterior (apartado 4.1). El banco de pruebas es un diseo VHDL que sirve para comprobar el funcionamiento de un circuito. Este diseo VHDL no tiene que estar limitado a las estructuras para sntesis, sino que puede usar todo el conjunto del VHDL. Esto se debe a que el banco de pruebas no va a implementarse en la FPGA (por lo tanto no se va a sintetizar)sinoqueseutilizarnicamenteparasimulacin. As que creamos una nueva fuente de tipo VHDL TestBench y la llamaremos tb_seg1.vhd (figura5.1).
Figura 5.1: Creacin de un nuevo banco de pruebas
Pinchamos en Next o Finish en todas las ventanas que nos aparezcan hasta llegar a la edicin del fichero del banco de pruebas. El ISE nos ha creado la estructura del banco de pruebas (figura 5.2) y ahora tenemos que crear los procesos que generen los estmulos. Si tienes dudas sobre la estructura del banco de pruebas de la figura 5.2, te recomendamos
20
Modelsim(http://model.com)esunsimuladordelacompaaMentorGraphics.Tienenunaversin limitadaparaestudiantesytambinofreceunaversinparaXilinx:ModelsimXE,disponibledesdela pginawebdeXilinx.
63
que repases el captulo 8 del manual de prcticas de ED2 [17mach], donde se explica con detallecadaunalaspartesdelbancodepruebas.
Seleccionar Behavioural Simulation
Declaracin de componente
Conexiones
Referencia o "instanciacin" del componente
Estmulos
Figura 5.2: Estructura del banco de pruebas
Dentro de la zona sealada como estmulos de la figura 5.2 hay una plantilla de un procesocreadaporelISE.Nosotros vamosacreardosprocesos.Unoparalasealqueva a simular la seal de reloj y otro para la seal de reset. No hace falta ms, ya que este circuito slo tena estas dos seales de entrada. Para crear los procesos, o bien borras la plantilla creada y aades los procesos nuevos, o bien modificas la plantilla para que el procesoquedecomosemuestraacontinuacin. El proceso que simula la seal de reloj se muestra en los cdigos 5.1 y 5.2. La diferencia entreamboseslafrecuenciadelreloj.Elcdigo5.1generaunrelojde10ns(5+5ns),que es el reloj de la XUPV2P (100 MHz). Por otro lado, el cdigo 5.2 genera un reloj de 20 ns (10+10ns),queeselrelojdelaNexys2(50MHz).
64
PClk_XUP: Process begin clk_100mhz <= '0'; wait for 5 ns; clk_100mhz <= '1'; wait for 5 ns; end process;
PClk_Nexys: Process begin clk_50mhz <= '0'; wait for 10 ns; clk_50mhz <= '1'; wait for 10 ns; end process;
Cdigo 5.1: Proceso que simula el reloj de la XUPV2P
Cdigo 5.2: Proceso que simula el reloj de la Nexys2
Observa que estos procesos no tienen lista de sensibilidad. Esto es porque los procesos que tienen sentencias con wait no tienen lista de sensibilidad. Estos procesos no son vlidos para sntesis21, ya que al hardware no le puedes decir directamente que espere 5 nanosegundos. Para ello, tendras que realizar un contador que contase los ciclos de un reloj cuya frecuencia sea conocida (de manera similar a como se hizo en la prctica anterior). Durantelasimulacin,losprocesosdeloscdigos5.1y5.2seejecutanpermanentemente. Sedetienedurante5ns(10ns)cadavezquellegaaunadelassentenciaswait.Portanto, lasealdereloj(clk_100mhzclk_50mhz)recibeperidicamenteunvalordiferente.. Para el proceso de la seal de reset nos podra bastar con simular que pulsamos el botn de reset una vez. Los cdigos 5.3 y 5.4 muestran estos procesos para la XUPV2P y la Nexys2. La nica diferencia de estos dos procesos es cmo se activan los reset: en la XUPV2PanivelbajoyenlaNexys2anivelalto.
PRst_N_XUP: Process begin rst_n <= '1'; wait for 108 ns; rst_n <= '0'; -- Reset a nivel bajo wait for 75 ns; rst_n <= '1'; wait; -- esperamos "eternamente" -- con el reset desactivado end process; PRst_Nexys: Process begin rst <= '0'; wait for 108 ns; rst <= '1'; -- Reset a nivel alto wait for 75 ns; rst <= '0'; wait; -- esperamos "eternamente" -- con el reset desactivado end process;
Cdigo 5.3: Proceso que simula la seal de reset para la XUPV2P
Cdigo 5.4: Proceso que simula la seal de reset para la Nexys2
En estos ejemplos, el reset se ha activado en un tiempo aleatorio de 108 ns. Poda haberse elegido otro. Y se ha mantenido activo durante 75 ns. En realidad, estos tiempos tendran que ser mucho mayores si se quisiese representar el tiempo que aproximadamente se mantienen presionando los pulsadores, pero es innecesario alargar lasimulacinduranteelreset. La ltima sentencia de estos procesos es un wait que termina en punto y coma, sin tiempos de espera. Este wait hace que se detenga la ejecucin del proceso y se quede esperando eternamente. Por lo tanto, a partir de entonces el reset se quedar inactivo durantetodalasimulacin. Para simular el circuito, podemos realizarla de dos maneras (lo haremos de la segunda forma):
Para la primera forma, necesitamos haber seleccionado el Modelsim como el simulador dentrodelISE(recuerdalafigura3.8.).SeleccionamosBehavioral Simulationenlasubventana
21
Procesosconsentenciawait for,unprocesoconsentenciawait untilpuedesersintetizableaunque nolosveremos.
65
Sources (pestaa Sources), ver figura 5.2. Para simular el modelo podemos pinchar dentro delaventanaProcesses,enModelsim Simulator
La segunda forma es crear un proyecto en Modelsim. Esta manera se explicar a continuacin.
Creamosunacarpetallamadasimulacionenlacarpetadondetengamosnuestroproyecto. Abrimos el Modelsim y creamos un nuevo proyecto: FileNewProject. Y creamos el proyectoseg1dentrodelacarpetasimulacion. Aadimos al proyecto los ficheros VHDL que hemos creado desde el ISE: FileAdd to ProyectExisting File.
Figura 5.3: Aadiendo ficheros al proyecto de Modelsim
Unavezqueaparecenlosdosficherosenlaventanadelaizquierda,seleccionamosambos y con el botn derecho del ratn le damos a CompileCompile All, y vemos si tenemos algn error. En caso de que haya algn error de compilacin se mostrar en la ventana inferiorenletrasrojas,ypinchandodosvecesenelmensajenossaldrunaventanaconla informacin del error y el nmero de lnea. Tambin se puede pinchar en el mensaje para que se muestre el error en el cdigo. Si hubiese un error, lo corregimos, grabamos y volvemos a repetir el proceso. En la ventana izquierda debern aparecer ambos ficheros conunamarcaverdequeindicaquesehancompiladoconxito.
66
Figura5.4: Compilando los ficheros del proyecto de Modelsim
Para empezar la simulacin, pinchamos en SimulateStart Simulation. Nos saldr una ventana, en ella entramos en work, y dentro de ella seleccionamos el banco de pruebas (tb_seg1_vhd),yledamosaOK.
Figura 5.5: Comienzo de la simulacin y seleccin del fichero del banco de pruebas para simular
Segn cmo tengamos configurado el Modelsim, saldrn unas ventanas u otras. Nosotros queremosquesalganlasventanasObjetcyWave.Paraello,sinoestuviesen,pinchamosen ViewDebug WindowsWaveyenViewDebug WindowsObjects.
67
Figura 5.6: Aadiendo la ventana de las formas de onda (Wave)
Para incluir las seales en la ventana de simulacin (Wave) y as ver las formas de onda, nos ponemos en la ventana de Workspace y seleccionamos el componente UUT. Haciendo esto, en la ventana Objects aparecern las seales de ese componente y pinchando con el botn derecho del ratn dentro de la ventana Objects seleccionamos Add to WaveSignals in Region. Si quisisemos aadir todas las seales de circuitos, haramos Add to Wave Signals in Design.Obienpodemosaadirlassealesindividualmente.
Figura 5.7: Aadiendo las seales de un componente
68
Ahora queremos simular el circuito durante 1400 ms (un poco ms de un segundo). Esto lo indicamos en la ventanita para poner el tiempo de simulacin (ver figura 5.8). Y pinchamos en el botn de la derecha (Run). Seleccionamos la pestaa wave si no estuviese seleccionada.
tiempo de simulacin: 1400 ms Run: orden para simular
Figura 5.8: Indicacin del tiempo de simulacin y orden para empezar la simulacin
Es una simulacin larga, pues un segundo de simulacin son muchos ciclos de reloj. Al sobrepasar el segundo de simulacin se producir un error por haberse desbordado el contador. En este caso, la simulacin nos advierte del error que vimos en el apartado anterior: hemos definido la seal con un rango que se va a desbordar (out of range) y no hemoslimitadolacuenta(verfigura5.9). Para ver las formas de onda, en caso de que no se muestre, pincha en la pestaa de las formasdeonda.Paraverlasimulacincompleta,pinchaeneliconomostradoenlafigura 5.9. Al lado del icono tienes otros para ampliar o disminuir el detalle (zoom). Puedes extraer la ventana de las formas de onda y hacerla independiente de la ventana del Modelsim.
Ver la simulacin completa Extraer la ventana de formas de onda
Pestaa de las formas de onda
Aviso de error
Figura 5.9: Resultado de la simulacin
Encaptulosposterioresiremosprofundizandoenlosbancosdepruebasylasimulacin.
69
6. Constantes, genricos y paquetes

Enestecaptulorepasaremosalgunosconceptosytcnicasquenosfacilitarneldiseoen VHDL, especialmente si necesitamos adaptar nuestro diseo a otras FPGA, tarjetas o entornos. Esto es muy importante porque har que nuestro diseo sea ms fcilmente reutilizable,loquenospermitirahorrartiempodedesarrollo.
6.1. Uso de constantes

De las prcticas anteriores podemos haber notado la incomodidad que implica utilizar dos placas con algunas caractersticas diferentes. Por ejemplo, en la placa XUPV2P para encender un led necesitamos poner un0, mientras que en la Nexys2 tenemos que poner un1paraencenderlo.Tambinvimosquelasplacasrelojescondistintafrecuencia. Por ltimo, si hemos utilizado la XUPV2P, quiz habremos notado que utilizar lgica negada puede dificultarnos la implementacin y la comprensin del funcionamiento un circuito. Por ejemplo, si queremos encender el led ld0 cuando presionamos el pulsador pb0 y tengamos el interruptor sw0 conectado, por ser lgica negada, la sentencia no es muy intuitiva, pues no se forma con la and (cdigo 6.1), sino con la or (cdigo 6.2). Esto, aunque es fcilmente explicable con las leyes de De Morgan, nos puede provocar algo de confusin.
ld0 <= pb0 and sw0; ld0 <= pb0 or sw0;
Cdigo 6.1: Sentencia con lgica directa
Cdigo 6.2: Sentencia equivalente al cdigo 6.1 pero con lgica inversa
Para evitar la confusin que nos puede dar lugar al leer el cdigo 6.2 tenemos varias opciones: 1. Usar nombres que indiquen que son seales con lgica negada. Esto nos advierte de la situacin,sinembargotenemosqueseguirtrabajandoconlgicanegada.Elcdigo6.3nos muestra un ejemplo de cmo podramos indicar que las seales funcionan con lgica negada(aadiendo"_n"). 2. Usarlgicadirectainternamente,habiendonegadolospuertosdeentradaantesdeusarlos y negando despus las salidas. A los nombres de los puertos les podemos aplicar la recomendacinanterior.Comoejemplosemuestraelcdigo6.4,enelquelastresprimeras sentencias transforman la lgica de los puertos. A raz de esto, la ltima sentencia ya trabajaconlgicadirecta.
71
ld0_n <= pb0_n or sw0_n;
Cdigo 6.3: Aadiendo '_n' a las seales que usan lgica inversa
-- asignacion de los puertos -- pb0_n, sw0_n : puertos entrada pb0 <= not pb0_n; sw0 <= not sw0_n; -- ld0_n, : puerto de salida ld0_n <= not ld0; -- Ya trabajamos con logica directa: ld0 <= pb0 and sw0;
Cdigo 6.4: Invirtiendo los puertos que trabajan con lgica inversa
3. Usar constantes que nos digan cul es el valor de funcionamiento de las seales (cdigo 6.5). Con esto hacemos el circuito independiente del tipo de lgica, lo nico que tenemos quehaceresponerelvaloradecuadodelasconstantes.Estaopcintienelagranventajade que nos permite usar el mismo diseo para la XUPV2P y la Nexys2 con solo cambiar el valordelasconstantes.Elinconvenienteesquelasentenciaesmslarga.
architecture .... constant c_on : std_logic := '0'; --solo tenemos que cambiar aqui segn la lgica constant c_off : std_logic := not c_on; begin ld0 <= c_on when ((pb0 = c_on) and (sw0 = c_on)) else c_off; end ...;
Cdigo 6.5: Usando constantes para independizar el circuito del tipo de lgica de las entradas
Siguiendo esta ltima indicacin, puedes probar a cambiar el cdigo 3.5 de modo que funcioneigualqueloharaenlaNexys2(cdigo3.6).
6.2. Uso de genricos

Si tenemos un diseo grande, con muchos ficheros (recuerda el VHDL estructural del apartado2.10),puedeserincmodoyprovocarerroreseltenerquecambiarelvalordelas constantes en cada uno de los ficheros, ya que en cada uno de los ficheros tendramos declaradaslasmismasconstantes(comoenelcdigo6.5). ElVHDLnospermitedefiniruntipodeconstantesespecialesllamadasgenricos(generic). Estas constantes se declaran en las entidades y sus valores se pueden propagar al referenciarloscomponentes. En el cdigo 6.6 se muestra la adaptacin del cdigo 6.5 asignando el genrico al valor de laconstante.
entity gen_xup is -- los genericos van en la entidad antes de los puertos Generic ( g_logic : std_logic := '0' ); Port ( pb0 : in std_logic; sw0 : in std_logic; ld0 : out std_logic ); end gen_xup; architecture Behavioral of gen_xup is constant c_on : std_logic := g_logic; -- el generico se puede asignar a la cte constant c_off : std_logic := not c_on; begin ...
Cdigo 6.6: Declaracin y uso de genricos
Como se ha comentado, la ventaja del genrico es que se puede propagar por el VHDL estructural. El paso de los valores se hace de manera similar a los puertos, en vez de la
72
sentenciaPORT MAPseutilizaGENERIC MAP.Alpropagarlosgenricossepierdeelvalorque selehabadadoenladeclaracindelaentidad.Dehecho,porestomismonoesnecesario asignarunvalorenladeclaracin. Aunque ms adelante veremos ejemplos de su utilizacin en circuitos estructurales, en el cdigo6.7semuestraunejemplo.
GEN: GEN_XUP generic map ( g_logic g_generico2 ) port map ( pb0 => sw0 => ld0 => ); => g_tipolog, -- el generico g_logic recibira el valor de g_tipolog => g_generico2
pb0, clk, ld0
Cdigo 6.7: Ejemplo de la transmisin de los genricos en una referencia a componente
Aunque el uso de genricos tiene muchas ventajas, no siempre es conveniente usarlos. Algunas herramientas slo admiten algunos tipos concreto de datos para los genricos. Y por otro lado, no conviene declarar una gran cantidad de genricos. Algunos recomiendan el uso de genricos slo para ciertos aspectos en concreto, por ejemplo para simulacin (definir retardos o condiciones variables), o tambin cuando segn determinadas condiciones se quiera variar el valor de los genricos de un componente. Estatcnica,aunquemuytil,porahoranolavamosaver.
6.3. Uso de paquetes

Una alternativa al uso de genricos es declarar las constantes en un paquete. El VHDL permite declarar constantes, tipos, funciones, procedimientos, etc. en paquetes de modo quesepuedanutilizarentodoeldiseosintenerquedeclararlosencadafichero. De hecho, ya hemos estado usando paquetes al incluir las siguientes sentencias (cdigo 6.8)encadaficheroVHDL.
library IEEE; use IEEE.STD_LOGIC_1164.ALL;
Cdigo 6.8: Inclusin del paquete STD_LOGIC_1164 de la biblioteca IEEE
Con la primera sen estamos diciendo que vamos a incluir la biblioteca IEEE. Con la segunda sentencia decimos que de la biblioteca IEEE vamos a usar el paquete STD_LOGIC_1164.ElALLdelfinalindicaquepodremosusartodoloqueincluyeelpaquete. Ahora crearemos un sencillo proyecto en el que incluiremos un paquete. El nombre del proyectoserled_pkg. Un paquete se crea en un fichero aparte. Para crear un nuevo paquete, desde la herramienta ISE crearemos una nueva fuente como ya sabemos hacer, pero indicaremos queesdetipoVHDLPackage.AlhacerlolaherramientaISEincluyeunospatronesquenos pueden servir de ayuda para recordar la sintaxis. De todos modos, como nuestro paquete vaasermuysencillonosbastaconcopiarelcdigo6.9.
package CTE_PKG is -- Paquete de definicion del nivel logico de las constantes constant c_on : std_logic := '0'; --solo tenemos que cambiar aqui segn la lgica constant c_off : std_logic := not c_on; end CTE_PKG;
Cdigo 6.9: Paquete con la definicin de las constantes
73
En el cdigo 6.9, la constante de encendido c_on se ha puesto a '0', por tanto correspondera a la versin de la XUPV2P, para la Nexys2 bastara con poner esta constantea'1'. EnlaherramientaISElospaquetesnoestnalavistadesdelaventanaSources.Parapoder editar un paquete tienes que pinchar en la pestaa Libraries y desplegar la carpeta work, allverssielpaqueteestincluidoono.Pinchandoenlpodrseditarlo.Enlafigura6.1 semuestraunaventanaquemuestralaanteriorexplicacin.
Dentro de work
Paquete
Seleccionar Libraries
Figura 6.1: Cmo ver el paquete incluido en el proyecto
Ahora crearemos una entidad que va a usar este paquete. La entidad simplemente tendr que apagar el led ld0 y encender el ld1. La entidad sera como la mostrada en el cdigo 6.10.
library IEEE; use IEEE.STD_LOGIC_1164.ALL; library WORK; use WORK.CTE_PKG.ALL; entity led is Port ( ld0 : out ld1 : out end led; -- la biblioteca por defecto del diseno se llama WORK
STD_LOGIC; STD_LOGIC);
architecture Behavioral of led is begin ld0 <= c_off; ld1 <= c_on; end Behavioral;
Cdigo 6.10: Entidad y arquitectura que usan el paquete del cdigo 6.9
Observando el cdigo 6.10 podemos apreciar que no tenemos que modificar la entidad y la arquitectura para usarlas en la XUPV2P o en la Nexys2, nos bastara con modificar el valor de la constante del paquete (cdigo 6.9). Esto nos permite realizar diseos ms fcilmente adaptables a otros entornos. En nuestro caso, podemos usar ambas placas con menoresinconvenientes.
74
En el cdigo 6.10 podemos observar que la biblioteca del paquete que hemos creado se llama WORK. Esta es la biblioteca por defecto, la biblioteca de trabajo y por lo general, pondremosnuestrospaquetesenesabiblioteca(sinodecimosnada,estarnah). Ahora, prueba a implementar este diseo en la XUPV2P y en la Nexys2. Lo nico que tienes que hacer es crear el paquete del cdigo 6.9 y la entidad y arquitectura del cdigo 6.10. La constante del paquete la tendrs que cambiar segn en qu placa lo ests implementando,igual queelfichero.ucf,questeinevitablementevaaserdistinto,pues esespecficoparacadaplaca.
75
7. Transmisin en serie por RS-232

El objetivo de esta prctica es realizar un diseo de mediana complejidad. Para la realizacin de este circuito es importante que tengas claro la teora de los registros de desplazamiento y las mquinas de estados finitos (FSM22) y cmo se implementan en VHDL. Si tienes dudas o te has olvidado, te recomendamos que realices las prcticas de ED2, en concreto los captulos 7, 9 y posteriores del libro [17mach]. Una buena prctica seraquelasimplementasesenlasplacasXUPV2PyNexys2. En esta prctica vamos a establecer una comunicacin asncrona entre la placa y una computadora.Esunbuenejemplodediseojerrquicoyconfigurable,enelqueadems se van a repasar las mquinas de estados finitos y registros de desplazamiento, y nos servir para aplicar conceptos vistos en prcticas anteriores, como los divisores de frecuenciayelusodepaquetesenVHDL. Por otra parte, y aunque en el captulo 5 de este manual ya se utiliz la herramienta de simulacin Modelsim, en esta prctica se va a explicar en detalle cmo hacer un banco de pruebas(testbench)ycomointerpretarlosresultadosqueseobtienendelsimulador. Debido a que esta prctica es larga y se aplican conceptos importantes, en el apartado siguienteseresumesucontenido.
7.1. Desarrollo de la prctica

En primer lugar, se expondr la metodologa propuesta para afrontar el diseo de un circuitocomplejo,enlaqueesfundamentalrealizarunaparticindelcircuitoenmdulos mssencillos. Posteriormente, en el apartado 7.3 se explicar brevemente el funcionamiento de una UART y el envo de datos mediante el protocolo serie RS232: tamao de datos, trama de datos,sealesqueseutilizanenlacomunicacin,velocidaddetransmisin,etc. A continuacin se propone un diseo modular, en el que primero se har el transmisor (en el apartado 7.4), despus el receptor para posteriormente integrarlos en un nico diseo. Para disear el transmisor lo primero que se hace es identificar las entradas y salidas. A continuacin se plantea su diagrama de bloques. El diseo que se propone es un diseo configurable, en el que el uso de constantes, funciones y paquetes facilita la reutilizacin y reduce las fuentes de errores al utilizar dos placas distintas en las prcticas. Una vez diseado el transmisor se procede a su comprobacin (apartado 7.5). Para ello crearemos el banco de pruebas, y mediante un simulador (el del ISE o el ModelSim) verificaremos el funcionamientodelcircuito. Para terminar con el transmisor, lo implementaremos en la FPGA y nos comunicaremos conlacomputadoramedianteelpuertoserie. De forma anloga a como se ha realizado el transmisor se disear el receptor, para posteriormente implementar la UART completa. En un diseo estructural conectamos el
22
FSM:delingls:FiniteStateMachine
77
transmisor y el receptor de manera que lo recibido por el receptor se emita por el transmisor,obtenindoseelecoenlacomputadora.
7.2. Consideraciones para el diseo de un circuito

Antes de explicar qu es una UART y abordar su diseo, vamos a introducir unas consideraciones previas, a tener en cuenta no slo para esta prctica sino tambin cada vezquenosenfrentemosconeldiseodeuncircuitodigital. Comoyasehacomentadoanteriormenteelobjetivofundamentalquesepersigueconeste manual es aprender a disear circuitos digitales de relativa complejidad usando VHDL y dispositivoslgicosprogramables(CPLDoFPGA).Paraconseguiresteobjetivo,alolargo del manual se propone un metodologa para el diseo de estos circuitos. Para ello los pasosaseguirson:

Estudiodelasespecificaciones Divisinfuncional Integracindecadaunodelosbloques(omdulos).
La particin del circuito en bloques (divisin funcional) es muy importante para poder abordar un diseo complejo. En el apartado 2.10 vimos las ventajas de realizar la particin,algunasdeellasson:

Independizarlosbloques:cadaunadelaspartessonindependientes Poderrepartireltrabajoentrevariaspersonas Simplificarlacomplejidaddeldiseo,pueslosbloquessonmssencillos.Estohaceque seamsfcildedisearydeverificar. Simplificar la verificacin del diseo. Como los bloques estn verificados de manera independiente,laverificacindelconjuntoresultamssencilla. Y otras ventajas como mayor facilidad para reutilizar los bloques, modificarlos, usar otrosyadiseados,...
Para cada uno de los bloque funcionales en que se dividida el proyecto habr que identificar entradas y salidas, realizar el diseo y por ltimo, comprobar su correcto funcionamiento.Paraverificar quenuestromdulohacelo quetiene quehacer,ynohace lo que no tiene que hacer, se utilizarn las herramientas de simulacin. Mediante la generacin de estmulos y la interpretacin de los resultados de la simulacin podremos identificar y detectar errores antes de implementar el diseo en la FPGA. Por ltimo, una vez que se hayan validado cada uno de los bloques funcionales se proceder a la integracinenelsistemacompleto.
7.3. Funcionamiento de una UART

En esta prctica disearemos un transmisor/receptor serie asncrono (Universal Asynchronous ReceiverTransmitter) que siga la norma RS232. Este mdulo nos permitir comunicar nuestra placa con el puerto serie de la computadora. En la norma se definen dos tipos de terminales: DTE y DCE, donde DTE es el equipo terminal de datos (la computadora)yDCEeseldecomunicacindedatos,yquehabitualmenteesunMODEM yennuestrocasoeslaplacadelaFPGA.
78
Aunque en la norma se definen ms seales, para establecer la comunicacin slo son imprescindiblestresseales:lalneadetransmisindedatos(TxD),laderecepcin(RxD),y la lnea de masa (GND). Como puedes ver en la figura 7.1, la referencia se toma desde la computadora (el DTE). Por tanto, desde el punto de vista de la FPGA (DCE), la seal RxD eslaquesetransmitealacomputadora,mientrasquelasealTxDeslaqueserecibedela computadora.Tendremosquetenercuidadoporqueestonospuedeconfundir.
(cables) imprescindibles: Tres lneas (cables)
2
RxD TxD GND
RxD 3 TxD
2 5
3 5
DCE
Data Communications Equipment
DTE
Data Terminal Equipment
Figura 7.1:Esquema de la conexin RS-232
Para la conexin serie, las placas tienen un conector DB9 como el mostrado en la figura 7.2.ElconectorDB9hembraestenelDCEyelmachoenelDTE(computadora).
GND TxD: Computadora FPGA RxD: FPGA Computadora
5 3 2
Figura 7.2: Conector DB9 hembra de la placa y los pines utilizados
Los pines de la FPGA que estn conectados con el puerto RS232 se muestran en la tabla 7.1. Aunque la placa XUPV2P tiene disponibles ms pines que estn incluidos en el protocolo, sin embargo slo utilizaremos los dos imprescindibles23 (mostrados en la tabla 7.1).Paraevitarconfusionesacercadelosnombres,lospuertosdelRS232losllamaremos comomuestralatabla7.1,demodoquealincluirelprefijoFPGAindicamosquehacemos referencia a la FPGA. Por tanto, el puerto FPGA_TX representa el dato que enva la FPGA a la computadora, que en el protocolo RS232 sera el RxD por estar referenciado al computador.
Puerto FPGA_TX FPGA_RX Sentido XUPV2P FPGA Computadora Computadora FPGA AE7 AJ8 PIN Nexys2 P9 U6
Tabla 7.1: Puertos del RS-232 que usaremos y los pines en las placas
Existen distintas velocidades de transmisin, que se definen en bits por segundo (bps) o baudios (921600, 460800, 230400, 115200, 57600, 38400, 19200, 9600, 4800, ). Tambin se
23
EnlaNexys2nohaymspinesdisponiblesparalaUART
79
puede variar el nmero de bits del dato que se enva, as como el envo de un bit de paridadyelnmerodebitsdefin. La lnea serie permanece a nivel alto (1) mientras no se envan datos. Cuando el transmisor va a empezar la transmisin, lo hace enviando un bit de inicio poniendo la lnea a cero. Posteriormente se envan consecutivamente los bits del dato empezando por elmenossignificativo.Despusdelltimobitdedatoseenvaelbitdeparidadencasode quesehayaespecificado.Porltimo,secierralatramaconunoodosbitsdefinponiendo la lnea a nivel alto. En la figura 7.3 se muestra el cronograma de un envo RS232 con 8 datos(enesteejemplo:11011101),unbitdeparidad(enestecasopar)yunbitdefin.
dato de 8 bits 11011101 bit de bit de bit de inicio in icio bit 0 bit 1 bit 2 bit 3 bit 4 bit 5 bit 6 bit 7 paridad fin lnea en reposo reposo
Transmisin dato de 8 bits En reposo TxD est a '1' bit de inicio a '0' dato de 7 u 8 bits paridad par paridad impar sin bit de paridad Uno dos bits de fin
Figura 7.3: Trama de un envo en RS232 con 8 bits, bit de paridad y un bit de fin
La prctica consistir en disear una UART compatible con RS232 que enve 8 bits de datos, que pueda recibir y transmitir simultneamente (fullduplex), sin bit de paridad y conunbitdefin. Para ir paso a paso, primero se realizar slo el transmisor. Posteriormente se realizar el receptor,paraluegounirlosenunnicodiseo.
7.4. Diseo del transmisor

Haremosuntransmisorquetendrlossiguientespuertos(figura7.4):
8 UART_TX dato_tx_in de/hacia nuestro sistema transmite transmitiendo fpga_tx clk rst hacia el exterior (computadora) (computad ora) FPGA_TX Pines: AE7 (XUPV2P) P9 (Nexys2)
Figura 7.4: Entradas y salidas del transmisor
En la figura 7.4, los puertos de la izquierda son los que se relacionan con nuestro sistema (elqueimplementemosenlaFPGA)yelpuertodeladerecha(fpga_tx)envaeldatoserie a la computadora. Antes de pasar a describir las seales, en la tabla 7.2 se incluyen unas constantes que se usarn en el diseo (recuerda el captulo 6). Fjate que las constantes comienzanporc_paraqueseamsfcilsuidentificacin.
80
Constante
c_on c_freq_clk c_baud
Tipo
std_logic natural natural
Descripcin Indicaelniveldelalgica.1paralgicapositiva(Nexys2),y0para lgicanegada(XUPV2P) Frecuenciadelreloj.Ennuestrocaso:108paralaXUPV2Py5107parala Nexys2 LosbaudiosalosquevaatransmitirlaUART:9600,115200,... Tabla 7.2: Constantes de la UART para su configuracin
Lasespecificacionesdelospuertossonlassiguientes:
Puerto
rst clk transmite dato_tx_in
bits I/O
Descripcin
1 I Sealderesetasncrono,suniveldependerdec_on 1 I 1 I 8 I
Sealderelojdelaplaca.Lafrecuenciadelrelojseindicaenlaconstante c_freq_clk. Sealdelsistemaqueordenaalmdulolatransmisindeldatoquese encuentraendato_tx_in.Laordenserdeunnicociclodereloj. Datoquesequiereenviar,seproporcionacuandoseactivatransmite (cuandotransmite='1') Indicaalsistemaqueelmduloesttransmitiendoyportantonopodr
transmitiendo
1 O atenderaningunanuevaordendetransmisin.Ignoraratransmite
cuandotransmitiendo estauno
fpga_tx
1 O Tramaqueseenvaenseriealacomputadora,sigueelformatoRS232
Tabla 7.3: Puertos del transmisor de la UART
Con estas especificaciones tenemos informacin suficiente para hacer el transmisor. Lo primero que tienes que hacer es crear un nuevo proyecto llamado uart_tx. Dentro del proyecto crea el paquete UART_PKG (recuerda la seccin 6.3 para ver cmo se crean los paquetes) e incluye las constantes de la tabla 7.2. Es importante que en el paquete pongas comentarios sobre el significado y los valores de las constantes, y sobre todo, que comentes qu valores son los ms habituales. En nuestro caso deberas de comentar qu valores tendra si se usase para la XUPV2P y para la Nexys2. Para mostrar un ejemplo de cmosepuedenponerestoscomentarios,sehaaadidoelcdigo7.1.
package UART_PKG is --------------------- declaracion de constantes ----------------------------------- c_on: indica el tipo de logica de los pulsadores, interruptores y LEDS -- si es '1' indica que es logica directa -> PLACA NEXYS2 -- si es '0' indica que es logica directa -> PLACA XUPV2P constant c_on : std_logic := '0'; -- XUPV2P -- c_freq_clk: indica la frecuencia a la que funciona el reloj de la placa -- para la Nexys2 el reloj va a 50MHz -> 5*10**7; -- para la XUPV2P el reloj va a 100MHz -> 10**8; constant c_freq_clk : natural := 10**8; -- XUPV2P -- c_baud: indica los baudios a los que transmite la UART, valores -- tipicos son 9600, 19200, 57600, 115200 -- Este valor depende de la conexion establecida con la computadora constant c_baud : natural := 115200; end UART_PKG;
Cdigo 7.1: Paquete con la declaracin de constantes
81
Ahora crea la entidad UART_TX. En la entidad incluye los puertos de la tabla 7.3 y no te olvidesdeincluirlareferenciaalpaqueteenlacabeceradelaUART24. El siguiente paso es disear el transistor de la UART por dentro, es decir, tenemos que crear la arquitectura. Con lo que ya sabemos, te recomendamos que pienses cmo lo haras antes de pasar a ver la solucin propuesta. Existen muchas alternativas de diseo para una misma funcionalidad y la que se propone aqu no es la nica ni tampoco tiene queserlamejor. Segn las especificaciones del funcionamiento del protocolo RS232 podemos pensar que necesitaremos: Undivisordefrecuenciaparagenerarunasealperidicaconlafrecuenciaindicadaenlos baudios. Unregistroqueguardeeldatoquevamosaenviar,yquelovayadesplazandosegnelbit queestemosenviando Un selector (multiplexor) que enve el bit de inicio, el bit de fin, los bits de datos o que mantengaenreposolalnea. Unbloquedecontrolqueindiquealrestodebloquesenqueestadoestamos,esdecir,qu esloquetocaenviar:bitdeinicio,defin,bitsdedatosoreposo.
As que en una primera versin hemos identificado estos cuatro bloques que podran organizarse como se muestra en la figura 7.5. Normalmente, estas primeras versiones las tendremos que modificar conforme vamos realizando el circuito. An as, cuanto ms lo pensemos al principio, menos modificaciones tengamos que hacer, y posiblemente perdamosmenostiempo.
Carga_desplz
dato_tx_in
Seleccion
'0' transmite desplaza '1' clk rst
n
fpga_tx
Control
transmite transmite transmitiendo transmitiendo baud clk rst
desplaza clk rst estado_tx
DivFreq
clk rst baud
Figura 7.5: Diagrama de bloques preliminar del transmisor de la UART
Acontinuacinexplicaremoscadaunodelosbloques.
7.4.1. Divisor de frecuencia

Este bloque se corresponde con el bloque DivFreq de la figura 7.5. Estebloque generar la sealqueindicacundohapasadoelintervalodetiempocorrespondienteacadabitdela
24
Recuerdaelcdigo6.10:library WORK; use WORK.UART_PKG.ALL;
82
tramadeenvo(figura7.3).Estasealtendrunafrecuenciadeterminadaporlaconstante c_baudyquesecorrespondeconlosbaudiosalosquesecomunicarlaUART.Encasode que te hayas olvidado de los contadores y divisores de frecuencia, te recomendamos que repaseselcaptulo6delasprcticasdeED2[17mach]. Estediseoloqueremoshacerconfigurable,demodoquesienundeterminadomomento queremos cambiar los baudios de la UART o si usamos una placa con distinta frecuencia de reloj, no tengamos que rehacer el circuito, sino que nos baste con cambiar el valor de lasconstantes(tabla7.2ycdigo7.1). Realizar un diseo configurable es ms complicado al principio y hace que se tarde ms en disear. Sin embargo, a la larga hace ahorrar mucho tiempo porque no hace falta redisear. Adems el diseo configurable suele ser ms seguro, ya que si tenemos que redisearuncircuitopodemoscometernuevoserrores. En nuestro caso, el diseo configurable tambin nos puede hacer ahorrar tiempo de simulacin, ya que para simular se pueden poner frecuencias mayores de envo de la UART,yasnotenerqueesperarloslargostiemposdesimulacin. Para facilitar la comprensin y el diseo, antes de pensar en el diseo configurable, veamoscmoharamoseldiseoconvaloresconcretos. Por ejemplo, a partir del reloj de la placa XUPV2P de 100 MHz (clk) supongamos que queremostransmitirconfrecuenciade9600Hz(baud).Portanto,lasealc_baudtendrun periodo de 104,167 s, y la crearemos de modo que est un nico ciclo de reloj a uno y el restodeltiempoacero.Lafigura7.6representaloscronogramasdelassealesdeentrada (clk)ysalida(baud).
T=104,167 s T=10 ns
DivFreq Di vFreq
Clk Cl k rst baud
10 ns
100 MHz
9600 Hz
Figura 7.6: Divisor de frecuencia de 100 MHz a 9600 Hz
Para disear el divisor de frecuencia se divide la frecuencia de entrada entre la frecuencia de salida (100MHz/9,6kHz = 10416,6710417) y el nmero resultante nos dar la cuenta necesaria para obtener la frecuencia de salida. Hacindolo de manera inversa, 10417 cuentas de 10 ns (clk) nos da un periodo de 104,17s, que es una buena aproximacin de lafrecuenciaquequeremos.Estoes,queremos9600Hzyobtenemos9599,69Hz. Para la creacin de este bloque habra que tener en cuenta lo explicado referente a los rangos numricos del apartado 4.2, y en vez de crear un contador con rango de 0 a 10416 que no tiene ninguna correspondencia fsica, lo haramos con el rango que delimite el anchodelbus.Comolog2(10416)=13,35;necesitaramos14bitsparaelcontador. Aunqueenesteejemplonoestanimportantecontarunciclomsomenos,yaque10nses despreciable frente a 104,167 s, en general hay que ser cuidadosos para hacer un contador que cuente el nmero de ciclos que queremos. Conviene dibujar el cronograma delcircuito(figura7.7)yposteriormentedisearlo.
83
10413 ciclos de reloj T=10 ns
fin de la cuenta if clk'event and clk='1' then if cuenta = 10416 then cuenta <= 0;
clk cont_baud baud

0 1 10414 10415 10416 0 1
10417 x 10 ns
Figura 7.7: Cronograma del contador del divisor de frecuencia en el final de la cuenta
A partir del cronograma podemos ver que una vez que cont_baud valga 10416 es cuando debemosinicializarelcontador.Comolastransicionesocurrenduranteelflancoactivode reloj (clk'event and clk='1') podemos confundirnos con los valores que se evalan para cadasealeneleventodereloj,quvalorhemosdeponerenlacomparacin,elanterior o el posterior a la transicin? En nuestro caso, comparamos con 10416 o con 10417 para iniciarelcontador? Lafigura7.8muestraelcronogramaampliado. clk Podemosapreciarqueesapartirdelflancodel reloj cuando las seales registradas (cont_baud 10416 0 1 cont_baud y baud) cambian de valor, por tanto, se comparan los valores que las seales tienen baud justo antes del flanco de reloj. Por tanto, en nuestrocaso,comparamoscon1416. Figura 7.8: Cronograma en la transicin a cero Ahoraqueyasabemoscmohacereldiseoconvalores concretos,veamoscmose hara configurableconlasconstantes. Enelejemploanterior,paracalcular elfindecuentadividimoslafrecuenciaderelojdela placaentrelavelocidaddetransmisin(100MHz/9,6kHz=10416,6710417).Porlotanto, en vez de hacer que el fin de cuenta sea hasta 10417, usaremos una constante (c_fin_conta_baud) que tenga el valor resultante de la divisin entre la constante que indica la frecuencia y la constante que indica la velocidad de transmisin. Esta constante semuestraenelcdigo7.2yladeberemosincluirenelpaquete.Eloperador/realizala divisinentera.Observaqueselerestaunoporquelacuentaempiezadesdecero.
constant c_fin_cont_baud : natural := c_freq_clk/c_baud - 1;
Cdigo 7.2: Constante para el clculo del fin de cuenta de divisor de frecuencia de la UART
Conesto,enlaarquitecturadeltransmisorpodramosdeclararlasealdelacuentaconel rangodependientedelaconstantec_fin_cont_baud.
signal cont_baud : natural range 0 to c_fin_cont_baud;
Cdigo 7.3: Rango de la seal cuenta basado en la constante de fin de cuenta
Sin embargo, con el cdigo 7.3 cometemos el mismo fallo que mostramos en el apartado 4.1 (recuerda los cdigos 4.1 y 4.3), en donde el rango no es potencia de dos. Esto lo podramos solucionar asegurndonos que la seal nunca sobrepase el fin de cuenta,
84
aunque una alternativa ms segura es usar una funcin que calcule el rango. Esto se explicarenelsubapartadosiguiente. 7.4.1.1. Uso de funciones Queremos calcular cuntos bits necesitamos para la seal cont_baud, para ello podemos crear una funcin que nos calcule el logaritmo en base dos del valor del fin de cuenta (c_fin_cont_baud). En VHDL una funcin puede tener varios argumentos de entrada y devuelveunasalida. En VHDL se pueden declarar funciones en la parte declarativa de la arquitectura (antes del begin), sin embargo nosotros la pondremos en el paquete que hemos creado. De esta maneralapodremosusarenelrestodemdulosdeldiseo. Por tanto, se ha de incluir la declaracin de la funcin (cdigo 7.4) en el paquete que hemos creado (cdigo 7.1). Es decir, copia el cdigo 7.4 en el paquete UART_PKG. Observa loscomentariosdelafuncin,esimportantequeincluyascomentariosparasabercmose usalafuncinsintenerquemirarteelcdigoparadescubrirsufuncionamiento.
--------------------------- funcion: log2i --------------------------------------- Descripcion: funcion que calcula el logaritmo en base 2 de un numero entero -positivo. No calcula decimales, devuelve el entero menor o igual -al resultado - por eso la i (de integer) del nombre log2i. -P. ej: log2i(7) = 2, log2i(8) = 3. -- Entradas: -* valor: numero entero positivo del que queremos calcular el logaritmo en -- Salida: -* devuelve el logaritmo truncado al mayor entero menor o igual que el resultado function log2i (valor : positive) return natural;
Cdigo 7.4: Declaracin de una funcin para el clculo del logaritmo
Cuando una funcin se declara en un paquete, el cuerpo de la funcin (function body) se tiene que incluir en el cuerpo del paquete (package body). El cuerpo del paquete lo podemoscrearacontinuacindelpaquete(package). Paracalcularellogaritmo,lafuncinlog2itendrquedividirpordosdemanerasucesiva hasta que el resultado sea cero (realizando la divisin entera). El nmero de divisiones quehayamosrealizadonosindicarelnmerodebitsnecesarios. En el cdigo 7.5 se ha incluido el cuerpo del paquete UART_PKG y dentro se ha incluido el cuerpo de la funcin log2i. Observa que se han incluido comentarios que explican cmo realiza las operaciones internamente. Quiz no sea necesario tanto detalle, pero es importante para facilitar la labor en el futuro si tuvieses que hacer correcciones o modificaciones.Copiaestecdigoeinclyelodespusdelpaquete.
85
Package body UART_PKG is -------------------- Funcion log2i ---------------------------------------- Ejemplos de funcionamiento (valor = 6, 7 y 8) -- * valor = 6 | * valor = 7 | * valor = 8 -tmp = 6/2 = 3 | tmp = 7/2 = 3 | tmp = 8/2 = 4 -log2 = 0 | log2 = 0 | log2 = 0 -- loop 0: tmp 3 > 0 | - loop 0: tmp 3>0 | - loop 0: tmp 4>0 -tmp = 3/2 = 1 | tmp = 3/2 = 1 | tmp = 4/2 = 2 -log2 = 1 | log2 = 1 | log2 = 1 -- loop 1: tmp 1 > 0 | - loop 1: tmp 1 > 0 | - loop 1: tmp 2 > 0 -tmp = 1/2 = 0 | tmp = 1/2 = 0 | tmp = 2/2 = 1 -log2 = 2 | log2 = 2 | log2 = 2 -- end loop: tmp = 0 | - end loop: tmp = 0 | - loop 2: tmp 1 > 0 -- * return log2 = 2 | * return log2 = 2 | temp = 1/2 = 0 -| log2 = 3 -| - end loop: tmp = 0 -| * return log2 = 3 function log2i (valor : positive) return natural is variable tmp, log2: natural; begin tmp := valor / 2; -- division entera, redondea al entero inmediatamente menor o = log2 := 0; while (tmp /= 0) loop tmp := tmp/2; log2 := log2 + 1; end loop; return log2; end function log2i; end UART_PKG;
Cdigo 7.5: Cuerpo del paquete UART_PKG y cuerpo de la funcin log2i
Observa que dentro de la funcin se han declarado variables, que son distintas que las seales. A diferencia de las variables, las seales no se pueden declarar dentro de una funcin.Laasignacindelasvariablesserealizaconeloperador:=.Lasvariablestoman su valor con la asignacin y no como ocurre con las seales en los procesos que toman el valoralsalirdeproceso. Fjate que la funcin devuelve un nmero menor al nmero de bits necesario, por ejemplo,pararepresentarun6necesitamos3bitsyno2(queserloquedevuelvalog2i). Si queremos representar un entero, tendremos que sumar uno al resultado, sin embargo, paralostiposunsignednosvienebienas,porqueelrangoincluyeelcero.Parafacilitarla sucomprensin,enlafigura7.9sedetallaesteconcepto.
Queremos representar el 6 Al calcular el logaritmo con log2i el resultado es 2: log2i(6) 2 Si queremos usar un natural hay que sumarle 1: Si queremos usar un unsigned no hay que sumar nada:
2+1
signal sen_nat: natural range 0 to 2**3-1; 7
signal sen_us: unsigned (2 downto 0); 3 bits: de 0 a 7
Figura 7.9: Uso del valor devuelto por la funcin log2i para la obtencin del rango de un natural y un unsigned
En el cdigo 7.6 se muestran un ejemplo de cmo se declararan dos seales (natural y unsigned)apartirdelresultadodevueltoporlafuncinlog2i.
constant log2_6 : natural := log2i(6); -- para representar 6, log2i devuelve 2 signal sen_nat: natural range 0 to (2**(log2_6+1))-1; -- si es entero hay que sumar 1 signal sen_us : unsigned (log2_6 downto 0); -- si es unsigned dejamos igual
Cdigo 7.6: Ejemplo de la utilizacin del resultado de la funcin log2i para los rangos de las seales
86
As pues, declararemos una constante que represente el nmero de bits necesarios para el contador (en realidad el nmero de bits menos 1). Esta constante la pondremos en el paquete. Tiene que estar despus de la declaracin de la funcin (cdigo 7.4) ya que utiliza dicha funcin25 (lo mejor es que la declaracin de la funcin la pongas al principio delpaquete).Estadeclaracinestenelcdigo7.7.
-- el numero de bits (nb) menos 1 necesarios para representar c_fin_cont_baud constant c_nb_cont_baud : natural := log2i(c_fin_cont_baud);
Cdigo 7.7: Constante que representa el nmero de bits menos uno del contador del divisor de frecuencia
Ahorayapodemosdeclararlasealdelcontadorenlaarquitectura.Elcdigo7.8muestra ladeclaracindelasealparaelcasodetipounsigned.
signal cont_baud : unsigned (c_nb_cont_baud downto 0); -- unsigned: dejamos igual
Cdigo 7.8: Declaracin de la sea , para el caso de tipo unsigned, que cuenta con el rango determinado por la constante calculada
Si quisisemos declararla como natural, podramos usar la declaracin del cdigo 7.9. Se ha incluido como ejemplo, ya que en este diseo disearemos el contador con tipo unsigned. Fjate que en el cdigo 7.9 se ha sumado 1 a la constante c_nb_cont_baud, y luego se le resta 1 al resultado de la exponenciacin, no es que se le estemos restando 1 otra vez al exponente. Esto es por la precedencia de los operadores, la exponenciacin tienemayorprecedenciaquelaresta.
signal cont_baud : natural range 0 to 2**(c_nb_cont_baud+1)-1; -- entero: sumar 1
Cdigo 7.9: Declaracin de la seal, para el caso de tipo natural, con el rango determinado por la constante calculada
As que con la seal declarada, ya podemos realizar el divisor de frecuencia. Intenta hacerlo t mismo sin mirar el cdigo 7.10, de todos modos, como se han introducido muchas constantes y conceptos nuevos, hemos incluido una posible solucin para que la compares con tu divisor de frecuencia. Es importante que antes de mirar la solucin disees la tuya, pues conforme avancemos en el libro, se va a reducir el cdigo de ejemplo.
P_DivFreq: Process(rst,clk) begin if rst = c_on then cont_baud <= (others => '0'); -- todo a cero baud <= '0'; elsif clk'event and clk='1' then baud <= '0'; -- por defecto, siempre a cero if cont_baud = c_fin_cont_baud then baud <= '1'; -- avisamos de fin de cuenta cont_baud <= (others => '0'); else cont_baud <= cont_baud + 1; end if; end if; end process;
Cdigo 7.10: Proceso del divisor de frecuencia del transmisor de la UART
7.4.1.2. Operaciones con constantes y con seales en VHDL En el captulo 8 veremos que muchas de las operaciones que se consideran simples, como ladivisin,notienenunaimplementacindirectaenhardware.Porejemplo,pararealizar
25
Importante:Enalgunossimuladores(porejemplo,laversin6.0deModelsim),nosepuedeusaruna funcinantesdetenerdeclaradosucuerpo.Sitienesesteproblemaconsultaelapartado7.4.1.3
87
una divisin tenemos que disear un mdulo VHDL que describa el hardware que la implemente,yyaveremosquenohaynicamaneradeimplementarundivisor. A raz de esto nos podramos preguntar si lo que hemos hecho en el apartado anterior es correcto, ya que hemos calculado el logaritmo de un nmero mediante divisiones sucesivas. Por tanto podramos preguntarnos podemos realizar estas divisiones en VHDLtaninocentemente?larespuestaessegnconquoperandos. Al sintetizar en VHDL se pueden realizar clculos complejos (divisiones, exponenciaciones,...) en el caso de que esas operaciones se realicen durante el proceso de sntesis (antes de bajarlo a la FPGA). Esto implica que los operandos tienen que ser constantes.Esdecir,podemosrealizarellogaritmode234,peronopodemosimplementar el logaritmo de la seal X (en realidad se podra, pero tendramos que describir en VHDL elmdulosintetizablequeloimplementase). Asquelafuncinlog2ilapodemosutilizarparacalcularellogaritmodeconstantes,pero no la podremos utilizar para implementarla en el circuito y calcular el logaritmo de seales,puesvanacambiar. Durante la sntesis, la herramienta ISE es la que calcula los valores resultantes de aplicar la funcin log2i a las constantes. Es decir, no es el circuito VHDL el que implementa la funcin y calcula el resultado, sino el sintetizador. Si fuesen seales (que cambian de valor) no se podra calcular el valor durante la sntesis, y por tanto habra que implementarenhardwareeloperador,yporlotantonosepodrausarlafuncin. 7.4.1.3. Uso de funciones dentro del mismo paquete En algunos simuladores (por ejemplo, la versin 6.0 de Modelsim), no se puede usar una funcin antes de tener declarado su cuerpo. Esto hace que no podamos usar una funcin paraconstantesdeclaradasenelmismopaquete.Estecasosemuestraenelcdigo7.11.
package UART_PKG is function log2i (valor : positive) return natural; constant c_nb_cont_baud : natural := log2i(c_fin_cont_baud); end UART_PKG; Package body UART_PKG is function log2i (valor : positive) return natural is variable tmp, log2: natural; begin tmp := valor / 2; -- division entera, redondea al entero menor log2 := 0; while (tmp /= 0) loop tmp := tmp/2; log2 := log2 + 1; end loop; return log2; end function log2i; end UART_PKG;
Cdigo 7.11: El uso de funciones dentro del mismo paquete da problemas en algunas herramientas
Esto no es un problema para el ISE, pero si queremos usar la versin 6.0 del Modelsim, parasolucionarestotenemosqueusardospaquetes,unodelospaquetestendrtodaslas declaraciones de funciones (UART_PKG_FUN) y en ese fichero incluiremos el cuerpo del paquetecontodosloscuerposdelasfunciones. En el segundo paquete incluiremos todas las declaraciones de constantes (UART_PKG). El paquetequetienelasdeclaracionesdeconstantestendrquereferenciarelpaquetequede
88
las funciones26, mientras que el resto de unidades harn referencia al paquete de las constantes, a no ser que necesiten usar alguna de las funciones y entonces tambin tendrnquehacerreferenciaalosdospaquetes. ExisteunaalternativaparaelModelsim,queesusardeclaracionesdiferidasdeconstantes (deferred constant). Esto consiste en declarar la constante en el paquete sin darle valor y volver a declarar la constante dndole su valor en el cuerpo del paquete, despus del cuerpodelafuncin.Enelcdigo7.12semuestracmosolucionarelcdigo7.11.
package UART_PKG is function log2i (valor : positive) return natural; -- declaracion diferida de constante (deferred constant), sin valor constant c_nb_cont_baud : natural; end UART_PKG; Package body UART_PKG is function log2i (valor : positive) return natural is variable tmp, log2: natural; begin tmp := valor / 2; -- division entera, redondea al entero menor log2 := 0; while (tmp /= 0) loop tmp := tmp/2; log2 := log2 + 1; end loop; return log2; end function log2i; -- se le da el valor a la constante en el cuerpo del paquete constant c_nb_cont_baud : natural := log2i(c_fin_cont_baud); end UART_PKG;
Cdigo 7.12: Uso de constantes diferidas para evitar problemas por usar funciones dentro del mismo paquete (cdigo 7.11). No vale para el ISE
Por desgracia, este mtodo no lo acepta el ISE. Con esto puedes ver que muchas veces el diseador est limitado a las herramientas que utilice. En el caso que acabamos de ver, lo queaceptauna,noloaceptalaotrayviceversa. 7.4.1.4. Ms funciones Este apartado te lo puedes saltar si ests cansado de funciones, constantes y dems. Es simplementeuncomentarioparalosmsatentos. Quizs te has fijado que en el cdigo 7.2, el resultado de realizar la divisin entera de c_freq_clk/c_baud - 1 da 10415 y nosotros habamos calculado que la constante debera ser 10416 por el redondeo, ya que la divisin da 10416,67 y habamos redondeado a 10417 (y luegolehabamosrestadounoporquesecuentadesdecero). Como el operador / realiza la divisin entera truncando al entero inferior inmediato, nosotros podramos crear una funcin entera con redondeo al entero ms cercano. Esta funcin la podemos incluir en el paquete y calcular el fin de cuenta (cambiando el cdigo 7.2) con esta funcin en vez de con el operador /. Aunque incluimos la funcin en el cdigo7.13,intentahacerlaportimismoantesdemirarelcdigo.
26
Recuerdaelcdigo6.10:library WORK; use WORK.UART_PKG_FUN.ALL;
89
function div_redondea (dividendo, divisor: natural) return integer is variable division : integer; variable resto : integer; begin division := dividendo/divisor; resto := dividendo rem divisor; -- rem: calcula el resto de la division entera if (resto > (divisor/2)) then division := division + 1; end if; return (division); end;
Cdigo 7.13: Funcin para el redondeo
7.4.2. Bloque de control

El bloque de control es el encargado dirigir al resto de bloques. Para realizar el control podramos pensar en cuatro estados: inicial (reposo), envo del bit de inicio, envo de los 8 bits de datos y el envo del bit de fin (en caso de que hubiese bit de paridad habra que incluir un estado ms). La figura 7.10 muestra una versin preliminar deldiagramadeestados.
en reposo e_init
e_bit_fin enviando el bit de fin
e_bit_init enviando el bit de inicio e_bits_dato enviando los 8 bits de datos
Figura 7.10: Diagrama de estados preliminar del transmisor de la UART
Hay otras opciones alternativas a la figura 7.10, por ejemplo incluir un estado para cada bit. Como ya sabes, una misma funcionalidad se puede implementar demuchas maneras. Vamosaexaminarquharancadaunodeestosestados: Estado inicial (e_init): en este estado inicial el sistema est en reposo esperando la orden de transmitir. Por tanto, la lnea de transmisin estar a uno (fpga_tx='1'), ya que es el valor inactivo. Cuando la seal transmite valga 1 ser el indicativo de que se quiere transmitir un dato, y por tanto se pasar a enviar el bit de inicio: e_bit_init. En este momento se dar la orden de cargar el dato (seal cargadato) que se quiere enviar (dato_tx_in) en el registro de desplazamiento. Simultneamente debemos sincronizar el contadordeldivisordefrecuencia,paraellopodramosdeshabilitarelcontadorduranteel estado inicial para que no cuente. Esta seal de habilitacin (en_divfreq) no la habamos contempladoenlaversinpreliminardeldiagramadebloques(figura7.5). Envo de bit de inicio (e_bit_init): en este estado se est enviando el bit de inicio, poniendo la lnea de transmisin a cero (fpga_tx='0'). Se saldr de este estado cuando hayapasadoelperiododetiempocorrespondienteaunbit.Estetiempovienedeterminado por la seal baud, generada por el divisor de frecuencia (apartado 7.4.1). Despus de este tiemposepasaraenviarlosbitsdedato. Envo de los bits del dato (e_bits_dato): en este estado se envan los 8 bits del dato. Una alternativa a esta opcin sera poner un estado para cada bit, sin embargo, usaremos un estadoparalos8bitsy,medianteuncontador,llevaremoslacuentadelnmerodebitsque sehanenviado.Paraenviarcadabit,elcontrolgenerarlasealdesplazaqueleindicaal registrodedesplazamientoquetienedesplazarsusbits.Cuandosehayanenviado/contado los8bitselcontadorgenerarunaseal(fin_cont8bits)queindicarquehayquepasara enviarelbitdefinyporlotantocambiaremosdeestado(siquisisemosimplementarelbit
90
de paridad, ira ahora). Por lo dicho anteriormente, en el diagrama preliminar de la figura 7.5habrqueaadirunbloquequecuentelosbits. Envo del bit de fin (e_bit_fin): En este estado se enva el bit de fin, poniendo la lnea de transmisin a uno (fpga_tx='1'). Se saldr de este estado cuando haya pasado el periodo correspondiente a un bit (ponemos un nico bit de fin), este periododetiempoloindicalasealbaud.
baud e_init transmite
e_bit_fin
e_bit_init
En la figura 7.11 se muestra el diagrama de estadosconlaindicacindelassealesque Figura 7.11: Diagrama de estados con la indicacin hacencambiardeestado. de las seales que hacen cambiar de estado Comohemosvistoenelanlisisdecadaunodelosestados,noshacenfaltamssealese incluso un bloque nuevo respecto a lo que inicialmente vimos en la figura 7.5. As que el nuevo diagrama de bloques podra quedar como muestra la figura 7.12, donde se incluye el bloque contador de los bits que se van enviando, y las seales en_divfreq, cargadato y fin_cont8bits. Como siempre, existen multitud de propuestas que tambin seran vlidas.
Carga_desplz
fin_cont8bits
e_bits_dato
baud
dato_tx_in
dato_tx_rg
Seleccion
'0' '1' clk rst fpga_tx
cargadato
Control
cargadato transmite transmitiendo transmite desplaza transmitiendo en_divfreq estado_tx baud fin_cont8bits Clk clk rst baud rst
desplaza clk rst

2
DivFrec
en_divfreq
CuentaBits
baud clk rst fin_cont8bits estado_tx
Figura 7.12: Diagrama de bloques definitivo del transmisor
Observa que ahora el divisor de frecuencia tiene una seal de habilitacin (en_divfreq), as que tienes que modificar el cdigo 7.10 de modo que incluya la habilitacin del contador.Sinoteacuerdascmosehace,uncontadorconhabilitacinlopuedesverenel captulo16delmanualdeED2(cdigo16.2). En la tabla 7.4 se muestra la tabla de estados, entradas y salidas. Antes de mirarla intenta realizarla por ti mismo. Puede ser que algunas salidas no te salgan igual, especialmente
91
las de las transiciones, en algunas no tiene que ser un error que no estn iguales que la tabla7.4.
Entradas
fin_cont8bits
Salidas
cargadato en_divfreq 0 0 1 1 1 1 1
Estado
transmite
Estado siguiente
desplaza
Actual
e_init e_init e_bit_init e_bit_init
0 1 X X
X X 0 1 X X 0 1
X X X X 0 1 X X
e_init e_bit_init e_bit_init e_bits_dato e_bits_dato e_bit_fin e_bit_fin e_init
0 1 0 0 0 0 0 0
0 0 0 0
e_bits_dato X e_bits_dato X e_bit_fin e_bit_fin X X
baud 1 0 0 0
transmitiendo 0 0 1 1 1 1 1 1
baud
Tabla 7.4: Tabla de estados, entradas y salidas del transmisor de la UART
Fjate que la salida desplaza, se pone a uno cuando estando en el estado e_bits_dato la seal baud se pone a uno. Esto es porque cuando se estn enviando los bits de dato hay quedesplazarelregistrodedesplazamientoparacambiarelbitquese enva,estosedebe hacercuandotranscurreelperiododetiempomarcadoporlasealbaud. A partir de la tabla 7.4, el diagrama de la figura 7.11 y las explicaciones anteriores, quiz puedas realizar el mdulo de control. Si no, repasa los captulos 9 y posteriores del manualdeED2[17mach]. Tambin debes hacer el contador CuentaBits (figura 7.12). Fjate que este contador debe funcionar solamente estando en el estado e_bits_dato y que la seal fin_cuenta8bits se debedeactivarcuandosehayaterminadodetransmitireloctavobit.Aqudebesdetener en cuenta la sincronizacin y evitar contar de ms o de menos. Es muy probable que necesitessimularparacorregiralgnerror.
7.4.3. Registro de desplazamiento y multiplexor

Estos bloques se han visto en el manual de ED2 [17mach]. El registro de desplazamiento seexplicaenelapartado7.1yelmultiplexorenelapartado3.1dedichomanual,adems tienesejemplosdemultiplexoresenelapartado2.3deestemanual. Lasalidadelmultiplexorlapuedespasarporunbiestableyquesealasalidadelbiestable la que corresponda con la seal fpga_tx, ya que es una buena prctica de diseo registrar lassalidasdeldiseo. Importante: si registras la salida del multiplexor, como se recomienda en el prrafo anterior, debes tener en cuenta que en reposo, la lnea de transmisin del puerto serie debeestara1,porlotanto,alresetear,lasealfpga_txladebesponera1ynoa0como suele ser ms habitual. En otro caso, al resetear parecera que nuestro transmisor fuese a iniciarunatransmisin.
92
Unavezquehayasrealizadoeldiseo,compruebaquelasintaxisestbien(Check Syntax), incluso prueba a sintetizarlo (Synthesize - XST), pero antes de implementarlo en la FPGA convendrsimularlo.
7.5. Simulacin del transmisor

El transmisor que hemos realizado tiene cierta complejidad, y a diferencia de los circuitos que hemos realizado hasta ahora, no es fcil de comprobar si lo hemos diseado bien. En los anteriores circuitos disponamos de los leds para ver el comportamiento del circuito, ahoranotenemoslosleds,ynoesfcilcomprobarsilatransmisinsehacecorrectamente y cumple los especificados del protocolo RS232. As que es prcticamente imprescindible simular el circuito antes de implementarlo en la FPGA. En el captulo 5 vimos los pasos para simular un circuito, tambin se explica en el captulo 8 del manual de prcticas de ED2 [17mach]. Ahora vamos a seguir los mismos pasos, pero por las caractersticas de nuestrocircuitotendremosquerealizarunbancodepruebasdemayorcomplejidad. La realizacin de un buen banco de prueba es una tarea muy importante en el diseo, inclusoendiseoscomplejospuedellevarmstiempoladepuracinqueelpropiodiseo. Muchas veces el banco de pruebas y el diseo lo realizan personas diferentes para evitar que el diseador realice el banco de pruebas en base a lo que ha diseado o segn su interpretacin de las especificaciones del circuito. Un buen banco de pruebas debe comprobarqueeldiseohaceloquedebehacerynohaceloquenodebehacer. A veces la complejidad del banco de pruebas es muy grande y se crean modelos de componentes para la simulacin. La descripcin de estos modelos puede ser muy diferente a los modelos que se sintetizan, ya que para simulacin se acepta todo el conjunto del VHDL, mientras que para sntesis slo se acepta un conjunto restringido. Paraelbancodepruebasdeltransmisorrecurriremosaestetipodemodelos. Para empezar a realizar el banco de pruebas crearemos una nueva fuente de tipo VHDL TestBench y la llamamos tb_uart_tx.vhd. Este banco de pruebas estar asociado a la entidaduart_txqueyahemoscreado. Loprimeroquedebeshaceresponerlosmismospaquetesquepusisteeneltransmisorde laUART,incluyendolareferenciaalpaquetequecreamosenelcdigo7.1. Ya que cada placa tiene un reloj con distinta frecuencia, en vez de crear un banco de pruebas distinto para cada placa, como hicimos en los cdigos 5.1 y 5.2, crearemos un procesoderelojdependientedelaconstantedelafrecuenciaderelojc_freq_clk. As que vamos a crear una constante con el periodo del reloj, para que pueda ser un nmero entero lo pondremos en nanosegundos, multiplicndolo por 109. La declaracin de la constante se ha puesto en el cdigo 7.14 y tendrs que incluirla en el paquete del cdigo7.1.
constant c_period_ns_clk : natural := 10**9/c_freq_clk;
Cdigo 7.14: Constante con el periodo del reloj en nanosegundos
Con esta constante podemos crear el mismo proceso de reloj para las dos placas, ya que est hecho en funcin de la constante del periodo cs_period_ns_clk. Fjate en el cdigo 7.15 que como en la sentencia wait for hay que indicar un tiempo, hemos tenido que multiplicarlaporunnanosegundo.
93
P_Clk: Process begin clk <= '0'; wait for (c_period_ns_clk / 2) * 1 ns; clk <= '1'; wait for (c_period_ns_clk / 2) * 1 ns; end process;
Cdigo 7.15: Modificacin del proceso del reloj para que su frecuencia dependa de constantes
Ahoracreaelprocesodereset.Cralodemanerasimilaraloscdigos5.3y5.4perohazlo usando las constantes c_on y c_off (cdigo 6.9) de manera que no tengas que usar un procesodistintodependiendodelaplacaqueestsusando. Fjate en la declaracin de seales del banco de pruebas. Observa que las seales tienen asignado un valor inicial. Quiz recuerdes que en sntesis no tiene sentido dar un valor inicialalasseales,puesslosepuededarvalorinicialalassealesqueformanbiestable y stos se inicializan con el reset. El resto de seales que no forman biestable reciben el valor de otras seales, y su valor inicial ser dependiente de esas otras seales, por tanto noselepuedenasignarotrovalorinicial. Sin embargo, para simulacin (en los bancos de pruebas) s puedes dar valores iniciales a las seales, aunque no es necesario. Si en simulacin, una seal de tipo std_logic no ha recibidovalor,mostraruna'U' (deUnknown,desconocido).Ensntesis,notienesentido, yaquefsicamentelasealtendrunatensincorrespondienteconelcerooelunolgico, aunqueparanosotrossuvalorseadesconocidooindeterminado. En nuestro banco de pruebas cambiaremos el valor inicial de la seal de reset a su valor inactivo(c_off),envezdel0quetienepordefecto.Elresto desealeslaspodemosdejar igual. A continuacin, en el subapartado siguiente crearemos el proceso que simula el envo de un dato, posteriormente incluiremos el envo de ms datos, y por ltimo aadiremos un modelo de receptor para simulacin que nos dir de manera automtica si el envo es correctoysicumplelostiemposdadosporlanormaRS232.
7.5.1. Proceso que modela la orden de enviar un dato

Dentro del banco de pruebas crearemos un proceso llamado P_Estimulos que va a modelar la accin de ordenar al transmisor el envo de un dato determinado. En este procesovamosahacerlosiguiente: 1. Inicialmenteponemoslasealtransmiteytodoslosbitsdedato_tx_inacero. 2. Unavezquelasealderesetsehayaactivadoydesactivado,esperamos70ns.Estopuedes hacerlodedosmaneras:
Calculando el tiempo que transcurre hasta que el reset vuelva a estar inactivo. Del cdigo5.3sabesqueelresetestarinactivodespusde108+75nsapartirdelcomienzo. Aestohabraqueaadirlelos70nsdelaesperaqueahorasepide. La manera anterior nos hace depender de los tiempos del proceso del reset, pero es mejorhacerlodependerdeloseventos.Esdecir,primeroesperaraquehayauncambio enelvalordelreset(rst'event)yqueelresetsepongaactivo(rst=c_on).Posteriormente esperaraqueelresetsevuelvaaponerinactivo.Yporltimo,esperarlos70ns.
En la figura 7.13 se muestran las dos opciones de manera grfica. La primera opcin, basada en tiempos, se muestra arriba; mientras que la segunda opcin, basada en
94
eventos, se muestra debajo. Nosotros implementaremos la segunda opcin. Fjate que elcronogramadelresetserefierealaplacaXUPV2P,puesesactivoanivelbajo.
wait for 108 ns; wait for 75 ns; wait for 70 ns;
XUPV2P rst
ns
ns
wait until rst'event and rst=c_on;
wait until rst=c_off;
wait for 70 ns;
Figura 7.13: Captura de eventos del reset basados en tiempos o en eventos. Referenciado a la XUPV2P
3. Esperamosaquehayaunflancodesubidadelasealdereloj.Estosehaceconlasentencia delcdigo7.16:
wait until clk'event and clk='1'
Cdigo7.16: Esperar a que haya un flanco de subida del reloj
4. Enviamos el dato 01010101. Para ello tendremos que poner la seal transmite a uno, dando as la orden de transmitir, simultneamente asignamos a dato_tx_in el valor que queremostransmitir. 5. Esperamosalsiguienteflancodesubidadereloj. 6. Quitamoslaordendetransmitiryponemoseldatoatransmitirtodoacero. 7. Esperamosindefinidamente.Recuerdaquesehaceconlasentenciawait; (cdigo5.3). Ahora, implementa este proceso para simular el circuito (en Modelsim o en el simulador delISE).Antesdesimularconvieneestimarcuntotiempodesimulacinrequerimospara comprobar que nuestro envo se realiza correctamente. Esto adems es necesario para comprobarquelasimulacinescorrecta. Estamos enviando a una frecuencia de 115200 baudios (o lo que hayas puesto en la constante c_baud del paquete UART_PKG). Esto significa que cada bit se debera de enviar durante algo menos de 8681 ns (27). Como enviamos el bit de inicio, los 8 bits del dato y el bitdefin,eltiempodetransmisinser10vecesmayor:86810ns,yaestoletenemosque sumar el tiempo del reset (figura 7.13) que es algo menos de 300 ns. Por tanto, nuestra simulacindurarunos87110ns,asquepodemosindicaralsimuladorquesimule88s. En el apartado siguiente vamos a analizar la simulacin, se va a explicar con el ISE Simulator, ya que tiene algunas particularidades, pero se puede hacer de manera similar con el Modelsim. En esta explicacin se supone que ya sabes los conceptos bsicos de la simulacinyelmanejodelossimuladores.Estoseexplicenelcaptulo5ysobretodoen elcaptulo8delmanualdeED2[17mach].Paracualquierdudaconsultaestoscaptulosya queesprobablequeestnexplicadas. El apartado siguiente es muy importante porque de nada nos vale hacer el banco de pruebas si no sabemos interpretar los resultados de la simulacin. Las formas de onda de lasimulacinpuedenresultarininteligiblessinoseanalizanconciertodetalleypaciencia.
27
Calculamoslainversadelosbaudiosylamultiplicamospor109parapasarlodesegundosananosegundos. EnrealidadnuestraUARTnopodrsertanexacta,sinoqueeltiempotendrqueserunacantidadmltiplo denuestroperiododereloj(apartado7.4.1)
95
Para el anlisis es imprescindible tener claro cmo deben de comportarse las seales. Comparando los resultados de la simulacin con los que nosotros esperamos podremos descubrirsihayalgnerrorennuestrodiseo.
7.5.2. Comprobacin de la simulacin

Las instrucciones bsicas para arrancar la simulacin con el ISE Simulator estn en el captulo 8 del manual de ED2 [17mach] por lo que no se repetirn aqu. Para simular con Modelsimconsultaelcaptulo5. Como el ISE Simulator tiene algunas particularidades, se explicar la simulacin con esta herramienta.Anas,deberaspodersimularconModelsimsinproblemas. Una vez que pinchas en Simulate Behavioral Model (estando seleccionado el mdulo del banco de pruebas) aparece la ventana de las formas de onda. Por defecto se simula durante 1000 ns y estn incluidas las seales del banco de pruebas, pero no las seales internas del transmisor de la UART. En la figura 7.14 se muestra la ventana de simulacin28.
Seleccin del tiempo de simulacin Simulacin: 1000 ns
Seales del banco de pruebas
Transmisor UART
Figura 7.14: Simulacin por defecto en el ISE
Si queremos observar todas las seales internas, como son estado_tx, baud, cargadato, fin_cont8bits,... (recuerda la figura 7.12), para ello debes de expandir el men donde se encuentra el transmisor de la UART (figura 7.14), y una vez expandido, seleccionar aquellas seales que queramos que aparezcan. Seleccionaremos todas menos las que ya estnenelbancodepruebas(rst,clk,transmite,...),pinchamosconelbotnderechodel
28
Sihassimuladoconanterioridadenelmismoproyecto,suelesimulareltiempodelaltimasimulacine incluyelassealesqueseusaronenesasimulacin
96
ratn y seleccionamos Add to waveform. Con esto ya tendremos las seales en el visor de formasdeondas.
Figura 7.15: Aadir seales en el ISE Simulator
Sin embargo, podemos observar que para las seales que hemos aadido no se muestran sus formas de onda. As que tendremos que reiniciar la simulacin. Para ello, pincha en SimulationRestart (o busca el icono). Y ahora pon 88 s en la seleccin del tiempo de simulacin(miralafigura7.14paraverdndeest).PorltimopinchaenSimulationRun For Specified Time.Conestosemostrarnlasformasdeondadelassealeshastalos88s. Para ver la simulacin completa pincha en SimulationZoomTo Full View 29. Ahora es el momentodecomprobarsinuestrocircuitofuncionacomodebe.Lafigura7.16muestralas formasdeondaqueaproximadamentedeberanaparecer.
Figura 7.16: Simulacin del transmisor con seales internas durante 88 s
29
EnModelsim,extraelaventanadelasformasdeonda(figura5.9)ypichaenViewZoomZoom Full
97
Ahorapasaremosacomprobarqueelcircuitofuncionabien. Lo primero que tienes que mirar es la seal fpga_tx. Esta seal debe de haber enviado el dato01010101 conforme al protocolo RS232. Como ya sabemos las especificaciones del protocolo, el aspecto de la seal debe ser como el mostrado en la figura 7.17. Acurdate queelprimerbitdeldatoqueseenvaeselbit0,porlotanto,tienequeserun1.
'0' '1' '0' '1' '0' '1' '0' '1' '0' '1'
bit de inicio
bit 0
bit 1
bit 2
bit 3
bit 4
bit 5
bit 6
bit 7
bit de fin
bits del dato
Figura 7.17: Forma de onda de la seal fpga_tx despus de simular 88 s
Si el resultado de tu simulacin no fuese como el mostrado en la figura 7.17 tendremos que buscar qu ha fallado. De todos modos, no es preocupante, rara vez los diseos funcionanalaprimera. Hay muchas cosas que pueden haber fallado, as que vamos poco a poco y empezaremos porelprincipio.Acontinuacinsemuestranunaseriedepasosquedebescomprobar: 1. Compruebaqueelbancodepruebashaceloquequeramosquehiciese Nuestro banco de pruebas era muy sencillo, as que esta comprobacin va a ser fcil. Lo primero es aumentar el zoom de las formas de ondas. Para ello pincha en SimulationZoomIn (o busca el icono30), tendrs que pinchar unas 7 veces o hasta que empiecesaverlastransicionesdelreloj. A continuacin llevamos la simulacin al inicio arrastrando la barra inferior a la izquierda. La seal dato_tx_in la ponemos en formato binario (pinchando encima de ellaconelbotnderecho). Tenemosquecomprobarquelasealderesetsecomportacomomuestralafigura7.13 (o invertida si trabajamos con la Nexys2). Y que aproximadamente a los 260 ns se activa la seal transmite, esta activacin debe durar un ciclo de reloj. Simultneamente la seal dato_tx_in debe de cambiar a 01010101. Posteriormente ambassealesseponenacero. Si esto est bien nos hace pensar que el banco de pruebas es correcto y que el fallo debedeestareneltransmisor.Acontinuacinpasamosacomprobarlo. 2. Compruebaquehaycambiodeestadoconlaordendetransmitir Arazdequeseactivalaordendetransmitirdebesuceder:

Elestado(estado_tx)pasadee_initae_bit_init Lasealcarga_datoseactivaenelmismociclodereloj Elpuertodesalidatransmitiendoseponeauno Lahabilitacindelcontador(en_divfreq)seponeauno El biestable donde se guarda el dato a transmitir (dato_tx_rg) se carga con el valor que queremosenviar(estosucedeenelcicloderelojsiguiente). La salida del transmisor (fpga_tx) se pone a cero (quiz tarde uno o dos ciclos de reloj) indicandoqueseempiezaaenviarelbitdeinicio.
30
EnModelsim:ViewZoomZoom In
98
Elcontadordelosbitsqueseenvan(cont8bits)debemantenerseacero Lassealesbaud,desplaza,fin_cont8bits debenseguiracero Y por ltimo, el contador del divisor de frecuencia (cont_baud) debe estar en cero y a partir del cambio de estado debe de empezar a contar cada ciclo de reloj. Haz que este contadorserepresentecomoenterosinsigno(unsigned)paraqueseamsfcildeverla cuenta.
En caso de que algo no funcione, identifica en el cdigo VHDL dnde est el fallo y corrgelo. Cuando lo tengas bien, pasa al siguiente punto. Como puedes ver, se trata deircomprobandoquelasespecificacionessecumplen. 3. Compruebaqueseenvaelbitcerodeldato Si todo lo del punto anterior era correcto, ahora tienes que comprobar que transcurridos alrededor de 8681 ns, el transmisor cambia de estado y pasa a enviar el bit cero del dato. Como se empez el envo sobre los 260 ns, tendrs que ir al tiempo 8950 ns, para ello pincha en SimulationGoto Time e introduce el tiempo deseado. Deberaapareceralgosimilaralomostradoenlafigura7.18.
Figura 7.18: Formas de onda para la transicin a los bits de datos
Como puedes ver, la seal baud se pone a uno, el estado cambia a e_bits_dato y el puertofpga_txempiezaaenviarelbit0deldato,queesununo. Si no ocurre nada de esto, comprueba la seal cont_baud. Esta seal debe de incrementarsucuentaencadaciclodereloj.Comoyavimosenelapartado7.4.1,elfin de cuenta depende de la frecuencia de reloj y de los baudios. Para la XUPV2P y a 115200 baudios, el fin de cuenta ser 867. Para la Nexys2, como la frecuencia es la mitad, la cuenta tambin ser de la mitad: 433. Esto lo calculaste en la constante c_fin_cont_baud(cdigo7.2). Entoncescompruebaque:
Lasealcont_baudrealizalacuentacorrectamenteyseponeacerodespusdesufinde cuenta Despusdelfindecuentadecont_baudsedebeactivarlasealbaud.
99
Compruebaquehaycambiodeestadodesdee_bit_initae_bits_dato.
Engeneralcompruebaquesecumplenlastransicionesdelatabla7.4. 4. Compruebaqueseenvanelrestodelosbitsdeldato De manera similar al punto anterior, tienes que comprobar que se van enviando el restodebitscorrectamente.Tendrsquecomprobarque:
Lasealcont_baudrealizalacuentacorrectamenteyseponeacerodespusdesufinde cuenta Lasealdesplazaseactivaconlasealbaud. Elregistrodedesplazamientodato_tx_rgdesplazasusbitsaladerecha. Lacuentadelosbitsenviadoscont8bitsvacreciendoconcadanuevoenvodebits
5. Compruebalatransicindelltimobitdedatosalbitdefin Esta transicin suele dar problemas porque la sincronizacin de la cuenta con el cambio de estado hay que hacerla con cierto cuidado. En la figura 7.19 se muestra cmo puede ser la transicin. Cuando se activa la seal baud y la cuenta cont8bits va por 7 ocurre la transicin al nuevo estado porque la seal fin_cont8bits se activa. Fjate que en la figura 7.19 la seal baud y fin_cont8bits se activan simultneamente. Notieneporquseras,perodependedecmoesthechoelrestodelcircuito,podra daralgnproblema.
Figura 7.19: Formas de onda para la transicin al bit de fin
A raz de la activacin de la seal fin_cont8bits el estado debera pasar a e_bit_fin. Conloqueelpuertofpga_txsedebedeponerauno(porserelbitdefin). 6. Compruebalatransicindelbitdefinalestadodereposo: Si todo lo anterior te funciona porque has tenido que corregirlo, esta ltima parte debera serte fcil. Tendrs que comprobar que se activa la seal baud despus del fin de cuenta. Y la activacin de esta seal nos debera de llevar al estado de reposo e_init. Debido a esto, la salida fpga_tx debe de seguir a uno (reposo) y comprueba quelassealesestncomolasdelatabla7.4.
100 Universidad Rey Juan Carlos
7. Compruebalostiempos: Si has llegado hasta aqu, significa que las formas de onda tienen un aspecto similar a las de la figura 7.16 y sobre todo, el dato que se transmite por el cable RS232 es igual al de la figura 7.17. Sin embargo, puede ser los tiempos no sean exactos, aunque seguramente s lo sean, pues has hecho comprobaciones que en cierta medida compruebantiempos. Ahora, para comprobar los tiempos, vuelve a mostrar la simulacin completa (ViewZoomTo Full View31). Pon el cursor en 40s, que ms o menos debe estar en el envo del tercer bit. Para poner el cursor en un tiempo, o bien lo arrastras con el ratn obienpinchasenSimulationGoto Time... eintroduceseltiempo32. Ahora queremos llevar el cursor al momento que ocurre la transicin de la seal fpga_tx desde el bit 2 hasta el bit 3. Para ello, selecciona la seal fpga_tx y pincha en SimulationGoto Previous Transition, y el cursor ir al tiempo (35 s). En Modelsim tienes que buscar el icono similarenelISESimulator). para ir al transicin previa (tambin existe un icono
As que podemos llevar los cursores de transicin en transicin y ver en qu tiempos ocurren. Se pueden insertar varios cursores, en el ISE: SimulationMarkersSingle Marker. En Modelsim se insertan: InsertCursor. El Modelsim indica en la parte inferior la diferenciadetiemposentredoscursores.Asquesillevaslosdoscursoresjustoenlas transiciones de dos bits consecutivos, puedes ver si la diferencia de tiempo se corresponde con la especificada. En nuestro caso muestra 8680 ns (muy cercano a los 8681nsquehabamoscalculado). Para calcular diferencias de tiempos en el simulador del ISE pinchamos en SimulationMarkersMeasure Marker y pinchamos en donde queramos situarlo. Aparecern dos cursores, con una diferencia de tiempos encima de ellos. Seleccionamos uno de ellos y lo llevamos a la transicin del bit 2 al 3 (no te olvides de seleccionarprimerolasealyluegopincharenSimulationGoto Next Transition).Hazlo mismo con el otro extremo del cursor, llevndolo a la transicin del bit 3 al 4. El ISE Simulator nos indica que la diferencia de tiempos es de 8,7 s. Si hacemos zoom de modo que salga el tiempo en nanosegundos, tendremos la medida exacta. Si haciendo zoom perdemos el cursor, pinchamos en MarkersGoto Previous Marker hasta encontrarlo. Por ltimo, comprueba que desde el bit de inicio hasta el bit de fin transcurren 86800ns.Tambinpuedescomprobarlomidiendoeltiempoenquetransmitiendoest auno. Sitodaslascomprobacionesquehemoshechosoncorrectas,esprobablequeeldiseo lo tengas bien. Sin embargo, an no lo hemos comprobado de manera suficiente. Por tanto en los siguientes apartados realizaremos unos bancos de pruebas ms exhaustivos. Es importante que aprendas a detectar por ti mismo los errores, para que puedasserindependienteenlasprcticassiguientes.
EnModelsimViewZoomZoom Full EnModelsimViewGoto Time...cuandointroduces40s,lointroducesennanosegundos(40000)
31 32
101
7.5.3. Proceso que modela las rdenes de enviar varios datos

En el banco de pruebas anterior comprobamos el envo de una trama, sin embargo, muchas veces los errores se producen al enviar una segunda trama, ya que, por ejemplo, puedepasarquenosehayaninicializadobienelcontadordelosbitsdeenvo. Por otro lado, en los bancos de pruebas tambin hay que considerar el funcionamiento errneo. Por ejemplo, qu pasara si antes de haber terminado el envo, se ordena un envonuevo.Enprincipiohemosespecificadoquecuandose estenviando,eltransmisor no va a atender ninguna peticin deenvo. Por lo tanto, tenemos que comprobar este tipo decosas. As que vamos a crear un nuevo banco de pruebas que enve cuatro datos y adems realicerdenesdeenvoantesdequeeltransmisorhayaterminadodeenviardato. Para conservar el banco de pruebas anterior, realiza una copia del fichero del banco de pruebasyllmalatb_uart_tx_2.vhd.Edtalaycambiadenombrealaentidad,llamndola tb_uart_tx_2, cambia tambin el nombre de la entidad que aparece en la arquitectura. Deberaquedarcomoindicaelcdigo7.17
... Entity tb_uart_tx_2 is End tb_uart_tx_2; Architecture tb ot tb_uart_tx_2 IS COMPONENT uart_tx ...
Cdigo 7.17: Nombre de la nueva entidad para el banco de pruebas
Ahora desde el ISE, selecciona Behavioral Simulation (figura 5.2). Pincha en Add Existing Source y aade el nuevo fichero que acabamos de crear. De este fichero mantenemos todo casiigualmenoselprocesodelosestmulos(P_estimulos). Vamos a crear una constante en la que guardaremos los cuatro datos que queremos enviar.Estaconstantelacrearemosenlamismaarquitecturadelbancodepruebas.Como la constante es un vector de vectores de 8 bits, tenemos que crear un tipo de datos que ser un vector de std_logic_vector de 8 bits. En el cdigo 7.18 se muestra la declaracin quetienesqueincluir.
type vector_slv is array (natural range <>) of std_logic_vector(7 downto 0); constant datos_test : vector_slv := ("10001101","01010101","11001010","00101101");
Cdigo 7.18: Declaracin de un tipo de datos que es un vector de std_logic_vector (slv) y la constante con los datos a probar
En la declaracin del tipo, el rango <> indica que est abierto y se especificar en la declaracin de la seal o constante. En la declaracin de la constante, el rango viene especificadoporelnmerodedatosincluidosenlainicializacin(4).Enestecaso,porser un rango de tipo natural es ascendente, empezando en el ndice cero (10001101) y terminandoen3(00101101). Hasta el primer envo lo haremos igual que como lo tenamos en el proceso P_estimulos (apartado 7.5.1), pero en vez de asignar a dato_tx_in directamente un valor constante, le asignaremos el contenido del ndice cero de la constante datos_test. Para ello, la asignacinladebeshacercomosemuestraenelcdigo7.19.
dato_tx_in <= datos_test(0); -- asignamos el dato del indice cero
Cdigo 7.19: Asignacin del valor del ndice cero de la constante
102
Ahoravamosaquitarlaltimasentenciadelproceso(wait;)yvamosahacerlosiguiente: 1. Esperamos hasta que termine la transmisin del envo anterior. Esto lo podemos detectar cuando veamos que la seal transmitiendo se pone a cero (si no te acuerdas, en la figura 7.13seexplicabacmohaceresto). 2. Una vez que hayamos detectado que se ha terminado la transmisin, vamos a empezar el segundo envo, y te recomendamos que pongas un comentario que indique el comienzo del segundo envo. Como ya sabes, los comentarios son muy importantes, no slo para ti, sinoparaaquellosquetrabajancontigooterevisaneltrabajoyintentanaveriguarqueslo quehasqueridohacer. 3. Ahoracomienzasarealizarelsegundoenvo,yasabescmosehace:

Ponemostransmiteauno Asignamos a dato_tx_in el dato que hay en el ndice 1 de la constante datos_test (recuerdaqueempiezaencero,poresoeselndice1ynoel2) Esperamosalsiguienteflancodesubidadereloj(recuerdaelcdigo7.16)
4. Despusdeordenarelsegundoenvo,podramosponerlasealtransmiteacero.Perono lovamosahacerparaprobarquocurresilasealtransmiteduramsdeunciclodereloj. Esto sera normal si, por ejemplo, la seal transmite estuviese asociada a un pulsador. Entoncesloqueharemosser:
Ponemos (dejamos) transmite a uno. En realidad no hara falta, porque guardara su valor,perolodejamosparadarnoscuentadeloqueestamoshaciendo. Ponemos todos los bits dato_tx_in a cero. Esto lo hacemos para detectar si hay fallo, al cambiareldato,sienelsegundoenvotodoslosbitssoncero,implicaquenohacargado bieneldato. Esperamos200ns. Ahoras,ponemostransmiteacero. Dejamostodoslosbitsdedato_tx_inacero. Y esperamos a que termine la transmisin, es decir detectamos cuando transmitiendo seaigualacero.
5. Todava no hemos empezado el tercer envo y vamos a cambiar algo las entradas esperandoquenoocurranada.Enlasimulacinhabraquecomprobarquenoocurrenada porestecambio

Mantenemostransmiteacero Asignamosadato_tx_ineldatodelanteriorenvoconlosbitsnegados:
dato_tx_in <= not datos_test(1);
Cdigo 7.20: Negamos los bits del segundo envo
Y ahora esperamos un ciclo de reloj, ya que para que las seales actualicen su valor tenemosqueponerunwait. Ponemosuncomentarioqueloindique Ponemostransmiteauno Asignamosadato_tx_ineldatoquehayenelndice2delaconstantedatos_test Esperamosunciclodereloj(esperamosalsiguienteflancodesubida)
6. Empezamoseltercerenvo:

103
7. Despusdeordenareltercerenvo,ponemosotrodatoendato_tx_inparacomprobarque noloenva:

Ponemostransmiteacero Asignamos a dato_tx_in el dato negado que hay en el ndice 2 de la constante datos_test Esperamos300ns Ponemostransmiteauno(estonodeberacambiarnada) Esperamos100ns Ponemostransmiteacero Ponemostododato_tx_inacero Esperamos200ns Yesperamosaqueterminelatransmisin(detectamoscuandotransmite='0').
8. Esperamos la mitad del tiempo en que se enva un bit. Es decir, estamos probando qu pasa si mantenemos la UART inactiva. Este tiempo lo vamos a poner en una constante en elpaqueteUART_PKG,igualquelohicimosconc_period_ns_clk(cdigo7.14).
constant c_period_ns_baud : natural := 10**9/c_baud;
Cdigo 7.21: Tiempo que transcurre en enviar un bit
As pues esperamos la mitad del tiempo de un bit, similar a lo que hicimos con la sentenciadelreloj(cdigo7.15)peroconlaconstantec_period_ns_baud.
9. Realizamoselcuartoenvo(elltimo).Comolaltimaesperahasidodetiempos,ynode evento, esperamos un ciclo de reloj para asegurarnos que los valores que ponemos van a durar un ciclo de reloj completo. Para entenderlo, fjate en la figura 7.20: hemos esperado 48ns, que coincide con 2 ns antes del flanco de subida del reloj. Si en ese momento ponemoslasealsauno,yesperamosunciclodereloj,lasealssloestaractivadurante 2 ns, en vez de estar activa durante un ciclo completo de reloj. Especialmente grave es el caso de que esperemos por tiempo y coincida justa en el flanco del reloj: estamos antes o despusdelasubida?
Partimos de aqu s <= wait s <= wait s <= '0'; for 48 ns; '1'; until clk'event and clk='1'; '0';
clk
wait for 48 ns; wait until clk'event and clk='1'
S
La seal S se activa mucho menos de un ciclo de reloj
Figura 7.20: Esperar por tiempos y luego por eventos puede producir seales de ancho muy inferior al ciclo de reloj
Para evitar este tipo de situaciones, cuando queramos activar una seal durante un ciclo de ciclos de reloj, ser conveniente hacer una espera por eventos de una seal sincronizada con el reloj (no tiene que ser el reloj, puede ser la seal transmitiendo como hemos hecho anteriormente). La figura 7.21 explica de manera grfica la solucin.
104
Partimos de aqu s <= wait wait s <= wait s <= '0'; for 48 ns; until clk'event and clk='1'; '1'; until clk'event and clk='1'; '0';
clk
wait for 48 ns;
S
La seal S se activa durante un ciclo de reloj completo
Figura 7.21: Solucin a la espera por tiempos seguida de espera por eventos (figura 7.20)
Asquepararealizarelcuartoenvoharemos:

Insertamosuncomentarioindicandoqueempezamoselcuartoenvo. Esperamosalsiguienteflancodesubidadelrelojparasincronizar(figura7.21). Ponemostransmiteauno Asignamosadato_tx_ineldatoquehayenelndice3delaconstantedatos_test Esperamosalsiguienteflancodesubidadelreloj
10. Terminamos la transmisin. Antes de esto, declararemos una seal llamada fin_envio de tipostd_logic,ylainicializaremosacero.Estasealnosservirparasabercuandohemos terminadodeordenarelltimoenvo.Msadelanteencontraremossuutilidad

Insertamosuncomentario Ponemostransmiteacero Ponemostododato_tx_inacero Ponemoslasealfin_envioauno. Esperamosindefinidamente:wait;
Con esto ya tendramos todo el banco de pruebas. Ahora queda simularlo siguiendo los pasosdelapartado7.5.2.Comosoncuatroenvosyvimosqueunenvoseranunos88s, simularemos352s,ounpocoms. Una vez tengas las formas de onda, tendrs que observar si se aprecian los cuatro envos, si la mquina de estados cambia a los estados adecuados, los contadores cuentan correctamente...33 En fin tendrs que realizar los pasos del apartado anterior pero considerando los cuatro envos. Y antes de nada, observar si los estmulos del banco de pruebas cumplen las especificaciones. Es una tarea de bastante paciencia, pero no es tan complicada.
7.5.4. Autocomprobacin en el banco de pruebas

Hemos visto que comprobar un banco de pruebas no es que sea excesivamente complicado (aunque lo pueda llegar a ser) sino que sobre todo es tedioso. Hay que ir transicinatransicincomprobandoquetodoestcomosuponemosquedebeestaryala vez, comprobando que se cumplen los tiempos especificados. Esto adems se agrava por
33
TenencuentaqueenelsimuladordelISE,cuandoestsviendotodalasimulacin(nohasampliadoconel zoom)avecesnosemuestrantransicionesdesealesqueduranpocotiempo(unciclodereloj).Enel Modelsimsisemuestranestastransicionesconunalnea.
105
el hecho de que cada vez que hagamos un cambio en nuestro diseo tendramos que volver a realizar toda la comprobacin. Por esto es muy interesante la idea de crear un bancodepruebasquelmismoseautocompruebe,avisndonosdecundohayaunerror yporconsiguienteevitndonostenerquerevisarcadadetalledelbancodepruebas. Evidentemente,hacerunbancoqueseautocompruebeesmscomplicadoyrequierems tiempo.Peroeltiempoinvertidoenhacerloseverecompensadoporunadeteccinmucho msrpidadeloserrores. Para crear un banco de pruebas que se autocompruebe lo que tenemos que hacer es codificar en el banco de pruebas las comprobaciones que haras a partir de las formas de ondadelasimulacin(similaraloquehicimosenelapartado7.5.2.). En nuestro caso, para comprobar que el envo del transmisor de la UART es correcto, podramos poner un modelo de un receptor de la UART de modo que verifiquemos que lo que ha recibido el modelo del receptor se corresponde con lo que ha enviado el transmisor. Como estamos haciendo un banco de pruebas, el modelo del receptor no tiene que ser sintetizable y puede estar basado en tiempos y eventos, segn las especificaciones del envo RS232 (figura 7.3). De hecho, ni siquiera tiene que estar referenciado a la seal de reloj.Porlotantoesunmodelobastantemssencillodehacer. Conestoestamosviendoqueunmismocircuitosepuededescribirendistintosnivelesde abstraccin. Por ejemplo, el transmisor que hemos hecho est descrito en lo que se llama niveldetransferenciaderegistros(RTL34).Enestenivel,elfuncionamientodelcircuitose describe en trminos del flujo de las seales (o transferencia) entre los biestables (o registros). En RTL, las transiciones estn definidas por la frecuencia del reloj. Hay niveles deabstraccinmsbajosqueelRTLcomopodraserladescripcindelcircuitoenelnivel depuertaslgicas,einclusomsbajo,comoloseraelniveldetransistores(describiendo cada puerta en su transistor correspondiente). Sintetizar es el proceso de pasar de un nivel de abstraccin ms alto a otro inferior, y esto es lo que hace el ISE de manera automticacuandoqueremospasarnuestrodiseoalaFPGA. Tambin hay niveles ms altos que el RTL, como el nivel de algoritmo, en el que se describe el funcionamiento como si se programase en un lenguaje de programacin. Este seraelnivelenelquevamosadescribirelreceptordelaUARTparaelbancodepruebas. VeremosqueenestenivelladescripcinesmuchomssencillaqueenRTL. Ahora vamos a empezar a realizar el modelo del receptor que incluiremos en el banco de pruebas. Para ello, de manera similar al apartado 7.5.3, hacemos una copia del banco de pruebas anterior, y al nuevo le llamamos tb_uart_tx_3.vhd. Editamos el fichero y cambiamos de nombre a la entidad, llamndola tb_uart_tx_3 (recuerda cdigo 7.17). Por ltimo,aadimoselficheroalproyectodelISE. A continuacin, en el banco de pruebas incluimos un nuevo proceso que va a ser nuestro modelo del receptor de alto nivel. Al proceso lo llamaremos P_Receptor. El esquema de nuestro nuevo banco de pruebas se muestra en la figura 7.22. En este esquema, los bloques con lnea discontinua representan los procesos del banco de pruebas. Puedes observar queelmodelodelreceptornogeneraestmuloscomoelrestodeprocesos(reset,
34
RTL:delinglsRegisterTransferLevel
106
reloj y entradas), sino que su funcin es leer la seal enviada por el transmisor para comprobarqueescorrecta.
Proceso que modela las entradas al circuito
P_Estmulos
8
UUT:UART_TX dato_tx_in transmite transmitiendo clk rst
P_Receptor
fpga_tx
P_Clk
Proceso que modela el reloj
Proceso que modela el reset
P_Reset
Componente que se quiere comprobar: Transmisor descrito en nivel RTL
Proceso que modela el receptor y verifica que la seal se recibe correctamente
Figura 7.22: Esquema del banco de pruebas del transmisor que incluye un proceso que modela el receptor descrito a alto nivel y verifica que el envo es correcto
Yaquevamosamodelarelreceptor,tenemosquetenermuypresentecmoeslatramade envo(recuerdalafigura7.3). Lospasosparacomprobarelenvoson: 1. Esperamos hasta que el transmisor enve el bit de inicio. Recuerda que el bit de inicio se indicaponiendolalneadetransmisin(fpga_tx)acero.Yasabescmosehaceesto:
wait until fpga_tx'event and fpga_tx='0';
Cdigo 7.22: Espera al flanco de bajada de la seal fpga_tx
2. Nos situamos en el tiempo medio del bit de inicio: Una vez que hemos detectado el comienzo de la transicin, esperamos la mitad del periodo de envo de cada bit (c_period_ns_baud/2) para situarnos justo en medio. Esto es importante, porque si leemos el bit justo en la transicin a otro bit, puede pasar que estemos leyendo el bit contiguo. La figura7.23muestrademaneraesquemticadndenossitaestaespera.
c_period_ns_baud c_period_ns_baud c_period_ns_baud
reposo
bit de inicio
bit 0 del dato
bit 1 del dato
bit 2 del dato ...
wait until fpga_tx fpga_tx'event 'event and fpga_tx = '0';
Lectura Lec tura
fpga_tx
esperamos la mitad del periodo para situarnos en medio del bit c_period_ns_baud 2
para leer nos situamos en el medio del bit wait for c_period_ns_baud/2 * 1 ns
Figura 7.23: Espera para situarnos en medio del bit de inicio
3. Leemos el valor del bit de inicio: Estando en medio del bit de inicio, procedemos a leer su valor.Aunqueparaelbitdeinicionoesnecesarioleersuvalor,porqueyalosabemos('0'), la lectura la hacemos para comprobar si efectivamente el bit de inicio es cero. En caso de que no sea cero, en VHDL existe la sentencia assert que nos permite avisar de errores e
107
inclusodetenerlasimulacin.Lasentenciadelecturayverificacindeunvalorsemuestra enelcdigo7.23.
assert fpga_tx = '0' -- Si no se cumple da el aviso report "Fallo en el bit de inicio" severity ERROR; -- niveles de severidad: NOTE,WARNING,ERROR,FAILURE
Cdigo 7.23: Ejemplo de una sentencia assert
Delcdigo7.23podemosobservarquelasentenciaasserttienetrespartes:

Lacondicinquesequiereverificar(fpga_tx = '0') Sinoseverificalacondicinanterior,semuestraelsiguienteaviso.Queenelejemploes: falloenelbitdeinicio. Por ltimo, la gravedad del error. Hay cuatro niveles de error, que de menor a mayor son: NOTE, WARNING, ERROR, FAILURE. Dependiendo del nivel de error, se puede ordenar detenerlasimulacinosimplementeavisar35.
Importante: date cuenta que estas tres partes forman el assert, y que es una nica sentencia. Por tanto hay un nico punto y coma al final (en medio no hay puntos y comas aunque se pueda separar en varias lneas). Si pusieses un punto y coma despusdelassertimplicaraquesondossentencias,unadeellasunassertsinaviso (sin report), y la otra slo tendra report, por lo que siempre avisara, y pensaras que teestavisandodeunerror. Otra cosa que puedes observar es que estamos leyendo solamente en el punto medio, como muestra la figura 7.23. Siendo estrictos deberamos de comprobar que la transmisinsemantieneacerodurantetodoeltiempocorrespondientealbitdeinicio, y no solo en el punto medio. Sin embargo, para simplificar el banco de pruebas, asumiremosqueessuficienteconcomprobarelpuntomedio. 4. Esperamos hasta el punto medio del bit cero del dato. Es decir, esperamos el tiempo correspondiente a un bit (c_period_ns_baud). En la figura 7.24 se muestra la espera que estamoshaciendo.
c_period_ns_baud c_period_ns_baud c_period_ns_baud
reposo
bit de inicio
bit 0 del dato
bit 1 del dato
bit 2 del dato ...
wait until fpga_tx'event and fpga_tx = '0';
Lectura
Lectura
fpga_tx
esperamos la mitad del periodo para situarnos en medio del bit c_period_ns_baud 2 wait for c_period_ns_baud/2 * 1 ns c_period_ns_baud
para leer nos situamos en el medio del bit wait for c_period_ns_baud * 1 ns;
Figura 7.24: Espera para situarnos en medio del bit 0 del dato
35
EnelModelsim,elniveldondesedetienelasimulacinseindicaenSimulateRuntime Options...Enla ventanaqueaparece,hayqueseleccionarlapestaaAssertionsyenelapartadoBreakonAssertionsse seleccionaelniveldeseado
108
5. Leemoselvalordelbitcerodeldato.Tenemosquecompararelvalorledoconelvalorque envi el transmisor. Los datos enviados por el transmisor los tenemos en la constante datos_test(recuerdaelcdigo7.18).Ahoraestamosenelprimerenvo(0)yenelbitcero. Por lo tanto la comparacin ser con datos_test(0)(0). Y el aviso (report) tendra que hacer referencia al bit cero del primer envo. La sentencia de lectura y verificacin de un valorsemuestraenelcdigo7.24.
assert fpga_tx = datos_test(0)(0) -- Si no se cumple da el aviso report "Fallo en el bit cero del dato del primer envio" severity ERROR; -- niveles de severidad: NOTE,WARNING,ERROR,FAILURE
Cdigo 7.24: Sentencia assert para el bit 0 del primer envo
6. Ahoratendramosquerepetirlaesperayrepetirlalecturaconelassertparalosrestantes7 bits del dato. Para evitar copiar y pegar siete veces, podemos hacer un bucle for como el del cdigo 7.25. Si incluyes el bucle tal como est en el cdigo 7.25, tendras que borrar lo quehicisteparaelbitcero(puntos4y5),puesestincluidoenestebucle.
for i in 0 to 7 loop wait for c_period_ns_baud * 1 ns; -- punto medio bit i del dato assert fpga_tx = datos_test(0)(i) -- leo y comparo el valor del dato report "Fallo en el bit del dato del primer envio (0)" severity ERROR; end loop;
Cdigo 7.25: Bucle for para comprobar todos los bits del dato
EnVHDLelndice(i)delosbuclesfornohayquedeclararlocomosealovariable. Observa que con el bucle hemos perdido parte de la informacin del report pues ahoranoindicaenqubitsehacometidoelfallo.Comoenelreportslopuedehaber texto(string),nopodemosincluirelndicedirectamente36. 7. Una vez que hemos ledo el ltimo bit del dato (bit 7), tenemos que hacer una espera ms paraelbitdefin. 8. Seguidamenteleemoselbitdefin,comprobamossisuvalores1ynotificandosihayerror. 9. Opcionalmentepodemosesperarmedioperiodoparaterminarelbitdefin,perorealmente noesnecesario,pueselbitdefintieneelmismovalorquelalneaenreposo. 10. Paraterminarelprocesoyquenovuelvaaejecutarsemsdesdeelprincipio,terminacon unasentenciawait;. Ahora simula el circuito durante unos 355s, como hiciste en el apartado 7.5.3 y observa si hay algn aviso de los assert. Estos avisos se muestran en la ventana inferior (mira la figura 7.25). En Modelsim, pinchando en el aviso el cursor se coloca en el instante en que se ha producido. El ISE no tienen esta caracterstica, as que tendrs que mirar el instante detiempoenelqueseprodujoyiraesetiempo(SimulationGoto Time...).Puedeserqueel avisosehayaproducidoporunfalloenelbancodepruebasqueacabasdehacerynopor el propio transmisor que estas probando. Si no encuentras el fallo, revisa que no tengas ningnpuntoycomaenmediodelasentencia,especialmenteentreelassertyelreport.
36
Estosepuedesolucionarcreandounafuncin(a_texto)querecibaunnatural(elndicei)ydevuelvael stringcorrespondientealnmerodelndice.Enelreportpodemosconcatenar(&),porejemplo: report "Fallo en el bit " & a_texto(i) & " del primer envio" Sedejacomoejercicioopcionalincluirestafuncin
109
Aviso de los Assert
Figura 7.25: Avisos de los assert en Modelsim
Quiz te hayas dado cuenta que con lo que hemos hecho hasta aqu slo estamos comprobando el primer envo, lo que sera el banco de pruebas del apartado 7.5.1, pero qupasaconlossiguientesenvos?cmoloscomprobamos? Podramos pensar en incluir otro bucle for en el proceso que hemos hecho para considerar cada envo. Sin embargo, sabemos que los procesos se ejecutan permanentemente a no ser que terminen en un wait;. Por tanto, quitando el ltimo wait; el proceso volvera al principio despus del primer envo y realizara las mismas comprobaciones que acabamos de hacer. As que no hace falta incluir el bucle for, sino quitarelltimowait;yadaptarelprocesoparaquehagalascomprobacionesadaptadasa cadaunodelosenvos. Demaneraesquemtica,loquetendrsquehaceres: 1. Quitarelltimowait;paraqueelprocesonosedetengadespusdelprimerenvo. 2. Cambiar la comprobacin de los datos enviados. Modificando el assert del cdigo 7.25 para que compruebe el dato segn el nmero de envo en el que estamos. Esta modificacinsemuestraenelcdigo7.26
assert fpga_tx = datos_test(numenvio)(i) report "Fallo en el bit del dato" severity ERROR;
Cdigo 7.26: Modificacin del cdigo 7.25 para que compare los bits segn el nmero de envo
Fjate que el report ya no distingue ni nmero de envo ni bit. Puedes ampliar lo indicadoenlanotaalpienmero36(pgina109)paraqueincluyaestainformacin. Observa tambin que en el cdigo 7.26 se ha creado una variable o seal nueva: numenvio. Esta variable va a indicar el nmero de envo en el que estamos. As que tendremosquedeclararla(enelpuntosiguiente). 3. Declarardelavariablenumenvio.Enlosprocesossepuedendeclararvariablesysedeclaran antesdelbegin.Ensimulacinsepuedeninicializarlasvariables(ensntesisnosetieneen cuenta la inicializacin), por tanto, como estamos haciendo un proceso utilizado simulacin,nohayproblema.Enelcdigo7.27semuestraladeclaracineinicializacinde lavariablenumenvio.
110
P_Receptor: Process variable numenvio : natural := 0; begin ....
Cdigo 7.27: Declaracin de la variable numenvio dentro del proceso P_Receptor
4. Incrementar el valor de numenvio al terminar cada recepcin. Esto lo hars al final del proceso. Recuerda que las variables se asignan mediante el operador:= y que reciben el valorinmediatamente.Adiferenciadelassealesquerecibenelvalorconlasentenciawait o al terminar el proceso. En el cdigo 7.28 se muestra la asignacin de incremento de la variablenumenvio,queserlaltimasentenciadelproceso.
... numenvio := numenvio + 1; end process
Cdigo 7.28: Incremento de la variable numenvio
Con esto ya comprobaramos los cuatro envos. Ahora vuelve a simular el circuito observando si hay nuevos avisos provenientes de los asserts. En teora, si has hecho todos los bancos de pruebas propuestos y has verificado que funcionan bien, podemos pasaraimplementarlaenlaFPGA. Antesdelaimplementacin,elapartadosiguientetemuestraunamaneramssofisticada de hacer bancos de pruebas de modo que terminen por s mismos y no tengas que calcular el tiempo de simulacin. Este apartado es opcional, y puedes saltrtelo o mirrtelomsadelantesiestscansadodelosbancosdepruebas.
7.5.5. Bancos de pruebas que terminan por s mismos

Comomuestraelsmbolo,esteapartadoesopcionalymuestracmohacerqueel banco de pruebas termine por s solo, ahorrndonos tener que calcular el tiempo de simulacin queleindicamosalsimulador. El ahorrarnos calcular el tiempo de simulacin puede parece un ahorro insignificante, sin embargo, es muy til para alguien que no ha hecho el banco de pruebas y no tiene la informacin que nosotros tenemos. Ms an, este clculo lo hemos hecho a partir de una frecuenciadetransmisindelaUART(baudios),quepuedevariaryaquedependedeuna constante (c_baud). Por lo tanto, el tiempo de simulacin es variable, y recalcularlo nos podra implicar tener que leernos la documentacin o incluso peor, tener que descifrar el cdigo del banco de pruebas, especialmente si hemos diseado el banco de pruebas hace tiempo. Como consecuencia, todo esto implica dedicar tiempo que nos lo podemos ahorrarhaciendounbancodepruebasquetermineporsmismo. Para detener la simulacin y por tanto, hacer un banco de pruebas que termine solo, tenemos que detener para siempre todos los procesos que generan estmulos, esto es, los procesosdelbancodepruebas. Vamos a verlo con un ejemplo. Copiamos el fichero del ltimo banco de pruebas que hemos hecho (el fichero tb_uart_tx_3.vhd del apartado 7.5.4) y lo llamamos tb_uart_tx_4.vhd. Cambiamos tambin el nombre de la entidad y arquitectura y lo aadimosalproyectodelISE. Observamos el banco de pruebas y vemos que de los cuatro procesos, hay dos que terminan con la sentencia wait;, que son el proceso de los estmulos y el proceso del
111
reset. Por tanto, estos dos procesos terminan por s mismos, y no tenemos que modificarlos. De los otros dos procesos, tenemos el proceso del reloj que es indefinido y siempre estar generando la seal de reloj, y el proceso del receptor, que siempre est a la espera de recibirunanuevatransmisin. Tenemos que cambiar estos dos procesos de modo que tambin terminen con la sentencia wait;cuandosehayacompletadolatransmisinyrecepcin. En el proceso que genera los estmulos habamos asignado a uno de la seal fin_envio (recuerda el punto 10 de la pgina 105) justo antes de terminar (antes de la sentencia wait;). Hasta ahora esta seal no la hemos utilizado, y nos servir para avisarnos sobre cundosedaltimaordendetransmisin. Sin embargo, no debemos de detener la simulacin cuando la seal fin_envio se pone a uno, pues esta seal indica cundo se ha dado la ltima orden de envo. Habr que esperar a que el transmisor enve cada uno de los bits con el protocolo RS232 y que el receptorlosreciba. Ahoratendremosquemodificarelmodelodelreceptordemodoqueunavezquelaseal fin_envio valga uno, y se haya completado la recepcin, ponga una nueva seal a uno indicando que se debe terminar la simulacin. Esta nueva seal la llamaremos fin_simulacion,yladeclararemosconvalorinicial'0'. Con esta modificacin, el proceso del modelo del receptor terminar como muestra el cdigo7.29.
... if fin_envio = '1' then fin_simulacion <= '1'; -- esperamos un poco para no detener simulacion de repente wait for c_period_ns_baud * 1 ns; wait; -- detenemos este proceso despues derecibir el ultimo envio end if; end process;
Cdigo 7.29: Modificacin del proceso del receptor del banco de pruebas para que se detenga en la ltima recepcin y genere la seal de aviso del fin de la simulacin
Observa que en el cdigo 7.29, con el ltimowait; detiene el proceso en caso de que se est recibiendo el ltimo envo. Observa tambin que antes del ltimo wait se ha incluido una espera de un periodo de la UART para que la simulacin no termine repentinamente justo despus de la recepcin del bit de fin. Dejando as tiempo para que el receptor pase alestadodereposo. Ahora slo nos queda detener el proceso del reloj y lo detendremos con la seal fin_simulacion. Modificamos el proceso del cdigo 7.15 para que termine como muestra elcdigo7.30
... if fin_simulacion = '1' then wait; -- detenemos el proceso cuando se haya recibido el ultimo end if; end process;
Cdigo 7.30: Modificacin del proceso del reloj para detener la simulacin
Conestoyanotenemosque preocuparnospor definir untiempodesimulacin.EnelISE pincharemos en SimulationRun All; mientras que en Modelsim pincharemos en SimulateRunRun -All, o en los iconos correspondientes. Con esta orden y debido a que
112
los procesos terminan con wait; la simulacin se detiene sola y no tendremos que preocuparnos de cunto tiempo debemos simular. No obstante, siempre puede suceder que te hayas equivocado al hacer estas modificaciones, as que al hacer un cambio debes de comprobar que todo sigue bien. En este caso debes de comprobar que se hacen los cuatro envos correctamente y que tanto el transmisor como el receptor terminan en el estadoinicial.
7.6. Implementacin en la FPGA: diseo estructural

Queelcircuitoseafuncionalmentecorrectonoimplicaque yanovayamosatenerningn problemaensuimplementacin.Puedeocurrirquetengamosrestriccionestemporales,de rea o de consumo que nos obliguen a realizar modificaciones. Adems, a veces ocurre que los resultados de simulacin no se corresponden con los de sntesis, ya que, entre otros motivos, por ser el conjunto de sntesis ms reducido que el de simulacin, la sntesisnosiempretraducefielmenteelmodeloVHDL. Ya hemos diseado el transmisor, que lo hemos simulado y al menos en tera funciona bien.SinembargoseraintilimplementarloenlaFPGAsinnadams,pueseltransmisor necesitaunaordenparatransmitir.Asquetenemosquehaceruncircuitosencilloquenos d algo que transmitir. Para ello emplearemos los pulsadores, pues ya hemos probado que funcionan, y haremos que al pulsar se enve un byte por el transmisor a la computadora. Esteejemplonosservirparaintroducireldiseoestructural. Para comenzar la implementacin, volvemos al proyecto en el ISE, all tendremos el componente transmisor y el banco de pruebas. En la subventana de fuentes (Sources) seleccionamos las fuentes para sntesis e implementacin (Sources for: Synthesis/Implementation). Ahora crearemos un diseo estructural, donde tengamos el transmisor junto con un interfazconlospulsadores.Elesquemadeldiseosemuestraenlafigura7.26.
TOP_UART_TX Pulsadores INTERFAZ_PB pb_0 caracter pb_1 transmite pb_2 pb_3 clk rst fpga_tx clk rst clk rst fpga_tx tx_ocupado UART_TX dato_tx_in transmite transmitiendo RS-232
pb_0 pb_1 pb_2 pb_3
Figura 7.26: Esquema estructural del transmisor de la UART que implementaremos en la FPGA
Cadaunodelosbloquesdelafigura7.26representaunaentidadVHDLylocrearemosen unficherodistinto:
UART_TX:eseltransmisordelaUARTquehemoscreadoysimulado INTERFAZ_PB:
es el interfaz con los pulsadores que cuando se presionen uno de los pulsadoresgenerarlaordendetransmitirundatoconcretoalaUART
113
TOP_UART_TX: es un bloque estructural que va definir las entradas y salidas, y establecer
lasconexionesentrelosdosmdulosanteriores. Acontinuacinsedanguasparadisearestosmdulos
7.6.1. Diseo del interfaz con los pulsadores

Empezamos creando una nueva fuente (New Source) de tipo VHDL Module, cuyos puertos son los mostrados en la figura 7.26. Todos los puertos sern de tipo std_logic, menos caracterqueserunstd_logic_vectordeochobits. LasespecificacionesdelmduloINTERFAZ_PBson: 1. Recibir las entradas de cuatro pulsadores. Ya sabemos que estas entradas son totalmente asncronasydeduracinvariable. 2. Segn el pulsador que se presione, debe de dar la orden al transmisor de enviar un dato determinado. En la tabla 7.5 se muestra la correspondencia de los puertos con los pulsadoresdelaplaca,eldatoquedebenenviar(enhexadecimal)yelcarcterASCIIconel quesecorresponde.
Puerto
pb_0 pb_1 pb_2 pb_3
Pulsadoresalosqueestconectado XUPV2P
DOWN RIGHT UP LEFT
Nexys2
BTNO BTN1 BTN2 BTN3
Dato
x"61" x"6C" x"6F" x"68"
Carcter ASCII
'a' 'l' 'o' 'h'
Tabla 7.5: Puertos de INTERFAZ_PB y su correspondencia con los pulsadores de las tarjetas y el dato que tienen que enviar al transmisor
3. La orden de transmisin debe de durar un nico ciclo de reloj y debe enviarse una nica ordendeenvoporcadapulsacin. 4. Si se presiona el pulsador mientras el transmisor est enviando un dato (transmitiendo='1'),seignorarlapulsacinynoseenviarningunaordenaltransmisor. 5. Es improbable que se presionen dos pulsadores en el mismo instante, en es caso puedes elegirquenvotendrprioridad. Con estas especificaciones intenta realizar el interfaz por ti mismo. Posteriormente, para comparar tu solucin o si ves que no te sale, lee las indicaciones que se dan a continuacin. Como la orden de envo tiene que durar un nico ciclo de reloj y los pulsadores son asncronos, haciendo que las seales estn activas durante muchos ciclos de reloj, tendremos que realizar detectores de flanco37 para cada seal proveniente del pulsador. Incluso, para la placa Nexys2 se debera de hacer un circuito antirebotes38. Por tanto internamenteelcircuitopodratenerdosprocesos:
P_detecta_flanco:Procesodetectordeflancosparacadapulsador P_envia_orden:
Proceso que da la orden de enviar los datos determinados por la tabla
7.5 Elesquemainternodelcircuitosemuestraenlafigura7.27.
37 38
Recuerdaelcdigo2.16.Losdetectoresdeflancoseexplicancondetalleenelcaptulo5.3.2dellibrodeED2 Prctica11delmanualdeED2[17mach]
114
x"68"
x"6F"
x"6C"
8
P_detecta_flanco Pulsadores pb_0 pb_1 pb_2 pb_3 pb_0 pb_1 pb_2 pb_3 clk rst clk rst pulso_0 pulso_1 pulso_2 pulso_3
x"61"
8
pulso_0 pulso_1 pulso_2 pulso_3
caracter transmite tx_ocupado
8 dato_tx_in transmite transmitiendo
P_envia_orden
Figura 7.27: Esquema interno de interfaz con los pulsadores
En el proceso P_detecta_flanco debes de tener en cuenta que segn la placa que uses, los pulsadores sern activos a nivel alto o bajo. Esto ya lo solucionamos con las constantes c_on y c_off (recuerda el cdigo 6.5), en el reset debes de inicializar los biestables de los detectores de flanco al nivel inactivo (c_off) porque de lo contrario, seguramente tengas una orden de envo con el reset. La seales de los pulsos detectados (pulso_0, pulso_1, ...) laspuedesponeractivasanivelalto. El proceso P_envia_orden puede ser combinacional, simplemente tiene que dar la orden de transmitir (transmite='1') cuando alguno de los pulsos (flancos detectados) estn activos y la seal tx_ocupado no est activa. En ese caso, se enviar el dato correspondientealpulsadorpresionado. Comoesunprocesocombinacional,noteolvidesdeasignarlassealesentodosloscasos obienponerunaasignacinpordefecto.Conestoevitasqueseformenlatchs(recuerdael apartado2.5). Como ltimo apunte, para asignar un valor hexadecimal, en VHDL se indica con unax delante.Porejemplo:
caracter <= x"68"; -- "01101000", la x indica que es hexadecimal; en ascci: h
Cdigo 7.31: Asignacin de un hexadecimal a un vector de 8 bits
Una vez que realicemos los dos procesos comprobamos la sintaxis en el ISE (Check Syntax). Fjate que si tienes seleccionado el mdulo INTERFAZ_PB, en la subventana Processes hay menos opciones. Mientras que seleccionando la UART_TX aparecen todas las opcionesdeimplementacin.EstosedebeaquelaUART_TXfiguracomoelmdulodems alto nivel, esto el ISE lo indica con un simbolito con cuadraditos a su izquierda . Para ponerunmdulocomoeldemsaltonivelsepinchaconelbotnderechoencimadely se selecciona Set as Top Module (figura 7.28). De todos modos, ninguno de estos dos mdulos va a ser el superior en la jerarqua, sino que ser el TOP_UART_TX, que crearemos msadelante.
115
Seleccin del mdulo de ms alto nivel
Figura 7.28: Cmo indicar el mdulo de mayor nivel
7.6.2. Banco de pruebas del interfaz con los pulsadores

Aunque el interfaz con los pulsadores es un diseo sencillo, es habitual cometer algn fallo, por lo tanto se recomienda hacer un banco de pruebas para asegurar que est bien. Comparado con el banco de pruebas del transmisor (apartado 7.5), este banco de pruebas esmuchomssencilloynodeberasuponerningunadificultad. Te recomendamos que lo intentes hacer por ti mismo y luego veas las indicaciones que se danacontinuacin. El interfaz con los pulsadores tiene cinco entradas adems del reloj y el reset. De estas entradas, cuatro corresponden a los pulsadores y la otra indica si el transmisor est ocupado. Un banco de pruebas sencillo para este circuito consistira en modelar el funcionamiento de los pulsadores. Aunque en vez de hacer que los pulsadores estn activos durante milisegundos, para reducir los tiempos de simulacin, haremos que estn activosduranteunoscientosdenanosegundos(oalomsmicrosegundos). Al activar un pulsador, tenemos que comprobar que la salida transmite se active durante un nico ciclo de reloj y que, en el mismo ciclo de reloj, la salida caracter tenga el valor correspondiente al pulsador. Si te das cuenta, estamos repitiendo las especificaciones del apartado anterior. As que lo que hay que hacer es modelar el comportamiento de las entradasycomprobarquesecumplenlasespecificaciones. En un principio, para simplificar el banco de pruebas, puedes dejar la entrada transmite permanentemente a cero. Aunque para ser ms rigurosos, podras implementar un pequeo proceso que modelase de forma simplificada el transmisor. De modo que simplemente active la seal transmite durante unos cien ciclos de reloj39 cada vez que el interfazconlospulsadoresdlaordendetransmitir(transmite='1').
39
Deberaestaractivaloqueduraunatransmisin,perolopuedesdejarencienciclosderelojparasimplificar yreducireltiempodesimulacin.
116
Asimismo podras probar qu sucede si se activan dos pulsadores simultneamente y tambinsiseactivanentiemposmuyprximos. Al hacer el banco de pruebas, usa las constantes c_on y c_off para independizarlo de las caractersticasdelaplaca. Una vez que has comprobado que funciona, puedes pasar al siguiente apartado para implementar en la placa el diseo completo: el transmisor de la UART junto con el interfazconlospulsadores.
7.6.3. Diseo estructural: unidad de ms alto nivel

En este apartado crearemos el mdulo que engloba a los anteriores, lo llamaremos TOP_UART_TX y la arquitectura ser de tipo Estructural. Al ponerle estenombre indicamos quelaarquitecturanodescribeuncomportamientosinoqueindicalosbloques(mdulos) conlosqueestformadaylasconexionesentrelosbloquesylospuertosdelaentidad. Lospasospararealizareldiseoestructuralson40: 1. Declarar los puertos de la entidad. Los puertos son los mostrados en la 7.26, todos ellos sondetipostd_logic.Recuerdaquealdeclararlaentidadylospuertosestamosindicando quenuestrocircuitoescomounacajanegraquesecomunicaconelexteriorconlospuertos de entrada y salida. En nuestro caso, esta caja negra se representara como muestra la figura7.29.
TOP_UART_TX Pulsadores pb_0 pb_1 pb_2 pb_3 clk rst rs t RS-232 fpga_tx
Figura 7.29: Representacin esquemtica de la entidad de ms alto nivel
2. NombraralaarquitecturaEstructural(oeninglsStructural)delaentidadTOP_UART_TX. 3. Declarar los componentes que vamos a utilizar. Como es un diseo estructural que est formado por componentes, tenemos que declarar los componentes en la parte declarativa delaarquitectura.Estoyalohemoshechoenlosbancosdepruebas(recuerdalafigura5.2). Sin embargo, al crear un banco de pruebas, la herramienta ISE declara el componente automticamente,asqueesprobablequenotehayasdadocuentadeestadeclaracin. La declaracin de un componente es muy similar a la declaracin de la entidad. En el cdigo7.32semuestraladeclaracindelaentidaddelINTERFAZ_PByenelcdigo7.33 se muestra la declaracin del componente INTERFAZ_PB. Las diferencias se han resaltadoenrojo.
40
SinoapareceelcomponentequeacabasdeaadirpuedeserporqueelISElohaaadidocomounafuente desimulacin.Paraqueaparezcaensntesis,enSourcesforseleccionaBehavioral Simulation(figura5.2). AllprobablementeestelcomponenteTOP_UART_TX.Pinchaenlconelbotnderechoyselecciona Properties.EnAssociationseleccionaSynthesis/Imp + SimulationypinchaenOk.Detodosmodos,al principio,mientrasnoincluyasningunasentenciasintetizable,elISEvaainterpretarqueesparasimulacin ynocambiarlaspropiedades.AsquealprincipiotrabajadesdeBehavioral Simulationhastaquetengas avanzadoelcircuito,enesemomentocompruebaslasintaxis(Check Syntax),lecambiaslaspropiedadesy vuelvesatrabajardesdeSourcesforSynthesis/Implementation.
117
entity interfaz_pb Port ( rst : in clk : in pb_0 : in pb_1 : in pb_2 : in pb_3 : in tx_ocupado : in transmite : out caracter : out ); end interfaz_pb;
is std_logic; std_logic; std_logic; std_logic; std_logic; std_logic; std_logic; std_logic; std_logic_vector (7 downto 0)
component interfaz_pb is Port ( rst : in std_logic; clk : in std_logic; pb_0 : in std_logic; pb_1 : in std_logic; pb_2 : in std_logic; pb_3 : in std_logic; tx_ocupado : in std_logic; transmite : out std_logic; caracter : out std_logic_vector (7 downto 0) ); end component;
Cdigo 7.32: Declaracin de entidad y diferencias con la declaracin de componente
Cdigo 7.33: Declaracin de componente41 y diferencias con la declaracin de entidad
As que incluye las declaraciones de los componentes INTERFAZ_PB y UART_TX en la partedeclarativadelaarquitectura(antesdelbegin). 4. Referenciaroinstanciarloscomponentes.Estoseracomocolocaryconectarennuestro circuito estructural los mdulos que vamos a utilizar. En la referencia se indican las conexionesdeseales,elllamadoportmap,dondelospuertosdelcomponentereferenciado seconectanconlassealesypuertosdelcircuitoestructural. En la figura 7.30 hemos detallado el circuito original (figura 7.26), donde se han diferenciado los puertos de la entidad TOP_UART_TX en azul, las seales internas de la arquitecturaTOP_UART_TXenrojoylospuertosdelcomponenteUART_TXenverde.
Seales de TOP_UART_TX TOP_UART_TX INTERFAZ_PB pb_0 caracter pb_1 transmite pb_2 pb_3 tx_ocupado clk rst fpga_tx clk rst clk rst fpga_tx UART_TX dato_tx_in transmite tx_ocupado transmite transmitiendo Puertos de UART_TX (no se ven desde TOP_UART_TX)
pb_0 pb_1 pb_2 pb_3
caracter_tx
Puertos de TOP_UART_TX
Figura 7.30: Representacin esquemtica de la arquitectura estructural, con los componentes referenciados y sus conexiones
Los puertos de los componentes no se ven desde la arquitectura estructural. Por ejemplo, el puerto de salida transmitiendo del componente UART_TX no se puede usar directamente por ser un puerto del componente. Esto es lgico, ya que dos componentes podran tener puertos con el mismo nombre (por ejemplo imagina que hubiese otro tipo de transmisor con la misma seal transmitiendo), en ese caso, si pudisemoshacerreferenciaalospuertosdeloscomponentesnoscrearaunconflicto porquenosabramosaculdelosdospuertosnosestaramosrefiriendo.
41
ElVHDLavecesesflexibleensucodificacin.Porejemplo,lapalabraisquevadespusdelnombredel componente(enlaprimeralnea)esopcional.Otroejemploesquedespusdelend componentsepuede incluirelnombredelcomponente(antesdelpuntoycoma).
118
As que los puertos de los componentes los conectaremos con seales o puertos del diseo estructural, y lo que usaremos en la arquitectura sern esas seales o puertos. Estasseales y puertosdel diseo estructural no tienen por qu llamarse igual que los delcomponente,aunquepuedanllamarseigual. Enlafigura7.31seexplicacmosereferenciauncomponenteenVHDL.Enelpunto1 seponeelnombredelareferencia.Estoesasporqueunmismocomponentesepuede utilizar ms de una vez. En el punto 2 se pone el nombre del componente utilizado, queeselnombredelaentidad.Enelport mapseconectanlospuertosdelcomponente con los puertos y seales del estructural. A la izquierda los puertos del componente (punto 3) y a la derecha los puertos y seales del estructural (punto 4). En el ejemplo, de estos puertos y seales, tres son seales (punto 5) y el resto son puertos (punto 6). Observa que el nombre de los puertos del componente no tiene que coincidir con los puertosysealesdelestructural.
1 Nombre de la instancia del componente (un componente se puede referenciar ms de una vez) 2 Nombre del componente (el nombre de la entidad)
TX: UART_TX Port Map ( rst clk transmite dato_tx_in transmitiendo fpga_tx ); 3 Puertos de UART_TX (no se ven desde TOP_UART_TX)
=> => => => => =>
rst, clk, transmite, caracter_tx, tx_ocupado, fpga_tx
6 5
puertos de TOP_UART_TX
seales de TOP_UART_TX
Puertos y seales de TOP_UART_TX
Figura 7.31: Explicacin de la referencia o instancia de un componente en VHDL
AhoraincluyelareferenciadelaUART_TX(figura7.31).Apartirdelaexplicacinquese ha dado y observando las conexiones de la figura 7.30, incluye tambin la referencia delINTERFAZ_PB. 5. Declarar seales. Observa en las figuras 7.30 y 7.31 las seales del estructural: transmite, caracter_tx y tx_ocupado. Estas seales las tendremos que declarar en la arquitectura. As pues declralas en la parte estructural de la arquitectura. Estas seales tendrn que coincidir entipo y nmero de bits con los puertoscon los que se conectan.De lo contrario aparecerunerroralcompilar. Una vez hayas hecho todos estos pasos, ya puedes comprobar si la sintaxis es correcta. Si an ests en Sources for: Behavioral Simulation mira la nota al pie 40 de la pgina 117 para cambiarasntesis. Fjatequinesahoralaunidaddemsaltonivel,deberadeserTOP_UART_TX. Ahoracreaelfichero.ucfparaasociarlospuertosconlospines.Lospulsadoresascialos segn la tabla 7.5. Para la XUPV2P pon el reset en el pulsador del medio, y en la Nexys2 ponelresetenelprimerinterruptor.
119
Sintetizaeimplementaelcircuitoenlaplaca.Conectaelpuertoseriedelordenadorconla placa. Y ahora comprobaremos que funciona bien. Para ello abrimos un hiperterminal, Windows suele tener uno en Inicio Todos los programas Accesorios Comunicaciones HyperTerminal. Tambin hay otros de libre distribucin como el RealTerm [24realt] que es gratuitoytieneopcionesmuyinteresantesparadepurarencasodequealgonovayabien. Usaremos el HyperTerminal de Microsoft, una vez que se sabe utilizar uno no es difcil usarotro. Al abrirlo nos aparecer una ventana para establecer una nueva conexin (figura 7.32), nos pide nombre de la conexin y un icono para ella (esto del nombre y del icono no siempre lo piden en otros hiperterminales). Si no nos lo pidiese pinchamos en ArchivoNueva Conexin.
Figura 7.32: Nueva conexin del hiperterminal
Posteriormente (figura 7.33) aparecer una ventana que dice Conectar a, le indicamos Conectar usando COM1(uotroCOMsegntuordenador). Y por ltimo nos saldrn las propiedades de la comunicacin con el puerto serie (figura 7.34). Despus del diseo que hemos hecho, ya estaremos familiarizados con el significado de estas propiedades. Las rellenamos segn las caractersticas de nuestro diseo: bits por segundo (115200), paridad (sin paridad), bits de parada (1), control de flujo(ninguno),.... Despus de darle a aceptar ya tendremos la conexin, y probamos a presionar uno de los cuatrobotones(noeldelmedioqueeselresetparalaXUPV2Pynoharnadavisible). Comprueba que en el hiperterminal aparecen los caracteres que has enviado. Si te salen, enhorabuena, has logrado implementar un diseo de relativamente complejo. Si no te sale, comprueba que las caractersticas de la conexin que has establecido coinciden con las de tu circuito, y que tienes los pines correctamente configurados. A veces sucede que el hiperterminal no funciona a altas velocidades de transmisin. En estos casos, el error aparece al configurar el hiperterminal, sin siquiera conectar la placa al PC por el puerto
120
serie. Si esto sucede, prueba a poner una velocidad baja, por ejemplo 9600. Comprueba tambin que el cable serie est bien conectado. Y si nada de esto funciona, prueba a simularelcircuitocompletoysiannofunciona,miraelapartado7.6.4.
Figura 7.33: Conexin al puerto serie
Figura 7.34: Caractersticas de la conexin
7.6.4. Cuando la sntesis no funciona

Puede ser que hayas seguido todos los pasos anteriores y an as no te funcione el circuito.Lascausasdequenofuncionepuedensermuydiversas,yporlotantoesresulta difcildedarunaguaexhaustivadecmoproceder.Sobretodoeslaexperiencialaquete ayudar a resolver de manera ms rpida estos problemas. An as te daremos una serie depuntosquepodrsrevisarcadavezquenosepasdndeestelerror. Importante: los momentos de bsqueda de fallos pueden ser desesperantes, sobre todo cuandosealarganmuchoylostiemposdeentregaseacercan.Enestosmomentoscrticos a veces sucede que estropeamos ms que arreglamos. Intentar mantener la calma puede ser un consejo difcilmente alcanzable, pero lo que s est en tu mano es hacer copias de seguridad. Cada vez que vayas a arreglar algo, haz una copia de seguridad. Lo recomendable sera utilizar un sistema de control de versiones, pero como mnimo, deberasdehacercopiasdelosficherosque vayasamodificar(incluyendoalnombredel ficheroelnmerodeversin,porejemplo:nombrefichero_v13.vhd). A continuacin te damos una serie de puntos que esperamos que te ayuden a encontrar loserrores: 7.6.4.1. Comprueba que todo est bien conectado Aunque esta recomendacin pueda parecer muy evidente, a veces las cosas no funcionan porestetipodedespistesysepierdemuchotiempobuscndoloenotrositio.Comprueba que todo est bien conectado: placa enchufada, interruptor encendido, cables conectados: RS232,USB,... 7.6.4.2. Comprueba el fichero .ucf Mira el fichero .ucf y vuelve a repasar la correspondencia de los pines con los puertos. Comprueba que no ests nombrando los pines de otra placa. Recuerda que en la Nexys2 hay algunos pines que en la placa no estn correctamente nombrados, mira las hojas de caractersticasdelaplacayvulvelosarevisar.
121
7.6.4.3. Comprueba el reset del circuito Hazlassiguientescomprobacionesdelresetdetucircuito: Miradequpulsadorointerruptorvieneelresetyverificaquenolotengasreseteado. CompruebaqueeneldiseoVHDLelresetdeloselementosdememoriaseactivesiempre almismonivel. Si has usado la constante c_on para activar los elementos de memoria (como hemos recomendado), comprueba que el valor de la constante se corresponde con el valor de activacin de su pulsador correspondiente. Recuerda que los pulsadores de las placa XUPV2PfuncionananivelbajoylosdelaNexys2anivelalto.
7.6.4.4. Simula el circuito completo Puedeserquehayascadaunodelosmdulosporseparado,peronoelcircuitocompleto. Quiz el fallo est en alguna conexin del mdulo de ms alto nivel. Simula el circuito completo y revisa bien las formas de onda. Vuelve a repasa las simulaciones de los mdulos. 7.6.4.5. Revisa las advertencias del sintetizador Observa detenidamente los warnings (advertencias) que da el ISE al sintetizar. Hay algunosquenospuedenayudaraencontrarelfallo(otrosnotienenmuchautilidad).Para ver los warnings tienes que pinchar en View Design Summary dentro de la subventana Processes (punto 1 de figura 7.35) o bien seleccionar la pestaa del resumen del diseo (Design Summary) (punto 2 de figura 7.35). En la ventada del resumen del diseo tienes que pinchar en los warnings (punto 3 de figura 7.35). Tambin los puedes ver pinchando enlapestaadeWarningsdelasubventanainferior(punto 4defigura 7.35),sinembargo, aqu slo veras los warnings, y hay ciertos avisos que pueden ser muy tiles que no se muestranaqu.
1
Ventana del resumen del diseo
3 Pinchar para
ver los warnings
Figura 7.35: Resumen del diseo en el ISE
122
Acontinuacinseexplicanelsignificadodealgunosdeestasadvertencias: 1. Erroresenlaslistasdesensibilidad.Laslistasdesensibilidadsonparasimulacin(repasa el manual de ED2 [17mach]), pero no se usan en sntesis. Cuando un proceso tiene mal la lista de sensibilidad, puede ocurrir que la simulacin no se corresponda con la sntesis. Recuerda que en la lista de sensibilidad se deben incluir las seales que se leen en el proceso42, aunque si es un proceso con reloj basta con incluir la seal de reloj y las anteriores43(elresethabitualmente).Asquecompruebaelwarningquedice: Xst:819Thefollowingsignalsaremissingintheprocesssensitivtylist... 2. Comprueba si hay registros que se quedan con valores constantes. Esto no siempre implicaqueseaunerror,asquedebesdecomprobarsisetratadeunerroroestbienas. Por ejemplo, probablemente al sintetizar el circuito completo te haya salido el siguiente error: Xst:1710 FF/Latch <dato_tx_rg_7> (without init value) has a constant value of 0 in block <TX>. Esta advertencia nos avisa que el bit 7 de la seal dato_tx_rg que est en el bloque TX tiene el valor constante0. El nombre del bloque (TX en este caso) lo da el nombre que hemos puesto a la referencia o instancia del componente (recuerda la figura 7.31 donde se puso el nombre TX al componente UART_TX). En nuestro caso tendremos que comprobarporquelbit7delasealdato_tx_rgsequedaacero. Que un biestable est siempre a cero, aparentemente es un error. Para descubrir si realmente se trata de un error tenemos que ir al proceso donde se asigna la seal (fichero uart_tx.vhd) y analizar las asignaciones. El proceso es el registro de desplazamiento. En la figura 7.36 se muestra el proceso44 y en ella podemos apreciar que el bit 7 de dato_tx_rg se asigna slo en las dos primeras sentencias, mientras que en la ltima sentencia se asignan todos los bits menos el 7. Esto es porque es un registro de desplazamiento a la derecha y por tanto dato_tx_rg(7) mantiene su valor. En la primera sentencia (en el reset) se asigna un cero y en la segunda se asigna dato_tx_in(7). Por lo tanto habr que seguir investigando qu valores tiene dato_tx_in(7).
P_CargaDesplaza: Process(rst, clk) begin if rst = c_on then dato_tx_rg(7) <= '0' dato_tx_rg <= (others => '0'); elsif clk'event and clk = '1' then if cargadato = '1' then dato_tx_rg <= dato_tx_in; dato_tx_rg(7) <= dato_tx_in(7) elsif desplaza = '1' then dato_tx_rg(7) dato_tx_rg (6 downto 0) <= dato_tx_rg (7 downto 1); no recibe valor, end if; guarda el que tena end if; end process;
Figura 7.36: Asignacin de la seal dato_tx_rg
42 43 44
Revisaelcaptulo3delmanualdeED2[17mach] Revisaelcaptulo5delmanualdeED2[17mach] Probablementenohayasrealizadoelprocesoigual,perofjateenestosejemplosparaentenderloquese intentaexplicar,yluegocompralocontudiseo.
123
El puerto dato_tx_in est conectado con el puerto caracter del INTERFAZ_PB (figura 7.30). As que tendremos que analizar qu valores recibe el puerto caracter. En la figura7.37semuestraelprocesodondeseasigna45.
P_envio_orden: Process(pulso_0, pulso_1, pulso_2, pulso_3, tx_ocupado) begin if tx_ocupado = '1' then transmite <= '0'; caracter <= (others => '0'); caracter(7) <= else transmite <= '0'; caracter(7) <= caracter <= (others => '0'); if pulso_0 = '1' then transmite <= '1'; caracter(7) <= caracter <= x"61"; -- "01100001", letra 'a' elsif pulso_1 = '1' then transmite <= '1'; caracter(7) <= caracter <= x"6C"; -- "01101100", letra 'l' elsif pulso_2 = '1' then transmite <= '1'; caracter <= x"6F"; -- "01101111", letra 'o' caracter(7) <= elsif pulso_3 = '1' then transmite <= '1'; caracter(7) <= caracter <= x"68"; -- "01101000", letra 'h' end if; end if; end process;
'0'
'0'
'0'
'0'
'0' '0'
Figura 7.37: Asignacin del puerto de salida caracter
Observando el proceso nos daremos cuenta que el bit 7 de caracter siempre recibe un cero.Estoesunacasualidad,debidoaquelascuatroletrasqueasignamostienenelbit mssignificativoacero.Elsintetizadorsehadadocuentadeesto,yenvezdeusarun biestable para este bit, lo ha reducido a una constante y lo avisa con ese warning. En otrocasopodraserdebidoporunerrornuestroalcodificar,peroenestecaso,debido alaparticularidaddelasasignaciones,lasimplificacinescorrecta. 3. Sealesquenoseusan.Normalmentedeclararunasealsinusarlapuedesignificarquete hasolvidadodeusarlaoqueinicialmentepensabasquelaibasausarytehasdadocuenta que no la necesitabas. En el primer caso, este warning te est recordando que te falta por haceralgoenelcircuito ypuedeserqueseaporestoquenofuncione.Enelsegundocaso deberas de borrar o como mnimo comentar la declaracin. Es importante tener el cdigo ordenado yquitar cosasintiles quedificulten lacomprensin del cdigo.El aviso queda elISEparaestassealesquesedeclaranperonoseusaneselsiguiente(enesteejemplola sealsellamas_inutil): Xst:1780Signal<s_inutil>isneverusedorassigned. 4. Sealesqueseasignanperoquenoseusan.Cuandohasasignadovaloraunasealpero no usas esa seal, seguramente sea que te has olvidado darle uso. En la figura 7.38 se representa este caso. Como puedes ver no tiene sentido crear una seal y asignarle valor paranada.
45
Delamismamaneraqueelcasoanterior,tuprocesopuedeserdiferente
124
seal que no se propaga
sin_salida puerto_entrada_1 puerto_entrada_2
Figura 7.38: Esquema de un circuito con una seal que no da valor
ElwarningquedaelsintetizadorISEeselsiguiente: Xst:646Signal<sin_salida>isassignedbutneverused. 5. Sealesqueseusansinrecibirvalor.Eselcasocontrarioalanterior,esbastantegraveque unasealqueestsusandonolehayasasignadovalor.Seracomoponeruncablealairey seguramente implique que te hayas olvidado de incluir la sentencia que le da valor. La figura7.39representaestecaso,dondealasealsin_asignarnoselehaasignadonada.
seal que no recibe valor
sin_entrada puerto_entrada puerto_salida
Figura 7.39: Esquema de un circuito con una seal que no ha recibido valor
Enestecasoelwarningeselsiguiente,yelsintetizadorlaponeavalorcero. Signal<sin_entrada>isusedbutneverassigned.Tiedtovalue0. 6. Creacin de Latches. Cuando el sintetizador avisa de que ha creado un latch46 para una seal conviene que comprobar que realmente queramos generar el latch. Aunque la creacindeunlatchnonecesariamenteimplicaqueseaunerror,engeneralserecomienda disear circuitos sncronos con el reloj, haciendo que los elementos de memoria sean activos por el flanco del reloj. Esto es una recomendacin de diseo porque son ms segurosydanmenosproblemas,peronoimplicaqueseaerrneo. Adems de esto, muchas veces se crean latches involuntariamente. Por ejemplo, cuando una seal combinacional no la asignamos en todas las alternativas, la seal tiene que guardar su valor y para ello genera un latch. Implementar la seal con un latch en vez de con un circuito combinacional puede producir un comportamiento indeseado en el circuito. As que cuando veas este warning comprueba que la seal se asigna en todas las alternativas, prestando atencin en que las sentencias if terminen en else (y no en elsif). Revisa los captulos 4 y 5 del manual de ED2 [17mach] si no entiendesestoltimo. El aviso que da el ISE se muestra a continuacin, en el que indica que se ha generado unlatchparalaseals_latch. Xst:737Found1bitlatchforsignal<s_latch>. 7. Formacindelazoscombinacionales.Cuandoapareceestaadvertenciahayquedescubrir qu la ocasiona y solucionarlo. En un circuito sncrono con FPGA no debera de haber
46
Loslatchsseexplicanenelapartado2.5ymsenprofundidadelcaptulos4y5delmanualdeED2 [17mach]
125
buclescombinacionales.Unbuclecombinacionalseformacuandoelrecorridodeunaseal sepropagahacasmismasinquehayanelementosdememoriaenmedio.Enlafigura7.40 semuestraelesquemadeunlazocombinacionalyelVHDLquelogenera.

Lazo combinacional
s_lazo s_2 in_1 in_2
s_2 <= in_1 or s_lazo; s_lazo <= in_2 or s_2; s_lazo
Figura 7.40: Esquema de un circuito con lazo combinacional y el cdigo VHDL que lo forma
Fjate que las seales s_2 y s_lazo forman el lazo combinacional. Estos lazos provocaran un funcionamiento asncrono y errtico por los retardos de las puertas y conexiones.Porlotantohayqueevitarlos,paraellohayqueentenderlafuncionalidad del circuito e intentar buscar una descripcin alternativa. La manera habitual de evitarlos es poner un biestable enmedio, aunque hay que hacerlo con cuidado, siendo necesariocomprobarqueelnuevocircuitocumplelafuncionalidaddeseada. La figura 7.41 muestra cmo se puede romper el lazo combinacional de la figura 7.40. Observa que este lazo se podra romper tambin por la seal s_2, en vez de por la seal s_lazo. La funcionalidad de estos circuitos sera diferente, por lo que se debe de comprobarsielcircuitosecomportacomoqueremos.
s_lazo s_2 in_1 in_2 Un biestable rompe el lazo combinacional s_lazo s_2 <= in_1 or s_lazo; P: Process (rst,clk) begin if rst = c_on then s_lazo <= '0'; elsif clk'event and clk='1' then s_lazo <= in_2 or s_2; end if; end process
Figura 7.41: Esquema que muestra cmo se puede romper el lazo combinacional de la figura 7.40
El aviso del sintetizador del ISE se muestra a continuacin. Sin embargo, si miras el aviso por la ventana del resumen del diseo (punto 2 de la figura 7.35), no se muestra la seal que forma el lazo. Tienes que mirarlo en la pestaa de Warnings de la subventana inferior (punto 4 de figura 7.35). An as, la informacin no siempre es muyclarayhayqueinvestigarunpocoparaencontrarellazo. Xst:2170Unitinterfaz_pb:thefollowingsignal(s)formacombinatorialloop:s_lazo. Por ltimo indicar que los lazos combinacionales son ms difciles de detectar cuando se forman entre varios mdulos de un diseo estructural. Vemoslo con un ejemplo similar al del transmisor de la UART pero ms sencillo. Tenemos un circuito estructuralcondosmdulos(figura7.42).
126
TOP_TX INTERFAZ pb pb transmite transmitiendo clk rst clk rst TRANSMISOR transmite transmite transmitiendo clk rst tx tx
Figura 7.42: Esquema de ejemplo de circuito estructural para mostrar lazos combinacionales entre mdulos
Unmduloesuntransmisorquecuandorecibelaordendetransmitir(transmite='1') comienza la transmisin por el puerto tx. Durante la transmisin pone la seal transmitiendo a valor 1. Este circuito tiene dos estados: e_init y e_tx. En el primero est en reposo esperando la orden, y en el segundo est transmitiendo, al terminar de transmitir,vuelvealestadodereposo. El otro mdulo es un interfaz con un pulsador pb. Este circuito detecta el flanco del pulsador generando la seal pulso_pb. Cuando hay flanco (pulso_pb='1'), ordena el inicio de la transmisin al transmisor. En caso de que el transmisor est transmitiendo (transmitiendo='1')elinterfaznoordenarlatransmisin. Podramos describir los procesos que asignan las salidas transmite y transmitiendo comosemuestranenlafigura7.43.
INTERFAZ ... P_I: Process (transmitiendo, pulso_pb) begin if transmitiendo = '1' then transmite <= '0'; elsif pulso_pb='1' then transmite <= '1'; else transmite <= '0'; end if; end process; ... TRANSMISOR ... P_T: Process (estado, transmite) begin case estado is when e_init => if transmite = '1' then transmitiendo <= '1'; else transmitiendo <= '0'; end if; when e_tx => transmitiendo <= '1'; end case; end process; ... transmitiendo se pone a '1' cuando transmite='1'
transmite se pone a '0' cuando transmitiendo='1'
transmite = '1'
transmitiendo ='1'
transmite = '0'
Por la rapidez, el estado no habr cambiado, estado=e_init y pulso_pb todava estar a '1' transmite = '0' transmitiendo ='0' transmite = '1'
Figura 7.43: Procesos en mdulos distintos que forman un lazo combinacional con las seales transmite y tranmitiendo.
Siobservaslosprocesos,ambossoncombinacionales.Lasealtransmitiendodepende de la seal transmite y viceversa. Por lo tanto ambas forman un lazo combinacional. Este lazo combinacional hara que en cuanto la seal transmite se pusiese a uno se volvera a poner a cero casi instantneamente debido a que transmitiendo se pondra
127
a uno. Tardara el tiempo de retardo de las seales y las puertas. Sin embargo, las seales no seran estables y volveran otra vez a los valores iniciales porque pulso_pb seguira a uno y el estado no habra cambiado, ya que por haber sido tan rpido el cambio de las seales, an no habra llegado el flanco de reloj que hara cambiar a los biestables. Adems esto podra hacer que el circuito fuese inestable porque no cumplirselostiemposdesetupyholddelosbiestables,provocandometaestabilidaden losbiestables(estoseexplicenED2). Cmo podramos solucionar este problema y romper el lazo combinacional? una primerasolucinpodraserregistrar47lassalidastransmitey/otransmitiendo.Laotra solucin es hacer que la seal transmitiendo dependa slo del estado y no de la entrada transmite. Si recuerdas de ED2, esto es hacer que la mquina de estados sea una mquina de Moore en vez de Mealy (el proceso de la figura 7.43). La figura 7.44 muestraelprocesocomomquinadeMoore,conestoserompeellazocombinacional.
INTERFAZ ... P_I: Process (transmitiendo, pulso_pb) begin if transmitiendo = '1' then transmite <= '0'; elsif pulso_pb='1' then transmite <= '1'; else transmite <= '0'; end if; end process; ... transmite se pone a '0' cuando transmitiendo='1' TRANSMISOR ... P_T: Process (estado, transmite) begin case estado is when e_init => transmitiendo <= '0'; when e_tx => transmitiendo <= '1'; end case; end process; ...
transmitiendo depende del estado no de transmite
Figura 7.44: El proceso del transmisor como mquina de Moore para romper el lazo combinacional.
8. Simplificacin de lgica. El sintetizador simplifica la lgica que no es til en el circuito final. Tenemos que estar muy atentos a estas simplificaciones porque implica que lo que hemos querido codificar no se va implementar como esperamos. Por ejemplo, supn que enalsintetizareltransmisordelaUARTtenemosunavisoqueindicalosiguiente48: Xst:2679 Register <baud> in unit <uart_tx> has a constant value of 0 during circuit operation.Theregisterisreplacedbylogic. Delafigura7.12yrecordandoloquehacenuestrotransmisorpodemosdeducirquesi la seal baud tiene un valor constante cero, nuestro transmisor no funcionar, pues es el que hace cambiar de estados y hacer los desplazamientos del registro de desplazamiento. Efectivamente, el que la seal baud valga cero el la causante de que porejemplolasealdesplazatengaelmismoavisoquebaud.Ytambinlaresponsable delosavisos: Xst:1799Statee_bits_datoisneverreachedinFSM<estado_tx>. Xst:1799Statee_bit_finisneverreachedinFSM<estado_tx>. Es decir, nos est diciendo que nunca se llega a los estados e_bits_dato y e_bit_fin. Loqueeslgicosibaudsiempresequedaacero.
47 48
Registrarunasealeslomismoqueponerunbiestableenesaseal. Curiosamenteesteavisonoestcatalogadoconowarningsinocomoinfo,porloquenoseveenlasuventana deWarnings(laqueestabajo,elpunto4defigura7.35).
128
Otrowarningnosdiceque: Xst:646Signal<dato_tx_rg<7:1>>isassignedbutneverused. Esta advertencia tambin es lgica, pues dato_tx_rg es el registro de desplazamiento., quecomolasealdesplazasequedaacero,losbitsdel7al1nuncavanaserusados. Por tanto, las advertencias del sintetizador pueden darnos informacin muy valiosa. Estando atentos a sta podemos detectar en qu falla el circuito. En este caso, era un fallo del divisor de frecuencia y este fallo tambin lo hubisemos detectado mediante simulacin, pero cuando no encuentras el fallo, es importante buscar cualquier fuente deinformacin. 9. Otros avisos. No podemos dar una lista exhaustiva de todos los warnings e infos que da el sintetizador, adems de que hara que este manual fuese muy aburrido. Con esta introduccinyatienessuficienteinformacinparainvestigarportimismoelsignificadode otrosavisos.Hayavisosquenosonimportantesylosversencasitodoslosdiseos,como: Xst:2734Propertyuse_dsp48isnotapplicableforthistechnology. As que con atencin y la experiencia que vayas adquiriendo irs aprendiendo a identificarelsignificadodelosavisosysuimportancia. 7.6.4.6. Muestra informacin del circuito por los leds Cuando el circuito no hace nada que podamos ver, como por ejemplo el circuito del transmisor de la UART, no tenemos informacin de si el circuito est haciendo algo. En estos casos los leds pueden ser una fuente de informacin muy valiosa. Puedes sacar sealesqueteayudenaconocerelestadointerno.Puedestambincodificarlosvaloresde los estados en los leds, para ver si se queda atascado en algn estado. Ten cuidado de no sacar seales cuya activacin sea muy corta, porque si es as, no podrs apreciar la activacin. Al sacar seales por los leds ten en cuenta las caractersticas de los leds de la placa, esto es, si funcionan a nivel alto o bajo. Mejor es que uses las constantes c_on y c_off. 7.6.4.7. Crea un nuevo proyecto en el ISE A veces el proyecto del ISE se corrompe y no actualiza los cambios que hagas en el circuito. En estos casos, el fichero .bit generado no cambia y corresponde a una versin anterior. La solucin es crear un nuevo proyecto e importar los ficheros .vhd del anterior. Puede ser desesperante que despus de horas de intentarlo todo, sea esto lo que haya originadoelfallo(aunqueporotraparteseaunaliviohaberencontradoelfallo).
7.7. Diseo del receptor de la UART

En este apartado se darn las indicaciones para disear el receptor de la UART. En los apartadosanterioressehadadomuchainformacinconelobjetivodequepuedasserms independiente en los diseos que se propongan a partir de ahora. As que no dudes en repasarlosconceptosanterioresencasodequeteencuentrescondificultades. Con todo lo que hemos visto sobre el funcionamiento del protocolo RS232, despus de haber diseado el transistor e incluso haber diseado un receptor para simulacin (apartado 7.5.4), no debera ser necesaria mucha explicacin para que puedas disear un receptorsintetizable. Laentidadquequeremosdiseartieneelaspectomostradoenlafigura7.45:
129
8 aviso_rx de/hacia nuestro sistema
UART_RX dato_rx_out del exterior (computadora) fpga_rx FPGA_RX Pines: AJ8 (XUPV2P) U6 (Nexys2)
recibiendo clk rst
Figura 7.45: Entradas y salidas del receptor
Las constantes del diseo sern las mismas que usamos para el transistor (tabla 7.2) y de hechousaremoslosmismospaquetes. Lasespecificacionesdelospuertossonlassiguientes:
Puerto
rst clk fpga_rx
bits I/O
Descripcin
1 I Sealderesetasncrono,suniveldependerdec_on 1 I
Sealderelojdelaplaca.Lafrecuenciadelrelojseindicaenlaconstante c_freq_clk.
1 I Tramaqueserecibeenseriedesdelacomputadora,sigueelformatoRS232
Avisodequeseharecibidounnuevodatoyqueestdisponibleen 1 O dato_rx_out.Elavisosedarponiendolaseala1duranteunnicociclo dereloj.
aviso_rx
dato_rx_out recibiendo
8 O 1 O
Proporcionalos8bitsdeldatoqueseharecibido.Estedatoessloser vlidodesdequeaviso_rxvalga1ymientrasrecibiendosea0 Cuandovale1indicaqueelmduloseencuentrarecibiendounatramay portantoelvalordeldatodato_rx_outnoesvlido Tabla 7.6: Puertos del receptor de la UART
En la figura 7.46 se muestra cmo debera ser el cronograma de las salidas del receptor al terminar una recepcin (fjate dnde est el bit de fin), posteriormente con la lnea en reposo, y por ltimo al comienzo de una nueva recepcin (fjate dnde est el bit de inicio). A partir de la figura se observa que el dato recibido (dato_rx_out) slo ser vlido a partir del aviso de la seal aviso_rx y mientras que la seal recibiendo se mantenga a 0. Cuando la seal recibiendo se ponga a1 el dato no ser vlido. Nunca podrn estar simultneamentea1lassealesrecibiendoyaviso_rx.
fin de la recepcin
... bit 7 del dato
comienzo de nueva recepcin reposo bit inicio

bit 0 ...
bit de fin
fpga_rx recibiendo aviso_rx dato_rx_out(7:0)

clk dato vlido
dato invlido
fin de la recepcin
dato invlido
Figura 7.46: Cronograma de salidas del receptor al terminar la recepcin y el comienzo de una nueva
130
A partir de aqu, intenta hacer el receptor por ti mismo. Si ves que tienes dudas, o para comparartusolucinconunapropuesta,consultalasguasquesedanacontinuacin. El diseo del receptor se puede realizar de manera parecida al del transmisor. Una primeraaproximacinaldiagramadebloquesdeldiseosemuestraenlafigura7.47.
Desplz_SIPO RegIn
fpga_rx fpga_rx_rg
7 0
dato_rx_out(7:0)
Control
desplaza baud_medio baud aviso_rx recibiendo en_divfreq
desplaza clk rst aviso_rx recibiendo
DivFrec
baud_medio baud clk en_divfreq rst
Clk
rst
Figura 7.47: Diagrama de bloques preliminar del receptor
Acontinuacinsedescribenbrevementecadaunodelosbloques.
7.7.1. Registro de desplazamiento

El registro de desplazamiento (Desplz_SIPO) es un registro al que se le van cargando los datos en serie y los devuelve en paralelo (serialin parallelout: SIPO). ste es el registro opuesto al que tenamos en el transmisor, que cargaba en paralelo y devolva en serie (PISO). Como el primer bit que se recibe es el bit 0, si la carga serie se hace por el bit ms significativo del registro y se hacen desplazar los bits hacia la derecha [bit n bit (n1)], enelltimodesplazamiento,elbit0recibidoestarenelbit0delregistro,yestarntodos los bits ordenados. La carga y el desplazamiento se realizan bajo la orden de la seal desplazaoriginadaenelbloquecontrol
7.7.2. Registro de entrada

Laentradadelacomunicacinseriefpga_rxseregistraenfpga_rx_rg(mduloRegIndela figura7.47).Comofpga_rxesunasealasncronaesconvenienteregistrarla,yparaevitar metaestabilidad se puede incluso registrar dos veces poniendo dos registros en cascada (recuerdalafigura2.11).
7.7.3. Divisor de frecuencia

Para el receptor, el divisor de frecuencia debe sincronizarse con la trama que se recibe. Esto esas porque el receptor no dirige la transmisin, como suceda con el transmisor. El divisor de frecuencia se mantiene inactivo con la cuenta a cero hasta que la entrada en_divfreqseponea1.Eldivisor defrecuenciasacadosseales:baudybaud_medio.baud marca la transicin del estado, y baud_medio marca el punto medio de cada bit de la transmisin. En este punto medio es donde se evala el valor del bit recibido, evitando evaluar el bit cerca de las transiciones donde se puede tomar el valor del bit contiguo. Estoessimilaraloquehicimosconelreceptorparasimulacin,recuerdalafigura7.24.
131
En la figura 7.48 se muestra el cronograma del divisor de frecuencia con una cuenta de ejemplo de 20 (en realidad la cuenta es mucho ms larga, y viene indicado por la constantec_cont_baud calculadaenelcdigo7.2).
comienzo de nueva recepcin reposo fpga_rx_rg cuenta baud baud_medio en_divfreq
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2
bit inicio
bit 0 del dato
bit 1 ...
nos situamos en el medio para leer el valor
Figura 7.48: Cronograma del divisor de frecuencia
7.7.4. Bloque de control

El bloque de control es una mquina de estados similar a la del transmisor (apartado 7.4.2). El cambio de estado tambin viene provocado por baud. La orden de desplazamiento (desplaza) se dar cuando se est en el estado de recepcin de dato (e_bits_dato)yllegalasealbaud_medio.
7.8. Banco de pruebas del receptor de la UART

Para hacer un banco de pruebas tenemos que crear un modelo de simulacin de las entradas. En el caso del receptor, slo tenemos tres entradas (figura 7.45), siendo dos de ellaselrelojyelreset.Laotraentradaeselpuertofpga_rx,quesecorrespondeconeldato serie que se recibe con el protocolo RS232. Por tanto, para realizar el banco de pruebas tendramos que realizar un proceso de simulacin que modelase un envo RS232. Habra quecontarlostiemposdecadabit,yenviarelbitdeinicio,los8bitsdeldato,elbitdefin y finalmente poner la lnea en reposo. Con todo lo que hemos visto sobre el protocolo RS232 y sobre simulacin, no deberas de tener muchas dificultades para realizar un banco de pruebas de este tipo. La figura 7.49 muestra un esquema de cmo podramos hacer el banco de pruebas del receptor. Observa que es similar a banco de pruebas del transmisor7.22.
Observar las salidas o crear un proceso que las verifique automticamente 8 aviso_rx recibiendo fpga_rx UUT: UART_RX dato_rx_out
P_Transmisor
P_Clk
Proceso que modela el reloj clk rst Proceso que modela el transmisor generando tramas serie con formato RS-232
P_Reset
Figura 7.49: Esquema del banco de pruebas del receptor, que incluye un proceso que modela el transmisor descrito a alto nivel
132
Otra opcin para el banco de pruebas es utilizar el transmisor que ya hemos realizado y su banco de pruebas para generar la trama RS232. Con esto nos ahorraramos realizar el modelo de alto nivel del transmisor que genera la trama RS232. Como ya hemos comprobado que el transmisor funciona, en este banco de pruebas slo estaramos probando el receptor, que es lo que queremos probar. La figura 7.50 muestra el esquema de este banco de pruebas. La ventaja de hacer este banco de pruebas es que tardamos menos en disearlo, la desventaja es que la simulacin ser ms lenta porque el modelo deltransmisoresmscomplejoquesifueseunmodeloparasimulacin.
Observar las salidas o crear un proceso que las verifique automticamente 8 aviso_rx recibiendo clk rst Proceso que modela las entradas al circuito fpga_rx UUT: UART_RX dato_rx_out Este es el componente que estamos probando
P_Clk
P_Estmulos
8
TX: UART_TX dato_tx_in transmite transmitiendo clk rst
P_Clk
Proceso que modela el reloj
fpga_tx
P_Reset
Este componente ya est probado
Figura 7.50: Esquema del banco de pruebas del receptor, que incluye el transmisor sintetizable
Ahora, elige uno de los dos bancos de pruebas y comprueba que las salidas dato_rx_out, aviso_rx y recibiendo son correctas. Probablemente no te salga bien a la primera y tendrs que analizar las seales y estados internos del receptor. Realiza esto por ti mismo para afianzar el anlisis de la simulacin explicado en el apartado 7.5. Consulta este apartadosinosabescmoprocederalacomprobacindelasformasdeondas.
7.9. Implementacin de la UART completa

Si has probado el receptor, ahora lo podrs unir con el transistor e implementarlos juntos en un slo diseo. Vamos a realizar un diseo que transmita lo recibido por el receptor, consiguindose un eco en el hiperterminal. Para ello, cada vez que se reciba un dato por el receptor tendramos que dar la orden de transmitir. Podemos utilizar el puerto aviso_rx del receptor para dar la orden al transmisor por el puerto transmite, puesto que ambas funcionan con un ciclo de reloj. Adems, cuando aviso_rx est activo, el dato est disponibleendato_rx_out,porloquenohabraquehacernadamsqueconectarloscomo muestralafigura7.51.
133
UART_ECO RX: UART_RX dato_rx_out aviso_rx recibiendo clk rst fpga_rx del exterior (computadora) FPGA_RX Pines: AJ8 (XUPV2P) U6 (Nexys2)
TX: UART_TX
8
dato_tx_in transmite transmitiendo fpga_tx
hacia el exterior (computadora) FPGA_TX Pines: AE7 (XUPV2P) P9 (Nexys2)
clk rst
clk rst
Figura 7.51: Circuito que transmite lo que recibe con protocolo RS-232
Implementas el diseo y observa si tienes eco. Ten en cuenta que los hiperterminales normalmente no tienen eco, esto es, no muestran lo que escribes (a no ser que lo configures), por tanto si ests viendo lo que escribes, probablemente lo tengas bien. PruebaaescribirsinelcableconectadooconlaFPGAdesprogramadaaversiveseco. Si obtienes caracteres distintos a los que has enviado, revisa la configuracin del hiperterminal.Sinotesalebien,compruebalospasosdelapartado7.6.4orealizaunbanco depruebasdelcircuitocompleto.
134
8. Circuitos aritmticos
En esta prctica se introducir el diseo de mdulos aritmticos en VHDL. La implementacin de este tipo de mdulos es de mucha utilidad, ya que una de las aplicaciones de los dispositivos programables como las FPGA es acelerar el cmputo. Sin embargo, para la implementacin de la mayora de las operaciones matemticas necesitamos describir cmo es el hardware. Es decir, no podremos utilizar el operador de divisin entre dos seales enteras, sino que tendremos describir cmo es el hardware que implementa la divisin. Otras operaciones ms sencillas como la suma, la resta y, a veces la multiplicacin entera, habitualmente las implementa el sintetizador. As que aunque para estas operaciones normalmente no tenemos que describir cmo se implementa en hardware,esimportantesaberentendercmofuncionanparaevitarerroresdediseo49. Debemos ser cuidadosos al implementar las operaciones matemticas en VHDL. Por un lado se deben elegir los tipos numricos correctamente y establecer operaciones consistentes entre las seales y variables. Por otro lado, como ya se ha dicho, se debe tener en cuenta que operaciones complejas como la divisin no son inmediatas en hardwareynormalmentesedebeespecificarqualgoritmolarealizar. Esimportantequenoolvidemosquelassealesdeuncircuito(hardware)nosonmsque un grupo de cables elctricos. Haciendo una abstraccin hemos agrupado y ordenado estos cables, considerando que forman una seal con un nmero determinado de bits. Y que incluso hemos determinado que esa seal es de un tipo numrico determinado. As queaunquedigamosqueunasealesdetipoenteroconsigno,tenemosquerecordarque esasealnoesmsqueungrupodecablesalqueledamosunsignificado. El tipo de datos que habitualmente hemos usado para vectores es std_logic_vector. Para estetipodedatoselVHDLnotieneimplementadosoperadoresaritmticos50.Porejemplo, si queremos realizar una suma de seales std_logic_vector debemos implementar nosotros el sumador. Esto tiene sentido, ya que con el tipo std_logic_vector no se especifica qu nmero representa, es decir no sabemos si se corresponde con un binario puro,ositienesigno,yenesecaso,siselarepresentacinesencomplementoados,signo magnitud, ... Sin embargo, si usamos vectores de tipo unsigned signed ya estamos especificando la representacin y el sintetizador podr implementar algunas operaciones pornosotros. En este captulo veremos los paquetes matemticos necesarios para implementar las operaciones. Posteriormente veremos cmo trabajar con los tipos unsigned y signed para realizar operaciones de suma y resta. A continuacin vermos cmo describir una multiplicacin entera y analizaremos con cierto detalle las ventajas e inconvenientes de algunas implementaciones. Por ltimo se introducir cmo se podra implementar la operacindeladivisinentera.
49
Enlareferencia[19mach]seexplicacmodescribirelhardwaredesumadoresyrestadoresusando esquemticos. Estodependedelpaquete.Elpaquetenumeric_stdnolaspermite,peroelpaquete std_logic_unsignedslaspermite,aunqueestopuedellevaraerror.Poreso,comoveremos,se recomiendaelpaquetenumeric_std.
50
135
8.1. Paquetes matemticos

Para usar los tipos unsigned y signed debemos usar ciertos paquetes (packages) que definenestostiposylasoperaciones.Existendospaquetesqueimplementanestostiposel IEEE.NUMERIC_STD y el IEEE.STD_LOGIC_ARITH. El primero es estndar y su uso est ms recomendado51, aunque ambos se pueden utilizar. As pues, cambiaremos la cabecera de nuestroficheroacomosemuestraenelcdigo8.1:
library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.NUMERIC_STD.ALL; -- usaremos este
Cdigo 8.1: Llamada al paquete numeric_std, recomendado
YquitaremoslasqueXilinxponepordefecto:
library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; -- esta no usaremos -- esta no usaremos
Cdigo 8.2: Llamada a los paquetes std_logic_arith y std_logic_unsigned, no recomendado, usaremos el del cdigo 8.1
De todas maneras es correcto usar ambos paquetes, pero s es importante que todos los mdulos de tu diseo usen los mismos paquetes y no mezclar numeric_std con std_logic_arith. Siquieresecharunvistazoaestospaquetes,suelenestareneldirectoriodeinstalacinde Xilinx, probablemente lo encontrars en C:\Xilinx92i\vhdl\src\ieee. All estn todos los ficheros .vhd de los paquetes. Dentro de ellos puedes mirar las declaraciones de las funciones,tipos,constantes,...ElVHDLdeestospaquetespuedeserunpococomplicado. Ten cuidado de no modificar estos ficheros, si los vas a ver a menudo, cpialos en otro directorio.Detodosmodosestosficherossonfcilesdeencontrareninternet.
8.2. Tipos unsigned y signed

Ya hemos trabajado con los tipos unsigned y signed (apartado 4.2 y captulo 6 de la referencia [17mach]). A diferencia de los integer que son datos escalares, los signed y unsignedsonvectores,cuyoselementosrepresentanlosbitsdelaseal. El uso de estos tipos se recomienda frente al uso de enteros. Aunque parezca ms fcil utilizar los tipos enteros, el uso de stos puede hacer que cometamos errores. Por otro lado, el uso de tipos vectoriales nos facilita la descripcin de muchas operaciones habituales en los circuitos digitales, como por ejemplo el desplazamiento, el uso de mscaras o la asignacin de bits concretos. Adems, nos da una visin ms prxima al hardware que estamos describiendo, ya que cada elemento del vector se corresponde con uncabledelcircuito. Una seal de tipo unsigned representa un nmero entero sin signo, por tanto se corresponde con un nmero entero en binario puro. Mientras que una seal de tipo signedrepresentaunnmeroenteroconsignorepresentadoencomplementoados.
51
Elusodelpaquetestd_logic_arith puededarlugaraambigedadesyerrores.Siquieresprofundizar consultaelsiguienteenlace: http://www.synthworks.com/papers/vhdl_math_tricks_mapld_2003.pdf
136
Enlossiguientesejemplos,parafacilitarlaidentificacindelostiposdesealesusaremos lassiguientesterminacionesenlosnombresdelasseales:
_us: _s: _slv: _sl:
sealesdetipounsigned sealesdetiposigned sealesdetipostd_logic_vector sealesdetipostd_logic sealesdetipointegerconrangopositivoynegativo(consigno)
_int_ps: sealesdetipointegerconrangopositivo(sinsigno) _int:
Opcionalmente, cuando sea de utilidad, al final del nombre se aadir un nmero que indicarelnmerodebitsdelaseal.As,lasealsenal_slv3,seraunstd_logic_vector de3bits(rangode2a0). Siguiendo esta notacin, en el cdigo 8.3 muestra la declaracin de tres seales: unsigned, signedystd_logic_vector. En las ltimas sentencias del cdigo se muestra cmo asignando los mismos bits los valores representados son distintos segn el tipo de datos. En el caso de la seal de tipo std_logic_vector,stanodeberaderepresentarningnnumero,yaspasasiseutilizael paquete numeric_std (cdigo 8.1). Sin embargo, si se usa el paquete std_logic_arith (cdigo 8.2) se considera que es un nmero sin signo, y esto puede llevar a error si no lo tienes en cuenta. Por esto no se recomienda el uso de los paquetes std_logic_arith y std_logic_unsigned(cdigo8.2).
signal senal_us3 : unsigned (2 downto 0); signal senal_s3 : signed (2 downto 0); signal senal_slv3 : std_logic_vector (2 downto 0); ... begin senal_us3 <= "111"; -- representa 7 en decimal senal_s3 <= "111"; -- representa -1 en decimal senal_slv3 <= "111"; -- no representa un numero, aunque si se usa el -- paquete STD_LOGIC_UNSIGNED es 7
Cdigo 8.3: Comparacin entre tipos unsigned, signed y std_logic_vector
Acontinuacinveremosrealizarconversionesentrelostiposnumricos.
8.3. Conversin de tipos numricos

Paraconvertirlostiposdedatosseusancastyfuncionesdeconversin.
8.3.1. Asignacin de bits

Como muestra el cdigo 8.4, los elementos (bits) de los unsigned signed y std_logic_vectorsepuedenasignarautomticamenteentreellosyastd_logic.
signal senal_sl : std_logic; signal senal_slv : std_logic_vector (c_nbits-1 downto 0); signal senal_us : unsigned (c_nbits-1 downto 0); signal senal_s : signed (c_nbits-1 downto 0); ... begin senal_sl <= senal_us(2); -- elemento (bit) de unsigned a std_logic senal_slv(0) <= senal_s(1); -- bit de signed a bit de std_logic senal_us(1) <= senal_slv(0); -- bit de std_logic_vector a bit de unsigned senal_s(2) <= senal_us(1); -- bit de unsigned a bit de signed
Cdigo 8.4: Conversin directa entre elementos (bits) de vectores y con std_logic
137
8.3.2. Conversiones
Las conversiones entre tipos unsigned y signed al tipo std_logic_vector se debe usar un cast.Lassealesdebentenerelmismorango.
signal senal_sl : std_logic; signal senal_slv : std_logic_vector (c_bits-1 downto 0); signal senal_us : unsigned (c_bits-1 downto 0); signal senal_s : signed (c_bits-1 downto 0); ... begin senal_slv <= std_logic_vector(senal_us); -- de unsigned a std_logic_vector senal_slv <= std_logic_vector(senal_s); -- de signed a std_logic_vector senal_s <= signed (senal_slv); -- de std_logic_vector a signed senal_us <= unsigned (senal_slv); -- de std_logic_vector a unsigned
Cdigo 8.5: Conversin cast entre signed y unsigned con std_logic_vector (del mismo rango)
Paraconvertirsignedyunsignedainteger,sedebenusarfuncionesdeconversin:
signal senal_int_ps : integer range 0 to 255; signal senal_int : integer range -128 to 127; signal senal_us8 : unsigned (7 downto 0); signal senal_s8 : signed (7 downto 0); ... begin senal_int_ps <= TO_INTEGER (senal_us8); -- de unsigned a entero sin signo senal_int <= TO_INTEGER (senal_s8); -- de signed a entero con signo -- de entero sin signo a unsigned, 8: indica el n bits: senal_us8 <= TO_UNSIGNED(senal_int_ps,8); -- de entero con signo a signed, 8: indica el n bits: senal_s8 <= TO_SIGNED (senal_int,8);
Cdigo 8.6: Funciones de conversin entre signed y unsigned a integer, usando el paquete
numeric_std
Si se usa el paquete std_logic_arith las funciones de conversin son conv_integer, conv_signed y conv_unsigned, en vez de to_integer, to_signed y to_unsigned respectivamente. La diferencia entre las asignaciones del cdigo 8.5 con las del cdigo 8.6 es que en las primeras se realiza un cast y en las segundas se utiliza una funcin de conversin que estnenlospaquetes. Por un lado el cast es una reinterpretacin del significado de la seal, pero la seal mantiene el mismo nmero de bits y el mismo formato. En el ejemplo del cdigo 8.5, lo que antes era un vector de 8 bits sin ningn significado numrico pasa a ser un nmero codificado en binario con signo o sin signo segn usemos el cast signed o unsigned. O la conversin contraria, un nmero binario que pasa a ser considerado un vector de 8 bits sininterpretacinnumrica. Por otro lado la conversin (cdigo 8.6) suele implicar un cambio en el formato del dato. En el ejemplo se realizan conversiones entre nmeros escalares (integer) y nmeros vectoriales(signedyunsigned). Para convertir de std_logic_vector a entero se requieren dos pasos. Primero se debe realizarprimerouncastasignedounsignedyluegounaconversinaentero.Pararealizar la conversin contraria, se convierte primero el entero a signed o unsigned y luego se realiza el cast a std_logic_vector. En el cdigo 8.7 se muestran ejemplos de estas conversiones. Se ha omitido la declaracin de la mayora de las seales, pues se corresponderanconlasdelcdigo8.6.
138
signal senal_slv8 : std_logic_vector (7 downto 0); ... begin -- de std_logic_vector a entero sin signo: senal_int_ps <= TO_INTEGER(unsigned(senal_slv8)); -- de std_logic_vector a entero con signo: senal_int <= TO_INTEGER(signed(senal_slv8)); -- de entero sin signo a std_logic_vector: senal_slv8 <= std_logic_vector(TO_UNSIGNED(senal_int_ps,8)); -- de entero sin signo a std_logic_vector: senal_slv8 <= std_logic_vector(TO_SIGNED(senal_int,8));
Cdigo 8.7: Conversin entre integer y std_logic_vector
8.4. Uso de constantes numricas

No podremos asignar directamente una constante decimal a un signed o unsigned, aunque s podemos comparar, o utilizarlos si interviene en una operacin (por ejemplo unasuma).Elcdigo8.8muestraunamaneraderealizarasignacindeconstantes.
signal sa_us8, sb_us8, sc_us8 : unsigned (7 downto 0); ... begin -- No se puede asignar la constante 5 directamente -- sa_us8 <= 5; --> esto no se puede sa_us8 <= TO_UNSIGNED(5,8); -- Las constantes se pueden usar con otras operaciones sb_us8 <= sa_us8 + 5; -- Las constantes se pueden usar con comparaciones sc_us8 <= TO_UNSIGNED(5,8) when (sb_us8 = 5) else TO_UNSIGNED(1,8);
Cdigo 8.8: Asignacin de constantes a un unsigned y uso de constantes en operaciones
8.5. Suma de nmeros positivos

Para realizar una sumatenemos que considerar el rango delos operandos y elacarreo. Es interesante adems que recuerdes cmo se realiza un sumador con esquemticos [19mach]. Enesteapartadoveremoscmosumarnmerossinsigno(unsigned),lasumadenmeros consignoseverenelapartadosiguientequesedescribelaresta. EnVHDL,lasumadossealesunsigneddelmismorangodacomoresultadoununsigned delmismorango.Porconsiguiente,sinolotenemosencuenta,perderemoselacarreo.En elcdigo8.9semuestraesteejemplo.
signal sa_us4, sb_us4, resul_us4 : unsigned (3 downto 0); ... begin -- Suma sin acarreo: resul_us4 <= sa_us4 + sb_us4;
Cdigo 8.9: Suma de tipos unsigned sin considerar el acarreo
Como la suma del cdigo 8.9 no tiene en cuenta el acarreo nos puede llevar a resultados errneos.Parasolucionarlotenemosquedosopciones:

Aumentarenunoelrangodelresultado Avisardequehahabidoundesbordamiento(overflow)
En el ejemplo del cdigo 8.9, como los sumandos tienen 4 bits, el resultado de la suma tendrcomomximo5bits(verfigura8.1).Estaeslareglageneralparacualquiernmero debits,elresultadotendrcomomximounbitmsquelosoperandos.
139
1111 +1111 11110
1510 1510 3010
No representable con 4 bits Representable con 5 bits
Desbordamiento
Figura 8.1: Desbordamiento en la suma de nmeros sin signo
Sin embargo no basta con asignar el resultado a un unsigned de 5 bits. El cdigo 8.10 muestraunamaneraerrneadeintentarsolucionarelproblema.
signal sa_us4, sb_us4 : unsigned (3 downto 0); signal resul_us5 : unsigned (4 downto 0); ... begin resul_us5 <= sa_us4 + sb_us4; -- MAL
Cdigo 8.10: Suma de tipos unsigned considerando el acarreo de manera errnea
Hay que tener cuidado con descripciones como la del cdigo 8.10 pues a veces las herramientas de diseo no la consideran errnea. Por ejemplo, la versin que usamos del ISE slo da una advertencia (warning52) y pone directamente a cero el bit 4 del resultado. Esto hara que nuestro diseo no funcionase como esperamos. Por eso es importante leer lasadvertenciasdelISEysimularelcircuito. Para incluir el acarreo en el resultado podemos concatenar un cero a la izquierda de los sumandos.Deestamaneralossumandostendrn5bitsyproporcionarnunresultadode 5bits.Paraconcatenarseutilizaeloperador&. Enelcdigo8.11semuestracmoconsiderarlosacarreos.Ladeclaracindelassealeses lamismaqueladelcdigo8.10
resul_us5 <= ('0' & sa_us4) + ('0' & sb_us4);
Cdigo 8.11: Suma considerando el acarreo de tipos unsigned
Sin embargo, no siempre podemos aumentar el tamao del resultado. En este caso tendremos que avisar si ha habido desbordamiento. Lo podremos hacer extrayendo los cuatro primeros bits del resultado, y dejando el bit ms significativo como seal de desbordamiento(ov).
signal sa_us4, sb_us4, resul_us4 : unsigned (3 downto 0); signal resul_us5 : unsigned (4 downto 0); signal ov : std_logic; -- aviso de desbordamiento (overflow) ... begin resul_us5 <= ('0' & sa_us4) + ('0' & sb_us4); -- resultado interno resul_us4 <= resul_us5(3 downto 0); -- resultado de 4 bits ov <= resul_us5(4); -- senal de desbordamiento
Cdigo 8.12: Suma de unsigned con aviso de desbordamiento
Observa en el cdigo 8.12 que trabajar con tipos vectoriales como unsigned permite extraer de manera sencilla el desbordamiento (ov). Si utilizsemos tipos escalares sera ms complicado y no tendramos el mismo control sobre los desbordamientos y el nmerodebitsqueestamosutilizandoencadaoperacin.
8.5.1. Informe de sntesis

Es interesante mirar los informes de la sntesis del ISE, en stos se muestran los sumadores que se han generado y el nmero de bits del sumador. Para ver el informe de sntesis, dentro de la subventana Processes, pincha en Synthesize - XSTView Synthesis
52
Elwarningquedadiceas:Widthmismatch.<resul_us5>hasawidthof5bitsbutassignedexpressionis4bitwide.
140
Report. En la ventana de la derecha aparecer el informe, donde puedes buscar el nmero
de sumadores/restadores que se han creado y el nmero de bits de cada uno de ellos. En lafigura8.2semuestraunapartedelinformeparaelsumadordelcdigo8.11.Vemosque sehacreadounsumadorde5bits,queesloquequeramosparaconsiderarelacarreo.
Sumador de 5 bits
Synthesize Sy nthesize - XST View Synthesis Report
Figura 8.2: Informe de sntesis
En general es interesante echarle un vistazo al informe de sntesis, en donde se muestra msinformacin,comoelnmerodeLUTs53utilizadasyestimacionestemporales. Hay otras formas de acceder al informe de sntesis, por ejemplo accediendo al resumen deldiseo54(Design Summary)ydesdeallpuedespincharenelSynthesis Report.
8.5.2. Esquema RTL

Una vez realizada la sntesis podemos ver el esquema RTL del circuito resultante. Para ello pinchamos en Synthesize - XSTView RTL Schematic. Aparecer una caja representandoalcircuitoconsuspuertosdeentradaysalida(figura8.3).
53 54
LUT:LookUpTable,tablasdeconsultaqueenlasFPGAsseutilizanparaimplementarlasfuncioneslgicas Recuerdalospasos1y2delafigura7.35
141
Doble click dentro del circuito
Figura 8.3: Esquema RTL
Haciendodobleclickdentrodelacajaveremoselesquemadelsumador(figura8.4). Pinchandoenloselementosdelesquemasemuestrainformacinenlasventanasdeabajo. De esta manera se pueden identificar las seales y ver cmo se ha sintetizado nuestro diseo. Para circuitos muy grandes se requiere paciencia por la gran cantidad de elementosquepuedellegarahaber.
Figura 8.4: Esquema RTL del sumador
En circuitos estructurales se podr pinchar en las cajas que habr dentro de cada circuito. Para volver a los circuitos de mayor jerarqua basta con hacer doble click fuera del circuito.
142
8.6. Resta de nmeros positivos

En este apartado veremos cmo hacer la resta de nmeros positivos, considerando el resultadocomonmeropositivo(magnitudomdulo)yteniendounasealdeunbitque indicarelsigno.Estoesequivalentealarepresentacinensignoymagnitud. Si queremos realizar una resta de nmeros positivos y queremos obtener el resultado como nmero positivo, tenemos que poner como minuendo el nmero mayor y como sustraendo el menor. Por lo tanto, antes de realizar la resta tendremos que comparar y realizar las asignaciones correspondientes segn quin sea el mayor. Si hemos tenido que intercambiarminuendoporsustraendodeberemosavisarqueelresultadoesnegativo. Este circuito se podra describir como muestra el cdigo 8.13. Como ya sabemos, existen muchas alternativas equivalentes para describir este circuito, por ejemplo, usando procesos,otrassealesintermedias,...
entity restapositiva is Port ( p_minuen_us : in unsigned (3 downto 0); -- Minuendo p_sustr_us : in unsigned (3 downto 0); -- Sustraendo p_resta_us : out unsigned (3 downto 0); -- Resta -- si es 1 indica que el resultado es negativo minuendo < sustraendo p_dif_negativa : out std_logic ); end restapositiva; architecture behavioral of restapositiva is signal dif_negativa : std_logic; begin -- si el sustraendo es mayor que el minuendo la diferencia sera negativa dif_negativa <= '0' when (p_minuen_us >= p_sustr_us) else '1'; p_resta_us <= (p_minuen_us - p_sustr_us) when dif_negativa = '0' else (p_sustr_us - p_minuen_us); p_dif_negativa <= dif_negativa; end behavioral;
Cdigo 8.13: Resta de nmeros positivos
Como la resta de nmeros positivos en la que el minuendo es el mayor est acotadaentre elvalordelminuendoycero,enestecasonotendremosdesbordamiento.
8.7. Suma y resta de nmeros enteros

Para sumar y restar nmeros enteros podemos combinar los apartados anteriores de modo que siempre sumemos o restemos nmeros positivos y calculemos el signo del resultado.Paraestoesnecesariorealizarunassencillascomprobacionesdelossignosylas magnitudes de los operandos. Esta sera la manera de operar con nmeros representados consignoymagnitud. Otra alternativa, ms utilizada en los circuitos digitales, es operar en complemento a dos. El complemento a dos permite operar nmeros positivos y negativos sin preocuparnos si tienendistintosigno.Asqueevitamoshacerlascomprobacionesquesehacenconsignoy magnitud. En el apartado 8.7.3 se ha incluido un pequeo repaso de los nmeros en complemento a dos. En la referencia [19mach] se explica cmo se realiza un sumador/restadordenmerosencomplementoadosusandoesquemticos. En VHDL, los nmeros en complemento a dos los podemos declarar como un signed. Para realizar la suma o la resta slo nos tenemos que preocupar de los rangos y del
143
desbordamiento. Los desbordamientos en las operaciones en complemento a dos son distintosquelosproducidosconnmerossinsigno(recuerdalafigura8.1). En la suma, el desbordamiento se produce cuando los dos sumandos tienen el mismo signo y el resultado tiene un signo distinto. Esto est explicado en la figura 8.5 del apartado8.7.3. Con esto ya tenemos la informacin necesaria para describir el sumador de nmeros enteros. El cdigo 8.14 muestra una posible implementacin del circuito, que incluye el avisodedesbordamiento.
entity sumaentera is Port ( p_sum1_s : in signed p_sum2_s : in signed p_resul_s : out signed p_ov : out std_logic -); end sumaentera; (3 downto 0); (3 downto 0); (3 downto 0); p_ov='1' -> desbordamiento
architecture behavioral of sumaentera is signal resul_s : signed (3 downto 0); begin resul_s <= p_sum1_s + p_sum2_s; -- calculo del desbordamiento: resultado con distinto signo que los 2 sumandos p_ov <= ( p_sum1_s(3) and p_sum2_s(3) and not(resul_s(3))) or (not(p_sum1_s(3)) and not(p_sum2_s(3)) and resul_s(3) ); p_resul_s <= resul_s; end behavioral;
Cdigo 8.14: Suma de nmeros enteros
En complemento a dos, la resta no es ms que una suma en la que se cambia el signo del sustraendo55. Para describir una resta en VHDL, simplemente ponemos la operacin de la restaycalculamoseldesbordamientoconsecuentemente,esdecir,negandoelsustraendo.. Elcdigo8.15muestralassentenciasquecambiaranrespectoalasuma(cdigo8.14).
... resul_s <= p_sum1_s - p_sum2_s; -- calculo del desbordamiento: resultado con distinto signo que los 2 sumandos p_ov <= ( p_sum1_s(3) and not(p_sum2_s(3)) and not(resul_s(3))) or (not(p_sum1_s(3)) and p_sum2_s(3) and resul_s(3) );
Cdigo 8.15: Resta de nmeros enteros
8.7.1. Aumento del rango de la suma en complemento a dos

La suma56 de nmeros enteros puede desbordarse (figura 8.5). Igual que en el caso de la sumadenmerospositivos(apartado8.5),sinoqueremostenerdesbordamientotenemos queaumentarelrangodelresultadoenunbit.Enelcdigo8.11vimoscmoresolveresta situacin para los nmeros positivos. En esta solucin concatenbamos un cero a la izquierdadecadasumando. Sin embargo, con nmeros enteros en complemento a dos no podemos hacer lo mismo porque estaramos cambiando el signo de los nmeros negativos. Por ejemplo, si tenemos el nmero 1101 (3) y le concatenamos un cero a la izquierda lo convertiremos en 01101, quenosloahoraesunnmeropositivosinoquelohemosconvertidoenelnmero13.
55
Recuerdaqueenlarepresentacinencomplementoados,cambiarelsignodeunnmeroescalcularsu complementoados Ylaresta,quecomoyahemosdichonoesmsqueunasumacambiandoelsignodelsustraendo
56
144
La solucin es concatenar un cero a la izquierda si el nmero es positivo y un uno si es el nmero es negativo. Es decir, concatenar con el valor del bit ms significativo, que es el bit que indica el signo. As, por ejemplo, si tenemos 0010 (2), obtendremos 00010, que siguesiendoel2.Ysitenemos1110(2),obtendremos11110,quesiguesiendoel2. Porlotanto,laadaptacindelcdigo8.11anmerosenterossemuestraenelcdigo8.16.
resul_s5 <= (sa_s4(3) & sum1_s4) + (sb_s4(3) & sum2_s4);
Cdigo 8.16: Suma de tipos signed considerando el acarreo
8.7.2. Aumento del rango usando funciones y atributos *

Una alternativa al cdigo 8.16 es usar la funcin resize. La funcin resize se encarga de redimensionar los vectores signed y unsigned. Esta funcin est en el paquete numeric_std,porloquenolapodrsutilizarsiestasusandolospaquetesstd_logic_arith ystd_logic_unsigned(recuerdaelapartado8.1). Conestafuncinelcdigo8.16quedaracomomuestraelcdigo8.17.
resul_s5 <= resize(sum1_s4, 5) + resize(sum2_s4, 5)
Cdigo 8.17: Suma de tipos signed considerando el acarreo y utilizando la funcin resize
En el primer argumento de la funcin resize se pone el vector signed o unsigned, y en el segundo argumento se pone el nmero de bits a los que se quiere redimensionar. La funcinresizeredimensionarelvectoradecuadamentedependiendodeltipoydelsigno delvector. Sin embargo podemos observar que realmente no hay mucha diferencia entre los cdigos 8.17y8.16.Aunqueencasoqueelcambioseademuchosbitselcdigo8.17sermsclaro y conciso. Por otro lado, resize es tanto para signed como para unsigned. Si lo hacemos nosotros, tendremos que elegir entre el cdigo 8.16 y el cdigo 8.10, segn sea signed o unsigned. Pero el cdigo 8.17 se puede optimizar, en vez de usar directamente el nmero de bits a los que queremos convertir los sumandos (5 en el ejemplo), podemos usar el atributo length, que nos devuelve el nmero de bits (longitud) de una seal. As, la expresin resul_s5'length nosdevolverelnmerodebitsdelasealresul_s5,quees5. Aunque no los hemos nombrado hasta ahora, los atributos en VHDL se utilizan bastante. Porejemplo,nosotrosyahemosutilizadoelatributoeventparalaexpresareleventodela sealdereloj:clk'event(recuerdaporejemploelapartado2.6). Los atributos se ponen con un apstrofe a continuacin de la seal. Hay muchos tipos de atributos, pero no todos son sintetizables o no son aceptados por las herramientas de diseo.Asqueantesdeutilizarlosdebescomprobarquenohayproblemaconellos. Utilizandoelatributolength,elcdigo8.17quedar:
resul_s5 <= resize(sum1_s4, resul_s5'length) + resize(sum2_s4, resul_s5'length);
Cdigo 8.18: Suma de tipos signed considerando el acarreo y utilizando la funcin resize con el atributo
length
Describiendo el sumador de esta manera no lo hacemos depender de un valor numrico, como lo era el 3 en el cdigo 8.16 el 5 en el cdigo 8.17. Esto tiene muchas ventajas, ya que si queremos cambiar el nmero de bits del sumador ya sea para reutilizarlo o porque hayan cambiado las especificaciones, no necesitamos cambiar el valor numrico, sino que
145
se hace automticamente al cambiar el rango de las seales en su declaracin. Esto nos podrahorrarerroresdeedicinespecialmenteencircuitosgrandes.
8.7.3. Breve repaso del complemento a dos *

En este apartado se hace un pequeo recordatorio de la representacin de nmeros en complemento a dos. En la tabla 8.1 se muestra la equivalencia de los nmeros en compelementoadosdecuatrobits.
decimal C2 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 1000 1001 1010 1011 1100 1101 1110 1111 0000 0001 0010 0011 0100 0101 0110 0111
Tabla 8.1: Nmeros en complemento a dos de 4 bits y su correspondiente decimal
Los nmeros positivos (y el cero) representados en complemento a dos siempre tienen un cero en el bit ms significativo. Como se ve en la tabla 8.1 los nmeros positivos en complementoadossecorrespondenconlosbinariospuros. Los nmeros negativos tienen un uno en el bit ms significativo. Para saber con qu nmerosecorrespondenseinviertenloscerosporunosylosunosporcerosyalresultado selesumauno. Porejemplo,sitenemosel1011.

Vemosqueesunnmeronegativoporquetieneununoenelbitmssignificativo. Invertimoscerosporunosyunosporceros:0100 Sumamosuno(0100+0001) =0101,queeselnmero5enbinario Porlotanto,1011eselnmero5
Esta operacin es la misma para hallar el complemento a dos de cualquier nmero (negarlo). En la suma de nmeros en complemento a dos el desbordamiento se produce cuando los dos sumandos tienen el mismo signo y el resultado tiene un signo distinto. La figura 8.5 muestraconejemploscundoseproducedesbordamiento.
146
No desborda
-7 +5 -2 -2
No desborda
0000 +1111 1111
010 +(-1)10 -110 Representable

iguales
1001 +0101 1110
-110 Sumandos con signos diferentes: No habr desbordamientoBien
Es representable en Ca2 de 4 bits iguales
Sumandos con signos diferentes: No habr desbordamientoBien
=
4 +2 6
No desborda
No desborda
Representable en Ca2 de 4 bits iguales
0100 +0010 0110
6 Sin cambio de signo Bien
Es representable en Ca2 de 4 bits iguales
1001 +1111 1 1000
-7 +(-1) -8
-8 Sin cambio de signo Bien se ignora el acarreo
1000 en Ca2 representa a
=
6 +5 11
Desborda
Desborda
0110 +0101 1010
No representable en Ca2 de 4 bits distintos
1000 +1111 10111
-8 +(-1) -9
-6 Cambio de signodesbordamiento
al estar en Ca2 representa a
7 Cambio de signodesbordamiento
al estar en Ca2 representa a
No representable en Ca2 de 4 bits distintos
Figura 8.5: Ejemplos de los casos de desbordamiento en la suma en complemento a dos
Para la resta, es equivalente que la suma pero habiendo cambiado previamente el signo delsustraendo.
8.8. Multiplicacin
ElsintetizadordelISEimplementalamultiplicacindedosnmerosenteros.Elresultado de la multiplicacin tendr tantos bits como la suma del nmero de bits de los productos. Elcdigo8.19muestracmosedescribeunamultiplicacindenmerosenterossinsigno.
... signal fact1_us4, fact2_us4 : unsigned (3 downto 0); signal prod_us8 : unsigned (7 downto 0); begin prod_us8 <= fact1_us4 * fact2_us4; ...
Cdigo 8.19: Producto de dos unsigned produce un unsigned con un nmero de bits resultado de la suma del nmero de bits de los factores
Las FPGA que usamos llevan integrados multiplicadores, por tanto, las operaciones de multiplicacin entera quedan eficientemente implementadas automticamente. Sin embargo, puede ser que necesitemos implementar ms multiplicadores que los que tiene laFPGA.LaFPGAdelaXUPV2Ptiene136,ladelaNexys2tiene20yladelaBasystiene4. Esto lo puedes ver en el informe de sntesis, que indica el nmero de multiplicadores totalesyusados.Enelcasoenelquesenecesitenmsmultiplicadoresquelosquetienela FPGA,elsintetizadorlosimplementarconlgicacombinacional. En el caso en el que uno de los factores de la multiplicacin sea una constante, sta podr ser ms simple. Especialmente si la constante es potencia de dos. El mecanismo de la
147
multiplicacin por dos en binario es como la multiplicacin por diez en decimal, es decir, basta con aadir ceros a la derecha. As que una multiplicacin por dos es un desplazamiento a la izquierda, con esto se reduce muchsimo la lgica requerida para su implementacin. Cuando se multiplica por una constante, el rango del resultado es el doble del nmero de bits del factor que no es constante. Este lleva implcito una consecuencia que hay que tener en cuenta: no podemos multiplicar un nmero por una constante de rango mayor queelnmero. As,elcdigo8.20seracomomultiplicarporcero,porquesetruncalaconstantealmismo nmero de bits que fact_us4. Por tanto el 16 (10000b) se quedara en 0 (0000b) por haber truncado el uno que est en el bit ms significativo. Para solucionarlo, tenemos que ampliar el rango del factor en un bit y ampliar el rango del producto. En el cdigo 8.21 se muestracmosehahechoesto.
... signal fact_us4: unsigned(3 downto 0); signal prod_us8: unsigned(7 downto 0); begin prod_us8 <= fact_us4 * 16; ... ... signal fact_us4: unsigned(3 downto 0); signal prod_us10:unsigned(9 downto 0); begin prod_us10 <= ('0'&fact_us4) * 16; ...
Cdigo 8.20: Producto por una constante de rango mayor. Errneo
Cdigo 8.21: Producto por una constante de rango mayor. Correcto
8.8.1. Algoritmo de la multiplicacin

Enesteapartadoseexplicarcmoeselalgoritmodelamultiplicacinyenlossiguientes se describirn varias maneras de implementar un multiplicador. Aunque un multiplicador lo podemos describir como se mostr en el cdigo 8.19 y el sintetizador se encarga de implementarlo, este apartado puede ser til porque se darn algunas indicaciones tiles para implementar otros operadores como la divisin, se analizarn distintasestrategiasparaimplementarciertostiposdeoperadoresysevernmanerasms avanzadasdedescribircircuitosenVHDL. Antesvercmoimplementarlamultiplicacinvamosaanalizarculeselmecanismoque utilizamos al multiplicar. La figura 8.6 muestra una multiplicacin con nmeros decimalesyasuderechalamismamultiplicacinenbinario.
9
x 13
27
+ 9
117
9 13 1001 9 0000 0 1001 36 72 + 1001 1110101 : 117

x 1101 :
1001 :
Figura 8.6: Ejemplos de multiplicacin entera en decimal y en binario
Siobservamoslafigura8.6podemosverquelosmecanismosdelamultiplicacindecimal y binaria son similares: se multiplica cada cifra del factor de abajo por el factor de arriba. El resultado de la multiplicacin se desplaza tantas cifras a la izquierda como la cifra del factor de abajo. Recuerda que desplazar a la izquierda es equivalente a multiplicar por la base, en decimal 10 y en binario 2. Por ltimo se suman todas las multiplicaciones parcialesyseobtieneelproducto.
148
En el caso de la multiplicacin binaria las multiplicaciones parciales son muy sencillas porque las nicas posibilidades son multiplicar por cero o por uno. Como veremos, estas multiplicacionessepuedenimplementarconpuertasand.
8.8.2. Implementacin de un multiplicador combinacional

Como hemos visto, para implementar la multiplicacin tendremos que realizar sumas, desplazamientosymultiplicacionesporunoycero. El diseo en esquemticos de este circuito se podra implementar como muestra la figura 8.7. El multiplicador tendr tantas etapas como bits de los factores. La primera etapaes la nicaquenotienesumador57.
1001
x 1101
1001
fact1 fact2(0) resul1
fact1 fact2(0)
+
1 prod(0) resul1 fact1 1001 x 1101 0100 + 0000 0010 01 prod(1) + prod(1) resul2 1001 x 1101 0010 fact1 fact2(2) resul2(4 downt0 1) sum_anded3 resul3 '0' '0' sum_anded3 fact1 fact2(2) fact1 fact2(1) resul1(4 downto 1) sum_anded2 resul2 fact2(1) '0''0' '0' sum_anded2 prod(0)
+ 1001
101 101
+ prod(2) prod(2) resul3 fact1
1001 1101
fact1 fact2(3) '0' '0'
fact2(3)
0101
+ 1001
1110101
resul3(4 downto 1) sum_anded4 resul4 prod + resul4 prod(7 downto 3)
sum_anded4
Figura 8.7: Esquema del multiplicador combinacional
En la implementacin se han hecho las sumas parciales conforme se va multiplicando. La figura8.8muestralacorrespondenciadelosnombresquesehandadoalasseales.
57
Tambinsepuedeponerunsumadorenelqueunodelossumandosescero.
149
1001 x 1101 1001 0000 1001 + 1001 1110101
fact1 fact2 resul1 + resul2 + sum_anded2 resul3 + resul4 sum_anded3 sum_anded4 prod
Figura 8.8: Sumas parciales para la multiplicacin
Lassealesson:

Losnmerosquesevanamultiplicar(factores):fact1yfact2 Los sumandos que ya se han multiplicado usando una puerta and: sum_anded1, sum_anded2,sum_anded3 Las sumas parciales: resul1, resul2, resul3 y resul4. Las seales sum_anded1 y resul1 seranequivalentes Elresultadodelamultiplicacin(producto):prod
is unsigned (3 downto 0); unsigned (3 downto 0); unsigned (7 downto 0)
ElVHDLdeesteesquemticopodraserelmostradoenelcdigo8.22.
entity mult_comb Port ( fact1 : in fact2 : in prod : out ); end mult_comb;
architecture behavioral of mult_comb is signal sum_anded1, sum_anded2, sum_anded3, sum_anded4 : unsigned(3 downto 0); signal resul1, resul2, resul3, resul4 : unsigned(4 downto 0); begin -- primera etapa sum_anded1 <= fact1 when fact2(0) = '1' else (others => '0'); resul1 <= '0' & sum_anded1; prod(0) <= resul1(0); -- segunda etapa sum_anded2 <= fact1 when fact2(1) = '1' else (others => '0'); resul2 <= ('0' & resul1(4 downto 1)) + ('0' & sum_anded2); prod(1) <= resul2(0); -- tercera etapa sum_anded3 <= fact1 when fact2(2) = '1' else (others => '0'); resul3 <= ('0' & resul2(4 downto 1)) + ('0' & sum_anded3); prod(2) <= resul3(0); -- cuarta etapa sum_anded4 <= fact1 when fact2(3) = '1' else (others => '0'); resul4 <= ('0' & resul3(4 downto 1)) + ('0' & sum_anded4); -- final: prod(7 downto 3) <= resul4; end behavioral;
Cdigo 8.22: Multiplicacin combinacional con sentencias concurrentes
Fjate que las sentencias del cdigo 8.22 son concurrentes, es decir, no estn dentro de un proceso.
8.8.3. Implementacin de un multiplicador combinacional genrico *

El multiplicador del apartado anterior es de cuatro bits58, siendo el resultado de ocho bits. Podemos ver que excepto la primera etapa, el resto de etapas son muy similares. Si ahora tuvisemos que disear un multiplicador de 16 bits (32 bits para el producto) tendramos que implementar las 16 etapas copiando y pegando de las anteriores. Esto, adems del tiempoinvertido,favorecelaaparicindeerrores.
58
Tambinsellamamultiplicador4x4
150
Para solucionar esto el VHDL permite generar sentencias repetitivas mediante la sentencia generate. En este apartado veremos primero la sentencia generate que nos permitereplicarsentenciasconcurrentessimilaresyposteriormentelaveremosaplicadaa unmultiplicadorgenricoenelquepodremosvariarelnmerodebitsdelosfactorescon genricos(recuerdaelapartado6.2). 8.8.3.1. La sentencia generate * En VHDL se pueden generar sentencias repetitivas mediante la sentencia generate. Por ejemplo, si queremos asignar a una seal los elementos de otra seal pero invertidos, podramos hacerlo como en el cdigo 8.23. Como siempre, el VHDL tiene varias alternativas para describir la misma cosa, y esta sentencia generate no es la nica manera dedescribirestafuncionalidad.Enelcdigo8.24semuestracmohacerlo.
... begin p_out(0) <= p_in(3); p_out(1) <= p_in(2); p_out(2) <= p_in(1); p_out(3) <= p_in(0); end behavioral; entity gen is Port ( p_in : in std_logic_vector (3 downto 0); p_out : out std_logic_vector (3 downto 0) ); end gen; architecture behavioral of gen is begin GENER: for i in 0 to 3 generate p_out(i) <= p_in(3-i); end generate; end behavioral;
Cdigo 8.23: Asignacin invirtiendo el orden de los bits
Cdigo 8.24: Asignacin invirtiendo el orden de los bits usando la sentencia generate
Lascaractersticasbsicasdelasentenciagenerateson:

Esunasentenciaconcurrente,porloquenopuedeirdentrodeunproceso59. Replicalassentenciasquecontieneconformealndicedelfor60 (enelejemplo:i) Estendicenosedeclarayelrangonopuedeservariable(peropuedeserungenrico). La sentencia generate empieza con una etiqueta (en el ejemplo: GENER), similar a las etiquetasdelosprocesosylareferenciaacomponentes.
En el ejemplo puedes observar que si copias la sentencia interna del generate para los cuatrovaloresdelndicesegeneranlasmismassentenciasdelcdigo8.23. 8.8.3.2. Multiplicacin con sentencia generate * Ahora que conocemos la sentencia generate podemos reescribir el multiplicador (cdigo 8.22) de modo que el ancho de los factores sea genrico. En el cdigo 8.25 se muestra el multiplicadorcombinacionalgenrico.
59 60
Dentrodelosprocesossepuedeutilizarlasentencialoopquetienealgunassimilitudes Elgeneratetambinpuedesercondicionalconunif,envezdeiterativoconelfor.
151
entity mult_comb_gen is Generic ( g_bits : natural := 4 ); Port ( fact1 : in unsigned (g_bits-1 downto 0); fact2 : in unsigned (g_bits-1 downto 0); prod : out unsigned (2*g_bits-1 downto 0) ); end mult_comb_gen;
-- doble de bits para el producto
architecture behavioral of mult_comb_gen is type t_vector_sumand is array (1 to g_bits) of unsigned (g_bits-1 downto 0); type t_vector_resul is array (1 to g_bits) of unsigned (g_bits downto 0); signal sum_anded : t_vector_sumand; signal resul : t_vector_resul; begin -- primera etapa sum_anded(1) <= fact1 when fact2(0) = '1' else (others => '0'); resul(1) <= '0' & sum_anded(1); prod(0) <= resul(1)(0); -- resto de etapas gen_mult: for i in 1 to g_bits-1 generate sum_anded(i+1) <= fact1 when fact2(i)='1' else (others =>'0'); resul(i+1) <= ('0' & resul(i)(g_bits downto 1)) + ('0' & sum_anded(i+1)); prod(i) <= resul(i+1)(0); end generate; -- final: prod(2*g_bits-1 downto g_bits) <= resul(g_bits)(g_bits downto 1); end behavioral;
Cdigo 8.25: Multiplicador combinacional genrico
Observandoelcdigo8.25podemosverque:

Elnmerodebitsdelosfactoresvienedefinidoporelgenricog_bits Las seales sum_anded1, sum_anded2, ... y resul1, resul2, ... se ha tenido que agrupar en vectoresparapoderusarlasdemaneraiterativaconelndicedelgenerate. Para poder declarar estos vectores hay que definir un tipo de datos que es un vector de vectores. En este caso son vectores de unsigned. Luego las seales se declaran con estos nuevostipos.
En general no se recomienda realizar el diseo genrico a la primera, sino realizar una primera versin para un caso particular, ver que funciona bien y luego generalizarla. Ya queeldiseogenricoesmscomplicado. 8.8.3.3. Banco de pruebas para el multiplicador genrico * Alhacerundiseogenricocomoelqueacabamosdever,tenemosquerealizarunbanco de pruebas que se adapte a los distintos valores del diseo. En el cdigo 8.26 se muestra unejemplodeestetipodebancosdeprueba.
152
entity tb_mult_comb_gen is Generic ( g_bits : natural := 4 ); end tb_mult_comb_gen; architecture TB of tb_mult_comb_gen is component mult_comb_gen Generic ( g_bits : natural := 4 ); Port ( fact1 : in unsigned (g_bits-1 downto 0); fact2 : in unsigned (g_bits-1 downto 0); prod : out unsigned (2*g_bits-1 downto 0) ); end component; signal fact1, fact2 : unsigned (g_bits-1 downto 0); signal prod : unsigned (2*g_bits-1 downto 0); begin uut: mult_comb_gen generic map ( g_bits => g_bits ) port map( fact1 => fact1, fact2 => fact2, prod => prod ); P_stim: Process begin for i in 0 to 2**g_bits-1 loop fact1 <= to_unsigned (i, g_bits); for j in 0 to 2**g_bits-1 loop fact2 <= to_unsigned (j, g_bits); wait for 50 ns; assert prod = i*j report "Fallo en la multiplicacion" severity ERROR; wait for 50 ns; end loop; end loop; wait; end process; end TB;
Cdigo 8.26: Banco de pruebas para el multiplicador combinacional genrico
Fjate que este banco de prueba es exhaustivo porque realiza todas las multiplicaciones posibles para el rango de los factores. El banco de pruebas incluye adems la sentencia assertquehacequeautocompruebesihahabidoalgnerror. Observaademsqueenlosrangosavecesseutilizalamultiplicacin(unsloasterisco)y otraslaexponenciacin(dosasteriscos),asegratequeentiendesporqu.
8.8.4. Implementacin de un multiplicador estructural *

Como ya sabemos, el VHDL permite mltiples descripciones para la misma funcionalidad. Una alternativa a la descripcin del multiplicador combinacional del apartado8.8.2esimplementarlodemaneraestructural. Por ejemplo, podemos describir la estructura que se repite en la figura 8.7 como un componente.Esdecir,describirlaentidaddelafigura8.9
153
sum
sum_and
p_and '0' suma_and '0'
resul
Figura 8.9: Componente bsico del multiplicador
La descripcin del mdulo de la figura 8.9 no tiene mayor dificultad y se deja como ejercicio. El mdulo estructural tampoco es difcil, se ha incluido en el cdigo 8.27. Observaqueadiferenciadelasversionesdeloscdigos8.22y8.25,enlaprimeraetapase ha puesto un sumador con un sumando igual a cero, por lo que funcionalmente son equivalentes.
entity mult_struct is port ( fact1 : in unsigned (3 downto 0); fact2 : in unsigned (3 downto 0); prod : out unsigned (7 downto 0) ); end mult_struct; architecture behavioral of mult_struct is constant c_cero : unsigned (3 downto 0) := "0000"; signal resul0, resul1, resul2, resul3 : unsigned (4 downto 0); component suma_and is port ( sum : in unsigned (3 downto 0); sum_and : in unsigned (3 downto 0); p_and : in std_logic; resul : out unsigned (4 downto 0) ); end component; begin
154
C_SUM_AND0: suma_and port map ( sum => c_cero, sum_and => fact1, p_and => fact2(0), resul => resul0 ); prod(0) <= resul0(0); C_SUM_AND1: suma_and port map ( sum => resul0 (4 downto 1), sum_and => fact1, p_and => fact2(1), resul => resul1 ); prod(1) <= resul1(0); C_SUM_AND2: suma_and port map ( sum => resul1 (4 downto 1), sum_and => fact1, p_and => fact2(2), resul => resul2 ); prod(2) <= resul2(0); C_SUM_AND3: suma_and port map ( sum => resul2 (4 downto 1), sum_and => fact1, p_and => fact2(3), resul => resul3 ); prod(7 downto 3) <= resul3; end behavioral;
Cdigo 8.27: Multiplicador estructural
8.8.5. Implementacin del multiplicador estructural genrico *

Dentro de las sentencias generate se pueden referenciar componentes y por lo tanto el multiplicadorestructuraldelcdigo8.27sepuedehacergenrico.
architecture behavioral of mult_struct is type t_vector_resul is array (0 to g_bits) of unsigned (g_bits downto 0); signal resul : t_vector_resul; component suma_and is generic ( g_bits : natural := 4 ); port ( sum : in unsigned (g_bits-1 downto 0); sum_and : in unsigned (g_bits-1 downto 0); p_and : in std_logic; resul : out unsigned (g_bits downto 0) ); end component; begin
155
resul(0) <= (others => '0'); GEN_SUMA: for i in 0 to g_bits-1 generate C_SUM_AND: suma_and generic map ( g_bits => g_bits ) port map ( sum => resul(i)(g_bits downto 1), sum_and => fact1, p_and => fact2(i), resul => resul(i+1) ); prod(i) <= resul(i+1)(0); end generate; prod(2*g_bits-1 downto g_bits) <= resul(g_bits)(g_bits downto 1); end behavioral;
Cdigo 8.28: Multiplicador estructural genrico
La entidad del multiplicador genrico no se ha incluido porque es similar a la del multiplicadorcombinacionalgenrico(cdigo8.25). Hayciertascosasinteresantesdelcdigo8.27:

Dentrodelgeneratehayunareferenciaacomponenteyunasentenciaconcurrente. Comolaprimeraetapasehaincluidoenelgenerate(adiferenciadelcdigo8.25),eltipo t_vector_resul tiene un elemento ms. Este elemento es el del ndice cero y su valor es todo cero. Este elemento es el que se suma en la primera etapa, y es equivalente a no realizarlasuma. Porlaraznanterior,elfordelgeneratetieneunaiteracinms
El banco de pruebas de este multiplicador puede ser similar al del multiplicador combinacionalgenricodelcdigo8.26.
8.9. Diseo considerando las prestaciones

El objetivo de este apartado es introducirnos en el anlisis de las prestaciones de un circuito de procesamiento y aprender distintas tcnicas para modificar las prestaciones. En el siguiente subapartado veremos un resumen de las prestaciones y cmo se deben considerar en el diseo. Posteriormente mediante el operador de multiplicacin aprenderemosdemaneraprcticaautilizaralgunasdeestastcnicas.
8.9.1. Anlisis de las prestaciones

Entrelasprestacionesdeuncircuitoseincluyenlavelocidaddeprocesamientoyelrea61. La velocidad de procesamiento depende de muchos factores, como son la frecuencia de reloj a la que funciona el circuito, la velocidad de propagacin de las seales y la tecnologa empleada. El rea es la cantidad de lgica empleada para implementar un circuito. Para implementar un circuito el diseador tiene ciertas libertades y restricciones. Por ejemplo, en nuestro caso podramos usar la placa XUP, la Nexys2 o la Basys, esto nos
61
Elconsumoenergticotambinesuncomponentemuyimportanteenlasprestacionesdeuncircuito.Un circuitoconbajoconsumoenergticonecesitarmenosenerga(menortamaodelabateraomayor duracin),disiparmenoscalorysermsfiableporquenosecalentartanto.Elanlisisdelconsumoest fueradelosobjetivosdeestelibro
156
dara ciertas libertades, pues si nuestro diseo fuese muy grande, podramos utilizar la XUP ya que su FPGA (Virtex2p) contiene un mayor nmero de celdas lgicas y multiplicadores.Evidentementeestosupondraunmayorcostededineroytenerqueusar unaplacademayortamao. Otroejemploseralafrecuenciadereloj,laXUPtieneunrelojde100MHzmientrasquela Nexys2 tiene un reloj de 50 MHz. Por otro lado la Basys tiene un reloj configurable mediante un jumper de 100, 50 25 MHz, lo que nos dara ms libertad. Sin embargo, las FPGAs Spartan3e de la Nexys2 y la Basys son ms lentas que la Virtex2p. En otros diseos el diseador podra tener la libertad de elegir la frecuencia de funcionamiento cambiando elcircuitodelreloj. Lo que acabamos de decir nos podra llevar a pensar que el diseador est limitado por circunstancias externas (frecuencia de reloj, FPGA utilizada, ...) y que el tipo de diseo VHDL que haga no tiene ninguna influencia en sus prestaciones. Afortunadamente esto no es as y una gran parte de las prestaciones del circuito viene determinada por la descripcindelcircuitoporpartedeldiseador. Una de las cosas que ms influyen en las prestaciones es el algoritmo empleado. Por ejemplo, en vez del algoritmo de multiplicacin escogido en el apartado 8.8.1 podamos haber implementado la multiplicacin sumando un factor tantas veces como el valor del otro factor. Es decir, si tenemos que multiplicar 7 x 9, podemos calcular el producto sumando siete veces el nmero nueve o sumando nueve veces el nmero siete. Este algoritmo es mucho menos eficiente que el que hemos visto en el apartado 8.8.1 ya que necesita ms sumadores (rea) y ms tiempo para completarse. Puedes hacer la prueba paracomprobarlo. Asquelaeleccindelalgoritmoesunaspectoclaveenlasprestacionesdeuncircuitoque incluso podra hacer que un diseo funcione ms eficientemente en una tecnologa ms barataqueotrodiseoconpeoralgoritmoenunatecnologaconmsprestaciones. Pero la eleccin del algoritmo no es la nica opcin con la que cuenta el diseador. Una vez escogido un algoritmo, el diseador puede hacer variaciones para ajustarse a sus especificaciones y restricciones. Normalmente, una vez elegido un algoritmo se puede elegir en mejorar una prestacin a costa de la otra. Es decir, podemos emplear ms rea para hacer el circuito ms rpido, y lo contrario, es decir hacer el circuito ms pequeo paraquequepaenlaFPGAperohaciendoqueseamslento. Estos casos se representan en las grficas de la figura 8.10. La grfica A de la izquierda representara las funciones que muestran la relacin entre la superficie y el tiempo de cmputo para dos algoritmos A0 y A1. El algoritmo A0 es menos eficiente que el algoritmo A1, ya que la implementacin del algoritmo A1 da como resultado un circuito con menos reaymenortiempodecmputo. LagrficaBdeladerechamuestralasvariacionesdereaytiempodecmputodentrode un mismo algoritmo. Como muestra la grfica, empleando un mismo algoritmo podemos movernos dentro de dicha funcin segn dnde tengamos la restriccin, en tiempo o en rea.
157
Mejora del algoritmo A0 A1
Mismo algoritmo A2
t0 > t1 Menor tiempo de cmputo S0 > S1 Menor superficie

A0 x0 x1
t0 > t1 Menor tiempo de cmputo S0 < S1 Mayor superficie

A2 superficie S1 S0 S2 y1 y0 y2
superficie
A1 S0 S1 t1
t0
tiempo de cmputo
t1 t0
t2
tiempo de cmputo
Figura 8.10: Curvas de prestaciones rea-tiempo para algoritmos
Estas funciones son simplificaciones para intentar explicar las relaciones entre las prestacionesdeuncircuito.Evidentementehaymsfactoresqueintervienen. Para entender esto mejor, resumiremos algunas de las tcnicas utilizadas en el diseo de circuitosdigitalesparaaumentaralgunasprestacionesacostadeotras.Estasson:

Paralelizacin Segmentacin Compartirrecursos Diseosecuencial
Acontinuacinveremoscadaunadeestastcnicasconmsdetalle. 8.9.1.1. Paralelizacin Esta tcnica consiste en realizar operaciones en paralelo y es una de las grandes ventajas de las FPGAs frente a los microprocesadores. Si queremos aumentar el nmero de elementos procesados por unidad de tiempo, podemos realizar procesamientos en paralelo, duplicando/triplicando/... los mdulos de procesamiento. La figura 8.11 muestra la representacin esquemtica de esta tcnica. Como se puede intuir, el doble de rea produce el doble de elementos procesados, que se podra traducir en doble velocidad de procesamiento o mitad de tiempo de cmputo. Sin embargo realmente no es as, pues suele ser ms del doble de rea al ser necesario incluir lgica de control. Y por otro lado, no es del todo exacto decir que el tiempo de procesamiento se disminuye a la mitad, ya quenosiemprehabrdoselementosdisponiblesparaserprocesados.
procesamiento entrada procesamiento salida entrada procesamiento
salida
Figura 8.11: Paralelizacin
8.9.1.2. Segmentacin La segmentacin62 consiste en dividir un procesamiento en tareas ms sencillas y separarlas por elementos de memoria. La figura 8.12 muestra la representacin esquemticadeestatcnica.
62
Lasegmentacineninglssellamapipelining
158
50 ns
entrada
procesamiento
salida
20 MHz
entrada
p1
p2
p3
salida
50 MHz
20 ns
20 ns
20 ns
Figura 8.12: Segmentacin
Conlasegmentacinsepuedenconseguirdosobjetivos:

Aumentarlafrecuenciaderelojdelcircuito Aumentarelcantidaddeelementosprocesadosporunidaddetiempo
Sinosfijamosenlafigura8.12podemosverquedebidoalolargoqueeselprocesamiento sinsegmentar,lafrecuenciamximadelcircuitoestlimitadaaltiempodeprocesamiento de este mdulo. Podra suceder que el resto del circuito tenga que ir ms lentamente debido a la lentitud de este mdulo, que impone 20 MHz de frecuencia mxima63. Esto implicara un detrimento en las prestaciones del resto del circuito. En cambio, si segmentamoselprocesamiento,cadaunadelasdivisionespodrirmsrpidamente,con loquelafrecuenciamximadelcircuitopuedesermselevada(50MHzenelejemplo). Por otro lado, la segmentacin permite aumentar la cantidad de elementos procesados ya que el procesamiento se realiza en cadena gracias a la separacin que establecen los elementos de memoria. Es decir, al mismo tiempo que p3 (de la figura 8.12) est terminando de procesar un elemento, p2 esta procesando el siguiente elemento, y p1 est procesando el elemento que acaba de entrar en la cadena. Esto implica que, una vez que sehallenadolacadena,tendremosunnuevoelementoprocesadocada20ns(50MHz). Sinembargolasegmentacinnoesideal,esdecir,sidividimosentresprocesamientos,no obtendremos el triple de frecuencia, ya que es difcil conseguir procesamientos iguales de modo que cada uno de ellos tarde exactamente un tercio del original. Por otro lado, hay que tener en cuenta el llenado y vaciado de la cadena de segmentacin, y que cuando tenemosqueprocesarunsloelementovaatardartresciclosdereloj. La segmentacin implica un aumento de rea por los elementos de memoria aadidos, ademssuelenecesitaralgunalgicaaadidadecontrol. Unejemplodemultiplicadorsegmentadoseverenelapartado8.9.3. 8.9.1.3. Compartir recursos Cuando el problema es el rea y no la velocidad de cmputo, o cuando sabemos que dos mdulos del circuito no van a necesitar hacer el mismo procesamiento simultneamente, sepuedencompartirrecursos.Porejemplo,sitenemosdosmdulosquenecesitanrealizar una multiplicacin, en vez de que cada uno tenga un multiplicador, podemos disear el circuito de modo que haya un nico multiplicador para los dos. Cuando es un recurso compartido por muchos mdulos, el ahorro de rea puede ser importante, aunque
63
Enelcasoquecompartanelmismoreloj
159
tambin puede aumentar los tiempos de procesamiento. Tambin ser necesario incluir mdulos de control de los recursos, lo que har que aumente el rea y la complejidad del circuito. Esta tcnica se emplea extensamente en arquitectura de computadores, en donde secompartenbuses,perifricos,unidadesdeprocesamiento,memorias,... En la figura 8.13 se muestra un esquema del mecanismo de compartir recursos. En el nuevodiseoconelprocesamientocompartidosehaaadidounbloquectrlqueindicala necesidad de aadir un mdulo de control para el recurso compartido y la comunicacin conelrestodelcircuito.
Mdulo 1 Mdulo 2 Mdulo 1 Mdulo 2
procesamiento
procesamiento
procesamiento
ctrl
Figura 8.13: Compartir recursos
8.9.1.4. Diseo secuencial Cuando tenemos que realizar varios procesamientos similares en cadena podemos optar porrealizarundiseosecuencial.Conestaalternativaseahorrareaconelcostedetardar varios ciclos de reloj en realizar el procesamiento. En la figura 8.14 se muestra de manera esquemtica en qu consiste esta tcnica. En esta figura se comparan el diseo combinacional, que es el diseo sin considerar ninguna tcnica, con la segmentacin y el diseo secuencial. En la figura podemos ver que el mismo procesamiento P se repite en varias etapas. Con el diseo segmentado se introducen elementos de memoria entre cada procesamiento, mientras que con el diseo secuencial, se utiliza un slo mdulo de procesamiento P que se utiliza de manera iterativa para el procesamiento. Dicho de manera coloquial, el diseo segmentado sera un diseo secuencial desenrollado. Obviamente, el diseo secuencial ahorra mdulos de procesamiento pero requiere de un mdulodecontroldeciertacomplejidad.
A
entrada
entrada entrada
p p
p control
p p p p p
salida p
salida
biestables
salida
Figura 8.14: Tres opciones de diseo. A: combinacional. B: Segmentado. C: Secuencial
160
Si observas el mdulo combinacional (A) de la figura 8.14 podrs ver que la estructura es similar al multiplicador combinacional de la figura 8.7, siendo el mdulo de procesamientoelmostradoenlafigura8.9.Enlossiguientesapartadosseanalizarncada una de estas estrategias con el ejemplo del multiplicador, as aprenderemos a utilizarlas demaneraprctica,viendolasventajaseinconvenientesdecadauna.
8.9.2. Anlisis del multiplicador combinacional

Los multiplicadores combinacionales suponen un coste considerable en lgica (tamao) y en retardos para el circuito. Adems el aumento del nmero de bits del multiplicador tieneimportantesrepercusionesensutamaoyretardos. Puede ocurrir que tengamos un circuito descrito correctamente pero que por su gran tamaonoquepaenlaFPGA,otambinpuedeocurrirquelosretardosdelcircuitohagan que no funcione a la frecuencia de nuestra tarjeta. Si esto ltimo ocurriese, el circuito se simulara bien pero no funcionara correctamente en la FPGA debido a que las seales no llegan a tiempo por sus largos tiempos de propagacin. Esto puede ser un gran problema porque podemos estar eternamente revisando la funcionalidad del circuito y la simulacin para encontrar los fallos y no lo encontraremos pues funcionalmente el circuitoestbien. En este apartado vamos a analizar el tamao y los retardos del multiplicador combinacional. Este anlisis no slo es valido para el diseo de multiplicadores sino que sertilparaotrotipodecircuitos. Primerovamosacompararelreayelcaminocrtico.Recuerdaqueelcaminocrticoesel camino combinacional del circuito que tiene un mayor retardo. El camino crtico ser el quedeterminelafrecuenciamximaalaquepuedefuncionarelcircuito. Para analizar el rea de un circuito tomaremos como referencia el nmero de slices que se necesitan. Los slices son unas unidades elementales de las FPGAs de Xilinx [26spart3] y contienen los elementos bsicos para implementar la lgica circuitos: LUTs, elementos de memoria, multiplexores y lgica aritmtica. Cuatro slices se agrupan en un bloque lgico configurableoCLB64. Gracias a que hemos diseado el multiplicador combinacional genrico en el apartado 8.8.3podremossintetizarelmultiplicadorcambiandoelnmerodebitsdelosfactorescon slomodificarelgenricog_bits. En el informe de sntesis (recuerda el apartado 8.5.1) puedes comprobar el nmero de slices necesarios para la sntesis y una estimacin del retardo mximo. Estos retardos son estimaciones, para obtener un dato ms preciso habra que hacer la implementacin y el mapeado, e incluso realizar una simulacin despus de la sntesis. Pero para el anlisis que queremos hacer esta estimacin es suficiente. Por otro lado, en el caso de que los retardos sean crticos, para reducirlos se pueden incluir restricciones temporales y opcionesdesntesisqueseenfoquenenminimizarlos. En la tabla 8.2 se muestra el nmero de slices y los retardos para el multiplicador combinacional segn el nmero de bits. Podemos ver que un nico multiplicador de 32 bits ocupa el 11% de la FPGA de la Nexys2 y que los retardos hacen que la frecuencia mximaseadetanslo11,3MHz.
64
CLB:ConfigurableLogicBlock
161
nbitsfactores slices %slicesNexys2 retardomx.(ns)
4 17 15,3
8 29 23,9 41,9
12 67 34,6 28,9
16 121 45,1 22,2
20 202 56,9 17,6
24 290 67,4 14,8
28 394 77,9 12,8
32 514 88,4 11,3
0,4% 0,6% 1,4% 2,6% 4,3% 6,2% 8,5% 11%
frecuenciamx.(MHz) 65,3
Tabla 8.2: Variacin de rea y retardos con el nmero de bits de los factores del multiplicador combinacional del apartado 8.8.3 para la Nexys2
Losresultadossonmuypobreseimplementarestetipodemultiplicadoressuponeunalto coste en rea y una reduccin muy importante en la frecuencia. Y lo que es peor, tendramosquemodificarelrelojdelaNexys2paraadaptarnosaestafrecuencia65. Los resultados para la XUPV2P tampoco son buenos aunque mejores a causa de sus mayores prestaciones. Como su tamao es mayor, el multiplicador de 32 bits ocupa un 3,8%delaFPGAylosretardosobligaranafuncionaralaFPGAa16,3MHz. Por suerte, estas FPGAs tienen multiplicadores embebidos de 18 bits. Y son los que se emplean al describir un multiplicador con la operacin de multiplicacin (cdigo 8.19). Los resultados de rea y retardos usando estos multiplicadores son mucho mejores (tabla 8.3). Con estos resultados, para 32 bits la frecuencia mxima (56 MHz) es mayor que la frecuenciadelrelojdelaNexys2,porloquenotendramosproblemaalusarlos.
nbitsfactores slices %slicesNexys2 multiplicadores %multiplicadoresNexys2 retardomx.(ns) frecuenciamx.(MHz) 4 0 1 5% 9,7 8 0 1 5% 10,2 12 0 1 5% 10,2 98,0 16 0 1 5% 10,2 98,0 20 25 4 20% 16,4 60,8 24 35 4 20% 16,9 59,1 28 45 4 20% 17,4 57,5 32 55 4 20% 17,9 56,0
0,0% 0,0% 0,0% 0,0% 0,5% 0,8% 1,0% 1,2%
103,4 98,4
Tabla 8.3: Variacin de rea y retardos con el nmero de bits de los factores de los multiplicadores embebidos de la Nexys2 (cdigo 8.19)
De la tabla 8.3 podemosobservar varias cosas interesantes.A partir de 20 bits seaumenta el nmero de multiplicadores de uno a cuatro. Esto se debe a que los multiplicadores embebidos son de 18x18 bits y por lo tanto hay usar cuatro para crear un multiplicador mayor. Adems, a causa de la lgica que hay que aadir entre los multiplicadores los retardos tambin aumentan considerablemente. En la figura 8.15 se muestra de manera esquemtica cmo se utilizan cuatro multiplicadores de 2x2 para realizar una multiplicacin de 4x4. Observa que despus de las multiplicaciones hay que realizar la sumadeloscuatroresultados.Elesquemadelafiguraesampliableaotronmerodebits.
65
RecuerdaquelafrecuenciaderelojdelaNexys2esde50MHz
162
10 x 01 x
1001 x 1101 1001 0000 1001 1001 + 1110101
10 00 + 010 10 x 11 +
01 01 01 00
001 01 x 11
001 010 011 + 110 1110101
10 + 10 110
01 01 011
Figura 8.15: Algortimo para calcular un multiplicador de 4x4 a partir de4 multiplicadores de 2x2
Por ltimo, vemos que la Spartan3e de la Nexys2 slo tiene 20 multiplicadores, por lo que un multiplicador de 20 bits emplea el 20% de los multiplicadores disponibles. La Virtex2p delaXUPV2Ptiene138multiplicadores,porloqueelproblemaesmenor,mientrasquela Spartan3edelaBasystanslotiene4multiplicadores. En el siguiente apartado veremos cmo disear un multiplicador segmentado y analizaremossusprestaciones.
8.9.3. Multiplicador segmentado

En el apartado 8.9.1.2 vimos las ventajas de realizar una segmentacin y que esta tcnica se poda aplicar a los multiplicadores. Para segmentar un multiplicador tenemos que poner registros entre cada una de las etapas, teniendo cuidado de ir trasladando correctamentelosdatosdecadaetapa. Teniendopresenteelesquemadelmultiplicadorcombinacionaldelafigura8.7vemosque se puede dividir naturalmente en tantas etapas como bits de los factores. En la figura 8.7 lalneadiscontinuaazulmarcadndepodemosrealizarlasegmentacin. En la figura 8.16 se muestra el esquema del multiplicador segmentado. Observa que en cada etapa hay registros que separan una etapa de la otra. Incluso los factores (fact1 y fact2) tienen que estar registrados si queremos poder realizar operaciones encadenadas, de manera que en las distintas etapas se puedan estar realizando multiplicaciones simultneas. Con esto hacemos que cada una de las etapas sea independiente y podamos estarrealizandounapartedeunamultiplicacindiferenteencadaetapa.
163
fact1
fact2
fact1_rg1 fact2_rg1(0)
fact1_rg1
fact2_rg1
e1
prod_rg1(0)
2 0 3 0 2 0
resul_rg1 '0' '0'
fact1_rg1 fact2_rg2(1)
fact1_rg2
fact2_rg2
e2
+ prod_rg2(1) fact1_rg3 fact2_rg3(2) '0' '0'
prod_rg2(1..0)
resul_rg2
fact1_rg3
fact2_rg3
e3
+ prod_rg3(2) resul_rg3 fact1_rg4 fact1_rg4

prod_rg3(2..0)
fact2_rg4
'0'
'0'
fact2_rg4(3)
e4
+
prod
Figura 8.16: Esquema del multiplicador segmentado
En este ejemplo, la multiplicacin estar lista en cinco ciclos de reloj, un ciclo ms que los bits del multiplicador. Sin embargo, una vez llena la cadena de la multiplicacin, si la mantenemosllenaobtendremosunresultadodistintocadaciclodereloj. Este diseo es modificable, por ejemplo se podra haber eliminado la primera etapa juntndolaconlasegunda,yaquetienemenorretardoyrea. EldiseoVHDLsemuestraenelcdigo8.29.Estediseosehahechogenricoydebidoa ellohayelementosdesealesvectorialesquenoseusan,comoporejemploalgunosdelos elementos del vector prod_rg. Como vemos en la figura 8.16, la primera etapa slo tiene un elemento: prod_rg1(0), y va aumentando en un elemento con cada etapa. Es decir, en lasegundaetapaesprod_rg2(1 downto 0),yassucesivamente.EldiseoVHDL,comoes un diseo genrico, se ha creado el vector de vectores prod_rg, donde el primer ndice corresponde con la primera etapa: prod_rg(1)(g_bits-1 downto 0), pero de este vector slo se utiliza el bit cero: prod_rg(1)(0). En la segunda etapa, slo se utilizan los dos bits menossignificativos:prod_rg(2)(1 downto 0),yassucesivamente.
164
De manera similar ocurre con los registros del segundo factor: fact2_rg. Conforme se avanzaenlasetapas,noesnecesarioguardarelvalordetodossuselementos.Delafigura 8.16 podemos observar que conforme se avanza en las etapas fact2_rg disminuye y prod_rg aumenta. As que se podra haber utilizado el mismo vector para los dos, utilizandoloselementosinferioresparaelprod_rgylossuperioresparafact2_rg.Estono sehahechoparanodificultarlacomprensindelcdigo.Comoconsecuencia,alsintetizar elcdigo8.16aparecernalgunosavisosdesealesnoutilizadas. Para reducir el tamao del cdigo en este libro no se ha incluido el reset en los biestables delmultiplicador,peroseraconvenienteincluirlo.
entity mult_seg_gen is Generic ( g_bits : natural := 4 ); Port ( clk : in std_logic; fact1 : in unsigned (g_bits-1 downto 0); fact2 : in unsigned (g_bits-1 downto 0); prod : out unsigned (2*g_bits-1 downto 0) ); end mult_seg_gen; architecture behavioral of mult_seg_gen is type t_vector_fact is array (1 to g_bits) of unsigned (g_bits-1 downto 0); type t_vector_resul is array (1 to g_bits) of unsigned (g_bits downto 0); -- prod_rg es la mitad inferior de prod, que se va manteniendo para abajo signal prod_rg, sum_anded, fact1_rg, fact2_rg, resul_rg : t_vector_fact; signal resul : t_vector_resul; begin -- primera etapa --------------------------------------------------------------sum_anded(1) <= fact1_rg(1) when fact2_rg(1)(0) = '1' else (others => '0'); resul(1) <= '0' & sum_anded(1); P_reg_1e: Process (clk) begin if clk'event and clk='1' then fact1_rg(1) <= fact1; -- registramos entradas fact2_rg(1) <= fact2; resul_rg(1) <= resul(1)(g_bits downto 1); -- registramos resultados prod_rg(1)(0) <= resul(1)(0); end if; end process; -- resto de etapas ------------------------------------------------------------gen_mult: for i in 2 to g_bits generate sum_anded(i) <= fact1_rg(i) when fact2_rg(i)(i-1)='1' else (others =>'0'); resul(i) <= ('0' & resul_rg(i-1)) + ('0' & sum_anded(i)); P_resuli_rg: Process (clk) begin if clk'event and clk='1' then fact1_rg(i) <= fact1_rg(i-1); fact2_rg(i) <= fact2_rg(i-1); resul_rg(i) <= resul(i)(g_bits downto 1); prod_rg(i)(i-1) <= resul(i)(0); prod_rg(i)(i-2 downto 0) <= prod_rg(i-1)(i-2 downto 0); end if; end process; end generate; -- registrar la salida -------------------------------------------------------P_prod_rg: Process (clk) begin if clk'event and clk='1' then prod(2*g_bits-1 downto g_bits) <= resul(g_bits)(g_bits downto 1); end if; end process; -- prod_rg ya esta registrado prod(g_bits-1 downto 0) <= prod_rg(g_bits)(g_bits-1 downto 0); end behavioral;
Cdigo 8.29: Multiplicador segmentado genrico
165
De la misma manera que en los multiplicadores anteriores, se ha analizado el tamao y los retardos del multiplicador segmentado (tabla 8.4). Como era de esperar el rea aumentarespectoalmultiplicadorcombinacional(tabla8.2)ylafrecuenciahadisminuido enormemente.Portanto,hemosresueltoelproblemadelafrecuenciadereloj,peroacosta deaumentarelrea.
nbitsfactores slices %slicesNexys2 retardomx.(ns) 4 30 4,7 8 83 4,1 12 178 4,5 16 306 4,8 20 492 4,7 24 698 5,0 198,5 28 953 5,1 195,4 32 1248 5,4 185,6
0,6% 1,8% 3,8% 6,6% 10,6% 15,8% 20,5% 26,8%
frecuenciamx.(MHz) 214,3 246,2 222,2 207,9 211,2
Tabla 8.4: Variacin de rea y retardos con el nmero de bits de los factores de los multiplicadores segmentados (cdigo 8.29)
Comolosretardoshandisminuidomuchomsdeloquenecesitamos,yparanoaumentar tanto el rea utilizada, en vez de realizar la segmentacin entre cada etapa podemos realizarla cada cierto nmero de etapas. Para este caso parece que segmentar cada tres o cuatro etapas mantendra la frecuencia superior a 50 MHz y hara disminuir las necesidadesderea. La segmentacin tambin es til cuando queremos implementar multiplicadores mayores de 18 bits utilizando los multiplicadores embebidos. Como vimos en la tabla 8.3, los retardosaumentabanporlanecesidaddeunirlosresultadosdeloscuatromultiplicadores (figura 8.15). Segmentar entre la salida de los multiplicadores y las sumas posteriores haradisminuirlosretardos,consiguindosefrecuenciasderelojmsaltas.
8.9.4. Implementacin del multiplicador secuencial

Se podra decir que el multiplicador secuencial es como el multiplicador segmentado enrolladosobresmismo,demodoquelassalidasdecadaetapasevuelvenasumarenel nico sumador en vez de ir a la siguiente etapa (recuerda la figura 8.14). Por lo tanto, todas las etapas se procesan en el mismo hardware y como consecuencia el multiplicador estarocupadohastaquetermine. Ser necesario un control que cuente el nmero de la multiplicacin parcial en la que se est, que indique cundo ha terminado y que controle cundo se pueden admitir datos para una nueva multiplicacin. La figura 8.17 muestra un esquemtico de uno de los posibles circuitos que implementa un multiplicador secuencial. No es un esquemtico completamentedetalladoparaqueseamsentendible.
166
fact2_rg fact1_rg
3 0 3 0
cont_bits
cont_bits
'0'
contador
'0' sum_anded
fincontbits
+ resul resul(0) fincontbits

finmult e_init 0X cargafact 1X e_mult X1 XX e_fin X0
0
4
1
4 3 2 1 0
cont_bits
Mquina de estados resul_rg

7 0
prod_rg
Figura 8.17: Esquemtico del multiplicador secuencial de 4 bits
En la figura 8.17 se puede identificar el elemento bsico de procesamiento sobre el que se iteranlasoperacionesyqueyavimosenlafigura8.9. LadescripcinVHDLcorrespondientealmultiplicadorsecuencialsemuestraenelcdigo 8.30.
entity mult_seq_gen is Generic (g_bits : natural := 4 ); Port ( rst : in std_logic; clk : in std_logic; start : in std_logic; -- orden de empezar multiplicacion fact1 : in unsigned (g_bits-1 downto 0); fact2 : in unsigned (g_bits-1 downto 0); finmult : out std_logic; -- fin de multiplicacion prod : out unsigned (2*g_bits-1 downto 0) ); end mult_seq_gen; architecture behavioral of mult_seq_gen is constant c_nb_contbits : natural := log2i(g_bits-1); signal contbits_us : unsigned (c_nb_contbits downto 0); signal contbits : natural range 0 to 2**(c_nb_contbits+1)-1; signal fincontbits : std_logic; signal cargafact : std_logic; signal fact1_rg, fact2_rg, sum_anded : unsigned (g_bits-1 downto 0); signal resul : unsigned (g_bits downto 0); -- resul_rg tiene 1 bit menos, porque no guarda el bit menos significativo -- ya que este va a prod_rg signal resul_rg : unsigned (g_bits-1 downto 0); signal prod_rg : unsigned (2*g_bits-1 downto 0); type estados_mult is (e_init, e_mult, e_fin); signal estado_act, estado_sig : estados_mult; begin
167
-------------------- MAQUINA DE ESTADOS ----------------------------------P_control_seq: Process(rst,clk) begin if rst = c_on then estado_act <= e_init; elsif clk'event and clk='1' then estado_act <= estado_sig; end if; end process; P_control_comb: Process (estado_act, start, fincontbits) begin cargafact <= '0'; finmult <= '0'; case estado_act is when e_init => if start = '1' then estado_sig <= e_mult; cargafact <= '1'; else estado_sig <= e_init; end if; when e_mult => if fincontbits = '1' then estado_sig <= e_fin; else estado_sig <= e_mult; end if; when e_fin => estado_sig <= e_init; finmult <= '1'; end case; end process; --------------- CARGA Y REGISTRO DE LOS FACTORES A MULTIPLICAR------------------P_cargafact: Process (rst, clk) begin if rst = c_on then fact1_rg <= (others => '0'); fact2_rg <= (others => '0'); elsif clk'event and clk='1' then if cargafact = '1' then fact1_rg <= fact1; fact2_rg <= fact2; elsif estado_act = e_fin then fact1_rg <= (others => '0'); fact2_rg <= (others => '0'); end if; end if; end process; -------------- CUENTA LOS BITS QUE SE VAN MULTIPLICANDO -------------------------P_cuenta_bits: Process (rst, clk) begin if rst = c_on then contbits_us <= (others =>'0'); elsif clk'event and clk='1' then if estado_act = e_mult then contbits_us <= contbits_us + 1; else contbits_us <= (others =>'0'); end if; end if; end process; fincontbits <= '1' when contbits=g_bits-1 else '0'; contbits <= to_integer(contbits_us); -- para los rangos se necesita un entero --------------- MODULO DE LA SUMA CON MULTIPLICACION (figura 8.9) -- la multiplicacion parcial del bit de fact2 con fact1, -- teniendo en cuenta el desplzamiento sum_anded <= fact1_rg when fact2_rg(contbits) = '1' else (others => '0'); resul <= ('0' & resul_rg) + ('0' & sum_anded);
168
--------------------- GUARDA EL RESULTADO en: -- resul_rg: si no se ha terminado -- prod_rg : si es el resultado definitivo (fincontbits='1') P_acum_mult: Process (rst, clk) begin if rst = c_on then resul_rg <= (others => '0'); prod_rg <= (others => '0'); elsif clk'event and clk='1' then case estado_act is when e_init | e_fin => resul_rg <= (others => '0'); prod_rg <= (others => '0'); when e_mult => if fincontbits = '0' then resul_rg <= resul(g_bits downto 1); prod_rg(contbits) <= resul(0); else resul_rg <= (others => '0'); -- ya no hace falta resul_rg prod_rg(2*g_bits-1 downto contbits) <= resul; --se guarda en prod_rg end if; end case; end if; end process; prod <= prod_rg; end behavioral;
Cdigo 8.30: Multiplicador secuencial genrico
Porltimo nosquedaanalizarlasprestacionesdeestemultiplicador.Latabla8.5muestra queconestemultiplicadormantenemoseltamaocontroladoytambinquelafrecuencia no baja excesivamente. Sin embargo hay que tener en cuenta que la multiplicacin tarda unnmerodeciclosmayorqueelnmerodebitsdelmultiplicador66.
nbitsfactores slices %slicesNexys2 retardomx.(ns) 4 38 6,5 8 37 7,9 12 83 9,1 16 81 8,9 20 136 11,4 24 144 11,3 88,1 28 156 11,3 88,2 32 162 10,8 92,4
0,8% 0,8% 1,8% 1,7% 2,9% 3,1% 3,4% 3,5%
frecuenciamx.(MHz) 152,7 126,5 110,3 112,4 88,0
Tabla 8.5: Variacin de rea y retardos con el nmero de bits de los factores de los multiplicadores secuenciales (cdigo 8.30)
8.9.5. Comparacin de los multiplicadores

Finalmente compararemos las cuatro alternativas de multiplicadores implementados. Recordemosantesculessonestasalternativas:

Multiplicadorembebido(cdigo8.19) Multiplicador combinacional (figura 8.7 y cdigo 8.22). El multiplicador genrico combinacional (apartado 8.8.3) y el estructural (apartado 8.8.4) tambin estn dentro de estacategora Multiplicadorsegmentado(apartado8.9.3) Multiplicador(apartado8.9.4)
En la figura 8.18 se muestra de manera grfica el porcentaje de rea (slices) utilizado en la Nexys2 para implementar los distintos multiplicadores segn el nmero de bits de los factores.
66
Dependiendodeltipodecontrolyeltipodemquinadeestadoselnmerodeciclospuedepuedevariar.
169
30% 25%
% Slices Nexys2
20% 15% 10% 5% 0% 4 8
segmentado combinacional secuencial embebidos
12
16
20
24
28
32 n bits
Figura 8.18: Utilizacin de rea de la Nexys2 para implementar los distintos multiplicadores respecto al nmero de bits del multiplicador
En la grfica se puede ver que la mejor alternativa en cuanto rea es utilizar los multiplicadores embebidos (para eso estn). El inconveniente es que la Spartan3e de la Nexys2tieneslo20multiplicadores,ycuandoserealizaunamultiplicacinde20bits,se utilizan4deellos(el20%).Conloqueslopodramosimplementarcincomultiplicadores embebidosde20bits. Los multiplicadores secuenciales mantienen el rea controlada, mientras que los multiplicadores combinacionales y segmentados aumentan mucho su rea conforme aumentaelnmerodebits,especialmentelossegmentados. En la figura 8.19 se muestra la frecuencia mxima a la que puede funcionar la Nexys2 segnelmultiplicadorqueseuseyelnmerodebitsdelosfactores.
250 segmentado secuencial embebidos combinacional
200
MHz Nexys2
150
100
50
0 4 8 12 16 20 24 28 32 n bits
Figura 8.19: Frecuencia mxima de la Nexys2 para los distintos multiplicadores respecto al nmero de bits del multiplicador
De la grfica podemos extraer que los multiplicadores combinacionales tienen muchos retardos(bajafrecuencia)mientrasqueenelextremoopuesto,lossegmentadostienenuna frecuencia mucho mayor que la que normalmente utiliza la tarjeta (50MHz). Por lo tanto, como ya se ha indicado, para aumentar la frecuencia de los combinacionales y reducir el readelossegmentados,sepuedehacerunasegmentacinintermedia. El multiplicador secuencial tiene buenas caractersticas en cuanto a retardos y rea, pero eslentoporquerequierevariosciclosdereloj. Y por ltimo, el multiplicador embebido tiene buenas prestaciones, pero podemos observar que la frecuencia baja a partir de 18 bits, ya que hay que utilizar varios
170
multiplicadores (figura 8.15). Para solucionar esto se puede segmentar a la salida de los multiplicadores embebidos o incluso realizar diseos mixtos, usando multiplicadores embebidosalavezquemultiplicadorescombinacionalesosegmentados. Comoresumen,noexisteunaestrategiaquesealamejorentodosloscasos,eslatareadel diseador analizar los requisitos del sistema y elegir lo que ms conviene en cada caso. Tambin es importante considerar el tipo de algoritmo, ya que ste puede influir en las prestaciones del sistema independientemente de la estrategia utilizada. Hay otros algoritmos y variantes que mejoran los que hemos vistos, el estudio de stos se sale del objetivodeestelibro,paramsinformacinpuedesconsultarlareferencia[7desch]. Por otro lado tambin hay que sealar que el tiempo de diseo es un factor muy importante.Estosignificaquenohayquemejorarlasprestacionescuandonoesnecesario. Por ejemplo, si nuestro multiplicador funciona bien y da las prestaciones requeridas, no hay que dedicar ms tiempo a mejorarlo. No es eficiente implementar un multiplicador msrpidooqueocupemenosreasiparasudiseonecesitoempleareldobledetiempo y mi sistema final no obtiene ninguna ventaja. Un retraso en el proyecto puede ser peor quereducirenun5%elreautilizadasitenemosunaFPGAsuficientementegrande.Esla tarea del ingeniero valorar todos los aspectos del diseo, sus costes y los tiempos de desarrollo.
8.10. Divisin
Al contrario de la multiplicacin, si necesitamos implementar una divisin entera, el operador / no est soportado para la sntesis, por lo tanto tendremos que disear el divisor67. Existen muchos algoritmos de divisin, a continuacin se explicar uno que es el que resulta ms parecido a nuestra forma de dividir a mano y es por tanto ms sencillo de entender. En la figura 8.20 se muestra una divisin entera realizada con nmeros enteros decimales yconnmerosenterosbinarios.
157 15 7 -13 27 -26 1 13 12 10011101 1101 -1101 1100 01101 -1101 001 Dividendo:15710=10011101 divisor:1310=1101 Cociente:1210=1100 Resto:1
Figura 8.20: Ejemplo de divisin entera en decimal y en binario
Veamospasoapasoelalgoritmoparahacerladivisin: Primero desplazamos a la izquierda el divisor lo ms que podamos siempre quequepa en el dividendo (D>d). La cantidad de veces que se ha desplazado la memorizamos. En electrnica digital, diramos que la guardamos en un registro que llamaremos Desplz. En nuestroejemplodelafigura8.21eldesplazamientoes3.
67
Anoserqueestemoshaciendounadivisinentredosconstantes.EnestecasoelcompiladorVHDLcalcula ladivisinyelresultadoeselqueseusaenlasntesis.Oquequeramoshacerunadivisinporunapotencia dedos.
171
10011101 1101 -1101
10011101 Dividendo 1101 Divisor Desplazamos a la izquierda divisor 10011101 Dividendo Desplz = 1 1101 Divisor Sique cabiendo (Divisor < Dividendo) 10011101 Dividendo 1101 Divisor Desplz = 2
Sique cabiendo (Divisor < Dividendo) 10011101 Dividendo Desplz = 3 1101 Divisor La siguiente no cabe (Divisor > dividendo) 10011101 Dividendo 1101 Divisor Desplz = 4 No
Figura 8.21: Paso 1 de la divisin: clculo del desplazamiento inicial
Una vez que tenemos el divisor desplazado lo ms posible a la izquierda (Desplz=3), restamos al dividendo el divisor y ponemos un 1 en el cociente (figura 8.22). En la figura sehanrellenadoloscerosquefaltanaladerechaprovocadosporeldesplazamiento.Enel clculomanualsehaceimplcitamenteaunquenoseponenparaahorrarlaescrituradela restacompleta.
10011101 -1101000 0110101 1101 1 Desplz = 3
Figura 8.22: Paso 2 de la divisin
Ahora,eldivisor,quehemosdesplazadotresvecesalaizquierda,lodesplazamosunavez a la derecha, es decir, como si del original lo desplazsemos dos veces a la izquierda. Por tanto Desplz=2. Probamos si cabe con el resultado de la resta anterior, si cabe (Dd) ponemosununoenelcociente.
10011101 -1101000 0110101 -110100 000001 1101 11 Desplz = 2
Volvemosadesplazareldivisoraladerecha(ahoraDesplz=1),yvolvemosaversicabeen lanuevarestaquehemoshecho.
10011101 -1101000 0110101 -110100 000001 11010 1101 110 No cabe Desplz = 1
Vemos que esta vez no cabe, por tanto pondremos un cero en el cociente, no hacemos la resta, y probamos desplazando el divisor a la derecha (ahora el Desplz=0, volvemos a comoestabaalprincipio)
172
10011101 -1101000 0110101 -110100 000001 1101
1101 1100 No cabe
Desplz = 0
Tampococabe,ycomoelcocientehavueltoasuposicinoriginal(Desplz = 0)ladivisin setermina(puesnosacamosdecimales).

10011101 -1101000 0110101 -110100 000001 1101 1100 cociente
resto
Ahora desplazando los restos a la izquierda podramos sacar decimales. En este caso podramossacarelprimerdecimalparacalcularelredondeodelcociente. Aspueslaimplementacinenhardwaredeestealgoritmodedivisinsepodrahacerde manera secuencial, pero tambin se podra desenrollar y realizarla de manera combinacionalosegmentada. Si se realiza de manera secuencial, la divisin se hara en varios ciclos de reloj, que depender del nmero de bits de los operandos. Por tanto, igual que con el multiplicador secuencial, el divisor necesitar de una parte de control que ordene la ejecucin de las operaciones que haya que realizar en cada momento. Una vez terminadas las operaciones deber proporcionar una seal de aviso que indique que el resultado est disponible. Adems,elmdulotendrunasealdeentradaqueordenelaejecucindeladivisin. Para este ejemplo no se va a incluir el esquema o el cdigo VHDL del divisor. Te recomendamosqueloimplementesportimismoyquehagaselbancodepruebas.Conla informacin sobre el algoritmo de divisin junto con las explicaciones del algoritmo de multiplicacin y los otros operadores de este captulo, pensamos que lo podras hacer por timismo. Incluso te proponemos que implementes una pequea calculadora en la FPGA. Metiendo losdatosporlospulsadoreseinterruptoresoporlaUART.Porejemplo,siusaslaNexys2, los interruptores podran ser los operandos y los botones la operacin: suma, resta, multiplicacinydivisin.Elresultadoseobtendraporeldisplaydesietesegmentos. Si usas la XUPV2P, como no hay tantos pulsadores ni interruptores, puedes realizar la operacin por la UART, introduciendo primero el primer operador, luego la operacin y por ltimo el segundo operador. El mayor problema aqu ser el control de lo que llega por la UART y la conversin en rdenes al mdulo que realiza la operacin. Para simplificar, te recomendamos que los nmeros que enves estn codificados en binario o en hexadecimal, pero no en decimal. Esto significa que desde el hiperterminal68 enviaras por ejemplo: 1110/11= E/3= en vez de 14/3=. Tu circuito debera devolver: 1000R10(enbinario)4R2(enhexadecimal).Eligeunadelasdosformas. Este circuito de divisin o calculadora por la UART tiene cierta complejidad debido al control, conversiones y la unin de varios mdulos, aparte de la propia complejidad del
68
Recuerdaelapartado7.6.3
173
divisor.Sinembargo,podraseruninteresanteproyectoqueunificaratodoloquehemos vistohastaahora.
174
9. Controlador de pantalla VGA

En esta prctica aprenderemos a disear un controlador para pantalla. Este controlador nos ser muy til para las siguientes prcticas, ya que permitir al sistema aumentar de maneraextraordinarialascapacidadesdeofrecernosinformacin Antes de explicar el funcionamiento de un controlador, piensa cmo puede un nico circuitoindicarelvalordecadaunodelospxelesdeunapantalla.Inclusoenpantallasde bajaresolucincomolasde640x480(640columnasy480filas)tenemosmsdetrescientos milpxeles. Evidentemente no se pueden controlar todos a la vez, y el mtodo par a controlarlo es similar al control del display de siete segmentos que se vio en el captulo 6 del libro [17mach].Esdecir,multiplexandoeneltiempo.Cadapxelseactivaduranteunapequea fraccin de tiempo y se refresca continuamente. Como esto ocurre a una velocidad muy elevada,nosotrosnonosdamoscuentaycreemosqueestncontinuamenteencendidos. Para controlar una la pantalla existen multitud de estndares. Mediante SVGA (Super Video Graphics Array) se conocen mltiples de estndares de visualizacin grfica de ordenadores. SVGA surgi despus del estndar VGA, y muchas veces se nombran de maneraindistinta(igualqueotrasvariantescomoXSGA).Estaspropuestasnoerannicas y cada fabricante propona temporizaciones diferentes. Posteriormente, VESA (Video Electronics Standards Association: http://www.vesa.org) defini un estndar para el video conelqueseintentaglutinarlaspropuestasdelosfabricantes. ElconectorVGAesdeltipomostradoenlafigura9.1,queeshabitual en los ordenadores actuales. Las seales y el control se definieron pensando en monitores de rayos catdicos, sin embargo, los Figura 9.1: Conector monitores digitales se han adaptado al mismo estndar para evitar VGA problemasdecompatibilidad. Para transformar las seales digitales de la FPGA en analgicas de estndar VGA se necesitan varios conversores digitalanalgicos. Estos conversores suelen estar integrados enunchipypuedenserbastantediferentesunosdeotros.Estoocurreconlosdelatarjeta XUPV2PylaNexys2. EnestecaptuloveremoselestndarVGA.Acontinuacinseresumirnlascaractersticas de los convertidores digitalanalgicos de las placas XUPV2P y Nexys2. Y por ltimo propondreldiseodeuncontroladorVGA.
9.1. Funcionamiento del estndar VGA

Para el control del monitor, la informacin de cada pxel de la pantalla se va enviando consecutivamente al ir barriendo toda la superficie por lneas horizontales y verticales. Cadapxelsecomponedetrescolores:rojo,verdeyazul. Las tres primeras seales de la tablas 9.2 y 9.3 indican la intensidad de cada color. Por ejemplo, si red=0 el pxel no contiene rojo, si por el contrario red=255 (o red=7 en la Nexys2)elpxeltieneelmximonivelderojo.
175
El envo de los valores de los pxeles se hace fila a fila empezando por el pxel de arriba a la izquierda y terminando con el pxel de abajo a la derecha (figura 9.2). Existen distintas resoluciones de pantalla, por ejemplo de 640 columnas x 480 filas (640x480) y otras ms habitualescomo800x6001024x768.
barrido horizontal pxel (0;0) pxel (0;639) Al llegar al final de la fila se sigue en el pxel de la izquierda de fila de abajo: pxel (1;0)
pxel (479;0)
pxel (479;639)
Figura 9.2: Pxeles en una pantalla con resolucin de 640x480
Para indicar el cambio de fila y el cambio de pantalla existen dos seales de sincronismo: sincronismo horizontal (hsynch) y vertical (vsynch). El sincronismo horizontal marca el finaldeunalneayelcomienzodeunanueva.Elsincronismoverticalmarcaelfindeuna pantalla y el comienzo de una nueva. La frecuencia de refresco viene dada por la frecuenciadelsincronismovertical. La figura 9.3 muestra las seales de sincronismo para el control de una pantalla VGA con 640x480 pxeles y una frecuencia de refresco de aproximadamente 60 Hz. Los tiempos se hanadaptadoaunafrecuenciade25MHz:cadapxeldura40ns.
640 pxeles
0 1 2 ..
639
25,6 s 1,92 s Sincronismo Horizontal hsynch 0,64 s
32 s 3,84 s
480 lneas
0 1 2 ..
479
480x32 s= 15,36 ms 0,992 ms Sincronismo Vertical vsynch 0,352 ms
16,768 ms (~60Hz)
64 s
Figura 9.3: Seales de sincronismo para una frecuencia de refresco de 60 Hz y 640x480 pxeles
176
Los valores de los tiempos son aproximados. Existe un estndar que define diversas frecuencias a las que normalmente se adaptan lo monitores, aunque como ya se ha dicho que varan segn el fabricante. Observa que hay intervalos de tiempo entre la seal de sincronismo y el envo de la informacin de los pxeles, a estos se les llama porches delanteroytrasero.Enlafigura9.4semuestranelporchetraseroydelantero(backporchy frontporch).
Porche trasero 48 pxeles
0 1 2 ..
imagen 640 pxeles

639
Porche delantero 16 pxeles
Sincronizacin 96 pxeles Sincronismo Horizontal hsynch Lnea: 800 pxeles Comienzo de lnea Reloj de 25 MHz: 32 s Fin de lnea
Figura 9.4: Cronograma de una lnea en pxeles
A veces, en el diseo digital las especificaciones no se dan en tiempos, sino que se da la frecuencia a la que salen los pxeles. Con esta frecuencia, se especifica el nmero de pxeles de los porches y las seales de sincronizacin para la sincronizacin horizontal, y el nmero de lneas para la vertical. Por ejemplo, en la figura 9.4 se muestra la especificacindelaslneasenpxelesynoentiempos. En la tabla 9.1 se muestran los valores para diversas resoluciones de pantalla. Todas las filas excepto la primera se corresponden con formatos propuestos por VESA. La primera fila de la tabla (sombreada) es una aproximacin de la segunda fila y es la que usaremos en nuestro diseo, para evitar una frecuencia de reloj de 25,175 MHz. En la figura 9.3 se han obtenido los tiempos tomando los mismos valores de pxeles de la segunda fila, aunque con una frecuencia de reloj ligeramente menor: 25 MHz, en vez de 25,175 MHz. Ya que, de hecho, con un reloj de 25 MHz se pueden tomar los valores de la segunda fila, yelcontroladortambinfuncionarenlamayoradelosmonitores.
Horizontal(enpxeles) Reloj Porche Vdeo Porche MHz Total Sincr. trasero activo delantero 640x480@60Hz 25 640 16 96 48 800 640x480@60Hz 25,175 640 16 96 48 800 800x600@60Hz 40,000 800 40 128 88 1056 800x600@72Hz 50,000 800 56 120 64 1040 1024x768@60Hz 65,000 1024 24 136 160 1344 1024x768@75Hz 75,000 1024 24 136 144 1328 Formato Vertical(enlneas) Porche Vdeo Porche Total Sincr. trasero activo delantero 480 9 2 29 520 480 11 2 31 524 600 1 4 23 628 600 37 6 23 666 768 3 6 29 806 768 3 6 29 806
Tabla 9.1: Valores para diversas resoluciones de pantalla
9.2. Conversores digital-analgico para VGA

Como estamos utilizando dos tarjetas electrnicas, a continuacin se resumen los convertidoresdeestasdosplacasysusentradas.
177
9.2.1. Conversor VGA de la XUPV2P

La tarjeta XUPV2P tiene un triple conversor digitalanalgico destinado a aplicaciones de video (FSM3818). Las salidas digitales de la FPGA correspondientes a cada color pasan por este circuito integrado y de all van al conector VGA. En esta tarjeta se utilizan 8 bits para cada color: rojo, verde y azul (RGB69). Por tanto, como cada color tiene 8 bits, tendremos 256 niveles distintos para cada color. Contando los tres colores, se tienen ms de16,7millonesdecolores(2563). LospinesdelaFPGAquecontrolanelvideosemuestranacontinuacin.Msadelantese explicarsufuncinconmsdetalle.
Puerto
red green blue pxl_clk
bits I/O pin
8 O 8 O 8 O 1 O H12
Descripcin Nivelderojodelpxel(de0a255).Pines:H10(bit7);C7;D7;F10;F9;G9; H9;G8(bit0) Niveldeverdedelpxel(de0a255).Pines:E11(bit7);G11;H11;C8;D8; D10;E10;G10 Niveldeazuldelpxel(de0a255).Pines:E14(bit7);D14;D13;C13;J15; H15;E15;D15 Relojdelconversor,quetendrunafrecuenciadiferentesegnla resolucinyfrecuenciarefrescoescogidas(tabla9.1) Siestacerohacequenosesaquenadaporpantalla(paracuandonose
vga_blank
1 O A8 usa).Sivaleuno,funcionanormalmente.Enlazonaenlaquenoseemite
informacinvisibleseponeacero.
hsynch
1 O B8 1 O D11
Sincronismohorizontal.Indicaelcambiodefila.Segnelestndarquese use,estasealpuedefuncionaranivelaltoobajo. Sincronismovertical.Indicaelcambiodepantalla(frecuenciaderefresco). Segnelestndarqueseuse,estasealpuedefuncionaranivelaltoobajo
vsynch
Conun1seaadecorrienteextraalconversordigitalanalgicodel verde.Sinoseactiva,losblancossevenrosadosporqueelverdenotiene comp_synch 1 O G12 tantaintensidad.Seponeaceroenlossincronismos70(horizontalesy verticales).Sinembargo,cuandoseactiva,avecessevenbrillosverdes extraos,asquealfinalpuedesalirmejorponerlasiempreacero. Tabla 9.2: Puertos del conversor VGA de la XUPV2P
9.2.2. Conversor VGA de la Nexys2

La tarjeta Nexys2 tiene un conversor digitalanalgico ms sencillo, con solo 10 bits frente a los 29 bits de la tabla 9.2. La Nexys2 tiene 8 bits para todos los colores, lo que hace que slotenga256coloresdistintos.Seemplean3bitsparaelrojo,3bitsparaelverdey 2bits para el azul, ya que parece que el ojo humano tiene menos sensibilidad para el azul. Adems de estos 8 bits, estn las seales de sincronismo vertical y horizontal, pero no se proporcionarelojcomoenlaXUPV2Pniotrassealescomovga_blankycomp_synch.
Puerto
red
bits I/O pin
Descripcin Nivelderojodelpxel(de0a7niveles). 3 O Pines:R8(bit2,mssignificativo);T8;R9(bit0,menossignificativo)
69 70
RGB:delassiglaseninglsdeloscolores:red,greenyblue Independientementedelniveldelossincronismoshsynchyvsych
178
green blue hsynch
3 O 2 O 1 O T4 1 O U3
Niveldeverdedelpxel(de0a7niveles). Pines:P6(bit2,mssignificativo);P8;N8(bit0,menossignificativo) Niveldeazuldelpxel(de0a3niveles). Pines:U4(bit1,mssignificativo);U5(bit0,menossignificativo) Sincronismohorizontal.Indicaelcambiodefila.Segnelestndarqueseuse, estasealpuedefuncionaranivelaltoobajo. Sincronismovertical.Indicaelcambiodepantalla(frecuenciaderefresco). Segnelestndarqueseuse,estasealpuedefuncionaranivelaltoobajo Tabla 9.3: Puertos del conversor VGA de la Nexys2
vsynch
Deestastablassepuedeobservarquelosconversoressonbastantedistintos.
9.3. Mdulo de sincronizacin

Con la informacin que tenemos podemos realizar un mdulo que genere las seales de sincronizacin para la pantalla VGA. Haremos un controlador con una resolucin de 640x480 pxeles a 25 MHz cada pxel, esto es, utilizaremos las especificaciones de la primera lnea de la tabla 9.1. Para estas especificaciones la polaridad de la sincronizacin es negativa, es decir, se pondr un cero cuando haya sincronismo (como se ha dibujado enlasfiguras9.3y9.4). Elbloquetendrelaspectodelafigura9.5.
SINCRO_VGA pxl_num line_num visible hsynch vsynch pxl_clk clk rst comp_synch
Figura 9.5: Entradas y salidas del sincronizador
Aunque las tarjetas XUPV2P y Nexys2 tengan distintos conversores, nosotros usaremos el mismo bloque y si lo tenemos que implementar en la Nexys2 simplemente dejaremos de usar los puertos que no sean necesarios. Las nicas diferencias importantes en la implementacinesquefuncionanadistintafrecuenciaderelojylaprofundidaddelcolor. Aparte del reset y el reloj, la mayora de las seales de la figura 9.5 estn en la tabla 9.2 9.3.Ladescripcindelospuertosquenoestnendichastablassemuestraenlatabla9.4.
Puerto
rst clk visible
bits I/O
Descripcin Sealderesetasncrono.LoharemosactivoanivelbajoenlaXUPV2Pyanivel 1 I altoenlaNexys2.
1 I Sealderelojdelaplaca.100MHzenlaXUPV2Py50MHzenlaNexyx2 1 O
Indicaconununosielmduloestenviandounpxelalapantalla.Siescerose esteneltiempodesincronismooporchedelanterootrasero(figura9.4) Indicaelpxel(columna),incluyetodoslospxeles,tantolosvisiblescomolos
pxl_num
10 O pxelesdelasincronizacinylosporches.Paraunaresolucindepantallade
640x480losvaloresirnde0a800(tomandolaprimerafiladelatabla9.3).
179
line_num
Indicalalnea(fila),incluyetodaslaslneas,tantolasvisiblescomolaslneasde 10 O lasincronizacinylosporches.Paraunaresolucindepantallade640x480los valoresirnde0a520(tomandolaprimerafiladelatabla9.3).
Tabla 9.4: Caractersticas de los puertos del mdulo de sincronizacin. El resto de puertos estn en las tablas 9.2 y 9.3
El mdulo de sincronizacin se puede realizar de muchas maneras. Nuestra recomendacineshacerlocontrescontadores,queseran:
Contadordeciclosdereloj:P_cont_clk.Cuentalosciclosderelojdecadapxel.Coneste contadorsepasadelafrecuenciadelrelojdelaFPGAalafrecuenciadecadapxel71.Con este mtodo slo el posible lograr las frecuencias que dividan (divisin entera) a la frecuenciadereloj. Contadordepxeles:P_cont_pxl.Cuentalospxelesdecadalnea. Contadordefilas:P_cont_line.Cuentalaslneasdecadapantalla.
Te recomendamos que cada contador sea un proceso secuencial independiente en el que slo se asigne la cuenta y que las seales que dependen de cada cuenta se asignen en un proceso combinacional aparte. Ya que si se ponen las seales dentro del proceso secuencial del contador se sintetizarn biestables y estarn retardadas respecto a la cuenta. La figura 9.6 esquematiza el sincronizador. Como se puede observar, los procesos secuenciales nicamente llevan la cuenta, mientras que los procesos o sentencias combinacionales generan el resto de las seales. Ten cuidado de no generar latches en los procesoscombinacionales(recuerda2.5).
Procesos o sentencias combinacionales
pxl_clk hsynch visible hsynch visible_pxl cont_pxl new_line visible_line vsynch cont_line comp_synch vsynch comp_synch
pxl_clk cont_clk new_pxl new_pxl clk cont_clk clk rst
cont_pxl
new_line clk rst
cont_line
rst P_cont_clk
P_cont_pxl
10
P_cont_line line_num pxl_num
Procesos secuenciales
contador de ciclos de reloj
contador de pxeles (columnas)
contador de lneas (filas)
Figura 9.6: Esquema del sincronizador
El proceso contador de ciclos de reloj (P_conta_clk) ser diferente si utilizamos la placa XUPV2P o la Nexys2, ya que sus relojes tienen distinta frecuencia y por lo tanto, la cuenta ser distinta. Esto lo podemos ver en las siguientes figuras: la figura 9.7 muestra el
71
indicadoenlasegundacolumnadelatabla9.3
180
cronograma de lo que queremos hacer si tenemos la XUPV2P y la figura 9.8 muestra el cronogramaparalaNexys2.
10ns f=100 MHz 0 1 2 3 0 1 2 3 0 f=25 MHz f=25 MHz 40 ns
20ns f=50 MHz 0 1 0 1 0 f=25 MHz f=25 MHz 40 ns
clk cont_clk pxl_clk new_pxl
clk cont_clk pxl_clk new_pxl
Figura 9.7: Cronograma del contador de ciclos de reloj para la XUPV2P (100 MHz)
Figura 9.8: Cronograma del contador de ciclos de reloj para la Nexys2 (50 MHz)
ComolaXUPV2Pvaa100MHzyqueremosqueenviaralaVGAlospxelescada25MHz (recuerda la primera fila de la tabla 9.1), cada pxel durar 4 ciclos de reloj. Por otro lado, comolaNexys2vaa50MHz,cadapxelsemantendrdurante2ciclosdereloj. En los cronogramas se ha incluido una seal new_pxl que avisar al siguiente contador P_cont_pxl (que cuenta los pxeles) que aumente un pxel. Podemos observar que en el caso de la Nexys2 esta seal coincide con pxl_clk. Aunque la Nexys2 no necesita la seal pxl_clk,lamantendremos. As que el proceso que cuenta los ciclos de reloj (P_cont_clk) contar cuatro o dos ciclos segn tengamos la tarjeta XUPV2P o la Nexys2. Lo ideal sera declarar el fin de cuenta medianteunaconstanteenunpaquete,yquealcambiardetarjeta,sloquetengamosque cambiarlasconstantesdelpaquete. Por otro lado, como podemos ver en la tabla 9.1, tenemos que tener en cuenta muchos valores para el control de la VGA. As que antes de empezar a describir el VHDL del sincronizador es conveniente declarar como constantes todos esos valores del control VGA que hemos escogido (primera fila de la tabla 9.1). Como vimos en el captulo 6, el usodeconstantesesmuyrecomendable.Ennuestrocaso,debidoaquehaytantosvalores distintos,serecomiendaelusodeconstantespor:
Claridad: si en el cdigo VHDL en vez de poner 640 ponemos c_pxl_total, ser ms fcil entender que nos referimos al nmero de pxeles totales. Un cdigo ms claro facilitalareutilizacinydisminuyelaposibilidaddeequivocarnos. Facilidadparacambiar:siqueremoscambiarelvalordeunaconstante,slotenemosque cambiar su valor en la declaracin, en vez de buscarla por todos los ficheros en los que est. Esta ltima manera de hacerlo adems de implicar mucho ms esfuerzo en la bsqueda, favorece la aparicin de errores ya que tambin hay constantes encubiertas. Es decir, habra que buscar y rehacer las operaciones con esas constantes. Por ejemplo, habraquebuscaryrecalcularun639quevendradec_pxl_total-1.
Como ya vimos, para poder usar las constantes sin tener que redeclararlas en todos los ficheros VHDL, conviene poner todas las constantes de la VGA en un paquete. Este paquetelopodremosusarentodoslosdiseosdelaVGA,y ademsnossermuchoms fcildemodificareldiseosiqueremoscambiarlaresolucindelapantalla. En el cdigo 9.1 se muestra cmo se podra hacer el paquete de la definicin de las constantes.Estasconstantesestnbasadasenlaprimerafiladelatabla9.1.
181
Enestepaqueteseutilizanfuncionesqueyahemosutilizado,comolog2i(cdigo7.4).Por lo tanto habra que incluir otro paquete ms general con estas funciones. No hace falta usarestafuncinypuedesasignardirectamenteelvaloralasconstantes,queenestecaso es10.Estosdospaqueteslospuedesdescargarenladireccindelareferencia[28web].
package VGA_PKG is -- Orden: -- 1) video activo, 2) porche delantero, 3) sincro 4) porche trasero -- Empezamos por el visible para que sea mas facil saber en que pixel visible -- estamos, ya que si no, habria que realizar una resta -- Por ejemplo para 640x480@60 Hz: ---------- Pixeles (horizontal, columnas) ---------------------------------| -- | | | | | -- | video activo | porche | sincro | porche | -- | | delantero | horizontal | trasero | -- | | | | | -- |<--------- 640 -------->|<--- 16 ---->|<------ 96 ----->|<---- 48 ---->| -- | | | | | -- | c_pxl_visible |c_pxl_fporch | c_pxl_synch | c_pxl_bporch | -- | | | | | -- | | | | -- |<----- c_pxl_2_fporch: 656 ---------->| | | -- | | | -- |<------------- c_pxl_2_synch: 752 --------------------->| | -- | | -- |<------------------------- c_pxl_total: 800 -------------------------->| -- Pixeles (horizontal o columnas): constant c_pxl_visible : natural := constant c_pxl_fporch : natural := -- del inicio hasta el porche delantero: constant c_pxl_2_fporch : natural := constant c_pxl_synch : natural := -- del inicio hasta la sincronizacion: constant c_pxl_2_synch : natural := -- total de pixeles horizontales: constant c_pxl_total : natural := -- el porche trasero: constant c_pxl_bporch : natural := -- Filas (vertical): constant c_line_visible constant c_line_fporch constant c_line_2_fporch constant c_line_synch constant c_line_2_synch constant c_line_total constant c_line_bporch
640; 16; c_pxl_visible + c_pxl_fporch; -- 656 96; c_pxl_2_fporch + c_pxl_synch; -- 752 800; c_pxl_total - c_pxl_2_synch; -48
: : : : : : :
natural natural natural natural natural natural natural
:= := := := := := :=
480; 9; c_line_visible + c_line_fporch; -- 489 2; c_line_2_fporch + c_line_synch; -- 491 520; c_line_total - c_line_2_synch; -- 29
-- numero de bits para la cuenta de pixeles(columnas) y lineas (filas) -- el logaritmo devuelve un bit menos, por eso se pone + 1 -- y hay que ponerle un -1, porque en el caso de que la cuenta sea justo -- potencia de dos, vale con un bit menos, porque se cuenta el cero -- por ejemplo, 8: log2i(8)= 3 | + 1 = 4, pero con 3 bits, tengo de 0 a 7 (cuento 8) -7: log2i(7)= 2 | + 1 = 3 constant c_nb_pxls : natural := log2i(c_pxl_total-1) + 1 ; --Para 640x480 es 10 constant c_nb_lines: natural := log2i(c_line_total-1) + 1 ; --Para 640x480 es 10 -- numero de bits para cada color (RGB) constant c_nb_red : natural := 8; -constant c_nb_green : natural := 8; -constant c_nb_blue : natural := 8; -Para la XUPV2P 3 para la Nexys 3 para la Nexys 2 para la Nexys
-- frecuencia de la VGA constant c_freq_vga : natural := 25*10**6; -- VGA 25MHz -- nivel activo de sincronismo constant c_synch_act : std_logic := '0'; -- Para 640x480 end VGA_PKG;
Cdigo 9.1: Paquete con la definicin de las constantes del controlador VGA
Observa en el paquete del cdigo 9.1 que la cuenta est referida a partir del video activo, en vez de empezar la lnea con el sincronismo horizontal (como se mostraba en la figura
182
9.4). En realidad al monitor VGA le da igual por donde se empiece a contar, ya que son seales peridicas. Al monitor le es indiferente que lo primero que le enviemos sean los pxeles visibles o los de sincronismo. De hecho, probablemente la primera pantalla que enviemos no se muestre y el monitor necesite recibir varias seales de sincronismo antes demostraralgoporpantalla.Delamismamaneraquepodemosconectarunmonitoraun ordenador en cualquier momento (y no justo cuando se enve la seal de sincronismo), nosotrospodemosempezarlacuentapordondequeramos siemprequemantengamoslas frecuenciasapropiadas. Debidoaquenoesunproblemadondeseempiezalacuenta,recomendamosempezarlaa partirdelospxelesvisibles72.Laventajadeestoesquelacuentasecorresponderconlas coordenadas en la pantalla. Es decir, si la cuenta de pxeles (pxl_num) es 80 y la de lneas (line_num) es 40, se est dibujando en la pantalla el pxel de la columna 80 y de la fila 40(73). Si comenzsemos la cuenta en otro punto, tendramos que restar para saber la correspondenciaentrelacuentadepxelesylascoordenadasenlapantalla74. La figura 9.9 muestra el cronograma de la cuenta de pxeles cuando se empieza desde los pxelesvisibles.
visible pxl_num hsynch
... 798 799 0 1 2 ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... 639 640 ,,, ... 655 656 ... ... ... ... ... 751 752 ... ... ... 798 799 0 1 ...
visible: 640 pxeles Comienzo de lnea
porche delantero: 19 pxeles
sincronizacin horizontal: 96 pxeles
porche trasero: 48 pxeles
fin de lnea
lnea: 800 pxeles
Figura 9.9: Cronograma de la cuenta de pxeles comenzando desde los pxeles visibles
As pues, con las indicaciones que se han dado, crea el mdulo sincro_vga. Una vez que lo tengas, simlalo. La creacin del banco de pruebas es sencilla, pues las nicas entradas sonelrelojyelreset.Lacomprobacindelasimulacinesmsdifcil,pueshayquemedir y comprobar que las cuentas y los tiempos se cumplen. En la figura 9.3 podemos ver que como la frecuencia de refresco es de 60 Hz, los sincronismos verticales deberan aparecer aproximadamente cada 17 ms. Por lo tanto, con 55 ms de simulacin debera ser suficiente, para cubrir tres refrescos de pantalla. En la comprobacin de la simulacin debers observar si se cumplen los tiempos de la figura 9.3, tanto de los pxeles como de laslneas.
9.4. Implementacin de un controlador VGA sencillo

Una vez que tenemos el sincronizador, lo hemos simulado y hemos comprobado que las cuentasytiempossoncorrectos,podemospasaraprobarloconunmonitorreal.
72 73 74
Ylacuentadelneasapartirdelaslneasvisibles Considerandolacolumnaceroladelaizquierdaylafilaceroladearriba(figura9.2) Estasrestastampocosonungranproblema,peroalfinalelcdigoquedamenosclaroyeldiseoms sencillo
183
Para ello utilizaremos el sincronizador y lo incluiremos dentro de un mdulo estructural demsaltonivel(VGA_SIMPLE).Dentrodeestemduloestructuralincluiremosunmdulo (PINTA_BARRAS) que se encargar de dibujar unas barras de colores en el monitor que nos permitirn comprobar el correcto funcionamiento del sincronizador. El esquema estructuraldeldiseoquequeremosimplementarsemuestraenlafigura9.10.
VGA_SIMPLE PINTA_BARRAS
10 8
pxl_num
10
red green blue

8 8
red green blue
line_num visible
SINCRO_VGA pxl_num line_num visible hsynch vsynch pxl_clk clk rst clk c lk rst comp_synch
vga_blank hsynch vsynch pxl_clk comp_synch
Figura 9.10: Esquema de bloques del controlador VGA sencillo
Las salidas son las que controlan la VGA y ya se explicaron en el apartado 9.2. Este esquema es para la XUPV2P, ya que la Nexys no necesita tantas seales y el ancho de bus delassealesdelcoloresmenor. El mdulo PINTA_BARRAS pondr un color diferente segn la columna de la pantalla en la que se est. Como hemos puesto la cuenta de los pxeles y lneas coincidentes con las columnas y filas de la pantalla, no hay que hacer ninguna conversin. Cuando visible sercero,pondrelcoloranegro(todocero). El cdigo 9.2 muestra el cdigo de la arquitectura del mdulo PINTA_BARRAS. Este proceso est orientado para la XUPV2P, aunque funciona para la Nexys2 si las constantes estn biendefinidas.
architecture behavioral of pinta_barras is constant c_bar_width : natural := 64; begin P_pinta: Process (visible, pxl_num, line_num) begin red <= (others=>'0'); green <= (others=>'0'); blue <= (others=>'0'); if visible = '1' then -- linea blanca de 1 pixel en los bordes if pxl_num = 0 OR pxl_num = c_pxl_visible -1 OR line_num=0 OR line_num= c_line_visible -1 then red <= (others=>'1'); green <= (others=>'1'); blue <= (others=>'1'); elsif line_num >= 256 and line_num < 256 + c_bar_width then -- esto solo tiene sentido para la XUPV2P red <= std_logic_vector(pxl_num(c_nb_red-1 downto 0)); green <= std_logic_vector(pxl_num(c_nb_green-1 downto 0)); blue <= std_logic_vector(pxl_num(c_nb_blue-1 downto 0)); if pxl_num >= 256 then red <= std_logic_vector(pxl_num(c_nb_red-1 downto 0)); green <= std_logic_vector(resize(255-pxl_num(7 downto 0),c_nb_green)); blue <= (others=>'0'); end if; if pxl_num >= 512 then -- rayas horizontales red <= (others=>not(line_num(0))); green <= (others=>not(line_num(0))); blue <= (others=>not(line_num(0)));
184
end if; elsif line_num >= 256+c_bar_width and line_num < 256 + 2*c_bar_width then red <= std_logic_vector(resize(255 - pxl_num(7 downto 0),c_nb_red)); green <= std_logic_vector(resize(255 - pxl_num(7 downto 0),c_nb_green)); blue <= std_logic_vector(resize(255 - pxl_num(7 downto 0),c_nb_blue)); if pxl_num >= 256 then red <=std_logic_vector(resize(255 - pxl_num(7 downto 0),c_nb_red)); green<=(others=>'0'); blue <= std_logic_vector(pxl_num(c_nb_blue-1 downto 0)); end if; if pxl_num >= 512 then -- puntos red <= (others=>pxl_num(0) xor line_num(0)); green <= (others=>pxl_num(0) xor line_num(0)); blue <= (others=>pxl_num(0) xor line_num(0)); end if; elsif pxl_num/c_bar_width = 0 then -- columna 0 sera blanca, columna 1 negra, ... red <= (others=>not(pxl_num(0))); green <= (others=>not(pxl_num(0))); blue <= (others=>not(pxl_num(0))); elsif pxl_num/c_bar_width = 1 then --blanco red <= (others=>'1'); green <= (others=>'1'); blue <= (others=>'1'); elsif pxl_num/c_bar_width = 2 then --amarillo red <= (others=>'1'); green <= (others=>'1'); blue <= (others=>'0'); elsif pxl_num/c_bar_width = 3 then --cian red <= (others=>'0'); green <= (others=>'1'); blue <= (others=>'1'); elsif pxl_num/c_bar_width = 4 then --verde red <= (others=>'0'); green <= (others=>'1'); blue <= (others=>'0'); elsif pxl_num/c_bar_width = 5 then --magenta red <= (others=>'1'); green <= (others=>'0'); blue <= (others=>'1'); elsif pxl_num/c_bar_width = 6 then --rojo red <= (others=>'1'); green <= (others=>'0'); blue <= (others=>'0'); elsif pxl_num/c_bar_width = 7 then --azul red <= (others=>'0'); green <= (others=>'0'); blue <= (others=>'1'); elsif pxl_num/c_bar_width = 8 then --negro red <= (others=>'0'); green <= (others=>'0'); blue <= (others=>'0'); else -- columna 639 sera blanca, 638 negra, ... red <= (others=>pxl_num(0)); green <= (others=>pxl_num(0)); blue <= (others=>pxl_num(0)); end if; end if; end process; end Behavioral;
Cdigo 9.2: Proceso que asigna colores segn el pxel
Lo que se muestra en la pantalla son unas barras verticales de colores a modo de carta de ajuste. La figura 9.11 muestra el resultado para la XUPV2P, como la Nexys2 tiene menor profundidad de color, las barras horizontales son distintas75 (slo hay una barra horizontal).
75
Enlapginawebdelareferencia[28web]puedesdescargarteficheromsadecuadoparalaNexys2.
185
640 pxeles
480 pxeles
Figura 9.11: Carta de ajuste que debe mostrarse por pantalla para la XUPV2P
Sinoconsiguesvernada,probablementeelsincronismoestmal.Aunquetambinpuede ser por cualquier otro motivo, tendrs que hacer las comprobaciones que ya sabes: pines, conexiones de seales, cables,... Tendrs tambin que hacer un banco de pruebas para todo el diseo, comprobando que los puertos red, green y blue, se ponen en los valores fijadossegnenelpxelylalneaenlaqueseest. Una vez que consigas mostrar la carta de ajuste por la pantalla, debes comprobar que las barrassedibujancorrectamente.Comprueba:
Que se dibuja un marco de color blanco de un pxel de ancho en los cuatro bordes, muchas veces falta algnborde por pintar en blanco, o algunosde los bordes tiene ms de un pxel de ancho. Como la resolucin de la pantalla es baja, los pxeles se puede distinguir. Quelasbarrasverticalestienenelmismoancho Quelasbarrasverticalesdelaizquierdayderechaestnformadasporlneasalternativas deblancoynegro. Los colores de las ocho barras verticales: blanco, amarillo, cian, verde, magenta, rojo, azul y negro. Si el blanco no es blanco sino rosado puede ser porque no tienes la seal comp_synch correctamente (tabla 9.2), pero tambin puede ser que el monitor est viejo. Comprueba que el monitor muestra los colores correctamente conectndolo a un ordenador76. Si los colores no se corresponden, comprueba que tienes los pines y las conexionesbienhechas. Queenlascuatrobarrashorizontalesnohaysaltosbruscosdecolor(siusaslaXUPV2P). Siloshubiese,esposiblesquealgnpuertonoestconectadoalpinadecuado. Laslneashorizontalesblancasynegrasdelabarrahorizontaldeladerecha(ladearriba) Lospxelesblancosynegrosalternadosenlabarrahorizontalqueestabajoaladerecha.
Haz los cambios para que se vea la carta de ajuste correctamente, quiz tengas que simularyverlosvaloresdeloscoloresenlasfilasycolumnasdondetengaslosproblemas
76
Tambinlopuedescomprobarsielmonitormuestraunaimagencuandoestandoencendidonoest conectadoaningncableVGA
186
10. Videojuego de tenis

En esta prctica utilizaremos el controlador VGA de la prctica anterior para disear uno de los primeros videojuegos que se desarrollaron y se hizo muy popular a principios de losaossetenta.Estevideojuegoestbasadoeneltenisdemesa(pingpong)yporestofue comercializadoconelnombrePongporlaempresaAtari. En el videojuego hay un recuadro que marca los lmites del campo de juego. Dentro de estecampohaydosbarrasverticales,unaaladerechayotraalaizquierdadelcampo,que representanalosdosjugadores.Hayunapelotaquevadeunjugadoraotro(figura10.1). La pelota puede rebotar en las paredes superior e inferior, pero si sobrepasa a los jugadoresyalcanzalasparedesverticalessergol.
Figura 10.1: Campo de juego
Las barras verticales pueden moverse verticalmente dentro de los lmites del campo de juego. En un principio, estas barras se mueven por la pulsacin de los pulsadores de la placa. Posteriormente se podrn controlar por el teclado PS/2 conectado a la placa (captulo 11). Cada jugador tiene dos teclas: una para ir arriba y otra para ir hacia abajo. Si no se pulsa ningunateclaosepulsanambasnohabrmovimiento. La figura 10.2 muestra un esquema de la implementacin del videojuego. Este esquema tienetresbloques:
SINCRO_VGA:sincronizadordelaVGAquehemosrealizadoenlaprcticaanterior INTERFAZ_PB:interfazconlospulsadoresdelaplaca PONG:encargadodelcontroldeljuego,movimientodepelotayjugadores,ydemostrarlo
porpantalla.
187
TOP_PONG INTERFAZ_PB pb_1 pb_2 pb_3 pb_4 pb_1 pb_2 pb_3 pb_4 clk rst jugizq_sube jugizq_baja jugdcha_sube jugdcha_baja
10
PONG jugizq_sube jugizq_baja jugdcha_sube jugdcha_baja

8
pxl_num
10
red green blue

8 8
red green blue
line_num visible
SINCRO_VGA pxl_num line_num visible hsynch vsynch pxl_clk clk rst clk rst comp_synch
clk
rst vga_blank hsynch vsynch pxl_clk comp_synch
Figura 10.2: Esquema de bloques del juego de tenis controlado por los pulsadores
Como siempre, se recomienda realizar el diseo por pasos, de manera que podamos ir comprobandoquetodovafuncionandocorrectamentedemaneraindependiente. Asquelospasospodrnser:

Dibujaryhacermoveraunjugadorporsuzonaapartirdelapulsacindesusbotones. Incluirelsegundojugadorycomprobarquesemuevendemaneraindependiente Dibujar y mover una pelota de manera permanente por el campo de juego, sin interaccinconlosjugadores Incluirlainteraccindelosjugadoresconlapelotaeincluirelgolalalcanzarlosbordes laterales
Acontinuacinsedarnalgunasindicacionesparaeldiseodeestasetapas.
10.1. Control de los jugadores

Como hemos dicho, vamos a ir por partes en el diseo. As que primero vamos delimitar el campo de juego. Este circuito es muy sencillo y ya hemos realizado algo similar. El diseo ser ms sencillo que la carta de ajuste que hicimos (figura 9.11). Pintaremos un campo de juego. Se recomienda limitar el campo de juego mediante constantes. De esta manera que podamos modificar su tamao fcilmente. As pues, la primera tarea ser dibujar el campo de juego, puedes elegir los colores que quieras. Pinta los lmites del campo de juego con ms de un pxel de ancho, para que se vea bien. Realizaremos el diseo, lo implementaremos en la FPGA para asegurarnos que tenemos el primer paso correctamente. Con el campo de juego definido, ahora dibujaremos los jugadores. Mejor empieza con un jugador,luego,cuandotefuncionepuedespasaralotro. En la figura 10.3 se muestran las dimensiones y coordenadas del jugador izquierdo respecto a la esquina superior izquierda. Esta esquina se considera el punto de coordenadas(0,0),ycoincideconelpxel0delalnea0delsincronizador(figura9.2).
188
c_coljug punto (0,0) columna: 0 fila: 0 Columnas
filajugizq c_altojug
c_anchojug
no es una constante, su valor se guardar en un registro
c_anchoborde
Filas
Figura 10.3: Coordenadas y medidas del jugador izquierdo en el campo
En la figura 10.3 todos los nombres que empiezan por c_ indican constantes. Estas constantes conviene declararlas para que sea fcil de cambiar. Observa que la fila del jugador (filajugizq) no es una constante, sino que ste va a ser el valor que va a cambiar duranteeljuegoyaqueeljugadorsepodrmoverhaciaarribayabajo. Se ha referido la posicin del jugador con el registro filajugizq y la constante c_coljug. Estas coordenadas se han considerado como el centro del jugador (figura 10.3). Para calcularloscuatrobordesdeljugadortendremosquesumarorestaralascoordenadas,las dimensiones divididas entre dos. Debido a esta divisin, es conveniente que las dimensiones del jugador sean un nmero par. Los bordes para el jugador izquierdo sern77:

Filadelbordesuperior(variable): Filadelbordeinferior(variable):
filajugizq - c_altojug/2 filajugizq + c_altojug/2 c_coljug - c_anchojug/2 c_coljug + c_anchojug/2
Columnadelbordeizquierdo(constante): Columnadelbordederecho(constante):
De estos bordes, como slo se mueve verticalmente, las filas sern variables y las columnasconstantes. Con estos valores, antes de empezar a mover el jugador, dibuja un jugador en la pantalla poniendosufilacomounaconstantequeluegocambiars. Una vez que tienes un jugador dibujado (o los dos), podemos empezar a moverlos. Primero debes de escoger los pulsadores de cada jugador y en qu sentido lo desplazan. Haz esto de modos que sean cmodos e intuitivos. Es decir, no elijas los pulsadores de la derecha para el jugador izquierdo, ni tampoco elijas como pulsador de un jugador uno queestentrelospulsadoresdelotrojugador. Tienes que definir el funcionamiento del movimiento de los jugadores en relacin con los pulsadores.Esdecir,podemosescogerentreestasdosopciones:
77
Enrealidad,conestasfrmulaselanchorealesunpxelmsanchoquelaconstante.Aunqueluegodepende delascondicionesysiseponencomparacionesdemayorymenor,omayorigualymenorigual.
189
El jugador se mueve slo al pulsar, pero si mantenemos pulsado el pulsador, no contina el movimiento. Es decir tenemos que pulsar y soltar consecutivamente para movereljugador. Eljugadorsemuevedemaneracontinuamientrasmantenemoselpulsadorpresionado
Para la primera opcin tendramos que realizar un detector de flanco. Recuerda el cdigo 2.16 y la figura 2.13 en la que se puede ver cmo se transforma una pulsacin larga en un nico pulso de reloj78. Si lo hacemos de esta manera tendremos que pulsar muchas veces paramovereljugadorytendremosquevariarenmsdeunpxellaposicindeljugador, ya que de otra manera el movimiento ser muy lento (pxel a pxel). Podemos tardar ms dediezsegundosenirdelbordesuperioralinferior. Con la segunda opcin se consigue un movimiento ms rpido, pero tan rpido que hay queralentizarlo.Nopodemoscambiarlaposicindeljugadorcadacicloderelojenelque tengamos presionado el pulsador. Si lo hacemos as, el jugador ir tan rpido que ni lo veremos, y pasar de estar en un extremo al otro (eso si estn bien los controles del jugador para que se mantenga dentro del campo de juego). As que para este caso la solucin est en muestrear la seal cada cierto tiempo (entre 5 y 10 ms son valores razonables). Tendremos que realizar un contador que al terminar su cuenta enve una seal de aviso para que se comprueben las seales de los pulsadores, si alguno est activado,deberenviarunpulso79deuncicloderelojalmduloPONGparaqueaumenteo disminuya en una lnea la posicin del jugador. Es importante volver poner las seales a cerodespusdemuestrear,porquesino,denuevoirmuyrpidoeljugador. Estasegundaopcinquedamejorynoesmsdifcildehacerquelaprimera. Tenencuentaningunapartedeljugadordebesobrepasarloslmitesdelcampo,portanto, para controlar la posicin del jugador debes tener en cuenta su altura y dnde estn los bordes. Por ejemplo, se debe de impedir que suba el jugador cuando est en el borde superior. En el caso de que el movimiento sea con los flancos hay que tener ms cuidado en el control de que el jugador no se salga del campo porque el movimiento es en saltos de variaslneas,ypuedeserquesaltefueradelcampo.
10.2. Pelota que rebota

Una vez que tenemos a los jugadores vamos a incluir la pelota. En la primera versin la pelota y los jugadores van a ser independientes. La pelota rebotar en las cuatro paredes del campo de juego y no chocar con los jugadores. La pelota ser cuadrada y tendr un anchopardefinidoenlasconstantesdelmdulo(c_anchobola). La pelota puede variar tanto su fila como columna, no como los jugadores que slo podan variar su fila. Por lo tanto se necesitan dos registros para guardar sus coordenadas. Pero tambin necesitamos un registro que guarde la direccin del movimientodelapelota.
78 79
Tambinhicimosundetectordeflancoeneltransmisor,recuerdalafigura7.27 Estassealesson:jugizq_sube,jugizq_baja,jugdcha_subeyjugdcha_baja
190
Para simplificar, limitaremos el movimiento de la pelota a las cuatro direcciones mostradas en la figura 10.4. Estas direcciones las llamaremos NO, NE, SE y SO, que corresponden con las direcciones noroeste, noreste, sureste y suroeste respectivamente. EnVHDL,estascuatrodireccioneslaspodemosdeclararcomoun enumerado.
NO
NE
SO
SE
Figura 10.4: cuatro direcciones de la pelota
La pelota seguir la misma trayectoria hasta que alcance uno de los bordes. Al llegar a stos cambiar la direccin tomando la direccin simtrica. La figura 10.5 muestra dos ejemplos de cambios de trayectoria de la pelota. El resto de choques son fcilmente deduciblesapartirdestos.
SE SE NE SO
Figura 10.5: Ejemplos de cambios de trayectoria de la pelota al chocar con las paredes
Igualqueenelcasodelosjugadores,laposicindelapelotanopuedecambiarcadaciclo de reloj. Tendremos que crear un contador de modo que cada cierto tiempo su posicin vare. Este tiempo puede ser del mismo orden de magnitud que el de muestreo de los jugadores.Cadavezqueelcontadoravisequesellegaalfindecuenta,sedebecomprobar que, siguiendo su trayectoria, la pelota no choca con los bordes. Si la pelota no choca se cambiar su fila y columna en un pxel segn la direccin indicada por la trayectoria. En el caso de haya choque, la pelota cambiar su trayectoria, y el cambio de fila y columna seguirlanuevatrayectoria. Puede pasar que cuando la pelota choca, si no cambias la fila y columna de manera consecuente con la nueva trayectoria, la pelota se quede enganchada en un borde. En este caso debes revisar las condiciones de choque y asegurarte que en el momento del choque se cambien la fila y columna segn la nueva trayectoria y no con la trayectoria anterior al choque. Al principio y despus de cada gol, la pelota puede salir del centro del campo, con una direccin pseudoaleatoria. Para conseguir que sea lo ms aleatorio posible hay que hacer depender el valor de algo aleatorio, por ejemplo, un contador que dependa de la ltima vezquesehaempezadoapulsarcualquieradelospulsadores.
10.3. Videojuego
Uniendolosjugadoresylapelotaconstruiremoslaprimeraversindelvideojuego.Ahora la pelota estar limitada por los jugadores y no por los lmites verticales (izquierdo y derecho) del campo. Si la pelota llega a uno de los bordes verticales del campo de juego significaqueeljugadorcontrariohametidogol. Estediseosepuedemejorarenmuchosaspectos:
191
Aumentar el nmero de direcciones y aadir efectos, por ejemplo, si choca con un jugadorquetienevelocidad Variarlavelocidaddelapelota. Aadir un marcador que cuente los goles de cada jugador. Si quieres hacer esto sera mejor que esperes a ver el captulo de pintar caracteres por pantalla (captulo 13). Aunquenoestmalquelopiensesantesdeverelcaptulo. MoverlosjugadoresconuntecladoPS/2,loveremosenelcaptulosiguiente. Poner una pelota redonda y jugadores menos rudimentarios. Lo veremos en el captulo dedibujarunaimagenporpantalla(captulo12).
Y cualquier otra idea que se te ocurra, sin embargo, a no ser que tengas un determinado inters, no es necesario hacer mejoras que no impliquen ningn aprendizaje nuevo. Para el objetivo de aprendizaje de este libro, no tiene mucho sentido mejorar el diseo a base deaadirmuchasmscondicionesenlosprocesossinms.
192
11. Puerto PS/2

ElpuertoPS/2seutilizaparaconectareltecladoyelratnalordenador.Aunquecadavez se usa menos desde la aparicin de los teclados y ratones USB, todava se ven muchos ordenadoresconestosconectores. El conector PS/2 consta de 6 pines, que es de tipo miniDIN (figura 11.1). El conector del teclado puede tener un color violeta o morado y el del ratn puede ser verde, aunque a vecesnotienenuncolorespecfico. El puerto PS/2 consta de cuatro cables: la alimentacin (4,5 5,5V), la tierra, el dato y el reloj. La comunicacin se realiza con las lneas de dato y reloj. La comunicacin se realiza entre un dispositivo: el teclado o el ratn, y la computadora o la FPGA(elhost).
Figura 11.1: Conector PS/2
El teclado y ratn PS/2 implementan un protocolo serie bidireccional sncrono con la computadora. El bus est en espera (idle) cuando ambas lneas (dato y reloj) estn a uno. Lacomputadoratieneelcontrolltimosobreelbus,pudiendoinhibirlacomunicacinen cualquiermomentoponiendounceroenlalneadereloj. El teclado puede funcionar de forma unidireccional, de modo que la computadora simplemente reciba las tramas del teclado. Sin embargo, para el funcionamiento del ratn se requiere un modo bidireccional. Por tanto, el funcionamiento del teclado es ms sencilloqueeldelratnyporestoseexplicarantes. Atencin: No se recomienda conectar un dispositivo PS/2 con el ordenador encendido. Por si acaso, te recomendamos que sigas la misma recomendacin cuando conectes el dispositivoalaplacadelaFPGA,esdecir,quelosconectesconlaplacaapagada.
11.1. Teclado PS/2

Como slo necesitamos recibir las tramas del teclado PS/2, realizaremos un receptor de tecladoPS/2,dejandoeltransmisorparaelratnPS/2. Las tramas enviadas por el protocolo PS/2 son de 11 bits, teniendo un bit de inicio, 8 bits de dato, un bit de paridad impar y un bit de fin. De manera similar al protocolo RS232, la lneadedatossemantieneavalorlgico1cuandoestinactiva,siendoelbitdeinicioun cero y el bit de fin un uno. Los ocho bits de datos se envan empezando por el menos significativo. El bit de paridad impar estar a uno si hay un nmero par de unos en los 8 bits de datos, y estar a cero si hay un nmero impar. Por tanto, contando los 8 bits de datos ms el bit de paridad, deber haber un nmero impar de unos (por eso es paridad impar). Esto se utiliza para detectar errores. La figura 11.2 muestra el cronograma de un envodeltecladoalacomputadora.
193
Lectura en los flancos de bajada clkps2
dataps2
b0
b1
b2
b3
b4
b5
b6
b7
bit de fin
reposo a '1'
bit de inicio a '0'
paridad impar
dato de 8 bits
reposo a '1'
Figura 11.2: Cronograma general de la transmisin del puerto PS/2
Podemos ver que la transmisin es muy parecida a la de la UART, la diferencia ms importante es que el PS/2 tiene dos lneas: la de datos (dataps2) y la del reloj (clkps2). La lneadelrelojeslaquemarcalafrecuencia,indicandoloscambiosdebitycundosedebe de leer. La frecuencia del reloj es de un rango entre 10 y 16,7 kHz (entre 60 y 100s). La lecturadelbitsedeberealizarenlosflancosdebajadadelrelojdelPS/2(clkps2).
Lectura en los flancos de bajada clkps2
dataps2
bit 0 bit 1 bit 2 bit 3 bit 4 bit 5 bit 6 bit 7
bit de fin
reposo a '1'
bit de inicio a '0'
paridad impar
dato de 8 bits 11011101
reposo a '1'
Figura 11.3: Ejemplo del cronograma para una transmisin del teclado
Con todo esto, podemos deducir que el diseo del receptor del teclado PS/2 ser muy parecido al receptor de la UART. La mayor diferencia est en la generacin de la seal paralalecturadelosbits.RecuerdaqueenelreceptordelaUART,paraleerlosbitsdela trama tenamos que generar la seal baud_medio a partir del divisor de frecuencia (apartado 7.7.3 y figura 7.48). Ahora ya no tenemos que generar esa seal porque la lectura viene marcada por los flancos de bajada de la seal de reloj del PS/2 (clkps2). Lo que tenemos que hacer es un detector de flancos de bajada de la seal clkps2. Tendremos queleercadabitdelatramacadavezquesedetectaunflancodebajada. As pues, la entidad del receptor del teclado podr ser como la mostrada en el bloque de la figura 11.4 . Observa que este receptor de se parece mucho al de la UART (figura 7.45). La diferencia es que ahora se tiene el puerto ps2clk que es el reloj de la transmisin que vienedelteclado.Tambinquesehaaadidolasealdeerror(error_ps)queindica siha habidoerrorenlatransmisin,calculadoapartirdelatramarecibidaysubitdeparidad.
194
11. Puerto PS/2
8 dato_kbd a nuestro sistema (FPGA)
RECEPTOR_KBD
aviso_kbd recibiendo kbd clk
kbdclk kbddata
del exterior (teclado)
rst
Figura 11.4: Entradas y salidas del receptor del teclado
En principio, con lo que hemos estudiado hasta ahora, no deberas de tener muchos problemaspararealizarestediseo. Se recomienda incluir uno o dos registros a la entrada de las seales externas (ps2clk y ps2data) para evitar metaestabilidad, y hacer las lecturas y la deteccin de flanco con las seales registradas. La metaestabilidad se explic en el captulo 5 de la referencia [17mach].
11.1.1. Cdigos scan

Hemos visto cmo recibir la informacin del teclado, pero quiz te hayas preguntado qu significado tienen las tramas recibidas. Es decir, cul es la relacin entre las teclas que pulsamos y lo que se enva por el PS/2. La relacin viene determinada por los cdigos scan. La figura 11.5 muestra los cdigos scan de las teclas de un teclado ingls norteamericano.
Figura 11.5: Cdigos scan de un teclado ingls norteamericano
Los cdigos scan de la figura 11.5 estn en hexadecimal, la mayora de ellos tiene dos dgitoshexadecimales,porlotantosepuedenenviarenlos8bitsdedatosdelatramadel PS/2. Sin embargo puedes observar que hay caracteres especiales que tienen ms de un cdigo scan y que su cdigo est precedido por E0h. Por ejemplo, la flecha hacia arriba tiene el cdigo E0h 75h. Estos cdigos scan dobles se llaman cdigos escapados (escaped scancodes)o teclasextendidas.Puedesverqueinclusohayalgunosquetienenmsdedos. Normalmenteloscdigosescapadostienenalgunarelacinconlossencillos.Porejemplola tecladecontrolCtrldelaizquierdatieneelcdigo14h,yladeladerechaesE0h14h. Loscdigosscanqueenvaeltecladosondedostipos:makeybreak.Cadavezquesepulsa una tecla se enva un cdigo make y cuando se deja de presionar se enva un cdigo break. El cdigo break es igual que el make pero precedido por el nmero F0h (en hexadecimal). Con esto se puede saber si se est pulsando una tecla mientras hay otra tecla pulsada, lo queestilporejemploparalasteclasdemaysculasycontrol:Shift,Alt,Ctrl,....
195
El teclado no realiza ninguna interpretacin de las teclas pulsadas, esto lo tiene que realizar la computadora (o en nuestro caso, la FPGA). Es decir, que si mantenemos presionada la tecla Shift cuando pulsamos la letra a, el teclado no enva la letra A mayscula, sino que le corresponde a la computadora interpretar que se ha enviado letra Alamayscula. En los cdigos scan escapados, cuando se enva el cdigo break, se enva entre los dos cdigosscan.Porejemplo,elcdigobreakdelaflechahaciaarribaserE0hF0h75h. Porponerunejemplo,siqueremosescribirlaletraZmayscula,sucederlosiguiente:

PresionamoslateclaShift:12h,ysinsoltarla PresionamoslateclaZ:1Ah SoltamoslaletraZ:F0h1Ah SoltamoslateclaShift:F0h12h
Asqueeltecladoenviar:12h1AhF0h1AhF0h12h. Si una tecla se mantiene pulsada se convierte en typematic, que significa que el teclado reenviar su cdigo make aproximadamente cada 100 ms, hasta que se suelte o hasta que sepresioneotratecla.Paraverificarestopuedesabriruneditordetextoyhacerlaprueba: Pulsaunatecla,porejemplolaB, einmediatamenteaparecerla letrabeneleditor.Si la has mantenido pulsada, al cabo de un breve espacio de tiempo volver a aparecer repetidamente hasta que la sueltes o hasta que pulses otra tecla. En este ltimo caso, esta ltima se convertir en typematic. Esto hay que tenerlo en cuenta en el control, cuando se esperaquesemantenganpresionadasvariasteclassimultneamente. Con esto ya tenemos informacin suficiente para hacer un receptor del teclado y, si fuese necesario,uncontrolquegestionelasteclasquesepulsan. Para probar este diseo puedes probar a enviar por la UART lo que se recibe por el tecladoopuedesincluirelcontroldelvideojuegoPongporelteclado.
11.2. Ratn PS/2

El interfaz con el ratn es ms complicado porque el ratn necesita recibir informacin desde la computadora para empezara funcionar, mientras que para el teclado no es necesarioaunquepuederecibirinformacindesdelacomputadoraparasuconfiguracin. Enelapartadoanteriorhemosvistocmorecibirdatosdeltecladosinnecesidaddeenviar altecladoningunainformacin. En este apartado vamos a introducir un concepto muy interesante que son los puertos bidireccionales.Estoes,puertosquepuedenenviaryrecibirdatos. Enesteapartadovamosaver:

Funcionamientodelratn ProtocoloPS/2paraenviarinformacinalratndesdelacomputadora Puertosbidireccionales DescripcindepuertosbidireccionalesenVHDL
11.2.1. Funcionamiento del ratn

ElinterfazestndarPS/2delratnadmitelassiguientesentradas:
MovimientoenelejeX(izquierda/derecha)
196
11. Puerto PS/2
MovimientoenelejeY(arriba/abajo) Botnizquierdo Botncentral Botnderecho
El ratn lee estas entradas a una frecuencia determinada y actualiza los contadores e indicadores para reflejar los estados de movimiento y botones. Existen muchos dispositivosapuntadoresquetienenentradasadicionalesypuedenproporcionardatosde maneradiferentealaqueseespecificaaqu(comoporejemplolos quetienenlaruedecita descroll). El ratn estndar tiene dos contadores que recogen la informacin del movimiento: los contadores de movimiento en X y en Y. Estos valores se codifican con 9 bits en complemento a 2, teniendo cada uno asociada una bandera de desbordamiento. El contenido de estos contadores, as como el estado de los tres botones, se envan a la computadora en un paquete de tres bytes. Los contadores de movimiento representan el movimiento que el ratn ha experimentado desde que se envi el ltimo paquete, por tantonorepresentanposicionesabsolutas. El contenido de estos bytes se muestra en la figura 11.6. El protocolo de envo es el explicado anteriormente en la figura 11.2. En la figura 11.6 slo se muestran los ocho bits dedatosdelostresenvosynosemuestranlosbitsdeincio,paridadyfin.
bit 7 Byte 1 Byte 2 Byte 3
Overfl.Y
bit 6
Overfl. X
bit 5
Signo Y
bit 4
Signo X Movimiento X Movimiento Y
bit 3
1
bit 2
bit 1
bit 0
bot. izq.
bot. Medio bot. dcha
Figura 11.6: Contenido de los tres bytes de informacin enviados por el ratn
El ratn se puede configurar para cambiar parmetros como la velocidad de muestreo, la resolucin,elescaladoysiesthabilitadalatransmisindedatosono. Hasta aqu el funcionamiento es similar al del teclado, sin embargo este funcionamiento corresponde con el modo de funcionamiento stream (transmisin) cuando est habilitada latransmisindedatos,peronoeselmododefuncionamientoconelquearrancaelratn. El ratn tiene varios modos de funcionamiento: reset, transmisin (stream), remoto y eco (wrap).Losmodosremotoyecocasinoseusan,asqueslovamosaverlosdosprimeros. Elmodoreseteselmodoenelqueentraelratnalencenderse.Alentrarenestemodoel ratnrealizauntestdeautodiagnsticoyponelossiguientesparmetros:

Velocidaddemuestreo:100muestras/s Resolucin:4cuentaspormilmetro(porcadamilmetroloscontadoresaumentanen4) Escalado:1:1 Envodedatos:deshabilitado
Una vez que el ratn realiza el autodiagnstico enva un cdigo que indicar si ha tenido xito (AAh) o si ha habido algn error (FCh). Luego enviar la identificacin del dispositivoPS/2,queparaunratnPS/2estndares00h.
197
Una vez que el ratn ha enviado la identificacin del dispositivo entra en el modo de transmisin. En el modo de transmisin el ratn enva la informacin si tiene habilitada esta funcin. Sin embargo, hemos visto que al arrancar el ratn en el modo reset, se deshabilita esta funcin. Para habilitar la transmisin, la computadora tiene que enviar el comando F4h (Enable Data Reporting). Una vez que el ratn recibe este comando, ste responder con el comandoFAhparaindicarelreconocimientodelcomando. A partir de ahora el ratn enviar datos normalmente y ya no ser necesario enviar ms comandosalratndesdelacomputadora. Se ha incluido la tabla 11.1 para resumir los comandos que se envan entre el ratn y la computadora(oFPGA)alarrancar,
secuenciaeneltiempo ratnFPGA FPGAratn 1 2 3 F4h 4 5 ... AAh 00h FAh informedemovimientodelratn(figura11.6.)
Tabla 11.1: Comunicacin entre el ratn y la FPGA hasta habilitar la transmisin de datos del ratn
Si queremos hacer un sistema lo ms sencillo posible en nuestra FPGA, nos bastara con enviar el comando F4h pasado un tiempo desde el arranque y esperar a recibir el comando de reconocimiento FAh, una vez hecho esto, el sistema pasara a recibir la informacin del movimiento del ratn. Por otro lado, hay que tener en cuenta que si estamos configurando la FPGA desde el cable JTAG y el ratn est conectado80, el ratn habrenviadoestosdoscomandosantesdequelaFPGAestconfigurada.Portanto,siya loshaenviado,nuestrosistemasepodraquedarbloqueadoesperandoarecibirlos. OtraalternativaesforzarelresetenviandoelcomandoderesetFFh,trasestecomando,el ratnenviarelreconocimientoycomenzarconlasecuenciadelatabla11.1. A continuacin veremos cmo funciona el protocolo PS/2 para enviar un comando desde lacomputadoraalratn
11.2.2. Protocolo PS/2 para transmitir desde la computadora

NormalmenteelcontroldelalneadedatosydelrelojPS/2lotieneeldispositivo(ratno teclado). Si la computadora (o FPGA) quiere tomar el control debe de poner la lnea del reloj(clkps2)acerodurante100s,despusdeestetiempo,liberalalneadelrelojypone la lnea de datos a cero (bit de inicio). Posteriormente, con la lnea de reloj controlada ya por el dispositivo, espera a cada flanco de bajada del reloj para poner cada uno de los datosyelbitdeparidad.Finalmente,lacomputadoraliberalalneadedatosconelbitde finyeldispositivoponeuncerodereconocimientoenlalneadedatos. La figura 11.7 muestra el cronograma de las lneas de reloj y datos del PS/2 cuando la computadora (o FPGA) quiere enviar datos al dispositivo. Como la lnea es bidireccional, en la figura se ha dibujado en rojo los valores puestos por la computadora y en azul los valorespuestosporelratn.
80
RecuerdaquenoesrecomendableconectarelratnoeltecladoPS/2conlaplacadelaFPGAencendida.
198
11. Puerto PS/2
FPGA toma el control del reloj 100s
clkps2
dataps2
b0
b1
b2
b3
b4
b5
b6
b7
bit de inicio
bits del dato
bit de paridad
bit de fin
bit de reconocimiento (ack) Ratn
FPGA
Figura 11.7: Cronograma de la transmisin de datos entre la computadora o FPGA (rojo) y el ratn (azul)
Para clarificar ms el cronograma, en la figura 11.8 se han separado los cronogramas segn quin pone el valor. En el de arriba y en rojo se han puesto los valores puestos por la computadora y abajo en azul las del ratn. Para ver mejor las relaciones entre las seales, en cada cronograma se incluye en lnea punteada los valores de la seal que son puestosporelotrodispositivo.
Computadora o FPGA clkps2
dataps2
b0
b1
b2
b3
b4
b5
b6
b7
clkps2 Ratn
dataps2
b0
b1
b2
b3
b4
b5
b6
b7
Figura 11.8: Cronogramas separados de la transmisin de datos desde la computadora hacia el ratn
Paramayorclaridad,acontinuacinseexplicaconmsdetalleelcronograma:
Lacomputadoratomaelcontroldelalneadelrelojponindolaacerodurantealmenos 100 s. Con esto se inhibe la actividad del ratn. Esto se puede interpretar como que la computadorasolicitarealizarunenvo Pasados 100 s, la computadora libera la lnea de reloj y pone un cero en la lnea de datos.Estecerosepuedeconsiderarcomoelbitdeinicio. Lacomputadoramantieneelceroenlalneadedatoshastaqueelratntomaelcontrol de la lnea de reloj y la pone a cero. Esta transicin de uno a cero (flanco de bajada) se puede considerar como un reconocimiento por parte del ratn de que ha recibido el bit deinicio,yelindicaalacomputadoraqueenveelprimerbitdeldato(elbit0) La computadora pone el bit nmero cero cuando detecta el flanco de bajada del reloj puesto por el ratn. El ratn indica con cada flanco de bajada del reloj que est preparadopararecibirelsiguientebit.Porlotanto,cadavezquelacomputadoradetecta
199
un nuevo flanco de bajada del reloj pondr un nuevo bit. Esta operacin se repite con todoslosbitsdeldatohastallegaralbitdeparidad.
La computadora, una vez que detecta el flanco de bajada de reloj despus del bit de paridad,liberalalneadedatos,loquehacequesepongaauno.Estoseraelbitdefin. Unavezliberadalalneadedatosporlacomputadora,elratnpondrlalneadedatos acero,indicandoquehareconocidolatransicin81. La computadora podr verificar el bit de reconocimiento en la lnea de datos cuando detecteunnuevoflancodebajadadelalneadereloj82. Para terminar, el dispositivo liberar la lnea de datos y de reloj, ponindose ambas a uno
Este protocolo es vlido tanto para el ratn como para el teclado, pero para el teclado no lohemosnecesitamosporqueporahoranohemosqueridoenviarleningncomando. Con esta informacin y con la del apartado anterior ya podramos proceder a realizar el interfazconelratn. Sin embargo, puede que te hayas estado preguntando, cmo puede haber una lnea bidireccional.Hastaahorahemosseguidolaregladequeunasealnopuedeserasignada desde dos sitios diferentes y hemos usado puertos que son o bien de entrada o bien de salida. A continuacin veremos cmo funcionan y cmo se implementan los puertos bidireccionales.
11.2.3. Puertos bidireccionales

Las lneas de reloj y dato del PS/2 son en drenador abierto83, esto permite realizar conexiones bidireccionales sobre el mismo cable. La figura 11.9 muestraun esquema muy simplificadodelaconexinendrenadorabiertoentrelaFPGAyelratn.Elesquemaest muy simplificado y slo pretende explicar el concepto, adems de que el esquema real es diferenteparalaXUPV2PylaNexys2.
FPGA VDD ratn Resistencia de pull-up FPGA
clkps2_r
clkps2_f
Figura 11.9: Esquema simplificado de la conexin en drenador abierto delPS/2
La figura 11.10 esquematiza el funcionamiento de un transistor en drenador abierto conectado a una resistencia de pullup. El inversor que se ha colocado despus de la seal AesparaquelasalidaLineatengaelmismovalor,sino,Lineaestarainvertida.
81 82 83
Eninglssellamaacknowledgebit(ack) EstereconocimientonoesnecesarioimplementarloenlaFPGA OcolectorabiertoencasodequeseacontransistoresbipolaresenvezdeconMOSFET
200
11. Puerto PS/2
La resistencia de pullup hace que la salida Linea est a VDD cuando el transistor no conduce.Cuandoeltransistorconduce,lasalidaLineatieneunatensincasicero.
VDD VDD VDD VDD
Linea='0'
0V A='1'
Linea='1'
5V
A='0'
transistor conduce A='1'
transistor no conduce A='0'
Figura 11.10: Funcionamiento de un transistor en drenador abierto con resistencia de pull-up
La figura 11.11 muestra el funcionamiento de dos transistores conectados en drenador abierto. Observando la figura vemos que si ninguno pone un cero, la salida es uno. Pero desde que uno ponga un cero, la salida ser cero. Esta configuracin tambin se llama andcableada(wiredand),porquefuncionacomounapuertaand.
VDD A 0 0 1 1 B Linea 0 0 1 0 0 0 1 1
Linea A B
Los dos transistores conducen VDD A='0' B='0' Linea='0'
Linea=0V
Un transistor conduce VDD A='1' B='0' Linea='0' Linea=0V
Ningn transistor conduce VDD A='1' B='1' Linea='1' Linea=VDD
Figura 11.11: Funcionamiento de dos transistores conectados en drenador abierto con resistencia de pull-up
Se pueden conectar ms de dos seales en drenador abierto y el funcionamiento sera el mismo,comosifueseunapuertaanddemsdedosentradas. De esta manera es como funcionan las lneas PS/2. En reposo, cuando nadie pone ningn valor, la lnea est a uno por la resistencia de pullup. Cuando uno de los dos pone un cero,lalneaseponeacero. AhoraquedavercmosedescribenestospuertosenVHDL
11.2.4. Puertos bidireccionales en VHDL

ParadescribirunpuertobidireccionalenVHDLseutilizanpuertosdetipoinoutyseales triestado. Una seal triestado puede valer '0', '1' puede estar en alta impedancia. En VHDLelvalordealtaimpedanciaserepresentacomo'Z'. Una seal triestado se implementa con un buffer triestado (figura 11.12). Este buffer tiene una seal de habilitacin (en) que cuando est a cero la salida est deshabilitada, o lo que eslomismo,estarenaltaimpedancia.
201
EN I S EN 0 0 1 1 I 0 1 0 1 S Z Z 0 1 deshabilitada
S <= I when EN = '1' else 'Z';
Figura 11.12: Buffer tri-estado
LadescripcindeunbuffertriestadoenVHDLtambinsemuestraenlafigura11.12. En VHDL, para los puertos de entrada y salida (inout) se recomienda separar la entrada delasalidaenlaunidaddemsaltoniveldemodoquenoestemosmanejandosealesde entrada y salida en todo el diseo. La figura 11.13 muestra un ejemplo para un diseo estructural,endondeelpuertodeentradaysalidaclkps2seseparaenlasealdeentrada clkps2_inyladesalidaclkps2_out.Estaltima,habilitadaporlasealen_clkps2.
TOP_RATON INTERFAZ_RATON puertos de salida en_clkps2 clkps2_out clkps2_in en_clkps2 clkps2_out clkps2 puerto inout entity TOP_RATON is port ( clkps2 : inout std_logic; ... end TOP_RATON; architecture ESTRUCTURAL of TOP_RATON is signal en_clkps2 : std_logic; signal clkps2_out, clkps2_in: std_logic; ... begin clkps2_in <= clkps2; clkps2 <= clkps2out when en_clkps2 = '1' else 'Z'; ...
clkps2_in puerto de entrada
Figura 11.13: Separacin de un puerto de entrada y salida en seales
Una vez que hemos separado el puerto de entrada y salida clkps2, en el resto del diseo no usaremos el puerto clkps2 sino que usaremos clkps2_in para leer y clkps2_out para escribir,comosifuesensealesdistintas.Estaeslaformaalaqueestamosacostumbrados a disear, la nica diferencia es que cuando queremos escribir algo en la seal de salida clkps2_outtenemosqueponerlasealdehabilitacinen_clkps2auno. Conestasindicacionesyapodrasrealizarelinterfazconelratn.Paradepurarlainterfaz puedes enviar por la UART los datos recibidos del ratn. Una vez que funcione, puedes probarapintaruncursorenlaVGAsegnelmovimientodelratn. En este captulo hemos visto la informacin necesaria para realizar interfaces bsicos con el teclado y el ratn. Para ampliar la informacin sobre el protocolo PS/2 y los distintos tiposdecomandosquetiene,puedesconsultarlasreferencias[4chu,6ceng,23qihw].
202
12. Memorias
El objetivo de este captulo es aprender a usar los bloques de memoria internos (BRAM) delasFPGAsdeXilinx,yengeneral,aaprenderadescribiryusarmemoriasenVHDL. El captulo se organizar de la siguiente manera: primero veremos los bloques de memoria internos de las FPGA de Xilinx, luego aprenderemos a describir una memoria ROM de modo que podamos mostrar en la VGA una imagen guardada en este tipo de memorias. Por ltimo aprenderemos a describir una memoria RAM, para ello propondremos un circuito que reciba una imagen por la UART, la guarde en la memoria RAMylamuestreporlapantalla.
12.1. Bloques de memoria RAM (BRAM)

La FPGA de la XUPV2P tiene 136 bloques de memoria RAM (BRAM) internos, mientras que la Spartan3e de la Nexys2 tiene 20 bloques84. Cada bloque tiene 18 Kbits85 de los cuales 16 Kbits son para guardar datos y 2 Kbits son para bits de paridad. Estos bloques se pueden configurar con distintos anchos de palabra, pudiendo pasar de 16K posiciones86 de memoria con un bit de ancho de palabra, hasta 512 posiciones de memoria con palabras de 32 bits (con 4 bits de paridad opcionales). Los bits de paridad se pueden usar como bits adicionales de dato, pero solamente en ciertas configuraciones. En la tabla 12.1 se muestran las distintas configuraciones. Las 3 configuraciones de la derecha (sombreadas) incluyen el bit de paridad, por eso suman 18 Kbits, mientras que las de la izquierda,quenolousan,suman16Kbits.
Posicionesdememoriaxnmerodebitsdelapalabra 16Kx1bit 8Kx2bits 4Kx4bits 2Kx9bits 1Kx18bits 512x36bits Tabla 12.1: Configuraciones de las BRAM
Siimplementamosunamemoriaconotroanchodepalabra,perderemosbits.Siqueremos una memoria de tres bits de ancho de palabra, usaramos la configuracin 4K x 4 bits, peroperderamoselcuartobit(ademsdelbitdeparidadquepierdeestaconfiguracin). El tamao total de la memoria interna de las FPGAs usando las BRAM lo calculamos multiplicando el nmero de posiciones de memoria de una BRAM por el nmero de bloquesBRAMquehay.Esteclculosemuestraenlatabla12.2.
Nexys2(20) 1bit 320K 2bits 160K 4bits 9bits 18bits 36bits 136K 20K 68K 10K 80K 40K XUPV2P(136) 2176K 1088K 544K 272K
Tabla 12.2: Tamao mximo de la memoria usando todas las BRAM de la FPGA segn el ancho de palabra
84
EstosbloquesdememoriaestndentrodelaFPGA,nosonlasmemoriasdelasplacas,poresoson memoriaspequeas. 1Kbit=210bits=1024bits Estas16Kposicionesenrealidadson16x1024posiciones.
85 86
203
As, por ejemplo, con un ancho de palabra de 9 bits, la memoria mxima que podremos usar en la XUPV2P tendr 272 K posiciones (278528), y la Nexys2 tendr 40 K posiciones (40960). Veamos con un ejemplo el tamao mximo de memoria que disponemos en las FPGAs. Supongamos que queramos guardar una imagen cuadrada en escala de grises con 8 bits de profundidad de color, es decir 256 niveles de gris87. Para este tipo de imgenes utilizaramos un ancho de palabra de 9bits (tabla 12.2). El tamao mximo de las imgenes segn el nmero de imgenes que queremos guardar se muestra en la tabla 12.3.
8bits/pxel 1imagen 2imgenes 3imgenes 4imgenes XUPV2P Nexys2 527x527 202x202 373x373 143x143 304x304 116x116 263x263 101x101
Tabla 12.3: Tamao mximo de las imgenes segn el nmero de imgenes que se van a guardar en las BRAM. Para imgenes de 8 bits por pxel.
Realmente no es mucha cantidad de memoria, si quisisemos guardar imgenes ms grandestendramosquerecurriralamemoriaexterna.LaXUPV2PpuedellevarunaDDR SRAM de 256 512 MB; la Nexys2 tiene una memoria SDRAM y otra flash de 16 MB cada una, estas memorias son tres rdenes de magnitud mayores que la memoria interna de la FPGA. Sin embargo, estas memorias externas son ms difciles de usar, especialmente la delaXUPV2P,ytambinsonbastantemslentasquelasBRAMinternasdelasFPGAs. Las memorias BRAM son de doble puerto, esto es, se puede acceder a ellas desde dos puertos independientes, incluso estos puertos pueden funcionar con relojes diferentes. Adems,estasmemoriassonmuyrpidasyaquedevuelveneldatosolicitadoenunciclo dereloj. Comoejemplo,enlafigura12.1semuestraelbloquedeunaBRAMdedoblepuertoycon relojes diferentes. Estamemoria es la ms general, ya que tiene doble puerto de entraday salida y relojes independientes para cada puerto. No es necesario incluir todos estos puertos al describir una memoria. En este ejemplo la longitud de palabra (dina, douta, dinb y doutb) es de 8 bits y el bus de direcciones (addra y addrb) tiene 17 bits. Con 17 bits sepuedeaccedera131072direcciones88,asqueconestamemoriapodramosguardaruna imagen de 362x362 pxeles de 8 bits cada pxel. Segn la tabla 12.3, en la XUPV2P podramos tener dos memorias de este tipo, sin embargo, esta memoria no cabra en la Nexys2.
87
EstaimagenlapodramosmostrarcompletamenteconelconversorVGAdelaXUPV2P,yaquelaVGAde estaplacatiene8bitsparacadacolor.SinembargolaNexys2slotiene8bitsparalostrescolores(recuerda elapartado9.2),porloqueestaramosguardandoinformacinquenopodramosmostrar.Enelcasodela Nexys2,siqueremosaprovecharmejorlamemoria,podramosguardarunaimagenencolorde8bits(256 colores).Estoloveremosenelapartado12.2.5.Enamboscasos,estaramosguardandounaimagenenlaque usamos8bitsparacadapxel. 217=131072
88
204
12. Memorias
BRAM
1
enb web dinb
ena wea dina
1 8
1 8
17
17
addrb
8
addra douta clka

8
doutb clkb
Figura 12.1: Bloque de memoria RAM de doble puerto
Enlatabla12.4seresumeelsignificadodelospuertos.
Seal
clka ena wea dina
bits I/O
Descripcin SealderelojparaelpuertoA HabilitacindelpuertoA,sinhabilitacinnosepodrleerniescribirenelpuertoA WriteEnabledeA:Habilitacinparaescrituradeldatodinaenladireccinde memoriaaddra DatodeentradaparaescribirenmemoriaporelpuertoA
1 1 1 8
I I I I
addra 17 I Direccindememoriaquesequiereleer/escribirparaelpuertoA douta 7 O Lecturadeldatoquehayenlaposicindememoriaaddra(tardaunciclodereloj) clkb 1 I SealderelojparaelpuertoB enb 1 I HabilitacindelpuertoB,sinhabilitacinnosepodrleerniescribirenelpuertoB web dinb
1 8
I I
WriteEnabledeB:Habilitacinparaescrituradeldatodinbenladireccinde memoriaaddrb DatodeentradaparaescribirenmemoriaporelpuertoB
addrb 17 I Direccindememoriaquesequiereleer/escribirparaelpuertoB doutb 7 O Lecturadeldatoquehayenlaposicindememoriaaddrb
Tabla 12.4: Listado de puertos de la BRAM de doble puerto
12.2. Dibujar una imagen guardada en una ROM

En este apartado vamos a disear varios circuitos que dibujen una imagen guardada en distintas memorias ROM. Empezaremos con un diseo muy sencillo y luego lo iremos complicando. Consideraremos las diferencias entre las placas XUPV2P y la Nexys2. El esquemageneraldeloquequeremoshacersemuestraenlafigura12.2.
205
TOP_PINTA_ROM ROM_IMG dout addr clk

c_nb_datmem c_nb_dirmem
PINTA_IMG datmem dirmem

8
10
pxl_num
10
red green blue

8 8
red green blue
line_num visible
clk
rst vga_blank hsynch vsynch pxl_clk comp_synch
Figura 12.2: Esquema de bloques del circuito que pinta en la pantalla una imagen guardada en una ROM
PodemosverqueelesquemaseparecealcontroladorVGAquevimosenlafigura9.10,la diferenciaestenlaintroduccindelbloquedelamemoriaROM(ROM_IMG). Observa que el bloque de la memoria ROM es mucho ms sencillo que el de la memoria RAM de doble puerto (figura 12.1). Por un lado, esta memoria ROM slo tiene un puerto, as que con esto se han quitado la mitad de los puertos (enb, web, dinb, addrb, doutb y clkb). Por otro lado, por ser una memoria de slo lectura, se quita el dato de entrada dina y la habilitacin de escritura wea. Tampoco se ha incluido la seal de habilitacin ena. As que slo nos queda el reloj (clk), la direccin de memoria que queremos leer (addr) y el datodevueltoporlamemoria(dout). Observa que el nmero de bits de la direccin de memoria (c_nb_dirmem) y el nmero de bits del dato89 (c_nb_datmem) estn con constantes. Y tambin que el nmero de bits de los colores(red,greenyblue)sonocho,peroparalaNexys2sern3,3y2respectivamente. AhoraveremoscmosepuededescribirunamemoriaROM.
12.2.1. Memoria ROM de un bit de ancho de palabra

En VHDL, una memoria ROM es simplemente una constante de tipo vectorial a la que se accedemedianteunprocesoconreloj.LadireccindememoriadelaROMeselndicedel vector. En el cdigo 12.1 se muestra un mdulo que describe una memoria ROM de 256 posiciones y con datos de un nico bit. Esta memoria ROM representa una imagen de 16 filas y 16 columnas. Por eso se ha llamado ROM1b_16x16, sin embargo la memoria es unidimensional,esdecir,accedemosporunndice(addr)quevadesde0a255ynoporla filaycolumna.Comoson255posicionesdememoriaaddresde8bits.
89
Elanchodepalabra
206
12. Memorias
entity ROM1b_16x16 is port ( clk : in std_logic; addr : in std_logic_vector(7 downto 0); dout : out std_logic ); end ROM1b_16x16; architecture BEHAVIORAL of ROM1b_16x16 is signal addr_int : natural range 0 to 2**8-1; type memostruct is array (natural range<>) of std_logic; constant img : memostruct := ( -- 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','0','1','0','1','0','1','0','1','0','1','0','1','0','1','0', '1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1', '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0', '1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1', '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0', '1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1', '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0', '1','1','1','1','1','1','1','1','1','1','1','1','1','1','1','1', '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0' ); begin addr_int <= TO_INTEGER(unsigned(addr)); P_ROM: process (clk) begin if clk'event and clk='1' then dout <= img(addr_int); end if; end process; end BEHAVIORAL;
-- 0 -- 1 -- 2 -- 3 -- 4 -- 5 -- 6 -- 7 -- 8 -- 9 --10 --11 --12 --13 --14 --15
-- pasar a entero la direccion
Cdigo 12.1: Memoria ROM de 256 posiciones y un bit de ancho de palabra90
En el cdigo 12.1 podemos ver que el dato de salida dout se obtiene un ciclo de reloj despusdehaberintroducidoladireccinquequeremos.Estotieneimplicacionesporque retrasaruncicloderelojlassalidasquedependendeestedato.
12.2.2. Circuito que dibuja la imagen de la ROM de un bit de ancho

Queremos dibujar la imagen de 16x16 de la ROM (cdigo 12.1) en la esquina superior izquierdadelaVGA.Elrestodelapantallaestarencolorazul. La imagen de la ROM slo tiene un bit por pxel, por tanto, ser una imagen de dos colores:blancoynegro91.Siconsideramoslosunoscomoblancoylosceroscomonegro,la imagen sera como la mostrada en la figura 12.3. En la imagen se han pintado los bordes decadapxelconlneadiscontnuagrisparaapreciarmsfcilmentesusdimensiones.
90 91
Elcdigodeestamemoriasepuededescargardelareferencia[28web] Enrealidadpodemoselegirotrosdoscolorescualquiera,peroslodos.
207
Figura 12.3: Imagen de la ROM del cdigo 12.1
Dibujaremos la imagen en la esquina superior izquierda de la pantalla. Como es una imagen de 16x16, estar dibujada entre las columnas 0 y 15, y entre las filas 0 y 15 de la pantalla. Esta ser la condicin que tendremos que poner en el proceso del mdulo PINTA_IMG (figura 12.2), que es el encargado de pintar92. El resto de la pantalla la pintaremosdeazul. Para mostrar la imagen tendremos que pedir el dato de la memoria, esperar a que la memoria devuelva el dato y dibujar el pxel en la VGA. Todo este proceso se tiene que hacer rpido, ya que la VGA no espera. La VGA tiene que mostrar los pxeles consecutivamente en los tiempos determinados por su frecuencia de refresco (recuerda la tabla 9.1). Por suerte las memorias BRAM son rpidas y slo tardan un ciclo de reloj en devolver el dato solicitado. En nuestra VGA cada pxel se muestra a una frecuencia de 25 MHz, y los relojes de las placas van cuatro veces ms rpido en la XUPV2P o dos veces ms rpido en la Nexys2. As que en principio no debera de haber problema por retrasar unciclodereloj. En la figura 12.4 se muestra cmo realizar el clculo de la direccin de memoria (dirmem o addr)apartirdelnmerodepxel(pxl_num)yelnmerodelnea(line_num)delaVGA. La figura representa la esquina superior izquierda de la VGA, donde queremos dibujar la imagende16x16.LosnmerosenazulrepresentanlascolumnasopxelesdelaVGA,que aunque van de 0 a 639, en la figura slo se han dibujado los primeros 18 (de 0 a 17). Los nmeros rojos representan las lneas (filas) de la VGA, que slo se han dibujado de la lnea cero a la cuatro. Los cuadrados representan los pxeles de la imagen, de todos los pxeles de la imagen slo se han dibujado los de las primeras filas, aunque en stas s se muestran las 16 columnas de cada fila. Por eso la imagen no se ve cuadrada, aunque lo sea.Dentrodecadapxelsehaindicadoelnmerodepxeldelaimagen.Estenmerode pxel se corresponde con la direccin de memoria que hay que solicitar para obtener el colordelpxel.
92
seraelprocesoequivalentealdelcdigo9.2,peroparaestediseoelprocesosermspequeo
208
12. Memorias
pxeles (columnas) de la pantalla (pxl_num) lneas de la pantalla (line_num)

0 0 1 2 3 4 ...
0 16 32 48 64 ... ...
1
1 17 33 49 ...
2
2 18 34 50
3
3 19 35 ...
4
4 20 36 ...
5
5 21 37
6
6 22 38
7
7 23 39
8
8 24 40
9
9 25 41
10
10 26 42
11
11 27 43
12
12 28 44
13
13 29 45
14
14 30 46 ...
15
15 31 47 63
16 17
...
pxeles de la imagen (dirmem)
38 = (2x16)+6 dirmem o addr line_num pxl_num c_ncol nmero de columnas de la imagen
Figura 12.4: Clculo de la direccin de memoria a travs del nmero de pxel y nmero de lnea de la VGA
En la parte inferior de la figura 12.4 se muestra cmo calcular la direccin de memoria correspondientealpxelquetenemosquemostrarencadamomento.Laformulaes: dirmem = (line_num c_ncol) + pxl_num
(12.1)
Donde dirmem es la direccin de memoria (tambin la hemos llamado addr); pxl_num y line_numsonelnmerodepxel(columna)yelnmerodelneadelaVGA,generadosen el sincronizador de la VGA (SINCRO_VGA); y c_ncol es una constante que define el nmero decolumnasdelaimagenqueestamosdibujando,queenelejemplovale16. Recuerda que para realizar una multiplicacin las dimensiones de los factores y el producto son muy importantes, si no, se sintetizarn multiplicadores muy grandes que consumirnmuchosrecursos.As quetenemosqueanalizarlasoperacionesimplicadas,y especialmentelamultiplicacin:
Elproductonopodrsermayorque255(8bits),pueseselnmerodedireccionesdela memoria,ynopodemosaccederaunaposicindememoriamayor. Aunqueline_numtieneunrangode0a519(10bits),enrealidad,paranuestraimagenel mximonmerodefilasson15(4bits).Porlotanto,envezdeusarline_numensurango completo,usaremosline_num(3 downto 0). Algo similar ocurre con pxl_num, aunque su rango es de 0 a 799, para nuestra imagen slonecesitamosloscuatroprimerosbits:pxl_num(3 downto 0). El resultado de multiplicar el valor mximo de line_num(3 downto 0) por 16, es un nmerode8bits(15x16=240). Sumando el nmero anterior con el mayor nmero que puede tener pxl_num(3 downto 0)resultaen255=240+15. dirmem = (line_num(3:0) c_ncol) + pxl_num(3:0) (12.2)
Asquelafrmula12.1quedar93: Sin embargo, si pasamos esta multiplicacin directamente aVHDL no se sintetizarcomo queremos. Recuerda los cdigos 8.20 y 8.21, en los que veamos que no podemos multiplicar una seal por una constante de mayor rango. En nuestro caso, n_col tiene 5 bitsmientrasqueline_num(3:0)tienecuatrobits.EnVHDLtendramosquehacerlocomo
93
Estoesunafrmula,notienelasintaxisdelVHDL
209
muestra el cdigo 12.2. Se ha tenido que crear la seal intermedia line_numx16, porque el producto tendr diez bits. Tiene que tener diez bits porque el factor tiene cinco bits y al multiplicar por una constante el producto tendr el doble de bits que el factor no constante. Posteriormente, en la suma se trunca line_numx16 ya que hemos visto que en nuestrocasoelproductonuncavaatenermsdeochobits.
... signal line_numx16 : unsigned (9 downto 0); begin line_numx16 <= ('0'&line_num(3 downto 0)) * 16; dirmem <= line_numx16(7 downto 0) + pxl_num(3 downto 0); ...
Cdigo 12.2: Clculo de la direccin de memoria con multiplicacin
Haciendolamultiplicacindeestamaneraevitamosquesesinteticenmultiplicadoresms grandesdelonecesarioyobtenemosunrangoacordeconladireccindememoria. El clculo de la direccin de memoria no hace falta que se haga nicamente cuando estemosenelrecuadrodelaVGAquecorrespondeconlaimagen,esdecirentrelasfilasy columnas 0 y 15. Este mdulo puede estar constantemente calculando la direccin de memoria y solicitando a la memoria datos, pero los datos devueltos slo los utilizaremos cuando estemos pintando la imagen (esquina superior izquierda). Esta es una de las diferencias entre el software y el hardware. El circuito encargado de calcular la direccin de memoria es independiente del resto y el que est calculando la direccin constantementenohacequeelrestodelcircuitovayamslento94. Con estas indicaciones puedes realizar el circuito. Cuando la pantalla muestre la imagen, debes de comprobar que se dibuja una imagen cuadrada de 16x16 como la de la figura 12.3. Diecisis pxeles de ancho no son muchos para una pantalla y por eso la imagen es pequea,peroqueramosevitarincluirunaROMmuygrandeenelcdigo12.1.Debesde comprobar que las lneas son rectas y continuas; que tienen el mismo ancho, especialmenteenlosbordesyesquinas;yquelaimagenescuadrada.
green
Si no se mostrase correctamente, debers de simular y ver los valores de los puertos red, y blue en los pxeles y lneas de la VGA donde se pinta la imagen. Haz las comprobacionesunavezquehayapasadolaprimerasincronizacinvertical(hsynch='0'). Leerelsiguienteapartadotambintepuedeayudaraencontraralgnfallo.
12.2.3. Mejoras y variantes del circuito que dibuja la imagen de la ROM

En este apartado veremos algunas mejoras y variantes del circuito anterior. Estas variantespodrnsertilesparaentenderlossiguientesapartadosycaptulos. Haz estas modificaciones en otras carpetas y proyectos, copiando los ficheros VHDL. Es muy importante que cuando realices modificaciones de un circuito que funciona mantengas la versin original. As, en caso de que nada funcione siempre puedas volver atrs. 12.2.3.1. Retraso de las salidas de la VGA Hemos visto que al solicitar los datos a la memoria vamos a tener un retraso de un ciclo de reloj en las seales que se generan en el mdulo PINTA_IMG: red, green y blue. Sin embargo, el resto de seales de la VGA no tienen retraso. Esto no es un gran problema
94
Sinembargo,enelcasodequequeramosquenuestrocircuitoconsumapocaenergaesconvenienteparar loscircuitosquenoestnhaciendonadatil.
210
12. Memorias
porque la frecuencia de la FPGA es mayor que la de la VGA. Sin embargo, a veces da problemas, especialmente en los primeros pxeles de cada fila95. Debido a esto, puede ser quelasprimerascolumnasnosemuestrenbien. Como solucin se puede retrasar el resto de seales de la VGA haciendo que estn sincronizadas con las seales que se generan en PINTA_IMG. Realizando esta modificacin, el esquema de la figura 12.2 se transformara en el de la figura 12.5, en donde el nico cambio es la inclusin del mdulo VGA_REG para registrar las seales de la VGA. Al registrar las seales (cdigo 2.13), en el reset se debera de asignar el valor que haga inactivalaseal96.
TOP_PINTA_ROM ROM_IMG dout addr clk
c_nb_datmem c_nb_dirmem c_nb _dirmem
PINTA_IMG datmem dirmem

8
10
pxl_num
10
red green blue VGA_REG

8 8
red green blue
line_num visible clk rst
vga_blank hsynch vsynch pxl_clk comp_synch clk rst
Figura 12.5: Esquema de bloques del circuito que pinta en la pantalla una imagen guardada en una ROM retrasando las seales de la VGA
Tanto si se produce algn defecto de este tipo como si no, te recomendamos que cambies el circuito y registres las salidas. Esto, adems de sincronizar las seales, registra los puertos de salida. Registrar los puertos de salida es una prctica muy recomendada porque la seal no tendr los retardos ni las transiciones espurias debidas a la lgica combinacional. Las transiciones espurias se producen por los retardos de las puertas (y tambin las interconexiones). En la figura 12.6 se puede ver cmo al cambiar la entrada A y D, se produceunatransicinespuriaenlasalidaS3.Latransicinesespuriaporquedespusde los retardos debidos a la propagacin de las seales, la salida S3 mantendr su valor original,porlotantosontransicionesnodeseadas.Siregistramosestasalida,latransicin espurianosetrasladaralasalidadelbiestable(PO)porqueeltiempodeestatransicines menorqueelperiododelreloj.
95
Ennuestrodiseolasegundacolumna(lanegra)delaimagen(figura12.3)seveablanca,porloqueseuna conlaprimerayterceracolumna,pareciendounacolumnamsgruesaqueelresto.Estoseproducaenla XUPV2PperonoenlaNesys2 Porejemplo,elvalorinactivodelassealeshsynchyvsynch,sueleser1ylodefinimosporlaconstante c_synch_actinvertida(recuerdaelcdigo9.1).
96
211
Tg Tg Tg
A t0 t1 t2 t3 t0 t1 t2 t3 A retardo S1 Tg B=1 C=1 D Tg Tg Tg transiciones espurias t0 t1 t2 t3

retardo Tg
S2 t0 t1 t2 t3
retardo Tg
PO S3 sin transiciones espurias
t0 t1 t2 t3 Tclk periodo de reloj
t0 t1 t2 t3 Tclk periodo de reloj
Figura 12.6: Eliminacin de transiciones espurias con un biestable
Siimplementaselcircuitopropuestoenesteapartado(figura12.5)ytesalebien,mantenlo como circuito base para los dems cambios. Es decir, parte de este para hacer los cambios propuestosenlossiguientesapartados. 12.2.3.2. Clculo de las direcciones sin multiplicador En la frmula del clculo de la direccin de memoria vemos que hay una multiplicacin. Del captulo 8, sabemos que las multiplicaciones consumen bastantes recursos y son ms lentas. Una alternativa a la multiplicacin es utilizar un registro que se inicialice en la fila cero y que aumente en 16 (c_ncol) cada vez que se incremente una fila. Hacerlo de esta manera requiere un poco ms de cuidado en las sumas y las inicializaciones de este registro, pero ahorra un multiplicador. Si quieres, puedes hacer una primera versin con lamultiplicacinyluegoprobararealizarlodeestamanera. 12.2.3.3. Dibujar la imagen en otro lugar de la pantalla En vez de dibujar la imagen en la esquina superior izquierda, empezando por el pxel de la posicin (0,0), ahora realizaremos el mismo circuito pero dibujando la imagen a partir delafila100ycolumna200. La solucin es fcil, en el proceso de pintar hay que cambiar las condiciones que sitan dnde se pintan los pxeles de la imagen (proceso P_pinta). Por otro lado, hay que cambiar la ecuacin del clculo de las direcciones. Ahora ya no se calculan con pxl_num y line_num, sino que hay que hacer un cambio de ejes restando 200 y 100 a estas seales respectivamente. Puedespensarqupasarcuandoalrealizarestasrestaspxl_numyline_numseanmenores que los sustraendos (200 y 100). Enrealidad no nos importa porque en el proceso P_pinta se controla que slo se pinte cuando sean mayores. Pero no est mal que pienses qu pasarasinosecontrolase. 12.2.3.4. Repeticin de la imagen Hemos realizado el circuito de modo que el clculo de la direccin de memoria se realiza constantemente y en el proceso de pintar (proceso P_pinta) es donde se incluyen las condiciones que indican dnde se pinta la imagen. En esta propuesta vamos a quitar las condiciones en el proceso P_pinta que hacen que la imagen se dibuje slo en la esquina superiorizquierda.Asqueelprocesodepintarquedaracomomuestraenelcdigo12.3.
212
12. Memorias
P_pinta: Process (visible, datmem) begin red <= (others=>'0'); green <= (others=>'0'); blue <= (others=>'0'); if visible = '1' then red <= (others => datmem); green <= (others => datmem); blue <= (others => datmem); end if; end process;
Cdigo 12.3: Dibujar la imagen de manera repetida
El resultado ser que la imagen se dibuja de manera repetitiva por toda la pantalla. Puedes probar a cambiar a mano la imagen de la ROM del cdigo 12.1 para poner otras formas. EntiendesporquseformaesaimagenenlaVGA? 12.2.3.5. Ampliacin por dos En esta variante vamos a volver a pintar una sola imagen en la esquina superior izquierda,perolaqueremospintaraldobledetamao.Envezdedibujarlaimagenensu tamaooriginalde16x16,lapintaremosatamao32x32.Seteocurrecmohacerlo? Porunlado tienesquecambiarelprocesoP_pintademodoqueahoraelcuadradodonde se pinta la imagen sea de 32x32 (esquina superior izquierda de la pantalla). Por otro lado queremos pintar el mismo pxel de la imagen en la interseccin de dos columnas y dos filas de la pantalla. Para ello, al calcular la direccin de memoria tendremos que dividir entredoslosnmerosdecolumnayfilaenlaqueestamos. La figura 12.7 muestra cmo se calcularan las direcciones de memoria. A diferencia de la figura 12.4, para evitar una imagen muy grande, en esta figura no se muestran las 32 columnasdelaimagen. Los cuadros con borde verde representan cada pxel de la imagen. Estos cuadros abarcan cuatro pxeles de la pantalla (borde negro). Observa que quitando el bit menos significativo de pxl_num obtenemos la columna de la imagen en la que estamos. Y lo mismo sucede con la fila, por ejemplo, los pxeles de la fila cero de la imagen estn en las filas cero y uno de la pantalla. Como ya sabemos, quitar el bit menos significativo es dividirpordos.
213
columna 6 de la imagen columnas 12 y 13 de la pantalla
pxeles (columnas) de la pantalla (pxl_num) 0100 0101 0011 0110 lneas de la pantalla (line_num)
fila 0 de la imagen filas 0 y 1 de la pantalla fila 1 de la imagen filas 2 y 3 de la pantalla fila 2 de la imagen filas 4 y 5 de la pantalla
0111
1111 ....
0000
0001
0010
1000
1001
1010
1100
1101
1011
1110
pxl_num/2
...
...
0 0 1 2 3 4 ...
48 32 16 0
2
1
4
2
6
3
8
4
10
5
11
12
6
13
14
7
15
16 17
8
0000 0001 0010 0011 0100 0101 ....
17
18
19
20
21
22
23
24
...
33
34 ...
35
36
37
38
39 ...
40
...
line_num / 2
...
19 = (1x16)+3 dirmem o addr line_num/2 pxl_num/2 c_ncol nmero de columnas de la imagen
Figura 12.7: Clculo de la direccin de memoria para pintar una imagen el doble de grande
Ahora, en vez de realizar las operaciones con pxl_num(3 downto 0) y line_num(3 downto 0) como se hicieron en el cdigo 12.2, las haremos con pxl_num(4 downto 1) y line_num(4 downto 1).Conestoconvertimoslainterseccindedosfilasydoscolumnasdelapantalla enunslopxeldelaimagen,dibujandolaimagencontamao32x32. Cuando hayas dibujado la imagen al doble de tamao puedes probar a realizar la ampliacin por cuatro, ocho,... Ampliaciones que no sean potencias de dos no son tan fciles,aunquenotandifcilescomolasampliacionesdenumerosfraccionarios. 12.2.3.6. Uso de las potencias de dos Quizyatehayasdadocuentaque paralaimagenqueestamosutilizandohayunaforma msfcildecalcularlasdireccionesdememoria.Comolaimagenesde16x16,y16esuna potencia de 2, las multiplicaciones son mucho ms sencillas. Lo que hemos hecho anteriormente es vlido para cualquier tipo de imagen, pero para imgenes con un un nmero de columnas que sea potencia de dos hay maneras ms sencillas de realizar los clculos. Multiplicarunnmeroporunapotenciadedos(2n)esequivalenteadesplazarelnmero, n veces a la izquierda. Como el nmero de columnas de la imagen es 16 (24), hay que desplazar cuatro veces a la izquierda el nmero de lnea de la pantalla (equivalente a la multiplicacin por 16 del cdigo 12.2) y sumarle los cuatro bits menos significativos del nmerodepxel(columna)delapantalla.Comodelnmerodepxelcogamosloscuatro bits menos significativos y ahora desplazamos el nmero de lnea de la pantalla cuatro bits a la izquierda, al final no es necesario sumar sino que basta con concatenar, pues las lneasocupanlos4bitsmssignificativosylascolumnas(pxelesdela pantalla)los4bits menos significativos. La figura 12.8muestra demanera esquemtica la operacin que hay quehacer.
214
12. Memorias
dirmem = (16 x line_num(3 downto 0)) + pxl_num(3 downto 0)

x16: desplazado 4 posiciones
16 x line_num(3 downto 0) pxl_num(3 downto 0)
dirmem(7 downto 0)
&
line_num(3 downto 0)
&
pxl_num(3 downto 0)
dirmem: 8 bits (4 + 4) 256 posiciones de memoria (16x16)
Figura 12.8: Esquema del clculo de la direccin de memoria para imgenes de 16x16
Por lo tanto, en este caso el clculo de la direccin de memoria se reduce a concatenar los cuatrobitsmenossignificativosdelaslneasylospxelesdelapantalla. As que en estos casos el clculo de la direccin de memoria resulta muy fcil. Para ayudar a entender mejor por qu es tan fcil, en la figura 12.9 se ha modificado la figura 12.4 poniendo los nmeros de lneas y pxeles en hexadecimal. Hacindolo as, se puede verquelaobtencindelnmerodepxeldelaimagen(direccindememoria)seconsigue concatenandoelnmerodelneaconelnmerodepxeldelapantalla.
pxeles (columnas) de la pantalla (pxl_num) 1111 .... 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 lneas de la pantalla (line_num) binario
...
0 0 1 2 3 4 ...
0 10 20 30 40 ... ...
1
1 11 21 31 ...
2
2 12 22 32
3
3 13 23 ...
4
4 14 24 ...
5
5 15 25
6
6 16 26
7
7 17 27
8
8 18 28
9
9 19 29
A
A 1A 2A
B
B 1B 2B
C
C 1C 2C
D
D 1D 2D
E
E 1E 2E ...
F
F 1F 2F 3F
10 11
hexadecimal
0000 0001 0010 0011 0100 0101

en hexadecimal
26h = 0010 0110 = 3810 dirmem o addr line_num pxl_num

en decimal: 38 = 2x16 + 6 en hexadecimal: 26 = 2x10 + 6
Figura 12.9: Clculo de la direccin de memoria aprovechando que la imagen tiene un nmero de columnas potencia de dos
Haz un nuevo proyecto incorporando esta forma de calcular la direccin de memoria. Emplearemos mucho esta forma de clculo en el captulo 15 en el que disearemos el videojuegoPacman.
12.2.4. Memoria ROM de varios bits de ancho de palabra

Cuando cada pxel de la imagen es de un nico bit97 se pueden agrupar todas las columnasdeunalnea enunanicadireccin dememoria.Porejemplo,envezdedefinir
97
Esunaimagenenblancoynegro
215
lamemoriacomolohicimosenelcdigo12.1,podemosdescribir laROMcomolo haceel cdigo 12.4, en donde todos los bits/pxeles de una fila estn en un vector que se guarda enunanicaposicindememoria.
entity ROM16b_16 is port ( clk : in std_logic; -- reloj addr : in std_logic_vector(3 downto 0); dout : out std_logic_vector(15 downto 0) ); end ROM16b_16; architecture BEHAVIORAL of ROM16b_16 is type memostruct is array (natural range<>) of std_logic_vector(15 downto 0); constant img : memostruct := ( -- FEDCBA9876543210 "0111111111111110",-- 0 "1111111111111111",-- 1 "1111000000001111",-- 2 "1110000000001111",-- 3 "1110001111111111",-- 4 "1110011111111111",-- 5 "1110011111111111",-- 6 "1110011111111111",-- 7 "1110011111111111",-- 8 "1110011111111111",-- 9 "1110011111111111",-- A "1110001111111111",-- B "1110000000001111",-- C "1111000000001111",-- D "1111111111111111",-- E "0111111111111110" -- F ); begin P_ROM: process (clk) begin if clk'event and clk='1' then dout <= img(to_integer(unsigned(addr))); end if; end process; end BEHAVIORAL;
Cdigo 12.4: Memoria ROM de 16 posiciones y 16 bits de ancho de palabra98
Posiblemente habrs notado que la imagen de la memoria es distinta a la que hemos estado usando, esto lo hemos hecho para incluir algo de variedad e mostrar nuevas posibilidades. Para distinguir mejor la imagen en el propio cdigo se han puesto en negritalosceros. Observa cmo han cambiado los anchos de los puertos, ahora la memoria slo tiene 16 posiciones (las 16 filas de la imagen) y por tanto bastan cuatro bits para acceder a cualquierposicin.Porotrolado,eldatotiene16bits(las16columnasdelaimagen). Guardar todos los pxeles de una fila en una misma direccin de memoria puede tener ventajas: Normalmentenohaymemoriasconunslobitdeanchodepalabra.Siusamosunslobit enunamemoriademayoranchodepalabra,estaramosdesperdiciandoelrestodelosbits. Las memorias tienen tiempos de acceso relativamente largos, si estos tiempos fuesen crticos, obtener toda una fila con un nico acceso a memoria podra hacer aumentar la velocidaddelsistema.
98
Elcdigodeestamemoriasepuededescargardelareferencia[28web]
216
12. Memorias
En nuestro caso no hay gran diferencia entre estas configuraciones de la ROM, ya que las BRAMsonmuyrpidasysepuedenconfigurardecualquieradelasmaneras. Cmocalcularamosahoraladireccindememoriaparaobtenercadapxel? La direccin de memoria es muy fcil de calcular ya que las filas de la imagen se correspondenconlasfilasdelapantalla99,portantobastaraconasignaradirmem/addrlos cuatrobitsmenossignificativosdeline_num. Paraobtenerelpxelapartirdeldatodevueltoporlamemoria,tendremosqueseleccionar el bit correspondiente a la columna de la pantalla en la que estamos. Sin embargo, como los ndices de la memoria son descendentes100 y las columnas de la pantalla aumentan de izquierdaaderecha,tendremosquerealizarunadelassiguientesopciones: Invertirelordendelosbits(apartado8.8.3.1) Realizarunarestadelndiceparanoverlaimagensimtricadelaimagenoriginal Guardarlaimagensimtricaenlamemoria.
En la figura 12.10 se muestra cmo realizar la resta del ndice para obtener el ndice complementarioalanchodelaimagen.
lneas de la pantalla (line_num) pxeles (columnas) de la pantalla (pxl_num)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0 1 2 3 4 5 6 7 8 9 A B C D E F
dirmem <= line_num(3 downto 0) pedimos el elemento 3 de la memoria la memoria devuelve datmem
ndices de datmem
F E D C B A 9 8 7 6 5 4 3 2 1 0 3
2 = F-D
Por ser descendente, si queremos pintar la columna D tenemos que coger el elemento F-D index <= 15 - pxl_num(3 downto 0);
Figura 12.10: Clculo de la direccin de memoria y del ndice del pxel en memorias que guardan toda la fila en una direccin
Realiza el diseo para mostrar esta imagen y comprueba que obtienes la misma imagen queladibujadaenlafigura12.10,verificaquenosalelaimagensimtricayqueloscuatro puntosnegrosdelasesquinassedibujancorrectamente. Dibujar esta imagen nos puede abrir las posibilidades para dibujar caracteres de una manera ms eficiente que llenando los procesos VHDL con condiciones if y elsif. Por ejemplo, si quisisemos incluir un marcador de goles en el videojuego Pong del captulo 10,seramseficienteutilizarmemoriasROMconlosmapasdebitsdeloscaracteres.Esto loveremosenelcaptulo13,peroestbienquevayaspensandocmoloharas.
99
Encasodequeestemospintandolaimagenenlaesquinasuperiorizquierda,sino,tendremosquehacer unarestaparatrasladarlosejesdecoordenadas.Comohicimosenelapartado12.2.3.3 Enestecaso15 downto 0
100
217
12.2.5. Memoria ROM para imagen con mayor profundidad de color

En este ejercicio pintaremos imgenes en escala de grises o en color. La imagen se guardar en una memoria similar a la del cdigo 12.4 con la diferencia de que ahora cada direccin de memoria guarda un pxel y no una fila de la imagen. La memoria tendr un ancho de palabra de ms de un bit en la que se guardan los distintos tonos de gris o los distintoscolores. Porejemploelcdigo12.5describeunamemoriaROMdeunaimagende10x10pxelesen escaladegrises.Portantotendr100posicionesdememoriayencadaposicinseguarda un pxel. Esto proporciona ocho bits de informacin sobre su color, lo que da 256 niveles degris.
entity ROM8b_pacman10x10 is port ( clk : in std_logic; addr : in std_logic_vector(7-1 downto 0); dout : out std_logic_vector(8-1 downto 0) ); end ROM8b_pacman10x10; architecture BEHAVIORAL of ROM8b_pacman10x10 is type memostruct is array (natural range<>) of std_logic_vector(8-1 downto 0); constant filaimg : memostruct := ( "00000111", "00001000", "01001011", "10011110", "11011011", "11100111", "11000010", "01111111", "00011101", "00001001", "00001000", "01111101", "11010100", "11101010", "11011110", "11001111", "11100110", "11101000", "10111010", "00111101", "01000110", "11010110", "11101011", "11101000", "11100111", "11100100", "11101011", "11100100", "11110010", "10111001", "10100111", "11101011", "11100011", "11010011", "11100111", "11101001", "11100100", "11000000", "01010010", "00010110", "11011111", "11100010", "11100011", "11100011", "11100101", "11000010", "01101010", "00100010", "00011110", "00000011", "11100011", "11010111", "11100000", "11100011", "11100111", "11000111", "01011010", "00001101", "00000101", "00000100", "10101010", "11101001", "11101000", "11011100", "11100101", "11100111", "11100000", "11011100", "01110111", "00011001", "01001000", "11100011", "11101000", "11010111", "11100110", "11100101", "11100111", "11011110", "11011111", "10111001", "00001000", "01100111", "11011000", "11101010", "11010110", "11011001", "11101001", "11011101", "10111100", "00111001", "00000101", "00010100", "01001001", "10011110", "11010010", "11100101", "11001101", "01110110", "00110011", "00000111"); begin P_ROM: process (clk) begin if clk'event and clk='1' then dout <= filaimg(to_integer(unsigned(addr))); end if; end process; end BEHAVIORAL;
Cdigo 12.5: Memoria ROM de 10x10 y 256 colores grises101
Esta memoria es similar a la del cdigo 12.1, la diferencia es que en el cdigo 12.1 cada pxel tena un bit (blanco o negro) y ahora se guarda mucha ms informacin de la intensidaddelgrisdecadapxel. El clculo de la direccin de memoria para mostrar el pxel en la VGA se realiza de manera similar al de la memoria del cdigo 12.1. Aunque ahora, por ser una memoria de 10x10, no se puede calcular concatenando fila y columna de la VGA como se propona en elapartado12.2.3.6. Como la memoria guarda ocho niveles de gris, en la XUPV2P la asignacin del dato devueltoporlamemoriaalospuertosdeloscoloresesdirecta(cdigo12.6),mientrasque en la Nexys2 hay que truncar porque su conversor VGA tiene menos niveles de color (cdigo12.6).
101
Elcdigodeestamemoriasepuededescargardelareferencia[28web]
218
12. Memorias
... red <= datmem; green <= datmem; blue <= datmem; ...
... red <= datmem (7 downto 5); green <= datmem (7 downto 5); blue <= datmem (7 downto 6); ...
Cdigo 12.6: Asignacin del valor del dato de la memoria de 8 bits de gris a los colores de la XUP
Cdigo 12.7: Asignacin del valor del dato de la memoria de 8 bits de gris a los colores de la Nexys2
Como alternativa, si queremos mostrar la imagen en color usando la misma cantidad de memoria podramos guardar en los ocho bits los tres colores RGB. Esto es especialmente convenienteparalaNexys2yaquelamemoriaqueacabamosdedescribirguardamsbits decolorquelosquesepuedenmostrarporlaVGAdelaNexys2. El cdigo 12.8 muestra una ROM que es igual que la anterior (cdigo 12.5) pero con la diferencia de que ahora cada elemento de memoria no guarda el color en escala de grises sino representa su combinacin RGB en ocho bits. La distribucin de los colores es la siguiente: los tres bits ms significativos son de rojo (7:5), los tres siguientes (4:2) son de verde,ylosdosmenossignificativos(1:0)sondeazul.
entity ROM_RGB_8b_pacman10x10 is port ( clk : in std_logic; addr : in std_logic_vector(7-1 downto 0); dout : out std_logic_vector(8-1 downto 0) ); end ROM_RGB_8b_pacman10x10; architecture BEHAVIORAL of ROM_RGB_8b_pacman10x10 is type memostruct is array (natural range<>) of std_logic_vector(8-1 downto 0); constant filaimg : memostruct := ( --"RRRGGGBB" "00000000", "00000000", "01001000", "10110100", "11111100", "11111100", "11011000", "10010000", "00100100", "00000000", "00000000", "10010000", "11111101", "11111101", "11111100", "11111100", "11111100", "11111101", "11011001", "01001000", "01001000", "11111101", "11111101", "11111100", "11111100", "11111100", "11111101", "11111101", "11111110", "11011001", "10111000", "11111101", "11111100", "11111100", "11111100", "11111100", "11111101", "11011001", "01101000", "00000000", "11111100", "11111100", "11111100", "11111100", "11111100", "11011000", "01101100", "00100100", "00100000", "00000000", "11111100", "11111100", "11111100", "11111100", "11111100", "11011000", "01101100", "00000000", "00000000", "00000000", "10111000", "11111101", "11111100", "11111100", "11111100", "11111100", "11111100", "11111101", "10010000", "00000000", "01001000", "11111101", "11111101", "11111100", "11111100", "11111100", "11111100", "11111101", "11111101", "11011001", "00000000", "01101100", "11111101", "11111101", "11111100", "11111100", "11111101", "11111101", "11011001", "01001000", "00000000", "00000000", "01001000", "10110100", "11111100", "11111100", "11111100", "10010000", "00100100", "00000000"); begin P_ROM: process (clk) begin if clk'event and clk='1' then dout <= filaimg(to_integer(unsigned(addr))); end if; end process; end BEHAVIORAL;
Cdigo 12.8: Memoria ROM de 10x10 y 256 colores102
De esta manera tenemos 256 colores y podemos aprovechar mejor la memoria con las capacidades de la Nexys2. Tambin para la XUPV2P puede ser conveniente porque no siempreesnecesariomostrarlosmsde16millonesdecoloresqueseguardancon24bits. Deestamaneraseahorramemoria103.
102 103
Elcdigodeestamemoriasepuededescargardelareferencia[28web] Quiz,comolaXUPV2Ppuedemostrarmscolores,seramsconvenienteusarnuevebits,utilizandoelbit deparidaddelasBRAMcomoeltercerbitdelazul,yaquedecualquiermanerasedesperdiciaraal emplearlaconfiguracindeochobits(recuerdalatabla12.1)
219
Ahora las asignaciones de los colores sern diferentes. En el cdigo 12.9 se muestran las asignaciones para la XUPV2P. Estas asignaciones estn dentro de un proceso secuencial y por eso se puede asignar dos veces la misma seal. Como sabemos, cuando se asigna una seal dos veces en un proceso, la seal recibe el ltimo valor asignado. La primera asignacin es para asignar a los bits menos significativos el valor del bit ms significativo de datmem (tambin se poda haber asignado un cero o un uno). En la segunda asignacin se asignan los bits ms significativos y se sobreescribe la anterior asignacin de estos bits. Enelcdigo12.10semuestralaasignacinparalaNexys2.
... red <= green <= blue <= red (7 downto 5) <= green(7 downto 5) <= blue (7 downto 6) <= ... (others=>datmem(7)); (others=>datmem(4)); (others=>datmem(1)); datmem(7 downto 5); datmem(4 downto 2); datmem(1 downto 0); ... red <= datmem(7 downto 5); green <= datmem(4 downto 2); blue <= datmem(1 downto 0); ...
Cdigo 12.9: Asignacin del valor del dato de la memoria de 8 bits de color a los colores de la XUP (en proceso secuencial)
Cdigo 12.10: Asignacin del valor del dato de la memoria de 8 bits de color a los colores de la Nexys2
Si implementas estos circuitos deber salir el mueco del videojuego Pacman . Saldr muy pequeo, ya que slo tiene diez pxeles de ancho y alto. Se ha escogido un tamao tanpequeoparapoderincluirelcdigoVHDLdelasROMenestelibro.
12.2.6. Memorias ROM grandes: convertir imgenes

Los ejemplos de imgenes que hemos visto se corresponden con imgenes pequeas. De hecho, estas imgenes han sido tan pequeas que el sintetizador no ha utilizado las BRAM sino que las ha guardado en la lgica distribuida de la FPGA. Una imagen pequea como la del cdigo 12.8 tiene cien elementos pero casi no se ve en la pantalla. PasarmanualmenteunaimagenmayoraunaROMdescritaVHDLesuntrabajotediosoy estril.Enlapginawebdeestelibro[28web]hayunprogramaqueconvierteunaimagen enunaROMdescritaenVHDL. EneseenlacetambinhaymemoriasROMdemayortamaodescritasenVHDLporsino puedes convertir las imgenes y quieres hacer pruebas. Prueba a dibujar en la VGA una imagen de mayor tamao (por ejemplo 100x100) guardada en una ROM descrita en VHDL.
12.3. Memorias RAM

UnamemoriaRAMsepuededescribirdemuchasmanerasenVHDL.ParalasFPGAsque estamos usando, Xilinx propone varios modelos de descripcin para usar las BRAM. Las descripciones cambian segn el nmero de puertos, los modos de funcionamiento y si se quieren usar las BRAM o la lgica distribuida. En este libro slo se describirn dos tipos de descripcin de memorias RAM, en la referencia [30xst] se pueden consultar todas las descripcionespropuestas. En el cdigo 12.11 se muestra una memoria de doble puerto. El puertoA es de escritura ylectura,paraescribirhayqueactivarelwriteenable(wea).ElpuertoBesslodelectura. Si quisisemos una memoria de un nico puerto, bastara con quitar los puertos addrb y doutbylassentenciasrelacionadasconellos.Enesteejemplosehahechounamemoriade noventamilposicionesyochobitsdeanchodepalabra.Ladireccindememoriatiene17 bits,yaque217eslaprimerapotenciadedossuperior(oigual)a90000.
220
12. Memorias
entity BRAM_DUAL port( clk wea addra addrb dina douta doutb ); end BRAM_DUAL;
is : : : : : : : in in in in in out out std_logic; std_logic; std_logic_vector(17-1 downto 0); std_logic_vector(17-1 downto 0); std_logic_vector(8-1 downto 0); std_logic_vector(8-1 downto 0); std_logic_vector(8-1 downto 0)
architecture BEHAVIOURAL of BRAM_DUAL is type memostruct is array (natural range<>) of std_logic_vector(8-1 downto 0); signal memo : memostruct(0 to 90000-1); signal addra_int, addrb_int : natural range 0 to 2**17 -1; signal addra_rg_int, addrb_rg_int : natural range 0 to 2**17 -1; begin addra_int <= TO_INTEGER(unsigned(addra)); addrb_int <= TO_INTEGER(unsigned(addrb)); P: process (clk) begin if clk'event and clk='1' then if wea = '1' then -- si se escribe en a memo(addra_int) <= dina; end if; addra_rg_int <= addra_int; addrb_rg_int <= addrb_int; end if; end process; doutb <= memo(addrb_rg_int); douta <= memo(addra_rg_int); end BEHAVIOURAL;
Cdigo 12.11: Memoria RAM de doble puerto, uno de escritura y lectura (modo write first) y el otro de slo lectura
Esta memoria es de tipo write first (se escribe primero y luego se lee lo que se ha escrito), que significa que se cuando se escribe un dato (wea='1'), en el siguiente ciclo de reloj la memoria devuelve el dato que se est introduciendo por douta, es decir no devuelve el datoquehabaenlaposicindememoriaantesdelaescritura. El otro caso es que la memoria leyese el dato antes de escribir: read first (primero se lee y luego se escribe). El cdigo 12.12 muestra el proceso si queremos que la memoria sea read first(primerolectura).ParaalgunasFPGAs,estetipodememorianosiempresesintetizan usandoBRAM,porloquedebesdemirarelinformedesntesis.Elrestodelaarquitectura serasimilaraldelcdigo12.11.
... P: process (clk) begin if clk'event and clk='1' then if wea = '1' then -- si se escribe en a memo(addra_int) <= dina; end if; douta <= memo(addra_int); doutb <= memo(addrb_int); end if; end process; ...
Cdigo 12.12: Proceso de la memoria RAM de doble puerto, uno de escritura y lectura (modo read first) y el otro de slo lectura
El cdigo 12.11 noest descrito con constantes para poner lasdimensiones de la memoria con un ejemplo concreto, pero sera ms conveniente haberlo descrito con genricos o constantesdeclaradasenlospaquetes.
221
Hay maneras vlidas de decribir una memoria en VHDL que el sintetizador de Xilinx no reconocecomodescripcionesquesepuedanmapearenuna BRAM.Siestefueseelcaso,el sintetizador podra estar mucho tiempo intentando mapear la memoria en la lgica distribuidadelaFPGA.Sivesqueestsintetizandodurantemuchotiempo: Revisaladescripcindelamemoria Mira el informe de sntesis (apartado 8.5.1), comprobando los recursos de la FPGA utilizados,verificandosiestusandolosBRAMolalgicadistribuida Comprueba que el tamao de la memoria no supera la cantidad de BRAM de tu FPGA (tabla12.2) Pruebaarealizarmemoriasmspequeasycompruebalosrecursosutilizadosenellas
12.4. Uso de memorias usando el Coregen *

UnaalternativaadescribirlamemoriaenVHDLesutilizarelCoregendeXilinx.ElCoregen permite crear ncleos (cores) de mdulos sin tener que describirlos en VHDL. Esto por un lado es una ventaja, aunque por otro, puede hacer ms complicada la visibilidad de la simulacin. An as, lo veremos en este apartado para saber que existe la posibilidad y ademsaspodemosverlasdistintasposibilidadesdelasmemoriasconlosBRAM. En el proyecto que tengamos del ISE abrimos la ventana decreacin de una nueva fuente (Create New Source), y seleccionamos IP (Coregen & Architecture Wizard). IP es el acrnimo de Intellectual Property, que se refiere a un componente que se puede utilizar bajo ciertas condicioneslegales.
Figura 12.11: Creacin de un IP
Figura 12.12: Seleccin de Block Memory Generator
DespusdepincharenNextaparecerunmendedirectorioparaseleccionareltipodeIP que queremos implementar. Entramos en Basic Elements Memory Elements y seleccionamos Block Memory Generator (las opciones de Dual y Single Port Block Memory no sedebenusaranoserpormotivosdecompatibilidadcondiseosanteriores). En la siguiente ventana pinchamos en finalizar, y posteriormente nos aparecer una ventana del generador de memoria, en la cual tendremos que introducir las especificaciones de la nuestra. En la primera ventana pondremos el nombre del componente y seleccionamos el tipo de memoria. La memoria (bram_ini) la haremos Single Dual Port. Esta opcin permite escribir desde el puerto A y leer por el puerto B. Otra opcin (True Dual Port RAM) permite leer y escribir desde los dos puertos. ElegiremosSingle Dual Port que es como la RAM del cdigo 12.11, que tiene un puerto deescrituraylectura,yelotropuertodeslodelectura.
222
12. Memorias
Figura 12.13: Seleccin de opciones de la memoria (I)
En la siguiente ventana (figura 12.14) seleccionamos el ancho de las palabras (8 bits) y la profundidaddelamemoria(90000300x300).Elmododeoperacin(Write First)yelresto deopcioneslasdejamosigual.
Figura 12.14: Seleccin de opciones de la memoria (II)
Figura 12.15: Seleccin de opciones de la memoria (III)
En la siguiente ventana (figura 12.15) aparecern las opciones para el puerto B, en ella ponemoselWrite Widtha8(elmismoqueparaelA),verificamosquelaprofundidadsalga la misma. En el modo de operacin (Operating Mode) se indica qu dato se obtiene de lectura cuando se est escribiendo, as que este modo slo afecta cuando se est escribiendo.Sepuedeseleccionarquesea:

Deprimeroescritura(Write First):seobtendrcomodatodelecturaelmismoqueseescribe. De primero lectura (Read First): se obtendr como dato de lectura el que haba antes de escribir. Sin cambio (No Change): se obtendr como dato de lectura el ltimo que se ley antes de empezarlaescritura.
El resto de ventanas que aparezcan se dejarn con los valores por defecto. Para terminar se pincha en finish en la ltima ventana (n 5), y la herramienta dedicar cierto tiempo a generarelcomponente. La memoria generada ser similar a la descrita en el cdigo 12.11. El cronograma de lecturayescrituradelaRAMsemuestraenlafigura12.16(ennuestrocasohemoscreado la memoria sin seal de habilitacin ENA). El modo de la memoria de este cronograma es deprimero escritura,porlo quesiseestescribiendo(WEA='1'),eldatoqueseobtieneen DOUTAeselmismoqueseestescribiendo(DINA).
223
Figura 12.16: Cronograma de con la lectura y escritura de la BRAM (modo write first)
En la figura 12.17 se muestra un cronograma de una memoria con modo de primero lectura.
Figura 12.17: Cronograma de con la lectura y escritura de la BRAM (modo read first)
12.5. Guardar y mostrar una imagen que llega por el puerto serie
Para terminar proponemos un diseo en el que enviemos una imagen de un tamao determinado desde nuestro ordenador por el puerto serie a la FPGA y la mostremos por pantalla. Para simplificar el circuito, previamente hay que determinar el tamao de la imagen,elnmerodecolores,laprofundidaddecolorylavelocidaddetransmisindela UART. El diagrama de bloques de un diseo que implementa esta funcionalidad se muestraenlafigura12.18.
RS-232
escritura
lectura
VGA
UART_RX
GuardaImg
BRAM
PintaImg
SincroVGA
Figura 12.18: Diagrama de bloques de la prctica
224
12. Memorias
Te recomendamos que para empezar realices primero la parte de la derecha del circuito (bloques BRAM, PintaImg y SincroVGA) y compruebes que funcione bien. Esto se hara con una ROM que tendr el mismo tamao de la RAM que usaremos para guardar la imagen delaUART.LaROMguardarlaimagenquesevaaenviarporlaUART104
lectura
VGA
ROM
PintaImg
SincroVGA
Figura 12.19: Primera versin del circuito
Unavezquelapartederechafuncionebien,cambiaremoslaROMporunaRAMdedoble puerto. El puerto de escritura A estar conectado con el bloque GuardaImg, e ir guardando cada pxel que llega desde la UART. Este bloque ir aumentando la direccin dememoriacadavezquellegaunnuevodatodelaUART.ElpuertodelecturaBestara conectado con PintaImg, y funcionara exactamente igual que la primera versin (figura 12.19). Acontinuacinveremosenquformatoenviaremoslaimagenycmolaenviaremos.
12.5.1. Conversin de la imagen

Hay multitud de formatos para guardar una imagen, muchos de ellos comprimen la imagen para reducir su tamao. A nosotros nos interesa tener la imagen en formato raw (en crudo), esto es un formato binario sin comprimir y sin cabeceras, en la que los pxeles estn consecutivos. Si la imagen est en escala de grises, cada byte corresponder con un pxel y si est en color, cada pxel tiene tres bytes correspondientes con los colores rojo, verde y azul. Este es el formato ms sencillo aunque los tamaos de las imgenes son grandespornousarcompresin. Podramos realizar un circuito que incluya la conversin de una imagen en un formato habitual (jpeg, png, gif) a raw, in embargo esto complicara mucho el circuito. As que ser mssencilloenviarlaimagendirectamenteenformatoraw. Para convertir una imagen a formato raw podemos usar los programas gratuitos Irfanview [15irfan] o ImageMagik [14imag]. En la conversin, las imgenes raw las guardamos sin cabeceras (hay algunos programas que permiten cabeceras en los ficheros raw). Si las imgenessonencolor,lasguardamosentrelazandoloscoloresRGB,esdecir queprimero va el pxel rojo, luego el verde y finalmente el azul del primer pxel, posteriormente va el segundopxelenlamismasucesindecoloresyashastaelfinal. Como las imgenes raw no tienen cabeceras ni ninguna otra informacin, al abrirlas con un programa de dibujo tenemos que darle las dimensiones y las caractersticas del color (cuantos bytes de color por pxel). Por eso es conveniente que en el nombre de la imagen incluyassusdimensionesyelnmerodecolores.
104
Puedesusarelprogramadelareferencia[28web]
225
La imagen raw se guardar segn los colores definidos de la imagen. Si la imagen est en escala de grises se guardar con ocho bits por pxel, y si est en color se guardar con 24 bits por pxel. Sin embargo esto a veces puede llevar a confusin ya que una imagen puede tener slo colores en escala de grises, pero estar definida con 24 bits de color. Al guardarla en formato raw podra suceder que no la estuvisemos guardando con los coloresquepensamos. Por eso es importante verificar el tamao de la imagen una vez creada. Las propiedades del archivo te indicarn el nmero de bytes de la imagen. Por ejemplo, si tienes una imagen de 10x10, tendr 100 pxeles. Si esta imagen tiene un tamao de 300 bytes, ser quetiene3bytesporpxel,porloqueestacolor(24bits).Siporelcontrarioeltamaode la imagen es de 100 bytes, implica que slo tiene un byte por pxel, por lo que est en escaladegrises. Si no quieres tener problemas en la conversin a raw, te recomendamos que antes de convertirunaimagenarawlaconviertasprimeroa:

PGM:silaquieresenescaladegrises(1byte:8bits) PPM:silaquieresacolor(3bytes:24bits)
Y luego conviertas una de estas dos a raw. Esto te da la seguridad de saber siempre cuantos bytes se estn usando para cada pxel. Adems, a partir del formato PGM y PPM puedes convertir la imagen a una ROM en VHDL usando el programa disponible en [28web]
12.5.2. Envo de la imagen

Siqueremoshacerelcircuitolomssencilloposible,sermejorenviarlaimagenenescala degrises.Mstardepodremosmodificareldiseo,enviandounaimagenencolor(3bytes por pxel) y guardando los tres colores en un byte, como vimos al final del apartado 12.2.5. Tambin se podr guardar la imagen en color en tres memorias de un byte cada una. Para enviar la imagen desde el ordenador puedes utilizar el programa RealTerm [24realt], que en la pestaa Send tiene un botn llamado Send File para enviar ficheros. Si la velocidad de transmisin es muy baja (9600 baudios) el envo de la imagen completa tardar bastante. Una velocidad de envo de 115200 es razonable. Recuerda que la velocidad de envo del ordenador debe ser la misma que la velocidad del receptor de la UARTquehasimplementado. SivesquenosemuestrabienlaimagendesdelaFPGA,pruebaarealizarelenvocondos bits de parada (Port -> Stop Bits), ya que puede ser que se estn enviando los bytes muy seguidos unos de otros. Si esto fuese as, tendras que cambiar el estado del bit de fin del receptorparaquenoduretanteo. Si sigue sin funcionar, comprueba que la frecuencia de envo de la UART coincide. Cambia esto en la pestaa Port -> Baud y pincha en el botn Change, porque si no, no se actualiza. Comprueba en la parte inferior de la ventana que la velocidad es la correcta. Si an as no sale, y has seguido todos los pasos (haciendo el circuito simplificado con la ROMdelafigura12.19)tendrsquesimular.
226
13. Mostrar caracteres por pantalla

En esta prctica mostraremos por pantalla los caracteres que se escriban desde el teclado. Para ello, necesitaremos tener una memoria ROM en la que tendremos el mapa de bits de los caracteres. En una versin inicial, el circuito simplemente se encargar de mostrar por pantalla los caracteres introducidos. Posteriormente se podrn incluir acciones como el borradodecaracteresyelretornodecarro. Parafacilitareldiseousaremoscaracteresdelmismotamao,demodoquecadacarcter tienereservadoelmismoespacio.Estonospermitirdividirelespaciodenuestrapantalla en una especie de tablero de ajedrez. En cada casilla de este tablero podr ir cualquier caracter. Esto har reducir la complejidad del circuito. As, por ejemplo, la letra A ocuparlomismoquelaletrai,yambaspodrnocuparlamismacasilla. Asimismo, cada casilla del tablero formar una cuadrcula en la que cada celda de esta cuadrcula representa un pxel. Las celdas de esta cuadrcula se pintarn de tal manera que formen el caracter deseado. Todas estas cuadrculas tendrn el mismo tamao. Para ayudar a comprender esto, la figura 13.1 muestra ejemplos de las cuadrculas (mapas de bits) para las letrasA,B ei. Observa que todos los caracteres estn inscritos en una cuadrculade8x16pxeles.Comonuestrapantallaesde640x480,podremosescribir80x30 caracteres.
8 pxeles 8 pxeles 8 pxeles
16 pxeles
16 pxeles
16 pxeles
Figura 13.1: Mapa de bits de la "A", la "B" y la "i"
Un mismo carcter puede dibujarse de muy diferentes maneras, tanto ms cuanto mayor sea el tamao de la cuadrcula, y es por eso que hay tantos tipos de fuentes. Adems, normalmente un carcter tambin se puede escribir en negrita, cursiva, subrayado,... Los mapas de bits de los caracteres se pueden guardar en una memoria ROM (as tambin lo hacanlasimpresorasmatriciales).TambinsepuedenusarmemoriasRAMparapermitir cargarfuentesdistintas. Uncircuitoqueescribeloscaracteresenpantallasepodrarealizarcomomuestralafigura 13.2.
227
HOLA
PS/2
VGA
Teclado
CtrlTxt
RAM
escritura
PintaChars
lectura lectu ra
SincroVGA
ROM
Figura 13.2: Diagrama de bloques del circuito que escribe los caracteres por pantalla
Delosbloquesdelafigura13.2,elinterfazconeltecladoylasincronizacindelaVGAya sabemos cmo se hacen. Como alternativa al teclado se podra emplear el receptor de la UART y escribir desde el hiperterminal. A continuacin se explicar cmo realizar el resto debloques.
13.1. Memoria ROM

En la memoria ROM deberan estar los 128 caracteres ASCII (aunque no todos son imprimibles), por tanto, nuestra memoria ROM tendr 128 cuadrculas similares a las mostradasenlafigura13.1.SiobservsemosunfragmentodelamemoriaROMtendrael aspecto mostrado en la figura 13.3. El fragmento del ejemplo se corresponde con los caracteresAyB.Lapartesombreadasecorrespondeconun1ylasinsombrearun0. Este valor nos indicar si tenemos que pintar el pxel de la pantalla en blanco (1) o en negro(0),suponiendoqueescribimosloscaracteresenblancosobrefondonegro. LaROMtieneunanchodepalabrade8bits(unbyte)paraguardarlos8pxelesdeancho delacuadrcula,similaraladelapartado12.2.4perocon128imgenesenvezdeconuna. La cuadrcula de los caracteres tiene 16 filas de alto, por tanto, cada carcter ocupar 16 posiciones de memoria. Como la ROM tiene que guardar los 128 caracteres ASCII, el tamao de la memoria ser de 128x16=2048 bytes. Para acceder a las 2048 posiciones de memoria necesitamos 11 bits (211 = 2048), por lo tanto, el puerto de la direccin de memoria(dirmem/addr)tendr11bits.
228
Palabra de 8 bits Carcter A: ASCII 65 41h Cada carter 100 0001 16 filas: 16 posiciones de memoria: 4 bits de direcciones Carcter B: ASCII 66 42h 100 0010
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
Direcciones de memoria
100 0001 0000 : 410h n de fila del carcter n de de carcter ASCII
128 caracteres x 16 filas: ROM de 2048 palabras de 8 bits Bus de direcciones: 11 bits
100 0001 1111 : 41Fh 100 0010 0000 : 420h
128 caracteres ASCII 7 bits de direcciones
de 000h a 7FFh carcter ASCII

7 bits
n de fila
4 bits
Carcter C: ASCII 67 43h 100 0011
100 0010 1111 : 42Fh 100 0011 0000 : 430h
Figura 13.3: Configuracin de la ROM para guardar la informacin de los pxeles de los 128 caracteres ASCII
El hecho de que cada carcter ocupe una cuadrcula de 8x16 es muy conveniente para la implementacin del circuito. Estos nmeros son potencias de dos, es decir, nmeros redondos en binario y, por tanto, las divisiones y multiplicaciones se podrn realizar desplazandolosbits. Por esto, de los 11 bits de direcciones que necesitamos para las acceder a las 2048 direcciones de memoria, los siete ms significativos indicarn el carcter ASCII al que queremos acceder, mientras que los cuatro menos significativos indicarn la fila de la cuadrculadedichocarcter.Observaquesielaltodelacuadrculanofueseunapotencia dedos,estonosepodrarealizartanfcilmente(habraquerealizarladivisin). Finalmente, al acceder a la posicin de memoria deseada, la memoria nos devolver un dato de 8 bits. Dependiendo del bit, escogeremos una columna diferente de la cuadrcula. Esto ya lo hemos visto en el apartado 12.2.4, y cmo evitar que pintemos la imagen simtricadelcaracter.
13.2. Memoria RAM

La memoria RAM va a ser una memoria similar a la que usamos en el apartado 12.5. Ser una memoria RAM de doble puerto. El puertoA conectado al mdulo CtrlTxt ser de escritura y en l se escribirn los caracteres que llegan del teclado. El puertoB ser de lectura y estar conectado al mdulo PintaChars, que mostrar por pantalla los caracteres escritos. La memoria memoria tendr comomnimo 2400 posiciones (80x30). Cada posicin tendr almenos7bitsparapoderguardarlos128caracteresASCII.Lamemoriasepodrampliar encasodequesequieraincluirunscroll.
13.3. Control del texto

El mdulo de control del texto CtrlTxt se encargar de guardar en la memoria RAM los caracteres que llegan del teclado. En una primera versin simplemente realizar esto, en
229
versiones ms avanzadas del diseo se podr analizar qu tipo de caracteres se estn recibiendo y realizar las acciones correspondientes. Por ejemplo, si se pulsa la tecla de borrar,sepodraborrarelltimocarcterescrito,oalpulsarelEntersepodrarealizarun retorno de carro. En un diseo todava ms avanzado, se podra incluir una lnea de comandosendondeseinterpretenciertoscomandospreestablecidos. La pantalla tiene 640 pxeles de ancho y cada carcter tiene un ancho de 8 pxeles, por tanto disponemos de 80 columnas para escribir caracteres. En cuanto a filas disponemos de30,yaqueson480pxelesdealtoentrelos16pxelesdealtodecadacarcter.Aspues, entotalnecesitamos80x30=2400caracteres. Para empezar se puede utilizar una memoria que, cuando est llena, ya no se puedan aadir ms caracteres. Posteriormente se podr realizar con una FIFO105, de modo que conforme lleguen nuevos caracteres se vayan incluyendo al final y que si est llena se vayan eliminando los que hayan entrado al principio. Sera conveniente realizarla por filas (80 caracteres), para que eliminase una fila entera. Tambin se podran hacer de mayortamaoypermitirlaposibilidaddescroll. As que en su versin ms sencilla, este circuito simplemente va a ir escribiendo en la memoria los caracteres ASCII que van entrando desde el teclado. El circuito llevar la cuentadelaposicindelamemoriadondedebedeentrarelsiguientecarcter.
13.4. Bloque que escribe los caracteres en la pantalla

Este bloque recibe del mdulo de sincronizacin la columna y fila que se est mostrando en pantalla (pxl_num y line_num). A partir de esta columna y fila, el mdulo debe realizar lossiguientescalculos:

CalcularlacuadrculaquecorrespondeconlacolumnayfiladelaVGA Hallar el caracter que est escrito en dicha cuadrcula. Esto se hace accediendo a la memoriaRAMconelnmerodecuadrcula A partir del caracter que est escritoen dicha cuadrcula y la fila de la VGA, obtener de lamemoriaROMelmapadebitsdelafila. Seleccionar el pxel de la fila que hay que pintar a partir del nmero de columna de la VGA
Debido a que hay dos accesos a distintas memorias (la RAM y la ROM), y stas tienen retardos, se debe prestar especial atencin a la sincronizacin para mostrar el pxel adecuado en cada momento. Como solucin, podramos retrasar dos ciclos de reloj las seales de la VGA106 como se hizo en el apartado 12.2.3.1. En aquel caso se retrasaron las seales un ciclo de reloj, pero ahora se deben retrasar dos ciclos porque hay dos accesos secuencialesamemorias. De manera imaginaria, la pantalla VGA estar dividida en cuadrculas de 8x16. Como hemos dicho, resultan 80 columnas x 30 filas, lo que hacen 2400 cuadrculas. Lo primero que tenemos que hacer es averiguar en qu cuadrcula de la VGA estamos segn la fila
105 106
DelinglsFirstIn,FirstOut,quetraducidoesprimeroenentrar,primeroensalir Aunqueprobablementenoseanecesarioporquelosmapasdebitsdeloscaracteressuelentenercerosenla primerayltimacolumna,queesdondepodrahaberproblemas.Portanto,sisontodosiguales,nose notarasiestamospintandoelpxeldeotrocaracter.Osino,saldrantodosloscaracteresdesplazasosunoo dospxelesaladerecha.Encualquiercaso,lomejorseraretrasarlassealesdelaVGAparasincronizarlas
230
(line_num) y la columna (pxl_num) de la VGA que estemos. El nmero de la cuadrcula (cuad_num) se corresponde con la numeracin de las cuadrculas mostrada en la figura 13.4.
640 pxeles : 80 caracteres
79
80
81
82
83
159
480 pxeles : 30 caracteres
160
161
162
163
239
240
241
242
243
319
...
...
2320
2399
Figura 13.4: Divisin de la pantalla en cuadrculas y numeracin de las cuadrculas
Para obtener el nmero de la cuadrcula tenemos que dividir el nmero de columna de la VGA (pxl_num) entre 8 (ancho de la cuadrcula), con esto tendremos la columna de la cuadrcula(col_cuad:entre0y79),ydividirelnmerodefiladelaVGA(line_num)entre 16 (alto de la cuadrcula), as tendremos la fila de la cuadrcula (fila_cuad: entre 0 y 29). Elnmerodecuadrcula(cuad_num)seobtendr:
cuad_num
= (80 x (line_num/16)) + pxl_num/8 = (80 x fila_cuad) + col_cuad
cuad_num
Sin embargo, en el captulo de operaciones matemticas (cap. 8) se vio que la multiplicacin y sobre todo la divisin, no son operaciones inmediatas de realizar en hardware. Afortunadamente107, las divisiones que hay que realizar son entre nmeros redondos en binario, pues 16 y 8 son potencias de 2, y esto lo va a simplificar enormemente. En la figura 13.5 se muestra cmo se pueden calcular fcilmente la columna y fila de la cuadrcula. Para la columna, como hay que dividir entre 8, basta con no tomar los 3 bits menossignificativos.Paralafilahabrquequitarlas4bits menossignificativos.Conesto nosahorramosladivisin.Siqueremosevitarlamultiplicacin80xfila_cuad,podramos tener un registro que vaya aumentando en 80 cada vez que se pasa a una nueva fila de cuadrcula(similaracomosepropusoenelapartado12.2.3.2).Sino,sepuederecurrirala multiplicacin.
107
Notanafortunadamente,sinoquestehasidoelmotivodeescogeresasdimensionesdelacuadrcula
231
columna del pxel: pxl_num
col_cuad = 0 00 0002 : 010 00 0012 : 110 00 0102 : 210 00 0112 : 310 00 1002 : 410
col_cuad = 1
col_cuad = 2 10 0002 : 1610 10 0012 : 1710 10 0102 : 1810 10 0112 : 1910 10 1002 : 2010 10 1012 : 2110 10 1102 : 2210 10 1112 : 2310
col_cuad = 3
00 1012 : 510 00 1102 : 610 00 1112 : 710 01 0002 : 810 01 0012 : 910 01 0102 : 1010 01 0112 : 1110 01 1002 : 1210 01 1012 : 1310 01 1102 : 1410 01 1112 : 1510
fila del pxel:
line_num
fila_cuad = 0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 fila_cuad = 1 01 01 01 01 01 01 01 01 01 01 01 01 01 01
00002 00012 00102 00112 01002 01012 01102 01112 10002 10012 10102 10112 11002 11012 11102 11112 00002 00012 00102 00112 01002 01012 01102 01112 10002 10012 10102 10112 11002 11012
: : : : : : : : : : : : : : : : : : : : : : : : : : : : : :
010: 110: 210: 310: 410: 510: 610: 710: 810: 910: 1010: 1110: 1210: 1310: 1410: 1510: 1610: 1710: 1810: 1910: 2010: 2110: 2210: 2310: 2410: 2510: 2610: 2710: 2810: 2910:
00h 01h 02h 03h 04h 05h 06h 07h 08h 09h 0Ah 0Bh 0Ch 0Dh 0Eh 0Fh 10h 11h 12h 13h 14h 15h 16h 17h 18h 19h 1Ah 1Bh 1Ch 1Dh
01 11102 : 3010: 1Eh 01 11112 : 3110: 1Fh fila_cuad = 2 10 00002 : 3210: 20h
11 0002 : 2410
Figura 13.5: Clculo de la fila y columna de la cuadrcula a partir de la fila y columna de la VGA
Ahora ya tendremos el nmero de la cuadrcula (cuad_num) en la que estamos. Con este ndice accedemos a la memoria RAM donde el mdulo de control del texto ha guardado los caracteres escritos en el teclado. El acceso a la memoria con el nmero de cuadrcula nosdevolverelcdigoASCIIdelcarcterdeesacuadrcula. As que ya tenemos los 7 bits de la seal del cdigo ASCII, estos 7 bits son los 7 bits ms significativos de la direccin de la memoria ROM donde est el mapa de bits de los caracteres. Recuerda la figura 13.3, los 7 bits ms significativos seleccionan el cdigo ASCII. Los4bitsmenossignificativosdelbusdedireccionesdelaROMindicanenqufiladelas 16 filas de la cuadrcula se estamos. Estos 4 bits los tomamos de los 4 bits menos significativoslafiladelpxelenqueestamos(line_num),quesonlosquenoseusaronpara calcularlacolumnadelacuadrcula(figura13.5). Ahora ya tenemos los 11 bits de direcciones con los que obtendremos los 8 pxeles de la filaquequeremosdelcarcter.Deestos8bitsseleccionaremoselbitdelacolumnaenque estemos. Esta columna la obtendremos con los 3 bits menos significativos del pxel de la columna (pxl_num), estos son los que no habamos usado para calcular la cuadrcula
232
(figura 13.5). Recuerda que hay que obtener el complementario del ndice para que no salgalaimagensimtrica. Segn sea el bit obtenido0 1 tendremos pintar el pxel negro o blanco en la pantalla. Lafigura13.6muestraelesquemadelosclculosdelasdireccionesde lasmemoriaspara obtener el color del pxel. En estos esquemas y explicaciones hay que tener en cuenta adems losrangos resultantes de las multiplicaciones. Por ejemplo, para la multiplicacin de line_num(8 downto 4) x 80 se debe aumentar el tamao de line_num(8 downto 4), tal comosehaexplicadoenelapartado12.2.2yelcdigo12.2.
line_num
9 8 7 6 5 4 3 2 1 0
pxl_num
9 8 7 6 5 4 3 2 1 0
0:520
0:800
8 7 6 5 4
pxl_num(9 downto 3)
dirram
4 3 11 10 9 8 7 6 5 4 3 2 1 0
x 80
0:29
0:79
0:2399
3 2 1 0
pxl_num(2 downto 0)
2 1 0
RAM
12
0:16
0:7
7
addr dout clk
datoram
6 5 4 3 2 1 0
&
0:127
0:16 dirrom
10 9 8 7 6 5 4 3 2 1 0
seleccin del pxel
0:2048
ROM
11
7 6 5 4 3 2 1 0
addr dout clk
datorom
El bit nos dir si debemos pintar el pxel blanco o negro
Figura 13.6: Esquema de los clculos de las direcciones de memoria para la obtencin del color del pxel
Con estas explicaciones pensamos que tendrs informacin suficiente para disear el circuito. Si te sale bien, puedes probar a hacer alguna variante de las que se han propuesto. Este tipo de diseos en los que utilizamos las cuadrculas, los emplearemos paraeldiseodevideojuegos(captulo15). Sitienesproblemasenlaimplementacinynosabesquhacerparasolucionarlos,puedes probar a implementar el circuito con una ROM en vez de la RAM. En la ROM habr caracteres fijados por t que se tendrn que mostrar por pantalla. Para este ejemplo, no hara falta que hicieses la ROM con 2400 posiciones de memoria, bastara con dos o tres filas(unas200posicionesseramsquesuficiente).
233
14. Procesamiento digital de imgenes

En esta prctica realizaremos un procesamiento sencillo de una imagen. Primero realizaremos un circuito ms sencillo en el que la imagen a procesar estar guardada en una memoria ROM, posteriormente ampliaremos el circuito para que reciba la imagen desde el puerto serie del ordenador. En ambos casos se mostrar en pantalla la imagen originalylaprocesada. Antes de analizar el circuito, veremos en qu consiste el procesamiento que queremos realizar.
14.1. Procesamiento de imgenes

A una imagen se le pueden aplicar muchos tipos de procesamientos diferentes. Un procesamiento habitual es aplicar una convolucin de ventana 3x3 sobre la imagen original. Estas ventanas tendrn distintos valores segn el procesamiento. En la figura 14.1 se muestran los operadores de convolucin de tres filtros. En la figura vemos que los filtrosdePrewittySobeltienendosoperadores:elhorizontalyelvertical.
Media 1 1/9 x 1 1 1 1 1 1 1 1 -1 0 1 -1 0 1 -1 0 1 Prewitt -1 -1 -1 0 0 0 1 1 1 -1 0 1 -2 0 2 -1 0 1 Sobel -1 -2 -1 0 0 0 1 2 1
Figura 14.1: Distintos operadores de convolucin
Los operadores se van aplicando pxel a pxel yel resultado se asignaalpxel de la nueva imagen. En la imagen 14.2 se muestra cmo se aplicara el operador horizontal de prewitt al pxel (1,1) de la imagen original. La figura incluye la frmula resultante de aplicar el operador,cuyoresultadoserelvalordelpxel(1,1)delaimagenprocesada.
-1 0 1 -1 0 1 -1 0 1
Aplicado al pixel (1,1)

(0,0) (0,1) (0,2)
A
(1,0)
B H N T Z ...
C I O U ... ...
D J P V ... ...
E K Q W ... ...
F L R X ... ...
-1 A 0G 1M S Y ...
-1 B 0H 1N T Z ...
-1 C 0I 1O U ... ...
D J P V ... ...
E K Q W ... ...
F L R X ... ...
G M S Y ...
Pixel (1,1) = | A B C + M + N + O |
Figura 14.2: Aplicacin del operador horizontal de Prewitt al pxel (1,1)
235
Conelfindeaclararcmoserealizaelprocesamiento,sevan amostrarlasecuacionesquedefinenlostresoperadoresdela figura14.1. Enlafigura14.3semuestralanumeracindelospxelespara identificarlosenlasecuaciones. Lasecuacionesdelpxelcentralp5son: Media:p5media =(1/9) (p1+p2+p3+p4+p5+p6+p7+p8+p9)
p1 p4 p7
p2 p5 p8
p3 p6 p9
Figura 14.3: Numeracin de los pxeles de la ventana
Prewitt:p5prewitt = |(p7+ p8+ p9) - (p1+ p2+ p3)| + |(p3+ p6+ p9) - (p1+ p4+ p7)| Sobel:p5sobel = |(p7+ 2 p8+ p9) - (p1+ 2 p2+ p3)| + |(p3+ 2 p6+ p9) - (p1+ 2 p4+ p7)| Estas operaciones se deben realizar para todos los pxeles de la imagen excepto para los bitsdelborde.Lospxelesdelbordedelaimagenresultantesepuedenponerennegro(a cero) para que las imgenes original y procesada tengan el mismo tamao. Por tanto la imagenresultantetendrunrecuadronegrodeunpxeldeancho.
14.2. Circuito que procesa una imagen guardada en una ROM

Queremos implementar un circuito que procese una imagen guardada en una memoria ROM y guarde la imagen procesada en una memoria RAM. El circuito mostrar ambas imgenes por pantalla. Las imgenes estarn en escala de grises con 256 niveles de gris, por lo tanto necesitaremos dos memorias de ocho bits de ancho de palabra. En la tabla 12.3 se anotaron los tamaos mximos de las imgenes de 8 bits/pxel que se podan guardar segn el nmero de imgenes que se tenan. En nuestro caso, como queremos guardar dos imgenes, para la XUPV2P podramos usar imgenes de 350x350 y para la Nexys2lasimgenespodranserde120x120108. Eldiagramadebloquesdeuncircuitoqueharalafuncionalidaddeseadasemuestraenla figura14.4.
original prewitt
ProcVentana
lectura lectura
VGA
CtrlMem
ROM
PintaImgs
SincroVGA
RAMproc
escritura
lectura
Figura 14.4: Diagrama de bloques del circuito que procesa y muestra una imagen guardada en una ROM
La mayora de los bloques los sabemos implementar, a continuacin se resume su funcionalidad:

SincroVGA:elgeneradordesincronismosdelaVGA(apartado9.3)
108
Sonvaloresorientativos,nopuedensuperarlosvaloresdelatabla12.3paradosimgenes
236
ROM: memoria ROM con la imagen que queremos procesar. Crearemos la ROM a partir de
unaimagenenescaladegrises(apartado12.2.6).Paraestecircuitoqueremosunamemoria ROM de doble puerto, por lo que tendremos que modificarla para aadir el puerto B (addrb y doutb). Los puertosA yB tendrn el mismo reloj. Es ms conveniente que sea de doble puerto para que los accesos a memoria para el procesamiento sean independientesdelosaccesosamemoriaparamostrarlaimagenporpantalla.
RAMproc: memoria RAM de doble puerto (apartado 12.3). Igual que la memoria ROM, esta
memoria tambin ser de doble puerto para independizar la parte que muestra la imagen procesadaenlaVGAdelapartequeguardalaimagenprocesada.
PintaImgs: es un proceso parecido al que vimos en el captulo de dibujar imgenes por
pantalla (cap. 12), pero con la diferencia de que ahora tenemos que dibujar dos imgenes. Este mdulo calcular de manera independiente las direcciones de memoria de ambas imgenes.Porlotanto,encadamomentoseobtendrndospxeles:unodecadamemoria. Segn la fila y columna de la VGA, el proceso que pinta los pxeles seleccionar qu pxel va a mostrar, que podr ser el pxel de la imagen original (ROM), el pxel de la imagen procesada (RAMproc) o el pxel del color del fondo. Las imgenes se mostrarn en distintas zonasdelapantalla,demanerasimilaracomosehizoenelapartado12.2.3.3. Ms adelante se podr incluir una memoria ROM de caracteres para incluir un texto indicativodelasimgenes,porejemplo:ImagenoriginaleImagenprocesadaPrewitt.
CtrlMem: este mdulo se encarga de obtener los pxeles necesarios de la imagen original parapoderaplicarlasconvolucionesdelaventana3x3explicadasenelapartado14.1.Esto seharparacadaunodelospxelesdelaimagenyelresultadoseguardarenlamemoria RAM (RAMproc). Este mdulo deber determinar qu pxeles corresponden con los bordes delaimagenparanoaplicarlaconvolucinenellosyponerlosdirectamenteanegroenla imagenprocesada. ProcVentana: este mdulo recibe de CtrlMem los nueve pxeles de una ventana para ser
procesados (figura 14.3 del apartado 14.1) y devuelve el valor del pxel resultante despus deaplicarlelasecuacionesdelprocesamiento.Comohayquerealizarmuchasoperaciones, es posible que no d tiempo realizarlas todas en el mismo ciclo de reloj. Por tanto se recomienda al menos registrar las entradas y las salidas, y analizar si los retardos son lo bastantegrandescomopararealizarsegmentacininsertandoalgnregistroms(recuerda elapartado8.9.1.2). Debido a que se han introducido registros, convendra incluir un control para avisar a CtrlMem de cundo se ha terminado la operacin (finproc_vent) y por tanto, cundo est disponible el resultado para ser guardado en la memoria RAM. Asimismo, tambin habra que incluir una seal (inicproc_vent) que le indicase a este mdulo cundo estn los pxeles preparados para iniciar el procesamiento. Estos controles sern ms necesarios en el procesamiento de la media, ya que hay que realizar una divisin y sta puede durar varios ciclos de reloj. En la figura 14.5 se muestran las entradasysalidasdeestemduloparaelcasodelprocesamientodePrewittoSobelya questosnonecesitanelpxelnmerocinco.
237
orden de iniciar el procesamiento

8 8 8
ProcVentana inicproc_vent p1 p2 p3
8
finproc_vent
pxeles de la ventana p1 p4 p7 p2 p5 p8 p3 p6 p9
fin del procesamiento, resul est disponible

8
p4 resul p6 p7
8 8 8
resultado del procesamiento
p8
8
p9 clk rst
Figura 14.5: Entradas y salidas del mdulo ProcVentana que realiza la convolucin de ventana 3x3
Por ltimo, debes recordar lo explicado en el captulo 8 de circuitos aritmticos para implementar las operaciones de la convolucin (apartado 14.1). Debes tener en cuenta que, al realizar las sumas, el resultado aumentar de rango, y por lo tanto, el resultado total tendr ms de ocho bits. Cuando haya desbordamiento (cuando el resultado sea mayor que 255), el circuito deber poner el resultado a blanco (255). Si no tienes esto en cuenta, los resultados con valor ms alto (ms blancos) quedarn con valores muy bajos (cercadelnegro)poreltruncamientodelosbitsmssignificativos. En la figura 14.6 se muestra el esquema de las operaciones que hay que realizar para calcular el resultado de la convolucin de ventana 3x3 del operador de Prewitt. Este esquema opera con nmeros enteros positivos y antes de restar se compara cul es el mayor, otra alternativa sera realizar las operaciones en complemento a dos. Al final, el resultado es un nmero de 10 u 11 bits que habra que convertir a ocho bits. Al describir el circuito en VHDL debes de analizar los rangos. Tambin hay que considerar los tiemposyversiesnecesariointroducirbiestablesparasegmentar(apartado8.9.1.2).
p1 p2 p3 p4 p6 p7 p8 p9
p1
8
p4
p7
8
p3
p6
p6
+ (8bits)
8
co
1
+ (8bits)
8
+ (8bits)
8
co
1
+ (8bits)
8
co (acarreo)
co (acarreo)
co
1
+ (9bits)
9
co
1
+ (9bits)
9
co
1
+ (9bits)
9
co
1
+ (9bits)
9
sumafila1
10
sumafila3
sumacol1
10
sumacol3
10
10
B comparador A>B 0 1 0 1
B comparador A>B 0 1 0 1
p1 p4 p7
p2 p5 p8
p3 p6 p9 restafilas M S - (10bits)
10
S - (10bits)
restacols
co
+ (10bits)
10
resul
considerar desbordamiento
Figura 14.6: Esquema de las operaciones de la convolucin 3x3 de Prewitt
238
14.3. Circuito que procesa una imagen que llega por la UART
Queremos hacer un circuito similar al anterior con la diferencia de que ahora la imagen original la vamos a recibir por la UART en vez de tenerla guardada en la ROM. La figura 14.7muestraeldiagramadebloquespropuestoparaelcircuito.
original
prewitt
ProcVentana
escritura / lectura
RS-232 CtrlMem UART_RX
lectura
VGA
RAMorig
PintaImgs
SincroVGA
RAMproc
escritura
lectura
Figura 14.7: Diagrama de bloques del circuito que procesa y muestra una imagen recibida por la UART
Aparte del receptor de la UART, que ya sabemos cmo se implementa, las nicas diferenciasconelcircuitoanteriorson:
RAMorig: ahora es una memoria RAM en vez de una ROM, tendr el mismo tamao, pero
sepodrescribirenella.ElbloqueCtrlMemguardarlospxelesquelleguendelaUART.
CtrlMem:estemduloesmscomplejoqueeldelcircuitoanterior.Puesantesdeempezara
procesar la imagen debe de haber recibido la imagen desde la UART. As que deber de tenerunosestadosquepodranserlossiguientes:
Espera:elmduloestalaesperadeempezararecibirlosdatosdelaUART Guarda: el mdulo guarda los pxeles que llegan de la UART en la memoria RAMorig. En
esteestadoactademanerasimilaralmduloGuardaImgdelapartado12.5(figura12.18)
Procesa:
una vez guardados todos los pxeles de la imagen, comienza a realizar el procesamientodemanerasimilaralapartadoanterior.
Como mejora se podra aadir que el circuito devolviese por la UART la imagen procesada. En este caso habra que incluir un programa en la computadora para guardar laimagenrecibidaycomprobarqueseharecibidobien.
14.4. Acelerar el procesamiento

Si has implementado yprobado el circuito del apartado anterior habrs podido notar que enloquemssetardaesenlatransmisinporlaUARTyqueelprocesamientoesmucho rpido. As que lo que convendra mejorar sera la transmisin, por ejemplo, transmitiendo por un puerto USB o por Ethernet. Sin embargo, estos diseos son ms complejosyestnfueradelosobjetivosdeestelibro.Portanto,apesardequeelcuellode botellanoestenelprocesamiento,enesteapartadoveremoscmoacelerarlo. Propondremos dos mejoras, una consiste en disminuir los accesos a memoria y la otra realizaelprocesamientodurantelarecepcin(alvuelo).
239
14.4.1. Disminuir los accesos a memoria

Es probable que ya hayas tenido en cuenta esta mejora al realizar los diseos previos. Cada vez que se realiza el procesamiento de una convolucin de ventana 3x3 hay que tener los nueve109 pxeles de la ventana. Por tanto, habra que realizar nueve accesos a memoria. En nuestro caso no es mucho problema porque las memorias BRAM son muy rpidas,peronosiempreesas. Sin embargo, como el procesamiento se va realizando con pxeles consecutivos, cuando nosmantenemosenlamismafila,slohacefaltapedirtresnuevospxeles,yaquelosseis restantes los tenamos de la ventana anterior. La figura 14.8 muestra un ejemplo sealandolospxelesrepetidos.Slocuandohayuncambiodefilasenecesitapedirtodos lospxeles.
Procesamiento del pxel 7
(0,0) (0,1) (0,2) (0,0)
Procesamiento del pxel 8

(0,1) (0,2)
0
(1,0)
1 7 13 19 25 31
2 8 14 20
3 9 15 21
4 10 16 22 28 34
5 11 17 23 29 35
0
(1,0)
1 7 13 19 25 31
2 8 14 20 26 32
3 9 15 21 27 33
4 10 16 22 28 34
5 11 17 23 29 35
6 12 18 24 30
6 12 18 24 30
26 27 32 33
pxeles necesarios: 0, 1, 2 6, 7, 8 12, 13, 14 repetidos
pxeles necesarios: 1, 2, 3 7, 8, 9 13, 14, 15 slo hace falta pedir estos tres
Figura 14.8: Pxeles repetidos en el clculo de la convolucin 3x3 para el procesamiento de dos pxeles consecutivos
Por tanto, aprovechando los pxeles que ya tenemos del procesamiento anterior, conseguimosreducirlosaccesosamemoriadenueveatres.
14.4.2. Procesamiento "al vuelo"

El circuito que recibe la imagen de la UART realiza el procesamiento una vez que se ha recibido y guardado la imagen. Una alternativa es realizar el procesamiento al mismo tiempoqueseestrecibiendolaimagen.Estaopcintodavamsinteresanteenelcasode que no sea necesario guardar la imagen original ya que esta alternativa no slo realiza el procesamientomsrpidamentesinoqueademsprescindedelamemoriaRAMorig. El mtodo consiste en guardar los pxeles que van llegando de la UART en registros de desplazamiento de modo que en cada momento se tengan tres filas de la imagen110. La figura 14.9 muestra el esquema de estos registros. Para simplificar se ha escogido una imagendesloseispxelesdeancho.Enlafigurasepuedeverqueenlafiladearribaslo hacen falta tres registros, mientras que las otras dos filas tienen tantos registros como columnastienelaimagen(enesteejemploseis).
109 110
NuevepxelesenelprocesamientodelamediayochopxelesenPrewittySobel Encasodequelaventanadelaconvolucinseade3x3
240
ancho de la ventana p9 UART_RX 14 13 12 p8 p7
nmero de pxel de la ventana p1 p4 p7 p2 p5 p8 p3 p6 p9 nmero de pxel de la imagen
p6 11 10 9 8
p5 7
p4 6 alto de la ventana
p3 2
p2 1
p1 0
ancho de fila de la imagen (n de columnas)
Figura 14.9: Registros que guardan tres filas de la imagen
Podemos ver que los tres registros de la derecha de las tres filas forman los nueve registrosquesenecesitanparaelprocesamientodelaventana. Para poder empezar a procesar los registros, stos deben haberse llenado, es decir, el registro p1 (abajo a la derecha) debe de haber recibido el pxel cero de la imagen. En la figura 14.9 se ha mostrado este caso, en el que ya se han recibido los primeros quince pxeles(de0a14)111yyasepuedeiniciarelprocesamiento.Unavezquesehanllenadolos registros,lospxelesseseguirndesplazandoaladerecha. En la figura 14.10 se muestra qu sucede cuando llega el pxel nmero quince. Con la llegada del pxel nmero quince, el pxel nmero cero que estaba en el registro de abajo a laderechasepierdeysereemplazaporelpxelnmerouno,yascontodos:sedesplazan aladerechaconlallegadadecadanuevopxeldesdelaUART.
p9 14 p8 13 p7 12 al recibir el pxel 15 de la UART 12 11 10 p9 15 p8 14 p7 13
p6 11 10 9 8
p5 7
p4 6
p6 9
p5 8
p4 7
p3 2
p2 1
p1 0
p3 3
p2 2
p1 1
Figura 14.10: Desplazamiento de los registros al recibir un nuevo pxel de la UART
Es interesante observar qu ocurre en los pxeles de los bordes de la imagen. En la figura 14.11 se muestra qu ocurre con los registros cundo se llega a un pxel del borde. Como sepuedeobservar,laventanaestencolumnasnoconsecutivasyportantoenestoscasos sepondrcomoresultadounpxelnegro.
111
Antesdequelleguenlosquincepxelesescomosiseestuviesenprocesandolospxelesdelborde,queirn acero(negro)enlaimagenprocesada
241
p9 17
p8 16
p7 15
p9 18
p8 17
p7 16 0 6
El pxel 11 no se procesa 1 7 13 19 25 31 2 8 14 20 3 9 15 21 4 10 16 22 28 34 5 11 17 23 29 35
p6 14 13 12 11
p5 10
p4 9 14 14 13
p6 12
p5 11
p4 10 12 18
p3 5
p2 4
p1 3
p3 6
p2 5
p1 4
24 30
26 27 32 33
Figura 14.11: Desplazamiento de los registros: llegada de un pxel del borde
Algo similar ocurre cuando se est en un pxel de la primera columna, como se muestra en la figura 14.12. En esta imagen se pasa de estar procesando el pxel nmero doce, que no se puede procesar por estar en un borde, a procesar el pxel trece, que s se puede procesar. El pxel que se est procesando coincide con el pxel que est en el registro p5, sealadoenrojoenlasimgenes.
El pxel 12 no se procesa 0 6 12 18 24 30 1 7 13 19 25 31 2 8 14 20 3 9 15 21 4 10 16 22 28 34 5 11 p6 17 23 29 35 10 9 8 p3 7 p2 6 p1 5 p3 8 p2 7 p1 6 16 15 14 13 p5 12 p4 11 17 16 15 p6 14 p5 13 p4 12 p9 19 p8 18 p7 17 p9 20 p8 19 p7 18
26 27 32 33
11
10
Figura 14.12: Desplazamiento de los registros: salida de un pxel del borde
Cuando se han enviado todos los pxeles (en este caso los 36), se estar procesando el pxel 28, que es el ltimo pxel procesable. A partir de este pxel, el resto de pxeles corresponden con bordes y estarn en negro en la imagen procesada. De todos modos, si sequieranvaciarlosregistros,habrquecontinuardesplazandolosregistroshastaquese vacen. As que en el circuito hay que incluir un control para indicar si los pxeles corresponden conpxelesdelborde,paradarlaordenderealizarlaconvolucinono.Encasonegativo, deber de poner el pxel resultante en negro. Este control deber contar el nmero de pxel que se est procesando y determinar tambin cundo se termina el procesamiento de la imagen. El control indicar cundo se deben desplazar los registros, que en lneas generalescoincideconlasealdeavisodelaUART(aviso_rx). Hay varias formas de implementar este control y el circuito de los registros de desplazamiento. En la figura 14.13 se muestra un esquema simplificado de los bloques de estecircuitoysurelacinconotrosmdulos.Sinembargo,esteesquemaessimplificadoy puede haber seales que debas incluir, dependiendo de ciertas decisiones de implementacin que tendrs que tomar. Por ejemplo, no se ha incluido la seal de habilitacindeldesplazamientodelosregistros.
242
BufferImg ctrl_dsplz ProcVentana desplaza UART_RX aviso_rx p9 dato_rx_out

8
inicproc_vent p9 p8 13 p7 12 p8 p7 p6 p6 p5 7 p4 6 p5 p4 finproc_vent p3 p3 2 p2 1 p1 0 p2
8
14
11
10
resul
p1
Figura 14.13: Diagrama de bloques simplificado del mdulo de los registros de desplazamiento
14.4.3. Uso de un bfer circular

Envezdeponerregistrosdedesplazamientoenelcircuitoanterior,sepuedeimplementar usando bferes112 circulares. Si la imagen tiene un gran nmero de columnas, puede ser mejordescribireldiseoconbferescircularesenvezdeconregistrosdedesplazamiento, ya que el bfer circular se puede implementar con una memoria y podramos utilizar los bloquesBRAM. Conceptualmente, un bfer circular es una memoria sin comienzo ni fin, es decir, el ltimoelementoesconsecutivoconelprimero. No se entrar en detalle con el funcionamiento del bfer circular, pero se darn algunos conceptos de su funcionamiento bsico. En la figura 14.14 se han capturado tres momentos en donde se han aadido tres elementos en el bfer. Para facilitar el entendimiento, estos elementos se han llamado consecutivamente con el orden de entrada:0,1y2.
fin fin fin principio 0 principio 1 0 principio 2 1 0
Figura 14.14: Esquema de la escritura de tres elementos en el bfer circular
Normalmente el bfer circular tiene dos punteros que indican el primer elemento del bfer (principio) y el ltimo (fin)113. Cada vez que se introduce un nuevo elemento en el bfer se incrementa el puntero de fin, ya que este puntero indica el ltimo elemento introducido.
112 113
Adaptacinalespaoldelapalabrainglesabuffer Alternativamente,envezdelpunterodefinsepuedeponerladireccinsiguiente,queeselpunteroala direccindondeentrarelnuevoelementoqueseintroduzca.
243
LosbferescircularesfuncionancomounaFIFO.ElnombreFIFOvienedelasinicialesen ingls: first in first out, y son un tipo de pilas en las que el primer elemento que ha entrado es el primero en salir. Si se saca un elemento del bfer saldr el elemento apuntado por el puntero de principio (que apunta al primer elemento) y el puntero de principioseincrementar. Si el bfer est lleno y se introduce un nuevo dato se sobreescribe el primer elemento introducido (sealado por el puntero de principio), y los punteros de principio y fin se incrementanunaposicin(verfigura14.15).
11 12 4 13 3 14 2 15 1 16 0 17 31 18 30 19 29 20 28 21 27 22 26 25 24 23 5 8 9 10 6 7 11 12 4 13 3 principio 2 14 15 1 fin 32 16 17 31 18 30 19 29 20 28 21 27 22 26 25 24 23 5 8 9 10 6 7 principio fin 11 12 13 3 14 2 15 33 16 32 17 31 18 30 19 29 20 28 21 27 22 26 25 24 23 4 5 8 9 10 6 7
principio fin
Figura 14.15: Llenado del bfer circular y escritura con el bfer lleno
El bfer circular se puede simplificar en nuestro circuito, ya que se puede trabajar con un nico puntero. En nuestro caso no vamos a introducir y sacar elementos en el bfer de forma independiente. Siempre que se introduce un dato nuevo se pondr en la salida el valoranteriorquehabaenladireccindememoriadondeseescribe. Enlafigura14.16muestraelmovimientodelpunterocuandoelbfernoestlleno.
puntero puntero puntero 0 1 0 2 1 0
Figura 14.16: Bfer circular con un nico puntero
Cuandoelbferestlleno,alintroducirunnuevoelemento,debersacarelelementoque haba. Por ejemplo, en la figura 14.17, cuando se introduce el 32, el bfer saca el 0. Y as sucesivamente, cuando se introduzca un nuevo elemento, el bfer sacar el uno. En realidad, esto es lo que ocurre cuando el bfer no est lleno, pero los valores previos que tengalamemoriasonindefinidos(ocerosilamemoriasehainicializado).
244
11 12 13 3 14 2 15 1 puntero 16 0 17 31 18 30 19 29 20 28 21 27 22 26 25 24 23 4 5
8 9 10 6 7
11 12 13 puntero 2 14 15 1 16 32 17 31 18 30 19 29 20 28 21 27 22 26 25 24 23 4 5 3
8 9 10 6 7
Al escribir un nuevo dato en el bfer, el bfer sacar el elemento que tena (el cero)
Figura 14.17: Funcionamiento del bfer circular con un nico puntero cuando est lleno
El diagrama de bloques simplificado implementado con bferes circulares se muestra en la figura 14.18. Este diagrama es la adaptacin con bferes de la versin de la figura 14.9 que tena registros de desplazamiento. Los tres registros de la derecha de cada fila se mantienen fuera de los bferes para tenerlos disponibles para el procesamiento. Por lo tanto, las bferes tendrn tantos elementos como columnas tenga la imagen menos tres (lostresquesehansacado).
ancho de la ventana UART_RX dato_rx_out
8
p9
p8
p7
Bufer
p6
p5
p4 alto de la ventana
Bufer
p3
p2
p1
Bufer de tantos elementos como columnas de la imagen menos 3
Figura 14.18: Variante del circuito de la figura 14.9 implementado con bferes
El bfer que tenemos que realizar es sencillo ya que cada vez que entra un dato tiene que salirotro(queserelprimeroquehaentrado).Asqueslotienetrespuertos(ademsdel relojyreset),queson:elpxelqueentra(pxl_in),elpxelquesale(pxl_out)ylasealque avisa que va a entrar un nuevo pxel (metepxl). La figura 14.19 muestra un posible esquemadelbfer.EnelcircuitohayunaRAMdeunnicopuertoyconmododelectura primero (read first). Las memorias RAM de este tipo se vieron en el cdigo 12.12. En el esquema tambin hay un contador, que es un contador circular que simplemente va aumentando la cuenta cada vez que llega un nuevo pxel. El fin de cuenta coincide con el tamaodelaRAM.Cuandolacuentallegaasufin,vuelveaempezardesdecero.
245
FIFO pxl_in metepxl contador incr clk rst

8
RAM_rf din dout

8
pxl_out
we RAM read first addr clk
Figura 14.19: Diagrama de bloques de la FIFO
Como siempre, el diagrama de la figura 14.19 es una propuesta que puede variar segn como implementes el diseo. Siempre debes comprobar mediante simulacin que funcionacorrectamente. Si no fuese posible utilizar una memoria con modo de primero lectura, habra que modificar el circuito. Por ejemplo utilizando una memoria RAM con dos puertos, uno para leer y otro para escribir. La cuenta de la lectura estara adelantada respecto a la de escritura, y la memoria tendra que tener un elemento ms. Si no es posible utilizar una memoria de doble puerto, habra que realizar la operacin en dos ciclos de reloj, o habra que tener preparado el pxel que se va a leer en un registro auxiliar antes de realizar la escritura.Comoyasabemos,existenmuchasposibilidadeseneldiseodigitalyeslatarea deldiseadorelegirentreellassegnlosrequisitosdelsistemayeltiempoquetienepara realizareldiseo.
246
15. Videojuego Pac-Man

Terminaremos este libro haciendo una versin simplificada del videojuego PacMan, tambin conocido en Espaa por comecocos. En este diseo no haremos nada que no hayamos hecho en los anteriores, pero nos permitir volver a utilizar y afianzar muchos de conceptos vistos. Al terminar la prctica podrs intentar implementar otros videojuegos clsicos en la FPGA, tal como han realizado los alumnos de DCSE en prcticas:SuperMarioBros,SpaceInvaders,Tetris,Arcanoid,Frogger,Zelda... Todava se nos quedarn temas por tratar en este libro, como seran profundizar en la optimizacin, diseos con varios relojes, uso de memorias externas, microprocesadores, buses, otros tipos de perifricos, ... quiz para otro libro, an as, con el conocimiento que puedeshaberadquiridoseguramentetendrslabasesuficienteparaafrontardiseosms complejosyseguiraprendiendoportimismo.
15.1. Videojuego Pac-Man

El videojuego PacMan se cre en 1980. El juego transcurre en un laberinto, el pacman es una cabeza amarilla con boca que tiene que comer las bolitas que hay por el laberinto sin que sea comido por los fantasmas. Hay cierto tipo de bolitas que son mgicas y permiten alpacmancomersealosfantasmas. Hay muchas versiones del videojuego, la figura 15.1 muestra la versin de las mquinas recreativas.Enlafigura15.2semuestralaadaptacinparaAtaricreadaen1981.
Figura 15.2: Versin del Pac-Man para Atari
Figura 15.1: Videojuego Pac-Man
No pretendemos implementar todas las funcionalidades del videojuego. Haremos una versinmssimplequetepermitir,silodeseas,implementarelvideojuegocompletopor timismo. Como hemos ido haciendo en el libro, implementaremos el diseo paso a paso. Primero crearemos el campo de juego, luego el mueco del pacman con su movimiento a travs del campo de juego. Posteriormente limitaremos el campo de juego con las paredes del laberinto. A continuacin crearemos las bolitas que se come el pacman, incluyendo la puntuacin.Porltimo,crearemosalosfantasmas.
247
Antes de empezar a leer, te animamos a que pienses cmo implementaras el videojuego. Luego, compara lo que has pensado con las propuestas que se van haciendo en este libro, y en caso de que sean diferentes, podras implementar ambas y comparar cul te parece mejor. Tambin te recomendamos que hagas lo mismo con cada uno de los apartados. Antes de leer el apartado, dedica un tiempo a pensar tu manera de implementarlo. Un diseo que parece obvio, puede haber requerido mucho tiempo en su elaboracin y estructuracin, y enfrentarse a esta primera fase es una de las tareas ms importantes del diseador.
15.2. El campo de juego

El campo de juego va a ser una matriz de 32 columnas y 30 filas. En principio, el pacman podr tener una de estas 960 posiciones (32x30= 960). Cada elemento de la matriz (celda) tendr 16 pxeles de ancho y 16 de alto114. Por lo tanto, el campo de juego tendr 512 pxeles de ancho y 480 pxeles de alto, estas dimensiones hacen que quepa en nuestra pantalla VGA que tiene 640x480 pxeles. Como el alto del campo de juego mide lo mismo que el de la pantalla, si se quiere incluir un marcador o alguna otra informacin, como el nmero de vidas del pacman, se tendrn que poner a los lados. Pondremos el campo de juegoalaizquierdadelapantallaylapartedelainformacin(marcador)aladerecha.La figura15.3muestralamatrizdelcampodejuegoysurelacinconlapantallaVGA.
lneas del campo fila_cuad columnas del campo de juego/laberinto (col_cuad)
0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
Zona del marcador

16 pxeles
0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D
16 pxeles
zona del marcador
cuadrcula del campo de juego
480 pxeles 30 cuadrculas
32 cuadrculas 512 pxeles
128 pxeles
Figura 15.3: Cuadrcula del campo de juego y su relacin con la pantalla de 640x480
114
Conestasdimensionesylaresolucindelapantallalosmuecossalengrandes,puedesoptarareducirlas celdasa8x8yasinclusopoderhacerellaberintomsgrande.
248
Podemos apreciar la similitud con el circuito que dibuja los caracteres por pantalla (captulo 13 y su figura 13.4). En este caso, las celdas son de 16x16 pxeles. Ya sabes la importancia de elegir nmeros que sean potencias de dos. El clculo de la columna y fila de la cuadrcula (col_cuad y fila_cuad) se realiza dividiendo el pxel de la pantalla (pxl_num) y la lnea de la pantalla (line_num) entre 16, esto es lo mismo que quitar los cuatro bits menos significativos. Esto es similar al clculo realizado en el apartado 13.4, peroenaquelcasoserealizabaconcuadrculasde8x16. En este caso hemos elegido un campo de juego de 32 columnas para calcular por concatenacin el nmero de la cuadrcula (la celda: cuad_num). Puedes elegir otro nmero distinto y realizar las operaciones realizadas en el apartado 13.4. Sin embargo, si eliges 32 columnastebastarconcatenaradecuadamentefila_cuadconcol_cuad,comosehacaen el apartado 12.2.3.6 (teniendo en cuenta que en ese apartado se concatenaban line_num y pxl_num). Antesdeseguir,terecomendamosquepruebeslacuadrcula,paraellopuedesdibujarun tablerodeajedrezconlascuadrculas,porejemplo: Lasfilasdelacuadrculaqueseanpares,fila_cuad(0)='0',tendrn:

lasceldaspares(col_cuad(0)='0')enblanco lasceldasimparesennegro lasceldasparesennegro lasimparesenblanco
Lasfilasdelacuadrculaqueseanimparestendrn:

Lazonadelmarcadorestarenazul
Una vez que tengas la cuadrcula puedes pasar al siguiente apartado. Recuerda realizar copias de los proyectos y trabajar con las copias, de modo que siempre tengas los proyectos de los apartados anteriores disponibles, por si todo va mal o por si decides retomarlos.
15.3. El jugador sin rostro

Queremos mover el pacman por el tablero de ajedrez (cuadrcula) que hemos hecho. El pacman tendr unas coordenadas (col_pacman fila_pacman) referidas a la columna y fila delacuadrcula(col_cuadyfila_cuad),porloquetendrnlasmismasdimensiones. Antes de empezar a disear, mejor que crees un proyecto nuevo y copia los archivos del anterior. Tendremosqueaadiralproyectounmdulodeinterfazconlospulsadores115paradirigir el movimiento del pacman. Ser un mdulo similar al explicado en el apartado 10.1, pero ahora el pacman se mueve de celda en celda, por lo tanto, de 16 en 16 pxeles. Si en el interfaz con los pulsadores eliges el modo de movimiento continuo (apartado 10.1), la velocidad de movimiento deber ser unas 16 veces ms lenta que la que hiciste en el diseo del Pong. Si el movimiento es por pulsaciones, ir de celda en celda y no habr problema, aunque quiz sea demasiado lento. Otra opcin es que el pacman siempre est en movimiento, y su direccin venga determinada por el ltimo pulsador que se haya presionado.
115
Tambinpuedeshacerinterfazconelteclado
249
Encualquiercaso,elinterfazconlospulsadoresproporcionarlassealesdemovimiento delpacmanencuatroposiblesdirecciones:arriba,abajo,derechaeizquierda.Estasseales debern de ser lo suficientemente lentas para que los movimientos sean visibles y controlables. Slo una de estas seales podr estar activa en cada momento, o si no, establecerprioridadesentreestasseales. Estas seales de las direcciones harn cambiar las coordenadas del pacman (col_pacman
fila_pacman). En el caso de que se superen los bordes del campo de juego, el pacman
aparecer por el otro extremo. Esto es, si est en la primera fila (la de arriba) y tiene la orden de subir, aparecer por la ltima fila (la de abajo) sin cambiar de columna. Lo mismoocurrirenelotrosentidoyenlascolumnas. En este diseo, adems de mostrar por la VGA el tablero de ajedrez que hiciste en el apartadoanterior,debermarcarenamarillolaceldadondeestelpacman.Recuerdaque la celda donde est el pacman viene determinada por col_cuad y fila_cuad. Estas seales tendrn que ser registros y los tendrs que inicializar mediante el reset al valor que estimes conveniente dentro de la cuadrcula. En la pantalla deber aparecer la celda del pacmanpintadacompletamentedeamarillo.Al presionarlospulsadoreslaceldaamarilla deber moverse por la pantalla. Comprueba que se mueve a una velocidad adecuada y quealatravesarlosbordesapareceenelladocontrario.
15.4. El pac-man
El jugador del diseo anterior no tena mucha gracia ya que no tena rostro, queremos mostrar al verdadero pacman. Realmente no hace falta mucha explicacin para esta tarea, ya que has hecho algo muy parecido en el captulo de escribir caracteres por pantalla. En aquelcaptulopintbamosloscaracterescorrespondientesalasceldas,ahoratenemosque pintarlafiguradelpacmanenunaceldadeterminada. Tenemos que crear una ROM con la imagen del pacman, puedes escoger el tipo de ROM queprefieras:enblancoynegro,escaladegrisesoatrescolores.Cmopintarestetipode memoriaslovimosenelcaptulo12. Partiremos del caso que consideramos ms sencillo, que es tener la ROM de ancho de palabra igual a los pxeles del ancho de la celda y tantas posiciones de memoria como el alto de la celda. Esto lo hicimos en el cdigo 12.4 y en la escritura de caracteres por pantalla. El cdigo 15.1 muestra la constante que tiene los valores de la ROM, para hacer la ROM simplemente tendras que copiar esa constante en una arquitectura como la del cdigo12.4yverificarquelosrangosdelassealessoncorrectos.
250
constant img : memostruct := ( -- FEDCBA9876543210 "0000000111100000",-- 0 "0000011111111000",-- 1 "0000111111111100",-- 2 "0001111011111110",-- 3 "0011111111111100",-- 4 "0011111111110000",-- 5 "0111111110000000",-- 6 "0111111000000000",-- 7 "0111111000000000",-- 8 "0111111110000000",-- 9 "0011111111110000",-- A "0011111111111100",-- B "0001111111111110",-- C "0000111111111100",-- D "0000011111111000",-- E "0000000111100000" -- F );
Cdigo 15.1: Constante de la ROM para dibujar el pac-man a dos colores
Asquepruebaaimplementarelcircuitoconelmuecodelpacmancomoprotagonista.Si hascogidolamemoriadelcdigo15.1,pintarasdeamarillocuandolamemoriadevuelve un uno y cuando la memoria devuelve un cero, lo mejor sera pintar el fondo. Esto es, cuando hay un cero, no pintar nada en la condicin (en el if del proceso) que pinta el pacman y dejar que la condicin que pinta el fondo ponga el color116, as parece que el pacman se mueve sobre el fondo. Si no haces esto as y los colores del fondo no coinciden conlosdelfondodelpacman,pareceraquestellevaseunaespeciedesombraincmoda. Una vez que lo tengas, comprueba que el mueco del pacman y no el cuadrado que tenamosantes,semuevebienporeltablerodeajedrez. En qu sentido te ha salido la boca del pacman? mira a la derecha o a la izquierda? recuerda del apartado 12.2.4 y del captulo 13 que si no cambibamos los ndices se dibujaba la imagen simtrica. En realidad te debera salir mirando a la derecha, pero el hecho de que se pueda cambiar tan fcilmente es una ventaja. Podemos hacer que mire hacia un lado o hacia el otro segn el sentido que tenga el pacman. Slo habra que guardarenunregistroelsentidodelltimomovimiento. Si quisisemos hacer que el pacman mire para arriba y para abajo, con la misma figura podramos hacer una trasposicin de filas por columnas. Aunque requiere un poco de anlisis y seguramente necesitars algunas pruebas, sta es la opcin ms recomendada. Otra alternativa sera crear otras dos imgenescon el pacman mirando arriba y abajo. Las imgenes se podran guardar en la misma ROM triplicando el nmero de direcciones de memoria117. La seleccin de la imagen se hara igual que la seleccin de los caracteres con laROMqueguardabaloscaracteresASCII. Una vez hecho todo esto, tendremos al pacman movindose por el tablero de ajedrez y mirandoenelsentidoenelquesemueve.
116
Portanto,lacondicinquepintaelpacmanylaquepintaelfondonodebenserexcluyentes,estoes,no debenestarenifelsif,sinoquedebenserdosifenelqueelpacmansobreescribealfondo. CreartresmemoriasROMesmenosrecomendableporquehaceaumentarelnmerodeconexiones internasdelcircuito.Adems,nuncasevanlasdistintasimgenesdelpacmansimultneamenteporloque nohayquegestionarlosaccesosindependientemente.
117
251
15.5. El laberinto
Hasta ahora el pacman se mueve libremente por el tablero de ajedrez. Queremos crear un laberinto y hacer que el pacman vea limitada su libertad de movimiento por las paredes dellaberinto. El laberinto tambin lo vamos a crear con una imagen en blanco y negro, donde los unos van a ser las paredes del laberinto y los ceros sern los pasillos por donde puede pasar el pacman. La imagen tendr que tener las mismas dimensiones de la cuadrcula del campo de juego. Pero las dimensiones estarn en cuadrculas y no en pxeles, es decir, la imagen ser de 32x30 en vez de 512x480 (recuerda las dimensiones en la figura 15.3). Con esto ahorramosmuchamemoria. Lo que haremos es pintar cada elemento de la imagen del laberinto (cada pxel) en una cuadrcula. Como las cuadrculas son de 16x16, sera como ampliar la imagen por 16. En apartado 12.2.3.5 vimos cmo mostrar una imagen ampliada por dos. Ahora, en vez de quitar el bit menos significativo (ampliacin por dos), quitaremos los cuatro bits menos significativos (ampliacin por 16). O dicho de otra manera, usaremos las coordenadas de la cuadrcula col_cuad y fila_cuad para calcular la direccin de memoria y, en su caso, el ndicedeldatodelamemoria. Asqueslohacefaltacrearlaimagendellaberinto.Enelcdigo15.2estlaconstantede la ROM para el laberinto (puedes crear otro laberinto si lo deseas). La ROM es del mismo tipo que la del pacman: cada fila de la imagen se corresponde con una direccin de memoria,ycadaelementodeldatocontienetodaslascolumnas.
constant img : memostruct := ( -- FEDCBA9876543210 "1111111111111111",-- 0 "1000000000000001",-- 1 "1011110111111101",-- 2 "1011110111111101",-- 3 "1011110111111101",-- 4 "1000000000000000",-- 5 "1011110110111111",-- 6 "1011110110111111",-- 7 "1000000110000001",-- 8 "1111110111111101",-- 9 "1111110111111101",--10 "1111110110000000",--11 "1111110110111100",--12 "0000000000100000",--13 "1111110110100000",--14 "1111110110111111",--15 "1111110110000000",--16 "1111110110111111",--17 "1111110110111111",--18 "1000000000000001",--19 "1011110111111101",--20 "1011110111111101",--21 "1000110000000000",--22 "1110110110111111",--23 "1110110110111111",--24 "1000000110000001",--25 "1011111111111101",--26 "1011111111111101",--27 "1000000000000000",--28 "1111111111111111" --29 ); -- los unos son las paredes
Cdigo 15.2: Constante de la ROM para dibujar el laberinto (mitad)
Si observas la memoria podrs ver que el ancho de palabra de la memoria es de slo 16 bits, mientras que el campo de juego tiene 32 columnas. Lo hemos hecho as porque el
252
campo es simtrico, entonces para pintar el lado derecho slo tenemos que poner la imagenespeculardelladoizquierdo.Asslonecesitamoslamitaddelamemoria. Peroantesdepintarlaimagenespecular,mejorserprobarsipodemospintarlamitadde la izquierda118. Haz una copia del proyecto anterior que pintaba el pacman e incluye la memoria del cdigo 15.2. Haz que se pinte la imagen de modo que cada pxel de la imagen tenga el tamao de una cuadrcula. El pacman deber aparecer por encima de la imagen de fondo. La imagen slo aparecer en la mitad izquierda del campo, en las primeras16columnasdelacuadrcula(256pxelesdelaVGA). Cuando lo tengas hecho, ahora vamos repetir la imagen en las siguientes 16 columnas de la cuadrcula (los pxeles del 256 al 511). En el apartado 12.2.3.4 vimos cmo repetir una imagen.Ahoraenvezderepetirlaentodalapantallalalimitaremosalcampodejuego. Si simplemente repites la imagen no quedar la imagen simtrica por el lado derecho, tendrsquecambiarlosndicesdelascolumnas.Estoloacabamosdehacerconelpacman para que mirase hacia el lado que camina y lo vimos en el apartado 12.2.4. En realidad lo quetenemosquehaceresdeshacerelcambiodendicesparaqueahorassalgalaimagen especular,puesesloquequeremos.Enresumen: En la parte izquierda del campo de juego haremos el cambio de ndices (apartado 12.2.4). Quesonlasceldas0ala15,olospxeles0a255. Enlapartederechanoharemoselcambiodendices.Celdas16a31pxeles256a511.
Noteolvidesdeelegircoloresdistintosparalasparedesdellaberintoylospasillos.
15.6. Recorrer el laberinto

Tenemos el pacman y el laberinto, pero el pacman cruza las paredes del laberinto sin problema.Enesteapartadoresolveremosestacuestin. Para tener en cuenta las paredes del laberinto, cada vez que se recibe una orden de movimiento, el circuito debe de comprobar si la nueva posicin est permitida. Si para la nuevaposicinenlaROMhayununoindicarqueesunapared,yporlotantoelpacman no se podr mover en esa direccin. Para hacer la comprobacin habr que acceder a la memoria y comprobar el elemento de la memoria correspondiente a la posicin deseada. ComotambinseaccedealaROMparapintarelcampodejuego,tendramosquerealizar uncontroldelosaccesos,yaquequeremosaccederaelladesdedossitiosdiferentes:para pintar y para comprobar la nueva posicin. Realmente no es mucho problema ya que los movimientos del jugador son muy lentos comparados con las frecuencias de la placa. Sin embargo,paraahorrarnosesecontrol,podemoshacerquelamemoriaROMdelcampode juegoseadedoblepuertoyaccederaelladeformaindependiente119. Parahacerlacomprobacinesconvenientequehagasunamquinadeestados,yaquelos accesos a memoria no son instantneos ni tampoco la actualizacin del registro que tendrs que escribir para indicar a la memoria la direccin que quieres leer. Por ltimo, si laceldaesaccesible,tendrsqueactualizarlasnuevascoordenadasdelpacman.
118
Siquieres,tambinpuedeshacerlaimagencompletaynorecurriraestostrucosparadibujarlaimagen especular Realmenteestasmemoriassonmuypequeaseinclusosepuedendefinircomoconstantesenelcdigo VHDL.Estosimplificaraenormementeelcircuito,peroloestamoshaciendoasparafamiliarizarnosconel usodelasmemorias.
119
253
Es importante tambin que la posicin inicial del pacman sea una posicin permitida (sea unceroenlaROMdellaberinto). Implementa el circuito y comprueba que el pacman slo se mueve por los pasillos, comprueba tambin que entra por el pasadizo que hay en los laterales y que sale por el ladoopuesto.
15.7. Control del movimiento del pac-man *

El movimiento del pacman no es muy suave. Si escogemos el movimiento por pulsacin, es decir, cada vez que presionamos el pulsador se mueve una celda, el movimiento es muy lento. Por otro lado, si escogemos el movimiento continuo a veces puede ser difcil desviar el rumbo por pasillos laterales. Podemos implementar un movimiento ms sofisticadoquehagalosiguiente: Al presionar un pulsador el pacman sigue la direccin fijada de manera indefinida hasta que encuentre una pared que le impida continuar. Es decir, no hace falta mantenerlo pulsadoparaquecontineelmovimiento. Si el pacman se mueve en una direccin y presionamos un pulsador de otra direccin, el pacmancontinuarmovindoseenladireccininicialhastaqueencuentreunpasilloquele permitacambiaralanuevadireccin.
Esta manera de moverse resulta ms fcil para controlar el movimiento del pacman y podermeterseporpasilloslaterales. Para implementar este movimiento necesitars crear una mquina de estados y un temporizadorquegenerepulsosparaordenareldesplazamientoperidicodelpacman.El temporizadordeterminarlavelocidaddelpacman.Otraalternativaespermitirpresionar dos pulsadores simultneamente siempre que no sean de direcciones opuestas. Sera similaraunmando(joystick)quepermitedireccionesoblicuas. La implementacin de este control de movimiento no es necesaria, pero mejora enormementeelcontroldelpacman.
15.8. La comida y los puntos

El pacman tiene que comerse todas las bolitas de comida que hay en el laberinto y esto le permite pasar de nivel. Cada bolita de comida le da un punto. Para implementar la comida puedes crear una memoria RAM del tamao de la cuadrcula (32x30). Esta memoria RAM tendr todos sus valores a cero (hay comida) y cada vez que el pacman paseporunacelda,seescribirununoenlaposicindememoriacorrespondiente.Porlo tanto, un cero en la memoria RAM significara que hay comida o lo que es lo mismo, que elpacmannohapasadoporall.Yununosignificarquenohaycomidaoqueelpacman hapasado. Si el pacman pasa dos veces por la misma celda se puede volver a escribir un uno en la memoria, no pasa nada por escribir de nuevo un uno en la memoria cuando ya haba un uno. Lo que s es importantees no volver a sumar puntos. Tendrs que crear un contador de puntos que se vaya incrementando cuando el pacman entre en una celda con comida (conunceroenlamemoriaRAMdelacomida).
254
Si se hace de esta manera habr puntos que nunca se podrn comer, pues la memoria RAM de la comida contiene todas las celdas de la cuadrcula, incluyendo las celdas de pared del laberinto por donde el pacman nunca podr transitar. No pasa nada, lo importante es tener en cuenta el nmero mximo de celdas transitables de un laberinto. Tendremos que crear un contador para cada laberinto que cuente el nmero de bolitas que se han comido (celdas transitadas), cuando se llegue al nmero mximo de celdas transitables se habr terminado la pantalla. Este nmero mximo de celdas transitables lo podrs calcular a mano y ponerlo como constante para cada laberinto, o tambin puedes crear un circuito que en la inicializacin cuente las celdas transitables del laberinto. La primeraopcinesmsfcildehacerparaunapantalla,mientrasquelasegundaopcines msgeneralizableyproducemenoserrores. De manera similar a la memoria ROM del laberinto, se accede a la memoria RAM de la comida desde dos sitios diferentes. Por un lado se accede al dibujar la pantalla y por otro ladoseaccedeparacontabilizarlospuntosyescribircundosetransitaporlasceldas.Por lo tanto podemos implementar la memoria RAM con doble puerto para independizar estasdospartes. Cuando se pinta el laberinto en la pantalla, entre otras, hay que hacer las siguientes comprobaciones: Siespared:sepintalaparedcomosehahechohastaahora.Nosemirasihaycomida,pues enlaparednosepintalacomida. Siespasillo:

Sinohaycomida:sepintaelpasillocomohemoshechohastaahora Sihaycomida:sepintaunabolitadecomidaconelmismocolordefondoqueelpasillo. Para la bolita de comida puedes crear una imagen de la misma manera que el pacman, tambin puedes crear imgenes ms sofisticadas con ms colores, o simplemente pintar deuncolordistintolospxelescentralesdelacelda.
Porltimo,puedesincluirunmarcadoraladerechaqueindiqueelnmerodepuntosdel pacman,queporahoraeslacuentadelnmerodebolitasquesehacomido.
15.9. Las paredes del laberinto *

Hemos pintado las paredes del laberinto de un color, coloreando toda la cuadrcula del mismocolor.Hacindoloas,lasparedesseparecenmsalaversindeAtari(figura15.2) quealaversindelasmquinasrecreativas(figura15.1).Podemosdejarlasparedescomo estn, pero si queremos un acabado ms similar al de las mquinas recreativas podemos pintarlasparedes. En la figura 15.4 se muestran las paredes como estn ahora. Para no dibujar el campo de juego entero, slo se muestra la esquina superior izquierda. En la figura se ha escogido el negrocomoparedyelblancocomopasillo,perocualquierotracombinacindecoloreses vlida. En la figura 15.5 se muestra el diseo cuadriculado que dibujara bordes redondeados.Estediseoserasimilaraldelaversindelasmquinasrecreativas(figura 15.1), aunque en el dibujo se ha escogido una combinacin de colores distinta para facilitarlavisualizacin.
255
contina
contina
...
...
contina
contina
...
...
Figura 15.4: Paredes rellenas con un slo color
Figura 15.5: Paredes rellenas con dibujos
Observandolafigura15.5podemosverquehaysietetiposdeceldasparapintarlapared. Estas celdas se muestran en la figura 15.6. Recordemos que en nuestro diseo las celdas son de 16x16, por lo tanto, las formas circulares aparecern un poco pixeladas, igual que lo era la imagen del pacman. El ancho de la lnea puede ser de dos pxeles y estarn centradosenlacuadrcula.
1 0 2 3 4 5 6
Figura 15.6: Tipos de celdas para pintar las paredes del laberinto
Por tanto se podra crear una memoria ROM que tuviese las imgenes de los tipos de celda de las paredes del laberinto. Los tipos de celda a pintar se pueden reducir a dos, ya que el tipo cero (figura 15.6) no necesita memoria; los tipos uno y dos, son el mismo dibujocambiandofilasporcolumnas;ylostipostres,cuatro,cincoyseis,sonelresultado de distintos cambios de filas y columnas (similar a las del dibujo del pacman visto en el apartado15.4).Puedeselegirloqueteseamsfcil:incluirenlaROMdostiposdeceldas yhacercambiosdefilasycolumnas,oincluirseistiposdeceldas. El tipo de celda de la pared viene determinada por las cuatro celdas adyacentes (arriba, derecha, abajo e izquierda). Dependiendo de si las celdas adyacentes son de pasillo o de pared, el tipo de celda a dibujar en la pared ser distinto. Tambin hay que considerar como casos especiales los bordes del campo de juego. El clculo para obtener del tipo de pared que hay que pintar es sencillo, la figura 15.7 muestra cuatro de las 16 posibles combinaciones120 (sin contar los bordes del campo de juego). Hay un caso que no se ha considerado, que es la pared rodeada de pasillo en las cuatro direcciones y su implementacinpodraseruncrculo.
120
Sincontarlosbordesdellaberinto.Adems,estoseneljuegooriginal(figura15.1)tienenunalneadoble, igualqueelcuartocentraldedondesalenlosfantasmas.
256
pasillo
pared
pared a la que se le calcula el tipo de celda para pintar
Figura 15.7: Obtencin del tipo de celda para pintar las paredes a partir de las celdas adyacentes
Parasaberqutipodeparedhayquepintarencadacasohayvariasalternativas: UsarotramemoriaROMquenosindiqueparacadaceldadeparedqutipoes.Losvalores de esta memoria los calcularamos manualmente121 segn los valores de la memoria ROM del laberinto (apartado 15.5). Como el nmero de tipos de pared son ms de dos, la memoria necesitara ms de un bit por celda, y por tanto, la memoria deber de tener tantas posiciones de memoria como celdas del laberinto. Es decir, no se puede poner toda una fila en una posicin de memoria como hemos estado haciendo con las memorias del pacmanydellaberinto. Porotrolado,recuerdaquelamemoriadellaberintoestabaalamitad,porquelaparte derecha es simtrica a la izquierda. Esto se puede seguir haciendo para esta nueva memoria ROM sabiendo que a la hora de pintar las paredes de la izquierda que sean deltipo3y4enlapartederechasecambiarnporlasdeltipo5y6respectivamentey alainversa(lasdel5y6secambiarnporlasdel3y4).Losotrostiposdeparedesson simtricos. Las celdas que son de pasillo se pueden dejar como de tipo cero (figura 15.6). Lo peor de este mtodo es que requiere hacer a mano la ROM cada vez que se crea un nuevo laberinto. OtraalternativasimilaralaanteriorescrearunanicamemoriaROMparaellaberintoyel tipo de pared. Bastara simplemente con incluir un tipo de celda ms que fuesepasillo. Conestotendramosochotiposdeceldas(recuerdalafigura15.6),quejustamentecabran enunbyte. Se puede realizar un mdulo al empezar que calculase el tipo que se pintar para cada celdadepared.SecalcularaapartirdelaROMdelpasilloyseguardaraenunamemoria RAM. Una vez guardados los datos en la memoria RAM este mdulo quedara inactivo y la memoria RAM funcionara de manera similar la ROM de las alternativas anteriores. La gran ventaja de este mtodo es que si se implementan varios niveles con distintos laberintos, el circuito se encarga de realizar los clculos, sin tener que realizarlos manualmente. Por otro lado, en los casos anteriores se necesita una ROM con el tipo de celda de pared para cada laberinto, en este caso slo se necesita una RAM, en la que se guardan los datos de las celdas al principio de cada laberinto. El tiempo empleado para realizar el clculo es insignificante y el jugador no se dara cuenta. Este mdulo tendra muchas caractersticas similares a los mdulos de procesamiento de imgenes que realizamosenelapartado14.2.
Tambinsepodracrearunejecutablequegenerelasmemoriasapartirdeunaimagen,similaraldescrito enelapartado12.2.6
121
257
Porltimo,tambinsepodracalculareltipodeceldadeparedenelmismomomentoque se est pintando. La dificultad de este mtodo es que para el clculo se necesitan cinco pxeles de la memoria del laberinto (cdigo 15.2), que son el pxel de la celda que se est pintando ms los cuatro pxeles adyacentes. Esto hace que se requieren varios accesos a memoria,porloquehayqueanticiparseparaquelosretardosnohaganquenosemuestre el pxel correcto. La ventaja de esta implementacin es que no se necesita una memoria paraguardarlostiposdeimgenesapintar.Estemdulotendraalgunassimilitudesconel procesamiento al vuelo del apartado 14.4.2, pero ahora resulta ms sencillo porque cada fila est en una posicin de memoria, y en el apartado 14.4.2 tenamos un pxel en cada posicindememoria.
Paraterminar,sepuedencrearparedesdellaberintomssofisticadasconmuypococoste, ya que slo se necesitan unos pocos tipos de celdas. En vez de los sencillos dibujos de la figura15.6sepuedencrearceldascontrescoloresymsprofundidaddecolor.
15.10. El tamao del pac-man *

Si has implementado la propuesta del apartado anterior, el pacman quedar pequeo frente al ancho del pasillo. Esto es porque las paredes del pasillo no ocupan toda la celda sino la zona central. En la figura 15.8 se puede comparar el tamao de los pasillos con la figuradelpacman.
Figura 15.8: Tamao del pac-man comparado con el antiguo y el nuevo pasillo
As que opcionalmente se puede ampliar el tamao del pacman al doble del tamao original para que ocupe la mayor parte del pasillo. La figura 15.9 muestra cmo quedara elpacmanenrelacinconelnuevopasillo.
Figura 15.9: Pac-man ampliado para que ocupe la mayor parte del pasillo
La implementacin de esta variante es fcil. Hay que crear una memoria ROM para el pacman que tenga el doble del tamao del anterior, en nuestro caso de 32x32. Podramos tambin utilizar la que tenamos, mostrndola al doble de tamao. Sin embargo, como el pacman es redondo, quedar mejor si lo dibujamos a 32x32 de lo contario quedar muy pixelado. Por ltimo slo queda pintarlo. En el proceso que asigna los colores de la VGA ya no podemos seleccionar el rea del pacman basndonos en la fila y columna de la cuadrcula (fila_cuad=fila_pacmanycol_cuad=col_pacman)yaqueahoraelpacmanocuparatambin parte de las ocho cuadrculas adyacentes, tal como se puede ver en la figura 15.10. Por lo tanto, ahora tenemos que calcular los pxeles y lneas de la pantalla donde empezara a dibujarselaimagen(referidosalapantallaynoalacuadrcula). Lafigura15.10muestraenqupxeldelapantallahayqueempezaramostrarelpacman, simplemente hay que restar 8 (la mitad de una celda) a la columna y a la fila de la VGA
258
donde comienza la cuadrcula del pacman. La columna y la fila del pacman (col_pacman y fila_pacman) se multiplican por 16 porque stas son la columna y fila de la cuadrcula, y queremosobtenerlacolumnaylafiladelaVGA.
16 col_pacman - 8 32 pxeles
16 fila_pacman - 8 32 pxeles fila_pacman
col_pacman
Figura 15.10: Coordenadas del pac-man ampliado
Ahora slo queda dibujar una imagen de 32x32 a partir del pxel de la pantalla que acabamosdecalcular.Estoyalohemoshechovariasveces(recuerdaelapartado12.2.3.3).
15.11. Movimiento continuo del pac-man *

Nuestro pacman se mueve dando saltos de celda en celda, es decir, de 16 en 16 pxeles. Esto no es un gran problema, pero es ms agradable verlo mover de un modo ms continuo. Para ello podemos implementar un movimiento que vaya de pxel a pxel. Aunque el pacman se mueva de pxel en pxel, esto slo ser una apariencia ya que realmente el pacman se seguir moviendo de cuadrcula en cuadrcula. Es decir, las posiciones del pacman seguirn estando referidas a la cuadrcula (col_pacman y fila_pacman). Este movimiento del pacman slo tiene sentido si hemos implementado un movimiento continuo del pacman. Si el movimiento del pacman viene determinado por pulsaciones individuales de los pulsadores, no tiene mucho sentido, aunque tambin se podra implementaryseguramentequedaramejor. Si el movimiento no est generado por las pulsaciones de los pulsadores, el pacman tiene una velocidad de movimiento determinado por un contador que, o bien muestrea los pulsadores (apartado 15.3) o bien genera pulsos que ordenan el movimiento del pacman (apartado15.7). Lo que habra que hacer es establecer otra cuenta 16 veces menor que ordene el movimiento aparente del pacman de pxel en pxel. Habr muchas maneras de implementarestecontrol,porejemplo,sepodrahacerunacuentanuevaquesea16veces menor que la cuenta original, y ahora, la cuenta original, en vez de contar ciclos de reloj, contar 16 pulsos de la nueva cuenta. Llamaremos a esta cuenta pacm_pxlmov y haremos que esa cuenta sea descendente, de quince a cero. La figura 15.11 muestra de manera esquemticaelmovimiento.
259
Posicin Inicial
16 col_pacman - 8 16 col_pacman - 8 15 16 col_pacman - 8 14 16 col_pacman - 8 8
Posicin Final
16 col_pacman - 8 0
Cambio de posicin
...
col_pacman=1 col_pacman=2 col_pacman=2 col_pacman=2
...
col_pacman=2
pacm_pxlmov=0
pacm_pxlmov=15 Comienza la cuenta atrs
pacm_pxlmov=14
...
pacm_pxlmov=8
...
pacm_pxlmov=0
Se resta a la posicin
Figura 15.11: Movimiento del pac-man pxel a pxel hasta llegar a la posicin final
Analicemoselmovimientodelpacman: El pacman parte de la posicin inicial estando en la columna uno de la cuadrcula (col_pacman=1). Elpacmanrecibelaordendemoversealaderecha,porlotantopasaaestarenlacolumna dos(col_pacman=2). En este momento comienza la cuenta atrs de pacm_pxlmov y vale quince. El valor de pacm_pxlmov se puede entender como el nmero de pxeles que le quedan para llegar a su destino. Para pintar el pacman se calculan sus coordenadas como se hizo en la figura 15.10 pero al valordelacolumnaselerestaelvalordepacm_pxlmov. Se contina haciendo lo mismo, y el pacman se ir acercando a su destino pxel a pxel, hastaquepacm_pxlmovseacero,yentonceselpacmanyadibujarcentradoessucelda.
En el ejemplo de la figura 15.11 el pacman se est moviendo a la derecha, por lo tanto pacm_pxlmovserestaalacolumna.Enelcasodequeelpacmanseestuviesemoviendoala izquierda,elvalordepacm_pxlmovsesumaraalvalordelacolumna.Yenloscasosenlos que el movimiento fuese hacia arriba o hacia abajo, el valor de pacm_pxlmov se sumara o restaraalascoordenadasdelafila.
15.12. El pac-man comiendo *

Nuestro pacman va con la boca abierta por todas partes, podemos hacer que abra y cierre la boca mientras camina y se come las bolitas de comida. Incluir esto tambin es sencillo, sobretodosihasimplementadoelmovimientocontinuodelapartadoanterior.Solamente tenemos que incluir en la ROM una imagen del pacman con la boca cerrada (un crculo completo)quealcombinarlaconladelabocaabiertaparecerqueabreycierralaboca. Si se desea un mayor realismo se pueden crear varias imgenes con la boca ms o menos abierta e irlas combinando durante el movimiento. La cuenta pacm_pxlmov del apartado anterior viene muy bien para la implementacin de este movimiento de la boca. Segn el valor de la cuenta se seleccionarn unas u otras imgenes del pacman con la boca ms o menos abierta. El cambio de las imgenes depender de la velocidad de movimiento del pacman y del nmero de imgenes que se tengan. Cuanto mayor nmero de imgenes, ms similares sern las imgenes contiguas y por lo tanto ms rpidamente se podrn
260
cambiar. Pero hay que tener en cuenta que cambios muy rpidos no son perceptibles por elojo/cerebrohumano.
15.13. Los fantasmas

Llega el momento de incluir a los malos del juego. Para los fantasmas tendrs que crear imgenes de ellos, si has ampliado el pacman como se sugera en el apartado 15.10, tendrs que crear los fantasmas del mismo tamao. No hace falta crear una imagen para cada fantasma, basta con usar la misma imagen y pintarla de distinto color. Eso s, cada fantasmadebertenersuspropiascoordenadas. Los ojos de los fantasmas miran hacia donde caminan, puedes implementar esto usando cuatro imgenes distintas con cuatro direcciones de ojos, o mejor an, puedes crear imgenes de los ojos independientes. Estos ojos se superpondrn a los fantasmas y as tambin podremos tener los ojos sin fantasma, que es lo que ocurre cuando son comidos por el pacman y tienen que volver a su casa. Esto ser en caso de que implementes las bolitas de comida mgicas. En caso de que superpongas los ojos tendrs que definir un colortransparenteparaquesepinteelfondo(elfantasma). Adems no hace falta crear imgenes de ojos de 32x32122, sino que como los ojos siempre estarnenlamitadsuperior,podemosolvidarnosdelamitadinferior.Eincluso,comolos ojos son iguales, podemos guardar un slo ojo y repetirlo en la otra mitad. As que la imagendelosojospuedeserdelamitad:16x16,silosfantasmassonde32x32. Y no slo esto, sino que como los ojos que miran a la derecha son simtricos con los ojos que miran a la izquierda (simetra vertical); e igual con los que miran arriba y abajo (simetrahorizontal),nospodrabastarcondosimgenesdeunsloojo. De la misma manera que el pacman, los fantasmas tambin tendrn unas coordenadas basadas en la cuadrcula pero los fantasmas podrn simular un movimiento continuo similaraldelpacmanquevimosenelapartado15.11. El movimiento de los fantasmas no est dirigido por los pulsadores, as que tenemos que crear nosotros el movimiento. Este movimiento debe ser ms o menos aleatorio. El movimiento no debe ser muy aleatorio porque si no sera muy errtico, los fantasmas debentenerunaciertacontinuidadenelmovimiento.Paraintroduciraleatoriedadpuedes basar la toma de decisiones en sucesos externos, por ejemplo, el nmero de ciclos de reloj que han pasado desde la ltima vez que se ha presionado/soltado un pulsador. O por ejemplo, basarlo en el nmero de celda donde est el pacman. Por ejemplo, tomando los ltimos bits de la fila y columna de la celda, y basando la nueva direccin en los valores de estos bits. Tambin puedes dotarlos de cierta inteligencia para que intenten encontrar alpacman. Porltimo,hayquecontrolarsielfantasmamataalpacman,ylasvidasdelpacman.
15.14. Otras mejoras *

Si has implementado todas las propuestas es ms que suficiente. Pero igual que sucede concasitodoprogramainformtico,siemprehayalgoquesepuedemejorarenuncircuito
122
Oimgenesde16x16enelcasodequelosmantengasdeltamaodelacuadrcula
261
digital.Llegadosaestepuntocreemosque,silodeseas,puedesimplementarportimismo elrestodecaractersticasdeljuego. Puedesincluir: Las cuatro bolitas de comida mgicas que hacen que el pacman tenga poderes durante un tiempo y pueda comerse a los fantasmas. Incluir parpadeo, cambio de color e incluir boca en los fantasmas durante el tiempo en el que son vulnerables. E incluso, combinar el color normalconelcolorvulnerableparaavisardequequedapocotiempodesuvulnerabilidad Incluirelmovimientodelasfaldasdelosfantasmas Hacerquelosfantasmasvuelvanacasacuandosoncomidos Controlar la puerta de la casa de los fantasmas y evitar que el pacman pueda entrar. No incluircomidaenlacasadelosfantasmas Incluir los premios que aparecen en las pantallas: cerezas, fresas, naranjas,... y asignar puntoscuandoseloscomaelpacman Incluirvariaspantallasyniveles,condiferenteslaberintos Aadirvidascuandosesuperaciertapuntuacin Escenificarlamuertedelpacman Incluirpantallasinicialesyfinales Memoriaconlamximapuntuacinconseguida Hacerqueelpacmanvayamsdespaciocuandoestcomiendo Implementarelcontroldelmovimientodesdeeltecladoynodesdelospulsadores
Ytodoloqueveasquefaltaytegustaraincluir,estujuego
15.15. Conclusiones
En el diseo de este videojuego hemos visto que cada caracterstica poda implementarse de muchas maneras. Algunas son claramente ms eficientes, pero en otras nos podemos plantear si vale la pena el ahorro considerando los recursos que tenemos. Por ejemplo, si tenemos en cuenta los recursos de la FPGA y los pequeos tamaos de las memorias de los personajes (pacman, fantasmas,...) los ahorros son insignificantes. Sin embargo no siempre es as, y por ejemplo en otros diseos, las memorias son un factor limitante. Recuerda por ejemplo la tabla 12.3 en donde se mostraban las limitaciones para usar imgenesgrandes. As que estas cuestiones siempre tienen que estar presentes en la mente del diseador: mejorar las prestaciones y valorar si merece la pena el ahorro conseguido frente al esfuerzodeimplementardichasmejoras. Para terminar, como dijimos al comienzo de este captulo, queda mucho por aprender y dehechopensamosqueeldiseadornuncadejadeaprender,peroesperamosquelovisto en este libro te valga para que puedas continuar el aprendizaje por ti mismo. Esperamos tambinquetehayasdivertidomientrashasestadoaprendiendooquealmenosquehaya sidoentretenido.
262
Referencias
AdeptdeDigilent.ProgramagratuitoparaprogramarlasFPGAsporUSB: http://www.digilentinc.com/Products/Detail.cfm?Prod=ADEPT [2ash] P.Ashenden,DigitalDesign,AnEmbeddedSystemsApproachUsingVHDL,Ed. MorganKaufmann,2008 [3basys] Basys,tarjetaconFPGAfabricadaporDigilent. ManualdereferenciadelaversinE: http://www.digilentinc.com/Data/Products/BASYS/BASYS_E_RM.pdf Pginawebdelatarjeta: http://www.digilentinc.com/Products/Detail.cfm?NavPath=2,400,791&Prod=BASYS [4chu] P.Chu,FPGAPrototypingUsingVHDLExamples,Willey,2008 [5cc] CreativeCommons.http://creativecommons.org/ Licenciadeestemanual:http://creativecommons.org/licenses/byncnd/3.0/ [6ceng] ComputerEngineering:http://www.computerengineering.org/ps2protocol/ [7desch] JP.Deschamps,Sntesisdecircuitosdigitales,unenfoquealgortmico,Thompson 2002. [8digi] DigilentInc.http://www.digilentinc.com/ [9dte] DepartamentodeTecnologaElectrnica,UniversidadReyJuanCarlos. http://gtebim.es [10dcse] DiseodeCircuitosySistemasElectrnicos.http://gtebim.es/docencia/DCSE [11ed2] ElectrnicaDigitalII.http://gtebim.es/docencia/EDII [12educ] F.Machado,N.Malpica,J.Vaquero,B.Arredondo,S.Borremeo,Aprojectoriented integralcurriculumonElectronicsforTelecommunicationEngineers,EDUCON Conference,Madrid,abril2010 [13ieee] IEEE,InstituteofElectricalandElectronicsEngineers.http://www.ieee.org [14imag] ImageMagik:http://www.imagemagick.org [15irfan] IrfanView:http://www.irfanview.com [16ise] ISEWebPackdeXilinx.http://www.xilinx.com/tools/webpack.htm Paradescargarversionesantiguas: http://www.xilinx.com/webpack/classics/wpclassic/index.htm [17mach] F.Machado,S.Borromeo,DiseodecircuitosdigitalesconVHDL,2010.Libro ElectrnicodisponibleenelarchivoabiertodelaUniversidadReyJuanCarlos. http://hdl.handle.net/10115/4045 [18mach] F.Machado,S.Borromeo,N.Malpica,DiseodigitalavanzadoconVHDL,Ed. Dykinson,2009. [19mach] F.Machado,S.Borromeo,N.Malpica,DiseodigitalconesquemticosyFPGA,Ed. Dykinson,2009. [20model] Modelsim,http://www.model.com [21nexys] Nexys2,tarjetaconFPGAfabricadaporDigilent.Manualdereferencia: http://www.digilentinc.com/Data/Products/NEXYS2/Nexys2_rm.pdf Pginawebdelatarjeta: http://www.digilentinc.com/Products/Detail.cfm?Prod=NEXYS2 [22openc] Opencores.http://www.opencores.org [23qihw] Qihardware:http://en.qihardware.com/wiki/Teclado [24realt] RealTerm.http://realterm.sourceforge.net/ [25rtl] IEEEStandardforVHDLRegisterTransferLevel(RTL)Synthesis,IEEEStd1076.6 [26spart3] Spartan3EFPGAFamily:DataSheet.DS312,Xilinx
H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H H
[1adept]
263
[27urjc] [28web] [29xilinx] [30xst] [31xup]
UniversidadReyJuanCarlos,http://www.urjc.es PginawebconcdigoVHDLcomplementarioaestelibro: http://gtebim.es/~fmachado/electronica Xilinx,http://www.xilinx.com XSTUserGuide9.2i.Xilinx,http://ww.xilinx.com/itp/xilinx92/books/docs/xst/xst.pdf XilinxUniversityProgramVirtexIIProDevelopmentSystem.Hardwarereferencemanual. UG069v1.09marzo2005.http://www.xilinx.com/univ/xupv2p.html

H H H H H H H H H H
264

Diseno Sistemas Digitales VHDL

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Diseno Sistemas Digitales VHDL

Uploaded by

Copyright:

Available Formats

Diseo de sistemas digitales con VHDL

3. Funcionamiento bsico de las tarjetas electrnicas ............................................................... 33

3.2. Encender los leds ............................................................................................................................ 37

4. Utilizacin del reloj y circuitos secuenciales ........................................................................... 57

5. Simulacin con Modelsim........................................................................................................ 63 6. Constantes, genricos y paquetes.......................................................................................... 71

7. Transmisin en serie por RS-232............................................................................................ 77

7.5. Simulacin del transmisor ............................................................................................................... 93

7.6. Implementacin en la FPGA: diseo estructural ........................................................................... 113

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

7.7. Diseo del receptor de la UART.................................................................................................... 129

8. Circuitos aritmticos .............................................................................................................. 135

8.8. Multiplicacin ................................................................................................................................ 147

8.9. Diseo considerando las prestaciones.......................................................................................... 156

8.10. Divisin ....................................................................................................................................... 171

9. Controlador de pantalla VGA ................................................................................................ 175

10. Videojuego de tenis ............................................................................................................. 187

11. Puerto PS/2 ......................................................................................................................... 193

11.2. Ratn PS/2.................................................................................................................................. 196

12. Memorias............................................................................................................................. 203

Universidad Rey Juan Carlos

13. Mostrar caracteres por pantalla........................................................................................... 227

14. Procesamiento digital de imgenes .................................................................................... 235

15. Videojuego Pac-Man ........................................................................................................... 247

Referencias ............................................................................................................................... 263

Departamento de Tecnologa Electrnica

Departamento de Tecnologa Electrnica

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

Universidad Rey Juan Carlos

Departamento de Tecnologa Electrnica

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

Universidad Rey Juan Carlos

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

Universidad Rey Juan Carlos

ndice de cdigo VHDL

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

Universidad Rey Juan Carlos

Departamento de Tecnologa Electrnica

Departamento de Tecnologa Electrnica

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

Universidad Rey Juan Carlos

Departamento de Tecnologa Electrnica

2. Repaso de VHDL para sntesis

Figura 2.1: Lista de palabras reservadas del VHDL

A continuacin veremos una serie de ejemplos de diseos VHDL de dificultad incremental.

Departamento de Tecnologa Electrnica

Diseo de sistemas digitales con VHDL - v1.00 - 28/10/2011

2.1. Puerta AND

PUERTA_AND PUE RTA_AND

Figura 2.2: Representacin de la entidad VHDL

Cdigo 2.1: Entidad en VHDL

'U':Noharecibidovalor '1':Unolgico(unofuerte) 'L':Cerodbil

Tabla 2.1: Valores del std_logic

Universidad Rey Juan Carlos

2. Repaso de VHDL para sntesis

architecture BEHAVIORAL of PUERTA_AND is begin C <= A and B; end BEHAVIORAL;

Cdigo 2.2: Arquitectura en VHDL