clair.cpp

#include "clair.h"
#include "sensor.h"
#include "debug.h"
#include <algorithm>

typedef struct {
  uint16_t samplingPeriodSeconds;
  uint8_t samplesPerMessage;
} transmission_config_t;

// the order of this array corresponds to the LMIC DR_XX enums
static transmission_config_t transmission_configs[] = {
  { .samplingPeriodSeconds = 855, .samplesPerMessage = 5 }, // SF12+
  { .samplingPeriodSeconds = 534, .samplesPerMessage = 4 }, // SF11+
  { .samplingPeriodSeconds = 214, .samplesPerMessage = 5 }, // SF10+
  { .samplingPeriodSeconds = 178, .samplesPerMessage = 3 }, // SF9+
  { .samplingPeriodSeconds = 134, .samplesPerMessage = 2 }, // SF8
  { .samplingPeriodSeconds = 75, .samplesPerMessage = 2 }, // SF7
  { .samplingPeriodSeconds = 38, .samplesPerMessage = 2 } // SF7/B
};

#define NROF_TRANSMISSION_CONFIGS (sizeof(transmission_configs) / sizeof(transmission_configs[0]))

Clair::Clair(Sensor *sensorArg) {
  sensor = sensorArg;

  currentDatarate = 0; // SF12
  secondsSinceLastSample = 0;
  numberOfSamplesInBuffer = 0;
  indexOfNextSampleInMinuteBuffer = 0;
}

bool Clair::setup() {
  return sensor->setup();
}

#define NROF_SAMPLES_IN_MINUTE_BUFFER (sizeof(minuteBuffer) / sizeof(minuteBuffer[0]))

void Clair::addSampleToMinuteBuffer(clair_sample_t sample) {
  minuteBuffer[indexOfNextSampleInMinuteBuffer] = sample;
  indexOfNextSampleInMinuteBuffer = (indexOfNextSampleInMinuteBuffer + 1) % NROF_SAMPLES_IN_MINUTE_BUFFER;
}

clair_sample_t Clair::getAverageSampleOfLastMinute() {
  uint32_t sumOfCo2ppms = 0;
  float sumOfTemperatures = 0;
  float sumOfHumidities = 0;

  for (uint16_t i = 0; i < NROF_SAMPLES_IN_MINUTE_BUFFER; i++) {
    sumOfCo2ppms += minuteBuffer[i].co2ppm;
    sumOfTemperatures += minuteBuffer[i].temperature;
    sumOfHumidities += minuteBuffer[i].humidity;
  }

  clair_sample_t averageSample;
  averageSample.co2ppm = (sumOfCo2ppms + (NROF_SAMPLES_IN_MINUTE_BUFFER / 2)) / NROF_SAMPLES_IN_MINUTE_BUFFER;
  averageSample.temperature = sumOfTemperatures / NROF_SAMPLES_IN_MINUTE_BUFFER;
  averageSample.humidity = sumOfHumidities / NROF_SAMPLES_IN_MINUTE_BUFFER;

  return averageSample;
}

#define PRINT_SAMPLE(SAMPLE) do { \
    PRINT(F("CO2: ")); \
    PRINT(SAMPLE.co2ppm); \
    PRINT(F(" ppm, temperature: ")); \
    PRINT(SAMPLE.temperature); \
    PRINT(F(" °C, humidity: ")); \
    PRINT(SAMPLE.humidity); \
    PRINTLN(F(" %")); \
  } while (0)

int16_t Clair::getCO2Concentration() {
  if (sensor->measurementFailed()) return -1;

  clair_sample_t sample = sensor->sampleMeasurements();

  PRINT(F("sample: "));
  PRINT_SAMPLE(sample);

  addSampleToMinuteBuffer(sample);
  secondsSinceLastSample += CLAIR_MEASURING_PERIOD_SECS;

  if (secondsSinceLastSample >= transmission_configs[currentDatarate].samplingPeriodSeconds) {
    PRINTLN(F("adding average sample of last minute to message buffer"));

    if (numberOfSamplesInBuffer == transmission_configs[currentDatarate].samplesPerMessage) {
      PRINTLN(F("message overdue, discarding oldest sample"));
      for (int i = 0; i < numberOfSamplesInBuffer - 1; i++) {
        sampleBuffer[i] = sampleBuffer[i + 1];
      }
      numberOfSamplesInBuffer -= 1;
    }

    clair_sample_t averageSample = getAverageSampleOfLastMinute();
    PRINT(F("average sample of last minute: "));
    PRINT_SAMPLE(averageSample);

    sampleBuffer[numberOfSamplesInBuffer] = averageSample;
    numberOfSamplesInBuffer += 1;
    PRINT(F("number of samples in buffer: "));
    PRINTLN(numberOfSamplesInBuffer);

    secondsSinceLastSample = 0;
  }

  return static_cast<int16_t>(sample.co2ppm);
}

