void can_init(can_t *obj, PinName rd, PinName td)
{
CANName can_rd = (CANName)pinmap_peripheral(rd, PinMap_CAN_RD);
CANName can_td = (CANName)pinmap_peripheral(td, PinMap_CAN_TD);
obj->can = (CANName)pinmap_merge(can_rd, can_td);
MBED_ASSERT((int)obj->can != NC);
if (obj->can == CAN_1) {
__HAL_RCC_CAN1_CLK_ENABLE();
obj->index = 0;
}
#if defined(CAN2_BASE) && (CAN_NUM == 2)
else if (obj->can == CAN_2) {
__HAL_RCC_CAN1_CLK_ENABLE(); // needed to set filters
__HAL_RCC_CAN2_CLK_ENABLE();
obj->index = 1;
}
#endif
else {
return;
}
// Configure the CAN pins
pinmap_pinout(rd, PinMap_CAN_RD);
pinmap_pinout(td, PinMap_CAN_TD);
if (rd != NC) {
pin_mode(rd, PullUp);
}
if (td != NC) {
pin_mode(td, PullUp);
}
CanHandle.Instance = (CAN_TypeDef *)(obj->can);
CanHandle.Init.TTCM = DISABLE;
CanHandle.Init.ABOM = DISABLE;
CanHandle.Init.AWUM = DISABLE;
CanHandle.Init.NART = DISABLE;
CanHandle.Init.RFLM = DISABLE;
CanHandle.Init.TXFP = DISABLE;
CanHandle.Init.Mode = CAN_MODE_NORMAL;
CanHandle.Init.SJW = CAN_SJW_1TQ;
CanHandle.Init.BS1 = CAN_BS1_6TQ;
CanHandle.Init.BS2 = CAN_BS2_8TQ;
CanHandle.Init.Prescaler = 2;
if (HAL_CAN_Init(&CanHandle) != HAL_OK) {
error("Cannot initialize CAN");
}
// Set initial CAN frequency to 100 kb/s
can_frequency(obj, 100000);
uint32_t filter_number = (obj->can == CAN_1) ? 0 : 14;
can_filter(obj, 0, 0, CANStandard, filter_number);
}
void HAL_CAN_MspInit(CAN_HandleTypeDef* hcan) {
(void)hcan;
__HAL_RCC_CAN1_CLK_ENABLE(); // Must always enable CAN1 clk even if we only use CAN2
{
__HAL_RCC_CAN1_CLK_ENABLE();
__HAL_RCC_CAN2_CLK_ENABLE();
}
CANx_CLK_ENABLE();
CANx_GPIO_CLK_ENABLE();
HAL_GPIO_Init(CANx_TX_GPIO_PORT, &(GPIO_InitTypeDef){
.Pin = CANx_TX_PIN,
.Mode = GPIO_MODE_AF_PP,
.Speed = GPIO_SPEED_FAST,
.Pull = GPIO_NOPULL, //GPIO_PULLUP,
.Alternate = CANx_TX_AF,
});
void can_init_freq (can_t *obj, PinName rd, PinName td, int hz)
{
CANName can_rd = (CANName)pinmap_peripheral(rd, PinMap_CAN_RD);
CANName can_td = (CANName)pinmap_peripheral(td, PinMap_CAN_TD);
CANName can = (CANName)pinmap_merge(can_rd, can_td);
MBED_ASSERT((int)can != NC);
if (can == CAN_1) {
__HAL_RCC_CAN1_CLK_ENABLE();
obj->index = 0;
}
#if defined(CAN2_BASE) && (CAN_NUM > 1)
else if (can == CAN_2) {
__HAL_RCC_CAN1_CLK_ENABLE(); // needed to set filters
__HAL_RCC_CAN2_CLK_ENABLE();
obj->index = 1;
}
#endif
#if defined(CAN3_BASE) && (CAN_NUM > 2)
else if (can == CAN_3) {
__HAL_RCC_CAN3_CLK_ENABLE();
obj->index = 2;
}
#endif
else {
return;
}
// Configure the CAN pins
pinmap_pinout(rd, PinMap_CAN_RD);
pinmap_pinout(td, PinMap_CAN_TD);
if (rd != NC) {
pin_mode(rd, PullUp);
}
if (td != NC) {
pin_mode(td, PullUp);
}
/* Use default values for rist init */
obj->CanHandle.Instance = (CAN_TypeDef *)can;
obj->CanHandle.Init.TTCM = DISABLE;
obj->CanHandle.Init.ABOM = DISABLE;
obj->CanHandle.Init.AWUM = DISABLE;
obj->CanHandle.Init.NART = DISABLE;
obj->CanHandle.Init.RFLM = DISABLE;
obj->CanHandle.Init.TXFP = DISABLE;
obj->CanHandle.Init.Mode = CAN_MODE_NORMAL;
obj->CanHandle.Init.SJW = CAN_SJW_1TQ;
obj->CanHandle.Init.BS1 = CAN_BS1_6TQ;
obj->CanHandle.Init.BS2 = CAN_BS2_8TQ;
obj->CanHandle.Init.Prescaler = 2;
/* Store frequency to be restored in case of reset */
obj->hz = hz;
can_registers_init(obj);
/* Bits 27:14 are available for dual CAN configuration and are reserved for
single CAN configuration: */
#if defined(CAN3_BASE) && (CAN_NUM > 2)
uint32_t filter_number = (can == CAN_1 || can == CAN_3) ? 0 : 14;
#else
uint32_t filter_number = (can == CAN_1) ? 0 : 14;
#endif
can_filter(obj, 0, 0, CANStandard, filter_number);
}
void HAL_CAN_MspInit(CAN_HandleTypeDef* hcan)
{
GPIO_InitTypeDef GPIO_InitStruct;
if(hcan->Instance==CAN1)
{
/* USER CODE BEGIN CAN1_MspInit 0 */
/* USER CODE END CAN1_MspInit 0 */
/* Peripheral clock enable */
HAL_RCC_CAN1_CLK_ENABLED++;
if(HAL_RCC_CAN1_CLK_ENABLED==1){
__HAL_RCC_CAN1_CLK_ENABLE();
}
/**CAN1 GPIO Configuration
PB8 ------> CAN1_RX
PB9 ------> CAN1_TX
*/
GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* Peripheral interrupt init */
HAL_NVIC_SetPriority(CAN1_TX_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(CAN1_TX_IRQn);
HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);
HAL_NVIC_SetPriority(CAN1_RX1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(CAN1_RX1_IRQn);
/* USER CODE BEGIN CAN1_MspInit 1 */
/* USER CODE END CAN1_MspInit 1 */
}
else if(hcan->Instance==CAN2)
{
/* USER CODE BEGIN CAN2_MspInit 0 */
/* USER CODE END CAN2_MspInit 0 */
/* Peripheral clock enable */
__HAL_RCC_CAN2_CLK_ENABLE();
HAL_RCC_CAN1_CLK_ENABLED++;
if(HAL_RCC_CAN1_CLK_ENABLED==1){
__HAL_RCC_CAN1_CLK_ENABLE();
}
/**CAN2 GPIO Configuration
PB5 ------> CAN2_RX
PB6 ------> CAN2_TX
*/
GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF9_CAN2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/* USER CODE BEGIN CAN2_MspInit 1 */
/* USER CODE END CAN2_MspInit 1 */
}
}
void enableGPIOPowerUsageAndNoiseReductions(void)
{
// AHB1
__HAL_RCC_BKPSRAM_CLK_ENABLE();
__HAL_RCC_DTCMRAMEN_CLK_ENABLE();
__HAL_RCC_DMA2_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_CLK_ENABLE();
__HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOF_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__HAL_RCC_GPIOI_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_DMA2D_CLK_ENABLE();
__HAL_RCC_GPIOJ_CLK_ENABLE();
__HAL_RCC_GPIOK_CLK_ENABLE();
#endif
//APB1
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_TIM3_CLK_ENABLE();
__HAL_RCC_TIM4_CLK_ENABLE();
__HAL_RCC_TIM5_CLK_ENABLE();
__HAL_RCC_TIM6_CLK_ENABLE();
__HAL_RCC_TIM7_CLK_ENABLE();
__HAL_RCC_TIM12_CLK_ENABLE();
__HAL_RCC_TIM13_CLK_ENABLE();
__HAL_RCC_TIM14_CLK_ENABLE();
__HAL_RCC_LPTIM1_CLK_ENABLE();
__HAL_RCC_SPI2_CLK_ENABLE();
__HAL_RCC_SPI3_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_UART4_CLK_ENABLE();
__HAL_RCC_UART5_CLK_ENABLE();
__HAL_RCC_I2C1_CLK_ENABLE();
__HAL_RCC_I2C2_CLK_ENABLE();
__HAL_RCC_I2C3_CLK_ENABLE();
__HAL_RCC_CAN1_CLK_ENABLE();
__HAL_RCC_DAC_CLK_ENABLE();
__HAL_RCC_UART7_CLK_ENABLE();
__HAL_RCC_UART8_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_I2C4_CLK_ENABLE();
__HAL_RCC_CAN2_CLK_ENABLE();
__HAL_RCC_CEC_CLK_ENABLE();
#endif
//APB2
__HAL_RCC_TIM1_CLK_ENABLE();
__HAL_RCC_TIM8_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_ADC1_CLK_ENABLE();
__HAL_RCC_ADC2_CLK_ENABLE();
__HAL_RCC_ADC3_CLK_ENABLE();
__HAL_RCC_SDMMC1_CLK_ENABLE();
__HAL_RCC_SPI1_CLK_ENABLE();
__HAL_RCC_SPI4_CLK_ENABLE();
__HAL_RCC_TIM9_CLK_ENABLE();
__HAL_RCC_TIM10_CLK_ENABLE();
__HAL_RCC_TIM11_CLK_ENABLE();
__HAL_RCC_SPI5_CLK_ENABLE();
__HAL_RCC_SAI1_CLK_ENABLE();
__HAL_RCC_SAI2_CLK_ENABLE();
#ifndef STM32F722xx
__HAL_RCC_SPI6_CLK_ENABLE();
#endif
//
// GPIO_InitTypeDef GPIO_InitStructure;
// GPIO_StructInit(&GPIO_InitStructure);
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; // default is un-pulled input
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_11 | GPIO_Pin_12); // leave USB D+/D- alone
//
// GPIO_InitStructure.GPIO_Pin &= ~(GPIO_Pin_13 | GPIO_Pin_14); // leave JTAG pins alone
// GPIO_Init(GPIOA, &GPIO_InitStructure);
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_Init(GPIOB, &GPIO_InitStructure);
//
// GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
// GPIO_Init(GPIOC, &GPIO_InitStructure);
// GPIO_Init(GPIOD, &GPIO_InitStructure);
// GPIO_Init(GPIOE, &GPIO_InitStructure);
}
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;
}
