ppm转换hex python

【12月原创】基于ART-PI的智能甲醛检测仪

基于 RT-Thread 的智能甲醛检测仪设计

【12月原创】
注意：该文章仅供学习参考，请勿转载

前言

硬件介绍

• ART-PI
• WZ-S-K 达特甲醛传感器
• ALIENTEK 4.3 RGBLCD

硬件接口使用说明

art-pi 甲醛传感器扩展板

笔者为 ART-PI 设计了一款兼容达特甲醛传感器的扩展板，EDA工具使用的是立创EDA,工程较为简单，当然也会开源给各位开发者使用。

硬件成品

ART-PI 介绍

WZ-S-K 达特甲醛传感器介绍

WZ-S-K 型甲醛检测传感器模组是英国达特公司设计的一款基于电化学的甲醛检测传感器，具有测量精度高、响应速度快、使用寿命长、功耗低等特点。该传感器能够直接将周围环境中的甲醛含量转换为浓度值，通过串口标准化输出，这款甲醛检测传感器能够非常方便的集成到产品中去，适用于智能家居、便携式测量仪表等产品。

ALIENTEK 4.3 RGBLCD 介绍

ART-PI 开发板上面提供了一个 LCD 接口，该接口支持正点原子的 LCD 屏幕，rt-thread 官方也提供了 LCD驱动支持包。手头上刚好有这种 LCD 屏幕，这次准备在 ART-PI 上开发一个 GUI 界面，用于显示测量的甲醛浓度值等信息。

软件设计

本项目所有代码均使用 RT-Thread Studio 编写，经过一段时间的熟悉学习，发现使用 RT-Thread Studio 开展基于 RT-Thread 系统开发工作还是非常方便的，推荐各位开发者熟悉使用。

软件框架

RT-Thread 软件包及硬件驱动使用说明

能够使用 ART-PI 快速开发原型机的原因主要是基于RT-Thread 开放的生态资源，由于其本身开放的特性，我们可以在RT-Thread 软件包中快速找到适合我们硬件的相关软件包，并无缝适配 ART-PI，对于物联网开发者而言，我们只需要关心我们自己要实现的产品功能即可。笔者认为这也许成为了目前国内做大的物联网开放生态，希望我们共同维护，加油RT-Thread。

在本项目种，主要使用到了RT-Thread 种以下几个软件包和硬件驱动模块。

• 硬件驱动模块

• LCD Module
• UART Module
• WIFI Module

• 软件模块

• lwip
• finsh

软件模块设计

显示模块

ART-PI 提供有基于正点原子的 LCD 驱动支持包，可以直接在 RT-Thread Studio 中对应的工程中勾选 LCD 外设驱动让工程支持 LCD 。

该 LCD 驱动支持包仅仅提供了用于测试 LCD 相关的刷屏函数，直接使用该驱动还不能进行简单的 GUI 绘制，因此我们需要基于该驱动来编写相关的 GUI 图形绘制接口，这里笔者分享一下自己编写的绘图函数接口。

void LTDC_Draw_Point(uint16_t x,uint16_t y,uint32_t color,uint8_t update)
{ 
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	uint32_t c;
	if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
	{
			c = x+y*LCD_WIDTH;
			lcd->lcd_info.framebuffer[2 * c] = color&0xff;
			lcd->lcd_info.framebuffer[2 * c + 1] =  (color>>8)&0xff;
	}
	else if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB888)	
	{
			c = x+y*LCD_WIDTH;
			lcd->lcd_info.framebuffer[3 * c] = color&0xff;
			lcd->lcd_info.framebuffer[3 * c + 1] =  (color>>8)&0xff;
			lcd->lcd_info.framebuffer[3 * c + 2] =  (color>>16)&0xff;
	}
	if(update)lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
}





//在指定位置画一个指定大小的圆
//(x,y):中心点
//r    :半径
void LTDC_Draw_Circle(uint16_t x0,uint16_t y0,uint8_t r,uint32_t color)
{
	int a,b;
	int di;
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	a=0;b=r;	  
	di=3-(r<<1);             //判断下个点位置的标志

	while(a<=b)
	{
		LTDC_Draw_Point(x0+a,y0-b,color,0);//5
 		LTDC_Draw_Point(x0+b,y0-a,color,0);//0           
		LTDC_Draw_Point(x0+b,y0+a,color,0);//4               
		LTDC_Draw_Point(x0+a,y0+b,color,0);//6 
		LTDC_Draw_Point(x0-a,y0+b,color,0);//1       
 		LTDC_Draw_Point(x0-b,y0+a,color,0);//3            
		LTDC_Draw_Point(x0-a,y0-b,color,0);//2             
		LTDC_Draw_Point(x0-b,y0-a,color,0);//7     	         
		a++;
		//使用Bresenham算法画圆     
		if(di<0)di +=4*a+6;	  
		else
		{
			di+=10+4*(a-b);   
			b--;
		} 						    
	}
	lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);

} 


void LTDC_Fill_Point(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,uint32_t color)
{
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	uint32_t i=0;
	uint32_t j=0;

		for(j=y1;j<y2;j++)
		{
			for(i=x1;i<x2;i++)
			{
				LTDC_Draw_Point(i,j,color,0);
			}
		}
	lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
}

uint16_t  swap_color(uint16_t src_color)
{
    uint16_t ret_color;

    ret_color = ((src_color&0xff)<<8)+((src_color>>8)&0xff);

}

// 指定每一个坐标点的颜色填充
// swapmode 字节交换 1 开启  0 关闭
void LTDC_Color_Fill(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,uint16_t *color,uint8_t swapmode)
{
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	uint32_t i=0;
	uint32_t j=0;


	if(color ==NULL)
	{
	    LOG_D("[ %s ] error color null\n",__FUNCTION__);
        return;
	}
		
	for(j=y1;j<y2;j++)
	{
		for(i=x1;i<x2;i++)
		{
		    if(swapmode)
		    {
	            LTDC_Draw_Point(i,j,swap_color(*color),0);
		    }
		    else {
		        LTDC_Draw_Point(i,j,*color,0);
            }
			color++;
			//rt_kprintf("%04X \n",*color);

		}
	}
	lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
}




// 填充
void LTDC_Fill(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,uint32_t color)
{
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	uint32_t y_len;
	uint32_t c=0;
	uint32_t i=0;
	uint32_t j=0;
	
	if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
	{
		y_len = y2-y1+1;
		for(j=y1;j<y_len;j++)
		{
			for(i=x1;i<x2;i++)
			{
				c = i+j*LCD_WIDTH;
				lcd->lcd_info.framebuffer[2 * c] = color&0xff;
				lcd->lcd_info.framebuffer[2 * c + 1] =  (color>>8)&0xff;
			}
		}
	}
	lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);

}






void LTDC_FastDrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,uint32_t color)
{
	uint16_t t; 
	int xerr=0,yerr=0,delta_x,delta_y,distance; 
	int incx,incy,uRow,uCol; 
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	delta_x=x2-x1; //计算坐标增量 
	delta_y=y2-y1; 
	uRow=x1; 
	uCol=y1; 
	if(delta_x>0)incx=1; //设置单步方向 
	else if(delta_x==0)incx=0;//垂直线 
	else {incx=-1;delta_x=-delta_x;} 
	if(delta_y>0)incy=1; 
	else if(delta_y==0)incy=0;//水平线 
	else{incy=-1;delta_y=-delta_y;} 
	if( delta_x>delta_y)distance=delta_x; //选取基本增量坐标轴 
	else distance=delta_y; 
	for(t=0;t<=distance+1;t++ )//画线输出 
	{  
		LTDC_Draw_Point(uRow,uCol,color,0);//画点 
		xerr+=delta_x ; 
		yerr+=delta_y ; 
		if(xerr>distance) 
		{ 
			xerr-=distance; 
			uRow+=incx; 
		} 
		if(yerr>distance) 
		{ 
			yerr-=distance; 
			uCol+=incy; 
		} 
	}
	lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);

	
}

//画线
// 横线 竖线  
void LTDC_DrawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2,uint32_t color)
{
	
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
	uint32_t i=0;
	uint32_t c;

	// x2 >=x1   y2 >=y1
	if(x1==x2)
	{
		if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
		{
				for(i=y1;i<y2;i++)
				{
					c = x1+i*LCD_WIDTH;
					lcd->lcd_info.framebuffer[2 * c] = color&0xff;
					lcd->lcd_info.framebuffer[2 * c + 1] =  (color>>8)&0xff;
				}
		}
	}
	else if(y1==y2)
	{
		if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
		{
				for(i=x1;i<x2;i++)
				{
					c = i+y1*LCD_WIDTH;
					lcd->lcd_info.framebuffer[2 * c] = color&0xff;
					lcd->lcd_info.framebuffer[2 * c + 1] =  (color>>8)&0xff;
				}
		}
	}
	
	lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);

}




void LTDC_Clear(uint32_t color)
{
		struct drv_lcd_device *lcd;
    lcd = (struct drv_lcd_device *)rt_device_find("lcd");
		if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB565)
		 {
			 

				for (int i = 0; i < LCD_BUF_SIZE /2; i++)
				{
						lcd->lcd_info.framebuffer[2 * i] = color&0xff;
						lcd->lcd_info.framebuffer[2 * i + 1] =  (color>>8)&0xff;
				}
				lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
		 }
		 else if (lcd->lcd_info.pixel_format == RTGRAPHIC_PIXEL_FORMAT_RGB888)
		 {
				 for (int i = 0; i < LCD_BUF_SIZE / 3; i++)
				 {
						 lcd->lcd_info.framebuffer[3 * i] = color&0xff;
						 lcd->lcd_info.framebuffer[3 * i + 1] =(color>>8)&0xff;
						 lcd->lcd_info.framebuffer[3 * i + 2] = (color>>16)&0xff;
				 }
				 lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
		 }
}




//在指定位置显示一个字符
//x,y:起始坐标
//num:要显示的字符:" "--->"~"
//size:字体大小 12/16/24/32
//mode:叠加方式(1)还是非叠加方式(0)
void LTDC_ShowChar(uint16_t x,uint16_t y,uint8_t num,uint8_t size,uint32_t char_color,uint32_t back_color,uint8_t mode)
{  							  
  uint8_t temp,t1,t;
	uint16_t y0=y;
	uint8_t csize=(size/8+((size%8)?1:0))*(size/2);		//得到字体一个字符对应点阵集所占的字节数	
	struct drv_lcd_device *lcd;
	lcd = (struct drv_lcd_device *)rt_device_find("lcd");
 	num=num-' ';//得到偏移后的值（ASCII字库是从空格开始取模，所以-' '就是对应字符的字库）
	for(t=0;t<csize;t++)
	{   
		if(size==12)temp=asc2_1206[num][t]; 	 	//调用1206字体
		else if(size==16)temp=asc2_1608[num][t];	//调用1608字体
		else if(size==24)temp=asc2_2412[num][t];	//调用2412字体
		else if(size==32)temp=asc2_3216[num][t];	//调用3216字体
		else return;								//没有的字库
		for(t1=0;t1<8;t1++)
		{			    
			if(temp&0x80)LTDC_Draw_Point(x,y,char_color,0);
			else if(mode==0)LTDC_Draw_Point(x,y,back_color,0);
			temp<<=1;
			y++;
			if(y>=LCD_HEIGHT)return;		//超区域了
			if((y-y0)==size)
			{
				y=y0;
				x++;
				if(x>=LCD_WIDTH)return;	//超区域了
				break;
			}
		}  	 
	}
  lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
	
}


