add: 添加已经完成的文档

markdown/core/flash_zone.md

@@ -0,0 +1,11 @@
+# Flash分区
+
+## 各区域分配
+
+
+|分区名     |内容           |格式|起始地址|大小|
+|----------|---------------|-------|----|---|
+|system    | 代码区    |  hex    |   |  |
+|lua_vm    | lua虚拟机本身  |  hex     |   |  |
+|lua_libs  | lua库          |  hex   |   |  |
+|lua_files | 用户脚本        |littlefs |   |  |

markdown/core/luat_api.md

@@ -0,0 +1,181 @@
+# Luat API列表
+
+当前手工维护, 待项目完善后, 使用工具自动生成
+
+## 核心API
+
+场景: 每隔5分钟唤醒一次/按键唤醒, 读取gpio状态, 写uart数据, 联网发送数据到服务器, 再次进入低功耗模式
+
+功能所需:
+* sys     -- 支撑整个流程
+* timer   --  支撑定时唤醒和流程控制
+* 流程控制 --  等待联网
+* pm      --  进入低功耗
+* gpio    --  读取gpio状态/按键唤醒
+* uart    --  写串口数据
+* socket  --  联网读写数据
+* lwm2m   --  电信卡联网读写数据
+* device  --  设备信息,联网数据中包含设备识别号(imei)
+
+--------------------------------------------------------------
+### API列表
+
+```lua
+-- 底层相关
+sys.run(mode)                    -- rtos核心机制启动,总是main.lua最后一句
+sys.restart(reson)               -- 重启
+sys.reson()                      -- 系统的原因(按键开机/定时器唤醒/中断唤醒...)
+
+-- 功耗管理
+pm.mode(pm.IDLE)                 -- 进入指定功耗模式
+
+-- 定时器
+timer.start(timer_type, timeout, callback, arg1, ...) -- 启动一个定时器
+timer.stop(id)                  -- 停止一个定时器
+
+-- 流程控制相关
+task.wait(timeout)              -- 当前协程让出调度权
+task.waitUtil(topic, timeout)   -- 等待topic发布,或超时
+task.publish(topic, arg1, ...)  -- 发布topic消息
+task.subscribe(topic, func)     -- 订阅topic消息
+task.start(func, arg1, ...)     -- 启动一个协程
+
+-- 低功耗相关
+lpmem.write(pos, data)          -- 写数据到不掉电内存
+lpmen.read(pos, len)            -- 从不掉电内读数据
+
+-- GPIO相关
+pmu.ldo(zone, mode)             -- 设置电压域
+gpio.setup(pin, mode, pullup,func) -- 设置GPIO脚的功能
+gpio.set(pin, value)            -- 设置输出电平
+gpio.get(pin, value)            -- 获取输入电平
+gpio.odr(pin)                   -- 获取输出电平
+
+-- UART相关
+uart.setup(id, bandrate, bit, nor, stop_bit) -- 配置uart
+uart.write(id, data)             -- 发送数据到UART
+uart.read(id, maxLen)           -- 读取数据
+uart.close(id)                  -- 关闭uart
+uart.on(event, callback)        -- uart的事件回调
+uart.tnow(id, pin,nor)          -- 485控制管脚 
+
+-- socket相关
+socket.ready()                  -- 判断是否已经附着到网络
+socket.new(mode, cert)          -- 新建一个socket, mode可以是tcp/udp等
+socket:select(msg_id)           -- 等待消息
+socket:connect(host, port, timeout) -- 建立连接
+socket:send(data, callback)     -- 发送数据
+socket:recv(timeout, callback)  -- 接收数据
+socket:read(maxLen)             -- 从缓冲区读取数据
+socket:write(data)              -- 将数据写入缓冲区
+socket:close()                  -- 关闭连接
+socket:on(event, callback)      -- 各种回调
+
+-- lwm2m 相关
+lwm2m.xxx                       -- 与socket类似
+
+-- coap相关
+coap.xxx                        -- 与socket类似
+
+-- 系统信息
+device.imei()                   -- 设备IMEI
+device.sn(val)                  -- 设备SN, 填入参数就设置sn, 不填就返回sn
+device.version()                -- 设备版本号
+device.muid()                   -- 设备识别号
+
+-- SIM卡相关
+sim.iccid()                     -- SIM的ICCID
+sim.imsi()                      -- 设备IMSI
+
+-- 网络状态相关
+modem.cellInfo()                -- 基站信息
+modem.csq()                     -- 信号强度
+modem.stat()                    -- 网络状态
+```
+
+--------------------------------------------------------------
+### 设想的lua代码
+```lua
+-- 定时发送GPIO1的状态到服务器
+
+local TG = 1
+gpio.setup(TG, gpio.INPUT, gpio.PULLUP)
+uart.setup(1)
+
+task.taskInit(function()
+    task.waitUtil("IP_READY", 60000) -- 等待联网,最多60秒
+    -- 读取设备信息
+    local imei = device.imei()
+    local iccid = sim.iccid()
+    local stat = gpio.get(TG)
+    local str = imei .. "," .. iccid .. "," .. stat
+    -- 写入uart
+    uart.write(1, str .. "\r")
+    -- 发送到服务器
+    local u = socket.create("udp", "udplab.openluat.com", 123456)
+    -- u:connect(30000)
+    u:send(imei .. "," .. iccid .. "," .. stat)
+    u:close()
+    -- 启动定时器, 5分钟后唤醒
+    timer.start(timer.hw, 5*60*1000)
+    -- 进入低功耗模式
+    pm.mode(pm.PM2)
+end)
+
+sys.run() -- TODO 反正都写这句,那就干脆去掉?
+```
+
+### 设想LUA代码2
+```lua
+-- 以下demo代码基于如下场景：
+--1. GPIO1为RETIO（深睡眠仍然可以唤醒的io），高电平工作在SLEEP1模式，低电平工作在IDLE模式
+--2. 串口1透传udp://udplab.openluat.com:8888
+
+pm.mode(pm.IDLE) -- 功耗管理工作在idle模式
+
+-- gpio1 功耗模式管理
+gpio.setup(1, gpio.INPUT, gpio.PULLUP, function(value)
+    pm.mode(value == 1 and pm.PM1 or pm.IDLE)
+end)
+
+uart.setup(1, ...)
+
+uart.on(1, 'recv', function(len)
+    sys.publish('SEND_REQ', uart.read(1, len))
+end)
+
+task.init(function()
+    while true do
+        if not socket.ready() then
+            task.wait('IP_READY')
+        end
+
+        local c = socket.new('udp')
+
+        if c:connect('udplab.openluat.com', 8888) then
+            local loop = true
+            while loop do
+                local r, d = c:recv('SEND_REQ')
+                if r == 'data' then
+                    uart.write(1, d)
+                elseif r == 'msg' then
+                    for _, v in ipairs(d) do
+                        if not c:send(v) then
+                            loop = false
+                            log.warn('demo', 'socket send error', socket.errorno())
+                            break
+                        end
+                    end
+                elseif r == 'error' then
+                    loop = false
+                    log.warn('demo', 'socket recv error', socket.errorno())
+                end
+            end
+        else
+            log.warn('demo', 'socket conn error', socket.errorno())
+        end
+        c:close()
+    end
+end)
+```
+

