Question 1

How to force toggling in a J–K flip-flop Under which input condition does a J–K flip-flop toggle its output state on each active clock edge?

Accepted Answer

Introduction / Context:The J–K flip-flop extends the S–R flip-flop by defining a behavior for the case when both inputs are asserted. That special case enables toggling, making the J–K FF useful as a programmable T (toggle) flip-flop for counters and clock division. Mastering the input-state mapping is essential for designing sequential logic.Given Data / Assumptions:Edge-triggered J–K FF sampled at the active clock edge.Inputs J and K can be 0 or 1 at the sampling moment.No asynchronous set or reset is active.Concept / Approach:The characteristic behavior is: J = 0, K = 0 → hold; J = 1, K = 0 → set; J = 0, K = 1 → reset; J = 1, K = 1 → toggle (Q_next = not Q_previous). Thus, to create a divide-by-2 output or a square wave, tie J and K high and clock the device.Step-by-Step Solution:Choose desired behavior: toggling on each active clock edge.Set inputs accordingly: J = 1 and K = 1.At each clock event, the output complements its previous state.Verification / Alternative check:Build a small counter: with J = K = 1, Q changes state every clock edge; viewing on a scope confirms a 50% duty cycle at half the input frequency (ignoring setup/hold and propagation delays).Why Other Options Are Wrong:J = 0, K = 0: holds state.J = 1, K = 0: sets.J = 0, K = 1: resets.Common Pitfalls:Forgetting to meet setup/hold timing on J and K; enabling asynchronous clears that inhibit toggling; misunderstanding that toggling occurs only at the clock edge, not continuously.Final Answer:J = 1, K = 1

Question 2

Negative-edge-triggered D flip-flop — concise functional description Which statement best describes a negative-edge-triggered D flip-flop's operation?

Accepted Answer

Introduction / Context:D flip-flops are the primary data storage elements in synchronous systems. The triggering edge (positive or negative) dictates when the input is sampled. A negative-edge-triggered device captures the input as the clock transitions from HIGH to LOW, then holds that value until the next qualifying edge. Accurately articulating this behavior prevents timing mistakes in design and analysis.Given Data / Assumptions:Flip-flop is negative-edge-triggered (active on NGT = negative-going transition).D is the data input; Q is the stored output.No asynchronous set/reset is active.Concept / Approach:At the instant of the falling clock edge, the flip-flop samples D and updates Q to that value, provided setup and hold times around the edge are satisfied. Between edges, changes on D do not affect Q. This one-edge sampling distinguishes flip-flops from level-sensitive latches, which are transparent for the duration of an enable/clock level.Step-by-Step Solution:Identify trigger: falling edge of CLK.State action: Q_next = D_sampled at that instant.Hold: Q remains constant until the next falling edge.Verification / Alternative check:Examine a timing diagram: apply a changing D; only values present at the falling edges appear at Q one-for-one; asynchronous variations in between edges are ignored.Why Other Options Are Wrong:Q identical to CLK when D is HIGH: nonsense; Q follows D sampling, not the clock signal.Q identical to D on PGT (positive-going transition): contradicts 'negative-edge-triggered.'Q always identical to D: that describes a transparent latch, not an edge-triggered FF.Common Pitfalls:Violating setup/hold times leading to metastability; misinterpreting the edge sense; expecting Q to respond to D changes between edges.Final Answer:The logic level at the D input is transferred to Q on NGT of CLK.

Question 3

Frequency division using flip-flops in cascade How many flip-flops are required to implement a divide-by-128 counter (i.e., overall division factor of 128)?

Accepted Answer

Introduction / Context:Binary ripple and synchronous counters are built by cascading flip-flops, each halving the frequency (divide-by-2) when configured to toggle. The total division achieved is 2^N where N is the number of flip-flops. Determining the required number for a target division is a core competency in digital design and timing generation.Given Data / Assumptions:Each flip-flop provides divide-by-2 when toggled (e.g., J = K = 1 on J–K, T = 1 on T-FF, or clocked D with feedback).We need an overall divide-by-128.Counter can be ripple or synchronous; the division count relation 2^N holds in either case.Concept / Approach:To obtain a division of 2^N = 128, solve for N. Since 2^7 = 128, seven toggle stages are required. Cascading seven flip-flops yields outputs at successively halved frequencies, with the most significant stage output toggling every 128 input cycles.Step-by-Step Solution:Recognize base relation: total divide = 2^N.Set 2^N = 128 → N = 7.Implement by connecting flip-flops to toggle on appropriate clock transitions.Verification / Alternative check:Trace a ripple counter: stage outputs divide by 2, 4, 8, 16, 32, 64, 128. After seven stages, the final output period spans 128 input clocks.Why Other Options Are Wrong:1, 4, 6 flip-flops yield 2, 16, 64 division—insufficient.More than 7 would exceed the needed division (e.g., 8 gives 256).Common Pitfalls:Confusing the number of states (2^N) with the maximum count value; forgetting that unused higher counts must be decoded and reset in non-power-of-two modulus counters, which is not needed here.Final Answer:7

