Max
/
LMIC-OTAA-Feather-Test
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

add hseProtokoll 

hse2020 lib hinzugefügt und mit konstanten Werte vorbelegt
master
Ralf Behrens 4 years ago
parent
8b3fde249b
commit
1e6baeb463
3 changed files with 846 additions and 2 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 608
      lib/hseSensorProtocol/hseSensorProtocol.cpp
  2. 209
      lib/hseSensorProtocol/hseSensorProtocol.h
  3. 29
      src/main.cpp

608
lib/hseSensorProtocol/hseSensorProtocol.cpp
Unescape View File

@ -0,0 +1,608 @@ @@ -0,0 +1,608 @@
/*
THIS IS GENERATED CODE
DO NOT EDIT
Developer: Max Reble
Copyright Notice: hse-electronics GmbH, Max Reble (2020)
License: MIT License (see LICENSE.txt)
*/
#include "HseSensorProtocol.h"
#include <stdlib.h> //malloc
#include <string.h> //memcpy
#define __HSESP_VERSION buffer[0]
HseSP::HseSP(uint8_t version, uint8_t size) : maxsize(size)
{
buffer = (uint8_t*) malloc(size);
buffer[0] = version;
buffer[1] = 255 - version;
dataCursor = 4;
}
HseSP::~HseSP(void){free(buffer);}
uint8_t HseSP::getSize(void)
{
return dataCursor;
}
uint8_t *HseSP::getBuffer(void)
{
generateCRC();
return buffer;
}
void HseSP::reset(){
dataCursor = 4;
}
void HseSP::generateCRC()
{
uint16_t uiCRC16 = 0;
uint8_t nElement, nBitPos;
//Skip first four elements as its the header
for (nElement = 4; nElement < dataCursor; nElement++)
for (nBitPos = 0; nBitPos < 8; nBitPos++)
if ((uiCRC16 ^ (buffer[nElement] >> nBitPos)) & 1)
uiCRC16 = (uiCRC16 >> 1) ^ 0xA001;
else
uiCRC16 >>= 1;
memcpy(buffer + 2, &uiCRC16, 2);
}
bool HseSP::addDataHeader(uint8_t type, uint8_t dataSize, uint8_t dataLen) {
if (dataCursor + (__HSESP_VERSION == 1 ? (dataSize + 1) * dataLen : (dataSize * dataLen) + 2) > maxsize)
return false;
buffer[dataCursor++] = type;
if (__HSESP_VERSION == 2)
buffer[dataCursor++] = dataLen;
return true;
}
bool HseSP::addDigitalInput(uint8_t value)
{
return addDigitalInput(&value, 1);
}
bool HseSP::addDigitalInput(uint8_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_DIGITAL_INPUT, HSESP_DIGITAL_INPUT_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_DIGITAL_INPUT;
memcpy(buffer + dataCursor, &values[i], sizeof(uint8_t));
dataCursor += sizeof(uint8_t);
}
return true;
}
bool HseSP::addDigitalOutput(uint8_t value)
{
return addDigitalOutput(&value, 1);
}
bool HseSP::addDigitalOutput(uint8_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_DIGITAL_OUTPUT, HSESP_DIGITAL_OUTPUT_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_DIGITAL_OUTPUT;
memcpy(buffer + dataCursor, &values[i], sizeof(uint8_t));
dataCursor += sizeof(uint8_t);
}
return true;
}
bool HseSP::addAnalogInput(float value)
{
return addAnalogInput(&value, 1);
}
bool HseSP::addAnalogInput(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_ANALOG_INPUT, HSESP_ANALOG_INPUT_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_ANALOG_INPUT;
int16_t val = values[i] * 100;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addAnalogOutput(float value)
{
return addAnalogOutput(&value, 1);
}
bool HseSP::addAnalogOutput(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_ANALOG_OUTPUT, HSESP_ANALOG_OUTPUT_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_ANALOG_OUTPUT;
int16_t val = values[i] * 100;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addTemperature(float value)
{
return addTemperature(&value, 1);
}
bool HseSP::addTemperature(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_TEMPERATURE, HSESP_TEMPERATURE_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_TEMPERATURE;
int16_t val = values[i] * 100;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addHumidity(float value)
{
return addHumidity(&value, 1);
}
bool HseSP::addHumidity(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_HUMIDITY, HSESP_HUMIDITY_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_HUMIDITY;
uint8_t val = values[i] * 2;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addPressure(float value)
{
return addPressure(&value, 1);
}
bool HseSP::addPressure(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_PRESSURE, HSESP_PRESSURE_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_PRESSURE;
uint16_t val = values[i] * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addIlluminance(uint16_t value)
{
return addIlluminance(&value, 1);
}
bool HseSP::addIlluminance(uint16_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_ILLUMINANCE, HSESP_ILLUMINANCE_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_ILLUMINANCE;
memcpy(buffer + dataCursor, &values[i], sizeof(uint16_t));
dataCursor += sizeof(uint16_t);
}
return true;
}
bool HseSP::addConcentration(float value)
{
return addConcentration(&value, 1);
}
bool HseSP::addConcentration(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_CONCENTRATION, HSESP_CONCENTRATION_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_CONCENTRATION;
uint16_t val = values[i] * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addDirection(float value)
{
return addDirection(&value, 1);
}
bool HseSP::addDirection(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_DIRECTION, HSESP_DIRECTION_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_DIRECTION;
int16_t val = values[i] * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addRSSI(int16_t value)
{
return addRSSI(&value, 1);
}
bool HseSP::addRSSI(int16_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_RSSI, HSESP_RSSI_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_RSSI;
uint8_t val = values[i] * -1;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addLoudness(uint8_t value)
{
return addLoudness(&value, 1);
}
bool HseSP::addLoudness(uint8_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_LOUDNESS, HSESP_LOUDNESS_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_LOUDNESS;
memcpy(buffer + dataCursor, &values[i], sizeof(uint8_t));
dataCursor += sizeof(uint8_t);
}
return true;
}
bool HseSP::addDistance(float value)
{
return addDistance(&value, 1);
}
bool HseSP::addDistance(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_DISTANCE, HSESP_DISTANCE_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_DISTANCE;
uint16_t val = values[i] * 1000;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addCounter(int16_t value)
{
return addCounter(&value, 1);
}
bool HseSP::addCounter(int16_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_COUNTER, HSESP_COUNTER_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_COUNTER;
memcpy(buffer + dataCursor, &values[i], sizeof(int16_t));
dataCursor += sizeof(int16_t);
}
return true;
}
bool HseSP::addVoltage(float value)
{
return addVoltage(&value, 1);
}
bool HseSP::addVoltage(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_VOLTAGE, HSESP_VOLTAGE_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_VOLTAGE;
int16_t val = values[i] * 1000;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addConductivity(uint16_t value)
{
return addConductivity(&value, 1);
}
bool HseSP::addConductivity(uint16_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_CONDUCTIVITY, HSESP_CONDUCTIVITY_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_CONDUCTIVITY;
memcpy(buffer + dataCursor, &values[i], sizeof(uint16_t));
dataCursor += sizeof(uint16_t);
}
return true;
}
bool HseSP::addLevel(uint8_t value)
{
return addLevel(&value, 1);
}
bool HseSP::addLevel(uint8_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_LEVEL, HSESP_LEVEL_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_LEVEL;
memcpy(buffer + dataCursor, &values[i], sizeof(uint8_t));
dataCursor += sizeof(uint8_t);
}
return true;
}
bool HseSP::addPrecipitation(float value)
{
return addPrecipitation(&value, 1);
}
bool HseSP::addPrecipitation(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_PRECIPITATION, HSESP_PRECIPITATION_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_PRECIPITATION;
uint16_t val = values[i] * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
return true;
}
bool HseSP::addLocation(float value)
{
return addLocation(&value, 1);
}
bool HseSP::addLocation(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_LOCATION, HSESP_LOCATION_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_LOCATION;
memcpy(buffer + dataCursor, &values[i], sizeof(float));
dataCursor += sizeof(float);
}
return true;
}
bool HseSP::addGenericUInt8(uint8_t value)
{
return addGenericUInt8(&value, 1);
}
bool HseSP::addGenericUInt8(uint8_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_UINT8, HSESP_GENERIC_UINT8_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_UINT8;
memcpy(buffer + dataCursor, &values[i], sizeof(uint8_t));
dataCursor += sizeof(uint8_t);
}
return true;
}
bool HseSP::addGenericUInt16(uint16_t value)
{
return addGenericUInt16(&value, 1);
}
bool HseSP::addGenericUInt16(uint16_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_UINT16, HSESP_GENERIC_UINT16_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_UINT16;
memcpy(buffer + dataCursor, &values[i], sizeof(uint16_t));
dataCursor += sizeof(uint16_t);
}
return true;
}
bool HseSP::addGenericInt16(int16_t value)
{
return addGenericInt16(&value, 1);
}
bool HseSP::addGenericInt16(int16_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_INT16, HSESP_GENERIC_INT16_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_INT16;
memcpy(buffer + dataCursor, &values[i], sizeof(int16_t));
dataCursor += sizeof(int16_t);
}
return true;
}
bool HseSP::addGenericUInt32(uint32_t value)
{
return addGenericUInt32(&value, 1);
}
bool HseSP::addGenericUInt32(uint32_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_UINT32, HSESP_GENERIC_UINT32_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_UINT32;
memcpy(buffer + dataCursor, &values[i], sizeof(uint32_t));
dataCursor += sizeof(uint32_t);
}
return true;
}
bool HseSP::addGenericInt32(int32_t value)
{
return addGenericInt32(&value, 1);
}
bool HseSP::addGenericInt32(int32_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_INT32, HSESP_GENERIC_INT32_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_INT32;
memcpy(buffer + dataCursor, &values[i], sizeof(int32_t));
dataCursor += sizeof(int32_t);
}
return true;
}
bool HseSP::addGenericFloat(float value)
{
return addGenericFloat(&value, 1);
}
bool HseSP::addGenericFloat(float *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_FLOAT, HSESP_GENERIC_FLOAT_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_FLOAT;
memcpy(buffer + dataCursor, &values[i], sizeof(float));
dataCursor += sizeof(float);
}
return true;
}
bool HseSP::addGenericANSIChar(char value)
{
return addGenericANSIChar(&value, 1);
}
bool HseSP::addGenericANSIChar(char *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_A_N_S_I_CHAR, HSESP_GENERIC_A_N_S_I_CHAR_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_A_N_S_I_CHAR;
memcpy(buffer + dataCursor, &values[i], sizeof(char));
dataCursor += sizeof(char);
}
return true;
}
bool HseSP::addGenericUTF16Char(wchar_t value)
{
return addGenericUTF16Char(&value, 1);
}
bool HseSP::addGenericUTF16Char(wchar_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_U_T_F16_CHAR, HSESP_GENERIC_U_T_F16_CHAR_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_U_T_F16_CHAR;
memcpy(buffer + dataCursor, &values[i], sizeof(wchar_t));
dataCursor += sizeof(wchar_t);
}
return true;
}
bool HseSP::addGenericBoolean(bool value)
{
return addGenericBoolean(&value, 1);
}
bool HseSP::addGenericBoolean(bool *values, uint8_t len)
{
if (!addDataHeader(HSESP_GENERIC_BOOLEAN, HSESP_GENERIC_BOOLEAN_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GENERIC_BOOLEAN;
memcpy(buffer + dataCursor, &values[i], sizeof(bool));
dataCursor += sizeof(bool);
}
return true;
}
bool HseSP::addClimateSensor(ClimateSensor_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_ClimateSensor, HSESP_ClimateSensor_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_ClimateSensor;
{
int16_t val = values->Temperature * 100;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
uint8_t val = values->Humidity * 2;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
uint16_t val = values->Pressure * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
memcpy(buffer + dataCursor, &values->Illuminance, sizeof(values->Illuminance));
dataCursor += sizeof(values->Illuminance);
}
}
return true;
}
bool HseSP::addGPSSensor(GPSSensor_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_GPSSensor, HSESP_GPSSensor_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_GPSSensor;
{
float val = values->Latitude * 1;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
float val = values->Longitude * 1;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
uint8_t val = values->SignalStrength * -1;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
}
return true;
}
bool HseSP::addPositionSensor(PositionSensor_t *values, uint8_t len)
{
if (!addDataHeader(HSESP_PositionSensor, HSESP_PositionSensor_SIZE, len))
return false;
for (uint8_t i = 0; i < len; i++) {
if (__HSESP_VERSION == 1 && i > 0)
buffer[dataCursor++] = HSESP_PositionSensor;
{
int16_t val = values->GSensorX * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
int16_t val = values->GSensorY * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
int16_t val = values->GSensorZ * 10;
memcpy(buffer + dataCursor, &val, sizeof(val));
dataCursor += sizeof(val);
}
{
memcpy(buffer + dataCursor, &values->Totalofshocks, sizeof(values->Totalofshocks));
dataCursor += sizeof(values->Totalofshocks);
}
{
memcpy(buffer + dataCursor, &values->Maxshocks, sizeof(values->Maxshocks));
dataCursor += sizeof(values->Maxshocks);
}
}
return true;
}

