Hubbry Logo
Synchronous circuitSynchronous circuitMain
Open search
Synchronous circuit
Community hub
Synchronous circuit
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Synchronous circuit
Synchronous circuit
Synchronous circuit
View on Wikipedia
from Wikipedia

In digital electronics, a synchronous circuit is a digital circuit in which the changes in the state of memory elements are synchronized by a clock signal. In a sequential digital logic circuit, data is stored in memory devices called flip-flops or latches. The output of a flip-flop is constant until a pulse is applied to its "clock" input, upon which the input of the flip-flop is latched into its output. In a synchronous logic circuit, an electronic oscillator called the clock generates a string (sequence) of pulses, the "clock signal". This clock signal is applied to every storage element, so in an ideal synchronous circuit, every change in the logical levels of its storage components is simultaneous. Ideally, the input to each storage element has reached its final value before the next clock occurs, so the behaviour of the whole circuit can be predicted exactly. Practically, some delay is required for each logical operation, resulting in a maximum speed limitations at which each synchronous system can run.

To make these circuits work correctly, a great deal of care is needed in the design of the clock distribution networks. Static timing analysis is often used to determine the maximum safe operating speed.

Nearly all digital circuits, and in particular nearly all CPUs, are fully synchronous circuits with a global clock. Exceptions are often compared to fully synchronous circuits. Exceptions include self-synchronous circuits,[1][2][3][4] globally asynchronous locally synchronous circuits, and fully asynchronous circuits.

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Synchronous circuit

View on Grokipedia
from Grokipedia
A synchronous circuit is a type of digital sequential circuit where the state changes and outputs are synchronized by a periodic , ensuring that all flip-flops and storage elements update their values simultaneously at the clock's active edges. This synchronization distinguishes synchronous circuits from asynchronous ones, as it relies on discrete time instants defined by the clock rather than continuous signal propagation. The core components of a synchronous circuit include circuits for processing inputs and generating next states, memory elements such as edge-triggered flip-flops (e.g., , JK, or T flip-flops) to store the current state, and a global to control timing. In operation, the present state (stored in flip-flops) and external inputs feed into the to produce outputs and next-state values, which are then loaded into the flip-flops on the clock edge, creating a predictable sequence of states over time. This structure forms the basis of finite state machines (FSMs), which are widely used in digital systems for tasks like sequence detection and control logic. Synchronous circuits are categorized into Moore machines, where outputs depend solely on the current state, and Mealy machines, where outputs also depend on the inputs, allowing for more responsive behavior in certain applications. Their clock-driven nature provides advantages in design predictability and ease of verification compared to asynchronous circuits, which respond to input changes without a clock and can suffer from timing hazards. However, synchronous designs must account for and distribution challenges in large-scale integrated circuits to maintain reliability.

Overview

Definition and Principles

A synchronous circuit, also known as a synchronous sequential circuit, is a type of digital circuit in which the state changes of elements occur at discrete instants of time, precisely synchronized by a common . This synchronization ensures that the circuit's behavior is predictable and depends not only on the current inputs but also on previous states stored in . Unlike combinational circuits, where outputs are determined solely by current inputs with no of past states, synchronous circuits incorporate feedback through storage elements, making their outputs a function of both present inputs and prior history. The foundational principle of synchronous circuits revolves around the clock signal, which acts as a global synchronizer to coordinate all state transitions. Memory elements, such as flip-flops, update their outputs exclusively on the active edges of the clock—typically the rising or falling edge—ensuring that changes propagate simultaneously across the circuit. This clock-driven timing prevents race conditions, where asynchronous signal propagation could lead to indeterminate states, by confining updates to predefined moments and allowing combinational logic outputs to settle before feeding into the memory elements. A generic synchronous sequential circuit structure comprises primary inputs, a combinational logic block that computes next states and outputs based on current inputs and states, elements that hold the present state, and feedback paths from the memory to the logic. The drives the memory elements, while outputs are derived from the combinational logic. This can be visualized as follows: external inputs and present state enter the combinational circuit, producing next-state signals that update the memory on clock edges and output signals that reflect the circuit's response.

