NUC123单片机的I2C从机模式

发表于 2017-10-23 20:25

/**************************************************************************//**

 * [url=home.php?mod=space&uid=288409]@file[/url]     main.c

 * [url=home.php?mod=space&uid=895143]@version[/url]  V3.00

 * $Revision: 18 $

 * $Date: 16/06/21 7:43p $

 * @brief

 *           Demonstrate how to set I2C in slave mode to receive the data from a Master.

 *           This sample code is EEPROM like, only support 256 bytes.

 *           Needs to work with I2C_Master sample code.

 * @note

 * Copyright (C) 2014~2015 Nuvoton Technology Corp. All rights reserved.

 *

 ******************************************************************************/

#include <stdio.h>

#include "NUC123.h"



#define PLLCON_SETTING      CLK_PLLCON_72MHz_HXT

#define PLL_CLOCK           72000000



uint32_t slave_buff_addr;

uint8_t g_au8SlvData[256];

uint8_t g_au8SlvRxData[3];

/*---------------------------------------------------------------------------------------------------------*/

/* Global variables                                                                                        */

/*---------------------------------------------------------------------------------------------------------*/

volatile uint8_t g_u8DeviceAddr;

volatile uint8_t g_u8SlvDataLen;



typedef void (*I2C_FUNC)(uint32_t u32Status);



static I2C_FUNC s_I2C0HandlerFn = NULL;



/*---------------------------------------------------------------------------------------------------------*/

/*  I2C0 IRQ Handler                                                                                       */

/*---------------------------------------------------------------------------------------------------------*/

void I2C0_IRQHandler(void)

{

    uint32_t u32Status;



    u32Status = I2C_GET_STATUS(I2C0);



    if(I2C_GET_TIMEOUT_FLAG(I2C0))

    {

        /* Clear I2C0 Timeout Flag */

        I2C_ClearTimeoutFlag(I2C0);

    }

    else

    {

        if(s_I2C0HandlerFn != NULL)

            s_I2C0HandlerFn(u32Status);

    }

}



/*---------------------------------------------------------------------------------------------------------*/

/*  I2C TRx Callback Function                                                                              */

/*---------------------------------------------------------------------------------------------------------*/

void I2C_SlaveTRx(uint32_t u32Status)

{

    uint8_t u8data;

    

    if(u32Status == 0x60)                       /* Own SLA+W has been receive; ACK has been return */

    {

        g_u8SlvDataLen = 0;

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }

    else if(u32Status == 0x80)                 /* Previously address with own SLA address

                                                   Data has been received; ACK has been returned*/

    {

        u8data = (unsigned char) I2C_GET_DATA(I2C0);   

        if(g_u8SlvDataLen < 2)        

        {

            g_au8SlvRxData[g_u8SlvDataLen++] = u8data;        

            slave_buff_addr = (g_au8SlvRxData[0] << 8) + g_au8SlvRxData[1];            

        }

        else 

        {

            g_au8SlvData[slave_buff_addr++] = u8data;

            if(slave_buff_addr==256)

            {

                slave_buff_addr = 0;

            }            

        }            



        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }

    else if(u32Status == 0xA8)                  /* Own SLA+R has been receive; ACK has been return */

    {

        I2C_SET_DATA(I2C0, g_au8SlvData[slave_buff_addr]);

        slave_buff_addr++;

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }

    else if(u32Status == 0xB8)                  /* Data byte in I2CDAT has been transmitted ACK has been received */

    {

        I2C_SET_DATA(I2C0, g_au8SlvData[slave_buff_addr++]);

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }    

    else if(u32Status == 0xC0)                 /* Data byte or last data in I2CDAT has been transmitted

                                                   Not ACK has been received */

    {

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }

    else if(u32Status == 0x88)                 /* Previously addressed with own SLA address; NOT ACK has

                                                   been returned */

    {

        g_u8SlvDataLen = 0;

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }

    else if(u32Status == 0xA0)                 /* A STOP or repeated START has been received while still

                                                   addressed as Slave/Receiver*/

    {

        g_u8SlvDataLen = 0;

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);

    }

    else

    {

        /* TO DO */

        printf("Status 0x%x is NOT processed\n", u32Status);

    }

}