209
lib/hseSensorProtocol/hseSensorProtocol.h
Unescape View File

@ -0,0 +1,209 @@ @@ -0,0 +1,209 @@
/*
THIS IS GENERATED CODE
DO NOT EDIT
Developer: Max Reble
Copyright Notice: hse-electronics GmbH, Max Reble (2020)
License: MIT License (see LICENSE.txt)
*/
#include <stdint.h>
#ifndef _HSE_SENSOR_PROTOCOL_H_
#define _HSE_SENSOR_PROTOCOL_H_
#define HSESP_DIGITAL_INPUT 0x01 //uint8_t
#define HSESP_DIGITAL_INPUT_SIZE sizeof(uint8_t)
#define HSESP_DIGITAL_OUTPUT 0x02 //uint8_t
#define HSESP_DIGITAL_OUTPUT_SIZE sizeof(uint8_t)
#define HSESP_ANALOG_INPUT 0x03 //int16_t
#define HSESP_ANALOG_INPUT_SIZE sizeof(int16_t)
#define HSESP_ANALOG_OUTPUT 0x04 //int16_t
#define HSESP_ANALOG_OUTPUT_SIZE sizeof(int16_t)
#define HSESP_TEMPERATURE 0x10 //int16_t
#define HSESP_TEMPERATURE_SIZE sizeof(int16_t)
#define HSESP_HUMIDITY 0x11 //uint8_t
#define HSESP_HUMIDITY_SIZE sizeof(uint8_t)
#define HSESP_PRESSURE 0x12 //uint16_t
#define HSESP_PRESSURE_SIZE sizeof(uint16_t)
#define HSESP_ILLUMINANCE 0x13 //uint16_t
#define HSESP_ILLUMINANCE_SIZE sizeof(uint16_t)
#define HSESP_CONCENTRATION 0x14 //uint16_t
#define HSESP_CONCENTRATION_SIZE sizeof(uint16_t)
#define HSESP_DIRECTION 0x15 //int16_t
#define HSESP_DIRECTION_SIZE sizeof(int16_t)
#define HSESP_RSSI 0x16 //uint8_t
#define HSESP_RSSI_SIZE sizeof(uint8_t)
#define HSESP_LOUDNESS 0x17 //uint8_t
#define HSESP_LOUDNESS_SIZE sizeof(uint8_t)
#define HSESP_DISTANCE 0x18 //uint16_t
#define HSESP_DISTANCE_SIZE sizeof(uint16_t)
#define HSESP_COUNTER 0x19 //int16_t
#define HSESP_COUNTER_SIZE sizeof(int16_t)
#define HSESP_VOLTAGE 0x1A //int16_t
#define HSESP_VOLTAGE_SIZE sizeof(int16_t)
#define HSESP_CONDUCTIVITY 0x1B //uint16_t
#define HSESP_CONDUCTIVITY_SIZE sizeof(uint16_t)
#define HSESP_LEVEL 0x1C //uint8_t
#define HSESP_LEVEL_SIZE sizeof(uint8_t)
#define HSESP_PRECIPITATION 0x1D //uint16_t
#define HSESP_PRECIPITATION_SIZE sizeof(uint16_t)
#define HSESP_LOCATION 0x1E //float
#define HSESP_LOCATION_SIZE sizeof(float)
#define HSESP_GENERIC_UINT8 0x70 //uint8_t
#define HSESP_GENERIC_UINT8_SIZE sizeof(uint8_t)
#define HSESP_GENERIC_UINT16 0x71 //uint16_t
#define HSESP_GENERIC_UINT16_SIZE sizeof(uint16_t)
#define HSESP_GENERIC_INT16 0x72 //int16_t
#define HSESP_GENERIC_INT16_SIZE sizeof(int16_t)
#define HSESP_GENERIC_UINT32 0x73 //uint32_t
#define HSESP_GENERIC_UINT32_SIZE sizeof(uint32_t)
#define HSESP_GENERIC_INT32 0x74 //int32_t
#define HSESP_GENERIC_INT32_SIZE sizeof(int32_t)
#define HSESP_GENERIC_FLOAT 0x75 //float
#define HSESP_GENERIC_FLOAT_SIZE sizeof(float)
#define HSESP_GENERIC_A_N_S_I_CHAR 0x76 //char
#define HSESP_GENERIC_A_N_S_I_CHAR_SIZE sizeof(char)
#define HSESP_GENERIC_U_T_F16_CHAR 0x77 //wchar_t
#define HSESP_GENERIC_U_T_F16_CHAR_SIZE sizeof(wchar_t)
#define HSESP_GENERIC_BOOLEAN 0x78 //bool
#define HSESP_GENERIC_BOOLEAN_SIZE sizeof(bool)
#define HSESP_ClimateSensor 0x80
#define HSESP_ClimateSensor_SIZE 7
#define HSESP_GPSSensor 0x81
#define HSESP_GPSSensor_SIZE 9
#define HSESP_PositionSensor 0x82
#define HSESP_PositionSensor_SIZE 10
class HseSP{
public:
HseSP(uint8_t version, uint8_t size);
~HseSP();
uint8_t getSize(void);
uint8_t *getBuffer(void);
void reset();
bool addDigitalInput(uint8_t value);
bool addDigitalInput(uint8_t *values, uint8_t len);
bool addDigitalOutput(uint8_t value);
bool addDigitalOutput(uint8_t *values, uint8_t len);
bool addAnalogInput(float value);
bool addAnalogInput(float *values, uint8_t len);
bool addAnalogOutput(float value);
bool addAnalogOutput(float *values, uint8_t len);
bool addTemperature(float value);
bool addTemperature(float *values, uint8_t len);
bool addHumidity(float value);
bool addHumidity(float *values, uint8_t len);
bool addPressure(float value);
bool addPressure(float *values, uint8_t len);
bool addIlluminance(uint16_t value);
bool addIlluminance(uint16_t *values, uint8_t len);
bool addConcentration(float value);
bool addConcentration(float *values, uint8_t len);
bool addDirection(float value);
bool addDirection(float *values, uint8_t len);
bool addRSSI(int16_t value);
bool addRSSI(int16_t *values, uint8_t len);
bool addLoudness(uint8_t value);
bool addLoudness(uint8_t *values, uint8_t len);
bool addDistance(float value);
bool addDistance(float *values, uint8_t len);
bool addCounter(int16_t value);
bool addCounter(int16_t *values, uint8_t len);
bool addVoltage(float value);
bool addVoltage(float *values, uint8_t len);
bool addConductivity(uint16_t value);
bool addConductivity(uint16_t *values, uint8_t len);
bool addLevel(uint8_t value);
bool addLevel(uint8_t *values, uint8_t len);
bool addPrecipitation(float value);
bool addPrecipitation(float *values, uint8_t len);
bool addLocation(float value);
bool addLocation(float *values, uint8_t len);
bool addGenericUInt8(uint8_t value);
bool addGenericUInt8(uint8_t *values, uint8_t len);
bool addGenericUInt16(uint16_t value);
bool addGenericUInt16(uint16_t *values, uint8_t len);
bool addGenericInt16(int16_t value);
bool addGenericInt16(int16_t *values, uint8_t len);
bool addGenericUInt32(uint32_t value);
bool addGenericUInt32(uint32_t *values, uint8_t len);
bool addGenericInt32(int32_t value);
bool addGenericInt32(int32_t *values, uint8_t len);
bool addGenericFloat(float value);
bool addGenericFloat(float *values, uint8_t len);
bool addGenericANSIChar(char value);
bool addGenericANSIChar(char *values, uint8_t len);
bool addGenericUTF16Char(wchar_t value);
bool addGenericUTF16Char(wchar_t *values, uint8_t len);
bool addGenericBoolean(bool value);
bool addGenericBoolean(bool *values, uint8_t len);
//ClimateSensor
typedef struct {
float Temperature;
float Humidity;
float Pressure;
uint16_t Illuminance;
} ClimateSensor_t;
bool addClimateSensor(ClimateSensor_t *values, uint8_t len = 1);
//GPSSensor
typedef struct {
float Latitude;
float Longitude;
int16_t SignalStrength;
} GPSSensor_t;
bool addGPSSensor(GPSSensor_t *values, uint8_t len = 1);
//PositionSensor
typedef struct {
float GSensorX;
float GSensorY;
float GSensorZ;
uint16_t Totalofshocks;
uint16_t Maxshocks;
} PositionSensor_t;
bool addPositionSensor(PositionSensor_t *values, uint8_t len = 1);
private:
uint8_t *buffer;
uint8_t maxsize;
uint8_t dataCursor;
void generateCRC(void);
bool addDataHeader(uint8_t type, uint8_t dataSize, uint8_t dataLen);
};
#endif

