自学教程：C++ I2C_TransferHandling函数代码示例

uint8_t TW88Write(uint8_t regAddr, uint8_t data){		int8_t retries;		retries=3;			while(I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET) { if ((retries--)>0) Delay(1); else return 0;}			//I2C_TransferHandling(I2C1, TW88_I2C_ADDR, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);		/* Configure slave address, nbytes, reload, end mode and start or stop generation */		I2C_TransferHandling(I2C1, TW88_I2C_ADDR, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);		retries=3;		while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET) {if ((retries--)>0) Delay(1); else return 0; }		//send the register address			I2C_SendData(I2C1, (uint8_t) regAddr);				retries=3;		while(I2C_GetFlagStatus(I2C1, I2C_ISR_TCR) == RESET){if ((retries--)>0) Delay(1); else return 0;}				/* Configure slave address, nbytes, reload, end mode and start or stop generation */		I2C_TransferHandling(I2C1, TW88_I2C_ADDR, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);				retries=3;		while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET) {if ((retries--)>0) Delay(1); else return 0;}				I2C_SendData(I2C1, data);				retries=3;		while(I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET) {if ((retries--)>0) Delay(1); else return 0;}				I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);								return 1;}

// Make this so we can handle if the nunchuk is disconnectedvoid f3d_i2c1_read_nunchuk (uint8_t device, uint8_t* buffer, uint16_t numbytes) {tryagain: ;  int count = 100;  while (I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET){  }  I2C_TransferHandling(I2C1, 0xA4, 1, I2C_AutoEnd_Mode, I2C_Generate_Start_Write);            // This is where were screwing up  while ((I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET) && count){    asm("nop");    count--;  }    if (count <= 0) {    goto tryagain;  }  I2C_SendData(I2C1,0x00);                                                                    while(I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET){  }  I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);  delay(1);  while (I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET) {  }  I2C_TransferHandling(I2C1, 0xA4, 6, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);  while (numbytes--) {    while(I2C_GetFlagStatus(I2C1, I2C_ISR_RXNE) == RESET);    *buffer++ = I2C_ReceiveData(I2C1);  }  while (I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET);                                    I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);}

/**  * @brief  Write to the configuration register of the LM75.  * @param  RegValue: specifies 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 */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_BUSY) != RESET)   {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(LM75_I2C, LM75_ADDR, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);    /* Wait until TXIS flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;    while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_TXIS) == RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Send Register address */  I2C_SendData(LM75_I2C, (uint8_t)LM75_REG_CONF);    /* Wait until TCR flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_TCR) == RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(LM75_I2C, LM75_ADDR, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);    /* Wait until TXIS flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_TXIS) == RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }      /* Write data to TXDR */  I2C_SendData(LM75_I2C, (uint8_t)LM75_BufferTX);    /* Wait until STOPF flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_STOPF) == RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }       /* Clear STOPF flag */  I2C_ClearFlag(LM75_I2C, I2C_ICR_STOPCF);      return LM75_OK;  }

/**  * @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 */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_BUSY) != RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(LM75_I2C, LM75_ADDR, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);    /* Wait until TXIS flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_TXIS) == RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Send Register address */  I2C_SendData(LM75_I2C, (uint8_t)LM75_REG_CONF);    /* Wait until TC flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_TC) == RESET)  {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }      /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(LM75_I2C, LM75_ADDR, 1, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);    /* Wait until RXNE flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;    while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_RXNE) == RESET)    {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Read data from RXDR */  LM75_BufferRX[0]= I2C_ReceiveData(LM75_I2C);      /* Wait until STOPF flag is set */  LM75Timeout = LM75_LONG_TIMEOUT;  while(I2C_GetFlagStatus(LM75_I2C, I2C_ISR_STOPF) == RESET)   {    if((LM75Timeout--) == 0) return LM75_TIMEOUT_UserCallback();  }    /* Clear STOPF flag */  I2C_ClearFlag(LM75_I2C, I2C_ICR_STOPCF);    /* Return Register value */  return (uint8_t)LM75_BufferRX[0];}

