File content as of revision 21:ce51bb0ba4a5:

#ifndef SN_SnStatusFrame
#define SN_SnStatusFrame

#include <stdint.h>

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

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;
    
    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
        uint32_t nfiles(0);
        float totbytes(0);
        SnSDUtils::GetDirProps(SnSDUtils::kSDdir, nfiles, totbytes);
        if (strcmp(SnSDUtils::kSDdir, SnSDUtils::kSDsubDir)!=0) {
            uint32_t sf(0);
            float sb(0);
            SnSDUtils::GetDirProps(SnSDUtils::kSDsubDir, sf, sb);
            nfiles   += sf;
            totbytes += sb;
        }
        totbytes /= 1000; // KB
        x = SnBitUtils::WriteTo(x, nfiles);
        x = SnBitUtils::WriteTo(x, totbytes);
        
        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