使用LARA-L6004D-01B和ATmega328P通过先进的LTE（4G）技术确保快速可靠的全球数据传输

创建需要连接并进行远距离通信的设备

LTE Cat.4 3 Click - Data with Arduino UNO Rev3

已发布 6月 24, 2024

点击板

LTE Cat.4 3 Click - Data

开发板

Arduino UNO Rev3

编译器

NECTO Studio

微控制器单元

ATmega328P

在各种应用中实现可靠的蜂窝连接，特别是在全球或多地区背景下与追踪、监测和通信相关的应用。

硬件概览

它是如何工作的？

LTE Cat.4 3 Click基于u-blox推出的LARA-L6004D-01B，这是LTE Cat 4模块中最小的形态因子。该数据专用模块支持DualStack IPv4/IPv6、FOAT/uFOTA、LwM2M、干扰检测等功能。它在700MHz至2600MHz的频率范围内作为四频设备运行。有两个SMA天线连接器，您应该连接MIKROE提供的适当天线。ANT1天线是主天线，支持TX和RX，而ANT2只支持LTE下行MIMO 2x2和3G RX多样性配置的RX。LTE Cat.4 3 Click具有用于1.8V和3.0V SIM类型的纳米SIM卡插槽。该模块还包括一个USB高速2.0兼容接

口，最小数据速率为480Mbps。该模块本身作为USB设备，并可连接到任何兼容的USB主机。它通过USB提供虚拟串口用于AT命令和通信，以及用于诊断日志的USB虚拟串口等。LTE Cat.4 3 Click使用标准的两线UART接口与主机MCU通信，常用的UART RX和TX支持高达3000000bps（默认为115200）。硬件流控功能也可通过RTS和CTS引脚使用。数据传输也可通过TX LED可视化。除了我们提供的库之外，您还可以使用一组AT命令与模块通信。网络状态可通过STS引脚和STATUS LED获取。该模块可

以通过软件、AT命令或PWR引脚关闭电源。该模块使用来自德州仪器的TXB0106和PCA9306双向转换器进行逻辑电平转换。I2C接口也可用于与主机MCU通信，并带有可选上拉电阻。该Click板™可以使用通过VCC SEL跳线选择的3.3V或5V逻辑电压级别运行。这样，既支持3.3V又支持5V的MCU可以正常使用通信线路。此外，该Click板™配备有包含易于使用的功能和示例代码的库，可用作进一步开发的参考。

LTE Cat.4 3 Click - Data hardware overview image

功能概述

开发板

Arduino UNO 是围绕 ATmega328P 芯片构建的多功能微控制器板。它为各种项目提供了广泛的连接选项，具有 14 个数字输入/输出引脚，其中六个支持 PWM 输出，以及六个模拟输入。其核心组件包括一个 16MHz 的陶瓷谐振器、一个 USB 连接器、一个电

源插孔、一个 ICSP 头和一个复位按钮，提供了为板子供电和编程所需的一切。UNO 可以通过 USB 连接到计算机，也可以通过 AC-to-DC 适配器或电池供电。作为第一个 USB Arduino 板，它成为 Arduino 平台的基准，"Uno" 符号化其作为系列首款产品的地

位。这个名称选择，意为意大利语中的 "一"，是为了纪念 Arduino Software（IDE）1.0 的推出。最初与 Arduino Software（IDE）版本1.0 同时推出，Uno 自此成为后续 Arduino 发布的基础模型，体现了该平台的演进。

微控制器概述

MCU卡片 / MCU

建筑

AVR

MCU 内存 (KB)

硅供应商

Microchip

引脚数

RAM (字节)

2048

你完善了我！

配件

