IO Public API

Public functions to interact with the IO subsystem. More...

Collaboration diagram for IO Public API:

Functions
ERR_te	io_init_subsys (void)
	Initializes the IO subsystem.
ERR_te	io_deinit_subsys (void)
	Deinitializes the IO subsystem.
ERR_te	io_start_subsys (void)
	Starts the IO subsystem.
ERR_te	io_stop_subsys (void)
	Stops the IO subsystem.
ERR_te	io_init_handle (IO_CFG_ts *io_cfg, IO_HANDLE_ts **io_handle_o)
	Initializes and registers an IO handle.
ERR_te	io_deinit_handle (IO_HANDLE_ts const *io_handle)
	Deinitializes an IO handle.
ERR_te	io_write (IO_HANDLE_ts *io_handle, PIN_STATUS_te pin_status)
	Writes a logic level to an IO pin.
ERR_te	io_read (IO_HANDLE_ts const *io_handle, PIN_STATUS_te *pin_status_o)
	Reads the current logic level of an IO pin.

Detailed Description

Public functions to interact with the IO subsystem.

Function Documentation

io_init_subsys()

ERR_te io_init_subsys

(

void

)

Initializes the IO subsystem.

Resets the internal state, registers the CLI commands, and initializes the logging dependency.

Must be called before any other IO API function.

Returns

• ERR_OK on success
• ERR_MODULE_ALREADY_INITIALIZED if the subsystem is already initialized
• Propagated error from cmd_register on failure

Note

Should only be called once during system startup.

See also

io_init_subsys

Definition at line 120 of file io.c.

                            {
    ERR_te err = 0;
 
    if(internal_state.initialized) {
        return ERR_MODULE_ALREADY_INITIALIZED;
    }
 
    internal_state = (struct internal_state_s){ 0 };
 
    internal_state.log_level = LOG_LEVEL_INFO;
    internal_state.subsys = MODULES_IO;
    internal_state.initialized = true;
    internal_state.started = false;
 
    init_log();
 
    err = cmd_register(&io_cmd_client_info);
    if(err != ERR_OK) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_init_subsys: cmd_register error"
        );
 
        return err;
    }
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "io_init_subsys: subsys initialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

io_deinit_subsys()

ERR_te io_deinit_subsys

(

void

)

Deinitializes the IO subsystem.

Resets the internal state to zero and deregisters the CLI commands. The subsystem must be stopped before calling this function.

Returns

• ERR_OK on success
• ERR_DEINITIALIZATION_FAILURE if the subsystem is not initialized or still running

Note

All IO handles should be deinitialized before calling this function.

See also

io_deinit_subsys

Definition at line 156 of file io.c.

                              {
    if(internal_state.initialized && !internal_state.started) {
        internal_state = (struct internal_state_s){ 0 };
 
        cmd_deregister(&io_cmd_client_info);
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_deinit_subsys: subsys is not initialized or not stopped"
        );
 
        return ERR_DEINITIALIZATION_FAILURE;
    }
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "io_deinit_subsys: subsys deinitialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

io_start_subsys()

ERR_te io_start_subsys

(

void

)

Starts the IO subsystem.

Enables runtime operations. After calling this function, io_write and io_read may be called.

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or already started

Note

Must be called after io_init_subsys.

See also

io_start_subsys

