Fixed-width integers (uint8_t, uint16_t, uint32_t) in Embedded C - Mini Project: Build & Apply

Working with Fixed-Width Integers in Embedded C

📖 Scenario: You are programming a small embedded device that reads sensor values and stores them in variables with exact sizes to save memory and ensure correct data handling.

🎯 Goal: You will create variables using fixed-width integer types uint8_t, uint16_t, and uint32_t, assign values to them, and then print their values to verify correct usage.

📋 What You'll Learn

Create variables with types uint8_t, uint16_t, and uint32_t

Assign specific values to each variable

Use a helper variable to hold a maximum value for uint8_t

Print the values of all variables

💡 Why This Matters

🌍 Real World

Embedded systems often have limited memory and require exact control over data sizes to optimize performance and storage.

💼 Career

Understanding fixed-width integers is essential for embedded software developers, firmware engineers, and anyone working close to hardware.

1

Create fixed-width integer variables

Create three variables: sensor1 of type uint8_t with value 100, sensor2 of type uint16_t with value 30000, and sensor3 of type uint32_t with value 1000000.

Embedded C

#include 
#include 

int main() {

    // Create sensor1, sensor2, sensor3 variables here

    return 0;
}

Hint

Use the exact types uint8_t, uint16_t, and uint32_t and assign the values exactly as given.

2

Add a maximum value variable for uint8_t

Create a variable called max_uint8 of type uint8_t and assign it the value 255, which is the maximum value for an 8-bit unsigned integer.

Embedded C

#include 
#include 

int main() {
    uint8_t sensor1 = 100;
    uint16_t sensor2 = 30000;
    uint32_t sensor3 = 1000000;

    // Create max_uint8 variable here

    return 0;
}

Hint

Remember that uint8_t can hold values from 0 to 255.

3

Print all variable values

Use printf to print the values of sensor1, sensor2, sensor3, and max_uint8. Use the format specifiers %u for all since they are unsigned integers.

Embedded C

#include 
#include 

int main() {
    uint8_t sensor1 = 100;
    uint16_t sensor2 = 30000;
    uint32_t sensor3 = 1000000;

    uint8_t max_uint8 = 255;

    // Print values here

    return 0;
}

Hint

Use printf with %u to print unsigned integers and include newline \n for readability.

4

Run the program and check output

Run the program and ensure the output exactly matches:
sensor1 = 100
sensor2 = 30000
sensor3 = 1000000
max_uint8 = 255

Embedded C

#include 
#include 

int main() {
    uint8_t sensor1 = 100;
    uint16_t sensor2 = 30000;
    uint32_t sensor3 = 1000000;

    uint8_t max_uint8 = 255;

    printf("sensor1 = %u\n", sensor1);
    printf("sensor2 = %u\n", sensor2);
    printf("sensor3 = %u\n", sensor3);
    printf("max_uint8 = %u\n", max_uint8);

    // Run and check output

    return 0;
}

Hint

Make sure your program prints exactly the values with the labels and new lines as shown.

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