【野火】瑞萨RA MCU创意氛围赛+室内空气质量监测盒子

Dyc.

一、背景

   空气污染越来越被大家重视，人们80%的时间都是在室内度过的，室内的空气环境质量对人们的身体健康更是息息相关，有幸参加野火电子与瑞萨联合举办的创意氛围赛，借着这次能白嫖的机会，把手里现有的传感器在RA平台上完成一个室内空气质量监测的盒子实现，有不足之处希望各位大佬指正修改开源（减少脑细胞死亡），下面介绍一下整个系统的架构，以及各个模块功能作用。


二、系统设计与实现
   白嫖当然申请最高配置的（野火启明RA6M5），各个传感器模块采集数据到RA6M5，进行数据处理和组包，在OLED屏山显示实时采集的数据，监测各个模块采集数据是否在合理范围，当超出安全值时，根据不同梯度范围，使蜂鸣器发出不同音调的声音进行提示。数据组包完成后，与板载的ESP8266进行通信，将采集的数据通过WiFi远程传输到Blinker服务器中，手机端访问blinker应用可查看历史和当前监测的室内环境数据信息。

系统架构

三、硬件模块
   整个系统分为四个模块，分别是数据采集：各个传感器感知数据， 数据处理传输：启明RA6M5（最强大脑），板载ESP8266，数据显示：0.96寸OLED屏，Blinker终端显示， 报警提示：蜂鸣器。传感器：温湿度采集 SH30、颗粒物浓度监测 PMS1003、 二氧化碳浓度监测 MH-Z19B、甲醛浓度监测 DS-HCHO，每个模块的具体性能就不一一列举了，此处省略1000字（淘宝百度很详细），这里贴几张图占位置。
SH30：

sh30

                                       DS-HCHO:

HCHO

PMS1003:

pms1003

                                 MH-Z19B:

mh-z19b

其余模块都在板子上，可看野火淘宝旗舰店官方高清大图

四、系统实现
详情见代码： 室内空气质量监测.zip (2.9 MB, 下载次数: 19)

2023-8-8 23:43 上传

点击文件名下载附件
代码

针对上面的系统架构中各个模块在，代码中的具体实现，下面简要列举几个模块
1.这是系统进入的原始接口，实现方式是串行模式，最开始初始化系统，LED、按键、串口打印、串口通信，温度传感器、CO2、空气质量传感器、OLED、HCHO、Beep，然后进入while循环依次调用各模块数据读取接口。

1. void hal_entry(void)
   
