RT-Thread-【RA2L1开发实践】- 温湿度检测平台RT-Thread问答社区

【RA2L1开发实践】- 温湿度检测平台

发布于 2023-03-15 23:49:51 浏览：366 订阅该版

本文参考如下链接：
https://club.rt-thread.org/index.php/ask/article/a7ed641719db11f2.html
https://club.rt-thread.org/ask/article/564d4ced03f0c7b7.html
https://club.rt-thread.org/ask/article/7ef4e81b9075c00f.html
https://docs.qq.com/doc/DTlVNc3F1a2p6UUJH?&u=f700df5c1bf84d45a6b888ba5d858e47

教程如下：
[温湿度检测平台.docx](https://club.rt-thread.org/file_download/fc3261f3a3223d82)

主要驱动代码
dht11.c
```c
/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-03-15     XiaoDai       the first version
 */
#ifndef SRC_DHT11_C_
#define SRC_DHT11_C_

#include "dht11.h"
#include <stdio.h>
#include "hal_data.h"
#include <board.h>
#define DBG_TAG                  "sensor.asair.dhtxx"
#ifdef PKG_USING_DHTXX_DEBUG
#define DBG_LVL                  DBG_LOG
#else
#define DBG_LVL                  DBG_ERROR
#endif
#include <rtdbg.h>
/* timing */
#define DHT1x_BEGIN_TIME         20  /* ms */
#define DHT2x_BEGIN_TIME         1   /* ms */
#define DHTxx_PULL_TIME          30  /* us */
#define DHTxx_REPLY_TIME         100 /* us */
#define MEASURE_TIME             40  /* us */
RT_WEAK void rt_hw_us_delay(rt_uint32_t us)
{
    rt_uint32_t delta;
    us = us * (SysTick->LOAD / (1000000 / RT_TICK_PER_SECOND));
    delta = SysTick->VAL;
    while (delta - SysTick->VAL < us) continue;
}
/**
 * This function will split a number into two part according to times.
 *
 * @param num      the number will be split
 * @param integer  the integer part
 * @param decimal  the decimal part
 * @param times    how many times of the real number (you should use 10 in this case)
 *
 * @return 0 if num is positive, 1 if num is negative
 */
int split_int(const int num, int *integer, int *decimal, const rt_uint32_t times)
{
    int flag = 0;
    if (num < 0) flag = 1;
    int anum = num<0 ? -num : num;
    *integer = anum / times;
    *decimal = anum % times;
    return flag;
}
/**
 * This function will convert temperature in degree Celsius to Kelvin.
 *
 * @param c  the temperature indicated by degree Celsius
 *
 * @return the result
 */
float convert_c2k(float c)
{
    return c + 273.15;
}
/**
 * This function will convert temperature in degree Celsius to Fahrenheit.
 *
 * @param c  the temperature indicated by degree Celsius
 *
 * @return the result
 */
float convert_c2f(float c)
{
    return c * 1.8 + 32;
}
/**
 * This function will convert temperature in degree Fahrenheit to Celsius.
 *
 * @param f  the temperature indicated by degree Fahrenheit
 *
 * @return the result
 */
float convert_f2c(float f)
{
    return (f - 32) * 0.55555;
}
/**
 * This function will read a bit from sensor.
 *
 * @param pin  the pin of Dout
 *
 * @return the bit value
 */
static uint8_t dht_read_bit(const rt_base_t pin)
{
    uint8_t retry = 0;
    while(rt_pin_read(pin) && retry < DHTxx_REPLY_TIME)
    {
        retry++;
        rt_hw_us_delay(1);
    }
    retry = 0;
    while(!rt_pin_read(pin) && retry < DHTxx_REPLY_TIME)
    {
        retry++;
        rt_hw_us_delay(1);
    }
    rt_hw_us_delay(MEASURE_TIME);
    return rt_pin_read(pin);
}
/**
 * This function will read a byte from sensor.
 *
 * @param pin  the pin of Dout
 *
 * @return the byte
 */
static uint8_t dht_read_byte(const rt_base_t pin)
{
    uint8_t i, byte = 0;
    for(i=0; i<8; i++)
    {
        byte <<= 1;
        byte |= dht_read_bit(pin);
    }
    return byte;
}
/**
 * This function will read and update data array.
 *
 * @param dev  the device to be operated
 *
 * @return RT_TRUE if read successfully, otherwise return RT_FALSE.
 */
rt_bool_t dht_read(dht_device_t dev)
{
    RT_ASSERT(dev);
    uint8_t i, retry = 0, sum = 0;
#ifdef PKG_USING_DHTXX_INTERRUPT_DISABLE
    rt_base_t level;
#endif
    /* Reset data buffer */
    rt_memset(dev->data, 0, DHT_DATA_SIZE);
    /* MCU request sampling */
    rt_pin_mode(dev->pin, PIN_MODE_OUTPUT);
    rt_pin_write(dev->pin, PIN_LOW);
    if (dev->type == DHT11) {
        rt_thread_mdelay(DHT1x_BEGIN_TIME);        /* Tbe */
    } else {
        rt_thread_mdelay(DHT2x_BEGIN_TIME);
    }
#ifdef PKG_USING_DHTXX_INTERRUPT_DISABLE
    level = rt_hw_interrupt_disable();
#endif
    rt_pin_mode(dev->pin, PIN_MODE_INPUT_PULLUP);
    rt_hw_us_delay(DHTxx_PULL_TIME);               /* Tgo */
    /* Waiting for sensor reply */
    while (rt_pin_read(dev->pin) && retry < DHTxx_REPLY_TIME)
    {
        retry++;
        rt_hw_us_delay(1);                         /* Trel */
    }
    if(retry >= DHTxx_REPLY_TIME) return RT_FALSE;
    retry = 0;
    while (!rt_pin_read(dev->pin) && retry < DHTxx_REPLY_TIME)
    {
        retry++;
        rt_hw_us_delay(1);                         /* Treh */
    };
    if(retry >= DHTxx_REPLY_TIME) return RT_FALSE;
    /* Read data */
    for(i=0; i<DHT_DATA_SIZE; i++)
    {
        dev->data[i] = dht_read_byte(dev->pin);
    }
#ifdef PKG_USING_DHTXX_INTERRUPT_DISABLE
    rt_hw_interrupt_enable(level);
#endif
    /* Checksum */
    for(i=0; i<DHT_DATA_SIZE-1; i++)
    {
        sum += dev->data[i];
    }
    if(sum != dev->data[4]) return RT_FALSE;
    return RT_TRUE;
}
/**
 * This function will get the humidity from dhtxx sensor.
 *
 * @param dev  the device to be operated
 *
 * @return the humidity value
 */
rt_int32_t dht_get_humidity(dht_device_t const dev)
{
    RT_ASSERT(dev);
    rt_int32_t humi = 0;
    switch(dev->type)
    {
    case DHT11:
        humi = dev->data[0] * 10 + dev->data[1];
        break;
    default:
        break;
    }
    return humi;
}
/**
 * This function will get the temperature from dhtxx sensor.
 *
 * @param dev  the device to be operated
 *
 * @return the temperature value
 */
rt_int32_t dht_get_temperature(dht_device_t const dev)
{
    RT_ASSERT(dev);
    rt_int32_t temp = 0;
    switch(dev->type)
    {
    case DHT11:
        temp = dev->data[2] * 10 + (dev->data[3] & 0x7f);
        if(dev->data[3] & 0x80) {
            temp = -temp;
        }
        break;
    default:
        break;
    }
    return temp;
}
/**
 * This function will init dhtxx sensor device.
 *
 * @param dev  the device to init
 * @param pin  the pin of Dout
 *
 * @return the device handler
 */
rt_err_t dht_init(struct dht_device *dev, const rt_base_t pin)
{
    if(dev == NULL)
        return -RT_ERROR;
    dev->type = DHT_TYPE;
    dev->pin  = pin;
    rt_memset(dev->data, 0, DHT_DATA_SIZE);
    rt_pin_mode(dev->pin, PIN_MODE_INPUT_PULLUP);
    return RT_EOK;
}
// 1、初始化类型
dht_device_t dht_create(const rt_base_t pin)
{
    dht_device_t dev;
    dev = rt_calloc(1, sizeof(struct dht_device));
    if (dev == RT_NULL)
    {
        LOG_E("Can't allocate memory for dhtxx device");
        return RT_NULL;
    }
    dev->type = DHT_TYPE;
    dev->pin  = pin;
    rt_memset(dev->data, 0, DHT_DATA_SIZE);
    rt_pin_mode(dev->pin, PIN_MODE_INPUT_PULLUP);
    return dev;
}
void dht_delete(dht_device_t dev)
{
    if (dev)
        rt_free(dev);
}
#endif /* SRC_DHT11_C_ */

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-03-15     XiaoDai       the first version
 */
#ifndef SRC_DHT11_H_
#define SRC_DHT11_H_
```
dht11.h
```c
#include <stdio.h>
#include <rthw.h>
#include <rtdevice.h>
#include <board.h>
#include <rtthread.h>
#define DHTLIB_VERSION                       "0.9.0"
#define DHT_DATA_SIZE                        5
/* sensor model type */
#define DHT11                                0
#define DHT_TYPE                             DHT11
struct dht_device
{
    rt_base_t   pin;
    rt_uint8_t  type;
    rt_uint8_t  data[DHT_DATA_SIZE];
    rt_mutex_t  lock;
};
typedef struct dht_device *dht_device_t;
dht_device_t dht_create(const rt_base_t pin);
void dht_delete(dht_device_t dev);
rt_err_t   dht_init(struct dht_device *dev, const rt_base_t pin);
rt_bool_t  dht_read(dht_device_t dev);
rt_int32_t dht_get_humidity(dht_device_t dev);
rt_int32_t dht_get_temperature(dht_device_t dev);
float convert_c2k(float c);//将摄氏温度转为开氏温度
float convert_c2f(float c);//将摄氏温度转为华氏温度
float convert_f2c(float f);//将华氏温度转为摄氏温度
rt_int32_t split_int(const rt_int32_t num, rt_int32_t *integer,
                     rt_int32_t *decimal, const rt_uint32_t times);
rt_err_t rt_hw_dht_init(const char *name, struct rt_sensor_config *cfg);

#endif /* SRC_DHT11_H_ */

0.96oled代码
void lcd_thread_handler(void *parameter)
{
    LCD_Init();
    LCD_Fill(0,0,LCD_W,LCD_H,WHITE);

lcd_show();
    rt_thread_mdelay(1000);
    LCD_Fill(0,0,LCD_W,LCD_H,WHITE);
    while(1)
    {
        lcd_show_pic1();
        rt_thread_mdelay(500);
    }
}

if(key_num ==1)
        {
//            u8g2_ClearBuffer(&u8g2);
            u8g2_DrawStr(&u8g2, 1, 40, "LED2 is on");
            u8g2_SendBuffer(&u8g2);

}
        else {
//            u8g2_ClearBuffer(&u8g2);
            u8g2_DrawStr(&u8g2, 1, 40, "LED2 is off");
            u8g2_SendBuffer(&u8g2);
        }

```

hal_entry.c

```c
/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author        Notes
 * 2021-10-10     Sherman       first version
 */
#include <rtthread.h>
#include "hal_data.h"
#include <rtdevice.h>

#define LED1_PIN    "P502" /* Onboard LED1 pins */
#define LED2_PIN    "P501" /* Onboard LED2 pins */
#define USER_INPUT  "P004"

rt_uint32_t pin ;
int key_num ;

void hal_entry(void)
{
    rt_kprintf("\nHello RT-Thread!\n");
     while (1)
    {

if( pin == 1)
        {
            rt_kprintf("\nUSER_INPUT push !\n");
            rt_pin_write(LED2,PIN_HIGH);

}
        rt_thread_mdelay(500);
    }
}

void irq_callback_test(void *args)
{
    static int out ,out2 ;
    rt_kprintf("\n IRQ03 triggered \n");
    rt_uint32_t led1_pin = rt_pin_get(LED1_PIN);
    rt_uint32_t led2_pin = rt_pin_get(LED2_PIN);
    out = rt_pin_read(led1_pin)?PIN_LOW:PIN_HIGH;
    out2 = rt_pin_read(led2_pin)?PIN_LOW:PIN_HIGH;
    rt_pin_write(led1_pin,out);
    rt_pin_write(led2_pin,out2);
    key_num++;

if( pin == 0 && key_num ==2)
    {
        rt_kprintf("\n LED2 is on !\n");
        rt_pin_write(LED2,PIN_HIGH);
    }
    else {
        rt_kprintf("\n LED2 is off !\n");
        rt_pin_write(LED2,PIN_LOW);
    }
    if(key_num ==2 )
        key_num =0;

}

void push_btn(void)
{
    /* init */
    rt_uint32_t pin = rt_pin_get(USER_INPUT);
    rt_kprintf("\n pin number : 0x%04X \n", pin);
    rt_err_t err = rt_pin_attach_irq(pin, PIN_IRQ_MODE_RISING, irq_callback_test, RT_NULL);
    if (RT_EOK != err)
    {
        rt_kprintf("\n attach irq failed. \n");
    }
    err = rt_pin_irq_enable(pin, PIN_IRQ_ENABLE);
    if (RT_EOK != err)
    {
        rt_kprintf("\n enable irq failed. \n");
    }

}
MSH_CMD_EXPORT(push_btn, push_btn);

```

偶然之中在源代码中发现官方已经帮我们定义好了有些引脚，所以就没必要重复定义了

![6da007e6794ee80795c6ae6483cfe47.png](https://oss-club.rt-thread.org/uploads/20230316/5febef469c782a73f2ed36d03804e5ea.png.webp)
最近工作特别忙，后面会持续学习，并发表分享
祝参与此次活动的小伙伴不断攀登高点！
最后，感谢瑞萨官方给的这次宝贵的机会