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

Introduction

Signed and unsigned numbers store values differently. Knowing their behavior helps avoid mistakes when working with small 8-bit microcontrollers.

When reading sensor data that can be negative or positive.

When counting items that can never be negative, like button presses.

When performing arithmetic that might overflow or wrap around.

When optimizing memory on small devices by choosing the right number type.

Syntax

Embedded C

signed char a;  // can hold -128 to 127
unsigned char b;  // can hold 0 to 255

signed char stores negative and positive numbers.

unsigned char stores only zero and positive numbers.

Examples

Here, a can hold negative value -10, b holds positive 250.

Embedded C

signed char a = -10;
unsigned char b = 250;

Assigning values outside the range causes overflow and unexpected results.

Embedded C

signed char a = 130;  // Overflow example
unsigned char b = 260; // Overflow example

Converting negative signed value to unsigned wraps around to a large positive number.

Embedded C

signed char a = -1;
unsigned char b = (unsigned char)a;
// b becomes 255 due to wrap-around

Sample Program

This program shows how signed and unsigned 8-bit values behave and convert between each other on an 8-bit MCU.

Embedded C

#include <stdio.h>

int main() {
    signed char s = -1;
    unsigned char u = 255;

    printf("Signed s = %d\n", s);
    printf("Unsigned u = %u\n", u);

    unsigned char converted = (unsigned char)s;
    signed char converted_back = (signed char)u;

    printf("Converted signed -1 to unsigned: %u\n", converted);
    printf("Converted unsigned 255 to signed: %d\n", converted_back);

    return 0;
}

Important Notes

On 8-bit MCUs, char is usually 8 bits, so ranges are limited.

Unsigned types wrap around from max to 0, signed types wrap from max positive to min negative.

Be careful when mixing signed and unsigned in calculations to avoid bugs.

Summary

Signed types store negative and positive numbers; unsigned store only positive.

8-bit signed char ranges from -128 to 127; unsigned char from 0 to 255.

Conversions between signed and unsigned can cause wrap-around effects.

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