基本完成测试项自测

src/GBT2015/GBT27930.c

@@ -21,6 +21,8 @@ const _27930_table_t _27930_table[] =
     {GBT_27930_2015_CST,10},
     {GBT_27930_2015_CSD,250},
     {GBT_27930_2015_CEM,250},
+    {GBT_27930_2015_BRM,0,5000},
+    {GBT_27930_2015_BCP,0,5000},
     {GBT_27930_2015_BRO,0,5000},
     {GBT_27930_2015_BCL,0,1000},
     {GBT_27930_2015_BCS,0,5000},
@@ -147,16 +149,20 @@ int can_GBT27930_read(GBT27930_t* dev, int timeout)
                         return GBT_27930_2015_BHM; 
                     } break;
                     case GBT_27930_2015_BRO: { 
-                        dev->bro_last.status = dev->bro.status;
-                        dev->bro.status = frame.data[0];
-                        return GBT_27930_2015_BRO; 
+                        if(frame.can_id == 0x900956f4){
+                            dev->bro_last.status = dev->bro.status;
+                            dev->bro.status = frame.data[0];
+                            return GBT_27930_2015_BRO; 
+                        }
                     } break;
                     case GBT_27930_2015_BCL: { 
-                        memcpy(&dev->bcl_last, &dev->bcl, sizeof(dev->bcl));
-                        dev->bcl.bmsVoltage_request = frame.data[0]|(frame.data[1]<<8); 
-                        dev->bcl.bmsCurrent_request = GBT_27930_CURRENT_OFFSET - (frame.data[2]|(frame.data[3]<<8)); 
-                        dev->bcl.bmsChargeMode = frame.data[4];
-                        return GBT_27930_2015_BCL;
+                         if(frame.can_id == 0x981056f4){
+                            memcpy(&dev->bcl_last, &dev->bcl, sizeof(dev->bcl));
+                            dev->bcl.bmsVoltage_request = frame.data[0]|(frame.data[1]<<8); 
+                            dev->bcl.bmsCurrent_request = GBT_27930_CURRENT_OFFSET - (frame.data[2]|(frame.data[3]<<8)); 
+                            dev->bcl.bmsChargeMode = frame.data[4];
+                            return GBT_27930_2015_BCL;
+                         }
                     }break;
                     case GBT_27930_2015_BSM: { 
                         memcpy(&dev->bsm_last, &dev->bsm, 8);
@@ -164,16 +170,20 @@ int can_GBT27930_read(GBT27930_t* dev, int timeout)
                         return GBT_27930_2015_BSM;
                     }break;
                     case GBT_27930_2015_BST: { 
-                        memcpy(&dev->bst, frame.data, 4);
-                        return GBT_27930_2015_BST;
+                        if(frame.can_id == 0x901956f4){
+                            memcpy(&dev->bst, frame.data, 4);
+                            return GBT_27930_2015_BST;
+                        }
                     }break;
                     case GBT_27930_2015_BSD: { 
-                        dev->bsd.bmsSOC_EOF = frame.data[0];
-                        dev->bsd.bmsUnitMaxVoltage = frame.data[1]|(frame.data[2]<<8);
-                        dev->bsd.bmsUnitMinVoltage = frame.data[3]|(frame.data[4]<<8);
-                        dev->bsd.bmsMaxUnitTemp = frame.data[5];
-                        dev->bsd.bmsMinUnitTemp = frame.data[6];
-                        return GBT_27930_2015_BSD;
+                         if(frame.can_id == 0x981C56f4){
+                            dev->bsd.bmsSOC_EOF = frame.data[0];
+                            dev->bsd.bmsUnitMaxVoltage = frame.data[1]|(frame.data[2]<<8);
+                            dev->bsd.bmsUnitMinVoltage = frame.data[3]|(frame.data[4]<<8);
+                            dev->bsd.bmsMaxUnitTemp = frame.data[5];
+                            dev->bsd.bmsMinUnitTemp = frame.data[6];
+                            return GBT_27930_2015_BSD;
+                         }
                     }break;
                     case GBT_27930_2015_BEM: { 
                         memcpy(&dev->bem, frame.data, 4);
@@ -372,7 +382,7 @@ void Can_sendpoll(void* args)
         {       
             if(systime_ms()> (zw_sendOb[i].lastsend_time+zw_sendOb[i].inteval_ms)){
                 int ret = write(canJ1939->fd, &zw_sendOb[i].frame, sizeof(struct can_frame));
-                usleep(2); //避免总线拥挤,
+                usleep(1); //避免总线拥挤,
                 zw_sendOb[i].lastsend_time =  systime_ms();
             }
         }
@@ -408,7 +418,7 @@ void  can_APP_add(int pgn,struct can_frame* txframe)
 /**
  * @brief 清除发送数据
  * @param pgn: 0时清除所有数据 
- *             0xff  清除除CSD/CST意外的所有数据
+ *             0xff  清除除CSD/CST/CEM意外的所有数据
  */
 void can_APP_clear(int pgn)
 {
@@ -421,7 +431,7 @@ void can_APP_clear(int pgn)
     }else if(pgn == 0xff){
         for(uint8_t i =0;i<10;i++)
         {
-           if((zw_sendOb[i].pgn != GBT_27930_2015_CSD)&&(zw_sendOb[i].pgn != GBT_27930_2015_CST))
+           if((zw_sendOb[i].pgn != GBT_27930_2015_CSD)&&(zw_sendOb[i].pgn != GBT_27930_2015_CST)&&(zw_sendOb[i].pgn != GBT_27930_2015_CEM))
            {zw_sendOb[i].pgn = 0;}
         }
     }else{
@@ -462,12 +472,6 @@ static void* can_GBT27930_Txloop(void* args)
         if (dev->stop == 0)
         {
             Can_sendpoll(args);
-            //pthread_mutex_lock(&dev->mutex);
-            // if(dev->last_tickcnt++ >=dev->tickcnt){
-            //     dev->last_tickcnt = 0;
-            //     can_J1939_send(canJ1939, frame);
-            // }
-            //pthread_mutex_unlock(&dev->mutex);
         }
         msleep(dev->frame_interval_ms);
 	}
@@ -1144,6 +1148,7 @@ int can_GBT27930_send_CCS(GBT27930_t* dev, GBT27930_CCS_t* req)
         // memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
         // // memcpy(&dev->frameCCS, &txframe, sizeof(struct can_frame));
         // pthread_mutex_unlock(&dev->mutex);
+        can_APP_clear(GBT_27930_2015_CRO);
         can_APP_add(GBT_27930_2015_CCS,&txframe);
         dev->frame.can_id = 0;
         return GBT_27930_2015_NORMAL;

src/GBT2015/GBT27930.h

@@ -91,60 +91,60 @@
 
 #define GBT_27930_CURRENT_OFFSET    4000
 
-
+#define GBT_27930_2015_NUL   (0)
 typedef struct
 {
     union 
     {
-        uint32_t  data;  
-        uint32_t  GBT_27930_2015_BRO_recv:1;
-        uint32_t  GBT_27930_2015_BCL_recv:1;
-        uint32_t  GBT_27930_2015_BCS_recv:1;
-        uint32_t  GBT_27930_2015_BSM_recv:1;
-        uint32_t  GBT_27930_2015_BSD_recv:1;
-        uint32_t  GBT_27930_2015_BST_recv:1;
-        uint32_t  GBT_27930_2015_reser:26 ;
+        uint32_t  data;
+        struct{    
+            uint32_t  GBT_27930_2015_NUL_recv:2;
+            uint32_t  GBT_27930_2015_BRM_recv:2;
+            uint32_t  GBT_27930_2015_BCP_recv:2;  
+            uint32_t  GBT_27930_2015_BRO_recv:2;
+            uint32_t  GBT_27930_2015_BCL_recv:2;
+            uint32_t  GBT_27930_2015_BCS_recv:2;
+            uint32_t  GBT_27930_2015_BSM_recv:2;
+            uint32_t  GBT_27930_2015_BSD_recv:2;
+            uint32_t  GBT_27930_2015_BST_recv:2;
+            uint32_t  GBT_27930_2015_BSD_timeOut:2;
+            uint32_t  GBT_27930_2015_BST_timeOut:2; 
+            uint32_t  GBT_27930_2015_reser: 10;
+        };
     };
 }_27930_recvFlag_t;
 uint16_t Can_get_27930Recvtime(uint8_t pgn_hex);
 
 #define  APPLY(X)                                 long int X##_curtime = systime_ms()
 /**按照协议结合框架执行协议处理*/
-#define  TIME_OUT(dev,pgn)                          if(pgn == GBT_27930_2015_BRO){\
-                                                    exit_handle(dev,GBT_27930_2015_BRO);\
-                                                    return GBT_27930_2015_ERROR;}\
-                                                   if(pgn == GBT_27930_2015_BSD){\
-                                                        can_GBT27930_send_timeout(dev, pgn);\
-                                                        secc_set_error(secc, GUN_PRECHARGE_FAULT);\
-                                                        break;\
-                                                    }else if(pgn == GBT_27930_2015_BST){\
-                                                        can_APP_clear(0xff);\
-                                                        can_GBT27930_send_timeout(dev, pgn);\
-                                                        secc_set_state(secc, GUN_STOPPING);\
-                                                        secc_set_error(secc, GUN_PRECHARGE_FAULT);\
-                                                        break;\
-                                                    }else if(pgn == GBT_27930_2015_BCL||pgn ==GBT_27930_2015_BCS){\
-                                                        can_GBT27930_send_timeout(dev, pgn);\
-                                                        secc_set_state(secc, GUN_COMFALUT);\
-                                                        secc_set_error(secc, GUN_PRECHARGE_FAULT);\
-                                                        return GBT_27930_2015_ERROR;\
-                                                    }           
-//需求满足,
-#define RECV_BMS(dev,pgn,curtime)               do{\
-                                                    if(can_GBT27930_wait_n(dev,pgn)==pgn){ \
-                                                    _27930_recvFlag.pgn##_recv=1;\
-                                                    curtime =systime_ms();}\
-                                                    else{\
-                                                     if((curtime+Can_get_27930Recvtime(pgn))< systime_ms()){\
-                                                        printf("%s_timeout\n",#pgn);\
-                                                        can_GBT27930_send_timeout(dev, pgn);\
-                                                        secc_set_state(secc, GUN_COMFALUT);\
-                                                        secc_set_error(secc, GUN_PRECHARGE_FAULT);\
-                                                        return GBT_27930_2015_ERROR;}\
+#define  TIME_OUT(dev,pgn)                          secc_port_t* secc = (secc_port_t*)dev->secc;\
+                                                    if((secc->GUN_Error != 0)&&(secc->GUN_State !=GUN_STOPPING)){\
+                                                    printccui("secc->GUN_Error =%08x\n",secc->GUN_Error);\
+                                                    if(secc->GUN_Error <BMS_STOP_BY_SOC){secc_set_state(secc, GUN_EMERGRNCY_STOP);}\
+                                                    else if(secc->GUN_Error<= BMS_STOP_BY_OYRHER){secc_set_state(secc, GUN_STOPPING);}\
+                                                    else if (secc->GUN_Error == BCP_VOL_MISMATCH){secc_set_state(secc, GUN_EMERGRNCY_STOP);}\
+                                                    else if(secc->GUN_Error < GBT_27930_2015_COM_MAX){secc_set_state(secc, GUN_STOPPING);}\
+                                                    if((secc->GUN_Error == GBT_CC1_FALUT)||(secc->GUN_Error == GUN_ELECLOCK_FAULT)){\
+                                                        dev->cst.chgOtherFault = 1;\
+                                                        can_GBT27930_send_CST(dev,&dev->cst);\
+                                                        secc_set_state(secc, GUN_EMERGRNCY_STOP);\
                                                     }\
-                                                }while(0)
+                                                    if(secc->GUN_Error == CCU_BATTERY_FAULT){\
+                                                        dev->cst.chgOtherFault = 1;\
+                                                        can_GBT27930_send_CST(dev,&dev->cst);\
+                                                        secc_set_error(secc, CCU_BATTERY_FAULT);\
+                                                    }\
+                                                    if(secc->GUN_Error == CCU_BATTERY_FAULT){\
+                                                        dev->cst.chgOtherFault = 1;\
+                                                        can_GBT27930_send_CST(dev,&dev->cst);\
+                                                        secc_set_error(secc, CCU_BATTERY_FAULT);\
+                                                    }\
+                                                    return GBT_27930_2015_ERROR;\
+                                                }\
+                                                if(pgn !=0){\
+                                                    if(_27930_recvFlag.pgn##_recv != 0)break;}
 
-#define RECV_BMS_1(dev,pgn)                 do{\
+#define RECV_BMS_1(dev,pgn)                 do{     int recv_pgn_flag =0 ;\
                                                     int ret = can_GBT27930_waits(dev,2,pgn,GBT_27930_2015_BST);\
                                                     if(ret == pgn){ \
                                                         _27930_recvFlag.pgn##_recv=1;\
@@ -157,10 +157,10 @@ uint16_t Can_get_27930Recvtime(uint8_t pgn_hex);
                                                         printf("%s_timeout\n",#pgn);\
                                                         recv_pgn_flag = pgn;\
                                                     }\
-                                                    pgn_run(dev);\
+                                                    exit_handle(dev,recv_pgn_flag);\
                                                 }while(0) 
 
-#define RECV_BMS_2(dev,pgn,pgn1)                do{\
+#define RECV_BMS_2(dev,pgn,pgn1)                do{ int recv_pgn_flag =0 ;\
                                                     int ret = can_GBT27930_waits(dev,3,pgn,pgn1,GBT_27930_2015_BST);\
                                                     if(ret == pgn){ \
                                                         _27930_recvFlag.pgn##_recv=1;\
@@ -182,20 +182,20 @@ uint16_t Can_get_27930Recvtime(uint8_t pgn_hex);
                                                         printf("%s_timeout\n",#pgn1);\
                                                         recv_pgn_flag = pgn1;\
                                                     }\
-                                                     pgn_run(dev);\
+                                                     exit_handle(dev,recv_pgn_flag);\
                                                 }while(0)    
 
 
-#define RECV_BMS_3(dev,pgn,pgn1,pgn2)         do{\
+#define RECV_BMS_3(dev,pgn,pgn1,pgn2)         do{   int recv_pgn_flag = 0;\
                                                     int ret = can_GBT27930_waits(dev,4,pgn,pgn1,pgn2,GBT_27930_2015_BST);\
                                                     if(ret == pgn){ \
-                                                        _27930_recvFlag.pgn##_recv=1;\
+                                                        _27930_recvFlag.pgn##_recv |=1;\
                                                         pgn##_curtime =systime_ms();\
                                                     }else if(ret == pgn1){ \
-                                                        _27930_recvFlag.pgn1##_recv=1;\
+                                                        _27930_recvFlag.pgn1##_recv |=1;\
                                                         pgn1##_curtime =systime_ms();}\
                                                     else if(ret == pgn2){ \
-                                                        _27930_recvFlag.pgn2##_recv=1;\
+                                                        _27930_recvFlag.pgn2##_recv |=1;\
                                                         pgn2##_curtime =systime_ms();}\
                                                     else if(ret == GBT_27930_2015_BST){\
                                                         secc_port_t* secc = (secc_port_t*)dev->secc;\
@@ -213,16 +213,9 @@ uint16_t Can_get_27930Recvtime(uint8_t pgn_hex);
                                                     if((pgn2##_curtime+Can_get_27930Recvtime(pgn2))< systime_ms()){\
                                                         printf("%s_timeout\n",#pgn2);\
                                                         recv_pgn_flag = pgn2;\
-                                                    }\
-                                                    pgn_run(dev);\
-                                                }\
+                                                    }}\
+                                                    exit_handle(dev,recv_pgn_flag);\
                                                 }while(0)
-typedef struct
-{
-    uint32_t  GBT_27930_TIMEOUT_BRO_recv :1;
-    uint32_t  time_out:31;
-}timaaaaae_t;
-
 
 
 typedef struct GBT27930_SPN

src/GBT2015/can_SECC.c

@@ -29,12 +29,9 @@ static int can_GBT27930_send_stop(GBT27930_t* dev, int REASON)
 
 
 //接收补充设置
-void  pgn_run(GBT27930_t* dev)
+void  pgn_run(GBT27930_t* dev,int pgn)
 {
-    if(_27930_recvFlag.GBT_27930_2015_BSD_recv == 1){
-        can_APP_clear(GBT_27930_2015_CST);
-        can_GBT27930_send_CSD(dev, &dev->csd);
-    }
+  
 }
 
 
@@ -46,8 +43,8 @@ static int can_GBT27930_send_timeout(GBT27930_t* dev, int STATE)
     memset(&dev->cem, 0, sizeof(dev->cem));
     switch(STATE)
     {
-        case GBT_27930_TIMEOUT_BRM:{dev->cem.brm_timeout=1;}break;
-        case GBT_27930_TIMEOUT_BCP:{dev->cem.bcp_timeout=1;}break;
+        case GBT_27930_2015_BRM:{dev->cem.brm_timeout=1;}break;
+        case GBT_27930_2015_BCP:{dev->cem.bcp_timeout=1;}break;
         case GBT_27930_2015_BRO:{dev->cem.bro_timeout=1;}break;
         case GBT_27930_2015_BCS:{dev->cem.bcs_timeout=1;}break;
         case GBT_27930_2015_BCL:{dev->cem.bcl_timeout=1;}break;
@@ -55,7 +52,6 @@ static int can_GBT27930_send_timeout(GBT27930_t* dev, int STATE)
         case GBT_27930_2015_BSD:{dev->cem.bsd_timeout=1;}break;
         default: {dev->cem.others=1;} break;
     }
-    can_APP_clear(0);
     return can_GBT27930_send_CEM(dev, &dev->cem);
 }
 
@@ -70,6 +66,7 @@ static int can_GBT27930_TryLock(GBT27930_t* dev, int timeout)
     if (secc->set_ELock_state(secc, 1, timeout) == 1)
     {
         pcu->update_ElecLock_state(pcu, 1);
+        printd("step.\n");
         secc_request_power(secc, POWER_REQUEST_PLACE_HOLD, 0.0f, 0.0f);
         secc_set_state(secc, GUN_ELOCKED);
         return 1;
@@ -169,7 +166,6 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
         secc_set_error(secc, GUN_CONTACTOR_FAULT);
         return -1;
     }
-
     for (now_ms = systime_ms(); now_ms <= end_ms; now_ms = systime_ms())
     {
         if (0.0f <= secc->VMeters && secc->VMeters < 10.0f) { break; }
@@ -186,7 +182,6 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
         }
         return -1;
     }
-
     if (secc->set_K1K2_state(secc, 1, 1000) == 1) 
     {
         pcu->update_K1K2_state(pcu, 1, 1);
@@ -194,7 +189,6 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
         secc_set_error(secc, GUN_CONTACTOR_FAULT);
         return -1;
     }
-
     float Vimd = ((float)dev->bhm.bmsMaxVoltage)/10;
     Vimd = fminf(Vimd, 500.0f);//取2者的小值
    // Vimd = fmaxf(Vimd, 500.0f);
@@ -249,14 +243,61 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
 
 void  exit_handle(GBT27930_t* dev,int pgn)
 {   
-    if(pgn == GBT_27930_2015_BRO){
-        secc_port_t *secc = (secc_port_t*)dev->secc;
-        can_GBT27930_send_timeout(dev, GBT_27930_2015_BRO);
-        secc_set_state(secc, GUN_COMFALUT);
-        secc_set_error(secc, GUN_PRECHARGE_FAULT);
-        //printd("SECC(%d) BMS Insulation timeout or fault.\n", secc->config->connectorId);
-        printccui("SECC(%d) BMS Insulation timeout or fault.\n", secc->config->connectorId);
-    }
+    secc_port_t *secc = (secc_port_t*)dev->secc;
+    switch (pgn)
+    {
+        case 0:
+            if(_27930_recvFlag.GBT_27930_2015_BSD_recv != 0){
+            can_APP_clear(GBT_27930_2015_CST);
+            can_GBT27930_send_CSD(dev, &dev->csd);
+            _27930_recvFlag.GBT_27930_2015_BSD_recv == 3;
+            }
+            if(_27930_recvFlag.GBT_27930_2015_BCP_recv != 0){
+                can_APP_clear(GBT_27930_2015_CRM);
+                _27930_recvFlag.GBT_27930_2015_BCP_recv == 3;       
+            }
+            if(_27930_recvFlag.GBT_27930_2015_BST_recv == 1)
+            {
+                if(dev->secc->GUN_State != GUN_STOPPING){
+                    can_APP_clear(0xff);
+                    if(dev->bst.bmsReachedSOC ==1){ secc_set_error(secc, BMS_STOP_BY_SOC);}
+                    else if(dev->bst.bmsReachedVoltage ==1){ secc_set_error(secc, BMS_STOP_BY_GLOB_VOL);}
+                    else if(dev->bst.bmsReachedUnitVoltage ==1){ secc_set_error(secc, BMS_STOP_BY_SIG_VOL);}
+                    else {secc_set_error(secc, BMS_STOP_BY_OYRHER);}
+                }
+            }
+        break;
+        case GBT_27930_2015_BRM:
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BRM);
+            secc_set_error(secc, GBT_27930_2015_BRM_TIMEOUT);
+        break;      
+        case GBT_27930_2015_BRO:
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BRO);
+            secc_set_error(secc, GBT_27930_2015_BRO_TIMEOUT);
+        break;          
+        case GBT_27930_2015_BSD:
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BSD);
+        break;
+        case GBT_27930_2015_BST:
+            _27930_recvFlag.GBT_27930_2015_BST_timeOut = 1;
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BST);
+        break;
+        case GBT_27930_2015_BCP:
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BCP);
+            secc_set_error(secc, GBT_27930_2015_BCP_TIMEOUT);
+        break;   
+        case GBT_27930_2015_BCL:
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BCL);
+            secc_set_error(secc, GBT_27930_2015_BCL_TIMEOUT);
+        break; 
+            case GBT_27930_2015_BCS:
+            can_GBT27930_send_timeout(dev, GBT_27930_2015_BCS);
+            secc_set_error(secc, GBT_27930_2015_BCS_TIMEOUT);
+        break; 
+        default:
+        break;
+        }
+   
 }
 
 static int can_GBT27930_PreCharge(GBT27930_t* dev)
