void serial_init(serial_t *obj, PinName tx, PinName rx)
{
struct serial_s *obj_s = SERIAL_S(obj);
// Determine the UART to use (UART_1, UART_2, ...)
UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX);
UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX);
// Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object
obj_s->uart = (UARTName)pinmap_merge(uart_tx, uart_rx);
MBED_ASSERT(obj_s->uart != (UARTName)NC);
// Enable USART clock
switch (obj_s->uart) {
case UART_1:
__HAL_RCC_USART1_FORCE_RESET();
__HAL_RCC_USART1_RELEASE_RESET();
__HAL_RCC_USART1_CLK_ENABLE();
obj_s->index = 0;
break;
case UART_2:
__HAL_RCC_USART2_FORCE_RESET();
__HAL_RCC_USART2_RELEASE_RESET();
__HAL_RCC_USART2_CLK_ENABLE();
obj_s->index = 1;
break;
#if defined(USART3_BASE)
case UART_3:
__HAL_RCC_USART3_FORCE_RESET();
__HAL_RCC_USART3_RELEASE_RESET();
__HAL_RCC_USART3_CLK_ENABLE();
obj_s->index = 2;
break;
#endif
#if defined(UART4_BASE)
case UART_4:
__HAL_RCC_UART4_FORCE_RESET();
__HAL_RCC_UART4_RELEASE_RESET();
__HAL_RCC_UART4_CLK_ENABLE();
obj_s->index = 3;
break;
#endif
#if defined(UART5_BASE)
case UART_5:
__HAL_RCC_UART5_FORCE_RESET();
__HAL_RCC_UART5_RELEASE_RESET();
__HAL_RCC_UART5_CLK_ENABLE();
obj_s->index = 4;
break;
#endif
#if defined(USART6_BASE)
case UART_6:
__HAL_RCC_USART6_FORCE_RESET();
__HAL_RCC_USART6_RELEASE_RESET();
__HAL_RCC_USART6_CLK_ENABLE();
obj_s->index = 5;
break;
#endif
#if defined(UART7_BASE)
case UART_7:
__HAL_RCC_UART7_FORCE_RESET();
__HAL_RCC_UART7_RELEASE_RESET();
__HAL_RCC_UART7_CLK_ENABLE();
obj_s->index = 6;
break;
#endif
#if defined(UART8_BASE)
case UART_8:
__HAL_RCC_UART8_FORCE_RESET();
__HAL_RCC_UART8_RELEASE_RESET();
__HAL_RCC_UART8_CLK_ENABLE();
obj_s->index = 7;
break;
#endif
}
// Configure the UART pins
pinmap_pinout(tx, PinMap_UART_TX);
pinmap_pinout(rx, PinMap_UART_RX);
if (tx != NC) {
pin_mode(tx, PullUp);
}
if (rx != NC) {
pin_mode(rx, PullUp);
}
// Configure UART
obj_s->baudrate = 9600;
obj_s->databits = UART_WORDLENGTH_8B;
obj_s->stopbits = UART_STOPBITS_1;
obj_s->parity = UART_PARITY_NONE;
#if DEVICE_SERIAL_FC
obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
#endif
obj_s->pin_tx = tx;
obj_s->pin_rx = rx;
init_uart(obj);
// For stdio management
if (obj_s->uart == STDIO_UART) {
stdio_uart_inited = 1;
memcpy(&stdio_uart, obj, sizeof(serial_t));
}
}
void serial_init(serial_t *obj, PinName tx, PinName rx)
{
// Determine the UART to use (UART_1, UART_2, ...)
UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX);
UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX);
// Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object
SERIAL_OBJ(uart) = (UARTName)pinmap_merge(uart_tx, uart_rx);
MBED_ASSERT(SERIAL_OBJ(uart) != (UARTName)NC);
// Enable USART clock
switch (SERIAL_OBJ(uart)) {
case UART_1:
__HAL_RCC_USART1_CLK_ENABLE();
SERIAL_OBJ(index) = 0;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA2_CLK_ENABLE();
#endif
break;
case UART_2:
__HAL_RCC_USART2_CLK_ENABLE();
SERIAL_OBJ(index) = 1;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
break;
#if defined(USART3_BASE)
case UART_3:
__HAL_RCC_USART3_CLK_ENABLE();
SERIAL_OBJ(index) = 2;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
break;
#endif
#if defined(UART4_BASE)
case UART_4:
__HAL_RCC_UART4_CLK_ENABLE();
SERIAL_OBJ(index) = 3;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
break;
#endif
#if defined(UART5_BASE)
case UART_5:
__HAL_RCC_UART5_CLK_ENABLE();
SERIAL_OBJ(index) = 4;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
break;
#endif
#if defined(USART6_BASE)
case UART_6:
__HAL_RCC_USART6_CLK_ENABLE();
SERIAL_OBJ(index) = 5;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA2_CLK_ENABLE();
#endif
break;
#endif
#if defined(UART7_BASE)
case UART_7:
__HAL_RCC_UART7_CLK_ENABLE();
SERIAL_OBJ(index) = 6;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
break;
#endif
#if defined(UART8_BASE)
case UART_8:
__HAL_RCC_UART8_CLK_ENABLE();
SERIAL_OBJ(index) = 7;
#if DEVICE_SERIAL_ASYNCH_DMA
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
break;
#endif
}
// Configure the UART pins
pinmap_pinout(tx, PinMap_UART_TX);
pinmap_pinout(rx, PinMap_UART_RX);
if (tx != NC) {
pin_mode(tx, PullUp);
}
if (rx != NC) {
pin_mode(rx, PullUp);
}
// Configure UART
SERIAL_OBJ(baudrate) = 9600;
SERIAL_OBJ(databits) = UART_WORDLENGTH_8B;
SERIAL_OBJ(stopbits) = UART_STOPBITS_1;
SERIAL_OBJ(parity) = UART_PARITY_NONE;
SERIAL_OBJ(pin_tx) = tx;
SERIAL_OBJ(pin_rx) = rx;
init_uart(obj);
// For stdio management
if (SERIAL_OBJ(uart) == STDIO_UART) {
stdio_uart_inited = 1;
memcpy(&stdio_uart, obj, sizeof(serial_t));
}
}
void systemInit(void)
{
// Priority grouping should be setup before any irq prio is set.
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITY_GROUPING);
// GPIO ports are always used so it makes sense to just enable the clocks to the available ports
#ifdef GPIOA
__HAL_RCC_GPIOA_CLK_ENABLE();
#endif
#ifdef GPIOB
__HAL_RCC_GPIOB_CLK_ENABLE();
#endif
#ifdef GPIOC
__HAL_RCC_GPIOC_CLK_ENABLE();
#endif
#ifdef GPIOD
__HAL_RCC_GPIOD_CLK_ENABLE();
#endif
#ifdef GPIOE
__HAL_RCC_GPIOE_CLK_ENABLE();
#endif
#ifdef GPIOF
__HAL_RCC_GPIOF_CLK_ENABLE();
#endif
// It makes it all lot easier if we just enable to DMA clocks, the additional idle current is neglectable
#ifdef DMA1
__HAL_RCC_DMA1_CLK_ENABLE();
#endif
#ifdef DMA2
__HAL_RCC_DMA2_CLK_ENABLE();
#endif
/* Select SysClk as source of USART1 clocks */
RCC_PeriphCLKInitTypeDef RCC_PeriphClkInit;
RCC_PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1;
RCC_PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK;
HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphClkInit);
// Init clocks of used peripherals
#ifdef USE_USART1
__HAL_RCC_USART1_CLK_ENABLE();
#endif
#ifdef USE_USART2
__HAL_RCC_USART2_CLK_ENABLE();
#endif
#ifdef USE_USART3
__HAL_RCC_USART3_CLK_ENABLE();
#endif
#ifdef USE_USART4
__HAL_RCC_UART4_CLK_ENABLE();
#endif
#ifdef USE_USART5
__HAL_RCC_UART5_CLK_ENABLE();
#endif
#ifdef USE_USART6
__HAL_RCC_USART6_CLK_ENABLE();
#endif
#ifdef USE_USART7
__HAL_RCC_UART7_CLK_ENABLE();
#endif
#ifdef USE_USART8
__HAL_RCC_UART8_CLK_ENABLE();
#endif
}
static void TM_USART_INT_Init(
USART_TypeDef* USARTx,
TM_USART_PinsPack_t pinspack,
uint32_t baudrate,
TM_USART_HardwareFlowControl_t FlowControl,
uint32_t Mode,
uint32_t Parity,
uint32_t StopBits,
uint32_t WordLength
) {
UART_HandleTypeDef UARTHandle;
IRQn_Type irq;
/*
* Initialize USARTx pins
* Set channel for USARTx NVIC
*/
#ifdef USART1
if (USARTx == USART1) {
/* Enable USART clock */
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_USART1_FORCE_RESET();
__HAL_RCC_USART1_RELEASE_RESET();
/* Init pins */
TM_USART1_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART1;
}
#endif
#ifdef USART2
if (USARTx == USART2) {
/* Enable USART clock */
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_USART2_FORCE_RESET();
__HAL_RCC_USART2_RELEASE_RESET();
/* Init pins */
TM_USART2_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART2;
}
#endif
#ifdef USART3
if (USARTx == USART3) {
/* Enable USART clock */
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_USART3_FORCE_RESET();
__HAL_RCC_USART3_RELEASE_RESET();
/* Init pins */
TM_USART3_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART3;
}
#endif
#ifdef UART4
if (USARTx == UART4) {
/* Enable UART clock */
__HAL_RCC_UART4_CLK_ENABLE();
__HAL_RCC_UART4_FORCE_RESET();
__HAL_RCC_UART4_RELEASE_RESET();
/* Init pins */
TM_UART4_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART4;
}
#endif
#ifdef UART5
if (USARTx == UART5) {
/* Enable UART clock */
__HAL_RCC_UART5_CLK_ENABLE();
__HAL_RCC_UART5_FORCE_RESET();
__HAL_RCC_UART5_RELEASE_RESET();
/* Init pins */
TM_UART5_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART5;
}
#endif
#ifdef USART6
if (USARTx == USART6) {
/* Enable UART clock */
__HAL_RCC_USART6_CLK_ENABLE();
__HAL_RCC_USART6_FORCE_RESET();
__HAL_RCC_USART6_RELEASE_RESET();
/* Init pins */
TM_USART6_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART6;
}
#endif
#ifdef UART7
if (USARTx == UART7) {
/* Enable UART clock */
__HAL_RCC_UART7_CLK_ENABLE();
__HAL_RCC_UART7_FORCE_RESET();
__HAL_RCC_UART7_RELEASE_RESET();
/* Init pins */
TM_UART7_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART7;
}
#endif
#ifdef UART8
if (USARTx == UART8) {
/* Enable UART clock */
__HAL_RCC_UART8_CLK_ENABLE();
__HAL_RCC_UART8_FORCE_RESET();
__HAL_RCC_UART8_RELEASE_RESET();
/* Init pins */
TM_UART8_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_UART8;
}
#endif
/* STM32F0xx related */
#ifdef USART4
if (USARTx == USART4) {
/* Enable UART clock */
__HAL_RCC_USART4_CLK_ENABLE();
__HAL_RCC_USART4_FORCE_RESET();
__HAL_RCC_USART4_RELEASE_RESET();
/* Init pins */
TM_USART4_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART4;
}
#endif
#ifdef USART5
if (USARTx == USART5) {
/* Enable UART clock */
__HAL_RCC_USART5_CLK_ENABLE();
__HAL_RCC_USART5_FORCE_RESET();
__HAL_RCC_USART5_RELEASE_RESET();
/* Init pins */
TM_USART5_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART5;
}
#endif
#ifdef USART7
if (USARTx == USART7) {
/* Enable UART clock */
__HAL_RCC_USART7_CLK_ENABLE();
__HAL_RCC_USART7_FORCE_RESET();
__HAL_RCC_USART7_RELEASE_RESET();
/* Init pins */
TM_USART7_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART7;
}
#endif
#ifdef USART8
if (USARTx == USART8) {
/* Enable UART clock */
__HAL_RCC_USART8_CLK_ENABLE();
__HAL_RCC_USART8_FORCE_RESET();
__HAL_RCC_USART8_RELEASE_RESET();
/* Init pins */
TM_USART8_InitPins(pinspack);
/* Set IRQ channel */
irq = IRQ_USART8;
}
#endif
/* Fill default settings */
UARTHandle.Instance = USARTx;
UARTHandle.Init.BaudRate = baudrate;
UARTHandle.Init.HwFlowCtl = FlowControl;
UARTHandle.Init.Mode = Mode;
UARTHandle.Init.Parity = Parity;
UARTHandle.Init.StopBits = StopBits;
UARTHandle.Init.WordLength = WordLength;
UARTHandle.Init.OverSampling = UART_OVERSAMPLING_16;
#if defined(STM32F0xx)
UARTHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
#endif
/* Disable IRQ */
HAL_NVIC_DisableIRQ(irq);
/* Set priority */
HAL_NVIC_SetPriority(irq, USART_NVIC_PRIORITY, TM_USART_INT_GetSubPriority(USARTx));
/* Enable interrupt */
HAL_NVIC_EnableIRQ(irq);
/* Clear interrupt */
HAL_NVIC_ClearPendingIRQ(irq);
/* Init USART */
HAL_UART_Init(&UARTHandle);
/* Enable RX interrupt */
USARTx->CR1 |= USART_CR1_RXNEIE;
}
//--------------------------------------------------------------
// interne Funktion
// init vom Comport
//--------------------------------------------------------------
static void P_BSP_COM_Init(UART_NAME_t uart) {
GPIO_InitTypeDef gpio_init_structure;
#if USE_UART1 == 1
if (uart == COM1) {
// GPIO Clock Enable
UB_System_ClockEnable(COM1_TX_PORT);
UB_System_ClockEnable(COM1_RX_PORT);
// UART Clock Enable
__HAL_RCC_USART1_CLK_ENABLE();
// GPIO TX
gpio_init_structure.Pin = COM1_TX_PIN;
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
gpio_init_structure.Speed = GPIO_SPEED_FAST;
gpio_init_structure.Pull = GPIO_PULLUP;
gpio_init_structure.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(COM1_TX_PORT, &gpio_init_structure);
// GPIO RX
gpio_init_structure.Pin = COM1_RX_PIN;
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
gpio_init_structure.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(COM1_RX_PORT, &gpio_init_structure);
}
#endif
#if USE_UART6 == 1
if (uart == COM6) {
// GPIO Clock Enable
memset(&rx_buf6[0], 0, RX_BUF_SIZE + 1); // ** WK **
UB_System_ClockEnable(COM6_TX_PORT);
UB_System_ClockEnable(COM6_RX_PORT);
// UART Clock Enable
__HAL_RCC_USART6_CLK_ENABLE();
// GPIO TX
gpio_init_structure.Pin = COM6_TX_PIN;
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
gpio_init_structure.Speed = GPIO_SPEED_FAST;
gpio_init_structure.Pull = GPIO_PULLUP;
gpio_init_structure.Alternate = GPIO_AF8_USART6;
HAL_GPIO_Init(COM6_TX_PORT, &gpio_init_structure);
// GPIO RX
gpio_init_structure.Pin = COM6_RX_PIN;
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
gpio_init_structure.Alternate = GPIO_AF8_USART6;
HAL_GPIO_Init(COM6_RX_PORT, &gpio_init_structure);
}
#endif
#if USE_UART7 == 1
if (uart == COM7) {
// GPIO Clock Enable
UB_System_ClockEnable(COM7_TX_PORT);
UB_System_ClockEnable(COM7_RX_PORT);
// UART Clock Enable
__HAL_RCC_UART7_CLK_ENABLE();
// GPIO TX
gpio_init_structure.Pin = COM7_TX_PIN;
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
gpio_init_structure.Speed = GPIO_SPEED_FAST;
gpio_init_structure.Pull = GPIO_PULLUP;
gpio_init_structure.Alternate = GPIO_AF8_UART7;
HAL_GPIO_Init(COM7_TX_PORT, &gpio_init_structure);
// GPIO RX
gpio_init_structure.Pin = COM7_RX_PIN;
gpio_init_structure.Mode = GPIO_MODE_AF_PP;
gpio_init_structure.Alternate = GPIO_AF8_UART7;
HAL_GPIO_Init(COM7_RX_PORT, &gpio_init_structure);
}
#endif
}
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);
}
// assumes Init parameters have been set up correctly
bool uart_init(pyb_uart_obj_t *uart_obj,
uint32_t baudrate, uint32_t bits, uint32_t parity, uint32_t stop, uint32_t flow) {
USART_TypeDef *UARTx;
IRQn_Type irqn;
int uart_unit;
const pin_obj_t *pins[4] = {0};
switch (uart_obj->uart_id) {
#if defined(MICROPY_HW_UART1_TX) && defined(MICROPY_HW_UART1_RX)
case PYB_UART_1:
uart_unit = 1;
UARTx = USART1;
irqn = USART1_IRQn;
pins[0] = MICROPY_HW_UART1_TX;
pins[1] = MICROPY_HW_UART1_RX;
__HAL_RCC_USART1_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART2_TX) && defined(MICROPY_HW_UART2_RX)
case PYB_UART_2:
uart_unit = 2;
UARTx = USART2;
irqn = USART2_IRQn;
pins[0] = MICROPY_HW_UART2_TX;
pins[1] = MICROPY_HW_UART2_RX;
#if defined(MICROPY_HW_UART2_RTS)
if (flow & UART_HWCONTROL_RTS) {
pins[2] = MICROPY_HW_UART2_RTS;
}
#endif
#if defined(MICROPY_HW_UART2_CTS)
if (flow & UART_HWCONTROL_CTS) {
pins[3] = MICROPY_HW_UART2_CTS;
}
#endif
__HAL_RCC_USART2_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART3_TX) && defined(MICROPY_HW_UART3_RX)
case PYB_UART_3:
uart_unit = 3;
UARTx = USART3;
#if defined(STM32F0)
irqn = USART3_8_IRQn;
#else
irqn = USART3_IRQn;
#endif
pins[0] = MICROPY_HW_UART3_TX;
pins[1] = MICROPY_HW_UART3_RX;
#if defined(MICROPY_HW_UART3_RTS)
if (flow & UART_HWCONTROL_RTS) {
pins[2] = MICROPY_HW_UART3_RTS;
}
#endif
#if defined(MICROPY_HW_UART3_CTS)
if (flow & UART_HWCONTROL_CTS) {
pins[3] = MICROPY_HW_UART3_CTS;
}
#endif
__HAL_RCC_USART3_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART4_TX) && defined(MICROPY_HW_UART4_RX)
case PYB_UART_4:
uart_unit = 4;
#if defined(STM32F0)
UARTx = USART4;
irqn = USART3_8_IRQn;
__HAL_RCC_USART4_CLK_ENABLE();
#else
UARTx = UART4;
irqn = UART4_IRQn;
__HAL_RCC_UART4_CLK_ENABLE();
#endif
pins[0] = MICROPY_HW_UART4_TX;
pins[1] = MICROPY_HW_UART4_RX;
break;
#endif
#if defined(MICROPY_HW_UART5_TX) && defined(MICROPY_HW_UART5_RX)
case PYB_UART_5:
uart_unit = 5;
#if defined(STM32F0)
UARTx = USART5;
irqn = USART3_8_IRQn;
__HAL_RCC_USART5_CLK_ENABLE();
#else
UARTx = UART5;
irqn = UART5_IRQn;
__HAL_RCC_UART5_CLK_ENABLE();
#endif
pins[0] = MICROPY_HW_UART5_TX;
pins[1] = MICROPY_HW_UART5_RX;
break;
#endif
#if defined(MICROPY_HW_UART6_TX) && defined(MICROPY_HW_UART6_RX)
case PYB_UART_6:
uart_unit = 6;
UARTx = USART6;
#if defined(STM32F0)
irqn = USART3_8_IRQn;
#else
irqn = USART6_IRQn;
#endif
pins[0] = MICROPY_HW_UART6_TX;
pins[1] = MICROPY_HW_UART6_RX;
#if defined(MICROPY_HW_UART6_RTS)
if (flow & UART_HWCONTROL_RTS) {
pins[2] = MICROPY_HW_UART6_RTS;
}
#endif
#if defined(MICROPY_HW_UART6_CTS)
if (flow & UART_HWCONTROL_CTS) {
pins[3] = MICROPY_HW_UART6_CTS;
}
#endif
__HAL_RCC_USART6_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART7_TX) && defined(MICROPY_HW_UART7_RX)
case PYB_UART_7:
uart_unit = 7;
#if defined(STM32F0)
UARTx = USART7;
irqn = USART3_8_IRQn;
__HAL_RCC_USART7_CLK_ENABLE();
#else
UARTx = UART7;
irqn = UART7_IRQn;
__HAL_RCC_UART7_CLK_ENABLE();
#endif
pins[0] = MICROPY_HW_UART7_TX;
pins[1] = MICROPY_HW_UART7_RX;
break;
#endif
#if defined(MICROPY_HW_UART8_TX) && defined(MICROPY_HW_UART8_RX)
case PYB_UART_8:
uart_unit = 8;
#if defined(STM32F0)
UARTx = USART8;
irqn = USART3_8_IRQn;
__HAL_RCC_USART8_CLK_ENABLE();
#else
UARTx = UART8;
irqn = UART8_IRQn;
__HAL_RCC_UART8_CLK_ENABLE();
#endif
pins[0] = MICROPY_HW_UART8_TX;
pins[1] = MICROPY_HW_UART8_RX;
break;
#endif
#if defined(MICROPY_HW_UART9_TX) && defined(MICROPY_HW_UART9_RX)
case PYB_UART_9:
uart_unit = 9;
UARTx = UART9;
irqn = UART9_IRQn;
__HAL_RCC_UART9_CLK_ENABLE();
pins[0] = MICROPY_HW_UART9_TX;
pins[1] = MICROPY_HW_UART9_RX;
break;
#endif
#if defined(MICROPY_HW_UART10_TX) && defined(MICROPY_HW_UART10_RX)
case PYB_UART_10:
uart_unit = 10;
UARTx = UART10;
irqn = UART10_IRQn;
__HAL_RCC_UART10_CLK_ENABLE();
pins[0] = MICROPY_HW_UART10_TX;
pins[1] = MICROPY_HW_UART10_RX;
break;
#endif
default:
// UART does not exist or is not configured for this board
return false;
}
uint32_t mode = MP_HAL_PIN_MODE_ALT;
uint32_t pull = MP_HAL_PIN_PULL_UP;
for (uint i = 0; i < 4; i++) {
if (pins[i] != NULL) {
bool ret = mp_hal_pin_config_alt(pins[i], mode, pull, AF_FN_UART, uart_unit);
if (!ret) {
return false;
}
}
}
uart_obj->uartx = UARTx;
// init UARTx
UART_HandleTypeDef huart;
memset(&huart, 0, sizeof(huart));
huart.Instance = UARTx;
huart.Init.BaudRate = baudrate;
huart.Init.WordLength = bits;
huart.Init.StopBits = stop;
huart.Init.Parity = parity;
huart.Init.Mode = UART_MODE_TX_RX;
huart.Init.HwFlowCtl = flow;
huart.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&huart);
// Disable all individual UART IRQs, but enable the global handler
uart_obj->uartx->CR1 &= ~USART_CR1_IE_ALL;
uart_obj->uartx->CR2 &= ~USART_CR2_IE_ALL;
uart_obj->uartx->CR3 &= ~USART_CR3_IE_ALL;
NVIC_SetPriority(IRQn_NONNEG(irqn), IRQ_PRI_UART);
HAL_NVIC_EnableIRQ(irqn);
uart_obj->is_enabled = true;
uart_obj->attached_to_repl = false;
if (bits == UART_WORDLENGTH_9B && parity == UART_PARITY_NONE) {
uart_obj->char_mask = 0x1ff;
uart_obj->char_width = CHAR_WIDTH_9BIT;
} else {
if (bits == UART_WORDLENGTH_9B || parity == UART_PARITY_NONE) {
uart_obj->char_mask = 0xff;
} else {
uart_obj->char_mask = 0x7f;
}
uart_obj->char_width = CHAR_WIDTH_8BIT;
}
uart_obj->mp_irq_trigger = 0;
uart_obj->mp_irq_obj = NULL;
return true;
}
// assumes Init parameters have been set up correctly
STATIC bool uart_init2(pyb_uart_obj_t *uart_obj) {
USART_TypeDef *UARTx;
IRQn_Type irqn;
int uart_unit;
const pin_obj_t *pins[4] = {0};
switch (uart_obj->uart_id) {
#if defined(MICROPY_HW_UART1_TX) && defined(MICROPY_HW_UART1_RX)
case PYB_UART_1:
uart_unit = 1;
UARTx = USART1;
irqn = USART1_IRQn;
pins[0] = MICROPY_HW_UART1_TX;
pins[1] = MICROPY_HW_UART1_RX;
__HAL_RCC_USART1_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART2_TX) && defined(MICROPY_HW_UART2_RX)
case PYB_UART_2:
uart_unit = 2;
UARTx = USART2;
irqn = USART2_IRQn;
pins[0] = MICROPY_HW_UART2_TX;
pins[1] = MICROPY_HW_UART2_RX;
#if defined(MICROPY_HW_UART2_RTS)
if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
pins[2] = MICROPY_HW_UART2_RTS;
}
#endif
#if defined(MICROPY_HW_UART2_CTS)
if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
pins[3] = MICROPY_HW_UART2_CTS;
}
#endif
__HAL_RCC_USART2_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART3_TX) && defined(MICROPY_HW_UART3_RX)
case PYB_UART_3:
uart_unit = 3;
UARTx = USART3;
irqn = USART3_IRQn;
pins[0] = MICROPY_HW_UART3_TX;
pins[1] = MICROPY_HW_UART3_RX;
#if defined(MICROPY_HW_UART3_RTS)
if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
pins[2] = MICROPY_HW_UART3_RTS;
}
#endif
#if defined(MICROPY_HW_UART3_CTS)
if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
pins[3] = MICROPY_HW_UART3_CTS;
}
#endif
__HAL_RCC_USART3_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART4_TX) && defined(MICROPY_HW_UART4_RX)
case PYB_UART_4:
uart_unit = 4;
UARTx = UART4;
irqn = UART4_IRQn;
pins[0] = MICROPY_HW_UART4_TX;
pins[1] = MICROPY_HW_UART4_RX;
__HAL_RCC_UART4_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART5_TX) && defined(MICROPY_HW_UART5_RX)
case PYB_UART_5:
uart_unit = 5;
UARTx = UART5;
irqn = UART5_IRQn;
pins[0] = MICROPY_HW_UART5_TX;
pins[1] = MICROPY_HW_UART5_RX;
__HAL_RCC_UART5_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART6_TX) && defined(MICROPY_HW_UART6_RX)
case PYB_UART_6:
uart_unit = 6;
UARTx = USART6;
irqn = USART6_IRQn;
pins[0] = MICROPY_HW_UART6_TX;
pins[1] = MICROPY_HW_UART6_RX;
#if defined(MICROPY_HW_UART6_RTS)
if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_RTS) {
pins[2] = MICROPY_HW_UART6_RTS;
}
#endif
#if defined(MICROPY_HW_UART6_CTS)
if (uart_obj->uart.Init.HwFlowCtl & UART_HWCONTROL_CTS) {
pins[3] = MICROPY_HW_UART6_CTS;
}
#endif
__HAL_RCC_USART6_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART7_TX) && defined(MICROPY_HW_UART7_RX)
case PYB_UART_7:
uart_unit = 7;
UARTx = UART7;
irqn = UART7_IRQn;
pins[0] = MICROPY_HW_UART7_TX;
pins[1] = MICROPY_HW_UART7_RX;
__HAL_RCC_UART7_CLK_ENABLE();
break;
#endif
#if defined(MICROPY_HW_UART8_TX) && defined(MICROPY_HW_UART8_RX)
case PYB_UART_8:
uart_unit = 8;
UARTx = UART8;
irqn = UART8_IRQn;
pins[0] = MICROPY_HW_UART8_TX;
pins[1] = MICROPY_HW_UART8_RX;
__HAL_RCC_UART8_CLK_ENABLE();
break;
#endif
default:
// UART does not exist or is not configured for this board
return false;
}
uint32_t mode = MP_HAL_PIN_MODE_ALT;
uint32_t pull = MP_HAL_PIN_PULL_UP;
for (uint i = 0; i < 4; i++) {
if (pins[i] != NULL) {
bool ret = mp_hal_pin_config_alt(pins[i], mode, pull, AF_FN_UART, uart_unit);
if (!ret) {
return false;
}
}
}
uart_obj->irqn = irqn;
uart_obj->uart.Instance = UARTx;
// init UARTx
HAL_UART_Init(&uart_obj->uart);
uart_obj->is_enabled = true;
return true;
}
/*#####################################################*/
bool _uart_open(Uart_t* UartSettings)
{
GPIO_InitTypeDef GPIO_InitStruct;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
/* Enable GPIO TX/RX clock */
_gpio_init(UartSettings->TxPort);
_gpio_init(UartSettings->RxPort);
//USARTx_TX_GPIO_CLK_ENABLE();
//USARTx_RX_GPIO_CLK_ENABLE();
/* Enable USART1 clock */
switch(UartSettings->UartNr)
{
#ifdef __HAL_RCC_USART1_CLK_ENABLE
case 0:
__HAL_RCC_USART1_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_USART2_CLK_ENABLE
case 1:
__HAL_RCC_USART2_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_USART3_CLK_ENABLE
case 2:
__HAL_RCC_USART3_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_UART4_CLK_ENABLE
case 3:
__HAL_RCC_UART4_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_UART5_CLK_ENABLE
case 4:
__HAL_RCC_UART5_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_USART6_CLK_ENABLE
case 5:
__HAL_RCC_USART6_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_UART7_CLK_ENABLE
case 6:
__HAL_RCC_UART7_CLK_ENABLE();
break;
#endif
#ifdef __HAL_RCC_UART8_CLK_ENABLE
case 7:
__HAL_RCC_UART8_CLK_ENABLE();
break;
#endif
}
//USARTx_CLK_ENABLE();
/*##-2- Configure peripheral GPIO ##########################################*/
/* UART TX GPIO pin configuration */
GPIO_InitStruct.Pin = 1 << UartSettings->TxPin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
switch(UartSettings->UartNr)
{
case 0:
case 1:
case 2:
GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
break;
case 3:
case 4:
case 5:
case 6:
case 7:
GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
break;
default:
return false;
}
//GPIO_InitStruct.Alternate = USARTx_TX_AF;
HAL_GPIO_Init(GET_GPIO_PORT_ADDR[UartSettings->TxPort], &GPIO_InitStruct);
/* UART RX GPIO pin configuration */
GPIO_InitStruct.Pin = 1 << UartSettings->RxPin;
//GPIO_InitStruct.Alternate = USARTx_RX_AF;
HAL_GPIO_Init(GET_GPIO_PORT_ADDR[UartSettings->RxPort], &GPIO_InitStruct);
UartSettings->udata = calloc(1, sizeof(UART_HandleTypeDef));
if(!UartSettings->udata)
return false;
UART_HandleTypeDef *UartHandle = (UART_HandleTypeDef *)UartSettings->udata;
//USART_DeInit(COM_USART[UartSettings->UartNr]);
//UART_nvic_config(UartSettings);
UartSettings->BaseAddr = (unsigned int)UartSettings;
UartHandle->Instance = COM_USART[UartSettings->UartNr];
UartHandle->Init.BaudRate = UartSettings->BaudRate;
UartHandle->Init.WordLength = UART_WORDLENGTH_8B;
UartHandle->Init.StopBits = UART_STOPBITS_1;
UartHandle->Init.Parity = UART_PARITY_NONE;
UartHandle->Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle->Init.Mode = UART_MODE_TX_RX;
UartHandle->Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(UartHandle);
return true;//UartOpen(UartSettings);
}
