Programacion en CUPL

Tema 5. Programación en CUPL 5.1.

Introducción................................................................................................................1

5.2.

Ficheros y extensiones importantes...........................................................................2

5.3. Notación.......................................................................................................................2 5.3.1. Nombres de variables ............................................................... ................................ 2 5.3.2. Números....................................................................................................................3 5.4.

Esquema de un programa en CUPL. CUPL. ........................................................................ 3

5.5.

Encabezamiento..........................................................................................................3

5.6. Declaración de pines...................................................................................................4 5.6.1. Comandos de preprocesado ............................................................... ....................... 4 5.7. Cuerpo principal del programa.................................................................................5 5.7.1. Ecuaciones combinacionales ........................................................................... .........5 ......... 5 5.7.2. Tablas de verdad.......................................................................................................6 5.7.3. Máquinas de estado...................................................................................................6 5.8. Ejemplos ................................................................ ...................................................... 7 5.8.1. Control de volumen. ..................................................................... ............................ 7 5.8.2. Control de barrera de aparcamiento........................................................................10

5.1.

Introducción

Con este tema se cubre lo relativo a la programación de dispositivos de baja capacidad, centrándonos en la PAL22V10 como dispositivo de referencia. Se usará el lenguaje CUPL, y en concreto el compilador gratuito suministrado por Atmel, llamado AWINCUPL. Este tema está basado en el Tutorial que sobre CUPL desarrollara en su día Brian Warneke, encontrado a través de Internet. Sirvan estas líneas como agradecimiento. El lenguaje CUPL es un compilador universal para sistemas lógicos programables, y será el utilizado para programar dispositivos lógicos de baja capacidad, principalmente pal’s. En concreto, en todos los ejemplos nos centraremos en la PAL22V10, que será sobre la que versarán las prácticas de la asignatura.

Titles you can't find anywhere else

Try Scribd FREE for 30 days to access over 125 million titles without ads or interruptions! Start Free Trial Cancel Anytime.





Tema 5. Programación en CUPL. 2

5.2.

Ficheros y extensiones importantes.

El lenguaje de programación CUPL se basa en ficheros con la extensión PLD, que contienen la definición del programa que se desea que ejecute el dispositivo programable. Cuando son abiertos, desde el el programa WinCUPL, como “proyecto”, se abrirán además los ficheros de simulación y compilación que tengan su mismo nombre. Si la compilación se produce con éxito, y si se ha seleccionado un dispositivo físico concreto (distinto de virtual), entonces se generarán una serie de ficheros, dependiendo de las opciones de compilación elegidas. De entre ellos, destacamos: *Fichero de mapa de fusibles: Con extensión .JED, incluye la información necesaria para que el programador de dispositivos lógicos pueda programar la PLD correspondiente. La información contenida, en ASCII, representa la matriz de fusibles con lo que resulta, de alguna manera, legible. *Fichero de documentación: Con extensión .DOC incluye, según las opciones que hayamos elegido, información de las ecuaciones expandidas y minimizadas, el número de términos producto usado para cada variable, el mapa de fusibles, e incluso el pin-out del dispositivo una vez programado. En caso de simular el circuito, se generarán los ficheros con extensión .SI, en el que se guardan los estímulos definidos, y el fichero .SO, en el que se almacena el resultado de la simulación.

5.3.

Notación

5.3.1. Nombres 5.3.1. Nombres de variables Para programar el funcionamiento requerido del sistema, tendremos que definir una serie de ecuaciones que manejarán las señales de entrada y salida. Para ello, tanto esas señales como las intermedias que quiera definir para simplificar la notación, deberán tener nombres válidos de variables. El lenguaje de programación tiene una serie de nombres reservados, que no pueden ser usados como nombres de variables, como son: APPEND

ASSEMBLY ASSY

COMPANY

CONDITION

DATE

DEFAULT

DESIGNER

DEVICE

ELSE

FIELD

