Neste tutorial, vamos projetar um detector de sequência de dois bits em zero. Para isso, utilizaremos o projeto dos CIs CD4069, CD4081 e CD40194 previamente implementados nos tutoriais:

• Como projetar o CI CD4069 em Verilog
• Como projetar o CI CD4081 em Verilog
• Como projetar o CI CD40194 em Verilog

São duas as opções de aprendizado neste tutorial: você pode optar por acompanhar o vídeo abaixo com a S-Board, ou seguir o passo-a-passo descrito neste artigo com a C-Board. Escolha o formato que mais se ajusta ao seu ritmo de aprendizado e vamos começar!

O que faz um circuito detector de sequência?

Um circuito detector de sequência é projetado para identificar uma sequência específica de bits em uma entrada de dados serial. Neste tutorial, vamos focar na detecção da sequência “00”, ou seja, em um circuito que sinaliza quando dois bits consecutivos forem iguais a zero. Essa sinalização será feita através de um LED, que acenderá quando a sequência “00” for detectada.

Em aplicações práticas, esse tipo de circuito é muito útil para sincronizar a recepção de dados, detectar erros de transmissão ou até mesmo como parte de um protocolo de comunicação mais complexo. Normalmente, circuitos serialziadores são utilizados em conjunto com circuitos deserializadores, covertendo dados em paralelos em dados seriais e vice-versa.

Qual é o diagrama lógico do circuito detector de sequência?

O diagrama de blocos do circuito detector de sequência de dois bits em zero é apresentado na Figura 1. Nele, podemos observar que o circuito é composto por três CIs: o CD4069, o CD4081 e o CD40194 ¹²³. Lembre-se que todos esses CIs já foram implementados em tutoriais anteriores, portanto, você deve consultar os links no início deste tutorial para entender como cada um deles funciona.

Qual é a pinagem do CI detector de sequência?

A partir a Figura 1, podemos identificar que o circuito detector de sequência possui apenas um sinal de entrada conectado ao pino din. Este sinal de entrada conecta-se ao pino SHIFT_RIGHT do CI CD40194 que, por sua vez, captura e desloca os bits de entrada para os registradores de deslocamento a cada borda de subida do sinal de relógio. O sinal din é o único sinal de entrada do circuito detector de sequência, e é utilizado para receber os bits que serão analisados pelo circuito. Os sinais de saída, por sua vez, são conectados aos pinos pair0 e pair1, que indicam a detecção da sequência “00” nos registradores de deslocamento, e os pinos dout[3:0], que representam o estado atual dos registradores de deslocamento. Tal comportamento está resumido na Tabela 1 a seguir:

Tabela 1. Descrição dos pinos do Circuito Detector de Sequência de 2 Bits.

Note que, na Tabela 1, foi adicionado o pino ledclk, que é opcional e pode ser utilizado para visualizar o sinal de relógio do sistema em um LED, facilitando a depuração do circuito. Note que, também, que os pinos Vss e Vdd não estão listados, pois a definição explícita desses pinos não é necessária em Verilog.

Conectando os blocos integrantes do detector de sequência

Para implementar o circuito detector de sequência é necessário conectar os blocos CD4069, CD4081 e CD40194. Isso pode ser realizado através do instanciamento dos módulos Verilog correspondentes a cada CI, conforme o código abaixo. O módulo detector é o módulo principal do circuito detector de sequencia e instancia os módulos cd4069, cd4081 e cd40194. Este módulos são conectados entre si através de sinais internos, que são declarados como wire, conforme indicado no código abaixo.

