AD7606+Verilog+FPGA+vivado+串口通信+数据解读 并行 全站最全

已于 2024-07-14 20:45:35 修改
阅读量414 收藏 3
点赞数 7
分类专栏： FPGA 文章标签： fpga开发
于 2024-07-14 14:56:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47761339/article/details/140415985
版权

AD7606具有八通道的采集信号，我们可以用它来采集各种模拟信号。我所用的模块如下：

在这里插入图片描述
如上图，右边10个接口，中间CH1~CH8为八路模拟信号输入，其两端为AGND。
左边为单片机或 fpga连接的线。本次用的是并行，所以DB0~DB15作为信号线输出给fpga。
OS0~OS2代码里均设置为0或也可自行接地，即无过采样。CO-A和CO-B连接到fpga的同一个引脚，FR-D可接也可不接，busy，RD/SC（代码对应是ad_rd）。SER接地（相当于并行输出，如果接高电平，相当于串行输出）如下图手册说明。
ser要接低电平才是并行
时序图，程序按看第一（即图2）和第三个（图4）来的。

在这里插入图片描述

用的板子芯片为7020的，上海微相板子，对应连接线如下。
约束
fpga的JP1端接线口整体图
ps:关于AD7606的供电可以用fpga的5V和gnd供电。

在这里插入图片描述
AD7606_UART代码如下：

`timescale 1ns / 1ps


module ad7606_uart(
 sys_clk,        
 rst_n,                 
 ad_data,    
 ad_busy,    
 first_data,            
 ad_os,      
 ad_cs,      
 ad_rd,      
 ad_reset,   
 ad_convstab,

uart_tx     
    );
    input                sys_clk;                  //50mhz
    input               rst_n;
 
    input [15:0]        ad_data;            //ad7606 采样数据
    input               ad_busy;            //ad7606 忙标志位
    input                first_data;         //ad7606 第一个数据标志位  
    output [2:0]        ad_os;              //ad7606 过采样倍率选择
    output          ad_cs;             //ad7606 AD cs
    output          ad_rd;              //ad7606 AD data read
    output          ad_reset;           //ad7606 AD reset
    output          ad_convstab;         //ad7606 AD convert start
 
    wire[15:0] ad_ch1   ;        //AD第1通道的数据
    wire[15:0] ad_ch2   ;        //AD第2通道的数据
    wire[15:0] ad_ch3   ;        //AD第3通道的数据
    wire[15:0] ad_ch4   ;        //AD第4通道的数据
    wire[15:0] ad_ch5   ;        //AD第5通道的数据
    wire[15:0] ad_ch6   ;        //AD第6通道的数据
    wire[15:0] ad_ch7   ;        //AD第7通道的数据
    wire[15:0] ad_ch8   ;       //AD第8通道的数据  */

    wire[15:0]data1  ;
    wire[15:0]data2  ;
    wire[15:0]data3  ;
    wire[15:0]data4  ;
    wire[15:0]data5  ;
    wire[15:0]data6  ;
    wire[15:0]data7  ;
    wire[15:0]data8  ;
	output                       uart_tx;
 ad7606 ad7606(
   .  clk(sys_clk),                  //50mhz
   .  rst_n(rst_n),
  
   .  ad_data(ad_data),            //ad7606 采样数据
   .  ad_busy(ad_busy),            //ad7606 忙标志位
   .  first_data( first_data),         //ad7606 第一个数据标志位  
   
   .  ad_os(ad_os),              //ad7606 过采样倍率选择
   .  ad_cs(ad_cs),              //ad7606 AD cs
   .  ad_rd(ad_rd),              //ad7606 AD data read
   .  ad_reset(ad_reset),           //ad7606 AD reset
   .  ad_convstab(ad_convstab),         //ad7606 AD convert start
   
   .ad_ch1(ad_ch1),              //AD第1通道的数据
   .ad_ch2(ad_ch2),              //AD第2通道的数据
   .ad_ch3(ad_ch3),              //AD第3通道的数据
   .ad_ch4(ad_ch4),              //AD第4通道的数据
   .ad_ch5(ad_ch5),              //AD第5通道的数据
   .ad_ch6(ad_ch6),              //AD第6通道的数据
   .ad_ch7(ad_ch7),              //AD第7通道的数据
   .ad_ch8(ad_ch8)              //AD第8通道的数据  
  
    //output reg [3:0] cnt
 
    );   
  uart_test   uart_test(
.sys_clk(sys_clk) ,      //system clock 50Mhz on board
.rst_n(rst_n) ,      //reset ,low active
.data1(ad_ch1) ,
.data2(ad_ch2) ,
.data3(ad_ch3) ,
.data4(ad_ch4) ,
.data5(ad_ch5) ,
.data6(ad_ch6) ,
.data7(ad_ch7) ,
.data8(ad_ch8) ,
.uart_tx(uart_tx)
);

endmodule

底层ad7606代码如下：

`timescale 1ns / 1ns
//
// Module Name:    ad7606 
//
module ad7606(
   input                clk,                  //50mhz
    input               rst_n,
 
    input [15:0]        ad_data,            //ad7606 采样数据
    input               ad_busy,            //ad7606 忙标志位
   input                first_data,         //ad7606 第一个数据标志位  
 
    output [2:0]        ad_os,              //ad7606 过采样倍率选择
    output reg          ad_cs,              //ad7606 AD cs
    output reg          ad_rd,              //ad7606 AD data read
    output reg          ad_reset,           //ad7606 AD reset
    output reg          ad_convstab,         //ad7606 AD convert start
 
    output reg [15:0] ad_ch1,              //AD第1通道的数据
    output reg [15:0] ad_ch2,              //AD第2通道的数据
    output reg [15:0] ad_ch3,              //AD第3通道的数据
    output reg [15:0] ad_ch4,              //AD第4通道的数据
    output reg [15:0] ad_ch5,              //AD第5通道的数据
    output reg [15:0] ad_ch6,              //AD第6通道的数据
    output reg [15:0] ad_ch7,              //AD第7通道的数据
    output reg [15:0] ad_ch8              //AD第8通道的数据  
  
    //output reg [3:0] cnt
 
    );
 reg [3:0]  state;
 
