/*

beescale_lora_mcci.ino

BeieliScale, see https://mini-beieli.ch

Joerg Lehmann, nbit Informatik GmbH

*/

#include <Catena.h>

#include <Catena_Led.h>
#include <Catena_CommandStream.h>
#include <Catena_Mx25v8035f.h>

#include <Wire.h>
#include <Adafruit_BME280.h>
#include <Arduino_LoRaWAN.h>
#include <lmic.h>
#include <hal/hal.h>
#include <mcciadk_baselib.h>

#include <cmath>
#include <type_traits>

#include <HX711.h>

using namespace McciCatena;

/****************************************************************************\
|
|  MANIFEST CONSTANTS & TYPEDEFS
|
\****************************************************************************/

/* how long do we wait between transmissions? (in seconds) */
enum {
    // set this to interval between transmissions, in seconds
    // Actual time will be a little longer because have to
    // add measurement and broadcast time, but we attempt
    // to compensate for the gross effects below.
    CATCFG_T_CYCLE = 6 * 60, // every 6 minutes
    CATCFG_T_CYCLE_TEST = 30, // every 10 seconds
    CATCFG_T_CYCLE_INITIAL = 30,    // every 30 seconds initially
    CATCFG_INTERVAL_COUNT_INITIAL = 30,     // repeat for 15 minutes
};

/* additional timing parameters; ususually you don't change these. */
enum {
    CATCFG_T_WARMUP = 1,
    CATCFG_T_SETTLE = 5,
    CATCFG_T_OVERHEAD = (CATCFG_T_WARMUP + CATCFG_T_SETTLE),
    CATCFG_T_MIN = CATCFG_T_OVERHEAD,
    CATCFG_T_MAX = CATCFG_T_CYCLE < 60 * 60 ? 60 * 60 : CATCFG_T_CYCLE,     // normally one hour max.
    CATCFG_INTERVAL_COUNT = 30,
};

constexpr uint32_t CATCFG_GetInterval(uint32_t tCycle)
{
    return (tCycle < CATCFG_T_OVERHEAD)
        ? CATCFG_T_OVERHEAD
        : tCycle - CATCFG_T_OVERHEAD;
}

enum {
    CATCFG_T_INTERVAL = CATCFG_GetInterval(CATCFG_T_CYCLE),
};

enum {
    PIN_ONE_WIRE = A2, // XSDA1 == A2
    PIN_SHT10_CLK = 8, // XSCL0 == D8
    PIN_SHT10_DATA = 12, // XSDA0 == D12
};

// the cycle time to use
unsigned gTxCycle;
// remaining before we reset to default
unsigned gTxCycleCount;

// forwards
static void settleDoneCb(osjob_t* pSendJob);
static void warmupDoneCb(osjob_t* pSendJob);
static void txFailedDoneCb(osjob_t* pSendJob);
static void sleepDoneCb(osjob_t* pSendJob);
static Arduino_LoRaWAN::SendBufferCbFn sendBufferDoneCb;
static Arduino_LoRaWAN::ReceivePortBufferCbFn receiveMessage;
void setTxCycleTime(unsigned txCycle, unsigned txCount);

// Additional Commands
// forward reference to the command function
cCommandStream::CommandFn cmdHello;
cCommandStream::CommandFn cmdGetCalibrationSettings;
cCommandStream::CommandFn cmdGetSensorReadings;
cCommandStream::CommandFn cmdGetScale1;
cCommandStream::CommandFn cmdGetScale2;
cCommandStream::CommandFn cmdCalibrateZeroScale1;
cCommandStream::CommandFn cmdCalibrateZeroScale2;
cCommandStream::CommandFn cmdCalibrateScale1;
cCommandStream::CommandFn cmdCalibrateScale2;

// the individual commmands are put in this table
static const cCommandStream::cEntry sMyExtraCommmands[] =
        {
        { "hello", cmdHello },
        { "get_calibration_settings", cmdGetCalibrationSettings },
        { "get_sensor_readings", cmdGetSensorReadings },
        { "calibrate_zero_scale1", cmdCalibrateZeroScale1 },
        { "calibrate_zero_scale2", cmdCalibrateZeroScale2 },
        { "calibrate_scale1", cmdCalibrateScale1 },
        { "calibrate_scale2", cmdCalibrateScale2 },
        // other commands go here....
        };

/* a top-level structure wraps the above and connects to the system table */
/* it optionally includes a "first word" so you can for sure avoid name clashes */
static cCommandStream::cDispatch
sMyExtraCommands_top(
        sMyExtraCommmands,          /* this is the pointer to the table */
        sizeof(sMyExtraCommmands),  /* this is the size of the table */
        "application"                   /* this is the "first word" for all the commands in this table*/
        );


