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

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

在这里插入图片描述

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

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(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

  1. module DAC_rom_signal
  2. (
  3.     Clk,
  4.     Rst_n,
  5.     DAC_State,
  7.     DAC_DATA,
  8.     Data_Start
  9. );
  11.     input Clk ;
  12.     input Rst_n;
  13.     input DAC_State;
  15.     output [15:0]DAC_DATA;
  16.     output reg Data_Start;
  18.     reg [11:0]address;
  19.     wire clock ;
  20.     wire [11:0]q;
  23.     DAC_rom    DAC_rom0(
  24.         .address(address),
  25.         .clock(clock),
  26.         .q(q)
  28.         );
  31.     reg [31:0]timer_cnt ;
  32.     reg  timer_full_flag ; 
  33.     parameter Timer_Cnt_Full = 5_000_000 ;  // 0.01s 循环定时 // 1S 循环计时 50_000_000  3s 150_000_000 clk div parameter
  35.     reg  r_Data_Start ; // 信号延时一个时钟
  37.     // 定时器脉冲信号
  38.     always@(posedge Clk or negedge Rst_n)
  39.     if(!Rst_n)
  40.         timer_cnt <= 32'd0;
  41.     else if(timer_cnt == (Timer_Cnt_Full - 1'b1))
  42.         timer_cnt <= 32'd0 ; //定时计数器清零
  43.     else
  44.         timer_cnt <= timer_cnt + 1'b1 ;
  46.     // timer_full_flag
  47.     always@(posedge Clk or negedge Rst_n)
  48.     if(!Rst_n)
  49.         timer_full_flag <= 1'd0;
  50.     else if(timer_cnt == (Timer_Cnt_Full - 1'b1))
  51.         timer_full_flag <= 1'd1;
  52.     else
  53.         timer_full_flag <= 1'd0;
  55.     assign  clock = timer_full_flag ;
  59.     // reg [3:0]address ; 
  60.     always@(posedge Clk or negedge Rst_n)
  61.     if(!Rst_n)
  62.         address <= 4'd0 ;
  63.     else if(timer_full_flag)
  64.         address <= address +1'b1; // address 到 4095后会自动清零，相当于循环
  65.     else
  66.         address <= address ;
  69.     // Data_Start     DAC_DATA <= 1'b0;
  70.     // 启动信号延时一个时钟周期 reg r_Data_Start ;
  71.     always@(posedge Clk or negedge Rst_n)
  72.     if(!Rst_n)
  73.         r_Data_Start <= 1'b0 ;
  74.     else if(timer_full_flag && DAC_State)
  75.         r_Data_Start <= 1'b1 ;
  76.     else
  77.         r_Data_Start <= 1'b0 ;        
  79.     // 延时一个时钟节拍，保证信号可以跟新当前的DA数据
  80.     always@(posedge Clk or negedge Rst_n)
  81.     if(!Rst_n)
  82.         Data_Start <= 1'b0 ;
  83.     else
  84.         Data_Start <= r_Data_Start ;
  88.     assign DAC_DATA = {4'b0100,q} ;  // 4'b0100 ，给通道1 发送信号
  92. endmodule

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

  1. module dac_tlv5618
  2. (
  3.     Clk,
  4.     Rst_n,
  6.     DAC_DATA,
  7.     Start,
  8.     Set_Done,
  10.     DAC_CS_N,
  11.     DAC_DIN,
  12.     DAC_SCLK,
  13.     DAC_State
  14. );
  16.     input Clk;
  17.     input Rst_n;
  19.     input [15:0]DAC_DATA;
  20.     input Start;
  21.     output reg Set_Done;
  24.     output reg DAC_CS_N;
  25.     output reg DAC_DIN;
  26.     output reg DAC_SCLK;
  27.     output DAC_State;
  29.     assign DAC_State = DAC_CS_N;
  31.     reg en;
  32.     parameter DIV_PARAM = 2 ; //  clk div parameter
  33.     reg [3:0]DIV_CNT;
  34.     reg SCLK2X;
  35.     reg [5:0]SCLK_GEN_CNT ;   // 状态机半周期计数个数
  37.     wire trans_done ;
  38.     // clk_div
  39.     // 
  40.     reg [15:0]r_DAC_DATA ;
  41.     always@(posedge Clk or negedge Rst_n)
  42.     if(!Rst_n)
  43.         r_DAC_DATA <= 16'd0;
  44.     else if(Start)
  45.         r_DAC_DATA <= DAC_DATA;
  46.     else
  47.         r_DAC_DATA <= r_DAC_DATA;
  50.     // en singal handle
  51.     always@(posedge Clk or negedge Rst_n)
  52.     if(!Rst_n)
  53.         en <= 1'b0;
  54.     else if(Start)
  55.         en <= 1'b1 ;
  56.     else if(trans_done)
  57.         en <= 1'b0;
  58.     else
  59.         en <= en ;
  61.     // div_clk --> 12.5Mhz
  62.     // reg [3:0]DIV_CNT;
  63.     always@(posedge Clk or negedge Rst_n)
  64.     if(!Rst_n)
  65.         DIV_CNT <= 4'd0;
  66.     else if(en)
  67.         begin
  68.             if(DIV_CNT == DIV_PARAM -1'b1)
  69.                 DIV_CNT <= 4'd0;
  70.             else
  71.                 DIV_CNT <= DIV_CNT + 1'd1;
  72.         end
  73.     else
  74.         DIV_CNT <= 4'd0;
  76.     //生成2倍SCLK使能脉冲，时钟计数器 
  77.     //reg SCLK2X;
  78.     always@(posedge Clk or negedge Rst_n)
  79.     if(!Rst_n)
  80.         SCLK2X <= 1'b0 ;
  81.     else if(en && (DIV_CNT == (DIV_PARAM -1'b1) )) // must add en singal 
  82.         SCLK2X <= 1'b1;
  83.     else 
  84.         SCLK2X <= 1'b0;
  86.     //  状态机半周期计数
  87.     //  reg [5:0]SCLK_GEN_CNT ;
  88.     always@(posedge Clk or negedge Rst_n)
  89.     if(!Rst_n)
  90.         SCLK_GEN_CNT <= 6'd0;
  91.     else if(SCLK2X && en)
  92.         begin
  93.             if(SCLK_GEN_CNT == 6'd33)
  94.                 SCLK_GEN_CNT <= 6'd0;
  95.             else
  96.                 SCLK_GEN_CNT <= SCLK_GEN_CNT +1'b1 ;
  97.         end
  98.     else
  99.         SCLK_GEN_CNT  <= SCLK_GEN_CNT ;
  102.     // state machine handle
  103.     //      DAC_CS_N;  DAC_DIN;   DAC_SCLK;
  104.     always@(posedge Clk or negedge Rst_n)
  105.     if(!Rst_n)
  106.         begin
  107.         DAC_CS_N <= 1'd1;    
  108.         DAC_DIN  <= 1'd0;
  109.         DAC_SCLK <= 1'd1;
  110.         end
  111.     else if(SCLK2X && (!Set_Done)) 
  112.         begin
  113.         case(SCLK_GEN_CNT)
  115.             0  :  begin  DAC_CS_N <= 1'b0 ; DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[15];  end
  116.             2  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[14];  end
  117.             4  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[13];  end
  118.             6  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[12];  end
  119.             8  :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[11];  end
  120.             10 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[10];  end
  121.             12 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[9];  end
  122.             14 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[8];  end
  123.             16 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[7];  end
  124.             18 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[6];  end
  125.             20 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[5];  end
  126.             22 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[4];  end
  127.             24 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[3];  end
  128.             26 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[2];  end
  129.             28 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[1];  end
  130.             30 :  begin  DAC_SCLK <= 1'b1 ; DAC_DIN <= r_DAC_DATA[0];  end
  131.             32    :    begin  DAC_SCLK <= 1'b1 ; end
  132.             33 :  begin  DAC_CS_N <= 1'b1 ; end
  133.             1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31: begin DAC_SCLK <= 1'b0 ; end
  134.             default: ;
  135.         endcase
  136.         end
  138.     assign trans_done = (SCLK_GEN_CNT == 33) && SCLK2X ;
  140.     // Set_Done handle
  141.     always@(posedge Clk or negedge Rst_n)
  142.     if(!Rst_n)
  143.         Set_Done <= 1'b0;
  144.     else if(trans_done)
  145.         Set_Done <= 1'b1;
  146.     else
  147.         Set_Done <= 1'b0;
  150. endmodule

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

第3部分 按键滤波模块 key_filter.v

  1. //定义按键函数端口
  2. module key_filter(
  3.     Clk ,
  4.     Rst_n ,
  5.     key_in ,
  7.     key_flag, //检测按键成功信号
  8.     key_state //实时的信号
  9. );
  11.     input Clk ;
  12.     input Rst_n ;
  13.     input key_in ;
  15.     output reg key_flag ;
  16.     output reg key_state ;
  19.     //定义状态机
  20.     localparam
  21.         IDEL       = 4'b0001 ,
  22.         FILTER0    = 4'b0010 ,
  23.         DOWN          = 4'b0100 ,
  24.         FILTER1    = 4'b1000 ;
  27.     //定义使用到的寄存器
  28.     reg [3:0]state ;
  30.     reg key_tmp0 , key_tmp1 ; // key_in 的状态寄存器
  31.     wire pedge , nedge ;
  34.     reg en_cnt_20ms ;
  35.     reg [19:0]cnt_20ms ;
  36.     reg cnt_20ms_full ;
  38.     //对外部输入的异步信号key_in进行同步处理
  39.     reg key_in_sa,key_in_sb;
  40.     always@(posedge Clk or negedge Rst_n)
  41.     if(!Rst_n)begin
  42.         key_in_sa <= 1'b0;
  43.         key_in_sb <= 1'b0;
  44.     end
  45.     else begin
  46.         key_in_sa <= key_in;
  47.         key_in_sb <= key_in_sa;    
  48.     end
  50.     //获取上一个周期的 按键电平 和当前 按键电平
  51.     //目的： 获取 按键状态判断是否是下降沿还是上升沿到来
  52.     always@(posedge Clk or negedge Rst_n)
  53.     if(Rst_n == 1'b0) begin
  54.         key_tmp0 <= 1'b0 ;
  55.         key_tmp1 <= 1'b0 ;
  56.     end
  57.     else begin //每次时钟上升沿到来，两个寄存器读取上一次的数据的值
  58.         key_tmp0 <= key_in_sb;
  59.         key_tmp1 <= key_tmp0;    
  60.     end    
  62.     // 下降沿和上升沿到来标志位信号
  63.     assign nedge = ((~key_tmp0 ) & ( key_tmp1)) ; //判断下降沿是否到来？  
  64.     //分析：:  下降沿到来的清况是高电平-->低电平的变换过程，也就是说：
  65.     //    key_tmp1 存的前1个时刻的电平，
  66.     // key_tmp0 存的是当前时刻的电平，
  67.     // 要满足该条件，也就是说， key_tmp0 <= 0 且 key_tmp1 <= 1; 此时得到 nedge = 1 ;
  68.     assign pedge = key_tmp0 & (!key_tmp1) ; //判断上升沿是否到来？    
  70.     //状态机判断
  71.     always@(posedge Clk or negedge Rst_n)
  72.     if(!Rst_n) //复位状态下，状态机处于空闲状态 
  73.         begin    
  74.             state <= IDEL ;            //复位状态下，状态机处于空闲模式下
  75.             en_cnt_20ms <= 1'b0 ; //消抖计数器关闭
  76.             key_flag  <= 1'b0 ;     //按键成功标志位清零
  77.             key_state <= 1'b1 ;     //默认输入按键状态高电平
  78.         end
  79.     else 
  80.        begin
  81.          case(state)
  82.             IDEL :
  83.                 begin
  84.                     key_flag <= 1'b0 ;    //空闲状态下，按键成功标志位永远为0
  85.                     if(nedge == 1'b1) begin        //按键检测到下降沿到来
  86.                         state <= FILTER0 ;//进入下一个案件滤波状态
  87.                         en_cnt_20ms <= 1 ;//开启使能计数20ms
  88.                         end
  89.                     else
  90.                        state <= IDEL ;    //未检测到下降沿到来，信号状态保持不变
  91.                 end
  92.             FILTER0:
  93.             if(cnt_20ms_full == 1'b1) begin //看消除抖动20ms后，且20ms内没有检测到上升沿到来  = 20ms
  94.                     key_flag <= 1'b1;        //表示按键    已经成功按下
  95.                     key_state<= 1'b0;        //此时输入按键按下输出状态为低电平
  96.                     state <= DOWN ;        //进入下一状态
  97.                     en_cnt_20ms <= 0 ;    //20ms计数器关闭                
  98.                 end
  99.             else if(pedge == 1'b1) begin    //没有满20ms 以内，有上升沿的到来,表明此时是抖动信号，非按键按下信号
  100.                     state <= IDEL ;
  101.                     en_cnt_20ms <= 0 ;//计数器关闭
  102.                 end
  103.                 else    //上述两者情况均为出现，则状态机保持不变
  104.                     state <= FILTER0 ;
  105.             DOWN:
  106.                 begin 
  107.                 key_flag <= 1'b0; //检测到有按键按下，发送一个脉冲信号，由上一个状态的高电平变为低电平
  108.                     if(pedge == 1'b1) begin //上一个状态时间超过20ms，此时需要一直等待上升沿的到来（做为按键松开的标志）
  109.                         state <= FILTER1 ;    //进入到下一状态
  110.                         en_cnt_20ms <= 1'b1 ;//开启下一次20ms 延时计数
  111.                     end
  112.                     else  //没有，则保持该状态
  113.                         state <= DOWN ;    
  114.                 end        
  115.             FILTER1:
  116.                 if(cnt_20ms_full == 1'b1) begin//表示 20ms计数又一次到来,此时按键稳定
  117.                    key_flag <= 1'b1;        //表示上升沿的信号稳定的信号，随后到 IDEL又会设置为低电平，产生一个脉冲信号
  118.                     key_state<= 1'b1;         //此时输入按键按下状态为低电平
  119.                     en_cnt_20ms <= 1'b0 ; //关闭20ms定时器
  120.                     state <=IDEL ;
  121.                 end
  122.                 else if(nedge)begin    // 20ms内又出现了下降沿，表示这是一次抖动
  123.                     en_cnt_20ms <= 1'b0 ;
  124.                     state <= DOWN ;
  125.                 end
  126.                 else    //20ms内状态保持不变
  127.                     state <=FILTER1 ;
  128.             default:
  129.                 begin
  130.                     state <= IDEL ; 
  131.                     key_flag <= 1'b0;
  132.                     key_state<= 1'b1;     //默认状态时 1 高电平
  133.                     en_cnt_20ms <= 1'b0 ; //默认状态时 0 低电平
  134.                 end
  135.         endcase
  136.       end
  138. //    定时器启动 always块
  139.     always@(posedge Clk or negedge Rst_n)
  140.     if(!Rst_n)
  141.         cnt_20ms <= 20'd0;
  142.     else if(en_cnt_20ms)
  143.         cnt_20ms <= cnt_20ms + 1'b1;
  144.     else // 关闭时，计时器清零
  145.         cnt_20ms <= 20'd0;
  148.     //定时器20ms always块 50Mhz 20ms = cnt_20ms : 1_000_000
  149.     always@(posedge Clk or negedge Rst_n)
  150.     if(Rst_n == 1'b0)
  151.         cnt_20ms_full <= 0 ;
  152.     else if(cnt_20ms == 20'd999_999)
  153.         cnt_20ms_full <= 1'b1 ;  //计数值计满标志位
  154.     else
  155.         cnt_20ms_full <= 1'b0 ;    // 未挤满，输出0
  158. endmodule

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

  1. // 模块功能，每次按键按下，使用控制AD 100次信号采样
  2. // 采样的信号 存放到fifo中。
  4. module  ctrl_sample
  5. (
  6.     Clk,
  7.     Rst_n,
  8.     key_flag ,
  9.     key_state ,
  10.     Ad_Conv_Done,
  11.     Fifo_almost_full,
  13.     Ad_En_Conv
  15. );
  16.     input Clk;
  17.     input Rst_n;
  18.     input key_flag ;
  19.     input key_state ;
  20.     input Ad_Conv_Done;
  21.     input Fifo_almost_full;
  23.     output reg Ad_En_Conv;
  25.     parameter SAMPLE_TIMES =  100 ; //每次采样次数
  27.     reg [6:0]sample_cnt ;
  29.     // key_state key_flag
  30.     // Ad_En_Conv ;
  31.     reg en_flag ;
  32.     always@(posedge Clk or negedge Rst_n)
  33.     if(!Rst_n)
  34.         en_flag <= 1'b0 ;
  35.     else if(key_flag && (!key_state))
  36.         begin
  37.             if(Fifo_almost_full)
  38.                 en_flag <= 1'b0;
  39.             else
  40.                 en_flag <= 1'b1;
  41.         end
  42.     else if(Fifo_almost_full || (sample_cnt== (SAMPLE_TIMES-1)) )
  43.         en_flag <= 1'b0;
  44.     else
  45.         en_flag <= en_flag ;
  47.     // Ad_En_Conv handle
  48.     always@(posedge Clk or negedge Rst_n)
  49.     if(!Rst_n)
  50.         Ad_En_Conv <= 1'b0 ;
  51.     else if(key_flag && (!key_state))
  52.         begin
  53.             if(Fifo_almost_full)
  54.                 Ad_En_Conv <= 1'b0;
  55.             else
  56.                 Ad_En_Conv <= 1'b1;
  57.         end
  58.     else if(en_flag && Ad_Conv_Done)
  59.         Ad_En_Conv <= 1'b1;
  60.     else    
  61.         Ad_En_Conv <= 1'b0;
  64.     // Ad_Conv_Done
  65.     // Ad_En_Conv
  66.     // sample_cnt
  67.     always@(posedge Clk or negedge Rst_n)
  68.     if(!Rst_n)
  69.         sample_cnt <= 7'b0 ;
  70.     else if(Ad_Conv_Done)
  71.         begin
  72.             if(sample_cnt == (SAMPLE_TIMES-1) )
  73.                 sample_cnt <=7'd0;
  74.             else
  75.                 sample_cnt <= sample_cnt +1'b1;
  76.         end
  77.     else
  78.         sample_cnt <= sample_cnt ;
  81. endmodule

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

  1. module ad128s022
  2. (
  3.             Clk,
  4.             Rst_n,
  6.             Channel,
  7.             Data,
  9.             En_Conv,
  10.             Conv_Done,
  11.             ADC_State,
  12.             DIV_PARAM,
  14.             ADC_SCLK,
  15.             ADC_DOUT,
  16.             ADC_DIN,
  17.             ADC_CS_N    
  18. );
  20.             input Clk;
  21.             input Rst_n;
  23.             input  [2:0]Channel;
  24.             output reg [11:0]Data;
  26.             input En_Conv;
  27.             output reg Conv_Done;
  28.             output ADC_State;
  29.             input [7:0]DIV_PARAM;
  31.             output reg ADC_SCLK;
  32.             input  ADC_DOUT;
  33.             output reg ADC_DIN;
  34.             output reg ADC_CS_N;    
  37.             reg en ;
  38.             reg [2:0]r_Channel;
  39.             reg [7:0]DIV_CNT ;
  40.             reg  SCLK2X ;
  41.             reg [5:0]SCLK_GEN_CNT;
  42.             reg [11:0]r_Data;
  47.             //  en handle 
  48.             always@(posedge Clk or negedge Rst_n)
  49.             if(!Rst_n)
  50.                 en <= 1'b0;
  51.             else if(En_Conv)
  52.                 en <= 1'b1;
  53.             else if(Conv_Done)
  54.                 en <= 1'b0 ;
  55.             else
  56.                 en <= en ;
  60.             // r_Channel  we set En_Conv is a plus signal 
  61.             always@(posedge Clk or negedge Rst_n)
  62.             if(!Rst_n)
  63.                 r_Channel <= 3'd0;
  64.             else if(En_Conv)
  65.                 r_Channel <= Channel;
  66.             else
  67.                 r_Channel <= r_Channel;
  69.             // 时钟分频脉冲计数
  70.             // reg [7:0]DIV_CNT ;
  71.             always@(posedge Clk or negedge Rst_n)
  72.             if(!Rst_n)
  73.                 DIV_CNT <= 8'd0 ;
  74.             else if(en)
  75.                 begin
  76.                 if(DIV_CNT == (DIV_PARAM -1) )
  77.                     DIV_CNT <= 8'd0 ;
  78.                 else    
  79.                     DIV_CNT <= DIV_CNT + 1'd1 ;
  80.                 end
  81.             else    
  82.                 DIV_CNT <= 8'd0 ;
  84.             // SCLK2X plus
  85.             // reg  SCLK2X
  86.             always@(posedge Clk or negedge Rst_n)
  87.             if(!Rst_n)
  88.                 SCLK2X <= 1'b0;
  89.             else if(DIV_CNT == (DIV_PARAM -1) )
  90.                 SCLK2X <= 1'b1 ;
  91.             else
  92.                 SCLK2X <= 1'b0;
  94.             // reg [5:0]SCLK_GEN_CNT 
  95.             always@(posedge Clk or negedge Rst_n)
  96.             if(!Rst_n)
  97.                 SCLK_GEN_CNT  <= 6'd0 ;
  98.             else if(en && SCLK2X)
  99.                 begin
  100.                 if(SCLK_GEN_CNT == 6'd33)
  101.                     SCLK_GEN_CNT <=6'd0;
  102.                 else
  103.                     SCLK_GEN_CNT <= SCLK_GEN_CNT + 1'b1 ;
  104.                 end
  105.             else
  106.                 SCLK_GEN_CNT <= SCLK_GEN_CNT ;
  107.             //
  109.             /*
  110.             output ADC_SCLK
  111.             input  ADC_DOUT;
  112.             output ADC_DIN;
  113.             output reg ADC_CS_N;    
  114.             reg [11:0]r_Data;
  115.             */
  117.             always@(posedge Clk or negedge Rst_n)
  118.             if(!Rst_n)
  119.                 begin
  120.                 ADC_SCLK <= 1'b1;
  121.                 ADC_DIN  <= 1'b0;
  122.                 ADC_CS_N  <= 1'b1;
  123.                 end
  124.             else if(en && SCLK2X)
  125.                 begin
  126.                 case(SCLK_GEN_CNT)
  127.                 0: begin ADC_CS_N <= 1'b0; ADC_SCLK <= 1'b1; ADC_DIN <= 1'b0; end
  128.                 1,3: begin ADC_SCLK <= 1'b0; end
  129.                 2,4,6,8:  begin ADC_SCLK <= 1'b1 ; end
  130.                 5:  begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[2]; end
  131.                 7:  begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[1]; end
  132.                 9:  begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[0]; end
  133.                 10: begin ADC_SCLK <= 1'b1; r_Data[11] <= ADC_DOUT ; end
  134.                 12: begin ADC_SCLK <= 1'b1; r_Data[10] <= ADC_DOUT ; end
  135.                 14: begin ADC_SCLK <= 1'b1; r_Data[9] <= ADC_DOUT ; end
  136.                 16: begin ADC_SCLK <= 1'b1; r_Data[8] <= ADC_DOUT ; end
  137.                 18: begin ADC_SCLK <= 1'b1; r_Data[7] <= ADC_DOUT ; end
  138.                 20: begin ADC_SCLK <= 1'b1; r_Data[6] <= ADC_DOUT ; end
  139.                 22: begin ADC_SCLK <= 1'b1; r_Data[5] <= ADC_DOUT ; end
  140.                 24: begin ADC_SCLK <= 1'b1; r_Data[4] <= ADC_DOUT ; end
  141.                 26: begin ADC_SCLK <= 1'b1; r_Data[3] <= ADC_DOUT ; end
  142.                 28: begin ADC_SCLK <= 1'b1; r_Data[2] <= ADC_DOUT ; end
  143.                 30: begin ADC_SCLK <= 1'b1; r_Data[1] <= ADC_DOUT ; end
  144.                 32: begin ADC_SCLK <= 1'b1; r_Data[0] <= ADC_DOUT ; end
  145.                 11,13,15,17,19,21,23,25,27,29,31: begin ADC_SCLK <= 1'b0;  end
  146.                 33: begin ADC_CS_N <= 1'b1; end
  147.                 default: ;
  148.                 endcase
  149.                 end    
  151.         // output [11:0]Data 
  152.         always@(posedge Clk or negedge Rst_n)
  153.         if(!Rst_n)
  154.             Data  <= 12'd0 ;
  155.         else if(en && SCLK2X && (SCLK_GEN_CNT == 6'd33))
  156.             Data <= r_Data ;
  157.         else
  158.             Data <= Data ;
  160.         // conv_Done signal
  161.         always@(posedge Clk or negedge Rst_n)
  162.         if(!Rst_n)
  163.             Conv_Done  <= 1'd0 ;
  164.         else if(en && SCLK2X && (SCLK_GEN_CNT == 6'd33))
  165.             Conv_Done <= 1'd1 ;
  166.         else
  167.             Conv_Done <= 1'd0 ;    
  169.         //产生ADC工作状态指示信号,保持和CS片选信号同步即可
  170.         assign ADC_State = ADC_CS_N ; 
  172. endmodule

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

  1. // megafunction wizard: %FIFO%
  2. // GENERATION: STANDARD
  3. // VERSION: WM1.0
  4. // MODULE: scfifo 
  6. // ============================================================
  7. // File Name: AD_fifo.v
  8. // Megafunction Name(s):
  9. //             scfifo
  10. //
  11. // Simulation Library Files(s):
  12. //             
  13. // ============================================================
  14. // ************************************************************
  15. // THIS IS A WIZARD-GENERATED FILE. DO NOT EDIT THIS FILE!
  16. //
  17. // 13.0.0 Build 156 04/24/2013 SJ Full Version
  18. // ************************************************************
  21. //Copyright (C) 1991-2013 Altera Corporation
  22. //Your use of Altera Corporation's design tools, logic functions 
  23. //and other software and tools, and its AMPP partner logic 
  24. //functions, and any output files from any of the foregoing 
  25. //(including device programming or simulation files), and any 
  26. //associated documentation or information are expressly subject 
  27. //to the terms and conditions of the Altera Program License 
  28. //Subscription Agreement, Altera MegaCore Function License 
  29. //Agreement, or other applicable license agreement, including, 
  30. //without limitation, that your use is for the sole purpose of 
  31. //programming logic devices manufactured by Altera and sold by 
  32. //Altera or its authorized distributors.  Please refer to the 
  33. //applicable agreement for further details.
  36. // synopsys translate_off
  37. `timescale 1 ps / 1 ps
  38. // synopsys translate_on
  39. module AD_fifo (
  40.     clock,
  41.     data,
  42.     rdreq,
  43.     sclr,
  44.     wrreq,
  45.     almost_empty,
  46.     almost_full,
  47.     empty,
  48.     full,
  49.     q,
  50.     usedw);
  52.     input      clock;
  53.     input    [11:0]  data;
  54.     input      rdreq;
  55.     input      sclr;
  56.     input      wrreq;
  57.     output      almost_empty;
  58.     output      almost_full;
  59.     output      empty;
  60.     output      full;
  61.     output    [11:0]  q;
  62.     output    [9:0]  usedw;
  64.     wire [9:0] sub_wire0;
  65.     wire  sub_wire1;
  66.     wire  sub_wire2;
  67.     wire [11:0] sub_wire3;
  68.     wire  sub_wire4;
  69.     wire  sub_wire5;
  70.     wire [9:0] usedw = sub_wire0[9:0];
  71.     wire  empty = sub_wire1;
  72.     wire  full = sub_wire2;
  73.     wire [11:0] q = sub_wire3[11:0];
  74.     wire  almost_empty = sub_wire4;
  75.     wire  almost_full = sub_wire5;
  77.     scfifo    scfifo_component (
  78.                 .clock (clock),
  79.                 .sclr (sclr),
  80.                 .wrreq (wrreq),
  81.                 .data (data),
  82.                 .rdreq (rdreq),
  83.                 .usedw (sub_wire0),
  84.                 .empty (sub_wire1),
  85.                 .full (sub_wire2),
  86.                 .q (sub_wire3),
  87.                 .almost_empty (sub_wire4),
  88.                 .almost_full (sub_wire5),
  89.                 .aclr ());
  90.     defparam
  91.         scfifo_component.add_ram_output_register = "OFF",
  92.         scfifo_component.almost_empty_value = 1,
  93.         scfifo_component.almost_full_value = 1023,
  94.         scfifo_component.intended_device_family = "Cyclone IV E",
  95.         scfifo_component.lpm_numwords = 1024,
  96.         scfifo_component.lpm_showahead = "OFF",
  97.         scfifo_component.lpm_type = "scfifo",
  98.         scfifo_component.lpm_width = 12,
  99.         scfifo_component.lpm_widthu = 10,
  100.         scfifo_component.overflow_checking = "ON",
  101.         scfifo_component.underflow_checking = "ON",
  102.         scfifo_component.use_eab = "ON";
  105. endmodule

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

  1. module  fifo_send_ctrl
  2. (    
  3.     Clk,
  4.     Rst_n,
  5.     Tx_done ,
  6.     Fifo_empty ,
  7.     Fifo_q,
  9.     Tx_Send_en,
  10.     Tx_Data,
  11.     Fifo_rdreq
  12. );
  14.     input Clk ;
  15.     input Rst_n ;
  16.     input Tx_done ;
  17.     input Fifo_empty ;
  18.     input [11:0]Fifo_q ;
  20.     output reg Tx_Send_en ;
  21.     output reg [7:0]Tx_Data ;
  22.     output reg Fifo_rdreq ;
  24.     //
  25. localparam
  26.         STATE_S0    = 5'b0_0001,
  27.         STATE_S1 = 5'b0_0010,
  28.         STATE_S2    = 5'b0_0100,
  29.         STATE_S3    = 5'b0_1000,
  30.         STATE_S4    = 5'b1_0000;
  32.     reg[4:0]state;
  34.     always@(posedge Clk or negedge Rst_n)
  35.     if(!Rst_n)begin
  36.         state <= STATE_S0;
  37.     end
  38.     else begin
  39.         case(state)
  40.             STATE_S0:
  41.                 if(Fifo_empty == 1'b0) 
  42.                     begin                     // fifo 有data
  43.                     Fifo_rdreq <= 1'b1 ; //发送读信号
  44.                     state <= STATE_S1;
  45.                     end
  46.                 else
  47.                     state <= STATE_S0;    
  48.             STATE_S1:
  49.                     begin
  50.                     Fifo_rdreq <= 1'b0 ;
  51.                     state <= STATE_S2;
  52.                     end
  53.             STATE_S2:
  54.                     begin
  55.                     Tx_Send_en <= 1'b1;
  56.                     Tx_Data <= {4'b0000,Fifo_q[11:8]} ; // 先发送高8位
  57.                     state <= STATE_S3;
  58.                     end            
  59.             STATE_S3:
  60.                 if(Tx_done == 1'b1)
  61.                     begin
  62.                     Tx_Send_en <= 1'b1;
  63.                     Tx_Data <= Fifo_q[7:0] ; //再发送低8位
  64.                     state <= STATE_S4;
  65.                     end    
  66.                 else
  67.                     begin
  68.                     Tx_Send_en <= 1'b0;
  69.                     state <= STATE_S3;
  70.                     end                    
  71.             STATE_S4:
  72.                 if(Tx_done == 1'b1)
  73.                     state <= STATE_S0;
  74.                 else if(Tx_done == 1'b0)
  75.                     begin
  76.                     Tx_Send_en <= 1'b0;
  77.                     state <= STATE_S4;
  78.                     end            
  79.             default:state <= STATE_S1;
  80.         endcase        
  81.     end
  84. endmodule

第8部分： uart_byte_tx .v 串口发送模块

  1. module uart_byte_tx(
  2.     Clk,
  3.     Rst_n,
  4.     data_byte,
  5.     send_en,
  6.     baud_set,
  8.     Rs232_Tx,
  9.     Tx_Done,
  10.     uart_state
  11. );
  13.     input Clk;
  14.     input Rst_n;
  15.     input [7:0]data_byte;
  16.     input send_en;
  17.     input [2:0]baud_set;
  19.     output reg Rs232_Tx;
  20.     output reg Tx_Done;
  21.     output reg uart_state;
  23.     reg bps_clk;    //波特率时钟
  25.     reg [15:0]div_cnt;//分频计数器
  27.     reg [15:0]bps_DR;//分频计数最大值
  29.     reg [3:0]bps_cnt;//波特率时钟计数器
  31.     reg [7:0]r_data_byte;
  33.     localparam START_BIT = 1'b0;
  34.     localparam STOP_BIT = 1'b1;
  36.     always@(posedge Clk or negedge Rst_n)
  37.     if(!Rst_n)
  38.         uart_state <= 1'b0;
  39.     else if(send_en)
  40.         uart_state <= 1'b1;
  41.     else if(bps_cnt == 4'd11)
  42.         uart_state <= 1'b0;
  43.     else
  44.         uart_state <= uart_state;
  46.     always@(posedge Clk or negedge Rst_n)
  47.     if(!Rst_n)
  48.         r_data_byte <= 8'd0;
  49.     else if(send_en)
  50.         r_data_byte <= data_byte;
  51.     else
  52.         r_data_byte <= r_data_byte;
  54.     always@(posedge Clk or negedge Rst_n)
  55.     if(!Rst_n)
  56.         bps_DR <= 16'd5207;
  57.     else begin
  58.         case(baud_set)
  59.             0:bps_DR <= 16'd5207;
  60.             1:bps_DR <= 16'd2603;
  61.             2:bps_DR <= 16'd1301;
  62.             3:bps_DR <= 16'd867;
  63.             4:bps_DR <= 16'd433;
  64.             default:bps_DR <= 16'd5207;            
  65.         endcase
  66.     end    
  68.     //counter
  69.     always@(posedge Clk or negedge Rst_n)
  70.     if(!Rst_n)
  71.         div_cnt <= 16'd0;
  72.     else if(uart_state)begin
  73.         if(div_cnt == bps_DR)
  74.             div_cnt <= 16'd0;
  75.         else
  76.             div_cnt <= div_cnt + 1'b1;
  77.     end
  78.     else
  79.         div_cnt <= 16'd0;
  81.     // bps_clk gen
  82.     always@(posedge Clk or negedge Rst_n)
  83.     if(!Rst_n)
  84.         bps_clk <= 1'b0;
  85.     else if(div_cnt == 16'd1)
  86.         bps_clk <= 1'b1;
  87.     else
  88.         bps_clk <= 1'b0;
  90.     //bps counter
  91.     always@(posedge Clk or negedge Rst_n)
  92.     if(!Rst_n)    
  93.         bps_cnt <= 4'd0;
  94.     else if(bps_cnt == 4'd11)
  95.         bps_cnt <= 4'd0;
  96.     else if(bps_clk)
  97.         bps_cnt <= bps_cnt + 1'b1;
  98.     else
  99.         bps_cnt <= bps_cnt;
  101.     always@(posedge Clk or negedge Rst_n)
  102.     if(!Rst_n)
  103.         Tx_Done <= 1'b0;
  104.     else if(bps_cnt == 4'd11)
  105.         Tx_Done <= 1'b1;
  106.     else
  107.         Tx_Done <= 1'b0;
  109.     always@(posedge Clk or negedge Rst_n)
  110.     if(!Rst_n)
  111.         Rs232_Tx <= 1'b1;
  112.     else begin
  113.         case(bps_cnt)
  114.             0:Rs232_Tx <= 1'b1;
  115.             1:Rs232_Tx <= START_BIT;
  116.             2:Rs232_Tx <= r_data_byte[0];
  117.             3:Rs232_Tx <= r_data_byte[1];
  118.             4:Rs232_Tx <= r_data_byte[2];
  119.             5:Rs232_Tx <= r_data_byte[3];
  120.             6:Rs232_Tx <= r_data_byte[4];
  121.             7:Rs232_Tx <= r_data_byte[5];
  122.             8:Rs232_Tx <= r_data_byte[6];
  123.             9:Rs232_Tx <= r_data_byte[7];
  124.             10:Rs232_Tx <= STOP_BIT;
  125.             default:Rs232_Tx <= 1'b1;
  126.         endcase
  127.     end    
  129. endmodule

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

  1. // 实验内容：
  2. // ① 通过按键控制AD采集模块
  3. // ② 按键按下，ad 进行采样100 次，操作
  4. // ③ ad 采样的数据存取到fifo 中
  5. // ④ 读取fifo中的数据，将数据通过串口模块发送，直到fifo 的数据全部读取完毕为止
  6. // ⑤ 读取的数据是12位，串口模块发送需要先变成标准的2个8位数据发送，通过电脑上的串口调试助手显示发送的数据
  7. // 信号发生器模块： 【内部有一个 DA_rom 数据模块】 ，每次间隔0.01S,发送一次模拟数据到，模拟信号发送通道1，发送出去
  8. // 信号采样时间现在本工程暂时无法控制，下一个工程【27_ADC_DAC_system】将会完善改功能
  9. module  AD_DA_Top
  10. (
  11.      Clk ,
  12.      Rst_n ,
  13.      key_in ,
  15.      ADC_DOUT ,
  16.      ADC_SCLK ,
  17.      ADC_DIN  ,
  18.      ADC_CS_N ,
  20.      Rs232_Tx ,
  22.      DAC_CS_N ,
  23.      DAC_DIN  ,
  24.      DAC_SCLK
  26. );
  29.     input Clk ;
  30.     input Rst_n ;
  31.     input key_in ;
  33.     input ADC_DOUT ;
  34.     output ADC_SCLK;
  35.     output ADC_DIN;
  36.     output ADC_CS_N;
  38.     output Rs232_Tx;
  40.     // 信号源
  41.     output  DAC_CS_N;
  42.     output  DAC_DIN;
  43.     output  DAC_SCLK;
  46.     wire key_flag ;
  47.     wire key_state ;
  48.     wire Ad_En_Conv;
  49.     wire Conv_Done;
  50.     wire Fifo_empty;
  51.     wire Fifo_almost_full;
  53.     wire Tx_Done;
  54.     wire Tx_Send_en;
  55.     wire [7:0]Tx_Data;
  56.     wire [11:0]fifo_dtae;
  57.     wire [11:0]Fifo_q;
  58.     wire Fifo_rdreq;
  60.     wire [15:0]DAC_DATA ;
  61.     wire Start ;
  62.     wire DAC_State;
  64. key_filter    key_filter_0(
  65.         .Clk(Clk) ,
  66.         .Rst_n(Rst_n) ,
  67.         .key_in(key_in) ,
  69.         .key_flag(key_flag), //检测按键成功信号
  70.         .key_state(key_state) //实时的信号
  71.     );
  74. ctrl_sample ctrl_sample0
  75.     ( 
  76.         .Clk(Clk),
  77.         .Rst_n(Rst_n),
  78.         .key_flag(key_flag) ,
  79.         .key_state(key_state) ,
  80.         .Ad_Conv_Done(Conv_Done),
  81.         .Fifo_almost_full(Fifo_almost_full),
  83.         .Ad_En_Conv(Ad_En_Conv)
  85.     );
  88. ad128s022 ad128s022_0
  89. (
  90.             .Clk(Clk),
  91.             .Rst_n(Rst_n),
  93.             .Channel(3'd5),
  94.             .Data(fifo_dtae),
  96.             .En_Conv(Ad_En_Conv),
  97.             .Conv_Done(Conv_Done),
  98.             .ADC_State(), // 和 ADC_CS_N  状态保持一致
  99.             .DIV_PARAM(8'd13),
  101.             .ADC_SCLK(ADC_SCLK),
  102.             .ADC_DOUT(ADC_DOUT),
  103.             .ADC_DIN(ADC_DIN),
  104.             .ADC_CS_N(ADC_CS_N)    
  105. );    
  107.     AD_fifo    AD_fifo_0 (
  108.         .clock(Clk),
  109.         .data(fifo_dtae),
  110.         .rdreq(Fifo_rdreq),
  111.         .sclr(!Rst_n), 
  112.         .wrreq(Conv_Done),
  113.         .almost_empty(),
  114.         .almost_full(Fifo_almost_full),
  115.         .empty(Fifo_empty),
  116.         .full(),
  117.         .q(Fifo_q),
  118.         .usedw()
  119.         );
  123. fifo_send_ctrl    fifo_send_ctrl_0
  124.     (    
  125.         .Clk(Clk),
  126.         .Rst_n(Rst_n),
  127.         .Tx_done(Tx_Done) ,
  128.         .Fifo_empty(Fifo_empty) ,
  129.         .Fifo_q(Fifo_q),
  131.         .Tx_Send_en(Tx_Send_en),
  132.         .Tx_Data(Tx_Data),
  133.         .Fifo_rdreq(Fifo_rdreq)
  134.     );
  137. uart_byte_tx    uart_byte_tx_0(
  138.         .Clk(Clk),
  139.         .Rst_n(Rst_n),
  140.         .data_byte(Tx_Data),
  141.         .send_en(Tx_Send_en),
  142.         .baud_set(3'd4),     // 115200bps
  144.         .Rs232_Tx(Rs232_Tx),
  145.         .Tx_Done(Tx_Done),
  146.         .uart_state()
  147.     );
  150.         DAC_rom_signal DAC_rom_signal_0
  151.         (
  152.             .Clk(Clk),
  153.             .Rst_n(Rst_n),
  154.             .DAC_State(DAC_State),
  155.             .DAC_DATA(DAC_DATA),
  156.             .Data_Start(Start)
  157.         );
  159.         dac_tlv5618 dac_tlv5618_0
  160.         (
  161.             .Clk(Clk),
  162.             .Rst_n(Rst_n),
  164.             .DAC_DATA(DAC_DATA),
  165.             .Start(Start),
  166.             .Set_Done(),
  168.             .DAC_CS_N(DAC_CS_N),
  169.             .DAC_DIN(DAC_DIN),
  170.             .DAC_SCLK(DAC_SCLK),
  171.             .DAC_State(DAC_State)
  172.         );
  174. endmodule

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

发表评论

表情：
评论列表 （有 0 条评论，218人围观）

还没有评论，来说两句吧...

相关阅读