Embedded C programming: GPIO and bit manipulation

Why it matters

Every sensor input, LED, relay driver and solenoid valve on a microcontroller board is reached through GPIO registers, and the only safe way to change one pin without disturbing the other seven (or thirty-one) is bit manipulation. Getting a mask or a bit number wrong switches the wrong actuator — on a machine, that is a safety problem, not just a bug.

Key ideas

GPIO registers. Each port is controlled by a small set of memory-mapped registers. On an AVR (ATmega) port B, for example:

• DDRB — data direction: bit = 1 makes the pin an output, 0 an input.
• PORTB — output latch; for a pin set as input, writing 1 enables the internal pull-up.
• PINB — reads the actual pin levels. On an STM32 (Cortex-M) the equivalents are MODER (2 bits per pin), ODR (output data), IDR (input data) and BSRR, which sets or resets pins atomically with a single write. Other families use other conventions (PIC's TRIS uses 0 for output), so always check the datasheet.

Bit numbering. Bits are numbered from 0 at the least significant bit (LSB). "Bit 3" means mask 1 << 3 = 0x08. Phrases like "the 3rd bit" are ambiguous — state the bit number.

The four core operations (n = bit number):

• Set: REG |= (1 << n);
• Clear: REG &= ~(1 << n);
• Toggle: REG ^= (1 << n);
• Test: if (REG & (1 << n)) or bit = (REG >> n) & 1; OR with 1 forces a 1, AND with 0 forces a 0, XOR with 1 inverts, and in each case the bits with mask 0 (or 1 for AND) are left unchanged.

Fields. Many control registers pack multi-bit fields (prescalers, modes). To write value v into a k-bit field starting at bit p: clear the field, then OR in the shifted value. To read it: shift right and mask.

Shifts. x << k multiplies an unsigned value by 2ᵏ; bits shifted out of the register width are lost. x >> k divides an unsigned value by 2ᵏ (integer). Right-shifting a negative signed value is implementation-defined in C — use unsigned types (uint8_t, uint32_t) for registers.

volatile. Registers and variables changed by hardware or an ISR must be declared volatile so the compiler re-reads them every time instead of keeping a stale copy in a CPU register.

Read-modify-write hazards. PORTB |= 0x01 is really read, OR, write. If an interrupt changes another bit of PORTB in between, that change is lost. Fixes: disable interrupts briefly, use atomic set/reset registers (BSRR), or bit-band/bit instructions (8051 SETB, AVR SBI/CBI for low I/O addresses).

Electrical side. Inputs must never float: use pull-up or pull-down resistors (internal or external). Mechanical switches bounce for a few milliseconds, so debounce in software or with an RC filter. Outputs have current limits per pin and per port (take from the datasheet; a few mA to about 20 mA is typical); larger loads need a transistor, MOSFET or relay driver.

Formulas

mask = 1 << n

• n = bit number (0 = LSB). Mask is an unsigned integer of the register width.

REG_new = (REG & ~(m << p)) | ((v & m) << p)

• Writes field value v; m = 2ᵏ − 1 for a k-bit field; p = position of the field's lowest bit.

v = (REG >> p) & m

• Reads a k-bit field.

(x << k) mod 2ʷ

• Result of a left shift in a w-bit register; overflowing bits are discarded.

R = (V_CC − V_F) / I_F

• LED series resistor (Ω): V_CC = output high voltage (V), V_F = LED forward voltage (V), I_F = desired current (A). Check I_F against the pin limit.

f_out = f_clk / (2 × N)

• Square-wave frequency (Hz) from a software toggle loop that spends N clock cycles between toggles; f_clk = CPU clock (Hz).

Worked examples

Example 1 (standard). PORTB = 0b1010 1100 (0xAC). Toggle bit 2, then clear bit 7, then set bit 0.

1. Toggle bit 2: mask = 1 << 2 = 0x04. Bit 2 of 0xAC is 1, so it becomes 0: 0xAC ^ 0x04 = 0xA8.
2. Clear bit 7: mask = ~(1 << 7) = 0x7F. 0xA8 & 0x7F = 0x28.
3. Set bit 0: 0x28 | 0x01 = 0x29.

Final value: 0x29 = 0b0010 1001.

Example 2 (GATE level). An 8-bit timer control register holds 0xB5. Bits 6–4 form a 3-bit prescaler field. (a) Write the code and the new register value for prescaler code 6. (b) Read the field back. (c) A software loop toggles a pin every 4 clock cycles on a 16 MHz MCU; find the output frequency. (d) Choose an LED resistor for a 5 V pin, V_F = 2 V, I_F = 10 mA.

1. Field: k = 3 → m = 0b111 = 7, p = 4. Clear mask = ~(7 << 4) = ~0x70 = 0x8F.
2. 0xB5 & 0x8F = 0x85 (1011 0101 → 1000 0101).
3. Value shifted: 6 << 4 = 0x60. New value = 0x85 | 0x60 = 0xE5. Code: REG = (REG & ~(7u << 4)) | (6u << 4);
4. Read back: (0xE5 >> 4) & 7 = 0x0E & 7 = 6 ✓.
5. f_out = f_clk / (2 × N) = 16 × 10⁶ / (2 × 4) = 2 × 10⁶ Hz → 2 MHz (each period needs two toggles).
6. R = (5 − 2) V / 0.010 A = 300 Ω; take the next standard value 330 Ω, giving I = 3 / 330 = 9.1 mA, within a typical pin rating.

Common mistakes

• Mixing 1-based "nth bit" with 0-based bit numbers — 1 << 5 is bit 5, the sixth bit.
• Using & with the mask itself instead of its complement when clearing: REG &= (1 << n) clears every other bit.
• Writing REG = (1 << n) instead of REG |= (1 << n), wiping the rest of the port.
• Forgetting that shifts overflow an 8-bit register: 0x5A << 2 is 0x68 in 8 bits, not 0x168.
• Operator precedence: REG & 1 << n == 0 parses as REG & ((1 << n) == 0). Bracket everything.
• Omitting volatile on a flag set in an ISR, so the main loop never sees it change.
• Leaving inputs floating, or driving a relay coil straight from a pin.

For GATE ME

Expect short questions on binary/hexadecimal conversion, results of AND/OR/XOR/shift on given register values, choosing the correct mask expression, and simple timing (toggle frequency, delay loops) or interfacing calculations (resistor for an LED). Practise converting hex ↔ binary quickly, tracking a register through several operations, and remembering the register width when shifting.

Quick check

1. What is 0b1100 & 0b1010?
2. Write the C statement that sets bit 5 of PORTD.
3. What is 0x3C after clearing bit 3?
4. What is 0x5A << 2 in an 8-bit register (in hex)?
5. Why must an ISR-shared flag be volatile?

Answers: 1. 0b1000 2. PORTD |= (1 << 5); 3. 0x34 4. 0x68 5. So the compiler re-reads it from memory instead of using a cached copy.