From 441356f0aba07b76d5e9d02f6d7c735121252dbc Mon Sep 17 00:00:00 2001 From: Joerg Lehmann Date: Fri, 21 Jun 2019 14:21:59 +0200 Subject: [PATCH] Initial commit --- README.md | 5 + mini-beieli-node.ino | 988 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 993 insertions(+) create mode 100644 README.md create mode 100644 mini-beieli-node.ino diff --git a/README.md b/README.md new file mode 100644 index 0000000..e47bcfd --- /dev/null +++ b/README.md @@ -0,0 +1,5 @@ +# mini-beieli-node - Bienenstock Ueberwachung + +Code fuer den LoraWAN Node + +Autor: Joerg Lehmann, nbit Informatik GmbH diff --git a/mini-beieli-node.ino b/mini-beieli-node.ino new file mode 100644 index 0000000..3e5d03d --- /dev/null +++ b/mini-beieli-node.ino @@ -0,0 +1,988 @@ +/* + + mini-beieli-node.ino + + BeieliScale, see https://mini-beieli.ch + + Joerg Lehmann, nbit Informatik GmbH + +*/ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +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[123]; +} __attribute__((packed)) CONFIG_data; + +typedef struct { + uint8_t version; // Version + uint8_t vbat; // Batteriespannung (0: <= 2510mV, 70: 3000mV, 170: 3700mV, 255: >= 4295mV [1 Einheit => 7mV]) + 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 (0: <= 2510mV, 70: 3000mV, 170: 3700mV, 255: >= 4295mV [1 Einheit => 7mV]) + 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 (0: <= 2510mV, 70: 3000mV, 170: 3700mV, 255: >= 4295mV [1 Einheit => 7mV]) + 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(); + + // Use D10 to regulate power + pinMode(D10, OUTPUT); + + 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(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"); + + // Enable Power + digitalWrite(D10, HIGH); + + // 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"); + } + + //LoadCell_1.power_down(); + + gCatena.SafePrintf("Setup Scale 2...\n"); + LoadCell_2.begin(D12, A2); + + if (!(LoadCell_2.wait_ready_timeout(1000))) { + gCatena.SafePrintf("Scale 2 not ready.\n"); + } + + //LoadCell_2.power_down(); + + 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(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"); + + } +} + +uint8_t GetVBatValue(int millivolts) +{ + uint8_t res; + if (millivolts <= 2510) { + res = 0; + + } else if (millivolts >= 4295) { + res = 255; + + } else { + res = (millivolts - 2510) / 7; + } + + return res; +} + +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; + + // Setup Scales + setup_scales(); + + // 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); + gCatena.SafePrintf("Load_cell 1 weight1_current: %ld\n", weight1_current); + } + 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); + gCatena.SafePrintf("Load_cell 2 weight2_current: %ld\n", weight2_current); + } + else { + Serial.println("HX711 LoadCell_2 not ready."); + } + + // Power-Down HX711 + //LoadCell_2.power_down(); + + // Disable Power + digitalWrite(D10, LOW); + + gCatena.SafePrintf("After Read Scales\n"); + + // Gewicht berechnen + weight_current32 = (int32_t)((((weight1_current - config_data.cal_w1_0) / config_data.cal_w1_factor) + ((weight2_current - config_data.cal_w2_0) / config_data.cal_w2_factor)) / 5.0); + 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 = GetVBatValue((int)(vBat * 1000.0f)); + 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 = GetVBatValue((int)(vBat * 1000.0f)); + 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 { + gCatena.SafePrintf("now going to sleep for 6 minutes...\n"); + Serial.flush(); + gLed.Set(LedPattern::Sleeping); + os_setTimedCallback( + &sensorJob, + os_getTime() + sec2osticks(CATCFG_T_INTERVAL), + sleepDoneCb); + if (!fUsbPower) { + gCatena.Sleep(CATCFG_T_INTERVAL - 5); + } + } + } + + last_sensor_reading.vbat = GetVBatValue((int)(vBat * 1000.0f)); + + 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) { + gCatena.SafePrintf("SendBuffer firstTime\n"); + gLoRaWAN.SendBuffer((uint8_t*)&lora_data_first, sizeof(LORA_data_first), sendBufferDoneCb, NULL, fConfirmed); + } else { + gCatena.SafePrintf("SendBuffer not firstTime\n"); + 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; + } + gCatena.SafePrintf("sendBufferDoneCB before TimedCallback\n"); + os_setTimedCallback( + &sensorJob, + os_getTime() + sec2osticks(CATCFG_T_SETTLE), + pFn); + gCatena.SafePrintf("sendBufferDoneCB after TimedCallback\n"); +} + +static void txFailedDoneCb( + osjob_t* pSendJob) +{ + gCatena.SafePrintf("not provisioned, idling\n"); + gLoRaWAN.Shutdown(); + gLed.Set(LedPattern::NotProvisioned); +} + + + +static void settleDoneCb( + osjob_t* pSendJob) +{ + gCatena.SafePrintf("settleDoneCb\n"); + sleepDoneCb(pSendJob); +} + +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)); + + gCatena.SafePrintf("last_sensor_reading.weight1: %ld\n", last_sensor_reading.weight1); + gCatena.SafePrintf("config_data.cal_w1_0: %ld\n", config_data.cal_w1_0); + gCatena.SafePrintf("w1_gramm: %s\n", w1_gramm); + gCatena.SafePrintf("w1_gramm (float): %d\n", (int)w1_gramm.toFloat()); + gCatena.SafePrintf("config_data.cal_w1_factor: %d\n", (int)config_data.cal_w1_factor); + + 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; +} +