VGA (Video Graphics Array) – Parte II

Hello my friends,

Continuando com o projeto do VGA embarcando no kit da Altera DE1, a primeira parte do projeto é saber qual a resolução do monitor que estará sendo utilizado. Neste projeto será o 1280×1024/60Hz da LG.

Neste link apresenta todas as configurações de diversos resoluções onde usaremos como base para o desenvolvimento conforme a ilustrado na figura abaixo.

VGA_Timing
Figura 01: Timing.

A seguir será criado um PLL (Phase Locked Loop) no QSYS que será capaz de fornecer o clock para o sistema, ou seja, a frequência do pixel de 108MHz.

Ao abrir o QSYS (Tutorial sobre QSYS) adicionaremos o componente “Altera PLL” de acordo com a Figura 02:

VGA_Timing_02
Figura 02: Avalon ALTPLL.

A configuração do componente é bem simples visto que não usaremos todos os recursos disponíveis pela Altera.

  1. Speed Grade : 7;
  2. Frequency Output: 24MHz (Disponível no kit);
  3. Operation Mode: With no compesation.
VGA_Timing_03
Figura 03: Configuração de Entrada (01).
  1. Optional Inputs: Create an “areset” input to asynchronously reset PLL;
  2. Lock Output: Create “locked” output.
VGA_Timing_04
Figura 04: Configuração de Entrada (02).
  1. Enter Output clock frequency: 108MHz;
  2. Clock phase shift: 0º;
  3. Clock duty cycle: 50%.
VGA_Timing_05
Figura 05: Configurações de Saída.

A seguir clicar em “Finish“. Na tela inicial do QSYS devemos configurar a Avalon para podermos ter os pinos de IOs do PLL conforme demonstrado a seguir.

VGA_Timing_06
Figura 06: Configuração Avalon.

Na Aba “HDL Example” pode ser visualizado o código-fonte do Nios em VHDL.

 component vga_qsys is
 port (
 clk_in_clk    : in std_logic  := 'X'; -- clk
 reset_reset   : in std_logic  := 'X'; -- reset
 clk_out_clk   : out std_logic       ; -- clk
 locked_export : out std_logic         -- export
 );
 end component vga_qsys;

 u0 : component vga_qsys
 port map (
 clk_in_clk    => CONNECTED_TO_clk_in_clk,   -- clk_in.clk
 reset_reset   => CONNECTED_TO_reset_reset,  -- reset.reset
 clk_out_clk   => CONNECTED_TO_clk_out_clk,  -- clk_out.clk
 locked_export => CONNECTED_TO_locked_export -- locked.export
 );

Para salvar o QSYS deve clicar em “File=>Save”, escolher o nome do projeto, por exemplo, vga_qsys e por final gerar o código-fonte na aba “Generation=>Generate”.

Na próxima parte começaremos desenvolver o código em VHDL onde fará o sincronismo horizontal e vertical.

Até a próxima.

VGA (Video Graphics Array) – Parte I

Hello my friends,

Neste tutorial será desenvolvido um projeto utilizando circuito VGA (Video Graphics Array) disponível na placa DE1 da Altera.

Primeiramente farei uma breve introdução sobre o padrão descrevendo suas características, funcionalidades e posteriormente para o desenvolvimento do código em VHDL.

INTRODUÇÃO

Desenvolvido pela empresa IBM em 1987 o padrão VGA contém informações sobre as imagens apresentadas nos monitores de computadores e televisores.

A primeira versão permitiu uma resolução de 640×480 pixels com 16 cores podendo serem visualizados em uma taxa de 60Hz  e utilizando um clock de 25MHz (T = 40ns), desde então surgiram muitas revisões, como exemplo o Super VGA (SVGA) com resoluções tais como 800×600 or 1024×768 pixels.

INTERFACE

A interface possuem dois tipos de sinais, dados e controle. Os sinais de dados são níveis de tensão no  RGB (Red Green Blue) para determinar a cor de cada pixel do monitor e os sinais de controle fornecem o sincronismo horizontal e vertical.

