爱吃蛋挞的Dolly

2020届部分校招IC笔试题

1 AMD

1.1 if A=4’b0011，B=3’b110 and C=4’b1110，then which one is the correct result for expression of {2{~^A}}^(B[1:0]&C[3:2]) ？

A. 00
B. 01
C. 10
D. 11

~^A = ~(0&0&1&1) = ~0 = 1;
{2{~^A}} = {2{1}} = 2’b11;
(B[1:0]&C[3:2]) = 2’b10 & 2’b11 = 2’b10;
{2{~^A}}^(B[1:0]&C[3:2]) = 2’b11 ^ 2’b10 = 2’b01.

1.2 Which statement is correct？

A. UVM test termination is using raise/drop uvm_object.
B. When we set the verbosity to UVM_LOW,the message with UVM_NONE cannot be issued.
C. If we set the configuration object in test layer,both subcomponents and sequences can retrieve its handle.
D. In SV language,It fails to cast a null pointer to an object. “$(abc,null);”

1.3 …全特么是验证的

1.7 Please select the 4-state unsigned integer types（）

A. bit.
B. logic.
C. reg.
D. shortint.

Verilog-1995中规定的数据类型有：变量(reg), 线网(wire), 32位有符号数(integer), 64位无符号数(time), 浮点数(real)。
SV中：
.logic:可以作为一个四状态变量
bit: 双状态的无符号类型
byte: 8位双状态的有符号类型
shortint: 16位双状态的有符号类型
longint: 64位双状态的有符号类型
integer: 32位四状态的有符号整数
time： 64位四状态的无符号整数
real: 双状态的双精度浮点数

1.8 Choose the right descriptions of the different between latch and flip-flop listed below（）

A. Flip-Flop saves area.
B. Latch can’t avoid glitch.
C. Flip-Flop is easier for timing closure.
D. Latch run slower than Flip-Flop.

Latch可以组成Flip-Flop；
Latch也可以避免毛刺，比如门控时钟。

1.9 Which of the following items can help reduce test time（）

A. Increase Operation Voltage.
B. Increase scan shift clock frequency.
C. Utilize more scan IOs.
D. Insert gating logic.

1.11 Coverage is usually used to evaluate the verification quality, please identify all code coverage related items from following options.

A. Branch coverage.
B. Condition coverage.
C. Function coverage.
D. Toggle coverage.
E. State coverage.
F. Expression coverage.
G. FSM coverage.

1.12 Which type of timing path is NOT included in this picture?

A. Input port to a D pin of Flop.
B. CLK pin of One Flop to D pin next Flop.
C. Q pin of flop to an output port.
D. Input to output port through purely combinational logic.

典型的组合逻辑路径只有以下四种：

1.13 Which is the correct flow for Physical Design ?

A. Floorplan → Placement → CTS → Routing
B. CTS → Floorplan → Placement → Routing
C. Placement → Floorplan → CTS → Routing
D. CTS → Placement → Floorplan → Routing

The main steps in ASIC Physical design flow are:

Design Netlist (after Synthesis);
Floorplanning;
Partitioning;
Placement;
Clock-Tree Synthesis (CTS);
Routing;
Physical Verification;
GDS Ⅱ Generation。

1.14 “PVT corner” is a significant concept in physical design to characterize different working conditions of a chip -P stands for Process and V stands for voltage. What does T stand for ?

A. Time.
B. Temperature.
C. Thickness.
D. Threshold.

1.15 Which of the following metal layer has Maximum resistance?

A. Metal2.
B. Metal3.
C. Metal5.
D. Metal8.

1.16 which of the following files are necessary for timing analysis?

A. SPEF.
B. DEF.
C. SDC.
D. Netlist.

STA tool:

Netlist;
Library;
SDC;
Parasitic.

1.17 Which among the following methods are applicable to fix setup violation?

A. Swap high Vt cells into low Vt cells.
B. Increase driver size of long net.
C. Delaying the clock to the end point.
D. Decreasing the size of certain cells in the data path.

降低cell电压；
增加驱动；
延时时钟；
减小cell面积。

1.18 Which of the following timing arcs should a normal DFF have in stand cell library?

A. CK → D.
B. CK → Q.
C. D → Q.
D. CK → CDN.

1.19 Cell Delay can be calculated based on:()

A. input transition.
B. input load.
C. output transition.
D. output load.

input transition：输入数据的变换时间；
output transition: 上一级数据的变换时间；
input load：输入负载，负载越大input transition越小；
output load：输出负载。

1.20 太简单

1.21 7nm工艺中的7nm指的是（）

A. 芯片中最小晶体管的源极长度.
B. 芯片中最小晶体管的源极宽度.
C. 芯片中最小单元的沟道长度.
D. 芯片中最小单元的源极宽度.

1.22 What is the layer that TCP worked on？

A. Network.
B. Data Link.
C. Transport.
D. Application. E. Session.

OSI七层模型：

应用层；
表示层；
会话层；
传输层；
网络层；
数据链路层；
物理层。
TCP属于传输层；IP属于网络层；HTTP属于应用层，基于TCP连接。

1.23 有一个4位的D/A转换器，设他的满刻度输出电压位10V，当输入数字量为1101时，输出电压为（）

A. 8.125V.
B. 4V.
C. 6.25V.
D. 9.375V.

1.24 Which of below pattern can detect the fault in below diagram?

A. A=1,B=1,C=0,D=0.
B. A=1,B=1,C=1,D=1.
C. A=0,B=0,C=1,D=1.
D. A=0,B=1,C=0,D=1.

1.25 In ARM AMBA AHB protocol,which of following responses is ONE cycle response?

A. OKAY.
B. ERROR.
C. RETRY.
D. SPLIT.

1.26 Assume A[3:0]=4’b0101,B[3:0]=4’b1111,which statement is correct()?

1.27 For a truth table like below,which kind of logic cell could it be?

input A	input B	output Z
1	1	0
1	0	1
0	1	1
0	0	1

A. OR.
B. NAND.
C. XOR.
D. NOR.

1.28 Choose the correct equation for power calculation()

A. Ptotal=Pstatic+Pdynamic.
B. Ptotal=Pleakage+Pinternal+Pswitching.
C. Ptotal=Pinternal+Pdynamic.
D. Ptotal=Pleakage+Pswitching.

1.29 We need to define clock specifications in SDC file,using commands like below:create_clock -name GFXCLK -period 600 -waveform {0 300}.What can we know from this command?

A. Clock frequency.
B. Clock duty cycle.
C. Clock source latency.
D. Clock name.

1.30 Which is the correct method to fix EM issue?

A. downsize victim driver.
B. double net width,double net spacing,chanfe route layer.
C. insert buffer in victim net.
D. add shield.

1.31 高频放大器工作频率越高，以下说法正确的是（）

A. 增益和带宽都大.
B. 增益和带宽都小.
C. 增益变大，带宽变小.
D. 增益变小，带宽变大.

1.32 PCIE

1.33 Ubuntu的内核有哪几个子系统（）

A. 进程管理系统.
B. 用户管理系统.
C. I/O管理系统.
D. 文件管理系统.
E. 内存管理系统.
F. 安全管理系统.

2 大疆

2.1 下列关于多bit数据跨时钟域的处理思路，错误的有（）

A. 发送方给出数据，接收方用本地时钟同步两拍再使用.
B. 发送方把数据写到异步fifo，接收方从异步fifo里读出.
C. 对于连续变化的信号，发送方转为格雷码发送，接收方收到后再转为二进制.
D. 发送方给出数据，发送方给出握手请求，接收方收到后回复.

两级信号同步是处理单比特信号，而多比特数据可以用异步FIFO、格雷码、握手协议。

2.2 对12.918做无损定点化，需要的最小位宽是多少位，位宽选择11位时的量化误差是多少？

A. 12位，0.0118.
B. 13位，0.0039.
C. 12位，0.0039.
D. 13位，0.0118.

12用二进制表示需要4位，若小数用8位表示0.918/(2^(-8))=235.008，即235×2^(-8)=0.918，所以最少只要12位。当11位时，小数的位宽只有7,0.918/(2^(-7))=117.5040，117×2^(-7)=0.9141,0.918-0.9141=0.0039。

2.3 考虑如下的4×4的“二维仲裁器”，R00到R33为输入，G00到G33为输出，N和W也为输入，E和S也为输出，假设所有的逻辑门（包括非门/与门/反相器）延时都为1ns，请问该电路的最大延迟为：

A. 23ns.
B. 25ns.
C. 19ns.
D. 21ns.

