plm100s/IPv6overLoRaWAN/main.cpp

#include <cox.h>
#include <IPv6.hpp>
#include <IPv6LoRaWAN.hpp>
#include <CoAPRequest.hpp>
 
#define OVER_THE_AIR_ACTIVATION 1
 
#include "LoRaMacKR920.hpp"
LoRaMacKR920 LoRaWAN = LoRaMacKR920(SX1276);
 
Timer timerSend;
 
static const uint8_t devEui[] = "\x00\x11\x22\x33\x44\x55\x66\x77";
static const uint8_t appEui[] = "\x00\x00\x00\x00\x00\x00\x00\x01";
 
#if (OVER_THE_AIR_ACTIVATION == 1)
static uint8_t appKey[16];
 
char keyBuf[128];
Timer timerKeyInput;
 
#include <nrf5x/nRF5xFlashPage.hpp>
nRF5xFlashPage ConfigMemory(0x7F000);
#else
 
static const uint8_t NwkSKey[] = "\xa4\x88\x55\xad\xe9\xf8\xf4\x6f\xa0\x94\xb1\x98\x36\xc3\xc0\x86";
static const uint8_t AppSKey[] = "\x7a\x56\x2a\x75\xd7\xa3\xbd\x89\xa3\xde\x53\xe1\xcf\x7f\x1c\xc7";
static uint32_t DevAddr = 0x06e632e8;
#endif //OVER_THE_AIR_ACTIVATION
 
IPv6 ipv6;
IPv6LoRaWAN ipv6LoRaWAN(LoRaWAN, 222);
uint16_t txCnt = 0;
 
static void eventCoAPResponse(CoAPRequest &req, const CoAPRequest::ResponseInfo_t *response) {
  if (response) {
    printf("* Got something CoAP response (%d.%02d):", response->code >> 5, response->code & 0x1F);
    for (size_t i = 0; i < response->payloadLen; i++) {
      printf(" %02X", response->payload[i]);
    }
    if (response->location) {
      printf(", location:%s\n", response->location);
    }
    printf("\n");
  } else {
    printf("* No response\n");
  }
  delete &req;
 
  timerSend.startOneShot(10000);
}
 
static void taskPeriodicSend(void *) {
  CoAPRequest *req = new CoAPRequest();
  if (!req) {
    printf("* Not enough memory to make a CoAPRequest.\n");
    return;
  }
 
  req->open(CoAP::GET, "coap://[fe80::1]/time", &ipv6LoRaWAN);
  req->onResponse(eventCoAPResponse);
 
  error_t err = req->send();
  if (err != ERROR_SUCCESS) {
    printf("* Sending a CoAPRequest error:%d\n", err);
    delete req;
  } else {
    printf("* Sending a CoAPRequest success.\n");
  }
}
 
#if (OVER_THE_AIR_ACTIVATION == 1)
static void eventLoRaWANJoin(
  LoRaMac &lw,
  bool joined,
  const uint8_t *joinedDevEui,
  const uint8_t *joinedAppEui,
  const uint8_t *joinedAppKey,
  const uint8_t *joinedNwkSKey,
  const uint8_t *joinedAppSKey,
  uint32_t joinedDevAddr,
  const RadioPacket &,
  uint32_t airTime
) {
  Serial.printf("* Tx time of JoinRequest: %lu usec.\n", airTime);
 
  if (joined) {
    Serial.println("* Joining done!");
    postTask(taskPeriodicSend, NULL);
  } else {
    Serial.println("* Joining failed. Retry to join.");
    lw.beginJoining(devEui, appEui, appKey);
  }
}
#endif //OVER_THE_AIR_ACTIVATION
 
static void eventLoRaWANJoinRequested(
  LoRaMac &, uint32_t frequencyHz, const LoRaMac::DatarateParams_t &dr
) {
  printf("* JoinRequested(Frequency: %lu Hz, Modulation: ", frequencyHz);
  if (dr.mod == Radio::MOD_FSK) {
    printf("FSK\n");
  } else if (dr.mod == Radio::MOD_LORA) {
    const char *strLoRaBW[] = { "UNKNOWN", "125kHz", "250kHz", "500kHz" };
    printf("LoRa, SF:%u, BW:%s)\n", dr.param.LoRa.sf, strLoRaBW[dr.param.LoRa.bw]);
  }
}
 
