基于ARM-LINUX的温度传感器驱动（DS18B20） .

DS18B20数字温度传感器接线方便，封装成后可应用于多种场合，如管道式，螺纹式，磁铁吸附式，不锈钢封装式，型号多种多样，有LTM8877，LTM8874等等。主要根据应用场合的不同而改变其外观。封装后的DS18B20可用于电缆沟测温，高炉水循环测温，锅炉测温，机房测温，农业大棚测温，洁净室测温，弹药库测温等各种非极限温度场合。耐磨耐碰，体积小，使用方便，封装形式多样，适用于各种狭小空间设备数字测温和控制领域。

技术性能描述

1. 独特的单线接口方式，DS18B20在与微处理器连接时仅需要一条口线即可实现微处理器与DS18B20的双向通讯。
        2. 测温范围 －55℃～+125℃，固有测温分辨率0.5℃。
        3. 支持多点组网功能，多个DS18B20可以并联在唯一的三线上。
        4. 工作电源: 3~5V/DC
        5. 在使用中不需要任何外围元件
        6. 测量结果以9~12位数字量方式串行传送

DS18b20封装

DS18B20 引脚功能： GND 电压地 •DQ 单数据总线 •VDD 电源电压 •NC 空引脚

DS18b20与处理器的连接

DS18B20 工作原理及应用

DS18B20 的温度检测与数字数据输出全集成于一个芯片之上，从而抗干扰力更强。其一个工作周期可分为两个部分，即温度检测和数据处理。在讲解其工作流程之前我们有必要了解 18B20的内部存储器资源。18B20 共有三种形态的存储器资源。它们分别是：

ROM 只读存储器：

用于存放 DS18B20ID 编码，其前 8 位是单线系列编码（DS18B20 的编码是19H） ，后面48 位是芯片唯一的序列号，最后 8位是以上 56的位的 CRC码（冗余校验）。数据在出产时设置不由用户更改。DS18B20 共 64 位 ROM。

RAM 数据暂存器：

用于内部计算和数据存取，数据在掉电后丢失，DS18B20 共9 个字节 RAM，每个字节为 8 位。第1、2 个字节是温度转换后的数据值信息，第 3、4 个字节是用户 EEPROM（常用于温度报警值储存）的镜像。在上电复位时其值将被刷新。第 5 个字节则是用户第 3 个 EEPROM的镜像。第 6、7、8 个字节为计数寄存器，是为了让用户得到更高的温度分辨率而设计的，同样也是内部温度转换、计算的暂存单元。第 9 个字节为前 8个字节的 CRC码。EEPROM 非易失性记忆体，用于存放长期需要保存的数据，上下限温度报警值和校验数据， DS18B20共3位EEPROM，并在 RAM 都存在镜像，以方便用户操作。

控制器对 18B20 操作流程：

1、 复位：首先我们必须对 DS18B20 芯片进行复位，复位就是由控制器（单片机）给 DS18B20单总线至少 480uS 的低电平信号。当 18B20 接到此复位信号后则会在 15~60uS 后回发一个芯片的存在脉冲。

2、 存在脉冲：在复位电平结束之后，控制器应该将数据单总线拉高，以便于在 15~60uS 后接收存在脉冲，存在脉冲为一个 60~240uS 的低电平信号。至此，通信双方已经达成了基本的协议，接下来将会是控制器与 18B20 间的数据通信。如果复位低电平的时间不足或是单总线的电路断路都不会接到存在脉冲，在设计时要注意意外情况的处理。

3、 控制器发送 ROM 指令：双方打完了招呼之后最要将进行交流了，ROM 指令共有 5条，每一个工作周期只能发一条，ROM指令分别是读 ROM 数据、指定匹配芯片、跳跃 ROM、芯片搜索、报警芯片搜索。ROM 指令为 8 位长度，功能是对片内的 64位光刻 ROM进行操作。其主要目的是为了分辨一条总线上挂接的多个器件并作处理。诚然，单总线上可以同时挂接多个器件，并通过每个器件上所独有的 ID号来区别，一般只挂接单个 18B20芯片时可以跳过 ROM 指令（注意：此处指的跳过 ROM指令并非不发送 ROM 指令，而是用特有的一条“跳过指令” ）