A exibição das imagens na tela do monitor é um processo de varredura das linhas (retraço horizontal) e colunas (retraço vertical), ou seja, da esquerda para direita e de cima para baixo onde serão acesos cada pixel de acordo com sua tonalidade de acordo com a figura a abaixo:

Figura 01
Figura 01: Varredura Horizontal e Vertical.

A duração total de um linha são 800 pulsos de clock (32μs) denominado Scanline Time (A), o sincronismo horizontal se dá pela transição de descida do pino HSYNC que indica que uma linha foi finalizada e que próxima linha será iniciada que deverá permanecer por um período B (tempo de sincronismo) de 96 pulsos de clock (3.84μs) de acordo com a Figura 02:

Após o período B possui um período chamado de Back Porch  (tempo de guarda inicial) com 48 pulsos de clock (1.92μs) antes de iniciar a região ativa da linha (área visível) com 640 pulsos de clock (25.6μs). Após serem transmitidos todos os pixels da linha haverá um tempo de guarda final denominada Front Porch com 16 pulsos de clock (0.64μs) deve ser aguardado até que o sinal HSYNC seja colocado em zero novamente.

Figura 02
Figura 02: Sincronismo Horizontal.
 O sinal de sincronismo vertical inicia-se com a transição de descida do pino VSYNC indicando que um quadro foi finalizado e que o próximo será iniciado com duração de 2 linhas (0.0064ms), em seguida terá o tempo de guarda inicial (Back Porch) de linhas (0.45ms), possuindo uma área visível de 480 linhas (15.25 ms) e antes de terminar o frame existe  0 tempo de guarda final (Front Porch) de 31 linhas (1.02ms) conforme apresentado na figura a seguir.
Figura 03
Figura 03: Sincronismo Vertical.
Temporização de outras resoluções

Para outras resoluções existem uma temporização diferente do que apresentado acima para 640×480. Abaixo podemos verificar os tempos de acordo com a resolução e a taxa de amostragem.

Tabela 01
Tabela 01: Temporizações para alguns formatos.

Neste link você encontrará outras resoluções com sua respectivas temporizações.

Esquema Elétrico DE1

O kit DE1 inclui um conector de 16 pinos para o padrão VGA. Os sinais de sincronização do VGA estão conectados diretamente no FPGA Cyclone II, um DAC com resolução de 4 bits usando uma rede de resistores para fornecer os sinais de dados analógicos. Abaixo pode ser visto o esquema elétrico do circuito da placa de desenvolvimento.

Figura 04
Figura 04: Circuito VGA.
Pinagem Cyclone II

A tabela são exibidos as conexões entre os pinos do FPGA ao circuito VGA do kit.

Tabela 02
Tabela 02: Conexões.

Na próxima Parte II iniciaremos um simples código em VHDL sendo capaz de apresentar uma imagem no monitor.

Até mais!

Processador Nios II – Desenvolvimento: Final

Olá Galera,

Esta série teve como objetivo demonstrar como iniciar um projeto utilizando o softcore.

5. Gravando os arquivos .sof e .elf no FPGA Cyclone II do Kit DE1.

Neste último post referente ao Processador Nios II embarcados nos dispositivos FPGA da Altera iremos programar os arquivos .sof e .elf no FPGA.

A) SOF

Com o software Quartus II aberto, clique em “Tools => Programmer” conforme exibido na figura a seguir.

Figura 01
Figura 01: Programmer.

Em seguida será aberto a tela do Programmer, Clique em “Add File…” (1) para adicionar o arquivo .sof (2) e depois clique em “Open” (3) . 

Figura 03
Figura 02: Adicionando o arquivo .sof.

Utilizaremos o gravador “USB-Blaster” (1) disponível no Kit Altera DE1, selecione a caixa “Program/Configure” (2) em depois clicar em “Start” (3) e em “Progress” (4) informará o status da gravação.