FLD

FORMAT

FUNCTION

FUSE

GROUP

IF

JUMP

LOC

LOCATION

MACRO

MIN

NAME

NODE

OUT

PARTNO

PIN

PINNNODE

PRESENT

REV

REVISION

SEQUENCE SEQUEN SEQUENCED CED SEQUEN SEQUENCEJ CEJK K SEQUEN SEQUENCER CERS S

SEQUENCET TABLE

Igualmente, hay una serie de símbolos que no podrán formar parte de nombres de variables:






Teniendo esto en cuenta, cualquier otro nombre es válido. Como ejemplos de nombres válidos de variables podrían ser: ENTRADA_1. De esta manera defino nombres. Pueden contener números y subrayados, pero no guiones ni espacios. Ent0..3 definirá un conjunto de variables que se nombrarán correlativamente Ent0, Ent1, Ent2 y Ent3. Siempre tiene que empezar por 0. [Ent0,Ent1,Ent2, Ent3] esta es otra forma de definir lo mismo que antes, pero aquí sí que podríamos agrupar nombres o índices no correlativos: [sube, baja, para, reset]

5.3.2. Números 5.3.2. Números Cuando queramos asignar un valor a una variable, o establecer una comparación, podemos usar números expresados en binario, decimal, hexadecimal y octal. Se diferenciarán en un primer carácter, entre comillas simples: Número

Base

Valor decimal

'b'0

Binario

0

'b'1101

Binario

13

'o'663

Octal

435

'D' 92

decimal

92

'h' BA

hexadecimal

186

'b'[001..100]

binario

rango de 1 a 4

5.4.

Esquema de un programa en CUPL.

Un fichero .PLD, que contiene un programa en CUPL, tiene siempre la misma estructura, compuesto de un encabezamiento, en el que se da información acerca del diseño, un bloque de definición de variables, en el que se nombran los pines y se definen conjuntos de variables, y el bloque central de definición de funcionamiento.

5.5.

Encabezamiento

El encabezamiento sigue una estructura totalmente estandar. De todas las líneas del mismo, las dos únicas que tienen un efecto real sobre el diseño son la primera y la última. En la primera, name , se especifica el nombre del diseño, y será el nombre que se le dé al fichero de salida *.JED que se produzca. Debe ser un nombre válido de fichero, por tanto. En la última línea, Device, se introduce el nombre del dispositivo que se va a usar por de fecto. Esta asignación se puede, en teoría, sobreseer en el momento de la compilación indicando otro dispositivo. En la práctica, como el programa presenta un problema justamente en la elección de dispositivos, es necesario fijar en esta línea el dispositivo concreto que vamos a usar. En nuestro caso, utilizaremos casi siempre el dispositivo PAL22V10, que se especifica como:






Esto tiene la ventaja de que evitaremos quedarnos sin términos para sintetizar ecuaciones, y nos permite comprobar a posteriori en el archivo .DOC qué salidas requieren más términos productos, para asignar convenientemente los pines. Un ejemplo de cabecera sería como sigue: Name PartNo Date Revision Designer Company Assembly Location Device

5.6.

prueba3 ; 00 ; 30/10/2003 ; 01 ; Engineer ; Atmel ; None ; ; p22v10 ;

Declaración de pines

Tras la cabecera, se incluye la sección en la que se nombran los diferentes pines de E/S que se vayan a usar. Para ello, la sintaxis es: PIN = ; Se puede definir un nombre común para una serie de pines. Igualmente se puede indicar la polaridad de la señal, esto es si se activa a nivel alto o bajo. A todos los efectos, la señal se cambia de sentido lógico, y operaríamos con ella negada. Algunos ejemplos serían: Pin 1 = entrada1; Pin [2..4] = [Q0..Q2]; Pin 10 = !Reset; En esta sección también se definirán las variables de más de un bit que posteriormente se usarán en el código. Estas variables, llamadas FIELD, se usarán para definir tablas de verdad y máquinas de estado, entre otras cosas. Para definir un Field, simplemente tendré que darle un nombre y asignarle variables: FIELD estado = [Q0..Q2]; FIELD entradas = [entrada1, entrada2, entrada3]; FIELD salidas = [sube, baja, paro, marcha];

