Merge branch 'master' of https://gitee.com/openLuat/luatos-soc-air105

application/include/luat_conf_bsp.h

@@ -28,6 +28,8 @@
 
 #define LUAT_USE_FS_VFS 1
 #define LUAT_USE_VFS_INLINE_LIB 1
+// 内存优化: 减少内存消耗, 会稍微减低性能
+#define LUAT_USE_MEMORY_OPTIMIZATION_CODE_MMAP 1
 
 
 #define LUAT_USE_UART 1
@@ -71,9 +73,10 @@
 
 //----------------------------
 // 高级功能, 其中shell是推荐启用, 除非你打算uart0也读数据
+#ifndef __DEBUG__
 #define LUAT_USE_SHELL 
 #define LUAT_USE_DBG
-
+#endif
 #define LUAT_USE_OTA
 
 // 多虚拟机支持,实验性,一般不启用
@@ -166,7 +169,7 @@ extern unsigned int gLVFlashTime;
 #define __LUATOS_TICK_64BIT__
 #define LUAT_USE_MEMORY_OPTIMIZATION_CODE_MMAP
 
-#ifndef __DEBUG__
+#ifndef __LV_DEBUG__
 #undef LV_USE_PERF_MONITOR
 #endif
 

application/src/luat_lib_usbapp.c

@@ -30,6 +30,7 @@
 #include "luat_base.h"
 #include "luat_msgbus.h"
 #include "app_interface.h"
+#include "luat_zbuff.h"
 
 static int l_usb_app_vhid_cb(lua_State *L, void* ptr) {
     rtos_msg_t* msg = (rtos_msg_t*)lua_topointer(L, -1);
@@ -51,12 +52,42 @@ int32_t luat_usb_app_vhid_cb(void *pData, void *pParam)
 	case USB_HID_NOT_READY:
 	case USB_HID_READY:
 	case USB_HID_SEND_DONE:
+	case USB_HID_NEW_DATA:
 	    msg.arg1 = (uint32_t)pParam;
         luat_msgbus_put(&msg, 0);
 		break;
 	}
     return 0;
 }
+/*
+USB 设置VID和PID
+@api usbapp.set_id(id, vid, pid)
+@int 设备id,默认为0
+@int vid 小端格式
+@int pid 小端格式
+@return 无
+@usage
+usbapp.set_id(0, 0x1234, 0x5678)
+*/
+static int l_usb_set_id(lua_State* L) {
+    luat_usb_app_set_vid_pid(luaL_optinteger(L, 1, 0), luaL_optinteger(L, 2, 0x1234), luaL_optinteger(L, 3, 0x5678));
+    return 0;
+}
+
+/*
+USB HID设备模式
+@api usbapp.hid_mode(id, mode, buff_size)
+@int 设备id,默认为0
+@int mode，目前0是键盘，1是自定义
+@int buff_size，只能是8,16,32,64，如果是键盘模式或者填了其他值，自动为8
+@usage
+usbapp.hid_mode(0, 0) -- usb hid键盘模式
+usbapp.hid_mode(0, 1) -- usb hid自定义模式，用于免驱USB交互
+*/
+static int l_usb_set_hid_mode(lua_State* L) {
+	uat_usb_app_set_hid_mode(luaL_optinteger(L, 1, 0), luaL_optinteger(L, 2, 0), luaL_optinteger(L, 3, 8));
+	return 0;
+}
 
 /*
 启动USB设备
@@ -112,24 +143,76 @@ static int l_usb_vhid_upload(lua_State* L) {
 }
 
 /*
-USB HID设备上传数据
-@api usbapp.rawKey(id, data)
+USB HID设备上传用户自定义数据
+@api usbapp.hid_tx(id, data, start, len)
 @int 设备id,默认为0
-@string 数据，需为定长的8字节
+@string or zbuff 注意数据量不足时会自动填充0
+@int 可选，data为zbuff才有效，要发送的数据起始位置，默认为0
+@int 可选，data为zbuff才有效，要发送的数据长度，默认为zbuff内有效数据，最大值不超过zbuff的最大空间
 @return bool 成功返回true,否则返回false
 @usage
 -- HID上传数据
-usbapp.rawKey(0, string.char(0x08,0,0x15,0,0,0,0,0)) -- usb hid会模拟敲出win+r
+usbapp.hid_tx(0, "1234") -- usb hid上传0x31 0x32 0x33 0x34  + N个0
 */
