Beginner
10 min
0

Deliver exact location details with Teseo-LIV3FL and STM32F100ZE

Accurate, reliable, and always on target

GNSS 6 Click with UNI Clicker

Published Dec 10, 2023

Click board™

GNSS 6 Click

Development board

UNI Clicker

Compiler

NECTO Studio

MCU

STM32F100ZE

Determine and provide accurate location information for applications such as navigation and mapping

A

A

Hardware Overview

How does it work?

GNSS 6 Click is based on the Teseo-LIV3FL, a tiny low-power GNSS module from STMicroelectronics. It supports all the GNSS constellations, and the user can select the active constellations in the firmware configuration. By default, active GNSS constellations are GPS and Glonass. The module supports SBAS as a system that provides differential GPS correction data. It also supports differential GPS that improves position accuracy. The other features are Assisted GNSS, ST-assisted GPS, predictive AGNSS, real-time AGPS, and more. In addition, the module comes equipped with an embedded flash that can be used for data logging and FW upgrades. GNSS 6 Click is equipped with the SMA antenna connector, which can connect

the appropriate active antenna for improved range and received signal strength. For improved reception, there are filters but also the BGA824N6, a silicon germanium low-noise amplifier for GNSS from Infineon. The RF output of this amplifier is internally matched to 50Ohm. The antenna can be switched off over the TPS22943, a low-input-voltage current-limited load switch from Texas Instruments. The Teseo-LIV3FL module has a backup supply option on this Click board™ available as an onboard VCC input or over the coin battery. GNSS 6 Click uses a standard 2-Wire UART interface to communicate with the host MCU, supporting much of the functionality of the industry-standard 16C650 UART. In addition, the

module includes an I2C interface, supporting normal and fast speed with up to 400kHz of clock frequency. Both interfaces support the NMEA protocol. The time output pulse is available as a PPS LED indication and over the PPS pin. You can wake the module from the software standby over the WUP pin, while the RST pin is a standard reset pin for the GNSS module. This Click board™ can be operated only with a 3.3V logic voltage level. The board must perform appropriate logic voltage level conversion before using MCUs with different logic levels. Also, it comes equipped with a library containing functions and an example code that can be used as a reference for further development.

GNSS 6 Click hardware overview image

Features overview

Development board

UNI Clicker is a compact development board designed as a complete solution that brings the flexibility of add-on Click boards™ to your favorite microcontroller, making it a perfect starter kit for implementing your ideas. It supports a wide range of microcontrollers, such as different ARM, PIC32, dsPIC, PIC, and AVR from various vendors like Microchip, ST, NXP, and TI (regardless of their number of pins), four mikroBUS™ sockets for Click board™ connectivity, a USB connector, LED indicators, buttons, a debugger/programmer connector, and two 26-pin headers for interfacing with external electronics. Thanks to innovative manufacturing technology, it allows you to build

gadgets with unique functionalities and features quickly. Each part of the UNI Clicker development kit contains the components necessary for the most efficient operation of the same board. In addition to the possibility of choosing the UNI Clicker programming method, using a third-party programmer or CODEGRIP/mikroProg connected to onboard JTAG/SWD header, the UNI Clicker board also includes a clean and regulated power supply module for the development kit. It provides two ways of board-powering; through the USB Type-C (USB-C) connector, where onboard voltage regulators provide the appropriate voltage levels to each component on the board, or using a Li-Po/Li

Ion battery via an onboard battery connector. All communication methods that mikroBUS™ itself supports are on this board (plus USB HOST/DEVICE), including the well-established mikroBUS™ socket, a standardized socket for the MCU card (SiBRAIN standard), and several user-configurable buttons and LED indicators. UNI Clicker is an integral part of the Mikroe ecosystem, allowing you to create a new application in minutes. Natively supported by Mikroe software tools, it covers many aspects of prototyping thanks to a considerable number of different Click boards™ (over a thousand boards), the number of which is growing every day.

UNI clicker double image

Microcontroller Overview

MCU Card / MCU

default

Type

8th Generation

Architecture

ARM Cortex-M3

MCU Memory (KB)

512

Silicon Vendor

STMicroelectronics

Pin count

144

RAM (Bytes)

32768

You complete me!

Accessories

GNSS L-Band Active Antenna (LBAND01D-S6-00) is an active patch 50Ω antenna from Inpaq Technology that supports GNSS L-Band (frequency range from 1525 up to 1559MHz) applications. It offers excellent performance with its high gain and efficiency for tracking, fleet management, navigation, and many other tracking applications. The magnetic mounting type antenna, with dimensions of 37.5x34.5x12.5mm, connects to the device by a 3m long cable with an SMA PLUG male connector. It provides superior performance when coupled with Click boards™ that require highly accurate location abilities such as RTK.

