File content as of revision 28:484943132bb0:

#ifndef SN_SnStatusFrame
#define SN_SnStatusFrame

#include <stdint.h>

#include "SnBitUtils.h"
#include "SnCommWin.h"
#include "SnConfigFrame.h"
#include "SnEventFrame.h"
#include "SnSDUtils.h"

//#define ST_DEBUG

struct SnStatusFrame {
    //
    // A simple struct (everything public) to function like namespace.
    // The contents of the status frame are sent from here, in order to
    // help make sure the status frame is the same for each comm method.
    //
    // No member variables are used in order to preserve memory on the mbed.
    // (i.e. no actual status frame middle-man object exists)
    //
    
    static const uint8_t    kIOVers;    // MUST BE INCREASED if bytes written/read change!!
    
    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   kMaxSizeOfV3 = 
            kMaxSizeOfV2 + sizeof(uint32_t) + sizeof(float);
    static const uint32_t   kMaxSizeOf   = kMaxSizeOfV1;
    
 public:
    static bool             fgRecalcFiles;
 private:
    static uint32_t         fgNfiles;
    static float            fgTotKbytes;
 public:
    static
    uint32_t    GetNfiles() { return fgNfiles; }
    static
    float       GetTotKbytes() { return fgTotKbytes; }
    
    static
    uint32_t    GetMaxSizeOf(const uint8_t rv) {
        if (rv==1) {
            return kMaxSizeOfV1;
         } else if (rv==2) {
            return kMaxSizeOfV2;
         } else {
            return kMaxSizeOfV3;
         }
    }
    
    template<class T>
    static
    SnCommWin::ECommWinResult WriteTo(T& x,
                                      const SnConfigFrame& conf,
                                      const SnEventFrame& evt,
                                      char* const evtBuf,
                                      const uint16_t seq,
                                      const float thmrate,
                                      const float evtrate,
                                      const uint8_t loseLSB,
                                      const uint8_t loseMSB,
                                      const uint16_t wvBase) {
        // expect 'x' to be a MODSERIAL& or a char const*
        
        const uint32_t llen = strlen(conf.GetLabel());
        
        // if anything about these writes changes, update kIOVers and SizeOf
        x = SnBitUtils::WriteTo(x, SnStatusFrame::kIOVers);
        x = SnBitUtils::WriteTo(x, conf.GetMacAddress());
        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);
        // file info
        if (fgRecalcFiles) {
#ifdef ST_DEBUG
            printf("Calling GetDirProps for %s\r\n",SnSDUtils::kSDdir);
#endif
            SnSDUtils::GetDirProps(SnSDUtils::kSDdir, fgNfiles, fgTotKbytes);
            fgTotKbytes /= 1e3; // KB
#ifdef ST_DEBUG
            printf("nfiles=%u, tb=%g kb\r\n",fgNfiles,fgTotKbytes);
#endif
            fgRecalcFiles = false;
        }
        x = SnBitUtils::WriteTo(x, fgNfiles);
        x = SnBitUtils::WriteTo(x, fgTotKbytes);
        
        return SnCommWin::kOkMsgSent;
    }

    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 maxsize = GetMaxSizeOf(rv);
        const uint32_t msz = maxsize - SnConfigFrame::kConfLblLen 
                           + confLblLen;
        if (rv==1) {
            if ((loseLSB==0) && (loseMSB==0)) {
                return msz;
            } else {
                return msz - maxsize
                           + SnEventFrame::SizeOf(SnEventFrame::kIOVers,
                                                  loseLSB, loseMSB);
            }
        } else {
            return msz;
        }
    }
    
    static
    uint32_t SizeOf(const uint8_t rv, const SnConfigFrame& conf) {
        return SizeOf(rv, conf.GetLabelStrLen(),
                      conf.GetWvLoseLSB(), conf.GetWvLoseMSB());
    }
    
};

#endif // SN_SnStatusFrame