一致性大部通过 还需优化一些逻辑

src/GBT2015/GBT27930.c

@@ -25,7 +25,8 @@ const _27930_table_t _27930_table[] =
     {GBT_27930_2015_BCL,0,1000},
     {GBT_27930_2015_BCS,0,5000},
     {GBT_27930_2015_BSM,0,1},//国标没有超时要求
-    {GBT_27930_2015_BST,0,10},
+    {GBT_27930_2015_BST,0,5000},
+    {GBT_27930_2015_BSD,0,10000},
 };
 
 static uint16_t Can_get_27930sendtime(uint8_t pgn_hex)
@@ -274,6 +275,58 @@ int can_GBT27930_wait_n(GBT27930_t* dev,int pgn)
     return 0;
 }
 
+/**
+ * @brief 等待多个事件
+ * @param num 参数个数
+ * @note 最大不超过10个
+ */ 
+int can_GBT27930_waits(GBT27930_t* dev,uint8_t num, ...)
+{
+    secc_port_t* secc = (secc_port_t*)dev->secc;
+    printd("dev->fd[0]:%d\n", dev->fd[0]);
+    if (dev->fd[0] < 0 ) return GBT_27930_2015_ERROR;
+    int PF = 0; 
+    struct timeval start_time,cur_time;
+    gettimeofday(&start_time, NULL);    
+    fd_set readfds;
+    int rv;
+
+    va_list args;          
+    int ltemp[10];
+    
+    va_start(args, num);   
+    for (uint8_t i = 0; i < num; i++) {
+        ltemp[i] = va_arg(args, int);
+    }
+    
+    FD_ZERO(&readfds);
+    FD_SET(dev->fd[0], &readfds);
+    struct timeval tv;
+    // gettimeofday(&cur_time, NULL);   
+    // if(cur_time.tv_sec>= (start_time.tv_sec+timeout/1000))break;
+    // tv.tv_sec = start_time.tv_sec+timeout/1000 -cur_time.tv_sec ;
+    // tv.tv_usec = 2000;
+    // tv.tv_usec = (timeout%1000)*1000+cur_time.tv_usec-start_time.tv_usec;
+    tv.tv_usec = 0;
+    tv.tv_sec = 0;
+    rv = select(dev->fd[0]+1, &readfds, NULL, NULL, &tv);
+    
+    if (rv > 0)
+    {
+        if(FD_ISSET(dev->fd[0], &readfds))
+        {
+            int ret = recv(dev->fd[0], &PF, sizeof(PF), 0);
+            if (ret == sizeof(PF))
+            {       
+                   for (uint8_t i = 0; i < num; i++) {
+                    if(PF == ltemp[i]){va_end(args);return PF;}    
+                }
+            }
+        }
+    }
+    va_end(args);  
+    return GBT_27930_2015_ERROR;
+}
 
 typedef struct zw_send
 {
@@ -316,7 +369,7 @@ void Can_sendpoll(void* args)
     pthread_mutex_lock(&zw_mutex);
     for(uint8_t i;i<10;i++){
         if(zw_sendOb[i].pgn != 0)
-        {           
+        {       
             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); //避免总线拥挤,
@@ -341,7 +394,7 @@ void  can_APP_add(int pgn,struct can_frame* txframe)
     }
     if(p->pgn == 0)
     {
-        p->pgn = pgn;
+        p->pgn = pgn;       
         memcpy(&p->frame, txframe, sizeof(struct can_frame));
         p->inteval_ms = Can_get_27930sendtime(pgn);
         p->lastsend_time = 0 ;    
@@ -355,20 +408,29 @@ void  can_APP_add(int pgn,struct can_frame* txframe)
 /**
  * @brief 清除发送数据
  * @param pgn: 0时清除所有数据 
+ *             0xff  清除除CSD/CST意外的所有数据
  */
 void can_APP_clear(int pgn)
 {
-   pthread_mutex_lock(&zw_mutex);
-   if(pgn != 0){
-        zw_send_t* p = find_empty(pgn,0);
-        if(p != NULL)p->pgn = 0;
-   }else{
+    pthread_mutex_lock(&zw_mutex);
+    if(pgn ==0){
         for(uint8_t i =0;i<10;i++)
         {
             zw_sendOb[i].pgn = 0;
         } 
+    }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))
+           {zw_sendOb[i].pgn = 0;}
+        }
+    }else{
+        for(uint8_t i =0;i<10;i++)
+        {
+         if(pgn == zw_sendOb[i].pgn)zw_sendOb[i].pgn = 0;
+        }
     }
-   pthread_mutex_unlock(&zw_mutex);
+    pthread_mutex_unlock(&zw_mutex);
 }
 
 //获取一个全局时间
