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

void SensorsTaskOSInit(void){       osSemaphoreDef(i2cTransactSem);            i2cSem = osSemaphoreCreate(osSemaphore(i2cTransactSem), 1);        ALBI2CHandle.Instance              = ALB_I2C;    ALBI2CHandle.Init.AddressingMode   = I2C_ADDRESSINGMODE_7BIT;    ALBI2CHandle.Init.Timing           = I2C_TIMING_100KHZ;    ALBI2CHandle.Init.DualAddressMode  = I2C_DUALADDRESS_DISABLED;    ALBI2CHandle.Init.OwnAddress2Masks = I2C_OA2_NOMASK;    ALBI2CHandle.Init.GeneralCallMode  = I2C_GENERALCALL_DISABLED;    ALBI2CHandle.Init.NoStretchMode    = I2C_NOSTRETCH_DISABLED;    ALBI2CHandle.Init.OwnAddress1      = 0x00;    ALBI2CHandle.Init.OwnAddress2      = 0x00;        assert_param(HAL_I2C_Init(&ALBI2CHandle) == HAL_OK);        SLBI2CHandle.Instance              = SLB_I2C;    SLBI2CHandle.Init.AddressingMode   = I2C_ADDRESSINGMODE_7BIT;    SLBI2CHandle.Init.Timing           = I2C_TIMING_100KHZ;    SLBI2CHandle.Init.DualAddressMode  = I2C_DUALADDRESS_DISABLED;    SLBI2CHandle.Init.OwnAddress2Masks = I2C_OA2_NOMASK;    SLBI2CHandle.Init.GeneralCallMode  = I2C_GENERALCALL_DISABLED;    SLBI2CHandle.Init.NoStretchMode    = I2C_NOSTRETCH_DISABLED;    SLBI2CHandle.Init.OwnAddress1      = 0x00;    SLBI2CHandle.Init.OwnAddress2      = 0x00;        assert_param(HAL_I2C_Init(&SLBI2CHandle) == HAL_OK);}

/**  * @brief I2C1 Initialization Function  * @param None  * @retval None  */static void MX_I2C1_Init(void){  /* USER CODE BEGIN I2C1_Init 0 */  /* USER CODE END I2C1_Init 0 */  /* USER CODE BEGIN I2C1_Init 1 */  /* USER CODE END I2C1_Init 1 */  hi2c1.Instance = I2C1;  hi2c1.Init.ClockSpeed = 400000;  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;  hi2c1.Init.OwnAddress1 = 0;  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;  hi2c1.Init.OwnAddress2 = 0;  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;  if (HAL_I2C_Init(&hi2c1) != HAL_OK)  {    Error_Handler();  }  /* USER CODE BEGIN I2C1_Init 2 */  /* USER CODE END I2C1_Init 2 */}

/** * @brief  Configures I2C interface * @param  None * @retval HAL status */static HAL_StatusTypeDef I2C_SHIELDS_Init(void){    HAL_StatusTypeDef ret_val = HAL_OK;      if(HAL_I2C_GetState(&I2C_SHIELDS_Handle) == HAL_I2C_STATE_RESET)    {        /* I2C_SHIELDS peripheral configuration */      //  I2C_SHIELDS_Handle.Init.ClockSpeed = NUCLEO_I2C_SHIELDS_SPEED;      //  I2C_SHIELDS_Handle.Init.DutyCycle = I2C_DUTYCYCLE_2;#ifdef STM32F401xE              I2C_SHIELDS_Handle.Init.ClockSpeed = NUCLEO_I2C_SHIELDS_SPEED;        I2C_SHIELDS_Handle.Init.DutyCycle = I2C_DUTYCYCLE_2;#endif#ifdef STM32L053xx        I2C_SHIELDS_Handle.Init.Timing = 0x0070D8FF;                            /*Refer AN4235-Application note Document*/#endif                I2C_SHIELDS_Handle.Init.OwnAddress1 = 0x33;        I2C_SHIELDS_Handle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;        I2C_SHIELDS_Handle.Instance = NUCLEO_I2C_SHIELDS;        /* Init the I2C */        I2C_SHIELDS_MspInit();        ret_val = HAL_I2C_Init(&I2C_SHIELDS_Handle);    }        return ret_val;}

/* I2C2 init function */void MX_I2C2_Init(void){  hi2c2.Instance = I2C2;  hi2c2.Init.Timing = 0x20303E5D;  hi2c2.Init.OwnAddress1 = 0;  hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;  hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;  hi2c2.Init.OwnAddress2 = 0;  hi2c2.Init.OwnAddress2Masks = I2C_OA2_NOMASK;  hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;  hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;  if (HAL_I2C_Init(&hi2c2) != HAL_OK)  {    Error_Handler();  }    /**Configure Analogue filter     */  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c2, I2C_ANALOGFILTER_ENABLE) != HAL_OK)  {    Error_Handler();  }}

