vhdl_proyectos

CAPITULO V: Ejemplos y aplicaciones prcticas.

En este capitulo demostrara la utilizacin del lenguaje Verilog en sntesis

lgica para la implementacin de circuitos prcticos a travs de una placa

de pruebas, el software de desarrollo ISE de XILINX. Se mostrara los pasos

necesarios para crear un proyecto, escribir el cdigo, herramientas de

sntesis, comprobacin y finalmente implementacin en circuito.

5.1

5.1.1

Descripcin del hardware utilizado.

Para el desarrollo de los ejemplos prcticos se utilizaron 2 placas

electrnicas, la primera, el KIT de desarrollo XC2-XL de la empresa

DIGILENT que posee dos

CPLDs y una placa creada para interfase y manejo de algunos perifricos

que se conecta directamente al kit de desarrollo XC2-XL.

Descripcin del KIT XC2-XL.

El KIT XC2-XL es un a placa de desarrollo para CPLDs que incluye 2 CPLDs,

XC2C256-TQ144 Y XC9572XL-VQ44 de la empresa XILINX

mayores fabricantes de CPLDs y FPGAs del mundo.

uno de los

Esta placa constituye una herramienta muy verstil para el desarrollo y

aprendizaje de CPLDs utilizando las herramientas de desarrollo,

programacin a travs de un puerto JTAG. Todos los puertos de los 2

CPLDs estn disponibles para su uso en conectores externos

Figura 5.1: Diagrama de bloques de XC2-XL

Entre las caractersticas mas destacadas de este sistema son las siguientes:

1 CPLD XC2C256-TQ144

111

1 CPLD XC9572XL-VQ44

1 puerto JTAG para programacin de los dos CPLDs.

1 oscilador en placa de 1.8432 MHz que puede ser cambiado.

Conectores externos disponibles para todos los pines de los 2 CPLDs.

1 pulsante nico conectado a 1 entrada de cada CPLD.

1 LED para cada uno de los CPLD

5.1.2

Mas detalles de la placa XC2-XL y sus esquemas se pueden encontrar en el

apndice C.

Placa de interfase.

La placa de interfase esta diseada para proveer de varios dispositivos de

interfase y circuitos lgicos adecuados para acoplar los diferentes niveles

de voltaje soportados por los CPLDs. Cave resaltar que los voltajes de

alimentacin del XC2C256 y el XC9572XL son diferentes y se tendr que

tener precaucin al momento de configurar las lneas de i/o de los CPLD.

Se ha provisto de circuitos lgicos 74LV541 y 74HC541 para poder convertir

los niveles de tensin y prestar cierto nivel de proteccin a las lneas de los

CPLDs.

La placa de Interfase cuenta con los siguientes dispositivos:

Teclado matricial de 3x4 teclas

3 pulsantes N.O.

3 interruptores N.O.

1 display de 4 dgitos a 7 segmentos multiplexado

8 LEDs de nodo comn

1 Driver de potencia ULN2803 con fuente variable

1 Interfase serial RS232 con su respectivo conector DB9F

Conectores individuales para perifricos, salidas de las lneas de los CPLDs y entradas y salidas de los circuitos 74xx541.

Leds Teclado

m atriz

D isplay

7 seg

4 digitos

Fuente

fija

R S232 Pulsantes y

sw itches

O .C .

D rivers

Fuente

variable

C onectores SIP

Figura 5.2: Esquema de bloques de la placa de pruebas.

112

C o n e cto

r He ad

er (kit X

C2- X

L )

7 4L

V y

7 4 H C

B l o qu

e

5.2 Breve Introduccin al programa de desarrollo Xilinx ISE.

El KIT de desarrollo XC2-XL incluye 2 CPLDs de XILINX, para poder utilizar estos chips se utiliza el sistema de desarrollo integrado de XILINX llamado ISE. La versin utilizada es la 8.1.

Este sistema permite varios mtodos de desarrollo de un sistema basado ya sea en FPGA o CPLDs, estos mtodos son: lenguajes descriptivos, mediante el uso del editor grafico o una combinacin de los 2.

ISE provee la facilidad de trabajar con lenguajes descriptivos tales como ABEL, VHDL y Verilog el cual ser objetos de nuestro estudio. Los mtodos grficos de diseo digital no sern abordados.

ISE es un poderoso sistema integrado de desarrollo, abarca todas las herramientas necesarias para realizar un diseo completo digital. Estas herramientas comprenden, un editor grafico, un editor de texto, programa de sntesis lgica, un simulador, editores de pines y restricciones, programa de programacin y algunas herramientas adicionales.

Xilinx ofrece una muy amplia variedad de documentos referentes a sus productos y aplicaciones, manuales tcnicos, notas de aplicacin y ejemplos todos ellos disponibles a travs de su direccin de Internet.

En este numeral describiremos los pasos bsicos para crear un diseo utilizando un dispositivo digital, generar un proyecto, correr el programa de sntesis, simulacin y por ultimo la programacin del dispositivo.

Antes comenzar con lo antes indicado, citaremos algunas recomendaciones las cuales seguiremos como guas para el diseo de un sistema digital utilizando un lenguaje HDL.

Cuando se va a disear un sistema digital necesitamos como primer paso antes de comenzar a escribir el cdigo ya sea en cualquier

lenguaje HDL es el de tener una idea clara de lo que queremos que

nuestro diseo haga. Es importante definir claramente un diagrama

de bloques, en el cual podamos incluir los mdulos que formaran

parte de nuestro circuito.

Ya sea que utilicemos diseo de arriba abajo o abajo arriba es necesario definir las lneas necesarias de entrada, salida, seales de

reloj etc.

Otra consideracin muy importante es el de tratar de describir mdulos pequeos e integrarlos en porciones de cdigo mas

complejas.

113

Al escribir mdulos tratar de que estos sean lo mas genricos posibles, esto se consigue con la utilizacin de parmetros en los

mdulos de esta forma si por ejemplo describimos un comparador de

8 bits parametrizando la longitud del comparador necesitaramos

nicamente cambiar el parmetro de 8 a 16 para conseguir un

comparador de 16 bits.

Es recomendable verificar el funcionamiento de los mdulos descritos, para esto se recomienda utilizar archivos de comprobacin

los cuales se pueden generar automticamente definiendo seales

lgicas o escribiendo el cdigo en el mismo lenguaje HDL.

El modulo TOP o el que contiene a los otros mdulos se recomienda mantenerlo lo ms pequeo como posible, es decir que contenga las

instancias de los mdulos y las entradas y salidas necesarias.

Por ultimo es bueno revisar despus del proceso de sntesis de los mdulos el esquema generados para verificar que lo que hemos

descrito en HDL sea lo que habamos pretendido. Para esto ISE

provee 2 opciones de visualizacin del esquema, el primero a nivel

RTL el cual es genrico de acuerdo a la sntesis lgica y el segundo

mas especifico de acuerdo a las tecnologas utilizadas de acuerdo a

los dispositivos y libreras que utiliza la herramienta de sntesis

lgica.

5.2.1 Crear un nuevo proyecto.

Se asume que el programa ISE se encuentra instalado y listo para ser

utilizado. Con este antecedente en el men de programas buscamos la

carpeta de xilinx ISE 8.x y buscamos Project Navigator este enlace abre el

sistema de desarrollo ISE.

La pantalla principal del ISE aparecer como se muestra en la figura 5.3.

Indicados con nmeros se encuentran:

(1). Barra de herramientas

(2). Ventana de archivos fuentes

(3). Ventana de procesos

(4). rea de trabajo, reportes, simulacin, etc.

(5). Ventana de actividades.

114

Figura 5.3: Ventana principal de ISE.

1. Vamos a File > New Project, aparecer la ventana de Project

Wizard- Create New Project. En este cuadro introduciremos el

nombre del proyecto que vamos a crear, la carpeta donde se alojara

el proyecto y en el men de tipo de fuente para Top

level,

elegiremos HDL.

2. El siguiente cuadro es el de las propiedades del dispositivo que

vamos a utilizar para el diseo, sea este un FPGA o un CPLD.

Escogemos de la lista la pieza adecuada, es recomendable revisar las

hojas tcnicas de la pieza para poder seleccionar correctamente los

parmetros de velocidad, empaquetaduras y categoras. Elegimos la

herramienta de sntesis a XST (VHDL/Verilog) al igual que el

simulador de acuerdo al que se tenga disponible. ISE Simulator

(VHDL/Verilog) viene de paquete con el programa ISE. Tambin es

posible obtener una versin compacta de ModelSim de Mentor

Graphics llamada ModelSimXE que tiene muy buenas caractersticas.

3. En la opcin para crear una nueva fuente seleccionamos nueva

fuente (new source), de inmediato aparece una ventana con varias

opciones, escogemos verilog Module y le asignamos un nombre. Al

pulsar el botn de siguiente aparece un cuadro para definir los

puertos de nuestro modulo, ah se deber escribir el nombre de las

lneas de entrada y salida, as mismo definir la longitud de los

vectores o si son escalares.

115

4. La siguiente ventana nos muestra un resumen de los parmetros

definidos para nuestro modulo, si algo esta incorrecto se puede

regresar para redefinir los parmetros.

5. A continuacin se nos presenta una vez mas la ventana de creacin

de nueva fuente, ah podremos ver el nombre de nuestro modulo

recin definido. Si se desea incluir mas mdulos se debe repetir el

proceso o tambin es factible aadir ms mdulos posteriormente.