Click Shield for Arduino UNO 具有两个专有的 mikroBUS™ 插座，使所有 Click board™ 设备能够轻松与 Arduino UNO 板进行接口连接。Arduino UNO 是一款基于 ATmega328P 的微控制器开发板，为用户提供了一种经济实惠且灵活的方式来测试新概念并构建基于 ATmega328P 微控制器的原型系统，结合了性能、功耗和功能的多种配置选择。Arduino UNO 具有 14 个数字输入/输出引脚（其中 6 个可用作 PWM 输出）、6 个模拟输入、16 MHz 陶瓷谐振器（CSTCE16M0V53-R0）、USB 接口、电源插座、ICSP 头和复位按钮。大多数 ATmega328P 微控制器的引脚都连接到开发板左右两侧的 IO 引脚，然后再连接到两个 mikroBUS™ 插座。这款 Click Shield 还配备了多个开关，可执行各种功能，例如选择 mikroBUS™ 插座上模拟信号的逻辑电平，以及选择 mikroBUS™ 插座本身的逻辑电压电平。此外，用户还可以通过现有的双向电平转换电压转换器使用任何 Click board™，无论 Click board™ 运行在 3.3V 还是 5V 逻辑电压电平。一旦将 Arduino UNO 板与 Click Shield for Arduino UNO 连接，用户即可访问数百种 Click board™，并兼容 3.3V 或 5V 逻辑电压电平的设备。

Click Shield for Arduino UNO accessories 1 image

这款多频LTE橡胶天线带可调角度是我们提供的所有3G/4G LTE Click板以及其他需要在全球所有主要蜂窝频段上具有出色吞吐量的设备的绝佳选择。该天线具有SMA公头连接器，可使其直接安装在Click板™或女性SMA模块连接器上。天线位置可以以45度为增量进行调整（0度/45度/90度）。

LTE Cat.4 3 Click - Data accessories 1 image

使用的MCU引脚

mikroBUS™映射器

Network Status

PC0

Module Power-On

PD2

RST

UART RTS

PB2

SCK

MISO

MOSI

Power Supply

3.3V

Ground

GND

Ring Indicator

PD6

PWM

UART CTS

PC3

INT

UART TX

PD0

UART RX

PD1

I2C Clock

PC5

SCL

I2C Data

PC4

SDA

Power Supply

Ground

GND

“仔细看看！”

Click board™ 原理图

LTE Cat.4 3 Click - Data Schematic schematic

一步一步来

项目组装

Click Shield for Arduino UNO front image hardware assembly

从选择您的开发板和Click板™开始。以Arduino UNO Rev3作为您的开发板开始。

Arduino UNO Rev3 front image hardware assembly

Charger 27 Click front image hardware assembly

Charger 27 Click complete accessories setup image hardware assembly

Arduino UNO Rev3 Access MB 1 - upright/background 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.4 3 Click 驱动程序的 API。

关键功能:

ltecat43_set_power_state - 此函数通过在高电平状态下使用特定时间切换PWR引脚来设置所需的电源状态。
ltecat43_set_sim_apn - 此函数为SIM卡设置APN。
ltecat43_send_sms_text - 此函数将文本消息发送到手机号码。

开源

代码示例

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

/*!
 * @file main.c
 * @brief LTE Cat.4 3 Click Example.
 *
 * # Description
 * Application example shows device capability of connecting to the network and
 * sending SMS or TCP/UDP messages using standard "AT" commands.
 *
 * The demo application is composed of two sections :
 *
 * ## Application Init
 * Initializes the driver, restarts the module, and tests the communication.
 *
 * ## Application Task
 * Application task is split in few stages:
 *  - LTECAT43_CONFIGURE_FOR_NETWORK:
 * Sets configuration to device to be able to connect to the network.
 *
 *  - LTECAT43_WAIT_FOR_CONNECTION:
 * Waits for the network registration indicated via CREG URC event and then checks the connection status.
 *
 *  - LTECAT43_CONFIGURE_FOR_EXAMPLE:
 * Sets the device configuration for sending SMS or TCP/UDP messages depending on the selected demo example.
 *
 *  - LTECAT43_EXAMPLE:
 * Depending on the selected demo example, it sends an SMS message (in PDU or TXT mode) or TCP/UDP message.
 *
 * By default, the TCP/UDP example is selected.
 *
 * ## Additional Function
 * - static void ltecat43_clear_app_buf ( void )
 * - static void ltecat43_log_app_buf ( void )
 * - static err_t ltecat43_process ( void )
 * - static void ltecat43_error_check( err_t error_flag )
 * - static err_t ltecat43_rsp_check ( void )
 * - static err_t ltecat43_cfg_for_network( void )
 * - static err_t ltecat43_check_connection( void )
 * - static err_t ltecat43_cfg_for_example( void )
 * - static err_t ltecat43_example( void )
 *
 * @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 Filipovic
 *
 */