-static int l_usb_vhid_upload_raw(lua_State* L) {
-    size_t len;
-    const char* data = luaL_checklstring(L, 2, &len);
-    if (len > 8) {
-        luat_usb_app_vhid_upload_raw(USB_ID0, data);
+static int l_usb_hid_tx(lua_State* L) {
+    size_t start, len;
+    const char *buf;
+    luat_zbuff_t *buff = NULL;
+    if(lua_isuserdata(L, 2)) {
+        buff = ((luat_zbuff_t *)luaL_checkudata(L, 2, LUAT_ZBUFF_TYPE));
+        start = luaL_optinteger(L, 3, 0);
+        len = luaL_optinteger(L, 4, buff->used);
+        if (start >= buff->len) {
+        	lua_pushboolean(L, 0);
+        	return 1;
+        }
+        if ((start + len)>= buff->len) {
+        	len = buff->len - start;
+        }
+        if (len > 0) {
+        	luat_usb_app_vhid_tx(USB_ID0, buff->addr + start, len);
+            lua_pushboolean(L, 1);
+        }
+        else {
+            lua_pushboolean(L, 0);
+        }
+    } else {
+    	buf = luaL_checklstring(L, 2, &len);
+    	luat_usb_app_vhid_tx(USB_ID0, buf, len);
         lua_pushboolean(L, 1);
     }
-    else {
-        lua_pushboolean(L, 0);
+    return 1;
+}
+
+/*
+buff形式读接收到的数据，一次读出全部数据存入buff中，如果buff空间不够会自动扩展，目前只有air105支持这个操作
+@api    usbapp.hid_rx(id, buff)
+@int 设备id,默认为0
+@zbuff zbuff对象
+@return 返回读到的长度，并把zbuff指针后移
+@usage
+usbapp.hid_rx(0, buff)
+*/
+static int l_usb_hid_rx(lua_State *L)
+{
+    uint8_t id = luaL_checkinteger(L, 1);
+
+    if(lua_isuserdata(L, 2)){//zbuff对象特殊处理
+    	luat_zbuff_t *buff = ((luat_zbuff_t *)luaL_checkudata(L, 2, LUAT_ZBUFF_TYPE));
+        int result = luat_usb_app_vhid_rx(id, NULL, 0);	//读出当前缓存的长度，目前只有105支持这个操作
+        if (result > (buff->len - buff->used))
+        {
+        	__zbuff_resize(buff, buff->len + result);
+        }
+        luat_usb_app_vhid_rx(id, buff->addr + buff->used, result);
+        lua_pushinteger(L, result);
+        buff->used += result;
+        return 1;
+    }
+    else
+    {
+        lua_pushinteger(L, 0);
+        return 1;
     }
     return 1;
 }
@@ -173,24 +256,29 @@ static int l_usb_udisk_detach_sdhc(lua_State* L) {
 	luat_usb_udisk_detach_sdhc(USB_ID0);
     return 0;
 }
-#include "rotable.h"
-static const rotable_Reg reg_usbapp[] =
+
+
+#include "rotable2.h"
+static const rotable_Reg_t reg_usbapp[] =
 {
-    { "start",              l_usb_start,                0},
-    { "stop",               l_usb_stop,                 0},
-    { "vhid_upload",        l_usb_vhid_upload,          0},
-    { "rawKey",        l_usb_vhid_upload_raw,          0},
-    { "vhid_cancel_upload", l_usb_vhid_cancel_upload,   0},
-	{ "udisk_attach_sdhc", l_usb_udisk_attach_sdhc,   0},
-	{ "udisk_detach_sdhc", l_usb_udisk_detach_sdhc,   0},
-
-    { "HID_NOT_READY",      NULL,   USB_HID_NOT_READY},
-    { "HID_READY",          NULL,   USB_HID_READY},
-    { "HID_SEND_DONE",      NULL,   USB_HID_SEND_DONE},
-	{ NULL,        NULL,   0}
+	{ "set_id" ,         ROREG_FUNC(l_usb_set_id)},
+	{ "hid_mode" ,         ROREG_FUNC(l_usb_set_hid_mode)},
+    { "start" ,         ROREG_FUNC(l_usb_start)},
+    { "stop" ,       ROREG_FUNC(l_usb_stop)},
+	{ "hid_tx", ROREG_FUNC(l_usb_hid_tx)},
+	{ "hid_rx", ROREG_FUNC(l_usb_hid_rx)},
+    { "vhid_upload",        ROREG_FUNC(l_usb_vhid_upload)},
+    { "vhid_cancel_upload", ROREG_FUNC(l_usb_vhid_cancel_upload)},
+	{ "udisk_attach_sdhc", ROREG_FUNC(l_usb_udisk_attach_sdhc)},
+	{ "udisk_detach_sdhc", ROREG_FUNC(l_usb_udisk_detach_sdhc)},
+    { "NO_READY",      ROREG_INT(USB_HID_NOT_READY)},
+    { "READY",         ROREG_INT(USB_HID_READY)},
+    { "SEND_OK",      ROREG_INT(USB_HID_SEND_DONE)},
+	{ "NEW_DATA",      ROREG_INT(USB_HID_NEW_DATA)},
+	{ NULL,            {}},
 };
 
 LUAMOD_API int luaopen_usbapp( lua_State *L ) {
-    luat_newlib(L, reg_usbapp);
+	luat_newlib2(L, reg_usbapp);
     return 1;
 }

application/src/luat_uart_air105.c

@@ -187,10 +187,11 @@ int luat_uart_setup(luat_uart_t *uart){
     if (uart->parity == 1)parity = UART_PARITY_ODD;
     else if (uart->parity == 2)parity = UART_PARITY_EVEN;
     int stop_bits = (uart->stop_bits)==1?UART_STOP_BIT1:UART_STOP_BIT2;
-    if (uart->id == 4)
-        Core_VUartInit(VIRTUAL_UART0, uart->baud_rate, 1, (uart->data_bits), parity, stop_bits, NULL);
-    else
+    if (uart->id >= UART_MAX) {
+    	Core_VUartInit(VIRTUAL_UART0, uart->baud_rate, 1, (uart->data_bits), parity, stop_bits, NULL);
+    } else {
         Uart_BaseInit(uart->id, uart->baud_rate, 1, (uart->data_bits), parity, stop_bits, NULL);
+    }
     return 0;
 }
 

application/src/luat_usb_app_air105.c

@@ -29,7 +29,15 @@
 extern void *luat_spi_get_sdhc_ctrl(void);
 
 int32_t luat_usb_app_vhid_cb(void *pData, void *pParam);
+void luat_usb_app_set_vid_pid(uint8_t usb_id, uint16_t vid, uint16_t pid)
+{
+	Core_USBSetID(usb_id, vid, pid);
 
+}
+void uat_usb_app_set_hid_mode(uint8_t usb_id, uint8_t hid_mode, uint8_t buff_size)
+{
+	Core_USBSetHIDMode(usb_id, hid_mode, buff_size);
+}
 //打开luatos内置usb device config，实现虚拟MSC，HID和串口的复合设备功能，串口收发见luat_uart
 void luat_usb_app_start(uint8_t usb_id)
 {
@@ -43,14 +51,19 @@ void luat_usb_app_stop(uint8_t usb_id)
 	USB_StackClearSetup(usb_id);
 }
 
-void luat_usb_app_vhid_upload(uint8_t usb_id, uint8_t *key_data, uint16_t len)
+void luat_usb_app_vhid_tx(uint8_t usb_id, uint8_t *data, uint32_t len)
 {
-	Core_VHIDUploadData(usb_id, key_data, len);
+	Core_VHIDSendRawData(usb_id, data, len);
 }
 
-void luat_usb_app_vhid_upload_raw(uint8_t usb_id, uint8_t *key_data)
+uint32_t luat_usb_app_vhid_rx(uint8_t usb_id, uint8_t *data, uint32_t len)
 {
-	Core_VHIDSendRawData(usb_id, key_data,8);
+	return Core_VHIDRxBufferRead(usb_id, data, len);
+}
+
+void luat_usb_app_vhid_upload(uint8_t usb_id, uint8_t *key_data, uint32_t len)
+{
+	Core_VHIDUploadData(usb_id, key_data, len);
 }
 
 void luat_usb_app_vhid_cancel_upload(uint8_t usb_id)

bsp/air105/hal/core_dac.c

@@ -67,7 +67,7 @@ void DAC_DMAInit(uint8_t DAC_ID, uint8_t Stream)
 	DMA_InitStruct.DMA_Peripheral = SYSCTRL_PHER_CTRL_DMA_CHx_IF_DAC;
 	DMA_InitStruct.DMA_PeripheralBurstSize = DMA_BurstSize_4;
 	DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&DAC->DAC_DATA;
-	DMA_InitStruct.DMA_Priority = DMA_Priority_1;
+	DMA_InitStruct.DMA_Priority = DMA_Priority_3;
 	DMA_InitStruct.DMA_MemoryBurstSize = DMA_BurstSize_4;
 	DMA_InitStruct.DMA_MemoryDataSize = DMA_DataSize_HalfWord;
 	DMA_InitStruct.DMA_PeripheralDataSize = DMA_DataSize_HalfWord;
@@ -80,7 +80,15 @@ void DAC_Setup(uint8_t DAC_ID, uint32_t Freq, uint32_t OutRMode)
 	uint32_t Ctrl;
 	DAC->DAC_CR1 |= (1 << 4);
 	while (DAC->DAC_CR1 & (1 << 29));
-	DAC->DAC_TIMER = ((SystemCoreClock >> 3) / Freq) - 1;
+	switch(Freq)
+	{
+	case 44100:
+		DAC->DAC_TIMER = 543;
+		break;
+	default:
+		DAC->DAC_TIMER = ((SystemCoreClock >> 3) / Freq) - 1;
+		break;
+	}
 	DAC->DAC_FIFO_THR = 10;
 	DAC->DAC_CR1 = (OutRMode << 5) | 0x18;
 }

bsp/air105/hal/core_debug.c

@@ -380,8 +380,11 @@ void DBG_Printf(const char* format, ...)
 		len = vsnprintf_(buf, 1023, format, ap);
 	}
 	va_end(ap);
-
+#ifndef __DEBUG__
     prvDBGCtrl.TxFun( buf, len);
+#else
+    add_printf_data(buf, len);
+#endif
 	if (!OS_CheckInIrq())
 	{
 		OS_Free(buf);

bsp/air105/hal/core_pm.c

@@ -58,11 +58,13 @@ void PM_Print(void)
 int32_t PM_Sleep(void)
 {
 	uint64_t StartTick;
-	uint32_t Temp;
+	volatile uint32_t Temp, Temp2, Temp3;
 	if (prvPM.HWFlagBit || prvPM.DrvFlagBit) return -ERROR_DEVICE_BUSY;
 	__disable_irq();
 	SYSCTRL->ANA_CTRL |= BIT(7)|BIT(5)|BIT(4);
 	SYSCTRL->LDO25_CR |= BIT(4);
+	Temp2 = ADC0->ADC_CR1;
+	Temp3 = DAC->DAC_CR1;
 	ADC0->ADC_CR1 |= BIT(8);
 	ADC0->ADC_CR1 &= ~BIT(6);
 	DAC->DAC_CR1 |= BIT(4);
@@ -75,9 +77,8 @@ int32_t PM_Sleep(void)
 //	SYSCTRL->LDO25_CR &= ~BIT(5);
 //	SYSCTRL->PHER_CTRL &= ~BIT(20);
 	TRNG->RNG_ANA = Temp;
-	ADC0->ADC_CR1 &= ~BIT(8);
-	ADC0->ADC_CR1 |= BIT(6);
-	DAC->DAC_CR1 &= ~BIT(4);
+	ADC0->ADC_CR1 = Temp2;
+	DAC->DAC_CR1 = Temp3;
 	SYSCTRL->LDO25_CR &= ~BIT(4);
     SYSCTRL->ANA_CTRL &= ~(BIT(7)|BIT(5)|BIT(4));
 	WDT_Feed();

bsp/air105/hal/core_uart.c

@@ -330,7 +330,7 @@ int Uart_DMATxInit(uint8_t UartID, uint8_t Stream, uint32_t Channel)
 	DMA_InitStruct.DMA_Peripheral = prvUart[UartID].DMATxChannel;
 	DMA_InitStruct.DMA_PeripheralBurstSize = DMA_BurstSize_8;
 	DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&Uart->OFFSET_0.THR;
-	DMA_InitStruct.DMA_Priority = DMA_Priority_3;
+	DMA_InitStruct.DMA_Priority = DMA_Priority_1;
 	DMA_InitStruct.DMA_MemoryBurstSize = DMA_BurstSize_8;
 	prvUart[UartID].DMATxStream = Stream;
 	return DMA_ConfigStream(Stream, &DMA_InitStruct);
@@ -530,7 +530,7 @@ uint32_t Uart_RxBufferRead(uint8_t UartID, uint8_t *Data, uint32_t Len)
 		return 0;
 	}
 	ISR_OnOff(prvUart[UartID].IrqLine, 0);
-	if (!Len)
+	if (!Data || !Len)
 	{
 		ReadLen = prvUart[UartID].RxBuf.Pos;
 		ISR_OnOff(prvUart[UartID].IrqLine, 1);

bsp/air105/hal/core_usb_ll_driver.c

@@ -1467,6 +1467,7 @@ static int prvUSB_SetupEPFifo(HANDLE hUSB)
 		}
 		if (UseFifo > 512)
 		{
+			DBG("to much fifo!");
 			return -1;
 		}
 		if (hwUSB->EpCtrl[i].ToHostEnable)
@@ -1481,6 +1482,7 @@ static int prvUSB_SetupEPFifo(HANDLE hUSB)
 		}
 		if (UseFifo > 512)
 		{
+			DBG("to much fifo!");
 			return -1;
 		}
 	}

