UNIVERSIDAD PONTIFICIA COMILLAS

ESCUELA TCNICA SUPERIOR DE INGENIERA (ICAI)

INGENIERO EN AUTOMTICA Y ELECTRNICA INDUSTRIAL

PROYECTO FIN DE CARRERA

ANALIZADOR LGICO DE BAJO COSTE BASADO EN UNA FPGA

AUTOR: JAIME TRINOR GOIRA MADRID, Septiembre 2005

ndice General
Documento n 1 MEMORIA
Parte I Memoria

Prlogo 1

Captulo 1 - Introduccin3
1.- Motivacin del Proyecto..5 2.-Objetivos...5 3.- Metodologa .5 4.- Recursos ..7

Captulo 2 Desarrollo ..8

1.- Software8 Cdigo del programa .14 2.- Hardware.27 2.1.- Placa de Prueba..29 2.2.- Placa Final .35 2.3.- VHDL ..46 2.3.1.- Cdigo VHDL.77

Captulo 3 Conclusiones ..105 Captulo 4 Futuros Desarrollos ...106 Bibliografa ..109

Parte II Esquemas
II.1.1.- Bloques Placa de Prueba.. .....110 II.1.2.- Bloques Placa Final ...111 II.2 Esquemas Elctricos II.2.1.- Esquema placa de Prueba ...114 II.2.2.- Esquema Placa final 115

Parte III Estudio Econmico ...117 Parte IV Manual de Usuario ....120 Parte V Anexos
V.1.- RAM ...123 V.2.- FPGA .128 V.3.- Buffer .132 V.4.- EPC2TC32.133 V.5.- 74HC14D ..137 V.6.- 74HC05 .138

Documento n 2 PLIEGO DE CONDICIONES

Condiciones Generales .................................................................139 Condiciones Tcnicas y Particulares 141

PRLOGO
A la hora de buscar un proyecto de fin de carrera se quera encontrar algo relacionado con la electrnica digital y a ser posible relacionado con la sntesis de circuitos integrados en una FPGA debido al inters suscitado tras cursar la asignatura de Sistemas Electrnicos Digitales correspondiente al primer curso de la titulacin de Ingeniera en Automtica y Electrnica Industrial. Entonces fue cuando apareci este proyecto, que estaba ligado por completo con la asignatura estudiada y a su vez comprenda otros temas de inters dentro del campo de la electrnica digital. Se parta como un proyecto en el que se deba aplicar conocimiento, ingenio e imaginacin, en el que debido a sus largas y diferentes tareas, prometa un gran aprendizaje por parte del autor en temas como el diseo de circuitos impresos, diseo de bloques lgicos en VHDL y ampliacin de los conocimientos en ciertos programas informticos.

A medida que se iba realizando el proyecto, a pesar de las dificultades tcnicas, se comprob que era un proyecto totalmente abierto y dinmico, no marcado desde el comienzo todo el desarrollo, sino que conforme se iba progresando, haba que ir mejorando lo anterior y encontrar soluciones que en un primer momento no se vean claras pero que finalmente, muchas de ellas se consiguieron.

Se marcaron muchos objetivos inicialmente, aparentemente asequibles pero que segn iba transcurriendo el tiempo se comprendi que no era moco de pavo el invento y que se necesitara mucho ms tiempo del que se dispona, por ello se opt por continuar algunos puntos en posteriores proyectos.

Se ha conseguido desarrollar un analizador lgico utilizando la tarjeta Prince de la universidad acoplndole un par de memorias RAM a la FPGA de dicha tarjeta y tambin probar todo el funcionamiento, comprobando que todo va a la perfeccin. No obstante, esta placa se mont tras haber realizado por completo el diseo de la placa final en la que se incluan todos los componentes y la pena fue que esta ltima placa no se pudo fabricar debido a su coste elevado y a la falta de tiempo para tenerla antes de la entrega de esta memoria. Esperemos que en un futuro no muy lejano esa placa pueda verse hecha realidad y que sirva de ayuda a compaeros de la escuela que, como yo, sufrieron a la hora de probar circuitos digitales despus de realizar una simulacin

exitosa y no conseguan descubrir por qu no funcionaba su diseo. Con este analizador esperemos que se mejore el rendimiento de ciertas asignaturas y estudios, y por supuesto que sirva como herramienta a aquellos que la necesiten.

En la memoria que viene a continuacin se va a detallar todo el proceso para poder realizar un analizador de prueba sobre la tarjeta Prince y tambin de cmo es el diseo y los pasos a seguir para tener un analizador lgico de bajo coste basado en una FPGA con todos sus componentes. Se incluir un CD con informacin diversa de todos los bloques programados (circuitos integrados en la FPGA mediante la programacin en VHDL y software de control y comunicacin PC-Analizador), adems de los propios programas para comunicarse con el analizador de prueba y con el futuro Analizador JTG_05

INTRODUCCIN:

En este proyecto se va a realizar un analizador lgico de bajo coste que servir para monitorizar, capturar y analizar todo tipo de seales digitales con el objetivo de depurar, verificar y optimizar sistemas digitales de cualquier ndole. El proceso es muy simple: se procede a almacenar los datos procedentes de unas seales digitales de entrada en una o varias memorias que, una vez se hallan llenado, se envan sus datos a un ordenador para ver su evolucin temporal. En la Figura 1 se puede observar un analizador de venta en el mercado electrnico que realiza lo descrito con anterioridad (tiene un men de configuracin en la pantalla, la memoria incorporada y tambin muestra la evolucin de las seales en su monitor). Sin embargo, debido a su coste tan elevado, es inviable adquirirlo como algo normal para un laboratorio docente con ms de 10 puestos (modelos de gama media de la marca Tektronix se venden en torno a los 8000 la unidad). Por ello se propone en este proyecto utilizar el procesador y el monitor de un ordenador convencional para reducir ese excesivo coste mencionado.

Figura 1: Analizador Lgico comercial

Memoria. Introduccin

Para la realizacin de este proyecto se pretende emplear una FPGA de la marca Altera (puesto que ya se conoce el manejo de este tipo de FPGAs por parte del autor del proyecto) en la que se configurarn los controles y circuitos necesarios para gestionar el almacenamiento de los valores de las seales de entrada y a su vez de enviarlas al PC conectado. Adems, ser capaz de recibir los parmetros de configuracin del analizador que le enviar el PC.

Se tienen que definir varias partes del proyecto para poder realizar lo descrito: 1.- Hardware: Ser una parte configurable (FPGA) y un circuito serigrafiado. En este ltimo se pondrn los componentes principales (memorias RAM, Buffers y FPGA) y el resto de componentes se detallarn en el captulo Desarrollo de la presente memoria (seccin Hardware). En la parte configurable, se tendrn que disear varios dispositivos en VHDL que sern los que configuren la FPGA para poder actuar como analizador.

2.- Software: Se tendr que realizar un programa que se comunique con el analizador desde un PC a travs del puerto serie para de esta forma, enviarle los parmetros de configuracin y de disparo al analizador (el disparo es la o las seales que provocan que el analizador comience su muestreo). Cuando el dispositivo a desarrollar termine de capturar muestras, las enviar al ordenador, y ste las mostrar temporalmente en su monitor.

Los parmetros de configuracin programables que se van a disponer en este analizador van a ser el nmero de entradas a muestrear, la frecuencia de muestreo y por ltimo el nmero de muestras que se quiere almacenar en cada memoria. En cuanto a los parmetros de disparo, el analizador ser capaz de realizar un muestreo con disparo manual (el usuario le indica al dispositivo cundo quiere que empiece el muestreo), por flanco de subida o de bajada de una seal especificada tambin por el usuario y tambin por patrn (la seal de disparo es un valor especfico de todas las seales de entrada).

Jaime Trinor Goira

Memoria. Introduccin

Lo que se busca en este analizador es rapidez, profundidad de muestras y capacidad de datos (nmero de entradas), y a un precio asequible, y todo ello lo tienen que dar las memorias, aunque la velocidad tambin depender del modelo de la FPGA y del reloj que se le ponga a sta. Por lo que se opt por poner varias memorias RAM en cascada , teniendo un total de 8 memorias SRAM.

1 Motivacin del proyecto

Como se ha comentado antes, una motivacin bastante importante es la de poder poseer un dispositivo de estas caractersticas a un precio reducido, de tal forma que la universidad pueda emplearlo para fines docentes, siendo esa otra motivacin ya que en ciertas asignaturas (tales como sistemas electrnicos digitales, microprocesadores, etc.) en las que se emplean otros dispositivos digitales, ocurre que al hacer un programa y cargarlo a la tarjeta correspondiente despus de haberlo simulado y comprobado que funciona, la realidad no se parece a lo simulado, lo que en ocasiones provoca quebraderos de cabeza. Con el analizador realizado se podr observar todas las seales accesibles de la prctica de laboratorio correspondientes y hallar el fallo cometido.

2 Objetivos
1.-Bsqueda de los componentes adecuados para el analizador. 2.-Diseo y montaje de una placa de pruebas (para conectar sobre la tarjeta Prince de la universidad). 3.-Bsqueda de la mxima resolucin de tiempos en la escritura de la RAM. 4.- Software de configuracin y comunicacin con el analizador. 5.- Programacin del control del analizador en la FPGA. 6.-Software de monitorizacin de los datos procedentes de la memoria RAM 7.- Diseo y montaje de la placa final con todos los componentes.

Memoria. Introduccin

3 Metodologa
Las especificaciones mnimas iniciales eran las de poder muestrear 32 entradas, tener un mnimo de capacidad de 1MB y adems poder muestrear a una velocidad de unos 100MHz. En el mercado no haba memorias RAM de estas caractersticas o las que se acercaban un poco estaban fuera de presupuesto por mucho. Entonces, se encontraron memorias del tipo 256K x 4 (256 Kilo Bytes de direcciones o posiciones de memoria y 4 entradas) con un tiempo de acceso de 12ns (aproximadamente 83MHz) y, como se ha dicho, se han adquirido 8 RAM de este estilo. Con esto se consegua tener un analizador ms dinmico, pudiendo ganar profundidad de datos a costa de tener menor nmero de entradas o viceversa. Las opciones quedan finalmente de la siguiente manera: se pueden muestrear 4 entradas y tener hasta 2MB de datos, 8 entradas y 1MB de profundidad de muestras, 16 entradas con 512KB 32 entradas y 256KB. Adems de esto, se han conectado las RAM formando dos bancos de memorias con seales de habilitacin y de posicin de memoria independientes en cada banco para poder tener un tiempo de muestreo de la mitad de su ciclo de escritura (en un ciclo se empieza a almacenar una muestra en la o las memorias del banco A y en el siguiente pulso de reloj se mantiene la escritura esa/s memoria/s del banco A y se empieza a introducir otro dato en una o varias memorias del banco B), consiguiendo una velocidad de hasta 160MHz. Como uno de los objetivos es el de tener mxima resolucin de tiempos en la escritura de la RAM, implica la necesidad de poseer dispositivos rpidos que puedan tratar seales lo ms rpido posible. Los Buffers de proteccin a utilizar son los de la serie ACT puesto que son los ms rpidos del mercado, teniendo un tiempo de propagacin de puerta de 3.4ns, suficiente para la velocidad requerida. Como ltimo componente bsico, est la FPGA que se ha utilizado una de la marca Altera de la serie 10k30 de 208 pines debido a su conocimiento de manejo previo, de su entorno de programacin y de su capacidad y velocidad, pudiendo introducir un reloj de hasta 100MHz con la posibilidad de duplicar dicha velocidad con su PLL interno. Para la representacin temporal de las seales se ha utilizado el programa MaxPlus II de Altera que importndole un archivo con la extensin *.vec que contiene una serie de parmetros que se explicarn en la seccin de Software, es capaz de mostrar la evolucin temporal de los datos recogidos en dicho archivo.

Jaime Trinor Goira

Memoria. Introduccin

En cuanto a software de programacin se ha utilizado el lenguaje C junto con C++ que se emple este ltimo para la gestin del puerto serie desde Windows y el primero para la programacin de un men de usuario y escritura del fichero *.vec. Por ltimo destacar la utilizacin del lenguaje de alto nivel VHDL para la programacin de la FPGA.

4 Recursos
Los recursos empleados en el proyecto han sido diversos debido a su complejidad y cantidad de tareas a realizar. Para la programacin en C y C++ se emple el programa DevC++ siendo de libre distribucin. En cuanto a la programacin de la FPGA se utiliz MaxPlus II de Altera con una licencia para estudiantes, puesto que es el nico capaz de programar FPGAs de dicha marca. Para el diseo Hardware el programa Eagle Layout Editor fue suficiente para la placa de prueba con su versin gratuita, sin embargo para el diseo de la placa final se necesit de una licencia para el diseo multicapa. En la parte de la placa de prueba se tom una tarjeta Prince de la universidad ya que sta dispone de una FPGA integrada con otros componentes y a travs de sus conectores se incorpor la placa de prueba que contiene 2 memorias RAM y un Buffer, de esta forma se pudieron realizar todas las pruebas previas sin necesidad de fabricar una que pudiera no haber valido.

Analizador Lgico basado en FPGA

Captulo 2 DESARROLLO
SOFTWARE En esta seccin se detalla el programa realizado, que es capaz de comunicarse con el analizador y enviarle los parmetros de configuracin. Tambin realiza la recepcin de los datos almacenados en las memorias del analizador. Una vez recibidos estos datos, se almacenarn en un fichero que se puede abrir en MaxPlus II para ver la evolucin temporal de las seales muestreadas en el analizador.

El programa tendr dos versiones prcticamente iguales (una para poder manejar el Analizador de Prueba de la tarjeta Prince y otra versin para configurar y utilizar el Analizador JTG_05), y lo que har bsicamente es abrir un puerto serie del ordenador que est conectado al analizador (COM1 o COM2) para despus pedir al usuario que indique si desea capturar datos en la RAM del analizador segn varios modos de disparo, leer los datos y escribirlos en el fichero o bien reconfigurar el analizador (nmero de entradas, frecuencia de muestreo y nmero de muestras a almacenar).

Como el Analizador de Prueba tiene solamente 2 memorias RAM del tipo 256 KBytes x 4 entradas, las opciones de muestreo en cuanto a nmero de entradas van a ser solamente 4 u 8 entradas, mientras que para el Analizador JTG_05, como dispone de 8 memorias del mismo estilo, se podrn seleccionar 4,8,16 y 32 entradas a muestrear.

La comunicacin se realiza mediante un pequeo protocolo en el cual se enva primero un byte de configuracin en el que se indica si se desea leer o escribir y de qu forma se quiere escribir (segn que bit o bits estn activados), y seguidamente se envan los bytes del modo de captura (si es que ste modo est seleccionado). Los distintos modos de almacenar muestras vienen recogidos en un men de disparo en el que se le pide al usuario que seleccione dicho modo: modo manual, flanco de subida, flanco de bajada y por ltimo modo patrn. Cada uno consiste en: 1.-Manual : El usuario oprime cualquier tecla del ordenador y el analizador comienza el muestreo de las seales de entrada seleccionadas. 2.- Flanco de subida: se indica el nmero de entrada que se corresponder con la seal de disparo del muestreo, es decir, cuando en dicha seal se produzca un flanco de

Jaime Trinor Goira

SOFTWARE

subida (cambia su valor de 0 a 1), el control residente en la FPGA empezar a almacenar los datos en las memorias muestreando las entradas deseadas. 3.- Flanco de bajada: lo mismo que el anterior pero empezando el muestreo cuando se produce un flanco de bajada (la entrada pasa de valer 1 a 0) de la seal deseada (teniendo en cuenta el nmero de entradas disponibles). 4.-Modo Patrn: el usuario introduce un valor en hexadecimal en funcin del nmero de entradas a muestrear y cuando stas entradas coinciden con ese valor, comienza el muestreo.

El byte de configuracin es como puede apreciarse en la Figura 2: los dos primeros bits indican si se quiere leer o escribir en la RAM del analizador y el resto de bits indican qu modo y tipo de captura que se va a realizar: el tercer y cuarto bit indican el nmero de entradas a muestrear (equivaliendo un 00 a 4 entradas, un 01 a 8 entradas, 10 a 16 y por ltimo un 11 a 32 entradas) y el resto por orden son los modos comentados antes del men (modo manual, flanco de subida, flanco de bajada y patrn). Cuando el flag de lectura est a 1, el resto de bits deben estar a 0 y cuando el analizador reciba este byte, enviar los datos de sus RAM; si el bit de escritura est a 1, el de lectura estar a 0 y se indicar el nmero de entradas (de la forma que se explic antes) y el modo de disparo activando solamente el bit correspondiente a dicho modo.

Figura 1 : Byte de configuracin

Al iniciar el programa se pide al usuario que introduzca el valor del puerto que va a establecer la comunicacin (1 para COM1 y 2 para COM2) entre el PC y el analizador, entonces aparecer un men principal en el que se pide si se desea leer o escribir. En este momento, como no se ha configurado ni hecho nada previamente con el analizador, la nica opcin es la de escribir, entonces pulsando la tecla 2 se ir al men de disparo que contiene las 4 opciones mencionadas antes (manual, flanco y patrn). Al seleccionar la opcin deseada se proceder a pedir los datos de configuracin generales, es decir, nmero de entradas a muestrear, frecuencia de muestreo y nmero de muestras a almacenar y despus, en funcin del modo de disparo se pedirn ms datos o no: en el modo manual aparte de los datos de configuracin generales no se necesita nada ms, para el modo de flanco de subida y de bajada se requerir saber qu nmero de entrada de las que se van a muestrear va a ser la encargada de comenzar el muestreo, y en el modo patrn se necesitar saber el patrn en hexadecimal tambin correspondiente al nmero de entradas seleccionadas. Para la configuracin general, se ha establecido que en la frecuencia de muestreo se disponga de 2 bytes de resolucin respecto al reloj de la FPGA, es decir, el programa principal no enva directamente la frecuencia de muestreo que se desea tener, sino que se indica el nmero de ciclos del reloj de la FPGA que son necesarios contar para tener una frecuencia equivalente a la introducida por el usuario. De esta forma, segn se est utilizando el Analizador de prueba o el Analizador JTG_05, se tendr un rango de frecuencias distinto ya que cada analizador dispone de un reloj con una frecuencia distinta. Como se quiere una resolucin de 2 bytes (=65536 en decimal) si dividimos el valor de la frecuencia del reloj de la FPGA de cada analizador por 65536 obtendremos la frecuencia mnima de muestreo de cada analizador. Para el Analizador de prueba se tiene que la tarjeta Prince utiliza un oscilador de 14.7456 MHz, por lo que dividido por 65536 tenemos 225 Hz de frecuencia mnima y la mxima, obviamente, es la del propio reloj de la FPGA. Para el Analizador JTG_05 se tiene un reloj de 160 MHz (tambin es sta la frecuencia mxima) , obteniendo mediante la misma operacin de antes una frecuencia mnima de 2442 HZ. Por otro lado, dentro de la configuracin general se quiere indicar cuantas muestras del total se van a almacenar. Al disponer de unas memorias de 18 bits de direcciones (ms de 2 bytes), se necesitar enviar 3 bytes para indicarle al analizador cuntas muestras por memoria se van a almacenar.

SOFTWARE

Con todo esto, al seleccionar el modo de escritura dentro del men de disparo(se pulsa 1 para modo manual, 2 para flanco de subida, 3 para flanco de bajada y 4 para patrn), el programa principal enva al analizador el byte de configuracin, seguido de los 2 bytes de frecuencia y los 3 bytes correspondientes al nmero de muestras. Ms tarde, si se ha escogido flanco de subida o de bajada, se enviar el byte que indique la entrada que realizar el muestreo cuando se produzca el flanco seleccionado en dicha seal, y si se ha escogido el modo patrn, se enviarn los 4 bytes que contienen la informacin del valor transformado a binario (el usuario introduce el valor del patrn en hexadecimal) de todas las entradas para que se produzca el disparo. Tras haber enviado todos estos parmetros, si se cumplen las condiciones de disparo sealadas, el analizador comenzar a muestrear las seales de entrada hasta llegar a la posicin de memoria correspondiente al nmero de muestras seleccionado, momento en el cul, se enviar por parte del analizador ese nmero de muestras al ordenador por el mismo puerto serie abierto previamente. Ya con los datos recibidos, se volver al men principal donde se pedir al usuario que seleccione lo que desea hacer: leer esos datos recibidos, capturar unos nuevos en el analizador o reconfigurar los parmetros del analizador. Seleccionando de nuevo la escritura (opcin 2) no se vuelven a pedir los parmetros de configuracin. Si se escoge la primera opcin, se comenzar a escribir en un fichero con el nombre Analizador.vec el valor en binario de todas las muestras recibidas del nmero de entradas especificado. Este fichero tiene que tener la forma que sigue:
UNIT ns; INPUTS Entrada1 Entrada2 .... ; PATTERN 100 > 1 200 > 1 300 > 0 . . . ; 0 1 0 .... .... ....

Primero se indica las unidades de tiempo que se desean utilizar (ns, us, ms, s) escribiendo UNIT ns; (si se quieren unidades en nanosegundos), despus se indica el nombre de cada entrada mediante INPUTS Entrada1 y por ltimo se indica el valor
11

Memoria.Desarrollo

SOFTWARE

de cada entrada en cada intervalo de tiempo: para ello se indica el tiempo seguido de un indicador mayor > y despus el valor de cada entrada en el mismo orden con que se declararon los nombres de las entradas.

Para todo lo comentado se han realizado diversas funciones en C y C++, en C++ se han programado las funciones referentes al manejo del puerto serie en Windows, mientras que el resto del cdigo se ha hecho en C. Las funciones para utilizar el puerto serie han sido: BOOL Inicializar_puerto(), BOOL Escribir_puerto(DWORD num_datos), BOOL Leer_puerto(DWORD num_datos) y BOOL Cerrar_puerto(). Todas ellas devuelven un True o un FALSE segn se cumpla o no lo que quieren realizar. La funcin Inicializar_puerto abre el puerto serie especificado en la variable PUERTO que es una cadena con el valor COM1 o COM2 y abre ese puerto con los parmetros especificados en los Define, es decir, se definen el nmero de bits de datos, el nmero de bits de stop, la paridad y la velocidad de transmisin. El puerto se abre con la funcin CreateFile() en la que se indica el nombre del puerto, el propsito (lectura y/o escritura), si se desea compartir el recurso (al ser un puerto solamente lo puede utilizar una aplicacin), si hay que abrir un fichero existente o no (obviamente un puerto ya existe, por lo que no hay que crear uno nuevo), y el formato. Finalmente los atributos de esta funcin quedan de la siguiente forma:
CreateFile (GENERIC_READ | GENERIC_WRITE, PUERTO, 0, NULL, OPEN_EXISTING, 0, NULL);

Una vez abierto el puerto se comprueba que se ha abierto correctamente y se establece el tamao del buffer de envo y recepcin, seguido de los datos de velocidad, paridad etc.. y por ltimo los Timeouts o lo que es lo mismo los tiempos entre caracteres, el tiempo que se espera si no se recibe el dato o el tiempo que tarda a enviar el siguiente dato si el anterior no se ha enviado.

La funcin Escribir_puerto(DWORD num_datos) enva por el puerto abierto previamente el nmero de datos seleccionado en la variable num_datos, y si no puede enviar todos los datos da un error e indica cuntos caracteres han sido enviados.

12

Jaime Trinor Goira

SOFTWARE

