Hubbry Logo
Programmable interval timerProgrammable interval timerMain
Open search
Programmable interval timer
Community hub
Programmable interval timer
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Programmable interval timer
Programmable interval timer
Programmable interval timer
View on Wikipedia
from Wikipedia

In computing and in embedded systems, a programmable interval timer (PIT) is a counter that generates an output signal when it reaches a programmed count. The output signal may trigger an interrupt.

Common features

[edit]

PITs may be one-shot or periodic. One-shot timers will signal only once and then stop counting. Periodic timers signal every time they reach a specific value and then restart, thus producing a signal at periodic intervals. Periodic timers are typically used to invoke activities that must be performed at regular intervals.

Counters are usually programmed with fixed intervals that determine how long the counter will count before it will output a signal.

IBM PC compatible

[edit]

The Intel 8253 PIT was the original timing device used on IBM PC compatibles. It used a 1.193182 MHz clock signal (one third of the color burst frequency used by NTSC, one twelfth of the system clock crystal oscillator,[1] therefore one quarter of the 4.77 MHz CPU clock) and contains three timers. Timer 0 is used by Microsoft Windows (uniprocessor) and Linux as a system timer, timer 1 was historically used for dynamic random access memory refreshes and timer 2 for the PC speaker.[2]

The LAPIC in newer Intel systems offers a higher-resolution (one microsecond) timer.[3] This is used in preference to the PIT timer in Linux kernels starting with 2.6.18.[4]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Programmable interval timer

View on Grokipedia
from Grokipedia
A programmable interval timer (PIT) is a hardware counter device designed to generate precise timing signals and interrupts in microprocessor-based systems by decrementing from a programmed value until reaching zero, at which point it triggers an output pulse or signal. These timers typically operate using an external clock input and support configurable intervals ranging from microseconds to seconds, making them essential for tasks requiring accurate timekeeping without relying on software loops. The seminal implementation of a PIT is the , introduced in the late as a peripheral for microcomputers, featuring three independent 16-bit counters that use NMOS technology and a single +5V in a 24-pin DIP package. Its successor, the Intel 8254 (released shortly thereafter), enhanced this design with HMOS technology for higher clock speeds up to 10 MHz, additional read-back commands for status monitoring, and compatibility as a superset of the 8253, while maintaining the core structure of data bus buffering, read/write logic, and programmable control registers. Both chips support six operational modes—interrupt on terminal count, hardware-retriggerable one-shot, rate generator, square wave generator, software-triggered strobe, and hardware-triggered strobe—allowing binary or BCD counting for versatile applications like event counting or waveform generation. In computing history, PITs like the 8253/8254 became foundational in early personal computers, such as the IBM PC, where they provided system timing for real-time clocks, baud rate generation, and interrupt scheduling at frequencies derived from a 1.193 MHz oscillator. Beyond legacy x86 systems, modern embedded applications continue to employ PIT variants for , digital one-shots, and programmable rate multiplication, often integrated into microcontrollers for efficient, low-power timing without CPU intervention.

Overview

Definition and Purpose

A (PIT) is a specialized hardware counter circuit integrated into systems, designed to decrement from an initial value loaded by software at a constant until reaching zero, at which point it produces an output signal. This device functions as a versatile timing element, allowing precise control over intervals without relying on processor-intensive software loops. The primary purpose of a PIT is to facilitate accurate time management in microprocessors and embedded systems, supporting applications such as periodic task scheduling, event timing, delay generation, and frequency division. Unlike fixed-interval timers, a PIT offers software-configurable intervals, enabling adaptation to varying system requirements while minimizing CPU overhead by offloading timing operations to dedicated hardware. Upon expiration of the programmed count, the PIT generates an output signal that can transition to a low or high state, often triggering an to the processor. It supports both one-shot operation, where a single event is produced before requiring reconfiguration, and periodic operation, where the timer automatically reloads and repeats the cycle for ongoing intervals. As a foundational component for real-time operations, the PIT provides the essential timing basis in environments where continuous CPU polling for events would be inefficient, ensuring reliable interrupt-driven responses in multitasking and control systems.

