Section 8.10  Design with Multiplexers    413
To facilitate the evaluation of the multiplexer inputs, we prepare a table showing 
the input conditions for each possible state transition in the ASM chart.  Table   8.8    gives 
this information for the ASM chart of  Fig.   8.20   . There are two transitions from present 
state 00 or 01 and three from present state 10 or 11. The sets of transitions are sepa-
rated by horizontal lines across the table. The input conditions listed in the table are 
obtained from the decision boxes in the ASM chart. For example, from  Fig.   8.20   , we 
note that present state 01 will go to next state 10 if    =1    or to next state 11 if    =0   . 
In the table, we mark these input conditions as  x  and    x′   , respectively. The two columns 
under “multiplexer inputs” in the table specify the input values that must be applied 
to MUX1 and MUX2. The multiplexer input for each present state is determined from 
the input conditions when the next state of the flip‐flop is equal to 1. Thus, after present 
state 01, the next state of    G
1
is always equal to 1 and the next state of    G
0
is equal to 
the complement of  x . Therefore, the input of MUX1 is made equal to 1 and that of 
MUX2 to    x   when the present state of the register is 01. As another example, after pres-
ent state 10, the next state of    G
1
must be equal to 1 if the input conditions are    yz′    or 
yz . When these two Boolean terms are ORed together and then simplified, we obtain 
the single binary variable  y as indicated in the table. The next state of    G
0
is equal to 1 
if the input conditions are    yz = 11   . If the next state of    G
1
remains at 0 after a given 
present state, we place a 0 in the multiplexer input, as shown in present state 00 for 
 FIGURE 8.21  
