[新增]1.改动其他文件和蓝精灵一致，增加GPS函数。2.增加休眠前函数和休眠后函数。3.休眠while中取消delay

【问题】1.不写delay不休眠，2.GPS无信息

inc/hal_module_adapter.h

@@ -8,6 +8,10 @@ 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)
 #define I2C_INT2_REQ_BITMAP    								 (0x2)
 
@@ -55,6 +59,13 @@ typedef struct
     UINT32 param[5];
 }adcReqMsg;
 
+typedef struct
+{
+    void * dataPtr;
+    UINT32 len;
+}gpsReqMsg;
+
+
 typedef struct
 {
     UINT32 event;

src/app.c

@@ -50,10 +50,10 @@ volatile bool isRecvTimeout = false;
 /** \brief receive complete flag */
 volatile bool isRecvComplete = false;
 
-uint8_t process0SlpHandler     = 0xff;
-uint8_t process1SlpHandler     = 0xff;
-uint8_t process2SlpHandler     = 0xff;
-uint8_t process3SlpHandler     = 0xff;
+uint8_t process0SlpHandler     = 0x00;
+uint8_t process1SlpHandler     = 0x01;
+uint8_t process2SlpHandler     = 0x02;
+uint8_t process3SlpHandler     = 0x03;
 uint8_t deepslpTimerID          = 7;
 uint8_t Can_Rece_buffer[8];
 uint8_t Batt_Cell_Num = 14;//默认数值14、17
@@ -111,6 +111,63 @@ process_NB	    gProc3State = PROCESS_NB_STATE_IDLE;
 #define PROC_Can_STATE_SWITCH(a)  (gProc2State = a) //can 状态切换
 #define PROC_NB_STATE_SWITCH(a)  (gProc3State = a) //NB状态切换
 //-------------------------------------------------------------------------------------------------------------------------------------------------------
+static void appBeforeHib(void *pdata, slpManLpState state)
+{
+    uint32_t *p_param = (uint32_t *)pdata;
+
+    #ifdef USING_PRINTF
+        printf("Before Hibernate:%d \n",state);
+    #endif
+    ECOMM_TRACE(UNILOG_PLA_APP, appBeforeHib_1, P_SIG, 1, "Before Hibernate = %x",*p_param);
+	slpManAONIOLatchEn(AonIOLatch_Enable);
+
+}
+
+static void appAfterHib(void *pdata, slpManLpState state)
+{
+    #ifdef USING_PRINTF
+        printf("Try Hibernate Failed:%d \n",state);
+    #endif
+    ECOMM_TRACE(UNILOG_PLA_APP, appAfterHib_1, P_SIG, 0, "Try Hibernate Failed, Interrupt Pending. Only sleep failed this function will excute");
+}
+
+
+static void appBeforeSlp1(void *pdata, slpManLpState state)
+{
+    #ifdef USING_PRINTF
+        printf("Before Sleep1:%d \n",state);
+    #endif
+    ECOMM_TRACE(UNILOG_PLA_APP, appBeforeSlp1_1, P_SIG, 0, "Before Sleep1");
+	slpManAONIOLatchEn(AonIOLatch_Enable);
+}
+
+static void appAfterSlp1(void *pdata, slpManLpState state)
+{
+    #ifdef USING_PRINTF
+        printf("After Sleep1:%d \n",state);
+    #endif
+    PROC_Task_STATE_SWITCH(PROCESS_STATE_SLEEP);
+    ECOMM_TRACE(UNILOG_PLA_APP, appAfterSlp1_1, P_SIG, 0, "After Sleep1, no matter sleep success or not this function will excute");
+}
+
+
+static void appBeforeSlp2(void *pdata, slpManLpState state)
+{
+    #ifdef USING_PRINTF
+        printf("before sleep2:%d \n",state);
+    #endif
+    ECOMM_TRACE(UNILOG_PLA_APP, appBeforeSlp2_1, P_SIG, 0, "Before Sleep2");
+	slpManAONIOLatchEn(AonIOLatch_Enable);
+}
+
+static void appAfterSlp2(void *pdata, slpManLpState state)
+{
+    #ifdef USING_PRINTF
+        printf("sleep2 failed:%d \n",state);
+    #endif
+    ECOMM_TRACE(UNILOG_PLA_APP, appAfterSlp2_1, P_SIG, 0, "Sleep2 Failed, Interrupt Pending. Only sleep failed this function will excute");
+}
+
 unsigned int crc_chk(uint8_t* data, uint8_t length)
 {  
     int j;
@@ -218,6 +275,7 @@ static void process0AppTask(void* arg)//任务调度程序
     UINT16 Uart_index = 0;
     UINT16 NB_index  = 0;
     uint32_t sleep_index = 0;
+    int32_t inParam = 0xAABBCCDD;
     PROC_Task_STATE_SWITCH(PROCESS_STATE_IDLE);
     NetSocDisplay(LED_SOC_0,LED_TURN_OFF);
     NetSocDisplay(LED_SOC_1,LED_TURN_OFF);
@@ -226,8 +284,18 @@ static void process0AppTask(void* arg)//任务调度程序
     FaultDisplay(LED_TURN_OFF);
     NVIC_EnableIRQ(PadWakeup1_IRQn);
     slpManSetPmuSleepMode(true,SLP_HIB_STATE,false);
-    slpManApplyPlatVoteHandle("process0slp",&process0SlpHandler);
+    slpManApplyPlatVoteHandle("pro0",&process0SlpHandler);
     slpManPlatVoteDisableSleep(process0SlpHandler, SLP_SLP2_STATE); 
+
+    slpManRegisterUsrdefinedBackupCb(appBeforeHib,&inParam,SLPMAN_HIBERNATE_STATE);
+    slpManRegisterUsrdefinedRestoreCb(appAfterHib,NULL,SLPMAN_HIBERNATE_STATE);
+
+    slpManRegisterUsrdefinedBackupCb(appBeforeSlp1,NULL,SLPMAN_SLEEP1_STATE);
+    slpManRegisterUsrdefinedRestoreCb(appAfterSlp1,NULL,SLPMAN_SLEEP1_STATE);
+
+    slpManRegisterUsrdefinedBackupCb(appBeforeSlp2,NULL,SLPMAN_SLEEP2_STATE);
+    slpManRegisterUsrdefinedRestoreCb(appAfterSlp2,NULL,SLPMAN_SLEEP2_STATE);
+
     slpManSlpState_t slpstate = slpManGetLastSlpState();
     #ifdef USING_PRINTF
             printf("slpstate:%d \n",slpstate);
@@ -315,6 +383,7 @@ static void process0AppTask(void* arg)//任务调度程序
                 PROC_NB_STATE_SWITCH(PROCESS_NB_STATE_SLEEP);
                 PROC_Uart_STATE_SWITCH(PROCESS_Uart_STATE_SLEEP);
                 PROC_Can_STATE_SWITCH(PROCESS_STATE_SLEEP);
+                osDelay(1000/portTICK_PERIOD_MS);
                 #if 1
                 if(slpManCheckVoteState(process0SlpHandler, &State, &cnt)==RET_TRUE)
                 {
@@ -322,8 +391,8 @@ static void process0AppTask(void* arg)//任务调度程序
                         printf("[%d]We Can Check Vote State, state=%d, cnt=%d\r\n",__LINE__,State,cnt);
                     #endif						
                 }
-                slpManPlatVoteEnableSleep(process0SlpHandler, SLP_SLP2_STATE);  // cancel the prohibition of sleep2
-
+                //slpManPlatVoteEnableSleep(process0SlpHandler, SLP_SLP2_STATE);  // cancel the prohibition of sleep2
+                slpManPlatVoteEnableSleep(process0SlpHandler, SLP_SLP2_STATE); 
                 if(slpManCheckVoteState(process0SlpHandler, &State, &cnt)==RET_TRUE)
                 {
                     #ifdef USING_PRINTF
@@ -334,14 +403,9 @@ static void process0AppTask(void* arg)//任务调度程序
                             printf("[%d]Waiting sleep\r\n",__LINE__);
                 #endif		
                 #endif
-
-                slpManDeepSlpTimerStart(deepslpTimerID,300000); // create a 60s timer, DeepSleep Timer is always oneshoot
-
                 FaultDisplay(LED_TURN_ON);
-                while(1)                // now app can enter hib, but ps and phy maybe not, so wait here
-                {
-                    osDelay(3000/portTICK_PERIOD_MS);
-                }
+                slpManDeepSlpTimerStart(deepslpTimerID,60000); 
+                while(1);
             }
         }
     }