/****************************************************************************\
|
| READ-ONLY DATA
|
\****************************************************************************/

static const char sVersion[] = "0.1";
static const byte MAX_VALUES_TO_SEND = 8;
static const uint8_t LORA_DATA_VERSION = 1;
static const uint8_t LORA_DATA_VERSION_FIRST_PACKAGE = 128;
static const uint32_t PRESSURE_OFFSET = 825;

/****************************************************************************\
|
| VARIABLES
|
\****************************************************************************/

// must be 65 bytes long...
typedef struct {
  long cal_w1_0;                                      // 4 Bytes, Wert Waegezelle 1 ohne Gewicht
  long cal_w2_0;                                      // 4 Bytes, Wert Waegezelle 2 ohne Gewicht
  float cal_w1_factor;                                // 4 Bytes,
  float cal_w2_factor;
  byte fill[49];
} __attribute__((packed)) CONFIG_data;

typedef struct {
    uint8_t version;                                   // Version
    uint8_t vbat;                                      // Batteriespannung (1 Einheit => 20 mV)
    uint8_t humidity[MAX_VALUES_TO_SEND];              // Luftfeuchtigkeit in Prozent
    int16_t temperature;                               // Temperatur (Startwert) in 1/10 Grad Celsius
    int8_t temperature_change[MAX_VALUES_TO_SEND - 1]; // Unterschied Temperatur seit letztem Messwert in 1/10 Grad Celsius
    uint8_t pressure[MAX_VALUES_TO_SEND];              // Luftdruck in Hekto-Pascal (0 entspricht 825 hPa)
    uint16_t weight[MAX_VALUES_TO_SEND];               // Waegezelle Gesamtgewicht, in 5g
    uint8_t offset_last_reading;                       // Zeitunterschied letzte zu erste Messung (in Minuten) 
} __attribute__((packed)) LORA_data;

typedef struct {
    uint8_t version;                                  // Version
    uint8_t vbat;                                     // Batteriespannung (1 Einheit => 20 mV)
    uint8_t humidity;                                 // Luftfeuchtigkeit in Prozent
    int16_t temperature;                              // Temperatur in 1/10 Grad Celsius
    uint8_t pressure;                                 // Luftdruck in Hekto-Pascal (0 entspricht 825 hPa)
    int32_t weight1;                                  // Waegezelle 1, Raw Value
    int32_t weight2;                                  // Waegezelle 2, Raw Value
    uint16_t weight;                                  // Waegezelle Gesamtgewicht, in 5g
} __attribute__((packed)) LORA_data_first;

typedef struct {
    uint8_t vbat;                                     // Batteriespannung (1 Einheit => 20 mV)
    uint8_t humidity;                                 // Luftfeuchtigkeit in Prozent
    int16_t temperature;                              // Temperatur in 1/10 Grad Celsius
    uint8_t pressure;                                 // Luftdruck in Hekto-Pascal (0 entspricht 825 hPa)
    int32_t weight1;                                  // Waegezelle 1, Raw Value
    int32_t weight2;                                  // Waegezelle 2, Raw Value
    uint16_t weight;                                  // Waegezelle Gesamtgewicht, in 5g
} SENSOR_data;


byte my_position = 0;    // what is our actual measurement, starts with 0
long timer_pos0;

// Global Variables
LORA_data lora_data;
LORA_data_first lora_data_first;
CONFIG_data config_data;
SENSOR_data last_sensor_reading;

// generic timer
long t_cur;

// the primary object
Catena gCatena;

//
// the LoRaWAN backhaul.  Note that we use the
// Catena version so it can provide hardware-specific
// information to the base class.
//
Catena::LoRaWAN gLoRaWAN;

//
// the LED
//
StatusLed gLed(Catena::PIN_STATUS_LED);

//   The temperature/humidity sensor
Adafruit_BME280 gBME280; // The default initalizer creates an I2C connection
bool fBme;

SPIClass gSPI2(
    Catena::PIN_SPI2_MOSI,
    Catena::PIN_SPI2_MISO,
    Catena::PIN_SPI2_SCK);

//   The flash
Catena_Mx25v8035f gFlash;
bool fFlash;

// Scales
HX711 LoadCell_1;
HX711 LoadCell_2;

//  USB power
bool fUsbPower;

// have we printed the sleep info?
bool g_fPrintedSleeping = false;

//  the job that's used to synchronize us with the LMIC code
static osjob_t sensorJob;
void sensorJob_cb(osjob_t* pJob);

