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

application/include/app_interface.h

@@ -42,6 +42,7 @@
 #include "core_dcmi.h"
 #include "core_rng.h"
 #include "core_task.h"
+#include "audio_ll_drv.h"
 #include "core_soft_keyboard.h"
 #include "lfs.h"
 #include "usb_driver.h"

application/src/luat_audio_air105.c

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2022 OpenLuat & AirM2M
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#include "luat_base.h"
+#include "luat_msgbus.h"
+#include "luat_fs.h"
+#include <stdlib.h>
+#include "luat_multimedia.h"
+#include "app_interface.h"
+
+static Audio_StreamStruct prvAudioStream;
+int32_t luat_audio_app_cb(void *pData, void *pParam)
+{
+    rtos_msg_t msg = {0};
+	msg.handler = l_multimedia_raw_handler;
+	msg.arg1 = (pParam == INVALID_HANDLE_VALUE)?MULTIMEDIA_CB_AUDIO_DONE:MULTIMEDIA_CB_AUDIO_NEED_DATA;
+	msg.arg2 = prvAudioStream.pParam;
+	luat_msgbus_put(&msg, 1);
+
+}
+
+int luat_audio_start_raw(uint8_t multimedia_id, uint8_t audio_format, uint8_t num_channels, uint32_t sample_rate, uint8_t bits_per_sample, uint8_t is_signed)
+{
+	prvAudioStream.pParam = multimedia_id;
+	prvAudioStream.CB = luat_audio_app_cb;
+	prvAudioStream.BitDepth = bits_per_sample;
+	prvAudioStream.BusType = AUSTREAM_BUS_DAC;
+	prvAudioStream.BusID = 0;
+	prvAudioStream.Format = audio_format;
+	prvAudioStream.ChannelCount = num_channels;
+	prvAudioStream.SampleRate = sample_rate;
+	prvAudioStream.IsDataSigned = is_signed;
+	return Audio_StartRaw(&prvAudioStream);
+}
+
+int luat_audio_write_raw(uint8_t multimedia_id, uint8_t *data, uint32_t len)
+{
+	if (len)
+		return Audio_WriteRaw(&prvAudioStream, data, len);
+	return -1;
+}
+
+
+int luat_audio_stop_raw(uint8_t multimedia_id)
+{
+	Audio_Stop(&prvAudioStream);
+	return ERROR_NONE;
+}
+
+int luat_audio_pause_raw(uint8_t multimedia_id, uint8_t is_pause)
+{
+	if (is_pause)
+	{
+		Audio_Pause(&prvAudioStream);
+	}
+	else
+	{
+		Audio_Resume(&prvAudioStream);
+	}
+	return ERROR_NONE;
+}

application/src/luat_base_air105.c

@@ -200,6 +200,8 @@ static const luaL_Reg loadedlibs[] = {
   {"softkb", luaopen_softkb}, 
 #endif
   {"usbapp", luaopen_usbapp},
+  {"audio", luaopen_multimedia_audio},
+  {"decode", luaopen_multimedia_decode},
   {NULL, NULL}
 };
 

application/src/luat_lib_usbapp.c

@@ -111,6 +111,29 @@ static int l_usb_vhid_upload(lua_State* L) {
     return 1;
 }
 
+/*
+USB HID设备上传数据
+@api usbapp.rawKey(id, data)
+@int 设备id,默认为0
+@string 数据，需为定长的8字节
+@return bool 成功返回true,否则返回false
+@usage
+-- HID上传数据
+usbapp.rawKey(0, string.char(0x08,0,0x15,0,0,0,0,0)) -- usb hid会模拟敲出win+r
+*/
+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);
+        lua_pushboolean(L, 1);
+    }
+    else {
+        lua_pushboolean(L, 0);
+    }
+    return 1;
+}
+
 /*
 USB HID设备取消上传数据
 @api usbapp.vhid_cancel_upload(id)
@@ -134,7 +157,7 @@ USB U盘设备挂载SDHC，TF卡
 usbapp.udisk_attach_sdhc(0)
 */
 static int l_usb_udisk_attach_sdhc(lua_State* L) {
-    luat_usb_app_vhid_cancel_upload(USB_ID0);
+	luat_usb_udisk_attach_sdhc(USB_ID0);
     return 0;
 }
 