static void printChannelInformation(LoRaMac &lw) {
  printf("* Channel list:");
  for (uint8_t i = 0; i < lw.MaxNumChannels; i++) {
    const LoRaMac::ChannelParams_t *p = lw.getChannel(i);
    if (p) {
      printf(" [%u] %lu Hz", i, p->Frequency);
    } else {
      printf(" [%u] NA", i);
    }
  }
  printf("\n");
 
  const LoRaMac::DatarateParams_t *dr = lw.getDatarate(lw.getCurrentDatarateIndex());
  printf(" - Default DR%u:", lw.getCurrentDatarateIndex());
  if (dr->mod == Radio::MOD_LORA) {
    printf("LoRa(SF%u BW:", dr->param.LoRa.sf);
    switch (dr->param.LoRa.bw) {
    case Radio::BW_125kHz: printf("125kHz\n"); break;
    case Radio::BW_250kHz: printf("250kHz\n"); break;
    case Radio::BW_500kHz: printf("500kHz\n"); break;
    default: printf("(unexpected:%u)\n", dr->param.LoRa.bw); break;
    }
  } else if (dr->mod == Radio::MOD_FSK) {
    printf("FSK\n");
  } else {
    printf("Unknown modulation\n");
  }
 
  printf(" - Default Tx index: %d\n", lw.getCurrentTxPowerIndex());
  printf(
    " - # of repetitions of unconfirmed uplink frames: %u\n",
    lw.getNumRepetitions()
  );
}
 
#if (OVER_THE_AIR_ACTIVATION == 1)
 
static void taskBeginJoin(void *) {
  Serial.stopListening();
  Serial.println("* Let's start join!");
  LoRaWAN.beginJoining(devEui, appEui, appKey);
}
 
static void eventAppKeyInput(SerialPort &) {
  uint8_t numOctets = strlen(keyBuf);
  if (numOctets == 32) {
    numOctets /= 2;
    char strOctet[3];
 
    for (uint8_t j = 0; j < numOctets; j++) {
      strOctet[0] = keyBuf[2 * j];
      strOctet[1] = keyBuf[2 * j + 1];
      strOctet[2] = '\0';
 
      appKey[j] = strtoul(strOctet, NULL, 16);
    }
 
    printf("* New AppKey:");
    for (uint8_t j = 0; j < numOctets; j++) {
      printf(" %02X", appKey[j]);
    }
    printf(" (%u byte)\n", numOctets);
    ConfigMemory.write(appKey, 0, numOctets);
    postTask(taskBeginJoin, NULL);
    return;
  } else {
    printf("* HEX string length MUST be 32-byte.");
  }
 
  Serial.inputKeyboard(keyBuf, sizeof(keyBuf) - 1);
}
 
static void eventKeyInput(SerialPort &) {
  timerKeyInput.stop();
  while (Serial.available() > 0) {
    Serial.read();
  }
 
  Serial.onReceive(eventAppKeyInput);
  Serial.inputKeyboard(keyBuf, sizeof(keyBuf) - 1);
  Serial.println(
    "* Enter a new appKey as a hexadecimal string "
    "[ex. 00112233445566778899aabbccddeeff]"
  );
}
 
#endif //OVER_THE_AIR_ACTIVATION
 
void setup() {
  Serial.begin(115200);
  Serial.printf("\n*** [Nol.Board] IPv6 over LoRaWAN ***\n");
 
  System.setTimeDiff(9 * 60);  // KST
 
  timerSend.onFired(taskPeriodicSend, NULL);
 
  LoRaWAN.begin();
 
#if (OVER_THE_AIR_ACTIVATION == 1)
  LoRaWAN.onJoin(eventLoRaWANJoin);
#endif
 
  LoRaWAN.onJoinRequested(eventLoRaWANJoinRequested);
  LoRaWAN.setPublicNetwork(false);
 
  printChannelInformation(LoRaWAN);
 
#if (OVER_THE_AIR_ACTIVATION == 0)
  printf("ABP!\n");
  LoRaWAN.setABP(NwkSKey, AppSKey, DevAddr);
  LoRaWAN.setNetworkJoined(true);
 
  postTask(taskPeriodicSend, NULL);
#else
  Serial.printf(
    "* DevEUI: %02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
    devEui[0], devEui[1], devEui[2], devEui[3],
    devEui[4], devEui[5], devEui[6], devEui[7]
  );
 
  ConfigMemory.read(appKey, 0, 16);
  Serial.printf(
    "* AppKey: %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
    appKey[0], appKey[1], appKey[2], appKey[3],
    appKey[4], appKey[5], appKey[6], appKey[7],
    appKey[8], appKey[9], appKey[10], appKey[11],
    appKey[12], appKey[13], appKey[14], appKey[15]
  );
 
  if (memcmp(appKey, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 16) == 0) {
    /* The appKey is required to be entered by user.*/
    Serial.onReceive(eventAppKeyInput);
    Serial.inputKeyboard(keyBuf, sizeof(keyBuf) - 1);
    Serial.println(
      "* Enter a new appKey as a hexadecimal string "
      "[ex. 00112233445566778899aabbccddeeff]"
    );
  } else {
    Serial.println("* Press any key to enter a new appKey in 3 seconds...");
    timerKeyInput.onFired(taskBeginJoin, NULL);
    timerKeyInput.startOneShot(3000);
    Serial.onReceive(eventKeyInput);
  }
 
  Serial.listen();
 
#endif //OVER_THE_AIR_ACTIVATION
 
  pinMode(GPIO1, OUTPUT);
  digitalWrite(GPIO1, LOW);
 
  ipv6LoRaWAN.begin(devEui, appEui);
  ipv6.begin();
}