@@ -266,39 +307,54 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
     ccu_port_t *ccu = (ccu_port_t*)dev->ccu;
     pcu_port_t *pcu = (pcu_port_t*)dev->pcu;
     printccui("PreCharge charge start\n");
+    long int wait_time ;
     //----------等待车端BRM就绪----------
     can_GBT27930_send_CRM(dev, 0x00, 0xFFFFFFFF, NULL);
-    ret = can_GBT27930_wait(dev, GBT_27930_2015_BRM, BRM_TIMEOUT);
-    if (ret != GBT_27930_2015_BRM)
+    APPLY(GBT_27930_2015_BRM);
+    WAIT_CONDI(
+        wait_time,1000000,
+        ,
+        RECV_BMS_1(dev,GBT_27930_2015_BRM);
+        TIME_OUT(dev,GBT_27930_2015_BRM);
+    );
+    printccui("step\n");
+    //----------等待车端电池电压----------
+    can_GBT27930_send_CRM(dev, 0xAA, 0xFFFFFFFF, NULL);
+    APPLY(GBT_27930_2015_BCP);
+    WAIT_CONDI(
+        wait_time,1800000,
+        ,
+        RECV_BMS_1(dev,GBT_27930_2015_BCP);
+        TIME_OUT(dev,GBT_27930_2015_BCP);
+    );
+
+    printccui("step\n");
+    printi("SECC(%d).bcp.bmsPermitttedMaxVoltage:%d, bmsPermitttedMaxCurrent:%d, bmsNominalTotalkWH:%d, bmsVoltage:%d \n", secc->config->connectorId, dev->bcp.bmsPermitttedMaxVoltage, dev->bcp.bmsPermitttedMaxCurrent, dev->bcp.bmsNominalTotalkWH, dev->bcp.bmsVoltage);
+    printd("SECC(%d) PreCharging.maxVoltage:%f,minVoltage:%f, maxCurrent:%f, minCurrent:%f\n", secc->config->connectorId, secc->SECC_maxV, secc->SECC_minV, secc->SECC_maxI, secc->SECC_minI);
+    if (dev->bcp.bmsPermitttedMaxVoltage < secc->SECC_minV) 
     {
-        printccui("BRM_TIMEOUT\n");
-        can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BRM);
+        can_GBT27930_send_stop(dev, GBT_27930_STOP_VOLTAGE_MISTACH);
         secc_set_error(secc, GUN_PRECHARGE_FAULT);
