topaLE
/
ahoy
mirror of https://github.com/lumapu/ahoy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add files via upload 

NRF24L01+ Radio send channel evaluation and hopping heuristik (helps to reduces TX retransmits in relation to TX count)
pull/1080/head
oberfritze 2 years ago
committed by GitHub
parent
12a9da55e3
commit
3d1a946bff
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 941 additions and 837 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 929
      src/hm/hmPayload.h
  2. 849
      src/hm/hmRadio.h

929
src/hm/hmPayload.h
View File

@ -1,458 +1,471 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// 2023 Ahoy, https://ahoydtu.de // 2023 Ahoy, https://ahoydtu.de
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/ // Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifndef __HM_PAYLOAD_H__ #ifndef __HM_PAYLOAD_H__
#define __HM_PAYLOAD_H__ #define __HM_PAYLOAD_H__
#include "../utils/dbg.h" #include "../utils/dbg.h"
#include "../utils/crc.h" #include "../utils/crc.h"
#include "../config/config.h" #include "../config/config.h"
#include <Arduino.h> #include <Arduino.h>
typedef struct { typedef struct {
uint8_t txCmd; uint8_t txCmd;
uint8_t txId; uint8_t txId;
uint8_t invId; uint8_t invId;
uint32_t ts; uint32_t ts;
uint8_t data[MAX_PAYLOAD_ENTRIES][MAX_RF_PAYLOAD_SIZE]; uint8_t data[MAX_PAYLOAD_ENTRIES][MAX_RF_PAYLOAD_SIZE];
uint8_t len[MAX_PAYLOAD_ENTRIES]; uint8_t len[MAX_PAYLOAD_ENTRIES];
bool complete; bool complete;
uint8_t maxPackId; uint8_t maxPackId;
bool lastFound; bool lastFound;
uint8_t retransmits; uint8_t retransmits;
bool requested; bool requested;
bool gotFragment; bool gotFragment;
bool rxTmo; bool rxTmo;
} invPayload_t; uint8_t lastFragments; // for send quality measurement
} invPayload_t;
typedef std::function<void(uint8_t)> payloadListenerType;
typedef std::function<void(uint16_t alarmCode, uint32_t start, uint32_t end)> alarmListenerType; typedef std::function<void(uint8_t)> payloadListenerType;
typedef std::function<void(uint16_t alarmCode, uint32_t start, uint32_t end)> alarmListenerType;
template<class HMSYSTEM>
class HmPayload { template<class HMSYSTEM>
public: class HmPayload {
HmPayload() {} public:
HmPayload() {}
void setup(IApp *app, HMSYSTEM *sys, statistics_t *stat, uint8_t maxRetransmits, uint32_t *timestamp) {
mApp = app; void setup(IApp *app, HMSYSTEM *sys, statistics_t *stat, uint8_t maxRetransmits, uint32_t *timestamp) {
mSys = sys; mApp = app;
mStat = stat; mSys = sys;
mMaxRetrans = maxRetransmits; mStat = stat;
mTimestamp = timestamp; mMaxRetrans = maxRetransmits;
for(uint8_t i = 0; i < MAX_NUM_INVERTERS; i++) { mTimestamp = timestamp;
reset(i); for(uint8_t i = 0; i < MAX_NUM_INVERTERS; i++) {
} reset(i);
mSerialDebug = false; }
mHighPrioIv = NULL; mSerialDebug = false;
mCbAlarm = NULL; mHighPrioIv = NULL;
mCbPayload = NULL; mCbAlarm = NULL;
} mCbPayload = NULL;
}
void enableSerialDebug(bool enable) {
mSerialDebug = enable; void enableSerialDebug(bool enable) {
} mSerialDebug = enable;
}
void addPayloadListener(payloadListenerType cb) {
mCbPayload = cb; void addPayloadListener(payloadListenerType cb) {
} mCbPayload = cb;
}
void addAlarmListener(alarmListenerType cb) {
mCbAlarm = cb; void addAlarmListener(alarmListenerType cb) {
} mCbAlarm = cb;
}
void loop() {
if (NULL != mHighPrioIv) { void loop() {
ivSend(mHighPrioIv, true); if (NULL != mHighPrioIv) {
mHighPrioIv = NULL; ivSend(mHighPrioIv, true);
} mHighPrioIv = NULL;
} }
}
void zeroYieldDay(Inverter<> *iv) {
DPRINTLN(DBG_DEBUG, F("zeroYieldDay")); void zeroYieldDay(Inverter<> *iv) {
record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug); DPRINTLN(DBG_DEBUG, F("zeroYieldDay"));
uint8_t pos; record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug);
for(uint8_t ch = 0; ch <= iv->channels; ch++) { uint8_t pos;
pos = iv->getPosByChFld(ch, FLD_YD, rec); for(uint8_t ch = 0; ch <= iv->channels; ch++) {
iv->setValue(pos, rec, 0.0f); pos = iv->getPosByChFld(ch, FLD_YD, rec);
pos = iv->getPosByChFld(ch, FLD_MP, rec); iv->setValue(pos, rec, 0.0f);
iv->setValue(pos, rec, 0.0f); pos = iv->getPosByChFld(ch, FLD_MP, rec);
} iv->setValue(pos, rec, 0.0f);
} }
}
void zeroInverterValues(Inverter<> *iv) {
DPRINTLN(DBG_DEBUG, F("zeroInverterValues")); void zeroInverterValues(Inverter<> *iv) {
record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug); DPRINTLN(DBG_DEBUG, F("zeroInverterValues"));
for(uint8_t ch = 0; ch <= iv->channels; ch++) { record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug);
uint8_t pos = 0; for(uint8_t ch = 0; ch <= iv->channels; ch++) {
for(uint8_t fld = 0; fld < FLD_EVT; fld++) { uint8_t pos = 0;
switch(fld) { for(uint8_t fld = 0; fld < FLD_EVT; fld++) {
case FLD_YD: switch(fld) {
case FLD_YT: case FLD_YD:
case FLD_MP: case FLD_YT:
continue; case FLD_MP:
} continue;
pos = iv->getPosByChFld(ch, fld, rec); }
iv->setValue(pos, rec, 0.0f); pos = iv->getPosByChFld(ch, fld, rec);
} iv->setValue(pos, rec, 0.0f);
} }
}
notify(RealTimeRunData_Debug);
} notify(RealTimeRunData_Debug);
}
void ivSendHighPrio(Inverter<> *iv) {
mHighPrioIv = iv; void ivSendHighPrio(Inverter<> *iv) {
} mHighPrioIv = iv;
}
void ivSend(Inverter<> *iv, bool highPrio = false) {
bool save_rxTmo; void ivSend(Inverter<> *iv, bool highPrio = false) {
bool save_rxTmo;
if(!highPrio) {
if (mPayload[iv->id].requested) { if(!highPrio) {
if (!mPayload[iv->id].complete) if (mPayload[iv->id].requested) {
process(false); // no retransmit if (!mPayload[iv->id].complete)
process(false); // no retransmit
if (!mPayload[iv->id].complete) {
if (mSerialDebug) if (!mPayload[iv->id].complete) {
DPRINT_IVID(DBG_INFO, iv->id); if (mSerialDebug)
if (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId) { DPRINT_IVID(DBG_INFO, iv->id);
mStat->rxFailNoAnser++; // got nothing if (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId) {
if (mSerialDebug) mStat->rxFailNoAnser++; // got nothing
DBGPRINTLN(F("enqueued cmd failed/timeout")); if (mSerialDebug)
} else { DBGPRINTLN(F("enqueued cmd failed/timeout"));
mStat->rxFail++; // got fragments but not complete response } else {
if (mSerialDebug) { mStat->rxFail++; // got fragments but not complete response
DBGPRINT(F("no complete Payload received! (retransmits: ")); if (mSerialDebug) {
DBGPRINT(String(mPayload[iv->id].retransmits)); DBGPRINT(F("no complete Payload received! (retransmits: "));
DBGPRINTLN(F(")")); DBGPRINT(String(mPayload[iv->id].retransmits));
} DBGPRINTLN(F(")"));
} }
iv->setQueuedCmdFinished(); // command failed }
} iv->setQueuedCmdFinished(); // command failed
} }
} }
}
save_rxTmo = mPayload[iv->id].rxTmo;
reset(iv->id); save_rxTmo = mPayload[iv->id].rxTmo;
mPayload[iv->id].rxTmo = save_rxTmo; reset(iv->id);
mPayload[iv->id].requested = true; mPayload[iv->id].rxTmo = save_rxTmo;
mPayload[iv->id].requested = true;
yield();
#ifdef undef yield();
if (mSerialDebug) { #ifdef undef
DPRINT_IVID(DBG_INFO, iv->id); if (mSerialDebug) {
DBGPRINT(F("Requesting Inv SN ")); DPRINT_IVID(DBG_INFO, iv->id);
DBGPRINTLN(String(iv->config->serial.u64, HEX)); DBGPRINT(F("Requesting Inv SN "));
} DBGPRINTLN(String(iv->config->serial.u64, HEX));
#endif }
#endif
if (iv->getDevControlRequest()) {
if (mSerialDebug) { if (iv->getDevControlRequest()) {
DPRINT_IVID(DBG_INFO, iv->id); if (mSerialDebug) {
DBGPRINT(F("Devcontrol request 0x")); DPRINT_IVID(DBG_INFO, iv->id);
DBGPRINT(String(iv->devControlCmd, HEX)); DBGPRINT(F("Devcontrol request 0x"));
DBGPRINT(F(" power limit ")); DBGPRINT(String(iv->devControlCmd, HEX));
DBGPRINTLN(String(iv->powerLimit[0])); DBGPRINT(F(" power limit "));
} DBGPRINTLN(String(iv->powerLimit[0]));
mSys->Radio.sendControlPacket(iv->radioId.u64, iv->devControlCmd, iv->powerLimit, false); }
mPayload[iv->id].txCmd = iv->devControlCmd; mSys->Radio.sendControlPacket(iv->radioId.u64, iv->devControlCmd, iv->powerLimit, false);
//iv->clearCmdQueue(); mPayload[iv->id].txCmd = iv->devControlCmd;
//iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit //iv->clearCmdQueue();
} else { //iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit
uint8_t cmd = iv->getQueuedCmd(); } else {
DPRINT_IVID(DBG_INFO, iv->id); uint8_t cmd = iv->getQueuedCmd();
DBGPRINT(F("prepareDevInformCmd 0x")); DPRINT_IVID(DBG_INFO, iv->id);
DBGHEXLN(cmd); DBGPRINT(F("prepareDevInformCmd 0x"));
mSys->Radio.prepareDevInformCmd(iv->radioId.u64, cmd, mPayload[iv->id].ts, iv->alarmMesIndex, false); DBGHEXLN(cmd);
mPayload[iv->id].txCmd = cmd; mSys->Radio.prepareDevInformCmd(iv->radioId.u64, cmd, mPayload[iv->id].ts, iv->alarmMesIndex, 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 void add(Inverter<> *iv, packet_t *p) {
mPayload[iv->id].txId = p->packet[0]; if (p->packet[0] == (TX_REQ_INFO + ALL_FRAMES)) { // response from get information command
DPRINTLN(DBG_DEBUG, F("Response from info request received")); mPayload[iv->id].txId = p->packet[0];
uint8_t *pid = &p->packet[9]; DPRINTLN(DBG_DEBUG, F("Response from info request received"));
if (*pid == 0x00) { uint8_t *pid = &p->packet[9];
DPRINTLN(DBG_DEBUG, F("fragment number zero received and ignored")); if (*pid == 0x00) {
} else { DPRINTLN(DBG_DEBUG, F("fragment number zero received and ignored"));
DPRINT(DBG_DEBUG, F("PID: 0x")); } else {
DPRINTLN(DBG_DEBUG, String(*pid, HEX)); DPRINT(DBG_DEBUG, F("PID: 0x"));
if ((*pid & 0x7F) < MAX_PAYLOAD_ENTRIES) { DPRINTLN(DBG_DEBUG, String(*pid, HEX));
memcpy(mPayload[iv->id].data[(*pid & 0x7F) - 1], &p->packet[10], p->len - 11); if ((*pid & 0x7F) < MAX_PAYLOAD_ENTRIES) {
mPayload[iv->id].len[(*pid & 0x7F) - 1] = p->len - 11; memcpy(mPayload[iv->id].data[(*pid & 0x7F) - 1], &p->packet[10], p->len - 11);
mPayload[iv->id].gotFragment = true; mPayload[iv->id].len[(*pid & 0x7F) - 1] = p->len - 11;
} mPayload[iv->id].gotFragment = true;
}
if ((*pid & ALL_FRAMES) == ALL_FRAMES) {
// Last packet if ((*pid & ALL_FRAMES) == ALL_FRAMES) {
if (((*pid & 0x7f) > mPayload[iv->id].maxPackId) || (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId)) { // Last packet
mPayload[iv->id].maxPackId = (*pid & 0x7f); if (((*pid & 0x7f) > mPayload[iv->id].maxPackId) || (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId)) {
if (*pid > 0x81) mPayload[iv->id].maxPackId = (*pid & 0x7f);
mPayload[iv->id].lastFound = true; 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")); } 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(); mPayload[iv->id].txId = p->packet[0];
iv->clearDevControlRequest();
if ((p->packet[12] == ActivePowerContr) && (p->packet[13] == 0x00)) {
bool ok = true; if ((p->packet[12] == ActivePowerContr) && (p->packet[13] == 0x00)) {
bool ok = true;
if((p->packet[10] == 0x00) && (p->packet[11] == 0x00)) {
#ifdef AHOY_MQTT_SUPPORT if((p->packet[10] == 0x00) && (p->packet[11] == 0x00)) {
mApp->setMqttPowerLimitAck(iv); #ifdef AHOY_MQTT_SUPPORT
#endif mApp->setMqttPowerLimitAck(iv);
} else { #endif
ok = false; } else {
} ok = false;
DPRINT_IVID(DBG_INFO, iv->id); }
DBGPRINT(F("has ")); DPRINT_IVID(DBG_INFO, iv->id);
if(!ok) DBGPRINT(F("not ")); DBGPRINT(F("has "));
DBGPRINT(F("accepted power limit set point ")); if(!ok) DBGPRINT(F("not "));
DBGPRINT(String(iv->powerLimit[0])); DBGPRINT(F("accepted power limit set point "));
DBGPRINT(F(" with PowerLimitControl ")); DBGPRINT(String(iv->powerLimit[0]));
DBGPRINTLN(String(iv->powerLimit[1])); DBGPRINT(F(" with PowerLimitControl "));
DBGPRINTLN(String(iv->powerLimit[1]));
iv->clearCmdQueue();
iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit iv->clearCmdQueue();
if(mHighPrioIv == NULL) // do it immediately if possible iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit
mHighPrioIv = iv; if(mHighPrioIv == NULL) // do it immediately if possible
} mHighPrioIv = iv;
iv->devControlCmd = Init; }
} iv->devControlCmd = Init;
} }
}
void process(bool retransmit) {
for (uint8_t id = 0; id < mSys->getNumInverters(); id++) { void process(bool retransmit) {
Inverter<> *iv = mSys->getInverterByPos(id); for (uint8_t id = 0; id < mSys->getNumInverters(); id++) {
if (NULL == iv) Inverter<> *iv = mSys->getInverterByPos(id);
continue; // skip to next inverter if (NULL == iv)
continue; // skip to next inverter
if (IV_MI == iv->ivGen) // only process HM inverters
continue; // skip to next inverter if (IV_MI == iv->ivGen) // only process HM inverters
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 if ((mPayload[iv->id].txId != (TX_REQ_INFO + ALL_FRAMES)) && (0 != mPayload[iv->id].txId)) {
mPayload[iv->id].complete = true; // no processing needed if txId is not 0x95
continue; // skip to next inverter mPayload[iv->id].complete = true;
} continue; // skip to next inverter
}
if (!mPayload[iv->id].complete) {
bool crcPass, pyldComplete; if (!mPayload[iv->id].complete) {
crcPass = build(iv->id, &pyldComplete); bool crcPass, pyldComplete;
if (!crcPass && !pyldComplete) { // payload not complete uint8 Fragments;
if ((mPayload[iv->id].requested) && (retransmit)) { crcPass = build(iv->id, &pyldComplete, &Fragments);
if (mPayload[iv->id].retransmits < mMaxRetrans) {
mPayload[iv->id].retransmits++; // evaluate quality of send channel with rcv params
if (iv->devControlCmd == Restart || iv->devControlCmd == CleanState_LockAndAlarm) { mSys->Radio.evalSendChannelQuality (crcPass, mPayload[iv->id].retransmits,
// This is required to prevent retransmissions without answer. Fragments, mPayload[iv->id].lastFragments);
DPRINTLN(DBG_INFO, F("Prevent retransmit on Restart / CleanState_LockAndAlarm...")); mPayload[iv->id].lastFragments = Fragments;
mPayload[iv->id].retransmits = mMaxRetrans; if (!crcPass && !pyldComplete) { // payload not complete
} else if(iv->devControlCmd == ActivePowerContr) { if ((mPayload[iv->id].requested) && (retransmit)) {
DPRINT_IVID(DBG_INFO, iv->id); if (mPayload[iv->id].retransmits < mMaxRetrans) {
DPRINTLN(DBG_INFO, F("retransmit power limit")); mPayload[iv->id].retransmits++;
mSys->Radio.sendControlPacket(iv->radioId.u64, iv->devControlCmd, iv->powerLimit, true); if (iv->devControlCmd == Restart || iv->devControlCmd == CleanState_LockAndAlarm) {
} else { // This is required to prevent retransmissions without answer.
if(false == mPayload[iv->id].gotFragment) { DPRINTLN(DBG_INFO, F("Prevent retransmit on Restart / CleanState_LockAndAlarm..."));
DPRINT_IVID(DBG_WARN, iv->id); mPayload[iv->id].retransmits = mMaxRetrans;
if (mPayload[iv->id].rxTmo) { } else if(iv->devControlCmd == ActivePowerContr) {
DBGPRINTLN(F("nothing received")); DPRINT_IVID(DBG_INFO, iv->id);
mPayload[iv->id].retransmits = mMaxRetrans; DPRINTLN(DBG_INFO, F("retransmit power limit"));
} else { mSys->Radio.sendControlPacket(iv->radioId.u64, iv->devControlCmd, iv->powerLimit, true);
DBGPRINTLN(F("nothing received: complete retransmit")); } else {
mPayload[iv->id].txCmd = iv->getQueuedCmd(); if(false == mPayload[iv->id].gotFragment) {
DPRINTLN(DBG_INFO, F("(#") + String(iv->id) + F(") prepareDevInformCmd 0x") + String(mPayload[iv->id].txCmd, HEX)); DPRINT_IVID(DBG_WARN, iv->id);
mSys->Radio.prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); if (mPayload[iv->id].rxTmo) {
} DBGPRINTLN(F("nothing received"));
} else { mPayload[iv->id].retransmits = mMaxRetrans;
for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId - 1); i++) { } else {
if (mPayload[iv->id].len[i] == 0) { DBGPRINTLN(F("nothing received: complete retransmit"));
DPRINT_IVID(DBG_WARN, iv->id); mPayload[iv->id].txCmd = iv->getQueuedCmd();
DBGPRINT(F("Frame ")); DPRINTLN(DBG_INFO, F("(#") + String(iv->id) + F(") prepareDevInformCmd 0x") + String(mPayload[iv->id].txCmd, HEX));
DBGPRINT(String(i + 1)); mSys->Radio.prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true);
DBGPRINTLN(F(" missing: Request Retransmit")); }
mSys->Radio.sendCmdPacket(iv->radioId.u64, TX_REQ_INFO, (SINGLE_FRAME + i), true); } else {
break; // only request retransmit one frame per loop for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId - 1); i++) {
} if (mPayload[iv->id].len[i] == 0) {
yield(); DPRINT_IVID(DBG_WARN, iv->id);
} DBGPRINT(F("Frame "));
} DBGPRINT(String(i + 1));
} DBGPRINTLN(F(" missing: Request Retransmit"));
} else if (false == mPayload[iv->id].gotFragment) { mSys->Radio.sendCmdPacket(iv->radioId.u64, TX_REQ_INFO, (SINGLE_FRAME + i), true);
// only if there is no sign of life break; // only request retransmit one frame per loop
mPayload[iv->id].rxTmo = true; // inv might be down, no complete retransmit anymore }
} yield();
} }
} else if(!crcPass && pyldComplete) { // crc error on complete Payload }
if (mPayload[iv->id].retransmits < mMaxRetrans) { }
mPayload[iv->id].retransmits++; } else if (false == mPayload[iv->id].gotFragment) {
DPRINTLN(DBG_WARN, F("CRC Error: Request Complete Retransmit")); // only if there is no sign of life
mPayload[iv->id].txCmd = iv->getQueuedCmd(); mPayload[iv->id].rxTmo = true; // inv might be down, no complete retransmit anymore
DPRINT_IVID(DBG_INFO, iv->id); }
DBGPRINT(F("prepareDevInformCmd 0x")); }
DBGHEXLN(mPayload[iv->id].txCmd); } else if(!crcPass && pyldComplete) { // crc error on complete Payload
mSys->Radio.prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); if (mPayload[iv->id].retransmits < mMaxRetrans) {
} else if (false == mPayload[iv->id].gotFragment) { mPayload[iv->id].retransmits++;
// only if there is no sign of life DPRINTLN(DBG_WARN, F("CRC Error: Request Complete Retransmit"));
mPayload[iv->id].rxTmo = true; // inv might be down, no complete retransmit anymore mPayload[iv->id].txCmd = iv->getQueuedCmd();
} DPRINT_IVID(DBG_INFO, iv->id);
} else { // payload complete DBGPRINT(F("prepareDevInformCmd 0x"));
#ifdef undef DBGHEXLN(mPayload[iv->id].txCmd);
DPRINT(DBG_INFO, F("procPyld: cmd: 0x")); mSys->Radio.prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true);
DBGHEXLN(mPayload[iv->id].txCmd); } else if (false == mPayload[iv->id].gotFragment) {
DPRINT(DBG_INFO, F("procPyld: txid: 0x")); // only if there is no sign of life
DBGHEXLN(mPayload[iv->id].txId); mPayload[iv->id].rxTmo = true; // inv might be down, no complete retransmit anymore
#endif }
DPRINT(DBG_DEBUG, F("procPyld: max: ")); } else { // payload complete
DPRINTLN(DBG_DEBUG, String(mPayload[iv->id].maxPackId)); #ifdef undef
DPRINT(DBG_INFO, F("procPyld: cmd: 0x"));
record_t<> *rec = iv->getRecordStruct(mPayload[iv->id].txCmd); // choose the parser DBGHEXLN(mPayload[iv->id].txCmd);
mPayload[iv->id].complete = true; DPRINT(DBG_INFO, F("procPyld: txid: 0x"));
mPayload[iv->id].rxTmo = false; DBGHEXLN(mPayload[iv->id].txId);
#endif
uint8_t payload[128]; DPRINT(DBG_DEBUG, F("procPyld: max: "));
uint8_t payloadLen = 0; DPRINTLN(DBG_DEBUG, String(mPayload[iv->id].maxPackId));
memset(payload, 0, 128); record_t<> *rec = iv->getRecordStruct(mPayload[iv->id].txCmd); // choose the parser
mPayload[iv->id].complete = true;
for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId); i++) { mPayload[iv->id].rxTmo = false;
memcpy(&payload[payloadLen], mPayload[iv->id].data[i], (mPayload[iv->id].len[i]));
payloadLen += (mPayload[iv->id].len[i]); uint8_t payload[128];
yield(); uint8_t payloadLen = 0;
}
payloadLen -= 2; memset(payload, 0, 128);
#ifdef undef for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId); i++) {
if (mSerialDebug) { memcpy(&payload[payloadLen], mPayload[iv->id].data[i], (mPayload[iv->id].len[i]));
DPRINT(DBG_INFO, F("Payload (")); payloadLen += (mPayload[iv->id].len[i]);
DBGPRINT(String(payloadLen)); yield();
DBGPRINT(F("): ")); }
mSys->Radio.dumpBuf(payload, payloadLen); payloadLen -= 2;
}
#endif #ifdef undef
if (mSerialDebug) {
if (NULL == rec) { DPRINT(DBG_INFO, F("Payload ("));
DPRINTLN(DBG_ERROR, F("record is NULL!")); DBGPRINT(String(payloadLen));
} else if ((rec->pyldLen == payloadLen) || (0 == rec->pyldLen)) { DBGPRINT(F("): "));
if (mPayload[iv->id].txId == (TX_REQ_INFO + ALL_FRAMES)) mSys->Radio.dumpBuf(payload, payloadLen);
mStat->rxSuccess++; }
#endif
rec->ts = mPayload[iv->id].ts;
for (uint8_t i = 0; i < rec->length; i++) { if (NULL == rec) {
iv->addValue(i, payload, rec); DPRINTLN(DBG_ERROR, F("record is NULL!"));
yield(); } else if ((rec->pyldLen == payloadLen) || (0 == rec->pyldLen)) {
} if (mPayload[iv->id].txId == (TX_REQ_INFO + ALL_FRAMES))
iv->doCalculations(); mStat->rxSuccess++;
uint8_t pos = iv->getPosByChFld(CH0, FLD_PAC, rec);
if (pos != 0xff) { rec->ts = mPayload[iv->id].ts;
float ac_power = iv->getValue(pos, rec); for (uint8_t i = 0; i < rec->length; i++) {
mSys->handle_pac (iv, (uint16_t)(ac_power+0.5f)); iv->addValue(i, payload, rec);
} yield();
}
notify(mPayload[iv->id].txCmd); iv->doCalculations();
uint8_t pos = iv->getPosByChFld(CH0, FLD_PAC, rec);
if(AlarmData == mPayload[iv->id].txCmd) {
uint8_t i = 0; if (pos != 0xff) {
uint16_t code; float ac_power = iv->getValue(pos, rec);
uint32_t start, end; mSys->handle_pac (iv, (uint16_t)(ac_power+0.5f));
while(1) { }
code = iv->parseAlarmLog(i++, payload, payloadLen, &start, &end);
if(0 == code) notify(mPayload[iv->id].txCmd);
break;
if (NULL != mCbAlarm) if(AlarmData == mPayload[iv->id].txCmd) {
(mCbAlarm)(code, start, end); uint8_t i = 0;
yield(); uint16_t code;
} uint32_t start, end;
} while(1) {
} else { code = iv->parseAlarmLog(i++, payload, payloadLen, &start, &end);
DPRINT(DBG_ERROR, F("plausibility check failed, expected ")); if(0 == code)
DBGPRINT(String(rec->pyldLen)); break;
DBGPRINTLN(F(" bytes")); if (NULL != mCbAlarm)
mStat->rxFail++; (mCbAlarm)(code, start, end);
} yield();
}
iv->setQueuedCmdFinished(); }
} } else {
} DPRINT(DBG_ERROR, F("plausibility check failed, expected "));
yield(); DBGPRINT(String(rec->pyldLen));
} DBGPRINTLN(F(" bytes"));
} mStat->rxFail++;
}
private:
void notify(uint8_t val) { iv->setQueuedCmdFinished();
if(NULL != mCbPayload) }
(mCbPayload)(val); }
} yield();
}
void notify(uint16_t code, uint32_t start, uint32_t endTime) { }
if (NULL != mCbAlarm)
(mCbAlarm)(code, start, endTime); private:
} void notify(uint8_t val) {
if(NULL != mCbPayload)
bool build(uint8_t id, bool *complete) { (mCbPayload)(val);
DPRINTLN(DBG_VERBOSE, F("build")); }
uint16_t crc = 0xffff, crcRcv = 0x0000;
if (mPayload[id].maxPackId > MAX_PAYLOAD_ENTRIES) void notify(uint16_t code, uint32_t start, uint32_t endTime) {
mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES; if (NULL != mCbAlarm)
(mCbAlarm)(code, start, endTime);
// check if all fragments are there }
*complete = true;
for (uint8_t i = 0; i < mPayload[id].maxPackId; i++) { bool build(uint8_t id, bool *complete, uint8_t *fragments) {
if(mPayload[id].len[i] == 0) DPRINTLN(DBG_VERBOSE, F("build"));
*complete = false; uint16_t crc = 0xffff, crcRcv = 0x0000;
} if (mPayload[id].maxPackId > MAX_PAYLOAD_ENTRIES)
if(!*complete) mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES;
return false;
// check if all fragments are there
for (uint8_t i = 0; i < mPayload[id].maxPackId; i++) { *complete = true;
if (mPayload[id].len[i] > 0) { *fragments = 0;
if (i == (mPayload[id].maxPackId - 1)) { for (uint8_t i = 0; i < mPayload[id].maxPackId; i++) {
crc = ah::crc16(mPayload[id].data[i], mPayload[id].len[i] - 2, crc); if(mPayload[id].len[i] == 0) {
crcRcv = (mPayload[id].data[i][mPayload[id].len[i] - 2] << 8) | (mPayload[id].data[i][mPayload[id].len[i] - 1]); *complete = false;
} else } else {
crc = ah::crc16(mPayload[id].data[i], mPayload[id].len[i], crc); (*fragments)++;
} }
yield(); }
} if(!*complete)
return false;
return (crc == crcRcv) ? true : false;
} for (uint8_t i = 0; i < mPayload[id].maxPackId; i++) {
if (mPayload[id].len[i] > 0) {
void reset(uint8_t id) { if (i == (mPayload[id].maxPackId - 1)) {
#ifdef undef crc = ah::crc16(mPayload[id].data[i], mPayload[id].len[i] - 2, crc);
DPRINT_IVID(DBG_INFO, id); crcRcv = (mPayload[id].data[i][mPayload[id].len[i] - 2] << 8) | (mPayload[id].data[i][mPayload[id].len[i] - 1]);
DBGPRINTLN(F("resetPayload")); } else
#endif crc = ah::crc16(mPayload[id].data[i], mPayload[id].len[i], crc);
memset(mPayload[id].len, 0, MAX_PAYLOAD_ENTRIES); }
mPayload[id].txCmd = 0; yield();
mPayload[id].gotFragment = false; }
mPayload[id].retransmits = 0;
mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES; return (crc == crcRcv) ? true : false;
mPayload[id].lastFound = false; }
mPayload[id].complete = false;
mPayload[id].requested = false; void reset(uint8_t id) {
mPayload[id].ts = *mTimestamp; #ifdef undef
mPayload[id].rxTmo = true; // design: dont start with complete retransmit DPRINT_IVID(DBG_INFO, id);
} DBGPRINTLN(F("resetPayload"));
#endif
IApp *mApp; memset(mPayload[id].len, 0, MAX_PAYLOAD_ENTRIES);
HMSYSTEM *mSys; mPayload[id].txCmd = 0;
statistics_t *mStat; mPayload[id].gotFragment = false;
uint8_t mMaxRetrans; mPayload[id].retransmits = 0;
uint32_t *mTimestamp; mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES;
invPayload_t mPayload[MAX_NUM_INVERTERS]; mPayload[id].lastFound = false;
bool mSerialDebug; mPayload[id].complete = false;
Inverter<> *mHighPrioIv; mPayload[id].requested = false;
mPayload[id].ts = *mTimestamp;
alarmListenerType mCbAlarm; mPayload[id].rxTmo = true; // design: dont start with complete retransmit
payloadListenerType mCbPayload; mPayload[id].lastFragments = 0; // for send channel quality measurement
}; }
#endif /*__HM_PAYLOAD_H__*/ IApp *mApp;
HMSYSTEM *mSys;
statistics_t *mStat;
uint8_t mMaxRetrans;
uint32_t *mTimestamp;
invPayload_t mPayload[MAX_NUM_INVERTERS];
bool mSerialDebug;
Inverter<> *mHighPrioIv;
alarmListenerType mCbAlarm;
payloadListenerType mCbPayload;
};
#endif /*__HM_PAYLOAD_H__*/