5.6.1. Comandos de preprocesado El compilador tiene una serie de comandos de preprocesado para ayudar a la confección de los programas. Así, puedo definir etiquetas, que me servirán para poder usarlas dentro del programa, de la misma manera que en lenguaje C estándar: $define DIR_BASE ‘h’2000 $define SI ‘b’1 Estas líneas no acaban en punto y coma. Otro tipo de comandos de preprocesado son los bucles REPEAT. Con estos bucles puedo escribir de forma cómoda una serie de líneas que






$repeat i = [0..7] $define point{i} 'b'{i} $repend

Esto sería lo mismo que poner:

$define $define $define $define $define $define $define $define

point0 point1 point2 point3 point4 point5 point6 point7

'b'000 'b'001 'b'010 'b'011 'b'100 'b'101 'b'110 'b'111

Dentro de los bucles REPEAT, se pueden usar operaciones aritméticas para definir valores. Por ejemplo, para definir un contador ascendente-descendente, ascendente-descendente, en cada estado tendré que ir al anterior o al siguiente, lo que puedo expresar muy cómodamente así: $repeat i=[1..14] Present 'D'{i} if SUBE next 'D'{i+1}; if BAJA next 'D'{i-1}; default next 'D'{i}; $repend

5.7.

Cuerpo principal del programa

En esta parte del fichero será en la que, propiamente, codificaré el funcionamiento que deseo de mi sistema. Aquí podré incluir tanto ecuaciones lógicas que definan sistemas combinacionales o secuenciales, como definiciones de máquinas de estados complejas.

5.7.1. Ecuaciones 5.7.1. Ecuaciones combinacionales Para definir un circuito combinacional, tan solo habrá que escribir las ecuaciones lógicas que lo forman. Ello se hará usando los operadores lógicos básicos, pudiendo usar paréntesis, o dividir una ecuación en varias partes, por medio del comando APPEND. Operador Ejemplo Función lógica

!

!A

NOT

&

A&B

AND

#

A#B

OR

$

A$B

XOR

Como ejemplo de ecuaciones lógicas, podemos ver las siguientes, que reproducen la codificación del nivel de llenado de un depósito(Z2-Z1) en función de los sensores (S2-S1-S0) que estén activos, así como la generación de una señal de error (Z3) en caso de combinación ilógica (por ejemplo, 110) Z1 =

s1 & s2;






sentencia APPEND, que me permite ir añadiendo sumandos a una determinada ecuación. Así, la segunda ecuación la puedo escribir como: APPEND Z2 = (!s0 & !s1 & s2); APPEND Z2 = (s0 & s1 & s2);

5.7.2. Tablas de verdad Otra forma más sencilla, a veces, de establecer ecuaciones lógicas es definir directamente la tabla de verdad que relaciona los valores lógicos a la entrada y a la salida del circuito combinacional que se quiere diseñar. Para ello, deberemos definir previamente, con la sentencia FIELD, los dos grupos de variables (entradas y salidas) en le orden en que va a ser definida la tabla. En el siguiente ejemplo, vemos cómo se definiría el circuito anteriormente descrito, pero utilizando tablas. Primero, con las dos sentencias FIELD defino las entradas (ins) y las salidas (outs), para posteriormente ir especificando los valores de las salidas en función de las entradas: FIELD ins=[s2, s1, s0]; FIELD outs=[Z3, Z2, Z1]; TABLE ins => outs { 'b'000 => 'b'000; 'b'001 => 'b'001; 'b'010 => 'b'100; 'b'011 => 'b'010; 'b'100 => 'b'100; 'b'101 => 'b'100; 'b'110 => 'b'100; 'b'111 => 'b'011;}