@@ -395,21 +457,21 @@ static void* can_GBT27930_Txloop(void* args)
     
     static uint8_t cst_cnt =0 ; //发送2次cml 发送一次CTS
 	while(dev->quitTx == 0)
-	{
+    {
         time_run();
         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);
+            //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);
 	}
-    printd(".quitTx = 1\n");
+    printccui(".quitTx = 1\n");
     pthread_exit(NULL);
 	return NULL;
 }
@@ -478,9 +540,10 @@ static void* can_GBT27930_Rxloop(void* args)
             send(dev->fd[1], &PF, sizeof(PF), 0);
         }
 
-        if (PF == GBT_27930_2015_BST && dev->lastPF != GBT_27930_2015_BST)
+        if (PF == GBT_27930_2015_BST)
         {
-            secc_set_state(secc, GUN_STOPPING);
+            //secc_set_state(secc, GUN_STOPPING); 
+            send(dev->fd[1], &PF, sizeof(PF), 0); 
             can_GBT27930_show_BST(dev);
         }
 
@@ -567,7 +630,7 @@ int can_GBT27930_init(GBT27930_t* dev, const char *can_name)
         dev->bsm_last.bmsPowerPermitted = 1;
         dev->cro.status = 0x00;
         dev->can_name = can_name;
-        dev->frame_interval_ms = 10; //发送间隔最小是10ms
+        dev->frame_interval_ms = 2; //发送间隔最小是10ms
         printd("CAN(%s).connectorId[%d]...\n", dev->can_name, secc->config->connectorId);
         pthread_mutex_init(&dev->mutex, NULL);
         printd("step\n");
@@ -580,7 +643,7 @@ void can_GBT27930_exit(GBT27930_t* dev)
 {
     if (dev)
     {
-        printd("step\n");
+        printccui("step\n");
         secc_port_t* secc = (secc_port_t*)dev->secc;
         if (dev->quit == 0)
         {
@@ -628,6 +691,7 @@ int can_GBT27930_send_CEM(GBT27930_t* dev, GBT27930_CEM_t *req)
         // dev->last_tickcnt = 0;
         // pthread_mutex_unlock(&dev->mutex);
         can_APP_add(GBT_27930_2015_CEM,&txframe);
+        txframe.can_id = 0 ;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))
@@ -660,12 +724,14 @@ int can_GBT27930_send_CHM(GBT27930_t* dev)
         txframe.can_dlc = 3;
         dev->stop = 0;
 
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CHM)/10;
-        dev->last_tickcnt = 0;
-        printTxCanFrame(dev->can_name, &dev->frame);
-        pthread_mutex_unlock(&dev->mutex);
+        // pthread_mutex_lock(&dev->mutex);
+        // memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
+        // dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CHM)/10;
+        // dev->last_tickcnt = 0;
+        // printTxCanFrame(dev->can_name, &dev->frame);
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CHM,&txframe);
+        txframe.can_id = 0 ;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))
@@ -731,12 +797,15 @@ int can_GBT27930_send_CRM(GBT27930_t* dev, uint8_t status, uint32_t CHG_No, uint
         txframe.can_dlc = 8;
         dev->stop = 0;
 
+        can_APP_clear(GBT_27930_2015_CHM);
         can_APP_clear(GBT_27930_2015_CEM); //GB2015-27930-tab.d1
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CRM)/10;
-        dev->last_tickcnt = 0;
-        pthread_mutex_unlock(&dev->mutex);
+        // pthread_mutex_lock(&dev->mutex);
+        // memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
+        // dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CRM)/10;
+        // dev->last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CRM,&txframe);
+        txframe.can_id = 0;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))
@@ -839,6 +908,7 @@ int can_GBT27930_send_CTS(GBT27930_t* dev, struct tm *ptm)
         // dev->CTS_last_tickcnt = 0;
         // pthread_mutex_unlock(&dev->mutex);
         can_APP_add(GBT_27930_2015_CTS,&txframe);
