SerVision - IoT room server monitoring

//#include <Sodaq_RN2483.h>
//#include <Sodaq_wdt.h>
//#include <StringLiterals.h>
//#include <Switchable_Device.h>
//#include <Utils.h>

/*
* Copyright (c) 2015 SODAQ. All rights reserved.
*
* This file is part of Sodaq_RN2483.
*
* Sodaq_RN2483 is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or(at your option) any later version.
*
* Sodaq_RN2483 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Sodaq_RN2483.  If not, see
* <http://www.gnu.org/licenses></http:>.
*/

#define DEBUG
#include <Sodaq_RN2483.h>

    //----------------------------------------------//
    // ---------------- DEFINITIONS ----------------// 
    //----------------------------------------------//

#define uplinkCnt 10

// LED color customization for all the application
// Should give color mix for Orange (0xFF6600) assuming color index is accurate
#define LED_RED_CUST    0x00
#define LED_GREEN_CUST  0x99
#define LED_BLUE_CUST   0xFF

#define debugSerial SerialUSB
#define loraSerial  Serial2 // Serial communcation with the lora module
#define TXserial    Serial  // Serial communication with the arduino leonardo

    //----------------------------------------------//
    // ---------------- DECLARATION ----------------// 
    //----------------------------------------------//

// ----- LoRa key initialisation (we use OTAA for the sodaq) ----- //

//#define ABP
#define OTAA

#ifdef ABP
  // ABP Keys - Use your own KEYS!
  const uint8_t devAddr[4] =  {} ;
  const uint8_t nwkSKey[16] = {} ;
  const uint8_t appSKey[16] = {} ;
#else
  // OTAA Keys - Use your own KEYS!
  const uint8_t devEUI[8]  = {} ;
  const uint8_t appEUI[8]  = {} ;
  const uint8_t appKey[16] = {} ;
#endif

// Payload is 'Microchip ExpLoRa' in HEX
const uint8_t testPayload[] = {0x4d, 0x69, 0x63, 0x72, 0x6f, 0x63, 0x68, 0x69, 0x70, 0x20, 0x45, 0x78, 0x70, 0x4c, 0x6f, 0x52, 0x61} ;

String message = "";


    //----------------------------------------------//
    // ------------- UTILITY FUNCTIONS -------------// 
    //----------------------------------------------//



/**
 * @brief Parses and prints three IPv4 addresses from a 12-byte downlink payload.
 *
 * This function interprets the given 12-byte buffer as three sequential IPv4 addresses:
 * - Bytes 03   : Gateway IP
 * - Bytes 47   : External IP
 * - Bytes 811  : Internal IP
 *
 * The function prints each IP in human-readable format (e.g., 192.168.1.1)
 * to the debug serial port.
 *
 * @param data Pointer to the received downlink payload buffer.
 * @param length Length of the buffer (must be at least 12).
 */
void printDownlinkAsIPs(const uint8_t* data, uint16_t length) {
  if (length < 12) {
    debugSerial.println("Payload downlink invalide (taille < 12).");
    return;
  }

  debugSerial.print("Gateway IP : ");
  debugSerial.print(data[0]); debugSerial.print(".");
  debugSerial.print(data[1]); debugSerial.print(".");
  debugSerial.print(data[2]); debugSerial.print(".");
  debugSerial.println(data[3]);

  debugSerial.print("External IP : ");
  debugSerial.print(data[4]); debugSerial.print(".");
  debugSerial.print(data[5]); debugSerial.print(".");
  debugSerial.print(data[6]); debugSerial.print(".");
  debugSerial.println(data[7]);

  debugSerial.print("Internal IP : ");
  debugSerial.print(data[8]); debugSerial.print(".");
  debugSerial.print(data[9]); debugSerial.print(".");
  debugSerial.print(data[10]); debugSerial.print(".");
  debugSerial.println(data[11]);
}


/**
 * @brief Just a function to print the payload properly on the serial console
 *
 * @return void
 */
void printPayload(const uint8_t* payload, size_t length) {
  debugSerial.print("Payload [");
  debugSerial.print(length);
  debugSerial.print("] : ");

  for (size_t i = 0; i < length; i++) {
    debugSerial.print(payload[i]);
    if (i < length - 1) {
      debugSerial.print(", ");
    }
  }

  debugSerial.println();
}

/**
 * @brief Parses a formatted string and converts it into a LoRa-compatible payload.
 *
 * Expected format:
 *   "temp : <val>, hum : <val>, rawLum : <val>, flame : <val>, localConn : <val>, gatewayConn : <val>, publicConn : <val>#"
 *
 * @param msg   The input string.
 * @param payload Output byte array to store encoded data.
 * @return true if parsing and conversion were successful; false otherwise.
 */
