i2c驱动设备的应用

已于 2022-05-11 17:30:11 修改
阅读量1k 收藏
点赞数 3
文章标签： ubuntu linux
于 2022-04-26 14:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51482074/article/details/124408568
版权

i2c驱动设备的应用

  • I2C总线原理

I2C即Inter IC，由Philips公司开发，是当今电子设计中应用非常广泛的串行总线之一，主要用于电压、温度监控，EEPROM(电可擦可编程只读存储器)数据的读写，光模块的管理等。I2C总线只有两根线，SCL和SDA，SCL即Serial Clock，串行时钟，SDA即Serial Data，串行数据。

  • I2C总线的速率

标准模式下：100Kbps
快速模式下：400Kbps
高速模式下：3.4Mbps

  • I2C总线结构如下图所示：
    在这里插入图片描述

1.阅读理解源代码

查看源代码

进行修改，重构，远程调试等

$ vim 24cXX.c
$ vim eeprog.c
  • 24cXX.h源代码
/***************************************************************************
    copyright            : (C) by 2003-2004 Stefano Barbato
    email                : stefano@codesink.org

    $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef _24CXX_H_
#define _24CXX_H_
#include <linux/i2c-dev.h>
#include <linux/i2c.h>

#define EEPROM_TYPE_UNKNOWN 0
#define EEPROM_TYPE_8BIT_ADDR   1
#define EEPROM_TYPE_16BIT_ADDR  2

struct eeprom
&#123;
    char *dev;  // device file i.e. /dev/i2c-N
    int addr;   // i2c address
    int fd;     // file descriptor
    int type;   // eeprom type
&#125;;

/*
 * opens the eeprom device at [dev_fqn] (i.e. /dev/i2c-N) whose address is
 * [addr] and set the eeprom_24c32 [e]
 */
int eeprom_open(char *dev_fqn, int addr, int type, struct eeprom*);
/*
 * closees the eeprom device [e] 
 */
int eeprom_close(struct eeprom *p_device_struct);
/*
 * read and returns the eeprom byte at memory address [mem_addr] 
 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 
 */
int eeprom_read_byte(struct eeprom* p_device_struct, __u16 mem_addr);
/*
 * read the current byte
 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 
 */
int eeprom_read_current_byte(struct eeprom *p_device_struct);
/*
 * writes [data] at memory address [mem_addr] 
 * Note: eeprom must have been selected by ioctl(fd,I2C_SLAVE,address) 
 */
int eeprom_write_byte(struct eeprom *p_device_struct, __u16 mem_addr, __u8 data);

#endif
  • 24cXX.c源代码
/***************************************************************************
    copyright            : (C) by 2003-2004 Stefano Barbato
    email                : stefano@codesink.org

    $Id: 24cXX.h,v 1.6 2004/02/29 11:05:28 tat Exp $

 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <linux/fs.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <assert.h>
#include <string.h>
#include "24cXX.h"


static inline __s32 i2c_smbus_access(int file, char read_write, __u8 command,
    int size, union i2c_smbus_data* data)
&#123;
    struct i2c_smbus_ioctl_data args;

    args.read_write = read_write;
    args.command = command;
    args.size = size;
    args.data = data;
    return ioctl(file, I2C_SMBUS, &args);
&#125;


static inline __s32 i2c_smbus_write_quick(int file, __u8 value)
&#123;
    return i2c_smbus_access(file, value, 0, I2C_SMBUS_QUICK, NULL);
&#125;

static inline __s32 i2c_smbus_read_byte(int file)
&#123;
    union i2c_smbus_data data;
    if (i2c_smbus_access(file, I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data))
        return -1;
    else
        return 0x0FF & data.byte;
&#125;

static inline __s32 i2c_smbus_write_byte(int file, __u8 value)
&#123;
    return i2c_smbus_access(file, I2C_SMBUS_WRITE, value,
        I2C_SMBUS_BYTE, NULL);
&#125;

static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)
&#123;
    union i2c_smbus_data data;
    if (i2c_smbus_access(file, I2C_SMBUS_READ, command,
        I2C_SMBUS_BYTE_DATA, &data))
        return -1;
    else
        return 0x0FF & data.byte;
&#125;

static inline __s32 i2c_smbus_write_byte_data(int file, __u8 command,
    __u8 value)
&#123;
    union i2c_smbus_data data;
    data.byte = value;
    return i2c_smbus_access(file, I2C_SMBUS_WRITE, command,
        I2C_SMBUS_BYTE_DATA, &data);
&#125;

static inline __s32 i2c_smbus_read_word_data(int file, __u8 command)
&#123;
    union i2c_smbus_data data;
    if (i2c_smbus_access(file, I2C_SMBUS_READ, command,
        I2C_SMBUS_WORD_DATA, &data))
        return -1;
    else
        return 0x0FFFF & data.word;
&#125;

static inline __s32 i2c_smbus_write_word_data(int file, __u8 command,
    __u16 value)
&#123;
    union i2c_smbus_data data;
    data.word = value;
    return i2c_smbus_access(file, I2C_SMBUS_WRITE, command,
        I2C_SMBUS_WORD_DATA, &data);
&#125;

static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value)
&#123;
    union i2c_smbus_data data;
    data.word = value;
    if (i2c_smbus_access(file, I2C_SMBUS_WRITE, command,
        I2C_SMBUS_PROC_CALL, &data))
        return -1;
    else
        return 0x0FFFF & data.word;
&#125;


/* Returns the number of read bytes */
static inline __s32 i2c_smbus_read_block_data(int file, __u8 command,
    __u8* values)
