大部分项能够通过

.vscode/settings.json

@@ -5,6 +5,11 @@
         "types.h": "c",
         "bitset": "c",
         "chrono": "c",
-        "algorithm": "c"
+        "algorithm": "c",
+        "assert.h": "c",
+        "gbt27930.h": "c",
+        "array": "c",
+        "string": "c",
+        "string_view": "c"
     }
 }

src/GBT2015/GBT27930.c

@@ -1,10 +1,12 @@
 #include "GBT27930.h"
 #include <stdarg.h>  
+#include <assert.h>
 //
 typedef struct 
 {
     uint8_t pgn_hex;
     uint16_t time_ms;
+    uint16_t BMS_pgn_time;
 }_27930_table_t;
 
 //GB27930_2015 Tab3
@@ -19,9 +21,14 @@ const _27930_table_t _27930_table[] =
     {GBT_27930_2015_CST,10},
     {GBT_27930_2015_CSD,250},
     {GBT_27930_2015_CEM,250},
+    {GBT_27930_2015_BRO,0,5000},
+    {GBT_27930_2015_BCL,0,1000},
+    {GBT_27930_2015_BCS,0,5000},
+    {GBT_27930_2015_BSM,0,1},//国标没有超时要求
+    {GBT_27930_2015_BST,0,10},
 };
 
-static uint8_t Can_get_27930sendtime(uint8_t pgn_hex)
+static uint16_t Can_get_27930sendtime(uint8_t pgn_hex)
 {
     uint8_t lnum = sizeof(_27930_table)/sizeof(_27930_table_t);
     for(uint8_t i=0;i<lnum;i++)
@@ -31,6 +38,15 @@ static uint8_t Can_get_27930sendtime(uint8_t pgn_hex)
     return 0;
 }
 
+uint16_t Can_get_27930Recvtime(uint8_t pgn_hex)
+{
+    uint8_t lnum = sizeof(_27930_table)/sizeof(_27930_table_t);
+    for(uint8_t i=0;i<lnum;i++)
+    {
+        if(_27930_table[i].pgn_hex ==pgn_hex)return _27930_table[i].BMS_pgn_time;
+    }
+    return 0;
+}
 
 int can_GBT27930_read(GBT27930_t* dev, int timeout)
 {
@@ -131,7 +147,7 @@ int can_GBT27930_read(GBT27930_t* dev, int timeout)
                     } break;
                     case GBT_27930_2015_BRO: { 
                         dev->bro_last.status = dev->bro.status;
-                        dev->bro.status = frame.data[0]; 
+                        dev->bro.status = frame.data[0];
                         return GBT_27930_2015_BRO; 
                     } break;
                     case GBT_27930_2015_BCL: { 
@@ -195,8 +211,6 @@ int can_GBT27930_wait(GBT27930_t* dev, int waitPF, int timeout,...)
             ltemp[i] = va_arg(args, int);
         }
     }
-   
-
     while(1)        //增加体现等待时间的逻辑
     {
         FD_ZERO(&readfds);
@@ -229,45 +243,167 @@ int can_GBT27930_wait(GBT27930_t* dev, int waitPF, int timeout,...)
     return GBT_27930_2015_ERROR;
 }
 