6. Por ultimo tenemos una ventana final de resumen donde se

encuentran los mdulos y el detalle de parmetros para su revisin.

Al pulsar el botn de finish, aparecer en la ventana de trabajo en

cdigo Verilog la definicin del modulo recin creado con la

descripcin de ingresos y salidas. Desde este punto podemos

empezar a escribir el cdigo para nuestro sistema.

En la ventana de archivos fuentes se podr ver tambin el modulo recin

creado bajo el dispositivo que hemos escogido para el diseo.

Si se requiere adicionar un nuevo modulo al sistema basta con posicionarse

en la ventana de fuentes y con el botn derecho del ratn escogemos Add

New Source o si ya tenemos un modulo creado la opcin Add Source, y

seguimos los pasos ya antes vistos.

Una vez definido y descrito el cdigo de nuestro modulo debemos primero

verificar si tenemos errores de sintaxis, para ello usamos en la ventana de

procesos la opcin implement design, extendemos las opciones y buscamos

sinthesize > check syntax, mediante el uso del botn derecho del ratn

corremos el proceso con run o Rerun.

Es importante que en la ventana de archivos fuentes en la lista desplegable

que esta en la parte superior se escoja la opcion Sntesis - Implementation.

En la ventana de actividades en la pestaa console se podr ver los

distintos procesos cuando son ejecutados, as mismo en caso de errores o

mensajes de advertencia se pudran ver los detalles en las respectivas

pestaas.

Una vez corrido el proceso de verificacin de sintaxis, estamos listos para

ejecutar la herramienta sntesis, que es el proceso de transformar el cdigo

HDL en registros de transferencia de nivel o RTL, en este nivel el cdigo se

convierte en elementos regidos por ecuaciones lgicas. Para correr el

proceso de sntesis usamos botn derecho del ratn sobre Sinthesize- XST y

seleccionamos Run o Rerun. De la misma manera los mensajes del proceso

de sntesis y sus errores o advertencias pueden ser observados en la

ventana de Consola y las respectivas especficas.

116

Si el proceso de sntesis ha sido correcto se podr verificar el esquema

generado por nuestro cdigo usando las opciones view RTL schematic o

view Technology schematic. La primera opcin como ya se menciono nos

muestra el circuito de forma general como se ve a nivel de RTL en forma de

compuertas, registros etc. La otra opcin es mas especifica, muestra la

forma de cmo se implementara fsicamente de acuerdo a los recursos del

dispositivo que se utilice, a las libreras del sistema, etc. Este proceso es

una forma mas especifica del dispositivo a usarse.

Para simular nuestro sistema debemos contar con un archivo de pruebas,

para esto se puede crear de 2 formas. La primera mas sencilla y

recomendada para sistemas pequeos y personas menos diestras en el

lenguaje HDL es utilizar la herramienta para crear formas de onda provista

por ISE y la segunda crear un archivo de pruebas descrito en un lenguaje

HDL, esta opcin da la facilidad al diseador de realizar las pruebas que el

requiera y de la manera mas conveniente para el, pero se requiere de una

mayor destreza y un manejo mas avanzado del lenguaje. En este caso se

trabajara con la primera opcin.

Para esto, en la ventana de archivos fuentes, seleccionamos del men

desplegable behavioral simulation, sobre esta misma ventana mediante el

botn derecho adicionamos una nueva fuente, la ventana de tipo de fuente

aparecer y seleccionaremos Test Bench WaveForm, le asignaremos un

nombre. A continuacin se nos preguntara a que modulo se desea

relacionar estas formas de onda, seleccionaremos el modulo que deseamos

en caso de existir mas. Por ultimo aparecer una ventana de sumario con

los detalles.

Una vez aceptado aparecer una ventana de configuracin de la forma de

onda, parmetros para definicin de los periodos de reloj en caso de contar

con uno o tiempos de respuesta pueden ser definidos en esta ventan,

adems longitud de la prueba, entre otros parmetros. Una vez definido

esto esta ventana cerrara y en el rea de trabajo aparecer un grafico de

tiempos con las ondas definidas, al igual con las lneas de entrada y salidas

especificadas en nuestro modulo. Mediante el uso del ratn se puede

modificar niveles en entradas al modulo para acondicionar la prueba a

nuestros requerimientos. Una vez terminado este proceso cerraremos la

ventana de formas de onda y aceptaremos cuando se pregunte si

deseamos grabar los cambios.

Al cerrarse esta ventana notaremos que en la ventana de archivos fuentes

se creo el archivo que definimos para la prueba y debajo de este se

encuentra nuestro modulo el cual vamos a probar. En la ventana de

procesos veremos una opcin llamado Xilinx ISE Simulator con 2 procesos,

Generate expected simulation results, y simulate Behavioral model. Si

corremos el primer proceso en la ventana de trabajo aparecer la forma de

onda especificada por nosotros y veremos las salidas de nuestro modulo

como se comportan ante las entradas definidas. La segunda opcin se

117

utiliza para poder hacer un seguimiento paso a paso o continuo por las

definiciones en nuestro cdigo HDL, tambin se presentara un diagrama de

tiempos para su anlisis.

Despus de haber realizado las pruebas necesarias para nuestro modulo y

realizado las correcciones requeridas, el prximo paso seria implementar

nuestro diseo en el dispositivo que se eligi usar. Para esto debemos

definir las restricciones primero, para esto utilizamos la opcin User

Constraints y corremos el proceso Assign package pins este abrir un

programa llamado PACE en donde podemos asignar los pines a nuestras

entradas y salidas de nuestro modulo, tambin podremos definir los niveles

de voltaje y tipos como LVTTL, CMOS3.3, CMOS2.5 etc. Si requerimos tener

colectores abiertos en las salidas entre otras opciones. Las restricciones

abarcan una gran cantidad de propiedades que se pueden definir, mediante

PACE nicamente seleccionamos las restricciones de emplazamiento en el

chip. Restricciones de tiempos u otras ms avanzadas se las puede definir

utilizando el editor de restricciones o describiendo en un archivo de texto

las restricciones. Xilinx provee todo un manual completo sobre el uso y

propiedades de las restricciones para usarlas tanto en FPGAs y CPLDs. Para

nuestro propsito utilizaremos nicamente restricciones asignadas por

PACE.

Una vez definido nuestras restricciones, buscamos el proceso Implement

Design, que abarca algunos procesos ya utilizados antes y algunos nuevos

que nicamente se pueden correr si tenemos definidas nuestras

restricciones, tales como Fit y Translate. El primero se encarga de encajar

nuestro diseo en el dispositivo seleccionado utilizando las restricciones

definidas y los archivos generados por Translate.

Tambin se corre el proceso que genera los archivos de programacin para

ser implementados en el CPLD o FPGA a travs del programa IMPACT. y el

programa Impact y el respectivo cable de programacin JTAG.

Esta breve explicacin constituye una pequea introduccin al uso del

programa ISE y la implementacin de un diseo a travs de este programa.

La documentacin existente para cada proceso y algunos no citados aqu es

muy extensa. Es recomendable revisar esta informacin para obtener

mayores detalles y caractersticas operativas de ISE.

5.3 Ejemplos Prcticos.

En este numeral se vern algunos ejemplos prcticos a manera didctica de

tal forma que se pueda comprender mejor el proceso de diseo digital

utilizando lenguaje HDL Verilog y el programa de desarrollo ISE.

Los primeros ejemplos demostraran mdulos muy generales y tiles que

sern posteriormente utilizados en otros ejemplos mas complejos.

118

5.3.1 Diseo de un decodificador de BCD a 7 Segmentos multiplexado

para display de LED.

Descripcin:

Se requiere disear un decodificador - manejador para display de 7

segmentos con entrada de BCD y salida de 7 segmentos multiplexados para

cuatro digitos.

Requerimientos:

Ingreso formato BCD Salida 7 segmentos Activos a nivel lgico 0. Display nodo Comn.

Salida de 4 bits para manejo de transistores PNP comunes.

Diseo:

para nodos

Para lograr este diseo se ha dividido en partes al sistema, primeramente

se ha creado un modulo llamado BCD7SEG que se encarga de codificar la

entrada de BCD en cdigo 7 segmentos activo a nivel lgico 0. La tabla 5.1

muestra el contenido de la tabla creada para la decodificacin.

CODIGO BCD

0000

0001

0010

0011

0100

0101

0110

0111

1000

1001

1010

1011

1100

1101

1110

1111

CODIGO 7 SEGMENTOS

0000001

1001111

0010010

0000110

1001100

0100100

0100000

0001111

0000000

0001100

0001000

1100000

1110010

1000010

0110000

0111000

CARCTER

0

1

2

3

4

5

6

7

8

9

A

B

C

D

E

F

TABLA 5.1: Decodificador de BCD-7SEG para display

El modulo de BCD7SEG utiliza una salida a tres estados que se logra con la

seal de entrada de habilitacin "enable", cuando esta lnea se encuentra a

nivel lgico 0 las salidas del decodificador se activan caso contrario

permanecen en alta impedancia. El propsito de esto es de poder unir mas

mdulos de este tipo de acuerdo al numero de displays que tenga el

sistema y controlar mediante la activacin de "enable" cual de los mdulos

ser activo.

119

El modulo principal se lo ha denominado Display4BCD, este es nuestro

modulo Top. El el se han creado los siguientes componentes: un divisor de

frecuencia que divide la frecuencia del reloj de 1.8432 Mhz para 2048 es

decir baja a una frecuencia de 900Hz que se utilizara para el refresco de los

