meshx::MeshXGpioImpl Class Reference

Concrete GPIO Implementation Class. More...

Inheritance diagram for meshx::MeshXGpioImpl:

Public Member Functions
	MeshXGpioImpl (uint8_t logical_pin, const char *name, GpioMode mode)
	Constructor.
virtual	~MeshXGpioImpl ()
	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).
virtual int	setPwmDutyCycle (uint8_t duty_cycle) override
	Set PWM duty cycle (convenience method).
virtual int	setPwmFrequency (uint32_t frequency) override
	Set PWM frequency (convenience method).
virtual int	registerInterrupt (void(*callback)(uint8_t, void *), void *user_data, uint8_t trigger_type) override
	Register interrupt (convenience method).
virtual int	unregisterInterrupt () override
	Unregister interrupt (convenience method).
virtual int	enableInterrupt (bool enable) override
	Enable/disable interrupt (convenience method).
Public Member Functions inherited from meshx::MeshXIoInterface
virtual	~MeshXIoInterface ()=default

Private Attributes
uint8_t	m_logical_pin
char	m_name [32]
GpioMode	m_mode
bool	m_initialized
void(*	m_intr_callback )(uint8_t, void *)
void *	m_intr_user_data

Friends
void	meshx_gpio_intr_cb_wrapper (uint8_t logical_pin, void *user_data)
	Static interrupt callback wrapper for C API.

Detailed Description

Concrete GPIO Implementation Class.

Constructor & Destructor Documentation

MeshXGpioImpl()

meshx::MeshXGpioImpl::MeshXGpioImpl ( uint8_t logical_pin, const char * name, GpioMode mode )

inline

Constructor.

Parameters

logical_pin	Logical pin number
name	Pin name
mode	GPIO mode

        : m_logical_pin(logical_pin), m_mode(mode), m_initialized(false),
          m_intr_callback(nullptr), m_intr_user_data(nullptr) {
        strncpy(m_name, name, sizeof(m_name) - 1);
        m_name[sizeof(m_name) - 1] = '\0';
    }

~MeshXGpioImpl()

virtual meshx::MeshXGpioImpl::~MeshXGpioImpl ( )

inlinevirtual

Destructor.

                             {
        // Cleanup if needed
    }

Member Function Documentation

enableInterrupt()

virtual int meshx::MeshXGpioImpl::enableInterrupt ( bool enable )

inlineoverridevirtual

Enable/disable interrupt (convenience method).

Parameters

enable

true to enable, false to disable

Returns

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

Reimplemented from meshx::MeshXIoInterface.

                                                      {
        std::vector<uint32_t> args = {static_cast<uint32_t>(enable)};
        return execute(IoFunction::ENABLE_INTERRUPT, args);
    }

execute()

virtual int meshx::MeshXGpioImpl::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 GPIO if not already initialized
            meshx_err_t err = meshx_gpio_init();
            if (err != MESHX_SUCCESS) {
                return static_cast<int>(IoError::NOT_INITIALIZED);
            }
            m_initialized = true;
        }
 
        switch (function) {
            case IoFunction::SET_LEVEL: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::INVALID_LEVEL);
                }
                uint8_t level = static_cast<uint8_t>(args[0]);
                if (level > 1) {
                    return static_cast<int>(IoError::INVALID_LEVEL);
                }
                meshx_err_t err = meshx_gpio_set_level(m_logical_pin, level);
                return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::INVALID_MODE);
            }
 
            case IoFunction::GET_LEVEL: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::INVALID_ARG);
                }
                uint8_t* level_ptr = reinterpret_cast<uint8_t*>(static_cast<uintptr_t>(args[0]));
                if (level_ptr == nullptr) {
                    return static_cast<int>(IoError::INVALID_ARG);
                }
                meshx_err_t err = meshx_gpio_get_level(m_logical_pin, level_ptr);
                return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::INVALID_MODE);
            }
 
            case IoFunction::TOGGLE: {
                meshx_err_t err = meshx_gpio_toggle(m_logical_pin);
                return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::INVALID_MODE);
            }
 
            case IoFunction::SET_PWM_DUTY: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::PWM_INVALID_PARAM);
                }
                // PWM functions should use meshx_pwm API or meshx_gpio_execute_function
                meshx_err_t err = meshx_gpio_execute_function(m_logical_pin, MESHX_IO_FUNCTION_SET_PWM_DUTY, &args[0], 1);
                return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::PWM_NOT_SUPPORTED);
            }
 
            case IoFunction::SET_PWM_FREQUENCY: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::PWM_INVALID_PARAM);
                }
                meshx_err_t err = meshx_gpio_execute_function(m_logical_pin, MESHX_IO_FUNCTION_SET_PWM_FREQUENCY, &args[0], 1);
                return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::PWM_NOT_SUPPORTED);
            }
 
            case IoFunction::REGISTER_INTERRUPT: {
                if (args.size() < 3) {
                    return static_cast<int>(IoError::INVALID_ARG);
                }
                void (*callback)(uint8_t, void*) = reinterpret_cast<void (*)(uint8_t, void*)>(static_cast<uintptr_t>(args[0]));
                void* user_data = reinterpret_cast<void*>(static_cast<uintptr_t>(args[1]));
                uint8_t trigger_type = static_cast<uint8_t>(args[2]);
                return registerInterrupt(callback, user_data, trigger_type);
            }
 
            case IoFunction::UNREGISTER_INTERRUPT: {
                meshx_err_t err = meshx_gpio_unregister_intr(m_logical_pin);
                return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::INTR_NOT_SUPPORTED);
            }
 
            case IoFunction::ENABLE_INTERRUPT: {
                if (args.size() < 1) {
                    return static_cast<int>(IoError::INVALID_ARG);
                }
                bool enable = static_cast<bool>(args[0]);
                meshx_err_t err = meshx_gpio_intr_enable(m_logical_pin, enable);
                return (err == MESHX_SUCCESS) ? 0 : 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);
        }
    }

getLevel()

virtual int meshx::MeshXGpioImpl::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.

                                                  {
        if (level == nullptr) {
            return static_cast<int>(IoError::INVALID_ARG);
        }
        // Note: This would need to call meshx_gpio_get_level directly
        // since execute() can't return the level value
        meshx_err_t err = meshx_gpio_get_level(m_logical_pin, level);
        return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::INVALID_MODE);
    }

getLogicalPin()

virtual uint8_t meshx::MeshXGpioImpl::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::MeshXGpioImpl::getName ( ) const

inlineoverridevirtual

Get pin name.

Returns

const char* Pin name

Implements meshx::MeshXIoInterface.

                                                 {
        return m_name;
    }

isFunctionSupported()

virtual bool meshx::MeshXGpioImpl::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:
                return (m_mode == GpioMode::OUTPUT ||
                        m_mode == GpioMode::INPUT_OUTPUT ||
                        m_mode == GpioMode::OPEN_DRAIN ||
                        m_mode == GpioMode::OPEN_DRAIN_INPUT_OUTPUT);
 
            case IoFunction::REGISTER_INTERRUPT:
            case IoFunction::UNREGISTER_INTERRUPT:
            case IoFunction::ENABLE_INTERRUPT:
                return (m_mode == GpioMode::INPUT ||
                        m_mode == GpioMode::INPUT_OUTPUT ||
                        m_mode == GpioMode::OPEN_DRAIN_INPUT_OUTPUT);
 
            case IoFunction::SET_PWM_DUTY:
            case IoFunction::SET_PWM_FREQUENCY:
                return (m_mode == GpioMode::PWM_OUTPUT);
 
            case IoFunction::CUSTOM_FUNCTION:
                // Custom functions are always supported for extensibility
                return true;
 
            default:
                return false;
        }
    }

registerInterrupt()

virtual int meshx::MeshXGpioImpl::registerInterrupt ( void(* callback )(uint8_t, void *), void * user_data, uint8_t trigger_type )

inlineoverridevirtual

Register interrupt (convenience method).

Parameters

callback	Function pointer to callback
user_data	User data passed to callback
trigger_type	Interrupt trigger type

Returns

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

Reimplemented from meshx::MeshXIoInterface.

                                                                 {
        // Convert trigger type to meshx_gpio_intr_type_t
        meshx_gpio_intr_type_t intr_type;
        switch (trigger_type) {
            case 1: intr_type = MESHX_GPIO_INTR_POSITIVE_EDGE; break;
            case 2: intr_type = MESHX_GPIO_INTR_NEGATIVE_EDGE; break;
            case 3: intr_type = MESHX_GPIO_INTR_ANY_EDGE; break;
            case 4: intr_type = MESHX_GPIO_INTR_LOW_LEVEL; break;
            case 5: intr_type = MESHX_GPIO_INTR_HIGH_LEVEL; break;
            default: return static_cast<int>(IoError::INVALID_ARG);
        }
 
        // Store the callback and user data for the wrapper
        m_intr_callback = callback;
        m_intr_user_data = user_data;
 
        // Use a static wrapper function that calls back with the logical pin
        meshx_err_t err = meshx_gpio_register_intr(m_logical_pin, intr_type,
                                                   meshx_gpio_intr_cb_wrapper, this);
        return (err == MESHX_SUCCESS) ? 0 : static_cast<int>(IoError::INTR_NOT_SUPPORTED);
    }

setLevel()

virtual int meshx::MeshXGpioImpl::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.

                                                 {
        std::vector<uint32_t> args = {static_cast<uint32_t>(level)};
        return execute(IoFunction::SET_LEVEL, args);
    }

setPwmDutyCycle()

virtual int meshx::MeshXGpioImpl::setPwmDutyCycle ( uint8_t duty_cycle )

inlineoverridevirtual

Set PWM duty cycle (convenience method).

Parameters

duty_cycle

Duty cycle (0-100%)

Returns

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

Reimplemented from meshx::MeshXIoInterface.

                                                             {
        std::vector<uint32_t> args = {static_cast<uint32_t>(duty_cycle)};
        return execute(IoFunction::SET_PWM_DUTY, args);
    }

setPwmFrequency()

virtual int meshx::MeshXGpioImpl::setPwmFrequency ( uint32_t frequency )

inlineoverridevirtual

Set PWM frequency (convenience method).

Parameters

frequency

Frequency in Hz

Returns

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

Reimplemented from meshx::MeshXIoInterface.

                                                             {
        std::vector<uint32_t> args = {frequency};
        return execute(IoFunction::SET_PWM_FREQUENCY, args);
    }

toggle()

virtual int meshx::MeshXGpioImpl::toggle ( )

inlineoverridevirtual

Toggle pin level (convenience method).

Returns

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

Reimplemented from meshx::MeshXIoInterface.

                                  {
        std::vector<uint32_t> args;  // No arguments needed for toggle
        return execute(IoFunction::TOGGLE, args);
    }

unregisterInterrupt()

virtual int meshx::MeshXGpioImpl::unregisterInterrupt ( )

inlineoverridevirtual

Unregister interrupt (convenience method).

Returns

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

Reimplemented from meshx::MeshXIoInterface.

                                               {
        std::vector<uint32_t> args;  // No arguments needed
        return execute(IoFunction::UNREGISTER_INTERRUPT, args);
    }

Friends And Related Symbol Documentation

meshx_gpio_intr_cb_wrapper

void meshx_gpio_intr_cb_wrapper ( uint8_t logical_pin, void * user_data )

friend

Static interrupt callback wrapper for C API.

Parameters

logical_pin	Logical pin number
user_data	User data (pointer to MeshXGpioImpl instance)

{
    MeshXGpioImpl* instance = static_cast<MeshXGpioImpl*>(user_data);
    if (instance != nullptr && instance->m_intr_callback != nullptr) {
        instance->m_intr_callback(logical_pin, instance->m_intr_user_data);
    }
}

Field Documentation

m_initialized

bool meshx::MeshXGpioImpl::m_initialized

private

Initialization flag

m_intr_callback

void(* meshx::MeshXGpioImpl::m_intr_callback) (uint8_t, void *)

private

Interrupt callback

m_intr_user_data

void* meshx::MeshXGpioImpl::m_intr_user_data

private

Interrupt user data

m_logical_pin

uint8_t meshx::MeshXGpioImpl::m_logical_pin

private

Logical pin number

m_mode

GpioMode meshx::MeshXGpioImpl::m_mode

private

GPIO mode

m_name

char meshx::MeshXGpioImpl::m_name[32]

private

Pin name

---

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

• meshx_gpio_impl.cpp