29
src/main.cpp
Unescape View File

@ -32,9 +32,13 @@ @@ -32,9 +32,13 @@
*
*******************************************************************************/
#include <lmic.h>
#include <hal/hal.h>
#include <SPI.h>
#include "hseSensorProtocol.h"
//
// For normal use, we require that you edit the sketch to replace FILLMEIN
@ -70,6 +74,10 @@ static const u1_t PROGMEM APPKEY[16] = {0xca, 0x96, 0x9a, 0x15, 0x76, 0x5d, 0xaf @@ -70,6 +74,10 @@ static const u1_t PROGMEM APPKEY[16] = {0xca, 0x96, 0x9a, 0x15, 0x76, 0x5d, 0xaf
void os_getDevKey(u1_t *buf) { memcpy_P(buf, APPKEY, 16); }
// hse-Protokoll Datensatz
HseSP hse(2, 60);
static uint8_t mydata[] = "Hello, world!";
static osjob_t sendjob;
@ -136,13 +144,30 @@ void printHex2(unsigned v) { @@ -136,13 +144,30 @@ void printHex2(unsigned v) {
Serial.print(v, HEX);
}
void Messen()
{
hse.reset();
HseSP::ClimateSensor_t cs;
cs.Temperature = 22.2; //°C
cs.Humidity = 55.5; //%
cs.Pressure = 1000.1; //hPa
cs.Illuminance = 123;
hse.addClimateSensor(&cs);
}
void do_send(osjob_t *j) {
// Check if there is not a current TX/RX job running
if (LMIC.opmode & OP_TXRXPEND) {
Serial.println(F("OP_TXRXPEND, not sending"));
} else {
// Prepare upstream data transmission at the next possible time.
LMIC_setTxData2(1, mydata, sizeof(mydata) - 1, 0);
Messen();
uint8_t* buffer = hse.getBuffer();
int size = hse.getSize();
LMIC_setTxData2(1, buffer, size, 0);
Serial.println(F("Packet queued"));
}
// Next TX is scheduled after TX_COMPLETE event.
@ -303,3 +328,5 @@ void setup() { @@ -303,3 +328,5 @@ void setup() {
void loop() {
os_runloop_once();
}

Write Preview
Loading…
Cancel
Save