Question 4

Glitches when deriving two-phase clocks from a positive-edge J–K flip-flop A positive edge-triggered J–K flip-flop is used to create a two-phase clock, but oscilloscope inspection shows glitches. What causes the glitches, and how can the issue be co…

Accepted Answer

Introduction / Context:Generating two-phase, nonoverlapping clocks from a single clock source often involves gating a clock with flip-flop outputs (e.g., Q and Q_bar). However, when gating occurs around the same edge that updates the flip-flop, small propagation delays can create brief hazards or glitches. Recognizing this race and choosing the correct mitigation is a practical design skill for clocking networks.Given Data / Assumptions:Positive-edge-triggered J–K flip-flop produces complementary outputs Q and Q_bar.An AND gate (or similar gating) uses Q/Q_bar with the clock to form phases.Glitches are visible at transitions on a scope.Concept / Approach:At the same instant the clock edge arrives, the J–K flip-flop outputs transition after a finite propagation delay. If those outputs are used to gate the clock itself, the overlap between the changing outputs and the actively switching clock can transiently enable the gate, creating short pulses (glitches). Changing the triggering edge so outputs settle before the opposite edge arrives can break the race.Step-by-Step Solution:Identify the race: clock rising edge both toggles FF and is present at the gate; outputs do not change exactly at the edge but shortly after.Recognize the hazard: during propagation, both gate inputs may momentarily meet the pass condition.Mitigate by phase staggering: use a negative-edge-triggered FF so outputs settle well before the next positive edge used for gating.Alternative mitigations: insert proper nonoverlap logic or retime with additional flip-flops.Verification / Alternative check:Simulate timing with realistic delays: observe that with positive-edge gating and positive-edge update, narrow spikes occur. Switching to negative-edge flip-flop eliminates spikes because outputs change on the falling edge, away from the active gate edge.Why Other Options Are Wrong:Floating PRESET/CLEAR: can cause issues but not specifically edge-correlated glitches in two-phase generation.Race between J and K inputs: with static J and K, the problem is not J/K but the interaction of clock and Q transitions.Replacing AND with NAND: changes polarity but does not remove the timing race that causes the spikes.Common Pitfalls:Ignoring real propagation delays; assuming ideal, instantaneous flip-flop outputs; forgetting to provide nonoverlap or phase separation when deriving multiple phases from one clock.Final Answer:A race condition exists between the clock and the outputs of the flip-flop feeding the AND gate; replace the flip-flop with a negative edge-triggered J-K Flip-Flop.

Question 5

S–R flip-flop fundamentals — input levels required to force a state change For an S–R (Set–Reset) latch or flip-flop with active-HIGH inputs, which logic level must be applied at the respective S or R input to SET or RESET the device?

Accepted Answer

Introduction / Context:An S–R (Set–Reset) latch or flip-flop is among the most basic storage elements in digital electronics. Understanding which input level causes a state change is foundational for debugging larger sequential circuits and for interpreting truth tables of derived devices such as JK and D flip-flops.Given Data / Assumptions:Active-HIGH S and R inputs (the most common convention).No asynchronous clears or presets beyond S and R.We are discussing the logical behavior, not analog implementation details.Concept / Approach:With active-HIGH inputs, driving S to a HIGH forces Q to 1 (SET), and driving R to a HIGH forces Q to 0 (RESET). When both inputs are LOW simultaneously, the latch holds its previous state. The combination S = 1 and R = 1 is generally invalid for level-sensitive SR latches (or mapped to toggle/hold in other families), but the basic rule remains: a HIGH on the respective input asserts that function.Step-by-Step Solution:Identify signal polarity: active-HIGH S and R.Apply S = HIGH ⇒ device SETS (Q ← 1).Apply R = HIGH ⇒ device RESETS (Q ← 0).Therefore, the required input level to force either action is HIGH.Verification / Alternative check:Consult any SR truth table: S R = 1 0 → Qnext = 1; S R = 0 1 → Qnext = 0; S R = 0 0 → hold. This matches bench behavior on NOR- or NAND-realizations under active-HIGH conventions (with bubbles indicating inversion if active-LOW).Why Other Options Are Wrong:LOW: LOW corresponds to non-asserted inputs in active-HIGH logic.Installed with diodes / limiting resistors / tri-stated: these are implementation or bus-connection details, not the logical condition that causes setting or resetting.Common Pitfalls:Mixing up active-HIGH and active-LOW conventions. Always check symbol bubbles and datasheets.Final Answer:HIGH