@@ -360,7 +424,7 @@ static void process1AppTask(void* arg)
     uint8_t *Uart_Reve_Point = NULL;
     Uart_Receive_Type Uart_Receive_Msg;
 	PROC_Uart_STATE_SWITCH(PROCESS_Uart_STATE_IDLE);
-	slpManApplyPlatVoteHandle("process1slp",&process1SlpHandler);
+    slpManApplyPlatVoteHandle("pro1",&process1SlpHandler);
     slpManPlatVoteDisableSleep(process1SlpHandler, SLP_SLP2_STATE); 
     Uart_Receive_Msg.Bms_Address = 0x01;
     Uart_Receive_Msg.Bms_Read_Funcode = 0x03;
@@ -507,12 +571,11 @@ static void process1AppTask(void* arg)
             {	
 			    free(Uart_Rece_buffer); 
                 slpManPlatVoteEnableSleep(process1SlpHandler, SLP_SLP2_STATE);  
-                slpManPlatVoteDisableSleep(process1SlpHandler, SLP_HIB_STATE);  
-                while(1)
+                while (1)
                 {
-                    osDelay(3000);
-                }           
-                //此处休眠
+                    ;
+                }
+                
                 break;
             }
         }
@@ -551,7 +614,7 @@ static void process2AppTask(void* arg)
     int send_index = 0;
     uint16_t Batt_Cell_addU = 0x0000;
     Can_Rece_buffer[0]=0xff;
-    slpManApplyPlatVoteHandle("process2slp",&process2SlpHandler);
+    slpManApplyPlatVoteHandle("pro2",&process2SlpHandler);
     slpManPlatVoteDisableSleep(process2SlpHandler, SLP_SLP2_STATE);
     while(1)
     {
@@ -708,11 +771,11 @@ static void process2AppTask(void* arg)
             case PROCESS_STATE_SLEEP:
             {   
                 slpManPlatVoteEnableSleep(process2SlpHandler, SLP_SLP2_STATE); 
-  
-                while(1)
+                while (1)
                 {
-                    osDelay(3000);
-                }                                     
+                    ;
+                }
+                                    
                 break;
             }
         }
@@ -796,12 +859,12 @@ void Tcp_Data_Assemble(uint8_t datatype)
     }
     return;
 }
