add:io序列操作和64bit的系统tick，精度为48M/1秒

application/include/luat_conf_bsp.h

@@ -163,7 +163,7 @@ extern unsigned int gLVFlashTime;
 
 #define LV_USE_PERF_MONITOR     1
 #define __LVGL_SLEEP_ENABLE__
-
+#define __LUATOS_TICK_64BIT__
 #define LUAT_USE_MEMORY_OPTIMIZATION_CODE_MMAP
 
 #ifndef __DEBUG__

application/src/luat_base_air105.c

@@ -202,6 +202,7 @@ static const luaL_Reg loadedlibs[] = {
   {"usbapp", luaopen_usbapp},
   {"audio", luaopen_multimedia_audio},
   {"decode", luaopen_multimedia_decode},
+  {"ioqueue", luaopen_io_queue},
   {NULL, NULL}
 };
 

application/src/luat_io_queue_air105.c

@@ -0,0 +1,266 @@
+/*
+ * 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_lib_io_queue.h"
+#include "app_interface.h"
+
+#define LUAT_LOG_TAG "hwtimer"
+#include "luat_log.h"
+
+static int32_t luat_io_queue_done_cb(void *pData, void *pParam)
+{
+	rtos_msg_t msg;
+	msg.handler = l_io_queue_done_handler;
+	msg.ptr = pParam;
+	luat_msgbus_put(&msg, 1);
+	return 0;
+}
+
+static int32_t __FUNC_IN_RAM__ luat_io_queue_dummy_cb(void *pData, void *pParam)
+{
+	return 0;
+}
+
+static int32_t __FUNC_IN_RAM__ luat_io_queue_capture_cb(void *pData, void *pParam)
+{
+	rtos_msg_t msg;
+	uint64_t tick = GetSysTick();
+	msg.handler = l_io_queue_capture_handler;
+	msg.ptr = ((uint32_t)pData << 8) | GPIO_Input(pData);
+	msg.arg1 = (tick >> 32);
+	msg.arg2 = tick & 0x0ffffffff;
+	luat_msgbus_put(&msg, 1);
+	return 0;
+}
+
+void luat_io_queue_init(uint8_t hw_timer_id, uint32_t cmd_cnt, uint32_t repeat_cnt)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	HWTimer_InitOperationQueue(hw_timer_id, cmd_cnt, repeat_cnt, luat_io_queue_done_cb, hw_timer_id);
+}
+
+void luat_io_queue_start(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	HWTimer_StartOperationQueue(hw_timer_id);
+}
+
+void luat_io_queue_stop(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	HWTimer_Stop(hw_timer_id);
+}
+
+
+void luat_io_queue_clear(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	HWTimer_ClearOperationQueue(hw_timer_id);
+}
+
+void luat_io_queue_release(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	HWTimer_FreeOperationQueue(hw_timer_id);
+}
+
+void luat_io_queue_set_delay(uint8_t hw_timer_id, uint16_t time, uint8_t sub_tick, uint8_t is_continue)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = NULL;
+	cmd.Operation = is_continue?OP_QUEUE_CMD_CONTINUE_DELAY:OP_QUEUE_CMD_ONE_TIME_DELAY;
+	cmd.PinOrDelay = sub_tick;
+	cmd.uArg.Time = time;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_repeat_delay(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = NULL;
+	cmd.Operation = OP_QUEUE_CMD_REPEAT_DELAY;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_add_io_config(uint8_t hw_timer_id, uint8_t pin, uint8_t is_input, uint8_t pull_mode, uint8_t level)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = NULL;
+	cmd.Operation = is_input?OP_QUEUE_CMD_SET_GPIO_DIR_IN:OP_QUEUE_CMD_SET_GPIO_DIR_OUT;
+	cmd.PinOrDelay = pin;
+	cmd.uArg.IOArg.Level = level;
+	cmd.uArg.IOArg.PullMode = pull_mode;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+
+void luat_io_queue_add_io_out(uint8_t hw_timer_id, uint8_t pin, uint8_t level)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = NULL;
+	cmd.Operation = OP_QUEUE_CMD_GPIO_OUT;
+	cmd.PinOrDelay = pin;
+	cmd.uArg.IOArg.Level = level;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_add_io_in(uint8_t hw_timer_id, uint8_t pin, CBFuncEx_t CB, void *user_data)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = CB;
+	cmd.uParam.pParam = user_data;
+	cmd.Operation = CB?OP_QUEUE_CMD_GPIO_IN_CB:OP_QUEUE_CMD_GPIO_IN;
+	cmd.PinOrDelay = pin;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_capture_set(uint8_t hw_timer_id, uint32_t max_tick, uint8_t pin, uint8_t pull_mode, uint8_t irq_mode)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = NULL;
+	cmd.Operation = OP_QUEUE_CMD_CAPTURE_SET;
+	cmd.PinOrDelay = pin;
+	cmd.uParam.MaxCnt = max_tick;
+	cmd.uArg.ExitArg.ExtiMode = irq_mode;
+	cmd.uArg.ExitArg.PullMode = pull_mode;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_capture(uint8_t hw_timer_id, CBFuncEx_t CB, void *user_data)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = CB;
+	cmd.PinOrDelay = 0xff;
+	cmd.uParam.pParam = user_data;
+	cmd.Operation = CB?OP_QUEUE_CMD_CAPTURE_CB:OP_QUEUE_CMD_CAPTURE;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_capture_end(uint8_t hw_timer_id, uint8_t pin)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.CB = NULL;
+	cmd.Operation = OP_QUEUE_CMD_CAPTURE_END;
+	cmd.PinOrDelay = pin;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+void luat_io_queue_end(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return;
+	OPQueue_CmdStruct cmd;
+	cmd.Operation = OP_QUEUE_CMD_END;
+	HWTimer_AddOperation(hw_timer_id, &cmd);
+}
+
+uint8_t luat_io_queue_check_done(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return 0;
+	return HWTimer_CheckOperationQueueDone(hw_timer_id);
+
+}
+
+int luat_io_queue_get_size(uint8_t hw_timer_id)
+{
+	if (hw_timer_id >= HW_TIMER_MAX) return 0;
+	return HWTimer_GetOperationQueueLen(hw_timer_id);
+
+}
+
+void luat_io_queue_get_data(uint8_t hw_timer_id, uint8_t *input_buff, uint32_t *input_cnt, uint8_t *capture_buff, uint32_t *capture_cnt)
+{
+	if ((hw_timer_id >= HW_TIMER_MAX) || !HWTimer_GetOperationQueue(hw_timer_id))
+	{
+		*input_cnt = 0;
+		*capture_cnt = 0;
+	}
+	else
+	{
+		OPQueue_CmdStruct *Cmd = HWTimer_GetOperationQueue(hw_timer_id);
+		uint32_t len = HWTimer_GetOperationQueueLen(hw_timer_id);
+		uint32_t input_pos = 0;
+		uint32_t capture_pos = 0;
+		uint32_t i;
+		for(i = 0; i < len; i++)
+		{
+			switch(Cmd[i].Operation)
+			{
+			case OP_QUEUE_CMD_GPIO_IN:
+			case OP_QUEUE_CMD_GPIO_IN_CB:
+				input_buff[input_pos * 2] = Cmd[i].PinOrDelay;
+				input_buff[input_pos * 2 + 1] = Cmd[i].uArg.IOArg.Level;
+				input_pos++;
+				break;
+			case OP_QUEUE_CMD_CAPTURE:
+			case OP_QUEUE_CMD_CAPTURE_CB:
+				if (Cmd[i].PinOrDelay >= GPIO_NONE)
+				{
+					len = 0;
+					break;
+				}
+
+				capture_buff[capture_pos * 6] = Cmd[i].PinOrDelay;
+				capture_buff[capture_pos * 6 + 1] = Cmd[i].uArg.IOArg.Level;
+				BytesPutLe32(&capture_buff[capture_pos * 6 + 2], Cmd[i].uParam.MaxCnt);
+				capture_pos++;
+				break;
+			}
+		}
+		*input_cnt = input_pos;
+		*capture_cnt = capture_pos;
+	}
+	return ;
+
+}
+
+void luat_io_queue_capture_start_with_sys_tick(uint8_t pin, uint8_t pull_mode, uint8_t irq_mode)
+{
+	GPIO_PullConfig(pin, pull_mode, (pull_mode > 1)?0:1);
+	GPIO_Config(pin, 1, 0);
+	GPIO_ExtiSetCB(pin, luat_io_queue_capture_cb, NULL);
+	switch(irq_mode)
+	{
+	case OP_QUEUE_CMD_IO_EXTI_BOTH:
+		GPIO_ExtiConfig(pin, 0, 1, 1);
+		break;
+	case OP_QUEUE_CMD_IO_EXTI_UP:
+		GPIO_ExtiConfig(pin, 0, 1, 0);
+		break;
+	case OP_QUEUE_CMD_IO_EXTI_DOWN:
+		GPIO_ExtiConfig(pin, 0, 0, 1);
+		break;
+	}
+}
+
+void luat_io_queue_capture_end_with_sys_tick(uint8_t pin)
+{
+	GPIO_ExtiSetCB(pin, NULL, NULL);
+	GPIO_ExtiConfig(pin, 0, 0, 0);
+}

bsp/air105/hal/core_debug.c

@@ -365,22 +365,23 @@ void DBG_Printf(const char* format, ...)
 {
 	char *buf = NULL;
 	char isr_buf[256];
+	int len;
 	va_list ap;
 	if (!prvDBGCtrl.AppMode) return;
 	va_start(ap, format);
 	if (OS_CheckInIrq())
 	{
 		buf = isr_buf;
-		vsnprintf_(buf, 255, format, ap);
+		len = vsnprintf_(buf, 255, format, ap);
 	}
 	else
 	{
 		buf = OS_Zalloc(1024);
-		vsnprintf_(buf, 1023, format, ap);
+		len = vsnprintf_(buf, 1023, format, ap);
 	}
 	va_end(ap);
 
-    prvDBGCtrl.TxFun( buf, strlen(buf));
+    prvDBGCtrl.TxFun( buf, len);
 	if (!OS_CheckInIrq())
 	{
 		OS_Free(buf);

bsp/air105/hal/core_hwtimer.c

@@ -25,7 +25,6 @@ typedef struct
 //	const I2C_TypeDef *RegBase;
 	const int IrqLine;
 	OPQueue_CmdStruct *Cmd;
-	Buffer_Struct InDataBuf;
 	CBFuncEx_t CmdDoneCB;
 	void *pCmdDoneParam;
 	uint32_t TotalCount;
@@ -33,7 +32,6 @@ typedef struct
 	uint32_t CurCount;
 	uint32_t RepeatCnt;
 	uint32_t CmdQueuePos;
-	uint32_t CapturePin;
 	uint8_t IsQueueRunning;
 	uint8_t ContinueDelay;
 }HWTimer_CtrlStruct;
@@ -90,9 +88,9 @@ static HWTimer_CtrlStruct prvHWTimer[HW_TIMER_MAX] = {
 };
 
 static void prvHWTimer_IrqHandlerOperationQueue( int32_t Line, void *pData);
-static void prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HWTimer_CtrlStruct *HWTimer);
+static void prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HWTimer_CtrlStruct *HWTimer, uint8_t Pin);
 
-static int32_t prvHWTimer_DummyCB(void *pData, void *pParam)
+static int32_t __FUNC_IN_RAM__ prvHWTimer_DummyCB(void *pData, void *pParam)
 {
 	return 0;
 }
@@ -107,37 +105,36 @@ static void prvHWTimer_IrqHandlerEndOperationQueue( int32_t Line, void *pData)
 static int32_t __FUNC_IN_RAM__ prvHWTimer_OperationQueuExti(void *pData, void *pParam)
 {
 	uint32_t HWTimerID = (uint32_t)pParam;
-	uint32_t pin = (uint32_t)pData;
-//	DBG("%x,%x", pin, prvHWTimer[HWTimerID].CapturePin);
-	if (pin == prvHWTimer[HWTimerID].CapturePin)
-	{
-		prvHWTimer_StartOperationQueue(HWTimerID, &prvHWTimer[HWTimerID]);
-	}
+	prvHWTimer_StartOperationQueue(HWTimerID, &prvHWTimer[HWTimerID], (uint32_t)pData);
 	return 0;
 }
 
 
-static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HWTimer_CtrlStruct *HWTimer)
+static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HWTimer_CtrlStruct *HWTimer, uint8_t Pin)
 {
 	volatile uint32_t Period;
 	while(HWTimer->IsQueueRunning)
 	{
 
-//		DBG("%u, %u, %u, %u, %u, %u, %u, %u, %u, %x, %x", HWTimer->TotalRepeat, HWTimer->RepeatCnt,
+//		DBG("%u,%u,%u,%u,%u,%u,%u,%u,%u,%x", HWTimer->TotalRepeat, HWTimer->RepeatCnt,
 //				HWTimer->TotalCount, HWTimer->CurCount, HWTimer->Cmd[HWTimer->CurCount].Operation,
-//				HWTimer->Cmd[HWTimer->CurCount].Arg1, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level,
+//				HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level,
 //				HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode, HWTimer->Cmd[HWTimer->CurCount].uArg.Time,
-//				HWTimer->Cmd[HWTimer->CurCount].CB, HWTimer->Cmd[HWTimer->CurCount].pParam);
+//				HWTimer->Cmd[HWTimer->CurCount].CB);
 
 		switch(HWTimer->Cmd[HWTimer->CurCount].Operation)
 		{
 		case OP_QUEUE_CMD_GPIO_OUT:
-			GPIO_Output(HWTimer->Cmd[HWTimer->CurCount].Arg1, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level);
+			GPIO_Output(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level);
+			HWTimer->CurCount++;
+			break;
+		case OP_QUEUE_CMD_GPIO_IN_CB:
+			HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level = GPIO_Input(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay);
+			HWTimer->Cmd[HWTimer->CurCount].CB(HWTimerID, &HWTimer->Cmd[HWTimer->CurCount]);
 			HWTimer->CurCount++;
 			break;
 		case OP_QUEUE_CMD_GPIO_IN:
-			HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level = GPIO_Input(HWTimer->Cmd[HWTimer->CurCount].Arg1);
-			BSP_SetBit(HWTimer->InDataBuf.Data, HWTimer->InDataBuf.Pos, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level);
+			HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level = GPIO_Input(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay);
 			HWTimer->CurCount++;
 			break;
 		case OP_QUEUE_CMD_ONE_TIME_DELAY:
@@ -149,6 +146,24 @@ static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HW
 			return;
 			break;
 		case OP_QUEUE_CMD_CAPTURE:
+			HWTimer->Cmd[HWTimer->CurCount].PinOrDelay = Pin;
+			if (!TIMM0->TIM[HWTimerID].ControlReg)
+			{
+				HWTimer->Cmd[HWTimer->CurCount + 1].Operation = OP_QUEUE_CMD_CAPTURE_END;
+			}
+			else
+			{
+				HWTimer->Cmd[HWTimer->CurCount].uParam.MaxCnt = TIMM0->TIM[HWTimerID].LoadCount - TIMM0->TIM[HWTimerID].CurrentValue;
+				HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level = GPIO_Input(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay);
+			}
+			HWTimer->CurCount++;
+			if (OP_QUEUE_CMD_CAPTURE_END != HWTimer->Cmd[HWTimer->CurCount].Operation)
+			{
+				return;
+			}
+			break;
+		case OP_QUEUE_CMD_CAPTURE_CB:
+			HWTimer->Cmd[HWTimer->CurCount].PinOrDelay = Pin;
 			if (!TIMM0->TIM[HWTimerID].ControlReg)
 			{
 				HWTimer->Cmd[HWTimer->CurCount + 1].Operation = OP_QUEUE_CMD_CAPTURE_END;
@@ -156,10 +171,11 @@ static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HW
 			else
 			{
 				HWTimer->Cmd[HWTimer->CurCount].uParam.MaxCnt = TIMM0->TIM[HWTimerID].LoadCount - TIMM0->TIM[HWTimerID].CurrentValue;
-				HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level = GPIO_Input(HWTimer->Cmd[HWTimer->CurCount].Arg1);
+				HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level = GPIO_Input(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay);
 			}
+			HWTimer->Cmd[HWTimer->CurCount].CB(HWTimerID, &HWTimer->Cmd[HWTimer->CurCount]);
 			HWTimer->CurCount++;
-			if (OP_QUEUE_CMD_CAPTURE_END != HWTimer->Cmd[HWTimer->CurCount + 1].Operation)
+			if (OP_QUEUE_CMD_CAPTURE_END != HWTimer->Cmd[HWTimer->CurCount].Operation)
 			{
 				return;
 			}
@@ -170,13 +186,13 @@ static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HW
 			break;
 
 		case OP_QUEUE_CMD_SET_GPIO_DIR_OUT:
-			GPIO_Config(HWTimer->Cmd[HWTimer->CurCount].Arg1, 0, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level);
-			GPIO_PullConfig(HWTimer->Cmd[HWTimer->CurCount].Arg1, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode, (HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode > 1)?0:1);
+			GPIO_Config(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 0, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.Level);
+			GPIO_PullConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode, (HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode > 1)?0:1);
 			HWTimer->CurCount++;
 			break;
 		case OP_QUEUE_CMD_SET_GPIO_DIR_IN:
-			GPIO_PullConfig(HWTimer->Cmd[HWTimer->CurCount].Arg1, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode, (HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode > 1)?0:1);
-			GPIO_Config(HWTimer->Cmd[HWTimer->CurCount].Arg1, 1, 0);
+			GPIO_PullConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode, (HWTimer->Cmd[HWTimer->CurCount].uArg.IOArg.PullMode > 1)?0:1);
+			GPIO_Config(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 1, 0);
 			HWTimer->CurCount++;
 			break;
 		case OP_QUEUE_CMD_CB:
@@ -184,24 +200,23 @@ static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HW
 			HWTimer->CurCount++;
 			break;
 		case OP_QUEUE_CMD_CAPTURE_SET:
-			GPIO_PullConfig(HWTimer->Cmd[HWTimer->CurCount].Arg1, HWTimer->Cmd[HWTimer->CurCount].uArg.ExitArg.PullMode, (HWTimer->Cmd[HWTimer->CurCount].uArg.ExitArg.PullMode > 1)?0:1);
-			GPIO_Config(HWTimer->Cmd[HWTimer->CurCount].Arg1, 1, 0);
-			HWTimer->CapturePin = HWTimer->Cmd[HWTimer->CurCount].Arg1;
+			GPIO_PullConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, HWTimer->Cmd[HWTimer->CurCount].uArg.ExitArg.PullMode, (HWTimer->Cmd[HWTimer->CurCount].uArg.ExitArg.PullMode > 1)?0:1);
+			GPIO_Config(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 1, 0);
 			TIMM0->TIM[HWTimerID].ControlReg = 0;
 			TIMM0->TIM[HWTimerID].LoadCount = HWTimer->Cmd[HWTimer->CurCount].uParam.MaxCnt;
 			TIMM0->TIM[HWTimerID].ControlReg = TIMER_CONTROL_REG_TIMER_ENABLE|TIMER_CONTROL_REG_TIMER_MODE;
-			GPIO_ExtiSetCB(HWTimer->Cmd[HWTimer->CurCount].Arg1, prvHWTimer_OperationQueuExti, HWTimerID);
+			GPIO_ExtiSetCB(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, prvHWTimer_OperationQueuExti, HWTimerID);
 			prvHWTimer[HWTimerID].ContinueDelay = 0;
 			switch(HWTimer->Cmd[HWTimer->CurCount].uArg.ExitArg.ExtiMode)
 			{
 			case OP_QUEUE_CMD_IO_EXTI_BOTH:
-				GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].Arg1, 0, 1, 1);
+				GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 0, 1, 1);
 				break;
 			case OP_QUEUE_CMD_IO_EXTI_UP:
-				GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].Arg1, 0, 1, 0);
+				GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 0, 1, 0);
 				break;
 			case OP_QUEUE_CMD_IO_EXTI_DOWN:
-				GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].Arg1, 0, 0, 1);
+				GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 0, 0, 1);
 				break;
 			}
 
@@ -209,14 +224,15 @@ static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HW
 			return;
 			break;
 		case OP_QUEUE_CMD_CAPTURE_END:
-			GPIO_ExtiSetCB(HWTimer->Cmd[HWTimer->CurCount].Arg1, NULL, NULL);
+			GPIO_ExtiSetCB(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, NULL, NULL);
+			GPIO_ExtiConfig(HWTimer->Cmd[HWTimer->CurCount].PinOrDelay, 0, 0, 0);
 			TIMM0->TIM[HWTimerID].ControlReg = 0;
 			HWTimer->CurCount++;
 			break;
 		case OP_QUEUE_CMD_END:
 			HWTimer->CurCount = 0;
 			HWTimer->RepeatCnt++;
-			if (HWTimer->RepeatCnt >= HWTimer->TotalRepeat)
+			if (HWTimer->TotalRepeat && (HWTimer->RepeatCnt >= HWTimer->TotalRepeat))
 			{
 				TIMM0->TIM[HWTimerID].ControlReg = 0;
 				TIMM0->TIM[HWTimerID].LoadCount = 24;
@@ -237,7 +253,7 @@ static void __FUNC_IN_RAM__ prvHWTimer_StartOperationQueue(uint8_t HWTimerID, HW
 START_HWTIMER:
 	TIMM0->TIM[HWTimerID].ControlReg = 0;
 	Period = HWTimer->Cmd[HWTimer->CurCount].uArg.Time;
-	Period = Period * SYS_TIMER_1US + HWTimer->Cmd[HWTimer->CurCount].Arg1;
+	Period = Period * SYS_TIMER_1US + HWTimer->Cmd[HWTimer->CurCount].PinOrDelay;
 	TIMM0->TIM[HWTimerID].LoadCount = Period - 1;
 	TIMM0->TIM[HWTimerID].ControlReg = TIMER_CONTROL_REG_TIMER_ENABLE|TIMER_CONTROL_REG_TIMER_MODE;
 	HWTimer->CurCount++;
@@ -256,7 +272,7 @@ static void __FUNC_IN_RAM__ prvHWTimer_IrqHandlerOperationQueue( int32_t Line, v
 	{
 		TIMM0->TIM[HWTimerID].ControlReg = 0;
 	}
-	prvHWTimer_StartOperationQueue(HWTimerID, &prvHWTimer[HWTimerID]);
+	prvHWTimer_StartOperationQueue(HWTimerID, &prvHWTimer[HWTimerID], GPIO_NONE);
 }
 
 void HWTimer_StartPWM(uint8_t HWTimerID, uint32_t HighCnt, uint32_t LowCnt, uint8_t IsOnePulse)
@@ -336,7 +352,7 @@ void HWTimer_Stop(uint8_t HWTimerID)
 	PM_SetHardwareRunFlag(PM_HW_TIMER_0 + HWTimerID, 0);
 }
 
-void HWTimer_InitOperationQueue(uint8_t HWTimerID, uint32_t nCount, uint32_t Repeat, uint32_t InputByte, CBFuncEx_t CmdDoneCB, void *pCmdDoneParam)
+void HWTimer_InitOperationQueue(uint8_t HWTimerID, uint32_t nCount, uint32_t Repeat, CBFuncEx_t CmdDoneCB, void *pCmdDoneParam)
 {
 	if (prvHWTimer[HWTimerID].IsQueueRunning)
 	{
@@ -345,14 +361,6 @@ void HWTimer_InitOperationQueue(uint8_t HWTimerID, uint32_t nCount, uint32_t Rep
 	}
 	prvHWTimer[HWTimerID].TotalCount = nCount;
 	prvHWTimer[HWTimerID].TotalRepeat = Repeat;
-	if (InputByte)
-	{
-		OS_ReInitBuffer(&prvHWTimer[HWTimerID].InDataBuf, InputByte);
-	}
-	else
-	{
-		OS_DeInitBuffer(&prvHWTimer[HWTimerID].InDataBuf);
-	}
 	if (prvHWTimer[HWTimerID].Cmd)
 	{
 		OS_Free(prvHWTimer[HWTimerID].Cmd);
@@ -373,6 +381,7 @@ void HWTimer_InitOperationQueue(uint8_t HWTimerID, uint32_t nCount, uint32_t Rep
 
 void HWTimer_AddOperation(uint8_t HWTimerID, OPQueue_CmdStruct *pCmd)
 {
+
 	if (prvHWTimer[HWTimerID].TotalCount > prvHWTimer[HWTimerID].CmdQueuePos)
 	{
 		memcpy(&prvHWTimer[HWTimerID].Cmd[prvHWTimer[HWTimerID].CmdQueuePos], pCmd, sizeof(OPQueue_CmdStruct));
@@ -385,11 +394,6 @@ static void HWTimer_ResetOperationQueue(uint8_t HWTimerID)
 {
 	prvHWTimer[HWTimerID].CurCount = 0;
 	prvHWTimer[HWTimerID].RepeatCnt = 0;
-	prvHWTimer[HWTimerID].InDataBuf.Pos = 0;
-	if (prvHWTimer[HWTimerID].InDataBuf.MaxLen)
-	{
-		memset(prvHWTimer[HWTimerID].InDataBuf.Data, 0, prvHWTimer[HWTimerID].InDataBuf.MaxLen);
-	}
 }
 
 
@@ -410,7 +414,7 @@ void HWTimer_StartOperationQueue(uint8_t HWTimerID)
 	prvHWTimer[HWTimerID].Cmd[prvHWTimer[HWTimerID].CmdQueuePos].Operation = OP_QUEUE_CMD_END;
 	HWTimer_ResetOperationQueue(HWTimerID);
 	prvHWTimer[HWTimerID].IsQueueRunning = 1;
-	prvHWTimer_StartOperationQueue(HWTimerID, &prvHWTimer[HWTimerID]);
+	prvHWTimer_StartOperationQueue(HWTimerID, &prvHWTimer[HWTimerID], GPIO_NONE);
 	ISR_OnOff(prvHWTimer[HWTimerID].IrqLine, 1);
 	PM_SetHardwareRunFlag(PM_HW_TIMER_0 + HWTimerID, 1);
 }
@@ -424,7 +428,6 @@ void HWTimer_ClearOperationQueue(uint8_t HWTimerID)
 
 void HWTimer_FreeOperationQueue(uint8_t HWTimerID)
 {
-	OS_DeInitBuffer(&prvHWTimer[HWTimerID].InDataBuf);
 	OS_Free(prvHWTimer[HWTimerID].Cmd);
 	prvHWTimer[HWTimerID].Cmd = NULL;
 	prvHWTimer[HWTimerID].CmdDoneCB = prvHWTimer_DummyCB;
@@ -444,12 +447,6 @@ uint8_t HWTimer_CheckOperationQueueDone(uint8_t HWTimerID)
 	return !prvHWTimer[HWTimerID].IsQueueRunning;
 }
 
-int HWTimer_GetOperationQueueInputResult(uint8_t HWTimerID, uint8_t *Value)
-{
-	memcpy(Value, prvHWTimer[HWTimerID].InDataBuf.Data, prvHWTimer[HWTimerID].InDataBuf.MaxLen);
-	return prvHWTimer[HWTimerID].InDataBuf.MaxLen;
-}
-
 uint32_t HWTimer_GetOperationQueueCaptureResult(uint8_t HWTimerID, CBFuncEx_t CB, void *pParam)
 {
 	uint32_t i = 0;
@@ -465,3 +462,14 @@ uint32_t HWTimer_GetOperationQueueCaptureResult(uint8_t HWTimerID, CBFuncEx_t CB
 	}
 	return Cnt;
 }
+
+uint32_t HWTimer_GetOperationQueueLen(uint8_t HWTimerID)
+{
+	if (!prvHWTimer[HWTimerID].Cmd) return 0;
+	return prvHWTimer[HWTimerID].CmdQueuePos;
+}
+
+OPQueue_CmdStruct *HWTimer_GetOperationQueue(uint8_t HWTimerID)
+{
+	return 	prvHWTimer[HWTimerID].Cmd;
+}

bsp/air105/include/core_hwtimer.h

@@ -55,12 +55,11 @@ void HWTimer_Stop(uint8_t HWTimerID);
  * @param HWTimerID 硬件定时器ID
  * @param nCount 操作步骤总数
  * @param Repeat 重复次数
- * @param InputByte IO读取的次数，注意每8次1个byte，不足8个也算1个byte
  * @param CmdDoneCB 全部完成后回调函数
  * @param pCmdDoneParam 回调函数的用户参数
  *
  */
