RT-Thread-【2024-RSOC】day5 RTT软件包学习RT-Thread问答社区

【2024-RSOC】day5 RTT软件包学习

发布于 2024-07-27 16:15:03 浏览：601 订阅该版

[tocm]

# day5-RT-thread 软件包学习

## 1.学习内容

今天主要讲了关于rtt软件包的使用，导师列举了rtt文件系统，以及阿里云mqtt，还有aht20软件包的使用。我来简单的复现一下

### rtt文件系统
[rtt官方文件系统介绍](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/programming-manual/filesystem/filesystem)

首先在env中使能文件系统

![使能文件系统.png](https://oss-club.rt-thread.org/uploads/20240727/147c22ecdefe2ab05f7a45122268f8f5.png)

![使能文件系统2.png](https://oss-club.rt-thread.org/uploads/20240727/9ad4b2c5ee1d707aea5e350d9353ee56.png)

![开启elm.png](https://oss-club.rt-thread.org/uploads/20240727/0ac077c61781d7d30d38f8e6debcb9c2.png)

![开启elm2.png](https://oss-club.rt-thread.org/uploads/20240727/71d7ef51fd5dbe05888c5a2274e2b7d8.png)

![更改扇区大小.png](https://oss-club.rt-thread.org/uploads/20240727/676226aa5e1857d3ac73752c654e280b.png)

配置完成关闭env编译烧录

![烧录后.png](https://oss-club.rt-thread.org/uploads/20240727/ff245ab43d1c58d972fc0c95cb158f53.png)

剩下的操作就跟linux里的指令大差不差了，例如创建文件夹用`mkdir`等命令

![创建文件.png](https://oss-club.rt-thread.org/uploads/20240727/21a912f1029f81bd15cdcc39a0ba8e1a.png)

### mqtt协议

MQTT 是一种轻量级的消息传输协议，特别适用于物联网（IoT）设备。今天的课程重点讲解了如何在 RT-Thread 上实现 MQTT 协议，并且演示了通过mqtt协议将板载aht20温湿度传感器采集到的温湿度数据上传至阿里云物联网平台。

首先在env中打开aht20和rw007的设备驱动。

![使能传感器.png](https://oss-club.rt-thread.org/uploads/20240729/ca0e9c9a996c83510da62b269b6558a2.png)

然后在阿里云创建产品和设备

![创建产品.png](https://oss-club.rt-thread.org/uploads/20240729/31c88fb5bb9a274a14abe0b73e141bf1.png.webp)

![创建设备.png](https://oss-club.rt-thread.org/uploads/20240729/182f05e7be59f272300aaf2333614440.png.webp)

然后在线上软件包上开启连接阿里云的软件包并且将阿里云里的设备信息三元组等修改成自己创建的设备。

![修改三元组信息.png](https://oss-club.rt-thread.org/uploads/20240729/89f0e4b1eb5bfc9f9819d0a978ed1cac.png)

![三元组信息.png](https://oss-club.rt-thread.org/uploads/20240729/93ae9917d6ecb1295aeb25950dc30cfb.png.webp)

代码部分，我们分三步走，首先得开启aht20并且通过i2c总线拿到温湿度数据，其次开启WiFi连接网络，最后将温湿度信息通过cjson格式经过mqtt协议发送到阿里云服务器上。
以下是三部分的代码

温湿度采集线程
```c
#include <board.h>
#include <rtthread.h>
#include <drv_gpio.h>
#include <rtdevice.h>
#include "aht10.h"
#define LOG_TAG              "app_aht21"
#define LOG_LVL              LOG_LVL_DBG

static float humidity, temperature;
static aht10_device_t dev;
static int count;
/* 总线名称 */
static const char *i2c_bus_name = "i2c3";
//新建一个线程专门用于读取传感器温湿度数据并将数据分别放入两个消息队列中
static rt_thread_t thread1 = RT_NULL;
rt_mq_t mq_hum = RT_NULL;
rt_mq_t mq_tem = RT_NULL;
/* 定义一个线程入口 */
static void thread1_entry(void *parameter)
{
    while (1)
    {
        /* 读取湿度 */
        humidity = aht10_read_humidity(dev);
        // LOG_D("humidity   : %d.%d %%", (int)humidity, (int)(humidity * 10) % 10);
        rt_mq_send(mq_hum, &humidity, sizeof(humidity));
        /* 读取温度 */
        temperature = aht10_read_temperature(dev);
        // LOG_D("temperature: %d.%d", (int)temperature, (int)(temperature * 10) % 10);
        rt_mq_send(mq_tem, &temperature, sizeof(temperature));
        rt_thread_mdelay(500);
    }
}
static int app_aht21_example(void)
{
    /* 初始化 aht10 */
    dev = aht10_init(i2c_bus_name);
    if (dev == RT_NULL)
    {
        rt_kprintf(" The sensor initializes failure");
        return 0;
    }
    // 初始化消息队列
    mq_hum = rt_mq_create("mq_hum", 10, sizeof(humidity), RT_IPC_FLAG_FIFO);
    mq_tem = rt_mq_create("mq_tem", 10, sizeof(temperature), RT_IPC_FLAG_FIFO);
    // 创建线程
    thread1 = rt_thread_create("thread1", thread1_entry, RT_NULL, 1024, 25, 10);
    if (thread1 != RT_NULL)
    {
        rt_thread_startup(thread1);
    }
    return RT_EOK;
}
/* 导出到 msh 命令列表中 */

MSH_CMD_EXPORT(app_aht21_example, app_aht21_example);

```

wifi连接线程
```c
// #include <wlan_mgnt.h>
#include <rtthread.h>

#define WIFI_SSID "CU_C5sC"//自己WiFi名字
#define WIFI_PASSWORD "dadaqagd"//WiFi密码

rt_err_t rt_wlan_connect(const char *ssid, const char *password);

static void app_wifi_connect(void)
{
    rt_err_t result;
    result = rt_wlan_connect(WIFI_SSID, WIFI_PASSWORD);
    if (result != RT_EOK)
    {
        rt_kprintf("wifi connect failed\n");
    }
    else
    {
        rt_kprintf("wifi connect success\n");
    }
}
MSH_CMD_EXPORT(app_wifi_connect, wifi connect);

```

最后是mqtt温湿度属性上报线程
```c
#include <board.h>
#include <rtthread.h>
#include <drv_gpio.h>
#ifndef RT_USING_NANO
#include <rtdevice.h>
#endif /* RT_USING_NANO */
#include "rtthread.h"
#include "dev_sign_api.h"
#include "mqtt_api.h"
#define GPIO_LED_B    GET_PIN(F, 11)
#define LOG_TAG              "app_mqtt"
#define LOG_LVL              LOG_LVL_DBG
// #include <ulog.h>
extern rt_mq_t mq_hum;
extern rt_mq_t mq_tem;
static char DEMO_PRODUCT_KEY[IOTX_PRODUCT_KEY_LEN + 1] = {0};
static char DEMO_DEVICE_NAME[IOTX_DEVICE_NAME_LEN + 1] = {0};
static char DEMO_DEVICE_SECRET[IOTX_DEVICE_SECRET_LEN + 1] = {0};
void *HAL_Malloc(uint32_t size);
void HAL_Free(void *ptr);
void HAL_Printf(const char *fmt, ...);
int HAL_GetProductKey(char product_key[IOTX_PRODUCT_KEY_LEN + 1]);
int HAL_GetDeviceName(char device_name[IOTX_DEVICE_NAME_LEN + 1]);
int HAL_GetDeviceSecret(char device_secret[IOTX_DEVICE_SECRET_LEN]);
uint64_t HAL_UptimeMs(void);
int HAL_Snprintf(char *str, const int len, const char *fmt, ...);
#define EXAMPLE_TRACE(fmt, ...)  \
    do { \
        HAL_Printf("%s|%03d :: ", __func__, __LINE__); \
        HAL_Printf(fmt, ##__VA_ARGS__); \
        HAL_Printf("%s", "\r\n"); \
    } while(0)
static void example_message_arrive(void *pcontext, void *pclient, iotx_mqtt_event_msg_pt msg)
{
    iotx_mqtt_topic_info_t     *topic_info = (iotx_mqtt_topic_info_pt) msg->msg;
    switch (msg->event_type) {
        case IOTX_MQTT_EVENT_PUBLISH_RECEIVED:
            /* print topic name and topic message */
            EXAMPLE_TRACE("Message Arrived:");
            EXAMPLE_TRACE("Topic  : %.*s", topic_info->topic_len, topic_info->ptopic);
            EXAMPLE_TRACE("Payload: %.*s", topic_info->payload_len, topic_info->payload);
            EXAMPLE_TRACE("\n");
            //查找payload中的数据是否等于字符串"led1"，如果是则点亮LED
            // "led0"，如果是则熄灭LED
            // "led2"，如果是则切换LED状态
            if (strstr(topic_info->payload, "led1") != NULL) {
                rt_pin_write(GPIO_LED_B, PIN_HIGH);
                rt_kprintf("led on\n");
            } else if (strstr(topic_info->payload, "led0") != NULL) {
                rt_pin_write(GPIO_LED_B, PIN_LOW);
                rt_kprintf("led off\n");
            } else if (strstr(topic_info->payload, "led2") != NULL) {
                rt_pin_write(GPIO_LED_B, !rt_pin_read(GPIO_LED_B));
                rt_kprintf("led toggle\n");
            }
            break;
        default:
            break;
    }
}
static int example_subscribe(void *handle)
{
    int res = 0;
    const char *fmt = "/%s/%s/user/get";
    char *topic = NULL;
    int topic_len = 0;
    topic_len = strlen(fmt) + strlen(DEMO_PRODUCT_KEY) + strlen(DEMO_DEVICE_NAME) + 1;
    topic = HAL_Malloc(topic_len);
    if (topic == NULL) {
        EXAMPLE_TRACE("memory not enough");
        return -1;
    }
    memset(topic, 0, topic_len);
    HAL_Snprintf(topic, topic_len, fmt, DEMO_PRODUCT_KEY, DEMO_DEVICE_NAME);
    res = IOT_MQTT_Subscribe(handle, topic, IOTX_MQTT_QOS0, example_message_arrive, NULL);
    if (res < 0) {
        EXAMPLE_TRACE("subscribe failed");
        HAL_Free(topic);
        return -1;
    }
    HAL_Free(topic);
    return 0;
}
// 该函数用来从消息队列中读取温湿度数据组合成payload数据格式并传入example_publish函数
static void mqtt_tranfer_sensor(void *pclient)
{
    float humidity;
    float temperature;
    char *payload = NULL;
    int payload_len = 0,res = 0;
    const char     *fmt = "/sys/%s/%s/thing/event/property/post";
    char           *topic = NULL;
    int topic_len = 0;
    topic_len = strlen(fmt) + strlen(DEMO_PRODUCT_KEY) + strlen(DEMO_DEVICE_NAME) + 1;
    topic = HAL_Malloc(topic_len);
    if (topic == NULL) {
        EXAMPLE_TRACE("memory not enough");
        return;
    }
    memset(topic, 0, topic_len);
    HAL_Snprintf(topic, topic_len, fmt, DEMO_PRODUCT_KEY, DEMO_DEVICE_NAME);
    rt_mq_recv(mq_hum, &humidity, sizeof(humidity), RT_WAITING_NO);
    // LOG_D("humidity   : %d.%d %%", (int)humidity, (int)(humidity * 10) % 10);
    /* 从队列中读取温度并打印 */
    rt_mq_recv(mq_tem, &temperature, sizeof(temperature), RT_WAITING_NO);
    // LOG_D("temperature: %d.%d", (int)temperature, (int)(temperature * 10) % 10);
    // 判断数据是否合法
    if (humidity < 0 || humidity > 100 || temperature < -40 || temperature > 85) {
        EXAMPLE_TRACE("data error");
        return;
    }
    //计算payload所需长度，温度湿度数据保留一位小数上传，"params":{"CurrentTemperature":16.5,"CurrentHumidity":56.3}
    payload_len = strlen("{\"params\":{\"CurrentTemperature\":16.5,\"CurrentHumidity\":56.3}}") + 3;
    payload = HAL_Malloc(payload_len);
    if (payload == NULL) {
        EXAMPLE_TRACE("memory not enough");
        return;
    }
    memset(payload, 0, payload_len);
    HAL_Snprintf(payload, payload_len, "{\"params\":{\"CurrentTemperature\":%.1f,\"CurrentHumidity\":%.1f}}", temperature, humidity);
    res = IOT_MQTT_Publish_Simple(0, topic, IOTX_MQTT_QOS0, payload, strlen(payload));
    if (res < 0) {
        EXAMPLE_TRACE("publish failed, res = %d", res);
        HAL_Free(topic);
        HAL_Free(payload);
        return;
    }
    HAL_Free(topic);
    HAL_Free(payload);
}
static void example_event_handle(void *pcontext, void *pclient, iotx_mqtt_event_msg_pt msg)
{
    EXAMPLE_TRACE("msg->event_type : %d", msg->event_type);
}
static void mqtt_example_main(void *parameter)
{
    void                   *pclient = NULL;
    int                     res = 0;
    int                     loop_cnt = 0;
    iotx_mqtt_param_t       mqtt_params;
    HAL_GetProductKey(DEMO_PRODUCT_KEY);
    HAL_GetDeviceName(DEMO_DEVICE_NAME);
    HAL_GetDeviceSecret(DEMO_DEVICE_SECRET);
    EXAMPLE_TRACE("mqtt example");
    /* Initialize MQTT parameter */
    memset(&mqtt_params, 0x0, sizeof(mqtt_params));
    mqtt_params.handle_event.h_fp = example_event_handle;
    pclient = IOT_MQTT_Construct(&mqtt_params);
    if (NULL == pclient) {
        EXAMPLE_TRACE("MQTT construct failed");
        return;
    }
    res = example_subscribe(pclient);
    if (res < 0) {
        IOT_MQTT_Destroy(&pclient);
        return;
    }
    while (1) {
        if (0 == loop_cnt % 20) {
            // example_publish(pclient);
            mqtt_tranfer_sensor(pclient);
        }
        IOT_MQTT_Yield(pclient, 200);
        loop_cnt += 1;
    }
    return;
}
// #ifdef FINSH_USING_MSH
// MSH_CMD_EXPORT_ALIAS(mqtt_example_main, ali_mqtt_sample, ali coap sample);
// #endif
static char mqtt_thread_stack[4096];
static struct rt_thread mqtt_thread;
static int app3_mqtt_example()
{
    rt_thread_init(&mqtt_thread, "mqtt_thread", mqtt_example_main, RT_NULL, mqtt_thread_stack, sizeof(mqtt_thread_stack), 20, 10);
    rt_thread_startup(&mqtt_thread);
    return 0;
}
MSH_CMD_EXPORT(app3_mqtt_example, app_ali_mqtt_sample);
```

编译烧录后，可以看到系统msh中我们创建的三个命令，按照顺序依次启动。

![三个线程.png](https://oss-club.rt-thread.org/uploads/20240729/35c0208a60da62d878e62a58c2d67fc1.png)

首先启动aht20线程

![aht线程启动.png](https://oss-club.rt-thread.org/uploads/20240729/0ef6b12c4dd5f77b6b7a2c9f26d724f9.png)

再启动WiFi连接线程

![wifi线程启动.png](https://oss-club.rt-thread.org/uploads/20240729/be312f519e3dacc89ed9c33cea73687d.png)

最后启动mqtt线程

![mqtt线程启动.png](https://oss-club.rt-thread.org/uploads/20240729/b73ee2ee77997ff91177aa8b7f7f0982.png)

完成后就可以在阿里云查看到传输的数据

![阿里云数据.png](https://oss-club.rt-thread.org/uploads/20240729/977c5dc9dc4b89145f2207e36db58ef7.png.webp)