DS18B20 驱动编写

嵌入式开发平台：mini2440

DS18B20 所用GPIO：S3C2410_GPF(3)

一、DS18B20 时序分析

        DS18B20的一线工作协议流程是：初始化→ROM操作指令→存储器操作指令→数据传输，其工作时序包括：初始化时序、写时序、读时序。

1、初始化时序

       主机首先发出一个480-960微秒的低电平脉冲，然后释放总线变为高电平，并在随后的480微秒时间内对总线进行检测，如果有低电平出现说明总线上有器件已做出应答，若无低电平出现一直都是高电平说明总线上无器件应答。

　  作为从器件的DS18B20在一上电后就一直在检测总线上是否有480-960微秒的低电平出现，如果有，在总线转为高电平后等待15-60微秒后将总线电平拉低60-240微秒做出响应存在脉冲，告诉主机本器件已做好准备，若没有检测到就一直在检测等待。

[cpp]  view plain  copy

 

1. static int ds18b20_init(void)    
2. {    
3.     int retval = 0;    
4.     
5.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
6.     s3c2410_gpio_pullup(DQ, 0);    
7.     
8.     s3c2410_gpio_setpin(DQ, 1);    
9.     udelay(2);    
10.     s3c2410_gpio_setpin(DQ, 0); // 拉低ds18b20总线，复位ds18b20     
11.     udelay(500);                // 保持复位电平500us     
12.     
13.     s3c2410_gpio_setpin(DQ, 1); // 释放ds18b20总线     
14.     udelay(60);    
15.     
16.     // 若复位成功，ds18b20发出存在脉冲（低电平，持续60~240us）     
17.     s3c2410_gpio_cfgpin(DQ, CFG_IN);    
18.     retval = s3c2410_gpio_getpin(DQ);    
19.     
20.     udelay(500);    
21.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
22.     s3c2410_gpio_pullup(DQ, 0);    
23.     s3c2410_gpio_setpin(DQ, 1); // 释放总线     
24.     
25.     return retval;    
26. }    

2、写时序

     写周期最少为60微秒，最长不超过120微秒，写周期一开始作为主机先把总线拉低1微秒表示写周期开始，随后若主机想写0，则继续拉低电平最少60微秒直至写周期结束，然后释放总线为高电平；若主机想写1，在一开始拉低总线电平1微秒后就释放总线为高电平，一直到写周期结束。

     而作为从机的DS18B20则在检测到总线被拉低后等待15微秒然后从15μs到45μs开始对总线采样，在采样期内总线为高电平则为1，若采样期内总线为低电平则为0。

[cpp]  view plain  copy

 

1. static void write_byte(unsigned char data)    
2. {    
3.     int i = 0;    
4.     
5.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
6.     s3c2410_gpio_pullup(DQ, 1);    
7.     
8.     for (i = 0; i < 8; i++)    
9.     {    
10.         // 总线从高拉至低电平时，就产生写时隙     
11.         s3c2410_gpio_setpin(DQ, 1);    
12.         udelay(2);    
13.         s3c2410_gpio_setpin(DQ, 0);    
14.         s3c2410_gpio_setpin(DQ, data & 0x01);    
15.         udelay(60);    
16.         data >>= 1;    
17.     }    
18.     s3c2410_gpio_setpin(DQ, 1); // 重新释放ds18b20总线     
19. }    

3、读时序

      对于读数据操作时序也分为读0时序和读1时序两个过程，读时序是从主机把单总线拉低之后，在1微秒之后就得释放单总线为高电平，以让DS18B20把数据传输到单总线上。DS18B20在检测到总线被拉低1微秒后，便开始送出数据，若是要送出0就把总线拉为低电平直到读周期结束；若要送出1则释放总线为高电平。

     主机在一开始拉低总线1微秒后释放总线，然后在包括前面的拉低总线电平1微秒在内的15微秒时间内完成对总线进行采样检测，采样期内总线为低电平则确认为0，采样期内总线为高电平则确认为1，完成一个读时序过程，至少需要60μs才能完成。

[cpp]  view plain  copy

 

1. static unsigned char read_byte(void)    
2. {    
3.     int i;    
4.     unsigned char data = 0;    
5.   // 总线从高拉至低，只需维持低电平17ts，再把总线拉高，就产生读时隙     
6.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
7.     s3c2410_gpio_pullup(DQ, 0);   
8.    
9.     for (i = 0; i < 8; i++)    
10.     {    
11.           
12.         s3c2410_gpio_setpin(DQ, 1);    
13.         udelay(2);    
14.         s3c2410_gpio_setpin(DQ, 0);    
15.         udelay(2);    
16.         s3c2410_gpio_setpin(DQ, 1);    
17.         udelay(8);    
18.         data >>= 1;    
19.         s3c2410_gpio_cfgpin(DQ, CFG_IN);    
20.         if (s3c2410_gpio_getpin(DQ))    
21.             data |= 0x80;    
22.         udelay(50);    
23.     }    
24.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
25.     s3c2410_gpio_pullup(DQ, 0);    
26.     s3c2410_gpio_setpin(DQ, 1); // 释放ds18b20总线     
27.     return data;    
28. }    

