Console Public API

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

Collaboration diagram for Console Public API:

Functions
ERR_te	console_init (CONSOLE_HANDLE_ts *console_handle)
	Initializes the console subsystem.
ERR_te	console_run (void)
	Runs the console state machine. Must be called periodically.

Detailed Description

Public functions to interact with the console subsystem.

Function Documentation

console_init()

ERR_te console_init

(

CONSOLE_HANDLE_ts *

console_handle

)

Initializes the console subsystem.

Configures the internal state, initializes the RX GPIO pin in alternate function mode, and initializes the USART peripheral with interrupt-driven reception. USART reception is enabled before the function returns.

Note

CONFIG_CONSOLE_USART_CBUF_SIZE must be a power of two. Initialization will fail with ERR_INVALID_CONFIGURATION otherwise.

Parameters

[in]

console_handle

Pointer to the console configuration structure.

Returns

• ERR_OK on success
• ERR_INVALID_CONFIGURATION if the USART circular buffer size is not a power of two

See also

console_init

Definition at line 92 of file console.c.

                                                       {
    if(is_pow(CONFIG_CONSOLE_USART_CBUF_SIZE) == false) {
        return ERR_INVALID_CONFIGURATION;
    }
 
    internal_state.usart_instance = console_handle->usart_instance;
 
    init_log();
 
    GPIO_CFG_ts console_rx_pin = { 0 };
    console_rx_pin.port = console_handle->gpio_port;
    console_rx_pin.pin = console_handle->gpio_pin;
    console_rx_pin.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    console_rx_pin.alternate_function = console_handle->gpio_alternate_function;
    gpio_init(&console_rx_pin);
 
    USART_CFG_ts console_usart = { 0 };
    console_usart.instance = console_handle->usart_instance;
    console_usart.baud_rate = console_handle->usart_baud_rate;
    console_usart.interrupt_en = USART_INTERRUPT_EN_TRUE;
    usart_init(&console_usart);
 
    usart_set_reception(internal_state.usart_instance, ENABLE);
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

console_run()

ERR_te console_run

(

void

)

Runs the console state machine. Must be called periodically.

Each call performs the following steps:

1. Drains any bytes received into the USART circular buffer by the ISR.
2. Handles console mode entry and exit via the Ctrl+C character.
3. In console mode, echoes typed characters and accumulates them in an internal buffer.
4. On carriage return, processes backspace characters, then passes the resulting command string to cmd_execute.

Returns

• ERR_OK on success
• Propagated error from internal circular buffer or command operations

Runs the console state machine. Must be called periodically.

See also

console_run

Definition at line 120 of file console.c.

                         {
    ERR_te err;
    uint8_t data_len = 0;
 
    err = cbuf_len(&internal_state.usart_data_recv_cbuf, &data_len);
    if(err != ERR_OK) {
        return err;
    }
 
    if(data_len) {
        uint8_t data[data_len];
 
        err = cbuf_read(&internal_state.usart_data_recv_cbuf, data);
        if(err != ERR_OK) {
            return err;
        }
 
        if(*data == CONSOLE_MODE_CMD && internal_state.console_mode == false) {
            internal_state.console_mode = true;
            log_set_force_disable(true);
            usart_send(internal_state.usart_instance, (uint8_t*)"$", 1);
        }
        else if(*data == CONSOLE_MODE_CMD && internal_state.console_mode == true) {
            internal_state.console_mode = false;
            log_set_force_disable(false);
 
            uint8_t console_text_len = 0;
            err = cbuf_len(&internal_state.console_cbuf, &console_text_len);
            if(err != ERR_OK) {
                return err;
            }
 
            for(uint8_t i = 0; i < console_text_len + 1; i++) {
                usart_send(internal_state.usart_instance, (uint8_t*)"\x7F", 1);
            }
        }
 
        if(*data != CONSOLE_MODE_CMD && internal_state.console_mode == true) {
            usart_send(internal_state.usart_instance, data, data_len);
 
            err = cbuf_write(&internal_state.console_cbuf, data, data_len);
            if(err != ERR_OK) {
                return err;
            }
 
            for(uint32_t i = 0; i < data_len; i++) {
                if(data[i] == '\r') {
                    log_set_force_disable(false);
 
                    uint8_t console_text_len = 0;
                    err = cbuf_len(&internal_state.console_cbuf, &console_text_len);
                    if(err != ERR_OK) {
                        return err;
                    }
 
                    char console_text[console_text_len];
 
                    err = cbuf_read(&internal_state.console_cbuf, (uint8_t*)console_text);
                    if(err != ERR_OK) {
                        return err;
                    }
 
                    console_text[console_text_len - 1] = '\0';
 
                    uint8_t backspace_counter = 0;
 
                    for(int16_t j = console_text_len - 1; j >= 0; j--) {
                        while(console_text[j] == 127) {
                            backspace_counter++;
                            console_text[j] = 0;
                            j--;
                        }
 
                        while(backspace_counter) {
                            console_text[j] = 0;
                            backspace_counter--;
                            j--;
                        }
                    }
 
                    arr_cmprs((char*)console_text, console_text_len);
                    internal_state.console_mode = false;
                    usart_send(internal_state.usart_instance, (uint8_t*)"\r\n", 2);
                    cmd_execute(console_text);
                }
            }
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function: