BMS s komunikací RS485/232/Modbus

[Marcus81]

Nikto mi tu nevie s tym poradit?
Je mozne na bms 16s pripojit napr. iba 4s?

[FRSO]

Nikto mi tu nevie s tym poradit?
Je mozne na bms 16s pripojit napr. iba 4s?

Dle mě určitě ne, nevím o tom, zeptej se ještě mikela na fóru.

[Lui]

Nikto mi tu nevie s tym poradit?
Je mozne na bms 16s pripojit napr. iba 4s?

večšinou každý výrobca udáva na aký počet článkov má BMS,tie čo napríklad ja používam fungujú 8-16S ak by som potreboval inú možnú kombináciu článkov,tak si vyberiem nejakú inú...je trebars aj 8-24S alebo aj 10-32S iné kombinácie nepoznám,kedže v mojom systéme som neriešil nikdy,kedže to nie je pre mňa potrebné...

[Joskob]

Nikto mi tu nevie s tym poradit?
Je mozne na bms 16s pripojit napr. iba 4s?

Mam 7S bms od cinana z lithiumbatterypcb a da sa nastavit od 1S az po 10S. Taktiez bms Mgod (vyzera ako nejaky klon Daly bms)

[ViktorEX]

hmm, hezky ... ale dal mi to nepomohlo... nemate prosim nekdo nejaky vzorovy programek?

Tak je to ten Foxtrot, třeba trochu pomůže pro inspiraci.

Kód: Vybrat vše

