Sending several bytes with LoRa

allardna · March 1, 2021, 11:04am

Hello everyone,
I’m working on a project using Lorawan in which I need to send 7 bytes over Lora. I’m using the LoraAPI example and I only can send data byte to byte. Therefore I modified the code by using the send function 7 times to send my data to the gateway. By the way, I’m using TTN console to see the data I sent. It seems to send properly (I’m looking at the serial transmission if the board sends the send confirmation message. And I check with LEDs too.

Here is my code (sorry it’s not very clean)

/**

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,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include <stdio.h>
#include “mbed.h”
#include “lorawan/LoRaWANInterface.h”
#include “lorawan/system/lorawan_data_structures.h”
#include “events/EventQueue.h”

// Application helpers

#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
*/
#define CONFIRMED_MSG_RETRY_COUNTER 3

/**

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
setup_trace();

// 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);
lorawan.add_app_callbacks(&callbacks);

// 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”,
CONFIRMED_MSG_RETRY_COUNTER);

// 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
ev_queue.dispatch_forever();

return 0;
}

/**

Sends a message to the Network Server
*/
static void send_message(uint8_t Octet_envoye) {

static DigitalOut led(LED1, 0);

// create a one-byte payload which contains whether the PIR sensor is high or low

uint8_t buffer1 = {Octet_envoye};
int16_t retcode = lorawan.send(MBED_CONF_LORA_APP_PORT, buffer1, sizeof(buffer1), MSG_CONFIRMED_FLAG);

led =1;
ThisThread::sleep_for(500);
led=0;

if (retcode != 0) {
printf(“Sent message over LoRaWAN successfully!\n”);

}
else {
printf(“Failed to send message (duty-cycle violation?) (%d)\n”, retcode);
}
}

/**

Receive a message from the Network Server
*/
static void receive_message() {

int16_t retcode = lorawan.receive(MBED_CONF_LORA_APP_PORT, rx_buffer,
LORAMAC_PHY_MAXPAYLOAD,
MSG_CONFIRMED_FLAG|MSG_UNCONFIRMED_FLAG);

// ignore errors while retrieving
if (retcode < 0) return;

printf(“Received %d bytes: “, retcode);
for (uint8_t i = 0; i < retcode; i++) {
printf(”%x”, rx_buffer[i]);
}
printf(“\n”);
}

/**

Event handler
*/
static void lora_event_handler(lorawan_event_t event)
{
static DigitalOut led2(LED3, 0);
static DigitalOut led3(LED4, 0);
switch (event) {
case CONNECTED:
printf(“\r\n Connection - Successful \r\n”);
if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
send_message(1);

     } else {
         ev_queue.call_every(TX_TIMER, send_message,1);
     }

     break;
 case DISCONNECTED:
     ev_queue.break_dispatch();
     printf("\r\n Disconnected Successfully \r\n");
     break;
 case TX_DONE:
     printf("\r\n Message Sent to Network Server \r\n");
     if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
         send_message(5);
         ThisThread::sleep_for(5000);
         send_message(4);
         ThisThread::sleep_for(5000);
         send_message(2);
         ThisThread::sleep_for(5000);
         send_message(8);
         ThisThread::sleep_for(5000);
         send_message(11);
         ThisThread::sleep_for(5000);
         send_message(143);
         ThisThread::sleep_for(5000);
         send_message(60);
         led3=1;
         ThisThread::sleep_for(500);
         led3=0;
     }
     break;
 case TX_TIMEOUT:
 case TX_ERROR:
 case TX_CRYPTO_ERROR:
 case TX_SCHEDULING_ERROR:
     printf("\r\n Transmission Error - EventCode = %d \r\n", event);
     // try again
     if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
         send_message(1);
     }
     break;
 case RX_DONE:
     printf("\r\n Received message from Network Server \r\n");
     receive_message();
     break;
 case RX_TIMEOUT:
 case RX_ERROR:
     printf("\r\n Error in reception - Code = %d \r\n", event);
     break;
 case JOIN_FAILURE:
     printf("\r\n OTAA Failed - Check Keys \r\n");
     break;
 case UPLINK_REQUIRED:
     printf("\r\n Uplink required by NS \r\n");
     if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
         send_message(1);
     }
     break;
 default:
     MBED_ASSERT("Unknown Event");

}
}

// EOF

The code is compiling well, and the 5 seconds was to see if it was a syncro problem with TTN.

Thanks in advance,

Natan

Topic		Replies	Views
Sending 64bits of data using LoRaWAN Application development	1	468	June 24, 2021
Encoding library/ functions for LORAWAN/ TTN Mbed OS mbed_os	0	318	April 3, 2020
Assistance Needed: Sending Data to The Things Network using LoRa-E5-Dev-Board and Mbed OS Mbed OS mbed_os	0	32	August 7, 2024
LoRaWAN timeouts and general misbehavior Mbed OS	3	610	September 23, 2021
Mbed Simulator LoRaWAN example -- Where's the encoder? Mbed OS lora	1	777	March 15, 2021

Sending several bytes with LoRa

Related topics