Historical Context

The programmable interval timer (PIT) emerged in the 1970s as a critical peripheral for early microcomputers, developed by to provide precise timing and counting functions in systems lacking dedicated clock hardware. These devices addressed challenges in microprocessor-based designs, where asynchronous operations and handling required reliable periodic signals for tasks like event scheduling and data polling. 's focus on NMOS technology enabled compact, single-supply integration, making PITs essential for the burgeoning 8-bit ecosystem around the 8080 and processors. A key milestone came with the introduction of the in 1976, the first widely adopted PIT featuring three independent 16-bit counters programmable for various timing modes. This chip became a standard peripheral in Intel microcomputer systems, supporting frequencies up to 2.6 MHz and facilitating interrupt-driven operations. Its successor, the , arrived in the early 1980s with enhancements like read-back capabilities for counter status and higher clock speeds up to 10 MHz, offering greater flexibility for advanced applications while maintaining compatibility with the 8253. Adoption accelerated in the late 1970s across 8-bit platforms and peaked with the 1981 launch of the (Model 5150), where the 8253 served as the system timer, generating interrupts at approximately 18.2 Hz derived from a 1.193 MHz input clock. The evolution of PITs was driven by the growing need for dependable interrupt-based timing in multitasking operating systems and real-time embedded applications, where precise delays and event synchronization were paramount. In PC designs, clock derivation often drew from video standards, dividing the 14.31818 MHz color burst frequency by 12 to yield the 1.193 MHz PIT input, ensuring compatibility with display refresh rates. Early non-Intel variants appeared in competing architectures, such as 's Z80 CTC (Counter/Timer Circuit) introduced around 1979, which provided four channels for Z80-based systems like the Sinclair ZX Spectrum, offering similar programmable timing but optimized for daisy-chained interrupts. By the 2000s, the shift toward system-on-chip (SoC) integration supplanted discrete PITs, as microcontrollers and processors embedded timers directly to reduce component count, power consumption, and board space in compact devices.

Core Components and Features

Internal Architecture

A typical programmable interval timer (PIT) features a comprising three independent 16-bit down-counters, each equipped with a programmable input clock, a gate control signal for starting or stopping the count, and an output pin for generating timing signals. These counters operate asynchronously from one another but can be synchronized through their respective gate signals, allowing flexible timing configurations in systems. The clock source for each counter is an external oscillator input, typically ranging from 1 to 10 MHz, which drives the counting on the rising edge of the without an internal prescaler in standard designs. The interval time generated by a counter is calculated as T=NfclkT = \frac{N}{f_{clk}} seconds, where NN is the loaded count value (ranging from 1 to for 16-bit resolution) and fclkf_{clk} is the clock . Each counter's output signal (OUT) changes state upon reaching zero, with the exact behavior (, toggle, etc.) depending on the selected operating mode. Interfacing with the host CPU occurs via an 8-bit bidirectional data bus, enabling the loading of count values as least significant byte (LSB) followed by most significant byte (MSB). A dedicated control word register allows mode selection and counter assignment, while advanced variants include a read-back register for querying counter status, current count, and output levels without interrupting operation. Address decoding uses chip select (CS) and two address lines (A1, A0) to select between the three counters and the control register. PITs support both binary and (BCD) counting modes for versatile applications, with low-power variants (such as the 82C54) offering compatibility with TTL designs while consuming less power under a single 5V supply. These devices ensure broad compatibility, with counters handling clock inputs up to 10 MHz in high-speed versions.

Operating Modes

