meshx_io_bridge.cpp File Reference

MeshX IO Bridge Implementation. More...

#include "../interface/meshx_io_bridge.h"
#include "../inc/meshx_io_factory.hpp"
#include "../inc/meshx_io_interface.hpp"
#include "../inc/meshx_io_types.hpp"
#include <vector>
#include <memory>

Functions
meshx_io_handle_t	meshx_io_create (const meshx_io_config_t *config)
	Create IO instance from configuration.
void	meshx_io_destroy (meshx_io_handle_t handle)
	Destroy IO instance.
meshx_err_t	meshx_io_execute (meshx_io_handle_t handle, meshx_io_func_t function, const uint32_t *args, uint8_t arg_count)
	Execute IO function.
uint8_t	meshx_io_get_logical_pin (meshx_io_handle_t handle)
	Get logical pin number.
const char *	meshx_io_get_name (meshx_io_handle_t handle)
	Get pin name.
bool	meshx_io_is_function_supported (meshx_io_handle_t handle, meshx_io_func_t function)
	Check if function is supported.
meshx_err_t	meshx_io_set_level (meshx_io_handle_t handle, uint8_t level)
	Set pin level (convenience function).
meshx_err_t	meshx_io_get_level (meshx_io_handle_t handle, uint8_t *level)
	Get pin level (convenience function).
meshx_err_t	meshx_io_toggle (meshx_io_handle_t handle)
	Toggle pin level (convenience function).
meshx_err_t	meshx_io_init (void)
	Initialize IO subsystem.
meshx_err_t	meshx_io_deinit (void)
	Deinitialize IO subsystem.

Detailed Description

MeshX IO Bridge Implementation.

This file implements the C bridge for the C++ IO abstraction layer. It provides the glue between C applications and C++ IO instances.

Author

MeshX Team

Date

2024

Function Documentation

meshx_io_create()

meshx_io_handle_t meshx_io_create

(

const meshx_io_config_t *

config

)

Create IO instance from configuration.

Parameters

config

IO configuration

Returns

meshx_io_handle_t IO instance handle, NULL on failure

                                                                   {
    if (config == nullptr) {
        return nullptr;
    }
 
    IoConfig io_config;
    io_config.logical_pin = config->logical_pin;
    io_config.type = static_cast<IoType>(config->io_type);
    io_config.name = config->name ? config->name : "";
 
    // Copy configuration based on type
    if (io_config.type == IoType::GPIO) {
        io_config.config.gpio.mode = config->config.gpio.mode;
        io_config.config.gpio.pull = config->config.gpio.pull;
        io_config.config.gpio.drive = config->config.gpio.drive;
        io_config.config.gpio.initial_level = config->config.gpio.initial_level;
        io_config.config.gpio.signal_inversion = config->config.gpio.signal_inversion;
    } else if (io_config.type == IoType::PWM) {
        io_config.config.pwm.frequency = config->config.pwm.frequency;
        io_config.config.pwm.duty_cycle = config->config.pwm.duty_cycle;
        io_config.config.pwm.resolution = config->config.pwm.resolution;
        io_config.config.pwm.channel = config->config.pwm.channel;
    }
 
    auto instance = MeshXIoFactory::getInstance().create(io_config);
    if (!instance) {
        return nullptr;
    }
 
    // Return as raw pointer (opaque handle)
    return static_cast<meshx_io_handle_t>(instance.release());
}

meshx_io_deinit()

meshx_err_t meshx_io_deinit

(

void

)

Deinitialize IO subsystem.

Returns

meshx_err_t Error code

                                  {
    // No specific deinit needed for factory singleton
    return MESHX_SUCCESS;
}

meshx_io_destroy()

void meshx_io_destroy

(

meshx_io_handle_t

handle

)

Destroy IO instance.

Parameters

handle

IO instance handle

                                                {
    if (handle != nullptr) {
        delete static_cast<MeshXIoInterface*>(handle);
    }
}

meshx_io_execute()

meshx_err_t meshx_io_execute	(	meshx_io_handle_t	handle,
		meshx_io_func_t	function,
		const uint32_t *	args,
		uint8_t	arg_count )

Execute IO function.

Parameters

handle	IO instance handle
function	IO function to execute
args	Function arguments array
arg_count	Number of arguments

Returns

meshx_err_t Error code

                                                {
    if (handle == nullptr) {
        return MESHX_INVALID_ARG;
    }
 
    MeshXIoInterface* instance = static_cast<MeshXIoInterface*>(handle);
    std::vector<uint32_t> arg_vec;
    if (args != nullptr && arg_count > 0) {
        arg_vec.assign(args, args + arg_count);
    }
 
    int result = instance->execute(static_cast<IoFunction>(function), arg_vec);
    return (result == 0) ? MESHX_SUCCESS : MESHX_FAIL;
}

meshx_io_get_level()

meshx_err_t meshx_io_get_level	(	meshx_io_handle_t	handle,
		uint8_t *	level )

Get pin level (convenience function).

Parameters

	handle	IO instance handle
[out]	level	Pointer to store pin level

Returns

meshx_err_t Error code

                                                                         {
    if (handle == nullptr || level == nullptr) {
        return MESHX_INVALID_ARG;
    }
    int result = static_cast<MeshXIoInterface*>(handle)->getLevel(level);
    return (result == 0) ? MESHX_SUCCESS : MESHX_FAIL;
}

meshx_io_get_logical_pin()

uint8_t meshx_io_get_logical_pin

(

meshx_io_handle_t

handle

)

Get logical pin number.

Parameters

handle

IO instance handle

Returns

uint8_t Logical pin number

                                                           {
    if (handle == nullptr) {
        return 0xFF;
    }
    return static_cast<MeshXIoInterface*>(handle)->getLogicalPin();
}

meshx_io_get_name()

const char * meshx_io_get_name

(

meshx_io_handle_t

handle

)

Get pin name.

Parameters

handle

IO instance handle

Returns

const char* Pin name

                                                        {
    if (handle == nullptr) {
        return nullptr;
    }
    return static_cast<MeshXIoInterface*>(handle)->getName();
}

meshx_io_init()

meshx_err_t meshx_io_init

(

void

)

Initialize IO subsystem.

This function initializes the IO factory and registers all IO types.

Returns

meshx_err_t Error code

                                {
    // Factory initializes itself on getInstance()
    (void)MeshXIoFactory::getInstance();
    return MESHX_SUCCESS;
}

meshx_io_is_function_supported()

bool meshx_io_is_function_supported	(	meshx_io_handle_t	handle,
		meshx_io_func_t	function )

Check if function is supported.

Parameters

handle	IO instance handle
function	IO function to check

Returns

true if function is supported

false if function is not supported

                                                              {
    if (handle == nullptr) {
        return false;
    }
    return static_cast<MeshXIoInterface*>(handle)->isFunctionSupported(static_cast<IoFunction>(function));
}

meshx_io_set_level()

meshx_err_t meshx_io_set_level	(	meshx_io_handle_t	handle,
		uint8_t	level )

Set pin level (convenience function).

Parameters

handle	IO instance handle
level	Pin level (0 = low, 1 = high)

Returns

meshx_err_t Error code

                                                                        {
    if (handle == nullptr) {
        return MESHX_INVALID_ARG;
    }
    int result = static_cast<MeshXIoInterface*>(handle)->setLevel(level);
    return (result == 0) ? MESHX_SUCCESS : MESHX_FAIL;
}

meshx_io_toggle()

meshx_err_t meshx_io_toggle

(

meshx_io_handle_t

handle

)

Toggle pin level (convenience function).

Parameters

handle

IO instance handle

Returns

meshx_err_t Error code

                                                      {
    if (handle == nullptr) {
        return MESHX_INVALID_ARG;
    }
    int result = static_cast<MeshXIoInterface*>(handle)->toggle();
    return (result == 0) ? MESHX_SUCCESS : MESHX_FAIL;
}