测试2.4G可以传输，CFG_CONN_INTV目前不能设置为1，否则不能传输数据

串口打印接口调整为PB9，调整文件结构，增加touch和uart，还未调试

project/solution/ble_hid_composite/Output/bin/Settings/standard.setting

@@ -18,6 +18,6 @@
         <add key="rf_pa_cap" value="8" />
         <add key="rf_mix_cap" value="8" />
         <add key="uosc_both_cap" value="0PF" />
-        <add key="rf_tx_pwr" value="0" />
+        <add key="rf_tx_pwr" value="4" />
     </appSettings>
 </configuration>

project/solution/ble_hid_composite/functions/func.c → project/solution/ble_hid_composite/app/func.c

@@ -113,6 +113,7 @@ void func_run(void)
     printf("%s\n", __func__);
 
     while (1) {
+        WDT_CLR();
         func_enter();
         switch (func_cb.sta) {
 #if FUNC_BT_EN

project/solution/ble_hid_composite/functions/func_wireless.c → project/solution/ble_hid_composite/app/func_wireless.c

@@ -15,11 +15,14 @@ void func_wireless_process(void)
 {
     func_process();
 
-#if WIRELESS_TRANSMIT_EN	
-    func_wireless_sub_process();
-#else
-    wireless_service_proc();
-#endif
+    if (bTransmitEn)
+    {
+        func_wireless_sub_process();
+    }
+    else
+    {
+        wireless_service_proc();
+    }
 
 #if SYS_OFF_TIME
     if(sys_cb.pwroff_delay == 0) {
@@ -68,7 +71,10 @@ void func_wireless(void)
 
     while (func_cb.sta == FUNC_WIRELESS) {
         func_wireless_process();
-        func_wireless_message(msg_dequeue());
+        if (bTransmitEn)
+        {
+            func_wireless_message(msg_dequeue());
+        }
     }
 
     func_wireless_exit();

project/solution/ble_hid_composite/functions/msg_wireless.c → project/solution/ble_hid_composite/app/msg_wireless.c

@@ -8,8 +8,8 @@ void func_wireless_message_do(u16 msg)
             break;
 
         case MSG_SYS_1S: {
-            // printf("MSG_SYS_1S\n");
-            // wireless_send_ctrl_cmd(WIRELESS_CTRL_CMD_CODE_TEST, 10, (u8 *)0x18000);
+            printf("MSG_SYS_1S\n");
+            wireless_send_ctrl_cmd(WIRELESS_CTRL_CMD_CODE_TEST, 10, (u8 *)0x18000);
         }
         break;
 

project/solution/ble_hid_composite/modules/ble/ble_proc.c → project/solution/ble_hid_composite/ble/ble_proc.c

@@ -61,7 +61,9 @@ AT(.text.app.proc.ble)
 void ble_app_proc(void)
 {
     ble_user_service_proc();
+#if USB_EN
     ble_hid_service_proc();
+#endif // USB_EN
 }
 
 AT(.com_sleep.ble.sleep)

project/solution/ble_hid_composite/bsp/bsp_param.h

@@ -15,9 +15,14 @@
 #define PARAM_WL_ADDR_INFO_LEN      7
 #define PARAM_WL_BT_MODE            (PARAM_WL_ADDR_INFO + PARAM_WL_ADDR_INFO_LEN)           //1BYTE
 #define PARAM_WL_BT_MODE_LEN        1
-
 #define PARAM_BLE_CENTRAL_ADDR      (PARAM_WL_BT_MODE + PARAM_WL_BT_MODE_LEN)               //7BYTE
 #define PARAM_BLE_CENTRAL_ADDR_LEN  7
+#define TOUCH_CONFIG_ADDR           (PARAM_BLE_CENTRAL_ADDR + PARAM_BLE_CENTRAL_ADDR_LEN)
+#define TOUCH_CONFIG_LEN            36
+#define TOUCH_CHIP_TYPE_ADDR        (TOUCH_CONFIG_ADDR + TOUCH_CONFIG_LEN)
+#define TOUCH_CHIP_TYPE_LEN          1
+#define TOUCH_HASH_FLAG_ADDR         (TOUCH_CHIP_TYPE_ADDR + TOUCH_CHIP_TYPE_LEN)
+#define TOUCH_HASH_FLAG_LEN          4
 
 
 void bsp_param_init(void);

project/solution/ble_hid_composite/bsp/bsp_sys.c

@@ -10,6 +10,11 @@ xcfg_cb_t xcfg_cb;
 sys_cb_t sys_cb AT(.buf.bsp.sys_cb);
 u16 tmr5ms_cnt;
 
+#if WIRELESS_TRANSMIT_EN
+bool bTransmitEn = true;
+#else
+bool bTransmitEn = false;
+#endif // WIRELESS_TRANSMIT_EN
 
 AT(.text.bsp.sys.dbg)
 void sys_flash_guid_dump(void)
@@ -251,6 +256,8 @@ void bsp_sys_init(void)
     func_cb.sta = FUNC_WIRELESS;
 
     printf("%s, %d\n",__func__, func_cb.sta);
+
+    WDT_EN();
 }
 
 void bsp_periph_init(void)

project/solution/ble_hid_composite/bsp/bsp_sys.h

@@ -20,6 +20,7 @@ typedef struct {
 } sys_cb_t;
 
 extern sys_cb_t sys_cb;
+extern bool bTransmitEn;
 
 void bsp_sys_init(void);
 void bsp_periph_init(void);

project/solution/ble_hid_composite/config.h

@@ -31,7 +31,7 @@
 #define SYS_SLEEP_TIME                  0                      	        //自动休眠时间(秒), 0为不自动休眠
 #define SYS_OFF_TIME                    0                               //自动关机时间(秒), 0为不自动关机
 #define SYS_PWRUP_TIME                  0                               //长按开机时间(毫秒), 0为立即开机
-#define BSP_UART_DEBUG_EN               PRINTF_PB3                      //串口打印调试使能[Baud=1500000]
+#define BSP_UART_DEBUG_EN               PRINTF_PB9                      //串口打印调试使能[Baud=1500000]
 #define BSP_ADKEY_EN                    0                               //AD按键使能[Default: PB0]
 #define BSP_IOKEY_EN                    0                               //IO按鍵使能[WK0:PP;]
 #define BSP_CHARGE_EN                   0                               //充电功能使能

project/solution/ble_hid_composite/touch/AutoTest.c

@@ -0,0 +1,147 @@
+/*
+ * AutoTest.c
+ *
+ *  Created on: Jun 13, 2024
+ *      Author: Administrator
+ */
+#include "TouchInclude.h"
+
+#if AUTO_TEST
+TEST_STATE TestState;
+/*********************************************************************
+ * @fn      EXTI0_INT_INIT
+ *
+ * @brief   Initializes EXTI0 collection.
+ *
+ * @return  none
+ */
+void EXTI0_INT_INIT(void)
+{
+    EXTI_InitTypeDef EXTI_InitStructure = {0};
+    //NVIC_InitTypeDef NVIC_InitStructure = {0};
+
+    GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource5);
+    EXTI_InitStructure.EXTI_Line = EXTI_Line5;
+    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Event;//EXTI_Mode_Interrupt;
+    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
+    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
+    EXTI_Init(&EXTI_InitStructure);
+    EXTI->INTENR |= EXTI_INTENR_MR5;
+//    NVIC_InitStructure.NVIC_IRQChannel = EXTI7_0_IRQn;
+//    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
+//    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
+//    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
+//    NVIC_Init(&NVIC_InitStructure);
+}
+AT(.com_text.gpio_isr)
+void gpio_isr_callback(void)
+{
+    gpio_edge_pending_clear();
+
+    printf(info);
+}
+
+void io_interrupt_init(void)
+{
+    gpio_edge_cap_typedef config;
+
+    config.edge = GPIO_EDGE_FALLING;
+    config.gpiox = IOKEY_PORT;
+    config.gpio_pin = IOKEY_PIN;
+
+    gpio_edge_capture_config(&config);
+
+    gpio_edge_pic_config(gpio_isr_callback, 0);
+}
+
+void AutoTestInit(void)
+{
+    GPIO_InitTypeDef GPIO_InitStructure = {0};
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
+    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
+
+    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
+    GPIO_InitStructure.GPIO_Pin = TEST_START_PIN;
+    GPIO_Init(GPIOA, &GPIO_InitStructure);
+
+    GPIO_SetBits(GPIOB, TEST_BUSY_PIN);
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
+    GPIO_InitStructure.GPIO_Pin = TEST_BUSY_PIN;
+    GPIO_Init(GPIOB, &GPIO_InitStructure);
+
+    GPIO_SetBits(GPIOA, TEST_OK_PIN);
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
+    GPIO_InitStructure.GPIO_Pin = TEST_OK_PIN;
+    GPIO_Init(GPIOA, &GPIO_InitStructure);
+
+    GPIO_SetBits(GPIOA, TEST_NG_PIN);
+    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
+    GPIO_InitStructure.GPIO_Pin = TEST_NG_PIN;
+    GPIO_Init(GPIOA, &GPIO_InitStructure);
+
+    TestState = TEST_INIT;
+
+    EXTI0_INT_INIT();
+}
+
+
+
+TEST_STATE GetTestState(void)
+{
+    return TestState;
+}
+
+
+void ReturnTestResult(BOOL rst)
+{
+    if(rst)//OK
+    {
+        GPIO_ResetBits(GPIOA, TEST_OK_PIN);
+        GPIO_SetBits(GPIOA, TEST_NG_PIN);
+    }
+    else //NG
+    {
+        GPIO_SetBits(GPIOA, TEST_OK_PIN);
+        GPIO_ResetBits(GPIOA, TEST_NG_PIN);
+    }
+    TestState = TEST_FINISH;
+    GPIO_SetBits(GPIOB, TEST_BUSY_PIN);
+}
+
+void AutoTestHandle(void)
+{
+    if(EXTI_GetITStatus(EXTI_Line5)!=RESET)
+    {
+        if(TestState==TEST_INIT || TestState==TEST_FINISH)
+        {
+            GPIO_ResetBits(GPIOB, TEST_BUSY_PIN);
+            TestState = TEST_READY;
+        }
+
+        EXTI_ClearITPendingBit(EXTI_Line5);     /* Clear Flag */
+    }
+}
+
+//void EXTI7_0_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
+//
+///*********************************************************************
+// * @fn      EXTI0_IRQHandler
+// *
+// * @brief   This function handles EXTI0 Handler.
+// *
+// * @return  none
+// */
+//void EXTI7_0_IRQHandler(void)
+//{
+//  if(EXTI_GetITStatus(EXTI_Line5)!=RESET)
+//  {
+//     GPIO_ResetBits(GPIOB, TEST_BUSY_PIN);
+//
+//     TestState = TEST_READY;
+//     EXTI_ClearITPendingBit(EXTI_Line5);     /* Clear Flag */
+//     //GPIO_SetBits(GPIOB, TEST_BUSY_PIN);
+//  }
+//}
+
+#endif

project/solution/ble_hid_composite/touch/BerlinTouch.c

@@ -0,0 +1,689 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : IIC.c
+* Author             : WCH
+* Version            : V1.0
+* Date               : 2018/12/12
+* Description        : I2C 读写
+*******************************************************************************/
+
+
+/*********************************************************************
+ * INCLUDES
+ */
+#include "typedef.h"
+#include "TouchInclude.h"
+
+#define READ_TOUCH_POS_EVT                  0x0001
+#define READ_RESET_TOUCH_IC_EVT             0x0002
+#define SYS_INIT_FINISH_EVT                 0x0004
+#define RELEASE_TOUCH_EVT                   0x0008
+#define READ_ONE_POINT_EVT                  0x0010
+#define START_REPORT_POS_EVT                0x0020
+#define CHECK_TOUCH_INT_EVT                 0x0040
+#define REPORT_AGAIN_EVT                    0x0080
+#define CHECK_ESD_EVT                       0x0100
+#define HID_DEBUG_EVT                       0x0200
+#define CHECK_USB_STATUS_EVT                0x0400
+
+#define PERIO_1s 1600
+#define PERIO_2s (PERIO_1s*2)
+#define PERIO_5s (PERIO_1s*5)
+#define PERIO_40s (PERIO_1s*40)
+
+
+#pragma pack(1)
+typedef struct
+{
+    UINT8 Reserved0:3;
+    UINT8 FPEvent:1;
+    UINT8 HotknotEvent:1;
+    UINT8 GestureEvent:1;
+    UINT8 RequestEvent:1;
+    UINT8 TouchEvent:1;
+
+    UINT8 INTCounter;
+
+    UINT8 TouchNum:4;
+    UINT8 LargeTouch:1;
+    UINT8 HoverApproachFlag:1;
+    UINT8 EdgeFlag:1;
+    UINT8 ReseINT:1;
+
+    UINT8 CustomCoorInfoFlag:1;
+    UINT8 StylusKey:3;
+    UINT8 Reserved1:4;
+
+    UINT8 StylusPower;
+    UINT8 Reserved3;
+    UINT16 CheckSum;
+}ST_EVENT_HEAD;
+
+#pragma pack(1)
+typedef struct{
+    UINT8 rom_pid[6];               /* rom PID */
+    UINT8 rom_vid[3];               /* Mask VID */
+    UINT8 rom_vid_reserved;
+    UINT8 patch_pid[8];              /* Patch PID */
+    UINT8 patch_vid[4];              /* Patch VID */
+    UINT8 patch_vid_reserved;
+    UINT8 sensor_id;
+    UINT8 reserved[2];
+    UINT16 checksum;
+}ST_FW_VERSION;
+
+static UINT8 IICTouchTaskId = INVALID_TASK_ID;
+static UINT8 PointNum = 0;
+static UINT8 ReadPointCnt = 0;
+static BOOL ReportPosSuccess = TRUE;
+static void ReadOnePoint(void);
+static void CheckTouchINT(void);
+static void StartReportPos(void);
+static void ReportPos(void);
+static UINT16 IICTouch_ProcessEvent( UINT8 task_id, UINT16 events );
+static void BT_Check_ESD();
+
+#ifdef MOUSE_REPORT
+  #ifndef GESTURE
+  extern UINT8 mouse_right_click_time;
+  #endif
+#ifndef GESTURE
+  extern void ReportMousePos(POINTER * pTP);
+#else
+  void ReportMousePos(POINTER * pTP, UINT8 interface);
+#endif
+
+  BOOL StylusFlag;
+#endif
+
+static BOOL SysInitFinish = FALSE;
+extern BOOL SleepEn;
+/*******************************************************************************
+* Function Name  : BT_WR_Reg
+* Description    : 向GT911写入一次数据
+* Input          : reg:起始寄存器地址
+                   buf:数据缓缓存区
+                   len:写数据长度
+* Output         : None
+* Return         : 0,成功;1,失败.
+*******************************************************************************/
+__attribute__((section(".highcode")))
+UINT8 BT_WR_Reg(UINT32 reg,UINT8 *buf,UINT8 len)
+{
+    return IICWriteBytes(reg,buf,len);
+}
+
+///*******************************************************************************
+//* Function Name  : BT_RD_Reg
+//* Description    : 从GT911读出一次数据
+//* Input          : reg:起始寄存器地址
+//                   buf:数据缓缓存区
+//                   len:读数据长度
+//* Output         : None
+//* Return         : None
+//*******************************************************************************/
+//__attribute__((section(".highcode")))
+UINT8 BT_RD_Reg(UINT32 reg, UINT8 *buf,UINT8 len)
+{
+    return IICReadBytes(reg, buf, len);
+}
+
+
+
+static void ShutdownHIDI2C()
+{
+    UINT8 nTryTimes = 50;
+
+    if(IICWriteOneByte(0x3030AABB, 0xCC))
+    {
+        delay_ms(80);
+        while(nTryTimes--)
+        {
+          if(SearchAddress(100))
+            break;
+          delay_ms(10);
+        }
+    }
+}
+
+BOOL EntryUpdateMode()
+{
+    UINT8 tryTimes = 3,i;
+
+    UINT8 cmd[6] = {0x00,0x00,0x00,0x02,0x01,0x00};
+
+    UINT32 state1,state2;
+
+    gpio_reset_bits(GPIOA_REG, RST_PIN);
+    delay_ms(20);//RST
+    gpio_set_bits(GPIOA_REG, RST_PIN);
+    delay_ms(15);//RST
+    GioInterruptFlag = 0;
+    if(!SearchAddress(100))
+    {
+        return FALSE;
+    }
+    while(tryTimes--)
+    {
+        IICWriteBytes(0x00000002, cmd + 4, 2);
+        cmd[2] = 0x20;
+        cmd[3] = 0x00;
+
+        IICReadBytes(0x00002000, (UINT8*)&state1, 4);
+        for(i=0; i<3; i++)
+        {
+            IICReadBytes(0x00002000, (UINT8*)&state2, 4);
+
+            if(state1 != state2)
+            {
+                break;
+            }
+        }
+        if(i==3) return TRUE;
+    }
+    return FALSE;
+}
+
+
+static void CheckTouchChipType(void)
+{
+    UINT8 i;
+    ST_FW_VERSION  fw;
+
+    for(i=0; i<100; i++)
+    {
+        if(IICReadBytes(0x1000C, (UINT8*)&fw, sizeof(fw)))
+        {
+          if(GetCheckSum8((UINT8*)&fw,  sizeof(fw)-2)==fw.checksum)
+          {
+             PRINT("pid1=%s\n", fw.patch_pid);
+             if(fw.patch_pid[0] == '9' && fw.patch_pid[1] == '8' && fw.patch_pid[2] == '9' && fw.patch_pid[3] == '7' )
+             {
+                 ChipType = CHIP_TYPE_BERLINA;
+                 break;
+             }
+          }
+        }
+        if(IICReadBytes(0x10014, (UINT8*)&fw, sizeof(fw)))
+        {
+          if(GetCheckSum8((UINT8*)&fw, sizeof(fw)-2)==fw.checksum)
+          {
+             PRINT("pid2=%s\n", fw.patch_pid);
+             if((fw.patch_pid[0]=='2' && fw.patch_pid[1] == '9' && fw.patch_pid[2] == '3' && (fw.patch_pid[3] == '3' || fw.patch_pid[3] == '6'))
+              ||(fw.patch_pid[0]=='6' && fw.patch_pid[1] == '8' && fw.patch_pid[2] == '7' )
+              )
+             {
+                ChipType = CHIP_TYPE_BERLINB;
+                break;
+             }
+             else if(fw.patch_pid[0]=='2' && fw.patch_pid[1] == '9' && fw.patch_pid[2] == '3' && fw.patch_pid[3] == '1' )
+             {
+                 ChipType = CHIP_TYPE_BERLIND;
+                 break;
+             }
+          }
+        }
+    }
+    if(i==10)
+    {
+        PRINT("Chip type unknown\n");
+
+        if(!IsBerlinChipType(ChipType))
+        {
+            ChipType = CHIP_TYPE_BERLIND;
+        }
+    }
+}
+
+
+/*******************************************************************************
+* Function Name  : BT_Init
+* Description    : 触摸板初始化，获取ID，确认是否工作
+* Input          : None
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void BT_Init(void)
+{
+    TouchProc = CheckTouchINT;
+
+    CheckPos = MAX_POINT;
+
+    CheckTouchChipType();
+
+    if(ChipType==CHIP_TYPE_BERLINB || ChipType==CHIP_TYPE_BERLIND)
+    {
+        ShutdownHIDI2C();
+    }
+
+    if (IICTouchTaskId == INVALID_TASK_ID)
+    {
+      IICTouchTaskId = TMOS_ProcessEventRegister(IICTouch_ProcessEvent);
+      tmos_set_event(IICTouchTaskId, HID_DEBUG_EVT);
+    }
+
+    tmos_start_task(IICTouchTaskId, CHECK_ESD_EVT, PERIO_2s );
+    tmos_start_task(IICTouchTaskId, SYS_INIT_FINISH_EVT, PERIO_40s );
+
+    PRINT("sys init\n");
+}
+
+
+static void BT_Check_ESD()
+{
+
+  UINT32 reg_addr = 0x10170;
+  if(ChipType==CHIP_TYPE_BERLINA)
+  {
+      reg_addr = 0x10168;
+  }
+
+
+  if(!enable_ESD_check) return;
+
+  if(IICReadOneByte(reg_addr) == 0xAA)
+  {
+      PRINT("BT Check ESD Error!\n");
+      ResetTouchChip(); //Rstart touch ic
+  }
+  else
+  {
+      IICWriteOneByte(reg_addr, 0xAA);
+  }
+}
+
+
+static void ClearTouchFlag()
+{
+  UINT32 reg_addr = 0x10274;
+
+  if(ChipType == CHIP_TYPE_BERLINA)
+  {
+      reg_addr = 0x10338;
+  }
+  else  if(ChipType == CHIP_TYPE_BERLIND)
+  {
+      reg_addr = 0x10308;
+  }
+
+
+  if(!IsDebugMode && !ReleaseFlag)
+  {
+      IICWriteOneByte(reg_addr, 0);            //清标志
+  }
+}
+void BT_SetTouchEvent()
+{
+
+  tmos_set_event(IICTouchTaskId, CHECK_TOUCH_INT_EVT);
+}
+
+
+
+static UINT16 IICTouch_ProcessEvent( UINT8 task_id, UINT16 events )
+{
+    //BOOL bSuccess = TRUE;;
+    if(events & REPORT_AGAIN_EVT)
+    {
+      ReportPos();
+      events ^= REPORT_AGAIN_EVT;
+      goto OUT_FUMC;
+    }
+
+    if(events & START_REPORT_POS_EVT)
+    {
+      //PRINT("SR");
+      StartReportPos();
+      events ^= START_REPORT_POS_EVT;
+      goto OUT_FUMC;
+    }
+
+    if(events & READ_ONE_POINT_EVT)
+    {
+      ReadOnePoint();
+      events ^= READ_ONE_POINT_EVT;
+
+      //有中断，取消USB检测
+      events &= ~CHECK_USB_STATUS_EVT;
+      tmos_stop_task(IICTouchTaskId, CHECK_USB_STATUS_EVT);
+
+      goto OUT_FUMC;
+    }
+
+    if(events & CHECK_TOUCH_INT_EVT)
+    {
+      //PRINT("TI");
+
+      CheckTouchINT();
+      events ^= CHECK_TOUCH_INT_EVT;
+
+      if(PointNum == 0 && SysInitFinish) //松键
+      {
+        tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s ); //1s后开启USB检测
+      }
+
+      goto OUT_FUMC;
+    }
+
+    if(events & CHECK_ESD_EVT)
+    {
+      //PRINT("esd check\n");
+      BT_Check_ESD();
+      events ^= CHECK_ESD_EVT;
+      tmos_start_task(IICTouchTaskId, CHECK_ESD_EVT, PERIO_2s );
+      goto OUT_FUMC;
+    }
+
+    if(events & SYS_INIT_FINISH_EVT)
+    {
+      SysInitFinish = TRUE;
+
+      events ^= SYS_INIT_FINISH_EVT;
+      tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s);
+      goto OUT_FUMC;
+    }
+
+    if(events & CHECK_USB_STATUS_EVT)
+    {
+
+      events ^= CHECK_USB_STATUS_EVT;
+
+      if(CheckUsbStatus())
+      {
+          tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_5s );//避免系统重连慢造成反复复位重连
+      }
+      else {
+          tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s );
+      }
+
+
+      goto OUT_FUMC;
+    }
+
+    if(events & HID_DEBUG_EVT)
+    {
+      CommandHandle();
+      events ^= HID_DEBUG_EVT;
+      tmos_set_event(task_id, HID_DEBUG_EVT);
+      goto OUT_FUMC;
+    }
+
+    return 0;
+
+OUT_FUMC:
+
+    return  events;
+}
+
+
+
+static void CheckTouchINT()
+{
+  //UINT8 PointNum;
+
+  ST_EVENT_HEAD event_head;
+
+  UINT32 reg_addr = 0x10274;
+
+  if(ChipType == CHIP_TYPE_BERLINA)
+  {
+      reg_addr = 0x10338;
+  }
+  else  if(ChipType == CHIP_TYPE_BERLIND)
+  {
+      reg_addr = 0x10308;
+  }
+
+
+  StylusFlag = FALSE;
+
+  IICReadBytes(reg_addr, (UINT8*)&event_head, sizeof(ST_EVENT_HEAD));
+
+  if(event_head.TouchEvent==0 && !ReleaseFlag)
+  {
+     IICWriteOneByte(reg_addr, 0);                               //清标志,如果延迟较长可以去掉
+
+     return ;
+  }
+
+  PointNum = event_head.TouchNum;
+
+  TouchNum = 0;
+
+
+  if(PointNum > MAX_POINT)   PointNum = MAX_POINT;
+
+
+#ifdef MOUSE_REPORT
+    StylusFlag = FALSE;
+#endif
+    NoTouchTimer = 0;
+
+    ReadPointCnt = 0;
+
+    OutRangeFlag = 0xFFFF;
+
+    Press_Flag = 0;
+
+    if(PointNum==0)
+    {
+      tmos_set_event(IICTouchTaskId, START_REPORT_POS_EVT);
+    }
+    else
+    {
+      tmos_set_event(IICTouchTaskId, READ_ONE_POINT_EVT);
+    }
+}
+
+//__attribute__((section(".highcode")))
+static void ReadOnePoint()
+{
+    UINT8 buf[13];
+    UINT8 index;
+    UINT16 tmp;
+
+    UINT32 reg_addr = 0x10274;
+
+    if(ChipType == CHIP_TYPE_BERLINA)
+    {
+        reg_addr = 0x10338;
+    }
+    else  if(ChipType == CHIP_TYPE_BERLIND)
+    {
+        reg_addr = 0x10308;
+    }
+    reg_addr += (ReadPointCnt<<3) + sizeof(ST_EVENT_HEAD);
+
+    IICReadBytes(reg_addr, buf, 8);
+
+#ifdef STYLUS_REPORT
+    if(buf[0]&0x80)
+    {
+      BT_RD_Reg(BT_GSTID_REG + (PointNum << 3) ,buf+7,6);     //stylus keY
+
+      StylusPress = ((UINT16)buf[6]<<8)+buf[5] ; //stylus pressure
+
+      StylusFlag = TRUE;
+
+      if((DeviceMode!=DEVICE_MODE_MOUSE) && (BleDeviceMode!=DEVICE_MODE_MOUSE) && (!UartReportPosEn))
+      {
+        Press_Flag = (((UINT16)buf[12] & 0xFC) << 8) | 0x8000;
+
+        buf[0] =9;//&= 0x7F;
+        index = 9;
+      }
+      else
+      {
+        if(StylusPress==0)
+          goto OUT_FUNC;
+
+        ShareBuf[0] =0;
+        index = 0;
+      }
+    }
+    else
+#endif
+    {//查找和上次相同Press_Flag的索引位置
+      for(index=0; index<10; index++)
+      {
+        if(((Press_Flag_Bak0 & (1L<<index))!= 0) && TP[ index ].Contact_Identifier == (buf[0]>>4))
+        {
+          break; //
+        }
+      }
+
+      if(index>=10)//没有找到配对位置，找一个空位
+      {
+        for(index=0; index<10; index++)
+        {
+          if(((Press_Flag_Bak0 | Press_Flag ) & (1L<<index)) == 0)
+          {
+            break; //
+          }
+        }
+      }
+    }
+
+    if(index>=10) goto OUT_FUNC; //没有空位
+
+    if((Press_Flag & 0x8000) && buf[0] == 9) //stylus Press_Flag
+    {
+    #ifdef STYLUS_TILT
+      StylusTiltX = ((UINT16)buf[8]<<8)+buf[7] ;
+      StylusTiltY = ((UINT16)buf[10]<<8)+buf[9] ;
+    #endif
+    }
+    else
+    {
+      tmp = ((UINT16)buf[7]<<8)+buf[6];
+      if(tmp==0)
+      {
+        goto OUT_FUNC;
+      }
+    }
+
+
+  #ifdef AUTO_ADJUST_SOLUTION
+    if(bSolutionValid)
+    {
+      TP[index].X_pos = (UINT32)(((UINT16)buf[2]<<8)+buf[1] ) * (RESOLUTION_X-1) / wMaxX;
+      TP[index].Y_pos = (UINT32)(((UINT16)buf[4]<<8)+buf[3] ) * (RESOLUTION_Y-1) / wMaxY;
+    }
+    else
+  #else
+    {
+      TP[index].X_pos = ( ((UINT16)buf[3]<<8)+buf[2] );
+      TP[index].Y_pos = ( ((UINT16)buf[5]<<8)+buf[4] );
+    }
+  #endif
+
+    TP[index].X_pos_back = TP[index].X_pos;
+    TP[index].Y_pos_back = TP[index].Y_pos;
+#ifdef NEW_REVOLVE_PROTOCAL
+    if (PosConvert(TP, index) == FALSE)  //超出黑边的坐标返回FALSE，裁剪掉
+      goto OUT_FUNC;
+#endif
+    TP[ index ].Tip_Switch = 1;
+
+    Press_Flag |= ((UINT16)1<<index);
+
+    TP[ index ].Contact_Identifier = buf[0]>>4;
+
+
+OUT_FUNC:
+    ReadPointCnt++;
+
+    if(ReadPointCnt >= PointNum)
+    {
+      tmos_set_event(IICTouchTaskId, START_REPORT_POS_EVT);
+
+    }
+    else
+    {
+      tmos_set_event(IICTouchTaskId, READ_ONE_POINT_EVT);
+    }
+}
+//__attribute__((section(".highcode")))
+void StartReportPos()
+{
+  TouchNum = 0;
+  for(UINT8 i=0; i<MAX_POINT; i++)
+  {
+    if((Press_Flag & (((UINT16)1)<<i)) == 0)
+    {
+      TP[i].Tip_Switch = 0;
+    }
+    else
+    {
+      TouchNum++;
+    }
+  }
+
+#ifdef DOUBLECLIK_FILETER
+  if(TouchNum <= 1)  //&& (DeviceMode == DEVICE_MODE_MOUSE))
+  {
+    DoubleClickFilter(StylusFlag, 0);
+  }
+  else
+  {
+    DoubleClickTimer = 100;
+  }
+#endif
+  Press_Flag &= OutRangeFlag;
+  Press_Flag_Bak0 = Press_Flag;
+  Press_Flag |= Press_Flag_Bak1|Press_Flag_Bak2;//|Press_Flag_Bak3;
+
+#ifdef CALL_OSD_MENU
+  CallOSDMenu();    //双指在右下角下滑，串口上报命令调用OSD菜单
+#endif
+#ifdef GESTURE
+  if ( DeviceMode == DEVICE_MODE_MOUSE || BleDeviceMode == DEVICE_MODE_MOUSE)
+  {
+    WheelMove();
+
+    if (TwoPointsClick() == 1)
+    {
+      bclickFlag = 1;
+    }
+  }
+#endif
+
+  ReportPos();
+}
+
+
+//__attribute__((section(".highcode")))
+static void ReportPos()
+{
+  //static UINT8 nUSBFailedTimes = 0;
+  ReportPosSuccess = TRUE;
+
+  if(UsbReportPosEn || BleReportPosEn)
+  {
+    if(((DeviceMode == DEVICE_MODE_MULTITOUCH) && (config.report_type != EN_MOUSE_ONLY)) || (config.report_type == EN_MULTITOUCH_ONLY))
+    {
+      Absolute_Up_Pack(TP);
+    }
+    else if(config.report_type != EN_MULTITOUCH_ONLY)
+    {
+      ReportMousePos(TP);
+    }
+  }
+#ifdef UART_ENABLE
+  else if(UartReportPosEn)
+  {
+    UartUpdatePos( &TP[0]);
+  }
+#endif
+
+    ClearTouchFlag();
+
+    Press_Flag_Bak3 = Press_Flag_Bak2;
+    Press_Flag_Bak2 = Press_Flag_Bak1;
+    Press_Flag_Bak1 = Press_Flag_Bak0;
+
+    tmos_stop_task( IICTouchTaskId, REPORT_AGAIN_EVT );
+
+}
+
+/*********************************************************************
+*********************************************************************/

project/solution/ble_hid_composite/touch/Gesture.c

@@ -0,0 +1,624 @@
+/********************************** (C) COPYRIGHT ******************************
+* File Name          :usb_driver.h
+* Author             : DL
+* Version            : V1.1
+* Date               : 2020/06/02
+* Description        : A demo for USB compound device created by CH552, support
+					   touch panel , and HID-compliant device.
+********************************************************************************/
+#include "TouchInclude.h"
+
+UINT16  wTwoPointsCoorYBak[2];	 //备份Y坐标，用来判断角落是否有两指滑动
+BOOL bTwoFingersMoveDown = 0;	 //双指下滑
+UINT8  byTwoTouch = 0;            //双指按下计算用
+
+extern UINT8 TouchNum;
+
+#ifdef GESTURE
+UINT8 byTouchNumberChange = 0;  //双指点击时记录手指数变化
+UINT8 byTouchTime1 = 0;	        //单指点击时计时
+UINT8 byTouchTime2 = 0;	        //双指点击时计时
+UINT16 wCoorXBak[5];	        //备份X坐标，用来判断是否有滑动
+UINT16 wCoorYBak[5];	        //备份Y坐标，用来判断是否有滑动
+UINT8 byFirstTouch = 0;	        //用于双指第一次按下去抖
+BOOL bMoveFlag = 0;		        //双指滑动标志
+BOOL bclickFlag = 0;	        //双指点击标志
+UINT8 byWheelUpDown = 0;        //双指滑动后滚轮上下滚动标志
+
+#define LEFT_RIGHT_MOVE_DIS 600
+#define UP_DOWN_MOVE_DIS 600
+#define FIVE_MOVE_DIS 400
+UINT8 byFourTouch = 0;
+UINT8 byFiveTouch = 0;
+UINT8 FourfingersGesture(void);
+UINT8 byLeftRightMoveFlag = 0;  //左右滑动的标志
+UINT8 byUpDownMoveFlag = 0;  //上下滑动的标志
+BOOL bUpDowntMoveCtrl = 0;	 //上下滑动，上报键值之后要上报ctrl键
+UINT16 wDisCoorX[4];
+UINT16 wDisCoorY[4];
+UINT16 wDisCoorXbak[4];
+UINT16 wDisCoorYbak[4];
+BOOL bFiveFingersMoveInFlag = 0;
+BOOL bFiveFingersMoveOutFlag = 0;
+extern UINT8 TouchNumBak;
+extern BOOL bTwoFingerCoorBak;
+extern UINT8 TouchCount;		   //手指按下帧数记录，要延迟3帧才上报鼠标
+
+/*******************************************************************************
+* Function Name  : WheelMove
+* Description    : 检测双指滑动
+* Input          : None
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void WheelMove()
+{
+	byWheelUpDown = 0; 	//每次清0重新判断
+
+	if (TouchNum == 0)
+	{
+		byFirstTouch = 0;
+	}
+	else if (TouchNum == 2)
+	{
+
+		if (byFirstTouch == 0)
+		{
+			byFirstTouch++;		  //要去抖一次，否则坐标不对
+		}
+		else if(byFirstTouch == 1)
+		{
+
+			byFirstTouch = 3;
+
+			wCoorXBak[0] = TP[0].X_pos;			 //备份坐标，用来做距离判断滑动
+			wCoorXBak[1] = TP[1].X_pos;
+
+			wCoorYBak[0] = TP[0].Y_pos;
+			wCoorYBak[1] = TP[1].Y_pos;
+		}
+		else if (byFirstTouch > 1)
+		{
+			//左右滑动也要判断，以免识别成点击
+			if (TP[0].X_pos + 100 < wCoorXBak[0] && TP[1].X_pos + 100 < wCoorXBak[1])
+			{
+				bMoveFlag = 1;	 //置滑动标志，有滑动就不会识别成点击
+			}
+			else if (TP[0].X_pos > wCoorXBak[0] + 100 && TP[1].X_pos > wCoorXBak[1] + 100)
+			{
+				bMoveFlag = 1;
+			}
+			else if (TP[0].Y_pos + 20 < wCoorYBak[0] && TP[1].Y_pos + 20 < wCoorYBak[1])	//Up
+			{
+				bMoveFlag = 1;
+
+				byWheelUpDown = 1;
+			}
+			else if (TP[0].Y_pos > wCoorYBak[0] + 20 && TP[1].Y_pos > wCoorYBak[1] + 20)   //Down
+			{
+				bMoveFlag = 1;
+
+				byWheelUpDown = 2;
+			}
+
+			if (bMoveFlag)		//有滑动了，重新备份坐标来判断距离
+			{
+				wCoorXBak[0] = TP[0].X_pos;
+				wCoorXBak[1] = TP[1].X_pos;
+
+				wCoorYBak[0] = TP[0].Y_pos;
+				wCoorYBak[1] = TP[1].Y_pos;
+			}
+		}
+	}
+}
+
+ /*******************************************************************************
+* Function Name  : TwoPointsClick
+* Description    : 检测双指点击，有下面4种情况：
+					1、双指同时点击，同时松开
+					2、双指同时点击，松开时一指先离开，另一指再离开
+					3、单指先触摸到，紧接着双指触摸，双指同时松开
+					4、单指先触摸到，紧接着双指触摸，松开时一指先离开，另一指再离开
+* Input          : None
+* Output         : None
+* Return         : 1：双指双击 other：无效
+*******************************************************************************/
+UINT8 TwoPointsClick()
+{
+	UINT8 flag = 0xff;
+
+	if (bMoveFlag == 1)	   //双指有滑动，直接退出检测
+	{
+		byTouchNumberChange = 0;
+		return(flag);
+	}
+
+	if (TouchNum == 0)	   //没有手指，已松键
+	{
+		//双指同时按下同时松开，并且触摸时间在400ms内
+        if ((byTouchNumberChange == 2) && (byTouchTime2 < 10))
+		{
+		    //CH552UART0SendByte(0xbb);
+			flag = 1;
+
+		}
+		//两指同时按下，松开过程先变一指再松开，触摸时间在400ms内
+		else if ((byTouchNumberChange == 3) && (byTouchTime1 < 10))
+		{
+		    //CH552UART0SendByte(0xbb);
+			flag = 1;
+
+		}
+		//按下时先单指接触再变两指接触，松开过程不管，触摸时间在400ms内
+		else if ((byTouchNumberChange == 4) && (byTouchTime1 < 20) && (byTouchTime2 < 10))
+		{
+			//CH552UART0SendByte(0xbb);
+			flag = 1;
+		}
+
+		byTouchNumberChange = 0;
+		byTouchTime1 = 0;
+		byTouchTime2 = 0;
+	}
+	else if ((TouchNum == 1) && (byTouchNumberChange != 0xFF))	  //检测到单指触摸
+	{
+        if (byTouchNumberChange == 0)	   //如果之前没有触摸，说明在按下的过程先是一指触摸
+		{
+			byTouchNumberChange = 1;
+			byTouchTime1 = 0;
+		}
+		else if (byTouchNumberChange == 2)	//如果之前是两指触摸，说明在松开的过程先是一指离开
+		{
+		    byTouchNumberChange = 3;
+		}
+
+		flag = 2;
+
+	}
+	else if ((TouchNum == 2) && (byTouchNumberChange != 0xFF))	   //检测到两指触摸
+	{
+		if (byTouchNumberChange == 0)	   //如果之前没有触摸，说明在按下的过程是两指同时触摸
+		{
+			byTouchNumberChange = 2;
+			byTouchTime1 = 0;
+			byTouchTime2 = 0;
+		}
+		else if (byTouchNumberChange == 1)	 //如果之前先识别到一指触摸，说明在按下的过程是一指变两指
+		{
+			byTouchNumberChange = 4;
+			byTouchTime2 = 0;
+		}
+
+		flag = 2;
+	}
+	else	//其他手指数则非法
+	{
+	    byTouchNumberChange = 0xFF;
+		byTouchTime1 = 0;
+		byTouchTime2 = 0;
+		flag = 0;
+	}
+	return(flag);
+}
+
+
+void BackUpXPos()
+{
+	UINT8 i;
+	for (i = 0; i < 5; i++)
+	{
+		wCoorXBak[i] = TP[i].X_pos;
+	}
+}
+
+void BackUpYPos()
+{
+	UINT8 i;
+	for (i = 0; i < 5; i++)
+	{
+		wCoorYBak[i] = TP[i].Y_pos;
+	}
+}
+
+UINT16 GetAbs(UINT16 a, UINT16 b)
+{
+	return a > b ? a - b : b - a;
+}
+
+
+
+void ReportKey()
+{
+	#if (DEBUG!=Debug_USB)
+		if (!IsBLEConnected() || BleReportPosEn == DISABLE)
+	#else
+		if (((!BleReportFirst) && EnumOK) || !IsBLEConnected() || BleReportPosEn == DISABLE)
+	#endif
+	{
+
+		R8_UEP3_T_LEN = 9;
+		R8_UEP3_CTRL = (R8_UEP3_CTRL & (~ MASK_UEP_T_RES)) | UEP_T_RES_ACK;
+	}
+	else
+	{
+		HidDev_Report(HID_RPT_ID_KEY_IN, HID_REPORT_TYPE_INPUT, 8, &pEP3_RAM_Addr[1]);
+	}
+}
+
+UINT8 FourfingersGesture()
+{
+	UINT8 i;
+	UINT8 xmoveincount = 0;
+	UINT8 ymoveincount = 0;
+	UINT8 xmoveoutcount = 0;
+	UINT8 ymoveoutcount = 0;
+
+	memset(pEP3_RAM_Addr, 0, 9);
+	pEP3_RAM_Addr[0] = HID_RPT_ID_KEY_IN;
+
+
+
+	//CH552UART0SendByte(TouchNum);
+	//PRINT("Touch=%d\n", TouchNum);
+	if (TouchNum == 0)
+	{
+		byLeftRightMoveFlag = 0;   //clean move flag
+		byUpDownMoveFlag = 0;
+		bFiveFingersMoveInFlag = 0;
+		bFiveFingersMoveOutFlag = 0;
+
+		if (byFourTouch || byFiveTouch)
+		{
+			if (byFourTouch == 3 || byFiveTouch == 3)	 //松键第一帧
+			{
+				pEP3_RAM_Addr[1] = 1;	 //上报Ctrl
+			}
+			else
+			{
+				pEP3_RAM_Addr[1] = 0;
+
+				//防止鼠标判断有误，需要清除以下标志
+				TouchNumBak = 0;
+				TouchCount = 0;
+				bTwoFingerCoorBak = 0;
+			}
+
+			ReportKey();
+
+			if (byFourTouch)
+				byFourTouch--;
+
+			if (byFiveTouch)
+				byFiveTouch--;
+
+			return 1;
+		}
+	}
+	else if (TouchNum == 4)
+	{
+
+		if (byFourTouch == 0 )
+		{
+			byFourTouch++;
+		}
+		else if (byFourTouch == 1)
+		{
+			byFiveTouch = 0;
+
+			BackUpXPos();
+			BackUpYPos();
+
+			byFourTouch = 3;
+
+			pEP3_RAM_Addr[1] = 1;		//Ctrl
+
+			ReportKey();
+
+		}
+		else if (byFourTouch > 1)
+		{
+			//上报了键值，要紧接着上报一帧Ctrl键，否则系统会识别长按键，键值功能失效
+			if (bUpDowntMoveCtrl)
+			{
+				bUpDowntMoveCtrl = 0;
+				//byFourTouch = 2;  //这里上报了Ctrl，松键的时候就不上报Ctrl了
+
+				pEP3_RAM_Addr[1] = 1;	 //上报Ctrl
+
+				ReportKey();
+			}
+
+			if (TP[0].X_pos + LEFT_RIGHT_MOVE_DIS < wCoorXBak[0] && TP[1].X_pos + LEFT_RIGHT_MOVE_DIS < wCoorXBak[1]
+				&& TP[2].X_pos + LEFT_RIGHT_MOVE_DIS < wCoorXBak[2] /*&& TP[3].X_pos + LEFT_RIGHT_MOVE_DIS < wCoorXBak[3]*/) //left
+			{
+			   	//CH552UART0SendByte(0xF5);
+
+				if (byLeftRightMoveFlag == 0 || byLeftRightMoveFlag == 2)
+				{
+					byLeftRightMoveFlag = 1;
+
+					pEP3_RAM_Addr[1] = 0x01;	//Ctrl
+					pEP3_RAM_Addr[3] = 0x4f;//0x50;	//<-
+
+					ReportKey();
+				}
+				BackUpXPos();
+			}
+			else if (TP[0].X_pos > wCoorXBak[0] + LEFT_RIGHT_MOVE_DIS && TP[1].X_pos > wCoorXBak[1] + LEFT_RIGHT_MOVE_DIS
+					&& TP[2].X_pos > wCoorXBak[2] + LEFT_RIGHT_MOVE_DIS/* && TP[3].X_pos > wCoorXBak[3] + LEFT_RIGHT_MOVE_DIS*/)  //right
+			{
+
+				//CH552UART0SendByte(0xF6);
+
+				if (byLeftRightMoveFlag == 0 || byLeftRightMoveFlag == 1)
+				{
+					byLeftRightMoveFlag = 2;
+
+					pEP3_RAM_Addr[1] = 0x01;	//Ctrl
+					pEP3_RAM_Addr[3] = 0x50;//0x4f;	//->
+
+					ReportKey();
+				}
+				BackUpXPos();
+			}
+			else if (TP[0].Y_pos + UP_DOWN_MOVE_DIS < wCoorYBak[0] && TP[1].Y_pos + UP_DOWN_MOVE_DIS < wCoorYBak[1]
+					&& TP[2].Y_pos + UP_DOWN_MOVE_DIS < wCoorYBak[2] /*&& TP[3].Y_pos + UP_DOWN_MOVE_DIS < wCoorYBak[3]*/)	//Up
+			{
+
+				if (byUpDownMoveFlag == 0 || byUpDownMoveFlag == 2)
+				{
+					byUpDownMoveFlag = 1;
+					bUpDowntMoveCtrl = 1;
+
+					pEP3_RAM_Addr[1] = 0x01;	//Ctrl
+					pEP3_RAM_Addr[3] = 0x52;	//up
+
+					ReportKey();
+				}
+				BackUpYPos();
+			}
+			else if (TP[0].Y_pos > wCoorYBak[0] + UP_DOWN_MOVE_DIS && TP[1].Y_pos > wCoorYBak[1] + UP_DOWN_MOVE_DIS
+					&& TP[2].Y_pos > wCoorYBak[2] + UP_DOWN_MOVE_DIS /*&& TP[3].Y_pos > wCoorYBak[3] + UP_DOWN_MOVE_DIS*/)   //Down
+			{
+
+				if (byUpDownMoveFlag == 0 || byUpDownMoveFlag == 1)
+				{
+					byUpDownMoveFlag = 2;
+					bUpDowntMoveCtrl = 1;
+
+					pEP3_RAM_Addr[1] = 0x01;	//Ctrl
+					pEP3_RAM_Addr[3] = 0x51;	//down
+
+					ReportKey();
+				}
+				BackUpYPos();
+			}
+		}
+		return 1;
+	}
+	else if (TouchNum == 5)			//五指手势识别
+	{
+
+		if (byFiveTouch == 0 )
+		{
+			byFiveTouch++;
+		}
+		else if (byFiveTouch == 1)
+		{
+			byFourTouch = 0;
+
+			BackUpXPos();
+			BackUpYPos();
+
+			byFiveTouch = 3;
+
+			pEP3_RAM_Addr[1] = 1;		//Ctrl
+
+			ReportKey();
+
+		}
+		else if (byFiveTouch > 1)
+		{
+			for (i = 0; i < 3; i++)
+			{
+				wDisCoorX[i] = GetAbs(TP[i].X_pos, TP[i + 2].X_pos);
+				wDisCoorY[i] = GetAbs(TP[i].Y_pos, TP[i + 2].Y_pos);
+
+				wDisCoorXbak[i] = GetAbs(wCoorXBak[i], wCoorXBak[i + 2]);
+				wDisCoorYbak[i] = GetAbs(wCoorYBak[i], wCoorYBak[i + 2]);
+			}
+
+			wDisCoorX[3] = GetAbs(TP[0].X_pos, TP[4].X_pos);
+			wDisCoorY[3] = GetAbs(TP[0].Y_pos, TP[4].Y_pos);
+
+			wDisCoorXbak[3] = GetAbs(wCoorXBak[0], wCoorXBak[4]);
+			wDisCoorYbak[3] = GetAbs(wCoorYBak[0], wCoorYBak[4]);
+
+
+			//=======================Close========================//
+			for (i = 0; i < 4; i++)
+			{
+				if (wDisCoorX[i] + FIVE_MOVE_DIS < wDisCoorXbak[i])
+				{
+					xmoveincount++;
+				}
+
+				if (wDisCoorY[i] + FIVE_MOVE_DIS < wDisCoorYbak[i])
+				{
+					ymoveincount++;
+				}
+			}
+
+			if ((xmoveincount + ymoveincount >= 3))
+			{
+
+				if (bFiveFingersMoveInFlag == 0)
+				{
+					bFiveFingersMoveInFlag = 1;
+
+					pEP3_RAM_Addr[1] = 1;		//Ctrl
+					pEP3_RAM_Addr[3] = 0x05;	//B
+
+					ReportKey();
+				}
+				BackUpXPos();
+				BackUpYPos();
+			}
+
+			//=======================Open========================//
+			for (i = 0; i < 4; i++)
+			{
+				if (wDisCoorX[i] > wDisCoorXbak[i] + FIVE_MOVE_DIS)
+				{
+					xmoveoutcount++;
+				}
+
+				if (wDisCoorY[i] > wDisCoorYbak[i] + FIVE_MOVE_DIS)
+				{
+					ymoveoutcount++;
+				}
+			}
+
+			if (xmoveoutcount + ymoveoutcount >= 3)
+			{
+				//CH552UART0SendByte(0xF3);
+
+				if (bFiveFingersMoveOutFlag == 0)
+				{
+					bFiveFingersMoveOutFlag = 1;
+
+					pEP3_RAM_Addr[1] = 1;		//Ctrl
+					pEP3_RAM_Addr[3] = 0x05;	//B
+
+					ReportKey();
+				}
+				BackUpXPos();
+				BackUpYPos();
+			}
+		}
+		return 1;
+	}
+	else if (byFourTouch || byFiveTouch)
+	{
+		return 1;
+	}
+	return 0;
+}
+#endif
+
+
+#ifdef DOUBLECLIK_FILETER
+extern UINT16 Press_Flag;
+extern UINT16 Press_Flag_Bak1;
+extern UINT16 Press_Flag_Bak2;
+extern UINT16 StylusPress;
+UINT8 DoubleClickTimer = 0;
+
+void DoubleClickFilter(BOOL flag, UINT8 id)
+{
+	 static UINT16 PrePointX = 0xFFFF, PrePointY = 0xFFFF;
+	 //static UINT16 PreStylusPressure = 0;
+	 UINT16 Range = 240;
+	 //static UINT8 ID;
+
+#if USBCONFIG
+	 if(config.mouse_double_click_en ==0)
+	   return;
+#endif
+
+	 if(flag)
+	 {
+		 Range = 150;
+	 }
+
+
+	 if(DoubleClickTimer < 5)// || DoubleClickFlag)  //400ms以内连续单指Touch
+	 {
+		 if(TP[id].X_pos < PrePointX + Range && TP[id].X_pos + Range > PrePointX
+			 && TP[id].Y_pos < PrePointY + Range && TP[id].Y_pos + Range > PrePointY)
+		 {
+			 //ID = id;
+
+			 TP[id].X_pos = PrePointX;
+
+			 TP[id].Y_pos = PrePointY;
+
+		 }
+		 else
+		 {
+			 DoubleClickTimer = 100;
+		 }
+
+	 }
+	 else
+	 {
+		 PrePointX = TP[id].X_pos;
+		 PrePointY = TP[id].Y_pos;
+	 }
+
+	 if((Press_Flag&Press_Flag_Bak1&Press_Flag_Bak2)==0 && !flag)
+	 {
+		 DoubleClickTimer = 0;
+	 }
+}
+#endif
+
+#ifdef CALL_OSD_MENU
+//双指在右下角下滑，串口上报命令调用OSD菜单
+#define X_RANGE	10916
+#define Y_RANGE 6400
+
+UINT8 CallOsdMenuCmd[10] = {0x55, 0x56, 0xd1, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x27};
+
+void CallOSDMenu()
+{
+	UINT16 x_range = X_RANGE;
+	if (TouchNum == 0)
+	{
+		byTwoTouch = 0;
+
+		if (bTwoFingersMoveDown)
+		{
+			bTwoFingersMoveDown = 0;
+
+			USART2_SendData(CallOsdMenuCmd, 10);
+		}
+	}
+	else if (TouchNum == 2)
+	{
+		if(TpOption.uart_cmd == UART_COMMAND_A_90
+		||TpOption.uart_cmd == UART_COMMAND_B_90
+		||TpOption.uart_cmd == UART_COMMAND_A_270
+		||TpOption.uart_cmd == UART_COMMAND_B_270
+		)
+		{
+			x_range = RESOLUTION_X/2;
+		}
+
+		if (TP[0].X_pos_back > x_range && TP[0].Y_pos_back > Y_RANGE && TP[1].X_pos_back > x_range && TP[1].Y_pos_back > Y_RANGE)
+		{
+			if (byTwoTouch == 0)
+			{
+				byTwoTouch++;
+			}
+			else if (byTwoTouch == 1)
+			{
+				wTwoPointsCoorYBak[0] = TP[0].Y_pos_back;
+				wTwoPointsCoorYBak[1] = TP[1].Y_pos_back;
+
+				byTwoTouch++;
+			}
+			else if (byTwoTouch > 1)
+			{
+				if (TP[0].Y_pos_back > wTwoPointsCoorYBak[0] + 320
+					&& TP[1].Y_pos_back > wTwoPointsCoorYBak[1] + 320)
+				{
+					 //CH552UART0SendByte(0x66);
+					 bTwoFingersMoveDown = 1;
+				}
+			}
+		}
+	}
+}
+#endif

project/solution/ble_hid_composite/touch/GoodixTouch.c

@@ -0,0 +1,631 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : IIC.c
+* Author             : WCH
+* Version            : V1.0
+* Date               : 2018/12/12
+* Description        : I2C 读写
+*******************************************************************************/
+
+
+/*********************************************************************
+ * INCLUDES
+ */
+#include "include.h"
+
+#define READ_TOUCH_POS_EVT                  0x0001
+#define READ_RESET_TOUCH_IC_EVT             0x0002
+#define SYS_INIT_FINISH_EVT                 0x0004
+#define RELEASE_TOUCH_EVT                   0x0008
+#define READ_ONE_POINT_EVT                  0x0010
+#define START_REPORT_POS_EVT                0x0020
+#define CHECK_TOUCH_INT_EVT                 0x0040
+#define REPORT_AGAIN_EVT                    0x0080
+#define CHECK_ESD_EVT                       0x0100
+#define HID_DEBUG_EVT                       0x0200
+#define CHECK_USB_STATUS_EVT                0x0400
+
+#define PERIO_1s 1600
+#define PERIO_2s (PERIO_1s*2)
+#define PERIO_5s (PERIO_1s*5)
+#define PERIO_40s (PERIO_1s*40)
+
+static UINT8 IICTouchTaskId = INVALID_TASK_ID;
+static UINT8 PointNum = 0;
+static UINT8 ReadPointCnt = 0;
+static BOOL ReportPosSuccess = TRUE;
+
+static void ReadOnePoint(void);
+//static void CheckTouchINT(void);
+static void StartReportPos(void);
+static void ReportPos(void);
+static UINT16 IICTouch_ProcessEvent( UINT8 task_id, UINT16 events );
+static void CheckTouchChipType();
+static void CheckTouchINT(void);
+
+#ifdef MOUSE_REPORT
+  #ifndef GESTURE
+  extern UINT8 mouse_right_click_time;
+  #endif
+#ifndef GESTURE
+  extern void ReportMousePos(POINTER * pTP);
+#else
+  void ReportMousePos(POINTER * pTP, UINT8 interface);
+#endif
+
+  static BOOL StylusFlag;
+#endif
+
+static BOOL SysInitFinish = FALSE;
+
+//BOOL GT_Check_I2C_Address()
+//{
+//    BOOL bRet;
+//
+//    IIC_Start();
+//
+//    bRet = IIC_Send_Byte(GT_CMD_WR);     //发送写命令
+//
+//    IIC_Stop();
+//
+//    return bRet;
+//}
+
+
+static void ShutdownHIDI2C()
+{
+    IICWriteBytes( 0x8000, ShareBuf + 1, 1);
+    ShareBuf[0]=0xAA;
+    ShareBuf[1]=0;
+    ShareBuf[2]=0x56;
+
+    IICWriteBytes( 0x8041, ShareBuf + 1, 2);
+    IICWriteBytes( 0x8040, ShareBuf, 1);//关闭HID-I2C功能
+
+    IICWriteBytes( 0x824E, ShareBuf + 1, 1);
+}
+
+/*******************************************************************************
+* Function Name  : GT_Init
+* Description    : 触摸板初始化，获取ID，确认是否工作
+* Input          : None
+* Output         : None
+* Return         : None
+*******************************************************************************/
+void GT_Init(void)
+{
+    //TouchProc = CheckTouchINT;
+
+    //CheckPos = MAX_POINT;
+    CheckTouchChipType();
+
+    if(ChipType == CHIP_TYPE_73XX)//新版7387必须要先关掉hid才能读取版本号
+    {
+      delay_ms(500);
+      ShutdownHIDI2C();
+      delay_ms(40);
+      ShutdownHIDI2C();
+      delay_ms(40);
+      ShutdownHIDI2C();
+    }
+
+
+    if(ChipType == CHIP_TYPE_9XXX || ChipType == CHIP_TYPE_9PXX)
+    {
+        gpio_reset_bits(GPIOA_REG, INT_PIN);
+        gpio_set_out(GPIOA_REG, INT_PIN);
+
+        delay_ms(60);//RST
+
+        gpio_set_input(GPIOA_REG, INT_PIN);
+    }
+
+
+    if (IICTouchTaskId == INVALID_TASK_ID)
+    {
+      IICTouchTaskId = TMOS_ProcessEventRegister(IICTouch_ProcessEvent);
+      tmos_set_event(IICTouchTaskId, HID_DEBUG_EVT);
+    }
+//
+    //PRINT("enable esd check\n");
+    tmos_start_task(IICTouchTaskId, CHECK_ESD_EVT, PERIO_2s );
+    tmos_start_task(IICTouchTaskId, SYS_INIT_FINISH_EVT, PERIO_40s );
+}
+
+
+void GT_Check_ESD()
+{
+    UINT8 tmp;
+
+
+    if(!enable_ESD_check) return;
+
+    if (!IICReadBytes(0x8044, &tmp, 1) || tmp == 0x03)
+    {
+      PRINT("GT Check ESD Error!\n");
+      ResetTouchChip();
+
+      return;
+    }
+    else if(!IICReadBytes(0x8040,&tmp,1) || tmp == 0xAA)
+    {
+      PRINT("GT Check ESD Error!\n");
+      ResetTouchChip(); //Rstart touch ic
+
+      return;
+    }
+    else
+    {
+      tmp = 0xAA;
+      IICWriteOneByte(0x8040,tmp);
+    }
+
+}
+
+
+static void CheckTouchChipType()
+{
+    UINT8 i;
+    UINT8 pid[8];
+
+    for(i=0; i<10; i++)
+    {
+        if(IICReadBytes(0x8240, pid, 4))
+        {
+            if((pid[0] ==  '7'&& pid[1] ==  '3'&& pid[2] ==  '8' && pid[3] ==  '8')
+            || (pid[0] ==  '7'&& pid[1] ==  '3'&& pid[2] ==  '8' && pid[3] ==  '7')
+            )
+            {
+                ChipType = CHIP_TYPE_73XX;
+                break;
+            }
+        }
+        if(IICReadBytes(0x8140, pid, 4))
+        {
+           if((pid[0] ==  '9'&& pid[1] ==  '1'&& pid[2] ==  '1'))
+           {
+               ChipType = CHIP_TYPE_9XXX;
+               break;
+           }
+           else if((pid[0] ==  '7'&& pid[1] ==  '2'&& pid[2] ==  '8' && pid[3] ==  '8')
+                   || (pid[0] ==  '9'&& pid[1] ==  '2'&& pid[2] ==  '8' && pid[3] ==  '6')
+                   )
+           {
+               ChipType = CHIP_TYPE_9XXX;
+               break;
+           }
+        }
+    }
+    if(i==10)
+    {
+        PRINT("Chip type unknow\n");
+
+        if(IsBerlinChipType(ChipType))
+        {
+            ChipType = CHIP_TYPE_9XXX;
+        }
+    }
+}
+
+
+
+static void ClearTouchFlag()
+{
+  UINT16 addr;
+
+  if(ChipType == CHIP_TYPE_73XX)
+  {
+    addr = 0x824e;
+  }
+  else
+  {
+    addr = 0x814e;
+  }
+#ifdef CHIP_TYPE_GT738X
+  if(!IsDebugMode)
+#else
+  if(!IsDebugMode)
+#endif
+  {
+      UINT8 temp = 0;
+      IICWriteBytes(addr,&temp,1);             //清标志
+
+  }
+
+}
+void GT_SetTouchEvent()
+{
+  tmos_set_event(IICTouchTaskId, CHECK_TOUCH_INT_EVT);
+}
+//
+
+static UINT16 IICTouch_ProcessEvent( UINT8 task_id, UINT16 events )
+{
+    //BOOL bSuccess = TRUE;;
+    if(events & REPORT_AGAIN_EVT)
+    {
+      ReportPos();
+      events ^= REPORT_AGAIN_EVT;
+      goto OUT_FUMC;
+    }
+
+    if(events & START_REPORT_POS_EVT)
+    {
+      //PRINT("SR");
+      StartReportPos();
+      events ^= START_REPORT_POS_EVT;
+      goto OUT_FUMC;
+    }
+
+    if(events & READ_ONE_POINT_EVT)
+    {
+      ReadOnePoint();
+      events ^= READ_ONE_POINT_EVT;
+
+      //有中断，取消USB检测
+      events &= ~CHECK_USB_STATUS_EVT;
+      tmos_stop_task(IICTouchTaskId, CHECK_USB_STATUS_EVT);
+
+      goto OUT_FUMC;
+    }
+
+    if(events & CHECK_TOUCH_INT_EVT)
+    {
+      //PRINT("TI");
+      CheckTouchINT();
+      events ^= CHECK_TOUCH_INT_EVT;
+
+      if(PointNum == 0 &&  SysInitFinish) //松键
+      {
+        tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s ); //1s后开启USB检测
+      }
+
+      goto OUT_FUMC;
+    }
+
+    if(events & CHECK_ESD_EVT)
+    {
+      //PRINT("esd check\n");
+      GT_Check_ESD();
+      events ^= CHECK_ESD_EVT;
+      //PRINT("enable esd check\n");
+      tmos_start_task(IICTouchTaskId, CHECK_ESD_EVT, PERIO_2s );
+      goto OUT_FUMC;
+    }
+
+    if(events & SYS_INIT_FINISH_EVT)
+    {
+
+        SysInitFinish = TRUE;
+      events ^= SYS_INIT_FINISH_EVT;
+      tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s);
+      goto OUT_FUMC;
+    }
+
+    if(events & CHECK_USB_STATUS_EVT)
+    {
+      events ^= CHECK_USB_STATUS_EVT;
+
+      if(CheckUsbStatus())
+       {
+           tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_5s );//避免系统重连慢造成反复复位重连
+       }
+       else {
+           tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s );
+       }
+
+      goto OUT_FUMC;
+    }
+
+//    if(events & HID_DEBUG_EVT)
+//    {
+//      CommandHandle();
+//      events ^= HID_DEBUG_EVT;
+//      tmos_set_event(task_id, HID_DEBUG_EVT);
+//      goto OUT_FUMC;
+//    }
+
+    return 0;
+
+OUT_FUMC:
+
+    return  events;
+}
+//
+//
+static void CheckTouchINT(void)
+{
+    UINT8 point_num;
+
+    UINT16 addr;
+
+    if(ChipType == CHIP_TYPE_73XX)
+    {
+      addr = 0x824e;
+    }
+    else
+    {
+      addr = 0x814e;
+    }
+
+    IICReadBytes(addr,&point_num,1);                //读取触摸点的状态
+#ifdef CHIP_TYPE_GT738X
+    if((( point_num & BIT7 ) == 0 || (point_num & 0x0F)> MAX_POINT) && !ReleaseFlag)                                      /* 正常不会执行这个的,表示GT芯片是否准备好 */
+#else
+    if((( point_num & BIT7 ) == 0 || (point_num & 0x0F)> MAX_POINT))                                      /* 正常不会执行这个的,表示GT芯片是否准备好 */
+#endif
+    {
+      point_num = 0;
+      IICWriteBytes(addr,&point_num,1);              //清标志,如果延迟较长可以去掉
+      return;
+    }
+#ifdef MOUSE_REPORT
+    StylusFlag = FALSE;
+#endif
+    NoTouchTimer = 0;
+
+    PointNum = point_num & 0x0F;
+
+    ReadPointCnt = 0;
+
+    OutRangeFlag = 0xFFFF;
+
+    Press_Flag = 0;
+
+
+//    if(PointNum==0)
+//    {
+//      StartReportPos();
+//    }
+//    else
+//    {
+//      ReadOnePoint();
+//    }
+    if(PointNum==0)
+    {
+      tmos_set_event(IICTouchTaskId, START_REPORT_POS_EVT);
+
+    }
+    else
+    {
+      tmos_set_event(IICTouchTaskId, READ_ONE_POINT_EVT);
+    }
+
+}
+
+//__attribute__((section(".highcode")))
+static void ReadOnePoint()
+{
+  UINT8 buf[13];
+  UINT8 index;
+  UINT16 tmp;
+    //UINT8 tmp8;
+  UINT16 reg_addr = GT_POINT_BASE_ADDR + ReadPointCnt * 8;
+
+  if(ChipType == CHIP_TYPE_73XX)
+  {
+    reg_addr = 0x824F + ReadPointCnt * 8;
+  }
+  else
+  {
+    reg_addr = 0x814F + ReadPointCnt * 8;
+  }
+
+
+  IICReadBytes( reg_addr, buf, 7 );
+
+#ifdef STYLUS_REPORT
+    if(buf[0]&0x80)
+    {
+      GT_RD_Reg(GT_GSTID_REG + (PointNum << 3) ,buf+7,6);     //stylus keY
+
+      StylusPress = ((UINT16)buf[6]<<8)+buf[5] ; //stylus pressure
+
+      StylusFlag = TRUE;
+
+      if((DeviceMode!=DEVICE_MODE_MOUSE) && (!UartReportPosEn))
+      {
+        Press_Flag = (((UINT16)buf[12] & 0xFC) << 8) | 0x8000;
+
+        buf[0] =9;//&= 0x7F;
+        index = 9;
+      }
+      else
+      {
+        if(StylusPress==0)
+          goto OUT_FUNC;
+
+        ShareBuf[0] =0;
+        index = 0;
+      }
+    }
+    else
+#endif
+    {//查找和上次相同Press_Flag的索引位置
+      for(index=0; index<10; index++)
+      {
+        if(((Press_Flag_Bak0 & (1L<<index))!= 0) && TP[ index ].Contact_Identifier == buf[0])
+        {
+          break; //
+        }
+      }
+
+      if(index>=10)//没有找到配对位置，找一个空位
+      {
+        for(index=0; index<10; index++)
+        {
+          if(((Press_Flag_Bak0 | Press_Flag ) & (1L<<index)) == 0)
+          {
+            break; //
+          }
+        }
+      }
+    }
+
+    if(index>=10) goto OUT_FUNC; //没有空位
+
+    if((Press_Flag & 0x8000) && buf[0] == 9) //stylus Press_Flag
+    {
+    #ifdef STYLUS_TILT
+      StylusTiltX = ((UINT16)buf[8]<<8)+buf[7] ;
+      StylusTiltY = ((UINT16)buf[10]<<8)+buf[9] ;
+    #endif
+    }
+    else
+    {
+      tmp = ((UINT16)buf[6]<<8)+buf[5];
+      if(tmp==0)
+      {
+        goto OUT_FUNC;
+      }
+    }
+
+
+  #ifdef AUTO_ADJUST_SOLUTION
+    if(bSolutionValid)
+    {
+      TP[index].X_pos = (UINT32)(((UINT16)buf[2]<<8)+buf[1] ) * (RESOLUTION_X-1) / wMaxX;
+      TP[index].Y_pos = (UINT32)(((UINT16)buf[4]<<8)+buf[3] ) * (RESOLUTION_Y-1) / wMaxY;
+    }
+    else
+  #else
+    {
+      TP[index].X_pos = ( ((UINT16)buf[2]<<8)+buf[1] );
+      TP[index].Y_pos = ( ((UINT16)buf[4]<<8)+buf[3] );
+    }
+  #endif
+
+  TP[index].X_pos_back = TP[index].X_pos;
+  TP[index].Y_pos_back = TP[index].Y_pos;
+
+#ifdef NEW_REVOLVE_PROTOCAL
+  if (PosConvert(TP, index) == FALSE)  //超出黑边的坐标返回FALSE，裁剪掉
+    goto OUT_FUNC;
+#endif
+    TP[ index ].Tip_Switch = 1;
+
+    Press_Flag |= ((UINT16)1<<index);
+
+    TP[ index ].Contact_Identifier = buf[0];
+
+
+OUT_FUNC:
+    ReadPointCnt++;
+
+    if(ReadPointCnt >= PointNum)
+    {
+      tmos_set_event(IICTouchTaskId, START_REPORT_POS_EVT);
+        //StartReportPos();
+
+    }
+    else
+    {
+        //ReadOnePoint();
+      tmos_set_event(IICTouchTaskId, READ_ONE_POINT_EVT);
+    }
+}
+__attribute__((section(".highcode")))
+void StartReportPos()
+{
+  TouchNum = 0;
+  for(UINT8 i=0; i<MAX_POINT; i++)
+  {
+    if((Press_Flag & (((UINT16)1)<<i)) == 0)
+    {
+      TP[i].Tip_Switch = 0;
+    }
+    else
+    {
+      TouchNum++;
+    }
+  }
+
+#ifdef DOUBLECLIK_FILETER
+  if(TouchNum <= 1)  //&& (DeviceMode == DEVICE_MODE_MOUSE))
+  {
+    DoubleClickFilter(StylusFlag, 0);
+  }
+  else
+  {
+    DoubleClickTimer = 100;
+  }
+#endif
+  Press_Flag &= OutRangeFlag;
+  Press_Flag_Bak0 = Press_Flag;
+  Press_Flag |= Press_Flag_Bak1|Press_Flag_Bak2;//|Press_Flag_Bak3;
+
+#ifdef CALL_OSD_MENU
+  CallOSDMenu();    //双指在右下角下滑，串口上报命令调用OSD菜单
+#endif
+#ifdef GESTURE
+  if ( DeviceMode == DEVICE_MODE_MOUSE )
+  {
+    WheelMove();
+
+    if (TwoPointsClick() == 1)
+    {
+      bclickFlag = 1;
+    }
+  }
+#endif
+
+  ReportPos();
+}
+
+
+//__attribute__((section(".highcode")))
+static void ReportPos()
+{
+  //static UINT8 nUSBFailedTimes = 0;
+  ReportPosSuccess = TRUE;
+
+  if (UsbReportPosEn || bTransmitEn)
+  {
+    if (bTransmitEn && !UsbReportPosEn)
+    {
+    #ifdef UART_ENABLE
+      UartUpdatePos( &TP[0]);
+    #endif
+
+      Absolute_Up_Pack(TP);
+    }
+    else if(((DeviceMode == DEVICE_MODE_MULTITOUCH) && (config.report_type != EN_MOUSE_ONLY)) || (config.report_type == EN_MULTITOUCH_ONLY))
+    {
+      Absolute_Up_Pack(TP);
+    }
+  #ifdef MOUSE_REPORT
+    else if(config.report_type != EN_MULTITOUCH_ONLY)
+    {
+      ReportMousePos(TP);
+    }
+  #endif
+
+  }
+#ifdef UART_ENABLE
+  //else if(UartReportPosEn)
+  //{
+  //  UartUpdatePos( &TP[0]);
+  //}
+#endif
+
+  if(ReportPosSuccess)// || (EnumOK==FALSE && IsBLEConnected()==FALSE))
+  {
+    ClearTouchFlag();
+
+    Press_Flag_Bak3 = Press_Flag_Bak2;
+    Press_Flag_Bak2 = Press_Flag_Bak1;
+    Press_Flag_Bak1 = Press_Flag_Bak0;
+
+    //tmos_stop_task( IICTouchTaskId, REPORT_AGAIN_EVT );
+
+    tmos_start_task(IICTouchTaskId, CHECK_USB_STATUS_EVT, PERIO_1s ); //1s后开启USB检测
+  }
+  else
+  {
+    //tmos_set_event(IICTouchTaskId, REPORT_AGAIN_EVT);
+    //tmos_start_task(IICTouchTaskId, REPORT_AGAIN_EVT,3);
+    //GPIOA_InverseBits(GPIO_Pin_2);
+  }
+}
+
+/*********************************************************************
+*********************************************************************/

