meshx_pwm.c File Reference

MeshX PWM Runtime Implementation (Updated to reduce log verbosity). More...

#include <string.h>
#include <stdbool.h>
#include "interface/gpio/meshx_pwm.h"
#include "interface/gpio/meshx_gpio_platform.h"
#include "../../inc/meshx_err.h"
#include "../../interface/logging/meshx_log.h"
#include "../../inc/module_id.h"

Data Structures
struct	meshx_pwm_config_t
	PWM configuration structure. More...
struct	meshx_pwm_state_t
	PWM runtime state structure. More...
struct	meshx_pwm_runtime_t
	PWM runtime state structure. More...

Functions
meshx_err_t	meshx_pwm_init (void)
	Initialize PWM subsystem.
meshx_err_t	meshx_pwm_deinit (void)
	Deinitialize PWM subsystem.
static meshx_err_t	validate_pwm_logical_pin (uint8_t logical_pin)
	Validate logical pin number for PWM.
static meshx_err_t	validate_pwm_frequency (uint32_t frequency)
	Validate PWM frequency.
static meshx_err_t	validate_pwm_duty_cycle (uint8_t duty_cycle)
	Validate PWM duty cycle.
static meshx_err_t	validate_pwm_resolution (uint8_t resolution)
	Validate PWM resolution.
static meshx_err_t	allocate_pwm_channel (uint8_t logical_pin, uint8_t *channel)
	Allocate PWM channel.
meshx_err_t	meshx_pwm_start (uint8_t logical_pin)
	Start PWM output on pin.
meshx_err_t	meshx_pwm_stop (uint8_t logical_pin)
	Stop PWM output on pin.
meshx_err_t	meshx_pwm_set_duty_cycle (uint8_t logical_pin, uint8_t duty_cycle)
	Set PWM duty cycle.
meshx_err_t	meshx_pwm_get_duty_cycle (uint8_t logical_pin, uint8_t *duty_cycle)
	Get PWM duty cycle.
meshx_err_t	meshx_pwm_set_frequency (uint8_t logical_pin, uint32_t frequency)
	Set PWM frequency.
meshx_err_t	meshx_pwm_get_frequency (uint8_t logical_pin, uint32_t *frequency)
	Get PWM frequency.
meshx_err_t	meshx_pwm_set_resolution (uint8_t logical_pin, uint8_t resolution)
	Set PWM resolution.
meshx_err_t	meshx_pwm_get_resolution (uint8_t logical_pin, uint8_t *resolution)
	Get PWM resolution.
bool	meshx_pwm_is_initialized (void)
	Check if PWM subsystem is initialized.
uint8_t	meshx_pwm_get_pin_count (void)
	Get number of configured PWM pins.
uint8_t	meshx_pwm_get_allocated_channels (void)
	Get number of allocated PWM channels.
bool	meshx_pwm_is_started (uint8_t logical_pin)
	Check if PWM is started on pin.
void	meshx_pwm_test_set_pin_count (uint8_t count)

Variables
static meshx_pwm_runtime_t	pwm_runtime
static meshx_pwm_config_t	test_pwm_configs [128]
static meshx_pwm_state_t	test_pwm_states [128]

Detailed Description

MeshX PWM Runtime Implementation (Updated to reduce log verbosity).

This file implements the PWM runtime subsystem for MeshX. It provides the runtime API for PWM operations with parameter validation, hardware channel allocation, and PWM state management.

Author

MeshX Team

Date

2024

Function Documentation

allocate_pwm_channel()

meshx_err_t allocate_pwm_channel ( uint8_t logical_pin, uint8_t * channel )

static

Allocate PWM channel.

Parameters

	logical_pin	Logical pin number
[out]	channel	Allocated channel number

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    if (channel == NULL) {
        return MESHX_INVALID_ARG;
    }
 
    // Check if channel is already allocated for this pin
    if (pwm_runtime.pwm_configs != NULL) {
        uint8_t configured_channel = pwm_runtime.pwm_configs[logical_pin].channel;
        if (configured_channel != 0xFF) {  // 0xFF means not configured
            // Check if channel is already in use
            for (uint8_t i = 0; i < pwm_runtime.allocated_channels; i++) {
                if (pwm_runtime.channel_allocation[i] == configured_channel) {
                    // Channel already allocated to another pin
                    return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
                }
            }
 
            *channel = configured_channel;
            pwm_runtime.channel_allocation[pwm_runtime.allocated_channels++] = configured_channel;
            return MESHX_SUCCESS;
        }
    }
 
    // Find free channel (simple linear search)
    // TODO: Implement better channel allocation strategy
    for (uint8_t ch = 0; ch < sizeof(pwm_runtime.channel_allocation); ch++) {
        bool channel_in_use = false;
        for (uint8_t i = 0; i < pwm_runtime.allocated_channels; i++) {
            if (pwm_runtime.channel_allocation[i] == ch) {
                channel_in_use = true;
                break;
            }
        }
 
        if (!channel_in_use) {
            *channel = ch;
            pwm_runtime.channel_allocation[pwm_runtime.allocated_channels++] = ch;
 
            // Update configuration if available
            if (pwm_runtime.pwm_configs != NULL) {
                pwm_runtime.pwm_configs[logical_pin].channel = ch;
            }
 
            return MESHX_SUCCESS;
        }
    }
 
    return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;  // No channels available
}