二、操作方法

       DS18B20单线通信功能是分时完成的，有严格的时序概念，如果出现序列混乱，1-WIRE器件将不影响主机，因此读写时序很重要。系统对DS18B20的各种操作必须按协议进行，根据DS18B20的协议规定，微控制器控制DS18B20完成温度的转换必须经过以下4个步骤：

1）每次读写前对DS18B20进行复位初始化。复位要求主CPU将数据线下拉500μs，然后释放，DS18B20收到信号后等待16μs-60μs左右，然后发出60μs-240μs的存在低脉冲，主CPU收到此信号后表示复位成功。

2）发送一条ROM指令

3）发送存储器指令

1、让DS18B20进行一次温度转换的具体操作如下：

a -- 主机先做个复位操作；
b -- 主机再写跳过ROM的操作（CCH）命令；
c -- 然后主机接着写转换温度的操作指令，后面释放总线至少1秒，让DS18B20完成转换操作。需要注意的是每个命令字节在写的时候都是低字节先写，例如CCH的二进制为11001100，在写到总线上时要从低位开始写，写的顺序是“0、0、1、1、0、0、1、1”，整个操作的总线状态如图所。

2、读取RAM的温度数据，同样，这个操作也要按照三个步骤：

a -- 主机发出复位操作并接受DS18B20的应答（存在）脉冲；
b -- 主机发出跳过对ROM操作的命令（CCH）;
c -- 主机发出读取RAM的命令（BEH），随后主机依次读取DS18B20发出的从第0-第8，共九个字节的数据。如果只想读取温度数据，那在读完第0和第1个数据后就不再理会后面DS18B20发出的数据即可，同样读取数据也是低位在前，整个操作的总线状态如图所示。

三、具体驱动编写

1、ds18b20_drv.c

[cpp]  view plain  copy

 

