Modification for applying CCCV charging scheme

[paulsteigel]

Hi Armin,
I have added the following procedure to modify the charge scheme for old Luxpower inverter and have tested in a week to:

1. Preventing the cell overvoltage charge;
2. Apply the CCCV charging with Phase 1: Increasing charge current to recommended 0.3 C in 45 minutes; Phase 2: constant Current till reaching expected SOC or the state of potential cell over voltage; and Phase 3: to reduce current gradually to 0 at the final stage.
   I would like to share here for you to consider if this helps. Some modifications to the LimitFrame and data structure is neeed such as: MaxCellVoltage, Battery Type.
   One point to note: the bool IsCharging is set base on your getCurrent(), it has only 2 state. I would like to have isCharging set to true when current is greater than zero but it a bit difficult to work with bit shifting in your getCurrent(), please help ( I have no basic knowledge on C++ programing, what I did was learning from your code and my background on VB)
   Best
   Ngoc

`================CODE==================
// For controlling charge scheme
const uint8_t CHARGE_PHASE_1 = 45;            // 45 minutes warming up, charging current will go up in linear mode
const uint8_t CHARGE_PHASE_3 = 45;            // 45 minutes warming up, charging current will go down gradually in linear mode
//#define SOC_END_CONSTANT_CURRENT  80        // milestone for changing charging scheme
#define CHARGING_CURRENT_PER_CAPACITY 3       // to be three tenth of capacity
#define MAX_SOC_BULK_CHARGE_THRESHOLD_PERCENT 95 // SOC Level to move to absorption mode

const uint8_t CHARGE_RATIO = 60L;
const uint32_t MOMENTARY_CHARGE_DURATION = (2L * CHARGE_RATIO * 1000L);       // if charge is continuing in this duration, the main charging sequense started
const uint32_t CHARGE_STATUS_REFRESH_INTERVAL = (1L * CHARGE_RATIO * 1000L);  // interval for refreshing charge status

bool IsCharging = false;            // Keep state of charging one getcurrent return positive
//uint16_t Max_Charge_Current_100_milliAmp;   // keep peak charging current during warm up for stabilising
uint16_t Computed_Current_limits_100mA;      // tính giới hạn dòng
uint16_t Charge_Current_100_milliAmp;
uint32_t StartChargeTime = 0;                // Store starting time for charge
uint32_t LastCheckTime = 0;                  // Record time count for each charging check
uint8_t ChargePhase = 0;                     // Charging phase (1CC,2CC,3CV)
uint8_t MinuteCount = 0; // counting minutes for charge
// End of controlling charge scheme

/* This part is for controlling the charge scheme 
 * following CCCV method
 * 1.Warm-up in about 40 minutes; 2. Constant current till certain voltage or SOC;
 * 3.Constant Voltage with reduction of charging curent till SOC 100% or 3.40 V for LFP, 4.15 V for Lion (about 3h)
 * Warmup 40 keep 160  cool-down 45 minutes
*/
 
void ControlChargeScheme(){
  uint8_t ChargeStatusRef = 0;
  if (IsCharging) {
    if (StartChargeTime == 0) {
      StartChargeTime = millis(); // Store starting time for charge
      // Get the proper charging current: either BMS limit or using 0.3C
      Computed_Current_limits_100mA = min(swap(sJKFAllReplyPointer->ChargeOvercurrentProtectionAmpere) * 10, 
      JKComputedData.TotalCapacityAmpereHour * CHARGING_CURRENT_PER_CAPACITY);
      Serial.println(F("Charging check: >Selected Current:")); Serial.print(Computed_Current_limits_100mA);   
    }
  } else {
    resetCharge();
    return;
  }
  
  // Get into current charging phase  
  if (StartChargeTime == 0) return; // No charging detected
  // Allow this to be triggered once
  if (ChargePhase == 0) {
    if ((millis() - StartChargeTime) < MOMENTARY_CHARGE_DURATION) return;
    // Charge started in more than MOMENTARY_CHARGE_DURATION, charging started, get into phase 1
    MinuteCount = MOMENTARY_CHARGE_DURATION / (CHARGE_RATIO * 1000L); // Marking the counter for warming up charge
    ChargePhase = 1;
    Serial.println(F("Enter phase 1:"));Serial.print(MinuteCount);
  }

  // Check if end of phase 1, move to phase 2 or next 
  if (ChargePhase == 1) {
    if ((millis() - StartChargeTime) >= ((CHARGE_PHASE_1 + 1) * CHARGE_RATIO * 1000L)) {
      ChargePhase = 2;
      MinuteCount = 0; //reset the minute counter to enter phase 2
      Serial.println(F("Enter phase 2:"));Serial.print(MinuteCount);
    }    
  } else if (ChargePhase == 2) {
    ChargeStatusRef = ReachChargeLimit();          
    if (ChargeStatusRef == 1) {      
      ChargePhase = 3;  
      MinuteCount = 0; //reset the minute counter during phase 2
    } else if (ChargeStatusRef == 2) {
      // reducing current by 10%
      Charge_Current_100_milliAmp = Charge_Current_100_milliAmp * 0.98;
    }
  }
  
  if ((millis() - LastCheckTime) < CHARGE_STATUS_REFRESH_INTERVAL) return;
  LastCheckTime = millis(); //reset the counter for resuming the check
  switch (ChargePhase) {
  case 1:        
    // Linear mapping of charging current until reaching 0.3C
    Charge_Current_100_milliAmp = map(MinuteCount, 1, CHARGE_PHASE_1, 0, Computed_Current_limits_100mA);    
    PylontechCANBatteryLimitsFrame.FrameData.BatteryChargeCurrentLimit100Milliampere = Charge_Current_100_milliAmp;
    MinuteCount ++;
    Serial.println(F("Charging phase 1: minute count::"));Serial.print(MinuteCount);
    Serial.print(F("Applied charged current::"));
    Serial.print(PylontechCANBatteryLimitsFrame.FrameData.BatteryChargeCurrentLimit100Milliampere);
    Serial.print(F("/"));Serial.print(Computed_Current_limits_100mA); 

    break;
  case 2: 
    // in this phase, do nothing to current at all
    Serial.println(F("Charging phase 2: Minute count::"));Serial.print(MinuteCount);
    Serial.print(F("Applied charged current::"));
    Serial.print(Charge_Current_100_milliAmp);
    Serial.print(F("/"));Serial.print(Computed_Current_limits_100mA);
    MinuteCount ++;    
    break;
  case 3: 
    //Keep charging till full or when the Inverter stop charging, need a new routine for this charging   
    Serial.println(F("Charging phase 3: Minute count::"));Serial.print(MinuteCount);
    MinuteCount ++;     
    if (ChargeStatusRef != 2) Charge_Current_100_milliAmp = map(MinuteCount, 1, CHARGE_PHASE_3, Computed_Current_limits_100mA, 0);
    PylontechCANBatteryLimitsFrame.FrameData.BatteryChargeCurrentLimit100Milliampere = Charge_Current_100_milliAmp;        
    Serial.println(F("Applied charged current::"));
    Serial.print(PylontechCANBatteryLimitsFrame.FrameData.BatteryChargeCurrentLimit100Milliampere);
    Serial.print(F("/"));Serial.print(Computed_Current_limits_100mA); 

    if (Charge_Current_100_milliAmp == 0) {
      // tell the inverter to stop charging or keep it to maintain the charge
      Serial.print(F("End of charge"));
      resetCharge();
    }
    break;
  default:
    // statements
    break;
  }      
}

void resetCharge(){
  Serial.println(F("Reset charge"));
  StartChargeTime = 0; // reset charge starting time
  LastCheckTime = 0;
  MinuteCount = 0;
  ChargePhase = 0;    
  // recover the charging limits
  PylontechCANBatteryLimitsFrame.FrameData.BatteryChargeCurrentLimit100Milliampere = 
  swap(sJKFAllReplyPointer->ChargeOvercurrentProtectionAmpere) * 10;
}

uint8_t ReachChargeLimit(){ 
  /* Status return: 
   *  0: nothing; 
   *  1: stop phase; 
   *  2: reducing current 10%; 
  */
  //will do this check every 5 minutes
  uint16_t Charge_MilliVolt_limit = 0;  
  if ((millis() - LastCheckTime) < CHARGE_STATUS_REFRESH_INTERVAL) return 0;
  // first check over voltage
  if (JKComputedData.BatteryType == 0) {//LFP battery  
    Charge_MilliVolt_limit = 3450;
  } else if (JKComputedData.BatteryType == 1){ //Lithium ion       
    Charge_MilliVolt_limit = 4200;  
  }
  // check SOC First
  return (sJKFAllReplyPointer->SOCPercent >= MAX_SOC_BULK_CHARGE_THRESHOLD_PERCENT)? 1 : 0;   
  Serial.println(F("Battery type:")); Serial.print(JKComputedData.BatteryType);
  if ((JKComputedData.MaximumCellMillivolt * 1.02) > Charge_MilliVolt_limit) {
    Serial.println(F("Status check 1")); Serial.print((JKComputedData.MaximumCellMillivolt * 1.02) - Charge_MilliVolt_limit);    
    return 2;  
  }       
}

//Modification to the LimitFrame
struct PylontechCANBatteryLimitsFrameStruct {
    struct PylontechCANFrameInfoStruct PylontechCANFrameInfo = { PYLON_CAN_BATTERY_LIMITS_FRAME_ID, 8 }; // 0x351
    struct {
        int16_t BatteryChargeOvervoltage100Millivolt;       // 0 to 750
        int16_t BatteryChargeCurrentLimit100Milliampere;    // 0 to 5000
        int16_t BatteryDischargeCurrentLimit100Milliampere; // -5000 to 0
        int16_t BatteryDischarge100Millivolt;               // 0 to 65535 // not in documentation
    } FrameData;
    void fillFrame(struct JKReplyStruct *aJKFAllReply) {
        FrameData.BatteryChargeOvervoltage100Millivolt = JKComputedData.BatteryFullVoltage10Millivolt / 10;
        if (Charge_Current_100_milliAmp > 0){
          FrameData.BatteryChargeCurrentLimit100Milliampere = Charge_Current_100_milliAmp;
        }else {
          FrameData.BatteryChargeCurrentLimit100Milliampere = swap(aJKFAllReply->ChargeOvercurrentProtectionAmpere) * 10;
        }
        FrameData.BatteryDischargeCurrentLimit100Milliampere = swap(aJKFAllReply->DischargeOvercurrentProtectionAmpere) * 10;
        FrameData.BatteryDischarge100Millivolt = swap(aJKFAllReply->BatteryUndervoltageProtection10Millivolt) / 10;
    }
};

`

