status_t I2C_MasterTransferBlocking(I2C_Type *base, i2c_master_transfer_t *xfer) { status_t result = kStatus_Success; uint32_t subaddress; uint8_t subaddrBuf[4]; int i; assert(xfer); /* If repeated start is requested, send repeated start. */ if (!(xfer->flags & kI2C_TransferNoStartFlag)) { if (xfer->subaddressSize) { result = I2C_MasterStart(base, xfer->slaveAddress, kI2C_Write); if (result == kStatus_Success) { /* Prepare subaddress transmit buffer, most significant byte is stored at the lowest address */ subaddress = xfer->subaddress; for (i = xfer->subaddressSize - 1; i >= 0; i--) { subaddrBuf[i] = subaddress & 0xff; subaddress >>= 8; } /* Send subaddress. */ result = I2C_MasterWriteBlocking(base, subaddrBuf, xfer->subaddressSize, kI2C_TransferNoStopFlag); if ((result == kStatus_Success) && (xfer->direction == kI2C_Read)) { result = I2C_MasterRepeatedStart(base, xfer->slaveAddress, xfer->direction); } } }
static status_t I2C_InitTransferStateMachineEDMA(I2C_Type *base, i2c_master_edma_handle_t *handle, i2c_master_transfer_t *xfer) { assert(handle); assert(xfer); status_t result = kStatus_Success; uint16_t timeout = UINT16_MAX; if (handle->state != kIdleState) { return kStatus_I2C_Busy; } else { i2c_direction_t direction = xfer->direction; /* Init the handle member. */ handle->transfer = *xfer; /* Save total transfer size. */ handle->transferSize = xfer->dataSize; handle->state = kTransferDataState; /* Wait until ready to complete. */ while ((!(base->S & kI2C_TransferCompleteFlag)) && (--timeout)) { } /* Failed to start the transfer. */ if (timeout == 0) { return kStatus_I2C_Timeout; } /* Clear all status before transfer. */ I2C_MasterClearStatusFlags(base, kClearFlags); /* Change to send write address when it's a read operation with command. */ if ((xfer->subaddressSize > 0) && (xfer->direction == kI2C_Read)) { direction = kI2C_Write; } /* If repeated start is requested, send repeated start. */ if (handle->transfer.flags & kI2C_TransferRepeatedStartFlag) { result = I2C_MasterRepeatedStart(base, handle->transfer.slaveAddress, direction); } else /* For normal transfer, send start. */ { result = I2C_MasterStart(base, handle->transfer.slaveAddress, direction); } /* Send subaddress. */ if (handle->transfer.subaddressSize) { do { /* Wait until data transfer complete. */ while (!(base->S & kI2C_IntPendingFlag)) { } /* Clear interrupt pending flag. */ base->S = kI2C_IntPendingFlag; handle->transfer.subaddressSize--; base->D = ((handle->transfer.subaddress) >> (8 * handle->transfer.subaddressSize)); /* Check if there's transfer error. */ result = I2C_CheckAndClearError(base, base->S); if (result) { return result; } } while ((handle->transfer.subaddressSize > 0) && (result == kStatus_Success)); if (handle->transfer.direction == kI2C_Read) { /* Wait until data transfer complete. */ while (!(base->S & kI2C_IntPendingFlag)) { } /* Clear pending flag. */ base->S = kI2C_IntPendingFlag; /* Send repeated start and slave address. */ result = I2C_MasterRepeatedStart(base, handle->transfer.slaveAddress, kI2C_Read); } } if (result) { return result; } /* Wait until data transfer complete. */ while (!(base->S & kI2C_IntPendingFlag)) { } /* Clear pending flag. */ base->S = kI2C_IntPendingFlag; /* Check if there's transfer error. */ result = I2C_CheckAndClearError(base, base->S); } return result; }
/*! * @brief Main function */ int main(void) { i2c_slave_config_t slaveConfig; i2c_master_config_t masterConfig; uint32_t sourceClock; BOARD_InitPins(); BOARD_BootClockRUN(); BOARD_InitDebugConsole(); PRINTF("\r\nI2C example -- MasterFunctionalInterrupt_SlaveFunctionalInterrupt.\r\n"); /* Enable master and slave NVIC interrupt. */ EnableIRQ(I2C_MASTER_IRQ); EnableIRQ(I2C_SLAVE_IRQ); /* Set i2c slave interrupt priority higher. */ NVIC_SetPriority(I2C_SLAVE_IRQ, 0); NVIC_SetPriority(I2C_MASTER_IRQ, 1); /*1.Set up i2c slave first*/ /* * slaveConfig.addressingMode = kI2C_Address7bit; * slaveConfig.enableGeneralCall = false; * slaveConfig.enableWakeUp = false; * slaveConfig.enableHighDrive = false; * slaveConfig.enableBaudRateCtl = false; * slaveConfig.enableSlave = true; */ I2C_SlaveGetDefaultConfig(&slaveConfig); slaveConfig.addressingMode = kI2C_Address7bit; slaveConfig.slaveAddress = I2C_MASTER_SLAVE_ADDR_7BIT; I2C_SlaveInit(EXAMPLE_I2C_SLAVE_BASEADDR, &slaveConfig); for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { g_slave_buff[i] = 0; } /*2.Set up i2c master to send data to slave*/ for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { g_master_buff[i] = i; } PRINTF("Master will send data :"); for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { if (i % 8 == 0) { PRINTF("\r\n"); } PRINTF("0x%2x ", g_master_buff[i]); } PRINTF("\r\n\r\n"); /* * masterConfig.baudRate_Bps = 100000U; * masterConfig.enableHighDrive = false; * masterConfig.enableStopHold = false; * masterConfig.glitchFilterWidth = 0U; * masterConfig.enableMaster = true; */ I2C_MasterGetDefaultConfig(&masterConfig); masterConfig.baudRate_Bps = I2C_BAUDRATE; sourceClock = CLOCK_GetFreq(I2C_MASTER_CLK_SRC); I2C_MasterInit(EXAMPLE_I2C_MASTER_BASEADDR, &masterConfig, sourceClock); /* Master send address to slave. */ I2C_MasterStart(EXAMPLE_I2C_MASTER_BASEADDR, I2C_MASTER_SLAVE_ADDR_7BIT, kI2C_Write); /* Enable module interrupt. */ I2C_EnableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable); I2C_EnableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable); /* Wait slave receive finished. */ while (g_slaveRxIndex < I2C_DATA_LENGTH) { } /* Disable module interrupt. */ I2C_DisableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable); I2C_DisableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable); /* Master send stop command. */ I2C_MasterStop(EXAMPLE_I2C_MASTER_BASEADDR); /*3.Transfer completed. Check the data.*/ for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { if (g_slave_buff[i] != g_master_buff[i]) { PRINTF("\r\nError occured in this transfer ! \r\n"); break; } } PRINTF("Slave received data :"); for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { if (i % 8 == 0) { PRINTF("\r\n"); } PRINTF("0x%2x ", g_slave_buff[i]); } PRINTF("\r\n\r\n"); /*4.Set up slave ready to send data to master.*/ for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { g_slave_buff[i] = ~g_slave_buff[i]; } PRINTF("This time , slave will send data: :"); for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { if (i % 8 == 0) { PRINTF("\r\n"); } PRINTF("0x%2x ", g_slave_buff[i]); } PRINTF("\r\n\r\n"); /* Already setup the slave transfer ready in item 1. */ /* 5.Set up master to receive data from slave. */ for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { g_master_buff[i] = 0; } /* Master send address to slave. */ I2C_MasterStart(EXAMPLE_I2C_MASTER_BASEADDR, I2C_MASTER_SLAVE_ADDR_7BIT, kI2C_Read); /* Enable module interrupt. */ I2C_EnableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable); I2C_EnableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable); g_masterReadBegin = true; /* Master put receive data in receive buffer. */ g_masterRxIndex = 0; /* Wait master receive finished. */ while (g_masterRxIndex < I2C_DATA_LENGTH) { } /* Disable module interrupt. */ I2C_DisableInterrupts(EXAMPLE_I2C_MASTER_BASEADDR, kI2C_GlobalInterruptEnable); I2C_DisableInterrupts(EXAMPLE_I2C_SLAVE_BASEADDR, kI2C_GlobalInterruptEnable); /*6.Transfer completed. Check the data.*/ for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { if (g_slave_buff[i] != g_master_buff[i]) { PRINTF("\r\nError occured in the transfer ! \r\n"); break; } } PRINTF("Master received data :"); for (uint32_t i = 0U; i < I2C_DATA_LENGTH; i++) { if (i % 8 == 0) { PRINTF("\r\n"); } PRINTF("0x%2x ", g_master_buff[i]); } PRINTF("\r\n\r\n"); PRINTF("\r\nEnd of I2C example .\r\n"); while (1) { } }