mbed-dev library fork for STM32F100R6 microcontroller (LQFP64, 24MHz, 32kB flash, 4kB ram, 2-channel DAC, HDMI CEC, very cheap) . Use in online compiler (instead mbed library) with selected platform Nucleo F103RB.
Fork of mbed-dev by
serial_api.h
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2006-2013 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 #ifndef MBED_SERIAL_API_H 00017 #define MBED_SERIAL_API_H 00018 00019 #include "device.h" 00020 #include "buffer.h" 00021 #include "dma_api.h" 00022 00023 // for 100F6 not implemented (N.S.) 00024 #undef DEVICE_SERIAL_ASYNCH 00025 00026 00027 #if DEVICE_SERIAL 00028 00029 #define SERIAL_EVENT_TX_SHIFT (2) 00030 #define SERIAL_EVENT_RX_SHIFT (8) 00031 00032 #define SERIAL_EVENT_TX_MASK (0x00FC) 00033 #define SERIAL_EVENT_RX_MASK (0x3F00) 00034 00035 #define SERIAL_EVENT_ERROR (1 << 1) 00036 00037 /** 00038 * @defgroup SerialTXEvents Serial TX Events Macros 00039 * 00040 * @{ 00041 */ 00042 #define SERIAL_EVENT_TX_COMPLETE (1 << (SERIAL_EVENT_TX_SHIFT + 0)) 00043 #define SERIAL_EVENT_TX_ALL (SERIAL_EVENT_TX_COMPLETE) 00044 /**@}*/ 00045 00046 /** 00047 * @defgroup SerialRXEvents Serial RX Events Macros 00048 * 00049 * @{ 00050 */ 00051 #define SERIAL_EVENT_RX_COMPLETE (1 << (SERIAL_EVENT_RX_SHIFT + 0)) 00052 #define SERIAL_EVENT_RX_OVERRUN_ERROR (1 << (SERIAL_EVENT_RX_SHIFT + 1)) 00053 #define SERIAL_EVENT_RX_FRAMING_ERROR (1 << (SERIAL_EVENT_RX_SHIFT + 2)) 00054 #define SERIAL_EVENT_RX_PARITY_ERROR (1 << (SERIAL_EVENT_RX_SHIFT + 3)) 00055 #define SERIAL_EVENT_RX_OVERFLOW (1 << (SERIAL_EVENT_RX_SHIFT + 4)) 00056 #define SERIAL_EVENT_RX_CHARACTER_MATCH (1 << (SERIAL_EVENT_RX_SHIFT + 5)) 00057 #define SERIAL_EVENT_RX_ALL (SERIAL_EVENT_RX_OVERFLOW | SERIAL_EVENT_RX_PARITY_ERROR | \ 00058 SERIAL_EVENT_RX_FRAMING_ERROR | SERIAL_EVENT_RX_OVERRUN_ERROR | \ 00059 SERIAL_EVENT_RX_COMPLETE | SERIAL_EVENT_RX_CHARACTER_MATCH) 00060 /**@}*/ 00061 00062 #define SERIAL_RESERVED_CHAR_MATCH (255) 00063 00064 typedef enum { 00065 ParityNone = 0, 00066 ParityOdd = 1, 00067 ParityEven = 2, 00068 ParityForced1 = 3, 00069 ParityForced0 = 4 00070 } SerialParity; 00071 00072 typedef enum { 00073 RxIrq, 00074 TxIrq 00075 } SerialIrq; 00076 00077 typedef enum { 00078 FlowControlNone, 00079 FlowControlRTS, 00080 FlowControlCTS, 00081 FlowControlRTSCTS 00082 } FlowControl; 00083 00084 typedef void (*uart_irq_handler)(uint32_t id, SerialIrq event); 00085 00086 #if DEVICE_SERIAL_ASYNCH 00087 /** Asynch serial hal structure 00088 */ 00089 typedef struct { 00090 struct serial_s serial; /**< Target specific serial structure */ 00091 struct buffer_s tx_buff; /**< Tx buffer */ 00092 struct buffer_s rx_buff; /**< Rx buffer */ 00093 uint8_t char_match; /**< Character to be matched */ 00094 uint8_t char_found; /**< State of the matched character */ 00095 } serial_t; 00096 00097 #else 00098 /** Non-asynch serial hal structure 00099 */ 00100 typedef struct serial_s serial_t; 00101 00102 #endif 00103 00104 #ifdef __cplusplus 00105 extern "C" { 00106 #endif 00107 00108 /** 00109 * \defgroup GeneralSerial Serial Configuration Functions 00110 * @{ 00111 */ 00112 00113 /** Initialize the serial peripheral. It sets the default parameters for serial 00114 * peripheral, and configure its specifieds pins. 00115 * 00116 * @param obj The serial object 00117 * @param tx The TX pin 00118 * @param rx The RX pin 00119 */ 00120 void serial_init(serial_t *obj, PinName tx, PinName rx); 00121 00122 /** Release the serial peripheral, not currently invoked. It requires further 00123 * resource management. 00124 * 00125 * @param obj The serial object 00126 */ 00127 void serial_free(serial_t *obj); 00128 00129 /** Configure the baud rate 00130 * 00131 * @param obj The serial object 00132 * @param baudrate The baud rate to be configured 00133 */ 00134 void serial_baud(serial_t *obj, int baudrate); 00135 00136 /** Configure the format. Set the number of bits, parity and the number of stop bits 00137 * 00138 * @param obj The serial object 00139 * @param data_bits The number of data bits 00140 * @param parity The parity 00141 * @param stop_bits The number of stop bits 00142 */ 00143 void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits); 00144 00145 /** The serial interrupt handler registration. 00146 * 00147 * @param obj The serial object 00148 * @param handler The interrupt handler which will be invoked when interrupt fires. 00149 * @param id The SerialBase object 00150 */ 00151 void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id); 00152 00153 /** Configure serial interrupt. This function is used for word-approach 00154 * 00155 * @param obj The serial object 00156 * @param irq The serial IRQ type (RX or TX) 00157 * @param enable Set to non-zero to enable events, or zero to disable them 00158 */ 00159 void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable); 00160 00161 /** Get character. This is a blocking call, waiting for a character 00162 * 00163 * @param obj The serial object 00164 */ 00165 int serial_getc(serial_t *obj); 00166 00167 /** Put a character. This is a blocking call, waiting for a peripheral to be available 00168 * for writing 00169 * 00170 * @param obj The serial object 00171 * @param c The character to be sent 00172 */ 00173 void serial_putc(serial_t *obj, int c); 00174 00175 /** Check if the serial peripheral is readable 00176 * 00177 * @param obj The serial object 00178 * @return Non-zero value if a character can be read, 0 if nothing to read. 00179 */ 00180 int serial_readable(serial_t *obj); 00181 00182 /** Check if the serial peripheral is writable 00183 * 00184 * @param obj The serial object 00185 * @return Non-zero value if a character can be written, 0 otherwise. 00186 */ 00187 int serial_writable(serial_t *obj); 00188 00189 /** Clear the serial peripheral 00190 * 00191 * @param obj The serial object 00192 */ 00193 void serial_clear(serial_t *obj); 00194 00195 /** Set the break 00196 * 00197 * @param obj The serial object 00198 */ 00199 void serial_break_set(serial_t *obj); 00200 00201 /** Clear the break 00202 * 00203 * @param obj The serial object 00204 */ 00205 void serial_break_clear(serial_t *obj); 00206 00207 /** Configure the TX pin for UART function. 00208 * 00209 * @param tx The pin used for TX 00210 */ 00211 void serial_pinout_tx(PinName tx); 00212 00213 /** Configure the serial for the flow control. It sets flow control in the hardware 00214 * if a serial peripheral supports it, otherwise software emulation is used. 00215 * 00216 * @param obj The serial object 00217 * @param type The type of the flow control. Look at the available FlowControl types. 00218 * @param rxflow The tx pin 00219 * @param txflow The rx pin 00220 */ 00221 void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow); 00222 00223 #if DEVICE_SERIAL_ASYNCH 00224 00225 /**@}*/ 00226 00227 /** 00228 * \defgroup AsynchSerial Asynchronous Serial Hardware Abstraction Layer 00229 * @{ 00230 */ 00231 00232 /** Begin asynchronous TX transfer. The used buffer is specified in the serial object, 00233 * tx_buff 00234 * 00235 * @param obj The serial object 00236 * @param tx The buffer for sending 00237 * @param tx_length The number of words to transmit 00238 * @param tx_width The bit width of buffer word 00239 * @param handler The serial handler 00240 * @param event The logical OR of events to be registered 00241 * @param hint A suggestion for how to use DMA with this transfer 00242 * @return Returns number of data transfered, or 0 otherwise 00243 */ 00244 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); 00245 00246 /** Begin asynchronous RX transfer (enable interrupt for data collecting) 00247 * The used buffer is specified in the serial object - rx_buff 00248 * 00249 * @param obj The serial object 00250 * @param rx The buffer for sending 00251 * @param rx_length The number of words to transmit 00252 * @param rx_width The bit width of buffer word 00253 * @param handler The serial handler 00254 * @param event The logical OR of events to be registered 00255 * @param handler The serial handler 00256 * @param char_match A character in range 0-254 to be matched 00257 * @param hint A suggestion for how to use DMA with this transfer 00258 */ 00259 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); 00260 00261 /** Attempts to determine if the serial peripheral is already in use for TX 00262 * 00263 * @param obj The serial object 00264 * @return Non-zero if the RX transaction is ongoing, 0 otherwise 00265 */ 00266 uint8_t serial_tx_active(serial_t *obj); 00267 00268 /** Attempts to determine if the serial peripheral is already in use for RX 00269 * 00270 * @param obj The serial object 00271 * @return Non-zero if the RX transaction is ongoing, 0 otherwise 00272 */ 00273 uint8_t serial_rx_active(serial_t *obj); 00274 00275 /** The asynchronous TX and RX handler. 00276 * 00277 * @param obj The serial object 00278 * @return Returns event flags if a RX transfer termination condition was met or 0 otherwise 00279 */ 00280 int serial_irq_handler_asynch(serial_t *obj); 00281 00282 /** Abort the ongoing TX transaction. It disables the enabled interupt for TX and 00283 * flush TX hardware buffer if TX FIFO is used 00284 * 00285 * @param obj The serial object 00286 */ 00287 void serial_tx_abort_asynch(serial_t *obj); 00288 00289 /** Abort the ongoing RX transaction It disables the enabled interrupt for RX and 00290 * flush RX hardware buffer if RX FIFO is used 00291 * 00292 * @param obj The serial object 00293 */ 00294 void serial_rx_abort_asynch(serial_t *obj); 00295 00296 /**@}*/ 00297 00298 #endif 00299 00300 #ifdef __cplusplus 00301 } 00302 #endif 00303 00304 #endif 00305 00306 #endif
Generated on Wed Jul 13 2022 04:55:01 by 1.7.2