void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // Determine the I2C to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT(obj->i2c != (I2CName)NC); // Enable I2C clock if (obj->i2c == I2C_1) { __I2C1_CLK_ENABLE(); } if (obj->i2c == I2C_2) { __I2C2_CLK_ENABLE(); } if (obj->i2c == I2C_3) { __I2C3_CLK_ENABLE(); } // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**I2C1 GPIO Configuration PB6 ------> I2C1_SCL PB7 ------> I2C1_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**I2C1 GPIO Configuration PB7 ------> I2C1_SDA PB8 ------> I2C1_SCL */ GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(I2C1_EV_IRQn, 7, 0); HAL_NVIC_EnableIRQ(I2C1_EV_IRQn); HAL_NVIC_SetPriority(I2C1_ER_IRQn, 6, 0); HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } }
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); }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // Determine the I2C to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); if (obj->i2c == (I2CName)NC) { error("I2C error: pinout mapping failed."); } // Enable I2C clock if (obj->i2c == I2C_1) { __HAL_RCC_I2C1_CONFIG(RCC_I2C1CLKSOURCE_SYSCLK); __I2C1_CLK_ENABLE(); } if (obj->i2c == I2C_2) { __I2C2_CLK_ENABLE(); } // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default }
void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) { GPIO_InitTypeDef GPIO_InitStruct; //Enable the GPIO-clock __GPIOB_CLK_ENABLE(); //Enable the I2C-Clock __I2C1_CLK_ENABLE(); //Configure GPIOB Pin_6 as SCL for I2C GPIO_InitStruct.Pin = GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; //init GPIOB PIN6 (SCL-Pin) HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); //Configure GPIOB Pin_7 as SDA for USART GPIO_InitStruct.Pin = GPIO_PIN_7; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; //init GPIOB PIN7 (SDA-Pin) HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); //Setup the Interruptlevel HAL_NVIC_SetPriority(I2C1_EV_IRQn, 0, 1); HAL_NVIC_SetPriority(I2C1_ER_IRQn, 0, 1); //enable the interrupt for USART1 HAL_NVIC_EnableIRQ(I2C1_EV_IRQn); HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**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_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } }
void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* Peripheral clock enable */ I2C1_SDA_GPIO_CLK_ENABLE(); I2C1_SCL_GPIO_CLK_ENABLE(); __I2C1_CLK_ENABLE(); /**I2C1 GPIO Configuration */ GPIO_InitStruct.Pin = I2C1_SDA_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = I2C1_SDA_AF; HAL_GPIO_Init(I2C1_SDA_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = I2C1_SCL_PIN; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = I2C1_SCL_AF; HAL_GPIO_Init(I2C1_SCL_PORT, &GPIO_InitStruct); } }
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_init(i2c_t *obj, PinName sda, PinName scl) { static int i2c1_inited = 0; static int i2c2_inited = 0; #if defined(I2C3_BASE) static int i2c3_inited = 0; #endif // Determine the I2C to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT(obj->i2c != (I2CName)NC); // Enable I2C1 clock and pinout if not done if ((obj->i2c == I2C_1) && !i2c1_inited) { i2c1_inited = 1; __HAL_RCC_I2C1_CONFIG(RCC_I2C1CLKSOURCE_SYSCLK); __I2C1_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Enable I2C2 clock and pinout if not done if ((obj->i2c == I2C_2) && !i2c2_inited) { i2c2_inited = 1; __I2C2_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } #if defined(I2C3_BASE) // Enable I2C3 clock and pinout if not done if ((obj->i2c == I2C_3) && !i2c3_inited) { i2c3_inited = 1; __I2C3_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } #endif // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**I2C1 GPIO Configuration PB6 ------> I2C1_SCL PB7 ------> I2C1_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* Peripheral DMA init*/ hdma_i2c1_rx.Instance = DMA1_Stream5; hdma_i2c1_rx.Init.Channel = DMA_CHANNEL_1; hdma_i2c1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_i2c1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c1_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c1_rx.Init.Mode = DMA_NORMAL; hdma_i2c1_rx.Init.Priority = DMA_PRIORITY_MEDIUM; hdma_i2c1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_i2c1_rx); __HAL_LINKDMA(hi2c,hdmarx,hdma_i2c1_rx); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(I2C1_EV_IRQn, 0, 13); HAL_NVIC_EnableIRQ(I2C1_EV_IRQn); HAL_NVIC_SetPriority(I2C1_ER_IRQn, 0, 15); HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**I2C1 GPIO Configuration PB6 ------> I2C1_SCL PB7 ------> I2C1_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(I2C1_ER_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } else if(hi2c->Instance==I2C2) { /* USER CODE BEGIN I2C2_MspInit 0 */ /* USER CODE END I2C2_MspInit 0 */ /**I2C2 GPIO Configuration PB10 ------> I2C2_SCL PB11 ------> I2C2_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C2_CLK_ENABLE(); /* Peripheral interrupt init*/ HAL_NVIC_SetPriority(I2C2_EV_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2C2_EV_IRQn); HAL_NVIC_SetPriority(I2C2_ER_IRQn, 0, 0); HAL_NVIC_EnableIRQ(I2C2_ER_IRQn); /* USER CODE BEGIN I2C2_MspInit 1 */ /* USER CODE END I2C2_MspInit 1 */ } }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**I2C1 GPIO Configuration PB6 ------> I2C1_SCL PB7 ------> I2C1_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Speed = GPIO_SPEED_LOW; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* Peripheral DMA init*/ hdma_i2c1_rx.Instance = DMA1_Channel7; hdma_i2c1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_i2c1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c1_rx.Init.MemInc = DMA_MINC_DISABLE; hdma_i2c1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c1_rx.Init.Mode = DMA_NORMAL; hdma_i2c1_rx.Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_Init(&hdma_i2c1_rx); __HAL_LINKDMA(hi2c,hdmarx,hdma_i2c1_rx); hdma_i2c1_tx.Instance = DMA1_Channel6; hdma_i2c1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_i2c1_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c1_tx.Init.MemInc = DMA_MINC_DISABLE; hdma_i2c1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c1_tx.Init.Mode = DMA_NORMAL; hdma_i2c1_tx.Init.Priority = DMA_PRIORITY_LOW; HAL_DMA_Init(&hdma_i2c1_tx); __HAL_LINKDMA(hi2c,hdmatx,hdma_i2c1_tx); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // Determine the I2C to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT(obj->i2c != (I2CName)NC); // Enable I2C1 clock and pinout if not done if ((obj->i2c == I2C_1) && !i2c1_inited) { i2c1_inited = 1; __I2C1_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Enable I2C2 clock and pinout if not done if ((obj->i2c == I2C_2) && !i2c2_inited) { i2c2_inited = 1; __I2C2_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Enable I2C3 clock and pinout if not done if ((obj->i2c == I2C_3) && !i2c3_inited) { i2c3_inited = 1; __I2C3_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default // I2C master by default obj->slave = 0; }
//****************************************************************************** // board_i2c_enable_clock // // Ensures that the specified Timer's clock is turned on. //****************************************************************************** int board_i2c_enable_clock (int module_id) { //-------------------------------------------------------- // Turn on clock for the associated I2Cx module. //-------------------------------------------------------- switch (module_id) { case 1: // I2C1 __I2C1_CLK_ENABLE(); break; case 2: // I2C2 __I2C2_CLK_ENABLE(); break; } return (0); // denote everything worked OK }
// Implement I2C MSP Init, as called for in the stm32f4xx_hal_i2c.c file void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) { ///// SET UP GPIO ///// //GPIO initialization constants GPIO_InitTypeDef GPIO_InitStruct; //Enable peripheral and GPIO clockS __GPIOB_CLK_ENABLE(); __I2C1_CLK_ENABLE(); //IMU GPIO configuration /* T_SWO -> PB3 SCL1 -> PB8 (pin 23 on MPU6500) SDA1 -> PB9 (pin 24 on MPU6500) Be mindful that the SPI pins are also located on this bus! Also: IMUINT (pin 12 on MPU6500) Note: AD0/SDO grounded -> address for MPU6500 is 0b1101000 */ //Config inputs: //We are configuring these pins. GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9; //I2C wants to have open drain lines pulled up by resistors GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; //Although we need pullups for I2C, we have them externally on // the board. GPIO_InitStruct.Pull = GPIO_NOPULL; //Set GPIO speed to fastest speed. GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; //Assign function to pins. GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; //Initialize the pins. HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); ///// SET UP NVIC ///// (interrupts!) #if I2C_USE_INT == 1 HAL_NVIC_SetPriority(I2C1_EV_IRQn, 0, 1); //event interrupt HAL_NVIC_EnableIRQ(I2C1_EV_IRQn); HAL_NVIC_SetPriority(I2C1_ER_IRQn, 0, 1);//error interrupt HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); #endif }
void i2c_init(I2C_HandleTypeDef *i2c) { // init the GPIO lines GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.Mode = GPIO_MODE_AF_OD; GPIO_InitStructure.Speed = GPIO_SPEED_FAST; GPIO_InitStructure.Pull = GPIO_NOPULL; // have external pull-up resistors on both lines const pin_obj_t *pins[2]; if (0) { #if MICROPY_HW_ENABLE_I2C1 } else if (i2c == &I2CHandle1) { // X-skin: X9=PB6=SCL, X10=PB7=SDA pins[0] = &pin_B6; pins[1] = &pin_B7; GPIO_InitStructure.Alternate = GPIO_AF4_I2C1; // enable the I2C clock __I2C1_CLK_ENABLE(); #endif } else if (i2c == &I2CHandle2) { // Y-skin: Y9=PB10=SCL, Y10=PB11=SDA pins[0] = &pin_B10; pins[1] = &pin_B11; GPIO_InitStructure.Alternate = GPIO_AF4_I2C2; // enable the I2C clock __I2C2_CLK_ENABLE(); } else { // I2C does not exist for this board (shouldn't get here, should be checked by caller) return; } // init the GPIO lines for (uint i = 0; i < 2; i++) { GPIO_InitStructure.Pin = pins[i]->pin_mask; HAL_GPIO_Init(pins[i]->gpio, &GPIO_InitStructure); } // init the I2C device if (HAL_I2C_Init(i2c) != HAL_OK) { // init error // TODO should raise an exception, but this function is not necessarily going to be // called via Python, so may not be properly wrapped in an NLR handler printf("HardwareError: HAL_I2C_Init failed\n"); return; } }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { __I2C2_FORCE_RESET(); __I2C2_RELEASE_RESET(); /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**I2C1 GPIO Configuration PB8 ------> I2C1_SCL PB9 ------> I2C1_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); //hi2c->Instance->CR1 = I2C_CR1_SWRST; //复位I2C控制器 //hi2c->Instance->CR1 = 0; // 解除复位(不会自动清除) /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ /*##-3- Configure the NVIC for I2C #########################################*/ /* NVIC for I2C1 */ // HAL_NVIC_SetPriority(I2C1_ER_IRQn, 0, 1); // HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); // HAL_NVIC_SetPriority(I2C1_EV_IRQn, 0, 2); // HAL_NVIC_EnableIRQ(I2C1_EV_IRQn); } }
/* PCA9506DGG IO Expander works over I2C1 PB8: SCL PB9: SDA PC13: *INT (interrupt pin) PC14: *OE pin (output enable) PC15: *RESET pin */ void InitializeIOexpander() { __GPIOB_CLK_ENABLE(); /* Enable I2C1 pins peripheral clock */ __I2C1_CLK_ENABLE(); /* Enable I2C1 peripheral clock */ GPIO_InitTypeDef GPIO_I2C1; /* Struct for I2C1 pins */ GPIO_I2C1.Mode = GPIO_MODE_AF_OD; /* Alternate function, Open-Drain */ GPIO_I2C1.Pin = GPIO_PIN_8 | GPIO_PIN_9; /* PB8:SCL PB9:SDA */ GPIO_I2C1.Pull = GPIO_PULLUP; /* Pull up resistor for I2C */ GPIO_I2C1.Speed = GPIO_SPEED_HIGH; /* High pin speed */ GPIO_I2C1.Alternate = GPIO_AF4_I2C1; /* Pins connected to I2C1 */ HAL_GPIO_Init(GPIOB, &GPIO_I2C1); /* Write pin config to registers */ handleI2C1.Instance = I2C1; /* I2C1 is used */ handleI2C1.Init.ClockSpeed = 400000; /* 400kHz bus speed */ handleI2C1.Init.DutyCycle = I2C_DUTYCYCLE_2; /* 50:50 duty cycle */ handleI2C1.Init.OwnAddress1 = 0x00; /* Address for this device. Not necessary */ handleI2C1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; /* 7 bit address mode */ handleI2C1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; /* Single address is enough */ handleI2C1.Init.OwnAddress2 = 0x00; /* Not important since dual address mode is disabled */ handleI2C1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; /* General call disabled, since this device is not slave */ handleI2C1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; /* Stretch mode is free, slave can stretch the bus */ Console("I2C1 HAL_I2C_Init (0 is ok):", HAL_I2C_Init(&handleI2C1)); /* Write configuration to I2C register */ __GPIOC_CLK_ENABLE(); /* Enable C Port peripheral clock */ GPIO_InitTypeDef GPIO_INT; /* Create a struct for INTerrupt pin */ GPIO_INT.Pin = GPIO_PIN_13; /* PC13 */ GPIO_INT.Mode = GPIO_MODE_IT_RISING_FALLING; /* INTerrupt on both edges */ GPIO_INT.Pull = GPIO_PULLUP; /* Pull up resistor */ HAL_GPIO_Init(GPIOC, &GPIO_INT); /* Write to PORTC register */ HAL_NVIC_SetPriority(EXTI15_10_IRQn, 1, 0); /* Pre group 1, sub 2 */ HAL_NVIC_EnableIRQ(EXTI15_10_IRQn); /* Enable External interrupt on PC13 */.
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /**I2C1 GPIO Configuration PF0-OSC_IN ------> I2C1_SDA PF1-OSC_OUT ------> I2C1_SCL */ GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF1_I2C1; HAL_GPIO_Init(GPIOF, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); } }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /**I2C1 GPIO Configuration PB6 ------> I2C1_SCL PB7 ------> I2C1_SDA */ GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); } }
void Init_BMP085 (void) { GPIO_InitTypeDef GPIO_InitStruct; __I2C1_CLK_ENABLE(); __GPIOB_CLK_ENABLE(); __HAL_RCC_AFIO_CLK_ENABLE(); // Init I2C GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); __HAL_AFIO_REMAP_I2C1_ENABLE(); hi2c2.Instance = I2C1; hi2c2.Init.ClockSpeed = 100000; hi2c2.Init.DutyCycle = I2C_DUTYCYCLE_2; hi2c2.Init.OwnAddress1 = 0; hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; hi2c2.Init.OwnAddress2 = 0; hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; HAL_I2C_Init(&hi2c2); I2Cdev_hi2c = &hi2c2; // init of i2cdevlib. // You can select other i2c device anytime and // call the same driver functions on other sensors while(!BMP085_testConnection()) ; BMP085_initialize(); }
void i2c_init(I2C_HandleTypeDef *i2c) { int i2c_unit; const pin_obj_t *scl_pin; const pin_obj_t *sda_pin; if (0) { #if defined(MICROPY_HW_I2C1_SCL) } else if (i2c == &I2CHandle1) { i2c_unit = 1; scl_pin = &MICROPY_HW_I2C1_SCL; sda_pin = &MICROPY_HW_I2C1_SDA; __I2C1_CLK_ENABLE(); #endif #if defined(MICROPY_HW_I2C2_SCL) } else if (i2c == &I2CHandle2) { i2c_unit = 2; scl_pin = &MICROPY_HW_I2C2_SCL; sda_pin = &MICROPY_HW_I2C2_SDA; __I2C2_CLK_ENABLE(); #endif #if defined(MICROPY_HW_I2C3_SCL) } else if (i2c == &I2CHandle3) { i2c_unit = 3; scl_pin = &MICROPY_HW_I2C3_SCL; sda_pin = &MICROPY_HW_I2C3_SDA; __I2C3_CLK_ENABLE(); #endif #if defined(MICROPY_HW_I2C4_SCL) } else if (i2c == &I2CHandle4) { i2c_unit = 4; scl_pin = &MICROPY_HW_I2C4_SCL; sda_pin = &MICROPY_HW_I2C4_SDA; __I2C3_CLK_ENABLE(); #endif } else { // I2C does not exist for this board (shouldn't get here, should be checked by caller) return; } // init the GPIO lines uint32_t mode = MP_HAL_PIN_MODE_ALT_OPEN_DRAIN; uint32_t pull = MP_HAL_PIN_PULL_NONE; // have external pull-up resistors on both lines mp_hal_pin_config_alt(scl_pin, mode, pull, AF_FN_I2C, i2c_unit); mp_hal_pin_config_alt(sda_pin, mode, pull, AF_FN_I2C, i2c_unit); // init the I2C device if (HAL_I2C_Init(i2c) != HAL_OK) { // init error // TODO should raise an exception, but this function is not necessarily going to be // called via Python, so may not be properly wrapped in an NLR handler printf("OSError: HAL_I2C_Init failed\n"); return; } // invalidate the DMA channels so they are initialised on first use const pyb_i2c_obj_t *self = &pyb_i2c_obj[i2c_unit - 1]; dma_invalidate_channel(self->tx_dma_descr); dma_invalidate_channel(self->rx_dma_descr); if (0) { #if defined(MICROPY_HW_I2C1_SCL) } else if (i2c->Instance == I2C1) { HAL_NVIC_EnableIRQ(I2C1_EV_IRQn); HAL_NVIC_EnableIRQ(I2C1_ER_IRQn); #endif #if defined(MICROPY_HW_I2C2_SCL) } else if (i2c->Instance == I2C2) { HAL_NVIC_EnableIRQ(I2C2_EV_IRQn); HAL_NVIC_EnableIRQ(I2C2_ER_IRQn); #endif #if defined(MICROPY_HW_I2C3_SCL) } else if (i2c->Instance == I2C3) { HAL_NVIC_EnableIRQ(I2C3_EV_IRQn); HAL_NVIC_EnableIRQ(I2C3_ER_IRQn); #endif #if defined(MICROPY_HW_I2C4_SCL) } else if (i2c->Instance == I2C4) { HAL_NVIC_EnableIRQ(I2C4_EV_IRQn); HAL_NVIC_EnableIRQ(I2C4_ER_IRQn); #endif } }
/* (#)Initialize the I2C low level resources by implementing the HAL_I2C_MspInit() API: (##) Enable the I2Cx interface clock (##) I2C pins configuration (+++) Enable the clock for the I2C GPIOs (+++) Configure I2C pins as alternate function open-drain (##) NVIC configuration if you need to use interrupt process (+++) Configure the I2Cx interrupt priority (+++) Enable the NVIC I2C IRQ Channel (##) DMA Configuration if you need to use DMA process (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive channel (+++) Enable the DMAx interface clock using (+++) Configure the DMA handle parameters (+++) Configure the DMA Tx or Rx channel (+++) Associate the initialized DMA handle to the hi2c DMA Tx or Rx handle (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on the DMA Tx or Rx channel */ void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) { // (#)Initialize the I2C low level resources by implementing the HAL_I2C_MspInit() API: // (##) Enable the I2Cx interface clock //__HAL_I2C_ENABLE(hi2c); //necessary? __I2C1_CLK_ENABLE(); // (##) I2C pins configuration // (+++) Enable the clock for the I2C GPIOs __GPIOB_CLK_ENABLE(); // (+++) Configure I2C pins as alternate function open-drain GPIO_InitTypeDef GPIO_InitStruct = { .Pin = I2C_SCL_GPIO_PIN | I2C_SDA_GPIO_PIN, .Mode = GPIO_MODE_AF_OD, .Pull = GPIO_PULLUP, //? .Speed = GPIO_SPEED_FREQ_HIGH, //? .Alternate = GPIO_AF4_I2C1 }; HAL_GPIO_Init(I2C_GPIO_PORT, &GPIO_InitStruct); //HAL_GPIO_WritePin(GPIOC, GPIO_PIN_8, GPIO_PIN_SET); // (##) NVIC configuration if you need to use interrupt process // (+++) Configure the I2Cx interrupt priority // (+++) Enable the NVIC I2C IRQ Channel // (##) DMA Configuration if you need to use DMA process // (+++) Declare a DMA_HandleTypeDef handle structure for the transmit or receive channel // (+++) Enable the DMAx interface clock using // (+++) Configure the DMA handle parameters // (+++) Configure the DMA Tx or Rx channel // (+++) Associate the initialized DMA handle to the hi2c DMA Tx or Rx handle // (+++) Configure the priority and enable the NVIC for the transfer complete interrupt on // the DMA Tx or Rx channel } static I2C_HandleTypeDef hi2c1; static I2C_HandleTypeDef hi2c2; int I2C_init(I2C_TypeDef *I2Cx) { I2C_HandleTypeDef *hi2c; if (I2Cx == I2C1) { hi2c = &hi2c1; hi2c->Instance = I2C1; } else { return -1; // Not implemented } hi2c->Init.ClockSpeed = 400000; hi2c->Init.DutyCycle = I2C_DUTYCYCLE_2; hi2c->Init.OwnAddress1 = 0x16; hi2c->Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; hi2c->Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; hi2c->Init.OwnAddress2 = 0xFE; hi2c->Init.GeneralCallMode = I2C_GENERALCALL_DISABLE; hi2c->Init.NoStretchMode = I2C_NOSTRETCH_DISABLE; if (HAL_I2C_Init(hi2c) != HAL_OK) return -1; return 0; }
void HAL_I2C_MspInit(I2C_HandleTypeDef* hi2c) { GPIO_InitTypeDef GPIO_InitStruct; if(hi2c->Instance==I2C1) { /* USER CODE BEGIN I2C1_MspInit 0 */ /* USER CODE END I2C1_MspInit 0 */ /**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_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C1_CLK_ENABLE(); /* Peripheral DMA init*/ hdma_i2c1_rx.Instance = DMA1_Stream5; hdma_i2c1_rx.Init.Channel = DMA_CHANNEL_1; hdma_i2c1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_i2c1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c1_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c1_rx.Init.Mode = DMA_NORMAL; hdma_i2c1_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH; hdma_i2c1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_i2c1_rx); __HAL_LINKDMA(hi2c,hdmarx,hdma_i2c1_rx); hdma_i2c1_tx.Instance = DMA1_Stream6; hdma_i2c1_tx.Init.Channel = DMA_CHANNEL_1; hdma_i2c1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_i2c1_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c1_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c1_tx.Init.Mode = DMA_NORMAL; hdma_i2c1_tx.Init.Priority = DMA_PRIORITY_LOW; hdma_i2c1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_i2c1_tx); __HAL_LINKDMA(hi2c,hdmatx,hdma_i2c1_tx); /* USER CODE BEGIN I2C1_MspInit 1 */ /* USER CODE END I2C1_MspInit 1 */ } else if(hi2c->Instance==I2C3) { /* USER CODE BEGIN I2C3_MspInit 0 */ /* USER CODE END I2C3_MspInit 0 */ /**I2C3 GPIO Configuration PC9 ------> I2C3_SDA PA8 ------> I2C3_SCL */ GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C3; HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_8; GPIO_InitStruct.Mode = GPIO_MODE_AF_OD; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Alternate = GPIO_AF4_I2C3; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Peripheral clock enable */ __I2C3_CLK_ENABLE(); /* Peripheral DMA init*/ hdma_i2c3_tx.Instance = DMA1_Stream4; hdma_i2c3_tx.Init.Channel = DMA_CHANNEL_3; hdma_i2c3_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_i2c3_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c3_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c3_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c3_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c3_tx.Init.Mode = DMA_NORMAL; hdma_i2c3_tx.Init.Priority = DMA_PRIORITY_MEDIUM; hdma_i2c3_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_i2c3_tx); __HAL_LINKDMA(hi2c,hdmatx,hdma_i2c3_tx); hdma_i2c3_rx.Instance = DMA1_Stream2; hdma_i2c3_rx.Init.Channel = DMA_CHANNEL_3; hdma_i2c3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_i2c3_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_i2c3_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_i2c3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_i2c3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_i2c3_rx.Init.Mode = DMA_NORMAL; hdma_i2c3_rx.Init.Priority = DMA_PRIORITY_MEDIUM; hdma_i2c3_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; HAL_DMA_Init(&hdma_i2c3_rx); __HAL_LINKDMA(hi2c,hdmarx,hdma_i2c3_rx); /* USER CODE BEGIN I2C3_MspInit 1 */ /* USER CODE END I2C3_MspInit 1 */ } }
void cHAL::Init(void) { __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_CAN2_CLK_ENABLE(); __HAL_RCC_CAN1_CLK_ENABLE(); __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_UART4_CLK_ENABLE(); GPIO_InitTypeDef gi; HAL_StatusTypeDef status; //Enable UART gi.Pin = GPIO_PIN_10 | GPIO_PIN_11; //C10=TX, C11=RX gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_LOW; gi.Alternate = GPIO_AF7_USART3; HAL_GPIO_Init(GPIOC, &gi); InitAndTestUSART(); //Onboard LEDs gi.Mode = GPIO_MODE_OUTPUT_PP; gi.Alternate = 0; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_LOW; gi.Pin = GPIO_PIN_7; HAL_GPIO_Init(GPIOB, &gi); LOGI(BSP::SUCCESSFUL_STRING, "GPIO for LED"); if(InitDWTCounter()) { LOGI(BSP::SUCCESSFUL_STRING, "DWTCounter"); } else { LOGE(NOT_SUCCESSFUL_STRING, "DWTCounter"); } //MP3-Player gi.Pin = GPIO_PIN_0 | GPIO_PIN_1; //A0=USART4_TX, A1=USART4_RX, Kerbe nach oben; ansicht von Pinseite, rechts von oben //VCC, RX, TX, DACR, DACL, SPK1, GND, SPK2 //Also: PA0 --> RX gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_LOW; gi.Alternate = GPIO_AF8_UART4; HAL_GPIO_Init(GPIOA, &gi); BELL.Instance = UART4; BELL.Init.BaudRate = 9600; BELL.Init.WordLength = UART_WORDLENGTH_8B; BELL.Init.StopBits = UART_STOPBITS_1; BELL.Init.Parity = UART_PARITY_NONE; BELL.Init.Mode = UART_MODE_TX_RX; BELL.Init.HwFlowCtl = UART_HWCONTROL_NONE; BELL.Init.OverSampling = UART_OVERSAMPLING_16; HAL_UART_Init(&BSP::BELL); LOGI(SUCCESSFUL_STRING, "UART4 for MP3-Module"); __I2C1_CLK_ENABLE(); __I2C2_CLK_ENABLE(); /* PB08 ------> I2C1_SCL PB09 ------> I2C1_SDA */ gi.Pin = GPIO_PIN_8 | GPIO_PIN_9; gi.Mode = GPIO_MODE_AF_OD; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_MEDIUM; gi.Alternate = GPIO_AF4_I2C1; HAL_GPIO_Init(GPIOB, &gi); /* PB10 ------> I2C2_SCL PB11 ------> I2C2_SDA */ gi.Pin = GPIO_PIN_10 | GPIO_PIN_11; gi.Mode = GPIO_MODE_AF_OD; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_MEDIUM; gi.Alternate = GPIO_AF4_I2C2; HAL_GPIO_Init(GPIOB, &gi); i2cbus[0].Instance = I2C1; i2cbus[0].Init.ClockSpeed = 100000; i2cbus[0].Init.DutyCycle = I2C_DUTYCYCLE_2; i2cbus[0].Init.OwnAddress1 = 0; i2cbus[0].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; i2cbus[0].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; i2cbus[0].Init.OwnAddress2 = 0; i2cbus[0].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; i2cbus[0].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; HAL_I2C_Init(&i2cbus[0]); LOGI("I2C1 configured for onboard digital io"); i2cbus[1].Instance = I2C2; i2cbus[1].Init.ClockSpeed = 100000; i2cbus[1].Init.DutyCycle = I2C_DUTYCYCLE_2; i2cbus[1].Init.OwnAddress1 = 0; i2cbus[1].Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; i2cbus[1].Init.DualAddressMode = I2C_DUALADDRESS_DISABLED; i2cbus[1].Init.OwnAddress2 = 0; i2cbus[1].Init.GeneralCallMode = I2C_GENERALCALL_DISABLED; i2cbus[1].Init.NoStretchMode = I2C_NOSTRETCH_DISABLED; HAL_I2C_Init(&BSP::i2c2); LOGI(BSP::SUCCESSFUL_STRING, "I2C2 for 1wire and external"); if(drivers::cPCA9685::SoftwareReset(&BSP::i2c1)) { LOGI(SUCCESSFUL_STRING, "i2c1 reset"); } else { LOGE(NOT_SUCCESSFUL_STRING, "i2c1 reset"); } if(pca9685_U7.Setup())//next to CPU, all A-Pins @ GND b01 { LOGI(SUCCESSFUL_STRING, "pca9685_U7"); } else { LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U7"); } if(pca9685_U9.Setup()) { LOGI(SUCCESSFUL_STRING, "pca9685_U9"); } else { LOGE(NOT_SUCCESSFUL_STRING, "pca9685_U9"); } //Interrupt-Pins for PCA9555 gi.Pin = GPIO_PIN_0|GPIO_PIN_1; gi.Mode = GPIO_MODE_INPUT; gi.Pull = GPIO_PULLUP; HAL_GPIO_Init(GPIOC, &gi); if(pca9555_U19.Setup()) { LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U19"); } else { LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U19"); } if(pca9555_U18.Setup()) { LOGI(BSP::SUCCESSFUL_STRING, "pca9555_U18"); } else { LOGE(BSP::NOT_SUCCESSFUL_STRING, "pca9555_U18"); } uint16_t tmp = pca9555_U18.GetInput(); inputState[WORD_I2C] = (inputState[WORD_I2C] & 0xFFFF0000) + tmp; tmp = pca9555_U19.GetInput(); inputState[WORD_I2C] = (inputState[WORD_I2C] & 0x0000FFFF) + (tmp << 16); rcSwitch.enableReceive(); if(drivers::cPCA9685::SoftwareReset(&BSP::i2c2)) { LOGI(SUCCESSFUL_STRING, "i2c2 reset"); } else { LOGE(NOT_SUCCESSFUL_STRING, "i2c2 reset"); } SearchI2C("I2C2", &i2c2); Init1wire(); //Enable Rotary Encoder Switch Input gi.Mode = GPIO_MODE_INPUT; gi.Alternate = 0; gi.Pull = GPIO_PULLUP; gi.Speed = GPIO_SPEED_LOW; gi.Pin = GPIO_PIN_13; HAL_GPIO_Init(GPIOC, &gi); LOGI(SUCCESSFUL_STRING, "GPIO for Rotary Encoder"); #ifdef DCF77 //DCF77 gi.Mode = GPIO_MODE_INPUT; gi.Alternate=0; gi.Pull=GPIO_PULLUP; gi.Speed=GPIO_SPEED_FREQ_LOW; gi.Pin=DCF77_PIN; HAL_GPIO_Init(DCF77_PORT, &gi); #endif #endif //=====PWM-Timers //=============== //Overall GPIO-Settings //All gpios enabled! gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_HIGH; //Overall base timer settings TIM_HandleTypeDef TimHandle; TimHandle.Init.Prescaler = 0; TimHandle.Init.Period = UINT16_MAX; TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP; //Overall OC-settings TIM_OC_InitTypeDef sConfig; sConfig.OCMode = TIM_OCMODE_PWM1; sConfig.OCPolarity = TIM_OCPOLARITY_HIGH; sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH; sConfig.OCFastMode = TIM_OCFAST_DISABLE; sConfig.OCIdleState = TIM_OCIDLESTATE_RESET; sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET; sConfig.Pulse = 0; //===Slow Timers (84MHz) TIM4 and TIM12 //TIM1, TIM8 SystemCoreClock/1 //Others SystemCoreClock/2 //Prescaler (uint16_t) ((SystemCoreClock / 1 bzw 2) / TimerTickFrq) - 1; //Einstellungen führen zu PWM-Frequenz von 116,5Hz (rechnerisch ermittelt, per LogicAnalyzer bestätigt) #ifdef SENSACTHS07 TimHandle.Init.Prescaler = 10; //for 84MHz-Timers __TIM12_CLK_ENABLE() ; gi.Pin = GPIO_PIN_14 | GPIO_PIN_15; gi.Alternate = GPIO_AF9_TIM12; HAL_GPIO_Init(GPIOB, &gi); TimHandle.Instance = TIM12; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O1.1 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O1.2 CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC1PE); CLEAR_BIT(TIM12->CCMR1, TIM_CCMR1_OC2PE); LOGI(BSP::SUCCESSFUL_STRING, "TIM12"); //===Fast Timers (168MHz) TIM1 and TIM8 TimHandle.Init.Prescaler = 20; __TIM8_CLK_ENABLE() ; gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9; gi.Alternate = GPIO_AF3_TIM8; HAL_GPIO_Init(GPIOC, &gi); TimHandle.Instance = TIM8; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //C6 O1.3 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //C7 O1.4 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //C9 O1.5 CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC1PE); CLEAR_BIT(TIM8->CCMR1, TIM_CCMR1_OC2PE); CLEAR_BIT(TIM8->CCMR2, TIM_CCMR2_OC4PE); LOGI(SUCCESSFUL_STRING, "TIM8"); __TIM1_CLK_ENABLE() ; gi.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10; gi.Alternate = GPIO_AF1_TIM1; HAL_GPIO_Init(GPIOA, &gi); TimHandle.Instance = TIM1; TIM_ClockConfigTypeDef sClockSourceConfig; TIM_MasterConfigTypeDef sMasterConfig; TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig; HAL_TIM_Base_Init(&TimHandle); sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; HAL_TIM_ConfigClockSource(&TimHandle, &sClockSourceConfig); HAL_TIM_PWM_Init(&TimHandle); sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET; sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE; HAL_TIMEx_MasterConfigSynchronization(&TimHandle, &sMasterConfig); sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE; sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE; sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF; sBreakDeadTimeConfig.DeadTime = 0; sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE; sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH; sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE; HAL_TIMEx_ConfigBreakDeadTime(&TimHandle, &sBreakDeadTimeConfig); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //A8 O1.6 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //A9 O1.7 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //A10 O1.8 CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC1PE); CLEAR_BIT(TIM1->CCMR1, TIM_CCMR1_OC2PE); CLEAR_BIT(TIM1->CCMR2, TIM_CCMR2_OC3PE); LOGI(SUCCESSFUL_STRING, "TIM1"); #endif #ifdef SENSACTHS04 TimHandle.Init.Prescaler = 10; //for 84MHz-Timers __TIM4_CLK_ENABLE(); gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9; gi.Alternate = GPIO_AF2_TIM4; HAL_GPIO_Init(GPIOB, &gi); TimHandle.Instance = TIM4; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB6 o2.1 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); //PB7 o2.2 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); //PB8 o1.1 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); //PB9 o1.2 TIM4->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM4->CCMR1 &= ~TIM_CCMR1_OC2PE; TIM4->CCMR2 &= ~TIM_CCMR2_OC3PE; TIM4->CCMR2 &= ~TIM_CCMR2_OC4PE; LOGI(SUCCESSFUL_STRING, "TIM4"); __TIM12_CLK_ENABLE(); gi.Pin = GPIO_PIN_14 | GPIO_PIN_15; gi.Alternate = GPIO_AF9_TIM12; HAL_GPIO_Init(GPIOB, &gi); TimHandle.Instance = TIM12; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); //PB14 O7.2 HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); ///PB15 O4.1 TIM12->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM12->CCMR1 &= ~TIM_CCMR1_OC2PE; LOGI(SUCCESSFUL_STRING, "TIM12"); //===Fast Timers (168MHz) TIM1 and TIM8 TimHandle.Init.Prescaler = 20; __TIM1_CLK_ENABLE(); gi.Pin = GPIO_PIN_8; gi.Alternate = GPIO_AF1_TIM1; HAL_GPIO_Init(GPIOA, &gi); TimHandle.Instance = TIM1; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3); TIM1->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM1->CCMR2 &= ~TIM_CCMR2_OC3PE; LOGI(SUCCESSFUL_STRING, "TIM1"); __TIM8_CLK_ENABLE(); gi.Pin = GPIO_PIN_6 | GPIO_PIN_7 | GPIO_PIN_9; gi.Alternate = GPIO_AF3_TIM8; HAL_GPIO_Init(GPIOC, &gi); TimHandle.Instance = TIM8; HAL_TIM_PWM_Init(&TimHandle); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2); HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4); TIM8->CCMR1 &= ~TIM_CCMR1_OC1PE; TIM8->CCMR1 &= ~TIM_CCMR1_OC2PE; TIM8->CCMR2 &= ~TIM_CCMR2_OC4PE; LOGI(SUCCESSFUL_STRING, "TIM8"); #endif //===SPI for Relais //PA15=LATCH,PB3=CLK PB4=MISO, PB5=MOSI //DRV8066 DIN=2, CLK(low@inak)=3, Latch@pos edge=4 __SPI3_CLK_ENABLE() ; gi.Pin = GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5; gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_HIGH; gi.Alternate = GPIO_AF6_SPI3; HAL_GPIO_Init(GPIOB, &gi); #ifdef SENSACTHS07 BSP::spi.Init.DataSize = SPI_DATASIZE_8BIT; HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET); gi.Pin = GPIO_PIN_14; gi.Mode = GPIO_MODE_OUTPUT_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_MEDIUM; HAL_GPIO_Init(GPIOC, &gi); #endif #ifdef SENSACTHS04 BSP::spi.Init.DataSize = SPI_DATASIZE_16BIT; HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET); gi.Pin = GPIO_PIN_15; gi.Mode = GPIO_MODE_OUTPUT_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_MEDIUM; HAL_GPIO_Init(GPIOA, &gi); #endif BSP::spi.Instance = SPI3; BSP::spi.Init.Mode = SPI_MODE_MASTER; BSP::spi.Init.Direction = SPI_DIRECTION_2LINES; BSP::spi.Init.CLKPolarity = SPI_POLARITY_LOW; BSP::spi.Init.CLKPhase = SPI_PHASE_1EDGE; BSP::spi.Init.NSS = SPI_NSS_SOFT; BSP::spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; BSP::spi.Init.FirstBit = SPI_FIRSTBIT_MSB; BSP::spi.Init.TIMode = SPI_TIMODE_DISABLED; BSP::spi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED; BSP::spi.Init.CRCPolynomial = 1; status = HAL_SPI_Init(&BSP::spi); if (status != HAL_OK) { LOGE("Unable to configure SPI for Relays"); while(1) {}; } uint8_t tx[] = {0, 0, 0}; #ifdef SENSACTHS07 HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_RESET); HAL_SPI_Transmit(&BSP::spi, tx, 3, 100); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET); LOGI(SUCCESSFUL_STRING, "SPI for DRV8860"); #endif #ifdef SENSACTHS04 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_RESET); if (HAL_SPI_Transmit(&BSP::spi, tx, 1, 100) == HAL_OK) { LOGI(SUCCESSFUL_STRING, "SPI for DRV8860"); } else { LOGE(NOT_SUCCESSFUL_STRING, "SPI for DRV8860"); } HAL_GPIO_WritePin(GPIOA, GPIO_PIN_15, GPIO_PIN_SET); #endif /**CAN2 GPIO Configuration PB12 ------> CAN2_RX PB13 ------> CAN2_TX */ gi.Pin = GPIO_PIN_12 | GPIO_PIN_13; gi.Mode = GPIO_MODE_AF_PP; gi.Pull = GPIO_NOPULL; gi.Speed = GPIO_SPEED_LOW; gi.Alternate = GPIO_AF9_CAN2; HAL_GPIO_Init(GPIOB, &gi); InitCAN(); return; }