void VL6180x_Shield_I2C1_Init(I2C_HandleTypeDef *hi2c1) {    GPIO_InitTypeDef GPIO_InitStruct;    /* Peripheral clock enable */    __I2C1_CLK_ENABLE();    /**I2C1 GPIO Configuration     PB8     ------> I2C1_SCL	     PB9     ------> I2C1_SDA     */    GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9;    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_LOW;    GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    hi2c1->Instance = I2C1;    hi2c1->Init.ClockSpeed = 400000;    hi2c1->Init.DutyCycle = I2C_DUTYCYCLE_2;    hi2c1->Init.OwnAddress1 = 0;    hi2c1->Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    hi2c1->Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;    hi2c1->Init.OwnAddress2 = 0;    hi2c1->Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    hi2c1->Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;    HAL_I2C_Init(hi2c1);}

/* I2C3 init function */void MX_I2C3_Init(void){	/*	 * The following is the required sequence in master mode.	 *	 * Program the peripheral input clock in I2C_CR2 Register in order to generate correct	 * timings	 * Configure the clock control registers	 * Configure the rise time register	 * Program the I2C_CR1 register to enable the peripheral	 * Set the START bit in the I2C_CR1 register to generate a Start condition	 */  hi2c3.Instance = I2C3;  hi2c3.Init.ClockSpeed = 100000;  hi2c3.Init.DutyCycle = I2C_DUTYCYCLE_2;  hi2c3.Init.OwnAddress1 = 0;  hi2c3.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;  hi2c3.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;  hi2c3.Init.OwnAddress2 = 0;  hi2c3.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;  hi2c3.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;  HAL_I2C_Init(&hi2c3);}

int initMPU(void){	int initOkay = -1;	HAL_I2C_StateTypeDef state;	uint8_t tempByte = 13;	uint8_t buffer[10] = {0,0,0,0,0,0,0,0,0,0};	hnd.Instance = I2C1;	hnd.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;	hnd.Init.ClockSpeed	= 400000;	hnd.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;	hnd.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;	hnd.Init.DutyCycle = I2C_DUTYCYCLE_2;	hnd.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;	hnd.Init.OwnAddress1 = 0x00;		HAL_I2C_Init(&hnd);	__HAL_I2C_ENABLE(&hnd);	state = HAL_I2C_GetState(&hnd); 	if(state == HAL_I2C_STATE_READY){		initOkay = 0;	}	buffer[0]=MPU6050_RA_PWR_MGMT_1;	buffer[1]=0x80;	printf("READ: %u",SCCB_Read(MPU6050_RA_WHO_AM_I));	printf("error: %u",HAL_I2C_GetError(&hnd));	return initOkay;}

