add:camera视频流

application/include/luat_conf_bsp.h

@@ -117,7 +117,7 @@
 #define LV_DISP_DEF_REFR_PERIOD gLVFlashTime
 extern unsigned int gLVFlashTime;
 #define LUAT_LV_DEBUG 0
-#define LV_USE_LOG 0
+#define LV_USE_LOG 1
 #define LV_MEM_CUSTOM 1
 
 #define LUAT_USE_LVGL_INDEV 1

application/src/luat_camera_air105.c

@@ -18,7 +18,7 @@
  * 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 "zlib.h"
 #include "app_interface.h"
 #include "luat_base.h"
 
@@ -38,10 +38,12 @@
 
 typedef struct
 {
+	uint64_t StartTick;
 	Buffer_Struct FileBuffer;
 	Buffer_Struct JPEGSavePath;
 	Timer_t *CheckTimer;
 	uint8_t *DataCache;
+	uint8_t *VideoCache;
 	uint32_t TotalSize;
 	uint32_t CurSize;
 	uint32_t VLen;
@@ -57,6 +59,7 @@ typedef struct
 	uint8_t PWMID;
 	uint8_t I2CID;
 	uint8_t NewDataFlag;
+	uint8_t DrawLCD;
 }Camera_CtrlStruct;
 
 static Camera_CtrlStruct prvCamera;
@@ -64,7 +67,6 @@ static Camera_CtrlStruct prvCamera;
 static struct luat_camera_conf camera_conf;
 
 static luat_lcd_conf_t* lcd_conf;