reg [7:0] cnt = 0 ;
reg [15:0] cnt50us = 0;
reg [5:0] i;
//reg [3:0] state;
 
parameter IDLE=4'd0;
parameter AD_CONV=4'd1;
parameter Wait_1=4'd2;
parameter Wait_busy=4'd3;
parameter READ_CH1=4'd4;
parameter READ_CH2=4'd5;
parameter READ_CH3=4'd6;
parameter READ_CH4=4'd7;
parameter READ_CH5=4'd8;
parameter READ_CH6=4'd9;
parameter READ_CH7=4'd10;
parameter READ_CH8=4'd11;
parameter READ_DONE=4'd12;
//parameter display=4'd13;
 
assign ad_os=3'b000;  //无过采样
//ad复位
always@(posedge clk)
 begin
    if(cnt<8'hff) begin
        cnt<=cnt+1;
        ad_reset<=1'b1;
      end
      else
        ad_reset<=1'b0;  //计数器达到ff后停止，ad_reset恒为零     
   end
 
//使用定时器来设置采样频率
always @(posedge clk or negedge rst_n) //每50us读取一次数据，ad的采样率为20K
    begin
        if(rst_n == 0)
            cnt50us <= 0;
        else begin 
            if(cnt50us < 16'd2499)
                begin
                    cnt50us <= cnt50us + 1;
                end
            else
                cnt50us <= 0;
            end
    end
always @(posedge clk) 
 begin
     if (ad_reset==1'b1) begin   //初始化ad
             state<=IDLE; 
             ad_ch1<=0;
             ad_ch2<=0;
             ad_ch3<=0;
             ad_ch4<=0;
             ad_ch5<=0;
             ad_ch6<=0;
             ad_ch7<=0;
             ad_ch8<=0;
             ad_cs<=1'b1;
             ad_rd<=1'b1; 
             ad_convstab<=1'b1;   //8通道同步采样
             i<=0;
     end         
     else begin
          case(state)     //need time:(20+2+5+1+3*8+1)*20ns=1060ns, fmax=1/1060ns=1MHZ
          IDLE: begin
                 ad_cs<=1'b1;
                 ad_rd<=1'b1; 
                 ad_convstab<=1'b1; 
                 if(i==20) begin        //延时20个时钟后开始转换
                     i<=0;           
                     state<=AD_CONV;
                 end
                 else 
                     i<=i+1'b1;
          end
          AD_CONV: begin       
                 if(i==2) begin                        //等待2个lock，convstab的下降沿最少为25ns，故至少需要两个时钟
                     i<=0;           
                     state<=Wait_1;
                     ad_convstab<=1'b1;                      
                 end
                 else begin
                     i<=i+1'b1;
                     ad_convstab<=1'b0;                     //启动AD转换
                 end
          end
          Wait_1: begin            
                 if(i==5) begin                           //等待5个clock, 等待busy信号为高(tconv)
                     i<=0;
                     state<=Wait_busy;
                 end
                 else 
                     i<=i+1'b1;
          end        
          Wait_busy: begin            
                 if(ad_busy==1'b0) begin                    //等待busy为低电平  即转换之后读取模式
                     i<=0;           
                     state<=READ_CH1;
                 end
          end
          READ_CH1: begin 
                 ad_cs<=1'b0;                              //cs信号有效  直到读取8通道结束
                 if(i==3) begin                            // 低电平持续3个时钟，完成通道1的读入
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch1<=ad_data;                        //读CH1
                     state<=READ_CH2;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH2: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch2<=ad_data;                        //读CH2
                     state<=READ_CH3;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH3: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch3<=ad_data;                        //读CH3
                     state<=READ_CH4;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH4: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch4<=ad_data;                        //读CH4
                     state<=READ_CH5;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH5: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch5<=ad_data;                        //读CH5
                     state<=READ_CH6;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH6: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch6<=ad_data;                        //读CH6
                     state<=READ_CH7;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH7: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch7<=ad_data;                        //读CH7
                     state<=READ_CH8;                
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_CH8: begin 
                 if(i==3) begin
                     ad_rd<=1'b1;
                     i<=0;
                     ad_ch8<=ad_data;                        //读CH8
                     state<=READ_DONE;               
                 end
                 else begin
                     ad_rd<=1'b0;   
                     i<=i+1'b1;
                 end
          end
          READ_DONE:begin                                 //完成读，回到idle状态
                     ad_rd<=1'b1;    
                     ad_cs<=1'b1;
                     if(cnt50us == 16'd2499)                      //不加此条件，则ad完成一次读取需1280ns，采样频率781.25K，但需注意ad每通道的追高采样只能为200K
                        state<=IDLE;
                    else
                        state<=READ_DONE;
          end       
          default:  state<=IDLE;
          endcase   
    end   
 
 end
 
endmodule

uart_test代码如下：



module uart_test(
    input                        sys_clk,       //system clock 50Mhz on board
    input                        rst_n,        //reset ,low active
	input                       [15:0] data1,
	input                       [15:0] data2,
	input                       [15:0] data3,
	input                       [15:0] data4,
	input                       [15:0] data5,
	input                       [15:0] data6,
	input                       [15:0] data7,
	input                       [15:0] data8,
	output                       uart_tx
);

parameter                      CLK_FRE = 50;//Mhz
localparam                       IDLE =  0;
localparam                       SEND =  1;   //send HELLO ALINX\r\n
localparam                       WAIT =  2;   //wait 1 second and send uart received data
reg[7:0]                         tx_data;
reg[7:0]                         tx_str;
reg                              tx_data_valid;
wire                             tx_data_ready;
reg[7:0]                         tx_cnt;

reg[31:0]                        wait_cnt;
reg[3:0]                         state;



always@(posedge sys_clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
	begin
		wait_cnt <= 32'd0;
		tx_data <= 8'd0;
		state <= IDLE;
		tx_cnt <= 8'd0;
		tx_data_valid <= 1'b0;
	end
	else
	case(state)
		IDLE:
			state <= SEND;
		SEND:
		begin
			wait_cnt <= 32'd0;
			tx_data <= tx_str;

			if(tx_data_valid == 1'b1 && tx_data_ready == 1'b1 && tx_cnt < 8'd23)//Send 12 bytes data
			begin
				tx_cnt <= tx_cnt + 8'd1; //Send data counter
			end
			else if(tx_data_valid && tx_data_ready)//last byte sent is complete
			begin
				tx_cnt <= 8'd0;
				tx_data_valid <= 1'b0;
				state <= WAIT;
			end
			else if(~tx_data_valid)
			begin
				tx_data_valid <= 1'b1;
			end
		end
		WAIT:
		begin
			wait_cnt <= wait_cnt + 32'd1;

     if(tx_data_valid && tx_data_ready)
			begin
				tx_data_valid <= 1'b0;
			end
			else if(wait_cnt >= CLK_FRE * 1000000) // wait for 1 second
				state <= SEND;
		end
		default:
			state <= IDLE;
	endcase
end

//combinational logic
//Send "HELLO ALINX\r\n"
always@(*)
begin
	case(tx_cnt)
	    8'd0 :  tx_str <= "C1";
		8'd1 :  tx_str <= data1[15:8];
		8'd2 :  tx_str <= data1[7:0];
		8'd3:   tx_str <= "C2";
		8'd4 :  tx_str <= data2[15:8];
		8'd5 :  tx_str <= data2[7:0]; 
		8'd6:   tx_str <= "C3";
		8'd7 :  tx_str <= data3[15:8]; 
		8'd8 :  tx_str <= data3[7:0]; 
		8'd9:   tx_str <= "C4";
		8'd10 :  tx_str <= data4[15:8]; 
		8'd11 :  tx_str <= data4[7:0]; 
		8'd12:   tx_str <= "C5";	
		8'd13 :  tx_str <= data5[15:8]; 
		8'd14 :  tx_str <= data5[7:0]; 
		8'd15:   tx_str <= "C6";
		8'd16 :  tx_str <= data6[15:8]; 
		8'd17 :  tx_str <= data6[7:0]; 
		8'd18:   tx_str <= "C7";
		8'd19 :  tx_str <= data7[15:8]; 
		8'd20 :  tx_str <= data7[7:0]; 
		8'd21:   tx_str <= "C8";
		8'd22 :  tx_str <= data8[15:8]; 
		8'd23 :  tx_str <= data8[7:0]; 
		default:tx_str <= 8'd0;
	endcase
end



uart_tx#
(
	.CLK_FRE(CLK_FRE),
	.BAUD_RATE(115200)
) uart_tx_inst
(
	.clk                        (sys_clk                  ),
	.rst_n                      (rst_n                    ),
	.tx_data                    (tx_data                  ),
	.tx_data_valid              (tx_data_valid            ),
	.tx_data_ready              (tx_data_ready            ),
	.tx_pin                     (uart_tx                  )
);
endmodule

uart_test同样包含一个子模块，如下：


module uart_tx
#(
	parameter CLK_FRE = 50,      //clock frequency(Mhz)
	parameter BAUD_RATE = 115200 //serial baud rate
)
(
	input                        clk,              //clock input
	input                        rst_n,            //asynchronous reset input, low active 
	input[7:0]                   tx_data,          //data to send
	input                        tx_data_valid,    //data to be sent is valid
	output reg                   tx_data_ready,    //send ready
	output                       tx_pin            //serial data output
);
//calculates the clock cycle for baud rate 
localparam                       CYCLE = CLK_FRE * 1000000 / BAUD_RATE;
//state machine code
localparam                       S_IDLE       = 1;
localparam                       S_START      = 2;//start bit
localparam                       S_SEND_BYTE  = 3;//data bits
localparam                       S_STOP       = 4;//stop bit
reg[2:0]                         state;
reg[2:0]                         next_state;
reg[15:0]                        cycle_cnt; //baud counter
reg[2:0]                         bit_cnt;//bit counter
reg[7:0]                         tx_data_latch; //latch data to send
reg                              tx_reg; //serial data output
assign tx_pin = tx_reg;
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		state <= S_IDLE;
	else
		state <= next_state;
end

always@(*)
begin
	case(state)
		S_IDLE:
			if(tx_data_valid == 1'b1)
				next_state <= S_START;
			else
				next_state <= S_IDLE;
		S_START:
			if(cycle_cnt == CYCLE - 1)
				next_state <= S_SEND_BYTE;
			else
				next_state <= S_START;
		S_SEND_BYTE:
			if(cycle_cnt == CYCLE - 1  && bit_cnt == 3'd7)
				next_state <= S_STOP;
			else
				next_state <= S_SEND_BYTE;
		S_STOP:
			if(cycle_cnt == CYCLE - 1)
				next_state <= S_IDLE;
			else
				next_state <= S_STOP;
		default:
			next_state <= S_IDLE;
	endcase
end
always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			tx_data_ready <= 1'b0;
		end
	else if(state == S_IDLE)
		if(tx_data_valid == 1'b1)
			tx_data_ready <= 1'b0;
		else
			tx_data_ready <= 1'b1;
	else if(state == S_STOP && cycle_cnt == CYCLE - 1)
			tx_data_ready <= 1'b1;
end


always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			tx_data_latch <= 8'd0;
		end
	else if(state == S_IDLE && tx_data_valid == 1'b1)
			tx_data_latch <= tx_data;
		
end

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		begin
			bit_cnt <= 3'd0;
		end
	else if(state == S_SEND_BYTE)
		if(cycle_cnt == CYCLE - 1)
			bit_cnt <= bit_cnt + 3'd1;
		else
			bit_cnt <= bit_cnt;
	else
		bit_cnt <= 3'd0;
end


always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		cycle_cnt <= 16'd0;
	else if((state == S_SEND_BYTE && cycle_cnt == CYCLE - 1) || next_state != state)
		cycle_cnt <= 16'd0;
	else
		cycle_cnt <= cycle_cnt + 16'd1;	
end

always@(posedge clk or negedge rst_n)
begin
	if(rst_n == 1'b0)
		tx_reg <= 1'b1;
	else
		case(state)
			S_IDLE,S_STOP:
				tx_reg <= 1'b1; 
			S_START:
				tx_reg <= 1'b0; 
			S_SEND_BYTE:
				tx_reg <= tx_data_latch[bit_cnt];
			default:
				tx_reg <= 1'b1; 
		endcase
end

endmodule

引脚约束如下：由于实现过程中，Vivado 报错：[Place 30-574] Poor placement for routing between an IO pin and BUFG.，将其报错语句中给的修改推荐复制到约束文件里即可。使用.xdc文件中的CLOCK_DEDICATED_ROUTE约束将此消息降级为警告。
语句为：set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets clk_IBUF]

set_property CLOCK_DEDICATED_ROUTE FALSE [get_nets clk_IBUF]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[15]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[14]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[13]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[12]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[11]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[10]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[9]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[8]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[6]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[5]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[4]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_data[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_os[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_os[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {ad_os[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports ad_busy]
set_property IOSTANDARD LVCMOS33 [get_ports ad_cs]
set_property IOSTANDARD LVCMOS33 [get_ports ad_convstab]
set_property IOSTANDARD LVCMOS33 [get_ports ad_rd]
set_property IOSTANDARD LVCMOS33 [get_ports ad_reset]
set_property IOSTANDARD LVCMOS33 [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports first_data]
set_property IOSTANDARD LVCMOS33 [get_ports rst_n]
set_property IOSTANDARD LVCMOS33 [get_ports sys_clk]
set_property IOSTANDARD LVCMOS33 [get_ports uart_tx]
set_property PACKAGE_PIN N17 [get_ports {ad_data[15]}]
set_property PACKAGE_PIN P18 [get_ports {ad_data[14]}]
set_property PACKAGE_PIN R16 [get_ports {ad_data[13]}]
set_property PACKAGE_PIN R17 [get_ports {ad_data[12]}]
set_property PACKAGE_PIN T16 [get_ports {ad_data[11]}]
set_property PACKAGE_PIN U17 [get_ports {ad_data[10]}]
set_property PACKAGE_PIN W18 [get_ports {ad_data[9]}]
set_property PACKAGE_PIN W19 [get_ports {ad_data[8]}]
set_property PACKAGE_PIN Y18 [get_ports {ad_data[7]}]
set_property PACKAGE_PIN Y19 [get_ports {ad_data[6]}]
set_property PACKAGE_PIN Y16 [get_ports {ad_data[5]}]
set_property PACKAGE_PIN Y17 [get_ports {ad_data[4]}]
set_property PACKAGE_PIN V17 [get_ports {ad_data[3]}]
set_property PACKAGE_PIN V18 [get_ports {ad_data[2]}]
set_property PACKAGE_PIN W14 [get_ports {ad_data[1]}]
set_property PACKAGE_PIN Y14 [get_ports {ad_data[0]}]
set_property PACKAGE_PIN V16 [get_ports {ad_os[2]}]
set_property PACKAGE_PIN W16 [get_ports {ad_os[1]}]
set_property PACKAGE_PIN T17 [get_ports {ad_os[0]}]
set_property PACKAGE_PIN R18 [get_ports ad_busy]
set_property PACKAGE_PIN V12 [get_ports ad_convstab]
set_property PACKAGE_PIN W13 [get_ports ad_cs]
set_property PACKAGE_PIN T14 [get_ports ad_rd]
set_property PACKAGE_PIN T15 [get_ports ad_reset]
set_property PACKAGE_PIN T11 [get_ports clk]
set_property PACKAGE_PIN T10 [get_ports first_data]
set_property PACKAGE_PIN P16 [get_ports rst_n]
set_property PACKAGE_PIN N18 [get_ports sys_clk]
set_property PACKAGE_PIN P14 [get_ports uart_tx]

至此，所有代码完毕。开始生成比特流文件，接好线，烧录程序
在这里插入图片描述
打开串口，设置波特率115200.接收数据
在这里插入图片描述
采集到数据为31 XX XX 32 XX XX 33 XX XX 34 XX XX 35 XX XX 36 XX XX 37 XX XX 38 XX XX.
其中31，32…38均为通道号，通道号后面为采集到的电压数据。本次实验中，只有CH1通道接了3.3V，其他通道号均悬空，悬空时电压为2.0V左右。
取CH1通道的一组31 29 26 ，数据为29 36，用计算器转化成10进制10550.
在这里插入图片描述
我这个ad7606的J2盖帽连接在10V处，其原理图显示为Range=1.
在这里插入图片描述
故而计算公式选择如下红框处，VIN=CODE×10/32768
把10550代入，VIN=10550×10/32768=3.219V 与我实际给的电压差不多，和万用表实测电压一致。
在这里插入图片描述

在这里插入图片描述
看其他CH2~CH8，取其中一个CH2 的数据1A 7B。同样接着计算，
在这里插入图片描述
在这里插入图片描述
结果为2V，与通道号悬空时候实测电压一致。至此程序的编写没问题。

链接：https://pan.baidu.com/s/1mylaGHqWAYowPT-4RKgumg
提取码：8sv4
–来自百度网盘超级会员V5的分享

冠头咸鱼
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
深度解析与优化：使用STM32F103读取AD7606并行数据
qq_38334677的博客
06-02 250
AD7606是一款16位的模数转换器，具有8个同步采样通道，能够以200 kSPS的速率进行数据采样。它支持并行和串行两种数据接口，本文将重点介绍并行接口的使用。
AD7606+Verilog+FPGA+vivado+串口通信 并行
07-14
用vivado软件编写的AD7606模块的驱动，串口通信，用串口调试助手观察八个通道数据。
FPGA采集AD7606全网最细讲解 提供串行和并行2套工程源码和技术支持
热门推荐
qq_41667729的博客
03-01 1万+
AD7606是一款非常受欢迎的AD芯片，因为他支持8通道同时采集数据，采样深度16位，已经很不错了，虽然采样率只有200 kSPS，但对电压等低速数据源的采集而言已经完全足够了，该芯片在电压检测等项目中有着广泛应用。 本文详细描述了设计方案，工程代码编译通过后上板调试验证，可直接项目移植，适用于在校学生、研究生项目开发，也适用于在职工程师做项目开发，可应用于AD数据采集领域
FPGA采集AD7606数据UDP网络传输 提供工程源码和技术支持 附带上位机接收软件
qq_41667729的博客
04-11 3739
FPGA采集AD7606数据UDP网络传输 提供工程源码和技术支持 附带上位机接收软件 本设计使用UDP传输FPGA采集的AD7606数据，上位机通过接收网口的 UDP 数据包，将AD7606的波形数据数据显示在电脑上。我们可以用更加直观的方式观察波形，是一个数字示波器雏形，并且可以保存 ADC 数据。
【国产虚拟仪器】基于 ZYNQ 的电能质量系统高速数据采集系统设计
YEYUANGEN的专栏
05-20 1563
设计网格叠加函数和波形叠加函数对画布缓存区的数据进行实时读取。，经过模拟多路复器输入转换电路完成模拟信号到数。在画布中取长方形区间作显示波形的幅值和传播时间。可以通过修改波形起始位置参数改变波形区域的大小。模式相对简单模式有着更高效的数据传输特性。任意函数发生器提供所需的信号进行实验。通过对串口终端打印出来的数据进行分析。通过对比现有高速采集系统的设计方案。充分满足了系统设计的实时性和高精度。需要在内存中开辟缓存空间和链表制作。分析得出实验结果和原始信号波形相同。模式加快了系统的数据传输和处理速度。
ad7606驱动及仿真_quartus_verilog_ad7606驱动及仿真_AD7606_
10-02
标题“ad7606驱动及仿真_quartus_verilog_ad7606驱动及仿真_AD7606_”所提及的核心技术点是关于AD7606模拟到数字转换器（ADC）的驱动程序设计以及在Quartus和Vivado这两个不同的FPGA开发平台上的仿真应用。...
FPGA+DSP的高速AD采集处理开发详解-综合文档
05-19
4. **FPGA与DSP通信**：讨论两者之间的数据传输方式，如并行接口、串行接口（如AXI4）、DMA（Direct Memory Access）等，以及如何优化通信带宽和时序。 5. **系统集成与调试**：介绍如何将FPGA和DSP模块集成到一个...
rtl.rar_AD7606_Xilinx_volt realization_xilinx 数据
09-23
3. **数据传输**：转换后的数据通过SPI（串行外设接口）或并行方式从AD7606传输到FPGA。对于并行接口，需要设计适当的同步逻辑，确保数据正确无误地接收。 4. **数据处理**：在FPGA内部，采集到的数据可能需要...
97-AD7609接口设计（串行模式）.7z
04-29
《AD7609串行接口设计在FPGA中的实现及Verilog HDL与Vivado的应用》 在数字信号处理领域，高速、高精度的模数转换器(ADC)如AD7609在各种应用中扮演着关键角色。AD7609是一款8位、125ksps的逐次逼近型ADC，具有良好...
FPGA实验5：4位加法计数器
lengmei1的博客
07-20 344
运用Quartus II 集成环境下的VHDL文本设计方法设计4位加法计数器，进行波形仿真和分析、引脚分配并下载到实验设备上进行功能测试。实验步骤和方法参考实验一，引脚分配可参考下表。
Artix7系列FPGA实现SDI视频编解码+UDP以太网传输，基于GTP高速接口，提供工程源码和技术支持
qq_41667729的博客
07-18 924
Artix7系列FPGA实现SDI视频编解码+UDP以太网传输，基于GTP高速接口，提供工程源码和技术支持
锁相环 vivado FPGA
bwhaxx的博客
07-21 217
原理 同步状态/跟踪状态：相位差在2kπ附近，频率差为0 到达上述状态的过程称为捕获过程 锁相环的捕获带：delta w的最大值，大于这个值的话就不能捕获 鉴相器（PD-phase discriminator）：相乘加LPF，相差提取到电压函数sin的相位中 LP:对PD产生的电压函数进行变换 VCO：将电压信息转移到瞬时频率上，与电压是一次函数关系（但是输入电压范围有限，才保持线性） VCO反馈给PD：PD要的是相位，也就是瞬时频率的积分。最终VCO反馈的是LP输出电压的积分，也就是输入相差的积分。（P
ZYNQ 入门笔记（零）：概述
最新发布
记录代码与生活
07-21 591
作为 AMD Xilinx SoC 的重要组成部分之一，Zynq 系列在视频编码、网络加速、射频信号处理等领域占据重要地位，其将 ARM 硬核 (PS) 与可编程逻辑 (PL) 集成在一块芯片内部，在提升系统整体性能的同时简化了设计流程。然而，初次接触 Zynq 的开发者可能会面临诸多困难，如工具链、开发流程、Block Design、AXI 总线、PS & PL 交互、联合调试等。笔者在此将学习过程中的笔记加以整理，希望能帮助大家快速入门 Zynq，体会软硬件联合开发的乐趣
[米联客-安路飞龙DR1-FPSOC] FPGA基础篇连载-18 I2C MASTER控制器驱动设计
米联客(milianke)
07-17 823
本文讨论了I2C Master控制器的系统框图和关键信号，包括I2C操作请求、总线忙指示、时钟分频器、发送和接收移位模块等。通过SCL时钟和I2C状态机控制SCL和SDA的输出逻辑和时序。文章还介绍了状态机设计和总线错误指示模块。总的来说，文章主要涵盖了I2C通信协议的工作原理和关键部件的功能。
嵌入式硬件-Xilinx FPGA DDR4 接口配置基础（PG150）
hi94的博客
07-17 1030
内存控制器（MC）旨在从用户界面（UI）块接收读取、写入和读取-修改-写入事务，并以低延迟高效地将它们发送到内存，满足所有DRAM协议和时序要求，同时使用最少的FPGA资源。该控制器还允许通过UI控制信号对低级功能进行一定程度的控制，例如按事务基础上的自动预充电（AutoPrecharge），以及可以用于确定何时发出DRAM刷新命令的信号。指的是数据总线在传输数据时的效率。最高支持 32 GB的组件密度，64 GB的LRDIMM，128 GB的RDIMM，16 GB的SODIMM和16 GB的UDIMM。
太速科技-基于XCVU9P+ C6678的8T8R的无线MIMO平台
Orihard_的博客
07-17 561
板卡基于TI TMS320C6678 DSP和XCVU9P高性能FPGA，FPGA接入4片AD9361 无线射频，构建8输入8输出的无线MIMO平台，丰富的FPGA资源和8核DSP为算法验证和信号处理提供强大能力。● DSP 外挂一组64-bit DDR3颗粒，总容量1GB，数据速率1333Mb/s;● DSP部分SPI/IIC/GPIO接口测试代码；● 工作温度：商业级 0℃～+55℃，工业级-40℃～+85℃；● XCVU9P部分QSFP+测试代码；● DSP部分Flash加载测试代码；
39.简易频率计（基于等精度测量法）（2）
2301_80417284的博客
07-17 399
39.简易频率计（基于等精度测量法）（2） 计算核心模块
【VERILOG】输入脉冲下降沿触发输出一组双脉冲 （附带testbench）
hcoolabc的博客
07-18 821
【代码】【VERILOG】输入脉冲，下降沿后输出一组双脉冲，附带t estbench。
fpga+ad7606并行8通道采集源verilog程序
12-22
FPGA AD7606并行8通道采集源Verilog程序是用Verilog语言编写的程序，用于控制FPGA芯片与AD7606模数转换器之间的数据采集传输。AD7606是一款8通道的模数转换器，用于将模拟信号转换成数字信号，而FPGA则是一款可编程逻辑器件，用于实现数字信号的处理和控制。通过编写Verilog程序，可以实现FPGA对AD7606进行控制和数据采集。 在编写这个程序时，需要考虑AD7606的8个通道数据的并行采集，即同时采集8个通道的数据。Verilog程序需要包括对AD7606的初始化配置、时序控制、数据获取和存储等功能。通过编写合适的Verilog代码，可以确保FPGA能够有效地控制AD7606，实现数据采集的功能。 在程序编写完成后，需要进行仿真和验证，确保程序能够正确地与AD7606通信并进行数据采集。同时还需要考虑程序的可扩展性和稳定性，以应对不同情况下的数据采集需求。 总之，FPGA AD7606并行8通道采集源Verilog程序是一个用于实现FPGA与AD7606之间数据采集的关键程序，在实际工程中需要仔细设计和验证，以确保其能够正常、稳定地运行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值