[Jack] wrote in to let us know about a project that creates a virtual microprocessor core based on the ATmega103 by using a Field-Programmable Gate Array. Great, we thought. Here’s another rather esoteric project like the NES on a FPGA, but what’s the motivation behind it? We asked [Jack] and he provided several scenarios where this is quite useful.

Implementing the AVR core allows code already written for the chips to be easily ported to an FPGA without a code rewrite. This way, if your needs outpaced the capabilities of the microcontroller long after the project has started, you can keep the code and move forward from that point with the added capabilities of the gate array. Having the core already implemented, you then only need to work with HDL for the parts of the project the AVR was unable to handle. He also makes the point that having an open source AVR core implementation provides a great tool for people already familiar with AVR to study when learning VHDL.

With products like the Butterfly that this project is based around, or the Maple we’ve seen in the past, programmable logic for the recreational hacker is starting to get a little easier.

VHDL ou “VHSIC Hardware Description Language” (Linguagem de descrição de hardware VHSIC “Very High Speed Integrated Circuits“) é uma linguagem usada para facilitar o design (projeto/concepção) de circuitos digitais em FPGAs e ASICs.

É uma linguagem para projetar circuitos eletrônicos lógicos, se assemelha um pouco com pascal e tem como objetivo padronizar o modo de programar circuitos integrados de diferentes fabricantes de um modo padronizado, isto é, o que você projeta em VHDL poderá ser usado em qualquer circuito integrado sem reescrita de código.

Mas a princípio, quem não tem muita experiência em sistemas embarcados pode se perder totalmente com a linguagem e de como utilizar. Um dos maiores problemas é aprender a usar as bibliotecas para começar a trabalhar, e alguns conceitos. Uma vantagem enorme é que a construção por meio de código é bem simplificada em relação ao projeto totalmente feito com símbolos primitivos e até mesmo substituindo decodificadores e contadores facilmente.

Tutorial em português de VHDL: VHDL pt

Outras fontes em inglês:

1. Rapid Prototyping of Digital Systems 2002 Hamblen & Furman
2. (Delmar) Digital Design with CPLD Applications & VHDL
3. McGraw Hill VHDL Programming by Example 4th.Ed
4. VHDL_Beginners_Book

A wikipédia tem bons exemplos em Português, mas nada se compara com a versão em inglês

Here is a short example for the Makefile I’m currently using to compile and test my VHDL project:

.PHONY: all clean testbench
 
VCDFILE = tmp
STOPTIME = 42ns
DEBUG = --vcd=$(VCDFILE) --stop-time=$(STOPTIME)
CLEANUP = rm -f $(VCDFILE)
OBJS = clock.o
TARGET =
 
all:
        make test
 
clean:
        ghdl --clean
 
testbench:
        ghdl -m $(TARGET)
        ghdl -r $(TARGET) $(DEBUG)
        gtkwave $(VCDFILE)
        $(CLEANUP)


Which is used in a terminal (providing you have gtkwave and ghdl installed) as follows:

$ make testbench TARGET=Chien_tb

Hoping to be useful, I’ll retire. I’ll be back in a few weeks with more details.

VHDL & LINUX

Dentro de mi poca experiencia en linux una de las cosas mas complicadas  que me ha tocado experimentar es el compilar y simular en en VHDL (Very High Speed Integrated Circuit), llegue   incluso a  recurrir a la emulacion  o virtualizacion de compiladores como Xilixs o Quartus, sin embargo googlenado un poco  y con muchas horas de practica logre desde la consola de mi linux generar simulaciones en este lenguaje. Dejo a continuacion un link con los paquetes necesarios para la compilacion y simulacion de un proyecto http://packages.ubuntu.com/, si usas ubuntu puedes desde synaptic buscar los paquetes GTKWave o bien utilizar:

$ sudo aptitude install ghdl
$ sudo aptitude install gtkwave

Si usas otra distribución, puedes verificar si encuentras el codigo fuente, en la excelente página de Roberto Aragón se puede encontrar información y ayuda, el enlace es el que sigue:

http://web.madritel.es/personales4/raragon/vhdl/t1.html

A continuacion les comento de  algunos comandos utiles para  compilar nustros proyectos y claro para  generarla simualcion de los mismos, GHDL dispone de un método muy sencillo para detectar las dependencias entre ficheros (la opción -i) y para elaborar la unidad de simulación (la opción -m). Si dispones de todos los ficheros fuente de la unidad, ejecutando:

$ ghdl -i *.vhd

importarás todos los componentes definidos en los ficheros.  Una vez generado este fichero, GHDL ya sabe las dependencias entre entidades, arquitecturas y configuraciones de tu unidad y es capaz de generarla. Para ello sólo tienes que ejecutar la orden:

$ ghdl -m unidad-de-simulación

Para simular el recién creado modelo, puedes ahora generar un fichero de onda (VCD) y después verlo con GTKWAVE o ejecutar al mismo tiempo ambos programas. Para el primer caso primero ejecuta:

$ ./adder_tb –vcd=adder.vcd

a lo que el sistema responderá:

adder_tb.vhdl:52:7:(assertion note): end of test

lo que significa que la simulación ha terminado con éxito. Se habrá creado el fichero adder_tb.vcd que contiene un seguimiendo de onda cuadrada en respuesta a la simulación. Para poder verlo y verificar los datos ejecuta:

$ gtkwave adder.vcd

y usa las opciones de menú en Search->Signal Search…para añadir señales y poder verificar las salidas del modelo. Si estás usando la versión 2.0.0pre3 de gtkwave y dispones de un fichero con trazas salvadas de una anterior ejecución (p.e. llamado adder.trc) puedes ejecutar la simulación cargando automáticamente las trazas con la llamada:

$ gtkwave adder.vcd adder.trc

Para ejecutar la simulación y al mismo tiempo ver la onda también puedes usar:

$ ./adder_tb –vcd=- | gtkwave -vcd

Arrancará directamente GTKWAVE, de modo que puedas añadir las señales que quieras, y comprobar que tu modelo funciona adecuadamente.

Yo tarde mucho encontrando esta información en Google, y este post es  únicamente para  facilitar a  aquellos  googleros que necesiten esta información de  forma mas rápida y sencilla. En caso de que tengan alguna duda sobre el lenguaje, algún proyecto que no salgo o quieran simplemente compartir  un poco de información dejen  un comentario para   hacer el post correspondiente.

edito!!  sabado 28 de Noviembre 2009

