228 lines
7.4 KiB
C++
228 lines
7.4 KiB
C++
/* VeDirectFrame
|
|
HexHandler.cpp
|
|
*
|
|
* Library to read/write from Victron devices using VE.Direct Hex protocol.
|
|
* Add on to Victron framehandler reference implementation.
|
|
*
|
|
* How to use:
|
|
* 1. Use sendHexCommand() to send hex messages. Use the Victron documentation to find the parameter.
|
|
* 2. The from class "VeDirectFrameHandler" derived class X must overwrite the function
|
|
* void VeDirectFrameHandler::hexDataHandler(VeDirectHexData const &data)
|
|
* to handle the received hex messages. All hex messages will be forwarted to function hexDataHandler()
|
|
* 3. Analyse the content of data (struct VeDirectHexData) to check if a message fits.
|
|
*
|
|
* 2024.03.08 - 0.4 - adds the ability to send hex commands and to parse hex messages
|
|
*
|
|
*/
|
|
#include <Arduino.h>
|
|
#include "VeDirectFrameHandler.h"
|
|
|
|
|
|
// support for debugging, 0=without extended logging, 1=with extended logging
|
|
constexpr int MODUL_DEBUG = 0;
|
|
|
|
|
|
/*
|
|
* calcHexFrameCheckSum()
|
|
* help function to calculate the hex checksum
|
|
*/
|
|
#define ascii2hex(v) (v-48-(v>='A'?7:0))
|
|
#define hex2byte(b) (ascii2hex(*(b)))*16+((ascii2hex(*(b+1))))
|
|
static uint8_t calcHexFrameCheckSum(const char* buffer, int size) {
|
|
uint8_t checksum=0x55-ascii2hex(buffer[1]);
|
|
for (int i=2; i<size; i+=2)
|
|
checksum -= hex2byte(buffer+i);
|
|
return (checksum);
|
|
}
|
|
|
|
|
|
/*
|
|
* AsciiHexLE2Int()
|
|
* help function to convert AsciiHex Little Endian to uint32_t
|
|
* ascii: pointer to Ascii Hex Little Endian data
|
|
* anz: 1,2,4 or 8 nibble
|
|
*/
|
|
static uint32_t AsciiHexLE2Int(const char *ascii, const uint8_t anz) {
|
|
char help[9] = {};
|
|
|
|
// sort from little endian format to normal format
|
|
switch (anz) {
|
|
case 1:
|
|
help[0] = ascii[0];
|
|
break;
|
|
case 2:
|
|
case 4:
|
|
case 8:
|
|
for (uint8_t i = 0; i < anz; i += 2) {
|
|
help[i] = ascii[anz-i-2];
|
|
help[i+1] = ascii[anz-i-1];
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return (static_cast<uint32_t>(strtoul(help, nullptr, 16)));
|
|
}
|
|
|
|
|
|
/*
|
|
* disassembleHexData()
|
|
* analysis the hex message and extract: response, id, flag and value/text
|
|
* buffer: pointer to message (ascii hex little endian format)
|
|
* data: disassembeled message
|
|
* return: true = successful disassembeld, false = hex sum fault or message
|
|
* do not aligin with VE.Diekt syntax
|
|
*/
|
|
template<typename T>
|
|
bool VeDirectFrameHandler<T>::disassembleHexData(VeDirectHexData &data) {
|
|
bool state = false;
|
|
char * buffer = _hexBuffer;
|
|
auto len = strlen(buffer);
|
|
|
|
// reset hex data first
|
|
data = {};
|
|
|
|
if ((len > 3) && (calcHexFrameCheckSum(buffer, len) == 0x00)) {
|
|
data.rsp = static_cast<VeDirectHexResponse>(AsciiHexLE2Int(buffer+1, 1));
|
|
|
|
switch (data.rsp) {
|
|
case R_DONE:
|
|
case R_ERROR:
|
|
case R_PING:
|
|
case R_UNKNOWN:
|
|
strncpy(data.text, buffer+2, len-4);
|
|
state = true;
|
|
break;
|
|
case R_GET:
|
|
case R_SET:
|
|
case R_ASYNC:
|
|
data.id = AsciiHexLE2Int(buffer+2, 4);
|
|
|
|
// future option: to analyse the flag here?
|
|
data.flag = AsciiHexLE2Int(buffer+6, 2);
|
|
|
|
if (len == 12) { // 8bit value
|
|
data.value = AsciiHexLE2Int(buffer+8, 2);
|
|
state = true;
|
|
}
|
|
|
|
if (len == 14) { // 16bit value
|
|
data.value = AsciiHexLE2Int(buffer+8, 4);
|
|
state = true;
|
|
}
|
|
|
|
if (len == 18) { // 32bit value
|
|
data.value = AsciiHexLE2Int(buffer+8, 8);
|
|
state = true;
|
|
}
|
|
break;
|
|
default:
|
|
break; // something went wrong
|
|
}
|
|
}
|
|
|
|
if constexpr(MODUL_DEBUG == 1) {
|
|
_msgOut->printf("[VE.Direct] debug: disassembleHexData(), rsp: %i, id: 0x%04X, value: 0x%X, Flag: 0x%02X\r\n",
|
|
data.rsp, data.id, data.value, data.flag);
|
|
}
|
|
|
|
if (_verboseLogging && !state)
|
|
_msgOut->printf("[VE.Direct] failed to disassemble the hex message: %s\r\n", buffer);
|
|
|
|
return (state);
|
|
}
|
|
|
|
|
|
/*
|
|
* uint2toHexLEString()
|
|
* help function to convert up to 32 bits into little endian hex String
|
|
* ascii: pointer to Ascii Hex Little Endian data
|
|
* anz: 1,2,4 or 8 nibble
|
|
*/
|
|
static String Int2HexLEString(uint32_t value, uint8_t anz) {
|
|
char hexchar[] = "0123456789ABCDEF";
|
|
char help[9] = {};
|
|
|
|
switch (anz) {
|
|
case 1:
|
|
help[0] = hexchar[(value & 0x0000000F)];
|
|
break;
|
|
case 2:
|
|
case 4:
|
|
case 8:
|
|
for (uint8_t i = 0; i < anz; i += 2) {
|
|
help[i] = hexchar[(value>>((1+1*i)*4)) & 0x0000000F];
|
|
help[i+1] = hexchar[(value>>((1*i)*4)) & 0x0000000F];
|
|
}
|
|
default:
|
|
;
|
|
}
|
|
return String(help);
|
|
}
|
|
|
|
|
|
/*
|
|
* sendHexCommand()
|
|
* send the hex commend after assembling the command string
|
|
* cmd: command
|
|
* id: id/register, default 0
|
|
* value: value to write into a id/register, default 0
|
|
* valsize: size of the value/id, 8, 16 or 32 bit, default 0
|
|
* return: true = message assembeld and send, false = it was not possible to put the message together
|
|
* SAMPLE: ping command: sendHexCommand(PING),
|
|
* read total DC input power sendHexCommand(GET, 0xEDEC)
|
|
* set Charge current limit 10A sendHexCommand(SET, 0x2015, 64, 16)
|
|
*
|
|
* WARNING: some values are stored in non-volatile memory. Continuous writing, for example from a control loop, will
|
|
* lead to early failure.
|
|
* On MPPT for example 0xEDE0 - 0xEDFF. Check the Vivtron doc "BlueSolar-HEX-protocol.pdf"
|
|
*/
|
|
template<typename T>
|
|
bool VeDirectFrameHandler<T>::sendHexCommand(VeDirectHexCommand cmd, uint16_t id, uint32_t value, uint8_t valsize) {
|
|
bool ret = false;
|
|
uint8_t flag = 0x00; // always 0x00
|
|
|
|
String txData = ":" + Int2HexLEString(cmd, 1); // add the command nibble
|
|
|
|
switch (cmd) {
|
|
case PING:
|
|
case APP_VERSION:
|
|
case PRODUCT_ID:
|
|
ret = true;
|
|
break;
|
|
case GET:
|
|
case ASYNC:
|
|
txData += Int2HexLEString(id, 4); // add the id/register (4 nibble)
|
|
txData += Int2HexLEString(flag, 2); // add the flag (2 nibble)
|
|
ret = true;
|
|
break;
|
|
case SET:
|
|
txData += Int2HexLEString(id, 4); // add the id/register (4 nibble)
|
|
txData += Int2HexLEString(flag, 2); // add the flag (2 nibble)
|
|
if ((valsize == 8) || (valsize == 16) || (valsize == 32)) {
|
|
txData += Int2HexLEString(value, valsize/4); // add value (2-8 nibble)
|
|
ret = true;
|
|
}
|
|
break;
|
|
default:
|
|
ret = false;
|
|
break;
|
|
}
|
|
|
|
if (ret) {
|
|
// add the checksum (2 nibble)
|
|
txData += Int2HexLEString(calcHexFrameCheckSum(txData.c_str(), txData.length()), 2);
|
|
String send = txData + "\n"; // hex command end byte
|
|
_vedirectSerial->write(send.c_str(), send.length());
|
|
|
|
if constexpr(MODUL_DEBUG == 1) {
|
|
auto blen = _vedirectSerial->availableForWrite();
|
|
_msgOut->printf("[VE.Direct] debug: sendHexCommand(): %s, Free FIFO-Buffer: %u\r\n", txData.c_str(), blen);
|
|
}
|
|
}
|
|
|
|
if (_verboseLogging && !ret)
|
|
_msgOut->println("[VE.Direct] send hex command fault:" + txData);
|
|
|
|
return (ret);
|
|
}
|