使用EG91NAXDGA-128-SGNS和STM32L073RZ确保在各种北美M2M应用中实现可靠的4G (LTE)蜂窝网络连接

符合3GPP Release 11标准的LTE Cat.1物联网解决方案

LTE Cat.1 3 Click (for North America) with Nucleo-64 with STM32L073RZ MCU

已发布 7月 29, 2024

点击板

LTE Cat.1 3 Click (for North America)

开发板

Nucleo-64 with STM32L073RZ MCU

编译器

NECTO Studio

微控制器单元

STM32L073RZ

使用 LTE Cat 1 标准在北美建立用于数据传输的蜂窝网络连接，以实现 M2M 应用

硬件概览

它是如何工作的？

LTE Cat.1 3 Click（北美版）基于Quectel的EG91NAXDGA-128-SGNS，这是一个具备接收分集功能的数据专用4G无线通信模块。该模块支持多种无线通信标准，包括LTE-FDD和WCDMA，提供跨多种网络的可靠数据连接。该模块还能提供语音功能（车联网版本支持语音和数据功能），旨在满足客户的特定需求。LTE Cat.1 3 Click支持多个LTE频段（B2/B4/B5/B12/B13/B25/B26）和频段B2、B4、B5的接收分集。此外，它还支持多星座GNSS，包括GPS、GLONASS、北斗/Compass、Galileo和QZSS。它完全集成了TCP、UDP和PPP等互联网服务协议，易于使用扩展AT命令。此Click板™几乎满足M2M应用的所有要求，例如汽车、智能计量、跟踪系统、安全、路由器、无线POS等。EG91NAXDGA-128-SGNS与主MCU之间的通信通过UART接口进行，使用标准的UART RX和TX引脚以及硬件流控制引脚（CTS/RTS/RI - 清除发送/准备发送/振铃指示器）以实现高效数据传输。模块的默认通信速度为115200bps，允许通过AT命令进行无缝数据交换。值得注意的是，此模块的车联网版本还具有音频接口，可通过I2C接口访问。LTE Cat.1 3 Click音频接口通过

MAX9860操作，MAX9860是一个可通过I2C接口配置的16位单声道音频语音编解码器。此设置与板背面的一个插孔配合使用，设计用于CTIA标准耳机，这些耳机通常用于现代智能手机，并具有组合音频和麦克风连接器。该标准确保与各种耳机和耳麦的兼容性。此外，音频接口支持高级功能，如回声消除和噪声抑制，增强语音通信的清晰度和质量。LTE Cat.1 3 Click还包括一个用于电源和数据传输的USB Type C连接器，符合USB 2.0规范（仅限从属）。此接口支持高达480Mbps的数据传输速率，便于AT命令通信、数据传输、GNSS NMEA语句输出、软件调试、固件升级和通过USB进行语音通信。板上带有一个USB FW升级开关，标记为USB BOOT，用于管理固件升级。此开关有0和1两个位置，0为正常操作，1为通过USB升级固件，确保简便的升级过程。此外，此Click板™包含若干增强其实用性和控制的附加功能。PWR按钮允许用户轻松打开或关闭模块，而RESET按钮提供快速重置模块的方式。这些功能还可以通过mikroBUS™引脚PWR和RST数字控制，提供更大的灵活性。此外，这些控制功能有专用的测试点，便于调试和测试。板上还具有两个视觉指示器，提供实时

状态更新。红色的NET LED提供网络活动反馈：在搜索网络时慢闪，在数据传输期间快闪，在语音通话期间保持常亮。黄色的STAT LED指示模块的电源状态，当模块关闭时熄灭，当模块通电时亮起。板上还包括DBG TX/RX接口测试点，用于调试UART通信，简化开发和故障排除过程。板上有三个u.Fl连接器，分别用于GNSS、LTE和LTE/WCDMA接收分集天线，MIKROE提供LTE平板旋转天线和主动GPS天线，以及IPEX-SMA电缆，以实现灵活高效的连接选项。此外，用户可以轻松选择GNSS天线的电源，通过在GNSS ANT跳线之间选择3.3V和5V。板上还配有一个微型SIM卡插槽，支持1.8V和3.0V uSIM卡，确保与广泛的蜂窝网络兼容，并允许用户选择最适合其特定使用情况的服务提供商。此Click板™可以通过VCC SEL跳线选择使用3.3V或5V逻辑电压水平。由于EG91NAXDGA-128-SGNS在3.8V下工作，还使用了TXB0106和PCA9306逻辑电平转换器以确保正常运行和精确的信号电平转换。这样，3.3V和5V的MCU都可以正确使用通信线路。此外，该Click板™配有一个包含易于使用的函数和示例代码的库，可用作进一步开发的参考。

LTE Cat.1 3 Click (for North America) hardware overview image

功能概述

开发板

