Linux驱动开发(速记版)--单总线

最新推荐文章于 2024-10-08 15:49:37 发布
最新推荐文章于 2024-10-08 15:49:37 发布
阅读量633 收藏 12
点赞数 13
分类专栏： 嵌入式驱动开发 文章标签： 驱动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42190402/article/details/142733727
版权

第124章 单总线简介

124.1 单总线概述

        单总线是一种串行通信协议，由Dallas Semiconductor开发，特点是用一根信号线实现双向数据传输和时钟同步，节省IO口且结构简单。

        它广泛应用于传感器、存储器等。

        硬件包括信号线、上拉电阻、设备和处理器。

        设备通过唯一64位地址识别，处理器控制通信。

124.2 单总线的通信步骤

        单总线是主从结构，当主机呼叫从机时，从机才会应答，所以主机都必须严格遵循单总线的命令时序。如果命令时序不对，则器件不会响应。

单总线的通信步骤通常包括以下几个阶段。

1 初始化：通信开始之前，主设备会发送初始化信号来确保单总线上没有其他设备正在通信。

        初始化信号是一个特定的序列，通常是将数据线拉低一段时间然后释放。

2 ROM 操作命令

3 功能命令

第125章 DS18B20 驱动框架编写

编写 DS18b20 驱动涉及以下几个关键知识点

1 字符设备驱动

2 平台总线

3 设备树

4 解析设备树

5 gpio 子系统

6 pinctrl 子系统

7 单总线协议

125.1 驱动程序的编写

        该代码是一个Linux内核模块，用于实现DS18B20温度传感器的平台驱动。

        它包含了驱动的初始化、设备探测（probe）功能以及模块的加载和卸载功能。

// 设备数据结构  
struct ds18b20_data {  
    dev_t dev_num; // 设备号  
    struct cdev ds18b20_cdev; // 字符设备结构  
    struct class *ds18b20_class; // 设备类  
    struct device *ds18b20_device; // 设备  
};  
  
static struct ds18b20_data *ds18b20; // 全局设备数据指针  
  
// 设备文件操作函数  
int ds18b20_open(struct inode *inode, struct file *file)  
{  
    return 0;  
}  
  
ssize_t ds18b20_read(struct file *file, char __user *buf, size_t size, loff_t *offs)  
{  
    // 此处应添加读取设备的实际逻辑  
    return 0; // 表示成功读取了0字节（应修改为实际读取的字节数）  
}  
  
int ds18b20_release(struct inode *inode, struct file *file)  
{  
    return 0;  
}  
  
// 定义设备文件操作结构  
static struct file_operations ds18b20_fops = {  
    .open = ds18b20_open,  
    .read = ds18b20_read,  
    .release = ds18b20_release,  
    .owner = THIS_MODULE,  
};  
  
