在美国体验ELS61-US和STM32F031K6带来的LTE连接的下一级别

完美的连接性：为美国提供Cat 1 LTE

LTE Cat.1-US Click (for United States) with Nucleo 32 with STM32F031K6 MCU

已发布 10月 01, 2024

点击板

LTE Cat.1-US Click (for United States)

开发板

Nucleo 32 with STM32F031K6 MCU

编译器

NECTO Studio

微控制器单元

STM32F031K6

专注于M2M IoT卓越性能的设计，我们的无线模块为美国企业提供高效的Cat 1 LTE连接，提供可靠且多功能的通信解决方案，具备无缝切换到2G和3G网络的功能。

硬件概览

它是如何工作的？

LTE Cat.1-US Click基于Thales的ELS61多频段无线模块。有两个Click板，分别覆盖两个不同的地区：LTE Cat.1-EU Click适用于欧洲地区，采用ELS61-E模块，而LTE Cat.1-US Click适用于北美地区，采用ELS61-US模块。这两个模块之间的主要区别是支持的频段，符合各个地区的法规。每个模块支持的频段的完整列表以及有关模块本身的其他相关信息可以在附加的ELS61数据表中找到。LTE Cat.1-US Click上的ELS61-US模块配备了一个Java®嵌入式虚拟机，利用强大的ARM11架构，使设备制造商能够利用大量资源来降低复杂性并加快应用集成的速度。最新的Java ME 3.2客户

端运行时平台通过共享内部资源（如内存、大量现有代码库和经过验证的软件构建块）降低总体拥有成本（TCO）和上市时间。该模块使用多MIDlet Java执行来同时托管和运行多个应用程序和协议。ELS61-US系列模块的UART总线连接到电平转换器的一侧，而另一侧（转换）连接到相应的mikroBUS™ UART引脚。然而，ELS61系列模块设计为传统的DCE设备（数据通信设备），提供全面的UART引脚数，包括硬件流控制引脚（CTS、RTS）。这些引脚被路由到mikroBUS™ CS（CTS）和INT引脚（RTS），如果需要硬件流控制，则可以在MCU软件中使用它们。具有最新TLS/SSL

引擎的扩展安全概念提供安全可靠的TCP/IP连接。其复杂的沙箱建模和分层架构简化了设备管理，并允许网络运营商的批准和应用代码开发同时进行，以缩短上市时间。LTE Cat.1模块提供长达七年的产品寿命、高效的带宽和功率利用率，以及满足M2M IoT解决方案严格要求的功能集，包括扩展的工作温度。LTE Cat.1-US Click确保了创新解决方案的简易集成和快速上市，并为可靠的连接平台提供了所需的支持，以及您可以信赖的价值。鉴于这些特性的可能性，LTE Cat.1-US Click可用于各种应用，如计量、跟踪和追踪、远程监视、连接的标志、车队管理和mHealth。

LTE Cat.1-US Click (for United States) hardware overview image

功能概述

开发板

Nucleo 32开发板搭载STM32F031K6 MCU，提供了一种经济且灵活的平台，适用于使用32引脚封装的STM32微控制器进行实验。该开发板具有Arduino™ Nano连接性，便于通过专用扩展板进行功能扩展，并且支持mbed，使其能够无缝集成在线资源。板载集成

ST-LINK/V2-1调试器/编程器，支持通过USB重新枚举，提供三种接口：虚拟串口（Virtual Com port）、大容量存储和调试端口。该开发板的电源供应灵活，可通过USB VBUS或外部电源供电。此外，还配备了三个LED指示灯（LD1用于USB通信，LD2用于电源

指示，LD3为用户可控LED）和一个复位按钮。STM32 Nucleo-32开发板支持多种集成开发环境（IDEs），如IAR™、Keil®和基于GCC的IDE（如AC6 SW4STM32），使其成为开发人员的多功能工具。

Nucleo 32 with STM32F031K6 MCU double side image

微控制器概述

MCU卡片 / MCU

建筑

ARM Cortex-M0

MCU 内存 (KB)

硅供应商

STMicroelectronics

引脚数

RAM (字节)

4096

你完善了我！

配件

Click Shield for Nucleo-32是扩展您的开发板功能的理想选择，专为STM32 Nucleo-32引脚布局设计。Click Shield for Nucleo-32提供了两个mikroBUS™插座，可以添加来自我们不断增长的Click板™系列中的任何功能。从传感器和WiFi收发器到电机控制和音频放大器，我们应有尽有。Click Shield for Nucleo-32与STM32 Nucleo-32开发板兼容，为用户提供了一种经济且灵活的方式，使用任何STM32微控制器快速创建原型，并尝试各种性能、功耗和功能的组合。STM32 Nucleo-32开发板无需任何独立的探针，因为它集成了ST-LINK/V2-1调试器/编程器，并随附STM32全面的软件HAL库和各种打包的软件示例。这个开发平台为用户提供了一种简便且通用的方式，将STM32 Nucleo-32兼容开发板与他们喜欢的Click板™结合，应用于即将开展的项目中。

