FIFO (первым пришёл — первым вышел) — это память, часто используемая при асинхронной передаче данных. Её особенность в том, что данные обрабатываются по принципу «первым пришёл — первым вышел» (последним пришёл — последним вышел). Фактически проблему асинхронной передачи многоразрядных данных, будь то из быстрого тактового домена в медленный или из медленного в быстрый, можно решить с помощью FIFO.


Принцип работы FIFO

Рабочий процесс

После сброса под управлением тактового сигнала записи и сигналов состояния данные записываются в FIFO. Адрес записи RAM начинается с 0. При каждой записи данных указатель адреса записи увеличивается на единицу, указывая на следующую ячейку памяти. Когда FIFO заполнен, данные больше нельзя записывать; в противном случае данные будут потеряны из-за перезаписи.

Когда данные в FIFO находятся в непустом или полном состоянии, под управлением тактового сигнала чтения и сигналов состояния данные можно считать из FIFO. Адрес чтения RAM начинается с 0. При каждом чтении данных указатель адреса чтения увеличивается на единицу, указывая на следующую ячейку памяти. Когда FIFO пуст при чтении, данные больше нельзя считывать; в противном случае считанные данные будут неверными.

Структура хранения FIFO — это двухпортовая RAM, поэтому чтение и запись могут выполняться одновременно. Типичная структурная схема асинхронного FIFO показана ниже. Порты и внутренние сигналы будут объяснены при написании кода.

Временные диаграммы чтения/записи

Что касается временных диаграмм записи, пока FIFO не заполнен, можно выполнять операции записи; если FIFO заполнен, запись дополнительных данных запрещена.

Что касается временных диаграмм чтения, пока FIFO не пуст, можно выполнять операции чтения; если FIFO пуст, чтение дополнительных данных запрещено.

В любом случае, в период нормального чтения/записи FIFO, если чтение и запись выполняются одновременно, скорость записи в FIFO не должна превышать скорость чтения.

Состояние пустоты при чтении

В начале сброса в FIFO нет данных, и сигнал состояния пустоты активен. После записи данных в FIFO сигнал состояния пустоты переводится в низкий уровень и становится неактивным. Когда адрес чтения данных догоняет адрес записи, то есть когда адреса чтения и записи равны, FIFO находится в состоянии пустоты.

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

Строго говоря, такая индикация состояния пустоты неверна. Однако цель формирования состояния пустоты — не дать операциям чтения считывать данные из пустого FIFO. Когда формируется сигнал состояния пустоты, в FIFO фактически есть данные, что эквивалентно досрочному определению сигнала состояния пустоты. В этот момент безопасно прекратить чтение данных из FIFO. Поэтому с точки зрения применения такая схема допустима.

Состояние заполненности при записи

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

В этом случае часто используется дополнительный 1 бит как бит расширения для адресов чтения и записи соответственно, чтобы различать, пуст ли FIFO или полон, когда адреса чтения и записи совпадают. Когда адреса чтения/записи и биты расширения полностью совпадают, это означает, что объём записанных данных и прочитанных данных равен, и FIFO пуст. Если адреса чтения/записи совпадают, но биты расширения противоположны, это означает, что объём записанных данных превышает объём прочитанных данных на одну глубину FIFO, и FIFO полон. Конечно, предпосылкой для этого условия является то, что состояние пустоты запрещает операции чтения, а состояние полноты запрещает операции записи.

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


Проектирование FIFO

Требования к проектированию

Чтобы спроектировать FIFO, применимый к различным сценариям, предлагаются следующие требования:

  • (1) Глубина и ширина FIFO параметризуются, выводятся сигналы состояния пустоты и полноты, а также выводится настраиваемый сигнал состояния полноты. Когда количество внутренних данных в FIFO достигает настроенного значения параметра, переведите этот сигнал в высокий уровень.
  • (2) Разрядности входных и выходных данных могут не совпадать, но разрядности записываемых данных и адреса записи должны быть согласованы с разрядностями читаемых данных и адреса чтения. Например, разрядность записываемых данных равна 8 битам, а разрядность адреса записи — 6 битам (64 элемента данных). Если требуется, чтобы разрядность выходных данных была 32 бита, разрядность выходного адреса должна быть 4 бита (16 элементов данных).
  • (3) FIFO является асинхронным, то есть сигналы управления чтением и записью поступают из разных тактовых доменов. Перед выводом сигналов состояния «пусто» и «полно» сигналы адреса чтения и записи следует синхронизировать с помощью кода Грея, а ошибки передачи данных при синхронизации с помощью регистровой выборки следует уменьшить за счёт сокращения переключений многоразрядных сигналов. Преобразование между кодом Грея и двоичным кодом показано ниже.

