/*******************************************************************************
* Function Name : I2C_EE_PageWrite
* Description : Writes more than one byte to the EEPROM with a single WRITE
* cycle. The number of byte can't exceed the EEPROM page size.
* Input : - pBuffer : pointer to the buffer containing the data to be
* written to the EEPROM.
* - WriteAddr : EEPROM's internal address to write to.
* - NumByteToWrite : number of bytes to write to the EEPROM.
* Output : None
* Return : None
*******************************************************************************/
void I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite)
{
/* Send START condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
/* Send EEPROM address for write */
I2C_Send7bitAddress(I2C1, EEPROM_ADDRESS, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Send the EEPROM's internal address to write to */
I2C_SendData(I2C1, WriteAddr);
/* Test on EV8 and clear it */
while(! I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* While there is data to be written */
while(NumByteToWrite--)
{
/* Send the current byte */
I2C_SendData(I2C1, *pBuffer);
/* Point to the next byte to be written */
pBuffer++;
/* Test on EV8 and clear it */
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
}
/* Send STOP condition */
I2C_GenerateSTOP(I2C1, ENABLE);
}
/**
* @brief Returns the RDAC register. The potentiometer value in ohm is
* given by the formula (cDValue/256*Rab + Rw), where Rab = xxxx and Rw = 60 ohm.
* @param xDigipot specifies what digipot has to be set.
* This parameter can be DIGIPOT1 or DIGIPOT2.
* @param pcDValue pointer to the variable in which the D value has to be stored.
* This parameter is an uint8_t*.
* @retval uint8_t Notifies if an I2C error has occured or if the communication has been correctly done.
* This parameter can be I2C_DIGIPOT_OK or I2C_DIGIPOT_ERROR.
*/
uint8_t SdkEvalPmDigipotRead(SdkEvalDigipot xDigipot, uint8_t* pcDValue)
{
/* Test on BUSY flag */
while (I2C_GetFlagStatus(DIGIPOT_I2C,I2C_FLAG_BUSY)) I2C_WAIT_TIMER();
/* Sends START condition */
I2C_GenerateSTART(DIGIPOT_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(DIGIPOT_I2C, I2C_EVENT_MASTER_MODE_SELECT)) I2C_WAIT_TIMER();
/* Sends address for read */
I2C_Send7bitAddress(DIGIPOT_I2C, s_vectxDigipotAddress[xDigipot], I2C_Direction_Receiver);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(DIGIPOT_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) I2C_WAIT_TIMER();
/* Disables acknowledgement */
I2C_AcknowledgeConfig(DIGIPOT_I2C, DISABLE);
/* Test on EV7 and clear it */
while(!I2C_CheckEvent(DIGIPOT_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED)) I2C_WAIT_TIMER();
/* Read a byte from DIGIPOT */
*pcDValue = I2C_ReceiveData(DIGIPOT_I2C);
/* Sends STOP Condition */
I2C_GenerateSTOP(DIGIPOT_I2C, ENABLE);
/* Enables acknowledgement to be ready for a new I2C operation */
I2C_AcknowledgeConfig(DIGIPOT_I2C,ENABLE);
/* Returns I2C operation OK value */
return I2C_DIGIPOT_OK;
}
static void SSD1306_WRITEMULTI(uint8_t* data, uint16_t count)
{
__disable_irq();
//Wait until I2C isn't busy
while(I2C_GetFlagStatus(I2C2, I2C_FLAG_BUSY) == SET);
I2C_TransferHandling(I2C2, SSD1306_I2C_ADDR, count + 1, I2C_AutoEnd_Mode, I2C_CR2_START); // Configure slave address, nbytes, reload, end mode and start or stop generation
while(I2C_GetFlagStatus(I2C2, I2C_ISR_TXIS) == RESET){}; // Wait until TXIS flag is set, waiting ACK
I2C_SendData(I2C2, 0x40);// Send Register address
while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXE) == RESET);
for (uint8_t i = 0; i < count; i++)
{
I2C_SendData(I2C2, data[i]); // Send data
while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXE) == RESET);
}
I2C_GenerateSTOP(I2C2, ENABLE);
while(I2C_GetFlagStatus(I2C2, I2C_ISR_STOPF) == RESET){};// Wait until STOPF flag is set
I2C_ClearFlag(I2C2, I2C_ICR_STOPCF); // Clear STOPF flag
__enable_irq();
}
char ARead_ATP(int slave_add)
{
char rdata;
I2C_Cmd(I2C1,ENABLE);
I2C_GenerateSTART(I2C1,ENABLE);
while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(I2C1,slave_add,I2C_Direction_Receiver);
while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
I2C_AcknowledgeConfig(I2C1,DISABLE);
I2C_GenerateSTOP(I2C1, ENABLE);
while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_RECEIVED));
rdata = I2C_ReceiveData(I2C1);
return rdata;
}
void LIS35_ReadRegister(char addr,char *v)
{
//Reads one register value
I2C_GenerateSTART(LIS35_I2C,ENABLE);
//Test on EV5 and clear it
while(!I2C_CheckEvent(LIS35_I2C, I2C_EVENT_MASTER_MODE_SELECT));
//Send LIS35 address, set I2C master in transmiter mode
I2C_Send7bitAddress(LIS35_I2C, LIS35_Addr, I2C_Direction_Transmitter);
//Test on EV6 and clear it
while(!I2C_CheckEvent(LIS35_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
//Send LIS35 local register address, which will be read
I2C_SendData(LIS35_I2C, addr);
// Test on EV8 and clear it
while(!I2C_CheckEvent(LIS35_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
//Re-generate START, transmition from slave beginning
I2C_GenerateSTART(LIS35_I2C,ENABLE);
//Test on EV5 and clear it
while(!I2C_CheckEvent(LIS35_I2C, I2C_EVENT_MASTER_MODE_SELECT));
//Send LIS35 address, set I2C master in receiver mode
I2C_Send7bitAddress(LIS35_I2C, LIS35_Addr, I2C_Direction_Receiver);
//Only one byte will be received
//NAck must be configured just before checking EV6 -> disable Acknowledge
I2C_AcknowledgeConfig(LIS35_I2C, DISABLE);
//Test on EV6 and clear it
while(!I2C_CheckEvent(LIS35_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
//Generate STOP Condition
I2C_GenerateSTOP(LIS35_I2C,ENABLE);
//Test on EV7 and clear it - Wait until DataN is in Shift register
while(!I2C_CheckEvent(LIS35_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED));
//Read DataN from DR register
*v=I2C_ReceiveData(LIS35_I2C);
//Enable Acknowledge for next transmission
I2C_AcknowledgeConfig(LIS35_I2C, ENABLE);
}
void mpu6050_i2c_byte_write(u8 write_data, u8 reg_addr)
{
while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_BUSY));
//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 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));
//send internal address to write to
I2C_SendData( MPU6050_I2C, reg_addr);
//test on ev8
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
//send the byte to be written
I2C_SendData(MPU6050_I2C,write_data);
//test on ev8
while(!I2C_CheckEvent(MPU6050_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
//send stop condition
I2C_GenerateSTOP( MPU6050_I2C, ENABLE);
//i2c_wait_stand();
}
/**
@brief Write to I2C
@param[in] devnum I2C peripheral number (1 or 2)
@param[in] adr I2C address
@param[in] buf pointer to data
@param[in] nbyte number of bytes to write (nbyte <= sizeof(buf))
@return 0 on success, non-zero otherwise
*/
uint8_t i2c_wr(uint8_t devnum, uint8_t adr, const uint8_t* buf, uint32_t nbyte)
{
I2C_TypeDef* I2Cx = i2c_get_pdef(devnum)->i2c;
//__IO uint32_t Timeout = 0;
/* Enable Error IT (used in all modes: DMA, Polling and Interrupts */
// I2Cx->CR2 |= I2C_IT_ERR;
if (nbyte) {
i2c_waitfor(I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY), 1);
// Intiate Start Sequence
I2C_GenerateSTART(I2Cx, ENABLE);
i2c_waitfor(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT), 2);
// Send Address EV5
I2C_Send7bitAddress(I2Cx, adr, I2C_Direction_Transmitter);
i2c_waitfor(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED), 3);
// EV6
// Write first byte EV8_1
I2C_SendData(I2Cx, *buf++);
while (--nbyte) {
// wait on BTF
i2c_waitfor(!I2C_GetFlagStatus(I2Cx, I2C_FLAG_BTF), 4);
I2C_SendData(I2Cx, *buf++);
}
i2c_waitfor(!I2C_GetFlagStatus(I2Cx, I2C_FLAG_BTF), 5);
I2C_GenerateSTOP(I2Cx, ENABLE);
i2c_waitfor(I2C_GetFlagStatus(I2C1, I2C_FLAG_STOPF), 6);
}
return 0;
}
uint8_t I2C_Read8(uint8_t addr, uint8_t reg)
{
uint8_t data = 0;
I2C_AcknowledgeConfig(I2C1, ENABLE);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY));
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB));
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT));
I2C_Send7bitAddress(I2C1, addr<<1,I2C_Direction_Transmitter);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
I2C_SendData(I2C1, reg);
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
I2C_GenerateSTART(I2C1, ENABLE);
while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_SB));
I2C_Send7bitAddress(I2C1, addr<<1, I2C_Direction_Receiver);
while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
I2C_NACKPositionConfig(I2C1, I2C_NACKPosition_Current);
I2C_AcknowledgeConfig(I2C1, DISABLE);
//need to add a wait here for new data, right now it goes to fast to get the new data.
while(!I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE));
data = I2C_ReceiveData(I2C1);
//while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_RECEIVED));
I2C_GenerateSTOP(I2C1, ENABLE);
while(I2C_GetFlagStatus(I2C1, I2C_FLAG_STOPF));
return data;
}
/**
* @brief This function handles the DMA Tx Channel interrupt Handler.
* @param None
* @retval None
*/
void I2C_DMA_TX_IRQHandler(i2c_dev *dev)
{
/* Check if the DMA transfer is complete */
if (DMA_GetFlagStatus(dev->dma_tx_ftc) != RESET)
{
/* Disable the DMA Tx Stream and Clear TC flag */
DMA_Cmd(dev->dma_tx_chan, DISABLE);
DMA_ClearFlag(dev->dma_tx_ftc);
/*!< Wait till all data have been physically transferred on the bus */
I2CTimeout = I2C_LONG_TIMEOUT;
while (!I2C_GetFlagStatus(dev->I2Cx, I2C_FLAG_BTF ))
{
if ((I2CTimeout--) == 0)
return;
}
/*!< Send STOP condition */
I2C_GenerateSTOP(dev->I2Cx, ENABLE);
/* Reset the variable holding the number of data to be written */
*I2CDataWritePointer = 0;
}
}
/**
* @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;
}
void crI2c( xCoRoutineHandle xHandle,
unsigned portBASE_TYPE uxIndex )
{
static uint8_t i;
crSTART( xHandle );
for ( ;; )
{
static uint8_t init = 0;
if ( init == 0 )
{
i2cSetEn( 0, 1 );
uint8_t data[1];
data[0] = 77;
i2cIo( 0, 0, 1, 1, data );
i2cConfig( 0, 0, 123, 10000 );
init = 1;
}
TI2C * idc = i2c( uxIndex );
// Commands loop.
if ( idc->master )
{
if ( ( idc->sendCnt ) || ( idc->receiveCnt ) )
{
idc->status = I2C_BUSY;
// wait for BUSY bit to get cleared.
idc->elapsed = 0;
while ( I2C_GetFlagStatus( idc->i2c, I2C_FLAG_BUSY ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_BUSY;
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
if ( idc->sendCnt )
{
// Generate START condition on a bus.
I2C_GenerateSTART( idc->i2c, ENABLE );
idc->status = I2C_MMS;
// Wait for SB to be set
idc->elapsed = 0;
while ( !I2C_CheckEvent( idc->i2c, I2C_EVENT_MASTER_MODE_SELECT ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_MMS;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
// Transmit the slave address with write operation enabled.
I2C_Send7bitAddress( idc->i2c, idc->address, I2C_Direction_Transmitter );
idc->status = I2C_TMS;
// Test on ADDR flag.
idc->elapsed = 0;
while ( !I2C_CheckEvent( idc->i2c, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_TMS;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
// Read data from send queue.
for ( i=0; i<idc->sendCnt; i++ )
{
idc = i2c( uxIndex );
// Transmit data.
uint8_t data = idc->sendQueue[ i ];
I2C_SendData( idc->i2c, data );
// Test for TXE flag (data sent).
idc->status = I2C_MBT;
idc->elapsed = 0;
while ( !I2C_CheckEvent( idc->i2c, I2C_EVENT_MASTER_BYTE_TRANSMITTED ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_MBT;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
idc->bytesWritten = i+1;
}
// Wait untill BTF flag is set before generating STOP.
idc->status = I2C_BTF;
idc->elapsed = 0;
while ( !I2C_GetFlagStatus( idc->i2c, I2C_FLAG_BTF ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_BTF;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
}
// Receiving data if necessary.
if ( idc->receiveCnt )
{
I2C_AcknowledgeConfig( idc->i2c, ENABLE );
// Generate START condition if there was at least one byte written.
I2C_GenerateSTART( idc->i2c, ENABLE );
idc->status = I2C_MMS_R;
// Wait for SB to be set
idc->elapsed = 0;
while ( !I2C_CheckEvent( idc->i2c, I2C_EVENT_MASTER_MODE_SELECT ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_MMS_R;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
I2C_Send7bitAddress( idc->i2c, idc->address, I2C_Direction_Receiver );
// Test on ADDR Flag
idc->status = I2C_RMS;
idc->elapsed = 0;
while ( !I2C_CheckEvent( idc->i2c, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_RMS;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
// Receiving a number of bytes from slave.
for ( i=0; i<idc->receiveCnt; i++ )
{
// Turn acknowledge off when reading the last byte.
if ( i == (idc->receiveCnt-1) )
I2C_AcknowledgeConfig( idc->i2c, DISABLE );
// Wait for data available.
idc->status = I2C_MBR;
idc->elapsed = 0;
while ( !I2C_CheckEvent( idc->i2c, I2C_EVENT_MASTER_BYTE_RECEIVED ) )
{
if ( idc->elapsed++ > idc->timeout )
{
idc->status = I2C_ERROR_MBR;
I2C_GenerateSTOP( idc->i2c, ENABLE );
goto i2c_end;
}
crDELAY( xHandle, 1 );
idc = i2c( uxIndex );
}
// Read the data.
uint8_t data = I2C_ReceiveData( idc->i2c );
idc->receiveQueue[i] = data;
idc->bytesRead = i+1;
}
}
// Generating STOP.
I2C_GenerateSTOP( idc->i2c, ENABLE );
// Idle status when finished in regular way.
idc->status = I2C_IDLE;
}
}
else // master.
{
// slave mode IO.
//...... implementation.....
// Idle status when finished in regular way.
//idc->status = I2C_IDLE;
crDELAY( xHandle, 1 );
}
i2c_end:
// To prevent cyclic writes of zero data.
idc->sendCnt = 0;
idc->receiveCnt = 0;
// Give other coroutines time for running.
crDELAY( xHandle, 1 );
}
crEND();
}
void i2c_ev_handler(void)
{
static uint8_t subaddress_sent, final_stop; // flag to indicate if subaddess sent, flag to indicate final bus condition
static int8_t index; // index is signed -1 == send the subaddress
uint8_t SReg_1 = I2Cx->SR1; // read the status register here
if (SReg_1 & 0x0001) { // we just sent a start - EV5 in ref manual
I2Cx->CR1 &= ~0x0800; // reset the POS bit so ACK/NACK applied to the current byte
I2C_AcknowledgeConfig(I2Cx, ENABLE); // make sure ACK is on
index = 0; // reset the index
if (reading && (subaddress_sent || 0xFF == reg)) { // we have sent the subaddr
subaddress_sent = 1; // make sure this is set in case of no subaddress, so following code runs correctly
if (bytes == 2)
I2Cx->CR1 |= 0x0800; // set the POS bit so NACK applied to the final byte in the two byte read
I2C_Send7bitAddress(I2Cx, addr, I2C_Direction_Receiver); // send the address and set hardware mode
} else { // direction is Tx, or we havent sent the sub and rep start
I2C_Send7bitAddress(I2Cx, addr, I2C_Direction_Transmitter); // send the address and set hardware mode
if (reg != 0xFF) // 0xFF as subaddress means it will be ignored, in Tx or Rx mode
index = -1; // send a subaddress
}
} else if (SReg_1 & 0x0002) { // we just sent the address - EV6 in ref manual
// Read SR1,2 to clear ADDR
__DMB(); // memory fence to control hardware
if (bytes == 1 && reading && subaddress_sent) { // we are receiving 1 byte - EV6_3
I2C_AcknowledgeConfig(I2Cx, DISABLE); // turn off ACK
__DMB();
(void)I2Cx->SR2; // clear ADDR after ACK is turned off
I2C_GenerateSTOP(I2Cx, ENABLE); // program the stop
final_stop = 1;
I2C_ITConfig(I2Cx, I2C_IT_BUF, ENABLE); // allow us to have an EV7
} else { // EV6 and EV6_1
(void)I2Cx->SR2; // clear the ADDR here
__DMB();
if (bytes == 2 && reading && subaddress_sent) { // rx 2 bytes - EV6_1
I2C_AcknowledgeConfig(I2Cx, DISABLE); // turn off ACK
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable TXE to allow the buffer to fill
} else if (bytes == 3 && reading && subaddress_sent) // rx 3 bytes
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // make sure RXNE disabled so we get a BTF in two bytes time
else // receiving greater than three bytes, sending subaddress, or transmitting
I2C_ITConfig(I2Cx, I2C_IT_BUF, ENABLE);
}
} else if (SReg_1 & 0x004) { // Byte transfer finished - EV7_2, EV7_3 or EV8_2
final_stop = 1;
if (reading && subaddress_sent) { // EV7_2, EV7_3
if (bytes > 2) { // EV7_2
I2C_AcknowledgeConfig(I2Cx, DISABLE); // turn off ACK
read_p[index++] = (uint8_t)I2Cx->DR; // read data N-2
I2C_GenerateSTOP(I2Cx, ENABLE); // program the Stop
final_stop = 1; // required to fix hardware
read_p[index++] = (uint8_t)I2Cx->DR; // read data N - 1
I2C_ITConfig(I2Cx, I2C_IT_BUF, ENABLE); // enable TXE to allow the final EV7
} else { // EV7_3
if (final_stop)
I2C_GenerateSTOP(I2Cx, ENABLE); // program the Stop
else
I2C_GenerateSTART(I2Cx, ENABLE); // program a rep start
read_p[index++] = (uint8_t)I2Cx->DR; // read data N - 1
read_p[index++] = (uint8_t)I2Cx->DR; // read data N
index++; // to show job completed
}
} else { // EV8_2, which may be due to a subaddress sent or a write completion
if (subaddress_sent || (writing)) {
if (final_stop)
I2C_GenerateSTOP(I2Cx, ENABLE); // program the Stop
else
I2C_GenerateSTART(I2Cx, ENABLE); // program a rep start
index++; // to show that the job is complete
} else { // We need to send a subaddress
I2C_GenerateSTART(I2Cx, ENABLE); // program the repeated Start
subaddress_sent = 1; // this is set back to zero upon completion of the current task
}
}
// TODO - busy waiting in ISR
// we must wait for the start to clear, otherwise we get constant BTF
while (I2Cx->CR1 & 0x0100) { ; }
} else if (SReg_1 & 0x0040) { // Byte received - EV7
read_p[index++] = (uint8_t)I2Cx->DR;
if (bytes == (index + 3))
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable TXE to allow the buffer to flush so we can get an EV7_2
if (bytes == index) // We have completed a final EV7
index++; // to show job is complete
} else if (SReg_1 & 0x0080) { // Byte transmitted EV8 / EV8_1
if (index != -1) { // we dont have a subaddress to send
I2Cx->DR = write_p[index++];
if (bytes == index) // we have sent all the data
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable TXE to allow the buffer to flush
} else {
index++;
I2Cx->DR = reg; // send the subaddress
if (reading || !bytes) // if receiving or sending 0 bytes, flush now
I2C_ITConfig(I2Cx, I2C_IT_BUF, DISABLE); // disable TXE to allow the buffer to flush
}
}
if (index == bytes + 1) { // we have completed the current job
subaddress_sent = 0; // reset this here
if (final_stop) // If there is a final stop and no more jobs, bus is inactive, disable interrupts to prevent BTF
I2C_ITConfig(I2Cx, I2C_IT_EVT | I2C_IT_ERR, DISABLE); // Disable EVT and ERR interrupts while bus inactive
busy = 0;
}
}
void MACEEP_Read(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t NumByteToRead)
{
/* While the bus is busy */
while(I2C_GetFlagStatus(MACEPP_I2C, I2C_FLAG_BUSY));
/* Send START condition */
I2C_GenerateSTART(MACEPP_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(MACEPP_I2C, I2C_EVENT_MASTER_MODE_SELECT));
/* Send EEPROM address for write */
I2C_Send7bitAddress(MACEPP_I2C, MACEEP_Address, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(MACEPP_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Send the EEPROM's internal address to read from: LSB of the address */
I2C_SendData(MACEPP_I2C, (uint8_t)(ReadAddr & 0x00FF));
/* Test on EV8 and clear it */
while(!I2C_CheckEvent(MACEPP_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* Send STRAT condition a second time */
I2C_GenerateSTART(MACEPP_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(MACEPP_I2C, I2C_EVENT_MASTER_MODE_SELECT));
/* Send EEPROM address for read */
I2C_Send7bitAddress(MACEPP_I2C, MACEEP_Address, I2C_Direction_Receiver);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(MACEPP_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* While there is data to be read */
while(NumByteToRead)
{
if(NumByteToRead == 1)
{
/* Disable Acknowledgement */
I2C_AcknowledgeConfig(MACEPP_I2C, DISABLE);
/* Send STOP Condition */
I2C_GenerateSTOP(MACEPP_I2C, ENABLE);
}
/* Test on EV7 and clear it */
if(I2C_CheckEvent(MACEPP_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED))
{
/* Read a byte from the EEPROM */
*pBuffer = I2C_ReceiveData(MACEPP_I2C);
/* Point to the next location where the byte read will be saved */
pBuffer++;
/* Decrement the read bytes counter */
NumByteToRead--;
}
}
/* Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(MACEPP_I2C, ENABLE);
}
/**
* @brief Write to the configuration register of the LM75.
* @param RegValue: sepecifies the value to be written to LM75 configuration
* register.
* @retval None
*/
uint8_t LM75_WriteConfReg(uint8_t RegValue)
{
uint8_t LM75_BufferTX = 0;
LM75_BufferTX = (uint8_t)(RegValue);
/* 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;
}
/* This funtion issues a stop condition and therefore
* releases the bus
*/
void I2C_stop(I2C_TypeDef* I2Cx){
// Send I2C1 STOP Condition
I2C_GenerateSTOP(I2Cx, ENABLE);
//while(I2C_GetFlagStatus(I2Cx, I2C_FLAG_STOPF)); //spoko to ja dopisalem
}
/* This funtion issues a stop condition and therefore
* releases the bus
*/
void I2C_stop(I2C_TypeDef* I2Cx){
// Send I2C1 STOP Condition
I2C_GenerateSTOP(I2Cx, ENABLE);
return;
}
/**
* @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 Writes a Byte to a given register into the audio codec through the
control interface (I2C)
* @param RegisterAddr: The address (location) of the register to be written.
* @param RegisterValue: the Byte value to be written into destination register.
* @retval o if correct communication, else wrong communication
*/
static uint32_t Codec_WriteRegister(uint32_t RegisterAddr, uint32_t RegisterValue)
{
uint32_t result = 0;
/*!< While the bus is busy */
CODECTimeout = CODEC_LONG_TIMEOUT;
while(I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_BUSY))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Start the config sequence */
I2C_GenerateSTART(CODEC_I2C, ENABLE);
/* Test on EV5 and clear it */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while (!I2C_CheckEvent(CODEC_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Transmit the slave address and enable writing operation */
I2C_Send7bitAddress(CODEC_I2C, CODEC_ADDRESS, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while (!I2C_CheckEvent(CODEC_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Transmit the first address for write operation */
I2C_SendData(CODEC_I2C, RegisterAddr);
/* Test on EV8 and clear it */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while (!I2C_CheckEvent(CODEC_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Prepare the register value to be sent */
I2C_SendData(CODEC_I2C, RegisterValue);
/*!< Wait till all data have been physically transferred on the bus */
CODECTimeout = CODEC_LONG_TIMEOUT;
while(!I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_BTF))
{
if((CODECTimeout--) == 0) Codec_TIMEOUT_UserCallback();
}
/* End the configuration sequence */
I2C_GenerateSTOP(CODEC_I2C, ENABLE);
#ifdef VERIFY_WRITTENDATA
/* Verify that the data has been correctly written */
result = (Codec_ReadRegister(RegisterAddr) == RegisterValue)? 0:1;
#endif /* VERIFY_WRITTENDATA */
/* Return the verifying value: 0 (Passed) or 1 (Failed) */
return result;
}
/**
* @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 and returns te value of an audio codec register through the
* control interface (I2C).
* @param RegisterAddr: Address of the register to be read.
* @retval Value of the register to be read or dummy value if the communication
* fails.
*/
static uint32_t Codec_ReadRegister(uint32_t RegisterAddr)
{
uint32_t result = 0;
/*!< While the bus is busy */
CODECTimeout = CODEC_LONG_TIMEOUT;
while(I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_BUSY))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Start the config sequence */
I2C_GenerateSTART(CODEC_I2C, ENABLE);
/* Test on EV5 and clear it */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while (!I2C_CheckEvent(CODEC_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Transmit the slave address and enable writing operation */
I2C_Send7bitAddress(CODEC_I2C, CODEC_ADDRESS, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while (!I2C_CheckEvent(CODEC_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/* Transmit the register address to be read */
I2C_SendData(CODEC_I2C, RegisterAddr);
/* Test on EV8 and clear it */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while (I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_BTF) == RESET)
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/*!< Send STRAT condition a second time */
I2C_GenerateSTART(CODEC_I2C, ENABLE);
/*!< Test on EV5 and clear it (cleared by reading SR1 then writing to DR) */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while(!I2C_CheckEvent(CODEC_I2C, I2C_EVENT_MASTER_MODE_SELECT))
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/*!< Send Codec address for read */
I2C_Send7bitAddress(CODEC_I2C, CODEC_ADDRESS, I2C_Direction_Receiver);
/* Wait on ADDR flag to be set (ADDR is still not cleared at this level */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while(I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_ADDR) == RESET)
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/*!< Disable Acknowledgement */
I2C_AcknowledgeConfig(CODEC_I2C, DISABLE);
/* Clear ADDR register by reading SR1 then SR2 register (SR1 has already been read) */
(void)CODEC_I2C->SR2;
/*!< Send STOP Condition */
I2C_GenerateSTOP(CODEC_I2C, ENABLE);
/* Wait for the byte to be received */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while(I2C_GetFlagStatus(CODEC_I2C, I2C_FLAG_RXNE) == RESET)
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/*!< Read the byte received from the Codec */
result = I2C_ReceiveData(CODEC_I2C);
/* Wait to make sure that STOP flag has been cleared */
CODECTimeout = CODEC_FLAG_TIMEOUT;
while(CODEC_I2C->CR1 & I2C_CR1_STOP)
{
if((CODECTimeout--) == 0) return Codec_TIMEOUT_UserCallback();
}
/*!< Re-Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(CODEC_I2C, ENABLE);
/* Clear AF flag for next communication */
I2C_ClearFlag(CODEC_I2C, I2C_FLAG_AF);
/* Return the byte read from Codec */
return result;
}
void I2C_BufferRead(I2C_TypeDef* I2Cx,u8* pBuffer,u8 devAddr, u8 ReadAddr, u16 NumByteToRead)
{
#if 0
/* Send START condition */
I2C_GenerateSTART(I2Cx, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT));
/* Send EEPROM address for write */
I2C_Send7bitAddress(I2Cx, devAddr, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Clear EV6 by setting again the PE bit */
I2C_Cmd(I2Cx, ENABLE);
/* Send the EEPROM's internal address to write to */
I2C_SendData(I2Cx, ReadAddr);
/* Test on EV8 and clear it */
while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* Send STRAT condition a second time */
I2C_GenerateSTART(I2Cx, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT));
/* Send EEPROM address for read */
I2C_Send7bitAddress(I2Cx, devAddr, I2C_Direction_Receiver);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* While there is data to be read */
while(NumByteToRead)
{
if(NumByteToRead == 1)
{
/* Disable Acknowledgement */
I2C_AcknowledgeConfig(I2Cx, DISABLE);
/* Send STOP Condition */
I2C_GenerateSTOP(I2Cx, ENABLE);
}
/* Test on EV7 and clear it */
if(I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED))
{
/* Read a byte from the EEPROM */
*pBuffer = I2C_ReceiveData(I2Cx);
/* Point to the next location where the byte read will be saved */
pBuffer++;
/* Decrement the read bytes counter */
NumByteToRead--;
}
}
/* Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(I2Cx, ENABLE);
#endif
}
void AJS_TargetIO_I2cStop(void* ctx)
{
I2C_Pin* i2c = (I2C_Pin*)ctx;
I2C_GenerateSTOP(i2c->I2Cx, ENABLE);
while (!I2C_CheckEvent(i2c->I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
}
uint32_t BH1750_Read(void)
{
uint16_t BH_H;
uint16_t BH_L;
uint32_t value;
int iTimeout = DEF_TIMEOUT_I2C;
I2C_AcknowledgeConfig(BH1750_I2C,ENABLE); // Enable I2C acknowledge
I2C_GenerateSTART(BH1750_I2C,ENABLE); // Send START condition
iTimeout = DEF_TIMEOUT_I2C;
while (!I2C_CheckEvent(BH1750_I2C,I2C_EVENT_MASTER_MODE_SELECT)) { // Wait for EV5
iTimeout--;
if(!(iTimeout)) {
return 0;
}
}
iTimeout = DEF_TIMEOUT_I2C;
while (!I2C_CheckEvent(BH1750_I2C, I2C_EVENT_MASTER_MODE_SELECT)) { // Wait for EV5
iTimeout--;
if(!(iTimeout)) {
return 0;
}
}
I2C_Send7bitAddress(BH1750_I2C, BH1750_ADDRESS, I2C_Direction_Receiver); // Send slave address for READ
iTimeout = DEF_TIMEOUT_I2C;
while (!I2C_CheckEvent(BH1750_I2C,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) { // Wait for EV6
iTimeout--;
if(!(iTimeout)) {
return 0;
}
}
iTimeout = DEF_TIMEOUT_I2C;
while (!I2C_CheckEvent(BH1750_I2C,I2C_EVENT_MASTER_BYTE_RECEIVED)) { // Wait for EV7 (Byte received from slave)
iTimeout--;
if(!(iTimeout)) {
return 0;
}
}
BH_H = (uint16_t)I2C_ReceiveData(BH1750_I2C); // Receive MSB
iTimeout = DEF_TIMEOUT_I2C;
while (!I2C_CheckEvent(BH1750_I2C,I2C_EVENT_MASTER_BYTE_RECEIVED)) { // Wait for EV7 (Byte received from slave)
iTimeout--;
if(!(iTimeout)) {
return 0;
}
}
BH_L = (uint32_t)I2C_ReceiveData(BH1750_I2C); // Receive LSB
I2C_AcknowledgeConfig(BH1750_I2C,DISABLE); // Disable I2C acknowledgment
I2C_GenerateSTOP(BH1750_I2C,ENABLE); // Send STOP condition
value = BH_H*256 + BH_L;
value = value*10/12;
return value;
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void main()
{
#ifdef FAST_I2C_MODE
/* system_clock / 1 */
CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
#else
/* system_clock / 2 */
CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV2);
#endif
/* Initialize LEDs mounted on STM8/128-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
STM_EVAL_LEDOff(LED1);
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
/* I2C Initialize */
I2C_Init(I2C_SPEED, 0xA0, I2C_DUTYCYCLE_2, I2C_ACK_CURR, I2C_ADDMODE_7BIT, 16);
/* Enable Buffer and Event Interrupt*/
I2C_ITConfig((I2C_IT_TypeDef)(I2C_IT_EVT | I2C_IT_BUF) , ENABLE);
enableInterrupts();
/* TXBuffer initializtion */
for (i = 0; i < BUFFERSIZE; i++)
TxBuffer[i] = i;
/* Send START condition */
I2C_GenerateSTART(ENABLE);
while (NumOfBytes);
while (I2C_GetFlagStatus(I2C_FLAG_BUSBUSY));
/* Add a delay to be sure that communication is finished */
Delay(0xFFFF);
/***** reception phase ***/
/* Wait while the bus is busy */
while (I2C_GetFlagStatus(I2C_FLAG_BUSBUSY));
/* Send START condition */
I2C_GenerateSTART(ENABLE);
/* Test on EV5 and clear it */
while (!I2C_CheckEvent(I2C_EVENT_MASTER_MODE_SELECT));
#ifdef TEN_BITS_ADDRESS
/* Send Header to Slave for write */
I2C_SendData(HEADER_ADDRESS_Write);
/* Test on EV9 and clear it*/
while (!I2C_CheckEvent(I2C_EVENT_MASTER_MODE_ADDRESS10));
/* Send slave Address */
I2C_Send7bitAddress(SLAVE_ADDRESS, I2C_DIRECTION_TX);
/* Test on EV6 and clear it */
while (!I2C_CheckEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* Repeated Start */
I2C_GenerateSTART(ENABLE);
/* Test on EV5 and clear it */
while (!I2C_CheckEvent(I2C_EVENT_MASTER_MODE_SELECT));
/* Send Header to Slave for Read */
I2C_SendData(HEADER_ADDRESS_Read);
/* Test on EV6 and clear it */
while (!I2C_CheckEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
#else
/* Send slave Address for write */
I2C_Send7bitAddress(SLAVE_ADDRESS, I2C_DIRECTION_RX);
/* Test on EV6 and clear it */
while (!I2C_CheckEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
#endif /* TEN_BITS_ADDRESS */
/* While there is data to be read */
while (NumByteToRead)
{
#ifdef SAFE_PROCEDURE
if (NumByteToRead != 3) /* Receive bytes from first byte until byte N-3 */
{
while ((I2C_GetFlagStatus(I2C_FLAG_TRANSFERFINISHED) == RESET)); /* Poll on BTF */
/* Read a byte from the Slave */
RxBuffer[Rx_Idx] = I2C_ReceiveData();
/* Point to the next location where the byte read will be saved */
Rx_Idx++;
/* 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_GetFlagStatus(I2C_FLAG_TRANSFERFINISHED) == RESET)); /* Poll on BTF */
/* Clear ACK */
I2C_AcknowledgeConfig(I2C_ACK_NONE);
/* Disable general interrupts */
disableInterrupts();
/* Read Data N-2 */
RxBuffer[Rx_Idx] = I2C_ReceiveData();
/* Point to the next location where the byte read will be saved */
Rx_Idx++;
/* Program the STOP */
I2C_GenerateSTOP(ENABLE);
/* Read DataN-1 */
RxBuffer[Rx_Idx] = I2C_ReceiveData();
/* Enable General interrupts */
enableInterrupts();
/* Point to the next location where the byte read will be saved */
Rx_Idx++;
while ((I2C_GetFlagStatus(I2C_FLAG_RXNOTEMPTY) == RESET)); /* Poll on RxNE */
/* Read DataN */
RxBuffer[Rx_Idx] = I2C_ReceiveData();
/* Reset the number of bytes to be read by master */
NumByteToRead = 0;
}
#else
if (NumByteToRead == 1)
{
/* Disable Acknowledgement */
I2C_AcknowledgeConfig(I2C_ACK_NONE);
/* Send STOP Condition */
I2C_GenerateSTOP(ENABLE);
/* Poll on RxNE Flag */
while ((I2C_GetFlagStatus(I2C_FLAG_RXNOTEMPTY) == RESET));
/* Read a byte from the Slave */
RxBuffer[Rx_Idx] = I2C_ReceiveData();
/* Point to the next location where the byte read will be saved */
Rx_Idx++;
/* Decrement the read bytes counter */
NumByteToRead--;
}
/* Test on EV7 and clear it */
if (I2C_CheckEvent(I2C_EVENT_MASTER_BYTE_RECEIVED) )
{
/* Read a byte from the EEPROM */
RxBuffer[Rx_Idx] = I2C_ReceiveData();
/* Point to the next location where the byte read will be saved */
Rx_Idx++;
/* Decrement the read bytes counter */
NumByteToRead--;
}
#endif /* SAFE_PROCEDURE */
}
/* check if sent and received data are not corrupted */
TransferStatus1 = Buffercmp((uint8_t*)TxBuffer, (uint8_t*) RxBuffer, BUFFERSIZE);
if (TransferStatus1 != FAILED)
{
while (1)
{
/* Toggle LED1*/
STM_EVAL_LEDToggle(LED1);
/* Insert delay */
Delay(0x7FFF);
}
}
else
{
while (1)
{
/* Toggle LED4*/
STM_EVAL_LEDToggle(LED4);
/* Insert delay */
Delay(0x7FFF);
}
}
}
/**
* @brief Reads a byte from a specific Camera register
* @param Addr: OV9655 register address.
* @retval data read from the specific register or 0xFF if timeout condition
* occured.
*/
uint8_t OV9655_ReadReg(uint16_t Addr)
{
uint32_t timeout = DCMI_TIMEOUT_MAX;
uint8_t Data = 0;
/* Generate the Start Condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV5 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send DCMI selcted device slave Address for write */
I2C_Send7bitAddress(I2C1, OV9655_DEVICE_READ_ADDRESS, I2C_Direction_Transmitter);
/* Test on I2C1 EV6 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send I2C1 location address LSB */
I2C_SendData(I2C1, (uint8_t)(Addr));
/* Test on I2C1 EV8 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Clear AF flag if arised */
I2C1->SR1 |= (uint16_t)0x0400;
/* Generate the Start Condition */
I2C_GenerateSTART(I2C1, ENABLE);
/* Test on I2C1 EV6 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Send DCMI selcted device slave Address for write */
I2C_Send7bitAddress(I2C1, OV9655_DEVICE_READ_ADDRESS, I2C_Direction_Receiver);
/* Test on I2C1 EV6 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Prepare an NACK for the next data received */
I2C_AcknowledgeConfig(I2C1, DISABLE);
/* Test on I2C1 EV7 and clear it */
timeout = DCMI_TIMEOUT_MAX; /* Initialize timeout value */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED))
{
/* If the timeout delay is exeeded, exit with error code */
if ((timeout--) == 0) return 0xFF;
}
/* Prepare Stop after receiving data */
I2C_GenerateSTOP(I2C1, ENABLE);
/* Receive the Data */
Data = I2C_ReceiveData(I2C1);
/* return the read data */
return Data;
}
/**
* @brief Writes a value in a register of the device through I2C.
* @param DeviceAddr: The address of the IOExpander, could be : IOE_1_ADDR
* or IOE_2_ADDR.
* @param RegisterAddr: The target register adress
* @param RegisterValue: The target register value to be written
* @retval IOE_OK: if all operations are OK. Other value if error.
*/
uint8_t I2C_WriteDeviceRegister(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t RegisterValue)
{
uint32_t read_verif = 0;
uint8_t IOE_BufferTX = 0;
/* Get Value to be written */
IOE_BufferTX = RegisterValue;
/* Configure DMA Peripheral */
IOE_DMA_Config(IOE_DMA_TX, (uint8_t*)(&IOE_BufferTX));
/* 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) == RESET)
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Transmit the slave address and enable writing operation */
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());
}
/* Transmit the first address for r/w operations */
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());
}
/* Enable I2C DMA request */
I2C_DMACmd(IOE_I2C,ENABLE);
/* Enable DMA TX Channel */
DMA_Cmd(IOE_DMA_TX_CHANNEL, ENABLE);
/* Wait until DMA Transfer Complete */
IOE_TimeOut = TIMEOUT_MAX;
while (!DMA_GetFlagStatus(IOE_DMA_TX_TCFLAG))
{
if (IOE_TimeOut-- == 0) return(IOE_TimeoutUserCallback());
}
/* Wait until BTF Flag is set before generating STOP */
IOE_TimeOut = 2 * TIMEOUT_MAX;
while ((!I2C_GetFlagStatus(IOE_I2C,I2C_FLAG_BTF)))
{
}
/* Send STOP Condition */
I2C_GenerateSTOP(IOE_I2C, ENABLE);
/* Disable DMA TX Channel */
DMA_Cmd(IOE_DMA_TX_CHANNEL, DISABLE);
/* Disable I2C DMA request */
I2C_DMACmd(IOE_I2C,DISABLE);
/* Clear DMA TX Transfer Complete Flag */
DMA_ClearFlag(IOE_DMA_TX_TCFLAG);
#ifdef VERIFY_WRITTENDATA
/* Verify (if needed) that the loaded data is correct */
/* Read the just written register*/
read_verif = I2C_ReadDeviceRegister(DeviceAddr, RegisterAddr);
/* Load the register and verify its value */
if (read_verif != RegisterValue)
{
/* Control data wrongly tranfered */
read_verif = IOE_FAILURE;
}
else
{
/* Control data correctly transfered */
read_verif = 0;
}
#endif
/* Return the verifying value: 0 (Passed) or 1 (Failed) */
return read_verif;
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/* System Clocks Configuration */
RCC_Configuration();
/* Configure the GPIO ports */
GPIO_Configuration();
/* DMA1 channel5 configuration ----------------------------------------------*/
DMA_DeInit(DMA1_Channel5);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)I2C2_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)I2C2_Buffer_Rx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = BufferSize;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
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_VeryHigh;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel5, &DMA_InitStructure);
/* DMA1 channel6 configuration ----------------------------------------------*/
DMA_DeInit(DMA1_Channel6);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)I2C1_DR_Address;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)I2C1_Buffer_Tx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(DMA1_Channel6, &DMA_InitStructure);
/* Enable I2C1 and I2C2 ----------------------------------------------------*/
I2C_Cmd(I2C1, ENABLE);
I2C_Cmd(I2C2, ENABLE);
/* I2C1 configuration ------------------------------------------------------*/
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_OwnAddress1 = I2C1_SLAVE_ADDRESS7;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = ClockSpeed;
I2C_Init(I2C1, &I2C_InitStructure);
/* I2C2 configuration ------------------------------------------------------*/
I2C_InitStructure.I2C_OwnAddress1 = I2C2_SLAVE_ADDRESS7;
I2C_Init(I2C2, &I2C_InitStructure);
/*----- Transmission Phase -----*/
/* 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, I2C2_SLAVE_ADDRESS7, I2C_Direction_Transmitter);
/* Test on I2C2 EV1 and clear it */
while(!I2C_CheckEvent(I2C2, I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED));
/* Test on I2C1 EV6 and clear it */
while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Enable I2C2 DMA */
I2C_DMACmd(I2C2, ENABLE);
/* Enable I2C1 DMA */
I2C_DMACmd(I2C1, ENABLE);
/* Enable DMA1 Channel5 */
DMA_Cmd(DMA1_Channel5, ENABLE);
/* Enable DMA1 Channel6 */
DMA_Cmd(DMA1_Channel6, ENABLE);
/* DMA1 Channel5 transfer complete test */
while(!DMA_GetFlagStatus(DMA1_FLAG_TC5));
/* DMA1 Channel6 transfer complete test */
while(!DMA_GetFlagStatus(DMA1_FLAG_TC6));
/* Send I2C1 STOP Condition */
I2C_GenerateSTOP(I2C1, ENABLE);
/* Test on I2C2 EV4 */
while(!I2C_CheckEvent(I2C2, I2C_EVENT_SLAVE_STOP_DETECTED));
/* Clear I2C2 STOPF flag: read operation to I2C_SR1 followed by a
write operation to I2C_CR1 */
(void)(I2C_GetFlagStatus(I2C2, I2C_FLAG_STOPF));
I2C_Cmd(I2C2, ENABLE);
/* Check if the transmitted and received data are equal */
TransferStatus = Buffercmp(I2C1_Buffer_Tx, I2C2_Buffer_Rx, BufferSize);
/* TransferStatus = PASSED, if the transmitted and received data
are the same */
/* TransferStatus = FAILED, if the transmitted and received data
are different */
while (1)
{
}
}
/**
* @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 Wait for EEPROM Standby state.
*
* @note This function allows to wait and check that EEPROM has finished the
* last operation. It is mostly used after Write operation: after receiving
* the buffer to be written, the EEPROM may need additional time to actually
* perform the write operation. During this time, it doesn't answer to
* I2C packets addressed to it. Once the write operation is complete
* the EEPROM responds to its address.
*
* @param None
* @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_WaitEepromStandbyState(void)
{
__IO uint16_t tmpSR1 = 0;
__IO uint32_t sEETrials = 0;
/*!< While the bus is busy */
sEETimeout = sEE_LONG_TIMEOUT;
while(I2C_GetFlagStatus(sEE_I2C, I2C_FLAG_BUSY))
{
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/* Keep looping till the slave acknowledge his address or maximum number
of trials is reached (this number is defined by sEE_MAX_TRIALS_NUMBER define
in stm32f429i_discovery_i2c_ee.h file) */
while (1)
{
/*!< Send START condition */
I2C_GenerateSTART(sEE_I2C, ENABLE);
/*!< Test on EV5 and clear it */
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);
/* Wait for ADDR flag to be set (Slave acknowledged his address) */
sEETimeout = sEE_LONG_TIMEOUT;
do
{
/* Get the current value of the SR1 register */
tmpSR1 = sEE_I2C->SR1;
/* Update the timeout value and exit if it reach 0 */
if((sEETimeout--) == 0) return sEE_TIMEOUT_UserCallback();
}
/* Keep looping till the Address is acknowledged or the AF flag is
set (address not acknowledged at time) */
while((tmpSR1 & (I2C_SR1_ADDR | I2C_SR1_AF)) == 0);
/* Check if the ADDR flag has been set */
if (tmpSR1 & I2C_SR1_ADDR)
{
/* Clear ADDR Flag by reading SR1 then SR2 registers (SR1 have already
been read) */
(void)sEE_I2C->SR2;
/*!< STOP condition */
I2C_GenerateSTOP(sEE_I2C, ENABLE);
/* Exit the function */
return sEE_OK;
}
else
{
/*!< Clear AF flag */
I2C_ClearFlag(sEE_I2C, I2C_FLAG_AF);
}
/* Check if the maximum allowed number of trials has bee reached */
if (sEETrials++ == sEE_MAX_TRIALS_NUMBER)
{
/* If the maximum number of trials has been reached, exit the function */
return sEE_TIMEOUT_UserCallback();
}
}
}
void LSM303DLH_I2C_BufferRead(u8 slAddr, u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
{
iNEMO_ENTER_CRITICAL();
/* While the bus is busy */
while(I2C_GetFlagStatus(LSM_I2C, I2C_FLAG_BUSY));
/* Send START condition */
I2C_GenerateSTART(LSM_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(LSM_I2C, I2C_EVENT_MASTER_MODE_SELECT));
/* Send LSM303DLH_Magn address for write */
I2C_Send7bitAddress(LSM_I2C, slAddr, I2C_Direction_Transmitter);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(LSM_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));
/* Clear EV6 by setting again the PE bit */
I2C_Cmd(LSM_I2C, ENABLE);
/* Send the LSM303DLH_Magn's internal address to write to */
I2C_SendData(LSM_I2C, ReadAddr);
/* Test on EV8 and clear it */
while(!I2C_CheckEvent(LSM_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
/* Send STRAT condition a second time */
I2C_GenerateSTART(LSM_I2C, ENABLE);
/* Test on EV5 and clear it */
while(!I2C_CheckEvent(LSM_I2C, I2C_EVENT_MASTER_MODE_SELECT));
/* Send LSM303DLH address for read */
I2C_Send7bitAddress(LSM_I2C, slAddr, I2C_Direction_Receiver);
/* Test on EV6 and clear it */
while(!I2C_CheckEvent(LSM_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));
/* While there is data to be read */
while(NumByteToRead)
{
if(NumByteToRead == 1)
{
/* Disable Acknowledgement */
I2C_AcknowledgeConfig(LSM_I2C, DISABLE);
/* Send STOP Condition */
I2C_GenerateSTOP(LSM_I2C, ENABLE);
}
/* Test on EV7 and clear it */
if(I2C_CheckEvent(LSM_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED))
{
/* Read a byte from the LSM303DLH */
*pBuffer = I2C_ReceiveData(LSM_I2C);
/* Point to the next location where the byte read will be saved */
pBuffer++;
/* Decrement the read bytes counter */
NumByteToRead--;
}
}
/* Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig(LSM_I2C, ENABLE);
iNEMO_EXIT_CRITICAL();
}