2.4 下图所示4位右移位寄存器，0时刻ABCD初始状态为0111，请写出5个时刻后的ABCD输出：

A. 1010.
B. 0100.
C. 1101.
D. 1110.

Time A B C D NAND

0 0 1 1 1 0

1 0 0 1 1 0

2 0 0 0 1 1

3 1 0 0 0 0

4 0 0 0 0 0

5 0 1 1 0 0

Time	A	B	C	D	NAND
0	0	1	1	1	0
1	0	0	1	1	0
2	0	0	0	1	1
3	1	0	0	0	0
4	0	0	0	0	0
5	0	1	1	0	0

2.5 关于流水线设计的理解，错误的是：

A. 流水线设计会消耗较多的组合逻辑资源.
B. 流水线设计会导致原有通路延时增加.
C. 流水线设计的思想，是使用面积换取速度.
D. 关键路径中插入流水线，能够提高系统时钟频率.

2.6 下列哪种逻辑门可以实现逻辑（A XOR B）OR （C AND D）？

A. NAND.
B. NOR.
C. XOR.
D. INV.

（A XOR B）OR （C AND D） = AB’ + A’B + CD
= ((AB’)’(A’B)’(CD)’)’
= ((A(BB)’)’((AA)’B)’(CD)’)’

2.7 关于DFT的描述错误的是：

A. DFT测试不能覆盖电路时序问题.
B. DFT测试过程通常会消耗大量的动态功耗.
C. DFT的主要目的是发现芯片生产过程中出现的缺陷.
D. 寄存器扫描链是一种常用的DFT技术.

DFT的at-speed test会采用芯片PLL高速时钟进行寄存器的setup和hold测试

2.8 下列那个工具不具备逻辑综合功能

A. Synplify.
B. Design Compiler.
C. Modelsim.
D. ISE.

2.9 对芯片静态功耗影响最大的是哪一项

A. 工作模式.
B. 频率.
C. 负载.
D. 电压.

Pstat = Istat × Vdd

2.10 组合逻辑中的冒险是由于（）引起的

A. 电路中有多个输出.
B. 电路未达到最简.
C. 逻辑门类型不同.
D. 电路中的延时.

由于延时导致电平翻转不能同时进行

2.11 指令系统中程序控制类指令的功能是

A. 实现主存于CPU之间的数据传送.
B. 实现程序执行顺序的改变.
C. 实现算术和逻辑运算.
D. 时间堆栈操作.

程序控制类指令包括：

跳转指令；
循环指令；
子程序指令；
中断指令。这些指令可以控制程序的执行顺序。

2.12 在对信号做降采样前添加滤波器，一般需要添加什么样的滤波器，完成什么功能？

A. 高通，抗周期延拓.
B. 高通，抗混叠滤波.
C. 低通，抗周期延拓.
D. 低通，抗混叠滤波.

为解决频率混叠，在对模拟信号进行离散化采集前，采用低通滤波滤除高于1/2采样频率的频率成分。实际仪器设计中，这个低通滤波器的截止频率（fc）为：截止频率（fc）=采样频率（fz）/2.56，在进行动态信号测试中测量仪器必须具有抗混叠滤波功能。

2.13 假设一个cycle只能完成一个8bits×8bits或一个17bits+17bits+17bits操作，那么设计16bits×16bits乘法最少可以多少个cycle完成？

A. 2.
B. 4.
C. 3.
D. 1.

两个16位相乘（A×B），等于同时有两个“两个8位相乘”，消耗一个cycle；
A的低八位乘B的低八位产生一个16位的数，类似的，一共产生4个16位的数，这四个16位的数交错相加;
最低八位不变，最高八位不变，次高位三个八位数相加，次低位三个八位数相加，又消耗两个cycle。

2.14 如下关于“线与”逻辑的描述，错误的是：

A. 可以使用OC门来实现“线与”.
B. “线与”逻辑必须在输出端加一个下拉电阻.
C. “线与”逻辑是两个输出信号相连可以实现“与”的功能.
D. 可以用OD门来实现“线与”.

OD：开漏，是对MOS管而言；
OC：集电极开路，是对双极性管而言。
两者实现线与需外加上拉电阻。

2.15 关于异步处理，以下说法正确的是：

A. 静态配置信号可以不做异步处理.
B. 异步FIFO采用格雷码的原因是为了提高电路速度.
C. 异步处理需要考虑发送和接收时钟之间的频率关系.
D. 单比特信号打两拍之后可以避免亚稳态的发生.

2.16 关于16点的FFT描述正确的是：

A. 每个蝶形算法需要一次复数加法.
B. 每级有8个蝶形算法.
C. 每个蝶形算法需要一次复数乘法.
D. 共有4级分解.

完成一个蝶形运算需要一次复数乘法和两次复数加法。

2.17 在不增加pipeline的情况下，如何解决一条critical path的setup时序不满足的问题

A. 使用更先进工艺的工艺库.
B. 在这条path上插入寄存器.
C. 将部分组合逻辑电路搬移到前级path上.
D. 降低时钟频率.

2.18 下列关于代码覆盖率描述错误的是：

A. 代码覆盖率达到百分之一百说明代码bug已消除.
B. 代码覆盖率包括功能覆盖率.
C. 代码覆盖率包括条件覆盖率.
D. 代码覆盖率包括语句覆盖率.

覆盖率是衡量设计验证完成程度的指标，并不是验证的目的。任何覆盖率达到100%并不代表芯片bug已消除。代码覆盖率包括：

行覆盖率；
条件覆盖率；
状态机覆盖率；
翻转覆盖率。功能覆盖率反映开发出来的需要覆盖的功能点覆盖的比例。断言覆盖率测量断言被触发的频繁程度。

2.19 C语言中定义了一个全局数组，编译后此数组可能分配在下列哪个阶段？

A. Text段.
B. Bss段.
C. Data段.
D. Stack段.

BSS存放的是未初始化的全局变量；
DATA存放的是初始化的全局变量。

2.20 下列优化方法中那些是速度优化方法：

A. 资源共享.
B. 关键路径优化.
C. 流水线.
D. 串行化.

2.21 对于PSK和QAM调制，以下哪些说法是正确的？

A. 对于QAM调制，星座图的每个点的幅度相等.
B. 2PSK和4PSK在归一化条件下，其幅值都是1.
C. 4-QAM调制与QSPK的调制方式一致.
D. 在同样信道条件下，16-QAM的误码率大于4-QAM.

PSK调制，星座图中的点都位于单位圆上，模相同（都为1），只有相位不同。而QAM调制星座图中的点不再位于单位圆上，而是分布在复平面的一定范围内，各点如果模相同，则相位必不相同，如果相位相同则模必不相同。

2.22 wirte-back cache和write-through cache的区别：（write-back）cache只在cache line被替代的时候把cache里的有效数据写下一级存储。

write-through（直写模式）在数据更新时，同时写入缓存cache和后端存储。此模式的优点是操作简单，缺点是因为数据修改需要同时写入存储，数据写入速度较慢。
write-back（回写模式）在数据更新时写入缓存cache只在数据被替换出缓存时，被修改的缓存数据才会被写到后端存储。此模式的优点是数据写入速度快，因为不需要写存储；缺点是已更新后的数据未被写入存储时出现系统掉电的情况，数据将无法找回。

2.23 正则表达式里可以使用计数符和通用字符集进行搜索匹配，这些计数符中，（*）号的意思是匹配0个，1个或多个，（+）号的意思是匹配一个或多个，（？）的意思是匹配0个或1个。

2.24 FPGA时序检查中对于异步复位电路的时序分析分别叫（恢复时间检查）和（移除时间检查）。

recovery time：恢复时间。
撤销复位时，恢复到解复位状态的电平必须在时钟有效沿来临之前的一段时间到来，才能保证时钟能有效恢复到解复位状态，此段时间为recovery time。类似于同步时钟的setup time。
如下图，rst_n为1’b0表示复位，clk上升沿触发，rst_n从1’b0到1’b1的上升沿与时钟上升沿必须不小于recovery time才能保证寄存器恢复到正常状态。
removal time：移除时间。
复位时，在时钟有效沿来临之后复位信号还需要保持的时间为移除时间removal time。类似同步时钟hold time。如下图，rst_n为1’b0表示复位有效，clk为上升沿触发，rst_n保持为1’b0经过clk上升沿后仍需保持一段时间，才能保证寄存器有效复位，放置亚稳态。

2.25 并行计算是提高程序速度的关键，设a为并行计算部分所占比例，n为并行处理的节点数，则并行计算带来的加速比为（1 /（a/n + 1 - a））。

