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

发布于 2019-11-02 01:53:19 浏览：818 订阅该版

* 本帖最后由 9527 于 2019-11-2 01:54 编辑 *

任务 1：实现异步日志 
```/* 邮箱控制块 */
static struct rt_mailbox mb;
/* 用于放邮件的内存池 */
static char mb_pool[128];

typedef struct {
    char *tag;
    void *data;       
} log_msg_t;

rt_err_t mylog(char* tag, void* data)
{
    log_msg_t *log_msg;
    
    if(tag == RT_NULL && data == RT_NULL)
        return RT_ERROR;
    
    log_msg = (log_msg_t *)rt_malloc(sizeof(log_msg_t));
    log_msg->tag = tag;
    log_msg->data = data;
    
    /* 发送log_msg的指针到邮箱中 */
    rt_mb_send(&mb, (rt_uint32_t)log_msg);       
    /* 延时200ms */
    rt_thread_mdelay(200);
    
    return RT_EOK;    
}

static void mylog_entry(void *param)
{
    log_msg_t *log_msg_ptr;
    
    while(1)
    {
        /* 从邮箱中收取邮件 */
        if(rt_mb_recv( &mb, (rt_ubase_t *)&log_msg_ptr, RT_WAITING_FOREVER) == RT_EOK)
        {
            if(strcmp(log_msg_ptr->tag,"temp") == 0)
            {                  
                rt_kprintf("[%s] data is:%d.<br>", log_msg_ptr->tag, (*(int*)(log_msg_ptr->data)) );                
            }
            else if(strcmp(log_msg_ptr->tag,"humi") == 0)
            {
                rt_kprintf("[%s] data is:%d%%.<br>", log_msg_ptr->tag, (*(int*)(log_msg_ptr->data)) );  
            }              
            
        }
        rt_thread_mdelay(200);           
    }    
}

rt_err_t mylog_init(void)
{
    rt_thread_t mylog_tid;  
    rt_err_t result;

/* 初始化一个mailbox */
    result = rt_mb_init(&mb,
                        "mylog_mb" ,
                        &mb_pool, 
                        sizeof(mb_pool)/4,
                        RT_IPC_FLAG_FIFO); 
    if (result != RT_EOK)
    {
        rt_kprintf("init mailbox failed.<br>");
        return -1;
    }                        
    
    mylog_tid = rt_thread_create("mylog_thr",
                    mylog_entry,
                    RT_NULL,
                    512,
                    11, 
                    10);
    if (mylog_tid != RT_NULL)
        rt_thread_startup(mylog_tid);
    return RT_EOK;      
}

```任务 2：系统跑起来 ，利用按键来控制温湿度的读取，
按键是采用的MultiButton来实现滤波的， MultiButton是rtthred的软件包，是一个小巧简单易用的事件驱动型按键驱动模块。
```
static rt_uint32_t click_cnt;
typedef enum
{
    IOTB_USER_BUTTON_0 = 0,
    IOTB_USER_BUTTON_1,
    IOTB_USER_BUTTON_2,
    IOTB_USER_BUTTON_WK_UP,
    IOTB_USER_BUTTON_MAX
} iotb_user_button_t;

static button user_button[IOTB_USER_BUTTON_MAX];
//static iotb_event_msg_t key_msg = {IOTB_EVENT_SRC_NONE, IOTB_EVENT_TYPE_NONE};

static uint8_t button_key0_read(void)
{
    return rt_pin_read(PIN_KEY0);
}

static uint8_t button_key1_read(void)
{
    return rt_pin_read(PIN_KEY1);
}

static uint8_t button_key2_read(void)
{
    return rt_pin_read(PIN_KEY2);
}

static uint8_t button_wkup_read(void)
{
    return rt_pin_read(PIN_WK_UP);
}

static void iotb_btn_0_cb(void *btn)
{
    rt_uint32_t btn_event_val;

iotb_event_msg_t key_msg = {IOTB_EVENT_SRC_NONE, IOTB_EVENT_TYPE_NONE};

LOG_D("btn_0_cb");

btn_event_val = get_button_event((struct button *)btn);

switch (btn_event_val)
    {
        case SINGLE_CLICK:
            if( click_cnt++ % 2)
            {
                temp_humi_event_put(EVENT_TEMP_HUMI_ON);
            }
            else
            {
                temp_humi_event_put(EVENT_TEMP_HUMI_OFF);
            }

LOG_I("button[KEY0] click event!");
            break;
    }
}

static void key_init(void)
{
    uint8_t i;

rt_pin_mode(PIN_KEY0, PIN_MODE_INPUT); /* set KEY pin mode to input */
    rt_pin_mode(PIN_KEY1, PIN_MODE_INPUT); /* set KEY pin mode to input */
    rt_pin_mode(PIN_KEY2, PIN_MODE_INPUT); /* set KEY pin mode to input */
    rt_pin_mode(PIN_WK_UP, PIN_MODE_INPUT); /* set KEY pin mode to input */

button_init(&user_button[IOTB_USER_BUTTON_0], button_key0_read, PIN_LOW);
    button_init(&user_button[IOTB_USER_BUTTON_1], button_key1_read, PIN_LOW);
    button_init(&user_button[IOTB_USER_BUTTON_2], button_key2_read, PIN_LOW);
    button_init(&user_button[IOTB_USER_BUTTON_WK_UP], button_wkup_read, PIN_HIGH); 
    button_attach(&user_button[IOTB_USER_BUTTON_0], SINGLE_CLICK, iotb_btn_0_cb);

for (i = 0; i < IOTB_USER_BUTTON_MAX; i ++)
    {
        button_start(&user_button*);
    } 
}

static  void btn_thread_entry(void *p)
{
    while (1)
    {
        /* 5ms */
        rt_thread_delay(RT_TICK_PER_SECOND / 200);
        button_ticks();
    }
}
rt_err_t key_process_start(void)
{
    rt_thread_t key_tid;

key_init();

key_tid = rt_thread_create("key_thr",
                               btn_thread_entry,
                               RT_NULL,
                               512,
                               6,
                               10);

if (key_tid != RT_NULL)
        rt_thread_startup(key_tid);

return RT_EOK;
}

```2.1，温湿度线程的事件判断，对应LED的不同事件状态,
```
#define AHT10_I2C_BUS       "i2c4"

static aht10_device_t dev;

/* 事件控制块 */
static struct rt_event event;

rt_err_t temp_humi_event_put(rt_uint32_t set)
{
    rt_event_send(&event, set);      
}

static void temp_humi_entry(void *pram)
{
    rt_uint32_t state;
    rt_uint32_t read_on;
    float humidity, temperature;      
    char humi_tag[] = "humi";
    int humi_data;   
    char temp_tag[] = "temp";
    int temp_data;
    
    while (1)
    {          
        /* receive first event */
        if (rt_event_recv(&event, (EVENT_TEMP_HUMI_ON | EVENT_TEMP_HUMI_OFF),
                          RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                          50, (rt_uint32_t *)&state) == RT_EOK)
        {
  
             if(state & EVENT_TEMP_HUMI_OFF)
             {
                  read_on = 0; 
                  led_red_off();
                  rt_thread_mdelay(10);          
             }else    if (state & EVENT_TEMP_HUMI_ON)
             {     
                 read_on = 1; 
                 rt_thread_mdelay(10); 
             } 
        } 
        if(read_on )
        {
            /* 读取湿度 */
            humidity = (int)aht10_read_humidity(dev);
            humi_data = (int) humidity;

mylog(humi_tag, (void*)&humi_data);
            /* 读取温度 */
            temp_data = (int)aht10_read_temperature(dev);
    //        rt_kprintf("temperature: %d.%d<br>", (int)temperature, (int)(temperature * 10) % 10);
            mylog(temp_tag, (void*)&temp_data);
            if( temp_data  > 40)
            {
                led_red_on();
            }
            else
            {
                 led_alert_event_put(EVENT_FLAG0);
            }
            rt_thread_mdelay(1000);          
    
        }
 
    }  
}

static void temp_humi_init(void)
{
    
    /* 总线名称 */
    const char *i2c_bus_name = AHT10_I2C_BUS;

/* 等待传感器正常工作 */
    rt_thread_mdelay(2000);

/* 初始化 aht10 */
    dev = aht10_init(i2c_bus_name);
    if (dev == RT_NULL)
    {
        LOG_E(" The sensor initializes failure");
    }    
    
}

rt_err_t temp_humi_start(void)
{
    rt_thread_t temp_humi_tid;
    
    temp_humi_init();
    /* 初始化事件对象 */
    rt_event_init(&event, "temp_humi_event", RT_IPC_FLAG_FIFO);
    
    /* 创建线程,入口是temp_humi_entry*/
    temp_humi_tid = rt_thread_create("temp_humi_thr",
                    temp_humi_entry,
                    RT_NULL,
                    1024,
                    7, 
                    10);
    /* 如果获得线程控制块，启动这个线程 */
    if (temp_humi_tid != RT_NULL)
        rt_thread_startup(temp_humi_tid);
    
    return RT_EOK;      
}
```