2. {
   
3.     /* TODO: add your own code here */
   
4. 
   
5.     LED_Init();         // LED 初始化
   
6.     Key_IRQ_Init(); // KEY 外部中断初始化
   
7. 
   
8.     Debug_UART4_Init(); // SCI4 UART 调试串口初始化
   
9.     Debug_UART9_Init();
   
10. 
    
11.     gxht30_init(); //白 sda:p105 黄 scl:p104
    
12.     double  a = 0.0;
    
13.     double  b = 0.0;
    
14.     uint8_t buff1[22];
    
15.     uint8_t buff2[25];
    
16.     uint8_t buff3[23];
    
17.     uint8_t buff4[16];
    
18. 
    
19.     OLED_Init();    // scl - P505    sda - P506
    
20. 
    
21.     CO2_init();//白-> rx3: 408  棕->tx3:409   红：5v  黑：Gnd
    
22.     int co2=0;
    
23. 
    
24.      struct PM25 *PM_data = NULL;
    
25.      PM_data = (struct PM25 *)malloc(sizeof(struct PM25));
    
26.      PM25_init();// 蓝 -> rx5:p513   黑 -> tx5:p805  红色：5v  黄色：GND
    
27. 
    
28.      HCHO_init(); //黄——> rx2:p302  绿——>tx2:p301
    
29. //    printf("start\r\n");
    
30. 
    
31.     OLED_Clear();
    
32.     R_BSP_SoftwareDelay(3, BSP_DELAY_UNITS_MILLISECONDS);
    
33.     while(1)
    
34.     {
    
35.         LED2_ON;
    
36.         if (recv_flag) {//debug
    
37.             recv_flag = false;
    
38.             sprintf(Send_buff, "%2x %4d %2.2f %2.2f %5d %.2f %2x", 0x42, co2, a, b, PM2_5, hcho_data, 0xff);//28
    
39.             printf ("%s\r\n", Send_buff);
    
40.             memset(Send_buff, 0, sizeof(Send_buff));
    
41.         }
    
42. 
    
43.         if (uart9_recv_flag) {// send data to esp8266
    
44.             if (!CO2_read()) {
    
45.                 co2 = co2_data;
    
46.                 // Buzzer_co2(co2);
    
47.                 // printf("co2:%d\r\n", co2);
    
48.             }
    
49.             if(gxht30_read()) {
    
50.                 a = gxht30_get_temperature();
    
51.                 b = gxht30_get_humidity();
    
52.                 // printf("Temp:%.2f Humi:%.2f\r\n", a, b);
    
53.             }
    
54.             PM25_read(PM_data);
    
55.             if (PM_data != NULL) {
    
56.                 // printf("PM1_0:%d PM2_5:%d PM10:%d\r\n", PM1_0, PM2_5, PM10);
    
57.             }
    
58. 
    
59.              if (HCHO_read()) {
    
60.                  // Buzzer_hcho(hcho_data);
    
61.                  // printf("hcho:%.2f %s\r\n", hcho_data, hcho_unit);
    
62.              }
    
63. 
    
64.             sprintf(buff1,"Temp:%.2f Humi:%.2f", a , b);
    
65.             sprintf(buff2,"PM1.0:%d  PM2.5:%d", PM1_0, PM2_5);
    
66.             sprintf(buff3,"PM10:%d   CO2:%d", PM10 , co2);
    
67.             sprintf(buff4,"HCHO:%.2f %s", hcho_data, hcho_unit);
    
68. 
    
69.             sprintf(Send_buff, "%2x %4d %2.2f %2.2f %5d %2x\r\n", 0x42, co2, a, b, PM2_5, 0xff);//28
    
70. 
    
71.             // printf ("buff1:%d\n", strlen(buff1));
    
72.             // printf ("buff2:%d\n", strlen(buff2));
    
73.             // printf ("buff3:%d\n", strlen(buff3));
    
74.             // printf ("buff4:%d\n", strlen(buff4));
    
75.             LED3_ON;
    
76.             uart9_recv_flag = false;
    
77.             uint32_t send_leng = 0;
    
78.             send_leng = strlen(Send_buff);
    
79.             uart9_Write_data(Send_buff, send_leng);
    
80.             memset(Send_buff, 0, sizeof(Send_buff));
    
81.             LED3_OFF;
    
82. 
    
83.             OLED_ShowString(0, 0, "Temp:", 12, 1);
    
84. //显示2个数字
    
85. //x,y :起点坐标
    
86. //len :数字的位数
    
87. //size:字体大小
    
88. //mode:模式  0,填充模式;1,叠加模式
    
89. //num:数值(0~4294967295);
    
90. // void OLED_ShowNum(uint8_t x, uint8_t y, uint32_t num, uint8_t len, uint8_t size, uint8_t mode)
    
91.             // OLED_ShowNum(26, 0, 20, 2, 12, 1);
    
92.             OLED_ShowString(0, 0, buff1, 12, 1);
    
93.             OLED_ShowString(0, 13, buff2, 12, 1);
    
94.             OLED_ShowString(0, 26, buff3, 12, 1);
    
95.             OLED_ShowString(0, 38, buff4, 12, 1);
    
96.             OLED_Refresh_Gram();
    
97.         }
    
98. 
    
99.     //    OLED_ShowHzStringRow(30, 0, (const char*)"启明", 1);
    
100.     //    OLED_ShowString(62, 0, (const uint8_t*)"R6M5", 16, 1);
     
101.     //    OLED_ShowHzStringRow(32, 24, (const char*)"电子发烧友", 1);
     
102. 
     
103.         /* 判断按键 KEY1_SW2 是否被按下 */
     
104.         if (key1_sw2_press)
     
105.         {
     
106.             key1_sw2_press = false; //标志位清零
     
107.             // PM_SLEEP_ON;
     
108.             // BEEP_ON = true;
     
109.             OLED_Clear();
     
110.             R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS); // 10ms
     
111.             OLED_ON();
     
112.         }
     
113. 
     
114.         /* 判断按键 KEY2_SW3 是否被按下 */
     
115.         if (key2_sw3_press)
     
116.         {
     
117.             key2_sw3_press = false; //标志位清零
     
118. //            PM_SLEEP_OFF;
     
119. //            BEEP_ON = false;
     
120.             OLED_OFF();
     
121.             LED3_TOGGLE;            //LED3 翻转
     
122.         }
     
123.         R_BSP_SoftwareDelay(2, BSP_DELAY_UNITS_SECONDS);
     
124.         LED2_OFF;
     
125.         R_BSP_SoftwareDelay(2, BSP_DELAY_UNITS_SECONDS);
     
126.     }
     
127.    free(PM_data);
     
128. 
     
