RT-Thread-RA-RTT RA2L1 PM2.5采集显示器RT-Thread问答社区

RA-RTT RA2L1 PM2.5采集显示器

发布于 2023-02-23 23:03:39 浏览：512 订阅该版

[tocm]

# 一、先上个完成图

![screenshot_568a3c58947798167193789b5bff827.jpg](https://oss-club.rt-thread.org/uploads/20230223/7162f20f22f0a3577aaefbd3f77238e3.jpg.webp)
# 二、工作原理
通过串口读取传感器数值解释完后，显示到数码管，数码管显示方式为动态扫描
程序分为2个线程，一个数据解释线程，一个数码管扫描显示线程
# 三、硬件连接

![screenshot_1677164064534.png](https://oss-club.rt-thread.org/uploads/20230223/cfc7bc06a2ea57dc5f9d797f93d84f2f.png)

![screenshot_1677164112648.png](https://oss-club.rt-thread.org/uploads/20230223/43f48193654aaf7035d234a0bd3458a7.png)
# 四、rt-thread studio驱动配置
打开UART0

![screenshot_1677164206574.png](https://oss-club.rt-thread.org/uploads/20230223/ee1c1d13b50986301c70f6863e102daf.png)
# 五、RA Smart Configurator配置
添加g_uart0 UART驱动
![screenshot_1677164354553.png](https://oss-club.rt-thread.org/uploads/20230223/f1a9e1c97d8002d3c84eb6fe5ade3493.png)
配置SC0为异步串口，选择101 100引脚

![screenshot_1677164432403.png](https://oss-club.rt-thread.org/uploads/20230223/dcd7b434d96b9c6768e697f22f76c088.png)
# 六、代码编写

PM2.5 接收及解释
```c

#include <rtthread.h>
#include <rtdevice.h>

#include <pm25.h>
#include "display.h"

#define DBG_TAG "app.pm25"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

static rt_device_t serial;
static pm25_state_t pm25_state;

uint16_t pm25_data_convert(uint8_t h, uint8_t l)
{
    return h<<8|l;
}

void pm25_thread_entry(void *parameter)
{
    uint8_t ch;

serial = rt_device_find("uart0");
    if (!serial)
    {
        LOG_E("find %s failed!\n", "uart1");
        return;
    }
    else{
        struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;  /* 初始化配置参数 */
        /* step2：修改串口配置参数 */
        config.baud_rate = BAUD_RATE_9600;        //修改波特率为 9600
        config.data_bits = DATA_BITS_8;           //数据位 8
        config.stop_bits = STOP_BITS_1;           //停止位 1
        config.tx_bufsz  = 0;                   //修改缓冲区 buff size 为 128
        config.rx_bufsz  = 128;                   //修改缓冲区 buff size 为 128
        config.parity    = PARITY_NONE;           //无奇偶校验位

/* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
        rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);

rt_device_open(serial, RT_DEVICE_FLAG_RX_NON_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);
    }

while(1){

//        rt_thread_delay(10);

if( rt_device_read(serial, -1, &ch, 1) > 0 ){
            pm25_state.recv_time = 10;

switch( pm25_state.recv_state )
            {
                case RECV_START1:
                    if( ch==0x42 ){
                        pm25_state.recv_state++;
                        pm25_state.recv_buf[pm25_state.recv_index++] = ch;
                    }
                    break;
                case RECV_START2:
                    if( ch==0x4d ){
                        pm25_state.recv_state++;
                        pm25_state.recv_buf[pm25_state.recv_index++] = ch;
                    }
                    break;
                case RECV_LEN1:
                    pm25_state.recv_state++;
                    pm25_state.recv_buf[pm25_state.recv_index++] = ch;
                    pm25_state.recv_len = ch<<8;
                    break;
                case RECV_LEN2:
                    pm25_state.recv_state++;
                    pm25_state.recv_buf[pm25_state.recv_index++] = ch;
                    pm25_state.recv_len |= ch;
                    break;
                case RECV_DATA:
                    if( pm25_state.recv_index < pm25_state.recv_len ){
                        pm25_state.recv_buf[pm25_state.recv_index++] = ch;
                        if( pm25_state.recv_index == pm25_state.recv_len ){
                            pm25_state.recv_state++;
                        }
                    }
                    break;
                case RECV_END:
//                    LOG_HEX("REPLY", 16, pm25_state.recv_buf, 32);
                    pm25_state.recv_state = 0;
                    pm25_state.recv_index = 0;
                    pm25_decode_t   *pm25_decode_ptr = (pm25_decode_t  *)pm25_state.recv_buf;
                    pm25_state.pm25_data.pm1_0 = pm25_data_convert(pm25_decode_ptr->pm1_0_h,pm25_decode_ptr->pm1_0_l);
                    pm25_state.pm25_data.pm2_5 = pm25_data_convert(pm25_decode_ptr->pm2_5_h,pm25_decode_ptr->pm2_5_l);
                    pm25_state.pm25_data.pm10 = pm25_data_convert(pm25_decode_ptr->pm10_h,pm25_decode_ptr->pm10_l);
                    pm25_state.pm25_data.pm1_0_air = pm25_data_convert(pm25_decode_ptr->pm1_0_air_h,pm25_decode_ptr->pm1_0_air_l);
                    pm25_state.pm25_data.pm2_5_air = pm25_data_convert(pm25_decode_ptr->pm2_5_air_h,pm25_decode_ptr->pm2_5_air_l);
                    pm25_state.pm25_data.pm10_air = pm25_data_convert(pm25_decode_ptr->pm10_air_h,pm25_decode_ptr->pm10_air_l);
                    pm25_state.pm25_data.quantity_0_3 = pm25_data_convert(pm25_decode_ptr->quantity_0_3_h,pm25_decode_ptr->quantity_0_3_l);
                    pm25_state.pm25_data.quantity_0_5 = pm25_data_convert(pm25_decode_ptr->quantity_0_5_h,pm25_decode_ptr->quantity_0_5_l);
                    pm25_state.pm25_data.quantity_1_0 = pm25_data_convert(pm25_decode_ptr->quantity_1_0_h,pm25_decode_ptr->quantity_1_0_l);
                    pm25_state.pm25_data.quantity_2_5 = pm25_data_convert(pm25_decode_ptr->quantity_2_5_h,pm25_decode_ptr->quantity_2_5_l);
                    pm25_state.pm25_data.quantity_5_0 = pm25_data_convert(pm25_decode_ptr->quantity_5_0_h,pm25_decode_ptr->quantity_5_0_l);
                    pm25_state.pm25_data.quantity_10 = pm25_data_convert(pm25_decode_ptr->quantity_10_h,pm25_decode_ptr->quantity_10_l);
                    pm25_state.pm25_data.version = pm25_decode_ptr->version;
                    pm25_state.pm25_data.err_code = pm25_decode_ptr->err_code;

display_dig(pm25_state.pm25_data.pm2_5_air);
//
//                    LOG_D("pm1_0 = %d",pm25_state.pm25_data.pm1_0);
//                    LOG_D("pm2_5 = %d",pm25_state.pm25_data.pm2_5);
//                    LOG_D("pm10 = %d",pm25_state.pm25_data.pm10);
//
//                    LOG_D("pm1_0_air = %d",pm25_state.pm25_data.pm1_0_air);
//                    LOG_D("pm2_5_air = %d",pm25_state.pm25_data.pm2_5_air);
//                    LOG_D("pm10_air = %d",pm25_state.pm25_data.pm10_air);
//
//                    LOG_D("quantity_0_3 = %d",pm25_state.pm25_data.quantity_0_3);
//                    LOG_D("quantity_0_5 = %d",pm25_state.pm25_data.quantity_0_5);
//                    LOG_D("quantity_1_3 = %d",pm25_state.pm25_data.quantity_1_0);
//                    LOG_D("quantity_2_5 = %d",pm25_state.pm25_data.quantity_2_5);
//                    LOG_D("quantity_5_0 = %d",pm25_state.pm25_data.quantity_5_0);
//                    LOG_D("quantity_10 = %d",pm25_state.pm25_data.quantity_10);
//                    LOG_D("\n");
                    break;
                default:
                    break;
            }
            if( pm25_state.recv_time > 0 ){
                pm25_state.recv_time --;
                if( pm25_state.recv_time==0 ){
                    pm25_state.recv_state = RECV_START1;
                    pm25_state.recv_index = 0;
                    LOG_E("recv timeout");
                }
            }
        }

//        rt_device_write(serial, 0,"hello world",11);

rt_thread_delay(10);
    }
}

void pm25_init(void)
{
    rt_thread_t tid1 = RT_NULL;

tid1 = rt_thread_create("pm25",
                pm25_thread_entry, RT_NULL,
                512,
                10, 10);

if (tid1 != RT_NULL)
        rt_thread_startup(tid1);
}
INIT_APP_EXPORT(pm25_init);

```
595动态扫描显示线程

```c
/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-02-18     dmjku       the first version
 */

#include <rtthread.h>
#include <rtdevice.h>

#include "display.h"

disp_buf_t disp_buf;

#define SERIAL_RCLK_PIN     "P302"
#define SERIAL_SCLK_PIN     "P303"
#define SERIAL_DIO_PIN      "P301"

rt_uint32_t rclk_pin;
rt_uint32_t sclk_pin;
rt_uint32_t dio_pin;

#define serial_rclk_pin(sta)       rt_pin_write(rclk_pin, sta)
#define serial_sclk_pin(sta)       rt_pin_write(sclk_pin, sta)
#define serial_dio_pin(sta)        rt_pin_write(dio_pin, sta)

const uint8_t dig_code[]={
        /********生成 0-f 的编码********/
        0xC0,////0
        0xF9,////1
        0xA4,////2
        0xB0,////3
        0x99,////4
        0x92,////5
        0x82,////6
        0xF8,////7
        0x80,////8
        0x90,////9
        0x88,////A
        0x80,////B
        0xC6,////C
        0xC0,////D
        0x86,////E
        0x8E,////F
};

void display_dig(uint16_t dig)
{
    uint8_t zero=0;
    if( dig/1000 ){
        disp_buf.dig[0] = dig_code[dig/1000];
        dig %= 1000;
        zero = 1;
    }
    else{
        disp_buf.dig[0] = 0xff;
    }

if( dig/100 ){
        disp_buf.dig[1] = dig_code[dig/100];
        dig %= 100;
        zero = 1;
    }
    else if(zero){
        disp_buf.dig[1] = dig_code[0];
    }
    else{
        disp_buf.dig[1] = 0xff;
    }

if( dig/10 ){
        disp_buf.dig[2] = dig_code[dig/10];
        dig %= 10;
        zero = 1;
    }
    else if(zero){
        disp_buf.dig[2] = dig_code[0];
    }
    else{
        disp_buf.dig[2] = 0xff;
    }

if( dig ){
        disp_buf.dig[3] = dig_code[dig];
    }
    else if(zero){
        disp_buf.dig[3] = dig_code[0];
    }
    else{
        disp_buf.dig[3] = 0xff;
    }
}

void display_led(void)
{
    const uint8_t pos_v[] = {0x08,0x04,0x02,0x01};
    static uint8_t pos = 0;
    disp_buf.output[0] = pos_v[pos];
    disp_buf.output[1] = disp_buf.dig[pos];
    pos++;
    if( pos>=4 )
        pos = 0;
}

static void display_wr_byte(uint8_t data)
{
    for( uint8_t i=0; i<8; i++ ){
        serial_dio_pin(data&0x80?1:0);
//        rt_hw_us_delay(1);
        serial_sclk_pin(1);
//        rt_hw_us_delay(1);
        serial_sclk_pin(0);

data <<= 1;
    }
}

static void display_refresh(void)
{
    for( uint8_t i=DISP_BUF_LEN; i>0; i-- ){
        display_wr_byte(disp_buf.output[i-1]);
    }
    serial_rclk_pin(1);
//    rt_hw_us_delay(1);
    serial_rclk_pin(0);
}

void display_thread_entry(void *paramter)
{
    display_dig(1);
    while( 1 ){

display_led();

display_refresh();

rt_thread_delay(5);
    }
}

void display_init(void)
{
    rclk_pin    = rt_pin_get(SERIAL_RCLK_PIN);
    sclk_pin    = rt_pin_get(SERIAL_SCLK_PIN);
    dio_pin     = rt_pin_get(SERIAL_DIO_PIN);

//    serial_rclk_pin(1);
//    serial_rclk_pin(0);
//    serial_sclk_pin(1);
//    serial_sclk_pin(0);
//    serial_dio_pin(1);
//    serial_dio_pin(0);

rt_thread_t tid1 = RT_NULL;

tid1 = rt_thread_create("disp",
            display_thread_entry, RT_NULL,
                512,
                10, 10);

if (tid1 != RT_NULL)
        rt_thread_startup(tid1);
}
INIT_APP_EXPORT(display_init);

```
# 七、总结
第一次使用的瑞萨的ARM系列芯片，在RT-thread studio的加持下结合RA Smart Configurator，不需看硬件手册，可以快速上手开发，真心好用，比keil+evn+stm32cubeMX还要顺手