project/solution/ble_hid_composite/touch/HidReport.c

@@ -0,0 +1,1076 @@
+/********************************** (C) COPYRIGHT ******************************
+* File Name          :usb_driver.C
+* Author             : DL
+* Version            : V1.1
+* Date               : 2018/10/21
+* Description        : A demo for USB compound device created by CH552, support
+					   touch panel , and HID-compliant device.
+********************************************************************************/
+#include "typedef.h"
+#include "TouchInclude.h"
+#include "usb_hid.h"
+#include "usb_desc.h"
+#include "api.h"
+#include "ble_hid_service.h"
+#include "app_hid_event.h"
+
+//#pragma  NOAREGS
+#define FLASH_Base   0x08004000
+#define APP_FALG_ADDR   (FLASH_Base - 256)
+#define HASH_FLAG_ADDR  (APP_FALG_ADDR + 4)
+
+//extern void GT_RD_Reg_HS(UINT16 reg,UINT8 *buf,UINT8 len);
+extern BOOL SearchAddress( UINT8 num );
+extern BOOL GetBondingMacAddr(UINT8* MacAddr);
+
+UINT8 TouchNum = 0;
+INT16 CheckPos = MAX_POINT;
+UINT8 Buffer_Queue;
+PACKAGE_INFO PackageInfo;
+UINT32 wReadAddress;
+UINT16 wReadLen;
+BOOL IsDebugMode;
+BOOL DisableDigiterInterface;
+
+BOOL OutDebugMode;
+UINT8 PenToFinger = 0;
+UINT8 const Version[] = VERSION;
+UINT8 print_log = 1;
+BOOL ReportExtInfoEn = 0;
+
+extern CHIP_TYPE ChipType;
+
+extern BOOL EnumOK;
+#ifdef STYLUS_TILT
+extern UINT16 StylusTiltX, StylusTiltY;
+#endif
+#define BOOT_ADDR  0x3800
+//void (*EnterUpdateMode)();
+
+//static UINT8 USBDebugTaskId = INVALID_TASK_ID;
+
+extern UINT8 DeviceMode;
+
+
+#ifdef CHIP_TYPE_GT738X
+extern void AppendReleaseFrame(void);
+#endif
+
+#ifdef UART_ENABLE
+extern UINT8 TxBuff[16];
+#endif
+
+#define DEF_USB_EP1_FS_SIZE     (PACKAGE_POINT_SIZE *(MAX_POINT/PACKAGE_POINT_NUM))
+#define DEF_USB_EP2_FS_SIZE 256
+UINT8 USBFS_EP1_Buf[DEF_USB_EP1_FS_SIZE + 10];
+
+
+UINT8 Absolute_Up_Pack( POINTER * pTP)
+{
+    UINT8 k,offset;
+	UINT8* p;
+
+    TouchNum = 0;
+
+    for(k = 0; k < MAX_POINT; k++)
+    {
+        if(Press_Flag & (1L << k))
+        {
+            TouchNum++;
+        }
+    }
+
+
+    memset(USBFS_EP1_Buf, 0 , DEF_USB_EP1_FS_SIZE);
+
+    k = 0;
+    CheckPos = MAX_POINT - 1;
+#ifdef STYLUS_REPORT
+    if(Press_Flag & 0x8000) //stylus
+    {
+		CheckPos--;
+
+        USBFS_EP1_Buf[k++] = HID_RPT_ID_STYLUS_IN;
+
+        USBFS_EP1_Buf[1] = 0;
+
+        if(pTP[9].Tip_Switch != 0 || (Press_Flag & 0x1000))
+        {
+            //if(pTP[9].Resolution_Multi==0)
+            {
+								//pTP[9].Resolution_Multi = 0;
+                USBFS_EP1_Buf[1] |= PEN_HOVER; //hover
+            }
+            if(StylusPress > 0 && (Press_Flag_Bak1 & 0x8000)!=0)
+            {
+                USBFS_EP1_Buf[1] |= PEN_TIP;//tip
+            }
+
+            if(Press_Flag & 0x1000)
+            {
+                USBFS_EP1_Buf[1] = PEN_HOVER | PEN_INVERT;
+
+                if(Press_Flag_Bak0 & Press_Flag_Bak1 & 0x1000)
+                {
+                  if(StylusPress > 0)
+                    USBFS_EP1_Buf[1] |= PEN_ERASER;
+                }
+
+                Press_Flag_Bak0 |= 0x8000;
+            }
+
+            if(Press_Flag & 0x2000)
+            {
+                USBFS_EP1_Buf[1] |= PEN_BARREL;
+            }
+        }
+
+
+        p = (UINT8*)(pTP + 9);
+		k++;
+        USBFS_EP1_Buf[k++] = p[2];
+        USBFS_EP1_Buf[k++] = p[3];
+        USBFS_EP1_Buf[k++] = p[4];
+        USBFS_EP1_Buf[k++] = p[5];
+        USBFS_EP1_Buf[k++] = StylusPress;
+        USBFS_EP1_Buf[k++] = StylusPress>>8;
+
+	#ifdef STYLUS_TILT
+		USBFS_EP1_Buf[k++] = (INT16)StylusTiltX / 20;
+		USBFS_EP1_Buf[k++] = (INT16)StylusTiltY / 20;
+	#endif
+		k = 4 + STYLUS_POINT_SIZE - (STYLUS_POINT_SIZE%4);
+
+    #if USB_HID_EN
+		usb_hid_buffer_push(EP_INDEX1, USBFS_EP1_Buf,STYLUS_POINT_SIZE);
+	#endif
+    }
+#endif
+
+    for(; CheckPos >= 0; CheckPos--)
+    {
+        offset = 0;
+        k = 0;
+        USBFS_EP1_Buf[k++] = HID_RPT_ID_TOUCH_IN;
+
+        for(; CheckPos >= 0; CheckPos--)
+        {
+
+            if(Press_Flag & (1L << CheckPos))
+            {
+        #if LE_HID_DIGITIZER
+            ble_hid_send_touch_cmd(pTP[CheckPos].Tip_Switch, CheckPos, pTP[CheckPos].X_pos, pTP[CheckPos].Y_pos);
+        #elif LE_HID_MOUSE
+            ble_hid_send_mouse_cmd(pTP[CheckPos].Tip_Switch,1, 1);
+        #endif
+                p = (UINT8*)(pTP + CheckPos);
+
+                USBFS_EP1_Buf[k++] = p[0] + (CheckPos << 4);//(p[1] << 4);//
+                USBFS_EP1_Buf[k++] = p[2];
+                USBFS_EP1_Buf[k++] = p[3];
+                USBFS_EP1_Buf[k++] = p[4];
+                USBFS_EP1_Buf[k++] = p[5];
+            }
+            if(k - offset >= PACKAGE_POINT_SIZE - 1)
+            {
+                break;
+            }
+        }
+        offset += PACKAGE_POINT_SIZE - 1;
+
+        if(offset < PACKAGE_POINT_SIZE * 2 - 1)
+        {
+  #ifdef STYLUS_REPORT
+            if(Press_Flag & 0x8000)
+            {
+                USBFS_EP1_Buf[offset] = TouchNum - 1;
+            }
+            else
+  #endif
+            {
+                USBFS_EP1_Buf[offset] = TouchNum;
+            }
+
+        }
+        else
+        {
+            USBFS_EP1_Buf[offset] = 0;
+        }
+#ifdef FIVE_POINTS_PACKAGE
+        offset += 2;  //4 bytes
+#else
+        offset++;
+#endif
+        if (bTransmitEn && !UsbReportPosEn)  //2.4G
+        {
+        #ifdef UART_ENABLE
+          if (TouchNum <= 5)
+          {
+            memcpy(&USBFS_EP1_Buf[DEF_USB_EP1_FS_SIZE], TxBuff, 10);
+            //RF_Enqueue(1, RF_PACKAGE_REPORT, PACKAGE_RAM_SIZE + 10, Ep1Buffer);
+            wireless_send_test(DEF_USB_EP1_FS_SIZE + 10, USBFS_EP1_Buf);
+          }
+          else
+        #endif
+          {
+            //RF_Enqueue(1, RF_PACKAGE_REPORT, offset, Ep1Buffer);
+            wireless_send_test(offset, USBFS_EP1_Buf);
+          }
+        }
+        else if(UsbReportPosEn)  //usb
+        {
+        #if USB_HID_EN
+           usb_hid_buffer_push(EP1_INDEX, USBFS_EP1_Buf,PACKAGE_POINT_SIZE);
+        #endif
+        }
+        else  //ble
+        {
+        #if LE_HID_MULTITOUCH
+            ble_hid_task_enqueue(BLE_HID_CMD_ID_MULTITOUCH, USBFS_EP1_Buf + 1, PACKAGE_POINT_SIZE - 1);
+        #endif
+        }
+    }
+    return 0;
+}
+
+
+#ifdef MOUSE_REPORT
+
+#ifndef GESTURE
+UINT8 mouse_right_click_time;
+
+
+UINT8 GetTouchNum()
+{
+  UINT8 k, num = 0;
+  for(k = 0; k < MAX_POINT; k++)
+  {
+    if(Press_Flag & (1L << k))
+    {
+      num++;
+    }
+  }
+  return num;
+}
+
+void TrigleEp3Input(UINT8 len, UINT8* pBuf)
+{
+#if USB_HID_EN
+  usb_hid_buffer_push(EP3_INDEX, pBuf, len);
+#endif
+}
+void TrigleEp4Input(UINT8 len, UINT8* pBuf)
+{
+#if USB_HID_EN
+    usb_hid_buffer_push(EP1_INDEX, pBuf, len);
+#endif
+}
+
+void ReportMousePos(POINTER * pTP)
+{
+  static UINT16 PrePointX = 0xFFFF, PrePointY = 0xFFFF, PrePointY1 = 0xFFFF;
+  static char nCnt = 0;
+  static  BOOL bRightClickFlag = 0;
+  UINT8 MouseReportBuffer[7];
+
+  TouchNum = GetTouchNum();
+
+  if(TouchNum == 0)
+  {
+    return;
+  }
+
+  if(((Press_Flag_Bak1 | Press_Flag_Bak2) & 0x3FF)==0) //��֡
+  {
+    PrePointX = pTP[0].X_pos;
+    PrePointY = pTP[0].Y_pos;
+    mouse_right_click_time = 0;
+    nCnt = 0;
+  }
+
+  if(TouchNum==2)
+  {
+    if(nCnt > 3)
+    {
+        MouseReportBuffer[0] = HID_RPT_ID_ABS_MOUSE_IN;
+        MouseReportBuffer[1] = 0;
+        TrigleEp4Input(ABS_MOUSE_PACKAGE_SIZE, MouseReportBuffer);
+        delay_ms(3);
+    }
+
+    MouseReportBuffer[4] = 0;
+    if((Press_Flag_Bak1 & Press_Flag_Bak2 & 0x3FF)==0)
+    {
+      PrePointY = TP[0].Y_pos;
+      PrePointY1 = TP[1].Y_pos;
+    }
+    if (TP[0].Y_pos + 256 < PrePointY && TP[1].Y_pos + 256  < PrePointY1) //Up
+    {
+        MouseReportBuffer[4] = 0xFF;
+    }
+    else if (TP[0].Y_pos > PrePointY + 256  && TP[1].Y_pos > PrePointY1 + 256 )   //Down
+    {
+        MouseReportBuffer[4] = 1;
+    }
+
+    if(MouseReportBuffer[4]!=0)
+    {
+        MouseReportBuffer[0] = HID_RPT_ID_MOUSE_IN;
+        MouseReportBuffer[1] = 0;
+        MouseReportBuffer[2] = 0;
+        MouseReportBuffer[3] = 0;
+
+      PrePointY = TP[0].Y_pos;
+      PrePointY1 = TP[1].Y_pos;
+
+      TrigleEp3Input(MOUSE_PACKAGE_SIZE, MouseReportBuffer);
+    }
+    nCnt = -5;
+  }
+  else if(nCnt > 3)
+  {
+  REPROT:
+      MouseReportBuffer[0] = HID_RPT_ID_ABS_MOUSE_IN;
+      MouseReportBuffer[2] = *(((PUINT8)&TP[0]) + 2);
+      MouseReportBuffer[3] = *(((PUINT8)&TP[0]) + 3);// p[1];
+      MouseReportBuffer[4] = *(((PUINT8)&TP[0]) + 4);//p[4];
+      MouseReportBuffer[5] = *(((PUINT8)&TP[0]) + 5);//p[3];
+      MouseReportBuffer[6] = 0;
+
+    if(nCnt==4) //��֡���뱨һ֡�ɼ�
+    {
+        MouseReportBuffer[1] = 0;
+      nCnt++;
+      TrigleEp4Input(ABS_MOUSE_PACKAGE_SIZE, MouseReportBuffer);
+      delay_ms(3);
+      bRightClickFlag = 0;
+    }
+
+    if(nCnt>=5)
+    {
+        MouseReportBuffer[1] = 1;
+
+      if(TP[0].X_pos < PrePointX + 200 && TP[0].X_pos + 200 > PrePointX //����
+       && TP[0].Y_pos < PrePointY + 200 && TP[0].Y_pos + 200 > PrePointY)
+      {
+        if(mouse_right_click_time>=16)
+        {
+          //USBFS_EP1_Buf[1] |= 0x02;
+          bRightClickFlag = 1;
+        }
+      }
+      else
+      {
+        PrePointX = 0xFFFF;
+      }
+      TrigleEp4Input(ABS_MOUSE_PACKAGE_SIZE, MouseReportBuffer);
+
+//      if(nCnt==8 && TP[0].Tip_Switch==0)
+//      {
+//        delay_ms(3);
+//      }
+
+      nCnt = 6;
+    }
+
+    if(TP[0].Tip_Switch==0)//�ɼ�
+    {
+    #if USBCONFIG
+      if(bRightClickFlag && !config.mouse_right_click_dis)
+    #else
+      if(bRightClickFlag)
+    #endif
+      {
+          MouseReportBuffer[1] = 0x03;
+          TrigleEp4Input(ABS_MOUSE_PACKAGE_SIZE, MouseReportBuffer);
+
+      }
+
+      delay_ms(5);
+      MouseReportBuffer[1] = 0;
+      Press_Flag_Bak1 = 0;
+      TrigleEp4Input(ABS_MOUSE_PACKAGE_SIZE, MouseReportBuffer);
+    }
+  }
+  else
+  {
+    if(nCnt>=0 && TP[0].Tip_Switch==0)//�ɼ�
+    {
+      nCnt = 4;
+      goto REPROT;
+    }
+    nCnt++;
+  }
+}
+#else
+ /*******************************************************************************
+* Function Name  : ReportMousePos
+* Description    : ƻ��ϵͳ��Щ��أ�
+					1����ָ����������������ʱ��Ҫ�ȱ�һ֡�ɿ������ܱ���������Ҫ���ɿ�
+					2��������Ҽ�������Ҽ�����Ҫ��2�Σ�������һֱ��̫�ࣨ���岻ȷ����������ɿ�
+* Input          : None
+* Output         : None
+* Return         : None
+*******************************************************************************/
+extern UINT8 byWheelUpDown;
+extern BOOL bclickFlag;
+extern BOOL bMoveFlag;
+UINT8 TouchNumBak;
+UINT16 Xcoorbak;
+UINT16 Ycoorbak;
+UINT8 TouchLeaveFlag = 0;
+BOOL bTwoFingerCoorBak = 0;
+UINT8 TouchCount = 0;		   //��ָ����֡����¼��Ҫ�ӳ�3֡���ϱ����
+//UINT8 byWheelStopCount = 0;    //����ֹͣ��3ֹ֡ͣ
+
+#ifdef CHIP_TYPE_GT738X
+extern BOOL ReleaseFlag;
+#endif
+
+UINT8 GetTouchNum()
+{
+	UINT8 k, num = 0;
+	for(k = 0; k < MAX_POINT; k++)
+	{
+		if(Press_Flag & (1L << k))
+		{
+			num++;
+		}
+	}
+	return num;
+}
+
+void ReportMousePos(POINTER * pTP, UINT8 interface)
+{
+	static UINT16 PrePointXBak = 0xFFFF, PrePointYBak = 0xFFFF;
+
+	//UINT8 i;
+	UINT8* p;
+	//UINT8 touchnumber = 0;
+
+
+
+	TouchNum = GetTouchNum();
+
+#ifdef CHIP_TYPE_GT738X
+	if(TouchNum ==0 )
+	{
+		if(!ReleaseFlag)
+		{
+			TouchNumBak = 0;
+			return;
+		}
+	}
+#endif
+
+	pEP3_RAM_Addr[0] = HID_RPT_ID_MOUSE_IN;
+
+	if (Press_Flag_Bak1==0)
+	{
+		TouchLeaveFlag++;
+		if (TouchLeaveFlag == 2)
+		{
+			bMoveFlag = 0;
+		}
+
+		if (TouchCount)
+		{
+			pEP3_RAM_Addr[1] = 1;
+			TouchCount = 0;
+		}
+		else
+		{
+			if (bclickFlag == 1)
+			{
+				pEP3_RAM_Addr[1] = 0x02;
+				bclickFlag = 0;
+			}
+			else
+			{
+				pEP3_RAM_Addr[1] = 0;
+			}
+			TouchNumBak = 0;
+			//TouchCount = 0;
+
+			bTwoFingerCoorBak = 0;
+			//return;
+		}
+	}
+
+	if(!(Press_Flag_Bak0&0x3FF) && (Press_Flag_Bak1&0x3FF))
+	{
+		if (TouchCount > 3)
+		{
+			pEP3_RAM_Addr[1] = 1;
+			TouchCount = 0;
+		}
+
+		if (bTwoFingerCoorBak == 1)
+		{
+			if (bclickFlag == 1)
+			{
+				pEP3_RAM_Addr[1] = 0x02;
+				bclickFlag = 0;
+			}
+			else
+			{
+				pEP3_RAM_Addr[1] = 0;
+			}
+			TouchCount = 0;
+
+		}
+
+		//Press_Flag_Bak1 = 0;
+
+		if ((bTwoFingerCoorBak == 1) && (PrePointXBak != 0xFFFF))
+		{
+			pTP[0].X_pos = PrePointXBak;
+			pTP[0].Y_pos = PrePointYBak;
+		}
+
+		PrePointXBak = pTP[0].X_pos;
+		PrePointYBak = pTP[0].Y_pos;
+	}
+	else if (Press_Flag_Bak0)
+	{
+		TouchLeaveFlag = 0;
+
+		if(TouchNum >= 2)
+		{
+			bTwoFingerCoorBak = 1;
+		}
+
+
+		if(TouchNum == 1 && TouchNumBak < 2)
+		{
+			if (TouchCount == 3)
+			{
+				TouchCount++;
+				pEP3_RAM_Addr[1] = 0;
+			}
+			else if (TouchCount == 4)
+			{
+				pEP3_RAM_Addr[1] = 1;
+			}
+		}
+
+		TouchNumBak = TouchNum;
+
+		if ((bTwoFingerCoorBak == 1) && (PrePointXBak != 0xFFFF))
+		{
+			pTP[0].X_pos = PrePointXBak;
+			pTP[0].Y_pos = PrePointYBak;
+		}
+
+		if(Press_Flag_Bak1==0 && Press_Flag_Bak2 ==0)
+		{
+			TouchCount = 1;
+
+			pEP3_RAM_Addr[1] = 0;
+
+
+			return;
+		}
+		else  //����֡
+		{
+			if (TouchCount < 3)
+			{
+				TouchCount++;
+
+				return;
+			}
+		}
+	}
+
+	p = (UINT8*)(pTP + 0);
+	{
+		pEP3_RAM_Addr[2] = p[2];
+		pEP3_RAM_Addr[3] = p[3];
+		pEP3_RAM_Addr[4] = p[4];
+		pEP3_RAM_Addr[5] = p[5];
+
+		if(TouchNum == 2)
+		{
+			//����
+			if (byWheelUpDown == 1)
+			{
+				pEP3_RAM_Addr[1] = 0;
+				pEP3_RAM_Addr[6] = 0x01;
+				//byWheelStopCount = 3;
+			}
+			else if (byWheelUpDown == 2)
+			{
+				pEP3_RAM_Addr[1] = 0;
+				pEP3_RAM_Addr[6] = 0xff;
+				//byWheelStopCount = 3;
+			}
+			else
+			{
+				pEP3_RAM_Addr[6] = 0;
+			}
+		}
+		else
+		{
+			pEP3_RAM_Addr[6] = 0;
+		}
+
+		if((Press_Flag&0x8000) && StylusPress == 0)
+		{
+			USBFS_EP1_Buf[1] = 0;
+		}
+
+
+		if(interface==0)
+		{
+			R16_UEP3_DMA =  (UINT16)(UINT32)pEP3_RAM_Addr;
+			R8_UEP3_T_LEN = 7;
+			R8_UEP3_CTRL = (R8_UEP3_CTRL & (~ MASK_UEP_T_RES)) | UEP_T_RES_ACK;
+		}
+		else
+		{
+			HidDev_Report(HID_RPT_ID_MOUSE_IN, 1, 6, pEP3_RAM_Addr + 1);
+		}
+	}
+}
+#endif
+#endif
+
+//void ReportToApple(POINTER * pTP)
+//{
+//	  UINT8* buf;
+//		UINT8 k;
+//
+//    TouchNum = 0;
+//		for(CheckPos = 0; CheckPos < 2; CheckPos++)
+//		{
+//			if(Press_Flag & (1L << CheckPos))
+//			{
+//				UINT8* p = (UINT8*)(pTP + CheckPos);
+//				k = 0;
+//
+//				buf[k++] = CheckPos;
+//
+//				if(CheckPos == 0)
+//				{
+//					buf = pEP3_RAM_Addr;
+//				}
+//				else
+//				{
+//					buf = pEP4_RAM_Addr;
+//				}
+//
+//				buf[k++] = p[0] + 2;
+//				buf[k++] = CheckPos;
+//				buf[k++] = p[2];
+//				buf[k++] = p[3];
+//				buf[k++] = p[4];
+//				buf[k++] = p[5];
+//				TouchNum++;
+//
+//				if(CheckPos == 0)
+//				{
+////					 R8_UEP3_T_LEN = 7;
+////					 R8_UEP3_CTRL = (R8_UEP3_CTRL & (~ MASK_UEP_T_RES)) | UEP_T_RES_ACK;
+//						 DevEp3In(7);
+//				}
+//				else
+//				{
+////					R8_UEP4_T_LEN = 7;
+////					R8_UEP4_CTRL = (R8_UEP4_CTRL & (~ MASK_UEP_T_RES)) | UEP_T_RES_ACK;
+//
+//					DevEp4In(7);
+//				}
+//			}
+//		}
+//}
+
+
+
+UINT8 package_index = 0;
+
+//void JumpToIAP(void)
+//{
+//   FLASH_Unlock_Fast();
+//   FLASH_ErasePage_Fast(APP_FALG_ADDR);
+//   FLASH_Lock_Fast();
+//   NVIC_SystemReset();
+//}
+//
+void SoftResetChip()
+{
+   sw_reset_kick(sw_reset_source_get());
+}
+
+
+
+void CommandHandle( void )
+{
+  	UINT8 Ret = 1;
+
+    if(PackageInfo.command == NO_OPERATE
+    #if USB_HID_EN
+       || ude_hid_isvalid(EP2_INDEX)==false
+    #endif // USB_HID_EN
+       || UsbReportPosEn==FALSE)
+    {
+        return;
+    }
+    switch(PackageInfo.command )
+    {
+    case I2C_READ:
+    {
+        PackageInfo.buf[64] = EDP2_INPUT_REPORT_ID;
+
+        switch(PackageInfo.sub_command)
+        {
+          case GET_VERSION:
+          {
+            memcpy(PackageInfo.buf + 65, Version, sizeof(Version));
+            //printf( "GET_VERSION!\r\n" );
+
+            break;
+          }
+        #if USBCONFIG
+          case GET_CONFIG:
+          {
+            GetConfigFromFlash(PackageInfo.buf + 65);
+            //memcpy(PackageInfo[QueueHead].buf + 65, (UINT8*)&config, sizeof(config));
+
+            break;
+          }
+        #endif
+          case CHECK_BLE_CONNECT:
+          {
+            //*(PackageInfo[QueueHead].buf + 65) = IsBLEConnected();// | bClientConnected;
+            break;
+          }
+          case GET_TOUCH_CHIP_INFO:
+          {
+    //            if(ChipType==CHIP_TYPE_FT5XXX)
+    //            {
+    //                UINT8 ChipIdVer[3];
+    //                if(PackageInfo[QueueHead].address == 0xA6)
+    //                {
+    //                  if(FT_Get_FW_Ver(ChipIdVer))
+    //                  {
+    //                    sprintf(PackageInfo[QueueHead].buf + 65, "FT%02X%02X_v%02X", ChipIdVer[0], ChipIdVer[1], ChipIdVer[2]);
+    //                  }
+    //                }
+    //                else if(PackageInfo[QueueHead].address == 0x95)
+    //                {
+    //                  PackageInfo[QueueHead].buf[65] = FT_MAX_X>>8;
+    //                  PackageInfo[QueueHead].buf[66] = FT_MAX_X;
+    //                  PackageInfo[QueueHead].buf[67] = FT_MAX_Y>>8;
+    //                  PackageInfo[QueueHead].buf[68] = FT_MAX_Y;
+    //                }
+    //            }
+    //            else if(ChipType== CHIP_TYPE_79XX)
+    //             {
+    //               Ret =  BT_RD_Reg(PackageInfo[QueueHead].address, PackageInfo[QueueHead].buf + 65, PackageInfo[QueueHead].len);
+    //             }
+    //            else
+            {
+              Ret =  IICReadBytes(PackageInfo.address, PackageInfo.buf + 65, PackageInfo.len);
+            }
+            break;
+          }
+
+      #if DEBUG == Debug_USB
+          case DEBUG_PIPE:
+          {
+            print_log = 1;
+            UINT8 len = pipe_read(&debug_pipe, (PackageInfo.buf + 66), 62);
+            *(PackageInfo.buf + 65) = len;
+            break;
+          }
+      #endif
+          case GTXXX_ENTER_UPDATE_MODE:
+          {
+              PackageInfo.buf[65] = EntryUpdateMode();
+              break;
+          }
+          case SYS_PIPE:
+          {
+            UINT8 len = pipe_read(&sys_pipe, (PackageInfo.buf + 66), 62);
+            *(PackageInfo.buf + 65) = len;
+            break;
+          }
+          case COOR_PIPE:
+         {
+           UINT8 len = pipe_read(&coor_pipe, (PackageInfo.buf + 66), 62);
+           *(PackageInfo.buf + 65) = len;
+           break;
+         }
+          case GET_BONDING_MAC:
+          {
+            //GetBondingMacAddr(PackageInfo[QueueHead].buf + 65);
+            break;
+          }
+          case GET_DEVICE_MAC:
+          {
+            //GetMACAddress(TmpBuf);
+            //memcpy(PackageInfo[QueueHead].buf + 65, TmpBuf, 6);
+            break;
+          }
+          case CET_TOUCH_CHIP_TYPE:
+          {
+            PackageInfo.buf[65] = CET_TOUCH_CHIP_TYPE;
+            PackageInfo.buf[66] = ChipType;
+            break;
+          }
+          case CHECK_I2C_CONNECT:
+          {
+            *(PackageInfo.buf + 65) = Ret;
+            break;
+          }
+          #if AUTO_TEST
+          case GET_TEST_STATE:
+          {
+              PackageInfo.buf[65] = GET_TEST_STATE;
+              PackageInfo.buf[66] = GetTestState();
+              break;
+          }
+          #endif
+          default:
+          {
+
+             UINT8 len = PackageInfo.len > 63 ? 63 : PackageInfo.len;
+
+             Ret =  IICReadBytes(PackageInfo.address, PackageInfo.buf + 65, len);
+
+             PackageInfo.address += len;
+             PackageInfo.len -= len;
+
+             if(Ret && PackageInfo.len!=0)
+             {
+             #if USB_HID_EN
+                 usb_hid_buffer_push(EP2_INDEX, PackageInfo.buf+64, 64);
+             #endif
+                 return;
+             }
+             break;
+           }
+        }
+
+        PackageInfo.command = NO_OPERATE;
+    #if USB_HID_EN
+        usb_hid_buffer_push(EP2_INDEX, PackageInfo.buf+64, 64);
+    #endif
+        break;
+    }
+
+    case I2C_WRITE:
+    {
+        if(PackageInfo.len > 0)
+        {
+            Ret =  IICWriteBytes(PackageInfo.address, PackageInfo.buf + COMMAND_HEARD_LEN, PackageInfo.len);
+        }
+
+        switch(PackageInfo.sub_command)
+        {
+        case RESET_TOUCH_IC:
+        {
+            ResetTouchChip();
+            //IsDebugMode = 0;
+            break;
+        }
+        case REBOOT_FROM_SRAM:
+        {
+            break;
+        }
+        case ENTRY_DEBUG_MODE:
+        {
+           IsDebugMode = 1;
+           break;
+        }
+        case QUIT_DEBUG_MODE:
+        {
+            IsDebugMode = 0;
+            break;
+        }
+        case S818X_ENTER_UPDATE_MODE:
+        {
+           //JumpToIAP();
+           break;
+        }
+        case DISABLE_DIGITER_INTERFACE:
+        {
+          DisableDigiterInterface = 1;
+          break;
+        }
+        case ENABLE_DIGITER_INTERFACE:
+        {
+          DisableDigiterInterface = 0;
+          break;
+        }
+      #if USBCONFIG
+        case SET_CONFIG:
+          SaveConfig(PackageInfo.buf + COMMAND_HEARD_LEN);
+          break;
+      #endif
+        case STOP_PRINT_LOG:
+          print_log = 0;
+          break;
+        case ENABLE_INT_IRQ:
+          enable_INT_irq = TRUE;
+          break;
+        case ENABLE_ESD_CHECK:
+          enable_ESD_check = TRUE;
+          break;
+        case DISABLE_INT_IRQ:
+          enable_INT_irq = FALSE;
+           break;
+         case DISABLE_ESD_CHECK:
+           enable_ESD_check = FALSE;
+           break;
+        case RESET_USB_DEVICE:
+             //SoftResetChip();
+             break;
+        case BLE_RF_TEST:
+          //DTMRecCmdData(PackageInfo.buf + COMMAND_HEARD_LEN, PackageInfo.len, FALSE);
+          break;
+    #if AUTO_TEST
+        case SET_TEST_RESULT:
+        {
+            if(PackageInfo.buf[COMMAND_HEARD_LEN])
+            {
+                ReturnTestResult(1);
+            }
+            else {
+                ReturnTestResult(0);
+            }
+            break;
+        }
+    #endif
+        default:
+          break;
+        }//end of switch(PackageInfo.sub_command)
+
+        PackageInfo.command = NO_OPERATE;
+
+        break;
+    }
+
+    default:
+        PackageInfo.command = NO_OPERATE;
+        break;
+    }//end of switch(Command)
+
+	if(Ret==0)
+	{
+	  SearchAddress(1);
+	  //ResetTouchChip();
+	}
+
+
+	if(OutDebugMode && ChipType!=CHIP_TYPE_FT5XXX)
+	{
+		UINT8 tmp[2] = {0,0};
+
+		OutDebugMode = 0;
+
+		if(ChipType == CHIP_TYPE_73XX)
+		{
+		    IICWriteBytes(0x8041, tmp, 2);
+		    IICWriteBytes(0x8040, tmp, 1);
+		}
+		else if(ChipType == CHIP_TYPE_BERLINB ||ChipType == CHIP_TYPE_BERLIND)
+		{
+		    UINT8 tmp2[6] = {0x00,0x00,0x04,0x00,0x04,0x00};
+
+		    IICWriteBytes(0x10174, tmp2, 6);
+		}
+		else if(ChipType == CHIP_TYPE_BERLINA)
+		{
+           UINT8 tmp2[7] = {0x00,0x00,0x04,0x00,0x04,0x00,0x00};
+
+           IICWriteBytes(0x10180, tmp2, 7);
+		}
+		else
+		{
+		    IICWriteBytes(0x8046, tmp, 1);
+		    IICWriteBytes(0x8040, tmp, 1);
+		}
+	}
+}
+
+
+BOOL Ep2ReporteParse(UINT8* buf)
+{
+    memcpy(PackageInfo.buf, buf, 64);
+
+    if(isBerlinSeries)
+    {
+        PackageInfo.command = PackageInfo.buf[1] >> 7;
+
+        PackageInfo.sub_command = PackageInfo.buf[1]&0x7F;
+
+        PackageInfo.address = PackageInfo.buf[2];
+
+        PackageInfo.address = (PackageInfo.address<<16) + ((UINT16)PackageInfo.buf[3] << 8) + PackageInfo.buf[4];
+
+        PackageInfo.len = ((UINT16)PackageInfo.buf[5] << 8) + PackageInfo.buf[6];
+
+        CommandHandle();
+
+    }
+    else
+    {
+      PackageInfo.command = (COMMAND_TYPE)PackageInfo.buf[1] & 0x03;
+
+      PackageInfo.sub_command = (COMMAND_TYPE)PackageInfo.buf[2];
+
+      PackageInfo.address = ((UINT16)PackageInfo.buf[3] << 8) + PackageInfo.buf[4];
+
+      PackageInfo.len = ((UINT16)PackageInfo.buf[5] << 8) + PackageInfo.buf[6];
+
+      CommandHandle();
+
+    }
+    return true;
+}
+
+
+void ReportInit( void )
+{
+    IsDebugMode = FALSE;
+
+
+    wReadLen = 0;
+
+    //todo
+    PackageInfo.command = NO_OPERATE;
+    PackageInfo.offset = 0;
+
+  	Press_Flag_Bak3 = 0;
+    Press_Flag_Bak2 = 0;
+    Press_Flag_Bak0 = 0;
+    Press_Flag_Bak1 = 0x0000;
+
+	DisableDigiterInterface = 0;
+
+	OutDebugMode = 1;
+
+#if USBCONFIG
+  if (config.report_type == EN_MULTITOUCH_ONLY)
+#else
+  if (1)
+#endif
+  {
+    DeviceMode = DEVICE_MODE_MULTITOUCH;
+  }
+  else
+  {
+    DeviceMode = DEVICE_MODE_MOUSE;
+  }
+
+//		//KEY_CLEAR();
+//	if(USBDebugTaskId==INVALID_TASK_ID)
+//	{
+//		USBDebugTaskId = TMOS_ProcessEventRegister(USBDebug_ProcessEvent);
+//	}
+
+}
+
+
+

project/solution/ble_hid_composite/touch/IIC.c

@@ -0,0 +1,291 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : IIC.c
+* Author             :
+* Version            : V1.0
+* Date               : 2018/12/12
+* Description        : I2C 读写
+*******************************************************************************/
+
+/*********************************************************************
+ * INCLUDES
+ */
+
+#include "TouchCommon.h"
+#include "iic.h"
+#include "driver_gpio.h"
+
+/* DATA ADDRESS Length Definition */
+#define Address_8bit  0
+#define Address_16bit  1
+#define Address_32bit  2
+
+#define CHECK_TIMES     (25)
+
+#define IIC_TIMEOUT 50
+
+#define IIC_SPEED_400   10
+void NOP_DELAY(UINT16 num)
+{
+    while(num--)
+    {
+        asm("nop");
+    }
+}
+void Touch_IIC_Init()
+{
+    gpio_init_typedef gpio_init_structure;
+
+    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
+    gpio_init_structure.gpio_fen = GPIO_FEN_GPIO;
+    gpio_init_structure.gpio_fdir = GPIO_FDIR_SELF;
+    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
+    gpio_init_structure.gpio_pupd = GPIO_PUPD_PU10K;
+    gpio_init_structure.gpio_drv = GPIO_DRV_6MA;
+
+    gpio_init_structure.gpio_pin = IIC_SCL;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+
+    gpio_init_structure.gpio_pin = IIC_SDA;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+
+    gpio_reset_bits(GPIOA_REG, IIC_SCL);
+    gpio_reset_bits(GPIOA_REG, IIC_SDA);
+}
+
+#define SCL_IN()            (gpio_read_data(GPIOA_REG)&IIC_SCL)
+#define SCL_HIGH()          gpio_set_input(GPIOA_REG, IIC_SCL)
+#define SCL_LOW()           gpio_set_out(GPIOA_REG, IIC_SCL)
+#define SDA_IN()            (gpio_read_data(GPIOA_REG)&IIC_SDA)
+#define SDA_HIGH()          gpio_set_input(GPIOA_REG, IIC_SDA)
+#define SDA_LOW()           gpio_set_out(GPIOA_REG, IIC_SDA)
+
+#define IIC_START()         {\
+    SDA_HIGH();\
+    SCL_HIGH();\
+    NOP_DELAY(IIC_SPEED_400);\
+    SDA_LOW();\
+    NOP_DELAY(IIC_SPEED_400);\
+    SCL_LOW();\
+}
+
+#define IIC_STOP()  {\
+    SDA_LOW();\
+    SCL_LOW();\
+    NOP_DELAY(IIC_SPEED_400);\
+    SCL_HIGH();\
+    NOP_DELAY(IIC_SPEED_400);\
+    SDA_HIGH();\
+}
+
+BOOL I2C_WaitForSclRelease(void)
+{
+    s8 nTryTimes = IIC_TIMEOUT;
+
+    while( SCL_IN() == 0  && nTryTimes!=0)
+    {
+        --nTryTimes;
+        NOP_DELAY(IIC_SPEED_400);
+    }
+
+    if(nTryTimes==0)
+        return 0;
+    return 1;
+}
+
+BOOL IIC_WRITE_DATA(UINT8 dat)
+{
+    BOOL nak;
+    UINT8 bit_off = 0x80;
+    do
+    {
+        if(bit_off & dat)
+        {
+            SDA_HIGH();
+        }
+        else
+        {
+            SDA_LOW();
+        }
+        NOP_DELAY(IIC_SPEED_400);
+        SCL_HIGH();
+        NOP_DELAY(IIC_SPEED_400);
+        bit_off >>= 1;
+        SCL_LOW();
+    } while (bit_off);
+
+    NOP_DELAY(IIC_SPEED_400);
+    SDA_HIGH();
+    SCL_HIGH();
+    NOP_DELAY(IIC_SPEED_400);
+    nak = SDA_IN();
+    SCL_LOW();
+
+    return nak==0;
+}
+
+BOOL IIC_READ_DATA(UINT8* dat, BOOL nack)
+{
+    UINT8 bit_off = 0x80;
+
+    SDA_HIGH();
+    SCL_HIGH();
+    NOP_DELAY(IIC_SPEED_400);
+    if(!I2C_WaitForSclRelease())
+    {
+        return 0;
+    }
+
+    while(1)
+    {
+        if(SDA_IN())
+        {
+            *dat |=  bit_off;
+        }
+        else
+        {
+            *dat &=  ~bit_off;
+        }
+
+        SCL_LOW();
+        NOP_DELAY(IIC_SPEED_400);
+        bit_off >>= 1;
+
+        if(bit_off)
+        {
+            SCL_HIGH();
+            NOP_DELAY(IIC_SPEED_400);
+            continue;
+        }
+        break;
+    };
+
+    if(nack)
+    {
+        SDA_HIGH();
+    }
+    else
+    {
+        SDA_LOW();
+    }
+    SCL_HIGH();
+    NOP_DELAY(IIC_SPEED_400 + 2);
+    SCL_LOW();
+    return 1;
+}
+
+BOOL GT_Check_I2C_Address(UINT8 Address)
+{
+    BOOL nack;
+
+    IIC_START();
+
+    nack = IIC_WRITE_DATA(Address);
+
+    IIC_STOP();
+
+    return nack;
+}
+
+BOOL  WriteAddress(UINT32 dwAddr)
+{
+   if(isBerlinSeries)
+   {
+      IIC_WRITE_DATA((UINT8)(dwAddr>>24) );
+
+      IIC_WRITE_DATA((UINT8)(dwAddr>>16) );
+   }
+   IIC_WRITE_DATA((UINT8)(dwAddr>>8) );
+
+   IIC_WRITE_DATA((UINT8)(dwAddr) );
+
+   return 1;
+}
+
+u8 IICReadOneByte(UINT32 ReadAddr)
+{
+    UINT8 temp=0;
+    IIC_START();
+    IIC_WRITE_DATA(GT_CMD_WR);
+    if(!WriteAddress(ReadAddr)) return 0;
+      NOP_DELAY(4);
+    IIC_START();
+     IIC_WRITE_DATA(GT_CMD_RD);
+     NOP_DELAY(4);
+    IIC_READ_DATA(&temp, 1);
+    IIC_STOP();
+    return temp;
+}
+
+BOOL IICReadBytes(UINT32 ReadAddr,UINT8 *pBuffer,UINT16 Length)
+{
+    BOOL ret = 1;
+    IIC_START();
+    if(!IIC_WRITE_DATA(GT_CMD_WR))
+        return 0;
+    if(!WriteAddress(ReadAddr)) return 0;
+    NOP_DELAY(4);
+    IIC_START();
+    IIC_WRITE_DATA(GT_CMD_RD);
+
+    for(; Length > 1; --Length)
+    {
+        NOP_DELAY(4);
+        ret = IIC_READ_DATA(pBuffer, 0);
+
+        if(!ret)
+        {
+            break;
+        }
+
+        pBuffer++;
+    }
+
+    if(ret)
+    {
+        NOP_DELAY(4);
+        IIC_READ_DATA(pBuffer, 1);
+    }
+
+    IIC_STOP();
+
+    return ret;
+}
+
+
+BOOL IICWriteOneByte(UINT32 WriteAddr,UINT8 DataToWrite)
+{
+    BOOL ret;
+    IIC_START();
+    ret = IIC_WRITE_DATA(GT_CMD_WR);
+    if(ret)
+    {
+        if(!WriteAddress(WriteAddr)) return 0;
+        ret = IIC_WRITE_DATA(DataToWrite);
+    }
+    IIC_STOP();
+    return ret;
+}
+
+BOOL IICWriteBytes(UINT32 WriteAddr,UINT8 *pBuffer,UINT16 Length)
+{
+    BOOL ret;
+
+    IIC_START();
+    ret = IIC_WRITE_DATA(GT_CMD_WR);
+    if(ret)
+    {
+        if(!WriteAddress(WriteAddr)) return 0;
+
+        while (Length--)
+        {
+            IIC_WRITE_DATA(*pBuffer);
+            pBuffer++;
+        }
+    }
+    IIC_STOP();
+    return ret;
+}
+
+
+/*********************************************************************
+*********************************************************************/