+
+//优化 等待事件 不满足会立即退出
+int can_GBT27930_wait_n(GBT27930_t* dev,int pgn)
+{    
+    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; 
+    fd_set readfds;
+    int rv;
+    FD_ZERO(&readfds);
+    FD_SET(dev->fd[0], &readfds);
+    struct timeval tv;
+    tv.tv_sec =0;
+    tv.tv_usec = 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))
+            {
+                if(PF == pgn)return PF;    
+            }
+        }
+    }
+    return 0;
+}
+
+
+typedef struct zw_send
+{
+    int pgn;
+    struct can_frame frame;
+    uint16_t inteval_ms; //发送间隔   
+    long int lastsend_time;
+}zw_send_t;
+
+static zw_send_t zw_sendOb[10] ={0,0,0,0,0,0,0,0,0,0};
+static pthread_mutex_t zw_mutex = PTHREAD_MUTEX_INITIALIZER;
+static uint8_t _27930_time[6] ={0};
+/**
+ * @brief 找到相应内存
+ * @param 目标pgn，0时随机返回一个空闲位置
+ *        opt: 0 默认找不到返回返回NULL，1 找不到对应对应空闲位置
+ * @return 返回值是目标位置，如果是NULL，说明错误
+ * @callergraph can_APP_add
+ *              can_APP_clear
+ */
+static zw_send_t* find_empty(int pgn,uint8_t opt)
+{
+    for(uint8_t i =0;i<10;i++)
+    {
+        if(zw_sendOb[i].pgn == pgn)return &zw_sendOb[i];
+    } 
+    if(opt == 0)return NULL;
+    for(uint8_t i =0;i<10;i++)
+    {
+        if(zw_sendOb[i].pgn == 0)return &zw_sendOb[i];
+    } 
+    return NULL;
+}
+
+//循环发送
+void Can_sendpoll(void* args)
+{  
+    GBT27930_t* dev = (GBT27930_t*)args;
+    can_j1939_t* canJ1939 = (can_j1939_t*)&dev->canJ1939;
+    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); //避免总线拥挤,
+                zw_sendOb[i].lastsend_time =  systime_ms();
+            }
+        }
+    }
+    pthread_mutex_unlock(&zw_mutex);
+}
+/**
+ * @brief 添加发送数据值
+ */
+void  can_APP_add(int pgn,struct can_frame* txframe)
+{
+    pthread_mutex_lock(&zw_mutex);
+    zw_send_t* p = find_empty(pgn,1);
+    if(p == NULL)
+    {
+
+        printccui("sends e  eddd %d\n",pgn);
+        assert(p);
+    }
+    if(p->pgn == 0)
+    {
+        p->pgn = pgn;
+        memcpy(&p->frame, txframe, sizeof(struct can_frame));
+        p->inteval_ms = Can_get_27930sendtime(pgn);
+        p->lastsend_time = 0 ;    
+    }else{
+         memcpy(&p->frame, txframe, sizeof(struct can_frame));
+    }
+
+    pthread_mutex_unlock(&zw_mutex);
+}
+
+/**
+ * @brief 清除发送数据
+ * @param pgn: 0时清除所有数据 
+ */
+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{
+        for(uint8_t i =0;i<10;i++)
+        {
+            zw_sendOb[i].pgn = 0;
+        } 
+    }
+   pthread_mutex_unlock(&zw_mutex);
+}
+
+//获取一个全局时间
+static void time_run()
+{
+    time_t now = time(NULL);
+    struct tm * ptm;
+    ptm = localtime(&now);
+    pthread_mutex_lock(&zw_mutex);
+    _27930_time[0] = DEC2BCD(ptm->tm_sec);
+    _27930_time[1] = DEC2BCD(ptm->tm_min);
+    _27930_time[2] = DEC2BCD(ptm->tm_hour);
+    _27930_time[3] = DEC2BCD(ptm->tm_mday);
+    _27930_time[4] = DEC2BCD(ptm->tm_mon);
+    _27930_time[5] = DEC2BCD(ptm->tm_year);
+    pthread_mutex_unlock(&zw_mutex);
+}
+
 static void* can_GBT27930_Txloop(void* args)
 {
     GBT27930_t* dev = (GBT27930_t*)args;
 	can_j1939_t* canJ1939 = (can_j1939_t*)&dev->canJ1939;
 	struct can_frame *frame = (struct can_frame *)&dev->frame;
+    
     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);