La funcin Leer_puerto(DWORD num_datos) lee del puerto el nmero de datos especificados en num_datos y si no consigue leer ese nmero indica cuntos datos han sido ledos sobre el total. Por ltimo se tiene la funcin Cerrar_puerto() que cierra el puerto mediante el comando CloseHandle(hcom), siendo hcom la variable manejador del puerto definido y es una variable definida en las clases de Windows C++. Ya se han descrito las funciones programadas en C++ y ahora falta detallar las escritas en C, que son 2: void pide_datos(COMUNICACION *comuni,int opcion, int inicio); y void escribe_fichero(void); La funcin pide datos recibe la direccin de la estructura de tipo COMUNICACION que contiene el valor de los bytes descritos en este apartado (configuracin, frecuencia, flanco, patron y numero de muestras ), la opcin del men de disparo (variable entera que vale 1 para modo manual, 2 para flanco de subida, 3 para flanco de bajada y 4 para patrn) y por ltimo recibe la variable entera inicio que valdr 0 o ms y sirve para indicarle a la funcin si tiene que pedir los parmetros de configuracin del analizador o simplemente poner el flag correspondiente al modo de disparo. La funcin escribe_fichero(void); abre un fichero con el nombre Analizador.vec en modo escritura y almacena los datos recibidos del analizador, y que han sido guardados en el buffer del puerto serie, segn el nmero de entradas que se hallan seleccionado, la frecuencia y el nmero de muestras segn se coment con anterioridad. Por ltimo el programa principal se encarga de gestionar todas las funciones descritas y de mostrar el men principal (1.-Lectura, 2.-Escritura y 3.-Reconfiguracin) y el men de disparo (1.-Modo manual, 2.-Flanco de subida, 3.-Flanco de bajada y 4.-Patron) segn proceda y adems pedir el valor del puerto COM a abrir.

Con todo lo descrito se puede comprender y ver el cdigo resultante del programa realizado (solamente se muestra el programa del Analizador JT_05 ya que el programa del Analizador de Prueba es casi idntico y los dos vienen incluidos en el CD del proyecto) que viene a continuacin:

13

Memoria.Desarrollo

SOFTWARE

/********************************************************************* Programa: Analizador Descripcin: Realiza la configuracin de un analizador remoto para ms tarde recibir los datos de ste por el puerto serie y guardarlos en un fichero de tal forma que se pueda ver ms tarde su evolucin temporal a travs del MaxPlus II Autor: Jaime Trinor Goira *********************************************************************/

#include #include #include #include #include

<stdio.h> <stdlib.h> <conio.h> <windows.h> <winbase.h>

#define #define #define #define #define

BAUDIOS 115200 TAM_DATOS 8 PARIDAD NOPARITY BITSTOP ONESTOPBIT MAX_SIZE_BUFFER 2097152

// Velocidad de transmision/recepcion // Tamao de datos // Sin paridad // Un bit de stop //Mximo buffer de lectura/escritura //En Herzios

#define RELOJ_FPGA 160000000

typedef struct{ //Estructura de los bytes del analizador unsigned char byte_conf; unsigned char byte_freq1, byte_freq2; unsigned char byte_nivel, byte_flanco; unsigned char byte_patron1,byte_patron2,byte_patron3,byte_patron4; unsigned char n_muestras1,n_muestras2,n_muestras3; }COMUNICACION;

//Variables glogales HANDLE hCom;

// Manejador del puerto

unsigned char sBuffer[MAX_SIZE_BUFFER];// Buffer de lectura/escritura int n_entradas,frecuencia,num_muestras; char PUERTO[5];

//Funciones del programa void pide_datos(COMUNICACION *comuni,int opcion, int inicio); void escribe_fichero(void); // Funciones de manejo del puerto serie BOOL Inicializar_puerto(); BOOL Escribir_puerto(DWORD num_datos); BOOL Leer_puerto(DWORD num_datos); BOOL Cerrar_puerto();

14

Jaime Trinor Goira

SOFTWARE

void main()//Programa principal { COMUNICACION comuni; //Estructura de comunicacin int opcion1; int opcion2,inicializado=0; int comm=0; int s; char c; comuni.byte_conf=0x00; //Ponemos todos los flags del byte de configuracin a 0 printf("***** BIENVENIDO AL ANALIZADOR JTG *****\n"); printf("\nQue puerto serie desea abriar?(1 para COMM1, 2 para COMM2) "); scanf("%d",&comm); //Se comprueba que es un puerto vlido while(comm!=1 && comm!=2){ printf("Puerto incorrecto!\nEscriba un valor de puerto valido(1 o 2)"); scanf("%d",&comm); } if(comm==1) strcpy(PUERTO,"COM1"); else if(comm==2) strcpy(PUERTO,"COM2"); Inicializar_puerto(); //Abrimos y configuramos el puerto serie

do{ //Menu principal printf("\n*** MENU PRINCIPAL ***\n"); if(inicializado!=0) //Si todava no se han recibido datos porque todava no hemos //escrito nunca en la RAM, no es lgico escribir un fichero vaco printf("\n1.- Lectura de la RAM \n"); printf("2.- Escritura en la RAM \n"); if(inicializado!=0) //Si todavia no hemos configurado nada, no es lgico tener la // opcin de reconfigurar printf("3.- Reconfigurar Analizador \n \n"); printf(" Escoja una opcion, pulse 0 para salir ----> scanf("%d",&opcion1); if(opcion1==3 && inicializado!=0){ inicializado=0;//Le indicamos a Pide_datos que queremos cambiar //de frecuencia de muestreo o de nmero de entradas opcion1=2; //Vamos al men de escritura } ");

15

Memoria.Desarrollo

SOFTWARE

switch(opcion1){ case 0: printf("FIN del programa\n"); break; case 1: (comuni.byte_conf)&=0xFE; //Se elimina el flag de escritura si es que estaba activado (comuni.byte_conf)|=0x02; //ponemos el flag de lectura a 1 if(n_entradas==4) Leer_puerto(num_muestras*8); //en la placa final son 8 RAM else Leer_puerto(num_muestras*4); //recibimos la mitad de bytes que con 4 entradas //Leemos todos los datos del analizador y los copiamos en el buffer printf("\nLos 10 primeros datos recogidos son: %2x, %2x, %2x,%2x, %2x, %2x,%2x, %2x, %2x,%2x \n",sBuffer[0],sBuffer[1],sBuffer[2],sBuffer[3],sBuffer[4],sBuffer[5], sBuffer[6],sBuffer[7],sBuffer[8],sBuffer[9]); escribe_fichero(); break; case 2: for(s=0;s<MAX_SIZE_BUFFER;s++) sBuffer[s]=0; //Se limpia el Buffer del puerto serie para no confundir datos (comuni.byte_conf)&=0xFD; //Se elimina el flag de lectura si estaba activado (comuni.byte_conf)|=0x01; //Flag de escritura activado //Menu de disparo printf("\n*** MENU DE DISPARO ***\n"); printf("1 --- Modo MANUAL\n"); printf("2 --- Modo FLANCO de Subida\n"); printf("3 --- Modo FLANCO de Bajada\n"); printf("4 --- Modo PATRON \n\n"); printf("Escoja la opcion deseada:----> "); scanf("%d",&opcion2);

16

Jaime Trinor Goira

SOFTWARE

switch(opcion2){ case 1: pide_datos(&comuni,1,inicializado); inicializado++; printf("\n Pulse una tecla para comenzar el muestreo c=scanf("%c",&c); c=getchar(); ");

//Actualizamos la cadena a enviar por el puerto serie sBuffer[0]=comuni.byte_conf; sBuffer[1]=comuni.byte_freq1; sBuffer[2]=comuni.byte_freq2; sBuffer[3]=comuni.n_muestras1; sBuffer[4]=comuni.n_muestras2; sBuffer[5]=comuni.n_muestras3; Escribir_puerto(6); printf("\n Configuracion= %2x, freq1= %2x, freq2= %2x \n ",sBuffer[0],sBuffer[1],sBuffer[2]); break; case 2: pide_datos(&comuni,2,inicializado); inicializado++; sBuffer[0]=comuni.byte_conf; sBuffer[1]=comuni.byte_freq1; sBuffer[2]=comuni.byte_freq2; sBuffer[3]=comuni.n_muestras1; sBuffer[4]=comuni.n_muestras2; sBuffer[5]=comuni.n_muestras3; sBuffer[6]=comuni.byte_nivel; Escribir_puerto(7); printf("\n Configuracion= %2x ,freq1= %2x, freq2= %2x, %2x flanco \n",sBuffer[0],sBuffer[1],sBuffer[2],sBuffer[3]); break; case 3: pide_datos(&comuni,3,inicializado); inicializado++; sBuffer[0]=comuni.byte_conf; sBuffer[1]=comuni.byte_freq1; sBuffer[2]=comuni.byte_freq2; sBuffer[3]=comuni.n_muestras1; sBuffer[4]=comuni.n_muestras2; sBuffer[5]=comuni.n_muestras3; sBuffer[6]=comuni.byte_flanco; Escribir_puerto(7);

17

Memoria.Desarrollo

SOFTWARE

printf("\n Configuracion= %2x ,freq1= %2x, freq2= %2x, %2x flanco \n",sBuffer[0],sBuffer[1],sBuffer[2],sBuffer[3]); break; case 4: pide_datos(&comuni,4,inicializado); inicializado++; sBuffer[0]=comuni.byte_conf; sBuffer[1]=comuni.byte_freq1; sBuffer[2]=comuni.byte_freq2; sBuffer[3]=comuni.n_muestras1; sBuffer[4]=comuni.n_muestras2; sBuffer[5]=comuni.n_muestras3; sBuffer[6]=comuni.byte_patron1; sBuffer[7]=comuni.byte_patron2; sBuffer[8]=comuni.byte_patron3; sBuffer[9]=comuni.byte_patron4; Escribir_puerto(10); break; default: printf("Opcion no contemplada"); break; } break; default: printf("Opcion no contemplada"); break; } }while(opcion1!=0); Cerrar_puerto(); }

18

Jaime Trinor Goira

SOFTWARE