Question 6

555 monostable design — find C1 for a required pulse width A 555 timer operates as a monostable (one-shot) with R1 = 220 kΩ. Determine the value of C1 needed to obtain a pulse width of 4 ms using t = 1.1 * R * C.

Accepted Answer

Introduction / Context:The 555 timer configured as a monostable multivibrator generates a single pulse whose width is set by an external resistor and capacitor. Selecting the correct timing capacitor for a desired pulse width prevents redesigns and repeated prototype iterations.Given Data / Assumptions:Pulsed one-shot configuration.R1 = 220 kΩ = 220,000 Ω.Desired pulse width t = 4 ms = 0.004 s.Formula: t = 1.1 * R * C.Concept / Approach:Rearrange the standard formula to solve for C: C = t / (1.1 * R). Convert all quantities to SI base units to avoid scale errors, then convert the result back to microfarads for readability.Step-by-Step Solution:C = t / (1.1 * R)= 0.004 / (1.1 * 220,000)= 0.004 / 242,000 ≈ 1.6529 × 10^-8 F= 16.53 nF ≈ 0.0165 µF ≈ 0.017 µF (preferred E12/E24 value).Verification / Alternative check:Back-calculate: t = 1.1 * 220 kΩ * 0.017 µF ≈ 1.1 * 220,000 * 17 × 10^-9 ≈ 0.004114 s ≈ 4.11 ms, within typical component tolerance ranges for R and C. Fine tuning can be done with precision parts if needed.Why Other Options Are Wrong:17 pF / 170 pF: three to five orders of magnitude too small.1,700 µF: absurdly large for a 4 ms one-shot with 220 kΩ.0.17 µF: would produce ~41 ms, not 4 ms.Common Pitfalls:Mistaking milli, micro, and nano prefixes; always convert to base units first.Final Answer:0.017 µF

Question 7

Hardware description languages (HDLs) — identify what is NOT a genuine advantage Which of the following is not a real advantage attributable to using an HDL (such as Verilog or VHDL) in digital design flows?

Accepted Answer

Introduction / Context:HDLs like Verilog and VHDL allow engineers to describe hardware behavior and structure textually, enabling simulation, synthesis, and verification. Distinguishing the true strengths of HDLs from unrelated tool features helps set correct expectations for a project’s methodology.Given Data / Assumptions:HDL refers to textual descriptions of hardware.Tooling may include simulators, synthesizers, and sometimes separate schematic or block-diagram editors.Concept / Approach:Core HDL advantages include abstraction (behavioral/RTL), parameterization for tailoring components, portability between technologies, and automated verification via testbenches. Graphical tools can accompany HDLs, but they are not inherent advantages of the language itself; they are separate user-interface features available in some EDA suites.Step-by-Step Reasoning:Identify advantages inherent to HDLs: abstraction, parametric reuse, synthesizable portability.Contrast with “graphical tools”: an IDE feature, not an HDL property.Therefore, the item not truly attributable to HDLs is “The use of graphical tools.”Verification / Alternative check:Examine vendor documentation: simulators and synthesizers operate on HDL source irrespective of whether a schematic GUI is provided. Many professional flows are entirely code-centric with minimal or no graphical tooling.Why Other Options Are Wrong:Higher abstraction: central HDL benefit.Tailoring components: achieved by generics/parameters.Combination statement: still reflects true HDL strengths.Portability: synthesizable RTL retargets across FPGAs/ASICs.Common Pitfalls:Confusing the HDL language with the EDA environment’s GUI capabilities.Final Answer:The use of graphical tools

Question 8

555 monostable design — find C1 for a required pulse width A 555 timer operates as a monostable (one-shot) with R1 = 1 MΩ. Determine the value of C1 required to obtain a pulse width of 2 s using t = 1.1 * R * C.

Accepted Answer

