public void AddMeasurement(DateTime time, double value) { if (Measurements[_actIndex] == null && _actIndex == 0) // erster Messwert ==> Trend auf 0 setzen { Trend = 0; lastTimeStamp = time; } else { double timeFactorToHour = 3600.0 / (time - lastTimeStamp).TotalSeconds; int ind = (_actIndex - 1 + 10) % 10; double delta = value - Measurements[ind].Value; if (value == 0) { Trend = 1000.0; } else { Trend = (Trend * 0.5 + delta / value * timeFactorToHour) / 1.5; } } Measurements[_actIndex] = new MeasurementValue(time, value); Log.Information($"Add SensorWithHistory; Sensor: {ItemEnum}, Value: {value}, Index: {_actIndex}, Trend: {Trend}"); _actIndex = (_actIndex + 1) % 10; // letzte Werte als aktuelle Werte speichern Time = time; Value = value; }
/// <summary> /// Transform each result in a JSON string and publish string to topic /// </summary> /// <param name="SensorValue">Sensor value</param> public override void HandleValue(MeasurementValue SensorValue) { lock (WriteLock) { PublishSingleValue(SensorValue); } }
/// <summary> /// Write sensor value to console /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> public override void HandleValue(MeasurementValue SensorValue) { lock (WriteLock) { System.Console.WriteLine($"Sensor [{SensorValue.PluginName}], Location [{SensorValue.SensorLocation}], Value [{SensorValue.Value}], Unit [{SensorValue.Unit}]"); } }
/// <summary> /// Write sensor values to file /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> public override void HandleValue(MeasurementValue SensorValue) { lock (WriteLock) { string data = SensorValue.ToJSON(); Datafile.WriteLine(data); } }
public override string ToString() { var timeString = MeasurementTime.ToString(Globals.DateTimeFormat); var typeDescription = Type.GetDescription(); var valueString = MeasurementValue.ToString("0,0.00", new CultureInfo("en-US", false)); return($"{{{timeString}, {typeDescription}, {valueString}}}"); }
/// <summary> /// Create a single measurement value /// </summary> /// <returns></returns> public MeasurementValue GetValue() { MeasurementValue value = new MeasurementValue("", Location, Unit, WaterGaugeConfig.Instance.SortOrder); value.Value = Gauge; value.Timestamp = Timestamp; return(value); }
private MeasurementValue Save(MeasurementValue value, long measurementItemId) { if (_connection.Get.Insert(MeasurementValueEntity.FromDomain(value, measurementItemId)) > 0) { return(value.WithId(_connection.LastIndex)); } return(null); }
/// <summary> /// Write sensor values to database /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> public override void HandleValue(MeasurementValue SensorValue) { lock (WriteLock) { var MType = DetermineMeasurementType(SensorValue); var MUnit = DetermineMeasurementUnit(SensorValue); var MLocation = DetermineMeasurementLocation(SensorValue); WriteSensorData(SensorValue, MType, MUnit, MLocation); } }
public override int GetHashCode() { unchecked { var hash = (int)Globals.HashCodeBase; hash = (hash * Globals.HashCodeMultiplier) ^ MeasurementTime.GetHashCode(); hash = (hash * Globals.HashCodeMultiplier) ^ MeasurementValue.GetHashCode(); hash = (hash * Globals.HashCodeMultiplier) ^ Type.GetHashCode(); return(hash); } }
/// <summary> /// Publish single measurement data /// </summary> /// <param name="dataToPublish"></param> private void PublishSingleValue(MeasurementValue dataToPublish) { var dataJSON = dataToPublish.ToJSON(); if (MQTTConfig.Instance.Handshake == true) { lock (WriteLock) { AcknowledgeList.Add(dataToPublish.ToHash(), dataToPublish); } } MqttClient.Publish(MQTTConfig.Instance.TopicData, Encoding.ASCII.GetBytes(dataJSON)); }
/// <summary> /// Read value from sensor and prepare real value /// </summary> /// <returns>Illuminance or 0.0</returns> protected override List <MeasurementValue> RawValues() { var result = new List <MeasurementValue>(); MeasurementValue value = new MeasurementValue(Name, "", Unit, AmbientLightConfig.Instance.SortOrder); if (Bricklet != null) { int rawIlluminance = Bricklet.GetIlluminance(); value.Value = rawIlluminance / 10.0; result.Add(value); } return(result); }
/// <summary> /// Write the sensor value to the database /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> /// <param name="MType">Used measurement type - the sensor name</param> /// <param name="MUnit">used measurement unit</param> /// <param name="MLocation">used measurement location</param> private void WriteSensorData(MeasurementValue SensorValue, MType MType, MUnit MUnit, MLocation MLocation) { var MValue = new MValue { Type = MType, Unit = MUnit, Location = MLocation, RecordTime = SensorValue.Timestamp, Value = SensorValue.Value }; DBInstance.Add(MValue); DBInstance.SaveChanges(); }
/// <summary> /// Read value from sensor and prepare real value /// </summary> /// <returns>Air pressure or 0.0</returns> protected override List <MeasurementValue> RawValues() { var result = new List <MeasurementValue>(); MeasurementValue value = new MeasurementValue(Name, "", Unit, AirPressureConfig.Instance.SortOrder); if (Bricklet != null) { int airPressureRaw = Bricklet.GetAirPressure(); value.Value = airPressureRaw / 1000.0; result.Add(value); } return(result); }
private void DataSubscriptionNewMeasurements(object sender, EventArgs <ICollection <IMeasurement> > e) { lock (m_measurementLock) { foreach (IMeasurement measurement in e.Argument) { MeasurementValue value = new MeasurementValue(); value.Timestamp = GetUnixMilliseconds(measurement.Timestamp); value.Value = measurement.Value; value.ID = measurement.ID; m_measurements.Add(value); } } }
/// <summary> /// Read value from sensor and prepare real value /// </summary> /// <returns>Humidity or 0.0</returns> protected override List <MeasurementValue> RawValues() { var result = new List <MeasurementValue>(); MeasurementValue value = new MeasurementValue(Name, "", Unit, HumidityConfig.Instance.SortOrder); if (Bricklet != null) { int humidityRaw = Bricklet.GetHumidity(); value.Value = humidityRaw / 10.0; result.Add(value); } return(result); }
public override Measurement AddMeasurement(DateTime time, double value) { //if (MeasurementsBuffer[_actIndex] == null && _actIndex == 0) // erster Messwert ==> Trend auf 0 setzen //{ // Trend = 0; // _lastPersistenceTime = time; //} //else //{ // double timeFactorToHour = 3600.0 / (time - _lastPersistenceTime).TotalSeconds; // int index = (_actIndex - 1 + 10) % 10; // double delta = value - MeasurementsBuffer[index].Value; // if (value == 0) // { // Trend = 1000.0; // } // else // { // Trend = (Trend * 0.5 + delta / value * timeFactorToHour) / 1.5; // } //} MeasurementsBuffer[_actIndex] = new MeasurementValue(time, value); var measurementValueBefore10Minutes = GetMeasurementValueBeforeXMinutes(MeasurementsBuffer, _actIndex, 10); if (measurementValueBefore10Minutes != null) { var timeDifference = (DateTime.Now - measurementValueBefore10Minutes.Time).TotalSeconds;; double valueDifference = value - measurementValueBefore10Minutes.Value; Trend = valueDifference / timeDifference * 3600; // Delta pro Stunde } else { Trend = double.MinValue; } Log.Information($"AddMeasurementToBuffer; Item: {Name}, Value: {value}, Index: {_actIndex}, Trend: {Trend}"); _actIndex = (_actIndex + 1) % MeasurementsBuffer.Length; // letzte Werte als aktuelle Werte speichern Time = time; Value = value; var measurement = new Measurement { ItemId = Id, Item = this, Time = time, Value = Value }; return(measurement); }
/// <summary> /// Determine measurement location object, create if not exists /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> /// <returns>Referenced measurement location object</returns> public MLocation DetermineMeasurementLocation(MeasurementValue SensorValue) { var MLocation = DBInstance.DBMeasurementLocations.Where(a => a.Name == SensorValue.SensorLocation).FirstOrDefault(); if (MLocation == null) { MLocation = new MLocation { Name = SensorValue.SensorLocation }; DBInstance.Add(MLocation); DBInstance.SaveChanges(); } return(MLocation); }
/// <summary> /// Determine measurement type (sensor name) object, create if not exists /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> /// <returns>Referenced measurement type object</returns> public MType DetermineMeasurementType(MeasurementValue SensorValue) { var MType = DBInstance.DBMeasurementTypes.Where(a => a.Name == SensorValue.PluginName).FirstOrDefault(); if (MType == null) { MType = new MType { Name = SensorValue.PluginName }; DBInstance.Add(MType); DBInstance.SaveChanges(); } return(MType); }
/// <summary> /// Determine measurement unit object, create if not exists /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> /// <returns>Referenced measurement unit object</returns> public MUnit DetermineMeasurementUnit(MeasurementValue SensorValue) { var MUnit = DBInstance.DBMeasurementUnits.Where(a => a.Name == SensorValue.Unit).FirstOrDefault(); if (MUnit == null) { MUnit = new MUnit { Name = SensorValue.Unit }; DBInstance.Add(MUnit); DBInstance.SaveChanges(); } return(MUnit); }
/// <summary> /// Read value from sensor and prepare real value /// </summary> /// <returns>Air pressure or 0.0</returns> protected override MeasurementValue ValueGetRaw() { MeasurementValue result = new MeasurementValue(Name, Unit, TemperatureConfig.Instance.SortOrder); if (_Bricklet == null) { return(result); } int temperatureRaw = _Bricklet.GetChipTemperature(); result.Value = temperatureRaw / 100.0; return(result); }
/// <summary> /// Read value from sensor and prepare real value /// </summary> /// <returns>Air pressure or 0.0</returns> protected override MeasurementValue ValueGetRaw() { MeasurementValue returnValue = new MeasurementValue(Name, Unit, AirPressureConfig.Instance.SortOrder); if (_Bricklet == null) { return(returnValue); } int airPressureRaw = _Bricklet.GetAirPressure(); returnValue.Value = airPressureRaw / 1000.0; return(returnValue); }
/// <summary> /// Read value from sensor and prepare real value /// </summary> /// <returns>Altitude or 0.0</returns> protected override MeasurementValue ValueGetRaw() { MeasurementValue result = new MeasurementValue(Name, Unit, AltitudeConfig.Instance.SortOrder); if (_Bricklet == null) { return(result); } int altitudeRaw = _Bricklet.GetAltitude(); result.Value = altitudeRaw / 100.0; return(result); }
public XmlElement WriteXmlTag(XmlElement element) { element.InnerText = MeasurementValue.ToString(); if (MeasurementAttributes != null) { foreach (string key in MeasurementAttributes.Keys) { if (MeasurementAttributes [key] != "") { element.SetAttribute(key, MeasurementAttributes [key]); } } } return(element); }
/// <summary> /// Part of interface TFDataSink - perform action with given data /// </summary> /// <param name="SensorValue"></param> public override void HandleValue(MeasurementValue SensorValue) { if (Bricklet == null) { return; } if (SensorValue.SortOrder == LcdConfig.Instance.SkipIndex) { return; } // Calculation of position in dependency of the sort order byte posX = (byte)((SensorValue.SortOrder % 2) * 10); byte posY = (byte)((SensorValue.SortOrder / 2) + 1); string MeasurementValueData = string.Format("{0,7:####.00} {1}", SensorValue.Value, SensorValue.Unit); lock (WriteLock) { Bricklet.WriteLine(posY, posX, MeasurementValueData); } }
protected override void ExecuteCrmWorkFlowActivity(CodeActivityContext context, LocalWorkflowContext localContext) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (localContext == null) { throw new ArgumentNullException(nameof(localContext)); } string aiSetupJson = AiSetupJson.Get(context); AiLogger aiLogger = new AiLogger(aiSetupJson, localContext.OrganizationService, localContext.TracingService, localContext.WorkflowExecutionContext, null, localContext.WorkflowExecutionContext.WorkflowCategory); string name = Name.Get(context); string measurementName = MeasurementName.Get(context); double measurementValue = MeasurementValue.Get(context); string measurementNameValidationResult = AiEvent.ValidateMeasurementName(measurementName); if (!string.IsNullOrEmpty(measurementNameValidationResult)) { localContext.TracingService.Trace(measurementNameValidationResult); LogSuccess.Set(context, false); return; } Dictionary <string, double> measurements = new Dictionary <string, double> { { measurementName, Convert.ToDouble(measurementValue) } }; bool logSuccess = aiLogger.WriteEvent(name, measurements); LogSuccess.Set(context, logSuccess); }
private void StatisticSubscriptionNewMeasurements(object sender, EventArgs <ICollection <IMeasurement> > e) { foreach (IMeasurement measurement in e.Argument) { int index = m_statistics.IndexOf(m => m.ID == measurement.ID); if (index < 0) { MeasurementValue statistic = new MeasurementValue { ID = measurement.ID, Value = measurement.Value, Timestamp = GetUnixMilliseconds(measurement.Timestamp) }; m_statistics.Add(statistic); } else { m_statistics[index].Value = measurement.Value; m_statistics[index].Timestamp = GetUnixMilliseconds(measurement.Timestamp); } } }
public static extern int imaqCalcCoeff(IntPtr image, ref ParticleReport report, MeasurementValue parameter, ref float coefficient);
/// <summary> /// Write sensor values to console /// </summary> /// <param name="SensorValue">Tinkerforge Sensor plugin value</param> public void HandleValue(MeasurementValue SensorValue) { System.Console.WriteLine($"Sensor [{SensorValue.Name}], Value [{SensorValue.Value}], Unit [{SensorValue.Unit}]"); }
public MeasurementValue ToDomain() => MeasurementValue.Create(_typeName, _value);
public static MeasurementValueEntity FromDomain(MeasurementValue domain) => new MeasurementValueEntity(domain.Id, domain.Type.NameCode, domain.Value);
internal static MeasurementValue FromApi(ApiMeasurementValue value) => MeasurementValue.Create(value.Name, value.Value);