void setup(void)
{
    gCatena.begin();
    ClearLoraData();

    setup_platform();
    setup_bme280();
    setup_scales();

    /* for 4451, we need wider tolerances, it seems */
#if defined(ARDUINO_ARCH_STM32)
        LMIC_setClockError(10 * 65536 / 100);
#endif

    setup_flash();
    setup_uplink();
}

void setup_platform(void)
{

  /* add our application-specific commands */
  gCatena.addCommands(
         sMyExtraCommands_top,
         nullptr
       );

  // read config_data from fram...
  gCatena.SafePrintf("Reading Calibration Config from FRAM...\n");
  gCatena.getFram()->getField(cFramStorage::kBme680Cal, (uint8_t *)&config_data, sizeof(config_data));

  gCatena.SafePrintf("cal_w1_0: %d\n",config_data.cal_w1_0);
  gCatena.SafePrintf("cal_w2_0: %d\n",config_data.cal_w2_0);
  gCatena.SafePrintf("cal_w1_factor: %d.%03d\n",(int)config_data.cal_w1_factor,(int)(config_data.cal_w1_factor*1000)%1000);
  gCatena.SafePrintf("cal_w2_factor: %d.%03d\n",(int)config_data.cal_w2_factor,(int)(config_data.cal_w2_factor*1000)%1000);
  gCatena.SafePrintf("Size of config_data: %d\n",sizeof(config_data));

  // im Moment statisch...
  //config_data.cal_w1_0 = 20000;
  //config_data.cal_w2_0 = 20000;
  //config_data.cal_w1_factor = 2.5;
  //config_data.cal_w2_factor = 2.5;


  // config_data speichern...
  //gCatena.SafePrintf("Writing Calibration Config to FRAM...\n");
  //gCatena.getFram()->saveField(cFramStorage::kBme680Cal, (const uint8_t *)&config_data, sizeof(config_data));

#ifdef USBCON
    // if running unattended, don't wait for USB connect.
    if (!(gCatena.GetOperatingFlags() & static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fUnattended))) {
        while (!Serial)
            /* wait for USB attach */
            yield();
    }
#endif

    gCatena.SafePrintf("\n");
    gCatena.SafePrintf("-------------------------------------------------------------------------------\n");
    gCatena.SafePrintf("BeieliScale Version %s.\n", sVersion);
    {
        char sRegion[16];
        gCatena.SafePrintf("Target network: %s / %s\n",
            gLoRaWAN.GetNetworkName(),
            gLoRaWAN.GetRegionString(sRegion, sizeof(sRegion)));
    }
    gCatena.SafePrintf("Enter 'help' for a list of commands.\n");

#ifdef CATENA_CFG_SYSCLK
    gCatena.SafePrintf("SYSCLK: %d MHz\n", CATENA_CFG_SYSCLK);
#endif

#ifdef USBCON
    gCatena.SafePrintf("USB enabled\n");
#else
    gCatena.SafePrintf("USB disabled\n");
#endif

    Catena::UniqueID_string_t CpuIDstring;

    gCatena.SafePrintf(
        "CPU Unique ID: %s\n",
        gCatena.GetUniqueIDstring(&CpuIDstring));

    gCatena.SafePrintf("--------------------------------------------------------------------------------\n");
    gCatena.SafePrintf("\n");

    // set up the LED
    gLed.begin();
    gCatena.registerObject(&gLed);
    gLed.Set(LedPattern::FastFlash);

    // set up LoRaWAN
    gCatena.SafePrintf("LoRaWAN init: ");
    if (!gLoRaWAN.begin(&gCatena)) {
        gCatena.SafePrintf("failed\n");
    }
    else {
        gCatena.SafePrintf("succeeded\n");
    }

    gLoRaWAN.SetReceiveBufferBufferCb(receiveMessage);
    setTxCycleTime(CATCFG_T_CYCLE_INITIAL, CATCFG_INTERVAL_COUNT_INITIAL);

    gCatena.registerObject(&gLoRaWAN);

    /* find the platform */
    const Catena::EUI64_buffer_t* pSysEUI = gCatena.GetSysEUI();

    uint32_t flags;
    const CATENA_PLATFORM* const pPlatform = gCatena.GetPlatform();

    if (pPlatform) {
        gCatena.SafePrintf("EUI64: ");
        for (unsigned i = 0; i < sizeof(pSysEUI->b); ++i) {
            gCatena.SafePrintf("%s%02x", i == 0 ? "" : "-", pSysEUI->b[i]);
        }
        gCatena.SafePrintf("\n");
        flags = gCatena.GetPlatformFlags();
        gCatena.SafePrintf(
            "Platform Flags:  %#010x\n",
            flags);
        gCatena.SafePrintf(
            "Operating Flags:  %#010x\n",
            gCatena.GetOperatingFlags());
    }
    else {
        gCatena.SafePrintf("**** no platform, check provisioning ****\n");
        flags = 0;
    }
}

void setup_bme280(void)
{
    if (gBME280.begin(BME280_ADDRESS, Adafruit_BME280::OPERATING_MODE::Sleep)) {
        fBme = true;
    }
    else {
        fBme = false;
        gCatena.SafePrintf("No BME280 found: check wiring\n");
    }
}

void setup_scales(void)
{
    gCatena.SafePrintf("Setup Scales...\n");

    // Initialize library with data output pin, clock input pin and gain factor.
    // Channel selection is made by passing the appropriate gain:
    // - With a gain factor of 64 or 128, channel A is selected
    // - With a gain factor of 32, channel B is selected
    // By omitting the gain factor parameter, the library
    // default "128" (Channel A) is used here.
    gCatena.SafePrintf("Setup Scale 1...\n");
    LoadCell_1.begin(A1, A0);
   
    if (!(LoadCell_1.wait_ready_timeout(1000))) {
      gCatena.SafePrintf("Scale 1 not ready.\n");
    }
    
    gCatena.SafePrintf("Setup Scale 2...\n");
    LoadCell_2.begin(D10, A2);

    if (!(LoadCell_2.wait_ready_timeout(1000))) {
      gCatena.SafePrintf("Scale 2 not ready.\n");
    }

    gCatena.SafePrintf("Setup Scales is complete\n");
}

void setup_flash(void)
{
    if (gFlash.begin(&gSPI2, Catena::PIN_SPI2_FLASH_SS)) {
        fFlash = true;
        gFlash.powerDown();
        gCatena.SafePrintf("FLASH found, put power down\n");
    }
    else {
        fFlash = false;
        gFlash.end();
        gSPI2.end();
        gCatena.SafePrintf("No FLASH found: check hardware\n");
    }
}

void setup_uplink(void)
{
    /* trigger a join by sending the first packet */
    if (!(gCatena.GetOperatingFlags() & static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fManufacturingTest))) {
        if (!gLoRaWAN.IsProvisioned())
            gCatena.SafePrintf("LoRaWAN not provisioned yet. Use the commands to set it up.\n");
        else {
            gLed.Set(LedPattern::Joining);

            /* warm up the BME280 by discarding a measurement */
            if (fBme)
                (void)gBME280.readTemperature();

            /* trigger a join by sending the first packet */
            ReadSensors(true,false);
        }
    }
}

// The Arduino loop routine -- in our case, we just drive the other loops.
// If we try to do too much, we can break the LMIC radio. So the work is
// done by outcalls scheduled from the LMIC os loop.
void loop()
{
    gCatena.poll();
}

void ClearLoraData(void)
{
    lora_data.version = LORA_DATA_VERSION;
    lora_data.vbat = 0;
    lora_data.temperature = 0;
    for (int i = 0; i < MAX_VALUES_TO_SEND; i++) {
        lora_data.humidity[i] = 0;
        lora_data.pressure[i] = 0;
        lora_data.weight[i] = 0;
        if (i < (MAX_VALUES_TO_SEND -1)) { 
          lora_data.temperature_change[i] = 0;
        }
    }    

    lora_data_first.version = LORA_DATA_VERSION_FIRST_PACKAGE;
    lora_data_first.vbat = 0;
    lora_data_first.humidity = 0;
    lora_data_first.pressure = 0;
    lora_data_first.weight1 = 0;
    lora_data_first.weight2 = 0;
    lora_data_first.weight = 0;
    lora_data_first.temperature = 0;

    my_position = 0;
}