Проектирование двухпортовой RAM

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

Описание на Verilog приведено ниже.

Пример

module  ramdp
    #(  parameter       AWI     = 5 ,
        parameter       AWO     = 7 ,
        parameter       DWI     = 64 ,
        parameter       DWO     = 16
        )
    (
        input                   CLK_WR , //такт записи
        input                   WR_EN ,  //разрешение записи
        input [AWI-1:0]         ADDR_WR ,//адрес записи
        input [DWI-1:0]         D ,      //данные для записи
        input                   CLK_RD , //такт чтения
        input                   RD_EN ,  //разрешение чтения
        input [AWO-1:0]         ADDR_RD ,//адрес чтения
        output reg [DWO-1:0]    Q        //данные чтения
     );
   //Ширина выхода больше ширины входа, найти коэффициент расширения и соответствующее количество бит
   parameter       EXTENT       = DWO/DWI ;
   parameter       EXTENT_BIT   = AWI-AWO > 0 ? AWI-AWO : 'b1 ;
   //Ширина входа больше ширины выхода, найти коэффициент сокращения и соответствующее количество бит
   parameter       SHRINK       = DWI/DWO ;
   parameter       SHRINK_BIT   = AWO-AWI > 0 ? AWO-AWI : 'b1;

   genvar i ;
   generate
      //Расширение разрядности данных (сокращение разрядности адреса)
      if (DWO >= DWI) begin
         //Логика записи, запись один раз за такт
         reg [DWI-1:0]         mem [(1<<AWI)-1 : 0] ;
         always @(posedge CLK_WR) begin
            if (WR_EN) begin
               mem[ADDR_WR]  <= D ;
            end
         end

         //Логика чтения, чтение 4 раза за такт
         for (i=0; i<EXTENT; i=i+1) begin
            always @(posedge CLK_RD) begin
               if (RD_EN) begin
                  Q[(i+1)*DWI-1: i*DWI]  <= mem[(ADDR_RD*EXTENT) + i ] ;
               end
            end
         end
      end

      //=================================================
      //Сокращение разрядности данных (расширение разрядности адреса)
      else begin
         //Логика записи, запись 4 раза за такт
         reg [DWO-1:0]         mem [(1<<AWO)-1 : 0] ;
         for (i=0; i<SHRINK; i=i+1) begin
            always @(posedge CLK_WR) begin
               if (WR_EN) begin
                  mem[(ADDR_WR*SHRINK)+i]  <= D[(i+1)*DWO -1: i*DWO] ;
               end
            end
         end

         //Логика чтения, чтение один раз за такт
         always @(posedge CLK_RD) begin
            if (RD_EN) begin
                Q <= mem[ADDR_RD] ;
            end
         end
      end
   endgenerate

endmodule

Проектирование счётчика

Счётчик используется для формирования адресной информации чтения/записи. Его разрядность настраивается. Задавать конечное значение не нужно; просто дайте ему переполниться и автоматически начать счёт заново. Описание на Verilog выглядит следующим образом.

Пример

module  ccnt
  #(параметр W )
   (
    input              rstn ,
    input              clk ,
    input              en ,
    output [W-1:0]     count
    );

   reg [W-1:0]          count_r ;
   always @(posedge clk or negedge rstn) begin
      if (!rstn) begin
         count_r        <= 'b0 ;
      end
      else if (en) begin
         count_r        <= count_r + 1'b1 ;
      end
   end
   assign count = count_r ;

endmodule

Проектирование FIFO

Этот модуль — основная часть FIFO. Он генерирует логику управления чтением/записью и формирует сигналы состояния empty, full и programmable full.

Из-за ограничений по объёму здесь приведён только код логики для случая, когда ширина данных чтения больше ширины данных записи. Описание кода для случая, когда ширина данных записи больше ширины данных чтения, см. в приложении.

Пример