bsp/common/include/core_service.h

@@ -48,6 +48,9 @@ void Core_LCDDrawBlock(LCD_DrawStruct *Draw);
 void Core_CameraDraw(LCD_DrawStruct *Draw);
 void Core_DecodeQR(uint8_t *ImageData, uint16_t ImageW, uint16_t ImageH,  CBDataFun_t CB);
 uint32_t Core_LCDDrawCacheLen(void);
+
+void Core_USBSetID(uint8_t USB_ID, uint16_t VID, uint16_t PID);
+void Core_USBSetHIDMode(uint8_t USB_ID, uint8_t HIDMode, uint8_t BuffSize);
 void Core_USBDefaultDeviceStart(uint8_t USB_ID);
 void Core_USBAction(uint8_t USB_ID, uint8_t Action, void *pParam);
 void Core_ScanKeyBoard(void);
@@ -72,9 +75,10 @@ int32_t Core_VUartBufferTx(uint8_t UartID, const uint8_t *Data, uint32_t Len);
 void Core_VUartBufferTxStop(uint8_t UartID);
 
 void Core_VHIDInit(uint8_t USB_ID, CBFuncEx_t CB);
-void Core_VHIDUploadData(uint8_t USB_ID, uint8_t *Data, uint16_t Len);
-void Core_VHIDSendRawData(uint8_t USB_ID, uint8_t *Data, uint16_t Len);
+void Core_VHIDUploadData(uint8_t USB_ID, uint8_t *Data, uint32_t Len);
+void Core_VHIDSendRawData(uint8_t USB_ID, uint8_t *Data, uint32_t Len);
 void Core_VHIDUploadStop(uint8_t USB_ID);
