基本逻辑：
and a&b 与 同为1时输出1
or a|b 或 有一个为1输出1
xor a^b 异或 ab不同时输出1
nand !(a&b) 与非 not and a与b再取反
nor ~(a|b) 或非 a或b再取反
xnor a~^b 同或 ab相同时输出1
anotb a&(!b) a与非b and not
假如有多个元件，并且使用的是多重逻辑判断，那就要注意运算的先后顺序：
比如有四个输入abcd，那么接4-1与非门时，就要先对四个输入做与，然后整体的结果再非。从上面的元件图中也可以直观地理解这个过程。
verilog语言和c语言的编写逻辑比较接近，但在核心思想上有些区别：在不使用代码块的情况下，verilog代码描述的是模块内部的关系，并不是对运算过程的描述。这就意味着，代码顺序无关紧要，爱写什么顺序就写什么顺序。如果需要代码有顺序应该怎么办呢？用always initial这样的代码块，代码块内部代码有顺序关系。
向量的位拓展：
用数字进行拓展的时候，必须写清楚位宽。比如{5{1'b1}}是合法的，{5{1}}就不行。
注意！仔细看，定义里的形参就和C语言一样，中间是逗号，不是分号！为了避免误会，可以写成C的形式避免写错。
以下是一个一位全加器的例子，可以直接拿来使用：
module add1(
input a,b, <--------是逗号，不是分号
input cin,
output sum,cout);
assign sum=a^b^cin;
assign cout=(a&b)|(a&cin)|(b&cin);
endmodule
从代码里可以看到，一个一位全加器有a b两个输入变量和cin进位变量，输出则是cout，指示是否需要进位，sum决定当前位；
因为sum实际上只决定当前位，所以可以采用三个输入异或，三个变量里有奇数个1，sum为1，反之为0.
cout则是进位，只要有至少两个输入为1，cout就是1，所以用三种情况或运算。
减法器的设计和加法器其实一样，只是在b的输入上增加了一个xor异或门，以及一位的符号变量sub。
这里我一开始遗漏了一处，和加法器不一样，第一个add16的cin输出是sub，不是0.
sub是0的时候，同普通的32位加法器，sub是1的时候，第一个加法器需要考虑sub作为cin也要一并加上，此外b的每一位都与1进行了异或。异或是指不一样为1，反之为0.
正确的代码：
module top_module(
input [31:0] a,
input [31:0] b,
input sub,
output [31:0] sum
);
//module add16 ( input[15:0] a, input[15:0] b, input cin, output[15:0] sum, output cout );
wire [31:0] real_b;
wire in_out;
assign real_b= b^{32{sub}};
add16 test1(.a(a[15:0]), .b(real_b[15:0]), .cin(sub), .cout(in_out), .sum(sum[15:0]));
add16 test2(.a(a[31:16]), .b(real_b[31:16]), .cin(in_out), .cout(), .sum(sum[31:16]));
endmodule
我在一开始尝试时，尝试了很多次，加法部分正常，减法部分一直有问题。查阅资料后才发现,问题出在real_b这一行，real_b是b和sub的异或，但是我一开始用的是b^sub，这种用法有问题.题目里也提到了类似的内容。
- a异或{16{b}}是将b复制16次，然后与a进行按位异或运算，输出结果是一个16位的向量。例如，如果a是16’h1234，b是1’b1，那么a异或{16{b}}的结果是16’hEDCB。
- a异或b是将b扩展为16位，然后与a进行按位异或运算，输出结果也是一个16位的向量。但是，b的扩展方式取决于b的类型，如果b是无符号的，那么b会在高位补零；如果b是有符号的，那么b会在高位补符号位。例如，如果a是16’h1234，b是1’b1，那么a异或b的结果是16’h1235（无符号扩展）或者16’h9235（有符号扩展）
三种赋值：
assign 连续赋值 右侧的值改变后，左侧立刻更新
x=y 阻塞赋值，只在initial和always里使用，这一句执行后，右边的表达式立刻赋值给左侧，然后执行下一句
x<=y 非阻塞赋值 ，只在initial和always里使用 直到当前块全部执行完，才统一更新左侧变量
组合逻辑： @(*) *表示敏感列表自动维护 一般配合阻塞赋值
时序逻辑: @(posedge clock) 上升沿为敏感列表 @(clock) 任意时钟变化为敏感列表 clock是变量 一般配合非阻塞赋值
因为非阻塞赋值在条件达成后才更新，这样可以确保时序相关的逻辑不会乱掉
注意：在同一个always块里，不要混用阻塞与非阻塞赋值。（但是实际使用了混用也能通过编译，代码的执行顺序可能会变乱。但一定不要给一个变量同时混用两种赋值方式）
三种赋值的区别：
module top_module(
input clk,
input a,
input b,
output wire out_assign,
output reg out_always_comb,
output reg out_always_ff );
assign out_assign=a^b;
always @(*) out_always_comb=a^b;
always @(posedge clk) out_always_ff <=a^b; //这里用的是上升沿触发,所以实际电路里会慢一点赋值
endmodule
//省略了always语句本来该有的begin和end
利用生成语句把1位全加器拼接出100位全加器：
module top_module(
input [99:0] a, b,
input cin,
output [99:0] cout,
output [99:0] sum );
genvar i; // 定义一个循环变量i
generate
for (i = 0; i < 100; i = i + 1) begin: ripple // 给begin...end块起一个名字ripple
if (i == 0) // 如果是第一个全加器，cin就是模块的输入cin
add1 adder0 (.a(a[0]), .b(b[0]), .cin(cin), .cout(cout[0]), .sum(sum[0]));
else // 如果不是第一个全加器，cin就是上一个全加器的cout
add1 adder1 (.a(a[i]), .b(b[i]), .cin(cout[i-1]), .cout(cout[i]), .sum(sum[i]));
end
endgenerate
endmodule
// 1位全加器的定义
module add1(
input a,b,
input cin,
output sum,cout);
assign sum=a^b^cin;
assign cout=(a&b)|(a&cin)|(b&cin);
endmodule
利用生成语句生成100位BCD码的行波加法器：
单行加法器的定义：
module bcd_fadd (
input [3:0] a,
input [3:0] b,
input cin,
output cout,
output [3:0] sum );
完整加法器：
module top_module(
input [399:0] a, b,
input cin,
output cout,
output [399:0] sum );
wire [99:0]c;
genvar i; // 定义一个循环变量i
generate
for (i = 0; i < 100; i = i + 1) begin: ripple // 给begin...end块起一个名字ripple
if (i == 0) // 第一个全加器
bcd_fadd adder0 (.a(a[3:0]), .b(b[3:0]), .cin(cin), .cout(c[0]), .sum(sum[3:0]));
else // 如果不是第一个全加器，cin就是上一个全加器的cout
bcd_fadd adder1 (.a(a[4*i+3:4*i]), .b(b[4*i+3:4*i]), .cin(c[i-1]), .cout(c[i]), .sum(sum[4*i+3:4*i]));
end
endgenerate
assign cout=c[99];
endmodule
值得注意的是，BCD码是用4个二进制来表示一个10进制数，所以他本质上还是十进制数，在加法器内，输入a、b和输出sum都是400位长。但是cout只需要1位。此外，每次输入的是4位，不是1位。
为了方便内部计算，增加了一个wire 变量c，用来存储中间的cout变量。记得最后把c[99]赋值给cout，这才是需要的cout输出。
---------------------
补码加法器：
补码加法器
-----------
一个奇葩卡诺图：
module top_module(
input a,
input b,
input c,
input d,
output out );
assign out=(a^b)&(c~^d) | (a~^b)&(c^d); //其实只需要这一句
endmodule
---------------------
时序逻辑：
d触发器：只能在时序逻辑里赋值，每次达到条件时，d触发器的q更新值。
8位版的d触发器，单位的d触发器只需要1位。
上升沿:posedge 下降沿 negedge
module top_module (
input clk,
input [7:0] d,
output [7:0] q
);
always @(posedge clk)begin
q<=d;
end
endmodule
假如现在又多了一个reset信号，这两种代码会产生什么区别：
//代码1
always @(posedge clk or posedge reset)begin
if(reset) q<=8'b00110100;
else q<=d;
end
//代码2
always @(posedge clk)begin
if(reset) q<=8'b00110100;
else q<=d;
end
代码1中，reset信号直接连到复位端，只要reset有信号，不需要和时钟同步就可以改变信号，这是异步复位。
代码2中，reset信号产生后，要延迟一个时刻等到时钟触发有效，才会改变输出q，这是同步复位，因为它和d作为组合逻辑一块送入。当然，缺点就是需要额外的一个周期才能复位。
-----------
latch 即锁存器
特点：它是电平敏感。也就是说不依赖边沿，always里用电平敏感列表
但是它仍存在时序，所以赋值要用非阻塞赋值 <=
效果：禁用时锁住当前值
D型锁存器，ena有效时，Q可变，否则Q锁定
但是锁存器不基于时钟信号，所以可以用assign直接定义：
module top_module (
input d,
input ena,
output q);
assign q = ena ? d : q;
endmodule
不是时序逻辑的部分就不要写在时序逻辑内
如图所示，一个包含两个复用器和d触发器的子模块：
module top_module (
input clk,
input w, R, E, L,
output Q
);
reg l1;
always @(*) begin
l1=E?w:Q;
end
always @(posedge clk)begin
if(L==0) Q<=l1;
else Q<=R;
end
endmodule
不是时序逻辑部分的定义就不要写在时序逻辑内。以上面这段代码为例，在输入d触发器前的这一段，需要用组合逻辑而不是时序逻辑，不要图方便把二者都写到时序逻辑里。
------------------
利用时序逻辑检测信号的上升沿和下降沿：
module top_module (
input clk,
input [7:0] in,
output [7:0] anyedge
);
reg [7:0]prev;
always @(posedge clk)begin
anyedge <= (in & ~prev)| (~in & prev);
prev <= in;
end
endmodule
下降沿捕获：Edgecapture - HDLBits (01xz.net)
捕获是指输出收到输入信号的下降沿后一直为0，直到被reset复位
module top_module (
input clk,
input reset,
input [31:0] in,
output [31:0] out
);
reg [31:0] out_reg;
reg [31:0] prev_in;
always @(posedge clk) begin
if (reset) begin
out_reg <= 32'b0;
prev_in <= in; // 复位时记录当前输入值
end
else begin
prev_in <= in;
out_reg <= out_reg | (prev_in & ~in); // 捕获下降沿
end
end
assign out=out_reg;
endmodule
//捕获下降沿并一直保存，除非reseet开着，reset关了以后，要继续保存值
verilog不支持同时在条件里写一个信号的上升沿和下降沿，也不支持在多个代码块里修改一个变量的值。这两点要注意。
posedge clk or negedge clk是非法写法。
双边检测器：输入信号有上升沿和下降沿都起效，但是说实话，我自己都不清楚为什么这么写就对了。
module top_module (
input clk,
input d,
output q
);
reg q_pos,q_neg;
/* always @(clk) begin
delay1<=d;
end*/
//assign q=delay1;
always @(posedge clk)begin
q_pos<=d;
end
always @(negedge clk)begin
q_neg<=d;
end
assign q=clk?q_pos:q_neg;
endmodule
Countbcd - HDLBits (01xz.net) 用bcd计数器做一个1000分频器，做了半天死活做不对
一开始我的错误想法：
module cacu1 (
input clk,
input reset,
input enable,
output ena,// Synchronous active-high reset
output [3:0] q);
always @(posedge clk)begin
if(reset) q<=0;
else if(enable)begin
if(q==4'b1001)begin
ena<=1;
q<=0;
end
else if(q<4'b1001) begin
ena<=0;
q<=q+4'b0001;
end
end
end
endmodule
module top_module (
input clk,
input reset, // Synchronous active-high reset
output [3:1] ena,
output [15:0] q); //15:12 11:8 7:4 3:0
cacu1 test1(.clk(clk),.reset(reset),.enable(1),.q(q[3:0]),.ena(ena[1]));
cacu1 test2(.clk(clk),.reset(reset),.enable(ena[1]),.q(q[7:4]),.ena(ena[2]));
cacu1 test3(.clk(clk),.reset(reset),.enable(ena[2]),.q(q[11:8]),.ena(ena[3]));
cacu1 test4(.clk(clk),.reset(reset),.enable(ena[3]),.q(q[15:12]),.ena());
endmodule
//这段代码是错的
这段代码有个严重问题，就是如果用ena来作为进位使能，那么要保证和题目要求一样，输出9时同步输出ena进位，那么在输出8时就要准备输出ena，那么判断条件就变成了8，而不是9.这样一来，个位的问题解决了，后面的却全是问题：用阻塞输出会导致ena不能输出，用非阻塞赋值又会导致乱序。
所以之后我换了个思路：
cacu1 test1(.clk(clk),.reset(reset),.enable(1),.q(q[3:0]),.ena());
cacu1 test2(.clk(clk),.reset(reset),.enable(ena[1]),.q(q[7:4]),.ena());
cacu1 test3(.clk(clk),.reset(reset),.enable(ena[2]),.q(q[11:8]),.ena());
cacu1 test4(.clk(clk),.reset(reset),.enable(ena[3]),.q(q[15:12]),.ena());
assign ena[1]=(q[3:0]==4'b1001)?1:0;
assign ena[2]=(q[7:4]==4'b1001 && ena[1])?1:0;
assign ena[3]=(q[11:8]==4'b1001 && ena[1] && ena[2])?1:0;
把ena的判断拆出来，直接用q的值来判断，bcd计数器内部的代码不管了。这样一来就不用再纠结进位的问题了。
需要注意的是，十位进位的条件是个位为9，百位进位的条件是十位和个位都要为9.。。以此类推。
-------------------------
时钟：用bcd计数器做一个12小时制的时钟：
module sixty(
input clk,
input reset,
input ena,
output [7:0] q);
always @(posedge clk)begin
if(reset) q<=8'b00000000;
else if(ena) begin
if(q[3:0]<4'b1001)begin
q[3:0]<=q[3:0]+4'b0001;
end
else begin //有进位
q[3:0]<=4'b0000;
if(q[7:4]<4'b0101)begin
q[7:4]<=q[7:4]+4'b0001;
end
else begin
q[7:4]<=4'b0000;
end
end
end
end
endmodule //分和秒用这个
module hou(
input clk,
input reset,
input ena,
output reg up,
output [7:0] q);
always @(posedge clk)begin
if(reset) q<=8'b00010010; //最大值12，所以处理会不一样
else if(ena) begin
if(q[7:4]==4'b001 && q[3:0]==4'b0010)begin
q[7:4]<=0;
q[3:0]<=4'b0001;
up<=1;
end
else if(q[7:4]==0 && q[3:0]<4'b1001)begin
q[3:0]<=q[3:0]+4'b0001;
up<=0;
end
else if(q[7:4]==0 && q[3:0]==4'b1001)begin
q[7:4]<=4'b0001;
q[3:0]<=0;
up<=0;
end
else if(q[7:4]==4'b0001 && q[3:0]<=4'b0001)begin
q[3:0]<=q[3:0]+4'b0001;
up<=0;
end
end
end
endmodule
module top_module(
input clk,
input reset,
input ena,
output pm,
output [7:0] hh,
output [7:0] mm,
output [7:0] ss);
wire sec2min,min2hou;
wire hour2pm;
sixty second(.clk(clk),.reset(reset),.ena(ena),.q(ss));
sixty minutes(.clk(clk),.reset(reset),.ena(sec2min),.q(mm));
hou hour(.clk(clk),.reset(reset),.ena(min2hou),.up(hour2pm),.q(hh)); //它的up也不能留下
assign sec2min=(ss==8'b01011001)?1:0;
assign min2hou=(mm==8'b01011001 && ss==8'b01011001)?1:0; //别忘了分针时针均为59才进位
always @(posedge clk) begin
if (hh==8'b00010001 && mm==8'b01011001 && ss==8'b01011001)
pm <= !pm;
end //不再造成组合逻辑环路
endmodule
在一开始，我遇到了一个问题，就是选择pm的值时，我用的是
//assign pm = (hh==8'b00010010 && mm==8'b01011001 && ss==8'b01011001)?(!pm):pm;
这条语句逻辑上没有问题，但电路设计上有明显问题：pm的值会依赖它的上一个值，导致在仿真过程中形成了逻辑环路，无限回环。
解决方法就是改成always 逻辑，或者用一个中间变量，避免环路的发生。
--------------------------
1-12计数器：Exams/ece241 2014 q7a - HDLBits (01xz.net)
这道题题干其实也很简单，给了一个4位的计数器子模块，外层再放一个总模块控制，每到12就重置。就是线接的比较奇怪。外层的Q和内层的Q连接，都是输出。c_enable三件套是输出，但是要接到内层的子模块上。enable可以让计数器正常工作，load则是强制让计数器的Q等于D。也就是说，外层在计数器值小于等于12时正常工作，等于12时，外层使能load信号，让计数器内部值重新变成c_d，即0001即可。
module top_module (
input clk,
input reset,
input enable,
output [3:0] Q,
output c_enable,
output c_load,
output [3:0] c_d
);
reg [3:0] temp;
//4-bit计数器的控制信号
assign c_enable = enable;
//带复位和置位，
assign c_load = reset | (Q == 4'd12 & enable == 1'b1);
assign c_d = 4'b1;
count4 counter1
(
.clk(clk),
.enable(c_enable),
.load(c_load),
.d(c_d),
.Q(Q)
);
endmodule
-------------------------------------
对于有限状态机：
状态转移的部分放在组合逻辑，外部的复位信号则放在时序逻辑。
根据要求的同步复位和异步复位不同，异步复位需要在时序逻辑的敏感条件里增加reset信号的上升沿，同步不需要。
一个异步复位状态机，上面的out表示在该状态下应该输出什么。
module top_module(
input clk,
input areset, // Asynchronous reset to state B
input in,
output out);//
parameter A=0, B=1;
reg state, next_state;
always @(*) begin // This is a combinational always block
// State transition logic
if(state==A)begin
if(in)begin
next_state=A;
end
else begin
next_state=B;
end
end
else begin
if(in)begin
next_state=B;
end
else begin
next_state=A;
end
end
end
always @(posedge clk, posedge areset) begin // This is a sequential always block
// State flip-flops with asynchronous reset //异步，立刻变
if(areset)
state=B;
else
state=next_state;
end
assign out=(state==A)?0:1; //根据提示，把out放在外面定义
// Output logic
// assign out = (state == ...);
endmodule
-----------------------------------
Exams/2014 q3fsm - HDLBits (01xz.net) 这一道题，说实话花了我很长时间
我一开始的思路：
module top_module (
input clk,
input reset, // Synchronous reset
input s,
input w,
output z
);
parameter a=1,b=2;
reg [1:0] state,next_state;
reg [1:0] count,index;
//int count,index;
always @(*)begin
if(state==a && s)
next_state=b;
else if(state==a &&s==0)
next_state=a;
end
always @(posedge clk)begin
if(reset)begin
state=a;
count=0;
index=0;
//z<=0;
end
else begin
state=next_state;
if(state==b)begin
index=index+1;
if(w==1) count=count+1;
end
if(index==2'b11)begin
count=0;
index=0;
end
// if(index==2'b11 && count==2'b10) z<=1;
//else z<=0; //写到里面延迟太大了 两个周期
end
end
assign z=(state==b&&count==2'b10)?1:0;
//assign z=((index==2'b10&&count==2'b01&&w)||(index==2'b10&&count==2'b10&&w==0))?1:0; //时长不对
endmodule
一开始的思路就是跟着题目给出的状态机走，只设置AB两个状态，然后在时序里计数，每次循环记到3就清零，在外面设置w为1的计数到2就输出1.但是这么设计，输出总是慢一个周期。
后来看到了别人的代码：
module top_module (
input clk,
input reset, // Synchronous reset
input s,
input w,
output z
);
parameter A = 0, B = 1, C = 2, D = 3;
reg [1:0] count;
reg [2:0] state, next_state;
always @ (*) begin
case (state)
A: next_state = s ? B : A;
B: next_state = C;
C: next_state = D;
D: next_state = B;
default: next_state = A;
endcase
end
always @ (posedge clk) begin
if (reset) state <= A;
else state <= next_state;
end
always @ (posedge clk) begin
case (state)
B: count <= w;
C: count <= w ? count + 1 : count;
D: begin
count <= w ? count + 1 : count;
// count <= 1'b0;
end
default: count <= 0;
endcase
end
assign z = ((state == B) && (count == 2));
endmodule
思路改变其实不大。开始我也想过用更多状态，但是当时在纠结后面输入0 1时需要几个状态。这里的代码则是很干脆地就分了 B C D三个状态，不管输入什么都向下一个状态转移。然后在时序逻辑里再分别计算加几个w。在最后的状态判断里，也不再使用循环数==3这样的条件，直接用state==B即可。我感觉这里可能是我的代码有问题的原因之一。
参考内容：
常见Verilog运算符（逻辑运算符、按位运算符、缩位运算符、迭代连接运算符、移位运算符）_verilog位运算符和逻辑运算符-CSDN博客
verilog语法2：assign、always/阻塞赋值与阻塞赋值 - 知乎 (zhihu.com)
标签：reset,语言,clk,always,HDLBits,module,verilog,output,input From： https://www.cnblogs.com/namezhyp/p/18046656