displays. Un registro de desplazamiento de 4 bits y un contador de 4

estados que se encargan de la activacin de los transistores y 4 instancias

del modulo BCD7SEG para manejo de cada uno de los dgitos.

Se ha definido un vector de 16 bits que lleva la informacin de los datos

BCD a cada uno de los displays, cada cuatro bits forman un dato, es decir

para el decodificador 1 la informacin esta comprendida por el vector [0:3],

para decodificador 2: [7:4], decodificador 3: [11:8] y para el decodificador

4 : [15:11].

Esquema de Bloques:

16

BCD[15:0] 7 7 7SEG

BCD[3:0]

BCD7SEG

En

CLK

Divisor

Cont

/

mux

7 BCD[7:4]

BCD7SEG

En

7 BCD[11:8]

BCD7SEG

En

7

BCD[15:12] BCD7SEG

En

D1

D2

D3

D4

Display4BCD

FIGURA 5.4: Modulo Display4BCD

Implementacin del cdigo Verilog HDL:

////////////////////////////////////////////////////////////////////////////////////////////////////

//Modulo Display 4 digitos, toma una entrada de 4 digitos en BDC

//que ingresa por InBCD y la convierte en 7 segmentos para display

//de cuatro digitos multiplexados el vector Data7Seg contiene la

//informacion decodificada, el vector OutEnables contiene las lineas

//de activacion para transistores en los displays. La frecuencia de

//refresco viene dada por CLOCK y el registro divisor. Reset entrada

//general de reset. Se crean 4 instancias de BCD a 7 Segmentos.

////////////////////////////////////////////////////////////////////////////////////////////////////

module Display4BCD(CLK, InBCD, OutEnables, Data7seg);

parameter VALOR_DIVISOR = 12'd2048;

input CLK;

120

input [15:0]InBCD;

output [3:0]OutEnables;

output [6:0]Data7seg;

reg [3:0]OutEnables = 4'b1110;

reg [11:0]Divisor = 12'b0;

reg [3:0]Auxiliar=4'b0001;

BCD7SEG Digito1(OutEnables[0], InBCD[3:0], Data7seg);




always@(posedge CLK)

if(Divisor == VALOR_DIVISOR-1)

begin

Divisor

4'b0001 : Out7Seg

Simulaciones y pruebas:

Para las simulaciones del sistema se defini un archivo tipo Test Bench

utilizando el asistente que proporciona el programa ISE. En este archivo se

defini el valor del reloj, y las entradas de comprobacin que en este caso

es el patrn en BCD 16'h1234.

FIGURA 5.7: Simulacin para mdulo Display4BCD

Los resultados de las simulaciones se los pueden observar en la figura 5.7.

Podemos ver que para cada valor de la habilitacin de las salidas o

activacin de nodos comunes tenemos un valor del cdigo en BCD

cumpliendo los requerimientos que tenamos.

Hay que resaltar que el valor del divisor se redujo de tal forma que se

facilite la simulacin del sistema. Esto se debe tener en cuenta el momento

de realizar las pruebas en circuito real y colocar el valor correcto ya que al

dejar el valor de pruebas el funcionamiento del display no ser

el

adecuado.

Implementacin Fsica:

Seal

(Salida7Seg_6) A B

C

D

E

F

G

(Salida7Seg_0)

Dir

O

O

O

O

O

O

O

Con A

33

34

35

36

37

38

39

Con B Con D CoolRunner II pin

10

9

7

6

5

4

3

123

OUT0

OUT1

OUT2

OUT3

CLK

O

O

O

O

I

19

20

21

22

-

21

22

23

24

TABLA 5.2: Distribucin de pines y conectores Proyecto Display4BCD

La implementacin fsica se la realizo de acuerdo a la tabla 5.2. El modulo

Display4BDC necesita una seal de 16 bits en formato BCD como ingreso al

modulo, lo que se hizo para efectos de prueba es definir internamente un

vector de 16 bits al cual se le dio el valor de prueba 16'h0235 y se lo

verifico en el kit de desarrollo y la placa de interfase, obtenindose los

resultados esperados.

5.3.2 Diseo de un decodificador de teclado de matriz de 3x4 teclas.

Descripcin.

Este diseo propone la implementacin de un decodificador para teclado de

matriz de 3x4 teclas.

Requerimientos.

Manejo de teclado matriz de 4 filas por 3 columnas. Eliminacin del rebote de las teclas pulsadas. Almacenamiento de 4 cdigos en 4 registros. Seal de indicacin de tecla pulsada.

Diseo.

Para la implementacin del manejador de teclado matriz se ha dispuesto

un modulo principal al cual se lo denomin KeyScan. Este modulo esta

conformado por varios sub-modulos los cuales iremos detallando a

continuacin.

MTXdecoder, que realiza la funcin de generar un pulso en cada fila para el

muestreo. Las lineas de las columnas del teclado son usadas como

ingresos, cuando una tecla es pulsada este bloque recibe la informacin de

la columna y verifica con la fila para establecer el valor de la tecla pulsada.

Una compuerta OR recoge cualquiera de las seales de las columnas y

activan la seal de Triegger del modulo monoestable que realiza la funcion

de antirebotes, al recibir una seal activa a uno dispara un pulso que a su

vez sirve como seal de entrada para un contador decodificador de 2 a 4 el

cual habilita los slip-flop tipo D que capturan el valor del codigo. El modulo

divisor divide la seal de reloj principal en 2 frecuencias F2 y F1 que es =

F2/2 F2 es mas lenta y se usa para generar la base de tiempo del

muestreo.

124

En la figura 5.6 podemos observar el diagrama de bloques del modulo

decodificador de teclado matriz.

Esquema de Bloques:

1

4

7

A

2

5

8

0

3

6

9

C

F1 F2 F3 F4

C1 C2 C3

MTXDecoder

F1

F2

F3

F4

Q0

Q1

Q2

Q3

Registro

C1

C2

C3

CLK

D0

D1

D2

D3

En

Q0

Q1

Q2

Q3

Q0

Q1

Q2

Q3

Contador - Decoder

Registro

O_1

O_2

O_3

O_4

D0

D1

D2

D3

Q0

Q1

Q2

Q3

Q4

Q5

Q6

Q7

CLK

En

Divisor

CLKO_2 Registro

CLK CLK

CLKO_1

D0

D1

D2

D3

En

Q0

Q1

Q2

Q3

Q8 Q9

Q10

Q11

Monoestable

CLK

Pulso

Trigger

Registro

D0

D1

D2

D3

En

Q 0

Q1

Q2

Q3

Q12

Q13

Q14

Q15

KEYSCAN RDY

FIGURA 5.6: Modulo KeyScan, manejador de teclado matriz.

Implementacin del cdigo Verilog HDL:

module KeyScan(CLK, FILAS, COLUMNAS, Q, PULSEOUT);

input CLK;

output PULSEOUT;

output [15:0]Q;

wire [3:0]Q1;

wire [3:0]Q2;

wire [3:0]Q3;

wire [3:0]Q4;

wire CLK2;

wire CLK1;

output [3:0]FILAS;

input [2:0] COLUMNAS;

wire [3:0] OUTCODE;

//Frecuencia / para h4000

//Frecuencia / para h2000

125

wire TRIGGER;

wire [3:0] EnFFD;

wire RDY;

wire Disable;

assign TRIGGER = |COLUMNAS;

assign Q[3:0] = Q1;

assign Q[7:4] = Q2;

assign Q[11:8] = Q3;

assign Q[15:12] = Q4;

PulseGen PULSE(CLK1, TRIGGER, PULSEOUT);

MTXDecoder MTX(CLK2, FILAS, COLUMNAS, OUTCODE);

Divisor DIV(CLK, CLK1, CLK2);

Habilitador SHIFT2(PULSEOUT, EnFFD);

FFD FF1(OUTCODE, EnFFD[0], Q1);




endmodule

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Modulo decodificador de teclado, utiliza un contador de 4 estados y un

// decodificador de 2 a 4 para generar el pulso de salida para las filas. En

// las columnas recibe la informacin si una tecla ha sido pulsada y la decodifica

//colocando el valor del codigo en OUTCODE

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

module MTXDecoder(CLK ,FILAS, COLUMNAS, OUTCODE);

input CLK;

output [3:0]FILAS;

input [2:0]COLUMNAS;

output reg [3:0]OUTCODE = 4'b0;

reg [1:0]Contador = 2'b0;

Selector2a4 LS139(Contador, FILAS);

always @(posedge CLK)

begin

