public static int InsertIntoDatabase(MeasuredValue currentValue, TypeCode typeCode)
{
if (currentValue == null)
{
return(0);
}
string sql = "INSERT INTO {0} (Name, MeasuredDate, Value, Quality, Remark) " +
"values(@Name, @MeasuredDate, @Value, @Quality, @Remark);";
sql = string.Format(sql, GetTableNameFor(typeCode));
int rowAffected = 0;
using (var command = new SqlCeCommand(sql, DataBaseConnection.GetSqlCeConnection()))
{
command.Parameters.AddWithValue("Name", currentValue.Name);
command.Parameters.AddWithValue("MeasuredDate", currentValue.TimeStamp);
command.Parameters.AddWithValue("Value", currentValue.Value);
command.Parameters.AddWithValue("Quality", (byte)currentValue.Quality);
command.Parameters.AddWithValue("Remark", currentValue.Description);
rowAffected = command.ExecuteNonQuery();
}
_logger.DebugFormat("Row affected: {0} - {1}", rowAffected, sql);
return(rowAffected);
}
public static int SaveValueWhenConditionsAreMet(MeasuredValue currentValue, CompressionCondition condition)
{
if (currentValue == null)
{
throw new ArgumentNullException("currentValue");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
// if the current value has the OPCQuality of "NoValue"
// return without writting the value
if (currentValue.Quality == OPCQuality.NoValue)
{
_logger.DebugFormat("current value {0} has the OPCQuality of \"NoValue\"", currentValue.Name);
return(0);
}
TypeCode typeCode = currentValue.GetTypeCode();
MeasuredValue previousValue = ReadLastMeasuredValueFromLocalDB(currentValue.Name, typeCode);
if (false == condition.ShouldCurrentValueBeWritten(currentValue, previousValue))
{
return(0);
}
int rowAffected = InsertIntoDatabase(currentValue, typeCode);
return(rowAffected);
}
public static MeasuredValue ReadLastMeasuredValueFromLocalDB(string valueName, TypeCode typeCode)
{
if (string.IsNullOrEmpty(valueName))
{
throw new ArgumentNullException("valueName");
}
MeasuredValue value = new MeasuredValue();
string sql = "SELECT Name, MeasuredDate, Value, Quality, Remark FROM {0} " +
"WHERE Name = @Name AND MeasuredDate IN" +
" (SELECT max(MeasuredDate) FROM {0} WHERE Name = @Name)";
sql = string.Format(sql, GetTableNameFor(typeCode));
using (var command = new SqlCeCommand(sql, DataBaseConnection.GetSqlCeConnection()))
{
command.Parameters.AddWithValue("Name", valueName);
using (SqlCeDataReader sr = command.ExecuteReader(System.Data.CommandBehavior.SingleRow))
{
if (sr.Read())
{
value.Name = (string)sr["Name"];
value.TimeStamp = (DateTime)sr["MeasuredDate"];
value.Value = sr["Value"];
value.Quality = (OPCQuality)(byte)sr["Quality"];
value.Description = (string)sr["Remark"];
}
}
}
return(value);
}
public void CheckMeasuredValue()
{
var mv = new MeasuredValue();
mv.Name = "test";
Assert.AreEqual(true, mv.IsValueNull());
Assert.AreEqual(false, mv.IsValid());
mv.Value = 1;
Assert.AreEqual(false, mv.IsValueNull());
Assert.AreEqual(false, mv.IsValid());
Assert.AreEqual(TypeCode.Int32, mv.GetTypeCode());
mv.TimeStamp = DateTime.Now;
Assert.AreEqual(false, mv.IsValueNull());
Assert.AreEqual(true, mv.IsValid());
mv.Value = "text";
Assert.AreEqual(TypeCode.String, mv.GetTypeCode());
int value = 2;
mv.Value = value;
Assert.AreEqual("2", mv.Value.ToString());
Assert.AreEqual(2, mv.Value);
/*string test = JsonConvert.SerializeObject(mv);
* MeasuredValue mv2 = JsonConvert.DeserializeObject<MeasuredValue>(test);
* Assert.AreEqual(2, mv2.Value);
*
* mv.Value = "Test";
* test = JsonConvert.SerializeObject(mv);
* MeasuredValue mv3 = JsonConvert.DeserializeObject<MeasuredValue>(test);
* Assert.AreEqual("Test", mv3.Value);*/
}
public string GetMeasurementItemText(MeasurementItemViewKind viewKind)
{
StringBuilder sb = new StringBuilder("");
if ((viewKind & MeasurementItemViewKind.DBId) != 0)
{
sb.Append($"[{Id.ToString()}]");
}
if ((viewKind & MeasurementItemViewKind.LogTime) != 0)
{
sb.AppendSeparated(LogTime.ToString());
}
if ((viewKind & MeasurementItemViewKind.EventTime) != 0)
{
sb.AppendSeparated(EventTime.ToString());
}
if ((viewKind & MeasurementItemViewKind.Value) != 0)
{
sb.AppendSeparated(MeasuredValue.ToString());
}
if ((viewKind & MeasurementItemViewKind.Unit) != 0)
{
sb.AppendSeparated(MeasuredUnit.ToString());
}
return(sb.ToString());
}
public SimpleBodyFrame(MeasuredValue time,
MeasuredVector3 location,
MeasuredVector3 velocity)
: base(time)
{
_location = location.In(SI.Metre);
_velocity = velocity.In(SI.Metre / SI.Second);
}
private void extractTrafficDataFromSiteMeasurements(SiteMeasurements measurementsForSite)
{
String siteGUID = measurementsForSite.measurementSiteReference.id;
log.Info("TMU site ID: " + siteGUID);
log.Info("Number of measurements for TMU site: " + measurementsForSite.measuredValue.Length);
// There can be a number of measured values reported for the site
foreach (_SiteMeasurementsIndexMeasuredValue measuredValue in measurementsForSite.measuredValue)
{
MeasuredValue mv = measuredValue.measuredValue;
BasicData basicData = mv.basicData;
// The index number of the site measurement is important - as this
// relates the data
// to the NTIS reference model, which adds context to the value
// (e.g. lane information,
// or vehicle characteristics)
int index = measuredValue.index;
// Determine what class (type) of traffic data is contained in the
// basic data
if (basicData.GetType() == typeof(TrafficFlow))
{
TrafficFlow flow = (TrafficFlow)basicData;
log.Info("[Measurement Index : " + index + "] Vehicle Flow Rate: " + flow.vehicleFlow.vehicleFlowRate);
if (flow.vehicleFlow.dataError)
{
MultilingualStringValue[] errorReason = flow.vehicleFlow.reasonForDataError.values;
foreach (MultilingualStringValue value in errorReason)
{
log.Info(" Data in error. Reason: \"" + value.Value + "\"");
}
}
}
else if (basicData.GetType() == typeof(TrafficSpeed))
{
TrafficSpeed speed = (TrafficSpeed)basicData;
log.Info("[Measurement Index : " + index + "] Average Speed: " + speed.averageVehicleSpeed.speed);
}
else if (basicData.GetType() == typeof(TrafficHeadway))
{
TrafficHeadway headway = (TrafficHeadway)basicData;
log.Info("[Measurement Index : " + index + "] Average Headway: " + headway.averageTimeHeadway.duration);
}
else if (basicData.GetType() == typeof(TrafficConcentration))
{
TrafficConcentration concentration = (TrafficConcentration)basicData;
log.Info("[Measurement Index : " + index + "] Traffic Occupancy (%): " + concentration.occupancy.percentage);
}
else
{
log.Error("Unexpected traffic data type contained in publication: " + basicData.GetType().Name.ToString());
}
}
}
public object Clone()
{
return(new StyleDefinition()
{
MeasuredValue = (CssMeasure)MeasuredValue.Clone(),
IsInheritable = IsInheritable,
Key = Key
});
}
private AutoMeasuredValue GetAutoMeasuredValue(byte[] data)
{
if (data.Length == 28)
{
return(null);
}
AutoMeasuredValue amv = new AutoMeasuredValue();
int nYear = 0;
int nMonth = 0;
int nDay = 0;
int nHour = 0;
int nMinute = 0;
int nSecond = 0;
try
{
amv.areaId = BitConverter.ToInt32(data, 0);
amv.machineId = BitConverter.ToInt32(data, 4);
amv.monitorId = BitConverter.ToInt32(data, 8);
amv.position_HVA = BitConverter.ToInt32(data, 12);
amv.channeld = BitConverter.ToInt32(data, 16);
amv.monitorPeriodTime = BitConverter.ToInt32(data, 20);
amv.typeSensor = BitConverter.ToInt32(data, 24);
if (amv.areaId == 0)//数据无效 返回空
{
return(null);
}
amv.MeasuredList = new List <MeasuredValue>();
//获取运行次数 =（总长度-数据头）/ 结构体大小
int runNum = (data.Length - 28) / 84;
for (int i = 0; i < runNum; i++)
{
MeasuredValue mv = new MeasuredValue();
mv = (MeasuredValue)MarshalHelper.ByteToStruct(data, i * 84 + 28, mv.GetType(), 84);
nYear = mv.year; nMonth = mv.month; nDay = mv.day; nHour = mv.hour; nMinute = mv.minute; nSecond = mv.second;
DateTime dateTime = new DateTime(mv.year, mv.month, mv.day, mv.hour, mv.minute, mv.second);
//PrintHelper.Info("CH-{0:D2} 数据{1} -- {2} ", channeld, i + 1, dateTime.ToString("yyyy-MM-dd HH:mm:ss"));
bool IsExists = amv.MeasuredList.Exists(x => x.year == mv.year && x.month == mv.month &&
x.day == mv.day && x.hour == mv.hour && x.minute == mv.minute && x.second == mv.second);
if (!IsExists)
{
amv.MeasuredList.Add(mv);
}
}
}
catch (Exception ex)
{
//LogHelper.Error(System.Reflection.MethodBase.GetCurrentMethod(), ex.Message);
return(null);
}
return(amv);
}
private void TransferQueueToDatebase(string messageQueuePath)
{
try
{
var simpleMessageQueueWrapper = new SimpleMessageQueueWrapper <IDictionary <string, object> >();
simpleMessageQueueWrapper.Initialize(messageQueuePath);
var dictionary = simpleMessageQueueWrapper.Peek();
int num = 500;
while (dictionary != null && num-- >= 0)
{
IEnumerable <string> source =
from key in dictionary.Keys
where key.Contains("MeasureTime")
select key;
string timeKeyName = source.FirstOrDefault <string>();
if (timeKeyName != null)
{
DateTime dateTime = (DateTime)dictionary[timeKeyName];
IEnumerable <string> enumerable =
from key in dictionary.Keys
where key != timeKeyName
select key;
foreach (string current in enumerable)
{
MeasuredValue measuredValue = new MeasuredValue();
measuredValue.Name = current;
measuredValue.Quality = OPCQuality.Good;
measuredValue.TimeStamp = (DateTime)dictionary[timeKeyName];
measuredValue.Description = "";
measuredValue.Value = dictionary[current];
if (measuredValue.Value is long)
{
measuredValue.Value = Convert.ToInt32(measuredValue.Value.ToString());
}
_Logger.DebugFormat("save to local DB: {0}", measuredValue);
ValueTableWriter.SaveValueWhenConditionsAreMet(measuredValue, _CompressionConditionManager.GetConfigFor(current));
}
dictionary = simpleMessageQueueWrapper.Receive();
}
else
{
_Logger.Error("cannot find a 'MeasureTime' in the message directory. Send message to ErrorQueue");
_ErrorQueue.Send(dictionary);
dictionary = simpleMessageQueueWrapper.Receive();
}
dictionary = simpleMessageQueueWrapper.Peek();
}
ValueTableWriter.TransferDataToDestDB();
}
catch (Exception ex)
{
_Logger.Error(ex.Message, ex);
}
}
public void WhenISubstractTheTwoValues()
{
try
{
_result = _values[0] - _values[1];
}
catch (UnitsOfMeasurementMismatchException ex)
{
_exception = ex;
}
}
private void extractTravelTimesFromSiteMeasurements(SiteMeasurements siteMeasurements)
{
String anprRouteId = siteMeasurements.measurementSiteReference.id;
// Should only be one travel time value per SiteMeasurements
// element (index=0)
MeasuredValue value = siteMeasurements.measuredValue[0].measuredValue;
if (value.basicData.GetType() == typeof(TravelTimeData))
{
TravelTimeData ttData = (TravelTimeData)value.basicData;
log.Info("Travel Time for ANPR Route " + anprRouteId + " : " + ttData.travelTime.duration + "s");
}
}
public putDatex2DataResponse GetDeliverTMUTrafficDataResponse(D2LogicalModel request)
{
log.Info("NEW DeliverTMUTrafficDataRequest Received!");
if (!ExampleDataCheckOk(request))
{
throw new SoapException("Incoming request does not appear to be valid!", SoapException.ClientFaultCode);
}
MeasuredDataPublication measuredDataPublication = request.payloadPublication as MeasuredDataPublication;
if (measuredDataPublication != null)
{
SiteMeasurements[] siteMeasurementsArray = measuredDataPublication.siteMeasurements;
foreach (SiteMeasurements siteMeasurements in siteMeasurementsArray)
{
_SiteMeasurementsIndexMeasuredValue[] measuredValueArray = siteMeasurements.measuredValue;
foreach (_SiteMeasurementsIndexMeasuredValue siteMeasurementsIndexMeasuredValue in measuredValueArray)
{
MeasuredValue measuredValue = siteMeasurementsIndexMeasuredValue.measuredValue;
BasicData basicData = measuredValue.basicData;
if (basicData is TrafficFlow)
{
VehicleFlowValue value = ((TrafficFlow)basicData).vehicleFlow;
log.Info("Vehicle flow rate : " + value.vehicleFlowRate);
}
else if (basicData is TrafficSpeed)
{
float speed = ((TrafficSpeed)basicData).averageVehicleSpeed.speed;
log.Info("Traffic speed : " + speed);
}
else if (basicData is TrafficHeadway)
{
float headWay = ((TrafficHeadway)basicData).averageTimeHeadway.duration;
log.Info("Traffic Headway : " + headWay);
}
else if (basicData is TrafficConcentration)
{
float percentage = ((TrafficConcentration)basicData).occupancy.percentage;
log.Info("Traffic concentration percentage : " + percentage);
}
}
}
}
return(new putDatex2DataResponse {
d2LogicalModel = new D2LogicalModel()
});
}
async void GetMeasurementAndUpdateAsync()
{
Measurement measurement = await AirlyManager.GetNearestMeasurement();
Index caqi = measurement.indexes.Where(index => index.name == "AIRLY_CAQI").FirstOrDefault();
MeasuredValue valuePm25 = measurement.values.Where(value => value.name == "PM25").FirstOrDefault();
MeasuredValue valuePm10 = measurement.values.Where(value => value.name == "PM10").FirstOrDefault();
MeasuredValue valueHumidity = measurement.values.Where(value => value.name == "HUMIDITY").FirstOrDefault();
MeasuredValue valuePressure = measurement.values.Where(value => value.name == "PRESSURE").FirstOrDefault();
Standard standardPm10 = measurement.standards.Where(standard => standard.pollutant == "PM10").FirstOrDefault();
Standard standardPm25 = measurement.standards.Where(standard => standard.pollutant == "PM25").FirstOrDefault();
if (caqi != null)
{
CaqiValue = caqi.value.HasValue ? (int)caqi.value : 0;
CaqiTitle = caqi.description;
CaqiDescription = caqi.advice;
CaquiColor = caqi.color;
}
if (valuePm25 != null)
{
Pm25Value = valuePm25.value.HasValue ? (int)valuePm25.value : 0;
}
if (valuePm10 != null)
{
Pm10Value = valuePm10.value.HasValue ? (int)valuePm10.value : 0;
}
if (valueHumidity != null)
{
HumidityValue = valueHumidity.value.HasValue ? ((double)valueHumidity.value / 100d) : 0;
}
if (valuePressure != null)
{
PressureValue = valuePressure.value.HasValue ? (int)valuePressure.value : 1000;
}
if (standardPm25 != null)
{
Pm25Percent = standardPm25.percent.HasValue ? (int)standardPm25.percent : 0;
}
if (standardPm10 != null)
{
Pm10Percent = standardPm10.percent.HasValue ? (int)standardPm10.percent : 0;
}
}
public void GetConnectionCheck()
{
var now = DateTime.Now;
var mv = new MeasuredValue()
{
Name = "",
Description = "meine beschreibung",
TimeStamp = now,
Value = "test",
Quality = OPCQuality.NoValue
};
int affectedRows = ValueTableWriter.SaveValueWhenConditionsAreMet(mv, CompressionCondition.GetDefaultCondition());
Assert.AreEqual(0, affectedRows);
//ValueTableWriter valueTable = new ValueTableWriter();
//MeasuredValue mv = valueTable.ReadLastMeasuredValueFromLocalDB("test", TypeCode.Double);
//Assert.AreEqual(OPCQuality.NoValue, mv.Quality);
}
/// <summary>
/// Validate the value for a Content Item with Value Type Num.
/// </summary>
/// <param name="contentItemWithValueTypeNum">The Content Item.</param>
private void ValidateValue(ContentItemWithValueTypeNum contentItemWithValueTypeNum)
{
//
// Validate the Measured Value.
//
MeasuredValue measuredValue = contentItemWithValueTypeNum.MeasuredValue;
if (measuredValue != null)
{
ConceptCode measurementUnits = measuredValue.MeasurementUnits;
if (measurementUnits == null)
{
contentItemWithValueTypeNum.ValidationResults.Add(new ValidationResult("Sequence Item encoding the Measurement Units does not exist."));
}
else
{
if (measurementUnits.CodingSchemeDesignator != "UCUM")
{
measurementUnits.ValidationResults.Add(new ValidationResult("Coding Scheme Designator is not equal to UCUM."));
}
if (!Dvtk.Ucum.Tools.IsValidTerm(measurementUnits.CodeValue, true, false))
{
measurementUnits.ValidationResults.Add(new ValidationResult("Code Value does not contain a valid Units of Measurement."));
}
}
}
//
// Validate the Numeric Value qualifier.
//
ConceptCode numericValueQualifier = contentItemWithValueTypeNum.NumericValueQualifier;
if (numericValueQualifier != null)
{
this.conceptCodeValidationRule.ValidateUsingContextGroup("42", numericValueQualifier);
}
}
public void InsertIntoIntTable()
{
DateTime now = DateTime.Now;
string tagName = "MyMeasuredValue";
int tagValue = 12345678;
string remark = "Bla Bla";
int count = ValueTableWriter.SaveValueWhenConditionsAreMet(
new MeasuredValue()
{
Name = tagName,
TimeStamp = now,
Quality = OPCQuality.Good,
Value = tagValue,
Description = remark
}, CompressionCondition.GetNoCompressionCondition());
Assert.AreEqual(1, count);
count = ValueTableWriter.SaveValueWhenConditionsAreMet(
new MeasuredValue()
{
Name = tagName,
TimeStamp = now + new TimeSpan(0, 0, 0, 1, 1),
Quality = OPCQuality.Good,
Value = tagValue,
Description = remark
}, CompressionCondition.GetDefaultCondition());
Assert.AreEqual(0, count);
MeasuredValue mv = ValueTableWriter.ReadLastMeasuredValueFromLocalDB("MyMeasuredValue", TypeCode.Int32);
Assert.AreEqual(tagName, mv.Name);
TimeSpan sp = now - mv.TimeStamp;
// Datenbankgenauigkeit ist bei Datum nicht hoch genug
Assert.Greater(0.1, sp.TotalSeconds);
Assert.AreEqual(tagValue, mv.Value);
Assert.AreEqual(OPCQuality.Good, mv.Quality);
Assert.AreEqual(remark, mv.Description);
}
internal static async Task <DeviceMeasuredValues> GetMeasuredValuesAsync(string deviceId, string date, string?sensorType)
{
InitClient();
var device = new DeviceMeasuredValues
{
Name = deviceId
};
CloudBlobContainer container = await GetContainerAsync(_Client);
BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(string.Empty, true, BlobListingDetails.Metadata, null, null, null, null);
if (!CheckIfDeviceIdExist(resultSegment, deviceId))
{
device.Name = "DeviceId does not exist";
return(device);
}
List <string> sensorTypes = GetSensorTypesForDevice(resultSegment, deviceId);
if (sensorType != null && !sensorTypes.Contains(sensorType))
{
device.Name = "SensorType does not exist";
return(device);
}
List <string> selectedSensorTypes = sensorType != null ? new List <string> {
sensorType
} : sensorTypes;
List <MeasuredValue> allSensorValues = new List <MeasuredValue>();
List <Task <List <MeasuredValue> > > tasks = new List <Task <List <MeasuredValue> > >();
foreach (var sensor in selectedSensorTypes)
{
Task <List <MeasuredValue> > theTask = GetSensorFileAsync(container, deviceId, date, sensor);
tasks.Add(theTask);
}
await Task.WhenAll(tasks);
foreach (var task in tasks)
{
List <MeasuredValue> sensorFile = task.Result;
if (task == tasks.First())
{
allSensorValues = sensorFile;
}
else
{
allSensorValues = allSensorValues.Zip(sensorFile, (first, second) =>
{
MeasuredValue mv = first;
mv.SensorValues.Add(second.SensorValues[0]);
return(mv);
}).ToList();
}
}
if (allSensorValues.Count == 0)
{
device.Name = "No data found that date";
}
device.MeasuredValues = allSensorValues;
return(device);
}
private void HandingOffsetCorrectionValues(ref ModbusIpMaster master)
{
if (master == null)
{
Logger.WriteDebugLog("Getting Null for ModbusIpMaster object master. Exiting From HandingOffsetCorrectionValues()");
return;
}
ushort[] ReadDataFlag;
ushort[] Output;
int SlNo;
int PartID;
int OperationID;
int Dimension;
int IterationCount;
float MeanVal;
float LambdaVal;
float LVal;
float SigmaVal;
float MeasuredValue;
float EWMAVal;
float LCLVal;
float UCLVal;
float CorrectionValue;
float MaxCorrectionStep;
DateTime MeasuredDateTime;
try
{
ReadDataFlag = master.ReadHoldingRegisters(HoldingRegForReadDataFlag, (ushort)1);
if (ReadDataFlag[0] == 1)
{
Logger.WriteDebugLog("Read Flag (606) is High");
Output = master.ReadHoldingRegisters(HoldingRegForSerialNo, (ushort)1);
SlNo = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegForPartID, (ushort)1);
PartID = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegForDimension, (ushort)1);
Dimension = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegForOperationID, (ushort)1);
OperationID = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegisterForIterationCount, (ushort)1);
IterationCount = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegForMean, (ushort)2);
MeanVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForLambda, (ushort)2);
LambdaVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForL, (ushort)2);
LVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForSigma, (ushort)2);
SigmaVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForMeasuredVal, (ushort)2);
MeasuredValue = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForEWMA, (ushort)2);
EWMAVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForLCL, (ushort)2);
LCLVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForUCL, (ushort)2);
UCLVal = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForCorrectionVal, (ushort)2);
CorrectionValue = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForMaxCorrectionStep, (ushort)2);
MaxCorrectionStep = GetFloat(Output);
Output = master.ReadHoldingRegisters(HoldingRegForNGComponent, (ushort)1);
int ngComponent = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegForAltCorrecting, (ushort)1);
int altCorrection = Output[0];
Output = master.ReadHoldingRegisters(HoldingRegForMeasuredDate, (ushort)2);
string MeasuredDate = ModbusUtility.GetUInt32(Output[1], Output[0]).ToString("00000000");
Output = master.ReadHoldingRegisters(HoldingRegForMeasuredTime, (ushort)2);
string MeasuredTime = ModbusUtility.GetUInt32(Output[1], Output[0]).ToString("000000");
MeasuredDateTime = DateTime.ParseExact(string.Format("{0}{1}", MeasuredDate, MeasuredTime), "yyyyMMddHHmmss", null);
Logger.WriteDebugLog(string.Format("Data Received : MC-{0} PartID-{1} Operation-{2} Operator-{3} Dimension-{4} Mean-{5} Lambda-{6} L-{7} Sigma-{8} Measured Value-{9} EWMA-{10} LCL-{11} UCL-{12} Correction Value-{13} Max Correction Step-{14} Measured DateTime-{15} Iteration Count-{16}", this._interfaceId, PartID, OperationID, "1", Dimension, MeanVal.ToString("00.0000"), LambdaVal.ToString("00.0000"), LVal.ToString("00.0000"), SigmaVal.ToString("00.0000"), MeasuredValue.ToString("00.0000"), EWMAVal.ToString("00.0000"), LCLVal.ToString("00.0000"), UCLVal.ToString("00.0000"), CorrectionValue.ToString("00.0000"), MaxCorrectionStep.ToString("00.0000"), MeasuredDateTime.ToString("dd-MMM-yyyy HH:mm:ss"), IterationCount));
DatabaseAccess.InsertDataToSPCAutoData(this._interfaceId, PartID, OperationID, "1", Dimension, MeanVal, LambdaVal, LVal, SigmaVal, MeasuredValue, EWMAVal, LCLVal, UCLVal, CorrectionValue, MaxCorrectionStep, MeasuredDateTime, IterationCount, ngComponent, altCorrection);
master.WriteSingleRegister(HoldingRegForACK, (ushort)SlNo);
master.WriteSingleRegister(HoldingRegForReadDataFlag, (ushort)2);
Logger.WriteDebugLog("Read Flag (606) is set to Low");
}
#region Communication
//send communicationNo
try
{
master.WriteSingleRegister(HoldingRegisterForCommunictaion, commNo);
}
catch (Exception ex)
{
if (master != null)
{
master.Dispose();
}
Logger.WriteErrorLog(ex.ToString());
}
if (commNo == 100)
{
commNo = 200;
}
else
{
commNo = 100;
}
#endregion
}
catch (Exception ex)
{
Logger.WriteErrorLog("Exception In HandingOffsetCorrectionValues() : " + ex.Message);
}
}
public putDatex2DataResponse GetDeliverMidasTrafficDataResponse(D2LogicalModel deliverMIDASTrafficDataRequest)
{
log.Info("New DeliverMIDASTrafficDataRequest received.");
MeasuredDataPublication measuredDataPublication = null;
// Validate the D2Logical Model
if (!ExampleDataCheckOk(deliverMIDASTrafficDataRequest))
{
throw new SoapException("Incoming request does not appear to be valid!", SoapException.ClientFaultCode);
}
// MeasuredDataPublication class contains the feed description, feed
// type, site measurements, publication time and other header information.
try
{
measuredDataPublication = deliverMIDASTrafficDataRequest.payloadPublication as MeasuredDataPublication;
if (measuredDataPublication != null && measuredDataPublication.headerInformation != null)
{
// Eash MIDAS site is encapsulated within a SiteMeasurements object.
// Cycle through these to get to the sensor readings for a MIDAS site.
foreach (SiteMeasurements siteMeasurement in measuredDataPublication.siteMeasurements)
{
log.Debug("measurementDataPublication ID is " + siteMeasurement.measurementSiteReference.id);
log.Debug("measurementDataPublication time default is " + siteMeasurement.measurementTimeDefault.ToString());
// Cycle through the MeasuredValues to get the individual sensor readings for a MIDAS site.
foreach (_SiteMeasurementsIndexMeasuredValue singleMeasuredValue in siteMeasurement.measuredValue)
{
int index = singleMeasuredValue.index;
// Each sensor reading has an index. This represents the lane number the sensor reading is for.
// On retrieving the index, you can use getLaneNumberFromTrafficDataIndex to get the lane number.
int laneNumber = GetLaneNumberFromTrafficDataIndex(index);
log.Debug("lane number is " + laneNumber);
// To determine what type the sensore reading is, cast the basic data value to the appropriate
// type and retrieve the value of interest.
MeasuredValue mv = singleMeasuredValue.measuredValue;
BasicData basicData = mv.basicData;
if (basicData is TrafficFlow)
{
// For a lane, TrafficFlow will appear 4 times. i.e.
// flow1, flow2 ... flow4. It will appear in order.
}
else if (basicData is TrafficSpeed)
{
// Now you have TrafficSpeed. Cast it appropriately
// to retrieve values you are interested in.
}
else if (basicData is TrafficHeadway)
{
// Now you have TrafficHeadway. Cast it appropriately
// to retrieve values you are interested in.
}
else if (basicData is TrafficConcentration)
{
// Now you have TrafficConcentration. Cast it
// appropriately to retrieve values you are
// interested in.
}
}
}
// You can convert the site measurements to you model objects
// and subsequently persist/manipulate your model objects.
List <TrafficData> trafficData = ConvertToModelObjects(measuredDataPublication.siteMeasurements.ToList());
}
}
catch (Exception e)
{
log.Error("Error while obtaining MeasuredDataPublication.");
log.Error(e.Message);
throw new SoapException("Error while obtaining MeasuredDataPublication.", SoapException.ServerFaultCode, e);
}
return(new putDatex2DataResponse {
d2LogicalModel = new D2LogicalModel()
});
}
public EmptyFrame(MeasuredValue time)
{
_time = time.In(SI.Second);
}
public void CheckMeasuredValueConverter()
{
string name = "TestName";
string value = "Text";
DateTime dt = DateTime.Now;
MeasuredValue mv = MeasuredValueConverter.ConvertTo(name, dt, value, TypeCode.String);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(value, mv.Value);
Assert.AreEqual(TypeCode.String, mv.GetTypeCode());
TypeCode tc = TypeCode.Int16;
short shortValue = 100;
value = shortValue.ToString();
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(shortValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
tc = TypeCode.Int32;
int intValue = 110;
value = intValue.ToString();
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(intValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
tc = TypeCode.Int64;
long longValue = 120;
value = longValue.ToString();
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(longValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
tc = TypeCode.Single;
float floatValue = 1002.2f;
value = floatValue.ToString(System.Globalization.CultureInfo.InvariantCulture);
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(floatValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
tc = TypeCode.Double;
double doubleValue = 2002.2;
value = doubleValue.ToString(System.Globalization.CultureInfo.InvariantCulture);
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(doubleValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
value = doubleValue.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("de"));
MeasuredValueConverter.UsedCultureInfo = System.Globalization.CultureInfo.CreateSpecificCulture("de");
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(doubleValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
MeasuredValueConverter.UsedCultureInfo = System.Globalization.CultureInfo.InvariantCulture;
tc = TypeCode.Boolean;
bool boolValue = true;
value = boolValue.ToString();
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(name, mv.Name);
Assert.AreEqual(dt, mv.TimeStamp);
Assert.AreEqual(boolValue, mv.Value);
Assert.AreEqual(tc, mv.GetTypeCode());
Assert.AreEqual(OPCQuality.Good, mv.Quality);
value = "True";
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(boolValue, mv.Value);
Assert.AreEqual(OPCQuality.Good, mv.Quality);
value = "TRUE";
mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
Assert.AreEqual(boolValue, mv.Value);
Assert.AreEqual(OPCQuality.Good, mv.Quality);
}
public void CheckMeasuredValueConverterException()
{
MeasuredValue mv = MeasuredValueConverter.ConvertTo("name", DateTime.Now, null, TypeCode.Empty);
}
public void WhenIDivideTheTwoValues()
{
_result = _values[0] / _values[1];
}
public void WhenIMultiplyTheTwoValues()
{
_result = _values[0] * _values[1];
}