-void HWTimer_InitOperationQueue(uint8_t HWTimerID, uint32_t nCount, uint32_t Repeat, uint32_t InputByte, CBFuncEx_t CmdDoneCB, void *pCmdDoneParam);
+void HWTimer_InitOperationQueue(uint8_t HWTimerID, uint32_t nCount, uint32_t Repeat, CBFuncEx_t CmdDoneCB, void *pCmdDoneParam);
 /**
  * @brief 加入IO操作序列
  *
@@ -99,14 +98,6 @@ void HWTimer_AddEndCmdInOperationQueue(uint8_t HWTimerID);
  * @return =0未完成，其他已完成
  */
 uint8_t HWTimer_CheckOperationQueueDone(uint8_t HWTimerID);
-/**
- * @brief 获取IO操作序列中IO读取的值
- *
- * @param HWTimerID 硬件定时器ID
- * @param Value copy的空间
- * @return 获取的byte数，和init时InputByte一致
- */
-int HWTimer_GetOperationQueueInputResult(uint8_t HWTimerID, uint8_t *Value);
 
 /**
  * @brief 获取IO操作序列中捕获状态
@@ -117,4 +108,8 @@ int HWTimer_GetOperationQueueInputResult(uint8_t HWTimerID, uint8_t *Value);
  * @return 捕获次数
  */
 uint32_t HWTimer_GetOperationQueueCaptureResult(uint8_t HWTimerID, CBFuncEx_t CB, void *pParam);