The operating modes of a programmable interval timer (PIT), such as the , are configured through an 8-bit control word written to the control word register, allowing independent programming of its three 16-bit counters. The control word format specifies the target counter (bits 7-6: 00 for counter 0, 01 for counter 1, 10 for counter 2), the read/write or latch command (bits 5-4: 00 to latch current count, 01 for least significant byte only, 10 for most significant byte only, 11 for least significant byte followed by most significant byte), the operating mode (bits 3-1: 000 for mode 0, 001 for mode 1, 010 for mode 2, 011 for mode 3, 100 for mode 4, 101 for mode 5), and the counting format (bit 0: 0 for binary, 1 for ). This structure enables flexible timing behaviors, with the input influencing operation differently across modes: it enables counting in modes 0, 2, 3, and 4, serves as a trigger in modes 1 and 5. Mode 0, known as interrupt on terminal count, operates as a one-shot where the counter loads the initial value and begins decrementing on the next clock edge after programming, with the output (OUT) initially low. Upon reaching terminal count (zero), OUT transitions high and remains high until the counter is reprogrammed or reloaded, making it suitable for generating precise delays or after a single interval. The shows OUT low during the counting period and high upon expiration, with counting disabled if is low. Mode 1 functions as a hardware-retriggerable one-shot, where OUT starts high and transitions low upon a rising edge on the input, initiating the countdown from the loaded value. If rises again before terminal count, the counter reloads and OUT remains low, allowing retriggering for extended pulses; at terminal count, OUT returns high. This mode is ideal for precise pulse-width generation in response to external hardware signals, with the waveform featuring a low pulse of duration equal to the programmed interval. In mode 2, the rate generator, the counter repeatedly divides the input clock by the loaded value N, producing a periodic output where OUT is high most of the time and pulses low for one clock cycle each time the count reaches one before reloading. This creates a continuous train of short pulses at a determined by the clock, commonly used for generating rates or periodic interrupts in serial communications. The consists of high periods interrupted by brief low pulses every N clock cycles. Mode 3, the square wave generator, produces an alternating high and low output with approximately equal duty cycles, where the counter decrements to zero and then reloads to generate toggles. For even N, each high and low phase lasts N/2 clock cycles; for odd N, the high phase is (N+1)/2 cycles and low is (N-1)/2 cycles, repeating continuously. This mode is particularly suited for tone generation in audio applications, such as driving speakers, due to its symmetric . Mode 4, software-triggered strobe, behaves similarly to mode 0 but with a brief output assertion: OUT remains high while counting down from the loaded value, transitions low upon terminal count, and returns high after one additional clock cycle before the counter reloads if commanded. Counting requires GATE high, and this mode supports software-initiated timing for events like strobing signals or short pulses in control systems. The waveform shows OUT high during the interval, followed by a single low clock pulse. Mode 5, hardware-triggered strobe, mirrors mode 4 but initiates counting on a rising edge of rather than software load, with OUT high until terminal count, then low for one clock cycle. must remain high after triggering to complete counting, making it useful for hardware-synchronized short pulses in event-driven systems. All modes support both binary and BCD counting formats as selected by the control word bit, allowing compatibility with decimal-based applications. To program a counter, the sequence begins by writing the 8-bit control word to select the mode and format, followed by loading the 16-bit count value (in one or two bytes depending on the read/write bits) into the selected counter's register. The counters operate as 16-bit down-counters in all modes, and the output for periodic modes like 2 and 3 is given by fout=fclkNf_{out} = \frac{f_{clk}}{N}, where fclkf_{clk} is the input clock and N is the loaded count (minimum 1, as N=0 is invalid).

Key Implementations

Intel 8253 PIT