bool parsePayload(const String& msg, uint8_t* payload) {
  String data = msg;
  data.trim();

  // Extract indexes of each field
  int tIdx = data.indexOf("temp : ") + 7;
  int hIdx = data.indexOf("hum : ") + 6;
  int lIdx = data.indexOf("rawLum : ") + 9;
  int fIdx = data.indexOf("flame : ") + 8;
  int lcIdx = data.indexOf("localConn : ") + 12;
  int gwIdx = data.indexOf("gatewayConn : ") + 14;
  int pcIdx = data.indexOf("publicConn : ") + 13;

  // Parse each value from the message
  float temp = data.substring(tIdx, data.indexOf(',', tIdx)).toFloat(); 
  int hum = data.substring(hIdx, data.indexOf(',', hIdx)).toInt();    
  int lum = data.substring(lIdx, data.indexOf(',', lIdx)).toInt();  
  int flame = data.substring(fIdx, data.indexOf(',', fIdx)).toInt();  
  int local = data.substring(lcIdx, data.indexOf(',', lcIdx)).toInt();  
  int gateway = data.substring(gwIdx, data.indexOf(',', gwIdx)).toInt();  
  int internet = data.substring(pcIdx).toInt();  // last value

  // Convert temperature (C) to fixed point value (x10), stored on 2 bytes
  uint16_t temp10 = (uint16_t)(temp * 10);
  payload[0] = temp10 >> 8;       // MSB
  payload[1] = temp10 & 0xFF;     // LSB

  // Store remaining values as single bytes
  payload[2] = (uint8_t)hum;
  payload[3] = (uint8_t)(lum);
  payload[4] = (uint8_t)flame;
  payload[5] = (uint8_t)local;
  payload[6] = (uint8_t)gateway;
  payload[7] = (uint8_t)internet;

  return true;
}

    //----------------------------------------------//
    // --------------- MAIN FUNCTIONS --------------// 
    //----------------------------------------------//


void setup()
{  
  TXserial.begin(9600);
	debugSerial.begin(9600) ;
	loraSerial.begin(LoRaBee.getDefaultBaudRate()) ;
  String message = "";
  
  //Initialize the LEDs and turn them all off
  pinMode(LED_RED, OUTPUT) ;
  pinMode(LED_GREEN, OUTPUT) ;
  pinMode(LED_BLUE, OUTPUT) ;

  digitalWrite(LED_RED, HIGH) ;
  digitalWrite(LED_GREEN, HIGH) ;
  digitalWrite(LED_BLUE, HIGH) ;

  // Power Up LED
  analogWrite(LED_RED,   LED_RED_CUST) ;
  analogWrite(LED_GREEN, LED_GREEN_CUST) ;
  analogWrite(LED_BLUE,  LED_BLUE_CUST) ;
  
  delay(2000) ;

  // Turn off the LEDs
  digitalWrite(LED_RED, HIGH) ;
  digitalWrite(LED_GREEN, HIGH) ;
  digitalWrite(LED_BLUE, HIGH) ;
  
	LoRaBee.setDiag(debugSerial) ; // optional
 
	#ifdef ABP
    if (LoRaBee.initABP(loraSerial, devAddr, appSKey, nwkSKey, true))
	  {
		  debugSerial.println("ABP Keys Accepted.") ;
	  }
	  else
	  {
		  debugSerial.println("ABP Key Setup Failed!") ;
	  }
  #else
    if (LoRaBee.initOTA(loraSerial, devEUI, appEUI, appKey, true))
    {
      debugSerial.println("OTAA Keys Accepted.") ;
    }
    else
    {
      debugSerial.println("OTAA Keys Setup Failed!") ;
    }
  #endif
  
  debugSerial.println("Sleeping for 5 seconds before starting sending out test packets.");
  for (uint8_t i = 5; i > 0; i--)
  {
    debugSerial.println(i) ;
    delay(1000) ;
  }

    debugSerial.println("--- LOOP --- ");

}

void loop()
{
  delay(60000); // Send the message every 10 sec
  while (TXserial.available()) {
    char c = TXserial.read();
    if (c == '#') {
      // End caracter is # so it is the end of the message string
      debugSerial.print("Received msg : ");
      debugSerial.println(message);
      message.trim(); // Clean message

      uint8_t payload[8]; // Payload of 8 bytes that is going to be sent via LoRa
      if (parsePayload(message, payload)) {
        debugSerial.println("Frame parsed with success");
        printPayload(payload, sizeof(payload));

        switch (LoRaBee.send(1, payload, sizeof(payload))) {
          case NoError:
          {
            debugSerial.println("Transmission OK");


            uint8_t downlink[64]; // max 64 bytes of downlink
            uint16_t len = LoRaBee.receive(downlink, sizeof(downlink)); // received func provided from RN2483 librarie

        if (len > 0) {
          debugSerial.print("Downlink received [");
          debugSerial.print(len);
          debugSerial.print(" bytes]: ");

          for (uint16_t i = 0; i < len; i++) {
            debugSerial.print("0x");
            if (downlink[i] < 16) debugSerial.print("0");
            debugSerial.print(downlink[i], HEX);
            debugSerial.print(" ");
          }
          debugSerial.println();

          printDownlinkAsIPs(downlink, len);

          // ----- Send IPs via serial to arduino ----- //

          TXserial.print("IPG:"); // Gateway
          TXserial.print(downlink[0]); TXserial.print(".");
          TXserial.print(downlink[1]); TXserial.print(".");
          TXserial.print(downlink[2]); TXserial.print(".");
          TXserial.println(downlink[3]);

          TXserial.print("IPE:"); // External (synoServer)
          TXserial.print(downlink[4]); TXserial.print(".");
          TXserial.print(downlink[5]); TXserial.print(".");
          TXserial.print(downlink[6]); TXserial.print(".");
          TXserial.println(downlink[7]);

          TXserial.print("IPI:"); // Internal (localDevice)
          TXserial.print(downlink[8]); TXserial.print(".");
          TXserial.print(downlink[9]); TXserial.print(".");
          TXserial.print(downlink[10]); TXserial.print(".");
          TXserial.println(downlink[11]);
          
          // ------------------------------------------- //



        }
        else {
              debugSerial.println("No downlink received.");
            }

            break;
          }

          default:
            debugSerial.println("Error during transmission");
            break;
        }

      } 
      
      else {
        debugSerial.println("Parsing error");
      }

      message = "";  // Clean up for next frame
      
    } else {
      message += c;
    }   
  }
}