update: 结合sys.lua的核心消息机制重新跑起来了

之前出问题的原因是luat_lib_rtos的return msg.handler写错参数

luat/inculde/luat_msgbus.h

@@ -14,14 +14,14 @@ typedef int (*luat_msg_handler) (lua_State *L, void* ptr);
 typedef struct rtos_msg{
     luat_msg_handler handler;
     void* ptr;
-}rtos_msg;
+}rtos_msg_t;
 
 
 // 定义接口方法
 void luat_msgbus_init(void);
-void* luat_msgbus_data();
-uint32_t luat_msgbus_put(struct rtos_msg* msg, size_t timeout);
-uint32_t luat_msgbus_get(struct rtos_msg* msg, size_t timeout);
+//void* luat_msgbus_data();
+uint32_t luat_msgbus_put(rtos_msg_t* msg, size_t timeout);
+uint32_t luat_msgbus_get(rtos_msg_t* msg, size_t timeout);
 uint32_t luat_msgbus_freesize(void);
 
 #endif

luat/inculde/luat_timer.h

@@ -4,10 +4,10 @@
 #include "luat_base.h"
 #include "luat_msgbus.h"
 
-typedef struct luat_timer_t
+typedef struct luat_timer
 {
-    uint32_t id;
     void* os_timer;
+    size_t id;
     size_t timeout;
     size_t type;
     size_t repeat;
@@ -15,8 +15,8 @@ typedef struct luat_timer_t
 }luat_timer_t;
 
 
-int luat_timer_start(struct luat_timer_t* timer);
-int luat_timer_stop(struct luat_timer_t* timer);
+int luat_timer_start(luat_timer_t* timer);
+int luat_timer_stop(luat_timer_t* timer);
 
 
 int luat_timer_mdelay(size_t ms);

luat/modules/luat_lib_rtos.c

