Apostila WinCupl PDF

1 Introdução
Dispositivos programáveis são componentes que contem arrays de elementos lógicos

(AND,OR, INVERT, LATCH, FLIP-PLOP) que podem ser configurados para realizar uma
determinada função.
Existem várias classes de dispositivos programáveis: FPGAs, PLAs, PROMs, PALs, GALs,
PLDs...
O uso deste tipo de dispositivo apresenta as seguintes vantagens:

• Redução do número de componentes;
• Redução da área de placa, com a redução de custo correspondente
• Maior confiabilidade (consequência direta do menor número de conexões);
• Flexibilidade: modificações no circuito podem ser feitas através de programação,
sem alteração de placa;
• Menor ciclo de projeto.
2 Arquiteturas básicas
A seguir serão apresentadas as arquiteturas básicas de alguns dispositivos programáveis.
Serão tambem realizados exercícios referentes à implementação do circuito apresentado
no “Exercício 2-1 – Equações do circuito combinacional 1”.
Exercício 2-1 – Equações do circuito combinacional 1

Definir as equações do circuito combinacional a seguir:
A B C Y
0 0 0 0
0 0 1 0 A
0 1 0 1
B Y
0 1 1 0
1 0 0 1
C
1 0 1 0
1 1 0 0
1 1 1 1
solução: Y = A • B • C + A • B • C + A • B • C
Alberto do Canto PLD2008_10.doc 1 de 26

2.1 PROM
As memórias programáveis de apenas
leitura (PROM – Programable Read
Only Memory) são os dispositivos
programáveis mais conhecidos.
A Ilustração 2-1 PROM 8 X 1 ao lado
mostra um exemplo de um dispositivo
programável.
Ilustração 2-1 PROM 8 X 1
Observe a existência dos 8 fusíveis identificados como F0, F1..F7.

Considere a possibilidade de “queimar” qualquer um destes fusíveis, e
que esta queima represente deixar a entrada da porta “OU” com o valor
lógico 0 (zero).
Exercício 2-2 – Implementar com PROM

Que fusíveis devem ser queimados na PROM acima, para que seja implementada a lógica
especificada no Exercício 2-1
(Y = A • B • C + A • B • C + A • B • C ) ?

2.2 PAL
PAL (Programable Array Logic) é um
dispositivo programável cuja
arquitetura é exemplificada na
Ilustração 2-2 – PAL ao lado.
Observe a existência de 18 fusíveis

identificados como F0, F1, ... F17.
Considere a possibilidade de
“queimar” qualquer um destes
fusíveis, e que esta queima represente
deixar a entrada da porta AND com o
valor lógico 1 (um).
Ilustração 2-2 – PAL
Exercício 2-3 – Implementar com PAL

Que fusíveis devem ser queimados Ilustração 2-2 acima, para que seja implementada a lógica
especificada no Exercício 2-1
(Y = A• B • C + A• B • C + A• B • C ) ?
Exercício ?? ?? – Limitações de uma PAL

Dê um exemplo de circuito combinacional S=F(A,B,C) que não possa ser implementado como o
dispositivo apresentado na Ilustração 2-2 acima.

Entendendo a notação
A Ilustração 2-3 ao lado representa um
PLD com 4 entradas e duas saidas.
Observe que as portas AND são
representadas como uma linha
horizontal, à qual estão conectadas as
entradas através de “fusíveis”. Neste
exemplo, os “fusíveis” são numerados
de 0 a 47, conforme mostrado na figura
a seguir.
Ilustração 2-3 - PAL4L2 – Pal didático
Exercício 2-4 – Implementar com PAL

A B C D S1 S2 Implementar com o dispositivo mostrado na Ilustração
0 0 0 0 1 0 2-3 - PAL4L2 – Pal didático.
0 0 0 1 0 0 Esta implementação deve ser realizada através da
0 0 1 0 0 0
especificação de:
0 0 1 1 0 1
0 1 0 0 0 0
• extração das equações:
0 1 0 1 0 0 S1 = f(A,B,C,D)
0 1 1 0 1 0 S2 = f(A,B,C,D)
0 1 1 1 0 0 • mapeamento de entradas: mapear as entradas
1 0 0 0 0 0 lógicas (A,B,C,D) para as entradas físicas
1 0 0 1 0 0 (I1,I2,I3,I4)
1 0 1 0 0 0 • Mapeamento de saidas: mapear as saidas lógicas
1 0 1 1 0 1 (S1, S2) para as saidas físicas (O1, O2).
1 1 0 0 0 0
• Especificação dos número de fusíveis que devem
1 1 0 1 0 0
1 1 1 0 0 0 ser queimados.
1 1 1 1 0 0
2.3 Exemplos de arquitetura

