FPGA 30 综合数字ADC /DAC 信号发送采集系统设计(综合项目设计)

╰+攻爆jí腚メ 2022-09-09 14:43 115阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqMTk4NjgxNzkwMg_size_16_color_FFFFFF_t_70_pic_center]

# FPGA 30 综合数字ADC /DAC 信号发送采集系统设计（综合项目设计） #

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vb7w3fZO-1630512386043)(img/blog\_img/fpga/image-20210901224056651.png)\]][img-vb7w3fZO-1630512386043_img_blog_img_fpga_image-20210901224056651.png]

模块名称 ： 综合数字ADC /DAC 信号发送采集系统设计

主要功能 ：本实验设计了一个信号发送和采集系统的设计，在整个系统中，基于原先学习的key\_filter 按键滤波模块，adc\_12s022 模数转换驱动模块，dac\_tlv5618 数模转换驱动模块，DAC\_rom\_siganl 信号rom存储器控制器模块，FIFO模块、FIFO\_send\_ctrl FIFO发送控制模块和uart\_tx 串口发送模块构成了整个综合的实验系统。

输入信号有 ： Key\_in 、 Clk 、 Rst\_n、 ADC\_DOUT

输出信号有 ：Rs232\_Tx 、 ( ADC\_CS\_N 、ADC\_DIN、ADC\_SCLK) ( DAC\_SCLK、DAC\_DIN、DAC\_CS\_N)。

实现功能（设计思想/流程）是： 通过按键Key\_in 按下，按键滤波以后，通过接收按键标志信号（key\_flag） 和 按键状态信号（key\_state） 输出给 按键控制采样模块，该模块通过判断FIFO数据是否已满、AD转换是否已经完成整这个3个信号来输出Ad\_En\_Conv 信号,即判断是否启动ADC 驱动模块开始电压（信号），并且内部该模块实现连续的100次采集，采集100次的数据信号，存储在中间的FIFO中，同时，本次使用的FIFO是一个单时钟，输入输出位宽相同的FIFO，在fifo\_send\_ctrl 模块，通过FIFO模块的FIFO\_almost\_empty 和 empty 信号输入给fifo\_send\_ctrl 模块，并且将器转换为标准的8bit发送的串口格式数据发送给uart\_byte\_tx 模块。此外，我们的信号也是通过fpga的rom资源来存储信号，并设计控制模块，驱动设计的dac\_tlv5618 数模转换模块，并在外部的模拟信号连接到adc\_128s022 的我们设定的采样通道。配合上半部分的电路连接，进而完成整个系统的设计。

1、首先实现整个系统设计图的下半部分

即：DAC信号存储控制模块的设计 DAC\_rom\_signal.v