void ShowLORAData(bool firstTime) 
{
  if (firstTime) {
  
    gCatena.SafePrintf("{\n");
    gCatena.SafePrintf("  \"version\": \"%u\",\n",lora_data_first.version);
    gCatena.SafePrintf("  \"vbat\": \"%u\",\n",lora_data_first.vbat);
    gCatena.SafePrintf("  \"humidity\": \"%u\",\n",lora_data_first.humidity);
    gCatena.SafePrintf("  \"pressure\": \"%u\",\n",lora_data_first.pressure);
    gCatena.SafePrintf("  \"weight1\": \"%ld\",\n",lora_data_first.weight1);
    gCatena.SafePrintf("  \"weight2\": \"%ld\",\n",lora_data_first.weight2);
    gCatena.SafePrintf("  \"weight\": \"%u\",\n",lora_data_first.weight);
    gCatena.SafePrintf("  \"temperature\": \"%u\",\n",lora_data_first.temperature);
    gCatena.SafePrintf("}\n");
    
  } else {
  
    gCatena.SafePrintf("{\n");
    gCatena.SafePrintf("  \"version\": \"%u\",\n",lora_data.version);
    gCatena.SafePrintf("  \"vbat\": \"%u\",\n",lora_data.vbat);
    gCatena.SafePrintf("  \"temperature\": \"%u\",\n",lora_data.temperature);
    gCatena.SafePrintf("  \"humidity\": [");
    for (int i = 0; i < MAX_VALUES_TO_SEND; i++) {
      gCatena.SafePrintf("%d",lora_data.humidity[i]);
      if (i < (MAX_VALUES_TO_SEND - 1)) {
        gCatena.SafePrintf(",");
      }
    }
    gCatena.SafePrintf("],\n");
    gCatena.SafePrintf("  \"pressure\": [");
    for (int i = 0; i < MAX_VALUES_TO_SEND; i++) {
      gCatena.SafePrintf("%d",lora_data.pressure[i]);
      if (i < (MAX_VALUES_TO_SEND - 1)) {
        gCatena.SafePrintf(",");
      }
    }
    gCatena.SafePrintf("],\n");
    gCatena.SafePrintf("  \"weight\": [");
    for (int i = 0; i < MAX_VALUES_TO_SEND; i++) {
      gCatena.SafePrintf("%ld",lora_data.weight[i]);
      if (i < (MAX_VALUES_TO_SEND - 1)) {
        gCatena.SafePrintf(",");
      }
    }
    gCatena.SafePrintf("],\n");
    gCatena.SafePrintf("  \"temperature_change\": [");
    for (int i = 0; i < MAX_VALUES_TO_SEND - 1; i++) {
      gCatena.SafePrintf("%d",lora_data.temperature_change[i]);
      if (i < (MAX_VALUES_TO_SEND - 2)) {
        gCatena.SafePrintf(",");
      }
    }
    gCatena.SafePrintf("]\n");
    gCatena.SafePrintf("}\n");
    
  }
}