Click Shield for Nucleo-32 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橡胶天线具有可调节角度，是我们提供的所有3G/4G LTE点击板以及其他需要在全球主要蜂窝频段上具有出色吞吐量的设备的优秀选择。该天线具有SMA公头连接器，可直接安装在Click板™或女性SMA模块连接器上。天线位置可以按45⁰增量调整（0⁰/45⁰/90⁰）。

使用的MCU引脚

mikroBUS™映射器

Reset

PA11

RST

UART CTS

PA4

SPI Clock

PB3

SCK

SPI Data OUT

PB4

MISO

SPI Data IN

PB5

MOSI

Power Supply

3.3V

Ground

GND

SPI Chip Select

PA8

PWM

UART RTS

PA12

INT

UART TX

PA10

UART RX

PA9

I2C Clock

PB6

SCL

I2C Data

PB7

SDA

Power Supply

Ground

GND

“仔细看看！”

Click board™ 原理图

LTE Cat.1-US Click (for United States) Schematic schematic

一步一步来

项目组装

Click Shield for Nucleo-144 front image hardware assembly

从选择您的开发板和Click板™开始。以Nucleo 32 with STM32F031K6 MCU作为您的开发板开始。

Nucleo 144 with STM32L4A6ZG MCU front image hardware assembly

Stepper 22 Click front image hardware assembly

Stepper 22 Click complete accessories setup image hardware assembly

Board mapper by product8 hardware assembly

STM32 M4 Clicker HA MCU/Select Step hardware assembly

Necto No Display image step 8 hardware assembly

Debug Image Necto Step hardware assembly

软件支持

库描述

该库包含 LTE Cat.1-US Click 驱动程序的 API。

关键功能:

ltecat1eu_send_cmd - 此函数向点击模块发送指定的命令
ltecat1eu_send_cmd_with_parameter - 此函数向点击模块发送带参数的命令
ltecat1eu_send_text_message - 此函数向手机号发送文本消息

开源

代码示例

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

/*!
 * @file main.c
 * @brief LTE Cat.1-US Click Example.
 *
 * # Description
 * This example reads and processes data from LTE Cat.1-US Clicks.
 *
 * The demo application is composed of two sections :
 * 
 * ## Application Init 
 * Initializes driver and wake-up module and sets default configuration for connecting device to network.
 * 
 * ## Application Task  
 * Waits for device to connect to network and then sends SMS to selected phone number.
 * 
 * ## Additional Function
 * - static void ltecat1us_clear_app_buf ( void )
 * - static void ltecat1us_error_check( err_t error_flag )
 * - static void ltecat1us_log_app_buf ( void )
 * - static void ltecat1us_check_connection( void )
 * - static err_t ltecat1us_rsp_check ( void )
 * - static err_t ltecat1us_process ( void )
 * 
 * @note
 * In order for the example to work, 
   user needs to set the phone number and sim apn to which he wants to send an SMS
 * Enter valid data for the following macros: SIM_APN and PHONE_NUMBER_TO_MESSAGE.
 * E.g. 
    SIM_APN "vipmobile"
    PHONE_NUMBER_TO_MESSAGE "+381659999999"
 *
 * @author Stefan Ilic
 *
 */

#include "board.h"
#include "log.h"
#include "ltecat1us.h"

#define APP_OK                      0
#define APP_ERROR_DRIVER           -1
#define APP_ERROR_OVERFLOW         -2
#define APP_ERROR_TIMEOUT          -3

#define RSP_OK                     "OK"
#define RSP_SYSSTART               "^SYSSTART"
#define RSP_ERROR                  "ERROR"

#define SIM_APN                    ""  // Set valid SIM APN
#define PHONE_NUMBER_TO_MESSAGE    ""  // Set Phone number to message
#define MESSAGE_CONTENT            "LTE Cat.1-US Click"   // Messege content 

#define PROCESS_BUFFER_SIZE        500

#define WAIT_FOR_CONNECTION        0
#define CONNECTED_TO_NETWORK       1

static ltecat1us_t ltecat1us;
static log_t logger;

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

static uint8_t app_connection_status        = WAIT_FOR_CONNECTION;

static err_t app_error_flag;

/**
 * @brief LTE Cat.1-US clearing application buffer.
 * @details This function clears memory of application buffer and reset it's length and counter.
 * @note None.
 */
static void ltecat1us_clear_app_buf ( void );

