transmitterState.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2014 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once

#include "managedInterface/message.h"

#include <string>
#include <vlpi/entityType.h>
#include <matrix/vlVector.h>
#include <vector>


class MANAGEDINTERFACE_DLL TransmitterStateMessage : public DtMessage
{
public:
   enum ModulationSystemType {ModulationSystemType_OTHER, ModulationSystemType_GENERIC, ModulationSystemType_HQ, ModulationSystemType_HQII, ModulationSystemType_HQIIA, ModulationSystemType_SINCGARS, ModulationSystemType_CCTT_SINCGARS, ModulationSystemType_EPLRS, ModulationSystemType_JTIDS};
   enum ModulationDetailAplitudeAngleType {ModulationDetailAplitudeAngleType_OTHER, ModulationDetailAplitudeAngleType_APLITUDE_ANGLE};
   enum ClearChannel {ClearChannel_NOT_CLEAR, ClearChannel_CLEAR};
   enum CryptoSystem {CryptoSystem_OTHER, CryptoSystem_KY_28, CryptoSystem_VINSON, CryptoSystem_NSVE, CryptoSystem_WSVE, CryptoSystem_SINGARS_ICOM, CryptoSystem_KY_75, CryptoSystem_KY_100};
   enum ModulationDetailPulseType {ModulationDetailPulseType_OTHER, ModulationDetailPulseType_PULSE, ModulationDetailPulseType_X_BAND, ModulationDetailPulseType_Y_BAND};
   enum InputSource {InputSource_OTHER, InputSource_PILOT, InputSource_COPILOT, InputSource_FIRST_OFFICER, InputSource_DRIVER, InputSource_LOADER, InputSource_GUNNER, InputSource_COMMANDER, InputSource_DIGITAL_DATA_DEVICE, InputSource_INTERCOM};
   enum ReferenceSystem {ReferenceSystem_WORLDCOORD=1, ReferenceSystem_ENTITYCOORD=2};
   enum ModulationDetailCombinationType {ModulationDetailCombinationType_OTHER, ModulationDetailCombinationType_AMPLITUDE_ANGLE_PULSE};
   enum ModulationMajorType {ModulationMajorType_OTHER, ModulationMajorType_AMPLITUDE, ModulationMajorType_AMPLITUDE_ANGLE, ModulationMajorType_ANGLE=3, ModulationMajorType_COMBINATION=4, ModulationMajorType_PULSE=5, ModulationMajorType_UNMODULATED=6, ModulationMajorType_CARRIER_PHASE_SHIFT=7};
   enum TransmitTerminalSecondaryMode {TransmitTerminalSecondaryMode_NONE, TransmitTerminalSecondaryMode_NET_POSITION_REFERENCE, TransmitTerminalSecondaryMode_PRIMARY_NAVIGATION_CONTROLLER, TransmitTerminalSecondaryMode_SECONDARY_NAVIGATION_CONTROLLER};
   enum TransmitState {TransmitState_OFF, TransmitState_RADIO_ON_NOT_TRANSMITTING, TransmitState_ON};
   enum CryptoMode {CryptoMode_BASEBAND, CryptoMode_DIPHASE};
   enum StartOfMessage {StartOfMessage_NOT_START, StartOfMessage_START};
   enum TransmitTerminalPrimaryMode {TransmitTerminalPrimaryMode_NTR, TransmitTerminalPrimaryMode_JTIDS};
   enum SyncState {SyncState_COURSE=1, SyncState_FINE=2};
   enum ModulationDetailCarrierPhaseShiftType {ModulationDetailCarrierPhaseShiftType_OTHER   };
   enum ModulationDetailUnmodulatedType {ModulationDetailUnmodulatedType_OTHER, ModulationDetailUnmodulatedType_CONTINOUS_WAVE};
   enum ModulationDetailAngleType {ModulationDetailAngleType_OTHER, ModulationDetailAngleType_FM, ModulationDetailAngleType_FSK, ModulationDetailAngleType_PM};
   enum ModulationDetailAplitudeType {ModulationDetailAplitudeType_OTHER, ModulationDetailAplitudeType_AFSK, ModulationDetailAplitudeType_AM, ModulationDetailAplitudeType_CW, ModulationDetailAplitudeType_DSB, ModulationDetailAplitudeType_ISB, ModulationDetailAplitudeType_LSB, ModulationDetailAplitudeType_SSB_FULL, ModulationDetailAplitudeType_SSB_REDUC, ModulationDetailAplitudeType_USB, ModulationDetailAplitudeType_VSB};
   enum AntennaPatternType {AntennaPatternType_OMNIDIRECTIONAL=0, AntennaPatternType_BEAM=1, AntennaPatternType_SPHERICALHARMONIC=2};


   struct SphericalAntennaPattern
   {
   unsigned char myOrder;
   std::vector<float> myCoefficients;
   ReferenceSystem myReferenceSystem;

        
      int size()
      {
         int size=0;
   size+=sizeof(unsigned char);
         size+=4; //for the count of the items in the list
   for(unsigned int i=0; i<myCoefficients.size(); i++)
   {
         size+=sizeof(float);
   }

   size+=sizeof(int);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeUInt8(myOrder);
   writer.writeInt32(myCoefficients.size()); //for the count of the items in the list
   for(unsigned int i=0; i<myCoefficients.size(); i++)
   {
      writer.writeSingle(myCoefficients[i]);
   }

   writer.writeInt32((int)myReferenceSystem);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myOrder=reader.readUInt8();
   unsigned int myCoefficients_count=reader.readInt32(); //for the count of the items in the list
   for(unsigned int i=0; i<myCoefficients_count; i++)
   {
      float afloat;
      afloat=reader.readSingle();
      myCoefficients.push_back(afloat);
   }
   myReferenceSystem=(ReferenceSystem)reader.readInt32();

      }
   };