void ReadSensors(bool firstTime, bool readOnly)
{
    int16_t temp_current;
    uint8_t humidity_current;
    uint8_t pressure_current;
    int32_t weight1_current;
    int32_t weight2_current;
    int16_t temp_last;
    int16_t temp_change;
    int32_t weight_current32;
    uint16_t weight_current;
    uint16_t weight_last;
    
    if (fBme) {
        Adafruit_BME280::Measurements m = gBME280.readTemperaturePressureHumidity();
        // temperature is 2 bytes from -0x80.00 to +0x7F.FF degrees C
        // pressure is 2 bytes, hPa * 10.
        // humidity is one byte, where 0 == 0/256 and 0xFF == 255/256.
        gCatena.SafePrintf(
            "BME280:  T: %d P: %d RH: %d\n",
            (int)m.Temperature,
            (int)m.Pressure,
            (int)m.Humidity);
        temp_current = (int16_t)((m.Temperature) * 10);
        humidity_current = (uint8_t)m.Humidity;
        pressure_current = (uint8_t)((m.Pressure / 100) - PRESSURE_OFFSET);
        gCatena.SafePrintf("pressure_current: %d\n",pressure_current);
    }


    // vBat
    float vBat = gCatena.ReadVbat();
    gCatena.SafePrintf("vBat:    %d mV\n", (int)(vBat * 1000.0f));

    // vBus
    float vBus = gCatena.ReadVbus();
    gCatena.SafePrintf("vBus:    %d mV\n", (int)(vBus * 1000.0f));
    fUsbPower = (vBus > 3.0) ? true : false;

    // Read Scales
    gCatena.SafePrintf("Before Read Scales\n");

    // Power-Up HX711
    LoadCell_1.power_up();

    if (!(LoadCell_1.wait_ready_timeout(1000))) {
      gCatena.SafePrintf("Scale 1 not ready.\n");
    }

    gCatena.SafePrintf("Before Read Scales\n");
    if (LoadCell_1.is_ready()) {
        Serial.println("HX711 LoadCell_1 is ready.");
        long w1 = LoadCell_1.read_average(5);
        weight1_current = (int32_t)w1;
        gCatena.SafePrintf("Load_cell 1 output val: %ld\n", w1);
    }
    else {
        Serial.println("HX711 LoadCell_1 not ready.");
    }

    // Power-Down HX711
    LoadCell_1.power_down();

    // Power-Up HX711
    LoadCell_2.power_up();

    if (!(LoadCell_2.wait_ready_timeout(1000))) {
      gCatena.SafePrintf("Scale 2 not ready.\n");
    }

    if (LoadCell_2.is_ready()) {
        Serial.println("HX711 LoadCell_2 is ready.");
        long w2 = LoadCell_2.read_average(5);
        weight2_current = (int32_t)w2;
        gCatena.SafePrintf("Load_cell 2 output val: %ld\n", w2);
    }
    else {
        Serial.println("HX711 LoadCell_2 not ready.");
    }

    // Power-Down HX711
    LoadCell_2.power_down();

    
    gCatena.SafePrintf("After Read Scales\n");

    // Gewicht berechnen
    weight_current32 = ((weight1_current - config_data.cal_w1_0) / config_data.cal_w1_factor) + ((weight2_current - config_data.cal_w2_0) / config_data.cal_w2_factor);
    if (weight_current32 < 0) {
      weight_current32 = 0;
    } else if (weight_current32 > UINT16_MAX) {
      weight_current32 = UINT16_MAX;
    }
    weight_current = (uint16_t)weight_current32;

    if (not(readOnly)) {
        // calculate last value
        weight_last = 0;
        temp_last = lora_data.temperature;

        for (int i = 0; i < my_position; i++) {
            temp_last = temp_last + lora_data.temperature_change[i];
        }    

        if (my_position > 0) {
          weight_last = lora_data.weight[my_position - 1];
        }
     
        if (firstTime) { 
          lora_data_first.vbat = (uint8_t)(vBat * 1000.0f / 20);
          lora_data_first.weight1 = weight1_current;
          lora_data_first.weight2 = weight2_current;
          lora_data_first.weight = weight_current;
          lora_data_first.temperature = temp_current;
          lora_data_first.humidity = humidity_current;
          lora_data_first.pressure = pressure_current;
        } else {
          lora_data.vbat = (uint8_t)(vBat * 1000.0f / 20);
          lora_data.weight[my_position] = weight_current;
          if (my_position == 0) {
            lora_data.temperature = temp_current;
          } else {
            temp_change = temp_current - temp_last; 
            if (temp_change > 127) {
              temp_change = 127;
            }
            if (temp_change < -128) {
              temp_change = -128;
            }
        
            lora_data.temperature_change[my_position - 1] = (uint8_t)temp_change;
          }
          lora_data.humidity[my_position] = humidity_current;
          lora_data.pressure[my_position] = pressure_current;
        }
    
        if (my_position == 0) {
          timer_pos0 = millis();
        }

        ShowLORAData(firstTime);
        my_position++;

        // Should we send the Data?
        // we send data the first time the system is started, when the array is full 
        // or when the weight has fallen more than 100g or the first measurement is 
        // more than one hour old (which should not happen :-) )
        if (firstTime || (my_position >= MAX_VALUES_TO_SEND) || ((weight_last - weight_current) > 20) || ((millis() - timer_pos0) > 3600000)) {
          lora_data.offset_last_reading = (uint8_t)((millis() - timer_pos0) / 1000 / 60);
          gCatena.SafePrintf("startSendingUplink()\n");
          startSendingUplink(firstTime);
        } else {
          doLightSleep(&sensorJob);
        }
    }

    last_sensor_reading.vbat = (uint8_t)(vBat * 1000.0f / 20);
    last_sensor_reading.weight1 = weight1_current;
    last_sensor_reading.weight2 = weight2_current;
    last_sensor_reading.weight = weight_current;
    last_sensor_reading.temperature = temp_current;
    last_sensor_reading.humidity = humidity_current;
    last_sensor_reading.pressure = pressure_current;
}

void startSendingUplink(bool firstTime)
{
    LedPattern savedLed = gLed.Set(LedPattern::Measuring);

    if (savedLed != LedPattern::Joining)
        gLed.Set(LedPattern::Sending);
    else
        gLed.Set(LedPattern::Joining);

    bool fConfirmed = false;
    if (gCatena.GetOperatingFlags() & (1 << 16)) {
        gCatena.SafePrintf("requesting confirmed tx\n");
        fConfirmed = true;
    }

    if (firstTime) {
      gLoRaWAN.SendBuffer((uint8_t*)&lora_data_first, sizeof(LORA_data_first), sendBufferDoneCb, NULL, fConfirmed);
    } else {
      gLoRaWAN.SendBuffer((uint8_t*)&lora_data, sizeof(LORA_data), sendBufferDoneCb, NULL, fConfirmed);
    }    
    ClearLoraData();
}

static void sendBufferDoneCb(
    void* pContext,
    bool fStatus)
{
    osjobcb_t pFn;

    gLed.Set(LedPattern::Settling);
    if (!fStatus) {
        gCatena.SafePrintf("send buffer failed\n");
        pFn = txFailedDoneCb;
    }
    else {
        pFn = settleDoneCb;
    }
    os_setTimedCallback(
        &sensorJob,
        os_getTime() + sec2osticks(CATCFG_T_SETTLE),
        pFn);
}