// 设备探测函数  
int ds18b20_probe(struct platform_device *dev)  
{  
    int ret;  
    printk(KERN_INFO "This is probe\n");  
  
    // 分配设备数据结构内存  
    ds18b20 = kzalloc(sizeof(*ds18b20), GFP_KERNEL);  
    if (!ds18b20) {  
        printk(KERN_ERR "kzalloc error\n");  
        ret = -ENOMEM;  
        goto error_0;  
    }  
  
    // 分配字符设备号  
    ret = alloc_chrdev_region(&ds18b20->dev_num, 0, 1, "myds18b20");  
    if (ret < 0) {  
        printk(KERN_ERR "alloc_chrdev_region error\n");  
        goto error_1;  
    }  
  
    // 初始化字符设备并添加到系统  
    cdev_init(&ds18b20->ds18b20_cdev, &ds18b20_fops);  
    ds18b20->ds18b20_cdev.owner = THIS_MODULE;  
    ret = cdev_add(&ds18b20->ds18b20_cdev, ds18b20->dev_num, 1);  
    if (ret < 0) {  
        printk(KERN_ERR "cdev_add error\n");  
        goto error_2;  
    }  
  
    // 创建设备类  
    ds18b20->ds18b20_class = class_create(THIS_MODULE, "sensors");  
    if (IS_ERR(ds18b20->ds18b20_class)) {  
        printk(KERN_ERR "class_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_class);  
        goto error_3;  
    }  
  
    // 创建设备  
    ds18b20->ds18b20_device = device_create(ds18b20->ds18b20_class, NULL, ds18b20->dev_num, NULL, "ds18b20");  
    if (IS_ERR(ds18b20->ds18b20_device)) {  
        printk(KERN_ERR "device_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_device);  
        goto error_4;  
    }  
  
    return 0;  
  
error_4:  
    class_destroy(ds18b20->ds18b20_class);  
error_3:  
    cdev_del(&ds18b20->ds18b20_cdev);  
error_2:  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
error_1:  
    kfree(ds18b20);  
error_0:  
    return ret;  
}  
  
// 定义设备匹配表  
static const struct of_device_id ds18b20_match_table[] = {  
    { .compatible = "ds18b20" },  
    { },  
};  
MODULE_DEVICE_TABLE(of, ds18b20_match_table);  
  
// 定义平台驱动  
static struct platform_driver ds18b20_driver = {  
    .driver = {  
        .owner = THIS_MODULE,  
        .name = "ds18b20",  
        .of_match_table = ds18b20_match_table,  
    },  
    .probe = ds18b20_probe,  
};  
  
// 模块初始化函数  
static int __init ds18b20_init(void)  
{  
    int ret;  
    ret = platform_driver_register(&ds18b20_driver);  
    if (ret < 0) {  
        printk(KERN_ERR "platform_driver_register error\n");  
        return -1;  
    }  
    return 0;  
}  
  
// 模块退出函数  
static void __exit ds18b20_exit(void)  
{  
    // 销毁设备  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
    // 销毁设备类  
    class_destroy(ds18b20->ds18b20_class);  
    // 删除字符设备  
    cdev_del(&ds18b20->ds18b20_cdev);  
    // 注销字符设备号  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
    // 释放设备数据结构内存  
    kfree(ds18b20);  
    // 注销平台驱动  
    platform_driver_unregister(&ds18b20_driver);  
}  
  
module_init(ds18b20_init);  
module_exit(ds18b20_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("DS18B20 Temperature Sensor Driver");

第126章 DS18B20 驱动设备树

126.1 DS18B20 驱动设备树配置

        打开 Linux/linux_sdk/kernel/arch/arm64/boot/dts/rockchip/rk3568-evb1-ddr4-v10.dtsi 文件，在根目录下添加 ds18b20 节点，如下所示：

ds18b20_gpio: gpio0_b0 {    
    // 表示该设备节点兼容ds18b20温度传感器  
    compatible = "ds18b20";    
      
    // 指定ds18b20连接到的GPIO引脚信息  
    // <&gpio0> 表示使用gpio0控制器  
    // RK_PB0 表示引脚号为RK_PB0  
    // GPIO_ACTIVE_HIGH 表示信号高电平有效  
    ds18b20-gpios = <&gpio0 RK_PB0 GPIO_ACTIVE_HIGH>;    
      
    // 定义引脚控制名称，这里使用默认配置  
    pinctrl-names = "default";    
      
    // 指向具体的引脚控制配置节点  
    // <&ds18b20_gpio_ctrl> 引用名为ds18b20_gpio_ctrl的控制配置  
    pinctrl-0 = <&ds18b20_gpio_ctrl>;    
};

        &pinctrl 节点添加如下节点，

ds18b20_gpio {    
    // 定义ds18b20的GPIO控制节点  
    ds18b20_gpio_ctrl: ds18b20-gpio-ctrl {    
        // 配置GPIO引脚信息  
        // 1: 引脚编号（可能表示在GPIO控制器中的索引）  
        // RK_PA0: 引脚地址（具体硬件上的引脚）  
        // RK_FUNC_GPIO: 引脚功能（设置为GPIO功能）  
        // &pcfg_pull_none: 引脚不上拉也不下拉  
        rockchip,pins = <1 RK_PA0 RK_FUNC_GPIO &pcfg_pull_none>;    
    };    
};

        修改完成后，重新编译并烧写内核镜像。

        内核镜像烧写完毕，输入以下命令

cd /proc/device-tree/gpio0_b0/
ls
cat compatible
设备树中DS18B20的GPIO的设备节点的兼容性字符串

         然后 Insmod装载 ds18b20的驱动，

加载的设备驱动列表

 

         至此，DS18b20 设备树配置和字符设备驱动框架已经完成了。

第127章 DS18B20 驱动复位时序编写

127.1 DS18B20 驱动获取 GPIO 编写

        该代码实现了一个完整的Linux内核模块，用于支持DS18B20温度传感器。

        它包含了必要的头文件、数据结构、文件操作、设备探测、初始化、退出函数等。

        在探测函数中，代码进行了内存分配、字符设备注册、设备类和设备的创建、GPIO配置等操作。

        在退出函数中，代码则进行了相应的清理和注销操作。

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/platform_device.h>  
#include <linux/of.h>  
#include <linux/cdev.h>  
#include <linux/device.h>  
#include <linux/gpio/consumer.h>  
#include <linux/fs.h>  
#include <linux/uaccess.h>  
  
// DS18B20 数据结构  
struct ds18b20_data {  
    dev_t dev_num;                // 设备号  
    struct cdev ds18b20_cdev;     // 字符设备结构体  
    struct class *ds18b20_class;  // 设备类  
    struct device *ds18b20_device;// 设备  
    struct gpio_desc *ds18b20_gpio;// GPIO 描述符  
};  
  
static struct ds18b20_data *ds18b20; // DS18B20 数据结构指针  
  
// 文件操作结构体函数  
static int ds18b20_open(struct inode *inode, struct file *file)  
{  
    return 0;  
}  
  
static ssize_t ds18b20_read(struct file *file, char __user *buf, size_t size, loff_t *offs)  
{  
    return 0;  
}  
  
static int ds18b20_release(struct inode *inode, struct file *file)  
{  
    return 0;  
}  
  
static struct file_operations ds18b20_fops = {  
    .open = ds18b20_open,  
    .read = ds18b20_read,  
    .release = ds18b20_release,  
    .owner = THIS_MODULE,  
};  
  
// 设备探测函数  
static int ds18b20_probe(struct platform_device *dev)  
{  
    int ret;  
    printk("This is probe\n");  
  
    // 分配内存给 ds18b20_data 结构体  
    ds18b20 = kzalloc(sizeof(*ds18b20), GFP_KERNEL);  
    if (!ds18b20) {  
        printk("kzalloc error\n");  
        ret = -ENOMEM;  
        goto error_0;  
    }  
  
    // 分配字符设备号  
    ret = alloc_chrdev_region(&ds18b20->dev_num, 0, 1, "myds18b20");  
    if (ret < 0) {  
        printk("alloc_chrdev_region error\n");  
        ret = -EAGAIN;  
        goto error_1;  
    }  
  
    // 初始化字符设备  
    cdev_init(&ds18b20->ds18b20_cdev, &ds18b20_fops);  
    ds18b20->ds18b20_cdev.owner = THIS_MODULE;  
    cdev_add(&ds18b20->ds18b20_cdev, ds18b20->dev_num, 1);  
  
    // 创建设备类  
    ds18b20->ds18b20_class = class_create(THIS_MODULE, "sensors");  
    if (IS_ERR(ds18b20->ds18b20_class)) {  
        printk("class_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_class);  
        goto error_2;  
    }  
  
    // 创建设备  
    ds18b20->ds18b20_device = device_create(ds18b20->ds18b20_class, NULL, ds18b20->dev_num, NULL, "ds18b20");  
    if (IS_ERR(ds18b20->ds18b20_device)) {  
        printk("device_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_device);  
        goto error_3;  
    }  
  
    // 获取 GPIO 描述符  
    ds18b20->ds18b20_gpio = gpiod_get_optional(&dev->dev, "ds18b20", 0);  
    if (!ds18b20->ds18b20_gpio) {  
        ret = -EBUSY;  
        goto error_4;  
    }  
  
    // 设置 GPIO 方向为输出  
    gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
  
    return 0;  
  
error_4:  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
error_3:  
    class_destroy(ds18b20->ds18b20_class);  
error_2:  
    cdev_del(&ds18b20->ds18b20_cdev);  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
error_1:  
    kfree(ds18b20);  
error_0:  
    return ret;  
}  
  
// 设备匹配表  
static const struct of_device_id ds18b20_match_table[] = {  
    { .compatible = "ds18b20" },  
    {},  
};  
  
// 平台驱动结构体  
static struct platform_driver ds18b20_driver = {  
    .driver = {  
        .owner = THIS_MODULE,  
        .name = "ds18b20",  
        .of_match_table = ds18b20_match_table,  
    },  
    .probe = ds18b20_probe,  
};  
  
// 模块初始化函数  
static int __init ds18b20_init(void)  
{  
    int ret;  
    ret = platform_driver_register(&ds18b20_driver);  
    if (ret < 0) {  
        printk("platform_driver_register error\n");  
        return -1;  
    }  
    return 0;  
}  
  
// 模块退出函数  
static void __exit ds18b20_exit(void)  
{  
    // 释放 GPIO 描述符  
    gpiod_put(ds18b20->ds18b20_gpio);  
  
    // 销毁设备  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
  
    // 销毁设备类  
    class_destroy(ds18b20->ds18b20_class);  
  
    // 删除字符设备  
    cdev_del(&ds18b20->ds18b20_cdev);  
  
    // 注销字符设备号  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
  
    // 释放 ds18b20_data 内存  
    kfree(ds18b20);  
  
    // 注销平台驱动  
    platform_driver_unregister(&ds18b20_driver);  
}  
  
module_init(ds18b20_init);  
module_exit(ds18b20_exit);  
MODULE_LICENSE("GPL");

127.2 DS18b20 驱动复位时序编写

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/platform_device.h>  
#include <linux/of.h>  
#include <linux/cdev.h>  
#include <linux/device.h>  
#include <linux/gpio/consumer.h>  
#include <linux/fs.h>  
#include <linux/uaccess.h>  
  
struct ds18b20_data {  
    dev_t dev_num;                  // 设备号  
    struct cdev ds18b20_cdev;       // 字符设备结构体  
    struct class *ds18b20_class;    // 设备类  
    struct device *ds18b20_device;  // 设备  
    struct gpio_desc *ds18b20_gpio; // GPIO 描述符  
};  
  
static struct ds18b20_data *ds18b20; // DS18B20 数据结构指针  
  
static int ds18b20_open(struct inode *inode, struct file *file)  
{  
    return 0;  
}  
  
static ssize_t ds18b20_read(struct file *file, char __user *buf, size_t size, loff_t *offs)  
{  
    return 0;  
}  
  
static int ds18b20_release(struct inode *inode, struct file *file)  
{  
    return 0;  
}  
  
static struct file_operations ds18b20_fops = {  
    .open = ds18b20_open,  
    .read = ds18b20_read,  
    .release = ds18b20_release,  
    .owner = THIS_MODULE,  
};  
  
// 设备探测函数  
static int ds18b20_probe(struct platform_device *dev)  
{  
    int ret;  
    printk("This is probe\n");  
  
    // 分配内存给 ds18b20_data 结构体  
    ds18b20 = kzalloc(sizeof(*ds18b20), GFP_KERNEL);  
    if (!ds18b20) {  
        printk("kzalloc error\n");  
        ret = -ENOMEM;  
        goto error_0;  
    }  
  
    // 分配字符设备号  
    ret = alloc_chrdev_region(&ds18b20->dev_num, 0, 1, "myds18b20");  
    if (ret < 0) {  
        printk("alloc_chrdev_region error\n");  
        ret = -EAGAIN;  
        goto error_1;  
    }  
  
    // 初始化字符设备  
    cdev_init(&ds18b20->ds18b20_cdev, &ds18b20_fops);  
    ds18b20->ds18b20_cdev.owner = THIS_MODULE;  
    cdev_add(&ds18b20->ds18b20_cdev, ds18b20->dev_num, 1);  
  
    // 创建设备类  
    ds18b20->ds18b20_class = class_create(THIS_MODULE, "sensors");  
    if (IS_ERR(ds18b20->ds18b20_class)) {  
        printk("class_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_class);  
        goto error_2;  
    }  
  
    // 创建设备  
    ds18b20->ds18b20_device = device_create(ds18b20->ds18b20_class, NULL, ds18b20->dev_num, NULL, "ds18b20");  
    if (IS_ERR(ds18b20->ds18b20_device)) {  
        printk("device_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_device);  
        goto error_3;  
    }  
  
    // 获取 GPIO 描述符  
    ds18b20->ds18b20_gpio = gpiod_get_optional(&dev->dev, "ds18b20", 0);  
    if (!ds18b20->ds18b20_gpio) {  
        ret = -EBUSY;  
        goto error_4;  
    }  
  
    // 设置 GPIO 方向为输出  
    gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
  
    return 0;  
  
error_4:  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
error_3:  
    class_destroy(ds18b20->ds18b20_class);  
error_2:  
    cdev_del(&ds18b20->ds18b20_cdev);  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
error_1:  
    kfree(ds18b20);  
error_0:  
    return ret;  
}  
  
// 设备匹配表  
static const struct of_device_id ds18b20_match_table[] = {  
    { .compatible = "ds18b20" },  
    {},  
};  
  
static struct platform_driver ds18b20_driver = {  
    .driver = {  
        .owner = THIS_MODULE,  
        .name = "ds18b20",  
        .of_match_table = ds18b20_match_table,  
    },  
    .probe = ds18b20_probe,  
};  
  
static int __init ds18b20_init(void)  
{  
    int ret;  
    ret = platform_driver_register(&ds18b20_driver);  
    if (ret < 0) {  
        printk("platform_driver_register error\n");  
        return -1;  
    }  
    return 0;  
}  
  
static void __exit ds18b20_exit(void)  
{  
    // 释放 GPIO 描述符  
    gpiod_put(ds18b20->ds18b20_gpio);  
  
    // 销毁设备  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
  
    // 销毁设备类  
    class_destroy(ds18b20->ds18b20_class);  
  
    cdev_del(&ds18b20->ds18b20_cdev);  
  
    // 注销字符设备号  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
  
    // 释放 ds18b20_data 内存  
    kfree(ds18b20);  
  
    // 注销平台驱动  
    platform_driver_unregister(&ds18b20_driver);  
}  
  
module_init(ds18b20_init);  
module_exit(ds18b20_exit);  
MODULE_LICENSE("GPL");

        硬件连接好之后，安装逻辑分析仪的上位机软件，安装完成之后，打开上位机软件，然后设置参数，

 

设置完毕之后，如下图所示：

上位机上捕捉到时序如下图所示： 

将捕捉到的复位时序和下图的时序图对比分析，可以看出驱动复位时序是没问题的。

        至此，DS18b20 驱动复位时序编写完成。

第128章 DS18B20 驱动写时序编写

         驱动入口函数调用了 ds18b20的写字节函数，

        写字节函数调用写位函数，

        写位函数调用 gpiod接口，

        gpiod接口基于 gpio描述符。

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/platform_device.h>  
#include <linux/of.h>  
#include <linux/gpio/consumer.h>  
#include <linux/uaccess.h>  
#include <linux/cdev.h>  
#include <linux/fs.h>  
#include <linux/delay.h> // for udelay  
  
struct ds18b20_data {  
    dev_t dev_num;  
    struct cdev ds18b20_cdev;  
    struct class *ds18b20_class;  
    struct device *ds18b20_device;  
    struct gpio_desc *ds18b20_gpio;  
};  
  
static struct ds18b20_data *ds18b20;  
  
// 复位 DS18B20  
static void ds18b20_reset(void) {  
    gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
    gpiod_set_value(ds18b20->ds18b20_gpio, 0);  
    udelay(700);  
    gpiod_set_value(ds18b20->ds18b20_gpio, 1);  
    gpiod_direction_input(ds18b20->ds18b20_gpio);  
    while (gpiod_get_value(ds18b20->ds18b20_gpio));  
    while (!gpiod_get_value(ds18b20->ds18b20_gpio));  
    udelay(480);  
}  
  
// 向 DS18B20 写入单个位  
static void ds18b20_writebit(unsigned char bit) {  
    gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
    gpiod_set_value(ds18b20->ds18b20_gpio, 0);  
    if (bit) {  
        udelay(10);  
        gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
    }  
    udelay(65);  
    gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
    udelay(2);  
}  
  
// 向 DS18B20 写入一个字节  
static void ds18b20_writebyte(int data) {  
    int i;  
    for (i = 0; i < 8; i++) {  
        ds18b20_writebit(data & 0x01);  
        data >>= 1;  
    }  
}  
  
// 字符设备操作函数  
static int ds18b20_open(struct inode *inode, struct file *file) {  
    return 0;  
}  
  
static ssize_t ds18b20_read(struct file *file, char __user *buf, size_t size, loff_t *offs) {  
    return 0;  
}  
  
static int ds18b20_release(struct inode *inode, struct file *file) {  
    return 0;  
}  
  
static struct file_operations ds18b20_fops = {  
    .open = ds18b20_open,  
    .read = ds18b20_read,  
    .release = ds18b20_release,  
    .owner = THIS_MODULE,  
};  
  
// 设备探测函数  
static int ds18b20_probe(struct platform_device *dev) {  
    int ret;  
    printk("This is probe\n");  
  
    ds18b20 = kzalloc(sizeof(*ds18b20), GFP_KERNEL);  
    if (!ds18b20) {  
        printk("kzalloc error\n");  
        ret = -ENOMEM;  
        goto error_0;  
    }  
  
    ret = alloc_chrdev_region(&ds18b20->dev_num, 0, 1, "myds18b20");  
    if (ret < 0) {  
        printk("alloc_chrdev_region error\n");  
        ret = -EAGAIN;  
        goto error_1;  
    }  
  
    cdev_init(&ds18b20->ds18b20_cdev, &ds18b20_fops);  
    ds18b20->ds18b20_cdev.owner = THIS_MODULE;  
    cdev_add(&ds18b20->ds18b20_cdev, ds18b20->dev_num, 1);  
  
    ds18b20->ds18b20_class = class_create(THIS_MODULE, "sensors");  
    if (IS_ERR(ds18b20->ds18b20_class)) {  
        printk("class_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_class);  
        goto error_2;  
    }  
  
    ds18b20->ds18b20_device = device_create(ds18b20->ds18b20_class, NULL, ds18b20->dev_num, NULL, "ds18b20");  
    if (IS_ERR(ds18b20->ds18b20_device)) {  
        printk("device_create error\n");  
        ret = PTR_ERR(ds18b20->ds18b20_device);  
        goto error_3;  
    }  
  
    ds18b20->ds18b20_gpio = gpiod_get_optional(&dev->dev, "ds18b20", 0);  
    if (!ds18b20->ds18b20_gpio) {  
        ret = -EBUSY;  
        goto error_4;  
    }  
  
    gpiod_direction_output(ds18b20->ds18b20_gpio, 1);  
    return 0;  
  
error_4:  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
error_3:  
    class_destroy(ds18b20->ds18b20_class);  
error_2:  
    cdev_del(&ds18b20->ds18b20_cdev);  
    unregister_chrdev_region(ds18b20->dev_num, 1);  
error_1:  
    kfree(ds18b20);  
error_0:  
    return ret;  
}  
  
static const struct of_device_id ds18b20_match_table[] = {  
    { .compatible = "ds18b20" },  
    { },  
};  
  
static struct platform_driver ds18b20_driver = {  
    .driver = {  
        .owner = THIS_MODULE,  
        .name = "ds18b20",  
        .of_match_table = ds18b20_match_table,  
    },  
    .probe = ds18b20_probe,  
};  
  
static int __init ds18b20_init(void) {  
    int ret;  
    ret = platform_driver_register(&ds18b20_driver);  
    if (ret < 0) {  
        printk("platform_driver_register error\n");  
        return -1;  
    }  
    ds18b20_reset();  
    ds18b20_writebyte(0xcc); // 写入 0Xcc 字符（跳过 ROM 命令）  
    return 0;  
}  
  
static void __exit ds18b20_exit(void) {  
    gpiod_put(ds18b20->ds18b20_gpio);  
    device_destroy(ds18b20->ds18b20_class, ds18b20->dev_num);  
    class_destroy(ds1

第129章 DS18B20 驱动读时序编写

        读时序参考STM32和写时序的套路。

第130章 DS18B20读温度

        字符设备的 file_operations的读操作给了 ds18b20的读取代码。

  
// 定义DS18B20数据结构体  
struct ds18b20_data {  
    // ... 其他成员变量（省略）  
    struct gpio_desc *ds18b20_gpio; // GPIO描述符指针  
};  
  
// 声明DS18B20数据结构体指针  
struct ds18b20_data *ds18b20;  
  
// 复位DS18B20传感器  
void ds18b20_reset(void) {  
    // ... 复位操作（省略）  
}  
  
// 向DS18B20写入单个位  
void ds18b20_writebit(unsigned char bit) {  
    // ... 写位操作（省略）  
}  
  
// 向DS18B20写入一个字节  
void ds18b20_writebyte(int data) {  
    // ... 写字节操作（使用ds18b20_writebit，省略）  
}  
  
// 从DS18B20读取单个位  
unsigned char ds18b20_readbit(void) {  
    // ... 读位操作（省略）  
    return bit;  
}  
  
// 从DS18B20读取一个字节  
int ds18b20_readbyte(void) {  
    // ... 读字节操作（使用ds18b20_readbit，省略）  
    return data;  
}  
  
// 从DS18B20读取温度值  
int ds18b20_readtemp(void) {  
    int temp_l, temp_h, temp;  
    ds18b20_reset(); // 复位传感器  
    ds18b20_writebyte(0xCC); // 发送跳过ROM命令  
    ds18b20_writebyte(0x44); // 发送启动温度转换命令  
    mdelay(750); // 延时等待温度转换完成  
    ds18b20_reset(); // 再次复位传感器  
    ds18b20_writebyte(0xCC); // 发送跳过ROM命令  
    ds18b20_writebyte(0xBE); // 发送读取温度值命令  
    temp_l = ds18b20_readbyte(); // 读取温度低位字节  
    temp_h = ds18b20_readbyte(); // 读取温度高位字节  
    temp = (temp_h << 8) | temp_l; // 组合成完整的温度值  
    return temp;  
}  
  
// 字符设备读取函数  
ssize_t ds18b20_read(struct file *file, char __user *buf, size_t size, loff_t *offs) {  
    int ds18b20_temp;  
    ds18b20_temp = ds18b20_readtemp(); // 读取温度值  
    if (copy_to_user(buf, &ds18b20_temp, sizeof(ds18b20_temp))) {  
        return -1; // 复制失败，返回错误  
    }  
    return 0; // 成功读取并复制温度值  
}  

struct file_operations ds18b20_fops = {
    .open = ds18b20_open, 
    .read = ds18b20_read, 
    .release = ds18b20_release, 
    .unlocked_ioctl = ds18b20_ioctl, 
    .owner = THIS_MODULE, };

// 初始化字符设备
cdev_init(&ds18b20->ds18b20_cdev, &ds18b20_fops);
ds18b20->ds18b20_cdev.owner = THIS_MODULE;
cdev_add(&ds18b20->ds18b20_cdev, ds18b20->dev_num, 1);

//初始化设备类
...
//初始化设备
...

// ... 其他代码（如模块初始化、退出等，省略）
/*在应用程序中*/

// 设置分辨率
ioctl(fd, SET_RESOLUTION, args);
while (1) {
// 读取数据
read(fd, &data, sizeof(data));
// 处理并打印温度信息
ds18b20_get_temp(data);

第131章 DS18B20设置分辨率

/*读取分辨率*/
int read_resolution(void) {
    int ret;
    // 复位传感器
    ds18b20_reset();
    // 发送指令字节 0xCC，跳过 ROM 操作，直接与单个设备通信
    ds18b20_writebyte(0xCC);
    // 发送指令字节 0xBE，读取当前设备的配置寄存器
    ds18b20_writebyte(0xBE);
    // 读取 4 个字节的数据，但实际上只有最后一个字节是分辨率信息
    ds18b20_readbyte();
    ds18b20_readbyte();
    ds18b20_readbyte();
    ds18b20_readbyte();
    // 读取最后一个字节，即分辨率信息
    ret = ds18b20_readbyte();
    // 返回分辨率值
    return ret;
}

/**
* DS18B20 温度传感器的 ioctl 函数
* @param file 文件指针
* @param cmd 命令
* @param args 参数
* @return 返回执行结果，成功返回 0，失败返回 -1
*/
long ds18b20_ioctl(struct file *file, unsigned int cmd, unsigned long args) {
    int resolution;
    if (cmd == SET_RESOLUTION) { // 判断命令是否为设置分辨率
        if (args >= SET_RESOLUTION_9 && args <= SET_RESOLUTION_12) { // 判断参数是否在有效的分辨率范围内
            set_resolution(args); // 调用设置分辨率的函数
            return 0; // 返回成功
        }
    }
    else if (cmd == READ_RESOLUTION) {
    // 读取分辨率
    resolution = read_resolution();
    // 将分辨率的值复制给用户空间的 args
    if (copy_to_user((int *)args, &resolution, sizeof(resolution))) {
    // 复制失败，返回-1 表示失败
        return -1;
        }
    }
    // 如果不匹配 SET_RESOLUTION 或者 args 不在有效范围内，不执行任何操作
    return -1; // 返回失败
}

struct file_operations ds18b20_fops = {
    .open = ds18b20_open, 
    .read = ds18b20_read, 
    .release = ds18b20_release, 
    .unlocked_ioctl = ds18b20_ioctl, 
    .owner = THIS_MODULE, };
/*在应用程序中*/

// 设置分辨率
ioctl(fd, SET_RESOLUTION, args);
// 读取分辨率
ioctl(fd, READ_RESOLUTION, &resolution);
ds18b20_get_resolution(resolution);
while (1) {
// 读取数据
read(fd, &data, sizeof(data));
// 处理并打印温度信息
ds18b20_get_temp(data);

大象荒野
关注
专栏目录
Linux驱动开发(速记版)--设备模型
荒野
10-04 1047
RK3568 讯为
Linux驱动开发(速记版)--设备树
荒野
10-02 732
讯为 RK3568
Linux驱动开发(速记版)--输入子系统
荒野
10-06 1258
讯为 RK3568
Linux驱动开发(速记版)--平台总线
荒野
09-30 955
讯为 RK3568
c++面试高频题-速记版
小x的博客
04-25 1813
内存地址对齐 // 64位系统 struct T{ int a; //0-3 char ch; //4 int b; // 8-11 long c; // 16-23 char chs[12]; //24-35 }; // 总共占据40bytes Linux的虚拟内存、物理内存。 -虚拟内存是硬件异常、硬件地址翻译、主存、磁盘文件和内核软件的完美交互，它为每个进程提供了一个大的、一致的和私有的地址空间。它有4个重要的能力： 它将主存看成是一个存储在
操作系统-速记版（个人幕布导出）
Blogs of imWalker
04-21 1550
绪论 OS硬件模型：冯,诺伊曼模型5部分：内存（MDR和MAR），处理单元（ALU和TEMP），控制单元（PC程序计数器和IR指令寄存器）， 输入，输出 OS的形成与发展 手工操作阶段 脱机输入输出（缓冲区或者spooling技术） 批处理技术 多道程序设计 OS基本类型 技术： 单道批处理技术 解决人机矛盾中，CPU和I/O设备不匹配的矛盾中形成的 多道批处理技术 高效利用...
阿里linux内核月报2014-07-08
wdjjwb的专栏
05-22 1174
Capsicum for Linux Capsicum: 一种基于文件句柄的新安全模型 Capsicum是一种源自FreeBSD的安全模型，与Linux下众多LSM的相同之处在于它们都是基于权限管理的，而不同之处在于LSM针对的操作对象非常丰富，有进程、VMA、端口、带有标签的文件等等，而Capsicum操作的对象非常单一：文件句柄。例如，一个fd必须带有CAP_READ才能被读取，必须带有C...
嵌入式知识图谱WiKi（嵌入式开发/研发入门教程和路线图）
qq582880551的博客
02-19 6681
嵌入式知识图谱WiKi 作者 将狼才鲸 时间 2022-02-18 Gitee文档源文件仓库网址 才鲸 / 嵌入式知识图谱WiKi CSDN有图的文档阅读网址 嵌入式知识图谱WiKi Bilibili视频讲解网址（待完成） 才鲸嵌入式主页 一、概述 1. 模块框图 备注：gitee暂不支持mermaid框图和流程图显示。可以下载本git仓库并用Typora等软件打开本.md文件查看。 也可以点击该CSDN同名文章查看能正常显示图片的版本。 备注：因为mermaid subgrap
Linux文档收藏
gpchen111的博客
06-11 625
cpu
《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码.zip
04-29
《Linux设备驱动开发详解-基于最新的Linux4.0内核》是一本深入讲解Linux设备驱动程序开发的专业书籍，源码.zip文件包含了与书中的讲解密切相关的代码示例。Linux驱动开发是连接硬件与操作系统内核的重要桥梁，对于...
《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码
06-21
驱动开发首先需要理解Linux设备模型，包括总线、设备、驱动的抽象概念。书中会介绍如何注册和注销设备，以及如何匹配设备和驱动。此外，还会讲解设备文件的创建和操作，如通过`open()`, `read()`, `write()`等系统调...
嵌入式linux驱动开发教程--源代码.rar
07-18
本教程将通过源代码的形式，深入解析嵌入式Linux驱动开发的相关知识。以下是对该教程内容的详细概述： 1. **驱动程序基本概念** - **驱动的作用**：驱动程序是操作系统与硬件之间的桥梁，它负责翻译操作系统的指令...
Linux设备驱动开发详解-基于最新的Linux4.0内核
04-08
总的来说，《Linux设备驱动开发详解-基于最新的Linux4.0内核(第三版)》这本书全面覆盖了Linux4.0内核下的设备驱动开发，从基本概念到高级技术，为读者提供了宝贵的实践指导。无论你是初学者还是经验丰富的开发者，都...
Linux系统中1553B总线内核态驱动开发研究.pdf
09-06
Linux系统中1553B总线内核态驱动开发研究 本文开发了基于Linux系统的1553B总线内核态驱动程序，对内核态驱动程序的原理和实现进行了详细的分析和介绍，给出了重要的数据结构和流程图。同时对1553B总线的内核态驱动...
FOC电机驱动开发踩坑记录
mengjiexu_cn的博客
09-26 653
2. 低压区域采样，优点是对应器件的电压承受能力要求低，缺点是需要精确控制采样的时间，采样时间必须在H桥的下臂导通时进行采样，否则采样不到正确的电流；常用的无感FOC控制算法有滑膜控制器、龙博格观测器，基本都是靠观测器加锁相环来实现对转子角度位置的估计，但是都会有一些问题，滑膜控制器的问题是可能会出现电机震荡，可以通过调整参数的大小来降低震荡的幅度但一定会有。电机的三相电流采样有3种采样的方法，1种是3相电流全部采样，好处是能采到三相的实时真实电流，缺点是成本是最高的；
【学习笔记】LVGL开源框架入门学习（移植与使用）
2203_75993546的博客
10-02 889
LVGL是一款开源的嵌入式GUI框架。轻量级和灵活性是其著有的特征。我们在开发如智能手表，仪器表盘时可以采用这个框架。
驱动开发系列19 - GBM 和 DRM 的关系（扫盲）
最新发布
GPU全栈博主-程序哥
10-08 50
DRM（Direct Rendering Manager）是 Linux 内核的一部分，负责管理图形硬件的访问，包括设备驱动程序、显示模式设置、缓冲区分配等。DRM 提供底层硬件交互和资源管理。DRM运行在内核空间，它是 Direct Rendering Manager (DRM) 的一部分，它以内核头文件的形式该头文件提供了底层接口，允许设备驱动程序与 DRM 系统交互，包括缓冲区管理、模式设置和其他硬件操作。
Linux驱动开发(速记版)--printctl子系统
荒野
10-05 844
讯为 RK3568
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大象荒野

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值