Marco De Silva / IONMcMotor

a

RoboClaw/UARTserial_mio/UARTSerial_mio.h@0:6b67f1bb9c76, 2021-09-28 (annotated)

Committer:
marcodesilva
Date:
Tue Sep 28 10:42:56 2021 +0000
Revision:
0:6b67f1bb9c76
d

Who changed what in which revision?

UserRevisionLine numberNew contents of line
marcodesilva 0:6b67f1bb9c76 1
marcodesilva 0:6b67f1bb9c76 2 #ifndef MBED_UARTSERIAL_MIO_H
marcodesilva 0:6b67f1bb9c76 3 #define MBED_UARTSERIAL_MIO_H
marcodesilva 0:6b67f1bb9c76 4
marcodesilva 0:6b67f1bb9c76 5 #include "platform/platform.h"
marcodesilva 0:6b67f1bb9c76 6
marcodesilva 0:6b67f1bb9c76 7 #if (DEVICE_SERIAL && DEVICE_INTERRUPTIN) || defined(DOXYGEN_ONLY)
marcodesilva 0:6b67f1bb9c76 8
marcodesilva 0:6b67f1bb9c76 9 #include "platform/FileHandle.h"
marcodesilva 0:6b67f1bb9c76 10 #include "SerialBase.h"
marcodesilva 0:6b67f1bb9c76 11 #include "InterruptIn.h"
marcodesilva 0:6b67f1bb9c76 12 #include "platform/PlatformMutex.h"
marcodesilva 0:6b67f1bb9c76 13 #include "hal/serial_api.h"
marcodesilva 0:6b67f1bb9c76 14 #include "platform/CircularBuffer.h"
marcodesilva 0:6b67f1bb9c76 15 #include "platform/NonCopyable.h"
marcodesilva 0:6b67f1bb9c76 16
marcodesilva 0:6b67f1bb9c76 17 #include "mbed.h"
marcodesilva 0:6b67f1bb9c76 18
marcodesilva 0:6b67f1bb9c76 19 #ifndef MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE
marcodesilva 0:6b67f1bb9c76 20 #define MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE 256
marcodesilva 0:6b67f1bb9c76 21 #endif
marcodesilva 0:6b67f1bb9c76 22
marcodesilva 0:6b67f1bb9c76 23 #ifndef MBED_CONF_DRIVERS_UART_SERIAL_TXBUF_SIZE
marcodesilva 0:6b67f1bb9c76 24 #define MBED_CONF_DRIVERS_UART_SERIAL_TXBUF_SIZE 256
marcodesilva 0:6b67f1bb9c76 25 #endif
marcodesilva 0:6b67f1bb9c76 26
marcodesilva 0:6b67f1bb9c76 27 namespace mbed {
marcodesilva 0:6b67f1bb9c76 28
marcodesilva 0:6b67f1bb9c76 29 /** \addtogroup drivers */
marcodesilva 0:6b67f1bb9c76 30
marcodesilva 0:6b67f1bb9c76 31 /** Class providing buffered UART communication functionality using separate circular buffer for send and receive channels
marcodesilva 0:6b67f1bb9c76 32 *
marcodesilva 0:6b67f1bb9c76 33 * @ingroup drivers
marcodesilva 0:6b67f1bb9c76 34 */
marcodesilva 0:6b67f1bb9c76 35
marcodesilva 0:6b67f1bb9c76 36 class UARTSerial_mio : private SerialBase, public FileHandle, private NonCopyable<UARTSerial_mio> {
marcodesilva 0:6b67f1bb9c76 37
marcodesilva 0:6b67f1bb9c76 38 public:
marcodesilva 0:6b67f1bb9c76 39
marcodesilva 0:6b67f1bb9c76 40 /** Create a UARTSerial_mio port, connected to the specified transmit and receive pins, with a particular baud rate.
marcodesilva 0:6b67f1bb9c76 41 * @param tx Transmit pin
marcodesilva 0:6b67f1bb9c76 42 * @param rx Receive pin
marcodesilva 0:6b67f1bb9c76 43 * @param baud The baud rate of the serial port (optional, defaults to MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE)
marcodesilva 0:6b67f1bb9c76 44 */
marcodesilva 0:6b67f1bb9c76 45 UARTSerial_mio(PinName tx, PinName rx, int baud = MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
marcodesilva 0:6b67f1bb9c76 46 virtual ~UARTSerial_mio();
marcodesilva 0:6b67f1bb9c76 47
marcodesilva 0:6b67f1bb9c76 48 /** Equivalent to POSIX poll(). Derived from FileHandle.
marcodesilva 0:6b67f1bb9c76 49 * Provides a mechanism to multiplex input/output over a set of file handles.
marcodesilva 0:6b67f1bb9c76 50 */
marcodesilva 0:6b67f1bb9c76 51 virtual short poll(short events) const;
marcodesilva 0:6b67f1bb9c76 52
marcodesilva 0:6b67f1bb9c76 53 /* Resolve ambiguities versus our private SerialBase
marcodesilva 0:6b67f1bb9c76 54 * (for writable, spelling differs, but just in case)
marcodesilva 0:6b67f1bb9c76 55 */
marcodesilva 0:6b67f1bb9c76 56 using FileHandle::readable;
marcodesilva 0:6b67f1bb9c76 57 using FileHandle::writable;
marcodesilva 0:6b67f1bb9c76 58
marcodesilva 0:6b67f1bb9c76 59 /** Write the contents of a buffer to a file
marcodesilva 0:6b67f1bb9c76 60 *
marcodesilva 0:6b67f1bb9c76 61 * Follows POSIX semantics:
marcodesilva 0:6b67f1bb9c76 62 *
marcodesilva 0:6b67f1bb9c76 63 * * if blocking, block until all data is written
marcodesilva 0:6b67f1bb9c76 64 * * if no data can be written, and non-blocking set, return -EAGAIN
marcodesilva 0:6b67f1bb9c76 65 * * if some data can be written, and non-blocking set, write partial
marcodesilva 0:6b67f1bb9c76 66 *
marcodesilva 0:6b67f1bb9c76 67 * @param buffer The buffer to write from
marcodesilva 0:6b67f1bb9c76 68 * @param length The number of bytes to write
marcodesilva 0:6b67f1bb9c76 69 * @return The number of bytes written, negative error on failure
marcodesilva 0:6b67f1bb9c76 70 */
marcodesilva 0:6b67f1bb9c76 71 virtual ssize_t write(const void *buffer, size_t length);
marcodesilva 0:6b67f1bb9c76 72
marcodesilva 0:6b67f1bb9c76 73 /** Read the contents of a file into a buffer
marcodesilva 0:6b67f1bb9c76 74 *
marcodesilva 0:6b67f1bb9c76 75 * Follows POSIX semantics:
marcodesilva 0:6b67f1bb9c76 76 *
marcodesilva 0:6b67f1bb9c76 77 * * if no data is available, and non-blocking set return -EAGAIN
marcodesilva 0:6b67f1bb9c76 78 * * if no data is available, and blocking set, wait until data is available
marcodesilva 0:6b67f1bb9c76 79 * * If any data is available, call returns immediately
marcodesilva 0:6b67f1bb9c76 80 *
marcodesilva 0:6b67f1bb9c76 81 * @param buffer The buffer to read in to
marcodesilva 0:6b67f1bb9c76 82 * @param length The number of bytes to read
marcodesilva 0:6b67f1bb9c76 83 * @return The number of bytes read, 0 at end of file, negative error on failure
marcodesilva 0:6b67f1bb9c76 84 */
marcodesilva 0:6b67f1bb9c76 85 virtual ssize_t read(void *buffer, size_t length);
marcodesilva 0:6b67f1bb9c76 86 virtual ssize_t read_timeout(void *buffer, size_t length, double _timeOut);
marcodesilva 0:6b67f1bb9c76 87
marcodesilva 0:6b67f1bb9c76 88 /** Close a file
marcodesilva 0:6b67f1bb9c76 89 *
marcodesilva 0:6b67f1bb9c76 90 * @return 0 on success, negative error code on failure
marcodesilva 0:6b67f1bb9c76 91 */
marcodesilva 0:6b67f1bb9c76 92 virtual int close();
marcodesilva 0:6b67f1bb9c76 93
marcodesilva 0:6b67f1bb9c76 94 /** Check if the file in an interactive terminal device
marcodesilva 0:6b67f1bb9c76 95 *
marcodesilva 0:6b67f1bb9c76 96 * @return True if the file is a terminal
marcodesilva 0:6b67f1bb9c76 97 * @return False if the file is not a terminal
marcodesilva 0:6b67f1bb9c76 98 * @return Negative error code on failure
marcodesilva 0:6b67f1bb9c76 99 */
marcodesilva 0:6b67f1bb9c76 100 virtual int isatty();
marcodesilva 0:6b67f1bb9c76 101
marcodesilva 0:6b67f1bb9c76 102 /** Move the file position to a given offset from from a given location
marcodesilva 0:6b67f1bb9c76 103 *
marcodesilva 0:6b67f1bb9c76 104 * Not valid for a device type FileHandle like UARTSerial_mio.
marcodesilva 0:6b67f1bb9c76 105 * In case of UARTSerial_mio, returns ESPIPE
marcodesilva 0:6b67f1bb9c76 106 *
marcodesilva 0:6b67f1bb9c76 107 * @param offset The offset from whence to move to
marcodesilva 0:6b67f1bb9c76 108 * @param whence The start of where to seek
marcodesilva 0:6b67f1bb9c76 109 * SEEK_SET to start from beginning of file,
marcodesilva 0:6b67f1bb9c76 110 * SEEK_CUR to start from current position in file,
marcodesilva 0:6b67f1bb9c76 111 * SEEK_END to start from end of file
marcodesilva 0:6b67f1bb9c76 112 * @return The new offset of the file, negative error code on failure
marcodesilva 0:6b67f1bb9c76 113 */
marcodesilva 0:6b67f1bb9c76 114 virtual off_t seek(off_t offset, int whence);
marcodesilva 0:6b67f1bb9c76 115
marcodesilva 0:6b67f1bb9c76 116 /** Flush any buffers associated with the file
marcodesilva 0:6b67f1bb9c76 117 *
marcodesilva 0:6b67f1bb9c76 118 * @return 0 on success, negative error code on failure
marcodesilva 0:6b67f1bb9c76 119 */
marcodesilva 0:6b67f1bb9c76 120 virtual int sync();
marcodesilva 0:6b67f1bb9c76 121 virtual int flush();
marcodesilva 0:6b67f1bb9c76 122 /** Set blocking or non-blocking mode
marcodesilva 0:6b67f1bb9c76 123 * The default is blocking.
marcodesilva 0:6b67f1bb9c76 124 *
marcodesilva 0:6b67f1bb9c76 125 * @param blocking true for blocking mode, false for non-blocking mode.
marcodesilva 0:6b67f1bb9c76 126 */
marcodesilva 0:6b67f1bb9c76 127 virtual int set_blocking(bool blocking)
marcodesilva 0:6b67f1bb9c76 128 {
marcodesilva 0:6b67f1bb9c76 129 _blocking = blocking;
marcodesilva 0:6b67f1bb9c76 130 return 0;
marcodesilva 0:6b67f1bb9c76 131 }
marcodesilva 0:6b67f1bb9c76 132
marcodesilva 0:6b67f1bb9c76 133 /** Check current blocking or non-blocking mode for file operations.
marcodesilva 0:6b67f1bb9c76 134 *
marcodesilva 0:6b67f1bb9c76 135 * @return true for blocking mode, false for non-blocking mode.
marcodesilva 0:6b67f1bb9c76 136 */
marcodesilva 0:6b67f1bb9c76 137 virtual bool is_blocking() const
marcodesilva 0:6b67f1bb9c76 138 {
marcodesilva 0:6b67f1bb9c76 139 return _blocking;
marcodesilva 0:6b67f1bb9c76 140 }
marcodesilva 0:6b67f1bb9c76 141
marcodesilva 0:6b67f1bb9c76 142 /** Enable or disable input
marcodesilva 0:6b67f1bb9c76 143 *
marcodesilva 0:6b67f1bb9c76 144 * Control enabling of device for input. This is primarily intended
marcodesilva 0:6b67f1bb9c76 145 * for temporary power-saving; the overall ability of the device to operate for
marcodesilva 0:6b67f1bb9c76 146 * input and/or output may be fixed at creation time, but this call can
marcodesilva 0:6b67f1bb9c76 147 * allow input to be temporarily disabled to permit power saving without
marcodesilva 0:6b67f1bb9c76 148 * losing device state.
marcodesilva 0:6b67f1bb9c76 149 *
marcodesilva 0:6b67f1bb9c76 150 * @param enabled true to enable input, false to disable.
marcodesilva 0:6b67f1bb9c76 151 *
marcodesilva 0:6b67f1bb9c76 152 * @return 0 on success
marcodesilva 0:6b67f1bb9c76 153 * @return Negative error code on failure
marcodesilva 0:6b67f1bb9c76 154 */
marcodesilva 0:6b67f1bb9c76 155 virtual int enable_input(bool enabled);
marcodesilva 0:6b67f1bb9c76 156
marcodesilva 0:6b67f1bb9c76 157 /** Enable or disable output
marcodesilva 0:6b67f1bb9c76 158 *
marcodesilva 0:6b67f1bb9c76 159 * Control enabling of device for output. This is primarily intended
marcodesilva 0:6b67f1bb9c76 160 * for temporary power-saving; the overall ability of the device to operate for
marcodesilva 0:6b67f1bb9c76 161 * input and/or output may be fixed at creation time, but this call can
marcodesilva 0:6b67f1bb9c76 162 * allow output to be temporarily disabled to permit power saving without
marcodesilva 0:6b67f1bb9c76 163 * losing device state.
marcodesilva 0:6b67f1bb9c76 164 *
marcodesilva 0:6b67f1bb9c76 165 * @param enabled true to enable output, false to disable.
marcodesilva 0:6b67f1bb9c76 166 *
marcodesilva 0:6b67f1bb9c76 167 * @return 0 on success
marcodesilva 0:6b67f1bb9c76 168 * @return Negative error code on failure
marcodesilva 0:6b67f1bb9c76 169 */
marcodesilva 0:6b67f1bb9c76 170 virtual int enable_output(bool enabled);
marcodesilva 0:6b67f1bb9c76 171
marcodesilva 0:6b67f1bb9c76 172 /** Register a callback on state change of the file.
marcodesilva 0:6b67f1bb9c76 173 *
marcodesilva 0:6b67f1bb9c76 174 * The specified callback will be called on state changes such as when
marcodesilva 0:6b67f1bb9c76 175 * the file can be written to or read from.
marcodesilva 0:6b67f1bb9c76 176 *
marcodesilva 0:6b67f1bb9c76 177 * The callback may be called in an interrupt context and should not
marcodesilva 0:6b67f1bb9c76 178 * perform expensive operations.
marcodesilva 0:6b67f1bb9c76 179 *
marcodesilva 0:6b67f1bb9c76 180 * Note! This is not intended as an attach-like asynchronous api, but rather
marcodesilva 0:6b67f1bb9c76 181 * as a building block for constructing such functionality.
marcodesilva 0:6b67f1bb9c76 182 *
marcodesilva 0:6b67f1bb9c76 183 * The exact timing of when the registered function
marcodesilva 0:6b67f1bb9c76 184 * is called is not guaranteed and susceptible to change. It should be used
marcodesilva 0:6b67f1bb9c76 185 * as a cue to make read/write/poll calls to find the current state.
marcodesilva 0:6b67f1bb9c76 186 *
marcodesilva 0:6b67f1bb9c76 187 * @param func Function to call on state change
marcodesilva 0:6b67f1bb9c76 188 */
marcodesilva 0:6b67f1bb9c76 189 virtual void sigio(Callback<void()> func);
marcodesilva 0:6b67f1bb9c76 190
marcodesilva 0:6b67f1bb9c76 191 /** Setup interrupt handler for DCD line
marcodesilva 0:6b67f1bb9c76 192 *
marcodesilva 0:6b67f1bb9c76 193 * If DCD line is connected, an IRQ handler will be setup.
marcodesilva 0:6b67f1bb9c76 194 * Does nothing if DCD is NC, i.e., not connected.
marcodesilva 0:6b67f1bb9c76 195 *
marcodesilva 0:6b67f1bb9c76 196 * @param dcd_pin Pin-name for DCD
marcodesilva 0:6b67f1bb9c76 197 * @param active_high a boolean set to true if DCD polarity is active low
marcodesilva 0:6b67f1bb9c76 198 */
marcodesilva 0:6b67f1bb9c76 199 void set_data_carrier_detect(PinName dcd_pin, bool active_high = false);
marcodesilva 0:6b67f1bb9c76 200
marcodesilva 0:6b67f1bb9c76 201 /** Set the baud rate
marcodesilva 0:6b67f1bb9c76 202 *
marcodesilva 0:6b67f1bb9c76 203 * @param baud The baud rate
marcodesilva 0:6b67f1bb9c76 204 */
marcodesilva 0:6b67f1bb9c76 205 void set_baud(int baud);
marcodesilva 0:6b67f1bb9c76 206
marcodesilva 0:6b67f1bb9c76 207 // Expose private SerialBase::Parity as UARTSerial_mio::Parity
marcodesilva 0:6b67f1bb9c76 208 using SerialBase::Parity;
marcodesilva 0:6b67f1bb9c76 209 // In C++11, we wouldn't need to also have using directives for each value
marcodesilva 0:6b67f1bb9c76 210 using SerialBase::None;
marcodesilva 0:6b67f1bb9c76 211 using SerialBase::Odd;
marcodesilva 0:6b67f1bb9c76 212 using SerialBase::Even;
marcodesilva 0:6b67f1bb9c76 213 using SerialBase::Forced1;
marcodesilva 0:6b67f1bb9c76 214 using SerialBase::Forced0;
marcodesilva 0:6b67f1bb9c76 215
marcodesilva 0:6b67f1bb9c76 216 /** Set the transmission format used by the serial port
marcodesilva 0:6b67f1bb9c76 217 *
marcodesilva 0:6b67f1bb9c76 218 * @param bits The number of bits in a word (5-8; default = 8)
marcodesilva 0:6b67f1bb9c76 219 * @param parity The parity used (None, Odd, Even, Forced1, Forced0; default = None)
marcodesilva 0:6b67f1bb9c76 220 * @param stop_bits The number of stop bits (1 or 2; default = 1)
marcodesilva 0:6b67f1bb9c76 221 */
marcodesilva 0:6b67f1bb9c76 222 void set_format(int bits = 8, Parity parity = UARTSerial_mio::None, int stop_bits = 1);
marcodesilva 0:6b67f1bb9c76 223
marcodesilva 0:6b67f1bb9c76 224 #if DEVICE_SERIAL_FC
marcodesilva 0:6b67f1bb9c76 225 // For now use the base enum - but in future we may have extra options
marcodesilva 0:6b67f1bb9c76 226 // such as XON/XOFF or manual GPIO RTSCTS.
marcodesilva 0:6b67f1bb9c76 227 using SerialBase::Flow;
marcodesilva 0:6b67f1bb9c76 228 // In C++11, we wouldn't need to also have using directives for each value
marcodesilva 0:6b67f1bb9c76 229 using SerialBase::Disabled;
marcodesilva 0:6b67f1bb9c76 230 using SerialBase::RTS;
marcodesilva 0:6b67f1bb9c76 231 using SerialBase::CTS;
marcodesilva 0:6b67f1bb9c76 232 using SerialBase::RTSCTS;
marcodesilva 0:6b67f1bb9c76 233
marcodesilva 0:6b67f1bb9c76 234 /** Set the flow control type on the serial port
marcodesilva 0:6b67f1bb9c76 235 *
marcodesilva 0:6b67f1bb9c76 236 * @param type the flow control type (Disabled, RTS, CTS, RTSCTS)
marcodesilva 0:6b67f1bb9c76 237 * @param flow1 the first flow control pin (RTS for RTS or RTSCTS, CTS for CTS)
marcodesilva 0:6b67f1bb9c76 238 * @param flow2 the second flow control pin (CTS for RTSCTS)
marcodesilva 0:6b67f1bb9c76 239 */
marcodesilva 0:6b67f1bb9c76 240 void set_flow_control(Flow type, PinName flow1 = NC, PinName flow2 = NC);
marcodesilva 0:6b67f1bb9c76 241 #endif
marcodesilva 0:6b67f1bb9c76 242
marcodesilva 0:6b67f1bb9c76 243 private:
marcodesilva 0:6b67f1bb9c76 244
marcodesilva 0:6b67f1bb9c76 245 void wait_ms(uint32_t millisec);
marcodesilva 0:6b67f1bb9c76 246 void wait_us(uint32_t microsec);
marcodesilva 0:6b67f1bb9c76 247
marcodesilva 0:6b67f1bb9c76 248 /** SerialBase lock override */
marcodesilva 0:6b67f1bb9c76 249 virtual void lock(void);
marcodesilva 0:6b67f1bb9c76 250
marcodesilva 0:6b67f1bb9c76 251 /** SerialBase unlock override */
marcodesilva 0:6b67f1bb9c76 252 virtual void unlock(void);
marcodesilva 0:6b67f1bb9c76 253
marcodesilva 0:6b67f1bb9c76 254 /** Acquire mutex */
marcodesilva 0:6b67f1bb9c76 255 virtual void api_lock(void);
marcodesilva 0:6b67f1bb9c76 256
marcodesilva 0:6b67f1bb9c76 257 /** Release mutex */
marcodesilva 0:6b67f1bb9c76 258 virtual void api_unlock(void);
marcodesilva 0:6b67f1bb9c76 259
marcodesilva 0:6b67f1bb9c76 260 /** Unbuffered write - invoked when write called from critical section */
marcodesilva 0:6b67f1bb9c76 261 ssize_t write_unbuffered(const char *buf_ptr, size_t length);
marcodesilva 0:6b67f1bb9c76 262
marcodesilva 0:6b67f1bb9c76 263 void enable_rx_irq();
marcodesilva 0:6b67f1bb9c76 264 void disable_rx_irq();
marcodesilva 0:6b67f1bb9c76 265 void enable_tx_irq();
marcodesilva 0:6b67f1bb9c76 266 void disable_tx_irq();
marcodesilva 0:6b67f1bb9c76 267
marcodesilva 0:6b67f1bb9c76 268 /** Software serial buffers
marcodesilva 0:6b67f1bb9c76 269 * By default buffer size is 256 for TX and 256 for RX. Configurable through mbed_app.json
marcodesilva 0:6b67f1bb9c76 270 */
marcodesilva 0:6b67f1bb9c76 271 CircularBuffer<char, MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE> _rxbuf;
marcodesilva 0:6b67f1bb9c76 272 CircularBuffer<char, MBED_CONF_DRIVERS_UART_SERIAL_TXBUF_SIZE> _txbuf;
marcodesilva 0:6b67f1bb9c76 273
marcodesilva 0:6b67f1bb9c76 274 PlatformMutex _mutex;
marcodesilva 0:6b67f1bb9c76 275
marcodesilva 0:6b67f1bb9c76 276 Callback<void()> _sigio_cb;
marcodesilva 0:6b67f1bb9c76 277
marcodesilva 0:6b67f1bb9c76 278 bool _blocking;
marcodesilva 0:6b67f1bb9c76 279 bool _tx_irq_enabled;
marcodesilva 0:6b67f1bb9c76 280 bool _rx_irq_enabled;
marcodesilva 0:6b67f1bb9c76 281 bool _tx_enabled;
marcodesilva 0:6b67f1bb9c76 282 bool _rx_enabled;
marcodesilva 0:6b67f1bb9c76 283 InterruptIn *_dcd_irq;
marcodesilva 0:6b67f1bb9c76 284
marcodesilva 0:6b67f1bb9c76 285 /** Device Hanged up
marcodesilva 0:6b67f1bb9c76 286 * Determines if the device hanged up on us.
marcodesilva 0:6b67f1bb9c76 287 *
marcodesilva 0:6b67f1bb9c76 288 * @return True, if hanged up
marcodesilva 0:6b67f1bb9c76 289 */
marcodesilva 0:6b67f1bb9c76 290 bool hup() const;
marcodesilva 0:6b67f1bb9c76 291
marcodesilva 0:6b67f1bb9c76 292 /** ISRs for serial
marcodesilva 0:6b67f1bb9c76 293 * Routines to handle interrupts on serial pins.
marcodesilva 0:6b67f1bb9c76 294 * Copies data into Circular Buffer.
marcodesilva 0:6b67f1bb9c76 295 * Reports the state change to File handle.
marcodesilva 0:6b67f1bb9c76 296 */
marcodesilva 0:6b67f1bb9c76 297 void tx_irq(void);
marcodesilva 0:6b67f1bb9c76 298 void rx_irq(void);
marcodesilva 0:6b67f1bb9c76 299
marcodesilva 0:6b67f1bb9c76 300 void wake(void);
marcodesilva 0:6b67f1bb9c76 301
marcodesilva 0:6b67f1bb9c76 302 void dcd_irq(void);
marcodesilva 0:6b67f1bb9c76 303
marcodesilva 0:6b67f1bb9c76 304 };
marcodesilva 0:6b67f1bb9c76 305 } //namespace mbed
marcodesilva 0:6b67f1bb9c76 306
marcodesilva 0:6b67f1bb9c76 307 #endif //(DEVICE_SERIAL && DEVICE_INTERRUPTIN) || defined(DOXYGEN_ONLY)
marcodesilva 0:6b67f1bb9c76 308 #endif //MBED_UARTSERIAL_H