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

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

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

已发布 6月 26, 2024

点击板

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

开发板

PIC32MZ clicker

编译器

NECTO Studio

微控制器单元

PIC32MZ1024EFH064

专注于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

功能概述

开发板

PIC32MZ Clicker 是一款紧凑型入门开发板，它将 Click 板™的灵活性带给您喜爱的微控制器，使其成为实现您想法的完美入门套件。它配备了一款板载 32 位带有浮点单元的 Microchip PIC32MZ 微控制器，一个 USB 连接器，LED 指示灯，按钮，一个 mikroProg 连接器，以及一个用于与外部电子设备接口的头部。得益于其紧凑的设计和清晰易识别的丝网标记，它提供了流畅且沉浸式的工作体验，允许在任

何情况下、任何地方都能访问。PIC32MZ Clicker 开发套件的每个部分都包含了使同一板块运行最高效的必要组件。除了可以选择 PIC32MZ Clicker 的编程方式，使用 USB HID mikroBootloader 或通过外部 mikroProg 连接器为 PIC，dsPIC 或 PIC32 编程外，Clicker 板还包括一个干净且调节过的开发套件电源供应模块。USB Micro-B 连接可以提供多达 500mA 的电流，这足以操作所有板载和附加模块。所有

mikroBUS™ 本身支持的通信方法都在这块板上，包括已经建立良好的 mikroBUS™ 插槽、重置按钮以及若干按钮和 LED 指示灯。PIC32MZ Clicker 是 Mikroe 生态系统的一个组成部分，允许您在几分钟内创建新的应用程序。它由 Mikroe 软件工具原生支持，得益于大量不同的 Click 板™（超过一千块板），其数量每天都在增长，它涵盖了原型制作的许多方面。

微控制器概述

MCU卡片 / MCU

建筑

PIC32

MCU 内存 (KB)

1024

硅供应商

Microchip

引脚数

RAM (字节)

524288

你完善了我！

配件

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

RE5

RST

UART CTS

RG9

SPI Clock

RG6

SCK

SPI Data OUT

RG7

MISO

SPI Data IN

RG8

MOSI

Power Supply

3.3V

Ground

GND

SPI Chip Select

RB3

PWM

UART RTS

RB5

INT

UART TX

RB2

UART RX

RB0

I2C Clock

RD10

SCL

I2C Data

RD9

SDA

Power Supply

Ground

GND

“仔细看看！”

Click board™ 原理图

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

一步一步来

项目组装

PIC32MZ clicker front image hardware assembly

从选择您的开发板和Click板™开始。以PIC32MZ clicker作为您的开发板开始。

GNSS2 Click front image hardware assembly

GNSS2 Click complete accessories setup image hardware assembly

Board mapper by product7 hardware assembly

Flip&Click PIC32MZ MCU 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