@@ -8,15 +8,15 @@
 
 //------------------------------------------------------------------
 static int l_rtos_receive(lua_State *L) {
-    struct rtos_msg msg;
+    rtos_msg_t msg;
     int re;
     re = luat_msgbus_get(&msg, luaL_checkinteger(L, 1));
     if (!re) {
-        luat_print("luat_msgbus_get msg!!!\n");
-        return msg.handler(L, &msg);
+        // luat_print("luat_msgbus_get msg!!!\n");
+        return msg.handler(L, msg.ptr);
     }
     else {
-        luat_print("luat_msgbus_get timeout!!!\n");
+        // luat_print("luat_msgbus_get timeout!!!\n");
         lua_pushinteger(L, -1);
         return 1;
     }
@@ -24,8 +24,8 @@ static int l_rtos_receive(lua_State *L) {
 
 //------------------------------------------------------------------
 static int l_timer_handler(lua_State *L, void* ptr) {
-    luat_print("l_timer_handler\n");
-    struct luat_timer_t *timer = (struct luat_timer_t *)ptr;
+    luat_timer_t *timer = (luat_timer_t *)ptr;
+    // luat_printf("l_timer_handler id=%ld\n", timer->id);
     lua_pushinteger(L, MSG_TIMER);
     lua_pushinteger(L, timer->id);
     lua_pushinteger(L, timer->timeout);
@@ -42,20 +42,25 @@ static int l_timer_handler(lua_State *L, void* ptr) {
 
 static int l_rtos_timer_start(lua_State *L) {
     lua_gettop(L);
-    lua_Integer id = luaL_checkinteger(L, 1);
-    lua_Integer timeout = luaL_checkinteger(L, 2);
-    lua_Integer repeat = luaL_optinteger(L, 3, 0);
-    //luat_printf("timer id=%lld ms=%lld repeat=%lld\n", id, ms, repeat);
-    if (timeout < 1)
-        return 0;
-    struct luat_timer_t *timer = (struct luat_timer_t *)luat_heap_malloc(sizeof(struct luat_timer_t));
+    size_t id = (size_t)luaL_checkinteger(L, 1) / 1;
+    size_t timeout = (size_t)luaL_checkinteger(L, 2);
+    size_t repeat = (size_t)luaL_optinteger(L, 3, 0);
+    // luat_printf("timer id=%ld\n", id);
+    // luat_printf("timer timeout=%ld\n", timeout);
+    // luat_printf("timer repeat=%ld\n", repeat);
+    if (timeout < 1) {
+        lua_pushinteger(L, 0);
+        return 1;
+    }
+    luat_timer_t *timer = (luat_timer_t*)luat_heap_malloc(sizeof(luat_timer_t));
     timer->id = id;
     timer->timeout = timeout;
     timer->repeat = repeat;
     timer->func = &l_timer_handler;
 
     luat_timer_start(timer);
-    lua_pushlightuserdata(L, timer);
+    //lua_pushlightuserdata(L, timer);
+    lua_pushinteger(L, 1);
 
     return 1;
 }

luat/rtt/luat_msgbus_rtt.c

@@ -9,7 +9,7 @@
 
 static rt_uint8_t msg_pool[4*1024];
 static struct rt_messagequeue mq;
-static void *msgdata = {0};
+// static void *msgdata = {0};
 
 void luat_msgbus_init(void) {
     rt_err_t result;
@@ -17,32 +17,32 @@ void luat_msgbus_init(void) {
     /* 初始化消息队列 */
     result = rt_mq_init(&mq,
                         "mqt",
-                        &msg_pool[0],             /* 内存池指向 msg_pool */
-                        sizeof(struct rtos_msg),        /* 每个消息的大小是 8 字节 */
-                        sizeof(msg_pool),        /* 内存池的大小是 msg_pool 的大小 */
-                        RT_IPC_FLAG_FIFO);       /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
+                        &msg_pool[0],              /* 内存池指向 msg_pool */
+                        sizeof(rtos_msg_t),        /* 每个消息的大小是 8 字节 */
+                        4*1024,                    /* 内存池的大小是 msg_pool 的大小 */
+                        RT_IPC_FLAG_FIFO);         /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
     if (result) {
         // pass
     }
 }
 
-void* luat_msgbus_data() {
-    return msgdata;
-}
+// void* luat_msgbus_data() {
+//     return msgdata;
+// }
 
-uint32_t luat_msgbus_put(struct rtos_msg* msg, size_t timeout) {
-    return rt_mq_send(&mq, msg, sizeof(struct rtos_msg));
+uint32_t luat_msgbus_put(rtos_msg_t* msg, size_t timeout) {
+    return rt_mq_send(&mq, msg, sizeof(rtos_msg_t));
 }
 
-uint32_t luat_msgbus_get(struct rtos_msg* msg, size_t timeout) {
+uint32_t luat_msgbus_get(rtos_msg_t* msg, size_t timeout) {
     rt_err_t result;
-    result = rt_mq_recv(&mq, msg, sizeof(struct rtos_msg), timeout);
+    result = rt_mq_recv(&mq, msg, sizeof(rtos_msg_t), timeout);
     if (result == RT_EOK) {
-        msgdata = msg->ptr;
+        // msgdata = msg->ptr;
         return 0;
     }
     else {
-        msgdata = NULL;
+        // msgdata = NULL;
         return result;
     }
 }

luat/rtt/luat_timer_rtt.c

@@ -8,35 +8,40 @@
 static char timer_name[32];
 
 static void rt_timer_callback(void *param) {
-    rt_kprintf("rt_timer_callback begin!!\n");
-    struct rtos_msg msg;
-    struct luat_timer_t *t = (struct luat_timer_t*)param;
-    msg.handler = t->func;
+    //rt_kprintf("rt_timer_callback begin!!\n");
+    rtos_msg_t msg;
+    luat_timer_t *timer = (luat_timer_t*)param;
+    msg.handler = timer->func;
     msg.ptr = param;
     luat_msgbus_put(&msg, 1);
-    rt_kprintf("rt_timer_callback end!!\n");
+    //rt_kprintf("rt_timer_callback end!! id=%ld msg=%ld\n", timer->id, param);
 }
 
-int luat_timer_start(struct luat_timer_t* timer) {
-    sprintf(timer_name, "t%ld", timer->id);
+int luat_timer_start(luat_timer_t* timer) {
+    // luat_printf("rtt timer id=%ld\n", timer->id);
+    // luat_printf("rtt timer timeout=%ld\n", timer->timeout);
+    // luat_printf("rtt timer repeat=%ld\n", timer->repeat);
+
+    rt_sprintf(timer_name, "t%ld", timer->id);
+    //luat_printf("rtt timer name=%s\n", timer_name);
     rt_tick_t time = timer->timeout;
     rt_uint8_t flag = timer->repeat ? RT_TIMER_FLAG_PERIODIC : RT_TIMER_FLAG_ONE_SHOT;
     rt_timer_t r_timer = rt_timer_create(timer_name, rt_timer_callback, timer, time, flag);
     if (r_timer == NULL) {
-        rt_kprintf("rt_timer_create FAIL\n");
+        //rt_kprintf("rt_timer_create FAIL\n");
         return 1;
     }
     if (rt_timer_start(r_timer) != RT_EOK) {
-        rt_kprintf("rt_timer_start FAIL\n");
+        //rt_kprintf("rt_timer_start FAIL\n");
         rt_timer_delete(r_timer);
         return 1;
     };
     timer->os_timer = r_timer;
-    rt_kprintf("rt_timer_start complete!!\n");
+    //rt_kprintf("rt_timer_start complete!!\n");
     return 0;
 }
 
-int luat_timer_stop(struct luat_timer_t* timer) {
+int luat_timer_stop(luat_timer_t* timer) {
     if (!timer)
         return 0;
     if (!timer->os_timer)