24c32，i2c原理

已于 2023-11-02 10:24:44 修改
阅读量7.1k 收藏 12
点赞数 3
文章标签： c语言
于 2017-01-19 11:07:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxchuan000/article/details/54613413
版权

通讯主要就是scl,sda线，和电源-地。4线

地址由24c32器件的A0,A1,A2来决定。SCL,SDA需要接上拉。

本次说的都是主机端流程。

1.启动和stop

SCL=1，SDA下降沿表示启动。 SCL=1，SDA上升沿表示stop。

2.写

流程：start---->设备地址，最后一位为0表示写，等待ACK（ACK是传输每个字节都有，谁收数据谁发ACK,除最后一次ACK为1,其他ACK为0）----->2个字节数据地址------->写入数据---------->stop

注意一点：

1. 24c32每页32字节，32字节写缓存。写入的数据先到缓存区，收到stop时，写入储存区。

2. 如果写入数据大于32字节，需要分为n/32次发送，否则写缓存会被覆盖。

3. 如果写如数据在页边界(如:写2个字节,31地址开始写,会导致32地址写不进去,需要先写第一页,在写第二页)

3.读

流程： start-------->设备地址(写，等应答ACK)------->写入2字节读取的地址------->restart--------->设备地址(读，等应答)-------->接收n个数据(每接收一个数据，应答ACK=0，最后一字节应答ACK=1)----->stop.

读的时候并没长度限制。启动操作变长了，先要写入地址，然后重新启动开始读取。可以把读分为写和读2个部分，写就和上面一样了，linux的I2C驱动就是这样写的。

4.仲裁失败，表示多个主机时，被别的主机抢占了总线。

linux系统中应用层使用:ioctl(fd, I2C_RDWR, &idata)来系统函数进行读写即可

参考主I2C程序：

#include "stm32f10x.h"

#define SCL_H         GPIOB->BSRR = IIC_SCL
#define SCL_L         GPIOB->BRR  = IIC_SCL 
   
#define SDA_H         GPIOB->BSRR = IIC_SDA
#define SDA_L         GPIOB->BRR  = IIC_SDA

#define SDA_read      GPIOB->IDR  & IIC_SDA



void I2C_delay(void)
{	
   	u16 i=50; //10-大概2us，50-大概7us，IIC速率大概80khz
   	while(i) 
   	{ 
     		i--; 
   	} 
}

u8 IIc_Start(void)
{
	SDA_H;
	SCL_H;
	I2C_delay();
	if(!SDA_read)return FALSE;	//SDA线为低电平则总线忙,退出
	SDA_L;
	I2C_delay();
	if(SDA_read) return FALSE;	//SDA线为高电平则总线出错,退出
	SDA_L;
	I2C_delay();
	return TRUE;
}

void IIc_Stop(void)
{
	SCL_L;
	I2C_delay();
	SDA_L;
	I2C_delay();
	SCL_H;
	I2C_delay();
	SDA_H;
	I2C_delay();
}

void Rd_Ack(void)
{	
	SCL_L;
	I2C_delay();
	SDA_L;
	I2C_delay();
	SCL_H;
	I2C_delay();
	SCL_L;
	I2C_delay();
}

 void Rd_NoAck(void)
{	
	SCL_L;
	I2C_delay();
	SDA_H;
	I2C_delay();
	SCL_H;
	I2C_delay();
	SCL_L;
	I2C_delay();
}

 u8 Wr_Ack(void) 	 //返回为:=1有ACK,=0无ACK
{
	SCL_L;
	I2C_delay();
	SDA_H;			
	I2C_delay();
	SCL_H;
	I2C_delay();
	if(SDA_read)
	{
      SCL_L;
      return FALSE;
	}
	SCL_L;
	return TRUE;
}

 void IIc_Send(u8 SendByte) //数据从高位到低位//
{
    u8 i=8;
    while(i--)
    {
        SCL_L;
        I2C_delay();
      if(SendByte&0x80)
        SDA_H;  
      else 
        SDA_L;   
        SendByte<<=1;
        I2C_delay();
		SCL_H;
        I2C_delay();
    }
    SCL_L;
}

 u8 IIc_Receive(void)  //数据从高位到低位//
{ 
    u8 i=8;
    u8 ReceiveByte=0;

    SDA_H;				
    while(i--)
    {
      ReceiveByte<<=1;      
      SCL_L;
      I2C_delay();
	  SCL_H;
      I2C_delay();	
      if(SDA_read)
      {
        ReceiveByte|=0x01;
      }
    }
    SCL_L;
    return ReceiveByte;
}

/*****************向有子地址器件发送多字节数据函数*************/
u8 Fm24cl64_WritenBytes(u8 sla,u16 suba,u8 *s,u16 no)
{
	u16 i;
	u8 error = TRUE;
	
	if(no==0) return error;
	IIc_Start();               /*启动总线*/
	IIc_Send(sla);             /*发送器件物理地址*/
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit1;
	}
	
	i=(u8)(suba>>8);
	IIc_Send(i);               /*发送器件子地址高字节*/
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit1;
	}
	i=(u8)suba;          /*发送器件子地址低字节*/
	IIc_Send(i);
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit1;
	}
	for(i=0;i<no;i++)
	{   
		IIc_Send(*(s+i));           /*发送数据*/
		if(Wr_Ack() == FALSE)
		{
			error = FALSE;
			break;
		}
	} 
exit1:	
	IIc_Stop();                 /*结束总线*/ 
	return error;
}
/***********向有子地址器件读取多字节数据函数*****************/
u8 Fm24cl64_ReadnBytes(u8 sla,u16 suba,u8 *s,u16 no)
{
	u16  i;
	u8 error = TRUE;
	
	if(no==0) return error;
	IIc_Start();              /*启动总线*/

	IIc_Send(sla);           /*发送器件地址*/
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit;
	}
	i=(u8)(suba>>8);
	IIc_Send(i);            /*发送器件子地址高字节*/
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit;
	}
	i=(u8)suba;          /*发送器件子地址低字节*/

	IIc_Send(i); 
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit;
	}
	IIc_Start();  
	IIc_Send(sla|0x01);
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit;
	}
	for(i=0;i<no-1;i++)
	{   
		*(s+i)=IIc_Receive();          /*发送数据*/
		Rd_Ack();           /*发送就答位*/  
	} 
	*(s+i)=IIc_Receive();
	Rd_NoAck();               /*发送非应位*/
exit:	
	IIc_Stop();               /*结束总线*/ 
	return error;
}
/*****************清除FM24cl64 从suba开始的地址空间0000-0X1FFF*************/
u8 FM24CL64_Clr(u8 sla,u16 suba)
{
	u8  i;
	u16 y;
	u8 error = TRUE;
	
	
	IIc_Start();               /*启动总线*/
	IIc_Send(sla);             /*发送器件物理地址*/
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit1;
	}
	
	i=(u8)(suba>>8);
	IIc_Send(i);               /*发送器件子地址高字节*/
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit1;
	}
	i=(u8)suba;          /*发送器件子地址低字节*/
	IIc_Send(i);
	if(Wr_Ack() == FALSE)
	{
		error = FALSE;
		goto exit1;
	}
	for(y=0;y<(0x2000 - 40);y++)
	{   
		IIc_Send(0);           /*发送数据*/
		if(Wr_Ack() == FALSE)
		{
			error = FALSE;
			break;
		}
	} 
exit1:	
	IIc_Stop();                 /*结束总线*/ 
	return error;
}

linux应用层代码。前提底层已经把i2c指定到了/dev/i2c-x

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <stdint.h>
#include <time.h>
#include <sys/timeb.h>
#include <string>