void ADXL345_Read(uint8_t DeviceAddr, uint8_t RegAddr, uint8_t* pBuffer, uint16_t NumByteToRead){  /* Test on BUSY Flag */  while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_BUSY) != RESET)  {  }  /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(ADXL345_I2C, DeviceAddr, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);  /* Wait until TXIS flag is set */  while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_TXIS) == RESET)  {  }  if(NumByteToRead>1)      RegAddr |= 0x80;  /* Send Register address */  I2C_SendData(ADXL345_I2C, (uint8_t)RegAddr);  /* Wait until TC flag is set */  while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_TC) == RESET)  {  }  /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(ADXL345_I2C, DeviceAddr, NumByteToRead, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);  /* Wait until all data are received */  while (NumByteToRead)  {    /* Wait until RXNE flag is set */    while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_RXNE) == RESET)    {    }    /* Read data from RXDR */    *pBuffer = I2C_ReceiveData(ADXL345_I2C);    /* Point to the next location where the byte read will be saved */    pBuffer++;    /* Decrement the read bytes counter */    NumByteToRead--;  }  /* Wait until STOPF flag is set */  while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_STOPF) == RESET)  {  }  /* Clear STOPF flag */  I2C_ClearFlag(ADXL345_I2C, I2C_ICR_STOPCF);}

/** * @brief  Writes one byte to the LSM303DLHC. * @param  DeviceAddr : specifies the slave address to be programmed. * @param  RegAddr : specifies the LSM303DLHC register to be written. * @param  pBuffer : pointer to the buffer  containing the data to be written to the LSM303DLH. * @retval LSM303DLHC Status */uint16_t LSM303DLHC_Write(uint8_t DeviceAddr, uint8_t RegAddr, uint8_t* pBuffer) {	/* Test on BUSY Flag */	LSM303DLHC_Timeout = LSM303DLHC_LONG_TIMEOUT;	while (I2C_GetFlagStatus(LSM303DLHC_I2C, I2C_ISR_BUSY ) != RESET) {		if ((LSM303DLHC_Timeout--) == 0)			return LSM303DLHC_TIMEOUT_UserCallback();	}	/* Configure slave address, nbytes, reload, end mode and start or stop generation */	I2C_TransferHandling(LSM303DLHC_I2C, DeviceAddr, 1, I2C_Reload_Mode,			I2C_Generate_Start_Write);	/* Wait until TXIS flag is set */	LSM303DLHC_Timeout = LSM303DLHC_LONG_TIMEOUT;	while (I2C_GetFlagStatus(LSM303DLHC_I2C, I2C_ISR_TXIS ) == RESET) {		if ((LSM303DLHC_Timeout--) == 0)			return LSM303DLHC_TIMEOUT_UserCallback();	}	/* Send Register address */	I2C_SendData(LSM303DLHC_I2C, (uint8_t) RegAddr);	/* Wait until TCR flag is set */	LSM303DLHC_Timeout = LSM303DLHC_LONG_TIMEOUT;	while (I2C_GetFlagStatus(LSM303DLHC_I2C, I2C_ISR_TCR ) == RESET) {		if ((LSM303DLHC_Timeout--) == 0)			return LSM303DLHC_TIMEOUT_UserCallback();	}	/* Configure slave address, nbytes, reload, end mode and start or stop generation */	I2C_TransferHandling(LSM303DLHC_I2C, DeviceAddr, 1, I2C_AutoEnd_Mode,			I2C_No_StartStop);	/* Wait until TXIS flag is set */	LSM303DLHC_Timeout = LSM303DLHC_LONG_TIMEOUT;	while (I2C_GetFlagStatus(LSM303DLHC_I2C, I2C_ISR_TXIS ) == RESET) {		if ((LSM303DLHC_Timeout--) == 0)			return LSM303DLHC_TIMEOUT_UserCallback();	}	/* Write data to TXDR */	I2C_SendData(LSM303DLHC_I2C, *pBuffer);	/* Wait until STOPF flag is set */	LSM303DLHC_Timeout = LSM303DLHC_LONG_TIMEOUT;	while (I2C_GetFlagStatus(LSM303DLHC_I2C, I2C_ISR_STOPF ) == RESET) {		if ((LSM303DLHC_Timeout--) == 0)			return LSM303DLHC_TIMEOUT_UserCallback();	}	/* Clear STOPF flag */	I2C_ClearFlag(LSM303DLHC_I2C, I2C_ICR_STOPCF );	return LSM303DLHC_OK ;}

