Toyomasa Watarai / mbed-dev-lpcx1769

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   LPCXpresso1769_blinky

Fork of mbed-dev by mbed official

targets/hal/TARGET_STM/TARGET_STM32F2/serial_api.c@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
This updates the lib to the mbed lib v125

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /* mbed Microcontroller Library
<> 144:ef7eb2e8f9f7 2 *******************************************************************************
<> 144:ef7eb2e8f9f7 3 * Copyright (c) 2016, STMicroelectronics
<> 144:ef7eb2e8f9f7 4 * All rights reserved.
<> 144:ef7eb2e8f9f7 5 *
<> 144:ef7eb2e8f9f7 6 * Redistribution and use in source and binary forms, with or without
<> 144:ef7eb2e8f9f7 7 * modification, are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 8 *
<> 144:ef7eb2e8f9f7 9 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 10 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 11 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 12 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 13 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 14 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 15 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 16 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 17 *
<> 144:ef7eb2e8f9f7 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 21 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 28 *******************************************************************************
<> 144:ef7eb2e8f9f7 29 */
<> 144:ef7eb2e8f9f7 30 #include "mbed_assert.h"
<> 144:ef7eb2e8f9f7 31 #include "serial_api.h"
<> 144:ef7eb2e8f9f7 32
<> 144:ef7eb2e8f9f7 33 #if DEVICE_SERIAL
<> 144:ef7eb2e8f9f7 34
<> 144:ef7eb2e8f9f7 35 #include "cmsis.h"
<> 144:ef7eb2e8f9f7 36 #include "pinmap.h"
<> 144:ef7eb2e8f9f7 37 #include <string.h>
<> 144:ef7eb2e8f9f7 38 #include "PeripheralPins.h"
<> 144:ef7eb2e8f9f7 39 #include "mbed_error.h"
<> 144:ef7eb2e8f9f7 40
<> 144:ef7eb2e8f9f7 41 #define UART_NUM (8)
<> 144:ef7eb2e8f9f7 42
<> 144:ef7eb2e8f9f7 43 static uint32_t serial_irq_ids[UART_NUM] = {0};
<> 144:ef7eb2e8f9f7 44 static UART_HandleTypeDef uart_handlers[UART_NUM];
<> 144:ef7eb2e8f9f7 45
<> 144:ef7eb2e8f9f7 46 static uart_irq_handler irq_handler;
<> 144:ef7eb2e8f9f7 47
<> 144:ef7eb2e8f9f7 48 int stdio_uart_inited = 0;
<> 144:ef7eb2e8f9f7 49 serial_t stdio_uart;
<> 144:ef7eb2e8f9f7 50
<> 144:ef7eb2e8f9f7 51 #if DEVICE_SERIAL_ASYNCH
<> 144:ef7eb2e8f9f7 52 #define SERIAL_S(obj) (&((obj)->serial))
<> 144:ef7eb2e8f9f7 53 #else
<> 144:ef7eb2e8f9f7 54 #define SERIAL_S(obj) (obj)
<> 144:ef7eb2e8f9f7 55 #endif
<> 144:ef7eb2e8f9f7 56
<> 144:ef7eb2e8f9f7 57 static void init_uart(serial_t *obj)
<> 144:ef7eb2e8f9f7 58 {
<> 144:ef7eb2e8f9f7 59 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 60 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 61 huart->Instance = (USART_TypeDef *)(obj_s->uart);
<> 144:ef7eb2e8f9f7 62
<> 144:ef7eb2e8f9f7 63 huart->Init.BaudRate = obj_s->baudrate;
<> 144:ef7eb2e8f9f7 64 huart->Init.WordLength = obj_s->databits;
<> 144:ef7eb2e8f9f7 65 huart->Init.StopBits = obj_s->stopbits;
<> 144:ef7eb2e8f9f7 66 huart->Init.Parity = obj_s->parity;
<> 144:ef7eb2e8f9f7 67 #if DEVICE_SERIAL_FC
<> 144:ef7eb2e8f9f7 68 huart->Init.HwFlowCtl = obj_s->hw_flow_ctl;
<> 144:ef7eb2e8f9f7 69 #else
<> 144:ef7eb2e8f9f7 70 huart->Init.HwFlowCtl = UART_HWCONTROL_NONE;
<> 144:ef7eb2e8f9f7 71 #endif
<> 144:ef7eb2e8f9f7 72 huart->TxXferCount = 0;
<> 144:ef7eb2e8f9f7 73 huart->TxXferSize = 0;
<> 144:ef7eb2e8f9f7 74 huart->RxXferCount = 0;
<> 144:ef7eb2e8f9f7 75 huart->RxXferSize = 0;
<> 144:ef7eb2e8f9f7 76
<> 144:ef7eb2e8f9f7 77 if (obj_s->pin_rx == NC) {
<> 144:ef7eb2e8f9f7 78 huart->Init.Mode = UART_MODE_TX;
<> 144:ef7eb2e8f9f7 79 } else if (obj_s->pin_tx == NC) {
<> 144:ef7eb2e8f9f7 80 huart->Init.Mode = UART_MODE_RX;
<> 144:ef7eb2e8f9f7 81 } else {
<> 144:ef7eb2e8f9f7 82 huart->Init.Mode = UART_MODE_TX_RX;
<> 144:ef7eb2e8f9f7 83 }
<> 144:ef7eb2e8f9f7 84
<> 144:ef7eb2e8f9f7 85 /* uAMR & ARM: Call to UART init is done between reset of pre-initialized variables */
<> 144:ef7eb2e8f9f7 86 /* and before HAL Init. SystemCoreClock init required here */
<> 144:ef7eb2e8f9f7 87 SystemCoreClockUpdate();
<> 144:ef7eb2e8f9f7 88
<> 144:ef7eb2e8f9f7 89 if (HAL_UART_Init(huart) != HAL_OK) {
<> 144:ef7eb2e8f9f7 90 error("Cannot initialize UART\n");
<> 144:ef7eb2e8f9f7 91 }
<> 144:ef7eb2e8f9f7 92 }
<> 144:ef7eb2e8f9f7 93
<> 144:ef7eb2e8f9f7 94 void serial_init(serial_t *obj, PinName tx, PinName rx)
<> 144:ef7eb2e8f9f7 95 {
<> 144:ef7eb2e8f9f7 96 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 97
<> 144:ef7eb2e8f9f7 98 // Determine the UART to use (UART_1, UART_2, ...)
<> 144:ef7eb2e8f9f7 99 UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX);
<> 144:ef7eb2e8f9f7 100 UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX);
<> 144:ef7eb2e8f9f7 101
<> 144:ef7eb2e8f9f7 102 // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object
<> 144:ef7eb2e8f9f7 103 obj_s->uart = (UARTName)pinmap_merge(uart_tx, uart_rx);
<> 144:ef7eb2e8f9f7 104 MBED_ASSERT(obj_s->uart != (UARTName)NC);
<> 144:ef7eb2e8f9f7 105
<> 144:ef7eb2e8f9f7 106 // Enable USART clock
<> 144:ef7eb2e8f9f7 107 switch (obj_s->uart) {
<> 144:ef7eb2e8f9f7 108 case UART_1:
<> 144:ef7eb2e8f9f7 109 __HAL_RCC_USART1_FORCE_RESET();
<> 144:ef7eb2e8f9f7 110 __HAL_RCC_USART1_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 111 __HAL_RCC_USART1_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 112 obj_s->index = 0;
<> 144:ef7eb2e8f9f7 113 break;
<> 144:ef7eb2e8f9f7 114
<> 144:ef7eb2e8f9f7 115 case UART_2:
<> 144:ef7eb2e8f9f7 116 __HAL_RCC_USART2_FORCE_RESET();
<> 144:ef7eb2e8f9f7 117 __HAL_RCC_USART2_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 118 __HAL_RCC_USART2_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 119 obj_s->index = 1;
<> 144:ef7eb2e8f9f7 120 break;
<> 144:ef7eb2e8f9f7 121
<> 144:ef7eb2e8f9f7 122 #if defined(USART3_BASE)
<> 144:ef7eb2e8f9f7 123 case UART_3:
<> 144:ef7eb2e8f9f7 124 __HAL_RCC_USART3_FORCE_RESET();
<> 144:ef7eb2e8f9f7 125 __HAL_RCC_USART3_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 126 __HAL_RCC_USART3_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 127 obj_s->index = 2;
<> 144:ef7eb2e8f9f7 128 break;
<> 144:ef7eb2e8f9f7 129 #endif
<> 144:ef7eb2e8f9f7 130 #if defined(UART4_BASE)
<> 144:ef7eb2e8f9f7 131 case UART_4:
<> 144:ef7eb2e8f9f7 132 __HAL_RCC_UART4_FORCE_RESET();
<> 144:ef7eb2e8f9f7 133 __HAL_RCC_UART4_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 134 __HAL_RCC_UART4_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 135 obj_s->index = 3;
<> 144:ef7eb2e8f9f7 136 break;
<> 144:ef7eb2e8f9f7 137 #endif
<> 144:ef7eb2e8f9f7 138 #if defined(UART5_BASE)
<> 144:ef7eb2e8f9f7 139 case UART_5:
<> 144:ef7eb2e8f9f7 140 __HAL_RCC_UART5_FORCE_RESET();
<> 144:ef7eb2e8f9f7 141 __HAL_RCC_UART5_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 142 __HAL_RCC_UART5_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 143 obj_s->index = 4;
<> 144:ef7eb2e8f9f7 144 break;
<> 144:ef7eb2e8f9f7 145 #endif
<> 144:ef7eb2e8f9f7 146 #if defined(USART6_BASE)
<> 144:ef7eb2e8f9f7 147 case UART_6:
<> 144:ef7eb2e8f9f7 148 __HAL_RCC_USART6_FORCE_RESET();
<> 144:ef7eb2e8f9f7 149 __HAL_RCC_USART6_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 150 __HAL_RCC_USART6_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 151 obj_s->index = 5;
<> 144:ef7eb2e8f9f7 152 break;
<> 144:ef7eb2e8f9f7 153 #endif
<> 144:ef7eb2e8f9f7 154 #if defined(UART7_BASE)
<> 144:ef7eb2e8f9f7 155 case UART_7:
<> 144:ef7eb2e8f9f7 156 __HAL_RCC_UART7_FORCE_RESET();
<> 144:ef7eb2e8f9f7 157 __HAL_RCC_UART7_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 158 __HAL_RCC_UART7_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 159 obj_s->index = 6;
<> 144:ef7eb2e8f9f7 160 break;
<> 144:ef7eb2e8f9f7 161 #endif
<> 144:ef7eb2e8f9f7 162 #if defined(UART8_BASE)
<> 144:ef7eb2e8f9f7 163 case UART_8:
<> 144:ef7eb2e8f9f7 164 __HAL_RCC_UART8_FORCE_RESET();
<> 144:ef7eb2e8f9f7 165 __HAL_RCC_UART8_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 166 __HAL_RCC_UART8_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 167 obj_s->index = 7;
<> 144:ef7eb2e8f9f7 168 break;
<> 144:ef7eb2e8f9f7 169 #endif
<> 144:ef7eb2e8f9f7 170 }
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 // Configure the UART pins
<> 144:ef7eb2e8f9f7 173 pinmap_pinout(tx, PinMap_UART_TX);
<> 144:ef7eb2e8f9f7 174 pinmap_pinout(rx, PinMap_UART_RX);
<> 144:ef7eb2e8f9f7 175
<> 144:ef7eb2e8f9f7 176 if (tx != NC) {
<> 144:ef7eb2e8f9f7 177 pin_mode(tx, PullUp);
<> 144:ef7eb2e8f9f7 178 }
<> 144:ef7eb2e8f9f7 179 if (rx != NC) {
<> 144:ef7eb2e8f9f7 180 pin_mode(rx, PullUp);
<> 144:ef7eb2e8f9f7 181 }
<> 144:ef7eb2e8f9f7 182
<> 144:ef7eb2e8f9f7 183 // Configure UART
<> 144:ef7eb2e8f9f7 184 obj_s->baudrate = 9600;
<> 144:ef7eb2e8f9f7 185 obj_s->databits = UART_WORDLENGTH_8B;
<> 144:ef7eb2e8f9f7 186 obj_s->stopbits = UART_STOPBITS_1;
<> 144:ef7eb2e8f9f7 187 obj_s->parity = UART_PARITY_NONE;
<> 144:ef7eb2e8f9f7 188
<> 144:ef7eb2e8f9f7 189 #if DEVICE_SERIAL_FC
<> 144:ef7eb2e8f9f7 190 obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
<> 144:ef7eb2e8f9f7 191 #endif
<> 144:ef7eb2e8f9f7 192
<> 144:ef7eb2e8f9f7 193 obj_s->pin_tx = tx;
<> 144:ef7eb2e8f9f7 194 obj_s->pin_rx = rx;
<> 144:ef7eb2e8f9f7 195
<> 144:ef7eb2e8f9f7 196 init_uart(obj);
<> 144:ef7eb2e8f9f7 197
<> 144:ef7eb2e8f9f7 198 // For stdio management
<> 144:ef7eb2e8f9f7 199 if (obj_s->uart == STDIO_UART) {
<> 144:ef7eb2e8f9f7 200 stdio_uart_inited = 1;
<> 144:ef7eb2e8f9f7 201 memcpy(&stdio_uart, obj, sizeof(serial_t));
<> 144:ef7eb2e8f9f7 202 }
<> 144:ef7eb2e8f9f7 203 }
<> 144:ef7eb2e8f9f7 204
<> 144:ef7eb2e8f9f7 205 void serial_free(serial_t *obj)
<> 144:ef7eb2e8f9f7 206 {
<> 144:ef7eb2e8f9f7 207 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 208
<> 144:ef7eb2e8f9f7 209 // Reset UART and disable clock
<> 144:ef7eb2e8f9f7 210 switch (obj_s->index) {
<> 144:ef7eb2e8f9f7 211 case 0:
<> 144:ef7eb2e8f9f7 212 __USART1_FORCE_RESET();
<> 144:ef7eb2e8f9f7 213 __USART1_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 214 __USART1_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 215 break;
<> 144:ef7eb2e8f9f7 216
<> 144:ef7eb2e8f9f7 217 case 1:
<> 144:ef7eb2e8f9f7 218 __USART2_FORCE_RESET();
<> 144:ef7eb2e8f9f7 219 __USART2_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 220 __USART2_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 221 break;
<> 144:ef7eb2e8f9f7 222
<> 144:ef7eb2e8f9f7 223 #if defined(USART3_BASE)
<> 144:ef7eb2e8f9f7 224 case 2:
<> 144:ef7eb2e8f9f7 225 __USART3_FORCE_RESET();
<> 144:ef7eb2e8f9f7 226 __USART3_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 227 __USART3_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 228 break;
<> 144:ef7eb2e8f9f7 229 #endif
<> 144:ef7eb2e8f9f7 230 #if defined(UART4_BASE)
<> 144:ef7eb2e8f9f7 231 case 3:
<> 144:ef7eb2e8f9f7 232 __UART4_FORCE_RESET();
<> 144:ef7eb2e8f9f7 233 __UART4_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 234 __UART4_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 235 break;
<> 144:ef7eb2e8f9f7 236 #endif
<> 144:ef7eb2e8f9f7 237 #if defined(UART5_BASE)
<> 144:ef7eb2e8f9f7 238 case 4:
<> 144:ef7eb2e8f9f7 239 __UART5_FORCE_RESET();
<> 144:ef7eb2e8f9f7 240 __UART5_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 241 __UART5_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 242 break;
<> 144:ef7eb2e8f9f7 243 #endif
<> 144:ef7eb2e8f9f7 244 #if defined(USART6_BASE)
<> 144:ef7eb2e8f9f7 245 case 5:
<> 144:ef7eb2e8f9f7 246 __USART6_FORCE_RESET();
<> 144:ef7eb2e8f9f7 247 __USART6_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 248 __USART6_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 249 break;
<> 144:ef7eb2e8f9f7 250 #endif
<> 144:ef7eb2e8f9f7 251 #if defined(UART7_BASE)
<> 144:ef7eb2e8f9f7 252 case 6:
<> 144:ef7eb2e8f9f7 253 __UART7_FORCE_RESET();
<> 144:ef7eb2e8f9f7 254 __UART7_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 255 __UART7_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 256 break;
<> 144:ef7eb2e8f9f7 257 #endif
<> 144:ef7eb2e8f9f7 258 #if defined(UART8_BASE)
<> 144:ef7eb2e8f9f7 259 case 7:
<> 144:ef7eb2e8f9f7 260 __UART8_FORCE_RESET();
<> 144:ef7eb2e8f9f7 261 __UART8_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 262 __UART8_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 263 break;
<> 144:ef7eb2e8f9f7 264 #endif
<> 144:ef7eb2e8f9f7 265 }
<> 144:ef7eb2e8f9f7 266
<> 144:ef7eb2e8f9f7 267 // Configure GPIOs
<> 144:ef7eb2e8f9f7 268 pin_function(obj_s->pin_tx, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
<> 144:ef7eb2e8f9f7 269 pin_function(obj_s->pin_rx, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
<> 144:ef7eb2e8f9f7 270
<> 144:ef7eb2e8f9f7 271 serial_irq_ids[obj_s->index] = 0;
<> 144:ef7eb2e8f9f7 272 }
<> 144:ef7eb2e8f9f7 273
<> 144:ef7eb2e8f9f7 274 void serial_baud(serial_t *obj, int baudrate)
<> 144:ef7eb2e8f9f7 275 {
<> 144:ef7eb2e8f9f7 276 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 277
<> 144:ef7eb2e8f9f7 278 obj_s->baudrate = baudrate;
<> 144:ef7eb2e8f9f7 279 init_uart(obj);
<> 144:ef7eb2e8f9f7 280 }
<> 144:ef7eb2e8f9f7 281
<> 144:ef7eb2e8f9f7 282 void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits)
<> 144:ef7eb2e8f9f7 283 {
<> 144:ef7eb2e8f9f7 284 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 285
<> 144:ef7eb2e8f9f7 286 if (data_bits == 9) {
<> 144:ef7eb2e8f9f7 287 obj_s->databits = UART_WORDLENGTH_9B;
<> 144:ef7eb2e8f9f7 288 } else {
<> 144:ef7eb2e8f9f7 289 obj_s->databits = UART_WORDLENGTH_8B;
<> 144:ef7eb2e8f9f7 290 }
<> 144:ef7eb2e8f9f7 291
<> 144:ef7eb2e8f9f7 292 switch (parity) {
<> 144:ef7eb2e8f9f7 293 case ParityOdd:
<> 144:ef7eb2e8f9f7 294 obj_s->parity = UART_PARITY_ODD;
<> 144:ef7eb2e8f9f7 295 break;
<> 144:ef7eb2e8f9f7 296 case ParityEven:
<> 144:ef7eb2e8f9f7 297 obj_s->parity = UART_PARITY_EVEN;
<> 144:ef7eb2e8f9f7 298 break;
<> 144:ef7eb2e8f9f7 299 default: // ParityNone
<> 144:ef7eb2e8f9f7 300 case ParityForced0: // unsupported!
<> 144:ef7eb2e8f9f7 301 case ParityForced1: // unsupported!
<> 144:ef7eb2e8f9f7 302 obj_s->parity = UART_PARITY_NONE;
<> 144:ef7eb2e8f9f7 303 break;
<> 144:ef7eb2e8f9f7 304 }
<> 144:ef7eb2e8f9f7 305
<> 144:ef7eb2e8f9f7 306 if (stop_bits == 2) {
<> 144:ef7eb2e8f9f7 307 obj_s->stopbits = UART_STOPBITS_2;
<> 144:ef7eb2e8f9f7 308 } else {
<> 144:ef7eb2e8f9f7 309 obj_s->stopbits = UART_STOPBITS_1;
<> 144:ef7eb2e8f9f7 310 }
<> 144:ef7eb2e8f9f7 311
<> 144:ef7eb2e8f9f7 312 init_uart(obj);
<> 144:ef7eb2e8f9f7 313 }
<> 144:ef7eb2e8f9f7 314
<> 144:ef7eb2e8f9f7 315 /******************************************************************************
<> 144:ef7eb2e8f9f7 316 * INTERRUPTS HANDLING
<> 144:ef7eb2e8f9f7 317 ******************************************************************************/
<> 144:ef7eb2e8f9f7 318
<> 144:ef7eb2e8f9f7 319 static void uart_irq(int id)
<> 144:ef7eb2e8f9f7 320 {
<> 144:ef7eb2e8f9f7 321 UART_HandleTypeDef * huart = &uart_handlers[id];
<> 144:ef7eb2e8f9f7 322
<> 144:ef7eb2e8f9f7 323 if (serial_irq_ids[id] != 0) {
<> 144:ef7eb2e8f9f7 324 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
<> 144:ef7eb2e8f9f7 325 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
<> 144:ef7eb2e8f9f7 326 irq_handler(serial_irq_ids[id], TxIrq);
<> 144:ef7eb2e8f9f7 327 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
<> 144:ef7eb2e8f9f7 328 }
<> 144:ef7eb2e8f9f7 329 }
<> 144:ef7eb2e8f9f7 330 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
<> 144:ef7eb2e8f9f7 331 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
<> 144:ef7eb2e8f9f7 332 irq_handler(serial_irq_ids[id], RxIrq);
<> 144:ef7eb2e8f9f7 333 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
<> 144:ef7eb2e8f9f7 334 }
<> 144:ef7eb2e8f9f7 335 }
<> 144:ef7eb2e8f9f7 336 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
<> 144:ef7eb2e8f9f7 337 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
<> 144:ef7eb2e8f9f7 338 volatile uint32_t tmpval = huart->Instance->DR; // Clear ORE flag
<> 144:ef7eb2e8f9f7 339 }
<> 144:ef7eb2e8f9f7 340 }
<> 144:ef7eb2e8f9f7 341 }
<> 144:ef7eb2e8f9f7 342 }
<> 144:ef7eb2e8f9f7 343
<> 144:ef7eb2e8f9f7 344 static void uart1_irq(void)
<> 144:ef7eb2e8f9f7 345 {
<> 144:ef7eb2e8f9f7 346 uart_irq(0);
<> 144:ef7eb2e8f9f7 347 }
<> 144:ef7eb2e8f9f7 348
<> 144:ef7eb2e8f9f7 349 static void uart2_irq(void)
<> 144:ef7eb2e8f9f7 350 {
<> 144:ef7eb2e8f9f7 351 uart_irq(1);
<> 144:ef7eb2e8f9f7 352 }
<> 144:ef7eb2e8f9f7 353
<> 144:ef7eb2e8f9f7 354 #if defined(USART3_BASE)
<> 144:ef7eb2e8f9f7 355 static void uart3_irq(void)
<> 144:ef7eb2e8f9f7 356 {
<> 144:ef7eb2e8f9f7 357 uart_irq(2);
<> 144:ef7eb2e8f9f7 358 }
<> 144:ef7eb2e8f9f7 359 #endif
<> 144:ef7eb2e8f9f7 360
<> 144:ef7eb2e8f9f7 361 #if defined(UART4_BASE)
<> 144:ef7eb2e8f9f7 362 static void uart4_irq(void)
<> 144:ef7eb2e8f9f7 363 {
<> 144:ef7eb2e8f9f7 364 uart_irq(3);
<> 144:ef7eb2e8f9f7 365 }
<> 144:ef7eb2e8f9f7 366 #endif
<> 144:ef7eb2e8f9f7 367
<> 144:ef7eb2e8f9f7 368 #if defined(UART5_BASE)
<> 144:ef7eb2e8f9f7 369 static void uart5_irq(void)
<> 144:ef7eb2e8f9f7 370 {
<> 144:ef7eb2e8f9f7 371 uart_irq(4);
<> 144:ef7eb2e8f9f7 372 }
<> 144:ef7eb2e8f9f7 373 #endif
<> 144:ef7eb2e8f9f7 374
<> 144:ef7eb2e8f9f7 375 #if defined(USART6_BASE)
<> 144:ef7eb2e8f9f7 376 static void uart6_irq(void)
<> 144:ef7eb2e8f9f7 377 {
<> 144:ef7eb2e8f9f7 378 uart_irq(5);
<> 144:ef7eb2e8f9f7 379 }
<> 144:ef7eb2e8f9f7 380 #endif
<> 144:ef7eb2e8f9f7 381
<> 144:ef7eb2e8f9f7 382 #if defined(UART7_BASE)
<> 144:ef7eb2e8f9f7 383 static void uart7_irq(void)
<> 144:ef7eb2e8f9f7 384 {
<> 144:ef7eb2e8f9f7 385 uart_irq(6);
<> 144:ef7eb2e8f9f7 386 }
<> 144:ef7eb2e8f9f7 387 #endif
<> 144:ef7eb2e8f9f7 388
<> 144:ef7eb2e8f9f7 389 #if defined(UART8_BASE)
<> 144:ef7eb2e8f9f7 390 static void uart8_irq(void)
<> 144:ef7eb2e8f9f7 391 {
<> 144:ef7eb2e8f9f7 392 uart_irq(7);
<> 144:ef7eb2e8f9f7 393 }
<> 144:ef7eb2e8f9f7 394 #endif
<> 144:ef7eb2e8f9f7 395
<> 144:ef7eb2e8f9f7 396 void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
<> 144:ef7eb2e8f9f7 397 {
<> 144:ef7eb2e8f9f7 398 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 399
<> 144:ef7eb2e8f9f7 400 irq_handler = handler;
<> 144:ef7eb2e8f9f7 401 serial_irq_ids[obj_s->index] = id;
<> 144:ef7eb2e8f9f7 402 }
<> 144:ef7eb2e8f9f7 403
<> 144:ef7eb2e8f9f7 404 void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
<> 144:ef7eb2e8f9f7 405 {
<> 144:ef7eb2e8f9f7 406 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 407 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 408 IRQn_Type irq_n = (IRQn_Type)0;
<> 144:ef7eb2e8f9f7 409 uint32_t vector = 0;
<> 144:ef7eb2e8f9f7 410
<> 144:ef7eb2e8f9f7 411 switch (obj_s->index) {
<> 144:ef7eb2e8f9f7 412 case 0:
<> 144:ef7eb2e8f9f7 413 irq_n = USART1_IRQn;
<> 144:ef7eb2e8f9f7 414 vector = (uint32_t)&uart1_irq;
<> 144:ef7eb2e8f9f7 415 break;
<> 144:ef7eb2e8f9f7 416
<> 144:ef7eb2e8f9f7 417 case 1:
<> 144:ef7eb2e8f9f7 418 irq_n = USART2_IRQn;
<> 144:ef7eb2e8f9f7 419 vector = (uint32_t)&uart2_irq;
<> 144:ef7eb2e8f9f7 420 break;
<> 144:ef7eb2e8f9f7 421 #if defined(USART3_BASE)
<> 144:ef7eb2e8f9f7 422 case 2:
<> 144:ef7eb2e8f9f7 423 irq_n = USART3_IRQn;
<> 144:ef7eb2e8f9f7 424 vector = (uint32_t)&uart3_irq;
<> 144:ef7eb2e8f9f7 425 break;
<> 144:ef7eb2e8f9f7 426 #endif
<> 144:ef7eb2e8f9f7 427 #if defined(UART4_BASE)
<> 144:ef7eb2e8f9f7 428 case 3:
<> 144:ef7eb2e8f9f7 429 irq_n = UART4_IRQn;
<> 144:ef7eb2e8f9f7 430 vector = (uint32_t)&uart4_irq;
<> 144:ef7eb2e8f9f7 431 break;
<> 144:ef7eb2e8f9f7 432 #endif
<> 144:ef7eb2e8f9f7 433 #if defined(UART5_BASE)
<> 144:ef7eb2e8f9f7 434 case 4:
<> 144:ef7eb2e8f9f7 435 irq_n = UART5_IRQn;
<> 144:ef7eb2e8f9f7 436 vector = (uint32_t)&uart5_irq;
<> 144:ef7eb2e8f9f7 437 break;
<> 144:ef7eb2e8f9f7 438 #endif
<> 144:ef7eb2e8f9f7 439 #if defined(USART6_BASE)
<> 144:ef7eb2e8f9f7 440 case 5:
<> 144:ef7eb2e8f9f7 441 irq_n = USART6_IRQn;
<> 144:ef7eb2e8f9f7 442 vector = (uint32_t)&uart6_irq;
<> 144:ef7eb2e8f9f7 443 break;
<> 144:ef7eb2e8f9f7 444 #endif
<> 144:ef7eb2e8f9f7 445 #if defined(UART7_BASE)
<> 144:ef7eb2e8f9f7 446 case 6:
<> 144:ef7eb2e8f9f7 447 irq_n = UART7_IRQn;
<> 144:ef7eb2e8f9f7 448 vector = (uint32_t)&uart7_irq;
<> 144:ef7eb2e8f9f7 449 break;
<> 144:ef7eb2e8f9f7 450 #endif
<> 144:ef7eb2e8f9f7 451 #if defined(UART8_BASE)
<> 144:ef7eb2e8f9f7 452 case 7:
<> 144:ef7eb2e8f9f7 453 irq_n = UART8_IRQn;
<> 144:ef7eb2e8f9f7 454 vector = (uint32_t)&uart8_irq;
<> 144:ef7eb2e8f9f7 455 break;
<> 144:ef7eb2e8f9f7 456 #endif
<> 144:ef7eb2e8f9f7 457 }
<> 144:ef7eb2e8f9f7 458
<> 144:ef7eb2e8f9f7 459 if (enable) {
<> 144:ef7eb2e8f9f7 460 if (irq == RxIrq) {
<> 144:ef7eb2e8f9f7 461 __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
<> 144:ef7eb2e8f9f7 462 } else { // TxIrq
<> 144:ef7eb2e8f9f7 463 __HAL_UART_ENABLE_IT(huart, UART_IT_TC);
<> 144:ef7eb2e8f9f7 464 }
<> 144:ef7eb2e8f9f7 465 NVIC_SetVector(irq_n, vector);
<> 144:ef7eb2e8f9f7 466 NVIC_EnableIRQ(irq_n);
<> 144:ef7eb2e8f9f7 467
<> 144:ef7eb2e8f9f7 468 } else { // disable
<> 144:ef7eb2e8f9f7 469 int all_disabled = 0;
<> 144:ef7eb2e8f9f7 470 if (irq == RxIrq) {
<> 144:ef7eb2e8f9f7 471 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
<> 144:ef7eb2e8f9f7 472 // Check if TxIrq is disabled too
<> 144:ef7eb2e8f9f7 473 if ((huart->Instance->CR1 & USART_CR1_TXEIE) == 0) {
<> 144:ef7eb2e8f9f7 474 all_disabled = 1;
<> 144:ef7eb2e8f9f7 475 }
<> 144:ef7eb2e8f9f7 476 } else { // TxIrq
<> 144:ef7eb2e8f9f7 477 __HAL_UART_DISABLE_IT(huart, UART_IT_TC);
<> 144:ef7eb2e8f9f7 478 // Check if RxIrq is disabled too
<> 144:ef7eb2e8f9f7 479 if ((huart->Instance->CR1 & USART_CR1_RXNEIE) == 0) {
<> 144:ef7eb2e8f9f7 480 all_disabled = 1;
<> 144:ef7eb2e8f9f7 481 }
<> 144:ef7eb2e8f9f7 482 }
<> 144:ef7eb2e8f9f7 483
<> 144:ef7eb2e8f9f7 484 if (all_disabled) {
<> 144:ef7eb2e8f9f7 485 NVIC_DisableIRQ(irq_n);
<> 144:ef7eb2e8f9f7 486 }
<> 144:ef7eb2e8f9f7 487 }
<> 144:ef7eb2e8f9f7 488 }
<> 144:ef7eb2e8f9f7 489
<> 144:ef7eb2e8f9f7 490 /******************************************************************************
<> 144:ef7eb2e8f9f7 491 * READ/WRITE
<> 144:ef7eb2e8f9f7 492 ******************************************************************************/
<> 144:ef7eb2e8f9f7 493
<> 144:ef7eb2e8f9f7 494 int serial_getc(serial_t *obj)
<> 144:ef7eb2e8f9f7 495 {
<> 144:ef7eb2e8f9f7 496 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 497 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 498
<> 144:ef7eb2e8f9f7 499 while (!serial_readable(obj));
<> 144:ef7eb2e8f9f7 500 return (int)(huart->Instance->DR & (uint16_t)0x1FF);
<> 144:ef7eb2e8f9f7 501 }
<> 144:ef7eb2e8f9f7 502
<> 144:ef7eb2e8f9f7 503 void serial_putc(serial_t *obj, int c)
<> 144:ef7eb2e8f9f7 504 {
<> 144:ef7eb2e8f9f7 505 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 506 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 507
<> 144:ef7eb2e8f9f7 508 while (!serial_writable(obj));
<> 144:ef7eb2e8f9f7 509 huart->Instance->DR = (uint32_t)(c & (uint16_t)0x1FF);
<> 144:ef7eb2e8f9f7 510 }
<> 144:ef7eb2e8f9f7 511
<> 144:ef7eb2e8f9f7 512 int serial_readable(serial_t *obj)
<> 144:ef7eb2e8f9f7 513 {
<> 144:ef7eb2e8f9f7 514 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 515 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 516
<> 144:ef7eb2e8f9f7 517 // Check if data is received
<> 144:ef7eb2e8f9f7 518 return (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) ? 1 : 0;
<> 144:ef7eb2e8f9f7 519 }
<> 144:ef7eb2e8f9f7 520
<> 144:ef7eb2e8f9f7 521 int serial_writable(serial_t *obj)
<> 144:ef7eb2e8f9f7 522 {
<> 144:ef7eb2e8f9f7 523 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 524 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 525
<> 144:ef7eb2e8f9f7 526 // Check if data is transmitted
<> 144:ef7eb2e8f9f7 527 return (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) ? 1 : 0;
<> 144:ef7eb2e8f9f7 528 }
<> 144:ef7eb2e8f9f7 529
<> 144:ef7eb2e8f9f7 530 void serial_clear(serial_t *obj)
<> 144:ef7eb2e8f9f7 531 {
<> 144:ef7eb2e8f9f7 532 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 533 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 534
<> 144:ef7eb2e8f9f7 535 huart->TxXferCount = 0;
<> 144:ef7eb2e8f9f7 536 huart->RxXferCount = 0;
<> 144:ef7eb2e8f9f7 537 }
<> 144:ef7eb2e8f9f7 538
<> 144:ef7eb2e8f9f7 539 void serial_pinout_tx(PinName tx)
<> 144:ef7eb2e8f9f7 540 {
<> 144:ef7eb2e8f9f7 541 pinmap_pinout(tx, PinMap_UART_TX);
<> 144:ef7eb2e8f9f7 542 }
<> 144:ef7eb2e8f9f7 543
<> 144:ef7eb2e8f9f7 544 void serial_break_set(serial_t *obj)
<> 144:ef7eb2e8f9f7 545 {
<> 144:ef7eb2e8f9f7 546 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 547 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 548
<> 144:ef7eb2e8f9f7 549 HAL_LIN_SendBreak(huart);
<> 144:ef7eb2e8f9f7 550 }
<> 144:ef7eb2e8f9f7 551
<> 144:ef7eb2e8f9f7 552 void serial_break_clear(serial_t *obj)
<> 144:ef7eb2e8f9f7 553 {
<> 144:ef7eb2e8f9f7 554 (void)obj;
<> 144:ef7eb2e8f9f7 555 }
<> 144:ef7eb2e8f9f7 556
<> 144:ef7eb2e8f9f7 557 #if DEVICE_SERIAL_ASYNCH
<> 144:ef7eb2e8f9f7 558
<> 144:ef7eb2e8f9f7 559 /******************************************************************************
<> 144:ef7eb2e8f9f7 560 * LOCAL HELPER FUNCTIONS
<> 144:ef7eb2e8f9f7 561 ******************************************************************************/
<> 144:ef7eb2e8f9f7 562
<> 144:ef7eb2e8f9f7 563 /**
<> 144:ef7eb2e8f9f7 564 * Configure the TX buffer for an asynchronous write serial transaction
<> 144:ef7eb2e8f9f7 565 *
<> 144:ef7eb2e8f9f7 566 * @param obj The serial object.
<> 144:ef7eb2e8f9f7 567 * @param tx The buffer for sending.
<> 144:ef7eb2e8f9f7 568 * @param tx_length The number of words to transmit.
<> 144:ef7eb2e8f9f7 569 */
<> 144:ef7eb2e8f9f7 570 static void serial_tx_buffer_set(serial_t *obj, void *tx, int tx_length, uint8_t width)
<> 144:ef7eb2e8f9f7 571 {
<> 144:ef7eb2e8f9f7 572 (void)width;
<> 144:ef7eb2e8f9f7 573
<> 144:ef7eb2e8f9f7 574 // Exit if a transmit is already on-going
<> 144:ef7eb2e8f9f7 575 if (serial_tx_active(obj)) {
<> 144:ef7eb2e8f9f7 576 return;
<> 144:ef7eb2e8f9f7 577 }
<> 144:ef7eb2e8f9f7 578
<> 144:ef7eb2e8f9f7 579 obj->tx_buff.buffer = tx;
<> 144:ef7eb2e8f9f7 580 obj->tx_buff.length = tx_length;
<> 144:ef7eb2e8f9f7 581 obj->tx_buff.pos = 0;
<> 144:ef7eb2e8f9f7 582 }
<> 144:ef7eb2e8f9f7 583
<> 144:ef7eb2e8f9f7 584 /**
<> 144:ef7eb2e8f9f7 585 * Configure the RX buffer for an asynchronous write serial transaction
<> 144:ef7eb2e8f9f7 586 *
<> 144:ef7eb2e8f9f7 587 * @param obj The serial object.
<> 144:ef7eb2e8f9f7 588 * @param tx The buffer for sending.
<> 144:ef7eb2e8f9f7 589 * @param tx_length The number of words to transmit.
<> 144:ef7eb2e8f9f7 590 */
<> 144:ef7eb2e8f9f7 591 static void serial_rx_buffer_set(serial_t *obj, void *rx, int rx_length, uint8_t width)
<> 144:ef7eb2e8f9f7 592 {
<> 144:ef7eb2e8f9f7 593 (void)width;
<> 144:ef7eb2e8f9f7 594
<> 144:ef7eb2e8f9f7 595 // Exit if a reception is already on-going
<> 144:ef7eb2e8f9f7 596 if (serial_rx_active(obj)) {
<> 144:ef7eb2e8f9f7 597 return;
<> 144:ef7eb2e8f9f7 598 }
<> 144:ef7eb2e8f9f7 599
<> 144:ef7eb2e8f9f7 600 obj->rx_buff.buffer = rx;
<> 144:ef7eb2e8f9f7 601 obj->rx_buff.length = rx_length;
<> 144:ef7eb2e8f9f7 602 obj->rx_buff.pos = 0;
<> 144:ef7eb2e8f9f7 603 }
<> 144:ef7eb2e8f9f7 604
<> 144:ef7eb2e8f9f7 605 /**
<> 144:ef7eb2e8f9f7 606 * Configure events
<> 144:ef7eb2e8f9f7 607 *
<> 144:ef7eb2e8f9f7 608 * @param obj The serial object
<> 144:ef7eb2e8f9f7 609 * @param event The logical OR of the events to configure
<> 144:ef7eb2e8f9f7 610 * @param enable Set to non-zero to enable events, or zero to disable them
<> 144:ef7eb2e8f9f7 611 */
<> 144:ef7eb2e8f9f7 612 static void serial_enable_event(serial_t *obj, int event, uint8_t enable)
<> 144:ef7eb2e8f9f7 613 {
<> 144:ef7eb2e8f9f7 614 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 615
<> 144:ef7eb2e8f9f7 616 // Shouldn't have to enable interrupt here, just need to keep track of the requested events.
<> 144:ef7eb2e8f9f7 617 if (enable) {
<> 144:ef7eb2e8f9f7 618 obj_s->events |= event;
<> 144:ef7eb2e8f9f7 619 } else {
<> 144:ef7eb2e8f9f7 620 obj_s->events &= ~event;
<> 144:ef7eb2e8f9f7 621 }
<> 144:ef7eb2e8f9f7 622 }
<> 144:ef7eb2e8f9f7 623
<> 144:ef7eb2e8f9f7 624
<> 144:ef7eb2e8f9f7 625 /**
<> 144:ef7eb2e8f9f7 626 * Get index of serial object TX IRQ, relating it to the physical peripheral.
<> 144:ef7eb2e8f9f7 627 *
<> 144:ef7eb2e8f9f7 628 * @param obj pointer to serial object
<> 144:ef7eb2e8f9f7 629 * @return internal NVIC TX IRQ index of U(S)ART peripheral
<> 144:ef7eb2e8f9f7 630 */
<> 144:ef7eb2e8f9f7 631 static IRQn_Type serial_get_irq_n(serial_t *obj)
<> 144:ef7eb2e8f9f7 632 {
<> 144:ef7eb2e8f9f7 633 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 634 IRQn_Type irq_n;
<> 144:ef7eb2e8f9f7 635
<> 144:ef7eb2e8f9f7 636 switch (obj_s->index) {
<> 144:ef7eb2e8f9f7 637 #if defined(USART1_BASE)
<> 144:ef7eb2e8f9f7 638 case 0:
<> 144:ef7eb2e8f9f7 639 irq_n = USART1_IRQn;
<> 144:ef7eb2e8f9f7 640 break;
<> 144:ef7eb2e8f9f7 641 #endif
<> 144:ef7eb2e8f9f7 642 #if defined(USART2_BASE)
<> 144:ef7eb2e8f9f7 643 case 1:
<> 144:ef7eb2e8f9f7 644 irq_n = USART2_IRQn;
<> 144:ef7eb2e8f9f7 645 break;
<> 144:ef7eb2e8f9f7 646 #endif
<> 144:ef7eb2e8f9f7 647 #if defined(USART3_BASE)
<> 144:ef7eb2e8f9f7 648 case 2:
<> 144:ef7eb2e8f9f7 649 irq_n = USART3_IRQn;
<> 144:ef7eb2e8f9f7 650 break;
<> 144:ef7eb2e8f9f7 651 #endif
<> 144:ef7eb2e8f9f7 652 #if defined(UART4_BASE)
<> 144:ef7eb2e8f9f7 653 case 3:
<> 144:ef7eb2e8f9f7 654 irq_n = UART4_IRQn;
<> 144:ef7eb2e8f9f7 655 break;
<> 144:ef7eb2e8f9f7 656 #endif
<> 144:ef7eb2e8f9f7 657 #if defined(UART5_BASE)
<> 144:ef7eb2e8f9f7 658 case 4:
<> 144:ef7eb2e8f9f7 659 irq_n = UART5_IRQn;
<> 144:ef7eb2e8f9f7 660 break;
<> 144:ef7eb2e8f9f7 661 #endif
<> 144:ef7eb2e8f9f7 662 #if defined(USART6_BASE)
<> 144:ef7eb2e8f9f7 663 case 5:
<> 144:ef7eb2e8f9f7 664 irq_n = USART6_IRQn;
<> 144:ef7eb2e8f9f7 665 break;
<> 144:ef7eb2e8f9f7 666 #endif
<> 144:ef7eb2e8f9f7 667 #if defined(UART7_BASE)
<> 144:ef7eb2e8f9f7 668 case 6:
<> 144:ef7eb2e8f9f7 669 irq_n = UART7_IRQn;
<> 144:ef7eb2e8f9f7 670 break;
<> 144:ef7eb2e8f9f7 671 #endif
<> 144:ef7eb2e8f9f7 672 #if defined(UART8_BASE)
<> 144:ef7eb2e8f9f7 673 case 7:
<> 144:ef7eb2e8f9f7 674 irq_n = UART8_IRQn;
<> 144:ef7eb2e8f9f7 675 break;
<> 144:ef7eb2e8f9f7 676 #endif
<> 144:ef7eb2e8f9f7 677 default:
<> 144:ef7eb2e8f9f7 678 irq_n = (IRQn_Type)0;
<> 144:ef7eb2e8f9f7 679 }
<> 144:ef7eb2e8f9f7 680
<> 144:ef7eb2e8f9f7 681 return irq_n;
<> 144:ef7eb2e8f9f7 682 }
<> 144:ef7eb2e8f9f7 683
<> 144:ef7eb2e8f9f7 684
<> 144:ef7eb2e8f9f7 685 /******************************************************************************
<> 144:ef7eb2e8f9f7 686 * MBED API FUNCTIONS
<> 144:ef7eb2e8f9f7 687 ******************************************************************************/
<> 144:ef7eb2e8f9f7 688
<> 144:ef7eb2e8f9f7 689 /**
<> 144:ef7eb2e8f9f7 690 * Begin asynchronous TX transfer. The used buffer is specified in the serial
<> 144:ef7eb2e8f9f7 691 * object, tx_buff
<> 144:ef7eb2e8f9f7 692 *
<> 144:ef7eb2e8f9f7 693 * @param obj The serial object
<> 144:ef7eb2e8f9f7 694 * @param tx The buffer for sending
<> 144:ef7eb2e8f9f7 695 * @param tx_length The number of words to transmit
<> 144:ef7eb2e8f9f7 696 * @param tx_width The bit width of buffer word
<> 144:ef7eb2e8f9f7 697 * @param handler The serial handler
<> 144:ef7eb2e8f9f7 698 * @param event The logical OR of events to be registered
<> 144:ef7eb2e8f9f7 699 * @param hint A suggestion for how to use DMA with this transfer
<> 144:ef7eb2e8f9f7 700 * @return Returns number of data transfered, or 0 otherwise
<> 144:ef7eb2e8f9f7 701 */
<> 144:ef7eb2e8f9f7 702 int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
<> 144:ef7eb2e8f9f7 703 {
<> 144:ef7eb2e8f9f7 704 // TODO: DMA usage is currently ignored
<> 144:ef7eb2e8f9f7 705 (void) hint;
<> 144:ef7eb2e8f9f7 706
<> 144:ef7eb2e8f9f7 707 // Check buffer is ok
<> 144:ef7eb2e8f9f7 708 MBED_ASSERT(tx != (void*)0);
<> 144:ef7eb2e8f9f7 709 MBED_ASSERT(tx_width == 8); // support only 8b width
<> 144:ef7eb2e8f9f7 710
<> 144:ef7eb2e8f9f7 711 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 712 UART_HandleTypeDef * huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 713
<> 144:ef7eb2e8f9f7 714 if (tx_length == 0) {
<> 144:ef7eb2e8f9f7 715 return 0;
<> 144:ef7eb2e8f9f7 716 }
<> 144:ef7eb2e8f9f7 717
<> 144:ef7eb2e8f9f7 718 // Set up buffer
<> 144:ef7eb2e8f9f7 719 serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
<> 144:ef7eb2e8f9f7 720
<> 144:ef7eb2e8f9f7 721 // Set up events
<> 144:ef7eb2e8f9f7 722 serial_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
<> 144:ef7eb2e8f9f7 723 serial_enable_event(obj, event, 1); // Set only the wanted events
<> 144:ef7eb2e8f9f7 724
<> 144:ef7eb2e8f9f7 725 // Enable interrupt
<> 144:ef7eb2e8f9f7 726 IRQn_Type irq_n = serial_get_irq_n(obj);
<> 144:ef7eb2e8f9f7 727 NVIC_ClearPendingIRQ(irq_n);
<> 144:ef7eb2e8f9f7 728 NVIC_DisableIRQ(irq_n);
<> 144:ef7eb2e8f9f7 729 NVIC_SetPriority(irq_n, 1);
<> 144:ef7eb2e8f9f7 730 NVIC_SetVector(irq_n, (uint32_t)handler);
<> 144:ef7eb2e8f9f7 731 NVIC_EnableIRQ(irq_n);
<> 144:ef7eb2e8f9f7 732
<> 144:ef7eb2e8f9f7 733 // the following function will enable UART_IT_TXE and error interrupts
<> 144:ef7eb2e8f9f7 734 if (HAL_UART_Transmit_IT(huart, (uint8_t*)tx, tx_length) != HAL_OK) {
<> 144:ef7eb2e8f9f7 735 return 0;
<> 144:ef7eb2e8f9f7 736 }
<> 144:ef7eb2e8f9f7 737
<> 144:ef7eb2e8f9f7 738 return tx_length;
<> 144:ef7eb2e8f9f7 739 }
<> 144:ef7eb2e8f9f7 740
<> 144:ef7eb2e8f9f7 741 /**
<> 144:ef7eb2e8f9f7 742 * Begin asynchronous RX transfer (enable interrupt for data collecting)
<> 144:ef7eb2e8f9f7 743 * The used buffer is specified in the serial object, rx_buff
<> 144:ef7eb2e8f9f7 744 *
<> 144:ef7eb2e8f9f7 745 * @param obj The serial object
<> 144:ef7eb2e8f9f7 746 * @param rx The buffer for sending
<> 144:ef7eb2e8f9f7 747 * @param rx_length The number of words to transmit
<> 144:ef7eb2e8f9f7 748 * @param rx_width The bit width of buffer word
<> 144:ef7eb2e8f9f7 749 * @param handler The serial handler
<> 144:ef7eb2e8f9f7 750 * @param event The logical OR of events to be registered
<> 144:ef7eb2e8f9f7 751 * @param handler The serial handler
<> 144:ef7eb2e8f9f7 752 * @param char_match A character in range 0-254 to be matched
<> 144:ef7eb2e8f9f7 753 * @param hint A suggestion for how to use DMA with this transfer
<> 144:ef7eb2e8f9f7 754 */
<> 144:ef7eb2e8f9f7 755 void serial_rx_asynch(serial_t *obj, void *rx, size_t rx_length, uint8_t rx_width, uint32_t handler, uint32_t event, uint8_t char_match, DMAUsage hint)
<> 144:ef7eb2e8f9f7 756 {
<> 144:ef7eb2e8f9f7 757 // TODO: DMA usage is currently ignored
<> 144:ef7eb2e8f9f7 758 (void) hint;
<> 144:ef7eb2e8f9f7 759
<> 144:ef7eb2e8f9f7 760 /* Sanity check arguments */
<> 144:ef7eb2e8f9f7 761 MBED_ASSERT(obj);
<> 144:ef7eb2e8f9f7 762 MBED_ASSERT(rx != (void*)0);
<> 144:ef7eb2e8f9f7 763 MBED_ASSERT(rx_width == 8); // support only 8b width
<> 144:ef7eb2e8f9f7 764
<> 144:ef7eb2e8f9f7 765 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 766 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 767
<> 144:ef7eb2e8f9f7 768 serial_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
<> 144:ef7eb2e8f9f7 769 serial_enable_event(obj, event, 1);
<> 144:ef7eb2e8f9f7 770
<> 144:ef7eb2e8f9f7 771 // set CharMatch
<> 144:ef7eb2e8f9f7 772 obj->char_match = char_match;
<> 144:ef7eb2e8f9f7 773
<> 144:ef7eb2e8f9f7 774 serial_rx_buffer_set(obj, rx, rx_length, rx_width);
<> 144:ef7eb2e8f9f7 775
<> 144:ef7eb2e8f9f7 776 IRQn_Type irq_n = serial_get_irq_n(obj);
<> 144:ef7eb2e8f9f7 777 NVIC_ClearPendingIRQ(irq_n);
<> 144:ef7eb2e8f9f7 778 NVIC_DisableIRQ(irq_n);
<> 144:ef7eb2e8f9f7 779 NVIC_SetPriority(irq_n, 0);
<> 144:ef7eb2e8f9f7 780 NVIC_SetVector(irq_n, (uint32_t)handler);
<> 144:ef7eb2e8f9f7 781 NVIC_EnableIRQ(irq_n);
<> 144:ef7eb2e8f9f7 782
<> 144:ef7eb2e8f9f7 783 // following HAL function will enable the RXNE interrupt + error interrupts
<> 144:ef7eb2e8f9f7 784 HAL_UART_Receive_IT(huart, (uint8_t*)rx, rx_length);
<> 144:ef7eb2e8f9f7 785 }
<> 144:ef7eb2e8f9f7 786
<> 144:ef7eb2e8f9f7 787 /**
<> 144:ef7eb2e8f9f7 788 * Attempts to determine if the serial peripheral is already in use for TX
<> 144:ef7eb2e8f9f7 789 *
<> 144:ef7eb2e8f9f7 790 * @param obj The serial object
<> 144:ef7eb2e8f9f7 791 * @return Non-zero if the TX transaction is ongoing, 0 otherwise
<> 144:ef7eb2e8f9f7 792 */
<> 144:ef7eb2e8f9f7 793 uint8_t serial_tx_active(serial_t *obj)
<> 144:ef7eb2e8f9f7 794 {
<> 144:ef7eb2e8f9f7 795 MBED_ASSERT(obj);
<> 144:ef7eb2e8f9f7 796
<> 144:ef7eb2e8f9f7 797 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 798 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 799
<> 144:ef7eb2e8f9f7 800 return ((HAL_UART_GetState(huart) == HAL_UART_STATE_BUSY_TX) ? 1 : 0);
<> 144:ef7eb2e8f9f7 801 }
<> 144:ef7eb2e8f9f7 802
<> 144:ef7eb2e8f9f7 803 /**
<> 144:ef7eb2e8f9f7 804 * Attempts to determine if the serial peripheral is already in use for RX
<> 144:ef7eb2e8f9f7 805 *
<> 144:ef7eb2e8f9f7 806 * @param obj The serial object
<> 144:ef7eb2e8f9f7 807 * @return Non-zero if the RX transaction is ongoing, 0 otherwise
<> 144:ef7eb2e8f9f7 808 */
<> 144:ef7eb2e8f9f7 809 uint8_t serial_rx_active(serial_t *obj)
<> 144:ef7eb2e8f9f7 810 {
<> 144:ef7eb2e8f9f7 811 MBED_ASSERT(obj);
<> 144:ef7eb2e8f9f7 812
<> 144:ef7eb2e8f9f7 813 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 814 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 815
<> 144:ef7eb2e8f9f7 816 return ((HAL_UART_GetState(huart) == HAL_UART_STATE_BUSY_RX) ? 1 : 0);
<> 144:ef7eb2e8f9f7 817 }
<> 144:ef7eb2e8f9f7 818
<> 144:ef7eb2e8f9f7 819 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
<> 144:ef7eb2e8f9f7 820 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
<> 144:ef7eb2e8f9f7 821 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
<> 144:ef7eb2e8f9f7 822 }
<> 144:ef7eb2e8f9f7 823 }
<> 144:ef7eb2e8f9f7 824
<> 144:ef7eb2e8f9f7 825 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
<> 144:ef7eb2e8f9f7 826 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
<> 144:ef7eb2e8f9f7 827 volatile uint32_t tmpval = huart->Instance->DR; // Clear PE flag
<> 144:ef7eb2e8f9f7 828 } else if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
<> 144:ef7eb2e8f9f7 829 volatile uint32_t tmpval = huart->Instance->DR; // Clear FE flag
<> 144:ef7eb2e8f9f7 830 } else if (__HAL_UART_GET_FLAG(huart, UART_FLAG_NE) != RESET) {
<> 144:ef7eb2e8f9f7 831 volatile uint32_t tmpval = huart->Instance->DR; // Clear NE flag
<> 144:ef7eb2e8f9f7 832 } else if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
<> 144:ef7eb2e8f9f7 833 volatile uint32_t tmpval = huart->Instance->DR; // Clear ORE flag
<> 144:ef7eb2e8f9f7 834 }
<> 144:ef7eb2e8f9f7 835 }
<> 144:ef7eb2e8f9f7 836
<> 144:ef7eb2e8f9f7 837 /**
<> 144:ef7eb2e8f9f7 838 * The asynchronous TX and RX handler.
<> 144:ef7eb2e8f9f7 839 *
<> 144:ef7eb2e8f9f7 840 * @param obj The serial object
<> 144:ef7eb2e8f9f7 841 * @return Returns event flags if a TX/RX transfer termination condition was met or 0 otherwise
<> 144:ef7eb2e8f9f7 842 */
<> 144:ef7eb2e8f9f7 843 int serial_irq_handler_asynch(serial_t *obj)
<> 144:ef7eb2e8f9f7 844 {
<> 144:ef7eb2e8f9f7 845 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 846 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 847
<> 144:ef7eb2e8f9f7 848 volatile int return_event = 0;
<> 144:ef7eb2e8f9f7 849 uint8_t *buf = (uint8_t*)(obj->rx_buff.buffer);
<> 144:ef7eb2e8f9f7 850 uint8_t i = 0;
<> 144:ef7eb2e8f9f7 851
<> 144:ef7eb2e8f9f7 852 // TX PART:
<> 144:ef7eb2e8f9f7 853 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
<> 144:ef7eb2e8f9f7 854 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
<> 144:ef7eb2e8f9f7 855 // Return event SERIAL_EVENT_TX_COMPLETE if requested
<> 144:ef7eb2e8f9f7 856 if ((obj_s->events & SERIAL_EVENT_TX_COMPLETE ) != 0) {
<> 144:ef7eb2e8f9f7 857 return_event |= (SERIAL_EVENT_TX_COMPLETE & obj_s->events);
<> 144:ef7eb2e8f9f7 858 }
<> 144:ef7eb2e8f9f7 859 }
<> 144:ef7eb2e8f9f7 860 }
<> 144:ef7eb2e8f9f7 861
<> 144:ef7eb2e8f9f7 862 // Handle error events
<> 144:ef7eb2e8f9f7 863 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
<> 144:ef7eb2e8f9f7 864 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
<> 144:ef7eb2e8f9f7 865 return_event |= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);
<> 144:ef7eb2e8f9f7 866 }
<> 144:ef7eb2e8f9f7 867 }
<> 144:ef7eb2e8f9f7 868
<> 144:ef7eb2e8f9f7 869 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
<> 144:ef7eb2e8f9f7 870 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
<> 144:ef7eb2e8f9f7 871 return_event |= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);
<> 144:ef7eb2e8f9f7 872 }
<> 144:ef7eb2e8f9f7 873 }
<> 144:ef7eb2e8f9f7 874
<> 144:ef7eb2e8f9f7 875 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
<> 144:ef7eb2e8f9f7 876 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
<> 144:ef7eb2e8f9f7 877 return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
<> 144:ef7eb2e8f9f7 878 }
<> 144:ef7eb2e8f9f7 879 }
<> 144:ef7eb2e8f9f7 880
<> 144:ef7eb2e8f9f7 881 HAL_UART_IRQHandler(huart);
<> 144:ef7eb2e8f9f7 882
<> 144:ef7eb2e8f9f7 883 // Abort if an error occurs
<> 144:ef7eb2e8f9f7 884 if (return_event & SERIAL_EVENT_RX_PARITY_ERROR ||
<> 144:ef7eb2e8f9f7 885 return_event & SERIAL_EVENT_RX_FRAMING_ERROR ||
<> 144:ef7eb2e8f9f7 886 return_event & SERIAL_EVENT_RX_OVERRUN_ERROR) {
<> 144:ef7eb2e8f9f7 887 return return_event;
<> 144:ef7eb2e8f9f7 888 }
<> 144:ef7eb2e8f9f7 889
<> 144:ef7eb2e8f9f7 890 //RX PART
<> 144:ef7eb2e8f9f7 891 if (huart->RxXferSize != 0) {
<> 144:ef7eb2e8f9f7 892 obj->rx_buff.pos = huart->RxXferSize - huart->RxXferCount;
<> 144:ef7eb2e8f9f7 893 }
<> 144:ef7eb2e8f9f7 894 if ((huart->RxXferCount == 0) && (obj->rx_buff.pos >= (obj->rx_buff.length - 1))) {
<> 144:ef7eb2e8f9f7 895 return_event |= (SERIAL_EVENT_RX_COMPLETE & obj_s->events);
<> 144:ef7eb2e8f9f7 896 }
<> 144:ef7eb2e8f9f7 897
<> 144:ef7eb2e8f9f7 898 // Check if char_match is present
<> 144:ef7eb2e8f9f7 899 if (obj_s->events & SERIAL_EVENT_RX_CHARACTER_MATCH) {
<> 144:ef7eb2e8f9f7 900 if (buf != NULL) {
<> 144:ef7eb2e8f9f7 901 for (i = 0; i < obj->rx_buff.pos; i++) {
<> 144:ef7eb2e8f9f7 902 if (buf[i] == obj->char_match) {
<> 144:ef7eb2e8f9f7 903 obj->rx_buff.pos = i;
<> 144:ef7eb2e8f9f7 904 return_event |= (SERIAL_EVENT_RX_CHARACTER_MATCH & obj_s->events);
<> 144:ef7eb2e8f9f7 905 serial_rx_abort_asynch(obj);
<> 144:ef7eb2e8f9f7 906 break;
<> 144:ef7eb2e8f9f7 907 }
<> 144:ef7eb2e8f9f7 908 }
<> 144:ef7eb2e8f9f7 909 }
<> 144:ef7eb2e8f9f7 910 }
<> 144:ef7eb2e8f9f7 911
<> 144:ef7eb2e8f9f7 912 return return_event;
<> 144:ef7eb2e8f9f7 913 }
<> 144:ef7eb2e8f9f7 914
<> 144:ef7eb2e8f9f7 915 /**
<> 144:ef7eb2e8f9f7 916 * Abort the ongoing TX transaction. It disables the enabled interupt for TX and
<> 144:ef7eb2e8f9f7 917 * flush TX hardware buffer if TX FIFO is used
<> 144:ef7eb2e8f9f7 918 *
<> 144:ef7eb2e8f9f7 919 * @param obj The serial object
<> 144:ef7eb2e8f9f7 920 */
<> 144:ef7eb2e8f9f7 921 void serial_tx_abort_asynch(serial_t *obj)
<> 144:ef7eb2e8f9f7 922 {
<> 144:ef7eb2e8f9f7 923 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 924 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 925
<> 144:ef7eb2e8f9f7 926 __HAL_UART_DISABLE_IT(huart, UART_IT_TC);
<> 144:ef7eb2e8f9f7 927 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
<> 144:ef7eb2e8f9f7 928
<> 144:ef7eb2e8f9f7 929 // clear flags
<> 144:ef7eb2e8f9f7 930 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
<> 144:ef7eb2e8f9f7 931
<> 144:ef7eb2e8f9f7 932 // reset states
<> 144:ef7eb2e8f9f7 933 huart->TxXferCount = 0;
<> 144:ef7eb2e8f9f7 934 // update handle state
<> 144:ef7eb2e8f9f7 935 if(huart->gState == HAL_UART_STATE_BUSY_TX_RX) {
<> 144:ef7eb2e8f9f7 936 huart->gState = HAL_UART_STATE_BUSY_RX;
<> 144:ef7eb2e8f9f7 937 } else {
<> 144:ef7eb2e8f9f7 938 huart->gState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 939 }
<> 144:ef7eb2e8f9f7 940 }
<> 144:ef7eb2e8f9f7 941
<> 144:ef7eb2e8f9f7 942 /**
<> 144:ef7eb2e8f9f7 943 * Abort the ongoing RX transaction It disables the enabled interrupt for RX and
<> 144:ef7eb2e8f9f7 944 * flush RX hardware buffer if RX FIFO is used
<> 144:ef7eb2e8f9f7 945 *
<> 144:ef7eb2e8f9f7 946 * @param obj The serial object
<> 144:ef7eb2e8f9f7 947 */
<> 144:ef7eb2e8f9f7 948 void serial_rx_abort_asynch(serial_t *obj)
<> 144:ef7eb2e8f9f7 949 {
<> 144:ef7eb2e8f9f7 950 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 951 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
<> 144:ef7eb2e8f9f7 952
<> 144:ef7eb2e8f9f7 953 // disable interrupts
<> 144:ef7eb2e8f9f7 954 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
<> 144:ef7eb2e8f9f7 955 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
<> 144:ef7eb2e8f9f7 956 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
<> 144:ef7eb2e8f9f7 957
<> 144:ef7eb2e8f9f7 958 // clear flags
<> 144:ef7eb2e8f9f7 959 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
<> 144:ef7eb2e8f9f7 960 volatile uint32_t tmpval = huart->Instance->DR; // Clear error flags
<> 144:ef7eb2e8f9f7 961
<> 144:ef7eb2e8f9f7 962 // reset states
<> 144:ef7eb2e8f9f7 963 huart->RxXferCount = 0;
<> 144:ef7eb2e8f9f7 964 // update handle state
<> 144:ef7eb2e8f9f7 965 if(huart->RxState == HAL_UART_STATE_BUSY_TX_RX) {
<> 144:ef7eb2e8f9f7 966 huart->RxState = HAL_UART_STATE_BUSY_TX;
<> 144:ef7eb2e8f9f7 967 } else {
<> 144:ef7eb2e8f9f7 968 huart->RxState = HAL_UART_STATE_READY;
<> 144:ef7eb2e8f9f7 969 }
<> 144:ef7eb2e8f9f7 970 }
<> 144:ef7eb2e8f9f7 971
<> 144:ef7eb2e8f9f7 972 #endif
<> 144:ef7eb2e8f9f7 973
<> 144:ef7eb2e8f9f7 974 #if DEVICE_SERIAL_FC
<> 144:ef7eb2e8f9f7 975
<> 144:ef7eb2e8f9f7 976 /**
<> 144:ef7eb2e8f9f7 977 * Set HW Control Flow
<> 144:ef7eb2e8f9f7 978 * @param obj The serial object
<> 144:ef7eb2e8f9f7 979 * @param type The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS)
<> 144:ef7eb2e8f9f7 980 * @param rxflow Pin for the rxflow
<> 144:ef7eb2e8f9f7 981 * @param txflow Pin for the txflow
<> 144:ef7eb2e8f9f7 982 */
<> 144:ef7eb2e8f9f7 983 void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
<> 144:ef7eb2e8f9f7 984 {
<> 144:ef7eb2e8f9f7 985 struct serial_s *obj_s = SERIAL_S(obj);
<> 144:ef7eb2e8f9f7 986
<> 144:ef7eb2e8f9f7 987 // Determine the UART to use (UART_1, UART_2, ...)
<> 144:ef7eb2e8f9f7 988 UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS);
<> 144:ef7eb2e8f9f7 989 UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS);
<> 144:ef7eb2e8f9f7 990
<> 144:ef7eb2e8f9f7 991 // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object
<> 144:ef7eb2e8f9f7 992 obj_s->uart = (UARTName)pinmap_merge(uart_cts, uart_rts);
<> 144:ef7eb2e8f9f7 993 MBED_ASSERT(obj_s->uart != (UARTName)NC);
<> 144:ef7eb2e8f9f7 994
<> 144:ef7eb2e8f9f7 995 if(type == FlowControlNone) {
<> 144:ef7eb2e8f9f7 996 // Disable hardware flow control
<> 144:ef7eb2e8f9f7 997 obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
<> 144:ef7eb2e8f9f7 998 }
<> 144:ef7eb2e8f9f7 999 if (type == FlowControlRTS) {
<> 144:ef7eb2e8f9f7 1000 // Enable RTS
<> 144:ef7eb2e8f9f7 1001 MBED_ASSERT(uart_rts != (UARTName)NC);
<> 144:ef7eb2e8f9f7 1002 obj_s->hw_flow_ctl = UART_HWCONTROL_RTS;
<> 144:ef7eb2e8f9f7 1003 obj_s->pin_rts = rxflow;
<> 144:ef7eb2e8f9f7 1004 // Enable the pin for RTS function
<> 144:ef7eb2e8f9f7 1005 pinmap_pinout(rxflow, PinMap_UART_RTS);
<> 144:ef7eb2e8f9f7 1006 }
<> 144:ef7eb2e8f9f7 1007 if (type == FlowControlCTS) {
<> 144:ef7eb2e8f9f7 1008 // Enable CTS
<> 144:ef7eb2e8f9f7 1009 MBED_ASSERT(uart_cts != (UARTName)NC);
<> 144:ef7eb2e8f9f7 1010 obj_s->hw_flow_ctl = UART_HWCONTROL_CTS;
<> 144:ef7eb2e8f9f7 1011 obj_s->pin_cts = txflow;
<> 144:ef7eb2e8f9f7 1012 // Enable the pin for CTS function
<> 144:ef7eb2e8f9f7 1013 pinmap_pinout(txflow, PinMap_UART_CTS);
<> 144:ef7eb2e8f9f7 1014 }
<> 144:ef7eb2e8f9f7 1015 if (type == FlowControlRTSCTS) {
<> 144:ef7eb2e8f9f7 1016 // Enable CTS & RTS
<> 144:ef7eb2e8f9f7 1017 MBED_ASSERT(uart_rts != (UARTName)NC);
<> 144:ef7eb2e8f9f7 1018 MBED_ASSERT(uart_cts != (UARTName)NC);
<> 144:ef7eb2e8f9f7 1019 obj_s->hw_flow_ctl = UART_HWCONTROL_RTS_CTS;
<> 144:ef7eb2e8f9f7 1020 obj_s->pin_rts = rxflow;
<> 144:ef7eb2e8f9f7 1021 obj_s->pin_cts = txflow;
<> 144:ef7eb2e8f9f7 1022 // Enable the pin for CTS function
<> 144:ef7eb2e8f9f7 1023 pinmap_pinout(txflow, PinMap_UART_CTS);
<> 144:ef7eb2e8f9f7 1024 // Enable the pin for RTS function
<> 144:ef7eb2e8f9f7 1025 pinmap_pinout(rxflow, PinMap_UART_RTS);
<> 144:ef7eb2e8f9f7 1026 }
<> 144:ef7eb2e8f9f7 1027
<> 144:ef7eb2e8f9f7 1028 init_uart(obj);
<> 144:ef7eb2e8f9f7 1029 }
<> 144:ef7eb2e8f9f7 1030
<> 144:ef7eb2e8f9f7 1031 #endif
<> 144:ef7eb2e8f9f7 1032
<> 144:ef7eb2e8f9f7 1033 #endif