meshx_pwm_deinit()

meshx_err_t meshx_pwm_deinit

(

void

)

Deinitialize PWM subsystem.

This function deinitializes the PWM subsystem and releases all resources. It stops all PWM outputs, deconfigures channels, and cleans up platform resources.

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Deinitializing PWM subsystem");
 
    if (!pwm_runtime.initialized) {
        MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM not initialized");
        return MESHX_SUCCESS;
    }
 
    // Stop all active PWM outputs
    for (uint8_t i = 0; i < pwm_runtime.pwm_pin_count; i++) {
        if (pwm_runtime.pwm_states != NULL && pwm_runtime.pwm_states[i].started) {
            meshx_pwm_stop(i);
        }
    }
 
    // Deinitialize platform-specific PWM
    meshx_err_t err = meshx_pwm_platform_deinit();
    if (err != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_GPIO, "Platform PWM deinit failed: %d", err);
        return err;
    }
 
    // Free allocated resources
    // Note: In actual implementation, these would be freed if dynamically allocated
    // For now, just reset pointers since they're statically allocated or NULL
    pwm_runtime.pwm_configs = NULL;
    pwm_runtime.pwm_states = NULL;
    memset(pwm_runtime.channel_allocation, 0xFF, sizeof(pwm_runtime.channel_allocation));
    pwm_runtime.allocated_channels = 0;
 
    pwm_runtime.initialized = false;
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM subsystem deinitialized");
    return MESHX_SUCCESS;
}

meshx_pwm_get_allocated_channels()

uint8_t meshx_pwm_get_allocated_channels

(

void

)

Get number of allocated PWM channels.

Returns

uint8_t Number of allocated channels

{
    return pwm_runtime.allocated_channels;
}

meshx_pwm_get_duty_cycle()

meshx_err_t meshx_pwm_get_duty_cycle	(	uint8_t	logical_pin,
		uint8_t *	duty_cycle )

Get PWM duty cycle.

Parameters

	logical_pin	Logical pin number (0-255)
[out]	duty_cycle	Pointer to store duty cycle

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Getting PWM duty cycle from pin %u", logical_pin);
 
    if (duty_cycle == NULL) {
        return MESHX_INVALID_ARG;
    }
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if PWM is started
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    // TODO: Get from platform-specific implementation
    // For now, return from runtime state
    *duty_cycle = pwm_runtime.pwm_states[logical_pin].duty_cycle;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM duty cycle on pin %u is %u%%", logical_pin, *duty_cycle);
    return MESHX_SUCCESS;
}

meshx_pwm_get_frequency()

meshx_err_t meshx_pwm_get_frequency	(	uint8_t	logical_pin,
		uint32_t *	frequency )

Get PWM frequency.

Parameters

	logical_pin	Logical pin number (0-255)
[out]	frequency	Pointer to store frequency

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Getting PWM frequency from pin %u", logical_pin);
 
    if (frequency == NULL) {
        return MESHX_INVALID_ARG;
    }
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if PWM is started
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    // TODO: Get from platform-specific implementation
    // For now, return from runtime state
    *frequency = pwm_runtime.pwm_states[logical_pin].frequency;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM frequency on pin %u is %u Hz", logical_pin, *frequency);
    return MESHX_SUCCESS;
}

meshx_pwm_get_pin_count()

uint8_t meshx_pwm_get_pin_count

(

void

)

Get number of configured PWM pins.

Returns

uint8_t Number of configured PWM pins

{
    return pwm_runtime.pwm_pin_count;
}

meshx_pwm_get_resolution()

meshx_err_t meshx_pwm_get_resolution	(	uint8_t	logical_pin,
		uint8_t *	resolution )

Get PWM resolution.

Parameters

	logical_pin	Logical pin number (0-255)