Comparison to Asynchronous Circuits

Synchronous circuits differ fundamentally from asynchronous circuits in their approach to timing and state transitions. In synchronous designs, a global dictates the timing of all operations, ensuring that state changes occur simultaneously across the circuit at regular intervals, based on worst-case delay assumptions. This contrasts with asynchronous circuits, which operate without a central clock, relying instead on local handshaking protocols or signal propagation delays to coordinate events, enabling data-driven or event-triggered behavior. Synchronous circuits offer several advantages in terms of predictability and design simplicity. Their clock-based provides uniform timing, making behavior more deterministic and easier to analyze, verify, and debug using established (CAD) tools. This approach also minimizes risks by aligning transitions to clock edges, enhancing overall reliability in large-scale systems. However, these benefits come at the cost of clock distribution overhead, which can introduce skew—variations in clock arrival times—and increase power consumption due to continuous clock toggling, sometimes accounting for up to 40% of total power in unoptimized designs. Asynchronous circuits, by eliminating the clock, address some synchronous limitations but introduce others. They can achieve lower power dissipation since only active components consume energy, without the idle switching of a global clock, and may exhibit higher speeds in average-case scenarios by avoiding worst-case delay penalties. Additionally, they demonstrate greater robustness to , voltage, and variations, as well as reduced . Despite these strengths, asynchronous designs are more challenging to implement, as they require careful hazard avoidance and glitch-free operation, with fewer mature verification tools available, leading to higher design complexity and potential reliability issues from timing uncertainties. Historically, synchronous circuits gained dominance in the and alongside the rise of very-large-scale integration (VLSI), as their predictable timing facilitated scalable integration and automated design flows in complex integrated circuits, overshadowing asynchronous approaches despite the latter's earlier origins in the mid-20th century. This shift was driven by the need for reliable, tool-supported methodologies in growing technologies.

Components

Memory Elements

In synchronous circuits, the primary memory elements are flip-flops, which store binary state information and update their outputs only in response to a transition, ensuring synchronized operation across the circuit. Unlike latches, which are level-sensitive devices that continuously propagate inputs to outputs while the enable signal is active, flip-flops are edge-triggered, making them essential for maintaining precise timing and avoiding race conditions in synchronous designs. This edge-triggered behavior allows flip-flops to capture input values at specific clock edges, typically the rising or falling edge, providing the temporal isolation required for reliable state storage. Flip-flops are classified into several types based on their input configurations, including SR (Set-Reset), JK, (Data), and T (Toggle), each with distinct characteristic equations, truth tables, and excitation tables that define their behavior and usage in state storage. The SR flip-flop uses Set (S) and Reset (R) inputs to force the output to 1 or 0, respectively, with its characteristic equation given by Qn+1=S+RˉQnQ_{n+1} = S + \bar{R} Q_n (where QnQ_n is the current state and the input S=1, R=1 is typically forbidden to avoid indeterminate states). Its is as follows:
SRQ_{n+1}
00Q_n
010
101
11Invalid
The excitation table for the SR flip-flop, which specifies the inputs needed to achieve desired state transitions, is:
Q_nQ_{n+1}SR
000X
0110
1001
11X0
The JK flip-flop extends the SR design by allowing J=1 and K=1 to toggle the state, addressing the invalid SR condition, with characteristic equation Qn+1=JQnˉ+KˉQnQ_{n+1} = J \bar{Q_n} + \bar{K} Q_n. Its truth table is:
JKQ_{n+1}
00Q_n
010
101
11\bar{Q_n}
The for the JK flip-flop is:
Q_nQ_{n+1}JK
000X
011X
10X1
11X0
The D flip-flop simplifies by directly transferring the D input to the output on the clock edge, with characteristic equation Qn+1=DQ_{n+1} = D, making it ideal for registers. Its is:
DQ_{n+1}
00
11
The excitation table for the D flip-flop is straightforward:
Q_nQ_{n+1}D
000
011
100
111
Finally, the T flip-flop toggles its state when T=1, with characteristic equation Qn+1=Qn⊕TQ_{n+1} = Q_n \oplus T, commonly used in counters. Its truth table is:
TQ_{n+1}
0Q_n
1\bar{Q_n}
The for the T flip-flop is:
Q_nQ_{n+1}T
000
011
101
110
These flip-flop types are constructed using logic gates, often in a master-slave configuration to achieve edge-triggered operation and prevent feedback interference during the clock cycle. The master-slave structure consists of two cascaded : the master is enabled during one clock phase (e.g., clock high for positive-edge triggering) to sample inputs, while the slave is enabled during the complementary phase to hold and transfer the stable value to the output, typically implemented with NAND or NOR gates for the underlying SR or D latches. This configuration ensures that the output changes only on the clock edge, isolating the input sampling from output propagation. In synchronous circuits, flip-flops serve as the fundamental units for storing state bits, where their outputs (Q and \bar{Q}) are fed back to gates to compute the next-state inputs, enabling the circuit to evolve predictably with each clock cycle. This feedback loop forms the basis for sequential behavior, with flip-flops updating on clock edges to synchronize state transitions across multiple elements.

Clocking Systems

In synchronous digital circuits, the serves as a periodic , typically a square wave, that establishes a precise time reference for coordinating data movement and state changes across the system. This signal oscillates at a defined , which is the inverse of its period (for example, a 200 MHz clock has a 5 ns period), and usually maintains a 50% to ensure balanced high and low phases for reliable operation. The clock triggers actions primarily on its rising or falling edges, where elements capture input data at these transitions to maintain synchrony. Clock signals are generated using stable sources such as crystal oscillators, which provide a low-noise reference ranging from tens to hundreds of MHz, often in the form of a quartz crystal vibrating at its resonant to produce a consistent output. In integrated circuits, phase-locked loops (PLLs) enhance this by multiplying the reference through a feedback mechanism involving a , , and , locking the output phase to the input while filtering noise for high stability. This combination enables on-chip clocks to reach exceeding 1 GHz in modern microprocessors. For distribution, the clock signal propagates through networks like buffered clock trees, where repeaters and amplifiers are inserted to counteract signal degradation over long distances and high fanouts, which are among the largest in the system. To minimize skew—the variation in arrival times at different points—symmetric structures such as H-trees are employed, featuring balanced branching and tapered wire widths that ensure uniform propagation delays, as seen in designs achieving skews below 75 ps. Buffers in these trees, often sized progressively (e.g., X50 to X134 drive strengths), further optimize latency and power while maintaining zero or near-zero skew. In complex systems like system-on-chips (SoCs), multiple clock domains operate at different frequencies to support diverse functional units, generated via PLLs or delay-locked loops for across regions. addresses power efficiency by inserting logic gates along clock paths to disable toggling in inactive domains, preventing unnecessary switching in registers and reducing dynamic power by up to 14.5% without significant timing overhead. This technique uses hierarchical models to apply gating conditions selectively per domain, ensuring glitch-free operation.

Design and Analysis

State Machine Design