Control implementation with multiplexers       
D
C
C
D
CLK
0
1
2
3
y
z
y
z
0
1
y
w
x
y
MUX1
s
1
G
1
G
0
s
0
s
1
s
0
0
1
2
3
MUX2
d
0
d
1
d
2
d
3
MUX select
2× 4
decoder
Convert pdf to powerpoint with - 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
convert pdf file to powerpoint; how to convert pdf to ppt for
Convert pdf to powerpoint with - 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
convert pdf into powerpoint; convert pdf file to powerpoint presentation
414    Chapter 8  Design at the Register Transfer Level
MUX1. If the next state of    G
1
is always 1, we place a 1 in the multiplexer input, as 
shown in present state 01 for MUX1. The other entries for MUX1 and MUX2 are 
derived in a similar manner. The multiplexer inputs from the table are then used in the 
control implementation of  Fig.   8.21   . Note that if the next state of a flip‐flop is a function 
of two or more control variables, the multiplexer may require one or more gates in its 
input. Otherwise, the multiplexer input is equal to the control variable, the complement 
of the control variable, 0, or 1.  
Design Example: Count the Number of Ones in a Register 
We will demonstrate the multiplexer implementation of the logic for a control unit by 
means of a design example—a system that is to count the number of 1’s in a word of 
data. The example will also demonstrate the formulation of the ASMD chart and the 
implementation of the datapath subsystem. 
From among various alternatives, we will consider a ones counter consisting of two 
registers  R1  and  R2 and a flip‐flop  E . (A more efficient implementation is considered 
in the problems at the end of the chapter.) The system counts the number of 1’s in the 
number loaded into register  R1  and sets register  R2  to that number. For example, if the 
binary number loaded into  R1  is 10111001, the circuit counts the five 1’s in  R1  and sets 
register  R 2 to the binary count 101. This is done by shifting each bit from register  R1  
one at a time into flip‐flop  E . The value in  E  is checked by the control, and each time it 
is equal to 1, register  R2  is incremented by 1. 
The block diagram of the datapath and controller are shown in  Fig.   8.22   (a). The 
datapath contains registers  R1,   R2 and  E as well as logic to shift the leftmost bit of  R1  
into  E . The unit also contains logic (a NOR gate to detect whether  R1  is 0, but that 
Table 8.8 
Multiplexer Input Conditions 
Present 
State 
Next 
State 
Input 
Condition 
Inputs 
G
1
G
0
G
1
G
0
s  
MUX1 
MUX2 
 0 
 0 
w    
 0 
 1 
 
 
 1 
 0 
 
 1 
 1 
x    
x    
 0 
 0 
y    
 0 
 0 
yz    
 0 
 1 
yz  
yz′+ yzy    
yz  
 1 
 1 
yz    
 1 
 0 
 
yz    
yyz′= yz    
y+yz′=y    
Online Convert PowerPoint to PDF file. Best free online export
Download Free Trial. Convert a PPTX/PPT File to PDF. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
changing pdf to powerpoint; convert pdf to editable powerpoint online
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
how to convert pdf to powerpoint on; convert pdf to powerpoint online no email
415
 FIGURE 8.22  
Block diagram and ASMD chart for count‐of‐ones circuit       
1
S_idle
Ready
1
Start
1
Zero
S_1
Incr_R2
reset_b
S_2
Shift_left
S_3
E
Load_regs
R2<= R2 +1
R1<= data
R2<= all 1s
{E, R1}<={E, R1}<< 1
S_idle
Ready
1
Start
1
Zero
S_1
reset_b
R1<= data
R2<= all 1s
{E, R1}<={E, R1}<< 1
S_2
S_3
E
1
R2<= R2 +1
Status
signals
Controller
Shift_left
Start
reset_b
clock
Datapath
R1
E
Zero
...
...
R2
E
data
count
Incr_R2
Load_regs
Shift_left
Ready
(a)
(b)
(c)
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Convert PDF to Image; Convert Word to PDF; Convert Excel to PDF; Convert PowerPoint to PDF; Convert Image to PDF; Convert Jpeg to PDF;
how to convert pdf to powerpoint in; embed pdf into powerpoint
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Convert PDF to HTML. |. Home ›› XDoc.PDF ›› VB.NET PDF: PDF to HTML. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
pdf to powerpoint conversion; images from pdf to powerpoint
416    Chapter 8  Design at the Register Transfer Level
detail is omitted in the figure). The external input signal  Start  launches the operation 
of the machine;  Ready  indicates the status of the machine to the external environment. 
The controller has status input signals  E  and  Zero  from the datapath. These signals 
indicate the contents of a register holding the MSB of the data word and the condition 
that the data word is 0, respectively.  E  is the output of the flip‐flop.  Zero  is the output 
of a circuit that checks the contents of register  R1  for all 0’s. The circuit produces an 
output  Zero  = 1 when  R1  is equal to 0 (i.e., when  R1  is empty of 1’s).  
A preliminary ASMD chart showing the state sequence and the register operations 
is illustrated in  Fig.   8.22   (b), and the complete ASMD chart in  Fig.   8.22   (c). Asserting 
Start  with the controller in  S_idle  transfers the state to  S_1 concurrently loads reg-
ister  R1  with the binary data word, and fills the cells of  R2  with 1’s. Note that incre-
menting a number with all 1’s in a counter register produces a number with all 0’s. 
Thus, the first transition from  S_1  to  S_2  will clear  R2 . Subsequent transitions will 
have  R2  holding a count of the bits of data that have been processed. The content of 
R1 as indicated by  Zero will also be examined in  S_1 . If  R1  is empty,  Zero  = 1, and 
the state returns to  S_idle where it asserts  Ready . In state  S_1,   Incr_R2  is asserted 
to cause the datapath unit to increment  R2  at each clock pulse. If  R1  is not empty of 
1’s, then  Zero  = 0, indicating that there are some 1’s stored in the register. The num-
ber in  R1  is shifted and its leftmost bit is transferred into  E . This is done as many 
times as necessary, until a 1 is transferred into  E . For every 1 detected in  E register 
R2  is incremented and register  R1  is checked again for more 1’s. The major loop is 
repeated until all the 1’s in  R1  are counted. Note that the state box of  S_3  has no 
register operations, but the block associated with it contains the decision box for  E . 
Note also that the serial input to shift register  R1  must be equal to 0 because we don’t 
want to shift external 1’s into  R1 . The register  R1  in  Fig.  8.22   (a) is a shift register. 
Register  R2  is a counter with parallel load. The multiplexer input conditions for the 
control are determined from  Table   8.9   . The input conditions are obtained from the 
ASMD chart for each possible binary state transition. The four states are assigned 
Table 8.9 
Multiplexer Input Conditions for Design Example 
Present 
State 
Next 
State 
Input 
Conditions 
Multiplexer 
Inputs 
G
1
G
0
G
1
G
0
MUX1 
MUX2 
 0 
 0 