Agradezco a la comunidad http://chitlesh.fedorapeople.org/FEL/ por el apoyo mostrado, ademas  que  los screenshots pertenecen a esta web.

]]> http://benoztalay.wordpress.com/2009/11/14/coding-has-begun/ Sat, 14 Nov 2009 05:45:20 +0000 lilozzy http://benoztalay.wordpress.com/2009/11/14/coding-has-begun/

I began coding certain elements of the OZ-3 in the last couple of weeks. It’s been going alright; I had to look back at my Logisim schematics to remember just how some parts work! I coded the smaller components, such as generic falling- and rising-edge triggered registers that can be sized according to their purpose. Also, I’ve done the ALU and condition block. Unfortunately, since I made up the schematics, I’ve forgotten the reasons behind various buffers that keep everything timed correctly (i.e., an instruction’s data doesn’t get to a stage in the pipeline too soon). This caused confusion on my part when programmed these buffers into the EX and WB stages.

I’ve adopted a coding style that incorporates behavioral architectures on smaller-scale items, such as the ALU and registers, while using a structural approach to larger pieces, such as the pipeline stages. I did it this way because it allows me the most control over how things go together while still giving the synthesis tools room for optimization that I may not think of. For example, the EX stage of the OZ-3 has a handful of components: the ALU, ALU A and B input registers, the condition block, and a register that acts as a buffer for the ID stage’s control signals. I coded all of those components behaviorally, then studied my schematics to put the pieces together structurally to create the whole stage.

I suppose I ought to spell out how the OZ-3 operates in more detail at this point. The instruction fetch stage gets the instruction from instruction memory, then passes that instruction the instruction decode stage in the next cycle. All data are gathered during the rising edge of the clock (as in, the registers that separate each stage are rising-edge triggered), and processed in the second half of the cycle. During the instruction decode stage, everything instruction will do is sorted out, then all of the control signals go out to each stage, where they’re put into buffers to wait until the instruction gets to the stage. For instance, the MEM stage has a two-stage buffer because the instruction needs to finish two stages until it gets to MEM. I’ve structured everything to accept an instruction of all zeroes as “do nothing”. For instance, if the condition block receives “000″ as the condition being tested, it automatically outputs ‘1,’ allowing the instruction to go through.

There is one big roadblock that I know I will run into while creating the VHDL code for this processor. Since the development board I’m using has both Flash memory and RAM resources, I’m using the Flash to store programs and the RAM as regular data memory. Both are organized as 8Mbytes x 16bits, but my instructions are 32 bits long, which means that I’ll need to extend the instruction fetch stage to two stages. Beyond that, I also need to learn how to use these components. I’ll need to create a writer for the Flash so that I can load programs into it, which may or may not include interfacing with the host computer. I’ll need to get rid of the old load and store instructions for the memory because those store and load whole 32-bit words, while I can only run those operations with half words. The new instructions I’ll be replacing those with are: load upper, load lower, store upper, store lower. What these will do is load 16 bits at an address to the upper or lower half of a register, or store the upper or lower half of a register into an address in memory.

Currently, I have the execution and writeback stages complete and simulated successfully. I’m going to delve into datasheets on Intel StrataFlash and the Micron pseudo-dynamic RAM module to figure out how they work. The development board’s user manual provides a fair explanation of them, but I want to get more detail before I start synthesizing anything. The next item on the list is creating a Flash and RAM reader/writer/tester. After that, I’ll have a good grasp of those components, as well as a useful tool for my board.

Ben Oztalay

Introdução

Este texto tem como objetivo principal listar todos os principais elementos que constituem a linguagem VHDL.

>>> Artigo em edição <<<

Entity

Uma entity define um bloco – suas entradas e suas saídas.

Declaração:

entity <nome_da_entidade> is

port (

signal <nome_do_sinal_1>: <sentido_do_sinal> <tipo_do_sinal> := <valor_inicial>;

signal <nome_do_sinal_n>: <sentido_do_sinal> <tipo_do_sinal> := <valor_inicial>

)

end entity <nome_da_entidade>;

A declaração das entradas/saídas da entidade  é feita através da declaração port (opcional).

Para especificação de tipo do sinal vide Seção Tipos.

Sentido do sinal: in (entrada), out (saída), inout / buffer (porta bidirecional)

Architecture

Uma architecture define o ‘comportamento’ de uma entidade, ou ainda as conexões  entre a entidade e seus  componentes.

Declaração:

architecture <nome_da_architecture> of <nome_da_entidade> is

<declaração dos sinais>

<declaração dos generics>

<declaração dos componentes>

begin

<processos>

end architecture <nome_da_architecture>;

Processos

Processos são blocos de código concorrentes presentes em um architecture que podem ser sensíveis a sinais pré-especificados.

Declaração:

<nome_do_processo>: process is

begin

<laços/operações>

end process <nome_do_processo>;

Tipos de dados

O Diagrama a seguir exibe a árvore de tipos de dados  utilizada na  linguagem VHDL

• constants

constant <nome_da_constante>: <tipo_da_constante> := <valor>;

• variables

variable <nome_da_variável>: <tipo_da_variável> := <valor_inicial>;

Atribuição:

<nome_da_variável> := <valor>;

• signals

signal <nome_do_sinal>: <sentido_do_sinal> <tipo_do_sinal> := <valor_inicial>

Atribuição:

<nome_do_sinal> <= <valor>;

Caso o sinal seja interno, isto é, se definido dentro de uma architecture, o sentido do sinal é desnecessário  (ele não faz parte do corpo da identity e, portanto, não se conecta externamente a nenhum sinal).

Atributos de sinais

<Nome_do_Sinal>‘delayed(<Tempo>) – Valor do sinal atrasado em <Tempo> unidades de tempo
<Nome_do_Sinal>’stable(<Tempo>) – True se nenhum evento ocorrer sobre o sinal <Nome_do_Sinal> nos últimos <Tempo> unidades de tempo
<Nome_do_Sinal>‘quiet(<Tempo>) – True se o sinal <Nome_do_Sinal> se mantiver constante por <Tempo> unidades de tempo
<Nome_do_Sinal>‘last_value – Valor do sinal <Nome_do_Sinal> antes da última variação/mudança
<Nome_do_Sinal>‘last_event – Instante no qual o sinal <Nome_do_Sinal> sofreu alteração pela última vez
<Nome_do_Sinal>‘last_active – Instante no qual o sinal <Nome_do_Sinal>esteve ativo na última vez
<Nome_do_Sinal>‘event – True se um evento ocorreu no sinal <Nome_do_Sinal> no ciclo corrente
<Nome_do_Sinal>‘active – True se o sinal <Nome_do_Sinal> está ativo no ciclo corrente
<Nome_do_Sinal>‘transaction – Valor de bit alterado a cada vez que o sinal <Nome_do_Sinal> sofre alterações

