update:适应新的luat_rtos

components/ethernet/common/platform_def.h

@@ -7,7 +7,7 @@
 #define platform_send_event luat_send_event_to_task
 #define platform_wait_event luat_wait_event_from_task
 
-#define platform_create_task	luat_thread_start
+#define platform_create_task	luat_rtos_task_create
 #define platform_get_current_task luat_get_current_task
 #define platform_task_sleep	luat_timer_mdelay
 #define platform_create_timer	luat_create_rtos_timer

components/ethernet/w5500/w5500.c

@@ -1873,15 +1873,9 @@ void w5500_init(luat_spi_t* spi, uint8_t irq_pin, uint8_t rst_pin, uint8_t link_
 		w5500->dhcp_client.state = DHCP_STATE_NOT_WORK;
 		uid = luat_mcu_unique_id(&t);
 		memcpy(w5500->mac, &uid[10], 6);
-		luat_thread_t thread;
-		thread.task_fun = w5500_task;
-		thread.name = "w5500";
-		thread.stack_size = 4 * 1024;
-		thread.priority = 3;
-		thread.userdata = w5500;
-		platform_create_task(&thread);
+		platform_create_task(&w5500->task_handle, 4 * 1024, 30, "w5500", w5500_task, w5500, 64);
 		prv_w5500_ctrl = w5500;
-		w5500->task_handle = thread.handle;
+
 		prv_w5500_ctrl->device_on = 1;
 		prv_w5500_ctrl->Sem = luat_mutex_create();
 	}

components/network/lwip/port/net_lwip.c