Figura 03
Figura 03: Gravando o arquivo .sof.

Após o término da gravação aparecerá a a mensagem “Successful”. 

B) ELF

Após compilar o projeto do Nios II no Eclipse é gerado o arquivo .elf e conforme demonstrado na figura abaixo o primeiro passo é clicar em “Run => Run Configurations…”.

Figura 04
Figura 04: Run Configurations.

Na tela abaixo devemos selecionar a opção “Nios II Hardwre => New_configuration” (1) , selecionar a aba “Target Connection ” (2), marque as caixas em “System ID checks” (3), porque não acrescentamos o componente System ID no projeto do Qsys e clicar em “Refresh Connections” (4) para estabelecer a comunicação entre Eclipse e FPGA.

Figura 05
Figura 05: Configurando o processo de gravação.

O processo estabelecerá comunicação com o FPGA, perceba em “Connections” nos campos “Processors” e “Byte Stream Devices” foram detectados o USB-BLASTER, dispositivo FPGA, processador Nios II e JTAG UART (componente adicionado no Qsys), e a seguir clique em “Run” para gravar o processador.

Figura 06
Figura 06: Gravando o Nios II.

Neste momento FPGA ja está programado com os arquivos .sof e . elf . No vídeo abaixo está sendo demonstrado o funcionamento.

Obrigado a todos!

Processador Nios II – Desenvolvimento: Parte IV

Olá pessoal,

Continuando com o desenvolvimento do processador Nios II embarcado em FPGA neste tópico demonstraremos como criar projeto no Eclipse. Se você não leu o post anterior pode ser encontrado aqui.

4. Criando projeto no Eclipse

O software Nios II contém duas partes principais: aplicações e BSP (Board Support Package).  O primeiro são os programas do usuário e o segundo são códigos específicos de configurações  Nios II. Note-se que a BSP baseia-se na informação a partir do arquivo .sopcinfo. Os códigos das duas parte são compilado e integrado em uma única imagem (arquivo .elf) e carregado para a memória principal do sistema do Nios II. O primeiro passo é abrir a IDE Eclipse:

Figura 01
Figura 01: Eclipse.

A tela abaixo informa qual local será o Workspace dos projetos. O Workspace poderá conter vários projetos, ou seja, pode criar outros projetos utilizando o mesmo Workspace.

Figura 02
Figura 02: Local do Workspace.

Criamos a pasta “firmware” dentro do projeto do Quartus II. A seguir aparecerá a página inicial do Eclipse. Para iniciar um novo projeto clique em “File => Nios II Application and BSP from Template”.

Figura 03
Figura 03: Iniciando o projeto.

Então surge a janela de acordo com a figura abaixo:

Figura 04
Figura 04: Aplicações do Nios II.

No campo “SOPC Information File Name” devemos inserir o arquivo “nios2_project.sopcinfo” onde contém as informações do BSP gerado pelo Qsys. Após importar este arquivo no campo “CPU Name” informará o nome do processador Nios II e em “Project Name” deve inserir o nome do projeto. Veja o exemplo abaixo:

Figura 05:
Figura 05: Configurando as aplicações do Nios II.

Em seguida clica em “Next >”.

Figura 06:
Figura 06: Configurando o Nios II Board Support Package.

No campo “Project name” deverá conter o nome do projeto BSP. Por exemplo, “nios2_bsp” e em seguida clica em “Finish”.

Para organização do projeto é importante que as aplicações e os arquivos BSP estão contidos na mesma estrutura de pasta dentro do projeto.

Veja na figura abaixo os arquivos de aplicações e as configurações de hardware (BSP).

Figura 07
Figura 07: Criado os arquivos.

Na pasta de aplicações (nios2_app) possui um arquivo “hello_word_small.c” onde criaremos o nosso programa em Linguagem C.

Figura 08
Figura 08: Hello Word.

Veja que o Eclipse já criou um trecho de código que poderá ser utilizado pelo programador.