module DAC_rom_signal
    (
    	Clk,
    	Rst_n,
    	DAC_State,
    	
    	DAC_DATA,
    	Data_Start
    );
    
    	input Clk ;
    	input Rst_n;
    	input DAC_State;
    	
    	output [15:0]DAC_DATA;
    	output reg Data_Start;
    		
    	reg [11:0]address;
    	wire clock ;
    	wire [11:0]q;
    	
    	
    	DAC_rom	DAC_rom0(
    		.address(address),
    		.clock(clock),
    		.q(q)
    		
    		);
    
     
    	reg [31:0]timer_cnt ;
    	reg  timer_full_flag ; 
    	parameter Timer_Cnt_Full = 5_000_000 ;  // 0.01s 循环定时 // 1S 循环计时 50_000_000  3s 150_000_000 clk div parameter
    	 
    	reg  r_Data_Start ; // 信号延时一个时钟
    	
    	// 定时器脉冲信号
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		timer_cnt <= 32'd0;
    	else if(timer_cnt == (Timer_Cnt_Full - 1'b1))
    		timer_cnt <= 32'd0 ; //定时计数器清零
    	else
    		timer_cnt <= timer_cnt + 1'b1 ;
    	
    	// timer_full_flag
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		timer_full_flag <= 1'd0;
    	else if(timer_cnt == (Timer_Cnt_Full - 1'b1))
    		timer_full_flag <= 1'd1;
    	else
    		timer_full_flag <= 1'd0;
    		
    	assign  clock = timer_full_flag ;
    	
    
    	
    	// reg [3:0]address ; 
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		address <= 4'd0 ;
    	else if(timer_full_flag)
    		address <= address +1'b1; // address 到 4095后会自动清零，相当于循环
    	else
    		address <= address ;
    		
    	
    	// Data_Start 	DAC_DATA <= 1'b0;
    	// 启动信号延时一个时钟周期 reg r_Data_Start ;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		r_Data_Start <= 1'b0 ;
    	else if(timer_full_flag && DAC_State)
    		r_Data_Start <= 1'b1 ;
    	else
    		r_Data_Start <= 1'b0 ;		
    		
    	// 延时一个时钟节拍，保证信号可以跟新当前的DA数据
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Data_Start <= 1'b0 ;
    	else
    		Data_Start <= r_Data_Start ;
    	
    		
    	
    	assign DAC_DATA = {4'b0100,q} ;  // 4'b0100 ，给通道1 发送信号
    
    
    
    endmodule

第2步 、dac\_tlv5618.v dac芯片驱动设计

module dac_tlv5618
    (
    	Clk,
    	Rst_n,
    	
    	DAC_DATA,
    	Start,
    	Set_Done,
    	
    	DAC_CS_N,
    	DAC_DIN,
    	DAC_SCLK,
    	DAC_State
    );
    
    	input Clk;
    	input Rst_n;
    	
    	input [15:0]DAC_DATA;
    	input Start;
    	output reg Set_Done;
    	
    	
    	output reg DAC_CS_N;
    	output reg DAC_DIN;
    	output reg DAC_SCLK;
    	output DAC_State;
    	
    	assign DAC_State = DAC_CS_N;
    	
    	reg en;
    	parameter DIV_PARAM = 2 ; //  clk div parameter
    	reg [3:0]DIV_CNT;
    	reg SCLK2X;
    	reg [5:0]SCLK_GEN_CNT ;   // 状态机半周期计数个数
    	
    	wire trans_done ;
    	// clk_div
    	// 
    	reg [15:0]r_DAC_DATA ;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		r_DAC_DATA <= 16'd0;
    	else if(Start)
    		r_DAC_DATA <= DAC_DATA;
    	else
    		r_DAC_DATA <= r_DAC_DATA;
    	
    	
    	// en singal handle
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		en <= 1'b0;
    	else if(Start)
    		en <= 1'b1 ;
    	else if(trans_done)
    		en <= 1'b0;
    	else
    		en <= en ;
    	
    	// div_clk --> 12.5Mhz
    	// reg [3:0]DIV_CNT;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		DIV_CNT <= 4'd0;
    	else if(en)
    		begin
    			if(DIV_CNT == DIV_PARAM -1'b1)
    				DIV_CNT <= 4'd0;
    			else
    				DIV_CNT <= DIV_CNT + 1'd1;
    		end
    	else
    		DIV_CNT <= 4'd0;
    		
    	//生成2倍SCLK使能脉冲，时钟计数器 
    	//reg SCLK2X;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		SCLK2X <= 1'b0 ;
    	else if(en && (DIV_CNT == (DIV_PARAM -1'b1) )) // must add en singal 
    		SCLK2X <= 1'b1;
    	else 
    		SCLK2X <= 1'b0;
    	
    	//  状态机半周期计数
    	//  reg [5:0]SCLK_GEN_CNT ;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		SCLK_GEN_CNT <= 6'd0;
    	else if(SCLK2X && en)
    		begin
    			if(SCLK_GEN_CNT == 6'd33)
    				SCLK_GEN_CNT <= 6'd0;
    			else
    				SCLK_GEN_CNT <= SCLK_GEN_CNT +1'b1 ;
    		end
    	else
    		SCLK_GEN_CNT  <= SCLK_GEN_CNT ;
    		
    	
    	// state machine handle
    	//  	DAC_CS_N;  DAC_DIN;   DAC_SCLK;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		begin
    		DAC_CS_N <= 1'd1;	
    		DAC_DIN  <= 1'd0;
    		DAC_SCLK <= 1'd1;
    		end
    	else if(SCLK2X && (!Set_Done)) 
    		begin
    		case(SCLK_GEN_CNT)
    
    			0  :  begin  DAC_CS_N <= 1'b0 ; DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[15];  end
    			2  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[14];  end
    			4  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[13];  end
    			6  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[12];  end
    			8  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[11];  end
    			10 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[10];  end
    			12 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[9];  end
    			14 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[8];  end
    			16 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[7];  end
    			18 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[6];  end
    			20 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[5];  end
    			22 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[4];  end
    			24 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[3];  end
    			26 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[2];  end
    			28 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[1];  end
    			30 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[0];  end
    			32	:	begin  DAC_SCLK <= 1'b1 ; end
    			33 :  begin  DAC_CS_N <= 1'b1 ; end
    			1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31: begin DAC_SCLK <= 1'b0 ; end
    			default: ;
    		endcase
    		end
    	
    	assign trans_done = (SCLK_GEN_CNT == 33) && SCLK2X ;
    	
    	// Set_Done handle
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Set_Done <= 1'b0;
    	else if(trans_done)
    		Set_Done <= 1'b1;
    	else
    		Set_Done <= 1'b0;
    
    
    endmodule

通过1、2步骤，可以实现连续信号发生器的设计。

第3部分 按键滤波模块 key\_filter.v

//定义按键函数端口
    module key_filter(
    	Clk ,
    	Rst_n ,
    	key_in ,
    	
    	key_flag, //检测按键成功信号
    	key_state //实时的信号
    );
    
    	input Clk ;
    	input Rst_n ;
    	input key_in ;
    	
    	output reg key_flag ;
    	output reg key_state ;
    	
    
    	//定义状态机
    	localparam
    		IDEL   	= 4'b0001 ,
    		FILTER0	= 4'b0010 ,
    		DOWN 	 	= 4'b0100 ,
    		FILTER1	= 4'b1000 ;
    	
    
    	//定义使用到的寄存器
    	reg [3:0]state ;
    	
    	reg key_tmp0 , key_tmp1 ; // key_in 的状态寄存器
    	wire pedge , nedge ;
    	
    		
    	reg en_cnt_20ms ;
    	reg [19:0]cnt_20ms ;
    	reg cnt_20ms_full ;
    	
    	//对外部输入的异步信号key_in进行同步处理
    	reg key_in_sa,key_in_sb;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)begin
    		key_in_sa <= 1'b0;
    		key_in_sb <= 1'b0;
    	end
    	else begin
    		key_in_sa <= key_in;
    		key_in_sb <= key_in_sa;	
    	end
    	
    	//获取上一个周期的 按键电平 和当前 按键电平
    	//目的： 获取 按键状态判断是否是下降沿还是上升沿到来
    	always@(posedge Clk or negedge Rst_n)
    	if(Rst_n == 1'b0) begin
    		key_tmp0 <= 1'b0 ;
    		key_tmp1 <= 1'b0 ;
    	end
    	else begin //每次时钟上升沿到来，两个寄存器读取上一次的数据的值
    		key_tmp0 <= key_in_sb;
    		key_tmp1 <= key_tmp0;	
    	end	
    	
    	// 下降沿和上升沿到来标志位信号
    	assign nedge = ((~key_tmp0 ) & ( key_tmp1)) ; //判断下降沿是否到来？  
    	//分析：:  下降沿到来的清况是高电平-->低电平的变换过程，也就是说：
    	//	key_tmp1 存的前1个时刻的电平，
    	// key_tmp0 存的是当前时刻的电平，
    	// 要满足该条件，也就是说， key_tmp0 <= 0 且 key_tmp1 <= 1; 此时得到 nedge = 1 ;
    	assign pedge = key_tmp0 & (!key_tmp1) ; //判断上升沿是否到来？	
    	
    	//状态机判断
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n) //复位状态下，状态机处于空闲状态 
    		begin	
    			state <= IDEL ;		    //复位状态下，状态机处于空闲模式下
    			en_cnt_20ms <= 1'b0 ; //消抖计数器关闭
    			key_flag  <= 1'b0 ;	 //按键成功标志位清零
    			key_state <= 1'b1 ;	 //默认输入按键状态高电平
    		end
    	else 
    	   begin
    	 	case(state)
    			IDEL :
    				begin
    					key_flag <= 1'b0 ;	//空闲状态下，按键成功标志位永远为0
    					if(nedge == 1'b1) begin		//按键检测到下降沿到来
    						state <= FILTER0 ;//进入下一个案件滤波状态
    						en_cnt_20ms <= 1 ;//开启使能计数20ms
    						end
    					else
    					   state <= IDEL ;	//未检测到下降沿到来，信号状态保持不变
    				end
    			FILTER0:
    			if(cnt_20ms_full == 1'b1) begin //看消除抖动20ms后，且20ms内没有检测到上升沿到来  = 20ms
    					key_flag <= 1'b1;		//表示按键	已经成功按下
    					key_state<= 1'b0;		//此时输入按键按下输出状态为低电平
    					state <= DOWN ;		//进入下一状态
    					en_cnt_20ms <= 0 ;	//20ms计数器关闭				
    				end
    			else if(pedge == 1'b1) begin	//没有满20ms 以内，有上升沿的到来,表明此时是抖动信号，非按键按下信号
    					state <= IDEL ;
    					en_cnt_20ms <= 0 ;//计数器关闭
    				end
    				else	//上述两者情况均为出现，则状态机保持不变
    					state <= FILTER0 ;
    			DOWN:
    				begin 
    				key_flag <= 1'b0; //检测到有按键按下，发送一个脉冲信号，由上一个状态的高电平变为低电平
    					if(pedge == 1'b1) begin //上一个状态时间超过20ms，此时需要一直等待上升沿的到来（做为按键松开的标志）
    						state <= FILTER1 ;	//进入到下一状态
    						en_cnt_20ms <= 1'b1 ;//开启下一次20ms 延时计数
    					end
    					else  //没有，则保持该状态
    						state <= DOWN ;	
    				end		
    			FILTER1:
    				if(cnt_20ms_full == 1'b1) begin//表示 20ms计数又一次到来,此时按键稳定
    				   key_flag <= 1'b1;		//表示上升沿的信号稳定的信号，随后到 IDEL又会设置为低电平，产生一个脉冲信号
    					key_state<= 1'b1;		 //此时输入按键按下状态为低电平
    					en_cnt_20ms <= 1'b0 ; //关闭20ms定时器
    					state <=IDEL ;
    				end
    				else if(nedge)begin	// 20ms内又出现了下降沿，表示这是一次抖动
    					en_cnt_20ms <= 1'b0 ;
    					state <= DOWN ;
    				end
    				else	//20ms内状态保持不变
    					state <=FILTER1 ;
    			default:
    				begin
    					state <= IDEL ; 
    					key_flag <= 1'b0;
    					key_state<= 1'b1;     //默认状态时 1 高电平
    					en_cnt_20ms <= 1'b0 ; //默认状态时 0 低电平
    				end
    		endcase
    	  end
    
    //	定时器启动 always块
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		cnt_20ms <= 20'd0;
    	else if(en_cnt_20ms)
    		cnt_20ms <= cnt_20ms + 1'b1;
    	else // 关闭时，计时器清零
    		cnt_20ms <= 20'd0;
    	
    	
    	//定时器20ms always块 50Mhz 20ms = cnt_20ms : 1_000_000
    	always@(posedge Clk or negedge Rst_n)
    	if(Rst_n == 1'b0)
    		cnt_20ms_full <= 0 ;
    	else if(cnt_20ms == 20'd999_999)
    		cnt_20ms_full <= 1'b1 ;  //计数值计满标志位
    	else
    		cnt_20ms_full <= 1'b0 ;	// 未挤满，输出0
    		
    
    endmodule

第4部分: ctrl\_sample 通过按键按下滤波后的信号，控制ADC 驱动，完成连续的100次信号采集

// 模块功能，每次按键按下，使用控制AD 100次信号采样
    // 采样的信号 存放到fifo中。
    
    module  ctrl_sample
    (
    	Clk,
    	Rst_n,
    	key_flag ,
    	key_state ,
    	Ad_Conv_Done,
    	Fifo_almost_full,
    	
    	Ad_En_Conv
    
    );
    	input Clk;
    	input Rst_n;
    	input key_flag ;
    	input key_state ;
    	input Ad_Conv_Done;
    	input Fifo_almost_full;
    
    	output reg Ad_En_Conv;
    	
    	parameter SAMPLE_TIMES =  100 ; //每次采样次数
    
    	reg [6:0]sample_cnt ;
    	
    	// key_state key_flag
    	// Ad_En_Conv ;
    	reg en_flag ;
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		en_flag <= 1'b0 ;
    	else if(key_flag && (!key_state))
    		begin
    			if(Fifo_almost_full)
    				en_flag <= 1'b0;
    			else
    				en_flag <= 1'b1;
    		end
    	else if(Fifo_almost_full || (sample_cnt== (SAMPLE_TIMES-1)) )
    		en_flag <= 1'b0;
    	else
    		en_flag <= en_flag ;
    	
    	// Ad_En_Conv handle
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Ad_En_Conv <= 1'b0 ;
    	else if(key_flag && (!key_state))
    		begin
    			if(Fifo_almost_full)
    				Ad_En_Conv <= 1'b0;
    			else
    				Ad_En_Conv <= 1'b1;
    		end
    	else if(en_flag && Ad_Conv_Done)
    		Ad_En_Conv <= 1'b1;
    	else	
    		Ad_En_Conv <= 1'b0;
    			
    	
    	// Ad_Conv_Done
    	// Ad_En_Conv
    	// sample_cnt
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		sample_cnt <= 7'b0 ;
    	else if(Ad_Conv_Done)
    		begin
    			if(sample_cnt == (SAMPLE_TIMES-1) )
    				sample_cnt <=7'd0;
    			else
    				sample_cnt <= sample_cnt +1'b1;
    		end
    	else
    		sample_cnt <= sample_cnt ;
    	
    
    endmodule

第5部分: ad128s022.v 芯片驱动模块，可以设置采样通道、采样频率等基本输入参数，即可驱动信号。

module ad128s022
    (
    			Clk,
    			Rst_n,
    			
    			Channel,
    			Data,
    			
    			En_Conv,
    			Conv_Done,
    			ADC_State,
    			DIV_PARAM,
    			
    			ADC_SCLK,
    			ADC_DOUT,
    			ADC_DIN,
    			ADC_CS_N	
    );
    
    			input Clk;
    			input Rst_n;
    			
    			input  [2:0]Channel;
    			output reg [11:0]Data;
    			
    			input En_Conv;
    			output reg Conv_Done;
    			output ADC_State;
    			input [7:0]DIV_PARAM;
    			
    			output reg ADC_SCLK;
    			input  ADC_DOUT;
    			output reg ADC_DIN;
    			output reg ADC_CS_N;	
    
    			
    			reg en ;
    			reg [2:0]r_Channel;
    			reg [7:0]DIV_CNT ;
    			reg  SCLK2X ;
    			reg [5:0]SCLK_GEN_CNT;
    			reg [11:0]r_Data;
    			
    
    			
    			
    			//  en handle 
    			always@(posedge Clk or negedge Rst_n)
    			if(!Rst_n)
    				en <= 1'b0;
    			else if(En_Conv)
    				en <= 1'b1;
    			else if(Conv_Done)
    				en <= 1'b0 ;
    			else
    				en <= en ;
    			
    			
    
    			// r_Channel  we set En_Conv is a plus signal 
    			always@(posedge Clk or negedge Rst_n)
    			if(!Rst_n)
    				r_Channel <= 3'd0;
    			else if(En_Conv)
    				r_Channel <= Channel;
    			else
    				r_Channel <= r_Channel;
    			
    			// 时钟分频脉冲计数
    			// reg [7:0]DIV_CNT ;
    			always@(posedge Clk or negedge Rst_n)
    			if(!Rst_n)
    				DIV_CNT <= 8'd0 ;
    			else if(en)
    				begin
    				if(DIV_CNT == (DIV_PARAM -1) )
    					DIV_CNT <= 8'd0 ;
    				else	
    					DIV_CNT <= DIV_CNT + 1'd1 ;
    				end
    			else	
    				DIV_CNT <= 8'd0 ;
    			
    			// SCLK2X plus
    			// reg  SCLK2X
    			always@(posedge Clk or negedge Rst_n)
    			if(!Rst_n)
    				SCLK2X <= 1'b0;
    			else if(DIV_CNT == (DIV_PARAM -1) )
    				SCLK2X <= 1'b1 ;
    			else
    				SCLK2X <= 1'b0;
    				
    			// reg [5:0]SCLK_GEN_CNT 
    			always@(posedge Clk or negedge Rst_n)
    			if(!Rst_n)
    				SCLK_GEN_CNT  <= 6'd0 ;
    			else if(en && SCLK2X)
    				begin
    				if(SCLK_GEN_CNT == 6'd33)
    					SCLK_GEN_CNT <=6'd0;
    				else
    					SCLK_GEN_CNT <= SCLK_GEN_CNT + 1'b1 ;
    				end
    			else
    				SCLK_GEN_CNT <= SCLK_GEN_CNT ;
    			//
    			
    			/*
    			output ADC_SCLK
    			input  ADC_DOUT;
    			output ADC_DIN;
    			output reg ADC_CS_N;	
    			reg [11:0]r_Data;
    			*/
    			
    			always@(posedge Clk or negedge Rst_n)
    			if(!Rst_n)
    				begin
    				ADC_SCLK <= 1'b1;
    				ADC_DIN  <= 1'b0;
    				ADC_CS_N  <= 1'b1;
    				end
    			else if(en && SCLK2X)
    				begin
    				case(SCLK_GEN_CNT)
    				0: begin ADC_CS_N <= 1'b0; ADC_SCLK <= 1'b1; ADC_DIN <= 1'b0; end
    				1,3: begin ADC_SCLK <= 1'b0; end
    				2,4,6,8:  begin ADC_SCLK <= 1'b1 ; end
    				5:  begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[2]; end
    				7:  begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[1]; end
    				9:  begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[0]; end
    				10: begin ADC_SCLK <= 1'b1; r_Data[11] <= ADC_DOUT ; end
    				12: begin ADC_SCLK <= 1'b1; r_Data[10] <= ADC_DOUT ; end
    				14: begin ADC_SCLK <= 1'b1; r_Data[9] <= ADC_DOUT ; end
    				16: begin ADC_SCLK <= 1'b1; r_Data[8] <= ADC_DOUT ; end
    				18: begin ADC_SCLK <= 1'b1; r_Data[7] <= ADC_DOUT ; end
    				20: begin ADC_SCLK <= 1'b1; r_Data[6] <= ADC_DOUT ; end
    				22: begin ADC_SCLK <= 1'b1; r_Data[5] <= ADC_DOUT ; end
    				24: begin ADC_SCLK <= 1'b1; r_Data[4] <= ADC_DOUT ; end
    				26: begin ADC_SCLK <= 1'b1; r_Data[3] <= ADC_DOUT ; end
    				28: begin ADC_SCLK <= 1'b1; r_Data[2] <= ADC_DOUT ; end
    				30: begin ADC_SCLK <= 1'b1; r_Data[1] <= ADC_DOUT ; end
    				32: begin ADC_SCLK <= 1'b1; r_Data[0] <= ADC_DOUT ; end
    				11,13,15,17,19,21,23,25,27,29,31: begin ADC_SCLK <= 1'b0;  end
    				33: begin ADC_CS_N <= 1'b1; end
    				default: ;
    				endcase
    				end	
    			
    		// output [11:0]Data 
    		always@(posedge Clk or negedge Rst_n)
    		if(!Rst_n)
    			Data  <= 12'd0 ;
    		else if(en && SCLK2X && (SCLK_GEN_CNT == 6'd33))
    			Data <= r_Data ;
    		else
    			Data <= Data ;
    	
    		// conv_Done signal
    		always@(posedge Clk or negedge Rst_n)
    		if(!Rst_n)
    			Conv_Done  <= 1'd0 ;
    		else if(en && SCLK2X && (SCLK_GEN_CNT == 6'd33))
    			Conv_Done <= 1'd1 ;
    		else
    			Conv_Done <= 1'd0 ;	
    		
    		//产生ADC工作状态指示信号,保持和CS片选信号同步即可
    		assign ADC_State = ADC_CS_N ; 
    			
    endmodule

第6部分、FIFO模块，注：这个一般来说，是调用内部IP 核来实现的，主要是看FIFO的配置，可以看一下 FPGA22 FIFO 的实现

// megafunction wizard: %FIFO%
    // GENERATION: STANDARD
    // VERSION: WM1.0
    // MODULE: scfifo 
    
    // ============================================================
    // File Name: AD_fifo.v
    // Megafunction Name(s):
    // 			scfifo
    //
    // Simulation Library Files(s):
    // 			
    // ============================================================
    // ************************************************************
    // THIS IS A WIZARD-GENERATED FILE. DO NOT EDIT THIS FILE!
    //
    // 13.0.0 Build 156 04/24/2013 SJ Full Version
    // ************************************************************
    
    
    //Copyright (C) 1991-2013 Altera Corporation
    //Your use of Altera Corporation's design tools, logic functions 
    //and other software and tools, and its AMPP partner logic 
    //functions, and any output files from any of the foregoing 
    //(including device programming or simulation files), and any 
    //associated documentation or information are expressly subject 
    //to the terms and conditions of the Altera Program License 
    //Subscription Agreement, Altera MegaCore Function License 
    //Agreement, or other applicable license agreement, including, 
    //without limitation, that your use is for the sole purpose of 
    //programming logic devices manufactured by Altera and sold by 
    //Altera or its authorized distributors.  Please refer to the 
    //applicable agreement for further details.
    
    
    // synopsys translate_off
    `timescale 1 ps / 1 ps
    // synopsys translate_on
    module AD_fifo (
    	clock,
    	data,
    	rdreq,
    	sclr,
    	wrreq,
    	almost_empty,
    	almost_full,
    	empty,
    	full,
    	q,
    	usedw);
    
    	input	  clock;
    	input	[11:0]  data;
    	input	  rdreq;
    	input	  sclr;
    	input	  wrreq;
    	output	  almost_empty;
    	output	  almost_full;
    	output	  empty;
    	output	  full;
    	output	[11:0]  q;
    	output	[9:0]  usedw;
    
    	wire [9:0] sub_wire0;
    	wire  sub_wire1;
    	wire  sub_wire2;
    	wire [11:0] sub_wire3;
    	wire  sub_wire4;
    	wire  sub_wire5;
    	wire [9:0] usedw = sub_wire0[9:0];
    	wire  empty = sub_wire1;
    	wire  full = sub_wire2;
    	wire [11:0] q = sub_wire3[11:0];
    	wire  almost_empty = sub_wire4;
    	wire  almost_full = sub_wire5;
    
    	scfifo	scfifo_component (
    				.clock (clock),
    				.sclr (sclr),
    				.wrreq (wrreq),
    				.data (data),
    				.rdreq (rdreq),
    				.usedw (sub_wire0),
    				.empty (sub_wire1),
    				.full (sub_wire2),
    				.q (sub_wire3),
    				.almost_empty (sub_wire4),
    				.almost_full (sub_wire5),
    				.aclr ());
    	defparam
    		scfifo_component.add_ram_output_register = "OFF",
    		scfifo_component.almost_empty_value = 1,
    		scfifo_component.almost_full_value = 1023,
    		scfifo_component.intended_device_family = "Cyclone IV E",
    		scfifo_component.lpm_numwords = 1024,
    		scfifo_component.lpm_showahead = "OFF",
    		scfifo_component.lpm_type = "scfifo",
    		scfifo_component.lpm_width = 12,
    		scfifo_component.lpm_widthu = 10,
    		scfifo_component.overflow_checking = "ON",
    		scfifo_component.underflow_checking = "ON",
    		scfifo_component.use_eab = "ON";
    
    
    endmodule

第7 部分 fifo\_send\_ctrl.v文件，主要实现的是将fifo 的存放数据【12位】设置一个转换【8位】输出，输出串口标准的发送信号.

module  fifo_send_ctrl
    (	
    	Clk,
    	Rst_n,
    	Tx_done ,
    	Fifo_empty ,
    	Fifo_q,
    	
    	Tx_Send_en,
    	Tx_Data,
    	Fifo_rdreq
    );
    
    	input Clk ;
    	input Rst_n ;
    	input Tx_done ;
    	input Fifo_empty ;
    	input [11:0]Fifo_q ;
    	
    	output reg Tx_Send_en ;
    	output reg [7:0]Tx_Data ;
    	output reg Fifo_rdreq ;
    		
    	//
    localparam
    		STATE_S0	= 5'b0_0001,
    		STATE_S1 = 5'b0_0010,
    		STATE_S2	= 5'b0_0100,
    		STATE_S3	= 5'b0_1000,
    		STATE_S4	= 5'b1_0000;
    
    	reg[4:0]state;
    	
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)begin
    		state <= STATE_S0;
    	end
    	else begin
    		case(state)
    			STATE_S0:
    				if(Fifo_empty == 1'b0) 
    					begin 					// fifo 有data
    					Fifo_rdreq <= 1'b1 ; //发送读信号
    					state <= STATE_S1;
    					end
    				else
    					state <= STATE_S0;	
    			STATE_S1:
    					begin
    					Fifo_rdreq <= 1'b0 ;
    					state <= STATE_S2;
    					end
    			STATE_S2:
    					begin
    					Tx_Send_en <= 1'b1;
    					Tx_Data <= {4'b0000,Fifo_q[11:8]} ; // 先发送高8位
    					state <= STATE_S3;
    					end			
    			STATE_S3:
    				if(Tx_done == 1'b1)
    					begin
    					Tx_Send_en <= 1'b1;
    					Tx_Data <= Fifo_q[7:0] ; //再发送低8位
    					state <= STATE_S4;
    					end	
    				else
    					begin
    					Tx_Send_en <= 1'b0;
    					state <= STATE_S3;
    					end					
    			STATE_S4:
    				if(Tx_done == 1'b1)
    					state <= STATE_S0;
    				else if(Tx_done == 1'b0)
    					begin
    					Tx_Send_en <= 1'b0;
    					state <= STATE_S4;
    					end			
    			default:state <= STATE_S1;
    		endcase		
    	end
    	
    
    endmodule

第8部分： uart\_byte\_tx .v 串口发送模块

module uart_byte_tx(
    	Clk,
    	Rst_n,
    	data_byte,
    	send_en,
    	baud_set,
    	
    	Rs232_Tx,
    	Tx_Done,
    	uart_state
    );
    
    	input Clk;
    	input Rst_n;
    	input [7:0]data_byte;
    	input send_en;
    	input [2:0]baud_set;
    	
    	output reg Rs232_Tx;
    	output reg Tx_Done;
    	output reg uart_state;
    	
    	reg bps_clk;	//波特率时钟
    	
    	reg [15:0]div_cnt;//分频计数器
    	
    	reg [15:0]bps_DR;//分频计数最大值
    	
    	reg [3:0]bps_cnt;//波特率时钟计数器
    	
    	reg [7:0]r_data_byte;
    	
    	localparam START_BIT = 1'b0;
    	localparam STOP_BIT = 1'b1;
    	
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		uart_state <= 1'b0;
    	else if(send_en)
    		uart_state <= 1'b1;
    	else if(bps_cnt == 4'd11)
    		uart_state <= 1'b0;
    	else
    		uart_state <= uart_state;
    	
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		r_data_byte <= 8'd0;
    	else if(send_en)
    		r_data_byte <= data_byte;
    	else
    		r_data_byte <= r_data_byte;
    	
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		bps_DR <= 16'd5207;
    	else begin
    		case(baud_set)
    			0:bps_DR <= 16'd5207;
    			1:bps_DR <= 16'd2603;
    			2:bps_DR <= 16'd1301;
    			3:bps_DR <= 16'd867;
    			4:bps_DR <= 16'd433;
    			default:bps_DR <= 16'd5207;			
    		endcase
    	end	
    	
    	//counter
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		div_cnt <= 16'd0;
    	else if(uart_state)begin
    		if(div_cnt == bps_DR)
    			div_cnt <= 16'd0;
    		else
    			div_cnt <= div_cnt + 1'b1;
    	end
    	else
    		div_cnt <= 16'd0;
    	
    	// bps_clk gen
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		bps_clk <= 1'b0;
    	else if(div_cnt == 16'd1)
    		bps_clk <= 1'b1;
    	else
    		bps_clk <= 1'b0;
    	
    	//bps counter
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)	
    		bps_cnt <= 4'd0;
    	else if(bps_cnt == 4'd11)
    		bps_cnt <= 4'd0;
    	else if(bps_clk)
    		bps_cnt <= bps_cnt + 1'b1;
    	else
    		bps_cnt <= bps_cnt;
    		
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Tx_Done <= 1'b0;
    	else if(bps_cnt == 4'd11)
    		Tx_Done <= 1'b1;
    	else
    		Tx_Done <= 1'b0;
    		
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Rs232_Tx <= 1'b1;
    	else begin
    		case(bps_cnt)
    			0:Rs232_Tx <= 1'b1;
    			1:Rs232_Tx <= START_BIT;
    			2:Rs232_Tx <= r_data_byte[0];
    			3:Rs232_Tx <= r_data_byte[1];
    			4:Rs232_Tx <= r_data_byte[2];
    			5:Rs232_Tx <= r_data_byte[3];
    			6:Rs232_Tx <= r_data_byte[4];
    			7:Rs232_Tx <= r_data_byte[5];
    			8:Rs232_Tx <= r_data_byte[6];
    			9:Rs232_Tx <= r_data_byte[7];
    			10:Rs232_Tx <= STOP_BIT;
    			default:Rs232_Tx <= 1'b1;
    		endcase
    	end	
    
    endmodule

第九部分： 顶层设计文件,就是模块核模块之间的连接

// 实验内容：
    // ① 通过按键控制AD采集模块
    // ② 按键按下，ad 进行采样100 次，操作
    // ③ ad 采样的数据存取到fifo 中
    // ④ 读取fifo中的数据，将数据通过串口模块发送，直到fifo 的数据全部读取完毕为止
    // ⑤ 读取的数据是12位，串口模块发送需要先变成标准的2个8位数据发送，通过电脑上的串口调试助手显示发送的数据
    // 信号发生器模块： 【内部有一个 DA_rom 数据模块】 ，每次间隔0.01S,发送一次模拟数据到，模拟信号发送通道1，发送出去
    // 信号采样时间现在本工程暂时无法控制，下一个工程【27_ADC_DAC_system】将会完善改功能
    module  AD_DA_Top
    (
    	 Clk ,
    	 Rst_n ,
    	 key_in ,
    
    	 ADC_DOUT ,
    	 ADC_SCLK ,
    	 ADC_DIN  ,
    	 ADC_CS_N ,
    	
    	 Rs232_Tx ,
    	
    	 DAC_CS_N ,
    	 DAC_DIN  ,
    	 DAC_SCLK
    	
    );
    
    
    	input Clk ;
    	input Rst_n ;
    	input key_in ;
    
    	input ADC_DOUT ;
    	output ADC_SCLK;
    	output ADC_DIN;
    	output ADC_CS_N;
    	
    	output Rs232_Tx;
    
    	// 信号源
    	output  DAC_CS_N;
    	output  DAC_DIN;
    	output  DAC_SCLK;
    	
    	
    	wire key_flag ;
    	wire key_state ;
    	wire Ad_En_Conv;
    	wire Conv_Done;
    	wire Fifo_empty;
    	wire Fifo_almost_full;
    	
    	wire Tx_Done;
    	wire Tx_Send_en;
    	wire [7:0]Tx_Data;
    	wire [11:0]fifo_dtae;
    	wire [11:0]Fifo_q;
    	wire Fifo_rdreq;
    	
    	wire [15:0]DAC_DATA ;
    	wire Start ;
    	wire DAC_State;
    
    key_filter	key_filter_0(
    		.Clk(Clk) ,
    		.Rst_n(Rst_n) ,
    		.key_in(key_in) ,
    		
    		.key_flag(key_flag), //检测按键成功信号
    		.key_state(key_state) //实时的信号
    	);
    	
    
    ctrl_sample ctrl_sample0
    	( 
    		.Clk(Clk),
    		.Rst_n(Rst_n),
    		.key_flag(key_flag) ,
    		.key_state(key_state) ,
    		.Ad_Conv_Done(Conv_Done),
    		.Fifo_almost_full(Fifo_almost_full),
    		
    		.Ad_En_Conv(Ad_En_Conv)
    
    	);
    	
    
    ad128s022 ad128s022_0
    (
    			.Clk(Clk),
    			.Rst_n(Rst_n),
    			
    			.Channel(3'd5),
    			.Data(fifo_dtae),
    			
    			.En_Conv(Ad_En_Conv),
    			.Conv_Done(Conv_Done),
    			.ADC_State(), // 和 ADC_CS_N  状态保持一致
    			.DIV_PARAM(8'd13),
    			
    			.ADC_SCLK(ADC_SCLK),
    			.ADC_DOUT(ADC_DOUT),
    			.ADC_DIN(ADC_DIN),
    			.ADC_CS_N(ADC_CS_N)	
    );	
    
    	AD_fifo	AD_fifo_0 (
    		.clock(Clk),
    		.data(fifo_dtae),
    		.rdreq(Fifo_rdreq),
    		.sclr(!Rst_n), 
    		.wrreq(Conv_Done),
    		.almost_empty(),
    		.almost_full(Fifo_almost_full),
    		.empty(Fifo_empty),
    		.full(),
    		.q(Fifo_q),
    		.usedw()
    		);
    	
    	
    	
    fifo_send_ctrl	fifo_send_ctrl_0
    	(	
    		.Clk(Clk),
    		.Rst_n(Rst_n),
    		.Tx_done(Tx_Done) ,
    		.Fifo_empty(Fifo_empty) ,
    		.Fifo_q(Fifo_q),
    		
    		.Tx_Send_en(Tx_Send_en),
    		.Tx_Data(Tx_Data),
    		.Fifo_rdreq(Fifo_rdreq)
    	);
    
    	
    uart_byte_tx	uart_byte_tx_0(
    		.Clk(Clk),
    		.Rst_n(Rst_n),
    		.data_byte(Tx_Data),
    		.send_en(Tx_Send_en),
    		.baud_set(3'd4),	 // 115200bps
    		
    		.Rs232_Tx(Rs232_Tx),
    		.Tx_Done(Tx_Done),
    		.uart_state()
    	);
    
    		
    		DAC_rom_signal DAC_rom_signal_0
    		(
    			.Clk(Clk),
    			.Rst_n(Rst_n),
    			.DAC_State(DAC_State),
    			.DAC_DATA(DAC_DATA),
    			.Data_Start(Start)
    		);
    		
    		dac_tlv5618 dac_tlv5618_0
    		(
    			.Clk(Clk),
    			.Rst_n(Rst_n),
    			
    			.DAC_DATA(DAC_DATA),
    			.Start(Start),
    			.Set_Done(),
    			
    			.DAC_CS_N(DAC_CS_N),
    			.DAC_DIN(DAC_DIN),
    			.DAC_SCLK(DAC_SCLK),
    			.DAC_State(DAC_State)
    		);
    
    endmodule

注： 本次作为一个综合实验，主要是对原先学习的知识做一个系统的设计，将现阶段所学的内容整合在一块，同时也需要知道真正在做fpga项目的时候，基本上都是先做系统模块化数字电路设计，后面模块再去写模块代码，做模块验证，最后根据顶层文件直接连接，最后综合和测试即可。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqMTk4NjgxNzkwMg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/cd033079a9ff4519840bd770d8ceaa90.png
[img-vb7w3fZO-1630512386043_img_blog_img_fpga_image-20210901224056651.png]: /images/20220829/6c3709b313e947ccba330f0b4efeeac0.png