Tutorial - Xilinx ISE

Transcrição

1 Tutorial - Xilinx ISE Universidade Federal do Rio de Janeiro Escola Politécnica Departamento de Eletrônica e Computação Autores: Artur Lemos Ioav Lichtenstein Thiago Lobo Orientador: Mário Vaz

2 Índice: 1. Introdução 3 2. Instalação 4 3. Criando um novo projeto 5 4. VHDL Básico 8 5. Simulando um projeto Criando um DCM Implementando um projeto na FPGA Exemplos de Código 27 2

3 1. Introdução O ISE (Integrated Software Environment) é um software criado pela Xilinx para síntese e análise de modelos HDL. O usuário poderá escrever, compilar, realizar análises temporais (utilizando diferentes estímulos como entrada) e/ ou configurar FPGA s com o modelo criado. Este tutorial visa fornecer ao usuário uma visão geral do software, mostrando, de forma simples, desde a ativação do programa até a compilação, visualização de diagramas RTL e configuração da FPGA Spartan 3AN com códigos VHDL. Desenvolveremos o tutorial baseando- nos num módulo divisor de freqüência, e forneceremos outros exemplos de código na última sessão. 3

4 2. Instalação Para ativar o ISE, deve- se baixar os arquivos no link das- disciplinas/eel480 - sistemas- digitais, garantir que estão na pasta ~/Downloads e executar a seguinte instrução no Terminal: cd ; tar xvf /Downloads/Xilinx.tar ;./ise.sh Feito isso, o ISE deverá estar ativado e para executá- lo, deve- se utilizar o seguinte comando, também no Terminal: ise & O que nos leva à tela principal do programa: 4

5 3. Criando um novo projeto Na tela principal do ISE, devemos começar pelo menu File > New Project e a janela New Project Wizard será aberta. Campos: Name - nome do projeto Location - localização onde o projeto será salvo* Description - descrição do projeto * - utilizaremos a pasta /tmp, pois eventualmente, o ISE pode gerar arquivos de projeto muito grandes, os quais excederiam o limite por usuário da rede. Para garantir que os arquivos sejam guardados, devemos utilizar o comando Archive, como mostraremos posteriormente. 5

6 Feito isso, clicar em Next. Agora, devemos escolher outros parâmetros de projeto: Evaluation Development Board - Spartan 3AN Starter Kit Synthesis Tool - XST Prefered Language - VHDL VHDL Source Analysis Standard - VHDL- 93 Após clicar, mais uma vez, em Next, uma janela que resume os parâmetros do projeto será exibida. Confira os dados e caso estejam corretos, clique em Finish. Agora, temos um projeto (.xise) pronto, basta adicionar códigos- fonte VHDL e poderemos trabalhar com os modelos. Para importar um código VHDL já escrito, devemos acessar o menu Project > Add Copy of Source, navegar até o arquivo e selecioná- lo. Isso copiará o arquivo para o workspace do projeto e permitirá sua edição. Sempre que a edição dos arquivos estiver concluída, devemos utilizar o menu Project > Archive, para salvar o projeto na pasta do 6

7 usuário em formato.zip. Para utilizar esse projeto posteriormente, basta descompactar o.zip gerado dentro da pasta /tmp e abri- lo na primeira tela do ISE ( Open Project ). 7

8 4. VHDL Básico VHDL é uma linguagem de descrição de hardware que foi inicialmente utilizada para documentar componentes digitais e acabou sendo aproveitada para simulações/ implementações em FPGA desses mesmos componentes. Um arquivo VHDL deve conter, no mínimo, uma entity e uma architecture. A entity consiste na descrição da interface do módulo como uma caixa preta: especificando apenas as entradas e saídas. A architecture descreve o funcionamento do módulo, propriamente dito. Costumamos separar architectures em duas classes: comportamentais e estruturais. As comportamentais servem para definir como um módulo funcionará e as estruturais servem para definir como um módulo de alta hierarquia interliga diferentes módulos menores (o que não deixa de ser seu funcionamento). A utilização de módulos já prontos dentro de uma architecture se assemelha à instanciação de um objeto em uma linguagem Orientada a Objetos: especifica- se o tipo do objeto (sua Entity), escolhe- se um nome e mapeia- se suas entradas e saídas (semelhante ao construtor de classes em Java). Dentro da architecture utilizamos sinais (signals) para intercomunicar módulos. É aplicável um paralelo com as variáveis de um programa em Java. Comentários são feitos utilizando- se um - -, por exemplo: - - Isso é um comentário e não será utilizado na síntese 8

