public IEnumerable <MeasureViewModel> Read(SensorTypeEnum sensorType, int currentProductionUnitId)
{
IList <MeasureViewModel> result = new List <MeasureViewModel>();
var fewDaysAgo = DateTime.Now.AddDays(-4);
result = entities.Measures.OrderByDescending(m => m.captureDate)
.Where(m => m.sensor.Id == (int)sensorType && m.productionUnit.Id == currentProductionUnitId && m.captureDate > fewDaysAgo)
.Select(meas => new MeasureViewModel
{
Id = meas.Id,
captureDate = meas.captureDate,
value = meas.value,
sensorId = meas.sensor.Id,
sensor = new SensorTypeViewModel()
{
Id = meas.sensor.Id,
name = meas.sensor.name
},
productionUnitId = meas.productionUnit.Id,
productionUnit = new ProductionUnitViewModel()
{
Id = meas.productionUnit.Id,
info = meas.productionUnit.info,
locationLatitude = meas.productionUnit.locationLatitude,
locationLongitude = meas.productionUnit.locationLongitude
},
}).ToList();
return(result);
}
public Sensor(int sensorID, SensorTypeEnum type, AlarmState state, string value)
{
this.sensorID = sensorID;
this.type = type;
this.state = state;
this.value = value;
}
public async Task <Decimal> GetLastMesure(SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
var rslt = await(from m in db.Measures.Include(m => m.sensor)
.Where(m => m.sensor.Id == (int)sensorType)
.OrderByDescending(m => m.Id)
select m).FirstOrDefaultAsync();
if (rslt != null)
{
if (sensorType == SensorTypeEnum.humidity)
{
return(Math.Round(rslt.value, 0));
}
else
{
return(Math.Round(rslt.value, 1));
}
}
else
{
return(0);
}
}
}
public async Task <List <Measure> > GetLastWeeksMesures(SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
return(await(from m in db.Measures.OrderByDescending(m => m.captureDate).Include(m => m.sensor).Take(7 * 24 * 6 * 4)
select m).Where(m => m.sensor.Id == (int)sensorType).ToListAsync());
}
}
public static SensorValueSet GetSensorValueSet(int currentProductionUnitId, SensorTypeEnum sensor, ApplicationDbContext db)
{
var currentValue = 0M;
var averageHourValue = 0M;
var averageDayValue = 0M;
var currentCaptureTime = String.Empty;
var lastDayCaptureTime = String.Empty;
var lastValue = db.Measures.Where(m => m.productionUnit.Id == currentProductionUnitId &&
m.sensor.Id == (int)sensor)
.OrderByDescending(m => m.captureDate).FirstOrDefault();
if (lastValue != null)
{
TimeZoneInfo rst = TimeZoneInfo.FindSystemTimeZoneById("Romance Standard Time");
currentCaptureTime = TimeZoneInfo.ConvertTimeFromUtc(lastValue.captureDate, rst).ToShortTimeString();
currentValue = lastValue.value;
var lastHour = lastValue.captureDate.AddHours(-1);
var averageHourValueRslt = db.Measures.Where(m => m.productionUnit.Id == currentProductionUnitId &&
m.sensor.Id == (int)sensor &&
m.captureDate >= lastHour)
.OrderByDescending(m => m.captureDate);
averageHourValue = Math.Round(averageHourValueRslt.Average(m => m.value), 1);
var lastDay = lastValue.captureDate.AddDays(-1);
lastDayCaptureTime = lastDay.ToShortDateString();
var averageDayValueRslt = db.Measures.Where(m => m.productionUnit.Id == currentProductionUnitId &&
m.sensor.Id == (int)sensor &&
m.captureDate >= lastDay)
.OrderByDescending(m => m.captureDate);
averageDayValue = Math.Round(averageDayValueRslt.Average(m => m.value), 1);
return(new SensorValueSet()
{
CurrentValue = currentValue,
CurrentCaptureTime = currentCaptureTime,
AverageHourValue = averageHourValue,
AverageDayValue = averageDayValue,
LastDayCaptureTime = lastDayCaptureTime
});
}
return(new SensorValueSet()
{
CurrentValue = 0,
CurrentCaptureTime = "-",
AverageHourValue = 0,
AverageDayValue = 0,
LastDayCaptureTime = "-"
});
}
public decimal RecordSensorsMeasure(SensorTypeEnum sensorType, bool isSleepModeActivated)
{
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
StringBuilder strResult = new StringBuilder();
decimal sumCapturedMesure = 0;
//if (isSleepModeActivated)
//{
// var taskWakeUp = Task.Run(async () =>
// {
// await WriteAsync(wakeupCommand, currentSensor);
// await Task.Delay(1000);
// });
// taskWakeUp.Wait();
//}
for (int i = 0; i < 4; i++)
{
Task.Run(async() =>
{
var str = await SendCommand(currentSensor.currentSerialPort, readValueCommand);
strResult.Append(str);
}).Wait();
decimal capturedMesure = 0;
var boolMeasure = Decimal.TryParse(strResult.ToString().Replace("\r", "")
.Replace(answersSleepMode, "")
.Replace(answersWakeUpMode, "")
, out capturedMesure);
sumCapturedMesure += capturedMesure;
strResult.Clear();
}
//if (isSleepModeActivated)
//{
// var taskSleep = Task.Run(async () =>
// {
// await WriteAsync(sleepModeCommand, currentSensor);
// });
// taskSleep.Wait();
//}
return(sumCapturedMesure / 4);
}
return(0);
}
public async Task <List <Measure> > GetLastTwoMonthsMesures(SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
return(await(from m in db.Measures.Include(m => m.sensor).Where(m => m.sensor.Id == (int)sensorType).Take(7 * 30 * 2)
group m by new { m.captureDate.Year, m.captureDate.DayOfYear } into groupedDay
select new Measure
{
captureDate = groupedDay.FirstOrDefault().captureDate,
value = groupedDay.Average(x => x.value),
}).ToListAsync());
}
}
public SensorConfiguration(SensorTypeEnum sensorType, SensorMeasurementTypeEnum measurementType)
{
ReadPipe = new ReadPipeConfiguration
{
SensorType = sensorType,
MeasurementType = measurementType
};
AnalyticsPipe = new AnalyticsPipeConfiguration();
RulesPipe = new RulesPipeConfiguration();
WindowPipe = new WindowPipeConfiguration();
FilterPipe = new FilterPipeConfiguration();
SendPipe = new SendPipeConfiguration();
}
public decimal RecordSensorsMeasure(SensorTypeEnum sensorType, bool isSleepModeActivated)
{
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
decimal capturedMesure = 0;
string strResult = String.Empty;
//if (isSleepModeActivated)
//{
// var taskWakeUp = Task.Run(async () =>
// {
// await WriteAsync(wakeupCommand, currentSensor);
// await Task.Delay(1000);
// });
// taskWakeUp.Wait();
//}
var taskMeasure = Task.Run(async() => {
await WriteAsync(readValueCommand, currentSensor)
.ContinueWith((a) => strResult = ReadAsync(ReadCancellationTokenSource.Token, currentSensor).Result);
var boolMeasure = Decimal.TryParse(strResult.Replace("\r", "")
.Replace(answersSleepMode, "")
.Replace(answersWakeUpMode, "")
, out capturedMesure);
});
taskMeasure.Wait();
//if (isSleepModeActivated)
//{
// var taskSleep = Task.Run(async () =>
// {
// await WriteAsync(sleepModeCommand, currentSensor);
// });
// taskSleep.Wait();
//}
return(capturedMesure);
}
return(0);
}
public async Task <String> GetLastCalibrationDate(SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
var currentDateTime = await(from m in db.SensorTypes where m.Id == (int)sensorType select m.lastCalibration).FirstOrDefaultAsync();
if (currentDateTime.Value == null)
{
return("No yet calibrated");
}
else
{
return(currentDateTime.Value.ToString("d"));
}
}
}
public async Task <Decimal> GetLastDayAverageMesure(SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
if (await db.Measures.CountAsync() == 0)
{
return(0);
}
var rslt = await(from m in db.Measures.Include(m => m.sensor)
.Where(m => m.sensor.Id == (int)sensorType)
.OrderByDescending(m => m.Id)
select m).Take(6 * 24).AverageAsync(m => m.value);
return(Math.Round(rslt, 1));
}
}
public async Task <Decimal> GetYesterdayMesure(SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
if (await db.Measures.CountAsync() == 0)
{
return(0);
}
var rslt = await(from m in db.Measures.Include(m => m.sensor)
.Where(m => m.sensor.Id == (int)sensorType)
.OrderBy(m => m.Id)
select m.value).Take(6 * 24).FirstOrDefaultAsync();
return(Math.Round(rslt, 1));
}
}
public void ResetCalibration(SensorTypeEnum sensorType)
{
if (!isInitialized)
{
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
var tsk = Task.Run(async() =>
{
await SendCommand(currentSensor.currentSerialPort, clearCalibrationCommand);
});
tsk.Wait();
}
}
public string GetSensorStatus(SensorTypeEnum sensorType, bool isSleepModeActivated)
{
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strResult = String.Empty;
//if (isSleepModeActivated)
//{
// var taskWakeUp = Task.Run(async () =>
// {
// await WriteAsync(wakeupCommand, currentSensor);
// await Task.Delay(1000);
// });
// taskWakeUp.Wait();
//}
var taskStatus = Task.Run(async() => {
await WriteAsync(getStatusCommand, currentSensor)
.ContinueWith((a) => strResult = ReadAsync(ReadCancellationTokenSource.Token, currentSensor).Result);
});
taskStatus.Wait();
//if (isSleepModeActivated)
//{
// var taskSleep = Task.Run(async () =>
// {
// await WriteAsync(sleepModeCommand, currentSensor);
// });
// taskSleep.Wait();
//}
return(strResult);
}
return(string.Empty);
}
// Public Methods
public bool Add(SensorDesignatorEnum Designator, SensorTypeEnum SensorType)
{
if (_sensors.ContainsKey(Designator))
{
return(false);
}
switch (SensorType)
{
case SensorTypeEnum.Peak_80350A:
_sensors.Add(Designator, new PeakSensor80350AClass(_parentGigatronics854x, Designator, SensorTypeEnum.Peak_80350A));
break;
case SensorTypeEnum.Regular:
_sensors.Add(Designator, new SensorClass(_parentGigatronics854x, Designator, SensorTypeEnum.Regular));
break;
}
return(true);
}
public void SetCalibration(SensorTypeEnum sensorType, int calibrationValue)
{
if (!isInitialized)
{
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strQuery = String.Format(setCalibrationCommand, calibrationValue);
var taskCal = Task.Run(async() => {
await WriteAsync(strQuery, currentSensor);
});
taskCal.Wait();
}
}
public void ResetCalibration(SensorTypeEnum sensorType)
{
if (!isInitialized)
{
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strResult = String.Empty;
var taskCal = Task.Run(async() => {
await WriteAsync(clearCalibrationCommand, currentSensor);
});
taskCal.Wait();
}
}
public void SetCalibration(SensorTypeEnum sensorType, int calibrationValue)
{
if (!isInitialized)
{
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strQuery = String.Format(setCalibrationCommand, calibrationValue);
var tsk = Task.Run(async() =>
{
await SendCommand(currentSensor.currentSerialPort, strQuery);
});
tsk.Wait();
}
}
public async Task SetLastCalibrationDate(SensorTypeEnum sensorType, DateTime currentDate)
{
using (await asyncLock.LockAsync())
{
try
{
var currentSensorType = await(from m in db.SensorTypes where m.Id == (int)sensorType select m).FirstOrDefaultAsync();
if (currentSensorType != null)
{
currentSensorType.lastCalibration = currentDate;
await db.SaveChangesAsync();
}
}
catch (Exception ex)
{
logModel.AppendLog(Log.CreateErrorLog("Exception on Database - Set Last Calibration Date", ex));
}
}
}
public string GetSensorStatus(SensorTypeEnum sensorType, bool isSleepModeActivated)
{
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strResult = String.Empty;
//if (isSleepModeActivated)
//{
// var taskWakeUp = Task.Run(async () =>
// {
// await WriteAsync(wakeupCommand, currentSensor);
// await Task.Delay(1000);
// });
// taskWakeUp.Wait();
//}
var tsk = Task.Run(async() =>
{
strResult = await SendCommand(currentSensor.currentSerialPort, getStatusCommand);
});
tsk.Wait();
//if (isSleepModeActivated)
//{
// var taskSleep = Task.Run(async () =>
// {
// await WriteAsync(sleepModeCommand, currentSensor);
// });
// taskSleep.Wait();
//}
return(strResult);
}
return(string.Empty);
}
public void SetCalibration(SensorTypeEnum sensorType, CalibrationType calibrationType)
{
if (!isInitialized)
{
return;
}
var calibrationCommand = String.Empty;
switch (calibrationType)
{
case CalibrationType.Mid:
calibrationCommand = midCalibrationCommand;
break;
case CalibrationType.Low:
calibrationCommand = lowCalibrationCommand;
break;
case CalibrationType.High:
calibrationCommand = highCalibrationCommand;
break;
default:
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
string strResult = String.Empty;
var taskCal = Task.Run(async() => {
await WriteAsync(calibrationCommand, currentSensor);
});
taskCal.Wait();
}
}
public void SetCalibration(SensorTypeEnum sensorType, CalibrationType calibrationType)
{
if (!isInitialized)
{
return;
}
var calibrationCommand = String.Empty;
switch (calibrationType)
{
case CalibrationType.Mid:
calibrationCommand = midCalibrationCommand;
break;
case CalibrationType.Low:
calibrationCommand = lowCalibrationCommand;
break;
case CalibrationType.High:
calibrationCommand = highCalibrationCommand;
break;
default:
return;
}
var currentSensor = this.GetSensor(sensorType);
if (currentSensor != null)
{
var tsk = Task.Run(async() =>
{
await SendCommand(currentSensor.currentSerialPort, calibrationCommand);
});
tsk.Wait();
}
}
/// <summary>
/// Send The sensor data to the backend
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="sensorTypeEnum"></param>
/// <returns></returns>
public async Task <bool> SendSensorData <T>(Dictionary <long, T> data, SensorTypeEnum sensorTypeEnum)
{
SetUp();
var d = await CompressDataAsync(data);
httpClient.DefaultRequestHeaders.Remove("Accept-Encoding");
httpClient.DefaultRequestHeaders.Add("Accept-Encoding", "gzip");
httpClient.DefaultRequestHeaders.Add("DeviceId", App.DeviceId);
var sessionId = cache.Get <string>(Config.SessionDataKey);
httpClient.DefaultRequestHeaders.Add("SessionId", sessionId);
var byteContent = new ByteArrayContent(d.ToArray());
var t = d.ToArray().Length;
//Commented just for development purpose
var response = await httpClient.PostAsync(Config.DataPushUrl + sensorTypeEnum.ToString(), byteContent);
if (response.IsSuccessStatusCode)
{
return(true);
}
return(false);
}
public Sensor(int sensorID, SensorTypeEnum type, string value)
{
this.sensorID = sensorID;
this.type = type;
this.value = value;
}
public AtlasSensor GetSensor(SensorTypeEnum currentSensorType)
{
return(sensorsList.Where(s => s.sensorType == currentSensorType).FirstOrDefault());
}
public bool isSensorOnline(SensorTypeEnum currentSensorType)
{
return((sensorsList.Where(s => s.sensorType == currentSensorType).FirstOrDefault() != null) ? true : false);
}
public async Task <bool> AddMesure(DateTime currentDate, decimal capturedValue, SensorTypeEnum sensorType)
{
using (await asyncLock.LockAsync())
{
var task = Task.Run(async() =>
{
try
{
var currentSensor = db.SensorTypes.Where(s => s.Id == (int)sensorType).FirstOrDefault();
db.Measures.Add(new Measure()
{
value = capturedValue, captureDate = currentDate, sensor = currentSensor
});
await db.SaveChangesAsync();
}
catch (Exception ex)
{
logModel.AppendLog(Log.CreateErrorLog("Exception on Database - Add Mesure", ex));
}
});
task.Wait();
}
return(true);
}
// Constructor
internal PeakSensor80350AClass(Gigatronics854x ParentGigatronics854x, SensorDesignatorEnum Designator, SensorTypeEnum Type)
: base(ParentGigatronics854x, Designator, Type)
{
}
public IEnumerable <MeasureViewModel> Read(SensorTypeEnum sensorType, double productionUnitLat, double productionUnitLong)
{
return(GetAll().Where(m => m.sensorId == (int)sensorType &&
m.productionUnit.locationLatitude == productionUnitLat &&
m.productionUnit.locationLongitude == productionUnitLong).Take(24));
}
public IEnumerable <MeasureViewModel> Read(SensorTypeEnum sensorType, int currentProductionUnitId, string range)
{
IList <MeasureViewModel> result = new List <MeasureViewModel>();
var fewDaysAgo = DateTime.Now.AddDays(-6);
var aWeekAgo = DateTime.Now.AddDays(-14);
var threeMonthsAgo = DateTime.Now.AddDays(-90);
var selectedTimeFrame = new DateTime();
if (range == "thisLastDays" || range == null)
{
selectedTimeFrame = fewDaysAgo;
}
if (range == "thisWeek")
{
selectedTimeFrame = aWeekAgo;
}
if (range == "lastThreeMonths")
{
selectedTimeFrame = threeMonthsAgo;
}
if (range == "lastThreeMonths")
{
result = entities.Measures.OrderByDescending(m => m.captureDate)
.Where(m => m.sensor.Id == (int)sensorType && m.productionUnit.Id == currentProductionUnitId && m.captureDate > selectedTimeFrame && m.captureDate.Hour == 9 && m.captureDate.Minute < 15)
.Select(meas => new MeasureViewModel
{
Id = meas.Id,
captureDate = meas.captureDate,
value = meas.value,
sensorId = meas.sensor.Id,
sensor = new SensorTypeViewModel()
{
Id = meas.sensor.Id,
name = meas.sensor.name
},
productionUnitId = meas.productionUnit.Id,
productionUnit = new ProductionUnitViewModel()
{
Id = meas.productionUnit.Id,
info = meas.productionUnit.info,
locationLatitude = meas.productionUnit.locationLatitude,
locationLongitude = meas.productionUnit.locationLongitude
},
}).ToList();
}
else
{
result = entities.Measures.OrderByDescending(m => m.captureDate)
.Where(m => m.sensor.Id == (int)sensorType && m.productionUnit.Id == currentProductionUnitId && m.captureDate > selectedTimeFrame)
.Select(meas => new MeasureViewModel
{
Id = meas.Id,
captureDate = meas.captureDate,
value = meas.value,
sensorId = meas.sensor.Id,
sensor = new SensorTypeViewModel()
{
Id = meas.sensor.Id,
name = meas.sensor.name
},
productionUnitId = meas.productionUnit.Id,
productionUnit = new ProductionUnitViewModel()
{
Id = meas.productionUnit.Id,
info = meas.productionUnit.info,
locationLatitude = meas.productionUnit.locationLatitude,
locationLongitude = meas.productionUnit.locationLongitude
},
}).ToList();
}
return(result);
}
