RT-Thread-[第二期空气质量分析仪] 第2周作业RT-Thread问答社区

[第二期空气质量分析仪] 第2周作业

发布于 2019-09-02 21:30:39 浏览：1073 订阅该版

任务概述:  一  创建线程, 调用温湿度读取接口;  二  编写pm2.5传感器驱动, 应用程创建线程, 读取pm2.5传感器数据.

周末学习摸索了两天, 终于出结果了.
pm2.5传感器输出位串口, 使用的是DMA接收模式
由于串口不能打印浮点型, 所以把整数部分和小数部分分开打印, 出来的效果还可以.

任务一:

temp_humi_th.c
```
#ifndef STM32F103ZET6_NANO
/* defined the DHT11 DATA pin: PG11 */
#define DHT11_DATA_PIN    GET_PIN(G, 11)

#else

/* defined the DHT11 DATA pin: PE15 */
#define DHT11_DATA_PIN    GET_PIN(E, 15)	
#endif

struct temp_humi
{
	rt_uint8_t  temp;
	rt_uint8_t  humi;
} temp_humi_data = {0,0};

static rt_device_t dev = RT_NULL;

/* 温湿度读取线程入口 */
void temp_humi_entry (void *parameter)
{
    //rt_device_t dev = RT_NULL;
    struct rt_sensor_data sensor_data;
    rt_size_t res;

while (1)
    {
        res = rt_device_read(dev, 0, &sensor_data, 1);

if (res != 1)
 {
 rt_kprintf("read data failed! result is %d ", res);
 rt_device_close(dev);
 return;
 }
 else
 {
 if (sensor_data.data.temp >= 0)
 {
 temp_humi_data.temp = (sensor_data.data.temp & 0xffff) >> 0; // get temp
 temp_humi_data.humi = (sensor_data.data.temp & 0xffff0000) >> 16; // get humi
 //rt_kprintf("temp:%d, humi:%d " ,temp_humi_data.temp, temp_humi_data.humi);
 }
 }
				dht11_read_temp();
				dht11_read_humi();

rt_thread_delay(1000);
    }	
	
}

/* 温湿度初始化, 初始化线程 */
void temp_humi_init (void)
{
		dht11_hw_init();
		temp_humi_thread_start();
	
	
}

/* 温湿度初始化, 初始化线程 */
rt_uint8_t temp_humi_thread_start (void)
{
    rt_thread_t dht11_thread;

dht11_thread = rt_thread_create("temp_humi",
                                     temp_humi_entry,
                                     RT_NULL,
                                     1024,
                                     RT_THREAD_PRIORITY_MAX / 2,
                                     20);
    if (dht11_thread != RT_NULL)
    {
        rt_thread_startup(dht11_thread);
    }

return RT_EOK;	
	
	
}

/* dht11初始化 */
rt_uint8_t dht11_hw_init (void)
{
    struct rt_sensor_config cfg;
	
    
    rt_uint8_t get_data_freq = 1; /* 1Hz */
    
    cfg.intf.user_data = (void *)DHT11_DATA_PIN;
    rt_hw_dht11_init("dht11", &cfg);

dev = rt_device_find("temp_dht11");
    if (dev == RT_NULL)
    {
        return RT_ERROR;
    }

if (rt_device_open(dev, RT_DEVICE_FLAG_RDWR) != RT_EOK)
 {
 rt_kprintf("open device failed! ");
 return RT_ERROR;
 }

rt_device_control(dev, RT_SENSOR_CTRL_SET_ODR, (void *)(&get_data_freq));

return RT_EOK;
	
}

/* dht11读取温湿度数据 */
rt_uint8_t dht11_read_temp (void)
{
	rt_kprintf("temp:%d " ,temp_humi_data.temp);
	
	return temp_humi_data.temp;
	
}

/* dht11读取温湿度数据 */
rt_uint8_t dht11_read_humi (void)
{
	rt_kprintf("humi:%d " ,temp_humi_data.humi);
	
	return temp_humi_data.humi;
}

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(temp_humi_init, temp humi init);```

