meshx::MeshXPwmImpl Class Reference

Concrete PWM Implementation Class. More...

Inheritance diagram for meshx::MeshXPwmImpl:

Public Member Functions
	MeshXPwmImpl (uint8_t logical_pin, const char *name)
	Constructor.
virtual	~MeshXPwmImpl ()
	Destructor.
virtual uint8_t	getLogicalPin () const override
	Get logical pin number.
virtual const char *	getName () const override
	Get pin name.
virtual bool	isFunctionSupported (IoFunction function) const override
	Check if function is supported.
virtual int	execute (IoFunction function, const std::vector< uint32_t > &args) override
	Execute IO function.
virtual int	setLevel (uint8_t level) override
	Set pin level (convenience method).
virtual int	getLevel (uint8_t *level) override
	Get pin level (convenience method).
virtual int	toggle () override
	Toggle pin level (convenience method).
int	start ()
	Start PWM output.
int	stop ()
	Stop PWM output.
bool	isStarted () const
	Check if PWM is started.
uint32_t	getFrequency () const
	Get current frequency.
uint8_t	getDutyCycle () const
	Get current duty cycle.
Public Member Functions inherited from meshx::MeshXIoInterface
virtual	~MeshXIoInterface ()=default
virtual int	setPwmDutyCycle (uint8_t duty_cycle)
	Set PWM duty cycle (convenience method).
virtual int	setPwmFrequency (uint32_t frequency)
	Set PWM frequency (convenience method).
virtual int	registerInterrupt (void(*callback)(uint8_t, void *), void *user_data, uint8_t trigger_type)
	Register interrupt (convenience method).
virtual int	unregisterInterrupt ()
	Unregister interrupt (convenience method).
virtual int	enableInterrupt (bool enable)
	Enable/disable interrupt (convenience method).

Private Attributes
uint8_t	m_logical_pin
char	m_name [32]
bool	m_initialized
bool	m_started
uint32_t	m_frequency
uint8_t	m_duty_cycle

Detailed Description

Concrete PWM Implementation Class.

Constructor & Destructor Documentation

MeshXPwmImpl()

meshx::MeshXPwmImpl::MeshXPwmImpl ( uint8_t logical_pin, const char * name )

inline

Constructor.

Parameters

logical_pin	Logical pin number
name	Pin name

        : m_logical_pin(logical_pin), m_initialized(false),
          m_started(false), m_frequency(1000), m_duty_cycle(50) {
        strncpy(m_name, name, sizeof(m_name) - 1);
        m_name[sizeof(m_name) - 1] = '\0';
    }

~MeshXPwmImpl()

virtual meshx::MeshXPwmImpl::~MeshXPwmImpl ( )

inlinevirtual

Destructor.

                            {
        if (m_started) {
            // Stop PWM if it's running
            meshx_pwm_stop(m_logical_pin);
        }
    }

Member Function Documentation

execute()

virtual int meshx::MeshXPwmImpl::execute ( IoFunction function, const std::vector< uint32_t > & args )

inlineoverridevirtual

Execute IO function.

Parameters

function	IO function to execute
args	Function arguments vector

Returns

int Error code (0 = success, negative = error)

Implements meshx::MeshXIoInterface.

                                                                                       {
        if (!m_initialized) {
            // Initialize PWM if not already initialized
            meshx_err_t err = meshx_pwm_init();
            if (err != MESHX_SUCCESS) {
                return static_cast<int>(IoError::NOT_INITIALIZED);
            }
            m_initialized = true;
        }
 
        switch (function) {
            case IoFunction::SET_PWM_DUTY: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::PWM_INVALID_PARAM);
                }
                uint8_t duty_cycle = static_cast<uint8_t>(args[0]);
                if (duty_cycle > 100) {
                    return static_cast<int>(IoError::PWM_INVALID_PARAM);
                }
 
                meshx_err_t err = meshx_pwm_set_duty_cycle(m_logical_pin, duty_cycle);
                if (err == MESHX_SUCCESS) {
                    m_duty_cycle = duty_cycle;
                    return 0;
                }
                return static_cast<int>(IoError::PWM_NOT_SUPPORTED);
            }
 
            case IoFunction::SET_PWM_FREQUENCY: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::PWM_INVALID_PARAM);
                }
                uint32_t frequency = args[0];
                if (frequency == 0 || frequency > 1000000) { // 1MHz max
                    return static_cast<int>(IoError::PWM_INVALID_PARAM);
                }
 
                meshx_err_t err = meshx_pwm_set_frequency(m_logical_pin, frequency);
                if (err == MESHX_SUCCESS) {
                    m_frequency = frequency;
                    return 0;
                }
                return static_cast<int>(IoError::PWM_NOT_SUPPORTED);
            }
 
            case IoFunction::SET_LEVEL:
            case IoFunction::GET_LEVEL:
            case IoFunction::TOGGLE:
                // PWM pins don't support direct level control
                return static_cast<int>(IoError::INVALID_MODE);
 
            case IoFunction::REGISTER_INTERRUPT:
            case IoFunction::UNREGISTER_INTERRUPT:
            case IoFunction::ENABLE_INTERRUPT:
                // PWM pins don't support interrupts
                return static_cast<int>(IoError::INTR_NOT_SUPPORTED);
 
            case IoFunction::CUSTOM_FUNCTION: {
                // Custom functions not implemented in this basic version
                return static_cast<int>(IoError::NOT_SUPPORTED);
            }
 
            default:
                return static_cast<int>(IoError::INVALID_MODE);
        }
    }