/**
 * @brief LTE Cat.1-US data reading function.
 * @details This function reads data from device and concats data to application buffer.
 * 
 * @return @li @c  0 - Read some data.
 *         @li @c -1 - Nothing is read.
 *         @li @c -2 - Application buffer overflow.
 *
 * See #err_t definition for detailed explanation.
 * @note None.
 */
static err_t ltecat1us_process ( void );

/**
 * @brief LTE Cat.1-US check for errors.
 * @details This function checks for different types of errors and logs them on UART.
 * @note None.
 */
static void ltecat1us_error_check( err_t error_flag );

/**
 * @brief LTE Cat.1-US logs application buffer.
 * @details This function logs data from application buffer.
 * @note None.
 */
static void ltecat1us_log_app_buf ( void );

/**
 * @brief LTE Cat.1-US response check.
 * @details This function checks for response and returns the status of response.
 * @param[in] response : Expected response.
 * 
 * @return application status.
 * See #err_t definition for detailed explanation.
 * @note None.
 */
static err_t ltecat1us_rsp_check ( char * response );

/**
 * @brief LTE Cat.1-US chek connection.
 * @details This function checks connection to the network and 
 *          logs that status to UART.
 * 
 * @note None.
 */
static void ltecat1us_check_connection( void );

void application_init ( void ) {
    log_cfg_t log_cfg;  /**< Logger config object. */
    ltecat1us_cfg_t ltecat1us_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 " );
    Delay_ms ( 1000 );
    
    // Click initialization.
    ltecat1us_cfg_setup( &ltecat1us_cfg );
    LTECAT1US_MAP_MIKROBUS( ltecat1us_cfg, MIKROBUS_1 );
    err_t init_flag  = ltecat1us_init( &ltecat1us, &ltecat1us_cfg );
    if ( init_flag == UART_ERROR ) {
        log_error( &logger, " Application Init Error. " );
        log_info( &logger, " Please, run program again... " );

        for ( ; ; );
    }
    
    log_info( &logger, " Power on device... " );
    
    ltecat1us_power_on( &ltecat1us );
    
    // CFUN - restart ME
    ltecat1us_send_cmd_with_parameter( &ltecat1us, LTECAT1US_CMD_CFUN, "0" );
    app_error_flag = ltecat1us_rsp_check( RSP_SYSSTART );
    ltecat1us_error_check( app_error_flag );
    
    // AT
    ltecat1us_send_cmd( &ltecat1us, LTECAT1US_CMD_AT );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    // ATI - product information
    ltecat1us_send_cmd( &ltecat1us, LTECAT1US_CMD_ATI );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    // CGMR - firmware version
    ltecat1us_send_cmd( &ltecat1us, LTECAT1US_CMD_CGMR );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    // COPS - deregister from network
    ltecat1us_send_cmd_with_parameter( &ltecat1us, LTECAT1US_CMD_COPS, "2" );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    // CGDCONT - set sim apn
    ltecat1us_set_sim_apn( &ltecat1us, SIM_APN );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
     
    // CFUN - full funtionality
    ltecat1us_send_cmd_with_parameter( &ltecat1us, LTECAT1US_CMD_CFUN, "1" );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    // COPS - automatic mode
    ltecat1us_send_cmd_with_parameter( &ltecat1us, LTECAT1US_CMD_COPS, "0" );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    
    // CEREG - network registration status
    ltecat1us_send_cmd_with_parameter( &ltecat1us, LTECAT1US_CMD_CEREG, "2" );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    // CIMI - request IMSI
    ltecat1us_send_cmd( &ltecat1us, LTECAT1US_CMD_CIMI );
    app_error_flag = ltecat1us_rsp_check( RSP_OK );
    ltecat1us_error_check( app_error_flag );
    Delay_ms ( 500 );
    
    app_buf_len = 0;
    app_buf_cnt = 0;
    app_connection_status = WAIT_FOR_CONNECTION;
    log_info( &logger, " Application Task " );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
    Delay_ms ( 1000 );
}