markdown/core/luat_core.md

@@ -0,0 +1,84 @@
+# Luat核心
+
+## 基本信息
+
+* 起草日期: 2019-11-25
+* 设计人员: [wendal](https://github.com/wendal)
+
+## Luat核心是怎么个存在
+
+总得来说, Luat核心就是运行luat脚本的最基本设施及核心流程
+
+### 最基本的设施包含
+
+* Lua虚拟机 -- 负责解析和执行脚本
+* 消息总线  -- 与宿主rtos系统进行单向信息传递
+* 文件系统  -- 读写文件,对核心来说,是读取lua脚本
+* 定时器    -- 脚本内的延时机制
+
+### 核心流程(Lua表达)
+
+基于消息总线的响应式处理
+
+```lua
+while 1 do
+    local msgtype, msgdata = rtos.receive(0)
+    if msgtype and handlers[msgtype] then
+        handlers[msgtype](msgtype, msgdata)
+    end
+end
+```
+
+逐行描述
+```lua
+-- 最外层,是一个无穷循环, 除非出错,否则永不退出
+while 1 do
+    -- 从消息队列接收信息, 无限等待
+    -- msgtype是消息的类型,总是一个数值
+    -- msgdata是消息的内容,不一定存在
+    local msgtype, msgdata = rtos.receive(0)
+    -- handlers是消息处理器的table
+    if msgtype and handlers[msgtype] then
+        -- 如果存在对应msgtype的处理器,则执行之
+        handlers[msgtype](msgtype, msgdata)
+    end
+end
+```
+
+## 核心流程(C层面)
+
+```c
+void luat_main(luaState* L) {
+    rtos_msg msg;
+    uint32_t re;
+    size_t timeout = 1000; // 每1000个tick喂一次狗
+    while (1) {
+        // 执行pub/sub队列
+
+        re = luat_msgbus_get(&msg, timeout);
+        if (re) {
+            // TODO喂狗
+        }
+        else {
+            switch(msg.msgtype) {
+            case MSG_TIMER:
+                // 清理堆栈,执行回调
+                luaL_pushfunction(L, msg.data);
+                luaL_pcall(...);
+                break;
+            case MSG_GPIO:
+                // 根据gpio的id, 执行回调
+                break;
+            case ...
+            }
+        }
+        // 检查堆栈, 继续下一轮
+    }
+}
+```
+
+## 相关知识点
+
+* [定时器](luat_timer.md)
+* [消息总线](luat_msgbus.md)
+* [文件系统](luat_fs.md)

markdown/core/luat_fs.md

@@ -0,0 +1,45 @@
+# 文件系统
+
+## 基本信息
+
+* 起草日期: 2019-11-28
+* 设计人员: [wendal](https://github.com/wendal)
+
+## 为什么需要文件系统
+
+* mcu内置一片flash区域或外部flash
+* 使用该区域存放lua脚本及其他文件
+* 将来可能还需要使用fatfs挂载sd卡
+
+## 设计思路和边界
+
+* 提供文件操作的lua api(增删改查), 用法与lua原生的io模块相同
+* 提供lua虚拟机读取lua脚本的C API
+* 额外提供获取文件系统信息的api, 包括C和lua
+
+## C API
+
+```c
+Luat_FILE luat_fs_fopen(char const* _FileName, char const* _Mode);
+uint8_t luat_fs_getc(Luat_FILE stream);
+uint8_t luat_fs_fseek(Luat_FILE stream, long offset, int origin);
+uint32_t luat_fs_ftell(Luat_FILE stream);
+uint8_t luat_fs_fclose(Luat_FILE stream);
+uint8_t luat_log_print(char *buf, len);
+```
+
+## Lua API
+
+基础API, 与原生io模块相同
+
+### 遍历文件夹
+
+```lua
+local names = io.lsdir("/ldata/") 
+```
+
+
+## 相关知识点
+
+* [Luat核心机制](luat_core.md)
+

markdown/core/luat_memory.md

@@ -0,0 +1,60 @@
+# 内存池
+
+## 基本信息
+
+* 起草日期: 2019-11-25
+* 设计人员: [wendal](https://github.com/wendal)
+
+## 为什么需要内存池
+
+* 一段连续的区域分配给用户使用, 独立于系统的heap
+* 这个内存区间的大小介于 64k ~ 100k
+* Lua虚拟机及相关全局变量应该使用该区域
+
+## 设计思路和边界
+
+* 使用freertos的heap_4作为原型
+* 额外提供一个用Lua虚拟机的alloc方法
+* 提供API查询剩余内存
+* API应该只涉及内存申请与释放,不做其他事情.
+
+## C API
+
+### 定义内存池总大小
+
+```c
+#define LUAT_MALLOC_HEAP_SIZE ((size_t) 85 * 1024)
+```
+
+### 
+
+```c
+// 初始化内存
+void  luat_heap_init(void);
+// 申请内存
+void* luat_heap_malloc(size_t len); // 如果失败,返回NULL
+// 释放内存
+void  luat_heap_free(void* ptr);
+// 缩放内存块
+void* luat_heap_realloc(void* ptr, size_t len);
+// 申请内存并填充0
+void* luat_heap_calloc(size_t len);
+// 获取剩余内存
+size_t luat_heap_getfree(void);
+// Lua所需要的alloc方法
+void* luat_heap_alloc(void *ud, void *ptr, size_t osize, size_t nsize);
+```
+
+## Lua API
+
+```lua
+-- 获取总内存数量
+mem.total_count()
+-- 获取剩余内存数量
+mem.free_count()
+```
+
+## 相关知识点
+
+* [Luat核心机制](luat_core.md)
+

markdown/core/luat_msgbus.md

@@ -0,0 +1,77 @@
+# 消息总线
+
+## 基本信息
+
+* 起草日期: 2019-11-25
+* 设计人员: [wendal](https://github.com/wendal)
+
+## 为什么需要消息总线
+
+1. 底层是rtos, lua虚拟机运行在一个thread中
+2. rtos要求一个线程必须在空闲时让出cpu资源,不能以死循环方式实现`延时`
+3. lua以单线程执行,对`中断`运行并不友好
+4. 定时器/GPIO中断/UART数据进入/网络数据进入,都属于`中断`
+5. 通过消息总线的方式,让`中断`信息以生产者的方式存在, 由`rtos.receive`作为消费者
+
+## 设计思路和边界
+
+1. 只涉及消息的收取和支出
+2. 使用固定大小的消息体,节省内存资源
+
+## 数据结构
+
+消息体以4字节对齐的方式存在
+
+```c
+struct RtosMsg {
+    uint32_t msgtype;
+    uint32_t msgdata;
+} rtos_msg;
+
+#define LUAT_MSGBUS_ITEMCOUNT ((size_t)0xFF)
+```
+
+其中
+
+* msgtype 消息类型
+* msgdata 消息负载,有具体消息类型决定
+
+## C API
+
+使用CMSIS_OS_v2的 Queue API进行操作, put和get操作
+
+### 发送消息
+
+```c
+uint32_t luat_msgbus_put(rtos_msg* msg, size_t timeout);
+uint32_t luat_msgbus_get(rtos_msg* msg, size_t timeout);
+uint32_t luat_msgbus_freesize(void);
+```
+
+### Luat 调试 API
+
+下列API用于debug, 不一定实现, 本模块暂不提供用户Lua API
+
+```lua
+--  获取剩余当前队列的长度
+rtos.msgbus_current_size() -- 返回数值
+-- 获取队列里面的全部消息,有可能为空队列
+rtos.msgbus_list() -- 返回 [[msgtype, msgdata], ...]
+-- 清空队列
+rtos.msgbus_clear() -- 无返回
+-- 放入一个消息
+rtos.msgbuf_send(msgtype, msgdata) -- 无返回
+```
+
+## 可用消息类型
+
+|消息类型|消息数据|备注|
+|--------|-------|----|
+|MSG_TIMER|FUNC|定时器|
+|MSG_UART_RXDATA|UART_ID, LEN|串口接收|
+|MSG_UART_TX_DONE|UART_ID|串口发送完成|
+|MSG_INT|GPIO_ID,INT|GPIO中断|
+
+## 相关知识点
+
+* [Luat核心机制](luat_core.md)

markdown/core/luat_platform.md

@@ -0,0 +1,127 @@
+# Luat 平台层
+
+为了跨平台, 需要一个"平台层"来隔离不同底层的实现
+
+
+## 为什么需要"平台层"
+
+* Lua的C语言实现, 代码基本上跨平台,但不是全部
+* Luat作为对硬件平台的封装,需要抽象为HAL
+* 还有一点, 就是对任务调度的抽象,包括定时器和消息队列
+
+----------------------------------------------------------------------------------
+## Lua 的跨平台
+
+这里讨论的是`Lua 5.3.5`.
+
+Lua 基本上是跨平台, 可以认为是95%以上, 以下为需要抽象的平台功能
+
+----------------------------------------------------------------------------------
+### 内存分配
+
+lua没有一个全局变量, 所有内存都是通过 `lua_newstate(l_alloc, NULL)` 的`l_alloc`参数(一个方法指针) 来分配.
+
+原形如下
+
+```c
+void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize)
+```
+
+所以, 我们需要定义一个抽象的C API
+
+```c
+void* luat_heap_alloc(void *ud, void *ptr, size_t osize, size_t nsize);
+```
+
+详细的API设计, 在 [内存池](luat_memory.md) 中定义, 其中还有`malloc`的抽象形式 `luat_heap_malloc`
+
+----------------------------------------------------------------------------------
+### io 操作
+
+lua的io操作涉及4个方面
+* `loadfile` 加载lua文件, 涉及 `fopen`/`fread`/`close` 等方法
+* `lua_writestring` 原始实现是把数据传给标准输出(stdout)
+* io库, 涉及`fopen`/`fread`/`fseek`/`close`/`feof`/`ferror` 等POSIX常用方法
+* debug库, 涉及`getc`方法, 从标准输入(stdin)读取用户输入
+
+```c
+Lua_FILE * luat_fs_fopen(char const* _FileName, char const* _Mode);
+```
+
+详细的API设计, 在 [文件系统](luat_fs.md) 中定义
+
+这部分的修改, 是需要改动lua源码的, 替换原有的api调用
+
+----------------------------------------------------------------------------------
+### lua里面的系统API
+
+lua里面与系统密切相关的API, 分别是
+
+```c
+time()    // os模块,获取系统时间, 需要支持
+popen()   // io/os模块,启动一个新进程, 不需要支持,相关lua API删除
+pclose()  // io/os模块, 关闭进程, 不需要支持,相关lua API删除
+exit()    // 关闭lua所在的进程, 不需要支持,相关lua API删除
+```
+
+可见, 只有time方法是必须实现的, 而time的实现跟具体平台强相关, 所以必须抽象
+
+```c
+uint8_t luat_os_get_time(*time_t);
+```
+
+----------------------------------------------------------------------------------
+## Luat 的跨平台
+
+对设备接口和网络通信的封装, 本质上就是对厂商私有API的封装.
+
+----------------------------------------------------------------------------------
+### 外设
+
+外设大多是同步API, 这C API 与 Lua API会非常相像
+
+```c
+uint8_t luat_gpio_setup(LuatGpioPin pin, Lua_Value value, LuatGpioPULL pullup);
+```
+
+```lua
+local LED = 33
+gpio.setup(LED, gpio.LOW, gpio.PULLUP)
+```
+
+----------------------------------------------------------------------------------
+### 网络通信
+
+这部分非常依赖于厂商的SDK, 如果假设均提供lwip之类的通信封装,则这部分没有太多的内容.
+
+如果假设不存在lwip之类的封装, 则需要非常详尽的API设计(照抄lwip也未尝不可)
+
+TODO 待完成网络通信的API设计
+
+----------------------------------------------------------------------------------
+## 任务调度
+
+
+那Luat依赖任务调度相关的API, rtos层
+
+* 定时器 timer   --  单次/循环触发中断
+* 消息队列 queue --  消息排队处理
+* 信号量 sem     --  预留
+
+从原理上说, 即使没有rtos, 只要实现上述3组API, Luat跑着裸板上也是没有问题的.
+
+能跑Luat的硬件, 其资源肯定能跑rtos. 是否使用rtos, 由厂商SDK决定.
+
+所以, 上面3组API, 也有对应的抽象
+
+* [定时器](luat_timer.md)
+* [消息总线](luat_msgbus.md)
+* [信号量]() 暂无场景支撑,未设计
+
+## 相关知识点
+
+* [编码规范](../proj/code_style.md)
+* [文件系统](luat_fs.md)
+* [定时器](luat_timer.md)
+* [消息总线](luat_msgbus.md)
+* [内存池](luat_memory.md)

markdown/core/luat_pm.md

@@ -0,0 +1,42 @@
+# 电源及低功耗管理
+
+## 基本信息
+
+* 起草日期: 2019-11-28
+* 设计人员: [wendal](https://github.com/wendal)
+
+## 为什么需要电源及低功耗管理
+
+* mcu通常提供多个低功耗级别,部分级别可以继续运行lua, 部分只能跑C
+
+## 设计思路和边界
+
+* 管理并抽象电源的C API, 提供一套Lua API供用户代码调用
+* 用户可申请直接进入指定的低功耗级别
+
+## C API(平台层)
+
+```C
+uint32_t luat_pm_mode(uint8_t mode);
+```
+
+## Lua API
+
+## 常量
+
+```lua
+pm.IDLE   -- 空闲模式,功耗高
+pm.SLEEP1 -- 休眠模式1, 主内存不掉电,低功耗内存(lpmem)掉电
+pm.SLEEP2 -- 休眠模式2, 主内存掉电,低功耗内存(lpmem)不掉电
+pm.HIB    -- 停止模式, 仅timer或gpio可以唤醒
+```
+
+### 进入指定的功耗级别
+
+```lua
+pm.mode(mode)
+```
+## 相关知识点
+
+* [Luat核心机制](luat_core.md)
+

markdown/core/luat_timer.md

@@ -0,0 +1,68 @@
+# Luat定时器
+
+## 基本信息
+
+* 起草日期: 2019-11-25
+* 设计人员: [wendal](https://github.com/wendal)
+
+## 为什么需要定时器
+
+1. 单次定时的需要, 例如10分钟后执行温度测量
+2. 循环定时的需要, 每5分钟联网一次,发送心跳
+3. `sys.wait`的需要, 通过定时器机制实现lua的延时执行
+
+## 设计思路和边界
+
+1. 基于rtos的timer API进行设计
+2. 定时器超时后, 生产消息并发送到 `消息总线` , 由`rtos.receive`进行消费
+3. 底层支持循环定时.
+
+## C API(平台层)
+
+### 数据结构
+
+```c
+#define LUAT_TIMER_MAXID ((size_t) 0xFFFF)
+```
+
+### 接口API
+
+```c
+uint32_t luat_timer_start(luat_timer_t* timer);
+uint32_t luat_timer_stop(luat_timer_t* timer);
+```
+
+## Lua API
+
+## 常量
+
+```lua
+timer.HW -- 硬件定时器
+timer.OS -- 软件定时器
+```
+
+### 启动定时器
+
+```lua
+-- timer_id 时钟id, 数值, 0-0xFF, 取决于LUAT_TIMER_MAXID
+-- timerout 超时时长, 数值, 1-0xFFFFFFFF, 单位毫秒
+local timer_id = timer.start(timer.OS, timeout, _repeat, function(timer_id) end)
+if not timer_id then
+    -- 启动成功
+else
+    -- 启动失败, 可能id已满或timeout值错误
+end
+```
+
+### 关闭定时器(含删除)
+
+```lua
+-- timer_id 时钟id, 数值, 0-0xFF, 取决于LUAT_TIMER_MAXID
+timer.stop(timer_id)
+-- 只要传入数值型的id, timer_stop总会成功
+```
+
+## 相关知识点
+
+* [Luat核心机制](luat_core.md)
+* [消息总线](msgbus.md)

markdown/device/luat_gpio.md

@@ -0,0 +1,48 @@
+# GPIO
+
+## 基本信息
+
+* 起草日期: 2019-12-18
+* 设计人员: [wendal](https://github.com/wendal)
+
+## 为什么需要GPIO
+
+* 读取外部输入的电平信号
+* 输出指定电平
+
+## 设计思路和边界
+
+* 管理并抽象GPIO的C API, 提供一套Lua API供用户代码调用
+
+## C API(平台层)
+
+```C
+int luat_gpio_setup(luat_gpio_t* gpio);
+int luat_gpio_set(int pin, int level);
+int luat_gpio_get(int pin);
+```
+
+## Lua API
+
+## 常量
+
+```lua
+gpio.INPUT  -- 输入模式
+gpio.OUTPUT -- 输出模式
+gpio.PULLDOWN -- 下拉
+gpio.PULLUP -- 上拉
+gpio.HIGH
+gpio.LOW
+```
+
+### 进入指定的功耗级别
+
+```lua
+gpio.setup(PIN, gpio.gpio.INPUT, function(t) end, gpio.PULLUP)
+gpio.set(PIN, gpio.HIGH)
+gpio.get(PIN)
+```
+## 相关知识点
+
+* [Luat核心机制](luat_core.md)
+

markdown/proj/code_style.md

@@ -0,0 +1,21 @@
+# 编码规范
+
+
+## C API规范
+
+* C API均以 `luat_` 开头, 后接模块名, 然后是方法名
+* 使用抽象的类型定义, 例如不使用`int`, 使用`uint32_t`
+* 使用下划线命名方式
+
+举例
+
+```c
+LUA_API void* luat_heap_alloc(void *ud, void *ptr, size_t osize, size_t nsize);
+```
+
+## Lua API 规范
+
+* 使用驼峰命名
+
+TODO lua api规范
+

markdown/proj/compare.md

@@ -0,0 +1,69 @@
+# 主要竞品分析
+
+|名称|硬件|lua版本|底层rtos|
+|----|----|------|--------|
+|NodeMCU|ESP32|5.1|自研|
+|Lua-RTOS-ESP32|ESP32|5.3|freertos|
+|eLua|多款|5.1|自研|
+|Luat|air202/air720|5.1|厂商rtos|
+|MicroPython|多款|py语言|自研|
+
+## NodeMCU
+
+官网: https://nodemcu.readthedocs.io/
+
+```
+NodeMCU is an open source Lua based firmware for the ESP8266 WiFi SOC from Espressif and uses an on-module flash-based SPIFFS file system.
+```
+
+专为esp8266/esp32设计,移植性不佳,但知名度非常高.
+
+## eLua
+
+官网: http://www.eluaproject.net/
+
+```
+eLua stands for Embedded Lua and the project aims to offer the full implementation of the Lua Programming Language to the embedded world, extending it with specific features for efficient and portable software embedded development.
+```
+
+luat最初也是从eLua开始开发,但eLua本身的开发已经半停滞,背后没有商业公司在维护.
+
+## Lua-RTOS-ESP32
+
+官网: https://github.com/whitecatboard/Lua-RTOS-ESP32
+
+```
+Lua RTOS is a real-time operating system designed to run on embedded systems, with minimal requirements of FLASH and RAM memory.
+```
+
+从eLua发展而来,底层改成freertos, lua版本也更新到5.3,支持众多外设, 由商业公司维护开发活跃.
+
+## MicroPython
+
+官网: https://micropython.org/
+
+```
+MicroPython is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimised to run on microcontrollers and in constrained environments.
+```
+
+https://micropython.nxez.com/2019/01/15/rtt-micropython-vs-official-native-micropython.html
+
+基于python的竞品中,`MicroPython`是最有实力的了, 移植到各种平台的实现也非常多.
+
+## Luat
+
+官网: http://www.openluat.com
+
+从eLua发展而来,为Air202深度定制,最近又移植到Air720系列,沿用了eLua的底层Lua API风格,发展出LuaTask和iRTU等上层建筑.
+
+曾经存在的win32虚拟环境, 也证明当年跨平台的一些尝试. 现在有qemu加持, 移植思路就不一样了.
+
+## 意见
+
+市面上的竞品, 要么专门为esp系列设计/要么lua版本低/要么没有商业公司支撑.
+
+从API完成度说, `Lua-RTOS-ESP32`是非常不错的产品,但其源码组织方式,在源码中大量使用`#ifdef`区分不同的场景,使得其可移植性大打折扣.
+
+`eLua`和`nodeMCU`均基于`Lua 5.1.x`,其代码具有参考价值.
+
+`MicroPython`是需要重视的对手.

markdown/proj/project_manager.md

@@ -0,0 +1,4 @@
+# 项目管理
+
+## 项目角色
+

markdown/proj/system_struct.md

@@ -0,0 +1,25 @@
+# 平台架构
+
+## 总体架构
+
+![](EC616_core_struct_v20191125.jpg)
+
+## Luat核心流程
+
+1. 系统启动,创建消息队列
+2. 注册周边回调函数
+3. 执行lua脚本
+4. lua脚本轮训等待消息队列
+
+
+```lua
+while 1 do
+    local msg = rtos.receive(0)
+    if msg then
+        handle(msg)
+    end
+end
+```
+
+![](EC616_core_workflow_v20191125.jpg)
+