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!

Anúncios

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!

Processador Nios II – Introdução

O Nios II é um processador softcore de 32 bits de arquitetura Harvard com conjunto de instruções reduzidas (RISC) desenvolvida pela Altera. O processador é um sistema em hardware embarcado unindo o poder do software e hardware ao mesmo tempo.

O Nios II é baseado em lógica programável em FPGA através do software Quartus II e o software Qsys/SOPC Builder. A figura a seguir ilustra a arquitetura interna de hardware do processador com  a unidade do núcleo (core), as memórias (SDRAM, SRAM, Flash), interfaces de comunicação e interfaces de entradas e saídas.

niosii
Sistema do Processador Nios II.

A seguir estão listadas algumas características do Nios II:

  • Set de instruções de 32 bits;
  • Registros de propósito geral de 32 bits;
  • Fontes de 32 interrupções;
  • Memory Management Unit (MMU);
  • Memory Protection Unit (MPU);
  • Debug através do JTAG
  • Memória no chip (On-Chip Memory);
  • Frequência até 200MHz.

O processador Nios II é equivalente a um microcontrolador que inclui uma combinação de periféricos e memórias em um único chip. O ambiente de desenvolvimento é baseado no GNU C/C++ e o Software Build Tools (SBT) para Eclipse.

O QSYS é um GUI (Graphical User Interface) que habilita as configurações do Nios II, tais como números de periféricos e memórias, espaçamento de endereços, controladores de Ethernet, UART, etc. Após criá-lo é gerado um arquivo HDL que deverá ser instanciado no Top Level de seu projeto.

Estarei demonstrando no próximo post como criar um projeto em FPGA utilizando o processador Nios II.

Até mais!