+uint32_t Core_VHIDRxBufferRead(uint8_t USB_ID, uint8_t *Data, uint32_t Len);
 
 void Core_UDiskAttachSDHC(uint8_t USB_ID, void *pCtrl);
 #endif

bsp/common/src/core_usb_app.c

@@ -56,10 +56,12 @@ typedef struct
 {
 	Buffer_Struct TxBuf;
 	Buffer_Struct TxCacheBuf;	// 缓存下次发送的数据
+	Buffer_Struct RxBuf;
 	CBFuncEx_t CB;
 	uint8_t USB_ID;
 	uint8_t IsReady;
 	uint8_t ToHostEpIndex;
+	uint8_t ToDeviceEpIndex;
 }Virtual_HIDCtrlStruct;
 
 
@@ -206,7 +208,7 @@ static const char *prvCore_StringInterface[3] = {
 
 
 
-static const usb_device_descriptor_t prvCore_DeviceDesc =
+static usb_device_descriptor_t prvCore_DeviceDesc =
 {
 		.bLength = USB_LEN_DEV_DESC,
 		.bDescriptorType = UDESC_DEVICE,
@@ -315,14 +317,14 @@ static const usb_interface_descriptor_t prvCore_HIDInterfaceDesc =
 		.iInterface = USBD_IDX_INTERFACE0_STR + 1,
 };
 
-static const usb_endpoint_descriptor_t prvCore_HIDEndpointDesc[2] =
+static usb_endpoint_descriptor_t prvCore_HIDEndpointDesc[2] =
 {
 		{
 				.bLength = USB_LEN_EP_DESC,
 				.bDescriptorType = UDESC_ENDPOINT,
 				.bEndpointAddress = UE_DIR_IN|DEVICE_HID_KEYBOARD_EP_IN,
 				.bmAttributes = UE_INTERRUPT,
-				.wMaxPacketSize = {0x08,0x00},
+				.wMaxPacketSize = {0x40,0x00},
 				.bInterval = 10,
 		},
 		{
@@ -330,7 +332,7 @@ static const usb_endpoint_descriptor_t prvCore_HIDEndpointDesc[2] =
 				.bDescriptorType = UDESC_ENDPOINT,
 				.bEndpointAddress = UE_DIR_OUT|DEVICE_HID_KEYBOARD_EP_OUT,
 				.bmAttributes = UE_INTERRUPT,
-				.wMaxPacketSize = {0x08,0x00},
+				.wMaxPacketSize = {0x40,0x00},
 				.bInterval = 10,
 		},
 };
@@ -379,20 +381,20 @@ static const usb_hid_descriptor_t  prvCore_HIDDesc =
 		.wDescriptorLength = {63,0},
 };
 
