Switch Debouncing

Switch debouncing is a fundamental technique in digital electronics and embedded systems that addresses the physical phenomenon of contact bounce in mechanical switches, ensuring that a single actuation is registered as a single, clean logic transition by a microcontroller or digital circuit [7]. When a mechanical switch or button is pressed or released, its metal contacts do not make or break cleanly; instead, they rapidly bounce against each other for a few milliseconds, generating a series of erratic electrical pulses before settling into a stable state [7]. This bounce can cause a digital input to be misinterpreted as multiple rapid presses, leading to erroneous behavior in circuits, keyboards, and control systems [7]. As a critical form of signal conditioning, debouncing is classified as an essential interface design practice for reliable human-machine interaction, sitting at the intersection of hardware design and software firmware. The core characteristic of switch bounce is its inherent mechanical nature, which is independent of the electrical function of the switch. The debouncing process works by filtering out these transient oscillations to deliver a single, definitive logic-level change to the input pin of a microcontroller or logic gate [7]. The main types of debouncing solutions are broadly categorized into hardware and software methods. Hardware debouncing utilizes passive resistor-capacitor (RC) filter networks to smooth the voltage transition, or dedicated Schmitt trigger circuits to provide hysteresis and a sharpened output signal. Software debouncing, often implemented in firmware, employs algorithms that ignore state changes for a predetermined settling period after an initial transition is detected, or uses periodic sampling to determine a stable switch state [7]. The choice between methods often involves trade-offs between component cost, board space, and processor overhead. The applications of switch debouncing are ubiquitous in any system involving mechanical user input. It is critically significant in keyboard matrix circuits, where a grid arrangement of rows and columns enables a microcontroller to detect multiple key presses using a reduced number of input/output pins [7]. Without effective debouncing, keystrokes in such a matrix could be registered multiple times, rendering a keyboard or keypad unusable. The technique remains vitally relevant in modern electronics, from consumer appliances and industrial control panels to automotive interfaces and IoT devices, ensuring the reliable interpretation of intentional human commands. Its proper implementation is a foundational requirement for robust embedded system design, preventing glitches and malfunctions that stem from the imperfect physical reality of mechanical components.

Extracted References

Keyboard Matrix Circuit Architecture

A keyboard matrix circuit is a grid-based electrical arrangement of rows and columns interconnected by switches (keys), enabling a microcontroller or processor to detect multiple key presses using a reduced number of input/output pins compared to individual wiring for each key [13]. This multiplexing approach is fundamental to the design of most modern computer keyboards, keypads, and other multi-button interfaces. The matrix typically consists of a set of row wires and a set of column wires, with a switch placed at each intersection. The microcontroller scans the matrix by sequentially driving each row line to a known state (often low or ground) while reading the column lines to detect which, if any, are pulled to that same state, indicating a closed switch at that intersection [13]. This method dramatically reduces the required pin count; for example, a 12-key keypad can be implemented with only 7 I/O pins (arranged as 4 rows and 3 columns) instead of 12 dedicated pins, while a full 104-key keyboard might use an 8x18 matrix requiring only 26 pins [13]. The scanning algorithm must run at a frequency high enough to capture human typing speeds without missing keystrokes, often in the range of 100 Hz to 1 kHz. A critical design consideration is "ghosting," where pressing multiple keys simultaneously can create electrical paths that cause false key detections. This is often mitigated by using diodes in series with each switch to ensure current flows in only one direction, preventing ambiguous electrical paths [13]. Rollover, the ability to correctly register multiple simultaneous key presses, is another key characteristic, with N-key rollover (NKRO) being a desirable feature in gaming and professional keyboards, achieved through more sophisticated matrix designs and scanning routines [13].

Charlieplexing Principles and Implementation

Charlieplexing is a multiplexing technique that enables a microcontroller to control a large number of light-emitting diodes (LEDs) using a minimal number of input/output (I/O) pins by leveraging the tri-state logic capabilities of those pins—high, low, or high-impedance states—to selectively activate individual LEDs [14]. The technique is named after its inventor, Charlie Allen. The fundamental principle relies on using pairs of pins to control LEDs, with each pin capable of being set as an output driving high, an output driving low, or a high-impedance input (effectively disconnected). To illuminate a specific LED connected between two pins, one pin is set as a high output (source), the other as a low output (sink), and all other pins are set to a high-impedance state, preventing unwanted current paths [14]. The maximum number of LEDs that can be controlled with n pins is given by the formula n(n − 1) [14]. This is because each ordered pair of pins can support one LED, with the orientation (anode to one pin, cathode to the other) determining the required bias. For instance, with 3 pins (A, B, C), the possible ordered pairs are (A,B), (A,C), (B,A), (B,C), (C,A), and (C,B), allowing control of 3*(3-1)=6 unique LEDs [14]. Each LED is connected with its anode to the first pin in the pair and its cathode to the second. The microcontroller illuminates one LED at a time by setting the correct output states for its specific pin pair. To create the illusion of multiple LEDs being on simultaneously, a rapid sequential scanning pattern (multiplexing) is used, where each LED is turned on for a brief period within a refresh cycle that is faster than the human eye's perception of flicker (typically above 60 Hz) [14].

Comparative Analysis and Application Context

Building on the concepts discussed above, the keyboard matrix and Charlieplexing represent two distinct but related applications of multiplexing to conserve microcontroller I/O resources. The keyboard matrix is designed for reading many digital inputs (switch closures), while Charlieplexing is optimized for controlling many digital outputs (LEDs). Both require time-division multiplexing, where the controller sequentially addresses individual elements in an array. A key technical difference lies in the circuit state management: a keyboard matrix typically uses pull-up or pull-down resistors on the column lines to define a default logic level when no key is pressed, and the microcontroller actively drives rows low during scanning [13]. In contrast, Charlieplexing relies critically on the microcontroller's ability to place pins into a high-impedance state to electrically disconnect them from the circuit, preventing parasitic current paths that would inadvertently light unwanted LEDs [14]. The choice between techniques depends on the application requirements. For example, in an embedded system like the FSFEB (a referenced but unspecified system), Charlieplexing was selected because a large number of LEDs were necessary to display the status of all modules, and most pins on the ATtiny3217 microcontroller were already allocated to other functions [14]. This technique takes direct advantage of the tri-state logic capabilities of the ATtiny3217's I/O ports. The practical implementation involves careful software design to manage the scanning routine and duty cycle for each LED to ensure uniform perceived brightness. While Charlieplexing maximizes LED count per pin, it increases circuit complexity due to the higher number of discrete connections (n(n-1) for LEDs versus rows + columns for a matrix) and requires more sophisticated drive software to manage the tri-state pin configurations dynamically [14]. Furthermore, the current for each LED is typically sourced and sunk directly by the microcontroller pins, which limits the total allowable current draw and often necessitates limiting resistors for each LED, calculated based on the forward voltage of the LED and the microcontroller's output voltage and current sourcing/sinking capabilities [14].

Historical Development

The historical development of switch debouncing is intrinsically linked to the evolution of digital electronics and electromechanical interfaces. Its necessity emerged from a fundamental physical limitation: the mechanical bounce inherent in contact-based switches. As digital systems advanced from rudimentary logic circuits to sophisticated microcontrollers, the methods for mitigating bounce evolved in complexity and integration, transitioning from discrete hardware solutions to sophisticated software algorithms.

Early Electromechanical Systems and the Recognition of Bounce (Pre-1970s)

The phenomenon of contact bounce was not a discovery of the digital age but a well-understood characteristic of electromechanical relays and switches used in telegraphy, telephony, and early computing. In these analog or electro-mechanical systems, the consequences of bounce were often negligible or mitigated by the inherent inertia of mechanical components. However, with the advent of solid-state digital logic in the 1960s—utilizing transistor-transistor logic (TTL) and later complementary metal-oxide-semiconductor (CMOS) families—the issue became critical. Digital circuits interpret voltage levels as discrete binary states (e.g., 0V for logic '0' and 5V for logic '1'). The rapid, oscillating transitions caused by a bouncing switch contact could be interpreted by a high-speed digital gate as multiple distinct logic pulses, leading to catastrophic errors in state machines, counters, and data entry systems [15]. Initial solutions were almost exclusively hardware-based, reflecting the era's design philosophy where processing capability was expensive and discrete components were the primary toolkit. Engineers employed simple resistor-capacitor (RC) low-pass filters at the input of logic gates. The capacitor would charge or discharge through the resistor, integrating the bouncing signal and providing a slowly changing voltage at the gate input. A Schmitt trigger inverter would then clean up the slow transition into a sharp, bounce-free digital signal. This method was effective but introduced a fixed delay and required additional passive components for every switch input, increasing board space and cost. For critical applications, more robust solutions like cross-coupled NAND or NOR gates forming an SR latch (or "debounce flip-flop") were used. This circuit exploited the bistable nature of the latch to settle into a definitive state upon the first contact make or break, ignoring subsequent bounces [15].

The Microcontroller Revolution and Software Debouncing (1970s-1990s)

The introduction of the microprocessor and, subsequently, the single-chip microcontroller in the 1970s and 1980s fundamentally shifted debouncing strategies. Devices like the Intel 8048 and later the immensely popular Intel 8051 family incorporated CPU, memory, and I/O ports on a single chip. This integration made processor cycles and memory increasingly economical resources compared to discrete hardware components. Engineers began to migrate debouncing logic from the circuit board into software firmware, a paradigm shift that offered greater flexibility and reduced material cost. Early software techniques were simple polling routines. The microcontroller would read the state of a switch input, wait for a predetermined "debounce delay" (typically 5 to 50 milliseconds, empirically derived from the physical characteristics of common switches), and then read the input again. If the two readings agreed, the input was considered stable. This approach, while simple, was inefficient as it consumed CPU cycles in delay loops, halting other processes. A more advanced method involved periodic sampling via timer interrupts. A hardware timer would trigger an interrupt service routine (ISR) at fixed intervals (e.g., every 1-10 ms) to sample all switch inputs. The software would then implement a digital filter, such as a shift register or counter, to validate a stable state over several consecutive samples before registering a keypress [15]. This non-blocking approach allowed the main program to continue execution, improving system responsiveness. The evolution of these algorithms was directly tied to the scanning frequencies required for human interface devices; as noted earlier, systems needed to sample fast enough to capture typing speeds without missing keystrokes [15].

Integration and Specialization in Modern Systems (2000s-Present)

The turn of the 21st century saw further miniaturization and integration. The rise of complex programmable logic devices (CPLDs), field-programmable gate arrays (FPGAs), and application-specific integrated circuits (ASICs) allowed debouncing logic to be implemented directly in hardware description languages (HDLs) like VHDL or Verilog. In these implementations, finite state machines (FSMs) could detect edges and enforce settling times with nanosecond precision, entirely independent of any software CPU. This method became prevalent in high-reliability or high-speed digital systems where deterministic timing was paramount. Simultaneously, the consumer electronics boom, driven by devices like smartphones and wearables, presented new challenges. Space and power constraints became extreme, pushing for greater integration at the system-on-chip (SoC) level. Modern microcontrollers now often include peripheral hardware dedicated to input conditioning. For instance, many ARM Cortex-M based MCUs feature GPIO blocks with programmable digital filters, glitch suppression, and interrupt-generation capabilities that can handle debouncing in hardware with minimal software overhead. The software's role has evolved to configuring these peripherals and processing high-level "key pressed" events. The problem also expanded in scope with new interface technologies. While physical switch bounce remains a concern for buttons and mechanical keyboards, capacitive touch sensors, encoders, and hall-effect sensors introduced new forms of signal instability requiring their own specialized filtering and validation algorithms, often combining analog front-ends with digital signal processing. Furthermore, the need for debouncing permeated diverse applications, from the button interfaces on embedded systems like Arduino projects to complex, multiplexed input arrays [14]. In complex displays, for instance, techniques like charlieplexing demand precise software timing to manage LEDs, and similar timing-critical approaches are necessary for reliably scanning matrices of physical switches without ghosting or false triggers [14].