#include "board.h"
#include "log.h"
#include "ltecat43.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 DEMO_EXAMPLE                        EXAMPLE_TCP_UDP // Example selection macro

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

// SMS example parameters
#define SIM_SMSC                            ""              // Set valid SMS Service Center Address - only in SMS PDU mode
#define PHONE_NUMBER_TO_MESSAGE             ""              // Set Phone number to message
#define SMS_MODE                            "1"             // 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.4 3 click board - demo example."

// Application buffer size
#define APP_BUFFER_SIZE                     256
#define PROCESS_BUFFER_SIZE                 256

/**
 * @brief Example states.
 * @details Predefined enum values for application example state.
 */
typedef enum
{
    LTECAT43_CONFIGURE_FOR_NETWORK = 1,
    LTECAT43_WAIT_FOR_CONNECTION,
    LTECAT43_CONFIGURE_FOR_EXAMPLE,
    LTECAT43_EXAMPLE

} ltecat43_example_state_t;

static ltecat43_t ltecat43;
static log_t logger;

/**
 * @brief Application example variables.
 * @details Variables used in application example.
 */
static uint8_t app_buf[ APP_BUFFER_SIZE ] = { 0 };
static int32_t app_buf_len = 0;
static err_t error_flag = LTECAT43_OK;
static ltecat43_example_state_t example_state;

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

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