//m^n函数
//返回值:m^n次方.
uint32_t LTDC_Pow(uint8_t m,uint8_t n)
{
	uint32_t result=1;	 
	while(n--)result*=m;    
	return result;
}			 
//显示数字,高位为0,则不显示
//x,y :起点坐标	 
//len :数字的位数
//size:字体大小
//color:颜色 
//num:数值(0~4294967295);	 
void LTDC_ShowNum(uint16_t x,uint16_t y,uint32_t num,uint8_t len,uint8_t size,uint32_t char_color,uint32_t back_color)
{         	
	uint8_t t,temp;
	uint8_t enshow=0;						   
	for(t=0;t<len;t++)
	{
		temp=(num/LTDC_Pow(10,len-t-1))%10;
		if(enshow==0&&t<(len-1))
		{
			if(temp==0)
			{
				LTDC_ShowChar(x+(size/2)*t,y,' ',size,char_color,back_color,0);
				continue;
			}else enshow=1; 
		 	 
		}
	 	LTDC_ShowChar(x+(size/2)*t,y,temp+'0',size,char_color,back_color,0); 
	}
} 


//显示数字,高位为0,还是显示
//x,y:起点坐标
//num:数值(0~999999999);	 
//len:长度(即要显示的位数)
//size:字体大小
//mode:
//[7]:0,不填充;1,填充0.
//[6:1]:保留
//[0]:0,非叠加显示;1,叠加显示.
void LTDC_ShowxNum(uint16_t x,uint16_t y,uint32_t num,uint8_t len,uint8_t size,uint32_t char_color,uint32_t back_color,uint8_t mode)
{  
	uint8_t t,temp;
	uint8_t enshow=0;						   
	for(t=0;t<len;t++)
	{
		temp=(num/LTDC_Pow(10,len-t-1))%10;
		if(enshow==0&&t<(len-1))
		{
			if(temp==0)
			{
				if(mode&0X80)LTDC_ShowChar(x+(size/2)*t,y,'0',size,char_color,back_color,mode&0X01);  
				else LTDC_ShowChar(x+(size/2)*t,y,' ',size,char_color,back_color,mode&0X01);  
 				continue;
			}else enshow=1; 
		 	 
		}
	 	LTDC_ShowChar(x+(size/2)*t,y,temp+'0',size,char_color,back_color,mode&0X01); 
	}
} 



//显示字符串
//x,y:起点坐标
//width,height:区域大小  
//size:字体大小
//*p:字符串起始地址		  
void LTDC_ShowString(uint16_t x,uint16_t y,uint16_t width,uint16_t height,uint8_t size,uint8_t *p,uint32_t char_color,uint32_t back_color)
{         
	uint8_t x0=x;
	width+=x;
	height+=y;
    while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
    {       
        if(x>=width){x=x0;y+=size;}
        if(y>=height)break;//退出
        LTDC_ShowChar(x,y,*p,size,char_color,back_color,0);
        x+=size/2;
        p++;
    }  
}

上述GUI 图形绘制函数有参考正点原子开发板的LCD 驱动例程源码，然后笔者基于 LTDC驱动相关原理自己编写了适用于 ART-PI 的绘图函数，这几个函数可以直接加入到ART-PI的 LCD 驱动包中使用。有了这几个简单的 GUI 绘图函数，就可以在 LCD 上面完成基本的图形和字符显示了。

下面就基于以上LCD 绘制函数，编写一个 LCD 显示的 app,用来显示甲醛浓度值。

/*
 * PXBF
 * lcd_show
 * Date           Author       Notes
 * 2020-12-11     pxbf       first version
 */


#include <rtthread.h>
#include <rtdevice.h>
#include "drv_common.h"
#include "lcd_port.h"
#include "rttlogo.h"
#include "hchoimg.h"
rt_thread_t lcd_show_thread=RT_NULL;


extern struct rt_messagequeue mq;


/**
 *  LCD 显示
 * @param parameter
 */