static void txFailedDoneCb(
    osjob_t* pSendJob)
{
    gCatena.SafePrintf("not provisioned, idling\n");
    gLoRaWAN.Shutdown();
    gLed.Set(LedPattern::NotProvisioned);
}



static void settleDoneCb(
    osjob_t* pSendJob)
{
    const bool fDeepSleep = checkDeepSleep();

    if (!g_fPrintedSleeping)
        doSleepAlert(fDeepSleep);

    if (fDeepSleep)
        doDeepSleep(pSendJob);
    else
        doLightSleep(pSendJob);
}

bool checkDeepSleep(void)
{
    bool const fDeepSleepTest = gCatena.GetOperatingFlags() & (1 << 19);
    bool fDeepSleep;

    if (fDeepSleepTest) {
        fDeepSleep = true;
    }
#ifdef USBCON
    else if (Serial.dtr()) {
        fDeepSleep = false;
    }
#endif
    else if (gCatena.GetOperatingFlags() & (1 << 17)) {
        fDeepSleep = false;
    }
    else if ((gCatena.GetOperatingFlags() & static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fUnattended)) != 0) {
        fDeepSleep = true;
    }
    else {
        fDeepSleep = false;
    }

    return fDeepSleep;
}

void doSleepAlert(const bool fDeepSleep)
{
    g_fPrintedSleeping = true;

    if (fDeepSleep) {
        bool const fDeepSleepTest = gCatena.GetOperatingFlags() & (1 << 19);
        const uint32_t deepSleepDelay = fDeepSleepTest ? 10 : 30;

        gCatena.SafePrintf("using deep sleep in %u secs"
#ifdef USBCON
                           " (USB will disconnect while asleep)"
#endif
                           ": ",
            deepSleepDelay);

        // sleep and print
        gLed.Set(LedPattern::TwoShort);

        for (auto n = deepSleepDelay; n > 0; --n) {
            uint32_t tNow = millis();

            while (uint32_t(millis() - tNow) < 1000) {
                gCatena.poll();
                yield();
            }
            gCatena.SafePrintf(".");
        }
        gCatena.SafePrintf("\nStarting deep sleep.\n");
        uint32_t tNow = millis();
        while (uint32_t(millis() - tNow) < 100) {
            gCatena.poll();
            yield();
        }
    }
    else
        gCatena.SafePrintf("using light sleep\n");
}

void doDeepSleep(osjob_t* pJob)
{
    /* ok... now it's time for a deep sleep */
    gLed.Set(LedPattern::Off);
    Serial.end();
    Wire.end();
    SPI.end();
    if (fFlash)
        gSPI2.end();

    gCatena.Sleep(CATCFG_T_INTERVAL);

    /* and now... we're awake again. trigger another measurement */
    Serial.begin();
    Wire.begin();
    SPI.begin();
    if (fFlash)
        gSPI2.begin();
    sleepDoneCb(pJob);
}


void doLightSleep(osjob_t* pJob)
{
    gLed.Set(LedPattern::Sleeping);
    os_setTimedCallback(
        pJob,
        os_getTime() + sec2osticks(CATCFG_T_INTERVAL),
        sleepDoneCb);
}

static void sleepDoneCb(osjob_t* pJob)
{
    gLed.Set(LedPattern::WarmingUp);

    os_setTimedCallback(
        &sensorJob,
        os_getTime() + sec2osticks(CATCFG_T_WARMUP),
        warmupDoneCb);
}

static void warmupDoneCb(osjob_t* pJob)
{
    ReadSensors(false,false);
}

static void receiveMessage(void *pContext, uint8_t port, const uint8_t *pMessage, size_t nMessage)
{
    unsigned txCycle;
    unsigned txCount;

    gCatena.SafePrintf("receiveMessage was called!!!\n");

    if (! (port == 1 && 2 <= nMessage && nMessage <= 3))
            {
            gCatena.SafePrintf("invalid message port(%02x)/length(%zx)\n",
                    port, nMessage
                    );
            return;
            }

     txCycle = (pMessage[0] << 8) | pMessage[1];

    if (txCycle < CATCFG_T_MIN || txCycle > CATCFG_T_MAX)
            {
            gCatena.SafePrintf("tx cycle time out of range: %u\n", txCycle);
            return;
            }

    // byte [2], if present, is the repeat count.
    // explicitly sending zero causes it to stick.
    txCount = CATCFG_INTERVAL_COUNT;
    if (nMessage >= 3)
            {
            txCount = pMessage[2];
            }

     // we print out the received message...
     gCatena.SafePrintf("Received Data (Payload): \n");
     for (byte i = 0; i < nMessage; i++) {
       gCatena.SafePrintf("%c", pMessage[i]);
     }
     gCatena.SafePrintf("\n");
     
     setTxCycleTime(txCycle, txCount);
}

