Support for DalyBMS

include/BatteryStats.h

@@ -86,6 +86,41 @@ class PylontechBatteryStats : public BatteryStats {
         bool _chargeImmediately;
 };
 
+class DalyBatteryStats : public BatteryStats {
+    friend class DalyBms;
+
+    public:
+        void getLiveViewData(JsonVariant& root) const final;
+        void mqttPublish() const final;
+
+    private:
+        void setManufacturer(String&& m) { _manufacturer = std::move(m); }
+        void setSoC(uint8_t SoC) { _SoC = SoC; _lastUpdateSoC = millis(); }
+        void setLastUpdate(uint32_t ts) { _lastUpdate = ts; }
+
+        float _voltage;
+        float _current;
+        float _temperature;
+        float _maxCellmV;
+        uint8_t _maxCellVNum;
+        float _minCellmV;
+        uint8_t _minCellVNum;
+        float _cellDiff;
+        std::string _state;
+        uint8_t _numberOfCells;
+        uint8_t _numOfTempSensors;
+        uint8_t _chargeState;
+        uint8_t _loadState;
+        bool _chargeFetState;
+        bool _dischargeFetState;
+        int _bmsHeartBeat;
+        float _resCapacityAh;
+        int _bmsCycles;
+        float _cellVmV[48];
+        bool _cellBalanceActive;
+        bool _connectionState;
+};
+
 class JkBmsBatteryStats : public BatteryStats {
     public:
         void getLiveViewData(JsonVariant& root) const final {

include/DalyBms.h

@@ -0,0 +1,203 @@
+/*
+DALY2MQTT Project
+https://github.com/softwarecrash/DALY2MQTT
+*/
+#include "SoftwareSerial.h"
+#include "Battery.h"
+#ifndef DALY_BMS_UART_H
+#define DALY_BMS_UART_H
+
+#define XFER_BUFFER_LENGTH 13
+#define MIN_NUMBER_CELLS 1
+#define MAX_NUMBER_CELLS 48
+#define MIN_NUMBER_TEMP_SENSORS 1
+#define MAX_NUMBER_TEMP_SENSORS 16
+
+#define START_BYTE 0xA5; // Start byte
+#define HOST_ADRESS 0x40; // Host address
+#define FRAME_LENGTH 0x08; // Length
+#define ERRORCOUNTER 10 //number of try befor clear data
+
+//time in ms for delay the bms requests, to fast brings connection error
+
+#define DELAYTINME 100
+
+class DalyBms  : public BatteryProvider {
+public:
+    bool init(bool verboseLogging) final;
+    void deinit() final;
+    void loop() final;
+    std::shared_ptr<BatteryStats> getStats() const final { return _stats; }
+
+    unsigned long previousTime = 0;
+    byte requestCounter = 0;
+    String failCodeArr;
+
+    enum COMMAND
+    {
+        CELL_THRESHOLDS = 0x59,
+        PACK_THRESHOLDS = 0x5A,
+        VOUT_IOUT_SOC = 0x90,
+        MIN_MAX_CELL_VOLTAGE = 0x91,
+        MIN_MAX_TEMPERATURE = 0x92,
+        DISCHARGE_CHARGE_MOS_STATUS = 0x93,
+        STATUS_INFO = 0x94,
+        CELL_VOLTAGES = 0x95,
+        CELL_TEMPERATURE = 0x96,
+        CELL_BALANCE_STATE = 0x97,
+        FAILURE_CODES = 0x98,
+        DISCHRG_FET = 0xD9,
+        CHRG_FET = 0xDA,
+        BMS_RESET = 0x00,
+        READ_SOC = 0x61, //read the time and soc
+        SET_SOC = 0x21, //set the time and soc
+        //END = 0xD8,
+        //after request the pc soft hangs a 0xD8 as last request, its empty, dont know what it means?
+    };
+
+
+    /**
+     * @brief Gets Voltage, Current, and SOC measurements from the BMS
+     * @return True on successful aquisition, false otherwise
+     */
+    bool getPackMeasurements();
+
+    /**
+     * @brief Gets the pack temperature from the min and max of all the available temperature sensors
+     * @details Populates tempMax, tempMax, and tempAverage in the "get" struct
+     * @return True on successful aquisition, false otherwise
+     */
+    bool getPackTemp();
+
+    /**
+     * @brief Returns the highest and lowest individual cell voltage, and which cell is highest/lowest
+     * @details Voltages are returned as floats with milliVolt precision (3 decimal places)
+     * @return True on successful aquisition, false otherwise
+     */
+    bool getMinMaxCellVoltage();
+
+    /**
+     * @brief Get the general Status Info
+     *
+     */
+    bool getStatusInfo();
+
+    /**
+     * @brief Get Cell Voltages
+     *
+     */
+    bool getCellVoltages();
+
+    /**
+     * @brief
+     * set the Discharging MOS State
+     */
+    bool setDischargeMOS(bool sw);
+
+    /**
+     * @brief set the Charging MOS State
+     *
+     */
+    bool setChargeMOS(bool sw);
+
+    /**
+     * @brief set the SOC
+     *
+     */
+    bool setSOC(float sw);
+
+    /**
+     * @brief Read the charge and discharge MOS States
+     *
+     */
+    bool getDischargeChargeMosStatus();
+
+    /**
+     * @brief Reseting The BMS
+     * @details Reseting the BMS and let it restart
+     */
+    bool setBmsReset();
+
+    /**
+     * @brief return the state of connection to the BMS
+     * @details returns the following value for different connection state
+     * -3 - could not open serial port
+     * -2 - no data recived or wrong crc, check connection
+     * -1 - working and collecting data, please wait
+     *  0 - All data recived with correct crc, idleing
+     *
+     * now changed to bool, only true if data avaible, false when no connection
+     */
+    bool getState();
+
+private:
+    bool _verboseLogging = true;
+    std::shared_ptr<DalyBatteryStats> _stats =
+        std::make_shared<DalyBatteryStats>();
+
+    bool getStaticData = false;
+    unsigned int errorCounter = 0;
+    unsigned int requestCount = 0;
+    uint32_t _lastRequest = 0;
+    uint8_t _pollInterval = 5;
+    unsigned int commandQueue[5] = {0x100, 0x100, 0x100, 0x100, 0x100};
+    /**
+     * @brief send the command id, and return true if data complete read or false by crc error
+     * @details calculates the checksum and sends the command over the specified serial connection
+     */
+    bool requestData(COMMAND cmdID, unsigned int frameAmount);
+
+    /**
+     * @brief Sends a complete packet with the specified command
+     * @details calculates the checksum and sends the command over the specified serial connection
+     */
+    bool sendCommand(COMMAND cmdID);
+
+    /**
+     * @brief command queue
+     */
+    bool sendQueueAdd(COMMAND cmdID);
+
+    /**
+     * @brief Send the command ID to the BMS
+     * @details
+     * @return True on success, false on failure
+     */
+    bool receiveBytes(void);
+
+    /**
+     * @brief Validates the checksum in the RX Buffer
+     * @return true if checksum matches, false otherwise
+     */
+    bool validateChecksum();
+
+    /**
+     * @brief Prints out the contense of the RX buffer
+     * @details Useful for debugging
+     */
+    void barfRXBuffer();
+
+    /**
+     * @brief Clear all data from the Get struct
+     * @details when wrong or missing data comes in it need sto be cleared
+     */
+    void clearGet();
+
+    /**
+     * @brief Buffer used to transmit data to the BMS
+     * @details Populated primarily in the "Init()" function, see the readme for more info
+     */
+    uint8_t my_txBuffer[XFER_BUFFER_LENGTH];
+
+    /**
+     * @brief Buffer filled with data from the BMS
+     */
+    uint8_t my_rxBuffer[XFER_BUFFER_LENGTH];
+
+
+uint8_t my_rxFrameBuffer[XFER_BUFFER_LENGTH*12];
+uint8_t frameBuff[12][XFER_BUFFER_LENGTH];
+unsigned int frameCount;
+};
+
+#endif // DALY_BMS_UART_H

src/Battery.cpp

@@ -3,6 +3,7 @@
 #include "MessageOutput.h"
 #include "PylontechCanReceiver.h"
 #include "JkBmsController.h"
+#include "DalyBms.h"
 #include "VictronSmartShunt.h"
 #include "MqttBattery.h"
 
@@ -61,6 +62,10 @@ void BatteryClass::updateSettings()
             _upProvider = std::make_unique<VictronSmartShunt>();
             if (!_upProvider->init(verboseLogging)) { _upProvider = nullptr; }
             break;
+         case 4:
+            _upProvider = std::make_unique<DalyBms>();
+            if (!_upProvider->init(verboseLogging)) { _upProvider = nullptr; }
+            break;
         default:
             MessageOutput.printf("Unknown battery provider: %d\r\n", config.Battery.Provider);
             break;

src/BatteryStats.cpp

@@ -99,6 +99,28 @@ void PylontechBatteryStats::getLiveViewData(JsonVariant& root) const
     addLiveViewAlarm(root, "bmsInternal", _alarmBmsInternal);
 }
 
+void DalyBatteryStats::getLiveViewData(JsonVariant& root) const
+{
+    BatteryStats::getLiveViewData(root);
+
+    if (_connectionState==true){
+    // values go into the "Status" card of the web application
+        addLiveViewValue(root, "voltage", _voltage, "V", 2);
+        addLiveViewValue(root, "current", _current, "A", 1);
+        addLiveViewValue(root, "temperature", _temperature, "°C", 1);
+        addLiveViewTextValue(root, "status", _state);
+        addLiveViewValue(root, "cellMaxVoltage", _maxCellmV, "mV", 0);
+        addLiveViewValue(root, "cellMinVoltage", _minCellmV, "mV", 0);
+        addLiveViewValue(root, "cellDiffVoltage", _cellDiff, "mV", 0);
+        addLiveViewTextValue(root, "chargeEnabled", (_chargeFetState?"yes":"no"));
+        addLiveViewTextValue(root, "dischargeEnabled", (_dischargeFetState?"yes":"no"));
+        addLiveViewValue(root, "chargeCycles", _bmsCycles,"",0);
+        addLiveViewValue(root, "remainingAh", _resCapacityAh,"Ah",1);
+    } else {
+
+    }
+}
+
 void JkBmsBatteryStats::getJsonData(JsonVariant& root, bool verbose) const
 {
     BatteryStats::getLiveViewData(root);
@@ -250,6 +272,34 @@ void PylontechBatteryStats::mqttPublish() const
     MqttSettings.publish(F("battery/charging/chargeImmediately"), String(_chargeImmediately));
 }
 
+void DalyBatteryStats::mqttPublish() const
+{
+    BatteryStats::mqttPublish();
+
+    MqttSettings.publish(F("battery/soc"), String(_SoC));
+    MqttSettings.publish(F("battery/voltage"), String(_voltage));
+    MqttSettings.publish(F("battery/current"), String(_current));
+    MqttSettings.publish(F("battery/temperature"), String(_temperature));
+    MqttSettings.publish(F("battery/minCellmV"), String(_minCellmV));
+    MqttSettings.publish(F("battery/minCellmVNum"), String(_minCellVNum));
+    MqttSettings.publish(F("battery/maxCellmV"), String(_maxCellmV));
+    MqttSettings.publish(F("battery/maxCellmVNum"), String(_maxCellVNum));
+    MqttSettings.publish(F("battery/cellmVDrift"), String(_cellDiff));
+    MqttSettings.publish(F("battery/status"), _state.c_str());
+    MqttSettings.publish(F("battery/chargeFetState"), String(_chargeFetState));
+    MqttSettings.publish(F("battery/dischargeFetState"), String(_dischargeFetState));
+    MqttSettings.publish(F("battery/numberOfCells"), String(_numberOfCells));
+    MqttSettings.publish(F("battery/numOfTempSensors"), String(_numOfTempSensors));
+    MqttSettings.publish(F("battery/chargeState"), String(_cellDiff));
+    MqttSettings.publish(F("battery/loadState"), String(_loadState));
+    MqttSettings.publish(F("battery/cycles"), String(_bmsCycles));
+    MqttSettings.publish(F("battery/remainingAh"), String(_resCapacityAh));
+    MqttSettings.publish(F("battery/bmsHeartBeat"), String(_bmsHeartBeat));
+    for (uint8_t c = 0; c<_numberOfCells;c++){
+        MqttSettings.publish("battery/cell_" + String(c), String(_cellVmV[c]));
+    }
+}
+
 void JkBmsBatteryStats::mqttPublish() const
 {
     BatteryStats::mqttPublish();