Section 8.6  HDL Description of Design Example    383
the ASMD chart ( Fig.   8.9   (d)). Note that nonblocking assignments are used (with 
symbol 6=) for the register transfer operations. This ensures that the register opera-
tions and state transitions are concurrent, a feature that is especially crucial during 
control state  S_1 . In this state,  A  is incremented by 1 and the value of  A2  ( A[2] is 
checked to determine the operation to execute at register  E  at the next clock. To 
accomplish a valid synchronous design, it is necessary to ensure that  A[2]  is checked 
before  A  is incremented. If blocking assignments were used, one would have to place 
the two statements that check  E  first and the  A  statement that increments last. How-
ever, by using nonblocking assignments, we accomplish the required synchronization 
without being concerned about the order in which the statements are listed. The 
counter  A  in  Datapath_RTL  is cleared synchronously because  clr_A_F  is synchro-
nized to the clock. 
The cyclic behaviors of the controller and the datapath interact in a chain reaction: 
At the active edge of the clock, the state and datapath registers are updated. A change 
in the state, a primary input, or a status input causes the level‐sensitive behaviors of 
the controller to update the value of the next state and the outputs. The updated values 
are used at the next active edge of the clock to determine the state transition and the 
updates of the datapath. 
Note that the manual method of design developed (1) a block diagram ( Fig.   8.9   (a)) 
showing the interface between the datapath and the controller, (2) an ASMD chart for 
the system ( Fig.   8.9   (d)), (3) the logic equations for the inputs to the flip‐flops of the 
controller, and (4) a circuit that implements the controller ( Fig.   8.12   ). In contrast, an 
RTL model describes the state transitions of the controller and the operations of the 
datapath as a step toward automatically synthesizing the circuit that implements them. 
The descriptions of the datapath and controller are derived directly from the ASMD 
chart in both cases.     
HDL Example 8.2  
// RTL description of design example (see  Fig.   8.11   )
module  Design_Example_RTL (A, E, F, Start, clock, reset_b);
// Specify ports of the top-level module of the design
// See block diagram,  Fig.   8.10   
output  [3: 0] A;
output  
E, F;
input  
Start, clock, reset_b;
// Instantiate controller and datapath units
Controller_RTL M0 (set_E, clr_E, set_F, clr_A_F, incr_A, A[2], A[3], Start, clock, reset_b);
Datapath_RTL M1 (A, E, F, set_E, clr_E, set_F, clr_A_F, incr_A, clock);
endmodule 
module  Controller_RTL (set_E, clr_E, set_F, clr_A_F, incr_A, A2, A3, Start, clock, reset_b);
output reg 
set_E, clr_E, set_F, clr_A_F, incr_A;
input  
Start, A2, A3, clock, reset_b;
Online pdf converter to powerpoint - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
how to add pdf to powerpoint presentation; conversion of pdf into ppt
Online pdf converter to powerpoint - VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in vb.net, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
how to convert pdf slides to powerpoint presentation; convert pdf to powerpoint presentation
384    Chapter 8  Design at the Register Transfer Level
reg  [1: 0]  
state, next_state;
parameter   
S_idle = 2'b00, S_1 = 2'b01, S_2 = 2'b11; // State codes
always   @ (posedge clock, negedge reset_b)  
// State transitions (edge sensitive)
if  (reset_b == 0) state <= S_idle;
else  state <= next_state;
// Code next-state logic directly from ASMD chart ( Fig.   8.9   d)
always @ (state, Start, A2, A3) begin 
// Next-state logic (level sensitive)
next_state = S_idle;
case  (state)
S_idle: 
if  (Start) next_state = S_1;  else  next_state = S_idle;
S_1:  
if  (A2 & A3) next_state = S_2;  else  next_state = S_1;
S_2:  
next_state = S_idle;
default : 
next_state = S_idle;
endcase 
end 
// Code output logic directly from ASMD chart ( Fig.   8.9   d)
always   @ (state, Start, A2) begin 
set_E   = 0; // default assignments; assign by exception
clr_E  = 0;
set_F   = 0;
clr_A_F = 0;
incr_A = 0;
case  (state)
S_idle:  
if  (Start) clr_A_F = 1;
S_1:  
begin  incr_A = 1;  if  (A2) set_E = 1;  else clr _E = 1;  end 
S_2:  
set_F = 1;
endcase 
end 
endmodule 
module  Datapath_RTL (A, E, F, set_E, clr_E, set_F, clr_A_F, incr_A, clock);
output   reg  [3: 0] A; 
// register for counter
output reg   
E, F; 
// flags
input   
set_E, clr_E, set_F, clr_A_F, incr_A, clock;
// Code register transfer operations directly from ASMD chart ( Fig.   8.9   (d))
always @ (posedge clock) begin 
if  (set_E)  
E <= 1;
if  (clr_E)  
E <= 0;
if  (set_F)  
F <= 1;
if  (clr_A_F) 
begin  A <= 0; F <= 0;  end 
if  (incr_A)  
A <= A + 1;
end 
endmodule    
Online Convert PowerPoint to PDF file. Best free online export
Online Powerpoint to PDF Converter. Download Free Trial. Convert a PPTX/PPT File to PDF. Just upload your file by clicking on the blue
adding pdf to powerpoint slide; convert pdf to powerpoint
XDoc.Converter for .NET, Support Documents and Images Conversion
Convert Word, Excel and PDF to image. Next Steps. Download Free Trial Download and try Converter for .NET with online support. See Pricing
convert pdf to ppt; drag and drop pdf into powerpoint
Section 8.6  HDL Description of Design Example    385
Testing the Design Description 
The sequence of operations for the design example was investigated in the previous 
section.  Table   8.3    shows the values of  E  and  F  while register  A  is incremented. It is 
instructive to devise a test that checks the circuit to verify the validity of the HDL 
description. The test bench in HDL Example 8.3 provides such a module. (The procedure 
for writing test benches is explained in Section 4.12.) The test module generates signals 
for  Start, clock and  reset_b and checks the results obtained from registers  A, E and  F . 
Initially, the  reset_b  signal is set to 0 to initialize the controller, and  Start  and  clock  are 
set to 0. At time    = 5   , the  reset_b  signal is de‐asserted by setting it to 1, the  Start  input 
is asserted by setting it to 1, and the clock is then repeated for 16 cycles. The  $monitor  
statement displays the values of  A, E and  F  every 10 ns. The output of the simulation is 
listed in the example under the simulation log. Initially, at time    t=0   , the values of the 
registers are unknown, so they are marked with the symbol  x . The first positive clock 
transition, at time = 10, clears  A  and  F but does not affect  E so  E  is unknown at this 
time. The rest of the table is identical to  Table   8.3   . Note that since  Start  is still equal to 
1 at time = 160, the last entry in the table shows that  A  and  F  are cleared to 0, and  E  
does not change and remains at 1. This occurs during the second transition, from  S_idle  
to  S_1 .    
HDL Example 8.3  
// Test bench for design example
'timescale 1 ns / 1 ps
module  t_Design_Example_RTL;
reg   
Start, clock, reset_b;
wire  [3: 0] A;
wire   
E, F;
// Instantiate design example
Design_Example_RTL M0 (A, E, F, Start, clock, reset_b);
// Describe stimulus waveforms
initial  #500  $finish ; 
// Stopwatch
initial 
begin 
reset_b = 0;
Start = 0;
clock = 0;
#5 reset_b = 1; Start = 1;
repeat  (32)
begin 
#5 clock = ~ clock; // Clock generator
end 
C#: How to Use SDK to Convert Document and Image Using XDoc.
This online C# tutorial will tell you how to implement conversion to Tiff file from PDF, Word You may use our converter SDK to easily convert PDF, Word, Excel
images from pdf to powerpoint; convert pdf file to ppt online
RasterEdge XDoc.PowerPoint for .NET - SDK for PowerPoint Document
Add image to specified position on PowerPoint page. Next Steps. Download Free Trial Download and try PDF for .NET with online support. See Pricing
how to convert pdf to ppt for; conversion of pdf to ppt online
386    Chapter 8  Design at the Register Transfer Level
Waveforms produced by a simulation of  Design_Example_RTL  with the test bench 
are shown in  Fig.   8.13   . Numerical values are shown in hexadecimal format. The results 
are annotated to call attention to the relationship between a control signal and the 
operation that it causes to execute. For example, the controller asserts  set_E  for one 
clock cycle  before  the clock edge at which  E  is set to 1. Likewise,  set_F  asserts during 
the clock cycle before the edge at which  F  is set to 1. Also,  clr_A_F  is formed in the 
cycle before  A  and  F  are cleared. A more thorough verification of  Design_Example_
RTL  would confirm that the machine recovers from a reset on the fly (i.e., a reset that 
is asserted randomly after the machine is operating). Note that the signals in the out-
put of the simulation have been listed in groups showing (1)  clock  and  reset_b (2)  Start  
and the status inputs, (3) the state, (4) the control signals, and (5) the datapath regis-
ters.  It is strongly recommended that the state always be displayed because this informa-
tion is essential for verifying that the machine is operating correctly and for debugging 
its description when it is not. For the chosen binary state code,    S_idle = 00
2
= 0
H
,
S_1= 01
2
= 1
H
,and S_= 11
2
= 3
H
.     
Structural Description 
The RTL description of a design consists of procedural statements that determine the 
functional behavior of the digital circuit. This type of description can be compiled by 
end 
initial 
$monitor  ("A = %b E = %b F = %b time = %0d", A, E, F,  $time );
endmodule 
Simulation log:
A = xxxx E = x F = x   time = 0
A = 0000 E = x F = 0 time = 10
A = 0001 E = 0 F = 0 time = 20
A = 0010 E = 0 F = 0 time = 30
A = 0011 E = 0 F = 0 time = 40
A = 0100 E = 0 F = 0 time = 50
A = 0101 E = 1 F = 0 time = 60
A = 0110 E = 1 F = 0 time = 70
A = 0111 E = 1 F = 0 time = 80
A = 1000 E = 1 F = 0 time = 90
A = 1001 E = 0 F = 0 time = 100
A = 1010 E = 0 F = 0 time = 110
A = 1011 E = 0 F = 0 time = 120
A = 1100 E = 0 F = 0 time = 130
A = 1101 E = 1 F = 0 time = 140
A = 1101 E = 1 F = 1 time = 150
A = 0000 E = 1 F = 0 time = 160   
VB.NET PDF - Convert PDF Online with VB.NET HTML5 PDF Viewer
to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Studio .NET HTML5 PDF Viewer PDF Viewer control as well as a powerful online PDF converter.
convert pdf to powerpoint using; pdf into powerpoint
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
XDoc.HTML5 Viewer. view, Annotate,Convert documents online using ASPX. XDoc.HTML5 Viewer. XDoc.Windows Viewer. XDoc.Converter. View & Process. XDoc.PDF. Scanning.
convert pdf to powerpoint with; change pdf to powerpoint on
Section 8.6  HDL Description of Design Example    387
 FIGURE 8.13  
Simulation results for  Design_Example_RTL        
Name
0
0
x
0
1
2
3
4
5
6
7
8
9
a
b
c
0
1
3
0
1
50
100
150
clock
reset_b
Start
A3
A2
state[1: 0]
clr_A_F
clr_E
incr_A
set_F
set_E
A[3: 0]
F
E
d
HDL synthesis tools, from which it is possible to obtain the equivalent gate‐level circuit 
of the design. It is also possible to describe the design by its structure rather than its 
function. A structural description of a design consists of instantiations of components 
that define the circuit elements and their interconnections. In this regard, a structural 
description is equivalent to a schematic diagram or a block diagram of the circuit. Con-
temporary design practice relies heavily on RTL descriptions, but we will present a 
structural description here to contrast the two approaches.  
For convenience, the circuit is again decomposed into two parts: the controller and 
the datapath. The block diagram of  Fig.   8.10    shows the high‐level partition between these 
units, and  Fig.   8.12    provides additional underlying structural details of the controller. 
The structure of the datapath is evident in  Fig.   8.10    and consists of the flip‐flops and the 
four‐bit counter with synchronous clear. The top level of the Verilog description replaces 
Design_Example_RTL,   Controller_RTL and  Datapath_RTL  by  Design_Example_STR,  
Controller_STR and  Datapath_STR respectively. The descriptions of  Controller_STR  
and  Datapath_STR  will be structural. 
HDL Example 8.4 presents the structural description of the design example. It consists 
of a nested hierarchy of modules and gates describing (1) the top‐level module,  Design_
Example_STR (2) the modules describing the controller and the datapath, (3)the modules 
describing the flip‐flops and counters, and (4) gates implementing the logic of the controller. 
For simplicity, the counter and flip‐flops are described by RTL models. 
The top‐level module (see  Fig.   8.10   ) encapsulates the entire design by (1) instantiating 
the controller and the datapath modules, (2) declaring the primary (external) input signals, 
C# HTML5 PDF Viewer SDK to convert and export PDF document to
to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Studio .NET HTML5 PDF Viewer PDF Viewer control as well as a powerful online PDF converter.
how to convert pdf slides to powerpoint presentation; change pdf to powerpoint
DocImage SDK for .NET: Web Document Image Viewer Online Demo
Try Online Demo Now. Please click Browse to upload a file to display in web viewer. Suppported files are Word, Excel, PowerPoint, PDF, Tiff, Dicom and main
convert pdf slides to powerpoint online; convert pdf to powerpoint online
388    Chapter 8  Design at the Register Transfer Level
(3) declaring the output signals, (4) declaring the control signals generated by the controller 
and connected to the datapath unit, and (5) declaring the status signals generated by the 
datapath unit and connected to the controller. The port list is identical to the list used in the 
RTL description. The outputs are declared as  wire  type here because they serve merely to 
connect the outputs of the datapath module to the outputs of the top‐level module, with 
their logic value being determined within the datapath module. 
The control module describes the circuit of  Fig.   8.12   . The outputs of the two flip‐flops 
G1  and  G0  are declared as  wire  data type.  G1  and  G0  cannot be declared as  reg  data 
type because they are outputs of an instantiated  D  flip‐flop.  DG1  and  DG0  are unde-
clared identifiers, i.e., implicit wires. The name of a variable is local to the module or 
procedural block in which it is declared. Nets may not be declared within a procedural 
block (e.g.,  begin  . . .  end ). The rule to remember is that a variable must be a declared 
register type (e.g.,  reg ) if and only if its value is assigned by a procedural statement 
(i.e.,a blocking or nonblocking assignment statement within a procedural block in cyclic 
or single‐pass behavior or in the output of a sequential UDP). The instantiated gates 
specify the combinational part of the circuit. There are two flip‐flop input equations and 
three output equations. The outputs of the flip‐flops  G1  and  G0  and the input equations 
DG1  and  DG0  replace output  Q  and input  D  in the instantiated flip‐flops. The  D  flip‐
flop is then described in the next module. The structure of the datapath unit has direct 
inputs to the  JK  flip‐flops. Note the correspondence between the modules of the HDL 
description and the structures in Figs. 8.9, 8.10, and 8.12.    
HDL Example 8.4  
// Structural description of design example (Figs. 8.9(a), 8.12)
module  Design_Example_STR
(  output   
[3: 0]  A, 
// V 2001 port syntax
output  
E, F,
input  
Start, clock, reset_b
);
Controller_STR M0 (clr_A_F, set_E, clr_E, set_F, incr_A, Start, A[2], A[3], clock, 
reset_b );
Datapath_STR M1 (A, E, F, clr_A_F, set_E, clr_E, set_F, incr_A, clock);
endmodule 
module  Controller_STR
 output  clr_A_F, set_E, clr_E, set_F, incr_A,
input  Start, A2, A3, clock, reset_b
);
wire  
G0, G1;
parameter  
S_idle = 2'b00, S_1 = 2'b01, S_2 = 2'b11;
wire   
w1, w2, w3;
Section 8.6  HDL Description of Design Example    389
not  (G0_b, G0);
not  (G1_b, G1);
buf  (incr_A, w2);
buf  (set_F, G1);
not  (A2_b, A2);
or  (D_G0, w1, w2);
and  (w1, Start, G0_b);
and  (clr_A_F, G0_b, Start);
and  (w2, G0, G1_b);
and  (set_E, w2, A2);
and  (clr_E, w2, A2_b);
and  (D_G1, w3, w2);
and  (w3, A2, A3);
D_flip_flop_AR M0 (G0, D_G0, clock, reset_b);
D_flip_flop_AR M1 (G1, D_G1, clock, reset_b);
endmodule 
// datapath unit
module  Datapath_STR
 output  [3: 0] 
