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 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==I2C2)
{
/* USER CODE BEGIN I2C2_MspInit 0 */
/* USER CODE END I2C2_MspInit 0 */
/**I2C2 GPIO Configuration
PF0 ------> I2C2_SDA
PF1 ------> I2C2_SCL
*/
GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
/* Peripheral clock enable */
__I2C2_CLK_ENABLE();
/* USER CODE BEGIN I2C2_MspInit 1 */
/* USER CODE END I2C2_MspInit 1 */
}
}
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
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();
/* 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
PA9 ------> I2C2_SCL
PA10 ------> I2C2_SDA
*/
GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Peripheral clock enable */
__I2C2_CLK_ENABLE();
/* Peripheral interrupt init*/
HAL_NVIC_SetPriority(I2C2_EV_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(I2C2_EV_IRQn);
HAL_NVIC_SetPriority(I2C2_ER_IRQn, 5, 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_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 */
}
}
/**
* @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 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
}
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;
}
}
/*******************************************************************************
* @brief : Initialise et configure le port materiel de l'I2C #2.
* @param : Aucun.
* @return : Rien.
******************************************************************************/
void LBF_I2C2_IOcfg (void)
{
//Based on Cube MX
GPIO_InitTypeDef GPIO_InitStruct;
/* Peripheral clock enable */
__I2C2_CLK_ENABLE();
/**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.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct) ;
}
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
}
}
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;
}