Introduction / Context:Choosing the timing capacitor for a 555 monostable is a straightforward calculation, but unit conversions must be handled carefully to avoid errors of orders of magnitude. Here we design for a 2-second pulse with a large timing resistor.Given Data / Assumptions:R1 = 1 MΩ = 1,000,000 Ω.Desired t = 2 s.Formula: t = 1.1 * R * C.Concept / Approach:Solve for C: C = t / (1.1 * R). After computing in farads, convert to microfarads to select a practical capacitor value. Consider real-world tolerances and leakage when choosing the dielectric and voltage rating.Step-by-Step Solution:C = 2 / (1.1 * 1,000,000) F= 2 / 1.1e6 ≈ 1.818 × 10^-6 F≈ 1.82 µF → choose the standard value 1.8 µF.Verification / Alternative check:Back-calculate: t ≈ 1.1 * 1 MΩ * 1.8 µF = 1.98 s, very close to 2 s, well within typical component tolerances (R ±5%, C ±10% or more). Selecting 2.0 µF yields ~2.2 s if a longer pulse is preferred.Why Other Options Are Wrong:18 F / 18 nF / 18 pF / 0.18 µF: all off by orders of magnitude compared with the required microfarad range.Common Pitfalls:Confusing mega (10^6) with kilo (10^3), and micro (10^-6) with nano (10^-9).Final Answer:1.8 µF

Question 9

Two-bit ripple counter — state after four clock pulses Two JK flip-flops are cascaded as a ripple counter with J = K = 1 on both stages (divide-by-4 counter). Starting from 00, what is the binary state after four input clock pulses?

Accepted Answer

Introduction / Context:Cascading JK flip-flops with J = K = 1 creates a toggle chain in which each stage divides the previous stage’s frequency by 2. Two such stages form a 2-bit ripple counter that cycles through four states (00 → 01 → 10 → 11 → 00 …).Given Data / Assumptions:Two stages, asynchronous ripple configuration.Each stage toggles on the appropriate clock edge when its input stage toggles.Initial state is 00 (Q1Q0).Concept / Approach:A 2-bit counter has a modulus of 4. After exactly four input clock pulses, the counter completes one full cycle and returns to its initial state. Therefore, the state after four pulses is 00 again.Step-by-Step Solution:Pulse 1: 00 → 01Pulse 2: 01 → 10Pulse 3: 10 → 11Pulse 4: 11 → 00Verification / Alternative check:Think in modulo arithmetic: count value N advances by 1 each pulse modulo 4. After 4 increments, N ≡ 0 (mod 4), which maps back to 00.Why Other Options Are Wrong:01, 10, 11: these are intermediate states after 1, 2, or 3 pulses, not after 4.11 (with carry): not applicable; the 2-bit counter simply wraps to 00.Common Pitfalls:Starting from an assumed state other than 00; the answer is contingent on the initial condition.Final Answer:00

Question 10

Clocked S–R device behavior — both inputs LOW For a clocked S–R flip-flop, if both S and R inputs are LOW when the active clock edge arrives, what happens to the output state?

Accepted Answer

Introduction / Context:Understanding the truth table of clocked S–R storage elements is crucial for designing synchronous systems. The S–R function generalizes the idea of setting and resetting a latch, while the clock edge determines when sampling occurs in synchronous variants.Given Data / Assumptions:Clocked (edge-controlled) S–R flip-flop.Active edge occurs while S = 0 and R = 0.No asynchronous inputs (CLR/PR) are active.Concept / Approach:In the canonical S–R truth table, S = 0 and R = 0 at the sampling moment cause the device to hold its previous state (no change). Only S = 1 forces a set, and R = 1 forces a reset. The forbidden or indeterminate input for a level-sensitive SR latch is S = R = 1; in clocked variants, this is either disallowed or mapped to a defined behavior depending on implementation, but it is not the present case.Step-by-Step Reasoning:At the active clock edge, inputs are S = 0, R = 0.S/R both LOW ⇒ neither set nor reset is requested.Therefore, Qnext = Qprev (hold condition).Verification / Alternative check:Vendor timing diagrams show flat Q behavior across the sampling edge when S and R are both 0. Simulation of a behavioral SR model will also confirm that Q remains unchanged for this input pair at the clock event.Why Other Options Are Wrong:Invalid state: associated with S = R = 1 in basic SR latches, not with both inputs LOW.Toggle: SR devices toggle only in special JK designs, not with S = R = 0.Reset / Set: would require R = 1 or S = 1 respectively.Common Pitfalls:Confusing SR operation with JK behavior, where J = K = 1 causes toggling.Final Answer:No change will occur in the output.

