//------------------------------------------------------------------------------
// Function: GetData
//
// This routine is called by worker thread to read a single sample, compare threshold
// and push it back to CLX. It simulates hardware thresholding by only generating data
// when the change of data is greater than threshold.
//
// Arguments:
// None
//
// Return Value:
// NTSTATUS code
//------------------------------------------------------------------------------
NTSTATUS
PrxDevice::GetData(
)
{
BOOLEAN DataReady = FALSE;
FILETIME TimeStamp = {0};
NTSTATUS Status = STATUS_SUCCESS;
SENSOR_FunctionEnter();
// new sample?
if (m_FirstSample != FALSE)
{
Status = GetPerformanceTime(&m_StartTime);
if (!NT_SUCCESS(Status))
{
m_StartTime = 0;
TraceError("COMBO %!FUNC! PRX GetPerformanceTime %!STATUS!", Status);
}
m_SampleCount = 0;
DataReady = TRUE;
}
else
{
// Compare the change of detection state, and only push the data back to
// clx. This is usually done in HW.
if (m_CachedData.Detected != m_LastSample.Detected)
{
DataReady = TRUE;
}
}
if (DataReady != FALSE)
{
// update last sample
m_LastSample = m_CachedData;
// push to clx
InitPropVariantFromBoolean(m_LastSample.Detected, &(m_pData->List[PRX_DATA_DETECT].Value));
InitPropVariantFromUInt32(m_LastSample.DistanceMillimeters, &(m_pData->List[PRX_DATA_DISTANCE].Value));
GetSystemTimePreciseAsFileTime(&TimeStamp);
InitPropVariantFromFileTime(&TimeStamp, &(m_pData->List[PRX_DATA_TIMESTAMP].Value));
SensorsCxSensorDataReady(m_SensorInstance, m_pData);
m_FirstSample = FALSE;
}
else
{
Status = STATUS_DATA_NOT_ACCEPTED;
TraceInformation("COMBO %!FUNC! PRX Data did NOT meet the threshold");
}
SENSOR_FunctionExit(Status);
return Status;
}
// This routine is called by worker thread to read a single sample and push it back
// to CLX.
NTSTATUS CustomSensorDevice::GetData()
{
PHardwareSimulator pSimulator = nullptr;
FILETIME TimeStamp = {};
NTSTATUS Status = STATUS_SUCCESS;
SENSOR_FunctionEnter();
if (FALSE != m_FirstSample)
{
Status = GetPerformanceTime(&m_StartTime);
if (!NT_SUCCESS(Status))
{
m_StartTime = 0;
TraceError("CSTM %!FUNC! GetPerformanceTime %!STATUS!", Status);
}
}
pSimulator = GetHardwareSimulatorContextFromInstance(m_SimulatorInstance);
if (nullptr == pSimulator)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
TraceError("CSTM %!FUNC! GetHardwareSimulatorContextFromInstance failed %!STATUS!", Status);
goto Exit;
}
// push to clx
InitPropVariantFromFloat(pSimulator->GetSample(), &(m_pData->List[CSTM_DATA_CO2_LEVEL_PERCENT].Value));
GetSystemTimePreciseAsFileTime(&TimeStamp);
InitPropVariantFromFileTime(&TimeStamp, &(m_pData->List[CSTM_DATA_TIMESTAMP].Value));
SensorsCxSensorDataReady(m_SensorInstance, m_pData);
m_FirstSample = FALSE;
Exit:
SENSOR_FunctionExit(Status);
return Status;
}
// This routine is called by worker thread to read a single sample, compare threshold
// and push it back to CLX. It simulates hardware thresholding by only generating data
// when the change of data is greater than threshold.
NTSTATUS ActivityDevice::GetData()
{
BOOLEAN dataReady = FALSE;
NTSTATUS status = STATUS_SUCCESS;
SENSOR_FunctionEnter();
if (NULL != m_SimulatorInstance)
{
// Use simulator to get m_pFiltered Sample
PHardwareSimulator pSimulator = GetHardwareSimulatorContextFromInstance(m_SimulatorInstance);
if (nullptr != pSimulator)
{
status = pSimulator->GetSample(m_pFilteredSample);
}
else
{
status = STATUS_INVALID_PARAMETER;
}
}
if (NT_SUCCESS(status))
{
status = CollectionsListSortSubscribedActivitiesByConfidence(m_pThresholds, m_pFilteredSample);
if (!NT_SUCCESS(status))
{
TraceError("ACT %!FUNC! CollectionsListSortSubscribedActivitiesByConfidence failed! %!STATUS!", status);
}
else
{
// new sample?
if (FALSE != m_FirstSample)
{
dataReady = TRUE;
}
else
{
dataReady = EvaluateActivityThresholds(m_pFilteredSample, m_pLastSample, m_pThresholds);
}
}
}
if (FALSE != dataReady)
{
// update last sample
FILETIME TimeStamp = {};
memcpy_s(m_pLastSample, m_pFilteredSample->AllocatedSizeInBytes, m_pFilteredSample, m_pFilteredSample->AllocatedSizeInBytes);
GetSystemTimePreciseAsFileTime(&TimeStamp);
InitPropVariantFromFileTime(&TimeStamp, &(m_pLastSample->List[ACTIVITY_DATA_TIMESTAMP].Value));
// push to clx
SensorsCxSensorDataReady(m_SensorInstance, m_pLastSample);
m_FirstSample = FALSE;
}
else
{
status = STATUS_DATA_NOT_ACCEPTED;
TraceInformation("ACT %!FUNC! Data did NOT meet the threshold");
}
SENSOR_FunctionExit(status);
return status;
}
// This routine is called by worker thread to read a single sample, compare threshold
// and push it back to CLX. It simulates hardware thresholding by only generating data
// when the change of data is greater than threshold.
NTSTATUS
PedometerDevice::GetData(
)
{
PHardwareSimulator pSimulator = GetHardwareSimulatorContextFromInstance(m_SimulatorInstance);
BOOLEAN DataReady = FALSE;
NTSTATUS Status = STATUS_SUCCESS;
ULONG CachedStepCountLimit = 0;
ULONG LastStepCountLimit = 0;
PedometerSample Sample = {};
SENSOR_FunctionEnter();
if (nullptr == pSimulator)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
TraceError("PED %!FUNC! GetHardwareSimulatorContextFromInstance failed %!STATUS!", Status);
goto Exit;
}
Status = pSimulator->GetSample(&Sample);
if (!NT_SUCCESS(Status))
{
TraceError("PED %!FUNC! GetSample failed %!STATUS!", Status);
goto Exit;
}
if (FALSE != m_FirstSample)
{
Status = GetPerformanceTime(&m_StartTime);
if (!NT_SUCCESS(Status))
{
m_StartTime = 0;
TraceError("PED %!FUNC! GetPerformanceTime failed %!STATUS!", Status);
}
m_SampleCount = 0;
DataReady = TRUE;
}
else
{
if (0 == m_CachedThreshold || FALSE != Sample.IsFirstAfterReset)
{
// Streaming mode
DataReady = TRUE;
}
else
{
if (FAILED(ULongAdd(Sample.UnknownStepCount, Sample.WalkingStepCount, &CachedStepCountLimit)) ||
FAILED(ULongAdd(Sample.RunningStepCount, CachedStepCountLimit, &CachedStepCountLimit)))
{
// If an overflow happened, we assume we reached the threshold
// in other words, there is no threshold value that can be larger
// than an overflowed value.
DataReady = TRUE;
}
else if (FAILED(ULongAdd(m_LastSample.UnknownStepCount, m_LastSample.WalkingStepCount, &LastStepCountLimit)) ||
FAILED(ULongAdd(m_LastSample.RunningStepCount, LastStepCountLimit, &LastStepCountLimit)))
{
// If an overflow happened, we assume we reached the threshold
// in other words, there is no threshold value that can be larger
// than an overflowed value.
DataReady = TRUE;
}
else if ((LastStepCountLimit < m_CachedThreshold && CachedStepCountLimit >= m_CachedThreshold) ||
(FALSE != Sample.IsFirstAfterReset))
{
// Compare the change of data to threshold, and only push the data back to
// clx if the change exceeds threshold or if this is the first sample after reset. This is usually done in HW.
DataReady = TRUE;
}
}
}
if (FALSE != DataReady)
{
// update last sample
m_LastSample = Sample;
// push to clx
InitPropVariantFromBoolean(m_LastSample.IsFirstAfterReset, &(m_pData->List[PEDOMETER_DATA_FIRST_AFTER_RESET].Value));
InitPropVariantFromUInt32(PedometerStepType_Unknown, &(m_pData->List[PEDOMETER_DATA_UNKNOWN_STEP_TYPE].Value));
InitPropVariantFromInt64(m_LastSample.UnknownStepDurationMs, &(m_pData->List[PEDOMETER_DATA_UNKNOWN_STEP_DURATION].Value));
InitPropVariantFromUInt32(m_LastSample.UnknownStepCount, &(m_pData->List[PEDOMETER_DATA_UNKNOWN_STEP_COUNT].Value));
InitPropVariantFromUInt32(PedometerStepType_Walking, &(m_pData->List[PEDOMETER_DATA_WALKING_STEP_TYPE].Value));
InitPropVariantFromInt64(m_LastSample.WalkingStepDurationMs, &(m_pData->List[PEDOMETER_DATA_WALKING_STEP_DURATION].Value));
InitPropVariantFromUInt32(m_LastSample.WalkingStepCount, &(m_pData->List[PEDOMETER_DATA_WALKING_STEP_COUNT].Value));
InitPropVariantFromUInt32(PedometerStepType_Running, &(m_pData->List[PEDOMETER_DATA_RUNNING_STEP_TYPE].Value));
InitPropVariantFromInt64(m_LastSample.RunningStepDurationMs, &(m_pData->List[PEDOMETER_DATA_RUNNING_STEP_DURATION].Value));
InitPropVariantFromUInt32(m_LastSample.RunningStepCount, &(m_pData->List[PEDOMETER_DATA_RUNNING_STEP_COUNT].Value));
// reset IsFirstAfterReset
m_LastSample.IsFirstAfterReset = FALSE;
InitPropVariantFromFileTime(&m_LastSample.Timestamp, &(m_pData->List[PEDOMETER_DATA_TIMESTAMP].Value));
SensorsCxSensorDataReady(m_SensorInstance, m_pData);
m_FirstSample = FALSE;
}
else
{
Status = STATUS_DATA_NOT_ACCEPTED;
TraceInformation("PED %!FUNC! Data did NOT meet the threshold");
}
SENSOR_FunctionExit(Status);
Exit:
return Status;
}