-                if (CAN_J939_PF(frame->can_id) == GBT_27930_2015_CML)
-                {
-                    time_t now = time(NULL);
-                    msleep(1);
-                    struct tm *ptm = localtime(&now);
-                    struct can_frame *frameCTS = (struct can_frame *)&dev->frameCTS;
-                    memset(frameCTS, 0, sizeof(struct can_frame));
-                    if(cst_cnt++ >0){
-                        frameCTS->can_id = CAN_EFF_FLAG|(6<<26)|(GBT_27930_2015_CTS<<16)|(dev->DA<<8)|dev->SA;
-                        frameCTS->data[0] = DEC2BCD(ptm->tm_sec);
-                        frameCTS->data[1] = DEC2BCD(ptm->tm_min);
-                        frameCTS->data[2] = DEC2BCD(ptm->tm_hour);
-                        frameCTS->data[3] = DEC2BCD(ptm->tm_mday);
-                        frameCTS->data[4] = DEC2BCD(ptm->tm_mon);
-                        frameCTS->data[5] = DEC2BCD(ptm->tm_year);
-                        frameCTS->data[6] = 0x20;
-                        frameCTS->can_dlc = 7;
-                        cst_cnt = 0 ;
-                        can_J1939_send(canJ1939, frameCTS);
-                    }
-                }
-                if (CAN_J939_PF(frame->can_id) == GBT_27930_2015_CRO && dev->cro.status == 0xAA)
-                {
-                    can_J1939_send(canJ1939, &dev->frameCCS);
-                }
             }
             pthread_mutex_unlock(&dev->mutex);
         }
@@ -308,10 +444,8 @@ static void* can_GBT27930_Rxloop(void* args)
 
         if (PF == GBT_27930_2015_BRO )
         {
-            if (dev->bro.status == 0xAA && dev->bro_last.status != 0xAA)
-            {
-                send(dev->fd[1], &PF, sizeof(PF), 0);
-            }
+            //if(dev->bro.status == 0xAA && dev->bro_last.status != 0xAA)
+            send(dev->fd[1], &PF, sizeof(PF), 0);
         }
 
         if (PF == GBT_27930_2015_BCL)
@@ -480,6 +614,7 @@ int can_GBT27930_send_CEM(GBT27930_t* dev, GBT27930_CEM_t *req)
         uint32_t *errn = (uint32_t*)req;
         txframe.can_id = (Priority<<26)|(GBT_27930_2015_CEM<<16)|(dev->DA<<8)|dev->SA;
         txframe.can_id |= CAN_EFF_FLAG;
+        printf("cem =%08x\n",*errn);
         txframe.data[0] = (errn[0]>>0)&0xFF;
         txframe.data[1] = (errn[0]>>8)&0xFF;
         txframe.data[2] = (errn[0]>>16)&0xFF;
@@ -487,11 +622,12 @@ int can_GBT27930_send_CEM(GBT27930_t* dev, GBT27930_CEM_t *req)
         txframe.can_dlc = 4;
         dev->stop = 0;
 
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CEM)/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_CEM)/10;
+        // dev->last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CEM,&txframe);
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))
@@ -595,6 +731,7 @@ 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_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;
@@ -696,11 +833,12 @@ int can_GBT27930_send_CTS(GBT27930_t* dev, struct tm *ptm)
         txframe.can_dlc = 7;
         dev->stop = 0;
 
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frameCTS, &txframe, sizeof(struct can_frame));
-        dev->CTS_tickcnt = Can_get_27930sendtime(GBT_27930_2015_CTS)/10;
-        dev->CTS_last_tickcnt = 0;
-        pthread_mutex_unlock(&dev->mutex);
+        // pthread_mutex_lock(&dev->mutex);
+        // memcpy(&dev->frameCTS, &txframe, sizeof(struct can_frame));
+        // dev->CTS_tickcnt = Can_get_27930sendtime(GBT_27930_2015_CTS)/10;
+        // dev->CTS_last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CTS,&txframe);
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe) == sizeof(struct can_frame))
@@ -741,12 +879,14 @@ int can_GBT27930_send_CML(GBT27930_t* dev, GBT27930_CML_t* info)
         txframe.data[7] = (chgMinOutputCurrent>>8)&0xFF;
         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_CML)/10;
-        dev->last_tickcnt = 0;
-        pthread_mutex_unlock(&dev->mutex);
+        memcpy(&dev->frameCTS, &txframe, sizeof(struct can_frame));
+        
+        // pthread_mutex_lock(&dev->mutex);
+        // dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CML)/10;
+        // dev->last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CML,&txframe);
+        dev->frame.can_id = 0;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe) == sizeof(struct can_frame))
@@ -825,12 +965,14 @@ int can_GBT27930_send_CRO(GBT27930_t* dev, uint8_t status)
             ccsframe.can_dlc = 8;
             memcpy(&dev->frameCCS, &ccsframe, sizeof(struct can_frame));
         }
