Question 1

Strong typing in VHDL: VHDL is very strict about how we assign to and compare various program elements. Which term correctly describes these elements (signals, variables, constants, and literals)?

Accepted Answer

Introduction / Context:VHDL is a strongly typed hardware description language. Correct terminology matters when reasoning about assignment, comparison, and type compatibility. The language groups assignable and comparable entities under a general term used throughout the standard and documentation.Given Data / Assumptions:We refer to signals, variables, constants, and literals in VHDL.We are focusing on the generic umbrella term used by the language.Type checking and object classes (signal/variable/constant) are enforced.Concept / Approach:In VHDL, the word “object” is the standard term for entities that hold values and participate in assignments and comparisons: signals, variables, constants, and files are all objects. This is separate from specific types such as std_logic_vector, integer, or user-defined enumerations.Step-by-Step Solution:Identify the language's umbrella term for assignable/comparable entities.Note that signals, variables, constants fit under the term “objects.”Conclude that the correct completion is “objects.”Verification / Alternative check:Review any VHDL reference: syntax rules refer to “object_kind,” and declarations specify object class (signal, variable, constant), confirming the usage.Why Other Options Are Wrong:LOGIC_VECTORS: A specific type/category, not the umbrella term.designs: Refers to higher-level entities/architectures, not assignable elements.arrays: A data structure form; not all objects are arrays.Common Pitfalls:Mixing object classes with types; assuming all signals are vectors; forgetting literals are also objects for comparison and expression evaluation.Final Answer:objects

Question 2

Odd-parity validation: Which data/parity pair correctly implements an ODD-parity data transmission, ensuring the total number of 1s (data + parity) is odd?

Accepted Answer

Introduction / Context:Parity bits provide a simple integrity check by constraining the total count of 1s in a codeword. For odd parity, the parity bit is selected so that data plus parity contains an odd number of 1s. This question checks your ability to count 1s correctly and apply the rule.Given Data / Assumptions:Odd parity is used.Each option lists 8 data bits and a single parity bit.Total ones across data and parity must be odd.Concept / Approach:Count the number of 1s in the data field. If the count is even, parity must be 1 to make the total odd. If the count is already odd, parity must be 0 to keep the total odd. Verify each option against this rule.Step-by-Step Solution:Option A: 1101 1011 → ones = 6; parity = 1 → total = 7 (odd) ✓Option B: 1101 0010 → ones = 4; parity = 0 → total = 4 (even) ✗Option C: 0001 0101 → ones = 3; parity = 1 → total = 4 (even) ✗Option D: 1010 1111 → ones = 6; parity = 0 → total = 6 (even) ✗Verification / Alternative check:A quick check: for odd parity, parity = NOT(even(data_ones)). Only option A uses parity = 1 when data has an even count, satisfying the requirement.Why Other Options Are Wrong:B: Even data ones with parity 0 leaves total even.C: Odd data ones with parity 1 yields even total.D: Even data ones with parity 0 yields even total.Common Pitfalls:Miscounting ones; forgetting spaces in visual groups do not affect counting; mixing odd/even rules; assuming parity “fixes” any error (it only detects many single-bit flips).Final Answer:data = 1101 1011 parity = 1

Question 3

Equality detection in logic circuits: Which specialized gate outputs HIGH exactly when its two inputs are equal (both 0 or both 1)?

Accepted Answer

Introduction / Context:Equality comparators form a foundation for digital systems: address matching, error detection, and control logic often require checking whether two bits (or vectors) are the same. At the single-bit level, one standard gate directly realizes equality.Given Data / Assumptions:Two binary inputs, A and B.We want output = 1 when A = B, and output = 0 when A ≠ B.Gate names use the “exclusive” family conventions.Concept / Approach:Exclusive-OR (XOR) outputs 1 when inputs differ. Exclusive-NOR (XNOR), being the logical complement of XOR, outputs 1 when inputs are the same and 0 otherwise. Thus, XNOR serves as a 1-bit equality detector. For multi-bit equality, XNOR is applied bitwise and the results are ANDed together.Step-by-Step Solution:Recall XOR truth: A⊕B = 1 for 01 and 10; 0 for 00 and 11.XNOR = NOT(XOR) → 1 for 00 and 11; 0 for 01 and 10.Equality condition matches XNOR exactly.Therefore, the equality gate is exclusive-NOR.Verification / Alternative check:Construct a small truth table for A, B, and outputs of XOR/XNOR to confirm which aligns with equality.Why Other Options Are Wrong:exclusive-AND / exclusive-NAND: Not standard gate types; distractors.exclusive-OR: Detects inequality, not equality.Common Pitfalls:Confusing XOR with XNOR; forgetting that XNOR is the equality operator in many HDLs (often written as A = B for vectors, but implemented via XNOR chains).Final Answer:exclusive-NOR

