plm100s/PLS100W_TFmini-UART/main.cpp

#include <cox.h>
#include <algorithm>
#include <LoRaMacKR920.hpp>
#include <nrf5x/nRF5xFlashPage.hpp>
 
//#define SENSOR_TEST_MODE
 
nRF5xFlashPage configMemory(0x76000);
char keyBuf[128];
Timer timerKeyInput;
 
LoRaMacKR920 LoRaWAN = LoRaMacKR920(SX1276);
 
Timer timerSend;
 
struct {
  uint16_t meter;
  uint16_t strength;
  uint16_t temp;
} res;
 
int recv_flag = 0;
uint8_t msg_data[10];
uint8_t data_index = 0;
uint8_t msg_checksum = 0;
 
static uint8_t devEui[8];
static uint8_t appKey[16];
 
static void decode_TFmini(){
  memcpy(&res.meter, &msg_data[0], sizeof(uint16_t));
  memcpy(&res.strength, &msg_data[2], sizeof(uint16_t));
  memcpy(&res.temp, &msg_data[4], sizeof(uint16_t));
  res.temp = (res.temp / 8) - 256 ;
#ifdef SENSOR_TEST_MODE
  printf("meter : %d, strength : %d, temp : %d\r\n",res.meter,res.strength,res.temp);
#endif
}
 
static void taskPeriodicSend(void *) {
  LoRaMacFrame *f = new LoRaMacFrame(255);
  if (!f || !f->buf) {
    printf("* Out of memory\n");
    return;
  }
 
  f->port = 1;
  f->type = LoRaMacFrame::UNCONFIRMED;
  f->len = snprintf((char *) f->buf, 50, "\"cm\":%d,\"strength\":%d,\"temp\":%d", res.meter, res.strength, res.temp);
 
  /* Uncomment below lines to specify parameters manually. */
  error_t err = LoRaWAN.send(f);
  printf("* Sending periodic report (%p:%s (%u byte)): %d\n", f, (const char *) f->buf, f->len, err);
  if (err != ERROR_SUCCESS) {
 
    delete f;
  }
}
 
static void eventLoRaWANJoin(
  LoRaMac &,
  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 &frame,
  uint32_t
) {
  if (joined) {
    printf("* Joined to the network!\n");
    postTask(taskPeriodicSend);
    timerSend.startPeriodic(10000);
  } else {
    printf("* Join failed. Retry to join\n");
    LoRaWAN.beginJoining(devEui, appKey);
  }
}
 
static void eventLoRaWANSendDone(LoRaMac &, LoRaMacFrame *frame) {
  printf("* Send done(%d): [%p] destined for port[%u], Freq:%lu Hz, Power:%d dBm, # of Tx:%u, ", frame->result, frame, frame->port, frame->freq, frame->power, frame->numTrials);
  if (frame->modulation == Radio::MOD_LORA) {
    const char *strBW[] = { "Unknown", "125kHz", "250kHz", "500kHz", "Unexpected value" };
    if (frame->meta.LoRa.bw > 3) {
      frame->meta.LoRa.bw = (Radio::LoRaBW_t) 4;
    }
    printf("LoRa, SF:%u, BW:%s, ", frame->meta.LoRa.sf, strBW[frame->meta.LoRa.bw]);
  } else if (frame->modulation == Radio::MOD_FSK) {
    printf("FSK, ");
  } else {
    printf("Unkndown modulation, ");
  }
  if (frame->type == LoRaMacFrame::UNCONFIRMED) {
    printf("UNCONFIRMED");
  } else if (frame->type == LoRaMacFrame::CONFIRMED) {
    printf("CONFIRMED");
  } else if (frame->type == LoRaMacFrame::MULTICAST) {
    printf("MULTICAST (error)");
  } else if (frame->type == LoRaMacFrame::PROPRIETARY) {
    printf("PROPRIETARY");
  } else {
    printf("unknown type");
  }
  if ( frame->result == RadioPacket::TOO_BIG){
    printf("- TOO BIG\n");
    delete frame;
    return;
  }
 
  printf(" frame\n");
  delete frame;
 
}
 