/* @brief Reads bytes from MPU6050 * * @param SlaveAddr - Slave I2C address * @param RegAddr - register address * @param pBuffer - buffer to write to * @ param NumByteToRead - number of bytes to read * * @retval @MPU6050_errorstatus */MPU6050_errorstatus MPU6050_Read(uint8_t SlaveAddr, uint8_t RegAddr, uint8_t* pBuffer, uint16_t NumByteToRead){   /* Test if SDA line busy */   MPU6050_Timeout = MPU6050_LONG_TIMEOUT;   while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_BUSY) != RESET)   {      if((MPU6050_Timeout--) == 0) return MPU6050_I2C_ERROR;   }   I2C_TransferHandling(MPU6050_I2C, SlaveAddr, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);   MPU6050_Timeout = MPU6050_LONG_TIMEOUT;   while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_TXIS) == RESET)   {      if((MPU6050_Timeout--) == 0) return MPU6050_I2C_ERROR;   }   if(NumByteToRead>1)   RegAddr |= 0x80;   I2C_SendData(MPU6050_I2C, (uint8_t)RegAddr);   MPU6050_Timeout = MPU6050_LONG_TIMEOUT;   while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_TC) == RESET)   {      if((MPU6050_Timeout--) == 0) return MPU6050_I2C_TX_ERROR;   }    I2C_TransferHandling(MPU6050_I2C, SlaveAddr, NumByteToRead, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);    while (NumByteToRead)    {      MPU6050_Timeout = MPU6050_LONG_TIMEOUT;      while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_RXNE) == RESET)      {         if((MPU6050_Timeout--) == 0) return MPU6050_I2C_RX_ERROR;      }      *pBuffer = I2C_ReceiveData(MPU6050_I2C);      pBuffer++;      NumByteToRead--;    }    MPU6050_Timeout = MPU6050_LONG_TIMEOUT;    while(I2C_GetFlagStatus(MPU6050_I2C, I2C_FLAG_STOPF) == RESET)    {      if((MPU6050_Timeout--) == 0) return MPU6050_I2C_ERROR;    }    I2C_ClearFlag(MPU6050_I2C, I2C_FLAG_STOPF);    return MPU6050_NO_ERROR;}

uint16_t I2C_Write(uint8_t deviceAddressess, uint8_t registerAddress, uint8_t* dataPointer){	I2C_Timeout = I2C_LONG_TIMEOUT;	while(I2C_GetFlagStatus(I2C, I2C_ISR_BUSY) != RESET)	{		if((I2C_Timeout--) == 0) return I2C_TIMEOUT_UserCallback();	}	/* Configure slave address, nbytes, reload, end mode and start or stop generation */	I2C_TransferHandling(I2C, deviceAddressess, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);	/* Wait until TXIS flag is set */	I2C_Timeout = I2C_LONG_TIMEOUT;  	while(I2C_GetFlagStatus(I2C, I2C_ISR_TXIS) == RESET)   	{		if((I2C_Timeout--) == 0) return I2C_TIMEOUT_UserCallback();	}	/* Send Register address */	I2C_SendData(I2C, (uint8_t) registerAddress);	/* Wait until TCR flag is set */	I2C_Timeout = I2C_LONG_TIMEOUT;	while(I2C_GetFlagStatus(I2C, I2C_ISR_TCR) == RESET)	{		if((I2C_Timeout--) == 0) return I2C_TIMEOUT_UserCallback();	}	/* Configure slave address, nbytes, reload, end mode and start or stop generation */	I2C_TransferHandling(I2C, deviceAddressess, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);	/* Wait until TXIS flag is set */	I2C_Timeout = I2C_LONG_TIMEOUT;	while(I2C_GetFlagStatus(I2C, I2C_ISR_TXIS) == RESET)	{		if((I2C_Timeout--) == 0) return I2C_TIMEOUT_UserCallback();	}  	/* Write data to TXDR */	I2C_SendData(I2C, *dataPointer);	/* Wait until STOPF flag is set */	I2C_Timeout = I2C_LONG_TIMEOUT;	while(I2C_GetFlagStatus(I2C, I2C_ISR_STOPF) == RESET)	{		if((I2C_Timeout--) == 0) return I2C_TIMEOUT_UserCallback();	}   	/* Clear STOPF flag */	I2C_ClearFlag(I2C, I2C_ICR_STOPCF);	return I2C_OK;}