@@ -147,7 +170,7 @@ USB U盘设备去除挂载SDHC，TF卡
 usbapp.udisk_detach_sdhc(0)
 */
 static int l_usb_udisk_detach_sdhc(lua_State* L) {
-    luat_usb_app_vhid_cancel_upload(USB_ID0);
+	luat_usb_udisk_detach_sdhc(USB_ID0);
     return 0;
 }
 #include "rotable.h"
@@ -156,6 +179,7 @@ static const rotable_Reg 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},

application/src/luat_usb_app_air105.c

@@ -48,6 +48,11 @@ void luat_usb_app_vhid_upload(uint8_t usb_id, uint8_t *key_data, uint16_t len)
 	Core_VHIDUploadData(usb_id, key_data, len);
 }
 
+void luat_usb_app_vhid_upload_raw(uint8_t usb_id, uint8_t *key_data)
+{
+	Core_VHIDSendRawData(usb_id, key_data,8);
+}
+
 void luat_usb_app_vhid_cancel_upload(uint8_t usb_id)
 {
 	Core_VHIDUploadStop(usb_id);

bsp/air105/test/test_usb_device.c

@@ -77,7 +77,7 @@ int32_t prvTest_HIDCB(void *pData, void *pParam)
 void Test_USBStart(void)
 {
 	Core_VUartInit(VIRTUAL_UART0, 0, 1, 0, 0, 0, prvTest_USBCB);
-	Core_VHIDInit(0, prvTest_HIDCB);
+//	Core_VHIDInit(0, prvTest_HIDCB);
 //	Core_VUartSetRxTimeout(VIRTUAL_UART0, 200);
 }
 
@@ -86,16 +86,16 @@ void prvUSB_Test(void *p)
 	SDHC_SPICtrlStruct SDHC;
 	memset(&SDHC, 0, sizeof(SDHC));
 	SDHC.SpiID = SPI_ID0;
-	SDHC.CSPin = GPIOC_13;
+	SDHC.CSPin = GPIOB_13;
 	SDHC.IsSpiDMAMode = 0;
 //	SDHC.NotifyTask = Task_GetCurrent();
 //	SDHC.TaskCB = prvEventCB;
-    SDHC.SDHCReadBlockTo = 5 * CORE_TICK_1MS;
-    SDHC.SDHCWriteBlockTo = 25 * CORE_TICK_1MS;
+    SDHC.SDHCReadBlockTo = 50 * CORE_TICK_1MS;
+    SDHC.SDHCWriteBlockTo = 250 * CORE_TICK_1MS;
     SDHC.IsPrintData = 0;
-    GPIO_Iomux(GPIOC_12,2);
-    GPIO_Iomux(GPIOC_14,2);
-    GPIO_Iomux(GPIOC_15,2);
+    GPIO_Iomux(GPIOB_12,0);
+    GPIO_Iomux(GPIOB_14,0);
+    GPIO_Iomux(GPIOB_15,0);
     GPIO_Config(SDHC.CSPin, 0, 1);
     SPI_MasterInit(SDHC.SpiID, 8, SPI_MODE_0, 400000, NULL, NULL);
 

bsp/audio/include/audio_ll_drv.h

@@ -25,7 +25,7 @@ typedef struct
 	llist_head DataHead;
 	uint32_t SampleRate;
 	uint8_t BitDepth;
-	uint8_t ChannelCount;	//声道，目前只有1
+	uint8_t ChannelCount;	//声道，目前只有1或者2
 	auStreamFormat_t Format;
 	auStreamBusType_t BusType;	//音频总线类型，DAC, IIS之类的
 	uint8_t BusID;		//音频总线ID

bsp/audio/src/audio_ll_drv.c

@@ -117,20 +117,35 @@ static int32_t prvAudio_RunDAC(Audio_StreamStruct *pStream)
 
 static int32_t prvAudio_WriteDACRaw(Audio_StreamStruct *pStream, uint8_t *pByteData, uint32_t ByteLen)
 {
-	uint32_t i;
+	uint32_t i, VaildLen;
 	uint32_t DiffBit;
+	uint16_t *wTemp;
 	Audio_DataBlockStruct *Block = zalloc(sizeof(Audio_DataBlockStruct));
+	VaildLen = ByteLen >> (pStream->ChannelCount >> 1);
+	//DBG("%u,%u", ByteLen, VaildLen);
 	if (pStream->BitDepth > 8)
 	{
-		Block->uPV.pu8 = malloc(ByteLen);
+		Block->uPV.pu8 = malloc(VaildLen);
 		if (!Block->uPV.pu8)
 		{
 			free(Block);
 			DBG("no mem!");
 			return -ERROR_NO_MEMORY;
 		}
-		memcpy(Block->uPV.pu8, pByteData, ByteLen);
-		Block->Len = ByteLen >> 1;
+		Block->Len = VaildLen >> 1;
+		if (2 == pStream->ChannelCount)
+		{
+			wTemp = pByteData;
+			for(i = 0; i < Block->Len; i++)
+			{
+				Block->uPV.pu16[i] = wTemp[i * 2];
+			}
+		}
+		else
+		{
+			memcpy(Block->uPV.pu8, pByteData, VaildLen);
+		}
+
 		if (pStream->IsDataSigned)
 		{
 			for(i = 0; i < Block->Len; i++)
@@ -158,20 +173,20 @@ static int32_t prvAudio_WriteDACRaw(Audio_StreamStruct *pStream, uint8_t *pByteD
 	}
 	else
 	{
-		Block->uPV.pu8 = malloc(ByteLen * 2);
+		Block->uPV.pu8 = malloc(VaildLen * 2);
 		if (!Block->uPV.pu8)
 		{
 			free(Block);
 			DBG("no mem!");
 			return -ERROR_NO_MEMORY;
 		}
-		Block->Len = ByteLen;
+		Block->Len = VaildLen;
 		DiffBit = prvAudio.DACBit - 8;
 		if (pStream->IsDataSigned)
 		{
 			for(i = 0; i < Block->Len; i++)
 			{
-				Block->uPV.pu16[i] = ((pByteData[i] + 0x80) & 0x00ff);
+				Block->uPV.pu16[i] = ((pByteData[i * pStream->ChannelCount] + 0x80) & 0x00ff);
 				Block->uPV.pu16[i] <<= DiffBit;
 			}
 		}
@@ -179,7 +194,7 @@ static int32_t prvAudio_WriteDACRaw(Audio_StreamStruct *pStream, uint8_t *pByteD
 		{
 			for(i = 0; i < Block->Len; i++)
 			{
-				Block->uPV.pu16[i] = pByteData[i];
+				Block->uPV.pu16[i] = pByteData[i * pStream->ChannelCount];
 				Block->uPV.pu16[i] <<= DiffBit;
 			}
 		}

bsp/common/include/core_service.h

@@ -73,6 +73,7 @@ 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_VHIDUploadStop(uint8_t USB_ID);
 
 void Core_UDiskAttachSDHC(uint8_t USB_ID, void *pCtrl);

bsp/common/src/core_usb_app.c

@@ -425,7 +425,7 @@ static const char prvCore_HIDKeyboardReportDesc[64] = {
 	    0x95, 0x06,                    //   REPORT_COUNT (6)
 	    0x75, 0x08,                    //   REPORT_SIZE (8)
 	    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-	    0x26, 0x00, 0xff,             	  //   LOGICAL_MAXIMUM (255)
+	    0x26, 0xff, 0x00,             	  //   LOGICAL_MAXIMUM (255)
 	    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
 	    0x19, 0x00,                    //   USAGE_MINIMUM (Reserved (no event indicated))
 	    0x29, 0x65,                    //   USAGE_MAXIMUM (Keyboard Application)
@@ -703,30 +703,6 @@ static int32_t prvCore_MSCCB(void *pData, void *pParam)
 {
 	USB_EndpointDataStruct *pEpData = (USB_EndpointDataStruct *)pData;
 	USB_EndpointDataStruct *pEpDataSave;
-	switch(prvUSBApp.tSCSI.BotState)
-	{
-	case USB_MSC_BOT_STATE_DATA_OUT_TO_DEVICE:
-	case USB_MSC_BOT_STATE_DATA_IN_TO_HOST:
-		goto MSC_RUN_IN_TASK;
-		break;
-	default:
-		if (pEpData->IsToDevice && pEpData->Data)
-		{
-			switch(pEpData->Data[15])
-			{
-			case SCSI_READ10:
-			case SCSI_READ12:
-			case SCSI_READ16:
-				goto MSC_RUN_IN_TASK;
-				break;
-			}
-
-		}
-		break;
-	}
-	USB_MSCHandle(pEpData, &prvUSBApp.tSCSI);
-	return ERROR_NONE;
-MSC_RUN_IN_TASK:
 	pEpDataSave = malloc(sizeof(USB_EndpointDataStruct));
 	memcpy(pEpDataSave, pEpData, sizeof(USB_EndpointDataStruct));
 	if (pEpData->Data && pEpData->Len)
@@ -740,7 +716,6 @@ MSC_RUN_IN_TASK:
 		pEpDataSave->Len = 0;
 	}
 	Task_SendEvent(prvUSBApp.hTaskHandle, USBD_MSC_CB, pEpDataSave, &prvUSBApp.tSCSI, pParam);
-
 	return ERROR_NONE;
 }
 
@@ -1234,6 +1209,18 @@ static void prvCore_USBAppTask(void *pParam)
 			pEpData = (USB_EndpointDataStruct *)Event.Param1;
 //			DBG("%d,%d,%d,%d", pEpData->USB_ID, pEpData->EpIndex, pEpData->IsToDevice, pEpData->Len);
 			USB_MSCHandle(pEpData, Event.Param2);
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_IN, 0, 0);
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_OUT, 1, 0);
+//			if (prvUSBApp.BlockCmd)
+//			{
+//				prvUSBApp.BlockCmd--;
+//			}
+//			else
+//			{
+//				DBG("!!!");
+//			}
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_IN, 0, 1);
+//			USB_StackEpIntOnOff(pEpData->USB_ID, DEVICE_MASS_STORAGE_EP_OUT, 1, 1);
 			free(pEpData->Data);
 			free(Event.Param1);
 			WDT_Feed();
@@ -1258,9 +1245,10 @@ void Core_UDiskAttachSDHC(uint8_t USB_ID, void *pCtrl)
 	memcpy(prvUSBApp.pSDHC, pCtrl, sizeof(SDHC_SPICtrlStruct));
 	prvUSBApp.tSCSI.pSCSIUserFunList = &prvSDHC_SCSIFun;
 	prvUSBApp.tSCSI.pUserData = prvUSBApp.pSDHC;
+	prvUSBApp.tSCSI.ReadTimeout = 500;
 	DBuffer_ReInit(&prvUSBApp.DataBuf, 8 * 1024);
+	prvUSBApp.pSDHC->USBDelayTime = 0;	//如果USB不稳定，可调加大USBDelayTime
 	prvUSBApp.pSDHC->SCSIDataBuf = &prvUSBApp.DataBuf;
-
 }
 
 void Core_UDiskDetachSDHC(uint8_t USB_ID)

bsp/device/include/dev_sdhc_spi.h

@@ -107,6 +107,8 @@ typedef struct
 	uint32_t Size;							//flash的大小KB
 	uint32_t OCR;
 	DBuffer_Struct *SCSIDataBuf;
+	uint32_t PreCurBlock;
+	uint32_t PreEndBlock;
 	uint32_t CurBlock;
 	uint32_t EndBlock;
 	uint16_t WriteWaitCnt;
@@ -122,11 +124,13 @@ typedef struct
 	uint8_t TempData[__SDHC_BLOCK_LEN__ + 8];
 	uint8_t IsPrintData;
 	uint8_t IsMMC;
+	uint8_t USBDelayTime;
 }SDHC_SPICtrlStruct;
 
 
 
 void SDHC_SpiInitCard(void *pSDHC);
+void SDHC_SpiReadCardConfig(void *pSDHC);
 void SDHC_SpiReadCardInfo(void *pSDHC);
 void SDHC_SpiWriteBlocks(void *pSDHC, const uint8_t *Buf, uint32_t StartLBA, uint32_t BlockNums);
 void SDHC_SpiReadBlocks(void *pSDHC, uint8_t *Buf, uint32_t StartLBA, uint32_t BlockNums);

bsp/device/src/dev_sdhc_spi.c

@@ -99,6 +99,10 @@ static int32_t prvSDHC_SCSIInit(uint8_t LUN, void *pUserData)
 static int32_t prvSDHC_SCSIGetCapacity(uint8_t LUN, uint32_t *BlockNum, uint32_t *BlockSize, void *pUserData)
 {
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
+	if (!pSDHC->Info.LogBlockSize || !pSDHC->Info.LogBlockNbr)
+	{
+		SDHC_SpiReadCardConfig(pSDHC);
+	}
 	*BlockSize = pSDHC->Info.LogBlockSize;
 	*BlockNum = pSDHC->Info.LogBlockNbr;
 	return 0;
@@ -121,11 +125,17 @@ static int32_t prvSDHC_SCSIPreRead(uint8_t LUN, uint32_t BlockAddress, uint32_t
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
 	if ((BlockAddress + BlockNums) > pSDHC->Info.LogBlockNbr)
 	{
+		DBG("%u,%u,%u", BlockAddress, BlockNums, pSDHC->Info.LogBlockNbr);
 		return -1;
 	}
 	pSDHC->CurBlock = BlockAddress;
 	pSDHC->EndBlock = BlockAddress + BlockNums;
-
+	if ((pSDHC->PreCurBlock == pSDHC->CurBlock) && pSDHC->PreEndBlock)
+	{
+//		DBG("%u,%u,%u", pSDHC->PreCurBlock, pSDHC->CurBlock, pSDHC->PreEndBlock);
+		pSDHC->CurBlock = pSDHC->PreEndBlock;
+		return 0;
+	}
 	prvSDHC_SCSIReadNext(LUN, pUserData);
 	return 0;
 }
@@ -142,7 +152,10 @@ static int32_t prvSDHC_SCSIRead(uint8_t LUN, uint32_t Len, uint8_t **pOutData, u
 	}
 	DBuffer_SetDataLen(pSDHC->SCSIDataBuf, 0, 1);
 	DBuffer_SwapCache(pSDHC->SCSIDataBuf);
-//	Task_DelayMS(1);
+	if (pSDHC->USBDelayTime)	//不得不降速
+	{
+		Task_DelayMS(pSDHC->USBDelayTime);
+	}
 #else
 	uint32_t ReadBlocks;
 	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
@@ -168,7 +181,15 @@ static int32_t prvSDHC_SCSIReadNext(uint8_t LUN, void *pUserData)
 #if 1
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
 	uint32_t ReadBlocks;
-	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
+	if (pSDHC->EndBlock <= pSDHC->CurBlock)
+	{
+		ReadBlocks = pSDHC->SCSIDataBuf->MaxLen >> 9;
+		pSDHC->PreCurBlock = pSDHC->EndBlock;
+		SDHC_SpiReadBlocks(pSDHC, DBuffer_GetCache(pSDHC->SCSIDataBuf, 1), pSDHC->PreCurBlock, ReadBlocks);
+		pSDHC->PreEndBlock = pSDHC->PreCurBlock + ReadBlocks;
+		DBuffer_SetDataLen(pSDHC->SCSIDataBuf, pSDHC->SCSIDataBuf->MaxLen, 1);
+		return ERROR_NONE;
+	}
 
 	if ( ((pSDHC->EndBlock - pSDHC->CurBlock) << 9) > pSDHC->SCSIDataBuf->MaxLen)
 	{
@@ -203,7 +224,6 @@ static int32_t prvSDHC_SCSIPreWrite(uint8_t LUN, uint32_t BlockAddress, uint32_t
 static int32_t prvSDHC_SCSIWrite(uint8_t LUN, uint8_t *Data, uint32_t Len, void *pUserData)
 {
 	SDHC_SPICtrlStruct *pSDHC = pUserData;
-	uint32_t WriteBlocks = Len >> 9;
 	if (!SDHC_IsReady(pSDHC)) return -1;
 	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
 	memcpy(DBuffer_GetCache(pSDHC->SCSIDataBuf, 1) + DBuffer_GetDataLen(pSDHC->SCSIDataBuf, 1), Data, Len);
@@ -218,6 +238,7 @@ static int32_t prvSDHC_SCSIDoWrite(uint8_t LUN, void *pUserData)
 	if (pSDHC->EndBlock <= pSDHC->CurBlock) return -1;
 	if (WriteBlocks)
 	{
+
 		if (WriteBlocks > (pSDHC->EndBlock - pSDHC->CurBlock))
 		{
 			WriteBlocks = pSDHC->EndBlock - pSDHC->CurBlock;
@@ -448,7 +469,7 @@ static int32_t SDHC_SpiWriteBlockData(SDHC_SPICtrlStruct *Ctrl)
 	uint8_t *pBuf;
 	Ctrl->SPIError = 0;
 	Ctrl->SDHCError = 0;
-	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * CORE_TICK_1MS;
+	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo;
 	while( (Ctrl->DataBuf.Pos < Ctrl->DataBuf.MaxLen) && (GetSysTick() < OpEndTick) )
 	{
 		Ctrl->TempData[0] = 0xff;
@@ -499,14 +520,14 @@ static int32_t SDHC_SpiWriteBlockData(SDHC_SPICtrlStruct *Ctrl)
 			goto SDHC_SPIWRITEBLOCKDATA_DONE;
 		}
 		Ctrl->DataBuf.Pos++;
-		OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * CORE_TICK_1MS;
+		OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo;
 	}
 	Result = ERROR_NONE;
 SDHC_SPIWRITEBLOCKDATA_DONE:
 	Ctrl->TempData[0] = 0xfd;
 	SPI_BlockTransfer(Ctrl->SpiID, Ctrl->TempData, Ctrl->TempData, 1);
 
-	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * CORE_TICK_1MS * Ctrl->DataBuf.MaxLen;
+	OpEndTick = GetSysTick() + Ctrl->SDHCWriteBlockTo * Ctrl->DataBuf.MaxLen;
 	DoneFlag = 0;
 	while( (GetSysTick() < OpEndTick) && !DoneFlag )
 	{
@@ -522,7 +543,6 @@ SDHC_SPIWRITEBLOCKDATA_DONE:
 			}
 		}
 	}
-
 	SDHC_SpiCS(Ctrl, 0);
 
 	return Result;
@@ -537,8 +557,7 @@ static int32_t SDHC_SpiReadBlockData(SDHC_SPICtrlStruct *Ctrl)
 	uint8_t *pBuf;
 	Ctrl->SPIError = 0;
 	Ctrl->SDHCError = 0;
-
-	OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo * CORE_TICK_1MS;
+	OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo;
 	while( (Ctrl->DataBuf.Pos < Ctrl->DataBuf.MaxLen) && (GetSysTick() < OpEndTick) )
 	{
 
@@ -577,7 +596,7 @@ READ_REST_DATA:
 			goto SDHC_SPIREADBLOCKDATA_DONE;
 		}
 		Ctrl->DataBuf.Pos++;
-		OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo * CORE_TICK_1MS;
+		OpEndTick = GetSysTick() + Ctrl->SDHCReadBlockTo;
 	}
 	Result = ERROR_NONE;
 
@@ -653,7 +672,6 @@ void SDHC_SpiReadCardConfig(void *pSDHC)
 	SD_CardInfo *pCardInfo = &Ctrl->Info;
 	uint64_t Temp;
 	uint8_t flag_SDHC = (Ctrl->OCR & 0x40000000) >> 30;
-
 	if (Ctrl->Info.CardCapacity) return;
 
 	if (SDHC_SpiCmd(Ctrl, CMD9, 0, 0))
@@ -882,6 +900,7 @@ SDHC_SPIREADBLOCKS_START:
 	if (Ctrl->DataBuf.Pos != Ctrl->DataBuf.MaxLen)
 	{
 		Retry++;
+		DBG("%d", Retry);
 		if (Retry > 3)
 		{
 			Ctrl->SDHCError = 1;
@@ -891,6 +910,7 @@ SDHC_SPIREADBLOCKS_START:
 	}
 	return;
 SDHC_SPIREADBLOCKS_ERROR:
+	DBG("!");
 	Ctrl->IsInitDone = 0;
 	Ctrl->SDHCError = 1;
 	return;
@@ -901,8 +921,8 @@ void *SDHC_SpiCreate(uint8_t SpiID, uint8_t CSPin)
 	SDHC_SPICtrlStruct *Ctrl = zalloc(sizeof(SDHC_SPICtrlStruct));
 	Ctrl->CSPin = CSPin;
 	Ctrl->SpiID = SpiID;
-	Ctrl->SDHCReadBlockTo = 5 * CORE_TICK_1MS;
-	Ctrl->SDHCWriteBlockTo = 25 * CORE_TICK_1MS;
+	Ctrl->SDHCReadBlockTo = 50 * CORE_TICK_1MS;
+	Ctrl->SDHCWriteBlockTo = 250 * CORE_TICK_1MS;
 //	Ctrl->IsPrintData = 1;
 	return Ctrl;
 }
@@ -922,6 +942,7 @@ uint8_t SDHC_IsReady(void *pSDHC)
 	}
 	else
 	{
+		DBG("!");
 		return 0;
 	}
 }

bsp/usb/include/usb_msc.h

@@ -107,9 +107,11 @@ typedef struct
 	MSC_BOT_CSWTypeDef  CSW;
 	Buffer_Struct BotDataBuffer;
 	SCSI_SenseTypeDef Sense;
+	uint64_t TestTime;
 	HANDLE pSCSIUserFunList;
 	Timer_t *ReadTimer;
 	void *pUserData;
+	uint32_t ReadTimeout;
 	uint32_t XferDoneLen;
 	uint32_t LastXferLen;
 	uint32_t XferTotalLen;//实际上需要发送的总数据量，有可能和CBW要求的不一样

bsp/usb/src/core_usb_class_msc_scsi.c

@@ -93,11 +93,9 @@ static void prvUSB_SendCSW(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct *
 static int32_t prvUSB_MSCTimeout(void *pData, void *pParam)
 {
 	MSC_SCSICtrlStruct *pMSC = (void *)pParam;
-	DBG("!");
-	pMSC->CSWStatus = USB_MSC_CSW_CMD_FAILED;
-	USB_StackStopDeviceTx(pMSC->USB_ID, pMSC->ToHostEpIndex, 0);
-	USB_StackSetEpStatus(pMSC->USB_ID, pMSC->ToHostEpIndex, 1, USB_EP_STATE_STALL);
-	prvUSB_SendCSW(NULL, pMSC);
+	DBG("bot timeout!, reboot usb");
+	Core_USBDefaultDeviceStart(pMSC->USB_ID);
+
 }
 
 static void prvUSB_SendBotData(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct *pMSC)
@@ -169,6 +167,7 @@ void USB_MSCHandle(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct *pMSC)
 					goto ERROR_OUT;
 				}
 				pMSC->XferDoneLen = 0;
+//				pMSC->TestTime = GetSysTickUS();
 				prvUSB_SCSIHandleCmd(pEpData, pMSC);
 				if (!pMSC->CBW.dDataLength)
 				{
@@ -311,6 +310,7 @@ static void prvUSB_SCSIHandleToHostData(USB_EndpointDataStruct *pEpData, MSC_SCS
 	pMSC->XferDoneLen += pMSC->LastXferLen;
 	if (pMSC->XferDoneLen >= pMSC->XferTotalLen)
 	{
+//		DBG("%llu", GetSysTickUS() - pMSC->TestTime);
 		prvUSB_SendCSW(pEpData, pMSC);
 		return;
 	}
@@ -650,7 +650,6 @@ static int32_t prvSCSI_Read(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct
 		BlockNums = BytesGetBe32(&pMSC->CBW.CB[10]);
 		break;
 	}
-
     /* case 10 : Ho <> Di */
     if ((pMSC->CBW.bmFlags & 0x80U) != 0x80U)
     {
@@ -692,12 +691,15 @@ static int32_t prvSCSI_Read(USB_EndpointDataStruct *pEpData, MSC_SCSICtrlStruct
 		DBG("!");
 		return -1;
 	}
-
 	pMSC->LastXferLen = TxLen;
 	USB_StackTxEpData(pEpData->USB_ID, pMSC->ToHostEpIndex, TxData, TxLen, TxLen, 0);
 	pMSC->BotState = USB_MSC_BOT_STATE_DATA_IN_TO_HOST;
 	pUserFun->ReadNext(pMSC->CBW.bLUN, pMSC->pUserData);
-	Timer_StartMS(pMSC->ReadTimer, 1000, 0);
+	if (pMSC->ReadTimeout)
+	{
+		Timer_StartMS(pMSC->ReadTimer, pMSC->ReadTimeout, 0);
+	}
+
     return 0;
 }
 

xmake.lua

@@ -145,6 +145,7 @@ target("lvgl")
     --add_includedirs("bsp/common",{public = true})
 	add_includedirs("bsp/common/include",{public = true})
     add_includedirs("bsp/cmsis/include",{public = true})
+    add_includedirs("bsp/audio/include",{public = true})
     add_includedirs(luatos.."luat/packages/lfs")
     add_includedirs(luatos.."lua/include",{public = true})
     add_includedirs(luatos.."luat/include",{public = true})
@@ -316,8 +317,12 @@ if with_luatos then
 
     add_files(luatos.."components/camera/*.c")
     add_includedirs(luatos.."components/camera")
+
     add_files(luatos.."components/soft_keyboard/*.c")
     add_includedirs(luatos.."components/soft_keyboard")
+
+    add_files(luatos.."components/multimedia/*.c")
+    add_includedirs(luatos.."components/multimedia")
 else
 
     add_files("Third_Party/vsprintf/*.c",{public = true})