Followup: LoRaWAN: How to set spreading factor, output power, bandwidth?

[Krulknul]

Following discussion #1169, I noticed something else that confused me regarding the radio controls in RadioLib.

Summarizing that other discussion, I was able to connect my device to the things network and upload data. Right now I would really like to test the performance under different radio settings and see how often I can transmit under those settings according to law and FUP.

Following discussion #1170, where I asked this same question, I am reposting my question here with the parameters adjusted to fall within legal norms, according to suggestions by @StevenCellist and @HeadBoffin.

I have the following program:

#include <Arduino.h>
#include "utilities.h"
#include "RadioLib.h"
#include "LoRaBoards.h"
#include "SparkFun_Ublox_Arduino_Library.h"
SFE_UBLOX_GPS myGPS;

// !!!!! APP EUI
#define RADIOLIB_LORAWAN_JOIN_EUI [redacted]
// !!!!! DEV EUI
#define RADIOLIB_LORAWAN_DEV_EUI [redacted]
// !!!!! APP EUI
#define RADIOLIB_LORAWAN_APP_KEY [redacted]
// !!! APP KEY
#define RADIOLIB_LORAWAN_NWK_KEY [redacted]

uint64_t joinEUI = RADIOLIB_LORAWAN_JOIN_EUI;
uint64_t devEUI = RADIOLIB_LORAWAN_DEV_EUI;
uint8_t appKey[] = {RADIOLIB_LORAWAN_APP_KEY};
uint8_t nwkKey[] = {RADIOLIB_LORAWAN_NWK_KEY};

const uint32_t uplinkIntervalSeconds = 60UL * 60UL; // minutes x seconds

const LoRaWANBand_t Region = EU868;
const uint8_t subBand = 0; // For US915, change this to 2, otherwise leave on 0

SX1276 radio = new Module(RADIO_CS_PIN, RADIO_DIO0_PIN, RADIO_RST_PIN, RADIO_DIO1_PIN);

LoRaWANNode node(&radio, &Region, subBand);

void debug(bool isFail, const __FlashStringHelper *message, int state, bool Freeze)
{
  if (isFail)
  {
    Serial.print(message);
    Serial.print("(");
    Serial.print(state);
    Serial.println(")");
    while (Freeze)
      ;
  }
}

void encodeCoordinates(byte *buffer, long latitude, long longitude)
{
  // Store first long (4 bytes)
  buffer[0] = (latitude >> 24) & 0xFF;
  buffer[1] = (latitude >> 16) & 0xFF;
  buffer[2] = (latitude >> 8) & 0xFF;
  buffer[3] = latitude & 0xFF;

  // Store second long (4 bytes)
  buffer[4] = (longitude >> 24) & 0xFF;
  buffer[5] = (longitude >> 16) & 0xFF;
  buffer[6] = (longitude >> 8) & 0xFF;
  buffer[7] = longitude & 0xFF;
}

