MCU--新塘N76E003--IIC

客官°小女子只卖身不卖艺 2023-01-20 09:57 130阅读 0赞

I2C 总线提供了一种串行通信方式，用在 MCU 与 EEPROM，LCD模块，温度传感器等等之间控制。  
I2C 用两条线 (数据线SDA 和时钟线 SCL) 在设备间传输数据。  
I2C 总线用作主机与从机之间双向数据传输。可以用于多主机系统，支持无中央主机及多主机系统，主机与主机之间的总线仲载传输，同步时钟SCL的存在，允许设备间使用不同比特率的数据传输。支持四种传输模式：主发，主收，从发，从收。  
I2C 总线仅支持 7位地址。支持广播呼叫，支持标准速率传输 (100kbps) 和快速传输( 400k bps)

功能描述  
对于双向传输操作，SDA 及SCL 引脚必须配置成开漏模式，形成逻辑线与功能：总线上当有一个器件输出0，总  
线上就是0电平，所有器件全输出1，总线上才是高电平，需要通过外接上拉电阻把电平拉高。N76E003, 在设置  
I2CEN (I2CON.6)使能I2C功能之前，必须把SCL，SDA的输出锁存在逻辑1的状态。

![c045fda55a6296ec85bf46efc1213f47.png][]

I2C 空闲时，两条线都为高。这时任一设备都可以做为主机发个起始位 START 开始数据传输，在停止位 STOP  
出现之前，总线被认为处于忙状态。主机产生串行时钟脉冲以及起始位和停止位。如果总线上没有START起始  
信号，则所有总线设备被认为未被寻址从机，硬件自动匹配自己的从机地址或广播呼叫地址，(广播地址可由 GC  
(I2ADDR.0)使能或禁止.)。若地址匹配，就产生中断。  
I2C总线上传输的每个字节都包含8个数据位(MSB优先)和一个应答位，共9位。但每次传输的字节个数没有明确  
界定(起始位 START 和停止位 STOP之间的字节个数) ，但每个字节都应有一个应答位。主机产生8个时钟脉  
冲，以传输8位数据。在第8个时钟SCL下沿后，由SDA脚输出数据后，SDA转为输入模式在第9个时钟脉冲以读取第9位应答位。在第9个时钟脉冲后，数据接收端若没准备好接收下一个字节，可以拉住时钟线保持低，让传输挂起。接收端释放时钟线SCL以后，传输继续。

![2797b9cd4a1b4c1888de357750531cdd.png][]

开始和停止条件  
I2C 总线时序定义了起始START (S)和结束STOP (P)的条件。时钟SCL为高时，数据线SDA由高电平至低电平的跳变被认为是起始START标志。时钟SCL为高时，数据线SDA由低电平至高电平的跳变被认为是结束STOP标志。起始和结束都由主机产生，起始和结束之间被认为是总线忙状态。当成功判定结束条件以后，主机释放总  
线，所有设备都回到监听总线起始位状态，之前被呼叫从机也转为未寻址从机。  
I2C总线进入空闲状态等待下一个起始START信号，开始下一次传输。  
主机若发出停止位STOP，传输就停止了。然而，主机也可以不发停止位，而是再次发出起始START信号（Sr）继续和上个地址通信，或者换个地址继续通信。各种读/写组合格式操作可能存在一个传输中。

![4b40643d212296f5d21ffdbba5d22e41.png][]

7位地址数据格式  
起始位 START 之后, 第一个字节必须是“7位地址SLA+第8位读写方向位( W)”，用以定义目标从机地址以及从*机写入或读出数据。若第8位是0，即SLA+W，表示下个字节开始主机向从机写数据；若是1，即SLA+R，就表*

示下字节开始，主机向从机读数据。所以，一个典型数据包含起始位 START，SLA+W/R，一个或多个字节数据，最后是停止位 STOP。当一个从机已被寻址及读写方向通过字节SLA+W/R，随后的8位数据就跟随之前的设定进行传输。  
I2C总线还有一种特殊寻址方式，广播呼叫寻址。  
在该模式下，发送的首字节数据为0。  
广播呼叫模式应用于主机希望向所有从机传输相同数据。当此寻址方式启用。收到广播要不要发应答由软件决定。若某个从机发了应答，这个从机就收发后续数据，和标准从机接收方式相同。注意：地址0x00默认用于广播呼叫方式，不能用于普通从机地址。因此理论上，总共7位地址I2C 总线，共可以连接127个设备，地址由1至127。