1. #include <linux/init.h>     
2. #include <linux/module.h>     
3. #include <linux/delay.h>     
4. #include <linux/kernel.h>     
5. #include <linux/moduleparam.h>     
6. #include <linux/init.h>     
7. #include <linux/types.h>     
8. #include <linux/fs.h>     
9. #include <mach/regs-gpio.h>     
10. #include <mach/hardware.h>     
11. #include <linux/cdev.h>     
12. #include <asm/uaccess.h>     
13. #include <linux/errno.h>     
14. #include <linux/gpio.h>     
15. #include <linux/device.h>     
16.     
17. /* 相关引脚定义,方便以后移植 */    
18. #define DQ         S3C2410_GPF(3)     
19. #define CFG_IN     S3C2410_GPIO_INPUT     
20. #define CFG_OUT    S3C2410_GPIO_OUTPUT     
21.     
22. // ds18b20主次设备号（动态分配）     
23. static int ds18b20_major = 0;    
24. static int ds18b20_minor = 0;    
25. static int ds18b20_nr_devs = 1;    
26.     
27. // 定义设备类型     
28. static struct ds18b20_device    
29. {    
30.     struct cdev cdev;    
31. };    
32.     
33. struct ds18b20_device *ds18b20_devp;    /*设备结构体指针 */    
34.     
35. static struct class *ds18b20_class;    
36. static struct class_device *ds18b20_class_dev;    
37.     
38. /* 函数声明 */    
39. static int ds18b20_open(struct inode *inode, struct file *filp);    
40. static int ds18b20_init(void);    
41. static void write_byte(unsigned char data);    
42. static unsigned char read_byte(void);    
43. static ssize_t ds18b20_read(struct file *filp, char __user * buf, size_t count, loff_t * f_pos);    
44. void ds18b20_setup_cdev(struct ds18b20_device *dev, int index);    
45.     
46. static int ds18b20_open(struct inode *inode, struct file *filp)    
47. {    
48.     int flag = 0;    
49.     
50.     flag = ds18b20_init();    
51.     if (flag & 0x01)    
52.     {    
53.         printk(KERN_WARNING "open ds18b20 failed\n");    
54.         return -1;    
55.     }    
56.     printk(KERN_NOTICE "open ds18b20 successful\n");    
57.     return 0;    
58. }    
59.     
60. static int ds18b20_init(void)    
61. {    
62.     int retval = 0;    
63.     
64.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
65.     s3c2410_gpio_pullup(DQ, 0);    
66.     
67.     s3c2410_gpio_setpin(DQ, 1);    
68.     udelay(2);    
69.     s3c2410_gpio_setpin(DQ, 0); // 拉低ds18b20总线，复位ds18b20     
70.     udelay(500);                // 保持复位电平500us     
71.     
72.     s3c2410_gpio_setpin(DQ, 1); // 释放ds18b20总线     
73.     udelay(60);    
74.     
75.     // 若复位成功，ds18b20发出存在脉冲（低电平，持续60~240us）     
76.     s3c2410_gpio_cfgpin(DQ, CFG_IN);    
77.     retval = s3c2410_gpio_getpin(DQ);    
78.     
79.     udelay(500);    
80.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
81.     s3c2410_gpio_pullup(DQ, 0);    
82.     s3c2410_gpio_setpin(DQ, 1); // 释放总线     
83.     
84.     return retval;    
85. }    
86.     
87. static void write_byte(unsigned char data)    
88. {    
89.     int i = 0;    
90.     
91.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
92.     s3c2410_gpio_pullup(DQ, 1);    
93.     
94.     for (i = 0; i < 8; i++)    
95.     {    
96.         // 总线从高拉至低电平时，就产生写时隙     
97.         s3c2410_gpio_setpin(DQ, 1);    
98.         udelay(2);    
99.         s3c2410_gpio_setpin(DQ, 0);    
100.         s3c2410_gpio_setpin(DQ, data & 0x01);    
101.         udelay(60);    
102.         data >>= 1;    
103.     }    
104.     s3c2410_gpio_setpin(DQ, 1); // 重新释放ds18b20总线     
105. }    
106.     
107. static unsigned char read_byte(void)    
108. {    
109.     int i;    
110.     unsigned char data = 0;    
111.     
112.     for (i = 0; i < 8; i++)    
113.     {    
114.         // 总线从高拉至低，只需维持低电平17ts，再把总线拉高，就产生读时隙     
115.         s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
116.         s3c2410_gpio_pullup(DQ, 0);    
117.         s3c2410_gpio_setpin(DQ, 1);    
118.         udelay(2);    
119.         s3c2410_gpio_setpin(DQ, 0);    
120.         udelay(2);    
121.         s3c2410_gpio_setpin(DQ, 1);    
122.         udelay(8);    
123.         data >>= 1;    
124.         s3c2410_gpio_cfgpin(DQ, CFG_IN);    
125.         if (s3c2410_gpio_getpin(DQ))    
126.             data |= 0x80;    
127.         udelay(50);    
128.     }    
129.     s3c2410_gpio_cfgpin(DQ, CFG_OUT);    
130.     s3c2410_gpio_pullup(DQ, 0);    
131.     s3c2410_gpio_setpin(DQ, 1); // 释放ds18b20总线     
132.     return data;    
133. }    
134.     
135. static ssize_t ds18b20_read(struct file *filp, char __user * buf, size_t count, loff_t * f_pos)    
136. {    
137.     int flag;    
138.     unsigned long err;    
139.     unsigned char result[2] = { 0x00, 0x00 };    
140.     //struct ds18b20_device *dev = filp->private_data;     
141.     
142.     flag = ds18b20_init();    
143.     if (flag & 0x01)    
144.     {    
145.         printk(KERN_WARNING "ds18b20 init failed\n");    
146.         return -1;    
147.     }    
148.     
149.     write_byte(0xcc);    
150.     write_byte(0x44);    
151.     
152.     flag = ds18b20_init();    
153.     if (flag & 0x01)    
154.         return -1;    
155.     
156.     write_byte(0xcc);    
157.     write_byte(0xbe);    
158.     
159.     result[0] = read_byte();    // 温度低八位     
160.     result[1] = read_byte();    // 温度高八位     
161.     
162.     err = copy_to_user(buf, &result, sizeof(result));    
163.     return err ? -EFAULT : min(sizeof(result), count);    
164. }    
165.     
166. static struct file_operations ds18b20_dev_fops = {    
167.     .owner = THIS_MODULE,    
168.     .open = ds18b20_open,    
169.     .read = ds18b20_read,    
170. };    
171.     
172. void ds18b20_setup_cdev(struct ds18b20_device *dev, int index)    
173. {    
174.     int err, devno = MKDEV(ds18b20_major, ds18b20_minor + index);    
175.     
176.     cdev_init(&dev->cdev, &ds18b20_dev_fops);    
177.     dev->cdev.owner = THIS_MODULE;    
178.     err = cdev_add(&(dev->cdev), devno, 1);    
179.     if (err)    
180.     {    
181.         printk(KERN_NOTICE "ERROR %d add ds18b20\n", err);    
182.     }    
183. }    
184.     
185. static int __init ds18b20_dev_init(void)    
186. {    
187.     int result;    
188.     dev_t dev = 0;    
189.     
190.     dev = MKDEV(ds18b20_major, ds18b20_minor);    
191.     
192.     if (ds18b20_major)    
193.     {    
194.         result = register_chrdev_region(dev, ds18b20_nr_devs, "ds18b20");    
195.     }    
196.     else    
197.     {    
198.         result = alloc_chrdev_region(&dev, ds18b20_minor, ds18b20_nr_devs, "ds18b20");    
199.         ds18b20_major = MAJOR(dev);    
200.     }    
201.     if (result < 0)    
202.     {    
203.         printk(KERN_WARNING "ds18b20: failed to get major\n");    
204.         return result;    
205.     }    
206.     
207.     /* 为新设备分配内存和初始化 */    
208.     ds18b20_devp = kmalloc(sizeof(struct ds18b20_device), GFP_KERNEL);    
209.     if (!ds18b20_devp)    
210.     {                           /*申请失败 */    
211.         result = -ENOMEM;    
212.         goto fail_malloc;    
213.     }    
214.     memset(ds18b20_devp, 0, sizeof(struct ds18b20_device));    
215.     
216.     ds18b20_setup_cdev(ds18b20_devp, 0);    
217.     
218.     /* 自动创建设备节点 */    
219.     ds18b20_class = class_create(THIS_MODULE, "ds18b20_sys_class");    
220.     if (IS_ERR(ds18b20_class))    
221.         return PTR_ERR(ds18b20_class);    
222.     
223.     ds18b20_class_dev =    
224.         device_create(ds18b20_class, NULL, MKDEV(ds18b20_major, 0), NULL, "ds18b20");    
225.     if (unlikely(IS_ERR(ds18b20_class_dev)))    
226.         return PTR_ERR(ds18b20_class_dev);    
227.     
228.     return 0;    
229.     
230.   fail_malloc:    
231.     unregister_chrdev_region(dev, 1);    
232.     return result;    
233. }    
234.     
235. static void __exit ds18b20_dev_exit(void)    
236. {    
237.     cdev_del(&ds18b20_devp->cdev);  /*注销cdev */    
238.     kfree(ds18b20_devp);        /*释放设备结构体内存 */    
239.     unregister_chrdev_region(MKDEV(ds18b20_major, 0), ds18b20_nr_devs); /*释放设备号 */    
240.     device_unregister(ds18b20_class_dev);    
241.     class_destroy(ds18b20_class);    
242. }    
243.     
244. module_init(ds18b20_dev_init);    
245. module_exit(ds18b20_dev_exit);    
246. MODULE_LICENSE("Dual BSD/GPL");    