4、 控制器发送存储器操作指令：在 ROM 指令发送给 18B20 之后，紧接着（不间断）就是发送存储器操作指令了。操作指令同样为 8 位，共 6 条，存储器操作指令分别是写 RAM 数据、读RAM 数据、将 RAM 数据复制到 EEPROM、温度转换、将 EEPROM中的报警值复制到 RAM、工作方式切换。存储器操作指令的功能是命令 18B20 作什么样的工作，是芯片控制的关键。

5、 执行或数据读写：一个存储器操作指令结束后则将进行指令执行或数据的读写，这个操作要视存储器操作指令而定。如执行温度转换指令则控制器（单片机）必须等待 18B20 执行其指令，一般转换时间为 500uS。如执行数据读写指令则需要严格遵循 18B20 的读写时序来操作。

若要读出当前的温度数据我们需要执行两次工作周期，第一个周期为复位、跳过 ROM 指令、执行温度转换存储器操作指令、等待 500uS 温度转换时间。紧接着执行第二个周期为复位、跳过 ROM指令、执行读 RAM 的存储器操作指令、读数据（最多为 9 个字节，中途可停止，只读简单温度值则读前 2 个字节即可）。其它的操作流程也大同小异，在此不多介绍。关于ds18b20的数据手册网上资源较为丰富，这里不再详细介绍，下面是基于ARM-LINUX的驱动程序，在arm-gcc 编译后测试通过。

