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

发布于 2019-10-29 11:08:54 浏览：803 订阅该版

为期3周的学习营就快结束了，rtthread 还是很值的学习的，学习营只是接触了个皮毛，接下来准备看看书，研究研究具体实现。也非常感谢学习营各位大神的指导。
**
任务一：**
见下面代码，我这样写 mylog() 传的都是指针，有一个问题就是数据需要立即处理。可能用 malloc 更好，但是并没有看到有人把 malloc 给 free。或者中间用环形队列存数据更好。

mylog.h:
```#ifndef __PM25_TH_H__
#define __PM25_TH_H__

typedef struct __mylog_TypeDef
{
    char* fileStr;
    void* data;
}mylog_TypeDef;

typedef mylog_TypeDef* mylog_TypeDef_t;

void mylog(char* TAG, void* data);
int mylog_init(void);

#endif```

mylog.c:
```#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#include "mylog.h"

static rt_thread_t async_tid = RT_NULL;
static struct rt_mailbox mb;
static char mb_pool[128];

void mylog(char* TAG, void* data)
{
    static mylog_TypeDef g_mylogStruct;
    g_mylogStruct.fileStr = TAG;
    g_mylogStruct.data = data;
    
    rt_mb_send(&mb, (rt_ubase_t)&g_mylogStruct);
}

static void mylog_thread_entry(void* param)
{
    mylog_TypeDef_t pstr;
    
    while(1){
        if(rt_mb_recv(&mb, (rt_ubase_t *)&pstr, RT_WAITING_FOREVER) == RT_EOK){
            rt_kprintf("[%s] data is: %d.%d<br>", pstr->fileStr, (int)*(float*)pstr->data, (int)(*(float*)pstr->data * 10) % 10);
        }
    }
}

int mylog_init(void)
{
    rt_err_t result;
    
    result = rt_mb_init(&mb,
                        "mbt",                      /* 名称是 mbt */
                        &mb_pool[0],                /* 邮箱用到的内存池是 mb_pool */
                        sizeof(mb_pool) / 4,        /* 邮箱中的邮件数目，因为一封邮件占 4 字节 */
                        RT_IPC_FLAG_FIFO);          /* 采用 FIFO 方式进行线程等待 */
    
    if (result != RT_EOK){
        rt_kprintf("init mailbox failed.<br>");
        return -1;
    }

async_tid = rt_thread_create("mylog",
                                 mylog_thread_entry, RT_NULL,
                                 1024,
                                 RT_MAIN_THREAD_PRIORITY - 2,
                                 20
                                );
    
    if(async_tid != RT_NULL)
        rt_thread_startup(async_tid);
    
    return 0;
}```

**任务二：**

我这个框架如下，exti 中断优先级最高，led_entry 及 mylog_thread_entry 其次，pm25_entry 及 temp_humi_entry 最低。led_entry 挂起等待事件，mylog_thread_entry 挂起等待邮件。exti 置位全局变量，led_entry 及 mylog_thread_entry 发送事件及邮件，led_entry 及 mylog_thread_entry 唤醒。

我这个框架感觉有个问题，就是并没有实现rtthread的优势，还是同步方式，没有实现异步方式。我觉得应该 pm25_entry 及 temp_humi_entry 优先级最高，在他们rt_thread_mdelay()的时候，led_entry 及 mylog_thread_entry 才运行，这样比较好。不过功能实现了就懒得改了:lol

key.h:
```#ifndef __KEY_H__
#define __KEY_H__

#define PIN_KEY2        GET_PIN(D, 8)      // PD8 :  KEY2         --> KEY
#define PIN_KEY1        GET_PIN(D, 9)      // PD9 :  KEY1         --> KEY
#define PIN_KEY0        GET_PIN(D, 10)     // PD10:  KEY0         --> KEY

typedef enum{
    KEY_TURN_OFF,
    KEY_TURN_ON
}KEY_StateTypeDef;

extern KEY_StateTypeDef TH_State;
extern KEY_StateTypeDef PM25_State;

void key_init();
#endif```

key.c:
```#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#include "led_alert.h"
#include "key.h"

KEY_StateTypeDef TH_State = KEY_TURN_OFF;
KEY_StateTypeDef PM25_State = KEY_TURN_OFF;

static void key_cb0(void *args)
{
    static uint8_t i = 0;
    i++;
    if(!rt_pin_read(PIN_KEY0)){
        if (i & 0x01){
            TH_State = KEY_TURN_ON;
        }
        else{
            TH_State = KEY_TURN_OFF;
        }
    }
}

static void key_cb1(void *args)
{
    static uint8_t i = 0;
    i++;
    if(!rt_pin_read(PIN_KEY1)){
        if (i & 0x01){
            PM25_State = KEY_TURN_ON;
        }
        else{
            PM25_State = KEY_TURN_OFF;
        }
    }
}

static void key_cb2(void *args)
{
    static uint8_t i = 0;
    i++;
    if(!rt_pin_read(PIN_KEY2)){
        if (i & 0x01){
            led_on(2);
        }
        else{
            led_off(2);
        }
    }    
}

void key_init()
{
    rt_pin_mode(PIN_KEY0, PIN_MODE_INPUT);
    rt_pin_mode(PIN_KEY1, PIN_MODE_INPUT);
    rt_pin_mode(PIN_KEY2, PIN_MODE_INPUT);
    
    rt_pin_attach_irq(PIN_KEY0, PIN_IRQ_MODE_FALLING, key_cb0, RT_NULL);
    rt_pin_attach_irq(PIN_KEY1, PIN_IRQ_MODE_FALLING, key_cb1, RT_NULL);
    rt_pin_attach_irq(PIN_KEY2, PIN_IRQ_MODE_FALLING, key_cb2, RT_NULL);

rt_pin_irq_enable(PIN_KEY0, PIN_IRQ_ENABLE);
    rt_pin_irq_enable(PIN_KEY1, PIN_IRQ_ENABLE);
    rt_pin_irq_enable(PIN_KEY2, PIN_IRQ_ENABLE);
}

```

led_alert.h:
```#ifndef __LED_ALERT_H__
#define __LED_ALERT_H__

#define LED0_PIN    GET_PIN(E, 7)
#define LED1_PIN    GET_PIN(E, 8)
#define LED2_PIN    GET_PIN(E, 9)

#define EVENT_LED0_OFF (1 << 0)
#define EVENT_LED0_ON  (1 << 1)
#define EVENT_LED0_BLINK  (1 << 2)

#define EVENT_LED1_OFF (1 << 3)
#define EVENT_LED1_ON  (1 << 4)
#define EVENT_LED1_BLINK  (1 << 5)

extern struct rt_event event;

int led_init();
void led_on(uint8_t led);
void led_off(uint8_t led);
void led_blink(uint8_t led);

#endif```

led_alert.c:
```#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

#include "led_alert.h"

/* 事件控制块 */
struct rt_event event;
static rt_thread_t led_tid = RT_NULL;

void led_entry(void *parameter)
{
    rt_uint32_t e;
    rt_err_t result;
    while(1){
        result = rt_event_recv(&event,
                               (EVENT_LED0_OFF | EVENT_LED0_ON | EVENT_LED0_BLINK |
                                EVENT_LED1_OFF | EVENT_LED1_ON | EVENT_LED1_BLINK),
                               RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                               RT_WAITING_FOREVER, 
                               &e
                              );
        if (result == RT_EOK){
            if(e & EVENT_LED0_OFF){
                led_off(0);
            }
            else if(e & EVENT_LED0_ON){
                led_on(0);
            }
            else if(e & EVENT_LED0_BLINK){
                led_blink(0);
            }

if(e & EVENT_LED1_OFF){
                led_off(1);
            }
            else if(e & EVENT_LED1_ON){
                led_on(1);
            }
            else if(e & EVENT_LED1_BLINK){
                led_blink(1);
            }
        }
    }
}

int led_init()
{
    rt_err_t result;

/* 初始化事件对象 */
    result = rt_event_init(&event, "event", RT_IPC_FLAG_FIFO);
    if (result != RT_EOK){
        rt_kprintf("init event failed.<br>");
        return -1;
    }
    
    rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(LED2_PIN, PIN_MODE_OUTPUT);
    
    led_off(3);
    
    led_tid = rt_thread_create("led",
                               led_entry, RT_NULL,
                               1024,
                               RT_MAIN_THREAD_PRIORITY - 2,
                               20
                              );
    if(led_tid != RT_NULL)
        rt_thread_startup(led_tid);
    
    return 0;
}

void led_on(uint8_t led)
{
    switch(led){
    case 0:
        rt_pin_write(LED0_PIN, PIN_LOW);
        break;
    case 1:
        rt_pin_write(LED1_PIN, PIN_LOW);
        break;
    case 2:
        rt_pin_write(LED2_PIN, PIN_LOW);
        break;
    default:
        rt_pin_write(LED0_PIN, PIN_LOW);
        rt_pin_write(LED1_PIN, PIN_LOW);
        rt_pin_write(LED2_PIN, PIN_LOW);
    }
}

void led_off(uint8_t led)
{
    switch(led){
    case 0:
        rt_pin_write(LED0_PIN, PIN_HIGH);
        break;
    case 1:
        rt_pin_write(LED1_PIN, PIN_HIGH);
        break;
    case 2:
        rt_pin_write(LED2_PIN, PIN_HIGH);    
        break;
    default:
        rt_pin_write(LED0_PIN, PIN_HIGH);
        rt_pin_write(LED1_PIN, PIN_HIGH);
        rt_pin_write(LED2_PIN, PIN_HIGH);
    }
}

void led_blink(uint8_t led)
{
    led_on(led);
    rt_thread_mdelay(20);
    led_off(led);
//    rt_thread_mdelay(200);
}```

