Practical Binary Coding Examples for ADC and GPIO Registers

When you transition from writing high-level Python scripts to programming bare-metal microcontrollers or debugging digital logic on a workbench, binary coding stops being an abstract math concept and becomes a physical reality. A flipped bit is not just a syntax error; it is a MOSFET driven into saturation when it should be in cutoff, or a 16-bit ADC returning garbage data because of an endianness mismatch. For electronics engineering students and embedded hobbyists, mastering binary coding examples is the bridge between theoretical digital logic and functional hardware.

This guide walks through two high-yield exam and practice problems: analog-to-digital quantization and bare-metal GPIO register masking. We will break down the governing theorems, expose the common traps that cost points on exams, and show you how to verify your answers independently on the bench.

The Core Method: Quantization Theory and Boolean Masking

Before attacking the math, we must establish the physical theorems governing these systems. For ADCs, the governing principle is uniform quantization. A Successive Approximation Register (SAR) ADC maps a continuous analog voltage range into discrete digital steps. The resolution is dictated by the reference voltage ($V_{ref}$) and the bit-depth ($n$). According to Analog Devices' technical notes on converter errors, the ideal step size (Least Significant Bit, or LSB) is exactly $V_{ref} / (2^n - 1)$, not $2^n$. This distinction is the most frequent point of failure in exam settings.

For microcontroller registers, the governing method is Boolean algebraic masking. Hardware registers like the ESP32's GPIO_OUT_REG are 32-bit memory addresses where each bit directly controls a physical pin. To manipulate specific pins without disturbing others, we use bitwise OR (to set bits HIGH) and bitwise AND (to clear bits LOW). This relies on the identity theorems: $X ext{ OR } 1 = 1$, $X ext{ OR } 0 = X$, $X ext{ AND } 0 = 0$, and $X ext{ AND } 1 = X$.

Walkthrough: 12-Bit ADC Binary to Voltage Conversion

Step 1: Identify the Governing Formula
The method applied here is uniform quantization mapping. The formula to convert a digital output code ($D_{out}$) back to an analog input voltage ($V_{in}$) is:

$$V_{in} = \left( \frac{D_{out}}{2^n - 1} \right) \times V_{ref}$$

Step 2: Convert Binary to Decimal (Show All Powers)
We map each bit position to its base-2 weight, starting from the Most Significant Bit (MSB) at position 11 down to the Least Significant Bit (LSB) at position 0.

• Bit 11 (0): $0 \times 2^{11} = 0$
• Bit 10 (1): $1 \times 2^{10} = 1024$
• Bit 9 (0): $0 \times 2^9 = 0$
• Bit 8 (1): $1 \times 2^8 = 256$
• Bit 7 (1): $1 \times 2^7 = 128$
• Bit 6 (0): $0 \times 2^6 = 0$
• Bit 5 (1): $1 \times 2^5 = 32$
• Bit 4 (0): $0 \times 2^4 = 0$
• Bit 3 (1): $1 \times 2^3 = 8$
• Bit 2 (1): $1 \times 2^2 = 4$
• Bit 1 (0): $0 \times 2^1 = 0$
• Bit 0 (0): $0 \times 2^0 = 0$

Summing the non-zero terms: $1024 + 256 + 128 + 32 + 8 + 4 = 1452$.
Therefore, $D_{out} = 1452$.

Step 3: Apply the Quantization Formula
Substitute $D_{out} = 1452$, $n = 12$, and $V_{ref} = 3.3$ into the equation:

$$V_{in} = \left( \frac{1452}{2^{12} - 1} \right) \times 3.3$$
$$V_{in} = \left( \frac{1452}{4095} \right) \times 3.3$$
$$V_{in} = 0.354578 \times 3.3$$
$$V_{in} \approx 1.1701 \text{ V}$$

Answer Sanity Check:
The MSB (Bit 11) is 0. This immediately tells us the voltage must be less than half of the reference voltage ($3.3 / 2 = 1.65$ V). Our answer of 1.17 V is logically consistent with the MSB state. Furthermore, the next bit (Bit 10) is 1, meaning the value is at least $1/4$ of the full scale ($0.825$ V). 1.17 V sits perfectly between 0.825 V and 1.65 V.

Independent Verification:
To verify on the bench, you would feed a known 1.170 V signal from a calibrated bench power supply into the ADC pin and read the register. In software, reverse-calculate: $(1.1701 / 3.3) \times 4095 = 1451.98$, which rounds cleanly back to our integer 1452.

Walkthrough: GPIO Register Bitwise Masking

Step 1: Analyze the Current State
Current Register: 1011 0110
Bit positions (7 to 0):
Bit 7=1, Bit 6=0, Bit 5=1, Bit 4=1, Bit 3=0, Bit 2=1, Bit 1=1, Bit 0=0.

Step 2: Formulate the OR Mask (Set Bits HIGH)
To set specific bits without affecting others, we use the bitwise OR operator (|). We place a 1 in the positions we want to force HIGH, and 0 in positions we want to leave alone.
Target: Set bits 2 and 3.
OR Mask: 0000 1100 (Hex: 0x0C).

Step 3: Apply the OR Operation

  1011 0110  (Current State)
| 0000 1100  (OR Mask)
  ---------
  1011 1110  (Intermediate State)

Step 4: Formulate the AND Mask (Clear Bits LOW)
To clear specific bits, we use the bitwise AND operator (&). We place a 0 in the positions we want to force LOW, and 1 in positions we want to preserve.
Target: Clear bits 4 and 5.
AND Mask: 1100 1111 (Hex: 0xCF).

Step 5: Apply the AND Operation

  1011 1110  (Intermediate State)
& 1100 1111  (AND Mask)
  ---------
  1000 1110  (Final State)

Answer Sanity Check:
Original: 1011 0110. We wanted bits 2,3 to be 1 (they are now 1). We wanted bits 4,5 to be 0 (they are now 0). Bits 7,6,1,0 should remain untouched. Original bits 7,6,1,0 were 1,0,1,0. Final bits 7,6,1,0 are 1,0,1,0. The logic holds perfectly.

Independent Verification:
On a physical development board, you would compile this logic using bare-metal register writes (e.g., writing to the GPIO_OUT_W1TS_REG to set and GPIO_OUT_W1TC_REG to clear on an ESP32). You then verify the answer by probing the physical pins with a digital multimeter. Pins mapped to bits 2 and 3 should read ~3.3V, while pins mapped to bits 4 and 5 should read ~0.0V.

Exam Survival FAQ: Binary Coding Pitfalls