9 Segue um exemplo básico: uma porta lógica AND: importando std_logic da biblioteca IEEE 2. library IEEE; 3. use IEEE.std_logic_1164.all; essa é a entidade (entity) 6. entity ANDGATE is 7. port ( 8. I1 : in std_logic; 9. I2 : in std_logic; 10. O : out std_logic); 11. end entity ANDGATE; essa é a arquitetura comportamental (architecture) 14. architecture behavioral of ANDGATE is 15. begin 16. O <= I1 and I2; 17. end architecture behavioral; Como podemos ver, a leitura do bloco entity permite imaginarmos o seguinte: I1 I2 I1 ANDGATE O Depois, em architecture, o funcionamento do bloco é descrito: a saída O recebe a operação bit- a- bit AND entre as entradas I1 e I2. A operação AND foi incluída quando importamos a biblioteca IEEE. 9

10 Agora, podemos analisar o divisor de freqüência clk_div: 18. library IEEE; 19. use IEEE.STD_LOGIC_1164.ALL; 20. use ieee.numeric_std.all; entity clk_div is 23. generic (n : integer := 4); 24. port (clk_in : in std_logic; 25. div : out std_logic; 26. div2 : out std_logic ); 27. end clk_div; architecture divide of clk_div is 30. signal cnt, cnt1 : integer := 0; 31. signal div_temp, div_temp2 : std_logic := '0'; begin 34. div <= div_temp; 35. div2 <= div_temp2; 36. process (clk_in) begin 37. if (clk_in'event and clk_in = '1') then 38. if cnt >= n then 39. div_temp <= not(div_temp); 40. cnt <= 1; 41. else 42. div_temp <= div_temp; 43. cnt <= cnt + 1; 44. end if; 45. end if; 46. if (clk_in'event and clk_in = '0') then 47. if cnt1 >= n then 48. cnt1 <= 1; 49. div_temp2 <= '1'; 50. else 51. div_temp2 <= '0'; 52. cnt1 <= cnt1 + 1; 53. end if; 54. end if; 55. end process; 56. end divide; Como podemos ver, o módulo clk_div é descrito por uma entrada (clk_in) e duas saídas (div1 e div2). O generic n : integer := 4 é equivalente a um #define em C. n será 10

11 substituído em todos os lugares que aparece no código por 4. Trata- se de uma constante. Dentro da architecture, vemos um process, que é como uma função em C. Todo processo leva uma lista de sensibilidade, que no caso é (clk_in). Isso indica que sempre que clk_in for atualizado, o process será executado. Há, também, 4 signals: 2 contadores e 2 temporários que são mapeados às saídas do bloco, como indicam as linhas: 57. div <= div_temp; 58. div2 <= div_temp2; Sabendo- se disso, podemos realizar o resto da análise como em qualquer linguagem de programação. Perceberemos que div é simplesmente clk_in dividido por n e que div2 é um clock cujo período é o mesmo de div, porém seu duty- cycle (tempo em nível alto) é de 25%, ao contrário dos 50% em clk_in e div. 11

12 Agora, podemos analisar o outro módulo, base_tempo, que utiliza o módulo clk_div para dividir a frequência do sinal de entrada clk. Vale ressaltar o fato de que um DCM (Digital Clock Manager foi necessário, voltaremos a falar sobre ele na sessão 5): 59. library IEEE; 60. use IEEE.STD_LOGIC_1164.ALL; 61. use ieee.numeric_std.all; 62. library UNISIM; 63. use UNISIM.Vcomponents.ALL; entity base_tempo is 66. generic (n: integer := 2); 67. port (clk : in std_logic; 68. clk_out : out std_logic; 69. clk_out_2 : out std_logic; 70. locked : out std_logic); 71. attribute LOC : string ; 72. attribute LOC of clk : signal is "E12"; 73. attribute LOC of locked : signal is "W21"; 74. attribute LOC of clk_out : signal is "Y22"; 75. attribute LOC of clk_out_2 : signal is "Y18"; 76. end entity; architecture estrutural of base_tempo is 80. component clk_div 81. port (clk_in : in std_logic; 82. div : out std_logic; 83. div2 : out std_logic); 84. end component; COMPONENT dcm1 87. PORT(CLKIN_IN : IN std_logic; 88. CLKFX_OUT : OUT std_logic; 89. CLKIN_IBUFG_OUT : OUT std_logic; 90. CLK0_OUT : OUT std_logic; 91. LOCKED_OUT : OUT std_logic); 92. END COMPONENT; signal clk_int : std_logic;

