数字典型电路知识结构地图，请大家参考，也希望积极补充！

1339650739

好文章，准本慢慢的跟着一个一个的学习了解一下！谢谢楼主更新！！

allen820

加油，赞楼主

zqq624723237

这个是准备成书吗？

rosshardware

如果大家喜欢，可以考虑，不过目前先计划把内容补充完，看看大家的反馈。希望大家能够积极补充和提问交流。目前主要考虑作为知识宣传，如果大家觉得以这样方式讲解RTL电路设计和Verilog语言比较好，后续再考虑是否出书推广。如果大家觉得不好，那就当作技术交流了。最近有点忙，更新有点慢哈，请大家稍微耐心等待一下：）

1339650739

回复 4# rosshardware

这个无符号加法在实现功能的时候，没有考虑a和b的那个数据位宽大，在进行功能实现的时候是不是应该考虑进去？不能直接默认a比较大把？

rosshardware

回复 25# 1339650739

是要考虑进去，在我写的Demo 代码里面是考虑了的哈，参考第4行，当然实现的代码，是可以优化，作为兼容A和B任意的位宽为最大的情况，我更新一下,参见第12行：

和C_WIDTH是根据A和B的位宽比较后决定的，如果A > B，则是A_WIDTH+1，否则就是B_WIDTH+1

