mirror of https://github.com/lumapu/ahoy.git
lumapu
2 years ago
53 changed files with 3017 additions and 605 deletions
@ -0,0 +1,437 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - https://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __CMT2300A_H__ |
|||
#define __CMT2300A_H__ |
|||
|
|||
#include "esp32_3wSpi.h" |
|||
|
|||
#define WORK_FREQ_KHZ 865000 // disired work frequency between DTU and
|
|||
// inverter in kHz
|
|||
#define HOY_BASE_FREQ_KHZ 860000 // in kHz
|
|||
#define HOY_MAX_FREQ_KHZ 923500 // 0xFE * 250kHz + Base_freq
|
|||
#define HOY_BOOT_FREQ_KHZ 868000 // Hoymiles boot/init frequency after power up inverter
|
|||
#define FREQ_STEP_KHZ 250 // channel step size in kHz
|
|||
#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
|
|||
|
|||
// detailed register infos from AN142_CMT2300AW_Quick_Start_Guide-Rev0.8.pdf
|
|||
|
|||
#define CMT2300A_MASK_CFG_RETAIN 0x10 |
|||
#define CMT2300A_MASK_RSTN_IN_EN 0x20 |
|||
#define CMT2300A_MASK_LOCKING_EN 0x20 |
|||
#define CMT2300A_MASK_CHIP_MODE_STA 0x0F |
|||
|
|||
#define CMT2300A_CUS_CMT10 0x09 |
|||
|
|||
#define CMT2300A_CUS_MODE_CTL 0x60 // [7] go_switch
|
|||
// [6] go_tx
|
|||
// [5] go_tfs
|
|||
// [4] go_sleep
|
|||
// [3] go_rx
|
|||
// [2] go_rfs
|
|||
// [1] go_stby
|
|||
// [0] n/a
|
|||
|
|||
#define CMT2300A_CUS_MODE_STA 0x61 // [3:0] 0x00 IDLE
|
|||
// 0x01 SLEEP
|
|||
// 0x02 STBY
|
|||
// 0x03 RFS
|
|||
// 0x04 TFS
|
|||
// 0x05 RX
|
|||
// 0x06 TX
|
|||
// 0x08 UNLOCKED/LOW_VDD
|
|||
// 0x09 CAL
|
|||
#define CMT2300A_CUS_EN_CTL 0x62 |
|||
#define CMT2300A_CUS_FREQ_CHNL 0x63 |
|||
|
|||
#define CMT2300A_CUS_IO_SEL 0x65 // [5:4] GPIO3
|
|||
// 0x00 CLKO
|
|||
// 0x01 DOUT / DIN
|
|||
// 0x02 INT2
|
|||
// 0x03 DCLK
|
|||
// [3:2] GPIO2
|
|||
// 0x00 INT1
|
|||
// 0x01 INT2
|
|||
// 0x02 DOUT / DIN
|
|||
// 0x03 DCLK
|
|||
// [1:0] GPIO1
|
|||
// 0x00 DOUT / DIN
|
|||
// 0x01 INT1
|
|||
// 0x02 INT2
|
|||
// 0x03 DCLK
|
|||
|
|||
#define CMT2300A_CUS_INT1_CTL 0x66 // [4:0] INT1_SEL
|
|||
// 0x00 RX active
|
|||
// 0x01 TX active
|
|||
// 0x02 RSSI VLD
|
|||
// 0x03 Pream OK
|
|||
// 0x04 SYNC OK
|
|||
// 0x05 NODE OK
|
|||
// 0x06 CRC OK
|
|||
// 0x07 PKT OK
|
|||
// 0x08 SL TMO
|
|||
// 0x09 RX TMO
|
|||
// 0x0A TX DONE
|
|||
// 0x0B RX FIFO NMTY
|
|||
// 0x0C RX FIFO TH
|
|||
// 0x0D RX FIFO FULL
|
|||
// 0x0E RX FIFO WBYTE
|
|||
// 0x0F RX FIFO OVF
|
|||
// 0x10 TX FIFO NMTY
|
|||
// 0x11 TX FIFO TH
|
|||
// 0x12 TX FIFO FULL
|
|||
// 0x13 STATE IS STBY
|
|||
// 0x14 STATE IS FS
|
|||
// 0x15 STATE IS RX
|
|||
// 0x16 STATE IS TX
|
|||
// 0x17 LED
|
|||
// 0x18 TRX ACTIVE
|
|||
// 0x19 PKT DONE
|
|||
|
|||
#define CMT2300A_CUS_INT2_CTL 0x67 // [4:0] INT2_SEL
|
|||
|
|||
#define CMT2300A_CUS_INT_EN 0x68 // [7] SL TMO EN
|
|||
// [6] RX TMO EN
|
|||
// [5] TX DONE EN
|
|||
// [4] PREAM OK EN
|
|||
// [3] SYNC_OK EN
|
|||
// [2] NODE OK EN
|
|||
// [1] CRC OK EN
|
|||
// [0] PKT DONE EN
|
|||
|
|||
#define CMT2300A_CUS_FIFO_CTL 0x69 // [7] TX DIN EN
|
|||
// [6:5] TX DIN SEL
|
|||
// 0x00 SEL GPIO1
|
|||
// 0x01 SEL GPIO2
|
|||
// 0x02 SEL GPIO3
|
|||
// [4] FIFO AUTO CLR DIS
|
|||
// [3] FIFO TX RD EN
|
|||
// [2] FIFO RX TX SEL
|
|||
// [1] FIFO MERGE EN
|
|||
// [0] SPI FIFO RD WR SEL
|
|||
|
|||
#define CMT2300A_CUS_INT_CLR1 0x6A // clear interrupts Bank1
|
|||
#define CMT2300A_CUS_INT_CLR2 0x6B // clear interrupts Bank2
|
|||
#define CMT2300A_CUS_FIFO_CLR 0x6C |
|||
|
|||
#define CMT2300A_CUS_INT_FLAG 0x6D // [7] LBD FLG
|
|||
// [6] COL ERR FLG
|
|||
// [5] PKT ERR FLG
|
|||
// [4] PREAM OK FLG
|
|||
// [3] SYNC OK FLG
|
|||
// [2] NODE OK FLG
|
|||
// [1] CRC OK FLG
|
|||
// [0] PKT OK FLG
|
|||
|
|||
#define CMT2300A_CUS_RSSI_DBM 0x70 |
|||
|
|||
#define CMT2300A_GO_SWITCH 0x80 |
|||
#define CMT2300A_GO_TX 0x40 |
|||
#define CMT2300A_GO_TFS 0x20 |
|||
#define CMT2300A_GO_SLEEP 0x10 |
|||
#define CMT2300A_GO_RX 0x08 |
|||
#define CMT2300A_GO_RFS 0x04 |
|||
#define CMT2300A_GO_STBY 0x02 |
|||
#define CMT2300A_GO_EEPROM 0x01 |
|||
|
|||
#define CMT2300A_STA_IDLE 0x00 |
|||
#define CMT2300A_STA_SLEEP 0x01 |
|||
#define CMT2300A_STA_STBY 0x02 |
|||
#define CMT2300A_STA_RFS 0x03 |
|||
#define CMT2300A_STA_TFS 0x04 |
|||
#define CMT2300A_STA_RX 0x05 |
|||
#define CMT2300A_STA_TX 0x06 |
|||
#define CMT2300A_STA_EEPROM 0x07 |
|||
#define CMT2300A_STA_ERROR 0x08 |
|||
#define CMT2300A_STA_CAL 0x09 |
|||
|
|||
#define CMT2300A_INT_SEL_TX_DONE 0x0A |
|||
|
|||
#define CMT2300A_MASK_TX_DONE_FLG 0x08 |
|||
#define CMT2300A_MASK_PKT_OK_FLG 0x01 |
|||
|
|||
// default CMT paramters
|
|||
static uint8_t cmtConfig[0x60] PROGMEM { |
|||
// 0x00 - 0x0f -- RSSI offset +- 0 and 13dBm
|
|||
0x00, 0x66, 0xEC, 0x1C, 0x70, 0x80, 0x14, 0x08, |
|||
0x11, 0x02, 0x02, 0x00, 0xAE, 0xE0, 0x35, 0x00, |
|||
// 0x10 - 0x1f
|
|||
0x00, 0xF4, 0x10, 0xE2, 0x42, 0x20, 0x0C, 0x81, |
|||
0x42, 0x32, 0xCF, 0x82, 0x42, 0x27, 0x76, 0x12, // 860MHz as default
|
|||
// 0x20 - 0x2f
|
|||
0xA6, 0xC9, 0x20, 0x20, 0xD2, 0x35, 0x0C, 0x0A, |
|||
0x9F, 0x4B, 0x29, 0x29, 0xC0, 0x14, 0x05, 0x53, |
|||
// 0x30 - 0x3f
|
|||
0x10, 0x00, 0xB4, 0x00, 0x00, 0x01, 0x00, 0x00, |
|||
0x12, 0x1E, 0x00, 0xAA, 0x06, 0x00, 0x00, 0x00, |
|||
// 0x40 - 0x4f
|
|||
0x00, 0x48, 0x5A, 0x48, 0x4D, 0x01, 0x1D, 0x00, |
|||
0x00, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x60, |
|||
// 0x50 - 0x5f
|
|||
0xFF, 0x00, 0x00, 0x1F, 0x10, 0x70, 0x4D, 0x06, |
|||
0x00, 0x07, 0x50, 0x00, 0x42, 0x0C, 0x3F, 0x7F // - TX 13dBm
|
|||
}; |
|||
|
|||
|
|||
enum {CMT_SUCCESS = 0, CMT_ERR_SWITCH_STATE, CMT_ERR_TX_PENDING, CMT_FIFO_EMPTY, CMT_ERR_RX_IN_FIFO}; |
|||
|
|||
template<class SPI> |
|||
class Cmt2300a { |
|||
typedef SPI SpiType; |
|||
public: |
|||
Cmt2300a() {} |
|||
|
|||
void setup(uint8_t pinCsb, uint8_t pinFcsb) { |
|||
mSpi.setup(pinCsb, pinFcsb); |
|||
init(); |
|||
} |
|||
|
|||
void setup() { |
|||
mSpi.setup(); |
|||
init(); |
|||
} |
|||
|
|||
// call as often as possible
|
|||
void loop() { |
|||
if(mTxPending) { |
|||
if(CMT2300A_MASK_TX_DONE_FLG == mSpi.readReg(CMT2300A_CUS_INT_CLR1)) { |
|||
if(cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) { |
|||
mTxPending = false; |
|||
goRx(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
uint8_t goRx(void) { |
|||
if(mTxPending) |
|||
return CMT_ERR_TX_PENDING; |
|||
|
|||
if(mInRxMode) |
|||
return CMT_SUCCESS; |
|||
|
|||
mSpi.readReg(CMT2300A_CUS_INT1_CTL); |
|||
mSpi.writeReg(CMT2300A_CUS_INT1_CTL, CMT2300A_INT_SEL_TX_DONE); |
|||
|
|||
uint8_t tmp = mSpi.readReg(CMT2300A_CUS_INT_CLR1); |
|||
if(0x08 == tmp) // first time after TX a value of 0x08 is read
|
|||
mSpi.writeReg(CMT2300A_CUS_INT_CLR1, 0x04); |
|||
else |
|||
mSpi.writeReg(CMT2300A_CUS_INT_CLR1, 0x00); |
|||
|
|||
if(0x10 == tmp) |
|||
mSpi.writeReg(CMT2300A_CUS_INT_CLR2, 0x10); |
|||
else |
|||
mSpi.writeReg(CMT2300A_CUS_INT_CLR2, 0x00); |
|||
|
|||
mSpi.writeReg(CMT2300A_CUS_FIFO_CTL, 0x02); |
|||
mSpi.writeReg(CMT2300A_CUS_FIFO_CLR, 0x02); |
|||
mSpi.writeReg(0x16, 0x0C); // [4:3]: RSSI_DET_SEL, [2:0]: RSSI_AVG_MODE
|
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_RX, CMT2300A_STA_RX)) |
|||
return CMT_ERR_SWITCH_STATE; |
|||
|
|||
mInRxMode = true; |
|||
|
|||
return CMT_SUCCESS; |
|||
} |
|||
|
|||
uint8_t getRx(uint8_t buf[], uint8_t len, int8_t *rssi) { |
|||
if(mTxPending) |
|||
return CMT_ERR_TX_PENDING; |
|||
|
|||
if(0x1b != (mSpi.readReg(CMT2300A_CUS_INT_FLAG) & 0x1b)) |
|||
return CMT_FIFO_EMPTY; |
|||
|
|||
// receive ok (pream, sync, node, crc)
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) |
|||
return CMT_ERR_SWITCH_STATE; |
|||
|
|||
mSpi.readFifo(buf, len); |
|||
*rssi = mSpi.readReg(CMT2300A_CUS_RSSI_DBM) - 128; |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_SLEEP, CMT2300A_STA_SLEEP)) |
|||
return CMT_ERR_SWITCH_STATE; |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) |
|||
return CMT_ERR_SWITCH_STATE; |
|||
|
|||
mInRxMode = false; |
|||
mCusIntFlag = mSpi.readReg(CMT2300A_CUS_INT_FLAG); |
|||
|
|||
return CMT_SUCCESS; |
|||
} |
|||
|
|||
uint8_t tx(uint8_t buf[], uint8_t len) { |
|||
if(mTxPending) |
|||
return CMT_ERR_TX_PENDING; |
|||
|
|||
if(mInRxMode) { |
|||
mInRxMode = false; |
|||
if(!cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) |
|||
return CMT_ERR_SWITCH_STATE; |
|||
} |
|||
|
|||
mSpi.writeReg(CMT2300A_CUS_INT1_CTL, CMT2300A_INT_SEL_TX_DONE); |
|||
|
|||
// no data received
|
|||
mSpi.readReg(CMT2300A_CUS_INT_CLR1); |
|||
mSpi.writeReg(CMT2300A_CUS_INT_CLR1, 0x00); |
|||
mSpi.writeReg(CMT2300A_CUS_INT_CLR2, 0x00); |
|||
|
|||
mSpi.writeReg(CMT2300A_CUS_FIFO_CTL, 0x07); |
|||
mSpi.writeReg(CMT2300A_CUS_FIFO_CLR, 0x01); |
|||
|
|||
mSpi.writeReg(0x45, 0x01); |
|||
mSpi.writeReg(0x46, len); // payload length
|
|||
|
|||
mSpi.writeFifo(buf, len); |
|||
|
|||
if(0xff != mRqstCh) { |
|||
mCurCh = mRqstCh; |
|||
mRqstCh = 0xff; |
|||
mSpi.writeReg(CMT2300A_CUS_FREQ_CHNL, mCurCh); |
|||
} |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_TX, CMT2300A_STA_TX)) |
|||
return CMT_ERR_SWITCH_STATE; |
|||
|
|||
// wait for tx done
|
|||
mTxPending = true; |
|||
|
|||
return CMT_SUCCESS; |
|||
} |
|||
|
|||
// initialize CMT2300A, returns true on success
|
|||
bool reset(void) { |
|||
mSpi.writeReg(0x7f, 0xff); // soft reset
|
|||
delay(30); |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) |
|||
return false; |
|||
|
|||
mSpi.writeReg(CMT2300A_CUS_MODE_STA, 0x52); |
|||
mSpi.writeReg(0x62, 0x20); |
|||
|
|||
for(uint8_t i = 0; i < 0x60; i++) { |
|||
mSpi.writeReg(i, cmtConfig[i]); |
|||
} |
|||
|
|||
|
|||
mSpi.writeReg(CMT2300A_CUS_IO_SEL, 0x20); // -> GPIO3_SEL[1:0] = 0x02
|
|||
|
|||
// interrupt 1 control selection to TX DONE
|
|||
if(CMT2300A_INT_SEL_TX_DONE != mSpi.readReg(CMT2300A_CUS_INT1_CTL)) |
|||
mSpi.writeReg(CMT2300A_CUS_INT1_CTL, CMT2300A_INT_SEL_TX_DONE); |
|||
|
|||
// select interrupt 2
|
|||
if(0x07 != mSpi.readReg(CMT2300A_CUS_INT2_CTL)) |
|||
mSpi.writeReg(CMT2300A_CUS_INT2_CTL, 0x07); |
|||
|
|||
// interrupt enable (TX_DONE, PREAM_OK, SYNC_OK, CRC_OK, PKT_DONE)
|
|||
mSpi.writeReg(CMT2300A_CUS_INT_EN, 0x3B); |
|||
|
|||
mSpi.writeReg(0x64, 0x64); |
|||
|
|||
if(0x00 == mSpi.readReg(CMT2300A_CUS_FIFO_CTL)) |
|||
mSpi.writeReg(CMT2300A_CUS_FIFO_CTL, 0x02); // FIFO_MERGE_EN
|
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_SLEEP, CMT2300A_STA_SLEEP)) |
|||
return false; |
|||
|
|||
delayMicroseconds(95); |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) |
|||
return false; |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_SLEEP, CMT2300A_STA_SLEEP)) |
|||
return false; |
|||
|
|||
if(!cmtSwitchStatus(CMT2300A_GO_STBY, CMT2300A_STA_STBY)) |
|||
return false; |
|||
|
|||
//switchDtuFreq(WORK_FREQ_KHZ);
|
|||
|
|||
return true; |
|||
} |
|||
|
|||
inline uint8_t freq2Chan(const uint32_t freqKhz) { |
|||
if((freqKhz % FREQ_STEP_KHZ) != 0) { |
|||
DPRINT(DBG_WARN, F("swtich frequency to ")); |
|||
DBGPRINT(String(freqKhz)); |
|||
DBGPRINT(F("kHz not possible!")); |
|||
return 0xff; // error
|
|||
// apply the nearest frequency
|
|||
//freqKhz = (freqKhz + FREQ_STEP_KHZ/2) / FREQ_STEP_KHZ;
|
|||
//freqKhz *= FREQ_STEP_KHZ;
|
|||
} |
|||
|
|||
if((freqKhz < HOY_BASE_FREQ_KHZ) || (freqKhz > HOY_MAX_FREQ_KHZ)) |
|||
return 0xff; // error
|
|||
|
|||
if((freqKhz < FREQ_WARN_MIN_KHZ) || (freqKhz > FREQ_WARN_MAX_KHZ)) |
|||
DPRINTLN(DBG_WARN, F("Disired frequency is out of EU legal range! (863 - 870MHz)")); |
|||
|
|||
return (freqKhz - HOY_BASE_FREQ_KHZ) / FREQ_STEP_KHZ; |
|||
} |
|||
|
|||
inline void switchChannel(uint8_t ch) { |
|||
mRqstCh = ch; |
|||
} |
|||
|
|||
inline uint32_t getFreqKhz(void) { |
|||
if(0xff != mRqstCh) |
|||
return HOY_BASE_FREQ_KHZ + (mRqstCh * FREQ_STEP_KHZ); |
|||
else |
|||
return HOY_BASE_FREQ_KHZ + (mCurCh * FREQ_STEP_KHZ); |
|||
} |
|||
|
|||
private: |
|||
void init() { |
|||
mTxPending = false; |
|||
mInRxMode = false; |
|||
mCusIntFlag = 0x00; |
|||
mCnt = 0; |
|||
mRqstCh = 0xff; |
|||
mCurCh = 0x20; |
|||
} |
|||
|
|||
// CMT state machine, wait for next state, true on success
|
|||
bool cmtSwitchStatus(uint8_t cmd, uint8_t waitFor, uint16_t cycles = 40) { |
|||
mSpi.writeReg(CMT2300A_CUS_MODE_CTL, cmd); |
|||
while(cycles--) { |
|||
yield(); |
|||
delayMicroseconds(10); |
|||
if(waitFor == (getChipStatus() & waitFor)) |
|||
return true; |
|||
} |
|||
//Serial.println("status wait for: " + String(waitFor, HEX) + " read: " + String(getChipStatus(), HEX));
|
|||
return false; |
|||
} |
|||
|
|||
inline bool switchDtuFreq(const uint32_t freqKhz) { |
|||
uint8_t toCh = freq2Chan(freqKhz); |
|||
if(0xff == toCh) |
|||
return false; |
|||
|
|||
switchChannel(toCh); |
|||
|
|||
return true; |
|||
} |
|||
|
|||
inline uint8_t getChipStatus(void) { |
|||
return mSpi.readReg(CMT2300A_CUS_MODE_STA) & CMT2300A_MASK_CHIP_MODE_STA; |
|||
} |
|||
|
|||
SpiType mSpi; |
|||
uint8_t mCnt; |
|||
bool mTxPending; |
|||
bool mInRxMode; |
|||
uint8_t mCusIntFlag; |
|||
uint8_t mRqstCh, mCurCh; |
|||
}; |
|||
|
|||
#endif /*__CMT2300A_H__*/ |
|||
@ -0,0 +1,189 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __ESP32_3WSPI_H__ |
|||
#define __ESP32_3WSPI_H__ |
|||
|
|||
#include "Arduino.h" |
|||
#if defined(ESP32) |
|||
#include "driver/spi_master.h" |
|||
#include "esp_rom_gpio.h" // for esp_rom_gpio_connect_out_signal |
|||
|
|||
#if CONFIG_IDF_TARGET_ESP32S3 |
|||
#define CLK_PIN 6 |
|||
#define MOSI_PIN 5 |
|||
#else |
|||
#define CLK_PIN 18 |
|||
#define MOSI_PIN 23 |
|||
#endif |
|||
|
|||
#define SPI_CLK 1 * 1000 * 1000 // 1MHz
|
|||
|
|||
#define SPI_PARAM_LOCK() \ |
|||
do { \ |
|||
} while (xSemaphoreTake(paramLock, portMAX_DELAY) != pdPASS) |
|||
#define SPI_PARAM_UNLOCK() xSemaphoreGive(paramLock) |
|||
|
|||
// for ESP32 this is the so-called HSPI
|
|||
// for ESP32-S2/S3/C3 this nomenclature does not really exist anymore,
|
|||
// it is simply the first externally usable hardware SPI master controller
|
|||
#define SPI_CMT SPI2_HOST |
|||
|
|||
template<uint8_t CSB_PIN=5, uint8_t FCSB_PIN=4> //, uint8_t GPIO3_PIN=15>
|
|||
class esp32_3wSpi { |
|||
public: |
|||
esp32_3wSpi() { |
|||
mInitialized = false; |
|||
} |
|||
|
|||
void setup(uint8_t pinCsb = CSB_PIN, uint8_t pinFcsb = FCSB_PIN) { //, uint8_t pinGpio3 = GPIO3_PIN) {
|
|||
paramLock = xSemaphoreCreateMutex(); |
|||
spi_bus_config_t buscfg = { |
|||
.mosi_io_num = MOSI_PIN, |
|||
.miso_io_num = -1, // single wire MOSI/MISO
|
|||
.sclk_io_num = CLK_PIN, |
|||
.quadwp_io_num = -1, |
|||
.quadhd_io_num = -1, |
|||
.max_transfer_sz = 32, |
|||
}; |
|||
spi_device_interface_config_t devcfg = { |
|||
.command_bits = 1, |
|||
.address_bits = 7, |
|||
.dummy_bits = 0, |
|||
.mode = 0, |
|||
.cs_ena_pretrans = 1, |
|||
.cs_ena_posttrans = 1, |
|||
.clock_speed_hz = SPI_CLK, |
|||
.spics_io_num = pinCsb, |
|||
.flags = SPI_DEVICE_HALFDUPLEX | SPI_DEVICE_3WIRE, |
|||
.queue_size = 1, |
|||
.pre_cb = NULL, |
|||
.post_cb = NULL, |
|||
}; |
|||
|
|||
ESP_ERROR_CHECK(spi_bus_initialize(SPI_CMT, &buscfg, SPI_DMA_DISABLED)); |
|||
ESP_ERROR_CHECK(spi_bus_add_device(SPI_CMT, &devcfg, &spi_reg)); |
|||
|
|||
// FiFo
|
|||
spi_device_interface_config_t devcfg2 = { |
|||
.command_bits = 0, |
|||
.address_bits = 0, |
|||
.dummy_bits = 0, |
|||
.mode = 0, |
|||
.cs_ena_pretrans = 2, |
|||
.cs_ena_posttrans = (uint8_t)(1 / (SPI_CLK * 10e6 * 2) + 2), // >2 us
|
|||
.clock_speed_hz = SPI_CLK, |
|||
.spics_io_num = pinFcsb, |
|||
.flags = SPI_DEVICE_HALFDUPLEX | SPI_DEVICE_3WIRE, |
|||
.queue_size = 1, |
|||
.pre_cb = NULL, |
|||
.post_cb = NULL, |
|||
}; |
|||
ESP_ERROR_CHECK(spi_bus_add_device(SPI_CMT, &devcfg2, &spi_fifo)); |
|||
|
|||
esp_rom_gpio_connect_out_signal(MOSI_PIN, spi_periph_signal[SPI_CMT].spid_out, true, false); |
|||
delay(100); |
|||
|
|||
//pinMode(pinGpio3, INPUT);
|
|||
mInitialized = true; |
|||
} |
|||
|
|||
void writeReg(uint8_t addr, uint8_t reg) { |
|||
if(!mInitialized) |
|||
return; |
|||
|
|||
uint8_t tx_data; |
|||
tx_data = ~reg; |
|||
spi_transaction_t t = { |
|||
.cmd = 1, |
|||
.addr = (uint64_t)(~addr), |
|||
.length = 8, |
|||
.tx_buffer = &tx_data, |
|||
.rx_buffer = NULL |
|||
}; |
|||
SPI_PARAM_LOCK(); |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi_reg, &t)); |
|||
SPI_PARAM_UNLOCK(); |
|||
delayMicroseconds(100); |
|||
} |
|||
|
|||
uint8_t readReg(uint8_t addr) { |
|||
if(!mInitialized) |
|||
return 0; |
|||
|
|||
uint8_t rx_data; |
|||
spi_transaction_t t = { |
|||
.cmd = 0, |
|||
.addr = (uint64_t)(~addr), |
|||
.length = 8, |
|||
.rxlength = 8, |
|||
.tx_buffer = NULL, |
|||
.rx_buffer = &rx_data |
|||
}; |
|||
|
|||
SPI_PARAM_LOCK(); |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi_reg, &t)); |
|||
SPI_PARAM_UNLOCK(); |
|||
delayMicroseconds(100); |
|||
return rx_data; |
|||
} |
|||
|
|||
void writeFifo(uint8_t buf[], uint8_t len) { |
|||
if(!mInitialized) |
|||
return; |
|||
uint8_t tx_data; |
|||
|
|||
spi_transaction_t t = { |
|||
.length = 8, |
|||
.tx_buffer = &tx_data, // reference to write data
|
|||
.rx_buffer = NULL |
|||
}; |
|||
|
|||
SPI_PARAM_LOCK(); |
|||
for(uint8_t i = 0; i < len; i++) { |
|||
tx_data = ~buf[i]; // negate buffer contents
|
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi_fifo, &t)); |
|||
delayMicroseconds(4); // > 4 us
|
|||
} |
|||
SPI_PARAM_UNLOCK(); |
|||
} |
|||
|
|||
void readFifo(uint8_t buf[], uint8_t len) { |
|||
if(!mInitialized) |
|||
return; |
|||
uint8_t rx_data; |
|||
|
|||
spi_transaction_t t = { |
|||
.length = 8, |
|||
.rxlength = 8, |
|||
.tx_buffer = NULL, |
|||
.rx_buffer = &rx_data |
|||
}; |
|||
|
|||
SPI_PARAM_LOCK(); |
|||
for(uint8_t i = 0; i < len; i++) { |
|||
ESP_ERROR_CHECK(spi_device_polling_transmit(spi_fifo, &t)); |
|||
delayMicroseconds(4); // > 4 us
|
|||
buf[i] = rx_data; |
|||
} |
|||
SPI_PARAM_UNLOCK(); |
|||
} |
|||
|
|||
private: |
|||
spi_device_handle_t spi_reg, spi_fifo; |
|||
bool mInitialized; |
|||
SemaphoreHandle_t paramLock = NULL; |
|||
}; |
|||
#else |
|||
template<uint8_t CSB_PIN=5, uint8_t FCSB_PIN=4> |
|||
class esp32_3wSpi { |
|||
public: |
|||
esp32_3wSpi() {} |
|||
void setup() {} |
|||
void loop() {} |
|||
}; |
|||
#endif |
|||
|
|||
#endif /*__ESP32_3WSPI_H__*/ |
|||
@ -0,0 +1,190 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/3.0/de/
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __HMS_DEFINES_H__ |
|||
#define __HMS_DEFINES_H__ |
|||
|
|||
#include "../hm/hmDefines.h" |
|||
|
|||
//-------------------------------------
|
|||
// HMS-350, HMS-500
|
|||
//-------------------------------------
|
|||
const byteAssign_t hms1chAssignment[] = { |
|||
{ FLD_UDC, UNIT_V, CH1, 2, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH1, 4, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH1, 6, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH1, 8, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH1, 12, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH1, CALC_IRR_CH, CH1, CMD_CALC }, |
|||
|
|||
{ FLD_UAC, UNIT_V, CH0, 14, 2, 10 }, |
|||
{ FLD_F, UNIT_HZ, CH0, 16, 2, 100 }, |
|||
{ FLD_PAC, UNIT_W, CH0, 18, 2, 10 }, |
|||
{ FLD_Q, UNIT_VAR, CH0, 20, 2, 10 }, // signed!
|
|||
{ FLD_IAC, UNIT_A, CH0, 22, 2, 100 }, |
|||
{ FLD_PF, UNIT_NONE, CH0, 24, 2, 1000 }, // signed!
|
|||
{ FLD_T, UNIT_C, CH0, 26, 2, 10 }, // signed!
|
|||
{ FLD_EVT, UNIT_NONE, CH0, 28, 2, 1 }, |
|||
|
|||
{ FLD_YD, UNIT_WH, CH0, CALC_YD_CH0, 0, CMD_CALC }, |
|||
{ FLD_YT, UNIT_KWH, CH0, CALC_YT_CH0, 0, CMD_CALC }, |
|||
{ FLD_PDC, UNIT_W, CH0, CALC_PDC_CH0, 0, CMD_CALC }, |
|||
{ FLD_EFF, UNIT_PCT, CH0, CALC_EFF_CH0, 0, CMD_CALC } |
|||
}; |
|||
#define HMS1CH_LIST_LEN (sizeof(hms1chAssignment) / sizeof(byteAssign_t)) |
|||
#define HMS1CH_PAYLOAD_LEN 30 |
|||
|
|||
//-------------------------------------
|
|||
// HMS-800, HMS-1000
|
|||
//-------------------------------------
|
|||
const byteAssign_t hms2chAssignment[] = { |
|||
{ FLD_UDC, UNIT_V, CH1, 2, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH1, 6, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH1, 10, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH1, 14, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH1, 22, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH1, CALC_IRR_CH, CH1, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH2, 4, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH2, 8, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH2, 12, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH2, 18, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH2, 24, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH2, CALC_IRR_CH, CH2, CMD_CALC }, |
|||
|
|||
{ FLD_UAC, UNIT_V, CH0, 26, 2, 10 }, |
|||
{ FLD_F, UNIT_HZ, CH0, 28, 2, 100 }, |
|||
{ FLD_PAC, UNIT_W, CH0, 30, 2, 10 }, |
|||
{ FLD_Q, UNIT_VAR, CH0, 32, 2, 10 }, // signed!
|
|||
{ FLD_IAC, UNIT_A, CH0, 34, 2, 100 }, |
|||
{ FLD_PF, UNIT_NONE, CH0, 36, 2, 1000 }, // signed!
|
|||
{ FLD_T, UNIT_C, CH0, 38, 2, 10 }, // signed!
|
|||
{ FLD_EVT, UNIT_NONE, CH0, 40, 2, 1 }, |
|||
{ FLD_YD, UNIT_WH, CH0, CALC_YD_CH0, 0, CMD_CALC }, |
|||
{ FLD_YT, UNIT_KWH, CH0, CALC_YT_CH0, 0, CMD_CALC }, |
|||
{ FLD_PDC, UNIT_W, CH0, CALC_PDC_CH0, 0, CMD_CALC }, |
|||
{ FLD_EFF, UNIT_PCT, CH0, CALC_EFF_CH0, 0, CMD_CALC } |
|||
}; |
|||
#define HMS2CH_LIST_LEN (sizeof(hms2chAssignment) / sizeof(byteAssign_t)) |
|||
#define HMS2CH_PAYLOAD_LEN 42 |
|||
|
|||
//-------------------------------------
|
|||
// HMS-1800, HMS-2000
|
|||
//-------------------------------------
|
|||
const byteAssign_t hms4chAssignment[] = { |
|||
{ FLD_UDC, UNIT_V, CH1, 2, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH1, 6, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH1, 10, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH1, 14, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH1, 22, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH1, CALC_IRR_CH, CH1, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH2, 4, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH2, 8, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH2, 12, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH2, 18, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH2, 24, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH2, CALC_IRR_CH, CH2, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH3, 26, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH3, 30, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH3, 34, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH3, 38, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH3, 46, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH3, CALC_IRR_CH, CH3, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH4, 28, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH4, 32, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH4, 36, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH4, 42, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH4, 48, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH4, CALC_IRR_CH, CH4, CMD_CALC }, |
|||
|
|||
{ FLD_UAC, UNIT_V, CH0, 50, 2, 10 }, |
|||
{ FLD_F, UNIT_HZ, CH0, 52, 2, 100 }, |
|||
{ FLD_PAC, UNIT_W, CH0, 54, 2, 10 }, |
|||
{ FLD_Q, UNIT_VAR, CH0, 56, 2, 10 }, // signed!
|
|||
{ FLD_IAC, UNIT_A, CH0, 58, 2, 100 }, |
|||
{ FLD_PF, UNIT_NONE, CH0, 60, 2, 1000 }, // signed!
|
|||
{ FLD_T, UNIT_C, CH0, 62, 2, 10 }, // signed!
|
|||
{ FLD_EVT, UNIT_NONE, CH0, 64, 2, 1 }, |
|||
{ FLD_YD, UNIT_WH, CH0, CALC_YD_CH0, 0, CMD_CALC }, |
|||
{ FLD_YT, UNIT_KWH, CH0, CALC_YT_CH0, 0, CMD_CALC }, |
|||
{ FLD_PDC, UNIT_W, CH0, CALC_PDC_CH0, 0, CMD_CALC }, |
|||
{ FLD_EFF, UNIT_PCT, CH0, CALC_EFF_CH0, 0, CMD_CALC } |
|||
}; |
|||
#define HMS4CH_LIST_LEN (sizeof(hms4chAssignment) / sizeof(byteAssign_t)) |
|||
#define HMS4CH_PAYLOAD_LEN 66 |
|||
|
|||
//-------------------------------------
|
|||
// HMT-1800, HMT-2250
|
|||
//-------------------------------------
|
|||
const byteAssign_t hmt6chAssignment[] = { |
|||
{ FLD_UDC, UNIT_V, CH1, 2, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH1, 4, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH1, 8, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH1, 12, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH1, 20, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH1, CALC_IRR_CH, CH1, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH2, CALC_UDC_CH, CH1, CMD_CALC }, |
|||
{ FLD_IDC, UNIT_A, CH2, 6, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH2, 10, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH2, 16, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH2, 22, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH2, CALC_IRR_CH, CH2, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH3, 24, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH3, 26, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH3, 30, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH3, 34, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH3, 42, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH3, CALC_IRR_CH, CH3, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH4, CALC_UDC_CH, CH3, CMD_CALC }, |
|||
{ FLD_IDC, UNIT_A, CH4, 28, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH4, 32, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH4, 38, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH4, 44, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH4, CALC_IRR_CH, CH4, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH5, 46, 2, 10 }, |
|||
{ FLD_IDC, UNIT_A, CH5, 48, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH5, 52, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH5, 56, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH5, 64, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH5, CALC_IRR_CH, CH5, CMD_CALC }, |
|||
|
|||
{ FLD_UDC, UNIT_V, CH6, CALC_UDC_CH, CH5, CMD_CALC }, |
|||
{ FLD_IDC, UNIT_A, CH6, 50, 2, 100 }, |
|||
{ FLD_PDC, UNIT_W, CH6, 54, 2, 10 }, |
|||
{ FLD_YT, UNIT_KWH, CH6, 60, 4, 1000 }, |
|||
{ FLD_YD, UNIT_WH, CH6, 66, 2, 1 }, |
|||
{ FLD_IRR, UNIT_PCT, CH6, CALC_IRR_CH, CH6, CMD_CALC }, |
|||
|
|||
{ FLD_UAC_1N, UNIT_V, CH0, 68, 2, 10 }, |
|||
{ FLD_UAC_2N, UNIT_V, CH0, 70, 2, 10 }, |
|||
{ FLD_UAC_3N, UNIT_V, CH0, 72, 2, 10 }, |
|||
{ FLD_UAC_12, UNIT_V, CH0, 74, 2, 10 }, |
|||
{ FLD_UAC_23, UNIT_V, CH0, 76, 2, 10 }, |
|||
{ FLD_UAC_31, UNIT_V, CH0, 78, 2, 10 }, |
|||
{ FLD_F, UNIT_HZ, CH0, 80, 2, 100 }, |
|||
{ FLD_PAC, UNIT_W, CH0, 82, 2, 10 }, |
|||
{ FLD_Q, UNIT_VAR, CH0, 84, 2, 10 }, |
|||
{ FLD_IAC_1, UNIT_A, CH0, 86, 2, 100 }, |
|||
{ FLD_IAC_2, UNIT_A, CH0, 88, 2, 100 }, |
|||
{ FLD_IAC_3, UNIT_A, CH0, 90, 2, 100 }, |
|||
{ FLD_PF, UNIT_NONE, CH0, 92, 2, 1000 }, |
|||
{ FLD_T, UNIT_C, CH0, 94, 2, 10 }, |
|||
{ FLD_EVT, UNIT_NONE, CH0, 96, 2, 1 }, |
|||
{ FLD_YD, UNIT_WH, CH0, CALC_YD_CH0, 0, CMD_CALC }, |
|||
{ FLD_YT, UNIT_KWH, CH0, CALC_YT_CH0, 0, CMD_CALC }, |
|||
{ FLD_PDC, UNIT_W, CH0, CALC_PDC_CH0, 0, CMD_CALC }, |
|||
{ FLD_EFF, UNIT_PCT, CH0, CALC_EFF_CH0, 0, CMD_CALC } |
|||
}; |
|||
#define HMT6CH_LIST_LEN (sizeof(hmt6chAssignment) / sizeof(byteAssign_t)) |
|||
#define HMT6CH_PAYLOAD_LEN 98 |
|||
|
|||
#endif /*__HMS_DEFINES_H__*/ |
|||
@ -0,0 +1,405 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://ahoydtu.de
|
|||
// Creative Commons - https://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __HMS_PAYLOAD_H__ |
|||
#define __HMS_PAYLOAD_H__ |
|||
|
|||
#include "../utils/dbg.h" |
|||
#include "../utils/crc.h" |
|||
#include "../config/config.h" |
|||
#include <Arduino.h> |
|||
|
|||
#define HMS_TIMEOUT_SEC 30 // 30s * 1000
|
|||
|
|||
typedef struct { |
|||
uint8_t txCmd; |
|||
uint8_t txId; |
|||
//uint8_t invId;
|
|||
uint32_t ts; |
|||
uint8_t data[MAX_PAYLOAD_ENTRIES][MAX_RF_PAYLOAD_SIZE]; |
|||
uint8_t len[MAX_PAYLOAD_ENTRIES]; |
|||
bool complete; |
|||
uint8_t maxPackId; |
|||
bool lastFound; |
|||
uint8_t retransmits; |
|||
bool requested; |
|||
bool gotFragment; |
|||
} hmsPayload_t; |
|||
|
|||
|
|||
typedef std::function<void(uint8_t, Inverter<> *)> payloadListenerType; |
|||
typedef std::function<void(uint16_t alarmCode, uint32_t start, uint32_t end)> alarmListenerType; |
|||
|
|||
|
|||
template<class HMSYSTEM, class RADIO> |
|||
class HmsPayload { |
|||
public: |
|||
HmsPayload() {} |
|||
|
|||
void setup(IApp *app, HMSYSTEM *sys, RADIO *radio, statistics_t *stat, uint8_t maxRetransmits, uint32_t *timestamp) { |
|||
mApp = app; |
|||
mSys = sys; |
|||
mRadio = radio; |
|||
mStat = stat; |
|||
mMaxRetrans = maxRetransmits; |
|||
mTimestamp = timestamp; |
|||
for(uint8_t i = 0; i < MAX_NUM_INVERTERS; i++) { |
|||
reset(i); |
|||
mIvCmd56Cnt[i] = 0; |
|||
} |
|||
mSerialDebug = false; |
|||
//mHighPrioIv = NULL;
|
|||
mCbAlarm = NULL; |
|||
mCbPayload = NULL; |
|||
//mLastRx = 0;
|
|||
} |
|||
|
|||
void enableSerialDebug(bool enable) { |
|||
mSerialDebug = enable; |
|||
} |
|||
|
|||
void addPayloadListener(payloadListenerType cb) { |
|||
mCbPayload = cb; |
|||
} |
|||
|
|||
void addAlarmListener(alarmListenerType cb) { |
|||
mCbAlarm = cb; |
|||
} |
|||
|
|||
void loop() { |
|||
/*if(NULL != mHighPrioIv) {
|
|||
ivSend(mHighPrioIv, true); |
|||
mHighPrioIv = NULL; |
|||
}*/ |
|||
} |
|||
|
|||
void ivSendHighPrio(Inverter<> *iv) { |
|||
//mHighPrioIv = iv;
|
|||
} |
|||
|
|||
void ivSend(Inverter<> *iv, bool highPrio = false) { |
|||
if ((IV_HMS != iv->ivGen) && (IV_HMT != iv->ivGen)) // only process HMS inverters
|
|||
return; |
|||
|
|||
if(!highPrio) { |
|||
if (mPayload[iv->id].requested) { |
|||
if (!mPayload[iv->id].complete) |
|||
process(false); // no retransmit
|
|||
|
|||
if (!mPayload[iv->id].complete) { |
|||
if (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId) |
|||
mStat->rxFailNoAnser++; // got nothing
|
|||
else |
|||
mStat->rxFail++; // got fragments but not complete response
|
|||
|
|||
iv->setQueuedCmdFinished(); // command failed
|
|||
if (mSerialDebug) |
|||
DPRINTLN(DBG_INFO, F("enqueued cmd failed/timeout")); |
|||
/*if (mSerialDebug) {
|
|||
DPRINT(DBG_INFO, F("(#")); |
|||
DBGPRINT(String(iv->id)); |
|||
DBGPRINT(F(") no Payload received! (retransmits: ")); |
|||
DBGPRINT(String(mPayload[iv->id].retransmits)); |
|||
DBGPRINTLN(F(")")); |
|||
}*/ |
|||
} |
|||
} |
|||
} |
|||
|
|||
reset(iv->id); |
|||
mPayload[iv->id].requested = true; |
|||
|
|||
yield(); |
|||
if (mSerialDebug) { |
|||
DPRINT_IVID(DBG_INFO, iv->id); |
|||
DBGPRINT(F("Requesting Inv SN ")); |
|||
DBGPRINTLN(String(iv->config->serial.u64, HEX)); |
|||
} |
|||
|
|||
record_t<> *rec = iv->getRecordStruct(RealTimeRunData_Debug); |
|||
if (iv->getDevControlRequest()) { |
|||
if (mSerialDebug) { |
|||
DPRINT_IVID(DBG_INFO, iv->id); |
|||
DBGPRINT(F("Devcontrol request 0x")); |
|||
DBGPRINT(String(iv->devControlCmd, HEX)); |
|||
DBGPRINT(F(" power limit ")); |
|||
DBGPRINTLN(String(iv->powerLimit[0])); |
|||
} |
|||
mRadio->sendControlPacket(&iv->radioId.u64, iv->devControlCmd, iv->powerLimit, false); |
|||
mPayload[iv->id].txCmd = iv->devControlCmd; |
|||
//iv->clearCmdQueue();
|
|||
//iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit
|
|||
} else if(((rec->ts + HMS_TIMEOUT_SEC) < *mTimestamp) && (mIvCmd56Cnt[iv->id] < 3)) { |
|||
mRadio->switchFrequency(&iv->radioId.u64, HOY_BOOT_FREQ_KHZ, WORK_FREQ_KHZ); |
|||
mIvCmd56Cnt[iv->id]++; |
|||
} else { |
|||
if(++mIvCmd56Cnt[iv->id] == 10) |
|||
mIvCmd56Cnt[iv->id] = 0; |
|||
uint8_t cmd = iv->getQueuedCmd(); |
|||
DPRINT_IVID(DBG_INFO, iv->id); |
|||
DBGPRINT(F("prepareDevInformCmd 0x")); |
|||
DBGHEXLN(cmd); |
|||
mRadio->prepareDevInformCmd(&iv->radioId.u64, cmd, mPayload[iv->id].ts, iv->alarmMesIndex, false); |
|||
mPayload[iv->id].txCmd = cmd; |
|||
} |
|||
} |
|||
|
|||
void add(Inverter<> *iv, hmsPacket_t *p) { |
|||
if (p->data[1] == (TX_REQ_INFO + ALL_FRAMES)) { // response from get information command
|
|||
mPayload[iv->id].txId = p->data[1]; |
|||
DPRINTLN(DBG_DEBUG, F("Response from info request received")); |
|||
uint8_t *pid = &p->data[10]; |
|||
if (*pid == 0x00) { |
|||
DPRINT(DBG_DEBUG, F("fragment number zero received and ignored")); |
|||
} else { |
|||
DPRINTLN(DBG_DEBUG, "PID: 0x" + String(*pid, HEX)); |
|||
if ((*pid & 0x7F) < MAX_PAYLOAD_ENTRIES) { |
|||
memcpy(mPayload[iv->id].data[(*pid & 0x7F) - 1], &p->data[11], p->data[0] - 11); |
|||
mPayload[iv->id].len[(*pid & 0x7F) - 1] = p->data[0] -11; |
|||
mPayload[iv->id].gotFragment = true; |
|||
} |
|||
|
|||
if ((*pid & ALL_FRAMES) == ALL_FRAMES) { |
|||
// Last packet
|
|||
if (((*pid & 0x7f) > mPayload[iv->id].maxPackId) || (MAX_PAYLOAD_ENTRIES == mPayload[iv->id].maxPackId)) { |
|||
mPayload[iv->id].maxPackId = (*pid & 0x7f); |
|||
if (*pid > 0x81) |
|||
mPayload[iv->id].lastFound = true; |
|||
} |
|||
} |
|||
} |
|||
} else if (p->data[1] == (TX_REQ_DEVCONTROL + ALL_FRAMES)) { // response from dev control command
|
|||
DPRINTLN(DBG_DEBUG, F("Response from devcontrol request received")); |
|||
|
|||
mPayload[iv->id].txId = p->data[1]; |
|||
iv->clearDevControlRequest(); |
|||
|
|||
if ((p->data[13] == ActivePowerContr) && (p->data[14] == 0x00)) { |
|||
bool ok = true; |
|||
if((p->data[11] == 0x00) && (p->data[12] == 0x00)) |
|||
mApp->setMqttPowerLimitAck(iv); |
|||
else |
|||
ok = false; |
|||
DPRINT_IVID(DBG_INFO, iv->id); |
|||
DBGPRINT(F(" has ")); |
|||
if(!ok) DBGPRINT(F("not ")); |
|||
DBGPRINT(F("accepted power limit set point ")); |
|||
DBGPRINT(String(iv->powerLimit[0])); |
|||
DBGPRINT(F(" with PowerLimitControl ")); |
|||
DBGPRINTLN(String(iv->powerLimit[1])); |
|||
|
|||
iv->clearCmdQueue(); |
|||
iv->enqueCommand<InfoCommand>(SystemConfigPara); // read back power limit
|
|||
} |
|||
iv->devControlCmd = Init; |
|||
} |
|||
} |
|||
|
|||
void process(bool retransmit) { |
|||
for (uint8_t id = 0; id < mSys->getNumInverters(); id++) { |
|||
Inverter<> *iv = mSys->getInverterByPos(id); |
|||
if (NULL == iv) |
|||
continue; // skip to next inverter
|
|||
|
|||
if ((IV_HMS != iv->ivGen) && (IV_HMT != iv->ivGen)) // only process HMS inverters
|
|||
continue; // skip to next inverter
|
|||
|
|||
if ((mPayload[iv->id].txId != (TX_REQ_INFO + ALL_FRAMES)) && (0 != mPayload[iv->id].txId)) { |
|||
// no processing needed if txId is not 0x95
|
|||
mPayload[iv->id].complete = true; |
|||
continue; // skip to next inverter
|
|||
} |
|||
|
|||
if (!mPayload[iv->id].complete) { |
|||
bool crcPass, pyldComplete; |
|||
crcPass = build(iv->id, &pyldComplete); |
|||
if (!crcPass && !pyldComplete) { // payload not complete
|
|||
if ((mPayload[iv->id].requested) && (retransmit)) { |
|||
if (mPayload[iv->id].retransmits < mMaxRetrans) { |
|||
mPayload[iv->id].retransmits++; |
|||
if (iv->devControlCmd == Restart || iv->devControlCmd == CleanState_LockAndAlarm) { |
|||
// This is required to prevent retransmissions without answer.
|
|||
DPRINTLN(DBG_INFO, F("Prevent retransmit on Restart / CleanState_LockAndAlarm...")); |
|||
mPayload[iv->id].retransmits = mMaxRetrans; |
|||
} else if(iv->devControlCmd == ActivePowerContr) { |
|||
DPRINTLN(DBG_INFO, F("retransmit power limit")); |
|||
mRadio->sendControlPacket(&iv->radioId.u64, iv->devControlCmd, iv->powerLimit, true); |
|||
} else { |
|||
if(false == mPayload[iv->id].gotFragment) { |
|||
|
|||
//DPRINTLN(DBG_WARN, F("nothing received: Request Complete Retransmit"));
|
|||
//mPayload[iv->id].txCmd = iv->getQueuedCmd();
|
|||
//DPRINTLN(DBG_INFO, F("(#") + String(iv->id) + F(") prepareDevInformCmd 0x") + String(mPayload[iv->id].txCmd, HEX));
|
|||
//mRadio->prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true);
|
|||
|
|||
DPRINT_IVID(DBG_INFO, iv->id); |
|||
DBGPRINTLN(F("nothing received")); |
|||
mPayload[iv->id].retransmits = mMaxRetrans; |
|||
} else { |
|||
for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId - 1); i++) { |
|||
if (mPayload[iv->id].len[i] == 0) { |
|||
DPRINT(DBG_WARN, F("Frame ")); |
|||
DBGPRINT(String(i + 1)); |
|||
DBGPRINTLN(F(" missing: Request Retransmit")); |
|||
//mRadio->sendCmdPacket(iv->radioId.u64, TX_REQ_INFO, (SINGLE_FRAME + i), true);
|
|||
break; // only request retransmit one frame per loop
|
|||
} |
|||
yield(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} /*else if(!crcPass && pyldComplete) { // crc error on complete Payload
|
|||
if (mPayload[iv->id].retransmits < mMaxRetrans) { |
|||
mPayload[iv->id].retransmits++; |
|||
DPRINTLN(DBG_WARN, F("CRC Error: Request Complete Retransmit")); |
|||
mPayload[iv->id].txCmd = iv->getQueuedCmd(); |
|||
DPRINT(DBG_INFO, F("(#")); |
|||
DBGPRINT(String(iv->id)); |
|||
DBGPRINT(F(") prepareDevInformCmd 0x")); |
|||
DBGPRINTLN(String(mPayload[iv->id].txCmd, HEX)); |
|||
mRadio->prepareDevInformCmd(iv->radioId.u64, mPayload[iv->id].txCmd, mPayload[iv->id].ts, iv->alarmMesIndex, true); |
|||
} |
|||
}*/ else { // payload complete
|
|||
DPRINT(DBG_INFO, F("procPyld: cmd: 0x")); |
|||
DBGPRINTLN(String(mPayload[iv->id].txCmd, HEX)); |
|||
DPRINT(DBG_INFO, F("procPyld: txid: 0x")); |
|||
DBGPRINTLN(String(mPayload[iv->id].txId, HEX)); |
|||
DPRINTLN(DBG_DEBUG, F("procPyld: max: ") + String(mPayload[iv->id].maxPackId)); |
|||
record_t<> *rec = iv->getRecordStruct(mPayload[iv->id].txCmd); // choose the parser
|
|||
mPayload[iv->id].complete = true; |
|||
|
|||
uint8_t payload[100]; |
|||
uint8_t payloadLen = 0; |
|||
|
|||
memset(payload, 0, 100); |
|||
|
|||
for (uint8_t i = 0; i < (mPayload[iv->id].maxPackId); i++) { |
|||
memcpy(&payload[payloadLen], mPayload[iv->id].data[i], (mPayload[iv->id].len[i])); |
|||
payloadLen += (mPayload[iv->id].len[i]); |
|||
yield(); |
|||
} |
|||
payloadLen -= 2; |
|||
|
|||
if (mSerialDebug) { |
|||
DPRINT(DBG_INFO, F("Payload (")); |
|||
DBGPRINT(String(payloadLen)); |
|||
DBGPRINT(F("): ")); |
|||
ah::dumpBuf(payload, payloadLen); |
|||
} |
|||
|
|||
if (NULL == rec) { |
|||
DPRINTLN(DBG_ERROR, F("record is NULL!")); |
|||
} else if ((rec->pyldLen == payloadLen) || (0 == rec->pyldLen)) { |
|||
if (mPayload[iv->id].txId == (TX_REQ_INFO + ALL_FRAMES)) |
|||
mStat->rxSuccess++; |
|||
|
|||
rec->ts = mPayload[iv->id].ts; |
|||
for (uint8_t i = 0; i < rec->length; i++) { |
|||
iv->addValue(i, payload, rec); |
|||
yield(); |
|||
} |
|||
iv->doCalculations(); |
|||
notify(mPayload[iv->id].txCmd, iv); |
|||
|
|||
/*if(AlarmData == mPayload[iv->id].txCmd) {
|
|||
uint8_t i = 0; |
|||
uint16_t code; |
|||
uint32_t start, end; |
|||
while(1) { |
|||
code = iv->parseAlarmLog(i++, payload, payloadLen, &start, &end); |
|||
if(0 == code) |
|||
break; |
|||
if (NULL != mCbAlarm) |
|||
(mCbAlarm)(code, start, end); |
|||
yield(); |
|||
} |
|||
}*/ |
|||
} else { |
|||
DPRINT(DBG_ERROR, F("plausibility check failed, expected ")); |
|||
DBGPRINT(String(rec->pyldLen)); |
|||
DBGPRINTLN(F(" bytes")); |
|||
mStat->rxFail++; |
|||
} |
|||
|
|||
iv->setQueuedCmdFinished(); |
|||
} |
|||
} |
|||
yield(); |
|||
} |
|||
} |
|||
|
|||
private: |
|||
void notify(uint8_t val, Inverter<> *iv) { |
|||
if(NULL != mCbPayload) |
|||
(mCbPayload)(val, iv); |
|||
} |
|||
|
|||
void notify(uint16_t code, uint32_t start, uint32_t endTime) { |
|||
if (NULL != mCbAlarm) |
|||
(mCbAlarm)(code, start, endTime); |
|||
} |
|||
|
|||
bool build(uint8_t id, bool *complete) { |
|||
DPRINTLN(DBG_VERBOSE, F("build")); |
|||
uint16_t crc = 0xffff, crcRcv = 0x0000; |
|||
if (mPayload[id].maxPackId > MAX_PAYLOAD_ENTRIES) |
|||
mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES; |
|||
|
|||
// check if all fragments are there
|
|||
*complete = true; |
|||
for (uint8_t i = 0; i < mPayload[id].maxPackId; i++) { |
|||
if(mPayload[id].len[i] == 0) |
|||
*complete = false; |
|||
} |
|||
if(!*complete) |
|||
return false; |
|||
|
|||
for (uint8_t i = 0; i < mPayload[id].maxPackId; i++) { |
|||
if (mPayload[id].len[i] > 0) { |
|||
if (i == (mPayload[id].maxPackId - 1)) { |
|||
crc = ah::crc16(mPayload[id].data[i], mPayload[id].len[i] - 1, crc); |
|||
crcRcv = (mPayload[id].data[i][mPayload[id].len[i] - 2] << 8) | (mPayload[id].data[i][mPayload[id].len[i] - 1]); |
|||
} else |
|||
crc = ah::crc16(mPayload[id].data[i], mPayload[id].len[i], crc); |
|||
} |
|||
yield(); |
|||
} |
|||
|
|||
return (crc == crcRcv) ? true : false; |
|||
} |
|||
|
|||
void reset(uint8_t id) { |
|||
DPRINT(DBG_INFO, "resetPayload: id: "); |
|||
DBGPRINTLN(String(id)); |
|||
memset(&mPayload[id], 0, sizeof(hmsPayload_t)); |
|||
//mPayload[id].txCmd = 0;
|
|||
mPayload[id].gotFragment = false; |
|||
//mPayload[id].retransmits = 0;
|
|||
mPayload[id].maxPackId = MAX_PAYLOAD_ENTRIES; |
|||
mPayload[id].lastFound = false; |
|||
mPayload[id].complete = false; |
|||
mPayload[id].requested = false; |
|||
mPayload[id].ts = *mTimestamp; |
|||
} |
|||
|
|||
IApp *mApp; |
|||
HMSYSTEM *mSys; |
|||
RADIO *mRadio; |
|||
statistics_t *mStat; |
|||
uint8_t mMaxRetrans; |
|||
uint32_t *mTimestamp; |
|||
//uint32_t mLastRx;
|
|||
hmsPayload_t mPayload[MAX_NUM_INVERTERS]; |
|||
uint8_t mIvCmd56Cnt[MAX_NUM_INVERTERS]; |
|||
bool mSerialDebug; |
|||
Inverter<> *mHighPrioIv; |
|||
|
|||
alarmListenerType mCbAlarm; |
|||
payloadListenerType mCbPayload; |
|||
}; |
|||
|
|||
#endif /*__HMS_PAYLOAD_H__*/ |
|||
@ -0,0 +1,213 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - https://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __HMS_RADIO_H__ |
|||
#define __HMS_RADIO_H__ |
|||
|
|||
#include "../utils/dbg.h" |
|||
#include "cmt2300a.h" |
|||
|
|||
typedef struct { |
|||
int8_t rssi; |
|||
uint8_t data[28]; |
|||
} hmsPacket_t; |
|||
|
|||
#define U32_B3(val) ((uint8_t)((val >> 24) & 0xff)) |
|||
#define U32_B2(val) ((uint8_t)((val >> 16) & 0xff)) |
|||
#define U32_B1(val) ((uint8_t)((val >> 8) & 0xff)) |
|||
#define U32_B0(val) ((uint8_t)((val ) & 0xff)) |
|||
|
|||
template<class SPI, uint32_t DTU_SN = 0x81001765> |
|||
class CmtRadio { |
|||
typedef SPI SpiType; |
|||
typedef Cmt2300a<SpiType> CmtType; |
|||
public: |
|||
CmtRadio() { |
|||
mDtuSn = DTU_SN; |
|||
} |
|||
|
|||
void setup(uint8_t pinCsb, uint8_t pinFcsb, bool genDtuSn = true) { |
|||
mCmt.setup(pinCsb, pinFcsb); |
|||
reset(genDtuSn); |
|||
} |
|||
|
|||
void setup(bool genDtuSn = true) { |
|||
mCmt.setup(); |
|||
reset(genDtuSn); |
|||
} |
|||
|
|||
bool loop() { |
|||
mCmt.loop(); |
|||
|
|||
if((!mIrqRcvd) && (!mRqstGetRx)) |
|||
return false; |
|||
getRx(); |
|||
if(CMT_SUCCESS == mCmt.goRx()) { |
|||
mIrqRcvd = false; |
|||
mRqstGetRx = false; |
|||
return true; |
|||
} else |
|||
return false; |
|||
} |
|||
|
|||
void tickSecond() { |
|||
} |
|||
|
|||
void handleIntr(void) { |
|||
mIrqRcvd = true; |
|||
} |
|||
|
|||
void enableDebug() { |
|||
mSerialDebug = true; |
|||
} |
|||
|
|||
void sendControlPacket(const uint64_t *ivId, uint8_t cmd, uint16_t *data, bool isRetransmit) { |
|||
DPRINT(DBG_INFO, F("sendControlPacket cmd: 0x")); |
|||
DBGHEXLN(cmd); |
|||
initPacket(ivId, TX_REQ_DEVCONTROL, SINGLE_FRAME); |
|||
uint8_t cnt = 10; |
|||
|
|||
mTxBuf[cnt++] = cmd; // cmd -> 0 on, 1 off, 2 restart, 11 active power, 12 reactive power, 13 power factor
|
|||
mTxBuf[cnt++] = 0x00; |
|||
if(cmd >= ActivePowerContr && cmd <= PFSet) { // ActivePowerContr, ReactivePowerContr, PFSet
|
|||
mTxBuf[cnt++] = ((data[0] * 10) >> 8) & 0xff; // power limit
|
|||
mTxBuf[cnt++] = ((data[0] * 10) ) & 0xff; // power limit
|
|||
mTxBuf[cnt++] = ((data[1] ) >> 8) & 0xff; // setting for persistens handlings
|
|||
mTxBuf[cnt++] = ((data[1] ) ) & 0xff; // setting for persistens handling
|
|||
} |
|||
|
|||
sendPacket(cnt, isRetransmit); |
|||
} |
|||
|
|||
bool switchFrequency(const uint64_t *ivId, uint32_t fromkHz, uint32_t tokHz) { |
|||
uint8_t fromCh = mCmt.freq2Chan(fromkHz); |
|||
uint8_t toCh = mCmt.freq2Chan(tokHz); |
|||
|
|||
if((0xff == fromCh) || (0xff == toCh)) |
|||
return false; |
|||
|
|||
mCmt.switchChannel(fromCh); |
|||
sendSwitchChCmd(ivId, toCh); |
|||
mCmt.switchChannel(toCh); |
|||
return true; |
|||
} |
|||
|
|||
void prepareDevInformCmd(const uint64_t *ivId, 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.
|
|||
initPacket(ivId, reqfld, ALL_FRAMES); |
|||
mTxBuf[10] = cmd; |
|||
CP_U32_LittleEndian(&mTxBuf[12], ts); |
|||
/*if (cmd == RealTimeRunData_Debug || cmd == AlarmData ) {
|
|||
mTxBuf[18] = (alarmMesId >> 8) & 0xff; |
|||
mTxBuf[19] = (alarmMesId ) & 0xff; |
|||
}*/ |
|||
sendPacket(24, isRetransmit); |
|||
} |
|||
|
|||
void sendPacket(uint8_t len, bool isRetransmit) { |
|||
if (len > 14) { |
|||
uint16_t crc = ah::crc16(&mTxBuf[10], len - 10); |
|||
mTxBuf[len++] = (crc >> 8) & 0xff; |
|||
mTxBuf[len++] = (crc ) & 0xff; |
|||
} |
|||
mTxBuf[len] = ah::crc8(mTxBuf, len); |
|||
len++; |
|||
|
|||
if(mSerialDebug) { |
|||
DPRINT(DBG_INFO, F("TX ")); |
|||
DBGPRINT(String(mCmt.getFreqKhz()/1000.0f)); |
|||
DBGPRINT(F("Mhz | ")); |
|||
ah::dumpBuf(mTxBuf, len); |
|||
} |
|||
|
|||
uint8_t status = mCmt.tx(mTxBuf, len); |
|||
if(CMT_SUCCESS != status) { |
|||
DPRINT(DBG_WARN, F("CMT TX failed, code: ")); |
|||
DBGPRINTLN(String(status)); |
|||
if(CMT_ERR_RX_IN_FIFO == status) |
|||
mIrqRcvd = true; |
|||
} |
|||
|
|||
if(isRetransmit) |
|||
mRetransmits++; |
|||
else |
|||
mSendCnt++; |
|||
} |
|||
|
|||
uint32_t mSendCnt; |
|||
uint32_t mRetransmits; |
|||
std::queue<hmsPacket_t> mBufCtrl; |
|||
|
|||
private: |
|||
inline void reset(bool genDtuSn) { |
|||
if(genDtuSn) |
|||
generateDtuSn(); |
|||
if(!mCmt.reset()) |
|||
DPRINTLN(DBG_WARN, F("Initializing CMT2300A failed!")); |
|||
else |
|||
mCmt.goRx(); |
|||
|
|||
mSendCnt = 0; |
|||
mRetransmits = 0; |
|||
mSerialDebug = false; |
|||
mIrqRcvd = false; |
|||
mRqstGetRx = false; |
|||
} |
|||
|
|||
inline void sendSwitchChCmd(const uint64_t *ivId, uint8_t ch) { |
|||
/** ch:
|
|||
* 0x00: 860.00 MHz |
|||
* 0x01: 860.25 MHz |
|||
* 0x02: 860.50 MHz |
|||
* ... |
|||
* 0x14: 865.00 MHz |
|||
* ... |
|||
* 0x28: 870.00 MHz |
|||
* */ |
|||
initPacket(ivId, 0x56, 0x02); |
|||
mTxBuf[10] = 0x15; |
|||
mTxBuf[11] = 0x21; |
|||
mTxBuf[12] = ch; |
|||
mTxBuf[13] = 0x14; |
|||
sendPacket(14, false); |
|||
mRqstGetRx = true; |
|||
} |
|||
|
|||
void initPacket(const uint64_t *ivId, uint8_t mid, uint8_t pid) { |
|||
mTxBuf[0] = mid; |
|||
CP_U32_BigEndian(&mTxBuf[1], (*ivId) >> 8); |
|||
CP_U32_LittleEndian(&mTxBuf[5], mDtuSn); |
|||
mTxBuf[9] = pid; |
|||
memset(&mTxBuf[10], 0x00, 17); |
|||
} |
|||
|
|||
inline void generateDtuSn(void) { |
|||
uint32_t chipID = 0; |
|||
#ifdef ESP32 |
|||
uint64_t MAC = ESP.getEfuseMac(); |
|||
chipID = ((MAC >> 8) & 0xFF0000) | ((MAC >> 24) & 0xFF00) | ((MAC >> 40) & 0xFF); |
|||
#endif |
|||
mDtuSn = 0x80000000; // the first digit is an 8 for DTU production year 2022, the rest is filled with the ESP chipID in decimal
|
|||
for(int i = 0; i < 7; i++) { |
|||
mDtuSn |= (chipID % 10) << (i * 4); |
|||
chipID /= 10; |
|||
} |
|||
} |
|||
|
|||
inline void getRx(void) { |
|||
hmsPacket_t p; |
|||
uint8_t status = mCmt.getRx(p.data, 28, &p.rssi); |
|||
if(CMT_SUCCESS == status) |
|||
mBufCtrl.push(p); |
|||
} |
|||
|
|||
CmtType mCmt; |
|||
uint32_t mDtuSn; |
|||
uint8_t mTxBuf[27]; |
|||
bool mSerialDebug; |
|||
bool mIrqRcvd; |
|||
bool mRqstGetRx; |
|||
}; |
|||
|
|||
#endif /*__HMS_RADIO_H__*/ |
|||
@ -0,0 +1,134 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://ahoydtu.de
|
|||
// Creative Commons - https://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#pragma once |
|||
#include "Display_Mono.h" |
|||
|
|||
class DisplayMono64X48 : public DisplayMono { |
|||
public: |
|||
DisplayMono64X48() : DisplayMono() { |
|||
mEnPowerSafe = true; |
|||
mEnScreenSaver = false; |
|||
mLuminance = 20; |
|||
mExtra = 0; |
|||
mDispY = 0; |
|||
mTimeout = DISP_DEFAULT_TIMEOUT; // interval at which to power save (milliseconds)
|
|||
mUtcTs = NULL; |
|||
mType = 0; |
|||
} |
|||
|
|||
void init(uint8_t type, uint8_t rotation, uint8_t cs, uint8_t dc, uint8_t reset, uint8_t clock, uint8_t data, uint32_t *utcTs, const char *version) { |
|||
|
|||
u8g2_cb_t *rot = (u8g2_cb_t *)((rotation != 0x00) ? U8G2_R2 : U8G2_R0); |
|||
mType = type; |
|||
|
|||
// Wemos OLed Shield is not defined in u8 lib -> use nearest compatible
|
|||
mDisplay = new U8G2_SSD1306_64X48_ER_F_HW_I2C(rot, reset, clock, data); |
|||
|
|||
mUtcTs = utcTs; |
|||
|
|||
mDisplay->begin(); |
|||
calcLinePositions(); |
|||
|
|||
mDisplay->clearBuffer(); |
|||
mDisplay->setContrast(mLuminance); |
|||
|
|||
printText("AHOY!", 0); |
|||
printText("ahoydtu.de", 1); |
|||
printText(version, 2); |
|||
mDisplay->sendBuffer(); |
|||
} |
|||
|
|||
void config(bool enPowerSafe, bool enScreenSaver, uint8_t lum) { |
|||
mEnPowerSafe = enPowerSafe; |
|||
mEnScreenSaver = enScreenSaver; |
|||
mLuminance = lum; |
|||
} |
|||
|
|||
void loop(void) { |
|||
if (mEnPowerSafe) { |
|||
if (mTimeout != 0) |
|||
mTimeout--; |
|||
} |
|||
} |
|||
|
|||
void disp(float totalPower, float totalYieldDay, float totalYieldTotal, uint8_t isprod) { |
|||
mDisplay->clearBuffer(); |
|||
|
|||
// set Contrast of the Display to raise the lifetime
|
|||
mDisplay->setContrast(mLuminance); |
|||
|
|||
if ((totalPower > 0) && (isprod > 0)) { |
|||
mTimeout = DISP_DEFAULT_TIMEOUT; |
|||
mDisplay->setPowerSave(false); |
|||
|
|||
if (totalPower > 999) |
|||
snprintf(mFmtText, DISP_FMT_TEXT_LEN, "%2.2f kW", (totalPower / 1000)); |
|||
else |
|||
snprintf(mFmtText, DISP_FMT_TEXT_LEN, "%3.0f W", totalPower); |
|||
|
|||
printText(mFmtText, 0); |
|||
} else { |
|||
printText("offline", 0); |
|||
// check if it's time to enter power saving mode
|
|||
if (mTimeout == 0) |
|||
mDisplay->setPowerSave(mEnPowerSafe); |
|||
} |
|||
|
|||
snprintf(mFmtText, DISP_FMT_TEXT_LEN, "D: %4.0f Wh", totalYieldDay); |
|||
printText(mFmtText, 1); |
|||
|
|||
snprintf(mFmtText, DISP_FMT_TEXT_LEN, "T: %4.0f kWh", totalYieldTotal); |
|||
printText(mFmtText, 2); |
|||
|
|||
IPAddress ip = WiFi.localIP(); |
|||
if (!(mExtra % 10) && (ip)) |
|||
printText(ip.toString().c_str(), 3); |
|||
else if (!(mExtra % 5)) { |
|||
snprintf(mFmtText, DISP_FMT_TEXT_LEN, "active Inv: %d", isprod); |
|||
printText(mFmtText, 3); |
|||
} else if (NULL != mUtcTs) |
|||
printText(ah::getTimeStr(gTimezone.toLocal(*mUtcTs)).c_str(), 3); |
|||
|
|||
mDisplay->sendBuffer(); |
|||
|
|||
mExtra++; |
|||
} |
|||
|
|||
private: |
|||
void calcLinePositions() { |
|||
uint8_t yOff = 0; |
|||
for (uint8_t i = 0; i < 4; i++) { |
|||
setFont(i); |
|||
yOff += (mDisplay->getMaxCharHeight()); |
|||
mLineYOffsets[i] = yOff; |
|||
} |
|||
} |
|||
|
|||
inline void setFont(uint8_t line) { |
|||
switch (line) { |
|||
case 0: |
|||
mDisplay->setFont(u8g2_font_fur11_tf); |
|||
break; |
|||
case 1: |
|||
case 2: |
|||
mDisplay->setFont(u8g2_font_6x10_tf); |
|||
break; |
|||
case 3: |
|||
mDisplay->setFont(u8g2_font_4x6_tr); |
|||
break; |
|||
case 4: |
|||
mDisplay->setFont(u8g2_font_4x6_tr); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void printText(const char *text, uint8_t line) { |
|||
uint8_t dispX = 0; //small display, use all we have
|
|||
dispX += (mEnScreenSaver) ? (mExtra % 4) : 0; |
|||
setFont(line); |
|||
mDisplay->drawStr(dispX, mLineYOffsets[line], text); |
|||
} |
|||
}; |
|||
@ -1,3 +1,4 @@ |
|||
#include "dbg.h" |
|||
|
|||
DBG_CB mCb = NULL; |
|||
bool mDebugEn = true; |
|||
|
|||
@ -0,0 +1,221 @@ |
|||
//-----------------------------------------------------------------------------
|
|||
// 2023 Ahoy, https://github.com/lumpapu/ahoy
|
|||
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/4.0/deed
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
#ifndef __IMPROV_H__ |
|||
#define __IMPROV_H__ |
|||
|
|||
#include <cstring> |
|||
#include <functional> |
|||
#include "dbg.h" |
|||
#include "AsyncJson.h" |
|||
|
|||
// https://www.improv-wifi.com/serial/
|
|||
// https://github.com/jnthas/improv-wifi-demo/blob/main/src/esp32-wifiimprov/esp32-wifiimprov.ino
|
|||
|
|||
// configure ESP through Serial interface
|
|||
#if !defined(ETHERNET) |
|||
class Improv { |
|||
public: |
|||
void setup(IApp *app, const char *devName, const char *version) { |
|||
mApp = app; |
|||
mDevName = devName; |
|||
mVersion = version; |
|||
|
|||
mScanRunning = false; |
|||
} |
|||
|
|||
void tickSerial(void) { |
|||
if(mScanRunning) |
|||
getNetworks(); |
|||
|
|||
if(Serial.available() == 0) |
|||
return; |
|||
|
|||
uint8_t buf[40]; |
|||
uint8_t len = Serial.readBytes(buf, 40); |
|||
|
|||
if(!checkPaket(&buf[0], len, [this](uint8_t type, uint8_t buf[], uint8_t len) { |
|||
parsePayload(type, buf, len); |
|||
})) { |
|||
DBGPRINTLN(F("check paket failed")); |
|||
} |
|||
dumpBuf(buf, len); |
|||
} |
|||
|
|||
private: |
|||
enum State : uint8_t { |
|||
STATE_STOPPED = 0x00, |
|||
STATE_AWAITING_AUTHORIZATION = 0x01, |
|||
STATE_AUTHORIZED = 0x02, |
|||
STATE_PROVISIONING = 0x03, |
|||
STATE_PROVISIONED = 0x04, |
|||
}; |
|||
|
|||
enum Command : uint8_t { |
|||
UNKNOWN = 0x00, |
|||
WIFI_SETTINGS = 0x01, |
|||
IDENTIFY = 0x02, |
|||
GET_CURRENT_STATE = 0x02, |
|||
GET_DEVICE_INFO = 0x03, |
|||
GET_WIFI_NETWORKS = 0x04, |
|||
BAD_CHECKSUM = 0xFF, |
|||
}; |
|||
|
|||
enum ImprovSerialType : uint8_t { |
|||
TYPE_CURRENT_STATE = 0x01, |
|||
TYPE_ERROR_STATE = 0x02, |
|||
TYPE_RPC = 0x03, |
|||
TYPE_RPC_RESPONSE = 0x04 |
|||
}; |
|||
|
|||
void dumpBuf(uint8_t buf[], uint8_t len) { |
|||
for(uint8_t i = 0; i < len; i++) { |
|||
DHEX(buf[i], false); |
|||
DBGPRINT(" ", false); |
|||
} |
|||
DBGPRINTLN("", false); |
|||
} |
|||
|
|||
inline uint8_t buildChecksum(uint8_t buf[], uint8_t len) { |
|||
uint8_t calc = 0; |
|||
for(uint8_t i = 0; i < len; i++) { |
|||
calc += buf[i]; |
|||
} |
|||
return calc; |
|||
} |
|||
|
|||
inline bool checkChecksum(uint8_t buf[], uint8_t len) { |
|||
/*DHEX(buf[len], false);
|
|||
DBGPRINT(F(" == "), false); |
|||
DBGHEXLN(buildChecksum(buf, len), false);*/ |
|||
return ((buildChecksum(buf, len)) == buf[len]); |
|||
} |
|||
|
|||
bool checkPaket(uint8_t buf[], uint8_t len, std::function<void(uint8_t type, uint8_t b[], uint8_t l)> cb) { |
|||
if(len < 11) |
|||
return false; |
|||
|
|||
if(0 != strncmp((char*)buf, "IMPROV", 6)) |
|||
return false; |
|||
|
|||
// verison check (only version 1 is supported!)
|
|||
if(0x01 != buf[6]) |
|||
return false; |
|||
|
|||
if(!checkChecksum(buf, (9 + buf[8]))) |
|||
return false; |
|||
|
|||
cb(buf[7], &buf[9], buf[8]); |
|||
|
|||
return true; |
|||
} |
|||
|
|||
uint8_t char2Improv(const char *str, uint8_t buf[]) { |
|||
uint8_t len = strlen(str); |
|||
buf[0] = len; |
|||
for(uint8_t i = 1; i <= len; i++) { |
|||
buf[i] = (uint8_t)str[i-1]; |
|||
} |
|||
return len + 1; |
|||
} |
|||
|
|||
void sendDevInfo(void) { |
|||
uint8_t buf[50]; |
|||
buf[7] = TYPE_RPC_RESPONSE; |
|||
buf[9] = GET_DEVICE_INFO; // repsonse to cmd
|
|||
uint8_t p = 11; |
|||
// firmware name
|
|||
p += char2Improv("AhoyDTU", &buf[p]); |
|||
// firmware version
|
|||
p += char2Improv(mVersion, &buf[p]); |
|||
// chip variant
|
|||
#if defined(ESP32) |
|||
p += char2Improv("ESP32", &buf[p]); |
|||
#else |
|||
p += char2Improv("ESP8266", &buf[p]); |
|||
#endif |
|||
// device name
|
|||
p += char2Improv(mDevName, &buf[p]); |
|||
|
|||
buf[10] = p - 11; // sub length
|
|||
buf[8] = p - 9; // paket length
|
|||
|
|||
sendPaket(buf, p); |
|||
} |
|||
|
|||
void getNetworks(void) { |
|||
if(!mScanRunning) |
|||
mApp->scanAvailNetworks(); |
|||
|
|||
JsonObject obj; |
|||
if(!mApp->getAvailNetworks(obj)) |
|||
return; |
|||
|
|||
mScanRunning = false; |
|||
|
|||
uint8_t buf[50]; |
|||
buf[7] = TYPE_RPC_RESPONSE; |
|||
buf[9] = GET_WIFI_NETWORKS; // repsonse to cmd
|
|||
uint8_t p = 11; |
|||
|
|||
JsonArray arr = obj[F("networks")]; |
|||
for(uint8_t i = 0; i < arr.size(); i++) { |
|||
buf[p++] = strlen(arr[i][F("ssid")]); |
|||
// ssid
|
|||
p += char2Improv(arr[i][F("ssid")], &buf[p]); |
|||
buf[p++] = String(arr[i][F("rssi")]).length(); |
|||
// rssi
|
|||
p += char2Improv(String(arr[i][F("rssi")]).c_str(), &buf[p]); |
|||
|
|||
buf[10] = p - 11; // sub length
|
|||
buf[8] = p - 9; // paket length
|
|||
|
|||
sendPaket(buf, p); |
|||
} |
|||
} |
|||
|
|||
void setState(uint8_t state) { |
|||
uint8_t buf[20]; |
|||
buf[7] = TYPE_CURRENT_STATE; |
|||
buf[8] = 0x01; |
|||
buf[9] = state; |
|||
sendPaket(buf, 10); |
|||
} |
|||
|
|||
void sendPaket(uint8_t buf[], uint8_t len) { |
|||
buf[0] = 'I'; |
|||
buf[1] = 'M'; |
|||
buf[2] = 'P'; |
|||
buf[3] = 'R'; |
|||
buf[4] = 'O'; |
|||
buf[5] = 'V'; |
|||
buf[6] = 1; // protocol version
|
|||
|
|||
buf[len] = buildChecksum(buf, len); |
|||
len++; |
|||
Serial.write(buf, len); |
|||
dumpBuf(buf, len); |
|||
} |
|||
|
|||
void parsePayload(uint8_t type, uint8_t buf[], uint8_t len) { |
|||
if(TYPE_RPC == type) { |
|||
if(GET_CURRENT_STATE == buf[0]) { |
|||
setDebugEn(false); |
|||
setState(STATE_AUTHORIZED); |
|||
} |
|||
else if(GET_DEVICE_INFO == buf[0]) |
|||
sendDevInfo(); |
|||
else if(GET_WIFI_NETWORKS == buf[0]) |
|||
getNetworks(); |
|||
} |
|||
} |
|||
|
|||
IApp *mApp; |
|||
const char *mDevName, *mVersion; |
|||
bool mScanRunning; |
|||
}; |
|||
#endif |
|||
|
|||
#endif /*__IMPROV_H__*/ |
|||
Loading…
Reference in new issue