13 100.begin 101.clk_divider : clk_div port map 102. (clk_in => clk_int, 103. div => clk_out, 104. div2 => clk_out_2); Inst_dcm1 : dcm1 PORT MAP ( 107. CLKIN_IN => clk, 108. CLKFX_OUT => clk_int, 109. CLKIN_IBUFG_OUT => open, 110. CLK0_OUT => open, 111. LOCKED_OUT => locked); 112.end estrutural; Começaremos a análise pela entity: como esperado, há uma entrada clk e duas saídas clk_out e clk_out_2. Há uma saída extra chamada locked, que simplesmente diz se o DCM está ou não sincronizado. As linhas associam sinais da entity a componentes da FPGA na qual o código será carregado. Exceto por E12, todos os sinais são mapeados a LEDS ou contatos, que podem ser identificados pelos mesmos nomes na placa física: 113.attribute LOC : string ; 114.attribute LOC of clk : signal is "E12"; 115.attribute LOC of locked : signal is "W21"; 116.attribute LOC of clk_out : signal is "Y22"; 117.attribute LOC of clk_out_2 : signal is "Y18"; A achitecture, como de se esperar, é estrutural, pois base_tempo trata- se de um módulo que unifica pequenos módulos (clk_div e dcm1). Para instanciarmos módulos, devemos antes fazer uma declaração do tipo COMPONENT nome... END COMPONENT;. Isso foi feito para o clk_div e o dcm1. Feito isso, podemos finalmente mapear as portas dos componentes (tal como inicializar um objeto em Java através de seu construtor) a sinais ou entradas/saídas da entidade. 13

14 No caso, utilizamos um sinal interno clk_int, que serve como saída do dcm1. Não podemos utilizar diretamente o clock da placa (50mHz), pois há problemas como capacitâncias parasitas que prejudicariam o funcionamento do circuito. De fato, resolvemos esse problema através do dcm1, que coloca uma frequência menor em clk_int para que essa seja utilizada como entrada para o clk_div. As saídas do clk_div são intuitivamente mapeadas às saídas clk_out e clk_out_2 da base_tempo. Acreditamos que a esse ponto, o leitor já adquiriu certa noção de código VHDL e de seu funcionamento, sendo capaz de continuar por si só utilizando referências online para funções mais complexas. 14

15 5. Simulando um projeto Completados os códigos VHDL, podemos realizar simulações e visualizar seu diagrama RTL através do ISE. Vale lembrar que podemos ver erros de sintaxe em tempo real na aba Errors, basta um CTRL + s para salvar o código e a janela será atualizada com os erros encontrados: Para sintetizar os arquivos, devemos selecionar a Implementation View em Design > Hierarchy. Feito isso, devemos clicar uma vez sobre o nome do componente que será sintetizado: 15

16 Feito isso, basta um duplo- clique em Synthesize - XST. Espere alguns instantes e verifique o log de erros para saber se a sintetização foi feita com sucesso. Para visualizar o esquemático RTL, basta expandir Synthesize - XST, um dupo- clique em View RTL Schematic e selecionar Start with a schematic of the top- level block no diálogo que será aberto. Com o Top- level schematic aberto, podemos dar duplos- cliques de forma a expandir as caixas- pretas que compoem o circuito. Podemos, finalmente, simular o código. Selecione a Simulation View em Design > Hierarchy e clique uma vez sobre o nome do componente que será simulado. Feito isso, expanda isim simulator e dê duplos- cliques, na sequência, em: Behavioral Check Sintax (um último teste de sintaxe) e 16

