[第3期空气质量分析仪]第三周作业

发布于 2019-10-28 21:25:04 浏览：1127 订阅该版

这周作业相对前两周任务量还是比较大的，主要是对线程间通信和邮箱邮件的使用，做起来还是很烧脑的，还是刚开始对内核部分理解的不够深刻，
本次工作的一部分是
异步日志，我主要是使用邮箱内存池，检测邮箱邮件然后实现打印；具体代码如下：
```
#define MP_BLOCK_SIZE  RT_ALIGN(sizeof(struct tmp_msg), sizeof(intptr_t)) /* 为了字节对齐 */
/*线程优先级，时间片*/
#define THREAD_PRIORTY  11
#define THREAD_TIMESLICE 5
/* 邮件大小*/
#define size  (4)
/*静态线程大小*/
static char mylog_stack[4096];
/*线程句柄*/
static struct rt_thread temp_rade_mb;
rt_thread_t humi_thread;
rt_thread_t pm25_thread;
/*邮箱控制块，邮箱大小*/
static char mb_pool[512];
static char mb_humi_pool[512];
static char mb_pm25_pool[512];

static struct rt_mailbox mb_temp;     //温度邮箱
static struct rt_mailbox mb_humi;     //湿度邮箱
static struct rt_mailbox mb_pm25;     //PM2.5邮箱

/*****全局变量声明*****/
extern int humi_switch;
extern int temp_switch;
extern int pm25_switch;
extern int pm25_vol;
extern int humi_vol;
extern int temp_vol;

struct recvdata                                     /* 定义一个结构体存放接收的数据 */
{
 char *name;
 float data;		
};

void mylog(int equipment_sign, char*name, float data)
{
	struct recvdata *temp;	
	temp=(struct recvdata *)malloc(sizeof(struct recvdata));
	struct recvdata *humi;	
	humi=(struct recvdata *)malloc(sizeof(struct recvdata));
	struct recvdata *pm25;	
	pm25=(struct recvdata *)malloc(sizeof(struct recvdata));
	switch(equipment_sign)
	{	
		case(1):	
		temp->name = name;
		temp->data = data;
		temp_vol = data;
//		rt_kprintf("name:%s ",name);
//		rt_kprintf("name:%s ",temp->name);
 if(temp->name != NULL)
		rt_mb_send(&mb_temp,(rt_uint32_t )temp) ;temp = NULL; break;
		case(2):
		humi->name = name;
		humi->data = data;
		humi_vol = data;
		if(humi->name != NULL)
		rt_mb_send(&mb_pm25,(rt_uint32_t )humi) ; humi = NULL; break;
		case(3):
		pm25->name = name;
		pm25->data = data;
		pm25_vol = data;
		if(pm25->name != NULL)
		rt_mb_send(&mb_pm25,(rt_uint32_t )pm25) ; break;
 }
}

/* 读取温度入口函数 */
static void temp_entry(void *param)
{
 struct recvdata *equipment;
	char str[80];
 equipment=(struct recvdata *)malloc(sizeof(struct recvdata));
 while(1)
 {		
		if( temp_switch != 0)
 if(rt_mb_recv(&mb_temp,(rt_ubase_t *)&equipment,RT_WAITING_FOREVER == RT_EOK))
 {
			sprintf(str, "[%s]data is: %d ",equipment->name,(int)equipment->data);
 rt_kprintf(str);
			
 equipment = RT_NULL; /* 清空数据 */
 /* 延时100ms */
 rt_thread_mdelay(1000);
 }
 }
}
/* 读取湿度线程入口函数 */
static void read_humi_entry(void *param)
{
	 struct recvdata *equipment;
	 char str[80];
 equipment=(struct recvdata *)malloc(sizeof(struct recvdata));
 while(1)
 {		
		if( humi_switch != 0)
 if(rt_mb_recv(&mb_humi,(rt_ubase_t *)&equipment,RT_WAITING_FOREVER == RT_EOK))
 {
			sprintf(str, "[%s]data is: %d ",equipment->name,(int)equipment->data);
 rt_kprintf(str);
			
 equipment = RT_NULL; /* 清空数据 */
 /* 延时100ms */
 rt_thread_mdelay(1000);
 }
 }
}

static void read_pm25_entry(void *param)
{
	 struct recvdata *equipment;
	 char str[80];
 equipment=(struct recvdata *)malloc(sizeof(struct recvdata));
 while(1)
 {		
		if( pm25_switch != 0)
 if(rt_mb_recv(&mb_pm25,(rt_ubase_t *)&equipment,RT_WAITING_FOREVER == RT_EOK))
 {
			sprintf(str, "[%s]data is: %d ",equipment->name,(int)equipment->data);
 rt_kprintf(str);
			
 equipment = RT_NULL; /* 清空数据 */
 /* 延时100ms */
 rt_thread_mdelay(1000);
 }
 }
}

/* 初始化读取线程 邮箱  */
int mylog_init(void)
{

/*初始化邮箱（mailbox）*/
 rt_err_t result;
 result = rt_mb_init(&mb_temp,
 "mb_temp",
 &mb_pool[0],
 sizeof(mb_pool)/4,RT_IPC_FLAG_FIFO);
 if(result != RT_EOK)
 {
 rt_kprintf("the mailbox initia failed ");
 return -1;
 }
/* shidu-mb */	
 result = rt_mb_init(&mb_humi,
 "mb_humi",
 &mb_humi_pool[0],
 sizeof(mb_humi_pool)/4,RT_IPC_FLAG_FIFO);
 if(result != RT_EOK)
 {
 rt_kprintf("the mailbox initia failed ");
 return -1;
 }
/* pm2.5-mb */		
	 result = rt_mb_init(&mb_pm25,
 "mb_pm25",
 &mb_pm25_pool[0],
 sizeof(mb_pm25_pool)/4,RT_IPC_FLAG_FIFO);
 if(result != RT_EOK)
 {
 rt_kprintf("the mailbox initia failed ");
 return -1;
 }
/***************thread**********/	
 humi_thread = rt_thread_create("humi_thread", read_humi_entry, "humi",
	 640, RT_THREAD_PRIORITY_MAX / 2, 20);
	
	 if (humi_thread != RT_NULL)
 {
 rt_thread_startup(humi_thread);
 }
	
 pm25_thread = rt_thread_create("pm25_thread", read_pm25_entry, "pm25",
	 640, RT_THREAD_PRIORITY_MAX / 2, 20);
	
	 if (pm25_thread != RT_NULL)
 {
 rt_thread_startup(pm25_thread);
 }
	
/* tempture-thread */		
 rt_thread_init(&temp_rade_mb,
 "temp_rade_mb",
 temp_entry,
 RT_NULL,
 &mylog_stack[0],
 sizeof(mylog_stack),
 RT_THREAD_PRIORITY_MAX /2,THREAD_TIMESLICE);
 rt_thread_startup(&temp_rade_mb);

return 0;
}```其它就是按键和led部分了：
```
void key_pin_0(void * args)
{

rt_thread_mdelay(20);
	k0_vol++;
	if(k0_vol%2 == 1)
	{
	  temp_switch = 1;
	  humi_switch = 0;
	}
	else
	{
		
		temp_switch = 0;
	    humi_switch = 0;
	}
    
}
void key_pin_1(void * args)
{
	k1_vol++;
	
	if(k1_vol%2 == 1)
	{
       temp_switch = 0;
	  humi_switch = 1;
	}
	else
	{
		temp_switch = 0;
	    humi_switch = 0;
	}

}

void key_pin_2(void * args)
{

k2_vol++;
	
	if(k2_vol%2 == 1)
	{
       
	  pm25_switch = 1;
	}
	else
	{
		pm25_switch = 0;
	}

}

void key_init(void)
{
    rt_pin_mode(key_0, PIN_MODE_INPUT_PULLUP);
    rt_pin_attach_irq(key_0, PIN_IRQ_MODE_FALLING, key_pin_0, RT_NULL);
    rt_pin_irq_enable(key_0, PIN_IRQ_ENABLE);

rt_pin_mode(key_1, PIN_MODE_INPUT_PULLUP);
    rt_pin_attach_irq(key_1, PIN_IRQ_MODE_FALLING , key_pin_1, RT_NULL);
    rt_pin_irq_enable(key_1, PIN_IRQ_ENABLE);
	
	rt_pin_mode(key_2, PIN_MODE_INPUT_PULLUP);
    rt_pin_attach_irq(key_2, PIN_IRQ_MODE_FALLING , key_pin_2, RT_NULL);
    rt_pin_irq_enable(key_2, PIN_IRQ_ENABLE);
	
}```led：
```#define temp_threshold    40
#define humi_threshold    70
#define pm25_threshold    3000

extern int pm25_vol;
extern int humi_vol;
extern int temp_vol;
extern int humi_switch;
extern int temp_switch;
extern int pm25_switch;

rt_thread_t led_thread;

/*接口可以初始化 led*/
void led_init()
{
    /* set LED0 pin mode to output */
    rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    rt_pin_write(LED0_PIN, PIN_HIGH);
}
/*接口可以点亮 led*/
void led_on()
{
    rt_pin_write(LED0_PIN, PIN_LOW);
}
/* 接口可以熄灭 led*/
void led_off()
{
    rt_pin_write(LED0_PIN, PIN_HIGH);
}
/*接口可以使 led 闪烁，200ms 闪烁周期*/
void led_blink()
{
    rt_pin_write(LED0_PIN, PIN_HIGH);
    rt_thread_mdelay(200);
    rt_pin_write(LED0_PIN, PIN_LOW);
    rt_thread_mdelay(200);
    rt_pin_write(LED0_PIN, PIN_HIGH);
    rt_thread_mdelay(200);
    rt_pin_write(LED0_PIN, PIN_LOW);
    rt_thread_mdelay(200);
	rt_pin_write(LED0_PIN, PIN_HIGH);
}

void led_entry(void *param)
{
  while(1)
  {
		
	if(pm25_switch || humi_switch || temp_switch)
	{	
		rt_kprintf("temp_vol: %d  , humi_vol:%d ,pm25_vol:%d",temp_vol,humi_vol,pm25_vol);
		if(temp_vol > temp_threshold||humi_vol > humi_threshold||pm25_vol > pm25_threshold)
		{
			led_on();
		}
		else
		{
			led_blink();
		}
	}
	rt_thread_mdelay(1000);
  }
}

void led_star(void)
{
   led_thread = rt_thread_create("led_thread", led_entry, "led",
	                                640, RT_THREAD_PRIORITY_MAX/2-2, 20);
	
	   if (led_thread != RT_NULL)
    {
        rt_thread_startup(led_thread);
    }
}```现象如下：
![temp.png](/uploads/201910/28/211742idjevso5owgsjgdw.png)![PM2.55.png](/uploads/201910/28/211819cfel0ztowwq6yces.png)
在做的过程中还是遇到很多问题，现象中也有没解决的传感器切换的过程中会有一个乱码，以及解决过的打印重叠问题，以及线程删除，数据丢失，
这些大部分原因是线程优先级问题以及申请内存空间处理问题，按键控制线程目前还没搞懂为啥出错，所以我暂且使用了标志。这周任务发现很多问题，
我会一一总结下来希望自己能在以后少走弯路，加油！！希望自己能把这个系统越用越好。