Linux总线之I2C

已于 2024-05-12 18:03:21 修改
阅读量1.3k 收藏 15
点赞数 3
文章标签： linux 单片机 运维
于 2022-12-05 15:59:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KnowHowNewhaoran/article/details/128177707
版权

文章目录

1.i2c总线

1.1i2c总线驱动硬件知识复习

（1）i2c几根线？

scl:时钟线

sda:数据线

（2）几种信号？

start:起始信号：scl为高电平的时候，sda从高到低的跳变

stop:结束信号：scl为高电平的时候，sda从低到高的跳变

ack:在第九个时钟周期的时候，sda总线是低电平就代表应答

	（master--->slave   slave ---->master）

No ack:在第九个时钟周期的时候，sda总线持续高电平

（3）i2c读写时序

写时序：

\*\*start+ (从机地址 7bit + 0(写) 1bit) + ack + 寄存器地址（8bit|16bit）+ack \*\*

**+data(8bit|16bit) + ack + stop**

读时序：

**start+ (从机地址 7bit + 0(写) 1bit) + ack + 寄存器地址（8bit|16bit）+ack **

 **start+ (从机地址 7bit + 1(读) 1bit) + ack + data(8bit 从机给主机) +NO ack+stop**

（4）i2c总线的特点

i2c是一个半双工,同步的，串行，具备应答机制的总线协议。

（5）i2c总线速率（控制器）

100K  低速    400K 全速   3.4M 高速

1.2i2c总线驱动框架结构

在这里插入图片描述

1.3i2c总线驱动的API

1.分配并初始化对象
    struct i2c_driver {
        int (*probe)(struct i2c_client *client, const struct i2c_device_id *id);
        int (*remove)(struct i2c_client *client);
        struct device_driver driver;
        //const struct i2c_device_id *id_table;
    }
	struct device_driver {
		const char		*name;
        const struct of_device_id	*of_match_table;
    }
	//i2c的匹配方式只有两种：1.idtable，2.设备树
2.注册、注销
    #define i2c_add_driver(driver) i2c_register_driver(THIS_MODULE, driver)  //注册
    void i2c_del_driver(struct i2c_driver *driver); //注销
3.一键注册的函数
    module_i2c_driver(变量名);

1.4i2c总线驱动的实例

#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>

int myi2c_probe(struct i2c_client* client,
    const struct i2c_device_id* id)
{
    printk("%s:%d\n", __func__, __LINE__);
    return 0;
}
int myi2c_remove(struct i2c_client* client)
{
    printk("%s:%d\n", __func__, __LINE__);
    return 0;
}

struct of_device_id oftable[] = {
    {.compatible = "hqyj,myi2c",},
    {}
};
MODULE_DEVICE_TABLE(of,oftable);

struct i2c_driver myi2c = {
    .probe = myi2c_probe,
    .remove = myi2c_remove,
    .driver = {
        .name = "myi2c123456",
        .of_match_table = oftable,
    }
};
module_i2c_driver(myi2c);
MODULE_LICENSE("GPL");

2.i2c总线驱动

2.1si7006（sht20）设备树的编写

2.1.1画出硬件连接图

在这里插入图片描述

2.1.2找到控制器的设备树

stm32mp151.dtsi

i2c1: i2c@40012000 {
    compatible = "st,stm32mp15-i2c";  //和控制器匹配的名字
    reg = <0x40012000 0x400>;         //控制器的地址
    interrupt-names = "event", "error";
    interrupts-extended = <&exti 21 IRQ_TYPE_LEVEL_HIGH>,
                  <&intc GIC_SPI 32 IRQ_TYPE_LEVEL_HIGH>;
    clocks = <&rcc I2C1_K>;
    resets = <&rcc I2C1_R>;
    #address-cells = <1>;
    #size-cells = <0>;     //修饰子节点 reg成员个数
    dmas = <&dmamux1 33 0x400 0x80000001>,
           <&dmamux1 34 0x400 0x80000001>;
    dma-names = "rx", "tx";
    power-domains = <&pd_core>;
    st,syscfg-fmp = <&syscfg 0x4 0x1>;
    wakeup-source;
    i2c-analog-filter;
    status = "disabled";  //控制器没有使能
};