Question 11

Flip-flop timing parameters — identify the item that is NOT standard Which of the following is not generally recognized as a standard flip-flop timing parameter?

Accepted Answer

Introduction / Context:Flip-flops are characterized by specific timing parameters that determine how they interact with clock and data signals. Correctly identifying these parameters is essential for reliable synchronous design and timing closure.Given Data / Assumptions:Edge-triggered flip-flops in synchronous systems.Standard datasheet terminology.Concept / Approach:Common parameters include setup time (tsu), hold time (th), propagation delay or clock-to-Q time (tCQ), and sometimes recovery/removal times for asynchronous inputs. The term “interval time” is not a standard flip-flop timing specification and does not appear as a defined parameter in vendor datasheets.Step-by-Step Reasoning:List standard parameters: setup, hold, propagation, clock-to-Q.Compare with options: “interval time” is not a recognized flip-flop metric.Therefore, select “Interval time” as the incorrect/irrelevant item.Verification / Alternative check:Reviewing any standard logic family datasheet (TTL/CMOS/FPGA primitives) shows no “interval time”; instead, they specify tsu, th, tpd, tCQ, tr/tf, and asynchronous timing specs.Why Other Options Are Wrong:Hold time: minimum time D must remain stable after the clock edge.Propagation delay time / Clock-to-Q: time for output to respond to clock/data change.Setup time: minimum time D must be stable before the clock edge.Clock-to-Q time: a specific propagation delay metric from clock to output.Common Pitfalls:Using nonstandard terms which can mask real timing violations in analysis.Final Answer:Interval time

Question 12

Edge-triggered flip-flops — essential requirement Which statement best captures what an edge-triggered flip-flop must include to detect and respond to clock transitions?

Accepted Answer

Introduction / Context:Edge-triggered flip-flops change state only at a clock transition, not during the level between edges. This behavior relies on internal circuitry that senses a rising or falling clock edge and briefly opens a sampling window.Given Data / Assumptions:Generic edge-triggered D/JK flip-flops.Device may be positive-edge or negative-edge triggered.Concept / Approach:The essential feature is an internal edge-detection mechanism (often implemented with transmission gates, pulse generators, or master–slave structures) that creates a short sampling pulse when the clock transitions. Whether the device is positive- or negative-edge triggered depends on the specific design, but all such flip-flops must detect an edge.Step-by-Step Reasoning:Edge-triggered behavior ⇒ requires transition sensing.Implementation ⇒ internal network produces a brief sampling pulse at the selected edge.Therefore, the must-have feature is an internal edge-detection network (positive or negative).Verification / Alternative check:Master–slave implementations effectively sample on one level and transfer on the next, emulating edge sensitivity; pulse-triggered designs explicitly generate a narrow pulse at the clock edge. Both embody edge detection internally.Why Other Options Are Wrong:Very fast response times: useful but not the defining requirement.Two inputs for rising and falling edges: a single clock input suffices; the device is designed for one edge.Positive-only / Negative-only: devices can be either; saying “only” is too restrictive.Common Pitfalls:Assuming edge-triggered means faster; it actually means edge-qualified sampling.Final Answer:an internal edge-detection network for clock transitions (either positive or negative edge)

Question 13

D flip-flop with positive-going transition (PGT) clock — action from CLEAR state A D flip-flop uses a PGT (positive-going transition) clock and is currently in the CLEAR state (Q = 0). Which input condition will cause the device to change state on t…

Accepted Answer

Introduction / Context:D flip-flops sample the D input at the active clock edge and transfer it to Q. If the device is positive-edge (PGT) triggered, only a rising edge causes the state to update. Knowing which input combinations lead to a state change is key for designing registers and synchronous pipelines.Given Data / Assumptions:Current state: CLEAR → Q = 0.Clock sensitivity: positive-going transition (PGT).No asynchronous set/clear asserted at the event.Concept / Approach:At the rising edge, Qnext becomes the present D. To change from Q = 0 to Q = 1, present D must be 1 at the moment of the PGT. Negative-going transitions (NGT) are irrelevant to a PGT device and produce no state change under normal operation.Step-by-Step Reasoning:Goal: change Q from 0 to 1.Condition: D must equal 1 when a rising edge occurs.Therefore, the required action is CLOCK PGT with D = 1.Verification / Alternative check:Simulate or consult timing diagrams: with D = 1 held stable for setup/hold around the rising edge, Q updates to 1 immediately after the edge; with D = 0, Q remains 0. Negative edges do not trigger in a PGT device.Why Other Options Are Wrong:Any NGT option: does not trigger a PGT flip-flop.PGT with D = 0: samples 0 and keeps Q = 0 (no state change from CLEAR).Common Pitfalls:Ignoring setup/hold requirements; even with D = 1, violating timing can prevent a reliable change.Final Answer:CLOCK PGT, D = 1