-        secc_set_state(secc, GUN_COMFALUT);
+        printd("SECC(%d) BMS Battery Voltage exceed the range of SECC\n", secc->config->connectorId);
         return GBT_27930_2015_ERROR;
     }
-    
-    //----------等待车端电池电压----------
-    can_GBT27930_send_CRM(dev, 0xAA, 0xFFFFFFFF, NULL);
-    ret = can_GBT27930_wait(dev, GBT_27930_2015_BCP, BCP_TIMEOUT);
-    if (ret != GBT_27930_2015_BCP)
+    //GB18487.1-2023.B.4.4
+    if(((dev->bcp.bmsVoltage*1.05) < (uint16_t)(secc->VMeters*10 + 0.5))|| ((dev->bcp.bmsVoltage*0.95) > (uint16_t)(secc->VMeters*10 + 0.5)))
     {
-        printccui("BCP_TIMEOUT\n");
-        can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BCP);
+        can_GBT27930_send_stop(dev, GBT_27930_STOP_VOLTAGE_MISTACH);
         secc_set_error(secc, GUN_PRECHARGE_FAULT);
-        secc_set_state(secc, GUN_COMFALUT);
+        printd("SECC(%d) BMS Battery Voltage exceed the range of SECC\n", secc->config->connectorId);
         return GBT_27930_2015_ERROR;
     }
-    can_APP_clear(GBT_27930_2015_CRM);
-    printi("SECC(%d).bcp.bmsPermitttedMaxVoltage:%d, bmsPermitttedMaxCurrent:%d, bmsNominalTotalkWH:%d, bmsVoltage:%d \n", secc->config->connectorId, dev->bcp.bmsPermitttedMaxVoltage, dev->bcp.bmsPermitttedMaxCurrent, dev->bcp.bmsNominalTotalkWH, dev->bcp.bmsVoltage);
-    printd("SECC(%d) PreCharging.maxVoltage:%f,minVoltage:%f, maxCurrent:%f, minCurrent:%f\n", secc->config->connectorId, secc->SECC_maxV, secc->SECC_minV, secc->SECC_maxI, secc->SECC_minI);
-    if (dev->bcp.bmsPermitttedMaxVoltage < secc->SECC_minV)
+    //GB18487.1-2023.B.4.4
+    if(((uint16_t)(secc->VMeters*10 + 0.5) >secc->SECC_maxV) ||(((uint16_t)(secc->VMeters*10 + 0.5) <secc->SECC_minV)))
     {
         can_GBT27930_send_stop(dev, GBT_27930_STOP_VOLTAGE_MISTACH);
         secc_set_error(secc, GUN_PRECHARGE_FAULT);
         printd("SECC(%d) BMS Battery Voltage exceed the range of SECC\n", secc->config->connectorId);
         return GBT_27930_2015_ERROR;
     }
+    printccui("step\n");
     //----------通知车端启动绝缘检测---------
     dev->cml.chgMaxOutputVoltage = (uint16_t)(secc->SECC_maxV*10 + 0.5);
     dev->cml.chgMinOutputVoltage = (uint16_t)(secc->SECC_minV*10 + 0.5);
@@ -306,16 +362,15 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
     dev->cml.chgMinOutputCurrent = (uint16_t)(secc->SECC_minI*10 + 0.5);
     can_GBT27930_send_CML(dev, &dev->cml);
     can_GBT27930_send_CTS(dev, NULL); 
-    long int wait_time ;
+    
     APPLY(GBT_27930_2015_BRO);
-    int recv_pgn_flag = 0;
     WAIT_CONDI(
         wait_time,60000,
         , 
         RECV_BMS_1(dev,GBT_27930_2015_BRO);
-        TIME_OUT(dev,recv_pgn_flag);
-        if(_27930_recvFlag.GBT_27930_2015_BRO_recv == 1)break;             
+        TIME_OUT(dev,GBT_27930_2015_BRO);         
     );
+    printccui("step\n");
     //----------等待车端绝缘检测完成----------
     can_GBT27930_send_CML(dev, &dev->cml);
     dev->bro.status = 0x00;//清零
@@ -330,23 +385,26 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
             return GBT_27930_2015_ERROR;
             ),  
            can_GBT27930_send_CTS(dev, NULL); 
-           if( dev->bro.status == 0xaa)break;
+           if( dev->bro.status == 0xaa)break;          
+           TIME_OUT(dev,GBT_27930_2015_NUL); 
            
     );
+    printccui("step\n");
     can_APP_clear(GBT_27930_2015_CML); ////GB2015-27930-tab.d1
     can_APP_clear(GBT_27930_2015_CTS);
     //----------开始调整桩端电压----------
     can_GBT27930_send_CRO(dev, 0x00);
-   
-    long int bro_time = systime_ms();
     
     WAIT_CONDI(  
         wait_time,60000,          
         SPILTE(
+            can_GBT27930_send_stop(dev, GBT_27930_STOP_VOLTAGE_MISTACH);
             secc_set_error(secc, GUN_PRECHARGE_FAULT);
+            return GBT_27930_2015_ERROR;
         ),
      //   RECV_BMS(dev,GBT_27930_2015_BRO,bro_time);
-        RECV_BMS(dev,GBT_27930_2015_BRO,bro_time);
+        RECV_BMS_1(dev,GBT_27930_2015_BRO);
+        TIME_OUT(dev,GBT_27930_2015_NUL)
         float VBattery = ((float)dev->bcp.bmsVoltage) / 10;
         float VDelta = fabs(secc->VGround - secc->VMeters);
         //printd("SECC(%d) SECC_minV:%f, VMeters:%f, SECC_maxV:%f, VGround:%f, VDelta:%f\n", secc->config->connectorId, secc->SECC_minV, secc->VMeters, secc->SECC_maxV, secc->VGround, VDelta);
@@ -361,13 +419,13 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
             secc_request_power(secc, POWER_REQUEST_CONST_VOLTAGE, VBattery, 0.0f);
         }
         if(dev->bro.status == 0x00){
-            printf("is fall\n");
             Global_flaut = 'b';
             secc_set_state(secc, GUN_EMERGRNCY_STOP);
             return GBT_27930_2015_ERROR;
         }
         msleep(200);
     );
+    printccui("step\n");
     secc_set_error(secc, GUN_PRECHARGE_FAULT);
     return GBT_27930_2015_ERROR;
 }
@@ -415,17 +473,12 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
     APPLY(GBT_27930_2015_BCL);
     APPLY(GBT_27930_2015_BSM);
     int start_sendCCS = 0;
-    int recv_pgn_flag = 0; //接收超时标准
     while(secc_should_stop(secc) != 1)
     {
         //int ret = can_GBT27930_wait(dev, 3<<24, 1000,GBT_27930_2015_BCS,GBT_27930_2015_BCL,GBT_27930_2015_BSM);
 
         RECV_BMS_3(dev,GBT_27930_2015_BCS,GBT_27930_2015_BCL,GBT_27930_2015_BSM);
-        TIME_OUT(dev,recv_pgn_flag)
-        if(_27930_recvFlag.GBT_27930_2015_BST_recv ==1){
-            can_APP_clear(GBT_27930_2015_CCS);
-            break;
-        }
+        TIME_OUT(dev,GBT_27930_2015_NUL)
         // if(can_GBT27930_wait_n(dev,GBT_27930_2015_BSM)==GBT_27930_2015_BSM){
         //  _27930_recvFlag.GBT_27930_2015_BSM_recv = 1;
         // }
@@ -448,7 +501,7 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
 
         if(_27930_recvFlag.GBT_27930_2015_BCS_recv == 1){
             _27930_recvFlag.GBT_27930_2015_BCS_recv = 0;
-            start_sendCCS |= 3; 
+            start_sendCCS |= 2; 
             bcs_ms = systime_ms();
             secc->EV_Charging_current = ((float)dev->bcs.chargingCurrent) / 10;
             secc->EV_Charging_voltage = ((float)dev->bcs.chargingVoltage) / 10;
@@ -465,22 +518,16 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
             float current = (((float)dev->bcl.bmsCurrent_request) / 10);
             if(dev->bsm.bmsBatteryOverTemp != 0){
                 secc_set_error(secc, CCU_BATTERY_FAULT);
-                goto endhandl;
             }else if(dev->bsm.bmsBatteryOverSOC ){
                 secc_set_error(secc, CCU_BATTERY_FAULT);
-                goto endhandl;  
-            }else if(dev->bsm.bmsBatteryOverCurrent){
-                secc_set_error(secc, CCU_BATTERY_FAULT);
-                goto endhandl; 
-            }else if(dev->bsm.bmsPowerBatteryOverTemp){
+            }else if(dev->bsm.bmsBatteryOverCurrent == 1){
                 secc_set_error(secc, CCU_BATTERY_FAULT);
-                goto endhandl;  
-            }else if(dev->bsm.bmsPowerBatteryOverRsizder){
+            }else if(dev->bsm.bmsPowerBatteryOverTemp == 1){
+                secc_set_error(secc, CCU_BATTERY_FAULT); 
+            }else if(dev->bsm.bmsPowerBatteryOverRsizder == 1){
                 secc_set_error(secc, CCU_BATTERY_FAULT);
-                goto endhandl; 
-            }else if(dev->bsm.bmsPowerBatteryConnector){
+            }else if(dev->bsm.bmsPowerBatteryConnector == 1){
                 secc_set_error(secc, CCU_BATTERY_FAULT);
-                goto endhandl; 
             }
             if (dev->bsm.bmsPowerPermitted == 0x0  && dev->bsm_last.bmsPowerPermitted == 1)
             {   //暂停
@@ -506,11 +553,13 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
             dev->ccs.chgChargedMinutes = (time(NULL) - secc->started_UTC + 30)/60;
             dev->ccs.chgOutputVoltage = (uint16_t)(secc->VMeters*10 + 0.5);
             dev->ccs.chgOutputCurrent = (uint16_t)(secc->IMeters*10 + 0.5);
-            if(start_sendCCS == 3)can_GBT27930_send_CCS(dev, &dev->ccs);
+            if(start_sendCCS == 3){
+                    
+                can_GBT27930_send_CCS(dev, &dev->ccs);
+            }
        // }
         usleep(2000);
     }
- endhandl:  
     printccui("step\n");
     secc_set_state(secc, GUN_STOPPING);
     return GBT_27930_2015_NORMAL;
@@ -536,12 +585,15 @@ static int can_GBT27930_EMERGRNCY_STOP(GBT27930_t* dev)
     secc_port_t* secc = (secc_port_t*)dev->secc;
     ccu_port_t *ccu = (ccu_port_t*)dev->ccu;
     pcu_port_t *pcu = (pcu_port_t*)dev->pcu;
+    
+    long delay_time = 100000;
 
+    if(secc->GUN_Error = BCP_VOL_MISMATCH)delay_time = 1000000; //GB18487.1-2023.B.4.7.8
     can_APP_clear(0);
     printccui("step\n");
     secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);
     can_GBT27930_send_CST(dev,&dev->cst);
-    usleep(100000);//
+    usleep(delay_time);//
 
     if (secc->set_K1K2_state(secc, 0, 1000) == 1) 
     {
@@ -597,15 +649,16 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
     long int wait_time; 
     APPLY(GBT_27930_2015_BSD);
     APPLY(GBT_27930_2015_BST);
-    int recv_pgn_flag = 0; //接收超时标准
     long wait_BSD_time = systime_ms();
     printccui("step\n");
+    can_APP_clear(GBT_27930_2015_CCS);
     WAIT_CONDI(
         wait_time,1000000,
         ,
         RECV_BMS_2(dev,GBT_27930_2015_BSD,GBT_27930_2015_BST);
-        TIME_OUT(dev,recv_pgn_flag)
+        TIME_OUT(dev,GBT_27930_2015_BST)
     ); 
+    
     printccui("step\n");
     secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);
     secc_stop_Transaction(secc);
@@ -618,7 +671,6 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
     }
 
     printccui("step\n");
-    recv_pgn_flag = 0 ;
     if (secc->GUN_Error == 0)
     {
         int64_t now_ms = systime_ms();
@@ -627,9 +679,8 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
         {
            
             float bmsA = secc->IMeters;
-            printf("bmsA =%f\n",bmsA);
             RECV_BMS_1(dev,GBT_27930_2015_BSD);
-            TIME_OUT(dev,recv_pgn_flag);          
+            TIME_OUT(dev,GBT_27930_2015_NUL)         
             if (bmsA < 5.0f) { break; }
             msleep(100);
         }
@@ -651,10 +702,12 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
     }
     WAIT_CONDI(
         wait_time,wait_BSD_time,
-        TIME_OUT(dev,GBT_27930_2015_BSD);
+        can_GBT27930_send_timeout(dev, GBT_27930_2015_BSD);
+        break;
         ,
-        int ret = can_GBT27930_waits(dev,1,GBT_27930_2015_BSD);       
-        if((ret ==  GBT_27930_2015_BSD)||(_27930_recvFlag.GBT_27930_2015_BSD_recv==1))break;
+        RECV_BMS_1(dev,GBT_27930_2015_BSD);
+        if(_27930_recvFlag.GBT_27930_2015_BSD_recv!= 0){break;}
+        if(_27930_recvFlag.GBT_27930_2015_BST_timeOut !=0){break;}
     );
     usleep(500000);    //临时措施，保证CEM/CSD发送 
     can_APP_clear(0);
@@ -712,19 +765,19 @@ void* can_GBT27930_loop(void* argv)
         if (state == 0) continue;
         switch(state)
         {
-            case GUN_STARTUP:       { can_GBT27930_TryLock(dev, 60000);printccui("step\n"); }break;
-            case GUN_ELOCKED:       { can_GBT27930_WaitAuthrized(dev, 60000);printccui("step\n"); } break;
-            case GUN_AUTHORIZED:    { can_GBT27930_Handshake(dev);printccui("step\n"); } break;
+            case GUN_STARTUP:       { can_GBT27930_TryLock(dev, 60000);}break;
+            case GUN_ELOCKED:       { can_GBT27930_WaitAuthrized(dev, 60000);} break;
+            case GUN_AUTHORIZED:    { can_GBT27930_Handshake(dev); } break;
             case GUN_INSULATION:    { can_GBT27930_Insulation(dev); } break;
             case GUN_PRECHARGE:     { can_GBT27930_PreCharge(dev); } break;
             case GUN_CHARGING:      { can_GBT27930_Charging(dev); } break;
             case GUN_SUSPEND:                                       break;
-            case GUN_STOPPING:      { can_GBT27930_Finishing(dev); } break;
-            case GUN_EMERGRNCY_STOP:{ can_GBT27930_EMERGRNCY_STOP(dev); break;}
+            case GUN_STOPPING:      {can_GBT27930_Finishing(dev); } break;
+            case GUN_EMERGRNCY_STOP:{can_GBT27930_EMERGRNCY_STOP(dev); break;}
             case GUN_COMFALUT:      {   }break;
             default:                { }break;
         }
-        if (secc->GUN_Error) { printi("secc->GUN_Error:%08x, %ld\n", secc->GUN_Error, secc->GUN_Error);break;}
+        //if (secc->GUN_Error) { printi("secc->GUN_Error:%08x, %ld\n", secc->GUN_Error, secc->GUN_Error);break;}
     }
     printe("Leave.\n");
     can_GBT27930_Finishing(dev);