1 个回答

core571 2019-10-29

这家伙很懒，什么也没写！

pm25.c

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

#include "mylog.h"
#include "led_alert.h"
#include "key.h"
#include "pm25.h"
#include "pm25_th.h"

static rt_thread_t pm25_tid = RT_NULL;

void pm25_entry(void *parameter)
{
   float dens = 0;
   
   while(1){
       if(PM25_State == KEY_TURN_ON){
           dens = gp2y_read_pm25();
           
           if(dens < 560){
               rt_event_send(&event, EVENT_LED1_BLINK);
           }
           else{
               rt_event_send(&event, EVENT_LED1_ON);
           }
           mylog("dens (ug/m3)", &dens);
       }
       else if(PM25_State == KEY_TURN_OFF){
           rt_event_send(&event, EVENT_LED1_OFF);
       }
//        dens = gp2y_read_pm25();
//        rt_kprintf("dens: %d.%d ug/m3\n", (int)dens, (int)(dens * 10) % 10);
       
       rt_thread_mdelay(1000);
   }
}

void pm25_init()
{
   gp2y_hw_init();
   pm25_tid = rt_thread_create("pm25_tid",
                               pm25_entry, RT_NULL,
                               1024,
                               RT_MAIN_THREAD_PRIORITY - 1,
                               20
                               );
   if(pm25_tid != RT_NULL)
       rt_thread_startup(pm25_tid);
}
```

temp_humi_th.c

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

#include "mylog.h"
#include "key.h"
#include "led_alert.h"
#include "temp_humi.h"
#include "temp_humi_th.h"

static rt_thread_t temp_humi_tid = RT_NULL;

static void temp_humi_entry(void *parameter)
{
   float humidity, temperature;
       
   while(1){
       if(TH_State == KEY_TURN_ON){
           aht10_read_humi(&humidity);
           aht10_read_temp(&temperature);
           
           if(humidity < 43){
               rt_event_send(&event, EVENT_LED0_BLINK);
           }
           else{
               rt_event_send(&event, EVENT_LED0_ON);
           }
           
           mylog("humidity (%)", &humidity);
           mylog("temperature (°C)", &temperature);
           
//            rt_kprintf("read aht10 sensor humidity   : %d.%d %%\n", (int)humidity, (int)(humidity * 10) % 10);
//            if( temperature >= 0 )
//            {
//                rt_kprintf("read aht10 sensor temperature: %d.%d°C\n", (int)temperature, (int)(temperature * 10) % 10);
//            }
//            else
//            {
//                rt_kprintf("read aht10 sensor temperature: %d.%d°C\n", (int)temperature, (int)(-temperature * 10) % 10);
//            }
       }
       else if(TH_State == KEY_TURN_OFF){
           rt_event_send(&event, EVENT_LED0_OFF);
       }
       rt_thread_mdelay(1000);
   }
}

//static void hook_of_scheduler(struct rt_thread* from, struct rt_thread* to)
//{
//    rt_kprintf("from: %s -->  to: %s \n", from->name , to->name);
//}

void temp_humi_init(void)
{
//    const char *i2c_bus_name = "i2c4";
   aht10_hw_init("i2c4");
   
   // rt_scheduler_sethook(hook_of_scheduler);
   
   temp_humi_tid = rt_thread_create("temp_humi_tid",
                                    temp_humi_entry, RT_NULL,
                                    1024,
                                    RT_MAIN_THREAD_PRIORITY - 1,
                                    10
                                    );
   if(temp_humi_tid != RT_NULL)
       rt_thread_startup(temp_humi_tid);

}
```

再次感谢 rtthread 各位大神的指导！