Projetando um flip-flop D usando Migen

Se você não tiver instalado Migen ou não sabe sobre Migen, leia nos proximos posts como Instalando Migen a linguagem de descrição de hardware Python baseado Flip-flops D


AD flip-flop  libera dados  que são mantido no pino de entrada de dados quando o Clock é aplicado (na entrada for positiva ou negativo ). O flip-flop D que prescisamos  ter um  pino  D é a entrada Q  e o pinos de saída Qi (invertida de Q). Ele também tem uma entrada de Clock que  e um pino de reset que faz o sincronismo flip-flop.

O flip-flop D  sera mostrado  aqui uma vantagem positiva desencadeada no flip-flop. A tabela verdade representa o mapeamento entre os pinos de entrada para os pinos de saída com base no pino de reset e estado pino do relógio. Desde a sua uma vantagem positiva desencadeada flip-flop, o pino do Clock é mostrado como uma transição de baixo para alto.

Apenas para referência, esta é a folha de dados de um flip-flop D IC.

A D flip-flop usando Migen
Crie um arquivo chamado Dff.py e adicione este código para ele.

———————————————————————————–

 

———————————————————————————–

  1. from migen.fhdl.std import *
  2.  
  3. class Dflipflop(Module):
  4. def __init__(self, D, Q, Qi):
  5. self.sync += Q.eq(D)
  6. self.comb += Qi.eq(~Q)

——————————————————————————————-

——————————————————————————————-

 

Os circuitos digitais podem ser divididas em síncrones (ou seja, funciona com base na entrada de clock) e assíncrones (independente do Clock) circuitos.

Circuitos assíncronos são também conhecidas como lógica de combinações. A sintaxe do Python usado para descrever o flip-flop D pode ser mais claramente compreendida através da leitura da guia Migen. Então eu não vou estar explicando aqui a sintaxe utilizada. descrevendo os (assíncrono) declarações síncronas e combinações estão no meu âmbito de Conhecimento.

 Porem este artigo parcialmente foi traduzido de outro blog que faz referencia ao projeto Migen , que sem descritivo nao poderia fazer este projeto do Flip- Flop usando o Fedora Eletronic Lab’s .

 
——————————————————————————————————————————
self.sync += Q.eq(D)

——————————————————————————————————————————
 Q.eq (D) é equivale / a copia do conteúdo de D para  Q que são a entrada e saída de nosso flip-flop.  Então sera designado como síncrono usando self.sync + =. Como mencionado anteriormente, um flip-flop D copia os dados do pino de entrada para o pino de saída em sincronia com a transição do Clock(pulso do clock). Assim, como este circuito é um circuito de sincronismo Digital
 ——————————————————————————————————————————————————–
self.comb += Qi.eq(~Q).
 ———————————————————————————————————————————————————
Qi.eq (~ Q)  é usado para inverter Q e copiar para Qi. Isto é atribuído como uma lógica de combinações. Isso significa que Qi é independente do pulso do Clock . Mas o flip-flop é um síncrone Isso não significa que vai mudar de forma assíncrona, desde a entrada de Qi é de uma lógica Q. síncrona
 
Testando o flip-flop D
Atualize seu arquivo  Dff.py com o código abaixo.
 —————————————————————————————————————————————————-
—————————————————————————————————————————————————–
  1. from migen.fhdl.std import *
  2. from migen.fhdl import verilog
  3. from migen.sim.generic import Simulator, TopLevel
  4. from random import randrange
  5.  
  6. class Dflipflop(Module):
  7. def __init__(self, D, Q, Qi):
  8. self.sync += Q.eq(D)
  9. self.comb += Qi.eq(~Q)
  10.  
  11. def do_simulation(self,s):
  12. s.wr(D,randrange(2))
  13.  
  14. #Simulation and verilog conversion
  15. D = Signal()
  16. Q = Signal()
  17. Qi = Signal()
  18.  
  19. #print(verilog.convert(Dflipflop(D, Q, Qi), ios={D,Q,Qi}))
  20.  
  21. sim = Simulator(Dflipflop(D,Q,Qi), TopLevel(“Dff.vcd”))
  22. sim.run(100)

————————————————————————————————————————————————————

————————————————————————————————————————————————————

Executando o script em python usando os comandos

