FIFO is essentially a first-in-first-out data buffer composed of RAM and read/write logic. The difference from RAM is that FIFO does not have external read/write address lines; data is written in sequence and read out in the same order, with the data address incremented by internal read/write pointers. Therefore, FIFO does not need to consider read/write conflict issues during operation.
According to the clock domain in which FIFO operates, it can be divided into synchronous FIFO and asynchronous FIFO. Synchronous FIFO uses the same clock for reading and writing, commonly used for temporary buffering where the data bit widths on both sides differ. Asynchronous FIFO has inconsistent read and write clocks, commonly used for processing data signals across clock domains.
Timing Diagram#
Synchronous FIFO#
In the initial state, the empty signal is high, indicating that the FIFO is empty. If a read operation is initiated at this time, the data read will be invalid. When wr_en is pulled high, data begins to be written into the FIFO. Once there is data in the FIFO, the empty signal will go low. After initiating read and write operations simultaneously, since it is a synchronous FIFO, the flags will not change.
When writing without reading, if there are two or more pieces of data in the FIFO, the almost empty signal will also go low. When the FIFO is full, it can only accept one write operation without a read operation, at which point the almost full signal will go high. Finally, if a write operation is performed without any read operation, the full signal will go high, indicating that the FIFO is now full. No further data can be written until a read request is made; if data is written at this time, it will be lost.
AXIS FIFO#
The timing diagram is as follows:
When writing data, s_axis_tvalid is high, and full is low, which means that s_axis_tready is high, allowing data to be written.
Similarly, when reading data, data can only be read when both valid and ready signals are high. m_axis_tvalid corresponds to the wr_en signal of the FIFO, m_axis_tready corresponds to the inverted full signal of the FIFO, s_axis_tvalid corresponds to the inverted empty signal of the FIFO, and s_axis_tready corresponds to the rd_en of the FIFO.
AXIS FIFO#
The IP core interface of the Axis FIFO is as follows:
This time, we are learning about asynchronous read/write of FIFO, so independent clock is selected as 'yes', and packet mode is not enabled. The Bd block diagram is as follows:
The output of clk_wiz has two ports, with port 1 having a clock rate of $100MHz$ and port 2 having a clock rate of $50MHz$. The source code for axis_data_source and axis_dest is as follows:
module axis_data_source (
input s_axis_clk,
input s_axis_rstn,
input m_axis_tready,
output [7:0] m_axis_tdata,
output m_axis_tvalid
);
reg [7:0] cnt;
always @(posedge s_axis_clk or negedge s_axis_rstn) begin
if(!s_axis_rstn) begin
cnt<=0;
end
else begin
if(m_axis_tready) begin
if(cnt==255) begin
cnt<=0;
end
else begin
cnt<=cnt+1'b1;
end
end
end
end
assign m_axis_tdata=cnt;
assign m_axis_tvalid=1'b1;
endmodule
/*read fifo data*/
module axis_dest (
input s_axis_clk,
input s_axis_tvalid,
input [7:0] s_axis_tdata,
output s_axis_tready
);
assign s_axis_tready=1'b1;
endmodule
In this case, data_source generates and outputs $0-0xFF$ at a rate of $100MHz$, while axis_dest continuously reads data at a rate of $50MHz$. The timing diagram is as follows:
It can be seen that initially the FIFO is not full, and writing and reading do not interfere with each other. As data is continuously written and cannot be read immediately, after a period of time, the FIFO's full signal goes high, corresponding to the m_axis_tready signal going low, and axis_data_source stops generating new data. The simulation diagram is as follows:
At this point, the rates of writing and reading are synchronized through the valid and ready signals.