void setTxCycleTime(unsigned txCycle, unsigned txCount)
{
    if (txCount > 0)
            gCatena.SafePrintf(
                    "message cycle time %u seconds for %u messages\n",
                    txCycle, txCount
                    );
    else
            gCatena.SafePrintf(
                    "message cycle time %u seconds indefinitely\n",
                    txCycle
                    );

    gTxCycle = txCycle;
    gTxCycleCount = txCount;
}

/* process "application hello" -- args are ignored */
// argv[0] is "hello"
// argv[1..argc-1] are the (ignored) arguments
cCommandStream::CommandStatus cmdHello(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    pThis->printf("Hello, world!\n");

    return cCommandStream::CommandStatus::kSuccess;
}


cCommandStream::CommandStatus cmdGetCalibrationSettings(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    pThis->printf("{\n");
    pThis->printf("  \"cal_w1_0\": \"%d\",\n",config_data.cal_w1_0);
    pThis->printf("  \"cal_w2_0\": \"%d\",\n",config_data.cal_w2_0);
    pThis->printf("  \"cal_w1_factor\": \"%d.%03d\n",(int)config_data.cal_w1_factor,(int)abs(config_data.cal_w1_factor*1000)%1000);
    pThis->printf("  \"cal_w2_factor\": \"%d.%03d\n",(int)config_data.cal_w2_factor,(int)abs(config_data.cal_w2_factor*1000)%1000);
    pThis->printf("}\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdGetSensorReadings(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    ReadSensors(false,true);
    pThis->printf("{\n");
    pThis->printf("  \"weight\": \"%d\",\n",last_sensor_reading.weight);
    pThis->printf("  \"weight1_raw\": \"%d\",\n",last_sensor_reading.weight1);
    pThis->printf("  \"weight2_raw\": \"%d\",\n",last_sensor_reading.weight2);
    pThis->printf("  \"temperature\": \"%d\",\n",last_sensor_reading.temperature);
    pThis->printf("  \"humidity\": \"%d\",\n",last_sensor_reading.humidity);
    pThis->printf("  \"pressure\": \"%d\",\n",last_sensor_reading.pressure);
    pThis->printf("  \"batt\": \"%d\",\n", last_sensor_reading.vbat);
    pThis->printf("}\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdGetScale1(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    pThis->printf("getscale1\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdGetScale2(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    pThis->printf("getscale2\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdCalibrateZeroScale1(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    ReadSensors(false,true);
    config_data.cal_w1_0 = last_sensor_reading.weight1;
    gCatena.getFram()->saveField(cFramStorage::kBme680Cal, (const uint8_t *)&config_data, sizeof(config_data));

    pThis->printf("{ \"msg\": \"calibrate_zero_scale1 was successful\" }\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdCalibrateZeroScale2(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    ReadSensors(false,true);
    config_data.cal_w2_0 = last_sensor_reading.weight2;
    gCatena.getFram()->saveField(cFramStorage::kBme680Cal, (const uint8_t *)&config_data, sizeof(config_data));

    pThis->printf("{ \"msg\": \"calibrate_zero_scale2 was successful\" }\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdCalibrateScale1(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    ReadSensors(false,true);

    String w1_gramm(argv[1]);
    config_data.cal_w1_factor = (((float)last_sensor_reading.weight1 - config_data.cal_w1_0)/ w1_gramm.toFloat());
    
    gCatena.getFram()->saveField(cFramStorage::kBme680Cal, (const uint8_t *)&config_data, sizeof(config_data));

    pThis->printf("{ \"msg\": \"calibrate_scale1 was successful\" }\n");

    return cCommandStream::CommandStatus::kSuccess;
}

cCommandStream::CommandStatus cmdCalibrateScale2(cCommandStream *pThis,void *pContext,int argc,char **argv)
{
    ReadSensors(false,true);

    String w2_gramm(argv[1]);
    config_data.cal_w2_factor = (((float)last_sensor_reading.weight2 - config_data.cal_w2_0)/ w2_gramm.toFloat());
    
    gCatena.getFram()->saveField(cFramStorage::kBme680Cal, (const uint8_t *)&config_data, sizeof(config_data));

    pThis->printf("{ \"msg\": \"calibrate_scale2 was successful\" }\n");

    return cCommandStream::CommandStatus::kSuccess;
}