[ArminJo]

Hi Ngoc,
in which of your branches can I find your current version?
So I can have a look at your code in a more complete context.
Thanks
Armin

[paulsteigel]

Hi Armin,
I did not make it on git hub as I am using Arduino ide, let's me update on GitHub for now!.
I tried adding my editions to the main branch, as the development process takes time, there might be some declaration missing but I placed the main code revision on the ino, jk-bms.h/hpp and pylontechcan.h/hpp already.
I will make a test on wokwi to see what is missing.
The only thing that I found not yet implemented is reporting of charge cycle to the inverter.
The following bits of code from Peter(https://github.com/Uksa007/esphome-jk-bms-can/blob/deprecated/esp32-example-can.yaml - line 245-276) worked but it is not very stable, see the images below

- canbus.send: # Actual SOC, SOH
          can_id: 0x355
          data: !lambda |-
            int soh = round(((id(charging_cycles).state/${max_cycles})-1)*-100);
            uint8_t can_mesg[3];
            can_mesg[0] = uint16_t(id(capacity_remaining).state) & 0xff;
            can_mesg[1] = uint16_t(id(capacity_remaining).state) >> 8 & 0xff;
            can_mesg[2] = soh & 0xff;
            can_mesg[3] = soh >> 8 & 0xff;
            ESP_LOGI("main", "send can id: 0x355 hex: %x %x %x %x", can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3]);
            return {can_mesg[0], can_mesg[1], can_mesg[2], can_mesg[3]};
      - delay: 10ms