void I2C_WriteRegister(uint8_t addr, uint8_t reg, uint8_t val){    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_BUSY) == SET);    I2C_TransferHandling(I2C2, addr, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXIS) == RESET);    I2C_SendData(I2C2, reg);    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TCR) == RESET);    I2C_TransferHandling(I2C2, addr, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXIS) == RESET);    I2C_SendData(I2C2, val);    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_STOPF) == RESET);    I2C_ClearFlag(I2C2, I2C_FLAG_STOPF);}

/* Private functions ---------------------------------------------------------*/int EEP_WriteData(uint8_t DevAddr, uint16_t RegAddr, uint8_t* DataBuf, uint16_t DataLen){	EEP_Timeout = EEP_LONG_TIMEOUT;	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_BUSY))	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_TransferHandling(I2C2,DevAddr,2,I2C_Reload_Mode,I2C_Generate_Start_Write);	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_TXIS) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_SendData(I2C2,RegAddr>>8);	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_TXIS) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}				I2C_SendData(I2C2,RegAddr&0xFF);	while(I2C_GetFlagStatus(I2C2,I2C_ISR_TCR) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_TransferHandling(I2C2,DevAddr,DataLen,I2C_AutoEnd_Mode,I2C_No_StartStop);	while(DataLen--)	{		while(I2C_GetFlagStatus(I2C2,I2C_FLAG_TXIS) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_SendData(I2C2, *DataBuf);		DataBuf++;	}		while(I2C_GetFlagStatus(I2C2,I2C_FLAG_STOPF) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}		I2C_ClearFlag(I2C2, I2C_ICR_STOPCF);	return SUCCESS;}

////	Originally, 'endTransmission' was an f(void) function.//	It has been modified to take one parameter indicating//	whether or not a STOP should be performed on the bus.//	Calling endTransmission(false) allows a sketch to//	perform a repeated start.////	WARNING: Nothing in the library keeps track of whether//	the bus tenure has been properly ended with a STOP. It//	is very possible to leave the bus in a hung state if//	no call to endTransmission(true) is made. Some I2C//	devices will behave oddly if they do not see a STOP.//uint8_t TwoWire::endTransmission(uint8_t sendStop) {	uint32_t _millis;		_millis = millis();	while(I2C_GetFlagStatus(twi, I2C_FLAG_BUSY) != RESET)	{		if(EVENT_TIMEOUT < (millis() - _millis)) return 0;	}	if (sendStop == true)	{		I2C_TransferHandling(twi, txAddress, txBufferLength, I2C_AutoEnd_Mode, I2C_Generate_Start_Write);	} 	else 	{		I2C_TransferHandling(twi, txAddress, txBufferLength, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);	}		uint8_t *pBuffer = txBuffer;	uint8_t NumByteToWrite = txBufferLength;	/* While there is data to be read */	while(NumByteToWrite--)	{		_millis = millis();		while(I2C_GetFlagStatus(twi, I2C_FLAG_TXIS) == RESET)		{			if(EVENT_TIMEOUT < (millis() - _millis)) return 0;		}		/* Send the current byte to slave */		I2C_SendData(twi, *pBuffer++);		}	_millis = millis();	if (sendStop == true)	{		while(I2C_GetFlagStatus(twi, I2C_FLAG_STOPF) == RESET)		{			if(EVENT_TIMEOUT < (millis() - _millis)) return 0;		}	}	else	{		while(I2C_GetFlagStatus(twi, I2C_FLAG_STOPF) == RESET)		{			if(EVENT_TIMEOUT < (millis() - _millis)) return 0;		}		}	// reset tx buffer iterator vars	txBufferLength = 0;	status = MASTER_IDLE;	return 0;}

int EEP_ReadData(uint8_t DevAddr, uint16_t RegAddr, uint8_t* DataBuf, uint16_t DataLen){ 	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_BUSY))	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_TransferHandling(I2C2,DevAddr,2,I2C_SoftEnd_Mode,I2C_Generate_Start_Write);	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_TXIS) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_SendData(I2C2,RegAddr>>8);	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_TXIS) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_SendData(I2C2,RegAddr&0xFF);	while(I2C_GetFlagStatus(I2C2,I2C_ISR_TC) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}			I2C_TransferHandling(I2C2,DevAddr,DataLen,I2C_AutoEnd_Mode,I2C_Generate_Start_Read);	while(DataLen)	{		while(I2C_GetFlagStatus(I2C2,I2C_FLAG_RXNE) == RESET)		{			if(EEP_Timeout-- == 0)				return ERROR;		}			*DataBuf = I2C_ReceiveData(I2C2);		DataBuf++;		DataLen--;	}	while(I2C_GetFlagStatus(I2C2,I2C_FLAG_STOPF) == RESET)	{		if(EEP_Timeout-- == 0)			return ERROR;	}	return SUCCESS;}

