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!

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

LPCXpresso IDE – Instalação

Olá,

Após realizar o download da IDE LPCXpresso onde mencionei no post anterior, agora será demonstrado como instalar o software no seu computador pessoal.

A atual versão encontrada no site para Windows foi a 7.9.2. Portanto, devemos clicar duas vezes no arquivo “LPCXpresso_7.9.2_493.exe”. A primeira tela de instalação é exibida abaixo:

Figura_01
Figura 01: Início da Instalação.

A tela acima pergunta se desejar instalar o software, portanto clicamos em Sim”A próxima figura apresenta a tela de bem-vindo do setup de instalação, clique em “Next” para continuar o processo.

Figura_02
Figura 02: Tela de Bem-vindo.

Em seguida exibirá os termos da licença:

Figura_03
Figura 03: Termos da Licença.

Para prosseguir com a instalação selecionar a opção “I Accept the agreement” e em seguida “Next” e então aparecerá a tela “Information”.

Figura_04
Figura 04: informações.

Esta tela informa as configurações, ferramentas, etc que compõe a instalação da IDE. Após a leitura (se desejar) clicar em “Next”.

Figura_05
Figura 05: Endereço da Instalação.

Na figura anterior deve informar qual destino será instalado o software LPCXpresso, neste tutorial estarei utilizando o endereço default. Em seguida clicar em “Next” e então informará que o destino informado não exite.

Figura_06
Figura 06: Criar pasta.

Sendo assim devemos clicar em “Sim” para prosseguir com o processo de instalação. A seguir aparecerá a tela abaixo:

Figura_07
Figura 07: Drivers de Instalação.

A figura acima informa quais drivers o usuário deseja instalar, neste exemplo marcarei todos os disponíveis e em seguida “Next”.

Figura_08
Figura 08: Atalhos de Configuração.

Nesta tela pergunta onde deve colocar atalhos de configuração do programa. Clicar em “Next” para continuar com a instalação.

Figura_09
Figura 09: Tarefas Adicionais.

Essas tarefas adicionais deseja saber para quais usuários serão criados o ícone. E então exibirá a tela abaixo:

Figura_10
Figura 10: prono para instalação.

A figura acima deseja saber se o usuário está pronto para instalar o software no computador/notebook. Se sim, clicar em “Next”. E então  começará a instalar o programa.

Figura_11
Figura 11: Instalando o Software.

Durante procedimento acima será necessário instalar drivers para que q IDE possa comunicar com o mundo externo (USB, IHM, etc). Abaixo segue alguns exemplos durante a instalação.

Figura_12
Figura 12: Driver – Controladores USB.
Figura_13
Figura 13: Driver – Interface Humana
Figura_14
Figura 14: Driver – Portas (COM e LPT).
Figura_15
Figura 15: Driver – Code Red.
Figura_16
Figura 16: Driver – Pacote CDM.

Após instalar os drivers acima a próxima tela está exibido abaixo com informações que devem serem lidas e sem seguida clicar em “Next”.

Figura_17
Figura 17: Informações.

Chegamos ao fim da instalação conforme descrito na figura abaixo. Nela possui três caixas onde a primeira “Launch LPCXpresso v7.9” inicializa o software e as próximas duas caixas são documentos sobre o ambiente de desenvolvimento.

Figura_18
Figura 18: Término da Instalação.

Após selecionar ou não as caixas acima deve-se clicar em “Finish” para finalizar o processo de instalação.

Após abrir a IDE será necessário registrar a licença no site do fabricante.

Figura_19
Figura 19: Registrar a Licença.

Este registro é gratuito, porém possui algumas limitações durante o desenvolvimento de seu projeto, como exemplo, o debug tem o limite de 8k.

LPCXpresso IDE – Download

Olá galera,

Neste tópico demonstrarei como realizar o download do ambiente de desenvolvimento (IDE – Integrated Development Environment) LPCXpresso do fabricante NXP para programação de microcontroladores ARM. Para fazer o download basta clicar no link abaixo:

https://www.lpcware.com/lpcxpresso/download

 Após clicar no link abrirá a tela abaixo no navegador.

Figura 01
Figura 01: LPCXpresso IDE Downloads.

Em Products downloads (quadrado em vermelho) apresenta três sistemas operacionais para download, Windows, Linux e Mac OS X. Neste exemplo iremos fazer o download para SO Windows. Sendo assim, clicar em Windows download e abrirá a próxima tela abaixo:

Figura 02
Figura 02: LPCXpresso Current Version.

Nessa tela estão disponíveis a versão atual 7.9.2  e versões mais antigas sem precisar cadastrar no site e o tamanho é aproximando 410MB do arquivo para download.

No próximo post mostrarei de como instalá-lo no computador.

Até mais.

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