-static const char prvCore_HIDCustomReportDescriptor[34] = {
+static char prvCore_HIDCustomReportDescriptor[34] = {
 	    0x06, 0x00, 0xff,              // USAGE_PAGE (Vendor Defined Page 1)
 	    0x09, 0x00,                    // USAGE (Undefined)
 	    0xa1, 0x01,                    // COLLECTION (Application)
 	    0x09, 0x00,                    //   USAGE (Undefined)
-	    0x75, 0x08,                    //   REPORT_SIZE (8)
-	    0x95, 0x08,                    //   REPORT_COUNT (8)
+	    0x95, USB_HID_KB_DATA_CACHE,      //   REPORT_COUNT (32)
+	    0x75, 0x08,      			   //   REPORT_SIZE (8)
 	    0x26, 0xff, 0x00,              //   LOGICAL_MAXIMUM (255)
 	    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
 	    0x81, 0x02,                    // INPUT (Data,Var,Abs)
 	    0x09, 0x00,                    //   USAGE (Undefined)
 	    0x26, 0xff, 0x00,              //   LOGICAL_MAXIMUM (255)
 	    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-	    0x95, 0x08,                    //   REPORT_COUNT (8)
+	    0x95, USB_HID_KB_DATA_CACHE,      //   REPORT_COUNT (32)
 	    0x75, 0x08,                    //   REPORT_SIZE (8)
 	    0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
 	    0xc0                           // END_COLLECTION
@@ -422,7 +424,7 @@ static const char prvCore_HIDKeyboardReportDesc[64] = {
 	    0x95, 0x01,                    //   REPORT_COUNT (1)
 	    0x75, 0x03,                    //   REPORT_SIZE (3)
 	    0x91, 0x03,                    //   OUTPUT (Cnst,Var,Abs)
-	    0x95, 0x06,                    //   REPORT_COUNT (6)
+	    0x95, USB_HID_KEY_CACHE,       //   REPORT_COUNT (30)
 	    0x75, 0x08,                    //   REPORT_SIZE (8)
 	    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
 	    0x26, 0xff, 0x00,             	  //   LOGICAL_MAXIMUM (255)
@@ -728,9 +730,8 @@ static int32_t prvCore_HIDCB(void *pData, void *pParam)
 	if (pEpData->IsToDevice)
 	{
 		prvCore_VHIDSetReady(1);
-		Buf.Data = pEpData->Data;
-		Buf.Pos = pEpData->Len;
-		pVHID->CB(prvLuatOS_VirtualHID.USB_ID, &Buf);
+		OS_BufferWrite(&pVHID->RxBuf, pEpData->Data, pEpData->Len);
+		pVHID->CB(USB_ID, USB_HID_NEW_DATA);
 	}
 	else
 	{
@@ -818,6 +819,43 @@ static int32_t prvCore_USBStateCB(void *pData, void *pParam)
 	}
 }
 
+void Core_USBSetID(uint8_t USB_ID, uint16_t VID, uint16_t PID)
+{
+	BytesPutLe16(prvCore_DeviceDesc.idVendor, VID);
+	BytesPutLe16(prvCore_DeviceDesc.idProduct, PID);
+}
+
+void Core_USBSetHIDMode(uint8_t USB_ID, uint8_t HIDMode, uint8_t BuffSize)
+{
+	switch(BuffSize)
+	{
+	case 8:
+	case 16:
+	case 32:
+	case 64:
+		break;
+	default:
+		BuffSize = 8;
+		break;
+	}
+	if (HIDMode)
+	{
+		prvUSBApp.pHIDReport = &prvCore_HIDCustomReportDescriptor;
+		prvUSBApp.HIDReportLen = sizeof(prvCore_HIDCustomReportDescriptor);
+		prvCore_HIDCustomReportDescriptor[10] = BuffSize;
+		prvCore_HIDCustomReportDescriptor[28] = BuffSize;
+		prvCore_HIDEndpointDesc[0].wMaxPacketSize[0] = BuffSize;
+		prvCore_HIDEndpointDesc[1].wMaxPacketSize[0] = BuffSize;
+	}
+	else
+	{
+		prvUSBApp.pHIDReport = &prvCore_HIDKeyboardReportDesc;
+		prvUSBApp.HIDReportLen = sizeof(prvCore_HIDKeyboardReportDesc);
+		prvCore_HIDEndpointDesc[0].wMaxPacketSize[0] = 8;
+		prvCore_HIDEndpointDesc[1].wMaxPacketSize[0] = 8;
+	}
+}
+
 void Core_USBDefaultDeviceStart(uint8_t USB_ID)
 {
 	uint8_t langid[2] = {0x09, 0x04};
@@ -825,6 +863,7 @@ void Core_USBDefaultDeviceStart(uint8_t USB_ID)
 	prvLuatOS_VirtualHID.USB_ID = USB_ID;
 	prvLuatOS_VirtualHID.IsReady = 0;
 	prvLuatOS_VirtualHID.ToHostEpIndex = DEVICE_HID_KEYBOARD_EP_IN;
+	prvLuatOS_VirtualHID.ToDeviceEpIndex = DEVICE_HID_KEYBOARD_EP_OUT;
 	prvUSBApp.tUDisk.BlockTotalNums = VIRTUAL_UDISK_BLOCKS_NUMS;
 	prvUSBApp.tUDisk.BlockSize = VIRTUAL_UDISK_BLOCKS_LEN;
 	prvUSBApp.tSCSI.LogicalUnitNum = 0;
@@ -962,7 +1001,7 @@ uint32_t Core_VUartRxBufferRead(uint8_t UartID, uint8_t *Data, uint32_t Len)
 		USB_StackEpIntOnOff(pVUart->USB_ID, pVUart->ToDeviceEpIndex, 1, 0);
 		break;
 	}
-	if (!Len)
+	if (!Data || !Len)
 	{
 		ReadLen = pVUart->RxBuf.Pos;
 		goto READ_END;
@@ -1022,7 +1061,6 @@ TX_END:
 		break;
 	}
 	return 0;
-
 }
 void Core_VUartBufferTxStop(uint8_t UartID)
 {
@@ -1044,7 +1082,30 @@ void Core_VUartBufferTxStop(uint8_t UartID)
 	}
 }
 
