it seems to work

Author: functionpointer

lib/Hoymiles/src/FrequencyManager.cpp

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#pragma once
+
+class FrequencyManager {
+
+
+}

lib/Hoymiles/src/FrequencyManager.h

@@ -75,5 +75,5 @@ bool ChannelChangeCommand::handleResponse(const fragment_t fragment[], const uin
 uint8_t ChannelChangeCommand::getMaxResendCount() const
 {
     // This command will never retrieve an answer. Repeat anyway to allow FrequencyManager to send it on a few different frequencies.
-    return 5;
+    return MAX_RESEND_COUNT;
 }

lib/Hoymiles/src/commands/ChannelChangeCommand.cpp

@@ -17,7 +17,7 @@ bool isChangeChannelCmd(CommandAbstract &cmd) {
 
 uint32_t FrequencyManager_CMT::getTXFrequency(CommandAbstract& cmd) {
     uint32_t freq = this->_getFrequency(cmd);
-    if (isChangeChannelCmd(cmd) && freq == Hoymiles.getRadioCmt()->getInverterTargetFrequency()) { 
+    if (isChangeChannelCmd(cmd) && freq == Hoymiles.getRadioCmt()->getInverterTargetFrequency()) {
         return Hoymiles.getRadioCmt()->getInvBootFrequency();
     }
     return freq;
@@ -30,27 +30,46 @@ uint32_t FrequencyManager_CMT::getRXFrequency(CommandAbstract& cmd) {
     return this->_getFrequency(cmd);
 }
 
-uint32_t _get_cmt_search_frequency(int failed_fetch_count, uint8_t cmd_send_count, uint32_t inverter_target_frequency, uint32_t min_frequency, uint32_t max_frequency, uint32_t legal_min_frequency, uint32_t legal_max_frequency, uint32_t channel_width) {
-    uint8_t cmd_retransmit_count = cmd_send_count-1;
-    int8_t offset = ((failed_fetch_count + cmd_retransmit_count) % 20) * (cmd_retransmit_count%2==0?-1:1);
-        
+// https://stackoverflow.com/a/14997413
+inline int positive_modulo(int i, int n) {
+    return (i % n + n) % n;
+}
+
+uint32_t _get_cmt_search_frequency(int failed_fetch_count, int cmd_send_count, uint32_t inverter_target_frequency, uint32_t min_frequency, uint32_t max_frequency, uint32_t legal_min_frequency, uint32_t legal_max_frequency, uint32_t channel_width) {
+    // cmt_send_count gets incremented in sendEsbPacket just before we are called; we do -1 to undo this
+    // _getFrequency also grabs the first transmission, setting it to inverterTargetFrequency. we do -1 to undo this as well
+    int cmd_transmissions_we_did = cmd_send_count-2; // how often this particular command has already been sent on a freq determined by this function
+
+    // failed_fetch_count starts at 1, due to how startsNextFetch counts
+    int fetches_we_did = failed_fetch_count - 1;
+
+    int offset2 = (fetches_we_did + (cmd_transmissions_we_did/2)) % 20;
+    int offset3 = offset2 * (cmd_transmissions_we_did%2==0?-1:1);
+
     uint32_t min_usable_freq = max(min_frequency, legal_min_frequency);
     uint32_t max_usable_freq = min(max_frequency, legal_max_frequency);
-    int8_t min_offset = -((inverter_target_frequency - min_usable_freq)/channel_width);
-    int8_t max_offset = (max_usable_freq - inverter_target_frequency)/channel_width;
+    int min_offset = -((inverter_target_frequency - min_usable_freq)/channel_width);
+    int max_offset = (max_usable_freq - inverter_target_frequency)/channel_width;
+
+    int final_offset = (positive_modulo(offset3 - min_offset, max_offset + 1 - min_offset)) + min_offset;
 
-    offset = ((offset - min_offset) % (max_offset - min_offset)) + min_offset;
-    
-    return inverter_target_frequency + (offset*channel_width);
+    int ret = inverter_target_frequency + (final_offset*channel_width);
+    Hoymiles.getMessageOutput()->printf("cmt_search_frequency min_offset=%" PRId32 " max_offset=%" PRId32 "\r\n", min_offset, max_offset);
+    Hoymiles.getMessageOutput()->printf("cmt_search_frequency failed_fetch_count=%" PRId32 " cmd_send_count=%" PRId32 " now trying %.3f MHz\r\n", failed_fetch_count, cmd_send_count, ret / 1000000.0);
+    Hoymiles.getMessageOutput()->printf("cmt_search_frequency offset2 %" PRId32 " offset3 %" PRId32 " final_offset %" PRId32 " \r\n", offset2, offset3, final_offset);
+    return ret;
 }
 
 uint32_t FrequencyManager_CMT::_getFrequency(CommandAbstract& cmd) {
     HoymilesRadio_CMT *radio = Hoymiles.getRadioCmt();
     uint32_t tgt_freq = radio->getInverterTargetFrequency();
-    uint8_t cmd_retransmit_count = cmd.getSendCount()-1;
+    int cmd_retransmit_count = cmd.getSendCount()-1;
 
-    if(this->_inv->isReachable() || this->_failedFetchCount == -1) {
-        // _lastWorkingFrequency was apparently working
+    if (_lastWorkingFrequency == 0) {
+        return tgt_freq; // see shouldSendChangeChannelCommand
+    }
+    if(this->_inv->isReachable() || this->_failedFetchCount <= 0) {
+        // _lastWorkingFrequency was working
         bool isOnTgtFreq = this->_lastWorkingFrequency == tgt_freq;
         if(isOnTgtFreq) {
             return tgt_freq;
@@ -86,7 +105,14 @@ void FrequencyManager_CMT::processRXResult(CommandAbstract *cmd, uint8_t verify_
 
 
 bool FrequencyManager_CMT::shouldSendChangeChannelCommand() {
-    return this->_lastWorkingFrequency != Hoymiles.getRadioCmt()->getInverterTargetFrequency() || (!this->_inv->isReachable());
+    if (!this->_inv->isReachable()) {
+        return true;
+    } else {
+        if (this->_lastWorkingFrequency == 0) {
+            return false; // 0 means FRAGMENT_OK was never received, i.e. no packet since OpenDTU boot. return false to preserve old startup sequence
+        }
+        return this->_lastWorkingFrequency != Hoymiles.getRadioCmt()->getInverterTargetFrequency();
+    }
 }
 
 void FrequencyManager_CMT::startNextFetch() {
@@ -95,4 +121,4 @@ void FrequencyManager_CMT::startNextFetch() {
     } else {
         this->_failedFetchCount++;
     }
-}
+}

lib/Hoymiles/src/frequencymanagers/FrequencyManager_CMT.cpp

@@ -23,4 +23,4 @@ class FrequencyManager_CMT:public FrequencyManagerAbstract {
     int _failedFetchCount = -1;
 };
 
-uint32_t _get_cmt_search_frequency(int failed_fetch_count, uint8_t cmd_send_count, uint32_t inverter_target_frequency, uint32_t min_frequency, uint32_t max_frequency, uint32_t legal_min_frequency, uint32_t legal_max_frequency, uint32_t channel_width);
+uint32_t _get_cmt_search_frequency(int failed_fetch_count, int cmd_send_count, uint32_t inverter_target_frequency, uint32_t min_frequency, uint32_t max_frequency, uint32_t legal_min_frequency, uint32_t legal_max_frequency, uint32_t channel_width);

lib/Hoymiles/src/frequencymanagers/FrequencyManager_CMT.h

@@ -6,10 +6,12 @@
 #include "Hoymiles.h"
 #include "HoymilesRadio_CMT.h"
 #include "commands/ChannelChangeCommand.h"
+#include "frequencymanagers/FrequencyManager_CMT.h"
 
 HMS_Abstract::HMS_Abstract(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial)
 {
+    _frequencyManager.reset(new FrequencyManager_CMT(this));
 }
 
 bool HMS_Abstract::sendChangeChannelRequest()

lib/Hoymiles/src/inverters/HMS_Abstract.cpp

@@ -7,13 +7,11 @@
 #include "HoymilesRadio_CMT.h"
 #include "commands/ChannelChangeCommand.h"
 #include "parser/AlarmLogParser.h"
-#include "frequencymanagers/FrequencyManager_CMT.h"
 
 HMT_Abstract::HMT_Abstract(HoymilesRadio* radio, const uint64_t serial)
     : HM_Abstract(radio, serial)
 {
     EventLog()->setMessageType(AlarmMessageType_t::HMT);
-    _frequencyManager.reset(new FrequencyManager_CMT(this));
 }
 
 bool HMT_Abstract::sendChangeChannelRequest()