if(Contador==2'd3)

Contador

always @(negedge CLK)

begin

case(Contador)

0: begin

case(COLUMNAS)

1: OUTCODE

2:

3:

endcase

endmodule

Salida

input CLK;

output reg CLKOUT1=1;

output reg CLKOUT2=1;

reg [17:0]Cont = 18'b0;

parameter VALORDIVISOR2 = 15'h4000;//16384;//1KHz fecuencia de muestreo

parameter VALORDIVISOR1 = VALORDIVISOR2/2;//15'h2;


begin

if(Cont == (VALORDIVISOR1-1))

begin

CLKOUT1

endmodule

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Modulo que sintetiza un FLIP-FLOP tipo D de cuatro canales.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

module FFD(D, Enable, Q);

input [3:0]D;

input Enable;

output reg [3:0]Q = 4'b0;

always @(Enable)

if(Enable)

Q

correcto funcionamiento de cada parte se realizo un archivo Test Bench del

modulo KeyScan. Para la simulacin se bajaron los tiempos del divisor de

4'h4000 a 4'h4. El estimulo en las columnas se lo realizo para el codigo "A"

y el codigo 0, los resultados podemos observarlos

cumpliendo con los requerimientos impuestos.

en la figura 5.10,

FIGURA 5.10: Simulacin modulo KeyScan, manejador de teclado matriz.


Seal

A (Salida7Seg_6)

B

C

D

E

F

G (Salida7Seg_0)

OUT0

OUT1

OUT2

OUT3

CLK

COLUMNAS0

COLUMNAS1

COLUMNAS2

FILAS0

FILAS1

FILAS2

FILAS3

PULSEOUT

Dir

O

O

O

O

O

O

O

O

O

O

O

I

I

I

I

O

O

O

O

O

Con A

33

34

35

36

37

38

39

19

20

21

22

-

Con B Con D

5

6

7

10

11

12

13

14

CoolRunner pin

10

9

7

6

5

4

3

21

22

23

24

142

140

139

136

135

134

133

132

TABLA 5.3: Distribucin de pines y conectores proyecto KeyScan

Para poder verificar el funcionamiento fsico del sistema se utiliz una

instancia del modulo Display4BCD conectado a la salida del modulo

KeyScan, los pines del CPLD y los respectivos conectores y seales se

131

muestran en la tabla 5.3, El resultado de la prueba fue acorde a lo

esperado.

5.3.3 Diseo de un contador sncrono visualizado, pulsante de

inicio/paro, reset, selector de arriba/abajo, selector de conteo

Lento/Rpido y carga por teclado.

Descripcin.

Se requiere disear un contador sncrono MOD1000 con entrada para un

pulsante de inicio/paro, entrada de reset y salida para visualizacin en un

display de 4 dgitos a 7 segmentos, tambin debe poseer una entrada de

selector de conteo arriba/abajo y capacidad de carga por teclado.

Requerimientos.

Selector de Inicio/Paro Selector de conteo Rpido/Lento Selector de conteo Arriba/Abajo Entrada de Reset. Numero MOD 10000 Posibilidad de carga por teclado Visualizacin en display de LED 7 segmentos.

Diseo.

Para lograr el diseo se ha dividido al circuito en 4 partes, modulo GenCLK,

que se encarga de dividir la frecuencia de acuerdo a la entrada R/L

(Rapido/Lento), modulo Display4BCD, que es el encargado de realizar el

manejo del display de 7 segmentos, modulo KeyScan que maneja el teclado

matricial de 3x4 y modulo contador que es el encargado de realizar el

conteo, este modulo trabaja en BCD directamente, realiza conteo

arriba/debajo de acuerdo a la seal Ar/Ab.

La salida del modulo contador va directamente al modulo Display4BCD para

la visualizacin. Este modulo tambin recibe la informacin del modulo

KeyScan que modifica directamente el valor de los contadores para realizar

la carga por teclado.

132

Esquema de Bloques:

DISPLAY 7 segmentos CLK 1

7

GenCLK R/L 1

Display4BCD

4

1

RST 1 16

Hab 1 Contador BCD

MOD 1000 CLK

4 Ar/Ab 1 16

KeyScan

1

4

7

A

2

5

8

3

6

9

0 C 3

Contador

FIGURA 5.11: Esquema en bloques Modulo Contador.

Implementacin:

En el codigo descrito a continuacin no se ha incluido el cdigo de los

mdulos Display4BCD y KeyScan ya que estos ya fueron descritos

anteriormente, solamente se encuentra las instancias de estos.

Cdigo Verilog.

//////////////////////////////////////////////////////////////////////////////

//Modulo principal del sistema, incluye el contador,

//el modulo de visualizacion, control de teclado matriz

// y generador de frecuencias de conteo que es un divisor

// de la frecuencia del reloj en 2 frecuencias para alimentar

// al contador

//////////////////////////////////////////////////////////////////////////////

module TOP(CLK, UpDn, ResetG, Enable, SlowFast, OutEnab, Salida7seg,

FILAS, COLUMNAS, PULSEOUT, Carga);

input CLK;

input ResetG;

input UpDn;

input Enable;

input SlowFast;

133

output [3:0] OutEnab;

output [6:0] Salida7seg;

wire [15:0] Salida;

wire InCONT;

wire ResetG;

wire OUTCLK;

output [3:0]FILAS;

input [2:0]COLUMNAS;

wire [15:0]Q;

output PULSEOUT;

wire PULSEOUT;

input Carga;

assign InCONT = OUTCLK;

Contador CONT(InCONT, UpDn, ResetG, Enable, Salida, Q, PULSEOUT);

Display4BCD Display(CLK, Salida, OutEnab, Salida7seg);

GenFrec GENCLOCK(CLK, SlowFast, OUTCLK);

KeyScan KEYPAD(CLK, FILAS, COLUMNAS, Q, PULSEOUT);

Endmodule

//////////////////////////////////////////////////////////////////////////////////////////

//Contador sincrono con entrada Habilitacion, reset,

//cuenta mientras la habilitacion este en estado 1 y hasta un

//maximo definido en el parametro MAX_CONTEO.

//Cuenta en BCD en vector Contador de 16 bits

/////////////////////////////////////////////////////////////////////////////////////////

module Contador(InCONT, UpDn, Reset, Enable, Contador, Q, Carga);

parameter MAX_CONTEO = 16'b1001_1001_1001_1001;

input InCONT;

input Reset;

input UpDn;

input Enable;

output [15:0] Contador;

reg [15:0] Contador;

input [15:0]Q;

input Carga;

initial

Contador[15:0]=16'b0000_0010_0011_0101;

134

always@(posedge InCONT or posedge Reset or posedge Carga)

begin

if(Reset)

Contador [15:0]

begin

if(Contador == 0)

Contador

parameter DIVISOR_SLOW = 20'd230400;

parameter DIVISOR_FAST = DIVISOR_SLOW / 4;

input CLK;

input SlowFast;

output reg OUTCLK;

reg [19:0]Divisor = 20'b0;


if(SlowFast)

begin

if(Divisor == DIVISOR_SLOW)

begin

OUTCLK

FIGURA 5.13a: Esquema esquemtico Modulo Contador generado por XST.

Simulaciones y pruebas:

En las figuras 5.14 a y 5.14b se muestran los diagramas de tiempos para el

contador. Ntese que el valor de Q posee el valor para la carga del

contador. El valor inicial del contador se lo a fijado en 16'd565 y al valor de

la carga en 16'd4660, equivalente a 16'h1234.

FIGURA 5.14a: Esquema esquemtico Modulo Contador generado por XST

FIGURA 5.14b: Esquema esquemtico Modulo Contador generado por XST

Este diagrama de tiempos solo refleja el comportamiento del contador

como tal, no estn considerados los diagramas para los mdulos de display,

138

teclado y divisor ya que estos ya se han probado en funcionamiento

anteriormente.


Seal

A (Salida7Seg_6)

B

C

D

E

F

G (Salida7Seg_0)

OUT0

OUT1

OUT2

OUT3

CLK

Carga

ResetG

UpDn

Enable

SlowFast

OutCLK

COLUMNAS0

COLUMNAS1

COLUMNAS2

FILAS0

FILAS1

FILAS2

FILAS3

PULSEOUT

Dir

O

O

O

O

O

O

O

O

O

O

O

I

I

I

I

I

I

O

I

I

I

O

O

O

O

O

Con A

33

34

35

36

37

38

39

19

20

21

22

-

6

7

8

11

10

40

Con B Con D

5

6

7

10

11

12

13

14

CoolRunner pin

10

9

7

6

5

4

3

21

22

23

24

41

39

40

35

34

2

142

140

139

136

135

134

133

132

TABLA 5.4: Distribucin de pines y conectores proyecto Contador

En la tabla 5.4 podemos observar en los pines utilizados para la

implementacin del contador, ntese que se ha implementado restricciones

en el posicionamiento de los pines, es decir se ha asignado para cada

modulo que hemos venido creando pines del CPLD y acorde a nuestros

nuevos requerimientos hemos adicionado diferentes entradas o salidas al

sistema.

En las pruebas fsicas implementadas en el kit de desarrollo XC2-XL y la

placa de interfase se pudo comprobar el correcto funcionamiento del

sistema implementado.

5.3.4 Diseo de un controlador para motor de pasos.

139

Descripcin.

En esta aplicacin se disear un controlador simple para un motor de

pasos de 4 fases unipolar. Este controlador realizara funciones simples

como generacin de las seales para las bobinas, movimiento adelante,

atrs y habilitacin y des-habilitacin de las salidas al modulo de potencia.

Todas estas funciones se realizaran en modo "FULL-STEP" o de paso

completo.

Para efectos de prueba del controlador de motor de pasos se creara un

modulo de pruebas el cual realizar las funcion siguiente:

Arranque adelante del motor en velocidad lenta, llegado a los h500 pulsos

el motor se acelera al doble de la velocidad de arranque hasta llegar a los

h999, momento en el cual cambia de direccin, llega nuevamente a los 500

pulsos y desacelera hasta llegar a 0 donde comienza nuevamente la

secuencia. Para visualizar el proceso se utilizara una instancia del modulo

Display4BCD y se creara un contador Up/Dn.

Requerimientos.

Manejo de Motor pasos unipolar de 4 fases. Generacin de secuencias para desplazamiento adelante y atrs en

paso completo.

Ingreso de una sola seal de reloj o pulsos. Seal de habilitacin de las salidas. Modulo de prueba para el motor Visualizacin del modulo de prueba en display 4 dgitos LED.

Diseo.

Los motores de pasos unipolares de 4 fases poseen 2 bobinados con

una

toma central que comnmente es alimentada con una tensin positiva.

B B

A

A

FIGURA 5.15: Motor De pasos Unipolar de 4 fases

140

La figura 5.15 muestra el diagrama de un motor de pasos unipololar de 4

fases.

Para el manejo de este tipo de motores utilizaremos un driver de potencia

ULN2803 el cual posee 8 salidas tipo colector abierto de 0.5A cada una a 40

VDC.

El esquema reducido de conexin para el driver y el motor se muestra en la

figura 5.16. Vm

Drv Motor Pasos

CLK A/R Hab.

A

A

B

B

FIGURA 5.16: Motor De pasos Unipolar de 4 fases

El modulo que se ha creado para manejar el motor de pasos se lo a

denominado MotorDriver , este modulo recibe la entrada de los pulsos a

travs de una seal denominada CLK, el modulo realiza la secuencia de que

alimentar a los drivers de cada fase, que para paso completo o Full-Step

se logra alimentando cada bobina contigua a la vez por un periodo de

tiempo que en este caso vendr dada por el tiempo en alto del pulso de

CLK. Si la seal de A/R esta en 1 la secuencia ser en sentido horario, y si

es 0 la secuencia ser en sentido anti-horario esto determinara el giro del

motor adelante o atrs.

Si la seal de Enable esta habilitada siempre existir una bobina del motor

alimentada manteniendo la posicin, si Enable va a 0 todas las bobinas del

motor sern deshabilitadas.

Esquema de Bloques.

141

DISPLAY 7 segmentos

1 CLK

7Seg

Display4BCD

Enb

InBCD

Divisor

CLK

7

4

SloFst CLK2

16

1

1

Contador

Pulsos

SloFst U/D

Contador Drv Motor Pasos

CLK

A/R Hab.

A

A

B

B

U/D 1

Comparadores M

ModuloTOP

FIGURA 5.17: Esquema de Bloques para modulo prueba de Motor Pasos

Implementacin:

//////////////////////////////////////////////////////////////////////////////////

// Modulo de Prueba para modulo control de motor de pasos

// genera 2 frecuencias a partir de la frecuencia del

// reloj del sistema, se escoge la frecuencia con la seal

// SloFast. Se utiliza modulos de display, contadores sincronos

// y el divisor de frecuencia, y el modulo de prueba MotorDriver

//////////////////////////////////////////////////////////////////////////////////

module ModuloTOP(CLK, OutEnab, Data7seg, OUTREG, Reset, CLK2);

input CLK, Reset;

output [3:0]OutEnab;

output [6:0]Data7seg;

output CLK2;

wire [15:0] Contador;

wire CLK;

wire CLK2;

reg SloFast=0;

reg Enable=1;

reg F_R=1 ;

output [3:0]OUTREG;

reg [15:0] ValorMAX =16'd16;

reg [15:0] ValorMED =16'd8;

reg Top=0;

142

r

Drive

Display4BCD DISP1(CLK, Contador, OutEnab, Data7seg);

DivisorFrec DIV1(CLK, SloFast, CLK2);

MotorDriver MOT1(CLK2, Enable, OUTREG, F_R);

ContadorSinc CONT1(CLK2, Enable, Reset, F_R, Contador);

always @*

if(Reset)

begin

SloFast


begin

if(SloFast)

begin

if(Divisor >= SLO_PARAM1-1)

begin

Divisor = SLO_PARAM2-1)

begin

Divisor

wire [3:0]OUTR;

reg [1:0] aux_cont = 2'b0;

Selector2a4 LS139(aux_cont, OUTR);

assign OUTREG[0] = (Enable)?(OUTR[2] & CLK):0;





if(F_R)

aux_cont

else

begin

if(Contador[3:0]== 9)

begin

Contador[3:0]

begin

Contador[11:8]


Seal

A (Salida7Seg_6)

B

C

D

E

F

G (Salida7Seg_0)

OUT0

OUT1

OUT2

OUT3

CLK

Reset

OUTREG0

OUTREG1

OUTREG2

OUTREG3

CLK2

Dir

O

O

O

O

O

O

O

O

O

O

O

I

I

O

O

O

O

O

Con A

33

34

35

36

37

38

39

19

20

21

22

-

7

Con B Con D

36

37

38

39

40

CoolRunner pin

10

9

7

6

5

4

3

21

22

23

24

39

105

104

103

102

101

TABLA 5.5: Distribucin de pines y conectores proyecto Motor Pasos

5.4 Aplicacin Global: Manejo de un panel de LEDs. 5.4.1 Introduccin.

En los numerales anteriores se revisaron algunos ejemplos prcticos de diseo digital de hardware. En este numeral se plantea el diseo de un controlador para un panel de LEDs. bsicamente, esta fu la razn que motiv el desarrollo del tema del diseo de hardware utilizando el lenguaje descriptivo Verilog como tema de esta tesis.

Paneles de mensaje variable y paneles grficos basados en diodos emisores de luz (LEDs), en la actualidad son muy populares. Uno de los mtodos mas comunes para manejo de tableros de mensajes variables o paneles grficos es el esquema de multiplexaje de matrices de leds dispuestos en paneles.

El multiplexaje puede tener algunas variantes, entre los mas utilizados estn multiplexaje a 2, 4, 8 y algunos ingenieros utilizan valores superiores.

El manejo de paneles multiplexados tiene algunas ventajas en contraste con los sistemas de manejo directo, entre algunas de estas ventajas podemos citar: reduccin del consumo de potencia, por lo tanto reduccin

148

del tamao de las fuentes de alimentacin, reduccin del numero de

manejadores o drivers para los LEDs, reduccin de los tamaos de los

circuitos Impresos etc.

As como presenta ventajas, estas no vienen gratis, un sistema

multiplexado compromete en algo el brillo del panel, adems demanda una

velocidad de procesamiento mucho mayor, especialmente en paneles

grandes en los cuales las ratas de refresco de la pantalla son elevadas.

Entonces, uno de los principales problemas, se convierte la velocidad de

procesamiento del sistema, el cual generalmente posee un procesador

central que se encarga de leer los datos de una memoria, procesar la

informacin y enviarla a los respectivos manejadores de cada panel. En

cada panel debe existir un manejador que pueda tomar la informacin y

realizar el multiplexaje de la informacin. En controles mas precisos estos

manejadores tambin controlan la iluminacin del panel y algunos casos

realizan controles de escalas de grises o controles RGB.

Los manejadores comerciales existen de muchos tipos, de interfase serial,

paralela, con control de intensidad de corriente, iluminacin etc. Pero cada

uno de ellos esta diseado para trabajar con un procesador o dispositivo

principal, que controle la operacin de estos y si se requiere multiplexaje el

uso de un procesador adicional es prcticamente obligatorio.

Es por eso que se plantea el diseo de un controlador autnomo para un

panel multiplexado. El diseo aqu expuesto sirve como gua para desarrollo

de futuros controladores mas complejos que puedan incluso realizar el

manejo de escalas de grises mediante el uso de modulacin del ancho de

pulso o PWM.

5.4.2 Descripcin.

Antes de explicar el diseo del controlador es necesario dejar algunos

conceptos en claro. Un tablero de LEDs esta formado por varios mdulos, y

estos mdulos a su vez por varios paneles. Cada panel es un arreglo de n x

m LEDs de acuerdo al criterio de cada diseador. De acuerdo al esquema

de manejo del panel puede un tablero poseer uno o varios procesadores.

El controlador del panel de LEDs multiplexado se ha diseado para

controlar un panel formado por una matriz de 6 x 8 LEDs, el diseo puede

ser acoplado para matrices mas grandes de acuerdo a las necesidades y

capacidades del hardware utilizado.

El concepto para el desarrollo de este manejador es el de eliminar el

procesador de cada panel encargado de realizar las funciones de

comunicacin y manejo de la matriz de leds, y reemplazar por

un

controlador que se interfase directamente al procesador principal de

149

manera paralela (o serial si se quisiera), en las que la tasa de transferencia

es muy elevada, realizar el multiplexaje de los leds manejando los circuitos

drivers para las fuentes y colocando los datos correspondientes a la

informacin enviada en los drenadores.

En la figura 5.19 se muestra un diagrama de bloques del manejador de

panel. El controlador se lo ha diseado con una interfase paralela de 8 bits.

Posee 2 seales de control WR y Stb que se utiliza para almacenar y

actualizar la informacin del panel.

El controlador del panel esta formado por las siguientes partes:

Interfase de comunicacin paralela de 8 bits Memoria (buffer In) de 8 bits x 6 para recepcin de la informacin

del panel desde el dispositivo master.

Memoria de actualizacin (buffer Out) de 8 bits x 6 de donde se toma la informacin para ser desplegada en el panel de acuerdo a

un contador de 6+ estados. Esta informacin maneja los drivers

para las columnas del panel.

Divisor de frecuencia de reloj que trabaja a 1Khz, que alimenta a un registro de desplazamiento que maneja los drivers para las filas del

panel y as realizar el muestreo.

5.4.2 Descripcin de los pines.

Datos (d0..d7)

Bus de datos por donde el controlador recibe la informacin del procesador

principal.

WR.

Seal de escritura sensible al flanco de subida, mediante un pulso positivo

la informacin presente en las lneas de d0..d7 se almacenan en la memoria

de ingreso BufferIn. El puntero de la memoria de ingreso se incrementa con

cada flanco de subida y se restablece a 0 al recibir un pulso extra en esta

lnea.

Stb.

Seal de actualizacin de la memoria, un pulso positivo en esta lnea causa

que la informacin que se encuentra en la memoria de ingreso Buffer in sea

copiada a la memoria de actualizacin BufferOut.

Es importante que toda la informacin correspondiente a todo el panel sea

cargada en la memoria de ingreso ya que de otra manera se podra

mostrar informacin errnea.

150

VLED

F1

F2

F3

F4

F5

F6

DRV FILAS

C7 C6 C5 C4 C3 C2 C1 C0

Manejador Columnas

Buffer Out (8 bits)

F1 F2 F3 F4 F5

F6

DatoOut 0 DatoOut 1 DatoOut 2

DatoOut 3

DatoOut 4

DatoOut 5

Divisor /

selector 0 1 2 3 4

5

Buffer In (8 bits)

DatoIn 0

DatoIn 1

DatoIn 2

DatoIn 3

DatoIn 4

DatoIn 5

Cristal

1.832Mhz Interfase Com.

Controlador de panel

FIGURA 5.19: Controlador de panel de LEDs

5.4.3

F1-F6

Lneas de salida, activas a nivel bajo, estas lneas se conectan a los drivers

de fuente que alimentan a los nodos de los LEDs.

C1-C8

Lneas de salida, activas a nivel lgico bajo, estas lneas se conectan a los

drivers drenadores. Los ctodos de los LEDs deben conectarse a los

drenadores.

Funcionamiento.

El controlador de panel debe ser controlado por el procesador principal

mediante 10 lneas, 8 de datos y 2 de control la operacin del controlador

151

s

a

Fil

r

d

o

ja

Ma

ne

as

V

mn

u

DR

Co

l

d7

d0

Stb

WR

se realiza de acuerdo a la tabla 5.6. Los estados indicados con una flecha

ascendente indican que la seal es sensible al flanco.

ESTADO

Inactivo

Escribir Dato

Actualizar Datos

Reset Dispositivo

WR

L

H

L

H

Stb

L

L

H

H

Notas

Realiza operacin de actualizacin de pantalla

Debe recibir 6 pulsos/dato + 1 de actualizacin

Actualiza Buffer Out con datos de Buffer In

Reinicia al dispositivo

TABLA 5.6: Operacin del controlador de panel de LEDs

En operacin normal el dispositivo debe ser colocado en estado inactivo, en

este estado el controlador realiza operaciones de actualizacin de la

pantalla, tomando la informacin de la memoria BufferOut y colocndola en

el puerto de salida del manejador de columnas. La informacin en el puerto

es invertida. Un contador de 6 estados se encarga de sincronizar los datos

de la memoria de salida hacia los drivers de columnas y el registro de

desplazamiento que maneja los drivers de filas.

D7 D0

Byte 0

Byte 1

Byte 2

Byte 3

Byte 4

Byte 5

FIGURA 5.20: Disposicin memoria de ingreso y salida con respecto a la matriz de LEDS

La actualizacin de los dato se realiza mediante el contador de 6 estados de

acuerdo a la tabla 5.7.

Contador Estados

0

1

2

3

4

5

Posicin Memoria

(Columnas)

~Byte 0

~Byte 1

~Byte 2

~Byte 3

~Byte 4

~Byte 5

Reg. Desplazamiento

F1 (111110)

F2 (111101)

F3 (111011)

F5 (110111)

F5 (101111)

F6 (011111)

TABLA 5.7: Operacin del controlador de panel de LEDs

En la figura 5.21 podemos ver el diagrama de tiempos para los ciclos de

escritura en la memoria de ingreso, actualizacin de la memoria de salida

con los datos escritos en la memoria de ingreso y los ciclos de actualizacin

o el barrido de la pantalla con los datos de la memoria BufferOut.

152

WR

D7-D0

Str

C. Est.

B.Out

F1

F2

F3

F4

F5

F6

X0 X1 X2 X3 X4 X5 X6

B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B B

0 1 2 3 4 5 0 1 2 3 4 5 0 1 2 3 4 5 0 1

2 3 4 5 0 1 2 3 4 5 0 1 2 3 4 5 0

B B X X X

1 2 3

4 5

X X X X X X

0 1 2

3 4 5

B

0

B B

1

2

FIGURA 5.21: Ciclos de escritura, actualizacin y barrido para controlador de panel

5.4.4 Implementacin del controlador.

Para implementar el controlador para manejo del panel de LEDs

multiplexado se utiliz el kit de desarrollo XC2-XL con el CPLD XC2C256-144

y la placa de interfase. Adicionalmente se implemento mediante el uso de

una baseta de pruebas un circuito de interfase de potencia para

interconexin con el panel de LEDs. A continuacin se muestra las

diferentes partes del diseo.

Codigo Verilog.

///////////////////////////////////////////////////////////////////////////////////////////////////

// Modulo Top controlador de panel de 6x8 para panel multiplexado

// de LEDs.

// ////////////////////////////////////////////////////////////////////////////////////////////////

module TopLedDrv(CLK, RESET, DataIn, WR, Stb, DataOut, OutSources);

input CLK, RESET;

input [7:0] DataIn;

input WR, Stb;

//PC

//PC

output [7:0] DataOut; //LED

output [5:0] OutSources;

wire [5:0] OutN;

assign OutSources = ~OutN;

//LED

153

Divisor DIV1(CLK, CLKOUT);

Refresco REF1(CLKOUT, RESET, DataIn, WR, Stb, DataOut, OutN);

endmodule

///////////////////////////////////////////////////////////////////////////////////////////////////

// Modulo Divisor

// Divide la frecuencia de entrada para obtener frecuencia de muestreo

// cristal utilizado 1.8432 Mhz.

// Frecuencia de muestreo 1KHz.

// ////////////////////////////////////////////////////////////////////////////////////////////////

module Divisor(CLK, CLKOUT);

input CLK;

output reg CLKOUT=0;

reg [17:0]Cont = 18'b0;

parameter VALORDIVISOR = 16'd1843; //1843


begin

if(Cont == (VALORDIVISOR-1))

begin

CLKOUT

output reg [MEMLONG-1:0]OutSources=6'b1000;

reg [ADDRZISE-1:0] AddrIn = 0;

reg [ADDRZISE-1:0] AddrOut = 0;

//2:0

reg [WORDSIZE-1:0] RegistroIn [0:MEMLONG-1];

reg [WORDSIZE-1:0] RegOut [0:MEMLONG-1];

initial

begin

RegOut[0]=1;

RegOut[1]=2;

RegOut[2]=3;

RegOut[3]=4;

RegOut[4]=5;

RegOut[5]=6;

RegistroIn[0]=0;

RegistroIn[1]=0;

RegistroIn[2]=0;

RegistroIn[3]=0;

RegistroIn[4]=0;

RegistroIn[5]=0;

OutSources=6'b1000;

AddrIn = 0;

end

//7:0

//7:0

/*********** Carga de Datos **************************/

always@(posedge WR)

if(Stb==0)

begin

if(AddrIn >= MEMLONG)

AddrIn

AddrOut = MEMLONG-1)

begin

AddrOut

Asignacin de pines

La lista siguiente muestra el detalle de las lneas utilizadas en el diseo, se

puede observar el nombre de la lnea, el estndar utilizado, el numero de

pin asignado y el numero de conector del puerto "D" del Kit de desarrollo

que se utiliz para la implementacin.

NET "CLK" LOC = "P38" | IOSTANDARD = LVTTL | SCHMITT_TRIGGER ; NET "DataIn" LOC = "P53" | IOSTANDARD = LVTTL ;#D32 NET "DataIn" LOC = "P52" | IOSTANDARD = LVTTL ;#D33 NET "DataIn" LOC = "P51" | IOSTANDARD = LVTTL ;#D34 NET "DataIn" LOC = "P50" | IOSTANDARD = LVTTL ;#D35 NET "DataIn" LOC = "P49" | IOSTANDARD = LVTTL ;#D36 NET "DataIn" LOC = "P48" | IOSTANDARD = LVTTL ;#D37 NET "DataIn" LOC = "P46" | IOSTANDARD = LVTTL ;#D38 NET "DataIn" LOC = "P45" | IOSTANDARD = LVTTL ;#D39 NET "DataOut" LOC = "P68" | IOSTANDARD = LVTTL ;#D22 NET "DataOut" LOC = "P66" | IOSTANDARD = LVTTL ;#D23 NET "DataOut" LOC = "P64" | IOSTANDARD = LVTTL ;#D24 NET "DataOut" LOC = "P61" | IOSTANDARD = LVTTL ;#D25 NET "DataOut" LOC = "P60" | IOSTANDARD = LVTTL ;#D26 NET "DataOut" LOC = "P59" | IOSTANDARD = LVTTL ;#D27 NET "DataOut" LOC = "P58" | IOSTANDARD = LVTTL ;#D28 NET "DataOut" LOC = "P57" | IOSTANDARD = LVTTL ;#D29 NET "OutSources" LOC = "P76" | IOSTANDARD = LVTTL ;#D16 NET "OutSources" LOC = "P75" | IOSTANDARD = LVTTL ;#D17 NET "OutSources" LOC = "P74" | IOSTANDARD = LVTTL ;#D18 NET "OutSources" LOC = "P71" | IOSTANDARD = LVTTL ;#D19 NET "OutSources" LOC = "P70" | IOSTANDARD = LVTTL ;#D20 NET "OutSources" LOC = "P69" | IOSTANDARD = LVTTL ;#D21 NET "Stb" LOC = "P56" | IOSTANDARD = LVTTL ;#D30 NET "WR" LOC = "P54" | IOSTANDARD = LVTTL ;#D31 NET "RESET" LOC = "P77" | IOSTANDARD = LVTTL ; #D15

Modulo de Interfase

Para realizar las pruebas fsicas del sistema se utiliz una baseta de pruebas

para implementar la parte de potencia del controlador. En la figura 5.22 se

muestra el esquema utilizado para el propsito. Se puede observar que

para el manejo de las filas del panel, donde se encuentran dispuestos los

nodos de los LEDs de la matriz, se utilizaron transistores PNP 2N3906, las

bases de estros transistores se manejan con las lneas F1..F6 a travs de un

driver 74HCT541. para el manejo de los ctodos de los LEDs del panel se

utiliz otro driver 74HCT541, el cual es activa los LEDs cuando va a un nivel

lgico bajo.

El panel utilizado para las pruebas es una matriz compuesto por 1 LED por

cada pxel, en el que se encuentra un conector tipo "header" de 6

posiciones para manejo de los nodos de la matriz y otro conector del

mismo tipo de 8 posiciones para el manejo de los ctodos de la matriz del

panel.

157

FIGURA 5.22: Esquema del circuito de driver para matriz de LEDs.

5.4.5 Pruebas de funcionamiento.

Como se mencion anteriormente, el controlador realiza las funciones de

barrido de la pantalla con los datos que se encuentran almacenados en la

memoria de actualizacin, esta operacin la realiza de forma automtica.

Para poder comprobar fsicamente el funcionamiento del controlador se

desarrollo un programa de prueba utilizando el lenguaje de programacin

Visual Basic y un puerto paralelo que se conecta a travs de la placa

de

interfase al controlador (CPLD).

Interfase Puerto paralelo.

Se utiliz el puerto paralelo con direccin 0x378 que posee 8 bits de salida

para los datos d0 .. d7 del controlador, en el puerto bi-direccional con

direccin de hardware 0x37A se utilizaron 2 lneas para el manejo de las

seales WR y Str. La conexin de las lneas se muestra en la figura 5.23.

158

GND

GND

GND

GND

Str

d7

d6

d5

d4

d3

d2

d1

d0

W R

FIGURA 5.23: Conector DB25 para puerto paralelo.

Software de prueba.

El software para la prueba se escribi utilizando Microsoft Visual Basic 6.

El propsito de este programa es el de probar la comunicacin con el

modulo de control para el panel.

En el software se generaron tablas de cdigo correspondientes a los

caracteres numricos del 0 a 9.

Con este criterio se puede generar cualquier tipo de carcter que se desee

desplegar en la pantalla. Para la prueba de comunicacin con el modulo es

suficiente desplegar caracteres numricos.

La pantalla de interfase se muestra en la figura 5.24. el programa de

prueba decodifica la informacin de un temporizador y enva de acuerdo a

la tabla 5.8 la informacin del numero a desplegar en la pantalla. La

velocidad de transmisin de los datos puede ser cambiada moviendo el

control de ajuste.

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

1

1

1

1

1

b1

1

1

b0

1

1

1

1

1

1

VALOR

7

5

5

5

5

7

b7 b6 b5 b4 b3 b2 b1

B0

B1

B2

B3

1

b0

1

1

1

1

VALOR

1

3

1

1

159

13

25

1

4

1

B4

B5

1

1

1

1

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

b1

1

1

1

1

1

1

b0

1

1

1

1 1

VALOR

7

1

7

4

4

7

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

b1

1

1

1 1

b0

1

1

1

1

1

1

VALOR

7

1

3

1

1

7

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

1

1

b1

1

b0

1

1

1

1

1

1

VALOR

5

5

7

1

1

1

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

1

1

b1

1

b0

1

1

1 1

1

1

1

1

VALOR

7

4

7

1

1

7

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

1

1

1

1

1

b1

1

b0

1

1

1

1

1

1

1

VALOR

7

4

7

5

5

7

b7 b6 b5 b4 b3

B0

B1

b2

1

b1

1

b0

1

1

VALOR

7

1

160

B2

B3

B4

B5

1

1

1

1

1

2

2

2

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

1

1

1

1

1

b1

1

1

1

b0

1

1

1

1

1

1

VALOR

7

5

7

5

5

7

b7 b6 b5 b4 b3

B0

B1

B2

B3

B4

B5

b2

1

1

1

b1

1

1

1 1

b0

1

1

1

1

1

1

VALOR

7

5

7

1

1

7

TABLA 5.8: Tabla de codificacin para caracteres numricos.

En la figura 5.24 observamos la pantalla de interfase para el programa de

pruebas del controlador del panel de LEDs. La descripcin del programa en

lenguaje Visual Basic se describe a continuacin.

FIGURA 5.24: Pantalla de control para prueba de controlador de panel

CODIGO VISUAL BASIC

'...................................................................................................................

Public Declare Sub sleep Lib "kernel32" Alias "Sleep" (ByVal dwMilliseconds As Long)

Public Declare Function Inp Lib "inpout32.dll" _

Alias "Inp32" (ByVal PortAddress As Integer) As Integer

Public Declare Sub Out Lib "inpout32.dll" _

Alias "Out32" (ByVal PortAddress As Integer, ByVal Value As Integer)

Public Const WR = 1

Public Const STR = 2

Public Const RESET = 4

Public I As Integer

161

Public Comando As Byte

Public TABLA(10, 6) As Byte

Public Buffer(5) As Byte

Public Tiempo As Integer

'...................................................................................................................

Sub WRITE_PULSE()

Out Val("&H37A"), Val("&H02")


End Sub

'...................................................................................................................

Sub STROBE_PULSE()



End Sub

'...................................................................................................................

Private Sub Com_RESET_Click()

Comando = Inp(Val("&H37A"))

Out Val("&H37A"), (Comando + RESET)

Out Val("&H37A"), (0)

sleep (100)

Out Val("&H37A"), (Comando And (Not (RESET)))

End Sub

'...................................................................................................................

Private Sub EnviaData()

Dim I As Integer

For I = 0 To 5

Out Val("&H378"), Buffer(I)

WRITE_PULSE

Next I

WRITE_PULSE

STROBE_PULSE

End Sub

'...................................................................................................................

Private Sub Cmd_Inicio_Click()

Timer1.Enabled = True

End Sub

'...................................................................................................................

Private Sub Command2_Click()

Dim Valor, I As Integer

Dim ByteL, ByteH As Byte

Dim LOW(5) As Byte, HIGH(5) As Byte

Valor = Val(Text_DATO)

162

ByteH = Valor \ 10

ByteL = Valor - (ByteH * 10)

For I = 0 To 5

LOW(I) = TABLA(ByteL, I)

HIGH(I) = TABLA(ByteH, I)

Buffer(I) = HIGH(I) * 16 Or LOW(I)

Next I

EnviaData

End Sub

'...................................................................................................................

Private Sub Command1_Click()

Timer1.Enabled = False

End Sub

'...................................................................................................................

Private Sub Form_Load()


Comando = 0

TABLA(0, 0) = 7

TABLA(0, 1) = 5

TABLA(0, 2) = 5

TABLA(0, 3) = 5

TABLA(0, 4) = 5

TABLA(0, 5) = 7

TABLA(0, 0) = 7

TABLA(1, 0) = 1

TABLA(1, 1) = 3

TABLA(1, 2) = 1

TABLA(1, 3) = 1

TABLA(1, 4) = 1

TABLA(1, 5) = 1

TABLA(2, 0) = 7

TABLA(2, 1) = 1

TABLA(2, 2) = 7

TABLA(2, 3) = 4

TABLA(2, 4) = 4

TABLA(2, 5) = 7

TABLA(3, 0) = 7

TABLA(3, 1) = 1

TABLA(3, 2) = 7

TABLA(3, 3) = 1

TABLA(3, 4) = 1

TABLA(3, 5) = 7

TABLA(4, 0) = 5

TABLA(4, 1) = 5

TABLA(4, 2) = 7

TABLA(4, 3) = 1

TABLA(4, 4) = 1

TABLA(4, 5) = 1

TABLA(5, 0) = 7

163

TABLA(5, 1) = 4

TABLA(5, 2) = 7

TABLA(5, 3) = 1

TABLA(5, 4) = 1

TABLA(5, 5) = 7

TABLA(6, 0) = 7

TABLA(6, 1) = 4

TABLA(6, 2) = 7

TABLA(6, 3) = 5

TABLA(6, 4) = 5

TABLA(6, 5) = 7

TABLA(7, 0) = 7

TABLA(7, 1) = 1

TABLA(7, 2) = 1

TABLA(7, 3) = 2

TABLA(7, 4) = 2

TABLA(7, 5) = 2

TABLA(8, 0) = 7

TABLA(8, 1) = 5

TABLA(8, 2) = 7

TABLA(8, 3) = 5

TABLA(8, 4) = 5

TABLA(8, 5) = 7

TABLA(9, 0) = 7

TABLA(9, 1) = 5

TABLA(9, 2) = 7

TABLA(9, 3) = 1

TABLA(9, 4) = 1

TABLA(9, 5) = 7

Slider.Value = 10

Timer1.Interval = Val(Slider.Value) * 50

End Sub

'...................................................................................................................

