Diff: AsyncSerial/AsyncSerial.h

Revision:

7:5ba3a01e13c4

Parent:

6:9d48f2197243

Child:

8:de7aaaf557ba

--- a/AsyncSerial/AsyncSerial.h	Wed Apr 01 17:44:12 2015 +0100
+++ b/AsyncSerial/AsyncSerial.h	Thu Apr 02 14:01:21 2015 +0000
@@ -3,15 +3,21 @@
 
 #include "mbed.h"
 
+//#define NDEBUG 1
 
+#ifdef NDEBUG
+#define DEBUG(...) /* nothing */
+#else
+#define DEBUG(...) { printf(__VA_ARGS__); }
+#endif // NDEBUG
 
 
 class AsyncSerial : public SerialBase
 {
 public:
-    typedef void (*send_done_t)(const uint8_t* sendBuffer, uint16_t sendLength);
+    typedef void (*send_done_t)(const char* sendBuffer, uint16_t sendLength);
     typedef void (*receive_done_t)(uint8_t* receiveBuffer, uint16_t receiveLength, uint8_t status);
-    typedef void (*wait_done_t)(void);
+    typedef void (*wait_done_t)(uint8_t status);
 
     typedef enum {
         RECEIVE_FOUND,
@@ -21,11 +27,11 @@
 
     AsyncSerial(PinName tx, PinName rx, PinName rts, PinName cts);
 
-    void send(send_done_t handler, const uint8_t* sendBuffer, uint16_t sendLength);
+    void send(send_done_t handler, const char* sendBuffer, uint16_t sendLength);
 
     template<typename T>
-    void send(T* object, void (T::*member)(const uint8_t*, uint16_t),
-              const uint8_t* buffer, uint16_t length)
+    void send(T* object, void (T::*member)(const char*, uint16_t),
+              const char* buffer, uint16_t length)
     {
         if (object && member && buffer && length)
         {
@@ -41,21 +47,21 @@
 
     void receive(receive_done_t handler,
                  uint8_t* receiveBuffer, uint16_t maxLength,
-                 const uint8_t* conditionStartBuffer, uint16_t conditionStartLength,
-                 const uint8_t* conditionEndBuffer, uint16_t conditionEndLength,
+                 const char* conditionStartBuffer, uint16_t conditionStartLength,
+                 const char* conditionEndBuffer, uint16_t conditionEndLength,
                  uint32_t timeoutMilli);
 
     template<typename T>
     void receive(T* object, void (T::*member)(uint8_t*, uint16_t, uint8_t),
                  uint8_t* receiveBuffer, uint16_t maxLength,
-                 const uint8_t* conditionStartBuffer, uint16_t conditionStartLength,
-                 const uint8_t* conditionEndBuffer, uint16_t conditionEndLength,
+                 const char* conditionStartBuffer, uint16_t conditionStartLength,
+                 const char* conditionEndBuffer, uint16_t conditionEndLength,
                  uint32_t timeoutMilli)
     {
         if (object && member)
         {
             receiveObject = static_cast<void*>(object);
-            memcpy(receiveMember, (uint8_t*) &member, sizeof(member));
+            memcpy(receiveMember, &member, sizeof(member));
             receiveDoneObject = &AsyncSerial::receivemembercaller<T>;
 
             receiveDoneHandler = NULL;
@@ -68,22 +74,24 @@
     }
 
     void wait(wait_done_t handler,
-              const uint8_t* conditionEndBuffer, uint16_t conditionEndLength,
+              const char* conditionEndBuffer, uint16_t conditionEndLength,
               uint32_t timeoutMilli);
 
     template<typename T>
-    void wait(T* object, void (T::*member)(void),
-              const uint8_t* conditionEndBuffer, uint16_t conditionEndLength,
+    void wait(T* object, void (T::*member)(uint8_t),
+              const char* conditionEndBuffer, uint16_t conditionEndLength,
               uint32_t timeoutMilli)
-    {
+    {        
         if (object && member)
         {
             waitObject = static_cast<void*>(object);
-            memcpy(waitMember, (uint8_t*) &member, sizeof(member));
+            memcpy(waitMember, &member, sizeof(member));
             waitDoneObject = &AsyncSerial::waitmembercaller<T>;
 
             waitDoneHandler = NULL;
 
+            DEBUG("wait: %X %X\r\n", waitObject, member);
+
             receive(NULL, 0,
                     NULL, 0,
                     conditionEndBuffer, conditionEndLength,
@@ -98,19 +106,19 @@
     /*  Send buffer with length but without registering a callback function.
         Useful in conjunction with the receive callback.
     */
-    void send(const uint8_t* buffer, uint16_t length);
+    void send(const char* buffer, uint16_t length);
 
 private:
     void receive(uint8_t* receiveBuffer, uint16_t maxLength,
-                 const uint8_t* conditionStartBuffer, uint16_t conditionStartLength,
-                 const uint8_t* conditionEndBuffer, uint16_t conditionEndLength,
+                 const char* conditionStartBuffer, uint16_t conditionStartLength,
+                 const char* conditionEndBuffer, uint16_t conditionEndLength,
                  uint32_t timeoutMilli);
 
     template<typename T>
-    static void sendmembercaller(void* object, uint8_t* member, const uint8_t* buffer, uint16_t length)
+    static void sendmembercaller(void* object, uint8_t* member, const char* buffer, uint16_t length)
     {
         T* o = static_cast<T*>(object);
-        void (T::*m)(const uint8_t*, uint16_t);
+        void (T::*m)(const char*, uint16_t);
         memcpy(&m, member, sizeof(m));
         (o->*m)(buffer, length);
     }
@@ -125,12 +133,12 @@
     }
 
     template<typename T>
-    static void waitmembercaller(void* object, uint8_t* member)
+    static void waitmembercaller(void* object, uint8_t* member, uint8_t status)
     {
         T* o = static_cast<T*>(object);
-        void (T::*m)(void);
+        void (T::*m)(uint8_t);
         memcpy(&m, member, sizeof(m));
-        (o->*m)();
+        (o->*m)(status);
     }
 
     void putDone();
@@ -138,36 +146,36 @@
     void getDone(uint8_t status);
     void receiveTimeout();
 
-    const uint8_t* sendBuffer;
+    const char* sendBuffer;
     uint16_t sendLength;
     uint16_t sendIndex;
 
     send_done_t sendDoneHandler;
     void* sendObject;
     uint8_t sendMember[16];
-    void (*sendDoneObject)(void* object, uint8_t* member, const uint8_t* buffer, uint16_t length);
+    void (*sendDoneObject)(void* object, uint8_t* member, const char* buffer, uint16_t length);
 
     receive_done_t receiveDoneHandler;
     void* receiveObject;
     uint8_t receiveMember[16];
     void (*receiveDoneObject)(void* object, uint8_t* member, uint8_t* buffer, uint16_t length, uint8_t status);
 
-    receive_done_t waitDoneHandler;
+    wait_done_t waitDoneHandler;
     void* waitObject;
     uint8_t waitMember[16];
-    void (*waitDoneObject)(void* object, uint8_t* member);
+    void (*waitDoneObject)(void* object, uint8_t* member, uint8_t status);
 
     bool     isReceiving;
     uint8_t* receiveBuffer;
     uint16_t receiveMaxLength;
     uint16_t receiveIndex;
 
-    bool           insideCondition;
-    const uint8_t* conditionStartBuffer;
-    uint16_t       conditionStartLength;
-    const uint8_t* conditionEndBuffer;
-    uint16_t       conditionEndLength;
-    uint16_t       conditionIndex;
+    bool        insideCondition;
+    const char* conditionStartBuffer;
+    uint16_t    conditionStartLength;
+    const char* conditionEndBuffer;
+    uint16_t    conditionEndLength;
+    uint16_t    conditionIndex;
 
     Timeout timeout;
 };