17 Simulate Behavioral Model (a simulação propriamente dita). Caso tudo corra bem, a janela do simulador (isim) será aberta: 17

18 Agora, podemos forçar um valor no clock de forma a observar a saída do circuito (que se trata de um clk_div). Devemos clicar com o botão direito na variável desejada e selecionar Force clock. Isso abrirá uma janela com diversas caixas a serem preenchidas: Value Radix - Tipo de clock: binário, ASCII, Decimal etc Leading Edge Value - Valor inicial de clock Trailing Edge Value - Valor final de clock Starting at Time Offset - Quando o clock começa Cancel After Time Offset - Quando o clock termina Duty Cycle (%) - Razão entre Leading Edge e Trailing Edge Period - Auto- explicativo Preenchendo da seguinte forma, obtemos um período de 50mHz. 18

19 Agora, devemos programar por quanto tempo a simulação será executada. Basta preencher a caixa de texto na barra de ícones e então clicar na setá para a esquerda (apagando a última simulação). Feito isso, devemos clicar no botão de play com uma ampulheta e na terceira lupa (com um X) para ajustar a escala dos gráficos ao tamanho da janela. Esse é o resultado final. Como podemos ver, o clock foi devidamente dividido. 19

20 Outra forma de impor valores de clock e de certas entradas é utilizar um TestBench. Para tanto, devemos selecionar a Implementation View em Design > Hierarchy, clicar com o botão direito sobre o módulo principal, ir em New > Source > TestBench. Devemos dar um nome ao TestBench (normalmente adicionando- se o sufixo _tb ao nome do componente original) e ao confirmar seremos levado à janela de seu código fonte (o código exemplo foi usado em um debouncer, que será descrito na última sessão): 118.LIBRARY ieee; 119.USE ieee.std_logic_1164.all; ENTITY debouncer2_tb IS 122.END debouncer2_tb; ARCHITECTURE behavior OF debouncer2_tb IS COMPONENT debouncer PORT( 128. Clk : IN std_logic; 129. Key : IN std_logic; 130. pulse : OUT std_logic 131. ); 132. END COMPONENT; Inputs 136. signal Clk : std_logic := '0'; 137. signal Key : std_logic := '0'; Outputs 140. signal pulse : std_logic; Clock period definitions 143. constant Clk_period : time := 10 ms; BEGIN Instantiate the Unit Under Test (UUT) 148. uut: debouncer2 PORT MAP ( 149. Clk => Clk, 20

21 150. Key => Key, 151. pulse => pulse 152. ); Clock process definitions 155. Clk_process :process 156. begin 157. Clk <= '0'; 158. wait for Clk_period/2; 159. Clk <= '1'; 160. wait for Clk_period/2; 161. end process; Stimulus process 165. stim_proc: process 166. begin 167. Key <= '0'; 168. wait for Clk_period; 169. Key <= '1'; 170. wait for Clk_period * 6; 171. Key <= '0'; 172. wait for Clk_period * 4; 173. Key <= '1'; 174. wait for Clk_period * 4; 175. Key <= '0'; 176. wait; 177. end process; END; Como pode- se ver, o módulo do exemplo possui duas entradas clk e key e uma saída pulse. Podemos inicializar as variáveis como nas linhas 136 e 137 e também definir um período para o clock. Feito isso, podemos implementar o Clk_process, que define como o clock mudará no tempo. No caso, como podemos ver, ele é forçado a 0, meio período é esperado, ele é forçado a 1, meio período é esperado e o processo se repete, gerando uma onda quadrada. O mesmo pode ser feito para os estímulos (as entradas) do componente no processo stim_proc. Podemos usar a 21

22 palavra reservada wait para definir os atrasos entre as mudanças de valores (que também podem ser definidas). Com o TestBench feito, basta simulá- lo no lugar do componente original e teremos o processo automatizado, sem necessidade de forçar clocks ou coisas do tipo. 22

23 6. Criando um DCM A criação de um DCM consiste nos seguintes passos: - Selecionar o Implementation View em Design > Hierarchy - Clicar com o botão direito no projeto e selecionar New Source - Busque por DCM na barra de pesquisa e selecione Single DCM_SP conforme a seguinte imagem: - Dê um nome diferente de dcm, tal como dcm1 ou dcm2, e clique em Finish - Feito isso, você será levado à janela Xilinx Clocking Window - Nessa janela é possível selecionar os mais variados parâmetros para o clock que o DCM transformará. 23