Nucleo-64搭载STM32L073RZ MCU提供了一个经济实惠且灵活的平台，供开发人员探索新的想法并原型化其设计。该板利用了STM32微控制器的多功能性，使用户能够为其项目选择性能和功耗之间的最佳平衡。它采用LQFP64封装的STM32微控制器，并包括一些必要的组件，例如用户LED，可以同时作为ARDUINO®信号使用，以及用户和复位按钮，以及用于精准定时操作的32.768kHz晶体振荡器。设计时考虑了扩展性和灵活性，Nucleo-64板具有ARDUINO®

Uno V3扩展连接器和ST morpho扩展引脚标头，为全面项目集成提供了对STM32 I/O的完全访问权限。电源选项具有适应性，支持ST-LINK USB VBUS或外部电源，确保在各种开发环境中的适应性。该板还配备了一个内置的ST-LINK调试器/编程器，具有USB重新枚举功能，简化了编程和调试过程。此外，该板还设计了外部SMPS，以实现有效的Vcore逻辑供电，支持USB设备全速或USB SNK/UFP全速，以及内置的加密功能，增强了项目的功耗效率和安全性。通过专用

连接器提供了额外的连接性，用于外部SMPS实验、ST-LINK的USB连接器和MIPI®调试连接器，扩展了硬件接口和实验的可能性。开发人员将通过STM32Cube MCU软件包中全面的免费软件库和示例得到广泛的支持。这与与各种集成开发环境（IDE）的兼容性相结合，包括IAR Embedded Workbench®、MDK-ARM和STM32CubeIDE，确保了平稳高效的开发体验，使用户能够充分发挥Nucleo-64板在其项目中的功能。

Nucleo 64 with STM32L073RZ MCU double side image

微控制器概述

MCU卡片 / MCU

建筑

ARM Cortex-M0

MCU 内存 (KB)

192

硅供应商

STMicroelectronics

引脚数

RAM (字节)

20480

你完善了我！

配件

Click Shield for Nucleo-64 配备了两个专有的 mikroBUS™ 插座，使得所有的 Click board™ 设备都可以轻松地与 STM32 Nucleo-64 开发板连接。这样，Mikroe 允许其用户从不断增长的 Click boards™ 范围中添加任何功能，如 WiFi、GSM、GPS、蓝牙、ZigBee、环境传感器、LED、语音识别、电机控制、运动传感器等。您可以使用超过 1537 个 Click boards™，这些 Click boards™ 可以堆叠和集成。STM32 Nucleo-64 开发板基于 64 引脚封装的微控制器，采用 32 位 MCU，配备 ARM Cortex M4 处理器，运行速度为 84MHz，具有 512Kb Flash 和 96KB SRAM，分为两个区域，顶部区域代表 ST-Link/V2 调试器和编程器，而底部区域是一个实际的开发板。通过 USB 连接方便地控制和供电这些板子，以便直接对 Nucleo-64 开发板进行编程和高效调试，其中还需要额外的 USB 线连接到板子上的 USB 迷你接口。大多数 STM32 微控制器引脚都连接到了板子左右边缘的 IO 引脚上，然后连接到两个现有的 mikroBUS™ 插座上。该 Click Shield 还有几个开关，用于选择 mikroBUS™ 插座上模拟信号的逻辑电平和 mikroBUS™ 插座本身的逻辑电压电平。此外，用户还可以通过现有的双向电平转换器，使用任何 Click board™，无论 Click board™ 是否在 3.3V 或 5V 逻辑电压电平下运行。一旦将 STM32 Nucleo-64 开发板与我们的 Click Shield for Nucleo-64 连接，您就可以访问数百个工作于 3.3V 或 5V 逻辑电压电平的 Click boards™。

Click Shield for Nucleo-64 accessories 1 image

主动 GPS 天线旨在增强您的 GPS 和 GNSS Click 板™ 的性能。这款外置天线结构坚固，适用于各种天气条件。凭借 1575.42MHz 的频率范围和 50Ohm 的阻抗，它确保了可靠的信号接收。天线在较宽的角度范围内提供大于 -4dBic 的增益，确保超过 75% 的覆盖率。± 5MHz 的带宽进一步保证了精确的数据采集。天线采用右旋圆极化 (RHCP)，提供稳定的信号接收。其紧凑的尺寸为 48.5×39×15mm，配有 2 米长的电缆，安装方便。磁性天线类型与 SMA 公连接器确保了安全便捷的连接。如果您需要为定位设备提供可靠的外置天线，我们的主动 GPS 天线是完美的解决方案。

LTE Cat.1 3 Click (for Europe) accessories 1 image