Private Sub Slider_Change()

If Slider.Value = 0 Then

Timer1.Interval = 1

Else

Timer1.Interval = Val(Slider.Value) * 50

End If

End Sub

'...................................................................................................................

Private Sub Timer1_Timer()

If Tiempo >= 99 Then

Tiempo = 0

Else

Tiempo = Tiempo + 1

Text_DATO.Text = Tiempo

Command2_Click

End If

164

End Sub

'...................................................................................................................

Conclusiones y Recomendaciones.

Despus de el estudio realizado el cual a incluido una extensa explicacin

terica fundamental para el correcto entendimiento de los conceptos que

involucra un diseo digital utilizando lenguaje descriptivo, algunos ejemplos

prcticos en los que se ha tratado de detallar el proceso de diseo,

verificacin y pruebas, vemos que el uso de los lenguajes descriptivos

puede constituir una herramienta muy poderosa para los ingenieros en el

desarrollo de hardware.

Con la introduccin de dispositivos digitales como son CPLDs y

especialmente FPGAs el uso de un lenguaje descriptivo es una necesidad, la

densidad con respecto a elementos lgicos es tan alta que para poder

utilizar estos dispositivos los mtodos tradicionales esquemticos son casi

imposibles de utilizar. En este documento se han descrito ejemplos

relativamente sencillos, pero las aplicaciones actuales de estos elementos

estn enfocados a sistemas digitales de alta complejidad.

Una verdadera industria se ha creado en torno al uso de estos ASICs que

muchas empresas han dedicado sus esfuerzos al desarrollo de lo que en

este mundo digital se conoce con el nombre de "IP" o propiedades

intelectuales, que no son mas que porciones de cdigo debidamente

probados y verificados para diferentes aplicaciones, ejemplo de estos son

puertos seriales, i2c, SPI, controladores de ethernet, USB, PCI, filtros

digitales, DSPs, procesadores, microcontroladores etc. Cientos de

aplicaciones se encuentran disponibles tambin de forma gratuita, as que

antes de comenzar a desarrollar un modulo o circuito, es posible que ya se

encuentre listo nicamente para ser integrado a nuestro diseo. Estas

ventajas se logran al utilizar los lenguajes descriptivos de Hardware ya que

estos son independientes de la tecnologa o dispositivo que se utilice.

Es muy importante tener en cuenta que cuando se trabaja con un lenguaje

descriptivo de Hardware no estamos "programando" software en un

procesador, lo que hacemos es describir hardware el que luego ser

plasmado en un circuito ASIC sea cual fuere, as que los conceptos bsicos

digitales debemos manejarlos muy bien de tal forma de obtener mediante

el cdigo lo que realmente queremos.

En el desarrollo de esta tesis se utiliz un CPLD para las pruebas, estos

dispositivos no son mas que arreglos compuertas similares a los PLDs

comunes tales como 22V10. En estos dispositivos el uso de memorias

requiere una cantidad significativa de registros los cuales consumen gran

cantidad de los recursos disponibles para solo lograr pequeas porciones de

165

memoria. Los FPGAs en contraste son dispositivos basados en PLAs

(Arreglos Lgicos Programables) los cuales poseen bloques especficos de

memoria con capacidades ya significativas que pueden solucionar estas

necesidades. Adems bloques de circuitos diferenciales especialmente

diseados para comunicacin entre dispositivos, ejemplo de esto sistemas

tenemos los buses SATA o interfases PCI Express que alcanzan velocidades

en el orden de los Ghz.

En conclusin, el xito en el desarrollo de un diseo digital esta basado

primeramente en el uso del dispositivo correcto para la aplicacin y en un

buen diseo del hardware a travs de un lenguaje descriptivo, verificacin

de funcionamiento y el uso de simuladores que nos ayudan a recortar los

tiempos de desarrollo y pruebas.

Despus de un extenso estudio el cual solo constituye una introduccin a

este amplio campo del diseo digital, se puede decir que es muy

importante tener bases fuertes en electrnica digital, circuitos lgicos tales

como registros, flip-flops, registros de desplazamiento y muchos otros

elementos lgicos, ya que al escribir un cdigo en HDL debemos pensar en

el dispositivo que se requiere utilizar y que el cdigo escrito sintetice el

elemento o modulo correcto.

166

APENDICE A. Definiciones Formales del

Lenguaje

Los anexos a continuacin especificados son tomados del Estndar Internacional Documento IEEE1364, IEC61691-4 primera edicin del 2004,

parte 4, "Behavioral Lenguajes, Verilog Hardware Description Lenguajes".

Formal syntax definition

A.1 Source text

A.1.1 Library source text library_text ::= { library_descriptions } library_descriptions ::= library_declaration | include_statement | config_declaration library_declaration ::= library library_identifier file_path_spec [ { , file_path_spec } ] [ -incdir file_path_spec [ { , file_path_spec } ] ; file_path_spec ::= file_path include_statement ::= include ; A.1.2 Configuration source text config_declaration ::= config config_identifier ; design_statement {config_rule_statement} endconfig design_statement ::= design { [library_identifier.]cell_identifier } ; config_rule_statement ::= default_clause liblist_clause | inst_clause liblist_clause | inst_clause use_clause | cell_clause liblist_clause | cell_clause use_clause default_clause ::= default inst_clause ::= instance inst_name inst_name ::= topmodule_identifier{.instance_identifier} cell_clause ::= cell [ library_identifier.]cell_identifier liblist_clause ::= liblist [{library_identifier}] use_clause ::= use [library_identifier.]cell_identifier[:config]

A.1.3 Module and primitive source text

source_text ::= { description }

description ::=

module_declaration

| udp_declaration

module_declaration ::=

{ attribute_instance } module_keyword module_identifier [ module_parameter_port_list ]

[ list_of_ports ] ; { module_item }

endmodule

| { attribute_instance } module_keyword module_identifier [ module_parameter_port_list ]

Ap.1

[ list_of_port_declarations ] ; { non_port_module_item }

endmodule

module_keyword ::= module | macromodule

A.1.4 Module parameters and ports

module_parameter_port_list ::= # ( parameter_declaration { , parameter_declaration } )

list_of_ports ::= ( port { , port } )

list_of_port_declarations ::=

( port_declaration { , port_declaration } )

| ( )

port ::=

[ port_expression ]

| . port_identifier ( [ port_expression ] )

port_expression ::=

port_reference

| { port_reference { , port_reference } }

port_reference ::=

port_identifier

| port_identifier [ constant_expression ]

| port_identifier [ range_expression ]

port_declaration ::=

{attribute_instance} inout_declaration

| {attribute_instance} input_declaration

| {attribute_instance} output_declaration

A.1.5 Module items

module_item ::=

module_or_generate_item

| port_declaration ;

| { attribute_instance } generated_instantiation

| { attribute_instance } local_parameter_declaration

| { attribute_instance } parameter_declaration

| { attribute_instance } specify_block

| { attribute_instance } specparam_declaration

module_or_generate_item ::=

{ attribute_instance } module_or_generate_item_declaration

| { attribute_instance } parameter_override

| { attribute_instance } continuous_assign

| { attribute_instance } gate_instantiation

| { attribute_instance } udp_instantiation

| { attribute_instance } module_instantiation

| { attribute_instance } initial_construct

| { attribute_instance } always_construct

module_or_generate_item_declaration ::=

net_declaration

| reg_declaration

| integer_declaration

| real_declaration

| time_declaration

| realtime_declaration

| event_declaration

| genvar_declaration

| task_declaration

| function_declaration

non_port_module_item ::=

{ attribute_instance } generated_instantiation

| { attribute_instance } local_parameter_declaration

Ap.2

| { attribute_instance } module_or_generate_item

| { attribute_instance } parameter_declaration

| { attribute_instance } specify_block

| { attribute_instance } specparam_declaration

parameter_override ::= defparam list_of_param_assignments ;

A.2 Declarations

A.2.1 Declaration types

A.2.1.1 Module parameter declarations

local_parameter_declaration ::=

localparam [ signed ] [ range ] list_of_param_assignments ;

| localparam integer list_of_param_assignments ;

| localparam real list_of_param_assignments ;

| localparam realtime list_of_param_assignments ;

| localparam time list_of_param_assignments ;

parameter_declaration ::=

parameter [ signed ] [ range ] list_of_param_assignments ;

| parameter integer list_of_param_assignments ;

| parameter real list_of_param_assignments ;

| parameter realtime list_of_param_assignments ;

| parameter time list_of_param_assignments ;

specparam_declaration ::= specparam [ range ] list_of_specparam_assignments ;

A.2.1.2 Port declarations

inout_declaration ::= inout [ net_type ] [ signed ] [ range ]

list_of_port_identifiers

input_declaration ::= input [ net_type ] [ signed ] [ range ]


output_declaration ::=

output [ net_type ] [ signed ] [ range ]


| output [ reg ] [ signed ] [ range ]


| output reg [ signed ] [ range ]

list_of_variable_port_identifiers

| output [ output_variable_type ]


| output output_variable_type

list_of_variable_port_identifiers

A.2.1.3 Type declarations

event_declaration ::= event list_of_event_identifiers ;

genvar_declaration ::= genvar list_of_genvar_identifiers ;

integer_declaration ::= integer list_of_variable_identifiers ;

net_declaration ::=

net_type [ signed ]

[ delay3 ] list_of_net_identifiers ;

| net_type [ drive_strength ] [ signed ]

[ delay3 ] list_of_net_de

Documents

vhdl_proyectos