NUC123的I2C接口使用方法

发表于 2017-8-20 21:42

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

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

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

 * $Revision: 16 $

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

 * @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 = I2C0->I2CSTATUS;



    if(I2C0->I2CTOC & I2C_I2CTOC_TIF_Msk)

    {

        /* Clear I2C0 Timeout Flag */

        I2C0->I2CTOC |= I2C_I2CTOC_TIF_Msk;

    }

    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 */

    {



        I2C0->I2CDAT = 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->PWRCON |= CLK_PWRCON_OSC22M_EN_Msk;



    /* Waiting for Internal RC clock ready */

    while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_OSC22M_STB_Msk));



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

    CLK->CLKSEL0 &= ~CLK_CLKSEL0_HCLK_S_Msk;

    CLK->CLKSEL0 |= CLK_CLKSEL0_HCLK_S_HIRC;

    CLK->CLKDIV &= ~CLK_CLKDIV_HCLK_N_Msk;

    CLK->CLKDIV |= CLK_CLKDIV_HCLK(1);



    /* Enable external XTAL 12MHz clock */

    CLK->PWRCON |= CLK_PWRCON_XTL12M_EN_Msk;



    /* Waiting for external XTAL clock ready */

    while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_XTL12M_STB_Msk));



    /* Set core clock as PLL_CLOCK from PLL */

    CLK->PLLCON = PLLCON_SETTING;

    while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_PLL_STB_Msk));

    CLK->CLKSEL0 &= (~CLK_CLKSEL0_HCLK_S_Msk);

    CLK->CLKSEL0 |= CLK_CLKSEL0_HCLK_S_PLL;



    /* Update System Core Clock */

    /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */

    //SystemCoreClockUpdate();

    PllClock        = PLL_CLOCK;            // PLL

    SystemCoreClock = PLL_CLOCK / 1;        // HCLK

    CyclesPerUs     = PLL_CLOCK / 1000000;  // For SYS_SysTickDelay()



    /* Enable UART & I2C0 module clock */

    CLK->APBCLK |= (CLK_APBCLK_UART0_EN_Msk | CLK_APBCLK_I2C0_EN_Msk);



    /* Select UART module clock source */

    CLK->CLKSEL1 &= ~CLK_CLKSEL1_UART_S_Msk;

    CLK->CLKSEL1 |= CLK_CLKSEL1_UART_S_HXT;



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

    /* 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(void)

{

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

    /* Init UART                                                                                               */

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

    /* Reset UART IP */

    SYS->IPRSTC2 |=  SYS_IPRSTC2_UART0_RST_Msk;

    SYS->IPRSTC2 &= ~SYS_IPRSTC2_UART0_RST_Msk;



    /* Configure UART0 and set UART0 Baudrate */

    UART0->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HXT, 115200);

    UART0->LCR = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;

}



void I2C0_Init(void)

{

    uint32_t u32BusClock;



    /* Reset I2C0 */

    SYS->IPRSTC2 |=  SYS_IPRSTC2_I2C0_RST_Msk;

    SYS->IPRSTC2 &= ~SYS_IPRSTC2_I2C0_RST_Msk;



    /* Enable I2C0 Controller */

    I2C0->I2CON |= I2C_I2CON_ENS1_Msk;



    /* I2C0 bus clock 100K divider setting, I2CLK = PCLK/(100K*4)-1 */

    u32BusClock = 100000;

    I2C0->I2CLK = (uint32_t)(((SystemCoreClock * 10) / (u32BusClock * 4) + 5) / 10 - 1); /* Compute proper divider for I2C clock */



    /* Get I2C0 Bus Clock */

    printf("I2C clock %d Hz\n", (SystemCoreClock / (((I2C0->I2CLK) + 1) << 2)));



    /* Set I2C0 4 Slave Addresses */

    /* Slave Address : 0x15 */

    I2C0->I2CADDR0 = (I2C0->I2CADDR0 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x15 << I2C_I2CADDR_I2CADDR_Pos);

    /* Slave Address : 0x35 */

    I2C0->I2CADDR1 = (I2C0->I2CADDR1 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x35 << I2C_I2CADDR_I2CADDR_Pos);

    /* Slave Address : 0x55 */

    I2C0->I2CADDR2 = (I2C0->I2CADDR2 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x55 << I2C_I2CADDR_I2CADDR_Pos);

    /* Slave Address : 0x75 */

    I2C0->I2CADDR3 = (I2C0->I2CADDR3 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x75 << I2C_I2CADDR_I2CADDR_Pos);



    /* Set I2C0 4 Slave Addresses Mask Bits*/

    /* Slave Address Mask Bits: 0x01 */

    I2C0->I2CADM0 = (I2C0->I2CADM0 & ~I2C_I2CADM_I2CADM_Msk) | (0x01 << I2C_I2CADM_I2CADM_Pos);

    /* Slave Address Mask Bits: 0x04 */

    I2C0->I2CADM1 = (I2C0->I2CADM1 & ~I2C_I2CADM_I2CADM_Msk) | (0x04 << I2C_I2CADM_I2CADM_Pos);

    /* Slave Address Mask Bits: 0x01 */

    I2C0->I2CADM2 = (I2C0->I2CADM2 & ~I2C_I2CADM_I2CADM_Msk) | (0x01 << I2C_I2CADM_I2CADM_Pos);

    /* Slave Address Mask Bits: 0x04 */

    I2C0->I2CADM3 = (I2C0->I2CADM3 & ~I2C_I2CADM_I2CADM_Msk) | (0x04 << I2C_I2CADM_I2CADM_Pos);



    /* Enable I2C0 interrupt and set corresponding NVIC bit */

    I2C0->I2CON |= I2C_I2CON_EI_Msk;

    NVIC_EnableIRQ(I2C0_IRQn);

}



void I2C0_Close(void)

{

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

    I2C0->I2CON &= ~I2C_I2CON_EI_Msk;

    NVIC_DisableIRQ(I2C0_IRQn);



    /* Disable I2C0 and close I2C0 clock */

    I2C0->I2CON &= ~I2C_I2CON_ENS1_Msk;

    CLK->APBCLK &= ~CLK_APBCLK_I2C0_EN_Msk;

}



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