129. 
     
130. #if BSP_TZ_SECURE_BUILD
     
131.     /* Enter non-secure code */
     
132.     R_BSP_NonSecureEnter();
     
133. #endif
     
134. }

复制代码

2、CO2模块
根据数据CO2数据使用手册，实现数据读取校验功能

1. int CO2_read()
   
2. {
   
3.     uint8_t co2_tmp_buff[9];
   
4.     memset(co2_tmp_buff, 0, sizeof(co2_tmp_buff));
   
5. 
   
6.     int ret =0;
   
7. 
   
8.     if (only_once_skip)
   
9.     {
   
10.         only_once_skip = 0;
    
11.         // first data is error, so skip
    
12.         Write_data(str);
    
13.         R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);
    
14. 
    
15.         co2_err = R_SCI_UART_Read (&g_uart3_ctrl, co2_tmp_buff, 9);
    
16.         assert(FSP_SUCCESS == co2_err);
    
17.         memset(co2_tmp_buff, 0, sizeof(co2_tmp_buff));
    
18.         R_BSP_SoftwareDelay (500, BSP_DELAY_UNITS_MILLISECONDS);
    
19.     }
    
20. 
    
21.     uint8_t i;
    
22.     for (i = 0; i < 1; i++)
    
23.     {
    
24.         Write_data(str);
    
25.         R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);
    
26. 
    
27.         co2_err = R_SCI_UART_Read (&g_uart3_ctrl, co2_tmp_buff, 9);
    
28.         assert(FSP_SUCCESS == co2_err);
    
29.         while ((UART_EVENT_RX_COMPLETE != g_uart3_event) && timeout_ms > 0)
    
30.         {
    
31.             R_BSP_SoftwareDelay(1U, BSP_DELAY_UNITS_MILLISECONDS);
    
32.             timeout_ms--;
    
33.         }
    
34.         if (UART_EVENT_ERR_FRAMING == g_uart3_event)
    
35.         {
    
36.         
    
37.             __BKPT(0);
    
38.         }
    
39.         g_uart3_event = UART_EVENT_ERR_FRAMING;
    
40.         timeout_ms    = 100000;
    
41. 
    
42.         // uint8_t j =0;//打印接收到的原始数据
    
43.         // for (j =0; j < 9; j++)
    
44.         // {
    
45.         //     printf("num:%d 0x%02x\n",j, co2_tmp_buff[j]);
    
46.         // }
    
47. 
    
48.         co2_data = 0;
    
49.         co2_data = co2_tmp_buff[2] *256 + co2_tmp_buff[3];
    
50.             
    
51.         ret = getCheckSum(co2_tmp_buff);
    
52. 
    
53.         if (ret == 0)
    
54.         {
    
55.             co2_data = 0;
    
56.             co2_data = co2_tmp_buff[2] *256 + co2_tmp_buff[3];
    
57.         //    printf("%s()%d co2_data:%d\n", __func__, __LINE__, co2_data);
    
58.             break;
    
59.         }
    
60.         printf("%s()%d CO2 check sum error\r\n",__func__, __LINE__);
    
61.         i = 0;//retry only once
    
62.     }
    
63. 
    
64.     return ret;
    
65. }

复制代码

3、温度传感器
根据sht30数据手册，完成数据采集读取功能

1. bool gxht30_read()
   
2. {
   
3. 
   
4.     Humiture_HS3003_writeRegister(gxht30_cmd_read_interval_measure, 2);
   
5.     uint8_t data[6] = { 0 };
   
6.     timeout_ms1           = 100000;
   
7. 
   
8.     gxht30_err = R_SCI_I2C_Read(&g_sci8_i2c_ctrl, data, sizeof(data), true);//true  false
   
9.     assert(FSP_SUCCESS == gxht30_err);
   
10.     while ((I2C_MASTER_EVENT_RX_COMPLETE != sci8_i2c_event) && timeout_ms1)
    
11.     {
    
12.         R_BSP_SoftwareDelay(1U, BSP_DELAY_UNITS_MILLISECONDS);
    
13.         timeout_ms1--;
    
14.     }
    
15.     if (I2C_MASTER_EVENT_ABORTED == sci8_i2c_event)
    
16.     {
    
17.         __BKPT(0);
    
18.     }
    
19. 
    
20.     sci8_i2c_event = I2C_MASTER_EVENT_ABORTED;
    
21.     timeout_ms1           = 100000;
    
22. 
    
23.     //check CRC, when fail, return false
    
24.     if (data[2] != crc8 (data, 2) || data[5] != crc8 (&data[3], 2))
    
25.     {
    
26.         return false;
    
27.     }
    
28.     temperature = ((((data[0] * 256.0) + data[1]) * 175) / 65535.0) - 45;
    
29.     humidity = (((data[3] * 256.0) + data[4]) * 100) / 65535.0;
    
30. 
    
31. //    printf("Temp:%.2f\r\n", temperature);
    
32. //    printf("Humidity:%.2f\r\n", humidity);
    
33.     return true;
    
34. }

