public override void Load()
{
try
{
IsEnabled = true;
PositionScaleFactor = 0.1;
_lastTimeStamp = 0;
_velocityVec = new Vector3D(0, 0, 0);
_positionVec = new Vector3D(0, 0, 0);
RawPosition = _positionVec;
_device = SensorDevices.GetFirstAvailable(FilterEnum.FindUSB);
_keepCallbackAlive = new ThreeSpaceInterop.DataCallbackDelegate(dataCallbackFunc);
// keepCallbackAlive is to prevent crash from garbage collection not being able to track into the unmanged code of ThreeSpace_API.dll
ThreeSpaceInterop.SetNewDataCallBack(_device.DeviceId, _keepCallbackAlive);
StreamCommandSlots slots = new StreamCommandSlots(StreamCommand.TSS_NULL);
slots.Slot0 = StreamCommand.TSS_GET_TARED_ORIENTATION_AS_QUATERNION;
slots.Slot1 = StreamCommand.TSS_GET_CORRECTED_ACCELEROMETER_VECTOR;
ThreeSpaceInterop.SetStreamingTiming(_device.DeviceId, 0, 0xffffffff, 0, ref _device.TimeStamp);
ThreeSpaceInterop.SetStreamingSlots(_device.DeviceId, ref slots, ref _device.TimeStamp);
ThreeSpaceInterop.StartStreaming(_device.DeviceId, ref _device.TimeStamp);
Calibrate();
}
catch (Exception exc)
{
IsEnabled = false;
}
}
void Update()
{
if (Input.GetKey(KeyCode.Escape))
{
SceneStackManager.Instance.LoadPrevious();
}
StartCamera();
if (!startTrackerDone)
{
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_INSTANT);
SensorDevice.GetInstance().Start();
startTrackerDone = true;
}
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
if (trackingResult.GetCount() == 0)
{
instantTrackable.OnTrackFail();
return;
}
Trackable track = trackingResult.GetTrackable(0);
instantTrackable.OnTrackSuccess(track.GetId(), track.GetName(), track.GetPose());
#if UNITY_EDITOR
if (Input.GetMouseButtonDown(0))
{
if (linePointCount < 100)
{
linePoint [linePointCount++] = TrackerManager.GetInstance().GetWorldPositionFromScreenCoordinate(Input.mousePosition);
lineRenderer.positionCount = linePointCount;
lineRenderer.SetPositions(linePoint);
}
}
#else
if (Input.touchCount > 0)
{
if (linePointCount < 100)
{
linePoint [linePointCount++] = TrackerManager.GetInstance().GetWorldPositionFromScreenCoordinate(Input.GetTouch(0).position);
lineRenderer.positionCount = linePointCount;
lineRenderer.SetPositions(linePoint);
}
}
if (Input.GetTouch(0).phase == TouchPhase.Ended)
{
linePointCount = 0;
}
#endif
}
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);
}
void OnApplicationPause(bool pause)
{
if (pause)
{
SensorDevice.GetInstance().Stop();
TrackerManager.GetInstance().StopTracker();
startTrackerDone = false;
StopCamera();
}
}
void StopCamera()
{
if (cameraStartDone)
{
Debug.Log("Unity StopCamera");
CameraDevice.GetInstance().Stop();
cameraStartDone = false;
SensorDevice.GetInstance().Stop();
}
}
public async Task ReadDeviceDataAsync_RuuviTagFound_ReturnData()
{
// Arrange
var numberFormatInfo = new NumberFormatInfo()
{
NumberDecimalSeparator = "."
};
const string ruuviTagAddress = "testAddress";
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = Type.SensorDeviceTypeId.RuuviTag,
Id = "SensorDevice1",
Address = ruuviTagAddress
};
var ruuviTag = new RuuviTag()
{
AccelerationX = 0.123,
AccelerationY = 0.564,
AccelerationZ = -0.153,
AirPressure = 1060,
BatteryVoltage = 2.11,
DataFormat = 5,
Humidity = 77,
MacAddress = ruuviTagAddress,
MeasurementSequenceNumber = 22,
MovementCounter = 123,
Temperature = 33.3,
TxPower = 3
};
_bleReaderMock.Setup(b => b.GetManufacturerDataAsync <RuuviTag>(ruuviTagAddress)).ReturnsAsync(ruuviTag);
var deviceDataReader = _serviceProvider.GetService <DeviceDataReader.DeviceDataReader>();
// Act
var measurementList = await deviceDataReader.ReadDeviceDataAsync(sensorDevice);
// Assert
Assert.AreEqual(8, measurementList.Count, "Amount of returned measurements is not correct");
Assert.AreEqual(ruuviTag.AccelerationX.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("AccelerationX", StringComparison.OrdinalIgnoreCase)).Value, "Value of AccelerationX is not correct");
Assert.AreEqual(ruuviTag.AccelerationY.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("AccelerationY", StringComparison.OrdinalIgnoreCase)).Value, "Value of AccelerationY is not correct");
Assert.AreEqual(ruuviTag.AccelerationZ.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("AccelerationZ", StringComparison.OrdinalIgnoreCase)).Value, "Value of AccelerationZ is not correct");
Assert.AreEqual(ruuviTag.AirPressure.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("Pressure", StringComparison.OrdinalIgnoreCase)).Value, "Value of Pressure is not correct");
Assert.AreEqual(ruuviTag.BatteryVoltage.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("BatteryVoltage", StringComparison.OrdinalIgnoreCase)).Value, "Value of BatteryVoltage is not correct");
Assert.AreEqual(ruuviTag.Humidity.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("Humidity", StringComparison.OrdinalIgnoreCase)).Value, "Value of Humidity is not correct");
Assert.AreEqual(ruuviTag.Temperature.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("Temperature", StringComparison.OrdinalIgnoreCase)).Value, "Value of Temperature is not correct");
Assert.AreEqual(ruuviTag.MovementCounter.Value.ToString(numberFormatInfo), measurementList.First(m =>
m.SensorId.Equals("MovementCounter", StringComparison.OrdinalIgnoreCase)).Value, "Value of MovementCounter is not correct");
}
/// <summary>
/// Gets the slot with given SensorDevice.
/// </summary>
/// <returns>The slot with device.</returns>
/// <param name="sensorDevice">Sensor device.</param>
public DeviceSlot GetSlotWithDevice(SensorDevice sensorDevice)
{
foreach (var slot in _deviceSlots)
{
if (!slot.IsEmpty && (slot.ConnectedDevice.Id == sensorDevice.Id))
{
return(slot);
}
}
return(null);
}
public void AddDeviceToSlot(int slotIndex, SensorDevice device)
{
if (slotIndex < 0 || slotIndex >= MaxNumConnectedDevices)
{
return;
}
_deviceSlots[slotIndex].AddDevice(device);
device.SlotIndex = slotIndex;
RaiseDeviceAddedEvent(new SlotEventArgs(_deviceSlots[slotIndex]));
}
private void InitializeCommands()
{
ConnectCommand = new RelayCommand(async() =>
{
await navigation.PushAsync(PageUrls.SENSORCONNECTVIEW);
});
GoToCategoriesCommand = new RelayCommand(async() =>
{
await navigation.PushAsync(PageUrls.CATEGORIESVIEW);
});
//LoginCommand = new RelayCommand(async () =>
//{
// if (userDataService.LoggedInUser == null)
// await navigation.PushModalAsync(PageUrls.LOGINVIEW);
//});
TestCommand = new RelayCommand(() =>
{
SensorDevice sensor = ServiceLocator.Current.GetInstance <SensorDevice>();
if (sensor.MovementService != null)
{
if (!sensor.MovementService.IsOn)
{
sensor.MovementService.SetEnabled(true);
}
if (!sensor.MovementService.IsUpdating)
{
sensor.MovementService.StartReadData(1000);
sensor.MovementService.OnValueChanged += MovementService_OnValueChanged;
}
else
{
sensor.MovementService.StopReadData();
sensor.MovementService.OnValueChanged -= MovementService_OnValueChanged;
foreach (var vect in vectList)
{
Debug.WriteLine(vect.X + "," + vect.Y + "," + vect.Z);
}
}
}
else
{
Debug.WriteLine("Movementsensor not found.");
}
if (sensor.KeyService != null)
{
sensor.KeyService.StartReadData(100);
sensor.KeyService.OnKeyPushed += KeyService_OnKeyPushed;
}
});
}
public async Task GetDeviceDataAsync_BluetoothDevices_ScanMade()
{
var sensorDeviceTypeId = "RuuviTag";
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = sensorDeviceTypeId,
Id = "SensorDevice1"
};
var sensorDeviceType = new SensorDeviceType()
{
Id = sensorDeviceTypeId,
Sensors = new List <Sensor>()
{
new Sensor()
{
Id = "Sensor1",
}
}
};
_dataReaderMock.Setup(d => d.ReadDeviceDataAsync(It.IsAny <SensorDevice>()))
.ReturnsAsync(new List <MeasurementData>());
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
{
sensorDeviceType
}
};
_configMock.Setup(c => c.Value).Returns(config);
var deviceScanner = _serviceProvider.GetService <Collector.DeviceScanner.DeviceScanner>();
// Act
var fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
// Assert
_bleReaderMock.Verify(b => b.ScanAsync(It.IsAny <string>(), It.IsAny <int>()), Times.Once,
"Bluetooth scan should've been made");
}
public async Task ExecuteAsync_PublishSensorDeviceTypeData_CorrectlyPublished()
{
var publishedMessages = new List <MqttApplicationMessage>();
var sensorDevice = new SensorDevice()
{
Id = "Device1",
SensorDeviceTypeId = "DeviceType1"
};
//Arrange
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
};
_mqttClientMock.Setup(m => m.IsConnected).Returns(true);
_mqttClientMock.Setup(m => m.PublishAsync(It.IsAny <MqttApplicationMessage>(), CancellationToken.None)).Callback((MqttApplicationMessage message, CancellationToken ct) => { publishedMessages.Add(message); });
_configMock.Setup(c => c.Value).Returns(config);
//Act
var btGwService = _serviceProvider.GetService <CollectorService>();
var cts = new CancellationTokenSource();
#pragma warning disable CS4014
// Run as fire & forget
Task.Run(() => btGwService.StartAsync(cts.Token).ConfigureAwait(false));
#pragma warning restore CS4014
await Task.Delay(100);
await btGwService.HandleConnectedAsync(new MqttClientConnectedEventArgs(new MqttClientAuthenticateResult()));
cts.Cancel();
// Assert
var topic = MqttMessageHelper.GetSensorDeviceTopic(sensorDevice.Id);
var payload = MqttMessageHelper.SerializePayload(sensorDevice);
var message = publishedMessages.FirstOrDefault(m => m.Topic.Equals(topic, StringComparison.OrdinalIgnoreCase));
Assert.IsNotNull(message, "MQTT message for type data of sensor device was not received");
Assert.AreEqual(topic, message?.Topic, "Sensor device message topic was not correct");
Assert.AreEqual(payload, message?.ConvertPayloadToString(), "Sensor device message payload was not correct");
}
void Start()
{
instantTrackable = FindObjectOfType <InstantTrackableBehaviour>();
if (instantTrackable == null)
{
return;
}
instantTrackable.OnTrackFail();
StartCamera();
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_INSTANT);
SensorDevice.GetInstance().Start();
}
public async Task CreateAsync(string sensorId, int deviceId)
{
var sensorDevice = new SensorDevice
{
DeviceId = deviceId,
SensorId = sensorId
};
_context.Attach(sensorDevice);
_context.Entry(sensorDevice).State = EntityState.Added;
await _context.SaveChangesAsync();
_context.Entry(sensorDevice).State = EntityState.Detached;
}
void StartCamera()
{
if (!cameraStartDone)
{
Debug.Log("Unity StartCamera");
ResultCode result = CameraDevice.GetInstance().Start();
if (result == ResultCode.Success)
{
cameraStartDone = true;
SensorDevice.GetInstance().Start();
//CameraDevice.GetInstance().SetAutoWhiteBalanceLock(true); // For ODG-R7 preventing camera flickering
}
}
}
void Start()
{
//focusIndicator = transform.GetChild(0).GetComponent<SpriteRenderer>();
//focusIndicator.enabled = false;
//myColor = GetComponent<SpriteRenderer>().color;
if (devicesController == null)
{
devicesController = GetComponentInParent <SensorDevicesController>();
}
if (device == null)
{
device = GetComponentInParent <SensorDevice>();
}
}
void OnApplicationPause(bool pause)
{
if (pause)
{
SensorDevice.GetInstance().Stop();
TrackerManager.GetInstance().StopTracker();
StopCamera();
}
else
{
StartCamera();
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_INSTANT);
SensorDevice.GetInstance().Start();
}
}
public void SaveOrUpdate(SensorDevice district)
{
using (FLMSEntities entities = new FLMSEntities())
{
if (district.Id == 0)
{
entities.SensorDevices.Add(district);
entities.SaveChanges();
}
else
{
entities.Entry(district).State = System.Data.Entity.EntityState.Modified;
entities.SaveChanges();
}
}
}
public async Task ReadDeviceDataAsync_DeviceTypeUnknown_LogAnError()
{
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = "SomeUnsupportedDeviceType"
};
var deviceDataReader = _serviceProvider.GetService <DeviceDataReader.DeviceDataReader>();
// Act
var measurementList = await deviceDataReader.ReadDeviceDataAsync(sensorDevice);
// Assert
Assert.AreEqual(0, measurementList.Count, "Measurement list cound should be zero");
_loggerMock.Verify(l => l.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), It.IsAny <Exception>(),
(Func <It.IsAnyType, Exception, string>)It.IsAny <object>()), Times.Once, "It should have been logged that the device type is unknown");
}
public void Select(SensorDevice device)
{
if (selectedDevice != device) // A new device will be selected
{
if (selectedDevice)
{
Deselect();
}
if (cameraController.MoveTo(device.transform))
{
device.Select();
canvasController.Populate(device);
selectedDevice = device;
}
}
else // The selected device is already selected, so deselect it
{
Deselect();
}
//if (selectedDevice == null)
//{
// device.Select();
// canvasController.Populate(device);
// selectedDevice = device;
// cameraController.MoveTo(device.transform);
//}
//else if (selectedDevice != device)
//{
// Deselect();
//}
//else if (selectedDevice == device)
//{
// Deselect();
//}
}
void Update()
{
if (instantTrackable == null)
{
return;
}
StartCamera();
if (!startTrackerDone)
{
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_INSTANT);
SensorDevice.GetInstance().Start();
startTrackerDone = true;
}
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
cameraBackgroundBehaviour.UpdateCameraBackgroundImage(state);
if (trackingResult.GetCount() == 0)
{
instantTrackable.OnTrackFail();
instantPlaneGrid.EnableDrawing(false);
return;
}
instantPlaneGrid.EnableDrawing(true);
Trackable trackable = trackingResult.GetTrackable(0);
planMatrix = trackable.GetPose();
Matrix4x4 poseMatrix = trackable.GetPose() * Matrix4x4.Translate(touchSumPosition);
instantTrackable.OnTrackSuccess(trackable.GetId(), trackable.GetName(), poseMatrix);
if (Input.touchCount > 0 && !rotationController.getRotationState() && !zoomInOut.getScaleState())
{
UpdateTouchDelta(Input.GetTouch(0).position);
}
}
public async Task GetDeviceDataAsync_NoDataAvailable_CustomMeasurementsNotHandled()
{
var customRule = new CustomMeasurementRule();
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = "someSensorDeviceTypeId",
Id = "someSensorId",
CalculatedMeasurements = new List <CustomMeasurementRule>()
{
customRule
}
};
_dataReaderMock.Setup(d => d.ReadDeviceDataAsync(It.IsAny <SensorDevice>()))
.ReturnsAsync(new List <MeasurementData>());
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
};
_configMock.Setup(c => c.Value).Returns(config);
var deviceScanner = _serviceProvider.GetService <Collector.DeviceScanner.DeviceScanner>();
// Act
var fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
// Assert
_loggerMock.Verify(l => l.Log(LogLevel.Error, It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), It.IsAny <Exception>(),
(Func <It.IsAnyType, Exception, string>)It.IsAny <object>()), Times.Never, "No error should be raised in DeviceScanner if no measurement data available");
}
void Update()
{
if (Input.GetKey(KeyCode.Escape))
{
SceneStackManager.Instance.LoadPrevious();
}
if (instantTrackable == null)
{
return;
}
StartCamera();
if (!startTrackerDone)
{
TrackerManager.GetInstance().StartTracker(TrackerManager.TRACKER_TYPE_INSTANT);
SensorDevice.GetInstance().Start();
startTrackerDone = true;
}
TrackingState state = TrackerManager.GetInstance().UpdateTrackingState();
TrackingResult trackingResult = state.GetTrackingResult();
if (trackingResult.GetCount() == 0)
{
instantTrackable.OnTrackFail();
return;
}
if (Input.touchCount > 0)
{
UpdateTouchDelta(Input.GetTouch(0).position);
}
Trackable trackable = trackingResult.GetTrackable(0);
Matrix4x4 poseMatrix = trackable.GetPose() * Matrix4x4.Translate(touchSumPosition);
instantTrackable.OnTrackSuccess(trackable.GetId(), trackable.GetName(), poseMatrix);
}
public void postUpdate(SensorDevice device)
{
if (mostRecentUpdates.ContainsKey(device.ID))
{
mostRecentUpdates[device.ID] = device;
}
else
{
mostRecentUpdates.Add(device.ID, device);
}
if (!displayedDevices.ContainsKey(device.ID))
{
if (device.isActive())
{
addToggleDevice(device);
}
}
else
{
updateToggleDevice(device);
}
}
public async Task <IList <MeasurementData> > ReadDeviceDataAsync(SensorDevice sensorDevice)
{
var measurements = new List <MeasurementData>();
switch (sensorDevice.SensorDeviceTypeId)
{
case Type.SensorDeviceTypeId.RuuviTag:
measurements.AddRange(await GetRuuviTagMeasurementsAsync(sensorDevice));
break;
case Type.SensorDeviceTypeId.Dht22:
measurements.AddRange(GetDht22Measurements(sensorDevice));
break;
// Add handlers for other device types here
default:
_logger.LogError($"Type of device at {sensorDevice.Address} is not supported. " +
"Please check that it's been correctly defined in 'sensordevicetype' section of the configuration file");
break;
}
return(measurements);
}
public async Task ReadDeviceDataAsync_RuuviTagNotFound_LogAWarning()
{
// Arrange
const string ruuviTagAddress = "testAddress";
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = Type.SensorDeviceTypeId.RuuviTag,
Id = "SensorDevice1",
Address = ruuviTagAddress
};
_bleReaderMock.Setup(b => b.GetManufacturerDataAsync <RuuviTag>(ruuviTagAddress)).ReturnsAsync(default(RuuviTag));
var deviceDataReader = _serviceProvider.GetService <DeviceDataReader.DeviceDataReader>();
// Act
var measurementList = await deviceDataReader.ReadDeviceDataAsync(sensorDevice);
// Assert
Assert.AreEqual(0, measurementList.Count, "Measurement list cound should be zero");
_loggerMock.Verify(l => l.Log(LogLevel.Warning, It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), It.IsAny <Exception>(),
(Func <It.IsAnyType, Exception, string>)It.IsAny <object>()), Times.Once, "It should have been logged that RuuviTag could not be read");
}
// GET: SensorDevices
public ActionResult Index(int?id)
{
SensorDeviceViewModel sensorDeviceViewModel = new SensorDeviceViewModel();
if (id != null)
{
SensorDevice sensorDevice = sensorDeviceService.GetSensorDeviceById(id);
sensorDeviceViewModel = new SensorDeviceViewModel()
{
Id = sensorDevice.Id,
IsActive = sensorDevice.IsActive,
ModelNumber = sensorDevice.Model,
SerialNumber = sensorDevice.SerialNumber,
SupplierName = sensorDevice.Supplier.Name
};
}
ViewBag.SupplierList = new SelectList(genericService.GetList <Supplier>(), "Id", "Name");
return(View(sensorDeviceViewModel));
}
public void Load(IWorkspace workspace)
{
_device = new SensorDevice();
workspace.RuntimeManager.System.HardwareController.RegisterHardwareDevice(_device);
}
public async Task GetDeviceDataAsync_CustomMeasurementSensorNotExists_ReturnNull()
{
var sensorDeviceTypeId = "SomeSensorType";
var sensorDeviceId = "SomeSensorDevice";
var sensorId = "SomeSensor";
var customRule = new CustomMeasurementRule()
{
Class = "MyClass",
Id = "MyId",
Name = "My custom measurement",
Unit = "qwerty",
Operator = Shared.Enum.OperatorType.IsGreaterThan,
SensorId = "UnknownSensor",
Type = Shared.Enum.ValueType.Default,
Value = "somevalue"
};
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = sensorDeviceTypeId,
Id = sensorDeviceId,
CalculatedMeasurements = new List <CustomMeasurementRule>()
{
customRule
}
};
var sensorDeviceType = new SensorDeviceType()
{
Id = sensorDeviceTypeId,
Sensors = new List <Sensor>()
{
new Sensor()
{
Id = sensorId,
}
}
};
_dataReaderMock.Setup(d => d.ReadDeviceDataAsync(It.IsAny <SensorDevice>()))
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = "some value"
}
});
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
{
sensorDeviceType
}
};
_configMock.Setup(c => c.Value).Returns(config);
var deviceScanner = _serviceProvider.GetService <Collector.DeviceScanner.DeviceScanner>();
// Act
var fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
// Assert
Assert.AreEqual(1, fullList.Count, "Amount of measurements is not correct");
Assert.AreEqual(sensorDeviceId, fullList[0].SensorDeviceId, "Sensor device ID is not correct");
}
public async Task GetDeviceDataAsync_WasLastTypeCustomMeasurementExists_HandleValueZeroAndMinusOne(
Shared.Enum.OperatorType operatorType, string measurementValue, string customRuleValue, string expectedComparisonValue)
{
var sensorDeviceTypeId = "SomeSensorType";
var sensorDeviceId = "SomeSensorDevice";
var sensorId = "SomeSensor";
var customRule = new CustomMeasurementRule()
{
Class = "MyClass",
Id = "MyId",
Name = "My custom measurement",
Unit = "qwerty",
Operator = operatorType,
SensorId = sensorId,
Type = Shared.Enum.ValueType.WasLast,
Value = customRuleValue
};
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = sensorDeviceTypeId,
Id = sensorDeviceId,
CalculatedMeasurements = new List <CustomMeasurementRule>()
{
customRule
}
};
var sensorDeviceType = new SensorDeviceType()
{
Id = sensorDeviceTypeId,
Sensors = new List <Sensor>()
{
new Sensor()
{
Id = sensorId,
}
}
};
_dataReaderMock.Setup(d => d.ReadDeviceDataAsync(It.IsAny <SensorDevice>()))
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = measurementValue
}
})
;
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
{
sensorDeviceType
}
};
_configMock.Setup(c => c.Value).Returns(config);
var deviceScanner = _serviceProvider.GetService <Collector.DeviceScanner.DeviceScanner>();
// Act
var fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
// Assert
Assert.AreEqual(2, fullList.Count, "Amount of measurements is not correct");
var customMeasurement = fullList.First(f => f.SensorId.Equals(customRule.Id, StringComparison.OrdinalIgnoreCase));
Assert.AreEqual(sensorDeviceId, customMeasurement.SensorDeviceId, "Sensor device ID does not match");
Assert.AreNotEqual(default(DateTime), customMeasurement.Timestamp, "Timestamp has not been set");
Assert.AreEqual(expectedComparisonValue, customMeasurement.Value, "Value is not what expected");
}
public async Task ExecuteAsync_PublishMeasurementData_CorrectlyPublished()
{
MqttApplicationMessage publishedMessage = null;
var sensorDevice = new SensorDevice()
{
Id = "Device1",
SensorDeviceTypeId = "DeviceType1"
};
var sensorDeviceType = new SensorDeviceType()
{
Id = "DeviceType1",
Sensors = new List <Sensor>()
{
new Sensor()
{
Id = "Sensor1",
}
}
};
//Arrange
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 0,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
{
sensorDeviceType
}
};
var measurementData = new MeasurementData()
{
SensorDeviceId = sensorDevice.Id, SensorId = sensorDeviceType.Sensors[0].Id, Timestamp = DateTime.Now, Value = "123"
};
var measurementList = new List <MeasurementData>()
{
measurementData
};
_mqttClientMock.Setup(m => m.IsConnected).Returns(true);
_mqttClientMock.Setup(m => m.PublishAsync(It.IsAny <MqttApplicationMessage>(), CancellationToken.None)).Callback((MqttApplicationMessage message, CancellationToken ct) => { publishedMessage = message; });
_configMock.Setup(c => c.Value).Returns(config);
_deviceScannerMock.Setup(d => d.GetDeviceDataAsync(config.SensorDevices)).ReturnsAsync(measurementList);
//Act
var btGwService = _serviceProvider.GetService <CollectorService>();
var cts = new CancellationTokenSource();
#pragma warning disable CS4014
// Run as fire & forget
Task.Run(() => btGwService.StartAsync(cts.Token).ConfigureAwait(false));
#pragma warning restore CS4014
await Task.Delay(100);
cts.Cancel();
var expectedMessage = $"{Constant.TopicMeasurement}/{sensorDevice.Location}/{sensorDevice.Id}/{measurementData.SensorId}";
Assert.AreEqual(expectedMessage, publishedMessage.Topic, "Published topic was incorrect");
Assert.AreEqual(measurementData.Value, publishedMessage.ConvertPayloadToString(), "Published payload was incorrect");
}
public async Task GetDeviceDataAsync_WasLastTypeCustomMeasurement_SequenceWorksCorrectly()
{
var sensorDeviceTypeId = "SomeSensorType";
var sensorDeviceId = "SomeSensorDevice";
var sensorId = "SomeSensor";
var customRule = new CustomMeasurementRule()
{
Class = "MyClass",
Id = "MyId",
Name = "My custom measurement",
Unit = "qwerty",
Operator = Shared.Enum.OperatorType.IsGreaterThan,
SensorId = sensorId,
Type = Shared.Enum.ValueType.WasLast,
Value = "1.66"
};
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = sensorDeviceTypeId,
Id = sensorDeviceId,
CalculatedMeasurements = new List <CustomMeasurementRule>()
{
customRule
}
};
var sensorDeviceType = new SensorDeviceType()
{
Id = sensorDeviceTypeId,
Sensors = new List <Sensor>()
{
new Sensor()
{
Id = sensorId,
}
}
};
_dataReaderMock.SetupSequence(d => d.ReadDeviceDataAsync(It.IsAny <SensorDevice>()))
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = "0.1"
}
})
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = "2.1"
}
})
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = "0.1"
}
})
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = "2.1"
}
})
;
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
{
sensorDeviceType
}
};
_configMock.Setup(c => c.Value).Returns(config);
var deviceScanner = _serviceProvider.GetService <Collector.DeviceScanner.DeviceScanner>();
// Act
var fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
var customMeasurement = fullList.First(f => f.SensorId.Equals(customRule.Id, StringComparison.OrdinalIgnoreCase));
Assert.AreEqual("-1", customMeasurement.Value, "Value is not what expected when condition has not been true yet");
fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
customMeasurement = fullList.First(f => f.SensorId.Equals(customRule.Id, StringComparison.OrdinalIgnoreCase));
Assert.AreEqual("0", customMeasurement.Value, "Value is not what expected when condition became true");
// Wait more than one second to get "WasLast" value to get updated to 1
await Task.Delay(1200);
fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
customMeasurement = fullList.First(f => f.SensorId.Equals(customRule.Id, StringComparison.OrdinalIgnoreCase));
Assert.AreEqual("1", customMeasurement.Value, "Value is not what expected when condition became false again");
fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
customMeasurement = fullList.First(f => f.SensorId.Equals(customRule.Id, StringComparison.OrdinalIgnoreCase));
Assert.AreEqual("0", customMeasurement.Value, "Value is not what expected when condition is true again");
}
public async Task GetDeviceDataAsync_CustomMeasurementCreatedForCorrectSensor()
{
var sensorDeviceTypeId = "SomeSensorType";
var sensorDeviceId = "SomeSensorDevice";
var sensorId = "SomeSensor";
var anotherSensorDeviceId = "AnotherSensor";
var customRule = new CustomMeasurementRule()
{
Class = "MyClass",
Id = "MyId",
Name = "My custom measurement",
Unit = "qwerty",
Operator = Shared.Enum.OperatorType.IsGreaterThan,
SensorId = sensorId,
Type = Shared.Enum.ValueType.Default,
Value = "10"
};
// Arrange
var sensorDevice = new SensorDevice
{
SensorDeviceTypeId = sensorDeviceTypeId,
Id = sensorDeviceId,
CalculatedMeasurements = new List <CustomMeasurementRule>()
{
customRule
}
};
var anotherSensorDevice = new SensorDevice
{
SensorDeviceTypeId = sensorDeviceTypeId,
Id = anotherSensorDeviceId,
CalculatedMeasurements = new List <CustomMeasurementRule>()
{
customRule
}
};
var sensorDeviceType = new SensorDeviceType()
{
Id = sensorDeviceTypeId,
Sensors = new List <Sensor>()
{
new Sensor()
{
Id = sensorId,
}
}
};
_dataReaderMock.Setup(d => d.ReadDeviceDataAsync(It.IsAny <SensorDevice>()))
.ReturnsAsync(new List <MeasurementData>()
{
new MeasurementData()
{
SensorDeviceId = anotherSensorDeviceId,
SensorId = sensorId,
Value = "12"
},
new MeasurementData()
{
SensorDeviceId = sensorDeviceId,
SensorId = sensorId,
Value = "8"
}
});
var config = new CollectorConfiguration
{
CollectorEnabled = true,
BluetoothAdapterName = "test",
ScanIntervalSeconds = 1,
SensorDevices = new List <SensorDevice>()
{
sensorDevice, anotherSensorDevice
},
SensorDeviceTypes = new List <SensorDeviceType>()
{
sensorDeviceType
}
};
_configMock.Setup(c => c.Value).Returns(config);
var deviceScanner = _serviceProvider.GetService <Collector.DeviceScanner.DeviceScanner>();
// Act
var fullList = await deviceScanner.GetDeviceDataAsync(config.SensorDevices);
// Assert
Assert.AreEqual(6, fullList.Count, "Amount of measurements is not correct");
var customMeasurement = fullList.First(f => f.SensorId.Equals(customRule.Id, StringComparison.OrdinalIgnoreCase));
Assert.IsFalse(bool.Parse(customMeasurement.Value), "Custom measurement value should be false for the correct sensor device");
}
