Fixed-width integers (uint8_t, uint16_t, uint32_t) in Embedded C - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an 8-bit unsigned integer variable named value.

Embedded C

uint[1]_t value = 100;

Drag options to blanks, or click blank then click option'

A8

B16

C32

D64

Attempts:

3 left

💡 Hint

Common Mistakes

Using a larger integer type than needed.

Confusing signed and unsigned types.

The uint8_t type is an 8-bit unsigned integer, perfect for small values.

2fill in blank

medium

Complete the code to declare a 16-bit unsigned integer named counter.

Embedded C

uint[1]_t counter = 5000;

Drag options to blanks, or click blank then click option'

A8

B32

C16

D64

Attempts:

3 left

💡 Hint

Common Mistakes

Using uint8_t which is too small for 5000.

Using signed integer types by mistake.

The uint16_t type is a 16-bit unsigned integer, suitable for values up to 65535.

3fill in blank

hard

Fix the error in the code by choosing the correct fixed-width integer type for largeNumber.

Embedded C

uint[1]_t largeNumber = 3000000000;

Drag options to blanks, or click blank then click option'

A32

B16

C8

D64

Attempts:

3 left

💡 Hint

Common Mistakes

Using uint16_t which cannot hold 3000000000.

Using signed types that might cause overflow.

The value 3000000000 requires at least 32 bits to be stored without overflow, so uint64_t is correct.

4fill in blank

hard

Fill both blanks to declare a 32-bit unsigned integer maxValue and assign it the maximum value.

Embedded C

uint[1]_t maxValue = [2];

Drag options to blanks, or click blank then click option'

A32

B65535

C4294967295

D16

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning 65535 to a 32-bit integer instead of the max 32-bit value.

Using 16 instead of 32 for the type size.

uint32_t is a 32-bit unsigned integer, and its maximum value is 4294967295.

5fill in blank

hard

Fill all three blanks to declare a 16-bit unsigned integer threshold, assign it 1000, and check if it is less than 2000.

Embedded C

uint[1]_t threshold = [2];
if (threshold [3] 2000) {
    // do something
}

Drag options to blanks, or click blank then click option'

A8

B1000

C<

D16

Attempts:

3 left

💡 Hint

Common Mistakes

Using 8-bit type which might be too small.

Using wrong comparison operators like > or ==.

uint16_t is used for 16-bit unsigned integers, 1000 is assigned, and the less than operator < checks the condition.

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