//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 3.0.6
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------

namespace mscl {

public class WirelessNode : global::System.IDisposable {
  private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  protected bool swigCMemOwn;

  internal WirelessNode(global::System.IntPtr cPtr, bool cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  }

  internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WirelessNode obj) {
    return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  }

  ~WirelessNode() {
    Dispose();
  }

  public virtual void Dispose() {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          msclPINVOKE.delete_WirelessNode(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      global::System.GC.SuppressFinalize(this);
    }
  }

  public WirelessNode(uint nodeAddress, BaseStation basestation) : this(msclPINVOKE.new_WirelessNode(nodeAddress, BaseStation.getCPtr(basestation)), true) {
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public static WirelessNode Mock(uint nodeAddress, BaseStation basestation, NodeInfo info) {
    WirelessNode ret = new WirelessNode(msclPINVOKE.WirelessNode_Mock__SWIG_0(nodeAddress, BaseStation.getCPtr(basestation), NodeInfo.getCPtr(info)), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static WirelessNode Mock(uint nodeAddress, BaseStation basestation, NodeInfo info, EepromMap initialEepromCache) {
    WirelessNode ret = new WirelessNode(msclPINVOKE.WirelessNode_Mock__SWIG_1(nodeAddress, BaseStation.getCPtr(basestation), NodeInfo.getCPtr(info), EepromMap.getCPtr(initialEepromCache)), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public static string deviceName(uint nodeAddress) {
    string ret = msclPINVOKE.WirelessNode_deviceName(nodeAddress);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public NodeFeatures features() {
    NodeFeatures ret = new NodeFeatures(msclPINVOKE.WirelessNode_features(swigCPtr), false);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Timestamp lastCommunicationTime() {
    Timestamp ret = new Timestamp(msclPINVOKE.WirelessNode_lastCommunicationTime(swigCPtr), false);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void setBaseStation(BaseStation basestation) {
    msclPINVOKE.WirelessNode_setBaseStation(swigCPtr, BaseStation.getCPtr(basestation));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public BaseStation getBaseStation() {
    BaseStation ret = new BaseStation(msclPINVOKE.WirelessNode_getBaseStation(swigCPtr), false);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool hasBaseStation(BaseStation basestation) {
    bool ret = msclPINVOKE.WirelessNode_hasBaseStation(swigCPtr, BaseStation.getCPtr(basestation));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void useGroupRead(bool useGroup) {
    msclPINVOKE.WirelessNode_useGroupRead(swigCPtr, useGroup);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void readWriteRetries(byte numRetries) {
    msclPINVOKE.WirelessNode_readWriteRetries__SWIG_0(swigCPtr, numRetries);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public byte readWriteRetries() {
    byte ret = msclPINVOKE.WirelessNode_readWriteRetries__SWIG_1(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void useEepromCache(bool useCache) {
    msclPINVOKE.WirelessNode_useEepromCache(swigCPtr, useCache);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void clearEepromCache() {
    msclPINVOKE.WirelessNode_clearEepromCache(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void updateEepromCacheFromNodeDiscovery(NodeDiscovery nodeDisovery) {
    msclPINVOKE.WirelessNode_updateEepromCacheFromNodeDiscovery(swigCPtr, NodeDiscovery.getCPtr(nodeDisovery));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public EepromMap getEepromCache() {
    EepromMap ret = new EepromMap(msclPINVOKE.WirelessNode_getEepromCache(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public uint nodeAddress() {
    uint ret = msclPINVOKE.WirelessNode_nodeAddress(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.Frequency frequency() {
    WirelessTypes.Frequency ret = (WirelessTypes.Frequency)msclPINVOKE.WirelessNode_frequency(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.CommProtocol communicationProtocol() {
    WirelessTypes.CommProtocol ret = (WirelessTypes.CommProtocol)msclPINVOKE.WirelessNode_communicationProtocol(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public Version firmwareVersion() {
    Version ret = new Version(msclPINVOKE.WirelessNode_firmwareVersion(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessModels.NodeModel model() {
    WirelessModels.NodeModel ret = (WirelessModels.NodeModel)msclPINVOKE.WirelessNode_model(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public string serial() {
    string ret = msclPINVOKE.WirelessNode_serial(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public string name() {
    string ret = msclPINVOKE.WirelessNode_name(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.MicroControllerType microcontroller() {
    WirelessTypes.MicroControllerType ret = (WirelessTypes.MicroControllerType)msclPINVOKE.WirelessNode_microcontroller(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public RadioFeatures radioFeatures() {
    RadioFeatures ret = new RadioFeatures(msclPINVOKE.WirelessNode_radioFeatures(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ulong dataStorageSize() {
    ulong ret = msclPINVOKE.WirelessNode_dataStorageSize(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.RegionCode regionCode() {
    WirelessTypes.RegionCode ret = (WirelessTypes.RegionCode)msclPINVOKE.WirelessNode_regionCode(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public PingResponse ping() {
    PingResponse ret = new PingResponse(msclPINVOKE.WirelessNode_ping(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool sleep() {
    bool ret = msclPINVOKE.WirelessNode_sleep(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void cyclePower() {
    msclPINVOKE.WirelessNode_cyclePower(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void resetRadio() {
    msclPINVOKE.WirelessNode_resetRadio(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void changeFrequency(WirelessTypes.Frequency frequency) {
    msclPINVOKE.WirelessNode_changeFrequency(swigCPtr, (int)frequency);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public SetToIdleStatus setToIdle() {
    SetToIdleStatus ret = new SetToIdleStatus(msclPINVOKE.WirelessNode_setToIdle(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void erase() {
    msclPINVOKE.WirelessNode_erase(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void startNonSyncSampling() {
    msclPINVOKE.WirelessNode_startNonSyncSampling(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public void clearHistogram() {
    msclPINVOKE.WirelessNode_clearHistogram(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public AutoBalanceResult autoBalance(ChannelMask mask, float targetPercent) {
    AutoBalanceResult ret = new AutoBalanceResult(msclPINVOKE.WirelessNode_autoBalance(swigCPtr, ChannelMask.getCPtr(mask), targetPercent), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public AutoCalResult_shmLink autoCal_shmLink() {
    AutoCalResult_shmLink ret = new AutoCalResult_shmLink(msclPINVOKE.WirelessNode_autoCal_shmLink(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public AutoCalResult_shmLink201 autoCal_shmLink201() {
    AutoCalResult_shmLink201 ret = new AutoCalResult_shmLink201(msclPINVOKE.WirelessNode_autoCal_shmLink201(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public AutoShuntCalResult autoShuntCal(ChannelMask mask, ShuntCalCmdInfo commandInfo) {
    AutoShuntCalResult ret = new AutoShuntCalResult(msclPINVOKE.WirelessNode_autoShuntCal(swigCPtr, ChannelMask.getCPtr(mask), ShuntCalCmdInfo.getCPtr(commandInfo)), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort readEeprom(ushort location) {
    ushort ret = msclPINVOKE.WirelessNode_readEeprom(swigCPtr, location);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void writeEeprom(ushort location, ushort value) {
    msclPINVOKE.WirelessNode_writeEeprom(swigCPtr, location, value);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public ChannelData getDiagnosticInfo() {
    ChannelData ret = new ChannelData(msclPINVOKE.WirelessNode_getDiagnosticInfo(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool testCommunicationProtocol(WirelessTypes.CommProtocol protocol) {
    bool ret = msclPINVOKE.WirelessNode_testCommunicationProtocol(swigCPtr, (int)protocol);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool verifyConfig(WirelessNodeConfig config, ConfigIssues outIssues) {
    bool ret = msclPINVOKE.WirelessNode_verifyConfig(swigCPtr, WirelessNodeConfig.getCPtr(config), ConfigIssues.getCPtr(outIssues));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void applyConfig(WirelessNodeConfig config) {
    msclPINVOKE.WirelessNode_applyConfig(swigCPtr, WirelessNodeConfig.getCPtr(config));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
  }

  public ushort getNumDatalogSessions() {
    ushort ret = msclPINVOKE.WirelessNode_getNumDatalogSessions(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public float percentFull() {
    float ret = msclPINVOKE.WirelessNode_percentFull(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.DefaultMode getDefaultMode() {
    WirelessTypes.DefaultMode ret = (WirelessTypes.DefaultMode)msclPINVOKE.WirelessNode_getDefaultMode(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getInactivityTimeout() {
    ushort ret = msclPINVOKE.WirelessNode_getInactivityTimeout(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public byte getCheckRadioInterval() {
    byte ret = msclPINVOKE.WirelessNode_getCheckRadioInterval(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.TransmitPower getTransmitPower() {
    WirelessTypes.TransmitPower ret = (WirelessTypes.TransmitPower)msclPINVOKE.WirelessNode_getTransmitPower(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.SamplingMode getSamplingMode() {
    WirelessTypes.SamplingMode ret = (WirelessTypes.SamplingMode)msclPINVOKE.WirelessNode_getSamplingMode(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ChannelMask getActiveChannels() {
    ChannelMask ret = new ChannelMask(msclPINVOKE.WirelessNode_getActiveChannels(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.WirelessSampleRate getSampleRate() {
    WirelessTypes.WirelessSampleRate ret = (WirelessTypes.WirelessSampleRate)msclPINVOKE.WirelessNode_getSampleRate(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public uint getNumSweeps() {
    uint ret = msclPINVOKE.WirelessNode_getNumSweeps(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool getUnlimitedDuration() {
    bool ret = msclPINVOKE.WirelessNode_getUnlimitedDuration(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.DataFormat getDataFormat() {
    WirelessTypes.DataFormat ret = (WirelessTypes.DataFormat)msclPINVOKE.WirelessNode_getDataFormat(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.DataCollectionMethod getDataCollectionMethod() {
    WirelessTypes.DataCollectionMethod ret = (WirelessTypes.DataCollectionMethod)msclPINVOKE.WirelessNode_getDataCollectionMethod(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public TimeSpan getTimeBetweenBursts() {
    TimeSpan ret = new TimeSpan(msclPINVOKE.WirelessNode_getTimeBetweenBursts(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getLostBeaconTimeout() {
    ushort ret = msclPINVOKE.WirelessNode_getLostBeaconTimeout(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.InputRange getInputRange(ChannelMask mask) {
    WirelessTypes.InputRange ret = (WirelessTypes.InputRange)msclPINVOKE.WirelessNode_getInputRange(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getHardwareOffset(ChannelMask mask) {
    ushort ret = msclPINVOKE.WirelessNode_getHardwareOffset(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.Filter getAntiAliasingFilter(ChannelMask mask) {
    WirelessTypes.Filter ret = (WirelessTypes.Filter)msclPINVOKE.WirelessNode_getAntiAliasingFilter(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.Filter getLowPassFilter(ChannelMask mask) {
    WirelessTypes.Filter ret = (WirelessTypes.Filter)msclPINVOKE.WirelessNode_getLowPassFilter(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.HighPassFilter getHighPassFilter(ChannelMask mask) {
    WirelessTypes.HighPassFilter ret = (WirelessTypes.HighPassFilter)msclPINVOKE.WirelessNode_getHighPassFilter(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getDebounceFilter(ChannelMask mask) {
    ushort ret = msclPINVOKE.WirelessNode_getDebounceFilter(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool getPullUpResistor(ChannelMask mask) {
    bool ret = msclPINVOKE.WirelessNode_getPullUpResistor(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.SensorOutputMode getSensorOutputMode() {
    WirelessTypes.SensorOutputMode ret = (WirelessTypes.SensorOutputMode)msclPINVOKE.WirelessNode_getSensorOutputMode(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public float getGaugeFactor(ChannelMask mask) {
    float ret = msclPINVOKE.WirelessNode_getGaugeFactor(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.Voltage getExcitationVoltage() {
    WirelessTypes.Voltage ret = (WirelessTypes.Voltage)msclPINVOKE.WirelessNode_getExcitationVoltage(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.Voltage getAdcVoltageRef() {
    WirelessTypes.Voltage ret = (WirelessTypes.Voltage)msclPINVOKE.WirelessNode_getAdcVoltageRef(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.Voltage getGainAmplifierVoltageRef() {
    WirelessTypes.Voltage ret = (WirelessTypes.Voltage)msclPINVOKE.WirelessNode_getGainAmplifierVoltageRef(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getGaugeResistance() {
    ushort ret = msclPINVOKE.WirelessNode_getGaugeResistance(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getNumActiveGauges() {
    ushort ret = msclPINVOKE.WirelessNode_getNumActiveGauges(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public LinearEquation getLinearEquation(ChannelMask mask) {
    LinearEquation ret = new LinearEquation(msclPINVOKE.WirelessNode_getLinearEquation(swigCPtr, ChannelMask.getCPtr(mask)), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.CalCoef_Unit getUnit(ChannelMask mask) {
    WirelessTypes.CalCoef_Unit ret = (WirelessTypes.CalCoef_Unit)msclPINVOKE.WirelessNode_getUnit(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.CalCoef_EquationType getEquationType(ChannelMask mask) {
    WirelessTypes.CalCoef_EquationType ret = (WirelessTypes.CalCoef_EquationType)msclPINVOKE.WirelessNode_getEquationType(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.SettlingTime getFilterSettlingTime(ChannelMask mask) {
    WirelessTypes.SettlingTime ret = (WirelessTypes.SettlingTime)msclPINVOKE.WirelessNode_getFilterSettlingTime(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.ThermocoupleType getThermocoupleType(ChannelMask mask) {
    WirelessTypes.ThermocoupleType ret = (WirelessTypes.ThermocoupleType)msclPINVOKE.WirelessNode_getThermocoupleType(swigCPtr, ChannelMask.getCPtr(mask));
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public TempSensorOptions getTempSensorOptions(ChannelMask mask) {
    TempSensorOptions ret = new TempSensorOptions(msclPINVOKE.WirelessNode_getTempSensorOptions(swigCPtr, ChannelMask.getCPtr(mask)), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public FatigueOptions getFatigueOptions() {
    FatigueOptions ret = new FatigueOptions(msclPINVOKE.WirelessNode_getFatigueOptions(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public HistogramOptions getHistogramOptions() {
    HistogramOptions ret = new HistogramOptions(msclPINVOKE.WirelessNode_getHistogramOptions(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ActivitySense getActivitySense() {
    ActivitySense ret = new ActivitySense(msclPINVOKE.WirelessNode_getActivitySense(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public EventTriggerOptions getEventTriggerOptions() {
    EventTriggerOptions ret = new EventTriggerOptions(msclPINVOKE.WirelessNode_getEventTriggerOptions(swigCPtr), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ushort getDiagnosticInterval() {
    ushort ret = msclPINVOKE.WirelessNode_getDiagnosticInterval(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.StorageLimitMode getStorageLimitMode() {
    WirelessTypes.StorageLimitMode ret = (WirelessTypes.StorageLimitMode)msclPINVOKE.WirelessNode_getStorageLimitMode(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public uint getSensorDelay() {
    uint ret = msclPINVOKE.WirelessNode_getSensorDelay(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.DataMode getDataMode() {
    WirelessTypes.DataMode ret = (WirelessTypes.DataMode)msclPINVOKE.WirelessNode_getDataMode(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.WirelessSampleRate getDerivedDataRate() {
    WirelessTypes.WirelessSampleRate ret = (WirelessTypes.WirelessSampleRate)msclPINVOKE.WirelessNode_getDerivedDataRate(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public ChannelMask getDerivedChannelMask(WirelessTypes.DerivedCategory category) {
    ChannelMask ret = new ChannelMask(msclPINVOKE.WirelessNode_getDerivedChannelMask(swigCPtr, (int)category), true);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public WirelessTypes.DerivedVelocityUnit getDerivedVelocityUnit() {
    WirelessTypes.DerivedVelocityUnit ret = (WirelessTypes.DerivedVelocityUnit)msclPINVOKE.WirelessNode_getDerivedVelocityUnit(swigCPtr);
    if (msclPINVOKE.SWIGPendingException.Pending) throw msclPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

}

}