The Programmable Interval Timer (PIT) was introduced in the late as a foundational component for timing and counting functions in early systems. It is housed in a 24-pin plastic (DIP) and operates on a single +5V TTL using nMOS technology. The chip features three independent 16-bit counters, each capable of handling clock inputs from DC up to a maximum of 2.6 MHz, enabling precise interval timing and event counting. Initially designed for integration with and 8085 microprocessor-based systems, it provided essential peripheral support for generating accurate delays and pulses. Key operational capabilities of the 8253 include support for six programmable modes (0 through 5), allowing configurations such as on terminal count, programmable one-shot, rate generator, square wave generator, hardware-triggered strobe, and software-triggered strobe. Each counter can perform counting in either binary or (BCD) format, with the mode selected via an 8-bit control word written to the ; the 8-bit control word configures the selected counter with bits 7–6 selecting the counter (0–2), bits 5–4 specifying the read/write operation (latch, LSB, MSB, or LSB then MSB), bits 3–1 selecting the mode (0–5), and bit 0 choosing binary (0) or BCD (1) counting. In typical system implementations, such as early PC compatibles, the 8253 interfaces via I/O ports 0x40 through 0x43, where ports 0x40–0x42 correspond to the data ports for counters 0–2, and 0x43 serves as the control port. A notable limitation of the 8253 is the absence of a read-back command, which in the 8254 provides status information along with latching; although the current can be latched and read without halting the counter, it lacks a dedicated for non-intrusive checks of operational details like mode or null , potentially complicating some real-time applications. Compared to its successor, the 8254, the 8253 operates at lower clock speeds (up to 2.6 MHz versus 10 MHz) and uses higher-power nMOS without enhancements like read-back commands or status querying, making it suitable primarily for the initial generation of personal computers before upgrades to the 8254 in later models. The three-counter architecture aligns with the general PIT design, providing independent channels for diverse timing tasks such as system interrupts and dynamic memory refresh.

Intel 8254 PIT

