NEO-6 Public API

Public functions to interact with the NEO-6 GPS subsystem. More...

Collaboration diagram for NEO-6 Public API:

Functions
ERR_te	neo6_init_subsys (void)
	Initializes the NEO-6 subsystem.
ERR_te	neo6_deinit_subsys (void)
	Deinitializes the NEO-6 subsystem.
ERR_te	neo6_start_subsys (void)
	Starts the NEO-6 subsystem.
ERR_te	neo6_stop_subsys (void)
	Stops the NEO-6 subsystem.
ERR_te	neo6_init_handle (NEO6_CFG_ts *neo6_cfg, NEO6_HANDLE_ts **neo6_handle_o)
	Initializes the NEO-6 hardware handle.
ERR_te	neo6_run (void)
	Processes received NMEA data. Must be called periodically.
ERR_te	neo6_get_info (NEO6_INFO_ts **neo6_info_o)
	Returns a pointer to the internal GPS data structure.

Detailed Description

Public functions to interact with the NEO-6 GPS subsystem.

Function Documentation

neo6_init_subsys()

ERR_te neo6_init_subsys

(

void

)

Initializes the NEO-6 subsystem.

Resets the internal state, initializes the USART receive circular buffers, initializes the logging dependency, and registers the CLI commands.

Must be called before any other NEO-6 API function.

Returns

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

See also

neo6_init_subsys

Definition at line 205 of file neo6.c.

                              {
    ERR_te err;
 
    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_NEO6;
    internal_state.usart_data_recv_cbuf.ptr = usart_data_recv_cbuf_mem;
    internal_state.usart_data_recv_cbuf.size = sizeof(usart_data_recv_cbuf_mem);
    internal_state.nmea_cbuf.ptr = nmea_cbuf_mem;
    internal_state.nmea_cbuf.size = sizeof(nmea_cbuf_mem);
    internal_state.dump_raw_nmea = false;
    internal_state.initialized = true;
    internal_state.started = false;
 
    init_log();
 
    err = cmd_register(&neo6_cmd_client_info);
    if(err != ERR_OK) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "neo6_init_subsys: cmd_register error"
        );
 
        return err;
    }
 
    LOG_INFO(
        internal_state.subsys,
        internal_state.log_level,
        "neo6_init_subsys: subsys initialized"
    );
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_deinit_subsys()

ERR_te neo6_deinit_subsys

(

void

)

Deinitializes the NEO-6 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
• Propagated error from cmd_deregister on failure

See also

neo6_deinit_subsys

Definition at line 246 of file neo6.c.

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

Here is the call graph for this function:

neo6_start_subsys()

ERR_te neo6_start_subsys

(

void

)

Starts the NEO-6 subsystem.

Returns

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

See also

neo6_start_subsys

Definition at line 274 of file neo6.c.

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

Here is the caller graph for this function:

neo6_stop_subsys()

ERR_te neo6_stop_subsys

(

void

)

Stops the NEO-6 subsystem.

Returns

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

See also

neo6_stop_subsys

Definition at line 298 of file neo6.c.

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

neo6_init_handle()

ERR_te neo6_init_handle	(	NEO6_CFG_ts *	neo6_cfg,
		NEO6_HANDLE_ts **	neo6_handle_o )

Initializes the NEO-6 hardware handle.

Configures the USART peripheral with interrupt-driven reception and initializes both the RX and TX GPIO pins in alternate function mode.

Note

Only one handle instance is supported. Calling this function a second time without deinitialization returns an error.

Parameters

[in]	neo6_cfg	Pointer to the NEO-6 configuration structure.
[out]	neo6_handle_o	Pointer to a handle pointer that will be set to the initialized instance.

Returns

• ERR_OK on success
• ERR_INITIALIZATION_FAILURE if a handle is already initialized, or if the USART or GPIO pointers in neo6_cfg are NULL

See also

neo6_init_handle