Synchronous circuits are often designed using finite state machines (FSMs), which model the system's behavior as a set of states, transitions between states based on inputs, and outputs produced in response to those states or inputs. This approach ensures that all state changes occur synchronously with the , providing predictable timing and glitch-free operation. FSM design begins with abstract specifications and proceeds to hardware implementation, focusing on logical correctness before physical constraints. Two primary FSM models are used in synchronous circuit design: and Mealy machines. In a , outputs depend solely on the current state and are generated combinatorially from state variables, resulting in outputs that change synchronously with state transitions on clock edges. This model simplifies output logic but may require more states for equivalent functionality. For example, a detecting a specific sequence like "101" in a serial input stream would produce an output assertion only upon entering a dedicated state after the sequence is fully matched. In contrast, a generates outputs that depend on both the current state and the inputs, allowing outputs to change immediately upon input arrival within the same clock cycle, potentially reducing the number of states needed. This can lead to faster response times but introduces the risk of combinational feedback paths if not carefully managed. Using the same "101" example, a Mealy machine might assert the output as soon as the final '1' input arrives in the appropriate state, without needing an extra state for output generation. The design process for synchronous FSMs follows a structured to derive an efficient from behavioral specifications. First, a is created, representing states as circles, transitions as directed arcs labeled with input conditions and output actions, providing a visual model of the system's dynamics. Next, the is converted into a state table listing current states, inputs, next states, and outputs, which serves as the basis for logic synthesis. State minimization follows to reduce the number of states while preserving functionality, typically using implication charts or partitioning methods to merge equivalent states. For the next-state and output logic, Karnaugh maps (K-maps) are employed to minimize expressions: variables representing current state and inputs form the map axes, with entries from the state table used to group adjacent 1s for sum-of-products simplification. This step yields compact equations, such as for a two-bit state encoding where next-state functions might simplify to D1=S0‾I+S1I‾D_1 = \overline{S_0} I + S_1 \overline{I} after K-map reduction. Implementation of the FSM involves mapping states to flip-flops for storage and deriving gates for next-state and output functions. Flip-flops, such as D-type, hold the current state on clock edges, with their inputs driven by the minimized next-state logic. State encoding choices include binary encoding, which uses the minimal number of bits (⌈log⁡2N⌉\lceil \log_2 N \rceil for NN states) to minimize flip-flop count but can lead to glitches during transitions due to multiple bit changes. encoding, conversely, assigns a unique flip-flop to each state (active high for the current state), simplifying decoding and improving in FPGA implementations, though it requires more flip-flops and logic resources. Modern synchronous FSM design leverages hardware description languages (HDLs) like and for and automated synthesis. In , an FSM can be described using an for states within a sensitive to clock and reset, with case statements defining transitions and outputs, which synthesis tools map to flip-flops and gates. similarly uses always blocks for , supporting both Moore and Mealy styles through non-blocking assignments for state updates. Tools like Design Compiler or infer FSM structures from HDL code, applying optimizations such as encoding selection during technology mapping to RTL or netlists.

Timing and Synchronization

In synchronous circuits, reliable operation hinges on precise timing parameters that govern the interaction between data signals and the clock. Setup time refers to the minimum duration the data input must remain stable before the active clock edge to ensure correct latching in memory elements like flip-flops. Hold time is the minimum duration the data must remain stable after the clock edge to prevent inadvertent changes from affecting the stored value. Clock-to-output delay, often denoted as tCLK→Qt_{CLK \to Q}, represents the propagation time from the clock edge to the valid output change at the flip-flop. These parameters are critical for defining the operational boundaries of the circuit. The minimum clock period TT must satisfy the inequality T>tpd+tsu+tskewT > t_{pd} + t_{su} + t_{skew}, where tpdt_{pd} is the propagation delay, tsut_{su} is the setup time, and tskewt_{skew} accounts for ; this ensures data propagates and stabilizes within one cycle without violations. arises from differences in arrival times at various flip-flops due to interconnect delays in the distribution network, potentially causing setup or hold violations if not managed. introduces short-term variations in clock period or phase from sources, further complicating timing reliability by altering edge positions unpredictably. Metastability occurs when a flip-flop input changes too close to the clock edge, leaving the output in an indeterminate state that may persist, leading to synchronization failures across clock domains. typically involves synchronizers, such as two-stage flip-flop chains, which provide additional settling time to resolve metastable states with high probability before the signal propagates further. Static timing analysis (STA) is a primary method for verifying these constraints without simulation, by computing signal arrival and required times across all paths to identify violations. Critical path identification within STA focuses on the longest delay path between registers, determining the maximum achievable clock frequency; tools compute slack as the difference between required and actual arrival times, flagging negative values for optimization. For verification, simulations incorporating timing models—such as those using standard delay format (SDF) files—replicate real-world delays to check for no setup or hold violations at the target clock frequency, complementing STA with dynamic behavior assessment.

