上机055

最新推荐文章于 2022-10-30 23:29:18 发布
最新推荐文章于 2022-10-30 23:29:18 发布
阅读量52 收藏
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68870311/article/details/124454786
版权

1.查看i2c源代码

（1）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

 

（2）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 *e, __u8 buf)
{
    int r;
    // we must simulate a plain I2C byte write with SMBus functions
    r = i2c_smbus_write_byte(e->fd, buf);
    if(r < 0)
        fprintf(stderr, "Error i2c_write_1b: %s\n", strerror(errno));
    usleep(10);
    return r;
}
 
static int i2c_write_2b(struct eeprom *e, __u8 buf[2])
{
    int r;
    // we must simulate a plain I2C byte write with SMBus functions
    r = i2c_smbus_write_byte_data(e->fd, buf[0], buf[1]);
    if(r < 0)
        fprintf(stderr, "Error i2c_write_2b: %s\n", strerror(errno));
    usleep(10);
    return r;
}
 
static int i2c_write_3b(struct eeprom *e, __u8 buf[3])
{
    int r;
    // we must simulate a plain I2C byte write with SMBus functions
    // the __u16 data field will be byte swapped by the SMBus protocol
    r = i2c_smbus_write_word_data(e->fd, buf[0], buf[2] << 8 | buf[1]);
    if(r < 0)
        fprintf(stderr, "Error i2c_write_3b: %s\n", strerror(errno));
    usleep(10);
    return r;
}
 
 
#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* e)
{
    int funcs, fd, r;
    e->fd = e->addr = 0;
    e->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((r = 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( ( r = ioctl(fd, I2C_SLAVE, addr)) < 0)
    {
        fprintf(stderr, "Error eeprom_open: %s\n", strerror(errno));
        return -1;
    }
    e->fd = fd;
    e->addr = addr;
    e->dev = dev_fqn;
    e->type = type;
    return 0;
}
 
int eeprom_close(struct eeprom *e)
{
    close(e->fd);
    e->fd = -1;
    e->dev = 0;
    e->type = EEPROM_TYPE_UNKNOWN;
    return 0;
}
 
#if 0
int eeprom_24c32_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)
{
    __u8 buf[3] = { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
    return i2c_write_3b(e, buf);
}
 
 
int eeprom_24c32_read_current_byte(struct eeprom* e)
{
    ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
    return i2c_smbus_read_byte(e->fd);
}
 
int eeprom_24c32_read_byte(struct eeprom* e, __u16 mem_addr)
{
    int r;
    ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
    __u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
    r = i2c_write_2b(e, buf);
    if (r < 0)
        return r;
    r = i2c_smbus_read_byte(e->fd);
    return r;
}
#endif
 
 
int eeprom_read_current_byte(struct eeprom* e)
{
    ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
    return i2c_smbus_read_byte(e->fd);
}
 
int eeprom_read_byte(struct eeprom* e, __u16 mem_addr)
{
    int r;
    ioctl(e->fd, BLKFLSBUF); // clear kernel read buffer
    if(e->type == EEPROM_TYPE_8BIT_ADDR)
    {
        __u8 buf =  mem_addr & 0x0ff;
        r = i2c_write_1b(e, buf);
    } else if(e->type == EEPROM_TYPE_16BIT_ADDR) {
        __u8 buf[2] = { (mem_addr >> 8) & 0x0ff, mem_addr & 0x0ff };
        r = i2c_write_2b(e, buf);
    } else {
        fprintf(stderr, "ERR: unknown eeprom type\n");
        return -1;
    }
    if (r < 0)
        return r;
    r = i2c_smbus_read_byte(e->fd);
    return r;
}
 
int eeprom_write_byte(struct eeprom *e, __u16 mem_addr, __u8 data)
{
    if(e->type == EEPROM_TYPE_8BIT_ADDR) {
        __u8 buf[2] = { mem_addr & 0x00ff, data };
        return i2c_write_2b(e, buf);
    } else if(e->type == EEPROM_TYPE_16BIT_ADDR) {
        __u8 buf[3] = 
            { (mem_addr >> 8) & 0x00ff, mem_addr & 0x00ff, data };
        return i2c_write_3b(e, buf);
    } 
    fprintf(stderr, "ERR: unknown eeprom type\n");
    return -1;
}

（3） eeproq.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");

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

 write(STDOUT_FILENO, "APP for 20193031xxxx ...\n", strlen("APP for 20193031xxxx...\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.编译并在ubuntn下运行

（1）编译

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbTBfNjg4NzAzMTE=,size_20,color_FFFFFF,t_70,g_se,x_16

 （2）查看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；

（3）手动输入

#linux_ubuntu180.4

export ARCH=arm

export CROSS_COMPILE=arm-linux-gnueabihf-

export PATH=$PATH:/home/jie/qemu/100ask_imx6ull-qemu/ToolChain/gcc-linaro-6.2.1-2016.11-x86_64_arm-linux-gnueabihf/binbash

make

 

#qemu_imx6ul

./i2c -r

./i2c -w

3.思考题

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

 

•I2C总线只需要一根数据线和一根时钟线两根线,总线接口已经集成在芯片内部,优化主板空间和成本。   

 

•无论总线上有多少设备,都只使用两条线,保持低引脚/信号数。   

 

•真正的支持多主机设备,但是同一时刻只允许一台主机。   

 

•I2C总线具有低功耗、抗干扰强的优点,传输距离长的特点。 

 

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

 

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

 

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

 

 

m0_68870311
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
EEPROM读和写的通用方法以及案例
perseverance51博客
03-15 3026
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
MINI2440i2c驱动学习一
10-09 850
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 8017
利用Linux内核自带的IIC总线驱动，按系统提供的框架，用ioctl方法对eeprom设备进行读写操作，并分别按单字节及多字节读写方式，对外提供函数接口，以供外部程序方便调用。 　　程序由3个文件组成，分别为头文件
构建驱动模块2--STM32模拟IIC访问 （AT24C02）EEPROM 操作
u011996698的博客
10-30 1682
            构建驱动模块2-- STM32模拟IIC访问 （AT24C02）EEPROM 操作         模拟IIC接口可以使用任意两个IO口实现，不受芯片引脚限制，而且硬件IIC在通信出错后，无法自行恢复，模拟IIC则可以迅速恢复；通过调整延时参数，可以调节访问速度。本程序把模拟II2C封装成一个模块，AT24C02只需要调用该模块即可。 1、初始化EEPROM设备。调用...
I2C总线的EEPROM（24C08）Linux驱动
fz835304205的专栏
08-23 2540
基于Linux 2.6.30内核 符合Linux驱动架构模型 针对24C08的Page读写做了优化。 完全模拟文件读写方式，支持lseek操作。 这个代码中，包含了设备的地址，在i2c_add_driver时会去探测该地址上是否有设备。 但通常，做板级开发时，i2c_device被放在board文件中， i2c_device和i2c_driver根据
【应用多元统计分析】上机一
最新发布
m0_72318954的博客
10-30 1001
第一次上机内容
专题资料（2021-2022年）Linux课程及上机测验时间安排.doc
10-07
例如，第一批上机测验的名单包括周磊（生物医学051班）、张振（英语055班（医学））、陈鑫（汉语言041班）等，直至最后一批的简杰辉（管理科学061班）和黄磊（生科062班（植物学））。 通过这样的详细安排，学校...
2020-7-10上机实践——switch语句学习。
qq_40180271的博客
07-10 324
1、问题及代码 1.1 /* *Copyright (c)2020,CSDN学院 *All rights reserved. *文件名称：main.c *作 者：李先声 *完成日期：2020年7月7日 *版 本 号：v1.0 *问题描述：设计一个投票表决器，其功能是： 输入Y、y，打印agree 输入N、n，打印disagree 输入其他，打印lose */ #include<stdio.h> int main() {
c++上机实验3定期存款利息计算器
hiahia233的博客
04-13 783
一 问题及代码* / * 文件名称：c++第三次实验定息存款利息计算器 * 作 者：张琪 * 完成日期：2016 年 4 月 11 日 * 版 本 号：v1.0 * 对任务及：求解方法的描述部分: * 输入描述：输入一定存款金额和存款期限 * 问题描述：求存款利息 * 程序输出：存款利息 * 问题分析：略 * 算法设计：略 */ #include using namespa
C++第三次上机实验，计算利息问题
chenhangming的博客
04-07 1653
一、问题及代码 * 文件名称：hangming.cpp * 作 者：陈航鸣 * 完成日期：2016 年 4 月 7 日 * 版 本 号：v1.0 * 对任务及求解方法的描述部分: * 输入描述： 无 * 问题描述：我的C++第三次实验，简单程序设计1 * 程序输出：利息计算问题 * 问题分析：略 * 算法设计：略 */ #include using namespac
Linux下的eeprom读写操作
yuzeze的专栏
07-12 8976
利用Linux内核自带的IIC总线驱动，按系统提供的框架，用ioctl方法对eeprom设备进行读写操作，并分别按单字节及多字节读写方式，对外提供函数接口，以供外部程序方便调用。 　　程序由3个文件组成，分别为头文件，函数实现文件，及测试程序。 /* ********************************************************************
eeprom应用程序
konjikinoyami的博客
06-12 2978
磨蹭了这么久。。写了一个相对看的过去的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 1190
<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 279
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 169
查看i2c源代码 在这里插入代码片 编译并在Ubuntu上运行 i2c （1）I2C总线的优点是什么？ I2C总线主要的优点是其简单性和有效性。由于接口直接在组件之上，因此I2C总线占用的空间非常小，减少了电路板的空间和芯片管脚的数量，降低了互联成本。总线的长度可高达25英尺，并且能够以10Kbps的传输速率支持40个组件。I2C总线的另一个优点是，它支持多主控（multimastering）， 其中任何能够进行发送和接收的设备都可以成为主总线。一个主控能够控制信号的传输和时钟频率。当然，在任何时间点上只
Linux-2.6.32.2内核在mini2440上的移植(十二)---移植I2C EEPROM驱动
zhoujk0520的专栏
11-30 1432
移植环境(红色粗字体字为修改后内容，蓝色粗体字为特别注意内容) 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 1235
在友善之臂的EEPROM的示例程序中看到有一些不一样的地方，使用了__LINE__这样的预编译宏。而且其用法也是比较好，使得主程序简洁明了。所以就学习了一下。 #include #include #include #include #include #include #include #include #include #include "24cXX.h"
C语言编程：上机题目集锦
"C语言上机题" C语言是一门基础且重要的编程语言，它以其简洁、高效的特点广泛应用于系统编程、嵌入式开发、软件工程等多个领域。本题主要涉及C语言的基本操作，包括文件操作、字符串处理、错误修正以及程序设计。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值