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

Visualizadores de Netlist no Quartus II

Olá pessoal,

Neste post explicarei um pouco sobre as funcionalidades dos visualizadores de Netlist disponíveis no software Quartus II.

Os visualizadores são RTL (Register Transfer Level) Viewer, State Machine Viewer e Technology Map Viewer onde eles permitem visualizar em forma de esquemático seu projeto após a primeira Analysis & Elaboration para projetos que utilizam Verilog (.v), VHDL (.vhd), Text Design Files (.tdf) ou Block Design Files (.bdf). Para projetos extensos, complexos ou trabalhar em um projeto desenvolvido por outras pessoas, essas ferramentas são muitos úteis para compreender o projeto como todo.

RTL Viewer e Technology Map Viewer fornecem uma lista hierarquíca do projeto e links para uma vista esquemática onde são exibidos os componentes dos elementos do projeto. A lista de hierarquia expande enquanto você navega através da visão esquemática com as opções Back (Voltar) e Forward (Avançar) em cada parte do seu projeto.

Abaixo segue um código em VHDL de projeto que consiste em um Registrador de entrada serial e saída paralela.

-- Inclusão de Bibliotecas
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

-- Entidade
entity RTL_Viewer is
port ( 
 iCLOCK : in std_logic; -- Clock de 27MHz 
 iRESET : in std_logic; -- Reset do circuito
 iENTRADA : in std_logic; -- Entrada de Dados
 oSAIDAS : out std_logic_vector(3 downto 0) -- Saída de Dados
); 
end RTL_Viewer;

-- Arquitetura
architecture Behavior of RTL_Viewer is

-- Signals
signal sSAIDAS : std_logic_vector (3 downto 0);

begin

-- Processos
Processo_Principal: 
process (iCLOCK, iRESET)
begin
 
  if iRESET = '1' then
    oSAIDAS <= (others => '0');

  elsif rising_edge (iCLOCK)then
    sSAIDAS (0) <= iENTRADA;
    sSAIDAS (1) <= sSAIDAS (0);
    sSAIDAS (2) <= sSAIDAS (1);
    sSAIDAS (3) <= sSAIDAS (2);

  end if;
 
oSAIDAS <= sSAIDAS;

end process;

end Behavior;

Para criar um projeto no Quartus II veja o post aqui. Para compilar o projeto devemos ir em “Processing => Start Compilation” ou “Crtl + L“, ou então fazer somente a Analysis & Elaboration.

Figura01
Figura 01: Compilando o Projeto.

Após compilar o projeto podemos verificar o RTL Viewer do projeto em “Tools => Netlist Viewer => RTL Viewer“.

Figura02
Figura 02: Visualizando o RTL Viewer.

Visualizando o resultado.

Figura03
Figura 03: Resultado RTL Viewer.

Após o resultado, podemos observar as entradas e as saídas utilizando o Flip-Flop tipo D (Data) do projeto em VHDL.

A seguir podemos visualizar o Technology Map Viewer em “Tools => Netlist Viewer ” obtendo uma visão mais ampla do circuito combinacional.

Figura04
Figura 04: Resultado Technology Map Viewer.

Esta visualização podemos verificar a entrada serial e saída paralela com clareza. Outra característica importante quando clicamos por exemplo na entrada iRESET verificamos em linha vermelha sua utilização no circuito.

Figura05
Figura 05: Entrada iRESET.

Imaginamos se o projeto estiverem componentes adicionados ao Topo de Hierarquia. A seguir possui um código onde estão sendo adicionados dois componentes sendo um de uma porta AND e o outro uma porta XOR.

-- Inclusão de Bibliotecas
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

-- Entidade
entity RTL_Viewer is
port ( 
 -- Entrada de Dados
 iENTRADA_A : in std_logic; 
 iENTRADA_B : in std_logic; 
 
 -- Entrada de Dados 
 oSAIDA_AND : out std_logic;
 oSAIDA_XOR : out std_logic
); 
end RTL_Viewer;

-- Arquitetura
architecture Behavior of RTL_Viewer is

-- Signals
signal sENTRADA_A : std_logic;
signal sENTRADA_B : std_logic;
signal sSAIDA_AND : std_logic;
signal sSAIDA_XOR : std_logic;

-- Componentes
-- Porta and
component PORTA_AND is
port( 
 iENTRADA_A : in std_logic; -- Entrada de Dado A
 iENTRADA_B : in std_logic; -- Entrada de Dado B
 oSAIDA : out std_logic -- Saída de Dados
 );
end component;

-- Porta xor
component PORTA_XOR is
port( 
 iENTRADA_A : in std_logic; -- Entrada de Dado A
 iENTRADA_B : in std_logic; -- Entrada de Dado B
 oSAIDA : out std_logic -- Saída de Dados
 );
end component;

begin

-- Instanciamento dos componentes
logic_and: PORTA_AND port map(
 iENTRADA_A => sENTRADA_A,
 iENTRADA_B => sENTRADA_B,
 oSAIDA => sSAIDA_AND
);

logic_xor: PORTA_XOR port map(
 iENTRADA_A => sENTRADA_A,
 iENTRADA_B => sENTRADA_B,
 oSAIDA => sSAIDA_XOR
);

--Atribuiçoes de Sinais
sENTRADA_A <= iENTRADA_A;
sENTRADA_B <= iENTRADA_B;
oSAIDA_AND <= sSAIDA_AND;
oSAIDA_XOR <= sSAIDA_XOR;

end Behavior;

Na entidade do projeto possui duas entradas (iENTRADA_A e iENTRADA_B) onde cada uma delas estão conectadas nas entradas A e B das portas lógicas AND e XOR e duas saídas (oSAIDA_AND e oSAIDA_XOR) onde elas estão conectadas nas saídas das portas lógicas.

Após compilar o projeto podemos verificar o RTL Viewer do projeto como demonstra a figura a seguir:

Figura06
Figura 06: Análise RTL Viewer.

Após a análise do RTL Viewer podemos verificar os dois componentes sendo instanciados no projeto. Ao clicar duas vezes em cada uma delas são exibidos seus componentes internos de acordo com as figuras 7 e 8:

Figura07
Figura 07: PORTA_XOR.
Figura08
Figura 08: PORTA_AND.

E a seguir o Technology Map Viewer do projeto sendo semelhante ao RTL Viewer.

Figura09
Figura 09: Technology Map Viewer.

Estas poderosas ferramentas fornecem os resultados iniciais e totalmente mapeadas durante a síntese, depuração, otimização e/ou restrições de processos de entrada.

Deixo aqui uma documentação da Altera sobre o assunto com explicações de como usar os Visualizadores de Netlist (Netlist Viewers).

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

DDS – Parte Prática I: Dados do Sintetizador

Frequência de Amostragem

Após uma pequena introdução do sintetizador DDS iremos colocar a mão na massa. Portanto, nós devemos saber qual será a frequência de saída e então levantar os parâmetros do sistema.

Como exemplo, 0 nosso projeto sintetizador DDS deverá ter uma frequência de saída 10kHz (Fmáx). Segundo a Equação de Nyquist a frequência de amostragem dever ser maior ou igual a duas vezes da frequência máxima.

F∝ ≥ 2. Fmáx

F∝ ≥ 2. 10kHz

F∝ ≥ 20kHz

Portanto, a frequência de amostragem deverá ser no mínimo 20kHz. Para o projeto iremos utilizar 50MHz disponível no kit DE1 atendendo o Teorema de Nyquist.

 Acumulador de Fase (ω)

Em seguida calcularemos o valor do Acumulador de Fase (ω). Para isto, é necessário obter algumas informações, tais como número de bits (N) do Acumulador e as frequências de entrada e saída. Neste exemplo utilizaremos 32 bits para o Acumulador.

ω = (Fmáx . 2^N) / F∝