+
+uint32_t HWTimer_GetOperationQueueLen(uint8_t HWTimerID);
+
+OPQueue_CmdStruct *HWTimer_GetOperationQueue(uint8_t HWTimerID);
 #endif

bsp/air105/test/test_dht11.c

@@ -21,6 +21,11 @@
 
 #include "user.h"
 
+
+enum
+{
+	EV_USER_DHT11_TEST_DONE = USER_EVENT_ID_START + 1,
+};
 typedef struct
 {
 	uint32_t LastValue;
@@ -42,7 +47,6 @@ static int32_t DHT11_ReadBit(void *pData, void *pParam)
 //		DBG("%u", Cmd->uParam.MaxCnt);
 		break;
 	case 1:
-//		DBG("%u", Cmd->uParam.MaxCnt);
 		DHT11->LastValue = Cmd->uParam.MaxCnt;
 		DHT11->BitPos = 7;
 		DHT11->BytePos = 0;
@@ -51,7 +55,7 @@ static int32_t DHT11_ReadBit(void *pData, void *pParam)
 	default:
 		diff = (Cmd->uParam.MaxCnt - DHT11->LastValue);
 		DHT11->LastValue = Cmd->uParam.MaxCnt;
-//		DBG("%u,%u,%u,%u", DHT11->BytePos, DHT11->BitPos, diff, Cmd->uParam.MaxCnt);
+//		DBG("%u,%u,%u,%u,%u", DHT11->BytePos, DHT11->BitPos, diff, Cmd->uParam.MaxCnt,Cmd->PinOrDelay);
 		if (diff > (100 * SYS_TIMER_1US))
 		{
 			DHT11->Data[DHT11->BytePos] |= (1 << DHT11->BitPos);
@@ -69,42 +73,60 @@ static int32_t DHT11_ReadBit(void *pData, void *pParam)
 	}
 	DHT11->Pos++;
 }
+static int32_t prvDHT11_TestCB(void *pData, void *pParam)
+{
+	Task_SendEvent(pParam, EV_USER_DHT11_TEST_DONE, 0, 0, 0);
+}
 
-
-void DHT11_TestOnce(uint8_t Pin, CBFuncEx_t CB)
+void DHT11_TestOnce(uint8_t Pin)
 {
 	uint8_t HWTimerID = HW_TIMER0;
 	uint32_t i;
 	OPQueue_CmdStruct OPCmd;
 	HANDLE TaskHandle = Task_GetCurrent();
-	HWTimer_InitOperationQueue(HWTimerID, 100, 1, 0, CB, TaskHandle);
-	OPCmd.Operation = OP_QUEUE_CMD_SET_GPIO_DIR_OUT;
-	OPCmd.Arg1 = Pin;
+	HWTimer_InitOperationQueue(HWTimerID, 100, 1, prvDHT11_TestCB, TaskHandle);
+	OPCmd.Operation = OP_QUEUE_CMD_SET_GPIO_DIR_IN;
+	OPCmd.PinOrDelay = Pin;
 	OPCmd.uArg.IOArg.Level = 0;
 	OPCmd.uArg.IOArg.PullMode = OP_QUEUE_CMD_IO_PULL_UP;
 	HWTimer_AddOperation(HWTimerID, &OPCmd);
 	OPCmd.Operation = OP_QUEUE_CMD_ONE_TIME_DELAY;
-	OPCmd.Arg1 = 0;
-	OPCmd.uArg.Time = 20000;
+	OPCmd.PinOrDelay = 0;
+	OPCmd.uArg.Time = 60000;
 	HWTimer_AddOperation(HWTimerID, &OPCmd);
 
+	OPCmd.Operation = OP_QUEUE_CMD_SET_GPIO_DIR_OUT;
+	OPCmd.PinOrDelay = Pin;
+	OPCmd.uArg.IOArg.Level = 0;
+	OPCmd.uArg.IOArg.PullMode = OP_QUEUE_CMD_IO_PULL_NONE;
+	HWTimer_AddOperation(HWTimerID, &OPCmd);
+	OPCmd.Operation = OP_QUEUE_CMD_ONE_TIME_DELAY;
+	OPCmd.PinOrDelay = 0;
+	OPCmd.uArg.Time = 18000;
+	HWTimer_AddOperation(HWTimerID, &OPCmd);
 
 	OPCmd.Operation = OP_QUEUE_CMD_CAPTURE_SET;
-	OPCmd.Arg1 = Pin;
+	OPCmd.PinOrDelay = Pin;
 	OPCmd.uArg.ExitArg.ExtiMode = OP_QUEUE_CMD_IO_EXTI_DOWN;
 	OPCmd.uArg.ExitArg.PullMode = OP_QUEUE_CMD_IO_PULL_UP;
 	OPCmd.uParam.MaxCnt = 100 * SYS_TIMER_1MS;
 	HWTimer_AddOperation(HWTimerID, &OPCmd);
 
 	OPCmd.Operation = OP_QUEUE_CMD_CAPTURE;
-	OPCmd.Arg1 = Pin;
+	OPCmd.PinOrDelay = 0xff;
 	OPCmd.uArg.IOArg.Level = 0xff;
-	for(i = 0; i < 43; i++) //40bit data+2bit start+1bit end
+	OPCmd.uParam.MaxCnt = 0;
+	for(i = 0; i < 42; i++) //40bit data+2bit start+1bit end
 	{
 		HWTimer_AddOperation(HWTimerID, &OPCmd);
 	}
 	OPCmd.Operation = OP_QUEUE_CMD_CAPTURE_END;
-	OPCmd.Arg1 = Pin;
+	OPCmd.PinOrDelay = Pin;
+	HWTimer_AddOperation(HWTimerID, &OPCmd);
+	OPCmd.Operation = OP_QUEUE_CMD_SET_GPIO_DIR_IN;
+	OPCmd.PinOrDelay = Pin;
+	OPCmd.uArg.IOArg.Level = 0;
+	OPCmd.uArg.IOArg.PullMode = OP_QUEUE_CMD_IO_PULL_UP;
 	HWTimer_AddOperation(HWTimerID, &OPCmd);
 	HWTimer_StartOperationQueue(HWTimerID);
 }