Applications

Basic Building Blocks

Synchronous circuits are constructed from fundamental modules that store and process in coordination with a . These basic building blocks include registers for , counters for generation, and arithmetic units like adders and ALUs for , all synchronized to ensure reliable operation. Registers provide parallel in synchronous circuits, typically implemented using D flip-flops as the core memory elements. An n-bit register consists of n D flip-flops connected in parallel, each storing one bit, with a common clock input that updates all bits simultaneously on the clock edge. The input is latched into the register when enabled, holding the value stable between clock cycles for subsequent logic operations. Shift registers extend this functionality for serial-to-parallel , such as in serial-in/parallel-out configurations. In a serial-in/parallel-out , data enters one bit at a time through a single input and shifts through the flip-flops on each clock pulse, with all bits available simultaneously at the parallel outputs after n cycles for an n-bit register. This module is essential for interfacing between lines and parallel processing paths in synchronous designs. Counters generate sequential binary codes in response to clock pulses, serving as fundamental timing and sequencing elements in synchronous circuits. Unlike ripple counters, where flip-flop outputs propagate sequentially causing delays, synchronous counters connect all flip-flop clock inputs to a common clock, ensuring simultaneous state changes without propagation ripple. A binary counter, for example, can be built using JK flip-flops, where each flip-flop toggles based on logic from prior bits to increment the count. Synchronous counters support up/down counting and modulo-N operation for customized sequences. In an up/down counter, a control signal reverses the increment/decrement logic, allowing bidirectional counting from 0 to 2^n - 1 or vice versa for an n-bit design. Modulo-N counters reset to zero after reaching N (where N ≤ 2^n) by decoding the terminal state to a reset signal, effectively dividing the clock frequency by N. The count value updates on each rising clock edge according to the equation Qk+1=(Qk+1)mod  NQ_{k+1} = (Q_k + 1) \mod N , where Q_k is the current state and k indexes the clock cycle. A practical example is the 4-bit synchronous binary up-counter using JK flip-flops, which counts from 0000 to 1111 (0 to 15 in ) before wrapping around. The circuit features four JK flip-flops (Q3 as MSB to Q0 as LSB), with J and K inputs derived from AND gates on lower-order outputs: for Q0, J0 = K0 = 1 (always toggle); for Q1, J1 = K1 = Q0; for Q2, J2 = K2 = Q0 · Q1; for Q3, J3 = K3 = Q0 · Q1 · Q2. All flip-flops share the clock input, and a clear input resets to 0000 asynchronously if needed. On each clock pulse, the state increments synchronously: starting at 0000, the first edge sets Q0 to 1 (0001); subsequent edges toggle higher bits as lower bits roll over, producing the binary sequence without delay accumulation. The output shows Q0 toggling every cycle (50% duty), Q1 every two cycles (25% duty), Q2 every four (12.5%), and Q3 every eight (6.25%), illustrating the frequency division inherent in binary counting. Adders and ALUs in synchronous circuits incorporate clocked registers to pipeline operations, breaking complex into clock-synchronized stages for higher throughput. A synchronous , such as a ripple-carry or carry-lookahead design, places registers at inputs and outputs to capture operands and results on clock edges, preventing timing skew in multi-stage . inserts these registers to balance path delays, allowing the clock period to match the longest stage delay rather than the entire , though it increases overall latency by one cycle per stage. Synchronous ALUs extend adders by integrating multiple operations (add, subtract, logic gates) with clocked registers for storage and result latching. The ALU receives inputs from register files via a data bus, performs the selected operation combinatorially, and stores the output in a destination register on the next clock edge, ensuring all data transfers align with the global clock. This registered approach enables pipelined execution in larger systems, where ALU results feed back into registers for chained computations without race conditions.