The 8254 Programmable Interval Timer (PIT), introduced in 1982, serves as an enhanced superset of the earlier 8253 model, providing improved timing and counting capabilities for systems. It maintains full pin compatibility with the 8253, enabling without hardware modifications, and is fabricated using high-performance HMOS technology to support higher operating speeds. The device features three independent 16-bit counters, each programmable for various timing functions, with the key upgrade being the addition of a read-back command that allows retrieval of the current count value and operational status without interrupting the counter's ongoing activity. This enhancement addresses limitations in real-time monitoring, making the 8254 suitable for more complex system designs. A notable advancement in the 8254 is its support for counter latching via the read-back feature, which captures the instantaneous count to prevent discrepancies during multi-byte reads in active counters. The control word is fully 8 bits, offering precise configuration of counter selection, read/write modes (such as latch counter, read-back, or least/most significant byte), operating modes, and binary/BCD counting formats. Programming differences include the ability to issue a read-back command to any specific counter or all three simultaneously; the resulting status byte reveals the counter's programmed mode, whether the output is high, the state, and if the initial count remains unprogrammed (null count). For scenarios involving partial reads during counting, the remaining ticks can be determined using the relation: remaining count = initial loaded value NN minus elapsed clock cycles since loading, ensuring accurate in time-sensitive applications. The 8254 was employed in the PC/AT (introduced in 1984), where it handled system timing, generation, and dynamic refresh, succeeding the 8253 in the prior XT model. Backward compatibility with 8253 software is maintained through identical basic programming sequences and mode operations, though the added read-back functionality requires no changes to legacy code while enabling optional advanced queries. Standard operation supports clock inputs up to 8 MHz, with the 8254-2 variant extending this to 10 MHz for faster processing environments. A low-power counterpart, the 82C54 (and Intel's P82C54), consumes significantly less power—typically under 10 mW—compared to the original HMOS version's 150 mW, making it ideal for portable or embedded systems while retaining all functional enhancements.

Usage in Systems

Integration in IBM PC Compatibles

In the original PC and its compatibles, the Programmable Interval Timer (PIT) was integrated into the system board via the I/O channel, occupying four consecutive ports starting at base address 0x40. Counter 0 was accessed at port 0x40, counter 1 at 0x41, counter 2 at 0x42, and the at 0x43, allowing software to configure modes and load initial counts through standard IN/OUT instructions. The PIT's input clock was derived from the system's main oscillator crystal of 14.31818 MHz, divided by 12 using a fixed prescaler circuit to produce an effective frequency of 1.193182 MHz for all three counters. This clock source originated from a multiple of the colorburst frequency (3.579545 MHz × 4), chosen for compatibility with video display generators like the used in the PC's monochrome and color graphics adapters. The counters were assigned specific roles to support core system operations. Counter 0 drove the system tick by generating periodic on IRQ0 (interrupt vector 0x08), programmed in mode 2 (rate generator) with an initial count of (loaded as 0x00 to the low byte at port 0x40, followed by 0x00 to the high byte), yielding approximately 18.2 Hz or 54.925 ms intervals to maintain the time-of-day clock and schedule software events. Counter 1 handled dynamic RAM (DRAM) refresh requests every 15 µs in mode 5 (hardware-triggered strobe), triggering row address strobe signals via the DMA controller to prevent memory data loss without software intervention. Counter 2 supported the for tone generation in mode 3 (square wave), where software could set divisor values to produce audible frequencies by toggling the speaker gate via port 0x61, and it also aided I/O timing. During system initialization, the programmed the PIT counters as described, with counter 0's IRQ0 handler incrementing a tick counter in low (at 0x0046:0x046C) to track elapsed time. Operating systems like relied on these s for basic scheduling, while modern descendants such as Windows and retain PIT support for legacy compatibility—reading the tick counter via BIOS 0x1A—but prioritize the (HPET) for higher-resolution, more accurate timing in contemporary x86 systems due to the PIT's limitations in precision and interrupt latency. The PIT's clock exhibited an inherent inaccuracy of approximately ±0.01% due to crystal oscillator tolerances, leading to cumulative drift of up to several seconds per day in long-running applications without external . This imprecision posed challenges for time-sensitive tasks but was mitigated in early multitasking environments like terminate-and-stay-resident (TSR) programs, which hooked the IRQ0 to perform background operations or cooperative task switching during the ~55 ms intervals, enabling rudimentary concurrency on the single-threaded OS.

Applications in Embedded Systems

In embedded systems, the Intel 8254 programmable interval timer (PIT) plays a key role in generating precise timing signals for various real-time operations, leveraging its three independent 16-bit counters to support functions beyond general-purpose computing. One prominent application is generating square waves using Mode 3, the square wave generator mode, which produces a continuous square wave output with approximately 50% (alternating between high and low states for equal or nearly equal periods depending on the count), suitable for applications such as baud rate generation or fixed-duty signal generation. This mode is particularly valuable in resource-constrained environments, where the PIT's ability to divide an input clock (up to 10 MHz) into lower frequencies supports efficient signal generation without additional hardware. For variable pulse-width modulation () used in , configurations involving two counters—one for the total period and one for the high-time —are typically employed. The 8254 also functions as a for system reliability, typically configured in Mode 0 (interrupt on terminal count) or Mode 5 (hardware-triggered strobe), where the counter is loaded with a timeout value and must be periodically reset by software; failure to do so triggers an or reset signal to recover from hangs or faults in critical embedded applications like industrial controls. Similarly, in Mode 2 (rate generator), the PIT generates periodic pulses that serve as a baud rate clock for universal asynchronous receiver-transmitters (UARTs), dividing the system clock to produce standard rates like 9600 for in embedded devices interfacing with sensors or peripherals. This mode ensures reliable data transmission by reloading the counter after each pulse, maintaining consistent intervals regardless of external gate signals. For event counting, the 8254's counters can be programmed to tally external pulses, such as those from , by sensor outputs to the clock input pin while using the input to enable or disable counting; although the counters operate in down-counting fashion, software can invert this for effective up-counting by preloading the maximum value (0xFFFF) and interpreting decrements as increments for applications like pulse-width measurement from proximity or flow . In automotive applications, derivatives of PIT architectures—programmable timer modules inspired by the 8254—have been employed in electronic control units (ECUs) for timing functions, such as in dashboards and control systems, to synchronize events and optimize performance. Integrated variants of PIT-like timers appear in many microcontrollers, where they facilitate by generating PWM signals for speed regulation in DC or motors, often combining timer interrupts with output compare units to adjust duty cycles dynamically based on feedback loops. Specific historical uses include timing applications in embedded systems under tight computational constraints. The advantages of the 8254 in embedded contexts stem from its low cost (as a single-chip solution under $5 in pricing) and simple parallel interfacing via an 8-bit data bus, making it ideal for integration into microprocessor-based systems without complex peripherals. However, challenges arise from its limited 16-bit resolution and fixed 10 MHz maximum , which constrain precision in high-speed applications (e.g., sub-microsecond timing), often leading to replacements with field-programmable gate arrays (FPGAs) that offer scalable counter depths and parallel processing for enhanced flexibility in modern embedded designs.

Modern Developments

Replacement Timers in PCs

As modern PCs evolved beyond the limitations of the original 8253/8254 PIT—such as its low 1.193 MHz frequency, shared access across cores leading to contention, and susceptibility to from inaccurate crystals—successor timers were integrated directly into processors and chipsets for higher precision and scalability. The Local APIC Timer, introduced with Intel's processors in 1993, marked an early hardware advancement by embedding a per-core within the processor's local (APIC).) This integration allowed independent timing on each core, programmable via memory-mapped registers (and later Model-Specific Registers, or MSRs, in x2APIC modes), with tick periods ranging from the clock period (typically nanoseconds) up to 128 times that, based on programmable dividers (1 to 128). Unlike the global PIT, the Local APIC Timer enabled efficient OS scheduling by delivering core-specific interrupts without bus arbitration overhead, reducing latency in multiprocessor systems. Another early PIT alternative, the Time Stamp Counter (TSC), emerged alongside the in 1993, providing a cycle-accurate, read-only counter incremented at the processor's core frequency. Accessible via the RDTSC instruction, the TSC offered sub-nanosecond resolution for time measurements but lacked generation, making it suitable as a high-speed reference rather than a full programmable timer; it addressed PIT shortcomings by scaling with CPU speeds up to multi-GHz rates without external clock dependencies. The High-Precision Event Timer (HPET), jointly developed by and and incorporated into PC chipsets starting in 2005, further advanced replacement capabilities with a dedicated hardware block featuring a 64-bit main counter running at 10–100 MHz (typically derived from a stable platform crystal). This frequency range provided periods as fine as 10 ns, calculated as T=1fhpetT = \frac{1}{f_{\text{hpet}}} (e.g., 100 ns at 10 MHz), enabling precise one-shot or periodic interrupts via up to 32 comparator registers per timer block that support virtual timer multiplexing for multiple applications. Integrated via 2.0 tables for OS discovery, HPET became a standard in systems supporting , though not strictly mandatory in earlier 1.0b implementations. Its fixed, CPU-independent clock eliminated PIT's drift issues (often ±0.01% accuracy limitations) and supported operations on >4 GHz processors without problems, improving reliability for time-sensitive tasks. Operating system transitions underscored HPET's adoption: Linux kernel 2.6.18 and later versions added support for HPET as a clocksource (with hrtimers for high-resolution timing), though the TSC is typically preferred as default when reliable, leveraging its high-resolution timers (hrtimers) for scheduling and POSIX compliance. Similarly, Windows Vista and subsequent releases utilized HPET as the primary multimedia timer, enhancing synchronization for audio/video processing over legacy PIT-based methods. These shifts, combined with TSC and Local APIC usage for core-level timing, rendered the PIT largely obsolete in contemporary x86 PCs, confining it to legacy compatibility modes.