@@ -125,4 +147,26 @@ void DHT11_TestResult(void)
 		DBG("check error %x,%x", DHT11.Data[4], DHT11.Data[5]);
 		DBG_HexPrintf(DHT11.Data, 4);
 	}
+	HWTimer_Stop(HWTimerID);
+}
+
+static void prvDHT11_Test(void *p)
+{
+	OS_EVENT Event;
+	while(1)
+	{
+		DBG("test start");
+		DHT11_TestOnce(GPIOD_06);
+		Task_GetEvent(Task_GetCurrent(), EV_USER_DHT11_TEST_DONE, &Event, NULL, 200 * SYS_TIMER_1MS);
+		DHT11_TestResult();
+		Task_DelayMS(1000);
+	}
+
+}
+
+void DHT11_TestInit(void)
+{
+	Task_Create(prvDHT11_Test, NULL, 1024, SERVICE_TASK_PRO, "dht11 task");
 }
+
+//INIT_TASK_EXPORT(DHT11_TestInit, "3");

bsp/common/include/bsp_common.h

@@ -223,7 +223,7 @@ typedef struct
     	uint16_t Time;	//delay时间，us
     } uArg;
     uint8_t Operation;	//操作类型
-    uint8_t Arg1;		//IO操作时为IOpin，delay操作时则为微调值，0~47，48为1us
+    uint8_t PinOrDelay;		//IO操作时为IOpin，delay操作时则为微调值，0~47，48为1us
 }OPQueue_CmdStruct;
 
 __attribute__((weak)) uint8_t OS_CheckInIrq(void);

