Waldo Valenzuela MemoriaT Eln

Universidad de Concepcin.
Departamento de Ingeniera Elctrica.

Facultad de Ingeniera.
Profesor Patrocinante
Dr. Miguel Figueroa Toro.
SOPORTE CAD PARA PROCESAMIENTO ADAPTIVO DE
SEALES EN VLSI
Waldo Enrique Valenzuela Pinilla
Informe de Memoria de Ttulo
Para optar al Ttulo de
Ingeniero Civil Electrnico
J unio 2006
2
A mi madre, por creer en m siempre y apoyarme en todos
los proyectos que he realizado en mi vida
3
Agradecimientos
Quiero agradecer a todas las personas que de una u otra forma estuvieron dando una mano de
apoyo y una palabra de alimento siempre que lo necesitaba. A mi profesor gua por la paciencia
demostrada, apoyo y la ayuda que me brind. A mis amigos Gonzalo y Esteban con los cuales
compartimos grandes momentos juntos tanto en lo acadmico como en lo personal.
4
Resumen
El procesamiento adaptivo de seales es una disciplina que busca solucionar los problemas
presentes en seales que actan en ambientes cambiantes, a travs del filtrado adaptivo o mediante
redes neuronales (entre otras tcnicas). En algunos ambientes se necesitan respuestas rpidas, las
cuales no pueden ser obtenidas mediante la implementacin de estas tcnicas a travs de algn
software y por consiguiente resulta ms til implementar estos algoritmos en circuitos VLSI.
Para el diseo de circuitos VLSI existen distintos software CAD que permiten realizar
esquemtico y layout de cualquier tipo de circuito. stos por lo general no contemplan circuitos
prediseados para aplicaciones especficas, sino ms bien nos proveen de bibliotecas estndar que
contienen una limitada cantidad de elementos disponibles para el diseo.
La presente memoria abord este tema a travs del diseo de una biblioteca de soporte CAD,
la cual contiene elementos prediseados necesarios para la implementacin de algoritmos de redes
neuronales LMS y GHA. Para esto se realiz un anlisis de estos dos algoritmos desde el punto de
vista circuital, identificando las partes que los componen y los elementos necesarios para su
implementacin. Posteriormente se da un pequeo vistazo al transistor de compuerta flotante, el cual
se utiliza como parte fundamental dentro de las memorias que se disearon dentro de este trabajo.
Luego se realiza una descripcin general de los software utilizados en el diseo de la biblioteca
(LTSpice y ELECTRIC). En seguida se muestra en forma detallada el diseo de cada uno de los
elementos que la componen, as como tambin las funciones diseadas en Matlab las cuales
permiten realizar distintos anlisis sobre los circuitos que pueden ser creados con esta biblioteca.
Finalmente se muestra el funcionamiento de esta biblioteca y sus funciones, mediante la
implementacin y simulacin de una red neuronal de cuatro entradas.
SOPORTE CAD PARA PROCESAMIENTO ADAPTIVO DE SEALES EN VLSI.
5
ndice General
1. INTRODUCCIN. .......................................................................................................................................... 10
1.1. OBJETIVOS................................................................................................................................................ 11
1.1.1 Objetivo General.................................................................................................................................. 11
1.1.2 Objetivos Especficos. .......................................................................................................................... 11
1.2. ORGANIZACIN DEL INFORME. ................................................................................................................... 11
2. ALGORITMOS DE PROCESAMIENTO ADAPTIVO DE SEALES......................................................... 13
2.1. ALGORITMOS ............................................................................................................................................ 13
2.1.1 Mtodo LMS ........................................................................................................................................ 13
2.1.2 Anlisis de componentes principales (PCA).......................................................................................... 15
2.2. ANLISIS DE ALGORITMOS PARA SU IMPLEMENTACIN EN VLSI. .................................................................. 18
3. INTRODUCCIN AL TRANSISTOR DE COMPUERTA FLOTANTE...................................................... 20
3.1. TNEL DE ELECTRONES (ELECTRON TUNNELING) ...................................................................................... 22
3.2. INYECCIN DE ELECTRONES (ELECTRON INJECTION). ................................................................................. 23
4. HERRAMIENTAS CAD PARA DISEO VLSI ............................................................................................ 25
4.1. EL DISEO FSICO...................................................................................................................................... 25
4.2. SIMULACIONES.......................................................................................................................................... 25
4.3. ELECTRIC .............................................................................................................................................. 25
4.3.1 Creacin de Celda ............................................................................................................................... 26
4.4. LTSPICE.................................................................................................................................................... 33
5. DISEO DE CELDAS DE LA BIBLIOTECA............................................................................................... 38
5.1. DIODO CMOS. ............................................................................................................................................ 38
5.2. ESPEJO DE CORRIENTE. .............................................................................................................................. 39
5.3. PAR DIFERENCIAL. .................................................................................................................................... 40
5.4. DISEO DEL MULTIPLICADOR DE GILBERT. ................................................................................................ 42
5.4.1 Diseo Esquemtico y layout en ELECTRIC......................................................................................... 45
5.4.2 Simulacin. .......................................................................................................................................... 46
5.5. DISEO AMPLIFICADOR OPERACIONAL ...................................................................................................... 48
5.5.2 Simulacin. .......................................................................................................................................... 55
5.6. DISEO DE MEMORIA. ............................................................................................................................... 56
5.6.1 Transistor de Inyeccin. ....................................................................................................................... 56
5.6.2 Transistor de Tuneling. ........................................................................................................................ 60
5.6.3 Condensador........................................................................................................................................ 61
5.6.5 Simulacin. .......................................................................................................................................... 67
5.7. CIRCUITO DIFERENCIAL. ............................................................................................................................ 69
5.7.2 Simulacin. .......................................................................................................................................... 71
6. HERRAMIENTAS DE ANLISIS DE MONTECARLO. ............................................................................. 72
6.1. FUNCIN GENERA_STRUCT........................................................................................................................ 72
6.2. FUNCIN AGREGA_MODELOS. ................................................................................................................... 74
6.3. FUNCIN ESCRIBIR. ................................................................................................................................... 76
6.4. FUNCIN ASIGNACION_ALEATORIA. .......................................................................................................... 76
6.5. FUNCIN MODIFICA_SIZE. ......................................................................................................................... 77
6.6. FUNCIN BUSCAR. .................................................................................................................................... 79
6.7. FUNCIN AGREGAR_SUBCIRCUITOS. .......................................................................................................... 79
6.8. FUNCIN ASIGNACIN_SUBCIRCUITOS. ...................................................................................................... 81
6.9. SIMULACIN DE UN NETLIST BAJO ANLISIS DE MONTECARLO. ................................................................... 81
6
7. IMPLEMENTACIN DE ALGORITMOS DE PROCESAMIENTO ADAPTIVO DE SEALES,
UTILIZANDO BIBLIOTECA DISEADA............................................................................................................. 86
7.1. CONSTRUCCIN DEL ESQUEMTICO Y LAYOUT. .......................................................................................... 87
7.2. SIMULACIONES.......................................................................................................................................... 90
7.2.1 Simulacin de red neuronal de cuatro entradas. ................................................................................... 90
7.2.2 Simulacin sin calibracin de la memoria. ........................................................................................... 91
7.2.3 Simulacin con calibracin y anlisis de montecarlo sobre la memoria. ............................................... 93
8. CONCLUSIN................................................................................................................................................ 96
8.1. CONCLUSIONES......................................................................................................................................... 96
8.2. TRABAJOS FUTUROS .................................................................................................................................. 97
9. REFERENCIAS .............................................................................................................................................. 98
10. ANEXOS. .................................................................................................................................................... 99
10.1. ANEXO 1: REGLAS PARA CAPACITOR POLY1-POLY2..................................................................................... 99
10.2. ANEXO 2: TABLA DE IDENTIFICACIN DE ELEMENTOS DENTRO DE UN NETLIST........................................... 100
10.3. ANEXO 3: FUNCIONES PARA ANLISIS DE MONTECARLO............................................................................ 100
10.3.1 Anexo 3(a): Funcin Genera_struct. .............................................................................................. 100
10.3.2 Anexo 3(b): Funcin Agrega_modelos. .......................................................................................... 103
10.3.3 Anexo 3(c): Funcin Escribir......................................................................................................... 104
10.3.4 Anexo 3(d): Funcin asignacion_aleatoria..................................................................................... 106
10.3.5 Anexo 3(e): Funcin Modifica_size. ............................................................................................... 107
10.3.6 Anexo 3(f): Funcin Buscar. .......................................................................................................... 109
10.3.7 Anexo 3(g): Funcin Agregar_subcircuitos. ................................................................................... 111
10.3.8 Anexo 3(h): Funcin Asignacin_subcircuito. ................................................................................ 112
7
ndice de Figuras.
2.1. APLICACIN DE MTODO LMS A REDES NEURONALES ........................................................................................ 13
2.2. EVOLUCIN DEL ERROR .................................................................................................................................. 14
2.3. EVOLUCIN DE LOS PESOS DE LA NEURONA ...................................................................................................... 15
2.4. APLICACIN DE MTODO GHA EN REDES NEURONALES ...................................................................................... 16
2.5. EVOLUCIN DE LOS PESOS DE LAS COMPONENTES 1 Y 2 ...................................................................................... 17
2.6. EVOLUCIN DE LOS PESOS DE LAS COMPONENTES 3 Y 4 ...................................................................................... 17
2.7. ESTRUCTURA DE DISTRIBUCIN EN REDES NEURONALES. .................................................................................... 18
3.1. VISTA FSICA DE UN TRANSISTOR DE COMPUERTA FLOTANTE ............................................................................... 21
3.2. VISTA LATERAL DEL TRANSISTOR DE COMPUERTA FLOTANTE................................................................................ 21
3.3. TRANSICIN DE LA BANDA DE ENERGA EN LA CAPA DE OXIDO (SIO
2
). ................................................................. 22
3.4. DIAGRAMA DE BANDA DEL ELECTRN [10] ........................................................................................................ 23
4.1. VENTANA DE INICIO DE ELECTRIC..................................................................................................................... 26
4.2. VENTANA DE MANIPULACIN Y CREACIN DE CELDAS ......................................................................................... 27
4. 3. VENTANA DE CREACIN DE INSTANCIAS............................................................................................................. 28
4.4. VENTANA DE CREACIN DE EXPORT. ................................................................................................................. 29
4.5. VENTANA DE ERRORES EN LVS ......................................................................................................................... 30
4.6. DISEO DE UN NOT EN SU PARTE ESQUEMTICA Y FSICA..................................................................................... 30
4.7. CONFIGURACIN EXTRACCIN SPICE. .............................................................................................................. 31
4.8. CIRCUITO LISTO PARA SIMULACIN SPICE.......................................................................................................... 32
4.9. PROGRAMA LTSPICE....................................................................................................................................... 33
4.10. PROGRAMA LTSIPCE OPCIONES DE VISUALIZACIN............................................................................................ 34
4.11. MEN DE VISUALIZACIN. ............................................................................................................................... 35
4.12. VISUALIZACIN DE FORMAS DE ONDA................................................................................................................ 36
4.13. ACTIVACIN DE CURSORES............................................................................................................................... 36
4.14. MEDICIN UTILIZANDO CURSORES.................................................................................................................... 37
5.1. DIODOS TIPO CMOS....................................................................................................................................... 38
5.2. ESPEJOS DE CORRIENTE TIPO CMOS................................................................................................................ 39
5.3. ESPEJO DE CORRIENTE NMOS ........................................................................................................................... 39
5.4. PAR DIFERENCIAL PMOS .................................................................................................................................. 40
5.5. CURVA PAR DIFERENCIAL ................................................................................................................................ 42
5.6. VERSIN CMOS DEL MULTIPLICADOR DE GILBERT ............................................................................................ 43
5.7. CURVA DE TRANSFERENCIA DC DEL MULTIPLICADOR DE GILBERT [8] ................................................................. 44
5.8. ESQUEMTICO DEL MULTIPLICADOR DE GILBERT............................................................................................... 45
5.9. LAYOUT DEL MULTIPLICADOR DE GILBERT ........................................................................................................ 46
5.10. SIMULACIN DEL ESQUEMTICO DEL MULTIPLICADOR DE GILBERT ..................................................................... 46
5.11. SIMULACIN LAYOUT DEL MULTIPLICADOR DE GILBERT..................................................................................... 47
5.12. ZOOM A LA CURVA DE TRANSFERENCIA DEL MULTIPLICADOR............................................................................... 47
5.13. AMPLIFICADOR OPERACIONAL BSICO .............................................................................................................. 48
5.14. CURVAS CARACTERSTICAS DEL AMPLIFICADOR IDEAL......................................................................................... 48
5.15. MODELO EN PEQUEA SEAL DE LA RESISTENCIA ACTIVA.................................................................................... 49
5.16. FUENTES DE CORRIENTES TIPO CMOS.............................................................................................................. 50
5.17. CURVAS CARACTERSTICAS DE UNA FUENTE DE CORRIENTE TIPO CMOS............................................................... 50
5.18. CURVA CARACTERSTICA ESPEJO DE CORRIENTE................................................................................................. 51
5.19. ESQUEMA DE UN AMPLIFICADOR DIFERENCIAL .................................................................................................. 51
5.20. AMPLIFICADOR OTA MILLER. .......................................................................................................................... 52
5.21. ESQUEMTICO DEL AMPLIFICADOR OTA MILLER .............................................................................................. 53
5.22. LAYOUT DEL AMPLIFICADOR OTA MILLER ....................................................................................................... 54
5.23. CURVA DEL AMPLIFICADOR OTA MILLER, ESQUEMTICO. ................................................................................. 55
5.24. CURVA DEL AMPLIFICADOR OTA MILLER, LAYOUT. ........................................................................................... 55
5.25. CELDA DE MEMORIA....................................................................................................................................... 56
5.26. FUENTES DE CORRIENTE TRANSISTOR DE INYECCIN .......................................................................................... 58
5.27. CELDA DE INYECCIN, ESQUEMTICO .............................................................................................................. 58
8
5.28. CELDA DE INYECCIN, LAYOUT......................................................................................................................... 59
5.29. PROPIEDADES DEL TRANSISTOR........................................................................................................................ 59
5.30. FUENTE DE CORRIENTE SPICE, CSTUN........................................................................................................... 60
5.31. TRANSISTOR DE TUNNELING ............................................................................................................................. 61
5.32. LAYOUT DE CAPACITOR DE 100[FF]................................................................................................................. 62
5.33. CELDA DE MEMORIA CON CIRCUITOS DE CALIBRACIN ....................................................................................... 63
5.34. GRFICOS DE CALIBRACIN DE CELDAS DE MEMORIA.......................................................................................... 64
5.35. ESQUEMTICO, CELDA DE MEMORIA CON CIRCUITOS DE CALIBRACIN. ............................................................... 65
5.36. SUB-CIRCUITO DE COMPUERTA FLOTANTE........................................................................................................ 65
5.37. LAYOUT, CELDA DE MEMORIA CON CIRCUITOS DE CALIBRACIN........................................................................... 66
5.38. ESQUEMTICO, SIMULACIN CELDA DE MEMORIA CON CIRCUITOS DE CALIBRACIN.............................................. 67
5.39. LAYOUT, SIMULACIN CELDA DE MEMORIA CON CIRCUITOS DE CALIBRACIN........................................................ 67
5.40. CIRCUITO DIFERENCIAL. ................................................................................................................................. 69
5.41. CIRCUITO DIFERENCIAL, ESQUEMTICO. ........................................................................................................... 70
5.42. CIRCUITO DIFERENCIAL, LAYOUT. ..................................................................................................................... 70
5.43. SIMULACIN CIRCUITO DIFERENCIAL, ESQUEMTICO.......................................................................................... 71
5.44. SIMULACIN CIRCUITO DIFERENCIAL, LAYOUT. .................................................................................................. 71
6.1. ESTRUCTURAS PARA LA FUNCIN GENERA_STRUCT .............................................................................................. 74
6.2. DISTRIBUCIN DE LA ESTRUCTURA MODELOS_CAMBIAR..................................................................................... 75
6.3. DISTRIBUCIN DE LA ESTRUCTURA TIPOS, FUNCIN MODIFICA_SIZE. .................................................................. 78
6.4. DISTRIBUCIN DE LA ESTRUCTURA TIPOS, FUNCIN AGREGA_SUBCIRCUITOS. ...................................................... 80
6.5. ESQUEMTICO DE NOTS PARA ANLISIS DE MONTECARLO................................................................................... 82
6.6. ANLISIS DC DE NOTS SIN MODIFICACIONES .................................................................................................... 83
6.7. ANLISIS DC DE NOTS CON MODIFICACIONES................................................................................................... 85
7.1. NEURONA DE CUATRO ENTRADAS ACTUALIZADA CON TREN DE PULSOS. ............................................................... 86
7.2. SINAPSIS DE LA PRIMERA ENTRADA, ESQUEMTICO ............................................................................................. 87
7.3. SINAPSIS DE LA PRIMERA ENTRADA, LAYOUT....................................................................................................... 88
7.4. LAYOUT RED NEURONAL DE CUATRO ENTRADAS ................................................................................................. 89
7. 5. SIMULACIN RED NEURONAL DE CUATRO ENTRADAS, ESQUEMTICO. ................................................................... 90
7.6. SIMULACIN RED NEURONAL DE CUATRO ENTRADAS, LAYOUT. ............................................................................. 90
7.7. SIMULACIN ESQUEMTICO MEMORIA Y DIFERENCIAL. ....................................................................................... 91
7.8. SIMULACIN LAYOUT MEMORIA Y DIFERENCIAL. ................................................................................................. 91
7.9. SIMULACIN MEMORIA Y DIFERENCIAL. ............................................................................................................. 92
7.10. SIMULACIN MEMORIA Y DIFERENCIAL CON CAMBIOS DE TAMAOS, SIN CALIBRACIN............................................ 93
7.11. SIMULACIN MEMORIA Y DIFERENCIAL CON CAMBIOS DE TAMAOS, CON CALIBRACIN. ......................................... 94
7.12. EVOLUCIN DE CADA UNA DE LAS COMPUERTAS FLOTANTES DEL CIRCUITO.......................................................... 94
9
ndice de Tablas.
2.1. ECUACIONES PRINCIPALES LMS Y GHA. ............................................................................................................... 18
2.2. ELEMENTOS NECESARIOS PARA LMS Y GHA........................................................................................................... 19
5.1. RESULTADOS DE LAS SIMULACIONES DE ESQUEMTICO Y LAYOUT. ............................................................................ 68
6.1. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN GENERA_STRUCT....................................................................... 73
6.2. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN AGREGA_MODELOS ................................................................... 75
6.3. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN ESCRIBIR.................................................................................. 76
6.4. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN ASIGNACIN_ALETORIA. ............................................................ 77
6.5. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN MODIFICA_SIZE. ....................................................................... 78
6.6. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN AGREGA_SUBCIRCUITOS. ........................................................... 80
6.7. DESCRIPCIN DE LOS PARMETROS DE LA FUNCIN ASIGNACION_SUBCIRCUITOS...................................................... 81
7.1. RESULTADOS DE LAS SIMULACIONES MEMORIA Y DIFERENCIAL. ................................................................................ 93
7.2. RESULTADOS DE LAS SIMULACIONES MEMORIA Y DIFERENCIAL DESPUS DE LA CALIBRACIN. ..................................... 95
10
CAPITULO I.
1. INTRODUCCIN.
La fabricacin de circuitos integrados a gran escala (VLSI) basados en transistores comenz
a mediados de los aos 80, producto del avance de las tecnologas de semiconductores. Esto
permiti a los desarrolladores implementar en espacios cada vez ms reducidos una mayor cantidad
de transistores, lo que con el pasar de los aos llev al diseo de ordenadores porttiles para el uso
de la gente comn que hasta esa fecha era casi imposible. Junto con esto, cada vez ms
universidades se fueron sumando a la enseanza e investigacin de esta tecnologa, proveyendo a
sus alumnos tanto de los conocimientos como de las herramientas necesarias para el diseo de
circuitos integrados.
En la actualidad, los grandes fabricantes de circuitos integrados como Intel, Texas
Instruments, Samsung, ATI Technologies, Advanced Micro Devices (AMD), IBM, NEC, Toshiba,
entre otras, utilizan distintos software CAD para el diseo de circuitos. stos consideran reglas de
diseo segn el proceso de fabricacin que utilice la compaa, pero estas reglas no pueden ser
divulgadas, por estar protegidas por acuerdos de confidencialidad. Esto trae consigo un problema en
la enseanza del diseo de circuitos, dado que para llevar a cabo una buena implementacin de un
algoritmo en un chip es necesario conocer las reglas de diseo. Es por esto que para suplir esta
falencia se crearon las reglas escalables, en la cual existe una medida nica que se escala segn el
proceso de fabricacin. Si bien este no representa en un 100% las reglas de cada fabricante, nos
permite una aproximacin bastante real del proceso de fabricacin.
Otro de los grandes problemas que surgi fue la fabricacin de pequeas cantidades de chips.
En este caso, dado que las grandes empresas fabrican slo a gran escala, para las pequeas empresas
o institutos resultaba casi imposible mandar a fabricar. Es por esto que a partir de 1981 surge
MOSIS, empresa que sirve de intermediario entre las grandes industrias de fabricacin de chips y las
pequeas firmas comerciales, agencias gubernamentales, universidades e institutos de investigacin
a travs del mundo. Esta empresa es la encargada de reunir todos los diseos en un solo Wafer
(plantilla donde van alojados todos los chips diseados) y mandarlo a fabricar a las distintas
empresas. De esta forma se logra poner mas a la mano la fabricacin de chips, permitiendo que los
diseos creados por las mentes de estudiantes o investigadores se conviertan en realidad.
Gracias a todo este proceso de investigacin y desarrollo en VLSI se ha logrado que hoy en
da sea ms comn el diseo de dispositivos menor tamao y porttiles, como son los telfonos
celulares y PDA. Sin embargo, dada la gran cantidad de seales y ruido presente en el ambiente que
nos rodea hace necesario que tcnicas de procesamiento adaptivo de seales como: filtros adoptivos
o redes neuronales (tcnicas que se especializan en solucionar problemas de seales presentes en
ambientes cambiantes o con ruido) se encuentren implementadas fsicamente dentro de estos
dispositivos. Si bien al ser implementadas mediante software seria econmicamente mas barato, en
trminos de respuesta seria bastante mayor, provocndose una disminucin en el rendimiento del
aparato.
Si bien los fabricantes de circuitos integrados utilizan software CAD diseados
especialmente para la empresa y cuentan con bibliotecas segn el tipo de circuito o algoritmo que se
desee implementar (como los antes mencionados), existen distintas alternativas comerciales de
distintos precios y programas libres.
Generalmente, este tipo de programas slo provee bibliotecas con componentes estndar para
el diseo y algunos circuitos ms complejos de uso general, pero no circuitos pre-diseados que
11
faciliten la implementacin de grandes algoritmos de procesamiento adaptivo. La falencia de este
tipo de bibliotecas trae como consecuencia perdida de tiempo en el diseo de circuitos de uso
general para este tipo de algoritmos tales como: multiplicadores, memorias, sumadores, etc.
desviando la atencin del diseador del problema real que desea solucionar.
Tomando en consideracin lo anterior, vemos que surge la necesidad de contar con
bibliotecas especializadas que contengan los componentes necesarios para la implementacin de
algoritmos de procesamiento adaptivo de seales, dado que el simple hecho de disear una y otra
vez los distintos sub-circuitos de uso general dentro de un proyecto genera prdidas de tiempo y
desva la atencin del diseador del problema general por un especifico, el cual se podra solucionar
de manera fcil si el software CAD contara con este tipo de bibliotecas.
1.1. OBJETIVOS
1.1.1 Objetivo General
El objetivo principal de la presente memoria es hacer una biblioteca de soporte CAD
utilizado el software ELECTRIC para el diseo e implementacin de algoritmos de procesamientos
adaptivos de seales en VLSI y adems proveer una gama de funciones que permitan probar el
funcionamiento de dichos algoritmos sometidos a distintas variaciones.
1.1.2 Objetivos Especficos.
Estudio de elementos necesarios para la implementacin de algoritmo como LMS y
GHA.
Descripcin de los programas utilizados para el diseo de la biblioteca y simulacin de
los distintos circuitos.
Desarrollo de los distintos elementos que componen la biblioteca.
Desarrollo de funciones en Matlab para la variacin y modificacin del netlist obtenidos
de los circuitos diseados.
Disear y simular utilizando la biblioteca y funciones creadas.
1.2. ORGANIZACIN DEL INFORME.
Este informe est estructurado de la siguiente manera:
El Captulo 2 analiza los algoritmos de procesamiento adaptivo LMS y GHA desde el
punto de vista de la cantidad y tipo de elementos que son necesarios para su
implementacin en VLSI.
El Captulo 3 presenta una breve descripcin del transistor de compuerta flotante, el cual
es un elemento fundamental dentro de las memorias que se disearn en esta biblioteca.
El Captulo 4 describe el uso y funcionamiento de los dos software utilizados,
ELECTRIC y LTSpice Switcher CAD
TM
III.
El Captulo 5 describe en forma detallada el diseo y funcionamiento de cada uno de los
elementos que componen esta biblioteca.
El Captulo 6 describe el funcionamiento de cada una de las funciones creadas en Matlab
y que se utilizaran para el manejo del archivo netlist.
12
El Captulo 7 describe la implementacin y simulacin de una red neuronal de cuatro
entradas utilizando la biblioteca diseada.
13
CAPITULO II
2. ALGORITMOS DE PROCESAMIENTO ADAPTIVO DE SEALES.
Hoy existen una gran cantidad de algoritmos para el procesamiento adaptivo de seales, de
los cuales hemos escogidos dos que representan dos lneas de investigacin dentro del rea de redes
neuronales, LMS y GHA.
Estos algoritmos clasifican las redes neuronales en dos tipos (segn la forma de actualizacin
de los pesos): las supervisadas, que utilizan una referencia durante el periodo de aprendizaje, y las
no supervisadas que no la necesitan.
A continuacin se presentara una breve descripcin de estos dos algoritmos.
2.1. ALGORITMOS
2.1.1 Mtodo LMS
La Red Neuronal de la figura 2.1 LMS (Least Mean Squared) o regla del mnimo cuadrado
(tambin se conoce como regla delta o de Widrow-Hoff), trata de minimizar un delta o diferencia
entre el valor observado y el deseado en la salida de la red [1].
La regla aprendizaje de los mnimos cuadrados es un mtodo a travs del cual se buscar el
valor deseado de los pesos W (figura 2.1) mediante la adaptacin de los pesos a medida que se vayan
presentando los patrones de entrenamiento y salidas deseadas para cada uno de ellos; cada
presentacin del set de patrones a la entrada a la red la llamaremos iteracin.
Para cada combinacin entrada-salida se realiza un proceso automtico de pequeos ajustes
en los valores de los pesos hasta que se obtienen las salidas correctas.
Figura N 2.1. Aplicacin de Mtodo LMS a redes neuronales
14
La regla de aprendizaje LMS minimiza el error cuadrado medio obtenido entre la salida
deseada para una entrada determinada y la salida que realmente se esta obteniendo en ese momento
producto de dicha entrada [5].
La mayora de las redes neuronales consta de una etapa de mapeo dada por la ecuacin 1.1.
Aqu la salida de la red es la resultante de las ponderaciones hechas por cada una de las entradas.

