Fixed-width integers (uint8_t, uint16_t, uint32_t) in Embedded C - Step-by-Step Execution

Concept Flow - Fixed-width integers (uint8_t, uint16_t, uint32_t)

Start

↓

Choose integer type

↓

Assign value

↓

Check value fits in bits?

No→Overflow occurs

Yes↓

Use value in program

↓

End

This flow shows how fixed-width integers are chosen, assigned values, checked for size limits, and used safely in embedded C.

Execution Sample

Embedded C

uint8_t a = 255;
uint16_t b = 50000;
uint32_t c = 3000000000;

Assign maximum and large values to fixed-width unsigned integers of 8, 16, and 32 bits.

Execution Table

Step	Variable	Assigned Value	Fits in Bits?	Result
1	a (uint8_t)	255	Yes (0-255)	a = 255
2	b (uint16_t)	50000	Yes (0-65535)	b = 50000
3	c (uint32_t)	3000000000	Yes (0-4294967295)	c = 3000000000
4	a (uint8_t)	256	No (overflow)	Value wraps to 0
5	b (uint16_t)	70000	No (overflow)	Value wraps to 4464

💡 Execution stops after demonstrating valid assignments and overflow wrap-around behavior.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
a	undefined	255	255	255	0	0
b	undefined	undefined	50000	50000	50000	4464
c	undefined	undefined	undefined	3000000000	3000000000	3000000000

Key Moments - 3 Insights

Why does assigning 256 to a uint8_t variable cause it to wrap to 0?

Because uint8_t can only hold values from 0 to 255 (8 bits). Assigning 256 exceeds this range, causing overflow and wrapping back to 0, as shown in step 4 of the execution_table.

How do we know if a value fits in a fixed-width integer type?

Check if the value is between 0 and the maximum for that type (e.g., 0-255 for uint8_t). Steps 1-3 show valid assignments where values fit within the bit limits.

What happens if a value is too large for uint16_t, like 70000?

It causes overflow and wraps around modulo 65536 (2^16). Step 5 shows 70000 wraps to 4464 because 70000 - 65536 = 4464.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'a' after step 4?

A 255

B 256

C 0

D Undefined

💡 Hint

Check the 'Result' column for step 4 where 'a' wraps due to overflow.

At which step does the variable 'b' first get assigned a value that does NOT fit in its type?

A Step 5

B Step 3

C Step 2

D Step 4

💡 Hint

Look for 'Fits in Bits?' column showing 'No' for 'b' in the execution_table.

If we assign 256 to a uint8_t variable, what would be the new value after wrapping?

A 1

B 0

C 255

D 256

💡 Hint

Refer to step 4 in execution_table where 256 assigned to uint8_t wraps to 0.

Concept Snapshot

Fixed-width integers store unsigned numbers with exact bit sizes.
uint8_t holds 0-255 (8 bits), uint16_t holds 0-65535 (16 bits), uint32_t holds 0-4294967295 (32 bits).
Assigning values outside these ranges causes overflow and wraps around modulo 2^bits.
Use these types in embedded C to control memory and ensure predictable behavior.

Full Transcript

This visual execution shows how fixed-width unsigned integers work in embedded C. We start by choosing the integer type (uint8_t, uint16_t, uint32_t) and assign values. Each type has a range based on its bit size. For example, uint8_t can hold values from 0 to 255. If we assign a value within this range, it stores correctly. If the value is too large, like 256 for uint8_t, it overflows and wraps around to 0. Similarly, uint16_t can hold up to 65535, but assigning 70000 causes wrap-around to 4464. This behavior is important to understand to avoid bugs in embedded programming. The execution table tracks each step, showing variable values and whether they fit in the type. The variable tracker summarizes how values change after each assignment. Key moments clarify common confusions about overflow and range checking. The quiz tests understanding of these concepts by referencing the execution steps. Remember, fixed-width integers help control memory and ensure your program behaves predictably on embedded devices.

Practice

1. What is the size in bits of the uint16_t type in embedded C?

easy

A. 64 bits

B. 8 bits

C. 32 bits

