Linux I2C驱动APP

一、I2C总线原理

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

2.i2C总线结构图

二、查看i2c源代码

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
{
    char *dev;  // device file i.e. /dev/i2c-N
    int addr;   // i2c address
    int fd;     // file descriptor
    int type;   // eeprom type
};

/*
 * 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)
{
    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);
}


static inline __s32 i2c_smbus_write_quick(int file, __u8 value)
{
    return i2c_smbus_access(file, value, 0, I2C_SMBUS_QUICK, NULL);
}

static inline __s32 i2c_smbus_read_byte(int file)
{
    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;
}

static inline __s32 i2c_smbus_write_byte(int file, __u8 value)
{
    return i2c_smbus_access(file, I2C_SMBUS_WRITE, value,
        I2C_SMBUS_BYTE, NULL);
}

static inline __s32 i2c_smbus_read_byte_data(int file, __u8 command)
{
    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;
}

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

static inline __s32 i2c_smbus_read_word_data(int file, __u8 command)
{
    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;
}

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

static inline __s32 i2c_smbus_process_call(int file, __u8 command, __u16 value)
{
    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;
}


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

static inline __s32 i2c_smbus_write_block_data(int file, __u8 command,
    __u8 length, __u8* values)
{
    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);
}

/* Returns the number of read bytes */
static inline __s32 i2c_smbus_read_i2c_block_data(int file, __u8 command,
    __u8* values)
{
    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 {
        for (i = 1; i <= data.block[0]; i++)
            values[i - 1] = data.block[i];
        return data.block[0];
    }
}

static inline __s32 i2c_smbus_write_i2c_block_data(int file, __u8 command,
    __u8 length, __u8* values)
{
    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);
}

/* Returns the number of read bytes */
static inline __s32 i2c_smbus_block_process_call(int file, __u8 command,
    __u8 length, __u8* values)
{
    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 {
        for (i = 1; i <= data.block[0]; i++)
            values[i - 1] = data.block[i];
        return data.block[0];
    }
}

static int i2c_write_1b(struct eeprom* p_device_struct, __u8 buf)
{
    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;
}

static int i2c_write_2b(struct eeprom* p_device_struct, __u8 buf[2])
{
    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;
}

static int i2c_write_3b(struct eeprom* p_device_struct, __u8 buf[3])
{
    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;
}


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

int eeprom_open(char* dev_fqn, int addr, int type, struct eeprom* p_device_struct)
{
    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)
    {
        fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
        return -1;
    }

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


    // 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)
    {
        fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
        return -1;
    }
    p_device_struct->fd = fd;
    p_device_struct->addr = addr;
    p_device_struct->dev = dev_fqn;
    p_device_struct->type = type;
    return 0;
}

int eeprom_close(struct eeprom* p_device_struct)
{
    close(p_device_struct->fd);
    p_device_struct->fd = -1;
    p_device_struct->dev = 0;
    p_device_struct->type = EEPROM_TYPE_UNKNOWN;
    return 0;
}

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


int eeprom_24c32_read_current_byte(struct eeprom* p_device_struct)
{
    ioctl(p_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
    return i2c_smbus_read_byte(p_device_struct->fd);
}

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


int eeprom_read_current_byte(struct eeprom* p_device_struct)
{
    ioctl(p_device_struct->fd, BLKFLSBUF); // clear kernel read buffer
    return i2c_smbus_read_byte(p_device_struct->fd);
}

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

int eeprom_write_byte(struct eeprom* p_device_struct, __u16 mem_addr, __u8 data)
{
    if (p_device_struct->type == EEPROM_TYPE_8BIT_ADDR) {
        __u8 buf[2] = { mem_addr & 0x00ff, data };
        return i2c_write_2b(p_device_struct, buf);
    }
    else if (p_device_struct->type == EEPROM_TYPE_16BIT_ADDR) {
        __u8 buf[3] =
        { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
        return i2c_write_3b(p_device_struct, buf);
    }
    fprintf(stderr, "ERR: unknown eeprom type\n");
    return -1;
}

 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 { do_usage_if( flag , __LINE__); } while(0);
void do_usage_if(int error_code, int line) {
    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);
}


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


static int read_from_eeprom(struct eeprom* e, int addr, int size) {
    int ch, i;
    for (i = 0; i < size; ++i, ++addr) {
        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);
    }
    fprintf(stderr, "\n\n");
    return 0;
}

static int write_to_eeprom(struct eeprom* e, int addr) {
    int i;
    for (i = 0, addr = 0; i < 256; i++, addr++) {
        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");
    }
    fprintf(stderr, "\n\n");
    return 0;
}

int main(int argc, char** argv) {
    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 201930310130 ...\n", strlen("APP for 201930310130 ...\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) {
    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);
    }
    eeprom_close(&e);

    return 0;
}

编译并在ubuntu下运行

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

三、思考题

1.I2C总线的优点是什么？

(1)只使用两根电线

(2)支持多个主服务器和多个从服务器ACK / NACK位确认每个帧都已成功传输

(3)硬件没有UART那么复杂

(4)众所周知且广泛使用的协议

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

启动条件：在SCL线路从高电平切换到低电平之前，SDA线路从高电平切换到低电平。

停止条件：SCL线路从低电平切换到高电平后，SDA线路从低电平切换到高电平。