public void TestMinMaxSensor() { var sensor = new MinMaxSensor(); var parameterCount = 3; var typeCount = 1; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("MinMax", config.Name); Assert.AreEqual(typeCount, config.Types.Length); Assert.AreEqual("Simulator.Bridge.Data.ImageData", config.Types[0]); Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("length", config.Parameters[0].Name); Assert.AreEqual(500, config.Parameters[0].DefaultValue); Assert.AreEqual(1f, config.Parameters[0].Min); Assert.AreEqual(1920f, config.Parameters[0].Max); Assert.AreEqual("distance", config.Parameters[1].Name); Assert.AreEqual(5f, config.Parameters[1].DefaultValue); Assert.AreEqual(0f, config.Parameters[1].Min); Assert.AreEqual(9f, config.Parameters[1].Max); Assert.AreEqual("sad", config.Parameters[2].Name); Assert.AreEqual(false, config.Parameters[2].DefaultValue); Assert.AreEqual(null, config.Parameters[2].Min); Assert.AreEqual(null, config.Parameters[2].Max); }
/// <summary> /// Loads the sensor list from an xml string /// </summary> /// <param name="xml">An input string for an xml sensor list</param> public void FromXML(string xml) { XmlDocument dom = new XmlDocument(); dom.LoadXml(xml); XmlNode xNode = dom.DocumentElement; if ((xNode.Name == SENSORS_ELEMENT) && (xNode.HasChildNodes)) { foreach (XmlNode jNode in xNode.ChildNodes) { if (jNode.Name == Sensor.SENSOR_ELEMENT) { SensorClasses sensorClass = SensorClasses.Unknown; SensorTypes sensorType = SensorTypes.UNKNOWN; foreach (XmlAttribute jAttribute in jNode.Attributes) { if (jAttribute.Name == CLASS_ATTRIBUTE) { sensorClass = (SensorClasses)Enum.Parse(typeof(SensorClasses), jAttribute.Value, true); } else if (jAttribute.Name == TYPE_ATTRIBUTE) { sensorType = (SensorTypes)Enum.Parse(typeof(SensorTypes), jAttribute.Value, true); } } if (sensorType == SensorTypes.ACCEL) { Sensor sensor = null; #if (PocketPC) if (sensorClass == SensorClasses.HTCDiamondTouch) { sensor = new HTCDiamondTouch(); } else #endif if (sensorClass == SensorClasses.MITes) { sensor = new MITe(); } else if (sensorClass == SensorClasses.Sparkfun) { sensor = new Sparkfun(); } else if (sensorClass == SensorClasses.Wockets) { sensor = new Wocket(); } else if (sensorClass == SensorClasses.HTCDiamondTouch) { sensor = new HTCDiamondTouch(); } sensor.FromXML(jNode.OuterXml); this.Insert(sensor._ID, sensor); } } } } }
public void TestDoubleSensor() { var sensor = new DoubleSensor(); var ex = Assert.Throws<Exception>(() => SensorTypes.GetConfig(sensor)); Assert.True(ex.Message.Contains("Sensor Configuration Error: Simulator.Tests.Web.DoubleSensor")); }
/// <summary> /// A constructor that initializes the sensor type and class /// </summary> /// <param name="type"></param> /// <param name="classname"></param> public Sensor(SensorTypes type, SensorClasses classname) { this._Class = classname; this._Type = type; this._SamplingRate = 0; this._Saving = true; }
public static void NewGet( bool isWait, SensorTypes sensor, bool isComparasion, char port = '0', ComparasionTypes comparasion = ComparasionTypes.Equal, Variable valueCompare = null, Variable arrayCompare = null, Variable buttons = null, Variable timer = null, bool reset = false) { Get get = new Get() { IsWait = isWait, Port = port, SensorType = sensor, IsComparsion = isComparasion, Comparasion = comparasion, ValueCompare = valueCompare, ArrayCompare = arrayCompare, Buttons = buttons, Timer = timer, CanContinue = false, }; GlobalVariables.ExportData.Push(get); }
/// <summary> /// Helper function for ParseConfig. Inserts an array of sensor objects in their correct place in sensors dictionary. /// </summary> /// <param name="stype">The type of sensors</param> /// <param name="slist">The list of sensors objects to be added</param> /// <param name="finalOrder">The order of these sensors objects in the overall associated sensor list</param> protected virtual void AddSensorsToList(SensorTypes stype, ArrayList slist, int finalOrder) { ArrayList DTlist = new ArrayList(); if (!SensorsDictionary.TryGetValue(stype, out DTlist)) { DTlist = new ArrayList(4); SensorsDictionary.Add(stype, DTlist); } if (DTlist.Capacity < (finalOrder + slist.Count)) { DTlist.Capacity = ((finalOrder + slist.Count) / 4 + 1) * 4; // increase capacity in steps of 4 } DTlist.InsertRange(finalOrder, slist); if (stype == SensorTypes.DiffDrive) { cacheDrive = (DriveAdapter)((ListEntry)DTlist[0]).Adapter; } else if (stype == SensorTypes.ToneGenerator) { cacheTone = (ToneGeneratorAdapter)((ListEntry)DTlist[0]).Adapter; } else if (stype == SensorTypes.LEDArray) { cacheLED = (LEDArrayAdapter)((ListEntry)DTlist[0]).Adapter; } }
static void Initialize() { Root = Path.Combine(Application.dataPath, ".."); PersistentDataPath = Application.persistentDataPath; AssetBundle.UnloadAllAssetBundles(false); SensorPrefabs = RuntimeSettings.Instance.SensorPrefabs.ToList(); if (SensorPrefabs.Any(s => s == null)) { Debug.LogError("Null Sensor Prefab Detected - Check RuntimeSettings SensorPrefabs List for missing Sensor Prefab"); #if UNITY_EDITOR UnityEditor.EditorApplication.isPlaying = false; #else // return non-zero exit code Application.Quit(1); #endif return; } BridgePlugins.Load(); LoadBuiltinAssets(); LoadExternalAssets(); Sensors = SensorTypes.ListSensorFields(SensorPrefabs); ParseConfigFile(); if (!Application.isEditor) { ParseCommandLine(); } }
public void ReturnAllSensorTypes_When_Invoked() { //Arrange var contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>() .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) .Options; using (var arrangeContext = new SmartDormitoryDbContext(contextOptions)) { var sensorType = new SensorTypes { IsDeleted = false, Type = "testType", CreatedOn = DateTime.Now, }; arrangeContext.SensorTypes.Add(sensorType); arrangeContext.SaveChanges(); } // Act && Asert using (var assertContext = new SmartDormitoryDbContext(contextOptions)) { var sensorService = new SensorService(assertContext); var allSensorTypes = sensorService.GetAllTypes().ToList(); Assert.AreEqual(1, allSensorTypes.Count); } }
public SensorMask(SensorTypes[] sensorTypes) { foreach (SensorTypes sensorType in sensorTypes) { MaskValue |= 1UL << (UInt16)sensorType; } }
private static void Initialize() { Root = Path.Combine(Application.dataPath, ".."); PersistentDataPath = Application.persistentDataPath; ParseConfigFile(); if (!Application.isEditor) { ParseCommandLine(); CreateLockFile(); } AssetBundle.UnloadAllAssetBundles(false); Sensors = new List <SensorConfig>(); SensorPrefabs = new List <SensorBase>(); BridgePlugins.Load(); LoadBuiltinAssets(); LoadExternalAssets(); Sensors = SensorTypes.ListSensorFields(SensorPrefabs); DatabaseManager.Init(); ClientSettingsService csservice = new ClientSettingsService(); if (string.IsNullOrEmpty(SimID)) { SimID = csservice.GetOrMake().simid; } csservice.SetSimID(SimID); }
public void TestEnumSensor() { var sensor = new EnumSensor(); var parameterCount = 2; var typeCount = 1; var valuesCount = 3; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("Enum", config.Name); Assert.AreEqual(typeCount, config.Types.Length); Assert.AreEqual("Simulator.Bridge.Data.ImageData", config.Types[0]); Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("car", config.Parameters[0].Name); Assert.AreEqual("C", config.Parameters[0].DefaultValue); Assert.AreEqual("enum", config.Parameters[0].Type); Assert.AreEqual("truck", config.Parameters[1].Name); Assert.AreEqual("A", config.Parameters[1].DefaultValue); Assert.AreEqual("enum", config.Parameters[1].Type); Assert.AreEqual(valuesCount, config.Parameters[0].Values.Length); Assert.AreEqual("A", config.Parameters[0].Values[0]); Assert.AreEqual("B", config.Parameters[0].Values[1]); Assert.AreEqual("C", config.Parameters[0].Values[2]); Assert.False(config.Parameters.Exists(p => p.Name == "NotPresent")); }
public double Auth(SensorTypes sensorType, double sensorValue) { switch (sensorType) { case SensorTypes.Temperature: if (sensorValue < MinTemp) sensorValue = MinTemp; if (sensorValue > MaxTemp) sensorValue = MaxTemp; break; case SensorTypes.Ph: if (sensorValue < MinPh) sensorValue = MinPh; if (sensorValue > MaxPh) sensorValue = MaxPh; break; case SensorTypes.Chlorine: if (sensorValue < MinChlor) sensorValue = MinChlor; if (sensorValue > MaxChlor) sensorValue = MaxChlor; break; case SensorTypes.Humidity: if (sensorValue < MinHum) sensorValue = MinHum; if (sensorValue > MaxHum) sensorValue = MaxHum; break; default: throw new ArgumentOutOfRangeException(nameof(sensorType), sensorType, null); } return sensorValue; }
public SensorMask(SensorMask previousSensorMask, SensorTypes[] sensorTypes) { MaskValue = previousSensorMask.MaskValue; foreach (SensorTypes sensorType in sensorTypes) { MaskValue |= 1UL << (UInt16)sensorType; } }
public override bool Initialize(SensorTypes sensorTypes) { if (this.queue == null) { this.queue = new NSOperationQueue(); } this.RequestedSensors = sensorTypes; return(true); }
public void RegisterDialog(SensorTypes sensorType, Type viewType, Type modelType) { _typeToDialogDictionary[sensorType] = new DialogSensorViewTypes() { ModelType = modelType, ViewType = viewType }; _factory?.RegisterModel(sensorType, modelType); }
/// <summary> /// A method that populates a sensor object from an XML string /// </summary> /// <param name="xml">An input XML string that describes the sensor</param> public virtual void FromXML(string xml) { XmlDocument dom = new XmlDocument(); dom.LoadXml(xml); XmlNode iNode = dom.DocumentElement; if (iNode.Name == SENSOR_ELEMENT) { foreach (XmlAttribute iAttribute in iNode.Attributes) { if (iAttribute.Name == CLASS_ATTRIBUTE) { this._Class = (SensorClasses)Enum.Parse(typeof(SensorClasses), iAttribute.Value, true); } else if (iAttribute.Name == TYPE_ATTRIBUTE) { this._Type = (SensorTypes)Enum.Parse(typeof(SensorTypes), iAttribute.Value, true); } } foreach (XmlNode jNode in iNode.ChildNodes) { foreach (XmlAttribute jAttribute in jNode.Attributes) { if ((jNode.Name == ID_ELEMENT) && (jAttribute.Name == ID_ATTRIBUTE)) { this._ID = Convert.ToInt32(jAttribute.Value); } else if ((jNode.Name == SR_ELEMENT) && (jAttribute.Name == TEXT_ATTRIBUTE)) { this._SamplingRate = Convert.ToInt32(jAttribute.Value); } else if ((jNode.Name == Receiver.RECEIVER_ELEMENT) && (jAttribute.Name == ID_ATTRIBUTE)) { this._Receiver = new Receivers.GenericReceiver(); this._Receiver._ID = Convert.ToInt32(jAttribute.Value); } else if ((jNode.Name == Decoder.DECODER_ELEMENT) && (jAttribute.Name == ID_ATTRIBUTE)) { this._Decoder = new Decoders.Accelerometers.GenericDecoder(); this._Decoder._ID = Convert.ToInt32(jAttribute.Value); } else if ((jNode.Name == LOCATION_ELEMENT) && (jAttribute.Name == TEXT_ATTRIBUTE)) { this._Location = jAttribute.Value; } else if ((jNode.Name == DESCRIPTION_ELEMENT) && (jAttribute.Name == TEXT_ATTRIBUTE)) { this._Description = jAttribute.Value; } } } } }
public void RemoveSensor(SensorTypes sensorType) { foreach (var s in _sensors) { if (s.Type == sensorType) { _sensors.Remove(s); return; } } }
public WISEObject CreateObject(SensorTypes sensorType, ObjectHandle hObject) { switch (sensorType) { case SensorTypes.lcd: return new EntityEquipmentSensorCBRNLCD(_sink, _hDatabase, hObject); case SensorTypes.ap2ce: return new EntityEquipmentSensorCBRNAP2Ce(_sink, _hDatabase, hObject); case SensorTypes.raid: return new EntityEquipmentSensorCBRNRAID(_sink, _hDatabase, hObject); case SensorTypes.i28: return new EntityEquipmentSensorCBRNI28(_sink, _hDatabase, hObject); case SensorTypes.i27: return new EntityEquipmentSensorCBRNI27(_sink, _hDatabase, hObject); } throw new NotImplementedException(); }
public MonitoringSensorViewModel(MonitoringSensorUpdate sensorUpdate, MonitoringNodeBase parent = null) { _lastStatusUpdate = DateTime.Now; Name = sensorUpdate.Name; _parent = parent; Product = sensorUpdate.Product; Status = sensorUpdate.Status; _sensorType = sensorUpdate.SensorType; _path = ConvertPathToString(sensorUpdate.Path); ShortValue = sensorUpdate.ShortValue; _sensorUpdate = sensorUpdate; }
static void Initialize() { Root = Path.Combine(Application.dataPath, ".."); PersistentDataPath = Application.persistentDataPath; Sensors = SensorTypes.ListSensorFields(RuntimeSettings.Instance?.SensorPrefabs); Bridges = BridgeTypes.GetBridgeTypes(); ParseConfigFile(); if (!Application.isEditor) { ParseCommandLine(); } }
protected Sensor(SensorTypes type, object owner, TShape shape, uint groups, uint affects, bool isCompound) { Type = type; Groups = groups; Affects = affects; // Note that sensor owner is allowed to be null (useful for manually creating debug sensors, but might be // applicable in finished games too). Owner = owner; Shape = shape; IsEnabled = true; IsCompound = isCompound; Contacts = new List <Sensor <TSensor, TShape, TShapeType, TSpace, TPosition> >(); }
public static string SignForType(SensorTypes type) { switch (type) { case SensorTypes.Temperature: return "°C"; case SensorTypes.Humidity: return "%"; case SensorTypes.Chlorine: return "ppm"; default: return ""; } }
public void AddSensor(SensorTypes sensorType) { foreach (var s in _sensors) { if (s.Type == sensorType) { return; } } var sensor = Create(sensorType); _sensors.Add(sensor); }
static void Initialize() { Root = Path.Combine(Application.dataPath, ".."); PersistentDataPath = Application.persistentDataPath; SensorPrefabs = LoadSensorPlugins(); Controllables = LoadControllablePlugins(); Sensors = SensorTypes.ListSensorFields(SensorPrefabs); Bridges = BridgeTypes.GetBridgeTypes(); ParseConfigFile(); if (!Application.isEditor) { ParseCommandLine(); } }
protected Sensor(SensorTypes type, object owner, int groups, int affects, bool isCompound, Shape3D shape = null) { Debug.Assert(owner != null, "Owner can't be null."); this.shape = shape; Type = type; Groups = groups; Affects = affects; Owner = owner; IsEnabled = true; IsCompound = isCompound; Contacts = new List <Sensor>(); }
public DroidSensors(SensorTypes sensorTypes) { this.sensorManager = Application.Context.GetSystemService(Context.SensorService) as SensorManager; this.sensorListener = new DroidSensorListener(); // Accelerometer if (sensorTypes.HasFlag(SensorTypes.Accelerometer)) { this.accelerometer = this.sensorManager.GetDefaultSensor(SensorType.Accelerometer); } // Gyroscope if (sensorTypes.HasFlag(SensorTypes.Gyroscope)) { this.gyroscope = this.sensorManager.GetDefaultSensor(SensorType.Gyroscope); } }
public override bool Initialize(SensorTypes sensorTypes) { if (!this.Initialized) { // Accelerometer if (sensorTypes.HasFlag(SensorTypes.Accelerometer)) { this.accelerometer = this.sensorManager.GetDefaultSensor(SensorType.Accelerometer); } // Gyroscope if (sensorTypes.HasFlag(SensorTypes.Gyroscope)) { this.gyroscope = this.sensorManager.GetDefaultSensor(SensorType.Gyroscope); } this.Initialized = true; return(true); } return(false); }
private ICharacterSensor Create(SensorTypes sensorType) { switch (sensorType) { case SensorTypes.Sight: return(new SightSensor()); case SensorTypes.MeleeRange: return(new MeleeRangeSensor()); case SensorTypes.FieldOfView: return(new FieldOfViewSensor()); case SensorTypes.SpeelCastRange: return(new SpellCastRangeSensor()); } return(null); }
public void TestStringSensor() { var sensor = new StringSensor(); var parameterCount = 2; var typeCount = 1; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("String", config.Name); Assert.AreEqual(typeCount, config.Types.Length); Assert.AreEqual("Simulator.Bridge.Data.ImageData", config.Types[0]); Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("Help", config.Parameters[0].Name); Assert.AreEqual("helping", config.Parameters[0].DefaultValue); Assert.AreEqual("string", config.Parameters[0].Type); Assert.AreEqual("LG", config.Parameters[1].Name); Assert.AreEqual(null, config.Parameters[1].DefaultValue); Assert.AreEqual("string", config.Parameters[1].Type); Assert.False(config.Parameters.Exists(p => p.Name == "NotPresent")); }
/// <summary> /// Initializes a new instance of the <see cref="DHT11"/> class. /// </summary> /// <param name="datatPin">The datat pin.</param> /// <param name="sensor">The sensor.</param> /// <exception cref="System.ArgumentException">Parameter cannot bet null.;dataPin</exception> public DHT11(GpioPin datatPin, SensorTypes sensor) { if (datatPin != null) { _dataPin = datatPin; _secondsSinceLastRead = 0D; _firstReading = true; _data = new UInt32[6]; _sensorType = sensor; //Init the data pin _dataPin.SetDriveMode(GpioPinDriveMode.Input); _dataPin.Write(GpioPinValue.High); _firstReading = true; _secondsSinceLastRead = 0; } else { throw new ArgumentException("Parameter cannot bet null.", "dataPin"); } }
public void TestColorSensor() { var sensor = new ColorSensor(); var parameterCount = 2; var typeCount = 1; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("Color", config.Name); Assert.AreEqual(typeCount, config.Types.Length); Assert.AreEqual("Simulator.Bridge.Data.ImageData", config.Types[0]); Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("picture", config.Parameters[0].Name); Assert.AreEqual("#FF00FFFF", config.Parameters[0].DefaultValue); Assert.AreEqual("color", config.Parameters[0].Type); Assert.AreEqual("space", config.Parameters[1].Name); Assert.AreEqual("#00000000", config.Parameters[1].DefaultValue); Assert.AreEqual("color", config.Parameters[1].Type); Assert.False(config.Parameters.Exists(p => p.Name == "NotPresent")); }
public void TestIntSensor() { var sensor = new IntSensor(); var parameterCount = 2; var typeCount = 1; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("Int", config.Name); Assert.AreEqual(typeCount, config.Types.Length); Assert.AreEqual("Simulator.Bridge.Data.ImageData", config.Types[0]); Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("year", config.Parameters[0].Name); Assert.AreEqual(2019, config.Parameters[0].DefaultValue); Assert.AreEqual("int", config.Parameters[0].Type); Assert.AreEqual("LG", config.Parameters[1].Name); Assert.AreEqual(0, config.Parameters[1].DefaultValue); Assert.AreEqual("int", config.Parameters[1].Type); Assert.False(config.Parameters.Exists(p => p.Name == "NotPresent")); }
public void TestBoolSensor() { var sensor = new BoolSensor(); var parameterCount = 2; var typeCount = 1; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("Bool", config.Name); Assert.AreEqual(typeCount, config.Types.Length); Assert.AreEqual("Simulator.Bridge.Data.ImageData", config.Types[0]); Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("happy", config.Parameters[0].Name); Assert.AreEqual(true, config.Parameters[0].DefaultValue); Assert.AreEqual("bool", config.Parameters[0].Type); Assert.AreEqual("duckie", config.Parameters[1].Name); Assert.AreEqual(false, config.Parameters[1].DefaultValue); Assert.AreEqual("bool", config.Parameters[1].Type); Assert.False(config.Parameters.Exists(p => p.Name == "NotPresent")); }
private static void Initialize() { Root = Path.Combine(Application.dataPath, ".."); PersistentDataPath = Application.persistentDataPath; ParseConfigFile(); if (!Application.isEditor) { ParseCommandLine(); CreateLockFile(); } AssetBundle.UnloadAllAssetBundles(false); Sensors = new List <SensorConfig>(); SensorPrefabs = new List <SensorBase>(); if (SensorPrefabs.Any(s => s == null)) { Debug.LogError("!!! Null Sensor Prefab Detected - Check RuntimeSettings SensorPrefabs List for missing Sensor Prefab"); #if UNITY_EDITOR UnityEditor.EditorApplication.isPlaying = false; #else Application.Quit(1); // return non-zero exit code #endif } BridgePlugins.Load(); LoadBuiltinAssets(); LoadExternalAssets(); Sensors = SensorTypes.ListSensorFields(SensorPrefabs); DatabaseManager.Init(); ClientSettingsService csservice = new ClientSettingsService(); if (string.IsNullOrEmpty(SimID)) { SimID = csservice.GetOrMake().simid; } csservice.SetSimID(SimID); }
public void TestManyDataSensor() { var sensor = new ManyDataSensor(); var parameterCount = 1; var expectedTypes = new [] { typeof(ImageData), typeof(PointCloudData), typeof(Detected3DObjectArray), typeof(Detected3DObjectData), }; var config = SensorTypes.GetConfig(sensor); Assert.AreEqual("ManyData", config.Name); Assert.AreEqual(expectedTypes.Length, config.Types.Length); for (int i=0; i<expectedTypes.Length; i++) { Assert.AreEqual(expectedTypes[i].ToString(), config.Types[i], $"Wrong type, expected {expectedTypes[i]}, got {config.Types[i]}"); } Assert.AreEqual(parameterCount, config.Parameters.Count); Assert.AreEqual("data", config.Parameters[0].Name); Assert.AreEqual(2, config.Parameters[0].DefaultValue); }
/// <summary> /// A constructor that initializes the sensor type and class /// </summary> /// <param name="type"></param> /// <param name="classname"></param> public Sensor(SensorTypes type,SensorClasses classname) { this._Class = classname; this._Type = type; this._SamplingRate = 0; this._Saving = true; }
public SensorMask(SensorMask previousSensorMask, SensorTypes sensorType) { MaskValue = previousSensorMask.MaskValue; MaskValue |= 1UL << (UInt16)sensorType; }
/// <summary> /// A method that populates a sensor object from an XML string /// </summary> /// <param name="xml">An input XML string that describes the sensor</param> public virtual void FromXML(string xml) { XmlDocument dom = new XmlDocument(); dom.LoadXml(xml); XmlNode iNode = dom.DocumentElement; if (iNode.Name == SENSOR_ELEMENT) { foreach (XmlAttribute iAttribute in iNode.Attributes) { if (iAttribute.Name == CLASS_ATTRIBUTE) this._Class = (SensorClasses)Enum.Parse(typeof(SensorClasses), iAttribute.Value,true); else if (iAttribute.Name == TYPE_ATTRIBUTE) this._Type = (SensorTypes)Enum.Parse(typeof(SensorTypes), iAttribute.Value,true); } foreach (XmlNode jNode in iNode.ChildNodes) { foreach (XmlAttribute jAttribute in jNode.Attributes) { if ((jNode.Name == ID_ELEMENT) && (jAttribute.Name == ID_ATTRIBUTE)) this._ID = Convert.ToInt32(jAttribute.Value); else if ((jNode.Name == SR_ELEMENT) && (jAttribute.Name == TEXT_ATTRIBUTE)) this._SamplingRate = Convert.ToInt32(jAttribute.Value); else if ((jNode.Name == Receiver.RECEIVER_ELEMENT) && (jAttribute.Name == ID_ATTRIBUTE)) { this._Receiver = new Receivers.GenericReceiver(); this._Receiver._ID = Convert.ToInt32(jAttribute.Value); } else if ((jNode.Name == Decoder.DECODER_ELEMENT) && (jAttribute.Name == ID_ATTRIBUTE)) { this._Decoder = new Decoders.Accelerometers.GenericDecoder(); this._Decoder._ID = Convert.ToInt32(jAttribute.Value); } else if ((jNode.Name == LOCATION_ELEMENT) && (jAttribute.Name == TEXT_ATTRIBUTE)) this._Location = jAttribute.Value; else if ((jNode.Name == DESCRIPTION_ELEMENT) && (jAttribute.Name == TEXT_ATTRIBUTE)) this._Description = jAttribute.Value; } } } }
public SensorMask(SensorTypes sensorType1, SensorTypes sensorType2, SensorTypes sensorType3) { MaskValue |= (1UL << (UInt16)sensorType1) | (1UL << (UInt16)sensorType2) | (1UL << (UInt16)sensorType3); }
public SensorMask(SensorTypes sensorType) { MaskValue |= 1UL << (UInt16)sensorType; }
public void SetSensorType(SensorTypes sensorType) { this.MaskValue = 1UL << (UInt16)sensorType; }
public void RemoveSensorType(SensorTypes sensorType) { this.MaskValue = this.MaskValue & ~(1UL << (UInt16)sensorType); }
public Boolean HasASensor(SensorTypes sensorType) { return (MaskValue & (1UL << (UInt16)sensorType)) != 0UL; }
public void AddSensorType(SensorTypes sensorType) { this.MaskValue = this.MaskValue | 1UL << (UInt16)sensorType; }
private static Tuple<SensorTypes, List<double>> GetData(List<Tuple<SensorTypes, double>> dataFromDb, SensorTypes sensorType) { var tempList = new List<double>(); foreach (var tuple in dataFromDb) { tempList.Add(tuple.Item2); } return new Tuple<SensorTypes, List<double>>(sensorType, tempList); }
// Graph drawing private Tuple<double, double> DrawGraph(UIView view, List<double> values, SensorTypes type) { var bounds = GraphBounds (values, (type == SensorTypes.Chlorine || type == SensorTypes.Ph)); var points = GraphPoints (values, bounds, view); var numberOfPoints = points.Count; if (numberOfPoints == 0) return bounds; var path = new UIBezierPath (); path.MoveTo (points[0]); for (var i = 1; i < numberOfPoints; i++) { path.AddLineTo (points[i]); } var layer = new CAShapeLayer (); layer.Path = path.CGPath; layer.StrokeColor = UIColor.White.CGColor; layer.LineWidth = 2; layer.FillColor = UIColor.Clear.CGColor; view.Layer.Sublayers = null; view.Layer.AddSublayer (layer); return bounds; }
public FailedDeviceSettings(int deviceId, float deviceGradient, SensorTypes type) { SensorType = type; FailedDeviceId = deviceId; FailedDeviceGradient = deviceGradient; }