project/solution/ble_hid_composite/touch/MS928x_mpi.c

@@ -0,0 +1,354 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : MS928x_mpi.c
+* Author             : Wingcool
+* Version            : V1.0
+* Date               : 2023/2/22
+* Description        : ms928x SDK升级操作
+*******************************************************************************/
+
+/******************************************************************************/
+/* 头文件包含 */
+#include "include.h"
+//#include <GoodixTouch.h>
+#include "CONFIG.h"
+//#include "CH57x_common.h"
+#include "TouchCommon.h"
+//#include "HAL.h"
+//#include "hiddev.h"
+//#include "hidtouch.h"
+#include "iic.h"
+//#include "DEBUG.H"
+#include "HidReport.h"
+//#include "usb_driver.H"
+//#include "I2CTouchService.h"
+//#include "Flash.h"
+//#include "hidReportDesc.h"
+//#include "central.h"
+//#include "RF_PHY.h"
+//#include "Flash.h"
+#include "tmos.h"
+
+#include "commlib.h"
+#include "MS928x.h"
+#include "MS928x_mpi.h"
+#include "mst_typedef.h"
+/*********************************************************************
+ * GLOBAL TYPEDEFS
+ */
+#define MS_SERVICE                          0x0001
+#define HID_DEBUG_EVT                       0x0200
+
+#define PERIO_100ms 160
+#define PERIO_1s    1600
+
+/*********************************************************************/
+UINT8 byIicDelay = 0;  //default 400KHz
+static UINT8 MS928xTaskId = INVALID_TASK_ID;
+BOOL bPressKeyFlag = 0;  //press reset key or not
+UINT16 wHPixelShift,wVPixelShift;  //
+
+static UINT16 MS928x_ProcessEvent( UINT8 task_id, UINT16 events );
+
+void Delay_ms(UINT8 u8ms)
+{
+  delay_ms(u8ms);
+}
+
+void Delay_us(UINT8 u8us)
+{
+  delay_us(u8us);
+}
+
+void I2C_Sel_Speed(UINT8 u8speed)
+{
+  switch (u8speed)
+  {
+    case I2C_SPEED_20K:
+      byIicDelay = 20;  //20K
+      break;
+    case I2C_SPEED_100K:
+      byIicDelay = 0;  //100K
+      break;
+    case I2C_SPEED_400K:
+      byIicDelay = 0;  //400K
+      break;
+    case I2C_SPEED_750K:
+      byIicDelay = 0;  //400K
+      break;
+    case 100:
+      byIicDelay = 0;  //100K
+      break;
+    case 20:
+      byIicDelay = 20;  //20K
+      break;
+    default:
+      byIicDelay = 0;  //400K
+      break;
+  }
+
+  //byIicDelay = 20;  //20K
+}
+
+UINT8 I2C16_ReadByte(UINT8 u8addr, UINT16 u16index)
+{
+  GT_CMD_WR = u8addr;
+  GT_CMD_RD = u8addr + 1;
+
+  u16index = ((u16index & 0xff00) >> 8) + ((u16index & 0x00ff) << 8);
+
+  return IICReadOneByte(u16index);
+}
+
+void I2C16_WriteByte(UINT8 u8addr, UINT16 u16index, UINT8 u8value)
+{
+  GT_CMD_WR = u8addr;
+  GT_CMD_RD = u8addr + 1;
+
+  u16index = ((u16index & 0xff00) >> 8) + ((u16index & 0x00ff) << 8);
+
+  IICWriteOneByte(u16index, u8value);
+}
+
+BOOL I2C_ReadBytes(UINT8 u8addr, UINT8 u8index, UINT8 *pIn, UINT8 u8len)
+{
+  GT_CMD_WR = u8addr;
+  GT_CMD_RD = u8addr + 1;
+
+  UINT16 u16index = (UINT16)u8index * 256;
+
+  return IICReadBytes(u16index, pIn, u8len);
+
+}
+
+//UINT8  I2C_ReadByte(UINT8 u8addr, UINT8 u8index)
+//{
+//
+//}
+//
+//void I2C_WriteByte(UINT8 u8addr, UINT8 u8index, UINT8 u8value)
+//{
+//
+//}
+
+void Sys_Reset(void)
+{
+
+    gpio_init_typedef gpio_init_structure;
+
+    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
+    gpio_init_structure.gpio_fen = GPIO_FEN_GPIO;
+    gpio_init_structure.gpio_fdir = GPIO_FDIR_SELF;
+    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
+    gpio_init_structure.gpio_pupd = GPIO_PUPD_PU10K;
+    gpio_init_structure.gpio_drv = GPIO_DRV_6MA;
+
+    gpio_init_structure.gpio_pin = RST_PIN;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+    gpio_reset_bits(GPIOA_REG, RST_PIN);
+
+    delay_us(200);
+    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+    gpio_set_bits(GPIOA_REG, RST_PIN);
+}
+
+void MS928X_MPI_Init(BOOL bpresskeyflag)
+{
+  UINT8 u8status;
+  SYSPARAM_T stParam;
+
+  tmos_stop_task(MS928xTaskId, MS_SERVICE);
+
+  Sys_Reset();
+
+  memset(&stParam, 0, sizeof(SYSPARAM_T));
+
+  stParam.u8chipAddr = MS928X_I2C_ADDR_92;  //MS928X IIC address, SASEL Pin -> GND, select 0x9A
+
+  stParam.u16sysConfig = SYS_CFG_SIG_CHANNEL_1;// | SYS_CFG_SIG_SYNC_SOG_1;// | SYS_CFG_ADDPLL_HIGH_REFCLK;  // 配置根据系统板来选择信号输入通道
+
+  stParam.videoParam.u8sourceIn = IN_ANALOG_VGA;  // 当前输入信号选择 VGA input
+
+  // 调用初始化函数
+  u8status = MS928X_Init(&stParam);
+
+  //PRINT("MS928X init status:0x%x\n", u8status);
+
+  if (bpresskeyflag)  //press key
+  {
+    bPressKeyFlag = 1;
+  }
+
+  tmos_start_task(MS928xTaskId, MS_SERVICE, PERIO_100ms);
+}
+
+void MS928XInit()
+{
+  UINT8 u8hvpixeldata[4];
+
+  if (bTransmitEn == TRUE)  //transmit
+  {
+    return;
+  }
+
+  GT_CMD_WR = MS928X_I2C_ADDR_92;
+  GT_CMD_RD = MS928X_I2C_ADDR_92 + 1;
+
+  if (GetHVPixel(u8hvpixeldata))
+  {
+    //PRINT("Get HV Pixel Success\n");
+    wHPixelShift = (UINT16)(((UINT16)u8hvpixeldata[0] << 8) + u8hvpixeldata[1]);
+    wVPixelShift = (UINT16)(((UINT16)u8hvpixeldata[2] << 8) + u8hvpixeldata[3]);
+  }
+  else  //没有存储，给一个默认的
+  {
+    //PRINT("No HV Pixel Data\n");
+    wHPixelShift = 1593;
+    wVPixelShift = 1;
+  }
+
+  //PRINT("wHPixelShift:%05d, wVPixelShift:%05d\n", wHPixelShift, wVPixelShift);
+
+  MS928xTaskId = TMOS_ProcessEventRegister(MS928x_ProcessEvent);
+
+//  if (MS928xTaskId == INVALID_TASK_ID)
+//  {
+//    MS928xTaskId = TMOS_ProcessEventRegister(MS928x_ProcessEvent);
+//    tmos_set_event(MS928xTaskId, HID_DEBUG_EVT);
+//  }
+
+  tmos_set_event(MS928xTaskId, HID_DEBUG_EVT);
+
+  MS928X_MPI_Init(0);
+
+}
+
+void MS928XService()
+{
+  VIDEOSHIFT_T sysVideoShift;
+  UINT8 u8status;
+  //UINT8 u8vic = 0;
+  UINT8 u8hvpixeldatabuf[4];
+
+  u8status = MS928X_Poll(); // 返回当前系统运行状态
+  //PRINT("MS928X Poll status:%d\n", u8status);
+
+  if (u8status == STATE_SUCCESS)
+  {
+    //WDT_DIS();
+    //PRINT("Disable watch dog\n");
+
+    //u8vic = MS928X_GetInputVideoMode();
+    //PRINT("MS928X vic:%03d\n", u8vic);
+
+    //MS928X_SetVideo();  // 设置 Video
+    MS928X_SetVideo(&sysVideoShift);  // 设置 Video
+    //MS928X_SetAudio(); // 设置 Audio
+
+    //if (u8vic == 4)
+    {
+      if (bPressKeyFlag == 1)  //press key
+      {
+        bPressKeyFlag = 0;
+
+        u8hvpixeldatabuf[0] = sysVideoShift.u16HShift >> 8;
+        u8hvpixeldatabuf[1] = sysVideoShift.u16HShift & 0xFF;
+        u8hvpixeldatabuf[2] = sysVideoShift.u16VShift >> 8;
+        u8hvpixeldatabuf[3] = sysVideoShift.u16VShift & 0xFF;
+
+        wHPixelShift = sysVideoShift.u16HShift;
+        wVPixelShift = sysVideoShift.u16VShift;
+
+        if (StoreHVPixel(u8hvpixeldatabuf))
+        {
+          //PRINT("Store HV Pixel Success\n");
+        }
+      }
+      else
+      {
+        sysVideoShift.u16HShift = wHPixelShift;
+        sysVideoShift.u16VShift = wVPixelShift;
+      }
+      //MS928X_WriteShift(1593,1);
+      //MS928X_WriteShift(sysVideoShift.u16HShift,sysVideoShift.u16VShift);
+      //MS928X_Video_SetShift(1593,1);
+      MS928X_Video_SetShift(sysVideoShift.u16HShift, sysVideoShift.u16VShift);
+      //PRINT("u16HShift:%05d, u16VShift:%05d\n", sysVideoShift.u16HShift, sysVideoShift.u16VShift);
+    }
+  }
+  else {
+    //WDT_EN();
+    //WDT_CLR();
+  }
+
+  //PRINT("MS928X Poll status:0x%x\n", u8status);
+  //PRINT("u16HShift:%05d, u16VShift:%05d\n", sysVideoShift.u16HShift, sysVideoShift.u16VShift);
+}
+
+bool GetHVPixel(UINT8* HVPixelData)
+{
+  UINT8 buf[10];
+
+  bsp_param_read(buf, HV_PIXEL_ADDR, HV_PIXEL_LEN);  //从flash读出来,len = 4 + 4
+
+  if(buf[0] == 0xAA && buf[1] == 0x55 && buf[2] == 0xAA && buf[3] == 0x55)  //if flag is right
+  {
+    memcpy(HVPixelData, &buf[4], 4);  //return 4 bytes HV Pixel
+    return TRUE;
+  }
+  memset(HVPixelData, 0, 4);  //if flag is wrong, clear HV Pixel
+  return FALSE;
+}
+
+bool StoreHVPixel(UINT8* HVPixelData)
+{
+  u8 buf[8];
+
+  buf[0] = 0xAA;
+  buf[1] = 0x55;
+  buf[2] = 0xAA;
+  buf[3] = 0x55;
+
+  //DataFlash_BlockErase(HV_PIXEL_ADDR);  //erase a block
+
+  //DataFlash_WriteDW(HV_PIXEL_ADDR, 0xAA55AA55);   //write 0xAA55AA55
+
+  memcpy(&buf[4], HVPixelData, 4);  //copy 4 bytes HV Pixel to buf
+
+  //DataFlash_Write((PUINT8)HV_PIXEL_ADDR + 4, (PUINT8)buf, HV_PIXEL_LEN);  //接着第4位开始写HV Pixel，len = 4
+
+  bsp_param_write(buf, HV_PIXEL_ADDR, HV_PIXEL_LEN);
+
+  bsp_param_sync();
+
+  return GetHVPixel(HVPixelData);  //judge and return HV Pixel
+}
+
+static UINT16 MS928x_ProcessEvent( UINT8 task_id, UINT16 events )
+{
+    if(events & MS_SERVICE)
+    {
+      MS928XService();
+      events ^= MS_SERVICE;
+
+      tmos_start_task(MS928xTaskId, MS_SERVICE, PERIO_100ms );
+
+      goto OUT_FUMC;
+    }
+
+    if(events & HID_DEBUG_EVT)
+    {
+      CommandHandle();
+      events ^= HID_DEBUG_EVT;
+      tmos_set_event(MS928xTaskId, HID_DEBUG_EVT);
+      goto OUT_FUMC;
+    }
+
+    return 0;
+
+OUT_FUMC:
+
+    return  events;
+}
+
+/******************************** endfile @ MS928x_mpi ******************************/

