Mistake on this page?
Report an issue in GitHub or email us


The LoRaWANInterface provides a C++ API for connecting to the internet over a LoRa network. This subsection explains the LoRaWANInterface API reference and then presents an example that you can directly import to Keil Studio Cloud.

To configure this class, please see the LoRa configuration documentation.

LoRaWANInterface class reference

Public Member Functions
 LoRaWANInterface (LoRaRadio &radio)
 Constructs a LoRaWANInterface using the LoRaWANStack instance underneath. More...
 LoRaWANInterface (LoRaRadio &radio, LoRaPHY &phy)
 Constructs a LoRaWANInterface using the user provided PHY object. More...
lorawan_status_t initialize (events::EventQueue *queue)
 Initialize the LoRa stack. More...
lorawan_status_t connect ()
 Connect OTAA or ABP using the Mbed OS config system. More...
lorawan_status_t connect (const lorawan_connect_t &connect)
 Connect OTAA or ABP with parameters. More...
lorawan_status_t disconnect ()
 Disconnect the current session. More...
lorawan_status_t add_link_check_request ()
 Validate the connectivity with the network. More...
void remove_link_check_request ()
 Removes link check request sticky MAC command. More...
lorawan_status_t set_datarate (uint8_t data_rate)
 Sets up a particular data rate. More...
lorawan_status_t enable_adaptive_datarate ()
 Enables adaptive data rate (ADR) More...
lorawan_status_t disable_adaptive_datarate ()
 Disables adaptive data rate. More...
lorawan_status_t set_confirmed_msg_retries (uint8_t count)
 Sets up the retry counter for confirmed messages. More...
lorawan_status_t set_channel_plan (const lorawan_channelplan_t &channel_plan)
 Sets the channel plan. More...
lorawan_status_t get_channel_plan (lorawan_channelplan_t &channel_plan)
 Gets the channel plans from the LoRa stack. More...
lorawan_status_t remove_channel_plan ()
 Removes an active channel plan. More...
lorawan_status_t remove_channel (uint8_t index)
 Removes a single channel. More...
int16_t send (uint8_t port, const uint8_t *data, uint16_t length, int flags)
 Send message to gateway. More...
int16_t receive (uint8_t port, uint8_t *data, uint16_t length, int flags)
 Receives a message from the Network Server on a specific port. More...
int16_t receive (uint8_t *data, uint16_t length, uint8_t &port, int &flags)
 Receives a message from the Network Server on any port. More...
lorawan_status_t add_app_callbacks (lorawan_app_callbacks_t *callbacks)
 Add application callbacks to the stack. More...
lorawan_status_t set_device_class (device_class_t device_class)
 Change device class. More...
lorawan_status_t get_tx_metadata (lorawan_tx_metadata &metadata)
 Get hold of TX meta-data. More...
lorawan_status_t get_rx_metadata (lorawan_rx_metadata &metadata)
 Get hold of RX meta-data. More...
lorawan_status_t get_backoff_metadata (int &backoff)
 Get hold of backoff time. More...
lorawan_status_t cancel_sending (void)
 Cancel outgoing transmission. More...
void lock (void)
 Provides exclusive access to the stack. More...
void unlock (void)
 Releases exclusive access to the stack. More...

LoRaWAN example

Go to https://github.com/ARMmbed/mbed-os-example-lorawan and follow the instructions in the README.md.

 * Copyright (c) 2017, Arm Limited and affiliates.
 * SPDX-License-Identifier: Apache-2.0
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * See the License for the specific language governing permissions and
 * limitations under the License.
#include <stdio.h>

#include "lorawan/LoRaWANInterface.h"
#include "lorawan/system/lorawan_data_structures.h"
#include "events/EventQueue.h"

// Application helpers
#include "DummySensor.h"
#include "trace_helper.h"
#include "lora_radio_helper.h"

using namespace events;

// Max payload size can be LORAMAC_PHY_MAXPAYLOAD.
// This example only communicates with much shorter messages (<30 bytes).
// If longer messages are used, these buffers must be changed accordingly.
uint8_t tx_buffer[30];
uint8_t rx_buffer[30];

 * Sets up an application dependent transmission timer in ms. Used only when Duty Cycling is off for testing
#define TX_TIMER                        10000

 * Maximum number of events for the event queue.
 * 10 is the safe number for the stack events, however, if application
 * also uses the queue for whatever purposes, this number should be increased.
#define MAX_NUMBER_OF_EVENTS            10

 * Maximum number of retries for CONFIRMED messages before giving up

 * Dummy pin for dummy sensor
#define PC_9                            0

 * Dummy sensor class object
DS1820  ds1820(PC_9);

* This event queue is the global event queue for both the
* application and stack. To conserve memory, the stack is designed to run
* in the same thread as the application and the application is responsible for
* providing an event queue to the stack that will be used for ISR deferment as
* well as application information event queuing.
static EventQueue ev_queue(MAX_NUMBER_OF_EVENTS *EVENTS_EVENT_SIZE);

 * Event handler.
 * This will be passed to the LoRaWAN stack to queue events for the
 * application which in turn drive the application.
