• 016——DHT11驱动开发（基于I.MX6uLL）

    目录

    一、 模块介绍

    1.1 简介

    1.2 电路描述

    1.3 通信协议

    二、 驱动程序

    三、 应用程序

    四、 上机实验

    一、 模块介绍

    1.1 简介

            DHT11 是一款可测量温度和湿度的传感器。比如市面上一些空气加湿器，会测量空气中湿度，再根据测量结果决定是否继续加湿。DHT11 数字温湿度传感器是一款含有已校准数字信号输出的温湿度复合传感器，具有超小体积、极低功耗的特点，使用单根总线与主机进行双向的串行数据传输。 DHT11 测量温度的精度为± 2℃，检测范围为-20℃ -60℃。湿度的精度为± 5%RH，检测范围为 5%RH-95%RH，常用于对精度和实时性要求不高的温湿度测量场合。

            这也是一款我们每次学习新板子都会用到的传感器，之前我做的很多32项目都有用到过。

    1.2 电路描述

            和 IRDA 模块的电路基本一致，主机通过一条数据线与 DH11 连接，主机通过这条线发命令给 DHT11， DHT11 再通过这条线把数据发送给主机。

    建议连接线长度短于20米时用5K上拉电阻,大于20米时根据实际情况使用合适的上拉电阻。
     

    1.3 通信协议

            DATA 用于微处理器与 DHT11之间的通讯和同步,采用单总线数据格式,一次通讯时间4ms左右,数据分小数部分和整数部分,具体格式在下面说明,当前小数部分用于以后扩展,现读出为零.操作流程如下:

    一次完整的数据传输为40bit,高位先出。
    数据格式:8bit湿度整数数据+8bit湿度小数数据
    +8bi温度整数数据+8bit温度小数数据
    +8bit校验和
    数据传送正确时校验和数据等于“8bit湿度整数数据+8bit湿度小数数据
    +8bi温度整数数据+8bit温度小数数据” 所得结果的末8位。
            用户MCU发送一次开始信号后,DHT11从低功耗模式转换到高速模式,等待主机开始信号结束后,DHT11发送响应信号,送出40bit的数据,并触发一次信号采集,用户可选择读取部分数据.从模式下,DHT11接收到开始信号触发一次温湿度采集,如果没有接收到主机发送开始信号,DHT11不会主动进行温湿度采集.采集数据后转换到低速模式。

    （记得当时期末考试还考了这道题让根据时钟写驱动程序，只不过那时候是基于stm32C8T6的。）

            总线空闲状态为高电平,主机把总线拉低等待DHT11响应,主机把总线拉低必须大于18毫秒,保证DHT11能检测到起始信号。 DHT11接收到主机的开始信号后,等待主机开始信号结束,然后发送80us低电平响应信号.主机发送开始信号结束后,延时等待20-40us后, 读取DHT11的响应信号,主机发送开始信号后,可以切换到输入模式,或者输出高电平均可, 总线由上拉电阻拉高。

            总线为低电平,说明DHT11发送响应信号,DHT11发送响应信号后,再把总线拉高80us,准备发送数据,每一bit数据都以50us低电平时隙开始,高电平的长短定了数据位是0还是1.格式见下面图示.如果读取响应信号为高电平,则DHT11没有响应,请检查线路是否连接正常.当最后一bit数据传送完毕后， DHT11拉低总线50us,随后总线由上拉电阻拉高进入空闲状态。数字0信号表示方法如图所示

    二、 驱动程序

    1. #include "asm-generic/errno-base.h"
    2. #include "asm-generic/gpio.h"
    3. #include "linux/jiffies.h"
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28. #include 
    29. #include 
    30.  
    31. struct gpio_desc{
    32. 	int gpio;
    33. 	int irq;
    34.     char *name;
    35.     int key;
    36. 	struct timer_list key_timer;
    37. } ;
    38.  
    39. static struct gpio_desc gpios[] = {
    40.     {115, 0, "dht11", },
    41. };
    42.  
    43. /* 主设备号                                                                 */
    44. static int major = 0;
    45. static struct class *gpio_class;
    46.  
    47. static u64 g_dht11_irq_time[84];
    48. static int g_dht11_irq_cnt = 0;
    49.  
    50. /* 环形缓冲区 */
    51. #define BUF_LEN 128
    52. static char g_keys[BUF_LEN];
    53. static int r, w;
    54.  
    55. struct fasync_struct *button_fasync;
    56.  
    57. static irqreturn_t dht11_isr(int irq, void *dev_id);
    58. static void parse_dht11_datas(void);
    59.  
    60. #define NEXT_POS(x) ((x+1) % BUF_LEN)
    61.  
    62. static int is_key_buf_empty(void)
    63. {
    64. 	return (r == w);
    65. }
    66.  
    67. static int is_key_buf_full(void)
    68. {
    69. 	return (r == NEXT_POS(w));
    70. }
    71.  
    72. static void put_key(char key)
    73. {
    74. 	if (!is_key_buf_full())
    75. 	{
    76. 		g_keys[w] = key;
    77. 		w = NEXT_POS(w);
    78. 	}
    79. }
    80.  
    81. static char get_key(void)
    82. {
    83. 	char key = 0;
    84. 	if (!is_key_buf_empty())
    85. 	{
    86. 		key = g_keys[r];
    87. 		r = NEXT_POS(r);
    88. 	}
    89. 	return key;
    90. }
    91.  
    92.  
    93. static DECLARE_WAIT_QUEUE_HEAD(gpio_wait);
    94.  
    95. // static void key_timer_expire(struct timer_list *t)
    96. static void key_timer_expire(unsigned long data)
    97. {
    98. 	// 解析数据, 放入环形buffer, 唤醒APP
    99. 	parse_dht11_datas();
    100. }
    101.  
    102.  
    103. /* 实现对应的open/read/write等函数，填入file_operations结构体                   */
    104. static ssize_t dht11_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
    105. {
    106. 	int err;
    107. 	char kern_buf[2];
    108.  
    109. 	if (size != 2)
    110. 		return -EINVAL;
    111.  
    112. 	g_dht11_irq_cnt = 0;
    113.  
    114. 	/* 1. 发送18ms的低脉冲 */
    115. 	err = gpio_request(gpios[0].gpio, gpios[0].name);
    116. 	gpio_direction_output(gpios[0].gpio, 0);
    117. 	gpio_free(gpios[0].gpio);
    118.  
    119. 	mdelay(18);
    120. 	gpio_direction_input(gpios[0].gpio);  /* 引脚变为输入方向, 由上拉电阻拉为1 */
    121.  
    122. 	/* 2. 注册中断 */
    123. 	err = request_irq(gpios[0].irq, dht11_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, gpios[0].name, &gpios[0]);
    124. 	mod_timer(&gpios[0].key_timer, jiffies + 10);	
    125.  
    126. 	/* 3. 休眠等待数据 */
    127. 	wait_event_interruptible(gpio_wait, !is_key_buf_empty());
    128.  
    129. 	free_irq(gpios[0].irq, &gpios[0]);
    130.  
    131. 	//printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    132.  
    133. 	/* 设置DHT11 GPIO引脚的初始状态: output 1 */
    134. 	err = gpio_request(gpios[0].gpio, gpios[0].name);
    135. 	if (err)
    136. 	{
    137. 		printk("%s %s %d, gpio_request err\n", __FILE__, __FUNCTION__, __LINE__);
    138. 	}
    139. 	gpio_direction_output(gpios[0].gpio, 1);
    140. 	gpio_free(gpios[0].gpio);
    141.  
    142.  
    143. 	/* 4. copy_to_user */
    144. 	kern_buf[0] = get_key();
    145. 	kern_buf[1] = get_key();
    146.  
    147. 	printk("get val : 0x%x, 0x%x\n", kern_buf[0], kern_buf[1]);
    148. 	if ((kern_buf[0] == (char)-1) && (kern_buf[1] == (char)-1))
    149. 	{
    150. 		printk("get err val\n");
    151. 		return -EIO;
    152. 	}
    153.  
    154. 	err = copy_to_user(buf, kern_buf, 2);
    155. 	
    156. 	return 2;
    157. }
    158.  
    159. static int dht11_release (struct inode *inode, struct file *filp)
    160. {
    161. 	return 0;
    162. }
    163.  
    164.  
    165. /* 定义自己的file_operations结构体                                              */
    166. static struct file_operations dht11_drv = {
    167. 	.owner	 = THIS_MODULE,
    168. 	.read    = dht11_read,
    169. 	.release = dht11_release,
    170. };
    171.  
    172. static void parse_dht11_datas(void)
    173. {
    174. 	int i;
    175. 	u64 high_time;
    176. 	unsigned char data = 0;
    177. 	int bits = 0;
    178. 	unsigned char datas[5];
    179. 	int byte = 0;
    180. 	unsigned char crc;
    181.  
    182. 	/* 数据个数: 可能是81、82、83、84 */
    183. 	if (g_dht11_irq_cnt < 81)
    184. 	{
    185. 		/* 出错 */
    186. 		put_key(-1);
    187. 		put_key(-1);
    188.  
    189. 		// 唤醒APP
    190. 		wake_up_interruptible(&gpio_wait);
    191. 		g_dht11_irq_cnt = 0;
    192. 		return;
    193. 	}
    194.  
    195. 	// 解析数据
    196. 	for (i = g_dht11_irq_cnt - 80; i < g_dht11_irq_cnt; i+=2)
    197. 	{
    198. 		high_time = g_dht11_irq_time[i] - g_dht11_irq_time[i-1];
    199.  
    200. 		data <<= 1;
    201.  
    202. 		if (high_time > 50000) /* data 1 */
    203. 		{
    204. 			data |= 1;
    205. 		}
    206.  
    207. 		bits++;
    208.  
    209. 		if (bits == 8)
    210. 		{
    211. 			datas[byte] = data;
    212. 			data = 0;
    213. 			bits = 0;
    214. 			byte++;
    215. 		}
    216. 	}
    217.  
    218. 	// 放入环形buffer
    219. 	crc = datas[0] + datas[1] + datas[2] + datas[3];
    220. 	if (crc == datas[4])
    221. 	{
    222. 		put_key(datas[0]);
    223. 		put_key(datas[2]);
    224. 	}
    225. 	else
    226. 	{
    227. 		put_key(-1);
    228. 		put_key(-1);
    229. 	}
    230.  
    231. 	g_dht11_irq_cnt = 0;
    232. 	// 唤醒APP
    233. 	wake_up_interruptible(&gpio_wait);
    234. }
    235.  
    236. static irqreturn_t dht11_isr(int irq, void *dev_id)
    237. {
    238. 	struct gpio_desc *gpio_desc = dev_id;
    239. 	u64 time;
    240. 	
    241. 	/* 1. 记录中断发生的时间 */
    242. 	time = ktime_get_ns();
    243. 	g_dht11_irq_time[g_dht11_irq_cnt] = time;
    244.  
    245. 	/* 2. 累计次数 */
    246. 	g_dht11_irq_cnt++;
    247.  
    248. 	/* 3. 次数足够: 解析数据, 放入环形buffer, 唤醒APP */
    249. 	if (g_dht11_irq_cnt == 84)
    250. 	{
    251. 		del_timer(&gpio_desc->key_timer);
    252. 		parse_dht11_datas();
    253. 	}
    254.  
    255. 	return IRQ_HANDLED;
    256. }
    257.  
    258.  
    259. /* 在入口函数 */
    260. static int __init dht11_init(void)
    261. {
    262.     int err;
    263.     int i;
    264.     int count = sizeof(gpios)/sizeof(gpios[0]);
    265.     
    266. 	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    267. 	
    268. 	for (i = 0; i < count; i++)
    269. 	{		
    270. 		gpios[i].irq  = gpio_to_irq(gpios[i].gpio);
    271.  
    272. 		/* 设置DHT11 GPIO引脚的初始状态: output 1 */
    273. 		err = gpio_request(gpios[i].gpio, gpios[i].name);
    274. 		gpio_direction_output(gpios[i].gpio, 1);
    275. 		gpio_free(gpios[i].gpio);
    276.  
    277. 		setup_timer(&gpios[i].key_timer, key_timer_expire, (unsigned long)&gpios[i]);
    278. 	 	//timer_setup(&gpios[i].key_timer, key_timer_expire, 0);
    279. 		//gpios[i].key_timer.expires = ~0;
    280. 		//add_timer(&gpios[i].key_timer);
    281. 		//err = request_irq(gpios[i].irq, dht11_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "100ask_gpio_key", &gpios[i]);
    282. 	}
    283.  
    284. 	/* 注册file_operations 	*/
    285. 	major = register_chrdev(0, "100ask_dht11", &dht11_drv);  /* /dev/gpio_desc */
    286.  
    287. 	gpio_class = class_create(THIS_MODULE, "100ask_dht11_class");
    288. 	if (IS_ERR(gpio_class)) {
    289. 		printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    290. 		unregister_chrdev(major, "100ask_dht11");
    291. 		return PTR_ERR(gpio_class);
    292. 	}
    293.  
    294. 	device_create(gpio_class, NULL, MKDEV(major, 0), NULL, "mydht11"); /* /dev/mydht11 */
    295. 	
    296. 	return err;
    297. }
    298.  
    299. /* 有入口函数就应该有出口函数：卸载驱动程序时，就会去调用这个出口函数
    300.  */
    301. static void __exit dht11_exit(void)
    302. {
    303.     int i;
    304.     int count = sizeof(gpios)/sizeof(gpios[0]);
    305.     
    306. 	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
    307.  
    308. 	device_destroy(gpio_class, MKDEV(major, 0));
    309. 	class_destroy(gpio_class);
    310. 	unregister_chrdev(major, "100ask_dht11");
    311.  
    312. 	for (i = 0; i < count; i++)
    313. 	{
    314. 		//free_irq(gpios[i].irq, &gpios[i]);
    315. 		//del_timer(&gpios[i].key_timer);
    316. 	}
    317. }
    318.  
    319.  
    320. /* 7. 其他完善：提供设备信息，自动创建设备节点                                     */
    321.  
    322. module_init(dht11_init);
    323. module_exit(dht11_exit);
    324.  
    325. MODULE_LICENSE("GPL");
    326.  
    327.

    三、 应用程序

    1.  
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. static int fd;
    12.  
    13. /*
    14.  * ./button_test /dev/mydht11
    15.  *
    16.  */
    17. int main(int argc, char **argv)
    18. {
    19. 	char buf[2];
    20. 	int ret;
    21.  
    22. 	int i;
    23. 	
    24. 	/* 1. 判断参数 */
    25. 	if (argc != 2) 
    26. 	{
    27. 		printf("Usage: %s \n", argv[0]);
    28. 		return -1;
    29. 	}
    30.  
    31. 	/* 2. 打开文件 */
    32. 	fd = open(argv[1], O_RDWR | O_NONBLOCK);
    33. 	if (fd == -1)
    34. 	{
    35. 		printf("can not open file %s\n", argv[1]);
    36. 		return -1;
    37. 	}
    38.  
    39. 	while (1)
    40. 	{
    41. 		if (read(fd, buf, 2) == 2)
    42. 			printf("get Humidity: %d, Temperature : %d\n", buf[0], buf[1]);
    43. 		else
    44. 			printf("get dht11: -1\n");
    45.  
    46. 		sleep(5);
    47. 	}
    48.  
    49. 	//sleep(30);
    50.  
    51. 	close(fd);
    52. 	
    53. 	return 0;
    54. }
    55.  
    56.

    四、 上机实验

    很容易失败

    操作还是老三样

    然后提交一下代码

    开发了点脚本还不成熟经过这11个驱动模块打磨后在分享给大家。

  • 相关阅读:
    第六十章 CSP的常见问题 - 如何结束CSP会话,CSP会话超时
    java开发常见面试问题
    Android系统编译
    clip-path图片裁剪
    ASP.NET集成客户关系管理的企业网站的设计与开发
    Django模型（二）
    java中有哪些条件选择方法呢?
    实战演练-2021年电赛国一之三端口DC-DC变换器
    软件测试之预示面试成功的暗示
    Android多版本flavor配置之资源文件和清单文件合并介绍
  • 原文地址：https://blog.csdn.net/qq_52479948/article/details/137434632