Signed vs unsigned behavior on 8-bit MCU in Embedded C - When to Use Which

The Big Idea

What if a tiny mistake in number type could crash your whole device without warning?

The Scenario

Imagine you are programming a small 8-bit microcontroller to read sensor values and control a device. You try to store numbers in a variable but sometimes get strange results when the values go below zero or above 255.

The Problem

Using only one type of number without understanding signed or unsigned causes bugs. Negative numbers might wrap around to large positive values, or calculations give wrong results. Debugging these errors by guessing is slow and frustrating.

The Solution

Knowing the difference between signed and unsigned numbers helps you pick the right variable type. This avoids unexpected wrap-around and makes your program behave correctly and predictably on the 8-bit MCU.

Before vs After

✗ Before

uint8_t x = 250; x = x + 10; // x becomes 4 (wraps around)

✓ After

int8_t x = 110; x = x + 10; // x becomes 120 (correct signed addition)

What It Enables

Understanding signed vs unsigned lets you write reliable code that handles all number ranges correctly on limited 8-bit hardware.

Real Life Example

When reading temperature sensors that can go below zero, using signed variables prevents wrong readings and keeps your device safe and accurate.

Key Takeaways

Signed and unsigned types store numbers differently on 8-bit MCUs.

Choosing the right type prevents bugs from number wrap-around.

This knowledge makes embedded programs more reliable and easier to debug.

Practice

1. What is the range of values for an 8-bit signed char on a typical MCU?

easy

A. -128 to 127

B. 0 to 255

C. -256 to 255

D. -127 to 128

Solution

1. Step 1: Understand 8-bit signed char range

   An 8-bit signed char uses one bit for sign and 7 bits for value, so it can represent values from -128 to 127.

2. Step 2: Compare with options

   Only -128 to 127 matches the correct range for signed 8-bit char.

3. Final Answer:

   -128 to 127 -> Option A

4. Quick Check:

   Signed 8-bit char range = -128 to 127 [OK]

Hint: Signed 8-bit char always includes negative half [OK]

Common Mistakes:

• Confusing signed and unsigned ranges
• Assuming 8-bit signed char goes to 255
• Mixing up sign bit usage

2. Which of the following declarations correctly defines an unsigned 8-bit variable in embedded C?

easy

A. signed char var;

B. int8_t var;

C. char unsigned var;

D. unsigned char var;

Solution

1. Step 1: Identify unsigned 8-bit type syntax

   In embedded C, unsigned char is the standard way to declare an unsigned 8-bit variable.

2. Step 2: Check other options

   signed char var; is signed, char unsigned var; is invalid syntax, int8_t var; is signed 8-bit integer.

3. Final Answer:

   unsigned char var; -> Option D

4. Quick Check:

   Unsigned 8-bit variable = unsigned char [OK]

Hint: Use 'unsigned char' for unsigned 8-bit variables [OK]

Common Mistakes:

• Using 'char unsigned' which is invalid syntax
• Assuming 'int8_t' is unsigned
• Confusing signed and unsigned keywords

3. Consider this code snippet on an 8-bit MCU:

unsigned char a = 250;
signed char b = (signed char)a;
printf("%d", b);

What is the output?

medium

A. 250

B. -6

C. 6

D. -250

Solution

1. Step 1: Understand casting from unsigned to signed

   Variable a holds 250 (unsigned). Casting to signed char wraps around because signed char max is 127.

2. Step 2: Calculate signed char value

   250 - 256 = -6 (wrap-around in 8-bit signed range)

3. Final Answer:

   -6 -> Option B

4. Quick Check:

   Unsigned 250 cast to signed 8-bit = -6 [OK]

Hint: Subtract 256 if unsigned > 127 when casting to signed [OK]

Common Mistakes:

• Assuming cast keeps original unsigned value
• Confusing sign extension with wrap-around
• Ignoring 8-bit overflow behavior

4. This code runs on an 8-bit MCU:

unsigned char x = 200;
signed char y = -100;
unsigned char z = x + y;
printf("%u", z);

What is the output?

medium

A. 156

B. 44

C. 100

D. 300

Solution

1. Step 1: Understand integer promotion in addition

   In expressions, unsigned char and signed char are promoted to int before addition.

2. Step 2: Calculate the sum

   200 + (-100) = 100 as int, but when assigned to unsigned char (8-bit), it wraps modulo 256. Since 100 fits in 8 bits, the value is 100.

3. Step 3: Print the result

   printf with %u prints unsigned int, so output is 100.

4. Final Answer:

   100 -> Option C

5. Quick Check:

   Signed promoted to int before addition, result 100 [OK]

Hint: Signed promoted to int before addition, watch final cast [OK]

Common Mistakes:

• Adding raw unsigned and signed bytes without promotion
• Assuming overflow without checking promotion
• Misinterpreting printf format specifiers

5. On an 8-bit MCU, you want to store the result of subtracting 150 from 100 using unsigned 8-bit variables:

unsigned char a = 100;
unsigned char b = 150;
unsigned char c = a - b;
printf("%u", c);

What will be printed and why?

hard

A. 206 because unsigned subtraction wraps around modulo 256

B. -50 because subtraction keeps sign in unsigned

C. 50 because it calculates absolute difference

D. Error due to negative result in unsigned

Solution

1. Step 1: Understand unsigned subtraction wrap-around

   Unsigned 8-bit subtraction wraps modulo 256. 100 - 150 = -50, which wraps to 256 - 50 = 206.

2. Step 2: Confirm printf output

   Variable c holds 206, so printf with %u prints 206.

3. Final Answer:

   206 because unsigned subtraction wraps around modulo 256 -> Option A

4. Quick Check:

   Unsigned subtraction wraps modulo 256 = 206 [OK]

Hint: Unsigned subtraction wraps modulo 256 on 8-bit MCU [OK]

Common Mistakes:

• Expecting negative numbers in unsigned arithmetic
• Assuming error on negative result
• Thinking subtraction gives absolute difference