复制代码

4、空气质量传感器
这里使用的PMS1003，可以采集PM1.0, PM2.5, PM10等颗粒物浓度，可以根据项目需求进行调整

1. int PM25_read(struct PM25 *p)
   
2. {
   
3.     read_flag = 0;
   
4.     memset(tmp_Buff,0,sizeof(tmp_Buff));
   
5. 
   
6.     while(1)
   
7.     {
   
8.         uint8_t ch;
   
9.         read(&g_uart5_ctrl, &ch, 1);
   
10.         if (uart_recv0_complete_flag == true && read_flag == 32)
    
11.         {
    
12.             uart_recv0_complete_flag = false;
    
13.             int ret = 0;
    
14.             read_flag = 0;
    
15.         //    int j =0;//PM2.5 原始数据
    
16.         //    for (j =0; j < read_flag; j++)
    
17.         //    {
    
18.         //        printf("num:%d 0x%02lx\n",j, tmp_Buff[j]);
    
19.         //    }
    
20.             ret = data_checksum(p);
    
21.             if (ret == 0)
    
22.             {
    
23.                 break;
    
24.             }
    
25. 
    
26.             printf("%s()%d PM2.5 data checksum error\r\n", __func__, __LINE__);
    
27.             break;
    
28.         }
    
29.     }
    
30. 
    
31.     return 0;
    
32. }

复制代码

5、HCHO
甲醛浓度传感器，目前使用的这个模块能采集多种有毒有害气体，根据数据手册实现了采集校验，区分气体类型功能

1. int HCHO_read()
   
2. {
   
3.     uint8_t hcho_tmp_buff[10];
   
4.     memset(hcho_tmp_buff, 0, sizeof(hcho_tmp_buff));
   
5. 
   
6.     int ret =0;
   
7.     uint8_t str[7] = {0x42, 0x4d, 0x01, 0x00, 0x00, 0x00, 0x90};
   
8.     int equivalent = 1;//当量
   
9. 
   
10.     if (hcho_only_once_skip)
    
11.     {
    
12.         hcho_only_once_skip = 0;
    
13.         // first data is error, so skip
    
14.         HCHO_Write_data(str);
    
15.         R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);
    
16. 
    
17.         hcho_err = R_SCI_UART_Read (&g_uart2_ctrl, hcho_tmp_buff, 10);
    
18.         assert(FSP_SUCCESS == hcho_err);
    
19.         memset(hcho_tmp_buff, 0, sizeof(hcho_tmp_buff));
    
20.         R_BSP_SoftwareDelay (500, BSP_DELAY_UNITS_MILLISECONDS);
    
21.     }
    
22. 
    
23.     uint8_t i;
    
24.     for (i = 0; i < 1; i++)
    
25.     {
    
26. 
    
27.         HCHO_Write_data(str);
    
28.         R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);
    
29. 
    
30.         hcho_err = R_SCI_UART_Read (&g_uart2_ctrl, hcho_tmp_buff, 10);
    
31.         assert(FSP_SUCCESS == hcho_err);
    
32.         while ((UART_EVENT_RX_COMPLETE != g_uart2_event) && hcho_timeout_ms > 0)
    
33.         {
    
34.             R_BSP_SoftwareDelay(1U, BSP_DELAY_UNITS_MILLISECONDS);
    
35.             hcho_timeout_ms--;
    
36.         }
    
37.         if (UART_EVENT_ERR_FRAMING == g_uart2_event)
    
38.         {
    
39.             __BKPT(0);
    
40.         }
    
41.         g_uart2_event = UART_EVENT_ERR_FRAMING;
    
42.         hcho_timeout_ms    = 100000;
    
43. 
    
44.         // int j =0;//打印HCHO原始数据
    
45.         // for (j =0; j < 10; j++)
    
46.         // {
    
47.         //     printf("num:%d 0x%02x\n",j, hcho_tmp_buff[j]);
    
48.         // }
    
49.         // printf("\n");
    
50. 
    
51.         ret = HCHOCheckSum(hcho_tmp_buff);
    
52.         if (ret == 0)
    