static void lcd_show_thread_entry(void *parameter)
{

    uint16_t gas_ppb ;
    float gas_f;
    float gas_mg_m3;
    char float_str[10];

    /* LCD 显示  */
    LTDC_ShowString(10,2,360,32,32,"WZ-S-K Sensor Test",BLUE,WHITE);
    LTDC_FastDrawLine(0, 35, sizeof("WZ-S-K Sensor Test")*16, 35,BLUE);
    LTDC_ShowString(185,50,64,32,32,"ppm",BLUE,WHITE);
    LTDC_ShowString(185,85,90,32,32,"mg/m3",BLUE,WHITE);

    // 图片显示
    LTDC_Color_Fill(400,0,640,69,(uint16_t*)image_rttlogo,1);

    /*  hcho img 192*200   76800 Bytes */
    LTDC_Color_Fill(400,100,592,300,(uint16_t*)hcho_image,1);
    while (1)
    {
        /* 从消息队列中接收消息 */
        if (rt_mq_recv(&mq, &gas_ppb, sizeof(gas_ppb), RT_WAITING_FOREVER) == RT_EOK)
        {
//            rt_kprintf("lcd_show: recv msg from msg queue, the gas_ppb :%d\n", gas_ppb);

            /*
             *   甲醛浓度单位换算
             *   1ppm = 1000 ppb
             *   1000ppb 约为 1230ug/m3
             *
             *   1ppm 约为 1230ug/m3  即 1.230 mg/m3
             *
             *
             *  1ppm = 0.74666 mg/m3
             * */

            gas_f = (float)(gas_ppb/1000.0);
            gas_mg_m3 = gas_f * 0.74666;


            rt_memset(float_str, 0, sizeof(float_str));
            sprintf(float_str, "%.3f",gas_f);
            //显示屏显示数字
            //0.023 mg/L
            LTDC_ShowString(100,50,80,32,32,float_str,RED,WHITE);


            rt_memset(float_str, 0, sizeof(float_str));
            sprintf(float_str, "%.3f",gas_mg_m3);

            //rt_kprintf("HCHO: %s mg/m3\n", float_str);

            //rt_kprintf("gas full:%d %s\n",(sensor->full_range_high)*256+sensor->full_range_low,float_str);


            //显示屏显示数字
            LTDC_ShowString(100,85,80,32,32,float_str,RED,WHITE);
        }
        rt_thread_mdelay(5);
    }
}


int lcd_show(void)
{

  /* 创建 serial 线程 */
  if(lcd_show_thread)
  {
      rt_kprintf("sensor_thread is created\n");
      return -1;
  }
  lcd_show_thread = rt_thread_create("lcd_show", lcd_show_thread_entry, RT_NULL, 1024, 24, 10);
  /* 创建成功则启动线程 */
  if (lcd_show_thread != RT_NULL)
  {
      rt_thread_startup(lcd_show_thread);
  }
  else
  {
      rt_kprintf("lcd_show_thread create error\n");
  }

  return 0;
}


INIT_APP_EXPORT(lcd_show);

传感器数据读取

WZ-S-K 传感器使用的是串行通信方式来完成数据输出，串口配置参数为 9600-8-1-N ，即波特率为 9600、数据位8位、停止位1位、无校验位。该传感器支持两种通信模式，分别位主动上传模式和问答模式，传感器默认为主动上传模式，每间隔1秒上传一次数据。在主动上传模式下，通信协议如下。

|0|1|2|3|4|5|6|7|8|
|----|----|
|起始位|气体名称|单位|小数位数(无)|气体浓度(高位)|气体浓度(低位)|满量程(高位)|满量程(低位)|校验值|
|0xFF|HCHO=0X17|Ppb=0x04|0x00|0x00|0x25|0x07|0xD0|0x25|

该通信协议中的校验值采用的是和校验，校验计算相关函数如下。

/*************************************************************************
*函数名： unsigned char FucCheckSum(uchar *i,ucharln)
*功能描述：求和校验（取发送、接收协议的 1\2\3\4\5\6\7 的和取反+1）
*函数说明：将组数的元素 1-倒数第二个元素相加后取反+1（元素个数必须大于 2）
*************************************************************************/
unsigned char FucCheckSum(unsigned char *i, unsigned char ln)
{
unsigned char j, tempq=0;
i+=1;
for(j=0; j<(ln-2); j++)
{
tempq+=*i;
i++;
}
tempq=(~tempq)+1;
return(tempq);
}

根据该通信协议，可以将气体的浓度值输出出来，气体浓度值的计算方法如下。

气体浓度值= 气体浓度高位*256+气体浓度低位