//We're really fortunate with the HMC5883L as it automatically//increments the internal register counter with every read//so we need to set the internal register pointer to the first data//register (the X value register) and just read the next 6 pieces//of data, X1, X2, Z1, Z2 Y1, Y2 and//voila! We have the compass values!uint8_t I2C_RdReg(int8_t Reg, int8_t *Data, uint8_t DCnt){	int8_t Cnt, SingleData = 0;	//As per, ensure the I2C peripheral isn't busy!	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_BUSY) == SET);	//Again, start another tranfer using the "transfer handling"	//function, the end bit being set in software this time	//round, generate a start condition and indicate you will	//be writing data to the HMC device.	I2C_TransferHandling(HMC_I2C, HMCAddr, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);	//Wait until the transmit interrupt status is set	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_TXIS) == RESET);	//Send the address of the register you wish to read	I2C_SendData(HMC_I2C, (uint8_t)Reg);	//Wait until transfer is complete!	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_TC) == RESET);	//As per, start another transfer, we want to read DCnt	//amount of bytes. Generate a start condition and	//indicate that we want to read.	I2C_TransferHandling(HMC_I2C, HMCAddr, DCnt, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);	//Read in DCnt pieces of data	for(Cnt = 0; Cnt<DCnt; Cnt++){		//Wait until the RX register is full of luscious data!		while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_RXNE) == RESET);		//If we're only reading one byte, place that data direct into the		//SingleData variable. If we're reading more than 1 piece of data		//store in the array "Data" (a pointer from main)		if(DCnt > 1) Data[Cnt] = I2C_ReceiveData(HMC_I2C);		else SingleData = I2C_ReceiveData(HMC_I2C);	}	//Wait for the stop condition to be sent	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_STOPF) == RESET);	//Clear the stop flag for next transfers	I2C_ClearFlag(HMC_I2C, I2C_FLAG_STOPF);	//Return a single piece of data if DCnt was	//less than 1, otherwise 0 will be returned.	return SingleData;}

/**  * @brief  Checks the LM75 status.  * @param  None  * @retval ErrorStatus: LM75 Status (ERROR or SUCCESS).  */ErrorStatus LM75_GetStatus(void){  uint32_t I2C_TimeOut = I2C_TIMEOUT;    /* Configure slave address, nbytes, reload, end mode and start or stop generation */  I2C_TransferHandling(LM75_I2C, LM75_ADDR, 0, I2C_AutoEnd_Mode, I2C_No_StartStop);    /* Clear NACKF and STOPF */  I2C_ClearFlag(LM75_I2C, I2C_ICR_NACKCF | I2C_ICR_STOPCF);    /* Generate start */  I2C_GenerateSTART(LM75_I2C, ENABLE);      /* Wait until timeout elapsed */  while ((I2C_GetFlagStatus(LM75_I2C, I2C_ISR_STOPF) == RESET) && (I2C_TimeOut-- != 0));     /* Check if Temp sensor is ready for use */  if ((I2C_GetFlagStatus(LM75_I2C, I2C_ISR_NACKF) != RESET) || (I2C_TimeOut == 0))  {          /* Clear NACKF and STOPF */    I2C_ClearFlag(LM75_I2C, I2C_ICR_NACKCF | I2C_ICR_STOPCF);        return ERROR;  }  else  {    /* Clear STOPF */    I2C_ClearFlag(LM75_I2C, I2C_ICR_STOPCF);        return SUCCESS;  }    }