static void lora_event_handler(lorawan_event_t event);

 * Constructing Mbed LoRaWANInterface and passing it the radio object from lora_radio_helper.
static LoRaWANInterface lorawan(radio);

 * Application specific callbacks
static lorawan_app_callbacks_t callbacks;

 * Entry point for application
int main(void)
    // setup tracing

    // stores the status of a call to LoRaWAN protocol
    lorawan_status_t retcode;

    // Initialize LoRaWAN stack
    if (lorawan.initialize(&ev_queue) != LORAWAN_STATUS_OK) {
        printf("\r\n LoRa initialization failed! \r\n");
        return -1;

    printf("\r\n Mbed LoRaWANStack initialized \r\n");

    // prepare application callbacks
    callbacks.events = mbed::callback(lora_event_handler);

    // Set number of retries in case of CONFIRMED messages
    if (lorawan.set_confirmed_msg_retries(CONFIRMED_MSG_RETRY_COUNTER)
            != LORAWAN_STATUS_OK) {
        printf("\r\n set_confirmed_msg_retries failed! \r\n\r\n");
        return -1;

    printf("\r\n CONFIRMED message retries : %d \r\n",

    // Enable adaptive data rate
    if (lorawan.enable_adaptive_datarate() != LORAWAN_STATUS_OK) {
        printf("\r\n enable_adaptive_datarate failed! \r\n");
        return -1;

    printf("\r\n Adaptive data  rate (ADR) - Enabled \r\n");

    retcode = lorawan.connect();

    if (retcode == LORAWAN_STATUS_OK ||
            retcode == LORAWAN_STATUS_CONNECT_IN_PROGRESS) {
    } else {
        printf("\r\n Connection error, code = %d \r\n", retcode);
        return -1;

    printf("\r\n Connection - In Progress ...\r\n");

    // make your event queue dispatching events forever

    return 0;

 * Sends a message to the Network Server
static void send_message()
    uint16_t packet_len;
    int16_t retcode;
    int32_t sensor_value;

    if (ds1820.begin()) {
        sensor_value = ds1820.read();
        printf("\r\n Dummy Sensor Value = %d \r\n", sensor_value);
    } else {
        printf("\r\n No sensor found \r\n");

    packet_len = sprintf((char *) tx_buffer, "Dummy Sensor Value is %d",

    retcode = lorawan.send(MBED_CONF_LORA_APP_PORT, tx_buffer, packet_len,

    if (retcode < 0) {
        retcode == LORAWAN_STATUS_WOULD_BLOCK ? printf("send - WOULD BLOCK\r\n")
        : printf("\r\n send() - Error code %d \r\n", retcode);

        if (retcode == LORAWAN_STATUS_WOULD_BLOCK) {
            //retry in 3 seconds
            if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
                ev_queue.call_in(3000, send_message);

    printf("\r\n %d bytes scheduled for transmission \r\n", retcode);
    memset(tx_buffer, 0, sizeof(tx_buffer));

 * Receive a message from the Network Server
static void receive_message()
    uint8_t port;
    int flags;
    int16_t retcode = lorawan.receive(rx_buffer, sizeof(rx_buffer), port, flags);

    if (retcode < 0) {
        printf("\r\n receive() - Error code %d \r\n", retcode);

    printf(" RX Data on port %u (%d bytes): ", port, retcode);
    for (uint8_t i = 0; i < retcode; i++) {
        printf("%02x ", rx_buffer[i]);
    memset(rx_buffer, 0, sizeof(rx_buffer));

 * Event handler
static void lora_event_handler(lorawan_event_t event)
    switch (event) {
        case CONNECTED:
            printf("\r\n Connection - Successful \r\n");
            if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
            } else {
                ev_queue.call_every(TX_TIMER, send_message);

        case DISCONNECTED:
            printf("\r\n Disconnected Successfully \r\n");
        case TX_DONE:
            printf("\r\n Message Sent to Network Server \r\n");
            if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
        case TX_TIMEOUT:
        case TX_ERROR:
        case TX_CRYPTO_ERROR:
            printf("\r\n Transmission Error - EventCode = %d \r\n", event);
            // try again
            if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
        case RX_DONE:
            printf("\r\n Received message from Network Server \r\n");
        case RX_TIMEOUT:
        case RX_ERROR:
            printf("\r\n Error in reception - Code = %d \r\n", event);
        case JOIN_FAILURE:
            printf("\r\n OTAA Failed - Check Keys \r\n");
        case UPLINK_REQUIRED:
            printf("\r\n Uplink required by NS \r\n");
            if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
            MBED_ASSERT("Unknown Event");

// EOF

Important Information for this Arm website

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.