/*  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();





    /* Lock protected registers */

    SYS_LockReg();



    /* Init UART0 for printf */

    UART0_Init();



    /*

        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-8-20 21:43

复制

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

 * @file     main.c

 * @version  V3.00

 * $Revision: 15 $

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

 * @brief    Demonstrate a 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 = I2C0->I2CSTATUS;



    if(I2C0->I2CTOC & I2C_I2CTOC_TIF_Msk)

    {

        /* Clear I2C0 Timeout Flag */

        I2C0->I2CTOC |= I2C_I2CTOC_TIF_Msk;

    }

    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 */

    {

        I2C0->I2CDAT = 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 */

    {

        I2C0->I2CDAT = 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)

        {

            I2C0->I2CDAT = 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 */

    {

        I2C0->I2CDAT = ((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 = I2C0->I2CDAT;

        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 */

    {

        I2C0->I2CDAT = 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 */

    {

        I2C0->I2CDAT = 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)

        {

            I2C0->I2CDAT = 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->PWRCON |= CLK_PWRCON_OSC22M_EN_Msk;



    /* Waiting for Internal RC clock ready */

    while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_OSC22M_STB_Msk));



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

    CLK->CLKSEL0 &= ~CLK_CLKSEL0_HCLK_S_Msk;

    CLK->CLKSEL0 |= CLK_CLKSEL0_HCLK_S_HIRC;

    CLK->CLKDIV &= ~CLK_CLKDIV_HCLK_N_Msk;

    CLK->CLKDIV |= CLK_CLKDIV_HCLK(1);



    /* Enable external XTAL 12MHz clock */

    CLK->PWRCON |= CLK_PWRCON_XTL12M_EN_Msk;



    /* Waiting for external XTAL clock ready */

    while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_XTL12M_STB_Msk));



    /* Set core clock as PLL_CLOCK from PLL */

    CLK->PLLCON = PLLCON_SETTING;

    while(!(CLK->CLKSTATUS & CLK_CLKSTATUS_PLL_STB_Msk));

    CLK->CLKSEL0 &= (~CLK_CLKSEL0_HCLK_S_Msk);

    CLK->CLKSEL0 |= CLK_CLKSEL0_HCLK_S_PLL;



    /* Update System Core Clock */

    /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */

    //SystemCoreClockUpdate();

    PllClock        = PLL_CLOCK;            // PLL

    SystemCoreClock = PLL_CLOCK / 1;        // HCLK

    CyclesPerUs     = PLL_CLOCK / 1000000;  // For SYS_SysTickDelay()



    /* Enable UART & I2C0 module clock */

    CLK->APBCLK |= (CLK_APBCLK_UART0_EN_Msk | CLK_APBCLK_I2C0_EN_Msk);



    /* Select UART module clock source */

    CLK->CLKSEL1 &= ~CLK_CLKSEL1_UART_S_Msk;

    CLK->CLKSEL1 |= CLK_CLKSEL1_UART_S_HXT;



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

    /* 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(void)

{

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

    /* Init UART                                                                                               */

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

    /* Reset UART IP */

    SYS->IPRSTC2 |=  SYS_IPRSTC2_UART0_RST_Msk;

    SYS->IPRSTC2 &= ~SYS_IPRSTC2_UART0_RST_Msk;



    /* Configure UART0 and set UART0 Baudrate */

    UART0->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HXT, 115200);

    UART0->LCR = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;

}



void I2C0_Init(void)

{

    uint32_t u32BusClock;



    /* Reset I2C0 */

    SYS->IPRSTC2 |=  SYS_IPRSTC2_I2C0_RST_Msk;

    SYS->IPRSTC2 &= ~SYS_IPRSTC2_I2C0_RST_Msk;



    /* Enable I2C0 Controller */

    I2C0->I2CON |= I2C_I2CON_ENS1_Msk;



    /* I2C0 bus clock 100K divider setting, I2CLK = PCLK/(100K*4)-1 */

    u32BusClock = 100000;

    I2C0->I2CLK = (uint32_t)(((SystemCoreClock * 10) / (u32BusClock * 4) + 5) / 10 - 1); /* Compute proper divider for I2C clock */



    /* Get I2C0 Bus Clock */

    printf("I2C clock %d Hz\n", (SystemCoreClock / (((I2C0->I2CLK) + 1) << 2)));



    /* Set I2C0 4 Slave Addresses */

    /* Slave Address : 0x15 */

    I2C0->I2CADDR0 = (I2C0->I2CADDR0 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x15 << I2C_I2CADDR_I2CADDR_Pos);

    /* Slave Address : 0x35 */

    I2C0->I2CADDR1 = (I2C0->I2CADDR1 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x35 << I2C_I2CADDR_I2CADDR_Pos);

    /* Slave Address : 0x55 */

    I2C0->I2CADDR2 = (I2C0->I2CADDR2 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x55 << I2C_I2CADDR_I2CADDR_Pos);

    /* Slave Address : 0x75 */

    I2C0->I2CADDR3 = (I2C0->I2CADDR3 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x75 << I2C_I2CADDR_I2CADDR_Pos);



    /* Enable I2C0 interrupt and set corresponding NVIC bit */

    I2C0->I2CON |= I2C_I2CON_EI_Msk;

    NVIC_EnableIRQ(I2C0_IRQn);

}



void I2C0_Close(void)

{

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

    I2C0->I2CON &= ~I2C_I2CON_EI_Msk;

    NVIC_DisableIRQ(I2C0_IRQn);



    /* Disable I2C0 and close I2C0 clock */

    I2C0->I2CON &= ~I2C_I2CON_ENS1_Msk;

    CLK->APBCLK &= ~CLK_APBCLK_I2C0_EN_Msk;



}



int32_t 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();



    /* Lock protected registers */

    SYS_LockReg();



    /* Init UART0 for printf */

    UART0_Init();



    /*

        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 mask */

    printf("\n");

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

    Read_Write_SLAVE(0x15);

    Read_Write_SLAVE(0x35);

    Read_Write_SLAVE(0x55);

    Read_Write_SLAVE(0x75);

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



    /* Access Slave with address mask */

    printf("\n");

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

    Read_Write_SLAVE(0x15 & ~0x01);

    Read_Write_SLAVE(0x35 & ~0x04);

    Read_Write_SLAVE(0x55 & ~0x01);

    Read_Write_SLAVE(0x75 & ~0x04);

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



    s_I2C0HandlerFn = NULL;



    /* Close I2C0 */

    I2C0_Close();



    while(1);

}