ω = (10kHz . 2^32) / 50MHz

ω = 858993,4592

Após obter o valor ω podemos saber qual será a real frequência de saída substituindo-o na equação acima e o erro de frequência:

ω = (Fmáx’ . 2^N) / F∝

858993 = (Fmáx’ . 2^32) / 50MHz

Fmáx’ = 9999,99465Hz

Logo o erro de frequência será:

ε = Fmáx’ / Fmáx

ε = 9999,99465Hz/ 10000Hz

ε =0,999999465

Portanto, o nosso código em VHDL para o Acumulador de Fase ficará conforme demonstrado abaixo sendo executado em um processo com sensibilidade ao clock de entrada (F∝) de 50MHz: 

Acumulador_de_fase:
process(iCLK)
begin

  if (rising_edge (iCLK)) then
 
    phase_acc <= phase_acc + 858993;

  end if; 

end process;
Conversor D/A e Look-up-Table

O Conversor  D/A foi utilizado do Microcontrolador LPC1768 da NXP com resolução de 10 bits. Sendo assim a LUT (Look-up-Table) obterá 1024 posições (2^10).

A função da LUT converterá os valores entregue pelo Acumulador de Fase em valores de amplitude para o conversor D/A. Abaixo segue um pequeno trecho do código da LUT em VHDL:

process(reset,clk)
begin

  if(reset = '1')then
    sin_data_int <= (others => '0'); 
 
  elsif(rising_edge(clk)) then
 
    if clk_en = '1' then
      sin_data <= sin_data_int; 
 
      case lut is 
        when 0 => sin_data_int <= ("1000000000"); 
        when 1 => sin_data_int <= ("1000000011"); 
        when 2 => sin_data_int <= ("1000000110"); 
        when 3 => sin_data_int <= ("1000001001"); 
        when 4 => sin_data_int <= ("1000001100"); 
        when 5 => sin_data_int <= ("1000001111"); 
        when 6 => sin_data_int <= ("1000010010"); 
        when 7 => sin_data_int <= ("1000010101"); 
        when 8 => sin_data_int <= ("1000011000"); 
        when 9 => sin_data_int <= ("1000011011"); 
        when 10 => sin_data_int <= ("1000011110");
        .
        .
        .
        when 1022 => sin_data_int <= ("0111111101"); 
        when 1023 => sin_data_int <= ("1000000000"); 
        when others => null;
      end case;
    end if; 
  end if; 
end process;

E abaixo o código do conversor D/A:

// Programa Principal
int main(void) 
{
  SystemInit(); // Configura os recursos básicos do microcontrolador. 
  NVIC_SetPriorityGrouping (0b010);
  Config_DAC(); // Chama a rotina de configuração do DAC

  // Ao infinito e além ...
  while(1) 
  {
    LPC_DAC->DACR = ((LPC_DAC->DACR &~(0x3FF<<6)) | (Digital_Input<<6));
  }
  return 0 ;
}

Conforme descrito anteriormente o Acumulador de Fase possui 32 bits e o Conversor D/A possui 10 bits. Então usaremos os 10 bits mais significativos (msb) do Acumulador para serem enviados para endereçar a LUT.

Acumulador_de_fase:
process(iCLK)
begin

  if (rising_edge (iCLK)) then
 
    phase_acc <= phase_acc + 858993;
    value_lut <= phase_acc(31 downto 22);

  end if; 

end process;

Neste momento iremos simular o código em VHDL utilizando o software Modelsim. A Figura 01 apresenta o sinal na saída do Acumulador de Fase (oDATA_SEN) e também podemos analisar a frequência de saída:

Figura01
Figura 01: Sinal na saída do FPGA.

O cursor na vertical em amarelo na Figura 01 verificamos o tempo de 1 ciclo do seno sendo em 100039911ps. Fazendo o inverso do período obtemos uma frequência de 9996,0104Hz.

No próximo tópico mostrarei o resultado no osciloscópio.

Até mais!

<=Anterior