Question 14

Active-HIGH SR latch behavior An SR latch with active-HIGH inputs is driven with S = 1 and R = 0. In this condition, what state does the latch assume (indicate the state of Q)?

Accepted Answer

Introduction / Context:An SR (Set–Reset) latch is the simplest bistable storage element in digital electronics. Understanding how input polarity (active-HIGH or active-LOW) affects the state transition is essential for correctly interfacing latches with combinational logic and for diagnosing behavior in larger sequential circuits.Given Data / Assumptions:Latch type: SR latch with active-HIGH control inputs.Applied inputs: S = 1 (asserted), R = 0 (deasserted).Outputs: Q and Q̄, where Q̄ is the logical complement of Q under normal operation.Concept / Approach:With active-HIGH inputs, a logic HIGH on S commands the latch to store a 1 (set), while a logic HIGH on R commands the latch to store a 0 (reset). If both inputs are LOW, the latch holds its previous state. The combination S = 1 and R = 1 is generally considered invalid/forbidden for an SR latch because it attempts to force both outputs LOW (for NOR-based implementation) and can lead to metastability upon release.Step-by-Step Solution:Identify input polarity: active-HIGH means 1 asserts the function.Apply inputs: S = 1 (asserted set), R = 0 (not asserted).Follow behavior: an asserted set drives Q → 1 and Q̄ → 0 regardless of the prior stored bit.Conclude state: the latch moves into the set state and will remain there until a subsequent reset action or power cycle.Verification / Alternative check:Consider a cross-coupled NOR implementation: S = 1 forces the left NOR output LOW, which releases the opposite side to go HIGH, producing Q = 1. Tracing the feedback confirms a stable set condition as long as R remains 0.Why Other Options Are Wrong:Reset state: Requires R = 1 (asserted reset), which is not the case.Hold state: Occurs only when both S and R are deasserted (S = 0, R = 0).Invalid/forbidden state: Associated with S = 1 and R = 1, not with S = 1 and R = 0.Common Pitfalls:Confusing active-HIGH with active-LOW versions (for NAND-based latches, assertions are LOW), and assuming the hold condition applies whenever one input is 0 (it applies only when both are inactive).Final Answer:Set state (Q = 1, Q̄ = 0)

Question 15

One-shot (monostable) timing In a standard one-shot multivibrator (monostable), the output pulse width is primarily determined by which external timing elements?

Accepted Answer

Introduction / Context:A one-shot, or monostable multivibrator, produces a single pulse of controlled width in response to a trigger. Designers frequently need to set this pulse duration to meet interface timing, debounce inputs, or generate timeouts. Knowing which components control the timing is essential when selecting values or troubleshooting errant pulse widths.Given Data / Assumptions:Device: generic one-shot (for example, 74121/74122 or CMOS variants).External timing network present on pins labeled REXT and CEXT.Pulse width depends on the RC time constant scaled by device-specific factors.Concept / Approach:Most monostables charge or discharge an external capacitor through an external resistor. The internal comparators and reference levels detect when the capacitor voltage crosses certain thresholds, ending the pulse. Thus, the dominant factor in pulse width is the product R * C, often multiplied by a constant K determined by the IC family and operating conditions.Step-by-Step Solution:Identify the timing pins and the connected R and C values.Use the datasheet formula of the form tW ≈ K * R * C, with K provided per device type.Select R and C to achieve the target width; adjust values to fine-tune timing as needed.Account for tolerances of components and temperature/supply variations when specifying margins.Verification / Alternative check:Bench measurement of the pulse width with an oscilloscope should closely match tW calculated from the chosen R and C, within tolerance bands. Simulation with SPICE models can also confirm expected timing before hardware build.Why Other Options Are Wrong:Two resistors / two capacitors: Without both R and C together, a monostable cannot set a stable, finite pulse width based on RC charging behavior.None of the above: Directly contradicts the standard monostable design, which always relies on an RC network.Common Pitfalls:Using incorrect units (for example, confusing nF and µF) or misreading the device-specific constant K, leading to an order-of-magnitude timing error.Final Answer:a resistor and capacitor

Question 16