-
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CRO)/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_CRO)/10;
+        // dev->last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CRO,&txframe);
+        dev->frame.can_id = 0;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))
@@ -928,10 +1070,12 @@ int can_GBT27930_send_CCS(GBT27930_t* dev, GBT27930_CCS_t* req)
         txframe.can_dlc = 8;
         dev->stop = 0;
 		
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        // memcpy(&dev->frameCCS, &txframe, sizeof(struct can_frame));
-        pthread_mutex_unlock(&dev->mutex);
+        // pthread_mutex_lock(&dev->mutex);
+        // memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
+        // // memcpy(&dev->frameCCS, &txframe, sizeof(struct can_frame));
+        // pthread_mutex_unlock(&dev->mutex);
+        can_APP_add(GBT_27930_2015_CCS,&txframe);
+        dev->frame.can_id = 0;
         return GBT_27930_2015_NORMAL;
 
         if (can_J1939_send(&dev->canJ1939, &txframe)==sizeof(struct can_frame))
@@ -1090,11 +1234,14 @@ int can_GBT27930_send_CST(GBT27930_t* dev, GBT27930_CST_t* req)
         txframe.can_dlc = 4;
         dev->stop = 0;
 		
-        pthread_mutex_lock(&dev->mutex);
-        memcpy(&dev->frame, &txframe, sizeof(struct can_frame));
-        dev->tickcnt = Can_get_27930sendtime(GBT_27930_2015_CST)/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_CST)/10;
+        // dev->last_tickcnt = 0;
+        // pthread_mutex_unlock(&dev->mutex);
+
+        can_APP_add(GBT_27930_2015_CST,&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

@@ -91,6 +91,41 @@
 
 #define GBT_27930_CURRENT_OFFSET    4000
 
+
+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;
+}_27930_recvFlag_t;
+uint16_t Can_get_27930Recvtime(uint8_t pgn_hex);
+
+//需求满足,
+#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;}\
+                                                    }\
+                                                }while(0)
+
+typedef struct
+{
+    uint32_t  GBT_27930_TIMEOUT_BRO_recv :1;
+    uint32_t  time_out:31;
+}timaaaaae_t;
+
+
+
+
 typedef struct GBT27930_SPN
 {
     uint32_t SPN:19;
@@ -424,4 +459,6 @@ int can_GBT27930_send_CSD(GBT27930_t* dev, GBT27930_CSD_t* req);
 void can_GBT27930_show_BST(GBT27930_t* can);
 void can_GBT27930_show_BEM(GBT27930_t* can);
 
+void can_APP_clear(int pgn);
+
 #endif//__GBT_27930_2015_H__

src/GBT2015/canJ1939.c

@@ -126,11 +126,10 @@ int	can_J1939_read(can_j1939_t* dev, struct can_frame *frame, int timeout)
 
 int	can_J1939_send(can_j1939_t* dev, struct can_frame *frame)
 {
-	if (dev && dev->fd > 0)
+	if ((dev && dev->fd > 0)&&(frame->can_id !=0))
 	{
 		// printTxCanFrame(dev->can_name, frame);
 		dev->txframe_ms = systime_ms();
-		printf("frame = %08x\n",frame->can_id);
 		int ret = write(dev->fd, frame, sizeof(struct can_frame));
 		if (ret == sizeof(struct can_frame))
 		{

src/GBT2015/can_SECC.c

@@ -1,7 +1,8 @@
 #include "secc_port.h"
 #include "GBT27930.h"
+int can_GBT27930_wait_n(GBT27930_t* dev,int pgn);
 
-
+static _27930_recvFlag_t _27930_recvFlag;
 static int can_GBT27930_send_stop(GBT27930_t* dev, int REASON)
 {
     ccu_port_t *ccu = (ccu_port_t*)dev->ccu;
@@ -36,13 +37,14 @@ static int can_GBT27930_send_timeout(GBT27930_t* dev, int 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_TIMEOUT_BRO:{dev->cem.bro_timeout=1;}break;
-        case GBT_27930_TIMEOUT_BCS:{dev->cem.bcs_timeout=1;}break;
-        case GBT_27930_TIMEOUT_BCL:{dev->cem.bcl_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;
         case GBT_27930_TIMEOUT_BST:{dev->cem.bst_timeout=1;}break;
         case GBT_27930_TIMEOUT_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);
 }
 
@@ -207,6 +209,17 @@ static int can_GBT27930_Insulation(GBT27930_t* dev)
     return 0;
 }
 
+#define SPILTE(X)               X  //单纯用于分割
+#define   WAIT_CONDI(XFlag,Xtime,Y1,Y2)     do{\
+                                            XFlag = systime_ms()+Xtime;\
+                                            while(1){\
+                                            if(XFlag < systime_ms()){Y1 \
+                                                break;}\
+                                            Y2\
+                                            usleep(5000);}\
+                                            XFlag = XFlag+1-systime_ms();\
+                                            }while(0)      
+
 static int can_GBT27930_PreCharge(GBT27930_t* dev)
 {
     int ret;
@@ -222,6 +235,7 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
         printccui("BRM_TIMEOUT\n");
         can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BRM);
         secc_set_error(secc, GUN_PRECHARGE_FAULT);
+        secc_set_state(secc, GUN_COMFALUT);
         return GBT_27930_2015_ERROR;
     }
     
@@ -233,6 +247,7 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
         printccui("BCP_TIMEOUT\n");
         can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BCP);
         secc_set_error(secc, GUN_PRECHARGE_FAULT);
+        secc_set_state(secc, GUN_COMFALUT);
         return GBT_27930_2015_ERROR;
     }
     