1    localparam A_WIDTH = 16;
2    localparam B_WIDTH = 8;
3  // Sumation result width should be 1 bit more than biggest widht of adder factor
4    localparam C_WIDTH = if (A_WIDTH > B_WIDTH) ? A_WIDTH + 1'b1 : B_WIDTH + 1'b1;
5
6   reg [A_WIDTH-1  : 0]      a;
7   reg [B_WIDTH-1  : 0]      b;
8   
9    reg [C_WIDTH-1  : 0]      c;
10
11    always @(*) begin
12          c = {{(C_WIDTH-A_WIDTH){1'b0}},a} +
                   {{C_WIDTH-B_WIDTH{1'b0}},b};
13    end

rosshardware

今天来讲讲有符号数的加法，从无符号的加法章节就提及过，只要加数有一方为有符号数，则和一定是有符号数，重点强调一下，大家千万不要从场景上分析，认为C = A+B一定是>0，则及时A和B有一个是有符号数，那么和就是无符号数，我们只能从电路结构上决定C是无符号，还是有符号，原因是，大家场景分析，往往只是从正常功能场景分析，而忽略了异常场景。 比如
A[1:0]：作为无符号数
  2     |        .                    .
  1     |   .         .          .
  0  —|.——————.————————
         |0 1   2   3   4    5   6

B[1:0]：作为有符号数
  2     |                             
  1     |.                       .
  0  —|——.————.————————
-1    |             .
         0     1     2    3    4

C正常为：正常场景，C被当做无符号数，没有问题，与有符号数值一样。

  2     |                             
  1     |.    .      .     .     .
  0  —|——————————————
-1    |            
         0     1     2    3    4


异常场景，或者说未来B[1:0]信号相位和幅度发生了变化
B[1:0]：作为有符号数
  2     |                             
  1     |            .                  
  0  —|——.————.————————
-1     |.                       .
         0     1     2    3    4

C[2:0]：作为有符号数(-4~3)波形
  3     |            .
  2     |                             
  1     |     .             .               
  0  —|——————————————
-1     |.                        .
         0     1     2    3    4

C[2:0]：作为无符号数(0~8)波形, 0,1 两个坐标点，3,4两个坐标点，就存在很大幅度跳变
  7     |.                         .
  6     |
  5     |
  4     |
  3     |            .
  2     |                             
  1     |     .             .               
  0  —|——————————————
-1     |                       
         0     1     2    3    4


所以C应该按照有符号处理，即便，从算法角度，希望C后续按照无符号进行后续计算处理，
也应该是做一个C的有符号到无符号转换，专访方式其实很简单就是，把C最高位取反，上面的里面即

C_UNSIGN = {~C[2]，C[1:0]}

这样异常场景，C_UNSIGN的波形为,这样，只是增加直流分量，其幅度仍然没有变化：

7      |            .                        
  6     |
  5     |     .            .
  4     |
  3     |.                        .
  2     |                             
  1     |                              
  0  —|——————————————
-1    |                       
         0     1     2    3    4

rosshardware

上面小节，主要跟大家强调，进行有符号运算，其和一定是有符号的，按照电路结构进行设计，如果根据场景需要把和作为无符号数使用，需要单独进行有符号到无符号转换，这个是电路结构的转换，不是简单定一个$signed去转换类型。有符号加法的Verilog实现形式，推荐两种方式：

方式一：传统方式，手动扩位，实现左右位宽匹配，扩位为符号位，另外信号输入有符号数，一定要显示定义，Verilog默认不定义就是无符号类型

1    localparam A_WIDTH = 16;
2    localparam B_WIDTH = 8;
3  // Sumation result width should be 1 bit more than biggest widht of adder factor
4    localparam C_WIDTH = if (A_WIDTH > B_WIDTH) ? A_WIDTH + 1'b1 : B_WIDTH + 1'b1;
5
6   reg signed [A_WIDTH-1  : 0]      a;
7   reg signed [B_WIDTH-1  : 0]      b;
8   
9    reg signed [C_WIDTH-1  : 0]      c;
10  reg unsigned [C_WIDTH-1  : 0]      c_unsigned;
11
12   always @(*) begin
13         c = {(C_WIDTH-A_WIDTH){a[A_WIDTH-1]}},a} +
                    {{C_WIDTH-B_WIDTH{b[B_WIDITH-1]}},b};
14    end
15
16   always @（*） begin
17         c_unsigned = {~c[C_WIDTH-1],c[C_WIDTH-2:0]};
18   end   
方式二： Synopsys推荐，直接定义好符号类型，和的位宽按照运算法则定义好，实际+地方不作位宽匹配，工具自动识别
1    localparam A_WIDTH = 16;
2    localparam B_WIDTH = 8;
3  // Sumation result width should be 1 bit more than biggest widht of adder factor
4    localparam C_WIDTH = if (A_WIDTH > B_WIDTH) ? A_WIDTH + 1'b1 : B_WIDTH + 1'b1;
5
6   reg signed [A_WIDTH-1  : 0]      a;
7   reg signed [B_WIDTH-1  : 0]      b;
8   
9    reg signed [C_WIDTH-1  : 0]      c;
10  reg unsigned [C_WIDTH-1  : 0]      c_unsigned;
11
12   always @(*) begin
13         c = a + b;
14    end
15
16   always @（*） begin
17         c_unsigned = {~c[C_WIDTH-1],c[C_WIDTH-2:0]};
18   end   

另种方式，综合效果是一样，个人还是推荐方式一，虽然写代码时间多花一点，但是整个代码更干净整洁，后续工具检查的Warning少，便于从LOG中检查出真正位宽不匹配的点，否则有很多这种伪不匹配Warning，LOG查看会非常费劲。 另外，强调一点，代码的编写从来都不是我们集成电路设计真正的瓶颈，真正时间是用于场景分析，需要分析，数据流分析，电路实现。代码编写只是我们设计思路的映射，所以初学者切忌不要被一些语言工具厂商或者教科书忽悠，认为作集成电路就是写Verilog，花大量时间学习和记忆一些枯燥的语法，大家会从我给的Demo看到，RTL 设计实现用的Verilog 语法都非常简单。我们核心是作逻辑时序和电路实现。

rosshardware

忘了介绍有符号的比较器的实现，这里给补充一下，有符号比较，两边一定是有符号数，需要统一处理，上一节讲了有符号到无符号的转换，因此，我们可以通过把有符号数，转换成无符号数，然后进行无符号的比较，结果应该是一致的，当然，目前Synopsys的工具也非常先进，我们自动把数据定义为有符号数，在比较时候，加上系统函数$signed就可以自动实现有符号数的比较。Verilog Demo：

有符号比较器 Verilog写法一，（通过作有符号到无符号转换实现）：
        localparam   A_WIDTH;
        localparam   B_WIDTH;
        
        reg signed [A_WIDTH-1:0]  a;  // Default declaration type is unsigned
        reg signed [B_WIDTH-1:0]  b;  // Default declaration type is unsigned
     
        reg                          c;
       // A_WIDTH is bigger than B_WIDTH
       always @(*) begin
             if ((~a[A_WIDTH-1],a[A_WIDTH-2:0]} > {~b[B_WIDTH-1],b[B_WIDTH-2:0]}) begin
                   c = 1'b1;
             end
             else begin
                  c = 1'b0;
             end
       end

sysnopsys 推荐写法：
       localparam   A_WIDTH;
        localparam   B_WIDTH;
        
        reg signed [A_WIDTH-1:0]  a;  // Default declaration type is unsigned
        reg signed [B_WIDTH-1:0]  b;  // Default declaration type is unsigned
     
        reg                          c;
       // A_WIDTH is bigger than B_WIDTH
       always @(*) begin
             if ($signed(a) > $signed(b)) begin
                   c = 1'b1;
             end
             else begin
                  c = 1'b0;
             end
       end

rosshardware

下面在聊聊有符号减法，从电路结构上讲，只要涉及到减法，理论上其得到的结果就是应该是一个有符号数，所以大家按照这个原则进行设计就行，如果需要对结果作转换，进行有符号到无符号转换即可，Verilog代码也推荐两种风格：
方式一：传统方式，手动扩位，实现左右位宽匹配，扩位为符号位，另外信号输入有符号数，一定要显示定义，Verilog默认不定义就是无符号类型

1    localparam A_WIDTH = 16;
2    localparam B_WIDTH = 8;
3  // Sumation result width should be 1 bit more than biggest widht of adder factor
4    localparam C_WIDTH = if (A_WIDTH > B_WIDTH) ? A_WIDTH + 1'b1 : B_WIDTH + 1'b1;
5
6   reg signed [A_WIDTH-1  : 0]      a;
7   reg signed [B_WIDTH-1  : 0]      b;
8   
9    reg signed [C_WIDTH-1  : 0]      c;
10  reg unsigned [C_WIDTH-1  : 0]      c_unsigned;
11
12   always @(*) begin
13         c = {(C_WIDTH-A_WIDTH){a[A_WIDTH-1]}},a} -
                     {{C_WIDTH-B_WIDTH{b[B_WIDITH-1]}},b};
14    end
15
16   always @（*） begin
17         c_unsigned = {~c[C_WIDTH-1],c[C_WIDTH-2:0]};
18   end   
方式二： Synopsys推荐，直接定义好符号类型，和的位宽按照运算法则定义好，实际+地方不作位宽匹配，工具自动识别
1    localparam A_WIDTH = 16;
2    localparam B_WIDTH = 8;
3  // Sumation result width should be 1 bit more than biggest widht of adder factor
4    localparam C_WIDTH = if (A_WIDTH > B_WIDTH) ? A_WIDTH + 1'b1 : B_WIDTH + 1'b1;
5
6   reg signed [A_WIDTH-1  : 0]      a;
7   reg signed [B_WIDTH-1  : 0]      b;
8   
9    reg signed [C_WIDTH-1  : 0]      c;
10  reg unsigned [C_WIDTH-1  : 0]      c_unsigned;
11
12   always @(*) begin
13         c = $signed(a) - $signed(b);
14    end
16   always @（*） begin
17         c_unsigned = {~c[C_WIDTH-1],c[C_WIDTH-2:0]};
18   end