1. #include <linux/module.h>
2. #include <linux/moduleparam.h>
3. #include <linux/fs.h>
4. #include <linux/proc_fs.h>
5. #include <linux/errno.h>
6. #include <linux/cdev.h>
7. #include <linux/ioctl.h>
8. #include <linux/fcntl.h>
9. #include <linux/sched.h>
10. #include <linux/poll.h>
11. #include <linux/version.h>
12. #include <linux/kernel.h>
13. #include <linux/init.h>
14. #include <linux/device.h>
15. #include <linux/mm.h>
16. #include <linux/spinlock.h>
17. #include <plat/map.h>
18. #include <asm/io.h>
19. #include <asm/delay.h>
20. #include <asm/memory.h>
21. #include <asm/uaccess.h>
22. #include <asm/mach/map.h>
23. #include <asm/uaccess.h>
24. #include <mach/regs-gpio.h>
25. #include <mach/map.h>
26. MODULE_LICENSE("GPL");
27. #define GPHCON (*(volatile unsigned int *)S3C2410_GPHCON)
28. #define GPHDAT (*(volatile unsigned int *)S3C2410_GPHDAT)
29. #define GPHUP (*(volatile unsigned int *)S3C2410_GPHUP)
30. static int ds18b20_major = 230;        /*静态申请设备号*/
31. struct cdev cdev;
32. struct class *my_class;
33. spinlock_t lock;
34. dev_t dev = 0;
35. int number_of_devices = 1;
36. /*配置为输入模式*/
37. void set_conIN(void)
38. {
39. GPHCON &= ~(1<<19);
40. GPHCON &= ~(1<<18);
41. }
42. /*配置为输出模式*/
43. void set_conOUT(void)
44. {
45. GPHCON |= (1<<18);
46. GPHCON &= ~(1<<19);
47. }
48. /*引脚置位*/
49. void set_data(int i)
50. {
51. if( i == 0 ){
52. GPHDAT &= ~(1<<9);
53. }else if( i == 1 ){
54. GPHDAT |= (1<<9);
55. }
56. }
57. /*复位ds18b20*/
58. unsigned int reset_ds18b20(void)
59. {
60. unsigned int retValue;
61. set_conOUT();
62. set_data(1);
63. __udelay(1);
64. set_data(0);
65. __udelay(600);
66. set_data(1);
67. __udelay(20);
68. set_conIN();
69. __udelay(100);
70. /*稍做延时后 如果x=0则初始化成功
71. x=1则初始化失*/
72. retValue = (GPHDAT >> 9) & 0x01;
73. printk("init is %d\n",retValue);
74. return retValue;
75. }
76. /*读取一位温度*/
77. unsigned int read_bit(void)
78. {
79. spin_lock(&lock);
80. set_conOUT();
81. //set_data(1);
82. //__udelay(2);
83. set_data(0);
84. __udelay(2);
85. set_conIN();
86. __udelay(1);
87. spin_unlock(&lock);
88. return ((GPHDAT >> 9) & 0x01);
89. }
90. /*写一位命令*/
91. void write_bit(char bitValue)
92. {
93. spin_lock(&lock);
94. set_conOUT();
95. set_data(0);
96. __udelay(15);
97. if( bitValue == 1 ){
98. set_data(1);
99. }else{
100. set_data(0);
101. }
102. spin_unlock(&lock);
103. __udelay(45);
104. set_conIN();
105. __udelay(2);
106. }
107. /*写命令*/
108. void write_cmd(char cmd)
109. {
110. unsigned char i;
111. unsigned char temp;
112. for(i=0; i<8;i++){
113. temp = cmd>>i;
114. temp &= 0x01;
115. write_bit(temp);
116. }
117. //__udelay(10);
118. }
119. /*打开设备*/
120. static int ds18b20_open(struct inode *inode,struct file *filp)
121. {
122. printk (KERN_INFO "HEY! device opened\n");
123. //GPHUP &= ~(1<<9);
124. GPHUP |= (1<<9);
125. spin_lock_init(&lock);
126. return 0;
127. }
128. /*读取数据*/
129. static int ds18b20_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
130. {
131. char lowValue=0,highValue=0;
132. unsigned int i;
133. //float value;
134. if(reset_ds18b20()){
135. printk("init error\n");
136. }
137. __udelay(400);
138. set_conOUT();
139. set_data(1);
140. write_cmd(0xCC);
141. write_cmd(0x44);
142. __udelay(100000);
143. if(reset_ds18b20()){
144. printk("init error\n");
145. }
146. __udelay(400);
147. set_conOUT();
148. set_data(1);
149. write_cmd(0xcc);
150. write_cmd(0xBE);
151. /*读取温度转化数值*/
152. for(i=0; i<8; i++){
153. if( read_bit() ){
154. lowValue |= (0x01<<i);
155. }
156. __udelay(62);
157. }
158. printk("lowValue is %d\n",lowValue);
159. for(i=0; i<8; i++){
160. if( read_bit() ){
161. highValue |= (0x01<<i);
162. }
163. __udelay(62);
164. }
165. printk("highValue is %d\n",highValue);
166. #if 0
167. i = highValue;
168. i <<= 8;
169. i = i|lowValue;
170. value = i*0.0625;
171. printk("kernel is %d\n",value);
172. #endif
173. highValue <<= 4;
174. highValue |= ((lowValue&0xf0)>>4) ;
175. /*拷贝内核数据到用户空间*/
176. copy_to_user(buffer, &highValue, sizeof(highValue));
177. return 0;
178. }
179. /*写命令，在此置空*/
180. static int ds18b20_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
181. {
182. return 0;
183. }
184. static int ds18b20_release(struct inode *inode,struct file *filp)
185. {
186. printk (KERN_INFO "device closed\n");
187. return 0;
188. }
189. static int ds18b20_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
190. {
191. return 0;
192. }
193. struct file_operations ds18b20_fops ={
194. .owner = THIS_MODULE,
195. .open = ds18b20_open,
196. .read = ds18b20_read,
197. .write = ds18b20_write,
198. .ioctl = ds18b20_ioctl,
199. .release = ds18b20_release,
200. };
201. static void ds18b20_setup_cdev(void)
202. {
203. int error,devno = MKDEV(ds18b20_major,0);
204. cdev_init(&cdev,&ds18b20_fops);
205. cdev.owner = THIS_MODULE;
206. cdev.ops = &ds18b20_fops;
207. error = cdev_add(&cdev,devno,1);
208. if( error )
209. printk(KERN_INFO"Error %d adding ds18b20 %d\n",error,0);
210. my_class = class_create(THIS_MODULE,"my_class");
211. if(IS_ERR(my_class))
212. {
213. printk("Err: failed in creating class.\n");
214. return;
215. }
216. device_create(my_class,NULL,devno,NULL,"ds18b20");
217. }
218. /*注册设备*/
219. static int ds18b20_init(void)
220. {
221. int result;
222. dev = MKDEV(ds18b20_major,0);
223. if(ds18b20_major)
224. result = register_chrdev_region(dev,1,"ds18b20");
225. else{
226. result = alloc_chrdev_region(&dev,0,1,"ds18b20");
227. ds18b20_major=MAJOR(dev);
228. }
229. if( result < 0 ){
230. printk(KERN_WARNING"ds18b20:unable to get major %d\n",ds18b20_major);
231. return result;
232. }
233. if(ds18b20_major == 0 )
234. ds18b20_major = result;
235. ds18b20_setup_cdev();
236. printk("ds18b20 initialized.\n");
237. return 0;
238. }
239. static void __exit ds18b20_exit(void)
240. {
241. dev_t devno = MKDEV (ds18b20_major, 0);
242. device_destroy(my_class,devno);
243. class_destroy(my_class);
244. cdev_del (&cdev);
245. unregister_chrdev_region (devno, number_of_devices);
246. printk("ds18b20_major=%d\n",ds18b20_major);
247. printk("ds18b20 device uninstalled\n");
248. }
249. module_init(ds18b20_init);
250. module_exit(ds18b20_exit);