2.1.3编写自己的设备树

参考：linux-5.10.61/Documentation/devicetree/bindings/i2c
&i2c1{
    pinctrl-names = "default", "sleep";
    pinctrl-0 = <&i2c1_pins_b>;       //管脚复用，工作状态                                                      
    pinctrl-1 = <&i2c1_sleep_pins_b>; //管脚复用，休眠状态
    i2c-scl-rising-time-ns = <100>;   //scl上升沿和下降沿的时间                                              
    i2c-scl-falling-time-ns = <7>;
    status = "okay";                  //使能控制器
    /delete-property/dmas;            //删除dma属性                                          
    /delete-property/dma-names;
    
    si7006@40{
        compatible = "hqyj,si7006";  //和设备驱动匹配的名字
        reg = <0x40>;                //从机地址
    };
};

2.2i2c中相关的结构体

i2c_client结构体：当驱动进入到probe函数之前，内核会创建i2c_client，

这个i2c_client是用来记录数据的。比如i2c_adapter（控制器驱动的对象）就

被存放到这个结构体中。后面在发消息的时候会用到这个i2c_adapter

https://www.totalphase.com/support/articles/200349176-7-bit-8-bit-and-10-bit-I2C-Slave-Addressing

struct i2c_client {
	unsigned short flags;		//i2c的标志位  I2C_M_TEN
	unsigned short addr;		//从机地址
	char name[I2C_NAME_SIZE];  //设备的名
	struct i2c_adapter *adapter;//控制器的对象
};

i2c_msg结构体：i2c设备驱动和控制器驱动传输数据的时候是通过i2c_msg

结构体完成的。

//消息结构体
struct i2c_msg {
	__u16 addr;	    //从机地址
	__u16 flags;    //读写标志位 0 写  1读
	__u16 len;		//消息的长度
	__u8 *buf;		//消息的首地址
};

2.3封装数据发送数据的过程

2.3.1消息的封装过程

有多少起始位就有多少消息，消息的长度是以字节表示的。

写的消息：

start+(slave addr 7bit 0 1bit)+ack+reg+ack+data+ack+stop

(slave addr 7bit 0 1bit)+reg+data

char wbuf[] = {reg,data};
struct i2c_msg w_msg = {
    .addr = client->addr,
    .flags = 0,
    .len = 2,
    .buf = wbuf,
};

读的消息：

start+(slave addr 7bit 0 1bit)+ack+reg+ack+

start+(slave addr 7bit 1 1bit)+ack+data+NO ack+stop

char rbuf[] = {reg};
unsigned char val;
struct i2c_msg r_msg[] = {
    [0] = {
        .addr = client->addr,
        .flags = 0,
        .len = 1,
        .buf = rbuf,
    },
    [1] = {
        .addr = client->addr,
        .flags = 1,
        .len = 1,
        .buf = &val,
    },
};

2.3.2消息的发送过程

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
功能：发送消息
参数：
    @adap:控制器驱动对象的指针
	@msgs:消息的首地址
	@num:消息的个数
返回值：成功返回值等于num,否则就是失败

2.4读取si7006串号和固件号实例

在这里插入图片描述
si7006.h

#ifndef __SI7006_H__
#define __SI7006_H__

#define GET_SERIAL  _IOR('j',0,int)
#define GET_FIRWARE  _IOR('j',1,int)

#define SERIAL_ADDR 0xfcc9
#define FIRWARE_ADDR 0x84b8

#endif

si7006.c

#include "si7006.h"
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/device.h>

#define CNAME "si7006"
struct i2c_client* gclient;
int major;
const int count = 1;
struct class* cls;
struct device* dev;

int i2c_read_serial_firware(unsigned short reg)
{
    int ret;
    unsigned char val;
    char r_buf[] = { reg >> 8, reg & 0xff };
    // 1.封装消息结构体
    struct i2c_msg r_msg[] = {
        [0] = {
            .addr = gclient->addr,
            .flags = 0,
            .len = 2,
            .buf = r_buf,
        },
        [1] = {
            .addr = gclient->addr,
            .flags = 1,
            .len = 1,
            .buf = &val,
        },
    };

    // 2.发送消息
    ret = i2c_transfer(gclient->adapter, r_msg, ARRAY_SIZE(r_msg));
    if (ret != ARRAY_SIZE(r_msg)) {
        printk("i2c read error\n");
        return -EAGAIN;
    }

    return val;
}
int si7006_open(struct inode* inode, struct file* file)
{
    return 0;
}
long si7006_ioctl(struct file* filp,
    unsigned int cmd, unsigned long arg)
{
    int data, ret;
    switch (cmd) {
    case GET_SERIAL:
        data = i2c_read_serial_firware(SERIAL_ADDR);
        if (data < 0) {
            printk("i2c read serial error\n");
            return data;
        }
        ret = copy_to_user((void*)arg, &data, sizeof(int));
        if (ret) {
            printk("copy data serial to user error\n");
            return -EIO;
        }
        break;
    case GET_FIRWARE:
        data = i2c_read_serial_firware(FIRWARE_ADDR);
        if (data < 0) {
            printk("i2c read firware error\n");
            return data;
        }
        ret = copy_to_user((void*)arg, &data, sizeof(int));
        if (ret) {
            printk("copy data firware to user error\n");
            return -EIO;
        }
        break;
    }
    return 0;
}
int si7006_close(struct inode* inode, struct file* file)
{
    return 0;
}
static struct file_operations fops = {
    .open = si7006_open,
    .unlocked_ioctl = si7006_ioctl,
    .release = si7006_close,
};

int si7006_probe(struct i2c_client* client,
    const struct i2c_device_id* id)
{
    gclient = client;
    printk("%s:%d\n", __func__, __LINE__);

    // 1.注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register chrdev error\n");
        return -EAGAIN;
    }
    // 2.创建设备节点
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("class create error\n");
        return PTR_ERR(cls);
    }
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, CNAME);
    if (IS_ERR(dev)) {
        printk("device create error\n");
        return PTR_ERR(dev);
    }

    return 0;
}
int si7006_remove(struct i2c_client* client)
{
    printk("%s:%d\n", __func__, __LINE__);
    device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    unregister_chrdev(major, CNAME);
    return 0;
}

struct of_device_id oftable[] = {
    {
        .compatible = "hqyj,si7006",
    },
    {}
};
MODULE_DEVICE_TABLE(of, oftable);

struct i2c_driver si7006 = {
    .probe = si7006_probe,
    .remove = si7006_remove,
    .driver = {
        .name = "si7006123456",
        .of_match_table = oftable,
    }
};
module_i2c_driver(si7006);
MODULE_LICENSE("GPL");

test.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include "si7006.h"

int main(int argc, const char *argv[])
{
	int fd,serial,firware;
	if((fd = open("/dev/si7006",O_RDWR)) < 0){
		perror("open error");
		exit(EXIT_FAILURE);
	}

    ioctl(fd,GET_SERIAL,&serial);
    ioctl(fd,GET_FIRWARE,&firware);

    printf("serial = %#x,firware = %#x\n",serial,firware);
	close(fd);
	return 0;
}

2.5读取si7006温湿度实例

在这里插入图片描述
在这里插入图片描述

si7006.h

#ifndef __SI7006_H__
#define __SI7006_H__

#define GET_SERIAL  _IOR('j',0,int)
#define GET_FIRWARE  _IOR('j',1,int)
#define GET_TMP  _IOR('j',2,int)
#define GET_HUM  _IOR('j',3,int)
#define SERIAL_ADDR 0xfcc9
#define FIRWARE_ADDR 0x84b8
#define TMP_ADDR 0xe3
#define HUM_ADDR 0xe5
#endif

si7006.c

#include "si7006.h"
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/uaccess.h>

#define CNAME "si7006"
struct i2c_client* gclient;
int major;
const int count = 1;
struct class* cls;
struct device* dev;
int i2c_read_serial_firware(unsigned short reg)
{
    int ret;
    unsigned char val;
    char r_buf[] = { reg >> 8, reg & 0xff };
    // 1.封装消息结构体
    struct i2c_msg r_msg[] = {
        [0] = {
            .addr = gclient->addr,
            .flags = 0,
            .len = 2,
            .buf = r_buf,
        },
        [1] = {
            .addr = gclient->addr,
            .flags = 1,
            .len = 1,
            .buf = &val,
        },
    };

    // 2.发送消息
    ret = i2c_transfer(gclient->adapter, r_msg, ARRAY_SIZE(r_msg));
    if (ret != ARRAY_SIZE(r_msg)) {
        printk("i2c read error\n");
        return -EAGAIN;
    }

    return val;
}

