SEC-Сумматор с SIPOPISO на ∀ количество бит19.01.2025 11:01

Привет, хабровы плисоводы!

Пока одни пытаются учить других как надо что-то там делать на ПЛИСах, я продолжаю постигать дзен в имплементации никому ненужных идей не несущих какой-либо практической ценности. Я уже делал и сумматор с одним уровнем логики, и рисовал картины-на-кристалле видаде, и делал не нормальное проектирование в вивадском ECO флоу (txt, видео), и даже делал Трахтенберга на ПЛИСах.

Сегодня мы продолжим путь издевательства над нашей дорогой областью программируемой логики и попробуем што-то новенькое:, а именно мы перевернем типичную фразу «Да у нас в плис все параллельно» и сделаем последовательный сумматор на одном Full Adder, но который может складывать числа любой положительной разрядности ну на оооочень высокой тактовой частоте доступной простой смертной логике.

Не переживайте, тут будет и образовательный контент. Поэтому с вас стрелка вверх за статью, а с меня разбор парочки нюансов, с которыми я столкнулся при разработке этого проекта.

В общем хватит прелюдий.

Цель:

Реализовать вычислительное ядро на базе полного сумматора, которому на входы операндов приходят последовательности бит, т.е. операнды подаются в виде последовательности бит, начиная с младшего. Снабдить схему сигналами загрузки операндов и выдачи результата в параллельной форме. Окончание вычислений снабдить сигналом валидности.

Для достижения поставленной цели, необходимо решить следующие задачи:

1. Реализовать:

   1. модуль parallel-input serial-output для загрузки операндов в вычислительное ядро

   2. вычислительное ядро на базе Full Adder (полного сумматора)

   3. модуль serial-input parallel-output для выгрузки результата

2. Сделать сигнал загрузки и валидности данных

3. Выполнить расчет потенциально возможной максимальной тактовой частоты, дать рекомендации по улучшению проекта.

4. Прототип проекта выполнить для кристалла xc7a35tcsg324–1

Начнем со структурной схемы проекта, приведенной на рисунке ниже.

Схема проекта в целом простая, особых пояснений не требует: приходит вектор входных данных на PSIO, потом преобразуется в последовательность бит (сериализация, младший бит выходит первым), биты поступают на вход полного сумматора FA (выхода два — сумма и знак переноса), выход сумматора идет на вход SIPO для десериализации.

Далее углубляемся по уровню представления ниже и опишем сигналы блоков и доп модули.

Схема будет синхронная, фактически конвейер, поэтому потребуется тактовая частота. Сброс для ардуинщиков и асик дизайнеров, поэтому делать мы его не будем.

Для SIPO потребуется некоторый сигнал загрузки/записи в сдвиговый регистр, поскольку в противном случае записывать данные он будет каждый такт, а это мы не хотим делать, поскольку не можем быть уверены в том, что iload будет появляться в строго дотактово нужное время. Поэтому записываем только по определенному стечению обстоятельств.

Сигнал записи для SIPO сформируем из сигнала iload и его задержанной копии. Сигнал выставляется в 1, когда приходит iload и сбрасывается в 0, когда приходит задержанная копия iload. Грубо говоря вот такая схема (из элеборейта взята)

flowcontrol

`timescale 1ns / 1ps

module flowcontrol(
    input iclk,
        
    input iload,
    input iload_delayed,
    output oread
);
    
    reg read;
    
    always @(posedge iclk) begin
        if (iload) begin
            read <= 1'b1;
        end
        
        if (iload_delayed) begin
            read <= 1'b0;
        end
    end
 
    assign oread = read;
endmodule

Формировать сигнал валидности ovalid будем из сигнала записи в SIPO (он же clock enable или ice), используя edge detector. Схема оч простая и описывается в пару строчек кода.

Картинка с интернета

Просто берем сигнал и его задержанную на такт копию и в зависимости от того нужно задетектить фронт или спад сигнала, реализуем одну из двух приведенных схем. В этом проекте требуется сформировать сигнал валидности после окончания записи бит в SIPO, поэтому выберем negedge detection

negedge detection waveform

always @(posedge iclk)  
    ce <= ice;

assign ovalid = ((ice == 1'b0) && (ce))? 1'b1 : 1'b0;

Перейдем к самому главному: к полному сумматору. Вообще классическая схема n-битного сумматора выглядит вот так (ну одна из схем, а то и там бывает ой как много разных)

здесь мы видим, што это цепочка однотипных элементов fulladder, соединенная цепью переноса oc[x]. И в наша основная задача, превратить эту цепочку в «закольцованный» fulladder. Что-то типа такого:

Основной затык тут в том, чтобы выровнять сигнал переноса и приход данных, а так же сброс переноса при поступлении новых данных. Но оказалось эти нюансы просто решаются добавлением триггеров со сбросом на входы ia, ib, ic. Как таковая схема не претерпела каких-то серьезных изменений, а сам код модуля тоже остался максимально простым и понятным

Полный сумматор с закольцованной цепью переноса

`timescale 1ns / 1ps