&#123;
    union i2c_smbus_data data;
    int i;
    if (i2c_smbus_access(file, I2C_SMBUS_READ, command,
        I2C_SMBUS_BLOCK_DATA, &data))
        return -1;
    else &#123;
        for (i = 1; i <= data.block[0]; i++)
            values[i - 1] = data.block[i];
        return data.block[0];
    &#125;
&#125;

static inline __s32 i2c_smbus_write_block_data(int file, __u8 command,
    __u8 length, __u8* values)
&#123;
    union i2c_smbus_data data;
    int i;
    if (length > 32)
        length = 32;
    for (i = 1; i <= length; i++)
        data.block[i] = values[i - 1];
    data.block[0] = length;
    return i2c_smbus_access(file, I2C_SMBUS_WRITE, command,
        I2C_SMBUS_BLOCK_DATA, &data);
&#125;

/* Returns the number of read bytes */
static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command,
    __u8* values)
&#123;
    union i2c_smbus_data data;
    int i;
    if (i2c_smbus_access(file, I2C_SMBUS_READ, command,
        I2C_SMBUS_I2C_BLOCK_DATA, &data))
        return -1;
    else &#123;
        for (i = 1; i <= data.block[0]; i++)
            values[i - 1] = data.block[i];
        return data.block[0];
    &#125;
&#125;

static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command,
    __u8 length, __u8* values)
&#123;
    union i2c_smbus_data data;
    int i;
    if (length > 32)
        length = 32;
    for (i = 1; i <= length; i++)
        data.block[i] = values[i - 1];
    data.block[0] = length;
    return i2c_smbus_access(file, I2C_SMBUS_WRITE, command,
        I2C_SMBUS_I2C_BLOCK_DATA, &data);
&#125;

/* Returns the number of read bytes */
static inline __s32 i2c_smbus_block_process_call(int file, __u8 command,
    __u8 length, __u8* values)
&#123;
    union i2c_smbus_data data;
    int i;
    if (length > 32)
        length = 32;
    for (i = 1; i <= length; i++)
        data.block[i] = values[i - 1];
    data.block[0] = length;
    if (i2c_smbus_access(file, I2C_SMBUS_WRITE, command,
        I2C_SMBUS_BLOCK_PROC_CALL, &data))
        return -1;
    else &#123;
        for (i = 1; i <= data.block[0]; i++)
            values[i - 1] = data.block[i];
        return data.block[0];
    &#125;
&#125;

static int i2c_write_1b(struct eeprom* p_device_struct, __u8 buf)
&#123;
    int byte;
    // we must simulate a plain I2C byte write with SMBus functions
    byte = i2c_smbus_write_byte(p_device_struct->fd, buf);
    if (byte < 0)
        fprintf(stderr, "Error i2c_write_1b: %s\n", strerror(errno));
    usleep(10);
    return byte;
&#125;

static int i2c_write_2b(struct eeprom* p_device_struct, __u8 buf[2])
&#123;
    int byte;
    // we must simulate a plain I2C byte write with SMBus functions
    byte = i2c_smbus_write_byte_data(p_device_struct->fd, buf[0], buf[1]);
    if (byte < 0)
        fprintf(stderr, "Error i2c_write_2b: %s\n", strerror(errno));
    usleep(10);
    return byte;