int i2c_read_tmp_hum(unsigned char reg)
{
    int ret;
    unsigned short val;
    char r_buf[] = { reg };
    // 1.封装消息结构体
    struct i2c_msg r_msg[] = {
        [0] = {
            .addr = gclient->addr,
            .flags = 0,
            .len = 1,
            .buf = r_buf,
        },
        [1] = {
            .addr = gclient->addr,
            .flags = 1,
            .len = 2,
            .buf = (__u8*)&val,
        },
    };

    // 2.发送消息
    ret = i2c_transfer(gclient->adapter, r_msg, ARRAY_SIZE(r_msg));
    if (ret != ARRAY_SIZE(r_msg)) {
        printk("i2c read error\n");
        return -EAGAIN;
    }

    return (val >> 8 | val << 8);
}
int si7006_open(struct inode* inode, struct file* file)
{
    return 0;
}
long si7006_ioctl(struct file* filp,
    unsigned int cmd, unsigned long arg)
{
    int data, ret;
    switch (cmd) {
    case GET_SERIAL:
        data = i2c_read_serial_firware(SERIAL_ADDR);
        if (data < 0) {
            printk("i2c read serial error\n");
            return data;
        }
        ret = copy_to_user((void*)arg, &data, sizeof(int));
        if (ret) {
            printk("copy data serial to user error\n");
            return -EIO;
        }
        break;
    case GET_FIRWARE:
        data = i2c_read_serial_firware(FIRWARE_ADDR);
        if (data < 0) {
            printk("i2c read firware error\n");
            return data;
        }
        ret = copy_to_user((void*)arg, &data, sizeof(int));
        if (ret) {
            printk("copy data firware to user error\n");
            return -EIO;
        }
        break;
    case GET_TMP:
        data = i2c_read_tmp_hum(TMP_ADDR);
        if (data < 0) {
            printk("i2c read tmp error\n");
            return data;
        }
        data &= 0xffff;
        ret = copy_to_user((void*)arg, &data, sizeof(int));
        if (ret) {
            printk("copy data tmp to user error\n");
            return -EIO;
        }
        break;
    case GET_HUM:
        data = i2c_read_tmp_hum(HUM_ADDR);
        if (data < 0) {
            printk("i2c read hum error\n");
            return data;
        }
        data &= 0xffff;
        ret = copy_to_user((void*)arg, &data, sizeof(int));
        if (ret) {
            printk("copy data hum to user error\n");
            return -EIO;
        }
        break;
    }
    return 0;
}
int si7006_close(struct inode* inode, struct file* file)
{
    return 0;
}

static struct file_operations fops = {
    .open = si7006_open,
    .unlocked_ioctl = si7006_ioctl,
    .release = si7006_close,
};

int si7006_probe(struct i2c_client* client,
    const struct i2c_device_id* id)
{
    gclient = client;
    printk("%s:%d\n", __func__, __LINE__);

    // 1.注册字符设备驱动
    major = register_chrdev(0, CNAME, &fops);
    if (major < 0) {
        printk("register chrdev error\n");
        return -EAGAIN;
    }
    // 2.创建设备节点
    cls = class_create(THIS_MODULE, CNAME);
    if (IS_ERR(cls)) {
        printk("class create error\n");
        return PTR_ERR(cls);
    }
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, CNAME);
    if (IS_ERR(dev)) {
        printk("device create error\n");
        return PTR_ERR(dev);
    }

    return 0;
}
int si7006_remove(struct i2c_client* client)
{
    printk("%s:%d\n", __func__, __LINE__);
    device_destroy(cls, MKDEV(major, 0));
    class_destroy(cls);
    unregister_chrdev(major, CNAME);
    return 0;
}

struct of_device_id oftable[] = {
    {
        .compatible = "hqyj,si7006",
    },
    {}
};
MODULE_DEVICE_TABLE(of, oftable);

