Diff: SnStatusFrame.h

Revision:

10:3c93db1cfb12

Parent:

8:95a325df1f6b

Child:

21:ce51bb0ba4a5

--- a/SnStatusFrame.h	Thu Aug 09 02:16:08 2012 +0000
+++ b/SnStatusFrame.h	Fri Aug 10 18:35:43 2012 +0000
@@ -20,11 +20,25 @@
     
     static const uint8_t    kIOVers;    // MUST BE INCREASED if bytes written/read change!!
     
-    static const uint32_t   kMaxSizeOf =
+    static const uint32_t   kMaxSizeOfV1 =
                1u + sizeof(uint64_t)
             + (sizeof(uint32_t)*3u) + (sizeof(uint16_t))
             + (sizeof(uint8_t)*3u) + SnConfigFrame::kConfLblLen
             + SnEventFrame::kMaxSizeOf;
+    static const uint32_t   kMaxSizeOfV2 = 
+            sizeof(uint64_t) + (3u*sizeof(uint32_t)) + (2u*sizeof(uint16_t))
+            + (3u*sizeof(uint8_t)) + (2u*sizeof(float))
+            + SnConfigFrame::kConfLblLen;
+    static const uint32_t   kMaxSizeOf   = kMaxSizeOfV1;
+    
+    static
+    uint32_t    GetMaxSizeOf(const uint8_t rv) {
+        if (rv==1) {
+            return kMaxSizeOfV1;
+         } else {
+            return kMaxSizeOfV2;
+         }
+    }
     
     template<class T>
     static
@@ -32,7 +46,10 @@
                                       const SnConfigFrame::EDatPackBit type,
                                       const SnConfigFrame& conf,
                                       const SnEventFrame& evt,
-                                      char* const evtBuf) {
+                                      char* const evtBuf,
+                                      const uint16_t seq,
+                                      const float thmrate,
+                                      const float evtrate) {
         // expect 'x' to be a MODSERIAL& or a char const*
         
         uint8_t loseLSB=0, loseMSB=0;
@@ -47,44 +64,37 @@
         x = SnBitUtils::WriteTo(x, llen);
         x = SnBitUtils::WriteTo(x, conf.GetLabel(), llen);
         x = SnBitUtils::WriteTo(x, conf.GetRun());
+        x = SnBitUtils::WriteTo(x, seq);
         x = SnBitUtils::WriteTo(x, static_cast<uint32_t>(time(0)));
         x = SnBitUtils::WriteTo(x, loseLSB);
         x = SnBitUtils::WriteTo(x, loseMSB);
         x = SnBitUtils::WriteTo(x, wvBase);
+        x = SnBitUtils::WriteTo(x, thmrate);
+        x = SnBitUtils::WriteTo(x, evtrate);
+        /*
         x = WriteEventTo(x, evtBuf, evt, 
                          loseLSB, loseMSB, wvBase);
-        
+        */
         return SnCommWin::kOkMsgSent;
     }
-    
-    static
-    MODSERIAL& WriteEventTo(MODSERIAL& x, char* const evtBuf, const SnEventFrame& evt,
-                            const uint8_t loseLSB, const uint8_t loseMSB,
-                            const uint16_t wvBase) {
-        evt.WriteTo(evtBuf, loseLSB, loseMSB, wvBase);
-        x = SnBitUtils::WriteTo(x, evtBuf, evt.SizeOf(SnEventFrame::kIOVers,loseLSB, loseMSB));
-        return x;
-    }
-    
-    static
-    char* WriteEventTo(char* const x, char* const evtBuf, const SnEventFrame& evt,
-                       const uint8_t loseLSB, const uint8_t loseMSB,
-                       const uint16_t wvBase) {
-        return evt.WriteTo(x, loseLSB, loseMSB, wvBase);
-    }
-    
+
     static
     uint32_t SizeOf(const uint8_t rv, const uint32_t confLblLen,
                     const uint8_t loseLSB, const uint8_t loseMSB) {
         // number of bytes read/written during i/o
-        const uint32_t msz = kMaxSizeOf - SnConfigFrame::kConfLblLen 
+        const uint32_t maxsize = GetMaxSizeOf(rv);
+        const uint32_t msz = maxsize - SnConfigFrame::kConfLblLen 
                            + confLblLen;
-        if ((loseLSB==0) && (loseMSB==0)) {
+        if (rv==1) {
+            if ((loseLSB==0) && (loseMSB==0)) {
+                return msz;
+            } else {
+                return msz - maxsize
+                           + SnEventFrame::SizeOf(SnEventFrame::kIOVers,
+                                                  loseLSB, loseMSB);
+            }
+        } else {
             return msz;
-        } else {
-            return msz - SnEventFrame::kMaxSizeOf 
-                       + SnEventFrame::SizeOf(SnEventFrame::kIOVers,
-                                              loseLSB, loseMSB);
         }
     }