#include <linux/module.h>
        #include <linux/moduleparam.h>
        #include <linux/fs.h>
        #include <linux/proc_fs.h>
        #include <linux/errno.h>
        #include <linux/cdev.h>
        #include <linux/ioctl.h>
        #include <linux/fcntl.h>
        #include <linux/sched.h>
        #include <linux/poll.h>
        #include <linux/version.h>
        #include <linux/kernel.h>
        #include <linux/init.h>
        #include <linux/device.h>
        #include <linux/mm.h>
        #include <linux/spinlock.h>
        #include <plat/map.h>
        #include <asm/io.h>
        #include <asm/delay.h>
        #include <asm/memory.h>
        #include <asm/uaccess.h>
        #include <asm/mach/map.h>
        #include <asm/uaccess.h>
        #include <mach/regs-gpio.h>
        #include <mach/map.h>
        MODULE_LICENSE("GPL");
 
#define GPHCON (*(volatile unsigned int *)S3C2410_GPHCON)
        #define GPHDAT (*(volatile unsigned int *)S3C2410_GPHDAT)
        #define GPHUP (*(volatile unsigned int *)S3C2410_GPHUP)
 
static int ds18b20_major = 230;        /*静态申请设备号*/ 
 
struct cdev cdev;
        struct class *my_class;
 
spinlock_t lock;
 
dev_t dev = 0;
        int number_of_devices = 1;
 
/*配置为输入模式*/
        void set_conIN(void)
        {
                GPHCON &= ~(1<<19);
                GPHCON &= ~(1<<18);
        }
 
/*配置为输出模式*/
        void set_conOUT(void)
        {
                GPHCON |= (1<<18);
                GPHCON &= ~(1<<19);
        }
 
/*引脚置位*/
        void set_data(int i)
        {
                if( i == 0 ){
                        GPHDAT &= ~(1<<9);
                }else if( i == 1 ){
                        GPHDAT |= (1<<9);
                }
        }
 
/*复位ds18b20*/
        unsigned int reset_ds18b20(void)
        {
                unsigned int retValue;
                set_conOUT();
 
        set_data(1);
                __udelay(1);
                set_data(0);
                __udelay(600);
                set_data(1);
                __udelay(20);
                set_conIN();
                __udelay(100);
                /*稍做延时后 如果x=0则初始化成功
                x=1则初始化失*/
                retValue = (GPHDAT >> 9) & 0x01;
                printk("init is %d\n",retValue);
                return retValue;
        }
 
/*读取一位温度*/
        unsigned int read_bit(void)
        {
                spin_lock(&lock);
                set_conOUT();
                //set_data(1);
                //__udelay(2);
                set_data(0);
                __udelay(2);
                set_conIN();
                __udelay(1);
                spin_unlock(&lock);
                return ((GPHDAT >> 9) & 0x01);
        }
 
/*写一位命令*/
        void write_bit(char bitValue)
        {
                spin_lock(&lock);
                set_conOUT();
                set_data(0);
                __udelay(15);
                if( bitValue == 1 ){
                        set_data(1);
                }else{
                        set_data(0);
                }
                spin_unlock(&lock);
                __udelay(45);
                set_conIN();
                __udelay(2);
        }
 