@@ -245,41 +260,61 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
         printd("SECC(%d) BMS Battery Voltage exceed the range of SECC\n", secc->config->connectorId);
         return GBT_27930_2015_ERROR;
     }
-    else
-    {
-        can_GBT27930_send_CTS(dev, NULL);
-    }
-    
     //----------通知车端启动绝缘检测---------
     dev->cml.chgMaxOutputVoltage = (uint16_t)(secc->SECC_maxV*10 + 0.5);
     dev->cml.chgMinOutputVoltage = (uint16_t)(secc->SECC_minV*10 + 0.5);
     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);
-    ret = can_GBT27930_wait(dev, GBT_27930_2015_BRO, BRO_0x00_TIMEOUT);
-    if (ret != GBT_27930_2015_BRO)
-    {
-        can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BRO);
-        secc_set_error(secc, GUN_PRECHARGE_FAULT);
-        printd("SECC(%d) BMS Insulation timeout or fault.\n", secc->config->connectorId);
-        return GBT_27930_2015_ERROR;
-    }
-
+    long int wait_time ;
+    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;
+    );
     //----------等待车端绝缘检测完成----------
     can_GBT27930_send_CML(dev, &dev->cml);
-    ret = can_GBT27930_wait(dev, GBT_27930_2015_BRO, BRO_0xAA_TIMEOUT);
-    if (ret != GBT_27930_2015_BRO)
-    {
-        can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BRO);
-        secc_set_error(secc, GUN_PRECHARGE_FAULT);
-        printd("SECC(%d) BMS Insulation timeout or fault.\n", secc->config->connectorId);
-        return GBT_27930_2015_ERROR;
-    }    
-
+    dev->bro.status = 0x00;//清零
+    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); 
+           if( dev->bro.status == 0xaa)
+           {
+            printf(",ambdnabdn");
+            break;
+           }
+    );
+    can_APP_clear(GBT_27930_2015_CML); ////GB2015-27930-tab.d1
+    can_APP_clear(GBT_27930_2015_CTS);
     //----------开始调整桩端电压----------
     can_GBT27930_send_CRO(dev, 0x00);
-    for(int i=0; i<60000; i+=200)
-    {
+   
+    long int bro_time = systime_ms();
+    
+    WAIT_CONDI(  
+        wait_time,60000,          
+        SPILTE(
+            secc_set_error(secc, GUN_PRECHARGE_FAULT);
+        ),
+     //   RECV_BMS(dev,GBT_27930_2015_BRO,bro_time);
+        RECV_BMS(dev,GBT_27930_2015_BRO,bro_time);
         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);
@@ -294,7 +329,7 @@ static int can_GBT27930_PreCharge(GBT27930_t* dev)
             secc_request_power(secc, POWER_REQUEST_CONST_VOLTAGE, VBattery, 0.0f);
         }
         msleep(200);