-void Core_VHIDUploadData(uint8_t USB_ID, uint8_t *Data, uint16_t Len)
+uint32_t Core_VHIDRxBufferRead(uint8_t USB_ID, uint8_t *Data, uint32_t Len)
+{
+	uint32_t ReadLen;
+	Virtual_HIDCtrlStruct *pVHID = &prvLuatOS_VirtualHID;
+	USB_StackEpIntOnOff(pVHID->USB_ID, pVHID->ToDeviceEpIndex, 1, 0);
+	if (!Data || !Len)
+	{
+		ReadLen = pVHID->RxBuf.Pos;
+		goto READ_END;
+
+	}
+	ReadLen = (pVHID->RxBuf.Pos < Len)?pVHID->RxBuf.Pos:Len;
+	memcpy(Data, pVHID->RxBuf.Data, ReadLen);
+	OS_BufferRemove(&pVHID->RxBuf, ReadLen);
+	if (!pVHID->RxBuf.Pos && pVHID->RxBuf.MaxLen > VIRTUAL_VHID_BUFFER_LEN)
+	{
+		OS_ReInitBuffer(&pVHID->RxBuf, VIRTUAL_VHID_BUFFER_LEN);
+	}
+READ_END:
+	USB_StackEpIntOnOff(pVHID->USB_ID, pVHID->ToDeviceEpIndex, 1, 1);
+	return ReadLen;
+}
+
+void Core_VHIDUploadData(uint8_t USB_ID, uint8_t *Data, uint32_t Len)
 {
 	if (!prvLuatOS_VirtualHID.IsReady) return;
 	USB_HIDKeyValue HIDKey;
@@ -1071,8 +1132,13 @@ void Core_VHIDUploadData(uint8_t USB_ID, uint8_t *Data, uint16_t Len)
 			HIDKeyBoard.SPECIALHID_KEY_b.RightShift = IsShift;
 			HIDKeyBoard.PressKey[0] = HIDKey.Value;
 //			DBG("%u,%c,%d,%x,%d", Pos - 1, Data[Pos - 1], 0, HIDKey.Value, HIDKey.Shift);
+			if (Pos >= Len)
+			{
+				OS_BufferWrite(&pVHID->TxCacheBuf, &HIDKeyBoard, sizeof(HIDKeyBoard));
+				break;
+			}
 ADD_REST:
-			for(i = 1; i < 6; i++)
+			for(i = 1; i < USB_HID_KEY_CACHE; i++)
 			{
 				HIDKey = USB_HIDGetValueFromAscii(Data[Pos]);
 				Pos++;
@@ -1097,26 +1163,6 @@ ADD_REST:
 					}
 
 				}