n
k
kj j
T
k k
x w W X Y
0
( 1.1 )
Durante el perodo de aprendizaje se lleva a cabo la modificacin del valor de los pesos a
travs de la minimizacin del error entre la salida y la entrada deseada. Cada delta de actualizacin
esta dado por la ecuacin 1.2.
( ) ( ) ( )
k k d k k k k i
X Y Y X E X E w ( 1.2 )
De aqu podemos ver que el valor del peso en la siguiente iteracin esta dado por la ecuacin
1.3.
( ) ( )
k k i i
X E t w t w + + 1 ( 1.3 )
siendo la constante de proporcionalidad o tasa de aprendizaje.
Esta expresin representa la modificacin de pesos obtenida al aplicar el algoritmo LMS. La
tasa es el parmetro que determina la estabilidad y la velocidad de convergencia del algoritmo.
Para graficar de manera ms clara la funcionalidad de este algoritmo lo aplicamos a una
pequea red de neuronal de cuatro entradas. Los resultados obtenidos fueron los siguientes:
Figura N 2.2. Evolucin del Error
15
Figura N 2.3. Evolucin de los Pesos de la Neurona
La figura 2.2 muestra la evolucin del error a medida que se presenta el set completo de
entradas a la neurona. El error entre la salida deseada y la salida de la neurona va disminuyendo
hasta llegar aproximadamente a cero. La figura 2.3 confirma lo anterior, aqu vemos tanto la
evolucin de los pesos como el valor que deberan llegar a tener. De esta forma, a medida que
aumentamos las muestras del set completo de entradas a la red los pesos van convergiendo al valor
deseado.
2.1.2 Anlisis de componentes principales (PCA)
El anlisis de componentes principales o conocido por su sigla en ingles PCA, es una tcnica
estadstica que nos permite reducir un conjunto de datos multidimensional a una dimensin menor.
Esto se logra encontrando las direcciones de los vectores que maximizan la varianza.
Esta tcnica es utilizada principalmente en compresin, extraccin de caractersticas y
visualizacin de datos de elevada dimensionalidad, siendo aplicadas en campos tales como
reconocimiento de patrones y compresin de imgenes.
Existe una gran cantidad de algoritmos de PCA para redes neuronales, clasificados en dos
grupos: algoritmos de reestimacin (solo con conexiones hacia delante y sus pesos actualizados de
una manera Hebbiana) y algoritmos de decorrelacion (estos poseen conexiones en ambos sentidos).
Para el desarrollo de nuestra biblioteca nos centraremos en el Algoritmo Hebbiano Generalizado
(GHA) el cual est enmarcado dentro del grupo de los algoritmos de reestimacin.
16
Figura N 2.4. Aplicacin de mtodo GHA en redes neuronales
En la etapa de mapeo de este tipo de red es igual a la mostrada en la figura 2.1, la diferencia
estriba en el clculo de los pesos, figura 2.4
Este algoritmo utiliza la regla de hebb [5] para el entrenamiento de las redes neuronales no
supervisadas. Sus ecuaciones principales son:

n
i
i i
X W Y
1
( 1.4 )
( ) ( ) ( ) ( )

1
1
j
i
i i
T
k W k y k x k x ( 1.5 )
( ) ( ) ( ) ( ) ( ) ( ) , k W k y k X k y k W k W
i
i
i i
+ + 1 ( 1.6 )
En las figuras 2.5 y 2.6 se muestran la evolucin de los pesos de cuatro componentes
principales stos fueron obtenidos al aplicar el algoritmo GHA a una red neuronal de cuatro
entradas y cuatro salidas.
La convergencia de los pesos de las distintas componentes estn relacionadas entre si a
travs de la ecuacin 1.5. Debido a lo anterior, la convergencia de los pesos de la componente 2
depende de la convergencia de los pesos de la componente 1 y as sucesivamente. Lo anterior lo
podemos verificar en la figuras 2.5 y 2.6, donde cada lnea del eje x representa 1200 iteraciones.
17
Figura N 2.5. Evolucin de los pesos de las componentes 1 y 2
Figura N 2.6. Evolucin de los pesos de las componentes 3 y 4
18
2.2. ANLISIS DE ALGORITMOS PARA SU IMPLEMENTACIN EN VLSI.
Figura N 2.7. Estructura de distribucin en redes neuronales.
Tabla 2.1. Ecuaciones Principales LMS y GHA.
Estructura LMS GHA
Mapeo

n
i
i i
X W Y
1

n
i
i i
X W Y
1
Aprendizaje
( )
k d k
Y Y E
( ) ( ) ( ) ( )

1
1
j
i
i i
T
k W k y k x k x
( ) ( )
k k i i
X E t w t w + + 1
( ) ( ) ( ) ( ) ( ) ( ) , k W k y k X k y k W k W
i
i
i i
+ + 1
En esta seccin haremos un pequeo anlisis de los algoritmos antes vistos desde el punto de
vista de su implementacin circuital, tomando en consideracin el tipo de elementos necesarios que
se requieren para su diseo.
Los dos algoritmos antes mencionados los podemos dividir en dos secciones principales:
Mapeo o Forward Path, donde se realiza el mapeo de entrada-salida a travs de los pesos sinpticos
de la red y el Aprendizaje o Feedback Path, donde se realiza la actualizacin de los pesos mediante
las dos tcnicas de actualizacin ya mencionadas. De esta forma podemos agrupar estas redes en dos
secciones (figura 2.7).
Una vez conocido las distintas secciones que conforman una red neuronal (mapeo y
aprendizaje), debemos identificar cada una de ellas. De esta forma podremos ver de manera mas
clara la cantidad de elementos (multiplicadores, sumadores, etc.) necesarios para el diseo e
implementacin de una red neuronal.
La tabla 2.1 clasifica cada una de las ecuaciones de los dos algoritmos antes vistos, de
manera de identificar las secciones de mapeo y aprendizaje.
19
Tabla 2.2. Elementos necesarios para LMS y GHA.
Elementos LMS GHA
Multiplicadores n 2n
Memorias n /por neurona n
n: cantidad de entradas de la red.
Como podemos apreciar en la tabla 2.1, se necesitan solo memoria y multiplicadores para la
implementacin de cada uno de estos algoritmos. En el caso de los sumadores, al trabajar en VLSI
anlogo, la suma se realiza utilizando la ley de corriente de Kirchhoff, donde la corriente de salida
de un nodo es la suma resultante de las corrientes de entradas a l. La tabla 2.2 muestra la cantidad
de elementos necesarios para el diseo de las distintas redes segn el tipo de algoritmo de
actualizacin.
En resumen:
La cantidad de multiplicadores necesarios por red depende tanto de la cantidad de
entradas a la red como del numero de neuronas del sistema.
En el caso de las memorias, estas solo dependen de la cantidad de entradas a la red.
20
CAPITULO III
3. INTRODUCCIN AL TRANSISTOR DE COMPUERTA FLOTANTE.
El objetivo principal de esta biblioteca es implementar los algoritmos de aprendizaje de
maquina en circuitos anlogos; dada la precisin que se logra con este tipo de tecnologa es
necesario contar con una memoria que almacene los valores anlogos resultantes de los clculos
realizados por estos algoritmos. De aqu la importancia del transistor de compuerta flotante utilizado
para disear esta memoria.
La caracterstica principal de este tipo de transistor es la capacidad de mantener en el tiempo
un valor determinado de voltaje en el GATE sin necesidad de estar energizado.
Esto se logra aislando el GATE del transistor (poly1) y colocando un segundo poly (poly2)
para formar un condensador [2] (figura 3.1). Producto del aislamiento del poly1 los electrones
almacenados en l no se pierden, logrando mantener un valor fijo de voltaje. Modificando la
cantidad de electrones en el poly1 podemos aumentar o disminuir el voltaje en el GATE del
transistor [6] [10].
Est es el principio bsico del funcionamiento de un transistor de compuerta flotante. En la
actualidad algunos circuitos digitales como las memorias EPROM utilizan este tipo de tecnologa.
Existen distintas tcnicas para extraer o ingresar electrones a la compuerta flotante. En el caso de las
EPROM, se programan mediante impulsos elctricos y su contenido se borra exponindolas a la luz
ultravioleta (de ah la ventanita que suelen incorporar este tipo de circuitos), de manera tal que estos
rayos atraen los elementos fotosensibles modificando su estado. Cada transistor dentro de la
memoria tiene una compuerta flotante de SiO
2
(sin conexin elctrica) que en estado normal se
encuentra apagado y almacena un 1 lgico. Durante la programacin, al aplicar una tensin (10 a
25V) la regin de la compuerta queda cargada elctricamente, haciendo que el transistor se
encienda, almacenando de esta forma un 0 lgico. Este dato queda almacenado de forma
permanente, sin necesidad de mantener la tensin en la compuerta ya que la carga elctrica puede
permanecer por un perodo aproximado de 10 aos.
En el caso de la memoria a implementar en la biblioteca, sta ocupa dos mtodos distintos a
los antes mencionados para realizar la inyeccin y extraccin de electrones dentro del GATE, estos
son:
Tnel de Electrones (Electrn Tunneling).
Inyeccin de Electrones (Electrn Injection).
Una de las ventajas de estos mtodos con respecto al anterior radica en la cantidad de
electrones que se extraen o inyectan en la compuerta flotante. De esta forma podemos almacenar
valores intermedios al 1 o 0 lgico, lo cual es fundamental dentro de una memoria anloga.
Al implementar este tipo de transistor en el diseo de algoritmos de aprendizaje de mquina,
se logran las siguientes ventajas [2]:
Almacenamiento no voltil de los pesos anlogos.
Actualizacin bidireccional de los pesos.
Escritura y lectura simultanea de memoria.
21
Figura N 3.1. Vista Fsica de un transistor de compuerta flotante
Figura N 3.2. Vista lateral del transistor de compuerta flotante
22
3.1. TNEL DE ELECTRONES (ELECTRON TUNNELING)
Como muestra la figura 3.1, el transistor de compuerta flotante esta compuesto por dos
transistores pmos, uno de ellos se encuentra cortocircuitado formando un condensador en el cual
ocurre el fenmeno de tnel de electrones. Este fenmeno se logra debido a que el transistor
utilizado para el condensador consta con una capa de oxido entre el canal y el poly1 mas delgada
que en un transistor normal. De esta manera facilita el traspaso de electrones a travs del oxido,
como muestra la figura 3.2.
El fenmeno de tnel de electrones, se produce en la capas de SiO
2
muy delgadas que estn
expuestas a cambios de voltaje, corriente o temperatura, en el anlisis de Fowler-Nordheim
Tunneling (FNT) [7] [12] explica en forma mas detallada este fenmeno.
Los electrones que conforman el SiO
2
cambian sus caractersticas al estar expuestos a
variaciones de voltaje. En el caso del transistor, esto se lleva a cabo al cambiar el valor del voltaje
(V
tun
) en el condensador formado por el transistor pmos (el pmos cortocircuitado en figura 3.2).
Debido a esta variacin de voltaje, se provoca una ruptura en el campo magntico de la capa de
SiO
2
, lo que provoca un cambio en las bandas de energa (figura 3.3) facilitando el paso de
electrones a travs de l. Esta diferencia potencial formada entre el n-well del transistor y poly1
hace que se reduzca el grueso del oxido (SiO
2
) facilitando que el electrn se desplace hacia el n-well
formando un tnel de electrones entre estas dos partes. De esta forma logramos sacar electrones del
condensador, como lo muestra la figura 3.2.
Al formarse el tnel debido al fenmeno de fowler-nordheim tunneling se genera una
corriente a travs del pmos cortocircuitado, la cual depende del voltaje a travs del oxido del GATE
en el pmos al n-well, as como del tamao del transistor (ancho W y largo L). La magnitud de la
corriente que circula a travs de la capa de SiO
2
esta gobernada por la ecuacin 3.1 [6]:
,
_

ox
f
tun tun
V
V
L W I I exp
0
( 3.1 )
Donde
0 tun
I es una corriente pre-exponencial inicial,
ox
V es el Voltaje a travs del oxido, y
f
V es una constante que varia con el ancho del oxido. W y L son el ancho y el largo del tnel en el
pmos (en micrones) respectivamente.
Figura N 3.3. Transicin de la Banda de Energa en la capa de oxido (SiO
2
).
23
3.2. INYECCIN DE ELECTRONES (ELECTRON INJECTION).
El fenmeno de inyeccin de electrones o como su sigla en ingles IHEI (impact-ionized hot-
electron injection [2] [6]) lo utilizamos para aumentar el nmero de electrones en el poly1 y de esta
forma logramos que el voltaje en el GATE disminuya, este fenmeno ocurren el pmos que no esta
cortocircuitado (transistor del lado izquierdo en la figura N 3.2).
Segn lo demostrado en el diagrama de Banda-Energa de figura N 3.4 [2], los huecos del
canal formado entre el DRAIN-SOURCE son acelerados en la regin de agotamiento (Depletion)
del transistor chocando contra el enrejado del semi-conductor. Cuando el campo elctrico formado
en el canal es grande una parte de los hueco que chocan contra el enrejado generan un par de
electrn-hueco adicional, estos electrones ionizados y llevados a la banda de conduccin por la
colisin son expelidos del canal por el campo elctrico producido cuando el voltaje supera los 3.1
[eV] debido a su energa cintica. Si el electrn es expelido hacia el xido de la puerta y superar la
diferencia 3.1 [eV] que separa las bandas de conduccin entre el Si y el SiO
2
este es inyectado en el
SiO
2
, el cual una vez all es recogido por el GATE [2].
Los electrones que son inyectados en el GATE generan una corriente hacia el canal formado
entre el SOURCE-DRAIN, pero en la literatura no existe un modelo simple que explique el
fenmeno de inyeccin de electrones (IHEI), es por esto que se utilizara el modelo [2] el cual
describe este fenmeno en trminos de voltaje, esta es una ecuacin semi-emprica:
( )

,
_
+
+

sd
gd
s inj
V
V
I I
2
exp ( 3.2 )
Donde I
s
es la corriente en el SOURCE, V
gd
es el voltaje entre el GATE-DRAIN en el
pFETs, y V
sd
es el voltaje entre el SOURCE y el DRAIN. u, , y o son parmetros ajustables. El
parmetro = 1 que incluimos en la ecuacin (3.2) para la consistencia de las unidades.
Figura N 3.4. Diagrama de banda del electrn [10]
24
El par adicional de electrn-hueco generado por la ionizacin por impacto en el canal a
travs del DRAIN en la regin de empobrecimiento son recogidos por el terminal del well/source y
por el DRAIN del pFET, respectivamente, generando una corriente adicional a travs del WELL,
para incluir esta corriente dentro del modelo se uso una expresin semi-emprica basada en modelos
PMOS de corriente en el sustrato [2]:
( )
,
_
+
+
t sg sd
t sg sd s b
V V V
V V V I I