project/solution/ble_hid_composite/touch/Touch.c

@@ -0,0 +1,117 @@
+/********************************** (C) COPYRIGHT *******************************
+ * File Name          : main.c
+ * Author             : Wingcool
+ * Version            : V1.0.0
+ * Date               : 2024/01/05
+ * Description        : Main program body.
+ *********************************************************************************/
+#include "include.h"
+#include "GoodixTouch.h"
+#include "HidReport.h"
+#include "usb_com.h"
+#include "MS928x.h"
+#include "uart_transfer.h"
+/*********************************************************************
+ * @fn      main
+ *
+ * @brief   Main program.
+ *
+ * @return  none
+ */
+void touch_init(void)
+{
+    tmos_init();
+
+//#if AUTO_TEST
+//    AutoTestInit();
+//#endif
+    Touch_IIC_Init();
+
+#if USBCONFIG
+    ConfigInit();
+
+    uart_transfer_init(9600);
+#else
+    uart_transfer_init(9600);
+#endif
+//
+//    //CheckFlag();
+//
+    MS928XInit();
+
+    CHIP_TYPE chip_type = GetChipTypeFromFlash();
+
+    if(IsBerlinSeries())
+    {
+      if(!IsBerlinChipType(chip_type) || chip_type==CHIP_TYPE_UNKNOW)
+      {
+          ChipType = CHIP_TYPE_BERLIND;
+      }
+      else
+      {
+          ChipType = chip_type;
+      }
+      isBerlinSeries = TRUE;
+    }
+    else
+    {
+      if(IsBerlinChipType(chip_type) || chip_type==CHIP_TYPE_UNKNOW)
+      {
+          ChipType = CHIP_TYPE_9XXX;
+      }
+      else
+      {
+          ChipType = chip_type;
+      }
+
+      isBerlinSeries = FALSE;
+    }
+
+
+   if(chip_type==CHIP_TYPE_UNKNOW)
+   {
+      IICTouchInit();
+
+//      if(config.intf == EN_USB_IIC)
+//      {
+//         SoftResetChip();
+//      }
+    #if USB_EN
+        dev_init(40, 40);
+        usb_init();
+        usb_device_init();
+    #endif // USB_EN
+
+   }
+   else
+   {
+       // ChipType = CHIP_TYPE_BERLINB;
+       PRINT("Chip type in flash is %d\n", chip_type);
+    #if USB_EN
+        dev_init(40, 40);
+        usb_init();
+        usb_device_init();
+    #endif // USB_EN
+
+//       if(config.intf == EN_USB_IIC)
+//       {
+//           while(UsbReportPosEn == FALSE);
+//       }
+       IICTouchInit();
+   }
+
+    PRINT("Initial finish\n");
+}
+
+
+void touch_process(void)
+{
+#if AUTO_TEST
+    AutoTestHandle();
+#endif
+    //CheckUart0Comand();
+    // CheckTouchInt();
+    CommandHandle();
+
+    TMOS_SystemProcess();
+}

project/solution/ble_hid_composite/touch/TouchCommon.c