Understanding the D latch Which statement correctly describes the behavior of a level-enabled D latch?

Accepted Answer

Introduction / Context:A D (data) latch is a level-sensitive storage element widely used for pipeline staging and simple registers. Its key characteristic is that, while enabled, the output tracks the input; when disabled, it holds the last sampled value. Distinguishing this behavior from edge-triggered flip-flops is crucial in timing design.Given Data / Assumptions:Device: level-enabled D latch with an enable (EN) signal.Polarity: assume active-HIGH enable unless otherwise stated.Outputs: Q and Q̄ (complement) available in many implementations.Concept / Approach:When EN = 1 (HIGH), the latch is transparent, meaning Q reflects D in real time (within propagation delay). When EN = 0 (LOW), the latch is opaque, meaning Q retains its previous value regardless of changes on D. This distinguishes a latch from an edge-triggered flip-flop, which samples only on clock transitions.Step-by-Step Solution:Enable asserted (EN = 1): Q ≈ D after a short delay; Q̄ ≈ NOT D.Enable deasserted (EN = 0): Internal feedback holds the stored state; D changes are ignored.Reassert EN to update Q to the current D level.This behavior supports gated data paths and glitch filtering when timed properly.Verification / Alternative check:Examine a timing diagram: during EN = 1, any transition on D is mirrored at Q; during EN = 0, Q is flat despite D activity. Simulation waveforms confirm this relationship precisely.Why Other Options Are Wrong:Output toggles if one input is held HIGH: Describes a T or JK flip-flop, not a D latch.Only one input can be HIGH: Not applicable; D latch has data and enable, not mutually exclusive inputs.Output complement follows the input: Q̄ follows NOT D when enabled, but Q follows D; the statement is misleading.Common Pitfalls:Confusing latch transparency with flip-flop edge-triggering, and forgetting that poor enable timing can pass hazards through the latch.Final Answer:Q output follows the input D when the enable is HIGH.

Question 17

Synchronous vs. asynchronous behavior Gated SR flip-flops are called asynchronous because their outputs respond immediately to input changes. Is this statement correct?

Accepted Answer

Introduction / Context:Sequential elements can have inputs that are either synchronous (qualified by a clock or gate) or asynchronous (acting immediately regardless of clock). Mislabeling these behaviors leads to design errors and timing violations. This question examines the common confusion surrounding gated SR flip-flops and asynchronous controls like PRE/CLR.Given Data / Assumptions:A gated SR device includes a gate/clock input that enables state changes only during specific levels.Asynchronous inputs (if present) are separate lines such as preset (PRE) and clear (CLR), often active-LOW.We evaluate whether gated SR is inherently asynchronous.Concept / Approach:By definition, synchronous inputs affect the state only in relation to a gating signal or clock. In a gated SR flip-flop, S and R are evaluated only when the gate is active; otherwise the output holds. Asynchronous inputs bypass the gate and can change the state immediately at any time. Therefore, calling a gated SR flip-flop “asynchronous” because it responds immediately is incorrect.Step-by-Step Solution:Identify the enable/gate input: when inactive, S and R changes do not alter Q.When the gate is active, S/R can set or reset according to the truth table (this is synchronous operation).Asynchronous lines, if provided, act immediately regardless of the gate and are distinctly labeled.Hence, the statement claiming “gated SR are asynchronous” is false.Verification / Alternative check:Consult timing diagrams: setup/hold times are defined relative to the gate for S and R, confirming synchrony. PRE/CLR timing is specified independently, highlighting their asynchronous nature.Why Other Options Are Wrong:True: Would conflate synchronous gating with immediate, clock-independent action.Common Pitfalls:Mixing up level-sensitive gating (synchronous) with asynchronous override signals; assuming any instantaneous response implies “asynchronous.”Final Answer:False

Question 18

JK flip-flop operating modes On a standard JK flip-flop, under which input condition is the flip-flop in the hold (no change) state?

Accepted Answer