LTE 平板旋转天线是提升 3G/4G LTE 设备性能的多功能选择。其宽频率范围为 700-2700MHz，确保在全球主要蜂窝频段上的最佳连接性。这款平板天线具有 SMA 公连接器，便于直接连接到您的设备或 SMA 模块连接器。其突出特点之一是可调角度，可按 45⁰ 增量设置（0⁰/45⁰/90⁰），允许您微调天线的方向以获得最佳信号接收。凭借 50Ω 的阻抗和 <2.0:1 的 VSW 比率，这款天线确保了可靠且高效的连接。其 5dB 增益、垂直极化和全向辐射模式增强了信号强度，适用于各种应用。天线尺寸为 196mm 长和 38mm 宽，提供紧凑且有效的连接解决方案。最大输入功率为 50W，能够满足各种设备的需求。

LTE Cat.1 3 Click (for Europe) accessories 2 image

IPEX-SMA 电缆是一种射频（RF）电缆组件。"IPEX" 指的是 IPEX 连接器，这是一种常用于小型电子设备中的微型同轴连接器。"SMA" 代表 SubMiniature Version A，是另一种常用于 RF 应用的同轴连接器。IPEX-SMA 电缆组件在一端具有 IPEX 连接器，另一端具有 SMA 连接器，使其能够连接使用这些特定连接器的设备或组件。这些电缆通常用于 WiFi 或蜂窝天线、GPS 模块以及其他需要可靠且低损耗连接的射频通信系统中的应用。

LTE Cat.1 3 Click (for Europe) accessories 3 image

使用的MCU引脚

mikroBUS™映射器

Module Power-ON

PC0

Reset / ID SEL

PC12

RST

UART RTS / ID COMM

PB12

SCK

MISO

MOSI

Power Supply

3.3V

Ground

GND

Ring Indicator

PC8

PWM

UART CTS

PC14

INT

UART TX

PA2

UART RX

PA3

I2C Clock

PB8

SCL

I2C Data

PB9

SDA

Power Supply

Ground

GND

“仔细看看！”

Click board™ 原理图

LTE Cat.1 3 Click (for North America) Schematic schematic

一步一步来

项目组装

Click Shield for Nucleo-64 accessories 1 image hardware assembly

从选择您的开发板和Click板™开始。以Nucleo-64 with STM32L073RZ MCU作为您的开发板开始。

Nucleo 64 with STM32F401RE MCU front image hardware assembly

LTE IoT 5 Click front image hardware assembly

LTE IoT 5 Click complete accessories setup image hardware assembly

Board mapper by product8 hardware assembly

Clicker 4 for STM32F4 HA MCU Step hardware assembly

Necto No Display image step 8 hardware assembly

Debug Image Necto Step hardware assembly

实时跟踪您的结果

应用程序输出

1. 应用程序输出 - 在调试模式下，“应用程序输出”窗口支持实时数据监控，直接提供执行结果的可视化。请按照提供的教程正确配置环境，以确保数据正确显示。

2. UART 终端 - 使用UART Terminal通过USB to UART converter监视数据传输，实现Click board™与开发系统之间的直接通信。请根据项目需求配置波特率和其他串行设置，以确保正常运行。有关分步设置说明，请参考提供的教程。

3. Plot 输出 - Plot功能提供了一种强大的方式来可视化实时传感器数据，使趋势分析、调试和多个数据点的对比变得更加直观。要正确设置，请按照提供的教程，其中包含使用Plot功能显示Click board™读数的分步示例。在代码中使用Plot功能时，请使用以下函数：plot(insert_graph_name, variable_name);。这是一个通用格式，用户需要将“insert_graph_name”替换为实际图表名称，并将“variable_name”替换为要显示的参数。

软件支持

库描述

该库包含 LTE Cat.1 3 Click (for North America) 驱动程序的 API。

Key functions:

ltecat13nax_write_register - 此功能将数据字节写入选定的寄存器地址。
ltecat13nax_max9860_cfg - 此功能用于设置 LTE Cat.1 3 Click 板上 MAX9860 的基本配置。
ltecat13nax_send_sms_pdu - 此功能以 PDU 模式发送短信到手机号码。

开源

代码示例

完整的应用程序代码和一个现成的项目可以通过NECTO Studio包管理器直接安装到NECTO Studio。应用程序代码也可以在MIKROE的GitHub账户中找到。