-// void GGACallBack(UINT8 res, UINT8 * params)
-// {
-// #ifdef USING_PRINTF	
-// 	printf("GPSCallBack\n");
-// #endif
-// }
+void GGACallBack(UINT8 res, UINT8 * params)
+{
+#ifdef USING_PRINTF	
+	printf("GPSCallBack,len:%d,GPS:%s\n",res,params);
+#endif
+}
 static void process3AppTask(void* arg)
 {
     CHAR SN[] = "GYTEST00000000003";
@@ -810,7 +873,7 @@ static void process3AppTask(void* arg)
     int TcpConnectID = -1;
     int TcpSendID = -1;
     int NB_send_len=59+Batt_Cell_Num_2+Batt_Temp_Num;//设定网络发送最大数值
-    slpManApplyPlatVoteHandle("process3slp",&process3SlpHandler);
+    slpManApplyPlatVoteHandle("pro3",&process3SlpHandler);
     slpManPlatVoteDisableSleep(process3SlpHandler, SLP_SLP2_STATE); 
 	PROC_NB_STATE_SWITCH(PROCESS_NB_STATE_IDLE);
     uint8_t* TcpSendBuffer;
@@ -828,8 +891,9 @@ static void process3AppTask(void* arg)
             {
                 while(TcpConnectID<0)
                 {
+                    
                     TcpConnectID = tcpipConnectionCreate(1,PNULL,PNULL,serverip,serverport,TcpCallBack);
-                    osDelay(10);
+                    osDelay(100);
                     #ifdef USING_PRINTF
                         printf("ConnectID:%d\n ",TcpConnectID);
                     #endif
@@ -839,13 +903,7 @@ static void process3AppTask(void* arg)
             }
             case PROCESS_NB_STATE_WORK:
             {
-                if (!TcpSendBuffer)
-                {
-                    #ifdef USING_PRINTF
-                        printf("[%d]malloc error! \r\n",__LINE__);
-                    #endif
-                }
-                //posGGAServiceStart(GGACallBack);
+                posGGAServiceStart(GGACallBack);
                 memset(TcpSendBuffer,0x00,92);
                 *(TcpSendBuffer+0) = 0x23;
                 *(TcpSendBuffer+1) = 0x23;
@@ -891,14 +949,11 @@ static void process3AppTask(void* arg)
             case PROCESS_NB_STATE_SLEEP:
             {   
             	tcpipConnectionClose(TcpConnectID);  
-                // posGGAServiceStop();
+                posGGAServiceStop();
 				free(TcpSendBuffer);
                 slpManPlatVoteEnableSleep(process3SlpHandler, SLP_SLP2_STATE);  // cancel the prohibition of sleep2
-                
-                while(1)
-                {
-                    osDelay(3000);
-                }                                     
+                while(1);
+                break;                                     
             }
         }
     }

src/app_socket.c

@@ -1,263 +0,0 @@
-/****************************************************************************
- *
- * Copy right:   2017-, Copyrigths of EigenComm Ltd.
- * File name:    app.c
- * Description:  EC616 socket demo entry source file
- * History:      Rev1.0   2018-10-12
- *
- ****************************************************************************/
-#include "bsp.h"
-#include "bsp_custom.h"
-#include "osasys.h"
-#include "ostask.h"
-#include "queue.h"
-#include "ps_event_callback.h"
-//#include "psproxytask.h"
-#include "app.h"
-#include "cmisim.h"
-#include "cmimm.h"
-#include "cmips.h"
-#include "sockets.h"
-#include "psifevent.h"
-#include "ps_lib_api.h"
-#include "lwip/netdb.h"
-#include "debug_log.h"
-#include "slpman_ec616.h"
-#include "plat_config.h"
-
-typedef enum {
-    UDP_CLIENT,
-    UDP_SERVER,
-    TCP_CLIENT,
-    TCP_SERVER
-} socketCaseNum;
-
-// Choose which test case to run
-static socketCaseNum testCaseNum = TCP_CLIENT;
-uint8_t socketSlpHandler           = 0xff;
-
-
-// app task static stack and control block
-#define INIT_TASK_STACK_SIZE    (1024)
-#define RINGBUF_READY_FLAG      (0x06)
-#define APP_EVENT_QUEUE_SIZE    (10)
-#define MAX_PACKET_SIZE         (256)
-
-static StaticTask_t             initTask;
-static UINT8                    appTaskStack[INIT_TASK_STACK_SIZE];
-static volatile UINT32          Event;
-static QueueHandle_t            psEventQueueHandle;
-static UINT8                    gImsi[16] = {0};
-static INT32                    sockfd = -1;
-static UINT32                   gCellID = 0;
-
-
-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);
-            ECOMM_STRING(UNILOG_PLA_STRING, socketRegisterPSUrcCallback_0, P_INFO, "SIM ready(imsi=%s)", (UINT8 *)imsi->contents);
-            break;
-        }
-        case NB_URC_ID_MM_SIGQ:
-        {
-            rssi = *(UINT8 *)param;
-            ECOMM_TRACE(UNILOG_PLA_APP, socketRegisterPSUrcCallback_1, P_INFO, 1, "RSSI signal=%d", rssi);
-            break;
-        }
-        case NB_URC_ID_PS_BEARER_ACTED:
-        {
-            ECOMM_TRACE(UNILOG_PLA_APP, socketRegisterPSUrcCallback_2, P_INFO, 0, "Default bearer activated");
-            break;
-        }
-        case NB_URC_ID_PS_BEARER_DEACTED:
-        {
-            ECOMM_TRACE(UNILOG_PLA_APP, socketRegisterPSUrcCallback_3, P_INFO, 0, "Default bearer Deactivated");
-            break;
-        }
-        case NB_URC_ID_PS_CEREG_CHANGED:
-        {
-            cereg = (CmiPsCeregInd *)param;
-            gCellID = cereg->celId;
-            ECOMM_TRACE(UNILOG_PLA_APP, pslibPSUrcCallback_4, P_INFO, 4, "URCCallBack:CEREG changed act:%d celId:%d locPresent:%d tac:%d", cereg->act, cereg->celId, cereg->locPresent, cereg->tac);
-            break;
-        }
-        case NB_URC_ID_PS_NETINFO:
-        {
-            netif = (NmAtiNetifInfo *)param;
-            if (netif->netStatus == NM_NETIF_ACTIVATED)
-                sendQueueMsg(QMSG_ID_NW_IP_READY, 0);
-            break;
-        }
-    }
-    return 0;
-}
-
-
-static void testCaseTcpClient()
-{
-    eventCallbackMessage_t *queueItem = NULL;
-    INT32 recvTimeout = 10;
-    INT32  result;
-    UINT32 cliLen;
-    fd_set readfds;
-    struct timeval tv;
-
-    struct addrinfo hints, *server_res;
-
-    CHAR   serverip[] = "39.156.69.79";
-    CHAR serverport[] = "80";
-    memset( &hints, 0, sizeof( hints ) );
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = IPPROTO_TCP;
-
-    while(1){
-        if (xQueueReceive(psEventQueueHandle, &queueItem, portMAX_DELAY))
-        {
-            #ifdef USING_PRINTF
-                printf("[%d]Queue receive->0x%x \r\n",__LINE__,queueItem->messageId);
-            #endif
-
-            switch(queueItem->messageId)
-            {
-                case QMSG_ID_NW_IP_READY:
-                    #ifdef USING_PRINTF
-                        printf("[%d]IP got ready\r\n",__LINE__);
-                    #endif
-                    if (getaddrinfo( serverip, serverport , &hints, &server_res ) != 0 ) 
-                    {
-                        #ifdef USING_PRINTF
-                            printf("[%d]TCP connect unresolved dns\r\n",__LINE__);
-                        #endif
-                    }
-                    sockfd = socket(AF_INET, SOCK_STREAM, 0);
-                    if (sockfd < 0)
-                    {
-                        #ifdef USING_PRINTF
-                            printf("[%d]socket create error\r\n",__LINE__);
-                        #endif
-                    }
-                    if (connect(sockfd, (struct sockaddr *) server_res->ai_addr, server_res->ai_addrlen) < 0 && errno != EINPROGRESS) 
-                    {
-                        #ifdef USING_PRINTF
-                            printf("[%d]socket connect fail\r\n",__LINE__);
-                        #endif
-                        close(sockfd);
-                        break;
-                    }
-                    #ifdef USING_PRINTF
-                            printf("[%d]socket connect success\r\n",__LINE__);
-                    #endif
-
-                    sendQueueMsg(QMSG_ID_SOCK_SENDPKG, 0);
-                    break;
-                case QMSG_ID_NW_IP_NOREACHABLE:
-                case QMSG_ID_NW_IP_SUSPEND:
-                    if (sockfd > 0)
-                    {
-                       close(sockfd);
-                       sockfd = -1;
-                    }
-                    break;
-                case QMSG_ID_SOCK_SENDPKG:
-                    send( sockfd, "hello", 6, 0 );
-                    osDelay(2000);
-                    #ifdef USING_PRINTF
-                            printf("[%d]socket send success\r\n",__LINE__);
-                    #endif
-                    sendQueueMsg(QMSG_ID_SOCK_SENDPKG, 0);
-                    break;
-            }
-            free(queueItem);
-        }
-        }
-
-
-}
-
-static void socketAppTask(void *arg)
-{
-    psEventQueueHandle = xQueueCreate(APP_EVENT_QUEUE_SIZE, sizeof(eventCallbackMessage_t*));
-    if (psEventQueueHandle == NULL)
-    {
-        ECOMM_TRACE(UNILOG_PLA_APP, socketAppTask_1, P_ERROR, 0, "psEventQueue create error!");
-        return;
-    }
-
-    switch(testCaseNum)
-    {
-        case TCP_CLIENT:
-            testCaseTcpClient();
-            break;
-        case TCP_SERVER:
-            break;
-    }
-}
-
-static void appInit(void *arg)
-{
-    osThreadAttr_t task_attr;
-
-    if(BSP_GetPlatConfigItemValue(PLAT_CONFIG_ITEM_LOG_CONTROL) != 0)
-    {
-        HAL_UART_RecvFlowControl(false);
-    }
-
-    slpManApplyPlatVoteHandle("SOCKET",&socketSlpHandler);
-    registerPSEventCallback(NB_GROUP_ALL_MASK, socketRegisterPSUrcCallback);
-    memset(&task_attr,0,sizeof(task_attr));
-    memset(appTaskStack, 0xA5,INIT_TASK_STACK_SIZE);
-    task_attr.name = "app";
-    task_attr.stack_mem = appTaskStack;
-    task_attr.stack_size = INIT_TASK_STACK_SIZE;
-    task_attr.priority = osPriorityNormal;
-    task_attr.cb_mem = &initTask;//task control block
-    task_attr.cb_size = sizeof(StaticTask_t);//size of task control block
-
-    osThreadNew(socketAppTask, NULL, &task_attr);
-    
-    //abupfotaInit();
-}
-
-/**
-  \fn          int main_entry(void)
-  \brief       main entry function.
-  \return
-*/
-void main_entry(void) {
-
-    BSP_CommonInit();
-    osKernelInitialize();
-    registerAppEntry(appInit, NULL);
-    if (osKernelGetState() == osKernelReady)
-    {
-        osKernelStart();
-    }
-    while(1);
-
-}
-

src/bsp_custom.c