气体浓度的单位为 ppb

举个例子，上述通信协议中传输的气体浓度值为 0*256+0x25 = 37(十进制) ppb

这里说明一下气体浓度单位相关换算，气体中 ppb 、ppm 和 ppt 的单位换算如下。

1ppm = 1000 ppb
1ppb = 1000 ppt

ppm 为 10 的 -6 次方
ppb 为 10 的 -9 次方
ppt 为 10 的 -12 次方

那么 ppb 和 mg/m3 之间该如何换算呢？经过和供应商沟通，他们提供了如下的换算关系。

1000 ppb 约等于 1230 ug/m3

1ppm = 1000 ppb
因此，1ppm 约为 1230 ug/m3

根据测得的甲醛浓度值，通过分析，我们可以对当前环境进行一个甲醛含量的简单评估，国家标准中《居室空气中甲醛的卫生标准》所规定的居室空气中甲醛的最高容许浓度为0.08毫克/立方米。

下面开始编写代码，利用 ART-PI 上的 UART1 连接 WZ-S-K 甲醛传感器，获取甲醛浓度值。

首先在 RT-Thread Settings 中使能 UART1。

然后，参考 RT-Thread 的官方文档中心中UART设备-串口设备使用示例，来编写甲醛传感器的串口读写程序，这里使用的是中断接收及轮询发送方式。

注意这里使用线程间通信中的消息队列的方式，将读取到的甲醛浓度值传递给LCD显示的app，中，用来显示甲醛浓度。

/*
 * PXBF
 * Dart sensor app
 * Date           Author       Notes
 * 2020-11-30     pxbf       first version
 */


#include <rtthread.h>
#include <rtdevice.h>
#include "drv_common.h"
#include "lcd_port.h"

#define SAMPLE_UART_NAME       "uart1"
static rt_device_t serial;
struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
/* 用于接收消息的信号量 */
static struct rt_semaphore rx_sem;
rt_thread_t sensor_thread=RT_NULL;


/* 消息队列控制块 */
struct rt_messagequeue mq;
/* 消息队列中用到的放置消息的内存池 */
static rt_uint16_t msg_pool[1024];



/*达特 WZ-S-K 传感器数据通信结构体*/
typedef struct
{

 uint8_t start_bit ; /*起始位*/
 uint8_t gas_name  ; /*气体名称*/
 uint8_t unit ;     /*单位*/
 uint8_t decimal_places ; /*小数位数*/
 uint8_t gas_density_high ; /*气体浓度高位*/
 uint8_t gas_density_low ; /*气体浓度低位*/
 uint8_t full_range_high ; /*满量程高位*/
 uint8_t full_range_low ; /*满量程低位*/
 uint8_t checksum_value ; /*校验值*/
}Dart_Sensor ;



/*************************************************************************
*函数名： unsigned char FucCheckSum(uchar *i,ucharln)
*功能描述：求和校验（取发送、接收协议的 1\2\3\4\5\6\7 的和取反+1）
*函数说明：将组数的元素 1-倒数第二个元素相加后取反+1（元素个数必须大于 2）
*************************************************************************/
unsigned char FucCheckSum(unsigned char *i, unsigned char ln)
{
    unsigned char j, tempq=0;
    i+=1;
    for(j=0; j<(ln-2); j++)
    {
    tempq+=*i;
    i++;
    }
    tempq=(~tempq)+1;
    return(tempq);
}


/* 接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    /* 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 */
    rt_sem_release(&rx_sem);

    return RT_EOK;
}

/**
 * 传感器数据接收处理线程
 * @param parameter
 */