24 Selecione conforme as exigências de seu projeto (como multiplicar/dividir o clock) - Clique em Next, selecione Use Global Buffers for all Selected Clock Outputs - Clique em Next, selecione Show all Modifiable Outputs e clique em Finish 24

25 - O DCM está criado, agora basta utilizar o código para o componente de DCM como mostrado na sessão 4. 25

26 7. Implementando um projeto na FPGA Caso os sinais da entity do componente já estejam mapeados para partes da FPGA, como mostrado na sessão 4, você está pronto para implementar o código na placa. É importante, obviamente, que a placa esteja ligada ao PC pela interface USB e esteja devidamente alimentada. Em primeiro lugar, devemos escolher a Implementation View em Design > Hierarchy, feito isso, clique uma vez sobre o módulo principal do seu projeto e clique duas vezes sobre Configure Target Device. A janela do impact será aberta. Clique duas vezes em Boundary Scan e clique com o botão direito no espaço em branco e selecione Initialize Chain. Na primeira miniatura da FPGA, carregue o arquivo.bit que correponde ao seu projeto. Deixei a segunda em bypass. Clique com o botão direito sobre a primeira miniatura e clique em Program FPGA Only. O programa deve estar carregado na placa. Observe as partes para as quais os sinais foram mapeados. 26

27 8. Exemplos de código Debouncer: 180.LIBRARY ieee; 181.USE ieee.std_logic_1164.all; 182.USE ieee.std_logic_unsigned.all; ENTITY debouncer2 IS 185. PORT (Clk : IN STD_LOGIC; 186. Key : IN STD_LOGIC; 187. pulse : OUT STD_LOGIC); 188.END debouncer2; ARCHITECTURE shift_register OF debouncer2 IS 191.SIGNAL SHIFT_KEY : STD_LOGIC_VECTOR(3 DOWNTO 0) := "1111"; BEGIN 194.PROCESS 195. BEGIN WAIT UNTIL Clk'EVENT AND Clk = '1'; SHIFT_KEY(2 DOWNTO 0) <= SHIFT_KEY(3 DOWNTO 1); 200. SHIFT_KEY(3) <= NOT Key; IF SHIFT_KEY(3 DOWNTO 0)="0000" THEN PULSE <= '1'; 203. ELSE PULSE <= '0'; 204. END IF; END PROCESS; 207.END shift_register; Primeiramente, explicaremos a motivação do circuito: remover trepidações transientes provenientes de chaves mecânicas. O módulo possui duas entradas Clk e Key e uma saída Pulse. Key é o sinal proveniente da chave mecânica, pulse é a saída que corresponde ao sinal da chave corrigido. O circuito funciona inicializando o registrador para 1111 e esperando que ele se torne 0000, para fazer pulse = 1. 27

28 A forma de atualizar o valor do registrador é ir colocando not key no lado direito do vetor de bits do registrador. Se por 4 clocks seguidos, o valor de key amostrado estiver em 1, o registrador estará no estado 0000 e pulse valerá 1, caso contrário pulse valerá 0. Isso faz sentido pois evita que a saída seja atualizada durante o transiente da vibração da chave, fazendo com que ela só seja ativada algum tempo depois (o suficiente para que a trepidação termine). Logo, haverá um atraso muito pequeno (porém detectável em osciloscópio) na resposta da chave. A seguinte imagem, adquirida em um osciloscópio ligado à FPGA com o programa do Debouncer carregado demonstra tal atraso e comprova o funcionamento do circuito: 28

29 A curva mais baixa é key e a mais alta é not pulse, vemos, portanto, que pulse só vai a 1 algum tempo depois de key ter ido a 1. Esse é o tempo do transiente de vibração. Referências: An ISE Tutorial - Luiz Rennó Projeto Debouncer - Camila Simões da Costa Cunha Vasconcellos, Henrique Duarte Faria, Patrick Svaiter, Paulo Roberto Yamasaki Catunda Relatório de Sistemas Digitais: Projeto Base de Tempo - Michael D. Barreto e Silva, Luiz Carlos, Gabriela Dantas 29