@@ -16,17 +16,21 @@
 
 void GPR_SetUartClk(void)
 {
-#if 0
-	GPR_ClockDisable(GPR_UART0FuncClk);
-	GPR_SetClockSrc(GPR_UART0FuncClk, GPR_UART0ClkSel_26M);
-	GPR_ClockEnable(GPR_UART0FuncClk);
-	GPR_SWReset(GPR_ResetUART0Func);
-#else
-	GPR_ClockDisable(GPR_UART1FuncClk);
-	GPR_SetClockSrc(GPR_UART1FuncClk, GPR_UART1ClkSel_26M);
-	GPR_ClockEnable(GPR_UART1FuncClk);
-	GPR_SWReset(GPR_ResetUART1Func);
-#endif
+    GPR_ClockDisable(GPR_UART0FuncClk);
+    GPR_ClockDisable(GPR_UART1FuncClk);
+    GPR_ClockDisable(GPR_UART2FuncClk);
+
+    GPR_SetClockSrc(GPR_UART0FuncClk, GPR_UART0ClkSel_26M);
+    GPR_SetClockSrc(GPR_UART1FuncClk, GPR_UART1ClkSel_26M);
+    GPR_SetClockSrc(GPR_UART2FuncClk, GPR_UART1ClkSel_26M);
+
+    GPR_ClockEnable(GPR_UART0FuncClk);
+    GPR_ClockEnable(GPR_UART1FuncClk);
+    GPR_ClockEnable(GPR_UART2FuncClk);
+
+    GPR_SWReset(GPR_ResetUART0Func);
+    GPR_SWReset(GPR_ResetUART1Func);
+    GPR_SWReset(GPR_ResetUART2Func);
 }
 
 extern ARM_DRIVER_USART Driver_USART0;
@@ -83,13 +87,31 @@ slpManSlpState_t CheckUsrdefSlpStatus(void)
 
 #endif
 
