i2c驱动APP

已于 2022-04-26 12:45:53 修改
阅读量127 收藏
点赞数
文章标签： linux
于 2022-04-26 08:42:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51994001/article/details/124419126
版权

1.查看i2c的源代码

1.1  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;

1.2  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 *e);
/*
 * 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* e, __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 *e);
/*
 * 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 *e, __u16 mem_addr, __u8 data);

#endif

1.3  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(a) do { do_usage_if( a , __LINE__); } while(0);
void do_usage_if(int b, int line) {
        const static char *eeprog_usage =
                "I2C-24C08(256 bytes) Read/Write Program, ONLY FOR TEST!\n"
                "FriendlyARM Computer Tech. 2009\n";
        if(!b)
                return;
        fprintf(stderr, "%s\n[line %d]\n", eeprog_usage, line);
        exit(1);
}


#define die_if(a, msg) do { do_die_if( a , msg, __LINE__); } while(0);
void do_die_if(int b, char* msg, int line) {
        if(!b)
                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");
}

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 201930310110\n", strlen("APP for 201930310110\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;
}

2.编译并在Ubuntu运行

附上机操作图如下：

3.思考题

3.1  i2c总线的优点是什么

i2C总线最主要的优点如下
控制器
1.i2C总线只需要一根数据线和一根时钟线两根线,总线接口已经集成在芯片内部,优化主板空间和成本
2.无论总线上有多少设备,都只使用两条线,保持低引/信号数
3.真正的支持多主机设备,但是同一时刻只允许一台主机
4.i2C总线有低功耗抗干强的优点,传输距离长的特点
5.连接到相同总线的C数量只受到总线的最大电容400pF限制
6.申行的8位双向数据传位速率在标准模式下可达100kbit/s,快速模式下可达40kbit/s,高速模式下可达34mbit/s,i2C总线的用途是作为与外设之间的通,比如典型的 eeprom,电容C.各种光热压力传感器等
3.2  i2c总线的启动信号和结束信号有什么特点

I2C总线在传送数据过程中共有三种类型信号， 分别是：开始信号、结束信号和应答信号。

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

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

应答信号：接收数据的IC在接收到8bit数据后，向发送数据的IC发出特定的低电平脉冲，表示已收到数据。

CPU向受控单元发出一个信号后，等待受控单元发出一个应答信号，CPU接收到应答信号后，根据实际情况作出是否继续传递信号的判断
 

qq_51994001
关注
上机055
weixin_63265735的博客
04-26 114
一，实验原理 1.i2c总线原理 I2C即Inter IC，由Philips公司开发，是当今电子设计中应用非常广泛的串行总线之一，主要用于电压、温度监控，EEPROM(电可擦可编程只读存储器)数据的读写，光模块的管理等。I2C总线只有两根线， 2.i2c总线结构图 二，查看i2c源代码 进入 i2c 目录，使用vi 编辑器或其他编辑器阅读理解源代码。 1.24cXX.h /*************************************************************
MINI2440i2c驱动学习一
10-09 853
int main(int argc, char** argv) {  struct eeprom e;  fprintf(stderr, "Open /dev/i2c/0 with 8bit mode\n");  die_if(eeprom_open("/dev/i2c/
Linux下的eeprom读写操作(IIC)
爱她就要努力
03-07 8047
利用Linux内核自带的IIC总线驱动，按系统提供的框架，用ioctl方法对eeprom设备进行读写操作，并分别按单字节及多字节读写方式，对外提供函数接口，以供外部程序方便调用。 　　程序由3个文件组成，分别为头文件
构建驱动模块2--STM32模拟IIC访问 （AT24C02）EEPROM 操作
u011996698的博客
10-30 1688
            构建驱动模块2-- STM32模拟IIC访问 （AT24C02）EEPROM 操作         模拟IIC接口可以使用任意两个IO口实现，不受芯片引脚限制，而且硬件IIC在通信出错后，无法自行恢复，模拟IIC则可以迅速恢复；通过调整延时参数，可以调节访问速度。本程序把模拟II2C封装成一个模块，AT24C02只需要调用该模块即可。 1、初始化EEPROM设备。调用...
I2C总线的EEPROM（24C08）Linux驱动
fz835304205的专栏
08-23 2544
基于Linux 2.6.30内核 符合Linux驱动架构模型 针对24C08的Page读写做了优化。 完全模拟文件读写方式，支持lseek操作。 这个代码中，包含了设备的地址，在i2c_add_driver时会去探测该地址上是否有设备。 但通常，做板级开发时，i2c_device被放在board文件中， i2c_device和i2c_driver根据
基于嵌入式系统的I2C驱动编写及测试
08-10
基于嵌入式系统的I2C驱动编写及测试 在嵌入式系统中，I2C（Inter-Integrated Circuit）是一种常用的总线协议，用于连接微控制器、感知器、显示器等外围设备。今天，我们将通过一个基于I2C总线的温度传感器驱动的...
Openharmony - HDF平台驱动之I2C驱动和测试程序
fulinux的博客
02-26 1539
Openharmony - HDF平台驱动之I2C驱动和测试程序
firefly-rk3288j开发板--linux I2C实验之eeprom驱动，包含驱动源码、测试app
06-10
适用用于linux内核驱动学习，参考
安卓 I2C JNI及测试 DEMO AS 源码
03-28
- DTS配置：Device Tree Source（DTS）文件用于描述硬件结构，应确保DTS中没有预定义的I2C从设备地址，以免与内核中的I2C驱动冲突。 6. **调试与优化** - 在Android设备上运行测试程序，检查日志输出，定位可能...
ms1112驱动（含i2c框架和iio框架）
最新发布
06-06
分为i2c框架和iio框架两类，ms1112.c为驱动文件，adcApp.c/ms1112App.c分别为对应的测试文件。 ms1112.c运行makefile，生成ms1112.ko文件。 adcApp.c/ms1112App.c根据自己的平台进行交叉编译 i2c框架： （1）不带...
EEPROM读和写的通用方法以及案例
perseverance51博客
03-15 3031
EEPROM读和写的通用方法以及案例 主要实现代码： //定义一个读和写的通用方法 #define EEPROM_write(address,p) { int i = 0;byte *pp = (byte*)&(p);for(;i<sizeof(p);i++) EEPROM.write(address+i,pp[i]);EEPROM.end();} #define EEPROM_read(address,p) { int i = 0;byte *pp = (byte*)&(p);for
Linux下的eeprom读写操作
yuzeze的专栏
07-12 8989
利用Linux内核自带的IIC总线驱动，按系统提供的框架，用ioctl方法对eeprom设备进行读写操作，并分别按单字节及多字节读写方式，对外提供函数接口，以供外部程序方便调用。 　　程序由3个文件组成，分别为头文件，函数实现文件，及测试程序。 /* ********************************************************************
eeprom应用程序
konjikinoyami的博客
06-12 2984
磨蹭了这么久。。写了一个相对看的过去的eeprom的应用程序。。 板子是fl2440。。跑的是Linux3.0。。主机是centos6.5。。 eeprom.h头文件 14 #include  15 #include  16 #include  17 #include  18 #include  19 #include  20 #include  21 #include  
EEPROM 驱动（module）程序
flyorgan的专栏
09-01 1193
<br />#include <linux/kernel.h><br />#include <linux/init.h><br />#include <linux/module.h><br />#include <linux/slab.h><br />#include <linux/sched.h><br />#include <linux/jiffies.h><br />#include <linux/i2c.h><br />#include <linux/fs.h><br />#include <asm
i2c驱动app
cerry_world的博客
04-24 285
I2C介绍 I2C即Inter IC，由Philips公司开发，是当今电子设计中应用非常广泛的串行总线之一，主要用于电压、温度监控，EEPROM(电可擦可编程只读存储器)数据的读写，光模块的管理等。I2C总线只有两根线，SCL和SDA，SCL即Serial Clock，串行时钟，SDA即Serial Data，串行数据。 查看i2c代码 code 24cXX.c eeprog.c 24cXX.h /******************************************************
【Linux】i2c驱动app
m0_57618561的博客
04-26 174
查看i2c源代码 在这里插入代码片 编译并在Ubuntu上运行 i2c （1）I2C总线的优点是什么？ I2C总线主要的优点是其简单性和有效性。由于接口直接在组件之上，因此I2C总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。总线的长度可高达25英尺，并且能够以10Kbps的传输速率支持40个组件。I2C总线的另一个优点是，它支持多主控（multimastering）， 其中任何能够进行发送和接收的设备都可以成为主总线。一个主控能够控制信号的传输和时钟频率。当然，在任何时间点上只
Linux-2.6.32.2内核在mini2440上的移植(十二)---移植I2C EEPROM驱动
zhoujk0520的专栏
11-30 1446
移植环境(红色粗字体字为修改后内容，蓝色粗体字为特别注意内容) 1，主机环境：VMare下CentOS 5.5 ，1G内存。 2，集成开发环境：Elipse IDE 3，编译编译环境：arm-linux-gcc v4.4.3，arm-none-linux-gnueabi-gcc v4.5.1。 4，开发板：mini2440，2M nor flash，128M nand flash。 5，
linux中输出调试信息
mndscc的博客
07-10 1236
在友善之臂的EEPROM的示例程序中看到有一些不一样的地方，使用了__LINE__这样的预编译宏。而且其用法也是比较好，使得主程序简洁明了。所以就学习了一下。 #include #include #include #include #include #include #include #include #include #include "24cXX.h"
LINUX下的IIC驱动（二）
xie0812的专栏
08-03 1825
这篇文章主要以友善的实验板为例介绍一下，他们所说的IIC下的EEPROM驱动吧。因为我个人觉得不是很好，可能会给初学者带来一下迷惑，纯属个人观点！
I2C设备驱动详解：从接口到实现
文章进一步探讨了I2C驱动的体系结构，分为三个层次：I2C核心层负责提供通用的I2C通信接口和设备管理，I2C总线驱动则实现具体的I2C适配器操作，如产生信号控制周期、读写操作和ACK机制。I2C设备驱动则针对硬件设备的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值