849
src/hm/hmRadio.h
View File

@ -1,379 +1,470 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// 2023 Ahoy, https://github.com/lumpapu/ahoy // 2023 Ahoy, https://github.com/lumpapu/ahoy
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/ // Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifndef __RADIO_H__ #ifndef __RADIO_H__
#define __RADIO_H__ #define __RADIO_H__
#include "../utils/dbg.h" #include "../utils/dbg.h"
#include <RF24.h> #include <RF24.h>
#include "../utils/crc.h" #include "../utils/crc.h"
#include "../config/config.h" #include "../config/config.h"
#include "SPI.h" #include "SPI.h"
#define SPI_SPEED 1000000 #define SPI_SPEED 1000000
#define RF_CHANNELS 5 #define RF_CHANNELS 5
#define TX_REQ_INFO 0x15 #define TX_REQ_INFO 0x15
#define TX_REQ_DEVCONTROL 0x51 #define TX_REQ_DEVCONTROL 0x51
#define ALL_FRAMES 0x80 #define ALL_FRAMES 0x80
#define SINGLE_FRAME 0x81 #define SINGLE_FRAME 0x81
const char* const rf24AmpPowerNames[] = {"MIN", "LOW", "HIGH", "MAX"}; #define SEND_CHANNEL_QUALITY_INTEGRATOR_SIZE 4
#define SEND_CHANNEL_MAX_QUALITY 4
#define SEND_CHANNEL_MIN_QUALITY -6
//----------------------------------------------------------------------------- #define SEND_CHANNEL_QUALITY_GOOD 2
// MACROS #define SEND_CHANNEL_QUALITY_OK 1
//----------------------------------------------------------------------------- #define SEND_CHANNEL_QUALITY_NEUTRAL 0
#define CP_U32_LittleEndian(buf, v) ({ \ #define SEND_CHANNEL_QUALITY_LOW -1
uint8_t *b = buf; \ #define SEND_CHANNEL_QUALITY_BAD -2
b[0] = ((v >> 24) & 0xff); \
b[1] = ((v >> 16) & 0xff); \ const char* const rf24AmpPowerNames[] = {"MIN", "LOW", "HIGH", "MAX"};
b[2] = ((v >> 8) & 0xff); \
b[3] = ((v ) & 0xff); \
}) //-----------------------------------------------------------------------------
// MACROS
#define CP_U32_BigEndian(buf, v) ({ \ //-----------------------------------------------------------------------------
uint8_t *b = buf; \ #define CP_U32_LittleEndian(buf, v) ({ \
b[3] = ((v >> 24) & 0xff); \ uint8_t *b = buf; \
b[2] = ((v >> 16) & 0xff); \ b[0] = ((v >> 24) & 0xff); \
b[1] = ((v >> 8) & 0xff); \ b[1] = ((v >> 16) & 0xff); \
b[0] = ((v ) & 0xff); \ b[2] = ((v >> 8) & 0xff); \
}) b[3] = ((v ) & 0xff); \
})
#define BIT_CNT(x) ((x)<<3)
#define CP_U32_BigEndian(buf, v) ({ \
//----------------------------------------------------------------------------- uint8_t *b = buf; \
// HM Radio class b[3] = ((v >> 24) & 0xff); \
//----------------------------------------------------------------------------- b[2] = ((v >> 16) & 0xff); \
template <uint8_t IRQ_PIN = DEF_IRQ_PIN, uint8_t CE_PIN = DEF_CE_PIN, uint8_t CS_PIN = DEF_CS_PIN, uint8_t AMP_PWR = RF24_PA_LOW, uint8_t SCLK_PIN = DEF_SCLK_PIN, uint8_t MOSI_PIN = DEF_MOSI_PIN, uint8_t MISO_PIN = DEF_MISO_PIN> b[1] = ((v >> 8) & 0xff); \
class HmRadio { b[0] = ((v ) & 0xff); \
public: })
HmRadio() : mNrf24(CE_PIN, CS_PIN, SPI_SPEED) {
if(mSerialDebug) { #define BIT_CNT(x) ((x)<<3)
DPRINT(DBG_VERBOSE, F("hmRadio.h : HmRadio():mNrf24(CE_PIN: "));
DBGPRINT(String(CE_PIN)); //-----------------------------------------------------------------------------
DBGPRINT(F(", CS_PIN: ")); // HM Radio class
DBGPRINT(String(CS_PIN)); //-----------------------------------------------------------------------------
DBGPRINT(F(", SPI_SPEED: ")); template <uint8_t IRQ_PIN = DEF_IRQ_PIN, uint8_t CE_PIN = DEF_CE_PIN, uint8_t CS_PIN = DEF_CS_PIN, uint8_t AMP_PWR = RF24_PA_LOW, uint8_t SCLK_PIN = DEF_SCLK_PIN, uint8_t MOSI_PIN = DEF_MOSI_PIN, uint8_t MISO_PIN = DEF_MISO_PIN>
DBGPRINT(String(SPI_SPEED)); class HmRadio {
DBGPRINTLN(F(")")); public:
} HmRadio() : mNrf24(CE_PIN, CS_PIN, SPI_SPEED) {
if(mSerialDebug) {
// Depending on the program, the module can work on 2403, 2423, 2440, 2461 or 2475MHz. DPRINT(DBG_VERBOSE, F("hmRadio.h : HmRadio():mNrf24(CE_PIN: "));
// Channel List 2403, 2423, 2440, 2461, 2475MHz DBGPRINT(String(CE_PIN));
mRfChLst[0] = 03; DBGPRINT(F(", CS_PIN: "));
mRfChLst[1] = 23; DBGPRINT(String(CS_PIN));
mRfChLst[2] = 40; DBGPRINT(F(", SPI_SPEED: "));
mRfChLst[3] = 61; DBGPRINT(String(SPI_SPEED));
mRfChLst[4] = 75; DBGPRINTLN(F(")"));
}
// default channels
mTxChIdx = 2; // Start TX with 40 // Depending on the program, the module can work on 2403, 2423, 2440, 2461 or 2475MHz.
mRxChIdx = 0; // Start RX with 03 // Channel List 2403, 2423, 2440, 2461, 2475MHz
mRfChLst[0] = 03;
mSendCnt = 0; mRfChLst[1] = 23;
mRetransmits = 0; mRfChLst[2] = 40;
mRfChLst[3] = 61;
mSerialDebug = false; mRfChLst[4] = 75;
mIrqRcvd = false;
} // default channels
~HmRadio() {} mTxChIdx = 2; // Start TX with 40
mRxChIdx = 0; // Start RX with 03
void setup(uint8_t ampPwr = RF24_PA_LOW, uint8_t irq = IRQ_PIN, uint8_t ce = CE_PIN, uint8_t cs = CS_PIN, uint8_t sclk = SCLK_PIN, uint8_t mosi = MOSI_PIN, uint8_t miso = MISO_PIN) {
DPRINTLN(DBG_VERBOSE, F("hmRadio.h:setup")); mSendCnt = 0;
pinMode(irq, INPUT_PULLUP); mRetransmits = 0;
uint32_t dtuSn = 0x87654321; mSerialDebug = false;
uint32_t chipID = 0; // will be filled with last 3 bytes of MAC mIrqRcvd = false;
#ifdef ESP32 }
uint64_t MAC = ESP.getEfuseMac(); ~HmRadio() {}
chipID = ((MAC >> 8) & 0xFF0000) | ((MAC >> 24) & 0xFF00) | ((MAC >> 40) & 0xFF);
#else void setup(uint8_t ampPwr = RF24_PA_LOW, uint8_t irq = IRQ_PIN, uint8_t ce = CE_PIN, uint8_t cs = CS_PIN, uint8_t sclk = SCLK_PIN, uint8_t mosi = MOSI_PIN, uint8_t miso = MISO_PIN) {
chipID = ESP.getChipId(); DPRINTLN(DBG_VERBOSE, F("hmRadio.h:setup"));
#endif pinMode(irq, INPUT_PULLUP);
if(chipID) {
dtuSn = 0x80000000; // the first digit is an 8 for DTU production year 2022, the rest is filled with the ESP chipID in decimal uint32_t dtuSn = 0x87654321;
for(int i = 0; i < 7; i++) { uint32_t chipID = 0; // will be filled with last 3 bytes of MAC
dtuSn |= (chipID % 10) << (i * 4); #ifdef ESP32
chipID /= 10; uint64_t MAC = ESP.getEfuseMac();
} chipID = ((MAC >> 8) & 0xFF0000) | ((MAC >> 24) & 0xFF00) | ((MAC >> 40) & 0xFF);
} #else
// change the byte order of the DTU serial number and append the required 0x01 at the end chipID = ESP.getChipId();
DTU_RADIO_ID = ((uint64_t)(((dtuSn >> 24) & 0xFF) | ((dtuSn >> 8) & 0xFF00) | ((dtuSn << 8) & 0xFF0000) | ((dtuSn << 24) & 0xFF000000)) << 8) | 0x01; #endif
if(chipID) {
#ifdef ESP32 dtuSn = 0x80000000; // the first digit is an 8 for DTU production year 2022, the rest is filled with the ESP chipID in decimal
#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3 for(int i = 0; i < 7; i++) {
mSpi = new SPIClass(FSPI); dtuSn |= (chipID % 10) << (i * 4);
#else chipID /= 10;
mSpi = new SPIClass(VSPI); }
#endif }
mSpi->begin(sclk, miso, mosi, cs); // change the byte order of the DTU serial number and append the required 0x01 at the end
#else DTU_RADIO_ID = ((uint64_t)(((dtuSn >> 24) & 0xFF) | ((dtuSn >> 8) & 0xFF00) | ((dtuSn << 8) & 0xFF0000) | ((dtuSn << 24) & 0xFF000000)) << 8) | 0x01;
//the old ESP82xx cannot freely place their SPI pins
mSpi = new SPIClass(); #ifdef ESP32
mSpi->begin(); #if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
#endif mSpi = new SPIClass(FSPI);
mNrf24.begin(mSpi, ce, cs); #else
mNrf24.setRetries(3, 15); // 3*250us + 250us and 15 loops -> 15ms mSpi = new SPIClass(VSPI);
#endif
mNrf24.setChannel(mRfChLst[mRxChIdx]); mSpi->begin(sclk, miso, mosi, cs);
mNrf24.startListening(); #else
mNrf24.setDataRate(RF24_250KBPS); //the old ESP82xx cannot freely place their SPI pins
mNrf24.setAutoAck(true); mSpi = new SPIClass();
mNrf24.enableDynamicPayloads(); mSpi->begin();
mNrf24.setCRCLength(RF24_CRC_16); #endif
mNrf24.setAddressWidth(5); mNrf24.begin(mSpi, ce, cs);
mNrf24.openReadingPipe(1, reinterpret_cast<uint8_t*>(&DTU_RADIO_ID)); mNrf24.setRetries(3, 15); // 3*250us + 250us and 15 loops -> 15ms
// enable all receiving interrupts mNrf24.setChannel(mRfChLst[mRxChIdx]);
mNrf24.maskIRQ(false, false, false); mNrf24.startListening();
mNrf24.setDataRate(RF24_250KBPS);
DPRINT(DBG_INFO, F("RF24 Amp Pwr: RF24_PA_")); mNrf24.setAutoAck(true);
DPRINTLN(DBG_INFO, String(rf24AmpPowerNames[ampPwr])); mNrf24.enableDynamicPayloads();
mNrf24.setPALevel(ampPwr & 0x03); mNrf24.setCRCLength(RF24_CRC_16);
mNrf24.setAddressWidth(5);
if(mNrf24.isChipConnected()) { mNrf24.openReadingPipe(1, reinterpret_cast<uint8_t*>(&DTU_RADIO_ID));
DPRINTLN(DBG_INFO, F("Radio Config:"));
mNrf24.printPrettyDetails(); // enable all receiving interrupts
} mNrf24.maskIRQ(false, false, false);
else
DPRINTLN(DBG_WARN, F("WARNING! your NRF24 module can't be reached, check the wiring")); DPRINT(DBG_INFO, F("RF24 Amp Pwr: RF24_PA_"));
} DPRINTLN(DBG_INFO, String(rf24AmpPowerNames[ampPwr]));
mNrf24.setPALevel(ampPwr & 0x03);
bool loop(void) {
if (!mIrqRcvd) if(mNrf24.isChipConnected()) {
return false; // nothing to do DPRINTLN(DBG_INFO, F("Radio Config:"));
mIrqRcvd = false; mNrf24.printPrettyDetails();
bool tx_ok, tx_fail, rx_ready; }
mNrf24.whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH else
mNrf24.flush_tx(); // empty TX FIFO DPRINTLN(DBG_WARN, F("WARNING! your NRF24 module can't be reached, check the wiring"));
}
// start listening
mNrf24.setChannel(mRfChLst[mRxChIdx]); bool loop(void) {
mNrf24.startListening(); if (!mIrqRcvd)
return false; // nothing to do
uint32_t startMicros = micros(); mIrqRcvd = false;
uint32_t loopMillis = millis(); bool tx_ok, tx_fail, rx_ready;
while (millis()-loopMillis < 400) { mNrf24.whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH
while (micros()-startMicros < 5110) { // listen (4088us or?) 5110us to each channel mNrf24.flush_tx(); // empty TX FIFO
if (mIrqRcvd) {
mIrqRcvd = false; // start listening
if (getReceived()) { // everything received mNrf24.setChannel(mRfChLst[mRxChIdx]);
return true; mNrf24.startListening();
}
} uint32_t startMicros = micros();
yield(); uint32_t loopMillis = millis();
} while (millis()-loopMillis < 400) {
// switch to next RX channel while (micros()-startMicros < 5110) { // listen (4088us or?) 5110us to each channel
startMicros = micros(); if (mIrqRcvd) {
if(++mRxChIdx >= RF_CHANNELS) mIrqRcvd = false;
mRxChIdx = 0; if (getReceived()) { // everything received
mNrf24.setChannel(mRfChLst[mRxChIdx]); return true;
yield(); }
} }
// not finished but time is over yield();
return true; }
} // switch to next RX channel
startMicros = micros();
void handleIntr(void) { if(++mRxChIdx >= RF_CHANNELS)
mIrqRcvd = true; mRxChIdx = 0;
} mNrf24.setChannel(mRfChLst[mRxChIdx]);
yield();
bool isChipConnected(void) { }
//DPRINTLN(DBG_VERBOSE, F("hmRadio.h:isChipConnected")); // not finished but time is over
return mNrf24.isChipConnected(); return true;
} }
void enableDebug() {
mSerialDebug = true; void handleIntr(void) {
} mIrqRcvd = true;
}
void sendControlPacket(uint64_t invId, uint8_t cmd, uint16_t *data, bool isRetransmit, bool isNoMI = true) {
DPRINT(DBG_INFO, F("sendControlPacket cmd: 0x")); bool isChipConnected(void) {
DBGHEXLN(cmd); //DPRINTLN(DBG_VERBOSE, F("hmRadio.h:isChipConnected"));
initPacket(invId, TX_REQ_DEVCONTROL, SINGLE_FRAME); return mNrf24.isChipConnected();
uint8_t cnt = 10; }
if (isNoMI) { void enableDebug() {
mTxBuf[cnt++] = cmd; // cmd -> 0 on, 1 off, 2 restart, 11 active power, 12 reactive power, 13 power factor mSerialDebug = true;
mTxBuf[cnt++] = 0x00; }
if(cmd >= ActivePowerContr && cmd <= PFSet) { // ActivePowerContr, ReactivePowerContr, PFSet
mTxBuf[cnt++] = ((data[0] * 10) >> 8) & 0xff; // power limit void sendControlPacket(uint64_t invId, uint8_t cmd, uint16_t *data, bool isRetransmit, bool isNoMI = true) {
mTxBuf[cnt++] = ((data[0] * 10) ) & 0xff; // power limit DPRINT(DBG_INFO, F("sendControlPacket cmd: 0x"));
mTxBuf[cnt++] = ((data[1] ) >> 8) & 0xff; // setting for persistens handlings DBGHEXLN(cmd);
mTxBuf[cnt++] = ((data[1] ) ) & 0xff; // setting for persistens handling initPacket(invId, TX_REQ_DEVCONTROL, SINGLE_FRAME);
} uint8_t cnt = 10;
} else { //MI 2nd gen. specific if (isNoMI) {
switch (cmd) { mTxBuf[cnt++] = cmd; // cmd -> 0 on, 1 off, 2 restart, 11 active power, 12 reactive power, 13 power factor
case TurnOn: mTxBuf[cnt++] = 0x00;
//mTxBuf[0] = 0x50; if(cmd >= ActivePowerContr && cmd <= PFSet) { // ActivePowerContr, ReactivePowerContr, PFSet
mTxBuf[9] = 0x55; mTxBuf[cnt++] = ((data[0] * 10) >> 8) & 0xff; // power limit
mTxBuf[10] = 0xaa; mTxBuf[cnt++] = ((data[0] * 10) ) & 0xff; // power limit
break; mTxBuf[cnt++] = ((data[1] ) >> 8) & 0xff; // setting for persistens handlings
case TurnOff: mTxBuf[cnt++] = ((data[1] ) ) & 0xff; // setting for persistens handling
mTxBuf[9] = 0xaa; }
mTxBuf[10] = 0x55; } else { //MI 2nd gen. specific
break; switch (cmd) {
case ActivePowerContr: case TurnOn:
cnt++; //mTxBuf[0] = 0x50;
mTxBuf[9] = 0x5a; mTxBuf[9] = 0x55;
mTxBuf[10] = 0x5a; mTxBuf[10] = 0xaa;
mTxBuf[11] = data[0]; // power limit break;
break; case TurnOff:
default: mTxBuf[9] = 0xaa;
return; mTxBuf[10] = 0x55;
} break;
cnt++; case ActivePowerContr:
} cnt++;
sendPacket(invId, cnt, isRetransmit, isNoMI); mTxBuf[9] = 0x5a;
} mTxBuf[10] = 0x5a;
mTxBuf[11] = data[0]; // power limit
void prepareDevInformCmd(uint64_t invId, uint8_t cmd, uint32_t ts, uint16_t alarmMesId, bool isRetransmit, uint8_t reqfld=TX_REQ_INFO) { // might not be necessary to add additional arg. break;
if(mSerialDebug) { default:
DPRINT(DBG_DEBUG, F("prepareDevInformCmd 0x")); return;
DPRINTLN(DBG_DEBUG,String(cmd, HEX)); }
} cnt++;
initPacket(invId, reqfld, ALL_FRAMES); }
mTxBuf[10] = cmd; // cid sendPacket(invId, cnt, isRetransmit, isNoMI);
mTxBuf[11] = 0x00; }
CP_U32_LittleEndian(&mTxBuf[12], ts);
if (cmd == RealTimeRunData_Debug || cmd == AlarmData ) { void prepareDevInformCmd(uint64_t invId, uint8_t cmd, uint32_t ts, uint16_t alarmMesId, bool isRetransmit, uint8_t reqfld=TX_REQ_INFO) { // might not be necessary to add additional arg.
mTxBuf[18] = (alarmMesId >> 8) & 0xff; if(mSerialDebug) {
mTxBuf[19] = (alarmMesId ) & 0xff; DPRINT(DBG_DEBUG, F("prepareDevInformCmd 0x"));
} DPRINTLN(DBG_DEBUG,String(cmd, HEX));
sendPacket(invId, 24, isRetransmit, true); }
} initPacket(invId, reqfld, ALL_FRAMES);
mTxBuf[10] = cmd; // cid
void sendCmdPacket(uint64_t invId, uint8_t mid, uint8_t pid, bool isRetransmit, bool appendCrc16=true) { mTxBuf[11] = 0x00;
initPacket(invId, mid, pid); CP_U32_LittleEndian(&mTxBuf[12], ts);
sendPacket(invId, 10, isRetransmit, appendCrc16); if (cmd == RealTimeRunData_Debug || cmd == AlarmData ) {
} mTxBuf[18] = (alarmMesId >> 8) & 0xff;
mTxBuf[19] = (alarmMesId ) & 0xff;
void dumpBuf(uint8_t buf[], uint8_t len) { }
//DPRINTLN(DBG_VERBOSE, F("hmRadio.h:dumpBuf")); sendPacket(invId, 24, isRetransmit, true);
for(uint8_t i = 0; i < len; i++) { }
DHEX(buf[i]);
DBGPRINT(" "); void sendCmdPacket(uint64_t invId, uint8_t mid, uint8_t pid, bool isRetransmit, bool appendCrc16=true) {
} initPacket(invId, mid, pid);
DBGPRINTLN(""); sendPacket(invId, 10, isRetransmit, appendCrc16);
} }
uint8_t getDataRate(void) { void dumpBuf(uint8_t buf[], uint8_t len) {
if(!mNrf24.isChipConnected()) //DPRINTLN(DBG_VERBOSE, F("hmRadio.h:dumpBuf"));
return 3; // unkown for(uint8_t i = 0; i < len; i++) {
return mNrf24.getDataRate(); DHEX(buf[i]);
} DBGPRINT(" ");
}
bool isPVariant(void) { DBGPRINTLN("");
return mNrf24.isPVariant(); }
}
uint8_t getDataRate(void) {
std::queue<packet_t> mBufCtrl; if(!mNrf24.isChipConnected())
return 3; // unkown
uint32_t mSendCnt; return mNrf24.getDataRate();
uint32_t mRetransmits; }
bool mSerialDebug; bool isPVariant(void) {
return mNrf24.isPVariant();
private: }
bool getReceived(void) {
bool tx_ok, tx_fail, rx_ready; bool isNewSendChannel ()
mNrf24.whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH {
return mTxChIdx != mTxLastChIdx;
bool isLastPackage = false; }
while(mNrf24.available()) {
uint8_t len; uint8_t getNextSendChannelIndex (void)
len = mNrf24.getDynamicPayloadSize(); // if payload size > 32, corrupt payload has been flushed {
if (len > 0) { // start with the next index: round robbin in case of same max bad quality for all channels
packet_t p; uint8_t bestIndex = (mTxChIdx + 1) % RF_CHANNELS;
p.ch = mRfChLst[mRxChIdx]; uint8_t curIndex = (bestIndex + 1) % RF_CHANNELS;
p.len = len; uint16_t i;
mNrf24.read(p.packet, len);
if (p.packet[0] != 0x00) { for (i=1; i<RF_CHANNELS; i++) {
mBufCtrl.push(p); if (mChQuality[curIndex] > mChQuality[bestIndex]) {
if (p.packet[0] == (TX_REQ_INFO + ALL_FRAMES)) // response from get information command bestIndex = curIndex;
isLastPackage = (p.packet[9] > ALL_FRAMES); // > ALL_FRAMES indicates last packet received }
else if (p.packet[0] == ( 0x0f + ALL_FRAMES) ) // response from MI get information command curIndex = (curIndex + 1) % RF_CHANNELS;
isLastPackage = (p.packet[9] > 0x10); // > 0x10 indicates last packet received }
else if ((p.packet[0] != 0x88) && (p.packet[0] != 0x92)) // ignore fragment number zero and MI status messages //#0 was p.packet[0] != 0x00 && return bestIndex;
isLastPackage = true; // response from dev control command }
}
} void addSendChannelQuality (int8_t quality)
yield(); {
} // continous averaging
return isLastPackage; // assume: mTxChIdx is still the last send channel index used
} quality = mChQuality[mTxChIdx] + quality;
if (quality < SEND_CHANNEL_MIN_QUALITY) {
void initPacket(uint64_t invId, uint8_t mid, uint8_t pid) { quality = SEND_CHANNEL_MIN_QUALITY;
#ifdef undef } else if (quality > SEND_CHANNEL_MAX_QUALITY) {
if(mSerialDebug) { quality = SEND_CHANNEL_MAX_QUALITY;
DPRINT(DBG_VERBOSE, F("initPacket, mid: ")); }
DHEX(mid); mChQuality[mTxChIdx] = quality;
DBGPRINT(F(" pid: ")); }
DBGHEXLN(pid);
} void evalSendChannelQuality (bool crcPass, uint8_t Retransmits, uint8_t rxFragments,
#endif uint8_t lastRxFragments)
memset(mTxBuf, 0, MAX_RF_PAYLOAD_SIZE); {
mTxBuf[0] = mid; // message id if (lastRxFragments == rxFragments) {
CP_U32_BigEndian(&mTxBuf[1], (invId >> 8)); // nothing received: send probably lost
CP_U32_BigEndian(&mTxBuf[5], (DTU_RADIO_ID >> 8)); if (!Retransmits || isNewSendChannel()) {
mTxBuf[9] = pid; // dont overestimate burst distortion
} addSendChannelQuality (SEND_CHANNEL_QUALITY_BAD);
}
void sendPacket(uint64_t invId, uint8_t len, bool isRetransmit, bool appendCrc16=true) { } else if (!lastRxFragments && crcPass) {
//DPRINTLN(DBG_VERBOSE, F("hmRadio.h:sendPacket")); if (!Retransmits || isNewSendChannel()) {
//DPRINTLN(DBG_VERBOSE, "sent packet: #" + String(mSendCnt)); // every fragment received successfull immediately
addSendChannelQuality (SEND_CHANNEL_QUALITY_GOOD);
// append crc's } else {
if (appendCrc16 && (len > 10)) { // every fragment received successfully
// crc control data addSendChannelQuality (SEND_CHANNEL_QUALITY_OK);
uint16_t crc = ah::crc16(&mTxBuf[10], len - 10); }
mTxBuf[len++] = (crc >> 8) & 0xff; } else if (crcPass) {
mTxBuf[len++] = (crc ) & 0xff; if (isNewSendChannel ()) {
} // last Fragment successfully received on new send channel
// crc over all addSendChannelQuality (SEND_CHANNEL_QUALITY_OK);
mTxBuf[len] = ah::crc8(mTxBuf, len); }
len++; } else if (!Retransmits || isNewSendChannel()) {
// no complete receive for this send channel
// set TX and RX channels addSendChannelQuality (SEND_CHANNEL_QUALITY_LOW);
mTxChIdx = (mTxChIdx + 1) % RF_CHANNELS; }
mRxChIdx = (mTxChIdx + 2) % RF_CHANNELS; }
if(mSerialDebug) { void resetSendChannelQuality ()
DPRINT(DBG_INFO, F("TX ")); {
DBGPRINT(String(len)); for(uint8_t i = 0; i < RF_CHANNELS; i++) {
#ifdef undef mChQuality[mTxChIdx] = 0;
DBGPRINT("B Ch"); }
DBGPRINT(String(mRfChLst[mTxChIdx])); }
DBGPRINT(F(" | "));
dumpBuf(mTxBuf, len); void dumpSendQuality()
#else {
DBGPRINTLN (" Bytes"); for(uint8_t i = 0; i < RF_CHANNELS; i++) {
#endif DBGPRINT(" " + String (mChQuality[i]));
} }
}
mNrf24.stopListening();
mNrf24.setChannel(mRfChLst[mTxChIdx]); std::queue<packet_t> mBufCtrl;
mNrf24.openWritingPipe(reinterpret_cast<uint8_t*>(&invId));
mNrf24.startWrite(mTxBuf, len, false); // false = request ACK response uint32_t mSendCnt;
uint32_t mRetransmits;
if(isRetransmit)
mRetransmits++; bool mSerialDebug;
else
mSendCnt++; private:
} bool getReceived(void) {
bool tx_ok, tx_fail, rx_ready;
volatile bool mIrqRcvd; mNrf24.whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH
uint64_t DTU_RADIO_ID;
bool isLastPackage = false;
uint8_t mRfChLst[RF_CHANNELS]; while(mNrf24.available()) {
uint8_t mTxChIdx; uint8_t len;
uint8_t mRxChIdx; len = mNrf24.getDynamicPayloadSize(); // if payload size > 32, corrupt payload has been flushed
if (len > 0) {
SPIClass* mSpi; packet_t p;
RF24 mNrf24; p.ch = mRfChLst[mRxChIdx];
uint8_t mTxBuf[MAX_RF_PAYLOAD_SIZE]; p.len = len;
}; mNrf24.read(p.packet, len);
if (p.packet[0] != 0x00) {
#endif /*__RADIO_H__*/ mBufCtrl.push(p);
if (p.packet[0] == (TX_REQ_INFO + ALL_FRAMES)) // response from get information command
isLastPackage = (p.packet[9] > ALL_FRAMES); // > ALL_FRAMES indicates last packet received
else if (p.packet[0] == ( 0x0f + ALL_FRAMES) ) // response from MI get information command
isLastPackage = (p.packet[9] > 0x10); // > 0x10 indicates last packet received
else if ((p.packet[0] != 0x88) && (p.packet[0] != 0x92)) // ignore fragment number zero and MI status messages //#0 was p.packet[0] != 0x00 &&
isLastPackage = true; // response from dev control command
}
}
yield();
}
return isLastPackage;
}
void initPacket(uint64_t invId, uint8_t mid, uint8_t pid) {
#ifdef undef
if(mSerialDebug) {
DPRINT(DBG_VERBOSE, F("initPacket, mid: "));
DHEX(mid);
DBGPRINT(F(" pid: "));
DBGHEXLN(pid);
}
#endif
memset(mTxBuf, 0, MAX_RF_PAYLOAD_SIZE);
mTxBuf[0] = mid; // message id
CP_U32_BigEndian(&mTxBuf[1], (invId >> 8));
CP_U32_BigEndian(&mTxBuf[5], (DTU_RADIO_ID >> 8));
mTxBuf[9] = pid;
}
void sendPacket(uint64_t invId, uint8_t len, bool isRetransmit, bool appendCrc16=true) {
//DPRINTLN(DBG_VERBOSE, F("hmRadio.h:sendPacket"));
//DPRINTLN(DBG_VERBOSE, "sent packet: #" + String(mSendCnt));
// append crc's
if (appendCrc16 && (len > 10)) {
// crc control data
uint16_t crc = ah::crc16(&mTxBuf[10], len - 10);
mTxBuf[len++] = (crc >> 8) & 0xff;
mTxBuf[len++] = (crc ) & 0xff;
}
// crc over all
mTxBuf[len] = ah::crc8(mTxBuf, len);
len++;
// set TX and RX channels
mTxLastChIdx = mTxChIdx;
mTxChIdx = getNextSendChannelIndex ();
mRxChIdx = (mTxChIdx + 2) % RF_CHANNELS;
if(mSerialDebug) {
#ifdef undef
DPRINT(DBG_INFO, F("TX "));
DBGPRINT(String(len));
DBGPRINT("B Ch");
DBGPRINT(String(mRfChLst[mTxChIdx]));
DBGPRINT(F(" | "));
dumpBuf(mTxBuf, len);
#else
DPRINT(DBG_INFO, F("TX (Ch ") + String (mRfChLst[mTxChIdx]) + "), " +
String (len) + " Bytes, Quality:");
dumpSendQuality();
DBGPRINTLN("");
#endif
}
mNrf24.stopListening();
mNrf24.setChannel(mRfChLst[mTxChIdx]);
mNrf24.openWritingPipe(reinterpret_cast<uint8_t*>(&invId));
mNrf24.startWrite(mTxBuf, len, false); // false = request ACK response
if(isRetransmit)
mRetransmits++;
else
mSendCnt++;
}
volatile bool mIrqRcvd;
uint64_t DTU_RADIO_ID;
uint8_t mRfChLst[RF_CHANNELS];
int8_t mChQuality[RF_CHANNELS];
uint8_t mTxChIdx;
uint8_t mTxLastChIdx;
uint8_t mRxChIdx;
SPIClass* mSpi;
RF24 mNrf24;
uint8_t mTxBuf[MAX_RF_PAYLOAD_SIZE];
};
#endif /*__RADIO_H__*/

Write Preview
Loading…
Cancel
Save