/*写命令*/
        void write_cmd(char cmd)
        {
                unsigned char i;
                unsigned char temp;
 
                for(i=0; i<8;i++){
                        temp = cmd>>i;
                        temp &= 0x01;
                        write_bit(temp);
                }
                //__udelay(10);
        }
        /*打开设备*/
        static int ds18b20_open(struct inode *inode,struct file *filp)
        {
                printk (KERN_INFO "HEY! device opened\n");
                //GPHUP &= ~(1<<9);
                GPHUP |= (1<<9);
                spin_lock_init(&lock);
                return 0;
        }
        /*读取数据*/
        static int ds18b20_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
        {
                char lowValue=0,highValue=0;
                unsigned int i;
                //float value;
 
        if(reset_ds18b20()){
                        printk("init error\n");
                }
                __udelay(400);
                set_conOUT();
                set_data(1);
                write_cmd(0xCC);
                write_cmd(0x44);
                __udelay(100000);
 
                if(reset_ds18b20()){
                        printk("init error\n");
                }
                __udelay(400);
                set_conOUT();
                set_data(1);
                write_cmd(0xcc);
                write_cmd(0xBE);
                /*读取温度转化数值*/
 
                for(i=0; i<8; i++){
                        if( read_bit() ){
                                lowValue |= (0x01<<i);
                        }
                        __udelay(62);
                }
                printk("lowValue is %d\n",lowValue);
                for(i=0; i<8; i++){
                        if( read_bit() ){
                                highValue |= (0x01<<i);
                        }
                        __udelay(62);
                }
                printk("highValue is %d\n",highValue);
        #if 0
                i = highValue;
                i <<= 8;
                i = i|lowValue;
                value = i*0.0625;
                printk("kernel is %d\n",value);
        #endif
 
        highValue <<= 4;
                highValue |= ((lowValue&0xf0)>>4) ;
 
                /*拷贝内核数据到用户空间*/
                copy_to_user(buffer, &highValue, sizeof(highValue));
                return 0;
        }
        /*写命令，在此置空*/
        static int ds18b20_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
        {
                return 0;
        }
 
static int ds18b20_release(struct inode *inode,struct file *filp)
        {
                        printk (KERN_INFO "device closed\n");
                return 0;
        }
 
static int ds18b20_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
        {
                return 0;
        }
 
struct file_operations ds18b20_fops ={
                .owner = THIS_MODULE,
                .open = ds18b20_open,
                .read = ds18b20_read,
                .write = ds18b20_write,
                .ioctl = ds18b20_ioctl,
        .release = ds18b20_release,
        };
        static void ds18b20_setup_cdev(void)
        {
                int error,devno = MKDEV(ds18b20_major,0);
                cdev_init(&cdev,&ds18b20_fops);
                cdev.owner = THIS_MODULE;
                cdev.ops = &ds18b20_fops;
                error = cdev_add(&cdev,devno,1);
                if( error )
                        printk(KERN_INFO"Error %d adding ds18b20 %d\n",error,0);
                my_class = class_create(THIS_MODULE,"my_class");
                if(IS_ERR(my_class))
                {
                        printk("Err: failed in creating class.\n");
                        return;
                }
                device_create(my_class,NULL,devno,NULL,"ds18b20");
        }
        /*注册设备*/
 
static int ds18b20_init(void)
        {
                int result;
 
        dev = MKDEV(ds18b20_major,0);
                if(ds18b20_major)
                        result = register_chrdev_region(dev,1,"ds18b20");
                else{
                        result = alloc_chrdev_region(&dev,0,1,"ds18b20");
                        ds18b20_major=MAJOR(dev);
                }
                if( result < 0 ){
                        printk(KERN_WARNING"ds18b20:unable to get major %d\n",ds18b20_major);
                        return result;
                }
                if(ds18b20_major == 0 )
                ds18b20_major = result;
 
                ds18b20_setup_cdev();
                printk("ds18b20 initialized.\n");
                return 0;
        }
 
static void __exit ds18b20_exit(void)
        {
                dev_t devno = MKDEV (ds18b20_major, 0);
                device_destroy(my_class,devno);
                class_destroy(my_class);
                cdev_del (&cdev);
                unregister_chrdev_region (devno, number_of_devices);
 
                printk("ds18b20_major=%d\n",ds18b20_major);
                printk("ds18b20 device uninstalled\n");
        }
 
module_init(ds18b20_init);
        module_exit(ds18b20_exit);