Introduction / Context:The JK flip-flop unifies SR behavior while avoiding the invalid state. Its truth table includes four operating modes: hold, reset, set, and toggle. Recognizing the hold condition is essential when analyzing synchronous state machines and designing gating networks that intentionally suppress state changes.Given Data / Assumptions:Device: edge-triggered JK flip-flop.Inputs: J and K are evaluated at the active clock edge (subject to setup/hold times).We seek the input combination that preserves the current state.Concept / Approach:The JK truth table indicates: J = 0, K = 0 → no change (hold); J = 1, K = 0 → set; J = 0, K = 1 → reset; J = 1, K = 1 → toggle. Thus the explicit hold condition is when both J and K are 0 during the sampling edge.Step-by-Step Solution:Ensure the clock edge occurs with J = 0 and K = 0 valid at the inputs.At the sampling edge, the device logic selects “no change,” leaving Q and Q̄ unchanged.Subsequent edges will maintain the stored state as long as J = K = 0.Any deviation (for example, J = 1 or K = 1) will invoke set/reset/toggle modes.Verification / Alternative check:Vendor datasheets and standard textbooks list the JK table, confirming the hold behavior for J = K = 0.Why Other Options Are Wrong:J = 1, K = 0: Set mode.J = 0, K = 1: Reset mode.J = 1, K = 1: Toggle mode (divide-by-two action under continuous clock).Common Pitfalls:Confusing JK with SR (which has a forbidden input) or forgetting that the JK = 11 case toggles, not holds.Final Answer:J = 0, K = 0

Question 19

Positive edge-triggered D flip-flop capture A positive edge-triggered D flip-flop will store a logic 1 under which timing condition?

Accepted Answer

Introduction / Context:Edge-triggered flip-flops sample inputs only at a specific clock transition. For a positive edge-triggered device, the LOW-to-HIGH transition is the critical instant. Understanding this sampling instant is essential for meeting setup and hold time constraints and avoiding metastability.Given Data / Assumptions:Device: positive edge-triggered D flip-flop.Input: D must be stable around the sampling edge.Clock: the active edge is rising (LOW → HIGH).Concept / Approach:At the rising edge of the clock, the flip-flop captures the logic level present on D (if setup/hold requirements are satisfied). If D = 1 at that instant, Q becomes 1 after the device propagation delay and remains 1 until the next active edge (unless asynchronously overridden by preset/clear signals, if present).Step-by-Step Solution:Ensure D = 1 during the setup interval before the rising edge.Apply a LOW-to-HIGH clock transition.Maintain D stable through the hold interval immediately after the edge.Observe Q transitioning to 1 after t_pd (propagation delay) and remaining latched until a later edge.Verification / Alternative check:Timing diagrams show the sampling window centered on the rising edge, with setup/hold slacks specified. Simulations using HDL primitives confirm that Q follows D only on that edge, not during steady clock levels.Why Other Options Are Wrong:HIGH-to-LOW: Describes negative-edge devices.Clock LOW or HIGH (steady levels): Edge-triggered devices do not capture simply due to level; they sample on transitions.Common Pitfalls:Violating setup/hold times, which may cause metastability or incorrect capture, and assuming level-sensitive behavior instead of edge-triggered.Final Answer:the D input is HIGH and the clock transitions from LOW to HIGH

Question 20

JK flip-flop as a divide-by-two A JK flip-flop is clocked at 20 kHz with inputs J = 1 and K = 1. What is the resulting Q output waveform?

Accepted Answer

Introduction / Context:One classic application of the JK flip-flop is clock division. When both inputs are asserted (J = K = 1), the device toggles state at each active clock edge, creating a square wave at half the input frequency. This forms the basis of ripple counters and frequency dividers.Given Data / Assumptions:JK flip-flop with J = 1 and K = 1 continuously.Clock frequency: 20 kHz.Positive edge triggering assumed (behavior is analogous for negative edge with appropriate phase shift).Concept / Approach:With J = K = 1, the JK truth table enters the toggle mode. Each active clock edge complements Q. Thus, after one edge Q flips; after the next, it flips back—completing one full cycle every two clock edges, which halves the frequency and produces a 50% duty square wave (ideal case).Step-by-Step Solution:Initial state: assume Q = 0 for discussion.At the first clock edge, Q → 1 (toggle).At the second clock edge, Q → 0 (toggle again).Two edges produce one output cycle → f_out = f_clk / 2 = 20 kHz / 2 = 10 kHz.Verification / Alternative check:Scope measurement will show Q transitions on every other clock edge, confirming frequency division by two. Chaining n such stages yields division by 2^n.Why Other Options Are Wrong:Constantly LOW/HIGH: Would imply asynchronous forcing or disabled clock, not the toggle mode.20 kHz square wave: That would indicate pass-through or buffering, not divide-by-two toggling.Common Pitfalls:Forgetting that propagation delays introduce phase lag; also, mixing up duty cycle if asynchronous clears/presets occur.Final Answer:a 10 kHz square wave

Flip-Flops Questions

Questions

Practice smarter