O nosso programa deverá ler o status da chave “i_sw0” e acionar o led (o_led) e o o_led_blink deverá ficar aceso/apagado por 500ms.

// Bibliotecas
#include "sys/alt_stdio.h"
#include "system.h"
#include "altera_avalon_pio_regs.h"

// Rotina Principal
int main()
{ 
 // Loop Inifinito 
 while (1)
 {
    if (IORD_ALTERA_AVALON_PIO_DATA(I_SW0_BASE))        // Lê o status da chave
       IOWR_ALTERA_AVALON_PIO_DATA(O_LED_BASE,1);       // Atribui nível lógico alto para saída o_led
    else
       IOWR_ALTERA_AVALON_PIO_DATA(O_LED_BASE,0);       // Atribui nível lógico baixo para saída o_led

    IOWR_ALTERA_AVALON_PIO_DATA(O_LED_BLINK_BASE,0);    // Atribui nível lógico baixo para saída o_led_blink
    usleep(500000);                                     // Atraso de 500ms
    IOWR_ALTERA_AVALON_PIO_DATA(O_LED_BLINK_BASE,1);    // Atribui nível lógico alto para saída o_led_blink
    usleep(500000);                                     // Atraso de 500ms
 }

 return 0;
}

A arquivo “system.h” são os endereços base de cada componente inserido no projeto do Qsys, veja o exemplo para entrada “i_sw0”:

#define ALT_MODULE_CLASS_i_sw0 altera_avalon_pio
#define I_SW0_BASE 0x3000
#define I_SW0_BIT_CLEARING_EDGE_REGISTER 0
#define I_SW0_BIT_MODIFYING_OUTPUT_REGISTER 0
#define I_SW0_CAPTURE 0
#define I_SW0_DATA_WIDTH 1
#define I_SW0_DO_TEST_BENCH_WIRING 0
#define I_SW0_DRIVEN_SIM_VALUE 0
#define I_SW0_EDGE_TYPE "NONE"
#define I_SW0_FREQ 50000000
#define I_SW0_HAS_IN 1
#define I_SW0_HAS_OUT 0
#define I_SW0_HAS_TRI 0
#define I_SW0_IRQ -1
#define I_SW0_IRQ_INTERRUPT_CONTROLLER_ID -1
#define I_SW0_IRQ_TYPE "NONE"
#define I_SW0_NAME "/dev/i_sw0"
#define I_SW0_RESET_VALUE 0
#define I_SW0_SPAN 16
#define I_SW0_TYPE "altera_avalon_pio"

E o arquivo “altera_avalon_pio_regs.h”  contém as macros de leitura e escrita nos periféricos de IO, exemplo:


if (IORD_ALTERA_AVALON_PIO_DATA(I_SW0_BASE))     // Lê o status da chave 
   IOWR_ALTERA_AVALON_PIO_DATA(O_LED_BASE,1);    // Atribui nível lógico alto na saída o_led

Para compilar o projeto clica em “Project” em em seguida “Build Project”.

Figura 09
Figura 09: Compilar o Projeto.

Após compilar o projeto verifica na aba Console a mensagem “Build Finished”, caso apresenta algum erro o mesmo será informado pelo Console.

No próximo post estaremos gravando os arquivos .sof (FPGA) e .elf (NIOS) no kit de desenvolvimento DE1 demonstrando seu funcionamento.

Até mais!

Processador Nios II – Desenvolvimento: Parte III

Olá pessoal,

Feliz Natal á todos!

Neste post explicarei como instanciar o componente Nios II no projeto do Quartus II e anteriormente demonstrei como criá-lo.

3. Adicionando e instanciando o componente Nios II no Top Level

Na aba “HDL Example” no projeto do Qsys possui dois trechos de códigos (VHDL ou Verilog) sendo primeiro o componente do nios2_project e segundo o trecho da instancia do componente com o nome u0 conforme exibido na figura abaixo:

Figura 01
Figura 01: Exemplo do HDL.

Primeiramente iremos copiar o primeiro trecho do código e colar abaixo do comentário “Adicionar o componente NIOS II” no “Top Level” do projeto. E em segunda copiar o segundo trecho do código e colocar abaixo do comentário “Instanciar o componente NIOS II”. Veja o trecho do código abaixo:

 
-- Arquitetura do projeto
architecture hardware of tutorial_nios is

-- Adicionar o componente NIOS II
 component nios2_project is
 port (
 clk_clk                                : in std_logic := 'X';  -- clk
 o_led_external_connection_export       : out std_logic;        -- export
 i_sw0_external_connection_export       : in std_logic := 'X';  -- export
 o_led_blink_external_connection_export : out std_logic         -- export
 );
 end component nios2_project
begin

-- Instanciar o componente NIOS II
 u0 : component nios2_project
 port map (
 clk_clk                                => CONNECTED_TO_clk_clk, -- clk.clk
 o_led_external_connection_export       => CONNECTED_TO_o_led_external_connection_export, -- o_led_external_connection.export
 i_sw0_external_connection_export       => CONNECTED_TO_i_sw0_external_connection_export, -- i_sw0_external_connection.export
 o_led_blink_external_connection_export => CONNECTED_TO_o_led_blink_external_connection_export -- o_led_blink_external_connection.export
 );

end hardware;

A seguir devemos atribuir os pinos de entradas e saídas da entidade do projeto aos pinos da instancia do componente do Nios II conforme o a figura e o código abaixo:

Figura 02
Figura 02: Ligações do projeto.
-- Instanciar o componente NIOS II
 u0 : component nios2_project
 port map (
 clk_clk                                => i_clk50m,
 o_led_external_connection_export       => o_led,
 i_sw0_external_connection_export       => i_sw0,
 o_led_blink_external_connection_export => o_led_blink
 );

end hardware;

O próximo passo será compilar o projeto (Crtl + L) do Quartus II com as modificações acima descritas e a figura abaixo exibe o RTL Viewer do projeto:

Figura 03
Figura 03: RTL Viewer.

No próximo explicarei como criar o projeto na IDE Eclipse. Obrigado e até a próxima!

Processador Nios II – Desenvolvimento: Parte II

Olá,

Anteriormente publiquei a Parte 1 sobre como iniciar um projeto utilizando o processador Nios II da Altera e agora demonstraremos a Parte 2.

2. Criando periféricos no Qsys

Conforme explicado em post anteriores o Nios II é um processador de 32 bits baseado em Hardware embarcado no FPGA. O projeto possuirá cinco componentes:

  • Seleção do clock (clk50mhz) do processador;
  • CPU (Core do Nios) de 32 bits;
  • Uma memória On-Chip Memory;
  • Três portas PIO (Paralel Input/Output): Uma entrada para chave i_sw0 e duas saídas o_led_blink o_led;
  • Interface JTAG UART para comunicação com o computador.

Para iniciar o software QSYS, devemos clicar em Tool => Qsys como mostra a figura abaixo:

Figura 01
Figura 01: Abrindo Software Qsys.

Em seguida será aberto a janela do Qsys com os periféricos do lado esquerdo que poderão serem adicionado ao projeto do Nios II.

Figura 02
Figura 02: Tela inicial do Qsys.

O processador Nios II necessita de uma frequência de clock para operar e neste exemplo utilizaremos o clock de 50MHz dsponível no kit de desenvolvimento DE1.

Clicamos na aba “Clock Settings” para configurar o valor do clock.

Figura 03
Figura 03: Configurando o clock do Nios II.

Na figura acima verificamos três campos importantes Name, Source e MHz.

  • Name: Nome do periférico (clk50mhz)
  • Source: Fonte de origem  (External)
  • MHz: Valor da frequência (50MHz)
Figura 04
Figura 04: Configurado o clock.

A seguir adicionaremos o processador Nios II ao projeto Qsys. Em Library, selecione a opção “Embedded Processors” e em seguida clica em “Nios II Processor” e depois em “+Add”.

Figura 05
Figura 05: Adicionando o Processador Nios II.

Surge a janela da figura seguinte que mostra os diversos tipos de processadores Nios II disponíveis no software Qsys.

Figura 06: Definindo o Processador Nios II.
Figura 06: Definindo o Processador Nios II.

Selecione a opção Nios II/e que é versão mais simples do Nios II. Clique no botão “Finish”  no lado inferior direito da janela para voltar na tela inicial do Qsys.

OBSERVAÇÃO: Na parte inferior são exibidos algumas informações de erros por não serem configurados alguns parâmetros que ainda não foram exibidos.

O próximo passo será adicionar a memória On-Chip. Em “Library” selecione “Memories and Memory Controllers => On Chip => On-Chip Memory (RAM or ROM)“.

Figura 07: Adicionando On-Chip Memory ao projeto.
Figura 07: Adicionando On-Chip Memory ao projeto.

A tela abaixo exibe a configuração On-Chip Memory. A memória utilizada será de 4k bytes e 32 bits de largura.

Figura 08: Parâmetros On-Chip Memory.
Figura 08: Parâmetros On-Chip Memory.

O próximo passo é adicionar a interface PIO ao projeto. Na biblioteca de componentes, selecione “Peripherals => Microcontrollers Peripherals => PIO (Parallel I/O)”.

Figura 09: Adicionando PIO.
Figura 09: Adicionando PIO.

A tela abaixo demonstra a configuração do PIO. Primeiramente configuramos para a entrada i_sw0, informaremos o comprimento “Width” de 1 bit e em “Direction” seleciona a opção “Input” e em seguida clique em “Finish”.

Figura 10: Configurando o PIO como entrada.
Figura 10: Configurando o PIO como entrada.

O mesmo deverá ser feito para as duas saídas o_led e o_led_blink, porém selecionar “Output” para “Direction” e 1 em “Width”.

A seguir adicionaremos o JTAG UART para realizar a comunicação entre o computador e o processador Nios II.  Em “Library”, selecione “Interface Protocols => JTAG UART” e clique no botão “+Add”. Sendo assim, surge a janela JTAG UART.

Figura 11: Adicionando JTAG UART.
Figura 11: Adicionando JTAG UART.

Não altere os parâmetros “Default” e clique no botão “Finish” e o sistema retornará para o software Qsys. Podemos verificar na figura abaixo o sistema completo com todos os componentes adicionados ao projeto do Qsys.

Figura 12: Periféricos adicionados.
Figura 12: Periféricos adicionados.

A seguir devemos configurar as conexões entre os periféricos na coluna “Connections” como  mostra a Figura 13.

Figura 13: Interligando os Periféricos.
Figura 13: Interligando os Periféricos.

Na coluna “Names” podemos alterar os nomes dos periféricos para facilitar durante a programação do Nios II e no momento de realizar as conexões na instância do componente. Clique em cima do componente e pressione a tecla F2 para renomeá-lo.

  • nios2_qsys_0 = nios2_processor
  • onchip_memory2_0 = onchip_memory
  • pio_0 = i_sw0
  • pio_1 = o_led
  • pio_2 = o_led_blink
  • jtag_uart_0 = jtag_uart

O endereçamento inicial (Base) e final (End) pode ser configurado pelo desenvolvedor ou automaticamente pelo Qsys em “System => Assign Base Address”.

Figura 13
Figura 13: Configuração dos endereços dos periféricos.

O processador Nios II possui um vetor reset definido pelo usuário quando em condição de reset, em seguida o processador busca a próxima instrução e também possui o endereço de memória que o processador busca quando á interrupção.

Para configurar estes parâmetros, clique duas vezes no componente nios2_processor e nos campos “Reset Vector” e “Exception Vector” selecionar a opção “onchip_memory.s1” e em seguida clicar em “Finish”.