S = （Ws + Wp）/（Ws + Wp/p），Ws为程序中串行部分，Wp为程序中的并行部分，p为并行节点数。

2.26 下图球框由三个相同的铁圈两两正相交组成，每个铁圈的电阻均为R。AB两点间的电阻为（5R/48）。

2.27 signal_a是clk_a(300M)时钟域的一个单时钟脉冲信号，如何将其同步到时钟域clk_b(100M)中，并产生出signal_b同步脉冲信号。请用verilog代码描述，并画出对应的时序波形说明图。


  
  
    
    
    
    
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      module 
      
      div_3_50(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input   
      
      clk,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input   
      
      rst_n,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input   
      
      in,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output  
      
      q,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output  
      
      out,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      );
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      q1,q2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      [1:0] count1,count2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      in_p,in_pp,in_ppp;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      wire 
      
      out_b;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      out_bb,out_bbb;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      q=q1|q2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(posedge 
      
      clk , negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n) 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      q1 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count1 
      
      < ='0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      if(count1==0) begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      q1 
      
      <= ~q1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count1 
      
      <= count1 + 1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      if(count1==1) begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      q1 = 
      
      ~q1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count1 
      
      <= count1 + 1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count1 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(negedge 
      
      clk , negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n) 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      q2 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count2 
      
      < ='0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      if(count2==0) begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      q2 
      
      <= ~q2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count2 
      
      <= count2 + 1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      if(count2==1) begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      q2 = 
      
      ~q2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count2 
      
      <= count2 + 1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      count2 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(posedge 
      
      clk , negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n) 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      in_p   
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      in_pp  
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      in_ppp 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      in_p   
      
      <= in;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      in_pp  
      
      <= in_p;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      in_ppp 
      
      <= in_pp;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      out_b = in_ppp|in_pp|in_p;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(posege 
      
      clk , negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n) 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      out_bb  
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      out_bbb 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      out_bb  
      
      <= out_b;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      out_bbb 
      
      <= out_bb;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      out = out_bbb;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      endmodule

select this verilog

2.28 如下图，一个高速接口的端口电路示意图，要求D端发送数字0/1。D/Q端收到相同的数字0/1。VREF电压为比较器数字输出0/1的判决电压。

（1）S1断开时，DQ端VREF电压需设置为？
（2）S1连通时，DQ端VREF电压需设置为？
（3）驱动端发送0时功耗比较低，这句话正确吗？为什么？

（1）S1断开时，若D为1，Q端电压为VDDQ，因此VREF要小于VDDQ。若D为0，Q端电压为0，因此VREF要大于0，因此0 （2）S1连通时，若D为1，Q端电压为VDDQ/3。若D为0，Q端电压为0，因此VREF要大于0，因此0 （3）驱动端为0时，NMOS管道通，反相器输出接地，电阻没有电流，因此功耗较低。

2.29 用Moore型状态机实现序列“1101”从右至左的不重叠检测。

（1）请画出状态转换图，其中状态用S0,S1,S2…表示。
（2）针对这个具体设计如何衡量验证的完备性？

（1）：

（2）：可以从定向测试，随机测试两种方式中产生激励，从代码覆盖率的角度保证代码覆盖率达100%。

