SE_GOESXmtr.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/

#ifndef NIDAS_DYNLD_ISFF_SE_GOESXMTR_H
#define NIDAS_DYNLD_ISFF_SE_GOESXMTR_H

#include "GOESXmtr.h"
#include <nidas/core/IOChannel.h>
#include <nidas/core/SampleTag.h>
#include <nidas/util/UTime.h>
#include <nidas/util/Logger.h>
#include <nidas/util/EndianConverter.h>

#include <string>
#include <iostream>
#include <vector>

namespace nidas { namespace dynld { namespace isff {

using namespace nidas::core;

class SE_GOESXmtr: public GOESXmtr {

public:

    SE_GOESXmtr();

    SE_GOESXmtr(const SE_GOESXmtr&);

    ~SE_GOESXmtr();

    SE_GOESXmtr* clone() const { return new SE_GOESXmtr(*this); }

    void setRFBaud(long val) throw(nidas::util::InvalidParameterException);

    int getRFBaud() const
    {
        return _rfBaud;
    }
    
    void init() throw (nidas::util::IOException);

    int getModel() const { return _model; }

    void setModel(int val) { _model = val; }

    int getMaxRFBaud() const { return _maxRFBaud; }

    virtual bool isNewFile() const { return false; }

    void transmitData(const nidas::util::UTime& sendTime,
        int configid,const Sample*)
        throw (nidas::util::IOException);

    void transmitDataSE110(const nidas::util::UTime& sendTime,
        int configid,const Sample*)
        throw (nidas::util::IOException);

    void transmitDataSE120(const nidas::util::UTime& sendTime,
        int configid,const Sample*)
        throw (nidas::util::IOException);

    void close() throw (nidas::util::IOException)
    {
        _port.close();
    }

    size_t send(const std::string& msg) throw(nidas::util::IOException);

    size_t send(char c) throw(nidas::util::IOException);

    std::string recv() throw(nidas::util::IOException);

    void flush() throw(nidas::util::IOException)
    {
        _port.flushBoth();
    }

    static std::string fix(const std::string& msg);

    static std::string unfix(const std::string& msg);

    static char crc(const std::string& msg);

    void encodeClock(const nidas::util::UTime& ut,char* out,bool fractsecs);

    nidas::util::UTime decodeClock(const char* in);

    void wakeup() throw(nidas::util::IOException);

    void tosleep() throw(nidas::util::IOException);

    void query() throw(nidas::util::IOException);

    int detectModel() throw(nidas::util::IOException);

    bool testTransmitSE120() throw(nidas::util::IOException);

    void cancelTransmit(const nidas::util::UTime& at)
        throw(nidas::util::IOException);

    int checkStatus() throw(nidas::util::IOException);

    void printStatus() throw();

    void printStatus(std::ostream&) throw();

    void setXmtrId() throw(nidas::util::IOException);

    unsigned long getXmtrId() throw(nidas::util::IOException);

    void setXmtrClock() throw(nidas::util::IOException);

    nidas::util::UTime getXmtrClock() throw(nidas::util::IOException);

    int getXmtrClockDelay(int nchar) const;

    unsigned long checkId() throw(nidas::util::IOException);

    int checkClock() throw(nidas::util::IOException);

    void transmitDataSE110() throw(nidas::util::IOException);

    void reset() throw(nidas::util::IOException);

    void doSelfTest() throw(nidas::util::IOException);

    int getSelfTestResults() throw(nidas::util::IOException);

    static std::string codeString(char pktType);

    void checkResponse(char ptype,const std::string& resp)
        throw(nidas::util::IOException);
    
    void checkACKResponse(char ptype,const std::string& resp,char seqnum)
        throw(nidas::util::IOException);
    
    void getBatteryVoltages(float &current, float& before, float& during)
        throw(nidas::util::IOException);

    static const char SOH = '\x1';

    static const char EOT = '\x4';

    static const std::string SOH_STR;

    struct SE_Codes {
        int value;
    const char* msg;
    };

    std::string getSelfTestStatusString();

    static const char PKT_GET_ID = '\x10';

    static const char PKT_SET_ID = '\x11';

    static const char PKT_SET_TIME = '\x13';

    static const char PKT_GET_TIME = '\x14';

    static const char PKT_XMT_DATA = '\x15';