/*!
 * @file main.c
 * @brief LTE Cat.1 3 NAX Click Example.
 *
 * # Description
 * Application example shows device capability of connecting to the network and 
 * sending SMS, TCP/UDP messages, calling the selected number, or getting GNSS location
 * using standard "AT" commands. 
 *
 * The demo application is composed of two sections :
 *
 * ## Application Init
 * Sets the device configuration for sending SMS, TCP/UDP messages, calling the selected number
 * or GNSS location.
 *
 * ## Application Task
 * Depending on the selected demo example, it sends an SMS message 
 * (in PDU or TXT mode) or a TCP/UDP message, calls the selected number or
 * gets GNSS location.
 *
 * ## Additional Function
 * - static void ltecat13nax_clear_app_buf ( void )
 * - static void ltecat13nax_log_app_buf ( void )
 * - static err_t ltecat13nax_process ( ltecat13nax_t *ctx )
 * - static void ltecat13nax_error_check( err_t error_flag )
 * - static void ltecat13nax_log_app_buf ( void )
 * - static err_t ltecat13nax_rsp_check ( uint8_t *rsp )
 * - static err_t ltecat13nax_cfg_for_network ( void )
 * - static err_t ltecat13nax_check_connection ( void )
 * - static err_t ltecat13nax_cfg_for_example ( void )
 * - static err_t ltecat13nax_example( void )
 * - static void gnss_parser_application ( char *rsp )
 *
 * @note
 * In order for the examples to work, user needs to set the APN and SMSC (SMS PDU mode only)
 * of entered SIM card as well as the phone number (SMS mode only) to which he wants to send an SMS.
 * Enter valid values for the following macros: SIM_APN, SIM_SMSC and PHONE_NUMBER_TO_MESSAGE.
 * Example:
    SIM_APN "internet"
    SIM_SMSC "+381610401"
    PHONE_NUMBER_TO_MESSAGE "+381659999999"
 *
 * @author Stefan Ilic 
 *
 */

#include "board.h"
#include "log.h"
#include "ltecat13nax.h"
#include "generic_pointer.h"
#include "conversions.h"

// Example selection macros
#define EXAMPLE_TCP_UDP                     0               // Example of sending messages to a TCP/UDP echo server
#define EXAMPLE_SMS                         1               // Example of sending SMS to a phone number
#define EXAMPLE_CALL                        2               // Example of calling selected phone number
#define EXAMPLE_GNSS                        3               // Example of getting GNSS location
#define DEMO_EXAMPLE                        EXAMPLE_TCP_UDP // Example selection macro

// SIM APN config
#define SIM_APN                             "internet"      // Set valid SIM APN

// SMS/CALL example parameters
#define SIM_SMSC                            ""              // Set valid SMS Service Center Address - only in SMS PDU mode
#define PHONE_NUMBER                        ""              // Set Phone number to message or call
#define SMS_MODE                            "0"             // SMS mode: "0" - PDU, "1" - TXT

// TCP/UDP example parameters
#define REMOTE_IP                           "77.46.162.162" // TCP/UDP echo server IP address
#define REMOTE_PORT                         "51111"         // TCP/UDP echo server port

// Message content
#define MESSAGE_CONTENT                     "LTE Cat.1 3 NAX Click board - demo example."

// Application buffer size
#define APP_BUFFER_SIZE                     500
#define PROCESS_BUFFER_SIZE                 200

/**
 * @brief Example states.
 * @details Predefined enum values for application example state.
 */
typedef enum
{
    LTECAT13NAX_CONFIGURE_FOR_NETWORK = 1,
    LTECAT13NAX_WAIT_FOR_CONNECTION,
    LTECAT13NAX_CONFIGURE_FOR_EXAMPLE,
    LTECAT13NAX_EXAMPLE

} ltecat13nax_example_state_t;

static ltecat13nax_t ltecat13nax;
static log_t logger;

static uint8_t app_buf[ APP_BUFFER_SIZE ] = { 0 };
static uint8_t gnss_info_message[ 200 ] = { 0 };
static int32_t app_buf_len = 0;
static err_t error_flag;
static ltecat13nax_example_state_t example_state;

/**
 * @brief LTE Cat.1 3 NAX clearing application buffer.
 * @details This function clears memory of application buffer and reset its length.
 * @note None.
 */
static void ltecat13nax_clear_app_buf ( void );

/**
 * @brief LTE Cat.1 3 NAX log application buffer.
 * @details This function logs data from application buffer to USB UART.
 * @note None.
 */
static void ltecat13nax_log_app_buf ( void );

/**
 * @brief LTE Cat.1 3 NAX data reading function.
 * @details This function reads data from device and concatenates data to application buffer. 
 * @param[in] ctx : Click context object.
 * See #ltecat13nax_t object definition for detailed explanation.
 * @return @li @c  0 - Read some data.
 *         @li @c -1 - Nothing is read.
 * See #err_t definition for detailed explanation.
 * @note None.
 */
static err_t ltecat13nax_process ( void );

/**
 * @brief Check for errors.
 * @details This function checks for different types of
 * errors and logs them on UART or logs the response if no errors occured.
 * @param[in] error_flag  Error flag to check.
 */
static void ltecat13nax_error_check( err_t error_flag );

/**
 * @brief Logs application buffer.
 * @details This function logs data from application buffer.
 */
static void ltecat13nax_log_app_buf ( void );

/**
 * @brief Response check.
 * @details This function checks for response and
 * returns the status of response.
 * @param[in] rsp  Expected response.
 * @return @li @c  0 - OK response.
 *         @li @c -2 - Timeout error.
 *         @li @c -3 - Command error.
 *         @li @c -4 - Unknown error.
 * See #err_t definition for detailed explanation.
 */
static err_t ltecat13nax_rsp_check ( uint8_t *rsp );

