【双FiFo流水线操作】

已于 2024-01-14 18:21:41 修改
阅读量419 收藏 8
点赞数 10
文章标签： fpga开发
于 2024-01-14 18:02:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45727248/article/details/135585851
版权
这篇文章详细描述了一个硬件设计中的串口输入模块，用于处理86x86数据，通过连续三行对应列的数值相加，并通过串转并模块实现。同时介绍了FIFO的控制逻辑，以及整个系统的时序同步和仿真过程。着重展示了UART通信和数据处理的实现方法。
摘要由CSDN通过智能技术生成

串口输入86×86的数据，让连续三行对应列的三个数相加，结果串口输出

rx模块，串转并

module uart_rx(
	input	wire 				sclk,
	input	wire 				rst_n,
	input	wire 				rx,
	output	reg 	[7:0]		po_data,
	output	reg 				po_flag
	);

//parameter 	CNT_BAUD_MAX =5207; 下板子用这个，波特率为9600
parameter 	CNT_BAUD_MaAX =9;   //设置为9，方便仿真
//parameter	CNT_HALF_BAUD_MAX =2603; 下板子用这个，波特率为9600
parameter	CNT_HALF_BAUD_MAX =4; //设置为4，方便仿真
reg 			rx1,rx2,rx2_reg;
reg 			rx_flag;
reg 	[12:0]	cnt_baud;
reg 			bit_flag;
reg     [2:0]   num;
reg 	[3:0]	bit_cnt;

always @(posedge sclk) begin
	{rx2_reg,rx2,rx1}<={rx2,rx1,rx};