发表于 2017-8-20 21:44

其实最好配合着手册，看着说明再看例子比较好懂了

发表于 2017-8-21 15:47

/* Set I2C0 4 Slave Addresses */
/* Slave Address : 0x15 */
I2C0->I2CADDR0 = (I2C0->I2CADDR0 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x15 << I2C_I2CADDR_I2CADDR_Pos);
/* Slave Address : 0x35 */
I2C0->I2CADDR1 = (I2C0->I2CADDR1 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x35 << I2C_I2CADDR_I2CADDR_Pos);
/* Slave Address : 0x55 */
I2C0->I2CADDR2 = (I2C0->I2CADDR2 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x55 << I2C_I2CADDR_I2CADDR_Pos);
/* Slave Address : 0x75 */
I2C0->I2CADDR3 = (I2C0->I2CADDR3 & ~I2C_I2CADDR_I2CADDR_Msk) | (0x75 << I2C_I2CADDR_I2CADDR_Pos);
不就一个单片机吗，怎么这么多从机地址

发表于 2017-8-21 19:09

有点难以理解了。

发表于 2017-8-21 20:41

有一些命名的寄存器看着好奇葩

发表于 2017-8-21 21:52

用寄存器虽然效率高，但是没有库函数的好理解。

发表于 2017-8-22 17:38

天灵灵地灵灵发表于 2017-8-21 21:52
用寄存器虽然效率高，但是没有库函数的好理解。

可以先用库函数写，再改成寄存器的，效果很好

发表于 2017-8-26 19:18

总结库函数有个规则，就是每次都是配置一堆那个结构体变量，然后通过一个函数把配置的结构体变量传递进去。

发表于 2017-8-26 19:19

比如那个时钟那个，之前看不懂，现在逛论坛多了，就懂了

发表于 2017-8-27 16:23

5574293 发表于 2017-8-22 17:38
可以先用库函数写，再改成寄存器的，效果很好

这一招真给力。

发表于 2017-8-27 20:19

手上没有IIC芯片，没法玩啊。

发表于 2017-9-5 08:45

void CLK_EnableModuleClock(uint32_t u32ModuleIdx)
{
*(volatile uint32_t *)((uint32_t)&CLK->APBCLK + (MODULE_APBCLK(u32ModuleIdx) * 4)) |= 1 << MODULE_IP_EN_Pos(u32ModuleIdx);
}
这个时钟使能库函数就没看懂，调用的是PWM01模块，，，
#define PWM01_MODULE ((0x0<<31)|(0x1<<29) |(0x3<<25) |(28<<20) |(MODULE_NoMsk<<10) |CLK_APBCLK_PWM01_EN_Pos)

发表于 2017-9-5 23:08

手里不搞个I2C的芯片，玩起来费劲。

发表于 2017-9-6 20:39

看完觉得简单多了。

发表于 2017-9-6 20:40

lss1985 发表于 2017-9-5 08:45
void CLK_EnableModuleClock(uint32_t u32ModuleIdx)
{
*(volatile uint32_t *)((uint32_t)&CLK->APBCL ...

是的，估计是用的都是APB时钟吧，你研究的怪深入的，那要研究这个，就别看库函数，直接看寄存器版本的例子，比较好。

发表于 2017-9-7 09:55

zhuotuzi 发表于 2017-9-6 20:40
是的，估计是用的都是APB时钟吧，你研究的怪深入的，那要研究这个，就别看库函数，直接看寄存器版本的例 ...

最终还是用了寄存器版本的写法，库函数直接能用的就用了，看不懂的还是寄存器好用

发表于 2019-7-4 17:35

IIC 超时功能怎么用？

[DemoCode下载] NUC123的I2C接口使用方法

相关帖子

浏览过的版块

技术新星奖章

湍急之河流

社区建设奖章

经常做客

偶尔光临