public DvlDataSet( SubsystemConfiguration SubsystemConfig, int SampleNumber, float Heading, float Pitch, float Roll, int Year, int Month, int Day, int Hour, int Minute, int Second, int HSec, float Salinity, float Temperature, float DepthOfTransducer, float SpeedOfSound, int BIT, int RefLayerMin, int RefLayerMax, float WmXVelocity, float WmYVelocity, float WmZVelocity, float WmErrorVelocity, bool WmInstrumentIsGoodVelocity, float WmTransverseVelocity, float WmLongitudinalVelocity, float WmNormalVelocity, bool WmShipIsGoodVelocity, float WmEastVelocity, float WmNorthVelocity, float WmUpwardVelocity, bool WmEarthIsGoodVelocity, float WmEastDistance, float WmNorthDistance, float WmUpwardDistance, float WmEarthRangeToWaterMassCenter, float WmEarthTimeLastGoodVel, float BtXVelocity, float BtYVelocity, float BtZVelocity, float BtErrorVelocity, bool BtInstrumentIsGoodVelocity, float BtTransverseVelocity, float BtLongitudinalVelocity, float BtNormalVelocity, float BtShipErrorVelocity, bool BtShipIsGoodVelocity, float BtEastVelocity, float BtNorthVelocity, float BtUpwardVelocity, bool BtEarthIsGoodVelocity, float BtEastDistance, float BtNorthDistance, float BtUpwardDistance, float BtEarthRangeToWaterMassCenter, float BtEarthTimeLastGoodVel, float Pressure, float RangeBeam0, float RangeBeam1, float RangeBeam2, float RangeBeam3, float AverageRange, float DmgEast, float DmgNorth, float DmgUpward, float DmgError, float DmgRefEast, float DmgRefNorth, float DmgRefUpward, float DmgRefError, LeakDetectionOptions LeakDetection) : base(DataSet.Ensemble.DATATYPE_FLOAT, // Type of data stored (Float or Int) NUM_ELEMENTS, // Number of bins 1, // Number of beams DataSet.Ensemble.DEFAULT_IMAG, // Default Image DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length DataSet.Ensemble.DvlID) { this.SubsystemConfig = SubsystemConfig; this.SampleNumber = SampleNumber; this.Pitch = Pitch; this.Roll = Roll; this.Heading = Heading; this.DateAndTime = DateAndTime; this.Salinity = Salinity; this.WaterTemp = Temperature; this.TransducerDepth = DepthOfTransducer; this.SpeedOfSound = SpeedOfSound; this.BIT = BIT; // Set time this.Year = Year; this.Month = Month; this.Day = Day; this.Hour = Hour; this.Minute = Minute; this.Second = Second; this.HSec = HSec; ValidateDateTime(Year, Month, Day, Hour, Minute, Second, HSec / 10); this.RefLayerMin = RefLayerMin; this.RefLayerMax = RefLayerMax; this.WmXVelocity = WmXVelocity; this.WmYVelocity = WmYVelocity; this.WmZVelocity = WmZVelocity; this.WmErrorVelocity = WmErrorVelocity; this.WmInstrumentIsGoodVelocity = WmInstrumentIsGoodVelocity; this.WmTransverseVelocity = WmTransverseVelocity; this.WmLongitudinalVelocity = WmLongitudinalVelocity; this.WmNormalVelocity = WmNormalVelocity; this.WmShipIsGoodVelocity = WmShipIsGoodVelocity; this.WmEastVelocity = WmEastVelocity; this.WmNorthVelocity = WmNorthVelocity; this.WmUpwardVelocity = WmUpwardVelocity; this.WmEarthIsGoodVelocity = WmEarthIsGoodVelocity; this.WmEastDistance = WmEastDistance; this.WmNorthDistance = WmNorthDistance; this.WmUpwardDistance = WmUpwardDistance; this.WmEarthRangeToWaterMassCenter = WmEarthRangeToWaterMassCenter; this.WmEarthTimeLastGoodVel = WmEarthTimeLastGoodVel; this.BtXVelocity = BtXVelocity; this.BtYVelocity = BtYVelocity; this.BtZVelocity = BtZVelocity; this.BtErrorVelocity = BtErrorVelocity; this.BtInstrumentIsGoodVelocity = BtInstrumentIsGoodVelocity; this.BtTransverseVelocity = BtTransverseVelocity; this.BtLongitudinalVelocity = BtLongitudinalVelocity; this.BtNormalVelocity = BtNormalVelocity; this.BtShipErrorVelocity = BtShipErrorVelocity; this.BtShipIsGoodVelocity = BtShipIsGoodVelocity; this.BtEastVelocity = BtEastVelocity; this.BtNorthVelocity = BtNorthVelocity; this.BtUpwardVelocity = BtUpwardVelocity; this.BtEarthIsGoodVelocity = BtEarthIsGoodVelocity; this.BtEastDistance = BtEastDistance; this.BtNorthDistance = BtNorthDistance; this.BtUpwardDistance = BtUpwardDistance; this.BtRangeToBottom = BtEarthRangeToWaterMassCenter; this.BtEarthTimeLastGoodVel = BtEarthTimeLastGoodVel; this.Pressure = Pressure; this.RangeBeam0 = RangeBeam0; this.RangeBeam1 = RangeBeam1; this.RangeBeam2 = RangeBeam2; this.RangeBeam3 = RangeBeam3; this.AverageRange = AverageRange; this.DmgEast = DmgEast; this.DmgNorth = DmgNorth; this.DmgUpward = DmgUpward; this.DmgError = DmgError; this.DmgRefEast = DmgRefEast; this.DmgRefNorth = DmgRefNorth; this.DmgRefUpward = DmgRefUpward; this.DmgRefError = DmgRefError; this.LeakDetection = LeakDetection; }
/// <summary> /// Initialize the values. /// </summary> private void Init() { // Create Subsystem Configuration based off Firmware and Serialnumber SubsystemConfig = new SubsystemConfiguration(new Firmware().GetSubsystem(SerialNumber.DVL), 0, 0); SampleNumber = 0; Pitch = 0.0f; Roll = 0.0f; Heading = 0.0f; DateAndTime = DateTime.Now; Year = DateAndTime.Year; Month = DateAndTime.Month; Day = DateAndTime.Day; Hour = DateAndTime.Hour; Minute = DateAndTime.Minute; Second = DateAndTime.Second; HSec = DateAndTime.Millisecond * 10; Salinity = 0.0f; WaterTemp = 0.0f; TransducerDepth = 0.0f; SpeedOfSound = 0.0f; BIT = 0; RefLayerMin = 0; RefLayerMax = 0; WmXVelocity = 0.0f; WmYVelocity = 0.0f; WmZVelocity = 0.0f; WmErrorVelocity = 0.0f; WmInstrumentIsGoodVelocity = false; WmTransverseVelocity = 0.0f; WmLongitudinalVelocity = 0.0f; WmNormalVelocity = 0.0f; WmShipIsGoodVelocity = false; WmEastVelocity = 0.0f; WmNorthVelocity = 0.0f; WmUpwardVelocity = 0.0f; WmEarthIsGoodVelocity = false; WmEastDistance = 0.0f; WmNorthDistance = 0.0f; WmUpwardDistance = 0.0f; WmEarthRangeToWaterMassCenter = 0.0f; WmEarthTimeLastGoodVel = 0.0f; BtXVelocity = 0.0f; BtYVelocity = 0.0f; BtZVelocity = 0.0f; BtErrorVelocity = 0.0f; BtInstrumentIsGoodVelocity = false; BtTransverseVelocity = 0.0f; BtLongitudinalVelocity = 0.0f; BtNormalVelocity = 0.0f; BtShipErrorVelocity = 0.0f; BtShipIsGoodVelocity = false; BtEastVelocity = 0.0f; BtNorthVelocity = 0.0f; BtUpwardVelocity = 0.0f; BtEarthIsGoodVelocity = false; BtEastDistance = 0.0f; BtNorthDistance = 0.0f; BtUpwardDistance = 0.0f; BtRangeToBottom = 0.0f; BtEarthTimeLastGoodVel = 0.0f; Pressure = 0.0f; RangeBeam0 = 0.0f; RangeBeam1 = 0.0f; RangeBeam2 = 0.0f; RangeBeam3 = 0.0f; AverageRange = 0.0f; DmgEast = 0.0f; DmgNorth = 0.0f; DmgUpward = 0.0f; DmgError = 0.0f; DmgRefEast = 0.0f; DmgRefNorth = 0.0f; DmgRefUpward = 0.0f; DmgRefError = 0.0f; LeakDetection = LeakDetectionOptions.NotInstalled; }
/// <summary> /// Use this constructor if all the settings are going to be /// set by the user. /// /// If this constructor is used, then none of the /// frequency dependent commands will be set to anything /// specific. The subsystem must be set and /// SetFrequencyDefaults() must be called for the /// frequency dependent commands to be set to default values. /// </summary> public AdcpSubsystemCommands() { // Set empty subsystem. SubsystemConfig = new SubsystemConfiguration(); // Set Default values SetDefaultOptions(); }
/// <summary> /// Read the JSON object and convert to the object. This will allow the serializer to /// automatically convert the object. No special instructions need to be done and all /// the properties found in the JSON string need to be used. /// /// DataSet.DvlDataSet decodedEns = Newtonsoft.Json.JsonConvert.DeserializeObject{DataSet.DvlDataSet}(encodedEns) /// /// </summary> /// <param name="reader">NOT USED. JSON reader.</param> /// <param name="objectType">NOT USED> Type of object.</param> /// <param name="existingValue">NOT USED.</param> /// <param name="serializer">Serialize the object.</param> /// <returns>Serialized object.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType != JsonToken.Null) { // Load the object JObject jsonObject = JObject.Load(reader); // SubsystemConfig ushort index = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEM_INDEX]; byte ssCode = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEM_CODE].ToObject<byte>(); byte cepoIndex = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_CEPOINDEX].ToObject<byte>(); byte configNum = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SSCONFIG_INDEX].ToObject<byte>(); SubsystemConfiguration SubsystemConfig = new SubsystemConfiguration(new Subsystem(ssCode, index), cepoIndex, configNum); #region System // Sample Number int SampleNumber = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_SAMPLENUMBER]; // Heading float Heading = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_HEADING]; // Pitch float Pitch = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_PITCH]; // Roll float Roll = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_ROLL]; // Year int Year = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_YEAR]; // Month int Month = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_MONTH]; // Day int Day = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DAY]; // Hour int Hour = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_HOUR]; // Minute int Minute = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_MINUTE]; // Second int Second = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_SECOND]; // HSec int HSec = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_HSEC]; // Salinity float Salinity = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_SALINITY]; // Salinity float Temperature = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_TEMPERATURE]; // TransducerDepth float TransducerDepth = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_TRANSDUCERDEPTH]; // SpeedOfSound float SpeedOfSound = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_SPEEDOFSOUND]; // BIT int BIT = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BIT]; // Ref Layer Min int RefLayerMin = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_REF_LAYER_MIN]; // Ref Layer Max int RefLayerMax = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_REF_LAYER_MAX]; #endregion #region Water Mass Instrument Velocity // WM X Vel float WmXVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_X_VEL]; // WM Y Vel float WmYVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_Y_VEL]; // WM Z Vel float WmZVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_Z_VEL]; // WM Error Vel float WmErrorVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_ERROR_VEL]; // WM Instrumment Is Good Vel bool WmInstrumentIsGoodVel = (bool)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_INSTRUMENT_IS_GOOD_VEL]; #endregion #region Water Mass Ship Velocity // WM Transverse Vel float WmTransverseVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_TRANSVERSE_VEL]; // WM Longitudinal Vel float WmLongitudinalVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_LONGITUDINAL_VEL]; // WM Normal Vel float WmNormalVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_NORMAL_VEL]; // WM Ship Is Good Vel bool WmShipIsGoodVel = (bool)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_SHIP_IS_GOOD_VEL]; #endregion #region Water Mass Earth Velocity // WM East Vel float WmEastVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_EAST_VEL]; // WM North Vel float WmNorthVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_NORTH_VEL]; // WM Upward Vel float WmUpwardVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_UPWARD_VEL]; // WM Earth Is Good Vel bool WmEarthIsGoodVel = (bool)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_EARTH_IS_GOOD_VEL]; #endregion #region Water Mass Earth Distance // WM East Vel float WmEastDist = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_EAST_DMG]; // WM North Vel float WmNorthDist = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_NORTH_DMG]; // WM Upward Vel float WmUpwardDist = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_UPWARD_DMG]; // WM Earth Range to WM center float WmEarthRangeToWaterMassCenter = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_EARTH_RANGE_TO_WM_CENTER]; // WM Earth Range to WM center float WmEarthTimeLastGoodVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_WM_EARTH_TIME_LAST_GOOD_VEL]; #endregion #region Bottom Track Instrument Velocity // Bottom Track X Vel float BtXVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_X_VEL]; // Bottom Track Y Vel float BtYVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_Y_VEL]; // Bottom Track Z Vel float BtZVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_Z_VEL]; // Bottom Track Error Vel float BtErrorVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_ERROR_VEL]; // Bottom Track Instrumment Is Good Vel bool BtInstrumentIsGoodVel = (bool)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_INSTRUMENT_IS_GOOD_VEL]; #endregion #region Bottom Track Ship Velocity float BtTransverseVel = 0.0f; float BtLongitudinalVel = 0.0f; float BtNormalVel = 0.0f; float BtShipErrVel = 0.0f; bool BtShipIsGoodVel = false; if (jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_TRANSVERSE_VEL] != null) { // Bottom Track Transverse Vel BtTransverseVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_TRANSVERSE_VEL]; } if (jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_LONGITUDINAL_VEL] != null) { // Bottom Track Longitudinal Vel BtLongitudinalVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_LONGITUDINAL_VEL]; } if (jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_NORMAL_VEL] != null) { // Bottom Track Normal Vel BtNormalVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_NORMAL_VEL]; } if (jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_SHIP_ERR_VEL] != null) { // Bottom Track Ship Error Vel BtShipErrVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_SHIP_ERR_VEL]; } if (jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_SHIP_IS_GOOD_VEL] != null) { // Bottom Track Ship Is Good Vel BtShipIsGoodVel = (bool)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_SHIP_IS_GOOD_VEL]; } #endregion #region Bottom Track Earth Velocity // Bottom Track East Vel float BtEastVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_EAST_VEL]; // Bottom Track North Vel float BtNorthVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_NORTH_VEL]; // Bottom Track Upward Vel float BtUpwardVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_UPWARD_VEL]; // Bottom Track Earth Is Good Vel bool BtEarthIsGoodVel = (bool)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_EARTH_IS_GOOD_VEL]; #endregion #region Bottom Track Earth Distance // Bottom Track East Distance float BtEastDist = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_EAST_DMG]; // Bottom Track North Distance float BtNorthDist = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_NORTH_DMG]; // Bottom Track Upward Distance float BtUpwardDist = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_UPWARD_DMG]; // Bottom Track Earth Range to WM center float BtEarthRangeToWaterMassCenter = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_EARTH_RANGE_TO_WM_CENTER]; // Bottom Track Earth Range to WM center float BtEarthTimeLastGoodVel = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_EARTH_TIME_LAST_GOOD_VEL]; #endregion #region Pressure and Range // Pressure float Pressure = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_BT_EAST_DMG]; // Range Beam 0 float RangeB0 = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_RANGE_B0]; // Range Beam 1 float RangeB1 = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_RANGE_B1]; // Range Beam 2 float RangeB2 = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_RANGE_B2]; // Range Beam 3 float RangeB3 = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_RANGE_B3]; // Average Range float AvgRange = (float)jsonObject[DataSet.BaseDataSet.JSON_STR_DVL_AVG_RANGE]; #endregion #region Distance Made Good // Distance Made Good East JToken DmgEastTkn = null; float DmgEast = 0.0f; if(jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_EAST, out DmgEastTkn)) { DmgEast = (float)DmgEastTkn; } // Distance Made Good North JToken DmgNorthTkn = null; float DmgNorth = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_NORTH, out DmgNorthTkn)) { DmgNorth = (float)DmgNorthTkn; } // Distance Made Good Upward JToken DmgUpwardTkn = null; float DmgUpward = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_UPWARD, out DmgUpwardTkn)) { DmgUpward = (float)DmgUpwardTkn; } // Distance Made Good Error JToken DmgErrorTkn = null; float DmgError = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_ERROR, out DmgErrorTkn)) { DmgError = (float)DmgErrorTkn; } #endregion #region Distance Made Good Reference Layer // Distance Made Good Reference Layer East JToken DmgRefEastTkn = null; float DmgRefEast = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_REF_EAST, out DmgRefEastTkn)) { DmgRefEast = (float)DmgRefEastTkn; } // Distance Made Good Reference Layer North JToken DmgRefNorthTkn = null; float DmgRefNorth = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_REF_NORTH, out DmgRefNorthTkn)) { DmgRefNorth = (float)DmgRefNorthTkn; } // Distance Made Good Reference Layer Upward JToken DmgRefUpwardTkn = null; float DmgRefUpward = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_REF_UPWARD, out DmgRefUpwardTkn)) { DmgRefUpward = (float)DmgRefUpwardTkn; } // Distance Made Good Reference Layer Error JToken DmgRefErrorTkn = null; float DmgRefError = 0.0f; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_DMG_REF_ERROR, out DmgRefErrorTkn)) { DmgRefError = (float)DmgRefErrorTkn; } #endregion #region LeakDetection // Leak Detection JToken LeakDetectionTkn = null; RTI.DataSet.DvlDataSet.LeakDetectionOptions LeakDetection = RTI.DataSet.DvlDataSet.LeakDetectionOptions.NotInstalled; if (jsonObject.TryGetValue(DataSet.BaseDataSet.JSON_STR_DVL_LEAKDETECTION, out LeakDetectionTkn)) { switch((string)LeakDetectionTkn) { case TS.LEAKDETECT_OK: LeakDetection = DvlDataSet.LeakDetectionOptions.OK; break; case TS.LEAKDETECT_WATER: LeakDetection = DvlDataSet.LeakDetectionOptions.WaterDetected; break; case TS.LEAKDETECT_NOT_INSTALLED: default: LeakDetection = DvlDataSet.LeakDetectionOptions.NotInstalled; break; } } #endregion // Create the object var data = new DvlDataSet(SubsystemConfig, SampleNumber, Heading, Pitch, Roll, Year, Month, Day, Hour, Minute, Second, HSec, Salinity, Temperature, TransducerDepth, SpeedOfSound, BIT, RefLayerMin, RefLayerMax, WmXVel, WmYVel, WmZVel, WmErrorVel, WmInstrumentIsGoodVel, WmTransverseVel, WmLongitudinalVel, WmNormalVel, WmShipIsGoodVel, WmEastVel, WmNorthVel, WmUpwardVel, WmEarthIsGoodVel, WmEastDist, WmNorthDist, WmUpwardDist, WmEarthRangeToWaterMassCenter, WmEarthTimeLastGoodVel, BtXVel, BtYVel, BtZVel, BtErrorVel, BtInstrumentIsGoodVel, BtTransverseVel, BtLongitudinalVel, BtNormalVel, BtShipErrVel, BtShipIsGoodVel, BtEastVel, BtNorthVel, BtUpwardVel, BtEarthIsGoodVel, BtEastDist, BtNorthDist, BtUpwardDist, BtEarthRangeToWaterMassCenter, BtEarthTimeLastGoodVel, Pressure, RangeB0, RangeB1, RangeB2, RangeB3, AvgRange, DmgEast, DmgNorth, DmgUpward, DmgError, DmgRefEast, DmgRefNorth, DmgRefUpward, DmgRefError, LeakDetection); return data; } return null; }
/// <summary> /// Get all the information about the Ensemble. /// </summary> /// <param name="data">Byte array containing the Ensemble data type.</param> private void Decode(byte[] data) { EnsembleNumber = MathHelper.ByteArrayToInt32(data, GenerateIndex(0)); NumBins = MathHelper.ByteArrayToInt32(data, GenerateIndex(1)); NumBeams = MathHelper.ByteArrayToInt32(data, GenerateIndex(2)); DesiredPingCount = MathHelper.ByteArrayToInt32(data, GenerateIndex(3)); ActualPingCount = MathHelper.ByteArrayToInt32(data, GenerateIndex(4)); Status = new Status(MathHelper.ByteArrayToInt32(data, GenerateIndex(5))); Year = MathHelper.ByteArrayToInt32(data, GenerateIndex(6)); Month = MathHelper.ByteArrayToInt32(data, GenerateIndex(7)); Day = MathHelper.ByteArrayToInt32(data, GenerateIndex(8)); Hour = MathHelper.ByteArrayToInt32(data, GenerateIndex(9)); Minute = MathHelper.ByteArrayToInt32(data, GenerateIndex(10)); Second = MathHelper.ByteArrayToInt32(data, GenerateIndex(11)); HSec = MathHelper.ByteArrayToInt32(data, GenerateIndex(12)); // Revision D additions if (NumElements >= NUM_DATA_ELEMENTS_REV_D && data.Length >= NUM_DATA_ELEMENTS_REV_D * Ensemble.BYTES_IN_INT32) { // Get the System Serial Num // Start at index 13 byte[] serial = new byte[SERIAL_NUM_INT * Ensemble.BYTES_IN_INT32]; System.Buffer.BlockCopy(data, GenerateIndex(13), serial, 0, SERIAL_NUM_INT * Ensemble.BYTES_IN_INT32); SysSerialNumber = new SerialNumber(serial); // Get the firmware number // Start at index 21 byte[] firmware = new byte[FIRMWARE_NUM_INT * Ensemble.BYTES_IN_INT32]; System.Buffer.BlockCopy(data, GenerateIndex(21), firmware, 0, FIRMWARE_NUM_INT * Ensemble.BYTES_IN_INT32); SysFirmware = new Firmware(firmware); // FOR BACKWARDS COMPATITBILITY // Old subsystems in the ensemble were set by the Subsystem Index in Firmware. // This means the that a subsystem code of 0 could be passed because // the index was 0 to designate the first subsystem index. Firmware revision 0.2.13 changed // SubsystemIndex to SubsystemCode. This will check which Firmware version this ensemble is // and convert to the new type using SubsystemCode. // // Get the correct subsystem by getting the index found in the firmware and getting // subsystem code from the serial number. //if (SysFirmware.FirmwareMajor <= 0 && SysFirmware.FirmwareMinor <= 2 && SysFirmware.FirmwareRevision <= 13 && GetSubSystem().IsEmpty()) //{ // // Set the correct subsystem based off the serial number // // Get the index for the subsystem // byte index = SysFirmware.SubsystemCode; // // Ensure the index is not out of range of the subsystem string // if (SysSerialNumber.SubSystems.Length > index) // { // // Get the Subsystem code from the serialnumber based off the index found // string code = SysSerialNumber.SubSystems.Substring(index, 1); // // Create a subsystem with the code and index // Subsystem ss = new Subsystem(Convert.ToByte(code), index); // // Set the new subsystem code to the firmware // //SysFirmware.SubsystemCode = Convert.ToByte(code); // // Remove the old subsystem and add the new one to the dictionary // SysSerialNumber.SubSystemsDict.Remove(Convert.ToByte(index)); // SysSerialNumber.SubSystemsDict.Add(Convert.ToByte(index), ss); // } //} } else { SysSerialNumber = new SerialNumber(); SysFirmware = new Firmware(); } // Revision H additions if (NumElements >= NUM_DATA_ELEMENTS_REV_H && data.Length >= NUM_DATA_ELEMENTS_REV_H * Ensemble.BYTES_IN_INT32) { // Get the Subsystem Configuration // Start at index 22 byte[] subConfig = new byte[SUBSYSTEM_CONFIG_NUM_INT * Ensemble.BYTES_IN_INT32]; System.Buffer.BlockCopy(data, GenerateIndex(22), subConfig, 0, SUBSYSTEM_CONFIG_NUM_INT * Ensemble.BYTES_IN_INT32); SubsystemConfig = new SubsystemConfiguration(SysFirmware.GetSubsystem(SysSerialNumber), subConfig); } else { // Create a default SubsystemConfig with a configuration of 0 SubsystemConfig = new SubsystemConfiguration(SysFirmware.GetSubsystem(SysSerialNumber), 0, 0); } // Set the time and date ValidateDateTime(Year, Month, Day, Hour, Minute, Second, HSec / 10); // Create UniqueId UniqueId = new UniqueID(EnsembleNumber, EnsDateTime); }
/// <summary> /// Set the default values for the given subsystem. /// A default value of 0 is used for CEPO index. If there is only /// 1 subsystem, then 0 should always work. /// </summary> /// <param name="ssConfig">Subsystem Configuration associated with these options.</param> public AdcpSubsystemCommands(SubsystemConfiguration ssConfig) { // Set the subsystem SubsystemConfig = ssConfig; // Set default values SetDefaults(); }
public EnsembleDataSet(int ValueType, int NumElements, int ElementsMultiplier, int Imag, int NameLength, string Name, int EnsembleNumber, int NumBins, int NumBeams, int DesiredPingCount, int ActualPingCount, SerialNumber SysSerialNumber, Firmware SysFirmware, SubsystemConfiguration SubsystemConfig, Status Status, int Year, int Month, int Day, int Hour, int Minute, int Second, int HSec) : base(ValueType, NumElements, ElementsMultiplier, Imag, NameLength, Name) { //this.UniqueId = UniqueId; this.EnsembleNumber = EnsembleNumber; this.NumBins = NumBins; this.NumBeams = NumBeams; this.DesiredPingCount = DesiredPingCount; this.ActualPingCount = ActualPingCount; this.SysSerialNumber = SysSerialNumber; this.SysFirmware = SysFirmware; this.SubsystemConfig = SubsystemConfig; this.Status = Status; this.Year = Year; this.Month = Month; this.Day = Day; this.Hour = Hour; this.Minute = Minute; this.Second = Second; this.HSec = HSec; //this.EnsDateTime = EnsDateTime; // Set the time and date ValidateDateTime(Year, Month, Day, Hour, Minute, Second, HSec / 10); // Create UniqueId UniqueId = new UniqueID(EnsembleNumber, EnsDateTime); }
/// <summary> /// Create an Ensemble data set. Include all the information /// about the current ensemble from the sentence. This will include /// the ensemble number and status. /// </summary> /// <param name="sentence">Sentence containing data.</param> public EnsembleDataSet(Prti03Sentence sentence) : base(DataSet.Ensemble.DATATYPE_INT, NUM_DATA_ELEMENTS, DataSet.Ensemble.DEFAULT_NUM_BEAMS_NONBEAM, DataSet.Ensemble.DEFAULT_IMAG, DataSet.Ensemble.DEFAULT_NAME_LENGTH, DataSet.Ensemble.EnsembleDataID) { // Set the ensemble number EnsembleNumber = sentence.SampleNumber; // Set time to now SetTime(); // Create UniqueId UniqueId = new UniqueID(EnsembleNumber, EnsDateTime); // Use default value for beams NumBeams = DataSet.Ensemble.DEFAULT_NUM_BEAMS_BEAM; // Use the special serial number for a DVL SysSerialNumber = SerialNumber.DVL; // Create blank firmware SysFirmware = new Firmware(); // Create Subsystem Configuration based off Firmware and Serialnumber if (sentence.SubsystemConfig != null) { SubsystemConfig = sentence.SubsystemConfig; SysFirmware.SubsystemCode = sentence.SubsystemConfig.SubSystem.Code; } else { // Create Subsystem Configuration based off Firmware and Serialnumber SubsystemConfig = new SubsystemConfiguration(SysFirmware.GetSubsystem(SysSerialNumber), 0, 0); } // Get the status from the sentence Status = sentence.SystemStatus; // No bin data NumBins = 0; }
// Dataset ID /// <summary> /// Create a Ensemble data set. This will create a blank dataset. The user must fill in the data for all /// the important values. /// </summary> public EnsembleDataSet() : base(DataSet.Ensemble.DATATYPE_INT, // Type of data stored (Float or Int) NUM_DATA_ELEMENTS, // Number of elements DataSet.Ensemble.DEFAULT_NUM_BEAMS_NONBEAM, // Element Multiplier DataSet.Ensemble.DEFAULT_IMAG, // Default Image DataSet.Ensemble.DEFAULT_NAME_LENGTH, // Default Image length DataSet.Ensemble.EnsembleDataID) { // Set the ensemble number to the default ensemble number EnsembleNumber = DEFAULT_ENS_NUM; // Set time to the current time SetTime(); // Create UniqueId UniqueId = new UniqueID(EnsembleNumber, EnsDateTime); // Set the number of beams //NumBeams = numBeams; // Set the number of bins //NumBins = numElements; // Use a blank serial number SysSerialNumber = new SerialNumber(); // Create blank firmware SysFirmware = new Firmware(); // Create Blank Subsystem configuration SubsystemConfig = new SubsystemConfiguration(); // Create a blank status Status = new Status(0); }
/// <summary> /// Create a Ensemble data set. This will create a blank dataset. The user must fill in the data for all /// the important values. /// </summary> /// <param name="valueType">Whether it contains 32 bit Integers or Single precision floating point </param> /// <param name="numElments">Number of Elements.</param> /// <param name="elementMultiplier">Element Multipliers.</param> /// <param name="imag"></param> /// <param name="nameLength">Length of name</param> /// <param name="name">Name of data type</param> /// <param name="numBins">Number of Bin</param> /// <param name="numBeams">Number of beams</param> public EnsembleDataSet(int valueType, int numElments, int elementMultiplier, int imag, int nameLength, string name, int numBins, int numBeams) : base(valueType, numElments, elementMultiplier, imag, nameLength, name) { // Set the ensemble number to the default ensemble number EnsembleNumber = DEFAULT_ENS_NUM; // Set time to the current time SetTime(); // Create UniqueId UniqueId = new UniqueID(EnsembleNumber, EnsDateTime); // Set the number of beams NumBeams = numBeams; // Set the number of bins NumBins = numBins; // Use a blank serial number SysSerialNumber = new SerialNumber(); // Create blank firmware SysFirmware = new Firmware(); // Create Blank Subsystem configuration SubsystemConfig = new SubsystemConfiguration(); // Create a blank status Status = new Status(0); }
/// <summary> /// Read the JSON object and convert to the object. This will allow the serializer to /// automatically convert the object. No special instructions need to be done and all /// the properties found in the JSON string need to be used. /// /// DataSet.EnsembleDataSet decodedEns = Newtonsoft.Json.JsonConvert.DeserializeObject{DataSet.EnsembleDataSet}(encodedEns) /// /// </summary> /// <param name="reader">NOT USED. JSON reader.</param> /// <param name="objectType">NOT USED> Type of object.</param> /// <param name="existingValue">NOT USED.</param> /// <param name="serializer">Serialize the object.</param> /// <returns>Serialized object.</returns> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType != JsonToken.Null) { // Load the object JObject jsonObject = JObject.Load(reader); // Decode the data int NumElements = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_NUMELEMENTS]; int ElementsMultiplier = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_ELEMENTSMULTIPLIER]; // EnsembleNumber int EnsembleNumber = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_ENSEMBLENUMBER]; // NumBins int NumBins = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_NUMBINS]; // NumBeams int NumBeams = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_NUMBEAMS]; // DesiredPingCount int DesiredPingCount = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DESIREDPINGCOUNT]; // ActualPingCount int ActualPingCount = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_ACTUALPINGCOUNT]; // SysSerialNumber SerialNumber SysSerialNumber = new SerialNumber((string)jsonObject[DataSet.BaseDataSet.STR_JSON_SERIALNUMBER_SERIALNUMBERSTRING]); // SysFirmware ushort major = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_FIRMWAREMAJOR]; ushort minor = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_FIRMWAREMINOR]; ushort rev = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_FIRMWAREREVISION]; byte code = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEMCODE].ToObject<byte>(); Firmware SysFirmware = new Firmware(code, major, minor, rev); // SubsystemConfig ushort index = (ushort)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEM_INDEX]; byte ssCode = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SUBSYSTEM_CODE].ToObject<byte>(); byte cepoIndex = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_CEPOINDEX].ToObject<byte>(); byte configNum = (byte)jsonObject[DataSet.BaseDataSet.JSON_STR_SSCONFIG_INDEX].ToObject<byte>(); SubsystemConfiguration SubsystemConfig = new SubsystemConfiguration(new Subsystem(ssCode, index), cepoIndex, configNum); // Status Status status = new Status((int)jsonObject[DataSet.BaseDataSet.JSON_STR_STATUS]); // Year int Year = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_YEAR]; // Month int Month = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_MONTH]; // Day int Day = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_DAY]; // Hour int Hour = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_HOUR]; // Minute int Minute = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_MINUTE]; // Second int Second = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_SECOND]; // HSec int HSec = (int)jsonObject[DataSet.BaseDataSet.JSON_STR_HSEC]; // Create the object // Need to call the constructor to create // the correct EnsDateTime and UniqueID var data = new EnsembleDataSet(DataSet.Ensemble.DATATYPE_INT, NumElements, ElementsMultiplier, DataSet.Ensemble.DEFAULT_IMAG, DataSet.Ensemble.DEFAULT_NAME_LENGTH, DataSet.Ensemble.EnsembleDataID, EnsembleNumber, NumBins, NumBeams, DesiredPingCount, ActualPingCount, SysSerialNumber, SysFirmware, SubsystemConfig, status, Year, Month, Day, Hour, Minute, Second, HSec); return data; } return null; }