exp
( 3.3 )
Donde I
b
y I
s
son las corrientes en el WELL y el SOURCE, y V
sd
y V
sg
son los voltajes entre
el SOURCE-DRAIN y SOURCE-GATE, respectivamente. q, , k y son parmetros ajustables.
25
CAPITULO IV
4. HERRAMIENTAS CAD PARA DISEO VLSI
Para realizar una biblioteca que nos permita poder implementar de manera correcta y
coherente todo tipo de algoritmos, primero que todo, es necesario tener plena seguridad que el
software CAD que se utilice para disear los circuitos implementen fielmente las reglas de diseo, y
adems las simulaciones asociadas a los distintos circuitos sean coherentes con el modelo diseado.
Los software escogidos para la realizacin de esta biblioteca son: ELECTRIC, el cual nos
permite realizar el diseo esquemtico y fsico de cualquier tipo de circuito y LTSpice, programa
encargado de simular el netlist extrado de ELECTRIC ya que este no cuenta con esta caracterstica.
4.1. EL DISEO FSICO
El diseo de un circuito en VLSI consiste en dos pasos fundamentales una vez fijado el
algoritmo que deseamos implementar: el diseo del esquemtico del circuito y posteriormente el
diseo del layout el cual es el que finalmente se enva para su fabricacin.
Existen distintas empresas dedicadas a la fabricacin de chips, as como distintas reglas
asociadas a los distintos procesos de fabricacin, es por esto, que para evitar rehacer las reglas por
cada proceso de fabricacin, se utilizaran procesos con reglas escalables donde solo existe una nica
unidad de medida. Esta unidad la llamaron LAMBDA (), la cual permite escalar las distinta reglas,
el valor de LAMBDA corresponde a la mitad del ancho mnimo del canal, dependiendo de proceso
de fabricacin con el que se este trabajando. En nuestro caso, trabajaremos con las reglas MOSIS
TSMC 0.35m [3] y el valor de LAMBDA es 0.2 [m].
Es por lo anterior que para un buen diseo fsico el software CAD que se utilice debe
manejar correctamente las reglas y el valor de LAMBDA de esta manera evitaremos sorpresas
despus de la fabricacin generadas por alguna regla no considerada o por haber considerado otro
valor de LAMBDA (estas dos razones pueden implicar que dentro de la pastilla se genere un corto
circuito no deseado entre dos elementos al haber roto o no considerado una regla, ya sea: metal,
poly, etc).
4.2. SIMULACIONES
La simulacin de los distintos circuitos es fundamental, ya que nos permiten verificar si los
algoritmos implementados cumplen exactamente con nuestros requerimientos, como por ejemplo
cantidad de corriente que circula, amplitudes, voltajes, etc. Debido al problema que presenta
ELECTRIC como lo habamos mencionado, se busco otro software que complementara esta
falencia, es por esto que encontramos el LTSPICE en su versin gratuita. Este software cumple con
todas nuestras necesidades, dentro de las cuales permite leer y simular el Netlist
1
que se extrae desde
ELECTRIC.
4.3. ELECTRIC
Este es un software CAD Open Source [4], trabaja con elementos fsicos previamente
diseado y los cuales para beneficio nuestro pueden ser modificados, tanto fsicamente como las
propias reglas de diseo: distancias, traslape, tipos de materiales, contactos, etc. Nuestra nica
26
desventaja dentro de este software, no permite realizar las simulaciones de SPICE, pero permite
extraer el Netlist que puede ser utilizado en otro software que realice esta accin.
A continuacin se realizara una descripcin general del programa, y como utilizar cada uno
de sus componentes en la diseo de un circuito.
4.3.1 Creacin de Celda
La celda es la base sobre la cual se realizara el circuito, sobre esta van todos los elementos,
conexiones, nodos, nombre que identifican y caracterizan el circuito. Cuando el software es iniciado
este no contiene esta celda (esto lo verificamos dado que la ventana de trabajo dice No cell in this
window, figura N 4.1), esta debe ser creada.
La Celda va alojada dentro de la biblioteca, esta es la que el usuario guarda en el disco duro.
Una biblioteca puede contener todos los tipos de celdas permitidos por el software tales como:
Celdas de esquemticos, layout, iconos, etc.
Figura N 4. 1. Ventana de inicio de Electric
27
Figura N 4.2. Ventana de manipulacin y creacin de celdas
En la Figura N 4.1 el campo (1) identifica el men de acceso a las distintas funciones del
software, en la segunda parte tenemos los botones de acceso rpido (2) dentro de los cuales se ubica
los botones tales como Abrir, guardar, Zoom, medicin de distancias, aumento e incremento del
desplazamiento en LAMBDA, tipo de seleccin de objetos, deshacer, rehacer, vistas y visualizacin
dentro de jerarquas. En el campo (4) vemos un men de acceso rapdio, este contiene tres pestaas
las cuales cumplen funciones, tales como, Explorador de biblioteca, tipo de tecnologa que se esta
usando, explorador de capas visibles (muestra que capas son las que se visualizan en la celda), en el
campo (5) vemos la pantalla de mensajes, tanto de errores como de sucesos que se realicen.
Para crear una celda debemos ir al men Cell y presionar New Cell una vez ejecutada esta
accin aparece el dialogo mostrado en la figura N 4.2.
La ventana mostrada en la figura N 4.2 se ocupa para distintos propsitos dentro de la
creacin de una nueva celda. En esta figura vemos que el campo (1) nos indica el nombre de la
librera donde ser creada la celda, en el campo (2) colocamos en nombre de la celda, en el campo
(3) escogimos el tipo de celda que va trabajar, dentro de la cuales tenemos layout (diseo fsico),
schematic (diseo esquemtico) e iconos (estas tres son las que utilizaremos para el diseo de la
biblioteca), y otras que por el momento no son de importancia. El campo (4) nos indica el tipo de
tecnologa que se utilizara, el campo (5) se escoge si queremos que la celda se visualice en una
ventana distinta de la principal este botn se utiliza cuando queremos tener la visin de dos celdas
en forma simultanea. Finalmente luego de haber escogido las opciones presionamos OK, ya hemos
creado nuestra celda de trabajo. Es importante mencionar que los elementos que se van a utilizar se
seleccionan en forma automtica de pendiendo del tipo de celda que se dese crear, por ejemplo si
seleccionamos una celda layout en el campo (3), automticamente aparecern los distintos
elementos necesarios para crear una celda de layout, en el lado izquierdo de la figura 4.1 campo (4).
Ya tenemos creada una celda ahora necesitamos crear un circuito. Bueno para esto debemos
seleccionar los elementos de la barra izquierda de la ventana principal (figura N 4.1, campo (4)) y
posteriormente con un click del mouse sobre la ventana creada aparecer el elemento creado. Para
unir los distintos elementos creados en la celda debemos seleccionar el elemento verificando que se
resalte el EXPORT (mas adelante se explicara esta funcin) de la puerta que queremos unir, luego
un click con el botn derecho del mouse sobre el EXPORT del siguiente elemento a unir
automticamente se crea la una unin entre el elemento que seleccionamos primero y el que
acabamos de seleccionar con el botn derecho, el tipo de unin se selecciona automticamente
28
segn los tipos de elementos que hemos unido, para el caso de la celda Layout puede ser de varios
tipos, as como por ejemplo metal1, poly1, poly2, etc. Esto depende del tipo de conexin que
permita el elemento dado que un elemento puede tener mas de una conexin, si la conexin que es
colocada automticamente por el programa no es la que deseamos debemos previamente seleccionar
el tipo de conexin en la barra figura 4.1 campo (4) y posteriormente realizar la unin. En el caso
del esquemtico solo existe un tipo de conexin as que no tendremos este problema.
Dentro de las caractersticas de ELECTRIC existe la posibilidad de unir distintas celdas
dentro de una celda base, de tal forma de realizar un circuito mas complejo utilizando celdas
prediseadas, para introducir una celda contenida en otra biblioteca o en la misma que estamos
trabajando debemos llamar la funcin que se ubica en el men principal, en Cell.. Place Cell
I nstante una vez escogido esto, podemos visualizar la creacin de instancias, figura 4.3.
Como vemos en la figura 4.3 la ventana de creacin de instancias consta de 3 campos
fundamentales de los cuales el primero (1) identifica la biblioteca donde se desea buscar la celda a
colocar, el segundo (2) nos indica que tipo de celdas queremos ver (tipo de vista, celdas de layout,
esquemtico, etc.) y el tercero (3) nos indica las celdas disponibles de la biblioteca seleccionada y de
la vista seleccionada, posteriormente se presiona New I nstance para crear la instancia en la celda
base dejando la posibilidad de escoger otra para colocar o New I nstante &Closepara seleccionar la
celda y cerrar la ventana.
Ahora bien para realizar la unin entre estas distintas celdas se debe contar con un puente de
conexin encargado de unir las distintas partes del circuito. Esto lo podemos realizar creando una
instancia en un nodo de conexin dentro del circuito l cual se denomina Export (como antes lo
habamos mencionado), la funcin fundamental de esta puerta es crear un nexo de conexin para la
unin de varias celdas visualizadas dentro de otra celda.
Para crear un Export primero debemos seleccionar el nodo del elemento donde se quiere
colocar un Export y posteriormente ir a Men ExportCreate Export , inmediatamente despus
aparece la ventana de la figura 4.4.
Figura N 4. 3. Ventana de creacin de Instancias
29
Figura N 4.4. Ventana de creacin de export.
En el campo (1) colocamos el nombre que deseamos darle al Export y en el campo (2) el tipo
de Export que deseamos, dentro de los cuales puede ser Export de entrada Input o salida Out, entre
otros. Esta caracterstica es importante debido a que facilita el diseo, por ejemplo, un circuito que
no tenga tierra con el solo hecho de que tenga un Export con esta caracterstica el programa asumir
que esta es la tierra sin necesidad de colocar un elemento de tierra que esta disponible en los
componentes del esquemtico.
Bueno ya hemos visto en su forma bsica la conexin y creacin de un circuito, ahora
tenemos que ver si el elemento que hemos creado cumple con las normas de conexin. Para realizar
esta verificacin debemos ir a Men Tools DRC Check Hierarchically, luego si existe algn
error en las conexiones en la ventana de mensajes de la parte inferior de la figura 4.1 campo (5)
aparecer le mensaje de error indicando que regla no se esta cumpliendo, si presionamos las teclas <
o > podemos ir verificando los distintos errores, si hay mas de uno en el circuito, los cuales se
resaltan dentro del esquemtico o layout que los contenga.
Una vez realizada las verificaciones de las reglas podemos chequera si el diseo fsico es
igual al diseo esquemtico. La mayora esta familiarizado con el diseo esquemtico y la forma que
tienen cada uno de sus elementos, y no con su forma real dentro de un chip, es por esto que Electric
nos permite realizar de manera rpida y concisa esta verificacin. De esta forma estar 100% seguros
que el diseo fsico es igual al diseo esquemtico (LVS: es la sigla en ingles, Layer v/s
Schemaquic, es decir comparacin entre diseo fsico y el diseo esquemtico).
Dentro de electric existen dos maneras de verificar el LVS, estas son:
Celdas con Igual nombre:
En este caso, las celdas que tienen igual nombre y distintas vistas, ELECTRIC las agrupa en
una sub-categora con el mismo nombre de la celda.
Para realizar la verificacin LVS debemos ir a Men Tools NCC Schematic and
Layout View of Cell in Current Windows. Este comando realiza el LVS a la celda que se este
visualizando en la ventana principal del programa.
Celdas con Distinto Nombre:
Existen ocasiones en que tenemos dos celdas con distintos nombres y vistas para circuitos
iguales, en este caso para realizar el LVS a las celdas se deben visualizar en distintas ventanas cada
una de las celdas mediante el comando Men View Edit View, posteriormente utilizamos el
comando que se encuentra en Men Tools NCC Cell from two Windows.
Si la comprobacin es correcta en la ventana de mensajes, figura 4.1 campo (5), aparecer:
Hierarchical NCC every cell in the design: cell 'Prueba_2{sch}' cell 'Prueba_1{lay}'
30
Comparing: Prueba:Prueba_2{sch} with: Prueba:Prueba_1{lay}
exports match, topologies match, sizes match in 0.0 seconds.
Summary for all cells: exports match, topologies match, sizes match
NCC command completed in: 0.015 seconds.
En el caso contrario que estas no sean iguales veremos la ventana que se muestra en la figura
4.5.
En el campo (1) vemos si error es en los export o en la conexin, en los campos (2) y (3)
vemos en que parte del layout y esquemtico se encuentran estos errores, respectivamente.
Finalmente aplicando todo lo anterior podremos lograr un diseo, tanto en su parte
esquemtica como en su layout. La Figuran 4.6 muestra el diseo final de una compuerta NOT en
sus dos vistas, esquemtico y Layout.
Figura N 4.5. Ventana de errores en LVS
Figura N 4.6. Diseo de un not en su parte esquemtica y fsica
31
Figura N 4.7. Configuracin Extraccin Spice.
Posterior al diseo de cualquier compuerta debemos configurar ELECTRIC para poder
simular nuestro circuito.
En primera instancia debemos configurar los parmetros de simulacin, tales como, libreras
adicionales, resistencias y capacitancias parsitas, modelos, tipos de modelo, tipo de motor spice,
etc. Para realizar esto debemos presionar el botn de preferencias en la barra de acceso rpido figura
4.1 o en Men Files Preferences..., luego aparecer la ventana mostrada en la figura 4.7.
Dentro de la figura 4.7 vemos marcados cinco campos importantes, el campo (1) se utiliza para
definir el Nivel spice del Netlist, tipo de motor spice y el forma del formato de salida, el campo (2)
es utilizado cuando queremos incluir los parasiticos dentro del netlist (estos son colocados cuando la
celda que estamos extrayendo es de tipo Layout) a travs de esta caracterstica podemos ver cuanto
influyen los parasiticos en la simulacin y realizar una simulacin mas real del proceso, el campo
(3) es para incluir el programa de simulacin, si el programa de simulacin spice corre en lnea de
comando entonces ELECTRIC crea el Netlist se lo pasa como parmetro al programa de simulacin,
sin tener la necesidad de hacer esto en forma manual. Los campo (4) y (5) son utilizados para incluir
modelos, libreras o sub-circuitos que se encuentren en un archivo de texto. Estos quedan incluidos
en el Netlist como un .INCLUDE. Al colocar este archivo en el campo (4) el
32
Figura N 4.8. Circuito listo para simulacin Spice.
INCLUDE se coloca en la cabecera del netlist y al colocarlo en el campo (5) queda incluido en final
del netlist.
Una vez configuradas las preferencias de simulacin debemos agregar a nuestra celda los
distintos elementos SPICE necesarios para la simulacin, tales como fuentes de poder, anlisis
transiente, anlisis DC, fuentes de pulso, etc. estos elementos los encontramos en la parte izquierda
de la ventana principal figura 4.1 campo (4) en la pestaa que dice SPICE, como lo muestra la figura
4.8.
Luego de haber configurado y alimentado nuestro circuito procedemos a extraer el Netlist
para su posterior simulacin, para esto vamos a Men Tools Simulation (SPI CE) Write
SPI CE deck...
OBS:
El desarrollo antes mostrado muestra la forma bsica de cmo utilizar el programa, para
mayores referencias ir al manual del programa.
33
4.4. LTSPICE
LTspice es un software de simulacin de descarga gratuita que encontramos en
http://www.linear.com/company. Es un simulador de alto rendimiento enfocado a simulacin de
circuitos SPICE III, adems nos permite visualizar, capturar y guardar distintas formas de ondas
obtenidas de la simulacin de circuitos, tanto de esquemticos realizados en el propio programa
como de netlist obtenidos de otros programas. Su versatilidad y fcil manejo nos permite realizar
simulaciones rpidas y con baja complejidad en la configuracin del software.
Como se muestra en la figura 4.9 existen 4 campos de inters, en el primero (1) vemos el
men de acceso a las distintas caractersticas, tales como preferencias, herramientas, tipos de vista,
etc. en el campo (2) vemos un men de acceso directo el cual puede ser configurado en el panel de
control segn la necesidad del usuario, adems provee de elementos prediseado en el caso que
deseemos realizar un circuito esquemtico en este programa, el campo (4) es la ventana principal
donde se aloja tanto el netlist como los grficos de las distintas simulaciones.
Un punto importante a considerar antes de la simulacin es configurar bien los parmetros
SPICE, es por esto que en la figura 4.9 se muestra el campo (3) (panel de control), en la parte de
configuracin SPICE. Aqu podemos apreciar parmetros de configuracin importante a la hora de
la simulacin, tales como el Reltol, este parmetro me indica la tolerancia del error dentro de la
simulacin, la calidad con que quiero que se realicen los clculos en mi simulacin. Adems
tenemos parmetros como el Trtol el cual para la mayora de los simuladores comerciales utiliza un
parmetro 7, en el caso de LTspice viene por defecto 1, este parmetro afecta directamente al tiempo
de muestreo y por ende en la calidad de la simulacin, un valor mayor de 1 en Trtol puede llevar
mas rpido a una solucin, pero este podra aumentar la inexactitud del resultado.
Figura N 4.9. Programa LTSpice
34
Una vez realizadas las configuraciones anteriores podemos proceder a cagar nuestro netlist
proveniente de ELECTRIC, para cargar este tipo de archivo se debe ir a Men Open y seleccionar
tipo de archivo Netlist. Una vez cargado el archivo procedemos a correrlo en la opcin Simulation
Run.
Al correr la simulacin nos podemos encontrar con dos casos: El archivo netlist contiene
errores, en cuyo caso debemos ir a men Views SPI CE error log... aqu aparecer un archivo
describiendo el tipo de error y la parte donde se genero, y si nuestro netlist esta correcto aparecer
un men de dialogo que nos muestra los voltajes y corriente disponibles para este circuito, figura
4.10.
Cada uno de los voltajes y corrientes trae sus correspondientes nombres asociados a los
diferentes export que se crearon en ELECTRIC. Una vez escogido la o las formas de onda que
queremos visualizar se despliega un grafico como se muestra en la figura 4.12, parte superior.
Adems situndonos con el cursor sobre el grafico y presionando el botn derecho del mouse
podemos desplegar el men que se muestra en la figura 4.11.
Figura N 4.10. Programa LTSpice opciones de visualizacin
35
Figura N 4.11. Men de visualizacin.
En la figura 4.11 lado izquierdo vemos un men con distintas opciones: zoom, adicin de
plot, grid, adicin de curvas, etc. en esta ultima nos detendremos un poco (Add Trace). Esta
caracterstica nos provee de una herramienta fundamental en el momento de la visualizacin de la
forma de onda deseada, al presionar sobre Add Traceaparece el men que se encuentra a la derecha
de la figura 4.11, aqu visualizamos tres campos importantes: Ventana superior, nos sirve para
visualizar en Avilable data solo las ondas que nosotros deseemos, por ejemplo, si escribimos V
automticamente en la seccin Avilable data aparecern solo las variables que contengan la letra V.
Ventana Expression(s) to add, aqu podemos realizar formulas donde incluyan las distintas corriente
y o voltajes del circuito, como por ejemplo, ( ) ( ) ( ) ( ) s Ix out V in V exp + .
Cada vez que corremos la simulacin del netlist nos aparece la ventana que se muestra en la
figura 4.10 y posteriormente debemos elegir el tipo de onda que deseamos visualizar, ahora bien, si
estamos modificado el netlist y queremos ver la evolucin de la misma forma de onda una y otra
vez, es una perdida de tiempo estar escogiendo la forma de onda cada vez que corrimos la
simulacin. Para evitar esto debemos escoger la forma de onda, luego seleccionar el grafico o la
ventana donde se encuentran los grficos, automticamente en el men superior aparecer una
opcin llamada Plot Settings, luego tienes que ir a Save plot settings y guardar la configuracin en
un archivo con el mismo nombre del netlist pero con extensin PLT, ahora cada vez que corras ese
netlist aparecer en forma automtica las formas de onda escogidas para la visualizacin. Si deseas
escoger otras formas de onda, puedes eliminar el archivo con extensin PLT o bien seleccionar otras
formas de onda y volver a guardarlas, rescribiendo el archivo antiguo.
Hemos presentado en forma clara y concisa la manera de utilizar LTspice para la simulacin
de netlist extrados desde ELECTRIC. A continuacin presentaremos un ejemplo de simulacin de
una compuerta NOT realizada en ELECTRIC y cuyos resultados son presentados en la figura 4.11,
adems veremos otras caractersticas de LTspice de gran utilidad dentro de la obtencin de
resultados.
36
Figura N 4.12. Visualizacin de formas de onda
Figura N 4.13. Activacin de cursores
LTspice permite visualizar valores en forma instantnea sobre las curvas obtenidas en la
simulacin, esto se realiza colocando el Mouse sobre el valor deseado y presionando con el botn
derecho nos muestra la figura 4.13.
En el campo (1), muestra el color de la lnea, el cual podemos cambiar, en el campo (2) la
cantidad de cursores que colocaremos sobre la onda (como mximo dos). Estos cursores permiten
medir tanto valores de voltaje, corriente y tiempo, as como tambin deltas de tiempo y amplitud,
pendiente, frecuencias, figura 4.14.
37
Figura N 4.14. Medicin utilizando cursores
38
CAPITULO V
5. DISEO DE CELDAS DE LA BIBLIOTECA
Dentro del diseo de las distintas partes que conforman la biblioteca, existen pequeos
circuitos o mejor dicho sub-circuitos que son de gran importancia al momento de realizar el diseo
de un circuito. Estos sub-circuitos se utilizan para completar circuitos de mayor tamao como
amplificadores operacionales o multiplicadores anlogos
Dentro de estos sub-circuitos tenemos: espejos de corrientes, pares diferenciales, diodos
formados con transistores CMOS, entre otros. Es por esto que previo al diseo de los elementos
fundamentales que conforman nuestra biblioteca daremos un pequeo vistazo a estos circuitos.
5.1. DIODO CMOS.
Para disear un diodo con utilizando un transistor CMOS se debe unir el GATE con el
DRAIN o SOURCE segn el tipo de transistor como se muestra la figura 4.1 (a) y 4.1 (b), de esta
forma obtenemos una la curva caracterstica de I v/s V del transistor similar a la de la juntura PN del
diodo, como se muestra en la figura 4.1 (c).
Esta curva caracterstica mostrada en la figura 4.1 (c), al unir el GATE con el DRAIN, esto
asegura que el transistor trabaje en la regin de saturacin y por lo tanto la corriente que circula a
travs del DRAIN esta dada por la ecuacin 4.1 [9]:
( ) ( )
2 2
2 2
'
T GS T GS D
V V V V
L
W K
I I
,
_

( 5.1 )
D
DS DS GS
I
V V V V + 2 ( 5.2 )
A este diodo a dems se le llama resistencia activa, utilizado generalmente para polarizar o
fijar un valor de voltaje determinado en un circuito.
Figura N 5.1. Diodos tipo CMOS. (a) Transistor canal n. (b) Transistor canal p.(c) curva
caracterstica Iv/sV.
39
5.2. ESPEJO DE CORRIENTE.
Figura N 5.2. Espejos de corriente tipo CMOS. (a) Espejo de corriente NMOS. (b) Espejo
de corriente PMOS.
Figura N 5.3. Espejo de corriente nmos
El espejo de corriente es utilizado para fijar la corriente que circula a travs del un transistor
CMOS por medio de una corriente de referencia, los modelos tpicos de espejos de corriente se
muestran en la figura 5.2.
Como muestra la figura 5.2 (a) y (b), el espejo de corriente esta compuesto por un transistor
y un diodo CMOS; la corriente I
0
o corriente reflejada que circula por el transistor CMOS es
controlada por la corriente que circula a travs del diodo CMOS, para lograr que I
0
sea igual o
aproximadamente igual a la corriente I
REF
, el tamao de los transistores debe ser igual o parecido, de
aqu vemos que M1 est en la saturacin porque V
DS1
= V
GS1
y si asumimos que V
DS2
_ V
GS2
-V
T2
,
esto permite que utilicemos las ecuaciones en la regin de la saturacin de los transistores CMOS.
En el caso ms general, el cuociente de I
0
a I
REF
est dado por la ecuacin 5.3 [9].
1
]
1
,
_
+
+
,
_
,
_
'
1
'
2
1
2
2
1
2
2 1
2 1 0
1
1
K
K
V
V
V V
V V
L W
W L
I
I
DS
DS
T GS
T GS
REF

