public SensorValues GetSensorValue(string deviceId)
{
SensorValues s = new SensorValues();
s.DeviceId = deviceId;
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
s.Pulse = getPulsevaluse();
sw.Stop();
s.Timewatch = sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L));
s.StatusDevice = "On";
return(s);
}
catch (Exception exc)
{
s.StatusDevice = "Error: " + exc.Message;
s.Pulse = "nd";
return(s);
}
finally
{ }
return(null);
}
/// <summary>
/// Get sensor's values.
/// </summary>
///
/// <param name="sensor">Sensor to get values of.</param>
/// <param name="sensorValues">etrieved sensor's values.</param>
///
/// <returns>Returns <b>true</b> if command was executed successfully or <b>false</b> otherwise.</returns>
///
public bool GetSensorValue(Sensor sensor, out SensorValues sensorValues)
{
byte[] command = new byte[3];
byte[] reply = new byte[16];
sensorValues = new SensorValues( );
// prepare message
command[0] = (byte)NXTCommandType.DirectCommand;
command[1] = (byte)NXTDirectCommand.GetInputValues;
command[2] = (byte)sensor;
if (SendCommand(command, reply))
{
sensorValues.IsValid = (reply[4] != 0);
sensorValues.IsCalibrated = (reply[5] != 0);
sensorValues.SensorType = (SensorType)reply[6];
sensorValues.SensorMode = (SensorMode)reply[7];
sensorValues.Raw = (ushort)(reply[8] | (reply[9] << 8));
sensorValues.Normalized = (ushort)(reply[10] | (reply[11] << 8));
sensorValues.Scaled = (short)(reply[12] | (reply[13] << 8));
sensorValues.Calibrated = (short)(reply[14] | (reply[15] << 8));
return(true);
}
return(false);
}
public async Task <SensorValues> AddSensorValuesAsync(SensorValues sensors)
{
var sensorsCollection = _database.GetCollection <SensorValues>("sensors");
await sensorsCollection.InsertOneAsync(sensors);
return(sensors);
}
public async Task <IActionResult> Post([FromBody] SensorsInput sensorsInput)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var sensors = new SensorValues()
{
//DeviceTimestamp = sensorsInput.DeviceTimestamp, // TODO change to DateTime
Temperature = sensorsInput.Temperature.Value,
Humidity = sensorsInput.Humidity.Value,
SoilMoisture = sensorsInput.SoilMoisture.Value
};
// save sensor values
await _sensorRepository.AddSensorValuesAsync(sensors);
var wateringResult = _wateringService.CalculateMilliseconds(sensors);
// TODO move to Watering Controller
if (wateringResult.Milliseconds > 0)
{
var watering = new WateringValue(sensors, wateringResult.Milliseconds);
await _wateringRepository.AddWateringAsync(watering);
}
return(CreatedAtAction("Get", new { id = sensors.Id }, wateringResult));
}
SensorValues GetSensorvalues()
{
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue("myPulseDevice");
pValue = Convert.ToDouble(sValues.Pulse);
this.timewatch = sValues.Timewatch;
return(sValues);
}
SensorValues GetSensorvalues()
{
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue("myFirstDevice");
tempValue = Convert.ToDouble(sValues.Temp);
this.timewatch = sValues.Timewatch;
return(sValues);
}
private SensorValuesModel getValuesModel(SensorValues values, ObjectId parentId)
{
var str_values = Newtonsoft.Json.JsonConvert.SerializeObject(values);
var obj_values = (JObject.Parse(str_values)).ToObject <SensorValuesModel>();
obj_values.sensorId = parentId;
return(obj_values);
}
public void Clear()
{
SensorValues.Clear();
MaxSensorValues.Clear();
NoiseOffsetValues.Clear();
rawSensorValues.Clear();
songAvgValues.Clear();
ModeValues.Clear();
}
double GetValue(double count)
{
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue("myPulseDevice");
this.timewatch = sValues.Timewatch;
pValue = Convert.ToDouble(sValues.Pulse);
return(pValue);
//return (Math.Sin((count / Divider) * 2.0 * Math.PI) + random.NextDouble() - 0.5) * 33;
}
private async void Receive_Timer_Tick(object state)
{
receiveTimer.Dispose();
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue("myFirstDevice");
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
});
}
public WateringResult CalculateMilliseconds(SensorValues sensors)
{
var wateringResult = new WateringResult();
if (sensors.SoilMoisture >= _appSettings.MinSoilMoisture)
{
// watering
wateringResult.Milliseconds = _appSettings.WateringMilliseconds;
}
return(wateringResult);
}
public void AddData(string sensorName, List <string> header, SensorValues newRecord)
{
prepareFs();
var sensorInfo = this.getSensorInfo(sensorName);
string str_values_line = valuesToString(newRecord);
string[] arr_values = { str_values_line };
int valuesLength = str_values_line.Length;
if (sensorInfo.ReadIndex == 0)
{
// sensorInfo.CsvHeader = header;
string str_header = headerToString(header);
string[] arr_header = { str_header };
int headerLength = str_header.Length;
var borders = new LineBorders()
{
StartPos = headerLength + 1,
EndPos = headerLength + 1 + valuesLength
};
lock (sensorInfo.fileLock)
{
// this will clear file - handy in development
File.Delete(sensorInfo.FileName);
File.AppendAllLines(sensorInfo.FileName, arr_header);
File.AppendAllLines(sensorInfo.FileName, arr_values);
sensorInfo.Lines.Add(borders);
}
}
else
{
var lastBorders = sensorInfo.getLastLine();
File.AppendAllLines(sensorInfo.FileName, arr_values);
var borders = new LineBorders()
{
StartPos = lastBorders.EndPos + 1,
EndPos = lastBorders.EndPos + 1 + valuesLength
};
sensorInfo.Lines.Add(borders);
}
sensorInfo.ReadIndex++;
}
public SensorResult NormalizeValue(SensorValues sensorValues)
{
if (!double.TryParse(sensorValues.RawValue, NumberStyles.Any, CultureInfo.InvariantCulture, out var temp))
{
throw new InvalidOperationException($"Can't parse double value '{sensorValues.RawValue}' for CustomTemperatureSensor");
}
return(new SensorResult
{
RawValue = sensorValues.RawValue,
Parameter = DeviceInfo.Parameter,
DeviceId = DeviceInfo.Id
});
}
public void Refresh()
{
for (int i = 0; i < NewPointsCount; i++)
{
SensorValues sValues = GetSensorvalues();
baseTime += sValues.Timewatch / baseTimeSelector;
points.RemoveAt(0);
// points.Add(new Point(count, GetValue(count)));
points.Add(new Point(baseTime, Convert.ToDouble(sValues.Pulse)));
IncreaseCount();
iter++;
}
OnDataChanged(ChartDataUpdateType.Reset, -1);
}
public void ReadADC()
{
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue(_deviceId);
sw.Stop();
double microseconds = sw.ElapsedTicks / (Stopwatch.Frequency / (1000L * 1000L));
// double ns = 1000000000.0 * (double)sw.ElapsedTicks / Stopwatch.Frequency;
sumTime += microseconds;
var task = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
textPlaceHolder.Text = sValues.Temp + " °C";
data.Add(
new Point
(
indexcount2++,
Convert.ToDouble(sValues.Temp)
));
indexcount2++;
txtTimeDiffMedio.Text = "Istant: " + Convert.ToString(sumTime / indexcount2) + " us";
txtTimeDiff.Text = "medio: " + microseconds + " us";
});
}
catch (Exception e)
{ StatusText.Text = e.Message; }
}
public SensorReaderEvent(
string serviceId,
string sensorName,
List <string> dataHeader,
int lastReadIndex,
SensorValues newData,
string ipAddress,
int listeningPort,
string customMessage = "")
: base(serviceId, ServiceType.SensorReader, customMessage)
{
SensorName = sensorName;
LastReadIndex = lastReadIndex;
IpAddress = ipAddress;
ListeningPort = listeningPort;
DataHeader = dataHeader;
NewData = newData;
}
private async void OnTimerTick(object sender, object e)
{
try
{
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue("myFirstDevice");
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
data.Add(
new Point
(
indexAwait++,
Convert.ToDouble(sValues.Temp)
));
});
}
catch (Exception ex)
{ StatusText.Text = ex.Message; }
}
public async Task TestSensorDataProcessing()
{
var clientRepository = _factory.Services.GetService <MqttClientRepository>();
byte[] actualBytes = null;
var deviceId = Guid.NewGuid();
var deviceClient = await clientRepository.Subscribe("data/microclimate", (s, bytes) =>
{
actualBytes = bytes;
return(Task.CompletedTask);
});
var deviceInfo = new DeviceInfo
{
DeviceCode = "CustomTemp",
Id = deviceId,
Parameter = ParameterType.TemperatureInside,
Type = DeviceType.Sensor
};
var sensorTemperature = 20.4d.ToString(CultureInfo.InvariantCulture);
var sensorValue = new SensorValues()
{
RawValue = sensorTemperature,
DeviceId = deviceId
};
await deviceClient.PublishAsync("data/device", deviceInfo);
await Task.Delay(1000);
await deviceClient.PublishAsync("data/sensors", sensorValue);
await Task.Delay(8000);
var actualMicroClimateParameter = actualBytes.DeserializeJsonBytes <MicroClimateParameterValue>();
Assert.Equal(actualMicroClimateParameter.ParameterType, deviceInfo.Parameter);
Assert.Equal(actualMicroClimateParameter.Value, sensorTemperature);
}
private async void StartProcess()
{
int indexcount = 0;
await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(2));
while (true)
{
Sensor s = new Sensor();
SensorValues sValues = s.GetSensorValue(_deviceId);
textPlaceHolder.Text = sValues.Temp + " °C";
data.Add(
new Point
(
indexcount++,
Convert.ToDouble(sValues.Temp)
));
await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(1));
}
}
private string valuesToString(SensorValues values)
{
return(JsonConvert.SerializeObject(values));
}
// interface implementation
public async Task <bool> AddToSensor(
string sensorName,
SensorValues newValues)
{
if (!await createConnection())
{
return(false);
}
string sensorsCollName = config.sensorsCollection;
string valuesCollName = config.sensorValuesCollection;
var sensorColl = database.GetCollection <SensorModel>(sensorsCollName);
try
{
SensorModel parentSensor = null;
var sensorCursor = await sensorColl.FindAsync <SensorModel>(
(record) => record.sensorName == sensorName);
await sensorCursor.MoveNextAsync();
if (sensorCursor.Current.Count() > 0)
{
parentSensor = sensorCursor.Current.First();
}
else
{
sensorCursor.Dispose();
parentSensor = new SensorModel(sensorName);
await sensorColl.InsertOneAsync(parentSensor);
}
var valuesModel = getValuesModel(newValues, parentSensor.id);
var valuesColl =
database.GetCollection <SensorValuesModel>(valuesCollName);
await valuesColl.InsertOneAsync(valuesModel);
}
catch (TimeoutException)
{
Console.WriteLine($"Failed to connect with the database on: "
+ $"{config.dbAddress} ... ");
return(false);
}
// var sensorFilter = Builders<SensorModel>
// .Filter
// .Eq(s => s.sensorName, sensorName);
// var update = Builders<SensorModel>
// .Update
// .Push<SensorValues>(s => s.records, newValues);
// UpdateResult addResult = null;
// try
// {
// addResult = await sensorColl.UpdateOneAsync(
// sensorFilter,
// update,
// new UpdateOptions { IsUpsert = true });
// }
// catch (TimeoutException)
// {
// Console.WriteLine($"Failed to connect with the database on: "
// + $"{config.dbAddress} ... ");
// return false;
// }
return(true);
}
/// <summary>
/// Get sensor's values.
/// </summary>
///
/// <param name="sensor">Sensor to get values of.</param>
/// <param name="sensorValues">etrieved sensor's values.</param>
///
/// <returns>Returns <b>true</b> if command was executed successfully or <b>false</b> otherwise.</returns>
///
public bool GetSensorValue( Sensor sensor, out SensorValues sensorValues )
{
byte[] command = new byte[3];
byte[] reply = new byte[16];
sensorValues = new SensorValues( );
// prepare message
command[0] = (byte) NXTCommandType.DirectCommand;
command[1] = (byte) NXTDirectCommand.GetInputValues;
command[2] = (byte) sensor;
if ( SendCommand( command, reply ) )
{
sensorValues.IsValid = ( reply[4] != 0 );
sensorValues.IsCalibrated = ( reply[5] != 0 );
sensorValues.SensorType = (SensorType) reply[6];
sensorValues.SensorMode = (SensorMode) reply[7];
sensorValues.Raw = (ushort) ( reply[8] | ( reply[9] << 8 ) );
sensorValues.Normalized = (ushort) ( reply[10] | ( reply[11] << 8 ) );
sensorValues.Scaled = (short) ( reply[12] | ( reply[13] << 8 ) );
sensorValues.Calibrated = (short) ( reply[14] | ( reply[15] << 8 ) );
return true;
}
return false;
}
private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
{
var sp = (SerialPort)sender;
string indata = _lastFragment + sp.ReadExisting();
sp.DiscardInBuffer();
if (!IsReading)
{
return;
}
indata = indata.Replace("\r\n", "\n");
var lines = indata.Split(SEP_LINES);
var noOfLines = lines.Length;
if (!indata.EndsWith(new string(SEP_LINES, 1)))
{
// last fragment is not complete
--noOfLines;
_lastFragment = lines[noOfLines];
}
else
{
_lastFragment = "";
}
const string suffixTime = "| ";
for (int index = 0; index < noOfLines; index++)
{
var line = lines[index];
var pos = line.IndexOf(suffixTime, StringComparison.Ordinal);
if (pos >= 0)
{
line = line.Substring(pos + suffixTime.Length);
}
if (line.StartsWith(COMMENT_PREFIX))
{
continue;
}
const string animationPrefix = @"=== ";
if (line.StartsWith(animationPrefix))
{
_animationTitle = line.Substring(animationPrefix.Length);
_animationTitle = _animationTitle.Replace(@" ===", "");
}
var fragments = line.Split(SEP_TIME_VALUE);
try
{
switch (fragments.Length)
{
case 1:
fragments = fragments[0].Split(';');
if (fragments.Length != 6)
{
continue;
}
AddValue(fragments[0], modeValueBuf, ModeValues);
AddValue(fragments[1], noiceOffsetValueBuf, NoiseOffsetValues);
AddValue(fragments[2], sensorValueBuf, SensorValues);
AddValue(fragments[3], rawSensorValueBuf, rawSensorValues, _animationTitle);
_animationTitle = null;
AddValue(fragments[4], maxSensorValueBuf, MaxSensorValues);
AddValue(fragments[5], songAvgValueBuf, songAvgValues);
break;
case 2:
DataItem di;
di.Time = Parse(fragments[0]);
di.Value = Parse(fragments[1]);
if (di.Time < _lastTime)
{
continue;
}
_lastTime = di.Time;
SensorValues.Add(di.Value);
break;
}
}
catch (FormatException)
{
}
}
ModeValues.AddRange(modeValueBuf); modeValueBuf.Clear();
SensorValues.AddRange(sensorValueBuf); sensorValueBuf.Clear();
MaxSensorValues.AddRange(maxSensorValueBuf); maxSensorValueBuf.Clear();
NoiseOffsetValues.AddRange(noiceOffsetValueBuf); noiceOffsetValueBuf.Clear();
rawSensorValues.AddRange(rawSensorValueBuf); rawSensorValueBuf.Clear();
songAvgValues.AddRange(songAvgValueBuf); songAvgValueBuf.Clear();
}