Figura 15
Figura 15: Configurando os vetores do Nios II.

 A seguir devemos disponibilizar acesso para o FPGA os pinos PIO (i_swo, o_led e o_led_blink) do Nios II. Na coluna “Export”  devemos clicar duas vezes na linha de “external_connection” para os PIOs citados de acordo com a figura abaixo.

Figura 16
Figura 16: Export Conduit para os PIOs.

O próximo passo é gerar os arquivos do Qsys, na aba “Generation” e clicar em “Generate”.  O software pedirá que salva o arquivo, neste exemplo será nios2_project.

Figura 17
Figura 17: Gerando arquivos do Nios II.

Final do processo sem erros com dois warnings. Não se preocupe neste momento com o warnings, porque não nos impedirá de fazer corretamente o projeto.

Figura 18
Figura 18: Fim do Generate.

O último passo deste tópico é adicionar o arquivo “nios2_project.qip” gerado pelo Qsys ao projeto do Quartus II. Este arquivo fica dentro pasta do projeto o seguinte caminho : nios2_project => synthesis => nios2_project.qip.

Figura 19
Figura 19: Localização do arquivo nios2_project.qip.

No projeto do Quartus em “Assignments =>Settings … =>Files”. Em “File Name” clique nos 3 pontinhos, seleciona o arquivo nios2_project.qip e em seguida clicar em “Add”.

Figura 20
Figura 20: Adicionando o arquivo nios2_project. qip ao projeto.

Em seguida clicar em Apply e OK no fim da página. O próximo post explicarei como adicionar o componente nios2_project no projeto Top Level.

Até mais!

Processador Nios II – Desenvolvimento: Parte I

Olá,

No post anterior expliquei brevemente as características do processador Nios II embarcado em FPGAs da Altera.

Agora desenvolveremos uma aplicação simples de como criar o projeto do processador utilizando a IDE do Eclipse disponibilizado pela Altera quando instalado o software Quartus II. O projeto consistirá em 5 etapas:

  1. Criando projeto no Quartus II versão 13.0
  2. Criando periféricos no Qsys
  3. Adicionando e instanciando o componente Nios II no Top Level
  4. Criando Projeto no Eclipse
  5. Gravando os arquivos .sof e .elf no FPGA Cyclone II do Kit DE1.

Então mão na massa!

1)   Criando o projeto no Quartus versão 13.0

Eu já publiquei em posts anteriores como iniciar um projeto no Quartus II que pode ser encontrado aqui. Este projeto têm duas entradas  sendo i_clk50m (clock de entrada de 50MHz) e i_sw0 (chave de acionamento) e duas saídas sendo o_led (acionado dependendo do estava da chave) e o_led_blink (piscará na frequência de 1Hz).

Abaixo podemos verificar o top level do projeto:

--
-- Resumo  : Como criar um projeto no Nios II
--
-- Autor   : Alexandre Magalhães
-- Data    : 17/12/2015
--
-- Projeto : tutorial_nios.vhd
--
-- Entradas: i_clk50m e i_sw0
-- Saídas  : o_led e o_led_blink
--
-- Adicionando a biblioteca do IEEE
library ieee;
   use ieee.std_logic_1164.all;

-- Entidade do projeto
entity tutorial_nios is
port
   (
     i_clk50m : in std_logic;    -- Entrada de clock de 50MHz
     i_sw0 : in std_logic;       -- Chave ON/OFF
     o_led : out std_logic;      -- Led acionado dependendo do estada da chave
     o_led_blink : out std_logic -- Led piscando a 1Hz
   );
end tutorial_nios;

-- Arquitetura do projeto
architecture hardware of tutorial_nios is

-- Adicionar o componente NIOS II

begin

-- Instanciar o componente NIOS II

end hardware;

No código acima possui dois importantes comentários o primeiro é o “Adicionar o componente NIOS II” significa onde devemos adicionar o componente do Nios II e o segundo comentário “Instanciar o componente NIOS II” significa onde deverá ser instanciado o componente. Esta explicação será demonstrada no próximo tópico.

Até mais!