Evolving Role in Contemporary Computing

In modern system-on-chips (SoCs), particularly microcontrollers based on architectures, programmable interval timer (PIT) principles are integrated through peripherals like the SysTick timer, a 24-bit down-counter that generates periodic interrupts for (RTOS) scheduling. This mechanism supports by decrementing from a reload value to zero, triggering exceptions at rates such as 1 kHz, and is essential for time-sliced multitasking in resource-constrained environments. These embedded timers play a key role in (IoT) devices, facilitating low-power periodic wake-ups from modes to enable efficient polling and data transmission while minimizing energy use—a capability increasingly adopted since the amid the rise of ultra-low-power . For example, SysTick is employed in Cortex-M-based IoT to precisely time execution intervals, ensuring compliance with power budgets in battery-operated nodes. In virtualized computing, hypervisors emulate PIT behavior to maintain compatibility for guest operating systems within cloud virtual machines (VMs), often by tracking virtual instruction counts and injecting interrupts to simulate hardware timing. However, this emulation introduces latency challenges, including 3× to 6× overheads in I/O-intensive workloads due to VM exit/entry costs and synchronization delays. Emerging trends highlight a shift to programmable fabrics in field-programmable gate arrays (FPGAs) for bespoke timer implementations, enabling custom decrementing counters with independent clock domains and interfaces like AHB-Lite for high-resolution, application-specific timing decoupled from host processors. Additionally, PIT-derived concepts support adaptive clocking in MCUs via , where timer interrupts trigger voltage and frequency adjustments to optimize power during variable workloads. In AI accelerators, such timers underpin batch timing and real-time scheduling, synchronizing tasks across heterogeneous cores to meet latency constraints in edge deployments.