Definition at line 322 of file neo6.c.

                                                                               {
    if(internal_state.neo6_handle.initialized == true) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "neo6_init_handle: handle already initialized"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    if(neo6_cfg->usart_instance == (void*)0) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "neo6_init_handle: No USART peripheral given"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
    else if(neo6_cfg->rx_gpio_port == (void*)0 || neo6_cfg->tx_gpio_port == (void*)0) {
        LOG_ERROR(
            internal_state.subsys,
            internal_state.log_level,
            "neo6_init_handle: No GPIO peripheral given"
        );
 
        return ERR_INITIALIZATION_FAILURE;
    }
 
    internal_state.neo6_handle.usart_instance = neo6_cfg->usart_instance;
    internal_state.neo6_handle.usart_baud_rate = neo6_cfg->usart_baud_rate;
    internal_state.neo6_handle.rx_gpio_port = neo6_cfg->rx_gpio_port;
    internal_state.neo6_handle.tx_gpio_port = neo6_cfg->tx_gpio_port;
    internal_state.neo6_handle.rx_gpio_pin = neo6_cfg->rx_gpio_pin;
    internal_state.neo6_handle.tx_gpio_pin = neo6_cfg->tx_gpio_pin;
    internal_state.neo6_handle.gpio_alternate_function = neo6_cfg->gpio_alternate_function;
 
    USART_CFG_ts neo6_usart = { 0 };
    neo6_usart.instance = neo6_cfg->usart_instance;
    neo6_usart.baud_rate = neo6_cfg->usart_baud_rate;
    neo6_usart.interrupt_en = USART_INTERRUPT_EN_TRUE;
    usart_init(&neo6_usart);
    usart_set_reception(neo6_usart.instance, ENABLE);
 
    GPIO_CFG_ts neo6_rx = { 0 };
    neo6_rx.port = neo6_cfg->rx_gpio_port;
    neo6_rx.pin = neo6_cfg->rx_gpio_pin;
    neo6_rx.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    neo6_rx.alternate_function = neo6_cfg->gpio_alternate_function;
    gpio_init(&neo6_rx);
 
    GPIO_CFG_ts neo6_tx = { 0 };
    neo6_tx.port = neo6_cfg->tx_gpio_port;
    neo6_tx.pin = neo6_cfg->tx_gpio_pin;
    neo6_tx.mode = GPIO_MODE_ALTERNATE_FUNCTION;
    neo6_tx.alternate_function = neo6_cfg->gpio_alternate_function;
    gpio_init(&neo6_tx);
 
    internal_state.neo6_handle.initialized = true;
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_run()

ERR_te neo6_run

(

void

)

Processes received NMEA data. Must be called periodically.

Drains bytes from the USART receive circular buffer into the NMEA accumulation buffer. Each time a newline character is detected, the complete sentence is extracted, its checksum is verified, and it is dispatched to the appropriate parser (RMC, VTG, GGA, GSA, or GSV).

Parsed values are written directly into the internal NEO6_INFO_ts structure and are accessible via neo6_get_info.

Note

Known limitation: if a received chunk contains the end of one sentence and the start of the next, the second sentence is lost. This does not currently cause observable issues.

Returns

• ERR_OK on success
• ERR_DATA_ACQUISITION_FAILURE if a sentence fails its checksum verification
• ERR_UNKNOWN if a checksum cannot be computed (malformed sentence)

Processes received NMEA data. Must be called periodically.

See also

neo6_run

Definition at line 387 of file neo6.c.

                      {
    uint8_t data_len = 0;
    cbuf_len(&internal_state.usart_data_recv_cbuf, &data_len);
 
    if(data_len) {
        uint8_t data[data_len];
 
        cbuf_read(&internal_state.usart_data_recv_cbuf, data);
 
        cbuf_write(&internal_state.nmea_cbuf, data, data_len);
 
        for(uint32_t i = 0; i < data_len; i++) {
            if(data[i] == '\n') {
                uint8_t nmea_len = 0;
                cbuf_len(&internal_state.nmea_cbuf, &nmea_len);
 
                uint8_t nmea_msg[nmea_len];
                cbuf_read(&internal_state.nmea_cbuf, nmea_msg);
 
                nmea_msg[nmea_len - 2] = '\0';
                nmea_msg[nmea_len - 1] = '\0';
 
                if(internal_state.dump_raw_nmea == true) {
                    LOG_INFO(
                        internal_state.subsys,
                        internal_state.log_level,
                        "%s", nmea_msg
                    );
                }
 
                // Process NMEA message
                ERR_te err = neo6_process_msg(nmea_msg, nmea_len);
                if(err != ERR_OK) {
                    return err;
                }
            }
        }
    }
 
    return ERR_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

neo6_get_info()

ERR_te neo6_get_info

(

NEO6_INFO_ts **

neo6_info_o

)

Returns a pointer to the internal GPS data structure.

The returned pointer is valid for the lifetime of the subsystem. The structure is updated in place on each successful NMEA parse. The caller must not free or modify the returned pointer.

Parameters

[out]

neo6_info_o

Pointer to a pointer that will be set to the internal NEO6_INFO_ts structure.

Returns

• ERR_OK always

See also

neo6_get_info

Definition at line 430 of file neo6.c.

                                                 {
    *neo6_info_o = &internal_state.neo6_info;
 
    return ERR_OK;
}

Here is the caller graph for this function: