Architecture and Hardware

What does "asynchronous" mean?

Asynchronous means not happening at the same time or not tied to a shared clock. Here's what it means in everyday use, serial communication, hardware and code.

On this page
  1. The short answer
  2. Asynchronous in everyday use
  3. Asynchronous communication in electronics
  4. Asynchronous signals in digital hardware
  5. Asynchronous programming on microcontrollers
  6. Synchronous vs asynchronous at a glance

The short answer

Asynchronous means not happening at the same time or not coordinated by a shared timing signal. The word comes from Greek roots meaning “not with time”. Things that are asynchronous proceed independently, and each side handles events when they arrive rather than in lockstep with the other.

The opposite, synchronous, means coordinated in time: happening together, or driven by a common clock or schedule.

The exact meaning depends on context:

  • Everyday communication: you send a message and the other person replies later.
  • Serial communication: devices exchange data without a shared clock wire.
  • Digital hardware: a signal can change at any moment, not just on a clock edge.
  • Programming: a task starts and the program carries on without waiting for it to finish.

Asynchronous in everyday use

Email, text messages and forum posts are asynchronous communication: the sender and receiver don’t need to be present at the same time. A phone call or video meeting is synchronous, with both people taking part live. Asynchronous learning means coursework you complete on your own schedule, such as recorded lectures with deadlines, rather than live classes at fixed times.

Asynchronous communication in electronics

In embedded systems, “asynchronous” most often describes a serial link that has no shared clock signal between sender and receiver.

How asynchronous serial (UART) stays in step without a clock

A UART (universal asynchronous receiver-transmitter) is the classic example. The sender and receiver each use their own clock, so they have to agree on timing in advance and resynchronize as data arrives:

  1. Agree on a baud rate. Both sides are set to the same bit rate, such as 9600 or 115200 bits per second, and the same format, such as 8 data bits, no parity, 1 stop bit (“8N1”).
  2. Idle high. When nothing is being sent, the line sits at its idle (high) level.
  3. Start bit. The sender pulls the line low for one bit-time. That falling edge tells the receiver a character is beginning and lets it line up its timing.
  4. Data bits. The receiver samples each bit near the middle of its expected bit-time. Many UARTs oversample, for example 16 times per bit, to find the middle reliably.
  5. Stop bit. The line returns high for at least one bit-time, marking the end of the character and giving the receiver a gap before the next start bit.

Because the receiver re-aligns on every start bit, small differences between the two clocks don’t add up across a long message. They only need to stay close enough over one character. As a rule of thumb, the combined mismatch needs to stay within a few percent, which is why baud-rate mismatches show up as garbage characters.

Synchronous transmission for comparison

In synchronous communication, a clock signal travels with the data, either on its own wire or embedded in the data signal. The receiver samples each bit on a clock edge, so no baud rate agreement is needed and there’s no start or stop bit overhead per character. SPI and I2C are synchronous: the controller drives a clock line, and data is valid relative to its edges.

In short: synchronous links send timing alongside the data, while asynchronous links rely on both sides keeping time independently and resynchronizing on signal edges. Our embedded communication protocols guide compares UART, SPI, I2C and CAN in detail.

Other asynchronous protocols

  • RS-232 and RS-485 carry UART-style asynchronous data over longer cables using different electrical signalling.
  • CAN has no separate clock wire. Nodes resynchronize on edges in the data stream, so it’s usually described as asynchronous in this sense, though bit timing is tightly specified.
  • 1-Wire is timed by pulses from the controller rather than a continuous clock.

Asynchronous signals in digital hardware

Asynchronous inputs and synchronizers

Inside a microcontroller or FPGA, most logic is synchronous: it changes state only on clock edges. Signals from the outside world, such as a button press, a sensor’s “data ready” line or a signal from another clock domain, are asynchronous: they can change at any instant, including right at a clock edge.

When a flip-flop samples a signal that’s changing at the wrong moment, it can briefly enter an undefined state called metastability. Hardware designers guard against this with synchronizers, typically two flip-flops in a row, before the signal is used. Microcontroller GPIO and peripheral inputs normally include this internally, so firmware developers rarely deal with it directly. It matters a lot to FPGA designers.

Asynchronous reset

Datasheets often mention asynchronous reset: a reset signal that takes effect immediately, without waiting for a clock edge. A synchronous reset acts only on the next clock edge. Microcontroller reset pins are typically asynchronous in effect, so pulling the pin low resets the chip whether or not its clock is running.

Asynchronous programming on microcontrollers

Blocking vs non-blocking code

A blocking (synchronous) call waits until its work is done before returning. For example, a function that sends 100 bytes over UART and returns only after the last byte leaves. During that time, the CPU can’t do anything else.

A non-blocking (asynchronous) call starts the work and returns straight away. The hardware carries on in the background, and the program is told later when it’s finished. Meanwhile, the CPU can update a display, read sensors or go to sleep to save power.

The familiar Arduino delay() function is blocking. Rewriting a loop to check elapsed time with millis() instead is a simple step toward non-blocking code.

Interrupts, DMA and callbacks

Microcontrollers support asynchronous work in hardware:

  • Interrupts let a peripheral signal the CPU the moment something happens, such as a byte arriving, a timer expiring or a pin changing. The CPU pauses its current work, runs an interrupt service routine (ISR), then resumes.
  • DMA (direct memory access) moves data between peripherals and memory without the CPU copying each byte, then raises an interrupt when the transfer completes.
  • Callbacks are functions you register with a driver to be called when an operation finishes. Many vendor HAL libraries offer interrupt- or DMA-based versions of transmit and receive functions with completion callbacks.

An RTOS adds another layer: a task can wait on a queue or semaphore while other tasks run, and the waiting task wakes when an interrupt delivers the data.

async/await on embedded

Some languages offer async/await syntax that lets asynchronous code read like straight-line code. In embedded Rust, for example, frameworks such as Embassy use async/await to run many concurrent tasks on a single core without a traditional RTOS. MicroPython offers asyncio on supported boards. The underlying idea is the same: start an operation, yield until it completes, let something else run in the meantime.

The catch: shared data and race conditions

Because asynchronous events can arrive at any time, code that shares data between an ISR and the main program needs care:

  • Mark variables shared with an ISR as volatile in C or C++ so the compiler re-reads them rather than caching a stale value.
  • Protect multi-byte or read-modify-write accesses, for example by briefly disabling interrupts or using atomic operations, so an interrupt can’t land halfway through an update.
  • Keep ISRs short: record the event or move the data, then let the main code or a task do the heavy work.

Asynchronous designs are powerful but harder to debug than step-by-step code, so it pays to keep the shared state small and well defined.

Synchronous vs asynchronous at a glance

Context Synchronous Asynchronous
Everyday communication Live call or meeting Email, messages, forums
Serial communication Shared clock (SPI, I2C) No shared clock; agreed baud rate and start/stop bits (UART)
Digital logic Changes on clock edges Can change at any time; needs synchronizing
Reset Takes effect on the next clock edge Takes effect immediately
Programming Blocking: wait until done Non-blocking: continue and get notified later

Across every context, the core idea is the same: asynchronous activities aren’t locked to a common clock or schedule, so each side has to deal with events whenever they arrive. To see where communication links and interrupts fit into a complete device, see our embedded system architecture guide.

The complete guide to architecture and hardware

Embedded System Architecture: Hardware and Software Components
Read the guide

Keep exploring

Guides from other topics

All topics →