+/**
+  \fn        void CheckLockOutState(void)
+  \brief      CheckLockOutState
+  \param     void
+ */
+void CheckLockOutState(void){
+	if((slpManGetWakeupPinValue() & (0x1<<2)) == 0){
+		#ifdef USING_PRINTF
+			printf("LOCK_OUT DOWN\r\n");
+		#endif	
+	}else{
+		#ifdef USING_PRINTF
+			printf("LOCK_OUT UP\r\n",__LINE__);
+		#endif	
+	}
+}
+
+
 static void PMU_WakeupPadInit(void)
 {
     const padWakeupSettings_t cfg =
     {
-         true,  true,             // group0 posedge, negedge
-         true,  true,             // group1 posedge, negedge
-         true,  true,             // group2 posedge, negedge
+        false, true,             // group0 posedge, negedge
+        true, true,             // group1 posedge, negedge
+        false, false,             // group2 posedge, negedge
     };
 
     slpManSetWakeupPad(cfg);
@@ -130,8 +152,9 @@ void BSP_CustomInit(void)
 	slpManGetPMUSettings();				
 
 	PMU_WakeupPadInit();
-	NVIC_DisableIRQ(PadWakeup0_IRQn);
-
+	NVIC_DisableIRQ(PadWakeup1_IRQn);
+	NVIC_EnableIRQ(PadWakeup2_IRQn);
+	CheckLockOutState();
 	slpManStartWaitATTimer();
 
 	CanSPIHandler(NULL,ARM_SPI_CPOL0_CPHA0,8,200000U);
@@ -172,6 +195,7 @@ void Pad1_WakeupIntHandler(void)
 
 void Pad2_WakeupIntHandler(void)
 {
+     CheckLockOutState();
     if(slpManExtIntPreProcess(PadWakeup2_IRQn)==false)
         return;
 

src/hal_module_adapter.c

@@ -13,7 +13,6 @@
 /*
 	gps
 */
-#define GPS_DATA_RECV_BUFFER_SIZE     						(256)
 static posGGACallBack gGPSDataCBfunc =NULL;
 // GSENSOR device addr
 #define GSENSOR_DEVICE_ADDR               						(SC7A20_IIC_ADDRESS)
@@ -57,8 +56,13 @@ static osMessageQueueId_t i2c_recv_msgqueue;
 */
 #define ADC_TASK_STACK_SIZE   								 (512)
 #define ADC_MSG_MAX_NUM        								 (7)
-#define ADC_AioResDivRatioDefault                                              (ADC_AioResDivRatio10Over16)
-#define REV_AioResDivRatioDefault								 16/10
+#define ADC_AioResDivRatioDefault                                              (ADC_AioResDivRatio1)
+#define REV_AioResDivRatioDefault								 1
+#define ADC_ChannelAioVbat										(1800)
+#define ADC_ChannelAioRes										(15000)
+#define NTC_FullAioValue											(1200)
+#define ADC_AioResDivRatioExtra                                              (ADC_AioResDivRatio8Over16)
+#define REV_AioResDivRatioExtra								 16/8
 #define NTC_REQ_UPDATE_DATA    							       (0x01)
 #define ADC_MSG_TIMEOUT      								 (1000)
 
@@ -81,6 +85,17 @@ static osEventFlagsId_t adcTrigerHandle = NULL;
 static osThreadId_t adcTaskHandle = NULL;
 static StaticTask_t adcTask = NULL;
 static UINT8 adcTaskStack[ADC_TASK_STACK_SIZE];
+
+
+/*
+	gps
+*/
+#define GPS_TASK_STACK_SIZE   								 (2048)
+QueueHandle_t gpsMsgHandle = NULL;
+static osThreadId_t gpsTaskHandle = NULL;
+static StaticTask_t gpsTask = NULL;
+static UINT8 gpsTaskStack[GPS_TASK_STACK_SIZE];
+
 /*
 	can
 */
@@ -1003,6 +1018,18 @@ void GsensorI2CHandler(ARM_I2C_SignalEvent_t cb_event)
      ECOMM_TRACE(UNILOG_PLA_DRIVER, I2C_GSENSOR_I, P_INFO, 0, "i2c config ok");
 #endif
 }
+
+/**
+  \fn     void GPSSendStr(uint8_t* strPtr, uint16_t strLen)
+  \param[in]  strPtr for gps usart port;
+  \brief    
+  \return      
+*/
+void GPSSendStr(uint8_t* strPtr, uint16_t strLen)
+{
+	HAL_UART_SendStr(PORT_USART_2,strPtr,strLen);
+
+}
 /**
   \fn    void GpsDataRecvCallback(uint32_t event, void* dataPtr, uint32_t dataLen)
   \param[in]  event   :Data receiving timeout processing and data receiving completion processing;
@@ -1013,21 +1040,21 @@ void GsensorI2CHandler(ARM_I2C_SignalEvent_t cb_event)
 */
 void GpsDataRecvCallback(UINT32 event, void* dataPtr, UINT32 dataLen)
 {
-    UINT8 GPS[256];
+   if((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE)){
+	    #ifdef USING_PRINTF	
+	    //	printf("GpsDataRecvCallback [%d] %s\r\n",dataLen,dataPtr);
+	    #endif 
+		if(dataLen>0){
+			gpsReqMsg gpsInfo;
+			gpsInfo.dataPtr=malloc(dataLen+1);
+			if(gpsInfo.dataPtr){
+				memcpy(gpsInfo.dataPtr,dataPtr,dataLen);	
+				gpsInfo.len=dataLen;
+				osMessageQueuePut(gpsMsgHandle, &gpsInfo, 0, 2000);
+			}
+		}
+   }
     slpManStartWaitATTimer(); 
-   if((event == ARM_USART_EVENT_RX_TIMEOUT) || (event == ARM_USART_EVENT_RECEIVE_COMPLETE))
-    {
-        //parse data
-         memcpy(GPS, dataPtr, dataLen);
-	   gGPSDataCBfunc(dataLen,GPS);
-#if 0	   
-#ifdef USING_PRINTF	
-	printf("GPS:len=%d,data=%s\r\n",datalen,GPS);
-#else
-       ECOMM_STRING(UNILOG_PLA_STRING, GPS_RECV_DATA, P_INFO, "GPS:%s", GPS);
-#endif
-#endif
-    }
 }
 /**
   \fn     void GPSUsartHandler(ARM_DRIVER_USART * uartDriverHandler, uint32_t baudRate)
@@ -1054,7 +1081,23 @@ void GPSUsartHandler(UINT32 baudRate)
 	halUartConfig.recvBuffPtr = gps_uart_recv_buf;
 	halUartConfig.recvBuffSize = GPS_DATA_RECV_BUFFER_SIZE;
 	HAL_UART_InitHandler(PORT_USART_2, &halUartConfig, &hwConfig, HAL_UART_TASK_CREATE_FLAG_SEND_RECV);
+	HAL_UART_RecvFlowControl(false);
+}
 
+/**
+  \fn  INT32 AdcGetRes(UINT32 NTCvalue)
+  \param[in]  req : NTCvalue
+  \brief     
+  \return    Resvalue
+*/
+static INT32 AdcGetRes(UINT32 NTCvalue){
+	UINT32 Resvalue;
+	if(NTCvalue>=(ADC_ChannelAioVbat-100))
+		Resvalue=1000000;
+	else{
+		Resvalue=ADC_ChannelAioRes*NTCvalue/(ADC_ChannelAioVbat-NTCvalue);
+	}
+	return Resvalue;
 }
 
 /**
@@ -1069,7 +1112,7 @@ INT32 AdcSendReq(UINT32 req,UINT32 * param , UINT8 len ,UINT32 timeout)
     adcReqMsg ReqMsg;
 	
     ReqMsg.request = req;
-    ReqMsg.param[NTC_Channel1] =   ReqMsg.param[NTC_Channel2] =  ReqMsg.param[NTC_Channel3] =  ReqMsg.param[NTC_Channel4] =  ReqMsg.param[NTC_Channel5] =ADC_AioResDivRatio10Over16  ;
+    ReqMsg.param[NTC_Channel1] =   ReqMsg.param[NTC_Channel2] =  ReqMsg.param[NTC_Channel3] =  ReqMsg.param[NTC_Channel4] =  ReqMsg.param[NTC_Channel5] =ADC_AioResDivRatioDefault  ;
     ret = osMessageQueuePut(adcMsgHandle, &ReqMsg, 0, timeout);
 
     if(ret != osOK)
@@ -1089,19 +1132,19 @@ INT32 AdcSendReq(UINT32 req,UINT32 * param , UINT8 len ,UINT32 timeout)
  		param[0] = gNtcDev.NTCvalue[1];
 		break;
 		case ADC_REQ_BITMAP_CH1:
-		param[0] = gNtcDev.NTCvalue[2+NTC_Channel1];	
+		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel1]);	
 		break;
 		case ADC_REQ_BITMAP_CH2:
-		param[0] = gNtcDev.NTCvalue[2+NTC_Channel2];	
+		param[0] =AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel2]);	
 		break;
 		case ADC_REQ_BITMAP_CH3:
-		param[0] = gNtcDev.NTCvalue[2+NTC_Channel3];	
+		param[0] =AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel3]);	
 		break;
 		case ADC_REQ_BITMAP_CH4:
-		param[0] = gNtcDev.NTCvalue[2+NTC_Channel4];	
+		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel4]);	
 		break;
 		case ADC_REQ_BITMAP_CH5:
-		param[0] = gNtcDev.NTCvalue[2+NTC_Channel5];	
+		param[0] = AdcGetRes(gNtcDev.NTCvalue[2+NTC_Channel5]);	
 		break;
 	  }
 	  osEventFlagsClear(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
@@ -1178,10 +1221,11 @@ static void AdcProcess(void* arg)
 			handle event
 	 */
 	adc_config_t adcConfig;
-
+	INT8 times=1;
 	ADC_GetDefaultConfig(&adcConfig);
 
 	osEventFlagsClear(adcEvtHandle, regMsg.request);
+	retry:
 
 	if(regMsg.request & ADC_REQ_BITMAP_VBAT)
 	{
@@ -1273,25 +1317,72 @@ static void AdcProcess(void* arg)
 	if(regMsg.request & ADC_REQ_BITMAP_CH1)
 	{
 	 	ADC_ChannelDeInit(ADC_ChannelAio1, ADC_UserAPP);
-		gNtcDev.NTCvalue[2+NTC_Channel1]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1])*REV_AioResDivRatioDefault;
+		if(times==1){
+			gNtcDev.NTCvalue[2+NTC_Channel1]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1])*REV_AioResDivRatioDefault;
+			if(gNtcDev.NTCvalue[2+NTC_Channel1]>(NTC_FullAioValue-100)){
+				regMsg.param[NTC_Channel1]=ADC_AioResDivRatioExtra;
+				times++;
+				goto retry;
+			}			
+		}else{
+			gNtcDev.NTCvalue[2+NTC_Channel1]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel1])*REV_AioResDivRatioExtra;
+		}
+			
 	}
 	if(regMsg.request & ADC_REQ_BITMAP_CH2)
 	{
 		ADC_ChannelDeInit(ADC_ChannelAio2, ADC_UserAPP);
-		gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioDefault;
+		if(times==1){
+			gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioDefault;
+			if(gNtcDev.NTCvalue[2+NTC_Channel2]>(NTC_FullAioValue-100)){
+				regMsg.param[NTC_Channel2]=ADC_AioResDivRatioExtra;
+				times++;
+				goto retry;
+			}			
+		}else{
+			gNtcDev.NTCvalue[2+NTC_Channel2]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel2])*REV_AioResDivRatioExtra;
+		}	
 	}
 	if(regMsg.request & ADC_REQ_BITMAP_CH3)
 	{
 		ADC_ChannelDeInit(ADC_ChannelAio3, ADC_UserAPP);
-		gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioDefault;
+		if(times==1){
+			gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioDefault;
+			if(gNtcDev.NTCvalue[2+NTC_Channel3]>(NTC_FullAioValue-100)){
+				regMsg.param[NTC_Channel3]=ADC_AioResDivRatioExtra;
+				times++;
+				goto retry;
+			}			
+		}else{
+			gNtcDev.NTCvalue[2+NTC_Channel3]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel3])*REV_AioResDivRatioExtra;
+		}
 	}
 	if(regMsg.request & ADC_REQ_BITMAP_CH4 ||regMsg.request & ADC_REQ_BITMAP_CH5)
 	{
 		ADC_ChannelDeInit(ADC_ChannelAio4, ADC_UserAPP);
 		if(gNtcDev.flagC4){
-			gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4])*REV_AioResDivRatioDefault;
+			if(times==1){
+				gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4])*REV_AioResDivRatioDefault;
+				if(gNtcDev.NTCvalue[2+NTC_Channel4]>(NTC_FullAioValue-100)){
+					regMsg.param[NTC_Channel4]=ADC_AioResDivRatioExtra;
+					times++;
+					goto retry;
+				}			
+			}else{
+				gNtcDev.NTCvalue[2+NTC_Channel4]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel4])*REV_AioResDivRatioExtra;
+			}			
 		}else{
-			gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5])*REV_AioResDivRatioDefault;
+			if(times==1){
+				gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5])*REV_AioResDivRatioDefault;
+				if(gNtcDev.NTCvalue[2+NTC_Channel5]>(NTC_FullAioValue-100)){
+					regMsg.param[NTC_Channel5]=ADC_AioResDivRatioExtra;
+					times++;
+					goto retry;
+				}			
+			}else{
+				gNtcDev.NTCvalue[2+NTC_Channel5]= HAL_ADC_CalibrateRawCode(NTCChannelResult[NTC_Channel5])*REV_AioResDivRatioExtra;
+			}
+			
 		}
 	}
 	 osEventFlagsSet(adcTrigerHandle, ADC_RECV_CONTROL_FLAG);
