Registro de aprendizaje HDLBits-Verilog|Vectores de lenguaje Verilog

11.vectores | vector0

práctica:Construya un circuito que tenga una entrada de 3 bits, luego genere el mismo vector y también lo divida en tres salidas separadas de 1 bit. Conecte la salida o0 a la posición 0 del vector de entrada, o1 a la posición 1, etc.

En un diagrama, una marca con un número al lado indica el ancho del vector (o "bus"), en lugar de dibujar una línea separada para cada bit del vector.

module top_module ( 
    input wire [2:0] vec,
    output wire [2:0] outv,
    output wire o2,
    output wire o1,
    output wire o0  ); // Module body starts after module declaration

    assign o0 = vec[0];
    assign o1 = vec[1];
    assign o2 = vec[2];
    assign outv = vec;
endmodule

De hecho, se puede encontrar que siempre que tenga la base del lenguaje C u otros lenguajes informáticos, no es difícil comenzar con las preguntas de Vetilog. Ejecútelo y funcionó.

12.vectores con más detalle | vector1

práctica:Construya un circuito combinacional que divida una media palabra de entrada (16 bits, [15:0] ) en bytes inferiores [7:0] y superiores [15:8].

`default_nettype none     // Disable implicit nets. Reduces some types of bugs.
module top_module( 
    input wire [15:0] in,
    output wire [7:0] out_hi,
    output wire [7:0] out_lo );

    assign out_hi[7:0] = in[15:8];
    assign out_lo[7:0] = in[7:0];
endmodule

13.Selección de parte vectorial | Vector2

práctica;Se ​​puede considerar que un vector de 32 bits contiene 4 bytes (bits [31:24], [23:16], etc.). Construya un circuito que invierta el orden de los bytes de la palabra de 4 bytes.

AaaaaaaBbbbbbbbbCccccccDdddddddd => DddddddddCccccccBbbbbbbbbAaaaaaa

module top_module( 
    input [31:0] in,
    output [31:0] out );//

    // assign out[31:24] = ...;
    assign out[31:24] = in[7:0];
    assign out[23:16] = in[15:8];
    assign out[15:8] = in[23:16];
    assign out[7:0] = in[31:24];
endmodule

14.Operadores bit a bit | Puertas vectoriales

Construya un circuito que tenga dos entradas de 3 bits que calcule el OR bit a bit de los dos vectores, el OR lógico de los dos vectores y el inverso (NO) de ambos vectores. Coloque la inversa de b en la mitad superior de out_not (es decir, bits [5:3]) y la inversa de a en la mitad inferior.

module top_module(
    input [2:0] a,
    input [2:0] b,
    output [2:0] out_or_bitwise,
    output out_or_logical,
    output [5:0] out_not
);
	assign out_or_bitwise = a | b;
    assign out_or_logical = a || b;
    assign out_not[5:3] = ~b;
    assign out_not[2:0] = ~a;

endmodule 

15.Puertas de cuatro entradas | Puertas4

Práctica:
Construya un circuito combinacional con cuatro entradas, en [3:0].

Hay 3 salidas:

out_and: salida de una puerta AND de 4 entradas.
out_or: salida de una puerta OR de 4 entradas.
out_xor: salida de una puerta XOR de 4 entradas.

module top_module(
    input [3:0] in,
    output out_and,
    output out_or,
    output out_xor
);
    assign out_and = in[3] & in[2] & in[1] & in[0];
    assign out_or  = in[3] | in[2] | in[1] | in[0];
    assign out_xor = in[3] ^ in[2] ^ in[1] ^ in[0];

endmodule 

Nota: El código se puede simplificar a

assign out_and = & in;
assign out_or  = | in;
assign out_xor = ^ in; 

16.Operador de concatenación de vectores | Vector3

práctica:
Dados varios vectores de entrada, concatenarlos y luego dividirlos en varios vectores de salida. Hay seis vectores de entrada de 5 bits: a, b, c, d, e y f, para un total de 30 bits de entrada. Hay cuatro vectores de salida de 8 bits: w, x, y y z, para 32 bits de salida. La salida debe ser una concatenación de los vectores de entrada seguida de dos bits 1:

module top_module (
    input [4:0] a, b, c, d, e, f,
    output [7:0] w, x, y, z );
    assign {
    
    w,x,y,z} = {
    
    a,b,c,d,e,f,2'b11};
endmodule

17.Inversión de vectores 1 | Vector

práctica：Dado un vector de entrada de 8 bits [7:0], invierta su orden de bits.

module top_module(
    input [7:0] in,
    output [7:0] out
);
	assign out = {
    
    in[0],in[1],in[2],in[3],in[4],in[5],in[6],in[7]};

endmodule 

18. Operador de replicación | Vector4

práctica：Construya un circuito que extienda con signo un número de 8 bits a 32 bits. Esto requiere una concatenación de 24 copias del bit de signo (es decir, replicar el bit[7] 24 veces) seguidas del propio número de 8 bits.

module top_module (
    input [7:0] in,
    output [31:0] out );

    assign out = {
    
    {
    
    24{
    
    in[7]}},in};

endmodule 

Nota: 1. Preste mucha atención al uso de llaves aquí. El múltiplo y la parte posterior deben formar un todo. Al principio, agregue un corchete menos. Me tomó mucho tiempo encontrar el error. Más tarde, lo descubrí. que hubo un mensaje para el error.

19.Más replicación | Vector5

práctica:

Como muestra el diagrama, esto se puede hacer más fácilmente utilizando los operadores de replicación y concatenación.

El vector superior es una concatenación de 5 repeticiones de cada entrada.
El vector inferior es 5 repeticiones de una concatenación de las 5 entradas.

module top_module (
    input a, b, c, d, e,
    output [24:0] out );

    assign out = ~{
    
    {
    
    5{
    
    a}},{
    
    5{
    
    b}},{
    
    5{
    
    c}},{
    
    5{
    
    d}},{
    
    5{
    
    e}}} ^ {
    
    5{
    
    a,b,c,d,e}};

endmodule 

Nota: 1. También se requieren aparatos ortopédicos