Section 6.6  HDL for Registers and Counters    283
complemented output of the rightmost flip‐flop to the input of the leftmost flip‐flop. 
The register shifts its contents once to the right with every clock pulse, and at the same 
time, the complemented value of the  E  flip‐flop is transferred into the  A  flip‐flop. 
Starting from a cleared state, the switch‐tail ring counter goes through a sequence of 
eight states, as listed in  Fig.   6.18   (b). In general, a  k ‐bit switch‐tail ring counter will go 
through a sequence of 2 k  states. Starting from all 0’s, each shift operation inserts 1’s from 
the left until the register is filled with all 1’s. In the next sequences, 0’s are inserted from 
the left until the register is again filled with all 0’s. 
A Johnson counter is a  k ‐bit switch‐tail ring counter with 2 k  decoding gates to pro-
vide outputs for 2 k  timing signals. The decoding gates are not shown in  Fig.   6.18   , but are 
specified in the last column of the table. The eight AND gates listed in the table, when 
connected to the circuit, will complete the construction of the Johnson counter. Since 
each gate is enabled during one particular state sequence, the outputs of the gates gen-
erate eight timing signals in succession. 
The decoding of a  k ‐bit switch‐tail ring counter to obtain 2 k  timing signals follows a 
regular pattern. The all‐0’s state is decoded by taking the complement of the two extreme 
flip‐flop outputs. The all‐1’s state is decoded by taking the normal outputs of the two extreme 
flip‐flops. All other states are decoded from an adjacent 1, 0 or 0, 1 pattern in the sequence. 
For example, sequence 7 has an adjacent 0, 1 pattern in flip‐flops  B  and  C . The decoded 
output is then obtained by taking the complement of  B  and the normal output of  C,  or    BC.    
One disadvantage of the circuit in  Fig.   6.18   (a) is that if it finds itself in an unused state, 
it will persist in moving from one invalid state to another and never find its way to a valid 
state. The difficulty can be corrected by modifying the circuit to avoid this undesirable 
condition. One correcting procedure is to disconnect the output from flip‐flop  B  that goes 
to the  D  input of flip‐flop  C  and instead enable the input of flip‐flop  C  by the function 
D
C
=(AC)B   
where    D
C
is the flip‐flop input equation for the  D  input of flip‐flop  C.  
Johnson counters can be constructed for any number of timing sequences. The num-
ber of flip‐flops needed is one‐half the number of timing signals. The number of decod-
ing gates is equal to the number of timing signals, and only two‐input gates are needed.   
6.6    HDL FOR REGISTERS AND COUNTERS 
Registers and counters can be described in Verilog at either the behavioral or the struc-
tural level. Behavioral modeling describes only the operations of the register, as pre-
scribed by a function table, without a preconceived structure. A structural‐level 
description shows the circuit in terms of a collection of components such as gates, flip‐
flops, and multiplexers. The various components are instantiated to form a hierarchical 
description of the design similar to a representation of a multilevel logic diagram. The 
examples in this section will illustrate both types of descriptions. Both are useful. When 
a machine is complex, a hierarchical description creates a physical partition of the 
machine into simpler and more easily described units. 
Pdf to ppt converter online - 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 to powerpoint slide; how to change pdf to powerpoint on
Pdf to ppt converter online - 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
pdf conversion to powerpoint; image from pdf to ppt
284    Chapter 6  Registers and Counters
Shift Register 
The universal shift register presented in Section 6.2 is a bidirectional shift register with a 
parallel load. The four clocked operations that are performed with the register are speci-
fied in  Table   6.6   . The register also can be cleared asynchronously. Our chosen name for a 
behavioral description of the four‐bit universal shift register shown in  Fig.   6.7   (a), the name 
Shift_Register_4_beh signifies the behavioral model of the internal detail of the top‐level 
block diagram symbol and distinguishes that model from a structural one. The behavioral 
model is presented in HDL Example 6.1, and the structural model is given in HDL Exam-
ple 6.2. The top‐level block diagram symbol in  Fig.   6.7   (a) indicates that the four‐bit uni-
versal shift register has two selection inputs ( s1  s0 ), two serial inputs ( shift_left, shift_right ), 
for controlling the shift register, two serial datapath inputs (MSB_in and LSB_in), a four‐
bit parallel input ( I_par ), and a four‐bit parallel output ( A_par ). The elements of vector 
I_par[3: 0]  correspond to the bits I
3
, . . . , I
0
in  Fig.   6.7   , and similarly for  A_par[3: 0].  
The  always  block describes the five operations that can be performed with the register. 
The  Clear  input clears the register asynchronously with an active‐low signal.  Clear  
must be high for the register to respond to the positive edge of the clock. The four 
clocked operations of the register are determined from the values of the two select 
inputs in the  case  statement. ( s1  and  s0  are concatenated into a two‐bit vector and are used 
as the expression argument of the  case  statement.) The shifting operation is specified by the 
concatenation of the serial input and three bits of the register. For example, the statement   
A_par <= {MSB_in, A_par [3: 1]}  
specifies a concatenation of the serial data input for a right shift operation ( MSB_in ) 
with bits  A_par[3: 1] of the output data bus . A reference to a contiguous range of bits 
within a vector is referred to as a  part select . The four‐bit result of the concatenation is 
transferred to register  A_par [3: 0]  when the clock pulse triggers the operation. This 
transfer produces a shift‐right operation and updates the register with new information. 
The shift operation overwrites the contents of  A_par[0]  with the contents of  A_par[1] . 
Note that only the functionality of the circuit has been described, irrespective of any 
particular hardware. A synthesis tool would create a netlist of ASIC cells to implement 
the shift register in the structure of  Fig.   6.7   (b). 
HDL Example 6.1 (Universal Shift Register‐Behavioral Model) 
// Behavioral description of a 4-bit universal shift register
//  Fig.   6.7    and  Table   6.3   
module  Shift_Register_4_beh ( 
// V2001, 2005
output  reg 
[3: 0] A_par, 
// Register output
input  
[3: 0] I_par, 
// Parallel input
input  
s1, s0,  
// Select inputs
MSB_in, LSB_in, 
// Serial inputs
CLK, Clear_b 
// Clock and Clear
);
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
how to convert pdf slides to powerpoint presentation; convert pdf into powerpoint
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
Our XDoc.Converter for .NET can help you to easily achieve high performance PDF conversion from Microsoft PowerPoint (.ppt and .pptx).
convert pdf file to powerpoint; change pdf to powerpoint
Section 6.6  HDL for Registers and Counters    285
Variables of type reg retain their value until they are assigned a new value by an 
assignment statement. Consider the following alternative case statement for the shift 
register model: 
always @  ( posedge  CLK,  negedge  Clear_b) // V2001, 2005
if  (Clear_b == 0) A_par <= 4’b0000;
else 
case  ({s1, s0})
2'b00: A_par <= A_par; 
// No change
2'b01: A_par <= {MSB_in, A_par[3: 1]}; 
// Shift right
2'b10: A_par <= {A_par[2: 0], LSB_in}; 
// Shift left
2'b11: A_par <= I_par; 
// Parallel load of input
endcase 
endmodule  
case  ({s1, s0})
// 2'b00: A_par <= A_par; 
// No change
2'b01: A_par <= {MSB_in, A_par [3: 1]}; // Shift right
2'b10: A_par <= {A_par [2: 0], LSB_in}; 
// Shift left
2'b11: A_par <= I_par; 
// Parallel load of input
endcase 
Without the case item    2′b00,    the  case  statement would not find a match between 
5
s1s0
6
and the case items, so register  A_par  would be left unchanged. 
A structural model of the universal shift register can be described by referring to the 
logic diagram of  Fig.   6.7   (b). The diagram shows that the register has four multiplexers and 
four  D  flip‐flops. A mux and flip‐flop together are modeled as a stage of the shift register. 
The stage is a structural model, too, with an instantiation and interconnection of a module 
for a mux and another for a  D  flip‐flop. For simplicity, the lowest‐level modules of the 
structure are behavioral models of the multiplexer and flip‐flop. Attention must be paid 
to the details of connecting the stages correctly. The structural description of the register 
is shown in HDL Example 6.2. The top‐level module declares the inputs and outputs and 
then instantiates four copies of a stage of the register. The four instantiations specify the 
interconnections between the four stages and provide the detailed construction of the 
register as specified in the logic diagram. The behavioral description of the flip‐flop uses 
a single edge‐sensitive cyclic behavior (an  always  block). The assignment statements use 
the nonblocking assignment operator (<=) the model of the mux employs a single level‐
sensitive behavior, and the assignments use the blocking assignment operator (=). 
HDL Example 6.2 (Universal Shift Register‐Structural Model) 
// Structural description of a 4-bit universal shift register (see  Fig.   6.7   )
module  Shift_Register_4_str ( 
// V2001, 2005
output  [3: 0] A_par, 
// Parallel output
input  [3: 0] I_par, 
// Parallel input
How to C#: Convert PDF, Excel, PPT to Word
How to for XImage. All Formats. XDoc.HTML5 Viewer. XDoc.Windows Viewer. XDoc.Converter. View & Process. XImage.Raster. How to C#: Convert PDF, Excel, PPT to Word
convert pdf back to powerpoint; how to convert pdf into powerpoint presentation
VB.NET PowerPoint: Process & Manipulate PPT (.pptx) Slide(s)
This VB.NET online tutorial page can help you processing control add-on can do PPT creating, loading powerful & profession imaging controls, PDF document, image
add pdf to powerpoint slide; how to convert pdf into powerpoint on
286    Chapter 6  Registers and Counters
input  
s1, s0, 
// Mode select
input  
MSB_in, LSB_in, CLK, Clear_b 
// Serial inputs, clock, clear
);
// bus for mode control
assign  [1:0] select = {s1, s0};
// Instantiate the four stages
stage ST0 (A_par[0], A_par[1], LSB_in, I_par[0], A_par[0], select, CLK, Clear_b);
stage ST1 (A_par[1], A_par[2], A_par[0], I_par[1], A_par[1], select, CLK, Clear_b);
stage ST2 (A_par[2], A_par[3], A_par[1], I_par[2], A_par[2], select, CLK, Clear_b);
stage ST3 (A_par[3], MSB_in, A_par[2], I_par[3], A_par[3], select, CLK, Clear_b);
endmodule 
// One stage of shift register
module  stage (i0, i1, i2, i3, Q, select, CLK, Clr_b);
input  
i0, 
// circulation bit selection
i1, 
// data from left neighbor or serial input for shift-right
i2, 
// data from right neighbor or serial input for shift-left
i3; 
// data from parallel input
output  
Q;
input  [1: 0] select; 
// stage mode control bus
input  
CLK, Clr_b; // Clock, Clear for fl ip-fl ops
wire  
mux_out;
// instantiate mux and fl ip-fl op
Mux_4_x_1 M0 
(mux_out, i0, i1, i2, i3, select);
D_fl ip_fl op M1 
(Q, mux_out, CLK, Clr_b);
endmodule 
// 4x1 multiplexer 
// behavioral model
module  Mux_4_x_1 (mux_out, i0, i1, i2, i3, select);
output  
mux_out;
input  
i0, i1, i2, i3;
input  [1: 0] select;
reg  
mux_out;
always  @ (select, i0, i1, i2, i3)
case  (select)
2'b00: 
mux_out = i0;
2'b01: 
mux_out = i1;
2'b10: 
mux_out = i2;
2'b11: 
mux_out = i3;
endcase 
endmodule 
VB.NET PowerPoint: Convert PowerPoint to BMP Image with VB PPT
NET PPT document converter allows for PowerPoint conversion to both images and documents, like rendering PowerPoint to BMP, GIF, PNG, TIFF, JPEG, SVG or PDF.
convert pdf pages into powerpoint slides; picture from pdf to powerpoint
How to C#: Convert Word, Excel and PPT to PDF
All Formats. XDoc.HTML5 Viewer. XDoc.Windows Viewer. XDoc.Converter. View & Process. XImage.Raster. Adobe PDF. How to C#: Convert Word, Excel and PPT to PDF.
table from pdf to powerpoint; convert pdf file to powerpoint presentation
Section 6.6  HDL for Registers and Counters    287
The above examples presented two descriptions of a universal shift register to illus-
trate the different styles for modeling a digital circuit. A simulation should verify that 
the models have the same functionality. In practice, a designer develops only the behav-
ioral model, which is then synthesized. The function of the synthesized circuit can be 
compared with the behavioral description from which it was compiled. Eliminating the 
need for the designer to develop a structural model produces a huge improvement in 
the efficiency of the design process.  
Synchronous Counter 
HDL Example 6.3 presents  Binary_Counter_4_Par_Load,  a behavioral model of the 
synchronous counter with a parallel load from  Fig.   6.14   .  Count  Load  CLK and  Clear_b  
are inputs that determine the operation of the counter according to the function speci-
fied in  Table   6.6   . The counter has four data inputs, four data outputs, and a carry output. 
The internal data lines ( I3  I2  I1  I0 ) are bundled as  Data_in[3: 0]  in the behavioral 
model. Likewise, the register that holds the bits of the count ( A3  A2  A1  A0 ) is  A_
count[3: 0].  It is good practice to have identifiers in the HDL model of a circuit corre-
spond exactly to those in the documentation of the model. That is not always feasible, 
however, if the circuit‐level identifiers are those found in a handbook, for they are often 
short and cryptic and do not exploit the text that is available with an HDL. The top‐level 
block diagram symbol in  Fig.   6.14   (a) serves as an interface between the names used in 
a circuit diagram and the expressive names that can be used in the HDL model. The 
carry output  C_out  is generated by a combinational circuit and is specified with an  assign  
statement.    C_out= 1   when the count reaches 15 and the counter is in the count state. 
Thus,    C_out =1   if    Count = 1, Load= 0,    and    A= 1111;    otherwise    C_out= 0.    The 
always  block specifies the operation to be performed in the register, depending on the 
values of  Clear_b,   Load,  and  Count . A 0 (active‐low signal) at  Clear_b  resets  A  to 0. 
Otherwise, if    Clear_=1,    one out of three operations is triggered by the positive edge 
of the clock. The  if  else if and else statements establish a precedence among the control 
signals  Clear  Load and  Count  corresponding to the specification in  Table   6.6   .  Clear_b  
overrides  Load  and  Count ;  Load  overrides  Count . A synthesis tool will produce the 
circuit of  Fig.   6.14   (b) from the behavioral model.  
// Behavioral model of D fl ip-fl op
module  D_fl ip_fl op (Q, D, CLK, Clr_b);
output  
Q;
input  
D, CLK, Clr;
reg  
Q;
always @  ( posedge  CLK,  negedge  Clr_b)
if  (!Clr_b) Q <= 1'b0; else Q <= D;
endmodule  
VB.NET PowerPoint: Read & Scan Barcode Image from PPT Slide
VB.NET PPT PDF-417 barcode scanning SDK to detect PDF-417 barcode image from PowerPoint slide. VB.NET APIs to detect and decode
convert pdf into powerpoint online; convert pdf pages to powerpoint slides
VB.NET PowerPoint: Use .NET Converter to Convert PPT to Raster
VB.NET PPT to raster images converter very well. Check PPT to PNG image converting sample code in VB powerful & profession imaging controls, PDF document, image
add pdf to powerpoint; convert pdf document to powerpoint
288    Chapter 6  Registers and Counters
Ripple Counter 
The structural description of a ripple counter is shown in HDL Example 6.4. The first 
module instantiates four internally complementing flip‐flops defined in the second mod-
ule as  Comp_D_flip_flop (Q, CLK, Reset) . The clock (input  CLK ) of the first flip‐flop 
is connected to the external control signal  Count . ( Count  replaces  CLK  in the port list 
of instance  F0 .) The clock input of the second flip‐flop is connected to the output of the 
first. ( A0  replaces  CLK  in instance  F1 .) Similarly, the clock of each of the other flip‐flops 
is connected to the output of the previous flip‐flop. In this way, the flip‐flops are chained 
together to create a ripple counter as shown in  Fig.   6.8   (b). 
The second module describes a complementing flip‐flop with delay. The circuit of a 
complementing flip‐flop is constructed by connecting the complement output to the  D  
input. A reset input is included with the flip‐flop in order to be able to initialize the 
counter; otherwise the simulator would assign the unknown value (x) to the output of 
the flip‐flop and produce useless results. The flip‐flop is assigned a delay of two time 
units from the time that the clock is applied to the time that the flip‐flop complements 
its output. The delay is specified by the statement    6= = #2∼Q.    Notice that the delay 
operator is placed to the right of the nonblocking assignment operator. This form of 
delay, called  intra‐assignment delay has the effect of postponing the assignment of the 
complemented value of  Q  to  Q . The effect of modeling the delay will be apparent in 
the simulation results. This style of modeling might be useful in simulation, but it is to 
be avoided when the model is to be synthesized. The results of synthesis depend on the 
ASIC cell library that is accessed by the tool, not on any propagation delays that might 
appear within the model that is to be synthesized.  
HDL Example 6.3 (Synchronous Counter) 
// Four-bit binary counter with parallel load (V2001, 2005)
// See  Figure   6.14    and  Table   6.6   
module  Binary_Counter_4_Par_Load (
output reg  [3: 0] 
A_count, 
// Data output
output  
C_out, 
// Output carry
input  [3: 0] 
Data_in, 
// Data input
input 
Count, 
// Active high to count
Load, 
// Active high to load
CLK, 
// Positive-edge sensitive
Clear_b 
// Active low
);
assign  C_out = Count && (~Load) && (A_count == 4'b1111);
always  @ ( posedge  CLK,  negedge  Clear_b)
if  (~Clear_b) 
A_count <= 4'b0000;
else if  (Load) 
A_count <= Data_in;
else if  (Count) 
A_count <= A_count + 1'b1;
else  
A_count <= A_count;  // redundant statement
endmodule  
Section 6.6  HDL for Registers and Counters    289
HDL Example 6.4 (Ripple Counter) 
// Ripple counter (See  Fig.   6.8   (b))
'timescale 1ns / 100 ps
module  Ripple_Counter_4bit (A3, A2, A1, A0, Count, Reset);
output  A3, A2, A1, A0;
input  Count, Reset;
// Instantiate complementing fl ip-fl op
Comp_D_fl ip_fl op F0 (A0, Count, Reset);
Comp_D_fl ip_fl op F1 (A1, A0, Reset);
Comp_D_fl ip_fl op F2 (A2, A1, Reset);
Comp_D_fl ip_fl op F3 (A3, A2, Reset);
endmodule 
// Complementing fl ip-fl op with delay
// Input to D fl ip-fl op = Q'
module  Comp_D_fl ip_fl op (Q, CLK, Reset);
output  Q;
input  CLK, Reset;
reg  
Q;
always @  ( negedge  CLK,  posedge  Reset)
if  (Reset) Q <= 1'b0;
else  Q <= #2 ~Q;  
// intra-assignment delay
endmodule 
// Stimulus for testing ripple counter
module  t_Ripple_Counter_4bit;
reg  
Count;
reg  
Reset;
wire  
A0, A1, A2, A3;
// Instantiate ripple counter
Ripple_Counter_4bit M0 (A3, A2, A1, A0, Count, Reset);
always 
#5 Count = ~Count;
initial 
begin 
Count = 1'b0;
Reset = 1'b1;
#4 Reset = 1'b0;
end 
initial  #170  $finish; 
endmodule  
290    Chapter 6  Registers and Counters
The test bench module in HDL Example 6.4 provides a stimulus for simulating and 
verifying the functionality of the ripple counter. The  always  statement generates a free‐ 
running clock with a cycle of 10 time units. The flip‐flops trigger on the negative edge of 
the clock, which occurs at    t= 10, 20, 30,    and every 10 time units thereafter. The waveforms 
obtained from this simulation are shown in  Fig.   6.19   . The control signal  Count  goes negative 
every 10 ns.  A0  is complemented with each negative edge of  Count but is delayed by 2 ns. 
Each flip‐flop is complemented when its previous flip‐flop goes from 1 to 0. After    t= 80 ns,    
all four flip‐flops complement because the counter goes from 0111 to 1000. Each output is 
delayed by 2 ns, and because of that,  A 3 goes from 0 to 1 at    = 88 ns    and from 1 to 0 at 
168 ns. Notice how the propagation delays accumulate to the last bit of the counter, result-
ing in very slow counter action. This limits the practical utility of the counter. 
70.0 ns
77.0 ns
84.0 ns
91.0 ns
98.0 ns
Reset
Count
A0
A1
A2
A3
t= 168 ns
t= 88 ns
(b) From 70 to 98 ns
(a) From 0 to 180 ns
0.0 ns
57.0 ns
114.0 ns
171.0 ns
Reset
Count
A0
A1
A2
A3
FIGURE 6.19 
Simulation output of HDL Example 6.4       
Problems    291
PROBLEMS 
(Answers to problems marked with * appear at the end of the book. Where appropriate, a logic 
design and its related HDL modeling problem are cross-referenced.) 
Note: For each problem that requires writing and verifying a Verilog description, a test plan is to 
be written to identify which functional features are to be tested during the simulation and how 
they will be tested. For example, a reset on the fly could be tested by asserting the reset signal 
while the simulated machine is in a state other than the reset state. The test plan is to guide the 
development of a test bench that will implement the plan. Simulate the model using the test bench 
and verify that the behavior is correct. If synthesis tools and an ASIC cell library or a field pro-
grammable gate array (FPGA) tool suite are available, the Verilog descriptions developed for 
Problems 6.34–6.51 can be assigned as synthesis exercises. The gate‐level circuit produced by the 
synthesis tools should be simulated and compared to the simulation results for the pre‐synthesis 
model  . 
In some of the HDL problems, there may be a need to deal with the issue of unused states (see 
the discussion of the  default   case  item preceding HDL Example 4.8 in  Chapter   4   ).  
 
6.1   Include a 2‐input NAND gate in the register of  Fig.   6.1    and connect the gate output to the 
C  inputs of all the flip‐flops. One input of the NAND gate receives the clock pulses from 
the clock generator, and the other input of the NAND gate provides a parallel load control. 
Explain the operation of the modified register. Explain why this circuit might have opera-
tional problems.   
 
6.2   Include a synchronous clear input to the register of  Fig.   6.2   . The modified register will have 
a parallel load capability and a synchronous clear capability. The register is cleared syn-
chronously when the clock goes through a positive transition and the clear input is equal 
to 1. (HDL—see Problem 6.35(a), (b).)   
 
6.3   What is the difference between serial and parallel transfer? Explain how to convert serial 
data to parallel and parallel data to serial. What type of register is needed?   
 
6.4*   The contents of a four‐bit register is initially 0110. The register is shifted six times to the 
right with the serial input being 1011100. What is the content of the register after each 
shift?   
 
6.5   The four‐bit universal shift register shown in  Fig.   6.7    is enclosed within one IC component 
package. (HDL—see Problem 6.52.) 
(a)
Draw a block diagram of the IC showing all inputs and outputs. Include two pins for 
the power supply.  
(b)
Draw a block diagram using two of these ICs to produce an eight‐bit universal shift 
register.     
 
6.6   Design a four‐bit shift register with parallel load using  D  flip‐flops. There are two control 
inputs:  shift  and  load . When  shift  = 1, the content of the register is shifted by one posi-
tion. New data are transferred into the register when  load  = 1 and  shift  = 0. If both 
control inputs are equal to 0, the content of the register does not change. (HDL—see 
Problem 6.35(c), (d).)   
 
6.7   Draw the logic diagram of a four‐bit register with four  D  flip‐flops and four 4 × 1 mul-
tiplexers with mode selection inputs  s  
1
and  s  
0
. The register operates according to the 
following function table. (HDL—see Problem 6.35(e), (f).)   
292    Chapter 6  Registers and Counters
 
6.8*   The serial adder of  Fig.   6.6    uses two four‐bit registers. Register  A  holds the binary number 
0101 and register  B  holds 0111. The carry flip‐flop is initially reset to 0. List the binary 
values in register  A  and the carry flip‐flop after each shift. (HDL—see Problem 6.54).   
 
6.9   Two ways for implementing a serial adder ( A  +  B ) is shown in Section 6.2. It is necessary 
to modify the circuits to convert them to serial subtractors ( A  -  B ). 
(a)
Using the circuit of  Fig.   6.5   , show the changes needed to perform  A  + 2’s complement 
of  B . (HDL—see Problem 6.35(h).)  
(b)   *Using the circuit of  Fig.   6.6   , show the changes needed by modifying  Table   6.2    from an 
adder to a subtractor circuit. (See Problem 4.12). (HDL—see Problem 6.35(i).)     
 
6.10   Design a serial 2’s complementer with a shift register and a flip‐flop. The binary number 
is shifted out from one side and it’s 2’s complement shifted into the other side of the shift 
register. (HDL—see Problem 6.35(j).)   
 
6.11   A binary ripple counter uses flip‐flops that trigger on the positive‐edge of the clock. What 
will be the count if 
(a)
the normal outputs of the flip‐flops are connected to the clock and  
(b)
the complement outputs of the flip‐flops are connected to the clock?     
 
6.12   Draw the logic diagram of a four‐bit binary ripple countdown counter using 
(a)
flip‐flops that trigger on the positive‐edge of the clock and  
(b)
flip‐flops that trigger on the negative‐edge of the clock.     
 
6.13   Show that a BCD ripple counter can be constructed using a four‐bit binary ripple counter 
with asynchronous clear and a NAND gate that detects the occurrence of count 1010. 
(HDL—see Problem 6.35(k).)   
 
6.14   How many flip‐flop will be complemented in a 10‐bit binary ripple counter to reach the 
next count after the following counts? 
(a)   *1001100111  
(b)
1111000111  
(c)
0000001111     
 
6.15*   A flip‐flops has a 3 ns delay from the time the clock edge occurs to the time the output 
is complemented. What is the maximum delay in a 10‐bit binary ripple counter that uses 
these flip‐flops? What is the maximum frequency at which the counter can operate 
reliably?   
 
6.16*   The BCD ripple counter shown in  Fig.   6.10    has four flip‐flops and 16 states, of which only 
10 are used. Analyze the circuit and determine the next state for each of the other six 
unused states. What will happen if a noise signal sends the circuit to one of the unused 
states? (HDL—see Problem 6.54.)   
s  
1
s  
0
Register Operation 
No change 
Complement the four outputs 
Clear register to 0 (synchronous with the clock) 
Load parallel data 
Documents you may be interested
Documents you may be interested