+        txframe.can_id = 0;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe) == sizeof(struct can_frame))
@@ -1291,6 +1361,7 @@ int can_GBT27930_send_CSD(GBT27930_t* dev, GBT27930_CSD_t* req)
         
         memset(&txframe, 0, sizeof(struct can_frame));
         txframe.can_id = (Priority<<26)|(GBT_27930_2015_CSD<<16)|(dev->DA<<8)|dev->SA;
+        txframe.can_id |= CAN_EFF_FLAG;
         txframe.data[0] = (req->chgCumulativeMintues>>0)&0xFF;
         txframe.data[1] = (req->chgCumulativeMintues>>8)&0xFF;
         txframe.data[2] = (req->chgCumulativeKWH>>0)&0xFF;
@@ -1302,11 +1373,13 @@ int can_GBT27930_send_CSD(GBT27930_t* dev, GBT27930_CSD_t* req)
         txframe.can_dlc = 8;
         dev->stop = 0;
 		
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CSD)/10;
-        dev->last_tickcnt = 0;
-        pthread_mutex_unlock(&dev->mutex);
+        // pthread_mutex_lock(&dev->mutex);
+        // memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
+        // dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CSD)/10;
+        // dev->last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CSD,&txframe);
+        dev->frame.can_id = 0;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))

src/GBT2015/GBT27930.h

@@ -94,14 +94,41 @@
 
 typedef struct
 {
-    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_reser:28;
+    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 ;
+    };
 }_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){ \
@@ -117,6 +144,79 @@ uint16_t Can_get_27930Recvtime(uint8_t pgn_hex);
                                                     }\
                                                 }while(0)
 
+#define RECV_BMS_1(dev,pgn)                 do{\
+                                                    int ret = can_GBT27930_waits(dev,2,pgn,GBT_27930_2015_BST);\
+                                                    if(ret == pgn){ \
+                                                        _27930_recvFlag.pgn##_recv=1;\
+                                                        pgn##_curtime =systime_ms();\
+                                                    }else if(ret == GBT_27930_2015_BST){\
+                                                        secc_port_t* secc = (secc_port_t*)dev->secc;\
+                                                        secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);\
+                                                        _27930_recvFlag.GBT_27930_2015_BST_recv=1;}\
+                                                    if((pgn##_curtime+Can_get_27930Recvtime(pgn))< systime_ms()){\
+                                                        printf("%s_timeout\n",#pgn);\
+                                                        recv_pgn_flag = pgn;\
+                                                    }\
+                                                    pgn_run(dev);\
+                                                }while(0) 
+
+#define RECV_BMS_2(dev,pgn,pgn1)                do{\
+                                                    int ret = can_GBT27930_waits(dev,3,pgn,pgn1,GBT_27930_2015_BST);\
+                                                    if(ret == pgn){ \
+                                                        _27930_recvFlag.pgn##_recv=1;\
+                                                        pgn##_curtime =systime_ms();\
+                                                    }else if(ret == pgn1){ \
+                                                        _27930_recvFlag.pgn1##_recv=1;\
+                                                        pgn1##_curtime =systime_ms();}\
+                                                    else if(ret == GBT_27930_2015_BST){\
+                                                        secc_port_t* secc = (secc_port_t*)dev->secc;\
+                                                        secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);\
+                                                        _27930_recvFlag.GBT_27930_2015_BST_recv=1;\
+                                                        GBT_27930_2015_BST_curtime =systime_ms();\
+                                                    }\
+                                                    if((pgn##_curtime+Can_get_27930Recvtime(pgn))< systime_ms()){\
+                                                        printf("%s_timeout\n",#pgn);\
+                                                        recv_pgn_flag = pgn;\
+                                                    }\
+                                                     if((pgn1##_curtime+Can_get_27930Recvtime(pgn1))< systime_ms()){\
+                                                        printf("%s_timeout\n",#pgn1);\
+                                                        recv_pgn_flag = pgn1;\
+                                                    }\
+                                                     pgn_run(dev);\
+                                                }while(0)    
+
+
+#define RECV_BMS_3(dev,pgn,pgn1,pgn2)         do{\
+                                                    int ret = can_GBT27930_waits(dev,4,pgn,pgn1,pgn2,GBT_27930_2015_BST);\
+                                                    if(ret == pgn){ \
+                                                        _27930_recvFlag.pgn##_recv=1;\
+                                                        pgn##_curtime =systime_ms();\
+                                                    }else if(ret == pgn1){ \
+                                                        _27930_recvFlag.pgn1##_recv=1;\
+                                                        pgn1##_curtime =systime_ms();}\
+                                                    else if(ret == pgn2){ \
+                                                        _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;\
+                                                        secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);\
+                                                        _27930_recvFlag.GBT_27930_2015_BST_recv=1;}\
+                                                    if((pgn##_curtime+Can_get_27930Recvtime(pgn))< systime_ms()){\
+                                                        printf("%s_timeout\n",#pgn);\
+                                                        recv_pgn_flag = pgn;\
+                                                    }\
+                                                    if((pgn1##_curtime+Can_get_27930Recvtime(pgn1))< systime_ms()){\
+                                                    printf("%s_timeout\n",#pgn1);\
+                                                    recv_pgn_flag = pgn1;\
+                                                    }\
+                                                    if(pgn2 != GBT_27930_2015_BSM){\
+                                                    if((pgn2##_curtime+Can_get_27930Recvtime(pgn2))< systime_ms()){\
+                                                        printf("%s_timeout\n",#pgn2);\
+                                                        recv_pgn_flag = pgn2;\
+                                                    }\
+                                                    pgn_run(dev);\
+                                                }\
+                                                }while(0)
 typedef struct
 {
     uint32_t  GBT_27930_TIMEOUT_BRO_recv :1;
@@ -125,7 +225,6 @@ typedef struct
 
 
 
-
 typedef struct GBT27930_SPN
 {
     uint32_t SPN:19;
@@ -460,5 +559,7 @@ void can_GBT27930_show_BST(GBT27930_t* can);
 void can_GBT27930_show_BEM(GBT27930_t* can);
 
 void can_APP_clear(int pgn);
+int can_GBT27930_waits(GBT27930_t* dev,uint8_t num, ...);  
 
+void  exit_handle(GBT27930_t* dev,int pgn);
 #endif//__GBT_27930_2015_H__

src/GBT2015/can_SECC.c

@@ -1,8 +1,9 @@
 #include "secc_port.h"
 #include "GBT27930.h"
 int can_GBT27930_wait_n(GBT27930_t* dev,int pgn);
-
 static _27930_recvFlag_t _27930_recvFlag;
+
+uint8_t  Global_flaut = 0;
 static int can_GBT27930_send_stop(GBT27930_t* dev, int REASON)
 {
     ccu_port_t *ccu = (ccu_port_t*)dev->ccu;
@@ -27,6 +28,16 @@ static int can_GBT27930_send_stop(GBT27930_t* dev, int REASON)
 }
 
 
+//接收补充设置
+void  pgn_run(GBT27930_t* dev)
+{
+    if(_27930_recvFlag.GBT_27930_2015_BSD_recv == 1){
+        can_APP_clear(GBT_27930_2015_CST);
+        can_GBT27930_send_CSD(dev, &dev->csd);
+    }
+}
+
+
 static int can_GBT27930_send_timeout(GBT27930_t* dev, int STATE)
 {
     ccu_port_t *ccu = (ccu_port_t*)dev->ccu;
@@ -40,8 +51,8 @@ static int can_GBT27930_send_timeout(GBT27930_t* dev, int STATE)
         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;
-        case GBT_27930_TIMEOUT_BST:{dev->cem.bst_timeout=1;}break;
-        case GBT_27930_TIMEOUT_BSD:{dev->cem.bsd_timeout=1;}break;
+        case GBT_27930_2015_BST:{dev->cem.bst_timeout=1;}break;
+        case GBT_27930_2015_BSD:{dev->cem.bsd_timeout=1;}break;
         default: {dev->cem.others=1;} break;
     }
     can_APP_clear(0);
@@ -107,13 +118,28 @@ static int can_GBT27930_Handshake(GBT27930_t* dev)
     ccu_port_t *ccu = (ccu_port_t*)dev->ccu;
     pcu_port_t *pcu = (pcu_port_t*)dev->pcu;
 
+    _27930_recvFlag.data = 0;
+
     printi("SECC(%d) Handshake...\n", secc->config->connectorId);
     secc->set_Aux12V_state(secc, 1);
     can_GBT27930_send_CHM(dev);
     int ret = can_GBT27930_wait(dev, GBT_27930_2015_BHM, BHM_TIMEOUT);
     if (ret == GBT_27930_2015_BHM)
     {
-        printv("BMS->bhm.bmsMaxVoltage:%f\n", (float)(dev->bhm.bmsMaxVoltage)/10);
+        printccui("BMS->bhm.bmsMaxVoltage:%f,secc->SECC_minV=%f\n", (float)(dev->bhm.bmsMaxVoltage)/10,secc->SECC_minV);
+        if(dev->bhm.bmsMaxVoltage < secc->SECC_minV*10){
+            can_APP_clear(0);
+            secc->set_Aux12V_state(secc, 0);
+            printccui("step\n");
+            if (secc->set_ELock_state(secc, 0, 1000)==1)
+            {
+                pcu->update_ElecLock_state(pcu, 0); 
+            }else{
+                secc_set_error(secc, GUN_ELECLOCK_STALL);
+            }
+            while(1){sleep(1);}  //停在这里 等待拔枪以后自己删除线程
+
+        }
         secc_set_state(secc, GUN_INSULATION);
         return 1;
     }
@@ -170,8 +196,8 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
     }
 
     float Vimd = ((float)dev->bhm.bmsMaxVoltage)/10;
-    Vimd = fminf(Vimd, 1000.0f);
-    Vimd = fmaxf(Vimd, 500.0f);
+    Vimd = fminf(Vimd, 500.0f);//取2者的小值
+   // Vimd = fmaxf(Vimd, 500.0f);
 
     secc->set_IMD_state(secc, 1);
     secc_request_power(secc, POWER_REQUEST_INSULATION, Vimd, 0);
@@ -220,6 +246,19 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
                                             XFlag = XFlag+1-systime_ms();\
                                             }while(0)      
 
+
+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);
+    }
+}
+
 static int can_GBT27930_PreCharge(GBT27930_t* dev)
 {
     int ret;
@@ -250,7 +289,7 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
         secc_set_state(secc, GUN_COMFALUT);
         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)
@@ -266,26 +305,22 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
     dev->cml.chgMaxOutputCurrent = (uint16_t)(secc->SECC_maxI*10 + 0.5);
     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,
-        SPILTE(
-            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);
-            return GBT_27930_2015_ERROR;
-        ),
-        can_GBT27930_send_CTS(dev, NULL);        
-        ret = can_GBT27930_wait_n(dev, GBT_27930_2015_BRO);
-        if(ret == GBT_27930_2015_BRO)break;
+        , 
+        RECV_BMS_1(dev,GBT_27930_2015_BRO);
+        TIME_OUT(dev,recv_pgn_flag);
+        if(_27930_recvFlag.GBT_27930_2015_BRO_recv == 1)break;             
     );
     //----------等待车端绝缘检测完成----------
     can_GBT27930_send_CML(dev, &dev->cml);
     dev->bro.status = 0x00;//清零
     WAIT_CONDI(  
-          wait_time,60000,
+          wait_time,wait_time,
           SPILTE(
             can_GBT27930_send_timeout(dev, GBT_27930_2015_BRO);
             secc_set_state(secc, GUN_COMFALUT);
@@ -295,11 +330,8 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
             return GBT_27930_2015_ERROR;
             ),  
            can_GBT27930_send_CTS(dev, NULL); 
-           if( dev->bro.status == 0xaa)
-           {
-            printf(",ambdnabdn");
-            break;
-           }
+           if( dev->bro.status == 0xaa)break;
+           
     );
     can_APP_clear(GBT_27930_2015_CML); ////GB2015-27930-tab.d1
     can_APP_clear(GBT_27930_2015_CTS);
@@ -328,6 +360,12 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
             printd("SECC(%d).VMeters:%f, VGround:%f, VBattery:%f\n", secc->config->connectorId, secc->VMeters, secc->VGround, VBattery);
             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);
     );
     secc_set_error(secc, GUN_PRECHARGE_FAULT);
@@ -371,19 +409,26 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
     printi("step\n");
     can_GBT27930_send_CRO(dev, 0xAA);
     printccui("step\n");
-    ret = can_GBT27930_wait(dev, GBT_27930_2015_BCL, BCL_TIMEOUT);
+    //ret = can_GBT27930_wait(dev, GBT_27930_2015_BCL, BCL_TIMEOUT);
     printccui("step\n");
-    long int bcs_time = systime_ms();
-    long int bcl_time = systime_ms();
+    APPLY(GBT_27930_2015_BCS);
+    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(dev,GBT_27930_2015_BCL,bcl_time);
-        RECV_BMS(dev,GBT_27930_2015_BCS,bcs_time);
-        if(can_GBT27930_wait_n(dev,GBT_27930_2015_BSM)==GBT_27930_2015_BSM){
-         _27930_recvFlag.GBT_27930_2015_BSM_recv = 1;
+
+        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;
         }
+        // if(can_GBT27930_wait_n(dev,GBT_27930_2015_BSM)==GBT_27930_2015_BSM){
+        //  _27930_recvFlag.GBT_27930_2015_BSM_recv = 1;
+        // }
  
        if(_27930_recvFlag.GBT_27930_2015_BCL_recv==1){ 
             _27930_recvFlag.GBT_27930_2015_BCL_recv = 0 ;
@@ -394,8 +439,8 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
                 float voltage = (((float)dev->bcl.bmsVoltage_request) / 10);
                 float current = (((float)dev->bcl.bmsCurrent_request) / 10);
                 //printi("SECC(%d) BCL voltage:%f, current:%f, mode:%d\n", secc->config->connectorId, voltage, current, dev->bcl.bmsChargeMode);
-                printccui("SBCL secc->VMeters:%f, secc->VGround:%f,secc->I=IMeters:%f\n",secc->VMeters, secc->VGround,secc->IMeters);
-                //printccui("SECC(%d) BCL voltage:%f, current:%f, mode:%d\n", secc->config->connectorId, voltage, current, dev->bcl.bmsChargeMode);
+                //printccui("SBCL secc->VMeters:%f, secc->VGround:%f,secc->I=IMeters:%f\n",secc->VMeters, secc->VGround,secc->IMeters);
+                printccui("SECC(%d) BCL voltage:%f, current:%f, mode:%d\n", secc->config->connectorId, voltage, current, dev->bcl.bmsChargeMode);
                 if (dev->bcl.bmsChargeMode == 1) { secc_request_power(secc, POWER_REQUEST_CONST_VOLTAGE, voltage, current); }
                 if (dev->bcl.bmsChargeMode == 2) { secc_request_power(secc, POWER_REQUEST_CONST_CURRENT, voltage, current); }
             }
@@ -410,13 +455,12 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
             secc->EV_Estimate_Minutes = dev->bcs.bmsChargingNeedMinutes;
             secc->SOC = dev->bcs.bmsSOC;
             //printi("SECC(%d)  BCS(%fV, %fA, %dM, %dP)\n", secc->config->connectorId, secc->EV_Charging_voltage, secc->EV_Charging_current, secc->EV_Estimate_Minutes, secc->SOC);
-            printccui("SECC(%d)  BCS(%fV, %fA, %dM, %dP)\n", secc->config->connectorId, secc->EV_Charging_voltage, secc->EV_Charging_current, secc->EV_Estimate_Minutes, secc->SOC);
+            //printccui("SECC(%d)  BCS(%fV, %fA, %dM, %dP)\n", secc->config->connectorId, secc->EV_Charging_voltage, secc->EV_Charging_current, secc->EV_Estimate_Minutes, secc->SOC);
             secc_report_MeterValues(secc);
         }
 
         if(_27930_recvFlag.GBT_27930_2015_BSM_recv == 1){
             _27930_recvFlag.GBT_27930_2015_BSM_recv  = 0;
-            bsm_ms = systime_ms();
             float voltage = (((float)dev->bcl.bmsVoltage_request) / 10);
             float current = (((float)dev->bcl.bmsCurrent_request) / 10);
             if(dev->bsm.bmsBatteryOverTemp != 0){
@@ -440,17 +484,16 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
             }
             if (dev->bsm.bmsPowerPermitted == 0x0  && dev->bsm_last.bmsPowerPermitted == 1)
             {   //暂停
-                printi("SECC(%d) BSM(%d).%s\n", secc->config->connectorId, dev->bsm.bmsPowerPermitted, "suspend");
+                printccui("SECC(%d) BSM(%d).%s\n", secc->config->connectorId, dev->bsm.bmsPowerPermitted, "suspend");
                 secc_request_power(secc, POWER_REQUEST_SHUTDOWN, voltage, current);
             }
             if (dev->bsm.bmsPowerPermitted == 0x1 && dev->bsm_last.bmsPowerPermitted == 0)
             {   //继续
-                printi("SECC(%d) BSM(%d).%s\n", secc->config->connectorId, dev->bsm.bmsPowerPermitted, "continue");
+                printccui("SECC(%d) BSM(%d).%s\n", secc->config->connectorId, dev->bsm.bmsPowerPermitted, "continue");
                 if (dev->bcl.bmsChargeMode = 0x01) { secc_request_power(secc, POWER_REQUEST_CONST_VOLTAGE, voltage, current); }
                 if (dev->bcl.bmsChargeMode = 0x02) { secc_request_power(secc, POWER_REQUEST_CONST_CURRENT, voltage, current); }
             }
         }
-        now_ms = systime_ms();
         // if ((now_ms - bcl_ms) > BCL_TIMEOUT) { printi("SECC(%d) timeout(bcl:%lld, bcs:%lld, bsm:%lld)\n", secc->config->connectorId, (now_ms - bcl_ms), (now_ms - bcs_ms), (now_ms - bsm_ms)); break;}
         // if ((now_ms - bcs_ms) > BCS_TIMEOUT) { printi("SECC(%d) timeout(bcl:%lld, bcs:%lld, bsm:%lld)\n", secc->config->connectorId, (now_ms - bcl_ms), (now_ms - bcs_ms), (now_ms - bsm_ms)); break;}
         // if ((now_ms - bsm_ms) > BSM_TIMEOUT) { printi("SECC(%d) timeout(bcl:%lld, bcs:%lld, bsm:%lld)\n", secc->config->connectorId, (now_ms - bcl_ms), (now_ms - bcs_ms), (now_ms - bsm_ms)); goto endhandl;}
@@ -464,11 +507,10 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
             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);
-            ccs_ms = systime_ms();
        // }
         usleep(2000);
     }
- endhandl:   
+ endhandl:  
     printccui("step\n");
     secc_set_state(secc, GUN_STOPPING);
     return GBT_27930_2015_NORMAL;
@@ -484,6 +526,63 @@ static int can_GBT27930_ReComm(GBT27930_t* dev)
     printccui("step\n");
 }
 
+/**
+ * @brief 紧急停机
+ * @see  /GB2015-27930-tab.A5
+ */
+
+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;
+
+    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);//
+
+    if (secc->set_K1K2_state(secc, 0, 1000) == 1) 
+    {
+        pcu->update_K1K2_state(pcu, 0, 0);
+    }else {
+        secc_set_error(secc, GUN_CONTACTOR_FAULT);
+    }
+    can_APP_clear(0);
+    secc->set_Aux12V_state(secc, 0);
+
+    if (secc->set_ELock_state(secc, 0, 1000)==1)
+    {
+        pcu->update_ElecLock_state(pcu, 0); 
+    }else{
+        secc_set_error(secc, GUN_ELECLOCK_STALL);
+    }
+
+    secc->request_Minutes = 0;
+    secc->request_SOC = 0;
+    secc->request_KWh = 0;
+    secc->reserve_on = 0;
+    secc->reservationId = 0;
+    secc->started_KWh = 0;
+    secc->started_UTC = 0;
+    secc->SOC = 0;
+    secc->EV_Charging_current = 0;
+    secc->EV_Charging_voltage = 0;
+    secc->EV_Estimate_Minutes = 0;
+    secc->transactionId = 0;
+
+    printd("step\n");
+    
+    can_GBT27930_close_pipe(dev);
+
+	printd("GUN_Error:%08x, GUN_State:%08x\n", secc->GUN_Error, secc->GUN_State);
+    secc_set_state(secc, GUN_PLUGIN);
+    printd("step\n");
+    return GBT_27930_2015_NORMAL;
+}
+
+
 static int can_GBT27930_Finishing(GBT27930_t* dev)
 {
     secc_port_t* secc = (secc_port_t*)dev->secc;
@@ -493,40 +592,50 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
     //printi("SECC(%d) Finishing...\n", secc->config->connectorId);
     printccui("SECC(%d) Finishing...\n", secc->config->connectorId);
     can_GBT27930_send_stop(dev,GBT_27930_STOP_CMD);//还没区分命令
-
+    
    /************GB2015-27930-tab.A6**************/
     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");
     WAIT_CONDI(
-        wait_time,5000,
+        wait_time,1000000,
         ,
-        if(can_GBT27930_wait_n(dev,GBT_27930_2015_BST)==GBT_27930_2015_BST)
-        break;
+        RECV_BMS_2(dev,GBT_27930_2015_BSD,GBT_27930_2015_BST);
+        TIME_OUT(dev,recv_pgn_flag)
     ); 
+    printccui("step\n");
     secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);
     secc_stop_Transaction(secc);
     {
         dev->csd.chgCode = 0x81828385;
         dev->csd.chgCumulativeKWH = (uint16_t)((secc->EMeters - secc->started_KWh) * 10);
         dev->csd.chgCumulativeMintues = (time(NULL) - secc->started_UTC + 30)/60;
-        can_GBT27930_send_CSD(dev, &dev->csd);
-        can_GBT27930_wait(dev, GBT_27930_2015_BSD, 1000);
+        //can_GBT27930_send_CSD(dev, &dev->csd);
+        //can_GBT27930_wait(dev, GBT_27930_2015_BSD, 1000);
     }
 
     printccui("step\n");
-
+    recv_pgn_flag = 0 ;
     if (secc->GUN_Error == 0)
     {
         int64_t now_ms = systime_ms();
         int64_t end_ms = systime_ms() + 5000;
         for (now_ms = systime_ms(); now_ms <= end_ms; now_ms = systime_ms())
         {
+           
             float bmsA = secc->IMeters;
+            printf("bmsA =%f\n",bmsA);
+            RECV_BMS_1(dev,GBT_27930_2015_BSD);
+            TIME_OUT(dev,recv_pgn_flag);          
             if (bmsA < 5.0f) { break; }
             msleep(100);
         }
     }
 
-    printd("step\n");
+    printccui("step\n");
 
     if (secc->set_K1K2_state(secc, 0, 1000) == 1) 
     {
@@ -535,14 +644,23 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
         secc_set_error(secc, GUN_CONTACTOR_FAULT);
     }
     
-    printd("step\n");
+    printccui("step\n");
     
-    msleep(100);    //临时措施，保证CEM发送
-
+    if((wait_BSD_time +10000) > systime_ms() ){
+        wait_BSD_time = wait_BSD_time +10001 -systime_ms();
+    }
+    WAIT_CONDI(
+        wait_time,wait_BSD_time,
+        TIME_OUT(dev,GBT_27930_2015_BSD);
+        ,
+        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;
+    );
+    usleep(500000);    //临时措施，保证CEM/CSD发送 
     can_APP_clear(0);
     secc->set_Aux12V_state(secc, 0);
 
