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 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!

O que é FPGA?

O que é FPGA?

Olá,

Bom dia! Boa Tarde! Boa Noite!

Neste texto falarei brevemente o que é FPGA (Field Programmable Gate Array – Arranjo de Portas Programável em Campo) onde eles são programados através de Lógica Programável para implementar circuitos digitais dedicados.

Figura_01
Figura 01: FPGA.

O FPGA foi desenvolvido em 1984 pela Xilinx para fins militares [1]. Desde então, o mercado vem crescendo mundialmente de US$ 1,9 bilhões em 2005 para US$ 2,75 bilhões em 2010[2]. Devido a esse grande aumento, hoje os FPGAs são largamente empregados nas indústrias automotiva através da tecnologia ADAS (Sistema Avançado de Assistência) aos motoristas, no setor das telecomunicações utilizados em transmissores de TV Digital, setor de multimídia para processamento de imagens em tempo real e alto desempenho, na medicina para diagnóstico, monitoramento e aplicações da terapia, onde necessitam de uma gama de processamento, e entre outros setores.

Os FPGAs são dispositivos semicondutores programáveis ​​que são baseados ao redor de uma matriz de CLBs (Configurable Logic Blocks – Lógica Blocos Configuráveis) conectados através de interconexões programáveis conforme demonstra a figura abaixo:

Figura_01
Figura 02: Estrutura interna do FPGA.

Os IOBs (Input Output Blocks – Blocos de Entradas e Saídas) são elementos que possuem buffers bidirecionais e flip-flops  onde podem ser configurados como registros de entradas e saídas.

As memórias RAM (Random Access Memory – Memória de Acesso Aleatório) são blocos disponíveis nas maiorias dos FPGAs que permitem a memória on-chip nos projetos.

O DCM (Digital Clock Management – Gestão Relógio Digital) é fornecido pela maioria dos FPGAs na indústria. Os FPGAs mais avançados da Xilinx fornece tanto de gestão DCM quanto no bloqueio  phase-looped que fornecem síntese de clock com precisão combinada com a redução de jitter e filtragem[3].

E por fim as IR (Interconnect Routing – Roteamento de Interconexão) são as conexões entre os CLBs e IOBs. Eles possuem trilhas para conectar as entradas e saídas dos CLBs e IOBs para as redes mais apropriadas.

Fabricantes

Existem duas grandes empresas que desenvolvem FPGA, Xilinx (49%) e Altera (40%), onde juntas domina o propósito geral da lógica programável com 89% de acordo com o gráfico abaixo:

Figura_03
Figura 03: Market Share.

Também possui outros fabricantes no mercado, a Lattice Semi (6%), Microsemi (4%) e QuickLogic (1%). A seguir um breve resumo das empresas [4].

 A empresa é líder no mercado de FPGAs com Market Share de $ 2,369.45 milhões. Suas famílias consiste nas séries-7  (Artix-7, Kintex-7 e Virtex-7) e os da série-6 (Virtex-6 e Sapartan-6). Em 2011 ganhou o prêmio “Highly Commended Prize” com o dispositivo Kintex-7.

Altera tem feito grandes progressos na conquista de quota de mercado nos últimos anos através de suas ferramentas e desempenho dos dispositivos. A empresa adquire um Market Share de $1,954.43 milhões de dólares. A série “Stratix” é a família de FPGAs de alto nível. No mid-range são as séries Arria, Cyclone completa com oferta de baixo custo.

A empresa Lattice Semiconductor aborda o baixo consumo de energia e mercado de baixo custo para FPGAs. Eles comercializam os seus produtos com “FPGAs de alto valor” da indústria, proporcionando melhor desempenho por custo com as séries  ECP3, ECP2, ECP2M. E possui um Market Share de $297.77 milhões de dólares.

Com Market Share de $207.49 milhões de dólares, Microsemi é especializada em baixo consumo de energia e de sinal misto FPGAs. Um diferencial principal está em sua tecnologia anti-fuse que está qualificado para tanto militares como voo espacial. Sua família Space-Grade consiste nas séries RTAX-S, SL, DSP, RT-ProASIC3 e dispositivos RTSX-SU.

O foco da QuickLogic está no setor de telefonia móvel que significa dispositivos ultra-baixo consumo de energia, embalagem fator de forma pequena, e projetar a segurança elevada e possui um Market Share de 26.20 milhões de dólares.

Evaluation Boards para Desenvolvimento

As empresas vem investindo no desenvolvimento de kits didáticos para usarem seus produtos (FPGAs, Microcontroladores, Microprocessadores), abaixo está listados dois Evaluation Board de baixo custo, sendo um da empresa Xilinx e o outro da Altera.

  • Spartan-6 LX9 MicroBoard

O Evaluation Board FPGA LX9 Microboard é de baixo custo, cerca de 89 dólares,é a solução perfeita para os designers interessados em explorar o processador MicroBlaze macio ou Spartan-6 FPGAs em geral.

Figura_04
Figura 04: Spartan-6 LX9.

Dados:

  • 10/100 Ethernet PHY
  • 128 Mb Multi-I/O SPI Flash
  • Chave DIP 4-bit
  • SDRAM 64 MB
  • 4 LEDs
  • On-board USB JTAG circuitry
  • Over-voltage and ESD protection on USB
  • Programmable clock chip
  • Reset and PROG push-buttons
  • Several pre-built MicroBlaze systems
  • Single-chip, 3-rail power with Power Good indicator
  • Spartan-6 XC6SLX9-2CSG324C FPGA
  • Two Digilent Pmod™ compatible headers (2×6)
  • USB-to-UART port

 

  • DE0-Nano Development and Education Board

A DE0-Nano de apenas 79 dólares introduz uma plataforma de desenvolvimento FPGA de tamanho compacto, adequado para projetos de circuitos prototipagem, como robôs e projetos “portáteis”. A placa é desenhado para ser utilizado na implementação mais simples possível direcionamento do dispositivo ciclone IV de até 22.320 elementos lógicos.

Figura_05
Figura 05: DE0-Nano.

Dados:

  • 22,320 elementos lógics (LEs)
  • Memória embarcada 594 (Kbits)
  • 66 multiplicadores 18 x 18
  • 4 General-purpose PLLs
  • 153 pinos de I/O
  • On-board USB-Blaster circuit for programming
  • FPGA Serial Configuration Device (EPCS)
  • 2x 40-pin Headers (GPIOs) provides 72 3.3V I/O pins
  • Alimentações 5V e 3V3
  • 32MB SDRAM
  • 2Kb I2C EEPROM
  • 8 verdes LEDs
  • 2 debounced push-buttons
  • 4 chaves dip
Referências Bibliográficas

[1] http://www.ni.com/white-paper/6984/pt/

[2] The Field-Programmable Gate Array (FPGA): Expanding Its Boundaries, InStat Market Research, April 2006

[3] http://www.xilinx.com/fpga/

[4] http://www.fpgadeveloper.com/2011/07/list-and-comparison-of-fpga-companies.html