void SYS_Init(void)

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init System Clock                                                                                       */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Enable XT1_OUT (PF0) and XT1_IN (PF1) */

    SYS->GPF_MFP |= SYS_GPF_MFP_PF0_XT1_OUT | SYS_GPF_MFP_PF1_XT1_IN;



    /* Enable Internal RC 22.1184MHz clock */

    CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);



    /* Waiting for Internal RC clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));



    /* Enable external XTAL 12MHz clock */

    CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);



    /* Waiting for external XTAL clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);



    /* Set core clock as PLL_CLOCK from PLL */

    CLK_SetCoreClock(PLL_CLOCK);



    /* Enable UART module clock */

    CLK_EnableModuleClock(UART0_MODULE);



    /* Enable I2C0 module clock */

    CLK_EnableModuleClock(I2C0_MODULE);



    /* Select UART module clock source */

    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));



    /*---------------------------------------------------------------------------------------------------------*/

    /* Init I/O Multi-function                                                                                 */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Set GPB multi-function pins for UART0 RXD and TXD */

    SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;



    /* Set GPF multi-function pins for I2C0 SDA and SCL */

    SYS->GPF_MFP |= (SYS_GPF_MFP_PF2_I2C0_SDA | SYS_GPF_MFP_PF3_I2C0_SCL);

    SYS->ALT_MFP1 &= ~(SYS_ALT_MFP1_PF2_Msk | SYS_ALT_MFP1_PF3_Msk);

    SYS->ALT_MFP1 |= (SYS_ALT_MFP1_PF2_I2C0_SDA | SYS_ALT_MFP1_PF3_I2C0_SCL);

}



void UART0_Init()

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init UART                                                                                               */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Reset IP */

    SYS_ResetModule(UART0_RST);



    /* Configure UART0 and set UART0 Baudrate */

    UART_Open(UART0, 115200);

}





void I2C0_Init(void)

{

    /* Open I2C module and set bus clock */

    I2C_Open(I2C0, 100000);



    /* Get I2C0 Bus Clock */

    printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));



    /* Set I2C 4 Slave Addresses */

    I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */

    I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */

    I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */

    I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */



    /* Set I2C 4 Slave Addresses Mask */

    I2C_SetSlaveAddrMask(I2C0, 0, 0x01);

    I2C_SetSlaveAddrMask(I2C0, 1, 0x04);

    I2C_SetSlaveAddrMask(I2C0, 2, 0x01);

    I2C_SetSlaveAddrMask(I2C0, 3, 0x04);



    /* Enable I2C interrupt */

    I2C_EnableInt(I2C0);

    NVIC_EnableIRQ(I2C0_IRQn);

}



void I2C0_Close(void)

{

    /* Disable I2C0 interrupt and clear corresponding NVIC bit */

    I2C_DisableInt(I2C0);

    NVIC_DisableIRQ(I2C0_IRQn);



    /* Disable I2C0 and close I2C0 clock */

    I2C_Close(I2C0);

    CLK_DisableModuleClock(I2C0_MODULE);



}



/*---------------------------------------------------------------------------------------------------------*/

/*  Main Function                                                                                          */

/*---------------------------------------------------------------------------------------------------------*/

int32_t main(void)

{

    uint32_t i;



    /* Unlock protected registers */

    SYS_UnlockReg();



    /* Init System, IP clock and multi-function I/O */

    SYS_Init();



    /* Init UART0 for printf */

    UART0_Init();



    /* Lock protected registers */

    SYS_LockReg();



    /*

        This sample code sets I2C bus clock to 100kHz. Then, Master accesses Slave with Byte Write

        and Byte Read operations, and check if the read data is equal to the programmed data.

    */



    printf("+----------------------------------------------------+\n");

    printf("|  I2C Driver Sample Code(Slave) for access Slave    |\n");

    printf("|  Needs to work with I2C_Master sample code.        |\n");

    printf("|  I2C Master (I2C0) <---> I2C Slave(I2C0)           |\n");

    printf("| !! This sample code requires two borads to test !! |\n");

    printf("+----------------------------------------------------+\n");



    printf("Configure I2C0 as a slave.\n");

    printf("The I/O connection for I2C0:\n");

    printf("I2C0_SDA(PF.2), I2C0_SCL(PF.3)\n");



    /* Init I2C0 */

    I2C0_Init();



    /* I2C enter no address SLV mode */

    I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI_AA);



    for(i = 0; i < 0x100; i++)

    {

        g_au8SlvData[i] = 0;

    }



    /* I2C function to Slave receive/transmit data */

    s_I2C0HandlerFn = I2C_SlaveTRx;



    printf("\n");

    printf("I2C Slave Mode is Running.\n");



    while(1);

}

