673 lines
17 KiB
C++
673 lines
17 KiB
C++
/*
|
||
|
||
beescale_lora_mcci.ino
|
||
|
||
BeieliScale, see https://mini-beieli.ch
|
||
|
||
Joerg Lehmann, nbit Informatik GmbH
|
||
|
||
*/
|
||
|
||
#include <Catena.h>
|
||
|
||
#include <Catena_Led.h>
|
||
#include <Catena_TxBuffer.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
|
||
};
|
||
|
||
/* 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),
|
||
};
|
||
|
||
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
|
||
};
|
||
|
||
// 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;
|
||
|
||
/****************************************************************************\
|
||
|
|
||
| READ-ONLY DATA
|
||
|
|
||
\****************************************************************************/
|
||
|
||
static const char sVersion[] = "0.1";
|
||
static const byte MAX_VALUES_TO_SEND = 4;
|
||
static const uint8_t LORA_DATA_VERSION = 1;
|
||
|
||
|
||
/****************************************************************************\
|
||
|
|
||
| VARIABLES
|
||
|
|
||
\****************************************************************************/
|
||
|
||
typedef struct {
|
||
uint8_t version; // Versionierung des Paketformats
|
||
uint8_t vbat; // Batteriespannung (1 Einheit => 20 mV)
|
||
uint8_t humidity; // Luftfeuchtigkeit in Zehntels-Prozent
|
||
uint8_t pressure; // Luftdruck in XXXX
|
||
uint8_t reading_offset[MAX_VALUES_TO_SEND]; // Zeit der Messung in Sekunden, erster Wert ist 0
|
||
int16_t weight_raw1[MAX_VALUES_TO_SEND]; // Reading (raw) der ersten Waegzelle
|
||
int16_t weight_raw2[MAX_VALUES_TO_SEND]; // Reading (raw) der zweiten Waegzelle
|
||
int16_t temperature[MAX_VALUES_TO_SEND]; // Temperatur in 1/10 Grad Celsius
|
||
} LORA_data;
|
||
|
||
// Global Variables
|
||
LORA_data lora_data;
|
||
|
||
// 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();
|
||
|
||
lora_data.version = LORA_DATA_VERSION;
|
||
|
||
setup_platform();
|
||
setup_bme280();
|
||
setup_scales();
|
||
setup_flash();
|
||
setup_uplink();
|
||
}
|
||
|
||
void setup_platform(void)
|
||
{
|
||
#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");
|
||
}
|
||
|
||
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.
|
||
LoadCell_1.begin(A3, A2);
|
||
LoadCell_2.begin(A1, A0);
|
||
|
||
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 */
|
||
startSendingUplink();
|
||
}
|
||
}
|
||
}
|
||
|
||
// 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();
|
||
|
||
/* for mfg test, don't tx, just fill -- this causes output to Serial */
|
||
if (gCatena.GetOperatingFlags() &
|
||
static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fManufacturingTest))
|
||
{
|
||
TxBuffer_t b;
|
||
fillBuffer(b);
|
||
delay(1000);
|
||
}
|
||
}
|
||
|
||
|
||
void ReadSensors()
|
||
{
|
||
|
||
// vBat
|
||
float vBat = gCatena.ReadVbat();
|
||
gCatena.SafePrintf("vBat: %d mV\n", (int) (vBat * 1000.0f));
|
||
lora_data.vbat = (vBat * 1000 / 20);
|
||
|
||
// vBus
|
||
float vBus = gCatena.ReadVbus();
|
||
gCatena.SafePrintf("vBus: %d mV\n", (int) (vBus * 1000.0f));
|
||
fUsbPower = (vBus > 3.0) ? true : false;
|
||
|
||
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
|
||
);
|
||
lora_data.temperature[0] = m.Temperature;
|
||
lora_data.humidity = m.Temperature;
|
||
lora_data.pressure = m.Pressure;
|
||
}
|
||
|
||
gCatena.SafePrintf("Before Read Scales\n");
|
||
if (LoadCell_1.wait_ready_timeout(1000))
|
||
{
|
||
long w1 = LoadCell_1.read_average(5);
|
||
gCatena.SafePrintf("Load_cell 1 output val: %ld\n", w1);
|
||
}
|
||
else {
|
||
Serial.println("HX711 LoadCell_1 not found.");
|
||
}
|
||
if (LoadCell_2.wait_ready_timeout(1000))
|
||
{
|
||
long w2 = LoadCell_2.read_average(5);
|
||
gCatena.SafePrintf("Load_cell 2 output val: %ld\n", w2);
|
||
}
|
||
else {
|
||
Serial.println("HX711 LoadCell_2 not found.");
|
||
}
|
||
gCatena.SafePrintf("After Read Scales\n");
|
||
|
||
}
|
||
|
||
|
||
void fillBuffer(TxBuffer_t &b)
|
||
{
|
||
b.begin();
|
||
FlagsSensor2 flag;
|
||
|
||
flag = FlagsSensor2(0);
|
||
|
||
b.put(FormatSensor2); /* the flag for this record format */
|
||
uint8_t * const pFlag = b.getp();
|
||
b.put(0x00); /* will be set to the flags */
|
||
|
||
// vBat is sent as 5000 * v
|
||
float vBat = gCatena.ReadVbat();
|
||
gCatena.SafePrintf("vBat: %d mV\n", (int) (vBat * 1000.0f));
|
||
b.putV(vBat);
|
||
flag |= FlagsSensor2::FlagVbat;
|
||
|
||
// vBus is sent as 5000 * v
|
||
float vBus = gCatena.ReadVbus();
|
||
gCatena.SafePrintf("vBus: %d mV\n", (int) (vBus * 1000.0f));
|
||
fUsbPower = (vBus > 3.0) ? true : false;
|
||
|
||
uint32_t bootCount;
|
||
if (gCatena.getBootCount(bootCount))
|
||
{
|
||
b.putBootCountLsb(bootCount);
|
||
flag |= FlagsSensor2::FlagBoot;
|
||
}
|
||
|
||
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
|
||
);
|
||
b.putT(m.Temperature);
|
||
b.putP(m.Pressure);
|
||
b.putRH(m.Humidity);
|
||
|
||
flag |= FlagsSensor2::FlagTPH;
|
||
}
|
||
|
||
|
||
gCatena.SafePrintf("Before Read Scales\n");
|
||
if (LoadCell_1.wait_ready_timeout(1000))
|
||
{
|
||
long w1 = LoadCell_1.read_average(5);
|
||
gCatena.SafePrintf("Load_cell 1 output val: %ld\n", w1);
|
||
}
|
||
else {
|
||
Serial.println("HX711 LoadCell_1 not found.");
|
||
}
|
||
if (LoadCell_2.wait_ready_timeout(1000))
|
||
{
|
||
long w2 = LoadCell_2.read_average(5);
|
||
gCatena.SafePrintf("Load_cell 2 output val: %ld\n", w2);
|
||
}
|
||
else {
|
||
Serial.println("HX711 LoadCell_2 not found.");
|
||
}
|
||
gCatena.SafePrintf("After Read Scales\n");
|
||
|
||
*pFlag = uint8_t(flag);
|
||
}
|
||
|
||
void startSendingUplink(void)
|
||
{
|
||
TxBuffer_t b;
|
||
LedPattern savedLed = gLed.Set(LedPattern::Measuring);
|
||
|
||
fillBuffer(b);
|
||
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;
|
||
}
|
||
|
||
//gLoRaWAN.SendBuffer(b.getbase(), b.getn(), sendBufferDoneCb, NULL, fConfirmed);
|
||
gLoRaWAN.SendBuffer((uint8_t*) &lora_data, sizeof(LORA_data), sendBufferDoneCb, NULL, fConfirmed);
|
||
|
||
|
||
}
|
||
|
||
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
|
||
)
|
||
{
|
||
startSendingUplink();
|
||
}
|