Question 4

Overflow conditions in 2's-complement addition: For the sum of two signed 2's-complement numbers to overflow, what must be true about the signs of the addends?

Accepted Answer

Introduction / Context:In 2's-complement arithmetic, overflow occurs when the true mathematical result cannot be represented in the available fixed-width format. Recognizing the sign patterns that cause overflow is essential for CPU ALUs, DSP code, and safety checks in embedded systems.Given Data / Assumptions:Fixed width N-bit 2's-complement representation.Two signed addends are added.Overflow flagging is based on sign behavior, not just carry out of MSB.Concept / Approach:Overflow in 2's complement addition happens when adding two positives yields a negative result, or adding two negatives yields a positive result. This only occurs when the two inputs share the same sign and the resulting sign differs. If the inputs have opposite signs, the sum moves toward zero and cannot overflow the representable range.Step-by-Step Solution:Case 1: Positive + Positive → Expected positive; if result sign bit = 1, overflow.Case 2: Negative + Negative → Expected negative; if result sign bit = 0, overflow.Case 3: Opposite signs → Magnitudes subtract; no overflow can occur.Therefore, overflow requires same-sign addends.Verification / Alternative check:Hardware rule: Overflow = carry into MSB XOR carry out of MSB. This condition evaluates true precisely in the same-sign overflow scenarios above.Why Other Options Are Wrong:be positive / be negative: Too narrow; either both positive or both negative can overflow.have opposite signs: Cannot overflow in 2's complement addition.Common Pitfalls:Confusing carry-out with overflow; applying unsigned intuition to signed operations; ignoring fixed width truncation effects.Final Answer:have the same sign

Question 5

Modular verification in VHDL design: After each sub-circuit within a VHDL subsection has been individually validated, what should be done before integrating and testing the subsection as a whole?

Accepted Answer

Introduction / Context:Complex digital systems are built from smaller components. A sound VHDL workflow emphasizes modularity: design small units, verify them, then integrate. Knowing the proper sequence reduces debug time and prevents fault propagation to higher hierarchy levels.Given Data / Assumptions:Sub-circuits (entities/architectures) exist within a subsection.Goal is to integrate these units into a larger block.Validation means functional simulation (and optionally formal checks) before integration.Concept / Approach:Unit testing (component-level verification) confirms each block meets its specification in isolation, using focused testbenches. Only after passing these tests does it make sense to combine components, otherwise integration testing becomes murky with multiple unknown failure sources.Step-by-Step Solution:Design entities and write architectures for each sub-circuit.Author unit testbenches to exercise all important behaviors.Run simulations to verify correctness and timing assumptions.After each unit is tested and passes, integrate and test the subsection.Verification / Alternative check:Adopt continuous integration practices: run regression test suites after every change; ensure unit tests pass before system-level simulation and synthesis.Why Other Options Are Wrong:designed: Design precedes testing; completion of design alone is insufficient.engineered / produced: Imprecise or manufacturing-oriented terms; not the verification step.Common Pitfalls:Skipping unit tests and relying only on top-level checks; inadequate test coverage; not stubbing external interfaces, making unit tests brittle.Final Answer:tested

Question 6

STD_LOGIC value set (IEEE 1164): Which of the following is not a valid STD_LOGIC scalar value? (Choose the exception.)

Accepted Answer

Introduction / Context:STD_LOGIC (IEEE 1164) extends binary logic to a 9-value set to model unknowns, high-impedance, weak/strong drives, and don’t-care conditions. Recognizing valid symbols prevents type errors and clarifies waveform interpretation during simulation.Given Data / Assumptions:Scalar STD_LOGIC values: 'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', '-'.Case is significant as typically shown in documentation (e.g., 'U' vs 'u').Question asks for the invalid (non-member) symbol.Concept / Approach:Compare each option to the IEEE 1164 set. A symbol present in the list is valid; anything outside is invalid. Remember that '-' is the don’t-care symbol; there is no '?' in the standard value set.Step-by-Step Solution:Check 'z': equivalent to 'Z' (high-impedance). Tools typically accept uppercase; the concept is valid.Check 'U': uninitialized/unknown → valid.Check '?': not part of IEEE 1164 STD_LOGIC → invalid.Check 'L': weak 0 → valid.Verification / Alternative check:Consult any IEEE 1164 reference: set includes {U, X, 0, 1, Z, W, L, H, -}. The question mark is not included; '-' serves as don’t-care.Why Other Options Are Wrong:'z': Represents high-impedance; valid (typically written uppercase as 'Z').'U': Uninitialized; valid.'L': Weak 0; valid.Common Pitfalls:Confusing '-' (don’t-care) with '?'; mixing case conventions; assuming simulator-specific aliases are part of the standard.Final Answer:'?'

