Problem: GPIO State Enum. Solve this hands-on electronics task on EWskills.

#include <iostream> #include <cstdint> enum class PinState : uint8_t { Low, High }; const char* toString(PinState s) { switch (s) { case PinState::Low: return "LOW"; case PinState::High: return "HIGH"; } return "LOW"; // defensive fallback } int main() { int x; std::cin >> x; PinState s = (x == 0) ? PinState::Low : PinState::High; std::cout << toString(s); return 0; } Explanation & Logic Summary: enum class enforces strong typing and scoped names ( PinState::Low ). uint8_t matches typical GPIO register widths in embedded systems. toString centralizes conversion for logging or debug output. Firmware Relevance & Real Embedded Meaning: Eliminates magic numbers in GPIO state handling. Encourages type-safe APIs for hardware abstraction layers. Demonstrates efficient enum sizing aligned with hardware registers.

56. GPIO State Enum

Your task is to declare a scoped enum class named PinState representing the logic level of a GPIO pin.

Requirements:

The enum class must have the values:
- Low
- High
The enum class must use uint8_t as its underlying type.
Implement a function:
```
const char* toString(PinState s)
```
which returns:
- "LOW" for PinState::Low
- "HIGH" for PinState::High

The program will:

Read an integer input x
x is guaranteed to be either 0 or 1
Map:
- 0 → PinState::Low
- 1 → PinState::High
Print the corresponding string representation

No other input values will be provided.

Input / Output Specification
Input:
A single integer x where:

x == 0 represents a LOW GPIO state
x == 1 represents a HIGH GPIO state

Output:
Print exactly one of the following strings (no newline required):

LOW
HIGH

Example 1
Input:

Output:

LOW

Example 2

Input:

Output:

HIGH

Need Help? Refer to the Quick Guide below

In C, a standard enum is essentially a set of named integers. These names leak into the global scope (causing naming collisions) and implicitly convert to int (causing logical bugs).

In C++, enum class (also called a Scoped Enum) solves these issues.

Scoped: Enum values are local to the enum (accessed via EnumName::Value).
Strongly Typed: They do not implicitly convert to integer.
Fixed Size: You can explicitly define the underlying integer type (e.g., uint8_t) to save memory.

Syntax & Usage

1. Basic Declaration

// C-Style (Unsafe)
enum Color { RED, GREEN, BLUE }; 
// int x = RED; // ✅ Valid but dangerous

// C++ Style (Safe)
enum class Status { 
    OK, 
    ERROR, 
    BUSY 
};

// Status s = OK;          // ❌ Error: Unknown identifier 'OK'
Status s = Status::OK;     // ✅ Correct

2. Specifying Underlying Type (Crucial for Embedded)

You can force the enum to use a specific integer size instead of the compiler default (usually int / 4 bytes).

// Force use of 8-bit integer (1 byte)
enum class State : uint8_t {
    IDLE = 0,
    RUNNING = 1,
    FAULT = 2
};

// sizeof(State) is now guaranteed to be 1 byte.

Comparison: Old vs New

Feature	C-Style enum	C++ enum class
Scope	Leaks names to surrounding scope.	Namespaces names (`Enum::Value`).
Type Safety	Implicitly converts to `int`.	No implicit conversion.
Comparison	Can compare different enums (`COLOR_RED == STATE_OFF`).	Compile Error (Safe).
Size	Implementation defined (usually `int`).	User defined (default `int`).

Relevance in Embedded/Firmware

1. Saving RAM & Flash

By defining enum class State : uint8_t, you ensure that variables of this type only consume 1 byte. Standard enums often default to 32-bit (4 bytes), wasting memory in struct layouts or arrays.

2. Preventing State Machine Bugs

In C, if you have enum Motor { OFF, ON } and enum LED { OFF, ON }, the compiler errors because OFF is defined twice.

With enum class Motor and enum class LED, Motor::OFF and LED::OFF are distinct. You can never accidentally assign a Motor state to an LED variable.

3. Switch-Case Safety

Modern compilers can warn you if a switch statement on an enum class does not handle all possible cases, ensuring you don't miss a new state added later.

Common Pitfalls (Practical Tips)

Pitfall	Details
❌ Implicit Int Casting	`int x = State::IDLE;` fails. You must use explicit casting: `int x = static_cast<int>(State::IDLE);`
❌ Bitwise Flags	`enum class` does not support `
✅ Usage Rule	Use `enum class` for distinct states (State Machines, Error Codes). Use old `enum` or `namespace` constants for bitmasks.
✅ Validating Inputs	Just because it's an enum class doesn't mean the value is valid. `State s = static_cast<State>(99);` is valid code but undefined logic. Always validate raw data before casting to an enum.