getDutyCycle()

uint8_t meshx::MeshXPwmImpl::getDutyCycle ( ) const

inline

Get current duty cycle.

Returns

uint8_t Current duty cycle (0-100%)

                                 {
        return m_duty_cycle;
    }

getFrequency()

uint32_t meshx::MeshXPwmImpl::getFrequency ( ) const

inline

Get current frequency.

Returns

uint32_t Current frequency in Hz

                                  {
        return m_frequency;
    }

getLevel()

virtual int meshx::MeshXPwmImpl::getLevel ( uint8_t * level )

inlineoverridevirtual

Get pin level (convenience method).

Parameters

[out]

level

Pointer to store pin level

Returns

int Error code (0 = success, negative = error)

Reimplemented from meshx::MeshXIoInterface.

                                                  {
        // PWM pins don't support direct level control
        return static_cast<int>(IoError::INVALID_MODE);
    }

getLogicalPin()

virtual uint8_t meshx::MeshXPwmImpl::getLogicalPin ( ) const

inlineoverridevirtual

Get logical pin number.

Returns

uint8_t Logical pin number

Implements meshx::MeshXIoInterface.

                                                   {
        return m_logical_pin;
    }

getName()

virtual const char * meshx::MeshXPwmImpl::getName ( ) const

inlineoverridevirtual

Get pin name.

Returns

const char* Pin name

Implements meshx::MeshXIoInterface.

                                                 {
        return m_name;
    }

isFunctionSupported()

virtual bool meshx::MeshXPwmImpl::isFunctionSupported ( IoFunction function ) const

inlineoverridevirtual

Check if function is supported.

Parameters

function

IO function to check

Returns

true if function is supported

false if function is not supported

Implements meshx::MeshXIoInterface.

                                                                         {
        switch (function) {
            case IoFunction::SET_LEVEL:
            case IoFunction::GET_LEVEL:
            case IoFunction::TOGGLE:
                // PWM pins don't support direct level control
                return false;
 
            case IoFunction::SET_PWM_DUTY:
            case IoFunction::SET_PWM_FREQUENCY:
                // PWM-specific functions
                return true;
 
            case IoFunction::REGISTER_INTERRUPT:
            case IoFunction::UNREGISTER_INTERRUPT:
            case IoFunction::ENABLE_INTERRUPT:
                // PWM pins don't support interrupts
                return false;
 
            case IoFunction::CUSTOM_FUNCTION:
                // Custom functions are always supported for extensibility
                return true;
 
            default:
                return false;
        }
    }

isStarted()

bool meshx::MeshXPwmImpl::isStarted ( ) const

inline

Check if PWM is started.

Returns

true if PWM is started

false if PWM is not started

                           {
        return m_started;
    }

setLevel()

virtual int meshx::MeshXPwmImpl::setLevel ( uint8_t level )

inlineoverridevirtual

Set pin level (convenience method).

Parameters

level

Pin level (0 = low, 1 = high)

Returns

int Error code (0 = success, negative = error)

Reimplemented from meshx::MeshXIoInterface.

                                                 {
        // PWM pins don't support direct level control
        return static_cast<int>(IoError::INVALID_MODE);
    }

start()

int meshx::MeshXPwmImpl::start ( )

inline

Start PWM output.

Returns

int Error code (0 = success, negative = error)

                {
        if (!m_initialized) {
            meshx_err_t err = meshx_pwm_init();
            if (err != MESHX_SUCCESS) {
                return static_cast<int>(IoError::NOT_INITIALIZED);
            }
            m_initialized = true;
        }
 
        meshx_err_t err = meshx_pwm_start(m_logical_pin);
        if (err == MESHX_SUCCESS) {
            m_started = true;
            return 0;
        }
        return static_cast<int>(IoError::PWM_NOT_SUPPORTED);
    }

stop()

int meshx::MeshXPwmImpl::stop ( )

inline

Stop PWM output.

Returns

int Error code (0 = success, negative = error)

               {
        if (!m_started) {
            return 0;  // Not an error if not started
        }
 
        meshx_err_t err = meshx_pwm_stop(m_logical_pin);
        if (err == MESHX_SUCCESS) {
            m_started = false;
            return 0;
        }
        return static_cast<int>(IoError::PWM_NOT_SUPPORTED);
    }

toggle()

virtual int meshx::MeshXPwmImpl::toggle ( )

inlineoverridevirtual

Toggle pin level (convenience method).

Returns

int Error code (0 = success, negative = error)

Reimplemented from meshx::MeshXIoInterface.

                                  {
        // PWM pins don't support direct level control
        return static_cast<int>(IoError::INVALID_MODE);
    }

Field Documentation

m_duty_cycle

uint8_t meshx::MeshXPwmImpl::m_duty_cycle

private

Current duty cycle

m_frequency

uint32_t meshx::MeshXPwmImpl::m_frequency

private

Current frequency

m_initialized

bool meshx::MeshXPwmImpl::m_initialized

private

Initialization flag

m_logical_pin

uint8_t meshx::MeshXPwmImpl::m_logical_pin

private

Logical pin number

m_name

char meshx::MeshXPwmImpl::m_name[32]

private

Pin name

m_started

bool meshx::MeshXPwmImpl::m_started

private

PWM started flag

---

The documentation for this class was generated from the following file:

• meshx_pwm_impl.cpp