static void sensor_thread_entry(void *parameter)
{
    int result;
    char ch;
    char i;
    static char start_byte=0;
    static char darte[9]; //达特甲醛传感器数据
    uint16_t gas_ppb=0;
    char count=0;
    unsigned char checksum;
    Dart_Sensor *sensor;


    while (1)
    {
        /* 从串口读取一个字节的数据，没有读取到则等待接收信号量 */
        while (rt_device_read(serial, -1, &ch, 1) != 1)
        {
            /* 阻塞等待接收信号量，等到信号量后再次读取数据 */
            rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
        }
        /* 读取到的数据通过串口错位输出 */
        //ch = ch + 1;
        //rt_device_write(serial, 0, &ch, 1);

        //rt_kprintf("%02X ",ch);

        if(start_byte!=0xff)
        {
            start_byte = ch;
        }

        if(start_byte == 0xff)//起始位
        {

            darte[count]=ch;

            count++;
            if(count==9)
            {


                sensor=&darte[0];
                checksum = FucCheckSum(&darte[0],sizeof(Dart_Sensor)); //字节总长度位9个字节

                if(checksum == sensor->checksum_value)
                {
                    gas_ppb =(uint16_t)((sensor->gas_density_high)*256+sensor->gas_density_low) ;

                    /* 发送消息到消息队列中 */
                    result = rt_mq_send(&mq, &gas_ppb, 2);
                    if (result != RT_EOK)
                    {
                        rt_kprintf("rt_mq_send ERR\n");
                    }
                }
                else {
                    rt_kprintf("get wz-s-k sensor data error\n");
                }
                count=0;
                start_byte=0;
            }
        }



    }
}


int dart_sensor(void)
{

    rt_err_t result;

    /* step1：查找串口设备 */
    serial = rt_device_find(SAMPLE_UART_NAME);

    /* step2：修改串口配置参数 */
    config.baud_rate = BAUD_RATE_9600;        //修改波特率为 9600
    config.data_bits = DATA_BITS_8;           //数据位 8
    config.stop_bits = STOP_BITS_1;           //停止位 1
    config.bufsz     = 128;                   //修改缓冲区 buff size 为 128
    config.parity    = PARITY_NONE;           //无奇偶校验位

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

    rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);

    /* 以中断接收及轮询发送模式打开串口设备 */
  rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
  /* 设置接收回调函数 */
  rt_device_set_rx_indicate(serial, uart_input);




  /* 初始化消息队列 */
  result = rt_mq_init(&mq,
                      "mqt",
                      &msg_pool[0],             /* 内存池指向 msg_pool */
                      2,                          /* 每个消息的大小是 1 字节 */
                      sizeof(msg_pool),        /* 内存池的大小是 msg_pool 的大小 */
                      RT_IPC_FLAG_FIFO);       /* 如果有多个线程等待，按照先来先得到的方法分配消息 */

  if (result != RT_EOK)
  {
      rt_kprintf("init message queue failed.\n");
      return -1;
  }


  /* 创建 serial 线程 */
  if(sensor_thread)
  {
      rt_kprintf("sensor_thread is created\n");
      return -1;
  }
  sensor_thread = rt_thread_create("sensor", sensor_thread_entry, RT_NULL, 1024, 25, 10);
  /* 创建成功则启动线程 */
  if (sensor_thread != RT_NULL)
  {
      rt_thread_startup(sensor_thread);
  }
  else
  {
      rt_kprintf("serial thread create error\n");
  }

  //    rt_device_close(serial);
  return 0;
}


INIT_APP_EXPORT(dart_sensor);
MSH_CMD_EXPORT(dart_sensor, dart HCHO sensor test);


int dart_close(void)
{
    if(sensor_thread)
    {
        rt_thread_delete(sensor_thread);
        sensor_thread=RT_NULL;
        LTDC_Clear(WHITE);
        serial = rt_device_find(SAMPLE_UART_NAME);
        if(serial)
            rt_device_close(serial);
        //信号量脱离
        rt_sem_detach(&rx_sem);
    }
    else {
        rt_kprintf("dart sensort thread not create,please run dart_sensor cmd\n");
    }
}

MSH_CMD_EXPORT(dart_close, close dart sensor test);

效果展示

优化

优化 LCD UI 设计

优化通信功能

优化甲醛检测仪的通信功能，支持甲醛检测仪连接 ONENET 物联网平台。

参考文档

• 《WZ-S-K 型甲醛检测模组使用说明书》
• 《正点原子RGB-LCD 驱动》