Disseny VHDL de la unitat de control d'un acceleròmetre

PROJECTE FINAL DE CARRERA Disseny VHDL de la Unitat de Control d’un Acceleròmetre (VHDL Design of an Accelerometer’s Control Unit) Estudis: Enginyeria de Telecomunicació Autor: Albert Casulleras Romero Directors: Jordi Madrenas Boadas Piotr Jozef Michalik Any: 2013 Disseny VHDL de la unitat de control d’un acceleròmetre 1 Índex Resum ........................................................................................................................ 3 Resumen .................................................................................................................... 5 Abstract..................................................................................................................... 7 1. Introducció........................................................................................................................ 9 1.1. Objectius................................................................................................................... 10 2. Acceleració i acceleròmetres.......................................................................................... 13 2.1. Tipus d’acceleròmetres............................................................................................. 15 2.1.1. Basats en tecnologia piezoelèctrica.................................................................. 15 2.1.2. Basats en tecnologia piezoresistiva .................................................................. 16 2.1.3. Basats en tecnologia capacitiva........................................................................ 16 2.2. L’acceleròmetre dissenyat........................................................................................ 17 2.2.1. El sensor capacitiu............................................................................................ 18 2.2.2. Els oscil·ladors.................................................................................................. 20 2.2.3. Descodificació de la freqüència........................................................................ 22 3. La unitat de control i descodificació i el comptador.................................................... 27 3.1. El comptador ............................................................................................................ 29 3.1.1. El comptador d’onze bits en format Gray ........................................................ 31 3.1.2. El convertidor Gray - binari ............................................................................. 35 3.1.3. Sincronitzador................................................................................................... 37 3.1.3.1. Sincronisme per senyal d’oscil·lador........................................................ 38 3.1.3.2. Sincronisme per senyal de rellotge........................................................... 40 3.2. El descodificador...................................................................................................... 41 3.2.1. Primera versió de l’algorisme........................................................................... 43 3.2.2. Representació parcial del període del senyal en el vector d’entrada................ 46 3.2.3. Presència de múltiples transicions en el vector d’entrada................................ 48 3.2.4. Problemàtica d’usar una correlació circular..................................................... 52 3.2.5. Versió final de l’algorisme............................................................................... 55 3.3. El computador .......................................................................................................... 58 3.4. El multiplexador de sortida ...................................................................................... 60 3.5. El bloc de configuració............................................................................................. 62 3.5.1. Primer subbloc: selector de senyals provinents dels oscil·ladors..................... 64 3.5.2. Segon subbloc: activació de les sondes............................................................ 65 3.5.3. Tercer subbloc: activació dels oscil·ladors....................................................... 66 4. Resultats .......................................................................................................................... 69 Conclusions ............................................................................................................. 75 Apèndix A. Codi Unitat de Control i Descodificació més Comptador .............. 77 Apèndix B. Bancs de Proves................................................................................ 109 B.1 Banc de Proves del Descodificador........................................................................ 109 B.2 Banc de Proves de la Unitat de Control i Descodificació....................................... 117 Apèndix C. Paràmetres de disseny de la Unitat mitjançant Cadence ............. 127 C.1 RTL Compiler ........................................................................................................ 127 C.2 Encounter................................................................................................................ 131 Apèndix D. Esquemàtic de la Unitat................................................................... 137 Referències ............................................................................................................ 139 Disseny VHDL de la unitat de control d’un acceleròmetre 2 Disseny VHDL de la unitat de control d’un acceleròmetre 3 Resum Un acceleròmetre és un instrument usat per calcular l’acceleració de l’objecte al que va unit, i ho fa a través del seu moviment inercial respecte a unes coordenades conegudes. Existeixen diferents tipus de tecnologies i dissenys que, tot i que tenen el mateix objectiu de mesurar l’acceleració, poden ser molt distints uns dels altres segons l’aplicació a la qual van destinats i les seves condicions de treball. Els acceleròmetres han passat d’estar orientats a l’ús industrial i d’investigació per mesurar vibracions i oscil·lacions (entre altres), a estar cada cop més presents en els aparells electrònics que ens envolten: GPS, telèfons mòbils, consoles de videojocs, ordinadors portàtils... El present treball descriu el Projecte Final de Carrera en el qual s’ha estat treballant al llarg del passat any: el disseny d’una unitat de control i descodificació més comptador associat d’un acceleròmetre MEMS (MicroElectroMechanical System) inclòs en un circuit integrat CMOS (Complementary Metal-Oxide-Semiconductor). Al llarg d’aquest document es detalla perquè això és important i com s’ha realitzat. Disseny VHDL de la unitat de control d’un acceleròmetre 4 Disseny VHDL de la unitat de control d’un acceleròmetre 5 Resumen Un acelerómetro es un instrumento usado para calcular la aceleración del objeto al que va unido, y lo hace a través de su movimiento inercial respecto a unas coordenadas conocidas. Existen diversos tipos de tecnologías y diseños que, todo y que tienen el mismo objetivo de medir la aceleración, pueden ser muy distintos los unos de los otros según la aplicación a la cual van destinados y sus condiciones de trabajo. Los acelerómetros han pasado de estar orientados al uso industrial y de investigación para medir vibraciones y oscilaciones (entre otros), a estar cada vez más presentes en los aparatos electrónicos que nos envuelven: GPS, teléfonos móviles, consolas de videojuegos, ordenadores portátiles... El trabajo presente describe el Proyecto Final de Carrera en el cual se ha estado trabajando a lo largo del pasado año: el diseño de una unidad de control y descodificación más contador asociado de un acelerómetro MEMS (MicroElectroMechanical System) incluido en un circuito integrado CMOS (Complementary Metal-Oxide-Semiconductor). A lo largo de este documento se detalla porqué esto es importante y como se ha realizado. Disseny VHDL de la unitat de control d’un acceleròmetre 6 Disseny VHDL de la unitat de control d’un acceleròmetre 7 Abstract An accelerometer is an instrument that calculates acceleration forces, using his inertial movement towards some known coordinates. There are quite a few technologies and designs and all of them have as a prime objective measuring acceleration, but they can be pretty different depending on their applications and work conditions. Accelerometers were initially oriented at industrial and research uses measuring vibrations and oscillations (among other things), but you can now found them in all sorts of electronic devices: GPS, mobile telephones, videogame consoles, portable computers, etc. This document describes the Career’s Final Project in which I have been working this last year: the design of a control and decoding unit plus an associated counter of a MEMS (MicroElectroMechanical System) accelerometer included in a CMOS (Complementary Metal-Oxide-Semiconductor) integrated circuit. In this document it will be explained why this is important and how we made it. Disseny VHDL de la unitat de control d’un acceleròmetre 14 m k o  (2.3) Un últim concepte a tenir en compte és el factor de qualitat, que és el paràmetre que descriu el comportament dinàmic del nostre sistema en resposta a un impuls. El definim com: b mk b m Qo     (2.4)  si 5.0Q: el sistema es sobreamortit o críticament amortit (si 5.0Q), la resposta es una funció exponencial decreixent en el temps. (Fig. 2.2)  si 5.0Q: el sistema es oscil·la amb amortiment dèbil, sent la seva funció una sinusoide de freqüència 2 4 1 1Q o  i d’amplitud exponencialment decreixent. (Fig. 2.3) Figura 2.2: En blau un sistema críticament amortit . 5.0Q En vermell exemple de sistema sobreamortit amb . 5.0Q Figura 2.3: Resposta d’un sistema amb amortiment dèbil a un impuls (Q > 0.5). Típicament, el sensor de l’acceleròmetre hauria de ser dissenyat amb , cosa que proporciona un temps mínim per establir la sortida en resposta d’algun canvi en l’entrada. Allunyar-se d’aquest valor significarà que la resposta serà més lenta o tindrà un sobreimpuls. 5.0Q Disseny VHDL de la unitat de control d’un acceleròmetre 15 A partir de les expressions (2.3) i (2.4) podem reescriure de nou l’equació diferencial de l’acceleració obtenint: )()()()( 2txtx Q txta o o    (2.5) on:  Q: factor de qualitat del sistema.  o  : freqüència de ressonància del sistema. Si traslladem aquesta darrera expressió al domini transformat utilitzant l’eina matemàtica de Laplace obtenim que: )()()()( 22 sXsXs Q sXssA o o   (2.6) Ens trobem en posició de poder calcular la funció de transferència del sistema H(s). Aquesta funció de transferència es en realitat l’expressió del càlcul de la sensibilitat del nostre sensor en el domini transformat, és a dir, la resposta en unitats de desplaçament respecte a l’entrada d’acceleració. 22 1 )( )( )( o os Q s sA sX sH     (2.7) 2.1. Tipus d’acceleròmetres Entre les tecnologies més habituals per implementar sensors d’acceleració hi han els acceleròmetres piezoelèctrics, els piezoresistius i els capacitius. 2.1.1. Basats en tecnologia piezoelèctrica La piezoelectricitat és la càrrega elèctrica que s’acumula en certs materials sòlids en resposta a aplicar una certa força mecànica. Un acceleròmetre piezoelèctric [6, 7] fa ús d’aquest efecte per mesurar la distància relativa entre una massa i el propi sensor per després representar l’acceleració en termes de voltatge (Fig. 2.4). Ocasionalment s’usen cristalls de quars, tot i que els més utilitzats estan formats per materials ceràmics piezoelèctrics tals com el titanat de bari o el titanat zirconat de plom (PZT). Disseny VHDL de la unitat de control d’un acceleròmetre 16 Figura 2.4: Secció d’un sensor piezoelèctric [6]. Aquests sensors són usats degut a la seva mida compacta i baix pes, entre altres motius. A destacar per això que presenten problemes al mesurar acceleracions estacionaries o que variïn lentament en el temps. 2.1.2. Basats en tecnologia piezoresistiva Els primers sensors MEMS amb gran popularitat es basaven en un sensor de pressió basat en l’efecte piezoresistiu. La piezoresistivitat [8] pot ser definida com el canvi de resistència d’un material quan és sotmès a estrès. Aquest efecte es conegut des del segle XIX en els metalls, però no va ser fins a meitats dels anys 1950 que es van reconèixer els semiconductors i particularment el silici tenien un major coeficient piezoresistiu comparats amb els metalls. En un acceleròmetre el material piezoresistiu és col·locat en un punt de màxima variació de l’estrès, de manera que és deformat segons l’acceleració que es sofreix, fet que modifica el valor de la seva resistència. Mesurant aquesta resistència a través d’un divisor de tensió o, millor encara, mitjançant un pont de Wheatstone per a millor sensitivitat, podem conèixer l’acceleració que sofreix el sensor. Aquest tipus d’acceleròmetres destaquen per la seva mida compacta, així com per la seva bona linealitat i gran amplitud de senyal. Tenen en contra, que són molt sensibles a canvis de temperatura i que dissipen una potència considerable. 2.1.3. Basats en tecnologia capacitiva Aquest tipus de dispositius [9] tenen com a peça clau dos o més conductors entre els quals hi ha un material dielèctric. Algun d’aquests conductors es mòbil segons l’acceleració a la que es sotmès l’acceleròmetre, cosa que provoca una capacitat variable que depèn precisament dels canvis de velocitat que s’experimenten (Fig. 2.5). Disseny VHDL de la unitat de control d’un acceleròmetre 17 Figura 2.5: Acceleròmetre basat en tecnologia capacitiva, estant en color més fosc les zones fixades a la resta del circuit i sent k la constant recuperadora de la molla de la placa mòbil. Les plaques fixes i mòbil formen capacitats variables en funció de l’acceleració que experimenta el dispositiu. En repòs, la distància entre la placa central i les plaques contigües es equidistant. En el moment en que el cos experimenti una acceleració en l’eix en que està orientat el sensor, una d’aquestes distàncies augmentarà mentre que l’altra disminuirà. Mesurant les capacitats que es formen podrem saber la distància que s’han mogut les plaques, cosa que ens ajudarà a determinar l’acceleració soferta.    d d CC oa (2.8)    d d CC ob (2.9) on:  d: distància entre les plaques en repòs.  o C: capacitat entre les plaques en repòs.   : desplaçament sofert per la placa central. Aquests acceleròmetres tenen bona sensibilitat, una sortida lineal, una bona resposta a acceleracions estacionàries, baixa dissipació de potència i poca sensibilitat a variacions de temperatura. A destacar com a inconvenient que poden ser afectats per interferències electromagnètiques. 2.2. L’acceleròmetre dissenyat Disseny VHDL de la unitat de control d’un acceleròmetre 18 El principi de funcionament de l’arquitectura que s’exposa a continuació [4] (Fig. 2.6) consisteix en la conversió de l’acceleració a freqüència a través d’un oscil·lador. A continuació la freqüència es desmodulada cap a un resultat digital mitjançant un conversor d’alta precisió, que utilitza un comptador com a primera aproximació de la mesura i una línia de retard regulada dinàmicament a través d’un llaç tancat amb una bomba de càrrega per afinar el resultat. Figura 2.6: Arquitectura usada en l’acceleròmetre proposat. El disseny del darrer bloc conversor freqüència a digital, la Unitat de Control i Descodificació juntament amb el Comptador associat són el principal objectiu d’aquest Projecte Final de Carrera. La descripció de cadascun dels elements usats es detalla en els següents punts. 2.2.1. El sensor capacitiu Un dels mètodes de la tesi doctoral en que col·labora aquest Projecte Final de Carrera és el d’usar capes metàl·liques de procés CMOS com a material estructural per a MEMS, alliberantles mitjançant atac àcid del diòxid de silici. Alguns elements senzills com voladisses i plaques suspeses (Fig. 2.7) ja han estat extretes amb èxit de xips CMOS en el Departament d’Enginyeria Electrònica de la UPC [6], alhora que altres grups de recerca han tingut prometedors resultats amb mètodes similars [10, 11, 12]. Aquest mètode no requereix afegir cap nova màscara en el procés, o complicats i/o disruptius passos de fabricació addicionals, pel que pot arribar a tenir un cost molt efectiu en comparació a solucions existents. En concret, es vol aconseguir a través d’aquest procés una estructura similar que actuï com a sensor capacitiu. Disseny VHDL de la unitat de control d’un acceleròmetre 19 Figura 2.7: Imatge d’un actuador electrostàtic construït mitjançant l’aïllament d’una capa d’alumini d’un xip en tecnologia CMOS de 350 nm en el laboratori mitjançant un atac àcid de l’òxid de silici intersticial. L’armadura superior es mòbil i té una mida de 100 μm x 100 μm [4]. Per al cas d’estructures mòbils en z, el seu comportament pot ser molt ben aproximat per la següent equació diferencial de segon ordre: )()()(),( tzktzbtzmzVFam celext         (2.10) Aquesta equació ja s’ha introduït en el primer capítol d’aquest document en l’equació (2.2), tot i que en aquest cas també es considera la força electrostàtica que s’origina entre les armadures del sensor capacitiu i que depèn del voltatge que s’hi aplica i del desplaçament c V z produït. En el cas de treballar amb freqüències per sota de la de ressonància, trobem que l’acceleració és aproximadament proporcional al desplaçament i amb un segon terme dependent de la força electrostàtica: si o    ( m k o  ) llavors tenim que: m F z m k ael ext  (2.11) El sensor a construir està format per dues plaques paral·leles, pel que la seva capacitat i força electrostàtica poden ser calculats com: zz A zC o    )( (2.12) 2 2 )(2 1 zz V AF o c el    (2.13) Disseny VHDL de la unitat de control d’un acceleròmetre 20 on és la superfície de la placa, A  es la permitivitat del medi que hi hagi entremig (aire per defecte) i la seva distància en repòs. El signe negatiu de la força electrostàtica és degut a que està orientat cap al sentit negatiu de l’eix Z. Es pot veure que en aquest cas l’aportació electrostàtica a la contant recuperadora és: o z 0   z F kel el (2.14) pel que en algunes circumstàncies pot excedir l’aportació elàstica a la constant recuperadora, portant al sensor a inestabilitat i a pull-in. Es pot demostrar que un voltatge que causa un desplaçament 3 o z z és un voltatge pull-in en un sensor, i pot ser evitat per exemple usant un activador controlat per càrrega [13]. Aquesta força electrostàtica canvia la constant recuperadora del dispositiu i, depenent del sensor, pot provocar que sigui no lineal en funció de la distància entre elèctrodes. Aquest és un efecte indesitjat i que ha de ser minimitzat per a preservar la linealitat. A través de (2.4) es veu que la força electrostàtica depèn del quadrat del voltatge, pel que un sistema senzill per evitar-ho és garantir que no hi ha cap component contínua al voltatge aplicat al dispositiu. Això es pot fer elevant el voltatge de l’elèctrode inferior per sobre de la massa i col·locant el llindar de voltatges de l’oscil·lador de forma que la component contínua en l’elèctrode superior és equivalent a l’aplicat en l’inferior. D’aquesta forma, la única font de força electrostàtica està lligada a la component alterna del voltatge i, ja que la freqüència de l’oscil·lador és molt més elevada que l’ample de banda de l’acceleròmetre, la força que atrau la placa mòbil es només proporcional al quadrat del voltatge mig i pot ser calculat posant 2 V en (2.4). En resum, si es vol reduir aquest desplaçament l’amplitud del voltatge en l’oscil·lador també s’ha de reduir, però ja que això incrementa el seu error s’ha d’optar per un terme mig. El sensor capacitiu descrit fins ara es correspon amb un disseny simple que actua en l’eix de coordenades z i que està format per un sol condensador variable, però també s’han inclòs en el xip altres sensors capacitius més complexos capaços de detectar acceleracions en múltiples eixos i formats per vàries capacitats que actuen alhora, com per exemple el que es pot veure en l’anterior figura 2.5. El seu funcionament és simplement una extensió de la teoria explicada en aquest capítol. 2.2.2. Els oscil·ladors Un cop s’ha fet la transformació de l’acceleració que sofreix el dispositiu a capacitat en els sensors descrits en l’apartat anterior, ara ens trobem amb la necessitat de mesurar aquesta segona variable: la capacitat. Per tal de fer-ho es fa ús de dos tipus d’oscil·ladors, la freqüència de sortida dels quals depèn precisament d’aquesta capacitat i que es mesura posteriorment en el següent bloc. Disseny VHDL de la unitat de control d’un acceleròmetre 21 El primer oscil·lador escollit per a aquest projecte és aplicable a sensors capacitius formats per dues plaques (una sola capacitat), com per exemple el mostrat en la figura 2.7. Està basat en dos comparadors que detecten el valor de la capacitat que forma el sensor, que es constantment carregat i descarregat, decidint així quina de les dues entrades d’un latch RS activar (Fig. 2.8). A la sortida tenim un senyal quadrat la freqüència del qual depèn directament d’aquesta capacitat i, alhora, indirectament de l’acceleració que pateix el dispositiu. Figura 2.8: Esquema de l’oscil·lador per a sensors capacitius de dues plaques, així com la relació entre el voltatge en el sensor i la sortida [4]. Amb l’oscil·lador estem convertint la capacitat del sensor en freqüència, que és modelada per la següent equació: )( 2zz V A I VC I fo cc           (2.15) on és el corrent de càrrega i descàrrega del sensor capacitiu, c IV  la diferència de voltatge entre llindars en l’oscil·lador i C la capacitat a mesurar. El segon oscil·lador implementat (Fig. 2.9) és per a sensors capacitius més complexos de tres plaques que formen dos condensadors, amb un funcionament molt semblant al mostrat en l’anterior figura 2.5. El seu principi de funcionament és una combinació del trobat en [14] i d’un oscil·lador de dent de serra [15]. Aquí la freqüència és calculada com: ) 2 ()1( 20 0 2 1 dx d VC I C C VC I f dd c dd c       (2.16) on és el corrent de càrrega, C la capacitat de dent de serra de l’oscil·lador, / les capacitats dels dos sensors a mesurar i la posició d’acceleració nul·la. A la pràctica tenim que , pel que podem aproximar l’anterior equació a: c I x 1 C2 C 0 d 0 d Disseny VHDL de la unitat de control d’un acceleròmetre 22 )1( 0 d x VC I f dd c   (2.17) Figura 2.9: Esquemàtic de l’oscil·lador per a sensors capacitius de tres plaques incloent-hi el circuit del comparador, juntament amb una simulació mostrant el seu funcionament [15]. En ambdós oscil·ladors tenim a la sortida un senyal quadrat de freqüència variable, en funció de l’acceleració que sofreix el dispositiu. 2.2.3. Descodificació de la freqüència La primera aproximació per poder descodificar la freqüència del senyal generat per l’oscil·lador es establint un comptador que compti el nombre de períodes d’un senyal de període conegut. Malauradament, aquest mètode es molt imprecís i requeriria d’un senyal de rellotge amb una freqüència d’un ordre molt superior al del senyal creat per poder disposar d’una resolució raonable. Per tant, es necessita d’un sistema més complex. La solució adoptada consisteix en separar aquest procés en dos càlculs que es realitzen en paral·lel un de l’altre (Fig. 2.10):  Un comptador porta el compte de quants períodes de rellotge del senyal provinent de l’oscil·lador estan continguts dins d’un segon senyal que s’usa com a referència i es definit per l’usuari.  Una línea de retard controlada de manera que es capaç d’establir amb precisió l’interval de temps que no pot ser precisat amb el comptador. Disseny VHDL de la unitat de control d’un acceleròmetre 23 Figura 2.10: Esquema simplificat de l’etapa de conversió de temps a digital [4]. En vermell, la meva aportació al projecte. Per realitzar aquest segon component de desmodulació es fa passar el senyal a mesurar per una línia de retard i, en el moment en que es requereix de mesurar de nou la freqüència, s’emmagatzemen tots els seus valors intermedis per tal de processar-los posteriorment (Fig. 2.11). Aquest muntatge equival a mostrejar el senyal amb el detall necessari per tal de millorar l’aproximació feta amb el comptador. Disseny VHDL de la unitat de control d’un acceleròmetre 30 Figura 3.2: Comptatge del nombre de períodes complerts d’oscillator que es produeixen en un període de sampling. Com es pot apreciar, hi ha fragments del senyal oscillator que no formen part dels càlculs, pel que la freqüència que s’obté a partir d’aquest mòdul té un cert error. Les primeres versions del comptador feien ús d’una codificació binària, degut sobretot a la seva simplicitat en el disseny. Tot i així, un comptador d’aquest estil no és el més òptim, ja que la codificació entre dos valors consecutius pot arribar a diferir en múltiples bits, fet que pot arribar a esdevenir un problema ja que eleva la probabilitat d’error en alguna transició entre valors, i es per això que el comptador actual usa una codificació Gray. El seu algorisme es força més complex de modelar, però ens assegura que la diferència entre dos valors consecutius sempre es mínima, d’un sol bit, pel que ens afegeix estabilitat addicional en el bloc. Un altre factor a tenir en compte del disseny del comptador es que la relació entre els dos senyals que marquen el seu funcionament es propera al miler, ja que cal comptar quants períodes de l’oscil·lador de freqüència ~100MHz hi han continguts en un període de sampling que s’espera que sigui proper a ~100kHz. És per això que el comptador funciona amb un codi d’onze bits, el qual ens proporciona un total de valors diferents, més que suficients pel seu bon funcionament. 2048211  A la figura 3.3 es mostra la interfície del bloc comptador. La versió final del bloc comptador (Fig. 3.4) es composa de tres mòduls: un comptador d’onze bits en format Gray, un convertidor cap al format binari i un sincronitzador. Disseny VHDL de la unitat de control d’un acceleròmetre 31 Figura 3.3: Interfície del comptador. Figura 3.4: Detall de les connexions entre els diversos mòduls que composen el comptador. A continuació es detallen aquests mòduls. 3.1.1. El comptador d’onze bits en format Gray El principal avantatge de fer servir un codi Gray en un comptador es que varia un sol bit entre dos valors consecutius qualsevol. Tot i així, es prou difícil el descriure quin es el bit que varia en cada moment, ja que l’algorisme no es gens evident (Taula 3.1). codi Gray posició codi Gray posició 0000 0 1100 8 0001 1 1101 9 Disseny VHDL de la unitat de control d’un acceleròmetre 32 0011 2 1111 10 0010 3 1110 11 0110 4 1010 12 0111 5 1011 13 0101 6 1001 14 0100 7 1000 15 Taula 3.1: Codificació Gray per al cas d’un comptador de 4 bits. La solució aplicada ha estat la d’implementar cada bit en un component per separat, el qual depèn dels valors de la resta per tal de determinar si ha de variar o no el seu valor (Fig. 3.5) [16]: Figura 3.5: Interfície corresponent al component encarregat d’un bit del comptador. on es el valor del bit anterior i el valor del bit actual i que és alhora l’entrada del bit posterior. Els valors de i venen determinats pels valors de cada component i serveixen per calcular els valors posteriors. El significat de és el de indicar si tots els bits menys significatius són zero o no. La tasca de cada component (Fig. 3.6) es la de realitzar les següents operacions: in qout q out z in z out z )1(1 ininoutout ziqiqiq          (3.4) ininout qzz   (3.5) Disseny VHDL de la unitat de control d’un acceleròmetre 33 Figura 3.6: Cada bloc genera un bit del codi Gray a través de , i un flip-flop de tipus T. A més a més, es genera de forma asíncrona a partir de les entrades i . out q out in qin z zin zin q A continuació, en la figura 3.7 es representa com es connecten tots aquests blocs per al comptador d’onze bits que s’incorpora en la unitat de control i descodificació. Disseny VHDL de la unitat de control d’un acceleròmetre 34 Figura 3.7: Esquemàtic del comptador en format Gray d’onze bits. A tenir en compte amb aquest sistema:  El valor de q<0> i de z<0> és definit en tot moment per part del sistema per tal de provocar que aquest funcioni segons es descriu en els següents punts. El valor de q<0> varia en cada cicle de rellotge en que el comptador avança, mentre que z<0> sempre val 1.  El valor de cada z depèn exclusivament del valor de q i z immediatament anteriors. Degut a que z<0> es sempre igual a 1, llavors tindrem que tot el vector z val 1 fins que un dels valors de q valgui també 1, el qual força els restants valors del vector z a 0. El vector z es bàsicament un marcador que indica a on es troba situat el primer 1 en el vector q. Disseny VHDL de la unitat de control d’un acceleròmetre 35  És necessari fer una petita modificació en l’entrada in q del darrer component M (3.6), ja que altrament el sistema es saturaria en el seu valor final 100 0000 0000 i no passaria mai al valor inicial 000 0000 0000.        MqMqqx 1 (3.6) No hauria d’afectar al nostre sistema de forma dramàtica el implementar aquesta mesura, ja que mai s’hauria d’arribar a l’extrem en que el comptador hagi esgotat tots els seus valors, però s’ha optat per afegir-ho igualment per mantenir la coherència de l’algorisme i poder detectar l’error en el cas d’aparèixer.  És important destacar que, a fi que l’algorisme funcioni correctament, el càlcul del vector z i de qx ha de ser realitzat combinacionalment, que no requereixi esperar al rellotge per calcular un nou valor. Per contra, el vector q es totalment síncron.  En el cas de tenir activat el senyal de reset, llavors tots els valors passen a ser nuls a excepció de q<0> i de z<0> que es mantenen iguals a 1. Aquest reset s’activa tant pel senyal hard_reset (que marca un reinici global de tota la unitat de control) com pel senyal soft_reset (que marca que es vol un nou càlcul de la freqüència). A continuació es mostra la Taula 3.2 a on s’especifiquen els valors de totes les variables per un comptador Gray de 4 bits. posició 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 z<4> 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 z<3> 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 z<2> 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 z<1> 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 z<0> 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Càlculs combinacionals qx 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 q<4> 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 q<3> 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 q<2> 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 q<1> 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 sortida Càlculs síncrons q<0> 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 Taula 3.2: Detall de tots els valors que pren un comptador Gray de 4 bits amb aquest disseny. 3.1.2. El convertidor Gray - binari Tant per poder usar el valor anterior del comptador en futurs càlculs, com per poder disposar d’un resultat senzill de processar a la sortida de la unitat de control, primer s’ha de convertir a Disseny VHDL de la unitat de control d’un acceleròmetre 36 un format binari. Aquesta es precisament la funció del convertidor Gray - binari que entrem a detallar (Fig. 3.8). Figura 3.8: Interfície del convertidor Gray - binari Al contrari que amb el comptador Gray presentat en el punt anterior, en aquest bloc els senyals hard_reset i soft_reset impliquen comportaments diferents. Mentre que hard_reset reinicia el bloc a un estat inicial i conegut, el senyal soft_reset marca que es requereix d’una nova conversió del valor d’entrada gray<10:0> a la sortida binary<10:0> (Fig. 3.9). El senyal counter_ready indica quan totes les operacions han finalitzat. Figura 3.9: Diagrama d’estats del convertidor Gray - binari La conversió des de codificació Gray cap a binari es realitza per separat en dos passos. Això es degut a que l’algorisme usat requereix de fer la conversió bit a bit, amb el problema afegit de que cal haver realitzat el càlcul del bit immediatament superior per tal de conèixer l’actual:  1xbinarixorxgrayxbinari , per tot 01  xM        11 MgrayMbinari (3.7) on M es el nombre de bits del comptador del comptador. Disseny VHDL de la unitat de control d’un acceleròmetre 37 A continuació s’ha proveït d’un exemple d’aquesta conversió d’una manera més gràfica (Fig. 3.10): Figura 3.10: Conversió del valor ‘0110’ en codificació Gray cap a binari Pel nostre cas, aquest algorisme implica que la transformació de tot el vector d’onze bits de l’entrada són en realitat onze operacions xor que s’han de realitzar en sèrie, una darrera l’altre. Teòricament es possible el realitzar tots aquests càlculs en un sol període de rellotge, però a la pràctica resulta ser una font constant de problemes en les simulacions, pel que finalment s’ha decidit el implantar-ho en dos cicles de rellotge. En cas de no fer-ho així, estaríem comprometent tota l’estabilitat que s’ha guanyat al fer un comptador amb codificació Gray. 3.1.3. Sincronitzador Tal i com s’ha explicat al principi d’aquest capítol 3, la unitat de control i descodificació té cinc entrades primàries que afecten a la gran majoria de blocs que la conformen:  sampling: indica cada quan s’ha de realitzar una nova estimació de la freqüència del senyal oscillator.  oscillator: senyal provinent de l’oscil·lador, de freqüència variable.  clk: senyal de rellotge generat internament en el xip.  enable: activa/desactiva el funcionament dels blocs de la unitat.  reset: entrada que força la unitat a un estat inicial i conegut. Té prioritat respecte al senyal enable. D’aquestes cinc entrades, les tres primeres (sampling, oscillator i clk) són especialment crítiques ja que marquen la pauta de funcionament de la unitat: indiquen quan s’han d’iniciar les operacions alhora que quan han d’haver finalitzat. És per això que és necessari que aquestes entrades siguin monitoritzades en tot moment per cada un dels blocs que són afectats. A la pràctica, la inclusió de diversos senyals asíncrons pot ser una font de problemes [17]. S’ha d’establir un sincronisme entre els senyals per poder assegurar que tots i cada un dels esdeveniments i operacions que s’han de realitzar es produeixin en l’instant que pertoca. Aquesta és la funció del bloc que ens ocupa: el sincronitzador (Fig. 3.11). Disseny VHDL de la unitat de control d’un acceleròmetre 38 Figura 3.11: Interfície del sincronitzador. ó similar: assegurar que dos nyals funcionin sota el mateix rellotge. En concret, tenim que: la de reiniciar de nou tots els càlculs. És necessari un sincronisme entre sampling i clk. n és el senyal que usa el sincronisme per detectar l’altre i que exposen a continuació. 3.1.3.1. Sincronisme per senyal d’oscil·lador ptador i que reconegui d’una forma gura quan cal que reiniciï el seu comptatge. El sincronitzador es composa de varis subblocs amb una funci se  el comptador determina quants períodes del senyal oscillator hi ha en un interval de temps definit pel senyal sampling, pel que s’ha d’establir una certa interacció entre aquests dos senyals. A més a més, requereix d’un segon sincronisme entre oscillator i clk ja que cal reportar el resultat de les operacions d’aquest bloc amb la resta de unitat (el comptador és l’únic bloc que fa servir com a rellotge el senyal oscillator).  Tant el descodificador, com el computador i el multiplexador de sortida funcionen amb les pautes que marca el senyal clk, però és necessari que reconeguin també les variacions del senyal sampling per a saber quan s’ha En resum, calen tres sincronismes: sampling amb oscillator, sampling amb clk i la sortida del comptador (que és originalment generat amb oscillator) amb clk. Aquests s’han agrupat en dos subblocs segons qui s’ Aquest subbloc és l’encarregat de sincronitzar el senyal sampling amb oscillator (Fig. 3.12). El sincronisme és requerit pel funcionament del com se Disseny VHDL de la unitat de control d’un acceleròmetre 39 Figura 3.12: Interfície del subbloc de sincronisme per senyal d’oscil·lador. El disseny implementat és una detecció síncrona de flanc de pujada del senyal sampling usant oscillator (Fig. 3.13). Figura 3.13: Esquemàtic del subbloc de sincronisme per senyal d’oscil·lador. El senyal sampling passa a través de dos registres de tipus D, que emmagatzemen el seu valor periòdicament segons marqui oscillator, fins que finalment una porta nor verifica si s’ha produït una transició de nivell baix a alt (Fig. 3.14).  tQnortQtQnortQtoscsampling 1112 1_ (3.8) Disseny VHDL de la unitat de control d’un acceleròmetre 46 Tot i així, un cop posat en pràctica l’algorisme es fan evidents certes situacions a les que cal donar solució:  La freqüència del senyal provinent de l’oscil·lador es variable amb el temps. Tot i el control que regula dinàmicament el retard de les etapes de la línia, es d’esperar que es doni una certa deriva si la freqüència varia dràsticament. Aquest efecte ocasiona que en certs càlculs no hi tenim representat en el vector d’entrada un període exacte del senyal. En casos extrems, pot fins i tot ser possible que el vector no contingui la transició que cerquem, o bé que hi hagi múltiples transicions representades, pel que cal adaptar l’algorisme per a que també funcioni en aquestes condicions.  Tal i com s’ha descrit la correlació, aquesta es circular. És a dir, que en les correlacions de les primeres posicions hi intervenen els valors del final del vector i a la inversa. Això pot provocar certs resultats inesperats en les posicions extremes del vector ja que no estem tractant valors contigus. En els següents punts s’entra en detall en aquests punts i es descriuen els mecanismes que s’han incorporat a l’algorisme per poder-los tractar correctament. 3.2.2. Representació parcial del període del senyal en el vector d’entrada Al ser el senyal de l’oscil·lador de freqüència variable, s’ha dotat a la línia de retard d’un control realimentat que regula de forma dinàmica el retard de les seves etapes a fi d’adaptar-se a aquestes variacions i poder tenir representat en el conjunt de valors exactament un període del senyal. Tot i així, s’han de preveure situacions a on hi hagi una certa deriva en l’apreciació d’aquest control. En aquest punt es tracta el cas de que la informació que ens aporta la línia de retard inclogui menys d’un període del senyal. En algunes d’aquestes situacions, fins i tot pot ser que en la informació proporcionada no hi hagi ni tan sols la transició de nivell alt a baix que cerquem. En aquests casos i degut a que la correlació es circular, l’algorisme troba sempre un màxim en la posició 0 i així ho indica a la sortida, però no hi ha manera de verificar-ho amb la informació disponible (Fig. 3.22). Disseny VHDL de la unitat de control d’un acceleròmetre 47 Figura 3.22: Exemple de línia de retard representant un senyal amb un període major que la suma conjunta de tots els seus retards. L’algorisme detecta la transició buscada al principi del vector, però no es pot assegurar que aquest sigui el valor correcte al no disposar de prou informació del senyal. La solució que s’ha adoptat per evitar aquest cas és la d’afegir etapes addicionals a les estrictament necessàries en la línia de retard. El control que regula el valor d’aquestes etapes seguirà ajustant-les a 64 o 128 posicions, però també es troben disponibles aquests valors de més que s’inclouen a l’algorisme (Fig 3.23). D’aquesta manera, ara tenim que:  si vector_size = 1 -> La línia de retard té una longitud de 64 etapes més 8 d’addicionals, 72 en total.  si vector_size = 0 -> La línia de retard té una longitud de 128 etapes més 16 d’addicionals, 144 en total. En ambdós casos s’assegura un correcte funcionament de l’algorisme per a derives de fins al 12.5% del període. Disseny VHDL de la unitat de control d’un acceleròmetre 48 Figura 3.23: Mateix exemple de l’anterior Figura 3.17, però ara amb etapes addicionals en la línia de retard. Ampliant el nombre d’etapes augmentem les possibilitats de que hi hagi representada la referència que busquem. 3.2.3. Presència de múltiples transicions en el vector d’entrada De manera anàloga a la exposada en el punt anterior, degut al variar la freqüència de l’oscil·lador amb el temps també es pot donar la situació que en la línia de retard s’hi representi més d’un període del senyal. Aquest cas cobra ara una especial importància, ja que al haver afegit etapes addicionals es més que probable que ens trobem en aquesta situació. Al tenir més informació de la estrictament necessària en el vector pot desembocar en que hi apareguin múltiples punts de referència (Fig. 3.24). Disseny VHDL de la unitat de control d’un acceleròmetre 49 Figura 3.24: Exemple de vector d’entrada a on la seva correlació ens dóna com a resultat dos màxims en les posicions 10 i 62. Qualsevol vector de període menor que la longitud de la línia de retard pot potencialment desembocar en aquesta situació. Tal i com ha estat definit l’algorisme fins ara, només s’emmagatzema la posició amb el resultat de la correlació més elevat, pel que un canvi en aquest punt és necessari si treballem amb múltiples transicions, sobretot si tenim en compte que el sistema pot ser afectat per errors puntuals en el càlcul dels màxims, fent destacar un d’ells per sobre a l’altre. Cal determinar quin dels dos màxims trobats és el que cerquem i informar-ho a la sortida. Arribats a aquest punt, dues solucions són possibles:  Adaptar l’algorisme fent possible l’emmagatzematge de múltiples posicions, la correlació de les quals superi un determinat llindar. En el cas de que n’hi hagi més d’un, implementar un mètode de detecció per conèixer del cert quin d’ells és el correcte.  Mantenir el funcionament de l’algorisme tal i com ha estat descrit fins ara, però ara finalitzar en el mateix moment en que detecti un primer resultat que superi un Disseny VHDL de la unitat de control d’un acceleròmetre 50 determinat llindar. En aquest moment s’assumeix que es el resultat que cerquem, pel que es determinarà el màxim local de la zona i s’informarà a la sortida. Definitivament, la segona opció és la més atractiva, degut sobretot a que no es requereix d’emmagatzematge de múltiples posicions i a que permet estalviar-se multitud de correlacions si la situació és la descrita. Tot i així, el poder determinar un llindar que ens garanteixi no equivocar-nos al assumir el màxim no es trivial (més encara quan s’incorpori a l’algorisme els canvis descrits en el proper punt 3.2.3 per combatre els problemes ocasionats d’usar una correlació circular). Tot l’algorisme està orientat a ser robust, a poder combatre els errors ocasionals que poden aparèixer, pel que el triar una opció que assumeix fets pot no ser tampoc la correcta decisió. Així doncs, el que s’ha implementat finalment és una versió més conservadora d’aquesta segona opció proposada: 1. S’executa l’algorisme tal i com s’ha descrit en els punts anteriors fins a arribar al 75% del vector (posició 112 si 128 etapes, 56 si 64). Senyals amb un període inferior a aquestes 112 (56) posicions no són contemplats en aquest algorisme, i el seu resultat és impredictible. Es dóna doncs un 12.5% de marge en la desviació de l’apreciació del període. 2. Es comprova si el màxim que s’ha trobat està situat en alguna de les primeres 32 posicions del vector (16 si és de 64 etapes) i si el seu valor és igual o superior a 19. Si no es compleixen totes dues condicions es segueix amb el funcionament original de l’algorisme, realitzant totes les correlacions pendents fins a arribar al final del vector. 3. Si es compleixen les condicions del segon punt, es fa una darrera comprovació abans de donar per finalitzat l’algorisme. Aquesta és una correlació addicional entre el vector ideal de la transició que cerquem i un altre que format per les posicions compreses entre 0->9 i 102->111 (0->9 i 46->55 si 64 etapes) (Fig. 3.25). Si ens trobem en el cas de tenir múltiples màxims, llavors aquest segon vector ha de contenir en les posicions altes tot uns, mentre que en les baixes o bé la transició que busquem o bé tot zeros. La correlació entre els dos vectors ha de donar un resultat menor o igual que 10 per assegurar de forma definitiva que el màxim trobat és el que ens interessa (Fig. 3.26). Disseny VHDL de la unitat de control d’un acceleròmetre 51 Figura 3.25: Detall de quines posicions del vector d’entrada formen part del vector auxiliar descrit en l’algorisme. Aquest vector auxiliar es correla amb el que conté la transició ideal cercada per a acabar de verificar que ens trobem en un cas de presència de múltiples transicions a l’entrada. Figura 3.26: Tal i com ha estat definit l’algorisme, només el tercer exemple compleix les condicions necessàries per a la detecció de múltiples màxims. El primer vector no conté cap màxim en les seves primeres 16 posicions pel que es rebutjat en el segon punt. El segon senyal no genera un vector auxiliar diferent del vector ideal de transició, incomplint així el tercer punt. El darrer cas, tot i contenir una transició en el seu inici, aquesta no genera un màxim prou elevat i passa inadvertida per l’algorisme a causa d’usar una correlació circular (punt 3.2.4). Amb aquest afegit a l’algorisme, tan sols s’afegeixen uns pocs càlculs addicionals al arribar a tres quarts del vector, però que ens permeten per una banda solucionar possibles derives en Disseny VHDL de la unitat de control d’un acceleròmetre 52 l’apreciació de fins a 12,5% en el període del senyal, i per l’altre poder finalitzar l’algorisme amb celeritat si la situació és l’esperada. 3.2.4. Problemàtica d’usar una correlació circular Tal i com s’ha comentat amb anterioritat, el mètode empleat per cercar la referència desitjada és mitjançant una sèrie de correlacions del vector d’entrada provinent de la línia de retard amb un patró amb la transició ideal, fent rotar el vector entre operació i operació per tal de minimitzar el hardware empleat. Això implica usar una correlació circular, a on en el resultat de les primeres posicions hi intervenen els darrers valors del vector i a la inversa (Fig. 3.27). Figura 3.27: Detall de les posicions que intervenen en el conjunt de correlacions a realitzar per a cada vector d’entrada 128 + 16 retards de longitud. Disseny VHDL de la unitat de control d’un acceleròmetre 53 Quan la referència que busquem es troba en una posició intermèdia del vector, la correlació resultant és màxima en aquest punt i l’algorisme ho detecta correctament. Altrament, si la referència es troba en les posicions inicials o finals del vector, aquesta pot quedar amagada ja que es depèn en aquests casos de valors no contigus (Fig. 3.28). La solució per evitar aquesta problemàtica es la d’afegir valors addicionals tant al inici com al final del vector d’entrada, de manera que ressaltin el possible màxim que hi pugui haver, alhora que no es creen màxims ficticis. Figura 3.28: Exemple de vector d’entrada amb una transició tant en les primeres posicions com en les darreres. En ambdues posicions, la seva correlació es veu afectada per la de l’altre transició, obtenint així una ‘erosió’ dels pics que complica molt la seva detecció. En l’anterior punt 3.2.2 es detalla com s’amplia la línia de retard per poder evitar situacions a on no tenim representat cap màxim en el vector d’entrada, pel que ara hi ha present en ell una mica més d’un període del senyal en la gran majoria de casos. El punt de partida és doncs el d’un senyal amb una desviació de màxima del període de fins al 12,5%, que equivalen a 16 posicions si usem una línia amb longitud de 128 etapes (8 si longitud de 64). El mecanisme implementat afegeix al principi del vector els valors de les posicions 103 a 111 i al final des de 31 a 41 si línia de retard amb una longitud de 128 etapes (47 a 55 i 15 a 25 si Disseny VHDL de la unitat de control d’un acceleròmetre 54 64 etapes). Ara, tot i que la correlació segueix sent circular i que de nou es fan càlculs amb valors de posicions no contigües, es soluciona la problemàtica degut a que s’assegura que aquests valors estan allunyats poc més de mig període de l’extrem del vector. Un vector que comenci amb uns i faci aviat la transició a zeros, trobarà en les posicions 103 a 111 (47 a 55) també uns i a l’inrevés (Fig. 3.29). En el cas de les posicions finals es produeix el mateix efecte amb les posicions 31 a 41 (15 a 25 si 64). Figura 3.29: Resultat d’aplicar l’algorisme prèvia ampliació del vector d’entrada de l’anterior figura 3.24. L’addició dels valors al inici i al final del vector reforcen les transició que hi havia en els extrems, fent ara possible una correcte detecció. Per acabar, cal esmentar com s’ha evitat el crear màxims ficticis al principi del vector que, juntament amb el mecanisme descrit en el punt 3.2.3, pot arribar a donar un resultat erroni al ser de valor massa elevat. Un vector iniciat amb zeros pot perfectament contenir en les posicions 103 a 111 (47 a 55 si 64) tot uns, cosa que crea un valor màxim en la correlació al seu inici de fins a 19 i força posteriorment a l’algorisme a finalitzar un cop entra en funcionament aquest mecanisme per evitar múltiples màxims (Fig. 3.30). Disseny VHDL de la unitat de control d’un acceleròmetre 55 Figura 3.30: Els valors afegits al inici del vector poden ocasionar un màxim que no es real i que pot afectar al resultat final. Cal doncs tenir en compte aquest cas alhora d’aplicar l’algorisme de representació de múltiples màxims que s’ha presentat en el punt 3.2.3. La única manera d’evitar aquesta situació es la d’obligar a que la correlació resultant entre el vector auxiliar i el patró ideal sigui no només menor que 10, sinó que també major que 2. És a dir, forçar a que el mecanisme només entri en acció si la transició està continguda entre les posicions 0 a 9. Això acota el nombre de casos resolts pel mecanisme de múltiples màxims, pel que disminueix la seva eficiència, però alhora evita tenir equivocacions degut a usar correlació circular. 3.2.5. Versió final de l’algorisme Després d’incloure en l’algorisme del descodificador les modificacions esmentades en els punts anteriors, aquest ha quedat finalment com (Fig. 3.31): Disseny VHDL de la unitat de control d’un acceleròmetre 62 Figura 3.35: Diagrama d’estats del multiplexador de sortida Tal i com s’ha especificat en el diagrama d’estats, les úniques entrades que es processen pel bloc són les que s’impliquen en el mode seleccionat, i ni tan sols es consideren la resta. S’evita d’aquesta manera que el mal funcionament d’algun dels blocs pugui ser evitat en aquest punt si es tria el mode adequat. Per posar un exemple, usant el mode 01 (línia de retard + comptador) s’eviten els errors tant del descodificador com del computador. S’afegeix així una capa addicional d’estabilitat en la unitat de control i descodificació. 3.5. El bloc de configuració El darrer bloc a descriure es el destinat a ser la interfície d’entrada i sortida de la unitat de control i descodificació: el bloc de configuració (Fig. 3.36). Disseny VHDL de la unitat de control d’un acceleròmetre 63 Figura 3.36: Interfície del bloc de configuració de la unitat de control. Com a entrades hi ha el rellotge, un reset i un enable, alhora que es té una entrada en mode sèrie (input) a on s’informa de la configuració que es vol, així com un marcador (change_config) que indica quan s’ha de llegir. Finalment, hi ha un conjunt de divuit senyals provinents de diferents oscil·ladors, dels que es transmet un d’ells cap a la línia de retard per ser processat. La principal funció d’aquest bloc és llegir un vector de configuració que ve informat per l’entrada externa input i es retransmet cap a la resta de blocs de la unitat de control. Al disposar d’entrades i sortides limitades en el xip, cal que aquest vector sigui transmès en mode sèrie, alhora que també es necessari que segueixi el format següent:  bit # 0: Nombre de plaques del sensor capacitiu: o (1) 3 plaques o (0) 2 plaques  bits # 1-2: Mode del multiplexador de sortida: o (11) computador o (10) línia de retard + comptador o (01) comptador + descodificador o (00) línia de retard + comptador + descodificador + computador  bit # 3: longitud de la línia de retard o (1) 64 bits o (0) 128 bits  bits # 4-8: Conjunt de bits usats per l’activació dels diferents oscil·ladors implantats en el xip, així com de la posterior selecció d’un dels seus senyals que es usat per mesurar l’acceleració que experimenta el dispositiu. També són requerits per fer una preselecció de les sondes que es monitoritzaran.  bits # 9-10: Activació / desactivació de les distintes sondes situades en determinades seccions del xip i que són visibles des de l’exterior.  bits # 11-16: Senyals addicionals de control de les sondes activades pels dos bits anteriors. Disseny VHDL de la unitat de control d’un acceleròmetre 64 És important notar que un cop s’activi el marcador change_config, el bloc llegeix els propers 17 bits informats en l’entrada input. Un cop hagin estat tots llegits es retransmeten per les diferents sortides, no abans de forma parcial. En el cas de tenir reset activat, el bloc posa a la sortida un vector amb tot zeros. Per exemple, si es transmet el següent vector: (bits 16 a 0) 110011 10 00110 0 00 0 se’ns indica que el sensor capacitiu usat es de dues plaques, que volem a la sortida totes les senyals possibles i que la línia de retard és d’una longitud de 128 bits. La resta de bits són usats per controlar components de fora de la unitat de control. Per tal de simplificar el bloc, s’ha subdividit en múltiples parts. La principal s’encarrega de llegir aquest vector d’informació i de repartir-ho internament per la unitat de control. Per les senyals corresponents a components a la resta del xip s’ha decidit el crear tres diferents subblocs que s’especifiquen a continuació. 3.5.1. Primer subbloc: selector de senyals provinents dels oscil·ladors A l’entrada del bloc de configuració disposem de totes les sortides dels oscil·ladors que hi ha al xip i que són provats, divuit en total. És doncs tasca d’aquest subbloc el seleccionar una d’aquestes senyals en funció de la informació que es detalli des de l’exterior (Fig. 3.37). Figura 3.37: Interfície del primer subbloc. El senyal escollit es portat a la sortida de la unitat de control, per ser immediatament redirigit cap a la línia de retard i posteriorment a l’entrada de la unitat de control per mesurar la seva freqüència (Taula 3.4). Es necessari que aquest senyal passi per fora de la unitat de control abans de ser processat, ja que una de les sondes del xip el monitoritza i es molt interessant que no hi hagin retards amb el que es visualitza des de la unitat de control i descodificació. reset enable config sortida reset enable config sortida 0 X XXXXX 0 1 1 01001 fin<8> 1 0 XXXXX 0 1 1 01010 fin<9> 1 1 00000 fin<0> 1 1 01011 fin<10> 1 1 00001 fin<1> 1 1 01100 fin<11> Disseny VHDL de la unitat de control d’un acceleròmetre 65 1 1 00010 fin<2> 1 1 01101 fin<12> 1 1 00011 fin<3> 1 1 01110 fin<13> 1 1 00100 fin<4> 1 1 01111 fin<14> 1 1 00101 fin<5> 1 1 10000 fin<15> 1 1 00110 fin<6> 1 1 10001 fin<16> 1 1 00111 fin<6> 1 1 altres 0 1 1 01000 fin<7> Taula 3.4: Relació d’entrades i sortides del primer subbloc. Finalment notar que aquest subbloc es de les poques parts de la unitat de control que no depenen d’un rellotge que marqui el seu funcionament. Això es així per tal d’evitar introduir distorsions al senyal seleccionat. 3.5.2. Segon subbloc: activació de les sondes El xip dissenyat es un prototip que serveix per verificar el seu funcionament en multitud de condicions. Té sentit doncs que incorpori una sèrie de sondes per tal de poder verificar el funcionament de tots els components a l’exterior. Aquest segon subbloc (Fig. 3.38) selecciona tres d’aquestes sondes segons el valor de les seves entrades (Taula 3.5). Figura 3.38: Interfície del segon subbloc. enable reset select config sortida enable reset select config sortida 0 X XX XXXXX no varia 1 1 11 00000 1 0 XX XXXXX 111 111 111 1 1 11 00001 1 1 00 XXXXX 111 111 111 1 1 11 00010 1 1 01 XXXXX 111 111 111 1 1 11 00011 1 1 10 00000 111 111 110 1 1 11 00100 1 1 10 00001 1 1 11 00101 111 111 000 1 1 10 00010 1 1 11 00110 1 1 10 00011 1 1 11 00111 1 1 10 00100 1 1 11 01000 1 1 10 00101 111 111 000 1 1 11 01001 1 1 10 00110 1 1 11 0101 1 1 10 00111 1 1 11 01011 111 001 110 1 1 10 01000 1 1 11 01100 1 1 10 01001 1 1 11 01101 1 1 10 01010 1 1 11 01110 1 1 10 01011 111 000 111 1 1 11 01111 001 111 110 Disseny VHDL de la unitat de control d’un acceleròmetre 66 1 1 10 01100 1 1 11 10000 1 1 10 01101 1 1 11 10001 1 1 10 01110 1 1 11 altres 111 111 111 1 1 10 01111 1 1 10 10000 1 1 10 10001 000 111 111 1 1 10 altres 111 111 111 Taula 3.5: Relació d’entrades i sortides del segon subbloc. La primera sonda es d’especial importància, ja que monitoritza l’entrada de la línia de retard. Es per això que s’incorporen més combinacions que amb la resta de sondes. 3.5.3. Tercer subbloc: activació dels oscil·ladors El darrer subbloc (Fig. 3.39) està fortament relacionat amb el primer, ja que aquest selecciona les senyals d’activació i desactivació de tots els oscil·ladors implantats en el xip. En un principi, tots ells estan desactivats a excepció d’un que es controlat directament des de l’exterior (Taula 3.6). La principal raó de la separació del primer subbloc i aquest tercer ha estat que aquest darrer es síncron respecte el senyal de rellotge, a diferència del primer que era purament combinacional. Figura 3.39: Interfície del tercer subbloc. enable reset config bit activat 0 X XXXXX no varia 1 0 XXXXX cap activat 1 1 00001 bit # 0 1 1 00010 bit # 1 1 1 00011 bit # 2 1 1 00100 bit # 3 1 1 00101 bit # 4 1 1 00110 bit # 5 1 1 00111 bit # 6 1 1 01000 bit # 7 1 1 01001 bit # 8 1 1 01010 bit # 9 1 1 01011 bit # 10 1 1 01100 bit # 11 Disseny VHDL de la unitat de control d’un acceleròmetre 67 1 1 01101 bit # 12 1 1 01110 bit # 13 1 1 01111 bit # 14 1 1 10000 bit # 15 1 1 10001 bit # 16 1 1 altres cap activat Taula 3.6: Relació d’entrades i sortides del tercer subbloc. Disseny VHDL de la unitat de control d’un acceleròmetre 68 Disseny VHDL de la unitat de control d’un acceleròmetre 69 4. Resultats Un xip per provar aquest disseny ha estat implementat en tecnologia CMOS de 150 nm. Aquest conté varis prototips de sensors capacitius i d’oscil·ladors (entre altres), juntament amb una part digital que inclou tots els components especificats al llarg del capítol 3, en la figura 4.1 es mostren els seus elements principals. La part digital ha estat descrita en llenguatge VHDL, sintetitzada amb Cadence RTL Compiler i distribuïda amb Encounter Digital Implementation, tenint en ment una freqüència d’entrada i de rellotge de 200 MHz. En la següent figura 4.2 es mostra amb detall la part digital del xip. Figura 4.1: Distribució final del xip tal i com s’ha fabricat. Inclou varis prototips de sensors capacitius i altres estructures (A), diversos oscil·ladors (B), una línia de retard (C) i la part digital que controla la resta de components i realitza la conversió temps a digital (D). Disseny VHDL de la unitat de control d’un acceleròmetre 70 Figura 4.2: Imatges del nucli digital incorporat en el xip just després d’haver estat distribuïda (A) i un cop ja fabricada (B), estant present en aquesta segona imatge la línia de retard. Finalment la part digital ha ocupat una altura de 360 μm i una amplada de 330 μm (118.800 μm2), mentre que la línia de retard ocupa 600.25160160   μm2. Tant la unitat de control i descodificació com el comptador han estat objecte de simulacions exhaustives en busca d’optimitzar cada etapa del seu disseny, en la figura 4.3 s’inclou una d’elles que mostra el funcionament del sistema de forma global. En aquestes s’observa un error no superior a 1 ps per a freqüències d’entrada i de rellotge properes als 200 MHz (~ 5 ns de període), inferior al 0,02%. Figura 4.3: Extracte d’una simulació global amb retards inclosos per a un rellotge de 5 ns de període, un oscil·lador d’11 ns i lectures (senyal sampling) cada 20 μs. En la imatge s’aprecien els senyals de sortida del comptador (counter), el descodificador (decoder) i el computador (computer), així com els marcadors associats per indicar quan poden ser llegits. Finalment, el senyal output indica la sortida final del dispositiu, exposant tots els resultats en mode sèrie. Totes les accions finalitzen en un temps màxim de 1,785 μs, que pot ser menor per diferents configuracions del dispositiu. Disseny VHDL de la unitat de control d’un acceleròmetre 71 En les següents figures 4.4, 4.5, 4.6 i 4.7 s’ensenyen de forma més detallada el funcionament del comptador, del descodificador, del comptador i del multiplexador de sortida respectivament. En elles s’ometen algunes de les senyals més generals, com són reset i enable, per tal de fer més èmfasi en les que intervenen activament en les operacions mostrades. Figura 4.4: Fragment de simulació del comptador. Tan aviat com el senyal soft_reset indica que el senyal sampling ha canviat a nivell alt, s’inicia la conversió del valor en format Gray cap a binari alhora que un reinici del comptatge. Tal i com es comenta en el punt 3.1.2, aquesta conversió es realitza en dos períodes i amb sincronia del senyal oscillator. Figura 4.5: Simulació del descodificador inclòs en la unitat. Quan s’indica a través del senyal soft_reset de que cal una nova descodificació del senyal d’entrada input es posa en funcionament el bloc. En el primer estat s’inicialitzen els diferents senyals auxiliars, en el segon es modifica el vector d’entrada per tal de facilitar els següents càlculs, i en el tercer es realitza la primera correlació que continuaran en el quart i cinquè estats. En el cas que es mostra, la major correlació que s’ha trobat és de 14 i es troba en la posició #11 (0B en binari), no s’han complert les condicions per acabar abans d’hora les operacions i s’han realitzat per a totes les posicions del vector d’entrada. Disseny VHDL de la unitat de control d’un acceleròmetre 78 qout: inout std_logic; zout: out std_logic ); end component; signal rst : std_logic; -- senyals que interconnecten els diferents digits signal z: std_logic_vector (width downto 0); signal q: std_logic_vector (width downto 0); -- Senyal auxiliar pel digit de més pes signal qx: std_logic; begin --Bucle per assignar valors a tots els digits exceptuant el de major pes create_lsb: for i in 1 to width-1 generate createbit: gray_1 port map (rst, q(i-1), z(i-1), clk, q(i), z(i)); end generate; -- Bit de major pes create_msb: gray_1 port map (rst, qx, z(width-1), clk, q(width), z(width)); --senyal auxiliar pel bit de major pes qx <= q(width-1) or q(width); -- mai hi haurà un ‘1’ per sota del bit de menor pes per definició z(0) <= '1'; -- reset i sortida final rst <= not hard_reset or soft_reset; output <= q(width downto 1); process(clk) begin if rising_edge(clk) then if hard_reset = '0' then q(0) <= '0'; elsif enable = '1' then if soft_reset = '1' then q(0) <= '1'; else --parity bit generation q(0) <= not q(0); end if; end if; end if; end process; end behav; -- ======= Detecció de sampling amb osc ======= Disseny VHDL de la unitat de control d’un acceleròmetre 79 library ieee; use ieee.std_logic_1164.all; entity osc_detector is port ( clk_s, osc, reset: in std_logic; clks_osc: out std_logic ); end osc_detector; architecture circuits of osc_detector is signal Q1, Q2: std_logic; begin clks_to_osc: process (osc, reset) begin if reset='0' then Q1 <= '0'; Q2 <= '0'; clks_osc <= '0'; elsif rising_edge(osc) then Q1 <= clk_s; Q2 <= Q1; clks_osc <= (Q1 and not Q2); end if; end process clks_to_osc; end circuits; -- ======= Detecció de sampling i osc amb clk ======= library ieee; use ieee.std_logic_1164.all; entity clk_detector is port ( clk_s, clk, counter, reset: in std_logic; soft_rst, counter_ready: out std_logic ); end clk_detector; architecture circuits of clk_detector is signal Q11, Q12, Q21, Q22: std_logic; begin clks_to_clk: process (clk, reset) begin if reset='0' then Q11 <= '0'; Q12 <= '0'; soft_rst <= '0'; elsif rising_edge(clk) then Disseny VHDL de la unitat de control d’un acceleròmetre 80 Q11 <= clk_s; Q12 <= Q11; soft_rst <= (Q11 and not Q12); end if; end process clks_to_clk; counter_to_clk: process (clk, reset) begin if reset='0' then Q21 <= '0'; Q22 <= '0'; counter_ready <= '0'; elsif rising_edge(clk) then Q21 <= counter; Q22 <= Q21; counter_ready <= (Q21 and not Q22); end if; end process counter_to_clk; end circuits; -- ======= Conversor Gray a Binari ======= library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity graytobin is port( clk, enable, hard_reset, soft_reset: in std_logic; input: in std_logic_vector (10 downto 0); counter_ready: out std_logic; output: out integer range 0 to 2047 ); end graytobin; architecture behav of graytobin is type state_machine is (stateA, stateB, stateC, stateD, stateE); signal state : state_machine; begin process(clk, hard_reset) variable gray, binary: std_logic_vector (10 downto 0); begin if hard_reset = '0' then state<= stateA; counter_ready <= '0'; output <= 0; gray:=(others=>'0'); binary:=(others=>'0'); Disseny VHDL de la unitat de control d’un acceleròmetre 81 elsif rising_edge(clk) then if enable = '1' then if state= stateA then if soft_reset = '1' then -- la entrada es guarda en el senyal ‘gray’ state<= stateB; gray:= input; else state<= state; gray:= gray; end if; binary:= binary; counter_ready<= '0'; output <= to_integer(unsigned(binary)); elsif state= stateB then -- conversió dels bits de major pes a binari binary(10):= gray(10); for x in 9 downto 5 loop binary(x):= gray(x) xor binary(x+1); end loop; gray:= gray; binary:= binary; counter_ready<= '0'; state<= stateC; elsif state<= stateC then -- conversió dels bits de menor pes a binari for x in 4 downto 0 loop binary(x):= gray(x) xor binary(x+1); end loop; counter_ready<= '0'; binary:= binary; gray:= gray; state<= stateD; elsif state <= stateD then counter_ready <= '0'; state <= stateE; output <= to_integer(unsigned(binary)); gray:= gray; binary:= binary; elsif state<= stateE then -- el resultat es posa a la sortida counter_ready<= '1'; state<= stateA; gray:= gray; binary:= binary; end if; Disseny VHDL de la unitat de control d’un acceleròmetre 82 else binary:=binary; gray:= gray; state<= state; end if; end if; end process; end behav; -- ======= Comptador ======= library ieee; use ieee.std_logic_1164.all; entity counter_11bit is port ( clk, osc, clk_s, enable, reset: in std_logic; soft_rst, counter_ready : out std_logic; output: out integer range 0 to 2047 ); end counter_11bit; architecture circuits of counter_11bit is component osc_detector port ( clk_s, osc, reset: in std_logic; clks_osc: out std_logic ); end component; component clk_detector port ( clk_s, clk, counter, reset: in std_logic; soft_rst, counter_ready: out std_logic ); end component; component counter generic(width:integer:=11); port( enable, hard_reset, soft_reset, clk: in std_logic; output: out std_logic_vector(width-1 downto 0) ); end component; component graytobin port( clk, enable, hard_reset, soft_reset: in std_logic; input: in std_logic_vector (10 downto 0); counter_ready: out std_logic; output: out integer range 0 to 2047 ); end component; signal clks_osc, counterready: std_logic; signal graycount: std_logic_vector (10 downto 0); Disseny VHDL de la unitat de control d’un acceleròmetre 83 begin oscdetector: osc_detector port map (clk_s, osc, reset, clks_osc); clkdetector: clk_detector port map (clk_s, clk, counterready, reset, soft_rst, counter_ready); graycounter: counter port map (enable, reset, clks_osc, osc, graycount); graytobinary: graytobin port map (osc, enable, reset, clks_osc, graycount, counterready, output); end circuits; -- ======= Descodificador ======= library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity total_decoder is generic(width:integer:=10); port( clk: in std_logic; hard_reset: in std_logic; soft_reset: in std_logic; enable: in std_logic; vector_size: in std_logic; -- 0 if size = 128 bits (+ 16 offset) -- 1 for size = 64 (+ 8 offset) input: in std_logic_vector (143 downto 0); out_enabled : out std_logic; output : out integer range 0 to 200 ); end total_decoder; architecture behav of total_decoder is -- Funció que compta i retorna el nombre de ‘1’ en un vector FUNCTION cnt (constant a: in std_logic_vector) return integer is variable nmb : integer range 0 to a'length; variable ai : std_logic_vector(a'length-1 downto 0); constant middle : integer := a'length/2; begin ai := a; if ai'length>=2 then nmb := cnt(ai(ai'length-1 downto middle))+cnt(ai(middle-1 downto 0)); else if ai(0)='1' then nmb:=1; else nmb:=0; end if; end if; Disseny VHDL de la unitat de control d’un acceleròmetre 84 return nmb; end cnt; -- fi de la funció -- definició dels senyals usats en el procés signal tdl_cnt: std_logic_vector (input'length+2*width-1 downto 0); signal xnor1, xnor2, auxiliar: std_logic_vector (2*width-1 downto 0); type state_machine is (state0, stateA, stateB, stateC, stateD, stateE, stateF, stateG, stateH, stateI); signal state : state_machine; begin process (clk) variable position1,position2,final_position: integer range 0 to 200; variable temp1,temp2,number_of_ones: integer range 0 to 20; -- es construeix un vector amb una transició ideal com: ||0....01....1|| constant tdl_sample: std_logic_vector (19 downto 0):= X"003FF"; begin if rising_edge(clk) then if hard_reset = '0' then -- si reset no es fa cap acció out_enabled <= '0'; state <= state0; temp1:= 0; temp2:= 0; number_of_ones:= 0; position1:= 1; position2:= 0; final_position:= 0; tdl_cnt<=(others=>'0'); auxiliar<=(others=>'0'); xnor1<=(others=>'0'); xnor2<=(others=>'0'); output<=0; elsif enable = '1' then -- el descodificador només actua si enable activat output<= final_position; case state is when state0 => -- si s’activa sampling s’inicien els càlculs -- construcció del vector auxiliar if soft_reset = '1' then if (vector_size = '0') then Disseny VHDL de la unitat de control d’un acceleròmetre 85 auxiliar<=input(111 downto 111-width+1) & input(width-1 downto 0); else auxiliar<=input(55 downto 55-width+1) & input(width-1 downto 0); end if; state <= stateA; else state<= state0; auxiliar<=(others=>'0'); end if; tdl_cnt<=(others=>'0'); temp1 := 0; temp2:= 0; position1:= 1; position2:= 0; final_position := 0; number_of_ones := 0; out_enabled<='0'; xnor1<=(others=>'0'); xnor2<=(others=>'0'); when stateA => -- contrucció del vector d’entrada ampliat com: -- -- si vector_size = 128 bits -------------------------------------------------- -- offset bits || bits útils -- -------143--------------127-------------------0 -- pel que treballarem amb un vector com ----------------------------------------------------------------- -- 111-width+2..111 || 0..143 || 31..31+width -- --0------------------------8-----------152--------------163-- -- -- si vector_size = 64 bits ----------------------------------------------------------------- -- bits no usats || offset bits || bits útils -- --143-------------71-------------------63-------------------0 ---------------------------------------------------------------------- -- 55..55-width+2 || 0..71 || 15+width..15 || 000000...-- --0------------------8----------80------------------92-------163— if (vector_size = '0') then tdl_cnt(width-2 downto 0)<=input(111 downto 111width+2); tdl_cnt(tdl_cnt'length-1 downto tdl_cnt'length-width1)<=input(31+width downto 31); tdl_cnt(tdl_cnt'length-width-2 downto width-1) <= input; else Disseny VHDL de la unitat de control d’un acceleròmetre 86 tdl_cnt(width-2 downto 0)<=input(55 downto 55width+2); tdl_cnt(71+2*width downto 71+width)<=input(15+width downto 15); tdl_cnt(tdl_cnt'length-1 downto 71+2*width+1)<=(others=>'0'); tdl_cnt(71+width-1 downto width-1)<=input(71 downto 0); end if; state <= stateB; out_enabled<='0'; number_of_ones:= 0; temp1:= 0; temp2:= 0; position1:= 1; position2:= 0; final_position:= 0; auxiliar<=auxiliar; xnor1<=(others=>'0'); xnor2<=(others=>'0'); when stateB => -- correla els primers bits del vector amb la mostra ideal -- posa el resultat en xnor1 i rota el vector tdl_cnt <= tdl_cnt(0) & tdl_cnt(tdl_cnt'high downto 1); xnor1 <= tdl_cnt(tdl_sample'length-1 downto 0) xnor tdl_sample; state <= stateC; auxiliar<=auxiliar; final_position:= 0; position1:= 1; position2:= 0; number_of_ones:= 0; temp1:= 0; temp2:= 0; out_enabled<='0'; xnor2<=(others=>'0'); when stateC => -- Sumatori de la primera correlació temp1:= cnt(xnor1); temp2:= 0; position1:= 1; position2:= 0; tdl_cnt <= tdl_cnt(0) & tdl_cnt(tdl_cnt'high downto 1); Disseny VHDL de la unitat de control d’un acceleròmetre 87 xnor2 <= tdl_cnt(tdl_sample'length-1 downto 0) xnor tdl_sample; out_enabled<= '0'; number_of_ones:= 0; auxiliar<=auxiliar; final_position:= 0; xnor1<=xnor1; state<= stateD; when stateD => -- Comprovació resultat en posicions parelles -- Correlació posicions parelles -- Sumatori posicions senars -- comptatge del nombre de ‘1’ en xnor2 temp2:= cnt(xnor2); --comprovant si tenim un nou màxim if temp1>number_of_ones then final_position:= position1; number_of_ones:= temp1; else final_position:= final_position; number_of_ones:= number_of_ones; end if; --comprovant en quina posició estem if position1 = tdl_cnt'length+1 then -- estem al final del vector d’entrada state <= stateH; else -- encara falten correlacions per fer state<= stateE; end if; xnor1 <= tdl_cnt (tdl_sample'length-1 downto 0) xnor tdl_sample; tdl_cnt <= tdl_cnt(0) & tdl_cnt(tdl_cnt'high downto 1); xnor2<=xnor2; position1:= position1; position2 := position2 +2; auxiliar<=auxiliar; out_enabled<='0'; when stateE => -- Comprovació resultat en posicions senars -- Correlació posicions senars -- Sumatori posicions parelles Disseny VHDL de la unitat de control d’un acceleròmetre 94 fout <= fin(10); elsif conf_MEMS_Sel="01011" then fout <= fin(11); elsif conf_MEMS_Sel="01100" then fout <= fin(12); elsif conf_MEMS_Sel="01101" then fout <= fin(13); elsif conf_MEMS_Sel="01110" then fout <= fin(14); elsif conf_MEMS_Sel="01111" then fout <= fin(15); elsif conf_MEMS_Sel="10000" then fout <= fin(16); elsif conf_MEMS_Sel="10001" then fout <= fin(17); else fout <= '0'; end if; else fout <= '0'; end if; end process; end behav; -- ======= Segon Multiplexador (probe) ======= library ieee; use ieee.std_logic_1164.all; entity mux2_probe is port (clk : in std_logic; e : in std_logic; reset : in std_logic; conf_MEMS_Sel: in std_logic_vector (4 downto 0); conf_probe_select : in std_logic_vector (1 downto 0); probe : out std_logic_vector (8 downto 0) ); end mux2_probe; architecture behav of mux2_probe is begin process (clk) begin -- si reset totes les sondes desactivades -- si conf_probe_select = 00 --> totes desactivades -- si 01 --> només probe 1 -- si 10 --> activació sondes -- si 11 --> com 10 però amb sonda 1 en comptes de 4 o 7 Disseny VHDL de la unitat de control d’un acceleròmetre 95 -- si conf_MEMS_Sel té un valor no esperat, totes desactivades if rising_edge(clk) then if e = '1' then if reset='0' then probe <= "111111111"; elsif conf_probe_select = "00" then probe <= "111111111"; elsif conf_probe_select = "01" then probe <= "111111110"; elsif conf_probe_select = "10" then if conf_MEMS_Sel="00000" then probe <= "111111110"; elsif conf_MEMS_Sel="00001" then probe <= "111111000"; elsif conf_MEMS_Sel="00010" then probe <= "111111000"; elsif conf_MEMS_Sel="00011" then probe <= "111111000"; elsif conf_MEMS_Sel="00100" then probe <= "111111000"; elsif conf_MEMS_Sel="00101" then probe <= "111111000"; elsif conf_MEMS_Sel="00110" then probe <= "111000111"; elsif conf_MEMS_Sel="00111" then probe <= "111000111"; elsif conf_MEMS_Sel="01000" then probe <= "111000111"; elsif conf_MEMS_Sel="01001" then probe <= "111000111"; elsif conf_MEMS_Sel="01010" then probe <= "111000111"; elsif conf_MEMS_Sel="01011" then probe <= "111000111"; elsif conf_MEMS_Sel="01100" then probe <= "000111111"; elsif conf_MEMS_Sel="01101" then probe <= "000111111"; elsif conf_MEMS_Sel="01110" then probe <= "000111111"; elsif conf_MEMS_Sel="01111" then probe <= "000111111"; elsif conf_MEMS_Sel="10000" then probe <= "000111111"; elsif conf_MEMS_Sel="10001" then probe <= "000111111"; else probe <= "111111111"; Disseny VHDL de la unitat de control d’un acceleròmetre 96 end if; else if conf_MEMS_Sel="00000" then probe <= "111111110"; elsif conf_MEMS_Sel="00001" then probe <= "111111000"; elsif conf_MEMS_Sel="00010" then probe <= "111111000"; elsif conf_MEMS_Sel="00011" then probe <= "111111000"; elsif conf_MEMS_Sel="00100" then probe <= "111111000"; elsif conf_MEMS_Sel="00101" then probe <= "111111000"; elsif conf_MEMS_Sel="00110" then probe <= "111001110"; elsif conf_MEMS_Sel="00111" then probe <= "111001110"; elsif conf_MEMS_Sel="01000" then probe <= "111001110"; elsif conf_MEMS_Sel="01001" then probe <= "111001110"; elsif conf_MEMS_Sel="01010" then probe <= "111001110"; elsif conf_MEMS_Sel="01011" then probe <= "111001110"; elsif conf_MEMS_Sel="01100" then probe <= "001111110"; elsif conf_MEMS_Sel="01101" then probe <= "001111110"; elsif conf_MEMS_Sel="01110" then probe <= "001111110"; elsif conf_MEMS_Sel="01111" then probe <= "001111110"; elsif conf_MEMS_Sel="10000" then probe <= "001111110"; elsif conf_MEMS_Sel="10001" then probe <= "001111110"; else probe <= "111111111"; end if; end if; end if; end if; end process; end behav; -- ======= Tercer Multiplexador (rst_osc) ======= Disseny VHDL de la unitat de control d’un acceleròmetre 97 library ieee; use ieee.std_logic_1164.all; entity mux3_osc is port (clk : in std_logic; e : in std_logic; reset : in std_logic; conf_MEMS_Sel: in std_logic_vector (4 downto 0); rst: in std_logic; rst_osc: out std_logic_vector (16 downto 0) ); end mux3_osc; architecture behav of mux3_osc is begin process (clk) begin -- activació i desactivació dels diferents oscil·ladors del xip if rising_edge(clk) then if e = '1' then if reset='0' then rst_osc <= (others => '1'); elsif conf_MEMS_Sel="00001" then rst_osc <= (0=> rst, others => '1'); elsif conf_MEMS_Sel="00010" then rst_osc <= (1=> rst, others => '1'); elsif conf_MEMS_Sel="00011" then rst_osc <= (2=> rst, others => '1'); elsif conf_MEMS_Sel="00100" then rst_osc <= (3=> rst, others => '1'); elsif conf_MEMS_Sel="00101" then rst_osc <= (4=> rst, others => '1'); elsif conf_MEMS_Sel="00110" then rst_osc <= (5=> rst, others => '1'); elsif conf_MEMS_Sel="00111" then rst_osc <= (6=> rst, others => '1'); elsif conf_MEMS_Sel="01000" then rst_osc <= (7=> rst, others => '1'); elsif conf_MEMS_Sel="01001" then rst_osc <= (8=> rst, others => '1'); elsif conf_MEMS_Sel="01010" then rst_osc <= (9=> rst, others => '1'); elsif conf_MEMS_Sel="01011" then rst_osc <= (10=> rst, others => '1'); elsif conf_MEMS_Sel="01100" then rst_osc <= (11=> rst, others => '1'); elsif conf_MEMS_Sel="01101" then Disseny VHDL de la unitat de control d’un acceleròmetre 98 rst_osc <= (12=> rst, others => '1'); elsif conf_MEMS_Sel="01110" then rst_osc <= (13=> rst, others => '1'); elsif conf_MEMS_Sel="01111" then rst_osc <= (14=> rst, others => '1'); elsif conf_MEMS_Sel="10000" then rst_osc <= (15=> rst, others => '1'); elsif conf_MEMS_Sel="10001" then rst_osc <= (16=> rst, others => '1'); else rst_osc <= (others => '1'); end if; end if; end if; end process; end behav; -- ======= Bloc de configuració ======= library ieee; use ieee.std_logic_1164.all; entity configuration_bits is port (clk : in std_logic; e : in std_logic; change_config: in std_logic; reset : in std_logic; input : in std_logic; fin: in std_logic_vector (17 downto 0); rst: in std_logic; output : out std_logic_vector (9 downto 0); fout: out std_logic; rst_osc: out std_logic_vector(16 downto 0); probe : out std_logic_vector (8 downto 0) ); end configuration_bits; architecture circuits of configuration_bits is component mux1_fout port (e : in std_logic; reset : in std_logic; conf_MEMS_Sel: in std_logic_vector (4 downto 0); fin: in std_logic_vector (17 downto 0); fout: out std_logic ); end component; Disseny VHDL de la unitat de control d’un acceleròmetre 99 component mux2_probe port (clk : in std_logic; e : in std_logic; reset : in std_logic; conf_MEMS_Sel: in std_logic_vector (4 downto 0); conf_probe_select : in std_logic_vector (1 downto 0); probe : out std_logic_vector (8 downto 0) ); end component; component mux3_osc port (clk : in std_logic; e : in std_logic; reset : in std_logic; conf_MEMS_Sel: in std_logic_vector (4 downto 0); rst: in std_logic; rst_osc: out std_logic_vector (16 downto 0) ); end component; signal temp : std_logic_vector (16 downto 0); signal conf_MEMS_Sel : std_logic_vector (4 downto 0); signal conf_probe_select : std_logic_vector (1 downto 0); type state_machine is (stateA, stateB); signal state : state_machine; begin mux1: mux1_fout port map (e, reset, conf_MEMS_Sel, fin, fout); mux2: mux2_probe port map (clk, e, reset, conf_MEMS_Sel, conf_probe_select, probe); mux3: mux3_osc port map (clk, e, reset, conf_MEMS_Sel, rst, rst_osc); process (clk) variable bits : natural range 0 to 16; begin if rising_edge(clk) then if reset = '0' then output <= (others => '0'); -- initial bits state <= stateA; conf_MEMS_Sel<=(others=>'0'); conf_probe_select<=(others=>'0'); temp<= (others=>'0'); bits:= 0; elsif state = stateA then if change_config = '1' then Disseny VHDL de la unitat de control d’un acceleròmetre 100 bits := 1; temp <= input & temp (temp'high downto 1); state <= stateB; output <= (others=>'0'); conf_MEMS_Sel<= (others=>'0'); conf_probe_select<= (others=>'0'); else bits:= 0; state<=stateA; temp<=temp; output<= temp(16 downto 11) & temp(3 downto 0); conf_MEMS_Sel<= temp (8 downto 4); conf_probe_select<= temp (10 downto 9); end if; else temp <= input & temp (temp'high downto 1); if bits = 16 then bits:= 0; state <= stateA; else state<=stateB; bits := bits + 1; end if; output<= (others=>'0'); conf_MEMS_Sel<= (others=>'0'); conf_probe_select<= (others=>'0'); end if; end if; end process; end circuits; -- ======= Multiplexador de Sortida ======= library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; entity mux is port(clk: in std_logic; counter: in integer range 0 to 2047; decoder: in integer range 0 to 150; compute: in integer range 0 to 300000; tdl_cnt: in std_logic_vector (143 downto 0); reset : in std_logic; counter_ready, decoder_ready : in std_logic; compute_ready: in std_logic; mode: in std_logic_vector (1 downto 0); Disseny VHDL de la unitat de control d’un acceleròmetre 101 -- si mode = '11' -> output = computador -- si mode = '10' -> output = tdl+comptador -- si mode = '01' -> output = comptador+descodificador -- si mode= '00'->output = tdl+comptador+descodificador+computador out_enabled : out std_logic; output: out std_logic ); end mux; architecture behav of mux is type state_machine is (stateA, stateB, stateC, stateD, stateE); signal state : state_machine; begin main: process (clk) variable temp_tdl : std_logic_vector (143 downto 0); variable temp_dec: std_logic_vector (7 downto 0); variable temp_counter: std_logic_vector (10 downto 0); variable temp_compute: std_logic_vector (17 downto 0); variable pos : integer range 0 to 144; begin if rising_edge(clk) then if reset = '0' then state <= stateA; out_enabled<='0'; output<='0'; temp_tdl:= (others=>'0'); temp_dec:= (others=>'0'); temp_compute:= (others=>'0'); temp_counter:= (others=>'0'); pos:= 0; elsif state = stateA then pos := 0; out_enabled <= '0'; output<='0'; temp_tdl := tdl_cnt; if mode= B"10" then if counter_ready='1' then temp_counter := std_logic_vector(to_unsigned(counter, temp_counter'length)); state <= stateB; else temp_counter:= temp_counter; state<= state; end if; elsif mode= B"01" then if decoder_ready='1' then temp_counter:= temp_counter; Disseny VHDL de la unitat de control d’un acceleròmetre 102 temp_dec:= std_logic_vector(to_unsigned(decoder,temp_dec'length)); state<= stateC; elsif counter_ready='1' then temp_counter:= std_logic_vector(to_unsigned(counter, temp_counter'length)); temp_dec:= temp_dec; state<= state; else temp_counter:= temp_counter; temp_dec:= temp_dec; state<= state; end if; elsif mode= B"11" then if compute_ready='1' then temp_compute := std_logic_vector(to_unsigned(compute,temp_compute'length)); state<= stateE; else temp_compute:= temp_compute; state<= state; end if; elsif mode= B"00" then if compute_ready='1' then temp_counter:= temp_counter; temp_dec:= temp_dec; temp_compute:= std_logic_vector(to_unsigned(compute,temp_compute'length)); state<= stateB; elsif decoder_ready='1' then temp_counter:= temp_counter; temp_dec:= std_logic_vector(to_unsigned(decoder,temp_dec'length)); temp_compute:= temp_compute; state<= state; elsif counter_ready='1' then temp_counter:= std_logic_vector(to_unsigned(counter, temp_counter'length)); temp_dec:= temp_dec; temp_compute:= temp_compute; state<= state; else temp_counter:= temp_counter; temp_dec:= temp_dec; temp_compute:= temp_compute; state<= state; end if; Disseny VHDL de la unitat de control d’un acceleròmetre 103 else temp_counter:= temp_counter; temp_dec:= temp_dec; temp_compute:= temp_compute; state<= state; end if; elsif state = stateB then -- output <- tdl_cnt out_enabled <= '1'; output <= temp_tdl (0); temp_tdl := temp_tdl(0) & temp_tdl (temp_tdl'high downto 1); pos := pos+1; if pos = 144 then pos := 0; state <= stateC; else state<= stateB; end if; temp_dec:= temp_dec; temp_counter:= temp_counter; temp_compute:= temp_compute; elsif state <= stateC then -- output <- counter output <= temp_counter (0); temp_counter:=temp_counter(0)&temp_counter(temp_counter'high downto 1); pos := pos+1; out_enabled <= '1'; if pos = 11 then pos:= 0; if mode=B"10" then state <= stateA; else state <= stateD; end if; else state<=stateC; end if; temp_tdl:= (others=>'0'); temp_dec:= temp_dec; temp_compute:= temp_compute; elsif state <= stateD then -- output <- decoder output <= temp_dec (0); temp_dec:=temp_dec(0)&temp_dec(temp_dec'high downto 1); Disseny VHDL de la unitat de control d’un acceleròmetre 110 variable temp: string (inp'left+1 downto 1) := (others => 'X'); begin for i in inp'reverse_range loop if inp(i)='1' then temp(i+1):='1'; elsif inp(i)='0' then temp(i+1):='0'; end if; end loop; return temp; end function; -- funció per a la conversió de text a vector function str_to_stdvec (inp:string) return std_logic_vector is variable temp: std_logic_vector (inp'range) := (others => 'X'); begin for i in inp'range loop if (inp(i)='1') then temp(i) := '1'; elsif (inp(i)='0') then temp(i) :='0'; end if; end loop; return temp; end function str_to_stdvec; SIGNAL clk : std_logic; SIGNAL hard_reset : std_logic; SIGNAL soft_reset : std_logic; SIGNAL enable : std_logic; signal vectorsize: std_logic; signal input: std_logic_vector (144 downto 0); signal out_enable : std_logic; SIGNAL output : integer range 0 to 150; BEGIN dut : total_decoder PORT MAP (clk, hard_reset, soft_reset, enable, vectorsize, input(143 downto 0), out_enable, output); process file infile, outfile, frecfile: text; variable line_buffer: line; variable tdl: std_logic_vector (287 downto 0); variable isone: std_logic:= '0'; variable sim, value: integer:=1; variable numberofones,numberofzeroes,pos,ones,zeroes,i: integer:=0; variable str_decoder: string (8 downto 1); Disseny VHDL de la unitat de control d’un acceleròmetre 111 variable str_tdl: string (144 downto 1); variable nokresults, okresults: integer:=0; begin -- reset i preparació de paràmetres per a la simulació file_open(outfile, "decoder.out", WRITE_MODE); hard_reset <= '0'; enable <= '1'; wait for 1 ns; hard_reset <= '1'; input(144) <= '0'; -- simulació while (sim<19) loop write(line_buffer, "== simulation #" &integer'image(sim)&" =="); writeline(outfile, line_buffer); -- construcció de les línies de retard if sim=1 then vectorsize <= '0'; --128 bits numberofones:= 64; numberofzeroes:=64; write(line_buffer, "--period =128, duty cycle=50%"); elsif sim=2 then vectorsize <= '0'; --128 bits numberofones:= 50; numberofzeroes:=78; write(line_buffer, "--period =128, duty cycle=40%"); elsif sim=3 then vectorsize <= '0'; --128 bits numberofones:= 78; numberofzeroes:=50; write(line_buffer, "--period =128, duty cycle=60%"); elsif sim=4 then vectorsize <= '0'; --128 bits numberofones:= 56; numberofzeroes:=56; write(line_buffer, "--period =112, duty cycle=50%"); elsif sim=5 then vectorsize <= '0'; --128 bits numberofones:= 45; numberofzeroes:=67; write(line_buffer, "--period =112, duty cycle=40%"); elsif sim=6 then vectorsize <= '0'; --128 bits numberofones:= 67; numberofzeroes:=45; write(line_buffer, "--period =112, duty cycle=60%"); Disseny VHDL de la unitat de control d’un acceleròmetre 112 elsif sim=7 then vectorsize <= '0'; --128 bits numberofones:= 72; numberofzeroes:=72; write(line_buffer, "--period =144, duty cycle=50%"); elsif sim=8 then vectorsize <= '0'; --128 bits numberofones:= 57; numberofzeroes:=87; write(line_buffer, "--period =144, duty cycle=40%"); elsif sim=9 then vectorsize <= '0'; --128 bits numberofones:= 87; numberofzeroes:=57; write(line_buffer, "--period =144, duty cycle=60%"); elsif sim=10 then vectorsize <= '1'; --64 bits numberofones:= 32; numberofzeroes:=32; write(line_buffer, "--period =64, duty cycle=50%"); elsif sim=11 then vectorsize <= '1'; --64 bits numberofones:= 25; numberofzeroes:=39; write(line_buffer, "--period =64, duty cycle=40%"); elsif sim=12 then vectorsize <= '1'; --64 bits numberofones:= 39; numberofzeroes:=25; write(line_buffer, "--period =64, duty cycle=60%"); elsif sim=13 then vectorsize <= '1'; --64 bits numberofones:= 28; numberofzeroes:=28; write(line_buffer, "--period =56, duty cycle=50%"); elsif sim=14 then vectorsize <= '1'; --64 bits numberofones:= 22; numberofzeroes:=34; write(line_buffer, "--period =56, duty cycle=40%"); elsif sim=15 then vectorsize <= '1'; --64 bits numberofones:= 34; numberofzeroes:=22; write(line_buffer, "--period =56, duty cycle=60%"); elsif sim=16 then vectorsize <= '1'; --64 bits numberofones:= 36; numberofzeroes:=36; Disseny VHDL de la unitat de control d’un acceleròmetre 113 write(line_buffer, "--period =72, duty cycle=50%"); elsif sim=17 then vectorsize <= '1'; --64 bits numberofones:= 29; numberofzeroes:=43; write(line_buffer, "--period =72, duty cycle=40%"); elsif sim=18 then vectorsize <= '1'; --64 bits numberofones:= 43; numberofzeroes:=29; write(line_buffer, "--period =72, duty cycle=60%"); end if; writeline(outfile, line_buffer); zeroes:=0; ones:=0; isone:='0'; pos:=0; while (pos<288) loop tdl(pos):=isone; if isone='0' then zeroes:=zeroes+1; else ones:=ones+1; end if; if zeroes=numberofzeroes then zeroes:=0; isone:='1'; elsif ones=numberofones then ones:=0; isone:='0'; end if; pos:=pos+1; end loop; pos:=0; -- inserim la línia de retard que pertoca i esperem el resultat while (pos<144) loop input(143 downto 0)<=tdl(143+pos downto pos); wait for 1 ns; soft_reset<='1'; wait for 100 ps; soft_reset<='0'; wait until rising_edge(out_enable); value:= output; wait until out_enable='0'; -- imprimim el resultat en l’arxiu de sortida str_tdl:= stdvec_to_str (input(143 downto 0)); Disseny VHDL de la unitat de control d’un acceleròmetre 114 write(line_buffer, "tdl is: " &str_tdl); writeline(outfile, line_buffer); write(line_buffer, "output is " &integer'image(value)); pos:=pos+1; -- comprovació de si el valor obtingut és o no correcte i:=0; while input(i)='0' and i/=144 loop i:=i+1; end loop; while input(i)='1' and i/=144 loop i:=i+1; end loop; --la variable 'i' hauria de registrar la transició 1->0 -- si el resultat és 143 o 0, es que no hi ha cap transició if i=value then write(line_buffer, " -> OK!"); okresults:= okresults+1; else write(line_buffer, " -> NOK!"); nokresults:=nokresults+1; end if; writeline(outfile, line_buffer); write(line_buffer, " ..."); writeline(outfile, line_buffer); ASSERT i=value REPORT "Found position is not correct." SEVERITY warning; end loop; sim:=sim+1; end loop; write(line_buffer, "# of OK results: "&integer'image(okresults)&" || # of not OK results: "&integer'image(nokresults)); writeline(outfile, line_buffer); okresults:=okresults+nokresults; write(line_buffer, "total number of simulations: "&integer'image(okresults)); writeline(outfile, line_buffer); -- totes les línies de retard han estat simulades, finalitzem el banc de proves assert false report "End of simulation." severity failure; end process; -- rellotge usat en el banc de proves clock: process begin Disseny VHDL de la unitat de control d’un acceleròmetre 115 clk <= '1'; wait for 25 ps; clk <= '0'; wait for 25 ps; end process clock; END stimulus; Disseny VHDL de la unitat de control d’un acceleròmetre 116 Disseny VHDL de la unitat de control d’un acceleròmetre 117 B.2 Banc de Proves de la Unitat de Control i Descodificació --- Recopilació de les sortides de la Unitat de Control --- i Descodificació en resposta a un senyal d'entrada --- definit en aquest mateix codi. --- La configuració d'entrada de la Unitat es llegeix de l'arxiu 'input.in'. --- Els resultats es presenten a l'arxiu 'output.out', a on es mostren --- les primeres 50 aproximacions que realitza la Unitat --- de la frecuència del senyal d'entrada tant en codificació binària com en decimal. ---------------------------------------------------------- -------- línia de retard ideal usada en la simulació ---------------------------------------------------------- library ieee; use ieee.std_logic_1164.all; entity delay is port (a: in std_logic; reset: in std_logic; b: out std_logic ); end delay; architecture behav of delay is begin process(a, reset) begin if reset='0' then b<='0'; else -- delay ~ osc_in_period/128 b <= a after 164.0625 ps; end if; end process; end behav; ----------------------------------------- LIBRARY ieee; USE ieee.std_logic_1164.all; use std.textio.all; Disseny VHDL de la unitat de control d’un acceleròmetre 118 use ieee.numeric_std.all; use ieee.math_real.all; entity total_design_tb is end total_design_tb; ARCHITECTURE stimulus OF total_design_tb IS COMPONENT total_design port ( clk: in std_logic; osc_in : in std_logic; clk_s: in std_logic; enable : in std_logic; change_config: in std_logic; reset : in std_logic; input: in std_logic; rst: in std_logic; fin: in std_logic_vector (17 downto 0); tdl_cnt : in std_logic_vector (143 downto 0); vector_size: out std_logic; fout: out std_logic; conf_probe_in_selectX: out std_logic_vector (5 downto 0); rst_osc: out std_logic_vector (16 downto 0); probe: out std_logic_vector (8 downto 0); out_enabled : out std_logic; output : out std_logic ); END COMPONENT; -- funció conversió de text a vector function str_to_stdvec (inp:string) return std_logic_vector is variable temp: std_logic_vector (inp'range) := (others => 'X'); begin for i in inp'range loop if (inp(i)='1') then temp(i) := '1'; elsif (inp(i)='0') then temp(i) :='0'; end if; end loop; return temp; end function str_to_stdvec; -- funció conversió de vector a text function stdvec_to_str (inp:std_logic_vector) return string is variable temp: string (inp'left+1 downto 1) := (others => 'X'); begin for i in inp'reverse_range loop Disseny VHDL de la unitat de control d’un acceleròmetre 119 if inp(i)='1' then temp(i+1):='1'; elsif inp(i)='0' then temp(i+1):='0'; end if; end loop; return temp; end function; component delay is port(a:in std_logic; reset: in std_logic; b: out std_logic ); end component; --rellotges usats SIGNAL clk : std_logic; SIGNAL osc_in : std_logic; SIGNAL clk_s : std_logic; SIGNAL clk_s_int : std_logic; --senyals d’entrada no directament controlats per l’usuari SIGNAL e, change_config, reset: std_logic; SIGNAL input : std_logic; signal tdl_cnt: std_logic_vector (143 downto 0); signal tdl: std_logic_vector(143 downto 0); -- sortides signal out_enabled, output : std_logic; signal fout, vector_size: std_logic; signal conf_probe_in_selectX: std_logic_vector (5 downto 0); signal probe: std_logic_vector (8 downto 0); signal rst_osc: std_logic_vector (16 downto 0); -- entrades signal input_vector: std_logic_vector (16 downto 0); signal fin: std_logic_vector (17 downto 0); signal rst: std_logic; -- constants temporals constant clk_s_period: time:= 20 us; constant osc_in_period: time := 21 ns; constant clk_period: time := 10 ns; -- el retard de cada etapa de la línia de retard ha de ser modificada manualment BEGIN dut : total_design Disseny VHDL de la unitat de control d’un acceleròmetre 126 Disseny VHDL de la unitat de control d’un acceleròmetre 127 Apèndix C. Paràmetres de disseny de la Unitat mitjançant Cadence C.1 Cadence RTL Compiler ## Paràmetres per a la construcció de les portes lògiques necessàries ## a partir de la codificació VHDL #### Template Script for RTL->Gate-Level Flow (generated from RC v08.10-s222_1) if {[file exists /proc/cpuinfo]} { sh grep "model name" /proc/cpuinfo sh grep "cpu MHz" /proc/cpuinfo } puts "Hostname : [info hostname]" ########################################################################### ### ## Preset global variables and attributes ########################################################################### ### set DESIGN total_design set SYN_EFF medium set MAP_EFF medium set DATE [clock format [clock seconds] -format "%b%d-%T"] set _OUTPUTS_PATH rc_out/outputs_${DATE} set _REPORTS_PATH rc_out/reports_${DATE} set _LOG_PATH rc_out/logs_${DATE} set_attribute lib_search_path {/software/Hit_kits/pdk_v1.9.1/PDK_LF150i_V1_9_1/digital/lef /software/Hit_kits/pdk_v1.9.1/PDK_LF150i_V1_9_1/digital/liberty} / set_attribute script_search_path {./scripts} / set_attribute hdl_search_path { ./vhdl/total_design/vhdl} / ##Default undriven/unconnected setting is 'none'. ##set_attribute hdl_unconnected_input_port_value 0 | 1 | x | none / ##set_attribute hdl_undriven_output_port_value 0 | 1 | x | none / ##set_attribute hdl_undriven_signal_value 0 | 1 | x | none / #set_attribute wireload_mode <value> / set_attribute information_level 7 / Disseny VHDL de la unitat de control d’un acceleròmetre 128 ############################################################### ## Library setup ############################################################### set_attribute library {LF150DI_HS_F_V1_6_typical_conditional.lib LF150DI_HS_F_V1_6_functional.lib} set_attribute lef_library {LF150DI_HS_F_V1_6.lef} #################################################################### ## Load Design #################################################################### read_hdl -vhdl {vhdl.vhd} elaborate $DESIGN puts "Runtime & Memory after 'read_hdl'" timestat Elaborate check_design -unresolved #################################################################### ## Constraints Setup #################################################################### set clock1 [define_clock -period 5000 -domain domain1 -name clk] ##200 MHz (5 ns) set clock2 [define_clock -period 5000 -domain domain2 -name clk_s] set clock3 [define_clock -period 5000 -domain domain3 -name osc_in] ##200 MHz (5 ns) external_delay -input 500 -clock $clock1 [all_inputs] external_delay -output 500 -clock $clock1 [all_outputs] set_attribute external_pin_cap 300 /designs/total_design/ports_out/* set_attribute external_driver [find [find -libcell LH_X1] -libpin Q] [find / -port tdl_cnt*] set_attribute external_driver [find [find -libcell LNCP_X4] -libpin QN] [find / -port fin*] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port clk] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port clk_s] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port enable] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port change_config] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port reset] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port rst] set_attribute external_driver [find [find -libcell INV_X3] -libpin Q] [find / -port input] set_attribute external_driver [find [find -libcell AO321_X2] -libpin Q] [find / -port osc_in] #set_attribute external_driver_input_slew <integer> <port> #set_attribute max_fanout <value> /designs/$DESIGN #set_attribute max_capacitance <value in fF> /designs/$DESIGN #set_attribute max_transition <value in ps> /designs/$DESIGN Disseny VHDL de la unitat de control d’un acceleròmetre 129 #path_disable -from <object> -through <object> -to <object> -name <string> #multi_cycle -from <object> -through <object> -to <object> -name <string> #path_delay -from <object> -through <object> -to <object> -delay <delay in ps> -#name <string> puts "The number of exceptions is [llength [find /designs/$DESIGN -exception *]]" if {![file exists ${_OUTPUTS_PATH}]} { file mkdir ${_OUTPUTS_PATH} puts "Creating directory ${_OUTPUTS_PATH}" } if {![file exists ${_REPORTS_PATH}]} { file mkdir ${_REPORTS_PATH} puts "Creating directory ${_REPORTS_PATH}" } if {![file exists ${_LOG_PATH}]} { file mkdir ${_LOG_PATH} puts "Creating directory ${_LOG_PATH}" } ########################################################################### ######################### ## Synthesizing to generic ########################################################################### ######################### synthesize -to_generic -eff $SYN_EFF puts "Runtime & Memory after 'synthesize -to_generic'" timestat GENERIC report datapath > $_REPORTS_PATH/${DESIGN}_datapath_generic.rpt ## ungroup -threshold <value> ########################################################################### ######################### ## Synthesizing to gates ########################################################################### ######################### synthesize -to_mapped -eff $MAP_EFF -no_incr puts "Runtime & Memory after 'synthesize -to_map -no_incr'" timestat MAPPED report datapath > $_REPORTS_PATH/${DESIGN}_datapath_map.rpt ##Intermediate netlist for LEC verification.. write_hdl -lec > ${_OUTPUTS_PATH}/${DESIGN}_intermediate.v Disseny VHDL de la unitat de control d’un acceleròmetre 130 write_do_lec -revised_design ${_OUTPUTS_PATH}/${DESIGN}_intermediate.v -logfile ${_LOG_PATH}/rtl2intermediate.lec.log > ${_OUTPUTS_PATH}/rtl2intermediate.lec.do ########################################################################### ############################ ## Incremental Synthesis ########################################################################### ############################ ## Uncomment to remove assigns & insert tiehilo cells during Incremental synthesis ##set_attribute remove_assigns true / ##set_remove_assign_options -buffer_or_inverter <libcell> -design <design|subdesign> ##set_attribute use_tiehilo_for_const <none|duplicate|unique> / synthesize -to_mapped -eff $MAP_EFF -incr puts "Runtime & Memory after incremental synthesis" timestat INCREMENTAL write_design -basename ${_OUTPUTS_PATH}/${DESIGN}_m -encounter ################################# ### write_do_lec ################################# write_do_lec -golden_design ${_OUTPUTS_PATH}/${DESIGN}_intermediate.v - revised_design ${_OUTPUTS_PATH}/${DESIGN}_m.v -logfile ${_LOG_PATH}/intermediate2final.lec.log > ${_OUTPUTS_PATH}/intermediate2final.lec.do ##Uncomment if the RTL is to be compared with the final netlist.. ##write_do_lec -revised_design ${_OUTPUTS_PATH}/${DESIGN}_m.v -logfile ${_LOG_PATH}/rtl2final.lec.log > ${_OUTPUTS_PATH}/rtl2final.lec.do report qor puts "Final Runtime & Memory." timestat FINAL puts "============================" puts "Synthesis Finished ........." puts "============================" file copy [get_attr stdout_log /] ${_LOG_PATH}/. ##quit Disseny VHDL de la unitat de control d’un acceleròmetre 131 C.2 Encounter Digital Implementation ## Definició de la distribució física de les portes lògiques en el xip ## i l’alimentació i rellotge que requereixen ####################################################### # # # Encounter Command Logging File # # Created on Fri Oct 28 12:28:59 2011 # # # ####################################################### #@(#)CDS: Encounter v09.12-s159_1 (32bit) 07/15/2010 13:17 (Linux 2.6) #@(#)CDS: NanoRoute v09.12-s013 NR100629-2344/USR64-UB (database version 2.30, 102.1.1) {superthreading v1.15} #@(#)CDS: CeltIC v09.12-s012_1 (32bit) 07/01/2010 02:29:05 (Linux 2.6.9-89.0.19.ELsmp) #@(#)CDS: AAE 09.12-e022 (32bit) 07/15/2010 (Linux 2.6.9-89.0.19.ELsmp) #@(#)CDS: CTE 09.12-s069_1 (32bit) Jul 15 2010 05:39:06 (Linux 2.6.9-89.0.19.ELsmp) #@(#)CDS: CPE v09.12-s009 # càrrega dels diferents arxius prèviament dissenyats zoomBox 0.020 0.062 0.017 0.063 loadConfig Default_wGDSv191b.conf 0 getenv ENCOUNTER_CONFIG_RELATIVE_CWD setDoAssign getIoFlowFlag setUIVar rda_Input ui_timingcon_file ../vhdl_compiler/rc_out/fourth_version/total_design_m.sdc setUIVar rda_Input ui_netlist ../vhdl_compiler/rc_out/fourth_version/total_design_m.v commitConfig fit setDrawView place oaIn verilog_albert total_design fplan # definició de l’alimentació de la Unitat clearGlobalNets globalNetConnect gnd! -type pgpin -pin VSS -inst * globalNetConnect vdd! -type pgpin -pin VDD -inst * fit addRing -spacing_bottom 1 -width_left 5 -width_bottom 5 -width_top 5 -spacing_top 1 - layer_bottom METAL_F -stacked_via_top_layer METAL_F -width_right 5 -around core - jog_distance 0.61 -offset_bottom 0.61 -layer_top METAL_F -threshold 0.61 -offset_left 0.61 -spacing_right 0.34 -spacing_left 0.34 -offset_right 0.61 -offset_top 0.61 -layer_right METAL5 -nets {gnd! vdd! } -follow io -stacked_via_bottom_layer METAL1 -layer_left METAL5 addStripe -block_ring_top_layer_limit METAL_F -max_same_layer_jog_length 1.16 - padcore_ring_bottom_layer_limit METAL5 -number_of_sets 6 -stacked_via_top_layer Disseny VHDL de la unitat de control d’un acceleròmetre 132 METAL_F -padcore_ring_top_layer_limit METAL_F -spacing 1 -merge_stripes_value 0.61 - layer METAL_F -block_ring_bottom_layer_limit METAL5 -width 1 -nets {gnd! vdd! } - stacked_via_bottom_layer METAL1 selectWire 10.5400 156.5900 11.5400 355.1700 6 gnd! selectWire 0.6100 156.5900 11.5400 157.5900 6 gnd! deleteSelectedFromFPlan # Distribució de les portes lògiques getMultiCpuUsage -localCpu setFillerMode -reset setFillerMode -corePrefix FILLER -createRows 1 -doDRC 1 -deleteFixed 1 -ecoMode 0 setPlaceMode -reset setPlaceMode -congEffort medium -timingDriven 1 -modulePlan 1 -doCongOpt 0 - clkGateAware 0 -powerDriven 0 -ignoreScan 1 -reorderScan 1 -ignoreSpare 1 -placeIOPins 0 -moduleAwareSpare 0 -checkPinLayerForAccess { 1 } -preserveRouting 0 - rmAffectedRouting 0 -checkRoute 0 -swapEEQ 0 setPlaceMode -fp false placeDesign -prePlaceOpt setDrawView place # Especificacions del rellotge setClockMeshSpecVar M:,defaultTrigger rising setClockMeshSpecVar -mesh clk_s allowGating 0 setClockMeshSpecVar -mesh clk_s -chain bottomPreferLayer {} setClockMeshSpecVar -mesh clk_s -chain driveCell {} setClockMeshSpecVar -mesh clk_s -chain enabled 0 setClockMeshSpecVar -mesh clk_s -chain ndr {} setClockMeshSpecVar -mesh clk_s -chain numLevel 0 setClockMeshSpecVar -mesh clk_s -chain preferredExtraSpace 0 setClockMeshSpecVar -mesh clk_s -chain shieldNet {} setClockMeshSpecVar -mesh clk_s -chain targetLocs {} setClockMeshSpecVar -mesh clk_s -chain topPreferLayer {} setClockMeshSpecVar -mesh clk_s defaultTrigger rising setClockMeshSpecVar -mesh clk_s drivePoint Center setClockMeshSpecVar -mesh clk_s hTreePattern {} setClockMeshSpecVar -mesh clk_s -localTree bottomPreferLayer {} setClockMeshSpecVar -mesh clk_s -localTree driveCells {} setClockMeshSpecVar -mesh clk_s -localTree enabled 0 setClockMeshSpecVar -mesh clk_s -localTree ndr {} setClockMeshSpecVar -mesh clk_s -localTree numCluster 0 setClockMeshSpecVar -mesh clk_s -localTree preferredExtraSpace 0 setClockMeshSpecVar -mesh clk_s -localTree rootPos ClusterCenter setClockMeshSpecVar -mesh clk_s -localTree shieldNet {} setClockMeshSpecVar -mesh clk_s -localTree topPreferLayer {} setClockMeshSpecVar -mesh clk_s maxBufferTrans 200 setClockMeshSpecVar -mesh clk_s maxDelay {} setClockMeshSpecVar -mesh clk_s maxLeafTrans 250 setClockMeshSpecVar -mesh clk_s maxPower 0 setClockMeshSpecVar -mesh clk_s maxSkew 0 Disseny VHDL de la unitat de control d’un acceleròmetre 133 setClockMeshSpecVar -mesh clk_s meshModule {} setClockMeshSpecVar -mesh clk_s meshType Fishbone setClockMeshSpecVar -mesh clk_s minDelay 0 setClockMeshSpecVar -mesh clk_s numStage 0 setClockMeshSpecVar -mesh clk_s -predriveCTS bottomPreferLayer {} setClockMeshSpecVar -mesh clk_s -predriveCTS driveCells {CLKBUF_X1 CLKBUF_X2 CLKBUF_X4 CLKBUF_X8 CLKBUF_X16 CLKBUF_X20} setClockMeshSpecVar -mesh clk_s -predriveCTS enabled 1 setClockMeshSpecVar -mesh clk_s -predriveCTS ndr {} setClockMeshSpecVar -mesh clk_s -predriveCTS preferredExtraSpace 0 setClockMeshSpecVar -mesh clk_s -predriveCTS shieldNet {} setClockMeshSpecVar -mesh clk_s -predriveCTS topPreferLayer {} setClockMeshSpecVar -mesh clk_s period 5000 setClockMeshSpecVar -mesh clk_s rootPin clk_s setClockMeshSpecVar -mesh clk_s rootTrans 100 setClockMeshSpecVar -mesh clk_s routePattern Trunk setClockMeshSpecVar -mesh clk_s trunkDriveDist StrictAttach setClockMeshSpecVar -mesh clk_s trunkOrient Horizontal setClockMeshSpecVar -mesh clk_s trunkPlacement UniformPitch setClockMeshSpecVar -mesh clk_s useMeshModule 0 setClockMeshSpecVar -mesh clkTree allowGating 0 setClockMeshSpecVar -mesh clkTree -chain bottomPreferLayer {} setClockMeshSpecVar -mesh clkTree -chain driveCell {} setClockMeshSpecVar -mesh clkTree -chain enabled 0 setClockMeshSpecVar -mesh clkTree -chain ndr {} setClockMeshSpecVar -mesh clkTree -chain numLevel 0 setClockMeshSpecVar -mesh clkTree -chain preferredExtraSpace 0 setClockMeshSpecVar -mesh clkTree -chain shieldNet {} setClockMeshSpecVar -mesh clkTree -chain targetLocs {} setClockMeshSpecVar -mesh clkTree -chain topPreferLayer {} setClockMeshSpecVar -mesh clkTree defaultTrigger rising setClockMeshSpecVar -mesh clkTree drivePoint Center setClockMeshSpecVar -mesh clkTree hTreePattern {} setClockMeshSpecVar -mesh clkTree -localTree bottomPreferLayer {} setClockMeshSpecVar -mesh clkTree -localTree driveCells {} setClockMeshSpecVar -mesh clkTree -localTree enabled 0 setClockMeshSpecVar -mesh clkTree -localTree ndr {} setClockMeshSpecVar -mesh clkTree -localTree numCluster 0 setClockMeshSpecVar -mesh clkTree -localTree preferredExtraSpace 0 setClockMeshSpecVar -mesh clkTree -localTree rootPos ClusterCenter setClockMeshSpecVar -mesh clkTree -localTree shieldNet {} setClockMeshSpecVar -mesh clkTree -localTree topPreferLayer {} setClockMeshSpecVar -mesh clkTree maxBufferTrans 200 setClockMeshSpecVar -mesh clkTree maxDelay {} setClockMeshSpecVar -mesh clkTree maxLeafTrans 250 setClockMeshSpecVar -mesh clkTree maxPower 0 setClockMeshSpecVar -mesh clkTree maxSkew 0 setClockMeshSpecVar -mesh clkTree meshModule {} setClockMeshSpecVar -mesh clkTree meshType {} Disseny VHDL de la unitat de control d’un acceleròmetre 134 setClockMeshSpecVar -mesh clkTree minDelay 0 setClockMeshSpecVar -mesh clkTree numStage 0 setClockMeshSpecVar -mesh clkTree -predriveCTS bottomPreferLayer {} setClockMeshSpecVar -mesh clkTree -predriveCTS driveCells {CLKBUF_X1 CLKBUF_X2 CLKBUF_X4 CLKBUF_X8 CLKBUF_X16 CLKBUF_X20} setClockMeshSpecVar -mesh clkTree -predriveCTS enabled 0 setClockMeshSpecVar -mesh clkTree -predriveCTS ndr {} setClockMeshSpecVar -mesh clkTree -predriveCTS preferredExtraSpace 0 setClockMeshSpecVar -mesh clkTree -predriveCTS shieldNet {} setClockMeshSpecVar -mesh clkTree -predriveCTS topPreferLayer {} setClockMeshSpecVar -mesh clkTree period 5000 setClockMeshSpecVar -mesh clkTree rootPin clk setClockMeshSpecVar -mesh clkTree rootTrans 100 setClockMeshSpecVar -mesh clkTree routePattern Trunk setClockMeshSpecVar -mesh clkTree trunkDriveDist StrictAttach setClockMeshSpecVar -mesh clkTree trunkOrient {} setClockMeshSpecVar -mesh clkTree trunkPlacement UniformPitch setClockMeshSpecVar -mesh clkTree useMeshModule 0 setClockMeshSpecVar -mesh oscTree allowGating 0 setClockMeshSpecVar -mesh oscTree -chain bottomPreferLayer {} setClockMeshSpecVar -mesh oscTree -chain driveCell {} setClockMeshSpecVar -mesh oscTree -chain enabled 0 setClockMeshSpecVar -mesh oscTree -chain ndr {} setClockMeshSpecVar -mesh oscTree -chain numLevel 0 setClockMeshSpecVar -mesh oscTree -chain preferredExtraSpace 0 setClockMeshSpecVar -mesh oscTree -chain shieldNet {} setClockMeshSpecVar -mesh oscTree -chain targetLocs {} setClockMeshSpecVar -mesh oscTree -chain topPreferLayer {} setClockMeshSpecVar -mesh oscTree defaultTrigger rising setClockMeshSpecVar -mesh oscTree drivePoint Center setClockMeshSpecVar -mesh oscTree hTreePattern {} setClockMeshSpecVar -mesh oscTree -localTree bottomPreferLayer {} setClockMeshSpecVar -mesh oscTree -localTree driveCells {} setClockMeshSpecVar -mesh oscTree -localTree enabled 0 setClockMeshSpecVar -mesh oscTree -localTree ndr {} setClockMeshSpecVar -mesh oscTree -localTree numCluster 0 setClockMeshSpecVar -mesh oscTree -localTree preferredExtraSpace 0 setClockMeshSpecVar -mesh oscTree -localTree rootPos ClusterCenter setClockMeshSpecVar -mesh oscTree -localTree shieldNet {} setClockMeshSpecVar -mesh oscTree -localTree topPreferLayer {} setClockMeshSpecVar -mesh oscTree maxBufferTrans 200 setClockMeshSpecVar -mesh oscTree maxDelay {} setClockMeshSpecVar -mesh oscTree maxLeafTrans 250 setClockMeshSpecVar -mesh oscTree maxPower 0 setClockMeshSpecVar -mesh oscTree maxSkew 0 setClockMeshSpecVar -mesh oscTree meshModule {} setClockMeshSpecVar -mesh oscTree meshType {} setClockMeshSpecVar -mesh oscTree minDelay 0 setClockMeshSpecVar -mesh oscTree numStage 0 Disseny VHDL de la unitat de control d’un acceleròmetre 135 setClockMeshSpecVar -mesh oscTree -predriveCTS bottomPreferLayer {} setClockMeshSpecVar -mesh oscTree -predriveCTS driveCells {CLKBUF_X1 CLKBUF_X2 CLKBUF_X4 CLKBUF_X8 CLKBUF_X16 CLKBUF_X20} setClockMeshSpecVar -mesh oscTree -predriveCTS enabled 1 setClockMeshSpecVar -mesh oscTree -predriveCTS ndr {} setClockMeshSpecVar -mesh oscTree -predriveCTS preferredExtraSpace 0 setClockMeshSpecVar -mesh oscTree -predriveCTS shieldNet {} setClockMeshSpecVar -mesh oscTree -predriveCTS topPreferLayer {} setClockMeshSpecVar -mesh oscTree period 5000 setClockMeshSpecVar -mesh oscTree rootPin osc_in setClockMeshSpecVar -mesh oscTree rootTrans 100 setClockMeshSpecVar -mesh oscTree routePattern Trunk setClockMeshSpecVar -mesh oscTree trunkDriveDist StrictAttach setClockMeshSpecVar -mesh oscTree trunkOrient {} setClockMeshSpecVar -mesh oscTree trunkPlacement UniformPitch setClockMeshSpecVar -mesh oscTree useMeshModule 0 setClockMeshSpecVar meshNames {clk_s clkTree oscTree} setClockMeshSpecVar -routeType clkRoute layer METAL1 setClockMeshSpecVar -routeType clkRoute spacing 0 setClockMeshSpecVar -routeType clkRoute width 0 setClockMeshSpecVar routeTypeDefNames clkRoute specifyClockMesh -tcl # Síntesis del rellotge setClockMeshSpecVar M:,defaultTrigger rising setClockMeshSpecVar -mesh clk_s routePattern Trunk setClockMeshSpecVar -mesh clkTree routePattern Trunk setClockMeshSpecVar -mesh oscTree routePattern Trunk specifyClockMesh -tcl synthesizeClockMesh -topChain -globalMesh -localTree -unfix # Enrutat de les connexions setNanoRouteMode -quiet -drouteStartIteration default setNanoRouteMode -quiet -routeTopRoutingLayer default setNanoRouteMode -quiet -routeBottomRoutingLayer default setNanoRouteMode -quiet -drouteEndIteration default setNanoRouteMode -quiet -routeWithTimingDriven false setNanoRouteMode -quiet -routeWithSiDriven false routeDesign -globalDetail sroute -connect { blockPin padPin padRing corePin floatingStripe } -layerChangeRange { METAL1 METAL_F } -blockPinTarget { nearestRingStripe nearestTarget } - padPinPortConnect { allPort oneGeom } -checkAlignedSecondaryPin 1 -blockPin useLef - allowJogging 1 -crossoverViaBottomLayer METAL1 -allowLayerChange 1 - targetViaTopLayer METAL_F -crossoverViaTopLayer METAL_F -targetViaBottomLayer METAL1 -nets { gnd! vdd! } trialRoute # Verificació i correcció verifyGeometry