void application_task ( void ) {
    if ( app_connection_status == WAIT_FOR_CONNECTION ) {
        // CGATT - request IMSI
        ltecat1us_send_cmd_check( &ltecat1us, LTECAT1US_CMD_CGATT );
        app_error_flag = ltecat1us_rsp_check( RSP_OK );
        ltecat1us_error_check( app_error_flag );
        Delay_ms ( 500 );
        
        // CEREG - network registration status
        ltecat1us_send_cmd_check( &ltecat1us, LTECAT1US_CMD_CEREG );
        app_error_flag = ltecat1us_rsp_check( RSP_OK );
        ltecat1us_error_check( app_error_flag );
        Delay_ms ( 500 );
        
        // CSQ - signal quality
        ltecat1us_send_cmd( &ltecat1us, LTECAT1US_CMD_CSQ );
        app_error_flag = ltecat1us_rsp_check( RSP_OK );
        ltecat1us_error_check( app_error_flag );
        Delay_ms ( 1000 );
        Delay_ms ( 1000 );
        Delay_ms ( 1000 );
        Delay_ms ( 1000 );
        Delay_ms ( 1000 );
    } else {
        log_info( &logger, "CONNECTED TO NETWORK" );
        
        // SMS message format - text mode
        ltecat1us_send_cmd_with_parameter( &ltecat1us, "AT+CMGF", "1" );
        app_error_flag = ltecat1us_rsp_check( RSP_OK );
        ltecat1us_error_check( app_error_flag );
        Delay_ms ( 1000 );
        Delay_ms ( 1000 );
        Delay_ms ( 1000 );
        
        for( ; ; ) {   
            log_printf( &logger, "> Sending message to phone number...\r\n" );
            ltecat1us_send_text_message( &ltecat1us, PHONE_NUMBER_TO_MESSAGE, MESSAGE_CONTENT );
            app_error_flag = ltecat1us_rsp_check( RSP_OK );
            ltecat1us_error_check( app_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 );
        }
    }
}

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 ltecat1us_clear_app_buf ( void ) {
    memset( app_buf, 0, app_buf_len );
    app_buf_len = 0;
    app_buf_cnt = 0;
}

static err_t ltecat1us_process ( void ) {
    err_t return_flag = APP_ERROR_DRIVER;
    int32_t rx_size;
    char rx_buff[ PROCESS_BUFFER_SIZE ] = { 0 };
    
    rx_size = ltecat1us_generic_read( &ltecat1us, rx_buff, PROCESS_BUFFER_SIZE );

    if ( rx_size > 0 ) { 
        int32_t buf_cnt = 0;
        return_flag = APP_OK;

        if ( app_buf_len + rx_size >= PROCESS_BUFFER_SIZE ) {
            ltecat1us_clear_app_buf(  );
            return_flag = APP_ERROR_OVERFLOW;
        } else {
            buf_cnt = app_buf_len;
            app_buf_len += rx_size;
        }

        for ( int32_t rx_cnt = 0; rx_cnt < rx_size; rx_cnt++ ) {
            if ( rx_buff[ rx_cnt ] != 0 ) {
                app_buf[ ( buf_cnt + rx_cnt ) ] = rx_buff[ rx_cnt ];
            } else {
                app_buf_len--;
                buf_cnt--;
            }
        }
    } 

    return return_flag;
}


static err_t ltecat1us_rsp_check ( char * response ) {
    uint16_t timeout_cnt = 0;
    uint16_t timeout = 50000;
    
    err_t error_flag = ltecat1us_process(  );
    if ( ( error_flag != 0 ) && ( error_flag != -1 ) ) {
        return error_flag;
    }
    
    while ( ( strstr( app_buf, response ) == 0 ) && ( strstr( app_buf, RSP_ERROR ) == 0 ) ) {
        error_flag = ltecat1us_process(  );
        if ( ( error_flag != 0 ) && ( error_flag != -1 ) ) {
            return error_flag;
        }
        
        timeout_cnt++;
        if ( timeout_cnt > timeout ) {
            while ( ( strstr( app_buf, response ) == 0 ) && ( strstr( app_buf, RSP_ERROR ) == 0 ) ) {
                ltecat1us_send_cmd( &ltecat1us, LTECAT1US_CMD_AT );
                ltecat1us_process(  );
                Delay_ms ( 100 );
            }
            ltecat1us_clear_app_buf(  );
            return APP_ERROR_TIMEOUT;
        }
        
        Delay_ms ( 1 );
    }
    
    ltecat1us_check_connection();
    
    ltecat1us_log_app_buf();
    
    log_printf( &logger, "-----------------------------------\r\n" );
    
    return APP_OK;
}

static void ltecat1us_error_check( err_t error_flag ) {
    if ( ( error_flag != 0 ) && ( error_flag != -1 ) ) {
        switch ( error_flag ) {
            case -2: {
                log_error( &logger, " Overflow!" );
                break;
            }
            case -3: {
                log_error( &logger, " Timeout!" );
                break;
            }
            default: {
                break;
            }
        }
    }
}

static void ltecat1us_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" );
    ltecat1us_clear_app_buf(  );
}

static void ltecat1us_check_connection( void ) {
    #define CONNECTED "+CGATT: 1"
    
    if ( strstr( app_buf, CONNECTED ) != 0 ) {
        app_connection_status = CONNECTED_TO_NETWORK;
    }
}

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