69. PWM Constructor Modes

#include <iostream>
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