diff --git a/src/app.cpp b/src/app.cpp index bd7d3965..c1519bfc 100644 --- a/src/app.cpp +++ b/src/app.cpp @@ -129,8 +129,8 @@ void app::loopStandard(void) { DBGPRINT(F(" | ")); mSys.Radio.dumpBuf(p->packet, p->len); #else - DPRINTLN(DBG_INFO, "RX (Ch " + String (p->ch) + "), " + - String (p->len) + " Bytes"); + DPRINTLN(DBG_INFO, "RX (Ch " + String (p->ch) + "), Delay " + String (p->delay) + + " us, " + String (p->len) + " Bytes"); #endif } diff --git a/src/defines.h b/src/defines.h index 1ac68345..14373a4b 100644 --- a/src/defines.h +++ b/src/defines.h @@ -19,9 +19,17 @@ typedef struct { uint8_t ch; uint8_t len; + long delay; // micros since preceeding tx_fail irq and this rx_ready irq uint8_t packet[MAX_RF_PAYLOAD_SIZE]; } packet_t; +typedef enum { // for radio special handling + INV_TYPE_DEFAULT, + INV_TYPE_HMCH1, + INV_TYPE_HMCH2, + INV_TYPE_HMCH4, +} inv_type_t; + typedef enum { InverterDevInform_Simple = 0, // 0x00 InverterDevInform_All = 1, // 0x01 diff --git a/src/hm/hmInverter.h b/src/hm/hmInverter.h index 51328508..b05a71ca 100644 --- a/src/hm/hmInverter.h +++ b/src/hm/hmInverter.h @@ -408,6 +408,22 @@ class Inverter { } } + inv_type_t getType () { + if (ivGen == IV_HM) { + switch (type) { + case INV_TYPE_1CH: + return INV_TYPE_HMCH1; + case INV_TYPE_2CH: + return INV_TYPE_HMCH2; + case INV_TYPE_4CH: + return INV_TYPE_HMCH4; + default: + return INV_TYPE_DEFAULT; + } + } + return INV_TYPE_DEFAULT; + } + bool isAvailable(uint32_t timestamp) { if((timestamp - recordMeas.ts) < INACT_THRES_SEC) return true; diff --git a/src/hm/hmPayload.h b/src/hm/hmPayload.h index 7b073bf6..f94fdecf 100644 --- a/src/hm/hmPayload.h +++ b/src/hm/hmPayload.h @@ -157,7 +157,7 @@ class HmPayload { DBGPRINT(F(" power limit ")); DBGPRINTLN(String(iv->powerLimit[0])); } - mSys->Radio.sendControlPacket(iv->radioId.u64, + mSys->Radio.sendControlPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), iv->devControlCmd, iv->powerLimit, false); mPayload[iv->id].txCmd = iv->devControlCmd; //iv->clearCmdQueue(); @@ -167,7 +167,7 @@ class HmPayload { DPRINT_IVID(DBG_INFO, iv->id); DBGPRINT(F("prepareDevInformCmd 0x")); DBGHEXLN(cmd); - mSys->Radio.prepareDevInformCmd(iv->radioId.u64, + mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), cmd, mPayload[iv->id].ts, iv->alarmMesIndex, false); mPayload[iv->id].txCmd = cmd; } @@ -271,7 +271,7 @@ class HmPayload { } else if(iv->devControlCmd == ActivePowerContr) { DPRINT_IVID(DBG_INFO, iv->id); DPRINTLN(DBG_INFO, F("retransmit power limit")); - mSys->Radio.sendControlPacket(iv->radioId.u64, + mSys->Radio.sendControlPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), iv->devControlCmd, iv->powerLimit, true); } else { if(false == mPayload[iv->id].gotFragment) { @@ -284,7 +284,7 @@ class HmPayload { mPayload[iv->id].txCmd = iv->getQueuedCmd(); DPRINTLN(DBG_INFO, F("(#") + String(iv->id) + F(") prepareDevInformCmd 0x") + String(mPayload[iv->id].txCmd, HEX)); - mSys->Radio.prepareDevInformCmd(iv->radioId.u64, + mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); } } else { @@ -294,7 +294,7 @@ class HmPayload { DBGPRINT(F("Frame ")); DBGPRINT(String(i + 1)); DBGPRINTLN(F(" missing: Request Retransmit")); - mSys->Radio.sendCmdPacket(iv->radioId.u64, + mSys->Radio.sendCmdPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex (), TX_REQ_INFO, (SINGLE_FRAME + i), true); break; // only request retransmit one frame per loop } @@ -315,7 +315,7 @@ class HmPayload { DPRINT_IVID(DBG_INFO, iv->id); DBGPRINT(F("prepareDevInformCmd 0x")); DBGHEXLN(mPayload[iv->id].txCmd); - mSys->Radio.prepareDevInformCmd(iv->radioId.u64, + mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex (), mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); } else if (false == mPayload[iv->id].gotFragment) { // only if there is no sign of life diff --git a/src/hm/hmRadio.h b/src/hm/hmRadio.h index 798fa1c6..f14e8684 100644 --- a/src/hm/hmRadio.h +++ b/src/hm/hmRadio.h @@ -19,9 +19,39 @@ #define ALL_FRAMES 0x80 #define SINGLE_FRAME 0x81 +#define RX_ANSWER_TMO 400 +#define RX_WAIT_SFR_TMO 40 +#define RX_WAIT_SAFETY_MRGN 20 + +#define RX_CHAN_TMO 5110 +#define RX_CHAN_MHCH1_TMO 10220 + +#define RX_DEF_MAX_CHANNELS RF_CHANNELS +#define RX_HMCH1_MAX_CHANNELS 2 const char* const rf24AmpPowerNames[] = {"MIN", "LOW", "HIGH", "MAX"}; +// Depending on the program, the module can work on 2403, 2423, 2440, 2461 or 2475MHz. +// Channel List 2403, 2423, 2440, 2461, 2475MHz +const uint8_t rf24ChLst[RF_CHANNELS] = { 3, 23, 40, 61, 75 }; + +// default rx channel hopping +const uint8_t rf24RxDefChan[5][5] = { + { 40, 61, 75, 3, 23 }, + { 61, 75, 3, 23, 40 }, + { 75, 3, 23, 40, 61 }, + { 3, 23, 40, 61, 75 }, + { 23, 40, 61, 75, 03 } +}; + +// reduced rx channel hopping for HM Inverter with only 1 Input (HM300 testet) +const uint8_t rf24RxHMCh1[5][5] = { // same formal array size for each variant + { 40, 61 }, + { 61, 75 }, + { 75, 75 /* 3 */ }, /* some strange problems with rx 3 especially here, so take 75 doubled instead */ + { 3, 23 }, + { 23, 40 } +}; //----------------------------------------------------------------------------- // MACROS @@ -61,14 +91,6 @@ class HmRadio { DBGPRINTLN(F(")")); } - // Depending on the program, the module can work on 2403, 2423, 2440, 2461 or 2475MHz. - // Channel List 2403, 2423, 2440, 2461, 2475MHz - mRfChLst[0] = 03; - mRfChLst[1] = 23; - mRfChLst[2] = 40; - mRfChLst[3] = 61; - mRfChLst[4] = 75; - // default channels mTxChIdx = AHOY_RF24_DEF_TX_CHANNEL; mRxChIdx = AHOY_RF24_DEF_RX_CHANNEL; @@ -118,7 +140,7 @@ class HmRadio { mNrf24.begin(mSpi, ce, cs); mNrf24.setRetries(3, 15); // 3*250us + 250us and 15 loops -> 15ms - mNrf24.setChannel(mRfChLst[mRxChIdx]); + mNrf24.setChannel(rf24RxDefChan[AHOY_RF24_DEF_TX_CHANNEL][AHOY_RF24_DEF_RX_CHANNEL]); mNrf24.startListening(); mNrf24.setDataRate(RF24_250KBPS); mNrf24.setAutoAck(true); @@ -151,16 +173,17 @@ class HmRadio { mNrf24.flush_tx(); // empty TX FIFO // start listening - mNrf24.setChannel(mRfChLst[mRxChIdx]); + mNrf24.setChannel(mRxChannels[mRxChIdx]); mNrf24.startListening(); uint32_t startMicros = micros(); uint32_t loopMillis = millis(); - while (millis()-loopMillis < 400) { - while (micros()-startMicros < 5110) { // listen (4088us or?) 5110us to each channel + while (millis()-loopMillis < mRxAnswerTmo) { + while (micros()-startMicros < mRxChanTmo ) { if (mIrqRcvd) { mIrqRcvd = false; if (getReceived()) { // everything received + return true; } } @@ -168,9 +191,10 @@ class HmRadio { } // switch to next RX channel startMicros = micros(); - if(++mRxChIdx >= RF_CHANNELS) + if(++mRxChIdx >= mMaxRxChannels) { mRxChIdx = 0; - mNrf24.setChannel(mRfChLst[mRxChIdx]); + } + mNrf24.setChannel(mRxChannels[mRxChIdx]); yield(); } // not finished but time is over @@ -178,6 +202,10 @@ class HmRadio { } void handleIntr(void) { + if (mRfIrqIndex < MAX_PAYLOAD_ENTRIES) { + // it is allowed to call micros() inside irq handler to read the time (but check for unexpected restart reasons) + mRfIrqTime[mRfIrqIndex++] = micros(); // remember Time of tx_fail and rx_readies + } mIrqRcvd = true; } @@ -189,9 +217,10 @@ class HmRadio { mSerialDebug = true; } - void sendControlPacket(uint64_t invId, uint8_t rf_ch, uint8_t cmd, uint16_t *data, bool isRetransmit, bool isNoMI = true) { + void sendControlPacket(uint64_t invId, inv_type_t invType, uint8_t txChan, uint8_t cmd, uint16_t *data, bool isRetransmit, bool isNoMI = true) { DPRINT(DBG_INFO, F("sendControlPacket cmd: 0x")); DBGHEXLN(cmd); + prepareReceive (invType, txChan, 1); initPacket(invId, TX_REQ_DEVCONTROL, SINGLE_FRAME); uint8_t cnt = 10; if (isNoMI) { @@ -225,14 +254,17 @@ class HmRadio { } cnt++; } - sendPacket(invId, rf_ch, cnt, isRetransmit, isNoMI); + sendPacket(invId, txChan, cnt, isRetransmit, isNoMI); } - void prepareDevInformCmd(uint64_t invId, uint8_t rf_ch, 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. + void prepareDevInformCmd(uint64_t invId, inv_type_t invType, uint8_t txChan, 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. if(mSerialDebug) { DPRINT(DBG_DEBUG, F("prepareDevInformCmd 0x")); DPRINTLN(DBG_DEBUG,String(cmd, HEX)); } + prepareReceive (invType, txChan, + // could be optimized for other inverter types as well + ((cmd == RealTimeRunData_Debug) && (invType == INV_TYPE_HMCH1)) ? 2 : 10); initPacket(invId, reqfld, ALL_FRAMES); mTxBuf[10] = cmd; // cid mTxBuf[11] = 0x00; @@ -246,12 +278,13 @@ class HmRadio { mTxBuf[18] = (alarmMesId >> 8) & 0xff; mTxBuf[19] = (alarmMesId ) & 0xff; } - sendPacket(invId, rf_ch, 24, isRetransmit, true); + sendPacket(invId, txChan, 24, isRetransmit, true); } - void sendCmdPacket(uint64_t invId, uint8_t rf_ch, uint8_t mid, uint8_t pid, bool isRetransmit, bool appendCrc16=true) { + void sendCmdPacket(uint64_t invId, inv_type_t invType, uint8_t txChan, uint8_t mid, uint8_t pid, bool isRetransmit, bool appendCrc16=true) { + prepareReceive (invType, txChan, 1); initPacket(invId, mid, pid); - sendPacket(invId, rf_ch, 10, isRetransmit, appendCrc16); + sendPacket(invId, txChan, 10, isRetransmit, appendCrc16); } void dumpBuf(uint8_t buf[], uint8_t len) { @@ -281,6 +314,24 @@ class HmRadio { bool mSerialDebug; private: + void prepareReceive (inv_type_t invType, uint8_t txChan, uint8_t rxFrameCnt) { + if (invType == INV_TYPE_HMCH1) { + mRxChannels = (uint8_t *)(rf24RxHMCh1[txChan]); + mMaxRxChannels = RX_HMCH1_MAX_CHANNELS; + mRxAnswerTmo = rxFrameCnt * RX_WAIT_SFR_TMO; // typical inverter answer has 2 packets + mRxAnswerTmo += RX_WAIT_SAFETY_MRGN; + if (mRxAnswerTmo > RX_ANSWER_TMO) { + mRxAnswerTmo = RX_ANSWER_TMO; + } + mRxChanTmo = RX_CHAN_MHCH1_TMO; + } else { + mRxChannels = (uint8_t *)(rf24RxDefChan[txChan]); + mMaxRxChannels = RX_DEF_MAX_CHANNELS; + mRxAnswerTmo = RX_ANSWER_TMO; + mRxChanTmo = RX_CHAN_TMO; + } + } + bool getReceived(void) { bool tx_ok, tx_fail, rx_ready; mNrf24.whatHappened(tx_ok, tx_fail, rx_ready); // resets the IRQ pin to HIGH @@ -288,11 +339,15 @@ class HmRadio { bool isLastPackage = false; 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 = mRxChannels[mRxChIdx]; p.len = len; + if (mRfIrqIndex) { + p.delay = mRfIrqTime[mRfIrqIndex - 1] - mRfIrqTime[0]; + } mNrf24.read(p.packet, len); if (p.packet[0] != 0x00) { mBufCtrl.push(p); @@ -343,24 +398,25 @@ class HmRadio { // set TX and RX channels mTxChIdx = rf_ch; - mRxChIdx = (mTxChIdx + 2) % RF_CHANNELS; + mRxChIdx = 0; if(mSerialDebug) { #ifdef undef DPRINT(DBG_INFO, F("TX ")); DBGPRINT(String(len)); DBGPRINT("B Ch"); - DBGPRINT(String(mRfChLst[mTxChIdx])); + DBGPRINT(String(rf24ChLst[mTxChIdx])); DBGPRINT(F(" | ")); dumpBuf(mTxBuf, len); #else - DPRINTLN(DBG_INFO, F("TX (Ch ") + String (mRfChLst[mTxChIdx]) + "), " + + DPRINTLN(DBG_INFO, F("TX (Ch ") + String (rf24ChLst[mTxChIdx]) + "), " + String (len) + " Bytes"); #endif } mNrf24.stopListening(); - mNrf24.setChannel(mRfChLst[mTxChIdx]); + mNrf24.setChannel(rf24ChLst[mTxChIdx]); mNrf24.openWritingPipe(reinterpret_cast(&invId)); + mRfIrqIndex = 0; mNrf24.startWrite(mTxBuf, len, false); // false = request ACK response if(isRetransmit) @@ -371,15 +427,18 @@ class HmRadio { volatile bool mIrqRcvd; uint64_t DTU_RADIO_ID; - - uint8_t mRfChLst[RF_CHANNELS]; + volatile uint8_t mRfIrqIndex; + volatile long mRfIrqTime[1 + MAX_PAYLOAD_ENTRIES]; SPIClass* mSpi; RF24 mNrf24; uint8_t mTxBuf[MAX_RF_PAYLOAD_SIZE]; uint8_t mTxChIdx; - uint8_t mRxChIdx; - + uint8_t mRxChIdx; // cur index in mRxChannels + uint8_t *mRxChannels; // rx channel to be used; depends on inverter and previous tx channel + uint8_t mMaxRxChannels; // actual size of mRxChannels; depends on inverter and previous tx channel + uint32 mRxAnswerTmo; // max wait time in millis for answers of inverter + uint32 mRxChanTmo; // max wait time in micros for a rx channel }; #endif /*__RADIO_H__*/ diff --git a/src/hm/miPayload.h b/src/hm/miPayload.h index 2ee669b0..2ba5467b 100644 --- a/src/hm/miPayload.h +++ b/src/hm/miPayload.h @@ -126,7 +126,7 @@ class MiPayload { DBGPRINT(F(" power limit ")); DBGPRINTLN(String(iv->powerLimit[0])); } - mSys->Radio.sendControlPacket(iv->radioId.u64, + mSys->Radio.sendControlPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), iv->devControlCmd, iv->powerLimit, false, false); mPayload[iv->id].txCmd = iv->devControlCmd; mPayload[iv->id].limitrequested = true; @@ -151,11 +151,11 @@ class MiPayload { if (cmd == 0x01 || cmd == SystemConfigPara ) { //0x1 and 0x05 for HM-types cmd = 0x0f; // for MI, these seem to make part of the Polling the device software and hardware version number command cmd2 = cmd == SystemConfigPara ? 0x01 : 0x00; //perhaps we can only try to get second frame? - mSys->Radio.sendCmdPacket(iv->radioId.u64, + mSys->Radio.sendCmdPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), cmd, cmd2, false, false); } else { - //mSys->Radio.prepareDevInformCmd(iv->radioId.u64, cmd2, mPayload[iv->id].ts, iv->alarmMesIndex, false, cmd); - mSys->Radio.sendCmdPacket(iv->radioId.u64, + //mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), cmd2, mPayload[iv->id].ts, iv->alarmMesIndex, false, cmd); + mSys->Radio.sendCmdPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), cmd, cmd2, false, false); }; @@ -454,7 +454,7 @@ const byteAssign_t InfoAssignment[] = { } else if(iv->devControlCmd == ActivePowerContr) { DPRINT_IVID(DBG_INFO, iv->id); DBGPRINTLN(F("retransmit power limit")); - mSys->Radio.sendControlPacket(iv->radioId.u64, + mSys->Radio.sendControlPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), iv->devControlCmd, iv->powerLimit, true, false); } else { uint8_t cmd = mPayload[iv->id].txCmd; @@ -466,7 +466,7 @@ const byteAssign_t InfoAssignment[] = { mPayload[iv->id].retransmits = mMaxRetrans; } else if ( cmd == 0x0f ) { //hard/firmware request - mSys->Radio.sendCmdPacket(iv->radioId.u64, + mSys->Radio.sendCmdPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), 0x0f, 0x00, true, false); //iv->setQueuedCmdFinished(); //cmd = iv->getQueuedCmd(); @@ -504,9 +504,9 @@ const byteAssign_t InfoAssignment[] = { } DBGPRINT(F(" 0x")); DBGHEXLN(cmd); - mSys->Radio.sendCmdPacket(iv->radioId.u64, + mSys->Radio.sendCmdPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), cmd, cmd, true, false); - //mSys->Radio.prepareDevInformCmd(iv->radioId.u64, cmd, mPayload[iv->id].ts, iv->alarmMesIndex, true, cmd); + //mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->getType, iv->getNextTxChanIndex(), cmd, mPayload[iv->id].ts, iv->alarmMesIndex, true, cmd); yield(); } } @@ -522,8 +522,8 @@ const byteAssign_t InfoAssignment[] = { DBGPRINT(F("prepareDevInformCmd 0x")); DBGHEXLN(mPayload[iv->id].txCmd); - //mSys->Radio.prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); - mSys->Radio.sendCmdPacket(iv->radioId.u64, + //mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); + mSys->Radio.sendCmdPacket(iv->radioId.u64, iv->getType(), iv->getNextTxChanIndex(), mPayload[iv->id].txCmd, mPayload[iv->id].txCmd, false, false); } } @@ -712,7 +712,7 @@ const byteAssign_t InfoAssignment[] = { if (p->packet[0] < (0x39 + ALL_FRAMES) ) { /*uint8_t cmd = p->packet[0] - ALL_FRAMES + 1; - mSys->Radio.prepareDevInformCmd(iv->radioId.u64, + mSys->Radio.prepareDevInformCmd(iv->radioId.u64, iv->geTType(), iv->getNextTxChanIndex(), cmd, mPayload[iv->id].ts, iv->alarmMesIndex, false, cmd); mPayload[iv->id].txCmd = cmd;*/ mPayload[iv->id].txCmd++; diff --git a/src/plugins/SML_OBIS_Parser.cpp b/src/plugins/SML_OBIS_Parser.cpp index bb25eee8..75c37913 100644 --- a/src/plugins/SML_OBIS_Parser.cpp +++ b/src/plugins/SML_OBIS_Parser.cpp @@ -409,7 +409,7 @@ void sml_handle_obis_state (unsigned char *buf) { #ifdef undef if (sml_trace_obis) { - DPRINTLN(DBG_INFO, "OBIS " + String(buf[0], HEX) + "-" + String(buf[1], HEX) + ":" + String(buf[2], HEX) + + DPRINTLN(DBG_INFO, "OBIS: " + String(buf[0], HEX) + "-" + String(buf[1], HEX) + ":" + String(buf[2], HEX) + "." + String (buf[3], HEX) + "." + String(buf[4], HEX) + "*" + String(buf[5], HEX)); } #endif @@ -481,7 +481,7 @@ int64_t sml_obis_get_int (unsigned char *data, unsigned int len) int64_t value = 0; if (len > 8) { - DPRINTLN(DBG_WARN, "Int too big"); + DPRINTLN(DBG_WARN, "SML: Int too big"); } else { unsigned int i; @@ -672,7 +672,7 @@ bool sml_get_list_entries (uint16_t layer) sml_msg_crc = sml_finit_crc (sml_msg_crc); if (rcv_crc != sml_msg_crc) { - DPRINTLN(DBG_WARN, "Wrong CRC for msg 0x" + String (sml_message, HEX) + + DPRINTLN(DBG_WARN, "SML: Wrong CRC for msg 0x" + String (sml_message, HEX) + ", 0x" + String (sml_msg_crc, HEX) + " <-> 0x" + String (rcv_crc, HEX)); } else { sml_msg_failure = 0; @@ -709,7 +709,7 @@ bool sml_get_list_entries (uint16_t layer) sml_msg_crc = sml_finit_crc (sml_msg_crc); if (rcv_crc != sml_msg_crc) { - DPRINTLN(DBG_WARN, "Wrong CRC for msg 0x" + String (sml_message, HEX) + + DPRINTLN(DBG_WARN, "SML: Wrong CRC for msg 0x" + String (sml_message, HEX) + ", 0x" + String (sml_msg_crc, HEX) + " <-> 0x" + String (rcv_crc, HEX)); } else { sml_msg_failure = 0; @@ -746,7 +746,7 @@ bool sml_get_list_entries (uint16_t layer) } break; default: - DPRINT(DBG_WARN, "Ill Element 0x" + String(type, HEX)); + DPRINT(DBG_WARN, "SML: Ill Element 0x" + String(type, HEX)); DBGPRINTLN(", len " + String (entry_len + len_info)); /* design: aussteigen */ sml_state = SML_ST_FIND_START_TAG; @@ -778,7 +778,7 @@ bool sml_get_list_entries (uint16_t layer) } } } else if (entry_len > sizeof (sml_serial_buf)) { - DPRINTLN (DBG_INFO, "skip " + String (entry_len)); + DPRINTLN (DBG_VERBOSE, "SML: skip " + String (entry_len)); sml_skip_len = entry_len; sml_state = SML_ST_SKIP_LIST_ENTRY; return false; @@ -900,7 +900,7 @@ uint16_t sml_parse_stream (uint16 len) cur_serial_buf = sml_serial_buf; } } else { - DPRINTLN(DBG_WARN, "Unexpected 0x" + String(*cur_serial_buf, HEX) + ", rest: " + String (sml_serial_len)); + DPRINTLN(DBG_WARN, "SML: Unexpected 0x" + String(*cur_serial_buf, HEX) + ", rest: " + String (sml_serial_len)); sml_state = SML_ST_FIND_START_TAG; parse_continue = true; } @@ -978,15 +978,15 @@ uint16_t sml_parse_stream (uint16 len) // a bit more verbose info obis_yield_in_all_value = sml_obis_scale_uint (obis_yield_in_all_value, obis_yield_in_all_scale); obis_yield_out_all_value = sml_obis_scale_uint (obis_yield_out_all_value, obis_yield_out_all_scale); - DPRINTLN(DBG_INFO, "Power " + String (obis_power_all_value) + + DPRINTLN(DBG_INFO, "OBIS: Power " + String (obis_power_all_value) + ", Yield in " + String (obis_yield_in_all_value) + ", Yield out " + String (obis_yield_out_all_value)); #else - DPRINTLN(DBG_VERBOSE, "Power " + String (obis_power_all_value)); + DPRINTLN(DBG_VERBOSE, "OBIS: Power " + String (obis_power_all_value)); #endif sml_handle_obis_pac (obis_power_all_value); } else { - DPRINTLN(DBG_WARN, "CRC ERROR 0x" + String (calc_crc16, HEX) + " <-> 0x" + String (rcv_crc16, HEX)); + DPRINTLN(DBG_WARN, "SML: CRC ERROR 0x" + String (calc_crc16, HEX) + " <-> 0x" + String (rcv_crc16, HEX)); } } sml_state = SML_ST_FIND_START_TAG;