-static uint8_t draw_lcd = 0;
 
 static int32_t prvCamera_DataTimeout(void *pData, void *pParam)
 {
@@ -220,7 +222,7 @@ static int32_t prvCamera_DCMICB(void *pData, void *pParam){
             prvCamera.VLen = 0;
             return 0;
         }
-        if (draw_lcd)
+        if (prvCamera.DrawLCD)
         {
             Camera_DrawLcd(RxBuf->Data, zbar_scan);
         }
@@ -236,7 +238,7 @@ static int32_t prvCamera_DCMICB(void *pData, void *pParam){
             }
             else if (prvCamera.DataCache)
             {
-            	if (draw_lcd) {
+            	if (prvCamera.DrawLCD) {
             	    Camera_DrawLcd(prvCamera.DataCache, zbar_scan);
             	}
             	Core_DecodeQR(prvCamera.DataCache, prvCamera.Width, prvCamera.Height,  DecodeQR_CBDataFun);
@@ -284,7 +286,7 @@ int luat_camera_init(luat_camera_conf_t *conf){
 	}
     memcpy(&camera_conf, conf, sizeof(luat_camera_conf_t));
     lcd_conf = conf->lcd_conf;
-    draw_lcd = conf->draw_lcd;
+    prvCamera.DrawLCD = conf->draw_lcd;
     if (lcd_conf)
     {
         prvCamera.Width = lcd_conf->w;
@@ -294,7 +296,7 @@ int luat_camera_init(luat_camera_conf_t *conf){
     {
         prvCamera.Width = camera_conf.sensor_width;
         prvCamera.Height = camera_conf.sensor_height;
-        draw_lcd = 0;
+        prvCamera.DrawLCD = 0;
     }
 
     if (conf->zbar_scan == 1){
@@ -332,6 +334,7 @@ int luat_camera_init(luat_camera_conf_t *conf){
 
 int luat_camera_start(int id)
 {
+	DCMI_SetCallback(prvCamera_DCMICB, camera_conf.zbar_scan);
 	if (prvCamera.DataCache)
 	{
 		DCMI_CaptureSwitch(0, 0, 0, 0, 0, NULL);
@@ -392,6 +395,152 @@ int luat_camera_capture(int id, uint8_t quality, const char *path)
     return 0;
 }
 
+static voidpf luat_zip_zalloc(    voidpf opaque, uint32_t items, uint32_t size)
+{
+	voidpf *p = malloc(items * size);
+	return p;
+}
+
+static void luat_zip_free (voidpf opaque, voidpf ptr)
+{
+	free(ptr);
+}
+
+static int luat_camera_video_zip(void *data ,void *param)
+{
+	PV_Union uPV;
+	uPV.p = param;
+    int ret;
+    unsigned have;
+    z_stream strm;
+    prvCamera.VideoCache[0] = 'V';
+    prvCamera.VideoCache[1] = 'C';
+    prvCamera.VideoCache[2] = 'A';
+    prvCamera.VideoCache[3] = 'M';
+    BytesPutLe16(prvCamera.VideoCache + 4, prvCamera.Width);
+    BytesPutLe16(prvCamera.VideoCache + 6, prvCamera.Height);
+    BytesPutLe32(prvCamera.VideoCache + 8, uPV.u16[1]);
+    {
+		if ((prvCamera.CurSize + (prvCamera.Height - uPV.u16[1]) * prvCamera.Width * 2) < (800 * (GetSysTickMS() - prvCamera.StartTick)))
+		{
+			BytesPutLe16(prvCamera.VideoCache + 12, uPV.u16[0]);
+			BytesPutLe16(prvCamera.VideoCache + 14, uPV.u16[0]);
+			memcpy(prvCamera.VideoCache + 16, data, uPV.u16[0]);
+			free(data);
+			Core_VUartBufferTx(VIRTUAL_UART0, prvCamera.VideoCache, uPV.u16[0] + 16);
+			prvCamera.CurSize += uPV.u16[0];
+			return 0;
+		}
+    }
+
+#undef zalloc
+    strm.zalloc = luat_zip_zalloc;
+    strm.zfree = luat_zip_free;
+#define zalloc OS_Zalloc
+    ret = deflateInit2_(&strm, 1, Z_DEFLATED, 12, 6,
+    		Z_DEFAULT_STRATEGY, ZLIB_VERSION, (int)sizeof(z_stream));
+    if (Z_OK == ret)
+    {
+    	strm.next_in = data;
+    	strm.avail_in = uPV.u16[0];
+    	strm.avail_out = 10240;
+		strm.next_out = prvCamera.VideoCache + 16;
+		ret = deflate(&strm, Z_FINISH);    /* no bad return value */
+		have = 10240 - strm.avail_out;
+		deflateEnd(&strm);
+    	BytesPutLe16(prvCamera.VideoCache + 12, uPV.u16[0]);
+    	BytesPutLe16(prvCamera.VideoCache + 14, have);
+    	free(data);
+		Core_VUartBufferTx(VIRTUAL_UART0, prvCamera.VideoCache, have + 16);
+		prvCamera.CurSize += have;
+    }
+    else
+    {
+    	DBG("%d", ret);
+    	free(data);
+    }
+
+}
+
+static int luat_camera_video_zip_done(void *data ,void *param)
+{
+	prvCamera.CaptureWait = 0;
+//	DBG("%u", prvCamera.CurSize);
+	prvCamera.CurSize = 0;
+}
+
+static int luat_camera_video_cb(void *pdata ,void *param)
+{
+    Buffer_Struct *RxBuf = (Buffer_Struct *)pdata;
+    prvCamera.NewDataFlag = 1;
+
+	if (!pdata){
+		if (prvCamera.JPEGEncodeDone)
+		{
+			prvCamera.JPEGEncodeDone = 0;
+			prvCamera.CaptureWait = 1;
+			Core_ServiceRunUserAPI(luat_camera_video_zip_done, NULL, NULL);
+
+		}
+		prvCamera.VLen = 0;
+	}
+	else
+	{
+		if ((!prvCamera.VLen || prvCamera.JPEGEncodeDone) && !prvCamera.CaptureWait)
+		{
+			if (!prvCamera.VLen)
+			{
+				prvCamera.StartTick = GetSysTickMS();
+			}
+			prvCamera.JPEGEncodeDone = 1;
+			uint8_t *data = malloc(RxBuf->MaxLen * 4);
+			if (data)
+			{
+				memcpy(data, RxBuf->Data, RxBuf->MaxLen * 4);
+				PV_Union uPV;
+				uPV.u16[0] = RxBuf->MaxLen * 4;
+				uPV.u16[1] = prvCamera.VLen;
+				Core_ServiceRunUserAPI(luat_camera_video_zip, data, uPV.u32);
+			}
+			else
+			{
+				DBG("no mem");
+				Core_PrintMemInfo();
+			}
+		}
+		prvCamera.VLen += prvCamera.drawVLen;
+	}
+	return 0;
+
+}
+
+int luat_camera_video(int id, int w, int h, uint8_t uart_id)
+{
+	uint8_t data_byte = camera_conf.zbar_scan?1:2;
+	Timer_Stop(prvCamera.CheckTimer);
+	OS_DeInitBuffer(&prvCamera.FileBuffer);
+	DCMI_SetCallback(luat_camera_video_cb, 0);
+	if (prvCamera.DataCache)
+	{
+		DCMI_CaptureSwitch(0, 0, 0, 0, 0, NULL);
+		free(prvCamera.DataCache);
+		prvCamera.DataCache = NULL;
+	}
+	if (prvCamera.VideoCache)
+	{
+		luat_vm_free(prvCamera.VideoCache);
+	}
+	prvCamera.VideoCache = luat_vm_malloc(10240 + 96);
+	DCMI_SetCROPConfig(1, (camera_conf.sensor_height-h) >> 1, ((camera_conf.sensor_width-w) >> 1)*data_byte, h - 1, data_byte*w- 1);
+	DCMI_CaptureSwitch(1, w * data_byte * 4, 0, 0, 0, &prvCamera.drawVLen);
+	prvCamera.drawVLen = 16;
+	prvCamera.CaptureWait = 0;
+	prvCamera.VLen = 0;
+	prvCamera.Width = w;
+	prvCamera.Height = h;
+    Timer_StartMS(prvCamera.CheckTimer, 1000, 1);
+}
+
 int luat_camera_stop(int id)
 {
 	Timer_Stop(prvCamera.CheckTimer);
@@ -402,6 +551,11 @@ int luat_camera_stop(int id)
 		prvCamera.DataCache = NULL;
 	}
 	OS_DeInitBuffer(&prvCamera.FileBuffer);
+	if (prvCamera.VideoCache)
+	{
+		luat_vm_free(prvCamera.VideoCache);
+		prvCamera.VideoCache = NULL;
+	}
     return 0;
 }
 

application/src/luat_malloc_air105.c

@@ -66,6 +66,16 @@ void luat_vm_pool_init(void)
 	luat_bpool(&luavm_pool, luavm_pool_data, sizeof(luavm_pool_data));
 }
 //------------------------------------------------
+
+void *luat_vm_malloc(size_t nsize)
+{
+	return luat_bget(&luavm_pool, nsize);
+}
+
+void luat_vm_free(void *ptr)
+{
+	return luat_brel(&luavm_pool, ptr);
+}
 // ---------- 管理 LuaVM所使用的内存----------------
 void* luat_heap_alloc(void *ud, void *ptr, size_t osize, size_t nsize) {
 //    if (0) {

application/src/luat_rtos_air105.c

@@ -82,3 +82,13 @@ void luat_release_rtos_timer(void *timer)
 {
 	Timer_Release(timer);
 }
+
+void luat_task_suspend_all(void)
+{
+	OS_SuspendTask(NULL);
+}
+
+void luat_task_resume_all(void)
+{
+	OS_ResumeTask(NULL);
+}

bsp/common/include/bsp_common.h

@@ -26,7 +26,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdarg.h>
-#include "cmsis_gcc.h"
+#include "cmsis_compiler.h"
 
 typedef struct
 {

bsp/common/include/platform_define.h

@@ -336,4 +336,191 @@ enum
 
 #endif
 
+#ifdef __AIR106_BSP__
+enum
+{
+	USB_ID0 = 0,
+	USB_MAX,
+	CAN_ID0 = 0,	//CAN CLK=SYS/2
+	CAN_ID1,
+	CAN_MAX,
+	I2C_ID0 = 0,	//I2C CLK=SYS/2
+	I2C_ID1,
+	I2C_MAX,
+	UART_ID0 = 0,
+	UART_ID1,
+	UART_ID2,
+	UART_ID3,
+	UART_MAX,
+	VIRTUAL_UART0 = 0,
+	VIRTUAL_UART_MAX,
+
+	SPI_ID0,
+	SPI_ID1,
+	SPI_MAX,
+
+	SPI_MODE_0 = 0,
+	SPI_MODE_1,
+	SPI_MODE_2,
+	SPI_MODE_3,
+
+	HW_TIMER0 = 0,
+	HW_TIMER1,
+	HW_TIMER2,
+	HW_TIMER3,
+	HW_TIMER4,
+	//下面是普通定时器
+	HW_TIMER5,
+	HW_TIMER6,
+	HW_TIMER7,
+	HW_TIMER8,
+	HW_TIMER9,
+	HW_TIMER10,
+	HW_TIMER11,
+	HW_TIMER12,
+	HW_TIMER13,
+	HW_TIMER14,
+
+	HW_TIMER_MAX,
+
+	ADC_CHANNEL_0 = 0,
+	ADC_CHANNEL_1,
+	ADC_CHANNEL_2,
+	ADC_CHANNEL_3,
+	ADC_CHANNEL_4,
+	ADC_CHANNEL_5,
+	ADC_CHANNEL_6,
+	ADC_CHANNEL_MAX,
+
+	DMA1_STREAM_0 = 0,
+	DMA1_STREAM_1,
+	DMA1_STREAM_2,
+	DMA1_STREAM_3,
+	DMA1_STREAM_QTY,
+	DMA_STREAM_QTY = DMA1_STREAM_QTY,
+
+	HAL_GPIO_MAX = 112,
+	HAL_GPIO_NONE = HAL_GPIO_MAX, //大于等于HAL_GPIO_NONE，说明不存在
+};
+
+
+enum
+{
+	GPIOA_00 = 0,
+	GPIOA_01,
+	GPIOA_02,
+	GPIOA_03,
+	GPIOA_04,
+	GPIOA_05,
+	GPIOA_06,
+	GPIOA_07,
+	GPIOA_08,
+	GPIOA_09,
+	GPIOA_10,
+	GPIOA_11,
+	GPIOA_12,
+	GPIOA_13,
+	GPIOA_14,
+	GPIOA_15,
+	GPIOB_00,
+	GPIOB_01,
+	GPIOB_02,
+	GPIOB_03,
+	GPIOB_04,
+	GPIOB_05,
+	GPIOB_06,
+	GPIOB_07,
+	GPIOB_08,
+	GPIOB_09,
+	GPIOB_10,
+	GPIOB_11,
+	GPIOB_12,
+	GPIOB_13,
+	GPIOB_14,
+	GPIOB_15,
+	GPIOC_00,
+	GPIOC_01,
+	GPIOC_02,
+	GPIOC_03,
+	GPIOC_04,
+	GPIOC_05,
+	GPIOC_06,
+	GPIOC_07,
+	GPIOC_08,
+	GPIOC_09,
+	GPIOC_10,
+	GPIOC_11,
+	GPIOC_12,
+	GPIOC_13,
+	GPIOC_14,
+	GPIOC_15,
+	GPIOD_00,
+	GPIOD_01,
+	GPIOD_02,
+	GPIOD_03,
+	GPIOD_04,
+	GPIOD_05,
+	GPIOD_06,
+	GPIOD_07,
+	GPIOD_08,
+	GPIOD_09,
+	GPIOD_10,
+	GPIOD_11,
+	GPIOD_12,
+	GPIOD_13,
+	GPIOD_14,
+	GPIOD_15,
+	GPIOE_00,
+	GPIOE_01,
+	GPIOE_02,
+	GPIOE_03,
+	GPIOE_04,
+	GPIOE_05,
+	GPIOE_06,
+	GPIOE_07,
+	GPIOE_08,
+	GPIOE_09,
+	GPIOE_10,
+	GPIOE_11,
+	GPIOE_12,
+	GPIOE_13,
+	GPIOE_14,
+	GPIOE_15,
+	GPIOM_00,
+	GPIOM_01,
+	GPIOM_02,
+	GPIOM_03,
+	GPIOM_04,
+	GPIOM_05,
+	GPIOM_06,
+	GPIOM_07,
+	GPIOM_08,
+	GPIOM_09,
+	GPIOM_10,
+	GPIOM_11,
+	GPIOM_12,
+	GPIOM_13,
+	GPIOM_14,
+	GPIOM_15,
+	GPION_00,
+	GPION_01,
+	GPION_02,
+	GPION_03,
+	GPION_04,
+	GPION_05,
+	GPION_06,
+	GPION_07,
+	GPION_08,
+	GPION_09,
+	GPION_10,
+	GPION_11,
+	GPION_12,
+	GPION_13,
+	GPION_14,
+	GPION_15,
+	GPIO_MAX,
+	GPIO_NONE = GPIO_MAX, //大于等于GPIO_NONE，说明不存在
+};
+#endif
+
 #endif

bsp/common/src/bsp_common.c

@@ -20,7 +20,396 @@
  */
 
 #include "bsp_common.h"
+#ifdef __LUATOS__
 
+
+__attribute__((weak)) uint8_t OS_CheckInIrq(void)
+{
+	return __get_IPSR();
+}
+
+#include "bget.h"
+#ifdef __BUILD_OS__
+#include "FreeRTOS.h"
+#include "semphr.h"
+#include "task.h"
+HANDLE OS_MutexCreate(void)
+{
+	return xSemaphoreCreateBinary();
+}
+
+HANDLE OS_MutexCreateUnlock(void)
+{
+	HANDLE Sem = xSemaphoreCreateBinary();
+	xSemaphoreGive(Sem);
+	return Sem;
+}
+
+void OS_MutexLock(HANDLE Sem)
+{
+	uint8_t suspend = !OS_IsSchedulerRun();
+	if (suspend)
+	{
+		xTaskResumeAll();
+	}
+	xSemaphoreTake(Sem, portMAX_DELAY);
+	if (suspend)
+	{
+		vTaskSuspendAll();
+	}
+}
+
+int32_t OS_MutexLockWtihTime(HANDLE Sem, uint32_t TimeoutMs)
+{
+	uint8_t suspend = !OS_IsSchedulerRun();
+	if (suspend)
+	{
+		xTaskResumeAll();
+	}
+	int result = xSemaphoreTake(Sem, TimeoutMs);
+	if (suspend)
+	{
+		vTaskSuspendAll();
+	}
+	if (pdTRUE != result)
+	{
+		return -ERROR_OPERATION_FAILED;
+	}
+	else
+	{
+		return ERROR_NONE;
+	}
+}
+
+void OS_MutexRelease(HANDLE Sem)
+{
+	BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+//	xSemaphoreGiveFromISR(Sem, &xHigherPriorityTaskWoken);
+	if (OS_CheckInIrq())
+	{
+		xSemaphoreGiveFromISR(Sem, &xHigherPriorityTaskWoken);
+		if (xHigherPriorityTaskWoken)
+		{
+			portYIELD_WITHIN_API();
+		}
+	}
+	else
+	{
+		xSemaphoreGive(Sem);
+	}
+}
+
+void OS_MutexDelete(HANDLE Sem)
+{
+	vSemaphoreDelete(Sem);
+}
+
+uint8_t OS_IsSchedulerRun(void)
+{
+	return (xTaskGetSchedulerState() == taskSCHEDULER_RUNNING);
+}
+
+void OS_SuspendTask(HANDLE taskHandle)
+{
+	if (taskHandle)
+	{
+		vTaskSuspend(taskHandle);
+	}
+	else
+	{
+		vTaskSuspendAll();
+	}
+}
+
+void OS_ResumeTask(HANDLE taskHandle)
+{
+	if (taskHandle)
+	{
+		vTaskResume(taskHandle);
+	}
+	else
+	{
+		xTaskResumeAll();
+	}
+}
+#endif
+static uint8_t prvOSRunFlag;
+extern const uint32_t __os_heap_start;
+extern const uint32_t __ram_end;
+__attribute__((weak)) void OS_SetStartFlag(void)
+{
+	prvOSRunFlag = 1;
+}
+__attribute__((weak)) uint32_t OS_EnterCritical(void)
+{
+#ifdef __BUILD_OS__
+	if (prvOSRunFlag)
+	{
+		if (__get_IPSR())
+		{
+			return taskENTER_CRITICAL_FROM_ISR();
+		}
+		else
+		{
+			taskENTER_CRITICAL();
+			return 0;
+		}
+	}
+	else
+#endif
+	{
+		__disable_irq();
+	}
+}
+__attribute__((weak)) void OS_ExitCritical(uint32_t Critical)
+{
+#ifdef __BUILD_OS__
+	if (prvOSRunFlag)
+	{
+		if (__get_IPSR())
+		{
+			taskEXIT_CRITICAL_FROM_ISR(Critical);
+		}
+		else
+		{
+			taskEXIT_CRITICAL();
+		}
+	}
+	else
+#endif
+	{
+		__enable_irq();
+	}
+}
+
+__attribute__((weak)) void *OS_Malloc(uint32_t Size)
+{
+	void *p;
+	uint32_t Critical = OS_EnterCritical();
+	p = bget(Size);
+	OS_ExitCritical(Critical);
+	return p;
+}
+
+__attribute__((weak)) void *OS_Zalloc(uint32_t Size)
+{
+	void *p;
+	uint32_t Critical = OS_EnterCritical();
+	p = bgetz(Size);
+	OS_ExitCritical(Critical);
+	return p;
+}
+
+__attribute__((weak)) void *OS_Calloc(uint32_t count, uint32_t eltsize)
+{
+	void *p;
+	uint32_t Critical = OS_EnterCritical();
+	p = bgetz(count * eltsize);
+	OS_ExitCritical(Critical);
+	return p;
+}
+
+__attribute__((weak)) void OS_Free(void *p)
+{
+	if (((uint32_t)p >= (uint32_t)(&__os_heap_start)) && ((uint32_t)p <= (uint32_t)(&__ram_end)))
+	{
+		uint32_t Critical = OS_EnterCritical();
+		brel(p);
+		OS_ExitCritical(Critical);
+	}
+
+}
+
+__attribute__((weak)) void *OS_Realloc(void *buf, uint32_t size)
+{
+	void *p;
+	uint32_t Critical = OS_EnterCritical();
+//	p = bget(size);
+//	memcpy(p, buf, size);
+//	brel(buf);
+	p = bgetr(buf, size);
+	OS_ExitCritical(Critical);
+	return p;
+}
+
+__attribute__((weak)) void OS_MemInfo(uint32_t *curalloc, uint32_t *totfree, uint32_t *maxfree)
+{
+	unsigned long  nget, nrel;
+	uint32_t Critical = OS_EnterCritical();
+	bstats(curalloc, totfree, maxfree, &nget, &nrel);
+	OS_ExitCritical(Critical);
+}
+
+int32_t OS_InitBuffer(Buffer_Struct *Buf, uint32_t Size)
+{
+	if (!Buf)
+		return 0;
+	Buf->Data = OS_Zalloc(Size);
+	if (!Buf->Data)
+	{
+		Buf->MaxLen = 0;
+		Buf->Pos = 0;
+		return 0;
+	}
+	Buf->MaxLen = Size;
+	Buf->Pos = 0;
+	return Size;
+}
+
+void OS_DeInitBuffer(Buffer_Struct *Buf)
+{
+	if (Buf->Data)
+	{
+		OS_Free(Buf->Data);
+	}
+	Buf->Data = NULL;
+	Buf->MaxLen = 0;
+	Buf->Pos = 0;
+}
+
+int32_t OS_ReInitBuffer(Buffer_Struct *Buf, uint32_t Size)
+{
+	if (!Buf)
+		return 0;
+
+	if (Buf->Data)
+	{
+		OS_Free(Buf->Data);
+	}
+	Buf->Data = OS_Zalloc(Size);
+	if (!Buf->Data)
+	{
+		Buf->MaxLen = 0;
+		Buf->Pos = 0;
+		return 0;
+	}
+	Buf->MaxLen = Size;
+	Buf->Pos = 0;
+	return Size;
+}
+
+int32_t OS_ReSizeBuffer(Buffer_Struct *Buf, uint32_t Size)
+{
+//	uint8_t *Old;
+	uint8_t *New;
+
+	if (!Buf)
+		return 0;
+
+//	Old = Buf->Data;
+//	if (Size < Buf->Pos)
+//	{
+//		Size = Buf->Pos;
+//	}
+//	New = OS_Zalloc(Size);
+//	if (!New)
+//	{
+//		return 0;
+//	}
+//	if (Old)
+//	{
+//		memcpy(New, Old, Buf->Pos);
+//		OS_Free(Old);
+//	}
+	uint32_t Critical = OS_EnterCritical();
+	New = bgetr(Buf->Data, Size);
+	if (New)
+	{
+		Buf->Data = New;
+		Buf->MaxLen = Size;
+	}
+	OS_ExitCritical(Critical);
+
+
+	return Size;
+}
+
+int32_t OS_BufferWrite(Buffer_Struct *Buf, void *Data, uint32_t Len)
+{
+	uint32_t WriteLen;
+	if (!Len)
+	{
+		return ERROR_NONE;
+	}
+	if (!Buf)
+	{
+		return -ERROR_PARAM_INVALID;
+	}
+	if (!Buf->Data)
+	{
+		Buf->Data = OS_Zalloc(Len);
+		if (!Buf->Data)
+		{
+			return -ERROR_NO_MEMORY;
+		}
+		Buf->Pos = 0;
+		Buf->MaxLen = Len;
+	}
+	WriteLen = Buf->Pos + Len;
+	if (WriteLen > Buf->MaxLen)
+	{
+		if (!OS_ReSizeBuffer(Buf, WriteLen))
+		{
+			return -ERROR_NO_MEMORY;
+		}
+	}
+	memcpy(&Buf->Data[Buf->Pos], Data, Len);
+	Buf->Pos += Len;
+	return ERROR_NONE;
+}
+
+int32_t OS_BufferWriteLimit(Buffer_Struct *Buf, void *Data, uint32_t Len)
+{
+	uint32_t WriteLen;
+	if (!Len)
+	{
+		return ERROR_NONE;
+	}
+	if (!Buf)
+	{
+		return -ERROR_PARAM_INVALID;
+	}
+	if (!Buf->Data)
+	{
+		Buf->Data = OS_Zalloc(Len);
+		if (!Buf->Data)
+		{
+			return -ERROR_NO_MEMORY;
+		}
+		Buf->Pos = 0;
+		Buf->MaxLen = Len;
+	}
+	WriteLen = Buf->Pos + Len;
+	if (WriteLen > Buf->MaxLen)
+	{
+		return -ERROR_NO_MEMORY;
+	}
+	memcpy(&Buf->Data[Buf->Pos], Data, Len);
+	Buf->Pos += Len;
+	return ERROR_NONE;
+}
+
+void OS_BufferRemove(Buffer_Struct *Buf, uint32_t Len)
+{
+	uint32_t RestLen;
+	uint32_t i;
+	if (!Buf)
+		return ;
+	if (!Buf->Data)
+		return ;
+	if (Len >= Buf->Pos)
+	{
+		Buf->Pos = 0;
+		return ;
+	}
+	RestLen = Buf->Pos - Len;
+	memmove(Buf->Data, Buf->Data + Len, RestLen);
+	Buf->Pos = RestLen;
+}
+
+
+
+#else
 const uint8_t ByteToAsciiTable[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 
 void LoopBuffer_Init(Loop_Buffer *Buf, void *Src, uint32_t MaxLen, uint32_t DataSize)
@@ -1832,3 +2221,5 @@ uint32_t unicode_to_utf8(void *in, uint32_t unicodelen, uint8_t *out, uint8_t is
 	}
 	return result;
 }
+
+#endif

bsp/common/src/core_service.c

@@ -827,90 +827,6 @@ int Core_OTACheckDone(void)
 	return 1;
 }
 
-//static void Core_OTACheckSpiFlash(void)
-//{
-//	CoreUpgrade_SectorStruct Sector;
-//	Buffer_Struct ReadBuffer;
-//	Buffer_Struct DataBuffer;
-//	int result;
-//	uint32_t Check;
-//	uint32_t DoneLen, ReadLen;
-//	volatile uint32_t ProgramPos, FlashPos;
-//	uint32_t LzmaDataLen;
-//	uint8_t LzmaHead[LZMA_PROPS_SIZE + 8];
-//	uint8_t LzmaHeadLen;
-//
-//	DoneLen = 0;
-//	OS_InitBuffer(&DataBuffer, SPI_FLASH_BLOCK_SIZE);
-//	OS_InitBuffer(&ReadBuffer, SPI_FLASH_BLOCK_SIZE);
-//	while(DoneLen < prvService.pFotaHead->DataLen)
-//	{
-//		ReadBuffer.Pos = sizeof(CoreUpgrade_SectorStruct);
-//		SPIFlash_Read(prvService.pSpiFlash, prvService.pFotaHead->DataStartAddress + DoneLen, ReadBuffer.Data, ReadBuffer.Pos, 1);
-//		DoneLen += sizeof(CoreUpgrade_SectorStruct);
-//		memcpy(&Sector, ReadBuffer.Data, sizeof(CoreUpgrade_SectorStruct));
-//		DBG("%x,%x,%x,%x,%x", Sector.MaigcNum, Sector.StartAddress, Sector.TotalLen, Sector.DataLen, Sector.DataCRC32);
-//		if (Sector.MaigcNum != __APP_START_MAGIC__)
-//		{
-//			DBG("ota sector info error %x", Sector.MaigcNum);
-//			return;
-//		}
-//		ProgramPos = Sector.StartAddress;
-//		FlashPos = DoneLen + prvService.pFotaHead->DataStartAddress;
-//		DoneLen += Sector.TotalLen;
-//
-//		Check = 0xffffffff;
-//		ReadLen = 0;
-//		while(ReadLen < Sector.TotalLen)
-//		{
-//			DBG("ota %x,%x,%u,%u", ProgramPos, FlashPos, ReadLen, Sector.TotalLen);
-//			ReadBuffer.Pos = 1;
-//			SPIFlash_Read(prvService.pSpiFlash, FlashPos, ReadBuffer.Data, ReadBuffer.Pos, 1);
-//			FlashPos += ReadBuffer.Pos;
-//			ReadLen += ReadBuffer.Pos;
-//			LzmaHeadLen = ReadBuffer.Data[0];
-//			if (LzmaHeadLen > sizeof(LzmaHead))
-//			{
-//				DBG("ota zip head error");
-//				return;
-//			}
-//			ReadBuffer.Pos = LzmaHeadLen + 4;
-//			SPIFlash_Read(prvService.pSpiFlash, FlashPos, ReadBuffer.Data, ReadBuffer.Pos, 1);
-//			FlashPos += ReadBuffer.Pos;
-//			ReadLen += ReadBuffer.Pos;
-//			memcpy(LzmaHead, ReadBuffer.Data, LzmaHeadLen);
-//			memcpy(&LzmaDataLen, ReadBuffer.Data + LzmaHeadLen, 4);
-//			ReadBuffer.Pos = LzmaDataLen;
-//			SPIFlash_Read(prvService.pSpiFlash, FlashPos, ReadBuffer.Data, ReadBuffer.Pos, 1);
-//			FlashPos += ReadBuffer.Pos;
-//			ReadLen += ReadBuffer.Pos;
-//
-//			DataBuffer.Pos = __FLASH_BLOCK_SIZE__;
-//			result = LzmaUncompress(DataBuffer.Data, &DataBuffer.Pos, ReadBuffer.Data, &LzmaDataLen, LzmaHead, LzmaHeadLen);
-//			if (DataBuffer.Pos != __FLASH_BLOCK_SIZE__)
-//			{
-//				DataBuffer.Pos = Sector.DataLen - (ProgramPos - Sector.StartAddress);
-//			}
-//			Check = CRC32_Cal(prvService.CRC32_Table, DataBuffer.Data, DataBuffer.Pos, Check);
-//			ProgramPos += DataBuffer.Pos;
-//
-//		}
-//		DBG("%u, %u", ProgramPos - Sector.StartAddress, Sector.DataLen);
-//		if (Sector.DataCRC32 != Check)
-//		{
-////				Reboot = 1;
-//			DBG("ota %x check crc32 fail %x %x", Sector.StartAddress, Check, Sector.DataCRC32);
-//			return;
-//		}
-//		else
-//		{
-//			DBG("ota %x check ok", Sector.StartAddress);
-//		}
-//	}
-//	OS_DeInitBuffer(&DataBuffer);
-//	OS_DeInitBuffer(&ReadBuffer);
-//}
-
 void Core_OTAEnd(uint8_t isOK)
 {
 	PV_Union uPV;
@@ -957,6 +873,10 @@ void Core_ServiceRunUserAPIWithFile(CBFuncEx_t CB, void *pData, void *pParam)
 	Task_SendEvent(prvService.StorgeHandle, SERVICE_RUN_USER_API, CB, pData, pParam);
 }
 
+void Core_ServiceRunUserAPI(CBFuncEx_t CB, void *pData, void *pParam)
+{
+	Task_SendEvent(prvService.ServiceHandle, SERVICE_RUN_USER_API, CB, pData, pParam);
+}
 
 void Core_LCDTaskInit(void)
 {

bsp/common/src/core_task.c

@@ -332,5 +332,10 @@ void Task_Debug(HANDLE TaskHandle)
 	}
 	volatile llist_head *Head = (llist_head *)vTaskGetPoint(TaskHandle, TASK_POINT_LIST_HEAD);
 	DBG("%x,%x,%x", Head, Head->next, Head->prev);
+}
+#else
+void Task_SendEvent(HANDLE TaskHandle, uint32_t ID, uint32_t P1, uint32_t P2, uint32_t P3)
+{
+
 }
 #endif

bsp/common/src/core_usb_app.c

@@ -591,6 +591,7 @@ static const USB_StorageSCSITypeDef prvCore_SCSIFun =
 static void prvCore_VUartOpen(Virtual_UartCtrlStruct *pVUart, uint8_t UartID)
 {
 	pVUart->USBOnOff = 1;
+	OS_DeInitBuffer(&pVUart->TxBuf);
 	if (pVUart->TxBuf.Data)
 	{
 		DBG("send last data %ubyte", pVUart->TxBuf.MaxLen);
@@ -658,6 +659,7 @@ static int32_t prvCore_USBEp0CB(void *pData, void *pParam)
 				case 0:
 					//close serial
 					pVUart->USBOnOff = 0;
+					OS_DeInitBuffer(&pVUart->TxCacheBuf);
 					pVUart->CB(pEpData->pLastRequest->wIndex[0] - DEVICE_INTERFACE_SERIAL_SN, UART_CB_ERROR);
 					break;
 				case 1:
@@ -806,6 +808,8 @@ static int32_t prvCore_USBStateCB(void *pData, void *pParam)
 		for(i = 0; i < VIRTUAL_UART_MAX; i++)
 		{
 			prvLuatOS_VirtualUart[i].USBOnOff = 0;
+			OS_DeInitBuffer(&prvLuatOS_VirtualUart[i].TxBuf);
+			OS_DeInitBuffer(&prvLuatOS_VirtualUart[i].TxCacheBuf);
 			prvLuatOS_VirtualUart[i].CB(i, UART_CB_ERROR);
 		}
 		break;

xmake.lua

@@ -54,7 +54,7 @@ set_arch("arm")
 --add macro defination
 local luatos_define = "__LUATOS__"
 if not with_luatos then luatos_define = nil end
-add_defines("__AIR105_BSP__","__USE_XTL__","CMB_CPU_PLATFORM_TYPE=CMB_CPU_ARM_CORTEX_M4","HSE_VALUE=12000000","CORTEX_M4","__FLASH_APP_START_ADDR__=0x01010000",luatos_define)
+add_defines("__AIR105_BSP__","__USE_XTL__","CMB_CPU_PLATFORM_TYPE=CMB_CPU_ARM_CORTEX_M4","HSE_VALUE=12000000","CORTEX_M4","__FLASH_APP_START_ADDR__=0x01010000")
 add_defines("__FLASH_OTA_INFO_ADDR__=0x0100F000")
 add_defines("_7ZIP_ST")
 add_defines("MBEDTLS_CONFIG_FILE=\"mbedtls_config.h\"")
@@ -193,7 +193,7 @@ target("app.elf")
     -- set kind
     set_kind("binary")
     set_targetdir("$(buildir)/out")
-    add_defines("__BUILD_APP__","__BUILD_OS__","CMB_USING_OS_PLATFORM","CMB_OS_PLATFORM_TYPE=CMB_OS_PLATFORM_FREERTOS")
+    add_defines("__BUILD_APP__","__BUILD_OS__","CMB_USING_OS_PLATFORM","CMB_OS_PLATFORM_TYPE=CMB_OS_PLATFORM_FREERTOS",luatos_define)
 
 if with_luatos then
     on_load(function (target)
@@ -260,7 +260,7 @@ if with_luatos then
     add_files(luatos.."luat/modules/*.c")
     add_files(luatos.."luat/vfs/*.c")
     remove_files(luatos.."luat/vfs/luat_fs_posix.c")
-
+    add_files(luatos.."components/common/*.c")
     add_files(luatos.."components/lcd/*.c")
     add_files(luatos.."components/sfd/*.c")
     add_files(luatos.."components/sfud/*.c")
@@ -282,6 +282,7 @@ if with_luatos then
     add_includedirs("application/include",{public = true})
     add_includedirs(luatos.."lua/include",{public = true})
     add_includedirs(luatos.."luat/include",{public = true})
+    add_includedirs(luatos.."components/common",{public = true})
     add_includedirs(luatos.."components/lcd",{public = true})
     add_includedirs(luatos.."components/sfud",{public = true})
     add_includedirs(luatos.."components/statem",{public = true})