/**
 * @brief Configure device for connection to the network.
 * @details Sends commands to configure and enable
 * connection to the specified network.
 * @return @li @c  0 - OK response.
 *         @li @c -2 - Timeout error.
 *         @li @c -3 - Command error.
 *         @li @c -4 - Unknown error.
 * See #err_t definition for detailed explanation.
 */
static err_t ltecat13nax_cfg_for_network ( void );

/**
 * @brief Wait for connection signal.
 * @details Wait for connection signal from CREG URC.
 * @return @li @c  0 - OK response.
 *         @li @c -2 - Timeout error.
 *         @li @c -3 - Command error.
 *         @li @c -4 - Unknown error.
 * See #err_t definition for detailed explanation.
 */
static err_t ltecat13nax_check_connection ( void );

/**
 * @brief Configure device for example.
 * @details Configure device for the specified example.
 * @return @li @c  0 - OK response.
 *         @li @c -2 - Timeout error.
 *         @li @c -3 - Command error.
 *         @li @c -4 - Unknown error.
 * See #err_t definition for detailed explanation.
 */
static err_t ltecat13nax_cfg_for_example ( void );

/**
 * @brief Execute example.
 * @details This function executes SMS, TCP/UDP or CALL example depending on the DEMO_EXAMPLE macro.
 * @return @li @c  0 - OK response.
 *         @li @c -2 - Timeout error.
 *         @li @c -3 - Command error.
 *         @li @c -4 - Unknown error.
 * See #err_t definition for detailed explanation.
 */
static err_t ltecat13nax_example( void );

/**
 * @brief GNSS parser application.
 * @details This function logs GNSS data on the USB UART and stores data in gnss_info_message buffer.
 * @param rsp Response buffer.
 * @note None.
 */
static void gnss_parser_application ( char *rsp ) ;

void application_init ( void ) 
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    ltecat13nax_cfg_t ltecat13nax_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.
    ltecat13nax_cfg_setup( &ltecat13nax_cfg );
    LTECAT13NAX_MAP_MIKROBUS( ltecat13nax_cfg, MIKROBUS_1 );
    if ( UART_ERROR == ltecat13nax_init( &ltecat13nax, &ltecat13nax_cfg ) ) 
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }
    
    ltecat13nax_process( );
    ltecat13nax_clear_app_buf( );
    Delay_ms ( 1000 );

    if ( 0 == ltecat13nax_get_ri_pin( &ltecat13nax ) )
    {
        ltecat13nax_start_up( &ltecat13nax );
        error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_RDY );
        ltecat13nax_error_check( error_flag );
    }

    // Restart device
    #define MIN_FUN_DEVICE "0"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_CFUN, MIN_FUN_DEVICE );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    ltecat13nax_error_check( error_flag );

    #define FULL_FUN_DEVICE "1"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_CFUN, FULL_FUN_DEVICE );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    ltecat13nax_error_check( error_flag );
    
    // Check communication
    ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_AT );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    ltecat13nax_error_check( error_flag );
    
    log_info( &logger, " Application Task " );
    example_state = LTECAT13NAX_CONFIGURE_FOR_NETWORK;
}

void application_task ( void ) 
{
    switch ( example_state )
    {
        case LTECAT13NAX_CONFIGURE_FOR_NETWORK:
        {
            if ( LTECAT13NAX_OK == ltecat13nax_cfg_for_network( ) )
            {
                example_state = LTECAT13NAX_WAIT_FOR_CONNECTION;
            }
            break;
        }
        case LTECAT13NAX_WAIT_FOR_CONNECTION:
        {
            if ( LTECAT13NAX_OK == ltecat13nax_check_connection( ) )
            {
                example_state = LTECAT13NAX_CONFIGURE_FOR_EXAMPLE;
            }
            break;
        }
        case LTECAT13NAX_CONFIGURE_FOR_EXAMPLE:
        {
            if ( LTECAT13NAX_OK == ltecat13nax_cfg_for_example( ) )
            {
                example_state = LTECAT13NAX_EXAMPLE;
            }
            break;
        }
        case LTECAT13NAX_EXAMPLE:
        {
            ltecat13nax_example( );
            break;
        }
        default:
        {
            log_error( &logger, " Example state." );
            break;
        }
    }
}

int main ( void ) 
{
    /* Do not remove this line or clock might not be set correctly. */
    #ifdef PREINIT_SUPPORTED
    preinit();
    #endif
    
    application_init( );
    
    for ( ; ; ) 
    {
        application_task( );
    }

    return 0;
}

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

static void ltecat13nax_log_app_buf ( void )
{
    for ( int32_t buf_cnt = 0; buf_cnt < app_buf_len; buf_cnt++ )
    {
        log_printf( &logger, "%c", app_buf[ buf_cnt ] );
    }
    log_printf( &logger, "============================\r\n" );
}