#define DEBUG_LEVEL_DEF 5 // do not use value, this is common print.you can use logdbg in project
// extern int DEBUG_LEVEL_DEF;
#define PRINTF_DEF(lev, fmt, lprt, ...)                                                                                \
    do                                                                                                                 \
    {                                                                                                                  \
        if (DEBUG_LEVEL_DEF >= lev)                                                                                    \
        {                                                                                                              \
            struct timeb tnow;                                                                                         \
            struct tm *tmnow;                                                                                          \
            ftime(&tnow);                                                                                              \
            tmnow = localtime(&tnow.time);                                                                             \
            printf("[%d-%02d-%02d %02d:%02d:%02d.%03d][%s][%s,%d]" fmt "\n", tmnow->tm_year + 1900, tmnow->tm_mon + 1, \
                   tmnow->tm_mday, tmnow->tm_hour, tmnow->tm_min, tmnow->tm_sec, tnow.millitm % 1000,                  \
                   lprt, __func__, __LINE__, ##__VA_ARGS__);                                                           \
        }                                                                                                              \
    } while (0);
#define printfat(fmt, ...) PRINTF_DEF(0, fmt, "fat", ##__VA_ARGS__)
#define printerr(fmt, ...) PRINTF_DEF(1, fmt, "err", ##__VA_ARGS__)
#define printwarn(fmt, ...) PRINTF_DEF(2, fmt, "war", ##__VA_ARGS__)
#define printinfo(fmt, ...) PRINTF_DEF(3, fmt, "inf", ##__VA_ARGS__)
#define printdbg(fmt, ...) PRINTF_DEF(4, fmt, "dbg", ##__VA_ARGS__)
#define printtra(fmt, ...) PRINTF_DEF(5, fmt, "tra", ##__VA_ARGS__)

class i2cOperateClass
{
public:
    i2cOperateClass(std::string i2DevFile = "/dev/i2c-0")
    {
        optFileName = i2DevFile;
        optFd = -1;
    }
    ~i2cOperateClass()
    {
    }
    static i2cOperateClass &instance()
    {
        static i2cOperateClass i2work;
        return i2work;
    }
    void closeOpt()
    {
        if (optFd <= 0)
        {
            return;
        }
        close(optFd);
        optFd = -1;
    }
    int initopt()
    {
        if (optFileName == "")
        {
            printerr("");
            return -1;
        }

        optFd = open(optFileName.c_str(), O_RDWR);
        if (optFd < 0)
        {
            printerr("%s:open fail!", optFileName.c_str());
            return -1;
        }
        ioctl(optFd, I2C_RETRIES, 2);
        return 0;
    }
    int readopt(uint8_t slaveDeviceAddress, uint16_t registerAddress, std::string &readstr, uint16_t readsize,
                uint16_t registerSize = 1)
    {
        readstr = "";
        if (optFd < 0)
        {
            printerr("%s:open fail!", optFileName.c_str());
            return -1;
        }
        uint8_t registerBuffer[4];
        if (registerSize == 1)
        {
            registerBuffer[0] = registerAddress;
        }
        else if (registerSize == 2)
        {
            registerBuffer[0] = registerAddress >> 8;
            registerBuffer[1] = registerAddress;
        }
        else
        {
            printerr("%d", registerSize);
            return -1;
        }
        printdbg("dev:0x%x, register:0x%x, readsize:%d", slaveDeviceAddress, registerAddress, readsize);
        readstr.resize(readsize);
        struct i2c_msg msgs[2] =
            {
                {slaveDeviceAddress, 0, registerSize, registerBuffer},
                {slaveDeviceAddress, I2C_M_RD, readsize, (uint8_t *)readstr.data()},
            };
        struct i2c_rdwr_ioctl_data idata =
            {
                msgs,
                2
            };
        if (ioctl(optFd, I2C_RDWR, &idata) < 0)
        {
            printerr("%s:open fail!", optFileName.c_str());
            return -2;
        }
        return readsize;
    }
    int writeopt(uint8_t slaveDeviceAddress, uint16_t registerAddress, std::string writestr,
                 uint16_t registerSize = 1)
    {
        if (optFd < 0)
        {
            printerr("%s:open fail!", optFileName.c_str());
            return -1;
        }
        uint8_t registerBuffer[4];
        if (registerSize == 1)
        {
            registerBuffer[0] = registerAddress;
        }
        else if (registerSize == 2)
        {
            registerBuffer[0] = registerAddress >> 8;
            registerBuffer[1] = registerAddress;
        }
        else
        {
            printerr("%d", registerSize);
            return -1;
        }
        std::string tmpWriteStr;
        tmpWriteStr.append((const char *)registerBuffer, registerSize);
        tmpWriteStr.append(writestr);
        printdbg("%x", tmpWriteStr.size());
        struct i2c_msg msgs[2] =
            {
                {slaveDeviceAddress, 0, tmpWriteStr.size(), (uint8_t *)tmpWriteStr.data()},
            };
        struct i2c_rdwr_ioctl_data idata =
            {
                msgs,
                1
            };
        if (ioctl(optFd, I2C_RDWR, &idata) < 0)
        {
            printerr("%s:write fail!", optFileName.c_str());
            return -2;
        }
        return writestr.size();
    }

private:
    std::string optFileName;
    int optFd;
};

int main()
{
    std::string tmpstr;
    int tmpflag;
    const unsigned char channel[] = {0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07};
    i2cOperateClass::instance().initopt();

    for(int i = 0; i < 8; i++)
    {
        uint16_t tmpregister = 0x84;
        tmpregister |= (channel[i] << 4);
        i2cOperateClass::instance().readopt(0x48, tmpregister, tmpstr, 1);
        if(tmpstr.size() < 1)
        {
            printerr("");
        }
        printdbg("%d", tmpstr[0]);
    }

    for(int i = 0; i < 8; i++)
    {
        uint16_t tmpregister = 0x84;
        tmpregister |= (channel[i] << 4);
        i2cOperateClass::instance().readopt(0x49, tmpregister, tmpstr, 1);
        if(tmpstr.size() < 1)
        {
            printerr("");
        }
        printdbg("%d", tmpstr[0]);
    }

    for(int i = 0; i < 8; i++)
    {
        uint16_t tmpregister = 0x84;
        tmpregister |= (channel[i] << 4);
        i2cOperateClass::instance().readopt(0x4A, tmpregister, tmpstr, 1);
        if(tmpstr.size() < 1)
        {
            printerr("");
        }
        printdbg("%d", tmpstr[0]);
    }

    for(int i = 0; i < 8; i++)
    {
        uint16_t tmpregister = 0x84;
        tmpregister |= (channel[i] << 4);
        i2cOperateClass::instance().readopt(0x4B, tmpregister, tmpstr, 1);
        if(tmpstr.size() < 1)
        {
            printerr("");
        }
        printdbg("%d", tmpstr[0]);
    }

    i2cOperateClass::instance().closeOpt();
    return 1;
}

Surpass-HC
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
存储芯片24C32（24Cxx）源码
06-03
存储芯片24Cxx源码，包括24C32、24C08、24C02等等，有详细注释，方便新手
串行 EEPROM 存储器芯片AT24C32（兼容同系列AT24CXX）
最新发布
xiaobuding的博客
11-28 3305
有些单片机没有内部的EEPROM，或者说内部的EEPROM空间不够大，这时候，我们就想到了外挂一个EEPROM芯片，而AT24C32就是一种常用的串行EEPROM存储器，它适用于许多需要在系统掉电后保留数据的嵌入式应用场景。AT24C32是一种常见的串行 EEPROM 存储器芯片，通常用于存储系统配置、用户数据、校准参数等。它具有以下特点，一般会在以下情况下被使用： 1.小容量数据存储：AT24C32的存储容量一般为32Kb，适合存储少量的配置信息、校准参数、设备标识等数据。 2.串行接口：AT24C32采
STM32F103 实例应用（10）——I2C读写24C32
qq_34118600的博客
02-04 2681
一、应用简介 本文介绍24C32的读写，基于野火的软件I2C程序。 board_i2c.h /**=========================================================================== @file board_i2c.h @brief 本文件是用于I2C驱动 @author 青梅煮久 @version r0.1 @date 2021/01/13 -------------------------.
i2c对24c32进行读写
feifansong的博客
03-01 4051
开发板环境：vivado 2017.1 ，开发板型号xc7z020clg400-1，这个工程主要是用i2c对24c32进行读写 Step1 新建工程然后按照下面截图中进行配置（主要配置了DDR、i2c） 配置完成后进行综合、生成顶层文件，生成的顶层文件如下图所示 [csharp] view plain copy [html] view plain copy //Copyrig...
BL24C32（EEPROM）读写操作
zwg1012的博客
03-22 1191
EEPROM-24C32的读写操作，24C32的读写时序和08已经16的都一样，所以分享出来，供大家学习与参考。
I2C总线原理与应用
08-20
I2C总线原理与应用 I2C总线是一种由Philips公司开发的两线式串行总线，用于连接微控制器及其外围设备。该总线产生于80年代，最初为音频和视频设备开发，如今方泛用于微控制器与各种功能模块的连接。 I2C总线的主要...
如何采用C51单片机读写CAT24C32
07-14
#defineWriteDeviceAddress0x0A2//定义器件在I2C总线中的写地址（注意：根据自定义从机地址接口改变） #defineReadDviceAddress0x0A3//定义器件在I2C总线中的读地址（注意：根据自定义从机地址接口改变） sbitSCL=...
Arduino I2C实时时钟芯片(RTC) 24C32存储器 DS1307时钟-电路方案
04-23
1.DS1307 I2C实时时钟芯片(RTC) 2.24C32 32K I2C EEPROM存储器 3.采用LIR2032可充电锂电池，并带充电电路 4.解决DS1307带备用电池不能读写的问题 5.充满电后，能提供DS1307计时1年 6引出DS1307的时钟引脚，为单片机...
利用I2C访问E2PROM 24C02设计思路及电路设计
11-14
1．设计思路 本设计通过PIC16F877的I2C方式来访问E2PROM芯片24C02，为方便看到访问过程，本设计通过5个LED灯的亮与灭来显示程序运行效果。 2．电路设计 24C02与单片机的接口原理图如图所示。 　图 24C02与...
单片机I2C读写24c02指导
03-05
单片机I2C通信是微控制器之间...需要注意的是，这种模拟方法可能不如使用专用的I2C库高效或可靠，但对于学习和理解I2C协议的基本原理非常有用。在实际项目中，通常会使用硬件支持的I2C接口或者I2C库来简化开发过程。
24C02_04_08_16_32_64中文数据手册
04-28
24C02 24C04 24C08 24C16 24C32 24C64中文数据手册
at24c32 linux,AT24C32使用方法总结
weixin_42395171的博客
05-14 2130
《AT24C32使用方法总结》由会员分享，可在线阅读，更多相关《AT24C32使用方法总结(3页珍藏版)》请在人人文库网上搜索。1、AT24C32使用方法总结 2011-04-29 16:56:58分类：LINUXAT24C32是 2-Wire Serial EEPROM ，容量为 32Kbits (4096*8)。利用该芯片可以模拟 I2C 总线，如果采用 IO 口来进行模拟，可以采用二线制( ...
Arduino I2C + AC24C32 EEPROM
aciauk242806的博客
01-17 1171
主要特性 AC24C32是Atmel的两线制串行EEPROM芯片，根据工作电压的不同，有-2.7、-1.8两种类型。主要特性有： 工作范围：-2.7类型范围4.5~5.5V，-1.8类型1.8~5.5V。本文用的为-2.7类型。 待机功耗：与工作电压有关，见下图 容量：4096 x 8bits，即32k bits 接口：I2C，工作在5V时支持最大时钟频率400kHz，其他...
24系列EEPROM的应用
菜鸟大补丸
06-01 5385
24系列EEPROM的应用   作为一种非易失性存储器（NVM），24系列EEPROM使用的很普遍，一般作为数据量不太大的数据存储器。下面总结一下其应用的一些要点。从命名上看，24CXX中XX的单位是kbit，如24C08，其存储容量为8k bit，即1k Byte＝1024 Byte。 一、工作条件 1．工作电压(VCC)    24CXX： 4.5V－5.5V
Arduino UNO AT24C32进行字符串数据读写操作（二）
perseverance51博客
11-24 835
Arduino UNO AT24C32进行字符串数据读写操作（二） 相关篇《Arduino UNO AT24C32进行字符串数据读写【优化篇】》 本篇在读写AT24C32的时候，采用移位运算来实现对高位和低位地址进行操作，实现功能都一样。 本示例同样适用于，AT24C04或以上的容量器件的读写。不适用于1/2Kbit容量的读写操作，大于2Kbit容量器件，地址位分高低位，读写方式有区别。 实例代码 /* Wire库I2C基本读写程序 AT24C32读写操作 /* 描述：AT2
LVPECL CML LVDS HSCL LPHSCL电路
沙漠的甲壳虫的博客
06-07 4837
时钟电路
STM32使用模拟IIC实现24C02读取
yuangaoping的专栏
11-09 5046
1.与硬件IIC的比较 1.1.使用灵活 可使用任意2个IO口实现，不用受芯片管脚限制； 1.2.速率快 通过调整延时，可以实现超过400k的速率，实际测试最大速率接近800k； 1.3.容错性强 硬件IIC在通信出错后，无法自行恢复，模拟IIC则可以迅速恢复； 2.底层接口函数 2.1. I2C_Start 2.2. I2C_Stop 2.3. I2C_SendACK
STM32软件模拟实现IIC写入和读取AT24C02（STM32CubeMx配置）
a1169511636的博客
07-13 4098
基于STM32软件模拟IIC对AT24C02进行写入和读取
AT24CXX系列芯片调试记录
liudong200618的博客
03-18 755
AT24CXX系列芯片调试记录前言在调试AT24C32芯片时，曾经遇到过内容读写不正常的问题，因此，在此记录一下遇到的问题以及解决的方法。问题在使用GD32F470的芯片驱动AT24C32芯片时，直接从GD的官网下载eeprom读写例程，官网的例程是驱动AT24C02的，但是在读写AT24C32芯片的内存时不正常。原因。
24c04与数码管工作原理
10-26
它的工作原理是通过I2C总线来与控制器通信。在读取数据时，控制器首先发送起始信号，然后发送器件地址和读取命令，24C04会返回对应地址存储的数据。在写入数据时，控制器也需要发送起始信号、器件地址和写入命令，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值