GNSS 6 Click accessories image

Used MCU Pins

mikroBUS™ mapper

NC
NC
AN
Reset
PE13
RST
ID COMM
PD11
CS
NC
NC
SCK
NC
NC
MISO
NC
NC
MOSI
Power Supply
3.3V
3.3V
Ground
GND
GND
Module Wake-Up
PD12
PWM
Timepulse Output
PG6
INT
UART TX
PB6
TX
UART RX
PB7
RX
I2C Clock
PB8
SCL
I2C Data
PB9
SDA
NC
NC
5V
Ground
GND
GND
1

Take a closer look

Schematic

GNSS 6 Click Schematic schematic

Step by step

Project assembly

UNI Clicker front image hardware assembly

Start by selecting your development board and Click board™. Begin with the UNI Clicker as your development board.

UNI Clicker front image hardware assembly
GNSS2 Click front image hardware assembly
SiBRAIN for STM32F745VG front image hardware assembly
Prog-cut hardware assembly
GNSS2 Click complete accessories setup image hardware assembly
UNI Clicker Access MB 1 - upright/background hardware assembly
Necto image step 2 hardware assembly
Necto image step 3 hardware assembly
Necto image step 4 hardware assembly
Necto image step 5 hardware assembly
Necto image step 6 hardware assembly
Necto image step 7 hardware assembly
Necto No Display image step 8 hardware assembly
Necto image step 9 hardware assembly
Necto image step 10 hardware assembly
Debug Image Necto Step hardware assembly

Track your results in real time

Application Output

After loading the code example, pressing the "DEBUG" button builds and programs it on the selected setup.

Application Output Step 1

After programming is completed, a header with buttons for various actions available in the IDE appears. By clicking the green "PLAY "button, we start reading the results achieved with Click board™.

Application Output Step 3

Upon completion of programming, the Application Output tab is automatically opened, where the achieved result can be read. In case of an inability to perform the Debug function, check if a proper connection between the MCU used by the setup and the CODEGRIP programmer has been established. A detailed explanation of the CODEGRIP-board connection can be found in the CODEGRIP User Manual. Please find it in the RESOURCES section.

Application Output Step 4

Software Support

Library Description

This library contains API for GNSS 6 Click driver.

Key functions:

  • gnss6_generic_read - This function reads a desired number of data bytes from the module.

  • gnss6_reset_device - This function resets the device by toggling the RST pin.

  • gnss6_parse_gpgga - This function parses the GPGGA data from the read response buffer.

Open Source

Code example

This example can be found in NECTO Studio. Feel free to download the code, or you can copy the code below.

/*!
 * @file main.c
 * @brief GNSS 6 Click example
 *
 * # Description
 * This example demonstrates the use of GNSS 6 click by reading and displaying
 * the GNSS coordinates.
 *
 * The demo application is composed of two sections :
 *
 * ## Application Init
 * Initializes the driver and resets the click board.
 *
 * ## Application Task
 * Reads the received data, parses the GPGGA info from it, and once it receives the position fix
 * it will start displaying the coordinates on the USB UART.
 *
 * ## Additional Function
 * - static void gnss6_clear_app_buf ( void )
 * - static err_t gnss6_process ( gnss6_t *ctx )
 * - static void gnss6_parser_application ( uint8_t *rsp )
 *
 * @author Stefan Filipovic
 *
 */

#include "board.h"
#include "log.h"
#include "gnss6.h"

#define PROCESS_BUFFER_SIZE 300

static gnss6_t gnss6;
static log_t logger;

static uint8_t app_buf[ PROCESS_BUFFER_SIZE ] = { 0 };
static int32_t app_buf_len = 0;

/**
 * @brief GNSS 6 clearing application buffer.
 * @details This function clears memory of application buffer and reset its length and counter.
 * @return None.
 * @note None.
 */
static void gnss6_clear_app_buf ( void );

/**
 * @brief GNSS 6 data reading function.
 * @details This function reads data from device and concatenates data to application buffer.
 * @param[in] ctx : Click context object.
 * See #gnss6_t object definition for detailed explanation.
 * @return @li @c  0 - Read some data.
 *         @li @c -1 - Nothing is read or Application buffer overflow.
 * See #err_t definition for detailed explanation.
 * @note None.
 */
static err_t gnss6_process ( gnss6_t *ctx );

/**
 * @brief GNSS 6 parser application.
 * @param[in] rsp Response buffer.
 * @details This function logs GNSS data on the USB UART.
 * @return None.
 * @note None.
 */
static void gnss6_parser_application ( uint8_t *rsp );