1 个回答

9527 2019-11-02

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

2.2 LED报警，LED线程优先级要比读数据的优先级高，才能在读数据时，指定的LED闪烁

```

/* 事件控制块 */
static struct rt_event led_alert_event;

void led_init(void )
{
    /* 设置 RGB 红灯引脚的模式为输出模式 */
    rt_pin_mode(PIN_LED_R, PIN_MODE_OUTPUT);   
    rt_pin_write(PIN_LED_R, PIN_HIGH);   
    rt_pin_mode(PIN_LED_G, PIN_MODE_OUTPUT);   
    rt_pin_write(PIN_LED_G, PIN_HIGH); 
    rt_pin_mode(PIN_LED_B, PIN_MODE_OUTPUT);   
    rt_pin_write(PIN_LED_B, PIN_HIGH); 
}

void led_red_on(void)
{
    /* 点亮 LED 灯 */
    rt_pin_write(PIN_LED_R, PIN_LOW);       
}

void led_red_off(void )
{
    /* 熄灭 LED 灯 */
    rt_pin_write(PIN_LED_R, PIN_HIGH);    
    
}

static void led_red_blink(void )
{
    rt_pin_write(PIN_LED_R, PIN_LOW);    
    rt_thread_mdelay(200);
    rt_pin_write(PIN_LED_R, PIN_HIGH);  
    rt_thread_mdelay(200);
}

void led_alert_event_put(rt_uint32_t set)
{
    rt_event_send(&led_alert_event, set);   
    rt_thread_mdelay(200);          
}

static void led_entry(void *param)
{
    rt_uint32_t state;
    
    while(1)
    {
        /* receive first event */
        if (rt_event_recv(&led_alert_event, (EVENT_FLAG0 | EVENT_FLAG1),
                          RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                          RT_WAITING_FOREVER, (rt_uint32_t *)&state) == RT_EOK)
                          
        {
             if (state & EVENT_FLAG0)
             {
                  led_red_blink();
             }
             else if (state & EVENT_FLAG1)
             {
             
             }          
        }      
    }  
}

rt_err_t led_alert_init(void)
{
    rt_thread_t led_alert_tid;  
    rt_err_t result;

/* 初始化事件对象 */
    rt_event_init(&led_alert_event, "alert_led_event", RT_IPC_FLAG_FIFO);
    
    
    led_alert_tid = rt_thread_create("led_alert_thr",
                    led_entry,
                    RT_NULL,
                    512,
                    7, 
                    10);
    if (led_alert_tid != RT_NULL)
        rt_thread_startup(led_alert_tid);
    return RT_EOK;     
    
}

```