Start    
 0 
 1 
Start  
Start  
 1 
 0 
Zero  
 1 
 0 
Zero    
Zero    
 0 
 1 
None 
 1 
 0 
E    
 
E    
 
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. C# Demo: Convert PowerPoint to PDF Document. Add references: RasterEdge.Imaging.Basic.dll.
how to convert pdf to ppt online; pdf to ppt
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
Convert PDF to HTML. |. C#.NET PDF SDK - Convert PDF to HTML in C#.NET. How to Use C# .NET XDoc.PDF SDK to Convert PDF to HTML Webpage in C# .NET Program.
convert pdf to powerpoint slide; convert pdf to powerpoint
Section 8.10  Design with Multiplexers    417
binary values 00 through 11. The transition from present state 00 depends on  Start . 
The transition from present state 01 depends on  Zero and the transition from pres-
ent state 11 on  E . Present state 10 goes to next state 11 unconditionally. The values 
under MUX1 and MUX2 in the table are determined from the Boolean input condi-
tions for the next state of    G
1
and    G
0
, respectively. 
The control implementation of the design example is shown in  Fig.   8.23   . This is a 
three‐level implementation, with the multiplexers in the first level. The inputs to the 
multiplexers are obtained from  Table   8.9   . The Verilog description in HDL Example 8.8 
instantiates structural models of the controller and the datapath. The listing of code 
includes the lower level modules implementing their structures. Note that the datapath 
unit does not have a reset signal to clear the registers, but the models for the flip‐flop, 
shift register, and counter have an active‐low reset. This illustrates the use of Verilog 
data type  supply1  to hardwire those ports to logic value 1 in their instantiation within 
Datapath_STR . Note also that the test bench uses hierarchical de‐referencing to access 
the state of the controller to make the debug and verification tasks easier, without hav-
ing to alter the module ports to provide access to the internal signals. Another detail to 
observe is that the serial input to the shift register is hardwired to 0. The lower level 
models are described behaviorally for simplicity.       
 FIGURE 8.23  