References

  1. https://www.idc-online.com/technical_references/pdfs/electronic_engineering/8253_Timer_IC_General.pdf
  2. https://www.scs.stanford.edu/10wi-cs140/pintos/specs/8254.pdf
  3. https://intel-vintage-developer.eu5.org/DESIGN/PERIPHRL/TECHNOTE/7203.HTM
  4. https://bitsavers.computerhistory.org/components/intel/MCS80/98-153D__MCS-80_Users_Manual_Oct77.pdf
  5. https://www.worldradiohistory.com/Archive-Electronics/70s/76/Electronics-1976-04-15.pdf
  6. https://www.ibm.com/history/personal-computer
  7. https://wiki.osdev.org/Programmable_Interval_Timer
  8. https://datasheets.chipdb.org/Zilog/Z80_PERIPHERALS/Z80_CPU_PERIPHERALS.pdf
  9. https://www.shmj.or.jp/english/pdf/ic/exhibi736E.pdf
  10. https://sapr.asvcorp.ru/datasheets/64/05/00000000564.pdf
  11. http://dylucknow.weebly.com/uploads/6/7/3/1/6731187/8253-4.pdf
  12. http://mcsprogram.org/browse/u5400C/246980/explain_8253__microprocessor_with_diagram.pdf
  13. https://www.circuits-diy.com/8253-programmable-interval-timer-datasheet/
  14. https://www.geeksforgeeks.org/electronics-engineering/differences-between-8253-and-8254/
  15. https://www.alldatasheet.com/datasheet-pdf/pdf/66099/INTEL/8254.html
  16. https://www.techedge.com.au/tech/8253tec.htm
  17. https://www.renesas.com/us/en/document/dst/82c54-datasheet
  18. http://www.tiij.org/issues/issues/spring2007/30_Jenkins/Jenkins-Programming%20the%208254%20PIT.pdf
  19. https://www.boondog.com/tutorials/8254/8254.htm
  20. http://www.bitsavers.org/components/intel/_dataBooks/1988_Intel_Embedded_Controller_Handbook_Volume_I_8-Bit.pdf
  21. https://www.intel.com/content/dam/www/public/us/en/documents/technical-specifications/software-developers-hpet-spec-1-0a.pdf
  22. https://wiki.osdev.org/APIC_Timer
  23. https://www.intel.com/content/dam/www/public/us/en/documents/technical-specification/software-developers-hpet-spec-1-0a.pdf
  24. https://learn.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps
  25. https://developer.arm.com/documentation/dui0552/latest/cortex-m3-peripherals/system-timer--systick
  26. https://developer.arm.com/documentation/101407/latest/Debugging/Debug-Windows-and-Dialogs/Core-Peripherals/Armv7-M-cores/Armv7-M--System-Tick-Timer
  27. http://www.cs.unc.edu/techreports/11-010.pdf
  28. https://ww1.microchip.com/downloads/aemDocuments/documents/FPGA/ApplicationNotes/ApplicationNotes/smartfusion_timer_an.pdf
  29. https://www.ti.com/lit/pdf/slva646
Add your contribution
Related Hubs
User Avatar
No comments yet.