( 5.3 )
De la ecuacin 5.3 y asumiendo que los transistores M1 y M2 son iguales, podemos ver que
la corriente I
0
- I
REF
debido que el voltaje fijado en el GATE de ambos transistores es el mismo.
40
5.3. PAR DIFERENCIAL.
Figura N 5.4. Par diferencial pmos
El par diferencial es un sub-circuito utilizado en distintos circuitos dada sus distintas
aplicaciones, en la figura 5.4 se muestra un par diferencial construido con transistores NMOS.
De la figura 5.4, vemos claramente que este tipo de circuito relaciona la corriente que circula
por M
1
y M
2
con el voltaje aplicado en V
1
y V
2
, as como tambin por ley de Kirchhoff la corriente
que circula por I
ss
es la resultante de la suma de las corrientes I
1
e I
2
. A continuacin se muestra el
desarrollo matemtico de las ecuaciones que gobiernan al Par Diferencial; como en los casos
anteriores asumimos que M
1
y M
2
son iguales.
Para comenzar definimos:
2 1
1 2
I I I
V V V
ss
d
+

( 5.4 )
Dado que los transistores M
1
y M
2
son iguales, podemos definir las corrientes I
1
y I
2
,
mediante la siguiente ecuacin.
( )
( )
2
2
'
2
2
1
'
1
2
2
T GS
T GS
V V
L
W K
I
V V
L
W K
I

( 5.5 )
Desarrollando las ecuaciones 5.5 obtenemos lo siguiente:
( )
( )
T GS
T GS
V V
L
W K
I
V V
L
W K
I

2
'
2
1
'
1
2
2
( 5.6 )
Aplicando un pequeo desarrollo matemtico y utilizando lo descrito en la ecuacin 5.4
obtenemos:
41
d
V
L
W K
I I
2
'
2 1
( 5.7 )
Finalmente utilizando las ecuaciones 5.7 y 5.4, podemos redefinir las corrientes I
1
e I
2
en
funcin del voltaje aplicado en los transistores M
1
y M
2
as como de la fuente corriente I
ss
.
L
W
K
I
V
V
I
L
W K I
I
L
W
K
I
V
V
I
L
W K I
I
d
d
d
d
,
_

,
_
,
_

,
_
+
'
2
'
2
'
2
'
1
2
1
2 2 2
2
1
2 2 2
( 5.8 )
De las ecuaciones 5.8 vemos que si V
d
= 0, entonces:
GS GS GS
V V V
I
I I

2 1
2 1
2 ( )
2
'
2 2
T GS
V V
L
W K I
( 5.9 )
Ahora bien utilizando la ecuacin 5.9 podemos re definir las ecuaciones 5.8, de esta forma la
corriente que circula por I
1
e I
2
queda dependiente solo de voltajes aplicados a los transistores M
1
y
M
2
respectivamente.
( ) ( )
( ) ( )
2
2
2
2
2
1
2
1
2 2
2
1
2 2
T GS
d
d
T GS
T GS
d
d
T GS
V V
V
V
V V
I I
I
V V
V
V
V V
I I
I
,
_

,
_
,
_

,
_
+
( 5.10 )
De las ecuaciones antes mencionadas podemos ver que para pequeos valores de V
d
, las
ecuaciones 5.10 pasan a comportarse de la siguiente manera.
( )
( )

,
_
,
_
+
2 2
2 2
2
1
d
T GS
d
T GS
V
V V
I I
I
V
V V
I I
I
( 5.11 )
42
Figura N 5.5. Curva Par diferencial
De aqu podemos ver que cuando 0 ,
2 1
I I I
ss
, o viceversa, adems el valor mximo de V
d
esta dado por:
( )
T GS d
V V V 2
max
( 5.12 )
Ahora con las ecuaciones 5.11 y 5.12 podemos graficar el comportamiento del par
diferencial.
Como se aprecia en la figura 5.5 existe una dependencia lineal entre la corriente por las
ramas del par diferencial y el voltaje aplicado en los transistores, pero esta deja de ser lnea a medida
que se aumenta el voltaje producto del termino cuadrtico en la ecuacin 5.10.
5.4. DISEO DEL MULTIPLICADOR DE GILBERT.
Un poco de historia, en 1968 el ingeniero de Tektronix, Barrie Gilbert, trabajando en un
oscilador de alta frecuencia fue el primero en demostrar que se pueden usar transistores bipolares
para obtener seales de alta calidad en un multiplicador anlogo de cuatro cuadrantes o celda de
Gilbert. Posteriormente en 1982 las ideas y topologas fueron aplicadas en el diseo del mismo
multiplicador pero ahora con transistores NMOS, figura 4.6. El multiplicador de Gilbert, satisface la
expresin Z = const X Y.
Escogimos este multiplicador para incluirlo en nuestra biblioteca debido a sus caractersticas
y su sencillez en el diseo de compuertas anlogas.
43
Figura N 5.6. Versin CMOS del multiplicador de Gilbert
El la figura 5.6 se muestra el esquemtico de la celda bsica de Gilbert o multiplicador de
cuatro cuadrantes. Se denominan multiplicadores de cuatro cuadrantes a aquellos que aceptan
seales en su entrada de ambas polaridades y conservan la polaridad correcta en la seal de salida
del multiplicador. Esto se logro utilizando un par diferencial para el diseo del circuito de
multiplicacin, dado que la matemtica involucrada en el desarrollo de las ecuaciones del par
diferencial arroja un termino no deseable en la multiplicacin de seales, se implemento un circuito
como se muestra en la figura 5.6 el cual cuenta con dos etapas de multiplicacin simples y cuyas
salidas se restan de manera de eliminar los trminos indeseables en el resultado de la multiplicacin.
A continuacin se presentara una descripcin bsica de la matemtica involucrada en el
multiplicador de Gilbert.
Asumiendo que todos los transistores son polarizados en la regin de saturacin y son de la
medida, y sus parmetros de transconductancia satisfacen K
1
= K
2
= K
3
= K
4
= K
a
y K
5
= K
6
=K
b
,
podemos definir la corriente de salida como I
0
= I
2
I
1
= (I
2b
+ I
2a
) (I
1a
+ I
1b
) [8], se redefini la
corriente I
0
de la siguiente forma:
,
_

4
2
4
3
2
3 0
2
1
2
1 2
I
V K
I
I
V K
I V K I
x a x a
x a
( 5.13 )
Asumiendo que:
1
2
3
2
<<
I
V K
x a
y 1
2
4
2
<<
I
V K
x a
Podemos redefinir la ecuacin 5.13 de la siguiente manera donde I
0
depende linealmente de
V
x
:
( )
x a
V I I K I
4 3 0
2 ( 5.14 )
Las corrientes I
3
, I
4
pueden ser expresadas por V
y
, dado que V
y
esta dada por:
44
( )
4 3
1
I I
K
V
a
y

( 5.15 )
Reemplazando (4.3) en la ecuacin (4.2), obtenemos la siguiente expresin:
y x b a
V V K K I 2
0
( 5.16 )
Finalmente vemos que la ecuacin (5.16) representa la corriente de salida en un
multiplicador anlogo ideal.
La ecuacin 5.16 se obtuvo a partir del supuesto que los voltajes
x
V y
y
V , son pequeos
menores a 100[mV], caso contrario esto voltajes pierden su linealidad pasando a constituir una
funcin tangente hiperblica, como muestra la ecuacin 5.17, donde la ecuacin 5.16 quedara
expresada por:
( ) ( )
y x b a
V V K K I tanh tanh 2
0
( 5.17 )
Es por esto que la curva de multiplicacin en un multiplicador de gilbert esta dada por la
figura 5.7.
Figura N 5.7. Curva de transferencia DC del multiplicador de Gilbert [8]
45
5.4.1 Diseo Esquemtico y layout en ELECTRIC
Figura N 5.8. Esquemtico del multiplicador de Gilbert
En la figura 5.8 se muestra el diseo final del esquemtico obtenido a partir de la figura 5.6.
Como se aprecia en la figura 5.8 la fuente de corriente mostrada en la figura 5.6 es diseada por un
transistor NMOS (M8) controlada por un espejo de corriente M7 el cual a su vez cuenta con un
diodo CMOS M11 que fija el valor de corriente que circula a travs de M7, adems las corriente I
1
e
I
2
estn distribuidas en forma igualitaria por un espejo de corriente PMOS formado por los
transistores M9 y M10.
Una vez diseado el esquemtico final del multiplicador figura 5.8, obtenemos el diseo final
de Layout del multiplicador de Gilbert, figura 5.9.
46
Figura N 5.9. Layout del multiplicador de Gilbert
5.4.2 Simulacin.
Figura N 5.10. Simulacin del esquemtico del multiplicador de Gilbert
Una vez obtenidos el esquemtico y layout del multiplicador de Gilbert, procedimos a
obtener su respuesta DC al cambio en las entradas del multiplicador, los resultados se muestran en
las figuras 5.10 y 5.11.
47
Figura N 5.11. Simulacin Layout del multiplicador de Gilbert
Figura N 5.12. Zoom a la curva de transferencia del multiplicador
Se aprecia que tanto las curvas obtenidas por el esquemtico Fig. 5.10 y layout Fig. 5.11 son
casi iguales, y se comportan tal como esperbamos, como se demostr en la figura 4.7. Se ve
claramente que para voltajes ms pequeos aumenta el rango de linealidad del multiplicador. Esto se
aprecia en las curvas de ms al centro y lo podemos verificar en la figura 5.12, la cual es un zoom a
los grficos anteriores.
Al apreciar con mas detenimiento la figura 5.12 vemos claramente que existen curvas que no
pasan por el centro del grafico, esto se debe al offset que se genera producto de los voltajes mayores
en la entrada, como vemos a medida que el voltaje disminuye las curvas son ms lineales y el
trmino de offset es despreciable.
48
5.5. DISEO AMPLIFICADOR OPERACIONAL
Figura N 5.13. Amplificador operacional bsico. (a) Amplificador bsico con transistor
NMOS (b) Modelo en pequea seal.
Figura N 5.14. Curvas caractersticas del amplificador ideal.
En el diseo de nuestra biblioteca hemos considerado incluir el diseo de un
amplificador operacional, debido a que como veremos ms adelante este es de suma importancia en
el diseo del circuito de memoria de la biblioteca.
A continuacin presentaremos una breve introduccin y diseo de los amplificadores
operacionales.
La forma mas bsica de disear un amplificador es utilizando un transistor, donde la entrada
del amplificador es el voltaje colocado en el GATE y la salida esta situada en el SOURCE o DRAIN
dependiendo de que tipo de transistor (PMOS o NMOS).
De la figura 5.13 podemos obtener la ecuacin caracterstica que rige el funcionamiento de
este tipo de amplificador.
( )
0
0
,V V i
R
V V
I D
D
DD
( 5.18 )
Las curvas que rigen el funcionamiento de este tipo de transistor se muestran en figura 4.15.
49
Como se aprecia en la figura 5.14 la funcin de transferencia del amplificador (a la derecha)
muestra claramente el punto de operacin donde debe operar el amplificador, donde la ecuacin que
rige la corriente que circula por el amplificador depende claramente tanto del voltaje de entrada V
I
como del voltaje de salida V
0
.
El punto de operacin del transistor es el punto en el cual se logra el mejor rendimiento del
amplificador a un rango de voltajes determinados en la entrada. Para lograr un punto de operacin
ptimo se debe polarizar el amplificador, existen distintas tcnicas de polarizacin dependiendo del
tipo de amplificador, tipo de circuito, as como del tipo de transistor que se utilice en el diseo. A
travs de la polarizacin adems logramos situar nuestro amplificador en la zona de amplificacin,
obtener el valor de ganancia deseado y disminuir la distorsin.
Existen parmetros que caracterizan los amplificadores, estos son su ganancia (A
V
),
impedancia de entrada (Z
I
), impedancia de salida (Z
0
) (ecuacin 5.19), entre otros.
0
0
0
0
0
I
V
I
I
I
I
V
I
V
Z
I
V
Z
V
V
A
( 5.19 )
En el diseo de circuitos integrados en VLSI se evita el uso de resistencia para polarizar los
distintos tipos de amplificadores, es por esto que existen dos formas bsicas de polarizar un
amplificador, con resistencias activas o con fuentes de corriente.
Las resistencias activas o tambin denominadas diodos CMOS como ya lo habamos
mencionado, son resistencias nolineales donde la corriente que circula a travs de la resistencia esta
dada por la ecuacin 5.20.
La figura 5.15 muestra el modelo en pequea seal del la resistencia activa, de aqu podemos
obtener el valor terico de la resistencia, el cual esta dado por:
m DS m
DS
g r g
r
i
v
R
1
1

+

( 5.20 )
Las fuentes de corriente utilizadas para la polarizacin de los amplificadores, se pueden
disear de distintas maneras. Generalmente una fuente de corriente es un transistor CMOS
trabajando en saturacin, donde la corriente que circula a travs del transistor esta regulada segn el
voltaje que sea aplicado en GATE del transistor, figura 5.16.
Figura N 5.15. Modelo en pequea seal de la resistencia activa
50
Figura N 5.16. Fuentes de corrientes tipo CMOS. (a) Fuente de corriente NMOS (b) Fuente
de corriente PMOS.
Figura N 5.17. Curvas caractersticas de una fuente de corriente tipo CMOS. (a) Curva
caracterstica NMOS (b) Curva caracterstica PMOS.
La figura 5.16 muestra los dos tipos de fuente de corriente, segn el tipo de transistor que se
utilice.
Las curvas que relacionan la corriente que circula a travs del transistor con el voltaje
aplicado se muestra en la figura 5.17.
De la curva 5.17, vemos que la resistencia de salida para cada una de las fuentes de corriente en
pequea seal esta dada por:
BIAS BIAS
DS
DS
I I
V
r r
+

1 1
0 ( 5.21 )
Generalmente para fijar una corriente determinada en la fuente de corriente se utilizan,
espejos de corriente o configuraciones mejoradas de estos, tales como Cascode, Wilson o Wilson
mejorado, de esta manera la resistencia de salida genera una corriente lo mas constante posible, as
como se muestra en la figura 4.19.
51
Figura N 5.18. Curva caracterstica espejo de corriente
Figura N 5.19. Esquema de un amplificador diferencial
Dentro de la gama de distintos amplificadores que existe, escogimos un amplificador
diferencial con carga activa tipo OTA Millar (amplificador de transconductancia), este tipo de
amplificador esta basado en un par diferencial polarizado con una fuente de corriente controlada por
un espejo de corriente.
En un amplificador diferencial la entrada esta dividida en dos voltajes y salida es nica,
como se muestra en la figura 4.20.
Las ecuaciones que rigen el amplificador diferencial de la figura 5.19, son:
( )
2 2 1 1 0
2 1
2 1
2
V k V k V
V V
V
V V V
cm
d

+

( 5.22 )
Utilizando las ecuaciones 5.22 podemos redefinir el voltaje de salida V
0
.
( ) ( )( )
cm
d
cm
d
cm
d
V k k
V
k k V
V
k V
V
k V
2 1 2 1 2 1 0
2 2 2
+
,
_
,
_
,
_
+ ( 5.23 )
Agrupando los trminos de la ecuacin 5.23, podemos definir dos ganancias, A
d
como la
ganancia diferencial y A
cm
como la ganancia de modo comn.
52
( )
( )
2 1
2 1
2
k k A
k k
A
cm
d

+
( 5.24 )
Utilizando las ecuaciones 5.24, redefinimos la ecuacin 5.23.
cm cm d d
V A V A V +
0
( 5.25 )
El amplificador OTA Miller con par PMOS y espejo NMOS como carga, se muestra en la
figura 4.17.
Del modelo en pequea seal de la figura 5.20, obtenemos las ecuaciones que rigen las
distintas ganancias en el amplificador.
( )
3 3 3
2 4
5 2
0
1
1
2 4
1
2
m ds m m
m ds ds
ds ds
cm
ds ds
m
id
d
g g g g
g g g
g g
A
g g
g
V
V
A
+
+

( 5.26 )
Figura N 5.20. Amplificador OTA Millar. (a) Amplificador OTA Miller (b) Modelo en
pequea seal.
53
5.5.1 Diseo Esquemtico y layout en ELECTRIC.
Figura N 5.21. Esquemtico del Amplificador OTA Miller
Tomando el modelo de amplificador OTA Miller mostrado en la figura 5.20 (a), se obtuvo el
esquemtico mostrado en la figura 5.21.
Como vemos la fuente de corriente formada por el transistor M5 a travs del cual circula una
corriente de 1 [A] se fija mediante un espejo de corriente externo fijada por una fuente de corriente
DC.
54
Una vez obtenido el esquemtico final del amplificador operacional OTA Miller, se procedi
al diseo final de layout mostrado en la figura 4.23.
Figura N 5.22. LayOut del Amplificador OTA Miller
55
5.5.2 Simulacin.
Figura N 5.23. Curva del Amplificador OTA Miller, Esquemtico.
Figura N 5.24. Curva del Amplificador OTA Miller, Layout.
Despus de tener el diseo del esquemtico y el layout procedemos a simular la curva de
transferencia DC, los resultados se muestran en las figuras 5.23 y 5.24.
Dado que se esta trabajando con transistores iguales tanto en el par diferencial como el
espejo de corriente y estos no se ven afectados por procesos de fabricacin ya que el software no
permite agregar estas anomalas obtenemos curvas similares entre el esquemtico y layout. Estas
simulaciones se obtuvieron haciendo un anlisis DC. Se fijo un voltaje de referencia de 2.5 [V] en la
entrada y se barrio el voltaje de entrada de 0 a 5 [V] con incrementos de 0.01 [V], de esta forma las
curvas mostradas en las figuras 5.23 y 5.24 tienen el mismo comportamiento ya previsto en la figura
5.14.
56
5.6. DISEO DE MEMORIA.
c
Figura N 5.25. Celda de Memoria
Como lo habamos mencionado la memoria anloga diseada esta formada por un transistor
de compuerta flotante, dado que se logra mejor control sobre el valor almacena, as como
actualizacin y lectura de los pesos en lnea. En la figura 4.26 se muestra el modelo de memoria que
se utilizara para esta biblioteca
Esta celda de memoria (figura 5.25) esta formada por un transistor de compuerta flotante y
un amplificador, M1 es el transistor principal donde sucede el fenmeno de inyeccin y M2 es el
transistor cortocircuitado donde sucede el fenmeno de Tunneling. La compuerta flotante esta
representada por el condensador Cw, l cual representa al condensador que se forma entre el poly1
de M1 y M2, y el poly2. Como se muestra en la figura 5.25 la celda contiene adems un
amplificador operacional su funcin es amplificar las diferencias de voltaje que se producen en la
compuerta flotante y compensar los cambios a travs de la salida conectada al condensador, de esta
forma el voltaje la compuerta flotante permanece casi constante y la salida del amplificador refleja
los cambios de voltaje producidos en ella.
Dentro del diseo de la celda de memoria se debe considerar todas las ecuaciones que rigen
el funcionamiento del transistor de compuerta flotante, todas las ecuaciones mencionadas en el
capitulo 3, de esta forma nos aseguramos que el diseo de la celda se lo mas aproximado a la celda
de memoria real. Para realizar lo anterior debemos disear cada uno de los cuatro elementos de la
celda de memoria, estos son:
Transistor de Inyeccin.
Transistor de Tunneling
Condensador.
Amplificador Operacional.
A continuacin describiremos el diseo de los primeros tres elementos mencionados
anteriormente, en cuanto al amplificador operacional, se utilizara el amplificador OTA Miller
descrito en el capitulo 5.5.
5.6.1 Transistor de Inyeccin.
El transistor de inyeccin es el encargado de inyectar electrones dentro de la compuerta
flotante disminuyendo el voltaje almacenado en la compuerta. Este transistor debe cumplir con las
ecuaciones propuestas en el capitulo 3.2 ecuaciones 3.2 y 3.3. De estas dos ecuaciones mencionadas
vemos que la ecuacin 3.2 describe la corriente que se genera entre el canal formado entre el
SOURCE-DRAIN y el GATE del transistor M1 de la figura 5.25, es por esto que el transistor debe
llevar una fuente de corriente conectada del DRAIN al GATE [2]. La ecuacin 3.3 muestra la
corriente generada por el exceso de electrones que no pasan hacia el GATE y que con recogidos por
el WELL, debido a esto el transistor M
1
de llevar una fuente de corriente adicional regida por esta
ecuacin y que se encuentre conectada entre el GATE y el WELL del transistor [2] [6].
57
Para llevar acabo una buena implementacin de las ecuaciones debemos incluir los
parmetros reales que permitan un correcto funcionamiento de las ecuaciones, es por esto que
utilizamos los parmetros descritos en [6] aqu se utilizaron parmetros empricos y semi-empricos
para la simulacin del transistor de compuerta flotante en su modelo SPICE. Las ecuaciones finales
son:
( )

,
_
+
+

sd
gd
s inj
V
V
I I
2
5 -
0.702
155.75
exp 10 1.30 ( 5.27 )
( )
,
_

