Pointer Casting Examples in Embedded C: What This Page Covers

These pointer casting examples in embedded C apply Lesson 9.5: byte-swap helpers for network order, a frame codec with a CRC-16, decoding an IEEE-754 float with memcpy, a word-copy routine that checks alignment, a packed record serialised field by field, sign extension of ADC samples, decoding a 32-bit GPIO register and a union overlay of a register. Every program was compiled with GCC and run; the output is real. These pointer casting examples in embedded C build on each other.

Example 1: Byte-Swap Helpers and Network Order

Problem: Send a port number and an IPv4 address in network (big-endian) byte order from a little-endian MCU. swap16 and swap32 reorder the bytes with shifts and masks. The conversion functions swap only on a little-endian host, so the same source is correct on a big-endian CPU. The byte dumps show the effect: the port 0x1F90 sits in memory as 90 1F and goes onto the wire as 1F 90; the address 0xC0A80101 changes from 01 01 A8 C0 to C0 A8 01 01, the familiar 192.168.1.1. On the Cortex-M4 the compiler recognises these patterns and emits a single REV or REV16 instruction. Among the pointer casting examples in embedded C this pattern is very common.

Example 2: A Frame Codec with CRC-16

Problem: Exchange commands over a UART with error detection. The frame is 0xAA, a length, a command, the payload and a 16-bit CRC, all multi-byte values in big-endian order. The CRC is the standard CRC-16/CCITT-FALSE (polynomial 0x1021, start value 0xFFFF); the program first checks the implementation against the well-known test vector “123456789” whose CRC is 0x29B1. The builder writes bytes with shifts, and the parser reads the CRC the same way, so no pointer to a wider type is ever formed and the alignment of the buffer does not matter. A single flipped bit is detected by the CRC (result −3). Keep these pointer casting examples in embedded C for revision.

Example 3: Decoding an IEEE-754 Float

Problem: Inspect how a 32-bit float is stored, for example to debug sensor data in a hex dump. memcpy copies the four bytes into a uint32_t without violating strict aliasing. The fields are 1 sign bit, 8 exponent bits (biased by 127) and 23 mantissa bits with an implied leading 1. For 1.0 the exponent is 127 (unbiased 0) and the mantissa is 0; for −2.5 the sign bit is set, the exponent 128 and the mantissa 0x200000 (the fraction .25 in binary 01 followed by zeros). The value 0.1 cannot be represented exactly, which shows as the repeating mantissa pattern 0x4CCCCD. The last lines go the other way and build 3.0 from fields.

Example 4: Word Copy with an Alignment Check

Problem: Copy faster by moving four bytes at a time, but only when that is legal. The test ((uintptr_t)d | (uintptr_t)s) & 3 is zero only if both addresses are multiples of 4, because OR-ing keeps any set low bit. Only then are the pointers converted to uint32_t *. The first call copies 15 bytes as 3 words plus 3 single bytes; the second call has an unaligned destination and falls back to 14 byte copies. Real library memcpy implementations use exactly this idea, plus extra code for the case where only one pointer is unaligned. The declaration _Alignas(4) (C11) guarantees the arrays are aligned; without it a uint8_t array may start at any address.

Example 5: Serialising a Record Field by Field

Problem: Store or transmit a record in a fixed format that does not depend on the compiler’s padding or the CPU’s byte order. In memory the structure occupies 12 bytes (padding after id and at the end); the wire format needs only 8: id, four timestamp bytes least significant first, two bytes of temperature and the flags. record_write and record_read move each field explicitly with shifts, so the format is the same on every compiler and CPU, and the buffer needs no alignment. The negative temperature −57 is cast to uint16_t first (so the shift acts on the bit pattern 0xFFC7) and back to int16_t when reading, restoring −57.

Example 6: Sign Extension of 12-Bit Samples

Problem: A sensor delivers 12-bit two’s-complement values in the low bits of a 16-bit word. A cast to int16_t does not make them negative, because the sign bit of the 12-bit field (bit 11) is not the sign bit of the 16-bit type. sign_extend masks the field and uses the trick (raw ^ sign) - sign, which flips the sign bit and subtracts it: 0x800 becomes −2048, 0xFFF becomes −1 and 0xFC7 becomes −57. The last lines illustrate conversion rules: converting an out-of-range value to a signed type is implementation-defined (GCC wraps modulo 2ⁿ), while conversion to an unsigned type is always defined as reduction modulo 2ⁿ.

Example 7: Decoding GPIOA_MODER

Problem: Read a GPIO mode register in a debugger and understand it. MODER has two bits per pin (00 input, 01 output, 10 alternate function, 11 analog). The decoder shifts the register right by 2 × pin and masks two bits. The reset value of GPIOA_MODER on the STM32F407 is 0xA8000000: PA13, PA14 and PA15 are in alternate-function mode (10), because those pins carry the debug interface (SWDIO, SWCLK and JTDI) after reset; all other pins are inputs. The second value, 0x55000000, is GPIOD with PD12 to PD15 set to output (01). No pointer cast is involved: a 32-bit register value is simply a number, and shifting and masking extracts its fields.

Example 8: A Union Overlay of a Register

Problem: Look at a 32-bit value as a word, as two half-words and as four bytes without pointer casts. A union places all members at the same address; type punning through a union is permitted in C99 and later. On a little-endian CPU byte[0] is the least significant byte, so 0xAABBCCDD gives half[0] = 0xCCDD and byte[0] = 0xDD. Writing byte[1] = 0 clears bits 15:8, producing 0xAABB00DD, and writing half[1] replaces the upper 16 bits. On a big-endian machine the same program would print different numbers: the union exposes the byte order of the host, so it is a tool for debugging and for hardware-specific code, not for portable file formats (Module 16 covers unions in depth).

Example 9: Mini Exercises

Key Takeaways from the Pointer Casting Examples in Embedded C

• These pointer casting examples in embedded C show that shifts and masks are the portable way to read and write multi-byte fields.
• Check alignment (low address bits) before forming a wider pointer.
• memcpy is the safe tool for reinterpreting bytes as another type.
• A wire format should be defined field by field, independent of padding and byte order.
• Sign extension needs the real field width, not a plain cast.
• Registers are numbers: extract fields by shifting and masking.