static err_t ltecat13nax_process ( void ) 
{
    uint8_t rx_buf[ PROCESS_BUFFER_SIZE ] = { 0 };
    int32_t overflow_bytes = 0;
    int32_t rx_cnt = 0;
    int32_t rx_size = ltecat13nax_generic_read( &ltecat13nax, rx_buf, PROCESS_BUFFER_SIZE );
    if ( ( rx_size > 0 ) && ( rx_size <= APP_BUFFER_SIZE ) ) 
    {
        if ( ( app_buf_len + rx_size ) > APP_BUFFER_SIZE ) 
        {
            overflow_bytes = ( app_buf_len + rx_size ) - APP_BUFFER_SIZE;
            app_buf_len = APP_BUFFER_SIZE - rx_size;
            memmove ( app_buf, &app_buf[ overflow_bytes ], app_buf_len );
            memset ( &app_buf[ app_buf_len ], 0, overflow_bytes );
        }
        for ( rx_cnt = 0; rx_cnt < rx_size; rx_cnt++ ) 
        {
            if ( rx_buf[ rx_cnt ] ) 
            {
                app_buf[ app_buf_len++ ] = rx_buf[ rx_cnt ];
            }
        }
        return LTECAT13NAX_OK;
    }
    return LTECAT13NAX_ERROR;
}

static err_t ltecat13nax_rsp_check ( uint8_t *rsp )
{
    uint32_t timeout_cnt = 0;
    uint32_t timeout = 10000;
    err_t error_flag = ltecat13nax_process( );
    if ( ( LTECAT13NAX_OK != error_flag ) && ( LTECAT13NAX_ERROR != error_flag ) )
    {
        return error_flag;
    }
    while ( ( 0 == strstr( app_buf, rsp ) ) &&
            ( 0 == strstr( app_buf, LTECAT13NAX_RSP_ERROR ) ) )
    {
        error_flag = ltecat13nax_process( );
        if ( ( LTECAT13NAX_OK != error_flag ) && ( LTECAT13NAX_ERROR != error_flag ) )
        {
            return error_flag;
        }
        if ( timeout_cnt++ > timeout )
        {
            ltecat13nax_clear_app_buf( );
            return LTECAT13NAX_ERROR_TIMEOUT;
        }
        Delay_ms ( 1 );
    }
    if ( strstr( app_buf, rsp ) )
    {
        return LTECAT13NAX_OK;
    }
    else if ( strstr( app_buf, LTECAT13NAX_RSP_ERROR ) )
    {
        return LTECAT13NAX_ERROR_CMD;
    }
    else
    {
        return LTECAT13NAX_ERROR_UNKNOWN;
    }
}

static void ltecat13nax_error_check( err_t error_flag )
{
    switch ( error_flag )
    {
        case LTECAT13NAX_OK:
        {
            ltecat13nax_log_app_buf( );
            break;
        }
        case LTECAT13NAX_ERROR:
        {
            log_error( &logger, " Overflow!" );
            break;
        }
        case LTECAT13NAX_ERROR_TIMEOUT:
        {
            log_error( &logger, " Timeout!" );
            break;
        }
        case LTECAT13NAX_ERROR_CMD:
        {
            ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_QIGETERROR );
            ltecat13nax_log_app_buf( );
            break;
        }
        case LTECAT13NAX_ERROR_UNKNOWN:
        default:
        {
            log_error( &logger, " Unknown!" );
            break;
        }
    }
    ltecat13nax_clear_app_buf(  );
    Delay_ms ( 500 );
}

static err_t ltecat13nax_cfg_for_network( void )
{
    err_t func_error = LTECAT13NAX_OK;
#if ( ( DEMO_EXAMPLE == EXAMPLE_TCP_UDP ) || ( DEMO_EXAMPLE == EXAMPLE_SMS ) || ( DEMO_EXAMPLE == EXAMPLE_CALL ) || ( DEMO_EXAMPLE == EXAMPLE_GNSS ) )
    // Deregister from network
    #define DEREGISTER_FROM_NETWORK "2"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_COPS, DEREGISTER_FROM_NETWORK );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );
    
    // Set SIM APN
    ltecat13nax_set_sim_apn( &ltecat13nax, SIM_APN );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Enable full functionality
    #define FULL_FUNCTIONALITY "1"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_CFUN, FULL_FUNCTIONALITY );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Enable network registartion
    #define ENABLE_REG "2"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_CREG, ENABLE_REG );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );
    
    // Automatic registration
    #define AUTOMATIC_REGISTRATION "0"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_COPS, AUTOMATIC_REGISTRATION );

#endif

    return func_error;
}