![de7973ccdeb20e6cba96effb6d6d7f7e.png][]在数据传输过程中，在时钟高电平时，SDA需要保持数据内容不能更改。只有在SCL为低时，SDA内容可以改变。

应答ACK  
每字节传输SCL第9个脉冲用于传输应答位 (ACK)。通过将SDA拉低，来允许接收端（无论主机或是从机）回应发送端（无论主机或从机）。应答位时钟由主机产生。发送端设备在应答位时钟高电平周期内，需放弃对SDA的控制。ACK 为一个低电平信号。在应答位时钟周期的高电平时，SDA保持低电平用以表示接收端已成功接收到发送端的数据。通常被寻址的从机在整个传输过程中每字节都需要回复应答位。当该从机接收无法应答（NACK）从机地址时，从机将SDA线保持高以便主机产生停止(STOP)或发送重复开始(START)信号。

若从机接收没有应答从机地址后，将自身切换到未寻址从机模式，从而无法接收更多数据字节。这时从机将SDA线拉高，此时主机应发送停止STOP信号或重复起始(repeated START)信号。

若是主机接收，主机控制着收发字节个数，主机在最后一个字节收发结束后不发应答位信号，从机端将切换为未寻址从机模式，并释放SDA线，以便主机直接发停止位STOP 或重开始位START。

*![209fc6d72832ad3c7392b2dc63e37c54.png][]*

仲裁  
主机仅可在总线空闲时发起传输。可能有多个器件同时发开始位START试图发起数据传输，这时就会出现总线  
仲裁。在该状态下，当SCL为高时，SDA上呈现仲裁信号。在仲裁过程中，第一个发起主机对SDA线置1（高电  
平）而另一个主机发送0（低电平），发送后主机会对SDA线上信号与自己发出的信号进行比较，由于“线与”  
的原因，时钟SCL为高时，发送0的主机会成功，而发送1的主机会失败。发送失败的主机立刻切换自身到未被寻  
址的从机状态，以确保自身能被仲裁胜利的主机寻址到。同时也释放数据线，并回到地址侦测状态，仲载失败的  
主机，仍会发送时钟，直到当前字节结束。  
仲裁机制让每个主机发送数据时，都会同时比较总线上的数据是否与自己发送的一致。注：如果其它主机发送  
0，发送1的主机会在仲裁中失败，仲裁会持续到总线上只有一个主机。如两个主机同时向一个从机发数据时，地  
址相同，仲裁会在第二个字节持续。

![c56783d08138dab8346b46fd7799f3f0.png][]

I2C 总线的这种仲裁机制，让总线上的设备可以有多个主机，而且没有优先等级。从机不介入仲裁。

I2C控制寄存器  
I2C共有五个控制寄存器： I2CON, I2STAT, I2DAT, I2ADDR, 和 I2CLK. 这些寄存器用以提供协议控制，状态显示，数据传输、接收以及时钟速率控制。为灵活应用，配置I2CPX (I2CON.0)可以交换SDA，SCL引脚功能。

![b346073d31f90dde8cae0b4f6fb5b00c.png][]

![b96f5a566ef3268bf61b76b80ef5a453.png][]

![93798eb89b7fbf4905a1ce03fd219b68.png][]

![b053cb0805df3115f4243ac303821c7d.png][]

![a93b6133f16af5b0c6a0e5ebd88b86cb.png][]

![7f90a32748b8a1574410f37e3aeccfa7.png][]

工作模式  
I2C 协议定义了四种模式：主机发送，主机接收，从机发送，从机接收。还有一种特殊模式广播呼叫模式，其操作方式与从机接收模式类似。

主机发送模式   
主机发送多个字节到从机，主机产生时钟，故需要在I2CLK内填入设定值。主机发送模式需要将STA (I2CON.5) 置1。此时，一旦检测到总线空闲，主机就会发出一个起始位START，若成功, SI(I2CON.3) 将被置1，状态码I2STAT置为08H。接下来应把从机地址和写位(SLA+W)写入 I2DAT ，然后清0位SI，总线上发出SLA+W。  
主机发出SLA+W 收到从机应答位ACK后， SI被置1，状态码I2STAT = 18H。接下来将按照用户定义格式发送数据。所有的数据发送完以后，位 STO (I2CON.4)置1，并清除SI位以发出停止信号STOP，或者也可以发送重复起始信号repeat START，而不发送STOP，直接开始新一轮数据传输。

![3f015050c33710f0070b97422a9f6451.png][]

主机接收模式  
主机接收模式，由从机传输数据。初始化设置与主机发送模式相同，主机发送起始位以后， I2DAT 应写入从机地址和“读位” (SLA+R)。收到从机应答位ACK后 SI 被置1且状态码 I2STAT= 40H。 SI 清0后开始接收从机数据，若 AA 位 (I2CON.2) =1，主机收到数据后回应答位；若 AA =0主机收到数据后不回应答NACK。然后主机可以发停止位或重起始开始新一轮传输。

*![96accd8f83000fcac496fdece50ed296.png][]*

从机接收模式  
在从机接收模式下，从机接收主机发来的数据。在传输开始前，I2ADDR 应写入从机地址，I2CLK内容无效，AA置1用以响应主机的寻址。上述初始化后，从机进入空闲模式，等待“写”信号（SLA+W）。若主机仲裁失败，也会直接进入从机接收模式。

当从机被“写”信号SLA+W寻址到后，需要清0 SI位，以便从主机接收数据。如果在传输过程中AA=0，从机将在下一字节返回无应答位NACK，从机也将转为未寻址从机，与主机联系终止，不再接收数据，且I2DAT保持之*前接收到的数据。*

*![5acede770624b8c0522768ba726deba6.png][]*

从机发送模式  
从机发送模式，数据由从机发送给主机。当初始化I2ADDR及I2CON值后，器件等待直到自身地址被“读”信号*(SLA+R)寻址。若主机仲裁失败，也可进入从机发送模式。*

*当从机被“读”信号SLA+R寻址，需要将SI信号清0用以向主机发送数据。通常主机接收每字节数据后会返回应**答位，如果没有接收到应答位，接下去的传输中，从机将发送全1数据。并变为未寻址从机。如果传输过程中AA**清0 ，从机将发送最后一个字节数据，并在接下去的传输中发送全1数据，并将自身变为未寻址从机。*

*![05d08e94402f485c5be2219ca253c998.png][]*

各状态码表述   
I2STAT状态寄存器中,有两种状态码不归属25种之前所述状态：F8H 及 00H。  
F8H 用以标示在之前的传输中没有有效信息，意味着，SI标志位为0且无I2C 中断产生。  
00H 标示在传输过程中，有总线错误发生。总线错误是指START 或 STOP在传输的过程中出现在错误的位置，例如在地址或数据的第二位或应答位。当总线发生错误，SI标志马上会被置1，工作中的节点设备马上切换到未被寻址从机模式，释放SDA 和SCL，并将I2STAT寄存器清0。要恢复总线状态，需要置位STO位并清除SI位，然后STO会由硬件清0，而不需要真正的STOP信号波形，释放总线恢复到正常空闲状态。  
有一种特殊情况，当SDA线被强制拉低导致阻塞，START信号或重复起始(repeat START)信号无法成功产生时，从机将失去同步。解决方法是在SCL线上额外多送一个时钟脉冲。通过将STA位置1，总线上产生额外的时钟脉冲，由于SDA始终拉低，SDA线上不会产生START信号。一旦SDA线被释放，正常的START信号送出，状态寄存器上会显示08H，串行传输继续。相同的状况，如果需要发送重复开始 (repeated START)信号受阻，也可以采用上述方式。在上述方式完成传输后，状态寄存器显示10H，而不是显示08H。注：软件无法介入上述总线问题传输。

![a2dd00dba7feac5733379c3f249aeb29.png][]

![779c8491d55e6d49a17ce4bdfadd2a03.png][]

重要说明： 当总线上看到的STATUS 为总线错误（bus error）时， I2C为持续使能状态，由于对I2C模块来说错误并没有清除，无法直接用清除 SI 的方式来停止总线错误，故SI会保持在1。所以，如果程序中用SI来判定当下I2C状态并继续流程时，建议用下述方法来增加程序的稳定性。  
解决方法：  
– 通过对总线送出Stop信号  
– 如果送出Stop仍然无效，说明时序已被打乱，需要对I2C总线传输进行关闭再重新开始传输。

I*2**C 超时溢出*