void setup()
{
  setupBoards();

  Serial.begin(9600);
  while (!Serial.available())
    delay(1000);

  Serial.println(F("Starting up"));

  Serial1.begin(GPS_BAUD_RATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
  if (myGPS.begin(Serial1) == false) // Connect to the Ublox module using serial port 1
  {
    Serial.println(F("Ublox GPS could not start."));
    while (1)
      delay(1000);
  }

  int state = radio.begin();
  debug(state != RADIOLIB_ERR_NONE, F("Initialise radio failed"), state, true);

  node.setADR(false);
  if (radio.setSpreadingFactor(8) != RADIOLIB_ERR_NONE)
  {
    Serial.println(F("Error setting spreading factor"));
  }

  while (1)
  {

    Serial.println(F("joining TTN"));
    node.beginOTAA(joinEUI, devEUI, nwkKey, appKey);
    state = node.activateOTAA();
    if (state == RADIOLIB_ERR_NONE || state == RADIOLIB_LORAWAN_NEW_SESSION)
    {
      Serial.println(F("Join successful"));
      break;
    }
    debug(state != RADIOLIB_ERR_NONE, F("Join failed"), state, false);
    delay(10000);
    Serial.print("Retry ");
  }
}

void loop()
{
  // get a GPS fix
  long latitude = myGPS.getLatitude();
  long longitude = myGPS.getLongitude();
  Serial.printf("%d %d\n", latitude, longitude);

  Serial.println("Sending uplink");

  byte payload[8];
  encodeCoordinates(payload, latitude, longitude);

  // Perform an uplink
  int state = node.sendReceive(payload, sizeof(payload));
  debug((state != RADIOLIB_LORAWAN_NO_DOWNLINK) && (state != RADIOLIB_ERR_NONE), F("Error in sendReceive"), state, false);
  Serial.printf("Uplink complete, next in %d seconds\n", uplinkIntervalSeconds);
  Serial.printf("Allowed in: %d\n", node.timeUntilUplink());
  Serial.printf("Last uplink: %d\n", node.getLastToA());

  // Wait until next uplink - observing legal & TTN FUP constraints
  delay(uplinkIntervalSeconds * 1000UL); // delay needs milli-seconds
}

As you can see, I am using node.setADR(false) to free myself from ADR, and then I try to set the spreading factor to 8. However, when I observe my uplinks on the TTN console, I see the following:

"settings": {
  "data_rate": {
    "lora": {
      "bandwidth": 125000,
      "spreading_factor": 10,
      "coding_rate": "4/5"
    }
  },
  "frequency": "867900000",
  "timestamp": 3218191924,
  "time": "2024-07-25T15:58:27.557965040Z"
},

The spreading factor observed by TTN seems to still be 10. This is also confirmed by the duration of my uplink as reported by RadioLib:
Last uplink: 371
371 ms of airtime; which corresponds pretty clearly to an SF of 10 as per this airtime calculator

I have also tried an SF of 7, with a high bandwidth of 250 as specified by that airtime calculator, but I get the same result in the TTN console, including the lower bandwidth.

How do I change these settings? It doesn't seem like this is working right now, judging by the values reported by TTN and even RadioLib itself.

[HeadBoffin]

Bearing in mind that RadioLib can be used for LoRa point to point as well, the LoRaWAN layers over the top like Shrek an onion - so the radio.setSpreadingFactor() call is then overridden when the LW stack setups an uplink with its settings.

So all LW config needs to do act on the node, in this case you to use the node.setDatarate() function.

You can ask @StevenCellist when you meet him why it's DR for LW and SF for the radio.

DR6 aka SF7 BW250 isn't in common use with TTN, hence it being greyed out in the calculator.

The TxPower works in steps of two from 16 down in the EU. The TTS algorithm works to reduce the DR first to reduce airtime. the precious resource, and the LoRa Alliance expect providers to restrict the use of SF11 & 12 due to the time on air - which is also far more susceptible to interference from other transmissions due to the duration.

So if you want to try the TxPower, do it on DR5.

All that said, RF antennas a couple of inches above the ground are pretty poor radiators, so by the time you've got to DR5 it won't be working so well and reducing the power will only make it worse.

In context for the vast majority of LW devices, ADR is on and the LNS just sorts this out - hence the suggestion to start at the very beginning, it's a great place for nuns teaching you to sing as well as many layered radio systems.

Another approach to tracking which does work nicely is LoRa point to point which I use for High Altitude Balloon projects with schools - far more flexibility for small bursts of info and 433MHz has much better range.

[Krulknul]

Thank you very much for that detailed response. Good to know that I'll have to change these settings on the node object, I'll try that out.

I was indeed also planning to try something peer to peer, and then maybe I could use TTN as a backup. I read in some other issue/discussion that it should be theoretically possible to use the LoRa module both peer to peer and with LoRaWAN, but that I may need to re-initialise the module to avoid them interfering with each other. Would you happen to know if this is the case? Are there any known examples of this?

[StevenCellist]

So far, we haven't seen reports of people using RadioLib to mix both P2P and LW, but my work of a month or two ago should allow both to coexist without any additional problems. You should be able to do a node.sendReceive(), do anything you want with the radio. methods (such as setSF, setTx, send, receive etc) and then again call node.sendReceive() as if nothing happened in between.

Feel free to give it a shot, and please report back on your findings as once every so often people come along to try it. So if we know that it works, we can recommend it - if it doesn't work, I'd like to know what happened so I can fix it :)