-    printd("step\n");
+    printccui("step\n");
 
     if (secc->set_ELock_state(secc, 0, 1000)==1)
     {
@@ -602,6 +720,7 @@ void* can_GBT27930_loop(void* argv)
             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_COMFALUT:      {   }break;
             default:                { }break;
         }

src/ccu_define.h

@@ -54,6 +54,7 @@ typedef enum gun_state
     GUN_CHARGING,           // 充电中
     GUN_SUSPEND,            // 充电挂起状态（暂停充电）
     GUN_STOPPING,           // 充电已完成，未拔枪
+    GUN_EMERGRNCY_STOP,     // 紧急停机
     GUN_COMFALUT,           // 通讯超时
     GUN_UNKNOW,             // 其他未知状态
 

src/main.c

@@ -455,6 +455,7 @@ int main(int argc, char* argv[])
         }
     }
 
+    
 
     // 初始化 OpenSSL
     SSL_library_init();
@@ -464,7 +465,6 @@ int main(int argc, char* argv[])
     mlog_init("/home/root/app_run/log/ccu", MLOG_MAX_FILESIZE, MLOG_MAX_FILENUMB);
 	printv("\n\t%s\n", formatAppVersion());
     printv("\tMLOG_MAX_FILESIZE:%d, MLOG_MAX_FILENUMB:%d\n", MLOG_MAX_FILESIZE, MLOG_MAX_FILENUMB);
-
     mgpio_init();
 	ccu_config_init();
     ocpp16_configkey_init();