BMW i3 CCS/charge port controller

[Jack Bauer]

Sorry to say I don't know much about the standards you mention. The 2017+ LIM does seem to allow for a negative current command at least based on the information I have.

[tmotion]

Very nice developments. Do you already know how the maximum charge current is defined in de LIM? Will this be fixed to the 50kW i3 speed or can we expect faster CCS charging speeds?

50kW seems a bit slow for today's standards. Anyway still super interesting!

[muehlpower]

Few quick measurements with the sense board connected to the LIM.

When I look at your measurements, it seems to me that the scaling of the 2017+ LIM is also different, which make sense, because the voltage range in the CAN messages is also higher. In my measurements the signal reaches 4.8V at DC500V at the LIM, what do you have at 500V?

[Domt177]

Very nice developments. Do you already know how the maximum charge current is defined in de LIM? Will this be fixed to the 50kW i3 speed or can we expect faster CCS charging speeds?

50kW seems a bit slow for today's standards. Anyway still super interesting!

I asked this on Patreon and Damien said it has a current range of +/- 500A, so much more than the 125 the i3 is limited to

[Jack Bauer]

Will check the span on the voltage measurement board. I hope to have some 2017 and later logs soon.

[EV_Builder]

Very nice developments. Do you already know how the maximum charge current is defined in de LIM? Will this be fixed to the 50kW i3 speed or can we expect faster CCS charging speeds?

50kW seems a bit slow for today's standards. Anyway still super interesting!

I asked this on Patreon and Damien said it has a current range of +/- 500A, so much more than the 125 the i3 is limited to

Albeit (another German word?!?) that's true we still won't know if the greenify phy interface will send just 1:1 the CAN or it has a 'machine limit setting' somewhere for if the plays pong with the bits..

@jack let me know if it makes sense to send my 2018 LIM to you to compare (or if I can compare myself) when I have it here..

[muehlpower]

The limits for pre 2017/26 are 0V-500V 0A-250A, post 2017/27 0V-1000V -500A-+500A.

[EV_Builder]

Ok; so at 400VDC that's 100kw charging for pre 2017/26 and 200kw for post 2017/27.

[bitterandreal]

Ok; so at 400VDC that's 100kw charging for pre 2017/26 and 200kw for post 2017/27.

Most charging stations won't actually deliver 500A.
And you need a very advanced battery pack and thermal management to safely charge at those speeds.
Model 3 for example starts at around 170kW with perfect thermal and SoC conditions but after 5 to 10 minutes the power is down to around 100kW and above 75% more like 50kW...

[bitterandreal]

Sorry to say I don't know much about the standards you mention. The 2017+ LIM does seem to allow for a negative current command at least based on the information I have.

That is great news because that looks like they use ISO 15118 which is great. Plug-and-charge should then work.
They probably don't use ISO 15118-20 which allows V2G because it is only officially released in 2020.
We will see... I'm looking forward to test the LIM with a V2G charger.

[Jack Bauer]

Excellent. Ballpark plan for me is to hit the ccs stations tomorrow sometime. Of course it won't work but will gather info just the same.

[EV_Builder]

Most charging stations won't actually deliver 500A.
And you need a very advanced battery pack and thermal management to safely charge at those speeds.
Model 3 for example starts at around 170kW with perfect thermal and SoC conditions but after 5 to 10 minutes the power is down to around 100kW and above 75% more like 50kW...

Ow that's true. Thermal management should be top notch anyway i think. Anyway thanks for your info. Wasn't planning to charge with 500AMPs on the short term anyway... saying that if everything goes according to plan i will have a taycan setup...

[Jack Bauer]

Ok folks here's where we're at : I'm beating the LIM class for the vcu down to something that should contain the necessary info to initiate dc charge. There are a lot more transitions needed in the dc side of the plan so I need some help here. I've setup a new branch on the vcu repo called ACDC_LIM. Here is my pathetic attempt so far:

Code: Select all

#include <i3LIM.h>