@@ -757,7 +757,7 @@ uint32_t net_lwip_rand()
 
 void net_lwip_init(void)
 {
-	luat_thread_t thread;
+
 	uint8_t i;
 	for(i = 0; i < MAX_SOCK_NUM; i++)
 	{
@@ -772,12 +772,7 @@ void net_lwip_init(void)
 	prvlwip.dhcp_timer = platform_create_timer(net_lwip_timer_cb, (void *)EV_LWIP_DHCP_TIMER, 0);
 	tcp_ticks = luat_mcu_tick64_ms() / TCP_SLOW_INTERVAL;
 	prvlwip.last_sleep_ms = luat_mcu_tick64_ms();
-	thread.task_fun = net_lwip_task;
-	thread.name = "lwip";
-	thread.stack_size = 16 * 1024;
-	thread.priority = 40;
-	platform_create_task(&thread);
-	prvlwip.task_handle = thread.handle;
+	platform_create_task(&prvlwip.task_handle, 16 * 1024, 40, "lwip", net_lwip_task, NULL, 64);
 	lwip_init();
 	platform_start_timer(prvlwip.common_timer, 1000, 1);
 

luat/include/luat_rtos.h

@@ -2,77 +2,85 @@
 #define LUAT_RTOS_H
 
 #include "luat_base.h"
-//定时器回调函数需要定义成 LUAT_RT_RET_TYPE fun_name(LUAT_RT_CB_PARAM)
-//定时器回调函数退出时需要， return LUAT_RT_RET;
-#ifndef LUAT_RT_RET_TYPE
-#define LUAT_RT_RET_TYPE	void
-#endif
+#include "luat_rtos_legacy.h"
 
-#ifndef LUAT_RT_RET
-#define LUAT_RT_RET
-#endif
+typedef LUAT_RT_RET_TYPE (*call_back_fun_t)(LUAT_RT_CB_PARAM);
 
-#ifndef LUAT_RT_CB_PARAM
-#define LUAT_RT_CB_PARAM	void
-//#define LUAT_RT_CB_PARAM	void *param
-//#define LUAT_RT_CB_PARAM void *pdata, void *param
-#endif
-/* ----------------------------------- thread ----------------------------------- */
-typedef int (*thread_entry) (void*);
-typedef void (*task_entry) (void*);
-typedef struct luat_thread{
-	union
-	{
-		int id;
-		void *handle;
-	};
-    union
-	{
-		thread_entry entry;
-		task_entry task_fun;
-	};
-    const char *name;
-    uint32_t stack_size;
-    uint32_t* task_stk;
-    uint32_t priority;
-    char* stack_buff;
-    void* userdata;
-}luat_thread_t;
-
-LUAT_RET luat_thread_start(luat_thread_t* thread);
-LUAT_RET luat_thread_stop(luat_thread_t* thread);
-LUAT_RET luat_thread_delete(luat_thread_t* thread);
-LUAT_RET luat_send_event_to_task(void *task_handle, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3);
-LUAT_RET luat_wait_event_from_task(void *task_handle, uint32_t wait_event_id, void *out_event, void *call_back, uint32_t ms);
-void *luat_get_current_task(void);
-/* ----------------------------------- semaphore ----------------------------------- */
-void *luat_semaphore_create(void);
-LUAT_RET luat_semaphore_delete(void* semaphore);
-LUAT_RET luat_semaphore_take(void* semaphore,uint32_t timeout);
-LUAT_RET luat_semaphore_release(void* semaphore);
-
-
-void *luat_mutex_create(void);
-LUAT_RET luat_mutex_lock(void *mutex);
-LUAT_RET luat_mutex_unlock(void *mutex);
-void luat_mutex_release(void *mutex);
-
-/* ----------------------------------- queue ----------------------------------- */
-
-void *luat_queue_create(size_t msgcount, size_t msgsize);
-LUAT_RET luat_queue_send(void*   queue, void* msg,  size_t msg_size, size_t timeout);
-LUAT_RET luat_queue_recv(void*   queue, void* msg, size_t msg_size, size_t timeout);
-LUAT_RET luat_queue_reset(void*   queue);
-LUAT_RET luat_queue_delete(void*   queue);
-LUAT_RET luat_queue_free(void*   queue);
-
-
-/* ----------------------------------- timer ----------------------------------- */
-void *luat_create_rtos_timer(void *cb, void *param, void *task_handle);
-int luat_start_rtos_timer(void *timer, uint32_t ms, uint8_t is_repeat);
-void luat_stop_rtos_timer(void *timer);
-void luat_release_rtos_timer(void *timer);
-
-void luat_task_suspend_all(void);
-void luat_task_resume_all(void);
+
+
+typedef enum LUAT_RTOS_WAIT
+{
+	LUAT_NO_WAIT = 0,
+	LUAT_WAIT_FOREVER = (uint32_t)0xFFFFFFFF
+}LUAT_RTOS_WAIT_E;
+
+
+
+/* ------------------------------------------------ task begin------------------------------------------------ */
+typedef void (*luat_rtos_task_entry) (void*);
+typedef void * luat_rtos_task_handle;
+//nStackSize为bytes，必须是4的倍数。nPriority是百分比，0~100,100为最高等级，由具体实现转换到底层SDK用的优先级。event_cout，当底层SDK不支持task带mailbox时，通过queue来模拟，需要设置的item_cout
+int luat_rtos_task_create(luat_rtos_task_handle *task_handle, uint32_t stack_size, uint8_t priority, const char *task_name, luat_rtos_task_entry task_fun, void* user_data, uint16_t event_cout);
+int luat_rtos_task_delete(luat_rtos_task_handle task_handle);
+int luat_rtos_task_suspend(luat_rtos_task_handle task_handle);
+int luat_rtos_task_resume(luat_rtos_task_handle task_handle);
+
+void luat_rtos_task_suspend_all(void);
+void luat_rtos_task_resume_all(void);
+void luat_rtos_task_sleep(uint32_t ms);
+/* ------------------------------------------------ task   end------------------------------------------------ */
+
+/* ----------------------------------------------- event begin---------------------------------------------- */
+int luat_rtos_event_send(luat_rtos_task_handle task_handle, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3, uint32_t timeout);
+int luat_rtos_event_recv(luat_rtos_task_handle task_handle, uint32_t wait_event_id, luat_event_t *out_event, call_back_fun_t *callback_fun, uint32_t timeout);
+
+/* ----------------------------------------------- event end---------------------------------------------- */
+
+/* ----------------------------------------------- message begin---------------------------------------------- */
+int luat_rtos_message_send(luat_rtos_task_handle task_handle, uint32_t message_id, void *p_message);
+int luat_rtos_message_recv(luat_rtos_task_handle task_handle, uint32_t *message_id, void **p_p_message, uint32_t timeout);
+/* ----------------------------------------------- message   end---------------------------------------------- */
+
+
+
+/* ---------------------------------------------- semaphore begin--------------------------------------------- */
+typedef void * luat_rtos_semaphore_t;
+
+int luat_rtos_semaphore_create(luat_rtos_semaphore_t *semaphore_handle, uint32_t init_count);
+int luat_rtos_semaphore_delete(luat_rtos_semaphore_t semaphore_handle);
+int luat_rtos_semaphore_take(luat_rtos_semaphore_t semaphore_handle, uint32_t timeout);
+int luat_rtos_semaphore_release(luat_rtos_semaphore_t semaphore_handle);
+/* ---------------------------------------------- semaphore   end--------------------------------------------- */
+
+
+
+/* ------------------------------------------------ mutex begin----------------------------------------------- */
+typedef void * luat_rtos_mutex_t;
+int luat_rtos_mutex_create(luat_rtos_mutex_t *mutex_handle);
+int luat_rtos_mutex_lock(luat_rtos_mutex_t mutex_handle, uint32_t timeout);
+int luat_rtos_mutex_unlock(luat_rtos_mutex_t mutex_handle);
+int luat_rtos_mutex_delete(luat_rtos_mutex_t mutex_handle);
+
+/* ------------------------------------------------ mutex   end----------------------------------------------- */
+
+
+
+/* ------------------------------------------------ queue begin----------------------------------------------- */
+typedef void * luat_rtos_queue_t;
+
+int luat_rtos_queue_create(luat_rtos_queue_t *queue_handle, uint32_t msgcount, uint32_t msgsize);
+int luat_rtos_queue_delete(luat_rtos_queue_t queue_handle);
+int luat_rtos_queue_send(luat_rtos_queue_t queue_handle, void *msg, uint32_t msg_size, uint32_t timeout);
+int luat_rtos_queue_recv(luat_rtos_queue_t queue_handle, void *msg, uint32_t msg_size, uint32_t timeout);
+/* ------------------------------------------------ queue   end----------------------------------------------- */
+
+
+
+/* ------------------------------------------------ timer begin----------------------------------------------- */
+typedef void * luat_rtos_timer_t;
+int luat_rtos_timer_create(luat_rtos_timer_t *timer_handle);
+int luat_rtos_timer_delete(luat_rtos_timer_t timer_handle);
+int luat_rtos_timer_start(luat_rtos_timer_t timer_handle, uint32_t timeout, uint8_t repeat, call_back_fun_t callback_fun, void *user_param);
+int luat_rtos_timer_stop(luat_rtos_timer_t timer_handle);
+/*------------------------------------------------ timer   end----------------------------------------------- */
 #endif

luat/include/luat_rtos_legacy.h

@@ -0,0 +1,48 @@
+#ifndef LUAT_RTOS_LEGACY_H
+#define LUAT_RTOS_LEGACY_H
+
+#include "luat_base.h"
+typedef struct
+{
+	uint32_t id;
+	uint32_t param1;
+	uint32_t param2;
+	uint32_t param3;
+}luat_event_t;
+//定时器回调函数需要定义成 LUAT_RT_RET_TYPE fun_name(LUAT_RT_CB_PARAM)
+//定时器回调函数退出时需要， return LUAT_RT_RET;
+#ifndef LUAT_RT_RET_TYPE
+#define LUAT_RT_RET_TYPE	void
+#endif
+
+#ifndef LUAT_RT_RET
+#define LUAT_RT_RET
+#endif
+
+#ifndef LUAT_RT_CB_PARAM
+#define LUAT_RT_CB_PARAM	void
+//#define LUAT_RT_CB_PARAM	void *param
+//#define LUAT_RT_CB_PARAM void *pdata, void *param
+#endif
+/* ----------------------------------- thread ----------------------------------- */
+LUAT_RET luat_send_event_to_task(void *task_handle, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3);
+LUAT_RET luat_wait_event_from_task(void *task_handle, uint32_t wait_event_id, luat_event_t *out_event, void *call_back, uint32_t ms);
+void *luat_get_current_task(void);
+
+
+
+void *luat_mutex_create(void);
+LUAT_RET luat_mutex_lock(void *mutex);
+LUAT_RET luat_mutex_unlock(void *mutex);
+
+
+
+/* ----------------------------------- timer ----------------------------------- */
+void *luat_create_rtos_timer(void *cb, void *param, void *task_handle);
+int luat_start_rtos_timer(void *timer, uint32_t ms, uint8_t is_repeat);
+void luat_stop_rtos_timer(void *timer);
+void luat_release_rtos_timer(void *timer);
+
+void luat_task_suspend_all(void);
+void luat_task_resume_all(void);
+#endif

luat/weak/luat_rtos_legacy_to_std.c

@@ -0,0 +1,64 @@
+#include "luat_base.h"
+#include "luat_rtos.h"
+#include "luat_rtos_legacy.h"
+
+LUAT_WEAK void luat_rtos_task_suspend_all(void)
+{
+	luat_task_suspend_all();
+}
+LUAT_WEAK void luat_rtos_task_resume_all(void)
+{
+	luat_task_resume_all();
+}
+LUAT_WEAK int luat_rtos_event_send(luat_rtos_task_handle task_handle, uint32_t id, uint32_t param1, uint32_t param2, uint32_t param3, uint32_t timeout)
+{
+	return luat_send_event_to_task(task_handle, id, param1, param2, param3);
+}
+LUAT_WEAK int luat_rtos_event_recv(luat_rtos_task_handle task_handle, uint32_t wait_event_id, luat_event_t *out_event, call_back_fun_t *callback_fun, uint32_t timeout)
+{
+	return luat_wait_event_from_task(task_handle, wait_event_id, out_event, callback_fun, timeout);
+}
+LUAT_WEAK int luat_rtos_message_send(luat_rtos_task_handle task_handle, uint32_t message_id, void *p_message)
+{
+	return luat_send_event_to_task(task_handle, message_id, p_message, 0, 0);
+}
+LUAT_WEAK int luat_rtos_message_recv(luat_rtos_task_handle task_handle, uint32_t *message_id, void **p_p_message, uint32_t timeout)
+{
+	luat_event_t event;
+	int result = luat_wait_event_from_task(task_handle, 0, &event, 0, timeout);
+	if (!result)
+	{
+		*message_id = event.id;
+		*p_p_message = (void *)event.param1;
+	}
+	return result;
+}
+
+LUAT_WEAK int luat_rtos_mutex_create(luat_rtos_mutex_t *mutex_handle)
+{
+	*mutex_handle = luat_mutex_create();
+	return (*mutex_handle)?0:-1;
+}
+
+LUAT_WEAK int luat_rtos_mutex_unlock(luat_rtos_mutex_t mutex_handle)
+{
+	return luat_mutex_unlock(mutex_handle);
+}
+
+LUAT_WEAK int luat_rtos_timer_create(luat_rtos_timer_t *timer_handle)
+{
+	*timer_handle = luat_create_rtos_timer(NULL, NULL, NULL);
+	return (*timer_handle)?0:-1;
+}
+
+LUAT_WEAK int luat_rtos_timer_stop(luat_rtos_timer_t timer_handle)
+{
+	luat_stop_rtos_timer(timer_handle);
+	return 0;
+}
+
+LUAT_WEAK int luat_rtos_timer_delete(luat_rtos_timer_t timer_handle)
+{
+	luat_release_rtos_timer(timer_handle);
+	return 0;
+}