2.30 进行一个运算单元的电路设计，A[7:0]*11111011，尽量用最少的资源实现，写出对应的RTL代码。


  
  
    
    
    
    
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      module 
      
      mul(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input  
      
      [7:0]    A,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output 
      
      [15:0]   B
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      );
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      wire 
      
      [15:0] reg1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      wire 
      
      [15:0] reg2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      wire 
      
      [15:0] reg3;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      reg1 = { A, {8{1'b0}}};
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      reg2 = { {6{1'b0}} , A ,{2{1'b0}}};
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      reg3 = { {8{1'b0}} , A};
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      B = reg1 - reg2 - reg3;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      endmodule

select this verilog

2.31 用C语言实现整数到ASCII码字符串的转换

额。。。。我尼玛

3 联芸科技

3.1 请解释D触发器和Latch的区别，解释同步复位和异步复位的区别及优缺点。

一、

Latch有电平触发，非同步控制。在使能信号有效时Latch相当于通路，在使能信号无效时Latch保持输出状态。D触发器由时钟沿触发，同步控制。
Latch容易产生毛刺，D触发器则不易产生毛刺。
如果使用门电路来搭建Latch和D触发器，则Latch消耗的门资源比D触发器要少，这是Latch比D触发器优越的地方。所以在ASIC中使用Latch的集成度比D触发器高，但在FPGA中恰好相反，因为FPGA中没有标准的Latch单元，但有D触发器单元，一个Latch需要多个LE才能实现。
二、
同步复位：同步复位只有在时钟沿到来时复位信号才起作用，则复位信号持续时间应该超过一个时钟周期才能保证系统复位。
异步复位：异步复位只要有复位信号系统马上就复位，因此异步复位抗干扰能力差，有些噪声也是能系统复位，因此有时候显得不够稳定，要想设计一个好的复位最好使用异步复位同步释放。
同步复位：
- 优点：
  - 有利于仿真器仿真；
  - 可以使用所设计的系统成为100%同步时序电路，这大大有利于时序分析，而且综合出来的fmax一般较高。
  - 因为他只有在时钟有效电平到来时才有效，所以可以滤掉高于时钟频率的毛刺。
- 缺点：
  - 复位信号的有效时长必须大于时钟周期，才能真正被系统识别并完成复位任务。同时还要考虑，诸如：clk skew，组合逻辑路径延>时，复位延时等因素；
  - 由于大多数的逻辑器件的目标库内的DFF都只有异步复位端口，所以，倘若采用同步复位的话，综合器就会在寄存器的寄存器的数据输入端口插入组合逻辑，这样就会耗费较多的逻辑资源。
异步复位：
- 优点：
  - 大多数目标器件库的DFF都有异步复位端口，因此采用异步复位可以节省资源；
  - 设计相对简单；
  - 异步复位信号识别方便，而且可以很方便的使用FPGA的全局复位端口GSR。
- 缺点：
  - 在复位信号释放（release）的时候很容易出现问题，倘若复位释放时恰好在时钟有效沿附近，就很容易使寄存器输出出现亚稳态，从而导致亚稳态。
  - 复位信号容易收到毛刺影响。

3.2 解释什么叫clock gating？并说明一下通常情况下为什么要做clock gating？简单列举通常实现的方法有哪些？

门控时钟计数（clock gating）是一种非常简单和有效的功耗控制方法，它的基本原理就是通过关闭芯片上暂时用不到的功能和它的时钟，从而实现节省电流消耗的目的。
clk信号和clk_enable相与。

时钟门控(Clock-Gating)一直以来都是降低微处理器功耗的重要手段,主要针对寄存器翻转带来的动态功耗。如何更加有效地设计时钟门控对于最大限度地降低功耗，同时保证处理器的性能至关重要。多核多线程微处理器中，多个功能部件可能不是同时工作的，对于无执行任务的功能部件就可以将其时钟关闭，减少其随时钟翻转进行多余的内部寄存器翻转，从而降低产生功耗的浪费和热量聚集。

3.3 实现一个可以1-8分频任意切换的分频器，要求无论是奇数分频还是偶数分频，分频后的时钟的duty cycle都是50%。

占空比模块：


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     module 
     
     Duty_Cycle#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         parameter   
     
     HIGH_TIME = 
     
     1,  
     
     //高电平时间
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     LOW_TIME  = 
     
     2,  
     
     //低电平时间
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     BIT_WIDTH = 
     
     2   
     
     //位宽
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     )(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input       clk,            
     
     //时钟
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input       rst_n,          
     
     //异步复位
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         output reg  clk_out         
     
     //输出
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg [
     
     BIT_WIDTH-
     
     1:
     
     0] 
     
     count;  
     
     //计数器
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         always_ff @(posedge clk, negedge rst_n) begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     if(!rst_n) begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     count <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     if(
     
     count < 
     
     HIGH_TIME) begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     count <= 
     
     count + 
     
     1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 clk_out <= '
     
     1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     if((
     
     count < 
     
     HIGH_TIME+
     
     LOW_TIME-
     
     1) && (
     
     count >= 
     
     HIGH_TIME))begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 clk_out <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     count <= 
     
     count + 
     
     1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     if(
     
     count >= 
     
     HIGH_TIME+
     
     LOW_TIME-
     
     1)begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 clk_out <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     count <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 clk_out <= clk_out;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     count <= 
     
     count;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     endmodule

select this verilog

分频模块：


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     module 
     
     Frequency_Divider#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     parameter   
     
     DIV_COEFF = 3,  //分频系数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     BIT_WIDTH = 
     
     2   //分频系数位宽
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     )(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input       
     
     clk,            //时钟
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input       
     
     rst_n,          //复位
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     output      
     
     clk_out         //分频时钟
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //=
     
     =====================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //奇偶判断，0为偶
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     wire 
     
     odd_even;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     wire 
     
     [BIT_WIDTH-1:0] div_coeff;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     div_coeff = DIV_COEFF;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     odd_even = div_coeff[0];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //=
     
     =====================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //计算高低占空比时间
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     parameter 
     
     HIGH_TIME = DIV_COEFF/2;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     parameter 
     
     LOW_TIME  = DIV_COEFF-HIGH_TIME;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //=
     
     =====================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //根据奇偶分频分配时钟
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     clk_p,clk_n;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     always_comb 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     if(odd_even)begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     clk_p = 
     
     clk;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     clk_n = 
     
     ~clk;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     clk_p = 
     
     clk;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     clk_n = 
     
     clk;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     wire 
     
     clk_out_p,clk_out_n;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     Duty_Cycle#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .HIGH_TIME 
     
     (HIGH_TIME),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .LOW_TIME  
     
     (LOW_TIME),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .BIT_WIDTH 
     
     (BIT_WIDTH)
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     )u1_Duty_Cycle(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .clk       
     
     (clk_p),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .rst_n     
     
     (rst_n),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .clk_out   
     
     (clk_out_p) 
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     Duty_Cycle#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .HIGH_TIME 
     
     (HIGH_TIME),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .LOW_TIME  
     
     (LOW_TIME),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .BIT_WIDTH 
     
     (BIT_WIDTH)
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     )u2_Duty_Cycle(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .clk       
     
     (clk_n),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .rst_n     
     
     (rst_n),
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     .clk_out   
     
     (clk_out_n) 
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     clk_out = clk_out_p | clk_out_n;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     endmodule

select this verilog

3.4 请画一个状态机（状态转换图）来检测串行比特流中的‘10011’。

3.5 现有三个输入信号分别是a，b，c，并且前级DFF Clock到a，b，c的延时分别是Ta，Tb，Tc（Ta>Tb>Tc），请用两个二输入选择器对a，b，c实现三输入选择输出，画电路图并解释设计思路，不需要考虑Clock Skew的影响。

3.6 请画出下列数字电路D触发器输出Q0，Q1的波形图（复位之后Q0，Q1均为0，画出复位后8个时钟周期）。

	Q0	Q1
RESET	0	0
第一个CLK	1	0
第二个CLK	1	1
第三个CLK	0	0
第四个CLK	1	0
第五个CLK	1	1
第六个CLK	0	0
第七个CLK	1	0
第八个CLK	1	1

3.7 分析代码覆盖率时，verilog语句if(a||b&&c)有那几个条件需要覆盖？请用表格列出每种状况下a/b/c的值（a/b/c均为bit类型，如果是0或1都无所谓，请用“-”表示）。

a b c a||b&&c

1 - - 1

0 0 0 0

0 0 1 0

0 1 0 0

- 1 1 1

a为真或b&&c为真，结果为真；
a和b&&c都为假时，结果为假。

a	b	c	a\|\|b&&c
1	-	-	1
0	0	0	0
0	0	1	0
0	1	0	0
-	1	1	1

3.8 使用任意一种编程或脚本语言（C，Verilog，SystemVerilog，shell，perl，Python）实现32位十六进制转化为二进制数（如abcd0123->10101011110011010000000100100011）。

一、十六进制间的任意转换：

我主要的思路分两个步骤：

1、把x进制数转换成十进制数

2、再把该十进制数转换成我们需要得到的m进制数
二、代码（func.c、func.h、main.c）

1、func.c

#include "func.h"
 
 
/*十进制转m进制*/
int decim(int n, int m, int buf[])
{
	int s;
	bzero(buf, sizeof(buf));
	
	s=0;
	while(n>=m){
		buf[s++] = (n - (n/m)*m);
		n /= m;
	}
	buf[s]=n;
	return s+1;
}
 
/*m进制转十进制*/
int C_decim(char n[], int m)
{
	int i,j,len,s,flag,num;
	
	s=0;
	flag=0;
	len=strlen(n);
	for(i=len-1; i>=0; i--){
		num = 1;
		for(j=0; j<flag; j++){
			num *= m;
		}
		if((n[i] >= '0') && (n[i] <= '9')){
			s += ((n[i]-'0')*num);	
		}else if((n[i] >= 'a') && (n[i] <= 'f')){
			s += ((n[i]-'a'+10)*num);
		}else if((n[i] >= 'A') && (n[i] <= 'F')){	
			s += ((n[i]-'A'+10)*num);
		}
		flag++;
	}
 
	return s;
}
char str1[16]={'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
char str2[16]={'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
/*判断数据的正确与否*/
int judge(int x, int m, char n[])
{
	int i,len;
	if(x<2 || m<2 || x>16 ||m>16){
		return -1;
	}
	
	len=strlen(n);
	
	for(i=0; i<len; i++){
		if(m > 9){
			if('0' > n[i] || n[i] > ('a'+m-10) || (n[i] > '9' && n[i] < 'A') || \
			 (n[i] > ('A'+m-10)&&(n[i] < 'a'))){
				return -1;
			}
		}else{
			if('0' > n[i] || ('0'+m) <= n[i] ){
				return -1;
			}
		}
	}
	return 0;
}

2、func.h

#include 
#include 
 
/*十进制转m进制*/
int decim(int , int , int *);
 
/*m进制转十进制*/
int C_decim(char * , int );
 
int judge(int , int , char *);

3、main.c

#include "func.h"
 
char str[16]={'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
int main(void)
{
	int i ,temp ,k ,x ,m ,buf[64];
	char n[64];
 
	while(1){
		bzero(n, sizeof(n));
		printf("\n十六进制间的任意转换（USAGE:x n m)\nx:输入的为几进制数;n:输入的数;m:将要转换成几进制数\n>>>>>>输入小于2的数退出<<<<<<\n");
		scanf("%d", &x);
		if(x < 2){
			return 0;
		}
		scanf("%s", n);
		scanf("%d", &m);
		
		/*判断输入数据的正确与否*/
		if(-1 == judge(x, m, n)){
			printf("input error!\n");
			continue;
		}
 
		/*转换成十进制*/
		temp=C_decim(n, x);
		/*转换成需要的进制*/
		k=decim(temp, m, buf);
		
		printf("%d进制数%s转换成%d进制数的结果: ", x, n, m);
		for(i=k-1; i>=0; i--){
			printf("%c", str[buf[i]]);
		}
		printf("\n\n");
	}
	return 0;
}

3.9 使用C或Verilog/SystemVerilog，定义并实现一个函数，传递三个int类型参数A，B，C，函数返回后，A的值不变，B的值变为A+B，C的值变为A-C，请写出函数原型定义与函数体的实现。


  
  
    
    
    
    
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
      module A;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      int A;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      int B;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      int C;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
      initial begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          A=
      
      1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          B=
      
      2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          C=
      
      3;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          $display(
      
      "%d,%d,%d",A,B,C);
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      #1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          func1(A,B,C);
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          $display(
      
      "%d,%d,%d",A,B,C);
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
      function automatic viod func1(
      
      ref 
      
      int A,
      
      ref 
      
      int B,
      
      ref 
      
      int C);
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          A=A;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          B=A+B;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
          C=A-C;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
      endfunction
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
        
        
        
        
      
      endmodule

select this verilog

3.10 请列出下述模块与中断先关的所有功能测试点。

CPU通过APB接口读写寄存器，interrupt为中断输出信号。模块内有如下寄存器，每个bit对应一种中断源，当某个中断enable位配置为1时，内部逻辑被允许对中断status位进行置位操作；当任意一位status被置位1，且其mask位为0时，则interrupt输出为高电平。CPU通过APB将status位写1清0。如果所有status位都被清0后，interrupt输出低电平。

中断使能寄存器reg_int_enable[7:0];
中断屏蔽寄存器reg_init_mask[7:0]; 中断状态寄存器reg_int_status[7:0]（所有位都是W1C，即“写1清0”）。

APB总线对三个寄存器任意一位读写操作功能测试；
reg_int_status寄存器任意一位W1C功能测试；
APB总线配置reg_int_enable寄存器任意一位为1，对应位status置位功能测试；
寄存器reg_int_enable和reg_int_status对应位置位时，且reg_int_mask对应位置0时，信号interrupt拉高功能测试；
reg_int_status寄存器所有位W1C操作，信号interrupt拉低功能测试。

4 联发科

4.1 ASIC流程，说出5个以上环节；Verilog说出5个以上keyword。

4.2 用一个mux和一个反相器实现xor，画电路或Verilog代码实现。

A B XOR

0 0 0

0 1 1

1 0 1

1 1 0

A	B	XOR
0	0	0
0	1	1
1	0	1
1	1	0

verilog实现：


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     module 
     
     xor_rill
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     (
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input 
     
     a,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input 
     
     b,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     output 
     
     z
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     assign 
     
     z = a?(~b):b;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     endmodule

4.3 如下图所示：clk到Q的输出延时为T1min

T1max + T2max + Tsetup < T；
所以：Tsetup < T-T1max-T2max；
T1min + T2min > Tholdup。

4.4 如下图所示：根据A的波形，画出B，C的波形，寄存器是同步清零的。

4.5 十进制的12.8125用二进制的数表示，十六进制的A8D6用八进制的数表示。

12 = 1100;
0.1825 × 4 = 3.25，表示：11.01，所以0.8125=0.1101；
所以，12.8125 = 1100.1101。
A8D6 = 1010100011010110 = 124326。

4.6 SV比Verilog强在哪里？OVM、UVM、VMM是什么？

SV支持面向对象的编程，支持断言的语法，支持更多的数据类型。 VMM：Verification Methodology Manual，由ARM和Synopsys提出的，寄存器解决方案RAL机制；
OVM：Open Verification Methodology，Mentor和Cadence共同提出，引进了factory机制；
UVM：Universal Verification Methodology，通用验证方法学，Accellera提出的，继承了VMM和OVM的优点，克服了二者的缺点，代表了验证方法学的主流，并得到了三大EDA厂商Cadence、Synopsys和Mentor Graphics的支持。

4.7 用Python或Perl写程序，在xxx.log中找到fail单词。

用。。。

4.8 int b = 100；int *a； a=&b有什么意义？a=b有什么意义？

a=&b定义指针变量a，变量指向整形数据b的地址，printf(“%d”,a)结果为100；
a=b表示指针变量a的值为100，a表示一个地址为100的数据。

4.9

4.10 CPU cache miss/hit 区别

CPU要访问的数据在Cache中有缓存，称为“命中”（Hit），反之则称为“缺失”（Miss）。
当运算器需要从存储器中提取数据时，它首先在最高级的Cache中寻找然后在次高级的Cache中寻找。如果在Cache中找到，则称为命中hit；反之则称为不命中hit。

4.11 110序列选择器，画出状态图，写出Verilog代码


  
  
    
    
    
    
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      module 
      
      Sequential_Detector(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input       
      
      clk,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input       
      
      rst_n,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input       
      
      in,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output      
      
      out
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      );
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      parameter   
      
      s0 = 2'b00,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s1 = 
      
      2'b01,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s2 = 
      
      2'b10;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      [1:0] cur_state,next_state;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      out_r;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff(posedge 
      
      clk,negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      cur_state 
      
      <= s0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      cur_state 
      
      <= next_state;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_comb 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      case(cur_state)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      s0: 
      
      next_state = (in==1'b1)?s1:s0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      s1: 
      
      next_state = (in==1'b1)?s2:s0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      s2: 
      
      nexe_state = (in==1'b0)?s0:s2;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      default: 
      
      nexe_state = s0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      endcase
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(posedge 
      
      clk,negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      out_r 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      case(cur_state)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s0: 
      
      out_r <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s1: 
      
      out_r <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s2: 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      if(in=
      
      =0)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      out_r 
      
      <= '1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      else
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      out_r 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      endcase
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      assign 
      
      out = out_r;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      endmodule

select this verilog

4.12 某夜，A、B、C、D四人要过桥，该桥每次只能通行2个人，只有一个手电筒，过桥必须持有手电筒，A、B、C、D四人单独过桥的时间分别为1分钟、2分钟、5分钟和10分钟。现要求四人最短时间完成过桥，不能折返，请问该如何操作？

AB先过去，A返回，CD再过去，B返回，AB再走一遍：2+1+10+2+2=17min。

5 平头哥

5.1 SV里四值变量有哪些？

reg（单比特或多比特的无符号数）；

wire（线网）；

time（64比特的无符号数）；

integer（32比特的有符号数）；

logic（SV改进型reg）。

5.2 SV里面动态数组、关联数组、队列各自的优缺点，应用场合。

特点：

动态数组：可以在仿真时分配空间或者调整宽度，这样在仿真中就可以使用最小的存储量；

关联数组：用来保存稀疏矩阵的元素，当随一个非常大的地址空间进行寻址时，SV只对实际写入的元素分配空间，比定宽和动态数组所> 占用的空间要小得多；

队列：结合了链表和数组的优点，可以在队列的任意位置增加或删除元素，这类操作在性能上比动态数组小得多，可以通过索引对任意> 元素进行访问；

应用场合：

动态数组：随机事务不确定位宽的大小；

关联数组：需要建立一个超大容量数组，用关联数组来存放稀疏矩阵中的元素；

队列：增加元素或删除元素方便。

5.3 function和task的区别

function task

函数能调用另一个函数，但不能调用另一个任务任务能调用另一个任务，也能调用另一个函数

函数总是在仿真0时刻就开始执行任务可以在非零仿真时刻执行

函数一定不能包含任何延迟、事件或时序控制声明语句任务可以包含延迟、事件或时序控制声明语句

函数至少有一个输入变量，函数可以有多个输入变量任务可以没有或者有多个输入、输出和双向变量

函数只能返回一个值，函数不能有输出或者双向变量任务不返回任何值，任务可以通过输出或者双向变量传递多个值

function	task
函数能调用另一个函数，但不能调用另一个任务	任务能调用另一个任务，也能调用另一个函数
函数总是在仿真0时刻就开始执行	任务可以在非零仿真时刻执行
函数一定不能包含任何延迟、事件或时序控制声明语句	任务可以包含延迟、事件或时序控制声明语句
函数至少有一个输入变量，函数可以有多个输入变量	任务可以没有或者有多个输入、输出和双向变量
函数只能返回一个值，函数不能有输出或者双向变量	任务不返回任何值，任务可以通过输出或者双向变量传递多个值

5.4 数据的类型转换怎么做？静态强制类型转换绝动态强制类型转换有什么区别？

静态转换：转换时指定目标类型，并在需要转换的表达式前加上单引号即可；

动态转换：使用函数$cast。

区别：静态类型转换操作不对转换值进行检查，具有一定的危险性；动态转换在运行时将进行检查，如果转换失败会产生运行时错误。

5.5 virtual interface的作用

interface只在module中声明，在class中要用virtual interface；

virtual interface是仿真运行时才连接到DUT上的，如果只是interface，在编译时就必须进行连接，在class中时是automatic，在运行> 的时候产生；

virtual interfacec主要完成接口的动态分配，只要在top层定义virtual interface，其它层不需要改变，直接通过interface传递参数> 即可；

消除绝对路径，避免修改的时候改的东西很多。

5.6 多态

多态性（polymorphisn）是允许你将父对象设置称为一个和更多的他的子对象相同的技术，复制之后，父对象就可以根据当前赋值给它的子> 对象的特性以不同的方式运作。简单的说就是允许将子类类型的指针赋值给父类类型的指针。

多态的作用是为了实现接口重用，为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

多态的实现方法：

覆盖：是指子类重新定义父类的虚函数的做法；

重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

验证的好多。。。

5.14 fork join，fork join_any，fork join_none的用法

fork join：当前速优子进程执行完毕，才会继续执行后面的进程；

fork join_any：当前的任一子进程执行完毕后，才会继续执行后面的进程；

fork join_none：当前的子进程并不阻塞后面的进程执行。

5.15 阻塞赋值和非阻塞赋值的区别。

阻塞赋值的操作符号用等号（=）表示，当前语句的赋值阻塞其它语句的赋值；

非阻塞赋值的操作符号用小于等于好（<=）表示，当前语句的赋值不阻塞其它语句的赋值。

5.16 Callback机制的运行机理

Callback机制，其实是使用OOP来实现的一种程序开发者向程序使用者提供的模块内部的接口，可以在Test_case的高度改变其他Component的一些行为。

对于程序的开发者而言：

派生一个uvm_callback的类；
typedef定义一个uvm_callbacks pool；
在对应的组件中注册派生的callback类。对于程序的使用者而言：
定义一个新的callback的派生子程序开发者所定义的类，并重写类的方法；
在对应的test_base中实例化并添加callback的类。

5.17 clock模块为什么要放在top module中，不放在program中的原因？

SV介绍program的一个重要部分就是为了将涉及和验证的调度区域通过显式的方式来安排，例如设计部分被建议放置在module中，而测试采样部分被建议放置在program中，program中不能使用always，program中的仿真时间与RTL中的是有区别的，SV将同一仿真时刻分为四个区域，相当于在原verilog的基础上又为program增加了一个执行区间，一个采样区间，所以clk的定义不能放在program中。当program中的initial结束时，SV会调用$finish完成仿真。

5.18 谈谈对block level，chip level，product level验证的理解？

block level：

每个模块验证首先要考虑的是哪些功能点是可以在模块一级完全验证的的，这基于如下考虑：

内部功能如状态机验证；

内部数据存储验证；

数据打包功能、编解码功能；

指令执行；

寄存器配置；

同时也需要考虑哪些功能无法在模块一级被验证到：

与其他相邻模块的互动信号；

与其他子系统的互动信号；

与芯片外部的互动信号；

与电源开关的验证。

chip level：

在芯片系统级，验证平台的复用性较高，主要因为：

外围的验证组件不需要像模块级、子系统级的组件数量多且经常需要更新，它们主要侧重于验证芯片的输入输出；

芯片内部的子系统之间的交互、协作检查主要交给了处理器和子系统，从寄存器检查和数据检查入手，写直接测试用例。

在芯片系统级的验证侧重于不同子系统之间的信号交互问题，以及实现更贴近实际使用的用例。这里的实习用例并非是在系统软件层面的，而是将> 系统软件层面的场景进一步拆分为多个模块互动情景，再分类测试的。

product level：

直接的软件测试激励，可根据示波器等工具观察波形变化，也可以根据SDK软件debug。

5.19 让用sv来验证一块memory的读写1G空间的过程

对地址空间分区间平均分成多份，对每份地址采取固定地址读写和随机读写两种策略：连续写，连续读，读紧跟着写；同时注意边界地址的读写操作。

5.20 UVM架构

5.21 请画出时钟的门控电路，要求是在使能信号无效时将时钟输出门控到高（低）电平，门控过程中请注意不产生毛刺。

5.22 请用ROM实现以下Verilog代码对应的功能：


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     always@(posedge clk) begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     if(a&&b)
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             q <= 
     
     1
     
     'b0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     else
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             q <= !q;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     end

select this verilog

ROM查找表：

a	b	D	Q
0	0	0	1
0	0	1	0
0	1	0	1
0	1	1	0
1	0	0	1
1	0	1	0
1	1	0	0
1	1	1	0

5.23 设计一个时序电路，输入是2个8bit的无符号数，输出是这两个数的最小公倍数。要求电路面积尽可能的小。请使用Verilog语言实现。

首先可以采用辗转相除法或者相减法求解最大公约数MCD；
然后利用A×B=MCD×LCM，求解最小公倍数；
其中辗转相减法和除法运算可采用状态机的方式实现。


  
  
    
    
    
    
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      module 
      
      lcm#(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      parameter 
      
      DATA_W = 8
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      )(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input                       
      
      clk,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input                       
      
      rst_n,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input   
      
      [DATA_W-1:0]        a,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input   
      
      [DATA_W-1:0]        b,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      input                       
      
      vld_in,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output  
      
      [DATA_W*2-1:0]      lcm_out,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output  
      
      [DATA_W-1:0]        mcd_out,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output                      
      
      vld_out,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      output                      
      
      ready
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      );
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      [DATA_W*2-1:0]  mcd,a_buf,b_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      [DATA_W*2-1:0]  mul_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg                 
      
      mcd_vld;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      reg 
      
      [1:0]           cur_stata,next_state;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      parameter   
      
      IDLE = 2'b00;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s0   = 
      
      2'b01;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s1   = 
      
      2'b10;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s2   = 
      
      2'b11;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(posedge 
      
      clk , negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      cur_state 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      cur_state 
      
      <= next_state;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      always_ff@(posedge 
      
      clk , negedge rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      if(!rst_n)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      next_state  
      
      <= IDLE;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      mcd         
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      mcd_vld     
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      a_buf       
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      b_buf       
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      mul_buf     
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      case(cur_state)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      IDLE:   
      
      
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      if(vld_in)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      a_buf   
      
      <= a;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      b_buf   
      
      <= b;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      next_state 
      
      <= s0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      mul_buf 
      
      <= a*b;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      mcd_vld 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      next_state 
      
      <= IDLE;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      mcd_vld 
      
      <= '0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s0:
      
      
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      if(a_buf!=
      
      b_buf)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      if(a_buf>b_buf)begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                                   
      
      a_buf   
      
      <= a_buf - b_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                                   
      
      b_buf   
      
      <= b_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                                   
      
      b_buf 
      
      <= b_buf-a_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                                   
      
      a_buf 
      
      <= b_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      next_state 
      
      <= s0;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      else 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                               
      
      next_state 
      
      <= s1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      s1: 
      
      begin
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      mcd 
      
      <= b_buf;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      mcd_vld 
      
      <= 1'b1;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      next_state 
      
      <= IDLE;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      default:
      
      
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                           
      
      next_state 
      
      <= IDLE;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                       
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
                   
      
      endcase
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      end
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      div 
      
      #(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .DATA_W(DATA_W*2)
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      ) 
      
      u_div(
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .clk,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .rst_n,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .vld_in(mcd_vld),
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .ready,
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .dividend(mul_bur),
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .divisor(mcd),
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .quotient(lcm_out),
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .remainder(),
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
               
      
      .vld_out
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      );
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
           
      
      assign 
      
      mcd_out = mcd;
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
        
     
     
       
       
       
       
    
    
      
      
      
      
     
     
     
     
    
    
      
      
      
      
     
     
       
       
       
       
    
    
      
      
      
      
    
    
      
      
      
      
     
     
       
       
       
       
      
      endmodule

select this verilog


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     module 
     
     div#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     parameter   
     
     DATA_W = 8
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     )(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input       
     
     clk,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input       
     
     rst_n,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input       
     
     vld_in,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     output      
     
     ready,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input   
     
     [DATA_W-1:0]    dividend,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     input   
     
     [DATA_W-1:0]    divisor,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     output  
     
     [DATA_W-1:0]    quotient,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     output  
     
     [DATA_W-1:0]    remainder,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     output                  
     
     vld_out
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     [DATA_W*2-1:0]  dividend_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     [DATA_W*2-1:0]  divisor_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     [DATA_W-1:0]    quotient_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     [DATA_W-1:0]    remainder_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     [1:0] cur_state,next_state;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     reg 
     
     [DATA_W-1:0] count;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     paratemer   
     
     IDLE = 2'b00,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     SUB  = 
     
     2'b01,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     SHIFT= 
     
     2'b10,
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     DONE = 
     
     2'b11;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     always_ff@(posedge 
     
     clk or negedge rst_n)begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     if(!rst_n)begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     dividend_e  
     
     <= '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     divisor_e   
     
     <= '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     quotient_e  
     
     <= '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     remainder_e 
     
     <= '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     count       
     
     <= '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     cur_state   
     
     <= IDLE;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     case 
     
     (sur_state)
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     IDLE: 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     dividend_e 
     
     <= ,dividend};
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     divisor_e  
     
     <= {divisor,{DATA_W{1'b0}}};
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     if(vld_in)
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     cur_state 
     
     <= SUB;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     else
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     cur_state 
     
     <= IDLE;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     SUB: 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     if(dividend_e 
     
     >= devisor_e)begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     quotient_e 
     
     <= {quotient_e[DATA_W-2:0],1'b1};
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     dividend_e 
     
     <= dividend_e - divisor_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     else 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     quotient_e 
     
     <= {quotient_e[DATA_W-2:0],1'b0};
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     dividend_e 
     
     <= dividend_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     cur_state 
     
     <= SHFIT;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     SHIFT:
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     if(count
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     cur_state 
     
     <= SUB;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     dividend_e 
     
     <= dividend_e<<1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     cound 
     
     <= count + 1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     else 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     cur_state   
     
     <= DONE;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                              
     
     remainder_e 
     
     <= dividend_e[DATA_W*2-1:DATA_W];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     DONE: 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     count  
     
     <='0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                          
     
     cur_state 
     
     <= IDLE;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     endcase
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     quotient = quotient_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     remainder = remainder_e;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     ready = (cur_state==IDLE)?1'b1:1'b0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     assign 
     
     vld_out = (cur_state==DONE)?1'b1:1'b0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     endmodule

select this verilog

或者我写的：


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Module Name:					LCM.v
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Department:					Xidian University
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Function Description:	        求最大公约数和最小公倍数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Version 	Design		Coding		Simulata	  Review		Rel data
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //V1.0		Verdvana	Verdvana	Verdvana		  			2020-01-04
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //-----------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Version	Modified History
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //V1.0		
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //-----------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     `timescale 
     
     1ns/
     
     1ns
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     module LCM #(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         parameter   DATA_WIDTH = 
     
     8          
     
     //数据位宽
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     )(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //**********时钟&复位***********//
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input                       clk,    
     
     //时钟
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input                       rst_n,  
     
     //复位
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //**********控制信号***********//
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input                       en,     
     
     //使能
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //**********输入数据***********//
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input  [DATA_WIDTH-
     
     1:
     
     0]     a,      
     
     //第一个数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input  [DATA_WIDTH-
     
     1:
     
     0]     b,      
     
     //第二个数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //**********输出数据***********//
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         output                      valid,  
     
     //输出数据有效信号
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         output [DATA_WIDTH*
     
     2-
     
     1:
     
     0]   gcd,    
     
     //最大公约数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         output [DATA_WIDTH*
     
     2-
     
     1:
     
     0]   lcm     
     
     //最小公倍数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //===================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //使能上升沿检测
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg en_r1,en_r2;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         always_ff @(posedge clk, negedge rst_n) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     if(!rst_n) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 en_r1 <= 
     
     '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 en_r2 <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 en_r1 <= en;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 en_r2 <= en_r1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         wire enable;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign enable = en_r1 && ~en_r2;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //===================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //辗转相除计算最大公约数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg  [DATA_WIDTH-
     
     1:
     
     0] numer,denom;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         wire [DATA_WIDTH-
     
     1:
     
     0]quotient,remain;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     DIV#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .DATA_WIDTH(DATA_WIDTH)                     
     
     //数据位宽
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         )u_DIV(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .numer,      
     
     //被除数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .denom,      
     
     //除数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .quotient,   
     
     //商
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .remain      
     
     //余数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg [DATA_WIDTH*
     
     2-
     
     1:
     
     0]   gcd_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         always_ff @(posedge clk, negedge rst_n) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     if(!rst_n) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 numer <= 
     
     '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 denom <= '
     
     0;   
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      		
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     if(valid) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 numer <= 
     
     '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 denom <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     if(enable) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 numer <= a;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 denom <= b;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     else 
     
     if(remain!=
     
     '0)begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 numer <= denom;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 denom <= remain;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             else begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 gcd_r <= denom;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
         end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
         assign gcd = (valid)?gcd_r:'
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //===================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //产生输出有效信号
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg valid_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         always_ff @(posedge clk, negedge rst_n) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     if(!rst_n) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 valid_r <= 
     
     '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             else if((remain=='
     
     0)&&(denom!=
     
     '0)&&(valid_r=='
     
     0)) 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 valid_r <= 
     
     '1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
             else begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                 valid_r <= '
     
     0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign valid = valid_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //===================================================
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //计算最小公倍数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         wire [DATA_WIDTH*
     
     2-
     
     1:
     
     0]   lcm_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         wire [DATA_WIDTH*
     
     2-
     
     1:
     
     0]   product;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign product = a*b;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     DIV#(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .DATA_WIDTH(DATA_WIDTH*
     
     2)                     
     
     //数据位宽
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         )ulcm_DIV(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .numer(product),      
     
     //被除数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .denom(gcd),      
     
     //除数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .quotient(lcm_r),   
     
     //商
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             .remain()      
     
     //余数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign lcm = (valid)?lcm_r:
     
     '0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
         
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     endmodule

select this verilog


 
 
   
   
   
   
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Module Name:					DIV.v
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Department:					Xidian University
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Function Description:	        整数除法器
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Version 	Design		Coding		Simulata	  Review		Rel data
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //V1.0		Verdvana	Verdvana	Verdvana		  			2020-01-03
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //-----------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //Version	Modified History
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //V1.0		
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
     //-----------------------------------------------------------------------------------
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     module 
     
     DIV #(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         DATA_WIDTH  = 
     
     8                     
     
     //数据位宽
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     )(
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //**********输入***********//
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input  [DATA_WIDTH-
     
     1:
     
     0] numer,      
     
     //被除数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         input  [DATA_WIDTH-
     
     1:
     
     0] denom,      
     
     //除数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     //**********输出***********//
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         output [DATA_WIDTH-
     
     1:
     
     0] quotient,   
     
     //商
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         output [DATA_WIDTH-
     
     1:
     
     0] remain      
     
     //余数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     );
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg [DATA_WIDTH*
     
     2-
     
     1:
     
     0] numer_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg [DATA_WIDTH*
     
     2-
     
     1:
     
     0] denom_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg quotient_e [DATA_WIDTH];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         always_comb 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             numer_r = ,numer};   
     
     //左边补齐0
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
             denom_r = denom << DATA_WIDTH;          
     
     //右边补齐0
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg [DATA_WIDTH*
     
     2-
     
     1:
     
     0] numer_e [DATA_WIDTH+
     
     1];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         reg [DATA_WIDTH*
     
     2-
     
     1:
     
     0] denom_e [DATA_WIDTH+
     
     1];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign numer_e[
     
     0] = numer_r;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign denom_e[
     
     0] = denom_r >> 
     
     1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         generate
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         genvar i;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
          
     
     for(i=
     
     0;i
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     begin:shift
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                 always_comb 
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     if( numer_e[i] >= denom_e[i])
     
     begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                         quotient_e[DATA_WIDTH-
     
     1-i] = 
     
     1
     
     'b1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                         numer_e[i+1] =  numer_e[i]-denom_e[i];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                         denom_e[i+1] = denom_e[i] >> 1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                     else begin
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
     
                         quotient_e[DATA_WIDTH-1-i] = 1'b0;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                         numer_e[i+
     
     1] =numer_e[i];
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
                         denom_e[i+
     
     1] = denom_e[i] >> 
     
     1;
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                      
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
                  
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      				
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     				assign quotient[i] = quotient_e[i]; 
     
     //得出商
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
              
     
     end
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         endgenerate
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
         assign remain = numer_e[DATA_WIDTH];    
     
     //取余数
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
       
    
    
      
      
      
      
   
   
     
     
     
     
    
    
    
    
   
   
     
     
     
     
    
    
      
      
      
      
   
   
     
     
     
     
   
   
     
     
     
     
    
    
      
      
      
      
       
       
       
       
     
     endmodule

select this verilog

6 其它

6.1 常用逻辑电平

低速：RS232、RS485、RS422、TTL、CMOS、LVTTL、LVCMOS、ECL、LVPECL等；
高速：LVDS、GTL、PGTL、CML、HSTL、SSTL等。

6.2 可编程逻辑器件

ROM、PLA、FPLA、PAL、GAL、EPLD、FPGA、CPLD等

6.3 基尔霍夫定律

KCL：电路中的任意节点，任意时刻流入该节点的电流等于流出该节点的电流；
KVL：在任何一个闭合回路中，各元件上的电压降的代数和等于电动势的代数和。

6.4 描述反馈电路的概念，列举他们的应用

反馈是将放大器输出信号（电压或电流）的一部分或全部，回收到放大器输入端与输入信号进行比较（相加或相减），并用比较所得的有效输入信号去控制输出，负反馈可以用来稳定输出信号或者增益，也可以扩展通频带，特别适合于自动控制系统。正反馈可以形成振荡，适合振荡电路和波形发生电路。

6.5 负反馈种类及其优点

电压并联反馈，电流串联反馈，电压串联反馈和电流并联反馈。

降低放大器的增益灵敏度，改变输入电阻和输出电阻，改善放大器的线性和非线性失真，有效地扩展，放大器的通频带，自动调节作用。

6.6 放大电路的频率补偿的目的是什么，有哪些方法

频率补偿：是为了改变频率特性，减小时钟和相位差，使输入输出频率同步。

相位补偿：通常是改善稳定裕度，相位补偿与频率补偿的目标有时是矛盾的。

不同的电路或者说不同的元器件对不同频率的放大倍数是不相同的，如果输入信号不是单一频率，就会造成高频放大的倍数大，低频放大的倍数小，结果输出的波形就产生了失真。

放大电路中频率补偿的目的：一是改善放大电路的高频特性，二是克服由于引入负反馈而可能出现自激振荡现象，使放大器能够稳定工作。

在放大电路中，由于晶体管结电容的存在常常会使放大电路频率响应的高频段不理想，为了解决这一问题，常用的方法就是在电路中引入负反馈。然后，负反馈的引入又引入了新的问题，那就是负反馈电路会出现自激振荡现象，所以为了使放大电路能够正常稳定工作，必须对放大电路进行频率补偿。

频率补偿的方法可以分为超前补偿和滞后补偿，主要是通过接入一些阻容元件来改变放大电路的开环增益在高频段的相频特性，目前使用最多的就是锁相环。

6.7 有源滤波器和无源滤波器的区别

无源滤波器：这种电路主要有无源元件 R、L 和 C 组成；

有源滤波器：集成运放和 R、C 组成，具有不用电感、体积小、重量轻等优点。集成运放的开环电压增益和输入阻抗均很高，输出电阻小，构成有源滤波电路后还具有一定的电压放大和缓冲作用。但集成运放带宽有限，所以目前的有源滤波电路的工作频率难以做得很高。

6.8 什么是频率响应，怎么才算是稳定的频率响应，简述改变频率响应曲线的几个方法

这里仅对放大电路的频率响应进行说明。在放大电路中，由于电抗元件（如电容、电感线圈等）及晶体管极间电容的存在，当输入信号的频率过低或过高时，放大电路的放大倍数的数值均会降低，而且还将产生相位超前或之后现象。也就是说，放大电路的放大倍数（或者称为增益)和输入信号频率是一种函数关系，我们就把这种函数关系称为放大电路的频率响应或频率特性。

放大电路的频率响应可以用幅频特性曲线和相频特性曲线来描述，如果一个放大电路的幅频特性曲线是一条平行于x轴的直线（或在关心的频率范围内平行于x轴），而相频特性曲线是一条通过原点的直线（或在关心的频率范围是条通过原点的直线），那么该频率响应就是稳定的。

改变频率响应的方法主要有：

改变放大电路的元器件参数；
引入新的元器件来改善现有放大电路的频率响应；
在原有放大电路上串联新的放大电路构成多级放大电路。

6.9 DAC和ADC的实现各有哪些方法？

实现DAC转换的方法有：

权电阻网络 D/A 转换；
倒梯形网络 D/A 转换；
权电流网络 D/A 转换；
权电容网络 D/A 转换；
开关树形 D/A 转换等。

实现ADC转换的方法有：

并联比较型A/D转换；
反馈比较型A/D转换；
双积分型A/D转换；
V-F变换型A/D转换。

6.10 A/D电路组成、工作原理

A/D 电路由取样、量化和编码三部分组成。

由于模拟信号在时间上是连续信号而数字信号在时间上是离散信号，因此A/D转换的第一步就是要按照奈奎斯特采样定律对模拟信号进行采样。又由于数字信号在数值上也是不连续的，也就是说数字信号的取值只有有限个数值，因此需要对采样后的数据尽量量化，使其量化到有效电平上，编码就是对量化后的数值进行多进制到二进制二进制的转换。

6.11 为什么一个标准的倒相器中P管的宽长比要比N管的宽长比大？

和载流子有关，P管是空穴导电，N管电子导电，电子的迁移率大于空穴，同样的电场下，N管的电流大于P管，因此要增大P管的宽长比，使之对称，这样才能使得两者上升时间下降时间相等、高低电平的噪声容限一样、充电和放电是时间相等。

6.12 锁相环有哪几部分组成？

锁相环路是一种反馈控制电路，简称锁相环（PLL）锁相环的特点是：利用外部输入的参考信号控制环路内部振荡信号的频率和相位。因锁相环可以实现输出信号频率对输入信号频率的自动跟踪，所以锁相环通常用于闭环跟踪电路。

锁相环在工作的过程中，当输出信号的频率与输入信号的频率相等时，输出电压与输入电压保持固定的相位差值，即输出电压与输入电压的相位被锁住，这就是锁相环名称的由来锁相环通常由鉴相器（PD）、环路滤波器（LF）和压控振荡器（VCO）三部分组成。

锁相环中的鉴相器又称为相位比较器，它的作用是检测输入信号和输出信号的相位差，并将检测出的相位差信号转换成电压信号输出，该信号经低通滤波器滤波后形成压控振荡器的控制电压，对振荡器输出信号的频率实施控制。

告辞。

你可能感兴趣的:(数字IC笔试题集锦)

android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断尐尐呅
结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
每日一题——第八十九题互联网打工人no1 C语言程序设计每日一练 c语言
题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
每日一题——第八十三题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
WPF中的ComboBox控件几种数据绑定的方式互联网打工人no1 wpf c#
一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
腾讯云技术深度探索：构建高效云原生微服务架构我的运维人生云原生架构腾讯云运维开发技术共享
腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
关于提高复杂业务逻辑代码可读性的思考编程经验分享开发经验 java 数据库开发语言
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
在一台Ubuntu计算机上构建Hyperledger Fabric网络落叶无声9 区块链超级账本 Hyperledger fabric 区块链 ubuntu 构建 hyperledger fabric
在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
【PG】常见数据库、表属性设置江无羡数据库
PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
Low Power概念介绍-Voltage Area 飞奔的大虎
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
每日一题——第八十八题互联网打工人no1 C语言程序设计每日一练 c语言
题目：输入一个9位的无符号整数，判断其是否有重复数字#include#include#includeintmain(){charnum_str[10];printf("请输入一个9位数的无符号数：");scanf_s("%9d",&num_str);if(strlen(num_str)!=9){printf("输入的不是一个9位无符号整数，请重新输入");}else{if(hasDuplicate
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首张三叨
你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
ES聚合分析原理与代码实例讲解光剑书架上的书大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
java短路运算符和逻辑运算符的区别 3213213333332132 java基础
/* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
Java异常那些不得不说的事白糖_ java exception
一、在finally块中做数据回收操作比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
BOM——Byte Order Mark，就是字节序标记在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输字符"ZERO WIDTH NO-BREAK SPACE"。这样如
JAVA Annotation之定义篇周凡杨 java 注解 annotation 入门注释
Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
tomcat的多域名、虚拟主机配置 g21121 tomcat
众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。很多朋友搜索的内容基本是告诉我们这么配置：在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linux capistrano
1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
log4j的用法 Harry642 java log4j
一、前言： log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oracle jave
定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页：　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：
Hessian 简单例子 antlove java Web service hessian
hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
数据库对象的同义词和序列百合不是茶 sql 序列同义词 ORACLE权限
回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试 mockito Powermock
实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle 数据库 plsql
/* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：负载均衡的好处增加可用资源增加吞吐量加快响应速度，降低延时出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
jquery-validation备忘白糖_ jquery css F#Firebug
留点学习jquery validation总结的代码： function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误，默认:&
solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。我们先看如何通过tomcat配置http授权限制。第一步：在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java 多线程
public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
买房历程 cfyme
2015-06-21: 万科未来城，看房子 2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675 2015-06-27: 房子首付,签完合同 2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
[军事与科技]制造大型太空战舰的前奏 comsci 制造
天气热了........空调和电扇要准备好.......... 最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界.......... 所以,我们不得不关
dateformat dai_lm DateFormat
"Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
Hadoop如何实现关联计算 datamachine mapreduce hadoop 关联计算
选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。以关联计算为例。假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？ &nbs
用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。本博客列表涉及的文章内容支持定制化Google搜索，特别感谢 JeOam 提供并帮助更新。本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
js去除空格，去除左右两端的空格蕃薯耀去除左右两端的空格 js去掉所有空格 js去除空格
js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
SpringMVC4零配置--web.xml hanqunfeng springmvc4
servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架 UI
同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。故事1：巧借力，乌鸦也可以吃核桃有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
JQuery EasyUI 验证扩展可怜的猫 jquery easyui 验证
最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。以下内容只需要在公用js中添加即可。使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
1.前言. 如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
Jquery性能优化 r361251 JavaScript jquery
一、注意定义jQuery变量的时候添加var关键字这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的二、请使用一个var来定义变量如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
在eclipse项目中使用maven管理依赖 tjj006 eclipse maven
概览: 如何导入maven项目至eclipse中建立自有Maven Java类库服务器建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就把
中国天气网省市级联页面 x125858805 级联
1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l