static uint8_t CP_Amps=0;
static uint8_t PP_Amps=0;
static uint8_t CP_Mode=0;
static uint8_t CP_Typ=0;
static uint8_t Batt_Cmp=0;
static uint8_t Flap_stat=0;
static uint8_t Cont_stat=0;
static uint8_t Cont_test=0;
static uint8_t Chg_Phase=0;
static uint16_t Cont_Volts=0;
static uint16_t V_Batt=0;
static uint16_t V_Avail=0;
static uint16_t minV_Avail=0;
static uint16_t I_Avail=0;
static uint16_t CCS_Vmeas=0;
static uint16_t CCS_Imeas=0;
static uint8_t V_Batt2=0;
static int32_t I_Batt=0;
static int32_t I_Math=0;
static uint16_t SOC_Local=0;
static uint16_t Wh_Local=0;
static bool PP=false;
s32fp CHG_Pwr=0; //calculated charge power. 12 bit value scale x25. Values based on 50kw DC fc and 1kw and 3kw ac logs. From bms???
int16_t  FC_Cur=0; //10 bit signed int with the ccs dc current command.scale of 1.
uint8_t  EOC_Time=0x00; //end of charge time in minutes.
uint8_t CHG_Status=0;  //observed values 0 when not charging , 1 and transition to 2 when commanded to charge. only 4 bits used.
                    //seems to control led colour.
uint8_t CHG_Req=0;  //observed values 0 when not charging , 1 when requested to charge. only 1 bit used in logs so far.
uint8_t CHG_Ready=0;  //indicator to the LIM that we are ready to charge. observed values 0 when not charging , 1 when commanded to charge. only 2 bits used.
uint8_t CONT_Ctrl=0;  //4 bits with DC ccs contactor command.

#define Status_NotRdy 0x0 //no led
#define Status_Rdy 0x2  //pulsing blue led when on charge. 0x2. 0x1 = 1 red flash then off
#define Req_Charge 0x1
#define Req_EndCharge 0x0
#define Chg_Rdy 0x1
#define Chg_NotRdy 0x0

#define No_Chg 0x0
#define AC_Chg 0x1
#define DC_Chg 0x2

void i3LIMClass::handle3B4(uint32_t data[2])  //Lim data

{
    uint8_t* bytes = (uint8_t*)data;// arrgghhh this converts the two 32bit array into bytes. See comments are useful:)
    CP_Amps=bytes[0];
    Param::SetInt(Param::PilotLim,CP_Amps);
    PP_Amps=bytes[1];
    Param::SetInt(Param::CableLim,PP_Amps);
    PP=(bytes[2]&0x1);
    Param::SetInt(Param::PlugDet,PP);
    CP_Mode=(bytes[4]&0xF);
     switch (CP_Mode)
    {
        case 0x8:
        CP_Typ=0;   //No pilot signal
        break;

        case 0x9:
        CP_Typ=1;   //Standard AC pilot. Not charging
        break;

        case 0xA:
        CP_Typ=2;   //Standard AC pilot. charging
        break;

        case 0xC:
        CP_Typ=3;   //5% pilot requesting CCS
        break;

        case 0xD:
        CP_Typ=4;   //CCS greenphy comms
        break;

        default:
        CP_Typ=0;   //No pilot signal
        break;
    }
    Param::SetInt(Param::PilotTyp,CP_Typ);

    Cont_Volts=bytes[7]*2;
   // Cont_Volts=FP_MUL(Cont_Volts,2);
    Param::SetInt(Param::CCS_V_Con,Cont_Volts);//voltage measured on the charger side of the hv ccs contactors in the car

}

void i3LIMClass::handle29E(uint32_t data[2])  //Lim data. Available current and voltage from the ccs charger

{
uint8_t* bytes = (uint8_t*)data;// arrgghhh this converts the two 32bit array into bytes. See comments are useful:)
V_Avail=((bytes[2]<<8)|(bytes[1]));
V_Avail=FP_TOINT(FP_DIV(V_Avail,10));
Param::SetInt(Param::CCS_V_Avail,V_Avail);//available voltage from ccs charger

I_Avail=((bytes[4]<<8)|(bytes[3]));
I_Avail=FP_TOINT(FP_DIV(I_Avail,10));
Param::SetInt(Param::CCS_I_Avail,I_Avail);//available current from ccs charger
}

void i3LIMClass::handle2B2(uint32_t data[2])  //Lim data. Current and Votage as measured by the ccs charger

{
uint8_t* bytes = (uint8_t*)data;// arrgghhh this converts the two 32bit array into bytes. See comments are useful:)
CCS_Vmeas=((bytes[1]<<8)|(bytes[0]));
CCS_Vmeas=FP_TOINT(FP_DIV(CCS_Vmeas,10));
Param::SetInt(Param::CCS_V,CCS_Vmeas);//Voltage measurement from ccs charger

CCS_Imeas=((bytes[3]<<8)|(bytes[2]));
CCS_Imeas=FP_TOINT(FP_DIV(CCS_Imeas,10));
Param::SetInt(Param::CCS_I,CCS_Imeas);//Current measurement from ccs charger
Batt_Cmp=bytes[4]&&0xc0;    //battrery compatability flag from charger? upper two bits of byte 4.
}