0.719703 1.985 2.985
94.85
exp 0.719703 - 1.985 2.985 1.127
sg sd
sg sd s b
V V
V V I I
( 5.28 )
Dado que no existen estas fuentes de corriente que se rijan por estas ecuaciones se crearon
dos fuentes de corrientes SPICE. Para esto se crearon dos iconos dentro de la biblioteca con
nombres CSINY y CSWELL, cada uno de estos iconos contiene un template que identifica el tipo
de fuente y sus caractersticas. Al extraer el Netlist, ELECTRIC lee el template que esta dentro del
icono y lo escribe en el archivo netlist. Un template no es ms que una lnea de comando que
ELECTRIC interpreta dentro del circuito y lo escribe en el netlist. El template para la ecuacin 3.2
es:
SPICE_template= B$(node_name) B D I=(1.127*Is(Minj))*((2.985 *V(S,D))-(1.985*V(S,G))-
0.719703)*exp(-(94.85 /((2.985 *V(S,D))-(1.985*V(S,G))-0.719703)))
( 5.29 )
ELECTRIC interpreta de la siguiente forma esta lnea de comando (5.29): la primera letra, B
es el tipo de fuente de corriente (no lineal), todo lo que viene encerrado entre $( ), ELECTRIC lee
el comando y coloca el nombre asociado a el, una vez que se exporte el netlist, estos comandos son,
node_nameidentifica el nombre que se le coloca a la fuente de corriente, B identifica el nombre de
la red donde esta conectada el terminal positivo de la fuente, as como la D identifica el nombre de
la red del circuito donde esta conectado el terminal negativo de la fuente, de esta misma forma se
realizo el icono que representa a la ecuacin 3.3.
El resultado final del diseo de las fuentes de corriente que rigen la inyeccin se muestra en
la figura 5.26.
58
Figura N 5.26. Fuentes de corriente transistor de inyeccin. (a) Icono CSINY (b) Icono
CSWELL.
Figura N 5.27. Celda de Inyeccin, Esquemtico
Luego de haber creado las fuentes de corriente SPICE se creo la celda que identifica el
transistor de inyeccin en su forma esquemtica y layout (figura 4.28 y 4.29), el cual identifica el
transistor M
1
de la figura 5.25.
59
Figura N 5.28. Celda de inyeccin, layout
Figura N 5.29. Propiedades del Transistor
Existe una pequea diferencia entre la celda de esquemtico y la de layout, si vemos la figura
5.27, existe dos numero los cuales son propiedades de la celda, en cualquier celda que se crea en
ELECTRIC existe la posibilidad de pasar parmetros que modifiquen elementos dentro de la celda,
de tal forma se crearon dos elementos de nombre W y L que modifican en forma automtica el
ancho y el largo del transistor de nombre inj de la figura 5.27, y sus valores por defecto son 3 y 2
respectivamente. Para que se realice la modificacin se debe colocar cdigo de ejecucin Java en el
elemento y donde se colocan los parmetros se debe colocar @ seguido del nombre del parmetro
(propiedades del elementos, en este caso transistor) automticamente ELECTRIC verifica que el
nombre del parmetro est dentro de la celda y coloca su valor en el netlist que se extrae, as como
en el elemento. Para el caso del transistor PMOS la ventana de configuracin se muestra en la figura
5.29, esto solo es posible en las celdas de tipo esquemtico.
60
5.6.2 Transistor de Tunneling.
El transistor de Tunneling, como ya lo habamos mencionado en el capitulo 3 es el
encargado de sacar los electrones del interior de la compuerta flotante de esta forma se logra
aumentar el valor de voltaje en el GATE de transistor. El fenmeno de Tunneling que ocurre al
variar el voltaje en la entrada del transistor M
2
figura 5.25 genera una corriente que va desde el
DRAIN del transistor al GATE del mismo que esta caracterizada por la ecuacin 5.30.
Obtenidos los parmetros [6] la ecuacin final a utilizar en la biblioteca es la siguiente.
,
_

