topaLE
/
ahoy
mirror of https://github.com/lumapu/ahoy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

optimized rf24 rx for MH300 like

pull/1080/head
no name 2 years ago
parent
42332cdac6
commit
08c8e01053
7 changed files with 141 additions and 58 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/app.cpp
  2. 8
      src/defines.h
  3. 16
      src/hm/hmInverter.h
  4. 12
      src/hm/hmPayload.h
  5. 117
      src/hm/hmRadio.h
  6. 22
      src/hm/miPayload.h
  7. 20
      src/plugins/SML_OBIS_Parser.cpp

4
src/app.cpp
View File

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

8
src/defines.h
View File

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

16
src/hm/hmInverter.h
View File

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

12
src/hm/hmPayload.h
View File

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

117
src/hm/hmRadio.h
View File

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

22
src/hm/miPayload.h
View File

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

20
src/plugins/SML_OBIS_Parser.cpp
View File

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

Write Preview
Loading…
Cancel
Save