发表于 2017-10-23 20:25

好多人I2C总是弄的不对，建议多看看官方的例子的设置顺序。

发表于 2017-10-23 20:26

这里也提供下主机模式的使用方法

复制

/**************************************************************************//**

 * @file     main.c

 * @version  V3.00

 * $Revision: 16 $

 * $Date: 16/06/21 7:43p $

 * @brief    Demonstrate I2C Master how to access Slave. 

 *           Needs to work with I2C_Slave sample code.

 * @note

 * Copyright (C) 2014~2015 Nuvoton Technology Corp. All rights reserved.

 *

 ******************************************************************************/

#include <stdio.h>

#include "NUC123.h"



#define PLLCON_SETTING      CLK_PLLCON_72MHz_HXT

#define PLL_CLOCK           72000000





/*---------------------------------------------------------------------------------------------------------*/

/* Global variables                                                                                        */

/*---------------------------------------------------------------------------------------------------------*/

volatile uint8_t g_u8DeviceAddr;

volatile uint8_t g_au8MstTxData[3];

volatile uint8_t g_u8MstRxData;

volatile uint8_t g_u8MstDataLen;

volatile uint8_t g_u8MstEndFlag = 0;



typedef void (*I2C_FUNC)(uint32_t u32Status);



static volatile I2C_FUNC s_I2C0HandlerFn = NULL;



/*---------------------------------------------------------------------------------------------------------*/

/*  I2C0 IRQ Handler                                                                                       */

/*---------------------------------------------------------------------------------------------------------*/

void I2C0_IRQHandler(void)

{

    uint32_t u32Status;



    u32Status = I2C_GET_STATUS(I2C0);



    if(I2C_GET_TIMEOUT_FLAG(I2C0))

    {

        /* Clear I2C0 Timeout Flag */

        I2C_ClearTimeoutFlag(I2C0);

    }

    else

    {

        if(s_I2C0HandlerFn != NULL)

            s_I2C0HandlerFn(u32Status);

    }

}



/*---------------------------------------------------------------------------------------------------------*/

/*  I2C Rx Callback Function                                                                               */

/*---------------------------------------------------------------------------------------------------------*/

void I2C_MasterRx(uint32_t u32Status)

{

    if(u32Status == 0x08)                       /* START has been transmitted and prepare SLA+W */

    {

        I2C_SET_DATA(I2C0, (g_u8DeviceAddr << 1));    /* Write SLA+W to Register I2CDAT */

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

    }

    else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */

    {

        I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

    }

    else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */

    {

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_STO_SI);

    }

    else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */

    {

        if(g_u8MstDataLen != 2)

        {

            I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);

            I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

        }

        else

        {

            I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_SI);

        }

    }

    else if(u32Status == 0x10)                  /* Repeat START has been transmitted and prepare SLA+R */

    {

        I2C_SET_DATA(I2C0, ((g_u8DeviceAddr << 1) | 0x01));   /* Write SLA+R to Register I2CDAT */

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

    }

    else if(u32Status == 0x40)                  /* SLA+R has been transmitted and ACK has been received */

    {

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

    }

    else if(u32Status == 0x58)                  /* DATA has been received and NACK has been returned */

    {

        g_u8MstRxData = (unsigned char) I2C_GET_DATA(I2C0);

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);

        g_u8MstEndFlag = 1;

    }

    else

    {

        /* TO DO */

        printf("Status 0x%x is NOT processed\n", u32Status);

    }

}

/*---------------------------------------------------------------------------------------------------------*/

/*  I2C Tx Callback Function                                                                               */

/*---------------------------------------------------------------------------------------------------------*/

void I2C_MasterTx(uint32_t u32Status)

