EL4121 Embedded System / mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

targets/TARGET_STM/TARGET_STM32F7/serial_device.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

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