Merge pull request #190 from TheThingsNetwork/feature/cayennelpp

CayenneLPP support

docs/CayenneLPP.md

@@ -0,0 +1,84 @@
+# API Reference
+
+The `CayenneLPP` class enables Arduino devices to encode data with the Cayenne Lower Power Protocol (LPP). [Read more about Cayenne LPP](https://mydevices.com/cayenne/docs/#lora-cayenne-low-power-payload)
+
+## Class: `CayenneLPP`
+
+Include and instantiate the CayenneLPP class. The constructor takes the size of the allocated buffer. Depending on the LoRa frequency plan and data rate used, the maximum payload varies. It's safe to send up to 51 bytes of payload.
+
+```c
+#include <CayenneLPP.h>
+
+CayenneLPP lpp(uint8_t size);
+```
+
+- `uint8_t size`: The maximum payload size to send, e.g. `51`.
+
+## Example
+
+```c
+TheThingsNetwork ttn(loraSerial, debugSerial, freqPlan);
+CayenneLPP lpp(51);
+
+lpp.reset();
+lpp.addTemperature(1, 22.5);
+lpp.addBarometricPressure(2, 1073.21);
+lpp.addGPS(3, 52.37365, 4.88650, 2);
+
+ttn.sendBytes(lpp.getBuffer(), lpp.getSize());
+```
+
+See the [CayenneLPP](https://github.com/TheThingsNetwork/arduino-device-lib/blob/master/examples/CayenneLPP/CayenneLPP.ino) example. 
+
+## Method: `reset`
+
+Resets the buffer.
+
+```c
+void reset(void);
+```
+
+## Method: `getSize`
+
+Returns the size of the buffer.
+
+```c
+uint8_t getSize(void);
+```
+
+## Method: `getBuffer`
+
+Returns a pointer to the buffer.
+
+```c
+uint8_t *getBuffer(void);
+```
+
+## Method: `copy`
+
+Copies the internal buffer to a specified buffer and returns the copied size.
+
+```c
+uint8_t copy(uint8_t *buffer);
+```
+
+## Methods: `add...`
+
+Add data to the buffer. The `channel` parameter acts as a key for the data field. The data fields you send are dynamic; you can selectively send data as long as the channel matches.
+
+```c
+uint8_t addDigitalInput(uint8_t channel, uint8_t value);
+uint8_t addDigitalOutput(uint8_t channel, uint8_t value);
+
+uint8_t addAnalogInput(uint8_t channel, float value);
+uint8_t addAnalogOutput(uint8_t channel, float value);
+
+uint8_t addLuminosity(uint8_t channel, uint16_t lux);
+uint8_t addPresence(uint8_t channel, uint8_t value);
+uint8_t addTemperature(uint8_t channel, float celsius);
+uint8_t addRelativeHumidity(uint8_t channel, float rh);
+uint8_t addAccelerometer(uint8_t channel, float x, float y, float z);
+uint8_t addBarometricPressure(uint8_t channel, float hpa);
+uint8_t addGyrometer(uint8_t channel, float x, float y, float z);
+uint8_t addGPS(uint8_t channel, float latitude, float longitude, float meters);
+```

examples/CayenneLPP/CayenneLPP.ino

@@ -0,0 +1,46 @@
+#include <TheThingsNetwork.h>
+#include <CayenneLPP.h>
+
+// Set your AppEUI and AppKey
+const char *appEui = "0000000000000000";
+const char *appKey = "00000000000000000000000000000000";
+
+#define loraSerial Serial1
+#define debugSerial Serial
+
+// Replace REPLACE_ME with TTN_FP_EU868 or TTN_FP_US915
+#define freqPlan REPLACE_ME
+
+TheThingsNetwork ttn(loraSerial, debugSerial, freqPlan);
+CayenneLPP lpp(51);
+
+void setup()
+{
+  loraSerial.begin(57600);
+  debugSerial.begin(9600);
+
+  // Wait a maximum of 10s for Serial Monitor
+  while (!debugSerial && millis() < 10000)
+    ;
+
+  debugSerial.println("-- STATUS");
+  ttn.showStatus();
+
+  debugSerial.println("-- JOIN");
+  ttn.join(appEui, appKey);
+}
+
+void loop()
+{
+  debugSerial.println("-- LOOP");
+
+  lpp.reset();
+  lpp.addTemperature(1, 22.5);
+  lpp.addBarometricPressure(2, 1073.21);
+  lpp.addGPS(3, 52.37365, 4.88650, 2);
+
+  // Send it off
+  ttn.sendBytes(lpp.getBuffer(), lpp.getSize());
+
+  delay(10000);
+}

src/CayenneLPP.cpp

@@ -0,0 +1,239 @@
+// Adapted from https://developer.mbed.org/teams/myDevicesIoT/code/Cayenne-LPP/
+
+// Copyright © 2017 The Things Network
+// Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+
+#include "CayenneLPP.h"
+
+CayenneLPP::CayenneLPP(uint8_t size) : maxsize(size)
+{
+  buffer = (uint8_t *)malloc(size);
+  cursor = 0;
+}
+
+CayenneLPP::~CayenneLPP(void)
+{
+  free(buffer);
+}
+
+void CayenneLPP::reset(void)
+{
+  cursor = 0;
+}
+
+uint8_t CayenneLPP::getSize(void)
+{
+  return cursor;
+}
+
+uint8_t *CayenneLPP::getBuffer(void)
+{
+  //    uint8_t[cursor] result;
+  //    memcpy(result, buffer, cursor);
+  //    return result;
+  return buffer;
+}
+
+uint8_t CayenneLPP::copy(uint8_t *dst)
+{
+  memcpy(dst, buffer, cursor);
+  return cursor;
+}
+
+uint8_t CayenneLPP::addDigitalInput(uint8_t channel, uint8_t value)
+{
+  if ((cursor + LPP_DIGITAL_INPUT_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_DIGITAL_INPUT;
+  buffer[cursor++] = value;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addDigitalOutput(uint8_t channel, uint8_t value)
+{
+  if ((cursor + LPP_DIGITAL_OUTPUT_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_DIGITAL_OUTPUT;
+  buffer[cursor++] = value;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addAnalogInput(uint8_t channel, float value)
+{
+  if ((cursor + LPP_ANALOG_INPUT_SIZE) > maxsize)
+  {
+    return 0;
+  }
+
+  int16_t val = value * 100;
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_ANALOG_INPUT;
+  buffer[cursor++] = val >> 8;
+  buffer[cursor++] = val;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addAnalogOutput(uint8_t channel, float value)
+{
+  if ((cursor + LPP_ANALOG_OUTPUT_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  int16_t val = value * 100;
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_ANALOG_OUTPUT;
+  buffer[cursor++] = val >> 8;
+  buffer[cursor++] = val;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addLuminosity(uint8_t channel, uint16_t lux)
+{
+  if ((cursor + LPP_LUMINOSITY_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_LUMINOSITY;
+  buffer[cursor++] = lux >> 8;
+  buffer[cursor++] = lux;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addPresence(uint8_t channel, uint8_t value)
+{
+  if ((cursor + LPP_PRESENCE_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_PRESENCE;
+  buffer[cursor++] = value;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addTemperature(uint8_t channel, float celsius)
+{
+  if ((cursor + LPP_TEMPERATURE_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  int16_t val = celsius * 10;
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_TEMPERATURE;
+  buffer[cursor++] = val >> 8;
+  buffer[cursor++] = val;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addRelativeHumidity(uint8_t channel, float rh)
+{
+  if ((cursor + LPP_RELATIVE_HUMIDITY_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_RELATIVE_HUMIDITY;
+  buffer[cursor++] = rh * 2;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addAccelerometer(uint8_t channel, float x, float y, float z)
+{
+  if ((cursor + LPP_ACCELEROMETER_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  int16_t vx = x * 1000;
+  int16_t vy = y * 1000;
+  int16_t vz = z * 1000;
+
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_ACCELEROMETER;
+  buffer[cursor++] = vx >> 8;
+  buffer[cursor++] = vx;
+  buffer[cursor++] = vy >> 8;
+  buffer[cursor++] = vy;
+  buffer[cursor++] = vz >> 8;
+  buffer[cursor++] = vz;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addBarometricPressure(uint8_t channel, float hpa)
+{
+  if ((cursor + LPP_BAROMETRIC_PRESSURE_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  int16_t val = hpa * 10;
+
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_BAROMETRIC_PRESSURE;
+  buffer[cursor++] = val >> 8;
+  buffer[cursor++] = val;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addGyrometer(uint8_t channel, float x, float y, float z)
+{
+  if ((cursor + LPP_GYROMETER_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  int16_t vx = x * 100;
+  int16_t vy = y * 100;
+  int16_t vz = z * 100;
+
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_GYROMETER;
+  buffer[cursor++] = vx >> 8;
+  buffer[cursor++] = vx;
+  buffer[cursor++] = vy >> 8;
+  buffer[cursor++] = vy;
+  buffer[cursor++] = vz >> 8;
+  buffer[cursor++] = vz;
+
+  return cursor;
+}
+
+uint8_t CayenneLPP::addGPS(uint8_t channel, float latitude, float longitude, float meters)
+{
+  if ((cursor + LPP_GPS_SIZE) > maxsize)
+  {
+    return 0;
+  }
+  int32_t lat = latitude * 10000;
+  int32_t lon = longitude * 10000;
+  int32_t alt = meters * 100;
+
+  buffer[cursor++] = channel;
+  buffer[cursor++] = LPP_GPS;
+
+  buffer[cursor++] = lat >> 16;
+  buffer[cursor++] = lat >> 8;
+  buffer[cursor++] = lat;
+  buffer[cursor++] = lon >> 16;
+  buffer[cursor++] = lon >> 8;
+  buffer[cursor++] = lon;
+  buffer[cursor++] = alt >> 16;
+  buffer[cursor++] = alt >> 8;
+  buffer[cursor++] = alt;
+
+  return cursor;
+}