struct i2c_driver si7006 = {
    .probe = si7006_probe,
    .remove = si7006_remove,
    .driver = {
        .name = "si7006123456",
        .of_match_table = oftable,
    }
};
module_i2c_driver(si7006);
MODULE_LICENSE("GPL");

test.c

#include "si7006.h"
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, const char* argv[])
{
    int fd, serial, firware, tmpcode, humcode;
    float tmp, hum;
    if ((fd = open("/dev/si7006", O_RDWR)) < 0) {
        perror("open error");
        exit(EXIT_FAILURE);
    }

    ioctl(fd, GET_SERIAL, &serial);
    ioctl(fd, GET_FIRWARE, &firware);

    printf("serial = %#x,firware = %#x\n", serial, firware);
    while (1) {
        ioctl(fd, GET_TMP, &tmpcode);
        ioctl(fd, GET_HUM, &humcode);

        hum = 125.0 * humcode / 65536 - 6;
        tmp = 175.72 * tmpcode / 65536 - 46.85;

        printf("tmp=%.2f,hum=%.2f\n",tmp,hum);
        sleep(1);
    }
    close(fd);
    return 0;
}
niuiniuiniu
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Linux驱动学习—I2C总线
suifen_的博客
01-14 1452
I2C是很常见的一种总线协议，I2C是NXP公司设计的，I2C使用两条线在主控制器和从机之间进行数据通信。一条是SCL（串行时钟线），另外一条是SDA(串行数据线)，因为I2C这两条数据线是开漏输出的，所以需要接上拉电阻，总线空闲的时候SCL和SDA处于高电平。I2C总线标准模式下速度可以达到100Kb/s,快速模式下可以达到400kb/s。
正点原子linux阿尔法开发板使用——IIC驱动_原子系统开启i2c
2401_83817971的博客
05-15 334
i2c_driver 类似 platform_driver，编写IIC设备驱动重点要处理的内容。* 当 I2C 设备和驱动匹配成功以后 probe 函数就会执行，和 platform 驱动一样。owner：一般为 THIS_MODULE。driver：要注册的 i2c_driver。注销IIC设备。
Linux之I2C驱动
风间琉璃的博客
09-28 4600
在 Linux 内核中 I2C 的体系结构分为 3 个部分：①： I2C 核心提供了I2C 总线驱动和设备驱动的注册、 注销方法②： I2C 总线驱动是对I2C 硬件体系结构中适配器端的实现， 适配器可由CPU 控制， 甚至可以直接集成在 CPU 内部。I2C 总线驱动就是 SOC 的，也叫做。③： I2C 设备驱动是对，设备一般挂接在受 CPU 控制的 I2C 适配器上， 通过 I2C 适配器与 CPU 交换数据。
linux系统下操作I2C总线外设（imx6ull的oled显示屏i2c驱动笔记）
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
04-24 1482
在硬件层中，I2C硬件总线只有两条线路，上面可以挂载多个I2C-device，这些I2C-device有的在I2C总线里充当主机的角色，一般情况该主机为板子上的主cpu中的I2C控制器，拿imx6ul板子来说，这个I2C主机就是imx6中的I2C控制器模块。
linux之I2C驱动分析
cqxcool66的博客
04-28 1309
实际上有两部分驱动并且是分层的。 I2C主机驱动。 2C设备驱动。 对于I2C主机驱动，一旦编写完成就不需要再做修改，其他的I2C设备直接调用主机驱动提供的API函数完成读写操作即可。这个正好符合Linux的驱动分离与分层的思想，因此Linux内核也将I2C驱动分为两部分： I2C总线驱动，I2C总线驱动就是SOC的I2C控制器驱动，也叫做I2C适配器驱动。 I2C设备驱动，I2C设备驱动就是针对具体的I2C设备而编写的驱动。 整体驱动构架理解： 方式概述：实际上有两个步骤： client(bor
Linux I2C总线设备驱动
JJ1116的博客
05-11 1834
1、I2C总线硬件介绍 I2C总线
Linux 驱动之 I2C
王小波的猪的博客
12-24 1404
目录 1、I2C 协议简介 2、Linux I2C 驱动框架简介 2.1、I2C 总线驱动 2.2、I2C 设备驱动 2.2.1、i2c_client 结构体 2.2.2、i2c_driver 结构体 2.3、I2C 设备与驱动匹配过程 3、I.MX6U 的 I2C 控制器驱动分析 4、I2C 设备驱动编写 1、I2C 协议简介 I2C 是由 NXP 公司设计的总线协议，用两根线进行通信，一根串行时钟线（SCL），一根串行数据线（SDA）。一个 I2C ...
linux驱动之I2C
qq_39048131的博客
09-14 1831
struct i2c_driver struct i2c_client i2c_master_send i2c_master_recv i2c_transfer linux I2c应用层驱动
linux i2c速度设置,I2C子系统之I2C总线时钟频率设置
weixin_31241561的博客
05-15 1372
可以发现此处已经将clk_p.rate修改为pclk了，默认值为0。调用函数s3c2410_baseclk_add()注册外设时钟的过程和注册总线时钟的过程类似，也是将各个定义好的外设时钟如：structclkinit_clocks_off[]={{......}，{.name="i2c",.id=-1,.parent=&clk_p,.enab...
Linux内核的I2C驱动框架详解
cumtchw
07-31 4874
目录1 I2C驱动整体框架图 2 I2C控制器2.1 I2C控制器设备--I2C控制器在内核中也被看做一个设备2.2 i2c控制器驱动程序2.3 platform_driver结构体中的probe函数做了什么2.3.1 疑问： i2cdev_notifier_call函数哪里来的2.3.2 疑问：为什么有两个probe2.3.3 疑问：of_i2c_register_devices(adap);和bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_n
IIS.rar_Linux i2c总线
09-21
在嵌入式Linux系统中，I2C（Inter-Integrated Circuit）总线是一种常见的通信协议，用于连接微控制器和其他低速外围设备。I2C总线由飞利浦（现NXP Semiconductors）在1980年代开发，其设计目标是减少电路板上的引脚...
i2c.rar_Linux i2c总线
09-24
Linux i2c总线是操作系统内核中用于与支持I²C协议的设备通信的接口。I²C（Inter-Integrated Circuit）是一种多主控、两线制的串行通信协议，由飞利浦（现NXP）公司开发，常用于微控制器与外围设备之间的通信。在...
linux c i2c总线 通信 源代码
03-01
Linux下的I2C总线通信是嵌入式系统和物联网设备中常见的通信方式，它主要用于连接微控制器和其他低速外设，如传感器、时钟、显示驱动等。在这个主题中，我们将深入探讨Linux C语言实现的I2C通信源代码。 I2C（Inter...
Linux - i2c.zip
06-18
5. **I2C设备探测**：Linux内核支持自动探测I2C总线上的设备，这可以通过`i2c_probe()`函数实现。探测过程中，内核会尝试匹配设备ID，以确定哪个设备驱动应该被加载。 6. **I2C事务处理**：I2C通信通常涉及多个...
linux I2C Bus.pdf
07-31
Linux I2C总线是一种基于两线制的串行通信协议，主要应用于嵌入式系统中，连接微控制器和其他外围设备。在这个系统中，SDA（数据线）和SCL（时钟线）是核心的通信线路。当SDA和SCL同时处于高电平，即1状态时，I2C...
Linux：Linux发展史
weixin_51142926的博客
07-22 4312
大家好！此篇文章并非技术博文，而是简单了解Linux的时代背景和发展史，只有知其所以然才能让我们更好地让走进Liunx的世界！
linux代填密码切换用户
zixuanyankai的博客
07-22 321
linux用户账户密码复杂，在不考虑安全的情况下，想要使用命令自动切换用户。
RV1126 Linux 系统，接外设，时好时坏（一）应该从哪些方面排查问题
最新发布
小灰灰的博客
07-25 106
在 Linux 系统中排查外设连接问题时，需要从硬件、软件、时序和协议等多个方面进行全面分析。逐步排查并记录每一步的测试结果，有助于快速定位问题的根源。解决 “时好时坏”的问题可能需要综合考虑多个因素，耐心细致的排查将会提高找到解决方案的效率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值