static err_t ltecat13nax_check_connection( void )
{
#if ( ( DEMO_EXAMPLE == EXAMPLE_TCP_UDP ) || ( DEMO_EXAMPLE == EXAMPLE_SMS ) || ( DEMO_EXAMPLE == EXAMPLE_CALL ) )
    #define CONNECTED_HOME      "+CREG: 2,1"
    #define CONNECTED_ROAMING   "+CREG: 2,5"
    ltecat13nax_send_cmd_check( &ltecat13nax, LTECAT13NAX_CMD_CREG );
    ltecat13nax_process( );
    if ( strstr( app_buf, CONNECTED_HOME ) || strstr( app_buf, CONNECTED_ROAMING ) )
    {
        Delay_ms ( 100 );
        ltecat13nax_process( );
        ltecat13nax_log_app_buf( );
        log_printf( &logger, "\r\n" );
        ltecat13nax_clear_app_buf( );
        // Check signal quality
        ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_CSQ );
        error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
        ltecat13nax_error_check( error_flag );
        return error_flag;
    }
    return LTECAT13NAX_ERROR;
    Delay_ms ( 500 );
#endif
    return LTECAT13NAX_OK;
}

static err_t ltecat13nax_cfg_for_example ( void )
{
    err_t func_error = LTECAT13NAX_OK;
#if ( DEMO_EXAMPLE == EXAMPLE_TCP_UDP )
    #define ACTIVATE_CONTEXT "1"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QIACT, ACTIVATE_CONTEXT );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QICSGP, ACTIVATE_CONTEXT );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

#elif ( DEMO_EXAMPLE == EXAMPLE_SMS )
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_CMGF, SMS_MODE );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    #define DEFAULT_ALPHABET    "\"GSM\""
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_CSCS, DEFAULT_ALPHABET );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );
#elif ( DEMO_EXAMPLE == EXAMPLE_CALL )
    if ( LTECAT13NAX_OK != ltecat13nax_max9860_cfg( &ltecat13nax ) )
    {
        log_error( &logger, " MAX9860 configuration." );
        for ( ; ; );
    }
    
#elif ( DEMO_EXAMPLE == EXAMPLE_GNSS )
    #define TURN_ON_GPS     "1"
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QGPS, TURN_ON_GPS );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

#else
    #error "No demo example selected"
#endif
    return func_error;
}

static err_t ltecat13nax_example ( void )
{
    err_t func_error = LTECAT13NAX_OK;
#if ( DEMO_EXAMPLE == EXAMPLE_TCP_UDP )
    uint8_t txt_end[ ] = "\032";
    uint8_t cmd_buf[ 100 ] = { 0 };
    
    #define CONTEXT_ID      "1"
    #define CONNECT_ID_TCP  "1"
    #define SEVICE_TYPE_TCP "\"TCP\""
    #define LOCAL_PORT      "0"
    #define ACCESS_MODE     "0"
    #define MAX_READ_SIZE   "1500"

    // Open TCP socket
    strcpy( cmd_buf, CONTEXT_ID );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, CONNECT_ID_TCP );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, SEVICE_TYPE_TCP );
    strcat( cmd_buf, ",\"" );
    strcat( cmd_buf, REMOTE_IP );
    strcat( cmd_buf, "\"," );
    strcat( cmd_buf, REMOTE_PORT );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, LOCAL_PORT );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, ACCESS_MODE );
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QIOPEN, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Send data to TCP socket
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QISEND, CONNECT_ID_TCP );
    strcpy( cmd_buf, MESSAGE_CONTENT );
    strcat( cmd_buf, txt_end );
    ltecat13nax_rsp_check( ">" );
    ltecat13nax_send_cmd( &ltecat13nax, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_SEND_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Read TCP socket data
    strcpy( cmd_buf, CONNECT_ID_TCP );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, MAX_READ_SIZE );
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QIRD, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Close TCP socket
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QICLOSE, CONNECT_ID_TCP );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );

    #define CONNECT_ID_UDP  "2"
    #define SEVICE_TYPE_UDP "\"UDP\""

    // Open UDP socket
    strcpy( cmd_buf, CONTEXT_ID );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, CONNECT_ID_UDP );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, SEVICE_TYPE_UDP );
    strcat( cmd_buf, ",\"" );
    strcat( cmd_buf, REMOTE_IP );
    strcat( cmd_buf, "\"," );
    strcat( cmd_buf, REMOTE_PORT );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, LOCAL_PORT );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, ACCESS_MODE );
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QIOPEN, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Send data to UDP socket
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QISEND, CONNECT_ID_UDP );
    strcpy( cmd_buf, MESSAGE_CONTENT );
    strcat( cmd_buf, txt_end );
    ltecat13nax_rsp_check( ">" );
    ltecat13nax_send_cmd( &ltecat13nax, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_SEND_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Read UDP socket data
    strcpy( cmd_buf, CONNECT_ID_UDP );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, MAX_READ_SIZE );
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QIRD, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );

    // Close UDP socket
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QICLOSE, CONNECT_ID_UDP );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;

    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