• files

Tipos de dados escalares

Definição de inteiros, floating point e tipos físicos

Definições genéricas de tipo podem ser utilizadas para definir inteiros, floating point e tipos físicos.

type <nome_do_tipo> is range <limite_inferior> to <limite_superior>

units

<nome_da_unidade>; l

end units <nome_do_tipo>;

A seção units é opcional.

Sistema Numérico

B”<Valor_Binário>”

O”<Valor Octal>”

X”<Valor Hexadecimal>”

D”<Valor decimal>”

tipos enumeration

type <nome_da_enumeração> is

(<nome_1>, <nome_2>,<nome_3>,…);

characters

O tipo caracter é definido na linguagem como a enumeração de todos os caracteres da tabela ASCII.

variable <nome_da_variável>: character;

booleans

O tipo booleano é definido por

type boolean is (false,true);

bits

O tipo bit é definido por

type bit is (‘0′,’1′);

standard_logic

Este tipo é definido no pacote std_logic_1164. É definido por

type std_ulogic is (

‘U’, — Uninitialized: Não inicializado

‘X’, — Desconhecido forçado

‘0′, — Zero forçado

‘1′, — Um forçado

‘Z’, — Alta impedância

‘W’, — Desconhecido fraco (Weak)

‘L’, — Zero fraco (Low)

‘H’ — Um fraco (High)

‘-’ — Não importa

);

Subtipos

Definição de subtipo:

subtype <nome_do_subtipo> is <tipo> range <limite_inferior> to <limite_superior>

Declaração de variável com subtipo:

variable <nome_da_variavel>: <nome_do_subtipo) := <valor_inicial>;

Atributos de escalares

<Nome_do_sinal>’left - primeiro (mais a esquerda) valor em <Nome_do_sinal>

<Nome_do_sinal>’right - último (mais a direita) valor em <Nome_do_sinal>

<Nome_do_sinal>’low - menor valor em <Nome_do_sinal>

<Nome_do_sinal>’high - maior valor em <Nome_do_sinal>

<Nome_do_sinal>’ascending - True se <Nome_do_sinal> está em uma faixa ascendente, False caso contrário

<Nome_do_sinal>’image(x) – string representando o valor de x

<Nome_do_sinal>’value(s) – o valor em <Nome do Sinal> que é representado por s

Aplicados apenas a tipos discretos ou físicos:

<Nome_do_sinal>‘pos(x) – número da posição x em <Nome_do_sinal>

<Nome_do_sinal>‘val(n) – valor em <Nome_do_sinal> na posição n

<Nome_do_sinal>’succ(x) – valor em <Nome_do_sinal> na posição um a mais que a de x

<Nome_do_sinal>‘pred(x) – valor em <Nome_do_sinal> na posição um a menos que a de x

<Nome_do_sinal>‘leftof(x) – valor em <Nome_do_sinal> na posição um a esquerda de x

<Nome_do_sinal>‘rightof(x) – valor em <Nome_do_sinal> na posição um a direita de x

Array / Vetores

array <faixa> of <subtipo>

A faixa é definida por:

<limite_inferior> to <limite_superior>

<limite_superior> downto <limite_inferior>

Multidimensional

type <nome_da_matriz> is array (<array_1>,<array_2>,…) of <tipo_definido>;

A matriz pode ser indexada através de

nome_da_matriz(<index_array_1>,…);

Atributos de vetores

<Nome_do_Sinal>‘left(N) – Limite esquerdo da faixa de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘right(N) – Limite direito da faixa de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘low(N) – Limite inferior da faixa de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘high(N) – Limite superior da faixa de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘range(N) – Faixa do índice de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘reverse_range(N) – Reverso  do índice de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘length(N) – Comprimento do índice de dimensão N do sinal <Nome_do_Sinal>

<Nome_do_Sinal>‘ascending(N) – True se faixa do indice de dimensão N de <Nome_do_Sinal> está em uma faixa acendente, Falso caso contrário

<Nome_do_Sinal>‘element(N) – Elemento subtipo de<Nome_do_Sinal>

Registro

type <Nome_do_registro> is record

<Nome_do_elemento1>: <tipo> range <limite_inferior> <limite_superior>;

<Nome_do_elemento2>: <tipo> range <limite_inferior> <limite_superior>;

<Nome_do_elementon>: <tipo> range <limite_inferior> <limite_superior>;

end record <Nome_do_registro>;

variable <Nome_da_variável>: <Nome_do_registro>

Acesso a elementos do registro:

<Nome_do_registro>.<Nome_do_elemento1>

Casting

to_string (<valor>)

to_ostring

to_hstring

integer_vector

bit_vector

Funções internas

retorna o máximo valor de um vetor, string, lista

Máximo

maximum(<value1>,<value2>,…,<valuen>)

retorna o máximo valor de um vetor, string, lista

Mínimo

minimum(<value1>,<value2>,…,<valuen>)

retorna o mínimo valor de um vetor, string, lista

After

A transferência do valor de sinal para o sinal de saída ocorre somente após <tempo> unidade de tempo.

<Nome_do_Sinal> = <valor> after <tempo>;

When

A transferência do valor de sinal para o sinal de saída ocorre de acordo com as cláusulas especificadas.

<Nome_do_Sinal> = <valor1> when <cláusula,variável> else <valor2>;

Wait

A expressão wait congela o processo até que haja alteração no sinal <Nome_do_Sinal> até determinada condição ocorrer (until) ou ainda por um determinado período de tempo <tempo> unidades de tempo.

Wait on <Nome_do_Sinal> | until <condition> | for <tempo>

Delta delay – wait until

Modelos de atraso

Transport

Este mecanismo de atraso modela uma atraso em que não importa a largura do pulso, a saída representará um pulso idêntico atrasado.

<Nome_do_Sinal> transport <valor, expressão> after <tempo>

Inertial

Circuitos eletrônicos reais não possuem resposta em freqüência infinita, além disso possuem alguma inércia, ou seja, eles tendem a se manter no mesmo estado a menos que alguma estado aplicado nas suas entradas permaneça por um determinado período.

O ofeito deste mecanismo de atraso é o seguinte: caso o sinal de entrada não permaneça no mesmo estado por pelo menos <tempo> unidades de tempo, a saída não se altera.

<Nome_do_Sinal> inertial <valor, expressão> after <tempo>

Uma atribuição de sinal em que haja omissão do mecanismo de atraso possui atraso inercial.

Exemplo de saídas para atraso inertial e transport, neste caso a largura do primeiro pulso não supera o atraso para o caso de atraso inercial, logo o sinal não é transferido para a saída.

Reject

Este mecanismo ‘rejeita’ a atribuição caso o sinal não permaneça no mesmo estado por <tempo> unidades de tempo.

<Nome_do_Sinal> reject <tempo> <valor, expressão>

Laços

Laço loop

Representa a priori  um laço infinito.

Declaração:

loop;

<expressões>

end loop;

Função next

Declaração:

Esta expressão interrompe e reinicia a execução do laço.

next;

Função exit

Esta expressão interrompe o laço definitivamente.

Declaração:

exit;

Laço Case

Permite a execução de determinados procedimentos de acordo com o valor do sinal <nome_do_sinal>.

Em alguns softwares que transcrevem o código para rtl, devido a possíveis limitações de dispositivos cpld/fpgas, exige-se que todas as possibilidades sejam tratadas através da condição when others.

Declaração do ‘laço’ case

case <nome_do_sinal>

when <value_1> =>

<expressões>

when <value_2> =>

<expressões>

when others => – condição opcional

<expressões>

end case;

Outra forma de declarar um ‘laço’ condicional case é utilizar o ‘laço’ with.

Declaração do ‘laço’ with

with <nome_do_sinal>

<variável> := <valor1> when <valor01>,

<valor2> when <valor02>,

<valorn> when <valor0n>;

Se nenhum procedimento é necessário, e, no entanto, todos os casos precisem de algum tipo de tratamento, recomenda-se a utilização da expressão

Null;

Laço if

if <condição> then

<expressões>

elsif <condição> then

<expressões>

else

<expressões>

end if;

Laço While

while <condição> loop

end loop;

for <variável> in  <lim_1> to/downto <lim_2> loop

end loop;

Componentes

Entidade principal:

Junto com os sinais declare o componente

component <Nome_do_componente> is

port (

signal <nome_do_sinal_i>: <sentido_do_sinal> <tipo_do_sinal> := <valor_inicial>

)

end component;

No architecture instancie e conecte os sinais as portas do componente

<nome_da_instancia>:  component <nome_da_entidade_componente>

port map ( <sinal1>, <sinal2> );

Funções

function<Nome_da_função> (<parameter1>,<paremeter2>) return <tipo_parametro_retorno> is

variable <Nome_variavel_retorno>:  <tipo_variavel_retorno>;

begin

<declarações>

return <Nome_variavel_retorno>;

end function <Nome_da_função>;

Procedimentos

procedure <Nome_do_procedimento> (<parameter1>,<paremeter2>)  is

begin

<declarações>

end procedure <Nome_do_procedimento>;

Pacotes

Declaração de pacote:

package <Nome_do_pacote> is

<declarações do pacote>

end package <Nome_do_pacote>;

Standard Packages

• standard
• env
• textio
• math_real
• math_complex
• std_logic_1164
• numeric_bit
• numeric_std
• numeric_bit_unsigned
• numeric_std_unsigned
• fixed_float_types
• fixed_generic_pkg
• fixed_pkg
• float_generic_pkg
• float_pkg

Referências

http://en.wikipedia.org/wiki/Vhdl

Softwares

• Atera Quartus II
• Xilinx – ISE
• ModelSim

Não tenho tanta experiência e conhecimento em VHDL quanto o Marcelo Barros ou o Francisco de Souza, leitor do Blog. No entanto, eu já estava preparando esse texto há um tempinho e complementei com algumas idéias desse outro texto do supracitado Marcelo.

Inclusive, a leitura desse outro texto é altamente recomendada!

Vamos ao meu humilde post:

Meu primeiro contato com VHDL foi há mais de um ano, mas só comecei a fazer projetos com ele há 3 meses, o que não é quase nada. Se alguém leu um dos primeiros posts desse blog, vai perceber que eu dizia que não é possível atribuir valor a um signal em mais de um local do código e isso é algo facilmente resolvido com as máquinas de estado.

Você pode tranquilamente fazer alguns circuitos em VHDL só usando IF e ELSE, mas, com o tempo, isso acaba atrapalhando quando você precisa configurar um sinal, fazer uma ou várias ações e, por fim, configurá-lo novamente.

Com o CASE, é possível criar estados e esses estados podem, cada um na sua vez, configurar o valor de um mesmo sinal.

Veja o exemplo abaixo:

Esse seria o modelo de um programa fictício que começa no estado A e fica nele até um sinal X receber o valor 1 (como se alguém clicasse num botão para disparar o mecanismo) depois ele passaria pelos estados B, C, E, F, retornando ao B e seguindo o loop até que um certo sinal Y receba o valor 1, então o sistema entra no estado D e por fim volta ao estado A para aguardar novamente o sinal X.

Para implementar essa máquina de estados, pode-se usar flip-flops do tipo D ( D é a entrada e Q é a saída), um para cada estado. A saída Q de cada Flip-flop é o controle para um certo circuito que atua quando o estado está ativo.

Traduzir isso para código VHDL é simplesmente seguir as setas e colocar o que acontece em cada estado.

O sinal “estado” pode ser definido como:

signal estado: natural range 0 to 5:= 0;

Além disso, o “when others” serve para prevenir possíveis erros no valor do estado. Nesse caso não vai ter problema, mas é uma boa prática de programação usá-lo.

Com esse exemplo, dá pra ver que em qualquer um dos estados B, C, E ou F o valor do sinal Y poderia ser modificado sem problemas. Além disso, fica mais fácil de entender para que o código serve se uma outra pessoa quiser ler.

No texto do Marcelo Barros, vocês vão notar que ele usa os estados com nomes. Isso também é uma boa prática de programação, mas como estou só mostrando o conceito, acho que fica mais simples de entender. Isso não é complicado de fazer:

Usando o “type”, você configura os possíveis nomes dos estados, como abaixo. Use sempre nomes que descrevam bem o que irá ser feito no estado.

type estados is (aguardando, setup, modulo, soma, iteracao, multiplicacao);