module  fifo
    #(  parameter       AWI        = 5 ,
        parameter       AWO        = 3 ,
        parameter       DWI        = 4 ,
        parameter       DWO        = 16 ,
        parameter       PROG_DEPTH = 16) //Настраиваемая глубина
    (
        input                   rstn,  //Один сброс для чтения и записи
        input                   wclk,  //тактовый сигнал записи
        input                   winc,  //разрешение записи
        input [DWI-1: 0]        wdata, //данные записи

        input                   rclk,  //тактовый сигнал чтения
        input                   rinc,  //разрешение чтения
        output [DWO-1 : 0]      rdata, //данные чтения

        output                  wfull,    //флаг заполнения записи
        output                  rempty,   //флаг пустоты чтения
        output                  prog_full //флаг программируемого заполнения
     );

   //Ширина выхода больше ширины входа, найти коэффициент расширения и соответствующее количество бит
   parameter       EXTENT       = DWO/DWI ;
   parameter       EXTENT_BIT   = AWI-AWO ;
   //Ширина выходных данных меньше ширины входных данных, найдите коэффициент уменьшения и соответствующее количество бит
   parameter       SHRINK       = DWI/DWO ;
   parameter       SHRINK_BIT   = AWO-AWI ;

   //==================== счетчик push/wr ===============
   wire [AWI-1:0]      waddr ;
   wire                wover_flag ; //Использовать один дополнительный бит для расширения адреса записи
   ccnt         #(.W(AWI+1))            
   u_push_cnt(
      .rstn           (rstn),
      .clk            (wclk),
      .en             (winc && !wfull), //Запретить запись, когда заполнено
      .count          ({wover_flag, waddr})
        );

   //============== счетчик pop/rd ===================
   wire [AWO-1:0]            raddr ;
   wire                      rover_flag ;  //Использовать один дополнительный бит для расширения адреса чтения
   ccnt         #(.W(AWO+1))    
   u_pop_cnt(
      .rstn           (rstn),
      .clk            (rclk),
      .en             (rinc & !rempty), //Запретить чтение, когда пусто
      .count          ({rover_flag, raddr})
      );

   //==============================================
   //Узкие данные на входе, широкие данные на выходе
generate
   if (DWO >= DWI) begin : EXTENT_WIDTH

      //Преобразование кода Грея
      wire [AWI:0] wptr    = ({wover_flag, waddr}>>1) ^ ({wover_flag, waddr}) ;
      //Синхронизировать указатель записи данных с доменом тактового сигнала чтения
      reg [AWI:0]  rq2_wptr_r0 ;
      reg [AWI:0]  rq2_wptr_r1 ;
      always @(posedge rclk or negedge rstn) begin
         if (!rstn) begin
            rq2_wptr_r0     <= 'b0 ;
            rq2_wptr_r1     <= 'b0 ;
         end
         else begin
            rq2_wptr_r0     <= wptr ;
            rq2_wptr_r1     <= rq2_wptr_r0 ;
         end
      end

      //Преобразование кода Грея
      wire [AWI-1:0] raddr_ex = raddr << EXTENT_BIT ;
      wire [AWI:0]   rptr     = ({rover_flag, raddr_ex}>>1) ^ ({rover_flag, raddr_ex}) ;
      //Синхронизировать указатель чтения данных с тактовым доменом записи
      reg [AWI:0]    wq2_rptr_r0 ;
      reg [AWI:0]    wq2_rptr_r1 ;
      always @(posedge wclk or negedge rstn) begin
         if (!rstn) begin
            wq2_rptr_r0     <= 'b0 ;
            wq2_rptr_r1     <= 'b0 ;
         end
         else begin
            wq2_rptr_r0     <= rptr ;
            wq2_rptr_r1     <= wq2_rptr_r0 ;
         end
      end

      //Обратное преобразование кода Грея
      //Если нужны только сигналы состояния пустоты и полного заполнения, обратное преобразование не требуется
      //Поскольку есть программируемый сигнал полного состояния, обратное преобразование адреса удобно для сравнения
      reg [AWI:0]       wq2_rptr_decode ;
      reg [AWI:0]       rq2_wptr_decode ;
      целое число           i ;
      always @(*) begin
         wq2_rptr_decode[AWI] = wq2_rptr_r1[AWI];
         for (i=AWI-1; i>=0; i=i-1) begin
            wq2_rptr_decode[i] = wq2_rptr_decode[i+1] ^ wq2_rptr_r1[i] ;
         end
      end
      always @(*) begin
         rq2_wptr_decode[AWI] = rq2_wptr_r1[AWI];
         for (i=AWI-1; i>=0; i=i-1) begin
            rq2_wptr_decode[i] = rq2_wptr_decode[i+1] ^ rq2_wptr_r1[i] ;
         end
      end

      //Когда адреса чтения/записи и биты расширения полностью совпадают, это пустое состояние
      assign rempty    = (rover_flag == rq2_wptr_decode[AWI]) &&
                         (raddr_ex >= rq2_wptr_decode[AWI-1:0]);
      //Когда адреса чтения/записи совпадают, но биты расширения различаются, это полное состояние
      assign wfull     = (wover_flag != wq2_rptr_decode[AWI]) &&
                         (waddr >= wq2_rptr_decode[AWI-1:0]) ;
      //Когда биты расширения совпадают, адрес записи обязательно не меньше адреса чтения
      //Когда биты расширения различаются, часть адреса записи обязательно меньше адреса чтения; к фактическому адресу записи нужно добавить одну глубину FIFO
      assign prog_full  = (wover_flag == wq2_rptr_decode[AWI]) ?
                          waddr - wq2_rptr_decode[AWI-1:0] >= PROG_DEPTH-1 :
                          waddr + (1<<AWI) - wq2_rptr_decode[AWI-1:0] >= PROG_DEPTH-1;

      //Создание экземпляра двухпортовой RAM
      ramdp
        #( .AWI     (AWI),
           .AWO     (AWO),
           .DWI     (DWI),
           .DWO     (DWO))
      u_ramdp
        (
         .CLK_WR          (wclk),
         .WR_EN           (winc & !wfull), //Запретить запись, когда буфер заполнен
         .ADDR_WR         (waddr),
         .D               (wdata[DWI-1:0]),
         .CLK_RD          (rclk),
         .RD_EN           (rinc & !rempty), //Запретить чтение, когда пусто
         .ADDR_RD         (raddr),
         .Q               (rdata[DWO-1:0])
         );

   end

   //==============================================
   //широкий вход и узкий выход
   /*
   else begin: SHRINK_WIDTH
      ……
   end
   */

 endgenerate
endmodule

Инстанцирование FIFO

Разработанный FIFO можно инстанцировать ниже для выполнения асинхронной обработки передачи данных разрядностью в несколько бит.

Разрядность записываемых данных — 4 бита, а глубина записи — 32.

Разрядность считываемых данных — 16 бит, глубина чтения — 8, а настраиваемая полная глубина — 16.

Пример

module  fifo_s2b(
        input                   rstn,
        input [4-1: 0]          din,     //Асинхронные данные записи
        input                   din_clk, //Асинхронный тактовый сигнал записи
        input                   din_en,  //асинхронное разрешение записи

        output [16-1 : 0]       dout,      //данные после синхронизации
        input                   dout_clk,  // Использовать тактовый сигнал синхронно
        input                   dout_en ); // Синхронное разрешение данных

   wire         fifo_empty, fifo_full, prog_full ;
   wire         rd_en_wir ;
   wire [15:0]  dout_wir ;

   // Запретить чтение в состоянии «пусто для чтения», иначе чтение будет продолжаться
   assign rd_en_wir     = fifo_empty ? 1'b0 : 1'b1 ;

   fifo  #(.AWI(5), .AWO(3), .DWI(4), .DWO(16), .PROG_DEPTH(16))
     u_buf_s2b(
        .rstn           (rstn),
        .wclk           (din_clk),
        .winc           (din_en),
        .wdata          (din),

        .rclk           (dout_clk),
        .rinc           (rd_en_wir),
        .rdata          (dout_wir),

        .wfull          (fifo_full),
        .rempty         (fifo_empty),
        .prog_full      (prog_full));

   // Данные и разрешение после синхронизации кэша
   reg          dout_en_r ;
   always @(posedge dout_clk or negedge rstn) begin
      if (!rstn) begin
         dout_en_r       <= 1'b0 ;
      end
      else begin
         dout_en_r       <= rd_en_wir ;
      end
   end
   assign       dout    = dout_wir ;
   assign       dout_en = dout_en_r ;

endmodule

testbench

Пример

`timescale 1ns/1ns
`define         SMALL2BIG
module test ;

`ifdef SMALL2BIG
   reg          rstn ;
   reg          clk_slow, clk_fast ;
   reg [3:0]    din ;
   reg          din_en ;
   wire [15:0]  dout ;
   wire         dout_en ;

   //сброс
   initial begin
      clk_slow  = 0 ;
      clk_fast  = 0 ;
      rstn      = 0 ;
      #50 rstn  = 1 ;
   end

   // Тактовый сигнал чтения clock_slow быстрее, чем 1/4 тактового сигнала записи clk_fast
   // Убедитесь, что данные чтения немного быстрее данных записи
   parameter CYCLE_WR = 40 ;
   always #(CYCLE_WR/2/4) clk_fast = ~clk_fast ;
   always #(CYCLE_WR/2-1) clk_slow = ~clk_slow ;

   // генерация данных
   initial begin
      din       = 16'h4321 ;
      din_en    = 0 ;
      wait (rstn) ;
      //(1) Проверка сигналов full, prog_full, empty
      force test.u_data_buf2.u_buf_s2b.rinc = 1'b0 ;
      repeat(32) begin
         @(negedge clk_fast) ;
         din_en = 1'b1 ;
         din    = {$random()} % 16;
      end
      @(negedge clk_fast) din_en = 1'b0 ;

      //(2) Проверка чтения/записи данных
      #500 ;
      rstn = 0 ;
      #10 rstn = 1 ;
      release test.u_data_buf2.u_buf_s2b.rinc;
      repeat(100) begin
         @(negedge clk_fast) ;
         din_en = 1'b1 ;
         din    = {$random()} % 16;
      end

      //(3) Остановить чтение и снова проверить сигналы empyt, full, prog_full
      force test.u_data_buf2.u_buf_s2b.rinc = 1'b0 ;
      repeat(18) begin
         @(negedge clk_fast) ;
         din_en = 1'b1 ;
         din    = {$random()} % 16;
      end
   end

   fifo_s2b u_data_buf2(
        .rstn           (rstn),
        .din            (din),
        .din_clk        (clk_fast),
        .din_en         (din_en),

        .dout           (dout),
        .dout_clk       (clk_slow),
        .dout_en        (dout_en));

`else
`endif

   //остановить моделирование
   initial begin
      forever begin
         #100;
         if ($time >= 5000)  $finish ;
      end
   end

endmodule

Анализ моделирования

На основе 3-шагового тестового воздействия в тестбенче анализ выглядит следующим образом:

Тест (1): Результаты временного анализа порта FIFO и некоторых внутренних сигналов приведены ниже.

Как видно из рисунка, перед тем как FIFO внутренне начинает записывать данные и сигнал состояния пустоты переходит в низкий уровень, есть период задержки. Это вызвано синхронизацией информации об адресах чтения/записи.

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

Тест (2): Когда FIFO одновременно выполняет чтение и запись, портовые сигналы цифрового модуля верхнего уровня асинхронной обработки показаны ниже. Два рисунка соответственно показывают процесс чтения в начале и в конце передачи данных.

Как видно из рисунков, данные корректно передаются как в начале, так и в конце, что завершает асинхронную обработку данных различной разрядности между разными тактовыми доменами.

Тест (3): Временная диаграмма моделирования всего поведения чтения/записи FIFO и остановки чтения показана ниже.

Как видно из рисунка, когда чтение и запись выполняются одновременно, сигнал состояния пустоты чтения rempty переходит в низкий уровень, что указывает на запись данных в FIFO. С одной стороны, скорость чтения данных немного выше скорости записи, и между передачами данных есть задержка, поэтому rempty будет переходить в высокий уровень в промежуточном процессе.

Во время процесса чтения/записи сигналы full и prog_full остаются на низком уровне, что указывает на то, что объем данных в FIFO не достиг определенного уровня. После остановки операции чтения два сигнала full вскоре переходят в высокий уровень, что указывает на заполнение FIFO. При внимательном сравнении информации об адресах чтения/записи поведение FIFO не вызывает проблем.

Полная реализация FIFO представлена во вложении, включая асинхронную реализацию и моделирование для случаев, когда разрядность входных данных меньше разрядности выходных данных.

Скачать исходный код для этой главы

Скачать