Vai gerar um Dxf.vcd que contém o resultado do nosso teste . O arquivo vcd pode ser visualizado utilizando ferramenta gtkwave.

——————————————————————————————————————————————————————-

python3 Dff.py

—————————————————————————————————————————————————————–
gtkwave Dff.vcd

———————————————————————————————————————————————————————

GTKWave-Dff.png

Como mencionei antes, leia o guia oficial do usuário  do Migen e tutorial para entender melhor como funciona melhor os código .

Para testar a D flip-flop, é preciso verificar se as entrada (D) é são copiadas  para a saída (Q e também Qi). Para isso, a entrada D deve ser alimentado com os valores (0 ou 1). Podemos usar o módulo randomico em Python para gerar alguns valores aleatórios.

s.wr (D, randrange (2))
O randrange é uma  função (2) que gera um número aleatório  ou seja 0 ou 1 s.wr escreve o número aleatório para D. A escrita acontece apenas depois de passar para  positivo no ciclo de clock.

Verilog  e equivalente do flip-flop D

Como irei mencionar nos proximos post’s ( instalaçao do Migen a linguagem de descrição de hardware baseado em Python), Migen  faz a converção  do código  do Python para código  Verilog equivalente. As ferramentas FPGA que temos atualmente só entende apenas Verilog / VHDL, isso é necessário conhecer . O código Verilog é  gerado e pode ser carregado para o software do seu fornecedor FPGA e verificado em seu hardware real. Mibuild (uma ferramenta dentro Migen) suporta alguns distribuidores de  FPGA para o qual você não tem que colar manualmente o seu código no Verilog para que seu  software  que foi fornecido para usar  no FPGA. Mibuild vai fazer isso por você (acessando ferramentas de distrobuidores  via linha de comando) e ainda pode carregar o arquivo de fluxo de bits para seu FPGA. Apenas Usando o  Mibuild  que será explicado .

Descomente sua  linha no  arquivo gerado  Dff.py e execute o seu código python novamente. Esta linha irá imprimir o código equivalente ao  Verilog do nosso  flip-flop D

————————————————————————————————

print(verilog.convert(Dflipflop(D, Q, Qi), ios={D,Q,Qi})).

 ————————————————————————————————
Abaixo estará  a saída do Verilog.
 ———————————————————————————————–
  1. /* Machine-generated using Migen */
  2. module top(
  3. input D,
  4. output reg Q,
  5. output Qi,
  6. input sys_clk,
  7. input sys_rst
  8. );
  9.  
  10.  
  11. // synthesis translate_off
  12. reg dummy_s;
  13. initial dummy_s <= 1‘d0;
  14. // synthesis translate_on
  15. assign Qi = (~Q);
  16.  
  17. always @(posedge sys_clk) begin
  18. if (sys_rst) begin
  19. Q <= 1′d0;
  20. end else begin
  21. Q <= D;
  22. end
  23. end
  24.  
  25. endmodule
  26. —————-

Outra forma de testar seu  flip-flops D: Usando um  divisor de frequência

Nota: Abaixo se mostrado  uma forma que não é a maneira certa de fazer uma divisão de freqüência.Mas  este é apenas um exemplo para Elucidar ou mostrar as capacidades de teste de MIGEN.

AD filp-flop pode ser usado como um divisor de frequência (frequência / 2). Leia este post  para uma explicação mais clara. Fazer uma conexão de Qi para D para dividir a frequência (alimentado ao pino do clock ) por 2  e Ligar um fio entre os pinos e é muito fácil com uso do  Migen – basta usar o mesmo sinal () para ambos os pinos.

Crie um arquivo chamado Dff_Divider.py e adicione o código abaixo.

  1. from migen.fhdl.std import *
  2. from migen.fhdl import verilog
  3. from migen.sim.generic import Simulator, TopLevel
  4.  
  5. class Dflipflop(Module):
  6. def __init__(self, D, Q, Qi):
  7. self.sync += Q.eq(D)
  8. self.comb += Qi.eq(~Q)
  9.  
  10. #Simulation and verilog conversion part
  11. Connect = Signal()
  12. Q = Signal()
  13.  
  14. sim = Simulator(Dflipflop(Connect,Q,Connect), TopLevel(“Dff_Divider.vcd”))
  15. sim.run(100)

 

 

 

 

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s