int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {    I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);    int timeout;    int count;    if (length == 0) return 0;    // Configure slave address, nbytes, reload, end mode and start generation    I2C_TransferHandling(i2c, address, length, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);    // Write all bytes    for (count = 0; count < length; count++) {        i2c_byte_write(obj, data[count]);    }    timeout = FLAG_TIMEOUT;    while(!I2C_GetFlagStatus(i2c, I2C_FLAG_TC)) {        timeout--;        if (timeout == 0) return 0;    }            if(stop) i2c_stop(obj);    return count;}

uint8_t i2cReceiveS(I2C_TypeDef* I2Cx, const uint8_t addr, uint8_t *buffer, uint8_t len){    uint8_t timeout;    if (chSemWaitTimeout(&i2c1_semS, MS2ST(I2C_TIMEOUT)) != MSG_OK)    {        return 1;    }    I2C_TransferHandling(I2Cx, addr, len, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);    while (len--)    {        timeout = 100;        while(I2C_GetFlagStatus(I2Cx, I2C_ISR_RXNE) == RESET)        {            chThdSleepMicroseconds(50);            if (!timeout--)            {                chSemSignal(&i2c1_semS);                return 1;            }        };        *buffer++ = I2Cx->RXDR;    }    chSemSignal(&i2c1_semS);    return 0;}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {    I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);    int count;    int timeout;    int value;    // Configure slave address, nbytes, reload, end mode and start or stop generation    I2C_TransferHandling(i2c, address, length, I2C_SoftEnd_Mode, I2C_Generate_Start_Read);    // Read all bytes    for (count = 0; count < length; count++) {        value = i2c_byte_read(obj, 0);        data[count] = (char)value;    }    timeout = FLAG_TIMEOUT;    while (!I2C_GetFlagStatus(i2c, I2C_FLAG_TC)) {        timeout--;        if (timeout == 0) return -1;    }    if (stop) i2c_stop(obj);    return length;}

/* sla includes also the r/w bit */uint8_t u8g_i2c_start(uint8_t sla){      while(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY) == SET);    I2C_TransferHandling(I2C1, sla, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);    while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TXIS) == RESET);    return 1;}

void f3d_i2c1_read_nunchuk (uint8_t device, uint8_t* buffer, uint16_t numbytes) {  while (I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET);  I2C_TransferHandling(I2C1, 0xA4, 1, I2C_AutoEnd_Mode, I2C_Generate_Start_Write);  while (I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET);  I2C_SendData(I2C1,0x00);  while(I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET);  I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);  delay(1);  while (I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET);  I2C_TransferHandling(I2C1, 0xA4, 6, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);  while (numbytes--) {    while(I2C_GetFlagStatus(I2C1, I2C_ISR_RXNE) == RESET);    *buffer++ = I2C_ReceiveData(I2C1);  }  while (I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET);  I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);}

void f3d_i2c1_write(uint8_t device, uint8_t reg, uint8_t* value) {     while (I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET);   I2C_TransferHandling(I2C1, device, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);   while (I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET);   I2C_SendData(I2C1,reg);   while(I2C_GetFlagStatus(I2C1, I2C_ISR_TCR) == RESET);   I2C_TransferHandling(I2C1, device, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);   while(I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET);   I2C_SendData(I2C1, *value);   while(I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET);   I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);}

