Intermediate
20 min

Achieve long-range connectivity in IoT applications, such as wireless sensor networks and remote meter readings, using Wio-E5 and PIC32MZ2048EFM100

LoRa wireless module solution powered by STM32WLE5

LR 10 Click with Curiosity PIC32 MZ EF

Published Mar 05, 2024

Click board™

LR 10 Click

Dev Board

Curiosity PIC32 MZ EF

Compiler

NECTO Studio

MCU

PIC32MZ2048EFM100

Enhance Internet of Things (IoT) projects focusing on energy efficiency and extensive connectivity range

A

A

Hardware Overview

How does it work?

LR 10 Click is based on the Wio-E5, a LoRa wireless module from Seeed Technology, renowned for its minimal power draw and compactness. This powerhouse module incorporates the STM32WLE5JC system-level package chip and the SX126X LoRa® chip for stellar performance alongside an Arm® Cortex® M4 MCU that ensures ultra-low power consumption. Designed primarily for IoT applications requiring minimal power and extended range—such as wireless sensor networks, remote meter reading, and other low-power, wide-area network scenarios - the Wio-E5 stands out as a versatile solution for many IoT needs. As mentioned, the Wio-E5 module integrates the STM32WLE5JC. This chip excels in various IoT applications thanks to its support for multi-mode operations, including (G)FSK and LoRa®, with bandwidth options ranging from 62.5kHz to 500kHz in LoRa® mode. It is

characterized by a maximum RF input power of +10dBm, ensuring robust signal strength. The device operates seamlessly across a broad frequency range of 868 to 928MHz, accommodating a wide spectrum of wireless communication needs. With an ability to deliver an output power of up to 22dBm, it ensures extensive coverage and reliable transmission across its operational frequency range. Furthermore, the board achieves a peak sensitivity of -137.5dBm, guaranteeing consistent and dependable communication capabilities, even under demanding environmental conditions. This Click board offers a rich selection of available interfaces to communicate with the host MCU, such as UART, I2C, and SPI, catering to diverse application needs. It simplifies the design of LoRaWAN® nodes through embedded global LoRaWAN® protocol support and an AT command set achieved by UART

and reset RST pin integration. Firmware upgrades are also possible via the UART interface in a Boot mode, triggered by the BOOT button, allowing for easy programming and software development leveraging the onboard MCU's capabilities through the SWD interface pins on the board's side. LR 10 Click also features the SMA antenna connector with an impedance of 50Ω, compatible with various antennas available from MIKROE, like the Rubber Antenna 868MHz, to enhance its connectivity. This Click board™ can be operated only with a 3.3V logic voltage level. The board must perform appropriate logic voltage level conversion before using MCUs with different logic levels. Also, it comes equipped with a library containing functions and an example code that can be used as a reference for further development.

LR 10 Click hardware overview image

Features overview

Development board

Curiosity PIC32 MZ EF development board is a fully integrated 32-bit development platform featuring the high-performance PIC32MZ EF Series (PIC32MZ2048EFM) that has a 2MB Flash, 512KB RAM, integrated FPU, Crypto accelerator, and excellent connectivity options. It includes an integrated programmer and debugger, requiring no additional hardware. Users can expand

functionality through MIKROE mikroBUS™ Click™ adapter boards, add Ethernet connectivity with the Microchip PHY daughter board, add WiFi connectivity capability using the Microchip expansions boards, and add audio input and output capability with Microchip audio daughter boards. These boards are fully integrated into PIC32’s powerful software framework, MPLAB Harmony,

which provides a flexible and modular interface to application development a rich set of inter-operable software stacks (TCP-IP, USB), and easy-to-use features. The Curiosity PIC32 MZ EF development board offers expansion capabilities making it an excellent choice for a rapid prototyping board in Connectivity, IOT, and general-purpose applications.

Curiosity PIC32MZ EF double side image

Microcontroller Overview

MCU Card / MCU

default

Architecture

PIC32

MCU Memory (KB)

2048

Silicon Vendor

Microchip

Pin count

100

RAM (Bytes)

524288

You complete me!

Accessories

