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

@@ -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

src/app.h

@@ -10,6 +10,7 @@
 #include <ArduinoJson.h>
 #if defined(ESP32)
 #include <esp_task_wdt.h>
+#define WDT_TIMEOUT_SECONDS 8   // Watchdog Timeout 8s
 #endif
 
 #include "config/settings.h"

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<void(uint8_t, Inverter<> *)> 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,18 +190,13 @@ 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;
                         } else {
                             bool fastNext = true;
                             if(q->iv->miMultiParts < 6) {
                                 mState = States::WAIT;
-                                    if((mWaitTime.isTimeout() && mIsRetransmit) || !mIsRetransmit) {
+                                if((q->iv->radio->mRadioWaitTime.isTimeout() && mIsRetransmit) || !mIsRetransmit) {
                                     miRepeatRequest(q);
                                     return;
                                 }
@@ -225,7 +214,6 @@ class Communication : public CommQueue<> {
                                     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) {
+            mFramesExpected = 1;
+            q->iv->radio->setExpectedFrames(mFramesExpected);
             q->iv->radio->sendCmdPacket(q->iv, TX_REQ_INFO, (SINGLE_FRAME + i), true);
             q->iv->radioStatistics.retransmits++;
-                mWaitTime.startTimeMonitor(SINGLEFR_TIMEOUT); // timeout
+            q->iv->radio->mRadioWaitTime.startTimeMonitor(DURATION_TXFRAME + DURATION_ONEFRAME + DURATION_RESERVE);
+
             mState = States::WAIT;
-            /*} else {
-                //add(q, true);
-                closeRequest(q, false);
-            }*/
         }
 
     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);
+            q->iv->radio->mRadioWaitTime.startTimeMonitor(DURATION_TXFRAME + DURATION_ONEFRAME + DURATION_RESERVE);
-            //mState = States::WAIT;
             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;

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

src/hm/hmInverter.h

@@ -639,6 +639,12 @@ class Inverter {
                     DBGPRINT(F(", DTU loss: "));
                     DBGPRINT(String(radioStatistics.dtuLoss));
                     DBGPRINT(F(" of "));
+                    if(mAckCount) {
+                        DBGPRINT(String(radioStatistics.dtuSent));
+                        DBGPRINT(F(". ACKs: "));
+                        DBGPRINTLN(String(mAckCount));
+                        mAckCount = 0;
+                    } else
                         DBGPRINTLN(String(radioStatistics.dtuSent));
                 }
 
@@ -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 <class REC_TYP>

src/hm/hmRadio.h

@@ -105,61 +105,88 @@ class HmRadio : public Radio {
         }
 
         void loop(void) {
-            if (!mIrqRcvd)
+            if (!mIrqRcvd && !mNRFisInRX)
-                return; // nothing to do
+                return;         // first quick check => nothing to do at all here
-            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(NULL == mLastIv) // prevent reading on NULL object!
                 return;
 
-            uint32_t innerLoopTimeout = 55000;
+            if(!mIrqRcvd) {     // no news from nRF, check timers
-            uint32_t loopMillis       = millis();
+                if (mRadioWaitTime.isTimeout()) { // timeout reached!
-            uint32_t outerLoopTimeout = (mLastIv->mIsSingleframeReq) ? 100 : ((mLastIv->mCmd != AlarmData) && (mLastIv->mCmd != GridOnProFilePara)) ? 400 : 600;
+                    mNRFisInRX = false;
-            bool isRxInit             = true;
+                    // add stop listening?
+                    return;
+                }
 
+                yield();
+
+                if (millis() - mTimeslotStart < innerLoopTimeout)
+                    return; // nothing to do
+
+                // otherwise switch to next RX channel
+                mTimeslotStart = millis();
+                rxPendular = !rxPendular;
+                //innerLoopTimeout = (rxPendular ? 1 : 2)*DURATION_LISTEN_MIN;
+                innerLoopTimeout = DURATION_LISTEN_MIN;
 
-            while ((millis() - loopMillis) < outerLoopTimeout) {
+                tempRxChIdx = (mRxChIdx + rxPendular*chOffset2) % RF_CHANNELS;
-                uint32_t startMicros = micros();
+                mNrf24->setChannel(mRfChLst[tempRxChIdx]);
-                while ((micros() - startMicros) < innerLoopTimeout) {  // listen (4088us or?) 5110us to each channel
+                isRxInit = false;
-                    if (mIrqRcvd) {
+
+                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 (getReceived()) { // everything received
+            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;
                 }
 
-                        innerLoopTimeout = 4088*5;
+                mNRFisInRX = true;
-                        if (isRxInit) {
+                if(tx_ok)
-                            isRxInit = false;
+                    mLastIv->mAckCount++;
-                            if (micros() - startMicros < 42000) {
+
-                                innerLoopTimeout = 4088*12;
+                // start listening
-                                mRxChIdx = (mRxChIdx + 4) % RF_CHANNELS;
+                mRxChIdx = (mTxChIdx + chOffset) % RF_CHANNELS;
                 mNrf24->setChannel(mRfChLst[mRxChIdx]);
+                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;
             }
-                        }
 
-                        startMicros = micros();
+            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;
                     }
-                    yield();
+                    innerLoopTimeout = DURATION_LISTEN_MIN;
+                    mTimeslotStart = millis();
                 }
-                // switch to next RX channel
+                return;
-                mRxChIdx = (mRxChIdx + 4) % RF_CHANNELS;
-                mNrf24->setChannel(mRfChLst[mRxChIdx]);
-                innerLoopTimeout = 4088;
-                isRxInit = false;
             }
-            // 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,8 +311,8 @@ 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
@@ -295,6 +321,8 @@ class HmRadio : public Radio {
                                 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
+                        }
                     }
                 }
                 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<SPIClass> mSpi;
         std::unique_ptr<RF24> mNrf24;

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<packet_t> 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;
@@ -120,9 +126,10 @@ class Radio {
 
         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__*/

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;
 };