Definition at line 181 of file io.c.

                             {
    if(internal_state.initialized && !internal_state.started) {
        internal_state.started = true;
 
        LOG_INFO(
            internal_state.subsys,
            internal_state.log_level,
            "io_start_subsys: subsys started"
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_start_subsys: subsys not initialized or already started"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

Here is the caller graph for this function:

io_stop_subsys()

ERR_te io_stop_subsys

(

void

)

Stops the IO subsystem.

Disables runtime operations. After calling this function, io_write and io_read will return an error.

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or already stopped

Note

Call this before deinitializing the subsystem or handles.

See also

io_stop_subsys

Definition at line 205 of file io.c.

                            {
    if(internal_state.initialized && internal_state.started) {
        internal_state.started = false;
 
        LOG_INFO(
            internal_state.subsys,
            internal_state.log_level,
            "io_stop_subsys: subsys stopped"
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_stop_subsys: subsys not initialized or already already stopped"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

io_init_handle()

ERR_te io_init_handle	(	IO_CFG_ts *	io_cfg,
		IO_HANDLE_ts **	io_handle_o )

Initializes and registers an IO handle.

Configures the GPIO pin described by io_cfg and allocates an internal handle from the pool.

Parameters

[in]	io_cfg	Pointer to the IO configuration structure.
[out]	io_handle_o	Pointer to a handle pointer that will be set to the allocated IO instance.

Returns

• ERR_OK on success
• ERR_NOT_ENOUGH_SPACE if the maximum number of IO handles is reached

See also

io_init_handle

Definition at line 229 of file io.c.

                                                                     {
    if(internal_state.io_num == CONFIG_IO_MAX_OBJECTS) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_init_handle: subsystem out of memory space"
        );
 
        return ERR_NOT_ENOUGH_SPACE;
    }
 
    gpio_init(io_cfg->gpio_handle);
 
    for(uint32_t i = 0; i < CONFIG_IO_MAX_OBJECTS; i++) {
        if(internal_state.ios[i].in_use == false) {
            internal_state.ios[i].gpio_cfg = *io_cfg->gpio_handle;
            txt_cpy(internal_state.ios[i].name,
                io_cfg->name,
                get_str_len(io_cfg->name) + 1);
 
            internal_state.ios[i].in_use = true;
 
            internal_state.io_num++;
 
            *io_handle_o = &internal_state.ios[i];
 
            LOG_INFO(
                internal_state.subsys,
                internal_state.log_level,
                "io_init_handle: io handle %s initialized",
                internal_state.ios[i].name
            );
 
            break;
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

io_deinit_handle()

ERR_te io_deinit_handle

(

IO_HANDLE_ts const *

io_handle

)

Deinitializes an IO handle.

Releases the internal resources associated with the given handle and marks the slot as available for reuse.

Parameters

[in]

io_handle

Pointer to the handle to deinitialize.

Returns

• ERR_OK on success
• ERR_UNINITIALZIED_OBJECT if no handles exist or the handle is not found

See also

io_deinit_handle

Definition at line 270 of file io.c.

                                                       {
    if(internal_state.io_num == 0) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_deinit_handle: no such handle to deinitialize"
        );
 
        return ERR_UNINITIALZIED_OBJECT;
    }
 
    for(uint32_t i = 0; i < CONFIG_IO_MAX_OBJECTS; i++) {
        if(&internal_state.ios[i] == io_handle) {
            internal_state.ios[i].gpio_cfg = (GPIO_CFG_ts){ 0 };
 
            uint8_t name_len = get_str_len(internal_state.ios[i].name) + 1;
            char name[name_len];
 
            str_cpy(name, internal_state.ios[i].name, name_len);
 
            for(uint32_t j = 0; j < name_len; j++) {
                internal_state.ios[i].name[j] = '\0';
            }
 
            internal_state.ios[i].in_use = false;
 
            internal_state.io_num--;
 
            LOG_INFO(
                internal_state.subsys,
                internal_state.log_level,
                "io_deinit_handle: io handle %s deinitialized",
                name
            );
 
            break;
        }
 
        if(i == CONFIG_IO_MAX_OBJECTS - 1) {
            LOG_ERROR(
                internal_state.subsys,
                internal_state.log_level,
                "io_deinit_handle: no such handle to deinitialize"
            );
 
            return ERR_UNINITIALZIED_OBJECT;
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

io_write()

ERR_te io_write	(	IO_HANDLE_ts *	io_handle,
		PIN_STATUS_te	pin_status )

Writes a logic level to an IO pin.

Parameters

[in]	io_handle	Pointer to the IO handle to write to.
[in]	pin_status	The logic level to drive on the pin (HIGH or LOW).

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or started

See also

io_write

Definition at line 323 of file io.c.

                                                                   {
    if(internal_state.initialized && internal_state.started) {
        gpio_write(
            io_handle->gpio_cfg.port,
            io_handle->gpio_cfg.pin,
            pin_status
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_write: subsystem not initialized or started"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

io_read()

ERR_te io_read	(	IO_HANDLE_ts const *	io_handle,
		PIN_STATUS_te *	pin_status_o )

Reads the current logic level of an IO pin.

Parameters

[in]	io_handle	Pointer to the IO handle to read from.
[out]	pin_status_o	Pointer to a variable that will receive the current pin level (HIGH or LOW).

Returns

• ERR_OK on success
• ERR_UNKNOWN if the subsystem is not initialized or started

See also

io_read

Definition at line 345 of file io.c.

                                                                           {
    if(internal_state.initialized && internal_state.started) {
        *pin_status_o = gpio_read(
            io_handle->gpio_cfg.port,
            io_handle->gpio_cfg.pin
        );
    }
    else {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "io_read: subsystem not initialized or started"
        );
 
        return ERR_UNKNOWN;
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: