git clone --recursive --depth 1 https://gitee.com/mirrors_RT-Thread/env-windows.git

menuconfig

pkgs --update

scons --target=mdk5

MSH_CMD_EXPORT()

int command(int argc, char **argv)

#include <rtthread.h>
#include <stdlib.h>
 
static int add(int argc, char **argv)
{
    int a;
    int b;
 
    if (argc != 3)
    {
        rt_kprintf("Usage: add <a> <b>\n");
        return -1;
    }
 
    a = atoi(argv[1]);
    b = atoi(argv[2]);
 
    rt_kprintf("%d + %d = %d\n",
               a,
               b,
               a + b);
 
    return 0;
}
 
MSH_CMD_EXPORT(add, add two numbers);

msh /> add 10 20
10 + 20 = 30

thread   pri  status   sp         stack size max used left tick error   tcb addr
--------------------------------------------------------------------------------
tshell    20  running  0x00000540 0x00001000   48%    0x0a     OK      0x203920e8
tcpip     10  suspend  0x00000490 0x00004000   08%    0x14     EINTRPT  0x2038cc98

static void my_thread_entry(void *parameter)
{
    while (1)
    {
        /* 线程任务 */
 
        rt_thread_mdelay(1000);
    }
}
 
static int my_thread_init(void)
{
    rt_thread_t tid;
 
    /* 创建线程 */
    tid = rt_thread_create(
        "my_thread",         /* 线程名字 */
        my_thread_entry,     /* 线程入口函数 */
        RT_NULL,             /* 传给入口函数的参数 */
        1024,                /* 栈大小，单位字节 */
        20,                  /* 优先级，数字越小优先级越高 */
        10                   /* 时间片 tick */
    );
 
    if (tid == RT_NULL)
    {
        return -RT_ERROR;
    }
 
    rt_thread_startup(tid);
 
    return RT_EOK;
}
 
INIT_APP_EXPORT(my_thread_init);  // 把 my_thread_init() 注册到 RT-Thread 的应用初始化阶段。

#include <rtthread.h>
 
#define THREAD_STACK_SIZE 1024
#define THREAD_PRIORITY   20
#define THREAD_TIMESLICE  10
 
static struct rt_thread my_thread;
 
/* 自己准备线程栈 */
static rt_uint8_t thread_stack[THREAD_STACK_SIZE];
 
static void my_thread_entry(void *parameter)
{
    while (1)
    {
        rt_kprintf("static thread running\n");
 
        rt_thread_mdelay(1000);
    }
}
 
int my_thread_init(void)
{
    rt_thread_init(
        &my_thread,              /* TCB */
        "my_thread",             /* 线程名称 */
        my_thread_entry,         /* 入口函数 */
        RT_NULL,                 /* 参数 */
        thread_stack,            /* 栈 */
        sizeof(thread_stack),    /* 栈大小 */
        THREAD_PRIORITY,         /* 优先级 */
        THREAD_TIMESLICE         /* 时间片 */
    );
 
    rt_thread_startup(&my_thread);
 
    return 0;
}

#include <rtthread.h>
 
static rt_timer_t my_timer = RT_NULL;
 
/* 定时器超时回调函数 */
static void timer_timeout(void *parameter)
{
    rt_kprintf("timer timeout! tick = %d\n", rt_tick_get());
}
 
/* 创建并启动定时器 */
static int timer_start_demo(void)
{
    /* 已创建就不重复创建 */
    if (my_timer == RT_NULL)
    {
        my_timer = rt_timer_create(
            "demo",                    /* timer 名称 */
            timer_timeout,             /* 超时回调 */
            RT_NULL,                   /* 回调参数 */
            RT_TICK_PER_SECOND,        /* 1 秒 */
            RT_TIMER_FLAG_PERIODIC     /* 周期定时器 */
        );
 
        if (my_timer == RT_NULL)
        {
            rt_kprintf("create timer failed!\n");
            return -1;
        }
    }
 
    rt_timer_start(my_timer);
 
    rt_kprintf("timer started\n");
 
    return 0;
}
 
MSH_CMD_EXPORT(timer_start_demo, start timer demo);

#define EVENT_RX_READY    (1 << 0)
#define EVENT_TX_DONE     (1 << 1)

rt_event_t event;
 
event = rt_event_create(
    "my_event",
    RT_IPC_FLAG_FIFO
);

rt_uint32_t recved;
 
rt_event_recv(
    event,
    EVENT_RX_READY,
    RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
    RT_WAITING_FOREVER,
    &recved
);

rt_event_send(event, EVENT_RX_READY);

#include <rtthread.h>
 
static rt_mailbox_t mb;
 
static int mailbox_init(void)
{
    mb = rt_mb_create(
        "mb",
        8,                  /* 最多存 8 条消息 */
        RT_IPC_FLAG_FIFO
    );
 
    if (mb == RT_NULL)
    {
        rt_kprintf("mailbox create failed\n");
        return -1;
    }
 
    return 0;
}

static void sender_entry(void *parameter)
{
    rt_ubase_t value = 100;
 
    while (1)
    {
        rt_mb_send(mb, value);
 
        rt_kprintf("send: %d\n", value);
 
        value++;
 
        rt_thread_mdelay(1000);
    }
}

static void receiver_entry(void *parameter)
{
    rt_ubase_t value;
 
    while (1)
    {
        rt_mb_recv(
            mb,
            &value,
            RT_WAITING_FOREVER
        );
 
        rt_kprintf("recv: %d\n", value);
    }
}

#include <rtthread.h>
 
typedef struct
{
    int id;
    int value;
} sensor_msg_t;
 
static rt_mq_t sensor_mq = RT_NULL;
 
/* 发送线程 */
static void sender_entry(void *parameter)
{
    sensor_msg_t msg;
    int count = 0;
 
    while (1)
    {
        msg.id = 1;
        msg.value = count++;
 
        if (rt_mq_send(sensor_mq,
                       &msg,
                       sizeof(msg)) == RT_EOK)
        {
            rt_kprintf("send: id=%d value=%d\n",
                       msg.id,
                       msg.value);
        }
        else
        {
            rt_kprintf("message queue full!\n");
        }
 
        rt_thread_mdelay(1000);
    }
}
 
/* 接收线程 */
static void receiver_entry(void *parameter)
{
    sensor_msg_t msg;
 
    while (1)
    {
        /*
         * 队列为空时永久等待
         */
        if (rt_mq_recv(sensor_mq,
                       &msg,
                       sizeof(msg),
                       RT_WAITING_FOREVER) == RT_EOK)
        {
            rt_kprintf("recv: id=%d value=%d\n",
                       msg.id,
                       msg.value);
        }
    }
}
 
static int mq_demo(void)
{
    rt_thread_t sender;
    rt_thread_t receiver;
 
    /* 创建消息队列
     *
     * 每条消息大小：sizeof(sensor_msg_t)
     * 最多保存：8 条消息
     */
    sensor_mq = rt_mq_create(
        "sensor",
        sizeof(sensor_msg_t),
        8,
        RT_IPC_FLAG_FIFO
    );
 
    if (sensor_mq == RT_NULL)
    {
        rt_kprintf("create message queue failed!\n");
        return -1;
    }
 
    /* 创建发送线程 */
    sender = rt_thread_create(
        "sender",
        sender_entry,
        RT_NULL,
        1024,
        20,
        10
    );
 
    /* 创建接收线程 */
    receiver = rt_thread_create(
        "receiver",
        receiver_entry,
        RT_NULL,
        1024,
        20,
        10
    );
 
    if (sender != RT_NULL)
        rt_thread_startup(sender);
 
    if (receiver != RT_NULL)
        rt_thread_startup(receiver);
 
    return 0;
}
 
MSH_CMD_EXPORT(mq_demo, message queue demo);

#include <rtthread.h>
 
/* 模拟一块独立 RAM：10 KB */
#define MY_HEAP_SIZE   (10 * 1024)
 
static rt_uint8_t my_heap_buffer[MY_HEAP_SIZE];
 
/* memheap 控制块 */
static struct rt_memheap my_heap;
 
static int memheap_demo(void)
{
    char *buf1;
    char *buf2;
 
    /* 1. 初始化内存堆 */
    if (rt_memheap_init(&my_heap,
                        "myheap",
                        my_heap_buffer,
                        sizeof(my_heap_buffer)) != RT_EOK)
    {
        rt_kprintf("memheap init failed!\n");
        return -1;
    }
 
    rt_kprintf("memheap initialized\n");
 
    /* 2. 从 myheap 中申请 1024 字节 */
    buf1 = rt_memheap_alloc(&my_heap, 1024);
 
    if (buf1 == RT_NULL)
    {
        rt_kprintf("buf1 alloc failed!\n");
        return -1;
    }
 
    rt_kprintf("buf1 alloc success: %p\n", buf1);
 
    /* 使用这块内存 */
    rt_snprintf(buf1, 1024, "Hello RT-Thread memheap!");
 
    rt_kprintf("buf1 content: %s\n", buf1);
 
    /* 3. 再申请 2048 字节 */
    buf2 = rt_memheap_alloc(&my_heap, 2048);
 
    if (buf2 == RT_NULL)
    {
        rt_kprintf("buf2 alloc failed!\n");
 
        rt_memheap_free(buf1);
        return -1;
    }
 
    rt_kprintf("buf2 alloc success: %p\n", buf2);
 
    /* 4. 释放第一块 */
    rt_memheap_free(buf1);
    buf1 = RT_NULL;
 
    rt_kprintf("buf1 freed\n");
 
    /* 5. 释放第二块 */
    rt_memheap_free(buf2);
    buf2 = RT_NULL;
 
    rt_kprintf("buf2 freed\n");
 
    return 0;
}
 
MSH_CMD_EXPORT(memheap_demo, memheap demo);

FATFS fs;      // 文件系统对象
FIL file;      // 文件对象
DIR dir;       // 目录对象
FILINFO info;  // 文件信息

#include "ff.h"
 
void save_config(void)
{
    FIL file;
    UINT bw;
    
    f_open(&file, "config.txt", FA_WRITE | FA_CREATE_ALWAYS);
    char config[] =
        "id=001\n"
        "interval=1000\n";
    f_write(&file, config, strlen(config), &bw);
    f_close(&file);
}
 
void load_config(void)
{
    FIL file;
    char buf[128];
    UINT br;
 
    f_open(&file, "config.txt", FA_READ);
    f_read(&file, buf, sizeof(buf) - 1, &br);
    buf[br] = 0;
    printf("%s", buf);
    f_close(&file);
}

struct netdev *eth;
struct netdev *wifi;
struct netdev *lte;
 
eth  = netdev_get_by_name("e0");
wifi = netdev_get_by_name("wlan0");
lte  = netdev_get_by_name("4g0");
 
if (netdev_is_link_up(eth))
{
    netdev_set_default(eth);
}
else if (netdev_is_link_up(wifi))
{
    netdev_set_default(wifi);
}
else if (netdev_is_link_up(lte))
{
    netdev_set_default(lte);
}

lwip_socket();
lwip_connect();
lwip_send();

at_socket();
at_connect();
at_send();

socket();
connect();
send();
recv();
close();

int sock;
 
sock = socket(AF_INET, SOCK_STREAM, 0);
 
connect(sock,
        (struct sockaddr *)&server,
        sizeof(server));
 
send(sock, data, len, 0);
 
recv(sock, buf, sizeof(buf), 0);
 
closesocket(sock);

lwip_connect()

at_connect()

{
    "device": {
        "name": "SensorNode01",
        "id": 1001,
        "version": "1.2.0"
    },
 
    "network": {
        "ip": "192.168.1.100",
        "port": 8080,
        "timeout": 5000
    },
 
    "system": {
        "mode": "auto",
        "debug": true,
        "logLevel": 2
    },
 
    "sensor": {
        "offset": 0.15,
        "scale": 1.02,
        "channels": [
            1,
            2,
            3
        ]
    }
}

#include <stdint.h>
#include <stdbool.h>
 
// 设备信息
typedef struct
{
    char name[32];
    int id;
    char version[16];
} DeviceInfo;
 
// 网络配置
typedef struct
{
    char ip[32];
    int port;
    int timeout;
} NetworkConfig;
 
// 系统配置
typedef struct
{
    char mode[16];
    bool debug;
    int logLevel;
} SystemConfig;
 
// 传感器配置
typedef struct
{
    float offset;
    float scale;
    int channels[8];
    int channelCount;
} SensorConfig;
 
// 总配置
 
typedef struct
{
    DeviceInfo device;
    NetworkConfig network;
    SystemConfig system;
    SensorConfig sensor;
} DeviceConfig;
 
DeviceConfig config;

#include <ArduinoJson.h>
 
bool load_config(const char* json)
{
    /* 创建 JSON 内存池,所有解析出来的数据暂时存这里 */
    StaticJsonDocument<1024> doc;
    
    /* JSON 字符串 → JsonDocument */
    DeserializationError error = deserializeJson(doc, json);
    if(error)
    {
        return false;
    }
 
    /* 读取 device JSON: "device":{"name":"SensorNode01"} */
    strcpy(config.device.name, doc["device"]["name"] | "unknown");
    config.device.id = doc["device"]["id"] | 0;
    strcpy(config.device.version, doc["device"]["version"] | "0.0");
 
    /* 网络配置 */
    strcpy(config.network.ip, doc["network"]["ip"] | "0.0.0.0");
    config.network.port = doc["network"]["port"] | 80;
    config.network.timeout = doc["network"]["timeout"] | 3000;
    
    /* 系统参数 */
    strcpy(config.system.mode, doc["system"]["mode"] | "manual");
    config.system.debug = doc["system"]["debug"] | false;
    config.system.logLevel = doc["system"]["logLevel"] | 1;
    /* 数组解析 JSON: "channels": [1,2,3] */
    JsonArray channels = doc["sensor"]["channels"];
    config.sensor.channelCount = 0;
    for(JsonVariant v : channels)
    {
        config.sensor.channels[config.sensor.channelCount] = v.as<int>();
        config.sensor.channelCount++;
    }
    return true;
}

config.system.debug = true;
config.sensor.scale = 1.05;

void save_config(char* buffer, size_t size)
{
    StaticJsonDocument<1024> doc;
    
    // device
    JsonObject device = doc.createNestedObject("device");
    device["name"] = config.device.name;
    device["id"] = config.device.id;
    device["version"] = config.device.version;
    
    // network
    JsonObject network = doc.createNestedObject("network");
    network["ip"] = config.network.ip;
    network["port"] = config.network.port;
    network["timeout"] = config.network.timeout;
 
    // system
    JsonObject system = doc.createNestedObject("system");
    system["mode"] = config.system.mode;
    system["debug"] = config.system.debug;
    system["logLevel"] = config.system.logLevel;
 
    // 输出 JSON
    serializeJsonPretty(doc, buffer, size);
}

{
  "device": {
    "name": "SensorNode01",
    "id": 1001,
    "version": "1.2.0"
  },
  "network": {
    "ip": "192.168.1.100",
    "port": 8080,
    "timeout": 5000
  },
  "system": {
    "mode": "auto",
    "debug": true,
    "logLevel": 2
  }
}