Nas próximas páginas são apresentadas ilustrações das arquiteturas dos seguintes
dispositivos comerciais:
• PAL16L8
• PAL16R8
• GAL22V10
Exercício 2-5 – Implementar com PAL16L8

Implementar com o PAL16L8 (Ilustração 2-4, mostrada na página seguinte) um
circuito combinacional com 6 entradas (A, B, C, D, E, F) e uma saida SAIDA1, que
implemente a equação:
SAIDA = A + B + C + D + E + F
Especifique o mapeamento das entradas e saidas para os pinos do dispositivo e o
número dos fusíveis que devem ser queimados.

Ilustração 2-4 - PAL16L8

Ilustração 2-5 PAL16R8

Ilustração 2-6 - GAL22V10

Ilustração 2-7 - Macrocélula GAL22V10
Exercício 2-6 – Implementar com PAL16L8

Implementar com o PAL16L8 (Ilustração 2-4, mostrada na página seguinte) um
circuito combinacional com 6 entradas (A, B, C, D, E, F) e uma SAIDA, que
implemente a equação:
SAIDA = A + B + C + D + E + F + A.B + C.D.E

Especifique o mapeamento das entradas e saidas para os pinos do dispositivo e o
número dos fusíveis que devem ser queimados.
3 Implementando PLDs
A implementação de um projeto com o uso de PLDs é feita através dos seguintes passos:
1. Projetar a Lógica
2. Selecionar o componente
3. Descrever a Lógica
4. Gerar o arquivo de queima
5. Queimar o dispositivo
Neste capítulo será apresentado o software wincupl utilizado como ferramenta de apoio
para o desenvolvimento com PLDs. Este software faz uso da linguagem CUPL (Cornel
University Programming Langage) pode ser obtido gratuitamente no site
http://www.atmel.com/products/PLD/

3.1 Utilizando equações
Neste tutorial será implementado o circuito
“GATES”, apresentado na Ilustração 3-1
Circuito "GATES".
Nele serão demonstradas as seguintes
práticas:
• Seleção do PLD
• Mapeamento dos pinos
• Utilização do wincupl:
o Wizard para seleção de
componentes
o Mapeamento de pinos
o Descrição de lógica com uso
de equações
Ilustração 3-1 Circuito "GATES"
3.1.1 Seleção do PLD

O projeto do circuito GATES faz uso do
componente ATF22V10 cuja arquitetura é
apresentada na Ilustração 2-6 - GAL22V10.
A pinagem deste dispositivo é mostrada na
Ilustração 3-2 ao lado.
A seleção do componente passa pelo

conhecimento da arquitetura interna do mesmo.
Observe que o componente atende os requisitos
de:
• Número de entradas
• Número de saídas
• Arquitetura
Ilustração 3-2 - Pinagem do

ATF22V10

3.1.2 Mapeamento dos pinos
Nesta etapa é realizado um mapeamento
entre o circuito lógico e o componente, ao
nível de pinagem.
Com este mapeamento, será criado um

componente, cuja pinagem é:
Ilustração 3-3 - mapeamento dos pinos

3.1.3 Descrever o circuito
Nesta etapa o circuito será descrito no programa Wincupl.
1. iniciar o Wincupl
2. iniciar um novo arquivo de projeto
3. Digitar informações de cabeçalho.

As informações de cabeçalho tem fins de
documentação
4. especificar o número de pinos

de entrada
5. Especificar o número de pinos

de saida
6. Zero pinnodes

Terminada esta etapa, será exibido um código fonte de um programa escrito na
linguagem CUPL. Observe que os dados digitados no assistente de criação do projeto são
utilizados para construir um “esqueleto” a partir do qual se construirão as demais
informações:
Name GATES ;
PartNo 00 ;
Date 7/10/2005 ;
Revision 01 ;
Designer abcanto ;
Company ufrgs ;
Assembly None ;
Location DELET ;
Device virtual ;
/* *************** INPUT PINS *********************/

PIN = ; /* */
PIN = ; /* */
/* *************** OUTPUT PINS *********************/