void i3LIMClass::handle2EF(uint32_t data[2])  //Lim data. Min available voltage from the ccs charger.

{
uint8_t* bytes = (uint8_t*)data;// arrgghhh this converts the two 32bit array into bytes. See comments are useful:)
minV_Avail=((bytes[1]<<8)|(bytes[0]));
minV_Avail=FP_TOINT(FP_DIV(minV_Avail,10));
Param::SetInt(Param::CCS_V_Min,minV_Avail);//minimum available voltage from ccs charger
}

void i3LIMClass::handle272(uint32_t data[2])  //Lim data. CCS contactor state and charge flap open/close status.

{
uint8_t* bytes = (uint8_t*)data;// arrgghhh this converts the two 32bit array into bytes. See comments are useful:)
Cont_stat=bytes[2];
}


void i3LIMClass::Send10msMessages()
{
   V_Batt=Param::GetInt(Param::udc)*10;
   V_Batt2=(Param::GetInt(Param::udc))/4;
   I_Batt=(Param::GetInt(Param::idc)+819)*10;//(Param::GetInt(Param::idc);FP_FROMINT
   //I_Batt=0xa0a0;
   SOC_Local=50;//(Param::GetInt(Param::SOC))*10;
uint8_t bytes[8]; //seems to be from i3 BMS.
bytes[0] = I_Batt & 0xFF;  //Battery current LSB. Scale 0.1 offset 819.2. 16 bit unsigned int
bytes[1] = I_Batt >> 8;  //Battery current MSB. Scale 0.1 offset 819.2.  16 bit unsigned int
bytes[2] = V_Batt & 0xFF;  //Battery voltage LSB. Scale 0.1. 16 bit unsigned int.
bytes[3] = V_Batt >> 8;  //Battery voltage MSB. Scale 0.1. 16 bit unsigned int.
bytes[4] = SOC_Local & 0xFF;;  //Battery SOC LSB. 12 bit unsigned int. Scale 0.1. 0-100%
bytes[5] = SOC_Local >> 8;  //Battery SOC MSB. 12 bit unsigned int. Scale 0.1. 0-100%
bytes[6] = 0x65;  //Low nibble battery status. Seem to need to be 0x5.
bytes[7] = V_Batt2;  //zwischenkreis. Battery voltage. Scale 4. 8 bit unsigned int.

Can::GetInterface(0)->Send(0x112, (uint32_t*)bytes,8); //Send on CAN1


}


void i3LIMClass::Send200msMessages()
{
    Wh_Local=Param::GetInt(Param::BattCap);
    CHG_Pwr=(CHG_Pwr & 0xFFF);
uint8_t bytes[8]; //Main LIM control message
bytes[0] = Wh_Local & 0xFF;  //Battery Wh lowbyte
bytes[1] = Wh_Local >> 8;  //BAttery Wh high byte
bytes[2] = ((CHG_Status<<4)|(CHG_Req));  //charge status in bits 4-7.goes to 1 then 2.8 secs later to 2. Plug locking???. Charge request in lower nibble. 1 when charging. 0 when not charging.
bytes[3] = (((CHG_Pwr)<<4)|CHG_Ready);  //charge readiness in bits 0 and 1. 1 = ready to charge.upper nibble is LSB of charge power.Charge power forecast not actual power!
bytes[4] = CHG_Pwr>>4;   //MSB of charge power.in this case 0x28 = 40x25 = 1000W. Probably net DC power into the Batt.
bytes[5] = FC_Cur & 0xff;   //LSB of the DC ccs current command
bytes[6] = ((CONT_Ctrl<<4)|(FC_Cur>>12));   //bits 0 and 1 MSB of the DC ccs current command.Upper nibble is DC ccs contactor control. Observed in DC fc logs only.
                    //transitions from 0 to 2 and start of charge but 2 to 1 to 0 at end. Status and Ready operate the same as in AC logs.
bytes[7] = EOC_Time;    // end of charge timer.


Can::GetInterface(0)->Send(0x3E9, (uint32_t*)bytes,8); //Send on CAN1

                //LIM needs to see this but doesnt control anything...
bytes[0] = 0xca;
bytes[1] = 0xff;
bytes[2] = 0x0b;
bytes[3] = 0x02;
bytes[4] = 0x69;
bytes[5] = 0x26;
bytes[6] = 0xf3;
bytes[7] = 0x4b;
Can::GetInterface(0)->Send(0x431, (uint32_t*)bytes,8); //Send on CAN1

                //LIM needs to see this but doesnt control anything...
bytes[0] = 0x00;
bytes[1] = 0x00;
bytes[2] = 0x00;
bytes[3] = 0x00;
bytes[4] = 0xfe;
bytes[5] = 0x00;
bytes[6] = 0x00;
bytes[7] = 0x60;
Can::GetInterface(0)->Send(0x560, (uint32_t*)bytes,8); //Send on CAN1

}

void i3LIMClass::Send100msMessages()
{
uint8_t bytes[8]; //Wake up message.
bytes[0] = 0xf5;
bytes[1] = 0x28;
bytes[2] = 0x88;
bytes[3] = 0x1d;
bytes[4] = 0xf1;
bytes[5] = 0x35;
bytes[6] = 0x30;
bytes[7] = 0x80;

Can::GetInterface(0)->Send(0x12f, (uint32_t*)bytes,8); //Send on CAN1

                //central locking status message.
bytes[0] = 0x81;
bytes[1] = 0x00;
bytes[2] = 0x04;
bytes[3] = 0xff;
bytes[4] = 0xff;
bytes[5] = 0xff;
bytes[6] = 0xff;
bytes[7] = 0xff;
Can::GetInterface(0)->Send(0x2fc, (uint32_t*)bytes,8); //Send on CAN1

                //Lim command 2. Used in DC mode

bytes[0] = 0xA2;  //Charge voltage limit LSB. 14 bit signed int.scale 0.1 0xfa2=4002*.1=400.2Volts
bytes[1] = 0x0f;  //Charge voltage limit MSB. 14 bit signed int.scale 0.1
bytes[2] = 0x00;  //Fast charge current limit. Not used in logs from 2014-15 vehicle so far. 8 bit unsigned int. scale 1.so max 254amps in theory...
bytes[3] = 0x18;  //time remaining in seconds to hit soc target from byte 7 in AC mode. LSB. 16 bit unsigned int. scale 10.
bytes[4] = 0x1B;  //time remaining in seconds to hit soc target from byte 7 in AC mode. MSB. 16 bit unsigned int. scale 10.
bytes[5] = 0xFB;  //time remaining in seconds to hit soc target from byte 7 in ccs mode. LSB. 16 bit unsigned int. scale 10.
bytes[6] = 0x06;  //time remaining in seconds to hit soc target from byte 7 in ccs mode. MSB. 16 bit unsigned int. scale 10.
bytes[7] = 0xA0;  //Fast charge SOC target. 8 bit unsigned int. scale 0.5. 0xA0=160*0.5=80%

Can::GetInterface(0)->Send(0x2f1, (uint32_t*)bytes,8); //Send on CAN1

                //Lim command 3. Used in DC mode

bytes[0] = 0x84; //Time to go in minutes LSB. 16 bit unsigned int. scale 1. May be used for the ccs station display of charge remaining time...
bytes[1] = 0x04; //Time to go in minutes MSB. 16 bit unsigned int. scale 1. May be used for the ccs station display of charge remaining time...
bytes[2] = Chg_Phase<<4;  //upper nibble seems to be a mode command to the ccs station. 0 when off, 9 when in constant current phase of cycle.
                    //more investigation needed here...
                   //Lower nibble seems to be intended for two end charge commands each of 2 bits.
bytes[3] = 0xff;
bytes[4] = 0xff;
bytes[5] = 0xff;
bytes[6] = 0xff;
bytes[7] = 0xff;
Can::GetInterface(0)->Send(0x2fa, (uint32_t*)bytes,8); //Send on CAN1

}