end
always @(posedge sclk or negedge  rst_n) begin
	if (rst_n == 1'b0) begin
		rx_flag <= 1'b0;
	end
	else if (bit_cnt == 4'd8 && bit_flag == 1'b1) begin
		rx_flag <= 1'b0;
	end
	else if (rx2_reg == 1'b1 && rx2 == 1'b0) begin
		rx_flag <= 1'b1;
	end
end
always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		cnt_baud <= 'd0;
	end
	else if (rx_flag == 1'b0) begin
		cnt_baud <= 'd0;
	end
	else if (rx_flag == 1'b1 && cnt_baud == CNT_BAUD_MAX) begin
		cnt_baud <= 'd0;
	end
	else if (rx_flag == 1'b1) begin
		cnt_baud <= cnt_baud + 1'b1;
	end
end
always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		bit_flag <= 1'b0;
	end
	else if (rx_flag == 1'b1 && cnt_baud == CNT_HALF_BAUD_MAX) begin
		bit_flag <= 1'b1;
	end
	else begin
		bit_flag <= 1'b0;
	end
end
always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		bit_cnt <= 'd0;
	end
	else if (bit_flag == 1'b1 && bit_cnt == 'd8) begin
		bit_cnt <= 'd0;
	end
	else if (bit_flag == 1'b1) begin
		bit_cnt <= bit_cnt + 1'b1;
	end
end
always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		po_data <='d0;
	end
	else if (bit_cnt >= 4'd1 && bit_flag == 1'b1) begin
		po_data <= {rx2_reg,po_data[7:1]};
	end
end
always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin	
		po_flag <= 1'b0;
	end
	else if (bit_cnt == 4'd8 && bit_flag == 1'b1) begin
		po_flag <= 1'b1;
	end
	else begin
		po_flag <= 1'b0;
	end
end
endmodule

ctrl_fifo模块

module crtl_fifo(  
input wire pi_flag, 
input wire [7:0]pi_data,
input wire clk,
input wire rst_n,
output reg [7:0] po,
output reg po_flag
    );
reg [6:0]cnt_lie,cnt_row;
reg wr_en0,rd_en;
wire full0,empty0;
reg [7:0]wr_data0;
wire [7:0] dout0;
reg wr_en1;
wire full1,empty1;
reg [7:0]wr_data1;
wire [7:0] dout1;
   fifo_generator_0 inst_fifo
         (
          .clk(clk),
           .din( wr_data0 ),
           . wr_en (wr_en0),
           . rd_en (rd_en),
           .dout(dout0),
            .full(full0),
            .empty(empty0)
          );
         fifo_generator_1 inst_fifo1
                 (
          .clk(clk),
           .din( wr_data1 ),
           . wr_en (wr_en1),
           . rd_en (rd_en),
           .dout(dout1),
            .full(full1),
            .empty(empty1)
          );
//cnt_lie,列的个数
always @(posedge clk or negedge rst_n) begin
          if (rst_n == 1'b0) begin
              cnt_lie <= 1'b0;
          end       
          else if (cnt_lie == 'd85&&pi_flag== 'd1) begin
              cnt_lie <= 1'b0;
           end
          else if (pi_flag== 'd1) begin
              cnt_lie  <= cnt_lie+1'b1;
          end
      end
//cnt_row,行的个数
      always @(posedge clk or negedge rst_n) begin
                if (rst_n == 1'b0) begin
                    cnt_row <= 1'b0;
                end       
                else if (cnt_row == 'd85&&pi_flag== 'd1&&cnt_lie == 'd85) begin
                    cnt_row <= 1'b0;
                 end
                else if (pi_flag== 'd1&&cnt_lie == 'd85) begin
                    cnt_row  <=cnt_row+1'b1;
                end
            end
//wr_en0,fifo0写使能,当行数为0或2-84时fifo0写使能有效
always @(posedge clk or negedge rst_n) begin
          if (rst_n == 1'b0) begin
              wr_en0 <= 1'b0;
          end
          else if ((cnt_row== 'd0&&pi_flag==1)||(cnt_row>=2&&cnt_row<=84&&pi_flag==1)) begin
              wr_en0 <= 1'b1;
          end
          else  wr_en0 <= 1'b0;
      end
//wr_data0,fifo0写数据，第0行时写入rx_data,2-84写入fif01中读出的数据
always @(posedge clk or negedge rst_n) begin
                if (rst_n == 1'b0) begin
                    wr_data0 <= 1'b0;
                end
                else if (pi_flag==1&&cnt_row== 'd0) begin
                    wr_data0 <= pi_data;
                end
                else  if(cnt_row>=2&&cnt_row<=84&&pi_flag==1)
                    wr_data0 <= dout1;
            end
//wr_en1,fifo1写使能,当行数1-84时fifo1写使能有效
            always @(posedge clk or negedge rst_n) begin
                      if (rst_n == 1'b0) begin
                          wr_en1 <= 1'b0;
                      end
                      else if (cnt_row>=1&&cnt_row<=84&&pi_flag==1) begin
                          wr_en1 <= 1'b1;
                      end
                      else  wr_en1 <= 1'b0;
                  end
//wr_data1,fifo1写数据，写入rx_data
                  always @(posedge clk or negedge rst_n) begin
                                  if (rst_n == 1'b0) begin
                                      wr_data1 <= 1'b0;
                                  end
                                  else if (pi_flag==1&&cnt_row>=1&&cnt_row<=84) begin
                                      wr_data1 <= pi_data;
                                  end
                                 end
//rd_en,读使能，第2-85行
always @(posedge clk or negedge rst_n) begin
          if (rst_n == 1'b0) begin
              rd_en <= 1'b0;
          end
          else if (cnt_row>=2&&pi_flag==1) begin
               rd_en <= 1'b1;
          end
          else   rd_en <= 1'b0;
      end
//fifo0,fifo1与pi_flag求和
always @(posedge clk or negedge rst_n) begin
          if (rst_n == 1'b0) begin
              po <= 1'b0;
              po_flag<='b0;
          end
          else if (rd_en=='d1) begin
               po <= pi_data+dout1+dout0;
               po_flag<='d1;
          end
          else po_flag<='b0;
      end                
endmodule

top模块

module top(
	input	wire clk,
	input	wire rst_n,
	input	wire rx,
	output wire tx
    );
    wire [7:0]data;
    wire flag;
    wire flag_sumover;
    wire [7:0]sum;
  uart_rx inst_rx(
    .sclk(clk),
    .rst_n(rst_n),
    .rx(rx),
    .po_data(data),
    .po_flag(flag)
  );
  uart_tx inst_tx(
     .sclk(clk),
      .rst_n(rst_n),
      .pi_flag(flag_sumover),
      .pi_data(sum),
      .tx(tx)
      );
   crtl_fifo int_ctrl(  
     .pi_flag(flag), 
      .pi_data(data),
      .clk(clk),
      .rst_n(rst_n),
      .po(sum),
      .po_flag(flag_sumover)
    ); 
endmodule

tx模块

module uart_tx(
	input	wire 			sclk,
	input	wire 			rst_n,
	input	wire 			pi_flag,
	input	wire 	[7:0]	pi_data,
	output	reg 			tx
	);
//parameter CNT_BAUD_MAX =5207; 下板子用这个，波特率9600
parameter CNT_BAUD_MAX =9; //为了仿真方便，设置为9
reg 	[7:0]	data_reg;
reg 			tx_flag,pi_flag2;
reg 	[12:0]	cnt_baud;
reg 			bit_flag;
reg 	[3:0]	bit_cnt;
always @(posedge sclk or negedge  rst_n) begin
	if (rst_n == 1'b0) begin
		pi_flag2 <='d0;
	end
	else if (pi_flag == 1'b1) begin
		pi_flag2 <=1;
	end
	else pi_flag2 <='d0;
end
always @(posedge sclk or negedge  rst_n) begin
	if (rst_n == 1'b0) begin
		data_reg <='d0;
	end
	else if (pi_flag2 == 1'b1) begin
		data_reg <= pi_data;
	end
end
always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		tx_flag <= 1'b0;
	end
	else if(bit_flag == 1'b1 && bit_cnt == 4'd8) begin
		tx_flag <= 1'b0;
	end
	else if (pi_flag == 1'b1) begin
		tx_flag <= 1'b1;
	end
end

always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		cnt_baud <= 'd0;
	end
	else if(tx_flag == 1'b0)begin
		cnt_baud <='d0;
	end
	else if (tx_flag == 1'b1 && cnt_baud == CNT_BAUD_MAX) begin
		cnt_baud <= 'd0;
	end
	else if (tx_flag == 1'b1) begin
		cnt_baud <= cnt_baud + 1'b1;
	end
end

always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		bit_flag <= 1'b0;
	end
	else if (cnt_baud == CNT_BAUD_MAX -1  && tx_flag == 1'b1) begin
		bit_flag <= 1'b1;
	end
	else begin
		bit_flag <= 1'b0;
	end
end


always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		bit_cnt <= 'd0;
	end
	else if(bit_flag == 1'b1 &&  bit_cnt == 4'd8) begin
		bit_cnt <= 'd0;
	end
	else if (bit_flag == 1'b1) begin
		bit_cnt <= bit_cnt + 1'b1;
	end
end

always @(posedge sclk or negedge rst_n) begin
	if (rst_n == 1'b0) begin
		tx <= 1'b1;
	end
	else if (pi_flag == 1'b1) begin
		tx <= 1'b0;
	end
	else if (bit_cnt<=7 && bit_flag == 1'b1) begin
		tx <= data_reg[bit_cnt];
	end
	else if (bit_flag == 1'b1 && bit_cnt == 4'd8) begin
		tx <= 1'b1;
	end
end
endmodule

仿真模块

`timescale 1ns / 1ps
module tb_top_uart;
	// Inputs
	reg sclk;
	reg rst_n;
	reg rx;
	reg [7:0]mem[85:0];
	// Outputs
	wire tx;
	// Instantiate the Unit Under Test (UUT)
	top  uut (
		.clk(sclk), 
		.rst_n(rst_n), 
		.rx(rx), 
		.tx(tx)
	);
	initial begin
		// Initialize Inputs
		sclk = 0;
		rst_n = 0;
		rx = 1;
		// Wait 100 ns for global reset to finish
		#100;
        rst_n =1;
		// Add stimulus here

	end
	always #10 sclk = ~sclk;
	initial begin
		$readmemb("C:/zynq/fifo-add/fifo-add.srcs/sim_1/new/data.txt",mem);
	end
	
	
	initial begin
		#200;
		rx_byte();
	end

	task rx_byte();
		integer i;
		integer j;
		begin
			for(j=0;j<86;j=j+1)begin
				for (i=0;i<86;i=i+1)begin
					rx_bit(mem[i]);
				end
			end
		end
	endtask
    

    task rx_bit(input [7:0] data);
    	integer i;
    	begin
    		for(i=0;i<10;i=i+1) begin
    			case (i)
					 0:rx =0;
					 1:rx =data[i-1];
					 2:rx =data[i-1];
					 3:rx =data[i-1];
					 4:rx =data[i-1];
					 5:rx =data[i-1];
					 6:rx =data[i-1];
					 7:rx =data[i-1];
					 8:rx =data[i-1];
					 9:rx =1;
    			endcase 
    			//#104160; 
    			#200;
    		end
    	end
    endtask  
endmodule

仿真效果

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
注：FIFO采用的是First-Word Fall-Through 读模式，读出的数据和读使能之间无延迟。

仰望星空D
关注
双FIFO流水线操作
qq_45565330的博客
11-02 1019
FIFO双流水实现
FPGA——双fifo的使用
qq_39231491的博客
09-03 2771
利用双fifo实现3个数值相加。实现10排0-85 每三排的数实现竖直相加。 module fifo( input wire clk , input wire rst_n , input wire[7:0] dina , input wire wr_en , ou...
linux 双向fifo
紫枫洛天的博客
05-12 274
注意open打开fifo的方式, 有阻塞和非阻塞模式 如果读阻塞模式打开, 那么要等到一个进程写入fifo之后, 这个读open才会打开 1 客户端 #include <stdio.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include<.
双口FIFO与RAM
Deep_accelerater的博客
06-27 1508
FIFO 该部分转载自异步FIFO—Verilog实现与异步FIFO设计 一、FIFO简介 FIFO是英文First In First Out 的缩写，是一种先进先出的数据缓存器，它与普通存储器的区别是没有外部读写地址线，这样使用起来非常简单，但缺点就是只能顺序写入数据，顺序的读出数据，其数据地址由内部读写指针自动加1完成，不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。 用途1： ...
二、双fifo流水线操作——verilog练习与设计
最新发布
k7126685的博客
05-04 629
fifo流水线操作
【FPGA学习】对FIFO的理解及双FIFO流水操作实验
jkgkj的博客
08-27 5985
FIFO（First input First Output） ，即先入先出，本质上是一个RAM，FIOF和RAM的共同点在于都是能储存数据，都有控制读和写的信号，不同点在于FIOF没有地址，因此不能任意指定读取某个数据，数据只能按照数据输入的顺序输出，且读写可以同时进行。 如果将数据把fifo的深度写满，数据将不能在进去，也不会覆盖原来的数据，读取fifo的数据也只能读一遍，读完一遍fifo就空了，需要再往fifo写数据才能读出新的数据，否则读出的数据一直是最后一次读fifo时的数据。..........
sync_srl_fifo.rar_srl_fifo_xilinx fifo
07-15
9. **性能优化**：为了提高性能，可能需要考虑流水线技术、异步接口、分布式RAM与Block RAM的混合使用等优化策略。 10. **仿真与验证**：在实际设计中，需要通过硬件描述语言的仿真工具（如ModelSim、Vivado ...
fifo.rar_fifo_异步FIFO
09-14
- **流水线设计**：为了提高数据吞吐率，FIFO的读写操作通常采用流水线方式，即读写操作可以在同一时间间隔内连续进行。 - **错误检测和恢复**：在系统运行过程中，可能会出现错误，如读写指针的异常。因此，需要...
FIFO.rar_control_control fifo_fifo control _fifo vhdl_fpga FIFO
09-21
6. **流水线设计**：在FPGA中，为了提高系统吞吐率，FIFO常与流水线技术结合，使得数据处理可以在多个阶段并行进行。 7. **错误检测与恢复**：设计中可能需要考虑错误检测机制，如奇偶校验位，以确保数据的完整性。...
FIFO.rar_fifo_fifo verilog_fifo vhdl
09-24
对于高性能应用，还可能引入流水线技术、预读策略、双端口或多端口存储器来提高吞吐量和效率。 总的来说，理解和实现FIFO对于任何涉足数字系统设计的工程师来说都是至关重要的。通过熟练掌握Verilog和VHDL，可以...
双fifo的乒乓式读写
a931863759的博客
09-29 7344
备注：fifo可以换成RAM等其他类型储存单元，只因熟悉fifo所以用它来说明（重点是如何使用乒乓式读写） 简介：一种常常应用于数据流控制的处理技巧，在保证等时域的前提下，两个fifo交互式的传输数据给数据处理模块。 处理流程：边看图边解释。首先是AD采集的数据流入，在等时域前提下，fifo1进行写操作，fifo2进行读操作（当然第一次没有可读的，但是数据流入的第一个周期是很短的）。fifo1
STM32F105双CAN双FIFO通讯心得体会
木牛的博客
01-03 1172
具体结合到本案例，客户代码里对CAN1、CAN2的过滤器进行配置时，当前过滤器组始终为0，即sFilterConfig.FilterNumber=0，而分配给CAN2的过滤器组又是从BANK 14开始的，即sFilterConfig.BankNumber = 14。的通讯，过程中遇到很多问题，在手头只有一个很小的开发板的情况下，费劲周折，终于解决了问题，不多说，直接把入坑与出坑的事情说一下吧。这个的出坑还是自己出的：FIFO0和FIFO1对应的RXMSG是不一样的，因为没有注意到，结果写成了一样，
双fifo流水线实现3x1024数组数据按列相加
weixin_38828382的博客
06-04 914
Vivado版本：2019.2 MATLAB Modelsim版本：Modelsim SE-64 10.7 实验内容：双fifo流水线实现3x1024数组数据按列相加 FIFO，First Input First Output，既先入先出，也是一种存储器。本质上还是RAM，外面加了一层地址管理，这样使得FIFO没有地址线，使得使用起来非常方便。缺点是只能顺序写入和顺序读出，不能随机访问。如果数据把FIFO写满了，数据就不能继续写入，原来的数据也不会被覆盖；读取数据也只能读取一遍，读空后继续进
STM32的CAN总线的接收双FIFO使用方法
xiahailong90的博客
08-08 1万+
通过下面的框图我们可以看到，STM32F013有两个接收FIFO图片:1.png 但是实际的使用中如何让着两个FIFO都被使用呢，解决办法就在这里， 1. STM32F103有0-13共14个过滤器组，每个过滤器组都可以绑定指定的FIFO。图片:1.png 图片:2.png 2. 特别需要注意的一点是，FIFO0和FIFO1的接收对应不同的中断入口，切记。 ...
双时钟FIFO设计例子
weiyunguan8611的博客
05-04 1194
2.2.1 顶层设计 2.2.2 顶层架构 2.2.4 安全FIFO访问 1.最小满用量MinUsedwFull=3 2.最小空用量MinUsedwEmpty=3 2.2.5 读握手的算法流程图ASM Charts 2.2.6 写握手的算法流程图ASM Charts 代码只是对上述逻辑图进行语言描述，由于文件太多，贴上来不方便，下面留上链接，自行下载。用的开发环境是quartues，仿真...
STM32f103 can的两个接收fifo使用方法
热门推荐
varding的专栏
09-10 2万+
stm32的文档上说can有两个接收fifo，但是对具体怎么使用并没有特别提到，在网上也没有找到靠谱或者统一的说法 我看了几个例子和文档也没发现具体怎么设置使用哪个fifo 今天仔细的看了下文档里的图片，突然想到fifo可能是在设置filter的时候启用的，然后测试了下证实了想法 可以看看can的几个例子，filter是必须设置的，不然没法收到数据，而使用哪个fifo就是图里
写自己的双时钟FIFO（DCFIFO）IP核，解决跨时钟域方式之一_通俗易懂篇！
fpga_Spig的博客
06-25 1135
双时钟fifo是遵循先入先出的原则，且读写的数据，在独立的线路上传输，所以连续的bit位传输，可以在不同的时钟下进行，可以有效地解决跨时钟域传输的问题。 双时钟fifo写法简述： 两个时钟，rd_clk,wr_clk. 读命令模块：当有读请求，判断是否读空信号为1，非空则发出读命令。组合逻辑 写命令模块：当有写请求，判断是否写满信号为1，非满则发出写命令。组合逻辑 存储模块：双口ram，当读为1，将读指针，指向的数据发送出去；当写为1，则将数据写入写指针所在的地址位。时序逻辑 q<= mem
FPGA中FIFO的配置
Micheal
12-18 8362
今天我们来讨论一下通过Quartus2中的Mega-plugin来配置一个FIFO，这是偏 软件的，但是今天我把归为硬件来讲，因为其中有许多是硬件相关联的。 首先我们TOOLS进入配置界面，选择"creat a custome megafuction variation",进入第2页然后在左面点开“memory compiler",然后选择FIFO，同时在右边填入自命名的器件名字。点下
单时钟FIFO基础与双时钟结构详解
FIFO的设计原则基于时间顺序，即最先进入的数据也将最先被取出，这对于许多通信协议和流水线设计至关重要。 本文首先强调了FIFO在ASIC（专用集成电路）设计中的常见需求，尤其是在处理跨时钟域的数据交换时，它充当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值