PWM Constructor Modes

Question

Problem: PWM Constructor Modes. Solve this hands-on electronics task on EWskills.

Accepted Answer

#include 
using namespace std;

class PWMController {
private:
    int frequency;
    int duty;
    bool enabled;

public:
    // Basic initialization constructor
    PWMController(int freq)
        : frequency(freq), duty(0), enabled(false) {}

    // Full initialization constructor
    PWMController(int freq, int dutyCycle)
        : frequency(freq), enabled(true)
    {
        if (dutyCycle < 0)
            duty = 0;
        else if (dutyCycle > 100)
            duty = 100;
        else
            duty = dutyCycle;
    }

    void setDuty(int d) {
        if (d < 0)
            duty = 0;
        else if (d > 100)
            duty = 100;
        else
            duty = d;
    }

    void disable() {
        enabled = false;
    }

    void print() {
        cout << "F=" << frequency
             << " D=" << duty
             << " EN=" << (enabled ? 1 : 0);
    }
};

int main() {
    int mode;
    cin >> mode;

    PWMController pwm(0);

    if (mode == 1) {
        int f;
        cin >> f;
        pwm = PWMController(f);
    }
    else {
        int f, d;
        cin >> f >> d;
        pwm = PWMController(f, d);
    }

    int x;
    cin >> x;

    if (x == -1)
        pwm.disable();
    else
        pwm.setDuty(x);

    pwm.print();
    return 0;
}

Explanation & Logic Summary

Constructor overloading enables multiple initialization paths
Duty cycle values are always clamped for safety
Enabled state reflects real PWM peripheral behavior
The design mirrors common embedded PWM driver APIs

Firmware Relevance & Real-World Context

PWM peripherals often support inactive and active initialization modes
Safe duty clamping prevents invalid hardware configurations
Reinforces constructor usage patterns common in embedded drivers

95. PWM Constructor Modes