Advanced Systems

Synchronous circuits serve as the foundational in modern microprocessors and central units (CPUs), where stages operate in unison under a global clock to ensure precise coordination of operations. In these systems, the instruction fetch-decode-execute cycle is synchronized across multiple stages, allowing for efficient by issuing a new instruction every clock cycle. This clock-driven approach minimizes timing hazards and enables high-throughput , as exemplified in five-stage pipelined MIPS processors that verify functionality through structured clocked sequences. In field-programmable gate arrays (FPGAs) and application-specific integrated circuits (ASICs), synchronous logic blocks form the core reconfigurable units, interconnected via clock domains to manage data flow in complex designs. FPGAs employ configurable logic blocks (CLBs) that integrate synchronous flip-flops for state storage, enabling predictable timing in logic arrays. Similarly, ASICs utilize multiple clock domains to partition functionality, addressing (CDC) challenges that arise from asynchronous interactions between domains, which is critical for scaling performance in high-end chips. Contemporary advancements in synchronous circuit design incorporate hybrid models such as Globally Asynchronous Locally Synchronous () architectures, which divide systems into synchronous islands connected by asynchronous channels to mitigate global clock distribution issues. reduces power consumption and timing complexity in large-scale integrations by allowing local clocks to operate independently while maintaining synchronous behavior within modules. Complementing this, low-power techniques like dynamic voltage and frequency scaling (DVFS) adjust clock frequency and supply voltage in tandem to optimize energy efficiency without compromising synchronous timing integrity. These synchronous frameworks underpin diverse applications, including embedded systems where clocked ensures reliable state management in resource-constrained environments. In telecommunications, (SDRAM) provides high-bandwidth data access synchronized to system clocks, supporting real-time packet processing in network hardware. For (DSP), synchronous circuits enable precise timing in filters and transforms, facilitating efficient handling of sampled data streams in audio and image processing pipelines.