PIN = ; /* */
PIN = ; /* */
PIN = ; /* */
PIN = ; /* */
PIN = ; /* */
PIN = ; /* */
PIN = ; /* */
PIN = ; /* */
Ilustração 3-4 - esqueleto criado pelo assistente
7. ir para o diálogo de seleção de dispositivos.
8. No diálogo de seleção de
dispositivo, selecionar o
dispositivo ATF22V10B. Neste
diálogo é possível identificar o
mnemônico que será utilizado
para especificar o dispositivo:
g22v10
9. Pressione o botão OK, para

retornar ao editor de textos
10.No editor de textos altere o De:

Device virtual ;
código fonte, substituindo o
nome do dispositivo: para:
Device g22v10 ;

11. Acrescentar o mapeamento dos
/* *************** INPUT PINS *********************/
pinos de entrada: PIN 2 = I_1 ; /* entrada I_1 */
PIN 3 = I_0 ; /* entrada I_0 */
12.acrescentar o mapeamento dos

/* *************** OUTPUT PINS *********************/
pinos de saida PIN 23 = O_INV_1 ; /* inversao entrada I_1 */
PIN 22 = O_INV_0 ; /* inversao entrada I_0 */
PIN 21 = O_AND ; /* AND das entradas */
PIN 19 = O_NAND ; /* NAND das entradas */
PIN 18 = O_OR ; /* OR das entradas */
PIN 17 = O_NOR ; /* NOR das entradas*/
PIN 16 = O_XOR ; /* OU EXCLUSIVO das entradas */
PIN 15 = O_XNOR; /* EQUIVALENCIA das entradas */
Observe:
• as informação de mapeamento dos pinos são extraídas da Ilustração
3-3, acima;
• os comentários possuem o formato
/* <comentário */
• nesta versão do wincupl não é permitida acentuação, mesmo nos
comentários;
13. Acrescentar as equações, que

