Merge branch '单步测试' into GPS测试

# Conflicts:
#	inc/hal_module_adapter.h
#	src/app.c
GPS和网络上传合并

inc/hal_module_adapter.h

@@ -8,8 +8,6 @@ extern "C" {
 #include "sensor.h"
 #include "can.h"
 
-//#define USING_PRINTF    								 (1)
-
 #define GPS_DATA_RECV_BUFFER_SIZE     						(1024)
 
 #define I2C_INT1_REQ_BITMAP    								 (0x1)

src/app.c

@@ -26,12 +26,13 @@
 #define PROC_MAIN_TASK_STACK_SIZE           (1024)
 #define PROC_UART_TASK_STACK_SIZE           (1024)
 #define PROC_CAN_TASK_STACK_SIZE           (1024)
-
+#define PROC_TCP_TASK_STACK_SIZE           (1024)
+#define APP_EVENT_QUEUE_SIZE    (10)
 uint8_t deepslpTimerID          = DEEPSLP_TIMER_ID7;
 uint8_t MainSlpHandler          = 0xff;
 uint8_t UartSlpHandler          = 0xfe;
 uint8_t CanSlpHandler          = 0xfd;
-
+uint8_t TcpSlpHandler          = 0xfd;
 
 #define Uart_Send_LEN         (8)
 #define Uart_Rece_LEN         (40)
@@ -42,6 +43,14 @@ static ARM_DRIVER_USART *USARTdrv = &Driver_USART1;
 volatile bool isRecvTimeout = false;
 volatile bool isRecvComplete = false;
 QueueHandle_t gpsMsgQueue = NULL;
+static volatile UINT32          Event;
+static QueueHandle_t            psEventQueueHandle;
+static UINT8                    gImsi[16] = {0};
+static INT32                    sockfd = -1;
+static UINT32                   gCellID = 0;
+int TcpconnectID = -1;
+volatile bool tcp_ready = false;
+
 uint8_t Batt_Cell_Num = 14;//默认数值14、17
 uint8_t Batt_Cell_Num_2 ;//默认数值
 uint8_t Batt_Temp_Num = 5;//默认数值5、7
@@ -93,6 +102,15 @@ typedef enum
 static process_CAN 		    gProcess_Can_Task = PROCESS_CAN_STATE_IDLE;
 #define PROC_CAN_STATE_SWITCH(a)  (gProcess_Can_Task = a)
 
+typedef enum
+{
+    PROCESS_TCP_STATE_IDLE = 0,
+    PROCESS_TCP_STATE_LINK,
+    PROCESS_TCP_STATE_WORK,
+    PROCESS_TCP_STATE_SLEEP
+}process_TCP;
+static process_TCP 		    gProcess_Tcp_Task = PROCESS_TCP_STATE_IDLE;
+#define PROC_TCP_STATE_SWITCH(a)  (gProcess_Tcp_Task = a)
 //堆栈申请
 static StaticTask_t             gProcess_Main_Task_t;
 static UINT8                  gProcess_Main_TaskStack[PROC_UART_TASK_STACK_SIZE];
@@ -100,7 +118,8 @@ static StaticTask_t             gProcess_Uart_Task_t;
 static UINT8                  gProcess_Uart_TaskStack[PROC_UART_TASK_STACK_SIZE];
 static StaticTask_t             gProcess_Can_Task_t;
 static UINT8                  gProcess_Can_TaskStack[PROC_CAN_TASK_STACK_SIZE];
-
+static StaticTask_t             gProcess_Tcp_Task_t;
+static UINT8                  gProcess_Tcp_TaskStack[PROC_TCP_TASK_STACK_SIZE];
 //睡眠进出函数
 static void appBeforeHib(void *pdata, slpManLpState state)
 {
@@ -120,7 +139,6 @@ static void appAfterHib(void *pdata, slpManLpState state)
     #endif
 }
 
-
 static void appBeforeSlp1(void *pdata, slpManLpState state)
 {
     #ifdef USING_PRINTF
@@ -156,9 +174,10 @@ static void Main_Task(void* arg)
 {
     UINT16 Can_index = 0;
     UINT16 Uart_index = 0;
-    UINT16 NB_index  = 0;
+    UINT16 Tcp_index  = 0;
     uint32_t sleep_index = 0;
     int32_t inParam = 0xAABBCCDD;
+    slpManWakeSrc_e Wakeup_source;
     PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
     NetSocDisplay(LED_SOC_0,LED_TURN_OFF);
     NetSocDisplay(LED_SOC_1,LED_TURN_OFF);
@@ -184,14 +203,19 @@ static void Main_Task(void* arg)
     #ifdef USING_PRINTF
             printf("slpstate:%d \n",slpstate);
     #endif
+    Wakeup_source =  slpManGetWakeupSrc();//获取唤醒源
+    #ifdef USING_PRINTF
+            printf("Wakeup_source:%d \n",Wakeup_source);
+    #endif
     if((slpstate == SLP_SLP2_STATE) || (slpstate == SLP_HIB_STATE))
     {
-        PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
+        PROC_MAIN_STATE_SWITCH(PROCESS_STATE_WORK);
     }
     else
     {
         PROC_MAIN_STATE_SWITCH(PROCESS_STATE_WORK);
     }
+
     //线程初始化完成
     while (true)
     {
@@ -209,7 +233,7 @@ static void Main_Task(void* arg)
                 osDelay(10/portTICK_PERIOD_MS);
                 Can_index++;
                 Uart_index++;
-                NB_index++;
+                Tcp_index++;
                 if (Uart_index >100)//Uart 1s 调用一次
                 {
                     PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_WORK);
@@ -220,11 +244,12 @@ static void Main_Task(void* arg)
                     PROC_CAN_STATE_SWITCH(PROCESS_CAN_STATE_RECV);
                     Can_index = 0;
                 }
-                if (NB_index >=100)//NB 1s 调用一次
+                if (Tcp_index >=100)//Tcp 1s 调用一次
                 {
-                    NB_index = 0;
+                    PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_LINK);
+                    Tcp_index = 0;
                 }
-                if(!Can_Enable)
+                if((!Can_Enable)&&(Uart_Rece_BattI==0x0000))
                 {
                     sleep_index++;
                 }
@@ -241,13 +266,16 @@ static void Main_Task(void* arg)
             }
             case PROCESS_STATE_SLEEP:
             {
-                Sleep_Flag = true;
-                while((gProcess_Uart_Task!=PROCESS_UART_STATE_SLEEP)||(gProcess_Can_Task!=PROCESS_CAN_STATE_SLEEP))
+                while((gProcess_Uart_Task!=PROCESS_UART_STATE_SLEEP)||(gProcess_Can_Task!=PROCESS_CAN_STATE_SLEEP)||(gProcess_Tcp_Task!=PROCESS_TCP_STATE_SLEEP))
                 {
                     PROC_UART_STATE_SWITCH(PROCESS_UART_STATE_SLEEP);
                     PROC_CAN_STATE_SWITCH(PROCESS_CAN_STATE_SLEEP);
+                    PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_SLEEP);
                 }
                 osDelay(1000);
+                #ifdef USING_PRINTF
+                            printf("Ms_sleep:uart_%d,can_%d,tcp_%d\r\n",gProcess_Uart_Task,gProcess_Can_Task,gProcess_Tcp_Task);
+                #endif
                 slpManSlpState_t State;
                 uint8_t cnt;
                 if(slpManCheckVoteState(MainSlpHandler, &State, &cnt)==RET_TRUE)
@@ -256,7 +284,7 @@ static void Main_Task(void* arg)
                         printf("[%d]We Can Check Vote Main State, state=%d, cnt=%d\r\n",__LINE__,State,cnt);
                     #endif						
                 }
-                slpManPlatVoteEnableSleep(MainSlpHandler, SLP_SLP2_STATE); 
+                slpManPlatVoteForceEnableSleep(MainSlpHandler, SLP_SLP2_STATE); //增加强制投票
                 if(slpManCheckVoteState(MainSlpHandler, &State, &cnt)==RET_TRUE)
                 {
                     #ifdef USING_PRINTF
@@ -274,11 +302,17 @@ static void Main_Task(void* arg)
                 #ifdef USING_PRINTF
                     printf("Main_Sleep\n");
                 #endif
-                slpManDeepSlpTimerStart(deepslpTimerID,60000); 
+                FaultDisplay(LED_TURN_ON);
+                slpManDeepSlpTimerStart(deepslpTimerID,600000); 
+                slpManSlpState_t slpstate = slpManPlatGetSlpState();
+                #ifdef USING_PRINTF
+                    printf("which slpstate can go now :%d \n",slpstate);
+                #endif
                 while(1)
                 {
-                    osDelay(5000/portTICK_PERIOD_MS);
+                    osDelay(60000/portTICK_PERIOD_MS);
                 }
+                break;
             }
         }
 
@@ -364,21 +398,22 @@ uint8_t* Uart_Receive_func(Uart_Receive_Type Uart_Receive_Msg,uint8_t* Uart_Rece
         isRecvComplete = false;
         CRC_Rece_buffer =*(Uart_Rece_buffer+Data_Len-1)<<8|*(Uart_Rece_buffer+Data_Len-2);
         CRC_chk_buffer = crc_chk(Uart_Rece_buffer,Data_Len-2);
-        // #ifdef USING_PRINTF
-        //     printf("Uart_Rece_buffer: ");
-        //     for(int i=0;i<Data_Len;i++)
-        //     {
-        //     printf("%x ",*(Uart_Rece_buffer+i));
-        //     }
-        //     printf("crcchk:%x,%x\n ",CRC_chk_buffer,CRC_Rece_buffer);
-        // #endif
         if (CRC_Rece_buffer == CRC_chk_buffer)//满足校验
         {
             return Uart_Rece_buffer;//此处指针移位出现重启问题
         }
         else //接收数据的校验不过屏蔽
         {
-            memset(Uart_Rece_buffer,0xff,Data_Len);
+            osDelay(2000);
+        #ifdef USING_PRINTF
+            printf("Uart_Rece_buffer: ");
+            for(int i=0;i<Data_Len;i++)
+            {
+            printf("%x ",*(Uart_Rece_buffer+i));
+            }
+            printf("crcchk:%x,%x\n ",CRC_chk_buffer,CRC_Rece_buffer);
+        #endif
+            memset(Uart_Rece_buffer,0x00,Data_Len);
             return Uart_Rece_buffer;
         }
     }
@@ -452,8 +487,9 @@ static void Uart_Task(void* arg)
             case PROCESS_UART_STATE_WORK:
             {
                 #ifdef USING_PRINTF
-                        printf("Uart work!\n");
+                        printf("UART_STATE_WORK!\n");
                 #endif
+                NetSocDisplay(LED_SOC_1,LED_TURN_ON);
                 Uart_task = false;
                 Uart_Rece_buffer = (uint8_t *)malloc(Uart_Rece_LEN);
                 while(!Uart_task)
@@ -569,15 +605,19 @@ static void Uart_Task(void* arg)
             case PROCESS_UART_STATE_SLEEP:
             {
                 slpManPlatVoteEnableSleep(UartSlpHandler, SLP_SLP2_STATE);
-                while(true)
+                #ifdef USING_PRINTF
+                    printf("UART_STATE_SLEEP\n");
+                #endif
+                while(1)
                 {
-                    osDelay(5000/portTICK_PERIOD_MS);
+                    osDelay(60000/portTICK_PERIOD_MS);
                 }
             }
         }
     }
 
 }
+//Can-线程任务
 static void Can_Task(void* arg)
 {
     uint32_t Can_ID;
@@ -657,12 +697,12 @@ static void Can_Task(void* arg)
             }
             case PROCESS_CAN_STATE_SEND:
             {
+                #ifdef USING_PRINTF
+                        printf("CAN_STATE_SEND!\n");
+                #endif
                 Can_Flag=false;
                 while(!Can_Flag)
                 {
-                    #ifdef USING_PRINTF
-                        printf("Can_Send!\n");
-                    #endif
                     switch(send_index)
                     {
                         case 0:
@@ -822,10 +862,321 @@ static void Can_Task(void* arg)
                 }
                 while(true)
                 {
-                    osDelay(5000/portTICK_PERIOD_MS);
+                    osDelay(60000/portTICK_PERIOD_MS);
+                }
+            }
+        }
+    }
+}
+static void sendQueueMsg(UINT32 msgId, UINT32 xTickstoWait)
+{
+    eventCallbackMessage_t *queueMsg = NULL;
+    queueMsg = malloc(sizeof(eventCallbackMessage_t));
+    queueMsg->messageId = msgId;
+    if (psEventQueueHandle)
+    {
+        if (pdTRUE != xQueueSend(psEventQueueHandle, &queueMsg, xTickstoWait))
+        {
+            ECOMM_TRACE(UNILOG_PLA_APP, sendQueueMsg_1, P_ERROR, 0, "xQueueSend error");
+        }
+    }
+}
+static INT32 socketRegisterPSUrcCallback(urcID_t eventID, void *param, UINT32 paramLen)
+{
+    CmiSimImsiStr *imsi = NULL;
+    CmiPsCeregInd *cereg = NULL;
+
+    UINT8 rssi = 0, index = 0;
+    NmAtiNetifInfo *netif = NULL;
+
+    switch(eventID)
+    {
+        case NB_URC_ID_SIM_READY:
+        {
+            imsi = (CmiSimImsiStr *)param;
+            memcpy(gImsi, imsi->contents, imsi->length);
+            #ifdef USING_PRINTF
+                printf("SIM ready(imsi=%s)\n",(UINT8 *)imsi->contents);
+            #endif
+            break;
+        }
+        case NB_URC_ID_MM_SIGQ:
+        {
+            rssi = *(UINT8 *)param;
+            #ifdef USING_PRINTF
+                printf("RSSI signal=%d\n",rssi);
+            #endif
+            ECOMM_TRACE(UNILOG_PLA_APP, socketRegisterPSUrcCallback_1, P_INFO, 1, "RSSI signal=%d", rssi);
+            break;
+        }
+        case NB_URC_ID_PS_BEARER_ACTED:
+        {
+            #ifdef USING_PRINTF
+                printf("Default bearer activated\n");
+            #endif
+            break;
+        }
+        case NB_URC_ID_PS_BEARER_DEACTED:
+        {
+            #ifdef USING_PRINTF
+                printf("Default bearer Deactivated\n");
+            #endif
+            break;
+        }
+        case NB_URC_ID_PS_CEREG_CHANGED:
+        {
+            cereg = (CmiPsCeregInd *)param;
+            gCellID = cereg->celId;
+            #ifdef USING_PRINTF
+                printf("URCCallBack:CEREG changed act:%d celId:%d locPresent:%d tac:%d\n", cereg->act, cereg->celId, cereg->locPresent, cereg->tac);
+            #endif
+            break;
+        }
+        case NB_URC_ID_PS_NETINFO:
+        {
+            netif = (NmAtiNetifInfo *)param;
+            if (netif->netStatus == NM_NETIF_ACTIVATED)
+                sendQueueMsg(QMSG_ID_NW_IP_READY, 0);
+                tcp_ready = true;
+            break;
+        }
+    }
+    return 0;
+}
+uint8_t bcc_chk(uint8_t* data, uint8_t length)//发送bcc校验函数
+{
+    uint8_t bcc_chk_return = 0x00;
+    uint8_t count = 0;
+    while (count<length)
+    {
+        bcc_chk_return^=data[count];
+        count++;
+    }
+    return  bcc_chk_return;
+}
+//电池数据组装函数
+void Tcp_Batt_Data_Assemble(void)
+{
+    int16_t Batt_current;
+    uint16_t BattU = 0x00;
+    uint8_t csq=0;
+    int8_t snr=0;
+    int8_t rsnr=0;
+    Batt_current = Uart_Rece_BattI;
+    OsaUtcTimeTValue timestracture;
+    appGetSystemTimeUtcSync(&timestracture);
+    battbuffer[0] = timestracture.UTCtimer1>>16;
+    battbuffer[0] = battbuffer[0] - 0x07D0;
+    battbuffer[1] = timestracture.UTCtimer1>>8;
+    battbuffer[2] = timestracture.UTCtimer1;
+    battbuffer[3] = timestracture.UTCtimer2>>24;
+    battbuffer[4] = timestracture.UTCtimer2>>16;
+    battbuffer[5] = timestracture.UTCtimer2>>8;
+    battbuffer[6] = 0x80;//信息体标志，此处为电池信息
+    battbuffer[7] = battbuffer[0];//年 
+    battbuffer[8] = battbuffer[1];//月
+    battbuffer[9] = battbuffer[2];//日
+    battbuffer[10] = battbuffer[3];//时 0时区时间
+    battbuffer[11] = battbuffer[4];//分
+    battbuffer[12] = battbuffer[5];//秒
+    appGetSignalInfoSync(&csq,&snr,&rsnr);//获取信号质量
+    battbuffer[13] = csq;// 网络信号
+    battbuffer[14] = 0x00;//故障等级
+    battbuffer[15] = 0x00;//故障代码高
+    battbuffer[16] = 0x00;//故障代码低
+    //电流适应性更改，从int转换到uint，加10000的偏移量，100mA的单位
+    if (Batt_current>0x8000)
+    {
+        Batt_current = Batt_current|0x7fff;
+        Batt_current = 0x2710 - Batt_current;
+        Batt_current = Batt_current;
+    }
+    else
+    {
+        Batt_current = Batt_current+0x2710;
+        Batt_current = Batt_current;
+    }
+    battbuffer[17] = Batt_current>>8;
+    battbuffer[18] = Batt_current;
+    BattU = battbuffer[19]<<8|battbuffer[20];
+    BattU  = BattU/10;
+    battbuffer[19] = BattU>>8;
+    battbuffer[20] = BattU;
+    battbuffer[21] = BattU>>8;
+    battbuffer[22] = BattU;//外电压
+    data_index = 32+Batt_Cell_Num_2+Batt_Temp_Num;
+    battbuffer[data_index] = 0x00;//电池状态
+    data_index++;
+    battbuffer[data_index] = 0x00;//是否加热
+    data_index++;
+}
+//Tcp线程
+static void Tcp_Task(void* arg)
+{
+    CHAR SN[] = "GYTEST00000000003";//SN应写到osfile里面
+    CHAR   serverip[] = "47.97.127.222";
+    CHAR  serverport[] = "8712";
+    struct addrinfo hints, *server_res;
+    int TcpsendID = -1;
+    memset( &hints, 0, sizeof( hints ) );
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+    psEventQueueHandle = xQueueCreate(APP_EVENT_QUEUE_SIZE, sizeof(eventCallbackMessage_t*));
+    int NB_send_len=59+Batt_Cell_Num_2+Batt_Temp_Num;//设定tcp发送的最大数值，以电池数据为上线
+    slpManApplyPlatVoteHandle("TcpSlp",&TcpSlpHandler);
+    slpManPlatVoteDisableSleep(TcpSlpHandler, SLP_SLP2_STATE);
+    PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_IDLE);
+    uint8_t Tcp_Index = 0;
+    uint8_t* TcpSendBuffer=NULL;
+    volatile bool Tcp_Flag=false;
+    eventCallbackMessage_t *queueItem = NULL;
+    uint8_t pmode;
+    uint32_t tau;
+    uint32_t act;
+    appSetEDRXSettingSync(0,5,0);
+    appSetPSMSettingSync(1,3*60*60,10);
+    appGetPSMSettingSync(&pmode,&tau,&act);
+    #ifdef USING_PRINTF
+        printf("psm:pmode-%d,tau-%d,act-%d!\n",pmode,tau,act);
+    #endif
+    while(true)
+    {
+        switch(gProcess_Tcp_Task)
+        {
+            case PROCESS_TCP_STATE_IDLE:
+            {
+                osDelay(1000);
+                break;
+            }
+            case PROCESS_TCP_STATE_LINK:
+            {
+                if(!tcp_ready)
+                {
+                    #ifdef USING_PRINTF
+                        printf("tcp not ready!\n");
+                    #endif
+                    PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_IDLE);
+                }
+                else 
+                {
+                    if(TcpconnectID<0)
+                    {
+                        #ifdef USING_PRINTF
+                            printf("Connecting...!%d\n",TcpconnectID);
+                        #endif
+                        if (getaddrinfo( serverip, serverport , &hints, &server_res ) != 0 )
+                        {
+                            #ifdef USING_PRINTF
+                                printf("TCP connect unresolved dns\n");
+                            #endif
+                        }
+                        sockfd = socket(AF_INET, SOCK_STREAM, 0);
+                        TcpconnectID = connect(sockfd, (struct sockaddr *) server_res->ai_addr, server_res->ai_addrlen);
+                        if(TcpconnectID<0)
+                        {
+                            #ifdef USING_PRINTF
+                                printf("Connect failed!%d\n",TcpconnectID);
+                            #endif
+                            close(sockfd);
+                            PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_IDLE);
+                            break;
+                        }
+                        else
+                        {
+                            PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_WORK);
+                            break;
+                        }
+                    }
+                    else 
+                    {
+                        PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_WORK);
+                    }
                 }
                 break;
             }