   struct ModulationType
   {
   ModulationMajorType myMajor;
   unsigned short myDetail;
   ModulationSystemType mySystem;

        
      int size()
      {
         int size=0;
   size+=sizeof(int);
   size+=sizeof(unsigned short);
   size+=sizeof(int);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeInt32((int)myMajor);
   writer.writeUInt16(myDetail);
   writer.writeInt32((int)mySystem);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myMajor=(ModulationMajorType)reader.readInt32();
   myDetail=reader.readUInt16();
   mySystem=(ModulationSystemType)reader.readInt32();

      }
   };


   struct OmniAntennaPattern
   {

        
      int size()
      {
         int size=0;

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {

      }
        
      void deserialize(DtStreamReader& reader)
      {

      }
   };


   struct BeamAntennaPattern
   {
   DtTaitBryan myOrientation;
   float myAzimuthBeamWidth;
   float myElevationBeamWidth;
   ReferenceSystem myReferenceSystem;
   float myEZ;
   float myEX;
   float myPhase;

        
      int size()
      {
         int size=0;
   size+=sizeof(double)*3;
   size+=sizeof(float);
   size+=sizeof(float);
   size+=sizeof(int);
   size+=sizeof(float);
   size+=sizeof(float);
   size+=sizeof(float);

         return size;
      }

      void serialize(DtStreamWriter& writer)
      {
   writer.writeDouble(myOrientation.psi());
   writer.writeDouble(myOrientation.theta());
   writer.writeDouble(myOrientation.phi());
   
   writer.writeSingle(myAzimuthBeamWidth);
   writer.writeSingle(myElevationBeamWidth);
   writer.writeInt32((int)myReferenceSystem);
   writer.writeSingle(myEZ);
   writer.writeSingle(myEX);
   writer.writeSingle(myPhase);

      }
        
      void deserialize(DtStreamReader& reader)
      {
   myOrientation.setPsi(reader.readDouble());
   myOrientation.setTheta(reader.readDouble());
   myOrientation.setPhi(reader.readDouble());
   
   myAzimuthBeamWidth=reader.readSingle();
   myElevationBeamWidth=reader.readSingle();
   myReferenceSystem=(ReferenceSystem)reader.readInt32();
   myEZ=reader.readSingle();
   myEX=reader.readSingle();
   myPhase=reader.readSingle();

      }
   };




  TransmitterStateMessage();
  virtual ~TransmitterStateMessage();

   virtual std::string getEntityId();
   virtual void setEntityId(std::string val);

   virtual unsigned short getRadioId();
   virtual void setRadioId(unsigned short val);

   virtual std::string getHostObjectId();
   virtual void setHostObjectId(std::string val);

   virtual DtEntityType getRadioEntityType();
   virtual void setRadioEntityType(DtEntityType val);

   virtual TransmitState getTransmitState();
   virtual void setTransmitState(TransmitState val);

   virtual InputSource getInputSource();
   virtual void setInputSource(InputSource val);

   virtual DtVector getWorldAntennaLocation();
   virtual void setWorldAntennaLocation(DtVector val);

   virtual DtVector32 getRelativeAntennaLocation();
   virtual void setRelativeAntennaLocation(DtVector32 val);

   virtual AntennaPatternType getAntennaPatternType();
   virtual void setAntennaPatternType(AntennaPatternType val);

   virtual unsigned long long getFrequency();
   virtual void setFrequency(unsigned long long val);

   virtual float getTransmitBandwidth();
   virtual void setTransmitBandwidth(float val);

   virtual float getPower();
   virtual void setPower(float val);

   virtual ModulationType getModulationType();
   virtual void setModulationType(ModulationType val);

   virtual CryptoMode getCryptoMode();
   virtual void setCryptoMode(CryptoMode val);

   virtual CryptoSystem getCryptoSystem();
   virtual void setCryptoSystem(CryptoSystem val);

   virtual unsigned short getCryptoKey();
   virtual void setCryptoKey(unsigned short val);

   virtual std::vector<unsigned char> getModulationParameters();
   virtual void setModulationParameters(std::vector<unsigned char> val);

   virtual std::vector<unsigned char> getAntennaPatternParameters();
   virtual void setAntennaPatternParameters(std::vector<unsigned char> val);

   virtual bool getFreqHopInUse();
   virtual void setFreqHopInUse(bool val);

   virtual bool getPseudoNoiseInUse();
   virtual void setPseudoNoiseInUse(bool val);

   virtual bool getTimeHopInUse();
   virtual void setTimeHopInUse(bool val);



  virtual int messageSize();
  
   static DtMessage* decode(unsigned char* buffer, int length);
   static std::string theMessageName();

protected:
   static std::string theFullName;

   std::string myEntityId;
   unsigned short myRadioId;
   std::string myHostObjectId;
   DtEntityType myRadioEntityType;
   TransmitState myTransmitState;
   InputSource myInputSource;
   DtVector myWorldAntennaLocation;
   DtVector32 myRelativeAntennaLocation;
   AntennaPatternType myAntennaPatternType;
   unsigned long long myFrequency;
   float myTransmitBandwidth;
   float myPower;
   ModulationType myModulationType;
   CryptoMode myCryptoMode;
   CryptoSystem myCryptoSystem;
   unsigned short myCryptoKey;
   std::vector<unsigned char> myModulationParameters;
   std::vector<unsigned char> myAntennaPatternParameters;
   bool myFreqHopInUse;
   bool myPseudoNoiseInUse;
   bool myTimeHopInUse;

   virtual void serialize(DtStreamWriter& writer);
   virtual void deserialize(DtStreamReader& reader);
};