53.         {
    
54.             if (hcho_tmp_buff[3] == 0x14)
    
55.             {
    
56.                 // 数据单位标识
    
57.                 if (hcho_tmp_buff[4] == 0x01)
    
58.                 {
    
59.                     hcho_unit = "ppm";
    
60.                 }
    
61.                 else if (hcho_tmp_buff[4] == 0x02)
    
62.                 {
    
63.                     hcho_unit = "VOL";
    
64.                 }
    
65.                 else if (hcho_tmp_buff[4] == 0x03)
    
66.                 {
    
67.                     hcho_unit = "LEL";
    
68.                 }
    
69.                 else if (hcho_tmp_buff[4] == 0x04)
    
70.                 {
    
71.                     hcho_unit = "Ppb";
    
72.                 }
    
73.                 else if (hcho_tmp_buff[4] == 0x05)
    
74.                 {
    
75.                     hcho_unit = "Mg/m3";
    
76.                 }
    
77.                 else
    
78.                 {
    
79.                     hcho_unit = "unknown";
    
80.                 }
    
81. 
    
82.                 //当量判断
    
83.                 if (0x01 == hcho_tmp_buff[5])
    
84.                 {
    
85.                     equivalent = 1;
    
86.                 }
    
87.                 else if(0x02 == hcho_tmp_buff[5])
    
88.                 {
    
89.                     equivalent = 10;
    
90.                 }
    
91.                 else if(0x03 == hcho_tmp_buff[5])
    
92.                 {
    
93.                     equivalent = 100;
    
94.                 }
    
95.                 else if(0x04 == hcho_tmp_buff[5])
    
96.                 {
    
97.                     equivalent = 1000;
    
98.                 }
    
99.                 else
    
100.                 {
     
101.                     printf("%s():%d equivalent read error\r\n", __func__, __LINE__);
     
102.                 }
     
103. 
     
104.                 hcho_data = (float)((hcho_tmp_buff[6]<<8) | hcho_tmp_buff[7]);
     
105.                 hcho_data = hcho_data / (float)equivalent;
     
106.                 // printf("%s():%d hcho_data:%.2f %s\r\n", __func__, __LINE__, hcho_data, hcho_unit);
     
107.                 ret = 1;
     
108.                 break;
     
109.             }
     
110.         }
     
111.         printf("%s():%d HCHO check sum error\r\n", __func__, __LINE__);
     
112.         i = 0;//retry only once
     
113.     }
     
114. 
     
115.     ret = -1;
     
116.     return ret;
     
117. }

复制代码

6、RA6M5与ESP8266通信
通过串口回调，实现RA6M5与ESP8266数据的通信传输功能

1. void uart9_Write_data(uint8_t *buffer, uint32_t datalen)
   
2. {
   
3.     R_BSP_SoftwareDelay(10, BSP_DELAY_UNITS_MILLISECONDS);
   
4. 
   
5.     uart9_err = R_SCI_UART_Write(&g_uart9_ctrl, buffer, datalen);
   
6.     assert(FSP_SUCCESS == uart9_err);
   
7.     while ((UART_EVENT_TX_DATA_EMPTY != g_uart9_event) && uart9_timeout_ms > 0)
   
8.     {
   
9.         R_BSP_SoftwareDelay(1U, BSP_DELAY_UNITS_MICROSECONDS);
   
10.         uart9_timeout_ms--;
    
11.     }
    
12.     if (UART_EVENT_ERR_FRAMING == g_uart9_event)
    
13.     {
    
14.         __BKPT(0);
    
15.     }
    
16. 
    
17.     g_uart9_event = UART_EVENT_ERR_FRAMING;
    
18.     uart9_timeout_ms    = 100000;
    
19. }
    
20. 
    
21. void uart9_read_data(uint8_t *buffer, uint32_t datalen)
    
22. {
    
23.     uart9_err = R_SCI_UART_Read (&g_uart9_ctrl, buffer, datalen);
    
24.     assert(FSP_SUCCESS == uart9_err);
    
25.     while ((UART_EVENT_RX_COMPLETE != g_uart9_event) && uart9_timeout_ms > 0)
    
26.     {
    
27.         R_BSP_SoftwareDelay(1U, BSP_DELAY_UNITS_MILLISECONDS);
    
28.         uart9_timeout_ms--;
    
29.     }
    
30.     if (UART_EVENT_ERR_FRAMING == g_uart9_event)
    
31.     {
    
32.         __BKPT(0);
    
33.     }
    
34.     g_uart9_event = UART_EVENT_ERR_FRAMING;
    
35.     uart9_timeout_ms    = 100000;
    
36. }

复制代码

五、界面展示
终端显示画面：

1

2

板子画面：