module full_adder(
    input iclk,
    input ireset,
    input ia,
    input ib,
    output os,
    output oc
    );
    
    reg a, b, c;
    wire carry;
    
    always @(posedge iclk) begin
        if (ireset) begin
            a <= 0;
            b <= 0;
            c <= 0;
        end else begin
            a <= ia;
            b <= ib;
            c <= carry;
        end
    end
    
    assign {carry, os} = a + b + c;
    assign oc = carry;
    
    
endmodule

Ну и в конце описания блоков, приведу код для стандартных модулей PISO и SIPO.
Важный нюанс тут состоит в том, что нам нужно выдавать младший бит первым. Так же модель PISO имеет выход валидности данных, сформированный как задержанный на так сигнал чтения этих данных (он же clock enable или ice).

piso.v

`timescale 1ns / 1ps

module piso #(
    parameter C_WIDTH = 4)
(
    input iclk,
    input iload,
    input [C_WIDTH - 1 : 0] id,
    input ice,
    output ovalid,
    output oq
    );
    reg valid;
    reg [C_WIDTH-1:0] temp = 0;
    reg q;
    always @(posedge iclk) begin
            
        valid <= ice;
            
        if(iload) begin
            temp <=id;
               q <= 0;
        end else begin
            if (ice) begin
                  q <= temp[0];
               temp <= temp>>1;
            end                   
        end
    end

    assign oq     =     q;
    assign ovalid = valid;
    
endmodule

Для модуля SIPO было лень переписывать стандартный код выдачи старшего бита первым, поэтому я просто перевернул выходной вектор используя цикл for (ресурсов ПЛИС это не требует, а просто переподключает провода в векторе oq[N: M] = q[M: N])

SIPO

`timescale 1ns / 1ps

module sipo #(parameter C_WIDTH = 4)(
    input  iclk,
    input  ice,
    input  id,
    output [C_WIDTH-1:0] oq,
    output ovalid
);
reg [C_WIDTH-1:0] q;
reg valid;
reg ce;

always @(posedge iclk) begin
    if (ice) begin
        q <= {q [C_WIDTH-1:0], id};
    end
end

genvar i;
generate
  for(i=0; i

`timescale 1ns / 1ps

module top #(parameter C_WIDTH = 10000)(
    input iclk,
    input [C_WIDTH - 1 : 0]ia,
    input [C_WIDTH - 1 : 0]ib,
    input iload,
    output [C_WIDTH : 0] osum,
    output ovalid
    );
    
    wire control_oread;
    wire piso_a_oq;
    wire piso_b_oq;
    
    wire fa_oc;
    wire fa_os;
    
    wire [C_WIDTH - 1 : 0] sipo_oq;
    
    wire piso_ovalid;
    reg piso_ovalid_dff;
    wire delayed_load;
    
    full_adder fa (
        .iclk(iclk),
        .ireset(iload),
        .ia(piso_a_oq),
        .ib(piso_b_oq),
        .os(fa_os),
        .oc(fa_oc)
    );
    
    piso #(.C_WIDTH(C_WIDTH)) piso_a  ( 
        .iclk(iclk),
        .iload(iload),
        .id(ia),
        .ice(control_oread),
        .ovalid(piso_ovalid),
        .oq(piso_a_oq)
    );
    
    piso  #(C_WIDTH) piso_b (
        .iclk(iclk),
        .iload(iload),
        .id(ib),
        .ice(control_oread),
        .oq(piso_b_oq)
    );
    
    srl  #(C_WIDTH) srl_read (
        .iclk(iclk),
        .id(iload),
        .ice(1'b1),
        .oq(delayed_load)
    );
    
    sipo  # (C_WIDTH) sipo_s (
        .iclk(iclk),
        .ice(piso_ovalid_dff),
        .id(fa_os),
        .oq(sipo_oq),
        .ovalid(ovalid)    
    );
        
    flowcontrol fc (
        .iclk(iclk),    
        .iload(iload),
        .iload_delayed(delayed_load),
        .oread(control_oread) 
    );
    reg oc_dff;
    always @(posedge iclk) begin
        oc_dff <= fa_oc;
        piso_ovalid_dff <= piso_ovalid;
    end
    
    assign osum = {oc_dff, sipo_oq};
    
endmodule

`timescale 1ns / 1ps

module tb ();
    parameter C_WIDTH = 1000;
    parameter MAX_2POW = 15;
    reg clk;
    wire [C_WIDTH : 0] osum;
    wire ovalid;
    reg [C_WIDTH -1 : 0] ia, ib;
    reg load;
    
     initial begin
        clk = 0;
        ia = 0;
        ib = 0;
        load = 0;
    end
    
    always 
        #5 clk = !clk;
     
     integer i, j;   
     always begin
     //fpga startup
     #1000
     //
        for (i = 5; i < 2**MAX_2POW; i = i + 1) begin
            for (j = 6; j < 2**MAX_2POW; j = j + 1) begin
                ia = i;
                ib = j;
                load = 1;
                #10
                load = 0;
                wait (ovalid);
                #10;
            end
        end
        
        #200;
        $finish;
    end
    
    top #(C_WIDTH) dut (
        .iclk(clk),
        .ia(ia),
        .ib(ib),
        .iload(load),
        .osum(osum),
        .ovalid(ovalid)    
    );
endmodule