/********** equacoes ************/
estabelecem as relações entra O_INV_1 = !I_1;
as entradas e saidas: O_INV_0 = !I_0;
O_AND = I_1 & I_0;
O_NAND = !(I_1 & I_0);
O_OR = I_1 # I_0;
O_NOR = !(I_1 # I_0);
O_XOR = I_1 $ I_0;
O_XNOR = !(I_1 $ I_0);
Observe: a tabela a seguir apresenta os operadores lógicos e sua precedência:
Operador Exemplo Descrição Precedência

! !A NOT 1
& A&B AND 2
# A#B OR 3
$ A$B XOR 4
14. No menu options..compiler, configurar o compilador:

15.Selecionar o menu Run..Device Dependent Compile F9 ou teclar F9, para
realizar a compilação
16.No diálogo Compilation Results,
certifique-se de que não
ocorreram erros:
17.Salvar o arquivo utilizando o menu File..Save.
4 Simulação
Após compilar sem erros, é possível simular o funcionamento do PLD.
1. Selecionar a
ferramenta de
simulação:
2. Criar um novo arquivo de

simulação:
3. Para especificar o projeto

que será simulado, no
diálogo Design
Properties, selecionar o
botão Design File...
4. Selecionar o arquivo
GATES.PLD criado na
etapa anterior e teclar
OK...
5. Selecionar o menu Signal..Add

Sinal, para especificar os sinais
simulados...

6. Aparecerá a caixa de diálogo Add
Signal, com o primeiro sinal I_0
selecionado na caixa de seleção
Signal List. Pressione o obtão OK,
para informar que este sinal deve
fazer parte da simulação.
7. Aparecerá novamente a caixa de

diálogo, permitindo selecionar o sinal
I_1. Pressionar OK, para selecioná-lo
para simulação.
8. Repetir o procedimento até que todos

os sinais de entrada e saida tenham
sido selecionados e a caixa de diálogo
Add Signal seja apresentada com a
caixa de seleção Signal List vazia.
Teclar o botão Done, para encerrar o
procedimento de adição de sinais
para simulação.
9. Aparecerá um quadro de simulação semelhante

ao mostrado na figura ao lado. Observe a
existência de um único vetor de testes, com as
entradas I_1 e I_0 indefinidas.
10. Selecionar o menu Signal..Add Vector

11. No diálogo Add Vector, especificar a adição de
mais 3 vetores de testes:
12. Com operações de arrastar e soltar, reordenar os nomes dos

sinais conforme mostrado na figura ao lado
13. Definir o valor 0 (zero) para:

• a entrada I_0;
• o vetor 1.
Observe:
• clicar no canto inferior esquerdo
para especificar o valor 0
• clicar no canto superior esquerdo
para especificar o valor 1
14. Repetir o procedimento para especificar os valores

de I_1 e I_0 nos quatro vetores de teste, conforme
mostrado na figura ao lado

15. Realizar a simulação, selecionando o menu
Simulator..Run Simulator
16. Verificar os resultados da simulação
5 Entendendo os Arquivos Gerados

O resultado do trabalho realizado neste tutorial é um conjunto de arquivos.
1. Retornar ao WinCupl
2. Abrir o arquivo Gates.doc
3. Localizar a secção Expanded Product Terms e observar:
O_AND => Equações AND

I_0 & I_1
Equação NAND iguais a equações AND. Isto é, o programa

O_NAND =>
I_0 & I_1 projetou a queima para um AND com inversão na macrocélula de
saída. Este mesmo tipo de abordagem é utilizado para
OR e NOR
XOR e EQU
O_NOR =>

O “OU EXCLUSIVO” é gerado considerando a identidade
O_XNOR =>
!I_0 & I_1 A ⊕ B = A.B + A.B
# I_0 & !I_1
O_AND.oe => “Output Enable” da saida O_AND: saida de 3 estados

1
habilitada.
4. Avançar até a secção “Fuse Plot” e observar

o “Mapa de Queima” correspondente ao
primeiro inversor (O_INV_0, pino 22):
Observe o mapa de queima e a Pin #22 05810 Mode --

00440 --------------------------------------------
arquitetura: 00484 ---------x----------------------------------
• A legenda: 00528 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
LEGEND X : fuse not blown 00572 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
- : fuse blown 00616 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
• A queima de todos os fusíveis da 00660 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
00704 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
linha 440, habilitando a saída; 00748 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
• A linha 484, apenas é mantido o 00792 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
00836 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
fusível correspondente ao pino 3, 00880 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
invertido
• Os fusíveis 5810 e 5811 são queimados, configurando a macrocélula de saída com
S1.S0 = 11 (saída combinacional não invertida)
• As linhas sem fusíveis queimados geram um produto (AND) igual a zero

5. Localizar a ===============================================================================
Chip Diagram
secção “Chip ===============================================================================
Diagram” e
______________
visualizar o | GATES |
desenho do x---|1 24|---x Vcc
componente I_1 x---|2 23|---x O_INV_1
I_0 x---|3 22|---x O_INV_0
projetado: x---|4 21|---x O_AND
x---|5 20|---x
x---|6 19|---x O_NAND
x---|7 18|---x O_OR
x---|8 17|---x O_NOR
x---|9 16|---x O_XOR
x---|10 15|---x O_XNOR
x---|11 14|---x
GND x---|12 13|---x
|______________|
6 Utilização de Tabelas Verdade

Neste capítulo será apresentada uma funcionalidade do software WinCupl, que permite o
uso de tabelas verdade para projeto de circuitos combinacionais.
Esta característica será demonstrada através do projeto de um binário – 7 segmentos.
6.1 Projeto Lógico

A figura ao lado apresenta um decodificador BCD – 7
segmentos, cuja tabela verdade mostrada a seguir
assume que as saídas em 0 acendem o led:
B3 B2 B1 B0 a b c d e f g
0 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 1 1 0 0 1 1 1 1
2 0 0 1 0 0 0 1 0 0 1 0
3 0 0 1 1 0 0 0 0 1 1 0
4 0 1 0 0 1 0 0 1 1 0 0
5 0 1 0 1 0 1 0 0 1 0 0
6 0 1 1 0 0 1 0 0 0 0 0
7 0 1 1 1 0 0 0 1 1 1 1
8 1 0 0 0 0 0 0 0 0 0 0
9 1 0 0 1 0 0 0 0 1 0 0

6.2 Mapeamento dos Pinos
Assumindo-se a utilização do ATF22V10B, será realizada
a atribuição de pinos conforme ilustração ao lado:
6.3 Descrever o circuito no WinCupl

1. Iniciar o WinCupl
2. Criar um novo projeto 7SEG-22V10
3. Completar o mapeamento dos
/* *************** INPUT PINS *********************/
pinos PIN 2 = b0;
PIN 3 = b1;
PIN 4 = b2;
PIN 5 = b3;
/* *************** OUTPUT PINS *********************/

PIN 23 = a ;
PIN 22 = b ;
PIN 21 = c ;
PIN 20 = d ;
PIN 19 = e ;
PIN 18 = f ;
PIN 17 = g ;
4. Acessar o menu Edit..Insert Table

5. Preencher o a caixa de diálogo
Create Table com os dados
mostrados na figura ao lado.
6. Após o preenchimento, clicar

sobre a região de visualização da
tabela. Aparecerá a tabela
verdade, conforme mostra a
figura ao lado.
7. clicar sobre as células da tabela
que devem ser alteradas,
adequando o seu preenchimento
conforme o projeto.
8. Ao final clicar sobre o botão OK.

9. Observe:
TABLE b3,b2,b1,b0 => a,b,c,d,e,f,g {
• o diálogo Create Table cria um texto 'b'0000 => 'b'0000001;
que descreve uma tabela verdade na 'b'0001 => 'b'1001111;
'b'0010 => 'b'0010010;
linguagem WinCupl 'b'0011 => 'b'0000110;
• a sintaxe utilizada para a descrição de 'b'0100 => 'b'1001100;
uma tabela 'b'0101 => 'b'0100100;
'b'0110 => 'b'0100000;
'b'0111 => 'b'0000000;
'b'1000 => 'b'0000000;
'b'1001 => 'b'0000100;}
10.Atualizar o dispositivo
Device g22v10 ;
11. Compilar e simular
7 Equações de próximo estado

Neste capítulo será apresentrado o projeto de um circuito sequencial simples, realizado
com o uso de equações de próximo estado.
7.1 Projeto Lógico

O projeto refere-se a um contador simples, cujo diagrama de
estados é mostrado na Ilustração 7-1ao lado.
A partir do diagrama de estados, é possível extrair a tabela a
seguir, da qual se definem as equações de próximo estados.
Q1 Q0 D1 D0
0 0 0 1
0 1 1 0
1 0 1 1
1 1 0 0 Ilustração 7-1 Diagrama
de estados
D1 = Q1 ⊕ Q0
D0 = Q0
7.2 Mapeamento dos pinos

A Ilustração 7-2 mostra definição de mapeamento de
pinos do ATF22V10
Ilustração 7-2 Mapeamento

dos pinos

7.3 Descrever o circuito
1. Iniciar o WinCupl
2. Criar um novo arquivo de projeto Nome: cont1
Device: g22v10
Pinos de Entrada: 1
Pinos de Saida: 2
Pin Nodes: 0
3. Completar o mapeamento dos /* *************** INPUT PINS *********************/

PIN 1 = clock;
pinos
/* *************** OUTPUT PINS *********************/
PIN 23 = Q1;
PIN 22 = Q0;
4. Especificar as equações de próximo estado

Q1.D = Q1 $ Q0;
Q0.D = !Q0;
5. Alternativamente ao uso de equações de próximo

TABLE Q1,Q0 => Q1.D, Q0.D {
estado, pode-se criar uma tabela de próximo 'b'00 => 'b'01;
estado 'b'01 => 'b'10;
'b'10 => 'b'11;
'b'11 => 'b'00;}
Observe a existência de extensões referentes

a macrocélula de saída:
Extensão Significado
.AP Asynchronous
preset of flip-flop
.SP Synchronous preset
of flip-flop
.D D nput of D-type
flip-flop
.CK Programmable clock
of flip-flop
.OE Programmable
output enable
6. Acrescente as equações referentes aos demais

Q1.AR = 'b' 0; Q0.AR = 'b' 0;
sinais da macrocélula Q1.SP = 'b' 0; Q0.SP = 'b' 0;
Q1.OE = 'b' 1; Q0.OE = 'b' 1;

7. Realize a simulação. Observe a
possibilidade de definir um sinal
como clock, para todos os vetores
(set whole signal.. C)
8 Diagramas de estado
A linguagem Cupl permite que se descreve um diagrama de estados para especificar uma
lógica sequencial.
8.1 Projeto Lógico

O uso de diagramas de estados será demontrado através
do projeto do contador BCD encadeável mostrado na
Ilustração 8-1 ao lado.
As características deste contador são as seguintes:

• Reset Assíncrono (entrada R)
• Operações síncronas definidas a partir das
entradas Ci e Ii, conforme a seguinte tabela:
Ilustração 8-1 - Contador BCD
A Tabela 8-1 ao lado mostra as operações do contador,

conforme especificado nos bits de comando Ci e Ii. Ci Ii Operação síncrona
Este contador é projetado para ser encadeado com outros 0 X Mantem contagem
idênticos, conforme apresentado na Ilustração 8-2 1 0 Decrementa
1 1 Incrementa
abaixo. Tabela 8-1 Operações do contador
Ci Ii contagem Co Io
b3 B2 B1 B0
0 0 qualquer 0 0
1 0 0 0 0 0 1 0
Diferente de 0000 0 0
1 1 1 0 0 1 1 1
Diferente de 1001 0 0
Tabela 8-2 comandos de saida
Ilustração 8-2 Encadeamento de contadores
A Tabela 8-2 acima mostra os bits de saída Co Io, utilizados no encadeamento de

contadores.

A Ilustração 8-3 ao lado
apresenta o diagrama de
estados, que descreve de
forma completa o
funcionamento do
contador.
Ilustração 8-3 Diagrama de estados
8.2 Implementação
A implementação do contador BCD será realizada considerando-se a utilização do PLD
ATF22V10B.
1. Especificar a pinagem desejada, conforme Ilustração 8-4 ao
lado
2. Iniciar o WinCupl e criar um projeto com as seguintes
características:
• Nome: BCD_Count
• Dispositivo: g22v10
• Número de Entradas: 4
• Número de Saídas: 6 Ilustração 8-4 Pinagem
3. Especificar os pinos de entrada

e de saída /* *************** INPUT PINS *********************/
PIN 1 = clock; /* clock */
Observe:
• a forma PIN 2 = R; /* Reset Assincrono */
PIN [21..18] = [Q3..0] ; PIN 3 = Ci; /* Contar */
PIN 4 = Ii; /* Incrementar (1) / Decrementar (0) */
• é equivalente a
PIN 21= Q3; /* *************** OUTPUT PINS *********************/
PIN 20= Q2;
PIN [21..18] = [Q3..0] ; /* saidas do contador */
PIN 19= Q1;
PIN 22 = Co ; /* comando para celula seguinte contar */
PIN 18= Q0;
PIN 23 = Io ; /* Comando para celula seguinte incrementar
/ decrementar */
4. Declarar as variáveis associadas a um

field cont = [Q3..0]; /* valor do contador */
conjunto de bits. field modo = [Ci,Ii]; /* modo de operacao */
Observe:
A variável cont declarada acima corresponde a uma
palavra de 4 bits, composta por Q3, Q2, Q1, Q0. É Expressão É equivalente a:
possível atribuir valores a esta variável, conforme cont = 'b'1001; Q3 = 'b'1;
mostrado na tabela ao lado: Q2 = 'b'0;
Q1 = 'b'0;
Q0 = 'b'1;
cont = 'h'9; cont = 'b'1001;

A tabela ao lado mostra algumas Number Base Decimal Value
alternativas para a especificação de 'b'0 Binary 0
valores numéricos: 'B'1101 Binary 13
'O'663 Octal 435
'D'92 Decimal 92
'h'BA Hexadecimal 186
'O'[300..477] Octal (range) 192..314
5. Utilizar a diretiva $DEFINE para definir

os estados: $define S0 'b'0000 /* definir estados */
Observe: $define S1 'b'0001
$define S2 'b'0010
A diretiva $define especifica ao compilador
$define S3 'b'0011
a equivalência de textos. Antes da $define S4 'b'0100
realização da compilação, é feita uma $define S5 'b'0101
substituição pelo texto equivalente. Por $define S6 'b'0110
$define S7 'b'0111
exemplo, o comando $define S8 'b'1000
cont = S9;
$define S9 'b'1001
é equivalente a;
cont = 'b'1001;
6. Especificar as operações de comparação

incr = modo:3; /* modo incremento */
“Equality operations”: decr = modo:2; /* modo decremento */
mant = modo:[0..1]; /* modo manter */
Observe:
As “Equality Operations” são expressões de comparação que podem assumir os valores “Verdadeiro” ou
“falso”. Por exemplo, a expressão decr assumirá o valor “verdadeiro” sempre que a variável modo tiver o
valor 2 (ou ‘b’ 10, em binário). Isto é, sempre que Ci=1 e Ii=0: verdadeiro quando a operação for
decrementar.
7. Descrever o diagrama de estados Sequenced cont {

present S0 if incr next S1;
if decr next S9;
if mant next S0;
if decr out Co;
if decr next S0;
if mant next S1;
if decr next S1;
if mant next S2;
if decr next S2;
if mant next S3;
if decr next S3;
if mant next S4;
if decr next S4;
if mant next S5;
if decr next S5;
if mant next S6;
if decr next S6;
if mant next S7;
if decr next S7;
if mant next S8;
if decr next S8;
if mant next S9;
if incr out Co out Io;
}

8. Especificar as operações de Set e Reset
Q3.ar = R;
Q2.ar = R;
Q1.ar = R;
Q0.ar = R;
Q0.sp = 'b'0;
Q3.sp = 'b'0;
Q2.sp = 'b'0;
Q1.sp = 'b'0;

Apostila WinCupl PDF

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Apostila WinCupl PDF

Hochgeladen von

Copyright:

Verfügbare Formate

1 Introdução

Dispositivos programáveis são componentes que contem arrays de elementos lógicos

O uso deste tipo de dispositivo apresenta as seguintes vantagens:

Exercício 2-1 – Equações do circuito combinacional 1

Alberto do Canto PLD2008_10.doc 1 de 26

Ilustração 2-1 PROM 8 X 1

Observe a existência dos 8 fusíveis identificados como F0, F1..F7.

Exercício 2-2 – Implementar com PROM

Alberto do Canto PLD2008_10.doc 2 de 26

Observe a existência de 18 fusíveis

Ilustração 2-2 – PAL

Exercício 2-3 – Implementar com PAL

Exercício ?? ?? – Limitações de uma PAL

Alberto do Canto PLD2008_10.doc 3 de 26

Ilustração 2-3 - PAL4L2 – Pal didático

Exercício 2-4 – Implementar com PAL

2.3 Exemplos de arquitetura

Exercício 2-5 – Implementar com PAL16L8

Alberto do Canto PLD2008_10.doc 4 de 26

Alberto do Canto PLD2008_10.doc 5 de 26

Alberto do Canto PLD2008_10.doc 6 de 26

Alberto do Canto PLD2008_10.doc 7 de 26

Exercício 2-6 – Implementar com PAL16L8

SAIDA = A + B + C + D + E + F + A.B + C.D.E

Alberto do Canto PLD2008_10.doc 8 de 26

Ilustração 3-1 Circuito "GATES"

3.1.1 Seleção do PLD

A seleção do componente passa pelo

Ilustração 3-2 - Pinagem do

Alberto do Canto PLD2008_10.doc 9 de 26

Com este mapeamento, será criado um

Ilustração 3-3 - mapeamento dos pinos

Alberto do Canto PLD2008_10.doc 10 de 26

2. iniciar um novo arquivo de projeto

3. Digitar informações de cabeçalho.

4. especificar o número de pinos

5. Especificar o número de pinos

Alberto do Canto PLD2008_10.doc 11 de 26

/* *************** INPUT PINS *********************/

/* *************** OUTPUT PINS *********************/

Ilustração 3-4 - esqueleto criado pelo assistente

7. ir para o diálogo de seleção de dispositivos.

9. Pressione o botão OK, para

10.No editor de textos altere o De:

Alberto do Canto PLD2008_10.doc 12 de 26

12.acrescentar o mapeamento dos

13. Acrescentar as equações, que

Observe: a tabela a seguir apresenta os operadores lógicos e sua precedência:

Operador Exemplo Descrição Precedência

14. No menu options..compiler, configurar o compilador:

Alberto do Canto PLD2008_10.doc 13 de 26

17.Salvar o arquivo utilizando o menu File..Save.

2. Criar um novo arquivo de

3. Para especificar o projeto

5. Selecionar o menu Signal..Add

Alberto do Canto PLD2008_10.doc 14 de 26

7. Aparecerá novamente a caixa de

8. Repetir o procedimento até que todos

9. Aparecerá um quadro de simulação semelhante

10. Selecionar o menu Signal..Add Vector

Alberto do Canto PLD2008_10.doc 15 de 26

12. Com operações de arrastar e soltar, reordenar os nomes dos

13. Definir o valor 0 (zero) para:

/* * INPUT PINS *******/

/* * OUTPUT PINS *******/

/* * OUTPUT PINS *******/

3. Completar o mapeamento dos /* * INPUT PINS *******/