*N76E003带一组14位超时计数器，用于防止I**2**C总线故障。一旦使能了超时定时器，计数器开始计数直至溢出，*

*即如果开启中断，I2TOF位会被硬件置1。当使能计数器，SI置1复位计数器， SI清0后重新开始计数。*

若I*2**C总线**出现故障，SI 位长时间不能清0，14位的超时定时器就会溢出，并进入中断。*

![d6e1e6d40880911eb658cce09853c30d.png][]

![e70aad8d6cbb7af18079492682025805.png][]

I2C 中断  
I2C的两个标志位：SI 和 I2TOF。这两个标志都会产生I2C事件中断请求。如果 EI2C (EIE.0) = 1且 EA = 1,当两个标志中的任意一个发生时， CPU 就会去执行中断代码。用户可以读取这两个标志位，来确定中断产生的原因。这两个标志需软件清0。  
另外，当使用I2C超时寄存器功能时，必须打开I2C中断用来配合超时的时序，否则I2C超时计数标志不会产生置位。

/*---------------------------------------------------------------------------------------------------------*/
    /*                                                                                                         */
    /* Copyright(c) 2017 Nuvoton Technology Corp. All rights reserved.                                         */
    /*                                                                                                         */
    /*---------------------------------------------------------------------------------------------------------*/
    
    //***********************************************************************************************************
    //  Nuvoton Technoledge Corp. 
    //  Website: http://www.nuvoton.com
    //  E-Mail : MicroC-8bit@nuvoton.com
    //  Date   : Jun/21/2017
    //***********************************************************************************************************
    
    //***********************************************************************************************************
    //  File Function: N76E003 I2C demo code, Slave Address of 24LC64 = 0xA0
    //
    //   ____________           ______________ 
    //  |            |   SDA    |             |
    //  |            |<-------->|             |
    //  |            |          |             |
    //  |N76E003(M) |          |   24LC64(S) |
    //  |            |   SCL    |             |
    //  |            |--------->|             |
    //  |____________|          |_____________|
    //
    //  Microchip I2C EEPROM 24xx64 (64K Bit) is used as the slave device.  
    //  The page size are 32Byte. Total are 256 page.
    //  If verification passes, Port3 will show 0x78. If there is any failure
    //  occured during the progress, Port3 will show 0x00.
    //***********************************************************************************************************
    
    #include "N76E003.h"
    #include "SFR_Macro.h"
    #include "Function_define.h"
    #include "Common.h"
    #include "Delay.h"
    
    #define SYS_CLK_EN              0
    #define SYS_SEL                 2
    #define SYS_DIV_EN              0                   //0: Fsys=Fosc, 1: Fsys = Fosc/(2*CKDIV)
    #define SYS_DIV                 1
    #define I2C_CLOCK               2
    
    #define EEPROM_SLA              0xA0
    #define EEPROM_WR               0
    #define EEPROM_RD               1
    
    #define LED                     P3
    #define PAGE_SIZE               32
    #define PAGE_NUMBER             4
    
    #define ERROR_CODE              0x78
    #define TEST_OK                 0x00
    
    bit I2C_Reset_Flag;
    //========================================================================================================
    void Init_I2C(void)
    {
            P13_OpenDrain_Mode;                    // Modify SCL pin to Open drain mode. don't forget the pull high resister in circuit
            P14_OpenDrain_Mode;                    // Modify SDA pin to Open drain mode. don't forget the pull high resister in circuit
        
        /* Set I2C clock rate */
        I2CLK = I2C_CLOCK; 
    
        /* Enable I2C */
        set_I2CEN;                                   
    }
    //========================================================================================================
    void I2C_SI_Check(void)
    {
            if (I2STAT == 0x00)
            {
                    I2C_Reset_Flag = 1;
                    set_STO;
                    SI = 0;
                    if(SI)
                    {
                            clr_I2CEN;
                            set_I2CEN;
                            clr_SI;
                            clr_I2CEN;        
                    }     
            }    
    }
    
    void One_Page_Read(UINT8 u8PageNumber,UINT8 u8DAT)
    {
        UINT8  u8Count;
        UINT16 u16Address;
    
        u16Address = (UINT16)u8PageNumber*32;
    
        /* Step1 */
        set_STA;                                /* Send Start bit to I2C EEPROM */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x08)                     /* 0x08:  A START condition has been transmitted*/
        {
            I2C_Reset_Flag = 1;
                    printf("\nI2C 'Send STA' error");
                    goto Read_Error_Stop;
        }
    
        /* Step2 */
        I2DAT = (EEPROM_SLA | EEPROM_WR);       /* Send (SLA+W) to EEPROM */
        clr_STA;                                /* Clear STA and Keep SI value in I2CON */    
        clr_SI;
        while (!SI);
        if (I2STAT != 0x18)                     /* 0x18: SLA+W has been transmitted; ACK has been received */              
        {
                    I2C_Reset_Flag = 1;
            printf("\nI2C 'Send SLA+W' error");
                    goto Read_Error_Stop;
        }
    
        /* Step3 */
        I2DAT = HIBYTE(u16Address);             /* Send I2C EEPROM's High Byte Address */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x28)                     /* 0x28:  Data byte in S1DAT has been transmitted; ACK has been received */              
        {
                    I2C_Reset_Flag = 1;
            printf("\nI2C 'Send I2C High Byte Address' error");
                    goto Read_Error_Stop;
        }
    
        /* Step4 */
        I2DAT = LOBYTE(u16Address);             /* Send I2C EEPROM's Low Byte Address */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x28)                     /* 0x28:  Data byte in S1DAT has been transmitted; ACK has been received */             
        {
                    I2C_Reset_Flag = 1;
                    printf("\nI2C 'Send I2C Low Byte Address' error");
                    goto Read_Error_Stop;
        }
    
        /* Step5 */
        set_STA;                                /* Repeated START */
        clr_SI; 
        while (!SI);
        if (I2STAT != 0x10)                     /* 0x10: A repeated START condition has been transmitted */
        {
                    I2C_Reset_Flag = 1;
            printf("\nI2C 'Send STA' error");
                    goto Read_Error_Stop;
        }
    
        /* Step6 */
        clr_STA;                                /* Clear STA and Keep SI value in I2CON */
        I2DAT = (EEPROM_SLA | EEPROM_RD);       /* Send (SLA+R) to EEPROM */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x40)                     /* 0x40:  SLA+R has been transmitted; ACK has been received */              
        {
                    I2C_Reset_Flag = 1;
            printf("\nI2C 'Send SLA+R' error");
                    goto Read_Error_Stop;
        }
    
        /* Step7 */                             /* Verify I2C EEPROM data */
        for (u8Count = 0; u8Count <PAGE_SIZE; u8Count++)
        {
            set_AA;                             /* Set Assert Acknowledge Control Bit */
            clr_SI;
            while (!SI);
            if (I2STAT != 0x50)                 /* 0x50:Data byte has been received; NOT ACK has been returned */              
            {
                            I2C_Reset_Flag = 1;
                printf("\nI2C 'No Ack' error");
                            goto Read_Error_Stop;
            }
           
            if (I2DAT != u8DAT)                 /* Send the Data to EEPROM */    
            {
                            I2C_Reset_Flag = 1;
                            printf("\nI2C 'Read data' error");
                goto Read_Error_Stop;
            }
            u8DAT = ~u8DAT; 
        }
    
        /* Step8 */
        clr_AA;                                 /* Send a NACK to disconnect 24xx64 */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x58)                     /* 0x58:Data byte has been received; ACK has been returned */
        {
            I2C_Reset_Flag = 1;
            printf("\nI2C 'Ack' error");
            goto Read_Error_Stop;
        }
        
        /* Step9 */    
          clr_SI;
        set_STO;
            while (STO)                        /* Check STOP signal */
            {
                I2C_SI_Check();
                if (I2C_Reset_Flag)
                    goto Read_Error_Stop;
            }
            
    Read_Error_Stop: 
            if (I2C_Reset_Flag)
            {
                    I2C_SI_Check();
                  printf("\nI2C Read error, test stop");
                    I2C_Reset_Flag = 0;
            }
    }
    //========================================================================================================
    void One_Page_Write(UINT8 u8PageNumber,UINT8 u8DAT)
    {
        UINT8  u8Count;
        UINT16 u16Address;
    
        u16Address = (UINT16)u8PageNumber*32;
    
        /* Step1 */
        set_STA;                                /* Send Start bit to I2C EEPROM */         
        clr_SI;
        while (!SI);
        if (I2STAT != 0x08)                     /* 0x08:  A START condition has been transmitted*/
        {
            I2C_Reset_Flag = 1;
            printf("\nI2C 'Send STA' error");
            goto Write_Error_Stop;
        }
    
        /* Step2 */
        clr_STA;                                /* Clear STA and Keep SI value in I2CON */
        I2DAT = EEPROM_SLA | EEPROM_WR;         /* Send (SLA+W) to EEPROM */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x18)                     /* 0x18: SLA+W has been transmitted; ACK has been received */             
        {
            I2C_Reset_Flag = 1;
            printf("\nI2C 'Send SLA+W' error");
            goto Write_Error_Stop;
        }
    
        /* Step3 */
        I2DAT = HIBYTE(u16Address);             /* Send EEPROM's High Byte Address */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x28)                     /* 0x28:  Data byte in S1DAT has been transmitted; ACK has been received */
        {
            I2C_Reset_Flag = 1;
            printf("\nI2C 'Send High byte address' error");
            goto Write_Error_Stop;
        }
    
        /* Step4 */
        I2DAT = LOBYTE(u16Address);             /* Send EEPROM's Low Byte Address */
        clr_SI;
        while (!SI);
        if (I2STAT != 0x28)                     /* 0x28:  Data byte in S1DAT has been transmitted; ACK has been received */
        {
            I2C_Reset_Flag = 1;
            printf("\nI2C 'Send Low byte address' error");
            goto Write_Error_Stop;
        }
    
        /* Step5 */
                                                /* Write data to I2C EEPROM */
        for (u8Count = 0; u8Count < PAGE_SIZE; u8Count++)
        {
            I2DAT = u8DAT;                      /* Send data to EEPROM */
            clr_SI;
            while (!SI);
            if (I2STAT != 0x28)                 /* 0x28:  Data byte in S1DAT has been transmitted; ACK has been received */
            {
                I2C_Reset_Flag = 1;
                            printf("\nI2C 'Write Data' error");
                goto Write_Error_Stop;
            }   
            u8DAT = ~u8DAT;        
        }
                                                //After STOP condition, a inner EEPROM timed-write-cycle 
                                                //will occure and EEPROM will not response to outside command
                                                /* 0x18: SLA+W has been transmitted; ACK has been received */
        /* Step6 */
        do
        {
                  set_STO;                            /* Set I2C STOP Control Bit */
            clr_SI;
            while (STO)                        /* Check STOP signal */
                    {
                        I2C_SI_Check();
                        if (I2C_Reset_Flag)
                            goto Write_Error_Stop;
                    }
            
            set_STA;                            /* Check if no ACK is returned by EEPROM, it is under timed-write cycle */
            clr_SI;
            while (!SI);
            if (I2STAT != 0x08)                 /* 0x08:  A START condition has been transmitted*/
            {
                I2C_Reset_Flag = 1;
                printf("\nI2C 'Wait Ready' error");
                goto Write_Error_Stop;
            }
    
            clr_STA;                            /* Clear STA and Keep SI value in I2CON */
            I2DAT = (EEPROM_SLA | EEPROM_WR);   /* Send (SLA+W) to EEPROM */
            clr_SI;
            while (!SI);
        }while(I2STAT != 0x18);
    
        /* Step7 */
        set_STO;                                /* Set STOP Bit to I2C EEPROM */
        clr_SI;
            while (STO)                        /* Check STOP signal */
            {
                I2C_SI_Check();
                if (I2C_Reset_Flag)
                    goto Write_Error_Stop;
            }
            
    Write_Error_Stop: 
            if (I2C_Reset_Flag)
            {
                    I2C_SI_Check();
                    I2C_Reset_Flag    = 0;
                    printf("\nI2C Write error, test stop");
            }
            
            
    }
    //========================================================================================================
    void main(void)
    {
    
        Set_All_GPIO_Quasi_Mode;
            InitialUART0_Timer3(115200);
      
        /* Initial I2C function */
        Init_I2C();                                 //initial I2C circuit
        
        /* page0 R/W */
        printf ("\n\n24LC64 Page0 Write (0x55,0xAA...)...");
        One_Page_Write(0,0x55);                     //page0, write 0x55,0xAA,........
    
        printf ("\n\n24LC64 Page0 Read...");
        One_Page_Read (0,0x55);                     //page0, read  0x55,0xAA,........
    
        /* page1 R/W */
        printf ("\n\n24LC64 Page1 Write (0x00,0xFF...)...");
        One_Page_Write(1,0x00);                     //page1, write 0x00,0xFF,........
        printf ("\n\n24LC64 Page1 Read...");
        One_Page_Read (1,0x00);                     //page1, read  0x00,0xFF,........
    
        /* page2 R/W */
        printf ("\n\n24LC64 Page2 Write (0xAA,0x55...)...");
        One_Page_Write(2,0xAA);                     //page2, write 0xAA,0x55,........
        printf ("\n\n24LC64 Page2 Read...");
        One_Page_Read (2,0xAA);                     //page2, read  0xAA,0x55,........
    
        /* page3 R/W */
        printf ("\n\n24LC64 Page3 Write (0xFF,0x00...)...");
        One_Page_Write(3,0xFF);                     //page3, write 0xFF,0x00,........
        printf ("\n\n24LC64 Page3 Read...");
        One_Page_Read (3,0xFF);                     //page3, read  0xFF,0x00,........
    
        /* page255 R/W */
        printf ("\n\n24LC64 Page255 Write (0x0F,0xF0...)...");
        One_Page_Write(255,0x0F);                   //page255, write 0x0F,0xF0,........
        printf ("\n\n24LC64 Page255 Read...");
        One_Page_Read (255,0x0F);                   //page255, read  0x0F,0xF0,........
    
        /* ==== Test Pass ==== */      
        printf ("\n\N76E003 <--> 24LC64, I2C Demo Code test pass...");
    
        while (1);
    /* =================== */
    }

