From 1e6baeb463e37ebff445faa3882962e13efdfdc0 Mon Sep 17 00:00:00 2001 From: Ralf Behrens Date: Thu, 6 Jan 2022 16:06:20 +0100 Subject: [PATCH] =?UTF-8?q?add=20hseProtokoll=20hse2020=20lib=20hinzugef?= =?UTF-8?q?=C3=BCgt=20und=20mit=20konstanten=20Werte=20vorbelegt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/hseSensorProtocol/hseSensorProtocol.cpp | 608 ++++++++++++++++++++ lib/hseSensorProtocol/hseSensorProtocol.h | 209 +++++++ src/main.cpp | 31 +- 3 files changed, 846 insertions(+), 2 deletions(-) create mode 100644 lib/hseSensorProtocol/hseSensorProtocol.cpp create mode 100644 lib/hseSensorProtocol/hseSensorProtocol.h diff --git a/lib/hseSensorProtocol/hseSensorProtocol.cpp b/lib/hseSensorProtocol/hseSensorProtocol.cpp new file mode 100644 index 0000000..f8bcf45 --- /dev/null +++ b/lib/hseSensorProtocol/hseSensorProtocol.cpp @@ -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 //malloc +#include //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; +} diff --git a/lib/hseSensorProtocol/hseSensorProtocol.h b/lib/hseSensorProtocol/hseSensorProtocol.h new file mode 100644 index 0000000..fc02231 --- /dev/null +++ b/lib/hseSensorProtocol/hseSensorProtocol.h @@ -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 +#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 diff --git a/src/main.cpp b/src/main.cpp index f593e80..f45117a 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -32,9 +32,13 @@ * *******************************************************************************/ + + #include #include #include +#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 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) { 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. @@ -302,4 +327,6 @@ void setup() { void loop() { os_runloop_once(); -} \ No newline at end of file +} + +