dascubed/CubeMessages.h

Go to the documentation of this file.

/***************************************************************************
**
**  This file is part of dascubed.
**
**  This file may be distributed and/or modified under the terms of the
**  GNU General Public License version 2 or 3 as published by the Free
**  Software Foundation and appearing in the file LICENSE.GPL included
**  in the packaging of this file.
**
**  This file 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.
**
**  You should have received a copy of the GNU General Public License
**  along with this program. If not, see <http://www.gnu.org/licenses/>.
**
**  See http://www.geopsy.org for more information.
**
**  Created: 2011-05-25
**  Authors:
**    Marc Wathelet (ISTerre, Grenoble, France)
**
***************************************************************************/

#ifndef CUBEMESSAGES_H
#define CUBEMESSAGES_H

#include <WaranCore.h>
#include "CubeTcpServer.h"

class CubeBuffer;

enum MessageClass {ControlMessageClass=0x01,
                   ParameterMessageClass=0x02,
                   StatusMessageClass=0x03,
                   DataMessageClass=0x04};

class StartPayload
{
public:
  enum MessageId {MessageId=0x01};
};

class StopPayload
{
public:
  enum MessageId {MessageId=0x02};
};

class ResetPayload
{
public:
  enum MessageId {MessageId=0x03};
};

class FrequencyPayload
{
public:
  FrequencyPayload(int value) {_frequency.value=value;}

  enum MessageId {MessageId=0x01};

  inline void bigEndianValues();
  unsigned int value() const {return _frequency.value;}

  void get(CubeTcpServer * tcpServer) {sendTCP(tcpServer, value());}
  static void sendTCP(CubeTcpServer * tcpServer, unsigned int value);
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _frequency;
};

inline void FrequencyPayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_frequency.bytes);
#endif
}

class GainsPayload
{
public:
  GainsPayload(int hard, int soft) {_hard.value=hard; _soft.value=soft;}

  enum MessageId {MessageId=0x02};

  inline void bigEndianValues();
  unsigned int hard() const {return _hard.value;}
  unsigned int soft() const {return _soft.value;}

  void get(CubeTcpServer * tcpServer) {sendTCP(tcpServer, hard(), soft());}
  static void sendTCP(CubeTcpServer * tcpServer, unsigned int hard, unsigned int soft);
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _hard;
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _soft;
};

inline void GainsPayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_hard.bytes);
  ByteOrder::swap(_soft.bytes);
#endif
}

class TimeModePayload
{
public:
  TimeModePayload(int value) {_timeMode.value=value;}

  enum MessageId {MessageId=0x03};

  inline void bigEndianValues();
  unsigned int value() const {return _timeMode.value;}

  void get(CubeTcpServer * tcpServer) {sendTCP(tcpServer, value());}
  static void sendTCP(CubeTcpServer * tcpServer, unsigned int value);
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _timeMode;
};

inline void TimeModePayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_timeMode.bytes);
#endif
}

class OkPayload
{
public:
  enum MessageId {MessageId=0x01};

  unsigned char messageClass() const {return _messageClass;}
  unsigned char messageId() const {return _messageId;}

  void get(CubeTcpServer * tcpServer);
private:
  unsigned char _messageClass;
  unsigned char _messageId;
};

class ErrorPayload
{
public:
  enum MessageId {MessageId=0x02};

  inline void bigEndianValues();

  void get(CubeTcpServer * tcpServer, CubeBuffer * buffer);
private:
  unsigned char _messageClass;
  unsigned char _messageId;
  unsigned char _errorClass;
  unsigned char _errorId;
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _errorData;
};

inline void ErrorPayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_errorData.bytes);
#endif
}

class HardVersionPayload
{
public:
  enum MessageId {MessageId=0x03};

  void get(CubeTcpServer * tcpServer);
private:
  char _string[16];
};

class SoftVersionPayload
{
public:
  enum MessageId {MessageId=0x04};

  void get(CubeTcpServer * tcpServer);
private:
  char _string[16];
};

class BatteryPayload
{
public:
  enum MessageId {MessageId=0x05};

  inline void bigEndianValues();
  float value() const {return _battery.value/2048.0;}

  void get(CubeTcpServer * tcpServer);
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _battery;
};

inline void BatteryPayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_battery.bytes);
#endif
}

class TemperaturePayload
{
public:
  enum MessageId {MessageId=0x06};

  inline void bigEndianValues();
  float value() const {return _temperature.value*0.125;}

  void get(CubeTcpServer * tcpServer);
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _temperature;
};

inline void TemperaturePayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_temperature.bytes);
#endif
}

class DataPayload
{
public:
  DataPayload(int seqNum) {_sequenceNumber.value=seqNum;}

  enum MessageId {MessageId=0x01};

  inline void bigEndianValues();
  unsigned int sequenceNumber() const {return _sequenceNumber.value;}
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _sequenceNumber;
};

inline void DataPayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  ByteOrder::swap(_sequenceNumber.bytes);
#endif
}

class DataGetPayload: public DataPayload
{
public:
  inline void bigEndianValues();
  unsigned int numberOfSamples() const {return _numberOfSamples.value;}
  unsigned int ppsBegin() const {return _ppsBegin.value;}
  unsigned int sampleIndex() const {return _sampleIndex.value;}
private:
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _numberOfSamples;
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _ppsBegin;
  union {
    unsigned int value;
    unsigned char bytes[4];
  } _sampleIndex;
};

inline void DataGetPayload::bigEndianValues()
{
#if BYTE_ORDER==LITTLE_ENDIAN
  DataPayload::bigEndianValues();
  ByteOrder::swap(_numberOfSamples.bytes);
  ByteOrder::swap(_ppsBegin.bytes);
  ByteOrder::swap(_sampleIndex.bytes);
#endif
}

#endif // CUBEMESSAGES_H