    static const char PKT_CANCEL_XMT = '\x16';

    static const char PKT_GET_XMT_QUE = '\x17';

    static const char PKT_QUERY = '\x18';

    static const char PKT_SET_GLOBALS = '\x1b';

    static const char PKT_GET_GLOBALS = '\x1c';

    static const char PKT_DISPLAY_VERSION = '\x1d';

    static const char PKT_XMT_DATA_SE120 = '\x1e';

    static const char PKT_POLL_ENABLE = 0x38;
    static const char PKT_POLL_DATA_GET = 0x39;
    static const char PKT_POLL_DATA_SET = 0x3a;

    static const char PKT_GET_SE1200_STATUS = '\x74';

    static const char PKT_RESET_XMTR = '\x76';

    static const char PKT_SELFTEST_DISPL = '\x77';

    static const char PKT_SELFTEST_START = '\x78';

    static const char PKT_SEND_FIXED_CHAN = '\x7a';

    static const char PKT_SOFTWARE_LOAD = '\x7c';

    /* Acknowledge from xmtr to a xmt data request,
     * load SDI script or polled xmt data req.
     * Indicates prev. pkt was OK.
     */
    static const char PKT_ACKNOWLEDGE = '\x80';

    static const char PKT_ERR_RESPONSE = '\xf0';

    static struct SE_Codes cmdCodes[];

    /* Signal Engineering Error Response Codes from the xmtr
     * for Type Code F0 (PKT_ERR_RESPONSE).
     */
    static const char PKT_STATUS_OK = 0;

    static const char PKT_STATUS_ILLEGAL_REQUEST = 0x01;

    static const char PKT_STATUS_ITEM_NOT_FOUND = 0x03;

    static const char PKT_STATUS_INVALID_DATE_TIME = 0x04;

    static const char PKT_STATUS_TRANSMIT_OVERLAP = 0x05;

    static const char PKT_STATUS_INVALID_CHANNEL = 0x06;

    static const char PKT_STATUS_INVALID_TRANSMIT_INTERVAL = 0x07;

    static const char PKT_STATUS_EEPROM_NOT_UPDATED = 0x08;

    static const char PKT_STATUS_INVALID_REPEAT_COUNT = 0x09;

    static const char PKT_STATUS_CLOCK_NOT_LOADED = 0x0a;

    static const char PKT_STATUS_CRC_ERROR_ON_LOAD = 0x0b;

    static const char* statusCodeStrings[];

    /* Received Packet Too Long */
    static const char ERR_TOOLONG = 0x01;

    /* Received Packet Too Short */
    static const char ERR_TOOSHORT = 0x02;

    /* Received Packet Checksum Error */
    static const char ERR_CRC = 0x03;

    /* Invalid Type Code */
    static const char ERR_BADTYPE = 0x04;

    /* SE110 only: Length Field mismatch */
    static const char ERR_BADLEN = 0x05;

    /* Unable to Allocate Memory */
    static const char ERR_MEMORY = 0x06;

    /* SE110 only: Invalid Sequence Number */
    static const char ERR_SEQUENCE = 0x07;

    /* Command Timeout for multi-packet Command */
    static const char ERR_TIMEOUT = 0x08;

    static const char* errorCodeStrings[];

    static struct selfTest {
        short mask;
    const char* text;
    } selfTestCodes[2][10];

private:
    
    static const nidas::util::EndianConverter* _fromBig;

    size_t read(void* buf, size_t len) throw (nidas::util::IOException);

    size_t write(const void* buf, size_t len) throw (nidas::util::IOException);

    size_t write(const struct iovec* iov, int iovcnt) throw (nidas::util::IOException);

    int _model;

    int _clockDiffMsecs;

    nidas::util::UTime _transmitQueueTime;

    nidas::util::UTime _transmitAtTime;

    nidas::util::UTime _transmitSampleTime;

    std::string _lastXmitStatus;

    std::string _softwareBuildDate;

    short _selfTestStatus;

    int _maxRFBaud;

    bool _gpsInstalled;

    size_t _xmitNbytes;

    unsigned long _activeId;

    int _rfBaud;

    SE_GOESXmtr& operator=(const SE_GOESXmtr&);

};


}}} // namespace nidas namespace dynld namespace isff

#endif