El compilador WinCUPL incluye además una herramienta para rellenar las tablas de manera semi-automática, generando todas las combinaciones de entrada, y permitiendo cambiar los valores con un simple click de raton.

5.7.3. Máquinas 5.7.3. Máquinas de estado Sin duda, una de las aplicaciones fundamentales de los dispositivos programables es la realización de máquinas de estado, bien sean máquinas explícitas (con sus entradas, estados y salidas) o implícitas (como puede ser un contador reversible). Para diseñar máquinas de estado, necesitaremos previamente definir las señales que formarán mi “estado”, los biestables que vaya a utilizar. Esto lo haremos con la sentencia FIELD, de manera similar a lo ya visto, asignando en este caso pines de salida que tengan registro asociado, obviamente. Resulta cómodo, aunque no es obligatorio, definir los nombres de los estados asignando a cada nombre un valor binario del estado, usando para ello la orden de preprocesado $DEFINE. Tras esto, definiremos la Tabla de transición de estados, simplemente escribiendo las distintas transiciones que pueden ocurrir desde un estado dado. Para ello, puedo definir previamente una serie de condiciones de transición, para simplificar la notación, que serán posteriormente simplificadas. También será frecuente el uso de transiciones por defecto, esto es, si no se cumple ninguna de las condiciones especificadas previamente. Veamos esto con un ejemplo: diseñamos una máquina de estado para el control de una barrera de un garaje. Tiene dos senso-








field estado=[Q1..0] ; /* Estado: bits Q1 y Q0*/ $define S0 'b'00 /* Defines para asignar nombre*/ $define S1 'b'01 /* a los estados. */ $define S2 'b'10 $define S3 'b'11

entrando=In1&(!In2)&Res_in; debajo=In1&In2&Res_in; saliendo=!In1&In2; nada=!(In1#In2)&Res_in; algo=(In1#In2);

/* Variables intermedias */ /* no son necesarias pero */ /* ayudan a definir las transiciones*/

sequenceD estado { /*Comienzo de una M.Est: SequenceD {*/ /* sintaxis de las transiciones: */ /* Present if next ;*/ present S0 if entrando next S1; default next S0; /* si no se da la condición: quédate*/ quédate*/ present S1 if nada next S0; if debajo next S2; if !Res_in next S0; if entrando next S1; present S2 if nada next S3; if algo next S2; if !Res_in next S0; present S3 next S0 ; /* Estado inestable: ve a S0 */ }

Up=!Q1&Q0; Down=!Q1&!Q0; Count=Q1&Q0;

/*Salidas de la M.Est. como combinacion del estado*/

Si quisiéramos definir una máquina de Mealy, deberíamos incluir en las diferentes transiciones (en todas las líneas if ), ), la especificación de la salida deseada, usando la orden OUT, seguida de las señales que se activarán en ese estado o transición: present S3

5.8.

next S0 OUT Count

Ejemplos

; /* Estado inestable: ve a S0 */






Revision 01 ; Designer MAPE ; Company GTE ; Assembly None ; Location ; Device p22v10 ; /************************************************************/ /* Sistema de control de volumen. Incluye: */ /* Maquina de estado para filtrar entrada Up */ /* Maquina de estado para filtrar entrada Dn */ /* Maquina de estado para convertir Mute en conmutador */ /* Contador reversible de 4 bits para guardar estado */ /* El Mute se realiza con la opcion .OE */ /************************************************************/ /* *************** INPUT PINS *********************/ PIN 1 = Clk ; /* Reloj*/ PIN 2 = Up ; /* Sube */ PIN 3 = Dn ; /* Baja */ PIN 4 = Mute ; /* Mute */ PIN 5 = Reset ; /* Reset act. a nivel bajo */ /* *************** OUTPUT PINS *********************/ PIN 14 = Q0 ; /* Contador de 4 bits. LSB */ PIN 15 = Q1 ; /* Contador de 4 bits. */ PIN 16 = Q2 ; /* Contador de 4 bits. */ PIN 17 = Q3 ; /* Contador de 4 bits. MSB */ PIN 18 = Q0U ; /* M.estados up */ PIN 19 = Q1U ; /* M.estados up */ PIN 20 = Q0D ; /* M.estados down */ PIN 21 = Q1D ; /* M.estados down */ PIN 22 = Q0M ; /* M.estados mute */ PIN 23 = Q1M ; /* M.estados mute */ FIELD FIELD FIELD FIELD

