嵌入式脚本语言全面对比：MicroPython、Lua、MJS、Forth 谁更适合你的 MCU？

# GPIO 控制
from machine import Pin
import time

led = Pin(2, Pin.OUT)

while True:
    led.value(1)
    time.sleep(1)
    led.value(0)
    time.sleep(1)

# I2C 通信
from machine import I2C

i2c = I2C(0, scl=Pin(1), sda=Pin(0))
devices = i2c.scan()
print("I2C 设备：", devices)

# 类与面向对象
class Sensor:
    def __init__(self, pin):
        self.pin = Pin(pin, Pin.IN)
    
    def read(self):
        return self.pin.value()

sensor = Sensor(4)
print("传感器值：", sensor.read())

-- GPIO 控制（基于 eLua）
pin_mode(2, OUTPUT)

while true do
    pin_write(2, 1)
    sleep(1000)
    pin_write(2, 0)
    sleep(1000)
end

-- 表（Table）作为核心数据结构
sensor = {
    name = "温湿度传感器",
    pin = 4,
    read = function(self)
        return adc_read(self.pin)
    end
}

print(sensor:read())

-- 协程（轻量级线程）
co = coroutine.create(function()
    for i = 1, 10 do
        print("协程执行：", i)
        coroutine.yield()
    end
end)

-- 恢复协程
while coroutine.resume(co) do
    sleep(500)
end

-- 元表（实现面向对象）
Sensor = {}
Sensor.__index = Sensor

function Sensor:new(pin)
    local s = setmetatable({}, Sensor)
    s.pin = pin
    return s
end

function Sensor:read()
    return adc_read(self.pin)
end

// C 代码中嵌入 Lua
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>

lua_State *L = luaL_newstate();
luaL_openlibs(L);

// 调用 Lua 函数
lua_getglobal(L, "my_function");
lua_pushnumber(L, 42);
lua_pcall(L, 1, 1, 0);

// 获取返回值
double result = lua_tonumber(L, -1);

lua_close(L);

// GPIO 控制
let led = Pin(2, Pin.OUT);

Timer.set(1000, Timer.REPEAT, function() {
    led.toggle();
    print("LED 状态：", led.read());
}, null);

// MQTT 连接
let mqtt_server = "mqtt://192.168.1.100";
MQTT.connect(mqtt_server, {
    user: "admin",
    pass: "public",
    on_connect: function() {
        print("MQTT 已连接");
        MQTT.sub("home/+/temp");
    },
    on_message: function(topic, msg) {
        print("主题：", topic, "消息：", msg);
    }
});

// FFI 调用 C 函数
let ffi = require("ffi");
ffi.cdef([[
    int printf(const char *fmt, ...);
    void *malloc(size_t size);
    void free(void *ptr);
]]);

ffi.C.printf("Hello from C!\n");
let ptr = ffi.C.malloc(100);
ffi.C.free(ptr);

// 异步 HTTP 请求
HTTP.fetch({
    url: "http://api.example.com/data",
    method: "GET",
    headers: {"Content-Type": "application/json"},
    success: function(body) {
        let data = JSON.parse(body);
        print("数据：", data);
    },
    error: function(err) {
        print("错误：", err);
    }
});

# 导入库（自动识别硬件）
import board
import digitalio
import time

# LED 控制（无需配置引脚）
led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT

while True:
    led.value = True
    time.sleep(0.5)
    led.value = False
    time.sleep(0.5)

# I2C 传感器（自动检测）
import adafruit_sht31d
import busio

i2c = busio.I2C(board.SCL, board.SDA)
sensor = adafruit_sht31d.SHT31D(i2c)

print("温度：%.2f°C" % sensor.temperature)
print("湿度：%.2f%%" % sensor.humidity)

# 显示屏支持
import displayio
import terminalio
from adafruit_display_text import label

text = label.Label(terminalio.FONT, text="Hello!")
text.x = 10
text.y = 20

// 低功耗 GPIO
var led = Pin("A1", {mode: OUTPUT});

// 中断处理
setWatch(function(e) {
    print("按钮按下！时间：", e.time);
}, Pin("A0"), {edge: "rising", repeat: true});

// 低功耗模式
// 休眠 10 秒，消耗仅 50μA
deepSleep(10000);

// 图形显示（支持 LCD）
g = require("Graphics").createLCD({
    width: 128, height: 64,
    buffer: new ArrayBuffer(1024)
});
g.drawString("Hello!", 10, 10);
g.flip();

