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

发布于 2019-10-30 09:38:31 浏览：930 订阅该版

[tocm]

* 本帖最后由 波尔顿 于 2019-10-30 09:39 编辑 *

越学习越感觉到自己的不足，三周以来才刚刚摸到一点门槛，还需要进一步深入的学习，感谢所有老师的付出。另外这个帖子编辑后放到草稿箱，过后就无法重新编辑了，有点奇怪。
#### 任务 1：实现异步日志（熟悉 IPC：邮箱的使用）
```
static void mylog_thred_emtry(void *parameter)
{
    struct msg *str;

while (1)
    {
        //rt_kprintf("thread1: try to recv a mail<br>");

/* 从邮箱中收取邮件 */
        if(rt_mb_recv(&mb, (rt_ubase_t *)&str, RT_WAITING_FOREVER) == RT_EOK)
        {
                if(1 == str->flag)
                {
                        rt_kprintf("[%s] temp data is:%d\t humi _data is:%d<br>",str->tag, str->data1, str->data2);
                }
                rt_thread_mdelay(100);
                //rt_free(str);
        }                                
    }
}

int mylog_init(void)
{
    rt_err_t result;

/* 初始化一个 mailbox */
    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_th = rt_thread_create("mylog", mylog_thred_emtry, 0, 1024, 30, 20);
        
    if (async_th != RT_NULL)
        rt_thread_startup(async_th);

return 0;
}

void mylog(char * tag, int flag, void * data1, void * data2)
{        
        struct msg mb_data_send;
        mb_data_send.tag        = tag;
        mb_data_send.flag        = flag;
        mb_data_send.data1        = data1;
        mb_data_send.data2        = data2;
        while(1)
        {
                rt_mb_send(&mb, (rt_ubase_t)&mb_data_send);        
                rt_thread_mdelay(1000);                
        }
}```#### 任务 2：系统跑起来（熟悉 IPC：事件集的使用）

2 个回答

波尔顿 2019-10-31

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

[i=s] 本帖最后由 波尔顿 于 2019-10-31 15:52 编辑 [/i]

key.c

```
void key_init(void)
{
        key_led();
        
        /* KEY1 KEY2 引脚为输出模式 */
        rt_pin_mode(KEY1_PIN, PIN_MODE_INPUT_PULLUP);
        rt_pin_mode(KEY2_PIN, PIN_MODE_INPUT_PULLUP);

}
void key_cb1(void *args)
{

key1_count++;
        
        if(key1_count & 0x01)
        {
                        rt_event_send(&event,EVENT_TEMP_HUMI_ON);
        }
        else
        {
            rt_event_send(&event,EVENT_TEMP_HUMI_OFF); 
        }

}

void key_led(void)
{
    rt_pin_attach_irq(KEY1_PIN, 0x00, key_cb1, RT_NULL);

rt_pin_irq_enable(KEY1_PIN, PIN_IRQ_ENABLE);

}
```

led_alert.c

```
ALIGN(RT_ALIGN_SIZE)
static char thread1_stack[1024];
static struct rt_thread thread1;

/* led 事件线程入口 */
void led_entry(void *param)
{
    rt_uint32_t e;
        // 事件 灯亮、灯灭、灯闪
        while(1)
        {
                if (rt_event_recv(&event, (EVENT_LED_ON | EVENT_LED_OFF | EVENT_LED_BLINK | EVENT_TEMP_HUMI_ON | EVENT_TEMP_HUMI_OFF),
                                                  RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                                                  RT_WAITING_FOREVER, &e) == RT_EOK)
                {
                        // 判断led 事件状态
                        if(e & EVENT_LED_ON)
                                {led_on();}
                        else if(e & EVENT_LED_OFF)
                                {led_off();}
                        else if(e & EVENT_LED_BLINK)
                                {led_blink();}
                                
                        if(e & EVENT_TEMP_HUMI_ON)
                                {temp_humi_sw=1;}
                        else if(e & EVENT_TEMP_HUMI_OFF)
                                {temp_humi_sw=0;}
                }
        }
}
int led_init(void)
{
    rt_err_t result;
        // 初始化led
        rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
        rt_pin_write(LED0_PIN, PIN_HIGH);

/* 初始化事件对象 */
    result = rt_event_init(&event, "event", RT_IPC_FLAG_FIFO);
    if (result != RT_EOK)
    {
        rt_kprintf("init event failed.\n");
        return -1;
    }

rt_thread_init(&thread1,
                   "event",
                   led_entry,
                   RT_NULL,
                   &thread1_stack[0],
                   sizeof(thread1_stack),
                   THREAD_PRIORITY - 1, THREAD_TIMESLICE);
    rt_thread_startup(&thread1);

return 0;
}

void led_on(void)
{
        rt_pin_write(LED0_PIN, PIN_LOW);
}

void led_off(void)
{
        rt_pin_write(LED0_PIN, PIN_HIGH);
}
void led_blink(void)
{
        rt_uint8_t i;
        
        for(i = 0; i < 2; i++)
        {
                led_on();
                rt_thread_mdelay(100);
                led_off();
                rt_thread_mdelay(100);                
        }
}
```

temp_humi_th.c

```

void temp_humi_entry(void *parameter)
{
        struct DHT11 dht11;
    rt_device_t dev = RT_NULL;
    struct rt_sensor_data sensor_data;
    rt_size_t res;
    rt_uint8_t get_data_freq = 1; /* 1Hz */

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

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

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

while (1)
    {

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

if (res != 1)
        {
            rt_kprintf("read data failed! result is %d\n", res);
            rt_device_close(dev);
            return;
        }
        else
        {
                        if(temp_humi_sw == 1)
                        {

if (sensor_data.data.temp >= 0)
                                {
                                        dht11.flag = 1;
                                        dht11.data1 = (sensor_data.data.temp & 0xffff) >> 0;
                                        dht11.data2 = (sensor_data.data.temp & 0xffff0000) >> 16;        
                                
                                        mylog("DHT11",dht11.flag,(void *)dht11.data1,(void *)dht11.data2);        
                                        rt_event_send(&event,EVENT_LED_BLINK);
                                        if(dht11.data1 >= 45)
                                        {
                                                temp_humi_alert = 1;
                                                rt_event_send(&event,EVENT_LED_ON);
                                        }
                                        // 借湿度测试报警
                                        if(dht11.data2 >= 45)
                                        {
                                                rt_event_send(&event,EVENT_LED_ON);
                                                rt_kprintf("HUMI ALERT!!! \n");
                                        }                                
                                }                                
                        }
        }
        rt_thread_delay(1000);
    }
}

uint8_t temp_humi_init(void)
{
    struct rt_sensor_config cfg;
    
    cfg.intf.user_data = (void *)DHT11_DATA_PIN;
    rt_hw_dht11_init("dht11", &cfg);
        
        rt_thread_t dht11_thread;

dht11_thread = rt_thread_create("dht_tem",
                                     temp_humi_entry,
                                     RT_NULL,
                                     1024,
                                     THREAD_PRIORITY,
                                     20);
    if (dht11_thread != RT_NULL)
    {
        rt_thread_startup(dht11_thread);
    }

return RT_EOK;
        
}
```

借用湿度测试报警