/**
 * @brief LTE Cat.4 3 data reading function.
 * @details This function reads data from device and concatenates data to application buffer. 
 * @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 ltecat43_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 ltecat43_error_check( err_t error_flag );

/**
 * @brief Response check.
 * @details This function checks for response and
 * returns the status of 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 ltecat43_rsp_check ( void );

/**
 * @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 ltecat43_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 ltecat43_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 ltecat43_cfg_for_example( void );

/**
 * @brief Execute example.
 * @details This function executes SMS or TCP/UDP 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 ltecat43_example( void );

void application_init ( void )
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    ltecat43_cfg_t ltecat43_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.
    ltecat43_cfg_setup( &ltecat43_cfg );
    LTECAT43_MAP_MIKROBUS( ltecat43_cfg, MIKROBUS_1 );
    if ( UART_ERROR == ltecat43_init( &ltecat43, &ltecat43_cfg ) )
    {
        log_error( &logger, " Application Init Error. " );
        log_info( &logger, " Please, run program again... " );
        for ( ; ; );
    }

    ltecat43_set_power_state ( &ltecat43, LTECAT43_POWER_STATE_ON );

    ltecat43_process( );
    ltecat43_clear_app_buf( );

    // Check communication
    ltecat43_send_cmd( &ltecat43, LTECAT43_CMD_AT );
    error_flag = ltecat43_rsp_check( );
    ltecat43_error_check( error_flag );

    // Restart device
    #define RESTART_DEVICE "1,1"
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_CFUN, RESTART_DEVICE );
    error_flag = ltecat43_rsp_check( );
    ltecat43_error_check( error_flag );

    log_info( &logger, " Application Task " );
    example_state = LTECAT43_CONFIGURE_FOR_NETWORK;
}

void application_task ( void )
{
    switch ( example_state )
    {
        case LTECAT43_CONFIGURE_FOR_NETWORK:
        {
            if ( LTECAT43_OK == ltecat43_cfg_for_network( ) )
            {
                example_state = LTECAT43_WAIT_FOR_CONNECTION;
            }
            break;
        }
        case LTECAT43_WAIT_FOR_CONNECTION:
        {
            if ( LTECAT43_OK == ltecat43_check_connection( ) )
            {
                example_state = LTECAT43_CONFIGURE_FOR_EXAMPLE;
            }
            break;
        }
        case LTECAT43_CONFIGURE_FOR_EXAMPLE:
        {
            if ( LTECAT43_OK == ltecat43_cfg_for_example( ) )
            {
                example_state = LTECAT43_EXAMPLE;
            }
            break;
        }
        case LTECAT43_EXAMPLE:
        {
            ltecat43_example( );
            break;
        }
        default:
        {
            log_error( &logger, " Example state." );
            break;
        }
    }
}

void main ( void )
{
    application_init( );

    for ( ; ; )
    {
        application_task( );
    }
}

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

static void ltecat43_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 ] );
    }
}

static err_t ltecat43_process ( void )
{
    uint8_t rx_buf[ PROCESS_BUFFER_SIZE ] = { 0 };
    int32_t overflow_bytes = 0;
    int32_t rx_cnt = 0;
    int32_t rx_size = ltecat43_generic_read( &ltecat43, 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 LTECAT43_OK;
    }
    return LTECAT43_ERROR;
}

static err_t ltecat43_rsp_check ( void )
{
    uint32_t timeout_cnt = 0;
    uint32_t timeout = 120000;
    ltecat43_clear_app_buf( );
    ltecat43_process( );
    while ( ( 0 == strstr( app_buf, LTECAT43_RSP_OK ) ) &&
            ( 0 == strstr( app_buf, LTECAT43_RSP_ERROR ) ) )
    {
        ltecat43_process( );
        if ( timeout_cnt++ > timeout )
        {
            ltecat43_clear_app_buf( );
            return LTECAT43_ERROR_TIMEOUT;
        }
        Delay_ms( 1 );
    }
    Delay_ms( 100 );
    ltecat43_process( );
    if ( strstr( app_buf, LTECAT43_RSP_OK ) )
    {
        return LTECAT43_OK;
    }
    else if ( strstr( app_buf, LTECAT43_RSP_ERROR ) )
    {
        return LTECAT43_ERROR_CMD;
    }
    else
    {
        return LTECAT43_ERROR_UNKNOWN;
    }
}

static void ltecat43_error_check( err_t error_flag )
{
    switch ( error_flag )
    {
        case LTECAT43_OK:
        {
            ltecat43_log_app_buf( );
            break;
        }
        case LTECAT43_ERROR:
        {
            log_error( &logger, " Overflow!" );
            break;
        }
        case LTECAT43_ERROR_TIMEOUT:
        {
            log_error( &logger, " Timeout!" );
            break;
        }
        case LTECAT43_ERROR_CMD:
        {
            log_error( &logger, " CMD!" );
            break;
        }
        case LTECAT43_ERROR_UNKNOWN:
        default:
        {
            log_error( &logger, " Unknown!" );
            break;
        }
    }
    Delay_ms( 500 );
}

static err_t ltecat43_cfg_for_network( void )
{
    err_t func_error = LTECAT43_OK;
    // Deregister from network
    Delay_ms ( 10000 );
    #define DEREGISTER_FROM_NETWORK "2"
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_COPS, DEREGISTER_FROM_NETWORK );
    error_flag = ltecat43_rsp_check();
    func_error |= error_flag;
    ltecat43_error_check( error_flag );
    
    // Set SIM APN
    ltecat43_set_sim_apn( &ltecat43, SIM_APN );
    error_flag = ltecat43_rsp_check();
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Enable full functionality
    #define FULL_FUNCTIONALITY "1"
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_CFUN, FULL_FUNCTIONALITY );
    error_flag = ltecat43_rsp_check();
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Enable network registartion
    #define ENABLE_REG "2"
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_CREG, ENABLE_REG );
    error_flag = ltecat43_rsp_check();
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Automatic registration
    #define AUTOMATIC_REGISTRATION "0"
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_COPS, AUTOMATIC_REGISTRATION );
    error_flag = ltecat43_rsp_check();
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    return func_error;
}

static err_t ltecat43_check_connection( void )
{
    #define CONNECTED "+CREG: 2,1"
    ltecat43_send_cmd_check ( &ltecat43, LTECAT43_CMD_CREG );
    error_flag = ltecat43_rsp_check( );
    ltecat43_error_check( error_flag );
    if ( strstr( app_buf, CONNECTED ) )
    {
        Delay_ms( 100 );
        ltecat43_process( );
        ltecat43_log_app_buf( );
        log_printf( &logger, "\r\n" );
        ltecat43_clear_app_buf( );
        // Check signal quality
        ltecat43_send_cmd( &ltecat43, LTECAT43_CMD_CSQ );
        error_flag = ltecat43_rsp_check( );
        ltecat43_error_check( error_flag );
        return error_flag;
    }
    Delay_ms ( 1000 );
    return LTECAT43_ERROR;
}

static err_t ltecat43_cfg_for_example( void )
{
    err_t func_error = LTECAT43_OK;
#if ( DEMO_EXAMPLE == EXAMPLE_TCP_UDP )
    #define ACTIVATE_PDP_CONTEXT "1,1"
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_CGACT, ACTIVATE_PDP_CONTEXT );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );
#elif ( DEMO_EXAMPLE == EXAMPLE_SMS )
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_CMGF, SMS_MODE );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );
#else
    #error "No demo example selected"
#endif
    return func_error;
}

static err_t ltecat43_example( void )
{
    err_t func_error = LTECAT43_OK;
#if ( DEMO_EXAMPLE == EXAMPLE_TCP_UDP )
    uint8_t cmd_buf[ 100 ] = { 0 };
    uint8_t urc_buf[ 20 ] = { 0 };
    uint16_t timeout_cnt = 0;
    uint16_t timeout = 30000;
    uint8_t * __generic_ptr socket_num_buf = 0;
    uint8_t tcp_socket_num[ 2 ] = { 0 };
    uint8_t udp_socket_num[ 2 ] = { 0 };

    // Create TCP socket
    #define RSP_USOCR "+USOCR: "
    #define TCP_PROTOCOL "6"
    ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USOCR, TCP_PROTOCOL );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    socket_num_buf = strstr( app_buf, RSP_USOCR ) + strlen ( RSP_USOCR );
    tcp_socket_num[ 0 ] = *socket_num_buf;
    ltecat43_error_check( error_flag );

    // Create UDP socket
    #define UDP_PROTOCOL "17"
    ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USOCR, UDP_PROTOCOL );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    socket_num_buf = strstr( app_buf, RSP_USOCR ) + strlen ( RSP_USOCR );
    udp_socket_num[ 0 ] = *socket_num_buf;
    ltecat43_error_check( error_flag );

    // Connect TCP socket to remote IP and port
    strcpy( cmd_buf, tcp_socket_num );
    strcat( cmd_buf, ",\"" );
    strcat( cmd_buf, REMOTE_IP );
    strcat( cmd_buf, "\"," );
    strcat( cmd_buf, REMOTE_PORT );
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_USOCO, cmd_buf );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Connect UDP socket to remote IP and port
    strcpy( cmd_buf, udp_socket_num );
    strcat( cmd_buf, ",\"" );
    strcat( cmd_buf, REMOTE_IP );
    strcat( cmd_buf, "\"," );
    strcat( cmd_buf, REMOTE_PORT );
    ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USOCO, cmd_buf );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Get message length
    uint8_t message_len_buf[ 5 ] = { 0 };
    uint16_t message_len = strlen( MESSAGE_CONTENT );
    uint16_to_str( message_len, message_len_buf );
    l_trim( message_len_buf );
    r_trim( message_len_buf );

    // Write message to TCP socket
    strcpy( cmd_buf, tcp_socket_num );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, message_len_buf );
    strcat( cmd_buf, ",\"" );
    strcat( cmd_buf, MESSAGE_CONTENT );
    strcat( cmd_buf, "\"" );
    ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USOWR, cmd_buf );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Read response message from TCP socket
    #define URC_READ_SOCKET_DATA_TCP "+UUSORD: "
    strcpy( urc_buf, URC_READ_SOCKET_DATA_TCP );
    strcat( urc_buf, tcp_socket_num );
    for ( ; ; )
    {
        ltecat43_process( );
        uint8_t * __generic_ptr start_response_buf = strstr( app_buf, urc_buf );
        if ( start_response_buf )
        {
            Delay_ms( 100 );
            ltecat43_process( );
            uint8_t response_len_buf[ 5 ] = { 0 };
            uint8_t * __generic_ptr start_response_len = strstr( start_response_buf, "," ) + 1;
            memcpy ( response_len_buf, start_response_len, app_buf_len - ( start_response_len - app_buf ) );
            strcpy( cmd_buf, tcp_socket_num );
            strcat( cmd_buf, "," );
            strcat( cmd_buf, response_len_buf );
            ltecat43_log_app_buf( );
            ltecat43_clear_app_buf( );
            ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USORD, cmd_buf );
            error_flag = ltecat43_rsp_check( );
            func_error |= error_flag;
            ltecat43_error_check( error_flag );
            break;
        }
        if ( timeout_cnt++ > timeout )
        {
            break;
        }
        Delay_ms( 1 );
    }
    timeout_cnt = 0;

    // Write message to UDP socket
    strcpy( cmd_buf, udp_socket_num );
    strcat( cmd_buf, "," );
    strcat( cmd_buf, message_len_buf );
    strcat( cmd_buf, ",\"" );
    strcat( cmd_buf, MESSAGE_CONTENT );
    strcat( cmd_buf, "\"" );
    ltecat43_send_cmd_par( &ltecat43, LTECAT43_CMD_USOWR, cmd_buf );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );

    // Read response message from UDP socket
    #define URC_READ_SOCKET_DATA_UDP "+UUSORD: "
    strcpy( urc_buf, URC_READ_SOCKET_DATA_UDP );
    strcat( urc_buf, udp_socket_num );
    for ( ; ; )
    {
        ltecat43_process( );
        uint8_t * __generic_ptr start_response_buf = strstr( app_buf, urc_buf );
        if ( start_response_buf )
        {
            Delay_ms( 100 );
            ltecat43_process( );
            uint8_t response_len_buf[ 5 ] = { 0 };
            uint8_t * __generic_ptr start_response_len = strstr( start_response_buf, "," ) + 1;
            memcpy ( response_len_buf, start_response_len, app_buf_len - ( start_response_len - app_buf ) );
            strcpy( cmd_buf, udp_socket_num );
            strcat( cmd_buf, "," );
            strcat( cmd_buf, response_len_buf );
            ltecat43_log_app_buf( );
            ltecat43_clear_app_buf( );
            ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USORF, cmd_buf );
            error_flag = ltecat43_rsp_check( );
            func_error |= error_flag;
            ltecat43_error_check( error_flag );
            break;
        }
        if ( timeout_cnt++ > timeout )
        {
            break;
        }
        Delay_ms( 1 );
    }
    
    // Close TCP socket
    ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USOCL, tcp_socket_num );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );
    
    // Close UDP socket
    ltecat43_send_cmd_par ( &ltecat43, LTECAT43_CMD_USOCL, udp_socket_num );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );
    Delay_ms( 5000 );
#elif ( DEMO_EXAMPLE == EXAMPLE_SMS )
    // Check SMS mode
    #define CMGF_PDU "+CMGF: 0"
    #define CMGF_TXT "+CMGF: 1"
    ltecat43_send_cmd_check( &ltecat43, LTECAT43_CMD_CMGF );
    error_flag = ltecat43_rsp_check( );
    func_error |= error_flag;
    ltecat43_error_check( error_flag );
    if ( strstr( app_buf, CMGF_PDU ) )
    {
        // Send SMS in PDU mode
        ltecat43_send_sms_pdu( &ltecat43, SIM_SMSC, PHONE_NUMBER_TO_MESSAGE, MESSAGE_CONTENT );
        error_flag = ltecat43_rsp_check( );
        func_error |= error_flag;
        ltecat43_error_check( error_flag );
    }
    else if ( strstr( app_buf, CMGF_TXT ) )
    {
        // Send SMS in TXT mode
        ltecat43_send_sms_text ( &ltecat43, PHONE_NUMBER_TO_MESSAGE, MESSAGE_CONTENT );
        error_flag = ltecat43_rsp_check( );
        func_error |= error_flag;
        ltecat43_error_check( error_flag );
    }
    Delay_ms( 10000 );
    Delay_ms( 10000 );
    Delay_ms( 10000 );
#else
    #error "No demo example selected"
#endif
    return func_error;
}

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