-    }
+    );
     secc_set_error(secc, GUN_PRECHARGE_FAULT);
     return GBT_27930_2015_ERROR;
 }
@@ -338,102 +373,116 @@ static int can_GBT27930_Charging(GBT27930_t* dev)
     printccui("step\n");
     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();
+    int start_sendCCS = 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);
-        switch(ret)
-        {
-            case GBT_27930_2015_BCL:
-            {
-                bcl_ms = systime_ms();
-                // if (dev->bcl.bmsChargeMode != dev->bcl_last.bmsChargeMode || dev->bcl.bmsVoltage_request != dev->bcl_last.bmsVoltage_request || dev->bcl.bmsCurrent_request != dev->bcl_last.bmsCurrent_request)
-                {
-                    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);
-                    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); }
-                }
-            }break;
-            case GBT_27930_2015_BCS:
-            {
-                bcs_ms = systime_ms();
-                secc->EV_Charging_current = ((float)dev->bcs.chargingCurrent) / 10;
-                secc->EV_Charging_voltage = ((float)dev->bcs.chargingVoltage) / 10;
-                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);
-                secc_report_MeterValues(secc);
-            }break;
-            case GBT_27930_2015_BSM:
+        //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;
+        }
+ 
+       if(_27930_recvFlag.GBT_27930_2015_BCL_recv==1){ 
+            _27930_recvFlag.GBT_27930_2015_BCL_recv = 0 ;
+            start_sendCCS |= 1; 
+            bcl_ms = systime_ms();
+            // if (dev->bcl.bmsChargeMode != dev->bcl_last.bmsChargeMode || dev->bcl.bmsVoltage_request != dev->bcl_last.bmsVoltage_request || dev->bcl.bmsCurrent_request != dev->bcl_last.bmsCurrent_request)
             {
-                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){
-                    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){
-                    secc_set_error(secc, CCU_BATTERY_FAULT);
-                    goto endhandl;  
-                }else if(dev->bsm.bmsPowerBatteryOverRsizder){
-                    secc_set_error(secc, CCU_BATTERY_FAULT);
-                    goto endhandl; 
-                }else if(dev->bsm.bmsPowerBatteryConnector){
-                    secc_set_error(secc, CCU_BATTERY_FAULT);
-                    goto endhandl; 
-                }
-                if (dev->bsm.bmsPowerPermitted == 0x0  && dev->bsm_last.bmsPowerPermitted == 1)
-                {   //暂停
-                    printi("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");
-                    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); }
-                }
-            }break;
-            case GBT_27930_2015_BRO: break;
-            default:{
-                printe("step, ret:%d\n", ret);
-                can_GBT27930_send_timeout(dev, GBT_27930_TIMEOUT_BCS);
-                secc_set_error(secc, GUN_CHARGING_FAULT);
-                return GBT_27930_2015_ERROR;
-            }break;
+                //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);
+                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); }
+            }
+        }
+
+        if(_27930_recvFlag.GBT_27930_2015_BCS_recv == 1){
+            _27930_recvFlag.GBT_27930_2015_BCS_recv = 0;
+            start_sendCCS |= 3; 
+            bcs_ms = systime_ms();
+            secc->EV_Charging_current = ((float)dev->bcs.chargingCurrent) / 10;
+            secc->EV_Charging_voltage = ((float)dev->bcs.chargingVoltage) / 10;
+            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);
+            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){
+                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){
+                secc_set_error(secc, CCU_BATTERY_FAULT);
+                goto endhandl;  
+            }else if(dev->bsm.bmsPowerBatteryOverRsizder){
+                secc_set_error(secc, CCU_BATTERY_FAULT);
+                goto endhandl; 
+            }else if(dev->bsm.bmsPowerBatteryConnector){
+                secc_set_error(secc, CCU_BATTERY_FAULT);
+                goto endhandl; 
+            }
+            if (dev->bsm.bmsPowerPermitted == 0x0  && dev->bsm_last.bmsPowerPermitted == 1)
+            {   //暂停
+                printi("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");
+                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;}
-        if ((now_ms - ccs_ms) > BCL_TIMEOUT)
-        {
-            // printi("SECC(%d) CCS VMeters:%f, IMeters:%f, EMeters:%f\n", secc->config->connectorId,secc->VMeters,secc->IMeters,secc->EMeters);
-            printccui("SECC(%d) CCS VMeters:%f, IMeters:%f, EMeters:%f\n", secc->config->connectorId,secc->VMeters,secc->IMeters,secc->EMeters);
+        // 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;}
+        // if ((now_ms - ccs_ms) > BCL_TIMEOUT)
+        // {
+        //     // printi("SECC(%d) CCS VMeters:%f, IMeters:%f, EMeters:%f\n", secc->config->connectorId,secc->VMeters,secc->IMeters,secc->EMeters);
+        //     printccui("SECC(%d) CCS VMeters:%f, IMeters:%f, EMeters:%f\n", secc->config->connectorId,secc->VMeters,secc->IMeters,secc->EMeters);
             memset(&dev->ccs, 0, sizeof(dev->ccs));
             dev->ccs.chgOutputting = 0x1;
             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);