-//				else if
-//				{
-//					OS_BufferWrite(&pVHID->TxCacheBuf, &HIDKeyBoard, sizeof(HIDKeyBoard));
-//					memset(&HIDKeyBoard, 0, sizeof(USB_HIDKeyBoradKeyStruct));
-//					//加入一个抬起的data
-//					OS_BufferWrite(&pVHID->TxCacheBuf, &HIDKeyBoard, sizeof(HIDKeyBoard));
-//					IsShift = HIDKey.Shift;
-//					LastValue = HIDKey.Value;
-//					HIDKeyBoard.SPECIALHID_KEY_b.RightShift = IsShift;
-//					HIDKeyBoard.PressKey[0] = HIDKey.Value;
-////					DBG("%u,%c,%d,%x,%d", Pos - 1, Data[Pos - 1], 0, HIDKey.Value, HIDKey.Shift);
-//					if (Pos < Len)
-//					{
-//						goto ADD_REST;
-//					}
-//					else
-//					{
-//						break;
-//					}
-//				}
 				else
 				{
 					LastValue = HIDKey.Value;
@@ -1143,7 +1189,6 @@ ADD_REST:
 	{
 		goto UPLOAD_END;
 	}
-
 	// 把缓存的Tx指针交给发送的Tx指针，缓存的Tx指针重新建立一个
 	Buffer_StaticInit(&pVHID->TxBuf, pVHID->TxCacheBuf.Data, pVHID->TxCacheBuf.Pos);
 	OS_InitBuffer(&pVHID->TxCacheBuf, VIRTUAL_VHID_BUFFER_LEN);
@@ -1152,13 +1197,18 @@ UPLOAD_END:
 	USB_StackEpIntOnOff(pVHID->USB_ID, pVHID->ToHostEpIndex, 0, 1);
 }
 