Contemporary Challenges and Persistent Relevance

Despite being a solved problem in classical terms, switch debouncing remains a relevant topic in engineering design. The pursuit of ultra-low-power devices, such as those in wireless sensor networks or energy-harvesting applications, forces designers to make careful trade-offs. A hardware RC filter constantly leaks current, while a software polling routine requires the CPU to wake from sleep, both impacting battery life. Advanced techniques, like using a microcontroller's wake-on-change interrupt coupled with a single timer to validate the input after a sleep period, are modern refinements of the core concept. The historical narrative of switch debouncing is one of adaptation and migration across layers of the technology stack. From its roots as a problem for discrete logic, solutions moved into software with the microcontroller, back into specialized hardware in FPGAs, and are now often embedded as configurable features within complex mixed-signal SoCs. It stands as a fundamental case study in embedded systems design, illustrating the continuous trade-off between hardware and software resources in the pursuit of reliable human-machine interaction [15][14].

# Initialize all pins to high-impedance (input mode)

In charlieplexed LED arrays, the initialization of all microcontroller pins to a high-impedance state, typically configured as digital inputs, serves as the foundational and quiescent state for the multiplexing algorithm. This configuration is not merely a preparatory step but a critical operational requirement that enables the precise control of individual LEDs within a matrix where the number of controllable devices scales quadratically with the number of available pins. The high-impedance state, often referred to as "tri-stated," effectively disconnects the pin's output driver from the circuit, presenting a very high electrical impedance to the connected network. This prevents unwanted current flow and allows other actively driven pins to establish controlled current paths through specific LEDs without interference [1][2].

### The Role of Tri-State Logic in Charlieplexing

Charlieplexing fundamentally exploits the tri-state logic capabilities of microcontroller general-purpose input/output (GPIO) pins. These pins can be dynamically configured into three distinct states:

• A logic HIGH (typically at the supply voltage, Vcc), acting as a current source. - A logic LOW (typically at ground potential, 0V), acting as a current sink. - A high-impedance (Hi-Z) or input state, which presents a high resistance path, effectively removing the pin from actively driving the bus. For a system with n control pins, this tri-state capability allows each pin pair to uniquely address one LED. The total number of addressable LEDs is given by n(n-1), as each ordered pair of pins supports one LED oriented to conduct current when the first pin is biased HIGH and the second LOW [1][2]. The high-impedance state is essential because, at any given moment, only two pins are active (one as an anode driver, one as a cathode sink), while all other n-2 pins must be set to Hi-Z. If these other pins were left as active outputs, they would create parallel, unintended current paths, causing multiple LEDs to illuminate faintly or creating short circuits that could damage the microcontroller or LEDs [3]. For instance, in a 4-pin charlieplexing setup capable of driving 12 LEDs, when illuminating the LED connected between Pin 1 (anode) and Pin 2 (cathode), Pins 3 and 4 must be in a high-impedance state to prevent current from flowing through any LED connected to them via Pin 1 or Pin 2 [2][3].

### Implementation and Configuration Sequence

The initialization sequence in firmware involves setting the data direction registers (DDRx) and port registers (PORTx) of the microcontroller to achieve the high-impedance input condition. For many microcontrollers, including AVR-based platforms like the ATtiny3217 referenced in the source material, this is accomplished by configuring the pin's data direction bit to "0" (input) and its corresponding port output bit to "0" (disabling the internal pull-up resistor) [1]. The typical boot-up or reset routine for a charlieplexing application would therefore include a loop that sets all pins designated for the LED matrix into this input mode before commencing the scanning algorithm. The process can be summarized as:

• Set the Data Direction Register (DDR) bits for the target pins to 0, configuring them as inputs. - Set the Port Output Register (PORT) bits for the same pins to 0, ensuring internal pull-up resistors are disabled. - The pin is now in a high-impedance input state, drawing minimal current and presenting minimal load to the external circuit. This state must be re-established for all non-active pins during every cycle of the multiplexing scan. The scanning algorithm operates by rapidly iterating through each LED or subset of LEDs:

1. Initialize all n pins to high-impedance (input mode). 2. For the target LED connected between Pin i (anode) and Pin j (cathode):

• Set Pin i as a HIGH output. - Set Pin j as a LOW output. - All other pins remain in high-impedance input mode. 3. Apply this state for a brief period (the "on-time" determining perceived brightness). 4. Return both active pins to high-impedance before configuring the next active pair. This cycle repeats at a frequency high enough to exploit persistence of human vision, typically above 60 Hz, to create the illusion of continuously lit displays [3][5].

### Electrical and Design Considerations

The high-impedance state has significant electrical implications for circuit design and performance. When a pin is in input mode, its input capacitance and leakage current become the primary factors affecting the node's behavior. Stray capacitance at the pin and along PCB traces can cause brief transient currents when the pin's state changes, which must be managed to avoid unintended LED flicker or increased electromagnetic interference. Furthermore, in a high-impedance state, the connected LED node is electrically "floating" and susceptible to noise pickup. While this is generally acceptable for the brief periods during multiplexing, it underscores the importance of a clean power supply and ground plane in the physical layout [6][16]. This initialization strategy is particularly advantageous in resource-constrained embedded systems, such as the FSFEB project where the ATtiny3217 microcontroller was employed. Building on the concept discussed above, charlieplexing was selected because a large number of status LEDs were required, and most of the microcontroller's pins were already allocated to other critical functions [1]. By using a few pins in a time-multiplexed, tri-state manner, the design achieves significant pin economy without requiring external driver ICs. This method allows control of a greater number of LEDs than would be possible with direct or standard multiplexing techniques using the same pin count [2][4].

### Contrast with Other Multiplexing Techniques

Charlieplexing's reliance on a universal high-impedance baseline differs from traditional row-column (matrix) multiplexing. In a standard matrix, non-active rows or columns are often driven to an opposite logic state (e.g., columns held LOW while scanning rows HIGH) to ensure LEDs are reverse-biased and off, rather than placed in a high-impedance state. The charlieplexing approach, with its default Hi-Z condition, minimizes power consumption in the off-state since no current flows through biasing resistors, and it simplifies the driving algorithm to managing pairs of pins rather than rows and columns. However, it imposes a stricter requirement on the microcontroller's ability to rapidly and reliably switch pin states and directions, which can affect the maximum achievable refresh rate and perceived brightness uniformity, especially as n increases [3][16].

# Light LED between A (high) and B (low)

The fundamental operational principle enabling charlieplexing is the precise control of voltage states across specific pin pairs to selectively illuminate individual light-emitting diodes (LEDs) within a larger array. This method leverages the tri-state logic capabilities of microcontroller input/output (I/O) pins—configurable as high (logic 1, typically at the supply voltage VCC), low (logic 0, typically at ground potential), or high-impedance (Hi-Z, effectively disconnected) [2]. By strategically setting one pin as a current source (high), another as a current sink (low), and all other pins in the network to a high-impedance state, current flows through only one uniquely addressed LED [1][2].

Tri-State Logic and Pin Configuration

The efficacy of this addressing scheme hinges on the microcontroller's ability to place unused pins into a high-impedance input mode. In this state, a pin presents a very high electrical impedance to the circuit, minimizing leakage current that could inadvertently partially illuminate non-targeted LEDs [2]. This is critical because, in a charlieplexed matrix, each LED is connected across a unique ordered pair of GPIO pins [1][2]. For an LED connected between pin A (anode) and pin B (cathode), illumination requires a forward voltage drop and sufficient current. This is achieved by configuring pin A as a digital output driven high, pin B as a digital output driven low, and ensuring all other pins connected to the network are set to high-impedance inputs [2]. The resulting voltage differential between pin A and pin B forward-biases the target LED, causing it to emit light, while the high-impedance state of other pins prevents the formation of alternative current paths that could activate other LEDs in the array [1].

Mathematical Scaling and Pin Efficiency

The scalability of charlieplexing is expressed by the formula n(n-1), where n represents the number of I/O pins dedicated to the LED matrix [1][2]. This quadratic relationship arises directly from the use of ordered pin pairs. Each pin can serve as the anode (high) in pairs with every other pin acting as the cathode (low), and vice versa, but an LED is a polarized component [1][2]. Therefore, the ordered pair (Pin1, Pin2) addresses a different physical LED than the pair (Pin2, Pin1), as the anode and cathode connections are reversed. For example:

• With 3 pins (A, B, C), the addressable LEDs are: A→B, A→C, B→A, B→C, C→A, C→B, totaling 3*(3-1)=6 LEDs [1][2]. - With 8 pins, the system can control 8*7=56 individual LEDs, a significant increase compared to the 16 LEDs possible with a traditional 4x4 multiplexed matrix using the same number of pins [2]. This efficiency made the technique particularly advantageous for the FSFEB project, which required status indication for numerous modules while the host ATtiny3217 microcontroller had most of its pins allocated to other functions [2].

Circuit Topology and Current Paths

The physical wiring of a charlieplexed array forms an interconnected mesh. Each pin connects to the anodes of LEDs for which it serves as the high-side driver and to the cathodes of LEDs for which it serves as the low-side sink [1][2]. A current-limiting resistor must be incorporated in series with each LED to prevent excessive current draw and potential damage to both the LED and the microcontroller's pin drivers. This resistor can be placed in a common location if all LEDs are designed to operate at the same nominal current, though its placement affects the circuit's commonality [2]. Controlling a specific LED, such as the one between pin A (high) and pin B (low), requires careful management of the entire pin set to avoid "ghosting" or partial illumination of unintended LEDs. Consider a 3-pin system (Pins 1, 2, 3) with 6 LEDs. To light the LED connected from Pin 2 (anode) to Pin 3 (cathode):

• Pin 2 is set as a HIGH output. - Pin 3 is set as a LOW output. - Pin 1 is set as a HIGH-IMPEDANCE input. This configuration creates one intended forward current path. However, if Pin 1 were incorrectly left as an output, it could create parasitic paths. For instance, if Pin 1 were also HIGH, current might flow from Pin 1 through the LED from Pin1→Pin3 (if it exists) and into Pin 3, weakly illuminating it [2]. Therefore, the strict protocol is that for any given driven pair, all other pins must be in a high-impedance state.

Multiplexing for Full Array Control

To display patterns or control more LEDs than can be lit simultaneously at full brightness, charlieplexing employs rapid time-division multiplexing. The controller cycles through illuminating each desired LED (or group of non-conflicting LEDs) one after another [2]. The duty cycle for each LED—the fraction of time it is actively powered—determines its perceived brightness. This can be adjusted through pulse-width modulation (PWM) of the drive signals during its allocated time slot.

Practical Considerations and Limitations

