Denislam Valeev / Mbed OS Nucleo_rtos_basic

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.

mbed-os/targets/TARGET_STM/TARGET_STM32F1/serial_device.c@0:e056ac8fecf8, 2018-03-13 (annotated)

Committer:
valeyev
Date:
Tue Mar 13 07:17:50 2018 +0000
Revision:
0:e056ac8fecf8
looking for...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
valeyev 0:e056ac8fecf8 1 /* mbed Microcontroller Library
valeyev 0:e056ac8fecf8 2 *******************************************************************************
valeyev 0:e056ac8fecf8 3 * Copyright (c) 2017, STMicroelectronics
valeyev 0:e056ac8fecf8 4 * All rights reserved.
valeyev 0:e056ac8fecf8 5 *
valeyev 0:e056ac8fecf8 6 * Redistribution and use in source and binary forms, with or without
valeyev 0:e056ac8fecf8 7 * modification, are permitted provided that the following conditions are met:
valeyev 0:e056ac8fecf8 8 *
valeyev 0:e056ac8fecf8 9 * 1. Redistributions of source code must retain the above copyright notice,
valeyev 0:e056ac8fecf8 10 * this list of conditions and the following disclaimer.
valeyev 0:e056ac8fecf8 11 * 2. Redistributions in binary form must reproduce the above copyright notice,
valeyev 0:e056ac8fecf8 12 * this list of conditions and the following disclaimer in the documentation
valeyev 0:e056ac8fecf8 13 * and/or other materials provided with the distribution.
valeyev 0:e056ac8fecf8 14 * 3. Neither the name of STMicroelectronics nor the names of its contributors
valeyev 0:e056ac8fecf8 15 * may be used to endorse or promote products derived from this software
valeyev 0:e056ac8fecf8 16 * without specific prior written permission.
valeyev 0:e056ac8fecf8 17 *
valeyev 0:e056ac8fecf8 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
valeyev 0:e056ac8fecf8 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
valeyev 0:e056ac8fecf8 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
valeyev 0:e056ac8fecf8 21 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
valeyev 0:e056ac8fecf8 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
valeyev 0:e056ac8fecf8 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
valeyev 0:e056ac8fecf8 24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
valeyev 0:e056ac8fecf8 25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
valeyev 0:e056ac8fecf8 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
valeyev 0:e056ac8fecf8 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
valeyev 0:e056ac8fecf8 28 *******************************************************************************
valeyev 0:e056ac8fecf8 29 */
valeyev 0:e056ac8fecf8 30
valeyev 0:e056ac8fecf8 31 #if DEVICE_SERIAL
valeyev 0:e056ac8fecf8 32
valeyev 0:e056ac8fecf8 33 #include "serial_api_hal.h"
valeyev 0:e056ac8fecf8 34
valeyev 0:e056ac8fecf8 35 #define UART_NUM (3)
valeyev 0:e056ac8fecf8 36
valeyev 0:e056ac8fecf8 37 uint32_t serial_irq_ids[UART_NUM] = {0};
valeyev 0:e056ac8fecf8 38 UART_HandleTypeDef uart_handlers[UART_NUM];
valeyev 0:e056ac8fecf8 39
valeyev 0:e056ac8fecf8 40 static uart_irq_handler irq_handler;
valeyev 0:e056ac8fecf8 41
valeyev 0:e056ac8fecf8 42 // Defined in serial_api.c
valeyev 0:e056ac8fecf8 43 inline int8_t get_uart_index(UARTName uart_name);
valeyev 0:e056ac8fecf8 44
valeyev 0:e056ac8fecf8 45 /******************************************************************************
valeyev 0:e056ac8fecf8 46 * INTERRUPTS HANDLING
valeyev 0:e056ac8fecf8 47 ******************************************************************************/
valeyev 0:e056ac8fecf8 48
valeyev 0:e056ac8fecf8 49 static void uart_irq(UARTName uart_name)
valeyev 0:e056ac8fecf8 50 {
valeyev 0:e056ac8fecf8 51 int8_t id = get_uart_index(uart_name);
valeyev 0:e056ac8fecf8 52
valeyev 0:e056ac8fecf8 53 if (id >= 0) {
valeyev 0:e056ac8fecf8 54 UART_HandleTypeDef * huart = &uart_handlers[id];
valeyev 0:e056ac8fecf8 55 if (serial_irq_ids[id] != 0) {
valeyev 0:e056ac8fecf8 56 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TXE) != RESET) {
valeyev 0:e056ac8fecf8 57 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TXE) != RESET) {
valeyev 0:e056ac8fecf8 58 irq_handler(serial_irq_ids[id], TxIrq);
valeyev 0:e056ac8fecf8 59 }
valeyev 0:e056ac8fecf8 60 }
valeyev 0:e056ac8fecf8 61 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) {
valeyev 0:e056ac8fecf8 62 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_RXNE) != RESET) {
valeyev 0:e056ac8fecf8 63 irq_handler(serial_irq_ids[id], RxIrq);
valeyev 0:e056ac8fecf8 64 /* Flag has been cleared when reading the content */
valeyev 0:e056ac8fecf8 65 }
valeyev 0:e056ac8fecf8 66 }
valeyev 0:e056ac8fecf8 67 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
valeyev 0:e056ac8fecf8 68 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_ERR) != RESET) {
valeyev 0:e056ac8fecf8 69 volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear ORE flag
valeyev 0:e056ac8fecf8 70 }
valeyev 0:e056ac8fecf8 71 }
valeyev 0:e056ac8fecf8 72 }
valeyev 0:e056ac8fecf8 73 }
valeyev 0:e056ac8fecf8 74 }
valeyev 0:e056ac8fecf8 75
valeyev 0:e056ac8fecf8 76 #if defined(USART1_BASE)
valeyev 0:e056ac8fecf8 77 static void uart1_irq(void)
valeyev 0:e056ac8fecf8 78 {
valeyev 0:e056ac8fecf8 79 uart_irq(UART_1);
valeyev 0:e056ac8fecf8 80 }
valeyev 0:e056ac8fecf8 81 #endif
valeyev 0:e056ac8fecf8 82
valeyev 0:e056ac8fecf8 83 #if defined(USART2_BASE)
valeyev 0:e056ac8fecf8 84 static void uart2_irq(void)
valeyev 0:e056ac8fecf8 85 {
valeyev 0:e056ac8fecf8 86 uart_irq(UART_2);
valeyev 0:e056ac8fecf8 87 }
valeyev 0:e056ac8fecf8 88 #endif
valeyev 0:e056ac8fecf8 89
valeyev 0:e056ac8fecf8 90 #if defined(USART3_BASE)
valeyev 0:e056ac8fecf8 91 static void uart3_irq(void)
valeyev 0:e056ac8fecf8 92 {
valeyev 0:e056ac8fecf8 93 uart_irq(UART_3);
valeyev 0:e056ac8fecf8 94 }
valeyev 0:e056ac8fecf8 95 #endif
valeyev 0:e056ac8fecf8 96
valeyev 0:e056ac8fecf8 97 void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
valeyev 0:e056ac8fecf8 98 {
valeyev 0:e056ac8fecf8 99 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 100
valeyev 0:e056ac8fecf8 101 irq_handler = handler;
valeyev 0:e056ac8fecf8 102 serial_irq_ids[obj_s->index] = id;
valeyev 0:e056ac8fecf8 103 }
valeyev 0:e056ac8fecf8 104
valeyev 0:e056ac8fecf8 105 void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
valeyev 0:e056ac8fecf8 106 {
valeyev 0:e056ac8fecf8 107 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 108 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 109 IRQn_Type irq_n = (IRQn_Type)0;
valeyev 0:e056ac8fecf8 110 uint32_t vector = 0;
valeyev 0:e056ac8fecf8 111
valeyev 0:e056ac8fecf8 112 #if defined(USART1_BASE)
valeyev 0:e056ac8fecf8 113 if (obj_s->uart == UART_1) {
valeyev 0:e056ac8fecf8 114 irq_n = USART1_IRQn;
valeyev 0:e056ac8fecf8 115 vector = (uint32_t)&uart1_irq;
valeyev 0:e056ac8fecf8 116 }
valeyev 0:e056ac8fecf8 117 #endif
valeyev 0:e056ac8fecf8 118
valeyev 0:e056ac8fecf8 119 #if defined(USART2_BASE)
valeyev 0:e056ac8fecf8 120 if (obj_s->uart == UART_2) {
valeyev 0:e056ac8fecf8 121 irq_n = USART2_IRQn;
valeyev 0:e056ac8fecf8 122 vector = (uint32_t)&uart2_irq;
valeyev 0:e056ac8fecf8 123 }
valeyev 0:e056ac8fecf8 124 #endif
valeyev 0:e056ac8fecf8 125
valeyev 0:e056ac8fecf8 126 #if defined(USART3_BASE)
valeyev 0:e056ac8fecf8 127 if (obj_s->uart == UART_3) {
valeyev 0:e056ac8fecf8 128 irq_n = USART3_IRQn;
valeyev 0:e056ac8fecf8 129 vector = (uint32_t)&uart3_irq;
valeyev 0:e056ac8fecf8 130 }
valeyev 0:e056ac8fecf8 131 #endif
valeyev 0:e056ac8fecf8 132
valeyev 0:e056ac8fecf8 133 if (enable) {
valeyev 0:e056ac8fecf8 134 if (irq == RxIrq) {
valeyev 0:e056ac8fecf8 135 __HAL_UART_ENABLE_IT(huart, UART_IT_RXNE);
valeyev 0:e056ac8fecf8 136 } else { // TxIrq
valeyev 0:e056ac8fecf8 137 __HAL_UART_ENABLE_IT(huart, UART_IT_TXE);
valeyev 0:e056ac8fecf8 138 }
valeyev 0:e056ac8fecf8 139 NVIC_SetVector(irq_n, vector);
valeyev 0:e056ac8fecf8 140 NVIC_EnableIRQ(irq_n);
valeyev 0:e056ac8fecf8 141
valeyev 0:e056ac8fecf8 142 } else { // disable
valeyev 0:e056ac8fecf8 143 int all_disabled = 0;
valeyev 0:e056ac8fecf8 144 if (irq == RxIrq) {
valeyev 0:e056ac8fecf8 145 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
valeyev 0:e056ac8fecf8 146 // Check if TxIrq is disabled too
valeyev 0:e056ac8fecf8 147 if ((huart->Instance->CR1 & USART_CR1_TXEIE) == 0) {
valeyev 0:e056ac8fecf8 148 all_disabled = 1;
valeyev 0:e056ac8fecf8 149 }
valeyev 0:e056ac8fecf8 150 } else { // TxIrq
valeyev 0:e056ac8fecf8 151 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
valeyev 0:e056ac8fecf8 152 // Check if RxIrq is disabled too
valeyev 0:e056ac8fecf8 153 if ((huart->Instance->CR1 & USART_CR1_RXNEIE) == 0) {
valeyev 0:e056ac8fecf8 154 all_disabled = 1;
valeyev 0:e056ac8fecf8 155 }
valeyev 0:e056ac8fecf8 156 }
valeyev 0:e056ac8fecf8 157
valeyev 0:e056ac8fecf8 158 if (all_disabled) {
valeyev 0:e056ac8fecf8 159 NVIC_DisableIRQ(irq_n);
valeyev 0:e056ac8fecf8 160 }
valeyev 0:e056ac8fecf8 161 }
valeyev 0:e056ac8fecf8 162 }
valeyev 0:e056ac8fecf8 163
valeyev 0:e056ac8fecf8 164 /******************************************************************************
valeyev 0:e056ac8fecf8 165 * READ/WRITE
valeyev 0:e056ac8fecf8 166 ******************************************************************************/
valeyev 0:e056ac8fecf8 167
valeyev 0:e056ac8fecf8 168 int serial_getc(serial_t *obj)
valeyev 0:e056ac8fecf8 169 {
valeyev 0:e056ac8fecf8 170 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 171 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 172
valeyev 0:e056ac8fecf8 173 while (!serial_readable(obj));
valeyev 0:e056ac8fecf8 174 if (obj_s->databits == UART_WORDLENGTH_8B) {
valeyev 0:e056ac8fecf8 175 return (int)(huart->Instance->DR & (uint8_t)0xFF);
valeyev 0:e056ac8fecf8 176 } else {
valeyev 0:e056ac8fecf8 177 return (int)(huart->Instance->DR & (uint16_t)0x1FF);
valeyev 0:e056ac8fecf8 178 }
valeyev 0:e056ac8fecf8 179 }
valeyev 0:e056ac8fecf8 180
valeyev 0:e056ac8fecf8 181 void serial_putc(serial_t *obj, int c)
valeyev 0:e056ac8fecf8 182 {
valeyev 0:e056ac8fecf8 183 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 184 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 185
valeyev 0:e056ac8fecf8 186 while (!serial_writable(obj));
valeyev 0:e056ac8fecf8 187 if (obj_s->databits == UART_WORDLENGTH_8B) {
valeyev 0:e056ac8fecf8 188 huart->Instance->DR = (uint8_t)(c & (uint8_t)0xFF);
valeyev 0:e056ac8fecf8 189 } else {
valeyev 0:e056ac8fecf8 190 huart->Instance->DR = (uint16_t)(c & (uint16_t)0x1FF);
valeyev 0:e056ac8fecf8 191 }
valeyev 0:e056ac8fecf8 192 }
valeyev 0:e056ac8fecf8 193
valeyev 0:e056ac8fecf8 194 void serial_clear(serial_t *obj)
valeyev 0:e056ac8fecf8 195 {
valeyev 0:e056ac8fecf8 196 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 197 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 198
valeyev 0:e056ac8fecf8 199 huart->TxXferCount = 0;
valeyev 0:e056ac8fecf8 200 huart->RxXferCount = 0;
valeyev 0:e056ac8fecf8 201 }
valeyev 0:e056ac8fecf8 202
valeyev 0:e056ac8fecf8 203 void serial_break_set(serial_t *obj)
valeyev 0:e056ac8fecf8 204 {
valeyev 0:e056ac8fecf8 205 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 206 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 207
valeyev 0:e056ac8fecf8 208 HAL_LIN_SendBreak(huart);
valeyev 0:e056ac8fecf8 209 }
valeyev 0:e056ac8fecf8 210
valeyev 0:e056ac8fecf8 211 #if DEVICE_SERIAL_ASYNCH
valeyev 0:e056ac8fecf8 212
valeyev 0:e056ac8fecf8 213 /******************************************************************************
valeyev 0:e056ac8fecf8 214 * LOCAL HELPER FUNCTIONS
valeyev 0:e056ac8fecf8 215 ******************************************************************************/
valeyev 0:e056ac8fecf8 216
valeyev 0:e056ac8fecf8 217 /**
valeyev 0:e056ac8fecf8 218 * Configure the TX buffer for an asynchronous write serial transaction
valeyev 0:e056ac8fecf8 219 *
valeyev 0:e056ac8fecf8 220 * @param obj The serial object.
valeyev 0:e056ac8fecf8 221 * @param tx The buffer for sending.
valeyev 0:e056ac8fecf8 222 * @param tx_length The number of words to transmit.
valeyev 0:e056ac8fecf8 223 */
valeyev 0:e056ac8fecf8 224 static void serial_tx_buffer_set(serial_t *obj, void *tx, int tx_length, uint8_t width)
valeyev 0:e056ac8fecf8 225 {
valeyev 0:e056ac8fecf8 226 (void)width;
valeyev 0:e056ac8fecf8 227
valeyev 0:e056ac8fecf8 228 // Exit if a transmit is already on-going
valeyev 0:e056ac8fecf8 229 if (serial_tx_active(obj)) {
valeyev 0:e056ac8fecf8 230 return;
valeyev 0:e056ac8fecf8 231 }
valeyev 0:e056ac8fecf8 232
valeyev 0:e056ac8fecf8 233 obj->tx_buff.buffer = tx;
valeyev 0:e056ac8fecf8 234 obj->tx_buff.length = tx_length;
valeyev 0:e056ac8fecf8 235 obj->tx_buff.pos = 0;
valeyev 0:e056ac8fecf8 236 }
valeyev 0:e056ac8fecf8 237
valeyev 0:e056ac8fecf8 238 /**
valeyev 0:e056ac8fecf8 239 * Configure the RX buffer for an asynchronous write serial transaction
valeyev 0:e056ac8fecf8 240 *
valeyev 0:e056ac8fecf8 241 * @param obj The serial object.
valeyev 0:e056ac8fecf8 242 * @param tx The buffer for sending.
valeyev 0:e056ac8fecf8 243 * @param tx_length The number of words to transmit.
valeyev 0:e056ac8fecf8 244 */
valeyev 0:e056ac8fecf8 245 static void serial_rx_buffer_set(serial_t *obj, void *rx, int rx_length, uint8_t width)
valeyev 0:e056ac8fecf8 246 {
valeyev 0:e056ac8fecf8 247 (void)width;
valeyev 0:e056ac8fecf8 248
valeyev 0:e056ac8fecf8 249 // Exit if a reception is already on-going
valeyev 0:e056ac8fecf8 250 if (serial_rx_active(obj)) {
valeyev 0:e056ac8fecf8 251 return;
valeyev 0:e056ac8fecf8 252 }
valeyev 0:e056ac8fecf8 253
valeyev 0:e056ac8fecf8 254 obj->rx_buff.buffer = rx;
valeyev 0:e056ac8fecf8 255 obj->rx_buff.length = rx_length;
valeyev 0:e056ac8fecf8 256 obj->rx_buff.pos = 0;
valeyev 0:e056ac8fecf8 257 }
valeyev 0:e056ac8fecf8 258
valeyev 0:e056ac8fecf8 259 /**
valeyev 0:e056ac8fecf8 260 * Configure events
valeyev 0:e056ac8fecf8 261 *
valeyev 0:e056ac8fecf8 262 * @param obj The serial object
valeyev 0:e056ac8fecf8 263 * @param event The logical OR of the events to configure
valeyev 0:e056ac8fecf8 264 * @param enable Set to non-zero to enable events, or zero to disable them
valeyev 0:e056ac8fecf8 265 */
valeyev 0:e056ac8fecf8 266 static void serial_enable_event(serial_t *obj, int event, uint8_t enable)
valeyev 0:e056ac8fecf8 267 {
valeyev 0:e056ac8fecf8 268 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 269
valeyev 0:e056ac8fecf8 270 // Shouldn't have to enable interrupt here, just need to keep track of the requested events.
valeyev 0:e056ac8fecf8 271 if (enable) {
valeyev 0:e056ac8fecf8 272 obj_s->events |= event;
valeyev 0:e056ac8fecf8 273 } else {
valeyev 0:e056ac8fecf8 274 obj_s->events &= ~event;
valeyev 0:e056ac8fecf8 275 }
valeyev 0:e056ac8fecf8 276 }
valeyev 0:e056ac8fecf8 277
valeyev 0:e056ac8fecf8 278
valeyev 0:e056ac8fecf8 279 /**
valeyev 0:e056ac8fecf8 280 * Get index of serial object TX IRQ, relating it to the physical peripheral.
valeyev 0:e056ac8fecf8 281 *
valeyev 0:e056ac8fecf8 282 * @param uart_name i.e. UART_1, UART_2, ...
valeyev 0:e056ac8fecf8 283 * @return internal NVIC TX IRQ index of U(S)ART peripheral
valeyev 0:e056ac8fecf8 284 */
valeyev 0:e056ac8fecf8 285 static IRQn_Type serial_get_irq_n(UARTName uart_name)
valeyev 0:e056ac8fecf8 286 {
valeyev 0:e056ac8fecf8 287 IRQn_Type irq_n;
valeyev 0:e056ac8fecf8 288
valeyev 0:e056ac8fecf8 289 switch (uart_name) {
valeyev 0:e056ac8fecf8 290 #if defined(USART1_BASE)
valeyev 0:e056ac8fecf8 291 case UART_1:
valeyev 0:e056ac8fecf8 292 irq_n = USART1_IRQn;
valeyev 0:e056ac8fecf8 293 break;
valeyev 0:e056ac8fecf8 294 #endif
valeyev 0:e056ac8fecf8 295 #if defined(USART2_BASE)
valeyev 0:e056ac8fecf8 296 case UART_2:
valeyev 0:e056ac8fecf8 297 irq_n = USART2_IRQn;
valeyev 0:e056ac8fecf8 298 break;
valeyev 0:e056ac8fecf8 299 #endif
valeyev 0:e056ac8fecf8 300 #if defined(USART3_BASE)
valeyev 0:e056ac8fecf8 301 case UART_3:
valeyev 0:e056ac8fecf8 302 irq_n = USART3_IRQn;
valeyev 0:e056ac8fecf8 303 break;
valeyev 0:e056ac8fecf8 304 #endif
valeyev 0:e056ac8fecf8 305 default:
valeyev 0:e056ac8fecf8 306 irq_n = (IRQn_Type)0;
valeyev 0:e056ac8fecf8 307 }
valeyev 0:e056ac8fecf8 308
valeyev 0:e056ac8fecf8 309 return irq_n;
valeyev 0:e056ac8fecf8 310 }
valeyev 0:e056ac8fecf8 311
valeyev 0:e056ac8fecf8 312 /******************************************************************************
valeyev 0:e056ac8fecf8 313 * MBED API FUNCTIONS
valeyev 0:e056ac8fecf8 314 ******************************************************************************/
valeyev 0:e056ac8fecf8 315
valeyev 0:e056ac8fecf8 316 /**
valeyev 0:e056ac8fecf8 317 * Begin asynchronous TX transfer. The used buffer is specified in the serial
valeyev 0:e056ac8fecf8 318 * object, tx_buff
valeyev 0:e056ac8fecf8 319 *
valeyev 0:e056ac8fecf8 320 * @param obj The serial object
valeyev 0:e056ac8fecf8 321 * @param tx The buffer for sending
valeyev 0:e056ac8fecf8 322 * @param tx_length The number of words to transmit
valeyev 0:e056ac8fecf8 323 * @param tx_width The bit width of buffer word
valeyev 0:e056ac8fecf8 324 * @param handler The serial handler
valeyev 0:e056ac8fecf8 325 * @param event The logical OR of events to be registered
valeyev 0:e056ac8fecf8 326 * @param hint A suggestion for how to use DMA with this transfer
valeyev 0:e056ac8fecf8 327 * @return Returns number of data transfered, or 0 otherwise
valeyev 0:e056ac8fecf8 328 */
valeyev 0:e056ac8fecf8 329 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)
valeyev 0:e056ac8fecf8 330 {
valeyev 0:e056ac8fecf8 331 // TODO: DMA usage is currently ignored
valeyev 0:e056ac8fecf8 332 (void) hint;
valeyev 0:e056ac8fecf8 333
valeyev 0:e056ac8fecf8 334 // Check buffer is ok
valeyev 0:e056ac8fecf8 335 MBED_ASSERT(tx != (void*)0);
valeyev 0:e056ac8fecf8 336 MBED_ASSERT(tx_width == 8); // support only 8b width
valeyev 0:e056ac8fecf8 337
valeyev 0:e056ac8fecf8 338 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 339 UART_HandleTypeDef * huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 340
valeyev 0:e056ac8fecf8 341 if (tx_length == 0) {
valeyev 0:e056ac8fecf8 342 return 0;
valeyev 0:e056ac8fecf8 343 }
valeyev 0:e056ac8fecf8 344
valeyev 0:e056ac8fecf8 345 // Set up buffer
valeyev 0:e056ac8fecf8 346 serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
valeyev 0:e056ac8fecf8 347
valeyev 0:e056ac8fecf8 348 // Set up events
valeyev 0:e056ac8fecf8 349 serial_enable_event(obj, SERIAL_EVENT_TX_ALL, 0); // Clear all events
valeyev 0:e056ac8fecf8 350 serial_enable_event(obj, event, 1); // Set only the wanted events
valeyev 0:e056ac8fecf8 351
valeyev 0:e056ac8fecf8 352 // Enable interrupt
valeyev 0:e056ac8fecf8 353 IRQn_Type irq_n = serial_get_irq_n(obj_s->uart);
valeyev 0:e056ac8fecf8 354 NVIC_ClearPendingIRQ(irq_n);
valeyev 0:e056ac8fecf8 355 NVIC_DisableIRQ(irq_n);
valeyev 0:e056ac8fecf8 356 NVIC_SetPriority(irq_n, 1);
valeyev 0:e056ac8fecf8 357 NVIC_SetVector(irq_n, (uint32_t)handler);
valeyev 0:e056ac8fecf8 358 NVIC_EnableIRQ(irq_n);
valeyev 0:e056ac8fecf8 359
valeyev 0:e056ac8fecf8 360 // the following function will enable UART_IT_TXE and error interrupts
valeyev 0:e056ac8fecf8 361 if (HAL_UART_Transmit_IT(huart, (uint8_t*)tx, tx_length) != HAL_OK) {
valeyev 0:e056ac8fecf8 362 return 0;
valeyev 0:e056ac8fecf8 363 }
valeyev 0:e056ac8fecf8 364
valeyev 0:e056ac8fecf8 365 return tx_length;
valeyev 0:e056ac8fecf8 366 }
valeyev 0:e056ac8fecf8 367
valeyev 0:e056ac8fecf8 368 /**
valeyev 0:e056ac8fecf8 369 * Begin asynchronous RX transfer (enable interrupt for data collecting)
valeyev 0:e056ac8fecf8 370 * The used buffer is specified in the serial object, rx_buff
valeyev 0:e056ac8fecf8 371 *
valeyev 0:e056ac8fecf8 372 * @param obj The serial object
valeyev 0:e056ac8fecf8 373 * @param rx The buffer for sending
valeyev 0:e056ac8fecf8 374 * @param rx_length The number of words to transmit
valeyev 0:e056ac8fecf8 375 * @param rx_width The bit width of buffer word
valeyev 0:e056ac8fecf8 376 * @param handler The serial handler
valeyev 0:e056ac8fecf8 377 * @param event The logical OR of events to be registered
valeyev 0:e056ac8fecf8 378 * @param handler The serial handler
valeyev 0:e056ac8fecf8 379 * @param char_match A character in range 0-254 to be matched
valeyev 0:e056ac8fecf8 380 * @param hint A suggestion for how to use DMA with this transfer
valeyev 0:e056ac8fecf8 381 */
valeyev 0:e056ac8fecf8 382 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)
valeyev 0:e056ac8fecf8 383 {
valeyev 0:e056ac8fecf8 384 // TODO: DMA usage is currently ignored
valeyev 0:e056ac8fecf8 385 (void) hint;
valeyev 0:e056ac8fecf8 386
valeyev 0:e056ac8fecf8 387 /* Sanity check arguments */
valeyev 0:e056ac8fecf8 388 MBED_ASSERT(obj);
valeyev 0:e056ac8fecf8 389 MBED_ASSERT(rx != (void*)0);
valeyev 0:e056ac8fecf8 390 MBED_ASSERT(rx_width == 8); // support only 8b width
valeyev 0:e056ac8fecf8 391
valeyev 0:e056ac8fecf8 392 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 393 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 394
valeyev 0:e056ac8fecf8 395 serial_enable_event(obj, SERIAL_EVENT_RX_ALL, 0);
valeyev 0:e056ac8fecf8 396 serial_enable_event(obj, event, 1);
valeyev 0:e056ac8fecf8 397
valeyev 0:e056ac8fecf8 398 // set CharMatch
valeyev 0:e056ac8fecf8 399 obj->char_match = char_match;
valeyev 0:e056ac8fecf8 400
valeyev 0:e056ac8fecf8 401 serial_rx_buffer_set(obj, rx, rx_length, rx_width);
valeyev 0:e056ac8fecf8 402
valeyev 0:e056ac8fecf8 403 IRQn_Type irq_n = serial_get_irq_n(obj_s->uart);
valeyev 0:e056ac8fecf8 404 NVIC_ClearPendingIRQ(irq_n);
valeyev 0:e056ac8fecf8 405 NVIC_DisableIRQ(irq_n);
valeyev 0:e056ac8fecf8 406 NVIC_SetPriority(irq_n, 0);
valeyev 0:e056ac8fecf8 407 NVIC_SetVector(irq_n, (uint32_t)handler);
valeyev 0:e056ac8fecf8 408 NVIC_EnableIRQ(irq_n);
valeyev 0:e056ac8fecf8 409
valeyev 0:e056ac8fecf8 410 // following HAL function will enable the RXNE interrupt + error interrupts
valeyev 0:e056ac8fecf8 411 HAL_UART_Receive_IT(huart, (uint8_t*)rx, rx_length);
valeyev 0:e056ac8fecf8 412 }
valeyev 0:e056ac8fecf8 413
valeyev 0:e056ac8fecf8 414 /**
valeyev 0:e056ac8fecf8 415 * Attempts to determine if the serial peripheral is already in use for TX
valeyev 0:e056ac8fecf8 416 *
valeyev 0:e056ac8fecf8 417 * @param obj The serial object
valeyev 0:e056ac8fecf8 418 * @return Non-zero if the TX transaction is ongoing, 0 otherwise
valeyev 0:e056ac8fecf8 419 */
valeyev 0:e056ac8fecf8 420 uint8_t serial_tx_active(serial_t *obj)
valeyev 0:e056ac8fecf8 421 {
valeyev 0:e056ac8fecf8 422 MBED_ASSERT(obj);
valeyev 0:e056ac8fecf8 423
valeyev 0:e056ac8fecf8 424 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 425 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 426
valeyev 0:e056ac8fecf8 427 return ((HAL_UART_GetState(huart) == HAL_UART_STATE_BUSY_TX) ? 1 : 0);
valeyev 0:e056ac8fecf8 428 }
valeyev 0:e056ac8fecf8 429
valeyev 0:e056ac8fecf8 430 /**
valeyev 0:e056ac8fecf8 431 * Attempts to determine if the serial peripheral is already in use for RX
valeyev 0:e056ac8fecf8 432 *
valeyev 0:e056ac8fecf8 433 * @param obj The serial object
valeyev 0:e056ac8fecf8 434 * @return Non-zero if the RX transaction is ongoing, 0 otherwise
valeyev 0:e056ac8fecf8 435 */
valeyev 0:e056ac8fecf8 436 uint8_t serial_rx_active(serial_t *obj)
valeyev 0:e056ac8fecf8 437 {
valeyev 0:e056ac8fecf8 438 MBED_ASSERT(obj);
valeyev 0:e056ac8fecf8 439
valeyev 0:e056ac8fecf8 440 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 441 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 442
valeyev 0:e056ac8fecf8 443 return ((HAL_UART_GetState(huart) == HAL_UART_STATE_BUSY_RX) ? 1 : 0);
valeyev 0:e056ac8fecf8 444 }
valeyev 0:e056ac8fecf8 445
valeyev 0:e056ac8fecf8 446 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart) {
valeyev 0:e056ac8fecf8 447 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
valeyev 0:e056ac8fecf8 448 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
valeyev 0:e056ac8fecf8 449 }
valeyev 0:e056ac8fecf8 450 }
valeyev 0:e056ac8fecf8 451
valeyev 0:e056ac8fecf8 452 void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart) {
valeyev 0:e056ac8fecf8 453 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
valeyev 0:e056ac8fecf8 454 volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear PE flag
valeyev 0:e056ac8fecf8 455 } else if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
valeyev 0:e056ac8fecf8 456 volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear FE flag
valeyev 0:e056ac8fecf8 457 } else if (__HAL_UART_GET_FLAG(huart, UART_FLAG_NE) != RESET) {
valeyev 0:e056ac8fecf8 458 volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear NE flag
valeyev 0:e056ac8fecf8 459 } else if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
valeyev 0:e056ac8fecf8 460 volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear ORE flag
valeyev 0:e056ac8fecf8 461 }
valeyev 0:e056ac8fecf8 462 }
valeyev 0:e056ac8fecf8 463
valeyev 0:e056ac8fecf8 464 /**
valeyev 0:e056ac8fecf8 465 * The asynchronous TX and RX handler.
valeyev 0:e056ac8fecf8 466 *
valeyev 0:e056ac8fecf8 467 * @param obj The serial object
valeyev 0:e056ac8fecf8 468 * @return Returns event flags if a TX/RX transfer termination condition was met or 0 otherwise
valeyev 0:e056ac8fecf8 469 */
valeyev 0:e056ac8fecf8 470 int serial_irq_handler_asynch(serial_t *obj)
valeyev 0:e056ac8fecf8 471 {
valeyev 0:e056ac8fecf8 472 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 473 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 474
valeyev 0:e056ac8fecf8 475 volatile int return_event = 0;
valeyev 0:e056ac8fecf8 476 uint8_t *buf = (uint8_t*)(obj->rx_buff.buffer);
valeyev 0:e056ac8fecf8 477 uint8_t i = 0;
valeyev 0:e056ac8fecf8 478
valeyev 0:e056ac8fecf8 479 // TX PART:
valeyev 0:e056ac8fecf8 480 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_TC) != RESET) {
valeyev 0:e056ac8fecf8 481 if (__HAL_UART_GET_IT_SOURCE(huart, UART_IT_TC) != RESET) {
valeyev 0:e056ac8fecf8 482 // Return event SERIAL_EVENT_TX_COMPLETE if requested
valeyev 0:e056ac8fecf8 483 if ((obj_s->events & SERIAL_EVENT_TX_COMPLETE ) != 0) {
valeyev 0:e056ac8fecf8 484 return_event |= (SERIAL_EVENT_TX_COMPLETE & obj_s->events);
valeyev 0:e056ac8fecf8 485 }
valeyev 0:e056ac8fecf8 486 }
valeyev 0:e056ac8fecf8 487 }
valeyev 0:e056ac8fecf8 488
valeyev 0:e056ac8fecf8 489 // Handle error events
valeyev 0:e056ac8fecf8 490 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_PE) != RESET) {
valeyev 0:e056ac8fecf8 491 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
valeyev 0:e056ac8fecf8 492 return_event |= (SERIAL_EVENT_RX_PARITY_ERROR & obj_s->events);
valeyev 0:e056ac8fecf8 493 }
valeyev 0:e056ac8fecf8 494 }
valeyev 0:e056ac8fecf8 495
valeyev 0:e056ac8fecf8 496 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_FE) != RESET) {
valeyev 0:e056ac8fecf8 497 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
valeyev 0:e056ac8fecf8 498 return_event |= (SERIAL_EVENT_RX_FRAMING_ERROR & obj_s->events);
valeyev 0:e056ac8fecf8 499 }
valeyev 0:e056ac8fecf8 500 }
valeyev 0:e056ac8fecf8 501
valeyev 0:e056ac8fecf8 502 if (__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE) != RESET) {
valeyev 0:e056ac8fecf8 503 if (__HAL_UART_GET_IT_SOURCE(huart, USART_IT_ERR) != RESET) {
valeyev 0:e056ac8fecf8 504 return_event |= (SERIAL_EVENT_RX_OVERRUN_ERROR & obj_s->events);
valeyev 0:e056ac8fecf8 505 }
valeyev 0:e056ac8fecf8 506 }
valeyev 0:e056ac8fecf8 507
valeyev 0:e056ac8fecf8 508 HAL_UART_IRQHandler(huart);
valeyev 0:e056ac8fecf8 509
valeyev 0:e056ac8fecf8 510 // Abort if an error occurs
valeyev 0:e056ac8fecf8 511 if ((return_event & SERIAL_EVENT_RX_PARITY_ERROR) ||
valeyev 0:e056ac8fecf8 512 (return_event & SERIAL_EVENT_RX_FRAMING_ERROR) ||
valeyev 0:e056ac8fecf8 513 (return_event & SERIAL_EVENT_RX_OVERRUN_ERROR)) {
valeyev 0:e056ac8fecf8 514 return return_event;
valeyev 0:e056ac8fecf8 515 }
valeyev 0:e056ac8fecf8 516
valeyev 0:e056ac8fecf8 517 //RX PART
valeyev 0:e056ac8fecf8 518 if (huart->RxXferSize != 0) {
valeyev 0:e056ac8fecf8 519 obj->rx_buff.pos = huart->RxXferSize - huart->RxXferCount;
valeyev 0:e056ac8fecf8 520 }
valeyev 0:e056ac8fecf8 521 if ((huart->RxXferCount == 0) && (obj->rx_buff.pos >= (obj->rx_buff.length - 1))) {
valeyev 0:e056ac8fecf8 522 return_event |= (SERIAL_EVENT_RX_COMPLETE & obj_s->events);
valeyev 0:e056ac8fecf8 523 }
valeyev 0:e056ac8fecf8 524
valeyev 0:e056ac8fecf8 525 // Check if char_match is present
valeyev 0:e056ac8fecf8 526 if (obj_s->events & SERIAL_EVENT_RX_CHARACTER_MATCH) {
valeyev 0:e056ac8fecf8 527 if (buf != NULL) {
valeyev 0:e056ac8fecf8 528 for (i = 0; i < obj->rx_buff.pos; i++) {
valeyev 0:e056ac8fecf8 529 if (buf[i] == obj->char_match) {
valeyev 0:e056ac8fecf8 530 obj->rx_buff.pos = i;
valeyev 0:e056ac8fecf8 531 return_event |= (SERIAL_EVENT_RX_CHARACTER_MATCH & obj_s->events);
valeyev 0:e056ac8fecf8 532 serial_rx_abort_asynch(obj);
valeyev 0:e056ac8fecf8 533 break;
valeyev 0:e056ac8fecf8 534 }
valeyev 0:e056ac8fecf8 535 }
valeyev 0:e056ac8fecf8 536 }
valeyev 0:e056ac8fecf8 537 }
valeyev 0:e056ac8fecf8 538
valeyev 0:e056ac8fecf8 539 return return_event;
valeyev 0:e056ac8fecf8 540 }
valeyev 0:e056ac8fecf8 541
valeyev 0:e056ac8fecf8 542 /**
valeyev 0:e056ac8fecf8 543 * Abort the ongoing TX transaction. It disables the enabled interupt for TX and
valeyev 0:e056ac8fecf8 544 * flush TX hardware buffer if TX FIFO is used
valeyev 0:e056ac8fecf8 545 *
valeyev 0:e056ac8fecf8 546 * @param obj The serial object
valeyev 0:e056ac8fecf8 547 */
valeyev 0:e056ac8fecf8 548 void serial_tx_abort_asynch(serial_t *obj)
valeyev 0:e056ac8fecf8 549 {
valeyev 0:e056ac8fecf8 550 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 551 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 552
valeyev 0:e056ac8fecf8 553 __HAL_UART_DISABLE_IT(huart, UART_IT_TC);
valeyev 0:e056ac8fecf8 554 __HAL_UART_DISABLE_IT(huart, UART_IT_TXE);
valeyev 0:e056ac8fecf8 555
valeyev 0:e056ac8fecf8 556 // clear flags
valeyev 0:e056ac8fecf8 557 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_TC);
valeyev 0:e056ac8fecf8 558
valeyev 0:e056ac8fecf8 559 // reset states
valeyev 0:e056ac8fecf8 560 huart->TxXferCount = 0;
valeyev 0:e056ac8fecf8 561 // update handle state
valeyev 0:e056ac8fecf8 562 if(huart->gState == HAL_UART_STATE_BUSY_TX_RX) {
valeyev 0:e056ac8fecf8 563 huart->gState = HAL_UART_STATE_BUSY_RX;
valeyev 0:e056ac8fecf8 564 } else {
valeyev 0:e056ac8fecf8 565 huart->gState = HAL_UART_STATE_READY;
valeyev 0:e056ac8fecf8 566 }
valeyev 0:e056ac8fecf8 567 }
valeyev 0:e056ac8fecf8 568
valeyev 0:e056ac8fecf8 569 /**
valeyev 0:e056ac8fecf8 570 * Abort the ongoing RX transaction It disables the enabled interrupt for RX and
valeyev 0:e056ac8fecf8 571 * flush RX hardware buffer if RX FIFO is used
valeyev 0:e056ac8fecf8 572 *
valeyev 0:e056ac8fecf8 573 * @param obj The serial object
valeyev 0:e056ac8fecf8 574 */
valeyev 0:e056ac8fecf8 575 void serial_rx_abort_asynch(serial_t *obj)
valeyev 0:e056ac8fecf8 576 {
valeyev 0:e056ac8fecf8 577 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 578 UART_HandleTypeDef *huart = &uart_handlers[obj_s->index];
valeyev 0:e056ac8fecf8 579
valeyev 0:e056ac8fecf8 580 // disable interrupts
valeyev 0:e056ac8fecf8 581 __HAL_UART_DISABLE_IT(huart, UART_IT_RXNE);
valeyev 0:e056ac8fecf8 582 __HAL_UART_DISABLE_IT(huart, UART_IT_PE);
valeyev 0:e056ac8fecf8 583 __HAL_UART_DISABLE_IT(huart, UART_IT_ERR);
valeyev 0:e056ac8fecf8 584
valeyev 0:e056ac8fecf8 585 // clear flags
valeyev 0:e056ac8fecf8 586 __HAL_UART_CLEAR_FLAG(huart, UART_FLAG_RXNE);
valeyev 0:e056ac8fecf8 587 volatile uint32_t tmpval __attribute__((unused)) = huart->Instance->DR; // Clear errors flag
valeyev 0:e056ac8fecf8 588
valeyev 0:e056ac8fecf8 589 // reset states
valeyev 0:e056ac8fecf8 590 huart->RxXferCount = 0;
valeyev 0:e056ac8fecf8 591 // update handle state
valeyev 0:e056ac8fecf8 592 if(huart->RxState == HAL_UART_STATE_BUSY_TX_RX) {
valeyev 0:e056ac8fecf8 593 huart->RxState = HAL_UART_STATE_BUSY_TX;
valeyev 0:e056ac8fecf8 594 } else {
valeyev 0:e056ac8fecf8 595 huart->RxState = HAL_UART_STATE_READY;
valeyev 0:e056ac8fecf8 596 }
valeyev 0:e056ac8fecf8 597 }
valeyev 0:e056ac8fecf8 598
valeyev 0:e056ac8fecf8 599 #endif /* DEVICE_SERIAL_ASYNCH */
valeyev 0:e056ac8fecf8 600
valeyev 0:e056ac8fecf8 601 #if DEVICE_SERIAL_FC
valeyev 0:e056ac8fecf8 602
valeyev 0:e056ac8fecf8 603 /**
valeyev 0:e056ac8fecf8 604 * Set HW Control Flow
valeyev 0:e056ac8fecf8 605 * @param obj The serial object
valeyev 0:e056ac8fecf8 606 * @param type The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS)
valeyev 0:e056ac8fecf8 607 * @param rxflow Pin for the rxflow
valeyev 0:e056ac8fecf8 608 * @param txflow Pin for the txflow
valeyev 0:e056ac8fecf8 609 */
valeyev 0:e056ac8fecf8 610 void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
valeyev 0:e056ac8fecf8 611 {
valeyev 0:e056ac8fecf8 612 struct serial_s *obj_s = SERIAL_S(obj);
valeyev 0:e056ac8fecf8 613
valeyev 0:e056ac8fecf8 614 // Determine the UART to use (UART_1, UART_2, ...)
valeyev 0:e056ac8fecf8 615 UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS);
valeyev 0:e056ac8fecf8 616 UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS);
valeyev 0:e056ac8fecf8 617
valeyev 0:e056ac8fecf8 618 // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object
valeyev 0:e056ac8fecf8 619 obj_s->uart = (UARTName)pinmap_merge(uart_cts, uart_rts);
valeyev 0:e056ac8fecf8 620 MBED_ASSERT(obj_s->uart != (UARTName)NC);
valeyev 0:e056ac8fecf8 621
valeyev 0:e056ac8fecf8 622 if(type == FlowControlNone) {
valeyev 0:e056ac8fecf8 623 // Disable hardware flow control
valeyev 0:e056ac8fecf8 624 obj_s->hw_flow_ctl = UART_HWCONTROL_NONE;
valeyev 0:e056ac8fecf8 625 }
valeyev 0:e056ac8fecf8 626 if (type == FlowControlRTS) {
valeyev 0:e056ac8fecf8 627 // Enable RTS
valeyev 0:e056ac8fecf8 628 MBED_ASSERT(uart_rts != (UARTName)NC);
valeyev 0:e056ac8fecf8 629 obj_s->hw_flow_ctl = UART_HWCONTROL_RTS;
valeyev 0:e056ac8fecf8 630 obj_s->pin_rts = rxflow;
valeyev 0:e056ac8fecf8 631 // Enable the pin for RTS function
valeyev 0:e056ac8fecf8 632 pinmap_pinout(rxflow, PinMap_UART_RTS);
valeyev 0:e056ac8fecf8 633 }
valeyev 0:e056ac8fecf8 634 if (type == FlowControlCTS) {
valeyev 0:e056ac8fecf8 635 // Enable CTS
valeyev 0:e056ac8fecf8 636 MBED_ASSERT(uart_cts != (UARTName)NC);
valeyev 0:e056ac8fecf8 637 obj_s->hw_flow_ctl = UART_HWCONTROL_CTS;
valeyev 0:e056ac8fecf8 638 obj_s->pin_cts = txflow;
valeyev 0:e056ac8fecf8 639 // Enable the pin for CTS function
valeyev 0:e056ac8fecf8 640 pinmap_pinout(txflow, PinMap_UART_CTS);
valeyev 0:e056ac8fecf8 641 }
valeyev 0:e056ac8fecf8 642 if (type == FlowControlRTSCTS) {
valeyev 0:e056ac8fecf8 643 // Enable CTS & RTS
valeyev 0:e056ac8fecf8 644 MBED_ASSERT(uart_rts != (UARTName)NC);
valeyev 0:e056ac8fecf8 645 MBED_ASSERT(uart_cts != (UARTName)NC);
valeyev 0:e056ac8fecf8 646 obj_s->hw_flow_ctl = UART_HWCONTROL_RTS_CTS;
valeyev 0:e056ac8fecf8 647 obj_s->pin_rts = rxflow;
valeyev 0:e056ac8fecf8 648 obj_s->pin_cts = txflow;
valeyev 0:e056ac8fecf8 649 // Enable the pin for CTS function
valeyev 0:e056ac8fecf8 650 pinmap_pinout(txflow, PinMap_UART_CTS);
valeyev 0:e056ac8fecf8 651 // Enable the pin for RTS function
valeyev 0:e056ac8fecf8 652 pinmap_pinout(rxflow, PinMap_UART_RTS);
valeyev 0:e056ac8fecf8 653 }
valeyev 0:e056ac8fecf8 654
valeyev 0:e056ac8fecf8 655 init_uart(obj);
valeyev 0:e056ac8fecf8 656 }
valeyev 0:e056ac8fecf8 657
valeyev 0:e056ac8fecf8 658 #endif /* DEVICE_SERIAL_FC */
valeyev 0:e056ac8fecf8 659
valeyev 0:e056ac8fecf8 660 #endif /* DEVICE_SERIAL */