3pp-mirror/ahoy
1
0
Fork 0
mirror of https://github.com/lumapu/ahoy.git synced 2025-05-10 23:46:37 +02:00
Code Issues Projects Releases Packages Wiki Activity

non blocking version

Browse source 
- shorten hms waiting times after last frame es well (might be too short to immedately stop timer!)
- timings still need review...
This commit is contained in:
rejoe2 2024-01-18 14:15:44 +01:00 • committed by GitHub
parent c3a2ad0a97
commit 4749b5ef3d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 222 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/app.cpp
View file

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

1
src/app.h
View file

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

99
src/hm/Communication.h
View file

@ -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);
//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;

6
src/hm/hmDefines.h
View file

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

8
src/hm/hmInverter.h
View file

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

128
src/hm/hmRadio.h
View file

@ -105,63 +105,90 @@ 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) {
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;
tempRxChIdx = (mRxChIdx + rxPendular*chOffset2) % RF_CHANNELS;
mNrf24->setChannel(mRfChLst[tempRxChIdx]);
isRxInit = false;
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(tx_ok)
mLastIv->mAckCount++;
// start listening
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;
}
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;
if (micros() - startMicros < 42000) {
innerLoopTimeout = 4088*12;
mRxChIdx = (mRxChIdx + 4) % RF_CHANNELS;
mNrf24->setChannel(mRfChLst[mRxChIdx]);
tempRxChIdx = (mRxChIdx + chOffset2) % RF_CHANNELS;
mNrf24->setChannel(mRfChLst[tempRxChIdx]);
} else {
mRxChIdx = tempRxChIdx;
}
innerLoopTimeout = DURATION_LISTEN_MIN;
mTimeslotStart = millis();
}
startMicros = micros();
}
yield();
}
// switch to next RX channel
mRxChIdx = (mRxChIdx + 4) % RF_CHANNELS;
mNrf24->setChannel(mRfChLst[mRxChIdx]);
innerLoopTimeout = 4088;
isRxInit = false;
}
// not finished but time is over
return;
}
}
bool isChipConnected(void) {
//DPRINTLN(DBG_VERBOSE, F("hmRadio.h:isChipConnected"));
return mNrf24->isChipConnected();
@ -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;

9
src/hm/radio.h
View file

@ -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__*/

5
src/hms/hmsRadio.h
View file

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