刘航宇发布的文章 - 第 4 页 - 我的学记|刘航宇的博客

登录 / 注册

刘航宇(共311篇)

找到 311 篇与刘航宇相关的结果 - 第 4 页

2023-07-19
嵌入式软件-基于C语言小端转大端意义题目示例解答1.char指针，按字节替换 2.利用union联合体共用内存空间特性，使用char数组来改变 3. 使用按位与运算保留以获取每个字节，然后按位左移到正确位置并拼接 4. 使用预定义好的宏函数意义大端小端转化对嵌入式系统有意义，因为不同的处理器或者通信协议可能采用不同的字节序来存储或者传输数据。字节序是指一个多字节数据在内存中的存放顺序，它有两种主要的形式：大端：最高有效位（MSB）存放在最低的内存地址，最低有效位（LSB）存放在最高的内存地址。小端：最低有效位（LSB）存放在最低的内存地址，最高有效位（MSB）存放在最高的内存地址。例如，一个32位的整数0x12345678，在大端系统中，它的内存布局是： pC703EF.png图片而在小端系统中，它的内存布局是： pC70G4J.png图片如果一个嵌入式系统需要和不同字节序的设备或者网络进行交互，就需要进行字节序的转换，否则会导致数据错误或者通信失败。例如，TCP/IP协议族中的所有层都采用大端字节序来表示数据包头中的16位或32位的值，如IP地址、包长、校验和等。如果一个嵌入式系统使用小端字节序的处理器，并且想要建立一个TCP连接，就需要将IP地址等信息从小端转换为大端再发送出去，否则对方无法正确解析。题目输入一个数字n，假设它是以小端模式保存在机器的，请将其转换为大端方式保存时的值。示例输入：1 返回值：16777216 解答 1.char指针，按字节替换 /* * @param n int整型 * @return int整型 */ int convert(int n ) { // write code here int tmp = 0x00000000; //开辟新的int空间用于接收转化结果 unsigned char *p = &tmp, *q = &n; p[0] = q[3]; p[1] = q[2]; p[2] = q[1]; p[3] = q[0]; return tmp; }2.利用union联合体共用内存空间特性，使用char数组来改变 /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param n int整型 * @return int整型 */ typedef union { int i; unsigned char c[4] } inc_u; int convert(int n ) { // write code here inc_u x; //这里也可以用新开辟空间进行置换 x.i = n; //利用按位异或运算可叠加、可还原性 x.c[0] ^= x.c[3], x.c[3] ^= x.c[0], x.c[0] ^= x.c[3]; //首尾两字节对调 x.c[1] ^= x.c[2], x.c[2] ^= x.c[1], x.c[1] ^= x.c[2]; //中间两字节对调 return x.i; /* 按位<<到正确位置，并用|拼装 return (x.c[0]<<24)|(x.c[1]<<16)|(x.c[2]<<8)|x.c[3]; */ }3. 使用按位与运算保留以获取每个字节，然后按位左移到正确位置并拼接 /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param n int整型 * @return int整型 */ int convert(int n ) { // write code here return (((n & 0xff000000)>>24) | ((n & 0x00ff0000)>>8 ) | ((n & 0x0000ff00)<<8 ) | ((n & 0x000000ff)<<24); //按位与时，遇0清零，遇1保留 ); }4. 使用预定义好的宏函数本条方法参考 https://www.codeproject.com/Articles/4804/Basic-concepts-on-Endianness 文中提到网络上常用的套接字接口（socket API）指定了一种称为网络字节顺序的标准字节顺序，这个顺序其实就是大端模式；而当时，同时代的 x86 系列主机反而是小端模式。所以就促使产生了如： ntohs() convert Network order TO Host order in Short (16 bit 大转小); ntohl() convert Network order TO Host order in Long (32 bit 大转小); htons() convert Host order TO Network order in Short (16 bit 小转大); htonl() convert Host order TO Network order in Long (32 bit 小转大). 所以我们这里使用 32 bit 小转大的 htonl() 宏函数来解决这个问题。 /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param n int整型 * @return int整型 */ int convert(int n ) { // write code here return htonl(n); ); }

嵌入式＆系统编程&脚本笔记 # 嵌入式 # C/C++

刘航宇 3年前
0 630 1
2023-07-13
反向散射理论与ADG902电路实现后向散射通信技术，是在天线对信号散射的基础上，采用标签后向散射的方式，通过改变发射端标签的反射系数来实现后向散射通信。无线电波在传输过程中，当通过不同介质时，因为介质阻抗的差异性，会产生反射作用，根据介质材料和阻抗的不同，会产生不同的反射量。因此通过调节天线端口的阻抗匹配度，入射的无线电波就可以产生不同反射量，导致入射信号和反射信号的差异性，也就是反射系数 Γ 。具体表示如下： $$\Gamma=\frac{Z_L-Z_0}{Z_L+Z_0}$$ 式中 Z0表示天线端的特征阻抗，一般是 50 Ω，ZL表示标签端口的输入阻抗，Γ表示入射信号振幅和反射信号振幅的复数比。当Γ=0 时，阻抗匹配，入射信号全部传递，无反射信号的产生；Γ = 1时，标签端的输入阻抗为开路，阻抗失配，入射信号被全部反射，产生幅值相同相位相同的反射信号；Γ = −1时，标签端的输入阻抗为短路状态，阻抗失配，入射信号被全部反射，产生幅值相同相位相反的反射信号。因此，通过改变标签的输入阻抗，产生不同的反射系数，就可以控制无线电波的入射和反射，实现有效信号的传递，这也就是后向散射通信的基本原理。为了实现上述后向散射通信，还需要加载天线端口的控制，结构如下图。通过射频开关来控制两个不同的负载阻抗与天线端口的连接，实现阻抗的匹配和失调，完成信号的入射和反射。当开关在负载 Z1和 Z2间转化时，由于负载阻抗的不同，载波信号在天线端的反射比例也不同，因此就产生了不同的调制载波。在实际通信中，为了达到最优传输质量，通常要使反射信号的差异最大，对应完全反射和完全吸收两种形式。对调制后的反射信号进行解调处理后，就可以得到所传递的基带信号，完成后向散射的通信。采用负载 50 Ω 的完全吸收和负载短路的完全反射两种信号传输差异，来实现后向散射的信息传输。图片使用后向散射开关 ADG 902 来实现基带信号对天线状态的控制，ADG 902 电路结构如图 4.12 所示。将数字基带信号的接入 ADG 902 的 CTRL 端，通过数字基带信号的“0”、“1”来控制 ADG 902 的关断和闭合，RF2 端连接射频天线。通过 ADG 902 中开关的关断，来控制天线对外界调制载波的反射和吸收。注意：RF1接天线，RF2接地也可以，这里读者可自行证明图片当逻辑电平 CTRL=0时，S1关断，S2闭合，此时天线接收端口接地，由式可得，Z=0，T=1，载波信号被完全反射；当逻辑电平 CTRL=1 时，S1 闭合，S2 关断，此时天线接收端匹配，载波被完全吸收。

通信&信息处理 # 通信&射频 # 物联网

刘航宇 3年前
1 1,557 2
【转载】Libero SOC Debug教程-片上逻辑分析仪IDENTIFY 本文转载于https://blog.csdn.net/whik1194/article/details/107074187 FPGA在线调试关于MICROSEMI片上逻辑分析仪 FPGA片上逻辑分析仪原理预期效果 0.准备一个创建好的LIBERO工程 1.新建IDENTIFY工程，并添加想要监测的信号 2.管脚分配，编译下载 3.设置触发类型 4.IICE逻辑分析仪核资源占用原文：参考： FPGA在线调试对于嵌入式系统来说，如单片机，进行硬件级程序调试时，通常采用的是JLink/ST-Link调试器，在线调试的方式来获取程序实时运行的状态，可以观察程序运行流程、各种变量的值、中断的触发情况，还可以设置断点、单步运行，方便快速的发现BUG，解决问题。但是对于FPGA来说，并不是顺序执行的，而是根据每一个Clk并行执行，所以我们不能使用调试器进行单步调试。 FPGA调试需要观察内部信号的值，各个信号之间的时序关系，所以使用逻辑分析仪是最好的调试方式了。有些FPGA工程，对外的接口，即输入输出，可能只有几个，但是他们之间的逻辑和时序关系非常复杂，所以内部有几十个中间寄存器，程序下载进去了，发现不是我们想要的效果，怎么办？你可能会说，查代码吧！如果这个工程非常简单，你可能只需要耗费几分钟或者几个小时就可以定位代码的问题所在。但是如果这是一个非常庞大的工程，内部的中间寄存器、信号，几百上千个，各个模块单独软件仿真都正常，整体仿真也正常，就是下载到实际的芯片中运行不正常。你如何进行问题定位？如果再去进行代码审查，这将会消耗非常多的时间。那么如果能在FPGA芯片内部装上一个逻辑分析仪，那不就直接可以看到内部信号的值了，而且还可以看到各个信号之间的时序关系。需求推动技术发展，既然开发者有这个需求，那么FPGA厂商肯定会实现这个功能！下面来一起看一下Microsemi FPGA片上逻辑分析仪的使用方法吧！关于MICROSEMI片上逻辑分析仪几大厂商的片上逻辑分析仪： Xilinx厂商ISE开发环境下的ChipScope工具 Altera厂商Quartus开发环境下的SignalTap工具 Lattice厂商Diamod开发环境下的Reveal工具对于 FPGA 工程师来说，这些都是很熟悉的名字。和以上几大FPGA厂商一样，Microsemi Libero也支持片上逻辑分析仪工具，只不过不是自己家研发的，使用的是Synospsy公司出品的Identify工具，其实，Libero中的综合器synplify也是Synospsy公司的。根据Synospsy官网的描述：Identify RTL 调试仪，这个调试工具除了支持Microsemi的FPGA产品外，还支持Altera和Xilinx的FPGA产品。 FPGA片上逻辑分析仪原理 Identify片上逻辑分析仪的原理，是通过在FPGA工程中加入一个IICE逻辑分析仪IP核，这个IP核，由控制器和采集器组成，采集器用于采集信号，控制器用于和JTAG调试器连接，并把数据发送到上位机，IICE内部有RAM空间，用于存储触发位置附近的信号，RAM空间的大小，即采样深度，可以自己调整。FPGA工程中加入IICE核，会占用一定的资源，资源占用的大小取决于：采样深度，采样信号的个数，采样信号的触发方式等。所以综上，FPGA片上逻辑分析仪需要3个组件：片上的IICE逻辑分析仪核、JTAG下载器、上位机。 pC5Uq6e.png图片 JTAG下载器也就是我们下载程序时使用的FlashPro x下载器，上位机软件也就是Identify工具，这个工具已经在安装Libero SoC时一同安装并注册**了。所以不需要安装其他的工具软件，只需要在已经设计好的FPGA公司中，配置一下IIC逻辑分析仪核就可以了。在已经创建好的Libero工程中，加入IICE逻辑分析仪核，并演示Identify工具的使用。预期效果以Microsemi SmartFusion系列的A2F200M3F芯片为例，其他芯片使用操作方法类似。示例工程功能：led每隔10个clk翻转一次为例，演示identify的使用。 identify添加完成之后，把led设置为上升沿触发，会抓取到类似如下的波形。 pChB2qJ.png图片 0.准备一个创建好的LIBERO工程这里以LED每隔10个时钟周期翻转为例。HDL文件内容： module led_demo( //inputs input clk, input rst_n, //outputs output reg led ); reg [3:0] cnt; always @ (posedge clk) begin if(!rst_n) cnt <= 0; else if(cnt == 10) /* max=10, 0-10 */ cnt <= 0; else cnt <= cnt + 1; end always @ (posedge clk) begin if(!rst_n) led <= 0; else if(cnt == 10) led <= ~led; end endmodule1.新建IDENTIFY工程，并添加想要监测的信号 1.0 先运行Synthesize 1.1 在Synthesize上右键，选择Open Interactively pChr5jO.png图片 1.2 在Synthesis上右键新建一个Identify工程 pChrTDe.png图片 1.3 输入新建的identify工程的名称和保存路径，选择默认的就行。 pChrqUA.png图片 1.4 在新建的identify工程上右键选择identify instrumentor pChsSKS.png图片 1.5 在HDL文件中选择要监测的信号和采样时钟，采样时钟选择Sample Clock，作为触发的信号选择Trigger Only，要监测的信号选择Sample Only，也可以选择Sample and Trigger，这样会占用更多的资源。 pChsG26.png图片 pChsNrD.png图片设置完成的信号会有标注 pChsgsS.png图片 sample clock 表示采样时钟，所有在 IICE 中添加的信号都会在 sample clock 的边沿进行采样，设为 sample clock 的信号前会出现一个时钟状的图标。设置为 sample 和 trigger 的信号都将作为被采样信号，区别在于 sample 信号只能被采样，而 trigger 信号可以作为触发采集的条件，当然你可以把一个信号同时设置为 sample 和 trigger 。 1.6 设置采样深度，选择Instrumentor->IICE pChsWZQ.png图片采样深度最大支持1048576 pChsfaj.png图片输入采样深度，数值越大，采样时间越长，相应的FPGA资源占用也越多。 pChsqLF.png图片 1.7 选择Run->Run pChsOZ4.png图片或者直接点击主界面的Run按钮 pChsjo9.png图片 1.8 编译完成之后，保存退出。 pChsxiR.png图片 2.管脚分配，编译下载 2.1 和正常流程一样，管脚分配，编译下载。可以看到JTAG部分的管脚已经被IICE逻辑分析仪核使用了 pChyiLD.png图片 2.2 在Identify Debug Design上右键，选择Open Interactively，打开identify工具 pChymWt.png图片 3.设置触发类型 3.1 选择要触发的信号，和触发类型，这里我选择的是led，上升沿触发。 pChyYYn.png图片 3.2 连接FlashPro下载器，点击小人图标，启动抓取，满足触发条件自动停止。 pChy6YR.png图片 D:/identify_demo/synthesis$ run -iice {IICE} INFO: run -iice IICE INFO: Info: Attempting to connect to: usb Info: Type: FlashPro4 Info: ID: 08152 Info: Connection: usb2.0 Info: Revision: UndefRev INFO: Checking communication with the Microsemi_BuiltinJTAG cable and the hardware INFO: The hardware is responding correctly INFO: Auto-detecting the device chain INFO: Device at chain position 1 is "A2F200M3F" INFO: IICE 'IICE' configured, waiting for trigger INFO: IICE 'IICE' Trigger detected, downloading samples INFO: notify -notify INFO: waveform viewer INFO: waveform viewer INFO: write vcd -iice IICE -comment {Identify created VCD dump} -gtkwave -noequiv IICE.vcd D:/identify_demo/synthesis$ 3.3 右侧黄色的显示就是触发瞬间时信号的值。右键可以改变数据格式。 pChyO6f.png图片 3.4 选择Debugger preferences可以设置采样时钟的周期，用于后面波形的时间测量 pChyz7Q.png图片 3.5 设置采样时钟的周期 pCh6Chn.png图片 3.6 点击波形按钮，在GTKWave中打开抓取到的波形。 pCh6kcV.png图片 3.7 可以按住左键拖动测量时间差 pCh6uN9.png图片 3.8 还可以给每个通道设置不同的颜色，和显示方式。 pCh6Q91.png图片 4.IICE逻辑分析仪核资源占用 IICE逻辑分析仪核占用的主要是逻辑资源和RAM资源，可以看到资源占用还是很多的。图片图片原文： https://blog.csdn.net/whik1194/article/details/107074187 参考： https://zhuanlan.zhihu.com/p/88314552 https://www.synopsys.com/zh-cn/implementation-and-signoff/fpga-based-design/identify-rtl-debugger.html http://training.eeworld.com.cn/video/1059 https://www.microsemi.com/document-portal/doc_view/132760-synopsys-identify-me-h-2013-03m-sp1-user-guide

嵌入式＆系统 FPGA&ASIC # ASIC/FPGA # 嵌入式

刘航宇 3年前
2 3,150 2
2023-07-10
Verilog实现AMBA--AHB To APB Bridge 1、APB桥 2、读传输 3、写传输 4、背靠背传输 5、AHB_to_APB Bridge的Verilog实现 6、仿真 1、APB桥 APB桥是AMBA APB总线上的唯一主机，也是AMBA AHB的一个从机。下图表示了APB桥接口信号：图片 APB Bridge将AHB传输转成APB传输并实现一下功能：（1）对锁存的地址进行译码并产生选择信号PSELx，在传输过程中只有一个选择信号可以被激活。也就是选择出唯一一个APB从设备以进行读写动作。（2）写操作时：负责将AHB送来的数据送上APB总线。（3）读操作时：负责将APB的数据送上AHB系统总线。（4）产生一时序选通信号PENABLE来作为数据传递时的启动信号 2、读传输下图表示了APB到AHB的读传输：图片传输开始于AHB总线上的T1时刻，在T2时刻地址信息被APB采样，如果传输目标是外设总线，那么这个地址就会被译码成选择信号发给外设，T2即为APB总线的SETUP周期，T3为APB的ENABLE周期，PENABLE信号拉高。在该周期内，外设必须提供读数据，通常情况下，读数据直接AHB读数据总线上，总线主机在T4时刻对读数据进行采样。在频率很高的情况下，在ENABLE CYCLE中可能数据不能够直接映射到AHB总线，需要在APB桥中在T4的时候打插入一个额外的等待周期，并在T5的时候才被AHB主采样。虽然需要多一个等待周期（一共2个），但是由于频率提升了因此总的性能也提升了。下图表示了一个读突发传输，所有的传输都只有一个等待周期图片 3、写传输下图表示了一个写传输：图片 APB总线上的单块数据写操作不需要等待周期。 APB桥负责对地址和数据进行采样，并在写操作的过程中保持它们的值。下图表示了一个写突发传输：图片虽然第一个传输可以零等待完成，但后续每一个传输都需要插入一个等待状态。 APB桥需要两个地址寄存器，以便在当前传输进行时，锁存下一次传输的地址。 4、背靠背传输下图表示了一个背靠背传输，顺序为写、读、写、读：如果写操作之后跟随着读操作，那么需要 3 个等待周期来完成这个读操作。通常的情况下，不会有读操作之后紧跟着写操作的发生，因为两者之间 CPU 会进行指令读取，并且指令存储器也不太可能挂在在APB总线上。图片下面以ARM DesignStart项目提供的软件包里的AHB转APB桥的代码，对其进行学习与仿真，以深入理解APB桥的实现方法，该转换桥比较简单，实现的是一对一的转换，也可以配合APB slave multiplexer模块，实现一对多的方式（主要依靠APB高位地址译码得到各个从机的PSEL信号）。如果想学习APB系统总线，可以参考Synopsys公司的DW_APB IP，该IP最多可支持16个APB从机，并支持所有的突发传输类型。 5、AHB_to_APB Bridge的Verilog实现 `timescale 1ns / 1ps module ahb_to_apb #( // Parameter to define address width // 16 = 2^16 = 64KB APB address space parameter ADDRWIDTH = 16, parameter REGISTER_RDATA = 1, parameter REGISTER_WDATA = 0 ) ( //---------------------------------- // IO Declarations //---------------------------------- input wire HCLK, // Clock input wire HRESETn, // Reset input wire PCLKEN, // APB clock enable signal input wire HSEL, // Device select input wire [ADDRWIDTH-1:0] HADDR, // Address input wire [1:0] HTRANS, // Transfer control input wire [2:0] HSIZE, // Transfer size input wire [3:0] HPROT, // Protection control input wire HWRITE, // Write control input wire HREADY, // Transfer phase done input wire [31:0] HWDATA, // Write data output reg HREADYOUT, // Device ready output wire [31:0] HRDATA, // Read data output output wire HRESP, // Device response // APB Output output wire [ADDRWIDTH-1:0] PADDR, // APB Address output wire PENABLE, // APB Enable output wire PWRITE, // APB Write output wire [3:0] PSTRB, // APB Byte Strobe output wire [2:0] PPROT, // APB Prot output wire [31:0] PWDATA, // APB write data output wire PSEL, // APB Select output wire APBACTIVE, // APB bus is active, for clock gating of APB bus // APB Input input wire [31:0] PRDATA, // Read data for each APB slave input wire PREADY, // Ready for each APB slave input wire PSLVERR // Error state for each APB slave ); //---------------------------------- // Variable Declarations //---------------------------------- reg [ADDRWIDTH-3:0] addr_reg; // Address sample register reg wr_reg; // Write control sample register reg [2:0] state_reg; // State for finite state machine reg [3:0] pstrb_reg; // Byte lane strobe register wire [3:0] pstrb_nxt; // Byte lane strobe next state reg [1:0] pprot_reg; // PPROT register wire [1:0] pprot_nxt; // PPROT register next state wire apb_select; // APB bridge is selected wire apb_tran_end; // Transfer is completed on APB reg [2:0] next_state; // Next state for finite state machine reg [31:0] rwdata_reg; // Read/Write data sample register wire reg_rdata_cfg; // REGISTER_RDATA paramater wire reg_wdata_cfg; // REGISTER_WDATA paramater reg sample_wdata_reg; // Control signal to sample HWDATA //---------------------------------- // Local Parameter Declarations //---------------------------------- // State machine localparam ST_BITS = 3; localparam [ST_BITS-1:0] ST_IDLE = 3'b000; // Idle waiting for transaction localparam [ST_BITS-1:0] ST_APB_WAIT = 3'b001; // Wait APB transfer localparam [ST_BITS-1:0] ST_APB_TRNF = 3'b010; // Start APB transfer localparam [ST_BITS-1:0] ST_APB_TRNF2 = 3'b011; // Second APB transfer cycle localparam [ST_BITS-1:0] ST_APB_ENDOK = 3'b100; // Ending cycle for OKAY localparam [ST_BITS-1:0] ST_APB_ERR1 = 3'b101; // First cycle for Error response localparam [ST_BITS-1:0] ST_APB_ERR2 = 3'b110; // Second cycle for Error response localparam [ST_BITS-1:0] ST_ILLEGAL = 3'b111; // Illegal state //---------------------------------- // Start of Main Code //---------------------------------- // Configuration signal assign reg_rdata_cfg = (REGISTER_RDATA == 0) ? 1'b0 : 1'b1; assign reg_wdata_cfg = (REGISTER_WDATA == 0) ? 1'b0 : 1'b1; // Generate APB bridge select assign apb_select = HSEL & HTRANS[1] & HREADY; // Generate APB transfer ended assign apb_tran_end = (state_reg == 3'b011) & PREADY; assign pprot_nxt[0] = HPROT[1]; // (0) Normal, (1) Privileged assign pprot_nxt[1] = ~HPROT[0]; // (0) Data, (1) Instruction // Byte strobe generation // - Only enable for write operations // - For word write transfers (HSIZE[1]=1), all byte strobes are 1 // - For hword write transfers (HSIZE[0]=1), check HADDR[1] // - For byte write transfers, check HADDR[1:0] assign pstrb_nxt[0] = HWRITE & ((HSIZE[1])|((HSIZE[0])&(~HADDR[1]))|(HADDR[1:0]==2'b00)); assign pstrb_nxt[1] = HWRITE & ((HSIZE[1])|((HSIZE[0])&(~HADDR[1]))|(HADDR[1:0]==2'b01)); assign pstrb_nxt[2] = HWRITE & ((HSIZE[1])|((HSIZE[0])&( HADDR[1]))|(HADDR[1:0]==2'b10)); assign pstrb_nxt[3] = HWRITE & ((HSIZE[1])|((HSIZE[0])&( HADDR[1]))|(HADDR[1:0]==2'b11)); // Sample control signals always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) begin addr_reg <= {(ADDRWIDTH-2){1'b0}}; wr_reg <= 1'b0; pprot_reg <= {2{1'b0}}; pstrb_reg <= {4{1'b0}}; end else if (apb_select) begin // Capture transfer information at the end of AHB address phase addr_reg <= HADDR[ADDRWIDTH-1:2]; wr_reg <= HWRITE; pprot_reg <= pprot_nxt; pstrb_reg <= pstrb_nxt; end end // Sample write data control signal // Assert after write address phase, deassert after PCLKEN=1 wire sample_wdata_set = apb_select & HWRITE & reg_wdata_cfg; wire sample_wdata_clr = sample_wdata_reg & PCLKEN; always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) sample_wdata_reg <= 1'b0; else if (sample_wdata_set | sample_wdata_clr) sample_wdata_reg <= sample_wdata_set; end // Generate next state for FSM // Note : case 3'b111 is not used. The design has been checked that // this illegal state cannot be entered using formal verification. always @(state_reg or PREADY or PSLVERR or apb_select or reg_rdata_cfg or PCLKEN or reg_wdata_cfg or HWRITE) begin case (state_reg) // Idle ST_IDLE : begin if (PCLKEN & apb_select & ~(reg_wdata_cfg & HWRITE)) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else if (apb_select) next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high else next_state = ST_IDLE; // Remain idle end // Transfer announced on AHB, but PCLKEN was low, so waiting ST_APB_WAIT : begin if (PCLKEN) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high end // First APB transfer cycle ST_APB_TRNF : begin if (PCLKEN) next_state = ST_APB_TRNF2; // Change to second cycle of APB transfer else next_state = ST_APB_TRNF; // Change to state-2 end // Second APB transfer cycle ST_APB_TRNF2 : begin if (PREADY & PSLVERR & PCLKEN) // Error received - Generate two cycle // Error response on AHB by next_state = ST_APB_ERR1; // Changing to state-5 and 6 else if (PREADY & (~PSLVERR) & PCLKEN) begin // Okay received if (reg_rdata_cfg) // Registered version next_state = ST_APB_ENDOK; // Generate okay response in state 4 else // Non-registered version next_state = {2'b00, apb_select}; // Terminate transfer end else // Slave not ready next_state = ST_APB_TRNF2; // Unchange end // Ending cycle for OKAY (registered response) ST_APB_ENDOK : begin if (PCLKEN & apb_select & ~(reg_wdata_cfg & HWRITE)) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else if (apb_select) next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high else next_state = ST_IDLE; // Remain idle end // First cycle for Error response ST_APB_ERR1 : next_state = ST_APB_ERR2; // Goto 2nd cycle of error response // Second cycle for Error response ST_APB_ERR2 : begin if (PCLKEN & apb_select & ~(reg_wdata_cfg & HWRITE)) next_state = ST_APB_TRNF; // Start APB transfer in next cycle else if (apb_select) next_state = ST_APB_WAIT; // Wait for start of APB transfer at PCLKEN high else next_state = ST_IDLE; // Remain idle end default : // Not used next_state = 3'bxxx; // X-Propagation endcase end // Registering state machine always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) state_reg <= 3'b000; else state_reg <= next_state; end // Sample PRDATA or HWDATA always @(posedge HCLK or negedge HRESETn) begin if (~HRESETn) rwdata_reg <= {32{1'b0}}; else if (sample_wdata_reg & reg_wdata_cfg & PCLKEN) rwdata_reg <= HWDATA; else if (apb_tran_end & reg_rdata_cfg & PCLKEN) rwdata_reg <= PRDATA; end // Connect outputs to top level assign PADDR = {addr_reg, 2'b00}; // from sample register assign PWRITE = wr_reg; // from sample register // From sample register or from HWDATA directly assign PWDATA = (reg_wdata_cfg) ? rwdata_reg : HWDATA; assign PSEL = (state_reg == ST_APB_TRNF) | (state_reg == ST_APB_TRNF2); assign PENABLE = (state_reg == ST_APB_TRNF2); assign PPROT = {pprot_reg[1], 1'b0, pprot_reg[0]}; assign PSTRB = pstrb_reg[3:0]; // Generate HREADYOUT always @(state_reg or reg_rdata_cfg or PREADY or PSLVERR or PCLKEN) begin case (state_reg) ST_IDLE : HREADYOUT = 1'b1; // Idle ST_APB_WAIT : HREADYOUT = 1'b0; // Transfer announced on AHB, but PCLKEN was low, so waiting ST_APB_TRNF : HREADYOUT = 1'b0; // First APB transfer cycle // Second APB transfer cycle: // if Non-registered feedback version, and APB transfer completed without error // Then response with ready immediately. If registered feedback version, // wait until state_reg == ST_APB_ENDOK ST_APB_TRNF2 : HREADYOUT = (~reg_rdata_cfg) & PREADY & (~PSLVERR) & PCLKEN; ST_APB_ENDOK : HREADYOUT = reg_rdata_cfg; // Ending cycle for OKAY (registered response only) ST_APB_ERR1 : HREADYOUT = 1'b0; // First cycle for Error response ST_APB_ERR2 : HREADYOUT = 1'b1; // Second cycle for Error response default : HREADYOUT = 1'bx; // x propagation (note :3'b111 is illegal state) endcase end // From sample register or from PRDATA directly assign HRDATA = (reg_rdata_cfg) ? rwdata_reg : PRDATA; assign HRESP = (state_reg == ST_APB_ERR1) | (state_reg == ST_APB_ERR2); assign APBACTIVE = (HSEL & HTRANS[1]) | (|state_reg); endmodule使用的测试用例和AHB从机的测试用例基本一样，首先是顶层： `timescale 1ns / 1ps module top_tb(); //---------------------------------- // Local Parameter Declarations //---------------------------------- localparam AHB_CLK_PERIOD = 5; // Assuming AHB CLK to be 100MHz localparam SIZE_IN_BYTES = 2048; localparam ADDRWIDTH = 32; //---------------------------------- // Variable Declarations //---------------------------------- reg HCLK = 0; wire HWRITE; wire [1:0] HTRANS; wire [2:0] HSIZE; wire [2:0] HBURST; wire HREADYIN; wire [31:0] HADDR; wire [3:0] HPROT; wire [31:0] HWDATA; wire HREADYOUT; wire [1:0] HRESP; wire [31:0] HRDATA; reg HRESETn; wire HREADY; wire [ADDRWIDTH-1:0] PADDR; // APB Address wire PENABLE; // APB Enable wire PWRITE; // APB Write wire [31:0] PWDATA; // APB write data wire PSEL; // APB Select wire PREADY; wire PSLVERR; wire [2:0] PPROT; wire [3:0] PSTRB; wire [31:0] PRDATA; //---------------------------------- // Start of Main Code //---------------------------------- assign HREADY = HREADYOUT; //----------------------------------------------------------------------- // Generate HCLK //----------------------------------------------------------------------- always #AHB_CLK_PERIOD HCLK <= ~HCLK; //----------------------------------------------------------------------- // Generate HRESETn //----------------------------------------------------------------------- initial begin HRESETn = 1'b0; repeat(5) @(posedge HCLK); HRESETn = 1'b1; end ahb_master #( .START_ADDR (32'h0), .DEPTH_IN_BYTES (SIZE_IN_BYTES) ) u_ahb_master ( .HRESETn (HRESETn), .HCLK (HCLK), .HADDR (HADDR), .HPROT (HPROT), .HTRANS (HTRANS), .HWRITE (HWRITE), .HSIZE (HSIZE), .HBURST (HBURST), .HWDATA (HWDATA), .HRDATA (HRDATA), .HRESP (HRESP), .HREADY (HREADYOUT) ); ahb_to_apb #( .ADDRWIDTH (ADDRWIDTH), .REGISTER_RDATA (0), .REGISTER_WDATA (0) ) u_ahb_to_apb( .HCLK (HCLK), .HRESETn (HRESETn), .PCLKEN (1'b1), .HSEL (1'b1), .HADDR (HADDR), .HTRANS (HTRANS), .HSIZE (HSIZE), .HPROT (HPROT), .HWRITE (HWRITE), .HREADY (HREADY), .HWDATA (HWDATA), .HREADYOUT (HREADYOUT), .HRDATA (HRDATA), .HRESP (HRESP), .PADDR (PADDR), .PENABLE (PENABLE), .PWRITE (PWRITE), .PREADY (PREADY), .PSLVERR (PSLVERR), .PSTRB (PSTRB), .PPROT (PPROT), .PWDATA (PWDATA), .PSEL (PSEL), .APBACTIVE (APBACTIVE), .PRDATA (PRDATA) ); apb_mem #( .P_SLV_ID (0), .ADDRWIDTH (ADDRWIDTH), .P_SIZE_IN_BYTES (SIZE_IN_BYTES), .P_DELAY (0) ) u_apb_mem ( `ifdef AMBA_APB3 .PREADY (PREADY), .PSLVERR (PSLVERR), `endif `ifdef AMBA_APB4 .PSTRB (PSTRB), .PPROT (PPROT), `endif .PRESETn (HRESETn), .PCLK (HCLK), .PSEL (PSEL), .PENABLE (PENABLE), .PADDR (PADDR), .PWRITE (PWRITE), .PRDATA (PRDATA), .PWDATA (PWDATA) ); `ifdef VCS initial begin $fsdbDumpfile("top_tb.fsdb"); $fsdbDumpvars; end initial begin `ifdef DUMP_VPD $vcdpluson(); `endif end `endif endmodule然后是AHB master的功能模型： `timescale 1ns / 1ps `define SINGLE_TEST `define BURST_TEST module ahb_master #( //---------------------------------- // Paramter Declarations //---------------------------------- parameter START_ADDR = 0, parameter DEPTH_IN_BYTES = 32'h100, parameter END_ADDR = START_ADDR+DEPTH_IN_BYTES-1 ) ( //---------------------------------- // IO Declarations //---------------------------------- input wire HRESETn, input wire HCLK, output reg [31:0] HADDR, output reg [1:0] HTRANS, output reg HWRITE, output reg [2:0] HSIZE, output reg [2:0] HBURST, output reg [3:0] HPROT, output reg [31:0] HWDATA, input wire [31:0] HRDATA, input wire [1:0] HRESP, input wire HREADY ); //---------------------------------- // Variable Declarations //---------------------------------- reg [31:0] data_burst[0:1023]; //---------------------------------- // Start of Main Code //---------------------------------- initial begin HADDR = 0; HTRANS = 0; HPROT = 0; HWRITE = 0; HSIZE = 0; HBURST = 0; HWDATA = 0; while(HRESETn === 1'bx) @(posedge HCLK); while(HRESETn === 1'b1) @(posedge HCLK); while(HRESETn === 1'b0) @(posedge HCLK); `ifdef SINGLE_TEST repeat(3) @(posedge HCLK); memory_test(START_ADDR, END_ADDR, 1); memory_test(START_ADDR, END_ADDR, 2); memory_test(START_ADDR, END_ADDR, 4); `endif `ifdef BURST_TEST repeat(5) @(posedge HCLK); memory_test_burst(START_ADDR, END_ADDR, 1); memory_test_burst(START_ADDR, END_ADDR, 2); memory_test_burst(START_ADDR, END_ADDR, 4); memory_test_burst(START_ADDR, END_ADDR, 6); memory_test_burst(START_ADDR, END_ADDR, 8); memory_test_burst(START_ADDR, END_ADDR, 10); memory_test_burst(START_ADDR, END_ADDR, 16); memory_test_burst(START_ADDR, END_ADDR, 32); memory_test_burst(START_ADDR, END_ADDR, 64); memory_test_burst(START_ADDR, END_ADDR, 128); memory_test_burst(START_ADDR, END_ADDR, 255); repeat(5) @(posedge HCLK); `endif $finish(2); end //----------------------------------------------------------------------- // Single transfer test //----------------------------------------------------------------------- task memory_test; input [31:0] start; // start address input [31:0] finish; // end address input [2:0] size; // data size: 1, 2, 4 integer i; integer error; reg [31:0] data; reg [31:0] gen; reg [31:0] got; reg [31:0] reposit[START_ADDR:END_ADDR]; begin $display("%m: read-after-write test with %d-byte access", size); error = 0; gen = $random(7); for (i = start; i < (finish-size+1); i = i + size) begin gen = $random & ~32'b0; data = align(i, gen, size); ahb_write(i, size, data); ahb_read(i, size, got); got = align(i, got, size); if (got !== data) begin $display("[%10d] %m A:%x D:%x, but %x expected", $time, i, got, data); error = error + 1; end end if (error == 0) $display("[%10d] %m OK: from %x to %x", $time, start, finish); $display("%m read-all-after-write-all with %d-byte access", size); error = 0; gen = $random(1); for (i = start; i < (finish-size+1); i = i + size) begin gen = {$random} & ~32'b0; data = align(i, gen, size); reposit[i] = data; ahb_write(i, size, data); end for (i = start; i < (finish-size+1); i = i + size) begin data = reposit[i]; ahb_read(i, size, got); got = align(i, got, size); if (got !== data) begin $display("[%10d] %m A:%x D:%x, but %x expected", $time, i, got, data); error = error + 1; end end if (error == 0) $display("[%10d] %m OK: from %x to %x", $time, start, finish); end endtask //----------------------------------------------------------------------- // Burst transfer test //----------------------------------------------------------------------- task memory_test_burst; input [31:0] start; // start address input [31:0] finish; // end address input [7:0] leng; // burst length integer i; integer j; integer k; integer r; integer error; reg [31:0] data; reg [31:0] gen; reg [31:0] got; reg [31:0] reposit[0:1023]; integer seed; begin $display("[%10d] %m: read-all-after-write-all burst test with %d-beat access", $time, leng); error = 0; seed = 111; gen = $random(seed); k = 0; if (finish > (start+leng*4)) begin for (i = start; i < (finish-(leng*4)+1); i = i + leng*4) begin for (j = 0; j < leng; j = j + 1) begin data_burst[j] = $random; reposit[j+k*leng] = data_burst[j]; end @(posedge HCLK); ahb_write_burst(i, leng); k = k + 1; end gen = $random(seed); k = 0; for (i = start; i < (finish-(leng*4)+1); i = i + leng*4) begin @(posedge HCLK); ahb_read_burst(i, leng); for (j = 0; j < leng; j = j + 1) begin if (data_burst[j] != reposit[j+k*leng]) begin error = error+1; $display("[%10d] %m A=%hh D=%hh, but %hh expected", $time, i+j*leng, data_burst[j], reposit[j+k*leng]); end end k = k + 1; r = $random & 8'h0F; repeat(r) @(posedge HCLK); end if (error == 0) $display("%m %d-length burst read-after-write OK: from %hh to %hh",leng, start, finish); end else begin $display("%m %d-length burst read-after-write from %hh to %hh ???",leng, start, finish); end end endtask //----------------------------------------------------------------------- // As AMBA AHB bus uses non-justified data bus scheme, data should be // aligned according to the address. //----------------------------------------------------------------------- function [31:0] align; input [ 1:0] addr; input [31:0] data; input [ 2:0] size; // num of bytes begin `ifdef BIG_ENDIAN case (size) 1 : case (addr[1:0]) 0 : align = data & 32'hFF00_0000; 1 : align = data & 32'h00FF_0000; 2 : align = data & 32'h0000_FF00; 3 : align = data & 32'h0000_00FF; endcase 2 : case (addr[1]) 0 : align = data & 32'hFFFF_0000; 1 : align = data & 32'h0000_FFFF; endcase 4 : align = data&32'hFFFF_FFFF; default : $display($time,,"%m ERROR %d-byte not supported for size", size); endcase `else case (size) 1 : case (addr[1:0]) 0 : align = data & 32'h0000_00FF; 1 : align = data & 32'h0000_FF00; 2 : align = data & 32'h00FF_0000; 3 : align = data & 32'hFF00_0000; endcase 2 : case (addr[1]) 0 : align = data & 32'h0000_FFFF; 1 : align = data & 32'hFFFF_0000; endcase 4 : align = data&32'hFFFF_FFFF; default : $display($time,,"%m ERROR %d-byte not supported for size", size); endcase `endif end endfunction `include "ahb_transaction_tasks.v" endmoduleahb_transaction_tasks.v文件如下： `ifndef __AHB_TRANSACTION_TASKS_V__ `define __AHB_TRANSACTION_TASKS_V__ //----------------------------------------------------------------------- // AHB Read Task //----------------------------------------------------------------------- task ahb_read; input [31:0] address; input [2:0] size; output [31:0] data; begin @(posedge HCLK); HADDR <= #1 address; HPROT <= #1 4'b0001; // DATA HTRANS <= #1 2'b10; // NONSEQ; HBURST <= #1 3'b000; // SINGLE; HWRITE <= #1 1'b0; // READ; case (size) 1 : HSIZE <= #1 3'b000; // BYTE; 2 : HSIZE <= #1 3'b001; // HWORD; 4 : HSIZE <= #1 3'b010; // WORD; default : $display($time,, "ERROR: unsupported transfer size: %d-byte", size); endcase @(posedge HCLK); while (HREADY !== 1'b1) @(posedge HCLK); HTRANS <= #1 2'b0; // IDLE @(posedge HCLK); while (HREADY === 0) @(posedge HCLK); data = HRDATA; // must be blocking if (HRESP != 2'b00) $display($time,, "ERROR: non OK response for read"); @(posedge HCLK); end endtask //----------------------------------------------------------------------- // AHB Write Task //----------------------------------------------------------------------- task ahb_write; input [31:0] address; input [2:0] size; input [31:0] data; begin @(posedge HCLK); HADDR <= #1 address; HPROT <= #1 4'b0001; // DATA HTRANS <= #1 2'b10; // NONSEQ HBURST <= #1 3'b000; // SINGLE HWRITE <= #1 1'b1; // WRITE case (size) 1 : HSIZE <= #1 3'b000; // BYTE 2 : HSIZE <= #1 3'b001; // HWORD 4 : HSIZE <= #1 3'b010; // WORD default : $display($time,, "ERROR: unsupported transfer size: %d-byte", size); endcase @(posedge HCLK); while (HREADY !== 1) @(posedge HCLK); HWDATA <= #1 data; HTRANS <= #1 2'b0; // IDLE @(posedge HCLK); while (HREADY === 0) @(posedge HCLK); if (HRESP != 2'b00) $display($time,, "ERROR: non OK response write"); @(posedge HCLK); end endtask //----------------------------------------------------------------------- // AHB Read Burst Task //----------------------------------------------------------------------- task ahb_read_burst; input [31:0] addr; input [31:0] leng; integer i; integer ln; integer k; begin k = 0; @(posedge HCLK); HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR ln = leng; end HWRITE <= #1 1'b0; // READ HSIZE <= #1 3'b010; // WORD @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); while (leng > 0) begin for (i = 0; i < ln-1; i = i + 1) begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b11; // SEQ; @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); data_burst[k%1024] <= HRDATA; k = k + 1; end leng = leng - ln; if (leng == 0) begin HADDR <= #1 0; HTRANS <= #1 0; HBURST <= #1 0; HWRITE <= #1 0; HSIZE <= #1 0; end else begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR1 ln = leng; end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); data_burst[k%1024] = HRDATA; // must be blocking k = k + 1; end end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); data_burst[k%1024] = HRDATA; // must be blocking end endtask //----------------------------------------------------------------------- // AHB Write Burst Task // It takes suitable burst first and then incremental. //----------------------------------------------------------------------- task ahb_write_burst; input [31:0] addr; input [31:0] leng; integer i; integer j; integer ln; begin j = 0; ln = 0; @(posedge HCLK); while (leng > 0) begin HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b10; // NONSEQ if (leng >= 16) begin HBURST <= #1 3'b111; // INCR16 ln = 16; end else if (leng >= 8) begin HBURST <= #1 3'b101; // INCR8 ln = 8; end else if (leng >= 4) begin HBURST <= #1 3'b011; // INCR4 ln = 4; end else begin HBURST <= #1 3'b001; // INCR ln = leng; end HWRITE <= #1 1'b1; // WRITE HSIZE <= #1 3'b010; // WORD for (i = 0; i < ln-1; i = i + 1) begin @(posedge HCLK); while (HREADY == 1'b0) @(posedge HCLK); HWDATA <= #1 data_burst[(j+i)%1024]; HADDR <= #1 addr; addr = addr + 4; HTRANS <= #1 2'b11; // SEQ; while (HREADY == 1'b0) @(posedge HCLK); end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); HWDATA <= #1 data_burst[(j+i)%1024]; if (ln == leng) begin HADDR <= #1 0; HTRANS <= #1 0; HBURST <= #1 0; HWRITE <= #1 0; HSIZE <= #1 0; end leng = leng - ln; j = j + ln; end @(posedge HCLK); while (HREADY == 0) @(posedge HCLK); if (HRESP != 2'b00) begin // OKAY $display($time,, "ERROR: non OK response write"); end `ifdef DEBUG $display($time,, "INFO: write(%x, %d, %x)", addr, size, data); `endif HWDATA <= #1 0; @(posedge HCLK); end endtask `endif还需要一个APB的从机模块： `timescale 1ns / 1ps `define AMBA_APB3 `define AMBA_APB4 module apb_mem #( parameter P_SLV_ID = 0, parameter ADDRWIDTH = 32, parameter P_SIZE_IN_BYTES = 1024, // memory depth parameter P_DELAY = 0 // reponse delay ) ( //---------------------------------- // IO Declarations //---------------------------------- `ifdef AMBA_APB3 output wire PREADY, output wire PSLVERR, `endif `ifdef AMBA_APB4 input wire [2:0] PPROT, input wire [3:0] PSTRB, `endif input wire PRESETn, input wire PCLK, input wire PSEL, input wire PENABLE, input wire [ADDRWIDTH-1:0] PADDR, input wire PWRITE, output reg [31:0] PRDATA = 32'h0, input wire [31:0] PWDATA ); //---------------------------------- // Local Parameter Declarations //---------------------------------- localparam DEPTH = (P_SIZE_IN_BYTES+3)/4; localparam AW = logb2(P_SIZE_IN_BYTES); //---------------------------------- // Variable Declarations //---------------------------------- `ifndef AMBA_APB3 wire PREADY; `else assign PSLVERR = 1'b0; `endif `ifndef AMBA_APB4 wire [3:0] PSTRB = 4'hF; `endif reg [7:0] mem0[0:DEPTH-1]; reg [7:0] mem1[0:DEPTH-1]; reg [7:0] mem2[0:DEPTH-1]; reg [7:0] mem3[0:DEPTH-1]; wire [AW-3:0] TA = PADDR[AW-1:2]; //---------------------------------- // Start of Main Code //---------------------------------- //-------------------------------------------------------------------------- // write transfer // ____ ____ ____ // PCLK ___| |____| |____| |_ // ____ ___________________ _____ // PADDR ____X__A________________X_____ // ____ ___________________ _____ // PWDATA ____X__DW_______________X_____ // ___________________ // PWRITE ____| |_____ // ___________________ // PSEL ____| |_____ // _________ // PENABLE ______________| |_____ //-------------------------------------------------------------------------- always @(posedge PCLK) begin if (PRESETn & PSEL & PENABLE & PWRITE & PREADY) begin if (PSTRB[0]) mem0[TA] <= PWDATA[ 7: 0]; if (PSTRB[1]) mem1[TA] <= PWDATA[15: 8]; if (PSTRB[2]) mem2[TA] <= PWDATA[23:16]; if (PSTRB[3]) mem3[TA] <= PWDATA[31:24]; end end //-------------------------------------------------------------------------- // read // ____ ____ ____ // PCLK ___| |____| |____| |_ // ____ ___________________ _____ // PADDR ____X__A________________X_____ // ____ _________ _____ // PRDATA ____XXXXXXXXXXX__DR_____X_____ // ____ _____ // PWRITE ____|___________________|_____ // ___________________ // PSEL ____| |_____ // _________ // PENABLE ______________| |_____ //-------------------------------------------------------------------------- always @(posedge PCLK) begin if (PRESETn & PSEL & ~PENABLE & ~PWRITE) begin PRDATA[ 7: 0] <= mem0[TA]; PRDATA[15: 8] <= mem1[TA]; PRDATA[23:16] <= mem2[TA]; PRDATA[31:24] <= mem3[TA]; end end `ifdef AMBA_APB3 localparam ST_IDLE = 'h0, ST_CNT = 'h1, ST_WAIT = 'h2; reg [7:0] count; reg ready; reg [1:0] state=ST_IDLE; assign PREADY = (P_DELAY == 0) ? 1'b1 : ready; always @(posedge PCLK or negedge PRESETn) begin if (PRESETn == 1'b0) begin count <= 'h0; ready <= 'b1; state <= ST_IDLE; end else begin case (state) ST_IDLE : begin if (PSEL && (P_DELAY > 0)) begin ready <= 1'b0; count <= 'h1; state <= ST_CNT; end else begin ready <= 1'b1; end end // ST_IDLE ST_CNT : begin count <= count + 1; if (count >= P_DELAY) begin count <= 'h0; ready <= 1'b1; state <= ST_WAIT; end end // ST_CNT ST_WAIT : begin ready <= 1'b1; state <= ST_IDLE; end // ST_WAIT default : begin ready <= 1'b1; state <= ST_IDLE; end endcase end // if end // always `else assign PREADY = 1'b1; `endif // Calculate log-base2 function integer logb2; input [31:0] value; reg [31:0] tmp; begin tmp = value - 1; for (logb2 = 0; tmp > 0; logb2 = logb2 + 1) tmp = tmp >> 1; end endfunction // synopsys translate_off `ifdef RIGOR always @(posedge PCLK or negedge PRESETn) begin if (PRESETn == 1'b0) begin end else begin if (PSEL & PENABLE) begin if (TA >= DEPTH) $display($time,,"%m: ERROR: out-of-bound 0x%x", PADDR); end end end `endif // synopsys translate_on endmodule6、仿真用VCS进行仿真，打印信息如下图片可见仿真完全正确，这里也只是做了AHB总线的单一传输和各种长度的增量突发，回环突发未涉及（对APB桥来说，它并不关心HBURST的信号值）。下面挂两张仿真截图：单一传输，先写后读：图片突发传输，先写完，再读完图片

IP&SOC设计 # SOC设计

刘航宇 3年前
1 1,575 1
数字锁相环(DPLL)研究与设计-面向FPGA/数字IC 前言锁相环的原理和组成数字锁相环的原理和组成数字鉴相器设计DPD 数字振荡器(DCO) 数字缓冲器(DB) 数字锁相环(DPLL)的实现电路硬件与性能评估工程代码下载前言随着数字电路技术的发展，数字锁相环在调制解调、频率合成、FM 立体声解码、彩色副载波同步、图象处理等各个方面得到了广泛的应用。数字锁相环不仅吸收了数字电路可靠性高、体积小、价格低等优点，还解决了模拟锁相环的直流零点漂移、器件饱和及易受电源和环境温度变化等缺点，此外还具有对离散样值的实时处理能力，已成为锁相技术发展的方向。所谓数字PLL，就是指应用于数字系统的PLL，也就是说数字PLL中的各个模块都是以数字器件来实现的，是一个数字的电路。数字锁相环的优点是电路最简单有效,可采用没有压控的晶振,降低了成本,提高了晶振的稳定性。但缺点是和模拟锁相环一样,一旦失去基准频率,输出频率立刻跳回振荡器本身的频率;另外还有一个缺点,就是当进行频率调整的时候，输出频率会产生抖动，频差越大，抖动会越大于密，不利于某些场合的应用。随着大规模、超高速的数字集成电路的发展，为数字锁相环路的研究与应用提供了广阔空间。由于晶体振荡器和数字调整技术的加盟，可以在不降低振荡器的频率稳定度的情况下，加大频率的跟踪范围，从而提高整个环路工作的稳定性与可靠性。简单的说有两个不同来源的信号：一个信号是参考信号，这个信号一般是由芯片的晶振得到的信号，它具有信号的稳定性较好等优点，但是其频率是固定不变的。另一个信号是由芯片或者模块内部的压控振荡器得到的。这种由压控振荡器得到的信号可以是某范围内的任意频率的信号，但是这种信号的稳定型较差，容易受到外界干扰。那么在实际使用过程中，我们需要一种频率能够变化的，同时质量较好的信号；或者对于一块芯片，我们需要不同的模块的内部时钟（这种时钟可以是压控振荡器产生）都能参考一个总的时钟来进行同步，从而避免两个模块内部时钟的差异而产生的数据传输的漂移等问题。因此，如何将压控振荡器得到的信号能够具有晶振信号的信号质量呢？那就是通过PLL锁相环来实现，如图1所示。只要压控振荡器产生的时钟（下称输入信号）是参考信号的整数倍（或者整除倍），那么就能将输入信号先进行分频，后得到与参考信号频率相同的时钟，将分频后的信号和参考信号进行比较，从而使分频后的信号和参考信号保持相同的稳定的频率和相位。被分频后的信号稳定，也就是间接的表示输入信号的稳定。从而我们得到了一个频率在一定范围内可变的稳定的信号。有上述可以看出，锁相环具有以下功能：（1）能够将一个信号和另一参考信号同步；（2）当这个信号是输出信号分频后得到的信号，PLL就能够得到参考信号的倍频信号（实际上倍频器很多都是利用了这个功能）；（3）当输入信号频率可变、分频系数可变时，PLL就能够得到在频率一定范围内稳定信号。图片锁相环的原理和组成锁相环（PLL）的作用我们已经大概了解了，其最主要功能的实现，是在于如何将两个频率不同、相位差始终在变化的信号，变成两个相同频率、相同相位的信号。这里引入一个概念，首先我们都知道，对于三角函数，只有两个同频率的三角函数才能比较其相位差。但这里的相位差是指两个正弦函数的初始相位差。而实际上根据三角函数的欧拉定义的理解来看，我们可以把三角函数看做是在某个圆上逆时针运动的点到x轴的距离。那么频率就是点在圆上运动的角速度，频率越大，其运动的角速度越大。相位就是点在圆上的位置，而初始相位就是点在圆上开始运动时的位置。当两个点的运动角速度相同时，我们可以得到两个点的初始位置差，就是两个正弦函数频率相同时，得到初始相位差。这个差值在运动过程中一直是不变的。但是当两个点运动角速度不同时，我们去看它的初始位置差是没有意义的，因为两个点的位置差是一直在变的，而初始位置差只是一个开始的位置差，是个不变的量，所以说对于频率不同的三角函数，我们讨论起初始相位差是没有意义的。但是不代表不能比较某一时刻两个点的位置。也就是相位差，相位是存在的。图片现在我们假设两个点在圆上赛跑，如图3所示，我们想让这两个点角速度相等。那么有一个办法就是以一个点为参考，参考点角速度不变，另一个点是速度可变点。每过一段时间，观察另一个点到参考点的位置，是在前，还是在后。如果在前，就让另一个点速度慢一点；如果在后，就让另一个点速度快一点。就这样不断调整另一个点的角速度，直到每次观察两个点都处于相同的位置。这样我们就可以认为这两个点达到了相同的速度。这种方法就是利用反馈调节来实现两个信号的同频同相。也就是锁相环（PLL）的实现原理。首先通过一个鉴相器来得到两个信号之间的相位差。并根据相位差输出电压信号。然后通过滤波器稳压后得到稳定的电压信号，该信号驱动压控振荡器得到新的频率的信号。当两个信号存在相位差时，电压信号就会改变，从而使受控信号不断变化。直到当两个信号没有相位差时，电压信号不再改变，从而使受控信号保持当前频率，这时，受控信号不再变化了，就叫做受控信号被锁定了。由上所述，一个锁相环由鉴相器、滤波器、振荡器三部分组成。外部输入是参考信号，内部输入和总的输出是受控信号。数字锁相环的原理和组成在数字电路中，原来模拟信号正弦波、余弦波的频率和相位变成了0和1的脉冲信号，那么我们如何理解数字信号中的频率和相位呢？对于脉冲信号来说，我们可以把频率理解为在某固定时间内脉冲出现的个数，为了方便表示，我们把上升沿的出现视为脉冲的出现，把相邻两个脉冲出现的时间t求倒数，就得到了该信号在这个时刻处的信号频率。而对于相位，相位差就是指，存在两个脉冲信号，以一个脉冲信号为参考，在其出现脉冲后，到另一个信号出现脉冲之间的时间差就是相位差，当另一个信号脉冲晚于参考信号脉冲出现的时间，称之为另一个信号的相位滞后于参考信号。当另一个信号的脉冲出现在参考信号之前，称之为另一个信号的相位提前于参考信号。上述是一种较为简单的描述方式，适合初识脉冲信号的读者理解。而实际上，对于脉冲信号的频率、相位等问题，严格来说这样理解有一点点问题，但是对于我们来搭建数字锁相环DPLL来说足够了。其实这种三角函数和信号之间的转化，其根本的原理来源于傅里叶变换，从而我们对一个时间域上的信号（例如脉冲信号）可以进行频率域（其代表的三角函数的合成）上的分析。我们知道了在数字电路中，脉冲信号也有了频率和相位的属性。那么我们的参考信号是以来时钟源的固定频率的信号，因为信号的质量比较好，所以该信号两个脉冲之间的时间差均是相同的，误差很小。我们在参考信号出现上升沿时，观察受控信号此时的状态。如果受控信号为高电平，我们就认为此时受控信号超前于参考信号；反之，如果受控信号是低电平，则认为此时的受控信号滞后于参考信号。当出现超前状态时，鉴相器会输出一个超前信号，超前信号会作用于振荡器，使得振荡器发出的受控信号频率降低。而滞后信号会使振荡器发出的受控信号频率升高，从而实现受控信号频率的反馈调节。如图4所示，当参考信号出现上升沿时，受控信号为低电平，此时输出一个滞后信号。（由于模块只在时钟为上升沿时触发，所以超前信号的触发延迟了半个时钟周期）图片由此我们能够大概了解了数字锁相环中如何看待脉冲信号的频率和相位，如何处理得到相位差以及相位差如何在锁相环中起作用来实现信号频率的反馈控制。同模拟的锁相环（PLL）类似，数字锁相环（DPLL）也是由：数字鉴相器（Digital Phase Detector）、数字缓冲器（Digital Buffer）、数字振荡器（Digital Controlled Oscillator）三个模块构成，其外部输入为参考信号，内部输入和输出为受控信号。下面我们就来具体讨论如何用verilog实现各个模块。数字鉴相器设计DPD 实现一个数字锁相环（DPLL），最重要的部分就是实现数字鉴相器（DPD）和数字振荡器（DF）。并且，这两个模块并不是独立存在的，而是说，数字振荡器的实现方式和数字振荡器的实现方式相互影响。所以只有两个模块共同设计，才能较好的实现一个数字锁相环的功能。首先我们来具体讨论一下一个数字鉴相器应该具有那些功能和特性：顾名思义，数字鉴相器就是能够鉴别两个数字信号相位的差别，并通过信号将这种差别表示出来。由上文我们已经知道了，对于两个矩形方波信号，其相位差可以看做是两个信号先后出现上升沿（或下降沿）之间的时间差。为了方便表示，假设以其中一个信号作为参考信号，另一个信号为受控信号，当参考信号出现上升沿（或下降沿）时，观察另一个信号是否已经出现了上升沿（或下降沿）。如果还未出现上升沿（或下降沿），则叫做“受控信号滞后于参考信号”，或者简称“滞后”；如果已经出现了上升沿（或下降沿），则叫做“受控信号提前于参考信号”，或者简称“提前”。而判断上升沿（或下降沿）是否已经出现，方法就是看当参考信号出现上升沿时，受控信号是1还是0：当受控信号为0，表示上升沿还没出现，所以是“滞后”；当受控信号为1，表示上升沿已经出现，所以是“提前”。对于下降沿也是按照同样的方法考虑。图片目前为止，我们已经有两个输入，参考信号和受控信号；两个输出，滞后信号和提前信号。如何通过verilog实现上述的输入输出关系呢？首先先讲异或与门，通过图4的描述，我们可以很容易看出来：滞后信号是参考信号与受控信号先异或，异或的结果和受控信号相与得到；提前信号是参考信号与受控信号先异或，异或的结果和参考信号相与得到。再加上一个RST的复位信号，我们可以得到如下图5电路：图片根据这个关系，来调节受控信号的频率，从而使受控信号的频率和参考信号最终相同。再考虑，如果按照上述方法调节，当受控信号和参考信号频率相差很大时，就会出现刚开始有一段时间，受控信号的频率是不断变化，不可预知的。这样的调节效果实时性并不好，需要时间来稳定。因此读者想到，如果能够在参考信号出现上升沿时，就让受控信号也出现上升沿，相当于两个人在赛跑时，当一个人从起点出发时，无论另一个人在哪，强制让另一个人也回到原点，两个人一起从原点出发。这样就能使受控信号和参考信号强制达到相同的频率，只是此时受控信号的占空比不是50%。然后再根据滞后和提前信号，调节受控信号的占空比，从而最终达到50%的占空比。按照这种方法，鉴相器就需要一个信号输出来表示上升沿的出现。再考虑到电路中的总的时钟源，我们这里采用触发的方法来实现。同时将上述的异或与门加入到代码中可以得到数字鉴相器的代码。但是在实际运用过程中发现，可能存在着受控信号先出现上升沿，从而过早的出现了提前或者滞后信号，导致数字振荡器的计数器上限呈现一个周期变化的不可控的数值的情况。为了避免这种情况，需要仔细考虑参考信号和受控信号如何生成提前和滞后信号这个问题，而不是简单的用异或来实现。如图6表示这种关系。图片按照上述代码写出来的数字鉴相器，具有更好的性能。根据这个表格，通过类似状态机的方法，来实现提前信号和滞后信号的输出。此外异或门配合D触发器方式也可以实现鉴相器效果仍可应用于本设计中。示例代码如下： module DPD_2 ( input reference_signal, // 参考时钟输入（来自外部晶振或基准源） input controlled_signal, // 反馈时钟输入（来自VCO分频后的时钟） input rst, // 异步复位信号，高电平有效 input clk, output reg lead_signal_wire, // 相位超前指示信号（输出到电荷泵） output reg lag_signal_wire, // 相位滞后指示信号（输出到电荷泵） output bothEdge ); // 延迟寄存器：用于检测两个时钟的到达顺序 reg ref_flag, fb_flag; reg ref_nflag, fb_nflag; reg lead_signal,lead_signal_n; reg lag_signal,lag_signal_n; reg reference_signal_d1,reference_signal_d2; reg controlled_signal_d1,controlled_signal_d2; wire bothEdge_fb; reg fb_flag_d1,fb_flag_d2,fb_nflag_d1,fb_nflag_d2; reg ref_flag_d1,ref_flag_d2,ref_nflag_d1,ref_nflag_d2; always @(posedge clk or negedge rst) begin if(!rst) begin reference_signal_d1 <= 'd0; controlled_signal_d1 <= 'd0; fb_flag_d1 <= 'd0; fb_flag_d2 <= 'd0; fb_nflag_d1 <= 'd0; fb_nflag_d2 <= 'd0; ref_flag_d1 <= 'd0; ref_flag_d2 <= 'd0; ref_nflag_d1 <= 'd0; ref_nflag_d2 <= 'd0; end else begin reference_signal_d1 <= reference_signal; reference_signal_d2 <= reference_signal_d1; controlled_signal_d1 <= controlled_signal; controlled_signal_d2 <= controlled_signal_d1; fb_flag_d1 <= fb_flag; fb_flag_d2 <= fb_flag_d1; fb_nflag_d1 <= fb_nflag; fb_nflag_d2 <= fb_nflag_d1; ref_flag_d1 <= fb_flag; ref_flag_d2 <= ref_flag_d1; ref_nflag_d1 <= ref_nflag; ref_nflag_d2 <= ref_nflag_d1; end end assign bothEdge = reference_signal & (~reference_signal_d1); wire bothEdge_n; assign bothEdge_n = (~reference_signal) & reference_signal_d1; // assign bothEdge_fb = controlled_signal & (~controlled_signal_d1); wire bothEdge_fb_n; //控制下降沿 assign bothEdge_fb_n = (~controlled_signal) & controlled_signal_d1; // // 参考时钟延迟寄存器：在reference_signal上升沿采样 // 功能：标记参考时钟是否到来 always @(posedge reference_signal or negedge rst) begin if (!rst) begin ref_flag <= 1'b0; // 复位时清零 ref_nflag <= 1'b0; end else begin ref_flag <= 1'b1; // 参考时钟到来后置1 ref_nflag <= 1'b0; end end // 反馈时钟延迟寄存器：在controlled_signal上升沿采样 // 功能：标记反馈时钟是否到来 always @(posedge controlled_signal or negedge rst) begin if (!rst) begin fb_flag <= 1'b0; // 复位时清零 fb_nflag <= 1'b0; end else begin fb_flag <= 1'b1; // 反馈时钟到来后置1 fb_nflag <= 1'b0; end end // 主逻辑：检测相位关系 - 谁先来谁占优 // 在参考时钟上升沿判断：如果反馈时钟还没来，说明参考超前 always @(posedge reference_signal_d2) begin if (!fb_flag_d2) lag_signal <= 1'b1; // fb_dly为0表示controlled_signal尚未到达，reference_signal超前 else lag_signal <= 1'b0; // fb_dly为1表示controlled_signal已到，两者已对齐或参考滞后 end // 在反馈时钟上升沿判断：如果参考时钟还没来，说明反馈超前（即参考滞后） always @(posedge controlled_signal_d2) begin if (!ref_flag_d2) lead_signal <= 1'b1; // ref_dly为0表示reference_signal尚未到达，controlled_signal超前 else lead_signal <= 1'b0; // ref_dly为1表示reference_signal已到，两者已对齐或反馈滞后 end //下降沿 always @(negedge reference_signal or negedge rst) begin if (!rst) begin ref_nflag <= 1'b0; // 复位时清零 ref_flag <= 1'b0; end else begin ref_nflag <= 1'b1; // 参考时钟到来后置1 ref_flag <= 1'b0; end end always @(negedge controlled_signal or negedge rst) begin if (!rst) begin fb_nflag <= 1'b0; // 复位时清零 fb_flag <= 1'b0; end else begin fb_nflag <= 1'b1; // 反馈时钟到来后置1 fb_flag <= 1'b0; end end always @(negedge reference_signal_d2) begin if (!fb_nflag_d2) lag_signal_n <= 1'b1; // fb_dly为0表示controlled_signal尚未到达，reference_signal超前 else lag_signal_n <= 1'b0; // fb_dly为1表示controlled_signal已到，两者已对齐或参考滞后 end // 在反馈时钟上升沿判断：如果参考时钟还没来，说明反馈超前（即参考滞后） always @(negedge controlled_signal_d2) begin if (!ref_nflag_d2) lead_signal_n <= 1'b1; // ref_dly为0表示reference_signal尚未到达，controlled_signal超前 else lead_signal_n <= 1'b0; // ref_dly为1表示reference_signal已到，两者已对齐或反馈滞后 end // 消毛刺逻辑：在任一时钟下降沿清零lead_signal_wire/lag_signal_wire信号 // 防止多脉冲叠加，确保每个周期只产生一个有效脉冲 /* always @(negedge reference_signal or negedge controlled_signal) begin {lead_signal_wire, lag_signal_wire} <= 2'b00; // 在时钟下降沿同时复位两个输出 end */ always @(posedge clk or negedge rst) begin if (!rst) begin lead_signal_wire <= 'b0; lag_signal_wire <= 'b0; end //else if(bothEdge & bothEdge_fb) begin else if((bothEdge & bothEdge_fb) | (bothEdge_n & bothEdge_fb_n)) begin lead_signal_wire <= 'b0; lag_signal_wire <= 'b0; end else begin lead_signal_wire <= lead_signal | lead_signal_n; lag_signal_wire <= lag_signal | lag_signal_n; end end endmodule数字振荡器(DCO) 现在我们已经构造出来了一个数字鉴相器，接下来我们将继续探讨如何实现一个数字振荡器（DCO）。实现一个固定脉冲频率的信号，我们可以通过已知的时钟源，分频得到一定频率范围内的脉冲。具体实现方法就是通过计数器的方式，当出现时钟脉冲时，计数器+1，计数器上限就是分频系数，当计数器的数小于上限的1/2时，输出1，当计数器的数大于上限的1/2时，输出0，当计数器的数超过上限时，计数器归零。这样就能实现对时钟源的分频。根据上述方法，只要改变计数器的上下限，就能改变分频系数，从而改变输出信号的频率。再参考上文受控信号和滞后提前信号的关系，我们就能通过根据滞后提前信号，改变计数器上下限，来实现对受控信号频率的控制。当计数器上限增加时，分频系数增加，频率减小；当计数器上限减小时，分频系数减小，频率增加；因此有：滞后信号——>受控信号的频率小——>增加受控信号的频率——>计数器上限减小提前信号——>受控信号的频率大——>减小受控信号的频率——>计数器上限增加此外根据上述对上升沿触发同步的说法，当出现上升沿触发信号时，受控信号应强制产生上升沿，即受控信号强制从该脉冲周期的开始处开始，即计数器的数回到0从新开始计数。综上所述，再加上复位信号，一个数字振荡器的所有构成就有了。到这里，一个数字锁相环（DPLL）其实就已经能够实现了，因为数字滤波器（DB）只是让受控信号的抗干扰能力更强，如图所示是仿真后的结果：图片数字缓冲器(DB) 下面再介绍一下数字缓冲器，来使受控信号的抗干扰能力更强。前面我们知道了，持续一个时钟周期的提前信号或者滞后信号能够使数字振荡器的计数器上限加一或者减一。当我的预设的数字振荡器的计数器上限与实际的参考信号的频率对应的计数器上限两个数值相差很大时，就有可能出现锁相环调节时间过长等现象。为了解决这种情况，如果能够让原来持续一个周期的提前信号或滞后信号成倍数的增加，变成持续n个周期的提前信号或者滞后信号，就能够使数字振荡器的计数器上限修改更快，从而更快的到达参考频率附近。但是相应的，受控信号的频率精度就会降低。也就是说，牺牲精度，追求速度。同时考虑另外一种情况，如果我对速度要求不高，但是对于精度要求较高，同时在信号传输过程中可能存在干扰，导致接收到的提前信号或滞后信号不是完全真实的信号，此时就可以通过一个累加器，只有接受到n个周期的提前信号，或者滞后信号，才对数字振荡器输出一个进位信号或者借位信号，此时数字振荡器的计数器上限才只加减1，这样就能有效的提高精度，减少信号干扰带来的影响。但是这种做法牺牲了数字锁相换锁定的时间。综上所述，一个时钟周期的提前或滞后信号，对应n个时钟周期的借位或进位信号，是提高锁定速度，降低锁定精度。想法，n个时钟周期的提前或滞后信号，对应一个时钟周期的借位或进位信号，是提高锁定精度，降低锁定速度。因此在实际运用中，应该按照自己的工程需要，合理选择比值。上述过程的实现方法，是通过一个计数器，当接收到一个提前或滞后信号时，计数器加a，当输出一个进位或借位信号时，计数器减b，调节a和b的比值，就能实现上述过程。数字缓冲器的仿真效果： 1、分时效果图片 2、倍时效果图片数字锁相环(DPLL)的实现所有的子模块都已经实现了，剩下的数字锁相环的实现，根据实际的要求，将上述几个模块进行例化就行。例化后的测试结果如图9所示，可以看到受控信号逐渐与参考信号对齐达到锁相环效果。图片为了方便起见，对输出信号进行2分频，再次观察输出结果，输出相当于2倍频了，成功完成PD、DCO、Divider等模块正确设计。图片电路硬件与性能评估图11为电路硬件图从图中可以看出各模块的连接关系，每个模块由基本门电路构成。通过性能优化后的的电路如图12所示。图片利用SMIC180nm工艺进行电路综合，时序报告：周期2ns 图片面积报告：2119um2 图片功耗报告：uw级别图片工程代码下载

FPGA&ASIC # ASIC/FPGA

刘航宇 3年前
1 4,016 4
2023-06-20
Microsemi Libero SOC常见问题-FPGA全局网络的设置问题描述最近在一个FPGA工程中分配rst_n引脚时，发现rst_n引脚类型为CLKBUF，而不是常用的INBUF，在分配完引脚commit检查报错，提示需要连接到全局网络引脚上。 Running Global Checker... Error:PLC002:No legal assignment exists for global net rst.n_c. Info:Uhlocking the driver or removing the region constraint for net rst nc may help to satisfy Error:PLC005:Automat ic global net placement failed. 尝试忽略这个错误，直接进行编译，在布局布线时又报错。 Error: PLC002: No legal assignment exists for global net rst_n_c. Error: PLC005: Automatic global net placement failed. Error: Failure when executing Tcl script. [ Line 18 ] 尝试取消引脚锁定LOCK，再次commit检查成功，编译下载正常，但是功能不对，再次打开引脚分配界面，发现是rst_n对应的引脚并不是我设置的那个，看来是CLKBUF的原因。问题分析网络上搜索一些资料后，发现是在一些工程中会出现这个问题，如果rst_n信号连接了许多IP核，和很多自己写的模块，这样rst_n就需要很强的驱动能力，即扇出能力(Fan Out)，而且布线会很长，所以在分配管脚时，IDE自动添加了CLKBUF，来提供更大的驱动能力和更小的延时。那么什么是FPGA的全局时钟网络资源呢？ FPGA全局布线资源简介我们知道FPGA的资源主要由以下几部分组成：可编程输入输出单元（IOB）基本可编程逻辑单元（CLB）数字时钟管理模块（DCM）嵌入块式RAM（BRAM）丰富的布线资源内嵌专用硬件模块。我们重点介绍布线资源，FPGA中布线的长度和工艺决定着信号在的驱动能力和传输速度。FPGA的布线资源可大概分为4类：全局布线资源：芯片内部全局时钟和全局复位/置位的布线长线资源：完成芯片Bank间的高速信号和第二全局时钟信号的布线短线资源：完成基本逻辑单元之间的逻辑互连和布线分布式布线资源：用于专有时钟、复位等控制信号线。一般设计中，我们不需要直接参与布线资源的分配，IDE中的布局布线器（Place and Route）可以根据输入逻辑网表的拓扑结构，和用户设定的约束条件来自动的选择布线资源。其中全局布线资源具有最强的驱动能力和最小的延时，但是只能限制在全局管脚上，厂商会特殊设计这部分资源，如Xilinx FPGA中的全局时钟资源一般使用全铜层工艺实现，并设计了专门时钟缓冲和驱动结构，从而使全局时钟到达芯片内部的所有可配置逻辑单元（CLB）、I/O单元（IOB）和选择性块RAM（Block Select ROM）的时延和抖动都为最小。一般全局布线资源都是针对输入信号来说的，如果IDE自动把rst_n引脚优化为了全局网络，而硬件电路设计上却把rst_n分配到了普通管脚上，那么就很麻烦了，要么牺牲全局网络的优势，手动将全局网络改为普通网络，要么为了利用全局网络的优势，修改电路，重新分配硬件引脚。所以如果一些关键的信号确定了，如时钟、复位等，产品迭代修改电路时，不要轻易调整这些关键引脚。 Microsemi FPGA的全局布线资源 Microsemi FPGA的全局时钟管脚编号，我们可以通过官方Datasheet来找到，在手册中关于全局IO的命名规则上，有如下介绍：即只有管脚名称为GFA0/1/2，GFB0/1/2，GFC0/1/2，GCA0/1/2，GCB0/1/2，GCC0/1/2（共18个）才支持全局网络分配，而且，如果使用了GFA0引脚作为全局输入引脚，那么GFA1和GFA2都不能再作为全局网络了，其他GFC等同理，这一点在设计电路时要特别注意。对于Microsemi SmartFusion系列FPGA芯片A2F200M3F-PQ208来说，只有7个，分别是：GFA0-15、GFA1-14、GFA2-13、GCA0-145、GCA1-146、GCC2-151、GCA2-153，引脚分配如下图所示：所以在设计A2F200M3F-PQ208硬件电路时，时钟和复位信号尽量分配在这些管脚上，以获得硬件性能的最大效率。这些全局引脚的延时时间都是非常小的，具体的时间参数可以从数据手册上获得。全局网络改为普通输入像文章开头介绍的情况，IDE自动把rst_n设置为全局网络，而实际硬件却不是全局引脚，应该怎么修改为普通输入呢？即CLKBUF改为普通的INBUF？网络上zlg的教程中使用的是版本较低的Libero IDE 8.0，新版的Libero SoC改动非常大，文中介绍的修改sdc文件的方法已经不能使用了，这里提供新的修改方法——调用INBUF IP Core的方式。这里官方已经考虑到了，在官方提供的INBUF IP Core可以把CLKBUF改为INBUF。在Catalog搜索框中输入：INBUF，可以看到这里也提供了LVDS信号专用的IP Core。拖动到SmartDesign中进行连接或者在源文件中直接例化的方式调用INBUF Core： INBUF INBUF_0( // Inputs .PAD ( rst_n ), // Outputs .Y ( rst_n_Y ) );这两种方法都是一样的。添加完成之后，再进行管脚分配，可以看到rst_n已经是普通的INBUF类型了，可以进行普通管脚的分配，而且commit检查也是没有错误的。普通输入上全局网络如果布局布线器没有把我们要的信号上全局网络，如本工程的CLK信号，IDE自动生成的是INBUF类型，我们想让他变成CLKBUF，即全局网络，来获取最大的驱动能力和最小的延时。那么应该怎么办呢？这里同样要使用到一个IP Core，和INBUF类似，这个IP Core的名称是CLKBUF，同样是在Catalog目录中搜索：CLKBUF，可以看到有CLKBUF开头的很多Core，这里同样也提供了LVDS信号专用的IP Core。可以直接拖动Core到SmartDesign图形编辑窗口：或者是在源文件中以直接例化的方式调用： CLKBUF CLKBUF_0( // Inputs .PAD ( CLKA ), // Outputs .Y ( CLKA_Y ) );这两种方式都是一样的，添加完成之后，再进行管脚分配，可以看到CLKA已经是全局网络了，只能分配在全局管脚上。总结对于不同厂家的FPGA，让某个信号上全局网络的方法都不尽相同，如Xilinx的FPGA是通过BUFG Core来让信号上全局网络，而且还有带使能端的全局缓冲 BUFGCE ， BUFGMUX 的应用更为灵活，有2个输入，可通过选择端选择输出哪一个。所以，信号的全局缓冲设置要根据不同厂商Core的不同来使用。

嵌入式＆系统 FPGA&ASIC IP&SOC设计 # 嵌入式

刘航宇 3年前
0 1,582 3
此内容被密码保护加密文章，请前往内页查看详情

我的随笔

刘航宇 3年前
0 124 2
Microsemi Libero SOC使用示例—建立点灯工程嵌入式开发中的Hello World，点灯是再也基础不过的实验了，通过点灯实验，可以了解芯片GPIO的控制和开发环境IDE新建工程的流程，对于FPGA来说，每个IO口几乎一样，所以本篇文章主要学习一下如何基于Microsemi Libero集成开发环境建立一个示例工程，让一个LED以500ms的频率闪烁，以Microsemi SmartFusion系列FPGA——A2F200M3F为例，Microsemi其他系列FPGA芯片过程类似。准备工作软件准备：硬件准备：新建工程的主要步骤1.新建工程 2.添加设计文件 3.仿真验证 4.管脚分配 5.程序下载 Microsemi FPGA的Flash结构准备工作工欲利其事，必先利其器，充分的准备工作很有必要。软件准备： Microsemi Libero SoC集成开发环境，并已经成功注册，软件版本推荐V11.8或更高版本。硬件准备： Microsemi FPGA开发板，主控芯片A2F200M3F-PQ208，其他型号芯片类似。 Flash Pro 4或Flash Pro5下载器，用于给FPGA芯片下载程序和调试。新建工程的主要步骤新建工程，选择芯片型号等新建设计，使用Verilog编写点灯模块。仿真验证，对编写的点灯模块进行时序仿真，来验证是否满足设计需求。综合、管脚分配、布局、布线。生成程序文件，连接开发板，使用FlashPro下载程序到芯片内，观察现象是否和设计的一致。 1.新建工程和大多数IDE一样，选择Project -> New Project，新建一个工程。 image.png图片输入工程名称LED_Blink，选择工程存放的路径，工程名称和路径不要有中文字符和空格，选择源文件的类型Verilog或者VHDL。 image.png图片选择芯片型号，这里选择Microsemi SmartFusion系列下的A2F200M3F芯片，PQ208封装，把鼠标放在所选芯片上，可以查看芯片的详细参数：封装、速度等级、温度范围，内核电压、Flash ROM大小、用户IO数目、RAM大小、Flash ROM大小，ARM Cortex-M3 SoC的外设配置等详细的参数。图片选择IO的电平标准，不同的电平标准，高低电平的电压范围是不同的，这里选择默认的LVTTL。图片是否创建MSS模块，MSS里有PLL和ARM Cortex-M3的使用，以后用到PLL和ARM核时再添加，这里先不选择，以后需要也可以再创建。图片是否导入已经存在的HDL文件，如果已经有一些写好的模块，可以在这里直接导入。图片是否导入已经存在的管脚约束文件，这里选择不添加，我们会在后面通过图形化工具来指定管脚。图片到这里，工程就创建完成了，然后会在存储路径下生成一个和工程名称一样的文件夹，工程相关的所以文件都存放在这里。主要包括以下几个文件夹：图片具体每个文件夹存放的是什么文件，我们在以后的文章再详细介绍。以上的工程配置在创建完工程之后，也可以再次更改，可以通过Project->Project Setting查看或更改配置：图片或者通过点击如下图标来进入配置界面：图片弹出如下窗口，和新建工程是一样的，可以更改FPGA的型号，但只限于同一个系列内。 2.添加设计文件 Microsemi Libero开发环境支持HDL方式和SmarDesign方式来创建设计，HDL方式支持VerilogHDL和VHDL两种硬件描述语言，而SmartDesign方式和Xilinx的Schematic原理图方式是一样的，是通过图形化的方式来对各个模块之间的连接方式进行编辑，两种方式都可以完成设计。由于本实验功能简单，所以以使用Verilog文件为例。创建Verilog文件创建Verilog文件有多种方式，可以直接双击左侧菜单中的Create Design->Create HDL 图片或者点击File->New->HDL，这两种方式都可以创建一个Verilog设计文件，这里选择Verilog文件。图片输入模块名称：led_driver，不用添加.v后缀名，Libero软件会自动添加。源代码： module led_driver( //input input clk, //clk=2MHz input rst_n, //0=reset //output output reg led ); parameter T_500MS = 999999; //1M reg [31:0] cnt; always @ (posedge clk) begin if(!rst_n) cnt <= 32'b0; else if(cnt >= T_500MS) cnt <= 32'b0; else //cnt < T_500MS cnt <= cnt + 32'b1; end always @ (posedge clk) begin if(!rst_n) led <= 1'b1; else if(cnt >= T_500MS) led <= ~led; end endmodule可以看到，代码非常的简单，定义一个计数器，系统时钟为2MHz=500ns，500ms=1M个时钟周期，当计数到500ms时，LED翻转闪烁。 3.仿真验证编写完成，之后，点击对号进行语法检查，如果没有语法错误就可以进行时序仿真了。新建Testbench文件底部切换到Design Hierarchy选项卡，在led模块上右键选择Create Testbechch创建仿真文件，选择HDL格式。图片给创建的testbench文件名一般为模块名后加_tb，这里为：led_driver_tb，因为我们的板子外部晶体为2M，所以这里系统时钟周期为500ns，这个也可以在文件中更改。图片点击OK之后，可以看到，Libero软件已经为我们生成了一些基本代码，包括输入端口的定义，系统时钟的产生，输入信号的初始化等等。我们只需要再增加几行即可。 `timescale 1ns/100ps module led_driver_tb; parameter SYSCLK_PERIOD = 500;// 2MHZ reg SYSCLK; reg NSYSRESET; wire led; //add output reg initial begin SYSCLK = 1'b0; NSYSRESET = 1'b0; end initial begin #(SYSCLK_PERIOD * 10 ) NSYSRESET = 1'b0; //add system reset #(SYSCLK_PERIOD * 100 ) NSYSRESET = 1'b1; //add system set end always @(SYSCLK) //generate system clock #(SYSCLK_PERIOD / 2.0) SYSCLK <= !SYSCLK; led_driver led_driver_0 ( // Inputs .clk(SYSCLK), .rst_n(NSYSRESET), // Outputs .led(led ) //add port // Inouts ); endmodule仿真代码也非常简单，输入信号初始化，NSYSRESET在10个时钟周期之后拉低，100个时钟周期之后拉高。使用ModelSim进行时序仿真仿真代码语法检查无误后，可以进行ModelSim自动仿真，在安装Libero时，已经默认安装了ModelSim仿真软件，并和Libero进行了关联。直接双击Simulate，Libero会自动打开ModelSim。图片可以看到输入输出信号，已经为我们添加好了：图片先点击复位按钮，复位系统，然后设置要运行的时间，由于设计的是500ms闪烁一次，这里我们先运行2s，即2000ms，在ModelSim中2秒已经算是很长的时间了，然后点击时间右边的运行按钮，耐心等待，停止之后就会看到led按500ms变化一次的波形了，如下图所示，可以再添加一个cnt信号到波形观察窗口，可以看到cnt周期性的变化。图片使用2个光标的精确测量，可以看出，led每隔500ms翻转一次，说明程序功能是正确的。 4.管脚分配与STM32等MCU不同，FPGA的引脚配置非常灵活，如STM32只有固定的几个引脚才能作为定时器PWM输出，而FPGA通过管脚分配可以设置任意一个IO口输出PWM，而且使用起来非常灵活，这也是FPGA和MCU的一个区别，当然其他的功能，如串口外设，SPI外设等等，都可以根据需要自己用HDL代码来实现，非常方便。时序仿真正常之后，就可以进行管脚分配了，即把模块的输入输出端口，真正的分配到芯片实际的引脚上，毕竟我们的代码是要运行在真正的芯片上的。打开引脚配置图形化界面双击Create/Edit I/O Attributes，打开图形化配置界面，在打开之前，Libero会先进行综合(Synthesize)、编译(Complie)，当都运行通过时，才会打开配置界面。图片分配管脚管脚可视化配置工具使用起来非常简单：引脚号指定、IO的电平标准，内部上下拉等等，非常直观。把时钟、复位、LED这些管脚分配到开发板原理图中对应的引脚，在分配完成之后，可以点击左上角的commit and check进行检查。图片在分配完成之后，为了以后方便查看已经分配的引脚，可以导出一个pdc引脚约束文件，选择Designer窗口下的File->Export->Constraint File，会导出一个led_driver.pdc文件，保存在工程目录下的constraint文件夹。图片一些特殊管脚的处理 SmartFusion系列的FPGA芯片，在分配个别引脚，如35-39、43-47这些引脚时，直接不能分配，这些引脚属于MSS_FIO特殊引脚，具体怎么配置为通用IO，可以查看下一篇文章。而新一代的SmartFusion 2系列的FPGA芯片则没有这种情况。 5.程序下载管脚分配完成之后，连接FlashPro下载器和开发板的JTAG接口，关闭Designer窗口，选择Program Device，耐心等待几分钟，如果连接正常，会在右侧输出编程信息：擦除、验证、编程等操作，下载完成之后，就会看到板子上的LED闪烁起来了。 Microsemi FPGA的Flash结构和Altera、Xilinx不同，Microsemi FPGA在下载程序时，并不是下载程序到SPI Flash，而是直接下载到FPGA内部的。目前，FPGA 市场占有率最高的两大公司Xilinx和Altera 生产的 FPGA 都是基于 SRAM 工艺的，需要在使用时外接一个片外存储器以保存程序。上电时，FPGA 将外部存储器中的数据读入片内 RAM，完成配置后，进入工作状态；掉电后 FPGA 恢复为白片，内部逻辑消失。这样 FPGA 不仅能反复使用，还无需专门的 FPGA编程器，只需通用的 EPROM、PROM 编程器即可。而Microsemi的SmartFusion、SmartFusion2、ProASICS3、ProASIC3E系列基于Flash结构，具备反复擦写和掉电后内容非易失性，因此基于Flash结构的FPGA同时具备了SRAM结构的灵活性和反熔丝结构的可靠性，这种技术是最近几年发展起来的新型FPGA实现工艺，目前实现的成本还偏高，没有得到大规模的应用。示例工程下载基于Libero V11.8.2.4的工程下载： LED_Blink.rar 下载地址：https://wcc-blog.oss-cn-beijing.aliyuncs.com/Libero/Libero-2/LED_Blink.rar 提取码：

嵌入式＆系统 FPGA&ASIC IP&SOC设计 # ASIC/FPGA # 嵌入式 # SOC设计

刘航宇 3年前
0 1,962 2
2023-05-29
Windows安装Jupyter Notebook及机器学习的库 Jupyter Notebook安装（Windows）下载Jupyter Notebook （1）打开cmd（如果没有把Python安装目录添加到Path，需要切换到Python安装目录的Scripts目录下）；（2）输入pip install jupyter；（推荐在外网环境下安装） 2.库安装下载下面文件 requirements.txt 下载地址：https://wwek.lanzoub.com/iLI2S0xm6a3a 提取码：然后执行： pip3 install -r requirements.txt 启动Juypter Notebook （1）命令行窗口输入jupyter notebook；浏览器会打开Jupyter Notebook窗口，说明Jupyter Notebook安装成功。 (2) 配置Jupyter Notebook 1、行窗口输入jupyter notebook --generate-config，会发现C:\Users\用户名\ .jupyter下多出了一个配置文件jupyter_notebook_config.py； image.png图片 2、这个配置文件，找到下面这句#c.NotebookApp.notebook_dir = ''。可以把它修改成c.NotebookApp.notebook_dir = 'D:\jupyter-notebook'，当然具体的目录由自己创建的文件夹决定（需要自己创建）。配置文件修改完成后，以后在jupyter notebook中写的代码都会保存在该目录下。现在重新启动jupyter notebook，就进入了新的工作目录； 5.添加代码自动补全功能（可选）（1）打开cmd，输入pip install jupyter_contrib_nbextensions，等待安装成功；（2）安装完之后需要配置nbextension（配置前要确保已关闭jupyter notebook），在cmd中输入jupyter contrib nbextension install --user --skip-running-check，等待配置成功；（3）在前两步成功的情况下，启动jupyter notebook，会发现在选项栏中多出了Nbextension的选项，点开该选项，并勾选Hinterland，即可添加代码自动补全功能。 image.png图片

机器学习 # 机器学习

刘航宇 3年前
0 459 1
FPGA&Matlab联合开发之滤波器模块（带通滤波器为例）在通信或者信号处理中，数字滤波器是非常重要的模块，前面有关博文中提到FIR滤波器的一步步Verilog设计，如https://ee.ac.cn/index.php/archives/511.html 本文以带通滤波器为例，利用Matlab进行高效开发目录 MATLAB生成低通滤波器设计步骤： Modelsim仿真上述文件 MATLAB生成低通滤波器设计步骤：（1）在MATLAB命令窗口中输入“filterDesigner”或“fdatool”出现如下对话框 image.png图片设置FIR滤波器为和需要的阶数滤波器，选择窗函数的类型为海明窗函数，海明窗函数可以得到旁瓣更小的效果，能量更加集中在主瓣中设置带通滤波器的上下截至频率分别为4MHz 和 5MHz （2）量化输入输出，点击工作栏左边的量化选项，即“set quantization parameters”选项，选择定点，设置输入字长为8，其他选择默认，如下图示： image.png图片（3）根据自己需求，细化一些配置。这里不难探索设置完成后，点击Targets中Generate HDL，选择生成Verilog 代码，设置路径，MATLAB即可生成设计好的滤波器Verilog HDL 代码以及测试文件： image.png图片（4）根据需求，配置输出.v文件的全局信号、测试文件，点击生成，生成后，Matlab主页面会提示.v生成的文件路径 Modelsim仿真上述文件 image.png图片可以看到输入信号在4MHZ~5MHZ备保留，设计无误。需要注意一点，一般Modelsim仿真输出波形都是离散的01信号，这里需要配置一下，在上图被选中的信号中，在左侧右键鼠标。右击,format,analog(automatic); 右击,radix,decimal; 这两个步骤完成之后，就出现上图模拟信号的效果

嵌入式＆系统 FPGA&ASIC 通信&信息处理软硬件算法 # ASIC/FPGA # 信号处理 # 硬件算法

刘航宇 3年前
0 679 2
2023-05-15
机器学习代码实现:线性回归与岭回归 1.线性回归模型线性回归模型是最简单的一种线性模型，模型的形式就是： $y=W^T x+b$ 我们可以通过对原本的输入向量x扩增一个为1的维度将参数W和b统一成一个参数W，即模型变成了 $y=W^T x$ 这里的W是原本两个参数合并之后的而其损失函数的形式是残差平方损失RSS $L=\frac{1}{2 m} \sum_{i=1}^m\left(W^T x_i-y_i\right)^2=\frac{1}{2 m}\left(W^T X-y\right)^T\left(W^T X-y\right)$ 我们很容易就可以通过求导得到线性回归模型的关于W的梯度 $\nabla_W L=\frac{1}{m} \sum_{i=1}^m\left(W^T x_i-y_i\right) x_i=\frac{1}{m} X^T\left(W^T X-y\right)$ 这样一来我们就可以通过梯度下降的方式来训练参数W，可以用下面的公式表示 $W:=W-\alpha \frac{1}{m} X^T\left(W^T X-y\right)$ 但实际上线性模型的参数W可以直接求解出，即： $W=\left(X^T X\right)^{-1} X^T y$ 2.线性回归的编程实现具体代码中的参数的形式可能和上面的公式推导略有区别，我们实现了一个LinearRegression的类，包含fit，predict和loss三个主要的方法，fit方法就是求解线性模型的过程，这里我们直接使用了正规方程来解 class LinearRegression: def fit(self, X: np.ndarray, y: np.ndarray) -> float: N, D = X.shape # 将每个样本的特征增加一个维度，用1表示，使得bias和weight可以一起计算 # 这里在输入的样本矩阵X末尾增加一列来给每个样本的特征向量增加一个维度 # 现在X变成了N*(D+1)维的矩阵了 expand_X = np.column_stack((X, np.ones((N, 1)))) self.w = np.matmul(np.matmul(np.linalg.inv(np.matmul(expand_X.T, expand_X)), expand_X.T), y) return self.loss(X, y)predict实际上就是将输入的矩阵X放到模型中进行计算得到对应的结果，loss给出了损失函数的计算方式： def loss(self, X: np.ndarray, y: np.ndarray): """ 线性回归模型使用的是RSS损失函数 :param X:需要预测的特征矩阵X，维度是N*D :param y:标签label :return: """ delta = y - self.predict(X) total_loss = np.sum(delta ** 2) / X.shape[0] return total_loss3.岭回归Ridge Regression与代码实现岭回归实际上就是一种使用了正则项的线性回归模型，也就是在损失函数上加上了正则项来控制参数的规模，即： $L=\frac{1}{2 m} \sum_{i=1}^m\left(W^T x_i-y_i\right)^2+\lambda\|W\|_2=\frac{1}{2 m}\left(W^T X-y\right)^T\left(W^T X-y\right)+\lambda W^T W$ 因此最终的模型的正规方程就变成了： $W=\left(X^T X+\lambda I\right)^{-1} X^T y$ 这里的\lambda是待定的正则项参数，可以根据情况选定，岭回归模型训练的具体代码如下 class RidgeRegression: def fit(self, X: np.ndarray, y: np.ndarray): N, D = X.shape I = np.identity(D + 1) I[D][D] = 0 expand_X = np.column_stack((X, np.ones((N, 1)))) self.W = np.matmul(np.matmul(np.linalg.inv(np.matmul(expand_X.T, expand_X) + self.reg * I), expand_X.T), y) return self.loss(X, y)4.数据集实验这里使用了随机生成的二位数据点来对线性模型进行测试，测试结果如下： image.png图片线性模型测试结果岭回归也使用同样的代码进行测试。

机器学习软硬件算法 # 机器学习 # 软件算法

刘航宇 3年前
0 367 1
联发科2024年数字IC设计验证实习生考题解析总体而言难度中等偏上，如有错误欢迎指正，考察感觉更像是考察嵌入式工程师（有STM32、FPGA基础就很轻松）：有数电、模电、python、verilog、C语言、SOC系统等基础知识，可以看到其实很对口电子信息类专业如电子信息、微电子、通信工程、电子科学、集成电路等专业，没有考察模集如果考模集大部分人要G，数集也没考，可能太底层了与工业界需求有偏差，数集在笔试面试中我认为如果考，可能考时序与功耗部分。这里的Round-Robin算法很值得学习。目录 1、（20分）逻辑化简： 2、（5分）ASIC flow 中综合工具的作用是什么？综合的时候需要SDC文件进行约束，请列举3条SDC的语法。 3、（10分）智力题 4、（10分）选择参与过的任一个项目，简述项目内容以及流程，讲述您在项目中承担的任务，挑一项你认为难的地方并阐述解决方案。 5、（5分）用python写一个冒泡排序的函数以及测试程序。 6、（15分）用Verilog 写一个 Round Robin 仲裁器。模块端口如下： 7、（15分）关于DMA寄存器配置，DMA寄存器（地址 0x81050010）表： 8、（20分）二阶带通滤波器，利用RC组件搭建，通带范围 1kHz~30kHz ，两个电阻 R 均为10kΩ ，问两个电容容值多少？ 1、（20分）逻辑化简：图片 (1)列出真值表 (2)列出其卡诺图 (3)写出Z的最简表达式答：卡诺图：卡诺图画完后勾1就完事了提示：约束项的一般形式为：与或式 = 0 （如果不是此种形式，化为此种形式）；如此题的BC = 0；或者AB +CD = 0；ABC + CD = 0；等等。BC=0（即B=1，且C=1）对应的格子画X。图片图片 2、（5分）ASIC flow 中综合工具的作用是什么？综合的时候需要SDC文件进行约束，请列举3条SDC的语法。答：ASIC flow 中综合工具的作用是将RTL级的硬件描述语言转换为与特定工艺库相匹配的门级网表，同时进行优化以满足时序、面积和功耗等约束。综合的时候需要SDC文件进行约束，SDC文件是一种基于Tcl的格式，用于指定设计的时序约束34。SDC文件中的常用时序约束语法有： create_clock -name <clock_name> -period <clock_period> [get_ports <clock_port>] 用于创建时钟源并指定时钟周期。 set_input_delay -clock <clock_name> <delay_value> [get_ports <input_port>] 用于指定输入端口相对于时钟源的延迟。 set_output_delay -clock <clock_name> <delay_value> [get_ports <output_port>] 用于指定输出端口相对于时钟源的延迟。 set_clock_uncertainty -setup <setup_value> -hold <hold_value> <clock_name> 用于指定时钟源的不确定性，包括建立时间和保持时间。 set_false_path -from [get_ports <source_port>] -to [get_ports <destination_port>] 用于指定不需要进行时序分析的路径。 set_multicycle_path -setup -from [get_clocks <source_clock>] -to [get_clocks <destination_clock>] <cycle_number> 用于指定多周期路径，即源时钟和目标时钟之间有多个周期的时间差。3、（10分）智力题（1）2 12 1112 3112 132112 ，下一个数？给理由；答：第一个数是2，第二个数是12，表示前一个数有1个2；第三个数是1112，表示前一个数有1个1和1个2；以此类推。所以，下一个数是1113122112，表示前一个数有1个1，1个3，2个1和2个2 （2）有一个小偷费劲力气进入到了银行的金库里。在金库里他找到了一百个箱子，每一个箱子里都装满了金币。不过，只有一个箱子里装的是真的金币，剩下的99个箱子里都是假的。真假金币的外形和质感完全一样，任何人都无法通过肉眼分辨出来。它们只有一个区别：真金币每一个重量为101克，而假金币的重量是100克。在金库里有一个电子秤，它可以准确地测量出任何物品的重量，精确到克。但很不幸的是，这个电子秤和银行的报警系统相连接，只要被使用一次就会立刻失效。请问，小偷怎么做才能只使用一次电子秤就找到装着真金币的箱子呢? 答：小偷可以这样做：从第一个箱子里拿出1个金币，从第二个箱子里拿出2个金币，从第三个箱子里拿出3个金币，以此类推，直到从第一百个箱子里拿出100个金币。然后，把所有拿出来的金币放在电子秤上，测量它们的总重量。如果所有的金币都是假的，那么总重量应该是5050克（等于1+2+3+…+100）。如果有一个箱子里是真的金币，那么总重量会比5050克多出一些。这个多出来的部分就是真金币的数量乘以1克。例如，如果第十一个箱子里是真的金币，那么总重量会比5050克多出11克，因为从第十一个箱子里拿出了11个真金币。所以，小偷只要看电子秤上显示的数字减去5050，就能知道哪个箱子里是真的金币了。 4、（10分）选择参与过的任一个项目，简述项目内容以及流程，讲述您在项目中承担的任务，挑一项你认为难的地方并阐述解决方案。答：优先答ASIC的设计与验证项目，其次是FPGA项目（如基于FPGA的图像处理、天线阵、雷达、加速器等等），其它项目不要答。 5、（5分）用python写一个冒泡排序的函数以及测试程序。 # 定义冒泡排序函数 def bubble_sort(lst): # 获取列表长度 n = len(lst) # 遍历列表n-1次 for i in range(n-1): # 设置一个标志，用于判断是否发生交换 swapped = False # 遍历未排序的部分 for j in range(n-1-i): # 如果前一个元素大于后一个元素，交换位置 if lst[j] > lst[j+1]: lst[j], lst[j+1] = lst[j+1], lst[j] # 标志设为True，表示发生了交换 swapped = True # 如果没有发生交换，说明列表已经有序，提前结束循环 if not swapped: break # 返回排序后的列表 return lst # 定义测试程序 # 创建一个乱序的列表 lst = [5, 3, 8, 2, 9, 1, 4, 7, 6] # 打印原始列表 print("Original list:", lst) # 调用冒泡排序函数，对列表进行排序 lst = bubble_sort(lst) # 打印排序后的列表 print("Sorted list:", lst)结果图 image.png图片 6、（15分）用Verilog 写一个 Round Robin 仲裁器。模块端口如下： input clock; input reset_b; input [N-1:0] request; input [N-1] lock; output [N-1] grant; //one-hot此处的 lock 输入信号，表示请求方收到了仲裁许可，在对应的lock拉低之前，仲裁器不可以开启新的仲裁。（可简单理解为仲裁器占用）该题要求参数化编程，在模块例化时可调整参数。也即是说你不能写一个固定参数，比如N=8的模块。参考波形图： image.png图片答： Round-Robin算法：当有多个设备同时想占用同一个资源时，需要仲裁器通过某种调度算法决定不同设备使用资源的先后顺序。 Round Robin算法就是其中一种调度算法，其思路是，当多个仲裁请求(request)送给仲裁器时，仲裁器通过轮询的方式分时给不同的设备返回许可(grant)，当一个requestor 得到了grant许可之后，它的优先级在接下来的仲裁中就变成了最低，当同时有多个requestor的时候，grant可以依次给到每个requestor，即使之前高优先级的requestor再次有新的request，也会等前面的requestor都grant之后再轮到它。由此看出，Round Robin算法是一种公平的算法，它避免了当最高优先级的requestor不断有新的request时，具有最高优先级的requestor一直占用资源，导致其他requestor无法占用资源的阻塞现象。在verilog设计中，如何实现呢？假设request是位宽是6,最高位是第5位，最低位是第0位，默认低比特位具有高优先级。 1.首先需要找到request中优先级最高的比特位，对优先级最高的比特位给出许可信号。这一步可以通过request和它的2的补码按位与。这是因为一个数和它的补码相与，得到的结果是一个独热码，独热码为1的那一位是这个数最低的1。 2.在下一轮仲裁中，已经被仲裁许可的比特位变成了最低优先级，而未被仲裁许可的比特位将会被仲裁。因此对第一步中给出许可的比特位（假设是第2位）以及它的低比特位进行屏蔽，对request中的第5位到第3位进行保持，这个操作可以利用掩码111000和request相与实现得到。得到掩码的方法是，对第一步的许可信号grant-1，再与grant本身相或，相或的结果再取反。 3.通过第二步得到第2位到第0位被屏蔽的request_new信号，判断request_new是否为全0信号，如果是全0信号，代表此时不存在需要被仲裁的比特位，则返回第一步：找到request中优先级最高的比特位，对优先级最高的比特位给出许可信号，然后进行第二步。如果request_new不是全0信号，代表存在未被仲裁的比特位，则找到request_new中优先级最高的比特位，对优先级最高的比特位给出许可信号，然后进行第二步。 // 功能： // -1- Round Robin 仲裁器 // -2- 仲裁请求个数N可变 // -3- 加入lock机制（类似握手） // -4- 复位时的最高优先级定为 0 ，次优先级：1 -> 2 …… -> N-2 -> N-1 `timescale 1ns / 1ps module RoundRobinArbiter #( parameter N = 4 //仲裁请求个数 )( input clock, input reset_b, input [N-1:0] request, input [N-1:0] lock, output reg [N-1:0] grant//one-hot ); // 模块内部参数 localparam IDLE = 3'b001;// 复位进入空闲状态，接收并处理系统的初次仲裁请求 localparam WAIT_REQ_GRANT = 3'b010;// 等待后续仲裁请求到来,并进行仲裁 localparam WAIT_LOCK = 3'b100;// 等待LOCK拉低 // 模块内部信号 reg [2:0] R_STATUS; //请求状态 reg [N-1:0] R_MASK; //掩码 wire [N-1:0] W_REQ_MASKED; assign W_REQ_MASKED = request & R_MASK; //屏蔽低位 always @ (posedge clock) begin if(~reset_b) begin R_STATUS <= IDLE; R_MASK <= 0; grant <= 0; end else begin case(R_STATUS) IDLE: begin if(|request) //首次仲裁请求，不全为0 begin R_STATUS <= WAIT_LOCK; //首先需要找到request中优先级最高的比特位，对优先级最高的比特位给出许可信号。 //这一步可以通过request和它的2的补码按位与。这是因为一个数和它的补码相与，得到的结果是一个独热码，独热码为1的那一位是这个数最低的1 grant <= request & ((~request)+1); R_MASK <= ~((request & ((~request)+1))-1 | (request & ((~request)+1))); //得到掩码的方法是，对第一步的许可信号grant-1，再与grant本身相或，相或的结果再取反。 end else begin R_STATUS <= IDLE; end end WAIT_REQ_GRANT://处理后续的仲裁请求 begin if(|request) begin R_STATUS <= WAIT_LOCK; //在下一轮仲裁中，已经被仲裁许可的比特位变成了最低优先级，而未被仲裁许可的比特位将会被仲裁。 //因此对第一步中给出许可的比特位（假设是第2位）以及它的低比特位进行屏蔽，对request中的第5位到第3位进行保持 //这个操作可以利用掩码111000和request相与实现得到。 if(|(request & R_MASK))//不全为零 begin grant <= W_REQ_MASKED & ((~W_REQ_MASKED)+1); R_MASK <= ~((W_REQ_MASKED & ((~W_REQ_MASKED)+1))-1 | (W_REQ_MASKED & ((~W_REQ_MASKED)+1))); end else begin grant <= request & ((~request)+1); R_MASK <= ~((request & ((~request)+1))-1 | (request & ((~request)+1))); end end else begin R_STATUS <= WAIT_REQ_GRANT; grant <= 0; R_MASK <= 0; end end //通过第二步得到第2位到第0位被屏蔽的request_new信号， //判断request_new是否为全0信号，如果是全0信号，代表此时不存在需要被仲裁的比特位，则返回第一步：找到request中优先级最高的比特位， //对优先级最高的比特位给出许可信号，然后进行第二步。如果request_new不是全0信号，代表存在未被仲裁的比特位， //则找到request_new中优先级最高的比特位，对优先级最高的比特位给出许可信号，然后进行第二步。 WAIT_LOCK: begin if(|(lock & grant)) //未释放仲裁器 begin R_STATUS <= WAIT_LOCK; end else if(|request) //释放的同时存在仲裁请求 begin R_STATUS <= WAIT_LOCK; if(|(request & R_MASK))//不全为零 begin grant <= W_REQ_MASKED & ((~W_REQ_MASKED)+1); R_MASK <= ~((W_REQ_MASKED & ((~W_REQ_MASKED)+1))-1 | (W_REQ_MASKED & ((~W_REQ_MASKED)+1))); end else begin grant <= request & ((~request)+1); R_MASK <= ~((request & ((~request)+1))-1 | (request & ((~request)+1))); end end else begin R_STATUS <= WAIT_REQ_GRANT; grant <= 0; R_MASK <= 0; end end default: begin R_STATUS <= IDLE; R_MASK <= 0; grant <= 0; end endcase end end endmodule测试代码 `timescale 1ns / 1ps module RoundRobinArbiter_tb; parameter N = 4; // 可以在测试时调整参数 // 定义测试信号 reg clock; reg reset_b; reg [N-1:0] request; reg [N-1:0] lock; wire [N-1:0] grant; // 定义时钟信号 initial clock = 0; always #10 clock = ~clock; // 实例化仲裁器模块 RoundRobinArbiter #( .N(N) ) inst_RoundRobinArbiter ( .clock (clock), .reset_b (reset_b), .request (request), .lock (lock), .grant (grant) ); // 定义时钟周期和初始值 initial begin reset_b <= 1'b0; request <= 0; lock <= 0; end // 定义请求和锁定信号的变化 initial begin #20; reset_b <= 1'b1; @(posedge clock) request <= 2; lock <= 2; @(posedge clock) request <= 0; @(posedge clock) request <= 5; lock <= 7; @(posedge clock) lock <= 5; @(posedge clock) request <= 1; @(posedge clock) lock <= 1; @(posedge clock) request <= 0; @(posedge clock) lock <= 0; #1000 $stop; // 测试结束 end // 显示测试结果和波形图 initial begin $monitor("Time=%t, clock=%b, reset_b=%b, request=%b, lock=%b, grant=%b", $time, clock, reset_b, request, lock, grant); $dumpfile("RoundRobinArbiter_tb.vcd"); $dumpvars(0,RoundRobinArbiter_tb); end endmodule结果： image.png图片如果对波形图无法理解可以看此博文 https://blog.csdn.net/m0_49540263/article/details/114967443 7、（15分）关于DMA寄存器配置，DMA寄存器（地址 0x81050010）表： image.png图片 image.png图片 Type 表示读写类型。Reset 表示复位值。写一个C函数 void dma_driver(void)，按步骤完成以下需求：分配DMA所需的源地址（0x30）分配DMA所需的目的地址（0x300）设置传输128 Byte 数据开始DMA传输等待DMA传输结束答： // 假设有以下宏定义 #define DMA_REG 0x81050010 // DMA控制寄存器的地址 #define DMA_SRC_ADDR 0x30 // DMA源地址 #define DMA_DST_ADDR 0x300 // DMA目的地址 #define DMA_SIZE 128 // DMA传输大小 #define DMA_START 1 // DMA开始传输的标志位 // 定义C函数 void dma_driver(void) void dma_driver(void) { // 定义一个指向DMA控制寄存器的指针 volatile uint32_t *dma_reg = (volatile uint32_t *)DMA_REG; // 清空DMA控制寄存器的值 *dma_reg = 0; // 设置DMA源地址，目的地址和传输大小 *dma_reg |= (DMA_SRC_ADDR << 2) | (DMA_DST_ADDR << 13) | (DMA_SIZE << 24); // 开始DMA传输 *dma_reg |= DMA_START; // 等待DMA传输结束 while (*dma_reg & DMA_START) { // 可以在这里做一些其他的事情，比如打印日志或者检查错误 // printf("Waiting for DMA to finish...\n"); // check_error(); } }官方一点的表达：DMA，全称为：Direct Memory Access，即直接存储器访问。直接存储器存取( DMA )用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须 CPU 干预，数据可以通过 DMA 快速地移动，这就节省了 CPU 的资源来做其他操作。典型的例子就是移动一个外部内存的区块到芯片内部更快的内存区。像是这样的操作并没有让处理器工作拖延，反而可以被重新排程去处理其他的工作。DMA 传输对于高效能嵌入式系统算法和网络是很重要的。DMA 传输方式无需 CPU 直接控制传输，也没有中断处理方式那样保留现场和恢复现场的过程，通过硬件为 RAM 与 I/O 设备开辟一条直接传送数据的通路，能使 CPU 的效率大为提高。 8、（20分）二阶带通滤波器，利用RC组件搭建，通带范围 1kHz~30kHz ，两个电阻 R 均为10kΩ ，问两个电容容值多少？答：第一步首得知道二阶带通（RC）滤波器的电路长啥样，高、低通组合一下就是带通，自己思考一下高、低通组合：如串联或并联，会得到带通还是带组？电路图： H___H21L__E34_WC@43F1_8.jpg图片这个一看就是总传递函数=A1*A2（模电二阶有源或无源滤波器绝对有） _LIYXIHR_08YNK__EV8SXDH.jpg图片然后化简 X25LO__~TXMGO59LTLV@9S9.jpg图片根据推导得到的表达式，对于 jwRC2 ，这一项，当 w 趋于无穷大时，uo/ui 趋于零。那么高频的临界点就是 wRC2 = 1+2C2/C1；（此时忽略低频项1/jwRC1）同理，对于低频项 1 /jwRC1， w 趋于无穷小时，uo/ui 趋于零，那么低频的临界点就是 1/wRC1 = 1+2C2/C1；然后解二元一次方程两个电容就被解出来了这里提供一种更简单方法：二阶带通滤波器的中心频率 f0 和品质因数 Q 可以用下面的公式计算： image.png图片已知 R1 = R2 = 10kΩ，f0 = (1kHz + 30kHz) / 2 = 15.5kHz，Q = f0 / (30kHz - 1kHz) = 0.54，代入上面的公式，可以求得： image.png图片这是一个二元一次方程组，可以用任意方法求解，例如消元法或代入法。为了方便起见，我们假设 C1 和 C2 的值相近，那么可以近似地认为 C1 = C2 = 3.45nF。这样就得到了两个电容的容值。当然，也可以选择其他的电容值，只要满足上面的方程组即可。

FPGA&ASIC 软硬件算法 # 笔试面试

刘航宇 3年前
0 2,182 9

311 文章数

554 评论量

人生倒计时

那年今日

2021 08/04 【高数】级数 ∑ 1/[nln(n)] 发散的证明

最新回复

。。
2026-06-22

好的，谢谢૮₍◜ෆ◝.₎ა
。。。。
2026-06-22

请问引脚面对自己还是朝下
Lapse
2026-05-30