void i2cMgr_t::ReadMany() {
// Enable Acknowledgement
I2C_AcknowledgeConfig(I2C1, ENABLE);
// Prepare DMA
DMA_DeInit(I2C_DMA_CHNL_RX);
DMA_InitTypeDef DMA_InitStructure;
//DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &I2C1->DR;
DMA_InitStructure.DMA_PeripheralBaseAddr = 0x40005410;
// Decide where to read data to
if(CmdToRead->DataToRead.Buf == 0) { // no need in this data
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CmdToRead->DataToRead.InnerBuf[0]; // dummy place
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; // Do not move pointer
}
else {
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CmdToRead->DataToRead.Buf[0];
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
}
DMA_InitStructure.DMA_BufferSize = CmdToRead->DataToRead.Length;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; // From I2C to memory
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(I2C_DMA_CHNL_RX, &DMA_InitStructure);
//Inform the DMA that the next End Of Transfer Signal will be the last one, need to send NACK after last byte
I2C_DMALastTransferCmd(I2C1, ENABLE);
// Start transmission
I2C_DMACmd(I2C1, ENABLE); // Enable DMA
DMA_Cmd(I2C_DMA_CHNL_RX, ENABLE); // Enable DMA channel
Delay.Reset(&Timer);
}
int16_t I2C1_Write(uint8_t * buffer, uint8_t address, uint16_t length)
{
int16_t return_code = pdTRUE;
uint16_t bytes_sent = 0;
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)) {} /*TODO: Timeout*/
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) {}
I2C_Send7bitAddress(I2C1, address, I2C_Direction_Transmitter);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) {}
I2C1_DMA_TX_Semaphore = 0;
if (length < 2)
{
while (bytes_sent < length)
{
I2C_SendData(I2C1, buffer[bytes_sent]);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF) == RESET) {}
bytes_sent++;
}
I2C_GenerateSTOP(I2C1, ENABLE);
while(I2C1->CR1 & I2C_CR1_STOP) {}
}
else
{
I2C1_DMAConfig((uint32_t)buffer, length, DIR_TX);
I2C_DMALastTransferCmd(I2C1, ENABLE);
DMA_Cmd(I2C1_DMA_STREAM_TX, ENABLE);
I2C_DMACmd(I2C1, ENABLE);
/* Wait for DMA interrupt */
while (I2C1_DMA_TX_Semaphore == 0) {}
}
return return_code;
}
void I2C_DMA_Read(u8 slaveAddr, u8 readAddr)
{
/* Disable DMA channel*/
DMA_Cmd(DMA1_Channel7, DISABLE);
/* Set current data number again to 14 for MPu6050, only possible after disabling the DMA channel */
DMA_SetCurrDataCounter(DMA1_Channel7, 14);
/* While the bus is busy */
while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_BUSY));
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(MPU6050_I2C, ENABLE); //Note this one, very important
/* Send START condition */
I2C_GenerateSTART(MPU6050_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_MODE_SELECT));
/* Send MPU6050 address for write */
I2C_Send7bitAddress(MPU6050_I2C, slaveAddr, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Clear EV6 by setting again the PE bit */
I2C_Cmd(MPU6050_I2C, ENABLE);
/* Send the MPU6050's internal address to write to */
I2C_SendData(MPU6050_I2C, readAddr);
/* Test on EV8 and clear it */
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* Send STRAT condition a second time */
I2C_GenerateSTART(MPU6050_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_MODE_SELECT));
/* Send MPU6050 address for read */
I2C_Send7bitAddress(MPU6050_I2C, slaveAddr, I2C_Direction_Receiver);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* Start DMA to receive data from I2C */
DMA_Cmd(DMA1_Channel7, ENABLE);
I2C_DMACmd(MPU6050_I2C, ENABLE);
// When the data transmission is complete, it will automatically jump to DMA interrupt routine to finish the rest.
//now go back to the main routine
}
void i2c_dma_read( u8 read_addr)
{
// read_addr +=1;
//disable dma channel
DMA_Cmd( MPU6050_DMA_CHANNEL, DISABLE);
//? set current data number again to 14
DMA_SetCurrDataCounter(MPU6050_DMA_CHANNEL, 14);
//while the bus is busy
while( I2C_GetFlagStatus( MPU6050_I2C,I2C_FLAG_BUSY));
//enable dma nack automatic generation.....
I2C_DMALastTransferCmd( MPU6050_I2C, ENABLE);
//send start condition
I2C_GenerateSTART( MPU6050_I2C, ENABLE);
//test on ev5 and clear it
while( !I2C_CheckEvent( MPU6050_I2C, I2C_EVENT_MASTER_MODE_SELECT));
//send mpu6050 address for write
I2C_Send7bitAddress( MPU6050_I2C, I2C1_MPU6050, I2C_Direction_Transmitter );
//test on ev6 and clear it
while( !I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
//clear ev6 by setting again the PE bit
I2C_Cmd( MPU6050_I2C,ENABLE);
//send the mpu6050 internal address to write to
I2C_SendData( MPU6050_I2C, read_addr);
//test on ev8 and clear it
while(!I2C_CheckEvent( MPU6050_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
//send start condition a second time
I2C_GenerateSTART(MPU6050_I2C, ENABLE);
//test on ev5 and clear it
while( !I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_MODE_SELECT));
//send mpu6050 address for read
I2C_Send7bitAddress(MPU6050_I2C,I2C1_MPU6050, I2C_Direction_Receiver);
//test on ev6 and clear it
while( !I2C_CheckEvent( MPU6050_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
//start dma to receive data from i2c
DMA_Cmd(MPU6050_DMA_CHANNEL, ENABLE);
I2C_DMACmd(MPU6050_I2C, ENABLE);
//when the data transmission is complete, it will automatically jump to dma interrupt routine
//to finish the rest.
}
/*=====================================================================================================*/
u32 I2C_ReadBytes(u8 SlaveAddr, u8 *ReadBuf, u8 NumByte)
{
I2C_ReadPtr = &NumByte;
I2C_GenerateSTART(I2Cx, ENABLE);
I2C_TimeCnt = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_Send7bitAddress(I2Cx, SlaveAddr, I2C_Direction_Receiver);
I2C_TimeCnt = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
DMA_InitStruct.DMA_Channel = DMAx_RX_CHANNEL;
DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)I2Cx_DR_ADDR;
DMA_InitStruct.DMA_Memory0BaseAddr = (u32)ReadBuf;
DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStruct.DMA_BufferSize = (u32)(NumByte);
DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
DMA_InitStruct.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStruct.DMA_FIFOMode = DMA_FIFOMode_Enable;
DMA_InitStruct.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStruct.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStruct.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(DMAx_RX_STREAM, &DMA_InitStruct);
I2C_DMALastTransferCmd(I2Cx, ENABLE);
DMA_Cmd(DMAx_RX_STREAM, ENABLE);
I2C_TimeCnt = I2C_TIMEOUT;
while (NumByte > 0)
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
return SUCCESS;
}
static rt_size_t i2c1_recv_bytes(struct rt_i2c_msg *msg)
{
rt_size_t bytes = 0;
rt_size_t len = msg->len;
DMA_InitTypeDef DMA_InitStructure;
if (len < 2)
{
I2C_AcknowledgeConfig(I2Cx,
msg->flags & RT_I2C_NO_READ_ACK?DISABLE:ENABLE);
(void)I2Cx->SR2;
I2C_GenerateSTOP(I2Cx, ENABLE);
while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_RXNE) == RESET);
msg->buf[bytes++] = I2C_ReceiveData(I2Cx);
while (I2Cx->CR1 & I2C_CR1_STOP);
I2C_AcknowledgeConfig(I2Cx, ENABLE);
return 1;
}
else
{
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)I2Cx_DR_ADDR;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)(msg->buf);
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = msg->len;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMAx_RX_CHANNEL, &DMA_InitStructure);
I2C_DMALastTransferCmd(I2Cx, ENABLE);
DMA_Cmd(DMAx_RX_CHANNEL, ENABLE);
//Check finshed
if(rt_sem_take(&DMA_RX_Sem,20)!=RT_EOK)
return 0;
}
return len;
}
int16_t I2C1_Read(uint8_t * buffer, uint8_t address, uint16_t length)
{
int16_t return_code = pdTRUE;
uint16_t bytes_received = 0;
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)) {} /*TODO: Timeout*/
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) {}
I2C_Send7bitAddress(I2C1, address, I2C_Direction_Receiver);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR) == RESET) {}
I2C1_DMA_RX_Semaphore = 0;
if (length < 2)
{
I2C_AcknowledgeConfig(I2C1, DISABLE);
(void)I2C1->SR2;
I2C_GenerateSTOP(I2C1, ENABLE);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE) == RESET) {}
if (length > 0)
{
buffer[bytes_received] = I2C_ReceiveData(I2C1);
}
while(I2C1->CR1 & I2C_CR1_STOP) {}
I2C_AcknowledgeConfig(I2C1, ENABLE);
}
else
{
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) {}
I2C1_DMAConfig((uint32_t)buffer, length, DIR_RX);
I2C_DMALastTransferCmd(I2C1, ENABLE);
DMA_Cmd(I2C1_DMA_STREAM_RX, ENABLE);
I2C_DMACmd(I2C1, ENABLE);
/* Wait for DMA interrupt */
while (I2C1_DMA_RX_Semaphore == 0) {}
}
return return_code;
}
/**
* @brief Read the configuration register from the LM75.
* @param None
* @retval LM75 configuration register value.
*/
uint8_t LM75_ReadConfReg(void)
{
uint8_t LM75_BufferRX[2] ={0,0};
/* Test on BUSY Flag */
LM75_Timeout = LM75_LONG_TIMEOUT;
while (I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BUSY))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Configure DMA Peripheral */
LM75_DMA_Config(LM75_DMA_RX, (uint8_t*)LM75_BufferRX, 2);
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(LM75_I2C, ENABLE);
/* Enable the I2C peripheral */
I2C_GenerateSTART(LM75_I2C, ENABLE);
/* Test on SB Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_SB))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send device address for write */
I2C_Send7bitAddress(LM75_I2C, LM75_ADDR, I2C_Direction_Transmitter);
/* Test on ADDR Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_CheckEvent(LM75_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send the device's internal address to write to */
I2C_SendData(LM75_I2C, LM75_REG_CONF);
/* Test on TXE FLag (data sent) */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while ((!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BTF)))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send START condition a second time */
I2C_GenerateSTART(LM75_I2C, ENABLE);
/* Test on SB Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_SB))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send LM75 address for read */
I2C_Send7bitAddress(LM75_I2C, LM75_ADDR, I2C_Direction_Receiver);
/* Test on ADDR Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_CheckEvent(LM75_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Enable I2C DMA request */
I2C_DMACmd(LM75_I2C,ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(LM75_DMA_RX_CHANNEL, ENABLE);
/* Wait until DMA Transfer Complete */
LM75_Timeout = LM75_LONG_TIMEOUT;
while (!DMA_GetFlagStatus(LM75_DMA_RX_TCFLAG))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send STOP Condition */
I2C_GenerateSTOP(LM75_I2C, ENABLE);
/* Disable DMA RX Channel */
DMA_Cmd(LM75_DMA_RX_CHANNEL, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(LM75_I2C,DISABLE);
/* Clear DMA RX Transfer Complete Flag */
DMA_ClearFlag(LM75_DMA_RX_TCFLAG);
/*!< Return Temperature value */
return (uint8_t)LM75_BufferRX[0];
}
/**
* @brief Reads a buffer of 2 bytes from the device registers.
* @param DeviceAddr: The address of the device, could be : IOE_1_ADDR
* or IOE_2_ADDR.
* @param RegisterAddr: The target register adress (between 00x and 0x24)
* @retval A pointer to the buffer containing the two returned bytes (in halfword).
*/
uint16_t I2C_ReadDataBuffer(uint8_t DeviceAddr, uint32_t RegisterAddr)
{
uint8_t tmp= 0;
uint8_t IOE_BufferRX[2] = {0x00, 0x00};
/* Configure DMA Peripheral */
IOE_DMA_Config(IOE_DMA_RX, (uint8_t*)IOE_BufferRX);
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(IOE_I2C, ENABLE);
/* Enable the I2C peripheral */
I2C_GenerateSTART(IOE_I2C, ENABLE);
/* Test on SB Flag */
IOE_TimeOut = TIMEOUT_MAX;
while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Send device address for write */
I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Transmitter);
/* Test on ADDR Flag */
IOE_TimeOut = TIMEOUT_MAX;
while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Send the device's internal address to write to */
I2C_SendData(IOE_I2C, RegisterAddr);
/* Test on TXE FLag (data dent) */
IOE_TimeOut = TIMEOUT_MAX;
while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Send START condition a second time */
I2C_GenerateSTART(IOE_I2C, ENABLE);
/* Test on SB Flag */
IOE_TimeOut = TIMEOUT_MAX;
while (!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_SB))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Send IOExpander address for read */
I2C_Send7bitAddress(IOE_I2C, DeviceAddr, I2C_Direction_Receiver);
/* Test on ADDR Flag */
IOE_TimeOut = TIMEOUT_MAX;
while (!I2C_CheckEvent(IOE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Enable I2C DMA request */
I2C_DMACmd(IOE_I2C,ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(IOE_DMA_RX_CHANNEL, ENABLE);
/* Wait until DMA Transfer Complete */
IOE_TimeOut = 2 * TIMEOUT_MAX;
while (!DMA_GetFlagStatus(IOE_DMA_RX_TCFLAG))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Send STOP Condition */
I2C_GenerateSTOP(IOE_I2C, ENABLE);
/* Disable DMA RX Channel */
DMA_Cmd(IOE_DMA_RX_CHANNEL, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(IOE_I2C,DISABLE);
/* Clear DMA RX Transfer Complete Flag */
DMA_ClearFlag(IOE_DMA_RX_TCFLAG);
/* Reorganize received data */
tmp = IOE_BufferRX[0];
IOE_BufferRX[0] = IOE_BufferRX[1];
IOE_BufferRX[1] = tmp;
/* return a pointer to the IOE_Buffer */
return *(uint16_t *)IOE_BufferRX;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f2xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f2xx.c file
*/
/* I2C configuration ---------------------------------------------------------*/
I2C_Config();
/* Initialize LEDs mounted on STM322xG-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* SysTick configuration -----------------------------------------------------*/
SysTickConfig();
/* Clear the RxBuffer */
Fill_Buffer(RxBuffer, RXBUFFERSIZE);
/*************************************Master Code******************************/
#if defined (I2C_MASTER)
/* I2C Struct Initialize */
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DUTYCYCLE;
I2C_InitStructure.I2C_OwnAddress1 = 0xA0;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;
#ifndef I2C_10BITS_ADDRESS
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
#else
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_10bit;
#endif /* I2C_10BITS_ADDRESS */
/* I2C Initialize */
I2C_Init(I2Cx, &I2C_InitStructure);
/* Master Transmitter --------------------------------------------------------*/
/* Generate the Start condition */
I2C_GenerateSTART(I2Cx, ENABLE);
#ifdef I2C_10BITS_ADDRESS
/* Test on I2C1 EV5 and clear it */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send Header to I2Cx for write or time out */
I2C_SendData(I2Cx, HEADER_ADDRESS_Write);
/* Test on I2Cx EV9 and clear it */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_ADDRESS10))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send I2Cx slave Address for write */
I2C_Send7bitAddress(I2Cx, (uint8_t)SLAVE_ADDRESS, I2C_Direction_Transmitter);
#else /* I2C_7BITS_ADDRESS */
/* Test on I2Cx EV5 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send I2Cx slave Address for write */
I2C_Send7bitAddress(I2Cx, SLAVE_ADDRESS, I2C_Direction_Transmitter);
#endif /* I2C_10BITS_ADDRESS */
/* Test on I2Cx EV6 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* I2Cx DMA Enable */
I2C_DMACmd(I2Cx, ENABLE);
/* Enable DMA TX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_TX, ENABLE);
/* Wait until I2Cx_DMA_STREAM_TX enabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_TX)!= ENABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Wait until DMA Transfer Complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(I2Cx_DMA_STREAM_TX,I2Cx_TX_DMA_TCFLAG) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* I2Cx DMA Disable */
I2C_DMACmd(I2Cx, DISABLE);
/* Wait until BTF Flag is set before generating STOP or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_GetFlagStatus(I2Cx,I2C_FLAG_BTF))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send I2Cx STOP Condition */
I2C_GenerateSTOP(I2Cx, ENABLE);
/* Disable DMA TX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_TX, DISABLE);
/* Wait until I2Cx_DMA_STREAM_TX disabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_TX)!= DISABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear any pending flag on Tx Stream */
DMA_ClearFlag(I2Cx_DMA_STREAM_TX, I2Cx_TX_DMA_TCFLAG | I2Cx_TX_DMA_FEIFLAG | I2Cx_TX_DMA_DMEIFLAG | \
I2Cx_TX_DMA_TEIFLAG | I2Cx_TX_DMA_HTIFLAG);
/* Master Receiver -----------------------------------------------------------*/
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(I2Cx, ENABLE);
/* Send I2Cx START condition */
I2C_GenerateSTART(I2Cx, ENABLE);
#ifdef I2C_10BITS_ADDRESS
/* Test on EV5 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send Header to Slave for write */
I2C_SendData(I2Cx, HEADER_ADDRESS_Write);
/* Test on EV9 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_ADDRESS10))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send slave Address */
I2C_Send7bitAddress(I2Cx, (uint8_t)SLAVE_ADDRESS, I2C_Direction_Transmitter);
/* Test on I2Cx EV6 and clear it or time out*/
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Repeated Start */
I2C_GenerateSTART(I2Cx, ENABLE);
/* Test on EV5 and clear it or time out*/
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send Header to Slave for Read */
I2C_SendData(I2Cx, HEADER_ADDRESS_Read);
#else /* I2C_7BITS_ADDRESS */
/* Test on I2Cx EV5 and clear it or time out*/
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send I2Cx slave Address for write */
I2C_Send7bitAddress(I2Cx, SLAVE_ADDRESS, I2C_Direction_Receiver);
#endif /* I2C_10BITS_ADDRESS */
/* Test on I2Cx EV6 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* I2Cx DMA Enable */
I2C_DMACmd(I2Cx, ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_RX, ENABLE);
/* Wait until I2Cx_DMA_STREAM_RX enabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_RX)!= ENABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(I2Cx_DMA_STREAM_RX,I2Cx_RX_DMA_TCFLAG)==RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Send I2Cx STOP Condition */
I2C_GenerateSTOP(I2Cx, ENABLE);
/* Disable DMA RX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_RX, DISABLE);
/* Wait until I2Cx_DMA_STREAM_RX disabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_RX)!= DISABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Disable I2C DMA request */
I2C_DMACmd(I2Cx,DISABLE);
/* Clear any pending flag on Rx Stream */
DMA_ClearFlag(I2Cx_DMA_STREAM_RX, I2Cx_RX_DMA_TCFLAG | I2Cx_RX_DMA_FEIFLAG | I2Cx_RX_DMA_DMEIFLAG | \
I2Cx_RX_DMA_TEIFLAG | I2Cx_RX_DMA_HTIFLAG);
if (Buffercmp(TxBuffer, RxBuffer, RXBUFFERSIZE) == PASSED)
{
/* LED2, LED3 and LED4 Toggle */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
else
{ /* ED2, LED3 and LED4 On */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
#endif /* I2C_MASTER */
/**********************************Slave Code**********************************/
#if defined (I2C_SLAVE)
/* Initialize I2C peripheral */
/* I2C Init */
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DUTYCYCLE;
I2C_InitStructure.I2C_OwnAddress1 = SLAVE_ADDRESS;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;
#ifndef I2C_10BITS_ADDRESS
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
#else
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_10bit;
#endif /* I2C_10BITS_ADDRESS */
I2C_Init(I2Cx, &I2C_InitStructure);
/* Slave Receiver ------------------------------------------------------------*/
/* Test on I2C EV1 and clear it */
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED))
{}
/* I2Cx DMA Enable */
I2C_DMACmd(I2Cx, ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_RX, ENABLE);
/* Wait until I2Cx_DMA_STREAM_RX enabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_RX)!= ENABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(I2Cx_DMA_STREAM_RX,I2Cx_RX_DMA_TCFLAG)==RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Test on I2Cx EV4 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_SLAVE_STOP_DETECTED))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Disable DMA RX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_RX, DISABLE);
/* Wait until I2Cx_DMA_STREAM_RX disabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_RX)!= DISABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Disable I2C DMA request */
I2C_DMACmd(I2Cx,DISABLE);
/* Clear any pending flag on Rx Stream */
DMA_ClearFlag(I2Cx_DMA_STREAM_RX, I2Cx_RX_DMA_TCFLAG | I2Cx_RX_DMA_FEIFLAG | I2Cx_RX_DMA_DMEIFLAG | \
I2Cx_RX_DMA_TEIFLAG | I2Cx_RX_DMA_HTIFLAG);
/* Slave Transmitter ---------------------------------------------------------*/
/* Test on I2C EV1 and clear it or time out*/
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED))
{}
/* I2Cx DMA Enable */
I2C_DMACmd(I2Cx, ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_TX, ENABLE);
/* Wait until I2Cx_DMA_STREAM_TX enabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_TX)!= ENABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(I2Cx_DMA_STREAM_TX,I2Cx_TX_DMA_TCFLAG)==RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Test on I2Cx EV3-2 and clear it or time out */
TimeOut = USER_TIMEOUT;
while ((!I2C_CheckEvent(I2Cx, I2C_EVENT_SLAVE_ACK_FAILURE))&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Disable DMA TX Channel */
DMA_Cmd(I2Cx_DMA_STREAM_TX, DISABLE);
/* Wait until I2Cx_DMA_STREAM_TX disabled or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetCmdStatus(I2Cx_DMA_STREAM_TX)!= DISABLE)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Disable I2C DMA request */
I2C_DMACmd(I2Cx,DISABLE);
/* Clear any pending flag on Tx Stream */
DMA_ClearFlag(I2Cx_DMA_STREAM_TX, I2Cx_TX_DMA_TCFLAG | I2Cx_TX_DMA_FEIFLAG | I2Cx_TX_DMA_DMEIFLAG | \
I2Cx_TX_DMA_TEIFLAG | I2Cx_TX_DMA_HTIFLAG);
if (Buffercmp(TxBuffer, RxBuffer, RXBUFFERSIZE) == PASSED)
{
/* LED2, LED3 and LED4 are On */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
else
{ /* LED2, LED3 and LED4 are Off */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
#endif /* I2C_SLAVE */
while(1)
{}
}
/**
* @brief Reads a block of data from the EEPROM.
* @param pBuffer : pointer to the buffer that receives the data read from
* the EEPROM.
* @param ReadAddr : EEPROM's internal address to read from.
* @param NumByteToRead : pointer to the variable holding number of bytes to
* read from the EEPROM.
*
* @note The variable pointed by NumByteToRead is reset to 0 when all the
* data are read from the EEPROM. Application should monitor this
* variable in order know when the transfer is complete.
*
* @note When number of data to be read is higher than 1, this function just
* configure the communication and enable the DMA channel to transfer data.
* Meanwhile, the user application may perform other tasks.
* When number of data to be read is 1, then the DMA is not used.
*
* @retval None
*/
void sEE_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t* NumByteToRead)
{
/* Set the pointer to the Number of data to be read. This pointer will be used
by the DMA Transfer Completer interrupt Handler in order to reset the
variable to 0. User should check on this variable in order to know if the
DMA transfer has been complete or not. */
sEEDataReadPointer = NumByteToRead;
/*!< While the bus is busy */
while(I2C_GetFlagStatus(sEE_I2C, I2C_FLAG_BUSY))
{
}
/*!< Send START condition */
I2C_GenerateSTART(sEE_I2C, ENABLE);
/*!< Test on EV5 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
}
/*!< Send EEPROM address for write */
I2C_Send7bitAddress(sEE_I2C, sEEAddress, I2C_Direction_Transmitter);
/*!< Test on EV6 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
}
#ifdef sEE_M24C08
/*!< Send the EEPROM's internal address to read from: Only one byte address */
I2C_SendData(sEE_I2C, ReadAddr);
#elif defined (sEE_M24C64_32)
/*!< Send the EEPROM's internal address to read from: MSB of the address first */
I2C_SendData(sEE_I2C, (uint8_t)((ReadAddr & 0xFF00) >> 8));
/*!< Test on EV8 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
}
/*!< Send the EEPROM's internal address to read from: LSB of the address */
I2C_SendData(sEE_I2C, (uint8_t)(ReadAddr & 0x00FF));
#endif /*!< sEE_M24C08 */
/*!< Test on EV8 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
}
/*!< Send STRAT condition a second time */
I2C_GenerateSTART(sEE_I2C, ENABLE);
/*!< Test on EV5 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
}
/*!< Send EEPROM address for read */
I2C_Send7bitAddress(sEE_I2C, sEEAddress, I2C_Direction_Receiver);
/*!< Test on EV6 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
}
/* If number of data to be read is 1, then DMA couldn't be used */
if ((uint16_t)(*NumByteToRead) < 2)
{
/*!< Disable Acknowledgement */
I2C_AcknowledgeConfig(sEE_I2C, DISABLE);
/*!< Send STOP Condition */
I2C_GenerateSTOP(sEE_I2C, ENABLE);
/*!< Test on EV7 and clear it */
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED))
{
}
/*!< Read a byte from the EEPROM */
*pBuffer = I2C_ReceiveData(sEE_I2C);
/*!< Decrement the read bytes counter */
(uint16_t)(*NumByteToRead)--;
/*!< Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(sEE_I2C, ENABLE);
}
/* DMA could be used for number of data higher than 1 */
else
{
/* Configure the DMA Rx Channel with the buffer address and the buffer size */
sEE_LowLevel_DMAConfig((uint32_t)pBuffer, (uint16_t)(*NumByteToRead), sEE_DIRECTION_RX);
/* Inform the DMA that the next End Of Transfer Signal will be the last one */
I2C_DMALastTransferCmd(sEE_I2C, ENABLE);
/* Enable the DMA Rx Channel */
DMA_Cmd(sEE_I2C_DMA_CHANNEL_RX, ENABLE);
}
}
/**
* @brief Read the data from the chip.
* @param RegName: specifies the register to be read.
* This member can be one of the following values:
* @retval status communication.
*/
I2C_Status_TypeDef I2C_readBytes(uint8_t devAddr, uint8_t RegName,uint8_t length,uint8_t *buffer, uint32_t timeout)
{
uint32_t zero_time;
/* Configure DMA Peripheral */
I2C_DMA_Config(I2C_DMA_RX, buffer, length);
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(I2C_USE, ENABLE);
//Start condition
I2C_GenerateSTART(I2C_USE, ENABLE);
zero_time = GetTickCount();
while (!I2C_GetFlagStatus(I2C_USE,I2C_FLAG_SB))
{
if(CheckTick(zero_time,timeout) == TRUE)
{
return I2C_STATUS_TIMEOUT;
}
}
//Send device address for write
I2C_Send7bitAddress(I2C_USE, devAddr, I2C_Direction_Transmitter);
zero_time = GetTickCount();
while (!I2C_CheckEvent(I2C_USE, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if(CheckTick(zero_time,timeout) == TRUE) return I2C_STATUS_TIMEOUT;
}
/* Send the device's internal address to write to */
I2C_SendData(I2C_USE, RegName);
zero_time = GetTickCount();
while ((!I2C_GetFlagStatus(I2C_USE,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(I2C_USE,I2C_FLAG_BTF)))
{
if(CheckTick(zero_time,timeout) == TRUE) return I2C_STATUS_TIMEOUT;
}
/* Send START condition a second time */
I2C_GenerateSTART(I2C_USE, ENABLE);
/* Test on SB Flag */
zero_time = GetTickCount();
while (!I2C_GetFlagStatus(I2C_USE,I2C_FLAG_SB))
{
if(CheckTick(zero_time,timeout) == TRUE) return I2C_STATUS_TIMEOUT;
}
/* Send address for read */
I2C_Send7bitAddress(I2C_USE, devAddr, I2C_Direction_Receiver);
/* Test on ADDR Flag */
zero_time = GetTickCount();
while (!I2C_CheckEvent(I2C_USE, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
if(CheckTick(zero_time,timeout) == TRUE) return I2C_STATUS_TIMEOUT;
}
/* Enable I2C DMA request */
I2C_DMACmd(I2C_USE,ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(I2C_DMA_RX_CHANNEL, ENABLE);
/* Wait until DMA Transfer Complete */
zero_time = GetTickCount();
while (!DMA_GetFlagStatus(I2C_DMA_RX_TCFLAG))
{
if(CheckTick(zero_time,timeout) == TRUE) return I2C_STATUS_TIMEOUT;
}
/* Send STOP Condition */
I2C_GenerateSTOP(I2C_USE, ENABLE);
/* Disable DMA RX Channel */
DMA_Cmd(I2C_DMA_RX_CHANNEL, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(I2C_USE,DISABLE);
/* Clear DMA RX Transfer Complete Flag */
DMA_ClearFlag(I2C_DMA_RX_TCFLAG);
/* return a Reg value */
return I2C_STATUS_SUCCESS;
}
/*=====================================================================================================*/
u32 I2C_DMA_ReadReg(u8 SlaveAddr, u8 ReadAddr, u8 *ReadBuf, u8 NumByte)
{
I2C_ReadPtr = &NumByte;
I2C_TimeCnt = I2C_TIMEOUT;
while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_GenerateSTART(I2Cx, ENABLE);
I2C_TimeCnt = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_Send7bitAddress(I2Cx, SlaveAddr, I2C_Direction_Transmitter);
I2C_TimeCnt = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_SendData(I2Cx, ReadAddr);
I2C_TimeCnt = I2C_TIMEOUT;
while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_BTF) == RESET)
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_GenerateSTART(I2Cx, ENABLE);
I2C_TimeCnt = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_Send7bitAddress(I2Cx, SlaveAddr, I2C_Direction_Receiver);
if (NumByte < 2) {
I2C_TimeCnt = I2C_TIMEOUT;
while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_ADDR) == RESET)
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_AcknowledgeConfig(I2Cx, DISABLE);
(void)I2Cx->SR2;
I2C_GenerateSTOP(I2Cx, ENABLE);
I2C_TimeCnt = I2C_TIMEOUT;
while (I2C_GetFlagStatus(I2Cx, I2C_FLAG_RXNE) == RESET)
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
*ReadBuf = I2C_ReceiveData(I2Cx);
NumByte--;
I2C_TimeCnt = I2C_TIMEOUT;
while (I2Cx->CR1 & I2C_CR1_STOP)
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
I2C_AcknowledgeConfig(I2Cx, ENABLE);
} else {
I2C_TimeCnt = I2C_TIMEOUT;
while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
DMA_InitStruct.DMA_Channel = DMAx_RX_CHANNEL;
DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)I2Cx_DR_ADDR;
DMA_InitStruct.DMA_Memory0BaseAddr = (u32)ReadBuf;
DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStruct.DMA_BufferSize = (u32)(NumByte);
DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
DMA_InitStruct.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStruct.DMA_FIFOMode = DMA_FIFOMode_Enable;
DMA_InitStruct.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
DMA_InitStruct.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStruct.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(DMAx_RX_STREAM, &DMA_InitStruct);
I2C_DMALastTransferCmd(I2Cx, ENABLE);
DMA_Cmd(DMAx_RX_STREAM, ENABLE);
}
I2C_TimeCnt = I2C_TIMEOUT;
while (NumByte > 0)
if ((I2C_TimeCnt--) == 0) return I2C_TimeOut();
return SUCCESS;
}
uint32_t i2c_read(i2c_dev *dev, uint8_t addr, uint8_t *tx_buff, uint8_t txlen, uint8_t *rx_buff, uint8_t *rxlen)
{
/* Set the pointer to the Number of data to be read. This pointer will be used
by the DMA Transfer Completer interrupt Handler in order to reset the
variable to 0. User should check on this variable in order to know if the
DMA transfer has been complete or not. */
if(dev->I2Cx == I2C1)
I2C1DataReadPointer = (uint16_t*) rxlen;
else
I2C2DataReadPointer = (uint16_t*) rxlen;
//uint16_t received;
//int flags;
//uint16_t ptr;
uint8_t *buffer8 = rx_buff;
//errno_r = 0;
//received = 0;
// While the bus is busy
dev->timeout = sEE_LONG_TIMEOUT;
while (I2C_GetFlagStatus(dev->I2Cx, I2C_FLAG_BUSY ))
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
// Send START condition
I2C_GenerateSTART(dev->I2Cx, ENABLE);
// Test on EV5 and clear it (cleared by reading SR1 then writing to DR)
dev->timeout = sEE_FLAG_TIMEOUT;
while (!I2C_CheckEvent(dev->I2Cx, I2C_EVENT_MASTER_MODE_SELECT ))
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
// Send address for write
I2C_Send7bitAddress(dev->I2Cx, addr, I2C_Direction_Transmitter );
dev->timeout = sEE_FLAG_TIMEOUT;
// Test on EV6 and clear it
while (!I2C_CheckEvent(dev->I2Cx,
I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ))
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
I2C_SendData(dev->I2Cx, *tx_buff++);
// Test on EV8 and clear it
dev->timeout = sEE_FLAG_TIMEOUT;
while (I2C_GetFlagStatus(dev->I2Cx, I2C_FLAG_BTF ) == RESET)
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
// Send STRAT condition a second time
I2C_GenerateSTART(dev->I2Cx, ENABLE);
// Test on EV5 and clear it (cleared by reading SR1 then writing to DR)
dev->timeout = sEE_FLAG_TIMEOUT;
while (!I2C_CheckEvent(dev->I2Cx, I2C_EVENT_MASTER_MODE_SELECT ))
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
// Send address for read
I2C_Send7bitAddress(dev->I2Cx, addr, I2C_Direction_Receiver );
if ((uint16_t)(*rxlen) < 2)
{
dev->timeout = sEE_FLAG_TIMEOUT;
while (I2C_GetFlagStatus(dev->I2Cx, I2C_FLAG_ADDR ) == RESET)
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
// Disable Acknowledgement
I2C_AcknowledgeConfig(dev->I2Cx, DISABLE);
/* Clear ADDR register by reading SR1 then SR2 register (SR1 has already been read) */
(void) dev->I2Cx->SR2;
/*!< STOP condition */
I2C_GenerateSTOP(dev->I2Cx, DISABLE);
I2C_ClearFlag(dev->I2Cx, I2C_FLAG_STOPF );
/* Send STOP condition */
I2C_GenerateSTOP(dev->I2Cx, ENABLE);
/* Wait for the byte to be received */
dev->timeout = sEE_FLAG_TIMEOUT;
while (I2C_GetFlagStatus(dev->I2Cx, I2C_FLAG_RXNE ) == RESET)
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
/*!< Read the byte received from the EEPROM */
*buffer8 = I2C_ReceiveData(dev->I2Cx);
(uint16_t)(*rxlen)--;
/* Wait to make sure that STOP control bit has been cleared */
dev->timeout = sEE_FLAG_TIMEOUT;
while (dev->I2Cx->CR1 & I2C_CR1_STOP )
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
// Re-Enable Acknowledgement to be ready for another reception
I2C_AcknowledgeConfig(dev->I2Cx, ENABLE);
}
else/* More than one Byte Master Reception procedure (DMA) -----------------*/
{
/*!< Test on EV6 and clear it */
dev->timeout = sEE_FLAG_TIMEOUT;
while (!I2C_CheckEvent(dev->I2Cx,
I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED ))
{
if ((dev->timeout--) == 0)
return I2C_ERROR;
}
/* Configure the DMA Rx Channel with the buffer address and the buffer size */
sEE_LowLevel_DMAConfig(dev, (uint32_t) buffer8, (uint16_t)(*rxlen),
sEE_DIRECTION_RX);
/* Inform the DMA that the next End Of Transfer Signal will be the last one */
I2C_DMALastTransferCmd(dev->I2Cx, ENABLE);
/* Enable the DMA Rx Stream */
if (dev->I2Cx == I2C1){
DMA_Cmd(sEE_I2C1_DMA_STREAM_RX, ENABLE);
} else if(dev->I2Cx == I2C2){
DMA_Cmd(sEE_I2C2_DMA_STREAM_RX, ENABLE);
}
/* Enable the sEE_I2C peripheral DMA requests */
I2C_DMACmd(dev->I2Cx, ENABLE);
}
return I2C_OK;
}
/**
* @brief Enables or disables the LM75.
* @param NewState: specifies the LM75 new status. This parameter can be ENABLE
* or DISABLE.
* @retval None
*/
uint8_t LM75_ShutDown(FunctionalState NewState)
{
uint8_t LM75_BufferRX[2] ={0,0};
uint8_t LM75_BufferTX = 0;
__IO uint8_t RegValue = 0;
/* Test on BUSY Flag */
LM75_Timeout = LM75_LONG_TIMEOUT;
while (I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BUSY))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Configure DMA Peripheral */
LM75_DMA_Config(LM75_DMA_RX, (uint8_t*)LM75_BufferRX, 2);
/* Enable DMA NACK automatic generation */
I2C_DMALastTransferCmd(LM75_I2C, ENABLE);
/* Enable the I2C peripheral */
I2C_GenerateSTART(LM75_I2C, ENABLE);
/* Test on SB Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_SB))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send device address for write */
I2C_Send7bitAddress(LM75_I2C, LM75_ADDR, I2C_Direction_Transmitter);
/* Test on ADDR Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_CheckEvent(LM75_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send the device's internal address to write to */
I2C_SendData(LM75_I2C, LM75_REG_CONF);
/* Test on TXE FLag (data sent) */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while ((!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BTF)))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send START condition a second time */
I2C_GenerateSTART(LM75_I2C, ENABLE);
/* Test on SB Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_SB))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send LM75 address for read */
I2C_Send7bitAddress(LM75_I2C, LM75_ADDR, I2C_Direction_Receiver);
/* Test on ADDR Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_CheckEvent(LM75_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Enable I2C DMA request */
I2C_DMACmd(LM75_I2C,ENABLE);
/* Enable DMA RX Channel */
DMA_Cmd(LM75_DMA_RX_CHANNEL, ENABLE);
/* Wait until DMA Transfer Complete */
LM75_Timeout = LM75_LONG_TIMEOUT;
while (!DMA_GetFlagStatus(LM75_DMA_RX_TCFLAG))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send STOP Condition */
I2C_GenerateSTOP(LM75_I2C, ENABLE);
/* Disable DMA RX Channel */
DMA_Cmd(LM75_DMA_RX_CHANNEL, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(LM75_I2C,DISABLE);
/* Clear DMA RX Transfer Complete Flag */
DMA_ClearFlag(LM75_DMA_RX_TCFLAG);
/*!< Get received data */
RegValue = (uint8_t)LM75_BufferRX[0];
/*---------------------------- Transmission Phase ---------------------------*/
/*!< Enable or disable SD bit */
if (NewState != DISABLE)
{
/*!< Enable LM75 */
LM75_BufferTX = RegValue & LM75_SD_RESET;
}
else
{
/*!< Disable LM75 */
LM75_BufferTX = RegValue | LM75_SD_SET;
}
/* Test on BUSY Flag */
LM75_Timeout = LM75_LONG_TIMEOUT;
while (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BUSY))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Configure DMA Peripheral */
LM75_DMA_Config(LM75_DMA_TX, (uint8_t*)(&LM75_BufferTX), 1);
/* Enable the I2C peripheral */
I2C_GenerateSTART(LM75_I2C, ENABLE);
/* Test on SB Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_SB) == RESET)
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Transmit the slave address and enable writing operation */
I2C_Send7bitAddress(LM75_I2C, LM75_ADDR, I2C_Direction_Transmitter);
/* Test on ADDR Flag */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while (!I2C_CheckEvent(LM75_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Transmit the first address for r/w operations */
I2C_SendData(LM75_I2C, LM75_REG_CONF);
/* Test on TXE FLag (data sent) */
LM75_Timeout = LM75_FLAG_TIMEOUT;
while ((!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_TXE)) && (!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BTF)))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Enable I2C DMA request */
I2C_DMACmd(LM75_I2C,ENABLE);
/* Enable DMA TX Channel */
DMA_Cmd(LM75_DMA_TX_CHANNEL, ENABLE);
/* Wait until DMA Transfer Complete */
LM75_Timeout = LM75_LONG_TIMEOUT;
while (!DMA_GetFlagStatus(LM75_DMA_TX_TCFLAG))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Wait until BTF Flag is set before generating STOP */
LM75_Timeout = LM75_LONG_TIMEOUT;
while ((!I2C_GetFlagStatus(LM75_I2C,I2C_FLAG_BTF)))
{
if((LM75_Timeout--) == 0) return LM75_TIMEOUT_UserCallback();
}
/* Send STOP Condition */
I2C_GenerateSTOP(LM75_I2C, ENABLE);
/* Disable DMA TX Channel */
DMA_Cmd(LM75_DMA_TX_CHANNEL, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(LM75_I2C,DISABLE);
/* Clear DMA TX Transfer Complete Flag */
DMA_ClearFlag(LM75_DMA_TX_TCFLAG);
return LM75_OK;
}
/**
* @brief Reads buffer of bytes from the slave.
* @param pBuffer: Buffer of bytes to read from the slave.
* @param NumByteToRead: Number of bytes to be read by the Master.
* @retval : None.
*/
void I2C_Master_BufferRead(uint8_t* pBuffer, uint16_t NumByteToRead)
{
#ifdef DMA_Master_Receive
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)pBuffer;
DMA_InitStructure.DMA_BufferSize = NumByteToRead;
DMA_Init(DMA1_Channel7, &DMA_InitStructure);
I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE);
/* Set Last bit to have a NACK on the last received byte */
I2C_DMALastTransferCmd(I2C1, ENABLE);
I2C_DMACmd(I2C1, ENABLE);
/* Enable the DMA Channel7 Transfer Complete IT */
DMA_ITConfig(DMA1_Channel7, DMA_IT_TC, ENABLE);
/* Generate the START */
I2C_GenerateSTART(I2C1, ENABLE);
#endif
#ifdef Polling_Master_Receive
/* Send START condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on EV5 and clear it */
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
/* Send slave address for read */
I2C_Send7bitAddress(I2C1, SLAVE_ADDRESS, I2C_Direction_Receiver);
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* While there is data to be read; here the safe procedure is implemented */
while (NumByteToRead)
{
if (NumByteToRead != 3) /* Receive bytes from first byte until byte N-3 */
{
while ((I2C_GetLastEvent(I2C1) & 0x00004) != 0x000004); /* Poll on BTF */
/* Read data */
*pBuffer = I2C_ReceiveData(I2C1);
pBuffer++;
/* Decrement the read bytes counter */
NumByteToRead--;
}
if (NumByteToRead == 3) /* it remains to read three data: data N-2, data N-1, Data N */
{
/* Data N-2 in DR and data N -1 in shift register */
while ((I2C_GetLastEvent(I2C1) & 0x000004) != 0x0000004); /* Poll on BTF */
/* Clear ACK */
I2C_AcknowledgeConfig(I2C1, DISABLE);
__disable_irq();
/* Read Data N-2 */
*pBuffer = I2C_ReceiveData(I2C1);
pBuffer++;
/* Program the STOP */
I2C_GenerateSTOP(I2C1, ENABLE);
/* Read DataN-1 */
*pBuffer = I2C_ReceiveData(I2C1);
__enable_irq();
pBuffer++;
while ((I2C_GetLastEvent(I2C1) & 0x00000040) != 0x0000040); /* Poll on RxNE */
/* Read DataN */
*pBuffer = I2C1->DR;
/* Reset the number of bytes to be read by master */
NumByteToRead = 0;
}
}
/* Make sure that the STOP bit is cleared by Hardware before CR1 write access */
while ((I2C1->CR1&0x200) == 0x200);
/* Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(I2C1, ENABLE);
#endif
}
/**
* @brief Reads a block of data from the EEPROM.
* @param pBuffer : pointer to the buffer that receives the data read from
* the EEPROM.
* @param ReadAddr : EEPROM's internal address to start reading from.
* @param NumByteToRead : pointer to the variable holding number of bytes to
* be read from the EEPROM.
*
* @note The variable pointed by NumByteToRead is reset to 0 when all the
* data are read from the EEPROM. Application should monitor this
* variable in order know when the transfer is complete.
*
* @note When number of data to be read is higher than 1, this function just
* configures the communication and enable the DMA channel to transfer data.
* Meanwhile, the user application may perform other tasks.
* When number of data to be read is 1, then the DMA is not used. The byte
* is read in polling mode.
*
* @retval sEE_OK (0) if operation is correctly performed, else return value
* different from sEE_OK (0) or the timeout user callback.
*/
uint32_t sEE_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t* NumByteToRead)
{
/* Set the pointer to the Number of data to be read. This pointer will be used
by the DMA Transfer Completer interrupt Handler in order to reset the
variable to 0. User should check on this variable in order to know if the
DMA transfer has been complete or not. */
sEEDataReadPointer = NumByteToRead;
/*!< While the bus is busy */
sEETimeout = sEE_LONG_TIMEOUT;
while(I2C_GetFlagStatus(sEE_I2C, I2C_FLAG_BUSY))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Send START condition */
I2C_GenerateSTART(sEE_I2C, ENABLE);
/*!< Test on EV5 and clear it (cleared by reading SR1 then writing to DR) */
sEETimeout = sEE_FLAG_TIMEOUT;
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Send EEPROM address for write */
I2C_Send7bitAddress(sEE_I2C, sEEAddress, I2C_Direction_Transmitter);
/*!< Test on EV6 and clear it */
sEETimeout = sEE_FLAG_TIMEOUT;
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Send the EEPROM's internal address to read from: MSB of the address first */
I2C_SendData(sEE_I2C, (uint8_t)((ReadAddr & 0xFF00) >> 8));
/*!< Test on EV8 and clear it */
sEETimeout = sEE_FLAG_TIMEOUT;
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Send the EEPROM's internal address to read from: LSB of the address */
I2C_SendData(sEE_I2C, (uint8_t)(ReadAddr & 0x00FF));
/*!< Test on EV8 and clear it */
sEETimeout = sEE_FLAG_TIMEOUT;
while(I2C_GetFlagStatus(sEE_I2C, I2C_FLAG_BTF) == RESET)
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Send STRAT condition a second time */
I2C_GenerateSTART(sEE_I2C, ENABLE);
/*!< Test on EV5 and clear it (cleared by reading SR1 then writing to DR) */
sEETimeout = sEE_FLAG_TIMEOUT;
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Send EEPROM address for read */
I2C_Send7bitAddress(sEE_I2C, sEEAddress, I2C_Direction_Receiver);
/* If number of data to be read is 1, then DMA couldn't be used */
/* One Byte Master Reception procedure (POLLING) ---------------------------*/
if ((uint16_t)(*NumByteToRead) < 2)
{
/* Wait on ADDR flag to be set (ADDR is still not cleared at this level */
sEETimeout = sEE_FLAG_TIMEOUT;
while(I2C_GetFlagStatus(sEE_I2C, I2C_FLAG_ADDR) == RESET)
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Disable Acknowledgement */
I2C_AcknowledgeConfig(sEE_I2C, DISABLE);
/* Clear ADDR register by reading SR1 then SR2 register (SR1 has already been read) */
(void)sEE_I2C->SR2;
/*!< Send STOP Condition */
I2C_GenerateSTOP(sEE_I2C, ENABLE);
/* Wait for the byte to be received */
sEETimeout = sEE_FLAG_TIMEOUT;
while(I2C_GetFlagStatus(sEE_I2C, I2C_FLAG_RXNE) == RESET)
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Read the byte received from the EEPROM */
*pBuffer = I2C_ReceiveData(sEE_I2C);
/*!< Decrement the read bytes counter */
(uint16_t)(*NumByteToRead)--;
/* Wait to make sure that STOP control bit has been cleared */
sEETimeout = sEE_FLAG_TIMEOUT;
while(sEE_I2C->CR1 & I2C_CR1_STOP)
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/*!< Re-Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(sEE_I2C, ENABLE);
}
else/* More than one Byte Master Reception procedure (DMA) -----------------*/
{
/*!< Test on EV6 and clear it */
sEETimeout = sEE_FLAG_TIMEOUT;
while(!I2C_CheckEvent(sEE_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/* Configure the DMA Rx Channel with the buffer address and the buffer size */
sEE_LowLevel_DMAConfig((uint32_t)pBuffer, (uint16_t)(*NumByteToRead), sEE_DIRECTION_RX);
/* Inform the DMA that the next End Of Transfer Signal will be the last one */
I2C_DMALastTransferCmd(sEE_I2C, ENABLE);
/* Enable the DMA Rx Stream */
DMA_Cmd(sEE_I2C_DMA_STREAM_RX, ENABLE);
}
/* If all operations OK, return sEE_OK (0) */
return sEE_OK;
}
/**
* @brief Reads a block of data from the FLASH.
* @param pBuffer : pointer to the buffer that receives the data read
* from the FLASH.
* @param ReadAddr : FLASH's internal address to read from.
* @param NumByteToRead : number of bytes to read from the FLASH.
* @retval : None
*/
void I2C_FLASH_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
uint32_t add_flash;
__IO uint32_t Rx1_Idx=0;
/*----------------------------1st sequence----------------------------------*/
i2c_send_opcode(OPC_READ,I2C1_Buffer_Tx);
add_flash = ReadAddr + 0x08000000;
i2c_send_add(add_flash,I2C1_Buffer_Tx);
i2c_send_byte_number(NumByteToRead,I2C1_Buffer_Tx);
/* Initialize the DMA Transmit counter: transmit opcode + address + number of data to be read */
DMA1_Channel6->CNDTR = 7;
/* Enable DMA1 Channel6 */
DMA_Cmd(DMA1_Channel6, ENABLE);
/* Send I2C1 START condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV5 and clear it */
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
/* Send I2C2 slave Address for write */
I2C_Send7bitAddress(I2C1, I2C_SLAVE_ADDRESS7, I2C_Direction_Transmitter);
/* Test on I2C1 EV6 and clear it */
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* DMA1 Channel6 transfer complete test */
while (!DMA_GetFlagStatus(DMA1_FLAG_TC6));
DMA_ClearFlag(DMA1_FLAG_TC6);
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* Send I2C1 STOP Condition */
I2C_GenerateSTOP(I2C1, ENABLE);
DMA_Cmd(DMA1_Channel6, DISABLE);
/*-------------------------------2nd sequence---------------------------------*/
DMA1_Channel7->CNDTR = (BufferSize-8);
/*Enable the last transfer bit*/
I2C_DMALastTransferCmd(I2C1, ENABLE);
/* Send I2C1 START condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV5 and clear it */
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
/* Send slave Address for write */
I2C_Send7bitAddress(I2C1, I2C_SLAVE_ADDRESS7, I2C_Direction_Receiver );
/* Test on I2C1 EV7 and clear it */
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
DMA_Cmd(DMA1_Channel7, ENABLE);
/* DMA1 Channel6 transfer complete test */
while (!DMA_GetFlagStatus(DMA1_FLAG_TC7));
DMA_ClearFlag(DMA1_FLAG_TC7);
DMA_Cmd(DMA1_Channel7, DISABLE);
/* Send I2C1 STOP Condition */
I2C_GenerateSTOP(I2C1, ENABLE);
while (NumByteToRead--) /* while there is data to be read */
{
*pBuffer = I2C1_Buffer_Rx[Rx1_Idx++];
/* Point to the next location where the byte read will be saved */
pBuffer++;
}
/* Reset the receive counter */
Rx1_Idx=0;
}
