Signed vs unsigned behavior on 8-bit MCU in Embedded C - Hands-On Comparison

Signed vs unsigned behavior on 8-bit MCU

📖 Scenario: You are working with an 8-bit microcontroller unit (MCU) that handles small numbers in registers. Understanding how signed and unsigned numbers behave is important for correct calculations and avoiding errors.

🎯 Goal: You will create two 8-bit variables: one signed and one unsigned. You will assign values to them, perform arithmetic, and observe how the MCU treats these numbers differently.

📋 What You'll Learn

Create an 8-bit signed variable called signed_val with the value -10.

Create an 8-bit unsigned variable called unsigned_val with the value 250.

Create a variable called result to store the sum of signed_val and unsigned_val.

Print the value of result as an integer.

💡 Why This Matters

🌍 Real World

Embedded systems often use 8-bit MCUs for small devices like sensors, toys, and simple controllers. Understanding signed vs unsigned helps avoid bugs in calculations.

💼 Career

Embedded software engineers must know how data types affect arithmetic and memory on MCUs to write reliable and efficient code.

1

Create signed and unsigned 8-bit variables

Create an 8-bit signed variable called signed_val and set it to -10. Also create an 8-bit unsigned variable called unsigned_val and set it to 250.

Embedded C

// Your code here

Hint

Use int8_t for signed 8-bit and uint8_t for unsigned 8-bit variables.

2

Create a variable to store the sum

Create an int16_t variable called result to store the sum of signed_val and unsigned_val.

Embedded C

#include 
#include 

int main() {
    int8_t signed_val = -10;
    uint8_t unsigned_val = 250;
    // Create result variable here
    // Your code here
    return 0;
}

Hint

Use int16_t to hold the sum because it can store values larger than 8 bits.

3

Calculate the sum of signed and unsigned values

Assign to result the sum of signed_val and unsigned_val using the expression signed_val + unsigned_val.

Embedded C

#include 
#include 

int main() {
    int8_t signed_val = -10;
    uint8_t unsigned_val = 250;
    int16_t result = 0;
    // Calculate sum here
    // Your code here
    return 0;
}

Hint

Use the plus operator + to add the two variables and assign to result.

4

Print the result

Use printf to print the value of result as a signed integer with the format specifier %d.

Embedded C

#include 
#include 

int main() {
    int8_t signed_val = -10;
    uint8_t unsigned_val = 250;
    int16_t result = signed_val + unsigned_val;
    // Print result here
    // Your code here
    return 0;
}

Hint

Use printf("%d\n", result); to print the integer value followed by a new line.

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