References

  1. https://my.ece.utah.edu/~kalla/ECE3700/verlogic3_chapter6.pdf
  2. https://people.engr.tamu.edu/xizhang/ECEN248/Chapter_7_8_Chapter_Part-I_Xi_Zhang.pdf
  3. https://engweb.eng.wayne.edu/ad/ad57/ad5781/public_html/ECECourses/ECE2610/LectureNotes/Lecture10.pdf
  4. https://www.vssut.ac.in/lecture_notes/lecture1430873727.pdf
  5. https://www.ebookbou.edu.bd/Books/Text/SST/DCSA/dcsa_2301/Unit-03.pdf
  6. https://people.ece.uw.edu/hauck/publications/AsynchArt.pdf
  7. https://users.cs.utah.edu/~ald/pubs/ald-nowick-tr-intro.pdf
  8. https://www.eng.auburn.edu/~agrawvd/COURSE/E6270_Spr15/PROJECT/REPORTS/Conover_Project.pdf
  9. http://web.cecs.pdx.edu/~mperkows/CLASS_573/febr-2007/davis-nowick-intro-tr.pdf
  10. https://www.academia.edu/11780788/INTRODUCTION_OF_VLSI_TECHNOLOGY
  11. https://www.cs.ucr.edu/~ehwang/courses/cs120b/flipflops.pdf
  12. https://users.ece.utexas.edu/~mcdermot/vlsi1/main/lectures/lecture_10.pdf
  13. https://digitalcommons.njit.edu/context/oat/article/1000/viewcontent/Carpinelli_Animated_Digital_Logic_Design_CompleteBook.pdf
  14. https://www.academia.edu/37781601/Introduction_to_Sequential_Circuits
  15. https://www.ece.iastate.edu/~alexs/classes/2015_Fall_281/slides_PDF/25_D_Flip-Flops.pdf
  16. https://saaubi.people.wm.edu/TeachingWebPages/Physics351_Fall2008/Week3/Chapter3_FlipFlops.pdf
  17. https://hajim.rochester.edu/ece/sites/friedman/papers/ProIEEE.pdf
  18. https://web.ece.ucsb.edu/~long/ece594a/PLL_intro_594a_s05.pdf
  19. https://vlsicad.ucsd.edu/Publications/Journals/j128.pdf
  20. https://users.ece.utexas.edu/~mcdermot/vlsi1/main/lectures/lecture_9.pdf
  21. https://people.eecs.berkeley.edu/~alanmi/publications/2008/dac08_hurst2.pdf
  22. https://www.allaboutcircuits.com/textbook/digital/chpt-11/finite-state-machines/
  23. https://www.eeeguide.com/synchronous-sequential-circuits/
  24. https://ee.usc.edu/~redekopp/ee101/slides/EE101Lecture20.pdf
  25. https://people.eecs.berkeley.edu/~randy/Courses/CS150.F00/Lectures/06-SeqImpl.pdf
  26. https://www.oreilly.com/library/view/introduction-to-digital/9780470900550/chap9-sec014.html
  27. https://trilobyte.com/pdf/golson_snug94.pdf
  28. https://www.allaboutcircuits.com/technical-articles/implementing-a-finite-state-machine-in-vhdl/
  29. https://kolegite.com/EE_library/papers/HDL/Finite_state_machines_in_VHDL.pdf
  30. https://www.engr.siu.edu/haibo/ece428/notes/ece428_synchr1.pdf
  31. https://engineering.purdue.edu/~vlsi/ECE559_Fall09/Notes/SequentialLogic.pdf
  32. http://web.mit.edu/6.111/www/f2016/handouts/L04.pdf
  33. https://courses.cs.washington.edu/courses/cse371/24sp/lectures/13/EECSE371-Sp24-13-CDC.pdf
  34. http://www.gstitt.ece.ufl.edu/courses/spring11/eel4712/lectures/metastability/EEIOL_2007DEC24_EDA_TA_01.pdf
  35. https://schaumont.dyn.wpi.edu/ece574f24/05timinganalysis.html
  36. https://course.ece.cmu.edu/~ee760/760docs/lec17.pdf
  37. https://tnm.engin.umich.edu/wp-content/uploads/sites/353/2021/03/1990.09.timeingVerify.CSE-TR-71-90.pdf
  38. https://www.uvm.edu/~cbcafier/cs2210/content/05_cpu_alu/registers.html
  39. https://gab.wallawalla.edu/~curt.nelson/engr354/lecture/chapter7_reg_counters.pdf
  40. https://www.allaboutcircuits.com/textbook/digital/chpt-11/synchronous-counters/
  41. https://www.electronics-tutorials.ws/counter/mod-counters.html
  42. https://openlab.citytech.cuny.edu/cet4805/files/2011/06/CET4805_Lab7_4bit_counter.pdf
  43. https://www.electronics-tutorials.ws/counter/count_3.html
  44. https://hajim.rochester.edu/ece/sites/friedman/papers/IJE_91.pdf
  45. https://personal.utdallas.edu/~dodge/EE2310/lec8.pdf
  46. https://docs.amd.com/r/en-US/ug474_7Series_CLB
  47. https://www.synopsys.com/blogs/chip-design/what-is-clock-domain-crossing.html
  48. https://ieeexplore.ieee.org/document/1257653
  49. https://ieeexplore.ieee.org/document/806526
  50. https://semiengineering.com/globally-asynchronous-locally-synchronous-clocks/
  51. https://semiengineering.com/knowledge_centers/low-power/techniques/dynamic-voltage-and-frequency-scaling/
  52. https://ieeexplore.ieee.org/document/936382
  53. https://www.alliancememory.com/product/synchronous-drams/
  54. https://www.legacyelectronics.com/products/sdram/
Add your contribution
Related Hubs
User Avatar
No comments yet.