static void eventLoRaWANReceive(LoRaMac &lw, const LoRaMacFrame *frame) {
  printf("* Received:");
  for (uint8_t i = 0; i < frame->len; i++) {
    printf(" %02X", frame->buf[i]);
  }
  printf(" (");
  frame->printTo(Serial);
  printf(")\n");
 
  if (
    (frame->type == LoRaMacFrame::CONFIRMED || lw.framePending) &&
    lw.getNumPendingSendFrames() == 0
  ) {
    // If there is no pending send frames, send an empty frame to ack or pull more frames.
    LoRaMacFrame *emptyFrame = new LoRaMacFrame(0);
    if (emptyFrame) {
      error_t err = LoRaWAN.send(emptyFrame);
      if (err != ERROR_SUCCESS) {
        delete emptyFrame;
      }
    }
  }
}
 
int check_checksum(){
  uint8_t checksum = 0;
  checksum += 0x59;
  checksum += 0x59;
  for (int i = 0 ; i < 6; i++){
    checksum += msg_data[i];
  }
  // printf("checksum: %d , msg_checksum: %d\r\n",checksum, msg_checksum);
  if (checksum == msg_checksum){
    return 1;
  } else{
    return 0;
  }
}
 
static void receivemsg(SerialPort &p) {
  while (p.available() > 0){
    uint8_t msg_byte = p.read();
    switch (recv_flag){
    case 0:
      (msg_byte == 0x59) ? recv_flag++ : recv_flag ;
      break;
    case 1:
      if (msg_byte == 0x59){
        recv_flag++;
      } else {
        recv_flag = 0;
      }
      break;
    case 2:
      msg_data[data_index] = msg_byte;
      data_index++;
      if (data_index == 6){
        recv_flag++;
        data_index = 0;
      }
      break;
    case 3:
      msg_checksum = msg_byte;
      if (check_checksum()){
        decode_TFmini();
        recv_flag = 0;
      }else {
        // printf("checksum Error!\r\n");
        recv_flag = 0;
      }
      break;
    }
  }
}
 
static void beginLoRaWAN(void *) {
  LoRaWAN.begin();
  LoRaWAN.onSendDone(eventLoRaWANSendDone);
  LoRaWAN.onReceive(eventLoRaWANReceive);
  LoRaWAN.onJoin(eventLoRaWANJoin);
  LoRaWAN.setPublicNetwork(true);
  LoRaWAN.beginJoining(devEui, 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(beginLoRaWAN);
    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.listen();
  Serial.inputKeyboard(keyBuf, sizeof(keyBuf) - 1);
  Serial.println(
    "* Enter a new appKey as a hexadecimal string "
    "[ex. 00112233445566778899aabbccddeeff]"
  );
}
 
void setup() {
  Serial.begin(115200);
  Serial.printf("\n*** [PLS100W] TFmini-UART + LoRaWAN ***\n");
  System.getEUI(devEui);
  Serial.printf("* EUI: %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]);
 
  Serial.printf("* Last reset reason:0x%02X\n", System.getResetReason());
  if (System.getResetReason() & (System.RESET_REASON_DOG | System.RESET_REASON_SREQ)) {
    const McuARMCortexM::CoreRegisterDump *last = System.getLastCoreRegisterDump();
    Serial.printf(" - R0: 0x%08lx, R1: 0x%08lx, R2: 0x%08lx, R3: 0x%08lx\n", last->r0, last->r1, last->r2, last->r3);
    Serial.printf(" - R12: 0x%08lx, LR: 0x%08lx, PC: 0x%08lx, PSR: 0x%08lx\n", last->r12, last->lr, last->pc, last->psr);
  }
 
  Serial2.begin(115200);
  Serial2.onReceive(receivemsg);
  Serial2.listen();
 
  timerSend.onFired(taskPeriodicSend);
 
#ifndef SENSOR_TEST_MODE
  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.*/
    eventKeyInput(Serial);
  } else {
    Serial.println("* Press any key to enter a new AppKey in 3 seconds...");
    timerKeyInput.onFired(beginLoRaWAN);
    timerKeyInput.startOneShot(3000);
    Serial.listen();
    Serial.onReceive(eventKeyInput);
  }
#endif
}