module detector(clk, rst, din, pair0, pair1, dout, ledclk);
    input       clk, rst, din;
    output      pair0, pair1;
    output[3:0] dout;
    output      ledclk;

    // internal signals
    wire[3:0]   q_sig;
    wire        g_sig, h_sig, i_sig, j_sig;

    assign  dout = {q_sig};
    assign  ledclk = clk;

    // CMOS Quad 2-input AND gate
    cd4069 cd4069_inst(
        .A(q_sig[0]), .B(q_sig[1]), .C(q_sig[2]), .D(q_sig[3]), .E(1'b0), .F(1'b0),
        .G(g_sig),    .H(h_sig),    .I(i_sig),    .J(j_sig),    .K(),     .L());

    // CMOS hex inverter
    cd4081 cd4081_inst(
        .A(g_sig), .B(h_sig), .J(pair0),
        .C(i_sig), .D(j_sig), .K(pair1), 
        .E(1'b0),  .F(1'b0),  .L(),
        .G(1'b0),  .H(1'b0),  .M());

    // CMOS 4-bit bidirectional universal shift register
    cd40194 cd40194_inst(
        .CLOCK(clk),
        .RESET(rst),
        .SHIFT_LEFT(1'b0),
        .SHIFT_RIGHT(din),
        .S(2'b01),
        .D(4'b0000),
        .Q(q_sig));
endmodule:detector

O sinal de entrada din é conectado ao pino SHIFT_RIGHT do CD40194, que captura os bits de entrada e os desloca para os registradores de deslocamento. Os sinais de saída pair0 e pair1 são conectados às portas AND do CD4081, que verificam se a sequência “00” foi detectada nos registradores Q0, Q1, Q2 e Q3 do CD40194 após estes sinais serem invertidos pelo CD4069. O sinal ledclk é opcional, e tem por objetivo visualizar o sinal de relógio do sistema, facilitando a depuração do circuito.

Declarando os módulos CD4069, CD4081 e CD40194

Caso copie o código acima e tente compilá-lo neste estágio do desenvolvimento, o resultado será o seguinte:

pitanga.v:15:5: error: unknown module 'cd4069'
    cd4069 cd4069_inst(
    ^~~~~~
pitanga.v:20:5: error: unknown module 'cd4081'
    cd4081 cd4081_inst(
    ^~~~~~
pitanga.v:27:5: error: unknown module 'cd40194'
    cd40194 cd40194_inst(
    ^~~~~~~

Top level design units:
    detector


Build failed: 3 errors, 0 warnings

Esta falha ocorre porque os módulos cd4069, cd4081 e cd40194 ainda não foram declarados. Para corrigir este erro, precisamos declarar esses módulos Verilog, copiando os códigos destes CIs e colando-os logo abaixo do módulo detector. Para facilitar o desenvolvimento, segue o código Verilog dos três CIs desenvolvidos nos tutoriais anteriores. Você pode copiar e colar este código no editor Verilog após módulo detector.

module cd40194(CLOCK, RESET, SHIFT_LEFT, SHIFT_RIGHT, S, D, Q);
  input   CLOCK;        
  input   RESET;
  input       [1:0] S;
  input   SHIFT_LEFT;
  input   SHIFT_RIGHT;   
  input       [3:0] D;
  output reg  [3:0] Q;
 
// continua ...
  // behavioral description (architecture)
  always@(posedge CLOCK) begin
    if(RESET)
      Q <= 4'b0000;
    else if(S == 2'b11)
      // parallel load mode
      Q <= D;
    else if (S == 2'b10) begin
      // shift left mode
      Q[3] <= SHIFT_LEFT;
      Q[2] <= Q[3];
      Q[1] <= Q[2];
      Q[0] <= Q[1];
    end
    else if (S == 2'b01) begin
      // shift right mode
      Q[0] <= SHIFT_RIGHT;
      Q[1] <= Q[0];
      Q[2] <= Q[1];
      Q[3] <= Q[2];
    end
    else
      Q <= Q;
  end
endmodule

// Descrição do Circuito CD4081B (Texas Instruments)
module cd4081(A, B, C, D, E, F, G, H, J, K, L, M);
// Declaração e direcionamento das portas
    input   A, B;   output J; // entradas e saída da porta 'a'
    input   C, D;   output K; // entradas e saída da porta 'b'
    input   E, F;   output L; // entradas e saída da porta 'c'
    input   G, H;   output M; // entradas e saída da porta 'd'

// Portas lógicas AND2
    and(J, A, B);   // porta 'a'
    and(K, C, D);   // porta 'b'
    and(L, E, F);   // porta 'c'
    and(M, G, H);   // porta 'd'
endmodule

module cd4069(
    input   A, B, C, D, E, F,
    output  G, H, I, J, K, L
);
  // Descrição lógica do CD4069 (6 inversores independentes)
  not(G, A);
  not(H, B);
  not(I, C);
  not(J, D);
  not(K, E);
  not(L, F);
endmodule

Compilando o circuito na C-Board

Antes de compilar o circuito detector de sequência na C-Board, é necessário realizar o mapeamento dos pinos do circuito para os componentes virtuais da C-Board. No entanto, antes de realizar o mapeamento, vamos compilar o circuito para verificar se não há erros de sintaxe até o momento. Para isso, clique no botão “Run”, localizado na parte inferior da barra lateral de ícones.

Top level design units:
    detector

Build succeeded: 0 errors, 0 warnings
Error: mismatched input '<EOF>' expecting {COMPONENT_ID, Identifier} in line 1:1 on file: pitanga.pinout

O relatório de compilação indica que o circuito foi compilado com sucesso, mas o projeto não pode ser compilado porque ainda não foi realizado o mapeamento dos pinos do circuito para os componentes virtuais da C-Board. Com o auxílio da Tabela 1, podemos implementar o mapeamento. O resultado do código de pinagem para a C-Board é apresentado abaixo.

//  MODULE PORT     BOARD COMPONENT
    clk         =   clk_1hz;
    rst         =   btn0;
    din         =   sw5;
    pair0       =   segd1.a_on;
    pair1       =   segd0.a_on;
    dout[0]     =   led3;
    dout[1]     =   led2;
    dout[2]     =   led1;
    dout[3]     =   led0;    

    // clock output
    ledclk      =   led5;

A pinagem acima indicada que o sinal de relógio do sistema (clk_1hz) é conectado ao pino clk, o sinal de reset (btn0) é conectado ao pino rst, e o sinal de entrada serial (sw5) é conectado ao pino din. Os sinais de saída pair0 e pair1 são conectados aos LEDs segd0.a_on e segd1.a_on, respectivamente, que acenderão quando a sequência “00” for detectada. Os sinais de saída do registrador de deslocamento (dout[0], dout[1], dout[2], dout[3]) são conectados aos LEDs led3, led2, led1 e led0, respectivamente. O sinal opcional de relógio do sistema (ledclk) é conectado ao LED led5.

Nota: caso você seja um assinante da Pitanga Student ou Student+, experimente aumentar a frequência do relógio do sistema para 3Hz, alterando a linha clk = clk_1hz; para clk = clk_3hz;. Isso permitirá que você visualize o comportamento do circuito em uma frequência maior. Tenha em mente que circuitos deste tipo podem executar a frequências muito maiores, na casa do Gigahertz. A frequência de 1Hz e 3Hz é utilizada aqui apenas para facilitar a visualização do comportamento do circuito.

Entendendo o relatório de compilação

Compilando novamente o projeto com o arquivo acima, não teremos mais erros de compilação. Segue relatório de compilação esperado:

Top level design units:
    detector

Build succeeded: 0 errors, 0 warnings
                     DESIGN SUMMARY REPORT
  module     : detector
  design file: pitanga.v
  pinout file: pitanga.pinout

Total number of wires: 18
Total number of cells: 15
Total number of ports: 12

  Cell      Instances   Cell      Instances   Cell      Instances
 -----------------------------------------------------------------
  AND2              0 | NAND2             0 | XOR2              0 
  AND3              0 | NAND3             0 | XOR3              0
  AND4              0 | NAND4             0 | XOR4              0
  OR2               0 | NOR2              6 | XNOR2             0
  OR3               0 | NOR3              0 | XNOR3             0
  OR4               0 | NOR4              0 | XNOR4             0
 -----------------------------------------------------------------
  BUF               1 | INV               4 | DFFRSE            4

Cells utilization: 15
Transistor count : 188/500 transistors (37.60 %)

Note que o relatório de compilação apresenta apenas 4 inversores (INV) dos 6 disponíveis no CD4069. Isso ocorre porque durante o processo de compilação a Pitanga identificou que dois inversores não são necessários para o funcionamento do circuito detector de sequência. Isso é uma otimização automática realizada pelo compilador, que busca reduzir o número de portas lógicas utilizadas no circuito. O mesmo ocorre com as portas AND do CD4081, que foram substituídas por portas NOR2. A Pitanga, através de um motor de síntese, entende que as portas lógicas AND2 do CD4081 podem ser substituídas por portas lógicas NOR2. Portas lógicas NOR2 possuem menos transistores que portas lógicas AND2, sendo mais eficientes em diversos aspectos que poderão ser explorados em tutoriais futuros⁴.

Experimentando o circuito detector de sequência

Agora que você chegou até aqui, é hora de experimentar o circuito detector de sequência na C-Board. Ative a chave sw5 para injetar uma sequência de bits em ‘1’ e verifique se os LEDs segd0.a_on e segd1.a_on irão se acender quando a sequência “00” for detectada. Note que as alterações nos LEDs led0, led1, led2 e led3 ocorrem a cada borda de subida do sinal de relógio, ou seja, quando o led5 passa do estado apagado para o estado acesso. A Figura 2 a seguir mostra este comportamento.

Conclusão

Se você chegou até aqui, parabéns! Você conseguiu implementar um circuito detector de sequência de dois bits em zero utilizando a C-Board Virtual Pitanga. Este projeto demonstrou como reusar componentes previamente projetados em Verilog, uma técnica muito comum na indústria de eletrônica avançada.

Referências