uint8_t i3LIMClass::Control_Charge()
{
    int opmode = Param::GetInt(Param::opmode);
    if (opmode != MOD_RUN)
    {
if (Param::GetBool(Param::PlugDet)&&(!Param::GetBool(Param::Chgctrl))&&(CP_Mode==0x9||CP_Mode==0xA))  //if we have an enable and a plug in and a std ac pilot lets go AC charge mode.
{
    Chg_Phase=0x0;
    CONT_Ctrl=0x0; //dc contactor mode 0 in AC
    FC_Cur=0;//ccs current request zero
  EOC_Time=0xFE;
  CHG_Status=Status_Rdy;
  CHG_Req=Req_Charge;
  CHG_Ready=Chg_Rdy;
  CHG_Pwr=6500/25;//approx 6.5kw ac
    return AC_Chg;

}


if (Param::GetBool(Param::PlugDet)&&(!Param::GetBool(Param::Chgctrl))&&(CP_Mode==0xC||CP_Mode==0xD))  //if we have an enable and a plug in and a 5% pilot lets go DC charge mode.
{
/*
DC goes all off, chgstatus=1, chg req=1, contactor=0.then move to chg ready=1.then add eoc time.then add contactor=2.then add current command.
phase 0 at start. then phase 1 when chg status and chg req go to 1. phase 9 when chg readiness goes to 1 then to 2 and onto 3 and send current req.
0x0 Standby
0x1 Initialisation
0x2 Subpoena
0x3 Energy transfer
0x4 Turn off
0xF Reserved
0xE Reserved
0xF Invalid signal

*/
    Chg_Phase=0x0;
    CONT_Ctrl=0x0; //dc contactor mode control required in DC
    FC_Cur=0;//ccs current request zero
  EOC_Time=0xFE;
  CHG_Status=Status_Rdy;
  CHG_Req=Req_Charge;
  CHG_Ready=Chg_Rdy;
  CHG_Pwr=49000/25;//approx 50kw dc
    return DC_Chg;

}


if (!Param::GetBool(Param::PlugDet)||(Param::GetBool(Param::Chgctrl)))  //if we a disable or plug remove shut down
{
    Chg_Phase=0x0;
    CONT_Ctrl=0x0; //dc contactor mode 0 in off
    FC_Cur=0;//ccs current request zero
  EOC_Time=0x00;
  CHG_Status=Status_NotRdy;
  CHG_Req=Req_EndCharge;
  CHG_Ready=Chg_NotRdy;
  CHG_Pwr=0;
    return No_Chg;
}
}

}

Whats needed is a much better state machine to handle the commands. My head is melted so I'm going to the workshop to weld something ...

[Jack Bauer]

So I made myself a little Savvycan special and stepped through the DC logs. A start sequence looks like :
DC Sequence : On detect 5% pilot Chg status goes to 1 and Chg req goes to 1. Target phase standby.
Next step : Target phase initialisation
Set chg power forecast (49050W in logs). Target phase to 9 (unknown?). At this point we switch from 5% to greenphy. Chg readiness to 1.
Contactor weld test begins.Set end of charge timer. V ramps to 410v and holds for a few seconds.
Voltage ramps down to 0 and afer a few seconds we go target phase Subpoena (precharge).
Once contactor measured volts matches batt voltage in 0x112 we go contactor command 2 in 0x3e9 and target phase to energy transfer.
Start sending current command and party hard!

[Isaac96]

Damn! That's actually not all that complicated! (For you)

And of course checksums, keepalive, heartbeat, then the actual implementation.
Contactor weld test -- that's probably done by a separate module?

[Jack Bauer]

The lim does it all. Just send it some can. That said I seem to have misjudged the desire for a cheap,available opensource ccs solution for conversions.

[davefiddes]

Can you push your latest changes to github please? I tried compiling the code from a few posts back but it's missing a few defines from elsewhere.

I'm fed up with my main project for now so I can do something to help improve the VCU codebase and get the LIM support going forwards.

[Jack Bauer]

Tried this today on a ccs station. Got a pilot type 5 which the code doesnt understand so didnt go any further.

Proof I need a break from this. What could 5 mean DUUUHHHHHH!

[davefiddes]

Cool!

Got the code and making a start.

[Jack Bauer]

Thanks Dave. Just pushed a mod to the pilot detection in 0x3b4. I'm an idiot. Its a 3 bit number not 4

Edit so it looks like the ccs station puts a static pilot out at first for some reason before going 5%.

[Jack Bauer]

I am a total moron.

[bji900]

Does the LIM for European CCS work the same as the US one? I would assume so, but just curious. We may not have an answer yet.

[tom91]

I am a total moron.

Oh but your the one in your own built electric car doing the "beep boop" on the laptop. While others buy completed cars like the sheep they are

This is looking to shape up to be a great item.

Official specification shows the CP needing to drop in voltage due to a car being plugged in before the charge station recognizes this and then tries to initalize comm. In other words, Charge station only talks when asked to talk.

[Bryson]

Awesome progress. I’m up to my ears in a drivetrain conversion otherwise I’d be all over this. I imagine there are lots like me who are following along but not ready quite yet.

[Jack Bauer]

Just tried on a 50kw ccs station. I get to state 2 where we ask for weld detect but the LIM is not happy so drops out comms. 100% I'm not sending right can or possibly missing messages but progress just the same. Going to try adding in some messages and return tomorrow. Thanks for the support folks:)