Clock-Dependent Peripheral Design

Question

Problem: Clock-Dependent Peripheral Design. Solve this hands-on electronics task on EWskills.

Accepted Answer

#include 
using namespace std;

class ClockController {
public:
    ClockController() {
        cout << "Clock enabled" << endl;
    }

    ~ClockController() {
        cout << "Clock disabled" << endl;
    }

    void write(int offset, int value) {
        cout << "Clocked write: " << offset << " " << value << endl;
    }
};

class Peripheral {
private:
    ClockController& clk;

public:
    Peripheral(ClockController& c) : clk(c) {
        cout << "Peripheral ready" << endl;
    }

    ~Peripheral() {
        cout << "Peripheral stopped" << endl;
    }

    void writeReg(int offset, int value) {
        clk.write(offset, value);
    }
};

class Driver {
private:
    ClockController clk;
    Peripheral periph;

public:
    Driver() : periph(clk) {
        cout << "Driver started" << endl;
    }

    void operate(int offset, int value) {
        periph.writeReg(offset, value);
    }

    ~Driver() {
        cout << "Driver stopped" << endl;
    }
};

int main() {
    int offset, value;
    cin >> offset >> value;

    {
        Driver drv;
        drv.operate(offset, value);
    }

    return 0;
}

Explanation & Logic Summary:

This problem demonstrates dependency-aware composition, where one component cannot function unless another component is already active.

The Driver owns the ClockController, making it responsible for enabling and disabling the clock.
The Peripheral does not own the clock; instead, it depends on an existing clock instance via a reference.

Because references:

Must be initialized at construction
Cannot be null
Cannot be reseated

the following guarantees are enforced:

The peripheral cannot exist without a clock
The clock must be created before the peripheral
The peripheral can never use an invalid clock

Constructor order guarantees safe startup:

Clock enabled
Peripheral ready
Driver started

Destructor order guarantees safe shutdown:

Driver stopped
Peripheral stopped
Clock disabled

Firmware Relevance & Real-World Context:

On real microcontrollers, peripherals such as UART, SPI, I2C, timers, and ADCs require their clocks to be enabled before any register access.

Violating this rule can cause:

Ignored writes
Bus faults
System lockups or resets

By encoding hardware dependencies directly into C++ class relationships:

Invalid states become impossible to express
Initialization and shutdown order is deterministic
Entire classes of low-level firmware bugs are eliminated

This makes dependency-aware composition a core embedded C++ design skill.

126. Clock-Dependent Peripheral Design