2、app-ds18b20.c

[cpp]  view plain  copy

 

1. #include <stdio.h>     
2. #include <stdlib.h>     
3. #include <unistd.h>     
4. #include <linux/ioctl.h>     
5.     
6. // 函数声明     
7. void ds18b20_delay(int i);    
8.     
9. int main()    
10. {    
11.     int fd, i;    
12.     unsigned char result[2];    // 从ds18b20读出的结果，result[0]存放低八位     
13.     unsigned char integer_value = 0;    
14.     float decimal_value = 0;    // 温度数值,decimal_value为小数部分的值     
15.     float temperature = 0;    
16.     
17.     fd = open("/dev/ds18b20", 0);    
18.     if (fd < 0)    
19.     {    
20.         perror("open device failed\n");    
21.         exit(1);    
22.     }    
23.     while (1)    
24.     {    
25.         i++;    
26.         read(fd, &result, sizeof(result));    
27.         integer_value = ((result[0] & 0xf0) >> 4) | ((result[1] & 0x07) << 4);    
28.         // 精确到0.25度     
29.         decimal_value = 0.5 * ((result[0] & 0x0f) >> 3) + 0.25 * ((result[0] & 0x07) >> 2);    
30.         temperature = (float)integer_value + decimal_value;    
31.         printf("Current Temperature:%6.2f\n", temperature);    
32.     
33.         ds18b20_delay(500);    
34.     }    
35. }    
36.     
37. void ds18b20_delay(int i)    
38. {    
39.     int j, k;    
40.     for (j = 0; j < i; j++)    
41.         for (k = 0; k < 50000; k++) ;    
42. }    

测试结果：

[cpp]  view plain  copy

 

1. [root@www.linuxidc.com home]#    
2. [root@www.linuxidc.com home]#./app-ds18b20    
3. open ds18b20 successful    
4. Current Temperature: 23.50    
5. Current Temperature: 23.50    
6. Current Temperature: 23.25    
7. Current Temperature: 23.50    
8. Current Temperature: 23.50    
9. Current Temperature: 23.50    
10. ^C    
11. [root@www.linuxidc.com home]#