任务二:
Drivers文件
pm25.c
```#define DATA_BYTE_NUM        9
#define ZPH_UART_NAME       "uart3"  /* 串口设备名称 */
static rt_device_t serial;              /* 串口设备句柄 */
struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT; /* 配置参数 */
rt_mutex_t mutex_lock;			/* 定义互斥量 */

struct rx_pm25_data rx_pm25;

/* 串口接收消息结构*/
struct rx_msg
{
    rt_device_t dev;
    rt_size_t size;
};
/* 消息队列控制块 */
static struct rt_messagequeue rx_mq;

int zph02_hw_init(void)
{
 rt_err_t ret = RT_EOK;
	 static char msg_pool[64];
	
 /* 查找串口设备 */
 serial = rt_device_find(ZPH_UART_NAME);
 if (!serial)
 {
 rt_kprintf("find %s failed! ", ZPH_UART_NAME);
 return RT_ERROR;
 }
		
		
		 /* 初始化消息队列 */
 rt_mq_init(&rx_mq, "rx_mq",
 msg_pool, /* 存放消息的缓冲区 */
 sizeof(struct rx_msg), /* 一条消息的最大长度 */
 sizeof(msg_pool), /* 存放消息的缓冲区大小 */
 RT_IPC_FLAG_FIFO); /* 如果有多个线程等待，按照先来先得到的方法分配消息 */
							 
							 /* DMA接收模式 */
		rt_device_open(serial, RT_DEVICE_FLAG_DMA_RX);
		
		config.baud_rate = BAUD_RATE_9600;
		config.data_bits = DATA_BITS_8;
		config.stop_bits = STOP_BITS_1;
		config.parity = PARITY_NONE;
		/* 打开设备后才可修改串口配置参数 */
		rt_device_control(serial, RT_DEVICE_CTRL_CONFIG, &config);
							 
 /* 设置接收回调函数 */
 rt_device_set_rx_indicate(serial, uart_input);
							 /* 发送字符串,此处不需要发送指令 */
// rt_device_write(serial, 0, str, (sizeof(str) - 1));
		/* 创建互斥量 */
		mutex_lock = rt_mutex_create("mutex_zph02", RT_IPC_FLAG_FIFO);

/* 创建 serial 线程 */
    rt_thread_t thread = rt_thread_create("serial", serial_thread_entry, RT_NULL, 1024, 25, 10);
    /* 创建成功则启动线程 */
    if (thread != RT_NULL)
    {
        rt_thread_startup(thread);
    }
    else
    {
        ret = RT_ERROR;
    }

return ret;
		
	
}

/* 接收数据回调函数 */
static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
{
    struct rx_msg msg;
    rt_err_t result;
    msg.dev = dev;
    msg.size = size;

result = rt_mq_send(&rx_mq, &msg, sizeof(msg));
 if ( result == -RT_EFULL)
 {
 /* 消息队列满 */
 rt_kprintf("message queue full！ ");
 }
 return result;
}

static void serial_thread_entry(void *parameter)
{
    struct rx_msg msg;
    rt_err_t result;
    rt_uint32_t rx_length;
    static rt_uint8_t rx_buffer[RT_SERIAL_RB_BUFSZ + 1];

while (1)
    {
        rt_memset(&msg, 0, sizeof(msg));
        /* 从消息队列中读取消息*/
        result = rt_mq_recv(&rx_mq, &msg, sizeof(msg), RT_WAITING_FOREVER);
        if (result == RT_EOK)
        {
						
            /* 从串口读取数据*/
            rx_length = rt_device_read(msg.dev, 0, rx_buffer, msg.size);
            rx_buffer[rx_length] = '\0';
						/* 解析数据*/
						zph02_get_data(rx_buffer, rx_length);

}
    }
}

/* 解析收到的数据 */
void zph02_get_data (rt_uint8_t *buf, rt_size_t size)
{
		rt_err_t result;
		rt_uint8_t i = 0;
		rt_uint8_t flag = 0;
		rt_uint8_t posi;
		
		do{
				if(buf* == 0xFF)
				{
						flag = 1;
						posi = i;
						break;
				}
				i++;
			
		}while(i < size);
		
		if(flag && size - posi >= DATA_BYTE_NUM)
		{
				/* 获取互斥量 */
				result = rt_mutex_take(mutex_lock, RT_WAITING_FOREVER);
				if (result == RT_EOK)
				{
						result = fuc_check_sum(&buf[posi], DATA_BYTE_NUM);
						if(result == RT_EOK)
						{
								rx_pm25.integer = buf[posi + 3];
								rx_pm25.decimal = buf[posi + 4];
								//rt_kprintf("read pm2.5: %d.%02d%% ",rx_pm25.integer, rx_pm25.decimal);
						}
						else rt_kprintf("read pm2.5: check sum error ");
				
				}
				rt_mutex_release(mutex_lock); 	/* 释放互斥量 */
			
		}
		
}

rt_err_t zph02_read_pm25(struct rx_pm25_data *data)
{
		rt_err_t result;
	
		/* 获取互斥量 */
		result = rt_mutex_take(mutex_lock, RT_WAITING_FOREVER);
		if (result == RT_EOK)
				{
					data->decimal = rx_pm25.decimal;
					data->integer = rx_pm25.integer;
					
				}
		rt_mutex_release(mutex_lock);   /* 释放互斥量 */
		if(result == RT_EOK)
				return RT_EOK;
		else
				return RT_ERROR;
	
}

/* 校验 */
rt_uint8_t fuc_check_sum(rt_uint8_t *buf, rt_size_t size)
{
		rt_uint8_t j, tempq = 0;
		
		buf += 1;
		for(j = 0; j < size-2; j++)
		{
				tempq += *buf;
				buf++;
		
		}
		
		tempq = ~tempq + 1;
		
		if(*buf == tempq)
			return RT_EOK;
		else 
			return RT_ERROR;
	
}```

Applications文件夹
pm25_th.c
```#define THREAD_PM25_STACK_SIZE   256

struct rx_pm25_data pm25data;
static rt_thread_t pm25_thread = RT_NULL;

void pm25_entry (void *parameter)
{
		rt_err_t result;
	
		while(1)
		{
				result = zph02_read_pm25(&pm25data);
		
				if(result == RT_EOK)
						rt_kprintf("get pm2.5: %d.%02d%% ",pm25data.integer, pm25data.decimal);
				else
						rt_kprintf("get pm2.5 fail ! ");
				
				rt_thread_mdelay(900);
		
		}
	
	
	
}

void pm25_init (void)
{
			zph02_hw_init();
	
			pm25_thread = rt_thread_create("thread_pm25",
														pm25_entry, RT_NULL,
														THREAD_PM25_STACK_SIZE,
														10, 10
														);
	
			if(pm25_thread != RT_NULL)
					rt_thread_startup(pm25_thread);
			rt_kprintf("thread1_pm25 created ");
	
}

/* 导出到 msh 命令列表中 */
MSH_CMD_EXPORT(pm25_init, pm25 init);
```

最后输出的数据

![微信图片_20190902211825.png](/uploads/201909/02/211918yybeqyc14fvld0ye.png)