868MHz right-angle rubber antenna is a compact and versatile solution for wireless communication. Operating within the frequency range of 868-915MHz, it ensures optimal signal reception and transmission. With a 50-ohm impedance, it's compatible with various devices and systems. This antenna boasts a 2dB gain, enhancing signal strength and extending communication range. Its vertical polarization further contributes to signal clarity. Designed to handle up to 50W of input power, it's a robust choice for various applications. Measuring just 48mm in length, this antenna is both discreet and practical. Its SMA male connector ensures a secure and reliable connection to your equipment. Whether you're working with IoT devices, remote sensors, or other wireless technologies, the 868MHz right-angle antenna offers the performance and flexibility you need for seamless communication.

LR 10 Click accessories 1 image

Used MCU Pins

mikroBUS™ mapper

NC
NC
AN
Reset / ID SEL
RA9
RST
SPI Select / ID COMM
RPD4
CS
SPI Clock
RPD1
SCK
SPI Data OUT
RPD14
MISO
SPI Data IN
RPD3
MOSI
Power Supply
3.3V
3.3V
Ground
GND
GND
NC
NC
PWM
NC
NC
INT
UART TX
RPD10
TX
UART RX
RPD15
RX
I2C Clock
RPA14
SCL
I2C Data
RPA15
SDA
NC
NC
5V
Ground
GND
GND
1

Take a closer look

Schematic

LR 10 Click Schematic schematic

Step by step

Project assembly

Curiosity PIC32MZ EF front image hardware assembly

Start by selecting your development board and Click board™. Begin with the Curiosity PIC32 MZ EF as your development board.

Curiosity PIC32MZ EF front image hardware assembly
GNSS2 Click front image hardware assembly
Prog-cut hardware assembly
GNSS2 Click complete accessories setup image hardware assembly
Curiosity PIC32 MZ EF MB 1 Access - upright/background hardware assembly
Necto image step 2 hardware assembly
Necto image step 3 hardware assembly
Necto image step 4 hardware assembly
Necto image step 5 hardware assembly
Necto image step 6 hardware assembly
Curiosity PIC32 MZ EF MCU Step hardware assembly
Necto No Display image step 8 hardware assembly
Necto image step 9 hardware assembly
Necto image step 10 hardware assembly
Debug Image Necto Step hardware assembly

Track your results in real time

Application Output

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

Application Output Step 1

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

Application Output Step 3

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

Application Output Step 4

Software Support

Library Description

This library contains API for LR 10 Click driver.

Key functions:

  • lr10_write_cmd - This function writes a desired command by using UART serial interface

  • lr10_write_cmd_sub_param - This function writes a desired command, subcommands and parameter by using UART serial interface

Open Source

Code example

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

/*!
 * @file main.c
 * @brief LR 10 Click Example.
 *
 * # Description
 * This example demonstrates the use of LR 10 click board by processing
 * the incoming data and displaying them on the USB UART.
 *
 * The demo application is composed of two sections :
 *
 * ## Application Init
 * Initializes the driver and performs a hardware reset of the device.
 *
 * ## Application Task
 * Depending on the selected mode, the application demo 
 * receives and processes all incoming data or sends the LoRa packet demo string. 
 * Results are being sent to the UART Terminal, where you can track their changes.
 *
 * ## Additional Function
 * - static void lr10_clear_app_buf ( void )
 * - static void lr10_log_app_buf ( void )
 * - static void lr10_log_receiver ( void )
 * - static err_t lr10_process ( lr10_t *ctx )
 *
 * @author Nenad Filipovic
 *
 */

#include "board.h"
#include "log.h"
#include "lr10.h"
#include "conversions.h"

// Comment the line below to switch application mode to receiver
#define DEMO_APP_TRANSMITTER

// Application buffer size
#define PROCESS_BUFFER_SIZE       200

// Default RF configuration
#define PROCESS_RF_CFG_DEFAULT    "868,SF7,125,8,8,14,ON,OFF,OFF"

// Application demo string
#define LR10_DEMO_STRING          "MikroE - LR 10 Click"

static lr10_t lr10;
static log_t logger;

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

/**
 * @brief LR 10 clearing application buffer.
 * @details This function clears memory of application buffer and reset its length.
 * @note None.
 */
static void lr10_clear_app_buf ( void );

/**
 * @brief LR 10 log application buffer.
 * @details This function logs data from application buffer to USB UART.
 * @note None.
 */
static void lr10_log_app_buf ( void );

/**
 * @brief LR 10 log receiver data.
 * @details This function logs data from receiver application buffer to USB UART.
 * @note None.
 */