@@ -1381,7 +1472,7 @@ void PowerPinConfig(IOType iotype)
 		
 		PAD_SetPinConfig(31, &padConfig);
 		GPIO_PinConfig(1, AON_GPS_POWER2, &config);
-		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 0);
+		GPIO_PinWrite(1, 1 << AON_GPS_POWER2, 1 << AON_RELAY_DRV);
 
 		PAD_SetPinConfig(32, &padConfig);
 		GPIO_PinConfig(1, AON_RELAY_DRV, &config);
@@ -1510,3 +1601,72 @@ void posGGAServiceStop( void)
 	GPSPowerCtr(false);
 	gGPSDataCBfunc = NULL;
 }
+
+
+/**
+  \fn   void gpsProcess(void* arg)
+  \param[in]  
+  \brief       handle gps init ,deinit and convert process
+  \return      
+*/
+static void GpsProcess(void* arg)
+{
+    gpsReqMsg msg;
+    #ifdef USING_PRINTF	
+    	printf("%s[%d]\r\n",__FUNCTION__, __LINE__);
+    #endif
+    while(1)
+    {
+    	/*
+		
+	*/
+	 osMessageQueueGet(gpsMsgHandle, &msg, 0, osWaitForever);
+	 /*
+			handle event
+	 */
+	    #ifdef USING_PRINTF	
+	    	printf("GpsProcess [%d] %s\r\n",msg.len,msg.dataPtr);
+	    #endif 
+		 if(msg.dataPtr)
+		 	free(msg.dataPtr);
+	  	msg.dataPtr=NULL;
+    }
+}
+
+/**
+  \fn    INT32 GpsTaskInit(void)
+  \param[in]  
+  \brief       create task for checking gps data
+  \return      
+*/
+INT32 GpsTaskInit(void)
+{
+
+	if(gpsMsgHandle == NULL)
+	{
+		gpsMsgHandle = osMessageQueueNew(1,sizeof(gpsReqMsg), NULL);
+		if(gpsMsgHandle == NULL)
+			return 1;
+	}
+	
+
+	if(gpsTaskHandle == NULL)
+	{
+		osThreadAttr_t task_attr;
+		memset(&task_attr , 0 , sizeof(task_attr));
+		task_attr.name = "GPS";
+		task_attr.priority = osPriorityNormal1;
+		task_attr.cb_mem = &gpsTask;
+		task_attr.cb_size = sizeof(StaticTask_t);
+		task_attr.stack_mem = gpsTaskStack;
+		task_attr.stack_size =GPS_TASK_STACK_SIZE;
+		memset(& gpsTaskStack, 0xa5, GPS_TASK_STACK_SIZE);
+		gpsTaskHandle = osThreadNew(GpsProcess , NULL,&task_attr);
+		if(gpsTaskHandle == NULL)
+			return 1;
+	}
+	
+	return 0;
+}
+
+

src/sensor.c