bsp/common/include/platform_define.h

@@ -46,16 +46,19 @@ enum
 	OP_QUEUE_CMD_SET_GPIO_DIR_IN,
 	OP_QUEUE_CMD_GPIO_OUT,
 	OP_QUEUE_CMD_GPIO_IN,
+	OP_QUEUE_CMD_GPIO_IN_CB,
 	OP_QUEUE_CMD_CB,
 	OP_QUEUE_CMD_CAPTURE_SET,
 	OP_QUEUE_CMD_CAPTURE,
+	OP_QUEUE_CMD_CAPTURE_CB,
 	OP_QUEUE_CMD_CAPTURE_END,
 	OP_QUEUE_CMD_IO_PULL_NONE = 0,
 	OP_QUEUE_CMD_IO_PULL_UP,
 	OP_QUEUE_CMD_IO_PULL_DOWN,
-	OP_QUEUE_CMD_IO_EXTI_BOTH = 0,	//双边沿中断
-	OP_QUEUE_CMD_IO_EXTI_UP,		//上升沿中断
+
+	OP_QUEUE_CMD_IO_EXTI_UP = 0,		//上升沿中断
 	OP_QUEUE_CMD_IO_EXTI_DOWN,		//下降沿中断
+	OP_QUEUE_CMD_IO_EXTI_BOTH,	//双边沿中断
 
 	COLOR_MODE_RGB_565 = 0,
 	COLOR_MODE_GRAY,