void ADXL345_Write(uint8_t DeviceAddr, uint8_t RegAddr, uint8_t* pBuffer){	/* Test on BUSY Flag */	while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_BUSY) != RESET)	{	}	/* Configure slave address, nbytes, reload, end mode and start or stop generation */	I2C_TransferHandling(ADXL345_I2C, DeviceAddr, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);	/* Wait until TXIS flag is set */	while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_TXIS) == RESET)	{	}	/* Send Register address */	I2C_SendData(ADXL345_I2C, (uint8_t) RegAddr);	/* Wait until TCR flag is set */	while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_TCR) == RESET)	{	}	/* Configure slave address, nbytes, reload, end mode and start or stop generation */	I2C_TransferHandling(ADXL345_I2C, DeviceAddr, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);	/* Wait until TXIS flag is set */	while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_TXIS) == RESET)	{	}	/* Write data to TXDR */	I2C_SendData(ADXL345_I2C, *pBuffer);	/* Wait until STOPF flag is set */	while(I2C_GetFlagStatus(ADXL345_I2C, I2C_ISR_STOPF) == RESET)	{	}	/* Clear STOPF flag */	I2C_ClearFlag(ADXL345_I2C, I2C_ICR_STOPCF);}

void I2C_WrReg(uint8_t Reg, uint8_t Val){	//Wait until I2C isn't busy	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_BUSY) == SET);	//"Handle" a transfer - The STM32F0 series has a shocking	//I2C interface... Regardless! Send the address of the HMC	//sensor down the I2C Bus and generate a start saying we're	//going to write one byte. I'll be completely honest,	//the I2C peripheral doesn't make too much sense to me	//and a lot of the code is from the Std peripheral library	I2C_TransferHandling(HMC_I2C, HMCAddr, 1, I2C_Reload_Mode, I2C_Generate_Start_Write);	//Ensure the transmit interrupted flag is set	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_TXIS) == RESET);	//Send the address of the register we wish to write to	I2C_SendData(HMC_I2C, Reg);	//Ensure that the transfer complete reload flag is	//set, essentially a standard TC flag	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_TCR) == RESET);	//Now that the HMC5883L knows which register	//we want to write to, send the address again	//and ensure the I2C peripheral doesn't add	//any start or stop conditions	I2C_TransferHandling(HMC_I2C, HMCAddr, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);	//Again, wait until the transmit interrupted flag is set	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_TXIS) == RESET);	//Send the value you wish you write to the register	I2C_SendData(HMC_I2C, Val);	//Wait for the stop flag to be set indicating	//a stop condition has been sent	while(I2C_GetFlagStatus(HMC_I2C, I2C_FLAG_STOPF) == RESET);	//Clear the stop flag for the next potential transfer	I2C_ClearFlag(HMC_I2C, I2C_FLAG_STOPF);}

void i2c_write(uint8_t* pBuffer, uint8_t num) {	uint8_t i = 0;	I2C_ITConfig(I2C2, I2C_IT_RXI | I2C_IT_TXI | I2C_IT_ADDRI | I2C_IT_STOPI, DISABLE);	while(I2C_GetFlagStatus(I2C2, I2C_ISR_BUSY) != RESET);	I2C_TransferHandling(I2C2, I2C_SLAVE, num, I2C_AutoEnd_Mode, I2C_Generate_Start_Write);	for(; i < num; i++) {		while(I2C_GetFlagStatus(I2C2, I2C_ISR_TXIS) == RESET);		I2C_SendData(I2C2, (uint8_t) I2C_SLAVE);	}	while(I2C_GetFlagStatus(I2C2, I2C_ISR_STOPF) == RESET); 	I2C_ClearFlag(I2C2, I2C_ICR_STOPCF);}

void i2c_start_transfer(mal_i2c_s *handle) {	handle->cmd = (volatile mal_i2c_cmd_e)handle->msg->packet.cmd;	// Reset variables	handle->state = (volatile mal_hspec_stm32f0_i2c_states_e)I2C_STATE_START;	handle->data_ptr = 0;	// Start transfer	uint32_t transfer_type = I2C_Generate_Start_Read;	if (MAL_I2C_WRITE == handle->cmd) {		transfer_type = I2C_Generate_Start_Write;	}	I2C_TransferHandling(handle->stm_handle, handle->msg->packet.address << 1, handle->msg->packet.packet_size,                         I2C_SoftEnd_Mode, transfer_type);}

uint8_t I2C_ReadReg(uint8_t addr, uint8_t reg, uint8_t *buffer, uint8_t length){    uint8_t count = 0;    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_BUSY) == SET);    I2C_TransferHandling(I2C2, addr, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXIS) == RESET);    I2C_SendData(I2C2, reg);    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_TC) == RESET);    I2C_TransferHandling(I2C2, addr, length, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);        while(count < length){        while(I2C_GetFlagStatus(I2C2, I2C_FLAG_RXNE) == RESET);        buffer[count] = I2C_ReceiveData(I2C2);        count++;    }    while(I2C_GetFlagStatus(I2C2, I2C_FLAG_STOPF) == RESET);    I2C_ClearFlag(I2C2, I2C_FLAG_STOPF);    return count;}