{

    if(u32Status == 0x08)                       /* START has been transmitted */

    {

        I2C_SET_DATA(I2C0, g_u8DeviceAddr << 1);    /* Write SLA+W to Register I2CDAT */

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

    }

    else if(u32Status == 0x18)                  /* SLA+W has been transmitted and ACK has been received */

    {

        I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

    }

    else if(u32Status == 0x20)                  /* SLA+W has been transmitted and NACK has been received */

    {

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA_STO_SI);

    }

    else if(u32Status == 0x28)                  /* DATA has been transmitted and ACK has been received */

    {

        if(g_u8MstDataLen != 3)

        {

            I2C_SET_DATA(I2C0, g_au8MstTxData[g_u8MstDataLen++]);

            I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_SI);

        }

        else

        {

            I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STO_SI);

            g_u8MstEndFlag = 1;

        }

    }

    else

    {

        /* TO DO */

        printf("Status 0x%x is NOT processed\n", u32Status);

    }

}



void SYS_Init(void)

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init System Clock                                                                                       */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Enable XT1_OUT (PF0) and XT1_IN (PF1) */

    SYS->GPF_MFP |= SYS_GPF_MFP_PF0_XT1_OUT | SYS_GPF_MFP_PF1_XT1_IN;



    /* Enable Internal RC 22.1184MHz clock */

    CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);



    /* Waiting for Internal RC clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);



    /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */

    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));



    /* Enable external XTAL 12MHz clock */

    CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);



    /* Waiting for external XTAL clock ready */

    CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);



    /* Set core clock as PLL_CLOCK from PLL */

    CLK_SetCoreClock(PLL_CLOCK);



    /* Enable UART module clock */

    CLK_EnableModuleClock(UART0_MODULE);



    /* Enable I2C0 module clock */

    CLK_EnableModuleClock(I2C0_MODULE);



    /* Select UART module clock source */

    CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));



    /*---------------------------------------------------------------------------------------------------------*/

    /* Init I/O Multi-function                                                                                 */

    /*---------------------------------------------------------------------------------------------------------*/



    /* Set GPB multi-function pins for UART0 RXD and TXD */

    SYS->GPB_MFP = SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;



    /* Set GPF multi-function pins for I2C0 SDA and SCL */

    SYS->GPF_MFP |= (SYS_GPF_MFP_PF2_I2C0_SDA | SYS_GPF_MFP_PF3_I2C0_SCL);

    SYS->ALT_MFP1 &= ~(SYS_ALT_MFP1_PF2_Msk | SYS_ALT_MFP1_PF3_Msk);

    SYS->ALT_MFP1 |= (SYS_ALT_MFP1_PF2_I2C0_SDA | SYS_ALT_MFP1_PF3_I2C0_SCL);

}



void UART0_Init()

{

    /*---------------------------------------------------------------------------------------------------------*/

    /* Init UART                                                                                               */

    /*---------------------------------------------------------------------------------------------------------*/

    /* Reset IP */

    SYS_ResetModule(UART0_RST);



    /* Configure UART0 and set UART0 Baudrate */

    UART_Open(UART0, 115200);

}



void I2C0_Init(void)

{

    /* Open I2C module and set bus clock */

    I2C_Open(I2C0, 100000);



    /* Get I2C0 Bus Clock */

    printf("I2C clock %d Hz\n", I2C_GetBusClockFreq(I2C0));



    /* Set I2C 4 Slave Addresses */

    I2C_SetSlaveAddr(I2C0, 0, 0x15, 0);   /* Slave Address : 0x15 */

    I2C_SetSlaveAddr(I2C0, 1, 0x35, 0);   /* Slave Address : 0x35 */

    I2C_SetSlaveAddr(I2C0, 2, 0x55, 0);   /* Slave Address : 0x55 */

    I2C_SetSlaveAddr(I2C0, 3, 0x75, 0);   /* Slave Address : 0x75 */



    /* Enable I2C interrupt */

    I2C_EnableInt(I2C0);

    NVIC_EnableIRQ(I2C0_IRQn);

}



void I2C0_Close(void)

{

    /* Disable I2C0 interrupt and clear corresponding NVIC bit */

    I2C_DisableInt(I2C0);

    NVIC_DisableIRQ(I2C0_IRQn);



    /* Disable I2C0 and close I2C0 clock */

    I2C_Close(I2C0);

    CLK_DisableModuleClock(I2C0_MODULE);



}



int32_t I2C0_Read_Write_SLAVE(uint8_t slvaddr)