Question 7

In digital systems, parity generation and parity checking are employed to detect ________ during the transmission or storage of binary data.

Accepted Answer

Introduction / Context: Parity generation and checking is a classic, low-cost technique used in digital electronics and computer systems to detect accidental changes in binary data. It appears in serial links, memory systems, I/O buses, and simple communication protocols to provide a first line of defense against bit errors introduced by noise or interference.Given Data / Assumptions:The system uses either even parity or odd parity.Parity is computed over a defined set of data bits (for example, a byte).Only single-bit error detection is guaranteed; multi-bit detection depends on error patterns.Concept / Approach: Parity adds one extra bit so that the total number of 1s (data bits + parity bit) is even for even parity, or odd for odd parity. At the receiver, parity is recomputed and compared with the received parity bit to decide whether a transmission or storage error likely occurred.Step-by-Step Solution:Choose a parity type (even or odd) for the link or memory.Compute parity at the source: parity = XOR of all data bits, adjusted to meet the chosen parity rule.Transmit or store the data bits along with the parity bit.At the destination, recompute parity from received data bits and compare with the received parity bit.If mismatch occurs, flag a parity error indicating data corruption.Verification / Alternative check: Because parity is essentially an XOR (mod-2 sum) across the bits, it reliably detects any odd number of bit flips (not just one). For many practical channels where single-bit errors dominate, parity is effective and simple.Why Other Options Are Wrong: Determining which number is greater requires a magnitude comparator, not parity. Arithmetic errors in a CPU are handled by internal logic or checksums, not parity on the ALU outputs. Counter miscounts are detected by redundant encoding or watchdog logic, not parity alone.Common Pitfalls: Assuming parity corrects errors (it does not), or that it detects all multi-bit errors (it only guarantees detection of odd-count bit flips). Confusing even versus odd parity conventions can also lead to false error flags.Final Answer: errors in binary data transmission

Question 8

Identify the Boolean equation that correctly represents the two-input exclusive-OR (XOR) function in standard sum-of-products or equivalent Boolean form.

Accepted Answer

Introduction / Context: The exclusive-OR (XOR) function outputs 1 when its inputs differ and 0 when they are the same. It is fundamental in parity generation, adders (sum output), and data comparison circuits. Recognizing its Boolean forms is essential for simplification and hardware realization.Given Data / Assumptions:Two inputs: A and B.Standard Boolean operators: * for AND, + for OR, and ~ for NOT.Equivalent XOR forms exist; we focus on a correct canonical expression.Concept / Approach: By definition, XOR is true when exactly one of the inputs is 1. Translating that into Boolean algebra yields the canonical sum-of-products: A*~B + ~A*B. This covers the two cases (1,0) and (0,1) while excluding (0,0) and (1,1).Step-by-Step Solution:Write cases where output must be 1: (A=1,B=0) and (A=0,B=1).Translate each case to a product term: A*~B and ~A*B.OR the product terms: A*~B + ~A*B.Confirm zero output for (0,0) and (1,1) by evaluation.Verification / Alternative check: Another well-known XOR identity is (A + B) * ~(A*B). Expanding shows it reduces to A*~B + ~A*B, confirming equivalence. Truth-table evaluation also verifies the mapping.Why Other Options Are Wrong: A*B + ~A*~B is XNOR (true when inputs are equal). A + B is OR (true when any input is 1, including both). A*B is AND (true only when both are 1). None of these match the XOR behavior of “one but not both.”Common Pitfalls: Confusing XOR with OR, or picking the XNOR form by mistake. Also, forgetting the valid alternative XOR form (A + B) * ~(A*B) can cause uncertainty when simplifying expressions.Final Answer: A*~B + ~A*B

Combinational Logic Circuits Questions

Questions

Practice smarter