D. 16 bits

Solution

1. Step 1: Understand the meaning of uint16_t

   The suffix 16_t means it uses 16 bits to store the number.

2. Step 2: Confirm the size

   By definition, uint16_t is an unsigned integer type that uses exactly 16 bits.

3. Final Answer:

   16 bits -> Option D

4. Quick Check:

   uint16_t = 16 bits [OK]

Hint: Look at the number in the type name for bit size [OK]

Common Mistakes:

• Confusing uint16_t with uint8_t
• Thinking it stores 16 bytes instead of bits
• Mixing signed and unsigned types

2. Which of the following is the correct way to declare a 32-bit unsigned integer variable named count?

easy

A. int32_t count;

B. uint32_t count;

C. uint16_t count;

D. int count32;

Solution

1. Step 1: Identify the correct type for 32-bit unsigned integer

   uint32_t is the standard fixed-width unsigned 32-bit integer type.

2. Step 2: Check the variable declaration syntax

   The syntax uint32_t count; correctly declares the variable count with that type.

3. Final Answer:

   uint32_t count; -> Option B

4. Quick Check:

   32-bit unsigned integer declaration = uint32_t count; [OK]

Hint: Use uint32_t for 32-bit unsigned integers [OK]

Common Mistakes:

• Using signed type int32_t instead of unsigned
• Using wrong bit size like uint16_t
• Incorrect variable naming or syntax

3. What will be the output of this code snippet?

#include 
#include 

int main() {
    uint8_t a = 250;
    uint8_t b = 10;
    uint8_t c = a + b;
    printf("%u", c);
    return 0;
}

medium

A. 260

B. Overflow error

C. 4

D. 10

Solution

1. Step 1: Understand the variable types and values

   a and b are uint8_t, which can hold values 0-255. a=250, b=10.

2. Step 2: Calculate the sum and consider overflow

   Sum is 250 + 10 = 260. Since uint8_t max is 255, it wraps around modulo 256: 260 - 256 = 4.

3. Final Answer:

   4 -> Option C

4. Quick Check:

   260 mod 256 = 4 [OK]

Hint: Remember 8-bit max is 255; sums wrap around modulo 256 [OK]

Common Mistakes:

• Expecting 260 as output ignoring overflow
• Thinking it causes runtime error
• Confusing signed and unsigned overflow behavior

4. Identify the error in this code snippet:

#include 

uint8_t x = 300;

medium

A. 300 is too large for uint8_t and causes overflow

B. Missing semicolon after declaration

C. uint8_t cannot be used without stdint.h

D. Variable name x is invalid

Solution

1. Step 1: Check the value assigned to uint8_t

   uint8_t can only hold values 0 to 255. 300 is outside this range.

2. Step 2: Understand the effect of assigning 300

   Assigning 300 causes overflow and the stored value wraps modulo 256, resulting in 44 (300 - 256).

3. Final Answer:

   300 is too large for uint8_t and causes overflow -> Option A

4. Quick Check:

   Value 300 > max 255 for uint8_t [OK]

Hint: Check if assigned value fits in the type's bit size [OK]

Common Mistakes:

• Assuming compiler error instead of overflow
• Ignoring the max value limit of uint8_t
• Thinking variable name or syntax is wrong

5. You want to store the number 70000 in a fixed-width unsigned integer variable. Which type should you choose to avoid overflow?

hard

A. uint32_t

B. uint16_t

C. uint8_t

D. int16_t

Solution

1. Step 1: Check the value range of each type

   uint8_t max is 255, uint16_t max is 65535, uint32_t max is 4294967295, int16_t max is 32767.

2. Step 2: Find the type that can hold 70000

   70000 is greater than 65535 and 32767, so only uint32_t can hold it without overflow.

3. Final Answer:

   uint32_t -> Option A

4. Quick Check:

   70000 <= 4294967295 of uint32_t [OK]

Hint: Pick type with max value ≥ your number to avoid overflow [OK]

Common Mistakes:

• Choosing uint16_t which is too small
• Using signed types that have smaller max positive values
• Ignoring overflow limits