[out]	resolution	Pointer to store resolution

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Getting PWM resolution from pin %u", logical_pin);
 
    if (resolution == NULL) {
        return MESHX_INVALID_ARG;
    }
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if PWM is started
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    // TODO: Get from platform-specific implementation
    // For now, return from runtime state
    *resolution = pwm_runtime.pwm_states[logical_pin].resolution;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM resolution on pin %u is %u bits", logical_pin, *resolution);
    return MESHX_SUCCESS;
}

meshx_pwm_init()

meshx_err_t meshx_pwm_init

(

void

)

Initialize PWM subsystem.

This function initializes the PWM subsystem based on compiled configuration. It sets up hardware PWM channels and configures all PWM pins according to their YAML configuration.

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Initializing PWM subsystem");
 
    if (pwm_runtime.initialized) {
        MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM already initialized");
        return MESHX_SUCCESS;
    }
 
    // Initialize platform-specific PWM
    meshx_err_t err = meshx_pwm_platform_init();
    if (err != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_GPIO, "Platform PWM init failed: %d", err);
        return err;
    }
 
    // TODO: Load configuration from generated headers
    // For now, initialize with empty configuration
    pwm_runtime.pwm_pin_count = 0;
    pwm_runtime.pwm_configs = NULL;
    pwm_runtime.pwm_states = NULL;
    memset(pwm_runtime.channel_allocation, 0xFF, sizeof(pwm_runtime.channel_allocation));
    pwm_runtime.allocated_channels = 0;
 
    pwm_runtime.initialized = true;
#if CONFIG_ENABLE_UNIT_TEST
    pwm_runtime.pwm_pin_count = 128;
    pwm_runtime.pwm_configs = test_pwm_configs;
    pwm_runtime.pwm_states = test_pwm_states;
    memset(test_pwm_configs, 0, sizeof(test_pwm_configs));
    memset(test_pwm_states, 0, sizeof(test_pwm_states));
    for (int i = 0; i < 128; i++) {
        test_pwm_configs[i].logical_pin = i;
        test_pwm_configs[i].channel = 0xFF;
        test_pwm_configs[i].frequency = 1000;
        test_pwm_configs[i].resolution = 10;
    }
#endif
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM subsystem initialized");
    return MESHX_SUCCESS;
}

meshx_pwm_is_initialized()

bool meshx_pwm_is_initialized

(

void

)

Check if PWM subsystem is initialized.

Returns

true if initialized

false if not initialized

{
    return pwm_runtime.initialized;
}

meshx_pwm_is_started()

bool meshx_pwm_is_started

(

uint8_t

logical_pin

)

Check if PWM is started on pin.

Parameters

logical_pin

Logical pin number

Returns

true if PWM is started

false if PWM is not started

{
    if (!pwm_runtime.initialized || logical_pin >= pwm_runtime.pwm_pin_count) {
        return false;
    }
 
    if (pwm_runtime.pwm_states == NULL) {
        return false;
    }
 
    return pwm_runtime.pwm_states[logical_pin].started;
}

meshx_pwm_set_duty_cycle()

meshx_err_t meshx_pwm_set_duty_cycle	(	uint8_t	logical_pin,
		uint8_t	duty_cycle )

Set PWM duty cycle.

Parameters

logical_pin	Logical pin number (0-255)
duty_cycle	Duty cycle (0-100%)

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "Setting PWM duty cycle on pin %u to %u%%", logical_pin, duty_cycle);
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Validate duty cycle
    err = validate_pwm_duty_cycle(duty_cycle);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if PWM is started
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    // TODO: Get physical pin from logical pin mapping
    // For now, use logical pin as physical pin (simplified)
    uint8_t physical_pin = logical_pin;
 
    // Set platform-specific PWM duty cycle
    err = meshx_pwm_platform_set_duty_cycle(physical_pin, duty_cycle);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Update runtime state
    pwm_runtime.pwm_states[logical_pin].duty_cycle = duty_cycle;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM duty cycle set on pin %u to %u%%", logical_pin, duty_cycle);
    return MESHX_SUCCESS;
}

meshx_pwm_set_frequency()

meshx_err_t meshx_pwm_set_frequency	(	uint8_t	logical_pin,
		uint32_t	frequency )

Set PWM frequency.

Parameters

