// Fills in fault data from an array of PQDIF channels which contains
// exactly one voltage channel and exactly one current channel.
private static void FillFaultData(MeasurementData voltageData, MeasurementData currentData, ChannelInstance[] channels)
{
ChannelInstance voltageChannel;
ChannelInstance currentChannel;
SeriesInstance voltageTimeSeries;
SeriesInstance currentTimeSeries;
SeriesInstance voltageDataSeries;
SeriesInstance currentDataSeries;
// Split the collection of wave forms into separate voltage and current wave forms
voltageChannel = channels.SingleOrDefault(channel => channel.Definition.QuantityMeasured == QuantityMeasured.Voltage);
currentChannel = channels.SingleOrDefault(channel => channel.Definition.QuantityMeasured == QuantityMeasured.Current);
if ((object)voltageChannel != null && (object)currentChannel != null)
{
// Get series instances for time, voltage, and current
voltageTimeSeries = voltageChannel.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Time);
currentTimeSeries = currentChannel.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Time);
voltageDataSeries = voltageChannel.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Val);
currentDataSeries = currentChannel.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Val);
// Fill in fault data for each of the three series obtained above
voltageData.Times = ToTicks(voltageTimeSeries);
currentData.Times = ToTicks(currentTimeSeries);
voltageData.Measurements = voltageDataSeries.OriginalValues.Select(Convert.ToDouble).ToArray();
currentData.Measurements = currentDataSeries.OriginalValues.Select(Convert.ToDouble).ToArray();
}
}
public static MeasurementData Convert(IEnumerable <Measurement> measurements)
{
var data = new MeasurementData();
foreach (var measurement in measurements)
{
var m = new Contracts.DTO.Measurement {
Latitude = System.Convert.ToDouble(measurement.Latitude),
Longitude = System.Convert.ToDouble(measurement.Longitude),
PlatformTime = Timestamp.FromDateTime(measurement.PlatformTimestamp),
Timestamp = Timestamp.FromDateTime(measurement.Timestamp),
SensorID = measurement.SensorID.ToString(),
};
foreach (var(key, dp) in measurement.Data)
{
m.Datapoints.Add(new DataPoint {
Key = key,
Accuracy = dp.Accuracy ?? 0,
Precision = dp.Precision ?? 0,
Unit = dp.Unit,
Value = System.Convert.ToDouble(dp.Value)
});
}
data.Measurements.Add(m);
}
return(data);
}
public static MeasurementData getMeasurementAsData(Measurement measurement)
{
MeasurementData mData = new MeasurementData();
mData.ActivityName = measurement.ActivityName;
mData.expID = measurement.expID;
mData.id = measurement.id;
mData.isMainActivity = measurement.isMainActivity;
mData.RoomId = measurement.RoomId;
mData.NumOfMeasures = measurement.NumOfMeasures;
mData.DifferenceBetweenMeasures = measurement.DifferenceBetweenMeasures;
mData.NumOfParametersToMeasure = measurement.NumOfParametersToMeasure;
mData.WindowOpenTimeSeconds = measurement.WindowOpenTimeSeconds;
mData.experimentOrder = measurement.experimentOrder;
if (measurement.measurementInstructions != null)
{
foreach (MeasureInstruction mi in measurement.measurementInstructions)
{
mData.measurementInstructions.Add(getMeasureInstructionAsData(mi));
}
}
return(mData);
}
// GET: Student/Measurement
public ActionResult Measurement(long activityId, string studentPhone, long studentRoom, long expId, int currActivityIndex, int numOfActivities)
{
MeasurementData measurementData = (MeasurementData)rsContext.getActivity(activityId);
TempData["NumOfMeasures"] = measurementData.NumOfMeasures;
TempData["DifferenceBetweenMeasures"] = measurementData.DifferenceBetweenMeasures;
TempData["NumOfParametersToMeasure"] = measurementData.NumOfParametersToMeasure;
TempData["WindowOpenTimeSeconds"] = measurementData.WindowOpenTimeSeconds;
StudentData studentData = rsContext.getStudent(studentPhone, studentRoom);
TempData["GroupID"] = studentData.GroupID;
TempData["RoomID"] = studentData.RoomId;
TempData["ExpID"] = expId;
TempData["CurrActivityIndex"] = currActivityIndex;
TempData["StudentPhone"] = studentPhone;
TempData["currActivityIndex"] = currActivityIndex;
TempData["numOfActivities"] = numOfActivities;
// TODO pass the instructions to view
int i = 0;
foreach (MeasureInstructionData mi in measurementData.measurementInstructions)
{
TempData["Instruction" + i] = mi.MeasurementInstruction;
i++;
}
rsContext.SaveChanges();
if (currActivityIndex == 0) // first in exp activities
{
return(PartialView());
}
return(View());
}
public ActionResult StudentsProgress(ActiveExperiment ae, bool flag = false)
{
ActiveExperimentData aeData = Adapting.getActiveExperimentAsData(ae);
ExperimentData expData = (ExperimentData)rsContext.getActivity(ae.ExpID);
if (flag == false)
{
rsContext.addActiveExperiment(aeData);
}
expData.ActiveExpID = aeData.ActiveExpID;
ae.ActiveExpID = aeData.ActiveExpID;
rsContext.SaveChanges();
TempData["NumberOfExperimentSteps"] = expData.activities.Count;
TempData["DifferenceBetweenMeasures"] = 0;
TempData["NumOfMeasures"] = 0;
foreach (ActivityData act in expData.activities)
{
if (act is MeasurementData)
{
MeasurementData measurement = (MeasurementData)act;
TempData["DifferenceBetweenMeasures"] = measurement.DifferenceBetweenMeasures;
TempData["NumOfMeasures"] = measurement.NumOfMeasures;
}
}
return(View("StudentsProgress", ae));
}
private void DeleteSelected_Click(object sender, RoutedEventArgs e)
{
List <MeasurementLogEntry> entries = new List <MeasurementLogEntry>();
ProgressBar.Visibility = Visibility.Visible;
foreach (MeasurementLogEntry entry in context.MeasurementLogEntries)
{
CheckBox selectItem = null;
MeasurementLogGrid.SelectedItem = entry;
selectItem = MeasurementLogGrid.Columns[MeasurementLogGrid.Columns.Count - 1].GetCellContent(MeasurementLogGrid.SelectedItem) as CheckBox;
if (selectItem != null)
{
if (selectItem.IsChecked == true)
{
entries.Add(entry);
}
}
}
foreach (MeasurementLogEntry entry in entries)
{
context.MeasurementLogEntries.Remove(entry);
}
context.SubmitChanges((EntriesRemoved) =>
{
ProgressBar.Visibility = Visibility.Collapsed;
MeasurementData.Load();
}, null);
}
public void Start()
{
if (m_cancellationTokenSource != null)
return;
m_cancellationTokenSource = new CancellationTokenSource();
m_task = Task.Run(() =>
{
var weight = 1.00;
var second = m_lastSecond;
var speed = 0.0;
var acceleration = 0.0;
var random = new Random();
const int weightRange = 5;
while (!m_cancellationTokenSource.IsCancellationRequested)
{
var measurement = new MeasurementData(weight, second, speed, acceleration, DateTime.Now);
m_lastSecond = second;
second += Interval.TotalSeconds;
double timeDiff = (second - measurement.Second);
weight = random.NextDouble() * weightRange;
speed = (weight - measurement.Weight) / timeDiff;
acceleration = (speed - measurement.Speed) / timeDiff;
Thread.Sleep(Interval);
m_measurementReceived.OnNext(measurement);
}
}, m_cancellationTokenSource.Token);
}
public async Task FlushAsync()
{
MeasurementData measurements;
TextMessageData messages;
this.m_measurementLock.Lock();
this.m_messageLock.Lock();
try {
measurements = this.m_triggerMeasurements;
messages = this.m_triggerMessages;
this.m_gaugeTriggerSerivce.Set(0D);
this.m_triggerMeasurements = new MeasurementData();
this.m_triggerMessages = new TextMessageData();
} finally {
this.m_messageLock.Unlock();
this.m_measurementLock.Unlock();
}
await Task.WhenAll(
this.PublishData(this.m_messageTriggerTopic, messages),
this.PublishData(this.m_measurementTriggerTopic, measurements)
).ConfigureAwait(false);
}
public static IDictionary <ObjectId, List <Measurement> > Convert(MeasurementData measurements)
{
var results = new Dictionary <ObjectId, List <Measurement> >();
foreach (var measurement in measurements.Measurements)
{
if (!ObjectId.TryParse(measurement.SensorID, out var id))
{
continue;
}
var m = new Measurement {
Location = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(measurement.Longitude, measurement.Latitude)
),
PlatformTime = measurement.PlatformTime.ToDateTime(),
Timestamp = measurement.Timestamp.ToDateTime(),
Data = measurement.Datapoints.ToDictionary(x => x.Key, x => new DataPoint {
Value = System.Convert.ToDecimal(x.Value),
Accuracy = x.Accuracy,
Precision = x.Precision,
Unit = x.Unit
}),
};
results.TryAdd(id, new List <Measurement>());
results[id].Add(m);
}
return(results);
}
private static void GenerateApproxRandomProblem(string outputFolder)
{
var folder = @"C:\dev\GitHub\p9-data\large\fits\meerkat_tiny\";
Console.WriteLine("Generating approx random images");
var data = MeasurementData.LoadLMC(folder);
int gridSize = 3072;
int subgridsize = 32;
int kernelSize = 16;
int max_nr_timesteps = 1024;
double cellSize = 1.5 / 3600.0 * PI / 180.0;
int wLayerCount = 24;
var maxW = 0.0;
for (int i = 0; i < data.UVW.GetLength(0); i++)
{
for (int j = 0; j < data.UVW.GetLength(1); j++)
{
maxW = Math.Max(maxW, Math.Abs(data.UVW[i, j, 2]));
}
}
maxW = Partitioner.MetersToLambda(maxW, data.Frequencies[data.Frequencies.Length - 1]);
double wStep = maxW / (wLayerCount);
var c = new GriddingConstants(data.VisibilitiesCount, gridSize, subgridsize, kernelSize, max_nr_timesteps, (float)cellSize, wLayerCount, wStep);
var metadata = Partitioner.CreatePartition(c, data.UVW, data.Frequencies);
var psfVis = new Complex[data.UVW.GetLength(0), data.UVW.GetLength(1), data.Frequencies.Length];
for (int i = 0; i < data.Visibilities.GetLength(0); i++)
{
for (int j = 0; j < data.Visibilities.GetLength(1); j++)
{
for (int k = 0; k < data.Visibilities.GetLength(2); k++)
{
if (!data.Flags[i, j, k])
{
psfVis[i, j, k] = new Complex(1.0, 0);
}
else
{
psfVis[i, j, k] = new Complex(0, 0);
}
}
}
}
Console.WriteLine("gridding psf");
var psfGrid = IDG.GridW(c, metadata, psfVis, data.UVW, data.Frequencies);
var psf = FFT.WStackIFFTFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
Directory.CreateDirectory(outputFolder);
ReconstructRandom(data, c, psf, 1, 200, outputFolder + "/random__block1");
ReconstructRandom(data, c, psf, 8, 50, outputFolder + "/random_10k_block8");
}
/// <summary>
/// Creates a new instance of the <see cref="Conductor"/> class.
/// </summary>
/// <param name="cycleIndex">The index of the cycle to be calculated.</param>
/// <param name="sampleRateDivisor">The value to divide from the sample rate to determine the starting location of the cycle.</param>
/// <param name="frequency">The frequency of the sine wave during this cycle.</param>
/// <param name="voltageData">The voltage data points.</param>
/// <param name="currentData">The current data points.</param>
public Conductor(int cycleIndex, int sampleRateDivisor, double frequency, MeasurementData voltageData, MeasurementData currentData)
{
int vStart = cycleIndex * (voltageData.SampleRate / sampleRateDivisor);
int iStart = cycleIndex * (currentData.SampleRate / sampleRateDivisor);
V = new Cycle(vStart, frequency, voltageData);
I = new Cycle(iStart, frequency, currentData);
}
private static void RunNotAccelerated(MeasurementData input, GriddingConstants c, float[,] fullPsf, string outFolder)
{
var file = "TestNotAccelerated";
var currentFolder = Path.Combine(outFolder, "NotAccelerated");
Directory.CreateDirectory(currentFolder);
ReconstructMinorCycle(input, c, 32, fullPsf, currentFolder, file, 3, 0.1f, false);
}
private static void ReconstructRandom(MeasurementData input, GriddingConstants c, float[,] psf, int blockSize, int iterCount, string file)
{
var cutFactor = 8;
var totalSize = new Rectangle(0, 0, c.GridSize, c.GridSize);
var psfCut = PSF.Cut(psf, cutFactor);
var maxSidelobe = PSF.CalcMaxSidelobe(psf, cutFactor);
var maxLipschitzCut = PSF.CalcMaxLipschitz(psfCut);
var lambda = (float)(LAMBDA * PSF.CalcMaxLipschitz(psfCut));
var lambdaTrue = (float)(LAMBDA * PSF.CalcMaxLipschitz(psf));
var alpha = ALPHA;
ApproxFast.LAMBDA_TEST = lambdaTrue;
ApproxFast.ALPHA_TEST = alpha;
var metadata = Partitioner.CreatePartition(c, input.UVW, input.Frequencies);
var random = new Random(123);
var approx = new ApproxFast(totalSize, psfCut, 8, blockSize, 0.0f, 0.0f, false, true, false);
var bMapCalculator = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psfCut, totalSize), new Rectangle(0, 0, psfCut.GetLength(0), psfCut.GetLength(1)));
var data = new ApproxFast.TestingData(new StreamWriter(file + "_tmp.txt"));
var xImage = new float[c.GridSize, c.GridSize];
var xCorr = Copy(xImage);
var residualVis = input.Visibilities;
var dirtyGrid = IDG.GridW(c, metadata, residualVis, input.UVW, input.Frequencies);
var dirtyImage = FFT.WStackIFFTFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
var maxDirty = Residuals.GetMax(dirtyImage);
var bMap = bMapCalculator.Convolve(dirtyImage);
var maxB = Residuals.GetMax(bMap);
var correctionFactor = Math.Max(maxB / (maxDirty * maxLipschitzCut), 1.0f);
var currentSideLobe = maxB * maxSidelobe * correctionFactor;
var currentLambda = (float)Math.Max(currentSideLobe / alpha, lambda);
var gCorr = new float[c.GridSize, c.GridSize];
var shared = new ApproxFast.SharedData(currentLambda, alpha, 1, 1, 8, CountNonZero(psfCut), approx.psf2, approx.aMap, xImage, xCorr, bMap, gCorr, new Random());
shared.ActiveSet = ApproxFast.GetActiveSet(xImage, bMap, shared.YBlockSize, shared.XBlockSize, lambda, alpha, shared.AMap);
shared.BlockLock = new int[shared.ActiveSet.Count];
shared.maxLipschitz = (float)PSF.CalcMaxLipschitz(psfCut);
shared.MaxConcurrentIterations = 1000;
approx.DeconvolveConcurrentTest(data, 0, 0, 0.0, shared, 1, 1e-5f, Copy(xImage), dirtyImage, psfCut, psf);
var output = Tools.LMC.CutN132Remnant(xImage);
Tools.WriteToMeltCSV(output.Item1, file + "_1k.csv", output.Item2, output.Item3);
FitsIO.Write(output.Item1, file + "_1k.fits");
FitsIO.Write(xImage, file + "_1k2.fits");
approx.DeconvolveConcurrentTest(data, 0, 0, 0.0, shared, iterCount, 1e-5f, Copy(xImage), dirtyImage, psfCut, psf);
output = Tools.LMC.CutN132Remnant(xImage);
Tools.WriteToMeltCSV(output.Item1, file + "_10k.csv", output.Item2, output.Item3);
FitsIO.Write(output.Item1, file + "_10k.fits");
FitsIO.Write(xImage, file + "_10k2.fits");
}
private MeasurementData GetCustomMeasurementValue(SensorDevice sensorDevice, List <MeasurementData> measurements, CustomMeasurementRule rule)
{
var sensorMeasurement = measurements.FirstOrDefault(m => m.SensorId.Equals(rule.SensorId, StringComparison.OrdinalIgnoreCase) &&
m.SensorDeviceId.Equals(sensorDevice.Id, StringComparison.OrdinalIgnoreCase));
if (sensorMeasurement == null)
{
_logger.LogError($"No sensor '{rule.SensorId}' found from measurements of device type '{sensorDevice.SensorDeviceTypeId}'");
return(null);
}
var data = new MeasurementData()
{
SensorDeviceId = sensorDevice.Id, SensorId = rule.Id, Timestamp = DateTime.Now
};
var comparisonResult = LogicHelper.Compare(sensorMeasurement.Value, rule.Value, rule.Operator);
switch (rule.Type)
{
case Shared.Enum.ValueType.Default:
data.Value = comparisonResult ? "true" : "false";
break;
case Shared.Enum.ValueType.WasLast:
var keyName = $"{sensorDevice.Id}-{sensorMeasurement.SensorId}-{rule.Id}";
if (comparisonResult)
{
if (!_wasLastList.ContainsKey(keyName))
{
_wasLastList.Add(keyName, DateTime.Now);
}
else
{
_wasLastList[keyName] = DateTime.Now;
}
data.Value = "0";
}
else
{
if (_wasLastList.ContainsKey(keyName))
{
var ts = DateTime.Now - _wasLastList[keyName];
data.Value = ((int)ts.TotalSeconds).ToString();
}
else
{
data.Value = "-1";
}
}
break;
default:
break;
}
return(data);
}
private static MeasurementData GetMeasurementData()
{
if (options != null && !options.IncludeMeasurementData)
{
return(null);
}
XElement measurementDataElement = (from i in supplementalDataDocument.Elements("supplementalData")
.Elements("measurementData")
select i).FirstOrDefault();
if (measurementDataElement == null)
{
return(null);
}
Progress("Adding measurement data", String.Empty);
MeasurementData measurementData = new MeasurementData();
List <XElement> measurementSystemElements = measurementDataElement.Elements("measurementSystem").ToList();
if (measurementSystemElements.Count > 0)
{
List <RegionMeasurementSystem> minDaysCounts = new List <RegionMeasurementSystem>();
foreach (XElement measurementSystemElement in measurementSystemElements)
{
RegionMeasurementSystem regionMeasurementSystem = new RegionMeasurementSystem();
regionMeasurementSystem.MeasurementSystemId = measurementSystemElement.Attribute("type").Value.ToString();
regionMeasurementSystem.RegionIds = measurementSystemElement.Attribute("territories").Value.ToString().Split(' ');
minDaysCounts.Add(regionMeasurementSystem);
}
measurementData.MeasurementSystems = minDaysCounts.ToArray();
}
List <XElement> paperSizeElements = measurementDataElement.Elements("paperSize").ToList();
if (paperSizeElements.Count > 0)
{
List <RegionPaperSize> paperSizes = new List <RegionPaperSize>();
foreach (XElement paperSizeElement in paperSizeElements)
{
RegionPaperSize regionPaperSize = new RegionPaperSize();
regionPaperSize.PaperSizeId = paperSizeElement.Attribute("type").Value.ToString();
regionPaperSize.RegionIds = paperSizeElement.Attribute("territories").Value.ToString().Split(' ');
paperSizes.Add(regionPaperSize);
}
measurementData.PaperSizes = paperSizes.ToArray();
}
Progress("Added measurement data", string.Empty, ProgressEventType.Added, measurementData);
return(measurementData);
}
public ActionResult EditMeasurement(Measurement measurement)
{
ExperimentData experimentData = (ExperimentData)rsContext.getActivity(measurement.expID);
MeasurementData measurementData = Adapting.getMeasurementAsData(measurement);
measurementData.RoomId = 0;
measurementData.experimentOrder = experimentData.activities.Count;
experimentData.addStep(measurementData);
rsContext.SaveChanges();
return(RedirectToAction("AddInstructionsForMeasures", new { MeasurementID = measurementData.id, NumOfParametersToMeasure = measurementData.NumOfParametersToMeasure }));
}
public async Task <ActionResult> SubmitDataProcessing(MeasurementData data)
{
if (ModelState.IsValid)
{
bool submitted = await _pollingService.SubmitTabletProcessing(data);
return(new JsonResult(submitted));
}
return(StatusCode(500));
}
public MeasurementData GenerateMeasurementData(int count)
{
var data = new MeasurementData();
for (var idx = 0; idx < count; idx++)
{
data.Measurements.Add(this.GenerateMeasurement());
}
return(data);
}
public void Start()
{
if (m_cancellationTokenSource != null)
{
return;
}
m_cancellationTokenSource = new CancellationTokenSource();
if (Port == null)
{
Port = new SerialPort(Settings.DeviceName, Settings.BaudRate, Parity.None, 8, StopBits.One);
}
if (!Port.IsOpen)
{
Port.Open();
}
m_task = Task.Run(() =>
{
var second = m_lastSecond + 1;
var weight = 0.0;
var speed = 0.0;
var acceleration = 0.0;
var measurement = new MeasurementData(weight, m_lastSecond, speed, acceleration, DateTime.Now);
while (!m_cancellationTokenSource.IsCancellationRequested)
{
try
{
UpdateMeasurement(ref second, out weight, out speed, out acceleration, ref measurement);
}
catch (Exception ex)
{
Trace.Write(ex);
}
}
try
{
if (Port.IsOpen)
{
Port.Close();
}
}
catch (Exception ex)
{
Trace.Write(ex);
}
}, m_cancellationTokenSource.Token);
}
private static void RunSearchPercent(MeasurementData input, GriddingConstants c, float[,] fullPsf, string outFolder)
{
var searchPercent = new float[] { 0.01f, 0.05f, 0.1f, 0.2f, 0.4f, 0.6f, 0.8f };
foreach (var percent in searchPercent)
{
var file = "SearchPercent" + percent;
var currentFolder = Path.Combine(outFolder, "Search");
Directory.CreateDirectory(currentFolder);
ReconstructMinorCycle(input, c, 32, fullPsf, currentFolder, file, 3, percent, false);
}
}
private static void RunBlocksize(MeasurementData input, GriddingConstants c, float[,] fullPsf, string outFolder)
{
var blockTest = new int[] { 2, 4, 8 };
foreach (var block in blockTest)
{
var file = "block" + block;
var currentFolder = Path.Combine(outFolder, "BlockSize");
Directory.CreateDirectory(currentFolder);
ReconstructMinorCycle(input, c, 32, fullPsf, currentFolder, file, 3, 0.1f, true, block);
}
}
private static void RunPsfSize(MeasurementData input, GriddingConstants c, float[,] fullPsf, string outFolder)
{
var psfTest = new int[] { 4, 8, 16, 32, 64 };
foreach (var psfSize in psfTest)
{
var file = "PsfSize" + psfSize;
var currentFolder = Path.Combine(outFolder, "PsfSize");
Directory.CreateDirectory(currentFolder);
ReconstructMinorCycle(input, c, psfSize, fullPsf, currentFolder, file, 3, 0.1f, false);
}
}
public ActionResult SaveInstructionsForMeasurementsInDB(List <string> allInstructions, long MeasurementID)
{
MeasurementData measurementData = rsContext.getMeasurementByID(MeasurementID);
foreach (string instruction in allInstructions)
{
measurementData.AddInstruction(instruction);
}
rsContext.SaveChanges();
return(RedirectToAction("EditExperiment", new { ExpID = measurementData.expID }));
}
public void ToCsv(MeasurementData data, StringBuilder sb)
{
if (data == null)
{
return;
}
string time = data.Timestamp.ToString(" HH:mm:ss.fff", CultureInfo.InvariantCulture);
string date = data.Timestamp.ToShortDateString();
sb.AppendLine($"{data.Weight},{data.Second},{data.Speed},{data.Acceleration},{time},{date}");
}
public RemoteTriggerQueue(IOptions <QueueSettings> options, IInternalMqttClient client)
{
this.m_gaugeTriggerSerivce = Metrics.CreateGauge("router_trigger_messages_queued", "Number of messages in the trigger queue.");
this.m_triggerMeasurements = new MeasurementData();
this.m_triggerMessages = new TextMessageData();
this.m_measurementLock = new SpinLockWrapper();
this.m_messageLock = new SpinLockWrapper();
this.m_client = client;
this.m_messageTriggerTopic = options.Value.TriggerQueueTemplate.Replace("$type", "messages");
this.m_measurementTriggerTopic = options.Value.TriggerQueueTemplate.Replace("$type", "measurements");
}
private void RefreshLastMeasurementValue(MeasurementData data)
{
if (this.InvokeRequired)
{
Measurement.DataReceived dr = RefreshLastMeasurementValue;
this.Invoke(dr, new object[] { data });
}
else
{
chart1.Invalidate();
lblMeasurementLastValue.Text = data.ToString();
}
}
public async void AddMeasurement(PostMeasurementsVM measurementVM)
{
MeasurementData measurement;
measurement = new MeasurementData()
{
DataType = _dataTypesRepo.SearchBy(dt => dt.Name == measurementVM.DataTypeName).FirstOrDefault(),
Instalation = _instalationsRepo.SearchBy(i => i.Name == measurementVM.InstalationName).FirstOrDefault(),
Location = _locationsRepo.SearchBy(l => l.Name == measurementVM.LocationName).FirstOrDefault(),
MeasurmentDate = DateTime.UtcNow,
Value = double.Parse(measurementVM.Value.Replace('.', ','))
};
await _measurementsRepo.AddAsync(measurement);
}
public void AddChartPoint(MeasurementData data, string key)
{
if (this.InvokeRequired)
{
if (data == null)
{
return;
}
Measurement.AddChartPoint acp = AddChartPoint;
this.Invoke(acp, data, key);
}
else
{
chart1.Series[key].Points.AddXY(data.CreationTime.ToOADate(), data.Value);
}
}
private async Task SendBatchToRouterAsync(int start, int count, IList <Measurement> measurements)
{
var data = new MeasurementData();
for (var idx = start; idx < start + count; idx++)
{
var measurement = measurements[idx];
data.Measurements.Add(measurement);
}
var result = await this.m_router.RouteAsync(data, default).ConfigureAwait(false);
this.m_logger.LogInformation("Sent {inputCount} messages to the router. {outputCount} " +
"messages have been accepted. Router response ID: {responseID}.",
data.Measurements.Count, result.Count, new Guid(result.ResponseID.Span));
}
public Task <bool> SubmitTabletProcessing(MeasurementData data)
{
var tablet = context.Tablets.Find(data.TabletId);
var profile = context.Profiles.Find(data.TabletId);
var _data = context.Datas.Find(profile.ProfileId);
Array.ForEach(data.TabletData, profileData =>
{
var data = context.Datas.Add(new Models.Data
{
DataArray = profileData,
ProfileId = profile.ProfileId
});
});
return(Task.FromResult(context.SaveChanges() != -1));
}
/// <summary>
/// Creates a new instance of the <see cref="Conductor"/> class.
/// </summary>
/// <param name="cycleIndex">The index of the cycle to be calculated.</param>
/// <param name="sampleRateDivisor">The value to divide from the sample rate to determine the starting location of the cycle.</param>
/// <param name="frequency">The frequency of the sine wave during this cycle.</param>
/// <param name="voltageData">The voltage data points.</param>
/// <param name="currentData">The current data points.</param>
public Conductor(int cycleIndex, int sampleRateDivisor, double frequency, MeasurementData voltageData, MeasurementData currentData)
{
int vStart = cycleIndex * (voltageData.SampleRate / sampleRateDivisor);
int iStart = cycleIndex * (currentData.SampleRate / sampleRateDivisor);
V = new Cycle(vStart, frequency, voltageData);
I = new Cycle(iStart, frequency, currentData);
}
void _port_MsgMeasurementReceived(object sender, MeasurementData mdata)
{
var data = mdata.Clone();
int id = 0, linkID = 0;
// ID と 姿勢の対応
switch (mdata.node_no) {
default: { return; }
// 左腿
case 2: { id = 0; linkID = 1; } break;
// 左脛
case 3: { id = 1; linkID = 2; } break;
// 左足首
case 4: { id = 2; linkID = 3; } break;
// 右腿
case 5: { id = 3; linkID = 4; } break;
// 右脛
case 6: { id = 4; linkID = 5; } break;
// 右足首
case 7: { id = 5; linkID = 6; } break;
}
_estimator[id].SetMeasurement(data.acc, data.gyro, data.comp, data.time);
if (false) {
_kvm.SetOrientation(linkID, _estimator[id].Pose);
} else {
_kvm.SetOrientation(linkID, quaternionZero);
}
_kvm.Solve();
ModelDrawHelper.DrawModel(imuzDraw1, _kvm);
return;
}