{

    uint32_t i;



    g_u8DeviceAddr = slvaddr;



    for(i = 0; i < 0x100; i++)

    {

        g_au8MstTxData[0] = (uint8_t)((i & 0xFF00) >> 8);

        g_au8MstTxData[1] = (uint8_t)(i & 0x00FF);

        g_au8MstTxData[2] = (uint8_t)(g_au8MstTxData[1] + 3);



        g_u8MstDataLen = 0;

        g_u8MstEndFlag = 0;



        /* I2C function to write data to slave */

        s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterTx;



        /* I2C as master sends START signal */

        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);



        /* Wait I2C Tx Finish */

        while(g_u8MstEndFlag == 0);

        g_u8MstEndFlag = 0;



        /* I2C function to read data from slave */

        s_I2C0HandlerFn = (I2C_FUNC)I2C_MasterRx;



        g_u8MstDataLen = 0;

        g_u8DeviceAddr = slvaddr;



        I2C_SET_CONTROL_REG(I2C0, I2C_I2CON_STA);



        /* Wait I2C Rx Finish */

        while(g_u8MstEndFlag == 0);



        /* Compare data */

        if(g_u8MstRxData != g_au8MstTxData[2])

        {

            printf("I2C Byte Write/Read Failed, Data 0x%x\n", g_u8MstRxData);

            return -1;

        }

    }

    printf("Master Access Slave (0x%X) Test OK\n", slvaddr);

    return 0;

}

/*---------------------------------------------------------------------------------------------------------*/

/*  Main Function                                                                                          */

/*---------------------------------------------------------------------------------------------------------*/

int32_t main(void)

{

    /* Unlock protected registers */

    SYS_UnlockReg();



    /* Init System, IP clock and multi-function I/O */

    SYS_Init();



    /* Init UART0 for printf */

    UART0_Init();



    /* Lock protected registers */

    SYS_LockReg();



    /*

        This sample code sets I2C bus clock to 100kHz. Then, Master accesses Slave with Byte Write

        and Byte Read operations, and check if the read data is equal to the programmed data.

    */

    printf("\n");

    printf("+----------------------------------------------------+\n");

    printf("| I2C Driver Sample Code(Master) for access Slave    |\n");

    printf("| Needs to work with I2C_Slave sample code           |\n");

    printf("|     I2C Master (I2C0) <---> I2C Slave(I2C0)        |\n");

    printf("| !! This sample code requires two borads to test !! |\n");

    printf("+----------------------------------------------------+\n");



    printf("Configure I2C0 as a master.\n");

    printf("The I/O connection for I2C0:\n");

    printf("I2C0_SDA(PF.2), I2C0_SCL(PF.3)\n");



    /* Init I2C0 */

    I2C0_Init();



    printf("\n");

    printf("Check I2C Slave(I2C0) is running first!\n");

    printf("Press any key to continue.\n");

    getchar();



    /* Access Slave with no address */

    printf("\n");

    printf(" == No Mask Address ==\n");

    I2C0_Read_Write_SLAVE(0x15);

    I2C0_Read_Write_SLAVE(0x35);

    I2C0_Read_Write_SLAVE(0x55);

    I2C0_Read_Write_SLAVE(0x75);

    printf("SLAVE Address test OK.\n");



    /* Access Slave with address mask */

    printf("\n");

    printf(" == Mask Address ==\n");

    I2C0_Read_Write_SLAVE(0x15 & ~0x01);

    I2C0_Read_Write_SLAVE(0x35 & ~0x04);

    I2C0_Read_Write_SLAVE(0x55 & ~0x01);

    I2C0_Read_Write_SLAVE(0x75 & ~0x04);

    printf("SLAVE Address Mask test OK.\n");



    s_I2C0HandlerFn = NULL;



    /* Close I2C0 */

    I2C0_Close();



    while(1);

}

发表于 2017-10-23 20:49

这个看得懂，是用的硬件收发器，库函数实现果然很方便。

发表于 2017-10-23 21:02

为何设置个这都这么难，难道我比较笨。

发表于 2017-10-23 21:24

u32Status == 0x88
这些如果都用宏就好懂了，要不这个数字真没法理解。

发表于 2017-10-24 18:54

/* Enable UART module clock */
CLK_EnableModuleClock(UART0_MODULE);

/* Enable I2C0 module clock */
CLK_EnableModuleClock(I2C0_MODULE);
是不是开启了这个时钟相当于激活了这个模块，就开始耗电了，如果不启动这个时钟，是不是就是没有供电。

[DemoCode下载] NUC123单片机的I2C从机模式

相关帖子

浏览过的版块