CSensor::CSensor() : mMPU1(false, mHandle),					 	 	 	      	  	  	  	  	 mMPU2(true, mHandle){	mHandle.Instance = I2C1;	__HAL_RCC_GPIOB_CLK_ENABLE();	__HAL_RCC_I2C1_CLK_ENABLE();	GPIO_InitTypeDef initPort;	initPort.Pin 		= GPIO_PIN_6 | GPIO_PIN_7;	initPort.Mode 		= GPIO_MODE_AF_OD;	initPort.Pull 		= GPIO_PULLUP;	initPort.Speed 		= GPIO_SPEED_FREQ_VERY_HIGH;	initPort.Alternate 	= GPIO_AF4_I2C1;	HAL_GPIO_Init(GPIOB, &initPort);	mHandle.Init.ClockSpeed 		= 400000U;	mHandle.Init.DutyCycle 			= I2C_DUTYCYCLE_2;	mHandle.Init.OwnAddress2 		= 0x00U;	mHandle.Init.OwnAddress1 		= 0x00U;	mHandle.Init.AddressingMode 	= I2C_ADDRESSINGMODE_7BIT;	mHandle.Init.DualAddressMode 	= I2C_DUALADDRESS_DISABLE;	mHandle.Init.GeneralCallMode 	= I2C_GENERALCALL_DISABLE;	mHandle.Init.NoStretchMode 		= I2C_NOSTRETCH_DISABLE;	HAL_I2C_Init(&mHandle);	if(false == (mMPU1.init() && mMPU2.init()))	{		//Error-Handler	}	mMPU1.writeRegister(MPU6050::CONFIG, static_cast<UInt8>(ELowPass::BANDWIDTH_44));	mMPU2.writeRegister(MPU6050::CONFIG, static_cast<UInt8>(ELowPass::BANDWIDTH_44));}

/** * @brief  Configures I2C interface * @retval HAL status */static HAL_StatusTypeDef I2C_EXPBD_Init(void){    HAL_StatusTypeDef ret_val = HAL_OK;    if(HAL_I2C_GetState(&I2C_EXPBD_Handle) == HAL_I2C_STATE_RESET)    {        /* I2C_EXPBD peripheral configuration */#if ((defined (USE_STM32F4XX_NUCLEO)) || (defined (USE_STM32L1XX_NUCLEO)))        I2C_EXPBD_Handle.Init.ClockSpeed = NUCLEO_I2C_EXPBD_SPEED;        I2C_EXPBD_Handle.Init.DutyCycle = I2C_DUTYCYCLE_2;#endif#if (defined (USE_STM32L0XX_NUCLEO))        I2C_EXPBD_Handle.Init.Timing = NUCLEO_I2C_EXPBD_TIMING_400KHZ;                            /* 400KHz */#endif        I2C_EXPBD_Handle.Init.OwnAddress1 = 0x33;        I2C_EXPBD_Handle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;        I2C_EXPBD_Handle.Instance = NUCLEO_I2C_EXPBD;        /* Init the I2C */        I2C_EXPBD_MspInit();        ret_val = HAL_I2C_Init(&I2C_EXPBD_Handle);    }    return ret_val;}

void i2c_frequency(i2c_t *obj, int hz) {    MBED_ASSERT((hz == 100000) || (hz == 400000) || (hz == 1000000));    I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);    // Common settings: I2C clock = 32 MHz, Analog filter = ON, Digital filter coefficient = 0    switch (hz) {        case 100000:            I2cHandle.Init.Timing = 0x20602938; // Standard mode with Rise Time = 400ns and Fall Time = 100ns            break;        case 400000:            I2cHandle.Init.Timing = 0x00B0122A; // Fast mode with Rise Time = 250ns and Fall Time = 100ns            break;        case 1000000:            I2cHandle.Init.Timing = 0x0030040E; // Fast mode Plus with Rise Time = 60ns and Fall Time = 100ns            break;        default:            break;    }    // I2C configuration    I2cHandle.Init.AddressingMode   = I2C_ADDRESSINGMODE_7BIT;    I2cHandle.Init.DualAddressMode  = I2C_DUALADDRESS_DISABLED;    I2cHandle.Init.GeneralCallMode  = I2C_GENERALCALL_DISABLED;    I2cHandle.Init.NoStretchMode    = I2C_NOSTRETCH_DISABLED;    I2cHandle.Init.OwnAddress1      = 0;    I2cHandle.Init.OwnAddress2      = 0;    I2cHandle.Init.OwnAddress2Masks = I2C_OA2_NOMASK;    HAL_I2C_Init(&I2cHandle);}

/******************************************************************************* * @brief  : Initialise et configure le peripherique I2C #2 * @param  : Aucun. * @return : Rien. ******************************************************************************/void LBF_I2C1_Init (uint32_t I2C1_Speed){// Following settings assume I2C1 core clock (=APB1 clock in Default LimiFrog setting)// is 8MHz and target I2C1 speed is 100KHz// TODO Find a way to ensure I2C2 clock remains 8MHz if STM32L4 core clock modified#define I2C1_PRESC	0x1   // tPRESC = (PRESC+1) x tI2C2CLK  -- 0.25us / 4MHz#define I2C1_SCLL  	0x13   // tSCLL = (SCLL+1) x tPRESC  --  5us#define I2C1_SCLH 	0x0F   // tSCLH = (SCLH+1) x tPRESC  --  4us#define I2C1_SDADEL 	0x2   // tSDADEL = SDADEL x tPRESC  -- 0.5us#define I2C1_SCLDEL	0x4   // tSCLDEL = (SCLDEL+1) x tPRESC  -- 1.25us// I2C speed: 400KHz,//  defined by tSCL = tSCLL + tSCLH + tSYNC1 + tSYNC2 ~ 2.5us  (400KHz)//  where tSYNC1 and tSYNC2 are delays introduced by the analog and/or digital noise filters and resync mechasinsms -- refer to Ref Manual I2C section (I2C master mode)// SCLDEL defines setup time: SDA stable before SCL rising edge// SDADEL defines hold time: SDA stable after SCL *falling* edge (as per I2C spec?)  hi2c1.Instance = I2C1;  hi2c1.Init.Timing = ((uint32_t)I2C1_PRESC ) << 28		    | ((uint32_t)I2C1_SCLDEL ) << 20		    | ((uint32_t)I2C1_SDADEL ) << 16		    | ((uint32_t)I2C1_SCLH ) << 8		    | ((uint32_t)I2C1_SCLL )  ;      //Contents of the I2C_TIMINGR_register value  hi2c1.Init.OwnAddress1 = 0;  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;  hi2c1.Init.OwnAddress2 = 0;  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;   HAL_I2C_Init(&hi2c1);}

/* I2C1 init function */static void MX_I2C1_Init(void){  hi2c1.Instance = I2C1;  hi2c1.Init.Timing = 0x2000090E;  hi2c1.Init.OwnAddress1 = 0;  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;  hi2c1.Init.OwnAddress2 = 0;  hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;  if (HAL_I2C_Init(&hi2c1) != HAL_OK)  {    _Error_Handler(__FILE__, __LINE__);  }    /**Configure Analogue filter    */  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)  {    _Error_Handler(__FILE__, __LINE__);  }    /**Configure Digital filter    */  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)  {    _Error_Handler(__FILE__, __LINE__);  }}

void i2c_hal_intialization(){ /*------------------- Initialization I2C bus -------------------*/    /*---------- Setup GPIOB - I2C1 port --------------*/    __GPIOB_CLK_ENABLE(); // Enable clock source for GPIOB    I2C1_GPIO_struct.Pin = I2C1_SDA|I2C1_SCL;    I2C1_GPIO_struct.Mode = GPIO_MODE_AF_OD;    I2C1_GPIO_struct.Pull = GPIO_PULLUP;    I2C1_GPIO_struct.Speed = GPIO_SPEED_HIGH;    I2C1_GPIO_struct.Alternate = GPIO_AF4_I2C1;    HAL_GPIO_Init(GPIOB, & I2C1_GPIO_struct);    /*------------------- Setup I2C1 -------------------*/    __I2C1_CLK_ENABLE(); // Enable clock source for I2C peripherals    I2C1_struct.Instance = I2C1;    I2C1_struct.Init.ClockSpeed = 400000;    I2C1_struct.Init.DutyCycle = I2C_DUTYCYCLE_2;    I2C1_struct.Init.OwnAddress1 = 0;    I2C1_struct.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    I2C1_struct.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;    I2C1_struct.Init.OwnAddress2 = 0;    I2C1_struct.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    I2C1_struct.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;    HAL_I2C_Init(&I2C1_struct);}

void i2c_frequency(i2c_t *obj, int hz){    MBED_ASSERT((hz > 0) && (hz <= 400000));    I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);    int timeout;    // wait before init    timeout = LONG_TIMEOUT;    while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));    // I2C configuration    I2cHandle.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;    I2cHandle.Init.ClockSpeed      = hz;    I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;    I2cHandle.Init.DutyCycle       = I2C_DUTYCYCLE_2;    I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    I2cHandle.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLED;    I2cHandle.Init.OwnAddress1     = 0;    I2cHandle.Init.OwnAddress2     = 0;    HAL_I2C_Init(&I2cHandle);    if (obj->slave) {        /* Enable Address Acknowledge */        I2cHandle.Instance->CR1 |= I2C_CR1_ACK;    }}

/**  * @brief  Initializes peripherals used by the I2C EEPROM driver.  * @param  None  * @retval None  */bool TWI_open(new_twi* TwiStruct){	if(!TwiStruct)		return false;	  I2C_HandleTypeDef *I2cHandle = calloc(1, sizeof(I2C_HandleTypeDef));	  if(!I2cHandle)		  return false;	   //I2C_InitTypeDef  I2C_InitStructure;	  TwiStruct->udata = (void *)I2cHandle;	  sEE_LowLevel_Init(TwiStruct);/*##-1- Configure the I2C peripheral #######################################*/	  I2cHandle->Instance             = sEE_I2C[TwiStruct->TwiNr];	  I2cHandle->Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;	  I2cHandle->Init.Timing      		= I2C_TIMING;	  I2cHandle->Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;	  //I2cHandle->Init.DutyCycle       = I2C_DUTYCYCLE_2;	  I2cHandle->Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;	  I2cHandle->Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;	  I2cHandle->Init.OwnAddress1     = TwiStruct->MasterSlaveAddr;	  //I2cHandle.Init.OwnAddress2     = 0xFF;	  if(HAL_I2C_Init(I2cHandle) != HAL_OK)	  {		  /* Initialization Error */		  return false;	  }	  return true;}

bool ADXL345::init(RANGE range, DATA_RATE dataRate){	GPIO PB10(GPIOB, GPIO::PIN10);	GPIO PB11(GPIOB, GPIO::PIN11);		PB10.init(GPIO::AF, GPIO::OD, GPIO::NONE, GPIO::MEDIUM);	PB11.init(GPIO::AF, GPIO::OD, GPIO::NONE, GPIO::MEDIUM);		/* Init I2C peripherals */	__HAL_RCC_I2C2_CLK_ENABLE();		i2c2.Instance             = I2C2;	i2c2.Init.ClockSpeed      = 100000; // clock speed 100kHz	i2c2.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;	i2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;	i2c2.Init.DutyCycle	      = I2C_DUTYCYCLE_2;	i2c2.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;	i2c2.Init.OwnAddress1     = 0x00;	i2c2.Init.OwnAddress2     = 0x00;	i2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;	HAL_I2C_Init(&i2c2);	if(this->getDevID() != 0xE5){		return false;	}	this->writeByte(POWER_CTL_REG, 0x08); // enable mesuare mode	this->clearSettings();	this->setRange(range);	this->setDataRate(dataRate);		return true;}

void i2c_frequency(i2c_t *obj, int hz){    MBED_ASSERT((hz == 100000) || (hz == 400000) || (hz == 1000000));    I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);    int timeout;    // wait before init    timeout = LONG_TIMEOUT;    while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));    // Common settings: I2C clock = 48 MHz, Analog filter = ON, Digital filter coefficient = 0    switch (hz) {        case 100000:            I2cHandle.Init.Timing = 0x10805E89; // Standard mode with Rise Time = 400ns and Fall Time = 100ns            break;        case 400000:            I2cHandle.Init.Timing = 0x00901850; // Fast mode with Rise Time = 250ns and Fall Time = 100ns            break;        case 1000000:            I2cHandle.Init.Timing = 0x00700818; // Fast mode Plus with Rise Time = 60ns and Fall Time = 100ns            break;        default:            break;    }    // I2C configuration    I2cHandle.Init.AddressingMode   = I2C_ADDRESSINGMODE_7BIT;    I2cHandle.Init.DualAddressMode  = I2C_DUALADDRESS_DISABLED;    I2cHandle.Init.GeneralCallMode  = I2C_GENERALCALL_DISABLED;    I2cHandle.Init.NoStretchMode    = I2C_NOSTRETCH_DISABLED;    I2cHandle.Init.OwnAddress1      = 0;    I2cHandle.Init.OwnAddress2      = 0;    I2cHandle.Init.OwnAddress2Masks = I2C_OA2_NOMASK;    HAL_I2C_Init(&I2cHandle);}

int tca9545_init(void){	GPIO_InitTypeDef GPIO_InitStruct;	uint8_t buf;	GPIO_InitStruct.Pin = tca9545RESET_PIN;	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;	GPIO_InitStruct.Pull = GPIO_PULLUP;	GPIO_InitStruct.Speed = GPIO_SPEED_LOW;    HAL_GPIO_Init(tca9545RESET_PORT, &GPIO_InitStruct);    tca9545_reset();	/* Init I2C Bus */	hi2c1.Instance = I2C1;	hi2c1.Init.ClockSpeed = 400000;	hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;	hi2c1.Init.OwnAddress1 = 0;	hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;	hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;	hi2c1.Init.OwnAddress2 = 0;	hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;	hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;	HAL_I2C_Init(&hi2c1);	/* Check the chip information */	buf = tca9545_get();	return 0;}

void I2C_Reset(void){  HAL_GPIO_WritePin(I2Cx_WAKEUP_GPIO_PORT, I2Cx_WAKEUP_PIN, GPIO_PIN_RESET);  HAL_I2C_DeInit(&I2cHandle);  HAL_I2C_Init(&I2cHandle);  HAL_Delay(5);  HAL_GPIO_WritePin(I2Cx_WAKEUP_GPIO_PORT, I2Cx_WAKEUP_PIN, GPIO_PIN_SET);  HAL_Delay(400);}

/* I2C1 init function */static void MX_I2C1_Init(void){    hi2c1.Instance = I2C1;//    hi2c1.Init.Timing = 0x2000090E;    hi2c1.Init.Timing =        (1 << I2C_TIMINGR_PRESC_Pos)    |        (0x13 << I2C_TIMINGR_SCLL_Pos)  |        (0x0F << I2C_TIMINGR_SCLH_Pos)  |        (0x2 << I2C_TIMINGR_SDADEL_Pos) |        (0x4 << I2C_TIMINGR_SCLDEL_Pos) ;    hi2c1.Init.OwnAddress1 = I2C_SLAVE_ADDR << 1;    hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;    hi2c1.Init.OwnAddress2 = 0;    hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;    hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;    if (HAL_I2C_Init(&hi2c1) != HAL_OK)    {        Error_Handler();    }    /**Configure Analogue filter    */    if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)    {        Error_Handler();    }    uart_printf("i2c init../r/n");    HAL_I2C_Init(&hi2c1);    uart_printf("i2c init done../r/n");}

/* I2C3 init function */void MX_I2C3_Init(void){    hi2c3.Instance = I2C3;    hi2c3.Init.ClockSpeed = 400000;    hi2c3.Init.DutyCycle = I2C_DUTYCYCLE_2;    hi2c3.Init.OwnAddress1 = 0x32 << 1;    hi2c3.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    hi2c3.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;    hi2c3.Init.OwnAddress2 = 0;    hi2c3.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    hi2c3.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;    HAL_I2C_Init(&hi2c3);}

void SSD1306_I2C_Init(void) {    hi2c.Instance = SSD1306_I2Cx;    hi2c.Init.ClockSpeed = SSD1306_CLOCK;    hi2c.Init.DutyCycle = I2C_DUTYCYCLE_2;    hi2c.Init.OwnAddress1 = 0;    hi2c.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    hi2c.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;    hi2c.Init.OwnAddress2 = 0;    hi2c.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    hi2c.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;    HAL_I2C_MspInit(&hi2c);    HAL_I2C_Init(&hi2c);}

/** * @brief	Initializes the I2C * @param	None * @retval	None */void I2C2_Init(){	/* Make sure we only initialize it once */	if (!prvInitialized)	{		/* Mutex semaphore for mutual exclusion to the I2C2 device */		xSemaphore = xSemaphoreCreateMutex();		if (xSemaphoreTake(xSemaphore, 100) == pdTRUE)		{			/* I2C clock & GPIOB enable */			__GPIOB_CLK_ENABLE();			__I2C2_CLK_ENABLE();			/* I2C SDA and SCL configuration */			GPIO_InitTypeDef GPIO_InitStructure;			GPIO_InitStructure.Pin  		= I2C_SCL_PIN | I2C_SDA_PIN;			GPIO_InitStructure.Mode  		= GPIO_MODE_AF_OD;			GPIO_InitStructure.Alternate 	= GPIO_AF4_I2C2;			GPIO_InitStructure.Pull			= GPIO_NOPULL;			GPIO_InitStructure.Speed 		= GPIO_SPEED_HIGH;			HAL_GPIO_Init(I2C_PORT, &GPIO_InitStructure);		//	/* NVIC Configuration */		//	NVIC_InitTypeDef NVIC_InitStructure;		//	/* Event interrupt */		//	NVIC_InitStructure.NVIC_IRQChannel = I2C1_EV_IRQn;		//	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configMAX_SYSCALL_INTERRUPT_PRIORITY;		//	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;		//	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;		//	NVIC_Init(&NVIC_InitStructure);		//	/* Error interrupt */		//	NVIC_InitStructure.NVIC_IRQChannel = I2C1_ER_IRQn;		//	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 14;		//	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;		//	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;		//	NVIC_Init(&NVIC_InitStructure);			/* I2C Init */			HAL_I2C_Init(&I2C_Handle);			/* Enable the I2C1 interrupts */		//	I2C_ITConfig(I2C_PERIPHERAL, I2C_IT_EVT, ENABLE);		//	I2C_ITConfig(I2C_PERIPHERAL, I2C_IT_ERR, ENABLE);			xSemaphoreGive(xSemaphore);		}		prvInitialized = true;	}}

void MX_I2C3_Init( I2C_HandleTypeDef &i2c, uint32_t speed  ){  i2c.Instance              = I2C3;  i2c.Init.ClockSpeed       = speed;  i2c.State                 = HAL_I2C_STATE_RESET;  i2c.Init.AddressingMode   = I2C_ADDRESSINGMODE_7BIT;  i2c.Init.DualAddressMode  = I2C_DUALADDRESS_DISABLE;  i2c.Init.DutyCycle        = I2C_DUTYCYCLE_16_9;  i2c.Init.GeneralCallMode  = I2C_GENERALCALL_DISABLE;  i2c.Init.NoStretchMode    = I2C_NOSTRETCH_DISABLE;  i2c.Init.OwnAddress1      = 0;  i2c.Init.OwnAddress2      = 0;  HAL_I2C_Init( &i2c );}

// Initialize i2c1. Currently connected to the IMU and the digital potvoid init_i2c1(void){	//I2C_HandleTypeDef *hi2c1 contains our handle information	//set config for the initial state of the i2c.	hi2c1.Instance = I2C1;	hi2c1.Init.ClockSpeed = I2C_CLOCK_RATE;  				//clock frequency; less than 400kHz	hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2; 				//for fast mode (doesn't matter now)	hi2c1.Init.OwnAddress1 = 0x0; 							//device address of the STM32 (doesn't matter)	hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;	//using 7 bit addresses	hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;  //disable dual address	hi2c1.Init.OwnAddress2 = 0x0;							//second device addr (doesn't matter)	hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;  //don't use 0x0 addr	hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; 		//allow slave to stretch SCL	hi2c1.State = HAL_I2C_STATE_RESET;	HAL_I2C_Init(&hi2c1);}

/**  * @brief  Configures I2C interface.  * @param  None  * @retval None  */static void I2Cx_Init(void){  if(HAL_I2C_GetState(&I2cHandle) == HAL_I2C_STATE_RESET)  {    /* DISCOVERY_I2Cx peripheral configuration */    I2cHandle.Init.ClockSpeed = 10000;    I2cHandle.Init.DutyCycle = I2C_DUTYCYCLE_2;    I2cHandle.Init.OwnAddress1 = 0x33;    I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    I2cHandle.Instance = DISCOVERY_I2Cx;          /* Init the I2C */    I2Cx_MspInit();    HAL_I2C_Init(&I2cHandle);  }}

/**  * @brief  initializes the M24LR04E  * @param  None  * @retval None  */void M24LR04E_init () {	I2CHandle.Instance              = I2C;  I2CHandle.Init.AddressingMode   = I2C_ADDRESSINGMODE_7BIT;  I2CHandle.Init.Timing           = I2C_TIMING_100KHZ;  I2CHandle.Init.DualAddressMode  = I2C_DUALADDRESS_DISABLE;  I2CHandle.Init.OwnAddress2Masks = I2C_OA2_NOMASK;  I2CHandle.Init.GeneralCallMode  = I2C_GENERALCALL_DISABLE;  I2CHandle.Init.NoStretchMode    = I2C_NOSTRETCH_DISABLE;  I2CHandle.Init.OwnAddress1      = 0xFE;  I2CHandle.Init.OwnAddress2      = 0xFE;  if(HAL_I2C_Init(&I2CHandle) != HAL_OK) {		get_app_config()->error_code = I2C_ERROR;    Error_Handler();      }}

/**  * @brief Discovery I2Cx Bus initialization  * @param None  * @retval None  */void I2Cbar_Init(void){  if(HAL_I2C_GetState(&I2CbarHandle) == HAL_I2C_STATE_RESET)  {    I2CbarHandle.Instance = DISCOVERY_I2Cbar;    I2CbarHandle.Init.OwnAddress1 =  BAROMETER_I2C_ADDRESS;    I2CbarHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;    I2CbarHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;    I2CbarHandle.Init.OwnAddress2 = 0;    I2CbarHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;    I2CbarHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;    /* Init the I2C */    I2Cbar_MspInit();    HAL_I2C_Init(&I2CbarHandle);  }}

/* I2C1 init function */void MX_I2C1_Init(void){  hi2c1.Instance = I2C1;  hi2c1.Init.ClockSpeed = 400000;  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;  hi2c1.Init.OwnAddress1 = I2C_ADDR_HOST_MCU;  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;  hi2c1.Init.OwnAddress2 = 0;  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_ENABLED;  HAL_I2C_Init(&hi2c1);  NVIC_SetPriority(I2C1_EV_IRQn, 6);  HAL_NVIC_EnableIRQ(I2C1_EV_IRQn);}