logical_pin	Logical pin number (0-255)
frequency	Frequency in Hz

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "Setting PWM frequency on pin %u to %u Hz", logical_pin, frequency);
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Validate frequency
    err = validate_pwm_frequency(frequency);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if PWM is started
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    // TODO: Get physical pin from logical pin mapping
    // For now, use logical pin as physical pin (simplified)
    uint8_t physical_pin = logical_pin;
 
    // Set platform-specific PWM frequency
    err = meshx_pwm_platform_set_frequency(physical_pin, frequency);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Update runtime state
    pwm_runtime.pwm_states[logical_pin].frequency = frequency;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM frequency set on pin %u to %u Hz", logical_pin, frequency);
    return MESHX_SUCCESS;
}

meshx_pwm_set_resolution()

meshx_err_t meshx_pwm_set_resolution	(	uint8_t	logical_pin,
		uint8_t	resolution )

Set PWM resolution.

Parameters

logical_pin	Logical pin number (0-255)
resolution	Resolution in bits (typically 8-16)

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "Setting PWM resolution on pin %u to %u bits", logical_pin, resolution);
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Validate resolution
    err = validate_pwm_resolution(resolution);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if PWM is started
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    // Update runtime state
    pwm_runtime.pwm_states[logical_pin].resolution = resolution;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM resolution set on pin %u to %u bits", logical_pin, resolution);
    return MESHX_SUCCESS;
}

meshx_pwm_start()

meshx_err_t meshx_pwm_start

(

uint8_t

logical_pin

)

Start PWM output on pin.

Parameters

logical_pin

Logical pin number (0-255)

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Starting PWM on pin %u", logical_pin);
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if already started
    if (pwm_runtime.pwm_states != NULL && pwm_runtime.pwm_states[logical_pin].started) {
        MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM already started on pin %u", logical_pin);
        return MESHX_SUCCESS;
    }
 
    // Get configuration
    uint32_t frequency = 1000;  // Default 1kHz
    uint8_t duty_cycle = 50;    // Default 50%
    uint8_t resolution = 10;    // Default 10-bit
 
    if (pwm_runtime.pwm_configs != NULL) {
        frequency = pwm_runtime.pwm_configs[logical_pin].frequency;
        duty_cycle = pwm_runtime.pwm_configs[logical_pin].duty_cycle;
        resolution = pwm_runtime.pwm_configs[logical_pin].resolution;
    }
 
    // Validate parameters
    err = validate_pwm_frequency(frequency);
    if (err != MESHX_SUCCESS) return err;
 
    err = validate_pwm_duty_cycle(duty_cycle);
    if (err != MESHX_SUCCESS) return err;
 
    err = validate_pwm_resolution(resolution);
    if (err != MESHX_SUCCESS) return err;
 
    // Allocate PWM channel
    uint8_t channel;
    err = allocate_pwm_channel(logical_pin, &channel);
    if (err != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_GPIO,
                   "Failed to allocate PWM channel for pin %u: %d", logical_pin, err);
        return err;
    }
 
    // TODO: Get physical pin from logical pin mapping
    // For now, use logical pin as physical pin (simplified)
    uint8_t physical_pin = logical_pin;
 
    // Start platform-specific PWM
    err = meshx_pwm_platform_start(physical_pin, frequency, duty_cycle, resolution);
    if (err != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_GPIO,
                   "Platform PWM start failed for pin %u: %d", logical_pin, err);
        return err;
    }
 
    // Update runtime state
    if (pwm_runtime.pwm_states != NULL) {
        pwm_runtime.pwm_states[logical_pin].started = true;
        pwm_runtime.pwm_states[logical_pin].frequency = frequency;
        pwm_runtime.pwm_states[logical_pin].duty_cycle = duty_cycle;
        pwm_runtime.pwm_states[logical_pin].resolution = resolution;
    }
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO,
               "PWM started on pin %u: %u Hz, %u%%, %u-bit",
               logical_pin, frequency, duty_cycle, resolution);
    return MESHX_SUCCESS;
}

meshx_pwm_stop()

meshx_err_t meshx_pwm_stop

(

uint8_t

logical_pin

)

Stop PWM output on pin.

Parameters

logical_pin

Logical pin number (0-255)

Returns

meshx_err_t MESHX_SUCCESS on success, error code on failure