VAR_GLOBAL
  NUM_DALYS : USINT := 2;  // number of Dalys present
  CH_DALYS : UINT := CH3_UNI;  // UNI channel for the communication
  DALYADDR : ARRAY[1..3] of BYTE := [16#40, 16#41, 0];  // Daly addresses
  Timeout_recv_Daly : TIME := T#100MS;        // How long wait for Daly response
  CurrentBatSum : Real;   // sum of battery current from all BMS
  CurrentBatSum_cl : CL;   // color of battery current from all BMS: > 0.5 green; < -0.5 orange; else green

END_VAR


// Structure for receiving and storing raw Daly data
TYPE
  DALYBMSDATA : STRUCT

    LastError_text : STRING;
    LastError_datetime : DT;
    ErrorCount : USINT;
    LastReceive_datetime : DT;
    ReceiveOKCount : USINT;  // counter of correct communications
    maxvoltage : REAL; // maximum cell voltage
    minvoltage : REAL; // minimum cell voltage
    totvoltage : REAL; // total battery voltage "pressure"
    current : REAL; // proud
    SOC : REAL; // SOC
    minVcellNo: USINT;  // cell no with minimum voltage
    maxVcellNo: USINT;  // cell no with maximum voltage
    temperature : INT; // temperatureplota
    state : USINT; // 0 - static  1 - charge   2 - discharge
    statea : CL; // rgb
    balancing : string[4];   // 16 battery cells in pack expected here
    MOScharging : USINT; // 1 - MOS for charging on
    MOSLoad : USINT;   // 1 - MOS for discharging on
    faultstatus1 : string[8];  // bits indicating error
    faultstatus2 : string[8];  // bits indicating error 2
  END_STRUCT
END_TYPE

// Daly values store
VAR_GLOBAL RETAIN
  dalys : ARRAY[1..3] OF DALYBMSDATA;
  daly_diffvoltage_1 : real; // difference of voltage between min and max for battery 1
  daly_diffvoltage_2 : real; // difference of voltage between min and max for battery 2
END_VAR

Kód: Vybrat vše

// Communicate with Daly BMS

// Expected RS-485, all Dalys to use a single communication channel


// function to calculate checksum
FUNCTION bchksm : USINT
  VAR_INPUT
    cfrom : PTR_TO USINT; // USINT pointer to start from
    numbytes : UINT; // number of bytes
  END_VAR
  VAR
    a : USINT;
  END_VAR

  REPEAT
    a := a + cfrom^;
    cfrom := cfrom + 1;
    numbytes := numbytes - 1;
  UNTIL numbytes = 0 END_REPEAT;
  bchksm := a;
END_FUNCTION

// Structure for received message
TYPE
  Dalyrecv : STRUCT
    error : STRING[250]; // error found, '' if none
    status : USINT; // processing status: 0: ready, 1: sending, 2: receiving, 3: result ready, 4: error
    lenmesrec : UINT; // length of the raw received message
    datarec : STRING[13]; // raw content of the received message
  END_STRUCT
END_TYPE


// send and receive one message from/to Daly
FUNCTION_BLOCK fbDalySendRec1
  VAR_INPUT
    init : BOOL; // trigger to start processing
    dst_addr : BYTE;    // address of Daly to send data to
    data_id : BYTE;   // command id
  END_VAR
  VAR_OUTPUT
    rm : Dalyrecv; // Daly status and data structure
  END_VAR
  VAR
    m : STRING[13]; // message data to send
    r : STRING[13]; // message data received
    pb : PTR_TO BYTE;
    pd : PTR_TO DWORD;
    // helpers
    chs : USINT;
    SendToDaly : fbSendTo;
    RecvFromDaly : fbRecvFrom;
    recvTimer : TON; // receiving timer
  END_VAR

  // init and send the message?
  IF init THEN
    recvTimer(IN := False, PT := Timeout_Recv_Daly);

    // construct the message to be sent
    rm.error := ''; // expect no error
    pb := adr(m); // to initial byte
    pb^ := 16#A5;
    pb := pb + 1; // to communication module address
    pb^ := dst_addr;
    //pb^ := SHL(dst_addr, 4);
    pb := pb + 1; // to data id
    pb^ := data_id;
    pb := pb + 1; // to data legth
    pb^ := 8;
    // may process data to send here, if any
    pd := pb + 1; // to first data DWORD
    pd^ := 0;
    pd := pd + 4; // to second data DWORD
    pd^ := 0;
    pb := pd + 4; // to checksum
    pb^ := USINT_TO_BYTE(bchksm(adr(m), 12));

    // send
    SendToDaly(rq :=True, chanCode := CH_DALYS, lenTx := 13, data := void(m));

    // initiate receiving timer
    recvTimer(IN := True);
    
    rm.status := 2; // receiving
  END_IF;

  // exit if the main program did not processed the response (3 = response data, 4 = error), then return without further processing
  IF rm.status > 2 THEN
    RETURN;
  END_IF;

  // initiate message receive if status = 2
  RecvFromDaly(rq :=True, chanCode := CH_DALYS, lenRx := 13, data := void(r));

  // message not received?
  IF not RecvFromDaly.mesRec THEN
    // timeout?
    IF recvTimer.Q THEN
      rm.error := 'General receive error: response timeout';
      rm.status := 4; // present the error
      return;
    ELSE
      return; // message not received and no timeout - continue waiting for response
    END_IF;
  ELSE // message received

    // message received - check general error
    IF RecvFromDaly.error <> 0 THEN
      rm.error := concat('General receive error: ', GetLastComErrTxt(RecvFromDaly.error));
      rm.status := 4; // indicate the error
      return;
    END_IF;
    // no error, start parsing
    rm.lenmesrec := RecvFromDaly.lenData;
    // despite potenital error, copy the received data to the output variable, if not too long
    IF rm.lenmesrec <= 13 THEN
      Memcpy(length := rm.lenmesrec, source := void(r), dest := void(rm.datarec));
    END_IF;
    pb := adr(rm.datarec); // to start_byte
    // check start byte
    IF not pb^ = 16#a5 THEN
      // first byte is not A5
      rm.error := 'Daly receive error: the first byte is not A5';
      rm.status := 4; // indicate the error
      return;
    END_IF;
    // verify checksum
    pb := pb + 12;
    chs := BYTE_TO_USINT(pb^);
    IF chs <> bchksm(adr(rm.datarec), 12) THEN
      rm.error := 'Daly receive error: checksum verification failed';
      rm.status := 4; // indicate the error
      return;
    ELSE
      // indicate correctly received data
      rm.status := 3;
    END_IF;
  END_IF;
END_FUNCTION_BLOCK


PROGRAM DalyBMS
  VAR
    a : fbDalySendRec1; // function block to send one message to Studer and receive response
    s : Dalyrecv; // structure with receive data
    tinit : BOOL := True; // for the first run, lanuch
    pw : PTR_TO WORD;
    pb : PTR_TO BYTE;
    pd : PTR_TO DWORD;
    daly_id : USINT := 1;           //current Daly to process
    daly_addr : BYTE ;               // current Daly address
    COMMAND_MIN : USINT := 16#90;    // minimum no of command to be sent
    COMMAND_MAX : USINT := 16#98;   // maximum no of command to be sent
    command_id : USINT := 16#90;  // work variable - current command_id
    i : USINT;
  END_VAR

  // if tinit, go to next command or next Daly
  if tinit THEN
    command_id := command_id + 1;
    if command_id > COMMAND_MAX THEN
       // first command id
       command_id := COMMAND_MIN;
       // next daly
       daly_id := daly_id + 1;
       if daly_id > NUM_DALYS THEN daly_id := 1; END_IF;
    end_if;
  END_IF;

  // take daly address
  daly_addr := DALYADDR[daly_id];

  // process the current command for the current Daly
  a(init := tinit, dst_addr := daly_addr, data_id := USINT_TO_BYTE(command_id), rm => s);
  tinit := False; // synchronous - wait for response

    // verify if response or came and process
  CASE s.status OF
    2:
       RETURN;

    4 :
      // mark error to the Daly data
      dalys[daly_id].LastError_text  := s.error;
      dalys[daly_id].LastError_datetime  := GetDateTime();
      dalys[daly_id].ErrorCount  := dalys[daly_id].ErrorCount + 1;
      tinit := True;

    3 :
      // mark last received data to Daly
      dalys[daly_id].LastReceive_datetime := GetDateTime();
      dalys[daly_id].ReceiveOKCount := dalys[daly_id].ReceiveOKCount + 1;
      tinit := True;
      
      // parse - go to the first data byte
      pw := adr(s.datarec) + 4;
      pb := pw;
      pd := pw;

      case command_id of

      16#90:
         dalys[daly_id].totvoltage := int_to_real(int_to_int(word_to_int(pw^))) * 0.1;
         pw := pw + 4;
         dalys[daly_id].current := - (int_to_real(int_to_int(word_to_int(pw^))) - 30000) * 0.1; // A
         pw := pw + 2;
         dalys[daly_id].SOC := int_to_real(int_to_int(word_to_int(pw^))) * 0.1; // perc.

      16#91:
         dalys[daly_id].maxvoltage := int_to_real(int_to_int(word_to_int(pw^))) / 1000; // mV
         pb := pw + 2;
         dalys[daly_id].maxVcellNo := byte_to_usint(pb^);
         pw := pw + 3;
         dalys[daly_id].minvoltage := int_to_real(int_to_int(word_to_int(pw^))) / 1000;
         pb := pb + 3;
         dalys[daly_id].minVcellNo := byte_to_usint(pb^);
      16#92:
         dalys[daly_id].temperature := byte_to_int(pb^) - 40;  // only one thermometer expected here
      16#93:
         dalys[daly_id].state := byte_to_usint(pb^);  // 0 - static  1 - charge   2 - discharge

         case dalys[daly_id].state of
         // static - grey
         0: dalys[daly_id].statea.r := 212;
            dalys[daly_id].statea.g := 212;
            dalys[daly_id].statea.b := 212;

         // charge - green
         1: dalys[daly_id].statea.r := 0;
            dalys[daly_id].statea.g := 200;
            dalys[daly_id].statea.b := 0;

         // discharge - orange
         2: dalys[daly_id].statea.r := 255;
            dalys[daly_id].statea.g := 128;
            dalys[daly_id].statea.b := 0;
         end_case;

         pb := pb + 1;
         dalys[daly_id].MosCharging := byte_to_usint(pb^);
         pb := pb + 1;
         dalys[daly_id].MosLoad := byte_to_usint(pb^);
         
         // force switch to nearest processed command
         // switches also 95 and 96 which could not be processes in this program
         
         command_id := 16#96;  // will be incremented
         
      16#97:
         dalys[daly_id].balancing := word_to_stringf(pw^, '%04X');         // bit = the cell is balancing
      16#98:
         dalys[daly_id].faultstatus1 := dword_to_stringf(pd^,'%08X');
         pd := pd + 4;
         dalys[daly_id].faultstatus2 := dword_to_stringf(pd^,'%08X');
      END_CASE;

  END_CASE;


  // calculate total current from batteries
  CurrentBatSum := 0;
  
  for i := 1 to NUM_DALYS DO
    CurrentBatSum := CurrentBatSum + dalys[i].current;
  end_for;

  if CurrentBatSum > 0.5 THEN // charge - green
    CurrentBatSum_cl.r := 0;CurrentBatSum_cl.g := 200;CurrentBatSum_cl.b := 0;
  elsif CurrentBatSum < -0.5 THEN // discharge - orange
     CurrentBatSum_cl.r := 255;CurrentBatSum_cl.g := 128;CurrentBatSum_cl.b := 0;
  else // static - grey
     CurrentBatSum_cl.r := 212;CurrentBatSum_cl.g := 212;CurrentBatSum_cl.b := 212;
  end_if;

  // actualization of the global variables
  daly_diffvoltage_1 := dalys[1].maxvoltage - dalys[1].minvoltage;
  daly_diffvoltage_2 := dalys[2].maxvoltage - dalys[2].minvoltage;
END_PROGRAM

ach jo, sotva jsem se prokousal zacatky arduina. takze stake stejne v pr... jako pred tim.

[Frantisekcon]

Dobrý den, poradí někdo s typem bms, který bude komunikovat s goodwe? Mám dva paky 16s lifepo4 200ah a slyšel jsem že dvě bms jdou propojit komunikací mezi sebou a komunikovat protokolem třeba Pylontech. Děkuji Fanda

[mpcz]

Zdravím. Tak to taky právě řeším. Potřebuji konkrétně připojit home-made baterii 48V Lifepo4 s DALY nebo jinou BMS na DEYE střídač. Chtěl bych to řešit "mezikusem" mezi BMS DALY a střídačem, který bude překládat data z DALY na řeč střídače, popř. i zpět. Z toho by vznikl univerzální překladač dat pro všechny střídače. Nejsem příznivcem továrních ledničkových baterií pro jejich uzavřenost, blbou rozšiřitelnost, cenu a také porucha článku mě úplně děsí. A ta vybíravost na kompatibilitu podstatně zužuje možnost výběru prvků a kapacit.
Rozšifrovat odchozí komunikaci DALY problém není, ale co chce DEYE, to už problém je, protože ho zatím nemám. Nemá někdo popis protokolu DEYE a byl by ochoten ho poslat? Díky, mpcz, 26oct2022

[lzahradil]

Modbus储能-组串-微逆宁波德业V118.pdf

(1.33 MiB) Staženo 288 x

[mpcz]

Zdravím, děkuji. Hledám protokol pro DEYE 10kW. Tato tabulka je pro DEYE nebo je to jen doporučení pro všechy výrobce? Dá se spolehnout na to, že to DEYE dodržuje? Díky, mpcz, 27oct2022