Para acabar, a parte do conteúdo do estado, que mostra o que ele realmente faz pode ser escrita num novo CASE dentro de um “process (estado)”. Serve para deixar o código mais limpo.

Bem, por hoje é só. Se estiver algo errado no código ou no desenho, avisem.

Se você quer entrar no mundo das FPGAs e aprender descrever Hardware em VHDL, eu aconselho a leitura de um texto curto e bem explicado sobre esse assunto no blog do Ricardo Bittencourt (Brain Dump): http://www.ricbit.com/2009/11/ataque-cilonio.html

Somente um pouco mais avançado que um Hello World da programação de Hardware, ele ensina a fazer leds acenderem em sequência. Tudo numa linguagem simples e com muitas imagens.

As I mentioned in my previous post, the next step that I wanted to take after designing the OZ-3 in simulation was to design and implement a simple CPU in an FPGA, just to get used to complex systems. Ironically, a couple days before I made that post, I had finished that CPU. It’s called Test CPU 1.

I said “simple CPU,” and by that, I mean a single-cycle, 16-bit RISC. The instruction set is ten instructions total; only the essentials. It doesn’t have any input capabilities, and all output capabilities are in 32 individual output pins, so data transfers would be rather difficult. Also, there are eight 16-bit registers. It can address 256 bytes of dRAM, and programs are limited to 4 MB, organized as 2Mbits x 16bits. The ALU is capable of addition and subtraction only, and it can only branch on zero. Here’s the full instruction set:

1. add
2. subtract
3. add immediate
4. subtract immediate
5. compare
6. branch on zero
7. jump
8. set/reset output pin
9. store
10. load

All of the immediates specified in add/subtract immediate are limited to five bits, so that makes loading 16-bit registers with values rather painstaking. Compare is simply subtraction without the register file being told to load the value on the ALU result bus.

I won’t really go into the microarchitecture, but one of the bigger problems I ran into while coding this processor involved synchronizing units with the clock and making sure nothing ended up being a two-stage process when everything was supposed to be single-cycle. I originally placed the program counter outside of the control unit/instruction decoder. This was a mistake, because I was clocking the control unit, as it was handling the Z-flag, which required a register to hold the value for use in the next instruction. I tried solving this by separating the Z-flag control area and the regular control area. This way, the Z-flag logic was the only part of the control unit that was clocked. I ended up running into undetermined problems with this, though.

To solve these problems, I put the program counter in the control unit and made sure that the control unit, register file, and dRAM were the only clocked pieces of the processor. By the way, during the first half of a cycle, all of the data is being interpreted/processed, and during the second half, the data is written. At last, after long hours of simulation, I was able to get it to work!

In actual synthesis, I ended up just getting rid of the data RAM all together. I wasn’t able to use the RAM resources on my FPGA development board because learning the interface wasn’t really worth it for this project. None of the programs I wanted to test used it, either. Eight registers were enough for my purposes. This drastically reduced the time it took to synthesize, map, translate, and place and route. From there, generating the programming file doesn’t take too long. It also cut down the amount of warnings given by ISE 11 by about 3,000.

I ran the CPU at 1 MHz, dividing down from the 50 MHz clock supplied on the board. The first program I got to work was one that counted to 0xFFFF, then lit an LED and waited indefinitely. The second program, my personal favorite, was one that controlled a 2×16 LCD display on a peripheral module, displaying the message “It works! ” Working out the timing for this program was especially difficult. I had to switch jump and branch address so many times that I ended up mixing them up and causing errors in the program that way. Despite this, it was quite rewarding when I clicked “Program Chain” then waited a couple seconds and saw “It works! ” on the screen, instead of a blank screen or flashing cursor. It’s still a  bit touchy; I have yet to find out why. But, this is where this project ends. I’ve begun coding components of the OZ-3, and hope to have a functional FPGA implementation by the end of November, or this year at the latest.

Ben Oztalay

Introdução

O ModelSim é  um popular aplicativo da Mentor Graphics voltado para a simulação e debug de hardware, em especial de dispositivos FPGA e ASIC. Este software trabalha com as linguagens de descrição de hardware Verilog, SystemC e VHDL.

O objetivo deste texto é listar os procedimentos básicos necessários para simulação de um projeto VHDL usando o ModelSim.

Tutorial

Criação de projeto ModelSim

Crie um projeto no ModelSim através da opção File > New > Project. Na janela que irá se abrir insira o nome do projeto (Project Name) e o caminho onde os arquivos do projeto deverão ser salvos (Project Location). Recomenda-se ainda renomear a biblioteca (Default Library Name) a ser utilizada na simulação.

Caso o projeto já esteja codificado insira os arquivos contendo todas as entidades utilizadas através da opção – Add Existing File – (utilize a tecla CTRL caso precise selecionar mais de um arquivo).

Após fechar esta janela, caso precise criar, adicionar ou remover algum arquivo referente ao projeto, isto poderá ser feito através da janela Workplace, utilizando a guia project, a partir do menu exibido ao clicar com o botão direito dentro desta janela. Caso a janela Workplace não esteja sendo exibida, no menu principal, selecione View > Workplace.

Após a inserção / edição dos entidades é necessário ‘compilar’ os arquivos para preparar o projeto para a simulação. Isso pode ser feito diretamente da janela Workplace, na guia Project – clique com o botão direito no arquivo com a entidade a ser simulada e selecione a opção compile.

Esta função pode ainda ser feita através do menu principal Compile. A opção Compile all prepara/verifica todos os arquivos do projeto.

Simulação

Na janela Workplace, selecione a guia Library. Procure pela biblioteca criada para o projeto, e clique em (+) para exibir todas as entidades. Dê um duplo clique na entidade a ser simulada.

A janela Objects, contendo todos os sinais utilizados pela entidade e a janela Wave, onde as formas de onda destes sinais serão exibidas devem ser abertas.

Caso elas não sejam exibidas habilite-as através do menu principal View > Objects e View > Wave.

Arraste (da janela Object para a janela Wave) os sinais que precisem ser visualizados durante a simulação.

Caso queira ‘forçar’ um valor/sinal de relógio os sinais, clique com o botão direito no sinal (Em quaisquer das janelas abertas) e selecione a opção desejada: a opção ‘force’ pode ser utilizada para configurar um sinal contínuo e ‘clock’ para configurar as características de um sinal de relógio.

Para rodar a simulação recomenda-se utilizar o terminal Transcript. Se o terminal não estiver sendo exibido habilite-o utilizando o menu View.

