Mark Vandermeulen / FYDP_Final

Code for our FYDP -only one IMU works right now -RTOS is working

Dependencies:   mbed

mbed/MODSERIAL/MODSERIAL.h@0:964eb6a2ef00, 2015-03-18 (annotated)

Committer:
majik
Date:
Wed Mar 18 22:23:48 2015 +0000
Revision:
0:964eb6a2ef00
This is our FYDP code, but only one IMU works with the RTOS.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
majik 0:964eb6a2ef00 1 /*
majik 0:964eb6a2ef00 2 Copyright (c) 2010 Andy Kirkham
majik 0:964eb6a2ef00 3
majik 0:964eb6a2ef00 4 Permission is hereby granted, free of charge, to any person obtaining a copy
majik 0:964eb6a2ef00 5 of this software and associated documentation files (the "Software"), to deal
majik 0:964eb6a2ef00 6 in the Software without restriction, including without limitation the rights
majik 0:964eb6a2ef00 7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
majik 0:964eb6a2ef00 8 copies of the Software, and to permit persons to whom the Software is
majik 0:964eb6a2ef00 9 furnished to do so, subject to the following conditions:
majik 0:964eb6a2ef00 10
majik 0:964eb6a2ef00 11 The above copyright notice and this permission notice shall be included in
majik 0:964eb6a2ef00 12 all copies or substantial portions of the Software.
majik 0:964eb6a2ef00 13
majik 0:964eb6a2ef00 14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
majik 0:964eb6a2ef00 15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
majik 0:964eb6a2ef00 16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
majik 0:964eb6a2ef00 17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
majik 0:964eb6a2ef00 18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
majik 0:964eb6a2ef00 19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
majik 0:964eb6a2ef00 20 THE SOFTWARE.
majik 0:964eb6a2ef00 21
majik 0:964eb6a2ef00 22 @file MODSERIAL.h
majik 0:964eb6a2ef00 23 @purpose Extends Serial to provide fully buffered IO
majik 0:964eb6a2ef00 24 @version see ChangeLog.c
majik 0:964eb6a2ef00 25 @date Nov 2010
majik 0:964eb6a2ef00 26 @author Andy Kirkham
majik 0:964eb6a2ef00 27 */
majik 0:964eb6a2ef00 28
majik 0:964eb6a2ef00 29 #ifndef MODSERIAL_H
majik 0:964eb6a2ef00 30 #define MODSERIAL_H
majik 0:964eb6a2ef00 31
majik 0:964eb6a2ef00 32 /** @defgroup API The MODSERIAL API */
majik 0:964eb6a2ef00 33 /** @defgroup MISC Misc MODSERIAL functions */
majik 0:964eb6a2ef00 34 /** @defgroup INTERNALS MODSERIAL Internals */
majik 0:964eb6a2ef00 35
majik 0:964eb6a2ef00 36 #ifndef MODSERIAL_DEFAULT_RX_BUFFER_SIZE
majik 0:964eb6a2ef00 37 #define MODSERIAL_DEFAULT_RX_BUFFER_SIZE 256
majik 0:964eb6a2ef00 38 #endif
majik 0:964eb6a2ef00 39
majik 0:964eb6a2ef00 40 #ifndef MODSERIAL_DEFAULT_TX_BUFFER_SIZE
majik 0:964eb6a2ef00 41 #define MODSERIAL_DEFAULT_TX_BUFFER_SIZE 256
majik 0:964eb6a2ef00 42 #endif
majik 0:964eb6a2ef00 43
majik 0:964eb6a2ef00 44 #include "mbed.h"
majik 0:964eb6a2ef00 45 #include "serial_api.h"
majik 0:964eb6a2ef00 46
majik 0:964eb6a2ef00 47 namespace AjK {
majik 0:964eb6a2ef00 48
majik 0:964eb6a2ef00 49 // Forward reference.
majik 0:964eb6a2ef00 50 class MODSERIAL;
majik 0:964eb6a2ef00 51
majik 0:964eb6a2ef00 52 /**
majik 0:964eb6a2ef00 53 * @author Andy Kirkham
majik 0:964eb6a2ef00 54 * @see http://mbed.org/cookbook/MODSERIAL
majik 0:964eb6a2ef00 55 * @see example3a.cpp
majik 0:964eb6a2ef00 56 * @see example3b.cpp
majik 0:964eb6a2ef00 57 * @see API
majik 0:964eb6a2ef00 58 *
majik 0:964eb6a2ef00 59 * <b>MODSERIAL_IRQ_INFO</b> is a class used to pass information (and access to protected
majik 0:964eb6a2ef00 60 * MODSERIAL functions) to IRQ callbacks.
majik 0:964eb6a2ef00 61 */
majik 0:964eb6a2ef00 62 class MODSERIAL_IRQ_INFO
majik 0:964eb6a2ef00 63 {
majik 0:964eb6a2ef00 64 public:
majik 0:964eb6a2ef00 65 friend class MODSERIAL;
majik 0:964eb6a2ef00 66
majik 0:964eb6a2ef00 67 MODSERIAL *serial;
majik 0:964eb6a2ef00 68
majik 0:964eb6a2ef00 69 MODSERIAL_IRQ_INFO() { serial = 0; }
majik 0:964eb6a2ef00 70
majik 0:964eb6a2ef00 71 /** rxDiscardLastChar()
majik 0:964eb6a2ef00 72 *
majik 0:964eb6a2ef00 73 * Remove the last char placed into the rx buffer.
majik 0:964eb6a2ef00 74 * This is an operation that can only be performed
majik 0:964eb6a2ef00 75 * by an rxCallback function.
majik 0:964eb6a2ef00 76 * @ingroup API
majik 0:964eb6a2ef00 77 * @return The byte removed from the buffer.
majik 0:964eb6a2ef00 78 */
majik 0:964eb6a2ef00 79 int rxDiscardLastChar(void);
majik 0:964eb6a2ef00 80
majik 0:964eb6a2ef00 81 protected:
majik 0:964eb6a2ef00 82
majik 0:964eb6a2ef00 83 /** setSerial()
majik 0:964eb6a2ef00 84 *
majik 0:964eb6a2ef00 85 * Used internally by MODSERIAL to set the "this" pointer
majik 0:964eb6a2ef00 86 * of the MODSERIAL that created this object.
majik 0:964eb6a2ef00 87 * @ingroup INTERNAL
majik 0:964eb6a2ef00 88 * @param A pointer to a MODSERIAL object instance.
majik 0:964eb6a2ef00 89 */
majik 0:964eb6a2ef00 90 void setSerial(MODSERIAL *s) { serial = s; }
majik 0:964eb6a2ef00 91 };
majik 0:964eb6a2ef00 92
majik 0:964eb6a2ef00 93 // Forward reference dummy class.
majik 0:964eb6a2ef00 94 class MODSERIAL_callback_dummy;
majik 0:964eb6a2ef00 95
majik 0:964eb6a2ef00 96 /**
majik 0:964eb6a2ef00 97 * @author Andy Kirkham
majik 0:964eb6a2ef00 98 * @see http://mbed.org/cookbook/MODSERIAL
majik 0:964eb6a2ef00 99 * @see example3a.cpp
majik 0:964eb6a2ef00 100 * @see example3b.cpp
majik 0:964eb6a2ef00 101 * @see API
majik 0:964eb6a2ef00 102 *
majik 0:964eb6a2ef00 103 * <b>MODSERIAL_callback</b> is a class used to hold application callbacks that
majik 0:964eb6a2ef00 104 * MODSERIAL can invoke on certain events.
majik 0:964eb6a2ef00 105 */
majik 0:964eb6a2ef00 106 class MODSERIAL_callback
majik 0:964eb6a2ef00 107 {
majik 0:964eb6a2ef00 108 protected:
majik 0:964eb6a2ef00 109
majik 0:964eb6a2ef00 110 //! C callback function pointer.
majik 0:964eb6a2ef00 111 void (*c_callback)(MODSERIAL_IRQ_INFO *);
majik 0:964eb6a2ef00 112
majik 0:964eb6a2ef00 113 //! C++ callback object/method pointer (the object part).
majik 0:964eb6a2ef00 114 MODSERIAL_callback_dummy *obj_callback;
majik 0:964eb6a2ef00 115
majik 0:964eb6a2ef00 116 //! C++ callback object/method pointer (the method part).
majik 0:964eb6a2ef00 117 void (MODSERIAL_callback_dummy::*method_callback)(MODSERIAL_IRQ_INFO *);
majik 0:964eb6a2ef00 118
majik 0:964eb6a2ef00 119 public:
majik 0:964eb6a2ef00 120
majik 0:964eb6a2ef00 121 /** Constructor
majik 0:964eb6a2ef00 122 */
majik 0:964eb6a2ef00 123 MODSERIAL_callback() {
majik 0:964eb6a2ef00 124 c_callback = 0;
majik 0:964eb6a2ef00 125 obj_callback = 0;
majik 0:964eb6a2ef00 126 method_callback = 0;
majik 0:964eb6a2ef00 127 }
majik 0:964eb6a2ef00 128
majik 0:964eb6a2ef00 129 /** attach - Overloaded attachment function.
majik 0:964eb6a2ef00 130 *
majik 0:964eb6a2ef00 131 * Attach a C type function pointer as the callback.
majik 0:964eb6a2ef00 132 *
majik 0:964eb6a2ef00 133 * Note, the callback function prototype must be:-
majik 0:964eb6a2ef00 134 * @code
majik 0:964eb6a2ef00 135 * void myCallbackFunction(MODSERIAL_IRQ_INFO *);
majik 0:964eb6a2ef00 136 * @endcode
majik 0:964eb6a2ef00 137 * @param A C function pointer to call.
majik 0:964eb6a2ef00 138 */
majik 0:964eb6a2ef00 139 void attach(void (*function)(MODSERIAL_IRQ_INFO *) = 0) { c_callback = function; }
majik 0:964eb6a2ef00 140
majik 0:964eb6a2ef00 141 /** attach - Overloaded attachment function.
majik 0:964eb6a2ef00 142 *
majik 0:964eb6a2ef00 143 * Attach a C++ type object/method pointer as the callback.
majik 0:964eb6a2ef00 144 *
majik 0:964eb6a2ef00 145 * Note, the callback method prototype must be:-
majik 0:964eb6a2ef00 146 * @code
majik 0:964eb6a2ef00 147 * public:
majik 0:964eb6a2ef00 148 * void myCallbackFunction(MODSERIAL_IRQ_INFO *);
majik 0:964eb6a2ef00 149 * @endcode
majik 0:964eb6a2ef00 150 * @param A C++ object pointer.
majik 0:964eb6a2ef00 151 * @param A C++ method within the object to call.
majik 0:964eb6a2ef00 152 */
majik 0:964eb6a2ef00 153 template<class T>
majik 0:964eb6a2ef00 154 void attach(T* item, void (T::*method)(MODSERIAL_IRQ_INFO *)) {
majik 0:964eb6a2ef00 155 obj_callback = (MODSERIAL_callback_dummy *)item;
majik 0:964eb6a2ef00 156 method_callback = (void (MODSERIAL_callback_dummy::*)(MODSERIAL_IRQ_INFO *))method;
majik 0:964eb6a2ef00 157 }
majik 0:964eb6a2ef00 158
majik 0:964eb6a2ef00 159 /** call - Overloaded callback initiator.
majik 0:964eb6a2ef00 160 *
majik 0:964eb6a2ef00 161 * call the callback function.
majik 0:964eb6a2ef00 162 *
majik 0:964eb6a2ef00 163 * @param A pointer to a MODSERIAL_IRQ_INFO object.
majik 0:964eb6a2ef00 164 */
majik 0:964eb6a2ef00 165 void call(MODSERIAL_IRQ_INFO *arg) {
majik 0:964eb6a2ef00 166 if (c_callback != 0) {
majik 0:964eb6a2ef00 167 (*c_callback)(arg);
majik 0:964eb6a2ef00 168 }
majik 0:964eb6a2ef00 169 else {
majik 0:964eb6a2ef00 170 if (obj_callback != 0 && method_callback != 0) {
majik 0:964eb6a2ef00 171 (obj_callback->*method_callback)(arg);
majik 0:964eb6a2ef00 172 }
majik 0:964eb6a2ef00 173 }
majik 0:964eb6a2ef00 174 }
majik 0:964eb6a2ef00 175 };
majik 0:964eb6a2ef00 176
majik 0:964eb6a2ef00 177 /**
majik 0:964eb6a2ef00 178 * @author Andy Kirkham
majik 0:964eb6a2ef00 179 * @see http://mbed.org/cookbook/MODSERIAL
majik 0:964eb6a2ef00 180 * @see http://mbed.org/handbook/Serial
majik 0:964eb6a2ef00 181 * @see example1.cpp
majik 0:964eb6a2ef00 182 * @see example2.cpp
majik 0:964eb6a2ef00 183 * @see example3a.cpp
majik 0:964eb6a2ef00 184 * @see example3b.cpp
majik 0:964eb6a2ef00 185 * @see example_dma.cpp
majik 0:964eb6a2ef00 186 * @see API
majik 0:964eb6a2ef00 187 *
majik 0:964eb6a2ef00 188 * <b>MODSERIAL</b> extends the Mbed library <a href="/handbook/Serial">Serial</a> to provide fully buffered
majik 0:964eb6a2ef00 189 * TX and RX streams. Buffer length is fully customisable.
majik 0:964eb6a2ef00 190 *
majik 0:964eb6a2ef00 191 * Before using MODSERIAL users should be familar with Mbed's standard <a href="/handbook/Serial">Serial</a>
majik 0:964eb6a2ef00 192 * library object. MODSERIAL is a direct "drop in" replacement for <a href="/handbook/Serial">Serial</a>. Where
majik 0:964eb6a2ef00 193 * previously Serial was used, MODSERIAL can be used as adirect replacement instantly offering standard
majik 0:964eb6a2ef00 194 * TX and RX buffering. By default, both TX and RX buffers are 256 bytes in length.
majik 0:964eb6a2ef00 195 *
majik 0:964eb6a2ef00 196 * @image html /media/uploads/mbedofficial/serial_interfaces.png
majik 0:964eb6a2ef00 197 *
majik 0:964eb6a2ef00 198 * Standard example:
majik 0:964eb6a2ef00 199 * @code
majik 0:964eb6a2ef00 200 * #include "mbed.h"
majik 0:964eb6a2ef00 201 * #include "MODSERIAL.h"
majik 0:964eb6a2ef00 202 *
majik 0:964eb6a2ef00 203 * MODSERIAL pc(USBTX, USBRX); // tx, rx
majik 0:964eb6a2ef00 204 *
majik 0:964eb6a2ef00 205 * int main() {
majik 0:964eb6a2ef00 206 * pc.printf("Hello World!");
majik 0:964eb6a2ef00 207 * while(1) {
majik 0:964eb6a2ef00 208 * pc.putc(pc.getc() + 1);
majik 0:964eb6a2ef00 209 * }
majik 0:964eb6a2ef00 210 * }
majik 0:964eb6a2ef00 211 * @endcode
majik 0:964eb6a2ef00 212 *
majik 0:964eb6a2ef00 213 * Example with alternate buffer length:
majik 0:964eb6a2ef00 214 * @code
majik 0:964eb6a2ef00 215 * #include "mbed.h"
majik 0:964eb6a2ef00 216 * #include "MODSERIAL.h"
majik 0:964eb6a2ef00 217 *
majik 0:964eb6a2ef00 218 * // Make TX and RX buffers 512byes in length
majik 0:964eb6a2ef00 219 * MODSERIAL pc(USBTX, USBRX, 512); // tx, rx
majik 0:964eb6a2ef00 220 *
majik 0:964eb6a2ef00 221 * int main() {
majik 0:964eb6a2ef00 222 * pc.printf("Hello World!");
majik 0:964eb6a2ef00 223 * while(1) {
majik 0:964eb6a2ef00 224 * pc.putc(pc.getc() + 1);
majik 0:964eb6a2ef00 225 * }
majik 0:964eb6a2ef00 226 * }
majik 0:964eb6a2ef00 227 * @endcode
majik 0:964eb6a2ef00 228 *
majik 0:964eb6a2ef00 229 * Example with alternate buffer length:
majik 0:964eb6a2ef00 230 * @code
majik 0:964eb6a2ef00 231 * #include "mbed.h"
majik 0:964eb6a2ef00 232 * #include "MODSERIAL.h"
majik 0:964eb6a2ef00 233 *
majik 0:964eb6a2ef00 234 * // Make TX 1024bytes and RX 512byes in length
majik 0:964eb6a2ef00 235 * MODSERIAL pc(USBTX, USBRX, 1024, 512); // tx, rx
majik 0:964eb6a2ef00 236 *
majik 0:964eb6a2ef00 237 * int main() {
majik 0:964eb6a2ef00 238 * pc.printf("Hello World!");
majik 0:964eb6a2ef00 239 * while(1) {
majik 0:964eb6a2ef00 240 * pc.putc(pc.getc() + 1);
majik 0:964eb6a2ef00 241 * }
majik 0:964eb6a2ef00 242 * }
majik 0:964eb6a2ef00 243 * @endcode
majik 0:964eb6a2ef00 244 */
majik 0:964eb6a2ef00 245 class MODSERIAL : public Serial
majik 0:964eb6a2ef00 246 {
majik 0:964eb6a2ef00 247 public:
majik 0:964eb6a2ef00 248
majik 0:964eb6a2ef00 249 // Allow instances of MODSERIAL_IRQ_INFO to use protected properties and methods.
majik 0:964eb6a2ef00 250 friend class MODSERIAL_IRQ_INFO;
majik 0:964eb6a2ef00 251
majik 0:964eb6a2ef00 252 //! A copy of the Serial parity enum
majik 0:964eb6a2ef00 253 /** @see http://mbed.org/projects/libraries/api/mbed/trunk/Serial#Serial.format */
majik 0:964eb6a2ef00 254 enum Parity {
majik 0:964eb6a2ef00 255 None = 0
majik 0:964eb6a2ef00 256 , Odd
majik 0:964eb6a2ef00 257 , Even
majik 0:964eb6a2ef00 258 , Forced1
majik 0:964eb6a2ef00 259 , Forced0
majik 0:964eb6a2ef00 260 };
majik 0:964eb6a2ef00 261
majik 0:964eb6a2ef00 262 //! A copy of the Serial IrqType enum
majik 0:964eb6a2ef00 263 enum IrqType {
majik 0:964eb6a2ef00 264 RxIrq = 0
majik 0:964eb6a2ef00 265 , TxIrq
majik 0:964eb6a2ef00 266 , RxOvIrq
majik 0:964eb6a2ef00 267 , TxOvIrq
majik 0:964eb6a2ef00 268 , TxEmpty
majik 0:964eb6a2ef00 269 , RxAutoDetect
majik 0:964eb6a2ef00 270 , NumOfIrqTypes
majik 0:964eb6a2ef00 271 };
majik 0:964eb6a2ef00 272
majik 0:964eb6a2ef00 273 //! Non-blocking functions return code.
majik 0:964eb6a2ef00 274 enum Result {
majik 0:964eb6a2ef00 275 Ok = 0 /*!< Ok. */
majik 0:964eb6a2ef00 276 , NoMemory = -1 /*!< Memory allocation failed. */
majik 0:964eb6a2ef00 277 , NoChar = -1 /*!< No character in buffer. */
majik 0:964eb6a2ef00 278 , BufferOversize = -2 /*!< Oversized buffer. */
majik 0:964eb6a2ef00 279 };
majik 0:964eb6a2ef00 280
majik 0:964eb6a2ef00 281 /**
majik 0:964eb6a2ef00 282 * The MODSERIAL constructor is used to initialise the serial object.
majik 0:964eb6a2ef00 283 *
majik 0:964eb6a2ef00 284 * @param tx PinName of the TX pin.
majik 0:964eb6a2ef00 285 * @param rx PinName of the TX pin.
majik 0:964eb6a2ef00 286 */
majik 0:964eb6a2ef00 287 MODSERIAL(PinName tx, PinName rx, const char* name = NULL);
majik 0:964eb6a2ef00 288
majik 0:964eb6a2ef00 289 /**
majik 0:964eb6a2ef00 290 * The MODSERIAL constructor is used to initialise the serial object.
majik 0:964eb6a2ef00 291 *
majik 0:964eb6a2ef00 292 * @param tx PinName of the TX pin.
majik 0:964eb6a2ef00 293 * @param rx PinName of the TX pin.
majik 0:964eb6a2ef00 294 * @param bufferSize Integer of the TX and RX buffer sizes.
majik 0:964eb6a2ef00 295 */
majik 0:964eb6a2ef00 296 MODSERIAL(PinName tx, PinName rx, int bufferSize, const char* name = NULL);
majik 0:964eb6a2ef00 297
majik 0:964eb6a2ef00 298 /**
majik 0:964eb6a2ef00 299 * The MODSERIAL constructor is used to initialise the serial object.
majik 0:964eb6a2ef00 300 *
majik 0:964eb6a2ef00 301 * @param tx PinName of the TX pin.
majik 0:964eb6a2ef00 302 * @param rx PinName of the TX pin.
majik 0:964eb6a2ef00 303 * @param txBufferSize Integer of the TX buffer sizes.
majik 0:964eb6a2ef00 304 * @param rxBufferSize Integer of the RX buffer sizes.
majik 0:964eb6a2ef00 305 */
majik 0:964eb6a2ef00 306 MODSERIAL(PinName tx, PinName rx, int txBufferSize, int rxBufferSize, const char* name = NULL);
majik 0:964eb6a2ef00 307
majik 0:964eb6a2ef00 308 virtual ~MODSERIAL();
majik 0:964eb6a2ef00 309
majik 0:964eb6a2ef00 310 /**
majik 0:964eb6a2ef00 311 * Function: attach
majik 0:964eb6a2ef00 312 *
majik 0:964eb6a2ef00 313 * The Mbed standard <a href="/handbook/Serial">Serial</a> library object allows an interrupt callback
majik 0:964eb6a2ef00 314 * to be made when a byte is received by the TX or RX UART hardware. MODSERIAL traps these interrupts
majik 0:964eb6a2ef00 315 * to enable it's buffering system. However, after the byte has been received/sent under interrupt control,
majik 0:964eb6a2ef00 316 * MODSERIAL can callback a user function as a notification of the interrupt. Note, user code should not
majik 0:964eb6a2ef00 317 * directly interact with the Uart hardware, MODSERIAL does that, instead, MODSERIAL API functions should
majik 0:964eb6a2ef00 318 * be used.
majik 0:964eb6a2ef00 319 *
majik 0:964eb6a2ef00 320 * <b>Note</b>, a character is written out then, if there is room in the TX FIFO and the TX buffer is empty,
majik 0:964eb6a2ef00 321 * putc() will put the character directly into THR (the output holding register). If the TX FIFO is full and
majik 0:964eb6a2ef00 322 * cannot accept the character, it is placed into the TX output buffer. The TX interrupts are then enabled
majik 0:964eb6a2ef00 323 * so that when the TX FIFO empties, the TX buffer is then transferred to the THR FIFO. The TxIrq will ONLY
majik 0:964eb6a2ef00 324 * be activated when this transfer of a character from BUFFER to THR FIFO takes place. If your character
majik 0:964eb6a2ef00 325 * throughput is not high bandwidth, then the 16 byte TX FIFO may be enough and the TX output buffer may
majik 0:964eb6a2ef00 326 * never come into play.
majik 0:964eb6a2ef00 327 *
majik 0:964eb6a2ef00 328 * @code
majik 0:964eb6a2ef00 329 * #include "mbed.h"
majik 0:964eb6a2ef00 330 * #include "MODSERIAL.h"
majik 0:964eb6a2ef00 331 *
majik 0:964eb6a2ef00 332 * DigitalOut led1(LED1);
majik 0:964eb6a2ef00 333 * DigitalOut led2(LED2);
majik 0:964eb6a2ef00 334 * DigitalOut led3(LED3);
majik 0:964eb6a2ef00 335 *
majik 0:964eb6a2ef00 336 * // To test, connect p9 to p10 as a loopback.
majik 0:964eb6a2ef00 337 * MODSERIAL pc(p9, p10);
majik 0:964eb6a2ef00 338 *
majik 0:964eb6a2ef00 339 * // This function is called when a character goes into the TX buffer.
majik 0:964eb6a2ef00 340 * void txCallback(void) {
majik 0:964eb6a2ef00 341 * led2 = !led2;
majik 0:964eb6a2ef00 342 * }
majik 0:964eb6a2ef00 343 *
majik 0:964eb6a2ef00 344 * // This function is called when a character goes into the RX buffer.
majik 0:964eb6a2ef00 345 * void rxCallback(void) {
majik 0:964eb6a2ef00 346 * led3 = !led3;
majik 0:964eb6a2ef00 347 * }
majik 0:964eb6a2ef00 348 *
majik 0:964eb6a2ef00 349 * int main() {
majik 0:964eb6a2ef00 350 * pc.baud(115200);
majik 0:964eb6a2ef00 351 * pc.attach(&txCallback, MODSERIAL::TxIrq);
majik 0:964eb6a2ef00 352 * pc.attach(&rxCallback, MODSERIAL::RxIrq);
majik 0:964eb6a2ef00 353 *
majik 0:964eb6a2ef00 354 * while(1) {
majik 0:964eb6a2ef00 355 * led1 = !led1;
majik 0:964eb6a2ef00 356 * wait(0.5);
majik 0:964eb6a2ef00 357 * pc.putc('A');
majik 0:964eb6a2ef00 358 * wait(0.5);
majik 0:964eb6a2ef00 359 * }
majik 0:964eb6a2ef00 360 * ]
majik 0:964eb6a2ef00 361 * @endcode
majik 0:964eb6a2ef00 362 *
majik 0:964eb6a2ef00 363 * @ingroup API
majik 0:964eb6a2ef00 364 * @param fptr A pointer to a void function, or 0 to set as none
majik 0:964eb6a2ef00 365 * @param type Which serial interrupt to attach the member function to (Seriall::RxIrq for receive, TxIrq for transmit buffer empty)
majik 0:964eb6a2ef00 366 */
majik 0:964eb6a2ef00 367 void attach(void (*fptr)(MODSERIAL_IRQ_INFO *), IrqType type = RxIrq) { _isr[type].attach(fptr); }
majik 0:964eb6a2ef00 368
majik 0:964eb6a2ef00 369 /**
majik 0:964eb6a2ef00 370 * Function: attach
majik 0:964eb6a2ef00 371 *
majik 0:964eb6a2ef00 372 * The Mbed standard <a href="/handbook/Serial">Serial</a> library object allows an interrupt callback
majik 0:964eb6a2ef00 373 * to be made when a byte is received by the TX or RX UART hardware. MODSERIAL traps these interrupts
majik 0:964eb6a2ef00 374 * to enable it's buffering system. However, after the byte has been received/sent under interrupt control,
majik 0:964eb6a2ef00 375 * MODSERIAL can callback a user function as a notification of the interrupt. Note, user code should not
majik 0:964eb6a2ef00 376 * directly interact with the Uart hardware, MODSERIAL does that, instead, MODSERIAL API functions should
majik 0:964eb6a2ef00 377 * be used.
majik 0:964eb6a2ef00 378 *
majik 0:964eb6a2ef00 379 * <b>Note</b>, a character is written out then, if there is room in the TX FIFO and the TX buffer is empty,
majik 0:964eb6a2ef00 380 * putc() will put the character directly into THR (the output holding register). If the TX FIFO is full and
majik 0:964eb6a2ef00 381 * cannot accept the character, it is placed into the TX output buffer. The TX interrupts are then enabled
majik 0:964eb6a2ef00 382 * so that when the TX FIFO empties, the TX buffer is then transferred to the THR FIFO. The TxIrq will ONLY
majik 0:964eb6a2ef00 383 * be activated when this transfer of a character from BUFFER to THR FIFO takes place. If your character
majik 0:964eb6a2ef00 384 * throughput is not high bandwidth, then the 16 byte TX FIFO may be enough and the TX output buffer may
majik 0:964eb6a2ef00 385 * never come into play.
majik 0:964eb6a2ef00 386 *
majik 0:964eb6a2ef00 387 * @code
majik 0:964eb6a2ef00 388 * #include "mbed.h"
majik 0:964eb6a2ef00 389 * #include "MODSERIAL.h"
majik 0:964eb6a2ef00 390 *
majik 0:964eb6a2ef00 391 * DigitalOut led1(LED1);
majik 0:964eb6a2ef00 392 * DigitalOut led2(LED2);
majik 0:964eb6a2ef00 393 * DigitalOut led3(LED3);
majik 0:964eb6a2ef00 394 *
majik 0:964eb6a2ef00 395 * // To test, connect p9 to p10 as a loopback.
majik 0:964eb6a2ef00 396 * MODSERIAL pc(p9, p10);
majik 0:964eb6a2ef00 397 *
majik 0:964eb6a2ef00 398 * class Foo {
majik 0:964eb6a2ef00 399 * public:
majik 0:964eb6a2ef00 400 * // This method is called when a character goes into the TX buffer.
majik 0:964eb6a2ef00 401 * void txCallback(void) { led2 = !led2; }
majik 0:964eb6a2ef00 402 *
majik 0:964eb6a2ef00 403 * // This method is called when a character goes into the RX buffer.
majik 0:964eb6a2ef00 404 * void rxCallback(void) { led3 = !led3; }
majik 0:964eb6a2ef00 405 * };
majik 0:964eb6a2ef00 406 *
majik 0:964eb6a2ef00 407 * Foo foo;
majik 0:964eb6a2ef00 408 *
majik 0:964eb6a2ef00 409 * int main() {
majik 0:964eb6a2ef00 410 * pc.baud(115200);
majik 0:964eb6a2ef00 411 * pc.attach(&foo, &Foo::txCallback, MODSERIAL::TxIrq);
majik 0:964eb6a2ef00 412 * pc.attach(&foo, &Foo::rxCallback, MODSERIAL::RxIrq);
majik 0:964eb6a2ef00 413 *
majik 0:964eb6a2ef00 414 * while(1) {
majik 0:964eb6a2ef00 415 * led1 = !led1;
majik 0:964eb6a2ef00 416 * wait(0.5);
majik 0:964eb6a2ef00 417 * pc.putc('A');
majik 0:964eb6a2ef00 418 * wait(0.5);
majik 0:964eb6a2ef00 419 * }
majik 0:964eb6a2ef00 420 * ]
majik 0:964eb6a2ef00 421 * @endcode
majik 0:964eb6a2ef00 422 *
majik 0:964eb6a2ef00 423 * @ingroup API
majik 0:964eb6a2ef00 424 * @param tptr A pointer to the object to call the member function on
majik 0:964eb6a2ef00 425 * @param mptr A pointer to the member function to be called
majik 0:964eb6a2ef00 426 * @param type Which serial interrupt to attach the member function to (Seriall::RxIrq for receive, TxIrq for transmit buffer empty)
majik 0:964eb6a2ef00 427 */
majik 0:964eb6a2ef00 428 template<typename T>
majik 0:964eb6a2ef00 429 void attach(T* tptr, void (T::*mptr)(MODSERIAL_IRQ_INFO *), IrqType type = RxIrq) {
majik 0:964eb6a2ef00 430 if((mptr != 0) && (tptr != 0)) {
majik 0:964eb6a2ef00 431 _isr[type].attach(tptr, mptr);
majik 0:964eb6a2ef00 432 }
majik 0:964eb6a2ef00 433 }
majik 0:964eb6a2ef00 434
majik 0:964eb6a2ef00 435 /**
majik 0:964eb6a2ef00 436 * @see attach
majik 0:964eb6a2ef00 437 * @ingroup API
majik 0:964eb6a2ef00 438 */
majik 0:964eb6a2ef00 439 void connect(void (*fptr)(MODSERIAL_IRQ_INFO *), IrqType type = RxIrq) { _isr[RxIrq].attach(fptr); }
majik 0:964eb6a2ef00 440
majik 0:964eb6a2ef00 441 /**
majik 0:964eb6a2ef00 442 * @see attach
majik 0:964eb6a2ef00 443 * @ingroup API
majik 0:964eb6a2ef00 444 */
majik 0:964eb6a2ef00 445 template<typename T>
majik 0:964eb6a2ef00 446 void connect(T* tptr, void (T::*mptr)(MODSERIAL_IRQ_INFO *), IrqType type = RxIrq) {
majik 0:964eb6a2ef00 447 if((mptr != 0) && (tptr != 0)) {
majik 0:964eb6a2ef00 448 _isr[type].attach(tptr, mptr);
majik 0:964eb6a2ef00 449 }
majik 0:964eb6a2ef00 450 }
majik 0:964eb6a2ef00 451
majik 0:964eb6a2ef00 452 /**
majik 0:964eb6a2ef00 453 * Function: writeable
majik 0:964eb6a2ef00 454 *
majik 0:964eb6a2ef00 455 * Determine if there is space available to write a byte
majik 0:964eb6a2ef00 456 *
majik 0:964eb6a2ef00 457 * @ingroup API
majik 0:964eb6a2ef00 458 * @return 1 if there is space to write a character, else 0
majik 0:964eb6a2ef00 459 */
majik 0:964eb6a2ef00 460 int writeable() { return txBufferFull() ? 0 : 1; }
majik 0:964eb6a2ef00 461
majik 0:964eb6a2ef00 462 /**
majik 0:964eb6a2ef00 463 * Function: readable
majik 0:964eb6a2ef00 464 *
majik 0:964eb6a2ef00 465 * Determine if there is a byte available to read
majik 0:964eb6a2ef00 466 *
majik 0:964eb6a2ef00 467 * @ingroup API
majik 0:964eb6a2ef00 468 * @return 1 if there is a character available to read, else 0
majik 0:964eb6a2ef00 469 */
majik 0:964eb6a2ef00 470 int readable() { return rxBufferEmpty() ? 0 : 1; }
majik 0:964eb6a2ef00 471
majik 0:964eb6a2ef00 472 /**
majik 0:964eb6a2ef00 473 * Function: txBufferSane
majik 0:964eb6a2ef00 474 *
majik 0:964eb6a2ef00 475 * Determine if the TX buffer has been initialized.
majik 0:964eb6a2ef00 476 *
majik 0:964eb6a2ef00 477 * @ingroup API
majik 0:964eb6a2ef00 478 * @return true if the buffer is initialized, else false
majik 0:964eb6a2ef00 479 */
majik 0:964eb6a2ef00 480 bool txBufferSane(void) { return buffer[TxIrq] != (char *)NULL ? true : false; }
majik 0:964eb6a2ef00 481
majik 0:964eb6a2ef00 482 /**
majik 0:964eb6a2ef00 483 * Function: rxBufferSane
majik 0:964eb6a2ef00 484 *
majik 0:964eb6a2ef00 485 * Determine if the RX buffer has been initialized.
majik 0:964eb6a2ef00 486 *
majik 0:964eb6a2ef00 487 * @ingroup API
majik 0:964eb6a2ef00 488 * @return true if the buffer is initialized, else false
majik 0:964eb6a2ef00 489 */
majik 0:964eb6a2ef00 490 bool rxBufferSane(void) { return buffer[TxIrq] != (char *)NULL ? true : false; }
majik 0:964eb6a2ef00 491
majik 0:964eb6a2ef00 492 /**
majik 0:964eb6a2ef00 493 * Function: txBufferGetCount
majik 0:964eb6a2ef00 494 *
majik 0:964eb6a2ef00 495 * Returns how many bytes are in the TX buffer
majik 0:964eb6a2ef00 496 *
majik 0:964eb6a2ef00 497 * @ingroup API
majik 0:964eb6a2ef00 498 * @return The number of bytes in the TX buffer
majik 0:964eb6a2ef00 499 */
majik 0:964eb6a2ef00 500 int txBufferGetCount(void) { return buffer_count[TxIrq]; }
majik 0:964eb6a2ef00 501
majik 0:964eb6a2ef00 502 /**
majik 0:964eb6a2ef00 503 * Function: rxBufferGetCount
majik 0:964eb6a2ef00 504 *
majik 0:964eb6a2ef00 505 * Returns how many bytes are in the RX buffer
majik 0:964eb6a2ef00 506 *
majik 0:964eb6a2ef00 507 * @ingroup API
majik 0:964eb6a2ef00 508 * @return The number of bytes in the RX buffer
majik 0:964eb6a2ef00 509 */
majik 0:964eb6a2ef00 510 int rxBufferGetCount(void) { return buffer_count[RxIrq]; }
majik 0:964eb6a2ef00 511
majik 0:964eb6a2ef00 512 /**
majik 0:964eb6a2ef00 513 * Function: txBufferGetSize
majik 0:964eb6a2ef00 514 *
majik 0:964eb6a2ef00 515 * Returns the current size of the TX buffer
majik 0:964eb6a2ef00 516 *
majik 0:964eb6a2ef00 517 * @ingroup API
majik 0:964eb6a2ef00 518 * @return The length iof the TX buffer in bytes
majik 0:964eb6a2ef00 519 */
majik 0:964eb6a2ef00 520 int txBufferGetSize(int size) { return buffer_size[TxIrq]; }
majik 0:964eb6a2ef00 521
majik 0:964eb6a2ef00 522 /**
majik 0:964eb6a2ef00 523 * Function: rxBufferGetSize
majik 0:964eb6a2ef00 524 *
majik 0:964eb6a2ef00 525 * Returns the current size of the RX buffer
majik 0:964eb6a2ef00 526 *
majik 0:964eb6a2ef00 527 * @ingroup API
majik 0:964eb6a2ef00 528 * @return The length iof the RX buffer in bytes
majik 0:964eb6a2ef00 529 */
majik 0:964eb6a2ef00 530 int rxBufferGetSize(int size) { return buffer_size[RxIrq]; }
majik 0:964eb6a2ef00 531
majik 0:964eb6a2ef00 532 /**
majik 0:964eb6a2ef00 533 * Function: txBufferFull
majik 0:964eb6a2ef00 534 *
majik 0:964eb6a2ef00 535 * Is the TX buffer full?
majik 0:964eb6a2ef00 536 *
majik 0:964eb6a2ef00 537 * @ingroup API
majik 0:964eb6a2ef00 538 * @return true if the TX buffer is full, otherwise false
majik 0:964eb6a2ef00 539 */
majik 0:964eb6a2ef00 540 bool txBufferFull(void);
majik 0:964eb6a2ef00 541
majik 0:964eb6a2ef00 542 /**
majik 0:964eb6a2ef00 543 * Function: rxBufferFull
majik 0:964eb6a2ef00 544 *
majik 0:964eb6a2ef00 545 * Is the RX buffer full?
majik 0:964eb6a2ef00 546 *
majik 0:964eb6a2ef00 547 * @ingroup API
majik 0:964eb6a2ef00 548 * @return true if the RX buffer is full, otherwise false
majik 0:964eb6a2ef00 549 */
majik 0:964eb6a2ef00 550 bool rxBufferFull(void);
majik 0:964eb6a2ef00 551
majik 0:964eb6a2ef00 552 /**
majik 0:964eb6a2ef00 553 * Function: txBufferEmpty
majik 0:964eb6a2ef00 554 *
majik 0:964eb6a2ef00 555 * Is the TX buffer empty?
majik 0:964eb6a2ef00 556 *
majik 0:964eb6a2ef00 557 * @ingroup API
majik 0:964eb6a2ef00 558 * @return true if the TX buffer is empty, otherwise false
majik 0:964eb6a2ef00 559 */
majik 0:964eb6a2ef00 560 bool txBufferEmpty(void);
majik 0:964eb6a2ef00 561
majik 0:964eb6a2ef00 562 /**
majik 0:964eb6a2ef00 563 * Function: rxBufferEmpty
majik 0:964eb6a2ef00 564 *
majik 0:964eb6a2ef00 565 * Is the RX buffer empty?
majik 0:964eb6a2ef00 566 *
majik 0:964eb6a2ef00 567 * @ingroup API
majik 0:964eb6a2ef00 568 * @return true if the RX buffer is empty, otherwise false
majik 0:964eb6a2ef00 569 */
majik 0:964eb6a2ef00 570 bool rxBufferEmpty(void);
majik 0:964eb6a2ef00 571
majik 0:964eb6a2ef00 572 /**
majik 0:964eb6a2ef00 573 * Function: txBufferSetSize
majik 0:964eb6a2ef00 574 *
majik 0:964eb6a2ef00 575 * Change the TX buffer size.
majik 0:964eb6a2ef00 576 *
majik 0:964eb6a2ef00 577 * @see Result
majik 0:964eb6a2ef00 578 * @ingroup API
majik 0:964eb6a2ef00 579 * @param size The new TX buffer size in bytes.
majik 0:964eb6a2ef00 580 * @param m Perform a memory sanity check. Errs the Mbed if memory alloc fails.
majik 0:964eb6a2ef00 581 * @return Result Ok on success.
majik 0:964eb6a2ef00 582 */
majik 0:964eb6a2ef00 583 int txBufferSetSize(int size, bool m) { return resizeBuffer(size, TxIrq, m); }
majik 0:964eb6a2ef00 584
majik 0:964eb6a2ef00 585 /**
majik 0:964eb6a2ef00 586 * Function: rxBufferSetSize
majik 0:964eb6a2ef00 587 *
majik 0:964eb6a2ef00 588 * Change the RX buffer size.
majik 0:964eb6a2ef00 589 *
majik 0:964eb6a2ef00 590 * @see Result
majik 0:964eb6a2ef00 591 * @ingroup API
majik 0:964eb6a2ef00 592 * @param size The new RX buffer size in bytes.
majik 0:964eb6a2ef00 593 * @param m Perform a memory sanity check. Errs the Mbed if memory alloc fails.
majik 0:964eb6a2ef00 594 * @return Result Ok on success.
majik 0:964eb6a2ef00 595 */
majik 0:964eb6a2ef00 596 int rxBufferSetSize(int size, bool m) { return resizeBuffer(size, RxIrq, m); }
majik 0:964eb6a2ef00 597
majik 0:964eb6a2ef00 598 /**
majik 0:964eb6a2ef00 599 * Function: txBufferSetSize
majik 0:964eb6a2ef00 600 *
majik 0:964eb6a2ef00 601 * Change the TX buffer size.
majik 0:964eb6a2ef00 602 * Always performs a memory sanity check, halting the Mbed on failure.
majik 0:964eb6a2ef00 603 *
majik 0:964eb6a2ef00 604 * @see Result
majik 0:964eb6a2ef00 605 * @ingroup API
majik 0:964eb6a2ef00 606 * @param size The new TX buffer size in bytes.
majik 0:964eb6a2ef00 607 * @return Result Ok on success.
majik 0:964eb6a2ef00 608 */
majik 0:964eb6a2ef00 609 int txBufferSetSize(int size) { return resizeBuffer(size, TxIrq, true); }
majik 0:964eb6a2ef00 610
majik 0:964eb6a2ef00 611 /**
majik 0:964eb6a2ef00 612 * Function: rxBufferSetSize
majik 0:964eb6a2ef00 613 *
majik 0:964eb6a2ef00 614 * Change the RX buffer size.
majik 0:964eb6a2ef00 615 * Always performs a memory sanity check, halting the Mbed on failure.
majik 0:964eb6a2ef00 616 *
majik 0:964eb6a2ef00 617 * @see Result
majik 0:964eb6a2ef00 618 * @ingroup API
majik 0:964eb6a2ef00 619 * @param size The new RX buffer size in bytes.
majik 0:964eb6a2ef00 620 * @return Result Ok on success.
majik 0:964eb6a2ef00 621 */
majik 0:964eb6a2ef00 622 int rxBufferSetSize(int size) { return resizeBuffer(size, RxIrq, true); }
majik 0:964eb6a2ef00 623
majik 0:964eb6a2ef00 624 /**
majik 0:964eb6a2ef00 625 * Function: txBufferFlush
majik 0:964eb6a2ef00 626 *
majik 0:964eb6a2ef00 627 * Remove all bytes from the TX buffer.
majik 0:964eb6a2ef00 628 * @ingroup API
majik 0:964eb6a2ef00 629 */
majik 0:964eb6a2ef00 630 void txBufferFlush(void) { flushBuffer(TxIrq); }
majik 0:964eb6a2ef00 631
majik 0:964eb6a2ef00 632 /**
majik 0:964eb6a2ef00 633 * Function: rxBufferFlush
majik 0:964eb6a2ef00 634 *
majik 0:964eb6a2ef00 635 * Remove all bytes from the RX buffer.
majik 0:964eb6a2ef00 636 * @ingroup API
majik 0:964eb6a2ef00 637 */
majik 0:964eb6a2ef00 638 void rxBufferFlush(void) { flushBuffer(RxIrq); }
majik 0:964eb6a2ef00 639
majik 0:964eb6a2ef00 640 /**
majik 0:964eb6a2ef00 641 * Function: getcNb
majik 0:964eb6a2ef00 642 *
majik 0:964eb6a2ef00 643 * Like getc() but is non-blocking. If no bytes are in the RX buffer this
majik 0:964eb6a2ef00 644 * function returns Result::NoChar (-1)
majik 0:964eb6a2ef00 645 *
majik 0:964eb6a2ef00 646 * @ingroup API
majik 0:964eb6a2ef00 647 * @return A byte from the RX buffer or Result::NoChar (-1) if bufer empty.
majik 0:964eb6a2ef00 648 */
majik 0:964eb6a2ef00 649 int getcNb() { return __getc(false); }
majik 0:964eb6a2ef00 650
majik 0:964eb6a2ef00 651 /**
majik 0:964eb6a2ef00 652 * Function: getc
majik 0:964eb6a2ef00 653 *
majik 0:964eb6a2ef00 654 * Overloaded version of Serial::getc()
majik 0:964eb6a2ef00 655 *
majik 0:964eb6a2ef00 656 * This function blocks (if the RX buffer is empty the function will wait for a
majik 0:964eb6a2ef00 657 * character to arrive and then return that character).
majik 0:964eb6a2ef00 658 *
majik 0:964eb6a2ef00 659 * @ingroup API
majik 0:964eb6a2ef00 660 * @return A byte from the RX buffer
majik 0:964eb6a2ef00 661 */
majik 0:964eb6a2ef00 662 int getc() { return __getc(true); }
majik 0:964eb6a2ef00 663
majik 0:964eb6a2ef00 664 /**
majik 0:964eb6a2ef00 665 * Function: txGetLastChar
majik 0:964eb6a2ef00 666 *
majik 0:964eb6a2ef00 667 * Rteurn the last byte to pass through the TX interrupt handler.
majik 0:964eb6a2ef00 668 *
majik 0:964eb6a2ef00 669 * @ingroup MISC
majik 0:964eb6a2ef00 670 * @return The byte
majik 0:964eb6a2ef00 671 */
majik 0:964eb6a2ef00 672 char txGetLastChar(void) { return txc; }
majik 0:964eb6a2ef00 673
majik 0:964eb6a2ef00 674 /**
majik 0:964eb6a2ef00 675 * Function: rxGetLastChar
majik 0:964eb6a2ef00 676 *
majik 0:964eb6a2ef00 677 * Return the last byte to pass through the RX interrupt handler.
majik 0:964eb6a2ef00 678 *
majik 0:964eb6a2ef00 679 * @ingroup MISC
majik 0:964eb6a2ef00 680 * @return The byte
majik 0:964eb6a2ef00 681 */
majik 0:964eb6a2ef00 682 char rxGetLastChar(void) { return rxc; }
majik 0:964eb6a2ef00 683
majik 0:964eb6a2ef00 684
majik 0:964eb6a2ef00 685
majik 0:964eb6a2ef00 686 /**
majik 0:964eb6a2ef00 687 * Function: autoDetectChar
majik 0:964eb6a2ef00 688 *
majik 0:964eb6a2ef00 689 * Set the char that, if seen incoming, invokes the AutoDetectChar callback.
majik 0:964eb6a2ef00 690 *
majik 0:964eb6a2ef00 691 * @ingroup API
majik 0:964eb6a2ef00 692 * @param int c The character to detect.
majik 0:964eb6a2ef00 693 */
majik 0:964eb6a2ef00 694 void autoDetectChar(char c) { auto_detect_char = c; }
majik 0:964eb6a2ef00 695
majik 0:964eb6a2ef00 696 /**
majik 0:964eb6a2ef00 697 * Function: move
majik 0:964eb6a2ef00 698 *
majik 0:964eb6a2ef00 699 * Move contents of RX buffer to external buffer. Stops if "end" detected.
majik 0:964eb6a2ef00 700 *
majik 0:964eb6a2ef00 701 * @ingroup API
majik 0:964eb6a2ef00 702 * @param char *s The destination buffer address
majik 0:964eb6a2ef00 703 * @param int max The maximum number of chars to move.
majik 0:964eb6a2ef00 704 * @param char end If this char is detected stop moving.
majik 0:964eb6a2ef00 705 */
majik 0:964eb6a2ef00 706 int move(char *s, int max, char end) {
majik 0:964eb6a2ef00 707 int counter = 0;
majik 0:964eb6a2ef00 708 char c;
majik 0:964eb6a2ef00 709 while(readable()) {
majik 0:964eb6a2ef00 710 c = getc();
majik 0:964eb6a2ef00 711 if (c == end) break;
majik 0:964eb6a2ef00 712 *(s++) = c;
majik 0:964eb6a2ef00 713 counter++;
majik 0:964eb6a2ef00 714 if (counter == max) break;
majik 0:964eb6a2ef00 715 }
majik 0:964eb6a2ef00 716 return counter;
majik 0:964eb6a2ef00 717 }
majik 0:964eb6a2ef00 718
majik 0:964eb6a2ef00 719 /**
majik 0:964eb6a2ef00 720 * Function: move (overloaded)
majik 0:964eb6a2ef00 721 *
majik 0:964eb6a2ef00 722 * Move contents of RX buffer to external buffer. Stops if auto_detect_char detected.
majik 0:964eb6a2ef00 723 *
majik 0:964eb6a2ef00 724 * @ingroup API
majik 0:964eb6a2ef00 725 * @param int max The maximum number of chars to move.
majik 0:964eb6a2ef00 726 * @param char *s The destination buffer address
majik 0:964eb6a2ef00 727 */
majik 0:964eb6a2ef00 728 int move(char *s, int max) {
majik 0:964eb6a2ef00 729 return move(s, max, auto_detect_char);
majik 0:964eb6a2ef00 730 }
majik 0:964eb6a2ef00 731
majik 0:964eb6a2ef00 732 /**
majik 0:964eb6a2ef00 733 * Function: claim
majik 0:964eb6a2ef00 734 *
majik 0:964eb6a2ef00 735 * Redirect a stream to this MODSERIAL object
majik 0:964eb6a2ef00 736 *
majik 0:964eb6a2ef00 737 * Important: A name parameter must have been added when creating the MODSERIAL object:
majik 0:964eb6a2ef00 738 *
majik 0:964eb6a2ef00 739 * @code
majik 0:964eb6a2ef00 740 * #include "MODSERIAL.h"
majik 0:964eb6a2ef00 741 * ...
majik 0:964eb6a2ef00 742 * MODSERIAL pc(USBTX, USBRX, "modser");
majik 0:964eb6a2ef00 743 *
majik 0:964eb6a2ef00 744 * int main() {
majik 0:964eb6a2ef00 745 * pc.claim() // capture <stdout>
majik 0:964eb6a2ef00 746 * pc.printf("Uses the MODSERIAL library\r\n");
majik 0:964eb6a2ef00 747 * printf("So does this!\r\n");
majik 0:964eb6a2ef00 748 * }
majik 0:964eb6a2ef00 749 * @endcode
majik 0:964eb6a2ef00 750 *
majik 0:964eb6a2ef00 751 * @ingroup API
majik 0:964eb6a2ef00 752 * @param FILE *stream The stream to redirect (default = stdout)
majik 0:964eb6a2ef00 753 * @return true if succeeded, else false
majik 0:964eb6a2ef00 754 */
majik 0:964eb6a2ef00 755 bool claim(FILE *stream = stdout);
majik 0:964eb6a2ef00 756
majik 0:964eb6a2ef00 757 #if 0 // Inhereted from Serial/Stream, for documentation only
majik 0:964eb6a2ef00 758 /**
majik 0:964eb6a2ef00 759 * Function: putc
majik 0:964eb6a2ef00 760 *
majik 0:964eb6a2ef00 761 * Write a character
majik 0:964eb6a2ef00 762 * Inhereted from Serial/Stream
majik 0:964eb6a2ef00 763 *
majik 0:964eb6a2ef00 764 * @see http://mbed.org/projects/libraries/api/mbed/trunk/Serial#Serial.putc
majik 0:964eb6a2ef00 765 * @ingroup API
majik 0:964eb6a2ef00 766 * @param c The character to write to the serial port
majik 0:964eb6a2ef00 767 */
majik 0:964eb6a2ef00 768 int putc(int c);
majik 0:964eb6a2ef00 769 #endif
majik 0:964eb6a2ef00 770
majik 0:964eb6a2ef00 771 #if 0 // Inhereted from Serial/Stream, for documentation only
majik 0:964eb6a2ef00 772 /**
majik 0:964eb6a2ef00 773 * Function: printf
majik 0:964eb6a2ef00 774 *
majik 0:964eb6a2ef00 775 * Write a formated string
majik 0:964eb6a2ef00 776 * Inhereted from Serial/Stream
majik 0:964eb6a2ef00 777 *
majik 0:964eb6a2ef00 778 * @see http://mbed.org/projects/libraries/api/mbed/trunk/Serial#Serial.printf
majik 0:964eb6a2ef00 779 * @ingroup API
majik 0:964eb6a2ef00 780 * @param format A printf-style format string, followed by the variables to use in formating the string.
majik 0:964eb6a2ef00 781 */
majik 0:964eb6a2ef00 782 int printf(const char* format, ...);
majik 0:964eb6a2ef00 783 #endif
majik 0:964eb6a2ef00 784
majik 0:964eb6a2ef00 785 #if 0 // Inhereted from Serial/Stream, for documentation only
majik 0:964eb6a2ef00 786 /**
majik 0:964eb6a2ef00 787 * Function: scanf
majik 0:964eb6a2ef00 788 *
majik 0:964eb6a2ef00 789 * Read a formated string
majik 0:964eb6a2ef00 790 * Inhereted from Serial/Stream
majik 0:964eb6a2ef00 791 *
majik 0:964eb6a2ef00 792 * @see http://mbed.org/projects/libraries/api/mbed/trunk/Serial#Serial.scanf
majik 0:964eb6a2ef00 793 * @ingroup API
majik 0:964eb6a2ef00 794 * @param format - A scanf-style format string, followed by the pointers to variables to store the results.
majik 0:964eb6a2ef00 795 */
majik 0:964eb6a2ef00 796 int scanf(const char* format, ...);
majik 0:964eb6a2ef00 797 #endif
majik 0:964eb6a2ef00 798
majik 0:964eb6a2ef00 799 protected:
majik 0:964eb6a2ef00 800 /**
majik 0:964eb6a2ef00 801 * Used to pass information to callbacks.
majik 0:964eb6a2ef00 802 * @ingroup INTERNALS
majik 0:964eb6a2ef00 803 */
majik 0:964eb6a2ef00 804 MODSERIAL_IRQ_INFO callbackInfo;
majik 0:964eb6a2ef00 805
majik 0:964eb6a2ef00 806 /**
majik 0:964eb6a2ef00 807 * Remove the last char placed into the rx buffer.
majik 0:964eb6a2ef00 808 * This is an operation that can only be performed
majik 0:964eb6a2ef00 809 * by an rxCallback function. To protect the buffers
majik 0:964eb6a2ef00 810 * this function is defined protected so that a
majik 0:964eb6a2ef00 811 * regular application cannot call it directly. It
majik 0:964eb6a2ef00 812 * can only be called by the public version within a
majik 0:964eb6a2ef00 813 * MODSERIAL_IRQ_INFO class.
majik 0:964eb6a2ef00 814 * @ingroup INTERNALS
majik 0:964eb6a2ef00 815 * @return The byte removed from the buffer.
majik 0:964eb6a2ef00 816 */
majik 0:964eb6a2ef00 817 int rxDiscardLastChar(void);
majik 0:964eb6a2ef00 818
majik 0:964eb6a2ef00 819 private:
majik 0:964eb6a2ef00 820
majik 0:964eb6a2ef00 821 /**
majik 0:964eb6a2ef00 822 * A pointer to the UART peripheral base address being used.
majik 0:964eb6a2ef00 823 * @ingroup INTERNALS
majik 0:964eb6a2ef00 824 */
majik 0:964eb6a2ef00 825 void *_base;
majik 0:964eb6a2ef00 826
majik 0:964eb6a2ef00 827 /**
majik 0:964eb6a2ef00 828 * The last byte to pass through the TX IRQ handler.
majik 0:964eb6a2ef00 829 * @ingroup INTERNALS
majik 0:964eb6a2ef00 830 */
majik 0:964eb6a2ef00 831 volatile char txc;
majik 0:964eb6a2ef00 832
majik 0:964eb6a2ef00 833 /**
majik 0:964eb6a2ef00 834 * The last byte to pass through the RX IRQ handler.
majik 0:964eb6a2ef00 835 * @ingroup INTERNALS
majik 0:964eb6a2ef00 836 */
majik 0:964eb6a2ef00 837 volatile char rxc;
majik 0:964eb6a2ef00 838
majik 0:964eb6a2ef00 839 /**
majik 0:964eb6a2ef00 840 * Pointers to the TX and RX buffers.
majik 0:964eb6a2ef00 841 * @ingroup INTERNALS
majik 0:964eb6a2ef00 842 */
majik 0:964eb6a2ef00 843 volatile char *buffer[2];
majik 0:964eb6a2ef00 844
majik 0:964eb6a2ef00 845 /**
majik 0:964eb6a2ef00 846 * Buffer in pointers.
majik 0:964eb6a2ef00 847 * @ingroup INTERNALS
majik 0:964eb6a2ef00 848 */
majik 0:964eb6a2ef00 849 volatile int buffer_in[2];
majik 0:964eb6a2ef00 850
majik 0:964eb6a2ef00 851 /**
majik 0:964eb6a2ef00 852 * Buffer out pointers.
majik 0:964eb6a2ef00 853 * @ingroup INTERNALS
majik 0:964eb6a2ef00 854 */
majik 0:964eb6a2ef00 855 volatile int buffer_out[2];
majik 0:964eb6a2ef00 856
majik 0:964eb6a2ef00 857 /**
majik 0:964eb6a2ef00 858 * Buffer lengths.
majik 0:964eb6a2ef00 859 * @ingroup INTERNALS
majik 0:964eb6a2ef00 860 */
majik 0:964eb6a2ef00 861 volatile int buffer_size[2];
majik 0:964eb6a2ef00 862
majik 0:964eb6a2ef00 863 /**
majik 0:964eb6a2ef00 864 * Buffer content counters.
majik 0:964eb6a2ef00 865 * @ingroup INTERNALS
majik 0:964eb6a2ef00 866 */
majik 0:964eb6a2ef00 867 volatile int buffer_count[2];
majik 0:964eb6a2ef00 868
majik 0:964eb6a2ef00 869 /**
majik 0:964eb6a2ef00 870 * Buffer overflow.
majik 0:964eb6a2ef00 871 * @ingroup INTERNALS
majik 0:964eb6a2ef00 872 */
majik 0:964eb6a2ef00 873 volatile int buffer_overflow[2];
majik 0:964eb6a2ef00 874
majik 0:964eb6a2ef00 875 /**
majik 0:964eb6a2ef00 876 * Auto-detect character.
majik 0:964eb6a2ef00 877 * @ingroup INTERNALS
majik 0:964eb6a2ef00 878 */
majik 0:964eb6a2ef00 879 volatile char auto_detect_char;
majik 0:964eb6a2ef00 880
majik 0:964eb6a2ef00 881 /**
majik 0:964eb6a2ef00 882 * Callback system.
majik 0:964eb6a2ef00 883 * @ingroup INTERNALS
majik 0:964eb6a2ef00 884 */
majik 0:964eb6a2ef00 885 MODSERIAL_callback _isr[NumOfIrqTypes];
majik 0:964eb6a2ef00 886
majik 0:964eb6a2ef00 887 /**
majik 0:964eb6a2ef00 888 * TX Interrupt Service Routine.
majik 0:964eb6a2ef00 889 * @ingroup INTERNALS
majik 0:964eb6a2ef00 890 */
majik 0:964eb6a2ef00 891 void isr_tx(bool doCallback);
majik 0:964eb6a2ef00 892
majik 0:964eb6a2ef00 893 /**
majik 0:964eb6a2ef00 894 * TX Interrupt Service Routine stub version.
majik 0:964eb6a2ef00 895 * @ingroup INTERNALS
majik 0:964eb6a2ef00 896 */
majik 0:964eb6a2ef00 897 void isr_tx(void) { isr_tx(true); }
majik 0:964eb6a2ef00 898
majik 0:964eb6a2ef00 899
majik 0:964eb6a2ef00 900 /**
majik 0:964eb6a2ef00 901 * RX Interrupt Service Routine.
majik 0:964eb6a2ef00 902 * @ingroup INTERNALS
majik 0:964eb6a2ef00 903 */
majik 0:964eb6a2ef00 904 void isr_rx(void);
majik 0:964eb6a2ef00 905
majik 0:964eb6a2ef00 906 /**
majik 0:964eb6a2ef00 907 * Get a character from the RX buffer
majik 0:964eb6a2ef00 908 * @ingroup INTERNALS
majik 0:964eb6a2ef00 909 * @param bool True to block (wait for input)
majik 0:964eb6a2ef00 910 * @return A byte from the buffer.
majik 0:964eb6a2ef00 911 */
majik 0:964eb6a2ef00 912 int __getc(bool);
majik 0:964eb6a2ef00 913
majik 0:964eb6a2ef00 914 /**
majik 0:964eb6a2ef00 915 * Put a character from the TX buffer
majik 0:964eb6a2ef00 916 * @ingroup INTERNALS
majik 0:964eb6a2ef00 917 * @param bool True to block (wait for space in the TX buffer if full)
majik 0:964eb6a2ef00 918 * @return 0 on success
majik 0:964eb6a2ef00 919 */
majik 0:964eb6a2ef00 920 int __putc(int c, bool);
majik 0:964eb6a2ef00 921
majik 0:964eb6a2ef00 922 /**
majik 0:964eb6a2ef00 923 * Function: _putc
majik 0:964eb6a2ef00 924 * Overloaded virtual function.
majik 0:964eb6a2ef00 925 */
majik 0:964eb6a2ef00 926 virtual int _putc(int c) { return __putc(c, true); }
majik 0:964eb6a2ef00 927
majik 0:964eb6a2ef00 928 /**
majik 0:964eb6a2ef00 929 * Function: _getc
majik 0:964eb6a2ef00 930 * Overloaded virtual function.
majik 0:964eb6a2ef00 931 */
majik 0:964eb6a2ef00 932 virtual int _getc() { return __getc(true); }
majik 0:964eb6a2ef00 933
majik 0:964eb6a2ef00 934 /**
majik 0:964eb6a2ef00 935 * Function: init
majik 0:964eb6a2ef00 936 * Initialize the MODSERIAL object
majik 0:964eb6a2ef00 937 * @ingroup INTERNALS
majik 0:964eb6a2ef00 938 */
majik 0:964eb6a2ef00 939 void init(int txSize, int rxSize, PinName rx);
majik 0:964eb6a2ef00 940
majik 0:964eb6a2ef00 941 /**
majik 0:964eb6a2ef00 942 * Function: flushBuffer
majik 0:964eb6a2ef00 943 * @ingroup INTERNALS
majik 0:964eb6a2ef00 944 */
majik 0:964eb6a2ef00 945 void flushBuffer(IrqType type);
majik 0:964eb6a2ef00 946
majik 0:964eb6a2ef00 947 /**
majik 0:964eb6a2ef00 948 * Function: resizeBuffer
majik 0:964eb6a2ef00 949 * @ingroup INTERNALS
majik 0:964eb6a2ef00 950 */
majik 0:964eb6a2ef00 951 int resizeBuffer(int size, IrqType type = RxIrq, bool memory_check = true);
majik 0:964eb6a2ef00 952
majik 0:964eb6a2ef00 953 /**
majik 0:964eb6a2ef00 954 * Function: downSizeBuffer
majik 0:964eb6a2ef00 955 * @ingroup INTERNALS
majik 0:964eb6a2ef00 956 */
majik 0:964eb6a2ef00 957 int downSizeBuffer(int size, IrqType type, bool memory_check);
majik 0:964eb6a2ef00 958
majik 0:964eb6a2ef00 959 /**
majik 0:964eb6a2ef00 960 * Function: upSizeBuffer
majik 0:964eb6a2ef00 961 * @ingroup INTERNALS
majik 0:964eb6a2ef00 962 */
majik 0:964eb6a2ef00 963 int upSizeBuffer(int size, IrqType type, bool memory_check);
majik 0:964eb6a2ef00 964
majik 0:964eb6a2ef00 965
majik 0:964eb6a2ef00 966
majik 0:964eb6a2ef00 967
majik 0:964eb6a2ef00 968 //DEVICE SPECIFIC FUNCTIONS:
majik 0:964eb6a2ef00 969 private:
majik 0:964eb6a2ef00 970 /**
majik 0:964eb6a2ef00 971 * Set pointers to UART and IRQ
majik 0:964eb6a2ef00 972 */
majik 0:964eb6a2ef00 973 void setBase( void );
majik 0:964eb6a2ef00 974
majik 0:964eb6a2ef00 975 /**
majik 0:964eb6a2ef00 976 * If required, allows for adding specific settings
majik 0:964eb6a2ef00 977 */
majik 0:964eb6a2ef00 978 void initDevice( void );
majik 0:964eb6a2ef00 979
majik 0:964eb6a2ef00 980 IRQn_Type _IRQ;
majik 0:964eb6a2ef00 981
majik 0:964eb6a2ef00 982 public:
majik 0:964eb6a2ef00 983 /**
majik 0:964eb6a2ef00 984 * Function: txIsBusy
majik 0:964eb6a2ef00 985 *
majik 0:964eb6a2ef00 986 * If the Uart is still actively sending characters this
majik 0:964eb6a2ef00 987 * function will return true.
majik 0:964eb6a2ef00 988 *
majik 0:964eb6a2ef00 989 * @ingroup API
majik 0:964eb6a2ef00 990 * @return bool
majik 0:964eb6a2ef00 991 */
majik 0:964eb6a2ef00 992 bool txIsBusy(void);
majik 0:964eb6a2ef00 993
majik 0:964eb6a2ef00 994
majik 0:964eb6a2ef00 995 };
majik 0:964eb6a2ef00 996
majik 0:964eb6a2ef00 997 }; // namespace AjK ends
majik 0:964eb6a2ef00 998
majik 0:964eb6a2ef00 999 using namespace AjK;
majik 0:964eb6a2ef00 1000
majik 0:964eb6a2ef00 1001 #endif