&#125;

static int i2c_write_3b(struct eeprom* p_device_struct, __u8 buf[3])
&#123;
    int byte;
    // we must simulate a plain I2C byte write with SMBus functions
    // the __u16 data field will be byte swapped by the SMBus protocol
    byte = i2c_smbus_write_word_data(p_device_struct->fd, buf[0], buf[2] << 8 | buf[1]);
    if (byte < 0)
        fprintf(stderr, "Error i2c_write_3b: %s\n", strerror(errno));
    usleep(10);
    return byte;
&#125;


#define CHECK_I2C_FUNC( var, label ) \
    do &#123;    if(0 == (var & label)) &#123; \
        fprintf(stderr, "\nError: " \
            #label " function is required. Program halted.\n\n"); \
        exit(1); &#125; \
    &#125; while(0);

int eeprom_open(char* dev_fqn, int addr, int type, struct eeprom* p_device_struct)
&#123;
    int funcs, fd, byte;
    p_device_struct->fd = p_device_struct->addr = 0;
    p_device_struct->dev = 0;

    fd = open(dev_fqn, O_RDWR);
    if (fd <= 0)
    &#123;
        fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
        return -1;
    &#125;

    // get funcs list
    if ((byte = ioctl(fd, I2C_FUNCS, &funcs) < 0))
    &#123;
        fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
        return -1;
    &#125;


    // check for req funcs
    CHECK_I2C_FUNC(funcs, I2C_FUNC_SMBUS_READ_BYTE);
    CHECK_I2C_FUNC(funcs, I2C_FUNC_SMBUS_WRITE_BYTE);
    CHECK_I2C_FUNC(funcs, I2C_FUNC_SMBUS_READ_BYTE_DATA);
    CHECK_I2C_FUNC(funcs, I2C_FUNC_SMBUS_WRITE_BYTE_DATA);
    CHECK_I2C_FUNC(funcs, I2C_FUNC_SMBUS_READ_WORD_DATA);
    CHECK_I2C_FUNC(funcs, I2C_FUNC_SMBUS_WRITE_WORD_DATA);

    // set working device
    if ((byte = ioctl(fd, I2C_SLAVE, addr)) < 0)
    &#123;
        fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
        return -1;
    &#125;
    p_device_struct->fd = fd;
    p_device_struct->addr = addr;
    p_device_struct->dev = dev_fqn;
    p_device_struct->type = type;
    return 0;
&#125;

int eeprom_close(struct eeprom* p_device_struct)
&#123;
    close(p_device_struct->fd);
    p_device_struct->fd = -1;
    p_device_struct->dev = 0;
    p_device_struct->type = EEPROM_TYPE_UNKNOWN;
    return 0;
&#125;

#if 0
int eeprom_24c32_write_byte(struct eeprom* p_device_struct, __u16 mem_addr, __u8 data)
&#123;
    __u8 buf[3] = &#123; (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data &#125;;
    return i2c_write_3b(p_device_struct, buf);
&#125;


int eeprom_24c32_read_current_byte(struct eeprom* p_device_struct)
&#123;
    ioctl(p_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
    return i2c_smbus_read_byte(p_device_struct->fd);
&#125;

int eeprom_24c32_read_byte(struct eeprom* p_device_struct, __u16 mem_addr)
&#123;
    int byte;
    ioctl(p_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
    __u8 buf[2] = &#123; (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff &#125;;
    byte = i2c_write_2b(p_device_struct, buf);
    if (byte < 0)
        return byte;
    byte = i2c_smbus_read_byte(p_device_struct->fd);
    return byte;
&#125;
#endif


int eeprom_read_current_byte(struct eeprom* p_device_struct)
&#123;
    ioctl(p_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
    return i2c_smbus_read_byte(p_device_struct->fd);
&#125;

int eeprom_read_byte(struct eeprom* p_device_struct, __u16 mem_addr)
&#123;
    int byte;
    ioctl(p_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
    if (p_device_struct->type == EEPROM_TYPE_8BIT_ADDR)
    &#123;
        __u8 buf = mem_addr & 0x0ff;
        byte = i2c_write_1b(p_device_struct, buf);
    &#125;
    else if (p_device_struct->type == EEPROM_TYPE_16BIT_ADDR) &#123;
        __u8 buf[2] = &#123; (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff &#125;;
        byte = i2c_write_2b(p_device_struct, buf);
    &#125;
    else &#123;
        fprintf(stderr, "ERR: unknown eeprom type\n");
        return -1;
    &#125;
    if (byte < 0)
        return byte;
    byte = i2c_smbus_read_byte(p_device_struct->fd);
    return byte;
&#125;

int eeprom_write_byte(struct eeprom* p_device_struct, __u16 mem_addr, __u8 data)
&#123;
    if (p_device_struct->type == EEPROM_TYPE_8BIT_ADDR) &#123;
        __u8 buf[2] = &#123; mem_addr & 0x00ff, data &#125;;
        return i2c_write_2b(p_device_struct, buf);
    &#125;
    else if (p_device_struct->type == EEPROM_TYPE_16BIT_ADDR) &#123;
        __u8 buf[3] =
        &#123; (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data &#125;;
        return i2c_write_3b(p_device_struct, buf);
    &#125;
    fprintf(stderr, "ERR: unknown eeprom type\n");
    return -1;
&#125;
  • eeprog.c源代码文件
/***************************************************************************
    copyright            : (C) by 2009 Guangzhou FriendlyaRM, in China
    email                : capbily@163.com
    website              : arm9.net
 ***************************************************************************/

#include <stdio.h>
#include <fcntl.h>
#include <getopt.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "24cXX.h"

#define DEVICE_FILE_STRING "/dev/i2c-0"
#define DEVICE_ADDRESS 0x50

#define usage_if(flag) do &#123; do_usage_if( flag , __LINE__); &#125; while(0);
void do_usage_if(int error_code, int line) &#123;
    const static char* eeprog_usage =
        "I2C-24C08(256 bytes) Read/Write Program, ONLY FOR TEST!\n"
        "FriendlyARM Computer Tech. 2009\n";
    if (!error_code)
        return;
    fprintf(stderr, "%s\n[line %d]\n", eeprog_usage, line);
    exit(1);
&#125;


#define die_if(flag, msg) do &#123; do_die_if( flag , msg, __LINE__); &#125; while(0);
void do_die_if(int error_code, char* msg, int line) &#123;
    if (!error_code)
        return;
    fprintf(stderr, "Error at line %d: %s\n", line, msg);
    fprintf(stderr, "   sysmsg: %s\n", strerror(errno));
    exit(1);
&#125;


static int read_from_eeprom(struct eeprom* e, int addr, int size) &#123;
    int ch, i;
    for (i = 0; i < size; ++i, ++addr) &#123;
        die_if((ch = eeprom_read_byte(e, addr)) < 0, "read error");
        if ((i % 16) == 0)
            printf("\n %.4x|  ", addr);
        else if ((i % 8) == 0)
            printf("  ");
        printf("%.2x ", ch);
        fflush(stdout);
    &#125;
    fprintf(stderr, "\n\n");
    return 0;
&#125;

static int write_to_eeprom(struct eeprom* e, int addr) &#123;
    int i;
    for (i = 0, addr = 0; i < 256; i++, addr++) &#123;
        if ((i % 16) == 0)
            printf("\n %.4x|  ", addr);
        else if ((i % 8) == 0)
            printf("  ");
        printf("%.2x ", i);
        fflush(stdout);
        die_if(eeprom_write_byte(e, addr, i), "write error");
    &#125;
    fprintf(stderr, "\n\n");
    return 0;
&#125;

int main(int argc, char** argv) &#123;
    struct eeprom e;
    int op;

    op = 0;

    usage_if(argc != 2 || argv[1][0] != '-' || argv[1][2] != '\0');
    op = argv[1][1];

    //TODO: 将数字改为自己的学号。
    write(STDOUT_FILENO, "APP for 201930310071 ...\n", strlen("APP for 201930310071 ...\n"));
    fprintf(stderr, "Open %s with 8bit mode\n", DEVICE_FILE_STRING);
    die_if(eeprom_open(DEVICE_FILE_STRING, DEVICE_ADDRESS, EEPROM_TYPE_8BIT_ADDR, &e) < 0,
        "unable to open eeprom device file "
        "(check that the file exists and that it's readable)");
    switch (op) &#123;
    case 'r':
        fprintf(stderr, "  Reading 256 bytes from 0x0\n");
        read_from_eeprom(&e, 0, 256);
        break;
    case 'w':
        fprintf(stderr, "  Writing 0x00-0xff into 24C08 \n");
        write_to_eeprom(&e, 0);
        break;
    default:
        usage_if(1);
        exit(1);
    &#125;
    eeprom_close(&e);

    return 0;
&#125;

2.编译应用程序

(1)使用Makefile文件直接编译

  • Makefile文件
vim Makefile

#C=gcc
C=$&#123;CROSS_COMPILE&#125;gcc
CFLAGS= -Wall -O2
OUTS=i2c
O_OUTS=eeprog.o 24cXX.o

i2c: $&#123;O_OUTS&#125;
 $(C) $(CFLAGS) -o $@ $^

%.o: %.c
 $(C) -c -o $@ $^

clean:
 @rm -vf *.o *~ $&#123;OUTS&#125;
  • 编译
make
arm-linux-gnueabihf-gcc -c -o eeprog.o eeprog.c
arm-linux-gnueabihf-gcc -c -o 24cXX.o 24cXX.c
arm-linux-gnueabihf-gcc -Wall -O2 -o i2c eeprog.o 24cXX.o

(2)使用NFS mount开发板主机

[root@ubuntu-qemu root]#
[/mnt/yaffs] mount -t nfs -o nolock 192.168.253.128:/nfs  /mnt/nfs
[/mnt/yaffs]cd /mnt/nfs/i2c 
[/mnt/nfs/i2c /]./i2c –w
Open /dev/i2c/0 with 8bit mode
Writing 0x00-0xff into ...

0000|  00 01 02 03 04 05 06 07    08 09 0a 0b 0c 0d 0e 0f
0010|  10 11 12 13 14 15 16 17    18 19 1a 1b 1c 1d 1e 1f
0020|  20 21 22 23 24 25 26 27    28 29 2a 2b 2c 2d 2e 2f
0030|  30 31 32 33 34 35 36 37    38 39 3a 3b 3c 3d 3e 3f
0040|  40 41 42 43 44 45 46 47    48 49 4a 4b 4c 4d 4e 4f
0050|  50 51 52 53 54 55 56 57    58 59 5a 5b 5c 5d 5e 5f
0060|  60 61 62 63 64 65 66 67    68 69 6a 6b 6c 6d 6e 6f
0070|  70 71 72 73 74 75 76 77    78 79 7a 7b 7c 7d 7e 7f
0080|  80 81 82 83 84 85 86 87    88 89 8a 8b 8c 8d 8e 8f
0090|  90 91 92 93 94 95 96 97    98 99 9a 9b 9c 9d 9e 9f
00a0|  a0 a1 a2 a3 a4 a5 a6 a7    a8 a9 aa ab ac ad ae af
00b0|  b0 b1 b2 b3 b4 b5 b6 b7    b8 b9 ba bb bc bd be bf
00c0|  c0 c1 c2 c3 c4 c5 c6 c7    c8 c9 ca cb cc cd ce cf
00d0|  d0 d1 d2 d3 d4 d5 d6 d7    d8 d9 da db dc dd de df
00e0|  e0 e1 e2 e3 e4 e5 e6 e7    e8 e9 ea eb ec ed ee ef
00f0|  f0 f1 f2 f3 f4 f5 f6 f7    f8 f9 fa fb fc fd fe ff


[/mnt/nfs/i2c /]./i2c –r
Open /dev/i2c/0 with 8bit mode
Reading 256 bytes from 0x00

0000|  00 01 02 03 04 05 06 07    08 09 0a 0b 0c 0d 0e 0f
0010|  10 11 12 13 14 15 16 17    18 19 1a 1b 1c 1d 1e 1f
0020|  20 21 22 23 24 25 26 27    28 29 2a 2b 2c 2d 2e 2f
0030|  30 31 32 33 34 35 36 37    38 39 3a 3b 3c 3d 3e 3f
0040|  40 41 42 43 44 45 46 47    48 49 4a 4b 4c 4d 4e 4f
0050|  50 51 52 53 54 55 56 57    58 59 5a 5b 5c 5d 5e 5f
0060|  60 61 62 63 64 65 66 67    68 69 6a 6b 6c 6d 6e 6f
0070|  70 71 72 73 74 75 76 77    78 79 7a 7b 7c 7d 7e 7f
0080|  80 81 82 83 84 85 86 87    88 89 8a 8b 8c 8d 8e 8f
0090|  90 91 92 93 94 95 96 97    98 99 9a 9b 9c 9d 9e 9f
00a0|  a0 a1 a2 a3 a4 a5 a6 a7    a8 a9 aa ab ac ad ae af
00b0|  b0 b1 b2 b3 b4 b5 b6 b7    b8 b9 ba bb bc bd be bf
00c0|  c0 c1 c2 c3 c4 c5 c6 c7    c8 c9 ca cb cc cd ce cf
00d0|  d0 d1 d2 d3 d4 d5 d6 d7    d8 d9 da db dc dd de df
00e0|  e0 e1 e2 e3 e4 e5 e6 e7    e8 e9 ea eb ec ed ee ef
00f0|  f0 f1 f2 f3 f4 f5 f6 f7    f8 f9 fa fb fc fd fe ff

3.思考题

(1)I2C总线的优点是什么？

1、I2C总线只需要一根数据线和一根时钟线两根线，总线接口已
经集成在芯片内部，优化主板空间和成本。
2、无论总线上有多少设备，都只使用两条线，保持低引脚/信号
数。
3、真正的支持多主机设备，但是同一时刻只允许一台主机。
4、I2C总线具有低功耗、抗干扰强的优点，传输距离长的特点。
5、连接到相同总线的IC 数量只受到总线的最大电容400pF 限
制。
6、串行的8 位双向数据传输位速率在标准模式下可达
100kbit/s，快速模式下可达400kbit/s，高速模式下可达3.4Mbit/s。

(2)I2C总线的启动信号和结束信号有什么特点。

启动信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。
结束信号：SCL为高电平时，SDA由低电平向高电平跳变，结束传送数据。

Hleang
关注
I2C总线原理及应用实例
ncdawen的专栏
03-22 2604
I2C(Inter－Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，最初为音频和视频设备开发，如今主要在服务器管理中使用，其中包括单个组件状态的通信。例如管理员可对各个组件进行查询，以管理系统的配置或掌握组件的功能状态，如电源和系统风扇。可随时监控内存、硬盘、网络、系统温度等多个参数，增加了系统的
I2C驱动
wql_c_c的博客
08-27 429
1、 I2C总线驱动 1、 dtsi配置：msm8937.dtsi i2c_3: i2c@78b7000 { /* BLSP1 QUP3 */ compatible = “qcom,i2c-msm-v2”; 2、 驱动文件：i2c-msm-v2.c 1） 总线驱动本身是个platform设备 2） 调用I2C核心层的API，注册一个adapter i2c_msm_probe–>i2c_msm...
Zynq-Linux移植学习笔记之46-光模块I2C驱动移植
无知的我
11-11 6711
1、背景介绍 近期板卡上开始使用中航光电的光模块，查阅资料发现这些光模块都可以通过I2C来获取状态信息并进行开关控制，描述如下，其中需要特别注意的是所有光模块的读写I2C地址都是一样的，不可以挂在一根总线上，要么分别单独控制，要么通过交换芯片切换控制。 为了实现这一点，可以考虑通过zynq的I2C控制器来对光模块进行操作。由于ZYNQ PS部分的I2C控制器只有两个，当光模块数量超过2个时使用PL部分的I2C IP核来实现较为简单。 2.硬件参考设计 这...
学会IIC的原理及应用,这一篇文章就够了
最新发布
Alex_LyCmk的博客
07-26 1092
IIC（Inter-Integrated Circuit）是 IIC Bus 简称，中文叫集成电路总线。它是一种串行通信总线，使用多主从架构，由飞利浦公司在1980年代为了让主板、嵌入式系统或手机用以连接低速周边设备而发展。自2006年10月1日起，使用I²C协议已经不需要支付专利费，但制造商仍然需要付费以获取I²C从属设备地址。IIC使用两根信号线进行通信：一根。
I2C应用
hellohellohhw的博客
04-28 1755
I2C简介 I2C(Inter－Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，最初为音频和视频设备开发，如今主要在服务器管理中使用，其中包括单个组件状态的通信。例如管理员可对各个组件进行查询，以管理系统的配置或掌握组件的功能状态，如电源和系统风扇。可随时监控内存、硬盘、网络、系统温度等多个参数，增加了系统的安全性，方便了管理。 I2C工作原理 I2C总线是由数据线SDA和时钟SCL构成...
I2C应用实例
acktomas的博客
03-02 3912
topicI²C实用教学：基于Arduino Micro的温度传感器导语I²C介绍I²C和Arduino温度传感器DS1621管脚连接Arduino与DS1621通讯发送数据读取数据 I²C实用教学：基于Arduino Micro的温度传感器 http://haipeng.me/2017/10/31/thermostat_with_arduino_micro_via_i2c/ 导语 I²C，即In...
I2C技术及应用
tianjinzhangli的专栏
04-18 854
I2C总线原理与应用      2010年1月27日 14:27  21ic  一.简介I2C(Inter－Integrated Circuit)总线是一种由Philips公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C总线产生于在80年代，
I2C 原理及应用
u013177084的专栏
09-12 3712
I2C 原理及应用(下) 6. S5PC100下的I2C控制器介绍 S5PC100处理器支持多主机I2C串行总线接口，并且它支持主机发送模式、主机接收模式、从机发送模式和从机接收模式4种模式，图4所示为I2C总线的概括图。 图4 I2C总线的概括图 7. I2C总线控制寄存器详解 表1为I2C总线控制寄存器描述。 表1        I2C总线控制寄存器 I2CCON
linux i2c设备驱动
paomadi的专栏
12-22 3371
一. i2c的结构体      1. i2c适配器 struct i2c_adapter { struct module *owner; //模块所有者 unsigned int id __deprecated; unsigned int class; //支持的类别(I2C_CLASS_HWMON,I2C_CLASS_DDC,I2C_CLASS_SPD) const stru
Linux下I2C设备驱动开发和实现
11-19
本文描述了Linux下I2C驱动的结构，并在此基础上给出了I2C设备驱动和应用的实现。 　1 引言 　I2C (INTER－Integrated CIRCUIT)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C...
I2C_I2C驱动源码_
10-02
了解并掌握I2C驱动的编写不仅可以帮助你更好地利用各种I2C设备，如EEPROM、传感器、显示模块等，还能加深对微控制器通信协议的理解，提升嵌入式系统设计能力。在实际项目中，正确配置和优化I2C驱动，能够有效地减少...
STM32系列I2C应用总结
06-04
STM32的I2C模块，有些坑要绕过去，这是一总结的文档。
Linux I2C设备驱动案例
11-12
9. **设备探测与绑定**：I2C驱动在启动时会扫描总线以查找设备。一旦找到匹配的设备，驱动就会与其绑定，准备进行数据交换。 10. **错误处理**：在驱动程序中，错误处理是必不可少的。例如，当无法与设备通信时，...
精华秘籍：MTK平台如何提高I2C驱动能力.docx
07-31
这种情况下，单纯调整I2C上拉电阻的值往往不能解决问题，因为影响I2C驱动能力的因素多种多样。 首先，I2C总线上每个设备的寄生电容会影响信号的上升和下降时间。这些电容会累积，可能导致信号质量下降，特别是在长...
嵌入式Linux中I2C驱动程序的应用设计
02-01
综上所述，嵌入式Linux中I2C驱动程序的应用设计涉及对uClinux操作系统内核机制的理解，包括驱动程序架构和中断处理机制。同时，需要深入了解I2C总线的通信协议和特性，以及如何在实际硬件上实现这些协议和特性。最终...
I2C协议&应用（嵌入式学习）
JiaYu的博客
06-25 773
I2C是Inter-Integrated Circuit的缩写，它是一种广泛使用的串行通信协议。它由飞利浦（现在是NXP Semiconductors）开发，并已成为各种电子设备中集成电路（IC）之间通信的标准。I2C是一种由两根线组成的接口，分别是串行数据线（SDA）和串行时钟线（SCL）。多个设备可以连接到同一总线上，每个设备都有一个唯一的地址，用于与总线上特定设备进行通信。I2C协议支持主设备和从设备。主设备发起通信并生成时钟信号，而从设备则响应主设备的命令或请求。
【物联网】I2C（IIC）通信协议详解与应用
热门推荐
Goforyouqp的博客
07-03 2万+
I2C（Inter-Integrated Circuit）是一种常见的串行通信协议，用于在集成电路（IC）之间进行通信。它由飞利浦半导体（现在是恩智浦）在1982年首次提出，并广泛应用于各种电子设备和系统中。本文将详细介绍I2C的工作原理、特性和常见的应用场景。
linux i2c从驱动到应用
a2591748032的博客
12-23 404
linux i2c从驱动到应用--Code参考
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值