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);
