verilog学习笔记——

1. 三元条件运算符Conditional ternary operator

module top_module (
    input [7:0] a, b, c, d,
    output [7:0] min);//

    // assign intermediate_result1 = compare? true: false;
    wire [7:0] w1,w2;
    assign w1= (a>b)?b:a;
    assign w2= (c>d)?d:c;
    assign min=(w1>w2)?w2:w1; 

endmodule

 2. Reduction operation 减排运算符_

module top_module (
    input [7:0] in,
    output parity); 
    
    assign parity = ^in;

endmodule

module top_module( 
    input [99:0] in,
    output out_and,
    output out_or,
    output out_xor 
);
    assign out_and = ∈
    assign out_or = |in;
    assign out_xor = ^in;

endmodule

 3. for 循环

 

module top_module( 
    input [99:0] in,
    output [99:0] out
);
    //方法一：采用for循环，循环次数为定值
    integer n;
    always@(*)
        begin
            for(n=99;n>=0;n--)
                out[n]=in[99-n];
        end

endmodule

module top_module( 
    input [99:0] in,
    output [99:0] out
);
    //方法二：采用 $bits（）函数，返回信号宽度，这个作为for循环的次数
    always@(*)
        begin
            for(int n=0;n<$bits(out);n++)
                out[n]=in[$bits(out)-n-1];
        end

endmodule

module top_module( 
    input [254:0] in,
    output [7:0] out );
    
    integer n;
    always@(*)
        begin
            out=8'b0;  //不要忘记给 Out赋初值
            for(n=0;n<=254;n++)
                out=out+in[n];
        end
endmodule

module top_module( 
    input [99:0] a, b,
    input cin,
    output [99:0] cout,
    output [99:0] sum );
    
    //方法一：子模块不用实例化
    integer i;
    assign {cout[0],sum[0]}=a[0]+b[0]+cin;
    always@(*)
        begin
            for(i=1;i<100;i++)
                     {cout[i],sum[i]}=a[i]+b[i]+cout[i-1];
        end
endmodule

 

module top_module( 
    input [99:0] a, b,
    input cin,
    output [99:0] cout,
    output [99:0] sum );
    
    //方法二：将一位加法器add1子模块实例化
    add1 u_0(.a(a[0]),.b(b[0]),.cin(cin),.cout(cout[0]),.sum(sum[0]));
    generate   //通过generate循环，可以产生一个对象（比如一个元件或者是一个模块）的多次例化
         genvar i;   //用在generate的循环中的标尺变量必须定义为gnevar类型;不可以是reg型，integer型；
            for(i=1;i<100;i++)
                begin:BLOCK1    //for循环之后的的begin最好加上一个标号（BLOCK1）；
                add1 u_i(.a(a[i]),.b(b[i]),.cin(cout[i-1]),.cout(cout[i]),.sum(sum[i]));
                end
    endgenerate
endmodule

// 对子模块在外面进行实例化
module add1(input a, input b, input cin, output cout, output sum);
    assign {cout, sum} = a + b + cin;
endmodule

module top_module( 
    input [399:0] a, b,
    input cin,
    output cout,
    output [399:0] sum );
    
    //需要构建一个变量储存进位，因为原模块中的cout只有一位
    wire [400:0] middle;
   //先对初始的加法器模块进行计算 
    assign cout=middle[400];
   // 实例化模块赋初值
    bcd_fadd U_0(.a(a[3:0]),.b(b[3:0]),.cin(cin),.cout(middle[4]),.sum(sum[3:0]));
    // 采用generate循环语句多次实例化模块
    generate
        genvar i;
        for(i=4;i<400;i=i+4)
            begin:add4
                bcd_fadd U_i(.a(a[i+3:i]),.b(b[i+3:i]),.cin(middle[i]),.cout(middle[i+4]),.sum(sum[i+3:i]));
            end
    endgenerate

endmodule

小结：  generate循环语句，可以产生一个对象（元件或模块）的多次实例化

1. 固定结构   generate……endgenerate

generate
//generate...loop循环语句
 
//generate...case分支语句
 
//generate...conditional条件语句
 
//嵌套的generate语句
endgenerate

2. generate循环语句

//generate循环语句被用于(verilog编译)细化阶段的语句复制
//允许对结构元素编写一个for循环
//for循环中使用的循环变量gv_i被称为genvar变量，这种变量必须用genvar来声明，
//并且只能在generate循环语句中使用；
//generate块需要标签，用来表示循环的实例化名称



generate
     for
         begin:block1
         ......
         end
endgenerate

3. generate 条件结构

// generate条件语句允许在细化期间对语句进行条件选择
// condition必须是一个静态的条件，即在细化期间计算的出
// statements可以是任何能够在模块中出现的语句
// 注意，由于条件的值可能取决于从上层模块中传递过来的参数，因此条件的值可能不能再细化期间被完全算出来。

generate
   if(condition)
      statements
    else
      statements
endgenerate

 4. generate分支结构

//generate分支语句与条件语句类似，只不过分支语句是用分支来进行条件选择

generate
     case()
        case1: ......;
        case2: ......;
        default: ......;
endgenerate