Control implementation for count‐of‐ones circuit       
Mux_1
Mux_2
2× 4 Decoder
C
D
C
D
0
Zero
1
E
s
1
s
0
s
1
s
0
Start
0
1
E
clock
reset_b
G
1
G
0
Start
Incr_R2
Shift_left
0
1
0
2
0
3
1
2
3
1
2
3
Ready
Load_regs
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
convert pdf to powerpoint online; convert pdf into powerpoint
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
VB.NET PDF - Convert PDF to TIFF Using VB in VB.NET. Free VB.NET Guide to Render and Convert PDF Document to TIFF in Visual Basic Class.
converting pdf to powerpoint; image from pdf to ppt
418    Chapter 8  Design at the Register Transfer Level
HDL Example 8.8 (Ones Counter)  
module  Count_Ones_STR_STR (count, Ready, data, Start, clock, reset_b);
// Mux – decoder implementation of control logic
// controller is structural
// datapath is structural
parameter  R1_size = 8, R2_size = 4;
output  
[R2_size -1: 0] count;
output  
Ready;
input  [R1_size -1: 0] 
data;
input  
Start, clock, reset_b;
wire  
Load_regs, Shift_left, Incr_R2, Zero, E;
Controller_STR M0 (Ready, Load_regs, Shift_left, Incr_R2, Start, E, Zero, clock, reset_b);
Datapath_STR M1 (count, E, Zero, data, Load_regs, Shift_left, Incr_R2, clock);
endmodule 
module  Controller_STR (Ready, Load_regs, Shift_left, Incr_R2, Start, E, Zero, clock, 
reset_b);
output   
Ready;
output  
Load_regs, Shift_left, Incr_R2;
input  
Start;
input  
E, Zero;
input  
clock, reset_b;
supply0  
GND;
supply1  
PWR;
parameter  
S0 = 2'b00, S1 = 2'b01, S2 = 2'b10, S3 = 2'b11; // Binary code
wire  
Load_regs, Shift_left, Incr_R2;
wire  
G0, G0_b, D_in0, D_in1, G1, G1_b;
wire  
Zero_b = ~Zero;
wire  
E_b = ~E;
wire  [1: 0] 
select = {G1, G0};
wire  [0: 3] 
Decoder_out;
assign  
Ready = ~Decoder_out[0];
assign   
Incr_R2 = ~Decoder_out[1];
assign   
Shift_left = ~Decoder_out[2];
and   
(Load_regs, Ready, Start);
mux_4x1_beh 
Mux_1 
(D_in1, GND, Zero_b, PWR, E_b, select);
mux_4x1_beh 
Mux_0 
(D_in0, Start, GND, PWR, E, select);
D_flip_flop_AR_b 
M1 
(G1, G1_b, D_in1, clock, reset_b);
D_flip_flop_AR_b 
M0 
(G0, G0_b, D_in0, clock, reset_b);
decoder_2x4_df 
M2 
(Decoder_out, G1, G0, GND);
endmodule 
Section 8.10  Design with Multiplexers    419
module  Datapath_STR (count, E, Zero, data, Load_regs, Shift_left, Incr_R2, clock);
parameter  
R1_size = 8, R2_size = 4;
output  [R2_size -1: 0] count;
output  
E, Zero;
input  [R1_size -1: 0] 
data;
input  
Load_regs, Shift_left, Incr_R2, clock;
wire  [R1_size -1: 0] 
R1;
wire  
Zero;
supply0  
Gnd;
supply1  
Pwr;
assign  Zero = (R1 == 0); 
// implicit combinational logic
Shift_Reg 
M1 
(R1, data, Gnd, Shift_left, Load_regs, clock, Pwr);
Counter 
M2 
(count, Load_regs, Incr_R2, clock, Pwr);
D_flip_flop_AR 
M3 
(E, w1, clock, Pwr);
and 
(w1, R1[R1_size - 1], Shift_left);
endmodule 
module  Shift_Reg (R1, data, SI_0, Shift_left, Load_regs, clock, reset_b);
parameter  R1_size = 8;
output  
[R1_size -1: 0] 
R1;
input  
[R1_size -1: 0] 
data;
input  
SI_0, Shift_left, Load_regs;
input  
clock, reset_b;
reg  
[R1_size -1: 0] 
R1;
always   @  ( posedge  clock,  negedge  reset_b)
if  (reset_b == 0) R1 <= 0;
else   begin 
if  (Load_regs) R1 <= data;  else 
if  (Shift_left) R1 <= {R1[R1_size -2: 0], SI_0};  end 
endmodule 
module  Counter (R2, Load_regs, Incr_R2, clock, reset_b);
parameter  
R2_size = 4;
output  [R2_size -1: 0] 
R2;
input  
Load_regs, Incr_R2;
input   
clock, reset_b;
reg  
[R2_size -1: 0] 
R2;
always  @ (posedge clock, negedge reset_b)
if  (reset_b == 0) R2 <= 0;
else   if  (Load_regs) R2 <= {R2_size {1'b1}};  
// Fill with 1
else   if  (Incr_R2 == 1) R2 <= R2 + 1;
endmodule 
module  D_flip_flop_AR (Q, D, CLK, RST_b);
output   
Q;
input  
D, CLK, RST_b;
420    Chapter 8  Design at the Register Transfer Level
reg   
Q;
always   @  ( posedge  CLK,  negedge  RST_b)
if  (RST_b == 0) Q <= 1'b0;
else  Q <= D;
endmodule 
module  D_flip_flop_AR_b (Q, Q_b, D, CLK, RST_b);
output   
Q, Q_b;
input  
D, CLK, RST_b;
reg   
Q;
assign  
Q_b = ~Q;
always   @  ( posedge  CLK,  negedge  RST_b)
if  (RST_b == 0) Q <= 1'b0;
else  Q <= D; 
endmodule 
// Behavioral description of four-to-one line multiplexer
// Verilog 2005 port syntax
module  mux_4x1_beh
output reg  
m_out,
input  
in_0, in_1, in_2, in_3,
input [1: 0]  
select
);
always  @ (in_0, in_1, in_2, in_3, select)  // Verilog 2005 syntax
case  (select)
2'b00: 
m_out = in_0;
2'b01: 
m_out = in_1;
2'b10: 
m_out = in_2;
2'b11: 
m_out = in_3;
endcase 
endmodule 
//  Dataflow description of two-to-four-line decoder
// See Fig. 4.19. Note: The figure uses symbol E, but the
// Verilog model uses enable to indicate functionality clearly.
module  decoder_2x4_df (D, A, B, enable);
output  
[0: 3] D;
input  
A, B;
input  
enable;
assign  
D[0] = !(!A && !B && !enable),
D[1] = !(!A && B && !enable),
D[2] = !(A && !B && !enable),
D[3] = !(A && B && !enable);
endmodule 
module  t_Count_Ones;
Section 8.10  Design with Multiplexers    421
parameter  R1_size = 8, R2_size = 4;
wire  
[R2_size -1: 0] 
R2;
wire  
[R2_size -1: 0] 
count;
wire  
Ready;
reg  
[R1_size -1: 0] 
data;
reg  
Start, clock, reset_b;
wire 
[1: 0] 
state; 
// Use only for debug
assign  state = {M0.M0.G1, M0.M0.G0};
Count_Ones_STR_STR M0 (count, Ready, data, Start, clock, reset_b);
initial  #650  $finish ;
initial   begin  clock = 0; #5  forever  #5 clock = ~clock;  end 
initial   fork 
#1 reset_b = 1;
#3 reset_b = 0;
#4 reset_b = 1;
#27 reset_b = 0;
#29 reset_b = 1;
#355 reset_b = 0;
#365 reset_b = 1;
#4 data = 8'Hff;
#145 data = 8'haa;
# 25 Start = 1;
# 35 Start = 0;
#55 Start = 1;
#65 Start = 0;
#395 Start = 1;
#405 Start = 0;
join 
endmodule    
Testing the Ones Counter 
The test bench in HDL Example 8.8 was used to produce the simulation results in 
Fig.  8.24   . Annotations have been added for clarification. In  Fig.   8.24   (a),  reset_b  is toggled 
low at t = 3 to drive the controller into  S_idle but with  Start  not yet having an assigned 
value. (The default is x.) Consequently, the controller enters an unknown state (the 
shaded waveform) at the next clock, and its outputs are unknown.
4
When  reset_b  is 
asserted (low) again at  t  = 27, the state enters  S_idle . Then, with  Start  = 1 at the first clock 
after  reset_b  is de‐asserted, (1) the controller enters  S_1 (2)  Load_regs  causes  R1  to be 
set to the value of  data namely,    8′Hff   , and (3)  R2  is filled with 1’s. At the next clock,  R2  
4 Remember, this simulation is in Verilog’s four‐valued logic system. In actual hardware, the values will be 0 or 1. 
Without a known applied value for the inputs, the next state and outputs will be undetermined, even after the reset 
signal has been applied.
422    Chapter 8  Design at the Register Transfer Level
starts counting from 0.  Shift_left  is asserted while the controller is in state  S_2 and 
incr_R2  is asserted while the controller is in state  S_1 . Notice that  R2  is incremented in 
the next cycle after  incr_R2  is asserted. No output is asserted in state  S_3 . The counting 
sequence continues in  Fig.   8.24   (b) until  Zero  is asserted, with  E  holding the last 1 of the 
data word. The next clock produces  count  = 8, and  state  returns to  S_idle . (Additional 
testing is addressed in the problems at the end of the chapter.)      
8.11     RACE‐FREE DESIGN (SOFTWARE RACE 
CONDITIONS) 
Once a circuit has been synthesized, either manually or with tools, it is necessary to 
verify that the simulation results produced by the HDL behavioral model match those of 
the netlist of the gates (standard cells) of the physical circuit. It is important to resolve any 
 FIGURE 8.24  
Simulation waveforms for count‐of‐ones circuit             
R2 filled with 1s
(a)
reset_b asserted (low), but
Start unknown
Machine begins
counting
R1 loaded with data
Name
0
30
60
90
120
clock
reset_b
Start
Zero
E
state[1: 0]
state[1]
state[0]
Ready
Load_regs
Shift_left
Incr_R2
data[7: 0]
R1[7: 0]
E
R2[3: 0]
count[3: 0]
x
0
X
x
x
xx
0
1
f
f
ff
2
3
0
1
0
2
fe
3
1
1
1
2
fc
3
2
2
f8
ff
1
Documents you may be interested
Documents you may be interested