mirror of https://github.com/lumapu/ahoy.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
487 lines
22 KiB
487 lines
22 KiB
//-----------------------------------------------------------------------------
|
|
// 2023 Ahoy, https://ahoydtu.de
|
|
// Creative Commons - https://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef __HM_PAYLOAD_H__
|
|
#define __HM_PAYLOAD_H__
|
|
|
|
#include "../utils/dbg.h"
|
|
#include "../utils/crc.h"
|
|
#include "../config/config.h"
|
|
#include "hmRadio.h"
|
|
#if defined(ESP32)
|
|
#include "../hms/cmt2300a.h"
|
|
#endif
|
|
#include <Arduino.h>
|
|
|
|
#define HMS_TIMEOUT_SEC 30
|
|
|
|
typedef struct {
|
|
uint8_t txCmd;
|
|
uint8_t txId;
|
|
uint32_t ts;
|
|
uint8_t data[MAX_PAYLOAD_ENTRIES][MAX_RF_PAYLOAD_SIZE];
|
|
int8_t rssi[MAX_PAYLOAD_ENTRIES];
|
|
uint8_t len[MAX_PAYLOAD_ENTRIES];
|
|
bool complete;
|
|
uint8_t maxPackId;
|
|
bool lastFound;
|
|
uint8_t retransmits;
|
|
bool requested;
|
|
bool gotFragment;
|
|
bool rxTmo;
|
|
} invPayload_t;
|
|
|
|
|
|
typedef std::function<void(uint8_t, Inverter<> *)> payloadListenerType;
|
|
typedef std::function<void(Inverter<> *)> alarmListenerType;
|
|
|
|
|
|
template<class HMSYSTEM>
|
|
class HmPayload {
|
|
public:
|
|
HmPayload() {}
|
|
|
|
void setup(IApp *app, HMSYSTEM *sys, uint8_t maxRetransmits, uint32_t *timestamp) {
|
|
mApp = app;
|
|
mSys = sys;
|
|
mMaxRetrans = maxRetransmits;
|
|
mTimestamp = timestamp;
|
|
for(uint8_t i = 0; i < MAX_NUM_INVERTERS; i++) {
|
|
reset(i);
|
|
mIvCmd56Cnt[i] = 0;
|
|
}
|
|
mSerialDebug = false;
|
|
mHighPrioIv = NULL;
|
|
mCbAlarm = NULL;
|
|
mCbPayload = NULL;
|
|
}
|
|
|
|
void enableSerialDebug(bool enable) {
|
|
mSerialDebug = enable;
|
|
}
|
|
|
|
void addPayloadListener(payloadListenerType cb) {
|
|
mCbPayload = cb;
|
|
}
|
|
|
|
void addAlarmListener(alarmListenerType cb) {
|
|
mCbAlarm = cb;
|
|
}
|
|
|
|
void loop() {
|
|
if (NULL != mHighPrioIv) {
|
|
ivSend(mHighPrioIv, true); // for e.g. devcontrol commands
|
|
mHighPrioIv = NULL;
|
|
}
|
|
}
|
|
|
|
/*void simulation() {
|
|
uint8_t pay[] = {
|
|
0x00, 0x01, 0x01, 0x24, 0x02, 0x28, 0x02, 0x33,
|
|
0x06, 0x49, 0x06, 0x6a, 0x00, 0x05, 0x5f, 0x1b,
|
|
0x00, 0x06, 0x66, 0x9a, 0x03, 0xfd, 0x04, 0x0b,
|
|
0x01, 0x23, 0x02, 0x28, 0x02, 0x28, 0x06, 0x41,
|
|
0x06, 0x43, 0x00, 0x05, 0xdc, 0x2c, 0x00, 0x06,
|
|
0x2e, 0x3f, 0x04, 0x01, 0x03, 0xfb, 0x09, 0x78,
|
|
0x13, 0x86, 0x18, 0x15, 0x00, 0xcf, 0x00, 0xfe,
|
|
0x03, 0xe7, 0x01, 0x42, 0x00, 0x03
|
|
};
|
|
|
|
Inverter<> *iv = mSys->getInverterByPos(0);
|
|
record_t<> *rec = iv->getRecordStruct(0x0b);
|
|
rec->ts = *mTimestamp;
|
|
for (uint8_t i = 0; i < rec->length; i++) {
|
|
iv->addValue(i, pay, rec);
|
|
yield();
|
|
}
|
|
iv->doCalculations();
|
|
notify(0x0b, iv);
|
|
}*/
|
|
|
|
void ivSendHighPrio(Inverter<> *iv) {
|
|
mHighPrioIv = iv;
|
|
}
|
|
|
|
void ivSend(Inverter<> *iv, bool highPrio = false) {
|
|
if(!highPrio) {
|
|
if (mPayload[iv->id].requested) {
|
|
if (!mPayload[iv->id].complete)
|
|
process(false); // no retransmit
|
|
|
|
if (!mPayload[iv->id].complete) {
|
|
if (mSerialDebug)
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
if (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId) {
|
|
iv->radioStatistics.rxFailNoAnser++; // got nothing
|
|
if (mSerialDebug)
|
|
DBGPRINTLN(F("enqueued cmd failed/timeout"));
|
|
} else {
|
|
iv->radioStatistics.rxFail++; // got fragments but not complete response
|
|
if (mSerialDebug) {
|
|
DBGPRINT(F("no complete Payload received! (retransmits: "));
|
|
DBGPRINT(String(mPayload[iv->id].retransmits));
|
|
DBGPRINTLN(F(")"));
|
|
}
|
|
}
|
|
iv->setQueuedCmdFinished(); // command failed
|
|
}
|
|
}
|
|
}
|
|
|
|
reset(iv->id, !iv->isAvailable());
|
|
mPayload[iv->id].requested = true;
|
|
|
|
yield();
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("Requesting Inv SN "));
|
|
DBGPRINTLN(String(iv->config->serial.u64, HEX));
|
|
}
|
|
|
|
if (iv->getDevControlRequest()) {
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("Devcontrol request 0x"));
|
|
DHEX(iv->devControlCmd);
|
|
DBGPRINT(F(" power limit "));
|
|
DBGPRINTLN(String(iv->powerLimit[0]));
|
|
}
|
|
iv->powerLimitAck = false;
|
|
iv->radio->sendControlPacket(iv, iv->devControlCmd, iv->powerLimit, false);
|
|
mPayload[iv->id].txCmd = iv->devControlCmd;
|
|
//iv->clearCmdQueue();
|
|
//iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit
|
|
} else {
|
|
#if defined(ESP32)
|
|
if((IV_HMS == iv->ivGen) || (IV_HMT == iv->ivGen)) {
|
|
record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug);
|
|
if(((rec->ts + HMS_TIMEOUT_SEC) < *mTimestamp) && (mIvCmd56Cnt[iv->id] < 3)) {
|
|
iv->radio->switchFrequency(iv, HOY_BOOT_FREQ_KHZ, WORK_FREQ_KHZ);
|
|
mIvCmd56Cnt[iv->id]++;
|
|
return;
|
|
} else if(++mIvCmd56Cnt[iv->id] == 10)
|
|
mIvCmd56Cnt[iv->id] = 0;
|
|
}
|
|
#endif
|
|
uint8_t cmd = iv->getQueuedCmd();
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("prepareDevInformCmd 0x"));
|
|
DBGHEXLN(cmd);
|
|
}
|
|
iv->radio->prepareDevInformCmd(iv, cmd, mPayload[iv->id].ts, iv->alarmLastId, false);
|
|
mPayload[iv->id].txCmd = cmd;
|
|
}
|
|
}
|
|
|
|
void add(Inverter<> *iv, packet_t *p) {
|
|
if (p->packet[0] == (TX_REQ_INFO + ALL_FRAMES)) { // response from get information command
|
|
mPayload[iv->id].txId = p->packet[0];
|
|
DPRINTLN(DBG_DEBUG, F("Response from info request received"));
|
|
uint8_t *pid = &p->packet[9];
|
|
if (*pid == 0x00) {
|
|
DPRINTLN(DBG_DEBUG, F("fragment number zero received and ignored"));
|
|
} else {
|
|
DPRINT(DBG_DEBUG, F("PID: 0x"));
|
|
DPRINTLN(DBG_DEBUG, String(*pid, HEX));
|
|
if ((*pid & 0x7F) < MAX_PAYLOAD_ENTRIES) {
|
|
memcpy(mPayload[iv->id].data[(*pid & 0x7F) - 1], &p->packet[10], p->len - 11);
|
|
mPayload[iv->id].len[(*pid & 0x7F) - 1] = p->len - 11;
|
|
mPayload[iv->id].gotFragment = true;
|
|
mPayload[iv->id].rssi[(*pid & 0x7F) - 1] = p->rssi;
|
|
}
|
|
|
|
if ((*pid & ALL_FRAMES) == ALL_FRAMES) {
|
|
// Last packet
|
|
if (((*pid & 0x7f) > mPayload[iv->id].maxPackId) || (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId)) {
|
|
mPayload[iv->id].maxPackId = (*pid & 0x7f);
|
|
if (*pid > 0x81)
|
|
mPayload[iv->id].lastFound = true;
|
|
}
|
|
}
|
|
}
|
|
} else if (p->packet[0] == (TX_REQ_DEVCONTROL + ALL_FRAMES)) { // response from dev control command
|
|
DPRINTLN(DBG_DEBUG, F("Response from devcontrol request received"));
|
|
|
|
mPayload[iv->id].txId = p->packet[0];
|
|
iv->clearDevControlRequest();
|
|
|
|
if ((p->packet[12] == ActivePowerContr) && (p->packet[13] == 0x00)) {
|
|
bool ok = true;
|
|
if((p->packet[10] == 0x00) && (p->packet[11] == 0x00)) {
|
|
mApp->setMqttPowerLimitAck(iv);
|
|
iv->powerLimitAck = true;
|
|
} else
|
|
ok = false;
|
|
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F(" has "));
|
|
if(!ok) DBGPRINT(F("not "));
|
|
DBGPRINT(F("accepted power limit set point "));
|
|
DBGPRINT(String(iv->powerLimit[0]));
|
|
DBGPRINT(F(" with PowerLimitControl "));
|
|
DBGPRINTLN(String(iv->powerLimit[1]));
|
|
}
|
|
|
|
iv->clearCmdQueue();
|
|
iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit
|
|
if(mHighPrioIv == NULL) // do it immediately if possible
|
|
mHighPrioIv = iv;
|
|
}
|
|
iv->devControlCmd = Init;
|
|
}
|
|
}
|
|
|
|
void process(bool retransmit) {
|
|
for (uint8_t id = 0; id < mSys->getNumInverters(); id++) {
|
|
Inverter<> *iv = mSys->getInverterByPos(id);
|
|
if (NULL == iv)
|
|
continue; // skip to next inverter
|
|
|
|
if ((mPayload[iv->id].txId != (TX_REQ_INFO + ALL_FRAMES)) && (0 != mPayload[iv->id].txId)) {
|
|
// no processing needed if txId is not 0x95
|
|
mPayload[iv->id].complete = true;
|
|
continue; // skip to next inverter
|
|
}
|
|
|
|
if (!mPayload[iv->id].complete) {
|
|
bool crcPass, pyldComplete, fastNext;
|
|
|
|
crcPass = build(iv, &pyldComplete, &fastNext);
|
|
if (!crcPass && !pyldComplete) { // payload not complete
|
|
if ((mPayload[iv->id].requested) && (retransmit)) {
|
|
if (mPayload[iv->id].retransmits < mMaxRetrans) {
|
|
mPayload[iv->id].retransmits++;
|
|
if (iv->devControlCmd == Restart || iv->devControlCmd == CleanState_LockAndAlarm) {
|
|
// This is required to prevent retransmissions without answer.
|
|
DPRINTLN(DBG_INFO, F("Prevent retransmit on Restart / CleanState_LockAndAlarm..."));
|
|
mPayload[iv->id].retransmits = mMaxRetrans;
|
|
} else if(iv->devControlCmd == ActivePowerContr) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DPRINTLN(DBG_INFO, F("retransmit power limit"));
|
|
iv->radio->sendControlPacket(iv, iv->devControlCmd, iv->powerLimit, true);
|
|
} else {
|
|
if(false == mPayload[iv->id].gotFragment) {
|
|
DPRINT_IVID(DBG_WARN, iv->id);
|
|
if (mPayload[iv->id].rxTmo) {
|
|
DBGPRINTLN(F("nothing received"));
|
|
mPayload[iv->id].retransmits = mMaxRetrans;
|
|
} else {
|
|
DBGPRINTLN(F("nothing received: complete retransmit"));
|
|
mPayload[iv->id].txCmd = iv->getQueuedCmd();
|
|
DPRINTLN(DBG_INFO, F("(#") + String(iv->id) + F(") prepareDevInformCmd 0x") + String(mPayload[iv->id].txCmd, HEX));
|
|
iv->radio->prepareDevInformCmd(iv, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true);
|
|
}
|
|
} else {
|
|
for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId - 1); i++) {
|
|
if (mPayload[iv->id].len[i] == 0) {
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_WARN, iv->id);
|
|
DBGPRINT(F("Frame "));
|
|
DBGPRINT(String(i + 1));
|
|
DBGPRINTLN(F(" missing: Request Retransmit"));
|
|
}
|
|
iv->radio->sendCmdPacket(iv, TX_REQ_INFO, (SINGLE_FRAME + i), true);
|
|
break; // only request retransmit one frame per loop
|
|
}
|
|
yield();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (false == mPayload[iv->id].gotFragment) {
|
|
// only if there is no sign of life
|
|
mPayload[iv->id].rxTmo = true; // inv might be down, no complete retransmit anymore
|
|
}
|
|
} else if(!crcPass && pyldComplete) { // crc error on complete Payload
|
|
if (mPayload[iv->id].retransmits < mMaxRetrans) {
|
|
mPayload[iv->id].retransmits++;
|
|
mPayload[iv->id].txCmd = iv->getQueuedCmd();
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_WARN, iv->id);
|
|
DBGPRINTLN(F("CRC Error: Request Complete Retransmit"));
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("prepareDevInformCmd 0x"));
|
|
DBGHEXLN(mPayload[iv->id].txCmd);
|
|
}
|
|
iv->radio->prepareDevInformCmd(iv, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmLastId, true);
|
|
}
|
|
} else { // payload complete
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("procPyld: cmd: 0x"));
|
|
DBGHEXLN(mPayload[iv->id].txCmd);
|
|
//DPRINT(DBG_DEBUG, F("procPyld: txid: 0x"));
|
|
//DBGHEXLN(mPayload[iv->id].txId);
|
|
DPRINT(DBG_DEBUG, F("procPyld: max: "));
|
|
DPRINTLN(DBG_DEBUG, String(mPayload[iv->id].maxPackId));
|
|
}
|
|
record_t<> *rec = iv->getRecordStruct(mPayload[iv->id].txCmd); // choose the parser
|
|
mPayload[iv->id].complete = true;
|
|
mPayload[iv->id].requested = false;
|
|
mPayload[iv->id].rxTmo = false;
|
|
|
|
uint8_t payload[150];
|
|
uint8_t payloadLen = 0;
|
|
|
|
memset(payload, 0, 150);
|
|
|
|
int8_t rssi = -127;
|
|
|
|
for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId); i++) {
|
|
if((mPayload[iv->id].len[i] + payloadLen) > 150) {
|
|
DPRINTLN(DBG_ERROR, F("payload buffer to small!"));
|
|
break;
|
|
}
|
|
memcpy(&payload[payloadLen], mPayload[iv->id].data[i], (mPayload[iv->id].len[i]));
|
|
payloadLen += (mPayload[iv->id].len[i]);
|
|
// get worst RSSI
|
|
if(mPayload[iv->id].rssi[i] > rssi)
|
|
rssi = mPayload[iv->id].rssi[i];
|
|
yield();
|
|
}
|
|
payloadLen -= 2;
|
|
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("Payload ("));
|
|
DBGPRINT(String(payloadLen));
|
|
DBGPRINT(F("): "));
|
|
ah::dumpBuf(payload, payloadLen);
|
|
}
|
|
|
|
if (NULL == rec) {
|
|
DPRINTLN(DBG_ERROR, F("record is NULL!"));
|
|
} else if ((rec->pyldLen == payloadLen) || (0 == rec->pyldLen)) {
|
|
if (mPayload[iv->id].txId == (TX_REQ_INFO + ALL_FRAMES))
|
|
iv->radioStatistics.rxSuccess++;
|
|
|
|
rec->ts = mPayload[iv->id].ts;
|
|
for (uint8_t i = 0; i < rec->length; i++) {
|
|
iv->addValue(i, payload, rec);
|
|
yield();
|
|
}
|
|
iv->rssi = rssi;
|
|
iv->doCalculations();
|
|
notify(mPayload[iv->id].txCmd, iv);
|
|
|
|
if(AlarmData == mPayload[iv->id].txCmd) {
|
|
uint8_t i = 0;
|
|
while(1) {
|
|
if(0 == iv->parseAlarmLog(i++, payload, payloadLen))
|
|
break;
|
|
if (NULL != mCbAlarm)
|
|
(mCbAlarm)(iv);
|
|
yield();
|
|
}
|
|
}
|
|
if (fastNext && (mHighPrioIv == NULL)) {
|
|
/*iv->setQueuedCmdFinished();
|
|
uint8_t cmd = iv->getQueuedCmd();
|
|
if (mSerialDebug) {
|
|
DPRINT_IVID(DBG_INFO, iv->id);
|
|
DBGPRINT(F("fast mode "));
|
|
DBGPRINT(F("prepareDevInformCmd 0x"));
|
|
DBGHEXLN(cmd);
|
|
}
|
|
iv->radioStatistics.rxSuccess++;
|
|
iv->radio->prepareDevInformCmd(iv, cmd, mPayload[iv->id].ts, iv->alarmLastId, false);
|
|
mPayload[iv->id].txCmd = cmd;
|
|
*/
|
|
mHighPrioIv = iv;
|
|
}
|
|
|
|
} else {
|
|
if (mSerialDebug) {
|
|
DPRINT(DBG_ERROR, F("plausibility check failed, expected "));
|
|
DBGPRINT(String(rec->pyldLen));
|
|
DBGPRINTLN(F(" bytes"));
|
|
}
|
|
iv->radioStatistics.rxFail++;
|
|
}
|
|
|
|
iv->setQueuedCmdFinished();
|
|
}
|
|
}
|
|
yield();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void notify(uint8_t val, Inverter<> *iv) {
|
|
if(NULL != mCbPayload)
|
|
(mCbPayload)(val, iv);
|
|
}
|
|
|
|
bool build(Inverter<> *iv, bool *complete, bool *fastNext ) {
|
|
DPRINTLN(DBG_VERBOSE, F("build"));
|
|
uint16_t crc = 0xffff, crcRcv = 0x0000;
|
|
if (mPayload[iv->id].maxPackId > MAX_PAYLOAD_ENTRIES)
|
|
mPayload[iv->id].maxPackId = MAX_PAYLOAD_ENTRIES;
|
|
|
|
// check if all fragments are there
|
|
*complete = true;
|
|
*fastNext = false;
|
|
for (uint8_t i = 0; i < mPayload[iv->id].maxPackId; i++) {
|
|
if(mPayload[iv->id].len[i] == 0) {
|
|
*complete = false;
|
|
}
|
|
}
|
|
if(!*complete)
|
|
return false;
|
|
|
|
for (uint8_t i = 0; i < mPayload[iv->id].maxPackId; i++) {
|
|
if (mPayload[iv->id].len[i] > 0) {
|
|
if (i == (mPayload[iv->id].maxPackId - 1)) {
|
|
crc = ah::crc16(mPayload[iv->id].data[i], mPayload[iv->id].len[i] - 2, crc);
|
|
crcRcv = (mPayload[iv->id].data[i][mPayload[iv->id].len[i] - 2] << 8) | (mPayload[iv->id].data[i][mPayload[iv->id].len[i] - 1]);
|
|
} else
|
|
crc = ah::crc16(mPayload[iv->id].data[i], mPayload[iv->id].len[i], crc);
|
|
}
|
|
yield();
|
|
}
|
|
|
|
//return (crc == crcRcv) ? true : false;
|
|
if (crc != crcRcv)
|
|
return false;
|
|
|
|
//requests to cause the next request to be executed immediately
|
|
if (mPayload[iv->id].gotFragment && ((mPayload[iv->id].txCmd < RealTimeRunData_Debug) || (mPayload[iv->id].txCmd >= AlarmData))) {
|
|
*fastNext = true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void reset(uint8_t id, bool setTxTmo = true) {
|
|
//DPRINT_IVID(DBG_INFO, id);
|
|
//DBGPRINTLN(F("resetPayload"));
|
|
memset(mPayload[id].len, 0, MAX_PAYLOAD_ENTRIES);
|
|
mPayload[id].txCmd = 0;
|
|
mPayload[id].gotFragment = false;
|
|
mPayload[id].retransmits = 0;
|
|
mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES;
|
|
mPayload[id].lastFound = false;
|
|
mPayload[id].complete = false;
|
|
mPayload[id].requested = false;
|
|
mPayload[id].ts = *mTimestamp;
|
|
mPayload[id].rxTmo = setTxTmo; // design: don't start with complete retransmit
|
|
}
|
|
|
|
IApp *mApp;
|
|
HMSYSTEM *mSys;
|
|
uint8_t mMaxRetrans;
|
|
uint32_t *mTimestamp;
|
|
invPayload_t mPayload[MAX_NUM_INVERTERS];
|
|
uint8_t mIvCmd56Cnt[MAX_NUM_INVERTERS];
|
|
bool mSerialDebug;
|
|
Inverter<> *mHighPrioIv;
|
|
|
|
alarmListenerType mCbAlarm;
|
|
payloadListenerType mCbPayload;
|
|
};
|
|
|
|
#endif /*__HM_PAYLOAD_H__*/
|
|
|