FPGA&ASIC(共54篇)
找到
54
篇与
FPGA&ASIC
相关的结果
-
【硬件算法进阶】Verilog实现802.3 CRC-32校验运算电路 循环冗余校验（Cyclic Redundancy Check，CRC）是通信中常用的差错检测编码方式，其基本工作原理是根据输入的信息位（信息码元），按照给定的生成多项式产生校验位（校验码元），并一起传送到接收端。在接收端，接收电路按照相同的规则对接收数据进行计算并生成本地的校验位，然后与收到的校验位进行对比，如果二者不同，则说明传输过程中发生了错误，否则说明传输是正确的。带有CRC校验结果的数据帧结构如表1-2所示。CRC检验位生成与检测工作包括以下基本步骤。图1-6是一个并行CRC-32校验运算电路。图中的d［7：0］是输入的用户数据，它是按照字节的方式输入的。load_ini是在对一个新的数据包开始校验计算之前对电路进行初始化的控制信号，经过初始化后，电路内部32比特寄存器的值改变为全1。calc是电路运算指示信号，在整个数据帧输入和CRC校验结果输出的过程中其都应该保持有效（高电平有效）。d_valid为1时表示当前输入的是需要进行校验运算的有效数据。crc［7：0］是电路输出的CRC校验运算结果，它是按照字节方式，在有效数据输入完成后开始输出的，一共有4个有效字节。crc_reg［31：0］是内部寄存器的值，具体使用时不需要该输出。并行计算的思想，输入数据S要并行输入到G(x)系数为1的支路中，输入数据从输入端按高到低逐bit输入，就可以实现。假如被除数是2位的数据S[1:0]=01，多项式是10011，x4 +x+1。在CRC校验里面，习惯省略最高位的1，多项式用0011表示。那么S除以0011的模二运算数字电路结构为：其中d1~ d4是寄存器输入；q1~q4是寄存器输出。寄存器需要赋初值，一般赋全1或全0。d1=S[1]^q4;d2= S[1]^ q1^q4;d3=q2;d4=q3。经过一次移位后：q1=d1= S[1]^q4;q2= d2= S[1]^ q1^q4;q3= d3=q2;q4= d4=q3。此时有：d1=S[0]^q3;d2= S[0]^ S[1]^ q4^q3;d3= S[1]^ q1^q4;d4= q2。令c[3:0]=，d[3:0]=，那么d就是最终的运算结果表达式，如下d[3]=c[1];d[2]= S[1]^ c[0]^c[3];d[1]= S[0]^ S[1]^ c[3]^ c[2];d[0]= S[0]^ c[2]。令c的初值为0，则01对0011的模二除法的余数为0011。再比如多项式为x5 +x3 +x+1，简记式为01011，其数字电路结构为：输入数据S要全部输入完，寄存器得到的结果才是最后的结果。同理可推导出其他多项式和输入数据的情况。对于循环检验，这里举个例子，如果数据是10bit*100个包，则每次输入10bit得到校验码后，该检验码为下次数据计算时寄存器D的初值，如此反复计算得到最后的检验码添加到整个数据后面即可，而不需要每个数据包后面都添加检验码。下面是以太网循环冗余校验电路的设计代码：module crc32_8023( clk, reset, d, load_init, calc, d_valid, crc_reg, crc ); input clk; input reset; input [7:0] d; input load_init; input calc; input d_valid; output reg [31:0] crc_reg; output reg [7:0] crc; wire [2:0] ctl; wire [31:0] next_crc; wire [31:0] i; assign i = crc_reg; assign ctl = ; always @(posedge clk or posedge reset) begin if(reset) crc_reg <= 32'hffffffff; else begin case (ctl) // 3'b000,3'b010: begin crc_reg <= crc_reg; crc <= crc;end 3'b001: begin crc_reg <= ; crc <= ~; //crc <= ~ crc_reg[16:23]; end 3'b011: begin crc_reg <= next_crc[31:0]; crc <= ~; //crc <= ~ next_crc[24:31]; end 3'b100,3'b110: begin crc_reg <= 32'hffffffff; crc <= crc; end 3'b101: begin crc_reg <= 32'hffffffff; crc <= ~; //crc <= ~ crc_reg[16:23]; end 3'b111: begin crc_reg <= 32'hffffffff; crc <= ~; //crc <= ~ next_crc[24:31]; end endcase end end assign next_crc[0] = d[7]^i[24]^d[1]^i[30]; //d+i=31 assign next_crc[1] = d[6]^d[0]^d[7]^d[1]^i[24]^i[25]^i[30]^i[31]; assign next_crc[2] = d[5]^d[6]^d[0]^d[7]^d[1]^i[24]^i[25]^i[26]^i[30]^i[31]; assign next_crc[3] = d[4]^d[5]^d[6]^d[0]^i[25]^i[26]^i[27]^i[31]; assign next_crc[4] = d[3]^d[4]^d[5]^d[7]^d[1]^i[24]^i[26]^i[27]^i[28]^i[30]; assign next_crc[5] = d[0]^d[1]^d[2]^d[3]^d[4]^d[6]^d[7]^i[24]^i[25]^i[27]^i[28]^i[29]^i[30]^i[31]; assign next_crc[6] = d[0]^d[1]^d[2]^d[3]^d[5]^d[6]^i[25]^i[26]^i[28]^i[29]^i[30]^i[31]; assign next_crc[7] = d[0]^d[2]^d[4]^d[5]^d[7]^i[24]^i[26]^i[27]^i[29]^i[31]; assign next_crc[8] = d[3]^d[4]^d[6]^d[7]^i[24]^i[25]^i[27]^i[28]^i[0]; //每项多出i[i],i=0、1、2...23 assign next_crc[9] = d[2]^d[3]^d[5]^d[6]^i[1]^i[25]^i[26]^i[28]^i[29]; assign next_crc[10] =d[2]^d[4]^d[5]^d[7]^i[2]^i[24]^i[26]^ i[27]^i[29]; assign next_crc[11] =i[3]^d[3]^i[28]^d[4]^i[27]^d[6]^i[25]^d[7]^i[24]; assign next_crc[12] =d[1]^d[2]^d[3]^d[5]^d[6]^d[7]^i[4]^i[24]^i[25]^i[26]^i[28]^i[29]^i[30]; assign next_crc[13] =d[0]^d[1]^d[2]^d[4]^d[5]^d[6]^i[5]^i[25]^i[26]^i[27]^i[29]^i[30]^i[31]; assign next_crc[14] =d[0]^d[1]^d[3]^d[4]^d[5]^i[6]^i[26]^i[27]^i[28]^i[30]^i[31]; assign next_crc[15] =d[0]^d[2]^d[3]^d[4]^i[7]^i[27]^i[28]^i[29]^i[31]; assign next_crc[16] =d[2]^d[3]^d[7]^i[8]^i[24]^i[28]^i[29]; assign next_crc[17] =d[1]^d[2]^d[6]^i[9]^i[25]^i[29]^i[30]; assign next_crc[18] =d[0]^d[1]^d[5]^i[10]^i[26]^i[30]^i[31]; assign next_crc[19] =d[0]^d[4]^i[11]^i[27]^i[31]; assign next_crc[20] =d[3]^i[12]^i[28]; assign next_crc[21] =d[2]^i[13]^i[29]; assign next_crc[22] =d[7]^i[14]^i[24]; assign next_crc[23] =d[1]^d[6]^d[7]^i[15]^i[24]^i[25]^i[30]; assign next_crc[24] =d[0]^d[5]^d[6]^i[16]^i[25]^i[26]^i[31]; assign next_crc[25] =d[4]^d[5]^i[17]^i[26]^i[27]; assign next_crc[26] =d[1]^d[3]^d[4]^d[7]^i[18]^i[28]^i[27]^i[24]^i[30]; assign next_crc[27] =d[0]^d[2]^d[3]^d[6]^i[19]^i[29]^i[28]^i[25]^i[31]; assign next_crc[28] =d[1]^d[2]^d[5]^i[20]^i[30]^i[29]^i[26]; assign next_crc[29] =d[0]^d[1]^d[4]^i[21]^i[31]^i[30]^i[27]; assign next_crc[30] =d[0]^d[3]^i[22]^i[31]^i[28]; assign next_crc[31] =d[2]^i[23]^i[29]; endmodule测试代码`timescale 1ns/1ns module crc_test(); reg clk, reset; reg [7:0] d; reg load_init; reg calc; reg data_valid; wire [31:0] crc_reg; wire [7:0] crc; initial begin clk=0; reset=0; load_init=0; calc=0; data_valid=0; d=0; end always begin #10 clk=1; #10 clk=0; end always begin crc_reset; crc_cal; end task crc_reset; begin reset=1; repeat(2)@(posedge clk); #5; reset=0; repeat(2)@(posedge clk); end endtask task crc_cal; begin repeat(5) @ (posedge clk); //通过losd_init=1 对CRC计算电路进行初始化 #5; load_init= 1; repeat(1)@ (posedge clk); //设置1oad_init=0,data_valid= 1,calc=1 //开始对输人数据进行CRC校验运算 #5; load_init= 0; data_valid=1; calc=1; d=8'haa; repeat(1)@ (posedge clk); #5; data_valid=1; calc=1; d=8'hbb; repeat(1)@ (posedge clk); #5; data_valid=1; calc=1; d=8'hcc; repeat(1)@ (posedge clk); #5; data_valid=1; calc=1; d=8'hdd; repeat(1)@ (posedge clk); //设置load_init=0,data_valid=1,calc=0 //停止对数据进行CRC校验运算,开始输出 //计算结果 #5; data_valid=1; calc=0; d=8'haa; repeat(1)@ (posedge clk); #5; data_valid=1; calc=0; d=8'hbb; repeat(1)@ (posedge clk); #5; data_valid=1; calc=0; d=8'hee; repeat(1)@ (posedge clk); #5; data_valid=1; calc=0; d=8'hdd; repeat(1)@ (posedge clk); #5; data_valid=0; repeat(10)@ (posedge clk); end endtask crc32_8023 my_crc_test(.clk(clk),.reset(reset),.d(d),.load_init(load_init),.calc(calc),.d_valid(data_valid),.crc_reg(crc_reg),.crc(crc)); endmodule图1-7是电路的仿真结果。图中①是电路进行CRC校验计算之前对电路进行初始化操作的过程，经过初始化之后，crc_reg内部数值为全1。②是对输入数据aa-> bb-> cc-> dd进行运算操作的过程，此时calc和data_valid均为1。③是输出计算结果的过程，CRC校验运算结果a7、01、b4和55先后被输出。在接收方向上，可以采用相同的电路进行校验检查，判断是否在传输过程中发生了差错。具体工作时，可以边接收用户数据边进行校验运算，当一个完整的MAC帧接收完成后（此时接收数据帧中的校验结果也参加了校验运算），如果当前校验电路的crc_reg值为0xC704DD7B（对于以太网中使用的CRC-32校验，无论原始数据是什么，正确接收时校验和都是此固定数值），说明没有发生错误，否则说明MAC帧有错。CRC-32校验值的作用是用于检测数据传输或存储中的错误。发送数据时，会根据数据内容生成简短的校验和，并将其与数据一起发送。接收数据时，将再次生成校验和并将其与发送的校验和进行比较。如果两者相等，则没有数据损坏。如果两者不相等，则说明数据在传输或存储过程中发生了改变，可能是由于噪声、干扰、故障或恶意篡改等原因造成的。CRC-32校验值可以有效地检测出数据中的随机错误，但是不能保证检测出所有的错误。例如，如果数据中有偶数个比特发生了翻转，那么CRC-32校验值可能不会改变，从而无法发现错误。因此，CRC-32校验值只能作为一种辅助的错误检测手段，不能完全依赖它来保证数据的正确性和完整性。相关工具如果不理解推导过程的话，可以由相关工具帮忙计算出结果和得到Verilog代码：CRC校验Verilog代码生成链接：http://outputlogic.com/?page_id=321CRC校验计算工具链接：http://www.ip33.com/crc.html，这个工具只能计算16bit为一个数据包的数据，如果数据包为10bit等之类的就不太适用在线计算器使用举例报文 ： 1011001 (0x59)生成多项式 ： g(x) = x^4 + x^3 + 1CRC : 1010 ( 0xa)CRC计算结果截图：参考文献Verilog HDL算法与电路设计-乔庐峰
-
【IC/CPU设计】极简的RISC_CPU设计 CPU为SOC系统的核心环节，该项目来自于夏宇闻老师的经典教材——《Verilog 数字系统设计教程》，通过此练习方便数字ICer更好的入门本次项目实践环境：前仿： Modelsim综合： Design CompileCPU简介CPU（Central Processing Unit），中文全称中央处理器，作为四大U之首(CPU/GPU/TPU/NPU），是计算机系统的运算和控制核心，也是当今数字系统中不可或缺的组成部分。CPU自诞生到如今发展超过50年，借助冯诺依曼体系，CPU掀起一股又一股的科技浪潮。RISC作为精简了指令集的CPU，除了指令更加简洁，还拥有简单合理的内部结构，从而提高了运算速度。CPU工作的5个阶段：（1）取指（IF，Instruction Fetch），将指令从存储器取出到指令寄存器。每取一条指令，程序计数器自加一。（2）译指（ID，Instruction Decode)，对取出的指令按照规定格式进行拆分和译码。（3）执行（EX，Execute），执行具体指令操作。（4）访问存储（MEM，Memory），根据指令访问存储、完成存储和读取。（5）写回（WB，Write Back），将计算结果写回到存储器。CPU内部关键结构：（1）算术逻辑运算器（ALU）；（2）累加器；（3）程序计数器；（4）指令寄存器和译码器；（5）时序和控制部件。RISC_CPU内部结构和Verilog实现本项目中的RISC_CPU一共有9个模块组成，具体如下：（1）时钟发生器；（2）指令寄存器；（3）累加器；（4）算术逻辑运算单元；（5）数据控制器；（6）状态控制器；（7）主状态机；（8）程序计数器；（9）地址多路器。整体结构时钟发生器模块图：端口描述：reset是高电平复位信号；clk是外部时钟信号；fetch是控制信号，是clk的八分频信号；fetch为高电平时，触发执行指令以及地址多路器输出指令地址和数据地址。alu_ena是算术逻辑运算单元的使能信号。可以看到alu_ena提前fetch高电平一个clk周期，fetch是clk的8分频信号。Verilog代码：// Description: RISC——CPU 时钟发生器 // ----------------------------------------------------------------------------- module clk_gen ( input clk , // Clock input reset , // High level reset output reg fetch , // 8 frequency division output reg alu_ena // Arithmetic enable ); reg [7:0] state; //One-piece state machine parameter S1 = 8'b0000_0001, S2 = 8'b0000_0010, S3 = 8'b0000_0100, S4 = 8'b0000_1000, S5 = 8'b0001_0000, S6 = 8'b0010_0000, S7 = 8'b0100_0000, S8 = 8'b1000_0000, idle = 8'b0000_0000; always@(posedge clk)begin if(reset)begin fetch <= 0; alu_ena <= 0; state <= idle; end else begin case(state) S1: begin alu_ena <= 1; state <= S2; end S2: begin alu_ena <= 0; state <= S3; end S3: begin fetch <= 1; state <=S4; end S4: begin state <= S5; end S5: state <= S6; S6: state <= S7; S7: begin fetch <= 0; state <= S8; end S8: begin state <= S1; end idle: state <= S1; default: state <=idle; endcase end end endmodule指令寄存器模块图：端口描述：寄存器是将数据总线送来的指令存入高8位或低8位寄存器中。ena信号用来控制是否寄存。每条指令为两个字节，16位，高3位是操作码，低13位是地址（CPU地址总线为13位，寻址空间为8K字节）。本设计的数据总线为8位，每条指令需要取两次，先取高8位，再取低8位。Verilog代码：// Description: RISC—CPU 指令寄存器 // ----------------------------------------------------------------------------- module register ( input [7:0] data , input clk , input rst , input ena , output reg [15:0] opc_iraddr ); reg state ; // always@( posedge clk ) begin if( rst ) begin opc_iraddr <= 16'b 0000_0000_0000_0000; state <= 1'b 0; end // if rst // If load_ir from machine actived, load instruction data from rom in 2 clock periods. // Load high 8 bits first, and then low 8 bits. else if( ena ) begin case( state ) 1'b0 : begin opc_iraddr [ 15 : 8 ] <= data; state <= 1; end 1'b1 : begin opc_iraddr [ 7 : 0 ] <= data; state <= 0; end default : begin opc_iraddr [ 15 : 0 ] <= 16'bxxxx_xxxx_xxxx_xxxx; state <= 1'bx; end endcase // state end // else if ena else state <= 1'b0; end endmodule 累加器模块图：端口描述：累加器用于存放当前结果，ena信号有效时，在clk上升沿输出数据总线的数据。// Description: RISC-CPU 累加器模块 // ----------------------------------------------------------------------------- module accum ( input clk , // Clock input ena , // Enable input rst , // Asynchronous reset active high input [7:0] data , // Data bus output reg [7:0] accum ); always@(posedge clk)begin if(rst) accum <= 8'b0000_0000;//Reset else if(ena) accum <= data; end endmodule 算术运算器模块图：端口描述：算术逻辑运算单元可以根据输入的操作码分别实现相应的加、与、异或、跳转等基本操作运算。本单元支持8种操作运算。opcode用来选择计算模式data是数据输入accum是累加器输出alu_ena是模块使能信号clk是系统时钟Verilog代码：// Description: RISC-CPU 算术运算器 // ----------------------------------------------------------------------------- module alu ( input clk , // Clock input alu_ena , // Enable input [2:0] opcode , // High three bits are used as opcodes input [7:0] data , // data input [7:0] accum , // accum out output reg [7:0] alu_out , output zero ); parameter HLT = 3'b000 , SKZ = 3'b001 , ADD = 3'b010 , ANDD = 3'b011 , XORR = 3'b100 , LDA = 3'b101 , STO = 3'b110 , JMP = 3'b111 ; always @(posedge clk) begin if(alu_ena) begin casex(opcode)//操作码来自指令寄存器的输出 opc_iaddr(15..0)的第三位 HLT: alu_out <= accum ; SKZ: alu_out <= accum ; ADD: alu_out <= data + accum ; ANDD: alu_out <= data & accum ; XORR: alu_out <= data ^ accum ; LDA : alu_out <= data ; STO : alu_out <= accum ; JMP : alu_out <= accum ; default: alu_out <= 8'bxxxx_xxxx ; endcase end end assign zero = !accum; endmodule 数据控制器模块图：端口描述：数据控制器的作用是控制累加器的数据输出，数据总线是分时复用的，会根据当前状态传输指令或者数据。数据只在往RAM区或者端口写时才允许输出，否则呈现高阻态。in是8bit数据输入data_ena是使能信号data是8bit数据输出Verilog代码：// Description: RISC-CPU 数据控制器 // ----------------------------------------------------------------------------- module datactl ( input [7:0] in , // Data input input data_ena , // Data Enable output wire [7:0] data // Data output ); assign data = (data_ena )? in: 8'bzzzz_zzzz ; endmodule 地址多路器模块图：端口描述：用于选择输出地址是PC（程序计数）地址还是数据/端口地址。每个指令周期的前4个时钟周期用于从ROM种读取指令，输出的是PC地址；后四个时钟周期用于对RAM或端口读写。地址多路器和数据控制器实现的功能十分相似。fetch信号用来控制地址输出，高电平输出pc_addr ,低电平输出ir_addr ;pc_addr 指令地址；ir_addr ram或端口地址。Verilog代码：// Description: RISC-CPU 地址多路器 // ----------------------------------------------------------------------------- module adr ( input fetch , // enable input [12:0] ir_addr , // input [12:0] pc_addr , // output wire [12:0] addr ); assign addr = fetch? pc_addr :ir_addr ; endmodule 程序计数器模块图：端口描述：程序计数器用来提供指令地址，指令按照地址顺序存放在存储器中。包含两种生成途径：（1）顺序执行的情况（2）需要改变顺序，例如JMP指令rst复位信号，高电平时地址清零；clock 时钟信号，系统时钟；ir_addr目标地址，当加载信号有效时输出此地址；pc_addr程序计数器地址load地址装载信号Verilog代码：// Description: RISC-CPU 程序计数器 // ----------------------------------------------------------------------------- module counter ( input [12:0] ir_addr , // program address input load , // Load up signal input clock , // CLock input rst , // Reset output reg [12:0] pc_addr // insert program address ); always@(posedge clock or posedge rst) begin if(rst) pc_addr <= 13'b0_0000_0000_0000; else if(load) pc_addr <= ir_addr; else pc_addr <= pc_addr + 1; end endmodule 状态控制器&主状态机模块图：（图左边）状态机端口描述：状态控制器接收复位信号rst，rst有效，控制输出ena为0，fetch有效控制ena为1。// Description: RISC-CPU 状态控制器 // ----------------------------------------------------------------------------- module machinectl ( input clk , // Clock input rst , // Asynchronous reset input fetch , // Asynchronous reset active low output reg ena // Enable ); always@(posedge clk)begin if(rst) ena <= 0; else if(fetch) ena <=1; end endmodule （图右边）主状态端口描述：主状态机是CPU的控制核心，用于产生一系列控制信号。指令周期由8个时钟周期组成，每个时钟周期都要完成固定的操作。（1）第0个时钟，CPU状态控制器的输出rd和load_ir 为高电平，其余为低电平。指令寄存器寄存由ROM送来的高8位指令代码。（2）第1个时钟，与上一个时钟相比只是inc_pc从0变为1，故PC增1，ROM送来低8位指令代码，指令寄存器寄存该8位指令代码。（3）第2个时钟，空操作。（4）第3个时钟，PC增1，指向下一条指令。操作符为HLT，输出信号HLT为高。操作符不为HLT，除PC增1外，其余控制线输出为0.（5）第4个时钟，操作。操作符为AND，ADD，XOR或LDA，读取相应地址的数据；操作符为JMP，将目的地址送给程序计数器；操作符为STO，输出累加器数据。（6）第5个时钟，若操作符为ANDD，ADD或者XORR，算术运算器完成相应的计算；操作符为LDA，就把数据通过算术运算器送给累加器；操作符为SKZ，先判断累加器的值是否为0，若为0，PC加1，否则保持原值；操作符为JMP，锁存目的地址；操作符为STO，将数据写入地址处。(7)第6个时钟，空操作。(8)第7个时钟，若操作符为SKZ且累加器为0，则PC值再加1，跳过一条指令，否则PC无变化。// Description: RISC-CPU 主状态机 // ----------------------------------------------------------------------------- module machine ( input clk , // Clock input ena , // Clock Enable input zero , // Asynchronous reset active low input [2:0] opcode , // OP code output reg inc_pc , // output reg load_acc , // output reg load_pc , // output reg rd , // output reg wr , // output reg load_ir , // output reg datactl_ena , // output reg halt ); reg [2:0] state ; //parameter parameter HLT = 3'b000 , SKZ = 3'b001 , ADD = 3'b010 , ANDD = 3'b011 , XORR = 3'b100 , LDA = 3'b101 , STO = 3'b110 , JMP = 3'b111 ; always@(negedge clk) begin if(!ena) //收到复位信号rst，进行复位操作 begin state <= 3'b000; <= 4'b0000; <= 4'b0000; end else ctl_cycle; end //------- task ctl_cycle ------- task ctl_cycle; begin casex(state) 3'b000: //load high 8bits in struction begin <= 4'b0001; <= 4'b0100; state <= 3'b001; end 3'b001://pc increased by one then load low 8bits instruction begin <= 4'b1001; <= 4'b0100; state <= 3'b010; end 3'b010: //idle begin <= 4'b0000; <= 4'b0000; state <= 3'b011; end 3'b011: //next instruction address setup 分析指令开始点 begin if(opcode == HLT)//指令为暂停HLT begin <= 4'b1000; <= 4'b0001; end else begin <= 4'b1000; <= 4'b0000; end state <= 3'b100; end 3'b100: //fetch oprand begin if(opcode == JMP) begin <= 4'b0010; <= 4'b0000; end else if(opcode == ADD || opcode == ANDD || opcode == XORR || opcode == LDA) begin <= 4'b0001; <= 4'b0000; end else if(opcode == STO) begin <= 4'b0000; <= 4'b0010; end else begin <= 4'b0000; <= 4'b0000; end state <= 3'b101; end 3'b101://operation begin if(opcode == ADD || opcode == ANDD ||opcode ==XORR ||opcode == LDA)//过一个时钟后与累加器的内存进行运算 begin <= 4'b0101; <= 4'b0000; end else if(opcode == SKZ && zero == 1)// & and && begin <= 4'b1000; <= 4'b0000; end else if(opcode == JMP) begin <= 4'b1010; <= 4'b0000; end else if(opcode == STO) begin//过一个时钟后吧wr变为1，写到RAM中 <= 4'b0000; <= 4'b1010; end else begin <= 4'b0000; <= 4'b0000; end state <= 3'b110; end 3'b110: begin if(opcode == STO) begin <= 4'b0000; <= 4'b0010; end else if(opcode == ADD || opcode == ANDD || opcode == XORR || opcode == LDA) begin <= 4'b0001; <= 4'b0000; end else begin <= 4'b0000; <= 4'b0000; end state <= 3'b111; end 3'b111: begin if(opcode == SKZ && zero == 1) begin <= 4'b1000; <= 4'b0000; end else begin <= 4'b0000; <= 4'b0000; end state <= 3'b000; end default: begin <= 4'b0000; <= 4'b0000; state <= 3'b000; end endcase end endtask endmodule 外围模块为了对RISC-CPU进行测试，需要对ROM、RAM和地址译码器进行设计。地址译码器模块说明：地址译码器用于产生选通信号，选通ROM或者RAM1FFFH —— 1800H RAM（范围）：1_1xxx_xxxx_xxxx17FFH —— 0000H ROM（范围）：0_xxxx_xxxx_xxxx+1_0xxx_xxxx_xxxxVerilog代码：// Description: RISC-CPU 地址译码器 // ----------------------------------------------------------------------------- module addr_decode ( input [12:0] addr , // Address output reg ram_sel , // Ram sel output reg rom_sel // Rom sel ); always@(addr)begin casex(addr) 13'b1_1xxx_xxxx_xxxx: <= 2'b01; 13'b0_xxxx_xxxx_xxxx: <= 2'b10; 13'b1_0xxx_xxxx_xxxx: <= 2'b10; default: <= 2'b00; endcase end endmodule RAM模块说明：RAM用于存放临时数据，可读可写。Verilog代码：// Description: RISC-CPU RAM模块 // ----------------------------------------------------------------------------- module ram ( input ena , // Enable input read , // read Enable input write , // write Enable inout wire [7:0] data , // data input [9:0] addr // address ); reg [7:0] ram [10'h3ff:0] ; assign data = (read && ena )? ram[addr]:8'h zz; always@(posedge write) begin ram[addr] <= data; end endmodule ROM模块说明：RAM用于存放只读数据。Verilog代码：// Description: RISC-CPU ROM模块 // ----------------------------------------------------------------------------- module rom ( input [12:0] addr , input read , input ena , output wire [7:0] data ); reg [7:0] memory [13'h1ff:0]; assign data = (read && ena)? memory[addr]:8'b zzzz_zzzz; endmodule 顶层模块模块图：Verilog代码：// Description: RISC-CPU 顶层模块 // ----------------------------------------------------------------------------- //`include "clk_gen.v" //`include "accum.v" //`include "adr.v" //`include "alu.v" //`include "machine.v" //`include "counter.v" //`include "machinectl.v" //`iclude "machine.v" //`include "register.v" //`include "datactl.v" module RISC_CPU ( input clk , input reset , output wire rd , output wire wr , output wire halt , output wire fetch , //addr output wire [12:0] addr , output wire [12:0] ir_addr , output wire [12:0] pc_addr , inout wire [7:0] data , //op output wire [2:0] opcode ); wire [7:0] alu_out ; wire [7:0] accum ; wire zero ; wire inc_pc ; wire load_acc ; wire load_pc ; wire load_ir ; wire data_ena ; wire contr_ena ; wire alu_ena ; //inst clk_gen mclk_gen( .clk (clk ), .reset (reset ), .fetch (fetch ), .alu_ena (alu_ena ) ); register m_register( .data (data ), .ena (load_ir ), .rst (reset ), .clk (clk ), .opc_iraddr ( ) ); accum m_accum( .data (alu_out ), .ena (load_acc ), .clk (clk ), .rst (reset ), .accum (accum ) ); alu m_alu( .data (data ), .accum (accum ), .clk (clk ), .alu_ena (alu_ena ), .opcode (opcode ), .alu_out (alu_out ), .zero (zero ) ); machinectl m_machinectl( .clk (clk ), .rst (reset ), .fetch (fetch ), .ena (contr_ena ) ); machine m_machine( .inc_pc (inc_pc ), .load_acc (load_acc ), .load_pc (load_pc ), .rd (rd ), .wr (wr ), .load_ir (load_ir ), .clk (clk ), .datactl_ena(data_ena ), .halt (halt ), .zero (zero ), .ena (contr_ena ), .opcode (opcode ) ); datactl m_datactl( .in (alu_out ), .data_ena (data_ena ), .data (data ) ); adr m_adr( .fetch (fetch ), .ir_addr (ir_addr ), .pc_addr (pc_addr ), .addr (addr ) ); counter m_counter( .clock (inc_pc ), .rst (reset ), .ir_addr (ir_addr ), .load (load_pc ), .pc_addr (pc_addr ) ); endmodule TestbenchTestbench包含三个测试程序,这个部分不能综合。Test1程序TEST1程序用于验证RISC-CPU的逻辑功能，根据汇编语言由人工编译的。若各条指令正确，应该在地址2E(hex)处，在执行HLT时刻停止。若程序在任何其他位置停止，则必有一条指令运行错误，可以按照注释找到错误的指令。test1汇编程序：(.pro文件/存放于ROM)//机器码-地址-汇编助记符-注释 @00 //address statement 111_0000 //00 BEGIN: JMP TST_JMP 0011_1100 000_0000 //02 HLT //JMP did not work 0000_0000 000_00000 //04 HLT //JMP did not load PC skiped 0000_0000 101_1100 //06 JMP_OK: LDA DATA 0000_0000 001_00000 //08 SKZ 0000_0000 000_0000 //0a HLT 0000_0000 101_11000 //0C LDA DATA_2 0000_0001 001_00000 //0E SKZ 0000_0000 111_0000 //10 JMP SKZ_OK 001_0100 000_0000 //12 HLT 0000_0000 110_11000 //14 SKZ_OK: STO TEMP 0000_0010 101_11000 //16 LDA DATA_1 0000_0000 110_11000 //18 STO TEMP 0000_0010 101_11000 //1A LDA TEMP 0000_0010 001_00000 //1C SKZ 0000_0000 000_00000 //1E HLT 0000_0000 100_11000 //20 XOR DATA_2 0000_0001 001_00000 //22 SKZ 0000_0000 111_00000 //24 JMP XOR_OK 0010_1000 000_00000 //26 HLT 0000_0000 100_11000 //28 XOR_OK XOR DATA_2 0000_0001 001_00000 //2A SKZ 0000_0000 000_00000 //2C HLT 0000_0000 000_0000 //2E END 0000_0000 111_00000 //30 JMP BEGIN 0000_0000 @3c 111_00000 //3c TST_JMP IMR OK 0000_0110 000_00000 //3E HLT test1数据文件：（.dat/存放于RAM）/----------------------------------- @00 ///address statement at RAM 00000000 //1800 DATA_1 11111111 //1801 DATA_2 10101010 //1082 TEMPTest2程序TEST1程序用于验证RISC-CPU的逻辑功能，根据汇编语言由人工编译的。这个程序是用来测试RISC-CPU的高级指令集，若执行正确，应在地址20（hex）处在执行HLT时停止。test2汇编程序：@00 101_11000 //00 BEGIN 0000_0001 011_11000 //02 AND DATA_3 0000_0010 100_11000 //04 XOR DATA_2 0000_0001 001_00000 //06 SKZ 0000_0000 000_00000 //08 HLT 0000_0000 010_11000 //0A ADD DATA_1 0000_0000 001_00000 //0C SKZ 0000_0000 111_00000 //0E JMP ADD_OK 0001_0010 111_00000 //10 HLT 0000_0000 100_11000 //12 ADD_OK XOR DATA_3 0000_0010 010_11000 //14 ADD DATA_1 0000_0000 110_11000 //16 STO TEMP 0000_0011 101_11000 //18 LDA DATA_1 0000_0000 010_11000 //1A ADD TEMP 0000_0001 001_00000 //1C SKZ 0000_0000 000_00000 //1E HLT 0000_0000 000_00000 //END HLT 0000_0000 111_00000 //JMP BEGIN 0000_0000test2数据文件：@00 00000001 //1800 DATA_1 10101010 //1801 DATA_2 11111111 //1802 DATA_3 00000000 //1803 TEMPTest3程序TEST3程序是一个计算0~144的斐波那契数列的程序，用来验证CPU整体功能。test3汇编程序：@00 101_11000 //00 LOOP:LDA FN2 0000_0001 110_11000 //02 STO TEMP 0000_0010 010_11000 //04 ADD FN1 0000_0000 110_11000 //06 STO FN2 0000_0001 101_11000 //08 VLDA TEMP 0000_0010 110_11000 //0A STO FN1 0000_0000 100_11000 //0C XOR LIMIT 0000_0011 001_00000 //0E SKZ 0000_0000 111_00000 //10 JMP LOOP 0000_0000 000_00000 //12 DONE HLT 0000_0000test3数据文件：@00 00000001 //1800 FN1 00000000 //1801 FN2 00000000 //1802 TEMP 10010000 //1803 LIMIT完整的testbenchVerilog代码：// Description: RISC-CPU 测试程序 // ----------------------------------------------------------------------------- `include "RISC_CPU.v" `include "ram.v" `include "rom.v" `include "addr_decode.v" `timescale 1ns/1ns `define PERIOD 100 // matches clk_gen.v module cputop_tb; reg [( 3 * 8 ): 0 ] mnemonic; // array that holds 3 8 bits ASCII characters reg [ 12 : 0 ] PC_addr, IR_addr; reg reset_req, clock; wire [ 12 : 0 ] ir_addr, pc_addr; // for post simulation. wire [ 12 : 0 ] addr; wire [ 7 : 0 ] data; wire [ 2 : 0 ] opcode; // for post simulation. wire fetch; // for post simulation. wire rd, wr, halt, ram_sel, rom_sel; integer test; //-----------------DIGITAL LOGIC---------------------- RISC_CPU t_cpu (.clk( clock ),.reset( reset_req ),.halt( halt ),.rd( rd ),.wr( wr ),.addr( addr ),.data( data ),.opcode( opcode ),.fetch( fetch ),.ir_addr( ir_addr ),.pc_addr( pc_addr )); ram t_ram (.addr ( addr [ 9 : 0 ]),.read ( rd ),.write ( wr ),.ena ( ram_sel ),.data ( data )); rom t_rom (.addr ( addr ),.read ( rd ), .ena ( rom_sel ),.data ( data )); addr_decode t_addr_decoder (.addr( addr ),.ram_sel( ram_sel ),.rom_sel( rom_sel )); //-------------------SIMULATION------------------------- initial begin clock = 0; // display time in nanoseconds $timeformat ( -9, 1, "ns", 12 ); display_debug_message; sys_reset; test1; $stop; test2; $stop; test3; $finish; // simulation is finished here. end // initial task display_debug_message; begin $display ("\n************************************************" ); $display ( "* THE FOLLOWING DEBUG TASK ARE AVAILABLE: *" ); $display ( "* \"test1;\" to load the 1st diagnostic program. *"); $display ( "* \"test2;\" to load the 2nd diagnostic program. *"); $display ( "* \"test3;\" to load the Fibonacci program. *"); $display ( "************************************************\n"); end endtask // display_debug_message task test1; begin test = 0; disable MONITOR; $readmemb ("test1.pro", t_rom.memory ); $display ("rom loaded successfully!"); $readmemb ("test1.dat", t_ram.ram ); $display ("ram loaded successfully!"); #1 test = 1; #14800; sys_reset; end endtask // test1 task test2; begin test = 0; disable MONITOR; $readmemb ("test2.pro", t_rom.memory ); $display ("rom loaded successfully!"); $readmemb ("test2.dat", t_ram.ram ); $display ("ram loaded successfully!"); #1 test = 2; #11600; sys_reset; end endtask // test2 task test3; begin test = 0; disable MONITOR; $readmemb ("test3.pro", t_rom.memory ); $display ("rom loaded successfully!"); $readmemb ("test3.dat", t_ram.ram ); $display ("ram loaded successfully!"); #1 test = 3; #94000; sys_reset; end endtask // test1 task sys_reset; begin reset_req = 0; #( `PERIOD * 0.7 ) reset_req = 1; #( 1.5 * `PERIOD ) reset_req = 0; end endtask // sys_reset //--------------------------MONITOR-------------------------------- always@( test ) begin: MONITOR case( test ) 1: begin // display results when running test 1 $display("\n*** RUNNING CPU test 1 - The Basic CPU Diagnostic Program ***"); $display("\n TIME PC INSTR ADDR DATA "); $display(" ------ ---- ------- ------ ------ "); while( test == 1 )@( t_cpu.pc_addr ) begin // fixed if(( t_cpu.pc_addr % 2 == 1 )&&( t_cpu.fetch == 1 )) begin // fixed #60 PC_addr <= t_cpu.pc_addr - 1; IR_addr <= t_cpu.ir_addr; #340 $strobe("%t %h %s %h %h", $time, PC_addr, mnemonic, IR_addr, data ); // Here data has been changed t_cpu.m_register.data end // if t_cpu.pc_addr % 2 == 1 && t_cpu.fetch == 1 end // while test == 1 @ t_cpu.pc_addr end 2: begin // display results when running test 2 $display("\n*** RUNNING CPU test 2 - The Basic CPU Diagnostic Program ***"); $display("\n TIME PC INSTR ADDR DATA "); $display(" ------ ---- ------- ------ ------ "); while( test == 2 )@( t_cpu.pc_addr ) begin // fixed if(( t_cpu.pc_addr % 2 == 1 )&&( t_cpu.fetch == 1 )) begin // fixed #60 PC_addr <= t_cpu.pc_addr - 1; IR_addr <= t_cpu.ir_addr; #340 $strobe("%t %h %s %h %h", $time, PC_addr, mnemonic, IR_addr, data ); // Here data has been changed t_cpu.m_register.data end // if t_cpu.pc_addr % 2 == 1 && t_cpu.fetch == 1 end // while test == 2 @ t_cpu.pc_addr end 3: begin // display results when running test 3 $display("\n*** RUNNING CPU test 3 - An Executable Program **************"); $display("***** This program should calculate the fibonacci *************"); $display("\n TIME FIBONACCI NUMBER "); $display(" ------ -----------------_ "); while( test == 3 ) begin wait( t_cpu.opcode == 3'h 1 ) // display Fib. No. at end of program loop $strobe("%t %d", $time, t_ram.ram [ 10'h 2 ]); wait( t_cpu.opcode != 3'h 1 ); end // while test == 3 end endcase // test end // MONITOR: always@ test //-------------------------HALT------------------------------- always@( posedge halt ) begin // STOP when HALT intruction decoded #500 $display("\n******************************************"); $display( "** A HALT INSTRUCTION WAS PROCESSED !!! **"); $display( "******************************************"); end // always@ posedge halt //-----------------------CLOCK & MNEMONIC------------------------- always#(`PERIOD / 2 ) clock = ~ clock; always@( t_cpu.opcode ) begin // get an ASCII mnemonic for each opcode case( t_cpu.opcode ) 3'b 000 : mnemonic = "HLT"; 3'b 001 : mnemonic = "SKZ"; 3'b 010 : mnemonic = "ADD"; 3'b 011 : mnemonic = "AND"; 3'b 100 : mnemonic = "XOR"; 3'b 101 : mnemonic = "LDA"; 3'b 110 : mnemonic = "STO"; 3'b 111 : mnemonic = "JMP"; default : mnemonic = "???"; endcase end endmodule $ readmemb ( "test1. pro" ,t_ rom. . memory ); $ readmemb ( "testl. dat",t_ ram_ . ram); 即可把编译好的汇编机器码装人虚拟ROM,把需要参加运算的数据装人虚拟RAM就可以开始仿真。上面语句中的第一项为打开的文件名,后一项为系统层次管理下的ROM模块和RAM模块中的存储器memory和ram。源代码&脚本隐藏内容，请前往内页查看详情前仿真结果test1 test2 test3 DC后仿真采用SMIC180工艺在典型环境下进行测试 时序报告： 面积报告： 功耗报告： 综合电路图： 总结该项目更加偏向于教学练习，CPU也是数字IC的重要研究方向，对此感兴趣的同学可以找点论文和开源资料进行学习。可以进一步优化如流水线、运算单元，扩展成SOC系统等。
-
【硬件算法】Verilog之FPGA实现信号移相法 实现信号移相可以用FPGA控制信号0-360度连续可调，对于高频信号（1GHZ以上）超出了FPGA工作频率还有一种办法是FPGA-》DA-》射频前端-》移相器-》阻抗匹配-》天线。本案例直接采用FPGA对数字中频信号处理（kHZ、MHZ）本质是边沿检测与分频现象：代码：/* Function : Phase Shift Interface : clk_fre---unit(MHZ) din_fre---unit(KHz) phase_angle---unit(0-360 Angle) Date: 2023/04/05 Description: Phase shift is carried out on the input square wave. The phase Angle unit is Angle (0-360), or the input can be greater than 360. The system clock unit is MHz and the input signal clock is KHz. */ module PhaseShift( input clk, //clk input rst_n, //rest input [7:0] clk_fre, //system clock frequency,MHZ input [15:0] din_fre, //input signal clock frequency,KHZ input [8:0] phase_angle, //phase shift angle input din, //input signal output reg dout //output signal ); reg [31:0] posedge_counter; reg [31:0] negedge_counter; reg [31:0] delay_counter; reg in_posedge_flg; reg in_negedge_flg; reg out_posedge_flg; reg out_negedge_flg; reg old_din; reg init_data=1'b1; always @(posedge clk or negedge rst_n) begin if(!rst_n) begin posedge_counter <= 1'b0; negedge_counter <= 1'b0; in_posedge_flg <= 1'b0; in_negedge_flg <= 1'b0; out_posedge_flg <= 1'b0; out_negedge_flg <= 1'b0; end else begin if(~old_din & din) in_posedge_flg = 1'b1; if(old_din & ~din) in_negedge_flg = 1'b1; old_din <= din; if(init_data) begin delay_counter <= ((1000000000)/din_fre*clk_fre)/360*(phase_angle%360)/1000000; dout <= din ; init_data <= 1'b0; end if(in_posedge_flg && posedge_counter <= delay_counter) begin posedge_counter <= posedge_counter + 1'b1 ; out_posedge_flg <= 1'b0; end else begin posedge_counter <= 1'b0 ; in_posedge_flg <= 1'b0 ; if(~out_posedge_flg) begin dout <= 1'b1 ; out_posedge_flg <= 1'b1 ; end end if (in_negedge_flg && negedge_counter <= delay_counter) begin negedge_counter <= negedge_counter + 1'b1 ; out_negedge_flg <= 1'b0 ; end else begin negedge_counter <= 1'b0 ; in_negedge_flg <= 1'b0 ; if(~out_negedge_flg) begin dout <= 1'b0 ; out_negedge_flg <= 1'b1; end end end end endmodule测试代码：`timescale 100ps/10ps // module test_PhaseShift; reg clk; reg rst_n; reg [7:0] clk_fre; //system clock frequency,MHZ reg [15:0] din_fre ; //input signal clock frequency,KHZ reg [8:0] phase_angle; //phase shift angle reg din ; //input signal wire dout ; //output signal initial begin clk = 0; din = 0; din_fre = 4000; phase_angle = 90; clk_fre = 100; rst_n = 1; #12 rst_n = 0; #4 rst_n = 1; #10000 $stop; //end end always #5 clk = ~clk; always #125 din = ~din; PhaseShift u1( .clk(clk), .rst_n(rst_n), .clk_fre(clk_fre), .din_fre(din_fre), .phase_angle(phase_angle), .din(din), .dout(dout) ); endmodule
-
【数字IC笔面必备】同步FIFO与异步FIFO 同步FIFO同步FIFO相对异步FIFO较为简单，FIFO：先入先出FIFO原则：满不能写，空不能读。关键：full和empty信号如何产生？方法1：用长度计数器factor。执行一次写操作，factor加1，执行一次读操作，factor减1。方法2：地址位扩展一位，用最高位来判断空满。读地址=写地址，则空；读地址与写地址相差一个存储空间长度，则满。对于方法1来说比较简单，本文重点讲异步FIFO，对于同步FIFO我们给出伪代码，读者自行补全该模块全部代码。异步FIFO异步FIFO的整体结构大致如下：Write_control:控制写操作与满信号（w_full）的判断与产生。Read_control:控制读操作与空信号(r_empty)的判断与产生。RAM:双端口数据存取RAM。Bin_to_gray:二进制码转格雷码模块。用于将读写地址二进制码转成格雷码。SYN：跨时钟同步模块，即将读地址的格雷码（r_g_addr）向w_clk同步；将写地址的格雷码（w_g_addr）向r_clk同步。主要操作就是通过寄存器打两拍。使用扩展地址位来判断空满，读写信号时钟不同。关键在于格雷码使用，同步可以不用格雷码，异步两时钟不一样，采用出错概率大，普通二进制码会出现多个错误，而格雷码每次跳转只会有一位发生变化，出错概率小且顶多是使得FIFO的读或者写操作暂停。详细解释：在中间状态采样，这个是不可能避免的，这是异步系统天生的缺陷。我们的目标是:即使在中间状态采样，也不能影响空满状态的判断。符合这个要求的编码方式是:每次只能有1个bit发生改变。为什么这么说呢?因为当只有一一个bit发生改变时，即使在中间状态采样，其结果也不外乎两种:递增前原指针和递增后新指针。显然递增后新指针是最新情况的反映，如果采样到这个指针，那么和我们的设计预期是一致的，如果采样到递增前的原指针，会有什么结果呢?假设现在采样读指针，那么最坏的情况就是把“不满”判断成了“满”，使得本来被允许的写操作被禁止了，但是这并不会对逻辑产生影响，只是带来了写操作的延迟。同样的，如果现在采样写指针，那么最坏的情况就是把“不空”判断成“空”，使得本来被允许的读操作被禁止了,但是这也不会对逻辑产生影响，只是带来了读操作的延迟显然每次之变化1个bit的编码方案可以有效解决中间态下空满状态的判断问题，格雷码就是这样一种编码。关键点解释1.跨时钟域传递信号做时钟同步一般通过打两拍。2.采用格雷码编码(解决汇聚问题)，因为格雷码每次跳转只会有一位发生变化，所以如果出现不确定状态也只会有两种状况，即正确变化了和不变。因此在读写时钟不一样的情况下，纵使读写地址每bit同步过程中出现延时不一致，也不会使得FIFO在实际空或者满之后，FIFO却没有正确的产生出空满信号。只有可能是实际没有空或者满，但产生了空满信号，但这对于FIFO的功能不会有影响，只会使得FIFO的读或者写操作暂停。3.读比写时钟更快，只会只出现实际没满，但误判为满；不会对功能（数据流）造成错误。4.写比读时钟更快，只会出现实际没空，但误判为空；不会对功能（数据流）造成错误。verilog格雷码生成观察下面码表，格雷码最高位与原码一致，其它位对应原码相邻两位相互异或的结果module bin_to_gray #( parameter WIDTH_D = 5 )( input [WIDTH_D-1:0] bin_c, output [WIDTH_D-1:0] gray_c ); wire h_b; assign h_b = bin_c[WIDTH_D-1]; reg [WIDTH_D-2:0] gray_c_d; integer i; always @( * ) for( i=0;i<WIDTH_D-1;i=i+1 ) gray_c_d[i] = bin_c[i]^bin_c[i+1]; assign gray_c = ; endmodule源程序下载
-
IC/SOC封装类型与对应成本关系 根据引脚引出的不同，封装可分为外围和阵列封装。根据有无封装连线分为有连接线的( Wire Bond)和倒装片(Flip-chip) 封装。其中，外围封装形式有DIP、PLCC、QFP、SOP等，如图14-23所示。此类封装的优点是价格便宜，板级可靠性比较高。但是其电性能和热性能较差，并且受到I/O引脚数目的限制，如PQFP (Plastic Quad Flat Package,塑料四边引脚扁平封装)，I/O 引脚数目也只能达到208~240个。阵列封装包括有连线的BGA和无连线的Flip-chip BGA等，如图14-24 所示。此类封装的优点是I/O密度高，板级集成的成品率高，但是价格相对较高。(1) BGA封装BGA封装技术的出现是封装技术的一大突破，它是近几年来推动封装市场的强有力的技术之一，BGA封装一改传统的封装结构，将引线从封装基板的底部以阵列球的方式引出，这样不仅可以安排更多的IO，而且大大提高了封装密度，改进了电性能。如果它再采用MCP (多芯片模块)封装或倒装片技术，有望进一步提高产 品的速度和降低复杂性。目前, BGA封装按照基板的种类，主要分为PBGA (塑封BGA)、CBGA (陶瓷BGA)、TBGA(载带BGA)、MBGA (金属BGA)等。图14-25以PBGA为例进行说明，PBGA中的焊球做在PWB基板上，基板是BT多层布线基板(2~4层)，封装采用的焊球材料为共晶或准共晶Pb-Sn合金、焊球和封装体的连接不需要另外的焊料。(2)倒装片封装(Flip Chip Packages)倒装片技术是一种先进的，非常有前途的集成电路封装技术。封装倒装片是一一种由 IBM公司最先使用的先进封装技术，它是利用倒装技术将芯片直接装入一- 个封装体内。倒装片封装可以是单芯片也可以是多芯片形式，其发展历史已将近40年，主要在手持或移动电子产品中使用广泛。一般芯片都是面朝上安装互连，而此类技术则是芯片面朝下，芯片上的焊区直接与基板上的焊区互连，如图14-26所示。因此，倒装封装的互连线非常短，由互连线产生的电容、电阻和电感也比其他封装形式小得多，具有较高的电性能和热性能。此外，采用此类封装的芯片焊区可面阵布局，更适于多I/O数的VLSI芯片使用。当然，倒装技术也有不足之处，如芯片面朝下安装互连，给工艺操作带来一定难度一焊 点检查困难，板级可靠性需要解决，费用也偏高。(3)多芯片封装(MCP, Multi Chip Package)多芯片封装是20世纪90年代兴起的- -种混合微电子组装技术，它是在高密度多层布线基板上,将若干裸芯片IC组装和互连,构成更复杂的或具有子系统功能的高级电子组件，常见的有Flash+MCU、Flash+MCU+SRAM、 SRAM+MCU和Analog IC+Digital IC+Memory等组合。图14-27 所示为MCP封装的示意图。目前，MCP多采用IC芯片叠层放置，可大大节约基板的面积，其主要特点是布线密度高，互连线短，体积小，重量轻和性能高等。但是由于封装了多块芯片，使得良品率有所下降，并且测试相对较困难，测试成本也很高。
-
RAM与ROM及Verilog实现 概念RAM（random access memory）即随机存储内存，这种存储器在断电时将丢失其存储内容，故主要用于存储短时间使用的程序。ROM 指的是“只读存储器”，即Read-Only Memory。只读存储器（Read-Only Memory，ROM）以非破坏性读出方式工作，只能读出无法写入信息。信息一旦写入后就固定下来，即使切断电源，信息也不会丢失，所以又称为固定存储器。ROM所存数据通常是装入整机前写入的，整机工作过程中只能读出，不像随机存储器能快速方便地改写存储内容。ROM所存数据稳定 ，断电后所存数据也不会改变，并且结构较简单，使用方便，因而常用于存储各种固定程序和数据。PROM 指的是“可编程只读存储器”既Programmable Red-Only Memory。这样的产品只允许写入一次，所以也被称为“一次可编程只读存储器”(One Time Progarmming ROM，OTP-ROM)。最初从工厂中制作完成的PROM内部并没有资料，用户可以用专用的编程器将自己的资料写入，但是这种机会只有一次，一旦写入后也无法修改。EPROM 指的是“可擦写可编程只读存储器”，即Erasable Programmable Read-Only Memory。它的特点是具有可擦除功能，擦除后即可进行再编程，但是缺点是擦除需要使用紫外线照射一定的时间。EEPROM 指的是“电可擦除可编程只读存储器”，即Electrically Erasable Programmable Read-Only Memory。它的最大优点是可直接用电信号擦除，也可用电信号写入。EEPROM不能取代RAM的原因是其工艺复杂， 耗费的门电路过多，且重编程时间比较长，同时其有效重编程次数也比较低。Flash memory 指的是“闪存”，所谓“闪存”，它也是一种非易失性的内存，属于EEPROM的改进产品。它的最大特点是必须按块(Block)擦除(每个区块的大小不定，不同厂家的产品有不同的规格)， 而EEPROM则可以一次只擦除一个字节(Byte)。目前“闪存”被广泛用在PC机的主板上，用来保存BIOS程序，便于进行程序的升级。其另外一大应用领域是用来作为硬盘的替代品，具有抗震、速度快、无噪声、耗电低的优点，但是将其用来取代RAM就显得不合适，因为RAM需要能够按字节改写，而Flash ROM做不到。二、编程1.要求：编程实现512x8的ROM和RAM。ROM、RAM至少应该包含的端口包括地址线、数据线、片选线、读写使能端，复位端和时钟端（其中部分信号线只适用于RAM）。ROM、RAM和总测试模块分别包含在不同的.v文件中。端口意义：2.设计思路：512x8的ROM和RAM,至少需要9位地址线和8位数据位。3.RAM实现代码//模块声明，指定模块名和端口引脚 module RAM (Data,Addr,CS,RWEnable,Reset,Clk); //参数定义，指定数据总线和地址总线的宽度，以及内存单元的数量 parameter width=8,msize=512; //端口引脚的方向和位宽定义 input CS,RWEnable,Reset,Clk; //输入信号，分别为芯片选择、读写使能、复位和时钟 input[width:0] Addr; //输入地址总线，宽度由width参数决定 inout[width-1:0] Data; //双向数据总线，宽度由width参数决定 //内部信号和寄存器的定义 reg [width-1:0] Data_temp; //用于暂存读出的数据的寄存器，宽度与Data总线相同 reg [width-1:0] Mem [msize-1:0]; //用于存储所有数据的内存数组，大小与内存单元数量相同 integer i; //用于遍历内存单元的整数变量 //always块，指定模块中所有操作的逻辑 always @(posedge Clk or posedge Reset) begin //复位条件，当Reset为1时，所有内存单元都被置为0 if(Reset) begin for(i=0;i<msize;i=i+1) //用一个for循环遍历所有内存单元 Mem[i] <= 0; //将每个内存单元赋值为0 end //写操作条件，当RWEnable为1且CS为1时，将Data总线上的数据写入到Addr指定的内存单元中 else if((RWEnable==1'b1)&&(CS==1'b1)) begin Mem[Addr] <= Data; //将Data总线上的数据赋值给Mem[Addr] end //读操作条件，当RWEnable为0且CS为1时，将Addr指定的内存单元中的数据读出并暂存在Data_temp中 else if((RWEnable==1'b0)&&(CS==1'b1)) begin Data_temp<=Mem[Addr]; //将Mem[Addr]中的数据赋值给Data_temp end //其他条件，当CS为0或RWEnable为不确定值时，将Data_temp置为高阻抗状态 else begin Data_temp <= 8'bz; //将Data_temp赋值为高阻抗状态 end end //assign语句，指定Data总线与Data_temp之间的连接关系 assign Data=RWEnable?8'bz:Data_temp; //当RWEnable为1时，Data总线处于高阻抗状态；当RWEnable为0时，Data总线接收Data_temp中的数据 endmodule //模块结束测试代码如下：//模块声明，指定模块名为RAM_TS module RAM_TS; //信号和寄存器的定义，指定与RAM模块相连的端口引脚和内部变量 reg CS_t,RWEnable_t,Reset_t,Clk_t; //芯片选择、读写使能、复位和时钟信号，都是1位的寄存器 wire [7:0] Data_t; //数据总线，是8位的线网 reg [8:0] Addr_t; //地址总线，是9位的寄存器 reg [7:0] Data_temp_t; //用于暂存写入数据的寄存器，也是8位的 //initial块，指定测试RAM模块的过程，只会在仿真开始时执行一次 initial begin RWEnable_t = 1;//w //初始化读写使能信号为1，表示写模式 Reset_t = 1; //初始化复位信号为1，表示复位模式 Clk_t = 0; //初始化时钟信号为0 Addr_t = 0; //初始化地址总线为0 Data_temp_t = 0; //初始化暂存数据为0 CS_t=1; //初始化芯片选择信号为1，表示使能模式 #5 Reset_t=0; //延迟5个时间单位后，将复位信号置为0，表示正常工作模式 repeat(10) //重复10次以下操作 begin #5 //延迟5个时间单位后 Addr_t=Addr_t+10; //将地址总线加10，表示访问下一个内存单元 Data_temp_t=Addr_t; //将地址总线上的值赋给暂存数据，表示要写入的数据与地址相同 end #70 //延迟70个时间单位后 RWEnable_t = 0;//r //将读写使能信号置为0，表示读模式 Addr_t=0; //将地址总线置为0，表示从第一个内存单元开始读取数据 repeat(10) //重复10次以下操作 begin #5 //延迟5个时间单位后 Addr_t=Addr_t+10; //将地址总线加10，表示访问下一个内存单元 end end //assign语句，指定数据总线与暂存数据之间的连接关系 assign Data_t=RWEnable_t?Data_temp_t:8'bz; always #5 Clk_t=~Clk_t; //实例化一个RAM模块，并且用定义好的信号和寄存器与之相连 RAM myRAM( .Data(Data_t), //将数据总线与RAM模块的Data端口相连 .Addr(Addr_t), //将地址总线与RAM模块的Addr端口相连 .CS(CS_t), //将芯片选择信号与RAM模块的CS端口相连 .RWEnable(RWEnable_t), //将读写使能信号与RAM模块的RWEnable端口相连 .Reset(Reset_t), //将复位信号与RAM模块的Reset端口相连 .Clk(Clk_t) //将时钟信号与RAM模块的Clk端口相连 ); endmodule //模块结束4.RAM仿真测试：① 数据写入操作② 数据读取操作5.ROM实现代码：ROM代码如下：//模块声明，指定模块名和端口引脚 module ROM(Data,Addr,CS,RDEnable,Reset,Clk); //参数定义，指定数据总线和地址总线的宽度，以及内存单元的数量 parameter width=8,msize=512; //端口引脚的方向和位宽定义 input CS,RDEnable,Reset,Clk; //输入信号，分别为芯片选择、读使能、复位和时钟 input[width:0] Addr; //输入地址总线，宽度由width参数决定 output [width-1:0] Data; //输出数据总线，宽度由width参数决定 //内部信号和寄存器的定义 reg [width-1:0] Data_read; //用于暂存读出的数据的寄存器，宽度与Data总线相同 reg [width-1:0] Mem [msize-1:0]; //用于存储所有数据的内存数组，大小与内存单元数量相同 integer i; //用于遍历内存单元的整数变量 //always块，指定模块中所有操作的逻辑 always @(posedge Clk or posedge Reset) begin //复位条件，当Reset为1时，所有内存单元都被置为其地址值 if(Reset) begin for(i=0;i<msize;i=i+1) //用一个for循环遍历所有内存单元 Mem[i] <= i; //将每个内存单元赋值为其地址值 end //读操作条件，当RDEnable为1且CS为1时，将Addr指定的内存单元中的数据读出并暂存在Data_read中 else if((RDEnable==1'b1)&&(CS==1'b1)) begin Data_read<=Mem[Addr]; //将Mem[Addr]中的数据赋值给Data_read end //其他条件，当CS为0或RDEnable为不确定值时，将Data_read置为高阻抗状态 else Data_read <= 8'bz; //将Data_read赋值为高阻抗状态 end //assign语句，指定Data总线与Data_read之间的连接关系 assign Data=Data_read; //当RDEnable为1时，Data总线输出Data_read中的数据；当RDEnable为0时，Data总线处于高阻抗状态 endmodule //模块结束测试代码如下：//模块声明，指定模块名为R0M98_TS module R0M_TS; //信号和寄存器的定义，指定与ROM98模块相连的端口引脚和内部变量 reg CS_t,RDEnable_t,Reset_t,Clk_t; //芯片选择、读使能、复位和时钟信号，都是1位的寄存器 wire [7:0] Data_t; //数据总线，是8位的线网 reg [8:0] Addr_t; //地址总线，是9位的寄存器 //initial块，指定测试ROM98模块的过程，只会在仿真开始时执行一次 initial begin RDEnable_t = 1;//r //初始化读使能信号为1，表示读模式 Reset_t = 1; //初始化复位信号为1，表示复位模式 Clk_t = 0; //初始化时钟信号为0 Addr_t = 0; //初始化地址总线为0 // Data_read_ts = 0; //初始化暂存数据为0 CS_t=1; //初始化芯片选择信号为1，表示使能模式 #5 Reset_t=0; //延迟5个时间单位后，将复位信号置为0，表示正常工作模式 repeat(10) //重复10次以下操作 begin #10 //延迟10个时间单位后 Addr_t=Addr_t+10; //将地址总线加10，表示访问下一个内存单元 end end //always块，指定时钟信号的变化规律，每隔5个时间单位翻转一次 always #5 Clk_t=~Clk_t; //实例化一个ROM98模块，并且用定义好的信号和寄存器与之相连 ROM myROM( .Data(Data_t), //将数据总线与ROM98模块的Data端口相连 .Addr(Addr_t), //将地址总线与ROM98模块的Addr端口相连 .CS(CS_t), //将芯片选择信号与ROM98模块的CS端口相连 .RDEnable(RDEnable_t), //将读使能信号与ROM98模块的RDEnable端口相连 .Reset(Reset_t), //将复位信号与ROM98模块的Reset端口相连 .Clk(Clk_t) //将时钟信号与ROM98模块的Clk端口相连 ); endmodule //模块结束 6.ROM仿真测试：
-
FPGA与数字IC设计中接口命名规范 在硬件编程中，接口命名规范也是一个良好的习惯。接口在确定模块划分后需要明确模块的端口以及模块间的数据交互。完成项目模块划分后，可以在确定端口及数据流向时参考使用。本节重点是EN与vld的区别！ ``信号说明clk模块工作时钟rst_n系统复位信号，低电平有效en门控时钟，请搜索本站关于门控时钟讲解，这是低功耗的设计，EN=0睡眠状态、阻断时钟输入vld数据有效标志指示信号，表示当前的 data 数据有效。注意，vld 不仅表示了数据有效，而且还表示了其有效次数。时钟收到多少个 vld=1，就表示有多少个数据有data数据总线。输入一般名称为 din，输出一般名称为 dout。类似的信号还有 addr，len 等err整个报文错误指示，在 eop=1 且 vld=1 有效时才有效sop报文起始指示信号，用于表示有效报文数据的第一个数据，当 vld=1 时此信号有效eop报文结束指示信号，用于表示有效报文数据的最后一个数据，当 vld=1 时此信号有效rdy模块准备好信号，用于模块之间控制数据发送速度。例如模块 A 发数据给模块 B，则rdy 信号由模块 B 产生，连到模块 A（该信号对于 B 是输出信号，对于 A 是输入信号）；B 要确保 rdy 产生正确，当此信号为 1 时，B 一定能接收数据；A 要确保仅在 rdy=1 时才发送
-
IC设计技巧-流水线设计 流水线概述如下图为工厂流水线，工厂流水线就是将一个工作（比如生产一个产品）分成多个细分工作，在生产流水线上由多个不同的人分步完成。这个待完成的产品在流水线上一级一级往下传递。比如完成一个产品，需要8道工序，每道工序需要10s，那么流水线启动后，不间断工作的话，第一个产品虽然要80s才完成，但是接下来每10s就能产出一个产品。使得速度大大提高。当然这也增加了人员等资源的付出。对于电路的流水线设计思想与上述思想异曲同工，也是以付出增加资源消耗为代价，去提高电路运算速度。流水线设计实例这里以一个简单的8位无符号数全加器的设计为实例来进行讲解，实现 assign = a[7:0] + b[7:0] +c_in c_out 为进位位。如果有数字电路常识的人都知道，利用一块组合逻辑电路去做8位的加法，其速度肯定比做2位的加法慢。因此这里可以采用4级流水线设计，每一级只做两位的加法操作，当流水线一启动后，除第一个加法运算之外，后面每经过一个2位加法器的延时，就会得到一个结果。整体结构如下，每一级通过in_valid,o_valid信号交互，分别代表每一级的输入输出有效信号。第一级：做最低两位与进位位的加法操作，并将运算结果和未做运算的高六位传给下一级。第二级：做2,3两位与上一级加法器的进位位的加法操作，并将本级运算结果和未做运算的高4位传给下一级。第三级：做4,5两位与进位位的加法操作，并将运算结果和未做运算的高2位传给下一级。第四级：做最高两位与上一级加法器输出的进位位的加法操作，并将结果组合输出。仿真结果如下如图，当整体模块in_valid有效时，送进去的数据a=1,b=5,c_in=1;故经过四个周期后，o_valid信号拉高，同时获得运算结果data_out=7。（本设计的流水线每级延时为一个时钟周期）后续输出信号7、9、10显然是间隔2个周期延迟，而不是延迟4周期、8周期逐个输出总结流水线就是通过将一个大的组合逻辑划分成分步运算的多个小组合逻辑来运算，从而达到提高速度的目的。在设计流水线的时候，我们一般要尽量使得每级运算所需要的时间差不多，从而做到流水匹配，提高效率。因为流水线的速度由运算最慢的那一级电路决定。
-
Vivado-FPGA Verilog烧写固化教程 Vivado里程序固化详细教程编者注：初玩FPGA开发板，我们都会遇到这种情况，每次事先写好的程序编译成功后，下载到板子里，输出结果十分赏心悦目，随着掉电之后，程序也就随之消失，再次上电，又要重新编译下载程序，十分麻烦，不是我们想看到的结果。所以学会固化程序十分重要！下面就来说说如何固化程序。目的简介：将FPGA的配置文件（固化用的配置文件是二进制文件，仅bin文件）烧写到板载Flash中，实现上电自启动，完成程序固化。法1：烧录bin文件过程步骤：1）在Vivado软件里找到Settings设置选项，进入，点击Bitstream选项，将 bin_file 勾上，点击 OK2）点击 generate bitstream （可以分步进行，Run Synthesis—Run implementation— genereate bitstream），生成 bit 文件和 bin 文件。3）点击 open hardware manager，连接板子4）在Hardware面板中右击FPGA器件（xc7a35t_0），选择Add Configuration Memery Device。5）在弹出的添加配置存储器的界面中，找到板载的Flash存储器型号，点击OK，完成添加。这里开发板flash型号是（ n25q64 ）选择3.3v。6）添加完成后，Vivado会提示添加完成，是否立即配置存储器。点击OK，进入配置存储器的界面，开始将二进制bin文件烧写到外部配置flash存储器中。提醒：如果配置存储器的界面突然找不到，可以右击flash存储器，点击Program Configuration Memory Device，会出现存储器的配置界面。7）找到二进制bin文件，选中，进行代码烧写, 实现上电自启动，完成程序固化。选择好烧写的二进制文件，选中后点击 OK，将代码烧录到 flash，。其他设置可以保持默认提醒：二进制文件路径为：project_name\project_name.runs\impl_1\xxx.bin。或project_name \project_name.runs\impl_2\xxx.bin。（project_name根据用户工程进行修改）。点击OK，烧写二进制文件。由于需要擦除存储器原有数据，校验，以及烧写等几步，所以配置时间可能会稍微久一点。完成后，点击OK。这样FPGA硬件程序就固化到外部配置存储器中了，下次上电就可以通过QSPI自启动。需要注意的是板载的配置跳线帽需要设置到QSPI模式。法二烧mcs文件第一步：先综合，然后打开综合设计第二步：点击Tools—Edit Device Properties(注意，必须按照第一步打开综合后的设计，才能找到这个选项)，然后配置相应参数。可以选择压缩bit流，这样后面固化时会快一些。选择合适的固化速率，可以适当设置高一些(默认是3MHZ)，因为固化本身比较慢；设置SPI 的bus width，因为flash使用的是QSPI，也即SPI4x(后面还会设置此参数)，所以这里要设置为4选择编程模式，因为我们是将程序固化到flash中，以后上电自动从flash读取程序，所以这里要勾选上。JTAG是一直且默认勾选的。点击OK进行下一步。第三步：生成bit流第四步：生成.mcs内存配置文件点击OK，即可在指定的路径下生成所需的.mcs文件第五步：打开硬件管理器，连接开发板。第六步：往flash下载.mcs文件点击OK，然后出现下面的界面，等待下载完成即可。第七步：断电重启注意： 一定要注意将自己开发板上设置编程模式的跳线帽跳到QSPI模式。还有就是固化完成后，不会立即运行程序，需要断电重启，此时开发板会自动从flash读取程序并运行。这样以后每次上电都会自动加载并运行这段程序，除非再次固化别的程序！！！
-
Verilog RTL级低功耗设计-门控时钟及时钟树 在ASIC/FGPA设计中，我们外界控制所设计的模块时候需要实现告诉他，我要给你输入信号了,你的工作了，反之你不用工作，这个就是门控时钟，就是使能信号EN，一般来说我们用EN控制CLK的产生。芯片功耗组成中，有高达40%甚至更多是由时钟树消耗掉的。这个结果的原因也很直观，因为这些时钟树在系统中具有最高的切换频率，而且有很多时钟buffer，而且为了最小化时钟延时，它们通常具有很高的驱动强度。此外，即使输入和输出保持不变，接收时钟的触发器也会消耗一定的功耗。而且这些功耗主要是动态功耗。那么减少时钟网络的功耗消耗，最直接的办法就是如果不需要时钟的时候，就把时钟关掉。这种方法就是大家熟悉的门控时钟：clock gating。(大家电路图中看到的CG cell就是门控时钟了)1门控时钟的结构1.1与门门控如果让我们设计一个门控时钟的电路，我们会怎么设计呢？最直接的方法，不需要时钟的时候关掉时钟，这就是与操作，我们只需要把enable和CLK进行“与”操作不就行了么，电路图如下：这种直接将控制EN信号和时钟CLK进行与操作完成门控的方式，可以完成EN为0时，时钟被关掉。但是同时带来另外一个很大的问题：毛刺如上图所示，EN是不受控制的，随时可能跳变，这样纯组合输出GCLK就完全可能会有毛刺产生。时钟信号上产生毛刺是很危险的。实际中，这种直接与门的方式基本不会被采样。所以我们需要改进电路，为了使门控时钟不产生毛刺，我们必须对EN信号进行处理，使其在CLK的高低电平期间保持不变，或者说EN的变化就是以CLK为基准的。1 很自然的我们会想到触发器，只要把EN用CLK寄存一下，那么输出就是以CLK为基准的；2 其实还有一种办法是锁存器，把EN用锁存器锁存的输出，也是以CLK为基准的。1.2 锁存门控我们先看一下第二种电路，增加锁存器的电路如下：对应的时序如下：可以看到，只有在CLK为高的时候，GCLK才可能会输出高，这样就能消除EN带来的毛刺。这是因为D锁存器是电平触发，在clk=1时，数据通过D锁存器流到了Q；在Clk=0时，Q保持原来的值不变。虽然达到了我们消除毛刺的目的，但是这个电路还有两个缺点：1如果在电路中，锁存器与与门相隔很远，到达锁存器的时钟与到达与门的时钟有较大的延迟差别，则仍会出现毛刺。2 如果在电路中，时钟使能信号距离锁存器很近，可能会不满足锁存器的建立时间，会造成锁存器输出出现亚稳态。如下图分析所示：上述的右上图中，B点的时钟比A时钟迟到，并且Skew > delay，这种情况下，产生了毛刺。为了消除毛刺，要控制Clock Skew，使它满足Skew ENsetup 一 (D->Q)，这种情况下，也产生了毛刺。为了消除毛刺，要控制Clock Skew，使它满足|Skew|< ENsetup一(D->Q)。1.3 寄存门控如1.1中提到的，我们还有另外的解决办法，就是用寄存器来寄存EN信号再与上CLK得到GCLK，电路图如下所示：时序如下所示：由于DFF输出会delay一个周期，所以除非CLKB上升沿提前CLKA很多，快半个周期，才会出现毛刺，而这种情况一般很难发生。但是，这种情况CLKB比CLKA迟到，是不会出现毛刺的。当然，如果第一个D触发器不能满足setup时间，还是有可能产生亚稳态。1.4 门控时钟结构选择那么到底采用哪一种门控时钟的结构呢？是锁存结构还是寄存结构呢？通过分析，我们大概会选择寄存器结构的门控时钟，这种结构比锁存器结构的问题要少，只需要满足寄存器的建立时间就不会出现问题。那么实际中是这样么？答案恰恰相反，SOC芯片设计中使用最多的却是锁存结构的门控时钟。原因是:在实际的SOC芯片中，要使用大量的门控时钟单元。所以通常会把门控时钟做出一个标准单元，有工艺厂商提供。那么锁存器结构中线延时带来的问题就不存在了，因为是做成一个单元，线延时是可控和不变的。而且也可以通过挑选锁存器和增加延时，总是能满足锁存器的建立时间，这样通过工艺厂预先把门控时钟做出标准单元，这些问题都解决了。那么用寄存器结构也可以达到这种效果，为什么不用寄存器结构呢？那是因为面积！一个DFF是由两个D锁存器组成的，采样D锁存器组成门控时钟单元，可以节省一个锁存器的面积。当大量的门控时钟插入到SOC芯片中时，这个节省的面积就相当可观了。所以，我们在工艺库中看到的标准门控时钟单元就是锁存结构了：当然，这里说的是SOC芯片中使用的标准库单元。如果是FPGA或者用RTL实现，个人认为还是用寄存器门控加上setup约束来实现比较稳妥。门控时钟代码always@(CLK or CLK_EN) if(!CLK) CLK_TEMP<=CLK_EN assign GCLK=CLK&CLK_TEMP2 RTL中的门控时钟通常情况下，时钟树由大量的缓冲器和反相器组成，时钟信号为设计中翻转率最高的信号，时钟树的功耗可能高达整个设计功耗40%。加入门控时钟电路后，由于减少了时钟树的翻转，节省了翻转功耗。同时，由于减少了寄存器时钟引脚的翻转行为，寄存器的内部功耗也减少了。采用门控时钟，可以非常有效地降低设计的功耗，一般情况下能够节省20%~60%的功耗。那么RTL中怎么才能实现门控时钟呢？答案是不用实现。现在的综合工具比如DC会自动插入门控时钟。如下图所示：这里有两点需要注意：插入门控时钟单元后，上面电路中的MUX就不需要了，如果数据D是多bit的（一般都是如此），插入CG后的面积可能反而会减少；如果D是单bit信号，节省的功耗就比较少，但是如果D是一个32bit的信号，那么插入CG后节省的功耗就比较多了。这里的决定因素就是D的位宽了，如果D的位宽很小，那么可能插入的CG面积比原来的MUX大很多，而且节省的功耗又很少，这样得不偿失。只有D位宽超过了一定的bit数后，插入CG的收益就比较大。那么这个临界值是多少呢？不同的工艺可能不一样，但是DC给的默认值是3.也就是说，如果D的位宽超过了3bit，那么DC就会默认插入CG，这样综合考虑就会有收益。我们可以通过DC命令：set_clock_gating_style -minimum_bitwidth 4来控制芯片中，对不同位宽的寄存器是否自动插入CG。一般情况都不会去修改它。附加：门控时钟的时钟树设计在时钟树的设计中，门控时钟单元应尽量摆放在时钟源附近，即防止在门控时钟单元的前面摆放大量的时钟缓冲器(Buffer)。 这样，在利用门控时钟电路停时钟时不仅能将该模块中的时钟停掉，也能将时钟树上的时钟缓冲器停止反转,有效地控制了时钟树上的功耗。如图11-24所示，在布局时将门控时钟电路的部件摆放在一起，并摆放在时钟源GCLK附近，停掉时钟后，整个时钟树_上的缓冲器(CTS)和时钟树驱动的模块都停止了翻转。通常的SoC设计中，门控时钟单元会被做成一个硬核或标准单元。3 RTL 门控时钟编码风格组合逻辑中，为避免生成锁存器，好的代码风格是if语句都加上else，case语句都加上default。时序逻辑中，为了让综合工具能够自动生成门控时钟，好的代码风格则是“若无必要，尽量不加else和default”——以减小数据翻转机会。虽然现在综合工具可以自动插入门控时钟，但是如果编码风格不好，也不能达到自动插入CG的目的。比较下面两种RTL写法：左边的RTL代码能够成功的综合成自动插入CG的电路；右边的RTL不能综合成插入CG的电路；右边电路在d_valid为低时，d_out也会一直变化，其实没有真正的数据有效的指示信号，所以综合不出来插入CG的电路。需要注意的是，有的前端设计人员，为了仿真的时候看的比较清楚，很容易会写成右边的代码，这样不仅不能在综合的时候自动插入CG来减少功耗；而且增加了d_out的翻转率，进一步增加了功耗。在不用的时候把数据设成0并不能减少功耗，保持数据不变化才能减少toggle，降低功耗！所以我们在RTL编写的时候一定要注意。作为前端设计者，了解这些知识就足够了，如果想深入了解综合的控制，可以去了解set_clock_gating_style 这个核心控制命令后记门控时钟是低功耗技术的一种常规方法，应用已经很成熟了，所以很多人会忽视它的存在和注意事项，也不了解它的具体时序。本文从SOC前端设计的角度详细解释了各种门控时钟的结构和RTL编码需要注意的事项，希望能对设计人员有所帮助。
-
I2C协议及verilog实现-串口读写 EEPROM I2C 基本概念I2C 总线（I2C bus，Inter-IC bus）是一个双向的两线连续总线，提供集成电路（ICs）之间的通信线路。I2C 总线是一种串行扩展技术，最早由 Philips 公司推出，广泛应用于电视，录像机和音频设备。I2C 总线的意思是“完成集成电路或功能单元之间信息交换的规范或协议”。Philips 公司推出的 I2C 总线采用一条数据线（SDA），加一条时钟线（SCL）来完成数据的传输及外围器件的扩展。I2C 总线物理拓扑结构如图 30.1 所示。I2C 总线在物理连接上比较简单，分别由 SDA(串行数据线)和 SCL(串行时钟线)两条总线及上拉电阻组成。通信的原理是通过控制 SCL 和 SDA 的时序，使其满足 I2C 的总线协议从而进行数据的传输。I2C 总线上的每一个设备都可以作为主设备或者从设备，而且每一个设备都会对应一个唯一的地址(可以从 I2C 器件数据手册得知)，主从设备之间就是通过这个地址来确定与哪个器件进行通信。本次实验我们把 FPGA 作为主设备，把挂载在总线上的其他设备（如 EEPROM、PFC8563 等 I2C 器件）作为从设备。I2C 总线数据传输速率在标准模式下可达 100kbit/s，快速模式下可达 400kbit/s，高速模式下可达 3.4Mbit/s。I2C 总线上的主设备与从设备之间以字节(8 位)为单位进行双向的数据传输。I2C 协议时序介绍I2C 协议整体时序图如图 30.2 所示I2C 协议整体时序说明如下：（1） 总线空闲状态：SDA 为高电平，SCL 为高电平；（2） I2C 协议起始位：SCL 为高电平时，SDA 出现下降沿，产生一个起始位；（3） I2C 协议结束位：SCL 为高电平时，SDA 出现上升沿，产生一个结束位；（4） I2C 读写数据状态：主要包括数据的串行输出输入和数据接收方对数据发送方的响应信号。具体时序如图 30.3 所示。当 I2C 主机（后面简称主机）向 I2C 从机（后面简称从机）写入数据时，SDA 上的每一位数据在 SCL 的高电平期间被写入从机中。从主机角度来看，需要在 SCL 低电平期间改变要写入的数据。而当主机读取从机中数据时，从机在 SCL 低电平期间将数据输出到 SDA 总线上，在 SCL 的高电平期间保持数据稳定，从主机角度来看，需要在 SCL 的高电平期间将 SDA 线上的数据读取并存储。每当一个字节的数据或命令传输完成时，数据接收方都会向发送方响应一位应答位。在响应应答位时，数据发出方将 SDA 总线设置为三态输入，由于 I2C 总线上都有上拉电阻，因此此时总线默认为高电平，若数据接收方正确接收到数据，则数据接收方将 SDA 总线拉低，以示正确应答。例如当主机向从机写入数据或命令时，每个字节都需要从机产生应答信号以告诉主机此次的数据或命令是否成功被写入。所以，当主机将一字节的数据或命令传出后，会将 SDA 信号设置为三态输入，等待从机应答（等待 SDA 被从机拉低为低电平），若从机正确应答，表明当前数据或命令传输成功，可以结束或开始下一个数据或命令的传输，否则表明数据或命令写入失败，主机就可以决定是否放弃写入或者重新发起写入。inout信号原理I2C 器件地址每个 I2C 器件都有一个器件地址，有的器件地址在出厂时地址就设置好了，用户不可以更改（例如 OV7670 器件地址为固定的 0x42），有的确定了几位，剩下几位由硬件确定（比如常见的 I2C 接口的 EEPROM 存储器，留有 3 个控制地址的引脚，由用户自己在硬件设计时确定）。严格讲，主机不是直接向从机发送地址，而是主机往总线上发送地址，所有的从机都能接收到主机发出的地址，然后每个从机都将主机发出的地址与自己的地址比较，如果匹配上了，这个从机就会向主机发出一个响应信号。主机收到响应信号后，开始向总线上发送数据，与这个从机的通讯就建立起来了。如果主机没有收到响应信号，则表示寻址失败。通常情况下，主从器件的角色是确定的，也就是说从机一直工作在从机模式。不同器件定义地址的方式是不同的，有的是软件定义，有的是硬件定义。例如某些单片机的I2C 接口作为从机时，其器件地址是可以通过软件修改从机地址寄存器确定的。而对于一些其他器件，如 CMOS 图像传感器、EEPROM 存储器，其器件地址在出厂时就已经设定好了，具体值可以在对应的数据手册中查到。对于 AT24C64 这样一颗 EEPROM 器件，其器件地址为 1010 加 3 位的片选信号。3位片选信号由硬件连接决定。例如 SOIC 封装的该芯片 PIN1、PIN2、PIN3 为片选地址。当硬件电路上分别将这三个 pin 连接到 GND 或 VCC 时，就可以设置不同的片选地址。I2C 协议在进行数据传输时，主机需要首先向总线上发出控制命令，其中，控制命令就包含了从机地址/片选信号+读写控制。然后等待从机响应。如图 30.4 所示为 I2C 控制命令传输的数据格式。I2C 传输时，按照从高到低的位序进行传输。控制字节的最低位为读写控制位，当该位为 0 时表示主机对从机进行写操作，当该位为 1 时表示主机对从机进行读操作。例如，当需要对片选地址为 100 的 AT24LC64 发起写操作，则控制字节应该为 1010_100_0。若进行读操作，则控制字节应该为 1010_100_1。I2C 存储器地址每个支持 I2C 协议的器件，内部总会有一些可供读写的寄存器或存储器，例如，对于我们用到的 EEPROM 存储器，内部就是顺序编址的一系列存储单元。对于我们常接触的 CMOS 摄像头如 OV7670（OV7670 的该接口叫 SCCB 接口，其实质也是一种特殊的 I2C协议，可以直接兼容 I2C 协议），其内部就是一系列编址的可供读写的寄存器。因此，我们要对一个器件中的存储单元（寄存器和存储器以下简称存储单元）进行读写，就必须要能够指定存储单元的地址。I2C 协议设计了有从机存储单元寻址地址段，该地址段为一个字或两个字节长度，在主机确认收到从机返回的控制字节响应后由主机发出。地址段长度视不同的器件类型，长度不同，例如同是 EEPROM 存储器，AT24C04 的址段长度为一个字节，而 AT24C64 的地址段长度为两个字节。具体是一个字节还是两个字节，与器件的存储单元数量有关。如图 30.5 和图 30.6 分别为 1 字节地址和 2 字节地址器件的地址分布图，其中 1 字节地址的器件是以内存为 1kbit 的 EEPROM 存储器 AT24C01 举例，2 字节地址的器件是以内存为 64kbit 的 EEPROM 存储器 AT24C64 举例的。I2C 单字节写时序根据前面讲的，不同器件，I2C 器件地址字节不同，这样对于 I2C 单字节写时序就会有所差别，图 30.7 和图 30.8 分别为 1 字节地址段器件和 2 字节地址段器件单字节写时序图。根据时序图，从主机角度来描述一次写入单字节数据过程如下：a. 主机设置 SDA 为输出；b. 主机发起起始信号；c. 主机传输器件地址字节，其中最低位为 0，表明为写操作；d. 主机设置 SDA 为三态门输入，读取从机应答信号；e. 读取应答信号成功，主机设置 SDA 为输出，传输 1 字节地址数据；f. 主机设置 SDA 为三态门输入，读取从机应答信号；g. 读取应答信号成功，对于两字节地址段器件，传输地址数据低字节，对于 1 字节地址段器件，主机设置 SDA 为输出，传输待写入的数据；h. 设置 SDA 为三态门输入，读取从机应答信号，对于两字节地址段器件，接着步骤 i；对于 1 字节地址段器件，直接跳转到步骤 k；i. 读取应答信号成功，主机设置 SDA 为输出，传输待写入的数据（对于两字节地址段器件）；j. 设置 SDA 为三态门输入，读取从机应答信号（两字节地址段器件）；k. 读取应答信号成功，主机产生 STOP 位，终止传输。I2C 连续写时序（页写时序）注：I2C 连续写时序仅部分器件支持。 连续写是主机连续写多个字节数据到从机，这个和单字节写操作类似，连续多字节写操作也是分为 1 字节地址段器件和 2 字节地址段器件的写操作，图 30.9 和图 30.10 分别为 1 字节地址段器件和 2 字节地址段器件连续多字节写时序图。根据时序图，从主机角度来描述一次写入多字节数据过程如下：a. 主机设置 SDA 为输出；b. 主机发起起始信号；c. 主机传输器件地址字节，其中最低位为 0，表明为写操作；d. 主机设置 SDA 为三态门输入，读取从机应答信号；e. 读取应答信号成功，主机设置 SDA 为输出，传输 1 字节地址数据；f. 主机设置 SDA 为三态门输入，读取从机应答信号；g. 读取应答信号成功后，主机设置 SDA 为输出，对于两字节地址段器件，传输低字节地址数据，对于 1 字节地址段器件，传输待写入的第 1 个数据h. 设置 SDA 为三态门输入，读取从机应答信号，对于两字节地址段器件，接着步骤 i；对于 1 字节地址段器件，直接跳转到步骤 k；i. 读取应答信号成功后，主机设置 SDA 为输出，传输待写入的第 1 个数据（两字节地址段器件）；j. 设置 SDA 为三态门输入，读取从机应答信号（两字节地址段器件）；k. 读取应答信号成功后，主机设置 SDA 为输出，传输待写入的下一个数据；l. 设置 SDA 为三态门输入，读取从机应答信号；n 个数据被写完，转到步骤 m，若数据未被写完，转到步骤 k；m. 读取应答信号成功后，主机产生 STOP 位，终止传输。注：对于 AT24Cxx 系列的 EEPROM 存储器，一次可写入的最大长度为 32 字节。I2C 单字节读时序同样的，I2C 读操作时序根据不同 I2C 器件具有不同的器件地址字节数，单字节读操作分为 1 字节地址段器件单节数据读操作和 2 字节地址段器件单节数据读操作。图30.11 和图 30.12 分别为不同情况的时序图。根据时序图，从主机角度描述一次读数据过程，如下：a. 主机设置 SDA 为输出；b. 主机发起起始信号；c. 主机传输器件地址字节，其中最低位为 0，表明为写操作；d. 主机设置 SDA 为三态门输入，读取从机应答信号；e. 读取应答信号成功，主机设置 SDA 输出，传输 1 字节地址数据；f. 主机设置 SDA 为三态门输入，读取从机应答信号；g. 读取应答信号成功，主机设置 SDA 输出，对于两字节地址段器件，传输低字节地址数据；对于 1 字节地址段器件，无此步骤，直接跳转到步骤 h；h. 主机发起起始信号；i. 主机传输器件地址字节，其中最低位为 1，表明为读操作；j. 设置 SDA 为三态门输入，读取从机应答信号；k. 读取应答信号成功，主机设置 SDA 为三态门输入，读取 SDA 总线上的一个字节的数据；l. 产生无应答信号（高电平）（无需设置为输出高电平，因为总线会被自动拉高）；m. 主机产生 STOP 位，终止传输。I2C 连续读时序（页读取）连续读是主机连续从从机读取多个字节数据，这个和单字节读操作类似，连续多字节读操作也是分为 1 字节地址段器件和 2 字节地址段器件的读操作，图 30.13 和图 30.14 分别为 1 字节地址段器件和 2 字节地址段器件连续多字节读时序图。根据时序图，从主机角度描述多字节数据读取过程如下：a. 主机设置 SDA 为输出b. 主机发起起始信号c. 主机传输器件地址字节，其中最低位为 0，表明为写操作。d. 主机设置 SDA 为三态门输入，读取从机应答信号。e. 读取应答信号成功，主机设置 SDA 输出，传输 1 字节地址数据f. 主机设置 SDA 为三态门输入，读取从机应答信号。g. 读取应答信号成功，主机设置 SDA 输出，对于两字节地址段器件，传输低字节地址数据；对于 1 字节地址段器件，无此步骤；直接跳转到步骤h；h. 主机发起起始信号；i. 主机传输器件地址字节，其中最低位为 1，表明为读操作；j. 设置 SDA 为三态门输入，读取从机应答信号；k. 设置 SDA 为三态门输入，读取 SDA 总线上的第 1 个字节的数据；l. 主机设置 SDA 输出，发送一位应答信号；m. 设置 SDA 为三态门输入，读取 SDA 总线上的下一个字节的数据；若 n 个字节数据读完成，跳转到步骤 n，若数据未读完，跳转到步骤 l；（对于 AT24Cxx，一次读取长度最大为 32 字节，即 n 不大于 32）n. 主机设置 SDA 输出，产生无应答信号（高电平）（无需设置为输出高电平，因为总线会被自动拉高）；o. 主机产生 STOP 位，终止传输。I2C 读写器件控制程序通过上述的讲述，对 I2C 读写器件数据时序有了一定的了解，下面将开始进行控制程序的设计。根据上面 I2C 的基本概念中有关读写时 SDA 与 SCL 时序，不管对于从机还是主机，SDA 上的每一位数据在 SCL 的高电平期间保持不变，而数据的改变总是在 SCL的低电平期间发生。因此，我们可以选用 2 个标志位对时钟 SCL 的高电平和低电平进行标记，如下图所示：scl_high 对 SCL 高电平期间进行标志，scl_low 对 SCL 低电平期间进行标志。这样就可以在 scl_high 有效时读 SDA 数据，在 scl_low 有效时改变数据。scl_high和 scl_low 产生的时序图如图 30.15 所示。在本实验中，时钟信号 SCL 采用计数器方法产生，计数器最大计数值为系统时钟频率除以 SCL 时钟频率，即：SCL_CNT_M = SYS_CLOCK/SCL_CLOCK。对于 scl_high 和 scl_low则只需要分别在计数到四分之一的最大值和四分之三的最大值时产生标志位即可，具体的时钟信号 SCL 和标志信号 scl_high、scl_low 产生实现代码如下：//系统时钟采用 50MHz parameter SYS_CLOCK = 50_000_000; //SCL 总线时钟采用 400kHz parameter SCL_CLOCK = 400_000; //产生时钟 SCL 计数器最大值 localparam SCL_CNT_M = SYS_CLOCK/SCL_CLOCK; reg [15:0]scl_cnt; //SCL 时钟计数器 reg scl_vaild; //I2C 非空闲时期 reg scl_high; //SCL 时钟高电平中部标志位 reg scl_low; //SCL 时钟低电平中部标志位 //I2C 非空闲时期 scl_vaild 的产生 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) scl_vaild <= 1'b0; else if(Wr | Rd) scl_vaild <= 1'b1; else if(Done) scl_vaild <= 1'b0; else scl_vaild <= scl_vaild; end //scl 时钟计数器 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) scl_cnt <= 16'd0; else if(scl_vaild)begin if(scl_cnt == SCL_CNT_M - 1) scl_cnt <= 16'd0; else scl_cnt <= scl_cnt + 16'd1; end else scl_cnt <= 16'd0; end //scl 时钟,在计数器值到达最大值一半和 0 时翻转 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) Scl <= 1'b1; else if(scl_cnt == SCL_CNT_M >>1) Scl <= 1'b0; else if(scl_cnt == 16'd0) Scl <= 1'b1; else Scl <= Scl; end //scl 时钟高低电平中部标志位 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) scl_high <= 1'b0; else if(scl_cnt == (SCL_CNT_M>>2)) scl_high <= 1'b1; else scl_high <= 1'b0; end //scl 时钟低电平中部标志位 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) scl_low <= 1'b0; else if(scl_cnt == (SCL_CNT_M>>1)+(SCL_CNT_M>>2)) scl_low <= 1'b1; else scl_low <= 1'b0; end上述代码中 Wr 和 Rd 信号为 I2C 进行一次写和读操作的门控使能信号，Done 信号为一次I2C写和读操作完成标志位。（SCL_CNT_M>>2）和(SCL_CNT_M>>1)+(SCL_CNT_M>>2)分别为 1/2 的 SCL_CNT_M 和 3/4 的 SCL_CNT_M 的计数值。在 SCL 时钟总线以及其高低电平标志位产生完成后，接下来的事情就是 SDA 数据线的产生，这个需要根据具体的读写操作时序完成。本实验主要采用状态机实现，根据上面讲述的读写数据的时序关系，设计了如图 30.16 所示的状态转移图，其状态机状态编码采用独热编码，若需要改变状态编码形式，只需改变程序中的 parameter 定义即可。根据上面 I2C 基本概念可知，不同的器件其寄存器地址字节数分为 1 字节或和 2 字节地址段，并且有些 I2C 器件是支持多字节的数据读写，所以在设计时考虑到该 I2C 控制器的通用性，我们将设计寄存器地址字节和读取数据个数均可自行设置的 I2C 控制器，用户可根据自己的实际应用情况设置选择与器件对应的寄存器地址字节数或是读写数据的字节数。寄存器地址字节数的可变主要是通过一个计数器对字节数进行计数，当计数值达到指定值后跳转到下一状态，具体的可参见代码。在状态机中，从主机角度来看，SDA 数据线上在写控制、写数据、读控制状态过程是需要串行输出数据，而在读数据状态过程是需要串行输入数据。根据数据在时钟高电平期间保持不变，改变数据在低电平时期的规则，本设计对时钟信号的高低电平进行计数，从而在指定的计数值进行输出或读取数据实现数据的串行输出和串行输入。串行输出和串行输入数据采用任务的形式进行表示，便于在主状态机中多次的调用。图 30.17为计数的过程以及特定状态变化的时序图，这里的特定状态主要是指读/写控制、读/写地址和读/写数据状态。图 30.17 中计数器 halfbit_cnt 和数据接收方对发送的响应检测标志位 ack 以及串行输出、输入数据任务的具体代码如下： //sda 串行接收与发送时 scl 高低电平计数器 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) halfbit_cnt <= 8'd0; else if((main_state == WR_CTRL)|| (main_state == WR_WADDR)|| (main_state == WR_DATA)|| (main_state == RD_CTRL)|| (main_state == RD_DATA))begin if(scl_low | scl_high)begin if(halfbit_cnt == 8'd17) halfbit_cnt <= 8'd0; else halfbit_cnt <= halfbit_cnt + 8'd1; end else halfbit_cnt <= halfbit_cnt; end else halfbit_cnt <= 8'd0; end //数据接收方对发送的响应检测标志位 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) ack <= 1'b0; else if((halfbit_cnt == 8'd16)&&scl_high&&(Sda==1'b0)) ack <= 1'b1; else if((halfbit_cnt == 8'd17)&&scl_low) ack <= 1'b0; else ack <= ack; end //输出串行数据任务 task send_8bit_data; if(scl_high && (halfbit_cnt == 8'd16)) FF <= 1; else if(halfbit_cnt < 8'd17)begin sda_reg <= sda_data_out[7]; if(scl_low) sda_data_out <= ; else sda_data_out <= sda_data_out; end else ; endtask //串行数据输入任务 task receive_8bit_data; if(scl_low && (halfbit_cnt == 8'd15)) FF <= 1; else if((halfbit_cnt < 8'd15))begin if(scl_high) sda_data_in <= ; else begin sda_data_in <= sda_data_in; end end else ; endtask对于计数器 halfbit_cnt 只在写控制、写数据、读控制、读数据状态下才进行计数，其他状态为零。代码中 FF 是进行串行输出或输入任务的标志位，当 FF 为 1 时表示退出任务，FF 为 0 时表示进入任务。这样便于在状态机中对任务的调用，以及在指定的时间退出任务。接下来就是主状态机的设计，主状态机的状态转移图上面已经给出，具体转移过程是依据 I2C 读写时序进行的，代码如下：//主状态机 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n)begin main_state <= IDLE; sda_reg <= 1'b1; W_flag <= 1'b0; R_flag <= 1'b0; Done <= 1'b0; waddr_cnt <= 2'd1; wdata_cnt <= 8'd1; rdata_cnt <= 8'd1; end else begin case(main_state) IDLE:begin sda_reg <= 1'b1; W_flag <= 1'b0; R_flag <= 1'b0; Done <= 1'b0; waddr_cnt <= 2'd1; wdata_cnt <= 8'd1; rdata_cnt <= 8'd1; if(Wr)begin main_state <= WR_START; W_flag <= 1'b1; end else if(Rd)begin main_state <= WR_START; R_flag <= 1'b1; end else main_state <= IDLE; end WR_START:begin if(scl_low)begin main_state <= WR_CTRL; sda_data_out <= wr_ctrl_word; FF <= 1'b0; end else if(scl_high)begin sda_reg <= 1'b0; main_state <= WR_START; end else main_state <= WR_START; end WR_CTRL:begin if(FF == 1'b0) send_8bit_data; else begin if(ack == 1'b1) begin//收到响应 if(scl_low)begin main_state <= WR_WADDR; FF <= 1'b0; if(Wdaddr_num == 2'b1) sda_data_out <= Word_addr[7:0]; else sda_data_out <= Word_addr[15:8]; end else main_state <= WR_CTRL; end else//未收到响应 main_state <= IDLE; end end WR_WADDR:begin if(FF == 1'b0) send_8bit_data; else begin if(ack == 1'b1) begin//收到响应 if(waddr_cnt == Wdaddr_num)begin if(W_flag && scl_low)begin main_state <= WR_DATA; sda_data_out <= Wr_data; waddr_cnt <= 2'd1; FF <= 1'b0; end else if(R_flag && scl_low)begin main_state <= RD_START; sda_reg <= 1'b1; end else main_state <= WR_WADDR; end else begin if(scl_low)begin waddr_cnt <= waddr_cnt + 2'd1; main_state <= WR_WADDR; sda_data_out <= Word_addr[7:0]; FF <= 1'b0; end else main_state <= WR_WADDR; end end else//未收到响应 main_state <= IDLE; end end WR_DATA:begin if(FF == 1'b0) send_8bit_data; else begin if(ack == 1'b1) begin//收到响应 if(wdata_cnt == Wrdata_num)begin if(scl_low)begin main_state <= STOP; sda_reg <= 1'b0; wdata_cnt <= 8'd1; end else main_state <= WR_DATA; end else begin if(scl_low)begin wdata_cnt <= wdata_cnt + 8'd1; main_state <= WR_DATA; sda_data_out <= Wr_data; FF <= 1'b0; end else main_state <= WR_DATA; end end else//未收到响应 main_state <= IDLE; end end RD_START:begin if(scl_low)begin main_state <= RD_CTRL; sda_data_out <= rd_ctrl_word; FF <= 1'b0; end else if(scl_high)begin main_state <= RD_START; sda_reg <= 1'b0; end else main_state <= RD_START; end RD_CTRL:begin if(FF == 1'b0) send_8bit_data; else begin if(ack == 1'b1) begin//收到响应 if(scl_low)begin main_state <= RD_DATA; FF <= 1'b0; end else main_state <= RD_CTRL; end else//未收到响应 main_state <= IDLE; end end RD_DATA:begin if(FF == 1'b0) receive_8bit_data; else begin if(rdata_cnt == Rddata_num)begin sda_reg <= 1'b1; if(scl_low)begin main_state <= STOP; sda_reg <= 1'b0; end else main_state <= RD_DATA; end else begin sda_reg <= 1'b0; if(scl_low)begin rdata_cnt <= rdata_cnt + 8'd1; main_state <= RD_DATA; FF <= 1'b0; end else main_state <= RD_DATA; end end end STOP:begin//结束操作 if(scl_high)begin sda_reg <= 1'b1; main_state <= IDLE; Done <= 1'b1; end else main_state <= STOP; end default: main_state <= IDLE; endcase end end主状态机完成后，I2C 控制器设计的大块就解决了，剩下的就是 SDA 数据线的输出了，该数据线采用三态使能输出，具体代码如下:assign Sda = sda_en ? sda_reg : 1'bz;对于使能信号 sda_en 按照上面的时序关系图可知，该信号在不同的状态，其高低电平变化的时刻是有差别的，比如在开始和结束状态，它是一直为高电平的，在写控制、写数据、读控制状态，它是在串行输出一字节数据期间（即 halfbit_cnt < 16 时）为高电平，之外的一个数据为位低电平，而在读数据状态时串行输入一字节数据期间（即halfbit_cnt < 16 时）为低电平电平，之外的一个数据位为高电平。具体代码如下： //SDA 三态使能信号 sda_en always@(*) begin case(main_state) IDLE: sda_en = 1'b0; WR_START,RD_START,STOP: sda_en = 1'b1; WR_CTRL,WR_WADDR,WR_DATA,RD_CTRL: if(halfbit_cnt < 16) sda_en = 1'b1; else sda_en = 1'b0; RD_DATA: if(halfbit_cnt < 16) sda_en = 1'b0; else sda_en = 1'b1; default: sda_en = 1'b0; endcase end本实验设计考虑到了多字节数据的读取情况，所以增加了数据读取和数据写入时的有效标志位信号。主要是标志读取数据时数据有效时刻和写数据时提供待写入数据时刻。具体代码如下： //写数据有效标志位 assign Wr_data_vaild = ((main_state==WR_WADDR)&& (waddr_cnt==Wdaddr_num)&& (W_flag && scl_low)&& (ack == 1'b1))|| ((main_state == WR_DATA)&& (ack == 1'b1)&&(scl_low)&& (wdata_cnt != Wrdata_num)); //读数据有效标志位前寄存器 assign rdata_vaild_r = (main_state == RD_DATA) &&(halfbit_cnt == 8'd15)&&scl_low; //读出数据有效标志位 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) Rd_data_vaild <= 1'b0; else if(rdata_vaild_r) Rd_data_vaild <= 1'b1; else Rd_data_vaild <= 1'b0; end //读出的有效数据 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) Rd_data <= 8'd0; else if(rdata_vaild_r) Rd_data <= sda_data_in; else Rd_data <= Rd_data; end到目前为止，整个 I2C 控制器的设计就完成了，接下来就进入仿真环节，我们需要EEPROM 的仿真模型进行仿真，这样能更好的检验 I2C 控制器设计的是否存在问题，以便后面进行优化改进。本实验采用的是镁光官网提供的 EEPROM 仿真模型，具体下载网址 为 http://www.microchip.com/zh/design-centers/memory/serial-eeprom/verilog-ibis-models，我们选择两个具有代表性的模型进行仿真，分别为 1 字节寄存器地址段的 24LC04B 和 2 字节寄存器地址段的 24LC64 仿真模型，利用这两个模型对我们设计的 I2C 控制器进行仿真。如图 30.18 为仿真验证的结构框图。这里我们对 1 字节寄存器地址段的 24LC04B 和 2 字节寄存器地址段的 24LC64 仿真模型的器件地址分别设置为 3’b001 和 3’b000，仿真时为了能分别对不同型号的模型进行仿真，在编写的 testbench 文件中采用了申明方法去选择当前使用哪个模型进行仿真，具体代码如下：`timescale 1ns/1ns `define CLK_PERIOD 20 //仿真模型选择 //`define TEST_M24LC64 //24LC64 `define TEST_M24LC04 //24LC04 module I2C_tb; reg Clk; //系统时钟 reg Rst_n; //系统复位信号 reg [15:0] Word_addr; //I2C 器件寄存器地址 reg Wr; //I2C 器件写使能 reg [7:0] Wr_data; //I2C 器件写数据 wire Wr_data_vaild;//I2C 器件写数据有效标志位 reg Rd; //I2C 器件读使能 wire[7:0] Rd_data; //I2C 器件读数据 wire Rd_data_vaild;//I2C 器件读数据有效标志位 wire Scl; //I2C 时钟线 wire Sda; //I2C 数据线 wire Done; //对 I2C 器件读写完成标识位 localparam NUM = 6'd4; //单次读写数据字节数 `ifdef TEST_M24LC64 localparam DevAddr = 3'b000; //I2C 器件的器件地址 localparam WdAr_NUM= 2; //I2C 器件的存储器地址字节数 `elsif TEST_M24LC04 localparam DevAddr = 3'b001; //I2C 器件的器件地址 localparam WdAr_NUM= 1; //I2C 器件的存储器地址字节数 `endif I2C I2C( .Clk(Clk), .Rst_n(Rst_n), .Rddata_num(NUM), .Wrdata_num(NUM), .Wdaddr_num(WdAr_NUM), .Device_addr(DevAddr), .Word_addr(Word_addr), .Wr(Wr), .Wr_data(Wr_data), .Wr_data_vaild(Wr_data_vaild), .Rd(Rd), .Rd_data(Rd_data), .Rd_data_vaild(Rd_data_vaild), .Scl(Scl), .Sda(Sda), .Done(Done) ); `ifdef TEST_M24LC64 M24LC64 M24LC64( .A0(1'b0), .A1(1'b0), .A2(1'b0), .WP(1'b0), .SDA(Sda), .SCL(Scl), .RESET(!Rst_n) ); `elsif TEST_M24LC04 M24LC04B M24LC04( .A0(1'b1), .A1(1'b0), .A2(1'b0), .WP(1'b0), .SDA(Sda), .SCL(Scl), .RESET(!Rst_n) ); `endif //系统时钟产生 initial Clk = 1'b1; always #(`CLK_PERIOD/2)Clk = ~Clk; initial begin Rst_n = 0; Word_addr = 0; Wr = 0; Wr_data = 0; Rd = 0; #(`CLK_PERIOD*200 + 1) Rst_n = 1; #200; `ifdef TEST_M24LC64 //仿真验证 24LC64 模型 //写入 20 组数据 Word_addr = 0; Wr_data = 0; repeat(20)begin Wr = 1'b1; #(`CLK_PERIOD); Wr = 1'b0; repeat(NUM)begin //在写数据有效前给待写入数据 @(posedge Wr_data_vaild) Wr_data = Wr_data + 1; end @(posedge Done); #2000; Word_addr = Word_addr + NUM; end #2000; //读出刚写入的 20 组数据 Word_addr = 0; repeat(20)begin Rd = 1'b1; #(`CLK_PERIOD); Rd = 1'b0; @(posedge Done); #2000; Word_addr = Word_addr + NUM; end `elsif TEST_M24LC04 //仿真验证 24LC04 模型 //写入 20 组数据 Word_addr = 100; Wr_data = 100; repeat(20)begin Wr = 1'b1; #(`CLK_PERIOD); Wr = 1'b0; repeat(NUM)begin //在写数据有效前给待写入数据 @(posedge Wr_data_vaild) Wr_data = Wr_data + 1; end @(posedge Done); #2000; Word_addr = Word_addr + NUM; end #2000; //读出刚写入的 20 组数据 Word_addr = 100; repeat(20)begin Rd = 1'b1; #(`CLK_PERIOD); Rd = 1'b0; @(posedge Done); #2000; Word_addr = Word_addr + NUM; end `endif #5000; $stop; end endmodule在 testbench 文件中，通过对 EEPROM 模型进行 20 写操作，每次写字节数为NUM，然后对 EEPROM 模型在刚写入数据的地址段进行读操作，通过比较读出和写入的数据验证 I2C 控制器设计是否正确。这里分别通过申明选择 TEST_M24LC64 或TEST_M24LC04 来作为当前的仿真模型。如图 30.19 所示为 2 字节地址的 EEPROM模型 24LC64 仿真结果。图 30.20 和图 30.21 分别为型号 24LC64 仿真模型写操作时序和读操作时序放大后的波形图。同样的方式选择 24LC04 型号 EEPROM 模型进行仿真，如图 30.22 所示为 1 字节地址的 EEPROM 模型 24LC604 仿真结果。图 30.23 和图 30.24 分别为型号24LC604 仿真模型写操作时序和读操作时序放大后的波形图。通过观察图 30.21 和图 30.24 的时序波形发现，在读操作时序结果中，读出的数据中某些位是高阻态，仔细观察波形可知，高阻态的位置正好是需要输出高电平的位置，这个的原因是 EEPROM 的仿真模型是完全与实际的器件是一样的，对于器件来说，只在输出 0 时将数据线拉低，而在高阻态或本应该为高电平的时刻都是设置为高阻态的，这个在仿真模型的代码中也有体现，具体体现这一点的代码如下： bufif1 (SDA, 1'b0, SDA_DriveEnableDlyd);其中，器件地址包括器件的地址字节数和 3 位的器件地址，具体分配如下：功能码主要是区分是写数据操作还是读数据操作，为了方便，我们直接规定，功能码为 0xf1 表示写数据操作，0xf2 表示读数据操作；起始地址是我们要读写数据的第一个地址；数据字节数表示要写入或读取的数据的字节个数，后面的数据 1 到数据n 表示要写入的 n 个数据，对于读操作没有这部分。如图 30.25 为该实验整体的设计框图。有关串口发送和接收以及 fifo 模块在前面章节都已经进行了讲解，这里就不重复讲解了，这里重点讲解命令解析模块的设计，命令解析模块的主要作用是对串口接收的数据进行解析，通过对接收的数据进行解析分析判断出是进行何种操作。根据我们自己规定的数据协议，进行如下的设计，首先我们将串口发送的数据的前 4 个数据存入一个缓冲区数据内，通过对功能码识别判断是写操作还是读操作，如果是写操作，就将后面待写入的数据存入 fifo 中；同时将器件地址、地址字节数、起始地址、数据字节数赋值给 I2C 对应的信号线；如果是读操作，就在前 4 个字节接收完成后将器件地址、地址字节数、起始 地址、数据字节数赋值给 I2C 对应的信号线，同时给 I2C 控制器模块的读使能给一个时钟周期的门控信号，使能 I2C 的读操作。读出的数据同样也是先存放在另外一个 fifo 中，然后送给串口发送模块发出。具体实现代码如下：module cmd_analysis( Clk, Rst_n, Rx_done, Rx_data, Wfifo_req, Wfifo_data, Rddata_num, Wrdata_num, Wdaddr_num, Device_addr, Word_addr, Rd ); input Clk; //系统时钟 input Rst_n; //系统复位 input Rx_done; //串口接收一字节数据完成 input[7:0] Rx_data; //串口接收一字节数据 output reg Wfifo_req; //写 fifo 请求信号 output reg[7:0] Wfifo_data; //写 fifo 数据 output reg[5:0] Rddata_num; //I2C 总线连续读取数据字节数 output reg[5:0] Wrdata_num; //I2C 总线连续读取数据字节数 output reg[1:0] Wdaddr_num; //I2C 器件数据地址字节数 output reg[2:0] Device_addr; //EEPROM 器件地址 output reg[15:0] Word_addr; //EEPROM 寄存器地址 output reg Rd; //EEPROM 读请求信号 reg [7:0] buff_data[4:0];//串口接收数据缓存器 //串口接收数据计数器 reg [7:0]byte_cnt; always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) byte_cnt <= 8'd0; else if(Rx_done && byte_cnt==8'd4)begin if(buff_data[1]==8'hf2) //读数据指令 byte_cnt <= 8'd0; else if(buff_data[1]==8'hf1) //写数据指令 byte_cnt <= byte_cnt + 8'd1; else byte_cnt <= 8'd0; //错误指令 end else if(Rx_done)begin if(byte_cnt == 8'd4 + buff_data[4]) byte_cnt <= 8'd0; else byte_cnt <= byte_cnt + 8'd1; end else byte_cnt <= byte_cnt; end //串口接收数据缓存器 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n)begin buff_data[0] <= 8'h00; buff_data[1] <= 8'h00; buff_data[2] <= 8'h00; buff_data[3] <= 8'h00; buff_data[4] <= 8'h00; end else if(Rx_done && byte_cnt<5) buff_data[byte_cnt] <= Rx_data; else ; end //写 fifo 请求信号 Wfifo_req always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) Wfifo_req <= 1'b0; else if(byte_cnt >8'd4 && Rx_done) Wfifo_req <= 1'b1; else Wfifo_req <= 1'b0; end //写 fifo 数据 Wfifo_data always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) Wfifo_data <= 8'd0; else if(byte_cnt > 8'd4 && Rx_done) Wfifo_data <= Rx_data; else Wfifo_data <= Wfifo_data; end //EEPROM 读请求信号 Rd always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) Rd <= 1'b0; else if(byte_cnt == 8'd4 && Rx_done && buff_data[1]==8'hf2) Rd <= 1'b1; else Rd <= 1'b0; end //指令完成标志位 reg cmd_flag; always@(posedge Clk or negedge Rst_n) begin if(!Rst_n) cmd_flag <= 1'b0; else if((byte_cnt == 8'd4)&& Rx_done) cmd_flag <= 1'b1; else cmd_flag <= 1'b0; end //EEPROM 读写数据、寄存器地址字节数，器件地址，寄存器地址 always@(posedge Clk or negedge Rst_n) begin if(!Rst_n)begin Rddata_num <= 6'd0; Wrdata_num <= 6'd0; Wdaddr_num <= 2'd0; Device_addr <= 3'd0; Word_addr <= 16'd0; end else if(cmd_flag == 1'b1)begin Rddata_num <= buff_data[4][5:0]; Wrdata_num <= buff_data[4][5:0]; Wdaddr_num <= buff_data[0][5:4]; Device_addr <= buff_data[0][2:0]; Word_addr <= ; end else ; end endmodule下面编写 testbench 测试文件对设计的命令解析模块进行仿真验证，该仿真主要是分别模拟发送写数据操作和读数据操作指令，来观察相应的输出时序波形结果。通过仿真时序结果可以对该模块进行优化改进，具体的 testbench 文件如下：`timescale 1ns/1ns `define CLK_PERIOD 20 module cmd_analysis_tb; reg Clk; reg Rst_n; reg Rx_done; reg [7:0] Rx_data; wire Wfifo_req; wire[7:0] Wfifo_data; wire[5:0] Rddata_num; wire[5:0] Wrdata_num; wire[1:0] Wdaddr_num; wire[2:0] Device_addr; wire[15:0] Word_addr; wire Rd; reg [15:0] addr; reg [7:0] data_num; reg [7:0] wr_data; reg [39:0] wdata_cmd; reg [39:0] rdata_cmd; cmd_analysis cmd_analysis( .Clk(Clk), .Rst_n(Rst_n), .Rx_done(Rx_done), .Rx_data(Rx_data), .Wfifo_req(Wfifo_req), .Wfifo_data(Wfifo_data), .Rddata_num(Rddata_num), .Wrdata_num(Wrdata_num), .Wdaddr_num(Wdaddr_num), .Device_addr(Device_addr), .Word_addr(Word_addr), .Rd(Rd) ); //写 FIFO 模块例化 fifo_wr wr( .clock(Clk), .data(Wfifo_data), .rdreq(), .wrreq(Wfifo_req), .empty(), .full(), .q(), .usedw() ); //系统时钟产生 initial Clk = 1'b1; always #(`CLK_PERIOD/2)Clk = ~Clk; initial begin Rst_n = 0; Rx_done = 0; Rx_data = 0; addr = 0; data_num = 0; wr_data = 0; wdata_cmd = 0; rdata_cmd = 0; #(`CLK_PERIOD*200 + 1) Rst_n = 1; #200; addr = 0; data_num = 4; wr_data = 0; send_uart_data_wr; //写数据 #500; send_uart_data_rd; //读数据 #500; addr = 4; data_num = 8; wr_data = 20; send_uart_data_wr; //写数据 #500; send_uart_data_rd; //读数据 #500; $stop; end //串口发送写数据命令和待写入数据任务 task send_uart_data_wr; begin //写数据指令 wdata_cmd = ; //发送写数据指令 repeat(5)begin Rx_done = 1; Rx_data = wdata_cmd[39:32]; #(`CLK_PERIOD) Rx_done = 0; #500; wdata_cmd = ; end //待写入数据 Rx_data = wr_data; repeat(data_num)begin Rx_done = 1; Rx_data = Rx_data + 1; #(`CLK_PERIOD) Rx_done = 0; #500; end end endtask //串口发送读数据命令任务 task send_uart_data_rd; begin //读数据指令 rdata_cmd = ; //发送读数据指令 repeat(5)begin Rx_done = 1; Rx_data = rdata_cmd[39:32]; #(`CLK_PERIOD) Rx_done = 0; #500; rdata_cmd = ; end end endtask endmodule仿真过程主要是模拟命令解析模块接收到写或读 EEPROM 操作指令后的操作是否和我们设计想要达到的目标是否一致。这里的写或读数据指令均采用任务的形式，写数据指令下待写入的数据是采用给定一个值的基础上递增进行赋值的。命令解析模块仿真的结果如图 30.26 所示。根据波形时序图，在模拟发送写操作命令 0x21,0xf1,0x00,0x00,0x04,0x06,0x07,0x08,0x09 时，在接收完数据字节数这个数据后，后面收到的数据就存入到 fifo 中去了，与我们设计的是一致的，同理可以分析读数据操作命令，也是没有问题的，这样命令解析模块就设计完成了。下面就是整个系统的设计，如图 30.25 整体设计框图中，在 I2C 写数据操作之前和读数据后分别加入了 fifo 模块，因为串口读写速度和 I2C 读写速度不一样，在这之间加入的 fifo 模块具有读写时钟不一致的特点，可以对数据进行一个缓存，这样就能解决前后速度不一样的问题，这里的两个 fifo 均设置的是读取数据在读请求前有效，这样设计的目的是为了与其他模块待输入数据与使能信号相匹配，里面的 fifo模块都是通过 QuartusII 软件生成的 IP 核，fifo 输入输出数据位宽均设置为 8位，深度设置为 64（多字节读取最多支持 32 字节，稍大于这个数就可以了）。在各模块均设计完成后，整个系统的顶层电路设计就显得比较简单了，根据设计的系统框图进行整合就可以了。整个系统设计的代码如下：module uart_eeprom( Clk, Rst_n, Uart_rx, Uart_tx, Sda, Scl ); parameter Baud_set = 3'd4;//波特率设置,这里设置为 115200 input Clk; //系统时钟 input Rst_n; //系统复位 input Uart_rx; //串口接收 output Uart_tx; //串口发送 inout Sda; //I2C 时钟线 output Scl; //I2C 数据线 wire [7:0] Rx_data; //串口接收一字节数据 wire Rx_done; //串口接收一字节数据完成 wire wfifo_req; //写 FIFO 模块写请求 wire [7:0] wfifo_data; //写 FIFO 模块写数据 wire [5:0] wfifo_usedw; //写 FIFO 模块已写数据量 wire [5:0] rfifo_usedw; //读 FIFO 模块可读数据量 wire rfifo_rdreq; //读 FIFO 模块读请求 wire [5:0] Rddata_num; //I2C 总线连续读取数据字节数 wire [5:0] Wrdata_num; //I2C 总线连续写取数据字节数 wire [1:0] Wdaddr_num; //EEPROM 数据地址字节数 wire [2:0] Device_addr; //EEPROM 地址 wire [15:0] Word_addr; //EEPROM 寄存器地址 wire Wr; //EEPROM 写使能 wire [7:0] Wr_data; //EEPROM 写数据 wire Wr_data_vaild;//EEPROM 写数据有效标志位 wire Rd; //EEPROM 读使能 wire [7:0] Rd_data; //EEPROM 读数据 wire Rd_data_vaild;//EEPROM 读数据有效标志位 wire Done; //EEPRO 读写完成标识位 wire tx_en; //串口发送使能 wire [7:0] tx_data; //串口待发送数据 wire tx_done ; //一次串口发送完成标志位 //串口接收模块例化 uart_byte_rx uart_rx( .Clk(Clk), .Rst_n(Rst_n), .Rs232_rx(Uart_rx), .baud_set(Baud_set), .Data_Byte(Rx_data), .Rx_Done(Rx_done) ); //指令解析模块例化 cmd_analysis cmd_analysis( .Clk(Clk), .Rst_n(Rst_n), .Rx_done(Rx_done), .Rx_data(Rx_data), .Wfifo_req(wfifo_req), .Wfifo_data(wfifo_data), .Rddata_num(Rddata_num), .Wrdata_num(Wrdata_num), .Wdaddr_num(Wdaddr_num), .Device_addr(Device_addr), .Word_addr(Word_addr), .Rd(Rd) ); //写缓存 fifo 模块例化 fifo_wr fifo_wr( .clock(Clk), .data(wfifo_data), .rdreq(Wr_data_vaild), .wrreq(wfifo_req), .empty(), .full(), .q(Wr_data), .usedw(wfifo_usedw) ); //EEPROM 写使能 assign Wr = (wfifo_usedw == Wrdata_num)&& (wfifo_usedw != 6'd0); //I2C 控制模块例化 I2C I2C( .Clk(Clk), .Rst_n(Rst_n), .Rddata_num(Rddata_num), .Wrdata_num(Wrdata_num), .Wdaddr_num(Wdaddr_num), .Device_addr(Device_addr), .Word_addr(Word_addr), .Wr(Wr), .Wr_data(Wr_data), .Wr_data_vaild(Wr_data_vaild), .Rd(Rd), .Rd_data(Rd_data), .Rd_data_vaild(Rd_data_vaild), .Scl(Scl), .Sda(Sda), .Done(Done) ); //读缓存 fifo 模块例化 fifo_rd fifo_rd( .clock(Clk), .data(Rd_data), .rdreq(rfifo_rdreq), .wrreq(Rd_data_vaild), .empty(), .full(), .q(tx_data), .usedw(rfifo_usedw) ); //串口发送使能 assign tx_en = ((rfifo_usedw == Rddata_num)&&Done)|| ((rfifo_usedw < Rddata_num)&& (rfifo_usedw >0)&&tx_done); //读 FIFO 模块读请求 assign rfifo_rdreq = tx_en; //串口发送模块例化 uart_byte_tx uart_tx( .Clk(Clk), .Rst_n(Rst_n), .send_en(tx_en), .baud_set(Baud_set), .Data_Byte(tx_data), .Rs232_Tx(Uart_tx), .Tx_Done(tx_done), .uart_state() ); endmodule下面对设计的整个系统进行编写 testbench 文件来仿真验证，整个仿真主要是通过串口发送模块模拟对该系统发送指令进行仿真验证，这里就只选用 M24LC64 这个仿真模型进行仿真，M24LC04 的仿真模型类似（读者可尝试对该模型进行仿真），编写的 testbench 文件具体代码如下：`timescale 1ns/1ns `define CLK_PERIOD 20 module uart_eeprom_tb; reg Clk; reg Rst_n; reg tx_en; reg [7:0] tx_data; wire tx_done; wire Uart_rx; wire Uart_tx; wire Sda; wire Scl; reg [15:0] addr; reg [7:0] data_num; reg [7:0] wr_data; reg [39:0] wdata_cmd; reg [39:0] rdata_cmd; localparam Baud_set = 3'd4; //波特率设置,这里设置为 115200 localparam DevAddr = 3'b000;//I2C 器件的器件地址 localparam WdAr_NUM = 2'd2; //I2C 器件的存储器地址字节数 //串口发送模块例化 uart_byte_tx uart_tx( .Clk(Clk), .Rst_n(Rst_n), .send_en(tx_en), .baud_set(Baud_set), .Data_Byte(tx_data), .Rs232_Tx(Uart_rx), .Tx_Done(tx_done), .uart_state() ); //串口读写 EEPROM 模块例化 uart_eeprom #(.Baud_set(Baud_set)) uart_eeprom( .Clk(Clk), .Rst_n(Rst_n), .Uart_rx(Uart_rx), .Uart_tx(Uart_tx), .Sda(Sda), .Scl(Scl) ); //EEPROM 模型例化 M24LC64 M24LC64( .A0(1'b0), .A1(1'b0), .A2(1'b0), .WP(1'b0), .SDA(Sda), .SCL(Scl), .RESET(!Rst_n) ); //系统时钟产生 initial Clk = 1'b1; always #(`CLK_PERIOD/2)Clk = ~Clk; initial begin Rst_n = 0; tx_data = 0; tx_en = 0; addr = 0; data_num = 0; wr_data = 0; wdata_cmd = 0; rdata_cmd = 0; #(`CLK_PERIOD*200 + 1) Rst_n = 1; #200; addr = 0; data_num = 4; wr_data = 0; send_uart_data_wr;//写数据 @(posedge uart_eeprom.I2C.Done); #500; send_uart_data_rd;//读数据 @(posedge uart_eeprom.I2C.Done); #500; addr = 4; data_num = 8; wr_data = 20; send_uart_data_wr;//写数据 @(posedge uart_eeprom.I2C.Done); #500; send_uart_data_rd;//读数据 @(posedge uart_eeprom.I2C.Done); //从 EEPROM 读出的数据串口发送出去，等待发送完成 repeat(data_num)begin @(posedge uart_eeprom.tx_done); end #5000; $stop; end //串口发送写数据命令和待写入数据任务 task send_uart_data_wr; begin //写数据指令 wdata_cmd = ,8'hf1, addr[15:8],addr[7:0],data_num}; //发送写数据指令 repeat(5)begin tx_en = 1; tx_data = wdata_cmd[39:32]; #(`CLK_PERIOD) tx_en = 0; @(posedge tx_done) #100; wdata_cmd = ; end //待写入数据 tx_data = wr_data; repeat(data_num)begin tx_en = 1; tx_data = tx_data + 1; #(`CLK_PERIOD) tx_en = 0; @(posedge tx_done) #100; end end endtask //串口发送读数据命令任务 task send_uart_data_rd; begin //读数据指令 rdata_cmd = ,8'hf2, addr[15:8],addr[7:0],data_num}; //发送读数据指令 repeat(5)begin tx_en = 1; tx_data = rdata_cmd[39:32]; #(`CLK_PERIOD) tx_en = 0; @(posedge tx_done) #100; rdata_cmd = ; end end endtask endmodule仿真过程主要是通过串口发送模块模拟对该系统发送读写指令进行仿真验证，分别进行了 2 次写和读指令的发送，读指令主要是对刚写入地址的数据进行读出，我们可以通过观察时序波形图，比较写入数据与读出数据是否一致来验证系统设计的正确性。如图 30.27 为系统仿真波形时序图。分别对一次写数据指令和一次读数据指令的波形进行放大后观察分析，如图 30.28 和图30.29 分别为一次对 EEPROM 写数据过程和读数据过程的波形时序图。这次写数据过程的仿真是通过串口发送模块模拟发送指令数据 0x21,0xf1,0x00,0x00,0x04,0x05,0x06,0x07,0x08，向 EEPROM 中起始地址为 0 开始写入 0x05,0x06,0x07,0x08 四个数据，可以通过观察图 30.28 的中 SDA 和 SCL 波形图分析得知，写入的数据确实是这四个数据，说明系统中串口写 EEPROM 部分是没有问题的。读数据过程的仿真是通过串口发送模块模拟发送指令数据 0x21,0xf2,0x00,0x00,0x04，向 EEPROM 中起始地址为 0 开始读出四个数据，通过观察图 30.29 的中 SDA和 SCL 波形图分析得知，读出的四个数据为 0x05,0x06,0x07,0x08，与之前在这些地址写入的数据是一致的，说明这次的读数据时没有问题的，同样的方式经过多次的验证，串口读写 EEPROM 系统是可以正常工作的。仿真验证进行完成后，接下来就是进行板级验证，先是引脚的分配，本实验板级验证平台是 AC620 开发板，根据开发板的引脚分配表对本实验所用引脚进行分配。如图 30.30 是 AC620 开发板上 EEPROM 部分的硬件原理图，在引脚分配之前，是需要对这一块硬件电路有所了解的。细心的读者会发现，I2C 时钟线 SCL 和 I2C 数据线没有进行硬件上拉处理，与前面讲解的需要上拉处理不一样，可能会猜想是硬件设计的问题。这里我说明一下，硬件设计是没有问题的，因为对于 FPGA 是可以通过软件对引脚进行上拉处理的，这个也是本实验包含的一个知识点。通过 Quartus II 软件将管脚设置为上拉电阻（弱上拉）的方法，具体的步骤如下：1.在菜单 Assignments 中选择 Pin Planner，也可以直接点击面板上引脚分配的图标2.这样进入引脚分配的界面，在弹出的 Pin Planner 界面的 All Pins 区域里点击鼠标右键，找到 Customize Columns。在弹出的 Customize Columns 对 话 框的 左 列表 框 选 择 Weak Pull-Up Resistor，再点击，把 Weak Pull-Up Resistor 添加到右列表框，这样在 Pin Planner 的 All Pins 区域里就有一列 Weak Pull-Up Resistor 的设置项。再把需要上拉的 SDA 和 SCL 在其对应的 Weak Pull-Up Resistor 列的位置双极鼠标左键，就会弹出一个 Off/On 的选项，选上 On 就可以了。最后完成后的设置如下：引脚分配和上拉设置完成后，对我们设计的系统顶层文件进行综合布局布线生成 sof 下载文件，然后下载到 AC620 实验平台进行板级验证。板级验证需要用到串口软件工具，这里使用的是名叫格西烽火的串口工具，选择对应的开发板的串口号和波特率，系统设计的波特率在顶层文件 uart_eeprom 中可进行设置，这里我们设置的波特率为115200bps。板级验证时，我们先往 EEPROM 里写入一些数据，也就是在串口发送 6 组数据，每组数据写入四个数据；写完后发送读数据命令，读出写入的数据，分两次读，一次读 20个数据，一次读 4 个数据，具体的发送读写指令操作和串口接收的数据如下图：从串口发送和接受的数据分析可得，从 EEPROM 读出的 20 个数据和写入的 20 个数据是一样的，这就说明，设计的整个系统是工作正常的，读者可以多次进行多组测试来验证设计的完整性，整个的测试还可以利用 Quartus II 软件中的 SignalTap II Logic Analyzer 工具对 SDA 和 SCL 的波形进行抓取分析系统设计的正确性，这里就不详细的说明了，读者可以自己进行尝试。整个串口读写 EEPROM 的系统设计就算完成了，里面还有很多需要完善的地方，读者可以在学习完成后，对本实验进行改进和拓展。本节小结本节主要从二线制 I2C 协议的基本知识和概念、 I2C 器件之间数据通信过程，比较全面的了解了 I2C 协议，并以此设计一个可进行读写操作的 I2C 控制器，结合前面设计的串口收发模块和 FIFO 模块设计了一个简易应用，实现了串口对 EEPROM 存储器的读写功能，并进行相应的板级验证。读者可以在此基础上进行一定的优化和拓展，AC620实验开发板上还有音频模块和时钟模块挂在在 I2C 总线上，读者可以利用这些模块实现更丰富的应用
-
【FPGA】【SPI】线性序列机与串行接口 ADC 驱动设计与验证 本章导读模数转换器即 A/D 转换器，或简称 ADC（Analog to Digital Conver），通常是指一个将模拟信号转变为数字信号的电子元件。通常的模数转换器是把经过与标准量比较处理后的模拟量转换成以二进制数值表示的离散信号的转换器。模数转换器的种类很多，按工作原理的不同，可分成间接 ADC 和直接 ADC。间接 ADC是先将输入模拟电压转换成时间或频率，然后再把这些中间量转换成数字量，常用的有双积分型 ADC。直接 ADC 则直接转换成数字量，常用的有并联比较型 ADC 和逐次逼近型 ADC。并联比较型 ADC：采用各量级同时并行比较，各位输出码也是同时并行产生，所以转换速度快。并联比较型 ADC 的缺点是成本高、功耗大。逐次逼近型 ADC：它产生一系列比较电压 VR，但它是逐个产生比较电压，逐次与输入电压分别比较，以逐渐逼近的方式进行模数转换。它比并联比较型 ADC 的转换速度慢，比双分积型 ADC 要快得多，属于中速 ADC 器件。双积分型 ADC：它先对输入采样电压和基准电压进行两次积分，获得与采样电压平均值成正比的时间间隔，同时用计数器对标准时钟脉冲计数。它的优点是抗干扰能力强，稳定性好；主要缺点是转换速度低。本节以 ADC128S022 为例介绍 ADC 的工作原理及时序图解释，并用线性序列机来描述时序图进而正确驱动此类设备。本实验中，直接使用 AD/DA 模块上的 DAC 模块的输出直接接到 ADC 模块的输入上，通过控制 DAC 输出不同电压值，然后比较 DAC 的输出与 ADC采样到的值的大小，来评估 ADC 驱动的正确性。ADC 芯片概述及电路设计ADC128S022 型 ADC 内部工作原理在 AC620 开发板上使用的模数转换器为逐次逼近型的低功耗芯片 ADC128S022，其具有 8 通道以及 12 位的分辨率。电源采用独立的模拟供电以及数字供电，其中模拟电源 VA输入范围为 2.7V~5.25V，数字电源 VD 输入范围为 2.7V~VA。其与外部通信支持多种接口如：SPI、QSPI、MICROWIRE 以及通用的 DSP 接口。转换速度在 50kps~200kps，典型情况下当3V 供电时功耗为 1.2mW，5V 供电时为 7.5mW。本款 ADC 为 12 位分辨率，因此 1bit 代表的电压值即为 VA/4096。手册中同时指出，当模拟输入电压低于 VA/8192 时，输出数据即为 0000_0000_0000b。同理由于芯片本身内部构造当输出数 0000_0000_0000b 变为 0000_0000_0001b 时，实际输入电压变化为 VA/8192 而不是 VA/4096。当输入电压大于等于 VA-1.5* VA/4096，输出数据即为 1111_1111_1111b。ADC128S022 型 ADC 芯片引脚功能ADC128S022 芯片引脚及功能描述如表 25.1 所示。ADC128S022 电路设计ADC128S022 部分电路图如图 25.2 所示。这里外接了一个抗混叠低通滤波器，其作用是为了避免输入信号的高频成分在 ADC 的基带中引起混叠。数字电源与模拟电源电压均为3.3V，且数字电源与模拟电源之间串联磁珠用于抑制电磁干扰。传输特性ADC128S022 型 ADC 接口时序微控制器与 ADC128S022 的接口如图 25.3 所示，该接口使用标准的 SPI 接口，因此可以直接连接到微控制器的片上 SPI。对于 FPGA 来说，则可以使用逻辑按照 SPI 时序搭建控制电路，以实现对 ADC128S022 的控制。ADC128S022 通过 SPI 接口与控制器进行通信的时序图如图 所示。一个串行帧开始于CS̅̅̅的下降沿，结束于CS̅̅̅的上升沿。一帧包含 16 个上升沿 SCLK。ADC 的 DOUT 引脚当CS̅̅̅为高时代表空闲状态，当为低时为传输状态。也就是相当于CS̅̅̅可以充当输出使能。在CS̅̅̅为高时 SCLK 默认高。在头三个 SCLK 的循环，ADC 处于采样模式（track）。在接下来的 13 个循环为保持模式（hold），转换完成并且完成数据输出。下降沿 1~4 为前导零，5~16 为输出转换结果。如果在持续测量模式中，ADC 在 N（16） 个 SCLK 的上升沿会自动进去采样模式，在N16+4 个下降沿进入保持/转换模式。进入采样模式有三种方式，第一种当 SCLK 为高电平时 CS 变为低，当 SCLK 第一个下降沿到来时便进入采样模式，如时序图所示；第二种当 SCLK 为低电平时CS变低，自动进入采样模式，CS的下降沿即视为 SCLK 的第一个下降沿；第三种 SCLK 与CS一同变为低，这样对于两信号上升沿没有时序约束，但对于其下降沿有要求。在 DIN 的 8 个控制寄存器，每一位代表的含义如表 25.2 所示。其中 ADD[2:0]代表的输入通道选择如表 25.3 所示。ADC128S022 接口时序设计经查阅手册可知器件工作频率 SCLK 推荐范围为 0.8~3.2MHz，这里定义其工作频率为1.92MHz(周期为 520ns)。设置一个两倍于 SCLK 的采样时钟 SCLK2X，使用 50M 系统时钟十三分频而来即 SCLK2X 为 3.84MHz。针对 SCLK2X 进行计数来确定图 25.4 中各个信号的状态。结合前面 ADC 的接口时序图，按照线性序列机的设计思路，可以整理得到每个信号发生变化时对应的时刻以及此时对应的计数器的值。表25.4为依照线性序列机的设计思想，整理得到的每个信号发生变化时对应的时刻以及此时对应的计数器的值。其中 CS_N 为芯片状态标志信号，SCLK 为芯片时钟输入脚，DIN 为芯片串行数据输入，DOUT 为芯片串行数据输出。线性序列机计数器的控制逻辑判断依据，如表 4.17.6 所示。以上就是通过线性序列机设计接口时序的一个典型案例，可以看到，线性序列机可以大大简化设计思路。线性序列机的设计思想就是使用一个计数器不断计数，由于每个计数值都会对应一个时间，那么当该时间符合需要操作信号的时刻时，就对该信号进行操作。这样，就能够轻松的设计出各种时序接口了。基于线性序列机的 ADC 驱动设计模块接口设计ADC128S022 接口逻辑模块图如图 25.5 所示。每个端口功能描述如表 25.5 所示。在每次使能转换的时候，寄存当前状态通道选择 Channel 的值，防止在转换过程中该值发生变化对转换过程产生影响。reg [2:0]r_Channel; //通道选择内部寄存器 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;生成使能信号，当输入使能信号有效后便将使能信号 en 置 1，当转换完成信号有效时便将其重新置 0。reg en; //转换使能信号 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;在数据手册中SCLK的频率范围为0.8~3.2MHz。这里为了方便适配不同的频率需求率，设置了一个可调的计数器。根据表中可以看出，需要根据计数器的值周期性的产生 SCLK时钟信号，这里可以将计数器的值等倍数放大，形成过采样。这里产生一个两倍于 SCLK 的信号，命名为 SCLK2X。首先编写分频计数器，时钟 SCLK2X 的计数器。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'b1)) //时钟分频设置 DIV_CNT <= 8'd0; else DIV_CNT <= DIV_CNT + 1'b1; end else DIV_CNT <= 8'd0;根据使能信号以及计数器状态生成 SCLK2X 时钟。always@(posedge Clk or negedge Rst_n) if(!Rst_n) SCLK2X <= 1'b0; else if(en && (DIV_CNT == (DIV_PARAM - 1'b1))) SCLK2X <= 1'b1; else SCLK2X <= 1'b0;每当使能转换后，对 SCLK2X 时钟进行计数。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'd1; end else SCLK_GEN_CNT <= SCLK_GEN_CNT;根据 SCLK2X 计数器的值来确认工作状态以及数据传输进程。reg [11:0]r_data; //转换结果读取内部寄存器 reg [5:0]SCLK_GEN_CNT;//SCLK2X 计数器 always@(posedge Clk or negedge Rst_n) if(!Rst_n)begin SCLK <= 1'b1;CS_N <= 1'b1;DIN <= 1'b1; end else if(en) begin if(SCLK2X)begin case(SCLK_GEN_CNT) 6'd0:begin CS_N <= 1'b0; end 6'd1:begin SCLK <= 1'b0; DIN <= 1'b0; end 6'd2:begin SCLK <= 1'b1; end 6'd3:begin SCLK <= 1'b0; end 6'd4:begin SCLK <= 1'b1; end 6'd5:begin SCLK <= 1'b0; DIN <= r_Channel[2];end 6'd6:begin SCLK <= 1'b1; end 6'd7:begin SCLK <= 1'b0; DIN <= r_Channel[1];end 6'd8:begin SCLK <= 1'b1; end 6'd9:begin SCLK <= 1'b0; DIN <= r_Channel[0];end 6'd10,6'd12,6'd14,6'd16,6'd18,6'd20,6'd22,6'd24,6'd26,6'd28,6'd 30,6'd32: begin SCLK <= 1'b1; r_data <= ; end 6'd11,6'd13,6'd15,6'd17,6'd19,6'd21,6'd23,6'd25,6'd27,6'd29,6'd 31: begin SCLK <= 1'b0; end 6'd33:begin CS_N <= 1'b1; end//将转换结果输出 default:begin CS_N <= 1'b1; end endcase end else ; end else CS_N <= 1'b1;一次转换结束的标志，即 en && SCLK2X && (SCLK_GEN_CNT == 6'd33)为真，并产生一个高脉冲的转换完成标志信号 Conv_Done。一次转换结束后将内部寄存器 r_data 的数据输出到输出端 Data 上。 always@(posedge Clk or negedge Rst_n) if(!Rst_n)begin Data <= 12'd0; Conv_Done <= 1'b0; end else if(en && SCLK2X && (SCLK_GEN_CNT == 6'd33))begin Data <= r_data; Conv_Done <= 1'b1; end else begin Data <= Data; Conv_Done <= 1'b0; endADC 工作状态，在手册中看出 CS_N 在工作时为低电平，因此直接将此信号作为工作状态指示。assign ADC_State = CS_N;仿真及板级测试为了测试模块功能，模拟 ADC 芯片的输出。这里用 Sin3e 产生一个正弦波文件，位宽12 位，个数为 4096，并以 sin_12bit.txt 保存当前工程下的 simulation 目录下的 modelsim 文件夹。这样就需要将产生的数据，发送到 ADC 驱动模块的输入线 DOUT 上，这里使用系统任务$readmemb，其可以用来从文件中读取数据到存储器中。其格式有以下三种：$readmemb("<数据文件名>",<存贮器名>);$readmemb("<数据文件名>",<存贮器名>,<起始地址>);$readmemb("<数据文件名>",<存贮器名>,<起始地址>,<结束地址>。首先定义文件存放位置。`define sin_data_file "./sin_12bit.txt"定义 4096 个 12 位的存储单元，然后将波形数据读取到存储器中。 reg[11:0] memory[4095:0];//测试波形数据存储空间 initial $readmemh(`sin_data_file,memory);在测试时将这些数据整体循环三次，进行验证。其中 gene_DOUT(memory[address])；依次将存储器中存储的波形数据读出，按照 ADC 芯片转换结果输出方式的送到 DOUT 信号线上。 integer i; initial begin Rst_n = 0;Channel = 0; En_Conv = 0; DOUT = 0;address = 0; #101; Rst_n = 1; #100; Channel = 5; for(i=0;i<3;i=i+1)begin for(address=0;address<4095;address=address+1)begin En_Conv = 1; #20; En_Conv = 0; gene_DOUT(memory[address]); @(posedge Conv_Done); //等待转换完成信号 #200; end end #20000; $stop; end将存储空间的数据按照 ADC 的数据输出格式，发送到 DOUT 信号线上，供控制模块采集。task gene_DOUT; input [15:0]vdata; reg [4:0]cnt; begin cnt = 0; wait(!CS_N); while(cnt<16)begin @(negedge SCLK) DOUT = vdata[15-cnt]; cnt = cnt + 1'b1; end end endtask全编译后进行仿真，可看出此次信号较多。这里首先查看与 ADC 相关的使能信号、状态标志信号以及 SCLK 时钟信号等。选中以上这些信号，可以看出，每当外界输入一个周期的 En_Conv 转换信号，模块内部使能信号 en 就置高，一直到转换完成标志信号 Conv_Done有效再置 0。当 SLK2X 计数器值为 33d 且当 SCLK2X 为高时，便输出一个时钟周期的高脉冲信号，标志着本次转换过程结束。同时 SCLK2X 时钟为 ADC 工作时钟 SCLK 的两倍。以上各信号符合既定的设计。DIN 为 FPGA 控制 ADC 通道选择的信号，这里选择的通道五也就是 ADD[2:0]=101b，可以看出图每个测量循环中发送 DIN 状态均一致。查看 DOUT 串行数据输出信号，在每个 SCLK 上升沿 DOUT 均会输出一位数据。在第一个转换过程中，DOUT 首先输出 4 个前导 0，然后依次输出 1000_0000_0000b（MSB），也就是在激励文件中例化的正弦波的第一个数据 800h。并在一次转换完成后，输出并行数据 Data。符合既定设计，可以自行分析第二个转换过程。查看 CS_N 与 ADC_State 工作状态标志信号，可看出当 ADC 处于转换时为低电平，空闲时为高电平，符合设计要求。将并行输出数据 Data 设置为模拟形式，主要参数如图 25.10 所示，其中波形所占高度可根据实际情况自行设计，此处暂定 100。重启仿真后可看出数据输入为 3 个周期的正弦波也就是采样正确，符合既定设计。这里如不重启仿真可能会出现如图 25.12 所示的波形影响观测，此为仿真软件本身问题，可不深究。为了进行板级仿真，新建测试 ADC_test 顶层文件，在顶层文件中例化 ADC 以及 DAC驱动，并设置好相关使能以及标志信号。再分别生成两个 ISSP 文件，其中驱动 DAC 电压数据的命名为 ISSP_DAC（源位宽为 16），采集 ADC 电压以及通道设置的为 ISSP_ADC（源位宽为 3，探针位宽为 12）。分配引脚并全编译后，下载程序，并启动 ISSP。1.DAC 的 DA 输出端连接 ADC 的 A0 输入端。如图 25.13 所示，使得 DAC 输出电压为0，可测得电压为 0。2.DAC 的 DA 输出端连接 ADC 的 A0 输入端。此时更新 DB 的输出值，如图 25.14，可以看出 A0 测量数据保持 0 不变。3.DAC 的 DB 输出端接 ADC 的 A1 输入端。此时更新 DB 值，其理论输出电压为7FF/FFF 4.096=2.048V ，如图 25.15 所示，使能 A1 测量端可测得输入电压为2535/40963.3=2.04V，在误差允许范围内。DAC的DB输出端接ADC的 A1 输入端。此时更新 DB 值，其理论输出电压为 BD3/FFF 4.096=3.072V,如图 25.16 所示，使能 A1 测 量 端 可 测 得 输 入 电 压 为 3815/4096 3.3=2.07V，在误差允许范围内。同理可测试的其他 DAC 输出电压以及 ADC 输入测量电压值。此处换算时需注意，DAC电路输出电压范围为 0~4V，ADC 电路测量电压范围为 0~3.3V。工程代码在我们设计的驱动模块中，需要给ADC芯片三个控制信号SCLK、CS_N、DIN，还需要有接收ADC转化结果的ADC_OUT。ADC芯片的选址信号通过Channel端给到ADC_driver中，然后通过ADC_DIN给到芯片中，用于选择采集模拟信号的通道。12位宽的Data输出给外部的FIFO缓存。module adc128s022( 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; //ADC转换通道选择 output reg [11:0]Data; //ADC转换结果 input En_Conv; //使能单次转换，该信号为单周期有效，高脉冲使能一次转换 output reg Conv_Done; //转换完成信号，完成转换后产生一个时钟周期的高脉冲 output ADC_State; //ADC工作状态，ADC处于转换时为低电平，空闲时为高电平 input [7:0]DIV_PARAM; //时钟分频设置，实际SCLK时钟 频率 = fclk / （DIV_PARAM * 2） output reg ADC_SCLK; //ADC 串行数据接口时钟信号 output reg ADC_CS_N; //ADC 串行数据接口使能信号 input ADC_DOUT; //ADC转换结果，由ADC输给FPGA output reg ADC_DIN; //ADC控制信号输出，由FPGA发送通道控制字给ADC reg [2:0]r_Channel; //通道选择内部寄存器 reg [11:0]r_data; //转换结果读取内部寄存器 reg [7:0]DIV_CNT;//分频计数器 reg SCLK2X;//2倍SCLK的采样时钟 reg [5:0]SCLK_GEN_CNT;//SCLK生成暨序列机计数器 reg en;//转换使能信号 //在每个使能转换的时候，寄存Channel的值，防止在转换过程中该值发生变化 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; //产生使能转换信号 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; //生成2倍SCLK使能时钟计数器 always@(posedge Clk or negedge Rst_n) if(!Rst_n) DIV_CNT <= 8'd0; else if(en)begin if(DIV_CNT == (DIV_PARAM - 1'b1)) DIV_CNT <= 8'd0; else DIV_CNT <= DIV_CNT + 1'b1; end else DIV_CNT <= 8'd0; //生成2倍SCLK使能时钟 always@(posedge Clk or negedge Rst_n) if(!Rst_n) SCLK2X <= 1'b0; else if(en && (DIV_CNT == (DIV_PARAM - 1'b1))) SCLK2X <= 1'b1; else SCLK2X <= 1'b0; //生成序列计数器 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'd1; end else SCLK_GEN_CNT <= SCLK_GEN_CNT; //序列机实现ADC串行数据接口的数据发送和接收 always@(posedge Clk or negedge Rst_n) if(!Rst_n)begin ADC_SCLK <= 1'b1; ADC_CS_N <= 1'b1; ADC_DIN <= 1'b1; end else if(en) begin if(SCLK2X)begin case(SCLK_GEN_CNT) 6'd0:begin ADC_CS_N <= 1'b0; end 6'd1:begin ADC_SCLK <= 1'b0; ADC_DIN <= 1'b0; end 6'd2:begin ADC_SCLK <= 1'b1; end 6'd3:begin ADC_SCLK <= 1'b0; end 6'd4:begin ADC_SCLK <= 1'b1; end 6'd5:begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[2];end //addr[2] 6'd6:begin ADC_SCLK <= 1'b1; end 6'd7:begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[1];end //addr[1] 6'd8:begin ADC_SCLK <= 1'b1; end 6'd9:begin ADC_SCLK <= 1'b0; ADC_DIN <= r_Channel[0];end //addr[0] //每个上升沿，寄存ADC串行数据输出线上的转换结果 6'd10,6'd12,6'd14,6'd16,6'd18,6'd20,6'd22,6'd24,6'd26,6'd28,6'd30,6'd32: begin ADC_SCLK <= 1'b1; r_data <= ; end //循环移位寄存DOUT上的12个数据 6'd11,6'd13,6'd15,6'd17,6'd19,6'd21,6'd23,6'd25,6'd27,6'd29,6'd31: begin ADC_SCLK <= 1'b0; end 6'd33:begin ADC_CS_N <= 1'b1; end default:begin ADC_CS_N <= 1'b1; end //将转换结果输出 endcase end else ; end else begin ADC_CS_N <= 1'b1; end //转换完成时，将转换结果输出到Data端口，同时产生一个时钟周期的高脉冲信号 always@(posedge Clk or negedge Rst_n) if(!Rst_n)begin Data <= 12'd0; Conv_Done <= 1'b0; end else if(en && SCLK2X && (SCLK_GEN_CNT == 6'd33))begin Data <= r_data; Conv_Done <= 1'b1; end else begin Data <= Data; Conv_Done <= 1'b0; end //产生ADC工作状态指示信号 assign ADC_State = ADC_CS_N; endmodule仿真结果