xmake.lua

@@ -66,9 +66,9 @@ set_languages("c11", "cxx11")
 
 add_asflags("-mcpu=cortex-m4","-mfpu=fpv4-sp-d16","-mfloat-abi=hard","-mthumb","-c",{force = true})
 -- add_arflags("-mcpu=cortex-m4","-mfpu=fpv4-sp-d16","-mfloat-abi=hard","-mthumb","-c","--specs=nano.specs","-ffunction-sections","-fdata-sections","-fstack-usage","-Og","-DTRACE_LEVEL=4",{force = true})
-add_cxflags("-mcpu=cortex-m4","-Og","-mfpu=fpv4-sp-d16","-mfloat-abi=hard","-mthumb","-c","--specs=nano.specs","-ffunction-sections","-fdata-sections","-fstack-usage","-DTRACE_LEVEL=4",{force = true})
+add_cxflags("-mcpu=cortex-m4","-Os","-mfpu=fpv4-sp-d16","-mfloat-abi=hard","-mthumb","-c","--specs=nano.specs","-ffunction-sections","-fdata-sections","-fstack-usage","-DTRACE_LEVEL=4",{force = true})
 
-add_ldflags("-mcpu=cortex-m4","-Og","-mfpu=fpv4-sp-d16","-mfloat-abi=hard","-mthumb","--specs=nano.specs","--specs=nosys.specs","-Wl,--gc-sections","-Wl,--check-sections","-Wl,--cref","-Wl,--no-whole-archive","-lc_nano","-Wl,--no-whole-archive",{force = true})
+add_ldflags("-mcpu=cortex-m4","-Os","-mfpu=fpv4-sp-d16","-mfloat-abi=hard","-mthumb","--specs=nano.specs","--specs=nosys.specs","-Wl,--gc-sections","-Wl,--check-sections","-Wl,--cref","-Wl,--no-whole-archive","-lc_nano","-Wl,--no-whole-archive",{force = true})
 
 set_dependir("$(buildir)/.deps")
 set_objectdir("$(buildir)/.objs")