RA2L1开发实践之温湿度检测平台

　　主要驱动代码
　　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_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
　　#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
　　/*
　　* 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）;
　　偶然之中在源代码中发现官方已经帮我们定义好了有些引脚，所以就没必要重复定义了




原作者：xiaodaidaii