Para rodar o projeto utilize o comando run <intervalo de tempo>  <ENTER>, ou ainda para uma simulação contínua, run -all.

Você pode também verificar a simulação passo a passo através do comando step. Nesse caso o código fonte será varrido linha a linha após cada comando step. Para parar o projeto utilize o comando break; ou stop;

Todas estas opções estão também disponíveis através do menu principal simulate, a opção break pode ainda ser acessada através do menu de atalhos (O último ícone representa esta opção).

Versão do software utilizada na elaboração do texto: ModelSim SE PLUS 6.3f

Notas:

Utilizando a linguagem tcl é possível elaborar novos comando para o modelsim.

Para gerar os sinais de entrada para o teste do projeto recomenda-se a criação de entidades com este propósito (test bench).  Neste caso, o projeto principal é conectado como um componente dentro da entidade de testes.

For those interested in programming electronic components there is always the possibility to use Xilinx if you are on Windows. Of course, there is a Xilinx port for Linux but it is buggy application and a very large download. This article aims to give an alternative to this application. One that will need only a few KB of download from an apt-get source.

Of course, we are speaking about Icarus Verilog (iverilog), GHDL and GtkWave.

After installing each of them (command line, download, whatever), you can start desgning. Suppose we have the following source:

module bser(en, clk, in, out, done);
        input en, clk;
        input [7:0]in;
        output out, done;
        reg [2:0]cst;
        reg out, done;
 
        initial
        begin
                done = 0;
                cst = 3'b0;
                out = 0;
        end
 
        always @(posedge en)
        begin
                done = 0;
                cst = 3'b0;
                out = 0;
        end
 
        always @(posedge clk)
                if (en)
                begin
                        out = in[cst];
                        cst = cst + 1;
                        if (cst ==
                        begin
                                done = 1;
                                cst = 0;
                        end
                end
endmodule


We need to test our source manually, so we will write a benchmark file (consult the documentation for the syntax) in which we will introduce two lines for dumping information about variables:

module bser_tb;
        reg en, clk;
        reg [7:0]in;
        bser g(en, clk, in, out, done);
        initial
        begin
                en = 0; in=8'b00010111; clk=0;
                $dumpfile("bser_tb");
                $dumpvars;
                #10000 $finish;
        end
 
        always
        begin
                #1 clk = ~clk;
        end
 
        initial
        begin
                #2 en=1;
        end
endmodule


Now, we will compile the source, run it and then use gtkwave to see the results. All of this is very repetitive, so a Makefile was needed:


test_bser:
        iverilog bser.v bser_tb.v
        ./a.out
        gtkwave bser_tb
        rm -f a.out bser_tb


This is what we will obtain after a few milliseconds:

That’s all.

Meu último projeto em VHDL foi um simples cronômetro com precisão de centésimos de segundo que, com dois displays de sete segmentos, apresenta o tempo.

Como só é possível apresentar dois dígitos de cada vez, foi adicionado suporte a um botão que, quando pressionado, muda o que o display exibe: Ele começa exibindo décimos e centésimos de segundo. Com um clique, passa a exibir os segundos. No clique seguinte, os minutos e depois, com mais um clique, as horas.

Para parar e continuar o cronômetro, foi usado mais um botão, ficando um sistema bem simples e funcional.

Cronômetro rodando numa MAX 7k da Altera

A imagem está em baixa resolução, mas mostra o cronômetro gravado numa CPLD MAX7128S da Altera, que deve ter uns 15 anos. Ela tem um clock de 25,175MHz, que permite um cronômetro com precisão de cerca de 40 nanosegundos (3,97 x 10⁻⁸ s), mas isso seria impossível de ver no display (centésimos de segundos já aparecem borrados). Então, no código, tem um divisor de frequência onde é usado um clock de 100Hz para a contagem de tempo.

O WordPress não permite anexar arquivos de texto, então coloquei no pastebin: http://pastebin.com/f459d41. Pena que eles não têm syntax highlight para VHDL. Para ver melhor, use o Notepad++ ou o Kate.

Para poder reutilizar esse código, será preciso trocar o valor do clock da sua CPLD ou FPGA para que o cronômetro marque o tempo certo. Nesse caso, o divisor de frequência usa o valor 125875 ou 11110101110110011, criando 200 descidas e subidas por segundo, que equivale a um clock de 100Hz.

Meu próximo projeto em VHDL será um controlador de interface serial RS232, aquela que provavelmente não existe mais no seu computador. Mesmo assim, é possível utilizar um conversor USB – RS232, como o que eu comprei por US$3,00 no DealExtreme.

Por hoje é só, pessoal.

Very complicated Hardware Description Language.

Pessoa sobre VHDL

Claro que não significa isso, mas bem que poderia.

Aprendendo VHDL para programar uma CPLD a fazer um simples circuito para criar um pulso ao clique de um botão me custou 3 dias.

E o projeto era simples: Criar um divisor de frequência para o conseguir 100Hz ao invés de 250MHz, esperar 3 ciclos do novo clock após o botão ser pressionado (evita ruído) e depois gerar um pulso para a saída.

Placa UP1 da Altera

Coisas que podem ser feitas em outras linguagens de programação dão problemas em VHDL, como mudar o valor de uma das variáveis duas vezes no processo.

Acho melhor começar a ler mais sobre VHDL.

Fui.

62 new items added to the Library from leading publishers like Addison-Wesley Professional, FT Press, IBM Press, IBM Redbooks, IconLogic, Inc., Manning Publications, McGraw-Hill, Morgan Kaufmann, O’Reilly Media, Inc., Packt Publishing, Peachpit Press, Pearson Certification, Prentice Hall, Sams, Total Training, Inc., and Wharton School Publishing.

	LINQ to Objects Using C# 4.0: Using and Extending LINQ to Objects and Parallel LINQ (PLINQ) By: Troy Magennis. Publisher: Addison-Wesley Professional
	Network Maintenance and Troubleshooting Guide: Field Tested Solutions for Everyday Problems, Second Edition By: Neal Allen. Publisher: Addison-Wesley Professional
	Technical Analysis Plain and Simple: Charting the Markets in Your Language, Third Edition By: Michael N. Kahn – CMT. Publisher: FT Press
	Software Test Engineering with IBM Rational Functional Tester: The Definitive Resource By: Chip Davis. Daniel Chirillo. Daniel Gouveia. Fariz Saracevic. Jeffrey R. Bocarsly. Larry Quesada. Lee B. Thomas. Marc van Lint. Publisher: IBM Press
	Curam Business Application Suite on IBM System Z By: Abbas Birjandi. Gaurav Bhagat. Helene Grosch. Guillaume Hoareau. Hank Kehlbeck. Yannick Le Floch. Daniel Moraru. Eamonn Moriarty. Robert O’Brien. William Walsh. Publisher: IBM Redbooks
	IBM z/OS V1R10 Communications Server TCP/IP Implementation Volume 4: Security and Policy-Based Networking By: Bill White. Mike Ebbers. Valirio de Souza Braga Jr.. WenHong Chen. Gwen Dente. Octavio L. Ferreira. Marco Giudici. Joel Porterie. Micky Reichenberg. Andi Wijaya. Publisher: IBM Redbooks
	IBM Power 520 and Power 550 (POWER6) System Builder By: Bart Jacob. Lukasz Dyjakon. Gun Woo Kim. Rohit Sood. Publisher: IBM Redbooks
	WebSphere Application Server V7.0 Security Guide By: Carla Sadtler. Fabio Albertoni. Leonard Blunt. Shu Guang Chen. Elisa Ferracane. Grzegorz Smolko. Joerg-Ulrich Veser. Sean Zhu. Publisher: IBM Redbooks
	WebSphere Application Server V7 Administration and Configuration Guide By: Carla Sadtler. Fabio Albertoni. Leonard Blunt. Michael Connolly. Stefan Kwiatkowski. Thayaparan Shanmugaratnam. Henrik Sjostrand. Saori Tanikawa. Margaret Ticknor. Joerg-Ulrich Veser. Carla Sadtler. Fabio Albertoni. Leonard Blunt. Michael Connolly. Stefan Publisher: IBM Redbooks
	WebSphere Application Server V7 Messaging Administration Guide By: Carla Sadtler. Leonard Blunt. Neela M Suram. Publisher: IBM Redbooks
	Discovering the Business Value Patterns of Integrated Information Framework By: Rufus Credle. Victor Akibola. Vijay Karna. Devi Pannerselvam. Remesh Pillai. Satyaprema Prasad. Publisher: IBM Redbooks
	Essentials of Adobe Captivate 4: “Skills and Drills” Learning By: Kevin A. Siegel. Publisher: IconLogic, Inc.
	Essentials of Adobe RoboHelp 8 HTML: “Skills and Drills” Learning By: Kevin A. Siegel. Publisher: IconLogic, Inc.
	The Art of Unit Testing: with Examples in .NET By: Roy Osherove. Publisher: Manning Publications
	Hello World!: Computer Programming for Kids and Other Beginners By: Warren Sande. Carter Sande. Publisher: Manning Publications
	Grails in Action By: Glen Smith. Peter Ledbrook. Publisher: Manning Publications
	Mule in Action By: David Dossot. John D’Emic. Publisher: Manning Publications
	MCITP SQL Server™ 2005 Database Administration All-in-One Exam Guide (Exams 70-431, 70-443, and 70-444) By: Darril Gibson. Publisher: McGraw-Hill
	MCITP SQL Server™ 2005 Database Developer All-in-One Exam Guide (Exams 70-431, 70-441, and 70-442) By: Darril Gibson. Publisher: McGraw-Hill
	OCA Oracle Database 11g: Administration I Exam Guide (Exam 1Z0-052) By: John Watson. Publisher: McGraw-Hill
	The Designer’s Guide to VHDL, Third Edition By: Peter Ashenden. Publisher: Morgan Kaufmann
	Reconfigurable Computing: The Theory and Practice of FPGA-Based Computation By: Scott Hauck. Andre DeHon. Publisher: Morgan Kaufmann
	VLSI Test Principles and Architectures: Design for Testability By: Laung-Terng Wang. Cheng-Wen Wu. Xiaoqing Wen. Publisher: Morgan Kaufmann
	Physically Based Rendering: From Theory to Implementation By: Matt Pharr. Greg Humphreys. Publisher: Morgan Kaufmann
	Readings in Hardware/Software Co-Design By: Giovanni De Micheli. Rolf Ernst. Wayne Wolf. Publisher: Morgan Kaufmann
	The System Designer’s Guide to VHDL-AMS: Analog, Mixed-Signal, and Mixed-Technology Modeling By: Peter Ashenden. Gregory Peterson. Darrell Teegarden. Publisher: Morgan Kaufmann
	Modeling Embedded Systems and SoCs: Concurrency and Time in Models of Computation By: Axel Jantsch. Publisher: Morgan Kaufmann
	The Art of Community, 1st Edition By: Jono Bacon. Publisher: O’Reilly Media, Inc.
	Programming the iPhone User Experience, 1st Edition By: Toby Boudreaux. Publisher: O’Reilly Media, Inc.
	flex & bison, 1st Edition By: John Levine. Publisher: O’Reilly Media, Inc.
	Quality Assurance for Dynamics AX-Based ERP Solutions: Verifying Dynamics AX customization to the Microsoft IBI standards By: Anil Kumar Gupta. Publisher: Packt Publishing
	Active Directory Disaster Recovery: Expert guidance on planning and implementing Active Directory disaster recovery plans By: Florian Rommel. Publisher: Packt Publishing
	PHP Oracle Web Development: Data Processing, Security, Caching, XML, Web Services, and AJAX By: Yuli Vasiliev. Publisher: Packt Publishing
	JDBC 4.0 and Oracle JDeveloper for J2EE Development: A J2EE developer’s guide for using Oracle JDeveloper’s integrated database features to build data-driven applications By: Deepak Vohra. Publisher: Packt Publishing
	SOA Approach to Integration: XML, Web Services, ESB, and BPEL in Real-World SOA Projects By: Poornachandra Sarang. Frank Jennings. Matjaz Juric. Ramesh Loganathan. Publisher: Packt Publishing
	Real World Google SketchUp 7 By: Mike Tadros. Publisher: Peachpit Press
	The Digital Photography Book, Volume 3 By: Scott Kelby. Publisher: Peachpit Press
	Plug-ins for Photoshop: featuring OnOne Software By: Matt Kloskowski. Publisher: Peachpit Press
	Real World HDR By: Matt Kloskowski. Publisher: Peachpit Press
	The Making of Times Square: Part 1 By: Bert Monroy. Publisher: Peachpit Press
	Dreamweaver CS4 for Beginners By: Rafael Concepcion. Publisher: Peachpit Press
	Online Photo Portfolios with Lightroom 2 and Dreamweaver CS4 By: Rafael Concepcion. Publisher: Peachpit Press
	Flash CS4 for Beginners By: Rafael Concepcion. Publisher: Peachpit Press
	Building a Website with Photoshop CS4 and Dreamweaver CS4 By: Rafael Concepcion. Publisher: Peachpit Press
	Getting Up To Speed with Wacom Intuos 4 By: Corey Barker. Publisher: Peachpit Press
	Creative Integration with Photoshop CS4 and Illustrator By: Corey Barker. Publisher: Peachpit Press
	CompTIA A+ Exam Cram, Fourth Edition By: David L. Prowse. Publisher: Pearson Certification
	Practical Virtualization Solutions: Virtualization from the Trenches By: Kenneth Hess. Amy Newman. Publisher: Prentice Hall
	Windows Server® 2008 How-To By: J. Peter Bruzzese. Ronald Barrett. Wayne Dipchan. Publisher: Sams
	Total Training for Adobe Photoshop CS3: Essentials By: Chad Perkins. Publisher: Total Training, Inc.
	Total Training for Adobe Flash CS3 Professional: Essentials By: John Ulliman. Publisher: Total Training, Inc.
	Total Training for Adobe Dreamweaver CS3: Essentials By: Janine Warner. Publisher: Total Training, Inc.
	Total Training for Adobe Flash CS3: Professional ActionScript 3 Essentials By: John Ulliman. Publisher: Total Training, Inc.
	Total Training for Adobe After Effect CS3: Essentials By: Ko Maruyama. Publisher: Total Training, Inc.
	Total Training for Adobe Illustrator CS3: Advanced By: Geoff Blake. Publisher: Total Training, Inc.
	Total Training for Adobe Photoshop CS3: Advanced By: Justin Seeley. Publisher: Total Training, Inc.
	Total Training for Adobe Premiere Pro CS3: Essentials By: Jason Barbosa. Christopher Hunt. Publisher: Total Training, Inc.
	Total Training for Adobe Flash CS3 Professional: Production Premium Integration By: John Ulliman. Publisher: Total Training, Inc.
	Total Training for Adobe CS3: Design Workflow By: Geoff Blake. Publisher: Total Training, Inc.
	Total Training for Adobe CS3: Web Design Workflow By: Abbas Rizvi. Publisher: Total Training, Inc.
	Total Training for Adobe Dreamweaver CS3: Advanced By: Janine Warner. Publisher: Total Training, Inc.
	The Fortune at the Bottom of the Pyramid: Eradicating Poverty Through Profits, Revised and Updated 5th Anniversary Edition By: C. K. Prahalad. Publisher: Wharton School Publishing

I’ve been attending the Design Automation Conference ever since I was a cub technology reporter at Electronic News.  Back then, things were very dynamic.  People were arguing over deep technical questions such as whether to support VHDL or Verilog, or another standard; what post-layout schemes to adopt; how to devise a heirarchical design methodology.  Today the questions are much deeper, and so is the technology. 

We have the ability, now, to design chips that are as complex as not just a city but an entire region’s electrical grid, in a space the size of your small fingernail and quite a bit thinner.  Designers are implementing chips with tens or even hundreds of processor cores.  A cell phone that had a dozen chips five years ago has two, perhaps just one. 

Designing and verifying these systems can be extremely complex.  Today, it’s not possible to draw a line in the sand between analog chip design and digital chip design.  Everything is mixed signal, so the software has to be able to understand both worlds and figure out how to help the designer deal with them…now!  That’s because systems manufacturers need the chips now. 

But how can you be sure such a complex design is correct before taking it to manufacturing? One leading foundry manager said recently that there are more than 120 design recommendations that deal with boundary effects alone…that is, recommendations for making sure that microscopic electrical lines stay far enough apart, in every dimension, to avoid a short circuit or similar problem. A typical verification strategy today involves working through billions of possibilities.  As one verification marketing manager put it recently, there are more possible variations in a complex semiconductor device today than there are atoms in the known universe. 

Crunching through all that data in less than 30 centuries requires extremely fast verification software, working in parallel over multiple computers.  And because nearly every step of the design process has a complimentary verification step, all of the design software has to be parallelized to be anywhere near fast enough to be useful.

There’s also the growing question of power efficiency.  Is my chip running at the lowest possible rate of power consumption, while still doing everything I need it to do? Can I make it last longer if it runs cooler?  Can I avoid expensive cooling devices or exotic chip packaging technologies by making my chip operate cooler?  Low power design has become extremely important not just because it’s green, but because it can save money as well.

Similarly, we’ve begun to expand outward.  By growing our expertise in low power design, the industry is now growing its ability to communicate with systems designers.  Whereas in the past the applications developers simply needed to know what kind of performance and memory they could expect from their device, today they need to know what power shutoff tools are available so they can automatically power down an LCD screen or a GPS locator while you are talking on the phone, for example.  The link between applications developers and chip developers is now at the firmware level, and this holds great promise for the industry.

The global recession has impacted every industry.  This is abundantly clear as I see former colleagues from several companies and even competitors, walking the floor of DAC with resumes and business cards in hand.  It would be a depressing sight, except that I earnestly believe this industry holds an important key to economic revitalization.  This is an exceptional, international group of people dedicated to improving their products and technologies for the common good.  This is a highly educated group of people, mentally tuned to that challenge.  This is a group that thrives on innovation, on entrepreneurship, and on risk-taking in pursuit of practical ideas with great potential benefit.

This is the group that will continue to develop the foundation technologies of the future.  And it is still very dynamic.

The picture shows the respective eclipse-plugins, which will enhance :

• frontend design
• autogeneration of documentation and maintenance of professional datasheets
• Perl/Tcl scripting (Perl modules which featured as from FEL10)
• version controlled

experience for Fedora users.

Think Methodology and not random packaging.

This is sentence that many people have heard from me. Feeding design methodologies is one of the reasons why Fedora Electronic Lab  is so attractive to many small companies.

Development behind FEL 12 focusses on adding value to the frontend design. Eclipse, being an industry standard IDE, is FEL’s main IDE for digital/embedded hardware design.

In the following blog posts, I will cover these features in depth, meanwhile you can try those plugins with yum on your Fedora 11. Only eclipse-eclox and eclipse-texlipse are not yet part of the Fedora collection. They are being reviewed #506429 and #506431 respectively.

The files include:

- I2C slave core for FPGA implementation

- Example of I2C based register file which would be useful for those needs FPGA-uC communication.
I2C Slave VHDL