void application_init ( void )
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    gnss6_cfg_t gnss6_cfg;  /**< Click config object. */

    /** 
     * Logger initialization.
     * Default baud rate: 115200
     * Default log level: LOG_LEVEL_DEBUG
     * @note If USB_UART_RX and USB_UART_TX 
     * are defined as HAL_PIN_NC, you will 
     * need to define them manually for log to work. 
     * See @b LOG_MAP_USB_UART macro definition for detailed explanation.
     */
    LOG_MAP_USB_UART( log_cfg );
    log_init( &logger, &log_cfg );
    log_info( &logger, " Application Init " );

    // Click initialization.
    gnss6_cfg_setup( &gnss6_cfg );
    GNSS6_MAP_MIKROBUS( gnss6_cfg, MIKROBUS_1 );
    err_t init_flag = gnss6_init( &gnss6, &gnss6_cfg );
    if ( ( UART_ERROR == init_flag ) || ( I2C_MASTER_ERROR == init_flag ) )
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }
    
    log_info( &logger, " Application Task " );
}

void application_task ( void )
{
    if ( GNSS6_OK == gnss6_process( &gnss6 ) )
    {
        if ( PROCESS_BUFFER_SIZE == app_buf_len )
        {
            gnss6_parser_application( app_buf );
        }
    }
}

int main ( void ) 
{
    application_init( );
    
    for ( ; ; ) 
    {
        application_task( );
    }

    return 0;
}

static void gnss6_clear_app_buf ( void ) 
{
    memset( app_buf, 0, app_buf_len );
    app_buf_len = 0;
}

static err_t gnss6_process ( gnss6_t *ctx ) 
{
    int32_t rx_size = 0;
    uint8_t rx_buf[ PROCESS_BUFFER_SIZE ] = { 0 };
    if ( GNSS6_DRV_SEL_UART == ctx->drv_sel )
    {
        rx_size = gnss6_generic_read( ctx, rx_buf, PROCESS_BUFFER_SIZE );
    }
    else
    {
        if ( GNSS6_OK == gnss6_generic_read( ctx, rx_buf, 1 ) )
        {
            if ( GNSS6_DUMMY != rx_buf[ 0 ] )
            {
                rx_size = 1;
            }
        }
    }
    if ( rx_size > 0 ) 
    {
        int32_t buf_cnt = app_buf_len;
        if ( ( ( app_buf_len + rx_size ) > PROCESS_BUFFER_SIZE ) && ( app_buf_len > 0 ) ) 
        {
            buf_cnt = PROCESS_BUFFER_SIZE - ( ( app_buf_len + rx_size ) - PROCESS_BUFFER_SIZE );
            memmove ( app_buf, &app_buf[ PROCESS_BUFFER_SIZE - buf_cnt ], buf_cnt );
        }
        for ( int32_t rx_cnt = 0; rx_cnt < rx_size; rx_cnt++ ) 
        {
            if ( rx_buf[ rx_cnt ] ) 
            {
                app_buf[ buf_cnt++ ] = rx_buf[ rx_cnt ];
                if ( app_buf_len < PROCESS_BUFFER_SIZE )
                {
                    app_buf_len++;
                }
            }
        }
        return GNSS6_OK;
    }
    return GNSS6_ERROR;
}

static void gnss6_parser_application ( uint8_t *rsp )
{
    uint8_t element_buf[ 100 ] = { 0 };
    if ( GNSS6_OK == gnss6_parse_gpgga( rsp, GNSS6_GPGGA_LATITUDE, element_buf ) )
    {
        static uint8_t wait_for_fix_cnt = 0;
        if ( ( strlen( element_buf ) > 0 ) && ( !strstr ( element_buf, GNSS6_RSP_NO_FIX ) ) )
        {
            log_printf( &logger, "\r\n Latitude: %.2s degrees, %s minutes \r\n", element_buf, &element_buf[ 2 ] );
            gnss6_parse_gpgga( rsp, GNSS6_GPGGA_LONGITUDE, element_buf );
            log_printf( &logger, " Longitude: %.3s degrees, %s minutes \r\n", element_buf, &element_buf[ 3 ] );
            memset( element_buf, 0, sizeof( element_buf ) );
            gnss6_parse_gpgga( rsp, GNSS6_GPGGA_ALTITUDE, element_buf );
            log_printf( &logger, " Altitude: %s m \r\n", element_buf );
            wait_for_fix_cnt = 0;
        }
        else
        {
            if ( wait_for_fix_cnt % 5 == 0 )
            {
                log_printf( &logger, " Waiting for the position fix...\r\n\n" );
                wait_for_fix_cnt = 0;
            }
            wait_for_fix_cnt++;
        }
        gnss6_clear_app_buf(  );
    }
}

// ------------------------------------------------------------------------ END

Additional Support

Resources