{
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "Stopping PWM on pin %u", logical_pin);
 
    // Validate pin
    meshx_err_t err = validate_pwm_logical_pin(logical_pin);
    if (err != MESHX_SUCCESS) {
        return err;
    }
 
    // Check if already stopped
    if (pwm_runtime.pwm_states == NULL || !pwm_runtime.pwm_states[logical_pin].started) {
        MESHX_LOGW(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM already stopped on pin %u", logical_pin);
        return MESHX_SUCCESS;
    }
 
    // TODO: Get physical pin from logical pin mapping
    // For now, use logical pin as physical pin (simplified)
    uint8_t physical_pin = logical_pin;
 
    // Stop platform-specific PWM
    err = meshx_pwm_platform_stop(physical_pin);
    if (err != MESHX_SUCCESS) {
        MESHX_LOGE(MODULE_ID_COMPONENT_MESHX_GPIO,
                   "Platform PWM stop failed for pin %u: %d", logical_pin, err);
        return err;
    }
 
    // Free allocated channel
    if (pwm_runtime.pwm_configs != NULL) {
        uint8_t channel = pwm_runtime.pwm_configs[logical_pin].channel;
        if (channel != 0xFF) {
            // Remove from allocation tracking
            for (uint8_t i = 0; i < pwm_runtime.allocated_channels; i++) {
                if (pwm_runtime.channel_allocation[i] == channel) {
                    // Shift remaining channels
                    for (uint8_t j = i; j < pwm_runtime.allocated_channels - 1; j++) {
                        pwm_runtime.channel_allocation[j] = pwm_runtime.channel_allocation[j + 1];
                    }
                    pwm_runtime.allocated_channels--;
                    break;
                }
            }
        }
    }
 
    // Update runtime state
    pwm_runtime.pwm_states[logical_pin].started = false;
 
    MESHX_LOGD(MODULE_ID_COMPONENT_MESHX_GPIO, "PWM stopped on pin %u", logical_pin);
    return MESHX_SUCCESS;
}

meshx_pwm_test_set_pin_count()

void meshx_pwm_test_set_pin_count

(

uint8_t

count

)

{
    if (count > 128) count = 128;
    pwm_runtime.pwm_pin_count = count;
}

validate_pwm_duty_cycle()

meshx_err_t validate_pwm_duty_cycle ( uint8_t duty_cycle )

static

Validate PWM duty cycle.

Parameters

duty_cycle

Duty cycle (0-100%)

Returns

meshx_err_t MESHX_SUCCESS if valid, error code if invalid

{
    if (duty_cycle > 100) {
        return MESHX_ERR_GPIO_PWM_INVALID_PARAM;
    }
 
    return MESHX_SUCCESS;
}

validate_pwm_frequency()

meshx_err_t validate_pwm_frequency ( uint32_t frequency )

static

Validate PWM frequency.

Parameters

frequency

Frequency in Hz

Returns

meshx_err_t MESHX_SUCCESS if valid, error code if invalid

{
    if (frequency == 0) {
        return MESHX_ERR_GPIO_PWM_INVALID_PARAM;
    }
 
    // TODO: Check against hardware limits from BSP constraints
    // For now, just check basic validity
    if (frequency > 40000000) {  // 40MHz theoretical max
        return MESHX_ERR_GPIO_PWM_INVALID_PARAM;
    }
 
    return MESHX_SUCCESS;
}

validate_pwm_logical_pin()

meshx_err_t validate_pwm_logical_pin ( uint8_t logical_pin )

static

Validate logical pin number for PWM.

Parameters

logical_pin

Logical pin number to validate

Returns

meshx_err_t MESHX_SUCCESS if valid, error code if invalid

{
    if (!pwm_runtime.initialized) {
        return MESHX_ERR_GPIO_NOT_INITIALIZED;
    }
 
    if (logical_pin >= pwm_runtime.pwm_pin_count) {
        return MESHX_ERR_GPIO_INVALID_PIN;
    }
 
    // Check if pin is configured for PWM
    if (pwm_runtime.pwm_configs != NULL &&
        pwm_runtime.pwm_configs[logical_pin].logical_pin != logical_pin) {
        return MESHX_ERR_GPIO_PWM_NOT_SUPPORTED;
    }
 
    return MESHX_SUCCESS;
}

validate_pwm_resolution()

meshx_err_t validate_pwm_resolution ( uint8_t resolution )

static

Validate PWM resolution.

Parameters

resolution

Resolution in bits

Returns

meshx_err_t MESHX_SUCCESS if valid, error code if invalid

{
    if (resolution == 0 || resolution > 20) {  // ESP32 supports up to 20-bit
        return MESHX_ERR_GPIO_PWM_INVALID_PARAM;
    }
 
    return MESHX_SUCCESS;
}

Variable Documentation

pwm_runtime

meshx_pwm_runtime_t pwm_runtime

static

test_pwm_configs

meshx_pwm_config_t test_pwm_configs[128]

static

test_pwm_states

meshx_pwm_state_t test_pwm_states[128]

static