Worked report to the inverter on ESPHOME: Through the ESPHOME versions (from Peter) does not send the max/min, and a bit unstable overtime. I revised his Can ID from 0x371 to 0x373 (using byd datasheet after some trials and errors at https://github.com/dfch/BydCanProtocol/tree/main)

Not worked implementation on current nano/uno version, I tried with 0x355 with no success. So my doubt is about the incorrect form of Can message.

That's all for now.
Best
Ngoc

PS: I am not quite familiar with C++ and your code taugh me a lot despite of a lot of struggle with uint8/16/32_t type...
Great thanks to your valuable works. I am thinking about make this work for ESP32 (not using ESPHOME) and use blynk or thingboards to make data accessible from elsewhere.

[ArminJo]

Hi Ngoc,
I included the 0x373 frame, this is enabled by default in line 260 in JK-BMSToPylontechCAN.cpp
I also added your CCCV schema. this must be enabled by define CAN_DATA_MODIFICATION in line 113 and #define USE_CCCV_MODIFY_FUNCTION in line 114 JK-BMSToPylontechCAN.cpp

Can you test this version at your site, especially the CCCV scheme?
The temperature bug is fixed in this version 😃.

Thanks for your contributing
Armin

[paulsteigel]

Hi Armin,
Many thanks for your supports, I will keep testing the CCCV for another week, actually, I have tested it a week by now! In included the 0x373 revision in the program and it has error during the compiling as below:

I checked your swap function and unable to find the problem

As it is a part of my learning curve for C++, can you be so kind to explain this for me with thank

return ((aWordToSwapBytes << 8) | (aWordToSwapBytes >> 8));

Possibly, there is a lack of a swap function with int_16t. I have very limited knowledge on bitwise activity then. Can you write another swap funtion with int16_t

Best
Ngoc

[ArminJo]

There is a new function

int16_t swap(int16_t aWordToSwapBytes) {
    return ((aWordToSwapBytes << 8) | (aWordToSwapBytes >> 8));
}

in JK-BMS.hpp