#elif ( DEMO_EXAMPLE == EXAMPLE_SMS )

    // Check SMS mode
    #define CMGF_PDU "+CMGF: 0"
    #define CMGF_TXT "+CMGF: 1"
    ltecat13nax_send_cmd_check( &ltecat13nax, LTECAT13NAX_CMD_CMGF );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    if ( strstr( app_buf, CMGF_PDU ) )
    {
        ltecat13nax_error_check( error_flag );
        // Send SMS in PDU mode
        ltecat13nax_send_sms_pdu( &ltecat13nax, SIM_SMSC, PHONE_NUMBER, MESSAGE_CONTENT );
        error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
        func_error |= error_flag;
    }
    else if ( strstr( app_buf, CMGF_TXT ) )
    {
        ltecat13nax_error_check( error_flag );
        // Send SMS in TXT mode
        ltecat13nax_send_sms_text ( &ltecat13nax, PHONE_NUMBER, MESSAGE_CONTENT );
        error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
        func_error |= error_flag;
    }
    ltecat13nax_error_check( error_flag );
    // 30 seconds delay
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );

#elif ( DEMO_EXAMPLE == EXAMPLE_CALL )
    uint8_t cmd_buf[ 100 ] = { 0 };
    
    strcpy( cmd_buf, LTECAT13NAX_CMD_ATD );
    ltecat13nax_clear_app_buf( );
    strcat( cmd_buf, PHONE_NUMBER );
    strcat( cmd_buf, ";" );
    
    log_printf( &logger, " Calling selected number \r\n" );
    ltecat13nax_send_cmd( &ltecat13nax, cmd_buf );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );
    
    ltecat13nax_clear_app_buf( );
    log_printf( &logger, "Dialing \r\n" );
    #define CHECK_DIALING "+CLCC: 1,0,2"  
    ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_CLCC );    
    error_flag = ltecat13nax_rsp_check( CHECK_DIALING );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );
    
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    #define CHECK_ANSWERED "+CLCC: 1,0,0"  
    ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_CLCC ); 
    error_flag = ltecat13nax_rsp_check( CHECK_ANSWERED );   
    while ( LTECAT13NAX_OK != error_flag )
    {
        ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_CLCC ); 
        error_flag = ltecat13nax_rsp_check( CHECK_ANSWERED );    
    }
    log_printf( &logger, "Answered \r\n" );
    ltecat13nax_error_check( error_flag );

    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    
    log_printf( &logger, "Hanging up \r\n" );
    ltecat13nax_send_cmd( &ltecat13nax, LTECAT13NAX_CMD_CHUP );
    ltecat13nax_clear_app_buf( );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    ltecat13nax_error_check( error_flag );
    ltecat13nax_clear_app_buf( );
    
    // 10 seconds delay
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );

#elif ( DEMO_EXAMPLE == EXAMPLE_GNSS )
    #define GPS_NEMA_GGA    "\"GGA\""
    ltecat13nax_send_cmd_with_params( &ltecat13nax, LTECAT13NAX_CMD_QGPSGNMEA, GPS_NEMA_GGA );
    error_flag = ltecat13nax_rsp_check( LTECAT13NAX_RSP_OK );
    func_error |= error_flag;
    gnss_parser_application( app_buf );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );

#else
    #error "No demo example selected"
#endif
    return func_error;
}

static void gnss_parser_application ( char *rsp ) 
{
    char element_buf[ 100 ] = { 0 };
    if ( LTECAT13NAX_OK == ltecat13nax_parse_gpgga( rsp, LTECAT13NAX_GPGGA_LATITUDE, element_buf ) )
    {        
        memset( gnss_info_message, 0, 200 ); 
        if ( strlen( element_buf ) > 0 )
        {
            strcpy( gnss_info_message, "GNSS info\n\r" );
            strcat( gnss_info_message, "Latitude: " );
            strncat( gnss_info_message, element_buf, 2 );
            strcat( gnss_info_message, " deg, " );
            strcat( gnss_info_message, &element_buf[ 2 ] );
            strcat( gnss_info_message, " min" );
            ltecat13nax_parse_gpgga( rsp, LTECAT13NAX_GPGGA_LONGITUDE, element_buf );
            strcat( gnss_info_message, "\n\rLongitude: " );
            strncat( gnss_info_message, element_buf, 3 );
            strcat( gnss_info_message, " deg, " );
            strcat( gnss_info_message, &element_buf[ 3 ] );
            strcat( gnss_info_message, " min" );
            memset( element_buf, 0, sizeof( element_buf ) );
            ltecat13nax_parse_gpgga( rsp, LTECAT13NAX_GPGGA_ALTITUDE, element_buf );
            strcat( gnss_info_message, "\n\rAltitude: " );
            strcat( gnss_info_message, element_buf );
            strcat( gnss_info_message, " m" );
            log_printf( &logger, "%s\r\n", gnss_info_message );
        }
        else
        {
            log_printf( &logger, " Waiting for the position fix...\r\n" );
        }
        log_printf( &logger, "\r\n-----------------------------------\r\n" );
        ltecat13nax_clear_app_buf();
    }
}

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