+            case PROCESS_TCP_STATE_WORK:
+            {
+                #ifdef USING_PRINTF
+                        printf("TCP_STATE_WORK!\n");
+                #endif
+                #ifdef USING_PRINTF
+                    printf("psm:pmode-%d,tau-%d,act-%d!\n",pmode,tau,act);
+                #endif
+                Tcp_Flag = false;
+                TcpSendBuffer = (uint8_t *)malloc(NB_send_len);
+                while (!Tcp_Flag)
+                {
+                    switch(Tcp_Index)
+                    {
+                        case 0://发送登录信息
+                        {
+                            Tcp_Index=1;
+                            break;
+                        }
+                        case 1://发送电池数据
+                        {
+                            memset(TcpSendBuffer,0x00,NB_send_len);
+                            *(TcpSendBuffer+0) = 0x23;
+                            *(TcpSendBuffer+1) = 0x23;
+                            *(TcpSendBuffer+2) = 0x02;
+                            *(TcpSendBuffer+3) = 0xfe;
+                            memcpy(TcpSendBuffer+4,SN,17);
+                            *(TcpSendBuffer+21) = 0x01;//01表示不加密
+                            Tcp_Batt_Data_Assemble();//数据组装函数
+                            *(TcpSendBuffer+22) = data_index>>8;//数据长度
+                            *(TcpSendBuffer+23) = data_index;//数据长度
+                            memcpy(TcpSendBuffer+24,battbuffer,data_index);
+                            *(TcpSendBuffer+NB_send_len-1) = bcc_chk(TcpSendBuffer,NB_send_len-1);
+                            #ifdef USING_PRINTF
+                                printf("battbuffer:");
+                                for (int i = 0; i < data_index; i++)
+                                {
+                                    printf("%x ",battbuffer[i]);
+                                }
+                                printf("\n");
+                            #endif
+                            TcpsendID = send(sockfd, TcpSendBuffer, NB_send_len, 0 );
+                            //发送失败暂时不写
+                            #ifdef USING_PRINTF
+                                printf("ConnectID:%d,TcpSend:%d,data length:%d,Data:  ",sockfd,TcpsendID,NB_send_len);
+                                for (int i = 0; i < NB_send_len; i++)
+                                {
+                                    printf("%x ",*(TcpSendBuffer+i));
+                                }
+                                printf("\n");
+                            #endif
+                            Tcp_Index=2;
+                            break;
+                        }
+                        case 2:
+                        {
+                            Tcp_Index=3;
+                            break;
+                        }
+                        default:
+                        {
+                            PROC_TCP_STATE_SWITCH(PROCESS_TCP_STATE_IDLE);
+                            Tcp_Index = 0;
+                            Tcp_Flag = true;
+                        }
+                    } 
+                }
+                free(TcpSendBuffer);
+                break;
+            }
+            case PROCESS_TCP_STATE_SLEEP:
+            {
+                slpManPlatVoteEnableSleep(TcpSlpHandler, SLP_SLP2_STATE); 
+                closesocket(sockfd);
+                deregisterPSEventCallback(socketRegisterPSUrcCallback);//注销NB网络事件函数
+                #ifdef USING_PRINTF
+                    printf("TCP_STATE_SLEEP\n");
+                #endif
+                while(1)
+                {
+                    osDelay(30000/portTICK_PERIOD_MS);
+                }
+            }
         }
     }
 }
