Problem: GPIO Pin Class. Solve this hands-on electronics task on EWskills.

#include <iostream> using namespace std; class GpioPin { public: int pinNumber; int state; // Default constructor GpioPin() { state = 0; // LOW } void write(int value) { state = value; } int read() { return state; } }; int main() { int pin, initialValue, finalValue; cin >> pin >> initialValue >> finalValue; GpioPin gpio; gpio.pinNumber = pin; gpio.write(initialValue); gpio.write(finalValue); cout << "GPIO Pin " << gpio.pinNumber << " State " << gpio.read(); return 0; } Explanation & Logic Summary: A class groups related variables and functions Object is created using a default constructor Pin number is assigned manually Functions update and return the pin state Output formatting demonstrates combining data and text Firmware Relevance & Real-World Context: Mimics how GPIO information is logged or printed in firmware debugging Reinforces structured data usage before introducing OOP concepts Ideal as the first class-based exercise in embedded C++ learning

84. GPIO Pin Class

Define a simple C++ class named GpioPin.

Class Requirements:

The class should contain:

An integer variable to store the pin number
An integer variable to store the pin state
- 0 represents LOW
- 1 represents HIGH

Constructor Requirements:

Provide a default constructor only
The default constructor must initialize:
- Pin state to 0 (LOW)
Pin number will be assigned manually after object creation

Member Functions:

void write(int value)
- Sets the pin state
- The value will always be 0 or 1
int read()
- Returns the current pin state

In main() Function:

Read three integers from standard input:
- pin
- initialValue
- finalValue
Create a GpioPin object using the default constructor
Assign the pin number directly to the object
Call write(initialValue)
Call write(finalValue)
Print the output in the required format using read()

Input Format:

pin
initialValue
finalValue

pin is a non-negative integer
initialValue and finalValue are always 0 or 1

Output Format:

GPIO Pin <pin number> State <pin state>

Output must match the format exactly
Single line output
No extra spaces or newlines

Example Input:

13
0
1

Example Output:

GPIO Pin 13 State 1

Constraints:

Use only a basic class with variables and functions
Do not use constructor parameters
Do not use advanced OOP concepts
No input validation is required
Output must match exactly

Need Help? Refer to the Quick Guide below

In C, we use struct to bundle data together. However, the data is completely open—anyone can modify any field at any time, often leading to bugs (e.g., changing a buffer index without checking bounds).

In C++, a Class is an extension of a struct that adds Encapsulation. It bundles data (variables) and logic (functions) together, and uses Access Specifiers (private, public) to control who can see or touch that data.

Note: In C++, the only technical difference between a struct and a class is that members are public by default in a struct, and private by default in a class.

Syntax & Usage

1. Basic Declaration

Grouping hardware register definitions and the functions that use them into a single unit.

class Motor {
private:
    // Only functions inside this class can access these variables.
    // This protects the hardware state from accidental corruption.
    int pwm_pin;
    int speed; 

public:
    // The "Public API" - The rest of the code uses these functions.
    
    // Constructor (Initializes the object)
    Motor(int pin) {
        pwm_pin = pin;
        speed = 0;
        // Hardware init logic...
    }

    void setSpeed(int s) {
        if (s > 100) s = 100; // Safety check (Invariant)
        if (s < 0) s = 0;
        speed = s;
        // Apply to hardware...
    }
};

2. Usage

int main() {
    Motor m1(9);      // Create object 'm1' on pin 9

    m1.setSpeed(50);  // ✅ OK: Accessing public function
    
    // m1.speed = 200; // ❌ Error: 'speed' is private
}

Struct vs. Class (Memory Layout)

Feature	C struct	C++ class
Data Access	Public (Open to everyone).	Controlled (`private`/`public`).
Logic	Functions are separate.	Functions are members.
Memory	Sum of members (+ padding).	Identical (Sum of members + padding).
Overhead	None.	Zero (unless Virtual Functions are used).

Relevance in Embedded/Firmware

1. Hardware Driver Encapsulation

This is the most important use case. You can hide the ugly, complex hardware register pointers inside the private section.

The Application Developer (User) just sees uart.init() and uart.send(). They don't need to know (and shouldn't touch) the UART->CR1 register directly.

2. Maintaining Invariants

An Invariant is a rule that must always be true (e.g., "Buffer index must never exceed 64").

If you use a C struct, a user can write buf.index = 100; and crash the system.

With a C++ class, you make index private. The user must call buf.advance(), which internally checks if (index < 64). This guarantees the system acts predictably.

3. Multiple Instances

In C, writing a driver that supports 3 UARTs often requires passing a context pointer (UART_Handle_t*) to every function.

In C++, you simply create 3 objects: UART u1, u2, u3;. The compiler handles the context (this pointer) automatically, making code cleaner.

Common Pitfalls (Practical Tips)

Pitfall	Details
❌ The "Size" Myth	Beginners fear classes use more RAM. A class with two `int`s takes exactly 8 bytes, just like a struct with two `int`s. There is no hidden metadata unless you use `virtual` functions.
❌ Getters/Setters Bloat	Don't blindly make everything private and add `getX()`/`setX()` for every variable. That defeats the purpose. Only expose what the user needs to do their job.
❌ Public Data	Avoid public member variables (e.g., `public: int data;`). If the user writes `obj.data = 0;`, your class doesn't know it changed, so it can't update dependent hardware states.
✅ Structs for Data	Use `struct` for simple data containers (like a data packet or coordinate) where all fields are effectively public. Use `class` for objects that do things (Drivers, Managers).