A,
output  
E, F,
input  
clr_A_F, set_E, clr_E, set_F, incr_A, clock
);
JK_flip_flop_2 M0 (E, E_b, set_E, clr_E, clock);
JK_flip_flop_2 M1 (F, F_b, set_F, clr_A_F, clock);
Counter_4 
M2 (A, incr_A, clr_A_F, clock);
endmodule 
// Counter with synchronous clear
module  Counter_4 ( output   reg  [3: 0] A,  input  incr, clear, clock);
always   @ (posedge clock) 
if  (clear)  A <= 0;  else if  (incr) A <= A + 1;
endmodule 
module  D_flip_flop_AR (Q, D, CLK, RST);
output   
Q;
input  
D, CLK, RST;
reg   
Q;
always   @ (posedge CLK, negedge RST) 
if  (RST == 0) Q <= 1'b0;
else  Q <= D;
endmodule 
// Description of JK flip-flop
390    Chapter 8  Design at the Register Transfer Level
The structural description was tested with the test bench that verified the RTL descrip-
tion to produce the results shown in  Fig.   8.13   . The only change necessary is the replacement 
of the instantiation of the example from  Design_Example_RTL  by  Design_Example_STR . 
The simulation results for  Design_Example_STR  matched those for  Design_Example_
RTL . However, a comparison of the two descriptions indicates that the RTL style is easier 
module  JK_flip_flop_2 (Q, Q_not, J, K, CLK);
output   
Q, Q_not;
input  
J, K, CLK;
reg   
Q;
assign  
Q_not = ~Q;
always   @ (posedge CLK) 
case  ({J, K})
2'b00: 
Q <= Q;
2'b01: 
Q <= 1'b0;
2'b10: 
Q <= 1'b1;
2'b11: 
Q <= ~Q;
endcase 
endmodule 
module t_Design_Example_STR; 
reg  Start, clock, reset_b;
wire  [3: 0] A;
wire  
E, F;
// Instantiate design example
Design_Example_STR M0 (A, E, F, Start, clock, reset_b);
// Describe stimulus waveforms
initial  #500  $finish ; 
// Stopwatch
initial 
begin 
reset_b = 0;
Start = 0;
clock = 0;
#5 reset_b = 1; Start = 1;
repeat  (32)
begin 
#5 clock = ~ clock; 
// Clock generator
end 
end 
initial 
$monitor  ("A = %b E = %b F = %b time = %0d", A, E, F,  $time );
endmodule    
Section 8.7  Sequential Binary Multiplier    391
to write and will lead to results faster if synthesis tools are available to automatically 
synthesize the registers, the combinational logic, and their interconnections.   
8.7    SEQUENTIAL BINARY MULTIPLIER 
This section introduces a second design example. It presents a hardware algorithm for 
binary multiplication, proposes the register configuration for its implementation, and 
then shows how to use an ASMD chart to design its datapath and its controller. 
The system we will examine multiplies two unsigned binary numbers. The hardware 
developed in Section 4.7 to execute multiplication resulted in a combinational circuit 
multiplier with many adders and AND gates, and requires large area of silicon as an 
integrated circuit. In contrast, in this section, a more efficient hardware algorithm results 
in a sequential multiplier that uses only one adder and a shift register. The savings in 
hardware and silicon area come about from a trade‐off in the space (hardware)–time 
domain. Aparallel adder uses more hardware, but forms its result in one cycle of the 
clock; a sequential adder uses less hardware, but takes multiple clock cycles to form its 
result. 
The multiplication of two binary numbers is done with paper and pencil by successive 
(i.e., sequential) additions and shifting. The process is best illustrated with a numerical 
example. Let us multiply the two binary numbers 10111 and 10011: 
23             10111  multiplican
19
10011
multiplier
10111
10111
00000
00000
10111
437
110110101
product
The process consists of successively adding and shifting copies of the multiplicand. 
Successive bits of the multiplier are examined, least significant bit first. If the multi-
plier bit is 1, the multiplicand is copied down; otherwise, 0’s are copied down. The 
numbers copied in successive lines are shifted one position to the left from the previ-
ous number. Finally, the numbers are added and their sum forms the product. The 
product obtained from the multiplication of two binary numbers of  n  bits each can 
have up to 2 n  bits. It is apparent that the operations of addition and shifting are 
executed by the algorithm. 
When the multiplication process is implemented with digital hardware, it is conve-
nient to change the process slightly. First, we note that, in the context of synthesizing 
a sequential machine, the add‐and‐shift algorithm for binary multiplication can be 
executed in a single clock cycle or over multiple clock cycles. A choice to form the 
392    Chapter 8  Design at the Register Transfer Level
product in the time span of a single clock cycle will synthesize the circuit of a parallel 
multiplier like the one discussed in Section 4.7. On the other hand, an RTL model of 
the algorithm adds shifted copies of the multiplicand to an accumulated partial prod-
uct. The values of the multiplier, multiplicand, and partial product are stored in regis-
ters, and the operations of shifting and adding their contents are executed under the 
control of a state machine. Among the many possibilities for distributing the effort of 
multiplication over multiple clock cycles, we will consider that in which only one par-
tial product is formed and accumulated in a single cycle of the clock. (One alternative 
would be to use additional hardware to form and accumulate two partial products in 
a clock cycle, but this would require more logic gates and either faster circuits or a 
slower clock.) Instead of providing digital circuits to store and add simultaneously as 
many binary numbers as there are 1’s in the multiplier, it is less expensive to provide 
only the hardware needed to sum two binary numbers and accumulate the partial 
products in a register. Second, instead of shifting the multiplicand to the left, the par-
tial product being formed is shifted to the right. This leaves the partial product and 
the multiplicand in the required relative positions. Third, when the corresponding bit 
of the multiplier is 0, there is no need to add all 0’s to the partial product, since doing 
so will not alter its resulting value. 
Register Configuration 
A block diagram for the sequential binary multiplier is shown in  Fig.   8.14   (a), and the 
register configuration of the datapath is shown in  Fig.   8.14   (b). The multiplicand is 
stored in register  B the multiplier is stored in register  Q and the partial product is 
formed in register  A  and stored in  A  and  Q . A parallel adder adds the contents of 
register  B  to register  A . The  C  flip‐flop stores the carry after the addition. The counter 
P  is initially set to hold a binary number equal to the number of bits in the multiplier. 
This counter is decremented after the formation of each partial product. When the 
content of the counter reaches zero, the product is formed in the double register  A  
and  Q and the process stops. The control logic stays in an initial state until  Start  
becomes 1. The system then performs the multiplication. The sum of  A  and  B  forms 
the  n  most significant bits of the partial product, which is transferred to  A . The output 
carry from the addition, whether 0 or 1, is transferred to  C . Both the partial product 
in  A  and the multiplier in  Q  are shifted to the right. The least significant bit of  A  is 
shifted into the most significant position of  Q the carry from  C  is shifted into the most 
significant position of  A and 0 is shifted into  C . After the shift‐right operation, one 
bit of the partial product is transferred into  Q  while the multiplier bits in  Q  are shifted 
one position to the right. In this manner, the least significant bit of register  Q desig-
nated by  Q[0] holds the bit of the multiplier that must be inspected next. The control 
logic determines whether to add or not on the basis of this input bit. The control logic 
also receives a signal,  Zero from a circuit that checks counter  P  for zero.  Q[0]  and 
Zero  are status inputs for the control unit. The input signal  Start  is an external control 
input. The outputs of the control logic launch the required operations in the registers 
of the datapath unit.  
Documents you may be interested
Documents you may be interested