[c045fda55a6296ec85bf46efc1213f47.png]: /images/20221021/fc1fdb37f83e4957a1cc5eae8686f353.png
[2797b9cd4a1b4c1888de357750531cdd.png]: /images/20221021/e4c3caa166d64114a9772b0d614704e7.png
[4b40643d212296f5d21ffdbba5d22e41.png]: /images/20221021/198de9c8d43d403bb87f4db60ed2cd36.png
[de7973ccdeb20e6cba96effb6d6d7f7e.png]: /images/20221021/8f205918c13d476c9b0c238656c2b654.png
[209fc6d72832ad3c7392b2dc63e37c54.png]: /images/20221021/255350a39fb84511ab775926fc4ec6a6.png
[c56783d08138dab8346b46fd7799f3f0.png]: /images/20221021/e96bce6e37564c7088edacedb17339d4.png
[b346073d31f90dde8cae0b4f6fb5b00c.png]: /images/20221021/2834db76d566487c969fa604ff96f0fd.png
[b96f5a566ef3268bf61b76b80ef5a453.png]: /images/20221021/6a61d9c11fd84aa6a89339595f1b9f5c.png
[93798eb89b7fbf4905a1ce03fd219b68.png]: /images/20221021/b63ba7ebfb984b099ac3ca12094c2c87.png
[b053cb0805df3115f4243ac303821c7d.png]: /images/20221021/d06fa767043448e88d2bf69543402d73.png
[a93b6133f16af5b0c6a0e5ebd88b86cb.png]: /images/20221021/07b6a5a919d546dcb715098e8b748ce3.png
[7f90a32748b8a1574410f37e3aeccfa7.png]: /images/20221021/54ee36f6bb274378898ff388b2099b8f.png
[3f015050c33710f0070b97422a9f6451.png]: /images/20221021/bf097c1aa1894275971422ff54cef009.png
[96accd8f83000fcac496fdece50ed296.png]: /images/20221021/4bd103bafa8b4b2fa458e2c9b26be423.png
[5acede770624b8c0522768ba726deba6.png]: /images/20221021/fff5e2bfe9e74448b2147714717b9eee.png
[05d08e94402f485c5be2219ca253c998.png]: /images/20221021/9c2de389307b463c9e7c810658d689c5.png
[a2dd00dba7feac5733379c3f249aeb29.png]: /images/20221021/1bdf61fd012349beabb3537744a1a005.png
[779c8491d55e6d49a17ce4bdfadd2a03.png]: /images/20221021/06b486894b5c4970bb20fccd5f3c8c29.png
[d6e1e6d40880911eb658cce09853c30d.png]: /images/20221021/75bf50b7e6ce425fba98c477eb93885f.png
[e70aad8d6cbb7af18079492682025805.png]: /images/20221021/425c05726820480d8d28f263825910c4.png