ox
tun
V
L W I
04 . 368
exp 10 35 . 9
8
( 5.30 )
Para implementar la ecuacin 5.30 se creo una fuente de corriente que se rige esta ecuacin
de la misma forma que se disearon las fuentes de corriente que rigen la inyeccin. Para este caso se
creo un icono de nombre CSTUN, el cual adems de llevar el smbolo de fuente de corriente lleva su
correspondiente template, como se muestra en 5.31.
SPICE_template= B$(node_name) Tun G I=9.35e8*exp(-368.04/V(Tun,G))*$(W)*$(L)*0.2*0.2
( 5.31 )
A diferencia de las dos fuentes creadas anteriormente, esta fuente lleva los parmetros W y
L, estos parmetros se deben pasar automticamente una vez definido el ancho y el largo del
transistor. Es por esto que dentro del icono se crearon dos atributos adicionales a la celda icono de la
fuente CSTUN, estos atributos llevan como nombre W y L, su valor es @W y @L, respectivamente,
y su cdigo de evolucin es Java igual que en el caso anterior, adems en la ecuacin estos
parmetros estn encerrados en $() permitiendo a ELECTRIC colocar el valor contenido en estos
parmetros en la ecuacin.
El resultado final del diseo del transistor de Tunneling tanto en su forma esquemtica como
en su forma de layout se muestran en la figura 5.31.
Figura N 5.30. Fuente de corriente SPICE, CSTUN
61
Figura N 5.31. Transistor de tunneling. (a) Transistor de Tunneling, Esquemtico (b)
Transistor de Tunneling, Layout.
Dentro de la figura 4.32, vemos que acompaado a la L y W, esta la palabra not found, esto
indica que como se extrajo estas celdas directamente, no se le a pasada ningn parmetro a ella, es
por esto que java interpreta @W y @L colocando este nombre.
5.6.3 Condensador.
En la figura 5.25 se muestra un condensador conectado entre el GATE del transistor M
1
y la
salida del amplificador operacional, este condensador representa el condensador formado entre el
poly1 del transistor M
1
y el poly2.
Dentro de la biblioteca que provee ELECTRIC existe el condensador para ser utilizado en
celdas del tipo esquemtico, pero no existe ningn condensador formado por poly1 y poly2 para la
biblioteca de layout. Es por esto que se creo una celda layout que contenga un capacitor formado por
poly1 y poly2.
Dado que estamos trabajando con proceso de fabricacin de 0.35 [], Mosis [3] nos indica
que la capacitancia obtenida entre poly1 y poly2 para este tipo de proceso de fabricacin es 879 [aF/
m
2
], en el Anexo 1 adjuntamos las reglas mosis para capacitores poly1-poly2.
Para que ELECTRIC interprete de manera correcta de que tipo de elemento se trata cuando
se extrae el netlist a la celda del capacitor se agrego un template (5.32) que identifica el capacitor.
62
Como la capacitancia es 879 [aF/ m
2
], para disear un capacitor de 100 [fF] se debe tener un poly2
de 53x53 []. La figura 4.33 muestra un layout del capacitor de 100[fF].
SPICE_template= C$(node_name) $(P2) $(P1) 100f
( 5.32 )
Definidos todos los elementos que componen la celda de memoria, podemos implementar el
diseo final del esquemtico, pero existe otro problema que debemos considerar en el diseo de la
celda.
Cuando implementamos un algoritmo de aprendizaje adaptivo se necesitan tantas memorias
como entradas tenga nuestra red, debido a que los procesos de fabricacin no son perfectos, existe
diferencia entre cada celda de memoria, ahora bien, este tipo de memoria se modifican con pulsos,
para aumentar la cantidad de electrones almacenados en la compuerta flotante debemos ingresar una
cierta cantidad de pulsos dependiendo del valor que deseamos almacenar, pero como lo
mencionamos, debido a la inexactitud del proceso de fabricacin entre las distintas celdas de
memoria una misma cantidad de pulsos no generan un mismo valor de actualizacin dentro de cada
una de las celdas. Esto provoca que los algoritmos implementados no funcionen de forma correcta.
Para solucionar el problema anterior se agrego a la memoria dos sub-circuitos adicionales los
cuales estn formados tambin con transistores de compuerta flotante [10]. De esta forma podemos
calibrar nuestras celdas de memorias de manera que se comporten de la misma forma. La figura 5.33
muestra la celda de memoria con estas modificaciones.
Figura N 5.32. Layout de Capacitor de 100[fF]
63
Figura N 5.33. Celda de memoria con circuitos de calibracin
El diseo de la celda de memoria con los circuitos de calibracin mostrados en la figura 4.33
(a) y (b), fueron obtenidos del paper [10], donde se demuestra el efecto de los circuitos de
calibracin en la implementacin del algoritmo LMS.
El funcionamiento bsico de esta nueva celda de memoria con circuitos de calibracin, es el
siguiente.
El sub-circuito (b) de la figura 5.33, es el encargado de ecualizar las tasas de Tunneling en
las distintas celdas de memoria, el aumento del voltaje FGdec incrementa el voltaje en el DRAIN y
reduce el voltaje en la juntura del GATE y Tnel del transistor M1, de esta manera incrementamos
la eficiencia de la inyeccin y reducimos la fuerza del Tunneling. Para ecualizar todas las celdas de
memoria primero se debe disminuir el voltaje FGdec, mediante la lnea Dec- de la figura 5.33 (b) y
posteriormente se procede a aumentar por separado el voltaje de FGdec de cada una de las celdas
por medio de la lnea Dec+, logrando ecualizar cada una de las celdas [10].
El sub-circuito (a) de la figura 5.33 se encarga de controlar la taza de inyeccin de las
distintas celdas de memoria, para esto se coloco una fuente de corriente formada por el transistor M
3
el cual controla la corriente que circula a travs del transistor M
1
logrando controlar la fuerza de la
64
inyeccin. La cantidad de corriente que circula por M
3
esta controlada por otro transistor de
compuerta flotante FGinc, la ecualizacin se realiza de la misma forma que para el sub-circuito (b),
disminuyendo todos los voltajes FGinc y aumentando por separado cada uno de los voltajes
mediante las lneas Dec- y Dec+ respectivamente.
A continuacin se muestra dos grficos obtenidos del paper [10] donde se demuestra el
efecto del circuito de calibracin en relacin al voltaje de actualizacin v/s cantidad de pulsos, para
8 celdas de memoria.
En la figura 5.34, se ve claramente que con circuito de calibracin se logra una misma
pendiente para las 8 celdas de memoria.
Figura N 5.34. Grficos de calibracin de celdas de memoria [10]. (a) Sin Circuito de Calibracin. (b) Con Circuito
de Calibracin.
65
Figura N 5.35. Esquemtico, celda de memoria con Circuitos de Calibracin.
Figura N 5.36. Sub-Circuito de compuerta Flotante
Despus de haber definido cada uno de los elementos de la memoria y sus respectivos
esquemticos se diseo el esquemtico y layout figuras 5.35 y 5.36, basados en la celda de memoria
con circuitos de calibracin, figura 5.33.
Dentro de la figura 5.35 vemos que existen tres iconos en forma de circulo con un triangulo
en el centro, estos iconos se crearon para poder realizar la simulacin SPICE una vez extrado el
netlist de la celda de memoria.
Los nodos FG, FGdec y FGinc no se encuentran conectados a ningn elemento que los asocie a la
tierra del circuito, es por esta razn que SPICE ve estos nodos como nodos flotantes lo cual genera
un problema para la simulacin. Para solucionar esto se creo un sub-circuito formado por una
resistencia y una fuente de voltaje controlada por voltaje, como muestra la figura 5.36. La resistencia
de este circuito de 100K impide la fuga de corriente a tierra de esta manera perdida de electrones en
la compuerta flotante es nula, adems el voltaje en la fuente es igual al voltaje que existe en el nodo
G de la figura 5.36, de esta manera se anulan los voltaje entre la resistencia y la fuente V(G).
66
Figura N 5.37. Layout, celda de memoria con circuitos de calibracin.
Para optimizar los espacios en la celda de layout se crearon 2 capacitores de 100 [fF] como
lo mencionamos anteriormente, la forma de los capacitores difiere de lo mostrado en la figura 5.33,
debido que al utiliza ese capacitor existiran muchos espacios no ocupados en la celda de memoria y
por ende aumentara innecesariamente el tamao de esta, es por esto que se vario la forma del
condensador manteniendo un rea de 2844,1 [
2
] lo cual equivale a 100 [fF] de capacitancia entre
poly1 y poly2.
67
5.6.5 Simulacin.
Las simulaciones obtenidas para las celdas de esquemtico y layout mostradas
anteriormente, las podemos ver en las figuras 5.38 y 5.39, respectivamente.
El circuito de esquemtico y layout se conectaron dos fuentes de pulsos las cuales
permitieron mostrar el fenmeno de inyeccin como Tunneling, de esta forma la salida de la
memoria (salida del amplificador) muestra un descenso en el voltaje de salida y posteriormente un
aumento en dicho voltaje, la tabla 5.1 muestra las variaciones de voltaje obtenida al aplicar 250
pulso de inyeccin y 250 pulsos de Tunneling.
Figura N 5.38. Esquemtico, Simulacin celda de memoria con circuitos de calibracin
Figura N 5.39. Layout, Simulacin celda de memoria con circuitos de calibracin.
68
Tabla 5.1. Resultados de las simulaciones de esquemtico y layout.
Estructura Esquemtico Layout
Voltaje Inicial 637.835 [mV] 1.11658 [V]
Voltaje Final 636.550 [mV] 1.11755 [V]
Diferencia
Inyeccin
-112.237 [mV] -106.997 [mV]
Diferencia
Tunneling
110.953 [mV] 107.972 [mV]
Pulsos
Inyeccin
250 250
Pulsos
Tunneling
250 250
De la tabla podemos ver que al generar 250 pulsos de inyeccin el voltaje de salida cae en -
112.237 [mV] en relacin a su voltaje inicial y al generar tunneling el voltaje aumenta en 110.953
[mV]. Al aplicar los mismos pulsos de voltaje tanto para la inyeccin como para el tunneling el
voltaje inicial de la salida de la memoria es casi idntico al voltaje final, las variaciones entre el
voltaje inicial y final se controlan utilizando los circuitos de calibracin.
69
5.7. CIRCUITO DIFERENCIAL.
Figura N 5.40. Circuito Diferencial.
Este circuito se creo debido al problema que se presenta en el multiplicador de gilbert
cuando los voltajes de entradas Vy+ y Vy- (figura 5.3) no se mueven en forma simtrica y adems
nuestra memoria tiene como salida un solo voltaje. Es por esto que se diseo un circuito cuya salida
de voltaje estuviera formada por un diferencial de voltaje y que el promedio de los cambios de
dichos voltajes fuera constante. Para esto se utilizo el circuito de la figura 5.40.
Los voltajes Vin y Vref de la figura 5.40 son los voltajes de entrada al circuito y los voltajes
Voutp y Voutm, representan los voltajes de salida, los cuales se mueven en forma simtrica, cuando
un voltaje aumenta el otro disminuye con la misma intensidad que aumento el otro, de esta manera
logramos un diferencial constante en la salida del circuito.
Para realizar el esquemtico final a partir de la figura 5.40 se debe considerar que cada
transistor es doble, exceptuando los transistores PM
1
y PM
3
; cada uno de los transistores esta
formado por dos transistores conectados en paralelo, de esta forma podemos reducir el tamao de
los transistores y ocupar menos espacio en el layout, as como disminuir la resistencia asociada a
ellos.
70
El diseo esquemtico y de layout obtenido a partir de la figura 5.40 son los siguientes:
Figura N 5.41. Circuito diferencial, esquemtico.
Figura N 5.42. Circuito diferencial, layout.
71
5.7.2 Simulacin.
Figura N 5.43. Simulacin circuito diferencial, esquemtico.
Figura N 5.44. Simulacin circuito diferencial, layout.
Para realizar la simulacin del esquemtico y de layout se hizo mediante un anlisis DC en el
cual variamos la entrada de 0 a 5 [V] y se mantuvo un voltaje en la referencia de 2.5 [V], los
resultados se muestran en las figuras 5.43 y 5.44.
Lo primero que se aprecia es el comportamiento similar tanto para curvas de esquemtico
como de layout. Como podemos ver que los voltajes Voutmy Voutp se mueven de la misma forma,
a medida que uno aumenta el otro disminuye y viceversa, generando un diferencial constante.
72
CAPITULO VI
6. HERRAMIENTAS DE ANLISIS DE MONTECARLO.
En los captulos anteriores se describieron todos los elementos que forman parte de nuestra
biblioteca, pero estos no consideran los defectos de fabricacin que sufren los distintos componentes
dentro del chip, as como tambin las variaciones que ah presente en los distintos modelos. Para
solucionar esta falencia nos vimos en la necesidad de crear funciones que manipulen el netlist
extrado de ELECTRIC permitiendo realizar un anlisis de montecarlo al circuito.
Se llama anlisis de montecarlo a todo algoritmo o funcin utilizada para analizar los
distintos efectos que sufrira un elemento, funcin, Algoritmo, etc. al estar expuesto a una variacin
aleatoria de sus caractersticas y parmetros. En nuestro caso, como se comportaran nuestros
circuitos al someterlos a cambios aleatorios, tanto a los parmetros que rigen los distintos modelos
como a los tamaos de los distintos elementos que componen el circuito.
Para realizar todas estas variaciones se disearon distintas funciones en matlab que operan
directamente sobre el netlist obtenido de ELECTRIC. Las funciones diseadas fueron las siguientes.
Genera_struct.
Agrega_modelos.
Escribir.
Asignacin_aleatoria.
Modifica_Size.
Buscar.
Agregar_SubCircuitos.
Asignacin_SubCircuitos.
Para realizar cada una de estas funciones se utilizaron funciones que matlab trae
incorporadas especializadas en el manejo de archivos y expresiones regulares (cadenas de caracteres
que define cierto patrn). Estas funciones se utilizan para buscar caracteres o cadenas de caracteres
dentro de un texto permitiendo modificar o remplazar este.
A continuacin describiremos el funcionamiento de las distintas funciones creadas y
finalmente aplicaremos dichas funciones a un netlist sencillo obtenido de ELECTRIC, verificando el
comportamiento de dicho circuito.
6.1. FUNCIN GENERA_STRUCT.
Lo primero que debemos analizar cuando deseamos intervenir sobre todos los elementos que
contiene un archivo netlist, es si en el archivo estn incluidos todos los elementos y modelos que
utiliza SPICE para la simulacin. En el caso de ELECTRIC, como ya lo habamos mencionado en el
capitulo 4.3 utiliza dos secciones donde el usuario puede incluir modelos o sub-circuitos que se
utilizaran para la generacin y simulacin del circuito, es por esto que lo primero que debemos hacer
antes de realizar nuestro anlisis de montecarlo sobre nuestro netlist, es asegurarnos que en el
archivo netlist estn escritos todos los modelos y sub-circuitos que se necesitan para la simulacin.
Es por esto que se crearon las tres primeras funciones genera_struct, agrega_modelos y escribir.
73
La funcin genera_struct se creo para analizar el netlist en busca de funciones SPICE tales
como .includey .lib, estas funciones SPICE se utilizan para incluir en el archivo netlist sub-circuitos
o modelos que se utilizan en el circuito de esta manera podemos reutilizar distintos modelos y sub-
circuitos sin necesidad de crearlos cada vez que creemos un circuito. En el caso del .include es
utilizado para incluir partes de modelos o sub-circuitos, el compilador SPICE lee el archivo
adjuntado por esta lnea e incluye todo el contenido de este archivo en el Netlist temporal que utiliza
para la simulacin. En el caso .lib, tambin se utiliza para incluir modelos as como sub-circuitos
con una pequea diferencia con el anterior, el compilador lee solo los modelos y sub-circuitos que
esta utilizando el circuito y con estos genera el netlist temporal, de esta manera el compilador utiliza
menos memoria. La forma general de estos dos comandos SPICE se muestra en 6.1.
.LIB C:\spice\common\bipolar.lib
.INCLUDE C:\spice files\wattmeter.cir.
( 6.1 )
La funcin genera_struct es una funcin recursiva, si dentro de un archivo .include existiera
otro, esta funcin se llama as misma hasta que encuentra todos los archivos relacionados. Su
funcionamiento es simple, el usuario pasa como parmetro el nombre del archivo netlist, si este esta
en el mismo directorio de la funcin o la ruta completa con el nombre del archivo donde se localiza
el netlist, posteriormente la funcin devuelve tres elementos: dos estructuras, la primera contiene
todos los modelos encontrados y la segunda contiene todos los sub-circuitos encontrados y un array
de caracteres con el nombre netlist_temporal, la cual contiene todo el archivo netlist que el usuario
entrego a la funcin, de esta forma el usuario puede tener el archivo en esta variable para realizar
cualquier modificacin sobre el. La forma de llamar a la funcin se muestra en 6.2.
[Modelos,SubCircuitos,Netlist_temporal]=Genera_Struct(Netlist) ( 6.2 )
Es importante mencionar la forma que esta constituida cada una de estas estructuras
generadas por esta funcin. En el caso de los modelos, cada modelo contiene un nombre, un tipo de
modelo y los parmetros del modelo, en la figura 6.1 (a) se muestra la forma como esta constituida
la estructura. Para los sub-circuitos, estos tienen tres campos fundamentales, el nombre del sub-
circuitos, los nodos de entrada al sub-circuitos y el contenido de este, en la figura 6.1 (b) se muestra
claramente la forma como esta constituida esta estructura.
Tabla 6.1. Descripcin de los parmetros de la funcin genera_struct.
Parmetro Tipo Funcin
Netlist Parmetro de entrada Nombre del archivo netlist que deseamos analizar.
Modelos Parmetro de salida Estructura que contiene todos los modelos encontrados
dentro del netlist.
SubCircuitos
Parmetro de salida Estructura que contiene todos los sub-circuitos
encontrados dentro del netlist.
Netlist_temporal
Parmetro de salida Variable que contiene un array de caracteres con el
netlist.
74
Figura N 6. 1. Estructuras para la funcin Genera_struct. (a) Distribucin de la estructura Modelos (b) Distribucin
de la estructura SubCircuito.
Tanto para la figura 6.1 (a) como para la (b) se muestra la forma como estn distribuidos los
campos en las estructuras seguido por un ejemplo. Aqu los nombre que estn entre parntesis
significan que puede variar, no as los que estn sin parntesis, lo mismo sucede para la estructura
SubCircuitos aqu los campos nodos y contenido son fijos, lo nico que puede variar es el nombre y
el contenido de nodos y contenido.
6.2. FUNCIN AGREGA_MODELOS.
Esta funcin se creo para modificar los parmetros dentro de la estructura llamada Modelos
que entrega la funcin genera_struct, adems permite agregar ms modelos dentro de esta estructura
a partir de los modelos existentes y adems permite variar el valor de los parmetros en forma
aleatoria con una desviacin estndar determinada.
De esta forma podemos crear distintos modelos a partir de los existentes y posteriormente
asignarlos a los distintos elementos que utilicen estos modelos dentro de nuestro circuito. Su forma
general es:
[Modelos,Nombres_generados] = agrega_modelos(Modelos_Cambiar,Modelos) ( 6.3 )
75
La tabla 6.2 describe cada uno de los parmetros y su funcin.
Para utilizar esta funcin el usuario debe crear una estructura que contenga el formato
mostrado por la figura 6.2 y pasarlo como parmetro a la funcin donde dice modelos_cambiar.
En la parte superior de la figura 6.2 se muestra la forma como debe ser generada la estructura
indicando la cual indica el tipo de parmetro cambiar y cuantos modelos generar. En la parte inferior
de esta figura vemos un ejemplo para esta estructura, aqu se crea una estructura con el nombre Tipo
en la cual indicamos el tipo modelo a buscar NMOS, con el nombre P, dado que cantidad es 4 se
crearan 4 modelos con los parmetros TNOM y VERSIN modificados en forma aleatoria con una
desviacin estndar de 0.1 y 1, respectivamente.
Tabla 6.2. Descripcin de los parmetros de la funcin agrega_modelos
Modelos_Cambiar Parmetro de entrada Estructura que contiene los nombres de los
modelos a cambiar, la cantidad de modelos a
generar y la desviacin estndar.
Modelos Parmetro de entrada Estructura que contiene todos los modelos
encontrados dentro del netlist, por la funcin
genera_struct.
Modelos
Parmetro de salida Estructura que contiene todos los modelos
generados a partir de la estructura
modelos_cambiar.
Nombres_generados
Parmetro de salida Array de caracteres con los nombres generados
por la funcin para los distintos modelos.
Figura N 6. 2. Distribucin de la estructura Modelos_Cambiar
76
6.3. FUNCIN ESCRIBIR.
Tabla 6.3. Descripcin de los parmetros de la funcin Escribir.
Netlist Parmetro de entrada Nombre del archivo netlist que se desea
modificar.
genera_struct y generados por la funcin
agrega_modelos.
SubCircuitos
Parmetro de entrada Estructura que contiene todos los sub-circuitos
genera_struct.
archivo_modificado
Parmetro de salida Nombre del archivo netlist que se genero a
partir de los modelos y sub-circuitos.
Esta funcin es la encargada de generar el netlist final el cual simularemos. La forma general
de llamar a esta funcin se presenta en (6.4).
La funcin se encarga de copiar el archivo tal cual se encuentra y elimina todos los .include y
.lib, que existieren en el netlist incluyendo los modelos y SubCircuitos en la parte donde se
encontraban estos comandos. La tabla 6.3 describe cada uno de los parmetros y su funcin.
archivo_modificado = Escribir(Netlist,Modelos,SubCircuitos) ( 6.4 )
Una caracterstica importante de esta funcin es que no necesariamente podemos generar el
netlist despus de utilizar la funcin agrega_modelos, sino que podemos usarla una vez encontrados
los modelos y sub-circuitos del netlist a travs de la funcin genera_struct. De esta forma
generaremos un nuevo netlist con estos elementos sin modificaciones o bien hacer nuestras propias
estructuras con modelos y sub-circuitos para este nuevo el netlist. El nombre del archivo modificado
no es el mismo que el del netlist, debido a que estaramos perdiendo el contenido de nuestro archivo
original, para ello generamos otro archivo que contiene el nombre del netlist original al cual se le
agrega la palabra _modificado, por ejemplo, si nuestro archivo netlist se llamaba Archivo.spi, el
archivo modificado se llamara Archivo_modificado.spi.
6.4. FUNCIN ASIGNACION_ALEATORIA.
Hasta el momento hemos construido funciones que modifican los modelos que ocupan los
circuitos y que generan un nuevo netlist a partir de los modelos modificados. Dado que ya contamos
con estas funciones, ahora lo que necesitamos asignar en forma aleatoria estos nuevos modelos a los
elementos que forman el nuevo netlist.
archivo_final=Asignacion_Aleatoria(Netlist,Modelos) ( 6.5 )
77
Tabla 6.4. Descripcin de los parmetros de la funcin Asignacin_aletoria.
Netlist
Parmetro de entrada
Nombre del archivo netlist que se desea
modificar.
Modelos
Parmetro de entrada
Estructura que contiene todos los modelos
genera_struct y generados por la funcin
agrega_modelos.
archivo_final Parmetro de salida
Nombre del archivo netlist que se genero a
partir de la asignacin en forma aleatoria de
estos modelos el cual contiene al final del
nombre la palabra _final y posteriormente su
extensin respectiva.
Esta funcin lee el tipo de modelo y busca donde esta el elemento que utiliza este modelo,
luego asigna un nombre aleatorio dentro de los que se generaron en la estructura de modelos
correspondiente al tipo de modelo y remplaza el nombre original por este. La bsqueda del elemento
en cuestin la realiza a travs de su letra inicial; dado que en SPICE [11] cada elemento tiene
asignado una letra inicial segn el modelo y tipo de elemento, por ejemplo todos los transistores del
tipo NMOS o PMOS comienzan con la letra M, de esta manera la funcin primero identifica la letra
que pertenece al tipo de modelo y posteriormente procede a buscar lnea por lnea dentro del archivo
netlist donde se encuentra el elemento que utiliza este modelo.
6.5. FUNCIN MODIFICA_SIZE.
Con las herramientas creadas hasta ahora podemos realizar un anlisis de montecarlo
variando en forma aleatoria los parmetros de los modelos y posteriormente asignarlos en forma
aleatoria a cada uno de los elementos que los utilicen.
Dentro de cada proceso existen errores en la fabricacin exacta de los tamaos de cada uno
de los elementos, as sean valores de resistencia, capacitancia, ancho de los transistores o de los
diodos, etc. cada elemento esta sujeto a este tipo de errores en el momento de la fabricacin. Es por
esto que creamos la funcin Modifica_size. Esta es la encargada de cambiar el tamao de cualquier
elemento dentro del netlist, por ejemplo si un transistor NMOS es diseado de un ancho de 2 [],
nosotros podemos asignarle un error de tamao en forma aleatoria con una desviacin estndar
determinada.
Su forma general es:
[archivo_modificado]=Modifica_size(Netlist,Tipos) ( 6.6 )
78
Tabla 6.5. Descripcin de los parmetros de la funcin Modifica_size.
Netlist Parmetro de entrada Nombre del archivo netlist que se desea
modificar.
Tipos Parmetro de entrada Estructura que contiene la letra inicial que
identifica el tipo de elemento que se desea
modificar, sea resistencia, capacitancia,
transistor, etc.
archivo_final
Parmetro de salida Nombre del archivo netlist que se genero a
partir de la modificacin en forma aleatoria de
los tamaos. El nombre generado contiene la
palabra _size al final del nombre original y
posteriormente su extensin.
Figura N 6.3. Distribucin de la estructura Tipos, funcin Modifica_size.
Dado que tipos es una estructura se requiere que el usuario cree esta estructura
identificando, que tipo de elemento desea modificar y con que desviacin estndar, para esto en la
figura 6.3 se muestra la forma de la estructura.
En la parte superior de la figura 6.3 se muestra la configuracin bsica de la estructura de
nombre Tipo, el primer campo seguido del nombre Tipo es variable, aqu va alojado la letra del
elemento que deseamos modificar, como en el ejemplo (figura 6.3 parte inferior) vemos que lleva el
letra M esto quiere decir que busque todos los transistores NMOS o PMOS y modifique su ancho W
y su largo L con una desviacin estndar de 0.1 y 0.5 respectivamente.
En el Anexo 2 se adjunto una tabla que muestra la primera letra que identifica cada elemento
dentro de un netlist.
79
6.6. FUNCIN BUSCAR.
TABLA 5.6. Descripcin de los parmetros de la funcin Buscar.
Netlist Parmetro de entrada Nombre del archivo netlist donde se desea
buscar.
encontrados por la funcin genera_struct.
SubCircuito Parmetro de entrada Estructura que contiene todos los sub-circuitos
encontrados por la funcin genera_struct.
Modelos Parmetro de salida Estructura que contiene todos los modelos
encontrados por la funcin genera_struct y los
encontrados por la funcin buscar.
SubCircuito Parmetro de salida Estructura que contiene todos los sub-circuitos
encontrados por la funcin genera_struct y los
encontrados por la funcin buscar.
Netlist_2
Parmetro de salida Variable que contiene el netlist completo, al
cual se han eliminado los modelos y sub-
circuitos que contena el netlist original.
En la creacin de un netlist generalmente se incluyen tanto modelos como sub-circuitos
dentro del netlist, sin necesidad de incluirlos en los .include o .lib, lo mismo sucede con los modelos
utilizados. Dado que nuestra funcin genera_struct, solo busca modelos y sub-circuitos en los
.include o .lib existentes en el circuito, creamos la funcin buscar cuya funcin es encontrar los sub-
circuitos y modelos dentro del netlist y agregarlos a los ya encontrados por la funcin genera_struct,
es una funcin complementaria que depende del usuario si la utiliza o no, ya que es l el que sabe si
existen modelos o sub-circuitos adicionales dentro del netlist, no se incluyo esta funcin dentro de la
funcin genera_struct para evitar una bsqueda innecesaria en caso que no existieran dichos
elementos.
[Modelos,SubCircuito,Netlist_2]=Buscar(Netlist,Modelos,SubCircuito) ( 6.7 )
La forma de las estructuras que se deben pasar a esta funcin son las mismas mencionadas en
la funcin genera_struct.
6.7. FUNCIN AGREGAR_SUBCIRCUITOS.
Unas de las caractersticas de ELECTRIC dentro de la creacin de circuitos es la capacidad
de utilizar celdas dentro de otras celdas, lo que es reflejado en la extraccin del netlist como un sub-
circuito. Un sub-circuito no es ms que una celda que podemos reutilizar dentro de nuestro netlist
sin necesidad de estar creando este circuito. En nuestro caso esto representa un problema cuando
hablamos de analizar el funcionamiento de un circuito a la variacin de parmetros ya que, por
ejemplo la memoria, se debe utilizar en muchas ocasiones, pero como esta es un sub-circuito cada
memoria que se utilizara dentro del circuito final ser la misma lo que no permitira tener distintas
memorias con distintos tamaos, al menos claro esta, que se crearan distintas memorias en la
80
biblioteca, lo que resultara contraproducente. Es por esto que creamos la funcin agrega sub-
circuitos la cual es la encargada de duplicar cuantas veces sea necesario los sub-circuitos que
indique el usuario.
[SubCircuitos_modificados] = agrega_SubCircuitos(cantidad,SubCircuitos) ( 6.8 )
En esta funcin existe una pequea variacin en la forma de la estructura que devuelve esta
funcin, la cual esta estructurada de la siguiente manera.
La forma de esta estructura se diseo pensando en la funcin encargada de la asignacin de
los distintos sub-circuitos dentro del netlist, de esta manera el primer campo de la estructura indica
el nombre original del sub-circuito y con el cual se debe buscar y el segundo campo contiene todos
los nombres alternativos para este sub-circuito.
Tabla 6.6. Descripcin de los parmetros de la funcin agrega_subcircuitos.
cantidad Parmetro de
entrada
Cantidad de sub-circuitos que se desea crear
por cada sub-circuito que se ingrese a la
funcin.
SubCircuito Parmetro de
entrada
Estructura que contiene todos los sub-circuitos
que se desean duplicar.
SubCircuitos_modificados
Parmetro de salida Estructura que contiene todos los sub-circuitos
duplicados.
Figura N 6.4. Distribucin de la estructura Tipos, funcin Agrega_subcircuitos.
81
6.8. FUNCIN ASIGNACIN_SUBCIRCUITOS.
Tabla 6.7. Descripcin de los parmetros de la funcin asignacion_SubCircuitos.
Netlist Parmetro de entrada Nombre del netlist al cual se desean asignarles
sub-circuitos en forma aleatoria.
SubCircuito Parmetro de entrada Estructura que contiene todos los sub-circuitos
que se desean asignar.
archivo_final
Parmetro de salida Nombre del archivo final, el cual contiene los
sub-circuitos asignados.
Como su nombre lo indica esta funcin es la encargada de buscar dentro del netlist los
nombres de los sub-circuitos que son utilizados y ver si existen sub-circuitos con dichos nombres
dentro de la estructura que se pasa como parmetro a la funcin y posteriormente asignarlo dichos
nombres en forma aleatoria.
archivo_final=Asignacion_SubCircuitos(Netlist,SubCircuitos) ( 6.9 )
Dentro de los modelos SPICE [11] la letra X al comienzo de cada lnea dentro del netlist
indica que el elemento en esa lnea es un sub-circuito. Mediante esta caracterstica la funcin busca
esta letra y posteriormente el nombre de sub-circuito que esta asignado a esa lnea, el nombre del
sub-circuito se encuentra al final, sino al final de la siguiente lnea. Considerando que cuando los
nodos de un sub-circuitos son demasiados estos continan en la siguiente lnea, en SPICE la
continuacin de una lnea es identificada por el signo + como primera carcter de una lnea dentro
del netlist, mediante esto nuestra funcin busca el fin de los nodos del sub-circuito y luego el
nombre de este.
En el Anexo 3 (a-h) se adjunta el cdigo completo realizado en matlab de cada una de las
siete funciones antes mencionadas.
6.9. SIMULACIN DE UN NETLIST BAJO ANLISIS DE MONTECARLO.
Una vez descrita cada una de las funciones se realizo un anlisis de montecarlo a un pequeo
circuito formado por NOT como se muestra en la figura 6.4.
Este circuito se modifico en forma aleatoria sus parmetros de temperatura y voltaje umbral
para ambos modelos (NMOS y PMOS), adems se modifico en forma aleatoria sus tamaos con una
pequea desviacin estndar y se realizo un anlisis DC de dicho circuito para ver su
comportamiento.
82
Figura N 6.5. Esquemtico de NOTs para anlisis de montecarlo.
El netlist original obtenido del circuito mostrado en la figura 5.5 (sin modificaciones) se
muestra a continuacin.
*** SPICE deck for cell note{sch} from library noname
*** Created on dom may 21, 2006 19:34:19
*** Last revised on dom may 21, 2006 19:40:48
*** Written on dom may 21, 2006 19:48:14 by Electric VLSI Design System,
*version 8.03
*** UC SPICE *** , MIN_RESIST 4.0, MIN_CAPAC 0.1FF
.OPTIONS NOMOD NOPAGE
* Model cards are described in this file:
.include D:\RESPALDO\Mis Documentos\Temp\models.sp
*** TOP LEVEL CELL: note{sch}
MN1 Out1 In gnd gnd N L=0.4U W=0.6U
MP1 vdd In Out1 vdd P L=0.8U W=1.2U
.DC Vin 0 3.3 0.01
VPower vdd gnd DC 4V
Vin In gnd DC 0V
* Trailer cards are described in this file:
.END
83
Figura N 6.6. Anlisis DC de NOTs sin modificaciones
Mediante el netlist mostrado anteriormente se generaron las cuatro curvas de transferencia
DC sin modificaciones, los resultados se muestran en la figura 6.6.
Se realizaron dos pruebas con el siguiente cdigo matlab:
clear all
clc
Netlist='note.spi'
Tipos=struct();
Tipos.PMOS.P.Cantidad=4;
Tipos.PMOS.P.VTH0=0.5
Tipos.PMOS.P.TNOM=0.1;
Tipos.NMOS.N.Cantidad=4;
Tipos.NMOS.N.VTH0=0.5
Tipos.NMOS.N.TNOM=0.8;
Modifica.M.W=0.08;
Modifica.M.L=0.05;
[Modelos,SubCircuitos,Netlist_temporal] = Genera_Struct(Netlist)
[Modelos_midificados,Nombres_generados] = agrega_modelos(Tipos,Modelos)
archivo_modificado = Escribir(Netlist,Modelos_midificados,SubCircuitos)
archivo_modificado = Asignacion_Aleatoria(archivo_modificado,Modelos_midificados)
archivo_modificado = Modifica_Size(archivo_modificado,Modifica)
84
A travs de este cdigo se realizaron dos prueba la primera con el cdigo mostrado
anteriormente, y la segunda cambiando la desviacin estndar del valor aleatorio de la temperatura
de operacin (TNOM) para el transistor PMOS a 0.5.
Como se muestra en cdigo matlab primero se crean dos estructura llamada Tipos y
Modifica, la primera es utilizada para cambiar los valores de los parmetros en los modelos
utilizados y la segunda se utiliza para cambiar el valor de los ancho y largo de los transistores que
existieran en el circuito.
Uno de los netlist utilizados se muestra a continuacin.
*** SPICE deck for cell note{sch} from library noname
*** Created on dom may 21, 2006 19:34:19
*** Last revised on dom may 21, 2006 19:40:48
*** Written on dom may 21, 2006 19:48:14 by Electric VLSI Design System,
*version 8.03
*** UC SPICE *** , MIN_RESIST 4.0, MIN_CAPAC 0.1FF
.OPTIONS NOMOD NOPAGE
* Model cards are described in this file:
** *******************************************
** **********MODELOS A UTILIZAR***************
.MODEL N NMOS(LEVEL = 49
+ VERSION = 3.1 TNOM = 27.0605 TOX = 7.8e-009
+ XJ = 1e-007 NCH = 220000000000000000 VTH0 = 0.68971 K1 = 0.59397
+ K2 = 0.0081007 K3 = 100 K3B = -8.3133 W0 = 2.8605e-005
+ PRDSW = -97.0588 PK2 = 0.0040021 WKETA = -0.0016946 LKETA = -0.0010853)
*
.MODEL N1 NMOS(LEVEL = 49
+ XJ = 1e-007 NCH = 220000000000000000 VTH0 = 1.1361 K1 = 0.59397
*
+ XJ = 1e-007 NCH = 220000000000000000 VTH0 = 0.8171 K1 = 0.59397
*
+ XJ = 1e-007 NCH = 220000000000000000 VTH0 = 0.80589 K1 = 0.59397
*
.MODEL P PMOS(LEVEL = 49
+ XJ = 1e-007 NCH = 85200000000000000 VTH0 = -0.25222 K1 = 0.43192
+ PRDSW = 62.7439 PK2 = 0.0019812 WKETA = 0.0036759 LKETA = -0.0037934)
*
.MODEL P1 PMOS(LEVEL = 49
+ XJ = 1e-007 NCH = 85200000000000000 VTH0 = -0.13257 K1 = 0.43192
*
+ XJ = 1e-007 NCH = 85200000000000000 VTH0 = -0.21303 K1 = 0.43192
*
*
+ XJ = 1e-007 NCH = 85200000000000000 VTH0 = -0.15678 K1 = 0.43192
** ******FIN DE MODELOS A UTILIZAR***********
*** TOP LEVEL CELL: note{sch}
MN1 Out1 In gnd gnd N2 L=0.4356U W=0.66525U
MP1 vdd In Out1 vdd P1 L=0.81287U W=1.0717U
.DC Vin 0 3.3 0.01
VPower vdd gnd DC 4V
Vin In gnd DC 0V
* Trailer cards are described in this file:
.END
85
Por razones de espacio y dado que no es necesario mostrar, se quitaron parmetros a cada
uno de los modelos generados. Como se aprecia en cada uno de los modelos tanto para PMOS como
NMOS los parmetros TNOM y TVH0 estn modificados con valores aleatorios, adems vemos que
los tamaos de los transistores varan claramente de los mostrados del netlist original, adems se
asigno en forma aleatoria cada uno de los modelos a los distintos transistores. Los resultados
obtenidos para cada una de las pruebas se muestran en la figura 6.7.
De los grficos obtenidos a partir de un mismo circuito sometido a distintos cambios de
parmetros a travs de las funciones hechas para anlisis de montecarlo nos damos cuenta
claramente que bajo distintas condiciones un circuito puede variar drsticamente su operacin.
Figura N 6.7. Anlisis DC de NOTs con modificaciones
86
CAPITULO VII
7. IMPLEMENTACIN DE ALGORITMOS DE PROCESAMIENTO ADAPTIVO DE
SEALES, UTILIZANDO BIBLIOTECA DISEADA.
Figura N 7.1. Neurona de Cuatro entradas actualizada con Tren de Pulsos.
Despus de haber analizado los algoritmo bsicos que son utilizados en procesamiento
adaptivo de de seales en VLSI, haber mostrado el funcionamiento de la tecnologa detrs del
transistor de compuerta flotante, analizado las herramientas que se utilizaron para crear la biblioteca
descrita en esta memoria y finalmente haber construido todas las partes que conforman dicha
biblioteca de VLSI junto con las funciones necesarias para realizar un buen anlisis de montecarlo
nos disponemos a mostrar el funcionamiento de estas herramienta realizando una neurona de cuatro
entradas actualizada por pulsos.
Para llevar a cabo esta implementacin tomaremos la red mostrada en la figura 6.1, la cual muestra
una neurona de 4 entradas.
Como se muestra en la figura 7.1 para implementar esta red de 4 entradas necesitaremos,
cuatro memorias, cuatro multiplicadores y un sumador. A partir de esta figura construiremos nuestro
esquemtico, posteriormente realizaremos el layout y finalmente simularemos dichos circuitos
mostrando el resultado final de la implementacin de esta biblioteca.
87
7.1. CONSTRUCCIN DEL ESQUEMTICO Y LAYOUT.
Figura N 7.2. Sinapsis de la primera entrada, esquemtico
El esquemtico obtenido tomando como modelo de neurona mostrada en la figura 6.1, esta
constituido por cuatro sinapsis, cada una de ellas contiene:
Una memoria.
Un Circuito diferencial.
Un multiplicador de Gilbert.
Como anteriormente lo habamos mencionado el sumador mostrado en la figura 7.1 se implementa
fcilmente en circuitos anlogos mediante la unin de las lneas de salida de cada uno de los
multiplicadores, de esta forma construimos un nodo en el cual la corriente de salida de un nodo es
igual a la sumatoria de las corriente de entrada a este (Ley de Kirchhoff).
La figura 7.2 muestra la sinapsis de la primera entrada que esta constituida de izquierda a
derecha por: una memoria, circuito diferencial y un multiplicador. Cada una de las cuatro sinapsis de
la neurona esta constituida por este mismo esquema de circuitos, es por esto que no se mostr la red
completa. Como lo mencionamos cada una de las salidas Vout+mostrada en la figura son unidas
para formar el sumador, de la misma forma las salidas Vout-, adems podemos apreciar que la
entrada X
1
se constituye mediante un diferencial de dos entradas VX1+y VX1-, estas son conectadas
directamente a la entrada superior del multiplicador (circuito del lado derecho de la figura 7.2).
Despus de haber diseado nuestro esquemtico procedemos a disear la parte de layout de
dicho esquemtico. El resultado final de nuestro layout se muestra claramente en la figura 7.3, de la
misma forma que se hizo para el esquemtico este layout esta conformado por los tres circuitos.
88
Figura N 7.3. Sinapsis de la primera entrada, layout
El diseo de layout de los tres componentes que conforman la sinapsis (memoria, circuito
diferencial y multiplicador) se hizo pensando en un mismo ancho para los tres, de esta manera al
unir los tres circuitos no quedan espacios libres que aumentaran innecesariamente el tamao de la
celda. Adems si deseamos disear una red de mas de 4 entradas nicamente tenemos que copiar
este circuito cuantas veces lo necesitemos, en la figura 7.4 se muestra el diseo final de layout de
nuestra neurona de 4 entradas en el cual todas las entradas se encuentran a la izquierda del circuito y
la salida de la neurona se encuentra a la derecha.
Como se muestra en este layout el ruteo interno se realizo en metal 1 y metal dos (celeste y
magenta), y las uniones superiores se realizaron en metal 3, amarillo.
89
Figura N 7.4. Layout red neuronal de cuatro entradas
90
7.2. SIMULACIONES.
7.2.1 Simulacin de red neuronal de cuatro entradas.
Figura N 7. 5. Simulacin red neuronal de cuatro entradas, esquemtico.
Figura N 7.6. Simulacin red neuronal de cuatro entradas, layout.
Para realizar la simulacin de la neurona de cuatro entradas sometimos la red a pulsos de
actualizacin y posteriormente fue sometida a cuatro entradas sinusoidales de distinta frecuencia.
Los resultados obtenidos se muestran en las figuras 7.5 y 7.6.
91
De las figuras 7.5 y 7.6 apreciamos claramente que despus de someter nuestra red a distintos pulsos
de actualizacin, estos logran valores determinados de voltajes segn la combinacin de pulsos de
Tunneling e inyeccin. Durante este proceso la salida de la red se mantiene en 0 [V] dado que las
entradas se encuentran en 0 [V], lo que nos comprueba que nuestro multiplicador esta funcionado de
forma correcta, al ver que la sumatoria de los
n n
W X es cero.
7.2.2 Simulacin sin calibracin de la memoria.
Como lo habamos mencionado en el capitulo 5.6 el modelo de memoria que
implementamos cuenta con dos circuitos adicionales, los cuales se utilizan para calibrar la memoria.
Esto se debe principalmente a la variacin que se genera despus del proceso de fabricacin, tanto
en el tamao de los transistores que existen entre las distintas celdas de memoria, as como la
variacin en los distintos parmetros del modelo de transistor de cada uno de ellos.
Para reproducir este fenmeno utilizaremos las herramientas de anlisis de montecarlo
creadas y explicadas en el capitulo 6. Lo primero que haremos es tomar el modelo de memoria que
se utilizo para la simulacin mostrada en las figuras 5.35 y 5.37 y agregar el circuito diferencial,
tanto en el layout como esquemtico, creando los circuitos de las figuras 7.7 y 7.8, posteriormente
simularlo y analizar lo sucedido.
Figura N 7.7. Simulacin esquemtico memoria y diferencial.
Figura N 7.8. Simulacin layout memoria y diferencial.
92
Figura N 7.9. Simulacin memoria y diferencial.
Para realizar la simulacin se crearon dos memorias como las mostradas en las figuras 7.7 y
7.8, y se sometieron a la misma cantidad de pulsos de inyeccin y de Tunneling. El resultado sin
variar sus parmetros se muestra en la figura 7.9.
La figura 7.9 muestra la salida del diferencial al someter las dos memorias a 250 pulsos de
Tunneling y 250 pulsos de inyeccin. Como podemos ver dado que las memorias estn sometidas a
los mismos voltajes y no existe ningn parmetro distinto dentro del modelo que utilizan los
transistores, adems no hay ningn cambio en el tamao de los transistores que diferencie estas dos
memorias, como era de esperar los delta generados por los pulsos de Tunneling e inyeccin son
idnticos, tanto para la memoria N 1 como para la memoria N 2. Esto implicara que los circuitos
de calibracin fueran innecesarios; esto sucedi tanto en la simulacin del circuito de layout como
para la simulacin en el circuito esquemtico.
En los procesos de fabricacin no es posible obtener dos memorias idnticamente iguales
como lo mostrado anteriormente, debido a esto la misma cantidad de pulsos de Tunneling no
provoca el mismo delta entre las distintas memorias, de la misma forma sucede con los pulsos de
inyeccin, es por esto que se necesitan calibrar cada una estas memorias.
Para realizar nuestro proceso de calibracin de estas dos memorias, lo primero que debemos
hacer es modificar los parmetros y modelos de los transistores para obtener deltas distintos, y
someter las memorias a las mismas condiciones de voltajes de entradas de manera de reproducir el
fenmeno mencionado.
Sometimos el netlist utilizado para realizar la simulacin mostrada en la figura7.9 a los
distintos algoritmos diseados anteriormente, variando tanto el modelo de los transistores como los
93
tamaos de estos. En la figura 7.10 se muestran los resultados obtenidos de las simulaciones despus
de someter el netlist a estos cambios.
Figura N 7.10. Simulacin memoria y diferencial con cambios de tamaos, sin calibracin.
Tabla 7.1. Resultados de las simulaciones memoria y diferencial.
Estructura Memoria N1 Memoria N2
Pulsos Inyeccin 250 250
Pulsos Tunneling 250 250
Voltaje Inicial salida del diferencial 323.211 [mV] 301.935 [mV]
Voltaje Final salida del diferencial 409.983 [mV] 269.311 [mV]
Diferencia Inyeccin -41.7306 [mV] -150.345 [mV]
Diferencia Tunneling 128.502 [mV] 117.721 [mV]
Delta inyeccin salida del amplificador -48.6493 [mV] -189.199 [mV]
Delta Tunneling salida del amplificador 153.209 [mV] 143.529 [mV]
De la simulacin mostrada en la figura 7.10 obtuvimos la siguiente tabla de datos, la cual
muestra los valores de voltaje de las distintas etapas de la simulacin.
Despus de haber sometido nuestro circuito a la variacin de parmetros en forma aleatoria a travs
de montecarlo, vemos claramente en la tabla 7.1 que se obtuvieron respuestas diferentes en los
deltas de voltaje tanto en la salida del circuito diferencial como en la salida del amplificador
operacional contenido en la memoria, adems se aprecia, dada la cantidad de transistores
involucrados en el circuito diferencial y al ser sometidos a cambios aleatorios en los tamaos y
parmetros de estos que cada uno de los deltas de voltaje presente en la entrada del circuito no son
reflejados en forma simtrica a la salida de este.
7.2.3 Simulacin con calibracin y anlisis de montecarlo sobre la memoria.
94
La variacin de parmetros producida netlist mostrada en la figura 7.10 y verificada en la
tabla 7.1, demuestra las diferencias en los voltajes podramos obtener en el proceso de fabricacin
de un chip, es por esto que debemos utilizar los circuitos de calibracin de la celda de memoria para
lograra que tanto los delta de inyeccin como los de Tunneling sean iguales bajo la misma cantidad
de pulsos.
Despus de llevar a cabo la calibracin se obtuvieron los siguientes resultados:
Figura N 7.11. Simulacin memoria y diferencial con cambios de tamaos, con calibracin.
Figura N 7.12. Evolucin de cada una de las compuertas flotantes del circuito
95
Como se muestra en la figura 7.11 despus de calibrar las distintas compuertas flotantes de
nuestro circuito, se logro igualar tanto los deltas de Tunneling como los de inyeccin mostrados en
la figura 7.10. La calibracin se llevo a cabo a travs de los siguientes pasos.
Se aumento la pendiente en la memoria 1, de manera igualamos la pendiente de inyeccin de
la memoria 2. Estos se llevo acabo aumento la corriente que circula por el transistor de
inyeccin, para esto se aplicaron pulsos de Tunneling para disminuir el voltaje FGinc1 de
esta manera aumentamos la corriente que circula por el transistor de inyeccin principal de la
memoria 1, en la figura 7.12 se demuestra la disminucin del voltaje FGinc1.
Se disminuyo la pendiente de inyeccin de la memoria 2 para equiparar las dos memorias.
Para esto disminuimos la corriente que circula por el transistor de inyeccin de la memoria
dos aumentando el voltaje FGinc2, parte inferior figura 7.12.
Para igualar los dos deltas de las memorias 1 y 2, disminuimos el voltaje FGdec2, a travs de
pulsos de inyeccin en el circuito de calibracin 2.
Los datos finales obtenidos de la figura 7.11, se muestran en la tabla 7.2. Si bien los
resultados no fueron exactos son casi iguales, con una diferencia de 1 [mV] entre el delta de
inyeccin entre las dos memorias, lo cual es aceptable, el resto de los resultados demuestra
diferencias del orden de los V, lo cual es bueno.
Tabla 7.2. Resultados de las simulaciones memoria y diferencial despus de la calibracin.
Estructura Memoria N1 Memoria N2
Voltaje Inicial salida del diferencial 323.211 [mV] 301.935 [mV]
Voltaje Final salida del diferencial 323,721 [mV] 302,025 [mV]
Diferencia Inyeccin -118.472 [mV] -117.635 [mV]
Diferencia Tunneling 117.982 [mV] 117.725 [mV]
Delta inyeccin salida del amplificador -143.99 [mV] -143.404 [mV]
Delta Tunneling salida del amplificador 143.373 [mV] 143.523 [mV]
96
8. CONCLUSIN
8.1. CONCLUSIONES
Durante el desarrollo de esta memoria de titulo se logro identificar y describir el
funcionamiento de cada uno de los elementos que componen los algoritmos de procesamiento
adaptivo de seales, LMS y GHA.
Aqu logramos apreciar la simplicidad de loas ecuaciones que conforman el algoritmo LMS,
la cual nos permite una fcil implementacin en hardware. El algoritmo GHA por otro lado, nos
presenta un nivel un poco mas complejo en el diseo de hardware, pero no es una traba para le
diseo, debido a que el tipo de elementos requeridos para su implementacin es el mismo que se
utiliza en LMS.
Se describieron en forma clara y concisa los programas que se necesitan para la utilizar la
biblioteca diseada mostrando sus virtudes, defectos y demostrando que se complementan
mutuamente en la implementacin y simulacin de circuitos en VLSI.
Si bien el diseo de la biblioteca qued condicionado a la utilizacin de ELECTRIC, no
ocurre lo mismo con el programa que se utilice para la simulacin, permitindonos de esta forma
buscar y probar distintos programas de simulacin SPICE que nos permitan disminuir el tiempo que
ser requiere para la simulacin de circuitos.
Se ha logrado disear y demostrar la funcionalidad de la biblioteca, mediante las
simulaciones de cada uno de los elementos que la componen. Adems se lograron crear las
funciones necesarias para genera las variaciones en los tamaos de los transistores y los parmetros
de los modelos. De esta manera, podemos contra con una herramienta que permita acocarnos cada
vez mas a las variaciones generadas en los procesos de fabricacin de un circuito e implementarlas
en nuestras simulaciones.
A travs de las distintas pruebas que se realizaron a los circuitos diseados utilizando las
funciones creadas en Matlab, nos dimos cuenta la importancia de contar con este tipo de
herramientas. Las cuales nos muestran de manera ms clara y concisa el funcionamiento real de los
circuitos, al estar expuestos a variaciones en sus parmetros. De esta forma el diseador puede ver el
tipo de problemas que se podran llegar a presentar y generar soluciones en forma anticipada a
dichos problemas.
Finalmente logramos demostrar el funcionamiento de todas las herramientas creadas tanto en
ELECTRIC como en Matlab, lo que nos permiten llevar a buen puerto el diseo de algoritmo de
procesamiento adaptivo de seales.
Despus de haber enfrentado los distintos problemas e interrogantes, junto con haber
analizado la tecnologa y mtodos de diseo presente en esta nueva rea dentro de nuestra carrera, la
cual nos abre un universo lleno de posibilidades dentro del diseo de VLSI anlogo, podemos
concluir que sen logrado los objetivos impuesto.
Todos los elementos diseados en esta biblioteca quedaron almacenados en el archivo de
nombre Biblioteca_VLSI, con extensin elib. Para poder utilizar dicha biblioteca en otro
software, es necesario verificar que este lea este tipo de extensin y adems debe soportar el diseo
escalable. La utilizacin de la biblioteca en ELECTRIC es sencilla, solo se debe cargar el archivo y
automticamente queda lista para ser utilizada.
97
Durante las simulaciones con el software LTSpice, nos dimos cuenta que es propenso a
generar errores de simulacin. Esto se debe, a las ecuaciones utilizadas en el diseo de las fuentes de
corriente. El software utiliza una matemtica muy rudimentaria para el clculo de las condiciones
iniciales de los circuitos, as como tambin durante la simulacin. Debido a esto es muy importante
fijar de manera correcta las condiciones iniciales dentro del circuito, de esta forma evitaremos lo
anterior.
Dentro del diseo de las distintas celdas de layout que componen la biblioteca, se tomo
especial cuidado en el ruteo interno de las celdas. Este debe ser realizado en metal1 y metal2,
dejando metal 3 y metal4 para ser utilizado en la unin de las distintas celdas. De esta forma nos
aseguramos de no provocar cortocircuitos en la unin de dos o ms celdas.
8.2. TRABAJOS FUTUROS
En este trabajo guardan cimentadas las bases para seguir diseado elementos que completen
cada vez ms esta biblioteca y de esta manera permitir la posibilidad de crear diferentes algoritmos
de procesamiento adaptivo de seales en VLSI anlogo, como anlisis de componentes
independientes (ICA) o redes de decorrelacion, entre otras. Se debe hacer un estudio acabado de los
distintos algoritmos identificando claramente su funcionamiento del punto de vista circuital y los
elementos que se necesitaran para su implementacin en VLSI.
Dentro del diseo VLSI para algunos algoritmos es necesario contar con multiplicadores de
pulsos, es por esto que queda como tarea disear este tipo de multiplicadores.
Dado que el condensador que se dise en layout es de 100 [fF], queda como tarea disear
distintos condensadores segn la capacidad que se requiera para futuros diseos.
El manejo automtico de los tamaos en los distintos elementes que componen las celdas de
layout es bastante limitado. Es importante mencionar que el transistor de tunneling fue diseado
para un ancho de 1.2 [] y un largo de 0.8 []. En el cado del transistor de inyeccin este fue
diseado para un ancho de 1 [] y un largo de 1 []. Debido a tipo de memorias que se utilice en un
futuro, el diseador deber agregar otros transistores de tunneling e inyeccin segn corresponda su
necesidad. No as para el diseo de esquemtico, ya que como lo habamos mencionado al pasar los
parmetros de ancho y largo de la celda, esta automticamente cambia de tamao los transistores, no
as en el diseo de layout, donde el diseador debe modificar manualmente dichos transistores.
98
9. REFERENCIAS
[1] B. Widrow and M. Lehr, 30Years of Adaptive Neuronal Networks: Perceptron, Madaline,
and Backpropagation, Proceeding of the IEEE, vol. 78, no. 9, 1990.
[2] C. Diorio, D. Hsu and M. Figueroa, Adaptive CMOS: From Biological Inspiration to
Systems-on-a-Chip, Proceeding of the IEEE, vol. 90, no. 3, pp. 345-347, 2002.
[3] http://mosis.org/Technical/Testdata/tsmc-035-prm.html.
[4] http://www.staticfreesoft.com/index.html.
[5] S. Haykin, Neural Networks a comprehensive foundation, Prentice Hall, 1999.
[6] K. Rahimi, C. Diorio, C. Hernandez, C. Brockhausen, A simulation model for floating-
gate MOS synapse transistors, Proceedings of the IEEE, vol. 2, 2002.
[7] M. Figueroa, S. Bridges, A 19.2 GOPS Mixed-Signal Filter With Floating-Gate
Adaptation, Proceeding of the IEEE, vol. 39, no. 7, 2004.
[8] A. Sharon, A. Zentner, Z. Sharvit and Y. Goldberg VLSI Work Gilbert Multiplier,
School of Engineering and Computer Science, The Hebrew University, Jerusalem.
[9] P. E. Allen and D. R. Holberg, CMOS Analog Cuircuit Design, Oxford University Press,
2002.
[10] M. Figueroa, S. Bridges and C. Diorio, On- Chip Compensation of Divece-Mismathch
Effects in Analog VLSI Neural Network, University of Washington, 2004.
[11] WinSpice3 Users Manual. 5 January, 2006. Mike Smith. Copyright2003 Mike Smith.
[12] M. Lenzlinger and E. H. Snow, Fowler-Nordheim tunneling into thermally grown SiO
2
,
J. of Applied Phys., vol. 40, no. 6, 1969.
[13] R. Brause, J. W, A VLSI-Design of the minimum entropy neuron, Goethe-University,
Frankfurt a. M., Alemania.
[14] K. I. Diamantaras, Principal Component Neural Networks Theory and Applications,
Aristotly University Thessaloniki.
[15] D. T. M. Slock, On the Convergence Behavior of the LMS and Normalized LMS
Algorithms, Proceedings of the IEEE, vol. 41, no. 9, 1993.
[16] B. Widrow, J. M. McCool, M. G. Larimore and C. R. Johnson, Stationary and
Nonstationary Learning Characteristics of the LMS adaptive Filter , Proceedings of the
IEEE, vol. 64, no. 8, 1978.
[17] S. Fiori, An Experimental Comparison of Three PCA Neural Networks, Dept. of
Electronics and Automatics, University of Ancona, Ancona, Italy.
[18] J. Killens, Utilizing Standard CMOS Process Floating Gate Devices for Analog Design,
Mississippi State University, 2001.
[19] S. C. Douglas and T. Meng, Normalized Data Nonlinearities for LMS Adaptation, IEEE
Transactions on Signal Processing, vol. 42, no. 6, 1994.
99
10. ANEXOS.
10.1. ANEXO 1: REGLAS PARA CAPACITOR POLY1-POLY2.
SCMOS Layout Rules - Poly2 for Capacitor
The poly2 layer is a second polysilicon layer (physically above the standard, or first, poly layer).
The oxide between the two polys is the capacitor dielectric. The capacitor area is the area of
coincident poly and electrode.
Lambda
Rule Description
SCMOS SUBM DEEP
11.1 Minimum width 3
1
7
2
n/a
11.2 Minimum spacing 3
3
3
4
n/a
11.3 Minimum poly overlap 2
5
5
6
n/a
11.4
Minimum spacing to active or well edge
(not illustrated)
2 2 n/a
11.5 Minimum spacing to poly contact 3 6 n/a
11.6 Minimum spacing to unrelated metal 2 2 n/a
Exceptions for AMIS C30 0.35 micron process:
1
Use lambda=8 for rule 11.1 only when using SCN4ME
2
Use lambda=10 for rule 11.1 only when using SCN4ME_SUBM
3
4
5
6
100
10.2. ANEXO 2: TABLA DE IDENTIFICACIN DE ELEMENTOS DENTRO DE UN NETLIST
Letter Description
R Resistor
C Capacitor
L Inductor
K Coupled inductor
S Voltage-controlled switch
W Current-controlled switch
I Independent current source
G Linear voltage-controlled current source
E Linear and non-linear voltage-controlled voltage
source
F Linear and non-linear current-controlled current
source
H Linear current-controlled voltage source
B Non-linear dependent voltage or current source
T Lossless transmission line
O Lossy transmission line
U Uniform distributed RC transmission lines
D Diode
Q Bipolar Junction Transistor (BJT)
J Junction Field-Effect Transistor (JFET)
M MOSFET
Z MESFET
10.3. ANEXO 3: FUNCIONES PARA ANLISIS DE MONTECARLO.
10.3.1 Anexo 3(a): Funcin Genera_struct.
function [Modelos,SubCircuitos,Netlist_temporal]=Genera_Struct(Netlist)
extension = Netlist(findstr(Netlist,'.'):end);
nombre_archivo = Netlist(1:findstr(Netlist,'.')-1);
puntero_Netlist=fopen(Netlist);
SubCircuitos=0;
101
Modelos=0;
Netlist_temporal='';
%=========================GENERACION DE MODELOS Y ESTRUCTURAS ======================
while ~feof(puntero_Netlist)
linea_netlist=fgetl(puntero_Netlist);
if ~isempty(findstr(linea_netlist,'.include'))|~isempty(findstr(linea_netlist,'.include'))|...
~isempty(findstr(linea_netlist,'.lib'))|~isempty(findstr(linea_netlist,'.LIB'))
vacios = findstr(linea_netlist,' ');
Direccion = linea_netlist(vacios(1)+1:end);
Modelo_ant=Modelos;
SubCircuito_ant=SubCircuitos;
[Modelos,SubCircuitos]=modelos(Direccion);
if isstruct(Modelos)
Modelos=Agrega(Modelos,Modelo_ant);
elseif Modelos==0
Modelos=Modelo_ant;
end
if isstruct(SubCircuitos)
SubCircuitos=Agrega(SubCircuitos,SubCircuito_ant);
elseif SubCircuitos==0
SubCircuitos=SubCircuito_ant;
end
end
Netlist_temporal=strvcat(Netlist_temporal,linea_netlist);
end
fclose(puntero_Netlist);
%=========================FUNCIN GENERACION DE ESTRUCTURAS ======================
function [Modelos,SubCircuito]=modelos(Archivo)
puntero_archivo=fopen(Archivo);
if puntero_archivo<0
clc
disp('La Direccion o el Nombre del Archivo no Existen')
disp(strcat('Direccion Invalida: ',Archivo))
Modelos=0;
SubCircuito=0;
pause
return
end
Salir_Model=1;
Salir_Circuito=1;
SubCircuito=0;
contador=1
Modelos=0;
Direcciones=0;
Contenido=cell(2,1);
while ~feof(puntero_archivo)
linea=fgetl(puntero_archivo);
if ~isempty(findstr(linea,'.include'))|~isempty(findstr(linea,'.include'))|...
~isempty(findstr(linea,'.lib'))|~isempty(findstr(linea,'.LIB'))
vacios = findstr(linea,' ');
Direccion = linea(vacios(1)+1:end);
Modelo_ant=Modelos;
102
SubCircuito_ant=SubCircuito;
[Modelos,SubCircuito]=modelos(Direccion);
Modelos=Agrega(Modelos,Modelo_ant);
elseif Modelos==0
Modelos=Modelo_ant;
end
if isstruct(SubCircuito)
SubCircuito=Agrega(SubCircuito,SubCircuito_ant);
elseif SubCircuito==0
SubCircuito=SubCircuito_ant;
end
end
if ~isempty(findstr(linea,'.MODEL'))|Salir_Model==0
if ~isempty(findstr(linea,'.MODEL'))
Salir_Model=0;
expr='.MODEL+\s+(?<Nombre>\w+)\s+(?<Tipo>\w+)';
[modelo mat] = regexp(linea, expr, 'names', 'match');
Modelo_Nombre=strcat(modelo.Tipo,'.',modelo.Nombre);
TYP=modelo.Tipo
NAM=modelo.Nombre
end
expr_nombre='\w*[a-zA-Z0-9]+\s+=';
expr_valor='\<=+\s+[-0-9.eE]+\>';
mat_nombre = regexp(linea, expr_nombre, 'match');
mat_valor = regexp(linea, expr_valor, 'match');
if ~isempty(mat_nombre)&~isempty(mat_valor)
for i=1:length(mat_valor)
valor_real=mat_valor{i}
valor_real=valor_real(2:end)
nombre = regexp(mat_nombre(i), '\w*[a-zA-Z0-9]', 'match')
modelo_creado = strcat('Modelos.',Modelo_Nombre,'.',nombre{1},'=',valor_real);
eval(modelo_creado{1});
end
end
if ~isempty(findstr(linea,')'))
Salir_Model=1;
end
end
if ~isempty(findstr(linea,'.SUBCKT'))|Salir_Circuito==0
if ~isempty(findstr(linea,'.SUBCKT'))
Salir_Circuito=0;
expr_circ='\<[.a-zA-Z0-9_-]\w*';
Circuito = regexp(linea, expr_circ, 'match');
Circuito_Nombre=strcat(Circuito{2},'.');
nodos=cell(1,length(Circuito)-2);
for i=3:length(Circuito)
nodos{i-2}=Circuito{i};
end
SubCircuito.(Circuito{2}).Nodos=nodos;
elseif isempty(findstr(linea,'.ENDS'))
Contenido{contador} = linea;
103
contador=contador+1;
SubCircuito.(Circuito{2}).Contenido=Contenido;
end
if ~isempty(findstr(linea,'.ENDS'))
contador=1;
Salir_Circuito=1;
end
end
end
fclose(puntero_archivo);
%=========================FUNCIN JUNTA ESTRUCTURAS ======================
function Nuevo = Agrega(Nuevo,Antiguo)
if isstruct(Antiguo)
Nombres = fieldnames(Antiguo)
for i=1:length(Nombres)
Nuevo.(Nombres{i})= Antiguo.Nombres{i}
end
end
10.3.2 Anexo 3(b): Funcin Agrega_modelos.
%=========================FUNCIN AGREGA MAS MODELOS ======================
function[Modelos,Nombres_generados] = agrega_modelos(Modelos_Cambiar,Modelos);
Model_Tipos_Cambiar = fieldnames(Modelos_Cambiar)
Model_Tipos_Actual = fieldnames(Modelos)
for h=1:length(Model_Tipos_Actual)
for j=1:length(Model_Tipos_Cambiar)
Tipo_Cambiar = Model_Tipos_Cambiar{j}
Tipo_Actual = Model_Tipos_Actual{h}
if strcmp(Tipo_Cambiar,Tipo_Actual)
Model_Tipo_Nombres_Actuales = fieldnames(Modelos_Cambiar.(Tipo_Cambiar))
Model_Tipo_Nombres_Cambiar = fieldnames(Modelos.(Tipo_Actual))
for NA=1:length(Model_Tipo_Nombres_Actuales)
for NC=1:length(Model_Tipo_Nombres_Cambiar)
Nombre_Cambiar = Model_Tipo_Nombres_Cambiar{NC};
Nombre_Actual = Model_Tipo_Nombres_Actuales{NA};
if strcmp(Nombre_Cambiar,Nombre_Actual)
cantidad=Modelos_Cambiar.(Tipo_Cambiar).(Nombre_Cambiar).Cantidad;
for u=1:cantidad
if u==1
NOMBRE=Nombre_Actual;
almacena{u}=NOMBRE;
Nombres_generados.(Tipo_Actual)=almacena;
else
NOMBRE=strcat(Nombre_Actual,num2str(u-1));
almacena{u}=NOMBRE;
Nombres_generados.(Tipo_Actual)=almacena;
end
Modelos.(Tipo_Actual).(NOMBRE)=Modelos.(Tipo_Actual).(Nombre_Actual);
Model_Tipo_Nombres_Parametro_Actuales =
fieldnames(Modelos.(Tipo_Actual).(NOMBRE));
Model_Tipo_Nombres_Parametro_Cambiar =
fieldnames(Modelos_Cambiar.(Tipo_Cambiar).(Nombre_Cambiar));
104
for PA=1:length(Model_Tipo_Nombres_Parametro_Actuales)
for PC=2:length(Model_Tipo_Nombres_Parametro_Cambiar)
Parametro_Actual = Model_Tipo_Nombres_Parametro_Actuales{PA};
Parametro_Cambiar = Model_Tipo_Nombres_Parametro_Cambiar{PC};
if strcmp(Parametro_Cambiar,Parametro_Actual)
valor=Modelos.(Tipo_Actual).(NOMBRE).(Parametro_Actual);
modificacion=Modelos_Cambiar.(Tipo_Cambiar).(Nombre_Cambiar).(Parametro_Cambiar);
valor_nuevo=valor+rand*modificacion;
Modelos.(Tipo_Actual).(NOMBRE).(Parametro_Actual)= valor_nuevo;
end
end
end
end
clear almacena;
end
end
end
end
end
end
10.3.3 Anexo 3(c): Funcin Escribir.
function archivo_modificado = Escribir(Netlist,Modelos,SubCircuitos)
puntero_Netlist=fopen(Netlist);
archivo_modificado=strcat(strcat(nombre_archivo,'_modificado'),extension);
destino=fopen(archivo_modificado,'w');
cont_includ=1;
while ~feof(puntero_Netlist)
linea_netlist=fgetl(puntero_Netlist);
if (~isempty(findstr(linea_netlist,'.include'))|~isempty(findstr(linea_netlist,'.include'))|...
~isempty(findstr(linea_netlist,'.lib'))|~isempty(findstr(linea_netlist,'.LIB')))&cont_includ<=1
cont_includ=cont_includ+1;
destino = escribir_modelos(destino,Modelos);
end
if isstruct(SubCircuitos)
destino = escribir_subcircuito(destino,SubCircuitos);
end
linea_netlist='';
elseif (~isempty(findstr(linea_netlist,'.include'))|~isempty(findstr(linea_netlist,'.include'))|...
~isempty(findstr(linea_netlist,'.lib'))|~isempty(findstr(linea_netlist,'.LIB')))&cont_includ>1
linea_netlist='';
end
fwrite(destino,linea_netlist);
fprintf(destino,'\n');
end
fclose(puntero_Netlist);
fclose(destino);
%===============FUNCIN ESCRIBE MODELOS EN ARCHIVO DESTINO ======================
105
function destino = escribir_modelos(destino,Modelos)
fprintf(destino,'** *******************************************\n');
fprintf(destino,'** **********MODELOS A UTILIZAR***************\n');
Tipos=fieldnames(Modelos)
for T=1:length(Tipos)
Nombres=fieldnames(Modelos.(Tipos{T}));
for N=1:length(Nombres)
Parametros=fieldnames(Modelos.(Tipos{T}).(Nombres{N}));
contador=1;
for P=1:length(Parametros)
Valor_parametro=Modelos.(Tipos{T}).(Nombres{N}).(Parametros{P});
Valor_parametro=num2str(Valor_parametro);
if P==1
linea_modelos=strcat(['.MODEL' ' ' Nombres{N} ' ' Tipos{T} '(' Parametros{P} ' = '
Valor_parametro]);
fwrite(destino,linea_modelos);
linea_modelos='+';
elseif contador <= 3
linea_modelos=strcat([linea_modelos ' ' Parametros{P} ' = ' Valor_parametro ' ']);
else
linea_modelos='+';
linea_modelos=strcat([linea_modelos ' ' Parametros{P} ' = ' Valor_parametro ' ']);
contador=1;
end
if P==length(Parametros)
linea_modelos=strcat(linea_modelos,')');
end
end
end
end
fprintf(destino,'** ******************************************\n');
fprintf(destino,'** ******FIN DE MODELOS A UTILIZAR***********\n');
%========== FUNCIN ESCRIBE SUBCIRCUITOS EN ARCHIVO DESTINO ====================
function destino = escribir_subcircuito(destino,SubCircuitos)
clc
fprintf(destino,'** *******SUBCIRCUITO A UTILIZAR**************\n');
Nombres=fieldnames(SubCircuitos);
for N=1:length(Nombres)
Nodos = SubCircuitos.(Nombres{N}).Nodos;
106
Contenido = SubCircuitos.(Nombres{N}).Contenido;
linea_subcircuito=strcat(['.SUBCKT' ' ' Nombres{N} ]);
for Nod=1:length(Nodos)
linea_subcircuito=strcat([linea_subcircuito ' ' Nodos{Nod}]);
end
fwrite(destino,linea_subcircuito);
for C=1:length(Contenido)
linea_subcircuito=Contenido{C};
end
linea_subcircuito=strcat(['.ENDS' ' ' Nombres{N} ]);
end
fprintf(destino,'** ****FIN DE SUBCIRCUITO A UTILIZAR*********\n');
10.3.4 Anexo 3(d): Funcin asignacion_aleatoria.
function archivo_final=Asignacion_Aleatoria(Netlist,Modelos)
Tipos_Modelos={'R';'C';'SW';'CSW';'URC';'LTRA';'D';'NPN';'PNP';'NJF';'PJF';...
'NMOS';'PMOS';'NMF';'PMF'};
Nombre_Modelos={'R';'C';'S';'W';'U';'O';'D';'Q';'Q';'J';'J';'M';'M';'Z';'Z'};
%-----------------------------------------------------------------------
archivo_final=strcat(strcat(nombre_archivo,'_final'),extension);
anterior=fopen(Netlist,'r');
modifica=fopen(archivo_final,'w');
%-----------------------------------------------------------------------
TYPE=fieldnames(Modelos);
clc
while ~feof(anterior)
linea_netlist=fgetl(anterior);
if ~isempty(linea_netlist)
primera_letra=linea_netlist(1)
for i=1:length(Nombre_Modelos)
if primera_letra==Nombre_Modelos{i}
linea_netlist=reemplaza(linea_netlist,Modelos,i);
break;
end
end
end
fwrite(modifica,linea_netlist);
fprintf(modifica,'\n');
end
fclose(anterior);
fclose(modifica);
%================FUNCIN REEMPLAZA MODELOS ALETORIOS =====================
107
function linea_netlist=reemplaza(linea_netlist,Modelos,Tipo_elemento)
clc
expr='\<\w*[0-9@a-zA-Z=._-]+\>';
Palabras = regexp(linea_netlist, expr, 'match');
TYPES=fieldnames(Modelos);
Comienzo_elemento={3;3;3;3;4;6;3;4;4;4;4;5;5;4;4};
inicio = Comienzo_elemento{Tipo_elemento}
if length(Palabras)>=4
for T=1:length(TYPES)
NAMES=fieldnames(Modelos.(TYPES{T}))
for P=4:length(Palabras)
if strcmp(Palabras{P},NAMES{1})
linea_netlist=remplaza_dos(linea_netlist,Palabras , NAMES,inicio,P);
end
end
end
end
function linea_netlist=remplaza_dos(linea_netlist,Palabras , NAMES,inicio,P)
% Me eseguro que el numero generado aletoriamente este dentro de la
% cantidad de elementos de NAMES
while true
numero=length(NAMES);
numero=round(rand*numero);
if (numero>=1)&(numero<=length(NAMES))
break;
end
end
Palabras{P}=NAMES{numero};
temp=Palabras{1};
for i=2:length(Palabras)
temp=strcat([temp ' ' Palabras{i} ' ']);
end
linea_netlist=temp;
10.3.5 Anexo 3(e): Funcin Modifica_size.
function [archivo_modificado]=Modifica_Size(Netlilst,Tipos)
clc
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
extension = Netlilst(findstr(Netlilst,'.'):end);
nombre_archivo = Netlilst(1:findstr(Netlilst,'.')-1);
puntero=fopen(Netlilst);
archivo_modificado=strcat(strcat(nombre_archivo,'_size'),extension);
destino=fopen(archivo_modificado,'w');
names_tipos = fieldnames(Tipos);
parametros_transistor={'AD';'AS';'PD';'PS'};
while ~feof(puntero)
linea=fgetl(puntero);
if isempty(linea)
linea='*';
108
end
if(linea(1)~='*'|linea(1)~='.')
for i=1:length(names_tipos)
if ~isempty(findstr(linea(1),names_tipos{i}))
if names_tipos{i}=='C'|names_tipos{i}=='R'|names_tipos{i}=='L'|names_tipos{i}=='D'
if names_tipos{i}=='D'
buscar='[0-9.]+[0-9]';
[m s e] = regexp(linea,buscar, 'match', 'start', 'end');
prefijo='';
numero=str2num(linea(s(1):e(1)));
else
buscar='[0-9.]+[a-zA-Z]';
prefijo=linea(e(1));
numero=str2num(linea(s(1):e(1)-1));
end
numero=numero+randn*(Tipos.(names_tipos{i}));
if numero<0
numero=numero*-1;
end
linea=regexprep(linea, buscar, strcat(num2str(numero),prefijo));
elseif isstruct(Tipos.(names_tipos{i}))
names_variables=fieldnames(Tipos.(names_tipos{i}));
if ~isempty(findstr(linea(1),'M'))
[m s e] = regexp(linea,'W=[0-9.]+[a-zA-Z]', 'match', 'start', 'end');
W=str2num(linea(s(1)+2:e(1)-1));
[m s e] = regexp(linea,'L=[0-9.]+[a-zA-Z]', 'match', 'start', 'end');
L=str2num(linea(s(1)+2:e(1)-1));
for j=1:length(names_variables)
variable=names_variables{j};
if findstr(linea,variable)
buscar=strcat(variable,'=[0-9.]+[a-zA-Z]');
numero=str2num(linea(s(1)+2:e(1)-1));
numero=numero+randn*(Tipos.(names_tipos{i}).(names_variables{j}));
if numero<0
numero=numero*-1;
end
linea=regexprep(linea, buscar, strcat(variable,'=',num2str(numero),prefijo));
end
if variable=='W'
W=numero;
elseif variable =='L'
L=numero;
end
end
end
end
end
for k=1:length(parametros_transistor)
109
if ~isempty(findstr(linea,parametros_transistor{k}))
buscar=strcat(parametros_transistor{k},'=[0-9.]+[a-zA-Z]');
if ~isempty(s)
numero=str2num(linea(s(1)+3:e(1)-1));
numero=numero*(W/L);
if numero<0
numero=numero*-1;
end
linea=regexprep(linea, buscar,
strcat(parametros_transistor{k},'=',num2str(numero),prefijo));
end
end
end
end
end
fwrite(destino,linea);
end
fclose(puntero);
fclose(destino);
10.3.6 Anexo 3(f): Funcin Buscar.
function [Modelos,SubCircuito,Netlist_2]=Buscar(Netlist,Modelos,SubCircuito)
salir=size(Netlist);
Salir_Circuito=1;
Salir_Model=1;
contador=1;
Circuito=0;
Netlist_2='';
si=0;
Circuito_Nombre='';
Contenido='';
for cuenta=1:salir(1)
linea=Netlist(cuenta,1:end);
if si==1&linea(1)=='+'
linea='';
si=0;
end
if ~isempty(findstr(linea,'.MODEL'))|Salir_Model==0
if ~isempty(findstr(linea,'.MODEL'))
Salir_Model=0;
expr='.MODEL+\s+(?<Nombre>\w+)\s+(?<Tipo>\w+)';
[modelo mat] = regexp(linea, expr, 'names', 'match');
TYP=modelo.Tipo
NAM=modelo.Nombre
end
expr_nombre='\w*[a-zA-Z0-9]+\s+=';
expr_valor='\<=+\s+[-0-9.eE]+\>';
mat_nombre = regexp(linea, expr_nombre, 'match');
mat_valor = regexp(linea, expr_valor, 'match');
110
if ~isempty(mat_nombre)&~isempty(mat_valor)
for i=1:length(mat_valor)
valor_real=mat_valor{i};
valor_real=valor_real(2:end);
valor_real=str2num(valor_real);
nombre = regexp(mat_nombre(i), '\w*[a-zA-Z0-9]', 'match')
nom=nombre{1};
nom=nom{1};
Modelos.(TYP).(NAM).(nom)=valor_real;
end
end
if ~isempty(findstr(linea,')'))
Salir_Model=1;
end
linea='';
end
if ~isempty(findstr(linea,'.SUBCKT'))|Salir_Circuito==0
if ~isempty(findstr(linea,'.SUBCKT'))
clear Circuito_Nombre;
clear Contenido;
linea_2=Netlist(cuenta+1,1:end);
if linea_2(1)=='+'
Circuito_2=genera(linea_2);
si=1;
else
si=0;
end
Salir_Circuito=0;
Circuito=genera(linea);
Circuito_Nombre=Circuito{2};
if ~isempty(findstr(Circuito_Nombre,'-'))
Circuito_Nombre=regexprep(Circuito_Nombre, '-', '_')
end
if si==1
con=1;
nodos=cell(1,(length(Circuito)-2)+length(Circuito_2));
nodos{con}=Circuito{i};
con=con+1;
end
for i=1:length(Circuito_2)
nodos{con}=Circuito_2{i};
con=con+1;
end
else
nodos=cell(1,length(Circuito)-2);
nodos{i-2}=Circuito{i};
end
end
SubCircuito.(Circuito_Nombre).Nodos=nodos;
111
elseif isempty(findstr(linea,'.ENDS'))
Contenido{contador,1} = linea;
SubCircuito.(Circuito_Nombre).Contenido=Contenido;
end
if ~isempty(findstr(linea,'.ENDS'))
contador=1;
Salir_Circuito=1;
end
linea='';
end
Netlist_2=strvcat(Netlist_2,linea);
end
function palabras = genera(linea)
palabra='';
con=1;
for i=length(linea):-1:1
if linea(i)~=' '
fin=i+1;
break;
end
end
for i=1:fin
if linea(i)~=' '
letra=linea(i);
if letra=='+'&i==1
letra='';
end
palabra=strcat(palabra,letra);
else
palabras{con}=palabra;
palabra='';
con=con+1;
end
end
10.3.7 Anexo 3(g): Funcin Agregar_subcircuitos.
function[SubCircuitos_modificados] = agrega_SubCircuitos(cantidad,SubCircuitos)
Nombres = fieldnames(SubCircuitos)
for Nom=1:length(Nombres)
for Cant=1:cantidad
new_name=strcat(Nombres{Nom},'_',num2str(Cant));
SubCircuitos_midificados.(Nombres{Nom}).(new_name).Nodos =
SubCircuitos.(Nombres{Nom}).Nodos;
SubCircuitos_midificados.(Nombres{Nom}).(new_name).Contenido=
SubCircuitos.(Nombres{Nom}).Contenido;
end
end
112
10.3.8 Anexo 3(h): Funcin Asignacin_subcircuito.
function archivo_final=Asignacion_SubCircuitos(Netlist,SubCircuitos)
%-----------------------------------------------------------------------
global modifica
global anterior
archivo_final = strcat(strcat(nombre_archivo,'_SubCircuitos'),extension);
anterior = fopen(Netlist,'r');
modifica = fopen(archivo_final,'w');
%-----------------------------------------------------------------------
while ~feof(anterior)
linea_netlist=fgetl(anterior);
if ~isempty(linea_netlist)
primera_letra=linea_netlist(1)
if primera_letra=='X'
linea_netlist=reemplaza(linea_netlist,SubCircuitos);
end
fwrite(modifica,linea_netlist);
else
end
end
fclose(anterior);
fclose(modifica);
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
%================FUNCIN REEMPLAZA SUBCIRCUITOS ALETORIOS =====================
function linea=reemplaza(linea,SubCircuitos)
global modifica
global anterior
Nombres=fieldnames(SubCircuitos);
while(1)
for i=1:length(Nombres)
nombre_corto=Nombres{i};
nombre_corto=nombre_corto(1:round(length(nombre_corto)*3/4));
if ~isempty(findstr(linea,nombre_corto))
linea=reemplaza_nombre(linea,Nombres{i},SubCircuitos)
break
end
end
fwrite(modifica,linea);
linea=fgetl(anterior);
if linea(1)~='+'
if linea(1)=='X'
linea=reemplaza(linea,SubCircuitos);
end
break
end
end
113
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
function lin = reemplaza_nombre(linea,nombre,SubCircuitos)
NAMES=fieldnames(SubCircuitos.(nombre));
total=length(NAMES);
while true
numero=round(rand*total);
if (numero>=1)&(numero<=total)
break;
end
end
nombre = encuentra(linea)
lin=regexprep(linea, nombre, NAMES{numero})
% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
function nombre = encuentra(linea)
palabra='';
con=1;
for i=length(linea):-1:1
if linea(i)~=' '
fin=i;
break;
end
end
for i=fin:-1:1
if linea(i)==' '
comienzo=i+1;
break;
end
end
nombre=linea(comienzo:fin);

Waldo Valenzuela MemoriaT Eln

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Waldo Valenzuela MemoriaT Eln

Caricato da

Copyright:

Formati disponibili

Universidad de Concepcin.

Departamento de Ingeniera Elctrica.

Potrebbero piacerti anche