-            can_GBT27930_send_CCS(dev, &dev->ccs);
+            if(start_sendCCS == 3)can_GBT27930_send_CCS(dev, &dev->ccs);
             ccs_ms = systime_ms();
-        }
+       // }
+        usleep(2000);
     }
  endhandl:   
-    printi("step\n");
+    printccui("step\n");
     secc_set_state(secc, GUN_STOPPING);
     return GBT_27930_2015_NORMAL;
 }
+/**
+ * @brief  通讯超时处理流程
+ * @related GB2015-27930 A11
+ */
+static int can_GBT27930_ReComm(GBT27930_t* dev)
+{
+    secc_port_t* secc = (secc_port_t*)dev->secc;
+    secc_set_state(secc, GUN_STOPPING);
+    printccui("step\n");
+}
 
 static int can_GBT27930_Finishing(GBT27930_t* dev)
 {
@@ -443,7 +492,16 @@ 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; 
+    WAIT_CONDI(
+        wait_time,5000,
+        ,
+        if(can_GBT27930_wait_n(dev,GBT_27930_2015_BST)==GBT_27930_2015_BST)
+        break;
+    ); 
     secc_request_power(secc, POWER_REQUEST_PLACE_FREE, 0, 0);
     secc_stop_Transaction(secc);
     {
@@ -454,7 +512,7 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
         can_GBT27930_wait(dev, GBT_27930_2015_BSD, 1000);
     }
 
-    printd("step\n");
+    printccui("step\n");
 
     if (secc->GUN_Error == 0)
     {
@@ -478,7 +536,10 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
     }
     
     printd("step\n");
+    
+    msleep(100);    //临时措施，保证CEM发送
 
+    can_APP_clear(0);
     secc->set_Aux12V_state(secc, 0);
 
     printd("step\n");
@@ -515,6 +576,8 @@ static int can_GBT27930_Finishing(GBT27930_t* dev)
     return GBT_27930_2015_NORMAL;
 }
 
+
+
 /******************************************************************************/
 
 void* can_GBT27930_loop(void* argv)
@@ -539,6 +602,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_COMFALUT:      {   }break;
             default:                { }break;
         }
         if (secc->GUN_Error) { printi("secc->GUN_Error:%08x, %ld\n", secc->GUN_Error, secc->GUN_Error);break;}

src/ccu_define.h

@@ -54,6 +54,7 @@ typedef enum gun_state
     GUN_CHARGING,           // 充电中
     GUN_SUSPEND,            // 充电挂起状态（暂停充电）
     GUN_STOPPING,           // 充电已完成，未拔枪
+    GUN_COMFALUT,           // 通讯超时
     GUN_UNKNOW,             // 其他未知状态
 
     GUN_SLACOK = GUN_ELOCKED,// PLC准备好

src/secc_port.c

@@ -155,7 +155,7 @@ 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->manul_stop) return 1;
+    if (secc->manul_stop)return 1;
 
     if (secc->request_KWh > 0.0f)
     {