static void lr10_log_receiver ( void );

/**
 * @brief LR 10 data reading function.
 * @details This function reads data from device and concatenates data to application buffer. 
 * @param[in] ctx : Click context object.
 * See #lr10_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 lr10_process ( lr10_t *ctx );

void application_init ( void ) 
{
    log_cfg_t log_cfg;  /**< Logger config object. */
    lr10_cfg_t lr10_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.
    lr10_cfg_setup( &lr10_cfg );
    LR10_MAP_MIKROBUS( lr10_cfg, MIKROBUS_1 );
    if ( UART_ERROR == lr10_init( &lr10, &lr10_cfg ) ) 
    {
        log_error( &logger, " Communication init." );
        for ( ; ; );
    }

    lr10_hw_reset( &lr10 );
    Delay_ms( 500 );

    lr10_generic_write( &lr10, LR10_CMD_AT, strlen(LR10_CMD_AT) );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );

    lr10_write_cmd( &lr10, LR10_CMD_VER );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );

    lr10_write_cmd( &lr10, LR10_CMD_ID );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );
    
    lr10_write_cmd_sub_param( &lr10, LR10_CMD_MODE, LR10_SUB_CMD_MODE_TEST, 
                                     LR10_SYMBOL_NULL, LR10_QUOTE_DISABLE );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );

    lr10_write_cmd( &lr10, LR10_CMD_TEST );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );

    lr10_inquire_cmd( &lr10, LR10_CMD_MODE );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );

#ifdef DEMO_APP_TRANSMITTER
    lr10_write_cmd_sub_param( &lr10, LR10_CMD_TEST, LR10_SUB_CMD_TEST_RFCFG, 
                                     PROCESS_RF_CFG_DEFAULT, LR10_QUOTE_DISABLE );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
    Delay_ms( 500 );
#endif
    
}

void application_task ( void ) 
{
#ifdef DEMO_APP_TRANSMITTER
    lr10_write_cmd_sub_param( &lr10, LR10_CMD_TEST, LR10_SUB_CMD_TEST_TX_STR, 
                                     LR10_DEMO_STRING, LR10_QUOTE_ENABLE );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_app_buf( );
        lr10_clear_app_buf( );
    }
#else
    lr10_write_cmd_param( &lr10, LR10_CMD_TEST, LR10_SUB_CMD_TEST_RX );
    if ( LR10_OK == lr10_process( &lr10 ) ) 
    {
        lr10_log_receiver( );
        lr10_clear_app_buf( );
    }
#endif
    Delay_ms( 1000 );   
}

void main ( void ) 
{
    application_init( );

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

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

static void lr10_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 void lr10_log_receiver ( void )
{
    for ( int32_t buf_cnt = 0; buf_cnt < app_buf_len; buf_cnt++ )
    {
        if ( ( app_buf[ buf_cnt ] == LR10_ASCII_SPACE ) && 
             ( app_buf[ buf_cnt + 1 ] == LR10_ASCII_QUOTE ) )
        {
            buf_cnt += 2;
            log_printf( &logger, "  Receive: " );
            for ( ; buf_cnt < app_buf_len - 3; buf_cnt += 2 )
            {
                uint8_t hex_in[ 3 ] = { 0 };
                hex_in[ 0 ] = app_buf[ buf_cnt ];
                hex_in[ 1 ] = app_buf[ buf_cnt + 1 ];
                log_printf( &logger, "%c", hex_to_uint8( hex_in ) );
            }
            log_printf( &logger, "\r\n" );
            break;
        }
    }
}

static err_t lr10_process ( lr10_t *ctx ) 
{
    uint8_t rx_buf[ PROCESS_BUFFER_SIZE ] = { 0 };
    int32_t overflow_bytes = 0;
    int32_t rx_cnt = 0;
    int32_t rx_size = lr10_generic_read( ctx, rx_buf, PROCESS_BUFFER_SIZE );
    if ( ( rx_size > 0 ) && ( rx_size <= PROCESS_BUFFER_SIZE ) ) 
    {
        if ( ( app_buf_len + rx_size ) > PROCESS_BUFFER_SIZE ) 
        {
            overflow_bytes = ( app_buf_len + rx_size ) - PROCESS_BUFFER_SIZE;
            app_buf_len = PROCESS_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 LR10_OK;
    }
    return LR10_ERROR;
}

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

Additional Support

Resources