uint8_t uart4_init(void) { //zmienna do zwracania statusu funkcji uint8_t uart_status; //inicjalizacja struktur od GPIO i USART GPIO_InitTypeDef GPIO_InitStruct; uart_status = UART_INIT_ERROR; /* Enable GPIO clock */ __HAL_RCC_GPIOA_CLK_ENABLE(); // Enable clock for UART4 peripheral __HAL_RCC_UART4_CLK_ENABLE(); /* Configure USART Tx as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_0; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = GPIO_AF8_UART4; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Configure USART Rx as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_1; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = GPIO_AF8_UART4; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); NVIC_SetPriority(UART4_IRQn, 1); NVIC_EnableIRQ(UART4_IRQn); //Handle UART4_HandleStruct.Instance = UART4; UART4_HandleStruct.Init.BaudRate = 115200; UART4_HandleStruct.Init.StopBits = UART_STOPBITS_1; UART4_HandleStruct.Init.WordLength = UART_WORDLENGTH_8B; UART4_HandleStruct.Init.Parity = UART_PARITY_NONE; UART4_HandleStruct.Init.Mode = UART_MODE_TX_RX; //Init uart_status = HAL_UART_Init(&UART4_HandleStruct); //UART4 enable __HAL_UART_ENABLE(&UART4_HandleStruct); //Wlaczenie przerwan od RX dla UART4 #ifdef UART4_IT_RX_ON UART4 -> CR1 |= USART_CR1_RXNEIE; #endif return uart_status; }
uint8_t usart2_init(void) { //zmienna do zwracania statusu funkcji uint8_t usart_status; //inicjalizacja struktur od GPIO GPIO_InitTypeDef GPIO_InitStruct; usart_status = UART_INIT_ERROR; /* Enable GPIO clock */ __HAL_RCC_GPIOA_CLK_ENABLE(); // Enable clock for USART1 peripheral __HAL_RCC_USART2_CLK_ENABLE(); /* Configure USART Tx as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* Configure USART Rx as alternate function */ GPIO_InitStruct.Pin = GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_FAST; GPIO_InitStruct.Alternate = GPIO_AF7_USART2; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); //Priorytet przerwania // HAL_NVIC_SetPriority(USART2_IRQn , 0 , 1); // HAL_NVIC_EnableIRQ(USART2_IRQn); //Handle USART2_HandleStruct.Instance = USART2; USART2_HandleStruct.Init.BaudRate = BAUDRATE_USART2; USART2_HandleStruct.Init.StopBits = USART_STOPBITS_1; USART2_HandleStruct.Init.Parity = USART_PARITY_NONE; USART2_HandleStruct.Init.Mode = USART_MODE_TX_RX; //Init usart_status = HAL_UART_Init(&USART2_HandleStruct); //USART2 enable __HAL_UART_ENABLE(&USART2_HandleStruct); //Przerwania od RX ON #ifdef USART2_IT_RX_ON // USART2 -> CR1 |= USART_CR1_RXNEIE; #endif return usart_status; }
/** * @brief Initializes the RS485 Driver enable feature according to the specified * parameters in the UART_InitTypeDef and creates the associated handle . * @param huart: uart handle * @param Polarity: select the driver enable polarity * This parameter can be one of the following values: * @arg UART_DE_POLARITY_HIGH: DE signal is active high * @arg UART_DE_POLARITY_LOW: DE signal is active low * @param AssertionTime: Driver Enable assertion time * 5-bit value defining the time between the activation of the DE (Driver Enable) * signal and the beginning of the start bit. It is expressed in sample time * units (1/8 or 1/16 bit time, depending on the oversampling rate) * @param DeassertionTime: Driver Enable deassertion time * 5-bit value defining the time between the end of the last stop bit, in a * transmitted message, and the de-activation of the DE (Driver Enable) signal. * It is expressed in sample time units (1/8 or 1/16 bit time, depending on the * oversampling rate). * @retval HAL status */ HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime) { uint32_t temp = 0x0; /* Check the UART handle allocation */ if(huart == NULL) { return HAL_ERROR; } /* Check the Driver Enable polarity */ assert_param(IS_UART_DE_POLARITY(Polarity)); /* Check the Driver Enable assertion time */ assert_param(IS_UART_ASSERTIONTIME(AssertionTime)); /* Check the Driver Enable deassertion time */ assert_param(IS_UART_DEASSERTIONTIME(DeassertionTime)); if(huart->State == HAL_UART_STATE_RESET) { /* Init the low level hardware : GPIO, CLOCK, CORTEX */ HAL_UART_MspInit(huart); } huart->State = HAL_UART_STATE_BUSY; /* Disable the Peripheral */ __HAL_UART_DISABLE(huart); /* Set the UART Communication parameters */ UART_SetConfig(huart); if(huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT) { UART_AdvFeatureConfig(huart); } /* Enable the Driver Enable mode by setting the DEM bit in the CR3 register */ huart->Instance->CR3 |= USART_CR3_DEM; /* Set the Driver Enable polarity */ MODIFY_REG(huart->Instance->CR3, USART_CR3_DEP, Polarity); /* Set the Driver Enable assertion and deassertion times */ temp = (AssertionTime << UART_CR1_DEAT_ADDRESS_LSB_POS); temp |= (DeassertionTime << UART_CR1_DEDT_ADDRESS_LSB_POS); MODIFY_REG(huart->Instance->CR1, (USART_CR1_DEDT|USART_CR1_DEAT), temp); /* Enable the Peripheral */ __HAL_UART_ENABLE(huart); /* TEACK and/or REACK to check before moving huart->State to Ready */ return (UART_CheckIdleState(huart)); }
void Uart::Active(FunctionalState newState) { if(ENABLE == newState) { __HAL_UART_ENABLE(&m_huart); } else { __HAL_UART_DISABLE(&m_huart); } }
/** * @brief Initializes the LIN mode according to the specified * parameters in the UART_InitTypeDef and creates the associated handle . * @param huart: uart handle * @param BreakDetectLength: specifies the LIN break detection length. * This parameter can be one of the following values: * @arg UART_LINBREAKDETECTLENGTH_10B: 10-bit break detection * @arg UART_LINBREAKDETECTLENGTH_11B: 11-bit break detection * @retval HAL status */ HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint16_t BreakDetectLength) { /* Check the UART handle allocation */ if(huart == NULL) { return HAL_ERROR; } /* Check the Break detection length parameter */ assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength)); /* LIN mode limited to 16-bit oversampling only */ if(huart->Init.OverSampling == UART_OVERSAMPLING_8) { return HAL_ERROR; } /* Init the low level hardware : GPIO, CLOCK, CORTEX */ HAL_UART_MspInit(huart); /* Disable the Peripheral */ __HAL_UART_DISABLE(huart); /* Set the UART Communication parameters */ if (UART_SetConfig(huart) == HAL_ERROR) { return HAL_ERROR; } if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT) { UART_AdvFeatureConfig(huart); } /* In LIN mode, the following bits must be kept cleared: - LINEN and CLKEN bits in the USART_CR2 register, - SCEN and IREN bits in the USART_CR3 register.*/ huart->Instance->CR2 &= ~(USART_CR2_CLKEN); huart->Instance->CR3 &= ~(USART_CR3_HDSEL | USART_CR3_IREN | USART_CR3_SCEN); /* Enable the LIN mode by setting the LINEN bit in the CR2 register */ huart->Instance->CR2 |= USART_CR2_LINEN; /* Set the USART LIN Break detection length. */ MODIFY_REG(huart->Instance->CR2, USART_CR2_LBDL, BreakDetectLength); /* Enable the Peripheral */ __HAL_UART_ENABLE(huart); /* TEACK and/or REACK to check before moving huart->State to Ready */ return (UART_CheckIdleState(huart)); }
/** @brief: init state flag acc to info in huart * @details: used in Uart3Debug_Init, private ****************************************************************/ static HAL_StatusTypeDef MyHAL_UARTInit(UART_HandleTypeDef * huart) { /* Check the UART handle allocation */ if (huart == NULL) { return HAL_ERROR; } /* Check the parameters */ if (huart->Init.HwFlowCtl != UART_HWCONTROL_NONE) { /* The hardware flow control is available only for USART1, USART2, USART3 and USART6 */ assert_param(IS_UART_HWFLOW_INSTANCE(huart->Instance)); assert_param(IS_UART_HARDWARE_FLOW_CONTROL(huart->Init.HwFlowCtl)); } else { assert_param(IS_UART_INSTANCE(huart->Instance)); } assert_param(IS_UART_WORD_LENGTH(huart->Init.WordLength)); assert_param(IS_UART_OVERSAMPLING(huart->Init.OverSampling)); if (huart->State == HAL_UART_STATE_RESET) { /* Allocate lock resource and initialize it */ huart->Lock = HAL_UNLOCKED; /* Init the low level hardware */ // HAL_NVIC_SetPriority(USART3_IRQn, 0, 0); // HAL_NVIC_EnableIRQ(USART3_IRQn); } huart->State = HAL_UART_STATE_BUSY; /* Disable the peripheral */ __HAL_UART_DISABLE(huart); /* Set the UART Communication parameters */ MyUARTSetConfig(huart); /* In asynchronous mode, the following bits must be kept cleared: * - LINEN and CLKEN bits in the USART_CR2 register, * - SCEN, HDSEL and IREN bits in the USART_CR3 register.*/ huart->Instance->CR2 &= ~(USART_CR2_LINEN | USART_CR2_CLKEN); huart->Instance->CR3 &= ~(USART_CR3_SCEN | USART_CR3_HDSEL | USART_CR3_IREN); /* Enable the peripheral */ __HAL_UART_ENABLE(huart); /* Initialize the UART state */ huart->ErrorCode = HAL_UART_ERROR_NONE; huart->State = HAL_UART_STATE_READY; return HAL_OK; } /* MyHAL_UARTInit */
/** * @brief Set Wakeup from Stop mode interrupt flag selection. * @param huart: UART handle. * @param WakeUpSelection: address match, Start Bit detection or RXNE bit status. * This parameter can be one of the following values: * @arg @ref UART_WAKEUP_ON_ADDRESS * @arg @ref UART_WAKEUP_ON_STARTBIT * @arg @ref UART_WAKEUP_ON_READDATA_NONEMPTY * @retval HAL status */ HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection) { HAL_StatusTypeDef status = HAL_OK; uint32_t tickstart = 0; /* check the wake-up from stop mode UART instance */ assert_param(IS_UART_WAKEUP_FROMSTOP_INSTANCE(huart->Instance)); /* check the wake-up selection parameter */ assert_param(IS_UART_WAKEUP_SELECTION(WakeUpSelection.WakeUpEvent)); /* Process Locked */ __HAL_LOCK(huart); huart->gState = HAL_UART_STATE_BUSY; /* Disable the Peripheral */ __HAL_UART_DISABLE(huart); /* Set the wake-up selection scheme */ MODIFY_REG(huart->Instance->CR3, USART_CR3_WUS, WakeUpSelection.WakeUpEvent); if (WakeUpSelection.WakeUpEvent == UART_WAKEUP_ON_ADDRESS) { UARTEx_Wakeup_AddressConfig(huart, WakeUpSelection); } /* Enable the Peripheral */ __HAL_UART_ENABLE(huart); /* Init tickstart for timeout managment*/ tickstart = HAL_GetTick(); /* Wait until REACK flag is set */ if(UART_WaitOnFlagUntilTimeout(huart, USART_ISR_REACK, RESET, tickstart, HAL_UART_TIMEOUT_VALUE) != HAL_OK) { status = HAL_TIMEOUT; } else { /* Initialize the UART State */ huart->gState = HAL_UART_STATE_READY; } /* Process Unlocked */ __HAL_UNLOCK(huart); return status; }
void USART_Configuration(UART_HandleTypeDef* usartHandle) { usartHandle->Instance = USART1; usartHandle->Init.BaudRate = 9600; usartHandle->Init.WordLength = UART_WORDLENGTH_8B; usartHandle->Init.StopBits = UART_STOPBITS_1; usartHandle->Init.Parity = UART_PARITY_NONE; usartHandle->Init.HwFlowCtl = UART_HWCONTROL_NONE; usartHandle->Init.Mode = UART_MODE_TX_RX; usartHandle->Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(usartHandle) != HAL_OK) { errorHandler("USART_INIT"); } __HAL_UART_ENABLE(usartHandle); }
/*====================================================================================================*/ void Serial_Config( void ) { GPIO_InitTypeDef GPIO_InitStruct; /* UART Clk ******************************************************************/ UARTx_TX_GPIO_CLK_ENABLE(); UARTx_RX_GPIO_CLK_ENABLE(); UARTx_CLK_ENABLE(); /* UART Pin ******************************************************************/ GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = GPIO_PIN_15; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_7; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = UARTx_TX_PIN; GPIO_InitStruct.Alternate = UARTx_TX_AF; HAL_GPIO_Init(UARTx_TX_GPIO_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = UARTx_RX_PIN; GPIO_InitStruct.Alternate = UARTx_RX_AF; HAL_GPIO_Init(UARTx_RX_GPIO_PORT, &GPIO_InitStruct); /* UART Init *****************************************************************/ Serial_HandleStruct.Instance = UARTx; Serial_HandleStruct.Init.BaudRate = UARTx_BAUDRATE; Serial_HandleStruct.Init.WordLength = UARTx_BYTESIZE; Serial_HandleStruct.Init.StopBits = UARTx_STOPBITS; Serial_HandleStruct.Init.Parity = UARTx_PARITY; Serial_HandleStruct.Init.HwFlowCtl = UARTx_HARDWARECTRL; Serial_HandleStruct.Init.Mode = UARTx_MODE; Serial_HandleStruct.Init.OverSampling = UARTx_OVERSAMPLE; HAL_UART_Init(&Serial_HandleStruct); /* UART Enable ***************************************************************/ __HAL_UART_ENABLE(&Serial_HandleStruct); __HAL_UART_CLEAR_FLAG(&Serial_HandleStruct, UART_FLAG_TC); }
/*====================================================================================================*/ void Serial_Config( void ) { GPIO_InitTypeDef GPIO_InitStruct; /* UART Clk ******************************************************************/ UARTx_TX_GPIO_CLK_ENABLE(); UARTx_RX_GPIO_CLK_ENABLE(); UARTx_CLK_ENABLE(); /* UART Pin ******************************************************************/ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = UARTx_TX_PIN; HAL_GPIO_Init(UARTx_TX_GPIO_PORT, &GPIO_InitStruct); GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = UARTx_RX_PIN; HAL_GPIO_Init(UARTx_RX_GPIO_PORT, &GPIO_InitStruct); /* UART IT *******************************************************************/ // HAL_NVIC_SetPriority(UARTx_IRQn, 0, 1); // HAL_NVIC_EnableIRQ(UARTx_IRQn); /* UART Init *****************************************************************/ Serial_InitStruct.Instance = UARTx; Serial_InitStruct.Init.BaudRate = UARTx_BAUDRATE; Serial_InitStruct.Init.WordLength = UARTx_BYTESIZE; Serial_InitStruct.Init.StopBits = UARTx_STOPBITS; Serial_InitStruct.Init.Parity = UARTx_PARITY; Serial_InitStruct.Init.HwFlowCtl = UARTx_HARDWARECTRL; Serial_InitStruct.Init.Mode = UARTx_MODE; HAL_UART_Init(&Serial_InitStruct); /* UART Enable ***************************************************************/ // __HAL_UART_ENABLE_IT(&Serial_InitStruct, UART_IT_RXNE); __HAL_UART_ENABLE(&Serial_InitStruct); __HAL_UART_CLEAR_FLAG(&Serial_InitStruct, UART_FLAG_TC); }
/** * @brief Set Wakeup from Stop mode interrupt flag selection * @param huart: uart handle, * @param WakeUpSelection: address match, Start Bit detection or RXNE bit status. * This parameter can be one of the following values: * @arg UART_WAKEUP_ON_ADDRESS * @arg UART_WAKEUP_ON_STARTBIT * @arg UART_WAKEUP_ON_READDATA_NONEMPTY * @retval HAL status */ HAL_StatusTypeDef HAL_UARTEx_StopModeWakeUpSourceConfig(UART_HandleTypeDef *huart, UART_WakeUpTypeDef WakeUpSelection) { /* check the wake-up from stop mode UART instance */ assert_param(IS_UART_WAKEUP_FROMSTOP_INSTANCE(huart->Instance)); /* Check the wake-up selection parameter */ assert_param(IS_UART_WAKEUP_SELECTION(WakeUpSelection.WakeUpEvent)); /* Process Locked */ __HAL_LOCK(huart); huart->State = HAL_UART_STATE_BUSY; /* Disable the Peripheral */ __HAL_UART_DISABLE(huart); /* Set the wake-up selection scheme */ MODIFY_REG(huart->Instance->CR3, USART_CR3_WUS, WakeUpSelection.WakeUpEvent); if(WakeUpSelection.WakeUpEvent == UART_WAKEUP_ON_ADDRESS) { UART_Wakeup_AddressConfig(huart, WakeUpSelection); } /* Enable the Peripheral */ __HAL_UART_ENABLE(huart); /* Wait until REACK flag is set before moving huart->State to Ready */ if(UART_WaitOnFlagUntilTimeout(huart, USART_ISR_REACK, RESET, UART_REACK_TIMEOUT) != HAL_OK) { return HAL_TIMEOUT; } /* Process Unlocked */ __HAL_UNLOCK(huart); /* Initialize the UART state*/ huart->ErrorCode = HAL_UART_ERROR_NONE; huart->State= HAL_UART_STATE_READY; return HAL_OK; }
/*====================================================================================================*/ void RS232_Config( void ) { GPIO_InitTypeDef GPIO_InitStruct; /* UARTx Clk */ UARTx_TX_GPIO_CLK_ENABLE(); UARTx_RX_GPIO_CLK_ENABLE(); UARTx_CLK_ENABLE(); /* UARTx Pin */ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_PULLUP; GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; GPIO_InitStruct.Pin = UARTx_TX_PIN; GPIO_InitStruct.Alternate = UARTx_TX_AF; HAL_GPIO_Init(UARTx_TX_GPIO_PORT, &GPIO_InitStruct); GPIO_InitStruct.Pin = UARTx_RX_PIN; GPIO_InitStruct.Alternate = UARTx_RX_AF; HAL_GPIO_Init(UARTx_RX_GPIO_PORT, &GPIO_InitStruct); /* UART Init *****************************************************************/ UART_HandleStruct.Instance = UARTx; UART_HandleStruct.Init.BaudRate = UARTx_BAUDRATE; UART_HandleStruct.Init.WordLength = UARTx_BYTESIZE; UART_HandleStruct.Init.StopBits = UARTx_STOPBITS; UART_HandleStruct.Init.Parity = UARTx_PARITY; UART_HandleStruct.Init.HwFlowCtl = UARTx_HARDWARECTRL; UART_HandleStruct.Init.Mode = UARTx_MODE; // UART_InitStruct.OverSampling = UARTx_OVERSAMPLE; HAL_UART_Init(&UART_HandleStruct); __HAL_UART_ENABLE(&UART_HandleStruct); __HAL_UART_CLEAR_FLAG(&UART_HandleStruct, UART_FLAG_TC); }
/** * @brief Initialize the LIN mode according to the specified * parameters in the UART_InitTypeDef and creates the associated handle . * @param huart UART handle. * @param BreakDetectLength specifies the LIN break detection length. * This parameter can be one of the following values: * @arg @ref UART_LINBREAKDETECTLENGTH_10B 10-bit break detection * @arg @ref UART_LINBREAKDETECTLENGTH_11B 11-bit break detection * @retval HAL status */ HAL_StatusTypeDef HAL_LIN_Init(UART_HandleTypeDef *huart, uint32_t BreakDetectLength) { /* Check the UART handle allocation */ if(huart == NULL) { return HAL_ERROR; } /* Check the LIN UART instance */ assert_param(IS_UART_LIN_INSTANCE(huart->Instance)); /* Check the Break detection length parameter */ assert_param(IS_UART_LIN_BREAK_DETECT_LENGTH(BreakDetectLength)); /* LIN mode limited to 16-bit oversampling only */ if(huart->Init.OverSampling == UART_OVERSAMPLING_8) { return HAL_ERROR; } /* LIN mode limited to 8-bit data length */ if(huart->Init.WordLength != UART_WORDLENGTH_8B) { return HAL_ERROR; } if(huart->gState == HAL_UART_STATE_RESET) { /* Allocate lock resource and initialize it */ huart->Lock = HAL_UNLOCKED; /* Init the low level hardware : GPIO, CLOCK */ HAL_UART_MspInit(huart); } huart->gState = HAL_UART_STATE_BUSY; /* Disable the Peripheral */ __HAL_UART_DISABLE(huart); /* Set the UART Communication parameters */ if (UART_SetConfig(huart) == HAL_ERROR) { return HAL_ERROR; } if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT) { UART_AdvFeatureConfig(huart); } /* In LIN mode, the following bits must be kept cleared: - LINEN and CLKEN bits in the USART_CR2 register, - SCEN and IREN bits in the USART_CR3 register.*/ CLEAR_BIT(huart->Instance->CR2, USART_CR2_CLKEN); CLEAR_BIT(huart->Instance->CR3, (USART_CR3_HDSEL | USART_CR3_IREN | USART_CR3_SCEN)); /* Enable the LIN mode by setting the LINEN bit in the CR2 register */ SET_BIT(huart->Instance->CR2, USART_CR2_LINEN); /* Set the USART LIN Break detection length. */ MODIFY_REG(huart->Instance->CR2, USART_CR2_LBDL, BreakDetectLength); /* Enable the Peripheral */ __HAL_UART_ENABLE(huart); /* TEACK and/or REACK to check before moving huart->gState and huart->RxState to Ready */ return (UART_CheckIdleState(huart)); }
/** * @brief Initialize the RS485 Driver enable feature according to the specified * parameters in the UART_InitTypeDef and creates the associated handle. * @param huart UART handle. * @param Polarity Select the driver enable polarity. * This parameter can be one of the following values: * @arg @ref UART_DE_POLARITY_HIGH DE signal is active high * @arg @ref UART_DE_POLARITY_LOW DE signal is active low * @param AssertionTime Driver Enable assertion time: * 5-bit value defining the time between the activation of the DE (Driver Enable) * signal and the beginning of the start bit. It is expressed in sample time * units (1/8 or 1/16 bit time, depending on the oversampling rate) * @param DeassertionTime Driver Enable deassertion time: * 5-bit value defining the time between the end of the last stop bit, in a * transmitted message, and the de-activation of the DE (Driver Enable) signal. * It is expressed in sample time units (1/8 or 1/16 bit time, depending on the * oversampling rate). * @retval HAL status */ HAL_StatusTypeDef HAL_RS485Ex_Init(UART_HandleTypeDef *huart, uint32_t Polarity, uint32_t AssertionTime, uint32_t DeassertionTime) { uint32_t temp; /* Check the UART handle allocation */ if (huart == NULL) { return HAL_ERROR; } /* Check the Driver Enable UART instance */ assert_param(IS_UART_DRIVER_ENABLE_INSTANCE(huart->Instance)); /* Check the Driver Enable polarity */ assert_param(IS_UART_DE_POLARITY(Polarity)); /* Check the Driver Enable assertion time */ assert_param(IS_UART_ASSERTIONTIME(AssertionTime)); /* Check the Driver Enable deassertion time */ assert_param(IS_UART_DEASSERTIONTIME(DeassertionTime)); if (huart->gState == HAL_UART_STATE_RESET) { /* Allocate lock resource and initialize it */ huart->Lock = HAL_UNLOCKED; #if (USE_HAL_UART_REGISTER_CALLBACKS == 1) UART_InitCallbacksToDefault(huart); if (huart->MspInitCallback == NULL) { huart->MspInitCallback = HAL_UART_MspInit; } /* Init the low level hardware */ huart->MspInitCallback(huart); #else /* Init the low level hardware : GPIO, CLOCK, CORTEX */ HAL_UART_MspInit(huart); #endif /* (USE_HAL_UART_REGISTER_CALLBACKS) */ } huart->gState = HAL_UART_STATE_BUSY; /* Disable the Peripheral */ __HAL_UART_DISABLE(huart); /* Set the UART Communication parameters */ if (UART_SetConfig(huart) == HAL_ERROR) { return HAL_ERROR; } if (huart->AdvancedInit.AdvFeatureInit != UART_ADVFEATURE_NO_INIT) { UART_AdvFeatureConfig(huart); } /* Enable the Driver Enable mode by setting the DEM bit in the CR3 register */ SET_BIT(huart->Instance->CR3, USART_CR3_DEM); /* Set the Driver Enable polarity */ MODIFY_REG(huart->Instance->CR3, USART_CR3_DEP, Polarity); /* Set the Driver Enable assertion and deassertion times */ temp = (AssertionTime << UART_CR1_DEAT_ADDRESS_LSB_POS); temp |= (DeassertionTime << UART_CR1_DEDT_ADDRESS_LSB_POS); MODIFY_REG(huart->Instance->CR1, (USART_CR1_DEDT | USART_CR1_DEAT), temp); /* Enable the Peripheral */ __HAL_UART_ENABLE(huart); /* TEACK and/or REACK to check before moving huart->gState and huart->RxState to Ready */ return (UART_CheckIdleState(huart)); }
//Initializes communication peripheral and buffers void xb_Init(void){ GPIO_InitTypeDef GPIO_InitStructure = {0}; DMA_HandleTypeDef hDMA_RX = {0}; //Configure GPIO pins for UART XB_PORT_ENPERCLK(); GPIO_InitStructure.Pin = XB_PIN_TX | XB_PIN_RX; GPIO_InitStructure.Mode = GPIO_MODE_AF_PP; GPIO_InitStructure.Pull = GPIO_NOPULL; GPIO_InitStructure.Speed = GPIO_SPEED_HIGH; GPIO_InitStructure.Alternate = XB_PORT_AF; HAL_GPIO_Init(XB_PORT_INST, &GPIO_InitStructure); //Configure USART peripheral XB_USART_INST->CR2 = 0xFF000000; //I wish I could remember what this line was supposed to do then ... :) XB_USART_ENPERCLK(); xb_ComPort.Instance = XB_USART_INST; xb_ComPort.Init.BaudRate = XB_USART_BAUDRATE; xb_ComPort.Init.WordLength = UART_WORDLENGTH_8B; xb_ComPort.Init.StopBits = UART_STOPBITS_1; xb_ComPort.Init.Parity = UART_PARITY_NONE; xb_ComPort.Init.HwFlowCtl = UART_HWCONTROL_NONE; xb_ComPort.Init.Mode = UART_MODE_TX_RX; HAL_UART_Init(&xb_ComPort); //Set character match and disable error interrupts (this can be done only while Receiver is enabled and USART is disabled (RE=1, UE=0) __HAL_UART_DISABLE(&xb_ComPort); //__HAL_UART_DISABLE_IT(&ComPort, UART_IT_ERR); MODIFY_REG(XB_USART_INST->CR3, USART_CR3_OVRDIS, USART_CR3_OVRDIS); MODIFY_REG(XB_USART_INST->CR2, USART_CR2_ADD, ((unsigned)XB_ENDOFCMDCHAR << UART_CR2_ADDRESS_LSB_POS)); __HAL_UART_ENABLE(&xb_ComPort); //Configure DMA for TX and RX XB_DMA_ENPERCLK(); xb_hDMA_TX.Instance = XB_DMA_TX; xb_hDMA_TX.Init.Direction = DMA_MEMORY_TO_PERIPH; xb_hDMA_TX.Init.PeriphInc = DMA_PINC_DISABLE; xb_hDMA_TX.Init.MemInc = DMA_MINC_ENABLE; xb_hDMA_TX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; xb_hDMA_TX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; xb_hDMA_TX.Init.Mode = DMA_NORMAL;//DMA_CIRCULAR; xb_hDMA_TX.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_Init(&xb_hDMA_TX); __HAL_LINKDMA(&xb_ComPort, hdmatx, xb_hDMA_TX); HAL_NVIC_SetPriority(XB_DMA_TX_IRQN, 3, 1); HAL_NVIC_EnableIRQ(XB_DMA_TX_IRQN); hDMA_RX.Instance = XB_DMA_RX; hDMA_RX.Init.Direction = DMA_PERIPH_TO_MEMORY; hDMA_RX.Init.PeriphInc = DMA_PINC_DISABLE; hDMA_RX.Init.MemInc = DMA_MINC_ENABLE; hDMA_RX.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hDMA_RX.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hDMA_RX.Init.Mode = DMA_CIRCULAR; hDMA_RX.Init.Priority = DMA_PRIORITY_MEDIUM; HAL_DMA_Init(&hDMA_RX); __HAL_LINKDMA(&xb_ComPort, hdmarx, hDMA_RX); //Enable USART interrupts HAL_NVIC_SetPriority(XB_USART_IRQN, 3, 3); HAL_NVIC_EnableIRQ(XB_USART_IRQN); __HAL_UART_ENABLE_IT(&xb_ComPort, UART_IT_CM); //Starts port reading HAL_UART_Receive_DMA(&xb_ComPort, xb_RxBuffer, XB_RXBUFSIZE); xb_MutexId = osMutexCreate(osMutex(xb_Mutex)); }