void Clair::setCurrentDatarate(int datarate) {
  if (datarate < 0 || datarate > (int) NROF_TRANSMISSION_CONFIGS) {
    PRINT(F("WARNING: invalid datarate: ")); PRINTLN(datarate);
    datarate = 0;
  }

  currentDatarate = datarate;

  PRINT(F("current datarate: "));
  PRINT_DATARATE(currentDatarate);
  PRINTLN("");
  PRINT(F("current sampling period [s]: ")); PRINTLN(transmission_configs[currentDatarate].samplingPeriodSeconds);
  PRINT(F("current # of samples in message: ")); PRINTLN(transmission_configs[currentDatarate].samplesPerMessage);
}

bool Clair::isMessageDue() {
  return numberOfSamplesInBuffer >= transmission_configs[currentDatarate].samplesPerMessage;
}

static uint8_t encodeCO2ppmByte(uint16_t co2ppm) {
  co2ppm = std::min(co2ppm, static_cast<uint16_t>(5100));
  return (co2ppm + 10) / 20; // apply proper rounding
}

static uint8_t encodeTemperatureByte(float temperature) {
  temperature = std::max(temperature, static_cast<float>(.0));
  temperature = std::min(temperature, static_cast<float>(31.0));
  uint8_t quantizedTemperature = ((uint8_t) (temperature + 0.5)) & 0x1F;
  return quantizedTemperature;
}

static uint8_t encodeHumidityByte(float humidity) {
  humidity = std::max(humidity, static_cast<float>(10.0));
  humidity = std::min(humidity, static_cast<float>(80.0));
  uint8_t quantizedHumidity = (uint8_t) (humidity + 5) / 10; // quantize to 10 °K steps
  quantizedHumidity -= 1; // start at 0
  return quantizedHumidity & 0x7;
}

static void encodeSample(clair_sample_t sample, uint8_t *messageBuffer) {
  messageBuffer[0] = encodeCO2ppmByte(sample.co2ppm);

  messageBuffer[1] = 0;
  messageBuffer[1] |= encodeTemperatureByte(sample.temperature) << 3; // 5 bits
  messageBuffer[1] |= encodeHumidityByte(sample.humidity); // 3 bits
}

#define CLAIR_PROTOCOL_VERSION 0
#define CLAIR_MESSAGE_ID_SAMPLE_LIST 0

uint8_t Clair::encodeMessage(uint8_t *messageBuffer, uint16_t messageBufferSize) {
  if (!isMessageDue()) return 0;
  if (messageBufferSize < 1) return 0;

  // encode header
  uint8_t *bufferPosition = messageBuffer;
  *bufferPosition = 0;
  *bufferPosition |= CLAIR_PROTOCOL_VERSION << 6; // protocol version (2 bits)
  *bufferPosition |= CLAIR_MESSAGE_ID_SAMPLE_LIST << 3; // message identifier (3 bits)
  // NOTE: to use all bits of the message header to full capacity we transmit the number of samples - 1!
  *bufferPosition |= transmission_configs[currentDatarate].samplesPerMessage - 1; // message header (3 bits)
  bufferPosition += 1;

  uint8_t messageLength = 1;

  // encode samples
  for (int i = 0; i < numberOfSamplesInBuffer; i++) {
    messageLength += 2;
    if (messageLength > messageBufferSize) {
      PRINT(F("WARNING: message buffer size too small:"));
      PRINTLN(messageBufferSize);
      return 0;
    }
    encodeSample(sampleBuffer[i], bufferPosition);
    bufferPosition += 2;
  }

  // reset sample buffer
  numberOfSamplesInBuffer = 0;

  return messageLength;
}