@@ -0,0 +1,483 @@
+#include "sensor.h"
+
+
+/***************在线测试**********************/
+INT8 SL_SC7A20_Online_Test(void)
+{
+    UINT8 SL_Read_Reg=0xff;
+    GSENSOR_ReadReg(SC7A20_CHIP_ID_ADDRESS,1, &SL_Read_Reg); 
+    //printf("SL_Read_Reg = %#x\r\n",SL_Read_Reg);	
+    if(SL_Read_Reg==SC7A20_CHIP_ID_VALUE){
+	return  1;
+   } else { 
+   	return -1;
+   }
+}
+
+/***************BOOT 重载内部寄存器值*********************/
+INT8  SL_SC7A20_BOOT(void)
+{
+    UINT8 SL_Read_Reg=0xff;
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_SC7A20_BOOT_ENABLE|SL_Read_Reg;
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg);
+    return  1;
+}
+
+
+/***************传感器量程设置**********************/
+INT8  SL_SC7A20_FS_Config(UINT8 Sc7a20_FS_Reg)
+{
+    UINT8 SL_Read_Reg=0xff,SL_Write_Reg;
+
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG4,1, &SL_Read_Reg); 
+    SL_Write_Reg=0x80|Sc7a20_FS_Reg|SL_SC7A20_HR_ENABLE;
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG4, SL_Write_Reg);
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG4,1, &SL_Read_Reg); 
+    if(SL_Read_Reg==SL_Write_Reg) {
+	return  1;
+    }else{
+    	return -1;
+    }
+}
+
+#if SL_6D4D2D1D_SEL==1  //1D
+//AOI1_INT1  运动检测，运动触发中断        6D运动检测
+//AOI2_INT2  位置检测，检测是否离开X+位置  1D位置识别
+/***************中断设置*************/
+INT8  SL_SC7A20_INT_Config(void)
+{
+    UINT8 SL_Read_Reg;
+
+    /*******************AOI1  IN  INT1********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x08;//AOI1 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg); 
+    
+    //H_LACTIVE SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_SC7A20_INT_ACTIVE_LOWER_LEVEL|SL_Read_Reg;
+    //interrupt happen,int pin output lower level
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);  
+    
+    //AOI1 CONFIG
+    SL_Read_Reg=0x00;            //0x7F
+    SL_Read_Reg=SL_Read_Reg|0x40;//方向运动识别模式
+    SL_Read_Reg=SL_Read_Reg|0x03;//X 轴高低事件 X轴数据的绝对值大于阈值
+    SL_Read_Reg=SL_Read_Reg|0x0C;//Y 轴高低事件 Y轴数据的绝对值大于阈值	
+    SL_Read_Reg=SL_Read_Reg|0x30;//Z 轴高低事件 Z轴数据的绝对值大于阈值	
+    GSENSOR_WriteReg(SL_SC7A20_INT1_CFG, SL_Read_Reg);    
+
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg|0x81;//Normal HP , HPF TO AOI1 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+    
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT1_THS, SL_SC7A20_INT_THS_10PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT1_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+        
+    //AOI1 TO INT1
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG3,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x40; //AOI1 TO INT1
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG3, SL_Read_Reg);  
+    /*******************AOI1  IN  INT1********************/
+
+
+    /*******************AOI2  IN  INT2********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x02;//AOI2 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg);	
+    
+    //H_LACTIVE SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_SC7A20_INT_ACTIVE_LOWER_LEVEL|SL_Read_Reg;
+    //interrupt happen,int pin output lower level
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);    
+
+    //AOI2 CONFIG
+    SL_Read_Reg=0x00;            //0xC2
+    SL_Read_Reg=SL_Read_Reg|0xC0;//方向位置识别模式
+    SL_Read_Reg=SL_Read_Reg|0x02;//X 轴高事件 X轴数据大于阈值 输出低电平，默认输出高电平
+    GSENSOR_WriteReg(SL_SC7A20_INT2_CFG, SL_Read_Reg);    
+
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg&0xFD;//NO HPF TO AOI2 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT2_THS, SL_SC7A20_INT_THS_40PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT2_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+    
+    //AOI2 TO INT2
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x20; //AOI2 TO INT2
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);  
+    /*******************AOI2  IN  INT2********************/
+
+    return  1;
+}
+#elif  SL_6D4D2D1D_SEL==2  //2D
+//AOI1_INT1  运动检测，运动触发中断 或事件   3D运动检测 
+//AOI2_INT2  位置检测，检测X+ 和 X-          2D位置识别
+/***************中断设置*************/
+INT8  SL_SC7A20_INT_Config(void)
+{
+    UINT8 SL_Read_Reg;
+
+    /*******************AOI1  IN  INT1********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x08;//AOI1 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg); 
+    
+    //AOI1 CONFIG
+    SL_Read_Reg=0x00;            //0x2A 或事件
+    SL_Read_Reg=SL_Read_Reg|0x02;//X 轴高事件 X轴数据的绝对值大于阈值
+    SL_Read_Reg=SL_Read_Reg|0x08;//Y 轴高事件 Y轴数据的绝对值大于阈值	
+    SL_Read_Reg=SL_Read_Reg|0x20;//Z 轴高事件 Z轴数据的绝对值大于阈值	
+    GSENSOR_WriteReg(SL_SC7A20_INT1_CFG, SL_Read_Reg);    
+   
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg|0x81;//Normal HP , HPF TO AOI1 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+    
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT1_THS, SL_SC7A20_INT_THS_10PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT1_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+        
+    //AOI1 TO INT1
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG3,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x40; //AOI1 TO INT1
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG3, SL_Read_Reg);  
+    /*******************AOI1  IN  INT1********************/
+
+
+    /*******************AOI2  IN  INT2********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x02;//AOI2 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg);	
+    
+    //H_LACTIVE SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_SC7A20_INT_ACTIVE_LOWER_LEVEL|SL_Read_Reg;
+    //interrupt happen,int pin output lower level
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);    
+
+    //AOI2 CONFIG
+    SL_Read_Reg=0x00;            //0xC3
+    SL_Read_Reg=SL_Read_Reg|0xC0;//方向位置识别模式
+    SL_Read_Reg=SL_Read_Reg|0x03;//X 轴高低事件 X轴数据的绝对值大于阈值 输出低电平，默认输出高电平
+    GSENSOR_WriteReg(SL_SC7A20_INT2_CFG, SL_Read_Reg);    
+
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg&0xFD;//NO HPF TO AOI2 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT2_THS, SL_SC7A20_INT_THS_40PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT2_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+    
+    //AOI2 TO INT2
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x20; //AOI2 TO INT2
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);  
+    /*******************AOI2  IN  INT2********************/
+
+    return  1;
+}
+#elif  SL_6D4D2D1D_SEL==4  //4D
+//AOI1_INT1  运动检测，运动触发中断 或事件     3D运动检测 
+//AOI2_INT2  位置检测，检测X+ 和 X-  Y+ 和 Y-  4D位置识别
+/***************中断设置*************/
+INT8  SL_SC7A20_INT_Config(void)
+{
+    UINT8 SL_Read_Reg;
+
+    /*******************AOI1  IN  INT1********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x08;//AOI1 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg); 
+    
+    //AOI1 CONFIG
+    SL_Read_Reg=0x00;            //0x2A 或事件
+    SL_Read_Reg=SL_Read_Reg|0x02;//X 轴高事件 X轴数据的绝对值大于阈值
+	SL_Read_Reg=SL_Read_Reg|0x08;//Y 轴高事件 Y轴数据的绝对值大于阈值	
+	SL_Read_Reg=SL_Read_Reg|0x20;//Z 轴高事件 Z轴数据的绝对值大于阈值	
+    GSENSOR_WriteReg(SL_SC7A20_INT1_CFG, SL_Read_Reg);    
+   
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg|0x81;//Normal HP , HPF TO AOI1 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+    
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT1_THS, SL_SC7A20_INT_THS_10PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT1_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+        
+    //AOI1 TO INT1
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG3,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x40; //AOI1 TO INT1
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG3, SL_Read_Reg);  
+    /*******************AOI1  IN  INT1********************/
+
+
+    /*******************AOI2  IN  INT2********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x02;//AOI2 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg);	
+    
+    //H_LACTIVE SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_SC7A20_INT_ACTIVE_LOWER_LEVEL|SL_Read_Reg;
+    //interrupt happen,int pin output lower level
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);    
+
+    //AOI2 CONFIG
+    SL_Read_Reg=0x00;            //0xCF
+    SL_Read_Reg=SL_Read_Reg|0xC0;//方向位置识别模式
+    SL_Read_Reg=SL_Read_Reg|0x0F;//XY 轴高低事件 XY轴数据的绝对值大于阈值 输出低电平，默认输出高电平
+    GSENSOR_WriteReg(SL_SC7A20_INT2_CFG, SL_Read_Reg);    
+
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg&0xFD;//NO HPF TO AOI2 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT2_THS, SL_SC7A20_INT_THS_40PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT2_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+    
+    //AOI2 TO INT2
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x20; //AOI2 TO INT2
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);  
+    /*******************AOI2  IN  INT2********************/
+
+    return  1;
+}
+#elif  SL_6D4D2D1D_SEL==6  //6D
+//AOI1_INT1  运动检测，运动触发中断                    6D运动检测
+//AOI2_INT2  位置检测，检测X+ 和 X-  Y+ 和 Y- Z+ 和 Z- 6D位置识别
+/***************中断设置*************/
+INT8  SL_SC7A20_INT_Config(void)
+{
+    UINT8 SL_Read_Reg;
+
+    /*******************AOI1  IN  INT1********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x08;//AOI1 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg); 
+    
+    //AOI1 CONFIG
+    SL_Read_Reg=0x00;            //0x7F  无LATCH功能
+    SL_Read_Reg=SL_Read_Reg|0x40;//方向运动识别模式
+    SL_Read_Reg=SL_Read_Reg|0x03;//X 轴高低事件 X轴数据的绝对值大于阈值
+    SL_Read_Reg=SL_Read_Reg|0x0C;//Y 轴高低事件 Y轴数据的绝对值大于阈值	
+    SL_Read_Reg=SL_Read_Reg|0x30;//Z 轴高低事件 Z轴数据的绝对值大于阈值	
+    GSENSOR_WriteReg(SL_SC7A20_INT1_CFG, SL_Read_Reg);    
+   
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg|0x81;//Normal HP , HPF TO AOI1 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+    
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT1_THS, SL_SC7A20_INT_THS_10PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT1_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+        
+    //AOI1 TO INT1
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG3,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x40; //AOI1 TO INT1
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG3, SL_Read_Reg);  
+    /*******************AOI1  IN  INT1********************/
+
+
+    /*******************AOI2  IN  INT2********************/
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG5,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x02;//AOI2 LATCH
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG5, SL_Read_Reg);	
+    
+    //H_LACTIVE SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_SC7A20_INT_ACTIVE_LOWER_LEVEL|SL_Read_Reg;
+    //interrupt happen,int pin output lower level
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);    
+
+    //AOI2 CONFIG
+    SL_Read_Reg=0x00;            //0xC2
+    SL_Read_Reg=SL_Read_Reg|0xC0;//方向位置识别模式
+    SL_Read_Reg=SL_Read_Reg|0x3F;//XYZ 轴高事件 XYZ轴数据的绝对值大于阈值 输出低电平，默认输出高电平
+    GSENSOR_WriteReg(SL_SC7A20_INT2_CFG, SL_Read_Reg);    
+
+    //HPF SET
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG2,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg&0xFD;//NO HPF TO AOI2 
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG2, SL_Read_Reg);
+
+    //中断阈值设置
+    GSENSOR_WriteReg(SL_SC7A20_INT2_THS, SL_SC7A20_INT_THS_40PERCENT);	
+    //大于阈值多少时间触发中断
+    GSENSOR_WriteReg(SL_SC7A20_INT2_DURATION, SL_SC7A20_INT_DURATION_2CLK);
+    
+    //AOI2 TO INT2
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG6,1, &SL_Read_Reg);
+    SL_Read_Reg=SL_Read_Reg|0x20; //AOI2 TO INT2
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG6, SL_Read_Reg);  
+    /*******************AOI2  IN  INT2********************/
+
+    return  1;
+}
+#endif
+
+/******外部中断处理函数中需要调用该函数*******/
+//retrun_value&0x20=0x20  ZH  Z轴高事件
+//retrun_value&0x20=0x10  ZL  Z轴低事件
+//retrun_value&0x20=0x08  YH  Y轴高事件
+//retrun_value&0x20=0x04  YL  Y轴低事件
+//retrun_value&0x20=0x02  XH  X轴高事件
+//retrun_value&0x20=0x01  XL  X轴低事件
+INT8  SL_SC7A20_INT_RESET(void)
+{
+
+    UINT8 SL_Read_Reg1;
+    UINT8 SL_Read_Reg2;
+    
+    /*****为了避免读取数据过程中又产生中断，可以暂时关闭中断*****/	
+ 
+    //SL_Read_Reg1 display the int1 type
+    GSENSOR_ReadReg(SL_SC7A20_INT1_SRC,1, &SL_Read_Reg1);
+    //SL_Read_Reg2 display the int2 type
+    GSENSOR_ReadReg(SL_SC7A20_INT2_SRC,1, &SL_Read_Reg2);
+    
+    //close INT1
+    GSENSOR_WriteReg(SL_SC7A20_INT1_CFG, 0x00);
+    //close INT2
+    GSENSOR_WriteReg(SL_SC7A20_INT2_CFG, 0x00);     
+    
+    if((SL_Read_Reg2&0x02)==0x02)
+    {
+        //X+
+    }
+    if((SL_Read_Reg2&0x01)==0x01)
+    {
+        //X-
+    }
+    if((SL_Read_Reg2&0x08)==0x08)
+    {
+        //Y+
+    }
+    if((SL_Read_Reg2&0x04)==0x04)
+    {
+        //Y-
+    }
+    if((SL_Read_Reg2&0x20)==0x20)
+    {
+        //Z+
+    }
+    if((SL_Read_Reg2&0x10)==0x10)
+    {
+        //Z-
+    }
+    
+    if(SL_Read_Reg1!=0||SL_Read_Reg2!=0)
+    {
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+
+}
+
+/***************数据更新速率**加速度计使能**********/
+INT8  SL_SC7A20_Power_Config(UINT8 Power_Config_Reg)
+{
+    UINT8 SL_Read_Reg;
+
+#if  SL_SC7A20_MTP_ENABLE==1
+    SL_Read_Reg  = 0x00;
+    GSENSOR_WriteReg(SL_SC7A20_MTP_CFG, SL_SC7A20_MTP_VALUE);
+    GSENSOR_ReadReg(SL_SC7A20_SDOI2C_PU_CFG,1, &SL_Read_Reg); 
+    SL_Read_Reg=SL_Read_Reg|SL_SC7A20_SDO_PU_MSK|SL_SC7A20_I2C_PU_MSK;
+    GSENSOR_WriteReg(SL_SC7A20_SDOI2C_PU_CFG, SL_Read_Reg);
+#endif
+    SL_Read_Reg  = 0xff;
+    GSENSOR_WriteReg(SL_SC7A20_CTRL_REG1, Power_Config_Reg);
+    GSENSOR_ReadReg(SL_SC7A20_CTRL_REG1,1, &SL_Read_Reg); 
+
+    if(SL_Read_Reg==Power_Config_Reg){
+	return  1;
+    }else{
+    	return -1;
+    }
+}
+
+
+#if   SL_SC7A20_16BIT_8BIT==0
+/***************加速度计数据读取*8bits*********/
+INT8  SL_SC7A20_Read_XYZ_Data(INT8 *SL_SC7A20_Data_XYZ_Buf)
+{
+    UINT8 SL_Read_Buf[7];
+    
+    GSENSOR_ReadReg(SL_SC7A20_STATUS_REG,1, &SL_Read_Buf[0]);
+    
+    if((SL_Read_Buf[0]&0x0f)==0x0f)
+    {
+        GSENSOR_ReadReg(SL_SC7A20_DATA_OUT,6, &SL_Read_Buf[1]);
+        SL_SC7A20_Data_XYZ_Buf[0]=(INT8)SL_Read_Buf[2];
+        SL_SC7A20_Data_XYZ_Buf[1]=(INT8)SL_Read_Buf[4];
+        SL_SC7A20_Data_XYZ_Buf[2]=(INT8)SL_Read_Buf[6];
+        return  1;   
+    }
+    else
+    {
+        return 0;
+    }
+}
+#elif SL_SC7A20_16BIT_8BIT==1
+/***************加速度计数据读取*16bits*********/
+INT8  SL_SC7A20_Read_XYZ_Data(INT16 *SL_SC7A20_Data_XYZ_Buf)
+{
+    UINT8 SL_Read_Buf[7];
+    
+    GSENSOR_ReadReg(SL_SC7A20_STATUS_REG,1, &SL_Read_Buf[0]);
+    
+    if((SL_Read_Buf[0]&0x0f)==0x0f)
+    {
+        GSENSOR_ReadReg(SL_SC7A20_DATA_OUT,6, &SL_Read_Buf[1]);
+ 
+        SL_SC7A20_Data_XYZ_Buf[0]=(INT16)((SL_Read_Buf[2]<<8) + SL_Read_Buf[1]);
+        SL_SC7A20_Data_XYZ_Buf[1]=(INT16)((SL_Read_Buf[4]<<8) + SL_Read_Buf[3]);
+        SL_SC7A20_Data_XYZ_Buf[2]=(INT16)((SL_Read_Buf[6]<<8) + SL_Read_Buf[5]);
+        return  1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+#endif
+void GsensorInit(void)
+{
+	INT8 res = 0;
+	res = SL_SC7A20_Online_Test();
+	if(res==1){
+		
+		SL_SC7A20_BOOT();
+		SL_SC7A20_FS_Config(SL_SC7A20_FS_4G);
+		SL_SC7A20_INT_Config();
+		SL_SC7A20_INT_RESET();
+		SL_SC7A20_Power_Config(SL_SC7A20_LOWER_POWER_ODR_400HZ);
+	}
+}