instruction stringlengths 149 5.37k | input stringclasses 1
value | output stringlengths 99 5.96k |
|---|---|---|
Please act as a professional verilog designer. alu : Implement an ALU for a 32-bit MIPS-ISA CPU. The “a” and “b” are the two operands of the ALU, the “aluc” is the opcode, and the “r” gives out the result. “zero” means if the result is zero, “carry” means if there is a carry bit, “negative” means if the result is negat... | `timescale 1ns / 1ps
module verified_alu(
input [31:0] a,
input [31:0] b,
input [5:0] aluc,
output [31:0] r,
output zero,
output carry,
output negative,
output overflow,
output flag
);
parameter ADD = 6'b100000;
parameter ADDU = 6'b100001;
parameter SUB = 6'b10... | |
Please act as a professional verilog designer. asyn_fifo : Implement an asynchronous FIFO, FIFO bit width and depth can be configured(parameter DEPTH = 16, parameter WIDTH = 8). The asynchronous FIFO structure is divided into several parts. The first part is dual-port RAM, which is used for data storage. Instantiate du... | `timescale 1ns/1ns
/***************************************RAM*****************************************/
module dual_port_RAM #(parameter DEPTH = 16, parameter WIDTH = 8)
(
input wclk ,
input wenc ,
input [$clog2(DEPTH)-1:0] waddr ,
input [WIDTH-1:0] wdata ,
input rclk ,
input renc ,
input [$clog2(DEPT... | |
Please act as a professional verilog designer. conwaylife : // The "game" is played on a two-dimensional grid of cells, where each cell is either 1 (alive) or 0 (dead). At each time step, each cell changes state depending on how many neighbours it has:
// (1) 0-1 neighbour: Cell becomes 0.
// (2) 2 neighbours: Cell sta... | // The "game" is played on a two-dimensional grid of cells, where each cell is either 1 (alive) or 0 (dead). At each time step, each cell changes state depending on how many neighbours it has:
// (1) 0-1 neighbour: Cell becomes 0.
// (2) 2 neighbours: Cell state does not change.
// (3) 3 neighbours: Cell becomes 1.
// ... | |
Please act as a professional verilog designer. FIFO_memory : In this project, Verilog code for FIFO memory is presented. The First-In-First-Out (FIFO) memory with the following specification is implemented in Verilog:
16 stages
8-bit data width
Status signals:
Full: high when FIFO is full else low.
Empty: high when F... | module fifo_mem(data_out,fifo_full, fifo_empty, fifo_threshold, fifo_overflow, fifo_underflow,clk, rst_n, wr, rd, data_in);
input wr, rd, clk, rst_n;
input[7:0] data_in; // FPGA projects using Verilog/ VHDL
output[7:0] data_out;
output fifo_full, fifo_empty, fifo_threshold, fifo_overflow, fifo_underflow... | |
Please act as a professional verilog designer. bcsadd100 : // You are provided with a BCD one-digit adder named bcd_fadd that adds
// two BCD digits and carry-in, and produces a sum and carry-out.
module bcd_fadd (
input [3:0] a,
input [3:0] b,
input cin,
output cout,
output [3:0] sum );
... | module bcd_fadd (
input [3:0] a,
input [3:0] b,
input cin,
output cout,
output [3:0] sum
);
wire [4:0] total;
assign total = a + b + cin;
// Check if the result exceeds valid BCD
assign sum = (total > 9) ? total + 6 : total; // Add 6 for correction if needed
assign cout ... | |
Please act as a professional verilog designer. dual_port_ram_asynchronous : // Dual-port asynchronous RAM.
module dual_port_ram_asynchronous_behavioral(
input clk_A, // Clock A
input clk_B, // Clock B
// PORT A
input we_A, ... | module dual_port_ram_asynchronous_behavioral
(clk_A, clk_B,
we_A, addr_A, data_in_A, data_out_A,
we_B, addr_B, data_in_B, data_out_B);
//===【1】先宣告參數 (Parameter) ===//
parameter DATA_WIDTH = 8;
parameter ADDR_WIDTH = 4;
parameter MEM_DEPTH = 16;
//===【2】宣告輸入/輸出埠 (Non-ANSI Style) ===... | |
Please act as a professional verilog designer. fifo_synchronous : // A synchronous fifo.
module fifo_synchronous_structural(
input clk, // Clock
input rst, // Reset
// PUSH
input [7:0] data_in, // DATA In
input push, // Push/Write enable
output full, ... | module fifo_synchronous_integrated(
input clk, // Clock
input rst, // Reset (假設同步 or 非同步視需求)
// PUSH
input [7:0] data_in, // DATA In
input push, // Push/Write enable
output full, // Full
// POP
output reg [7:0] ... | |
Please act as a professional verilog designer. bcdadd4 : // You are provided with a BCD (binary-coded decimal) one-digit adder named bcd_fadd that adds two BCD digits and carry-in, and produces a sum and carry-out.
module bcd_fadd (
input [3:0] a,
input [3:0] b,
input cin,
output cout,
output... | module bcd_fadd (
input [3:0] a,
input [3:0] b,
input cin,
output cout,
output [3:0] sum
);
wire [4:0] total;
assign total = a + b + cin;
assign sum = (total > 9) ? (total - 10) : total[3:0];
assign cout = (total > 9) ? 1'b1 : 1'b0;
endmodule
module top_module (
... | |
Please act as a professional verilog designer. module : // create one instance of module mod_a, then connect the module's three pins (in1, in2, and out)
// to your top-level module's three ports (wires a, b, and out).
//The module mod_a is provided for you — you must instantiate it.
//Hint: When connecting modules,... | module mod_a (
input in1,
input in2,
output out
);
// XNOR gate implementation
assign out = ~(in1 ^ in2);
endmodule
module top_module (
input a,
input b,
input c,
input d,
output out1,
output out2
);
// Instantiate mod_a for out1
mod_a u_mod_a1 (
... | |
Please act as a professional verilog designer. module_fadd : // you are given a module add16 that performs a 16-bit addition. You must instantiate two of them to create a 32-bit adder.
// One add16 module computes the lower 16 bits of the addition result,
// while the second add16 module computes the upper 16 bits of... | module add1 (
input a,
input b,
input cin,
output sum,
output cout
);
assign sum = a ^ b ^ cin;
assign cout = (a & b) | (a & cin) | (b & cin);
endmodule
module add16 (
input [15:0] a,
input [15:0] b,
input cin,
output [15:0] sum,
output cout
);
wire [15:0] c... | |
Please act as a professional verilog designer. 7458 : // The 7458 is a chip with four AND gates and two OR gates.
// Create a module with the same functionality as the 7458 chip.
// It has 10 inputs and 2 outputs. You may choose to use an assign statement
// to drive each of the output wires, or you may choose to d... | // The top Verilog module is a combinational logic module that takes in 8 inputs and produces 2 outputs. The first output, p1y, is the result of a logical AND operation on the first three inputs (p1a, p1b, and p1c) and a logical OR operation on the last three inputs (p1d, p1e, and p1f). The second output, p2y, is the ... | |
Please act as a professional verilog designer. alwaysblock2 : /* Build an XOR gate three ways, using an assign statement, a combinational always block, and a clocked always block. Note that the clocked always block produces a different circuit from the other two: There is a flip-flop so the output is delayed. */
modul... | // Build an XOR gate three ways, using an assign statement (output out_assign), a combinational always block (output out_always_comb), and a clocked always block (output out_always_ff). Note that the clocked always block produces a different circuit from the other two: There is a flip-flop so the output is delayed.
mo... | |
Please act as a professional verilog designer. always_if : /*
Build a 2-to-1 mux that chooses between a and b. Choose b if both sel_b1 and sel_b2 are true. Otherwise, choose a. Do the same twice, once using assign statements and once using a procedural if statement.
sel_b1 = 0 sel_b2 = 0 out_assign out_always = a,
se... | // Build a 2-to-1 mux that chooses between a and b. Choose b if both sel_b1 and sel_b2 are true. Otherwise, choose a. Do the same twice, once using assign statements and once using a procedural if statement.
module top_module (
input a,
input b,
input sel_b1,
input sel_b2,
output out_assign,
output reg out_alway... | |
Please act as a professional verilog designer. basic3 : // Design a 3-bit priority encoder. If none of the input bits are high (i.e., input is zero), output zero.
module priority_encoder(
input [2:0] in,
output reg [1:0] pos ); | // Design a 3-bit priority encoder. If none of the input bits are high (i.e., input is zero), output zero.
module priority_encoder(
input [2:0] in,
output reg [1:0] pos );
always @(*) begin
if (in[0]==1'b1)
pos = 0;
else if (in[1]==1'b1)
pos = 1;
else ... | |
Please act as a professional verilog designer. bugs_case : // This combinational circuit is supposed to recognize 8-bit keyboard scancodes for keys 0 through 9. It should indicate whether one of the 10 cases were recognized (valid), and if so, which key was detected. Fix the bug(s).
module top_module (
input [7:0]... | // This combinational circuit is supposed to recognize 8-bit keyboard scancodes for keys 0 through 9. It should indicate whether one of the 10 cases were recognized (valid), and if so, which key was detected. If the 8-bit input is 8'h45, 8'h16, 8'h1e, 8'h26, 8'h25, 8'h2e, 8'h36, 8'h3d, 8'h3e, or 8'h46, the 4-bit output... | |
Please act as a professional verilog designer. bugs_mux2 : // This 4-to-1 multiplexer doesn't work. Fix the bug(s).
// You are provided with a bug-free 2-to-1 multiplexer:
module mux2 (
input sel,
input [7:0] a,
input [7:0] b,
output [7:0] out
);
module top_module (
input [1:0] sel,
input [7:... | // Find the bug and fix this 8-bit wide 2-to-1 mux.
// module top_module (
// input sel,
// input [7:0] a,
// input [7:0] b,
// output out );
// assign out = (~sel & a) | (sel & b);
// endmodule
module top_module (
input sel,
input [7:0] a,
input [7:0] b,
output [7:0] o... | |
Please act as a professional verilog designer. decoder_3_8 : // Decoder - Three inputs decodes to 1 of 8 outputs (hot).
module decoder_3_8_behavioral(
input [2:0] in, // 3 Input
output reg [7:0] out); // 8 Outputs
// Insert your code here
endmodule | // Decoder - Three inputs decodes to 1 of 8 outputs (hot).
module decoder_3_8_behavioral(
input [2:0] in, // 3 Input
output reg [7:0] out); // 8 Outputs
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
always @ ( * ) begin
case (in)
3'b000 : out <=... | |
Please act as a professional verilog designer. demux_1x4 : // Demultiplexer - One input, four outputs.
module demux_1x4_behavioral(
input y, // 1 Input
input [1:0] sel, // Select
output reg a, b, c, d); // 4 Outputs
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSI... | // Demultiplexer - One input, four outputs.
module demux_1x4_behavioral(
input y, // 1 Input
input [1:0] sel, // Select
output reg a, b, c, d); // 4 Outputs
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
always @ ( * ) begin
case(sel)... | |
Please act as a professional verilog designer. encoder_8_3 : // Encoder - Eights inputs (1 hot) encodes to output.
module encoder_8_3_behavioral(
input [7:0] in, // 8 Inputs
output reg [2:0] out); // 3 Outputs
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
// Insert your code ... | // Encoder - Eights inputs (1 hot) encodes to output.
module encoder_8_3_behavioral(
input [7:0] in, // 8 Inputs
output reg [2:0] out); // 3 Outputs
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
always @ ( * ) begin
case(in)
8'b00000001 : out <= 3'b000;... | |
Please act as a professional verilog designer. gates100 : // Build a combinational circuit with 100 inputs, in[99:0].
// There are 3 outputs:
// out_and: output of a 100-input AND gate.
// out_or: output of a 100-input OR gate.
// out_xor: output of a 100-input XOR gate.
// Hint: The reduction operators will be usef... | // Build a combinational circuit with 100 inputs, in[99:0]. There are 3 outputs:
// (1) out_and: output of a 100-input AND gate.
// (2) out_or: output of a 100-input OR gate.
// (3) out_xor: output of a 100-input XOR gate.
module top_module (
input [99:0] in,
output out_and,
output out_or,
output out_xor
);
... | |
Please act as a professional verilog designer. gatesv : // You are given a four-bit input vector in[3:0].
//We want to know some relationships between each bit and its neighbour:
// out_both: Each bit of this output vector should indicate whether both the corresponding
//input bit and its neighbour to the left (high... | // You are given a four-bit input vector in[3:0]. We want to know some relationships between each bit and its neighbour:
// (1) out_both: Each bit of this output vector should indicate whether both the corresponding input bit and its neighbour to the left (higher index) are '1'. For example, out_both[2] should indicat... | |
Please act as a professional verilog designer. gatesv-2 : // You are given a four-bit input vector in[3:0]. We want to know some relationships between each bit and its neighbour:
// (1) out_both: Each bit of this output vector should indicate whether both the corresponding input bit and its neighbour to the left (high... | // You are given a four-bit input vector in[3:0]. We want to know some relationships between each bit and its neighbour:
// (1) out_both: Each bit of this output vector should indicate whether both the corresponding input bit and its neighbour to the left (higher index) are '1'. For example, out_both[2] should indicat... | |
Please act as a professional verilog designer. hadd : //Create a half adder. A half adder adds two bits (with no carry-in) and produces a sum and carry-out.
module top_module(
input a, b,
output cout, sum );
// Insert your code below
endmodule | // Create a half adder. A half adder adds two bits (with no carry-in) and produces a sum and carry-out.
module top_module (
input a,
input b,
output sum,
output cout
);
assign {cout, sum} = a+b;
endmodule | |
Please act as a professional verilog designer. intermediate1 : // Design a half adder. A half adder adds two bits and produces a sum and carry-out
module half_adder(
input a, b,
output cout, sum ); | // Design a half adder. A half adder adds two bits and produces a sum and carry-out
module half_adder(
input a, b,
output cout, sum );
assign sum = a^b;
assign cout = a&b;
endmodule | |
Please act as a professional verilog designer. jeff_74x151 : // 8-line to 1-line data selector/multiplexer.
// Based on the 7400-series integrated circuits used in my programable-8-bit-microprocessor.
module jeff_74x151_behavioral(
input d0, // DATA IN
input d1... | // 8-line to 1-line data selector/multiplexer.
// Based on the 7400-series integrated circuits used in my programable-8-bit-microprocessor.
module jeff_74x151_behavioral(
input d0, // DATA IN
input d1, //
input d2, ... | |
Please act as a professional verilog designer. m2014_q4a : // Implement a D latch using an always block.
module top_module (
input d,
input ena,
output logic q
); |
// Implement a D latch using an always block.
module top_module (
input wire d,
input wire ena,
output reg q
);
// Combinational logic to assign q based on ena and d
always @(*) begin
if (ena)
q = d;
// If ena is low, q retains its previous value (implies a latch)
... | |
Please act as a professional verilog designer. mt2015_eq2 : //Create a circuit that has two 2-bit inputs A[1:0] and B[1:0], and produces an output z. The value of z should be 1 if A = B, otherwise z should be 0.
module top_module ( input [1:0] A, input [1:0] B, output z );
// Insert your code here
endmodule | // Create a circuit that has two 2-bit inputs A[1:0] and B[1:0], and produces an output z. The value of z should be 1 if A = B, otherwise z should be 0.
module top_module(
input [1:0] A,
input [1:0] B,
output z);
assign z = A[1:0]==B[1:0];
endmodule | |
Please act as a professional verilog designer. mux2to1v : // Create a 100-bit wide, 2-to-1 multiplexer. When sel=0, choose a. When sel=1, choose b.
// Hint: The ternary operator (cond ? iftrue : iffalse) is easier to read.
module top_module(
input [99:0] a, b,
input sel,
output [99:0] out );
// Ins... | // Create a 2-1 multiplexer. When sel=0, choose a. When sel=1, choose b.
module top_module (
input [99:0] a,
input [99:0] b,
input sel,
output [99:0] out
);
assign out = sel ? b : a;
endmodule | |
Please act as a professional verilog designer. mux_to_demux : // Combining the mux-4x1 to the demux-1x4 to prove the input will equal
// the output (for the selected output).
module mux_to_demux_structural(
input a1, b1, c1, d1, // 4 Inputs
input [1:0] sel1, // Select
inpu... | // Combining the mux-4x1 to the demux-1x4 to prove the input will equal
// the output (for the selected output).
module mux_to_demux_structural(
input a1, b1, c1, d1, // 4 Inputs
input [1:0] sel1, // Select
input [1:0] sel2, // Select
output ... | |
Please act as a professional verilog designer. 7420 : //The 7400-series integrated circuits are a series of digital chips with a few gates each.
//The 7420 is a chip with two 4-input NAND gates.
// Create a module with the same functionality as the 7420 chip. It has 8 inputs and 2 outputs.
//Hint: You need to drive ... | // The 7400-series integrated circuits are a series of digital chips with a few gates each. The 7420 is a chip with two 4-input NAND gates.
// Create a module with the same functionality as the 7420 chip. It has 8 inputs and 2 outputs.
module top_module(
input p1a,
input p1b,
input p1c,
input p1d,
output p1y... | |
Please act as a professional verilog designer. andgate : // Create a module that implements an AND gate.
// Hint: Verilog has separate bitwise-AND (&) and logical-AND (&&) operators, like C.
// Since we're working with a one-bit here, it doesn't matter which we choose.
module top_module(
input a,
input b, ... | // Create a module that implements an AND gate.
module top_module(
input a,
input b,
output out
);
assign out = a & b;
endmodule | |
Please act as a professional verilog designer. basic1 : // Create a module with one input and one output that behaves like a wire
module wire_assign( input in, output out ); | // Create a module with one input and one output that behaves like a wire
module wire_assign( input in, output out );
// assign out to in
assign out = in;
endmodule | |
Please act as a professional verilog designer. basic4 : // Create a 2-to-1 multiplexer.
module mux(
input [4:0] a, b,
input sel,
output [4:0] out ); | // Create a module that implements an AND gate
module mux(
input [4:0] a, b,
input sel,
output [4:0] out );
assign out = sel?b:a;
endmodule | |
Please act as a professional verilog designer. bugs_mux2 : // This 8-bit wide 2-to-1 multiplexer doesn't work. Fix the bug(s).
module top_module (
input sel,
input [7:0] a,
input [7:0] b,
output out );
assign out = (~sel & a) | (sel & b);
endmodule | // Find the bug and fix this 8-bit wide 2-to-1 mux.
// module top_module (
// input sel,
// input [7:0] a,
// input [7:0] b,
// output out );
// assign out = (~sel & a) | (sel & b);
// endmodule
module top_module (
input sel,
input [7:0] a,
input [7:0] b,
output [7:0] o... | |
Please act as a professional verilog designer. bugs_nand3 : // This three-input NAND gate doesn't work. Fix the bug(s).
// You must use the provided 5-input AND gate:
module andgate ( output out, input a, input b, input c, input d, input e );
module top_module (input a, input b, input c, output out);//
andgate ... | module top_module (input a, input b, input c, output out);//
wire out_tmp;
assign out = ~out_tmp;
andgate inst1 ( out_tmp, a, b, c, 1, 1 );
endmodule | |
Please act as a professional verilog designer. fadd : Create a full adder. A full adder adds three bits (including carry-in) and produces a sum and carry-out.
module top_module(
input a, b, cin,
output cout, sum );
// Insert your code below
endmodule | // Create a full adder. A full adder adds three bits (including carry-in) and produces a sum and carry-out.
module top_module (
input a,
input b,
input cin,
output cout,
output sum
);
assign {cout, sum} = a+b+cin;
endmodule | |
Please act as a professional verilog designer. gates : /*
Ok, let's try building several logic gates at the same time. Build a combinational circuit with two inputs, a and b.
There are 7 outputs, each with a logic gate driving it:
out_and: a and b
out_or: a or b
out_xor: a xor b
out_nand: a nand b
out_nor: a nor b
ou... | // Build a combinational circuit with two inputs, a and b. There are 7 outputs, each with a logic gate driving it:
// (1) out_and: a and b
// (2) out_or: a or b
// (3) out_xor: a xor b
// (4) out_nand: a nand b
// (5) out_nor: a nor b
// (6) out_xnor: a xnor b
// (7) out_anotb: a and-not b
module top_module (
... | |
Please act as a professional verilog designer. m2014_q4e : // Implement a 2-input NOR gate.
module top_module (
input in1,
input in2,
output out
); | module top_module (
input in1,
input in2,
output out
);
assign out = ~(in1 | in2);
endmodule
| |
Please act as a professional verilog designer. mux_4x1 : // Multiplexer - Four inputs, one output.
module mux_4x1_behavioral(
input a, b, c, d, // 4 Inputs
input [1:0] sel, // Select
output reg y); // 1 Output
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT... | // Multiplexer - Four inputs, one output.
module mux_4x1_behavioral(
input a, b, c, d, // 4 Inputs
input [1:0] sel, // Select
output reg y); // 1 Output
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
always @ ( * ) begin
case(sel)
... | |
Please act as a professional verilog designer. nor2 : // Implement a module of a 2-input NOR gate in combinational logic.
// GATE PRIMITIVE
// CONTINUOUS ASSIGNMENT STATEMENT
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
module nor2_gate(
input a, b, // 2-Input
output y); ... | // 2-input NOR gate used in my programable-8-bit-microprocessor
module nor2_gate(
input a, b, // 2-Input
output y); // Output
// GATE PRIMITIVE
nor (y, a, b);
endmodule
module nor2_dataflow(
input a, b, // 2-Input
output y); // Output
// CONTINU... | |
Please act as a professional verilog designer. norgate : // Create a module that implements a NOR gate.
// A NOR gate is an OR gate with its output inverted.
// A NOR function needs two operators when written in Verilog.
// Hint: Verilog has separate bitwise-OR (|) and logical-OR (||) operators, like C.
// Since we... | // Create a module that implements a NOR gate.
module top_module(
input a,
input b,
output out
);
assign out = ~(a | b);
endmodule | |
Please act as a professional verilog designer. or2 : // Implement a module of a 2-input OR gate in combinational logic.
// GATE PRIMITIVE
// CONTINUOUS ASSIGNMENT STATEMENT
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
module or2_gate(
input a, b, // 2-Input
output y); ... | // 2-input OR gate used in my programable-8-bit-microprocessor
module or2_gate(
input a, b, // 2-Input
output y); // Output
// GATE PRIMITIVE
or (y, a, b);
endmodule
module or2_dataflow(
input a, b, // 2-Input
output y); // Output
// CONTINUOUS ... | |
Please act as a professional verilog designer. step_one : //Build a circuit with no inputs and one output. That output should always drive 1 (or logic high).
module top_module( output one );
// Insert your code here
assign one = [fixme];
endmodule | // Build a circuit with no inputs and one output. That output should always drive 1 (or logic high).
module top_module(
output one);
assign one = 1'b1;
endmodule | |
Please act as a professional verilog designer. wire : // Create a module with one input and one output that behaves like a wire.
module top_module( input in, output out );
endmodule
| // Create a module with one input and one output that behaves like a wire.
module top_module(
input in,
output out);
assign out = in;
endmodule | |
Please act as a professional verilog designer. xnorgate : //Create a module that implements an XNOR gate.
//Hint: The bitwise-XOR operator is ^. There is no logical-XOR operator.
module top_module(
input a,
input b,
output out );
// Insert your code here
endmodule
| // Create a module that implements an XNOR gate.
module top_module(
input a,
input b,
output out
);
assign out = ~(a^b);
endmodule | |
Please act as a professional verilog designer. xor2 : // Implement a module of a 2-input XOR gate in combinational logic.
// GATE PRIMITIVE
// CONTINUOUS ASSIGNMENT STATEMENT
// ALWAYS BLOCK with NON-BLOCKING PROCEDURAL ASSIGNMENT STATEMENT
module xor2_gate(
input a, b, // 2-Input
output y); ... | // 2-input XOR gate used in my programable-8-bit-microprocessor
module xor2_gate(
input a, b, // 2-Input
output y); // Output
// GATE PRIMITIVE
xor (y, a, b);
endmodule
module xor2_dataflow(
input a, b, // 2-Input
output y); // Output
// CONTINU... | |
Please act as a professional verilog designer. zero : //Build a circuit with no inputs and one output that outputs a constant 0
module top_module(
output zero
);// Module body starts after semicolon
endmodule
| // Build a circuit that always outputs a LOW.
module top_module(
output zero);
assign zero = 1'b0;
endmodule | |
Please act as a professional verilog designer. always_casez : // Build a priority encoder for 8-bit inputs. Given an 8-bit vector, the output should report the first (least significant) bit in the vector that is 1. Report zero if the input vector has no bits that are high. For example, the input 8'b10010000 should outp... | // Build a priority encoder for 8-bit inputs. Given an 8-bit vector, the output should report the first (least significant) bit in the vector that is 1. Report zero if the input vector has no bits that are high. For example, the input 8'b10010000 should output 3'd4, because bit[4] is first bit that is high.
module top... | |
Please act as a professional verilog designer. barrel_shifter : Module name:
barrel_shifter
Function:
A barrel shifter for rotating bits efficiently. This 8-bit barrel shifter takes an 8-bit input and shifts or rotates the bits based on a 3-bit control signal.
Input ports:
in [7:0]: 8-bit input to be shi... | module barrel_shifter (in, ctrl, out);
input [7:0] in;
input [2:0] ctrl;
output [7:0] out;
wire [7:0] x,y;
//4bit shift right
mux2X1 ins_17 (.in0(in[7]),.in1(1'b0),.sel(ctrl[2]),.out(x[7]));
mux2X1 ins_16 (.in0(in[6]),.in1(1'b0),.sel(ctrl[2]),.out(x[6]));
mux2X1 ins_15 (.in0(in[5]),.in1(1'b0),.sel(ctrl[2]... | |
Please act as a professional verilog designer. circuit5 : // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b c d e q
// 0ns x ... | // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b c d e q
// 0ns x x x x ... | |
Please act as a professional verilog designer. div_16bit : Implement a 16-bit divider module, the dividend is 16-bit and the divider is 8-bit in combinational logic. Extract the higher bits of the dividend, matching the bit width of the divisor. Compare these bits with the divisor: if the dividend bits are greater, set... | module verified_div_16bit(
input wire [15:0] A,
input wire [7:0] B,
output wire [15:0] result,
output wire [15:0] odd
);
reg [15:0] a_reg;
reg [15:0] b_reg;
reg [31:0] tmp_a;
reg [31:0] tmp_b;
integer i;
always@(*) begin
a_reg = A;
b_reg = B;
end
always@(*) begin
begin
tmp_a =... | |
Please act as a professional verilog designer. fsm3comb : // The following is the state transition table for a Moore state machine with one input, one output, and four states. Use the following state encoding: A=2'b00, B=2'b01, C=2'b10, D=2'b11.
// Implement only the state transition logic and output logic (the combin... | // The following is the state transition table for a Moore state machine with one input, one output, and four states. Use the following state encoding: A=2'b00, B=2'b01, C=2'b10, D=2'b11.Implement only the state transition logic and output logic (the combinational logic portion) for this state machine. Given the curren... | |
Please act as a professional verilog designer. fsm3onehot-2 : // The following is the state transition table for a Moore state machine with one input, one output, and four states. Use the following one-hot state encoding: A=4'b0001, B=4'b0010, C=4'b0100, D=4'b1000. Derive state transition and output logic equations by ... | // The following is the state transition table for a Moore state machine with one input, one output, and four states. Use the following one-hot state encoding: A=4'b0001, B=4'b0010, C=4'b0100, D=4'b1000. Derive state transition and output logic equations by inspection assuming a one-hot encoding. Implement only the sta... | |
Please act as a professional verilog designer. fsm_onehot : // Given the follow state machine with 1 input and 2 outputs (the outputs are given as "(out1, out2)"):
// S0 (0, 0) --0--> S0
// S0 (0, 0) --1--> S1
// S1 (0, 0) --0--> S0
// S1 (0, 0) --1--> S2
// S2 (0, 0) --0--> S0
// S2 (0, 0) --1--> S3
// S3 (0, 0) --0-... | // Given the follow state machine with 1 input and 2 outputs (the outputs are given as "(out1, out2)"):
// S0 (0, 0) --0--> S0
// S0 (0, 0) --1--> S1
// S1 (0, 0) --0--> S0
// S1 (0, 0) --1--> S2
// S2 (0, 0) --0--> S0
// S2 (0, 0) --1--> S3
// S3 (0, 0) --0--> S0
// S3 (0, 0) --1--> S4
// S4 (0, 0) --0--> S0
// S4 (0... | |
Please act as a professional verilog designer. jeff_74x181 : // 4-bit alu (arithmetic logic unit) and function generator.
// Provides 16 binary logic operations and 16 arithmetic operations on two 4-bit words.
// Based on the 7400-series integrated circuits used in my
// programable-8-bit-microprocessor
// MUST PUT in... | // 4-bit alu (arithmetic logic unit) and function generator.
// Provides 16 binary logic operations and 16 arithmetic operations on two 4-bit words.
// Based on the 7400-series integrated circuits used in my
// programable-8-bit-microprocessor
// MUST PUT includes IN TESTBENCH SINCE MY 8-bit PROCESSOR IS CALLING THESE... | |
Please act as a professional verilog designer. multi_8bit : Please act as a professional Verilog designer.
Implement a module of an 8-bit multiplier based on shifting and adding operations.
Module name:
multi_8bit
Input ports:
A [7:0]: First 8-bit input operand (representing a multiplicand).
... | module multi_8bit (
input [7:0] A,
input [7:0] B,
output reg [15:0] product
);
reg [7:0] multiplicand;
reg [3:0] shift_count;
integer i;
always @* begin
product = 16'b0;
multiplicand = A;
shift_count = 0;
for (i = 0; i < 8; i = i + 1) begin
if (B[i] == 1) begin
product... | |
Please act as a professional verilog designer. mux256to1v : // Create a 4-bit wide, 256-to-1 multiplexer. The 256 4-bit inputs are all packed into a single 1024-bit input vector.
// sel=0 should select bits in[3:0], sel=1 selects bits in[7:4], sel=2 selects bits in[11:8], etc.
// Hint: With this many options, a case ... | // Create a 4-bit wide, 256-to-1 multiplexer. The 256 4-bit inputs are all packed into a single 1024-bit input vector. sel=0 should select bits in[3:0], sel=1 selects bits in[7:4], sel=2 selects bits in[11:8], etc.
module top_module (
input [1023:0] in,
input [7:0] sel,
output [3:0] out
);
assign out = {in[sel*4+... | |
Please act as a professional verilog designer. reduction : //You're already familiar with bitwise operations between two values, e.g., a & b or a ^ b. Sometimes, you want to create a wide gate that operates on all of the bits of one vector, like (a[0] & a[1] & a[2] & a[3] ... ), which gets tedious if the vector is long... | // Parity checking is often used as a simple method of detecting errors when transmitting data through an imperfect channel. Create a circuit that will compute a parity bit for a 8-bit byte (which will add a 9th bit to the byte). We will use "even" parity, where the parity bit is just the XOR of all 8 data bits.
modul... | |
Please act as a professional verilog designer. ringer : // Suppose you are designing a circuit to control a cellphone's ringer and vibration motor.
// Whenever the phone needs to ring from an incoming call (input ring), your circuit must either
// turn on the ringer (output ringer = 1) or the motor (output motor = 1)... | // Suppose you are designing a circuit to control a cellphone's ringer and vibration motor. Whenever the phone needs to ring from an incoming call (input ring), your circuit must either turn on the ringer (output ringer = 1) or the motor (output motor = 1), but not both. If the phone is in vibrate mode (input vibrate_m... | |
Please act as a professional verilog designer. thermostat : // A heating/cooling thermostat controls both a heater (during winter) and an air conditioner (during summer).
// Implement a circuit that will turn on and off the heater, air conditioning, and blower fan as appropriate.
// The thermostat can be in one of tw... | // A heating/cooling thermostat controls both a heater (during winter) and an air conditioner (during summer). Implement a circuit that will turn on and off the heater, air conditioning, and blower fan as appropriate. The thermostat can be in one of two modes: heating (mode = 1) and cooling (mode = 0). In heating mode,... | |
Please act as a professional verilog designer. vector100r : Please act as a professional verilog designer.
//Given a 100-bit input vector [99:0], reverse its bit ordering.
module top_module(
input [99:0] in,
output [99:0] out
);
// Insert your code below
endmodule | module top_module(
input [99:0] in,
output [99:0] out
);
genvar i;
generate
for (i = 0; i < 100; i = i + 1) begin : reverse_bits
assign out[i] = in[99 - i];
end
endgenerate
endmodule
| |
Please act as a professional verilog designer. vector2 : // Build a circuit that will reverse the byte ordering of the 4-byte word.
// Hint: Part-select can be used on both the left side and right side of an assignment.
// AaaaaaaaBbbbbbbbCcccccccDddddddd => DdddddddCcccccccBbbbbbbbAaaaaaaa
module top_module(
in... | // Build a circuit that reverses the byte order of a 32-bit vector.
module top_module (
input [31:0] in,
output [31:0] out
);
assign out = {in[7:0], in[15:8], in[23:16], in[31:24]};
endmodule | |
Please act as a professional verilog designer. vector5 : //Given five 1-bit signals (a, b, c, d, and e), compute all 25 pairwise one-bit comparisons
// in the 25-bit output vector. The output should be 1 if the two bits being compared are equal.
// Hint: out[24] = ~a ^ a; // a == a, so out[24] is always 1.
// out[2... | // Given five 1-bit signals (a, b, c, d, and e), compute all 25 pairwise one-bit comparisons in the 25-bit output vector. The output should be 1 if the two bits being compared are equal. Example: out[24] = ~a ^ a; out[23] = ~a ^ b; out[22] = ~a ^ c; ... out[ 1] = ~e ^ d; out[ 0] = ~e ^ e.
module top_module (
input a,... | |
Please act as a professional verilog designer. vectorgates : // Build a circuit that has two 3-bit inputs that computes
// the bitwise-OR of the two vectors, the logical-OR of the two vectors,
and the inverse (NOT) of both vectors. Place the inverse of b in
// the upper half of out_not (i.e., bits [5:3]), and the in... | // Build a circuit that has two 3-bit inputs that computes the bitwise-OR of the two vectors, the logical-OR of the two vectors, and the inverse (NOT) of both vectors. Place the inverse of b in the upper half of out_not (i.e., bits [5:3]), and the inverse of a in the lower half.
module top_module(
input [2:0] a,
in... | |
Please act as a professional verilog designer. adder_bcd : Implement a module of a 4-bit BCD adder for decimal arithmetic operations.
Module name:
adder_bcd
Input ports:
A [3:0]: First BCD input (4-bit, representing a decimal digit from 0 to 9).
B [3:0]: Second BCD input (4-bit, represent... | module adder_bcd (
input [3:0] A, // First BCD number (0-9)
input [3:0] B, // Second BCD number (0-9)
input Cin, // Input carry
output [3:0] Sum, // BCD sum (0-9)
output Cout // Output carry
);
wire [4:0] temp_sum; // Temporary 5-bit sum to store initial result
wire... | |
Please act as a professional verilog designer. advanced1 : // This is a signed adder that adds two 8-bit 2's complement numbers. It also captures a signed overflow.
module signed_adder(input [7:0] a, input [7:0] b, output [7:0] s, output overflow );
// The numbers a and b are added to the output s.
// assign the occu... | // Design a signed adder that adds two 8-bit 2's complement numbers, a[7:0] and b[7:0].
// These numbers are added to produce s[7:0]. Also compute whether a (signed) overflow has occurred.
module signed_adder(input [7:0] a,
input [7:0] b,
output [7:0] s,
output overflow
);
assign s = a+b;
assign... | |
Please act as a professional verilog designer. always_case : // Case statements in Verilog are nearly equivalent to a sequence of if-elseif-else that compares one expression to a list of others. Its syntax and functionality differs from the switch statement in C.
/* always @(*) begin // This is a combinational circ... | // Create a 6-to-1 multiplexer. When sel is between 0 and 5, choose the corresponding data input. Otherwise, output 0. The data inputs and outputs are all 4 bits wide.
module top_module (
input [2:0] sel,
input [3:0] data0,
input [3:0] data1,
input [3:0] data2,
input [3:0] data3,
input [3:0] data4,
input [3:0] ... | |
Please act as a professional verilog designer. always_case2 : // A priority encoder is a combinational circuit that, when given an input bit vector, outputs the position of the first 1 bit in the vector.
// For example, a 8-bit priority encoder given the input 8'b10010000 would output 3'd4, because bit[4] is first bit... | // A priority encoder is a combinational circuit that, when given an input bit vector, outputs the position of the first 1 bit in the vector. For example, a 8-bit priority encoder given the input 8'b10010000 would output 3'd4, because bit[4] is first bit that is high. Build a 4-bit priority encoder. For this problem, i... | |
Please act as a professional verilog designer. always_case2-2 : // A priority encoder is a combinational circuit that, when given an input bit vector, outputs the position of the first 1 bit in the vector. For example, a 8-bit priority encoder given the input 8'b10010000 would output 3'd4, because bit[4] is first bit t... | // A priority encoder is a combinational circuit that, when given an input bit vector, outputs the position of the first 1 bit in the vector. For example, a 8-bit priority encoder given the input 8'b10010000 would output 3'd4, because bit[4] is first bit that is high. Build a 4-bit priority encoder. For this problem, i... | |
Please act as a professional verilog designer. circuit2 : // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b c d q
// 0ns 0 0 ... | // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b c d q
// 0ns 0 0 0 0 1 ... | |
Please act as a professional verilog designer. circuit4 : // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b c d q
// 0ns 0 0 ... | // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b c d q
// 0ns 0 0 0 0 0 ... | |
Please act as a professional verilog designer. ece241_2013_q2 : //A single-output digital system with four inputs (a,b,c,d) generates a logic-1 when 2, 7, or 15 appears on the inputs, and a logic-0 when 0, 1, 4, 5, 6, 9, 10, 13, or 14 appears. The input conditions for the numbers 3, 8, 11, and 12 never occur in this sy... | // A single-output digital system with four inputs (a,b,c,d) generates a logic-1 when 2, 7, or 15 appears on the inputs, and a logic-0 when 0, 1, 4, 5, 6, 9, 10, 13, or 14 appears. The input conditions for the numbers 3, 8, 11, and 12 never occur in this system. For example, 7 corresponds to a,b,c,d being set to 0,1,1,... | |
Please act as a professional verilog designer. ece241_2014_q3 : // For the following Karnaugh map, give the circuit implementation using one 4-to-1 multiplexer and as many 2-to-1 multiplexers as required, but using as few as possible. You are not allowed to use any other logic gate and you must use _a_ and _b_ as the m... | // For the following Karnaugh map, give the circuit implementation using one 4-to-1 multiplexer and as many 2-to-1 multiplexers as required, but using as few as possible. You are not allowed to use any other logic gate and you must use _a_ and _b_ as the multiplexer selector inputs, as shown on the 4-to-1 multiplexer b... | |
Please act as a professional verilog designer. encoder_to_decoder : // Combining the encoder-8-3 to the decoder-3-8 to prove the input will equal the output.
module encoder_to_decoder_structural(
input [7:0] in, // 8 Inputs
output [7:0] out // 8 Outputs
);
// Insert your code here
// ENC... | // Combining the encoder-8-3 to the decoder-3-8 to prove the input will equal the output.
module encoder_to_decoder_structural(
input [7:0] in, // 8 Inputs
output [7:0] out // 8 Outputs
);
wire [7:0] connect;
// ENCODER
encoder_8_3_behavioral encoder_8_3 (
.in(in),
... | |
Please act as a professional verilog designer. fixed_point_adder : Please act as a professional Verilog designer.
Implement a module of a parameterized fixed-point adder for arithmetic operations with fixed precision.
Module name:
fixed_point_adder
Input parameters:
Q: Number of fractional bi... | module fixed_point_adder #(
//Parameterized values
parameter Q = 15,
parameter N = 32
)
(
input [N-1:0] a,
input [N-1:0] b,
output [N-1:0] c
);
reg [N-1:0] res;
assign c = res;
always @(a,b) begin
// both negative or both positive
if(a[N-1] == b[N-1]) begin
res[N-2:0] = a[N-2:0] + b[N-2:... | |
Please act as a professional verilog designer. intermediate7 : // This is a permutation block module.
module P_box ( input wire [31:0] In32, output reg [31:0] Out32 );
localparam len_table = 32;
reg [5:0] In32table [len_table-1:0];
initial begin
In32table[0] = 15;
In32table[1] = 6;
In32table[2] = 20;
In32table[3] = 10... | // Advanced Hardware Design, lecture 1
module P_box ( input wire [31:0] In32, output reg [31:0] Out32 );
localparam len_table = 32;
reg [5:0] In32table [len_table-1:0];
initial begin
In32table[0] = 15;
In32table[1] = 6;
In32table[2] = 20;
In32table[3] = 10;
In32table[4] = 1... | |
Please act as a professional verilog designer. Kmap2 : //Implement the circuit described by the Karnaugh map below.
| | a'b' | a'b | ab | ab' |
|-------|------|------|-----|-----|
| c'd' | 1 | 1 | 0 | 1 |
| c'd | 1 | 0 | 0 | 1 |
| cd | 0 | 1 | 1 | 1 |
| cd' | 1 | 1 |... | // Implement the circuit described by the Karnaugh map below.
// ab
// cd 00 01 11 10
// 00 | 1 | 1 | 0 | 1 |
// 01 | 1 | 0 | 0 | 1 |
// 11 | 0 | 1 | 1 | 1 |
// 10 | 1 | 1 | 0 | 0 |
module top_module (
input a,
input b,
input c,
input d,
output out
);
assign out = (~c & ~b) | (~d&~a) | (a&c&d) |... | |
Please act as a professional verilog designer. Kmap4 : // Implement the circuit described by the Karnaugh map below.
| | a'b' | a'b | ab | ab' |
|-------|------|------|-----|-----|
| c'd' | 0 | 1 | 0 | 1 |
| c'd | 1 | 0 | 1 | 0 |
| cd | 0 | 1 | 0 | 1 |
| cd' | 1 | 0 ... | // Implement the circuit described by the Karnaugh map below.
// ab
// cd 00 01 11 10
// 00 | 0 | 1 | 0 | 1 |
// 01 | 1 | 0 | 1 | 0 |
// 11 | 0 | 1 | 0 | 1 |
// 10 | 1 | 0 | 1 | 0 |
module top_module (
input a,
input b,
input c,
input d,
output reg out
);
always @(*) begin
case({a,b,c... | |
Please act as a professional verilog designer. mux9to1v : // Create a 16-bit wide, 9-to-1 multiplexer. sel=0 chooses a, sel=1 chooses b, etc.
// For the unused cases (sel=9 to 15), set all output bits to '1'.
// Hint: With this many options, a case statement may be useful.
module top_module(
input [15:0] a, b, ... | // Create a 16-bit wide, 9-to-1 multiplexer. sel=0 chooses a, sel=1 chooses b, etc. For the unused cases (sel=9 to 15), set all output bits to '1'.
module top_module (
input [15:0] a,
input [15:0] b,
input [15:0] c,
input [15:0] d,
input [15:0] e,
input [15:0] f,
input [15:0] g,
... | |
Please act as a professional verilog designer. vector1 : Please act as a professional verilog designer.
//Vectors are used to group related signals using one name to make it more convenient to manipulate. For example, wire [7:0] w; declares an 8-bit vector named w that is equivalent to having 8 separate wires.
/*
De... | // Build a combinational circuit that splits an input half-word (16 bits, [15:0] ) into lower [7:0] and upper [15:8] bytes.
module top_module (
input [15:0] in,
output [7:0] out_hi,
output [7:0] out_lo
);
assign {out_hi, out_lo} = in;
endmodule | |
Please act as a professional verilog designer. vectorr : // Given an 8-bit input vector [7:0], reverse its bit ordering.
//Hint: assign out[7:0] = in[0:7]; does not work because Verilog does not allow vector bit ordering to be flipped.
//The concatenation operator may save a bit of coding, allowing for 1 assign statem... | // Given an 8-bit input vector [7:0], reverse its bit ordering.
module top_module (
input [7:0] in,
output [7:0] out
);
assign {out[0],out[1],out[2],out[3],out[4],out[5],out[6],out[7]} = in;
endmodule | |
Please act as a professional verilog designer. 2012_q1g : // Consider the function f shown in the Karnaugh map below. Implement this function.
x1'x2' x1'x2 x1x2 x1x2'
x3'x4' 1 0 0 1
x3'x4 0 0 0 0
x3x4 1 1 1 0
x3x4' 1 1 0 1
// Hint: Be careful of the... | module top_module (
input [3:0] x, // 更改位元範圍為 [3:0]
output reg f // 保留 f 為 reg 類型
);
// 使用 always 區塊來實現組合邏輯
always @(*) begin
case (x)
4'h0: f = 1;
4'h1: f = 1;
4'h2: f = 0;
4'h3: f = 0;
4'h4: f = 1;
... | |
Please act as a professional verilog designer. adder3 : // The adder adds two 3-bit numbers and a carry-in to produce a 3-bit sum and carry out.
// To encourage you to actually instantiate full adders, also output the carry-out from each full adder in the ripple-carry adder. cout[2] is the final carry-out from the las... | module top_module(
input [2:0] a, b,
input cin,
output [2:0] cout,
output [2:0] sum
);
// Internal carry wires
wire c1, c2, c3;
// First Full Adder
assign sum[0] = a[0] ^ b[0] ^ cin;
assign c1 = (a[0] & b[0]) | (a[0] & cin) | (b[0] & cin);
/... | |
Please act as a professional verilog designer. adder_8bit : Implement a module of an 8-bit adder with multiple bit-level adders in combinational logic.
Module name:
adder_8bit
Input ports:
a[7:0]: 8-bit input operand A.
b[7:0]: 8-bit input operand B.
cin: Carry-in input.
Output ports:... | module verified_adder_8bit(
input [7:0] a, b,
input cin,
output [7:0] sum,
output cout);
wire [8:0] c;
full_adder FA0 (.a(a[0]), .b(b[0]), .cin(cin), .sum(sum[0]), .cout(c[0]));
full_adder FA1 (.a(a[1]), .b(b[1]), .cin(c[0]), .sum(sum[1]), .cout(c[1]));
full_adder FA2 (.a(a[2]),... | |
Please act as a professional verilog designer. always_nolatches : // Suppose you're building a circuit to process scancodes from a PS/2 keyboard for a game.
// Given the last two bytes of scancodes received, you need to indicate whether one of the
// arrow keys on the keyboard have been pressed. This involves a fairl... | // Suppose you're building a circuit to process scancodes from a PS/2 keyboard for a game. Given the last two bytes of scancodes received, you need to indicate whether one of the arrow keys on the keyboard have been pressed. This involves a fairly simple mapping, which can be implemented as a case statement (or if-else... | |
Please act as a professional verilog designer. circuit1 : // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b q
// 0ns 0 0 0
// 5... | // This is a combinational circuit. Read the simulation waveforms to determine what the circuit does, then implement it.
// time a b q
// 0ns 0 0 0
// 5ns 0 0 0 ... | |
Please act as a professional verilog designer. comparator_3bit : Please act as a professional Verilog designer.
Implement a module of a 3-bit comparator for comparing binary numbers.
Module name:
comparator_3bit
Input ports:
A [2:0]: First 3-bit input operand (the first binary number to compa... | module comparator_3bit (
input [2:0] A,
input [2:0] B,
output A_greater,
output A_equal,
output A_less
);
assign A_greater = (A > B) ? 1'b1 : 1'b0;
assign A_equal = (A == B) ? 1'b1 : 1'b0;
assign A_less = (A < B) ? 1'b1 : 1'b0;
endmodule | |
Please act as a professional verilog designer. conditional : // Verilog has a ternary conditional operator ( ? : ) much like C:
// Given four unsigned numbers, find the minimum. Unsigned numbers can be compared with standard comparison operators (a < b). Use the conditional operator to make two-way min circuits, then c... | // Given four unsigned numbers, find the minimum. Unsigned numbers can be compared with standard comparison operators (a < b).
module top_module (
input [7:0] a,
input [7:0] b,
input [7:0] c,
input [7:0] d,
output reg [7:0] min
);
always @(*) begin
min = a;
if (min > b) min = ... | |
Please act as a professional verilog designer. intermediate8 : // This is a circuit synthesized from a truth table
// Inputs | Outputs
// x3 x2 x1 | f
// 0 0 0 | 1
// 0 0 1 | 1
// 0 1 0 | 0
// 0 1 1 | 1
// 1 0 0 | 0
// 1 0 1 | 0
// 1 1 0 | 1
//... | // https://hdlbits.01xz.net/wiki/Truthtable1
// This is a circuit synthesized from a truth table
// The truth table is for a three-input, one-output function. It has 8 rows for each of the 8 possible input combinations, and one output column.
// There are four inputs combinations where the output is 1, and four where... | |
Please act as a professional verilog designer. m2014_q3 : // Consider the function f shown in the Karnaugh map below. d is don't-care, which means you may choose to output whatever value is convenient. Implement this function.
// x1x2
// x3x4 00 01 11 10
// 00 | d | 0 | d | d |
// 01 | 0 | d | 1 | 0 |
// 1... | // Consider the function f shown in the Karnaugh map below. d is don't-care, which means you may choose to output whatever value is convenient. Implement this function.
// x[1]x[2]
// x[3]x[4] 00 01 11 10
// 00 | d | 0 | d | d |
// 01 | 0 | d | 1 | 0 |
// 11 | 1 | 1 | d | d |
// 10 | 1 | 1 | 0 | d |
modu... | |
Please act as a professional verilog designer. m2014_q4g : // Implement in Verilog the following circuit: A two-input XNOR (connected to 'in1' and 'in2) has an output connected to the input of a two-input XOR. The second input of the XOR is 'in3.' The output of the XOR is 'out'.
module top_module (
input in1,
input ... | // Implement in Verilog the following circuit: A two-input XNOR (connected to 'in1' and 'in2) has an output connected to the input of a two-input XOR. The second input of the XOR is 'in3.' The output of the XOR is 'out'.
module top_module (
input in1,
input in2,
input in3,
output wire out
);
//... | |
Please act as a professional verilog designer. m2014_q4i : // Build a circuit with no inputs and one output. That output should always drive 0 (or logic low).
module top_module(
output out); | // Build a circuit with no inputs and one output. That output should always drive 0 (or logic low).
module top_module(
output out);
assign out = 1'b0;
endmodule | |
Please act as a professional verilog designer. m2014_q6b : // Consider the state machine shown below:
// A (0) --0--> B
// A (0) --1--> A
// B (0) --0--> C
// B (0) --1--> D
// C (0) --0--> E
// C (0) --1--> D
// D (0) --0--> F
// D (0) --1--> A
// E (1) --0--> E
// E (1) --1--> D
// F (1) --0--> C
// F (1) --1--> D
... | // Consider the state machine shown below:
// A (0) --0--> B
// A (0) --1--> A
// B (0) --0--> C
// B (0) --1--> D
// C (0) --0--> E
// C (0) --1--> D
// D (0) --0--> F
// D (0) --1--> A
// E (1) --0--> E
// E (1) --1--> D
// F (1) --0--> C
// F (1) --1--> D
// Assume that you want to Implement the FSM using three fl... | |
Please act as a professional verilog designer. m2014_q6c : // Consider the state machine shown below:
// A (0) --0--> B
// A (0) --1--> A
// B (0) --0--> C
// B (0) --1--> D
// C (0) --0--> E
// C (0) --1--> D
// D (0) --0--> F
// D (0) --1--> A
// E (1) --0--> E
// E (1) --1--> D
// F (1) --0--> C
// F (1) --1--> D
... | // Consider the state machine shown below:
// A (0) --0--> B
// A (0) --1--> A
// B (0) --0--> C
// B (0) --1--> D
// C (0) --0--> E
// C (0) --1--> D
// D (0) --0--> F
// D (0) --1--> A
// E (1) --0--> E
// E (1) --1--> D
// F (1) --0--> C
// F (1) --1--> D
// Resets into state A. For this part, assume that a one-ho... | |
Please act as a professional verilog designer. mt2015_q4 : // Module A implements the boolean function z = (x^y) & x.
// Module B can be described by the following simulation waveform:
// time x y z
// 0ns 0 0 1 ... | // Module A implements the boolean function z = (x^y) & x.
// Module B can be described by the following simulation waveform:
// time x y z
// 0ns 0 0 1
// 5ns 0 0 1 ... | |
Please act as a professional verilog designer. popcount3 : // A "population count" circuit counts the number of '1's in an input vector. Build a population count circuit for a 3-bit input vector.
module top_module(
input [2:0] in,
output [1:0] out );
// Insert your code here
endmodule | // A "population count" circuit counts the number of '1's in an input vector. Build a population count circuit for a 3-bit input vector.
module top_module (
input [2:0] in,
output [1:0] out
);
assign out = in[0]+in[1]+in[2];
endmodule | |
Please act as a professional verilog designer. truthtable1 : // Create a combinational circuit that implements the truth table.
// x3 | x2 | x1 | f
// 0 | 0 | 0 | 0
// 0 | 0 | 1 | 0
// 0 | 1 | 0 | 1
// 0 | 1 | 1 | 1
// 1 | 0 | 0 | 0
// 1 | 0 | 1 | 1
// 1 | 1 | 0 | 0
// 1 | 1 | 1 | 1
module top_module (
input x3,
in... | // Create a combinational circuit that implements the truth table.
// x3 | x2 | x1 | f
// 0 | 0 | 0 | 0
// 0 | 0 | 1 | 0
// 0 | 1 | 0 | 1
// 0 | 1 | 1 | 1
// 1 | 0 | 0 | 0
// 1 | 0 | 1 | 1
// 1 | 1 | 0 | 0
// 1 | 1 | 1 | 1
module top_module (
input x3,
input x2,
input x1,
output f
);
assign f = ( ~x3 & x2 & ~x... | |
Please act as a professional verilog designer. wire_decl : // Implement the following circuit. Create two intermediate wires (named anything you want) to connect the AND and OR gates together. Note that the wire that feeds the NOT gate is really wire `out`, so you do not necessarily need to declare a third wire here. N... | // Implement the following circuit. Create two intermediate wires (named anything you want) to connect the AND and OR gates together. Note that the wire that feeds the NOT gate is really wire `out`, so you do not necessarily need to declare a third wire here. Notice how wires are driven by exactly one source (output of... | |
Please act as a professional verilog designer. 2014_q4a : // Consider an n-bit shift register circuit. Inputs E are for enabling shift, R for value to load, L is asserted when it should load, and w is the input to the first stage of the shift register. Write a Verilog module named top_module for one stage of this circu... | // Consider an n-bit shift register circuit. Inputs E are for enabling shift, R for value to load, L is asserted when it should load, and w is the input to the first stage of the shift register. Write a Verilog module named top_module for one stage of this circuit, including both the flip-flop and multiplexers.
module... | |
Please act as a professional verilog designer. advanced2 : // This is a decade counter that counts from 0 through 9, inclusive. It counts only when slowena is high.
module count_slow(input clk, input slowena, input reset, output reg [3:0] q);
// On the positive edge of the clock:
// if reset is high, reset the output q... | // Build a decade counter that counts from 0 through 9, inclusive, with a period of 10.
// The reset input is synchronous, and should reset the counter to 0.
// The slowena input indicates when the counter should increment. The counter should stay paused otherwise
module count_slow(
input clk,
input slowena,... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 11