// 蓝牙 BLE
NRF.setServices({
    0x1809: {  // 温度服务
        0x2A1C: {
            value: 25,
            readable: true
        }
    }
});

\ GPIO 控制（以 Mecrisp-Stellaris 为例）
: led-init  ( -- )
  5 gpio-mode-output ;  \ PA5 设为输出

: led-on  ( -- )
  5 gpio-set ;

: led-off  ( -- )
  5 gpio-clear ;

\ 闪烁 LED
: blink  ( -- )
  begin
    led-on  1000 ms
    led-off 1000 ms
  again ;

\ 堆栈操作
: square  ( n -- n² )
  dup * ;

: average  ( a b -- avg )
  + 2 / ;

\ 使用
5 square .      \ 输出：25
10 20 average . \ 输出：15

' LED 闪烁
10 PINMODE 2, OUTPUT
20 HIGH 2
30 DELAY 1000
40 LOW 2
50 DELAY 1000
60 GOTO 20

' 读取模拟输入
10 X = ANALOG(0)
20 PRINT "传感器值："; X
30 IF X > 500 THEN GOTO 100
40 GOTO 10
100 PRINT "超过阈值！"
110 END

' 简单计算
10 FOR I = 1 TO 10
20 PRINT I, I * I
30 NEXT I

;; GPIO 控制（假设嵌入式库）
(define led (make-gpio 2 'output))

(define (blink n)
  (when (> n 0)
    (gpio-write led 1)
    (sleep 1000)
    (gpio-write led 0)
    (sleep 1000)
    (blink (- n 1))))

(blink 10)

;; 函数式编程
(define (factorial n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

(display (factorial 10))  ; 3628800

;; 宏系统
(define-syntax when
  (syntax-rules ()
    ((when test body ...)
     (if test (begin body ...)))))

;; 高阶函数
(define sensors '(1 2 3 4))
(map (lambda (pin) (adc-read pin)) sensors)

import machine, network, time
from umqtt.simple import MQTTClient
import dht

# 传感器
sensor = dht.DHT22(machine.Pin(4))

# WiFi
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect('MyWiFi', 'password')

# MQTT
client = MQTTClient('esp32-sensor', '192.168.1.100')
client.connect()

while True:
    sensor.measure()
    temp = sensor.temperature()
    humid = sensor.humidity()
    
    msg = '{"temp":%.2f,"humid":%.2f}' % (temp, humid)
    client.publish('home/sensor/data', msg)
    
    # 深度睡眠 10 分钟
    machine.deepsleep(600000)

-- 实时 PID 控制
function pid_control(setpoint, measurement)
    local error = setpoint - measurement
    integral = integral + error
    local derivative = error - last_error
    
    local output = Kp * error + Ki * integral + Kd * derivative
    last_error = error
    return output
end

-- C 语言调用 Lua
-- 在 C 代码中：
lua_getglobal(L, "pid_control");
lua_pushnumber(L, setpoint);
lua_pushnumber(L, measurement);
lua_pcall(L, 2, 1, 0);
double output = lua_tonumber(L, -1);

// 蓝牙心率服务
NRF.setServices({
    0x180D: {
        0x2A37: {
            value: [0, 72],
            readable: true,
            notify: true
        }
    }
});

// 低功耗模式
setInterval(function() {
    var heartRate = readHeartRate();
    NRF.updateServices({
        0x180D: {
            0x2A37: { value: [0, heartRate], notify: true }
        }
    });
    
    // 睡眠 1 秒，消耗仅 50μA
    deepSleep(1000);
}, 1000);

// rlua - Rust 绑定 Lua
use rlua::{Lua, Result};

fn main() -> Result<()> {
    let lua = Lua::new();
    lua.context(|lua| {
        lua.globals().set("print", lua.create_function(|_, msg: String| {
            println!("Lua: {}", msg);
            Ok(())
        })?)?;
        lua.load("print('Hello from Rust!')").exec()?;
        Ok(())
    })
}

// WASM 在 MCU 上运行
use wasmi::*;

let module = Module::from_buffer(wasm_binary)?;
let instance = ModuleInstance::new(&module, &ImportsBuilder::default())?;
instance.invoke_export("main", &[], &mut NopExternals)?;

# MicroPython + TensorFlow Lite
import tflite

interpreter = tflite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# 运行推理
interpreter.set_tensor(input_index, sensor_data)
interpreter.invoke()
result = interpreter.get_tensor(output_index)