While pin-efficient, charlieplexing imposes specific design constraints. The forward voltage (V_f) of the LEDs must be considered relative to the microcontroller's logic levels to ensure reliable switching. The total current sourced or sunk by any single pin when multiple LEDs are multiplexed must not exceed the microcontroller's absolute maximum ratings [2]. Furthermore, the need for software to manage the precise timing and pin-state sequencing adds complexity to the firmware. Debugging can be challenging, as an error in pin configuration can manifest as multiple LEDs lighting faintly. Despite these constraints, the technique remains a powerful method for maximizing LED count in pin-limited embedded systems, as demonstrated in applications like the FSFEB project [2].

# Light LED between B (high) and A (low)

This fundamental operational principle governs the illumination of individual light-emitting diodes (LEDs) within a Charlieplexed array. The technique relies on precisely controlling the voltage state of each input/output (I/O) pin in a defined pair to create a forward bias across a specific LED, while ensuring all other LEDs connected to the shared pins remain in a non-conducting, or "dark," state [1][2].

Fundamental Biasing Principle

For an LED connected between two microcontroller pins designated as Pin A and Pin B, illumination occurs only when a specific voltage differential is applied. The anode of the LED is connected to Pin B and the cathode to Pin A [1]. To forward-bias the LED, Pin B must be configured as a logic HIGH output, sourcing current, while Pin A is configured as a logic LOW output, sinking current. This establishes the necessary potential difference (typically the microcontroller's supply voltage, e.g., 3.3V or 5V) to cause current to flow from Pin B, through the LED, and into Pin A, resulting in light emission [1][2]. The current is limited by a series resistor, whose value is calculated based on the supply voltage, the LED's forward voltage drop (Vf), and the desired forward current (If), using the formula R = (Vcc - Vf) / If [1]. The critical corollary to this rule is the management of all other pins in the system. To prevent unintended illumination of other LEDs that share Pin A or Pin B, these other pins must be placed in a high-impedance (Hi-Z) state, often achieved by configuring them as inputs [1][2]. In this state, a pin effectively disconnects its internal driver circuitry from the external node, presenting a very high resistance that neither sources nor sinks significant current. This prevents the formation of alternative current paths that could partially forward-bias other LEDs in the matrix.

Tri-State Logic and Pin Configuration

The practical implementation of this biasing scheme is entirely dependent on the tri-state logic capabilities of the microcontroller's I/O pins. Each pin can be dynamically configured into one of three essential states:

• Output HIGH: The pin is actively driven to the positive supply voltage (Vcc), capable of sourcing current.
• Output LOW: The pin is actively driven to ground (GND), capable of sinking current.
• Input (High-Impedance): The pin is not driven; its output drivers are disabled, presenting a high impedance to the circuit. Internal pull-up or pull-down resistors may be enabled or disabled in this mode. A complete illumination cycle for a single LED, such as the one between Pin B (high) and Pin A (low), involves a specific sequence of pin mode configurations executed by firmware [1][2]:

1. Pin B is configured as an output and set to a logic HIGH state. 2. 3. All other pins in the Charlieplexing set are configured as inputs (high-impedance), with their internal pull-up resistors disabled to minimize leakage current. 4. The LED remains illuminated for a brief period, typically 1-5 milliseconds in a multiplexing scheme. 5. After the allotted time, Pin B and Pin A are also set to high-impedance (input mode) to completely extinguish the LED before the cycle addresses the next LED in the sequence.

Electrical Considerations and Constraints

Successful operation requires careful attention to the electrical behavior of the pins, particularly when they are in the high-impedance state. The input capacitance of a pin, typically in the range of 5 to 15 picofarads, can couple with trace inductance to create ringing or slow settling times when switching states, potentially causing ghosting or crosstalk [1]. Furthermore, leakage current, though small (often specified as ±1 µA maximum for modern microcontrollers), can become significant in large arrays. If multiple LEDs share a common anode or cathode pin that is meant to be high-impedance, the cumulative leakage current from several pins could theoretically raise the voltage on a floating node enough to partially illuminate an LED with a low forward voltage. This is mitigated by ensuring all unused pins are actively driven to a defined logic level or by carefully selecting LEDs with a consistent and sufficiently high Vf. The technique also imposes constraints on drive strength. When a single pin acts as the current source for an LED, it must supply the entire forward current (e.g., 10-20 mA). The microcontroller's datasheet specifies the maximum current a single I/O pin can source or sink, as well as the total current limit for all I/O pins combined (often in the range of 80-200 mA for a package). These limits constrain the maximum brightness of individual LEDs and the number that can be illuminated simultaneously in a static (non-multiplexed) manner. In practice, Charlieplexing is almost always used with time-division multiplexing, where only one LED (or a small subset) is lit at any instant, keeping within the per-pin and total current budgets.

Software Control Algorithm

The firmware algorithm for managing a Charlieplexed array is a state machine that iterates through each possible ordered pin pair. For a system with n pins, the algorithm sequences through n(n-1) states [1][2]. For each target LED, corresponding to the ordered pair (B, A) where B is the anode pin and A is the cathode pin, the software performs the following actions:

• Calculates or looks up the correct port configuration register settings to set Pin B as HIGH output, Pin A as LOW output, and all other pins as high-impedance inputs. - Writes this configuration to the microcontroller's I/O port registers in a single, atomic operation where possible to prevent transient states that could briefly illuminate incorrect LEDs. - Maintains this configuration for a precise duration determined by the required refresh rate and brightness. The duty cycle for each LED is the illumination time divided by the total time to scan the entire array. - Before moving to the next LED in the sequence, the firmware typically sets all pins to a safe, defined state (often all inputs) to create a brief "blanking" period, ensuring no two LEDs are ever driven concurrently through an illegal path. The perceived brightness of an LED is directly proportional to its duty cycle within this scan period. Building on the initialization strategy discussed previously, which is advantageous in resource-constrained systems, the control code is often implemented using pre-computed lookup tables for pin configurations to maximize execution speed and ensure deterministic timing [1][2].

# Light LED between A (high) and C (low)

Fundamental Principle of Pin Pair Activation

The core operational principle for illuminating a specific LED in a Charlieplexed array involves precisely controlling the electrical state of exactly two I/O pins while placing all remaining pins in a high-impedance (high-Z) state [1][2]. To illuminate an LED connected between pin A (anode) and pin C (cathode), pin A is configured as a digital output and driven to a logic HIGH voltage level, typically the microcontroller's supply voltage (e.g., 3.3V or 5V) [1]. Simultaneously, pin C is also configured as a digital output but driven to a logic LOW voltage level, typically ground (0V) [1]. This establishes a forward voltage potential across the target LED, causing it to conduct current and emit light. The critical requirement is that all other pins in the system must be set to a high-impedance input state, effectively disconnecting them from the circuit and preventing unintended current paths that could partially illuminate other LEDs or create short circuits [1][2].

Electrical Current Path and Component Sizing

When pins A and C are correctly biased, current flows from the voltage source, through the microcontroller's internal circuitry of pin A, through the current-limiting resistor in series with the LED, through the LED itself (from anode to cathode), and into pin C, sinking to ground [1]. The current-limiting resistor is essential to prevent excessive current that could damage either the LED or the microcontroller's output pins. Its value is calculated using Ohm's Law, considering the forward voltage drop of the LED (V_f, typically 1.8V-3.3V depending on color and chemistry), the supply voltage (V_cc), and the desired forward current (I_f, often 10-20 mA for standard indicators) [1]. The formula is R = (V_cc - V_f) / I_f. For example, with a 5V supply, a red LED with a V_f of 2.0V, and a target I_f of 15 mA, the required resistor value would be (5V - 2.0V) / 0.015A = 200Ω [1]. The power dissipation in the resistor is P = I_f² * R, which in this case is (0.015)² * 200 = 0.045W, easily handled by a standard 0.125W (1/8W) resistor [1].

Tri-State Control and Pin Reconfiguration

The high-impedance state of the non-active pins is achieved by configuring them as digital inputs, which presents a very high input impedance (often in the megaohm range) to the circuit [2]. This tri-state control—HIGH, LOW, and high-Z—is the foundational capability that Charlieplexing exploits. In a software implementation, illuminating the LED between A and C requires a rapid sequence of pin mode and state changes:

• Store the previous state of all pins (if necessary for context restoration). - Set pin A as OUTPUT, HIGH. - Set pin C as OUTPUT, LOW. - Set all other pins (e.g., pins B, D, E...N) as INPUT (high-Z). - Maintain this configuration for the desired illumination period (e.g., 1-5 ms in a multiplexing scheme). - After the period elapses, all pins are typically returned to a safe state, often all inputs, before the next LED in the scanning sequence is addressed [1][2]. This dynamic reconfiguration occurs at high speed within the microcontroller's firmware control loop.

Addressing Matrix and Illumination Constraints

The addressing scheme is inherently directional due to the LED's diode characteristics, which only allow current to flow from anode to cathode [1][2]. Therefore, the ordered pair (A, C) addresses a different physical LED than the pair (C, A). If an LED is physically connected between the same two pins but in the opposite orientation, it will only illuminate when the pin roles are reversed (C as HIGH anode, A as LOW cathode) [2]. A critical constraint is that only one such current path can be active at any given time within the entire array. Attempting to illuminate two LEDs simultaneously by setting multiple pins as HIGH and multiple others as LOW would create parallel and potentially conflicting current paths, leading to incorrect LEDs lighting at reduced brightness, excessive current draw, or unpredictable behavior [1][2]. This necessitates time-division multiplexing where the controller cycles through each desired LED sequentially.

Practical Implementation and Timing Considerations

In a practical system like the FSFEB project using an ATtiny3217, the firmware maintains a map or function that translates a logical LED identifier (e.g., LED_12) into the specific pin pair required to illuminate it (e.g., Pin 4 as HIGH, Pin 1 as LOW) [2]. The illumination time per LED must be balanced within the scanning cycle. As noted earlier, this cycle must repeat at a frequency high enough to exploit the persistence of human vision. If a system has P LEDs to illuminate per cycle, and each is lit for time T_on, the total cycle time is at least P

• T_on. For a refresh rate of F Hz, the requirement is P
• T_on ≤ 1/F. For example, to refresh 56 LEDs (using 8 pins) at 60 Hz, the maximum T_on per LED is approximately 1 / (56 * 60) ≈ 298 microseconds [1][2]. The firmware's scanning algorithm must efficiently manage these tight timing constraints while also potentially handling other tasks like reading switch matrices.

Advantages in Resource-Constrained Systems

This method provides exceptional I/O efficiency. As established, with n pins, it controls n(n-1) LEDs [1][2]. This quadratic relationship dramatically outperforms standard multiplexing, which typically controls only about n²/4 LEDs for the same pin count when organized in an n/2 x n/2 matrix. The Charlieplexing approach was selected for the FSFEB precisely because it allowed a large number of status LEDs to be driven by the ATtiny3217, whose pins were largely occupied by other critical functions such as sensor interfaces and communication modules [2]. The technique effectively trades off increased firmware complexity and precise timing control for a substantial reduction in hardware resource requirements, a favorable trade-off in many embedded designs.

# Light LED between C (high) and A (low)

This specific instruction exemplifies the core operational principle of Charlieplexing, a sophisticated multiplexing technique that enables a microcontroller to control a large number of light-emitting diodes (LEDs) using a minimal number of input/output (I/O) pins by leveraging their tri-state logic capabilities—high, low, or high-impedance (Hi-Z) states [2]. The command "Light LED between C (high) and A (low)" precisely defines the electrical conditions required to illuminate a single, specific LED within a Charlieplexed array. In this context, pins labeled 'C' and 'A' represent two distinct I/O pins of a microcontroller, such as the ATtiny3217 used in the FSFEB project, where this method was chosen to manage a large number of status indicator LEDs while most pins were allocated to other functions [2].

Fundamental Operational Principle

The technique fundamentally relies on treating each I/O pin as a node that can be dynamically configured in one of three states to control current flow through a specific LED. To illuminate the LED connected between pins C and A, the microcontroller's firmware must execute a precise sequence of pin configurations [2]:

• Pin C is set as an output and driven HIGH, effectively becoming the anode-side voltage source for the target LED. - Pin A is set as an output and driven LOW, acting as the cathode-side current sink, completing the circuit.
• All other pins in the Charlieplexing array are set to a high-impedance (Hi-Z) input state. This is critical, as it electrically disconnects them from the active circuit, preventing unintended current paths that could partially illuminate other LEDs or create short circuits. This configuration creates a forward bias across the singular LED whose anode is connected to pin C and cathode to pin A. A current-limiting resistor, either placed in series with this specific LED or shared on a common power rail, ensures the forward current (I_f) remains within the LED's specified safe operating range, typically 10-20 mA for standard indicators [2]. The resulting voltage drop across the LED is determined by its forward voltage (V_f), which varies from approximately 1.8V to 3.3V depending on the semiconductor material and color [2].

Mathematical Scalability and Pin Efficiency

The efficiency of Charlieplexing stems from its use of ordered pin pairs. As noted earlier, with n available GPIO pins, the system can address up to n(n − 1) unique LEDs [1][2]. This quadratic relationship arises because each pin can serve as the anode (HIGH) in a pair with any other pin as the cathode (LOW), and vice versa, but an LED is a polarized device. Therefore, the ordered pair (C, A) lights a different physical LED than the pair (A, C), if both are populated. For example, a modest set of 8 GPIO pins can control 8 * 7 = 56 individually addressable LEDs [2]. This stands in stark contrast to a traditional multiplexed matrix, where 8 pins could typically control only a 4x4 grid (16 LEDs) or, with more complex drivers, a slightly higher number, but never reaching the same efficiency as Charlieplexing for direct LED control.

Firmware Implementation and Scanning Algorithm

Illuminating a single LED is merely the basic operation; practical applications require displaying patterns or multiple LEDs. This is achieved through a time-division multiplexing (TDM) scanning algorithm executed by the microcontroller. The firmware cycles through each LED that needs to be lit, activating only one specific pin pair (e.g., C-high, A-low) at any given moment. Each LED is illuminated for a very brief period, or duty cycle. Building on the concept discussed above, to refresh 56 LEDs at a flicker-free rate of 60 Hz, the maximum on-time (T_on) per LED is approximately 298 microseconds [2]. The human visual system, through persistence of vision, integrates these rapid, sequential flashes into the perception of a stable image. The scanning algorithm must, therefore, run at a high and consistent frequency within the microcontroller's main control loop. To manage complex displays, the firmware typically maintains a display buffer—a data structure in RAM that maps the desired on/off state for every addressable LED in the array. The scanning routine iterates through this buffer, and for each LED marked as "on," it configures the corresponding pin pair as outputs with the correct polarity and sets all other pins to Hi-Z. A critical optimization involves minimizing the number of pin state changes between cycles. If the next LED to be lit shares a pin with the currently active one (e.g., moving from LED on (C, A) to LED on (C, B)), the firmware can leave pin C configured as HIGH and only change pin A from LOW to Hi-Z and pin B from Hi-Z to LOW.

Circuit Design and Practical Considerations

Implementing a Charlieplexed network requires careful circuit design. Each LED is connected directly between two GPIO pins, with its anode toward one pin and cathode toward the other. A major design challenge is managing the forward voltage drops and current paths. Since multiple LEDs share the same physical pins, the forward voltage (V_f) of an "off" LED can affect the voltage seen by an "on" LED if multiple paths exist. The strict enforcement of the Hi-Z state for all non-active pins is what mitigates this. Furthermore, the internal protection diodes present on most microcontroller I/O pins can inadvertently conduct if voltage differences exceed safe limits, necessitating software that never creates conflicting output states (e.g., two pins both driven HIGH simultaneously while connected to the same LED). Current limiting is another key consideration. A common design approach is to place a single current-limiting resistor on the common V_cc rail supplying the microcontroller, relying on the output impedance of the pins. A more robust method is to use a resistor in series with each individual LED, though this increases component count. The value is calculated using Ohm's law: R = (V_cc - V_f - V_ol) / I_f, where V_ol is the output low voltage of the microcontroller pin (near 0V when sinking current). For a system with V_cc = 5V, an LED with V_f = 2.0V, and a target I_f of 15 mA, the required resistor value would be approximately (5V - 2.0V - 0V) / 0.015 A = 200 Ω [2]. In summary, the instruction "Light LED between C (high) and A (low)" encapsulates the precise, state-driven control mechanism of Charlieplexing. It highlights the technique's reliance on tri-state logic for isolation, its quadratic scalability in LED count, and the consequent demands on firmware for scanning and display buffer management, making it an optimal solution for maximizing LED drive capability from limited microcontroller pins in embedded systems [1][2].

# Light LED between B (high) and C (low)

The fundamental operational principle enabling charlieplexing is the precise, time-multiplexed control of current flow between specific pairs of microcontroller I/O pins. This technique leverages the tri-state logic capabilities of pins—configurable as HIGH (logic 1, sourcing current), LOW (logic 0, sinking current), or high-impedance (Hi-Z, input mode)—to selectively illuminate a single LED connected between two designated pins at any given moment [1][2]. The process of lighting an LED between a pin designated as the anode (B, set HIGH) and a pin designated as the cathode (C, set LOW) constitutes the core activation cycle.

Tri-State Pin Configuration for LED Activation

To illuminate a specific LED, the microcontroller executes a precise sequence of pin state configurations. For an LED connected with its anode to pin B and its cathode to pin C, the required states are:

• Pin B: Configured as a digital output and driven to a logic HIGH state (e.g., V_cc, typically 5V or 3.3V). This pin sources current into the LED's anode [1][2].
• Pin C: Configured as a digital output and driven to a logic LOW state (0V or ground potential). This pin sinks current from the LED's cathode, completing the circuit [1][2].
• All Other Pins: Configured as high-impedance (Hi-Z) inputs. This state presents a very high electrical resistance to the circuit, effectively disconnecting these pins and preventing unintended current paths that could cause ghost lighting of other LEDs [1][2]. This configuration creates a controlled voltage differential exclusively between pins B and C. Current flows from the high-voltage source (pin B), through the current-limiting resistor and the LED, and into the current sink (pin C). The high-impedance state on all other pins ensures that no alternative, lower-resistance path exists for the current, thereby isolating the intended LED [1][2].

Electrical Characteristics and Current Limiting

The current flowing through the LED (I_f) is determined by Ohm's Law and the forward voltage characteristics of the diode. The series current-limiting resistor (R_s) is critical for setting this current to a safe and optimal value. The required resistance is calculated using the formula: R_s = (V_cc - V_f) / I_f Where V_cc is the supply voltage (the HIGH logic level from pin B), V_f is the forward voltage drop of the specific LED (typically 1.8V-3.3V depending on its color and semiconductor material), and I_f is the desired forward current [1][2]. For a standard indicator LED with a V_f of 2.0V, powered from a 5V system with a target I_f of 15 mA, the resistor value would be approximately (5V - 2.0V) / 0.015 A = 200 Ω. This resistor must be placed in series with the LED, conventionally on the anode side, to protect it from excessive current [1][2].

Time-Multiplexed Scanning and Refresh Dynamics

As noted earlier, a single LED is illuminated for only a brief period within a rapid scanning cycle that addresses all LEDs in the array sequentially. The on-time (T_on) for each LED is a fraction of the total refresh period. For an array of n pins controlling n(n-1) LEDs, if the entire array must be refreshed at a frequency F_r (e.g., 60 Hz to avoid visible flicker), the maximum T_on per LED is: T_on ≤ 1 / (n(n-1) * F_r) Building on the concept discussed above, for a system with 8 pins (controlling 56 LEDs) refreshing at 60 Hz, the maximum T_on is approximately 298 microseconds [1][2]. The microcontroller's firmware must manage a scanning algorithm that cycles through each valid pin pair (B, C), applying the correct HIGH/LOW/Hi-Z states for this calculated duration before moving to the next LED. The human visual system integrates these rapid, sequential flashes, perceiving a stable image if the refresh rate is sufficiently high [1][2].

Addressing Scheme and Pin Pair Management

The system's addressing logic maps each physical LED to a unique ordered pair of GPIO pins (B, C). The order is critical because an LED is a polarized component; the pair (B, C) illuminates the LED when B is HIGH and C is LOW, while the pair (C, B) would correspond to an LED installed in the opposite orientation [1][2]. With n available pins, the total number of addressable LEDs is n(n-1), as each pin can serve as the anode (HIGH) in combination with any of the other n-1 pins acting as the cathode (LOW), excluding self-connections [1][2]. For example, in a modest 8-pin system, this yields 8 * 7 = 56 individually controllable LEDs [1][2].

Practical Implementation and Firmware Control

In practice, such as in the FSFEB project utilizing an ATtiny3217 microcontroller, the firmware implements a state machine or a lookup table that defines the activation sequence [1][2]. The control routine performs the following steps for each LED in the scan list:

1. Set the target anode pin (B) to output HIGH. 2. Set the target cathode pin (C) to output LOW. 3. Set all other pins to input (Hi-Z) mode. 4. Maintain this configuration for the duration of T_on. 5. Before switching to the next LED, all pins may be briefly set to Hi-Z to avoid transient short circuits during the reconfiguration. This method was chosen for the FSFEB precisely because a large number of status indicator LEDs were required, while most of the microcontroller's pins were already allocated to other functions such as switch matrix scanning or communication interfaces [1][2]. Charlieplexing maximized the utility of the limited remaining I/O resources.

Advantages and Design Considerations

The primary advantage of this technique is the exponential relationship between pin count and controllable LEDs, offering superior I/O efficiency compared to traditional multiplexing. However, it introduces specific design constraints. Furthermore, the very short T_on requires LEDs with good transient response characteristics. The average current through each LED is reduced by the duty cycle (D), calculated as D = T_on * F_r, which also reduces perceived brightness. To compensate, the peak current (I_f) during the T_on period can be increased (within the LED's maximum pulsed current rating), as the average power dissipation remains within safe limits [1][2]. This balance between peak current, duty cycle, and refresh rate is a key engineering trade-off in designing an effective charlieplexed display system.

# Light LED between C (high) and B (low)

This specific operational state within a Charlieplexed LED array demonstrates the fundamental principle of how individual light-emitting diodes are selectively illuminated through precise pin state control. In this configuration, pin C is set to a logic HIGH voltage level (typically V_cc, such as 5V or 3.3V), pin B is set to a logic LOW level (ground, 0V), and all other pins in the system are placed in a high-impedance (Hi-Z) input state [1][2]. This creates a forward-biasing voltage potential exclusively across the LED connected between pins C and B, with its anode on pin C and cathode on pin B, allowing current to flow and the diode to emit light. All other LEDs connected to either pin C or pin B remain dark because the necessary complete forward-biasing circuit path is not established; for an LED to light, one of its pins must be HIGH and the other LOW, with all other pins presenting high impedance to prevent sneak current paths [1][2].

Pin State Configuration and Current Path Isolation

The tri-state logic capability of microcontroller GPIO pins is essential for this operation. A pin can be configured in one of three states:

• Digital Output HIGH: Sourced from the microcontroller's internal supply rail.
• Digital Output LOW: Sinked to the microcontroller's ground.
• High-Impedance (Hi-Z) Input: Presents a very high resistance path, effectively disconnecting the pin from actively driving the circuit. For the "C high, B low" case, the precise state configuration for an n-pin system is:
• Pin C: Configured as a digital output driving HIGH. - Pin B: Configured as a digital output driving LOW. This configuration ensures current flows only along the intended path: from the voltage supply internal to the microcontroller, out of pin C, through the current-limiting resistor and the target LED, into pin B, and sinking to ground [1][2]. The high-impedance state on all non-active pins is critical. If another pin (e.g., pin A) were left as an output, even if at the same logic level as pin C or B, it could create an alternative, parallel current path. For instance, if pin A were also set HIGH, an LED connected between A and B would also light, causing crosstalk. The Hi-Z state prevents this by making these pins electrically "invisible" to the active circuit nodes [2].

Mathematical Addressing and Temporal Multiplexing

The ordered pair (C, B) corresponds to a unique address within the Charlieplexing matrix. As noted earlier, with n pins, the system can address n(n-1) LEDs [1][2]. If pins are labeled 0 through n-1, the LED lit by setting pin i HIGH and pin j LOW (where i ≠ j) is distinct from the LED that would be lit by setting pin j HIGH and pin i LOW. This accounts for the (n-1) term per driving pin and the total of n(n-1) [2]. To illuminate multiple LEDs to form a pattern, the controller must rapidly cycle through each required (HIGH-pin, LOW-pin) pair, dwelling on each for a brief period. This is temporal multiplexing. The dwell time, or T_on, must be sufficient for the LED to reach its luminous intensity but short enough that the cycling frequency across all active LEDs exceeds the flicker fusion threshold for human vision. Building on the concept discussed above, for a refresh rate of 60 Hz and k active LEDs in a pattern, the maximum T_on per LED is approximately 1/(k * 60) seconds [1][2]. For a complex pattern using many of the 56 possible LEDs from an 8-pin setup, this necessitates T_on times on the order of hundreds of microseconds, demanding efficient microcontroller code.

Circuit Analysis and Design Considerations

Analyzing the current path for the C-high/B-low case involves standard diode circuit equations. The series current-limiting resistor (R_limit) is mandatory to set the LED forward current (I_f). The value is calculated using: R_limit = (V_C - V_B - V_f_LED) / I_f Where:

• V_C is the voltage at pin C (output HIGH voltage, V_OH). - V_B is the voltage at pin B (output LOW voltage, V_OL, typically near 0V). - V_f_LED is the forward voltage of the specific LED. - I_f is the desired forward current (e.g., 10-20 mA for standard indicators). For example, with a V_OH of 5.0V, a V_OL of 0.1V, a red LED with a V_f of 2.0V, and a target I_f of 15 mA, the calculation yields R_limit = (5.0V - 0.1V - 2.0V) / 0.015A ≈ 193 Ω. A standard 200 Ω resistor would be used. The power dissipated in the resistor is P_R = I_f² * R_limit ≈ (0.015)² * 200 = 0.045 W, well within the rating of a standard 0.125 W (1/8 W) resistor [1][2]. A major design challenge, as noted earlier, is managing forward voltage drops and preventing unintended conduction. The high-impedance state has a small leakage current (microamps), which is usually negligible. However, if the voltage on a floating Hi-Z pin were to rise due to external noise or capacitive coupling to near the forward voltage threshold of an LED connected to the active HIGH pin, a faint glow could occur. This is often mitigated in firmware by ensuring Hi-Z pins have their internal pull-up resistors disabled and by maintaining a stable electrical environment [2].

Firmware Implementation Sequence

The microcontroller firmware to achieve this state follows a strict sequence to avoid transient states that could briefly illuminate incorrect LEDs:

1. Configure all pins (n total) as high-impedance inputs (default safe state). 2. Configure the target LOW pin (B) as a digital output and drive it LOW. 3. * The order of steps 2 and 3 is crucial. Setting the LOW pin first prevents a momentary HIGH-to-HIGH state if pin C were activated before pin B was pulled low. 4. 5. To deactivate, first drive pin C LOW, then reconfigure pins C and B back to Hi-Z inputs, or immediately reconfigure them for the next LED in the multiplexing sequence. This careful sequencing is a key software responsibility in Charlieplexing, ensuring clean transitions and maximizing the contrast between the intended lit LED and the dark background of the display [1][2].

Application Context in the FSFEB Project

In the FSFEB project, which utilized an ATtiny3217 microcontroller, this method was selected because a large number of status indicator LEDs were required for various modules, and most GPIO pins were already allocated to other critical functions like switch matrix scanning and communication interfaces [1][2]. By dedicating a small bank of 6-8 pins to Charlieplexing, dozens of status LEDs could be integrated without requiring a port expander or a second microcontroller. The "C high, B low" operation, repeated across all necessary pin pairs at a high frequency, allowed the compact system to provide comprehensive visual feedback. This approach exemplifies the technique's utility in resource-constrained embedded systems where maximizing functionality per I/O pin is paramount [1][2].

# Return all to high-Z for next cycle

Following the controlled illumination of a specific LED in a Charlieplexing scheme, the system must execute a deliberate deactivation sequence to prepare the GPIO pins for the next cycle. This sequence, often termed "returning all to high-impedance (Hi-Z)," is a critical phase that ensures electrical isolation of the recently active LED, prevents unintended current paths, and resets the pin states for the subsequent multiplexing step [1][2]. The process is not merely a software delay but a structured reconfiguration of the microcontroller's I/O ports to transition from an actively driven state to a passive, high-impedance input state.

The Deactivation Sequence and Its Rationale

The standard deactivation sequence for a Charlieplexed LED involves two or three deliberate steps, executed in a specific order to avoid electrical transients. Consider an LED connected between pin C (anode) and pin B (cathode), which was illuminated by driving pin C HIGH and pin B LOW. The recommended deactivation procedure is [1][2]:

• First, drive the anode pin (C) LOW. - Then, reconfigure both pins C and B as high-impedance digital inputs. This order is crucial. Driving the anode pin LOW first ensures the voltage across the LED falls to zero, immediately extinguishing it. If the pins were instead immediately reconfigured as inputs, their internal pull-up or pull-down resistors (if enabled) or residual charge could create an undefined voltage state, potentially causing a brief reverse bias or allowing a trickle of current to flow. Furthermore, setting a pin as an input before the connected pin is driven to a safe voltage can cause that input to float to an intermediate voltage, increasing power consumption due to CMOS shoot-through current in the input buffer [1]. The final state—all pins configured as Hi-Z inputs—creates a known, neutral electrical condition where no pins are actively sourcing or sinking current, effectively disconnecting all LEDs from the power rails. This is the default, idle state of the Charlieplexing array between active scanning phases.

Electrical and Timing Considerations

The transition back to Hi-Z has direct implications for the electrical design and timing budget of the multiplexing algorithm. When a pin is reconfigured from an output to an input, its output driver is disabled. The electrical node connected to that pin is no longer held at a defined logic level by a low-impedance source and begins to float. The rate at which it floats is determined by the parasitic capacitance of the PCB trace and the LED itself, and any leakage currents [1]. In a densely packed matrix, the capacitive coupling between adjacent traces can cause a floating node to briefly influence the voltage on a neighboring pin that is meant to be in a Hi-Z state. While typically a minor effect, in high-speed or noise-sensitive applications, this coupling must be considered. The time required to execute the deactivation commands in firmware—writing to the port registers to drive the pin LOW and then writing to the data direction register (DDR) to switch it to an input—is non-zero. This time, along with the time for the electrical signals to settle, must be accounted for within the total multiplexing period. For a system refreshing k LEDs at a frequency f_refresh, the total cycle time per LED is 1/(k * f_refresh). This time is partitioned into the LED on-time (T_on), the deactivation sequence time (T_deact), the activation/setup time for the next LED (T_act), and often a brief guard interval. Therefore, T_deact directly reduces the maximum available T_on, impacting perceived brightness [2].

Integration into the Scanning Algorithm

The return-to-Hi-Z operation is embedded within the core scanning loop of the Charlieplexing driver. A typical algorithm for an n-pin system controlling n(n-1) LEDs follows this pattern [1][2]:

1. Initialize all n pins as Hi-Z inputs (the starting idle state). 2. For each LED i in the scanning sequence:

• Determine the anode pin A_i and cathode pin K_i.
• Activation: Configure pin K_i as an output and drive it LOW. Then, configure pin A_i as an output and drive it HIGH.
• Illumination: Maintain this state for the calculated T_on.
• Deactivation: Drive pin A_i LOW. Then, reconfigure pins A_i and K_i as Hi-Z inputs. 3. Repeat from step 2 for the next LED in the sequence. This algorithm ensures that at any moment, only one specific pair of pins is actively driven, and all others are in a high-impedance state, preventing conflicts. The deactivation step (2d) is what cleanly concludes the control of one LED and restores the system to the baseline Hi-Z condition before the loop iterates. In optimized implementations, the deactivation for one LED and the activation for the next may be partially overlapped or sequenced to minimize dead time. For instance, after driving the previous anode LOW, the firmware might immediately reconfigure the next cathode pin as an output and drive it LOW, before finally reconfiguring the previous pins as inputs. This pipelining can improve the duty cycle but requires careful coding to avoid creating a momentary cross-connection where two outputs are incorrectly enabled [2].

Consequences of Omitting the Hi-Z Return

Failure to properly implement the return-to-Hi-Z phase can lead to several functional failures. The most common is ghosting or crosstalk, where LEDs other than the intended one glow dimly. This occurs if, for example, after illuminating LED1 (between pins 1+ and 2-), pin 2 is left driven LOW while the system attempts to illuminate LED2 (between pins 3+ and 4-). If pin 3 is driven HIGH, a current path may exist from pin 3, through LED2, into pin 4, but also through any other LED whose cathode is connected to the still-active LOW pin 2, such as a hypothetical LED between pins 3+ and 2- [1]. This creates multiple, unintended current paths. Another risk is increased power consumption. If two pins are accidentally left configured as outputs—one HIGH and one LOW—they create a continuous low-resistance path between Vcc and GND through whatever components connect them, resulting in significant static current draw. This is particularly detrimental in battery-powered devices like those in the FSFEB project [2]. Finally, omitting the Hi-Z state can lead to electrical stress on the LEDs. Leaving an LED in a forward-biased state for longer than its designed pulse rating (which is often higher than its continuous current rating) can degrade its lifespan. Conversely, floating nodes can subject LEDs to undefined reverse voltages, potentially exceeding their small reverse breakdown voltage (typically around 5V) [1].

Optimization for Resource-Constrained Systems

In embedded systems with stringent timing or processing constraints, such as the ATtiny3217 microcontroller used in the FSFEB project, the deactivation routine must be highly efficient [2]. This often involves direct manipulation of microcontroller port registers rather than using slower, abstracted digitalWrite() functions. Engineers may write compact assembly code or use bit-masking operations to change pin states and directions with minimal clock cycles. The entire sequence—driving the anode LOW and switching two port direction bits—might be accomplished in just a few instructions. Furthermore, the choice of scanning pattern (e.g., sequential by pin pair vs. a pattern optimized for minimal pin state changes) can reduce the number of transitions between output and Hi-Z states, thereby saving time and reducing computational overhead. The principle, however, remains invariant: a controlled return to a known, neutral Hi-Z state is the fundamental mechanism that enables Charlieplexing to scale control of numerous LEDs with a minimal pin count, by guaranteeing electrical isolation between each multiplexed time slice [1][2].

# Initialize all pins to high-impedance (input mode)

The initialization of all General-Purpose Input/Output (GPIO) pins to a high-impedance (Hi-Z) state is a fundamental and critical first step in configuring a microcontroller for Charlieplexing, as well as for other multiplexed circuits like keyboard matrices [1][2]. This procedure establishes a known, safe, and predictable electrical starting condition for the entire network of interconnected components before any active driving or sensing begins. In digital electronics, a pin configured as an input with no internal pull-up or pull-down resistor enabled presents a high impedance to the external circuit—typically in the megaohm (MΩ) range [1]. This state minimizes current draw and effectively disconnects the microcontroller's internal circuitry from the external node, allowing its voltage to be defined by other connected components or to float to an indeterminate level. For Charlieplexing, this initial Hi-Z configuration is essential because it prevents unintended current paths and false illumination of LEDs during the system's startup phase, when the firmware has not yet begun its controlled multiplexing sequence [2].

### Electrical Rationale and Circuit State Management

From a circuit theory perspective, initializing to Hi-Z input mode ensures that no pin actively sources or sinks current. This is crucial in a Charlieplexed network where multiple LEDs share common pins. If a pin were accidentally initialized as an output driving HIGH (anode) while another was configured as an output driving LOW (cathode), the specific LED connected between that pair would immediately illuminate, creating an uncontrolled startup state [2]. Furthermore, more complex parasitic current paths could occur through multiple LEDs if several pins are active simultaneously in an uncoordinated manner. The high-impedance state acts as an electronic "open switch" at each pin, isolating the microcontroller's driver transistors. This allows the system designer to assume that, upon power-up or reset, all external LED nodes are electrically passive until the firmware explicitly takes control. The procedure is typically implemented in code by writing the appropriate control registers for the microcontroller's port direction (e.g., DDRA, DDRB on AVR, or TRIS registers on PIC), setting them to configure all relevant pins as inputs, and ensuring that any internal pull-up resistors are disabled [1].

### Firmware Implementation Sequence

The initialization routine is a discrete step that precedes the main control loop. A typical implementation for an ATtiny3217, as used in the FSFEB project, would follow this sequence [2]:

• Disable interrupts (optional but recommended): Temporarily disable global interrupts to ensure the port configuration changes atomically without interference from an Interrupt Service Routine (ISR) that might also manipulate the same ports.
• Configure Port Direction Registers: Write to the PORTx.DIRCLR register (or equivalent) for each port used in the Charlieplexing array to set all designated pins as inputs. For example, PORTA.DIRCLR = 0xFF; would configure all 8 pins on Port A as inputs on a device where Port A is an 8-bit port [1].
• Disable Pull-up Resistors: Write to the PORTx.PINnCTRL registers (or the port's pull-up enable register) to ensure the internal pull-up resistors are inactive for each pin. This is vital because an enabled pull-up would source a small current to the node, potentially affecting the floating voltage and creating a weak, unintended bias.
• Re-enable interrupts: Restore the interrupt state if they were disabled. This sequence results in all Charlieplexing pins being in a high-impedance input state, drawing minimal leakage current (often less than 1 µA per pin) and presenting a near-infinite resistance to the external circuit [1].

### Contrast with Alternative Initialization Strategies

Initializing all pins to Hi-Z contrasts with other possible startup configurations, each with significant drawbacks for a multiplexed LED array:

• Initializing as Outputs Driving LOW: While this would also prevent unintended LED illumination (as no anode is HIGH), it creates a direct low-impedance path to ground on every pin. If an external voltage source or a charged capacitor were connected to any pin, it could cause a high short-circuit current to flow into the microcontroller pin, potentially damaging the device or distorting the power supply voltage.
• Initializing with Pull-up Resistors Enabled: This would pull all nodes towards the supply voltage (V_cc) through a high resistance (e.g., 20-50 kΩ). In a Charlieplexing matrix, this could create numerous, albeit weak, reverse-biasing conditions across LEDs and lead to unpredictable floating voltages on shared nodes, complicating the clean transition to the active multiplexing state.
• Leaving Pins in Default (Often Input) State: Relying on the microcontroller's power-on default is unreliable. While many microcontrollers default pins to Hi-Z inputs, this is not a universal specification. Some devices may have alternate default functions (e.g., serial communication), and others might enable pull-ups by default in certain power-saving modes. Explicit initialization guarantees portability and robustness across different devices and compiler toolchains [1].

### Integration with the Charlieplexing Control Algorithm

The Hi-Z initialization is the foundation upon which the dynamic pin control algorithm operates. The core multiplexing cycle for illuminating a single LED, such as LED_BC connected between pin B (cathode) and pin C (anode), builds directly from this baseline [2]:

1. Start from All Hi-Z: All pins in the array begin in the high-impedance input state. 2. Set Cathode LOW: Configure pin B as an output and drive it to a logic LOW (0V) to establish the current sink. 3. Set Anode HIGH: Configure pin C as an output and drive it to a logic HIGH (V_cc) to provide the forward voltage. 4. Maintain Illumination: The LED remains on for the calculated T_on duration (e.g., ~298 µs for a 56-LED array at 60 Hz refresh) [2]. 5. Deactivate and Return to Hi-Z: To extinguish the LED, the sequence is reversed. First, drive pin C (anode) LOW to remove the forward voltage, then reconfigure both pins C and B back to Hi-Z inputs. This two-step deactivation prevents a momentary high-current state that could occur if the anode were switched to Hi-Z while the cathode remained actively LOW. After deactivation, the system returns to the universal Hi-Z state, ready for the next LED in the multiplexing sequence to be activated using the same pattern. This disciplined approach of always returning to a neutral Hi-Z state between activating individual LEDs is what prevents ghosting and cross-talk within the matrix.

### Implications for Power Consumption and System Design

The high-impedance initialization strategy has direct benefits for power-sensitive embedded applications. When the system is idle (not actively refreshing the display), or during periods between scanning cycles, the Charlieplexing pins can be left in Hi-Z input mode. In this state, the current draw from these I/O pins is reduced to negligible leakage levels, contributing to lower overall system power consumption [1]. This is particularly advantageous for battery-operated devices. Furthermore, this approach simplifies the system's electrical design. Since the microcontroller does not impose a static bias on the network, the external circuit's behavior is solely determined by the active drive patterns during the multiplexing windows. This predictability makes analyzing current paths, calculating worst-case current draws, and ensuring signal integrity more straightforward for the designer.

# Light LED between A (high) and B (low)

The fundamental operational principle of Charlieplexing relies on the precise, sequential biasing of ordered pin pairs to create a forward voltage across a specific light-emitting diode (LED). In this scheme, to illuminate a single LED connected between two general-purpose input/output (GPIO) pins—designated as Pin A (anode connection) and Pin B (cathode connection)—the microcontroller executes a specific sequence of pin state configurations [1][2]. This process leverages the tri-state logic capabilities (HIGH, LOW, and High-Impedance or Hi-Z input) inherent to many microcontroller pins to control current flow through a single intended LED while preventing unintended conduction through other LEDs in the network [1].

Fundamental Activation Sequence

The canonical activation sequence for a single LED involves three distinct steps, transitioning the relevant pins from a default, non-conductive state to an active, current-driving state [1][2]. 1. Initial Hi-Z State: All pins in the Charlieplexing array are initially configured as Hi-Z inputs. This is the default, quiescent state where pins present a high impedance to the circuit, effectively acting as open circuits and preventing any current flow through the LED network [1]. As noted earlier, this initialization strategy is particularly advantageous in resource-constrained embedded systems [1]. 2. Cathode Preparation (Pin B to LOW): The microcontroller first configures the cathode pin (Pin B) as a digital output and drives it to a logic LOW state (typically 0V relative to the system ground) [1][2]. This step establishes the low-potential side of the intended current path. A critical design practice is to set this LOW pin before activating the anode pin. This sequence prevents a scenario where both pins might momentarily be at a HIGH logic level, which could cause a damaging reverse voltage or unintended current flow through other parallel paths in the matrix [1]. 3. Anode Activation (Pin A to HIGH): Finally, the anode pin (Pin A) is configured as a digital output and driven to a logic HIGH state (e.g., 3.3V or 5V, depending on the microcontroller's supply voltage, V_cc) [1][2]. With Pin A at a higher electrical potential than Pin B, a forward voltage is applied across the LED connected between them. If this voltage exceeds the LED's forward voltage (V_f), current begins to flow from Pin A, through the current-limiting resistor and the LED, to Pin B, causing the LED to emit light [1][2]. During this active phase, all other pins in the system not involved in this specific pair (Pin A and Pin B) must remain in the Hi-Z input state. This ensures they do not create alternative, lower-resistance paths that would shunt current away from the intended LED or cause multiple LEDs to illuminate simultaneously [1].

Electrical Design and Current Limiting

A current-limiting resistor is an essential series component for every LED in a Charlieplexed array. Its primary function is to set the forward current (I_f) to a safe and optimal value for the LED, preventing thermal damage due to overcurrent [1][2]. The value of this resistor is calculated using a modified form of Ohm's Law, which accounts for the voltage drop across the LED:

R_limit = (V_cc - V_f) / I_f

Where:

• R_limit is the required series resistance in ohms (Ω). - V_cc is the supply voltage provided by the microcontroller's HIGH output pin. - V_f is the forward voltage of the specific LED, which varies by color and chemistry (typically 1.8V for red, 2.0V for green/yellow, and 3.0V-3.6V for blue/white) [1]. - I_f is the desired forward current, commonly between 10 mA and 20 mA for standard indicator LEDs [1]. For a standard red LED with a V_f of 2.0V, powered from a 5V system with a target I_f of 15 mA, the calculation yields R_limit = (5V - 2.0V) / 0.015A = 200Ω [1]. This resistor must be placed in series with the LED on either the anode or cathode side. Its value is fixed during circuit design and must be chosen based on the worst-case V_cc and the smallest V_f among the LEDs used, to ensure the maximum current never exceeds the LED's absolute maximum rating [1][2].

Deactivation and State Transition

Proper deactivation is as crucial as activation for maintaining control and preventing ghosting or partial illumination. The recommended deactivation procedure is a two-step sequence that mirrors the activation sequence in reverse [1][2]:

1. First, drive the anode pin (Pin A) LOW. This action removes the forward voltage bias across the LED, causing the current to drop to zero and the LED to extinguish immediately [1]. 2. Then, reconfigure both pins A and B back to Hi-Z inputs. This returns the pins to the default, high-impedance state, effectively disconnecting them from the LED network and preparing them for the next cycle of the multiplexing algorithm or for use in activating a different LED pair [1][2]. This orderly shutdown prevents a situation where the cathode pin (B) is switched to Hi-Z while the anode pin (A) is still HIGH. Such a state could leave the anode connection floating at a high voltage, potentially allowing leakage currents or parasitic capacitances to sustain a small voltage across other LEDs, leading to faint ghosting [1].

Temporal Constraints in a Multiplexed System

In a practical Charlieplexing implementation, a single LED is not illuminated continuously. The microcontroller rapidly cycles through all LEDs that need to be "on" in a given frame, activating each one sequentially using the described procedure [1][2]. The human visual system's persistence of vision integrates these rapid flashes, perceiving a stable, continuously lit display [1]. Therefore, the active period (T_on) for any single LED during one refresh cycle is severely constrained. It is determined by the refresh rate and the total number of LEDs that are actively lit in the current display pattern. For a pattern lighting 10 LEDs on an 8-pin array (capable of 56 total), the T_on would be roughly 1.67 milliseconds. This brief pulse means the LED's instantaneous current during its T_on period can often be driven slightly higher than its nominal DC rating (a technique known as "pulse boosting") to compensate for the reduced duty cycle and maintain perceived brightness, though this must be done within the LED's peak forward current specifications [1][2].

Advantages and Design Implications

This "one-LED-at-a-time" operational principle is the source of Charlieplexing's key advantage: pin efficiency. The formula for the maximum number of addressable LEDs with n pins, n(n-1), derives directly from the number of unique ordered pin pairs (A, B) where A ≠ B [1][2]. Each pair corresponds to one possible current path and thus one uniquely addressable LED. However, this method introduces specific design challenges. The primary constraint is the reduced duty cycle and resultant lower average current per LED, which can limit maximum perceived brightness, especially for large arrays [1][2]. The circuit layout must be carefully designed to minimize parasitic capacitances and track lengths that could lead to cross-talk or slow switching speeds, which become problematic at high multiplexing rates [2]. Despite these constraints, the technique provides an elegant solution for driving a large number of indicators with a very limited number of microcontroller pins, as was required in applications like the FSFEB project [1].

# Light LED between B (high) and A (low)

This specific operational state within a Charlieplexed array represents the fundamental activation sequence for illuminating a single light-emitting diode (LED). It describes the precise configuration of two general-purpose input/output (GPIO) pins—designated here as Pin B and Pin A—to establish a forward-biased current path through a target LED whose anode is connected to Pin B and cathode to Pin A [1][2]. The methodology leverages the tri-state logic capabilities (HIGH, LOW, and high-impedance, or Hi-Z) of microcontroller pins to selectively enable one LED among many in a shared network [1][2].

Pin Configuration and Current Path

To activate the LED connected between Pin B (anode) and Pin A (cathode), the microcontroller executes a specific sequence of pin mode and state changes. The canonical procedure is as follows [1][2]:

• Step 1: Configure all pins to Hi-Z input. As a foundational step for Charlieplexing, all pins in the array are initially set to a high-impedance (Hi-Z) state, typically by configuring them as digital inputs. This ensures no unintended current flows before the target LED is addressed [1][2].
• Step 2: Set Pin A (cathode) as a LOW output. The microcontroller reconfigures Pin A from a Hi-Z input to a digital output and drives its logic level to LOW (e.g., 0V). This establishes the low-voltage sink for the current path [1][2].
• Step 3: Set Pin B (anode) as a HIGH output. Finally, the microcontroller reconfigures Pin B to a digital output and drives it to a HIGH logic level (e.g., 3.3V or 5V). The voltage difference between Pin B (HIGH) and Pin A (LOW) creates a forward bias across the target LED, causing it to illuminate [1][2]. The current flows from the voltage supply, through the internal driver of Pin B, through the current-limiting resistor in series with the LED, through the LED itself (from anode to cathode), and into Pin A, which sinks the current to ground. All other pins in the system remain in their Hi-Z input state, presenting a very high impedance that prevents the establishment of alternative, unintended current paths through other LEDs [1][2].

Electrical Design Considerations

The reliable operation of this state depends on several key electrical parameters beyond the basic pin states. The series current-limiting resistor (R_limit) is critical for setting the LED's forward current (I_f). Its value is calculated using a modified form of Ohm's Law: R_limit = (V_cc - V_f) / I_f, where V_cc is the supply voltage applied by the HIGH output pin and V_f is the forward voltage of the specific LED [1][2]. This is particularly relevant when considering the reverse bias condition imposed on other LEDs sharing the same pins. For instance, an LED connected between Pin A (anode) and Pin B (cathode) would have its anode at LOW (Pin A) and its cathode at HIGH (Pin B), applying a significant reverse voltage. While LEDs can tolerate a small reverse voltage (typically 5V), the design must ensure this does not exceed the LED's reverse breakdown voltage, which could cause leakage current or damage [1][2]. The high impedance of non-addressed pins generally mitigates this risk.

Timing and Multiplexing Context

The "# Light LED between B (high) and A (low)" state is not sustained continuously in a Charlieplexed display. It is one phase in a rapid time-division multiplexing (TDM) sequence. The microcontroller illuminates this specific LED for a very brief period (T_on), typically on the order of hundreds of microseconds to a few milliseconds, before deactivating it and moving to the next LED in the refresh cycle [1][2]. For an array of 56 LEDs (controlled by 8 pins) where all are lit, the T_on per LED would be about 298 microseconds [1][2]. This rapid cycling exploits the persistence of human vision to create a stable, apparently continuous image.

Deactivation Sequence

Properly extinguishing the LED is as crucial as activating it to avoid ghosting or partial illumination. This removes the forward voltage bias, causing the LED to stop emitting light immediately. - Then, reconfigure both Pin B and Pin A back to Hi-Z input states. This returns the pins to the safe, high-impedance starting condition, ready for the next activation cycle for a different LED pair. This sequence ensures a clean transition and prevents momentary short circuits that could occur if, for example, one pin were changed to a new state while the other remained active.

Application in Systems like FSFEB

This fundamental operation is the building block for complex displays. In systems like the FSFEB project, where an ATtiny3217 microcontroller must control many status LEDs with very few available pins, the Charlieplexing technique and this precise activation sequence are employed [1][2]. By programmatically sequencing through numerous pin pairs (B, A), (C, A), (C, B), etc., the firmware can control a large number of LEDs—n(n-1) for n pins—using a minimal set of GPIO resources [1][2]. The code implementing this would consist of loops and look-up tables that define which pin pairs to activate for each desired visual pattern, with careful timing to manage the refresh rate and brightness.

# Light LED between A (high) and C (low)

This section details the specific operational sequence for illuminating an individual light-emitting diode (LED) within a charlieplexed array, using the example of activating the LED connected between pins designated A (anode) and C (cathode). The procedure is a precise application of the tri-state logic principles that underpin the charlieplexing technique [1][2]. It involves a carefully ordered series of pin state changes to ensure reliable illumination while preventing unintended current paths that could cause ghosting or false activation of other LEDs in the network [2].

Pin State Configuration Sequence

The activation of a single LED requires configuring three distinct groups of pins within the system: the target anode, the target cathode, and all other unused pins. The sequence is critical for maintaining circuit integrity. 1. Configure Unused Pins to High-Impedance (Hi-Z): Before altering the states of the target pins, all other General-Purpose Input/Output (GPIO) pins not involved in the current activation must be set to a high-impedance (Hi-Z) input state [2]. This action electrically disconnects these pins from the active current path, presenting a very high resistance that prevents them from sinking or sourcing significant current. This step is fundamental to isolating the intended LED and is a direct application of the tri-state logic capability leveraged by charlieplexing [1]. 2. Drive the Cathode Pin (C) LOW: The next step is to configure the intended cathode pin (C) as a digital output and drive it to a logic LOW state (typically 0V relative to the system ground) [2]. Establishing the cathode at a low potential first creates the necessary voltage gradient for forward biasing the LED once the anode is activated. This order helps prevent transient states that could briefly forward-bias other unintended LED paths. 3. Drive the Anode Pin (A) HIGH: Finally, the target anode pin (A) is configured as a digital output and driven to a logic HIGH state (e.g., V_cc, often 3.3V or 5V) [2]. With the cathode already at LOW, this creates a positive voltage difference from pin A to pin C. When this difference exceeds the LED's forward voltage (V_f, typically 1.8V-3.3V), the LED becomes forward-biased and conducts current, resulting in illumination. The current is limited by a series resistor, whose value is calculated using Ohm's Law: R_limit = (V_cc - V_f) / I_f, where I_f is the desired forward current [2].

Electrical Pathway and Current Limitation

When pins A and C are correctly set to HIGH and LOW respectively, and all other pins are in Hi-Z, a complete electrical circuit is formed. Current flows from the microcontroller's power rail, through the internal circuitry of pin A configured as a HIGH output, through the external current-limiting resistor connected to pin A, through the LED from anode to cathode, into pin C configured as a LOW output, and finally back to the system ground through the microcontroller [2]. The series resistor is a critical safety component.

Deactivation and State Transition

Properly extinguishing the LED is as methodical as lighting it, and is essential for clean multiplexing and preventing latch-up or shoot-through currents in the microcontroller's output stages. 1. Drive the Anode Pin (A) LOW: The deactivation sequence begins by reconfiguring the anode pin (A) as an output (if not already) and driving it to a logic LOW state [2]. This action removes the positive voltage potential from the anode side of the LED. Since the cathode is already at LOW, the voltage potential across the LED drops to zero (or near zero), immediately ceasing current flow and extinguishing the light [2]. 2. Reconfigure Pins to Hi-Z or Next Target: After the LED is off, the pins must be prepared for the next step in the multiplexing cycle. Typically, both pins A and C are reconfigured back to high-impedance (Hi-Z) input states [2]. This returns them to a neutral, high-resistance condition, making them ready to be reassigned as anode, cathode, or left unused for the subsequent LED activation in the refresh sequence. Alternatively, if the next LED to be illuminated shares one of these pins, the controller may transition directly to the configuration for that LED, following the prescribed activation order.

Application in Multiplexing Cycles

This precise "A-high, C-low" procedure is not executed in isolation but is one step in a rapid, cyclical scanning algorithm that refreshes the entire LED array. The controller iterates through each LED in the array, activating them one at a time (or a few at a time in more advanced schemes) using this fundamental method [2]. For a system with 8 GPIO pins, this allows control of 8 * 7 = 56 individual LEDs [2]. Each LED is illuminated for a very brief period (T_on) during each refresh cycle of the entire array. The maximum on-time per LED is constrained by this refresh rate and the total number of LEDs; for an array of 56 LEDs refreshed at 60 Hz, the T_on is approximately 1 / (56 * 60 Hz) ≈ 298 microseconds [2].

Advantages and Design Considerations

The primary advantage of this method is the exponential increase in the number of LEDs that can be controlled relative to the number of GPIO pins used, a efficiency critical for resource-constrained embedded systems like the FSFEB project which employed an ATtiny3217 microcontroller [2]. A major consideration is managing forward voltage drops and preventing unintended conduction through parasitic paths created by multiple LEDs sharing common nodes [2]. The charlieplexing technique, through ordered procedures like the A-high/C-low activation, provides a systematic way to navigate these challenges and achieve dense LED matrices with minimal hardware resources [1][2].

# Light LED between C (high) and A (low)

This specific operational sequence within a Charlieplexing scheme details the precise steps required to illuminate a single light-emitting diode (LED) connected between two general-purpose input/output (GPIO) pins, designated C and A, where pin C serves as the anode (driven HIGH) and pin A serves as the cathode (driven LOW). The procedure is a fundamental building block for dynamically controlling large LED arrays with minimal microcontroller pins, leveraging the tri-state logic (HIGH, LOW, and high-impedance) capabilities of modern microcontrollers like the ATtiny3217 [1][2]. The methodology ensures that only the intended LED conducts current while preventing unintended activation of other LEDs in the shared network, a critical consideration given the complex interconnectivity of Charlieplexed circuits [1].

### Pin Configuration and Initial State

Prior to activating any LED, the microcontroller must establish a known, safe state for all pins involved in the Charlieplexing array. The standard initialization procedure configures all GPIO pins as high-impedance (Hi-Z) inputs [1][2]. In this state, the pins present a very high electrical resistance to the circuit, effectively disconnecting their internal drivers from the external node. This prevents any stray currents from flowing through the LED network and ensures no LEDs are partially forward-biased due to floating voltages. For the specific case of lighting the LED between pin C (anode) and pin A (cathode), all other pins in the array must remain in this Hi-Z input state throughout the activation sequence to avoid creating alternative current paths [1].

### Step-by-Step Activation Sequence

The activation of a single LED in a Charlieplexed matrix is a deliberate, multi-step process designed to prevent ghosting (unintended partial illumination) and protect components from current spikes. 1. Configure the Cathode (Pin A) as a LOW Output: The first step is to establish the low-voltage side of the circuit. Pin A is reconfigured from a Hi-Z input to a digital output and immediately driven to a logic LOW state (e.g., 0V) [1][2]. This action creates the necessary low-potential sink for current flow. Establishing the cathode first is crucial; if the anode were driven HIGH before the cathode was established as LOW, a momentary undefined voltage could appear across other LEDs sharing the anode pin, potentially causing brief, erroneous flashes. 2. Configure the Anode (Pin C) as a HIGH Output: Once the cathode is securely held at LOW, pin C is reconfigured from Hi-Z to a digital output and driven to a logic HIGH state (e.g., 5V or 3.3V, depending on the system) [1][2]. The voltage difference between pin C (HIGH) and pin A (LOW) now forward-biases the LED connected between them. Current flows from pin C, through a current-limiting resistor in series with the LED, through the LED itself, and into pin A. The current-limiting resistor is mandatory and its value is calculated using Ohm's Law: R_limit = (V_cc - V_f) / I_f, where V_cc is the supply voltage (the HIGH output level), V_f is the LED's forward voltage, and I_f is the desired forward current [1][2]. 3. Maintain All Other Pins in Hi-Z: Throughout this process, every other GPIO pin in the Charlieplexing array must remain configured as high-impedance inputs. This ensures they do not provide an alternative path for current that could bypass the intended LED or create parasitic voltage dividers that might partially illuminate other LEDs [1].

### Electrical Considerations and Current Path Analysis

When pin C is HIGH and pin A is LOW, a complete circuit is formed. The microcontroller's output driver at pin C sources current, which then travels through the external network. In a correctly designed Charlieplexed layout, the only low-resistance path available for this current is through the specific LED connected between pins C and A, and its series resistor. All other LEDs connected to either pin C or pin A will be reverse-biased or have an open circuit in their path, preventing conduction [1][2]. For instance, consider an LED connected between pin C (anode) and pin B (cathode). During the activation of the C-to-A LED, pin B is in a Hi-Z state. While the anode of this C-B LED is at HIGH voltage (from pin C), its cathode is not actively pulled LOW. It is floating, so the voltage at that node is determined by leakage currents and parasitic capacitance, insufficient to establish the forward voltage (V_f) required for illumination. Similarly, an LED connected between pin D (anode) and pin A (cathode) has its cathode at LOW (via pin A), but its anode, connected to pin D in Hi-Z, is not driven HIGH, leaving it reverse-biased or open [1].

### Timing Constraints and Multiplexing Integration

The illumination of the C-to-A LED is not sustained continuously in a multiplexed display. As noted earlier, the LED remains illuminated for a brief period, typically 1-5 milliseconds in a multiplexing scheme, before the system sequences to the next LED in the refresh pattern [1]. The on-time (T_on) for each LED is a function of the total number of LEDs being actively refreshed and the desired refresh rate to avoid visible flicker. The microcontroller's firmware uses a timer or a loop to control this duration precisely before proceeding to the deactivation sequence and then activating the next LED pair.

### Deactivation and Transition to Next State

To extinguish the LED and prepare the pins for the next operation in the multiplexing cycle, a controlled deactivation sequence is followed. This removes the forward voltage bias across the LED, causing current to cease immediately. - Then, reconfigure both pins C and A back to the high-impedance (Hi-Z) input state [1]. This returns them to the safe, neutral initial condition. This order is important. Driving the anode LOW first ensures a clean turn-off. If the pins were simply reconfigured to Hi-Z simultaneously, their internal and parasitic capacitances could discharge slowly, potentially causing a dim tail-off or creating momentary ambiguous states as the pins float. After both pins are in Hi-Z, the system can then begin the activation sequence for the next LED in the display refresh pattern, such as lighting an LED between pin D (HIGH) and pin B (LOW) [1][2].

### Application in the FSFEB Project

This precise control mechanism was essential for the FSFEB project, where a large number of status indicator LEDs were required, but the ATtiny3217 microcontroller had most of its pins allocated to other functions like switch matrix scanning and communication interfaces [1][2]. By implementing Charlieplexing with control sequences like "light LED between C (high) and A (low)," the design achieved control over many LEDs using just a few remaining GPIO pins. The firmware cycled through these activation sequences rapidly to update the status display for all modules, integrating this LED-driving task with the core debouncing and scanning algorithms running on the same microcontroller [1].

# Light LED between B (high) and C (low)

This section details the specific operational sequence for activating a single LED in a charlieplexed array by establishing a controlled current path between two designated General-Purpose Input/Output (GPIO) pins. The procedure is a fundamental atomic operation within the broader multiplexing cycle that refreshes the entire display [1][2]. The example uses pins labeled B and C, where B serves as the high-side driver (anode connection) and C serves as the low-side driver (cathode connection). Correct execution requires strict adherence to a state machine that manages pin configurations to prevent bus contention, short circuits, and unintended illumination of other LEDs in the network [2].

### Pin State Management and Initial Conditions

Prior to activation, the system must be in a known, safe state. All GPIO pins involved in the charlieplexing matrix are typically initialized as high-impedance (Hi-Z) inputs. This tri-state condition presents a very high resistance to the circuit, effectively disconnecting the microcontroller's output drivers from the network and preventing any current flow [1][2]. The activation sequence for the LED connected between pin B (anode) and pin C (cathode) is a multi-step process designed to avoid transient states that could cause unwanted effects:

1. Configure Cathode (Pin C) as LOW Output: The microcontroller first reconfigures pin C from a Hi-Z input to a digital output driven to a logic LOW state (e.g., 0V) [2]. This action establishes the low-voltage reference point for the circuit. It is critical to perform this step before activating the anode. If pin B were driven HIGH first while pin C remained in a Hi-Z or undefined state, the voltage on the shared network node could float, potentially causing weak or unintended conduction through other parallel LED paths in the matrix [2]. 2. Current flows from pin B, through the current-limiting resistor in series with the LED, through the LED itself (causing it to emit light), and into pin C, which sinks the current to ground [1][2]. This ordered procedure—cathode LOW before anode HIGH—is essential. Reversing the steps could create a momentary condition where both pins are HIGH (if the anode were activated while the cathode was still Hi-Z), resulting in no forward bias and thus no illumination, but more importantly, it fails to establish the necessary controlled current path from the outset [2].

### Electrical Characteristics and Current Path Analysis

When the sequence is complete, a complete series circuit is formed: V_CC (Internal) → Pin B Output Driver → PCB Trace → Resistor R_limit → LED → PCB Trace → Pin C Output Driver → Ground. The electrical behavior is governed by Kirchhoff's voltage law and the non-linear I-V characteristic of the LED. The current-limiting resistor (R_limit) is a critical series component. - V_f is the forward voltage drop of the specific LED, which depends on its semiconductor material and color (e.g., approximately 2.0V for a standard red LED) [2]. - I_f is the desired forward current for nominal brightness, commonly between 10 mA and 20 mA for standard indicators [2]. The instantaneous power dissipation in the resistor during the LED's on-time is P = I_f² * R_limit = (0.015A)² * 200Ω = 0.045W, well within the rating of a standard 1/4W resistor [2]. The output pins themselves must sink or source this current. The ATtiny3217, like many microcontrollers, has per-pin and total package current limitations (e.g., 40 mA per I/O pin, 200 mA for the entire device, as typical for the ATtiny series). The 15 mA design current in this example is safely within these limits [2]. The pin configured as LOW output (Pin C) acts as a current sink, and its internal MOSFET must safely conduct the I_f to ground.

### Deactivation and Transition to Next State

Extinguishing the LED requires careful sequencing to avoid a "glitch" or momentary flash of another LED. The deactivation sequence is the reverse of activation, but with added caution:

1. Drive Anode (Pin B) LOW: First, the microcontroller drives the output level of pin B from HIGH to LOW [2]. This action removes the forward bias by bringing the anode voltage down to (or near) the cathode voltage. The voltage across the LED immediately drops to near zero, ceasing current flow and turning the LED off. This step must come first. 2. Reconfigure Pins to Hi-Z or Next State: After both pins B and C are at logic LOW, they can be safely reconfigured. Typically, they are set back to high-impedance (Hi-Z) input states to prepare for the next phase of the multiplexing cycle, or they are immediately reconfigured for the next LED activation in the refresh pattern [2]. The critical rule is to never change the cathode pin (C) from a LOW output to a Hi-Z state while the anode (B) is still HIGH. Doing so would leave the cathode node floating at a high impedance. If the next step in the multiplexing sequence involved configuring another pin (e.g., Pin D) as a LOW output connected to this floating network, it could create an unintended current path through other LEDs, causing a brief, erroneous flash [2]. Driving the anode LOW first collapses the voltage across the LED, making the subsequent state changes safe.

### Timing Constraints within the Multiplexing Cycle

This entire activate-deactivate sequence for one LED constitutes a single slot in a time-division multiplexing (TDM) scheme. The LED's on-time (T_on) is the duration between the completion of its activation sequence and the initiation of its deactivation sequence. As noted earlier, for a refresh rate of 60 Hz and k active LEDs in a pattern, the maximum T_on per LED is approximately 1/(k * 60) seconds [2]. Therefore, the software routine executing the 4-step sequence (Cathode LOW, Anode HIGH, Anode LOW, Hi-Z) must execute in a fraction of this time. The duration is dictated by the microcontroller's clock speed and the efficiency of the GPIO control code. A delay or excessive execution time would directly reduce the available illumination time (T_on), lowering the LED's duty cycle and perceived brightness [2].

### Integration into System Software

In a practical implementation, such as the FSFEB project using the ATtiny3217, this low-level pin-control sequence is encapsulated within a driver function or a macro [2]. The system maintains a frame buffer in memory representing the desired on/off state of each of the n(n-1) possible LEDs. A display refresh function iterates through this buffer. For each LED that needs to be lit, it calls the activation sequence for its specific pin pair, waits for the prescribed T_on, executes the deactivation sequence, and then proceeds to the next lit LED in the scan list. This loop runs continuously, and the order of scanning can be optimized to minimize the number of pin reconfigurations between consecutive LEDs, thereby improving efficiency [1][2].