@@ -0,0 +1,1168 @@
+/*
+ * TouchCommon.c
+ *
+ *  Created on: Nov 10, 2021
+ *      Author: Administrator
+ */
+ #include "include.h"
+#include "TouchCommon.h"
+#include "TouchConfig.h"
+#include "pipe.h"
+#include "iic.h"
+#include "Gesture.h"
+#include "GoodixTouch.h"
+#include "BerlinTouch.h"
+#include "HidReport.h"
+#include "tmos.h"
+#include "driver_gpio.h"
+
+#define CHECK_TOUCH_INT_EVT                   0x0001
+#define USB_HID_DEBUG_EVT                     0x0002
+#define RESET_TOUCH_CHIP_EVT                  0x0004
+#define CHECK_USB_CONNECT_EVT                 0x0008
+#define ENABLE_UART_EVT                       0x0010
+#define ENABLE_USB_EVT                        0x0020
+#define TIMER_40MS_EVT                        0x0040
+
+static UINT16 Touch_ProcessEvent( UINT8 task_id, UINT16 events );
+static UINT8 TaskID = INVALID_TASK_ID;
+
+
+UINT8 GT_CMD_WR;
+UINT8 GT_CMD_RD;
+POINTER TP[ 10 ];                          /* �������֧�ֵĶ��� */
+UINT8 TouchNumber;
+UINT16 StylusPress;
+CHIP_TYPE ChipType;
+BOOL isBerlinSeries = FALSE;
+BOOL enable_INT_irq;
+BOOL enable_ESD_check;
+UINT8 HearBeatCheckTimer;
+UINT16 OutRangeFlag;
+BOOL GioInterruptFlag;
+UINT8 ShareBuf[10];
+UINT8 NoTouchTimer = 0;
+UINT8 DeviceMode  = DEVICE_MODE_MOUSE;
+UINT8 BleDeviceMode  = DEVICE_MODE_MULTITOUCH;
+UINT16 Press_Flag,Press_Flag_Bak0, Press_Flag_Bak1, Press_Flag_Bak2,Press_Flag_Bak3;
+UINT8 Uart1IdleTime = 0;
+BOOL BleReportFirst = FALSE;
+BOOL ReleaseFlag = 0;
+
+void (*TouchProc)(void);
+
+BOOL UsbReportPosEn = FALSE;
+BOOL UartReportPosEn = TRUE;
+BOOL BleReportPosEn = FALSE;
+
+#ifdef UART_ENABLE
+UINT8 TxBuff[16];
+UINT8 RxBuff[10];
+#ifdef NEW_REVOLVE_PROTOCAL
+BOOL UartRevolveEnable = TRUE;
+#endif
+#endif
+
+#ifdef NEW_REVOLVE_PROTOCAL
+  static UART_STATE uart_state = UART_STATE_IDLE;
+  UINT8 UartCmdBuf[sizeof(UART_LONG_CMD)]__attribute__((aligned(4))) = {0} ;
+  UART_CMD_BUF TpOption __attribute__((aligned(4))) = {UART_COMMAND_A_0};
+#endif
+
+#ifdef MOUSE_REPORT
+  #ifndef GESTURE
+  extern UINT8 mouse_right_click_time;
+  #endif
+#ifndef GESTURE
+  extern void ReportMousePos(POINTER * pTP);
+#else
+  void ReportMousePos(POINTER * pTP, UINT8 interface);
+#endif
+
+#endif
+
+
+#ifdef STYLUS_TILT
+UINT16 StylusTiltX, StylusTiltY;
+#endif
+
+BOOL IsBerlinSeries(void)
+{
+//    UINT8 i,cnt=0;
+
+//    gpio_init_typedef gpio_init_structure;
+//
+//    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
+//    gpio_init_structure.gpio_fen = GPIO_FEN_GPIO;
+//    gpio_init_structure.gpio_fdir = GPIO_FDIR_SELF;
+//    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
+//    gpio_init_structure.gpio_pupd = GPIO_PUPD_PU10K;
+//    gpio_init_structure.gpio_drv = GPIO_DRV_6MA;
+//
+//    gpio_init_structure.gpio_pin = RST_PIN;
+//    gpio_init(GPIOA_REG, &gpio_init_structure);
+//    gpio_reset_bits(GPIOA_REG, RST_PIN);
+
+
+//    delay_ms(2);
+//
+//    for(i=0; i<20; i++)
+//    {
+//        if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_4))
+//        {
+//            cnt++;
+//        }
+//        Delay_Us(100);
+//    }
+//
+//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
+//    GPIO_Init( GPIOB, &GPIO_InitStructure );
+//
+//    if(cnt > 10)
+//    {
+//        return FALSE;
+//    }
+//    else
+//    {
+//        return TRUE;
+//    }
+    return  FALSE;
+}
+
+
+void IICTouchInit()
+{
+  if (bTransmitEn == FALSE)
+    return;
+
+  TaskID = TMOS_ProcessEventRegister(Touch_ProcessEvent);
+
+  GioInterruptFlag = FALSE;
+
+  ResetTouchChip();
+
+  if(ChipType!=GetChipTypeFromFlash())
+  {
+      SaveChipTypeToFlash(ChipType);
+      SoftResetChip();
+      PRINT("RESET CHIP\n");
+  }
+#ifdef NEW_REVOLVE_PROTOCAL
+    TpOption.uart_long_cmd.ax = 0;
+    TpOption.uart_long_cmd.ay = 0;
+
+    TpOption.uart_long_cmd.dx = RESOLUTION_X;
+    TpOption.uart_long_cmd.dy = RESOLUTION_Y;
+#endif
+    tmos_set_event(TaskID, USB_HID_DEBUG_EVT);
+    tmos_start_task(TaskID, TIMER_40MS_EVT, 40);
+}
+
+static UINT16 Touch_ProcessEvent( UINT8 task_id, UINT16 events )
+{
+    if(events & CHECK_TOUCH_INT_EVT)
+    {
+      CheckTouchInt();
+      events ^= CHECK_TOUCH_INT_EVT;
+      tmos_start_task(task_id, CHECK_TOUCH_INT_EVT, 1);
+      goto OUT_FUMC;
+    }
+    if(events & ENABLE_USB_EVT)
+    {
+       events ^= ENABLE_USB_EVT;
+       if(Press_Flag_Bak2==0)
+       {
+           UartReportPosEn = DISABLE;
+           UsbReportPosEn = ENABLE;
+           tmos_stop_task(task_id, ENABLE_USB_EVT);
+
+           goto OUT_FUMC;
+       }
+       else
+       {
+           tmos_start_task(task_id, ENABLE_USB_EVT, 10 );
+
+           goto OUT_FUMC;
+       }
+    }
+    if(events & ENABLE_UART_EVT)
+    {
+        events ^= ENABLE_UART_EVT;
+        if(Press_Flag_Bak2==0)
+        {
+            UartReportPosEn = ENABLE;
+            UsbReportPosEn = DISABLE;
+            tmos_stop_task(task_id, ENABLE_UART_EVT);
+            goto OUT_FUMC;
+        }
+        else
+        {
+            tmos_start_task(task_id, ENABLE_UART_EVT, 10 );
+
+            goto OUT_FUMC;
+        }
+
+    }
+    if(events & USB_HID_DEBUG_EVT)
+    {
+      CommandHandle();
+      events ^= USB_HID_DEBUG_EVT;
+      tmos_set_event(task_id, USB_HID_DEBUG_EVT);
+      goto OUT_FUMC;
+    }
+    if(events & RESET_TOUCH_CHIP_EVT)
+    {
+      ResetTouchChip();
+      events ^= RESET_TOUCH_CHIP_EVT;
+      //tmos_set_event(task_id, RESET_TOUCH_CHIP_EVT);
+      goto OUT_FUMC;
+    }
+    if(events & TIMER_40MS_EVT)
+    {
+      #ifdef DOUBLECLIK_FILETER
+        DoubleClickTimer++;
+        if(DoubleClickTimer > 100) DoubleClickTimer = 100; //4s
+      #endif
+
+      #ifdef MOUSE_REPORT
+        #ifndef GESTURE
+          if(++mouse_right_click_time > 20) mouse_right_click_time = 20;
+        #endif
+      #endif
+       tmos_start_task(TaskID, TIMER_40MS_EVT, 40);
+      events ^= TIMER_40MS_EVT;
+      goto OUT_FUMC;
+    }
+
+    return 0;
+
+OUT_FUMC:
+
+    return  events;
+}
+char info[] = "io_isr\n";
+AT(.com_text.gpio_isr)
+void gpio_isr_callback(void)
+{
+    gpio_edge_pending_clear();
+    GioInterruptFlag = TRUE;
+    printf(info);
+}
+
+void io_interrupt_init(void)
+{
+    gpio_edge_cap_typedef config;
+
+    config.edge = GPIO_EDGE_FALLING;
+    config.gpiox = GPIOA_REG;
+    config.gpio_pin = INT_PIN;
+
+    gpio_edge_capture_config(&config);
+
+    gpio_edge_pic_config(gpio_isr_callback, 0);
+}
+
+
+void ResetTouchChip()
+{
+    gpio_init_typedef gpio_init_structure;
+
+    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
+    gpio_init_structure.gpio_fen = GPIO_FEN_GPIO;
+    gpio_init_structure.gpio_fdir = GPIO_FDIR_SELF;
+    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
+    gpio_init_structure.gpio_pupd = GPIO_PUPD_PU10K;
+    gpio_init_structure.gpio_drv = GPIO_DRV_6MA;
+
+    gpio_init_structure.gpio_pin = RST_PIN;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+    gpio_reset_bits(GPIOA_REG, RST_PIN);
+
+    delay_ms(1);//RST
+
+    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
+    gpio_init_structure.gpio_pin = INT_PIN;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+    gpio_set_bits(GPIOA_REG, INT_PIN);
+    delay_ms(80);
+    gpio_set_bits(GPIOA_REG, RST_PIN);
+
+    enable_INT_irq = FALSE;
+    enable_ESD_check = FALSE;
+    tmos_start_task(TaskID, CHECK_TOUCH_INT_EVT,1);
+
+    SearchAddress(100);
+
+    if(isBerlinSeries)
+    {
+        PRINT("Berlin series\n");
+
+        BT_Init();
+    }
+    else
+    {
+        PRINT("GT9XXX series\n");
+
+        GT_Init();
+    }
+
+    tmos_start_task(TaskID, CHECK_TOUCH_INT_EVT, 2 );
+    io_interrupt_init();
+
+    enable_INT_irq = TRUE;
+    enable_ESD_check = TRUE;
+    PRINT("Reset touch chip\n");
+}
+
+BOOL SearchAddress( UINT8 num )
+{
+  while(num--)
+  {
+    GT_CMD_WR = 0xBA;
+    if(GT_Check_I2C_Address(GT_CMD_WR))
+    {
+        GT_CMD_RD = 0xBB;
+        return 1;
+    }
+    GT_CMD_WR = 0x28;
+    GT_CMD_RD = 0x29;
+    if(GT_Check_I2C_Address(GT_CMD_WR))
+    {
+        return 1;
+    }
+//    GT_CMD_WR = 0x70;
+//    GT_CMD_RD = 0x71;
+//    if(FT_Check_I2C_Address())
+//    {
+//        return 1;
+//    }
+  }
+  return 0;
+}
+
+static void SetTouchEvent()
+{
+//  if(ChipType == CHIP_TYPE_FT5XXX)
+//  {
+//      FT_SetTouchEvent();
+//  }
+//  else
+  if(ChipType != CHIP_TYPE_9XXX)
+  {
+     BT_SetTouchEvent();
+  }
+  else
+  {
+    GT_SetTouchEvent();
+  }
+  //PRINT("have touch\n");
+}
+
+void CheckTouchInt()
+{
+
+//    if(GioInterruptFlag)
+//    {
+//
+//         SetTouchEvent();
+//      GioInterruptFlag = FALSE;
+//    }
+
+    if( (GioInterruptFlag) && (!DisableDigiterInterface))
+    {
+        if(enable_INT_irq)
+        {
+          //if(!IsUsbBusy())
+          {
+            SetTouchEvent();
+          }
+        }
+
+        GioInterruptFlag = FALSE;
+
+        return;
+    }
+}
+
+#ifdef UART_ENABLE
+void USART2_SendData(PUINT8 txbuf, UINT16 length)
+{
+    UINT8 TxCnt = 0;
+
+    while(TxCnt < length)
+    {
+        //PRINT("TxCnt:%d\r\n", TxCnt);
+        //USART_SendData(USART2, txbuf[TxCnt++]);
+        //while(USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET)
+        {
+            /* waiting for sending finish */
+        }
+    //        while(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) == RESET)
+    //        {
+    //            /* waiting for receiving finish */
+    //        }
+    //        RxBuffer[RxCnt++] = (USART_ReceiveData(USART2));
+
+        //PRINT("TxCnt:%d\r\n", TxCnt);
+    }
+}
+//__attribute__((section(".highcode")))
+void UartUpdatePos(POINTER * pTP)
+{
+#ifdef SELF_UART_PROTOCOL
+  UINT8 t,i;
+  UINT8 bParity = 0x56;
+  UINT16 x,y;
+
+  Press_Flag = Press_Flag_Bak0 | Press_Flag_Bak1;
+
+  for(i = 0; i < MAX_POINT; i++)
+  {
+    if(Press_Flag & (1L << i))
+    {
+      break;
+    }
+  }
+  if(i==MAX_POINT)
+  {
+    return;
+  }
+
+  t = i << 3;
+
+  if(pTP[i].Tip_Switch == 0)
+  {
+    t |= 0x04;
+  }
+  else
+  {
+    if(Press_Flag_Bak1==0)
+    {
+      t |= 0x01;
+    }
+    else
+    {
+      t |= 0x02;
+    }
+  }
+
+  x = pTP[i].X_pos_back;
+  y = pTP[i].Y_pos_back;
+
+  bParity += t;
+
+  bParity+= (UINT8)x;
+  bParity+= (UINT8)(x>>8);
+  bParity+= (UINT8)y;
+  bParity+= (UINT8)(y>>8);
+
+  TxBuff[0] = 0x55;
+  TxBuff[1] = 0x56;
+  TxBuff[2] = t;
+  TxBuff[3] = x&0xFF;
+  TxBuff[4] = x>>8;
+  TxBuff[5] = y&0xFF;
+  TxBuff[6] = y>>8;
+  TxBuff[7] = 0xFF;
+  TxBuff[8] = 0x00;
+  TxBuff[9] = bParity;
+
+  USART2_SendData( TxBuff, 10 );
+#else
+  UINT8 t,i;
+  UINT8 bParity = 0x52;
+  UINT16 x,y;
+
+  Press_Flag = Press_Flag_Bak0 | Press_Flag_Bak1;
+
+  for(i = 0; i < MAX_POINT; i++)
+  {
+    if(Press_Flag & (1L << i))
+    {
+      break;
+    }
+  }
+  if(i==MAX_POINT)
+  {
+    return;
+  }
+
+  if(pTP[i].Tip_Switch == 0)
+  {
+    t = 0x84;
+  }
+  else
+  {
+    if(Press_Flag_Bak1==0)
+    {
+      t = 0x81;
+    }
+    else
+    {
+      t = 0x82;
+    }
+  }
+
+
+    x = (UINT32)pTP[i].X_pos * 4095 / 16383;
+    y = (UINT32)pTP[i].Y_pos * 4095 / 9599;
+//    x = (UINT32)UartPosX * 4095 / 16383;
+//    y = (UINT32)UartPosY * 4095 / 9599;
+
+
+  bParity += t;
+
+  bParity+= (UINT8)x;
+  bParity+= (UINT8)(x>>8);
+  bParity+= (UINT8)y;
+  bParity+= (UINT8)(y>>8);
+
+  if (config.uart_protocol==EN_UART_PROTOCAL_10)
+  {
+    TxBuff[0] = 0x55;
+    TxBuff[1] = 0x54;
+    TxBuff[2] = t;
+    TxBuff[3] = x&0xFF;
+    TxBuff[4] = x>>8;
+    TxBuff[5] = y&0xFF;
+    TxBuff[6] = y>>8;
+    TxBuff[7] = 0xFF;
+    TxBuff[8] = 0x00;
+    TxBuff[9] = bParity;
+
+    if(bTransmitEn && !UsbReportPosEn)
+    {
+      //DevEp1In(EP1_BUFF_SIZE);
+
+      //RF_Enqueue(1, RF_PACKAGE_REPORT, 9, Ep1Buffer);
+      //PRINT("Mouse\n");
+
+      //memcpy(USBFS_EP1_Buf, TxBuff, 10);
+      //RF_Enqueue(1, RF_PACKAGE_REPORT, 10, Ep1UartBuffer);
+      //memcpy(Ep1UartBuffer, TxBuff, 10);
+
+    }
+    else
+    {
+      USART2_SendData(TxBuff, 10);
+    }
+
+
+  }
+  else
+  {
+    TxBuff[0] = 0xAA;
+    TxBuff[1] = 0x55;
+    TxBuff[2] = x&0xFF;
+    TxBuff[3] = x>>8;
+    TxBuff[4] = y&0xFF;
+    TxBuff[5] = y>>8;
+    TxBuff[6] = t;
+    TxBuff[7] = bParity-0x53;
+
+    if(bTransmitEn && !UsbReportPosEn)
+    {
+      //DevEp1In(EP1_BUFF_SIZE);
+
+      //RF_Enqueue(1, RF_PACKAGE_REPORT, 9, Ep1Buffer);
+      //PRINT("Mouse\n");
+
+      //memcpy(USBFS_EP1_Buf, TxBuff, 10);
+      //RF_Enqueue(1, RF_PACKAGE_REPORT, 10, Ep1UartBuffer);
+      //memcpy(Ep1UartBuffer, TxBuff, 10);
+
+    }
+    else
+    {
+      USART2_SendData(TxBuff, 8);
+    }
+  }
+
+#endif
+}
+
+
+#ifdef NEW_REVOLVE_PROTOCAL
+
+BOOL PosConvert(POINTER* TP, UINT8 index)
+{
+    INT16 tmpX ,tmpY;
+
+    tmpX = TP[index].X_pos;
+    tmpY = TP[index].Y_pos;
+    //�����ڱߵ�����ü���
+
+    switch(TpOption.uart_cmd)
+    {
+      case UART_COMMAND_A_0:
+        tmpX = (INT32)((INT16)TP[index].X_pos - TpOption.uart_long_cmd.ax) * RESOLUTION_X / (TpOption.uart_long_cmd.dx-TpOption.uart_long_cmd.ax);
+        tmpY = (INT32)((INT16)TP[index].Y_pos - TpOption.uart_long_cmd.ay) * RESOLUTION_Y / (TpOption.uart_long_cmd.dy-TpOption.uart_long_cmd.ay);
+        break;
+
+      case UART_COMMAND_B_0:
+        if(UsbReportPosEn)  //�ü�USB�����꣬OSD�˵�����������ʾ���������겻��
+        {
+
+          tmpX = (INT32)((INT16)TP[index].X_pos - TpOption.uart_long_cmd.ax) * RESOLUTION_X / (TpOption.uart_long_cmd.dx-TpOption.uart_long_cmd.ax);
+          tmpY = (INT32)((INT16)TP[index].Y_pos - TpOption.uart_long_cmd.ay) * RESOLUTION_Y / (TpOption.uart_long_cmd.dy-TpOption.uart_long_cmd.ay);
+        }
+        break;
+
+      case UART_COMMAND_A_90:
+      case UART_COMMAND_B_90:
+      {
+        tmpX  = TpOption.uart_long_cmd.ax  + (((INT32)((INT16)TpOption.uart_long_cmd.Ay - TP[index].Y_pos)*TpOption.uart_long_cmd.mx)>>10);
+        tmpY  = TpOption.uart_long_cmd.ay  + (((INT32)((INT16)TP[index].X_pos - TpOption.uart_long_cmd.Ax)*TpOption.uart_long_cmd.my)>>10);
+      }
+      case UART_SWITCH_90:
+      {
+        if(UartRevolveEnable)
+        {
+          TP[index].X_pos_back  = RESOLUTION_X - (UINT32)TP[index].Y_pos * RESOLUTION_X / RESOLUTION_Y;
+          TP[index].Y_pos_back   = (UINT32)TP[index].X_pos * RESOLUTION_Y / RESOLUTION_X;
+        }
+        break;
+      }
+
+      case UART_COMMAND_A_180:
+      case UART_COMMAND_B_180:
+      {
+        tmpX  = (INT16)RESOLUTION_X - (INT32)((INT16)TP[index].X_pos - (INT16)TpOption.uart_long_cmd.ax) * RESOLUTION_X / (TpOption.uart_long_cmd.dx-TpOption.uart_long_cmd.ax);
+        tmpY  = (INT16)RESOLUTION_Y - (INT32)((INT16)TP[index].Y_pos - (INT16)TpOption.uart_long_cmd.ay) * RESOLUTION_Y / (TpOption.uart_long_cmd.dy-TpOption.uart_long_cmd.ay);
+      }
+      case UART_SWITCH_180:
+      {
+        if(UartRevolveEnable)
+        {
+          TP[index].X_pos_back  = RESOLUTION_X - TP[index].X_pos;
+          TP[index].Y_pos_back   = RESOLUTION_Y - TP[index].Y_pos;
+        }
+        break;
+      }
+
+      case UART_COMMAND_A_270:
+      case UART_COMMAND_B_270:
+      {
+        tmpX  = (INT16)TpOption.uart_long_cmd.ax  + (((INT32)((INT16)TP[index].Y_pos - (INT16)TpOption.uart_long_cmd.Ay)*TpOption.uart_long_cmd.mx)>>10);
+        tmpY  = (INT16)TpOption.uart_long_cmd.ay  + (((INT32)((INT16)TpOption.uart_long_cmd.Ax - (INT16)TP[index].X_pos)*TpOption.uart_long_cmd.my)>>10);
+      }
+      case UART_SWITCH_270:
+      {
+        if(UartRevolveEnable)
+        {
+          TP[index].X_pos_back  = (UINT32)TP[index].Y_pos * RESOLUTION_X / RESOLUTION_Y;
+          TP[index].Y_pos_back  = RESOLUTION_Y - (UINT32)TP[index].X_pos * RESOLUTION_Y / RESOLUTION_X;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+
+
+    if(TpOption.uart_cmd == UART_COMMAND_A_0
+        || TpOption.uart_cmd == UART_COMMAND_A_90
+        || TpOption.uart_cmd == UART_COMMAND_A_180
+        || TpOption.uart_cmd == UART_COMMAND_A_270
+        )
+    {
+      if(tmpX >= (INT16)TpOption.uart_long_cmd.dx)
+      {
+        tmpX = TpOption.uart_long_cmd.dx-1;
+      }
+      if(tmpY >= (INT16)TpOption.uart_long_cmd.dy)
+      {
+        tmpY = TpOption.uart_long_cmd.dy-1;
+      }
+      if(tmpX < (INT16)TpOption.uart_long_cmd.ax)
+      {
+        tmpX = TpOption.uart_long_cmd.ax;
+      }
+      if(tmpY < (INT16)TpOption.uart_long_cmd.ay)
+      {
+        tmpY = TpOption.uart_long_cmd.ay;
+      }
+    }
+    else {
+      if(tmpX < 0)
+      {
+        tmpX = 0;
+        OutRangeFlag &= ~(1L<<index);
+      }
+      if(tmpX >= RESOLUTION_X)
+      {
+        tmpX = RESOLUTION_X;
+        OutRangeFlag &= ~(1L<<index);
+      }
+      if(tmpY < 0)
+      {
+        tmpY = 0;
+        OutRangeFlag &= ~(1L<<index);
+      }
+      if(tmpY >= RESOLUTION_Y)
+      {
+        tmpY = RESOLUTION_Y;
+        OutRangeFlag &= ~(1L<<index);
+      }
+    }
+
+    TP[index].X_pos = tmpX;
+    TP[index].Y_pos = tmpY;
+
+    return TRUE;
+}
+
+
+extern BOOL IsBLEConnected(void);
+void CheckUart0Comand( void )
+{
+  static UINT8 offset = 0;
+  static UINT8 cmd_len = 0;
+
+  UINT8 d;
+  //OPERATE_SYSTEM os;
+  UINT8* pBuf = &UartCmdBuf[1];
+#if 0
+  while( R8_UART0_RFC )
+  {
+    d = R8_UART0_RBR;
+
+    if(uart_state == UART_STATE_IDLE)
+    {
+      switch(d)
+      {
+        case UART_COMMAND_B_180:
+        case UART_COMMAND_B_0:
+          cmd_len = 14;
+          uart_state = UART_STATE_RECV_CMD;
+          break;
+        case UART_COMMAND_B_90:
+        case UART_COMMAND_B_270:
+        case UART_COMMAND_A_90:
+        case UART_COMMAND_A_270:
+          cmd_len = sizeof(UART_LONG_CMD) - 2;
+          uart_state = UART_STATE_RECV_CMD;
+          break;
+        default:
+          cmd_len = 2;
+          uart_state = UART_STATE_RECV_CMD;
+          break;
+      }
+      offset = 0;
+    }
+
+    if(uart_state==UART_STATE_RECV_CMD)
+    {
+      if(offset <  cmd_len)
+      {
+        pBuf[offset] = d;
+        offset++;
+        if(offset>=cmd_len)
+        {
+          UINT8 chksum = 0;
+          do
+          {
+            chksum += pBuf[--offset];
+          }while(offset);
+
+          if(chksum==0)
+          {
+            uart_state = UART_STATE_CHECK_CMD;
+          }
+          else
+          {
+            uart_state = UART_STATE_IDLE;
+          }
+        }
+      }
+    }
+  }
+#else
+
+    while(USART_GetFlagStatus(USART2, USART_FLAG_RXNE) != RESET)
+    {
+      pipe_write_c(&uart_cmd_pipe, (UINT8)USART2->DATAR);
+
+    }
+
+//      while(pipe_read(&uart_cmd_pipe, &d, 1))
+//    {
+//           USART2_SendData(&d, 1);
+//    }
+
+    if(uart_state != UART_STATE_CHECK_CMD)
+    {
+      while(pipe_read(&uart_cmd_pipe, &d, 1))
+      {
+      if(uart_state==UART_STATE_IDLE)
+      {
+         switch(d)
+        {
+          case UART_COMMAND_B_180:
+          case UART_COMMAND_B_0:
+            cmd_len = 14;
+            uart_state = UART_STATE_RECV_CMD;
+            break;
+          case UART_COMMAND_B_90:
+          case UART_COMMAND_B_270:
+          case UART_COMMAND_A_90:
+          case UART_COMMAND_A_270:
+            cmd_len = sizeof(UART_LONG_CMD) - 2;
+            uart_state = UART_STATE_RECV_CMD;
+            break;
+          default:
+            cmd_len = 1;
+            uart_state = UART_STATE_RECV_CMD;
+            break;
+        }
+
+        offset = 0;
+      }
+      if(uart_state==UART_STATE_RECV_CMD)
+      {
+
+        if(offset <  cmd_len)
+        {
+          pBuf[offset] = d;
+          offset++;
+          if(offset>=cmd_len)
+          {
+            uart_state = UART_STATE_CHECK_CMD;
+            break;
+          }
+        }
+      }
+    }
+  }
+#endif
+
+  if(uart_state == UART_STATE_CHECK_CMD)
+  {
+
+    {
+      switch(pBuf[0])
+      {
+        case EN_UART_DIS_USB:
+        {
+//          if( NoTouchTimer > 1)
+//          {
+//            UsbReportPosEn = DISABLE;
+//            UartReportPosEn = ENABLE;
+//          }
+//          else
+//          {
+//            return;
+//          }
+          tmos_start_task(TaskID, ENABLE_UART_EVT, 10);
+          break;
+        }
+        case EN_USB_DIS_UART:
+        case EN_USB_EN_UART:
+//          if(NoTouchTimer==0)
+//          {
+////            TP[0].Tip_Switch = 0;
+////            UartUpdatePos(&TP[0]);
+//            UartReportPosEn = DISABLE;
+//            return;
+//          }
+//          {
+//            UartReportPosEn = DISABLE;
+//            UsbReportPosEn = ENABLE;
+//          }
+          tmos_start_task(TaskID, ENABLE_USB_EVT, 10);
+          break;
+//        case EN_USB_EN_UART:
+//          UsbReportPosEn = ENABLE;
+//          UartReportPosEn = ENABLE;
+//          break;
+//        case GET_DEVICE_NAME:
+//        {
+//            USART2_SendData((PUINT8)DeviceName,strlen(DeviceName)+1);
+//          break;
+//        }
+//        case GET_BLE_CONNECT_STATE:
+//        {
+//          if(IsBLEConnected())
+//          {
+////            os = GetOperateSystem();
+////            if(os != IOS)
+////            {
+//              d = 1;
+////            }
+////            else
+////            {
+////              d = 2;
+////            }
+//             USART2_SendData(&d, 1);
+//          }
+//          else
+//          {
+//            d = 0;
+//            USART2_SendData(&d, 1);
+//          }
+//          break;
+//        }
+
+//        case ERASE_ALL_BONDS:
+//        {
+//          HidDev_SetParameter(HIDDEV_ERASE_ALLBONDS,0,0);
+//          break;
+//        }
+//        case DISCONNECT_BLE:
+//        {
+//          if(IsBLEConnected())
+//          {
+//             GAPBondMgr_SetParameter(GAPBOND_DISABLE_SINGLEBOND, sizeof(UINT8)*7, (UINT8*)HostAddr);
+//             GAPRole_TerminateLink( gapConnHandle );
+//          }
+//          //UINT8 adv_Event_Type = GAP_ADTYPE_ADV_IND;
+//          //GAPRole_SetParameter(GAPROLE_ADV_EVENT_TYPE, sizeof(UINT8), &adv_Event_Type);
+//          break;
+//        }
+        case ENABLE_GRAB_CONNECT:
+        {
+
+          break;
+        }
+        case EN_BLE_APPLE_REPORT:
+//          os = GetOperateSystem();
+//          if(os != IOS)
+//          {
+//            SetOperateSystem(IOS);
+////            USART2_SendData(&pBuf[0], 1);
+//            R8_SAFE_ACCESS_SIG = SAFE_ACCESS_SIG1;
+//            R8_SAFE_ACCESS_SIG = SAFE_ACCESS_SIG2;
+//            R8_RST_WDOG_CTRL |= RB_SOFTWARE_RESET;
+//          }
+          break;
+        case EN_BLE_WIN_REPORT:
+//          os = GetOperateSystem();
+//          if(os != ANDROID)
+//          {
+//            SetOperateSystem(ANDROID);
+//            USART2_SendData(&pBuf[0], 1);
+//            R8_SAFE_ACCESS_SIG = SAFE_ACCESS_SIG1;
+//            R8_SAFE_ACCESS_SIG = SAFE_ACCESS_SIG2;
+//            R8_RST_WDOG_CTRL |= RB_SOFTWARE_RESET;
+//          }
+
+          DeviceMode  = DEVICE_MODE_MULTITOUCH;
+
+          break;
+      #ifdef MOUSE_REPORT
+        case SET_OS_TYPE_NEW_MAC:
+            DeviceMode  = DEVICE_MODE_MOUSE;
+          break;
+        case SET_OS_TYPE_OLD_MAC:
+            DeviceMode = DEVICE_MODE_MOUSE;
+          break;
+      #endif
+        case UART_SWITCH_90:
+        case UART_SWITCH_270:
+        case UART_SWITCH_180:
+        {
+          UartRevolveEnable = 1;
+          TpOption.uart_cmd = (UART_COMMAND)pBuf[0];;
+          break;
+        }
+        case UART_SWITCH_0:
+        {
+          UartRevolveEnable = 0;
+        }
+        break;
+        case UART_COMMAND_A_90:
+        case UART_COMMAND_A_270:
+        case UART_COMMAND_B_90:
+        case UART_COMMAND_B_270:
+        {
+          UINT16  mx = (pBuf[9]<<8) + pBuf[10];
+          UINT16  my = (pBuf[11]<<8) + pBuf[12];
+          if(mx!=0 && my!=0)
+          {
+            TpOption.uart_cmd = (UART_COMMAND)pBuf[0];
+
+            TpOption.uart_long_cmd.ax = ((UINT16)pBuf[1]<<8) + pBuf[2];
+            TpOption.uart_long_cmd.ay = ((UINT16)pBuf[3]<<8) + pBuf[4];
+
+            TpOption.uart_long_cmd.dx = ((UINT16)pBuf[5]<<8) + pBuf[6];
+            TpOption.uart_long_cmd.dy = ((UINT16)pBuf[7]<<8) + pBuf[8];
+
+            TpOption.uart_long_cmd.Ax = ((UINT16)pBuf[13]<<8) + pBuf[14];
+            TpOption.uart_long_cmd.Ay = ((UINT16)pBuf[15]<<8) + pBuf[16];
+
+            TpOption.uart_long_cmd.Dx = ((UINT16)pBuf[17]<<8) + pBuf[18];
+            TpOption.uart_long_cmd.Dy = ((UINT16)pBuf[19]<<8) + pBuf[20];
+
+            if(TpOption.uart_cmd == UART_COMMAND_B_90 || TpOption.uart_cmd == UART_COMMAND_B_270)
+            {
+              TpOption.uart_long_cmd.ax = 0;
+              TpOption.uart_long_cmd.ay = 0;
+
+              TpOption.uart_long_cmd.dx = RESOLUTION_X;
+              TpOption.uart_long_cmd.dy = RESOLUTION_Y;
+            }
+            else
+            {
+              TpOption.uart_long_cmd.ax = (UINT32)TpOption.uart_long_cmd.ax*RESOLUTION_X/mx;
+              TpOption.uart_long_cmd.ay = (UINT32)TpOption.uart_long_cmd.ay*RESOLUTION_Y/my;
+
+              TpOption.uart_long_cmd.dx = (UINT32)TpOption.uart_long_cmd.dx*RESOLUTION_X/mx;
+              TpOption.uart_long_cmd.dy = (UINT32)TpOption.uart_long_cmd.dy*RESOLUTION_Y/my;
+            }
+
+            TpOption.uart_long_cmd.Ax = (UINT32)TpOption.uart_long_cmd.Ax*RESOLUTION_X/mx;
+            TpOption.uart_long_cmd.Ay = (UINT32)TpOption.uart_long_cmd.Ay*RESOLUTION_Y/my;
+
+            TpOption.uart_long_cmd.Dx = (UINT32)TpOption.uart_long_cmd.Dx*RESOLUTION_X/mx;
+            TpOption.uart_long_cmd.Dy = (UINT32)TpOption.uart_long_cmd.Dy*RESOLUTION_Y/my;
+
+            if(TpOption.uart_cmd == UART_COMMAND_A_90 || TpOption.uart_cmd == UART_COMMAND_B_90)
+            {
+              TpOption.uart_long_cmd.mx = ((UINT32)(TpOption.uart_long_cmd.dx - TpOption.uart_long_cmd.ax) << 10) /(TpOption.uart_long_cmd.Ay - TpOption.uart_long_cmd.Dy);
+              TpOption.uart_long_cmd.my = ((UINT32)(TpOption.uart_long_cmd.dy - TpOption.uart_long_cmd.ay) << 10) /(TpOption.uart_long_cmd.Dx - TpOption.uart_long_cmd.Ax);
+            }
+            else
+            {
+              TpOption.uart_long_cmd.mx = ((UINT32)(TpOption.uart_long_cmd.dx - TpOption.uart_long_cmd.ax) << 10) /(TpOption.uart_long_cmd.Dy - TpOption.uart_long_cmd.Ay);
+              TpOption.uart_long_cmd.my = ((UINT32)(TpOption.uart_long_cmd.dy - TpOption.uart_long_cmd.ay) << 10) /(TpOption.uart_long_cmd.Ax - TpOption.uart_long_cmd.Dx);
+            }
+          }
+
+          break;
+        }
+        case UART_COMMAND_A_0:
+        case UART_COMMAND_A_180:
+        case UART_COMMAND_B_0:
+        case UART_COMMAND_B_180:
+        {
+            TpOption.uart_cmd = (UART_COMMAND)pBuf[0];
+
+            if(TpOption.uart_cmd == UART_COMMAND_B_0 || TpOption.uart_cmd == UART_COMMAND_B_180)
+            {
+              UINT16  mx = (pBuf[9]<<8) + pBuf[10];
+              UINT16  my = (pBuf[11]<<8) + pBuf[12];
+              if(mx!=0 && my!=0)
+              {
+                TpOption.uart_long_cmd.ax = ((UINT16)pBuf[1]<<8) + pBuf[2];
+                TpOption.uart_long_cmd.ay = ((UINT16)pBuf[3]<<8) + pBuf[4];
+
+                TpOption.uart_long_cmd.dx = ((UINT16)pBuf[5]<<8) + pBuf[6];
+                TpOption.uart_long_cmd.dy = ((UINT16)pBuf[7]<<8) + pBuf[8];
+
+                TpOption.uart_long_cmd.ax = (UINT32)TpOption.uart_long_cmd.ax*RESOLUTION_X/mx;
+                TpOption.uart_long_cmd.ay = (UINT32)TpOption.uart_long_cmd.ay*RESOLUTION_Y/my;
+
+                TpOption.uart_long_cmd.dx = (UINT32)TpOption.uart_long_cmd.dx*RESOLUTION_X/mx;
+                TpOption.uart_long_cmd.dy = (UINT32)TpOption.uart_long_cmd.dy*RESOLUTION_Y/my;
+              }
+            }
+            else
+            {
+                TpOption.uart_long_cmd.ax = 0;
+                TpOption.uart_long_cmd.ay = 0;
+
+                TpOption.uart_long_cmd.dx = RESOLUTION_X;
+                TpOption.uart_long_cmd.dy = RESOLUTION_Y;
+            }
+          }
+          break;
+        default:
+          break;
+      }
+
+      d = pBuf[0];
+      USART2_SendData(&d, 1);
+
+      uart_state = UART_STATE_IDLE;
+    }
+  }
+}
+
+#endif
+#endif
+
+BOOL  CheckUsbStatus()
+{
+//  if(config.remote_wakeup_en || config.usb_bus_check_en==0)
+//    return FALSE;
+//
+//
+//   if(((DeviceMode == DEVICE_MODE_MULTITOUCH) && (USBFS_UEP_T_RES_NAK != (USBFSD->UEP1_CTRL_H & USBFS_UEP_T_RES_MASK)))
+//       ||(DeviceMode != DEVICE_MODE_MULTITOUCH && (USBFS_UEP_T_RES_NAK != (USBFSD->UEP3_CTRL_H & USBFS_UEP_T_RES_MASK))))
+//   {
+//
+//       IsDebugMode  = 0;
+//
+//       USBFS_Device_Init( ENABLE , PWR_VDD_SupplyVoltage());
+//
+//       PRINT("reset usb\n");
+//
+//       return TRUE;
+//   }
+//   else
+//   {
+//       if(DeviceMode == DEVICE_MODE_MULTITOUCH)
+//       {
+//           USBFS_EP1_Buf[0] = 0;
+//           USBFSD->UEP1_TX_LEN  = 0;
+//           USBFSD->UEP1_CTRL_H = (USBFSD->UEP1_CTRL_H & ~ USBFS_UEP_T_RES_MASK) | USBFS_UEP_T_RES_ACK;
+//       }
+//       else
+//       {
+//           USBFSD->UEP3_TX_LEN  = 0;
+//           USBFSD->UEP3_CTRL_H = (USBFSD->UEP3_CTRL_H & ~ USBFS_UEP_T_RES_MASK) | USBFS_UEP_T_RES_ACK;
+//       }
+//   }
+   return FALSE;
+}
+
+
+
+__attribute__((section(".highcode")))
+UINT16 PosReverse(UINT16 pos, UINT16 res)
+{
+  if(pos < res)
+    pos = res - pos;
+  else
+    pos  = 0;
+
+  return pos;
+}
+
+#ifdef CHIP_TYPE_GT738X
+void AppendReleaseFrame()
+{
+  if(Press_Flag_Bak0==0 && Press_Flag!=0)
+  {
+    Press_Flag = 0;
+    GioInterruptFlag = TRUE;
+    ReleaseFlag = 1;
+  }
+  else
+  {
+    ReleaseFlag = 0;
+  }
+}
+#endif
+
+
+UINT16 GetCheckSum8(UINT8* pBuf, UINT8 len)
+{
+    UINT16 wChksum = 0;
+    UINT8 i;
+    for(i=0; i<len; i++)
+    {
+        wChksum+=pBuf[i];
+    }
+    return wChksum;
+}
+
+BOOL IsBerlinChipType(CHIP_TYPE type)
+{
+    if(type!=CHIP_TYPE_9XXX && type!=CHIP_TYPE_9PXX && type!=CHIP_TYPE_73XX)
+    {
+        return TRUE;
+    }
+    return FALSE;
+}
+

project/solution/ble_hid_composite/touch/TouchConfig.c

@@ -0,0 +1,190 @@
+#include "TouchConfig.h"
+#include <string.h>
+#include "TouchCommon.h"
+#include "HidReport.h"
+#include "bsp_param.h"
+#include "api.h"
+
+#if USBCONFIG
+ST_CONFIG const_config ={
+    24,//sizeof(ST_CONFIG) - 13,//0x18 + 10,
+    EN_USB_UART,
+    0,
+    0,
+    0,
+    EN_MULTITOUCH_ONLY,
+    EN_UART_PROTOCAL_10,  //0x60
+    0x27,
+    0xC6,
+    0x09,
+    0x28,
+    0,
+    0,
+    0,
+    0x08,
+    0x79,
+    0x03,
+    0x8a,
+    0x40,
+    0x00,  //16384
+    0x25,
+    0x80,  //9600
+    {0,0,0,0,0,0},
+    {0,0},
+};
+
+__attribute__ ((aligned(4))) ST_CONFIG  config;
+
+UINT16 GetCheckSum(PUINT8 cfg)
+{
+    UINT8 i;
+    UINT16 chk_sum = 0;
+
+    for(i = 0; i< cfg[0] - 2; i++)
+    {
+        chk_sum += *(cfg + i);
+    }
+    return chk_sum;
+}
+
+BOOL CheckConfigValid(PUINT8 cfg)
+{
+    UINT16 chk_sum;
+    UINT16 tmp;
+
+    if((cfg[0] == 0) || (cfg[0] > CONFIG_SIZE))
+    {
+        PRINT( "CONFIG NG\n" );
+        return 0;
+    }
+    if(cfg[0] <= CONFIG_SIZE)
+    {
+        chk_sum = GetCheckSum(cfg);
+
+        tmp = cfg[cfg[0] - 2];
+
+        tmp = (tmp << 8) + cfg[cfg[0] - 1];
+
+        if(chk_sum != tmp)
+        {
+           PRINT( "CONFIG CHKSUM ERROR\n" );
+
+           return 0;
+        }
+    }
+
+    return 1;
+}
+
+void ConfigInit()
+{
+    UINT16 temp;
+
+    PRINT("Load config\r\n");
+
+    GetConfigFromFlash((PUINT8)&config);
+
+    if(!CheckConfigValid((PUINT8)&config))
+    {
+      PRINT("Config invalid\r\n");
+
+      {
+          UINT16 chksum;
+          PRINT("Reset config\r\n");
+
+          config = const_config;
+          config.len = CONFIG_SIZE;
+          chksum = GetCheckSum((PUINT8)&config);
+          //config.check_sum = chksum;
+          ((PUINT8)&config)[CONFIG_SIZE-2] = chksum >> 8;
+          ((PUINT8)&config)[CONFIG_SIZE-1] = chksum;
+      }
+
+      SaveConfig((PUINT8)&config);
+    }
+
+
+    temp = ((UINT16)config.resolution_x_h << 8) + config.resolution_x_l;
+    if (0 == temp)
+    {
+        config.resolution_x_h = 0x40;  //16384
+        config.resolution_x_l = 0x00;
+    }
+
+    temp = ((UINT16)config.resolution_y_h << 8) + config.resolution_y_l;
+    if (0 == temp)
+    {
+        config.resolution_y_h = 0x25;  //9600
+        config.resolution_y_l = 0x80;
+    }
+}
+
+void GetConfigFromFlash(PUINT8 pBuf)
+{
+    bsp_param_read(pBuf, TOUCH_CONFIG_ADDR, sizeof(ST_CONFIG));
+}
+
+void SaveConfig(PUINT8 cfg)
+{
+    if(CheckConfigValid(cfg))
+    {
+        bsp_param_write(cfg, TOUCH_CONFIG_ADDR, sizeof(ST_CONFIG));
+
+        bsp_param_sync();
+    }
+}
+
+UINT32 GetHandsShakeValue(UINT8* buf)
+{
+    UINT8 i;
+    UINT32 HandsShakeValue = 0x0928;
+
+    for(i = 0; i < 16; i++)
+    {
+        HandsShakeValue = (HandsShakeValue * 9897) + (buf[i]);
+    }
+
+    return HandsShakeValue;
+}
+
+void CheckFlag()
+{
+  //ÓëAP³ÌÐòµÄÎÕÊÖ±ê¼Ç
+    UINT32 uid[4];
+
+    UINT32 hash_flag;
+
+    bsp_param_read((UINT8*)&hash_flag, TOUCH_HASH_FLAG_ADDR, 4);
+
+    os_spiflash_id_get((UINT8*)uid);
+
+    uid[3] = GetHandsShakeValue((UINT8*)uid);
+
+    if(hash_flag!=uid[3])
+    {
+        //SoftResetChip();
+    }
+}
+
+CHIP_TYPE GetChipTypeFromFlash(void)
+{
+    UINT8 ct;
+
+    bsp_param_read((u8 *)&ct, TOUCH_CHIP_TYPE_ADDR, 1);
+
+    return ct;
+}
+
+void SaveChipTypeToFlash(CHIP_TYPE chip_type)
+{
+    UINT8 ct = chip_type;
+
+    bsp_param_write((u8 *)&ct, TOUCH_CHIP_TYPE_ADDR, 1);
+
+    bsp_param_sync();
+}
+#endif
+
+
+
+

project/solution/ble_hid_composite/touch/include/AutoTest.h

@@ -0,0 +1,29 @@
+/*
+ * AutoTest.h
+ *
+ *  Created on: Jun 13, 2024
+ *      Author: Administrator
+ */
+
+#ifndef APP_INCLUDE_AUTOTEST_H_
+#define APP_INCLUDE_AUTOTEST_H_
+#include "typedef.h"
+#if AUTO_TEST
+typedef enum{
+    TEST_INIT,
+    TEST_READY,
+    TEST_BUSY,
+    TEST_FINISH,
+}TEST_STATE;
+void AutoTestInit(void);
+TEST_STATE GetTestState(void);
+void ReturnTestResult(BOOL rst);
+void AutoTestHandle(void);
+#define TEST_START_PIN      GPIO_Pin_5      //PA5
+#define TEST_BUSY_PIN       GPIO_Pin_1      //PB1
+#define TEST_OK_PIN         GPIO_Pin_6      //PA6
+#define TEST_NG_PIN         GPIO_Pin_7      //PA7
+
+#endif
+
+#endif /* APP_INCLUDE_AUTOTEST_H_ */

project/solution/ble_hid_composite/touch/include/BerlinTouch.h

@@ -0,0 +1,50 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : IIC.h
+* Author             : WCH
+* Version            : V1.0
+* Date               : 2018/12/12
+* Description        : 
+*******************************************************************************/
+
+/******************************************************************************
+* MAX FREQ 400K Hz
+* DEV_ADDR_T = DEV_ADDR + W/R
+* HOST WRITE
+* +-------+----------+-----------+-----+------------+-----+------------+-----+----------+-----+-----+------+
+* | START | DEV_ADDR | WRITE (0) | ACK | REG_ADDR_H | ACK | REG_ADDR_L | ACK | DATA ... | ... | ACK | STOP |
+* +-------+----------+-----------+-----+------------+-----+------------+-----+----------+-----+-----+------+
+* HOST READ
+* +-------+----------+----------+-----+------------+-----+------------+------+-------+----------+----------+-----+------+-----+-----+-----+-----+------+
+* | START | DEV_ADDR | READ (1) | ACK | REG_ADDR_H | ACK | REG_ADDR_L | STOP | START | DEV_ADDR | READ (1) | ACK | DATA | ACK | ... | ... | NAK | STOP |
+* +-------+----------+----------+-----+------------+-----+------------+------+-------+----------+----------+-----+------+-----+-----+-----+-----+------+
+******************************************************************************/
+
+#ifndef __BT79xx_H__
+#define __BT79xx_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "typedef.h"
+
+#define BT_GSTID_REG  0X824E    //GT9147��ǰ��⵽�Ĵ������
+
+/* Function Define */
+//extern UINT8    BT_Send_Cfg              ( void );
+void 	  BT_Init			        ( void );
+void    Rest_BT79XX( void );
+UINT8   BT_Touch_Check     ( void );
+UINT8   BT_Scan          ( void );
+
+
+UINT8 BT_RD_Reg(UINT32 reg,UINT8 *buf,UINT8 len);
+UINT8 BT_WR_Reg(UINT32 reg,UINT8 *buf,UINT8 len);
+void BT_Init(void);
+void BT_SetTouchEvent();
+extern BOOL EntryUpdateMode();
+	
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/solution/ble_hid_composite/touch/include/Gesture.h

@@ -0,0 +1,39 @@
+/********************************** (C) COPYRIGHT ******************************
+* File Name          :usb_driver.h
+* Author             : DL
+* Version            : V1.1
+* Date               : 2020/06/02
+* Description        : A demo for USB compound device created by CH552, support
+					   touch panel , and HID-compliant device.
+********************************************************************************/
+#ifndef _GESTURE_H
+#define _GESTURE_H
+#include "typedef.h"
+
+#ifdef GESTURE
+	extern UINT8 byTouchNumberChange;  //˫ָ���ʱ��¼��ָ���仯
+	extern UINT8 byTouchTime1;	        //��ָ���ʱ��ʱ
+	extern UINT8 byTouchTime2;	        //˫ָ���ʱ��ʱ
+//		extern UINT16 wCoorXBak[];	        //����X���꣬�����ж��Ƿ��л���
+//		extern UINT16 wCoorYBak[];	        //����Y���꣬�����ж��Ƿ��л���
+	extern UINT8 byFirstTouch;	        //����˫ָ��һ�ΰ���ȥ��
+	extern BOOL bMoveFlag;		        //˫ָ������־
+	extern BOOL bclickFlag;	        //˫ָ�����־
+	extern UINT8 byWheelUpDown;        //˫ָ������������¹�����־
+
+	extern void WheelMove(void);
+	extern UINT8 TwoPointsClick(void);
+	extern UINT8 FourfingersGesture(void);
+	
+#endif
+
+#ifdef DOUBLECLIK_FILETER
+extern UINT8 DoubleClickTimer;
+void DoubleClickFilter(BOOL flag, UINT8 id);
+#endif
+
+#ifdef CALL_OSD_MENU
+extern void CallOSDMenu(void);	
+#endif
+
+#endif

project/solution/ble_hid_composite/touch/include/GoodixTouch.h

@@ -0,0 +1,63 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : IIC.h
+* Author             : WCH
+* Version            : V1.0
+* Date               : 2018/12/12
+* Description        :
+*******************************************************************************/
+
+/******************************************************************************
+* MAX FREQ 400K Hz
+* DEV_ADDR_T = DEV_ADDR + W/R
+* HOST WRITE
+* +-------+----------+-----------+-----+------------+-----+------------+-----+----------+-----+-----+------+
+* | START | DEV_ADDR | WRITE (0) | ACK | REG_ADDR_H | ACK | REG_ADDR_L | ACK | DATA ... | ... | ACK | STOP |
+* +-------+----------+-----------+-----+------------+-----+------------+-----+----------+-----+-----+------+
+* HOST READ
+* +-------+----------+----------+-----+------------+-----+------------+------+-------+----------+----------+-----+------+-----+-----+-----+-----+------+
+* | START | DEV_ADDR | READ (1) | ACK | REG_ADDR_H | ACK | REG_ADDR_L | STOP | START | DEV_ADDR | READ (1) | ACK | DATA | ACK | ... | ... | NAK | STOP |
+* +-------+----------+----------+-----+------------+-----+------------+------+-------+----------+----------+-----+------+-----+-----+-----+-----+------+
+******************************************************************************/
+
+#ifndef __GT9xx_H__
+#define __GT9xx_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "typedef.h"
+
+#define GT_COMMAND_REG  0x8040
+#ifdef CHIP_TYPE_GT738X
+#define GT_GSTID_REG 	0X824E   	//GT9147��ǰ��⵽�Ĵ������
+#define GT_POINT_BASE_ADDR	0x824F		//
+#define GT_KEY_ADDR	 0x829F
+#else
+#define GT_GSTID_REG 	0X814E   	//GT9147��ǰ��⵽�Ĵ������
+#define GT_POINT_BASE_ADDR	0x814F		//
+#define GT_KEY_ADDR	 0x819F
+#endif
+
+
+/* Function Define */
+//extern UINT8    GT_Send_Cfg              ( void );
+void 	  GT_Init			        ( void );
+void    Rest_GT911( void );
+UINT8   GT_Touch_Check     ( void );
+UINT8   GT_Scan          ( void );
+
+
+
+void GT_Init(void);
+void GT_SetTouchEvent();
+
+//BOOL GT_Check_I2C_Address(u8 Address);
+
+void GT_Check_ESD();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/solution/ble_hid_composite/touch/include/HidReport.h

@@ -0,0 +1,158 @@
+/********************************** (C) COPYRIGHT ******************************
+* File Name          :HidReport.h
+* Author             : DL
+* Version            : V1.1
+* Date               : 2018/10/21
+* Description        : A demo for USB compound device created by CH552, support
+					   touch panel , and HID-compliant device.
+********************************************************************************/
+#ifndef	__HID_REPORT_H__
+#define __HID_REPORT_H__
+#include  "TouchCommon.h"
+#include "typedef.h"
+
+typedef enum _EN_COMMAND_TYPE {
+  I2C_READ = 0,
+  I2C_WRITE = 1,
+  I2C_READ_BLOCK = 2,
+  GET_VERSION = 3,
+  RESET_TOUCH_IC = 4,
+  REBOOT_FROM_SRAM = 5,
+  ENTRY_DEBUG_MODE = 6,
+  QUIT_DEBUG_MODE = 7,
+  HID_RECONNECT = 8,
+  HID_DISCONNECT = 9,
+  CHECK_HID_CONNECTION = 10,
+  CHECK_TOUCH_IC_CONNECTION = 11,
+  WRITE_ASYNC = 12,
+  READ_ASYNC = 13,
+  S818X_ENTER_UPDATE_MODE = 14,
+  NULL_COMMAND = 15,
+  NO_OPERATE = 16,
+  ENABLE_DIGITER_INTERFACE = 17,
+  DISABLE_DIGITER_INTERFACE =18,
+  CHECK_I2C_CONNECT = 19,
+  CHECK_BLE_CONNECT = 20,
+  DEBUG_PIPE = 21,
+  SYS_PIPE = 22,
+  START_SCAN_DEVICE = 23,
+  STOP_SCAN_DEVICE = 24,
+  ERASE_BONDING = 25,
+  BONDING = 26,
+  GET_BONDING_MAC = 27,
+  GET_DEVICE_MAC = 28,
+  DEVICE_ADDR = 29,
+  DEVICE_NAME = 30,
+  DEVICE_RSSI	= 31,
+  STOP_PRINT_LOG = 32,
+  NOTIFY = 33,
+  FORCE_TEMINATE_BLE_AND_ADV = 34,
+  RESET_USB_DEVICE = 35,
+  GTXXX_ENTER_UPDATE_MODE = 36,
+  BLE_RF_TEST = 37,
+  GET_TOUCH_CHIP_INFO = 38,
+  COOR_PIPE = 39,
+  ENABLE_INT_IRQ = 40,
+  DISABLE_INT_IRQ = 41,
+  ENABLE_ESD_CHECK = 42,
+  DISABLE_ESD_CHECK = 43,
+  FIRST_PACKAGE = 44,
+  SUBSEQUENT_PACKAGE  = 45,
+  LAST_PACKAGE = 46,
+  CET_TOUCH_CHIP_TYPE = 47,
+  GET_CONFIG = 48,
+  SET_CONFIG = 49,
+  GET_TEST_STATE = 59,
+  SET_TEST_RESULT = 60,
+} COMMAND_TYPE;
+
+
+typedef enum _BUFF_STATE {
+    BUFF_FREE,
+    BUFF_DATA_READY,
+} BUFF_STATE;
+
+
+typedef struct _PACKAGE_INFO {
+    COMMAND_TYPE command;
+    COMMAND_TYPE sub_command;
+    UINT32 address;
+    UINT8 buf[128];
+    UINT16 len;
+    UINT16 offset;
+} PACKAGE_INFO;
+
+#define COMMAND_HEARD_LEN 	7
+
+
+/*******************************************************************************/
+/* Macro Definition */
+// HID Report IDs for the service
+#define HID_RPT_ID_TOUCH_IN      13 // Mouse input report ID
+#define HID_RPT_ID_FEATURE       7  // Feature report ID
+
+#define HID_RPT_ID_KEY_IN        3  // Keyboard input report ID
+#define HID_RPT_ID_KEY_IN1        4  // Keyboard input report ID
+#define HID_RPT_ID_ABS_MOUSE_IN      5    // Mouse input report ID
+#define HID_RPT_ID_MOUSE_IN      11  // Mouse input report ID
+
+#define HID_RPT_ID_KEY_IN2       1  // LED output report ID
+#define HID_RPT_ID_MOUSE_IN2   8  // Feature report ID
+#define HID_RPT_ID_MOUSE_FEATURE       9  // Feature report ID
+
+#define HID_RPT_ID_APPLESTYLUS_IN        10
+#define HID_RPT_ID_STYLUS_IN         6
+
+#define HID_RPT_ID_APPLE_IN          14
+#define HID_RPT_ID_APPLE_IN1         15
+#define HID_RPT_ID_APPLE_IN2         16
+#define HID_RPT_ID_APPLE_IN3         17
+#define HID_RPT_ID_APPLE_IN4         18
+
+#define HID_BUTTOM_TYPE_FEATRUE              12
+#define HID_DEVICE_IDENTIFIER_FEATRUE                33
+
+#define HID_NUM_REPORTS          20
+
+#define EDP2_INPUT_REPORT_ID    2
+#define EDP2_OUTPUT_REPORT_ID0      3
+#define EDP2_OUTPUT_REPORT_ID1      4
+#define EDP2_ACK_REPORT_ID          5
+
+#define REPORTID_EXT_INFO 11
+#define REPORTID_EXT_INFO_SWITCH 12
+#define REPORTID_USB_BUS_TEST 0
+
+#define EXT_INFO_BEEP  0x01
+
+//#define REPORTID_PEN  	8
+
+#define PEN_TIP					0x01
+#define PEN_BARREL			0x02
+#define PEN_INVERT			0x04
+#define PEN_ERASER		  0x08
+#define PEN_HOVER				0x20
+
+void SoftResetChip();
+extern BOOL Ep2ReporteParse(UINT8* buf);
+extern UINT8 Absolute_Up_Pack( POINTER * pTP);
+extern UINT8 Append_Up_Pack( void );
+extern void CommandHandle( void );
+extern void Ep2OutputReport( void );
+extern void Ep2InputReport( void );
+extern void ReportInit( void );
+extern void ReportMousePos(POINTER * pTP);
+//extern void ReportToApple( POINTER * pTP);
+#if (defined S558 || defined S538 || defined S518 || defined S528F)
+extern UINT8 ProcessUSBCommand(COMMAND_TYPE cmd, PUINT8 buf);
+#endif
+
+#define  TOUCH_RELEASE_TIMES 	5
+#define USB_COMMAND_EVT									0x0001
+
+extern BOOL IsDebugMode;
+extern BOOL DisableDigiterInterface;
+extern BOOL OutDebugMode;
+extern BOOL ReportExtInfoEn;
+#endif
+/**************************** END *************************************/

project/solution/ble_hid_composite/touch/include/IIC.h

@@ -0,0 +1,34 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : IIC.h
+* Author             : WCH
+* Version            : V1.0
+* Date               : 2018/12/12
+* Description        :
+*******************************************************************************/
+
+#ifndef __IIC_H__
+#define __IIC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "typedef.h"
+#include "driver_gpio.h"
+
+#define   IIC_SDA     (GPIO_PIN_3)  //PA3
+#define   IIC_SCL     (GPIO_PIN_2)  //PA2
+#define   RST_PIN     (GPIO_PIN_1)  //PA1
+#define   INT_PIN     (GPIO_PIN_0)   //PA0
+
+void Touch_IIC_Init(void);
+BOOL GT_Check_I2C_Address(UINT8 Address);
+UINT8 IICReadOneByte(UINT32 ReadAddr);
+BOOL IICReadBytes(UINT32 ReadAddr,UINT8 *pBuffer,UINT16 Length);
+BOOL IICWriteOneByte(UINT32 WriteAddr,UINT8 DataToWrite);
+BOOL IICWriteBytes(UINT32 WriteAddr,UINT8 *pBuffer,UINT16 Length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

project/solution/ble_hid_composite/touch/include/MS928x.h

@@ -0,0 +1,218 @@
+/**
+******************************************************************************
+* @file    MS928X.h
+* @author
+* @version V2.2.0
+* @date    15-Oct-2013
+* @brief   Definitions for MS928X library.
+* @history 11-Nov-2013 Update for MS928X.
+*
+* Copyright (c) 2009-2013, MacroSilicon Technology Co.,Ltd.
+******************************************************************************/
+
+#ifndef _MACROSILICON_TECH_MS928X_H_
+#define _MACROSILICON_TECH_MS928X_H_
+
+// MS928X SDK version.
+#define MS928X_MAJOR_VER            (0x02)
+#define MS928X_MINOR_VER            (0x07)
+
+#define MS928X_I2C_ADDR_92          (0x92)
+#define MS928X_I2C_ADDR_9A          (0x9A)
+
+//
+// Video Input sources.
+//
+typedef enum _ms928x_video_input_format
+{
+    IN_ANALOG_VGA           = 0x1,
+    IN_ANALOG_YPBPR         = 0x2,
+    IN_ANALOG_RGBS          = 0x3,
+    IN_ANALOG_RGB_CS        = 0x4
+    //IN_DIGITAL_RGB          = 0x5,
+    //IN_DIGITAL_YCBCR444     = 0x6,
+    //IN_DIGITAL_YCBCR422     = 0x7
+}eVideoSource;
+
+typedef enum _ms928x_output_color_space
+{
+    OUT_CS_RGB      = 0,
+    OUT_CS_YCBCR444 = 1,
+    OUT_CS_YCBCR422 = 2
+}eOutColorSpace;
+
+// Video Configurations
+enum _ms928x_system_configuration
+{
+    SYS_CFG_DEFAULT             = 0,        // Default configuration.
+    // Video
+    SYS_CFG_SIG_CHANNEL_1       = 0x01,     // Select channel1 according to system board design
+    SYS_CFG_SIG_SYNC_SOG_1      = 0x02,     // Select SYNC1 and SOG1
+    SYS_CFG_OUT_COLOR_MODE      = 0x04,     // output color space user define flag
+    SYS_CFG_OUT_MODE_DVI        = 0x08,     // Output sink Mode user define flag, default DVI
+
+    //
+    SYS_CFG_VFE_PLL_OPTION      = 0x10,     // option VFE pll flag
+
+    SYS_CFG_DDC_DISABLED        = 0x20,     // hdmi tx ddc unuse flag
+
+    // For audio
+    SYS_CFG_RIGHT_JUSTIFY       = 0x40,     // 0:Left-justify, 1:Right-Justify;
+
+    //
+    SYS_CFG_VP_OPTION           = 0x80,     // option vertical position precise flag
+
+    // For Digital-In
+    SYS_CFG_DDR                 = 0x0100,   // no use
+    SYS_CFG_EMBEDDED_SYNC       = 0x0200,   // no use, For BT.656
+
+    SYS_CFG_USER_VIC            = 0x0400,   // user define VIC
+
+    SYS_CFG_AUTO_ADJUST_DISABLE = 0x0800,   // disable auto phase and border detection
+
+    SYS_CFG_MONO_COLOR_ENABLE   = 0x1000,   // enable mono color function
+
+    SYS_CFG_ADC_HIGH_BANDWIDTH  = 0x2000,   // adc select high bandwidth
+
+    SYS_CFG_ADDPLL_HIGH_REFCLK  = 0x4000,   // addpll select high reference clock
+
+    SYS_CFG_RESERVED            = 0x8000    // Reserved.
+};
+
+//
+// Define the severity status code.
+//
+#define STATE_SUCCESS                   (0)
+#define STATE_FATAL_ERR                 (0x80)
+#define STATE_CHIP_NOT_EXIST            (0x81)
+#define STATE_HPD_ERR                   (0x82)
+#define STATE_READ_EDID_ERR             (0x83)
+#define STATE_MODE_NOT_CHANGED          (0x84)
+#define STATE_NO_INPUT_SIGNAL           (0x85)
+#define STATE_INVALID_PARAMETER         (0x86)
+#define STATE_UNKNOWN                   (0xFF)
+
+//
+// Audio Module, please refer to HDMI 1.3a spec.
+//
+#define MS928X_AUDIO_DEFAULT            (0x0)   // Default audio: I2S_48K_2CH_16BITS
+
+// Select audio source.
+#define MS928X_AUD_MODE_I2S             (0x1)
+#define MS928X_AUD_MODE_SPDIF           (0x2)
+
+// Sample length
+#define MS928X_AUD_LEN_16               (0x2)
+#define MS928X_AUD_LEN_24               (0xB)
+// Sample Channel
+#define MS928X_AUD_CH_2CH               (0x1)
+#define MS928X_AUD_CH_8CH               (0x7)
+// Sample rate
+#define MS928X_AUD_RATE_44K1            (0x0)
+#define MS928X_AUD_RATE_48K             (0x2)
+#define MS928X_AUD_RATE_32K             (0x3)
+#define MS928X_AUD_RATE_88K2            (0x8)
+#define MS928X_AUD_RATE_96K             (0xA)
+#define MS928X_AUD_RATE_176K4           (0xC)
+#define MS928X_AUD_RATE_192K            (0xE)
+
+//
+// Defines interface for video/audio
+//
+typedef struct _ms928x_video_param
+{
+    eVideoSource u8sourceIn;
+}VIDEOPARAM_T;
+
+typedef struct _ms928x_audio_param
+{
+    UINT8        u8audMode;
+    UINT8        u8audRate;
+    UINT8        u8audBits;
+    UINT8        u8audChannel;
+}AUDIOPARAM_T;
+
+// system parameters.
+typedef struct _ms928x_system_param
+{
+    UINT16          u8chipAddr;    //set UINT16, align the structure data
+    UINT16          u16sysConfig;
+    VIDEOPARAM_T    videoParam;
+    AUDIOPARAM_T    audioParam;
+    UINT8           u8userVIC;     // [Digital-In Only]. User will be responsible for setting the VIC.
+    UINT8           u8HDMIType;    // DVI : 0;  HDMI: 1
+    UINT8           u8HDMIColor;   //refer to eOutColorSpace
+    UINT8           u8Phase;       //from 0~31
+    UINT8           u8MnccGain;    //set color fix range: 0x10~0x1F(16~31)
+}SYSPARAM_T;
+
+typedef struct _ms928x_video_shift
+{
+    UINT16      u16HShift;     // H Shift Value
+    UINT16      u16VShift;     // V Shift Value
+}VIDEOSHIFT_T;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void MS928XInit();
+
+void MS928X_MPI_Init(BOOL bpresskeyflag);
+
+void MS928XService();
+
+// MS928X chip reset and initialization.
+UINT8   MS928X_Init(SYSPARAM_T* pstSysParam);
+
+// Determines the running status of the current system.
+UINT8   MS928X_Poll(VOID);
+
+//
+VOID    MS928X_SetVideo(VIDEOSHIFT_T*  g_sysVideoShift);
+//VOID    MS928X_WriteShift(UINT16 u16_h_shift, UINT16 u16_v_shift);
+VOID MS928X_Video_SetShift(INT16 i16_h_shift, INT16 i16_v_shift);
+// Note: This function should be called after the MS928X_SetVideo function.
+//VOID    MS928X_SetAudio(VOID);
+
+// Operations
+VOID    MS928X_Video_Mute(BOOL bmuteON);
+VOID    MS928X_Audio_Mute(BOOL bmuteON);
+
+// Returns TRUE if the sink device connected.
+BOOL    MS928X_HPD_Detect(VOID);
+
+// Returns TRUE if MS928x chip exists.
+BOOL    MS928X_IsValid(VOID);
+
+// Switch I2S/SPDIF audio.
+UINT8   MS928X_UpdateAudio(AUDIOPARAM_T* pstAudParam);
+
+// Get current input video mode.
+// Returns the corresponding VIC code. Returns 0xFF if no signal detected.
+UINT8   MS928X_GetInputVideoMode(VOID);
+
+// HDMI DDC access enable
+VOID    MS928X_DDC_Enable(BOOL b_enable);
+
+// Horizontal or vertical pixel shift
+VOID    MS928X_ShiftConfig(UINT8 u8_h_position, UINT8 u8_v_position);
+
+// Do auto phase, or set manual phase
+UINT8   MS928X_PhaseConfig(BOOL b_auto_enable, UINT8 u8_phase_sel);
+
+// Adjust brightness
+VOID    MS928X_SetVideoBrightness(INT8 i8_brightness);
+
+// Adjust contrast
+VOID    MS928X_SetVideoContrast(UINT8 u8_contrast);
+
+// Adjust tx data driver(max = 0xf)
+VOID  MS928X_SetHdmiDataDriver(UINT8 u8_main_driver, UINT8 u8_post_driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _MACROSILICON_TECH_MS928X_H_
+

project/solution/ble_hid_composite/touch/include/MS928x_mpi.h

@@ -0,0 +1,52 @@
+/******************************************************************************
+* @file    ms928x_mpi.h
+* @author
+* @version V1.0.0
+* @date    11-Nov-2014
+* @brief   MacroSilicon Programming Interface.
+*
+* Copyright (c) 2009-2014, MacroSilicon Technology Co.,Ltd.
+******************************************************************************/
+#ifndef __MACROSILICON_MS928X_PROGRAMMING_INTERFACE_H__
+#define __MACROSILICON_MS928X_PROGRAMMING_INTERFACE_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum _I2C_SPEED_CHOOSE_INFORMATION
+{
+  I2C_SPEED_20K = (UINT8)0,
+  I2C_SPEED_100K = (UINT8)1,
+  I2C_SPEED_400K = (UINT8)2,
+  I2C_SPEED_750K = (UINT8)3,
+
+} I2C_SPEED_E;
+
+extern UINT8 byIicDelay;
+
+extern VOID Sys_Reset(VOID);
+
+// Delay a period of time.
+extern VOID Delay_ms(UINT8 u8ms);
+extern VOID Delay_us(UINT8 u8us);
+
+//
+extern VOID I2C_Sel_Speed(UINT8 u8speed);
+extern UINT8 I2C16_ReadByte(UINT8 u8addr, UINT16 u16index);
+extern VOID I2C16_WriteByte(UINT8 u8addr, UINT16 u16index, UINT8 u8value);
+
+//
+extern BOOL I2C_ReadBytes(UINT8 u8addr, UINT8 u8index, UINT8 *pIn, UINT8 u8len);
+extern UINT8  I2C_ReadByte(UINT8 u8addr, UINT8 u8index);
+extern VOID I2C_WriteByte(UINT8 u8addr, UINT8 u8index, UINT8 u8value);
+
+bool GetHVPixel(UINT8* HVPixelData);
+bool StoreHVPixel(UINT8* HVPixelData);
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  // __MACROSILICON_MS928X_PROGRAMMING_INTERFACE_H__

project/solution/ble_hid_composite/touch/include/Touch.h

@@ -0,0 +1,6 @@
+#ifndef _TOUCH_H_
+#define _TOUCH_H_
+#include "typedef.h"
+extern void touch_init(void);
+extern void touch_process(void);
+#endif

project/solution/ble_hid_composite/touch/include/TouchCommon.h

@@ -0,0 +1,277 @@
+/*
+ * TouchCommon.h
+ *
+ *  Created on: Nov 10, 2021
+ *      Author: Administrator
+ */
+#ifndef INCLUDE_TOUCHCOMMON_H_
+#define INCLUDE_TOUCHCOMMON_H_
+
+
+#include "typedef.h"
+#include "TouchConfig.h"
+#include "global.h"
+
+#if(1)//DEBUG)
+  #define PRINT(format, ...)    printf(format, ##__VA_ARGS__)
+#else
+  #define PRINT(X...)
+#endif
+
+//#define NEW_REVOLVE_PROTOCAL
+#define UART_ENABLE
+
+#define RESOLUTION_X  (16384-1)//(4096-1)//(RESOLUTION_X-1)//
+#define RESOLUTION_Y  (9600-1)//(4096-1)//(RESOLUTION_Y-1)//if (g_nResolutionX == 0) g_nResolutionX = 1920;
+
+#ifdef WACOM_DRIVER
+  #define FIVE_POINTS_PACKAGE
+  //#define TWO_POINTS_PACKAGE
+#else
+#define TWO_POINTS_PACKAGE
+//#define SIX_POINTS_PACKAGE //for xp system
+//#define FIVE_POINTS_PACKAGE
+//#define TEN_POINTS_PACKAGE
+#endif
+
+#ifdef SIX_POINTS_PACKAGE
+  #define MAX_POINT 6
+  #define PACKAGE_POINT_NUM 6
+#endif
+
+#ifdef TEN_POINTS_PACKAGE
+  #define MAX_POINT 10
+  #define PACKAGE_POINT_NUM 10
+  #define BLE_PACKAGE_POINT_NUM 2
+#endif
+
+#ifdef FIVE_POINTS_PACKAGE
+  #define MAX_POINT 10
+  #define PACKAGE_POINT_NUM 5
+  #define BLE_PACKAGE_POINT_NUM 2
+#endif
+
+#ifdef TWO_POINTS_PACKAGE
+  #define MAX_POINT 10
+  #define PACKAGE_POINT_NUM 2
+  #define BLE_PACKAGE_POINT_NUM 2
+#endif
+
+
+#ifdef ONE_POINTS_PACKAGE
+  #define MAX_POINT 10
+  #define PACKAGE_POINT_NUM 1
+  #define BLE_PACKAGE_POINT_NUM 1
+#endif
+
+#ifdef WACOM_DRIVER
+  #define PACKAGE_POINT_SIZE  (PACKAGE_POINT_NUM * 11 + 3)
+#else
+  #ifdef FINGER_PRESSURE
+    #define PACKAGE_POINT_SIZE  (PACKAGE_POINT_NUM * 7 + 2)
+  #else
+    #define PACKAGE_POINT_SIZE  (PACKAGE_POINT_NUM * 5 + 2)
+    #define PACKAGE_RAM_SIZE  (PACKAGE_POINT_SIZE + 4 - (PACKAGE_POINT_SIZE%4))
+    #define BLE_PACKAGE_POINT_SIZE  (BLE_PACKAGE_POINT_NUM * 5 + 2)
+  #endif
+#endif
+
+#ifdef WACOM_DRIVER
+  #define STYLUS_POINT_SIZE   27
+#else
+  #ifdef STYLUS_TILT
+  #define STYLUS_POINT_SIZE   10
+  #else
+  #define STYLUS_POINT_SIZE   8
+  #endif
+#endif
+
+
+#define ABS_MOUSE_PACKAGE_SIZE   6
+#define MOUSE_PACKAGE_SIZE     5
+
+#define DEVICE_MODE_MOUSE 0
+#define DEVICE_MODE_SIGLETOUCH 1
+#define DEVICE_MODE_MULTITOUCH  2
+
+#ifdef UART_ENABLE
+typedef enum EN_UART_STATE{
+  UART_STATE_IDLE,
+  UART_STATE_RECV_CMD,
+  UART_STATE_CHECK_CMD,
+  UART_STATE_RECV_PARAM,
+  UART_STATE_ERROR = 0xFF,
+}UART_STATE;
+
+#if 0
+typedef enum EN_UART_COMMAND{
+  UART_COMMAND_180 = 0x33,
+  UART_COMMAND_0 = 0x34,
+  UART_COMMAND_90 = 0x35,
+  UART_COMMAND_270 = 0x36,
+}UART_COMMAND;
+#else
+typedef enum EN_UART_COMMAND{
+  EN_UART_DIS_USB = 0xA1,
+  EN_USB_DIS_UART = 0xA2,
+  EN_USB_EN_UART = 0xA3,
+  EN_BLE_APPLE_REPORT=0xA4,
+  EN_BLE_WIN_REPORT = 0xA5,
+//  DIS_BLE_TOUCH = 0xA6,
+//  EN_BLE_TOUCH = 0xA7,
+
+  USB_REPORT_FIRST = 0xA6,
+  BLE_REPORT_FIRST = 0xA7,
+
+  GET_DEVICE_NAME = 0xA8,
+  GET_BLE_CONNECT_STATE = 0xA9,
+
+  ERASE_ALL_BONDS = 0xAB,
+  ENABLE_GRAB_CONNECT = 0xAC,
+  DISCONNECT_BLE = 0xAD,
+
+  UART_COMMAND_B_180 = 0x5C,
+  UART_COMMAND_B_0 = 0x5A,
+  UART_COMMAND_B_90 = 0x5B,
+  UART_COMMAND_B_270 = 0x5D,
+
+  UART_SWITCH_0  = 0x7A,
+  UART_SWITCH_90 = 0x5E,
+  UART_SWITCH_270 = 0x5F,
+  UART_SWITCH_180 = 0x60,
+
+  UART_COMMAND_A_0 = 0x6A,
+  UART_COMMAND_A_90 = 0x6B,
+  UART_COMMAND_A_180 = 0x6C,
+  UART_COMMAND_A_270 = 0x6D,
+
+  SET_OS_TYPE_NEW_MAC = 0xB1,
+  SET_OS_TYPE_OLD_MAC = 0xB2,
+}UART_COMMAND;
+#endif
+#ifdef NEW_REVOLVE_PROTOCAL
+#pragma pack(1)
+typedef struct ST_UART_LONG_CMD{
+    UINT8 rs0;
+    UART_COMMAND uart_cmd;
+    UINT16 ax;
+    UINT16 ay;
+    UINT16 dx;
+    UINT16 dy;
+    UINT16 mx;
+    UINT16 my;
+    UINT16 Ax;
+    UINT16 Ay;
+    UINT16 Dx;
+    UINT16 Dy;
+    UINT8 CheckSum;
+    UINT8 rs1;
+}UART_LONG_CMD;
+
+#pragma pack(1)
+typedef union{
+  UART_COMMAND uart_cmd;
+  UART_LONG_CMD uart_long_cmd;
+  UINT8 buf[sizeof(UART_LONG_CMD)];
+}UART_CMD_BUF;
+
+
+
+#else
+typedef struct ST_UART_LONG_CMD{
+    UINT8 rs0;
+    UART_COMMAND uart_cmd;
+    UINT16 x_start;
+    UINT16 x_end;
+    UINT16 y_start;
+    UINT16 y_end;
+    UINT16 x_size;
+    UINT16 y_size;
+    UINT8 CheckSum;
+    UINT8 rs1;
+}UART_LONG_CMD;
+
+typedef union{
+  UART_COMMAND uart_cmd;
+  UART_LONG_CMD uart_long_cmd;
+  UINT8 buf[sizeof(UART_LONG_CMD)];
+}UART_CMD_BUF;
+#endif
+#endif
+
+
+/* 设备结构体信息定义 */
+typedef struct
+{
+    UINT8 Tip_Switch;
+    UINT8 Contact_Identifier;
+    UINT16 X_pos;   /* coordinate X */
+    UINT16 Y_pos;   /* coordinate Y */
+    UINT16 Resolution_Multi;
+    UINT16 X_pos_back;
+    UINT16 Y_pos_back;
+} POINTER;
+
+//#define   TRX_SEL_PIN     (GPIO_PIN_4)   //PA4
+//#define   TRX_SEL_IN()    (gpio_read_data(GPIOA_REG)&TRX_SEL_PIN)
+//#define   RX_RESET_PIN    (GPIO_PIN_0)   //PB0
+
+#define   BIT0                    (0X01)
+#define   BIT1                    (0X02)
+#define   BIT2                    (0X04)
+#define   BIT3                    (0X08)
+#define   BIT4                    (0X10)
+#define   BIT5                    (0X20)
+#define   BIT6                    (0X40)
+#define   BIT7                    (0X80)
+extern BOOL BleReportPosEn;
+extern BOOL UsbReportPosEn;
+extern UINT8 GT_CMD_WR;
+extern UINT8 GT_CMD_RD;
+extern POINTER TP[10];                          /* 按照最大支持的定义 */
+extern UINT8 TouchNumber;
+extern UINT16 Press_Flag;
+extern UINT16 StylusPress;
+extern CHIP_TYPE ChipType;
+extern BOOL isBerlinSeries;
+extern BOOL GioInterruptFlag;
+extern UINT8 TouchNum;
+extern INT16 CheckPos;
+extern UINT8 DeviceMode;
+extern UINT8 BleDeviceMode;
+extern UINT8 ShareBuf[10];
+extern UINT8 NoTouchTimer;
+extern UINT16 OutRangeFlag;
+extern UINT16 Press_Flag;
+extern UINT16 Press_Flag_Bak0;
+extern UINT16 Press_Flag_Bak1;
+extern UINT16 Press_Flag_Bak2;
+extern UINT16 Press_Flag_Bak3;
+extern BOOL UartReportPosEn;
+extern BOOL ReleaseFlag;
+extern UINT16 wESDCheckTime;
+extern BOOL enable_INT_irq;
+extern BOOL enable_ESD_check;
+extern UINT8 IdleTimer;
+extern UINT16 UsbInitTimer;
+#ifdef NEW_REVOLVE_PROTOCAL
+extern UART_CMD_BUF TpOption;
+#endif
+extern void (*TouchProc)(void);
+void GpioFuncInit(void);
+BOOL IsBerlinSeries(void);
+BOOL IsBerlinChipType(CHIP_TYPE type);
+void CheckTouchInt();
+UINT16 GetCheckSum8(UINT8* pBuf, UINT8 len);
+BOOL CheckUsbStatus();
+void AppendReleaseFrame();
+void IICTouchInit();
+void ResetTouchChip();
+void CheckUart0Comand( void );
+void UartUpdatePos(POINTER * pTP);
+BOOL SearchAddress( UINT8 num );
+//BOOL IIC_WR(UINT8* wBuf, UINT8 wLen, BOOL wStop, UINT8* rBuf, UINT8 rLen, BOOL rStop);
+BOOL PosConvert(POINTER* TP, UINT8 index);
+void USART2_SendData(PUINT8 txbuf, UINT16 length);
+void TIM3_Init( UINT16 arr, UINT16 psc );
+#endif /* INCLUDE_TOUCHCOMMON_H_ */

project/solution/ble_hid_composite/touch/include/TouchConfig.h

@@ -0,0 +1,99 @@
+/********************************** (C) COPYRIGHT *******************************
+* File Name          : I2Ctouchservice.h
+* Author             : WingCool
+* Version            : V1.0
+* Date               : 2019/11/29
+* Description        :
+*******************************************************************************/
+#ifndef _TOUCH_CONFIG_H
+#define _TOUCH_CONFIG_H
+#include "typedef.h"
+
+#define FLASH_Base   0x08004000
+#define APP_FALG_ADDR   (FLASH_Base - 256)
+#define HASH_FLAG_ADDR  (APP_FALG_ADDR + 4)
+
+#define AUTO_TEST           0
+#define USBCONFIG           1
+#define MOUSE_REPORT
+
+typedef enum {
+    CHIP_TYPE_UNKNOW,
+    CHIP_TYPE_9XXX,
+    CHIP_TYPE_9PXX,
+    CHIP_TYPE_73XX,
+    CHIP_TYPE_BERLINB,
+    CHIP_TYPE_BERLINA,
+    CHIP_TYPE_BERLIND,
+    CHIP_TYPE_78XX,
+    CHIP_TYPE_FT5XXX,
+    CHIP_TYPE_NUM,
+}CHIP_TYPE;
+
+
+typedef enum _OPRATE_SYSTEM{
+	ANDROID,
+	ANDROID_OS,
+	IOS
+}OPERATE_SYSTEM;
+
+//OPERATE_SYSTEM GetOperateSystem(void);
+//void SetOperateSystem(OPERATE_SYSTEM os);
+UINT8 DataFlash_BlockErase(UINT32 addr);
+UINT8 DataFlash_WriteDW(UINT32 addr, UINT32 dat);
+
+enum {EN_MOUSE_MULTITOUCH, EN_MOUSE_ONLY, EN_MULTITOUCH_ONLY};
+
+#if USBCONFIG
+#define CONFIG_ADDR (0x0800BF00)
+#define CHIP_TYPE_ADDR  (0x0800BE00)
+#define Fsize   (256)
+
+enum {EN_USB_UART, EN_USB_IIC};
+enum {EN_UART_PROTOCAL_8, EN_UART_PROTOCAL_10};
+
+#pragma pack(1)
+typedef struct{
+    UINT8 len;
+    UINT8 intf:1;
+    UINT8 mouse_right_click_dis:1;
+    UINT8 mouse_double_click_en:1;
+    UINT8 remote_wakeup_en:1;
+    UINT8 report_type:2;
+    UINT8 uart_protocol:2;
+    UINT8 vid_h;
+    UINT8 vid_l;
+    //UINT16 vid;
+    UINT8 pid_h;
+    UINT8 pid_l;
+    //UINT16 pid;
+    UINT8 uart_buad;
+    UINT8 usb_bus_check_en:1;
+    UINT8 res2:7;
+    UINT8 dimenshion_x_h;
+    UINT8 dimenshion_x_l;
+    UINT8 dimenshion_Y_h;
+    UINT8 dimenshion_Y_l;
+    //UINT16 dimenshion_x;
+    //UINT16 dimenshion_Y;
+    UINT8 resolution_x_h;//RESOLUTION_X;
+    UINT8 resolution_x_l;//RESOLUTION_X;
+    UINT8 resolution_y_h;//RESOLUTION_Y;
+    UINT8 resolution_y_l;//RESOLUTION_Y;
+    UINT8 res1[6];
+    UINT8 chksum[2]; //24  64 - 44=
+}ST_CONFIG;
+
+#define CONFIG_SIZE (sizeof(ST_CONFIG))
+
+extern ST_CONFIG config;
+extern void CheckBurnFlag();
+extern void ConfigInit();
+extern void SaveConfig(PUINT8 cfg);
+extern void GetConfigFromFlash(PUINT8 pBuf);
+
+extern void CheckFlag();
+extern CHIP_TYPE GetChipTypeFromFlash(void);
+extern void SaveChipTypeToFlash(CHIP_TYPE chip_type);
+#endif
+#endif

project/solution/ble_hid_composite/touch/include/TouchInclude.h

@@ -0,0 +1,14 @@
+#ifndef _TOUCH_INCLUDE_H_
+#define _TOUCH_INCLUDE_H_
+#include "TouchConfig.h"
+#include "typedef.h"
+#include "tmos.h"
+#include "pipe.h"
+#include "TouchCommon.h"
+#include "IIC.h"
+#include "AutoTest.h"
+#include "HidReport.h"
+#include "GoodixTouch.h"
+#include "BerlinTouch.h"
+#include "Touch.h"
+#endif

project/solution/ble_hid_composite/touch/include/commlib.h

@@ -0,0 +1,111 @@
+/**
+******************************************************************************
+* @file    CommLib.h
+* @author
+* @version V2.1.0
+* @date    15-Oct-2013
+* @brief   This file contains all header files
+* @history
+*
+* Copyright (c) 2009-2013, MacroSilicon Technology Co.,Ltd.
+******************************************************************************/
+
+#ifndef _MACROSILICON_TECH_COMMON_H_
+#define _MACROSILICON_TECH_COMMON_H_
+
+// KEIL C51
+//#define __KEIL_C__
+// KEIL ARM (STM32)
+//#define __KEIL_ARM_STM32__
+// Standard GCC
+//#define __STD_GCC__
+//Code Composer Studio
+//#define __CCS__
+
+#define __STD_GCC__
+
+#ifdef __KEIL_ARM_STM32__
+#ifndef _PLATFORM_ARM_
+#define _PLATFORM_ARM_
+#endif
+#endif
+
+
+// Compiler issue.
+#if defined (__CSMC__)
+#elif defined (__KEIL_C__)
+#elif defined (_PLATFORM_ARM_)
+#elif defined (__STD_GCC__)
+#elif defined (__CCS__)
+#else
+    #error "Please define the Compiler type!!!"
+#endif
+
+// SW Version.
+#define SW_MAJOR_VERSION        (0x02)    // Major version
+#define SW_MINOR_VERSION        (0x04)    // Minor version
+
+#if defined(__KEIL_C__)
+
+#ifndef SM39R16A3
+    #define STC_11LxxXE
+#endif
+
+    // For keil c compiler
+    #include <intrins.h>
+    #include <stdio.h>
+    #include <math.h>
+    #include <string.h>
+
+    // Add 8051 register header
+#if defined STC_11LxxXE
+    #include "STC_11LxxXE.h"
+#elif defined SM39R16A3
+    #include "SM39R16A3.h"
+#endif
+    #include "mst_typedef.h"
+    // Add peripheral configuration
+    #include "Periph_Config.h"
+
+#elif defined(_PLATFORM_ARM_) || defined(__CCS__)
+    #include <stdio.h>
+    #include <math.h>
+    #include <string.h>
+
+    #include "mst_typedef.h"
+
+#elif defined(__STD_GCC__)
+    #if defined(__KERNEL__)
+        #include <linux/string.h>
+    #else
+        #include <string.h>
+    #endif
+    #include "mst_typedef.h"
+
+#elif defined(__CSMC__)
+    #include <string.h>
+    #include "stm8s.h"
+    #include "mst_typedef.h"
+    #include "Periph_Config.h"
+    #include "stm8s\stm8s_lib.h"
+    #include "stm8s\stm8s_it.h"
+#ifdef SUPPORT_SYSTEM_EDID
+        #include "mst_i2c_slave.h"
+#endif
+
+#endif
+
+#if defined(__CSMC__) || defined(__KEIL_C__)
+    // Add mcu peripherals' header files.
+    #include "mst_periph.h"
+    #include "mst_debug.h"
+    #include "mst_timer.h"
+    #include "mst_i2c.h"
+    #include "mst_keys.h"
+#endif
+
+    // Platform Porting Related APIs
+    #include "MS928x_mpi.h"
+
+#endif //_MACROSILICON_TECH_COMMON_H_
+

project/solution/ble_hid_composite/touch/include/mst_typedef.h

@@ -0,0 +1,149 @@
+/**
+******************************************************************************
+* @file    mst_typedef.h
+* @author
+* @version V2.1.0
+* @date    15-Oct-2013
+* @brief   Definitions for typedefs.
+*
+* Copyright (c) 2009-2013, MacroSilicon Technology Co.,Ltd.
+******************************************************************************/
+
+#ifndef _MACROSILICON_TECH_TYPEDEF_H_
+#define _MACROSILICON_TECH_TYPEDEF_H_
+
+/*
+** Global typedefs.
+*/
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+// For ARM platform
+#if defined (_PLATFORM_ARM_)
+#define  __CODE const
+#define  __XDATA
+#define  __DATA
+#define __IDATA
+#define  __NEAR
+#define  __IO volatile
+
+
+typedef _Bool BOOL;
+
+#elif defined (__STD_GCC__)
+#define  __CODE const
+#define  __XDATA
+#define  __DATA
+#define __IDATA
+#define  __NEAR
+#define  __IO volatile
+
+
+//typedef _Bool BOOL;
+
+#elif defined (_PLATFORM_WINDOWS_)
+#define  __CODE
+#define  __XDATA
+#define  __DATA
+#define __IDATA
+#define  __NEAR
+#define  __IO
+
+#elif defined (__KEIL_C__)
+#define __CODE code
+#define __XDATA xdata
+#define __DATA data
+#define __IDATA idata
+#define __NEAR
+#define __IO volatile
+
+//bool bype
+typedef bit BOOL;
+
+#elif defined (__CSMC__)
+#define __CODE const
+#define __XDATA
+#define __DATA
+#define __IDATA
+#define __NEAR @near
+#define __IO volatile
+
+//bool bype
+typedef _Bool BOOL;
+#elif defined (_IAR_)
+#define __CODE const
+#define __XDATA
+#define __DATA
+#define __IDATA
+#define __NEAR @near
+#define __IO volatile
+
+//bool bype
+typedef _Bool BOOL;
+#endif // end of compiler platform define
+
+
+//unsigned integer type
+typedef unsigned char UINT8;
+typedef char          CHAR;
+typedef unsigned short UINT16;
+
+//signed integer type
+//typedef signed char INT8;
+typedef signed short INT16;
+
+//32bit type
+#if defined (_PLATFORM_ARM_) || defined (_PLATFORM_WINDOWS_)
+typedef unsigned int UINT32;
+typedef signed int INT32;
+#else
+typedef unsigned long int UINT32;
+typedef signed long int INT32;
+#endif
+
+#define VOID void
+
+#define FALSE 0
+#define TRUE  1
+
+#define DISABLE 0
+#define ENABLE  1
+
+#define LOW     0
+#define HIGH    1
+
+#define OFF     0
+#define ON      1
+
+
+// Helper macros.
+#define _UNUSED_(arg)     ((arg) = (arg))
+
+#ifndef _countof
+#define _countof(ARRAY) (sizeof(ARRAY) / sizeof(ARRAY[0]))
+#endif
+
+#ifndef max
+#define max(a, b)   (((a)>(b))?(a):(b))
+#endif
+
+#ifndef min
+#define min(a, b)   (((a)<(b))?(a):(b))
+#endif
+
+
+
+// For porting to different compilers
+typedef  UINT8  __XDATA   XUINT8;
+typedef  UINT16 __XDATA   XUINT16;
+typedef  UINT32 __XDATA   XUINT32;
+
+typedef  INT8   __XDATA   XINT8;
+typedef  INT16  __XDATA   XINT16;
+typedef  INT32  __XDATA   XINT32;
+
+
+#endif  // _MACROSILICON_TECH_TYPEDEF_H_
+

project/solution/ble_hid_composite/touch/include/pipe.h

@@ -0,0 +1,33 @@
+#ifndef _PIPE_H
+#define _PIPE_H
+
+#include "HidReport.h"
+#include "typedef.h"
+
+#define BUF_MAX 256
+#define OFFSET_MASK  0x00FF
+typedef struct _Pipe_t {
+   UINT16 header;
+   UINT16 tail;
+   UINT8 buf[BUF_MAX];
+}  Pipe_t;
+#if DEBUG == Debug_USB
+extern Pipe_t debug_pipe;
+#endif
+extern Pipe_t sys_pipe;
+
+extern Pipe_t uart_cmd_pipe;
+
+extern Pipe_t coor_pipe;
+
+void pipe_init(Pipe_t *pipe);
+
+UINT8 pipe_read(Pipe_t *pipe, UINT8 * value, UINT8 len);
+
+void pipe_write_c(Pipe_t *pipe, UINT8 value);
+
+void pipe_write_t(Pipe_t *pipe, UINT8* value, UINT8 len, COMMAND_TYPE cmd);
+
+void pipe_write(Pipe_t *pipe, UINT8* value, UINT8 len);
+#endif
+

project/solution/ble_hid_composite/touch/include/tmos.h

@@ -0,0 +1,29 @@
+/*
+ * tmos.h
+ *
+ *  Created on: Feb 29, 2024
+ *      Author: Administrator
+ */
+
+#ifndef APP_INCLUDE_TMOS_H_
+#define APP_INCLUDE_TMOS_H_
+#include "typedef.h"
+
+#define INVALID_TASK_ID                 0xFF      // Task ID isn't setup properly
+#define TASK_NO_TASK                    0xFF
+
+typedef unsigned char                   tmosTaskID;
+typedef unsigned short                  tmosEvents;
+typedef unsigned long                   tmosTimer;
+typedef unsigned char                   bStatus_t;
+typedef tmosEvents(*pTaskEventHandlerFn)( tmosTaskID taskID, tmosEvents event );
+
+extern bStatus_t tmos_init();
+extern bStatus_t tmos_set_event( tmosTaskID taskID, tmosEvents event );
+extern bStatus_t tmos_start_task( tmosTaskID taskID, tmosEvents event, tmosTimer time  );
+extern bStatus_t tmos_stop_task( tmosTaskID taskID, tmosEvents event );
+extern void TMOS_SystemProcess( void );
+extern tmosTaskID TMOS_ProcessEventRegister( pTaskEventHandlerFn eventCb );
+
+
+#endif /* APP_INCLUDE_TMOS_H_ */

project/solution/ble_hid_composite/touch/include/typedef.h

@@ -0,0 +1,93 @@
+#ifndef _TYPEDEF_H_
+#define _TYPEDEF_H_
+#ifndef VOID
+#define VOID                    void
+#endif
+#ifndef CONST
+#define CONST                   const
+#endif
+#ifndef BOOL
+typedef unsigned char           BOOL;
+#endif
+#ifndef BOOLEAN
+typedef unsigned char           BOOLEAN;
+#endif
+#ifndef CHAR
+typedef char                    CHAR;
+#endif
+#ifndef INT8
+typedef char                    INT8;
+#endif
+#ifndef INT16
+typedef short                   INT16;
+#endif
+#ifndef INT32
+typedef long                    INT32;
+#endif
+#ifndef UINT8
+typedef unsigned char           UINT8;
+#endif
+#ifndef UINT16
+typedef unsigned short          UINT16;
+#endif
+#ifndef UINT32
+typedef unsigned long           UINT32;
+#endif
+#ifndef UINT8V
+typedef unsigned char volatile  UINT8V;
+#endif
+#ifndef UINT16V
+typedef unsigned short volatile UINT16V;
+#endif
+#ifndef UINT32V
+typedef unsigned long volatile  UINT32V;
+#endif
+
+#ifndef UINT8C
+typedef const unsigned char           UINT8C;
+#endif
+#ifndef UINT16C
+typedef const unsigned short          UINT16C;
+#endif
+#ifndef UINT32C
+typedef const unsigned long           UINT32C;
+#endif
+
+#ifndef PVOID
+typedef void                    *PVOID;
+#endif
+#ifndef PCHAR
+typedef char                    *PCHAR;
+#endif
+#ifndef PCHAR
+typedef const char              *PCCHAR;
+#endif
+#ifndef PINT8
+typedef char                    *PINT8;
+#endif
+#ifndef PINT16
+typedef short                   *PINT16;
+#endif
+#ifndef PINT32
+typedef long                    *PINT32;
+#endif
+#ifndef PUINT8
+typedef unsigned char           *PUINT8;
+#endif
+#ifndef PUINT16
+typedef unsigned short          *PUINT16;
+#endif
+#ifndef PUINT32
+typedef unsigned long           *PUINT32;
+#endif
+#ifndef PUINT8V
+typedef volatile unsigned char  *PUINT8V;
+#endif
+#ifndef PUINT16V
+typedef volatile unsigned short *PUINT16V;
+#endif
+#ifndef PUINT32V
+typedef volatile unsigned long  *PUINT32V;
+#endif
+
+#endif

project/solution/ble_hid_composite/touch/pipe.c

@@ -0,0 +1,104 @@
+#include "pipe.h"
+//#include "ch57x_common.h"
+#include "hidreport.h"
+#include "api.h"
+
+#if DEBUG == Debug_USB
+Pipe_t debug_pipe = {0,0};
+#endif
+
+Pipe_t sys_pipe;
+Pipe_t coor_pipe;
+Pipe_t uart_cmd_pipe;
+extern UINT8 print_log;
+void pipe_init(Pipe_t *pipe)
+{
+	pipe->tail = pipe->header = 0;
+}
+
+UINT8 pipe_read(Pipe_t *pipe, UINT8 * value, UINT8 len)
+{
+    GLOBAL_INT_DISABLE();
+	UINT8 cnt = 0;
+	do
+	{
+		if(pipe->tail==pipe->header)
+		{
+			break;
+		}
+
+		value[cnt++] = pipe->buf[pipe->tail];
+
+		pipe->tail = (pipe->tail+1)&OFFSET_MASK;//%BUF_MAX;
+
+	}while(--len);
+
+	GLOBAL_INT_RESTORE();
+
+	return cnt;
+}
+
+void pipe_write_c(Pipe_t *pipe, UINT8 value)
+{
+    GLOBAL_INT_DISABLE();
+	pipe->buf[pipe->header] = value;
+
+	pipe->header = (pipe->header+1)&OFFSET_MASK;//%BUF_MAX;
+
+	if(pipe->tail==pipe->header)
+	{
+		pipe->tail = (pipe->tail+1)&OFFSET_MASK;//%BUF_MAX;
+	}
+	GLOBAL_INT_RESTORE();
+}
+
+void pipe_write(Pipe_t *pipe, UINT8* value, UINT8 len)
+{
+  UINT8 cnt = 0;
+
+  GLOBAL_INT_DISABLE();
+
+  UINT16 res = pipe->tail <= pipe->header ? pipe->tail + BUF_MAX - pipe->header : pipe->tail -  pipe->header;
+  if(res < len)
+  {
+      GLOBAL_INT_RESTORE();
+    return;
+  }
+
+  while(cnt < len)
+  {
+    pipe->buf[pipe->header] = value[cnt++];
+
+    pipe->header = (pipe->header+1)&OFFSET_MASK;//%BUF_MAX;
+  }
+  GLOBAL_INT_RESTORE();
+}
+
+
+void pipe_write_t(Pipe_t *pipe, UINT8* value, UINT8 len, COMMAND_TYPE cmd)
+{
+    GLOBAL_INT_DISABLE();
+	UINT8 cnt = 0;
+
+	UINT16 res = pipe->tail <= pipe->header ? pipe->tail + BUF_MAX - pipe->header : pipe->tail -  pipe->header;
+	if(res < len+2)
+	{
+	    GLOBAL_INT_RESTORE();
+		return;
+	}
+
+	pipe_write_c(pipe, len);
+
+	pipe_write_c(pipe, cmd);
+
+	while(cnt < len)
+	{
+		pipe->buf[pipe->header] = value[cnt++];
+
+		pipe->header = (pipe->header+1)&OFFSET_MASK;//%BUF_MAX;
+	}
+	GLOBAL_INT_RESTORE();
+}
+
+
+

project/solution/ble_hid_composite/touch/tmos.c

@@ -0,0 +1,184 @@
+/*
+ * tmos.c
+ *
+ *  Created on: Feb 29, 2024
+ *      Author: Administrator
+ */
+ #include "include.h"
+#include "typedef.h"
+#include "tmos.h"
+#include "string.h"
+#include "driver_tmr.h"
+
+#define TASK_ID_MAX 10
+#define TASK_EVENT_MAX  16
+
+
+static uint8_t tmos_num = 0;
+
+typedef struct{
+    tmosEvents event;
+    tmosTimer timer[TASK_EVENT_MAX];
+    tmosTimer time_stamp[TASK_EVENT_MAX];
+    pTaskEventHandlerFn TaskEventHandlerFn;
+}ST_TASK;
+
+static ST_TASK tmosTask[TASK_ID_MAX];
+static tmosTimer time_stamp = 0;
+
+
+
+static tmosTimer toms_tick=0;
+
+AT(.com_text.isr)
+void timer3_isq(void)
+{
+    if (tmr_get_flag(TMR3, TMR_IT_UPDATE) != RESET) {
+        tmr_clear_flag(TMR3, TMR_IT_UPDATE);
+         toms_tick++;
+
+    }
+}
+
+void timer3_650us_init(void)
+{
+    tmr_base_init_typedef tmr_base_init_struct;
+    clk_gate1_cmd(CLK_GATE1_TMR3, CLK_EN);
+
+    tmr_base_init_struct.clock_source = TMR_COUNTER_RISING;
+    tmr_base_init_struct.counter_source = TMR_INC_SOURCE;       // 1MHz
+    tmr_base_init_struct.prescale = 1 - 1;                   // 1KHz
+    tmr_base_init_struct.period = 650 - 1;                      // 5Hz
+    tmr_base_init(TMR3, &tmr_base_init_struct);
+
+    tmr_pic_config(TMR3, timer3_isq, 0, TMR_IT_UPDATE, ENABLE);
+
+    tmr_cmd(TMR3, ENABLE);
+
+
+    gpio_init_typedef gpio_init_structure;
+    gpio_init_structure.gpio_pin = GPIO_PIN_4;
+    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
+    gpio_init_structure.gpio_fen = GPIO_FEN_GPIO;
+    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
+    gpio_init_structure.gpio_drv = GPIO_DRV_6MA;
+    gpio_init(GPIOA_REG, &gpio_init_structure);
+}
+
+
+bStatus_t tmos_init()
+{
+    tmos_num = 0;
+
+    memset((void*)tmosTask, 0, sizeof(tmosTask));
+
+    toms_tick = 0;
+    time_stamp = 0;
+
+    timer3_650us_init();
+    return 0;
+}
+
+
+
+bStatus_t tmos_set_event( tmosTaskID taskID, tmosEvents event )
+{
+    tmosTask[taskID].event |= event;
+    return 0;
+}
+
+bStatus_t tmos_start_task( tmosTaskID taskID, tmosEvents event, tmosTimer time  )
+{
+    uint8_t i;
+
+    tmosTask[taskID].event |= event;
+
+    for(i=0; i<TASK_EVENT_MAX; i++)
+    {
+       if((event >> i) & 0x01)
+       {
+           tmosTask[taskID].timer[i] = time ;
+           break;
+       }
+    }
+    return 0;
+}
+
+bStatus_t tmos_stop_task( tmosTaskID taskID, tmosEvents event )
+{
+    uint8_t i;
+
+    tmosTask[taskID].event &= ~event;
+
+    for(i=0; i<TASK_EVENT_MAX; i++)
+    {
+        if((event >> i) & 0x01)
+        {
+            tmosTask[taskID].timer[i] = 0;
+            break;
+        }
+    }
+    return 0;
+}
+
+void TMOS_SystemProcess( void )
+{
+    uint8_t i,j,tick = 0;
+    tmosEvents event;
+
+    if(toms_tick==time_stamp)
+        return;
+
+    tick = toms_tick - time_stamp;
+    time_stamp = toms_tick;
+
+
+    for(i = 0; i<tmos_num; i++)
+    {
+        if(tmosTask[i].event == 0)
+        {
+            continue;
+        }
+        else
+        {
+            //PRINT("task_id=%d\n", i);
+            for(j=0; j<TASK_EVENT_MAX; j++)
+            {
+                event = 1L<<j;
+
+                if(tmosTask[i].event & event)
+                {
+                    //PRINT("task_event=%d\n", j);
+                    if(tmosTask[i].timer[j] > tick)
+                    {
+                        //PRINT("timer=%d\n", tmosTask[i].timer[j]);
+                        tmosTask[i].timer[j]-=tick;
+                    }
+                    else if(tmosTask[i].timer[j] <= tick)
+                    {
+                        //PRINT("timer=%d\n", tmosTask[i].timer[j]);
+
+                        tmosTask[i].timer[j] = 0;
+
+                        tmosTask[i].event &= ~event;
+
+                        tmosTask[i].TaskEventHandlerFn((tmosTaskID)i, event);
+                    }
+                }
+            }
+        }
+    }
+}
+
+tmosTaskID TMOS_ProcessEventRegister( pTaskEventHandlerFn eventCb )
+{
+    if(tmos_num >= TASK_ID_MAX)
+    {
+        return INVALID_TASK_ID;
+    }
+    else
+    {
+        tmosTask[tmos_num++].TaskEventHandlerFn = eventCb;
+    }
+    return tmos_num - 1;
+}

project/solution/ble_hid_composite/uart/uart_transfer.c

@@ -0,0 +1,181 @@
+#include "include.h"
+#include "driver_gpio.h"
+#include "driver_uart.h"
+#include "uart_transfer.h"
+
+#if TRACE_EN
+#define TRACE(...)                          my_printf("[WIRELESS] ");\
+                                            my_printf(__VA_ARGS__)
+#define TRACE_R(...)                        my_print_r(__VA_ARGS__);
+#else
+#define TRACE(...)
+#define TRACE_R(...)
+#endif // TRACE_EN
+
+#define UART_TX_PORT              GPIOA_REG
+#define UART_TX_PIN               GPIO_PIN_5
+#define UART_RX_PORT              GPIOA_REG
+#define UART_RX_PIN               GPIO_PIN_6
+
+#define USB_EP1_COOR_SIZE     (PACKAGE_POINT_SIZE *(MAX_POINT/PACKAGE_POINT_NUM))
+
+uart_transfer_cb_typedef uart_rx = {
+    .done = 0,
+    .len = 0,
+    .backlen = 0,
+    .timeout = 50, //ms
+};
+
+u8 u8ReceiveDataStep = 0;
+
+
+AT(.com_text.isr)
+void uart_isr(void)
+{
+    if (uart_get_flag(UART, UART_IT_RX) != RESET) {
+        uart_rx.tick = tick_get();
+        if (uart_rx.len < sizeof(uart_rx.buf))
+        {
+            switch (u8ReceiveDataStep)
+            {
+            case 0:
+                if (uart_receive_data(UART) == 0x55)
+                {
+                    uart_rx.buf[uart_rx.len++] = uart_receive_data(UART);
+                    u8ReceiveDataStep = 1;
+                }
+                else
+                {
+                    uart_rx.len = 0;
+                    u8ReceiveDataStep = 0;
+                }
+                break;
+
+            case 1:
+                if (uart_receive_data(UART) == 0x54)
+                {
+                    uart_rx.buf[uart_rx.len++] = uart_receive_data(UART);
+                    u8ReceiveDataStep = 2;
+                }
+                else
+                {
+                    uart_rx.len = 0;
+                    u8ReceiveDataStep = 0;
+                }
+                break;
+            /*
+            case 2:
+                if ((uart_receive_data(UART) & 0x80) == 0x80)
+                {
+                    uart_rx.buf[uart_rx.len++] = uart_receive_data(UART);
+                    u8ReceiveDataStep = 3;
+                }
+                else
+                {
+                    uart_rx.len = 0;
+                    u8ReceiveDataStep = 0;
+                }
+                break;
+            */
+            default:
+                uart_rx.buf[uart_rx.len++] = uart_receive_data(UART);
+                break;
+            }
+        }
+
+        uart_clear_flag(UART, UART_IT_RX);
+    }
+}
+
+void uart_transfer_init(u32 baud)
+{
+    if (bTransmitEn == TRUE)  //transmit
+    {
+        return;
+    }
+
+    uart_init_typedef uart_init_struct;
+    gpio_init_typedef gpio_init_structure;
+
+    clk_gate0_cmd(CLK_GATE0_UART, CLK_EN);
+
+    //clk_udet_clk_set(XOSC24M_CLK);  //udet 必须调用
+
+    // RX
+    gpio_init_structure.gpio_pin = UART_RX_PIN;
+    gpio_init_structure.gpio_dir = GPIO_DIR_INPUT;
+    gpio_init_structure.gpio_fen = GPIO_FEN_PER;
+    gpio_init_structure.gpio_fdir = GPIO_FDIR_SELF;
+    gpio_init_structure.gpio_mode = GPIO_MODE_DIGITAL;
+    gpio_init_structure.gpio_pupd = GPIO_PUPD_PU10K;
+    gpio_init(UART_RX_PORT, &gpio_init_structure);
+
+    // TX
+    gpio_init_structure.gpio_pin = UART_TX_PIN;
+    gpio_init_structure.gpio_dir = GPIO_DIR_OUTPUT;
+    gpio_init_structure.gpio_drv = GPIO_DRV_6MA;
+    gpio_init(UART_TX_PORT, &gpio_init_structure);
+
+    gpio_func_mapping_config(UART_RX_PORT, UART_RX_PIN, GPIO_CROSSBAR_IN_UARTRX);
+    gpio_func_mapping_config(UART_TX_PORT, UART_TX_PIN, GPIO_CROSSBAR_OUT_UARTTX);
+
+    uart_init_struct.baud = baud;
+    uart_init_struct.mode = UART_SEND_RECV_MODE;
+    uart_init_struct.word_len = UART_WORD_LENGTH_8b;
+    uart_init_struct.stop_bits = UART_STOP_BIT_1BIT;
+    uart_init_struct.one_line_enable = UART_SEPARATE;
+    /* Only UART Valid */
+    uart_init_struct.baud_fix = UART_BAUD_FIX;
+    /* Only UART Valid */
+    uart_init_struct.clock_source = UART_INC_CLOCK;
+    uart_init(UART, &uart_init_struct);
+
+    uart_pic_config(UART, uart_isr, 0, UART_IT_RX, ENABLE);
+
+    uart_cmd(UART, ENABLE);
+
+    //PRINT("uart_transfer_init\n");
+}
+
+void uart_transfer_data()
+{
+    //if (((tick_get() - uart_rx.tick) >= uart_rx.timeout) && uart_rx.len)
+    if ((USB_EP1_COOR_SIZE + 10) == uart_rx.len)
+    {
+		//uart_rx.done = 1;
+        while (uart_rx.backlen < 10) {
+            uart_rx.bufback[uart_rx.backlen] = uart_rx.buf[USB_EP1_COOR_SIZE + uart_rx.backlen];
+            uart_rx.backlen++;
+        }
+
+        uart_rx.len = 0;
+        u8ReceiveDataStep = 0;
+
+        u8 *p = uart_rx.bufback;
+
+        while (uart_rx.backlen) {
+
+            uart_send_data(UART, *p++);
+            while (uart_get_flag(UART, UART_IT_TX) != SET);
+            uart_rx.backlen --;
+        }
+    }
+}
+
+void uart_to_wireless_transfer_data()
+{
+    if (10 == uart_rx.len)
+    {
+
+		while (uart_rx.backlen < 10) {
+            uart_rx.bufback[uart_rx.backlen] = uart_rx.buf[uart_rx.backlen];
+            uart_rx.backlen++;
+        }
+
+        uart_rx.len = 0;
+        u8ReceiveDataStep = 0;
+        uart_rx.backlen = 0;
+
+        wireless_send_test(10, (u8 *)uart_rx.bufback);
+    }
+}

project/solution/ble_hid_composite/uart/uart_transfer.h

@@ -0,0 +1,22 @@
+#ifndef _UART_TRANSFER_H
+#define _UART_TRANSFER_H
+
+typedef struct {
+    u16 done;
+    u16 len;
+    u16 backlen;
+    u32 timeout;
+    u32 tick;
+    u8 buf[64 + 10];
+    u8 bufback[64 + 10];
+} uart_transfer_cb_typedef;
+
+extern uart_transfer_cb_typedef uart_rx;
+
+void uart_transfer_init(u32 baud);
+void uart_transfer_data();
+void uart_to_wireless_transfer_data();
+void udet_transfer_example(void);
+void udet_transfer_init(u32 baud);
+
+#endif // _UART_TRANSFER_H