RsaTypes.h

Go to the documentation of this file.

#pragma once
#include <misc/gen/Value.h>
#include <rsa/iface/global.h>
 
namespace sf
{

constexpr const char* US_METHOD_PEAK = "Peak";

constexpr const char* US_METHOD_COPY = "Copy";

struct _RSA_CLASS RsaTypes
{
    typedef unsigned long long IdType;

    typedef TVector<IdType> IdList;

    typedef void (*NotifyProc)(void* data, IdType id);

    struct _RSA_CLASS ParamState
    {
        ParamState() = default;
 
        ParamState(const ParamState& ps) = default;
 
        ParamState(std::string name, Value val)
          : name(std::move(name))
          , value(std::move(val))
        {}
 
        bool operator==(const ParamState& ps) const
        {
          return name == ps.name;
        }

        std::string name;
        Value value;
    };

    typedef TVector<ParamState> ParamStates;

    enum EParamFlag
    {
      pfReadonly = 1 << 0,
      pfEffectsParameter = 1 << 1,
      pfEffectsResult = 1 << 2,
      pfEffectsData = 1 << 3,
      pfChannelSingle = 1 << 4,
      pfGate = 1 << 5,
      pfMethod = 1 << 6,
      pfExport = 1 << 7,
      pfSystem = 1 << 8,
      pfWriteable = 1 << 9,
      pfAlias = 1 << 10,
      pfArchive = 1 << 11,
      pfWriteAtOff = 1 << 12,
    };

    enum EResultFlag
    {
      rfGate = 1 << 0,// Result is generated by a gate.
      rfIndex = 1 << 1,// Result contains synced i/o input.
      rfAsync = 1 << 2,// Result data is not sync synchronous.
      rfAsyncIndex = 1 << 3,// Result keeps track of sync counter values at the time async data was generated.
      rfHugeData = 1 << 4,// Result that generates a huge amount of data.
      rfStored = 1 << 5,// Generates data to be stored.
    };

    struct _RSA_CLASS ParamInfo
    {
        ParamInfo()
        {
          Init();
        }
 
        ParamInfo(const ParamInfo& pi)
        {
          Copy(pi);
        }
 
        ParamInfo& operator=(const ParamInfo& pi)
        {
          Copy(pi);
          return *this;
        }
 
        void Init()
        {
          Id = 0;
          Flags = 0;
          Gate = 0;
          Index = 0;
          Channel = 0;
          Name.clear();
          Unit.clear();
          Description.clear();
          Round.setType(Value::vitUndefined);
          Default.set(Round);
          Minimum.set(Round);
          Maximum.set(Round);
          States.clear();
        }
 
        ParamInfo& Copy(const ParamInfo& pi)
        {
          Id = pi.Id;
          Name = pi.Name;
          Description = pi.Description;
          Gate = pi.Gate;
          Channel = pi.Channel;
          Flags = pi.Flags;
          Index = pi.Index;
          Round = pi.Round;
          Default = pi.Default;
          Maximum = pi.Maximum;
          Minimum = pi.Minimum;
          States = pi.States;
          return *this;
        }

        IdType Id{0};
        unsigned Gate{0};
        unsigned Index{0};
        unsigned Channel{0};
        std::string Name;
        std::string Unit;
        std::string Description;
        Value Round;
        Value Default;
        Value Minimum;
        Value Maximum;
        ParamStates States;
        int Flags{0};
    };

    struct _RSA_CLASS ResultInfo
    {
        ResultInfo() = default;
 
        void reset()
        {
          Id = 0;
          Flags = 0;
          Gate = 0;
          Index = 0;
          Channel = 0;
          Name.clear();
          Description.clear();
          Bits = 0;
          WordSize = 0;
          ArraySize = 0;
          Offset = 0;
        }
 
        ResultInfo(const ResultInfo& pi)
        {
          Copy(pi);
        }
 
        ResultInfo& operator=(const ResultInfo& pi)
        {
          Copy(pi);
          return *this;
        }
 
        ResultInfo& Copy(const ResultInfo& pi)
        {
          Id = pi.Id;
          Flags = pi.Flags;
          Name = pi.Name;
          Gate = pi.Gate;
          Index = pi.Index;
          Channel = pi.Channel;
          WordSize = pi.WordSize;
          ArraySize = pi.ArraySize;
          Bits = pi.Bits;
          Offset = pi.Offset;
          return *this;
        }

        IdType Id{0};
        int Flags{0};
        unsigned Gate{0};
        unsigned Index{0};
        unsigned Channel{0};
        std::string Name;
        std::string Description;
        unsigned Bits{0};
        unsigned WordSize{0};
        unsigned ArraySize{0};
        int Offset{0};
    };

    struct BufferInfo
    {
        BufferInfo() = default;

        void Clear()
        {
          Buffer = nullptr;
          Size = 0;
          BlockBufSize = 0;
          Remain = 0;
          Counter = 0;
        }

        void* Buffer{nullptr};
        size_t Size{0};
        size_t BlockBufSize{0};
        size_t Remain{0};
        size_t Counter{0};
    };

    enum EAcquisitionType
    {
      atUltrasonic,
      atEddyCurrent
    };

    enum EDefaultParam : uint64_t
    {
      apNone = 0x0000,
      /*
       * Interface parameters from here.
       * 0x0000 is used for the interface implementation parameter.
       * 0x0001 is used for the RunMode parameter.
       */
      apChannels = 0x0002,
      apError = 0x0003,
      // Restart is imminent when an error occurs less than zero.
      // Acquisition cannot continue when errors occur larger than zero.
      apErrorMessage = 0x0004,
      apAmplitudeUnit = 0x0005,
      apUserFirst = 0x000F,
      /*
       * Channel parameters from here.
       */
      apChannel_Mask = 0x4000,
      apChannel_RepRate = 0x4001,
      apChannel_SyncMode = 0x4002,
      apChannel_Gates = 0x4003,
      apChannel_Inputs = 0x4004,
      apChannel_TimeUnits = 0x4005,
      apChannel_CopyDelay = 0x4006,
      apChannel_CopyRange = 0x4007,
      apChannel_SampleRate = 0x4008,
      apChannel_CopyEnable = 0x4009,
      apChannel_PopManual = 0x400A,
      apChannel_BiDirMode = 0x400B,
      apChannel_UserFirst = 0x401F,
      /*
       * Gate parameters from here.
       */
      apGate_Mask = 0x8000,
      apGate_Name = 0x8001,
      apGate_Delay = 0x8002,
      apGate_Range = 0x8003,
      apGate_SlaveTo = 0x8004,
      apGate_Enable = 0x8005,
      apGate_Method = 0x8006,
      apGate_Threshold = 0x8007,
      apGate_Amplitude = 0x8008,
      apGate_TimeOfFlight = 0x8009,
      apGate_UserFirst = 0x801F,
    };

    enum EDefaultResult : uint64_t
    {
      arNone = 0x0000,
      arUserFirst = 0x0001,
      /*
       * Channel results from here.
       */
      arChannel_Mask = 0x4000,
      arChannel_PopIndex = 0x4001,
      arChannel_CopyData = 0x4002,
      arChannel_CopyIndex = 0x4003,
      arChannel_UserFirst = 0x401F,
      /*
       * Gate results from here.
       */
      arGate_Amplitude = 0x8001,
      arGate_TimeOfFlight = 0x8002,
      arGate_Copy = 0x8003,
      arGate_Mask = 0x8000,
      arGate_UserFirst = 0x801F
    };

    enum EPopManual
    {
      pmDisabled = 0,
      pmReady,
      pmTrigger
    };
};
 
}// namespace sf