From 4749b5ef3d3a9f69330af07fd8b9c7271fabd371 Mon Sep 17 00:00:00 2001 From: rejoe2 Date: Thu, 18 Jan 2024 14:15:44 +0100 Subject: [PATCH] non blocking version - shorten hms waiting times after last frame es well (might be too short to immedately stop timer!) - timings still need review... --- src/app.cpp | 2 - src/app.h | 1 + src/hm/Communication.h | 145 +++++++++++++++++++++++++--------------- src/hm/hmDefines.h | 6 ++ src/hm/hmInverter.h | 10 ++- src/hm/hmRadio.h | 148 ++++++++++++++++++++++++++--------------- src/hm/radio.h | 11 ++- src/hms/hmsRadio.h | 5 +- 8 files changed, 214 insertions(+), 114 deletions(-) diff --git a/src/app.cpp b/src/app.cpp index c2a1fd6e..97abc790 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -7,8 +7,6 @@ #include "app.h" #include "utils/sun.h" -#define WDT_TIMEOUT_SECONDS 8 // Watchdog Timeout 8s - #if !defined(ESP32) void esp_task_wdt_reset() {} #endif diff --git a/src/app.h b/src/app.h index e6630219..a5438777 100644 --- a/src/app.h +++ b/src/app.h @@ -10,6 +10,7 @@ #include #if defined(ESP32) #include +#define WDT_TIMEOUT_SECONDS 8 // Watchdog Timeout 8s #endif #include "config/settings.h" diff --git a/src/hm/Communication.h b/src/hm/Communication.h index 7b5c84f9..efcb69f8 100644 --- a/src/hm/Communication.h +++ b/src/hm/Communication.h @@ -12,10 +12,6 @@ #include "../utils/timemonitor.h" #include "Heuristic.h" -#define MI_TIMEOUT 250 // timeout for MI type requests -#define FRSTMSG_TIMEOUT 150 // how long to wait for first msg to be received -#define DEFAULT_TIMEOUT 500 // timeout for regular requests -#define SINGLEFR_TIMEOUT 100 // timeout for single frame requests #define MAX_BUFFER 250 typedef std::function *)> payloadListenerType; @@ -65,8 +61,6 @@ class Communication : public CommQueue<> { mLastEmptyQueueMillis = millis(); mPrintSequenceDuration = true; - uint16_t timeout = (q->iv->ivGen == IV_MI) ? MI_TIMEOUT : (((q->iv->mGotFragment && q->iv->mGotLastMsg) || mIsRetransmit) ? SINGLEFR_TIMEOUT : ((q->cmd != AlarmData) && (q->cmd != GridOnProFilePara) ? DEFAULT_TIMEOUT : (1.5 * DEFAULT_TIMEOUT))); - /*if(mDebugState != mState) { DPRINT(DBG_INFO, F("State: ")); DBGHEXLN((uint8_t)(mState)); @@ -94,6 +88,9 @@ class Communication : public CommQueue<> { mFirstTry = q->iv->isAvailable(); q->iv->mCmd = q->cmd; q->iv->mIsSingleframeReq = false; + mFramesExpected = getFramesExpected(q); // function to get expected frame count. + mTimeout = DURATION_TXFRAME + mFramesExpected*DURATION_ONEFRAME + DURATION_RESERVE; + mState = States::START; break; @@ -115,7 +112,8 @@ class Communication : public CommQueue<> { q->iv->radio->prepareDevInformCmd(q->iv, q->cmd, q->ts, q->iv->alarmLastId, false); q->iv->radioStatistics.txCnt++; - mWaitTime.startTimeMonitor(timeout); + q->iv->radio->mRadioWaitTime.startTimeMonitor(mTimeout); + mIsRetransmit = false; setAttempt(); if((q->cmd == AlarmData) || (q->cmd == GridOnProFilePara)) @@ -124,7 +122,7 @@ class Communication : public CommQueue<> { break; case States::WAIT: - if (!mWaitTime.isTimeout()) + if (!q->iv->radio->mRadioWaitTime.isTimeout()) return; mState = States::CHECK_FRAMES; break; @@ -134,7 +132,7 @@ class Communication : public CommQueue<> { if(*mSerialDebug) { DPRINT_IVID(DBG_INFO, q->iv->id); DBGPRINT(F("request timeout: ")); - DBGPRINT(String(mWaitTime.getRunTime())); + DBGPRINT(String(q->iv->radio->mRadioWaitTime.getRunTime())); DBGPRINTLN(F("ms")); } if(!q->iv->mGotFragment) { @@ -150,13 +148,9 @@ class Communication : public CommQueue<> { mHeu.evalTxChQuality(q->iv, false, 0, 0); //q->iv->radioStatistics.rxFailNoAnser++; q->iv->radioStatistics.retransmits++; - mWaitTime.stopTimeMonitor(); + q->iv->radio->mRadioWaitTime.stopTimeMonitor(); mState = States::START; - /*if(*mSerialDebug) { - DPRINT_IVID(DBG_INFO, q->iv->id); - DBGPRINTLN(F("second try")); - }*/ return; } } @@ -196,36 +190,30 @@ class Communication : public CommQueue<> { yield(); } - /*if(0 == q->attempts) { - DPRINT_IVID(DBG_INFO, q->iv->id); - DBGPRINT(F("no attempts left")); - closeRequest(q, false); - } else {*/ - if(q->iv->ivGen != IV_MI) { - mState = States::CHECK_PACKAGE; + if(q->iv->ivGen != IV_MI) { + mState = States::CHECK_PACKAGE; + } else { + bool fastNext = true; + if(q->iv->miMultiParts < 6) { + mState = States::WAIT; + if((q->iv->radio->mRadioWaitTime.isTimeout() && mIsRetransmit) || !mIsRetransmit) { + miRepeatRequest(q); + return; + } } else { - bool fastNext = true; - if(q->iv->miMultiParts < 6) { - mState = States::WAIT; - if((mWaitTime.isTimeout() && mIsRetransmit) || !mIsRetransmit) { - miRepeatRequest(q); - return; - } - } else { - mHeu.evalTxChQuality(q->iv, true, (q->attemptsMax - 1 - q->attempts), q->iv->curFrmCnt); - if(((q->cmd == 0x39) && (q->iv->type == INV_TYPE_4CH)) - || ((q->cmd == MI_REQ_CH2) && (q->iv->type == INV_TYPE_2CH)) - || ((q->cmd == MI_REQ_CH1) && (q->iv->type == INV_TYPE_1CH))) { - miComplete(q->iv); - fastNext = false; - } - if(fastNext) - miNextRequest(q->iv->type == INV_TYPE_4CH ? MI_REQ_4CH : MI_REQ_CH1, q); - else - closeRequest(q, true); + mHeu.evalTxChQuality(q->iv, true, (q->attemptsMax - 1 - q->attempts), q->iv->curFrmCnt); + if(((q->cmd == 0x39) && (q->iv->type == INV_TYPE_4CH)) + || ((q->cmd == MI_REQ_CH2) && (q->iv->type == INV_TYPE_2CH)) + || ((q->cmd == MI_REQ_CH1) && (q->iv->type == INV_TYPE_1CH))) { + miComplete(q->iv); + fastNext = false; } + if(fastNext) + miNextRequest(q->iv->type == INV_TYPE_4CH ? MI_REQ_4CH : MI_REQ_CH1, q); + else + closeRequest(q, true); } - //} + } } break; @@ -321,6 +309,56 @@ class Communication : public CommQueue<> { } } + + inline uint8_t getFramesExpected(const queue_s *q) { + if(q->isDevControl) + return 1; + + if(q->iv->ivGen != IV_MI) { + if (q->cmd == RealTimeRunData_Debug) { + switch (q->iv->type) { // breaks are intentionally missing! + case INV_TYPE_1CH: return 2; + case INV_TYPE_2CH: return 3; + case INV_TYPE_4CH: return 4; + case INV_TYPE_6CH: return 7; + default: return 7; + } + } + + switch (q->cmd) { + case InverterDevInform_All: + case GetLossRate: + case SystemConfigPara: + return 1; + case AlarmData: return 0x0c; + case GridOnProFilePara: return 6; + + /*HardWareConfig = 3, // 0x03 + SimpleCalibrationPara = 4, // 0x04 + RealTimeRunData_Reality = 12, // 0x0c + RealTimeRunData_A_Phase = 13, // 0x0d + RealTimeRunData_B_Phase = 14, // 0x0e + RealTimeRunData_C_Phase = 15, // 0x0f + AlarmUpdate = 18, // 0x12, Alarm data - all pending alarms + RecordData = 19, // 0x13 + InternalData = 20, // 0x14 + GetSelfCheckState = 30, // 0x1e + */ + + default: return 8; // for the moment, this should result in sth. like a default timeout of 500ms + } + + } else { //MI + switch (q->cmd) { + case 0x09: + case 0x11: + return 2; + case 0x0f: return 3; + default: return 1; + } + } + } + inline bool validateIvSerial(uint8_t buf[], Inverter<> *iv) { uint8_t tmp[4]; CP_U32_BigEndian(tmp, iv->radioId.u64 >> 8); @@ -540,15 +578,13 @@ class Communication : public CommQueue<> { } void sendRetransmit(const queue_s *q, uint8_t i) { - //if(q->attempts) { - q->iv->radio->sendCmdPacket(q->iv, TX_REQ_INFO, (SINGLE_FRAME + i), true); - q->iv->radioStatistics.retransmits++; - mWaitTime.startTimeMonitor(SINGLEFR_TIMEOUT); // timeout - mState = States::WAIT; - /*} else { - //add(q, true); - closeRequest(q, false); - }*/ + mFramesExpected = 1; + q->iv->radio->setExpectedFrames(mFramesExpected); + q->iv->radio->sendCmdPacket(q->iv, TX_REQ_INFO, (SINGLE_FRAME + i), true); + q->iv->radioStatistics.retransmits++; + q->iv->radio->mRadioWaitTime.startTimeMonitor(DURATION_TXFRAME + DURATION_ONEFRAME + DURATION_RESERVE); + + mState = States::WAIT; } private: @@ -787,9 +823,11 @@ class Communication : public CommQueue<> { if(q->iv->miMultiParts == 7) q->iv->radioStatistics.rxSuccess++; + mFramesExpected = getFramesExpected(q); + q->iv->radio->setExpectedFrames(mFramesExpected); q->iv->radio->sendCmdPacket(q->iv, cmd, 0x00, true); - mWaitTime.startTimeMonitor(MI_TIMEOUT); + q->iv->radio->mRadioWaitTime.startTimeMonitor(DURATION_TXFRAME + DURATION_ONEFRAME + DURATION_RESERVE); q->iv->miMultiParts = 0; q->iv->mGotFragment = 0; mIsRetransmit = true; @@ -809,8 +847,7 @@ class Communication : public CommQueue<> { q->iv->radio->sendCmdPacket(q->iv, q->cmd, 0x00, true); - mWaitTime.startTimeMonitor(MI_TIMEOUT); - //mState = States::WAIT; + q->iv->radio->mRadioWaitTime.startTimeMonitor(DURATION_TXFRAME + DURATION_ONEFRAME + DURATION_RESERVE); mIsRetransmit = false; } @@ -965,6 +1002,8 @@ class Communication : public CommQueue<> { bool mFirstTry = false; // see, if we should do a second try bool mIsRetransmit = false; // we already had waited one complete cycle uint8_t mMaxFrameId; + uint8_t mFramesExpected = 12; // 0x8c was highest last frame for alarm data + uint16_t mTimeout = 0; // calculating that once should be ok uint8_t mPayload[MAX_BUFFER]; payloadListenerType mCbPayload = NULL; powerLimitAckListenerType mCbPwrAck = NULL; diff --git a/src/hm/hmDefines.h b/src/hm/hmDefines.h index a2a2d6b4..bee67bb8 100644 --- a/src/hm/hmDefines.h +++ b/src/hm/hmDefines.h @@ -86,6 +86,12 @@ enum {INV_TYPE_1CH = 0, INV_TYPE_2CH, INV_TYPE_4CH, INV_TYPE_6CH}; #define FREQ_WARN_MIN_KHZ 863000 // for EU 863 - 870 MHz is allowed #define FREQ_WARN_MAX_KHZ 870000 // for EU 863 - 870 MHz is allowed +#define DURATION_ONEFRAME 50 // timeout parameter for each expected frame (ms) +#define DURATION_RESERVE 90 // timeout parameter to still wait after last expected frame (ms) +#define DURATION_TXFRAME 60 // timeout parameter for first transmission and first expected frame (time to first channel switch from tx start!) (ms) +#define DURATION_LISTEN_MIN 5 // time to stay at least on a listening channel (ms) +#define DURATION_PAUSE_LASTFR 45 // how long to pause after last frame (ms) + typedef struct { uint8_t fieldId; // field id diff --git a/src/hm/hmInverter.h b/src/hm/hmInverter.h index 7bbf1019..ff3343fb 100644 --- a/src/hm/hmInverter.h +++ b/src/hm/hmInverter.h @@ -639,7 +639,13 @@ class Inverter { DBGPRINT(F(", DTU loss: ")); DBGPRINT(String(radioStatistics.dtuLoss)); DBGPRINT(F(" of ")); - DBGPRINTLN(String(radioStatistics.dtuSent)); + if(mAckCount) { + DBGPRINT(String(radioStatistics.dtuSent)); + DBGPRINT(F(". ACKs: ")); + DBGPRINTLN(String(mAckCount)); + mAckCount = 0; + } else + DBGPRINTLN(String(radioStatistics.dtuSent)); } mIvRxCnt = rxCnt; @@ -849,7 +855,7 @@ class Inverter { uint8_t mGetLossInterval = 0; // request iv every AHOY_GET_LOSS_INTERVAL RealTimeRunData_Debug uint16_t mIvRxCnt = 0; uint16_t mIvTxCnt = 0; - + uint16_t mAckCount = 0; }; template diff --git a/src/hm/hmRadio.h b/src/hm/hmRadio.h index 6539dd21..0ef24477 100644 --- a/src/hm/hmRadio.h +++ b/src/hm/hmRadio.h @@ -105,61 +105,88 @@ class HmRadio : public Radio { } void loop(void) { - if (!mIrqRcvd) - return; // nothing to do - mIrqRcvd = false; - bool tx_ok, tx_fail, rx_ready; - mNrf24->whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH - mNrf24->flush_tx(); // empty TX FIFO - - // start listening - uint8_t chOffset = 2; - mRxChIdx = (mTxChIdx + chOffset) % RF_CHANNELS; - mNrf24->setChannel(mRfChLst[mRxChIdx]); - mNrf24->startListening(); + if (!mIrqRcvd && !mNRFisInRX) + return; // first quick check => nothing to do at all here if(NULL == mLastIv) // prevent reading on NULL object! return; - uint32_t innerLoopTimeout = 55000; - uint32_t loopMillis = millis(); - uint32_t outerLoopTimeout = (mLastIv->mIsSingleframeReq) ? 100 : ((mLastIv->mCmd != AlarmData) && (mLastIv->mCmd != GridOnProFilePara)) ? 400 : 600; - bool isRxInit = true; + if(!mIrqRcvd) { // no news from nRF, check timers + if (mRadioWaitTime.isTimeout()) { // timeout reached! + mNRFisInRX = false; + // add stop listening? + return; + } + yield(); - while ((millis() - loopMillis) < outerLoopTimeout) { - uint32_t startMicros = micros(); - while ((micros() - startMicros) < innerLoopTimeout) { // listen (4088us or?) 5110us to each channel - if (mIrqRcvd) { - mIrqRcvd = false; + if (millis() - mTimeslotStart < innerLoopTimeout) + return; // nothing to do - if (getReceived()) { // everything received - return; - } + // otherwise switch to next RX channel + mTimeslotStart = millis(); + rxPendular = !rxPendular; + //innerLoopTimeout = (rxPendular ? 1 : 2)*DURATION_LISTEN_MIN; + innerLoopTimeout = DURATION_LISTEN_MIN; - innerLoopTimeout = 4088*5; - if (isRxInit) { - isRxInit = false; - if (micros() - startMicros < 42000) { - innerLoopTimeout = 4088*12; - mRxChIdx = (mRxChIdx + 4) % RF_CHANNELS; - mNrf24->setChannel(mRfChLst[mRxChIdx]); - } - } + tempRxChIdx = (mRxChIdx + rxPendular*chOffset2) % RF_CHANNELS; + mNrf24->setChannel(mRfChLst[tempRxChIdx]); + isRxInit = false; - startMicros = micros(); - } - yield(); + return; + } + + // here we got news from the nRF + + mNrf24->whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH + mIrqRcvd = false; + + if(tx_ok || tx_fail) { // tx related interrupt, basically we should start listening + mNrf24->flush_tx(); // empty TX FIFO + + if(mNRFisInRX) { + DPRINTLN(DBG_WARN, F("unexpected tx irq!")); + return; } - // switch to next RX channel - mRxChIdx = (mRxChIdx + 4) % RF_CHANNELS; + + mNRFisInRX = true; + if(tx_ok) + mLastIv->mAckCount++; + + // start listening + mRxChIdx = (mTxChIdx + chOffset) % RF_CHANNELS; mNrf24->setChannel(mRfChLst[mRxChIdx]); - innerLoopTimeout = 4088; - isRxInit = false; + mNrf24->startListening(); + mTimeslotStart = millis(); + tempRxChIdx = mRxChIdx; + chOffset2 = mLastIv->ivGen == IV_HM ? 4 : (mLastIv->mCmd == MI_REQ_CH1 || mLastIv->mCmd == MI_REQ_CH2) ? 1 :4; // reversed channel order for everything apart from 1/2ch MI Data requests + rxPendular = false; + + innerLoopTimeout = DURATION_TXFRAME; + } + + if(rx_ready) { + + if (getReceived()) { // check what we got, returns true for last package + mNRFisInRX = false; + mRadioWaitTime.startTimeMonitor(DURATION_PAUSE_LASTFR); // let the inverter first end his transmissions + // add stop listening? + } else { + //rxPendular = true; // stay longer on the next rx channel + + if (isRxInit) { + isRxInit = false; + tempRxChIdx = (mRxChIdx + chOffset2) % RF_CHANNELS; + mNrf24->setChannel(mRfChLst[tempRxChIdx]); + } else { + mRxChIdx = tempRxChIdx; + } + innerLoopTimeout = DURATION_LISTEN_MIN; + mTimeslotStart = millis(); + } + return; } - // not finished but time is over - return; } bool isChipConnected(void) { @@ -264,16 +291,15 @@ class HmRadio : public Radio { private: inline bool getReceived(void) { - bool tx_ok, tx_fail, rx_ready; - mNrf24->whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH bool isLastPackage = false; + rx_ready = false; // reset for ACK case while(mNrf24->available()) { uint8_t len; len = mNrf24->getDynamicPayloadSize(); // if payload size > 32, corrupt payload has been flushed if (len > 0) { packet_t p; - p.ch = mRfChLst[mRxChIdx]; + p.ch = mRfChLst[tempRxChIdx]; p.len = (len > MAX_RF_PAYLOAD_SIZE) ? MAX_RF_PAYLOAD_SIZE : len; p.rssi = mNrf24->testRPD() ? -64 : -75; p.millis = millis() - mMillis; @@ -285,16 +311,18 @@ class HmRadio : public Radio { ah::dumpBuf(p.packet, p.len, 1, 4); else ah::dumpBuf(p.packet, p.len); - return false; + //return false; + } else { + mLastIv->mGotFragment = true; + 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 MI status messages //#0 was p.packet[0] != 0x00 && + isLastPackage = true; // response from dev control command + rx_ready = true; //reset in case we first read messages from other inverter or ACK zero payloads } - mLastIv->mGotFragment = true; - 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 MI status messages //#0 was p.packet[0] != 0x00 && - isLastPackage = true; // response from dev control command } } yield(); @@ -340,6 +368,8 @@ class HmRadio : public Radio { mLastIv = iv; iv->mDtuTxCnt++; + mNRFisInRX = false; + mRqstGetRx = true; // preparation only } uint64_t getIvId(Inverter<> *iv) { @@ -362,8 +392,18 @@ class HmRadio : public Radio { uint8_t mRfChLst[RF_CHANNELS] = {03, 23, 40, 61, 75}; // channel List:2403, 2423, 2440, 2461, 2475MHz uint8_t mTxChIdx = 0; uint8_t mRxChIdx = 0; + uint8_t tempRxChIdx = mRxChIdx; bool mGotLastMsg = false; uint32_t mMillis; + bool tx_ok, tx_fail, rx_ready = false; + uint8_t chOffset = 2; + uint8_t chOffset2 = 4; + unsigned long mTimeslotStart = 0; + bool mNRFisInRX = false; + bool isRxInit = true; + bool rxPendular = false; + uint32_t innerLoopTimeout = DURATION_LISTEN_MIN; + //uint32_t outerLoopTimeout = 400; std::unique_ptr mSpi; std::unique_ptr mNrf24; diff --git a/src/hm/radio.h b/src/hm/radio.h index 1422b285..1db0b361 100644 --- a/src/hm/radio.h +++ b/src/hm/radio.h @@ -13,6 +13,7 @@ #include "../utils/dbg.h" #include "../utils/crc.h" +#include "../utils/timemonitor.h" enum { IRQ_UNKNOWN = 0, IRQ_OK, IRQ_ERROR }; @@ -68,9 +69,14 @@ class Radio { return mDtuSn; } + void setExpectedFrames(uint8_t framesExpected) { + mFramesExpected = framesExpected; + } + public: std::queue mBufCtrl; uint8_t mIrqOk = IRQ_UNKNOWN; + TimeMonitor mRadioWaitTime = TimeMonitor(0, true); // start as expired (due to code in RESET state) protected: virtual void sendPacket(Inverter<> *iv, uint8_t len, bool isRetransmit, bool appendCrc16=true) = 0; @@ -116,13 +122,14 @@ class Radio { mDtuSn |= (t << i); } mDtuSn |= 0x80000000; // the first digit is an 8 for DTU production year 2022, the rest is filled with the ESP chipID in decimal - } + } uint32_t mDtuSn; volatile bool mIrqRcvd; + bool mRqstGetRx; bool *mSerialDebug, *mPrivacyMode, *mPrintWholeTrace; uint8_t mTxBuf[MAX_RF_PAYLOAD_SIZE]; - + uint8_t mFramesExpected = 0x0c; }; #endif /*__RADIO_H__*/ diff --git a/src/hms/hmsRadio.h b/src/hms/hmsRadio.h index 6b502816..443a7d89 100644 --- a/src/hms/hmsRadio.h +++ b/src/hms/hmsRadio.h @@ -163,10 +163,13 @@ class CmtRadio : public Radio { uint8_t status = mCmt.getRx(p.packet, &p.len, 28, &p.rssi); if(CMT_SUCCESS == status) mBufCtrl.push(p); + if(p.packet[9] > ALL_FRAMES) // indicates last frame + mRadioWaitTime.stopTimeMonitor(); // we got everything we expected and can exit rx mode... + //optionally instead: mRadioWaitTime.startTimeMonitor(DURATION_PAUSE_LASTFR); // let the inverter first get back to rx mode? } CmtType mCmt; - bool mRqstGetRx; + //bool mRqstGetRx; bool mCmtAvail; uint32_t mMillis; };