estup = [Q1U, Q0U]; estdn = [Q1D, Q0D]; estmt = [Q1M, Q0M]; Cont = [Q3, Q2, Q1, Q0];

sequence estup { /* maquina UP: cada vez que se activa */ Present 'b'00 /* la entrada, se da un solo pulso. */ if Up & Reset Next 'b'01; if !Reset Next 'b'00; default next 'b'00; Present 'b'01 if Up & Reset Next 'b'10;






if !Dn & Reset Next 'b'00; if !Reset Next 'b'00; default next 'b'10; }/* la salida es Q0D*/ sequence estmt { /* Maquina mute: cada vez que se activa*/ Present 'b'00 /* la entrada, cambia de estado: se apaga */ if Mute & Reset Next 'b'01; /* o se enciende */ if !Reset Next 'b'00; /* Codificado: 00, 01, 11, 10*/ default next 'b'00; /* con lo que la salida es Q1*/ Present 'b'01 if !Mute & Reset Next 'b'11; if !Reset Next 'b'00; default next 'b'01; Present 'b'11 if Mute & Reset Next 'b'10; if !Reset Next 'b'00; default next 'b'11; Present 'b'10 if !Mute & Reset Next 'b'00; if !Reset Next 'b'00; default next 'b'11; } Sequence Cont{

/* contador 4 bits reversible */

Present 'D'0 if Q0U & !Q0D & Reset next 'D'1; /* Q0U: salida maquina up (bit 0)*/ if Q0D & Reset next 'D'15; /* Q0D: salida maquina down (bit 0)*/ default next 'D'0; $repeat i=[1..14] Present 'D'{i} if Q0U & !Q0D & Reset next 'D'{i+1}; if Q0D & Reset next 'D'{i-1}; default next 'D'{i}; $repend Present 'D'15 if Q0U & !Q0D & Reset next 'D'0; if Q0D & Reset next 'D'14; default next 'D'0; } Q1.oe=!Q1M; /*activacion del MUTE*/ Q2.oe=!Q1M;






5.8.2. Control de barrera de aparcamiento Este ejemplo ha sido comentado previamente. Aquí se desarrolla íntegro el programa de control de la barrera, y se incluye finalmente unas gráficas de simulación: Name Partno Revision Date Designer Company Assembly Location Device Format

Prueba2 pru2-1 1 27/10/2003 mape GTE 1 aqui p22v10 c:

; ; ; ; ; ; ; ; ; ;

/******************************************************************/ /* Programa de las barreras, en PAL22V10 */ /******************************************************************/ /** Pin Pin Pin Pin

Inputs **/ 1 = clk ; 2 = In1 ; 3 = In2 ; 4 = Res_in;

/** Outputs **/ Pin 14 = Up; Pin 15 = Down;






saliendo=!In1&In2; nada=!(In1#In2)&Res_in; algo=(In1#In2);

sequenceD estado { present S0 if entrando next S1; if !entrando next S0; present S1 if nada next S0; if debajo next S2; if !Res_in next S0; if entrando next S1; present S2 if nada next S3; if algo next S2; if !Res_in next S0; present S3 next S0 ; } estado.oe = 'b'11;

Up=!Q1&Q0; Down=!Q1&!Q0; Count=Q1&Q0;

Programacion en CUPL

Recommend Documents