void f3d_i2c1_read(uint8_t device, uint8_t reg, uint8_t* buffer, uint16_t numbytes) {  while (I2C_GetFlagStatus(I2C1, I2C_ISR_BUSY) != RESET); // Wait for I2C to become free  I2C_TransferHandling(I2C1, device, 1, I2C_SoftEnd_Mode, I2C_Generate_Start_Write); // Send start and device address  while (I2C_GetFlagStatus(I2C1, I2C_ISR_TXIS) == RESET); // Confirm that the transmitter empty  if (numbytes>1) {    reg |=0x80; // indicate that the transfer will involve multiple bytes  }  I2C_SendData(I2C1,reg); // Send the register address  while (I2C_GetFlagStatus(I2C1, I2C_ISR_TC) == RESET);  I2C_TransferHandling(I2C1, device, numbytes, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);  while (numbytes--) {    while(I2C_GetFlagStatus(I2C1, I2C_ISR_RXNE) == RESET);    *buffer++ = I2C_ReceiveData(I2C1);  }  while (I2C_GetFlagStatus(I2C1, I2C_ISR_STOPF) == RESET); // Wait for stop flag generation  I2C_ClearFlag(I2C1, I2C_ICR_STOPCF);}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) {    I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);    int count;    int value;    if (length == 0) return 0;    // Configure slave address, nbytes, reload, end mode and start or stop generation    I2C_TransferHandling(i2c, address, length, I2C_AutoEnd_Mode, I2C_Generate_Start_Read);    // Read all bytes    for (count = 0; count < length; count++) {        value = i2c_byte_read(obj, 0);        data[count] = (char)value;    }    return length;}

int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) {    I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);    //int timeout;    int count;    if (length == 0) return 0;    // [TODO] The stop is always sent even with I2C_SoftEnd_Mode. To be corrected.    // Configure slave address, nbytes, reload, end mode and start or stop generation    //if (stop) {    I2C_TransferHandling(i2c, address, length, I2C_AutoEnd_Mode, I2C_Generate_Start_Write);    //}    //else {    //    I2C_TransferHandling(i2c, address, length, I2C_SoftEnd_Mode, I2C_Generate_Start_Write);    //}    // Write all bytes    for (count = 0; count < length; count++) {        if (i2c_byte_write(obj, data[count]) != 1) {            i2c_stop(obj);            return 0;        }    }    /*    if (stop) {        // Wait until STOPF flag is set        timeout = LONG_TIMEOUT;        while (I2C_GetFlagStatus(i2c, I2C_ISR_STOPF) == RESET) {            timeout--;            if (timeout == 0) {                return 0;            }        }        // Clear STOPF flag        I2C_ClearFlag(i2c, I2C_ICR_STOPCF);    }    */    return count;}

uint8_t u8g_i2c_send_byte(uint8_t data){	//Send the address of the register we wish to write to	I2C_SendData(I2C1, control);	//Ensure that the transfer complete reload flag is Set, essentially a standard	//TC flag	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TCR) == RESET);	//Now that the HMC5883L knows which register we want to write to, send the address	//again and ensure the I2C peripheral doesn't add any start or stop conditions	I2C_TransferHandling(I2C1, 0x78, 1, I2C_AutoEnd_Mode, I2C_No_StartStop);	//Again, wait until the transmit interrupted flag is set	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TXIS) == RESET);	//Send the value you wish you write to the register	I2C_SendData(I2C1, data);	while(I2C_GetFlagStatus(I2C1, I2C_FLAG_TCR) == RESET);    return 1;}