-void Core_VHIDSendRawData(uint8_t USB_ID, uint8_t *Data, uint16_t Len)
+void Core_VHIDSendRawData(uint8_t USB_ID, uint8_t *Data, uint32_t Len)
 {
+	uint8_t zero[USB_HID_CUST_DATA_CACHE] = {0};
 	if (!prvLuatOS_VirtualHID.IsReady) return;
 	USB_HIDKeyValue HIDKey;
 	Virtual_HIDCtrlStruct *pVHID = &prvLuatOS_VirtualHID;
 	USB_StackEpIntOnOff(pVHID->USB_ID, pVHID->ToHostEpIndex, 0, 0);
 	OS_BufferWrite(&pVHID->TxCacheBuf, Data, Len);
+	if (Len % prvCore_HIDCustomReportDescriptor[28])
+	{
+		OS_BufferWrite(&pVHID->TxCacheBuf, zero, prvCore_HIDCustomReportDescriptor[28] - (Len % prvCore_HIDCustomReportDescriptor[28]));
+	}
 	Buffer_StaticInit(&pVHID->TxBuf, pVHID->TxCacheBuf.Data, pVHID->TxCacheBuf.Pos);
 	OS_InitBuffer(&pVHID->TxCacheBuf, VIRTUAL_VHID_BUFFER_LEN);
 	USB_StackTxEpData(pVHID->USB_ID, pVHID->ToHostEpIndex, pVHID->TxBuf.Data, pVHID->TxBuf.MaxLen, pVHID->TxBuf.MaxLen, 1);

bsp/usb/include/usb_driver.h

@@ -52,9 +52,9 @@ typedef struct
 	volatile Buffer_Struct TxBuf;
 	CBFuncEx_t CB;
 	void *pData;
+	uint32_t XferMaxLen;
 	uint16_t MaxPacketLen;
 	uint16_t TimeoutMS;
-	uint16_t XferMaxLen;
 	union
 	{
 		uint16_t ToHostStatus;
@@ -121,7 +121,7 @@ int32_t USB_StackStop(uint8_t USB_ID);
 void USB_StackPutRxData(uint8_t USB_ID, uint8_t EpIndex, const uint8_t *Data, uint32_t Len);
 void USB_StackResetEpBuffer(uint8_t USB_ID, uint8_t Index);
 void USB_StackSetEpStatus(uint8_t USB_ID, uint8_t EpIndex, uint8_t IsToDevice, uint8_t Status);
-int32_t USB_StackTxEpData(uint8_t USB_ID, uint8_t EpIndex, void *pData, uint16_t Len, uint16_t MaxLen, uint8_t ForceZeroPacket);
+int32_t USB_StackTxEpData(uint8_t USB_ID, uint8_t EpIndex, void *pData, uint32_t Len, uint32_t MaxLen, uint8_t ForceZeroPacket);
 void USB_StackSetRxEpDataLen(uint8_t USB_ID, uint8_t EpIndex, uint32_t Len);
 void USB_StackEpIntOnOff(uint8_t USB_ID, uint8_t EpIndex, uint8_t IsToDevice, uint8_t OnOff);
 /*************usb class api*******************/

bsp/usb/include/usb_hid.h

@@ -162,11 +162,16 @@
 #define USB_HID_REQ_SET_REPORT                         0x09U
 #define USB_HID_REQ_GET_REPORT                         0x01U
 
+#define USB_HID_KEY_CACHE		(6)
+#define USB_HID_KB_DATA_CACHE		(8)
+#define USB_HID_CUST_DATA_CACHE		(64)
+
 enum
 {
 	USB_HID_NOT_READY,
 	USB_HID_READY,
 	USB_HID_SEND_DONE,
+	USB_HID_NEW_DATA,
 };
 
 typedef struct
@@ -204,7 +209,7 @@ typedef struct
 
 	};
 	uint8_t bZero;
-	uint8_t PressKey[6];
+	uint8_t PressKey[USB_HID_KEY_CACHE];
 }USB_HIDKeyBoradKeyStruct;
 
 typedef struct

bsp/usb/src/core_usb_stack.c

@@ -461,7 +461,7 @@ int32_t USB_StackStartOTG(uint8_t USB_ID)
 	return -1;
 }
 
-int32_t USB_StackTxEpData(uint8_t USB_ID, uint8_t EpIndex, void *pData, uint16_t Len, uint16_t MaxLen, uint8_t ForceZeroPacket)
+int32_t USB_StackTxEpData(uint8_t USB_ID, uint8_t EpIndex, void *pData, uint32_t Len, uint32_t MaxLen, uint8_t ForceZeroPacket)
 {
 	USB_StackCtrlStruct *USBCore = &prvUSBCore[USB_ID];
 	USB_SetDeviceEPStatus(USBCore->pHWCtrl, EpIndex, 0, USB_EP_STATE_ACK);