/********************************************************************* Funcin: Pide_datos Descripcin: actualiza los datos de configuracin del analizador en funcin de lo deseado por el usuario y pide los datos del nmero de entradas y frecuencia de muestreo sino han sido introducidas con anterioridad *********************************************************************/ void pide_datos(COMUNICACION *comuni,int opcion, int inicio) { int cuenta,nivel,patron; if(inicio==0){ printf("\n Indique la frecuecia de muestreo (en Herzios, entre 2500 Hz y 160000 KHz ):--> \n"); scanf("%d",&frecuencia); while(frecuencia<2500 || frecuencia>160000000){ //si estamos fuera de rango pedimos de nuevo printf("\n Frecuencia fuera de rango, introduzca una frecuencia correcta:--> "); scanf("%d",&frecuencia); } printf("\n Indique el numero de entradas a muestrear (4 8 16 32) :--> "); scanf("%d",&n_entradas); while(n_entradas!=4 && n_entradas!=8 && n_entradas!=16 && n_entradas!=32){ printf("\n Numero de entradas no valido, introduzca el numero correcto (4 8 16 32) :--> "); scanf("%d",&n_entradas); } printf("\n Indicar el numero de muestras a almacenar en cada RAM (de 1 a 262143)"); scanf("%d",&num_muestras); while(num_muestras<1 || num_muestras>262143){ printf("\n Numero de muestras invalido (de 1 a 262143)"); scanf("%d",&num_muestras); } comuni->n_muestras1 = num_muestras & 0x00FF; comuni->n_muestras2 = (num_muestras>>8) & 0x00FF; comuni->n_muestras3 = (num_muestras>>16) & 0x00FF; if(n_entradas==4) (comuni->byte_conf)|=0x00; if(n_entradas==8) comuni->byte_conf|=0x08;

19

Memoria.Desarrollo

SOFTWARE

if(n_entradas==16) comuni->byte_conf|=0x04; if(n_entradas==32) comuni->byte_conf|=0x0C; cuenta=RELOJ_FPGA/frecuencia; //tenemos que enviar al analizador el numero de ciclos //que tiene que contar de su reloj para hacer el muestreo deseado comuni->byte_freq1=(cuenta & 0x00FF); comuni->byte_freq2=(cuenta>>8) & 0x00FF; //Desplazamos 8 bits a la derecha para coger la parte alta de la cuenta } if(opcion==1) (comuni->byte_conf)|=0x10;//Flag de opcin manual activado if(opcion==2){ comuni->byte_conf|=0x20;

//Flag de flanco de subida activado

printf("\n Indicar que entrada va a activar el muestreo por flanco de subida :--> "); scanf("%d", &nivel); while(nivel<1 || nivel>n_entradas){ printf("\n Entrada no reconocida, vuelvalo a intentar (entradas posibles de la 1 a la %2d):-->",n_entradas); scanf("%d", &nivel); } (comuni->byte_nivel)=(nivel & 0x00FF)-1; printf("\n Nivel es: %4x ",comuni->byte_nivel); } if(opcion==3){ comuni->byte_conf|=0x40;

//Flag de flanco de bajada activado

printf("\n Indicar que entrada va a activar el muestreo por flanco:-->"); scanf("%d", &nivel); while(nivel<1 || nivel>n_entradas){ printf("\n Entrada no reconocida, vuelvalo a intentar (entradas posibles de la 1 a la %2d):-->",n_entradas); scanf("%d", &nivel); } comuni->byte_flanco= (nivel & 0x00FF)-1; printf("flanco es %4x \n",comuni->byte_flanco); }

20

Jaime Trinor Goira

SOFTWARE

if(opcion==4){ comuni->byte_conf|=0x80; //Flag de patrn activado

printf("\n Introduzca el valor del patron a reconocer en hexadecimal:--> "); scanf("%x",&patron); while(((patron>0x000F) && n_entradas==4)||((patron>0x00FF)&& n_entradas==8) || ((patron>0xFFFF) && n_entradas==16)){ printf("\n Patron fuera de rango, ponga un patron acorde con el numero de entradas : (%2x entradas -> %2x bits):->",n_entradas,n_entradas); scanf("%x",&patron); } comuni->byte_patron1= comuni->byte_patron2= comuni->byte_patron3= comuni->byte_patron4= (patron) & 0x00FF; (patron>>8) & 0x00FF; (patron>>16) & 0x00FF; (patron>>24) & 0x00FF;

printf("\n El patron es: %12x, byte_patron1 %4x,byte_patron2 %4x, byte_patron3 %4x, byte_patron4 %4x \n",patron, comuni>byte_patron1,comuni->byte_patron2,comuni->byte_patron3,comuni>byte_patron4); } printf("\n Cuenta: %4d , byte_freq1: %4x, byte_freq2: %4x, byte_conf: %4x ",cuenta,comuni->byte_freq1,comuni->byte_freq2,comuni>byte_conf); }

21

Memoria.Desarrollo

SOFTWARE

/******************************************************************** Funcin: escribe_fichero Descripcin: escribe en un fichero con el nombre analizador.vec los datos recibidos por la via serie de tal forma que puedan ser representados temporalmente en el MaxPlus. Se debe escribir de la siguiente forma: UNIT ns; INPUTS Entrada1 Entrada2 .... ; PATTERN 100 > 1 0 .... 200 > 1 1 .... 300 > 0 0 .... . . . ; *********************************************************************/ void escribe_fichero(void) { int i=0,j=0,k=0,h=0,m=0; long int tiempo=0; FILE *pfichero; if((pfichero=fopen("analizador.vec","w"))==NULL){ //Abrimos fichero en modo escritura printf("Imposible abrir el archivo \n"); fclose(pfichero); exit(1); } fputs("UNIT ns;\nINPUTS",pfichero); //Ponemos las unidades de tiempo for(k=1;k<=n_entradas;k++){ fputs(" Entrada",pfichero); //Le decimos cuantas entradas hay que representar y sus nombres fprintf(pfichero,"%d",k); } fputs(";\nPATTERN ",pfichero);//Le damos los datos de forma binaria if(n_entradas==4){ for(i=0;i<num_muestras*8;i++){ tiempo=(1e9/frecuencia)*i; fprintf(pfichero,"\n%12d",tiempo); fputs(">",pfichero); for(j=0;j<4;j++){ //Como hay que escribir un valor por entrada, //se desplaza una posicin j a la derecha y se escribe en el fichero if((sBuffer[i]>>j)&0x01==0x01) //Se escribe en ASCII fputs(" 1",pfichero); else fputs(" 0",pfichero); } }

22

Jaime Trinor Goira

SOFTWARE

}else{//tenemos las mitad de bytes recibidos un nmero de entradas //distinto a 4 for(i=0;i<num_muestras*4;i++){ tiempo=(1e9/frecuencia)*i; fprintf(pfichero,"\n%12d",tiempo); fputs(">",pfichero); //Hemos recibido distintos bytes para las distintas entradas, // pero se corresponden con la misma posicin //de memoria (intervalo de tiempo) for(j=0;j<n_entradas;j++){ if(j==8 || j==16 || j==24) i++; //Si hemos terminado de escribir un byte pasamos al siguiente if((sBuffer[i]>>h)&0x01==0x01) fputs(" 1",pfichero); else fputs(" 0",pfichero); h++; if(h==8) h=0; //Si hemos desplazado los 8 bits a la derecha de un byte, //habr que desplazar el siguiente byte que se corresponde //con las siguientes 8 entradas } } } fputs(";",pfichero); fclose(pfichero); }

23

Memoria.Desarrollo

SOFTWARE

/********************************************************************* Funcin: Inicializar_puerto Descripcin: Esta funcion abre el puerto especificado en los #define y lo configura *********************************************************************/ BOOL Inicializar_puerto() { DCB dcb; // Propiedades del puerto COMMTIMEOUTS CommTimeouts; // Propiedades time-out del puerto // Abrimos el puerto hCom=CreateFile(PUERTO, GENERIC_READ | GENERIC_WRITE, 0, // acceso exclusivo NULL, // sin seguridad OPEN_EXISTING, 0, // no overlapped I/O NULL); // null template // Comprobamos resultado de apertura if (hCom == INVALID_HANDLE_VALUE) { printf("Error abriendo puerto: %s\n", GetLastError()); //0 return FALSE; } // Configuramos tamao de buffer de escritura/lectura if(!SetupComm(hCom, MAX_SIZE_BUFFER, MAX_SIZE_BUFFER)) { printf("Error configurando buffer: %s\n", GetLastError()); return FALSE; } // Configuramos el puerto //Obtenemos configuracion actual del puerto if(!GetCommState(hCom, &dcb)) { printf("Error obteniendo configuracion actual: %s\n", GetLastError()); return FALSE; } // Velocidad de transmision a 115200 dcb.BaudRate = BAUDIOS; // 8 bits de datos dcb.ByteSize = TAM_DATOS; // Sin paridad dcb.Parity = PARIDAD; // Un bit de stop dcb.StopBits = BITSTOP; // Abortar la escritura/lectura en caso de error dcb.fAbortOnError = TRUE;

24

Jaime Trinor Goira

SOFTWARE

// Establecemos la nueva configuracion if(!SetCommState(hCom, &dcb)) { printf("Error estableciendo nueva configuracion: %s\n", GetLastError()); return FALSE; } // Obtenemos configuracion de time-out actual if(!GetCommTimeouts (hCom, &CommTimeouts)) { printf("Error obteniendo configuracion time-out actual: %s\n", GetLastError()); return FALSE; } // Configuramos time-outs // Tiempo maximo en mseg. entre caracteres CommTimeouts.ReadIntervalTimeout = 50; // Multiplicador en mseg. usado para calcular el time-out // total para la recepcion de los datos CommTimeouts.ReadTotalTimeoutMultiplier = 10; // Constante a sumar al time-out total de recepcion CommTimeouts.ReadTotalTimeoutConstant = 50; // Igual que lectura CommTimeouts.WriteTotalTimeoutMultiplier = 10; // Igual que lectura CommTimeouts.WriteTotalTimeoutConstant = 50; // Establecemos nuevos valores de time-out if(!SetCommTimeouts (hCom, &CommTimeouts)) { printf("Error estableciendo nueva configuracion time-out: %s\n", GetLastError()); return FALSE; } return TRUE; } /********************************************************************* Funcin: Escribir_puerto Descripcin: Enva el nmero de datos especificado previamente alamcenados en el buffer ********************************************************************/ BOOL Escribir_puerto(DWORD num_datos) { DWORD iBytes; // Escribir if(!WriteFile(hCom, &sBuffer, num_datos, &iBytes,NULL)) { printf("Error escribiendo en puerto: %s\n", GetLastError()); return FALSE; } // Se comprueba si ha ido todo bien if(iBytes != num_datos) printf("Aviso: no se han escrito todos los datos (%d -> %d)\n", iBytes, num_datos); return TRUE; }

25

Memoria.Desarrollo

SOFTWARE

/********************************************************************* Funcin: Leer_puerto Descripcin: Recibe por el puerto serie el nmero de datos especificado, de lo contrario lo indica con un error. ********************************************************************/ BOOL Leer_puerto(DWORD num_datos) { DWORD iBytes; // Leer if(!ReadFile(hCom, &sBuffer, num_datos, &iBytes, NULL)) { printf("Error: leyendo en puerto: %s\n", GetLastError()); return FALSE; } // Se comprueba si han llegado todos los datos esperados if(iBytes != num_datos) printf("Aviso: No se han leido todos los datos (%d -> %d)\n", iBytes, num_datos); return TRUE; } /********************************************************************* Funcin: Cerrar_puerto Descripcin: Cierra el puerto serie especificado en el #define commX ********************************************************************/ BOOL Cerrar_puerto() { // Cerrar puerto return CloseHandle(hCom); }

26

Jaime Trinor Goira

Memoria. Desarrollo

Hardware
Se ha explicado que un analizador de estas caractersticas (basado en una FPGA), bsicamente, coge los valores de una serie de seales de entrada y las va almacenando en una memoria a una velocidad determinada. Para realizar esto, se necesita de un proteccin entre lo que se conecta (seales de entrada) y el analizador (mediante unos Buffer), una o varias memorias para almacenar los datos de entrada (RAM de tipo esttica) y una FPGA que ser la encargada de marcar la velocidad de muestreo y de enviar los datos al PC una vez se halla terminado la escritura. Con todo esto se va a partir del esquema de la siguiente figura:

Figura 1: Esquema bsico del circuito a realizar

En este proyecto se buscaba disponer de un analizador barato, rpido, con la mayor profundidad de datos posibles (mximo nmero de muestras) y a la vez con un nmero de entradas a muestrear lo ms elevado posible dentro de un presupuesto ajustado, por ello a la hora de buscar los componentes del analizador, se hizo hincapi en adquirir una memoria RAM que poseyera todas estas caractersticas que se han comentado ya que el resto de componentes ha adquirir no varan de precio ya que solamente se pueden poner esos (FPGA, buffers, etc). Entonces, para abaratar costes, en vez de comprar una memoria RAM de mucha capacidad y a la vez rpida y de muchas entradas (memoria difcil de encontrar y muy cara), se compraron 8 memorias de 256 KB por 4 entradas cada una y con un tiempo de acceso de 12 ns. De esta forma se tiene varias configuraciones (en cuanto al nmero de entradas a muestrear) posibles:
27

Memoria.Desarrollo

HARDWARE

1.- Se pueden muestrear 4 entradas con una profundidad de 2 MB (256 KB x 8 memorias = 2MB). 2.- Disponiendo de 8 entradas a muestrear (se utilizan 2 memorias a la vez en cada intervalo de escritura/lectura), se tiene una profundidad de 1MB (256 KB x 4 grupos de memorias) 3.- Otra opcin es guardar los datos de 16 seales de entradas y, en tal caso, se podrn almacenar hasta 512 KB en muestras debido a que en cada intervalo de muestreo se utilizan 4 memorias a la vez para poder tener las 16 entradas. 4.- La ltima posibilidad con este nmero de memorias es la de muestrear 32 entradas, lo que implica que se utilizan todas las RAM a la vez en cada ciclo de escritura/lectura. Ya con los componentes bsicos bien definidos (FPGA, Buffers y SRAMs) hay que completar el circuito con el resto de elementos necesarios para su correcto funcionamiento. A la hora de realizar el diseo del circuito impreso del analizador se vio que era necesario mandar a hacer la placa serigrafiada a una fbrica especializada ya que para el montaje y soldadura de la FPGA y para tener un circuito con una anchura de pistas de 8 milsimas (clase 4 de fabricacin), stas solo pueden hacerse mediante mquinas especiales. Cuando se pidi presupuesto para el montaje y realizacin de estas placas se descubri que tena un coste muy elevado y por ello se opt por realizar primero un circuito de prueba, llamado Analizador de Prueba de la tarjeta Prince, para validar todo el diseo del Analizador JTG_05 y, de esta forma asegurarse de que el diseo de la placa final es correcto y sirve para sus propsitos descritos. Por otro lado, tambin haca falta comprobar que la FPGA elegida vala para el diseo realizado (tiene el nmero de puertas necesarias, velocidad adecuada, nmero de entradas-salidas suficientes, etc). Por todo ello se pens en utilizar la Tarjeta Prince de la universidad (ya utilizada en asignaturas anteriores, algo que facilitaba su manejo) porque dispone de una FPGA con el mismo tamao de puertas y entradas - salidas que la del diseo. No obstante, es un modelo ms lento que la que se deseaba adquirir, pero para realizar el conjunto de pruebas para validar el proyecto era suficiente. Adems esta tarjeta tambin posee su propio oscilador de cuarzo, pulsadores, leds y puerto serie conectado a la FPGA con lo que no era necesario montar ningn circuito de acondicionamiento de seales ni nada por el estilo.

28

Jaime Trinor Goira

HARDWARE

Placa de Prueba

Placa de Prueba Como se ha dicho ya, con este circuito se va a conseguir utilizar la FPGA de la tarjeta Prince en la que se cargarn todos los controles y circuitos necesarios para hacer las funciones del analizador final. En esta placa de prueba se incorporar un Buffer de proteccin de 8 entradas, y 2 memorias RAM (una del banco de memorias A y la otra del B) con el objetivo de llevar a cabo todas las pruebas necesarias de velocidad y configuracin. Al tener 2 memorias, solamente se podr habilitar este analizador de prueba hasta 8 entradas en vez de 32 que es lo que poseer el diseo final. Por otro lado, al utilizar la FPGA de la tarjeta Prince y su propio reloj (14.7456 MHz), la velocidad quedar limitada a 70 ns de acceso en la memoria, valor muy lejano al tiempo mnimo de las RAM adquiridas (12 ns). Con el fin de utilizar la FPGA de la universidad, se adecuar un circuito de tal manera que se pueda acoplar ste a la tarjeta Prince utilizando los 4 conectores (4 conectores de 46 pines cada uno en formato hembra) incorporados para la verificacin y comprobacin de las seales externas de la FPGA y que se puede ver el la Foto 1. Por otro lado habr que tener en cuenta que dichas seales se encuentran conectadas fsicamente con otros dispositivos que no son necesarios para el analizador pero que sin embargo estn ah (microcontrolador, memoria RAM, conversores analgicos/digitales displays de 7 segmentos, LCD, etc...). Viendo los esquemas elctricos de la tarjeta Prince (se incluyen en el CD del proyecto para poder ser consultados), se han utilizado seales que no influyen tanto en el dispositivo a crear como en los conectados a la FPGA, estos son los pines conectados a diodos leds, seales de datos del microcontrolador, bus de datos y de direcciones de la RAM de la tarjeta, etc.. No se ha seleccionado ninguna seal de habilitacin de estos dispositivos para que no introduzcan valores errneos en las seales que utiliza el Analizador de Prueba.

29

Memoria.Desarrollo

HARDWARE

Placa de Prueba

Foto 1: Tarjeta Prince (FPGA y conectores)

En total hay que tener en cuenta que se necesitan utilizar las siguientes seales: los 18 bits de direcciones de las 2 memorias RAM (lo que hace 36 bits de salida) que son Dir1_[17..0] y Dir2_[17..0], 4 bits de datos por cada RAM (8 datos de entrada/salida para escribir/leer en las memorias) con el nombre Datos_RAM_[7..0], 8 seales de entrada (las que se van a muestrear) Entrada[7..0], las seales de habilitacin del Buffer Enable_A (que habilita los 4 primeros bits de entrada) y Enable_B (que habilita los otros 4 bits de entrada), las seales de habilitacin de las memorias RAM Chip_selects_0 para la RAM A1 y Chip_selects_1 para la RAM B1, y sus respectivos Write Enable y Output Enable WE1, WE2 y OE (salidas). Tambin se han dirigido dos seales a dos leds de la barra de leds de la tarjeta para indicar si se est leyendo (en realidad transmitiendo) o escribiendo en las memorias. Estas seales reciben el nombre de Leyendo y Escribiendo. Por ltimo faltan las seales que alimenten a los 3 dispositivos (RAM 1, RAM 2 y al Buffer de proteccin).

30

Jaime Trinor Goira

HARDWARE

Placa de Prueba

Seal Dir1_0 Dir1_1 Dir1_2 Dir1_3 Dir1_4 Dir1_5 Dir1_6 Dir1_7 Dir1_8 Dir1_9 Dir1_10 Dir1_11 Dir1_12 Dir1_13 Dir1_14 Dir1_15 Dir1_16 Dir1_17 Dir2_0 Dir2_1 Dir2_2 Dir2_3 Dir2_4 Dir2_5 Dir2_6 Dir2_7 Dir2_8 Dir2_9 Dir2_10 Dir2_11 Dir2_12 Dir2_13 Dir2_14 Dir2_15 Dir2_16 Dir2_17

Pin FPGA Pin Conector 18 17 24 26 25 28 27 29 40 39 41 44 46 45 47 89 88 92 93 96 95 97 99 100 126 125 128 127 134 133 136 173 174 170 172 168 16 15 18 20 19 22 21 23 34 33 35 38 40 39 41 30 29 32 33 36 35 37 39 40 29 30 27 28 23 24 21 30 29 32 31 34

Conector 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 4 4 4 4 4 4 4 4 4 3 3 3 3 3 3 3 2 2 2 2 2

Seal Entrada1 Entrada2 Entrada3 Entrada4 Entrada5 Entrada6 Entrada7 Entrada8 Datos_RAM_0 Datos_RAM_1 Datos_RAM_2 Datos_RAM_3 Datos_RAM_4 Datos_RAM_5 Datos_RAM_6 Datos_RAM_7 linea_serie_TX linea_serie_RX Chip_selects_0 Chip_selects_1 OE WE1 WE2 Leyendo Escribiendo Disp_lleno Reloj Reset GND_RAM_A VCC_RAM_A GND_BUFFER VCC_BUFFER GND_RAM_B VCC_RAM_B Enable_A Enable_B

Pin FPGA Pin Conector 135 122 121 120 167 163 164 162 132 131 140 139 142 141 144 143 30 31 90 166 161 94 169 149 148 150 79 180 22 31 32 33 35 38 37 39 25 26 17 18 15 16 13 14 24 25 31 36 40 34 33 8 9 7 23 24 27 37 6 11 41 43 160 159 41 42

Conector 3 3 3 3 2 2 2 2 3 3 3 3 3 3 3 3 1 1 4 2 2 4 2 3 3 3 4 2 1 1 3 3 3 3 2 2

Tabla 1: Pines conectados a la FPGA de la tarjeta Prince

En la Tabla 1 se recogen los pines de la FPGA a los que van a ir conectados los elementos de la placa de prueba. Estos pines se han seleccionado teniendo en cuenta los criterios anteriores (no utilizar seales de habilitacin de ningn componente de la tarjeta Prince y tener en cuenta qu seales son de entrada o de salida). Ya con todos los pines escogidos, se procede al diseo del circuito de la placa con el programa Eagle Layout Editor abriendo un Schematic donde se incluirn los elementos del circuito (Buffer, RAM1, RAM2 y condensadores de alimentacin), este esquema se puede observar en el apartado SCHs de la memoria. Con todos los dispositivos aadidos al esquema, se procedi a nombrar todas las entradas y salidas del circuito para que al exportar el esquema al circuito (Board del programa de diseo), se pudiera encaminar todas las pistas a su correspondiente destino. La placa se dise a 2 capas segn se ve en la Figura 1 (los cables de color rojo corresponden a pista por la cara de arriba y los azules a la cara de abajo).

31

Memoria.Desarrollo

HARDWARE

Placa de Prueba

Figura 2: Diseo de la placa de prueba

Lo ms importante a la hora de hacer el diseo fue la de medir con precisin la distancia entre los conectores de la tarjeta Prince puesto que si no se era muy preciso, no se conseguira encajar la placa de prueba en la tarjeta Prince. Para ello se imprimi en una transparencia el circuito (solamente con sus conectores y con un medidor preciso se corrigi hasta coincidir exactamente cada punto de la placa de prueba con su homlogo de la tarjeta). Algo tambin importante era la de minimizar el nmero de vias (taladros de la placa que unen una pista de la cara de arriba con la cara de abajo) ya que la placa se realiz de forma manual en la universidad.

La placa de prueba, como se ha comentado, se desarroll en la universidad mediante isolacin, revelado y ataque qumico de la placa, es decir, se obtuvo una placa de doble cara positiva de dimensiones acordes al circuito y se coloc el circuito impreso en hojas de transparencia, cada cara del circuito pegada a su correspondiente cara de la placa. De esta forma se abri una ventana en las partes del circuito que no tenan pistas, atacando a la fotoresina de la placa con luz ultravioleta durante 5 minutos. Despus se procedi con el revelado de la placa mediante un compuesto especial, y por ltimo se atac al xido correspondiente con la ventana abierta con cido clorhdrico. Ya con el circuito impreso en la placa, se hicieron los agujeros correspondientes al conector macho de cada lado que deba coincidir con el conector de la tarjeta Prince, utilizando como patrn una placa de soldadura con una separacin entre agujeros iguales a los que se deseaban obtener. Teniendo ya los agujeros de los conectores, se hicieron las
32 Jaime Trinor Goira

HARDWARE

Placa de Prueba

perforaciones de las vas para ms tarde unirlas con pequeos hilos de cobre. Por ltimo se soldaron los componentes y se teste el circuito comprobando que los extremos de cada pista tenan continuidad.

Foto 2: Placa de prueba desde distintos ngulos

En la Foto 2 se puede ver la placa realizada con su cara de arriba, su cara de abajo y su perfil. Tambin se podr apreciar que existen cuadrados y rectngulos de cobre en ambas caras y no se corresponden con ninguna pista ni ninguna seal, esto se debe a que se hizo al principio una placa similar pero sin estos polgonos, y se apreci en la placa que existan muchos cortes en las pistas del circuito (no haba continuidad entre sus extremos), y esto se deba a que el cido atacaba a la mayor parte del circuito (haba ms oxido que eliminar que pistas que dejar), y al atacar a tanto porcentaje del circuito, algunas seales se vean eliminadas en ciertas zonas. Por eso se recomienda a la hora de realizar placas de circuito similares, siempre utilizar la anchura mxima de pista posible y aadir los polgonos mencionados para que el cido no se coma partes esenciales del diseo.

33

Memoria.Desarrollo

HARDWARE

Placa de Prueba

Foto 3: Placa de Prueba acoplada a la tarjeta Prince

En esta ltima foto de esta parte de la memoria (Foto 3) se puede apreciar el acoplo realizado de la placa de prueba con la tarjeta Prince. Mediante un cable cinta de 10 pines acoplado al conector de arriba a la derecha de la placa de prueba se pueden introducir las seales de entrada de cualquier dispositivo digital.

34

Jaime Trinor Goira

HARDWARE

Placa del Analizador JTG_05

Esta placa va a tener que realizar las tareas que tena encomendadas la tarjeta Prince, por lo que debe ser capaz de comunicarse con un PC mediante un puerto serie. Dispondr de varios pulsadores para realizar pruebas de muestreo (uno de ellos ser el reset general), tendr que tener luces que indiquen el modo en el que est el analizador y adems, poseer una toma de alimentacin del circuito. Por supuesto, tendr que disponer de los dispositivos bsicos del analizador (memorias y buffers) que estaban en la placa de prueba y poseer una FPGA para gestionar todos los bloques del analizador (recepcin serie, comprobacin de disparo, muestreo, lectura y transmisin serie). Segn se describi al principio del captulo, se han adquirido 8 memorias RAM de tipo estticas para poder tener ms o menos entradas a muestrear a costa de tener menos o ms profundidad de muestras respectivamente. Como se van a poder muestrear hasta 32 seales digitales, se van a necesitar 4 Buffers de proteccin ya que a cada uno se le puede conectar solamente a 8 entradas.

Las RAM van conectadas en 2 bancos de memorias (banco A y banco B), por lo que hay 2 grupos de 4 memorias y a cada grupo o banco se les conecta el bus de direcciones respectivo (Dir1[0..17] y Dir2[0..17]). Tambin se le conecta a cada grupo la seal de habilitacin de escritura correspondiente (WE1 y WE2), mientras que la seal de habilitacin OE est conectada a todas las memorias y a la FPGA, y su valor es siempre el mismo (0) puesto que gestionando solamente las seales de WE y de CS se es capaz de almacenar y leer datos de las memorias. Esta forma de conexin (2 bancos de memorias) se realiza para poder duplicar la velocidad en el tiempo de escritura de la RAM, es decir, como cada memoria tiene un ciclo mnimo de escritura/lectura de 12 ns (aproximadamente 83 MHz), si en un ciclo del reloj de la FPGA (160MHz) se pone una posicin de memoria en una RAM del banco A de memorias y se mantiene esa posicin otro ciclo ms, cumplimos el tiempo mnimo de escritura. Si adems, en el segundo ciclo de reloj de escritura de la RAM del banco A comenzamos a escribir en una memoria del banco B la siguiente muestra de las entradas y as sucesivamente alternando los dos bancos de memorias, conseguiremos que la velocidad de muestreo

35

Memoria.Desarrollo

HARDWARE

Placa final

mxima absoluta pase de 12ns a la mitad ,6ns (en realidad un poco ms lento puesto que el reloj de la FPGA es de 160MHz, menor que 2 x 83,3MHz).

Con respecto a los Buffer de proteccin se han conectado las seales de habilitacin de tal forma que haya el mnimo nmero posible de dichas seales, es decir, como cada Buffer posee 2 seales Enable, una para cada grupo de 4 entradas, se tendra que controlar 16 seales de habilitacin, sin embargo las configuraciones posibles son solo de 4, 8, 16 32 entradas a muestrear por lo que con 4 seales Enable sera suficiente, por lo que las 2 seales de habilitacin del Buffer 2 (Enable_2A y Enable_2B) se han conectado al mismo punto, originando la seal de habilitacin Enable3, al igual que se ha hecho con las 4 seales de los otros 2 Buffer (Buffer 3 y 4) para obtener la seal Enable4. Para una configuracin de 4 entradas se activara el Enable1 (primer Enable del Buffer A), para 8 entradas se utilizaran los Enables Enable1 y Enable2 (los 2 del Buffer A), para 16 entradas pasaramos a habilitar el Enable 3 junto con los anteriores y con 32 entradas se manejaran todos los Enables con el mismo valor. Hay que tener en cuenta que si se quiere poseer de unos pulsadores de control, es necesario aadir un pequeo circuito para evitar rebotes en estas piezas, ya que al ser algo mecnico, est expuesto a vibraciones no controladas. Para evitar estos rebotes se pondr un inversor con Trigger Schmitt para que la salida del pulsador no cambie hasta unos lmites en los que no afecten las pequeas oscilaciones indeseadas. Seguido de este dispositivo se pondr otro inversor para volver a tener el valor deseado del pulsador. En cuanto a la comunicacin serie, hay que comentar que los valores de tensin de los bits que se transmiten y reciben son distintos que los de los valores que maneja el resto del circuito, es decir, se envan y reciben datos entre +/-12 voltios, sin embargo el circuito trabaja a una tensin digital tpica de 5 voltios por lo que habr que poner un conversor de nivel a la entrada del puerto serie del analizador que convierta de +/- 12 voltios a un valor de 5 0 voltios cuando se reciban bits por este canal y que haga la tarea inversa cuando se desee enviar datos del analizador al PC (ponga 12 voltios cuando reciba un 1 en digital o -12 voltios cuando reciba un 0). Por otro lado, se tiene que la FPGA hay que programarla de alguna forma, por lo que habr que aadir al diseo un circuito que configure la FPGA cada vez que se conecte a

36

Jaime Trinor Goira

HARDWARE

Placa final

la alimentacin (de otra forma todo lo configurado en la FPGA se borrar), es decir, que todos los controles y circuitos internos que se necesitan tener en la FPGA (ver captulo de VHDL) para realizar las tareas del analizador, deben permanecer o volver a aparecer en la FPGA cada vez que se vuelva a conectar la alimentacin. Para ello existe un circuito que es una memoria flash, que no se borra si se desconecta la alimentacin, que se conectar a la FPGA, en la cual se almacena el valor de lo que debe haber en la FPGA para actuar como un analizador y si se enciende el analizador, esta memoria enva su contenido a la FPGA y la vuelve a configurar. Los ltimos componentes que se necesita tener son diversos conectores para programar la memoria flash descrita y configurar la FPGA, otros conectores para acoplar las seales de entrada del dispositivo a analizar de distintas formas (mediante cables cinta, conector macho o conector hembra, eso depender del circuito al que se conecte) y por ltimo unos conectores para ver en cualquier momento cualquiera de las seales de entrada o salida de la FPGA. Con todo lo descrito se tienen todos los componentes del analizador, que son los que siguen a continuacin: FPGA: de la marca Altera modelo 10k30-Q208-1, de 30.000 puertas lgicas, 208 pines (147 de entrada/salida disponibles para el usuario) y velocidad -1(es el modelo ms rpido, permitiendo hasta 200 MHz).

8 memorias: Memorias RAM estticas de la marca IDT modelo 71028, 28 pines con montaje superficial, 256kB x 4 entradas y 12 ns de tiempo de acceso.

37

Memoria.Desarrollo

HARDWARE

Placa final

4 Buffers no inversores de la marca Texas Instruments modelo 74ACT244 de 20 pines cada uno, con un tiempo de propagacin de puerta de 3.6 ns. Se han buscado estos (serie ACT) puesto que son los ms rpido del mercado y como se requiere de tiempos rpidos para la escritura de las memorias, se necesita que el resto de componentes tambin sean tan rpidos o ms que las RAM.

Reloj de 100 MHz (Oscilador) con cristal de cuarzo. La FPGA dispone de un PLL interno que hace duplicar la velocidad del reloj que se introduce. Es el que va a marcar cada cunto tiempo se hace una operacin dentro de la FPGA.

4 pulsadores para realizar pruebas de forma manual sin necesidad de conectar el analizador a un PC, adems uno de ellos ser el Reset general del sistema por el cul llevar a todos los controles internos de la FPGA a su estado inicial, deteniendo todo el proceso.

4 leds indicadores del estado del analizador (operativo, leyendo, escribiendo y dispositivo lleno).

38

Jaime Trinor Goira

HARDWARE

Placa final

Configurador de la FPGA con memoria interna de Altera modelo EPC2TC32 para que cada vez que se conecte la alimentacin, reconfigure la FPGA con el programa del analizador.

Conector DB9 macho para puerto serie. Permite establecer la conexin entre el analizador y un PC.

Conversor de nivel para interface MAX232, se utiliza para convertir las seales que se reciben por el puerto serie (+-12 voltios) a seales lgicas de 5 0 voltios.

1 chip 74HC14D con 6 Trigger Schmith inversores para anular los rebotes de los pulsadores.

39

Memoria.Desarrollo

HARDWARE

Placa final

1 chip 74HC05 con 6 inversores para tener el valor deseado de los pulsadores.

2 Conectores hembra para cable cinta de 34 pines para conectar las 32 seales de entrada. Cada entrada va conectada al pin impar de cada conector, estando los pines pares conectados a masa para evitar capacidades parsitas en los cacles de entrada y con el objetivo de evitar interferencias y acoplamiento de ruidos entre seales. El pin 33 del segundo conector est asociado a una entrada de reloj externo de la FPGA por si se quiere sincronizar el analizador con algn dispositivo externo.

1 Conector de 10 pines para la configuracin de la FPGA y de la programacin de la memoria flash. Se ha optado por establecer una comunicacin entre el PC y la FPGA de la forma byte_blaster (puerto paralelo del PC y conector de 10 bits en el analizador). 1 Conector de alimentacin a 5 voltios. 4 Conectores hembra de 50 pines para poder ver en todo momento cualquier seal acoplada a la FPGA. El resto de componentes se corresponden a condensadores conectados entre alimentacin y masa con el fin de mantener la tensin estable entre unos dispositivos y otros cuando la alimentacin pueda fluctuar si algn dispositivo pide ms o menos corriente. Los ltimos componentes son resistencias para fines diversos que se podrn ver en los esquemas del captulo Esquemas.

40

Jaime Trinor Goira

HARDWARE

Placa final

El circuito se ha diseado ntegramente con el programa Eagle Layout Editor, siendo un circuito de 4 capas habiendo dos planos (uno de alimentacin VCC y otro de masa GND) y dos capas superficiales conteniendo el resto de seales de datos. La configuracin, los grosores del cobre de las distintas capas y la separacin entre capas es la que se puede ver en la Figura 1, siendo las capas internas las de alimentacin.

Figura 1: distancias entre capas y espesor del cobre

Por otro lado, las separaciones entre vias, seales y pads son las definidas en las normas de fabricacin para clase 4, es decir, con una anchura mnima de y entre seales de 8 milsimas, los dems parmetros se pueden ver en el anexo Especificaciones de Fabricacin que viene en el CD del proyecto.

Figura 2: Distancia entre pistas

41

Memoria.Desarrollo

HARDWARE

Placa final

Los nombres de las seales y los circuitos a los que estn conectadas vienen definidas en el apartado SCHs de la memoria y el diseo realizado con la ubicacin de todos los componentes se puede observar en la Figura 3 y en la Figura 4 se aprecia en color rojo las seales de la cara de arriba y en azul las seales de la cara de abajo.

Figura 3: Placa final, ubicacin de los componentes

Figura 4: Diseo final de las pistas de la placa

42

Jaime Trinor Goira

HARDWARE

Placa final

Hace falta detallar qu seales van conectadas a la FPGA y cules de ellas son entradas o salidas. La FPGA dispone de 147 pines libres para que el usuario los use como entradas o salidas a voluntad, los pines de alimentacin se conectarn al correspondiente plano de alimentacin (masa o Vcc). Teniendo en cuenta todos los componentes del circuito vamos a tener las siguientes seales por componentes: Memorias RAM: 18 bits de direcciones (salidas) por cada banco de memoria (en total 36 seales), Dir1_[0..17] y Dir2_[0..17], 8 salidas conectadas cada una a la seal de habilitacin de la RAM correspondiente (CS[1..8]), 2 salidas conectadas cada una de ellas al selector de escritura de cada banco de memoria (WE1 y WE2), 4 entradas-salidas por cada RAM para la lectura o escritura de las mismas (32 seales) y por ltimo la seal de Output Enable de las memorias (todas estn conectadas al mismo cable por simplicidad, como ya se coment). Las memorias ocupan un total de 79 pines de la FPGA. Buffers de proteccin: 8 entradas por cada buffer, que sern las seales a muestrear por el analizador (32 ya que hay 4 buffers), 4 salidas acopladas a cada Enable, que como ya se vio se simplific su nmero conectando al mismo cable ciertas seales de habilitacin porque las posibles configuraciones posibles del muestreo son 4, 8, 16 32 entradas. Entonces, estos circuitos consumen 36 pines de la FPGA (32 entradas y 4 salidas). Leds: cada led consume una salida de la FPGA ya que se quiere controlar cada luz con una seal distinta. (4 salidas) Pulsadores: estos componentes son entradas al sistema de la FPGA y cada uno utilizar entonces una entrada (4 entradas). Puerto Serie: este dispositivo solamente utilizar 2 seales (una de entrada para la recepcin serie y otra para la transmisin) aunque el que lo utilizar ser el conversor de nivel MAX232 ya que es ste el que est entre el puerto y la FPGA El resto de dispositivos no consumen entradas o salidas de usuario, sino que son las seales necesarias para manejar la FPGA (reloj y dems seales de la EPC2). Los inversores tampoco se conectan con la FPGA
43

Memoria.Desarrollo

HARDWARE

Placa final

En total necesitaremos 125 pines de usuario de la FPGA que, con el modelo escogido es suficiente ya que dispone de hasta 147 seales de este tipo. En la tabla que viene a continuacin se ha incluido el nombre de cada seal y el nmero del pin de la FPGA al que va conectado (los nombres + son seales de alimentacin positivas mientras que los - son masa).
Pin FPGA 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 Pin Conector 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 Conector Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Con1 Descripcin TCK nCS TDO + + Dir1_0 Dir1_1 Dir1_2 Dir1_3 Dir1_4 Dir1_5 Dir1_6 Dir1_7 Dir1_8 Dir1_9 Dir1_10 Dir1_11 Dir1_12 + + Dir1_13 Dir1_14 Dir1_15 Dir1_16 Dir1_17 WE1 CS1 CS2 + + CS3 CS4 dato1 dato2 dato3 dato4 + + dato5 dato6 dato7 dato8 TMS Pin FPGA Pin Conector 105 1 106 2 107 3 108 4 109 110 5 111 6 112 7 113 8 114 9 115 10 116 11 117 12 118 13 119 14 120 15 121 16 122 17 123 18 124 125 19 126 20 127 21 128 22 129 23 130 24 131 25 132 26 133 27 134 28 135 29 136 30 137 31 138 32 139 33 140 34 141 35 142 36 143 37 144 38 145 39 146 40 147 41 148 42 149 43 150 44 151 45 152 46 153 47 154 48 Conector con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 con3 Descripcin +

+ + dato27 dato28 dato29 dato30 dato31 dato32 + + CS5 CS6 CS7 CS8 -

+ + entrada1 entrada2 entrada3 entrada4 ENABLE1 entrada5 + + entrada6 entrada7 entrada8 ENABLE2 TDI

48 Con1

44

Jaime Trinor Goira

HARDWARE

Placa final

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104

49 50 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

Con1 Con1 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2 con2

OEP (Status) dato9 dato10 dato11 dato12 dato13 dato14 dato15 dato16 OE dato17 dato18 dato19 + dato20 dato21 dato22 dato23 dato24 dato25 dato26 + + CLK Dir2_0 + Dir2_1 Dir2_2 Dir2_3 Dir2_4 Dir2_5 Dir2_6 Dir2_7 Dir2_8 Dir2_9 Dir2_10 Dir2_11 Dir2_12 + Dir2_13 Dir2_14 Dir2_15 Dir2_16 Dir2_17 WE2

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208

49 50 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

con3 con3 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4

DCLK DATA entrada9 entrada10 entrada11 entrada12 ENABLE3 entrada13 entrada14 entrada15 + entrada16 entrada17 entrada18 entrada19 entrada20 entrada21 entrada22 entrada23 entrada24 entrada25 entrada26 + entrada27 entrada28 +

25 con4 26 con4 27 con4 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 con4 entrada29 entrada30 entrada31 entrada32 ENABLE4 Tx_PC Rx_PC + S1 S2 S3 S4 LED1 LED2 LED3 LED4

45

Memoria.Desarrollo

HARDWARE

VHDL

En este apartado se va a realizar el diseo del hardware necesario dentro de la FPGA para conseguir un circuito capaz de recibir por el puerto serie los datos de configuracin introducidos por un usuario a travs del programa Analizador.exe comentando en el epgrafe Software y en funcin de cmo sean esos datos, actuar de forma acorde con lo establecido. Este circuito tendr que muestrear el nmero de entradas declarado por el usuario a la frecuencia deseada por ste e ir almacenando estos datos en las distintas memorias RAM hasta que se llegue al nmero de muestras declaradas. Una vez transcurrido esto, se proceder a enviar todas esas muestras al PC para mostrar en el mismo la evolucin temporal de las seales de entrada. El hardware se ha dividido en varios bloques para que su manejo y programacin sea ms sencilla. Una parte se encargar primeramente de la recepcin de los bytes, otra de la lectura y escritura de las RAM, otra de la transmisin de un byte y por ltimo el control general que se encargar de gestionar todos los bloques. Bloque: Recepcin de Bytes. Segn lo visto en la parte de Software, se tiene un byte de configuracin con 8 bits que indican lo que se desea realizar en funcin de qu flags estn activados, por lo que este circuito se encargar de primero recibir por la lnea serie este byte de configuracin y hacer lo siguiente: si el bit de lectura est activado, indica que no se van a recibir ms bytes y se termina la transmisin por parte del PC. Si en cambio, est activado el bit de escritura, se esperar recibir 2 bytes que indican la frecuencia de muestreo (en realidad el nmero de ciclos del reloj del analizador a contar para tener la frecuencia deseada por el usuario), y 3 bytes que indican cuntas muestras se desea almacenar en cada memoria. Despus de recibir estos datos, si en el byte de configuracin el bit de manual est activado, se proceder a indicar que se termin la transmisin, si por el contrario est a 1 el bit de flanco de subida o el de flanco de bajada, se tendr que recibir el byte que indica qu entrada activar el muestreo. El ltimo caso posible es el de tener activado el bit de patrn por lo que se proceder a recibir los 4 bytes de patrn que indican el valor exacto de las entradas que hace disparar el muestreo, independientemente del nmero de entradas que se quieran muestrear.

46

Jaime Trinor Goira

HARDWARE

VHDL

Para poder realizar todo lo descrito, se van a necesitar varios circuitos: un contador de un bit para la recepcin por el puerto serie, un control de recepcin de un byte por la va serie, sendos registros donde almacenar los datos de los bytes recibidos , un registro de desplazamiento serie paralelo y un control que gestione todos estos bloques. o Contador de uno y medio bit: como la comunicacin serie se realiza a una frecuencia distinta que la del reloj del analizador, se necesita saber cuntos ciclos de ste reloj equivalen a la frecuencia de transmisin serie. Como dicha transmisin se realiza a 115200 baudios por segundo y el reloj de la FPGA es de 14.7456 MHz (el de la placa de prueba), equivale a 128 ciclos (en el Analizador JTG_05 equivale a 1389 ciclos del reloj de 160 MHz). Este contador informa tambin de cundo se ha alcanzado la mitad de la cuenta para indicar que se tiene medio bit de la lnea serie. Cada vez que se produce un flanco de reloj, si la seal Activa est a 1, se produce el incremento en uno del valor de la cuenta. Su cdigo en VHDL es el que sigue:
o

Registro de desplazamiento serie paralelo: se utiliza para ir almacenando los bits que se van recibiendo por el puerto serie. Cuando se activa la seal Desplaza , desplaza los bits del 7 al 1 una posicin a la derecha y el ltimo bit lo iguala al valor de la va serie y as al realizar 8 desplazamientos se tiene el byte completo recibido por la va serie.

La comunicacin por la va serie se realiza de la siguiente forma: la lnea se mantiene en alto nivel cuando no se transmite. Cuando comienza el envo de un byte, se procede a poner un bit de START (un bit en bajo nivel) seguido de los 8 bits de datos y por ltimo un bit de STOP que indica el fin del envo del byte correspondiente. o Control de recepcin serie de un byte: segn lo comentado en el prrafo anterior, se va a utilizar el contador de uno y medio bit para contar medio bit cuando la lnea serie cambie de nivel y adems est activa la seal habilita, es decir, cuando se reciba el bit de START y el Control de recepcin habilite este bloque, se contar medio bit y se comprobar que sigue siendo el bit de START (sigue con valor 0), entonces se resetear el contador para contar un bit entero, coincidiendo con la mitad del primer bit de datos, entonces se almacenar dicho valor en el registro de desplazamiento y as sucesivamente 7 veces ms hasta almacenar los 8 bits de datos en su orden correspondiente. Una vez concluido

47

Memoria.Desarrollo

HARDWARE

VHDL

esto, se esperar otro bit ms y si est la lnea a 1 es que es el bit de STOP, con lo que terminamos el proceso. Todo este control se realizar mediante una mquina de estados con el Diagrama de estados 1 :

Diagrama de estados 1: Recepcin de un byte

Se ha realizado una simulacin que se puede apreciar a continuacin en la que se han mostrado las seales relevantes del bloque de recepcin de un byte y se comprueba como realiza correctamente todo lo descrito: cuando la va serie cambia de estado (de 1 a 0) se cuenta medio bit, se comprueba que vale 0 y se cuentan otros 8 bits activando la seal desplaza en cada intervalo de 1 bit para almacenar en el registro el valor del bit de datos correspondiente que se est recibiendo. Una vez almacenados los 8 bits de datos se espera recibir el bit de stop y transcurrido este tiempo se indica que la transmisin se ha finalizado. Entre corchetes se indica con una I si es una entrada (Input) , con una O si es una salida (Output) o una B si es una variable interna de un subconjunto del bloque.

48

Jaime Trinor Goira

HARDWARE

VHDL

Simulacion 1: Recepcin de 1 Byte

Ampliacin de la escala de tiempos de la simulacin 1

o Registro de Configuracin: Es un registro de 8 bits que cuando la seal Carga

se activa, se procede a igualar la salida del registro con su entrada, correspondiente al byte recibido por el puerto serie.

o Registro de Frecuencia: Es un registro de 16 bits que cuando la seal Carga est

a 1, se iguala la parte alta del registro (ltimos 8 bits) al byte recibido por la lnea serie y cuando la seal Desplaza es activada, se desplazan 8 bits a la derecha.

49

Memoria.Desarrollo

HARDWARE

VHDL

o Registro de Flanco: Registro de 5 bits que cuando su seal de habilitacin

Carga es activada se igualan sus 5 bits a los 5 bits ms bajos del byte recibido.
o Registro de Patrn: Registro de 32 bits que al igual que el resto de los registros,

cuando la seal Carga se pone a 1, se produce la igualacin del ltimo byte del registro al byte que se recibi por la va serie y cuando su seal Desplaza est activada, se desplazan 8 bits a la derecha.
o Registro de Muestras: Consiste en un registro de 18 bits por el cual si la seal

Carga1 se pone a 1 se iguala la parte baja del registro (bits 7 a 0) al byte recibido, en cambio, si la seal Carga2 vale 1, se iguala los bits 15 al 8 al byte recibido por el puerto serie y por ltimo si la seal Carga3 se pone a 1, lo que se hace es igualar los bits 17 y 16 a los bits 1 y 0 del byte recibido, respectivamente.
o Control de recepcin : Este circuito ser otra mquina de estados encargada de

gestionar todos los bloques descritos anteriormente y segn lo mencionado en la introduccin del bloque Recepcin de Bytes, es decir, cuando la lnea serie cambie de alto a bajo nivel, recibir el byte de configuracin, habilitando el control de recepcin de un byte. Una vez se halla concluido con la recepcin del byte de configuracin, en funcin del valor de ste, se recibirn los bytes necesarios para el modo de funcionamiento que se requiera e ir cargando en los registros correspondientes el valor del byte. La secuencia es la siguiente: si el bit de escritura est activado, se mirar qu modo de disparo est puesto (manual, flanco de subida, flanco de bajada, patrn) y despus de recibir los 2 bytes de frecuencia almacenar los 3 bytes de nmero de muestras y por ltimo el byte de flanco o los 4 bytes de patrn o ninguno ms segn proceda.El diagrama de estados a configurar es el que se puede ver a continuacin:

50

Jaime Trinor Goira

HARDWARE

VHDL

Diagrama de estados 2 : Control de recepcin

51

Memoria.Desarrollo

HARDWARE

VHDL

Finalmente el bloque de recepcin queda con las entradas, salidas y circuitos que se pueden ver en la Figura 1:

Figura 1:Circuito de recepcin de bytes

52

Jaime Trinor Goira

HARDWARE

VHDL

Se ha realizado tambin una simulacin de este bloque y se van a mostrar varias grficas donde se comprueba que el bloque funciona correctamente para las diferentes configuraciones: la Simulacion 2 se ha realizado para una configuracin de disparo manual y 4 entradas (Byte de configuracin= 10001000), 15 ciclos de frecuencia de muestreo (Byte de frecuencia 1= 11110000 y byte de frecuencia 2 =00000000) y 20 muestras en cada memoria (Byte de muestras 1= 00101000 y los otros 2 bytes de muestras con todos sus bits a 0). En la Simulacion 2 se puede comprobar como en el estado S1 se recibe el byte de configuracin, en S4 el byte de frecuencia 1, en S7 el de frecuencia , en SM1 el de muestras1, en SM2 el de muestras2 y en SM3 el ltimo de las muestras. Estos 5 ltimos bytes son comunes para las simulaciones 2, 3 y 4. En la Simulacion 3 se observa el desarrollo para un disparo por flanco de subida con muestreo de 8 entradas (Byte de configuracin =10010100) y que active el disparo la seal nmero 6 (Byte de nivel = 01100000). En la ltima simulacin de este apartado (Simulacion 4) se ha preparado un disparo por patrn en el cual las seales de entrada deben valer 0F40E3 en hexadecimal para 4 seales de entrada (Byte de configuracin= 10000001).

Simulacion 2: Recepcin para disparo manual

53

Memoria.Desarrollo

HARDWARE

VHDL

Simulacion 3: Recepcin para disparo por flanco de subida

Simulacion 4: Recepcin para disparo por patrn

54

Jaime Trinor Goira

HARDWARE

VHDL

Bloque: Control de Escritura Lectura. Se trata de un circuito que se debe comunicar con las memorias RAM para poder almacenar los datos de las seales de entrada en dichas memorias y tambin ser capaz de leer los datos all recogidos. Este bloque se compone a su vez de varios circuitos: o Contador de posiciones: Como las memorias son de 256 kB de capacidad hay 18 bits que componen el bus de direcciones. Este contador realiza el incremento de una posicin de memoria cada vez que se produce un flanco de reloj y la seal Incrementa se iguala a 1. Por otro lado si la seal Reset es activada se pone el valor 0 como posicin de memoria. Adems indica con su salida memoria_llena=1 cuando el valor de la cuenta es igual al valor del nmero de muestras indicado por el usuario y almacenado su valor en el Registro de Muestras. o Muestreo: Recibe los 2 bytes de frecuencia o lo que es lo mismo, el nmero de ciclos que debe contar del reloj de la FPGA para muestrear a la velocidad deseada por el usuario. Si la seal Reset se pone a 1, el registro de cuenta se iguala a 1 y si hay un flanco de reloj, no se ha terminado la cuenta y la seal Activa est a 1, se incrementa la cuenta una vez. Por otro lado, si la cuenta es igual al nmero de ciclos recibido, se indica con la seal Terminado que se ha concluido el muestreo de ese dato. o Registro RAM: Es un registro bidireccional que se comunica con las RAM de tal forma que si se habilita la seal Escribe, el bus bidireccional de 32 bits se iguala a las 32 entradas recibidas del multiplexor de entrada, de lo contrario se deja en alta impedancia Z. Por otro lado, si se activa Lee al producirse un flanco de reloj, se iguala la salida a lo que se recibe por el bus bidireccional. Las memorias RAM compradas, poseen un registro igual a este que cuando se quiere escribir (seal CS=0, WE=0 y OE=0) iguala su registro a lo que recibe por el bus bidireccional, de lo contrario, sino lo deja en alta impedancia y se desea leer (CS=0, WE=1 y OE=0), iguala el bus a lo que tiene en la posicin de memoria dada.

55

Memoria.Desarrollo

HARDWARE

VHDL

La forma de leer y escribir en las memorias es como sigue: si lo que se desea es leer un dato de la RAM, ha de ponerse la direccin que se precisa leer y poner el chip select (CS) de la correspondiente memoria a 0, el Write Enable (WE) a 1 y el Output Enable (OE) a 0, manteniendo esta configuracin y transcurridos 12 ns, se ponen los datos internos de esa posicin de memoria (4 datos) en el bus bidireccional para ser ledos por la FPGA. Este proceso se aprecia en la siguiente figura (siendo DATAout el bus bidireccional):

Figura 2: Forma de Leer de la RAM

La forma de llevar a cabo la escritura de la RAM es algo similar: si cuando se pone una direccin de memoria, durante un tiempo mnimo de 12 ns, en la cual se almacenar el dato y se ponen las seales WE y CS a 0 durante mnimo 10ns, si en ese instante se encuentran los datos a ser almacenados en el bus bidireccional y se produce un cambio en CS pasando a valer 1, la RAM almacena los datos recibidos en esa posicin de memoria. Todo esto se observa en la figura que viene a continuacin:

Figura 3: Forma de escribir en la RAM

56

Jaime Trinor Goira

HARDWARE

VHDL

Con estos datos recogidos se puede proceder a realizar el control que gestione dicha lectura escritura.

o Control Lectura Escritura: Consiste en una mquina de estados de tipo Moore que tratar de escribir o leer un dato de la RAM segn se habiliten las seales Habilita lectura o Habilita escritura desde el exterior. Si se ha seleccionado escritura, se har a la velocidad de muestreo escogida, incrementando una posicin cada vez, hasta que se llene la memoria y si en cambio se opt por la lectura se har de dato en dato, esperando a que el bloque de transmisin lo halla enviado por completo y tambin hasta haber ledo todos los datos almacenados. El diagrama de estados diseado es el que viene al final de la pgina, siendo los estados con nombre Ex correspondientes al modo de escritura y los que tienen nombre Lx al modo de lectura. Cuando se recibe del contador de direcciones la seal de memoria_llena=1 implica que se han alcanzado todas las muestras deseadas por el usuario en esa memoria o grupo de memorias, y si se est en el modo de escritura se proceder a parar el proceso e indicarle al control general que ya no hay ms muestras que almacenar en ese grupo de memorias y si estamos en el modo de lectura, implicar que ya no quedan muestras por leer ni enviar de ese grupo de RAMs y tambin se le indicar al control general mediante la seal Dispositivo_lleno que se ha terminado el proceso de lectura/escritura de ese chip.

Diagrama de estados 3 : Control de lectura escritura

57

Memoria.Desarrollo

HARDWARE

VHDL

El bloque descrito, con sus entradas y salidas, queda como se puede observar en la Figura 4 :

Figura 4: Circuito para la escritura y lectura de la RAM

Se han realizado diversas simulaciones para detallar el proceso que se ha descrito. La primera simulacin (Simulacion 5) corresponde con la escritura de una RAM con un muestreo de 10 ciclos de reloj y un total de 15 muestras a almacenar. En la figura que va debajo de la Simulacion 5 se puede observar claramente como en E2 se cuentan 10 ciclos del reloj principal. Tambin se aprecia cmo las seales de OE y WE responden a como se deben comportar segn lo especificado en la Figura 3: Forma de escribir en la RAM. Por otro lado se observa como al llegar a la direccin nmero 15 de la memoria se pasa al estado S0 que corresponde al estado de espera de las rdenes. Por otro lado, en la Simulacion 6 se ha realizado para la lectura de la RAM con 10 muestras y una frecuencia de 10 ciclos de reloj (frecuencia que en este modo no influye ya que en un ciclo de reloj se lee un dato y en el siguiente se espera a que ese dato sea enviado por la lnea serie) y se ve como cada vez que la seal procedente del bloque de transmisin Transmisin_terminada vale 1, se va al estado L2 donde se lee el siguiente dato

58

Jaime Trinor Goira

HARDWARE

VHDL

Simulacion 5: Escritura de la RAM

Ampliacin de la escala de tiempos para la Simulacion 5

59

Memoria.Desarrollo

HARDWARE

VHDL

Simulacion 6: Lectura de la RAM

Ampliacin de la escala de tiempos de la Simulacion 6

60

Jaime Trinor Goira

HARDWARE

VHDL

Bloque: Transmisin de un Byte. Consiste en un circuito que recibe un byte desde el multiplexor de salida y lo enva por la lnea serie bit a bit. Tal como se dijo en el bloque Recepcin bytes se necesita un divisor de frecuencia para tener la velocidad del puerto serie. Tambin se utilizar un registro paralelo serie para ir desplazando los bits del byte a enviar y as enviar cada vez el bit correspondiente. Todo se gestionar a travs de un control de transmisin. o Contador de un bit: Cuenta el nmero de ciclos de reloj de la FPGA necesarios para obtener un tiempo equivalente a un bit a la velocidad del puerto serie (115200 baudios). o Registro paralelo serie: Cada vez que la seal Carga se activa, se carga el byte a enviar procedente del multiplexor de salida. Si Desplaza se pone a 1, se procede con el desplazamiento de un bit a la derecha del registro cargado con anterioridad (Los 7 ltimos bits pasan a tener una posicin menos que la que tenan), y el bit 0 es el que ser enviado por la va serie. o Control de Transmisin: Si se habilita dicho control desde el exterior, se cargarn los datos a enviar en el registro y se proceder al envo de un bit de START, que se corresponde con el estado a nivel bajo del puerto de transmisin, hasta que se cumpla el tiempo de un bit a la velocidad de 115200 baudios por segundo, seguidamente se enviar el primer dato del registro (bit 0), y transcurridos otro bit de la lnea serie, se desplazar el registro y se enviar el nuevo dato. As sucesivamente hasta haber enviado los 8 datos del byte, momento en el que se enviar el bit de STOP (puerto de transmisin serie a 1)y se dejar en alto nivel hasta que se quiera enviar otro byte. Al ser otra mquina de estados, su diagrama se refleja a continuacin:

61

Memoria.Desarrollo

HARDWARE

VHDL

Diagrama de estados 4: Control de transmisin

El circuito correspondiente al bloque de transmisin se puede ver en la Figura 5. Las entradas procedentes del resto de bloques y del control general son el reloj de la FPGA, la seal de reset general, la seal de habilitacin del envo de un byte (habilita_envio) y el propio byte a enviar (byte[7..0]) y las salidas son el puerto serie de transmisin (lin_s_TX) y la seal que indica que se ha terminado de transmitir (transmisin_terminada).

Figura 5: Circuito para el envo de un byte

62

Jaime Trinor Goira

HARDWARE

VHDL

Simulacion 7: Transmisin de un byte

Ampliacin de la escala de tiemposde la Simulacion 7

63

Memoria.Desarrollo

HARDWARE

VHDL

En la Simulacion 7 se aprecia como cuando la seal de habilita_envio vale 1, se comienza a enviar la entrada Byte[7..0] empezando desde el bit 0 hasta el bit 7 despus de haber enviado el bit de START. Este bit de comienzo se transmite en el estado T2, mientras que los bits de datos de la entrada Byte se envan en el estado T3 . En este caso el byte a enviar es 01110011 y se ve claramente el la simulacin cmo vara la lnea de transmisin serie con estos valores. En la ampliacin de la escala de tiempos de la misma simulacin se puede observar como tras contar 128 ciclos de reloj (de 0 a 127) la seal uno cambia a 1 indicando que se han contado los ciclos necesarios para transmitir a 115200 baudios por segundo con el reloj de la FPGA del Analizador de Prueba de la tarjeta Prince. En T4 se comprueba si se ha transmitido el ltimo bit del byte de entrada y si no es as se pasa al estado T5, donde se incrementa el contador de bits de datos enviados y se desplaza un bit a la derecha el registro paralelo/serie para enviar el siguiente dato. Finalmente en T6 se transmite el bit de STOP para que el ordenador reconozca que se ha finalizado la transmisin, y entonces la seal Transmisin_terminada cambia a 1 para indicarle al control general que puede enviar otro byte si lo desea y adems indicarle al control de lectura que ya puede leer otro dato de la RAM. Bloque: Multiplexor de Entrada. Este circuito recibe las 32 seales de entrada y los 2 bits del byte de configuracin que se relacionan con el nmero de entradas a muestrear (bits 2 y 3). Como cada 4 bits del registro bidireccional estn conectados a los bits de datos de las RAM (los bits 0 al 3 estn conectados a la RAM A1, del 4 al 7 a la RAM A2, del 16 al 19 a la RAM B1, etc), se necesita un multiplexor previo a este registro para entregar los datos correctos a las RAM en funcin de la configuracin realizada, siendo los casos posibles los siguientes: Si se quieren analizar solamente 4 entradas, a cada RAM se le enviarn esos mismos 4 bits por lo que el multiplexor copiar los 4 primeros bits de su entrada en grupos de 4 bits en su salida de tal forma que los bits del 0 al 3,del 4 al 7 y as en grupos de 4 hasta del 28 al 31 sern exactamente iguales. Si en cambio se desea muestrear 8 entradas, se enviarn los datos de las 8 seales a grupos de 2 RAM (el multiplexor copiar sus 8 primeras entradas a los bits de su salida 0 al 7, 8 al 15, 16 al 23 y 24 al 31).

64

Jaime Trinor Goira

HARDWARE

VHDL

Si se desea almacenar datos de 16 entradas, el multiplexor duplicar ese valor en los bits de salida del 0 al 15 y del 16 al 31. En el caso de querer 32 entradas, la salida ser igualada a la entrada en todos sus bits. Bloque: Multiplexor de Salida. El problema es parecido al que se explica en el multiplexor de entrada: como el Registro RAM est conectado directamente a cada una de las RAM, hay que seleccionar qu se va a enviar dependiendo del nmero de entradas que se muestrean y de la RAM que se est leyendo: Si se muestrean 4 entradas hay que enviar un byte por cada 4 bits de la memoria que corresponda. Siempre se pone en la parte baja del byte a enviar los 4 datos de la memoria RAM que corresponda y el resto de bits se igualan a 0. Cuando se lee la RAM A1, se cogen los datos 0 al 3 del Registro RAM, cuando se lee la RAM A2, los bits 4 al 7, y as sucesivamente hasta que se hallan ledo los datos de la RAM B4 (bits 28 al 31 de la salida del registro bidireccional). Cuando se tienen 8 entradas, se dispone a enviar un byte por cada 8 datos. Se empieza a leer las memorias RAM A1 y RAM A2 (bits 0 al 7 de la salida del registro triestado), despus las RAM A3 y RAM A4 (bits 8 al 15 del Registro RAM), y lo mismo con el banco de memorias B, que cuando se leen sus 2 primeras memorias, se envan los datos del Registro RAM correspondientes con los bits 16 al 23, y por ltimo, al leer las RAM B3 y RAM B4, se enviarn los bits 24 al 31 del registro de la RAM. Muestreando 16 entradas se tendr que hacer algo distinto ya que el protocolo de la va serie exige enviar byte a byte los datos, sin embargo aqu se tienen 16 datos (2 bytes) por lo que se mandar primero la parte baja del banco A de memorias cuando se estn recogiendo datos de las mismas (bits 0 al 7) y una vez se halla enviado dicho byte se enviar la parte alta (bits 8 al 15). Lo mismo se har a la hora de seleccionar la lectura del banco B de memorias: primero bits 16 al 23 y ms tarde cuando est libre la lnea serie el resto (bits 24 al 31).

65

Memoria.Desarrollo

HARDWARE

VHDL

Por ltimo tenemos la posibilidad de muestrear 32 entradas a la vez, por lo que se tendrn que enviar 4 bytes al PC de la misma forma que en el apartado anterior: el primer byte son los primeros 8 bits de la salida del registro, el segundo los 8 siguientes y as hasta haber mandado los 32 bits de datos. Para saber qu memoria se est leyendo, el control general posee dos seales que definen qu RAM est en uso : contador 1 y 2. La primera define qu RAM o grupo de RAM se est/n usando (depende del nmero de entradas que se muestrea) y la segunda qu byte se est enviando (para el caso de muestrear 16 32 entradas). De esta forma el multiplexor poseer un contador interno y sabr en todo momento qu dato hay que enviar puesto que recibe las seales que incrementan los contadores 1 y 2 (inc_cont1 e inc_cont2) y cada vez que una de ellas es activada, el multiplexor incrementa su contador para que el control de transmisin enve los datos correctos. Bloque: Desplazador Chip Selectes. Este bloque sirve para actualizar el valor de la seal CS de la RAM o RAMs que se est/n leyendo en el momento preciso. El bloque de lectura escritura se comunica con las 8 RAM a la vez mediante su Registro RAM sin embargo solamente posee 1 seal de chip select cuando en realidad existen 8 (una por cada memoria). El caso es que segn la configuracin del analizador (nmero de entradas) se van a tener que utilizar una o varias memorias a la vez y solamente un control de lectura escritura para todas. Como se ha visto con anterioridad, si el nmero de entradas a muestrear es de 4, se escribir/leer primero en la RAM A1 hasta que se llegue al nmero total de muestras deseadas y definidas e el Registro de Muestras y despus se pasa a la RAM A2, y as sucesivamentePara no perder los datos almacenados en una RAM mientras se escribe en otra, se utiliza este registro de desplazamiento, que copia el valor de CS procedente del control de lectura escritura en el chip select de la memoria que corresponda de la siguiente forma: Para 4 entradas: primero se copia el CS en la RAM A1 y cuando se llena esta, se pasa a RAM A2, y as hasta llegar a RAM B4. Para 8 entradas se copia inicialmente el CS en RAM A1 y RAM A2 a la vez hasta que se llenen, despus se copia el valor en RAM A3 y RAM A4, y cuando se llenen estas 2 memorias, se pasa al banco de RAMs B.

66

Jaime Trinor Goira

HARDWARE

VHDL

Para 16 entradas se almacena el valor del CS en todos los chip selects del banco de memorias A y una vez se halla llenado ste, se procede con la copia en los chip selects del banco B. Por ltimo si se prefiere muestrear 32 entradas, implica la escritura o lectura, segn proceda, de las 8 memorias a la vez, por lo que se igualar el valor del CS del control a todos los chip selects de las RAM. Este bloque recibe una seal procedente del Control General que cada vez que sta es activada, el Desplazador mira en el byte de configuracin el nmero de entradas que se estn muestreando y cambia el Chip Select a la/s memoria/s correspondiente/s.

Simulacion 8: Desplazador de Chip Selects, 4 entradas

Ampliacin de la escala de tiempos de la Simulacion 8

Como se ha detallado en la pgina anterior, en la Simulacion 8 puede verse como para una configuracin de 4 entradas, primero se copia el valor del Chip Select procedente del bloque de Lectura Escritura en la primera posicin de la salida Chip_selects[7..0] que equivale a copiar dicha seal en el Chip Select conectado a la primera memoria, la RAM A1, y cada vez que se produce un flanco positivo de reloj y la seal de entrada desplaza vale 1, el valor del Chip Select (CS) de la lectura/escritura se copia en la siguiente memoria. Para esta configuracin de 4 entradas se tendr un total de 7 desplazamientos para cubrir las 8 memorias del Analizador JTG_05.

67

Memoria.Desarrollo

HARDWARE

VHDL

Simulacion 9: Desplazador de Chip Selects, 8 entradas

En la Simulacion 9 se tiene el mismo proceso pero para una configuracin de 8 entradas y se aprecia como se desplaza la copia del CS en grupos de dos memorias y cada vez que Desplaza_CS vale 1, se pasa a las dos memorias siguientes. Para cubrir los Chip Selects de todas las memorias se tendr que realizar 3 desplazamientos en total.

En la siguiente simulacin (Simulacion 10) el proceso es parecido y se copia el valor de CS en grupos de 4 memorias, con lo que para cubrir las 8 RAM, bastar con desplazar los Chip Selects una sola vez.

Simulacion 10: Desplazador de Chip Selects, 16 entradas

Por ltimo, se ha hecho la Simulacion 11 que corresponde con una configuracin de 32 entradas y no se necesita desplazar ninguna seal, simplemente basta con copiar el contenido de CS en todos los bits de la seal Chip_selects[7..0].

Simulacion 11: Desplazador de Chip Selects, 32 entradas

68

Jaime Trinor Goira

HARDWARE

VHDL

Bloque: Multiplexor de prueba. Este multiplexor se ha hecho debido a que en este proyecto no se ha diseado un programa para duplicar la velocidad del analizador, es decir, para poder ir al doble de velocidad del ciclo de lectura escritura de la RAM (6 ns 166 MHz). La parte del hardware de la placa si lo permite ya que se ha diseado un circuito con dos bancos de memoria (2 buses de direcciones y 2 WE) que permitiran conectar un reloj de 166 MHz de tal forma que en un ciclo se estuviera escribiendo en un banco y en el siguiente ciclo se seguira guardando en ese mismo banco y a la vez en el otro, sin embargo esta opcin est pensada para futuros desarrollos por lo que este circuito se limita a copiar la direccin procedente del control de lectura escritura en los 2 bancos de memoria a la vez , al igual que el valor de WE en los write enable de cada banco (WE_A y WE_B). Para duplicar la velocidad se necesitara un control de lectura escritura independiente por cada banco de memorias (se detallar ms adelante).

Bloque: Control General. Este circuito es una mquina de estados que se dedica a controlar todos los bloques que se han explicado hasta ahora y hace lo que se describe en el Diagrama de estados 5: Control General: Si la lnea serie cambia a nivel bajo es que el ordenador est enviando los datos de configuracin del analizador, por lo que se habilitar el bloque Recepcin de bytes para recibir los bytes necesarios en funcin del modo de escritura o de lectura que halla aplicado el usuario. Cuando el bloque de recepcin halla concluido su tarea, se lo indicar al Control General activando la seal Recepcion_Terminada a 1 y ser cuando se vaya al estado E1, si se cumple que el modo elegido es el de escritura. En este estado se comprueba si se cumplen la condiciones de disparo, es decir, en modo manual se pasa directamente a muestrear las seales de entrada (estado E2), en modo flanco de subida se espera que en la seal de disparo escogida se produzca un flanco de subida (si la seal de disparo est a 0 , cuando cambie a 1 comenzar el muestreo; sin embargo, si est a 1 habr que esperar a que cambie a 0 (Fs1) y all de nuevo esperar que cambie otra vez a 1, correspondiente con el estado Fs2), lo mismo para flanco de bajada que se esperar un cambio de 1 a 0 (Estado Fb2) en la seal deseada o si est a 0 habr que esperar que cambie de 0 a 1 (Fb1) y si se produce dicho cambio se pasar a Fb2 hasta que se cumpla el flanco de bajada deseado. Para el modo patrn, segn el nmero de entradas a muestrear, se comparar el Registro de Patrn con las entradas, es decir, si el nmero de entradas

69

Memoria.Desarrollo

HARDWARE

VHDL

elegido es de 4, se compararn dichas entradas solamente con los bits 0 al 3 del registro que contiene la informacin del patrn, de otra forma, si son 8 entradas a muestrear, se comparar con los bits 0 al 7 del mencionado registro, con 16 entradas se aplicarn los bits 0 al 15 y para concluir, si son 32 entradas, se comparar con todo el registro. Una vez comprobadas las condiciones de disparo si estas se cumplen, se procede con la escritura (estado E2) de la primera memoria RAM A1 (para 4 entradas) o de las 2 primeras memorias (para 8 entradas), o del banco de memorias A (16 entradas), o bien todas las memorias a la vez (32 entradas) hasta que se llegue al nmero de muestras del registro que contiene dicha informacin, entonces en E3 se comprueba qu memoria/s se ha/n escrito mediante un contador y las seales num_entradas[1..0] de la siguiente forma: para 4 entradas (num_entradas=00), si el contador vale 7 (empieza en 0) es que se han escrito todas las muestras en todas las memorias; para 8 entradas (num_entradas=01), si el contador vale 3 (se han escrito 4 grupos de 2 memorias cada uno); para 16 entradas (num_entradas=10), si el contador vale 1 (se han escrito 2 grupos de 4 memorias cada uno); para 32 entradas (num_entradas=11) directamente cuando se llega al la ltima posicin de memoria (mem_llena=1). De esta forma si no se cumple lo descrito (no se ha terminado de almacenar todas las muestras en todas las RAM), se pasa al estado E3 donde se desplaza el chip select (segn lo mencionado en dicho bloque) ,para dar paso a la escritura de la/s siguiente/s RAM, y se incrementa el contador. Si en cambio se cumple que se han almacenado todas las muestras en todas las memorias, se pasa al estado E5 donde se resetea el desplazador de chip selects y el contador (para que la parte de lectura comience desde la/s primera/s memoria/s). Seguidamente se procede con la lectura de los dispositivos en L1 donde se espera a que se halla ledo un dato para ser transmitido en L2. Aqu es donde acta el Multiplexor de Salida, de tal forma que si son 16 32 entradas las seleccionadas, se enviarn 2 4 bytes respectivamente (la seal Contador2 lo indicar). Cuando se llene la o las RAM (dependiendo del nmero de entradas), se comprobar en L4 si quedan memorias por leer y si es as se desplazar el o los chip selects correspondientes y se incrementar el contador que indica cuantas memorias se han ledo. Cuando se halla terminado de leer todos los dispositivos, se terminar todo el proceso y se esperarn nuevas rdenes procedentes del PC.

70

Jaime Trinor Goira

HARDWARE

VHDL

Diagrama de estados 5: Control General

Todos los bloques del Analizador de Prueba se pueden ver en la Figura 6. Este bloque recibe como entradas el Reloj de la FPGA, el Reset general, la Linea_serie_RX (Puerto serie de recepcin) y las 32 seales de entrada (Signals[31..0]), mientras que sus salidas son los 32 bits que comunican las RAM con el registro triestado del control de lectura/escritura (Datos_memorias[31..0]), la seales Leyendo y Escribiendo que van conectadas a unos leds, Dir_A[17..0] y Dir_B[17..] que son los buses de direcciones de los bancos A y B de memorias, respectivamente, los Write Enable de cada banco de memorias, la lnea serie de transmisin (Linea_serie_TX), los Chip_selects[7..0] conectados cada bit a una memoria, y las seales de habilitacin de los Buffer de proteccin (Enables_Buffers[3..0]).
71

Memoria.Desarrollo

HARDWARE

VHDL

Figura 6: Analizador de Prueba

72

Jaime Trinor Goira

HARDWARE

VHDL

Finalmente con todos los bloques descritos, se tiene el bloque final que contiene a todos los anteriores (Figura 7), comprendiendo exclusivamente las seales conectadas a la FPGA, a los Buffers y a las RAM.

Figura 7: Analizador placa de prueba (Smbolo y pines de conexin a la tarjeta Prince )

73

Memoria.Desarrollo

HARDWARE

VHDL

En la ltima simulacin realizada (Simulacion 12: Control general y resto de bloques) se ha hecho para 20 muestras en cada RAM y 15 ciclos como frecuencia de muestreo con una configuracin de 4 entradas y modo manual. Como en la Simulacion 12: Control general y resto de bloques no se observa muy bien, se ha optado por ampliar la escala de tiempos y mostrar en cada figura solamente las seales relevantes a cada intervalo de tiempo, de tal forma que en la primera ampliacin se observe claramente la recepcin de los bytes, en la segunda la escritura y en la ltima la lectura y transmisin de los datos almacenados.

Simulacion 12: Control general y resto de bloques

74

Jaime Trinor Goira

HARDWARE

VHDL

Ampliacin de la escala de tiempos: Recepcin de bytes

Ampliacin de la escala de tiempos: Escritura RAMs

En la figura anterior, se ve claramente como despus de almacenar 20 muestras en la primera memoria RAM se pasa a guardar otras 20 muestras en la memoria RAM A2. cada ciclo de escritura de cada RAM corresponde al estado E2 del control general.

75

Memoria.Desarrollo

HARDWARE

VHDL

Ampliacin de la escala de tiempos: Lectura RAMs

En esta ltima ampliacin de la escala de tiempos de la Simulacion 12: Control general y resto de bloques se ha querido remarcar que cuando se enva por la va serie la muestra 20 de la RAM A1 se pasa a enviar la muestra 1 de la RAM A2 y as sucesivamente hasta haber ledo y transmitido todas las muestras de todas las RAM

76

Jaime Trinor Goira

HARDWARE

VHDL

Cdigo VHDL de los distintos circuitos:

Bloque de recepcin: o Contador de medio y de un bit: Entradas: clk (reloj), activa (cuenta cuando est a 1), reset (pone contador a 0) Salidas: entero (indica que ha contado un bit serie), medio(ha contado medio bit) Seales internas: cuenta (el valor de la cuenta de 0 a 127)
ENTITY cont_uno IS PORT( clk,activa,reset : IN BIT; entero,medio :OUT BIT); END cont_uno; ARCHITECTURE comp OF cont_uno IS SIGNAL cuenta : INTEGER RANGE 0 TO 127; BEGIN PROCESS(clk,reset) BEGIN IF reset='1' THEN cuenta<=0; ELSIF clk'event AND clk='1' THEN IF activa='1' THEN IF cuenta=56 THEN medio<='1'; ELSE medio<='0'; END IF; IF cuenta=127 THEN entero<='1'; cuenta<=0; ELSE cuenta<=cuenta+1; entero<='0'; END IF; END IF; END IF; END PROCESS; END comp;

77

Memoria.Desarrollo

HARDWARE

VHDL

o Registro de desplazamiento serie paralelo: Entradas: clk(reloj), desplaza(desplaza un bit a la derecha los bits de aux_dat), dato_serie (lnea serie de recepcin) Salidas: salida[7..0] (byte recibido) Seales internas: aux_dat[7..0](registro donde se almacenan los datos que van llegando y a la vez se desplazan)
ENTITY Reg_desp IS PORT( desplaza,dato_serie,clk : IN BIT; salida: OUT BIT_VECTOR (7 DOWNTO 0)); END Reg_desp; ARCHITECTURE comp OF Reg_desp IS SIGNAL aux_dat: BIT_VECTOR(7 DOWNTO 0); BEGIN PROCESS(clk) BEGIN IF clk'event AND clk='1' THEN IF desplaza='1' THEN aux_dat(6 DOWNTO 0)<=aux_dat(7 DOWNTO 1); aux_dat(7)<=dato_serie; END IF; END IF; END PROCESS; salida<=aux_dat; END comp;

o Control de recepcin de un byte: Entradas: medio y uno (procedentes del contador), clk (reloj), reset (general, lleva al primer estado si se pulsa el reset), linea_s (lnea serie de recepcin), habilita (procede del control general, empieza el proceso cuando vale 1) Salidas: reset_cont (resetea el contador de un bit), desplaza (desplaza un bit el registro de desplazamiento), activa (hace que el contador incremente la cuenta), listo (para indicar que se ha recibido un byte entero) Seales internas: m_moore (mquina de estados de tipo Moore), estado (seal que indica el estado actual del proceso), inc_cuenta (cuando recibe un bit de la lnea serie, incrementa su contador interno para saber qu bit se ha recibido),reset_cuenta (cuando se recibe el primer bit por la va serie, se pone el contador interno a 0), cuenta(contador del nmero de bits recibidos)

78

Jaime Trinor Goira

HARDWARE

VHDL

ENTITY recep_serie IS PORT( medio,uno,clk,reset,linea_s,habilita : IN BIT; reset_cont,desplaza,activa,listo: OUT BIT); END recep_serie; ARCHITECTURE comp OF recep_serie IS TYPE m_moore IS(S00,S0,S1,S2,S3,S4,S34,S5,S7); signal estado : m_moore; signal inc_cuenta,reset_cuenta : BIT; signal cuenta: integer range 0 TO 8; BEGIN PROCESS(clk,reset) BEGIN IF reset='0' THEN estado<=S00; ELSIF clk'event AND clk='1' THEN CASE estado IS WHEN S00=> IF habilita='1' THEN estado<=S0; END IF; WHEN S0 => IF linea_s='0' THEN estado<=S1; END IF; WHEN S1 => IF medio='1' AND linea_s='0' THEN --Se cuenta medio bit y se comprueba que sigue siendo bit de START estado<=S2; END IF; WHEN S2=> estado<=S3; --Reseteamos el contador de medio/un bit WHEN S3 => IF uno='1' THEN estado<=S34; END IF; WHEN S34=>estado<=S4; --Se cargan los datos que se van recibiendo WHEN S4 => IF cuenta>=8 THEN estado<=S5; ELSIF cuenta<8 THEN estado<=S3; END IF; WHEN S5 => --Una vez recibidos los 8 bits de datos se espera a recibir el bit de STOP IF uno='1' AND linea_s='1' THEN estado<=S7; END IF; WHEN S7 => estado<=S00; --Se indica que se ha terminado de recibir un byte END CASE; END IF; END PROCESS;

79

Memoria.Desarrollo

HARDWARE

VHDL

--Estado de las salidas WITH estado SELECT activa<='1' WHEN S1, '1' WHEN S3,'1' WHEN S5,'0' WHEN OTHERS; WITH estado SELECT desplaza<='1' WHEN S34,'0' WHEN OTHERS; WITH estado SELECT reset_cont<='1' WHEN S0,'1' WHEN S2, '0' WHEN OTHERS; WITH estado SELECT reset_cuenta<='1' WHEN S0,'0' WHEN OTHERS; WITH estado SELECT inc_cuenta<='1' WHEN S34,'0' WHEN OTHERS; WITH estado SELECT listo<='1' WHEN S7,'0' WHEN OTHERS; PROCESS(clk) BEGIN IF clk'event AND clk='1' THEN IF inc_cuenta='1' THEN cuenta<=cuenta+1; ELSIF reset_cuenta='1' THEN cuenta<=0; END IF; END IF; END PROCESS; END comp;

o Registro de configuracin: Entradas: carga(iguala el byte recibido a su registro), reloj, datos[7..0](byte recibido) Salidas: config(byte de configuracin)
ENTITY reg_configuracion IS PORT( carga,reloj : IN BIT; datos: IN BIT_VECTOR(7 DOWNTO 0); config : OUT BIT_VECTOR(7 DOWNTO 0)); END reg_configuracion; ARCHITECTURE comp OF reg_configuracion IS BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF carga='1' THEN config<=datos; END IF; END IF; END PROCESS; END comp;

80

Jaime Trinor Goira

HARDWARE

VHDL

o Registro de frecuencia: Entradas: desplaza (desplaza 8 bits a la derecha el registro interno), reloj, carga (carga el byte recibido en la parte alta del registro), datos[7..0](byte recibido por la lnea serie) Salidas: cuenta_freq(valor a contar del nmero de ciclos de reloj para tener la frecuencia deseada por el usuario) Seales internas: aux(la seal que va a ser desplazada)
ENTITY reg_frecuencia IS PORT( desplaza,carga,reloj: IN BIT; datos : IN BIT_VECTOR (7 DOWNTO 0); cuenta_freq : OUT BIT_VECTOR (15 DOWNTO 0)); END reg_frecuencia; ARCHITECTURE comp OF reg_frecuencia IS SIGNAL aux : BIT_VECTOR(15 DOWNTO 0); BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF carga='1' THEN aux(15 DOWNTO 8)<=datos; ELSIF desplaza='1' THEN aux(7 DOWNTO 0)<=aux(15 DOWNTO 8); END IF; END IF; END PROCESS; cuenta_freq<=aux; END comp;

o Registro de flanco: Entradas: carga (carga el byte recibido), reloj, datos[7..0](byte recibido) Salidas: nivel_flanco[4..0](Registro que indica la entrada que producir el disparo del muestreo)
ENTITY reg_nivel_flanco IS PORT( carga,reloj : IN BIT; datos: IN BIT_VECTOR(7 DOWNTO 0); nivel_flanco : OUT BIT_VECTOR(4 DOWNTO 0)); END reg_nivel_flanco;

81

Memoria.Desarrollo

HARDWARE

VHDL

ARCHITECTURE comp OF reg_nivel_flanco IS BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF carga='1' THEN nivel_flancor<=datos(4 DOWNTO 0); END IF; END IF; END PROCESS; END comp;

o Registro de Patrn: Entradas:reloj, carga(carga el byte recibido en la parte alta del registro aux), desplaza (realiza el desplazamiento de 1 byte a la derecha del registro interno), datos[7..0](es el byte recibido). Salidas: patron[31..0](valor del patrn recibido por el puerto serie) Seales internas: aux[31..0](registro interno para ser desplazado)
ENTITY reg_patron IS PORT( carga, desplaza, reloj : IN BIT; datos : IN BIT_VECTOR(7 DOWNTO 0); patron : OUT BIT_VECTOR(31 DOWNTO 0)); END reg_patron; ARCHITECTURE comp OF reg_patron IS SIGNAL aux : BIT_VECTOR(31 DOWNTO 0); BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF carga='1' THEN aux(31 DOWNTO 24)<=datos; ELSIF desplaza='1' THEN aux(23 DOWNTO 0)<=aux(31 DOWNTO 8); END IF; END IF; END PROCESS; patron<=aux; END comp;

82

Jaime Trinor Goira

HARDWARE

VHDL

o Registro de Muestras: Entradas: carga1, carga2 y carga3 (cargan el byte recibido correspondiente al nmero de muestras en su respectivo lugar ), reloj, datos[7..0] (byte recibido) Salidas: n_muestras[17..0] (nmero de muestras a realizar)
ENTITY reg_muestras IS PORT( carga1,carga2,carga3, reloj : IN BIT; datos : IN BIT_VECTOR(7 DOWNTO 0); n_muestras : OUT BIT_VECTOR(17 DOWNTO 0)); END reg_muestras; ARCHITECTURE comp OF reg_muestras IS BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF carga1='1' THEN n_muestras(7 DOWNTO 0)<=datos; END IF; IF carga2='1' THEN n_muestras(15 DOWNTO 8)<=datos; END IF; IF carga3='1' THEN n_muestras(17 DOWNTO 16)<=datos(1 DOWNTO 0); END IF; END IF; END PROCESS; END comp;

o Control de Recepcin: Entradas: reloj, listo (indica que se ha terminado la recepcin de 1 byte por la va serie), linea_serie, reset, lectura, escritura, manual, nivel, flanco y patron (son los bits del byte de configuracin ordenados del bit 0 al bit 7), empieza (seal que indica al control que debe comenzar su proceso) Salidas: terminado (indica que se ha finalizado la recepcin de bytes), carga_config, carga_freq, carga_nivel, carga_patron, carga_muestra1, carga_muestra2, carga_muestra3 (cada seal carga el byte recibido en el correspondiente registro y en su posicin definida), desplaza_freq, desplaza_patron(desplazan un byte a la derecha su correspondiente registro), habilita (le dice al control de recepcin de 1 byte que puede comenzar) Seales internas: maquina_estados, estado (estado actual del bloque), inc_contador, reset_contador, contador_patron (para saber cuantos desplazamientos llevamos en el registro de patrn)

83

Memoria.Desarrollo

HARDWARE

VHDL

ENTITY control_recepcion IS PORT( reloj,listo,linea_serie,reset,lectura,escritura,manual,nivel,flanco,patron,empieza: IN BIT; terminado,carga_config,carga_freq,carga_nivel,carga_patron,desplaza_freq,desplaza_patron ,habilita, carga_muestra1 ,carga_muestra2, carga_muestra3 : OUT BIT); END control_recepcion; ARCHITECTURE interna OF control_recepcion IS TYPE maquina_estados IS(S0,S1,S2,S3,S30,S4,S5,S6,S7,S8,S9,S90,S10,S11,S12,S13,S14,S15,SM1,SM11,SM2,SM21,SM3, SM31); SIGNAL estado: maquina_estados; SIGNAL inc_contador,reset_contador : BIT; SIGNAL contador_patron: INTEGER RANGE 0 TO 4; BEGIN PROCESS(reloj,reset) BEGIN IF reset='0' THEN estado<=S0; ELSIF reloj'event AND reloj='1' THEN CASE estado IS WHEN S0 => IF linea_serie='0' AND empieza='1' THEN estado<=S1; END IF; WHEN S1 => IF listo='1' THEN --Recibimos Byte estado<=S2; END IF; WHEN S2 => estado<= S3; --Se carga el byte de configuracin en el registro de configuracin WHEN S3 => IF escritura='1' AND lectura='0' THEN estado<=S4;

ELSIF lectura='1' AND escritura='0' THEN estado<=S30; END IF; WHEN S30 => estado<=S0; WHEN S4 => IF listo='1' THEN estado<=S5; --Recibimos Byte END IF; WHEN S5 => estado<= S6; --Se carga el primer byte de la cuenta del muestreo WHEN S6 => estado<= S7; --Desplazamos el byte de frecuencia para que quede en la parte baja del registro WHEN S7 => IF listo='1' THEN estado<=S8; --Recibimos Byte END IF;

84

Jaime Trinor Goira

HARDWARE

VHDL

WHEN S8 => estado<=SM1; --se carga el segundo byte de la cuenta para el muestreo WHEN SM1 => IF listo='1' THEN estado<=SM11; --Recibimos Byte END IF; WHEN SM11 => estado<=SM2; --cargamos el byte en el registro de numero de muestras WHEN SM2 => IF listo='1' THEN estado<=SM21; --Recibimos Byte END IF; WHEN SM21 => estado<=SM3; --cargamos segundo byte de numero de muestras WHEN SM3 => IF listo='1' THEN estado<=SM31; --Recibimos Byte END IF; WHEN SM31 => estado<=S9; --Cargamos los 2 bits restantes del numero de entradas WHEN S9 => --recibimos el resto de bytes si son necesarios IF patron='1' AND flanco='0' AND nivel='0' AND manual='0' THEN estado<=S12; ELSIF (flanco='1' OR nivel='1') AND patron='0' AND manual='0' THEN estado<=S10; ELSIF manual='1' AND patron='0' AND nivel='0' AND flanco='0' THEN estado<=S90; END IF; WHEN S90 => estado<=S0; --Se indica que ha finalizado la recepcin WHEN S10 => IF listo='1' THEN estado<=S11; --Recibimos Byte de flanco END IF; WHEN S11 => estado<=S0; --Se carga el byte de flanco en su registro correspondiente

WHEN S12 => IF listo='1' THEN estado<=S13; --Recibimos Byte de patrn END IF; WHEN S13 => IF contador_patron<3 THEN estado<=S14; ELSIF contador_patron>=3 THEN estado<=S15; END IF; WHEN S14 => estado<=S12; --Se desplaza el byte de patrn recibido WHEN S15 => estado<=S0; --Se indica que se ha terminado de recibir bytes END CASE END IF; END PROCESS;

--Estado de las Salidas WITH estado SELECT habilita<='1' WHEN S1,'1' WHEN S4,'1' WHEN S7,'1' WHEN S10,'1' WHEN S12,'1' WHEN SM1,'1' WHEN SM2,'1' WHEN SM3,'0' WHEN OTHERS; WITH estado SELECT

85

Memoria.Desarrollo

HARDWARE

VHDL

carga_config<='1' WHEN S2,'0' WHEN OTHERS; WITH estado SELECT carga_freq<='1' WHEN S5,'1' WHEN S8,'0' WHEN OTHERS; WITH estado SELECT desplaza_freq<='1' WHEN S6,'0' WHEN OTHERS; WITH estado SELECT terminado<='1' WHEN S90,'1' WHEN S15,'1' WHEN S11,'1' WHEN S30,'0' WHEN OTHERS; WITH estado SELECT carga_nivel<='1' WHEN S11, '0' WHEN OTHERS; WITH estado SELECT carga_patron<='1' WHEN S13,'0' WHEN OTHERS; WITH estado SELECT reset_contador<='1' WHEN S0,'0' WHEN OTHERS; WITH estado SELECT inc_contador<='1' WHEN S13,'0' WHEN OTHERS; WITH estado SELECT desplaza_patron<='1' WHEN S14,'0' WHEN OTHERS; WITH estado SELECT carga_muestra1<='1' WHEN SM11,'0' WHEN OTHERS; WITH estado SELECT carga_muestra2<='1' WHEN SM21,'0' WHEN OTHERS; WITH estado SELECT carga_muestra3<='1' WHEN SM31,'0' WHEN OTHERS;

PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF inc_contador='1' THEN contador_patron<=contador_patron+1; ELSIF reset_contador='1' THEN contador_patron<=0; END IF; END IF; END PROCESS; END interna;

86

Jaime Trinor Goira

HARDWARE

VHDL

Bloque de Control de Escritura Lectura:

o

Contador de posiciones:

Entradas: reloj, incrementa (aumenta una posicin de memoria), reset (pone el contador en la primera posicin de memoria), num_muestras[17..0] (valor del nmero de muestras deseadas por el usuario) Salidas: memoria_llena(indica que se han alcanzado el valor del nmero de muestras), salida[17..0] (Direccin de memoria que se va a aplicar a la RAM) Seales internas:
ENTITY inc_pos_RAM IS PORT( reloj, incrementa,reset : IN BIT; num_muestras : IN INTEGER RANGE 0 TO 262143; memoria_llena : OUT BIT; salida : OUT INTEGER RANGE 0 TO 262143); END inc_pos_RAM; ARCHITECTURE jaime OF inc_pos_RAM IS SIGNAL aux: INTEGER RANGE 0 TO 262143; BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF reset ='1' THEN aux<=0; ELSIF incrementa ='1' THEN aux<= aux +1; END IF; IF aux=num_muestras THEN memoria_llena<='1'; ELSE memoria_llena<='0'; END IF; END IF; END PROCESS; salida<=aux; END jaime;

87

Memoria.Desarrollo

HARDWARE

VHDL

Muestreo:

Entradas: reset (contador a 1), reloj, activa (incrementa contador), num_ciclos[15..0] (valor de la cuenta de la frecuencia del muestreo) Salidas: cuenta_ok (indica que se ha llegado al final de la frecuencia de muestreo) Seales internas: cuenta[15..0] (cuenta que se va incrementando), terminado (si hemos terminado la cuenta no debemos seguir incrementando el contador)
ENTITY muestreo IS PORT( reset,activa,reloj : IN BIT; num_ciclos: IN integer RANGE 1 TO 65535; --Procede del registro de frecuencia recibido cuenta_ok : OUT BIT); END muestreo; ARCHITECTURE interna OF muestreo IS SIGNAL cuenta : integer RANGE 1 TO 65535; SIGNAL terminado : BIT; BEGIN PROCESS(reloj,reset) BEGIN IF reset='1' THEN cuenta_aux1<=1; ELSIF reloj'event AND reloj='1' THEN IF activa='1' AND terminado='0' THEN cuenta_aux1<=cuenta_aux1+1; else cuenta_aux1<=1; END IF; END IF; IF cuenta=num_ciclos THEN terminado<='1'; ELSE terminado<='0'; END IF; END PROCESS; cuenta_ok<=terminado; END interna;

88

Jaime Trinor Goira

HARDWARE

VHDL

Registro RAM:

Entradas: datos_entrada[31..0] (seales de entrada a guardar en las RAM), reloj, lee (iguala el registro triestado interno a lo que le llega por el bus bidireccional), escribe (pone en el bus bidireccional el valor de las entradas) Salidas: salida[31..0] (lo que recibe el registro cuando se leen las RAM)

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY registro_RAM IS PORT( datos_entrada : IN std_logic_VECTOR (31 DOWNTO 0); reloj,lee,escribe: IN std_logic; DIN_OUT : INOUT std_logic_VECTOR(31 DOWNTO 0); salida : OUT std_logic_vector(31 DOWNTO 0)); END registro_RAM; ARCHITECTURE comp OF registro_RAM IS BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF lee='1'THEN salida<= DIN_OUT; END IF; END IF; IF escribe = '1' THEN DIN_OUT<=datos_entrada; ELSE DIN_OUT<=(OTHERS => 'Z') ; END IF; END PROCESS; END comp;

Control Lectura Escritura:

Entradas: TX_terminada (indica que el byte a sido enviado por el puerto serie), reloj, reset, habilita_escritura (queremos escribir en las RAM), habilita_lectura (indica que queremos leer de las RAM), memoria_llena (para saber cundo terminar la escritura/lectura), cuenta_freq (ha terminado la frecuencia de muestreo)

89

Memoria.Desarrollo

HARDWARE

VHDL

Salidas: reset_RAM (para poner la primera posicin de memoria), incrementa (aumentamos una posicin de memoria), CE y WE (seales de habilitacin de las RAM, escribe, lee, reset_freq (para poner el contador de la frecuencia de meustreo a 0), dato_leido (indica que ya se puede transmitir el dato procedente de la RAM), dispositivo_lleno(ya no quedan datos por leer o escribir) Seales internas: maquina_estados , estado (indica el estado en el que se encuentra el proceso)
ENTITY escritura_lectura IS PORT( TX_terminada,reloj,reset,habilita_escritura,habilita_lectura,memoria_llena,cuenta_fre q: IN BIT; reset_RAM,incrementa,CE,WE,escribe,cuenta,reset_cuenta_freq,lee,dato_leido,disposit ivo_lleno: OUT BIT); END escritura_lectura; ARCHITECTURE interna OF escritura_lectura IS TYPE maquina_estados IS (S0,E1,E2,E3,L1,L2,L3,L5,L6); SIGNAL estado : maquina_estados; BEGIN PROCESS(reloj,reset) BEGIN IF reset='0' THEN estado<=S0; ELSIF reloj'event AND reloj='1' THEN CASE estado IS WHEN S0 =>IF habilita_escritura='1' AND habilita_lectura='0' THEN estado<= E1; ELSIF habilita_escritura='0' AND habilita_lectura='1' THEN estado<=L1; END IF; --ESCRITURA WHEN E1 => estado<=E2; --Se incrementa la posicin de memoria WHEN E2 => IF cuenta_freq='1' AND memoria_llena='0' THEN estado<=E1; ELSIF memoria_llena='1' AND cuenta_freq='1' THEN --Si se llena la memoria, pasamos a indicarlo estado<=E3; END IF; WHEN E3 => estado<=S0;

90

Jaime Trinor Goira

HARDWARE

VHDL

--LECTURA WHEN L1=>estado<=L2; WHEN L2=>estado<=L3; --Leemos dato de la RAM

WHEN L3=> IF TX_terminada='1' AND memoria_llena='0' THEN --Indicamos que hemos leido el dato y esperamos a que sea enviado estado<=L2; ELSIF TX_terminada='1' AND memoria_llena='1' THEN estado<=L5; END IF; WHEN L4=> estado<=L3; --Aumentamos posicion de memoria WHEN L5 => IF habilita_lectura='1' THEN estado<=L6; --Se ha llenado el dispositivo, lo indicamos y volvemos al principio END IF; WHEN L6 => estado<=S0; END CASE; END IF; END PROCESS; --Estado de las salidas WITH estado SELECT reset_RAM<='1' WHEN S0,'0' WHEN OTHERS; WITH estado SELECT reset_cuenta_freq<='1' WHEN S0, '0' WHEN OTHERS; WITH estado SELECT WE<='0' WHEN E1,'1' WHEN OTHERS; WITH estado SELECT CE<='0' WHEN E1,'0' WHEN L1,'0' WHEN L2,'0' WHEN L3,'1' WHEN OTHERS; WITH estado SELECT escribe<='0' WHEN S0,'0' WHEN L1,'0' WHEN L2, '0' WHEN L3,'1' WHEN OTHERS; WITH estado SELECT incrementa<='1' WHEN E1,'1' WHEN L2,'0' WHEN OTHERS; WITH estado SELECT cuenta<='1' WHEN E2,'0' WHEN OTHERS; WITH estado SELECT dato_leido<='1' WHEN L3,'0' WHEN OTHERS; WITH estado SELECT lee<='1' WHEN L2,'0' WHEN OTHERS; WITH estado SELECT dispositivo_lleno<='1' WHEN E3,'1' WHEN L5,'0' WHEN OTHERS; END interna;

91

Memoria.Desarrollo

HARDWARE

VHDL

Bloque: Transmisin de un byte:

o

Contador de un bit: El mismo que el del bloque de recepcin.

Registro paralelo serie:

Entradas: reloj, desplaza (desplaza un bit a la derecha el byte que se quiere enviar por la va serie), carga (carga en su registro interno el byte de datos a enviar), datos[7..0] (byte que se quiere enviar) Salidas: salida (bit que ser enviado) Seales internas: aux_dat[7..0] (registro que se utiliza para desplazar los datos de entrada)
ENTITY reg_par_serie IS PORT( reloj,desplaza,carga : IN BIT; datos: IN BIT_VECTOR(7 DOWNTO 0); salida: OUT BIT); END reg_par_serie; ARCHITECTURE comp OF reg_par_serie IS SIGNAL aux_dat: BIT_VECTOR(7 DOWNTO 0); BEGIN PROCESS(reloj) BEGIN IF reloj'event AND reloj='1' THEN IF carga='1' THEN aux_dat<=datos; ELSIF desplaza='1' THEN aux_dat(6 DOWNTO 0)<=aux_dat(7 DOWNTO 1); END IF; END IF; END PROCESS; salida<=aux_dat(0); END comp;

Control de Transmisin: Entradas: uno (se ha contado el valor de un bit de la va serie), reloj, reset, dato (procede del registro anterior y es el valor del bit que se quiere transmitir), habilita (procede del control general y le indica a este control cundo comenzar su proceso)

92

Jaime Trinor Goira

HARDWARE

VHDL

Salidas: terminado (indica que se puede enviar otro byte), linea_serie (la de transmisin), desplaza (desplaza el registro para coger el siguiente dato que se tiene que enviar), activa (para aumentar la cuenta del divisor de frecuencia de la lnea serie), reset_cont (pone a 0 el contador anterior), carga (iguala el registro paralelo-serie al byte que se quiere enviar) Seales internas: maquina_estados , estado (indica el estado en el que se encuentra el proceso), inc_cont (incrementa el contador interno para saber cuntos bits del byte han sido enviados), res_cont (resetea este contador de bits enviados), contador (el de los bits mencionados)
ENTITY con_trans_serie IS PORT( uno,reloj,reset,dato,habilita : IN BIT; terminado,linea_serie,desplaza,activa,reset_cont,carga: OUT BIT); END con_trans_serie; ARCHITECTURE comp OF con_trans_serie IS TYPE maquina_estados IS (T0,T1,T2,T3,T4,T5,T6,T7); SIGNAL estado : maquina_estados; SIGNAL inc_cont,res_cont: BIT; SIGNAL contador: INTEGER RANGE 0 TO 8; BEGIN PROCESS(reset,reloj) BEGIN IF reset='0' THEN estado<=T0; ELSIF reloj'event AND reloj='1' THEN CASE estado IS WHEN T0 => IF habilita='1' THEN END IF; estado<=T1;

WHEN T1 => estado<= T2; --Se cargan los datos a ser enviados WHEN T2 => IF uno='1' THEN estado<=T3; --Si se ha enviado el bit de START, se procede a enviar los bits de datos END IF; WHEN T3 => IF uno='1' THEN estado<=T4; END IF; WHEN T4 => IF contador>=7 THEN estado<=T6; ELSIF contador<7 THEN estado<=T5; END IF; WHEN T5 => estado<=T3; WHEN T6 => IF uno='1' THEN estado<= T7; --Si hemos enviado el bit de STOP, indicamos que ya hemos terminado (en T7) END IF;

93

Memoria.Desarrollo

HARDWARE

VHDL

WHEN T7=> estado<=T0; END CASE; END IF; END PROCESS; --Estado de las salidas WITH estado SELECT linea_serie<= '0' WHEN T2, dato WHEN T3,dato WHEN T4,dato WHEN T5, '1' WHEN OTHERS; WITH estado SELECT activa<='1' WHEN T2, '1' WHEN T3, '1' WHEN T6,'0' WHEN OTHERS; WITH estado SELECT desplaza<='1' WHEN T5,'0' WHEN OTHERS; WITH estado SELECT carga<='1' WHEN T1, '0' WHEN OTHERS; WITH estado SELECT res_cont<='1' WHEN T0, '0' WHEN OTHERS; WITH estado SELECT inc_cont<='1' WHEN T5, '0' WHEN OTHERS; WITH estado SELECT reset_cont<='1' WHEN T0, '0' WHEN OTHERS; WITH estado SELECT terminado<='1' WHEN T7,'0' WHEN OTHERS; PROCESS(reloj) BEGIN --Contador para saber si se han enviado los 8 bits IF reloj'event AND reloj='1' THEN IF inc_cont='1' THEN contador<=contador+1; ELSIF res_cont='1' THEN contador<=0; END IF; END IF; END PROCESS; END comp;

94

Jaime Trinor Goira

HARDWARE

VHDL

Bloque Multiplexor de Entrada: Entradas: entradas[31..0](las propias seales a muestrear), num_entradas[1..0] (para indicar si se van a muestrear 4, 8, 16 32 entradas) Salidas: enables_buffers( habilitamos los buffers de proteccin necesarios), salida[31..0] (el valor de las entradas copiados en las salidas correspondientes segn lo explicado)
ENTITY mux_entradas IS PORT( entradas : IN BIT_VECTOR(31 DOWNTO 0); num_entradas: IN BIT_VECTOR(1 DOWNTO 0); enables_buffers : OUT BIT_VECTOR(3 DOWNTO 0); salida : OUT BIT_VECTOR(31 DOWNTO 0)); END mux_entradas; ARCHITECTURE comp OF mux_entradas IS BEGIN PROCESS BEGIN CASE num_entradas IS WHEN "00"=> salida(3 DOWNTO 0)<=entradas(3 DOWNTO 0); salida(7 DOWNTO 4)<=entradas(3 DOWNTO 0); salida(11 DOWNTO 8)<=entradas(3 DOWNTO 0); salida(15 DOWNTO 12)<=entradas(3 DOWNTO 0); salida(19 DOWNTO 16)<=entradas(3 DOWNTO 0); salida(23 DOWNTO 20)<=entradas(3 DOWNTO 0); salida(27 DOWNTO 24)<=entradas(3 DOWNTO 0); salida(31 DOWNTO 28)<=entradas(3 DOWNTO 0); enables_buffers<="1110"; --Habilitamos las 4 primeras entradas del Buffer A (enable 1 del buffer A en bajo nivel activa las 4 entradas) WHEN "01" => salida(7 DOWNTO 0)<=entradas(7 DOWNTO 0); salida(15 DOWNTO 8)<=entradas(7 DOWNTO 0); salida(23 DOWNTO 16)<=entradas(7 DOWNTO 0); salida(31 DOWNTO 24)<=entradas(7 DOWNTO 0); enables_buffers<="1100"; --Habilitamos las 8 entradas del Buffer A WHEN "10" => salida(15 DOWNTO 0)<=entradas(15 DOWNTO 0); salida(31 DOWNTO 16)<=entradas(15 DOWNTO 0); enables_buffers<="1000"; --Habilitamos Buffer A y B (Los 2 enables del Buffer B estn conectados entre s) WHEN "11" => salida(31 DOWNTO 0)<=entradas(31 DOWNTO 0); enables_buffers<="0000"; -- Habilitamos Buffer A, B , C y D (Los enables de los buffer C y D estn fsicamente conectados al mismo punto) END CASE; END PROCESS; END comp;

95

Memoria.Desarrollo

HARDWARE

VHDL

Bloque: Multiplexor de Salida: Entradas: reloj, reset, incrementa1 e incrementa2 (para saber qu byte a sido enviado y cul hay que enviar), datos_RAMS[31..0] (valor de los datos leidos de todas las RAMs), num_entradas[1..0] (para saber cuntas entradas se muestrearon) Salidas: byte_a_enviar[7..0] Seales internas: contador (para saber cuntos bytes quedan por enviar)
ENTITY mux_salida IS PORT( reloj,reset,incrementa1,incrementa2 : IN BIT; datos_RAMS : IN BIT_VECTOR(31 DOWNTO 0); num_entradas: IN BIT_VECTOR(1 DOWNTO 0); byte_a_enviar: OUT BIT_VECTOR(7 DOWNTO 0)); END mux_salida; ARCHITECTURE comp OF mux_salida IS SIGNAL contador : INTEGER RANGE 0 TO 7; BEGIN PROCESS BEGIN CASE contador IS WHEN 0 => IF num_entradas="00" THEN --4 entradas byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(3 DOWNTO 0) --RAM A1 byte_a_enviar(7 DOWNTO 4)<="0000"; --solo enviamos 4 datos ELSIF (num_entradas="01" OR num_entradas="10" OR num_entradas="11") THEN byte_a_enviar(7 DOWNTO 0)<=datos_RAMS(7 DOWNTO 0); END IF; WHEN 1 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(7 DOWNTO 4) ;--RAM A2 byte_a_enviar(7 DOWNTO 4)<="0000"; ELSIF (num_entradas="01" OR num_entradas="10" OR num_entradas="11") THEN byte_a_enviar(7 DOWNTO 0)<=datos_RAMS(15 DOWNTO 8); END IF; WHEN 2 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(11 DOWNTO 8);--RAM A3 byte_a_enviar(7 DOWNTO 4)<="0000"; ELSIF (num_entradas="01" OR num_entradas="10" OR num_entradas="11") THEN byte_a_enviar(7 DOWNTO 0)<=datos_RAMS(23 DOWNTO 16); END IF;

96

Jaime Trinor Goira

HARDWARE

VHDL

WHEN 3 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(15 DOWNTO 12);--RAM A4 byte_a_enviar(7 DOWNTO 4)<="0000"; ELSIF (num_entradas="01" OR num_entradas="10" OR num_entradas="11") THEN byte_a_enviar(7 DOWNTO 0)<=datos_RAMS(31 DOWNTO 24); END IF;

WHEN 4 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(19 DOWNTO 16);--RAM B1 byte_a_enviar(7 DOWNTO 4)<="0000"; END IF; WHEN 5 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(23 DOWNTO 20);--RAM B2 byte_a_enviar(7 DOWNTO 4)<="0000"; END IF; WHEN 6 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(27 DOWNTO 24);--RAM B3 byte_a_enviar(7 DOWNTO 4)<="0000"; END IF; WHEN 7 => IF num_entradas="00" THEN byte_a_enviar(3 DOWNTO 0)<=datos_RAMS(31 DOWNTO 28);--RAM B4 byte_a_enviar(7 DOWNTO 4)<="0000"; END IF; END CASE; END PROCESS; PROCESS(reloj) contador BEGIN IF reloj'event AND reloj='1' THEN IF reset='1' THEN contador<=0; ELSIF incrementa1='1' OR incrementa2='1' THEN contador<=contador+1; END IF; END IF; END PROCESS; END comp;

97

Memoria.Desarrollo

HARDWARE

VHDL

Bloque Desplazador Chip Selects: Entradas: Nentradas [1..0] (indica el nmero de entradas a muestrear), desplaza (realiza el desplazamiento correspondiente del CS de la/s RAMs que se vayan a utilizar), reloj, CS, reset Salidas: chip_selects[7..0] (conectado fsicamente a los CS de las distintas RAM) Seales internas: aux_CS [7..0](seal para poder desplazar el CS original)

ENTITY desplazador_CS IS PORT( Nentradas : IN BIT_VECTOR(1 DOWNTO 0); --BITS del numero de entradas (byte de configuracion) desplaza,reloj,CS,reset: IN BIT; chip_selects : OUT BIT_VECTOR (7 DOWNTO 0)); END desplazador_CS; ARCHITECTURE comp OF desplazador_CS IS SIGNAL aux_CS: BIT_VECTOR(7 DOWNTO 0); BEGIN PROCESS(reloj)--Multiplexor BEGIN IF reloj'event AND reloj='1' THEN CASE Nentradas IS WHEN "00" => IF reset='1' AND desplaza='0' THEN aux_CS(0)<='0'; aux_CS(1)<='1'; aux_CS(2)<='1'; aux_CS(3)<='1'; aux_CS(4)<='1'; aux_CS(5)<='1'; aux_CS(6)<='1'; aux_CS(7)<='1'; ELSIF desplaza='1' AND reset='0' THEN aux_CS(7 DOWNTO 1)<=aux_CS(6 DOWNTO 0); aux_CS(0)<='1'; END IF; WHEN "01" => IF reset='1' AND desplaza='0' THEN aux_CS(0)<='0'; aux_CS(1)<='0'; aux_CS(2)<='1'; aux_CS(3)<='1'; aux_CS(4)<='1'; aux_CS(5)<='1'; aux_CS(6)<='1'; aux_CS(7)<='1';

98

Jaime Trinor Goira

HARDWARE

VHDL

ELSIF desplaza='1' AND reset='0' THEN aux_CS(7 DOWNTO 2)<=aux_CS(5 DOWNTO 0); aux_CS(0)<='1'; aux_CS(1)<='1'; END IF; WHEN "10" => IF reset='1' AND desplaza='0' THEN aux_CS(0)<='0'; aux_CS(1)<='0'; aux_CS(2)<='0'; aux_CS(3)<='0'; aux_CS(4)<='1'; aux_CS(5)<='1'; aux_CS(6)<='1'; aux_CS(7)<='1'; ELSIF desplaza='1' AND reset='0' THEN aux_CS(7 DOWNTO 4)<=aux_CS(3 DOWNTO 0); aux_CS(0)<='1'; aux_CS(1)<='1'; aux_CS(2)<='1'; aux_CS(3)<='1'; END IF; WHEN "11" => aux_CS(0)<='0'; aux_CS(1)<='0'; aux_CS(2)<='0'; aux_CS(3)<='0'; aux_CS(4)<='0'; aux_CS(5)<='0'; aux_CS(6)<='0'; aux_CS(7)<='0'; END CASE; END IF; END PROCESS; chip_selects(0)<=aux_CS(0) OR CS; chip_selects(1)<=aux_CS(1) OR CS; chip_selects(2)<=aux_CS(2) OR CS; chip_selects(3)<=aux_CS(3) OR CS; chip_selects(4)<=aux_CS(4) OR CS; chip_selects(5)<=aux_CS(5) OR CS; chip_selects(6)<=aux_CS(6) OR CS; chip_selects(7)<=aux_CS(7) OR CS; END comp;

99

Memoria.Desarrollo

HARDWARE

VHDL

Bloque: Multiplexor de Prueba: Entradas: direcciones[17..0] (posicin de memoria que se debe poner en las memorias de ambos bancos de memorias), WE (valor de la seal de habilitacin que hay que poner en la RAM) Salidas: dir1[17..0], dir2[17..0] (valor de la direccin de memoria de cada banco de RAMs), WE1 y WE2 (valor de cada seal de habilitacin de cada banco)

ENTITY mux_prueba IS PORT( direcciones : IN BIT_VECTOR(17 DOWNTO 0); WE : IN BIT; dir1,dir2 : OUT BIT_VECTOR(17 DOWNTO 0); WE1,WE2 :OUT BIT); END mux_prueba; ARCHITECTURE interna OF mux_prueba IS BEGIN dir1<=direcciones; dir2<=direcciones; WE1<=WE; WE2<=WE; END interna;

Bloque: Control General: Entradas: byte_nivel[4..0] (indica qu entrada debe activar el disparo por flanco), entradas[31..0] (seales de entrada a muestrear), byte_patron[31..0] (valor del patrn que activar el disparo en este modo), escritura, lectura, num_entradas [1..0] manual, flanco_subida, flanco_bajada y patron (valor de los bits del byte de configuracin), reloj, recepcion_terminada (indica que no quedan bytes por recibir), transmision_terminada (indica que se envi por la lnea serie 1 byte), memoria_llena(para saber cundo hay que parar el muestreo y la lectura de las RAM), dato_leido, linea_serie, reset. Salidas: reset_CS (para indicarle al bloque de desplazador_CS que vamos a escribir_leer en el primer grupo de memorias), habilita_escritura, habilita_lectura, recibe_bytes (habilitamos el bloque de recepcin), desplaza_CS (pasamos a otra/s memoria/s), transmite_byte, escribiendo (indica si el analizador est escribiendo), leyendo (indica que se est leyendo), incrementa1 (para cambiar de memoria), incrementa2 (para transmitir otro byte), reset_cuenta

100

Jaime Trinor Goira

HARDWARE

VHDL

Seales internas: maquina_estados, estado (se indica en qu estado est el proceso), contador (indica qu memoria o memorias estn en uso), contador2 (para saber qu byte de la misma muestra se tiene que enviar), reset_cont, reset_cont2 (para resetear el contador correspondiente), inc_cont, inc_cont (para incrementar el contador correspondiente).
ENTITY control_generalplaca IS PORT( byte_nivel : IN INTEGER RANGE 0 TO 31; entradas,byte_patron: IN BIT_VECTOR(31 DOWNTO 0); escritura,lectura,manual,flanco_subida,flanco_bajada,patron : IN BIT; --Proceden del byte de configuracion num_entradas : IN BIT_VECTOR(1 DOWNTO 0); reloj,recepcion_terminada,transmision_terminada,memoria_llena,dato_leido,linea_seri e,reset : IN BIT; reset_CS,habilita_escritura,habilita_lectura,recibe_bytes,desplaza_CS,transmite_byte,e scribiendo,leyendo,incrementa1,incrementa2,reset_cuenta: OUT BIT); END control_generalplaca; ARCHITECTURE interna OF control_generalplaca IS TYPE maquina_estados IS (S0,S1,E1,P,Fs1,Fs2,Fb1,Fb2,E2,E3,E4,E5,L1,L2,L3,L4,L5,L6); SIGNAL estado :maquina_estados; SIGNAL contador : INTEGER RANGE 0 TO 8; SIGNAL contador2 : INTEGER RANGE 0 TO 4; SIGNAL reset_cont,reset_cont2,inc_cont,inc_cont2 : BIT; BEGIN PROCESS(reloj,reset) BEGIN IF reset='0' THEN estado<=S0; ELSIF reloj'event AND reloj='1' THEN CASE estado IS WHEN S0=> IF linea_serie='0' THEN --Vamos a recibir los bytes de configuracin estado<=S1; END IF; WHEN S1=> IF recepcion_terminada='1' THEN --Si hemos recibido todos los bytes esperamos a escribir en las RAMs IF escritura='1' THEN estado<=E1; END IF; END IF;

101

Memoria.Desarrollo

HARDWARE

VHDL

WHEN E1=> -- Vamos al modo deseado por el usuario IF manual='1' AND flanco_subida='0' AND flanco_bajada='0' AND patron='0' THEN estado<=E2; ELSIF manual='0' AND flanco_subida='0' AND (flanco_bajada='1' AND entradas(byte_nivel)='0') AND patron='0' THEN estado<=Fb1; --Si queremos flanco de bajada y la entrada de disparo est a '0' habr que esperar a que vuelva a subir y bajar ELSIF manual='0' AND flanco_subida='0' AND (flanco_bajada='1' AND entradas(byte_nivel)='1') AND patron='0' THEN estado<=Fb2; --Si por el contrario la entrada ya est en alto nivel solamente hay que esperar que baje ELSIF manual='0' AND (flanco_subida='1' AND entradas(byte_nivel)='0') AND flanco_bajada='0' AND patron='0' THEN estado<=Fs2 ; --Lo mismo para flanco de subida: si la entrada est a 0 directamente esperamos que suba, y si est a 1 esperamos a que vuelva a bajo nivel y se produzca el nuevo flanco de subida ELSIF manual='0' AND (flanco_subida='1' AND entradas(byte_nivel)='1') AND flanco_bajada='0' AND patron='0' THEN estado<=Fs1; ELSIF manual='0' AND flanco_subida='0' AND flanco_bajada='0' AND patron='1' THEN estado<=P; END IF; WHEN Fb1 => IF entradas(byte_nivel)='1' THEN estado<=Fb2; END IF; WHEN Fb2 => IF entradas(byte_nivel)='0' THEN estado<=E2; END IF; WHEN Fs1 => IF entradas(byte_nivel)='0' THEN estado<=Fb2; END IF; WHEN Fs2 => IF entradas(byte_nivel)='1' THEN estado<=E2; END IF; WHEN P=> CASE num_entradas IS --Como recibimos 32 bits de patrn siempre, comparamos el mismo nmero de bits (entradas con patrn) y si se cumple procedemos a muestrear WHEN "00" => IF entradas(3 DOWNTO 0)=byte_patron(3 DOWNTO 0) THEN estado<=E2; END IF;

102

Jaime Trinor Goira

HARDWARE

VHDL

WHEN "01" => IF entradas(7 DOWNTO 0)=byte_patron(7 DOWNTO 0) THEN estado<=E2; END IF; WHEN "10" => IF entradas(15 DOWNTO 0)=byte_patron(15 DOWNTO 0) THEN estado<=E2; END IF; WHEN "11" => IF entradas(31 DOWNTO 0)=byte_patron(31 DOWNTO 0) THEN estado<=E2; END IF; END CASE; --Escritura de las RAMs WHEN E2=> IF memoria_llena='1' THEN --Se espera a que se llene/n la/s memoria/s en funcin del nmero de entradas a muestrear estado<=E3; END IF; WHEN E3=> IF (num_entradas="00" AND contador=1) OR (num_entradas="01") OR (num_entradas="10" AND contador=1) OR num_entradas="11" THEN estado<=E5; ELSE estado<=E4; END IF; WHEN E4 => estado<=E2; WHEN E5 => estado<=L1; --Si terminamos la escritura, mandamos todos los datos por la via serie WHEN L1=>IF dato_leido='1' AND memoria_llena='0' THEN estado<=L2; ELSIF memoria_llena='1' THEN estado<=L4; END IF;

WHEN L2 => IF (num_entradas="00" OR num_entradas="01" OR (num_entradas="10" AND contador2=1) OR (num_entradas="11" AND contador=3)) AND transmision_terminada='1' THEN estado<=L1; ELSIF ((num_entradas="10" AND contador2<1) OR (num_entradas="11" AND contador2<3)) AND transmision_terminada='1' THEN estado<=L3; END IF; WHEN L3 => estado<=L2; WHEN L4 => IF (num_entradas="00" AND contador=1) OR (num_entradas="01") OR (num_entradas="10" AND contador=1) OR num_entradas="11" THEN estado<=L6; ELSE estado<=L5; END IF; WHEN L5 => estado<=L1;

103

Memoria.Desarrollo

HARDWARE

VHDL

WHEN L6=> estado<=S0; END CASE; END IF; END PROCESS; --Estado de las salidas WITH estado SELECT recibe_bytes<='1' WHEN S1,'0' WHEN OTHERS; WITH estado SELECT habilita_escritura<='1' WHEN E2,'0' WHEN OTHERS; WITH estado SELECT habilita_lectura<='1' WHEN L1,'1' WHEN L4,'0' WHEN OTHERS; WITH estado SELECT reset_cont<='1' WHEN S0,'1' WHEN E5,'0' WHEN OTHERS; WITH estado SELECT reset_cont2<='1' WHEN S1,'0' WHEN OTHERS; WITH estado SELECT inc_cont<='1' WHEN E4,'1' WHEN L5,'0' WHEN OTHERS; WITH estado SELECT inc_cont2<='1' WHEN L3,'0' WHEN OTHERS; WITH estado SELECT transmite_byte<='1' WHEN L2,'0' WHEN OTHERS; WITH estado SELECT desplaza_CS<='1' WHEN L5,'1' WHEN E4,'0' WHEN OTHERS; WITH estado SELECT reset_CS<='1' WHEN S1,'1' WHEN E5,'0' WHEN OTHERS; WITH estado SELECT leyendo<='1' WHEN L1,'1' WHEN L2,'1' WHEN L3,'1' WHEN L4,'1' WHEN L5,'1' WHEN L6,'0' WHEN OTHERS; WITH estado SELECT escribiendo<='1' WHEN E1,'1' WHEN E2,'1' WHEN E3,'1' WHEN E4,'1' WHEN E5,'0' WHEN OTHERS; incrementa1<=inc_cont; incrementa2<=inc_cont2; reset_cuenta<=reset_cont; PROCESS(reloj) BEGIN --Contadores para la lectura y escritura de las RAMs IF reloj'event AND reloj='1' THEN IF inc_cont='1' THEN contador<=contador+1; ELSIF reset_cont='1' THEN contador<=0; END IF; IF inc_cont2='1' THEN contador2<=contador2+1; ELSIF reset_cont='1' THEN contador2<=0; END IF; END IF; END PROCESS; END interna;

104

Jaime Trinor Goira

Captulo 3 Conclusiones
Se ha realizado el diseo de un analizador de 32 canales con diversos modos de disparo, velocidad de muestreo de hasta 160MHz y una profundidad variable de hasta 2MB de datos. El diseo de la placa que hace las funciones este dispositivo se ha hecho con tecnologa de fabricacin de clase 4 y a 4 capas, siendo una placa completamente autnoma y en la que se incluyen todos los componentes necesarios para configurar la FPGA, proteger el analizador de los circuitos conectados a ste, y donde se incorpora 8 memorias SRAM de 256KBx4 donde se almacenarn los datos capturados y muestreados en el tiempo. Por circunstancias diversas, no se pudo fabricar la placa definitiva (falta de tiempo y presupuesto).

No obstante se ha construido una placa de prueba (para la tarjeta Prince de la universidad) capaz de realizar las funciones de un analizador a una velocidad programable de hasta 15MHz, de 4 u 8 canales y una profundidad de muestras variable de 1 a 512 KB para 4 entradas y de la mitad para 8 entradas, de tal forma que cuando recibe los datos de configuracin desde un PC remoto, realiza el muestreo de las seales de entrada segn lo especificado por el usuario (frecuencia, nmero de entradas y modo de disparo) si es que se cumplen las condiciones de disparo. Al terminar de capturar muestras, el analizador de prueba enva los datos guardados al ordenador conectado.

Tambin se ha realizado un software de comunicacin entre el ordenador y el analizador por el cual el PC enva los datos de configuracin del analizador, y espera recibir los datos almacenados por el puerto serie y escribirlos en un fichero que ser abierto por el programa MaxPlus II para poder ver la evolucin temporal de las entradas.

Se ha realizado la comparacin de este analizador con uno similar de venta en las tiendas (32 entradas, 100MHz y 2KB de profundidad), y el analizador conseguido posee unas prestaciones ampliamente mejores puesto que mientras uno tiene tan solo 2KB de capacidad, el nuestro posee hasta 2MB, siendo variable el segundo en cuanto a nmero de entradas. Mientras el analizador de la comparacin ronda los 1000 de precio de venta al pblico, el nuestro sale alrededor de 320 (precio en el cual ya estn contabilizadas las futuras mejoras que se comentan en la parte III: estudio econmico).

105

Analizador Lgico basado en FPGA

Captulo 4 Futuros desarrollos

Debido a la complejidad del proyecto y al nmero de personas participantes en l (solamente una), ha sido imposible alcanzar todos los objetivos marcados inicialmente. No obstante, debido a su inters, se producirn mejoras y se complementar el diseo realizado en posteriores proyectos.

Un objetivo inicial era el de realizar un software de visualizacin propio y de un men visual en el cual se configurara el analizador , finalmente se opt por realizar un proyecto de continuacin que contuviese dicho software de visualizacin, y hacer un men contextual mediante ventanas de DOS.

Otro de los objetivos iniciales era el de hacer un analizador con un software multiplataforma (compatible con distintos sistemas operativos). Se hizo una previa documentacin sobre cmo poder realizarlo a travs de un programa de libre distribucin llamado WxWindows que compila el cdigo fuente generado en un entorno visual en Windows (Visual Basic, Visual C++, Borland C++, etc..) y permite ser ejecutado en Linux y Unix mediante la definicin de una serie de libreras y clases en C++. No se ha llevado a cabo este objetivo puesto que el software programado para el men de configuracin se ha realizado en C, por lo que se puede compilar en cualquier sistema operativo. Lo nico que hace referencia a C++ es la programacin del puerto serie, sin embargo Windows y Linux utilizan de forma diferente. Lo que habra que hacer simplemente es una versin para Linux de manejo de este Hardware (En el CD se incluye un enlace a una Web donde se puede ver la forma de manejar un puerto serie a travs de este sistema operativo).

A la hora de realizar las pruebas en la placa de la tarjeta Prince se vio como el sistema poda llegar a ser muy lento para gran cantidad de muestras almacenadas a la hora de enviarlas por el puerto serie. En la placa de prueba solamente se dispone de la cuarta parte de memorias que en el Analizador JTG_05 y se comprob que para la profundidad mxima de muestras y para una configuracin de 4 entradas, el analizador tardaba ms de 45 segundos (en el analizador final ms de 3 minutos) en descargar todos los datos, por lo que sera conveniente aadir una interfaz de comunicacin por puerto USB para reducir estos tiempos. Una mejora en este aspecto ya se hizo en los ltimos compases de

106

Jaime Trinor Goira

la realizacin del proyecto: incluir en la comunicacin el nmero de muestras que se quiere tener ya que inicialmente se muestreaban las entradas hasta llenar por completo todas las memorias. Aparte, si se quera muestrear a una velocidad reducida, el tiempo de almacenamiento y de transmisin se vea multiplicado enormemente, Ej: para la velocidad mnima de muestreo del Analizador de Prueba (225 Hz)y la mxima profundidad de muestras ( 2 218 ) se tardara en escribir todos los datos 2330 segundos (aproximadamente 38 minutos) y en enviarlos por el puerto serie los 45 segundos de antes. Con esto se demuestra que el aadir la opcin de nmero de muestras programable mejor el proyecto de forma espectacular.

Para mejorar an ms el analizador, se pens en realizar un muestreo continuo sea cual sea el modo de disparo a la velocidad indicada y una vez se cumpliesen las condiciones de disparo, se enviara al ordenador las muestras anteriores y posteriores al disparo de las mismas. De esta forma se podra ver la evolucin de las seales de entrada de una forma ms dinmica y el usuario del analizador podra detectar mejor los posibles fallos del sistema digital conectado.

La ltima mejora que se pens era la de conseguir un diseo en VHDL capaz de duplicar la velocidad de la escritura normal de las memorias: segn las especificaciones de las RAM, tienen un tiempo mnimo de acceso igual a 12ns, sin embargo el reloj del analizador final es ms rpido que este tiempo (exactamente el doble), por lo que si se conectan las RAM en paralelo y en un ciclo se comienza escribiendo en una memoria y en el siguiente flanco de reloj se comienza a escribir en la otra (manteniendo la escritura en la primera para cumplir con el tiempo mnimo de las RAM adquiridas), se consigue duplicar la velocidad como se deseaba y como se aprecia en la Figura 1:

Figura 1: Manera de duplicar la velocidad mxima de muestreo

Memoria. Futuros desarrollos

Analizador Lgico basado en FPGA

Esta parte comentada no se realiz porque en la placa de prueba el reloj es tan solo de casi 15 MHz y adems la FPGA es el modelo 4 de velocidad (solamente permite conectar un reloj de hasta 60 MHz), por lo que tampoco se poda cambiarle el reloj sin ms. Sin embargo, si sera posible simular y hacer pruebas en la placa de la tarjeta Prince realizando lo que se hace en la Figura 1 (claro est que a mucha menos velocidad). La parte fsica del diseo de la placa del Analizador JTG_05 y la de el Analizador de Prueba se ha realizado teniendo en cuenta lo dicho, por lo que se han puesto dos bancos de memorias, conectando a cada uno de ellos su bus de direcciones por separado, as que lo nico que habra que hacer es modificar la parte hardware correspondiente al diseo por VHDL.

Para ello habra que tener dos bloques de escritura/lectura en la circuitera interna de la FPGA para gestionar por separado cada banco de memorias, en vez de uno como se tiene actualmente y duplicar el nmero de seales que van desde el bloque de Control General hasta el bloque de Lectura Escritura. Dentro de este ltimo bloque habra que conectar cada registro bidireccional a la mitad de memorias, uno al bus de datos de las memorias del banco A y el otro registro triestado al bus de datos del banco de memorias B (ambos son de 16 bits de datos ya hay conectadas 4 memorias RAM por cada banco). A su vez, el control que gestiona la escritura lectura (Control General), tendra que comprobar si la cuenta del nmero de ciclos necesarios para la frecuencia requerida vale 1 o no, es decir, como la frecuencia mxima es de 160 MHz y la del reloj vale lo mismo y adems frecuencias mayores de 80MHz y menores de 160MHz no se pueden tener (todas las divisiones del reloj de la FPGA por esta frecuencia sern de 1 porque no se pueden contar fracciones de los ciclos del reloj), entonces se hara que si este bit (el ms bajo del registro de frecuencia) est a 1 y el resto a 0 es que se cumple lo mencionado y habr que realizar un muestreo de la forma de la Figura 1. Si se mantiene este diseo para el circuito interno de la FPGA de la placa de prueba, se obtiene que se muestreara de esta forma cuando la frecuencia introducida por el usuario estuviera entre 7372801 HZ y la frecuencia del reloj (14.7456MHz).

108

Jaime Trinor Goira

BIBLIOGRAFA

www.cadsoft.de , Pgina principal del programa Eagle Layout Editor en la que se puede conseguir su programa bsico de forma gratuita (limitado a placas de 2 caras y de dimensiones inferiores a 10x10cm) y en donde se recogen varios manuales de uso de su programa.

www.altera.com , Pgina Web de este proveedor y fabricante de componentes electrnicos, especializado en FPGAs y dispositivos parecidos. Aqu se puede descargar el programa MaxPlus II, pedir una licencia para la configuracin de la FPGA a utilizar e informacin tcnica de sus componentes.

www.amidata.es , Es la pgina de uno de los distribuidores ms importantes de Espaa de componentes electrnicos (RS). En este sitio se pueden realizar pedidos, buscar precios de componentes y tambin se pueden consultar datos tcnicos de los mismos.

www.farnell.com , Otro proveedor de componentes elctricos, electrnicos y electromecnicos con un amplio stock de productos.

www.codeproject.com/system/serial_com.asp, Foro y pgina dedicada al manejo del puerto serie mediante C++ en Windows.

www.lab-circuits.com, Pgina de una empresa dedicada a la fabricacin de serigrafa de circuitos con varias tecnologas de fabricacin. Las especificaciones de cada clase de fabricacin se pueden encontrar en la direccin www.lab-circuits.com/normfmil.htm

http://www.wxwindows.org/ , Pgina donde se recoge informacin sobre la programacin y compilacin de programas multiplataforma y en donde se puede encontrar el programa que compila entornos visuales en varios sistemas operativos (Linux y Windows).

109

Jaime Trinor Goira

Analizador Lgico basado en FPGA

PARTE Esquemas

SCHs

Placa de Prueba
Esta placa se compone, como ya se coment en su momento, de 4 conectores que irn ensamblados a la tarjeta Prince (SV1 a SV4 de la Figura 1), 2 memorias RAM (IC2 e IC3), un Buffer de proteccin (IC1A e IC1B), los condensadores para mantener la tensin de alimentacin de cada componente y por ltimo el conector para las seales de entrada (057-010-1). En este esquema se pueden comprobar los pines a los que van conectados cada componente y sus respectivos nombres.

Figura 1: Esquema de los componentes de la placa de prueba

110

Jaime Trinor Goira

Memoria. Esquemas

Placa Final

Figura 2: Esquema de la placa final 1

Figura 3: Esquema de la placa final 2

111

Jaime Trinor Goira

Memoria. Esquemas

Analizador Lgico basado en FPGA

Figura 4: Esquema de la placa final 3

Figura 5: Esquema de la placa final 4

112

Jaime Trinor Goira

Memoria. Esquemas

Figura 6: Esquema de la placa final 5

En las 5 figuras que se muestran justamente encima se detallan la conexin que se debe realizar entre los distintos componentes del Analizador JTG_05, se indica el nombre de cada componente y a su vez el de todas las seales usadas por el analizador.

El circuito final se podr ver en la parte de Esquemas elctricos de la memoria donde se mostrar en tamao real las pistas de las caras anterior y posterior tanto del circuito de prueba como el del analizador final.

113

Jaime Trinor Goira

Memoria. Esquemas

Analizador Lgico basado en FPGA

Esquemas Elctricos:
Los esquemas con los que se ha desarrollado y construido la placa de prueba y como debera quedar la placa final vienen definidos a continuacin. En el CD del proyecto se incluyen sendos archivos en formato PostScript para imprimir los circuitos con el tamao real y correcto que deben tener.

Placa de Prueba:

Esquema 1: Cara de arriba de la placa de prueba

Esquema 2: Cara de abajo de la placa de prueba

114

Jaime Trinor Goira

Memoria. Esquemas

Placa Final:

Esquema 3: Cara de arriba de la placa final

115

Jaime Trinor Goira

Memoria. Esquemas

Analizador Lgico basado en FPGA

Esquema 4:Cara de abajo de la placa final

116

Jaime Trinor Goira

ESTUDIO ECONMICO: En esta seccin del proyecto se trata de obtener el precio del producto Analizador JTG_05 para una produccin en serie del mismo. Hay que partir de que primero se realiza un prototipo del analizador y en ste se practican todas las pruebas y testeos antes de introducirlo al mercado en su versin definitiva.

Componente
EPF10K30 (FPGA) EPC2TC32 SRAM Buffer Oscilador 80 Conector DB9 MAX 232 74HC05 74HC14 Conector 50 pines Conector 32 pines Conector 10 pines Resistencias Condensadores ANALIZADOR

Cantidad
1 1 8 4 1 1 1 1 1 4 3 1 14 36

Precio Unitario ()
100 31 2.52 1.27 4.59 1.38 2.83 0.57 0.36 0.74 0.55 0.24 0.02 0.03

Coste total ()
100 31 20.16 5.08 4.59 1.38 2.83 0.57 0.36 2.96 1.65 0.24 0.28 1.08 172.18

En la tabla anterior se recogen los precios unitarios de cada componente del analizador y el nmero de cada componente que utiliza el mismo. En total, se tiene que para realizar un analizador hay que desembolsar 172 en componentes (Esta cifra se ver drsticamente disminuida porque los precios reflejados se corresponden a precios de venta al pblico en general, cuando se compren grandes cantidades este precio disminuir en casi un 50 % segn como se negocie con los proveedores, realizando una economa de escala).

Para la realizacin de cada placa del analizador es necesario enviarlo a una fbrica especializada en circuitos multicapa. La tecnologa de fabricacin es de clase 4 y su precio es de 5.4 por decmetro cuadrado de superficie para una placa de 1.6mm de espesor. El analizador mide 15cm de ancho por 16.5 de alto, lo que equivale a 2.475 decmetros cuadrados y supone un precio de 13.4 por placa. A este precio hay que aadirle el coste de programacin y preparacin de las mquinas que realizarn el proceso de fabricacin de la placa. Estos costes son de 419 independientemente del nmero de placas a realizar.

117

Jaime Trinor Goira

Memoria. Estudio Econmico

Analizador Lgico basado en FPGA

Ahora falta aadir los gastos de mano de obra que se derivan del diseo del hardware y del software del prototipo:

Descripcin

N de horas

Precio por hora de mano de obra ()

Total ()

Desarrollo Hardware (VHDL) Desarrollo Hardware (diseo placa) Software TOTAL mano de obra

250

25

6250

50

25

1250

150 450

25

3750 11250

En la anterior tabla se muestra el nmero de horas necesarias para llevar a cabo el desarrollo de las diferentes partes del analizador. El precio de la hora de la mano de obra incluyendo en el mismo la seguridad social (25% del total aproximadamente)

Como se ha dicho antes, se fabricar una primera versin de pruebas con varias unidades para comprobar que cumplen los requisitos mnimos de seguridad, normas de la comunidad econmica europea y por supuesto, las especificaciones del analizador.

Resumen:

Cantidad Componentes prototipo Componentes Versin definitiva Fabricacin Prototipo Fabricacin versin definitiva Mano de obra TOTAL 100 10 10 100

Precio unitario () 172 90

Precio Total () 1720 9000

55.3

553

17.6

176

11250 22700

118

Jaime Trinor Goira

Memoria. Estudio Econmico

En esta tabla mostrada, se recogen los datos calculados anteriormente y se quiere hallar el precio unitario final del Analizador JTG_05 que se debera poner de venta al pblico en el mercado.

Se ha tenido en cuenta que primero se fabrican 10 unidades del analizador prototipo (lo que hace un total de 419 de fabricacin ms 134 en las 10 placas) y despus se realizarn otras 100 de la versin del diseo final (419 ms 1340). Tambin para el gasto en componentes se ha tenido en cuenta que en la segunda compra nos hacen un buen descuento por volumen del pedido. En total se obtiene un precio de 227 como precio unitario que se tiene que desembolsar por cada analizador. Si queremos tener un beneficio de en torno al 20% del precio de venta y tenemos en cuenta el IVA (16%) del producto, obtenemos un precio aproximado de venta al pblico de 316 . Obviamente si las ventas son buenas, se podra aumentar la produccin y disminuir sustancialmente el precio unitario del producto.

Por otro lado, no se han tenido en cuenta los gastos en publicidad (que variarn en funcin de la demanda y de la estrategia de la compaa), ni los gastos de transporte ya que pueden ir a cargo del cliente (habr que negociar tambin). Tampoco los posibles intereses de los prstamos necesarios para el desarrollo de este analizador. Estos factores pueden hacer variar ligeramente el precio final del dispositivo.

119

Jaime Trinor Goira

Analizador Lgico basado en FPGA

Manual de Usuario
Programa Principal Primeramente es necesario ejecutar el programa Analizador.exe que viene incluido en el CD del proyecto, en ese instante aparecer un men con 3 opciones: 1.-Lectura de la RAM 2.-Escritura de la RAM 3.- Reconfiguracion de los datos

Para la primera opcin es necesario haber escrito previamente en la RAM, ya que de lo contrario no se habr recibido ningn dato (En el analizador final se indica con una luz si estn todos los datos enviados o no). Una vez haya datos en el buffer del puerto serie, se proceder a escribir dato a dato el valor cada una de las entradas de forma binaria en cada intervalo de tiempo en un fichero con el nombre Analizador.vec

En la segunda opcin (Escritura), existe otro men para indicar que modo de escritua se quiere: 1.- Modo Manual 2.- Flanco de Subida 3.- Flanco de Bajada 4.- Modo Patrn

Antes de pedir los datos correspondientes al modo de escritura seleccionado, se pedirn los datos generales a todos los modos si es que no se han introducido antes, y estos son: la frecuencia de muestreo y el nmero de entradas a muestrear.

En el modo manual se espera la pulsacin de una tecla para comenzar el muestreo, mientras que para el modo de flanco de subida o de bajada se espera que una seal determinada (indicada por el usuario) cumpla el flanco correspondiente y una vez sucede esto, se procede con el muestreo. En el modo patrn se espera que todas las entradas que se van a muestrear cumplan un valor determinado a la vez.

La ltima opcin de todas (Reconfiguracin de los datos ) es por si el usuario decide muestrear ms o menos entradas y/o decide muestrear a otra velocidad.
120 Jaime Trinor Goira

Memoria. Manual de Usuario

VHDL MAXPLUS II: Como se ha comentado, al leer los datos procedentes del analizador se realiza la escritura de dichos datos en un fichero: Analizador.vec .El contenido de este fichero puede observarse por distintos editores de texto, pero solamente se puede abrir y ver la evolucin de las seales de entrada declaradas en l mediante el programa MaxPlus II y para ello hay que hacer lo siguiente: 1.- Se selecciona en el men Max+Plus II -> Waveform Editor 2.- Seguidamente se va al men File -> Import Vector File y se busca el fichero creado por el software principal, que estar en la carpeta donde se halla ejecutado dicho programa y disminuyendo o aumentando con la lupa la escala de tiempos se observarn los cambios en las seales de entrada. El programa MaxPlus II se puede obtener gratuitamente desde la pgina Web de Altera (www.altera.com), conteniendo una versin para estudiantes (MaxPlus II 10.2) en la que una vez descargado el archivo .exe habr que registrar el nmero de serie del disco duro del ordenador donde se desee instalar (siempre en la unidad que contenga el Sistema Operativo), y una vez realizado esto, se enviar al correo seleccionado un email que contiene la licencia necesaria para poder ejecutar el programa en el PC; se copiar un cdigo recibido y se guardar como un archivo de texto .dat en una carpeta con el nombre de mp2student y de esta forma, una vez abierto el programa se selecciona options -> license setup y se busca el archivo creado anteriormente para poder hacer funcionar con normalidad el programa.

Por otro lado, la forma de programar la EPC2 y de configurar la FPGA se ha realizado a travs de un cable denominado ByteBlaster que conecta el puerto paralelo del ordenador con un puerto de 10 pines de la tarjeta. Pues bien, para poder realizar la carga de datos en ambos dispositivos es necesario instalar un pequeo driver en el ordenador (para Windows XP) de la siguiente forma:

1.- Abrir el Panel de Control. 2.- Cambiar a Vista Clsica si es necesario. 3.- Hacer doble click en Aadir Hardware y Siguiente para continuar. 4.- Seleccionar Si, ya he conectado el Hardware y darle a Siguiente. 5.- Seleccionar Agregar un nuevo dispositivo de Hardware y Siguiente.
121 Jaime Trinor Goira

Memoria. Manual de Usuario

Analizador Lgico basado en FPGA

6.- Seleccionar Instalar el Hardware seleccionndolo manualmente de una lista (avanzado) y pulsar el botn de Siguiente. 7.- Seleccionar Dispositivos de sonido, vdeo y juegos , y Siguiente 8.- Pinchar en Utilizar disco, y buscar el archivo win2000.inf en la carperta \drivers\win2000 donde est instalado el MaxPlus II. 9.- Darle a Continuar de todos modos y seleccionar Altera ByteBlaster. 10.- Pinchar en Siguiente para instalar el driver. 11.- Darle de nuevo a Continuar de todos modos, seguidamente a Terminar, y por ltimo resetear el PC

Una vez instalado el Hardware hay que indicarlo en el programa MaxPlus II abrindolo y escogiendo la seleccin Programmer desde el men del programa Max+Plus II. Seguidamente se procede a seleccionar Hardware Setup e indicar el tipo de programacin a realizar (en este caso es ByteBlaster) y el puerto por donde se enviarn los datos a la FPGA y la EPC2. Finalmente pinchar OK y ya se tiene puesto en marcha el Hardware de programacin. EAGLE LAYOUT EDITOR Este programa se ha utilizado para realizar el diseo tanto de la placa de prueba como de la placa final del analizador. Es un programa que se puede descargar una versin de prueba en www.cadsoft.de con limitacin a una placa 10x8 cm y 2 capas solamente, por lo que para el diseo de la primera placa de prueba fue suficiente. Sin embargo, para la segunda que es de 4 capas hay que poseer una licencia para su manejo completo.

En sus libreras no estaban todos los componentes necesarios para el diseo realizado por lo que se tuvo que hacer el smbolo, encapsulado y circuito con el mismo programa (la EPC2TC32 y las memorias RAM). Para futuros desarrollos con la misma herramienta y para poder utilizar los mismos componentes, se ha realizado una librera llamada Analizador.lbr que contiene todos los dispositivos necesarios para construir el analizador descrito en este proyecto (tambin incluida en el CD).

122

Jaime Trinor Goira

ANEXO A DATOS GENERALES DE LAS MEMORIAS RAM

Memoria. Anexos

Analizador Lgico basado en FPGA

124

Jaime Trinor Goira

Memoria. Anexos

125

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

126

Jaime Trinor Goira

Memoria. Anexos

127

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

ANEXO B DATOS GENERALES DE LA FPGA

128

Jaime Trinor Goira

Memoria. Anexos

129

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

130

Jaime Trinor Goira

Memoria. Anexos

131

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

ANEXO C DATOS DEL BUFFER DE PROTECCIN

132

Jaime Trinor Goira

Memoria. Anexos

ANEXO D DATOS GENERALES DEL CONFIGURADOR EPC2TC32

133

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

134

Jaime Trinor Goira

Memoria. Anexos

135

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

136

Jaime Trinor Goira

Memoria. Anexos

ANEXO E: DATOS DEL INVERSOR CON TRIGGER SCHMITT

137

Jaime Trinor Goira

Memoria. Anexos

Analizador Lgico basado en FPGA

ANEXO F: DATOS DEL INVERSOR SXTUPLE

138

Jaime Trinor Goira

Pliego de condiciones generales y econmicas

Condiciones generales
Las condiciones y clusulas que se establecen en este documento son de obligado cumplimiento por las partes contratantes. I Tanto el administrador como el cliente se comprometen desde la fecha de la firma del contrato a llevar a cabo lo que se estipule. II Ante cualquier reclamacin o discrepancia en lo concerniente al cumplimiento de lo pactado por cualquiera de las partes, una vez agotada toda va de entendimiento, se tramitar el asunto por la va de lo legal. El dictamen o sentencia que se dicte ser de obligado cumplimiento para las dos partes. III Al firmarse el contrato, el suministrador se compromete a facilitar toda la informacin necesaria para la instalacin y buen funcionamiento del sistema, siempre que sea requerido para ello. IV Asimismo, el cliente entregar al suministrador todas las caractersticas distintivas del equipo comprado y aquellas otras que considere oportunas para el necesario conocimiento de la misma a efectos del diseo del presente equipo. V El plazo de entrega ser de tres meses, a partir de la fecha de la firma del contrato, pudiendo ampliarse en un mes. Cualquier modificacin de los plazos deber contar con el acuerdo de las dos partes. VI En caso de retrasos imputables al suministrador, se considerar una indemnizacin del 1% del valor estipulado por semana de retraso. VII Existir un plazo de garanta de un ao a partir de la entrega del sistema. Dicha garanta quedar sin efecto si se demostrase que el sistema ha estado sometido a manipulacin o uso indebido.
139 Jaime Trinor Goira

Pliego de Condiciones

Analizador Lgico basado en FPGA

VIII Cumplido dicho plazo de garanta, el suministrador queda obligado a la reparacin del sistema durante un plazo de cinco aos, fuera del cual quedar a su propio criterio atender la peticin del cliente.

IX En ningn momento tendr el suministrador obligacin alguna frente a desperfectos o averas por uso indebido por personas no autorizadas por el suministrador.

Condiciones econmicas
I Los precios indicados en este proyecto son firmes y sin revisin por ningn concepto, siempre y cuando se acepten dentro del periodo de validez del presupuesto que se fija hasta Diciembre de 2005.

II El pago se realizar como sigue: 75% a la firma del contrato. 25% en el momento de entrega.

III La forma de pago ser al contado mediante cheque nominativo o mediante transferencia bancaria. En ningn caso se aceptarn letras de cambio.

IV El suministrador se har cargo de los gastos de embalaje y del transporte, dentro de la ciudad donde se encuentre la instalacin. En caso de ser necesario transporte interurbano, el gasto correr por cuenta del cliente. En todo caso, el responsable de los posibles desperfectos ocasionados por el transporte ser el suministrador.

V Durante el plazo de garanta, la totalidad de los gastos originados por las reparaciones corrern por cuenta del suministrador.

VI Fuera de dicho plazo y durante los siguientes cinco aos, los costes sern fijados mediante acuerdo por ambas partes. Pasados 5 aos, stos los fijar exclusivamente el suministrador.

140

Jaime Trinor Goira

Pliego de Condiciones

Pliego de condiciones tcnicas y particulares

Equipo informtico
El equipo informtico debe estar homologado conforme a la normativa Europea y Espaola a fecha de Junio de 2001. El equipo informtico debe instalarse conforme a las indicaciones del fabricante, manteniendo las condiciones de humedad y temperatura entre los lmites marcados. Los programas informticos empleados han de contar con la licencia preceptiva y cumplir con las condiciones de la misma. En caso de usar programas de licencia GPL, se debern respetar las condiciones de la misma.

Normas de calidad
Los sistemas se disearn de forma que cumplan las normas UNE, CEI y EN aplicables a este tipo de productos, as como las normas ETSI (European Telecommunications Standards Institute) para sistemas de radiofrecuencia.

Normas de Seguridad e Higiene

El proyecto cumplir con la Ley 31/95 de Prevencin de Riesgos Laborales.

Vida til del producto

Los sistemas se disearn para una vida til no inferior a 10 aos en funcionamiento continuo.

Otros criterios de diseo

Se emplearn componentes normalizados para los circuitos electrnicos.

141

Jaime Trinor Goira