@@ -873,7 +1224,7 @@ void Can_Task_Init()
     osThreadAttr_t task_attr;
     memset(&task_attr,0,sizeof(task_attr));
     memset(gProcess_Can_TaskStack, 0xA5, PROC_CAN_TASK_STACK_SIZE);
-    task_attr.name = "Uart_Task";
+    task_attr.name = "Can_Task";
     task_attr.stack_mem = gProcess_Can_TaskStack;
     task_attr.stack_size = PROC_CAN_TASK_STACK_SIZE;
     task_attr.priority = osPriorityNormal;
@@ -882,13 +1233,31 @@ void Can_Task_Init()
 
     osThreadNew(Can_Task, NULL, &task_attr);
 
+}
+//Tcp线程初始化
+void Tcp_Task_Init()
+{
+    osThreadAttr_t task_attr;
+    registerPSEventCallback(NB_GROUP_ALL_MASK, socketRegisterPSUrcCallback);
+    memset(&task_attr,0,sizeof(task_attr));
+    memset(gProcess_Tcp_TaskStack, 0xA5, PROC_TCP_TASK_STACK_SIZE);
+    task_attr.name = "Tcp_Task";
+    task_attr.stack_mem = gProcess_Tcp_TaskStack;
+    task_attr.stack_size = PROC_TCP_TASK_STACK_SIZE;
+    task_attr.priority = osPriorityNormal;
+    task_attr.cb_mem = &gProcess_Tcp_Task_t;
+    task_attr.cb_size = sizeof(StaticTask_t);
+
+    osThreadNew(Tcp_Task, NULL, &task_attr);
+
 }
 void appInit(void *arg)
 {
     Main_Task_Init();
-    //Uart_Task_Init(); 暂时屏蔽Uart读取
+    Uart_Task_Init(); 暂时屏蔽Uart读取
     Can_Task_Init();
     GpsTaskInit();
+    Tcp_Task_Init();
 }
 //主函数入口
 void main_entry(void) {

src/bsp_custom.c

@@ -139,7 +139,7 @@ void BSP_CustomInit(void)
     BSP_LoadPlatConfigFromRawFlash();
     rawFlashPlatConfig = BSP_GetRawFlashPlatConfig();
 #ifdef USING_PRINTF
-	SetPrintUart(PORT_USART_1);
+	SetPrintUart(PORT_USART_0);
 #else
     if(rawFlashPlatConfig && (rawFlashPlatConfig->logControl != 0 ))
     {