src/ccu_define.h

@@ -54,8 +54,8 @@ typedef enum gun_state
     GUN_CHARGING,           // 充电中
     GUN_SUSPEND,            // 充电挂起状态（暂停充电）
     GUN_STOPPING,           // 充电已完成，未拔枪
-    GUN_EMERGRNCY_STOP,     // 紧急停机
     GUN_COMFALUT,           // 通讯超时
+    GUN_EMERGRNCY_STOP,     // 紧急停机 
     GUN_UNKNOW,             // 其他未知状态
 
     GUN_SLACOK = GUN_ELOCKED,// PLC准备好
@@ -121,6 +121,24 @@ typedef enum alarm_state
     PCU_PWMFB6_FAULT,
     PCU_PWMFB7_FAULT,
     ERROR_MAX_NUMBER,
+
+    BMS_STOP_BY_SOC = 0x81000000,    //BMS达到SOC，主动停止
+    BMS_STOP_BY_GLOB_VOL,
+    BMS_STOP_BY_SIG_VOL,             //单体电压停止
+    BMS_STOP_BY_OYRHER,              //其他故障
+    BCP_VOL_MISMATCH = 0x81000010,   //BCP报文与实际报文不匹配
+    GBT_27930_2015_BRM_TIMEOUT,
+    GBT_27930_2015_BSM_TIMEOUT,
+    GBT_27930_2015_BCP_TIMEOUT,
+    GBT_27930_2015_BRO_TIMEOUT,
+    GBT_27930_2015_BCL_TIMEOUT,
+    GBT_27930_2015_BCS_TIMEOUT,
+    GBT_27930_2015_BSD_TIMEOUT,
+    GBT_27930_2015_BST_TIMEOUT,
+    GBT_27930_2015_COM_MAX,
+    GBT_18487_OVER_VOL, //GB18487.1-2023.B.4.7.8
+    GBT_CC1_FALUT,
+    GUN_ELECLOCK_FAULT
 }alarm_state_t;
 
 

src/ccu_port.c

@@ -251,6 +251,13 @@ static void gunA_IO_check(ccu_port_t* ccu)
     }
     if (seccA->config->GUN_Type == GUN_TYPE_GBDC)
     {
+         if(gunA_Get_ELock(ccu) == 0)
+        {
+            if((seccA->GUN_State >=GUN_ELOCKED)&&(seccA->GUN_State <=GUN_CHARGING))
+            {
+                   secc_set_error(seccA,GUN_ELECLOCK_FAULT); 
+            }
+        }
         seccA->CC1_voltage = gunA_Get_CC1_Voltage(ccu);
         // printi("CC1_voltage:%f\n", seccA->CC1_voltage);
         if ((4.0f - 0.5f) < seccA->CC1_voltage  &&  seccA->CC1_voltage < (4.0f + 0.5f))
@@ -265,11 +272,14 @@ static void gunA_IO_check(ccu_port_t* ccu)
             }
         }else{
             printi("CC1_voltage:%f\n", seccA->CC1_voltage);
-            if (seccA->GUN_State >= GUN_PLUGIN)
+            if (seccA->GUN_State == GUN_PLUGIN)
             {
                 printi("CC1_voltage:%f\n", seccA->CC1_voltage);
                 secc_exit_can(seccA);
                 secc_set_state(seccA, GUN_PLUGOUT);
+            }else if((seccA->GUN_State > GUN_PLUGIN)&&(seccA->GUN_State <= GUN_EMERGRNCY_STOP))
+            {
+                secc_set_error(seccA,GBT_CC1_FALUT);
             } 
             printi("CC1_voltage:%f\n", seccA->CC1_voltage);
         }

src/secc_port.c

@@ -138,7 +138,7 @@ int secc_set_state(secc_port_t* secc, int STATE)
 {
     ccu_port_t* ccu = (ccu_port_t*)secc->ccu;
     pcu_port_t* pcu = (pcu_port_t*)secc->pcu;
-    printd("secc->fp[1]:%d, STATE:%d\n", secc->fp[1], STATE);
+    printccui("secc->fp[1]:%d, STATE:%d\n", secc->fp[1], STATE);
     if (secc->fp[1] > 0 && STATE >= GUN_PLUGIN)
     {
         send(secc->fp[1], &STATE, sizeof(STATE), 0);
@@ -154,23 +154,23 @@ int secc_set_state(secc_port_t* secc, int STATE)
 
 int secc_should_stop(secc_port_t* secc)
 {
-    if (secc->GUN_Error!=0 && secc->GUN_Error!=GUN_RESERVED) return 1;
+    //if (secc->GUN_Error!=0 && secc->GUN_Error!=GUN_RESERVED) return 1;
     if (secc->manul_stop)return 1;
 
-    if (secc->request_KWh > 0.0f)
-    {
-        float totalKWh = secc->EMeters - secc->started_KWh;
-        if (totalKWh > secc->request_KWh) return 1;
-    }
-    if (secc->request_Minutes > 0)
-    {
-        int totalMinutes = (time(NULL) - secc->started_UTC)/60;
-        if (totalMinutes > secc->request_Minutes) return 1;
-    }
-    if (secc->request_SOC > 0)
-    {
-        if (secc->SOC > secc->request_SOC ) return 1;
-    }
+    // if (secc->request_KWh > 0.0f)
+    // {
+    //     float totalKWh = secc->EMeters - secc->started_KWh;
+    //     if (totalKWh > secc->request_KWh) return 1;
+    // }
+    // if (secc->request_Minutes > 0)
+    // {
+    //     int totalMinutes = (time(NULL) - secc->started_UTC)/60;
+    //     if (totalMinutes > secc->request_Minutes) return 1;
+    // }
+    // if (secc->request_SOC > 0)
+    // {
+    //     if (secc->SOC > secc->request_SOC ) return 1;
+    // }
     return 0;
 }