701 lines
19 KiB
C
701 lines
19 KiB
C
/*
|
|
* Abstraction of the counter device.
|
|
*
|
|
*/
|
|
#include "device.h"
|
|
#include "params.h"
|
|
#include "sock.h"
|
|
#include "hware.h"
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#define HWARE_TEST(functionCall) \
|
|
if( hware_failed(error=(functionCall)) ) \
|
|
goto Error; \
|
|
else
|
|
|
|
/*
|
|
* get a pointer to the current sample
|
|
*/
|
|
static SAMPLE* cur_sample(DEVICE* device)
|
|
{
|
|
return &device->sample_array[device->sample_index];
|
|
}
|
|
|
|
/*
|
|
* get a pointer to the num'th previous sample
|
|
*/
|
|
static SAMPLE* prv_sample(DEVICE* device, int num)
|
|
{
|
|
int idx = (device->sample_index + SAMPLE_ARRAY_SZ - num) % SAMPLE_ARRAY_SZ;
|
|
return &device->sample_array[idx];
|
|
}
|
|
|
|
void make_report(DEVICE* device)
|
|
{
|
|
dbg_printf(0, "make_report\n");
|
|
int i;
|
|
SAMPLE* sp = cur_sample(device);
|
|
device->report = *sp;
|
|
device->report.average_rate = device->report.counter_rate;
|
|
device->report.minimum_rate = device->report.counter_rate;
|
|
device->report.maximum_rate = device->report.counter_rate;
|
|
for (i = 1; i <= device->params.report_period; ++i)
|
|
{
|
|
SAMPLE* psp;
|
|
psp = prv_sample(device, i);
|
|
if (psp->valid)
|
|
{
|
|
device->report.time_delta = time_diff(&sp->timestamp, &psp->timestamp);
|
|
device->report.count_delta = sp->count64 - psp->count64;
|
|
if (device->report.time_delta > 0.0)
|
|
device->report.average_rate = device->report.count_delta
|
|
/ device->report.time_delta;
|
|
if (i < device->params.report_period)
|
|
{
|
|
device->report.num_polls += psp->num_polls;
|
|
if (psp->counter_rate < device->report.minimum_rate)
|
|
device->report.minimum_rate = psp->counter_rate;
|
|
if (psp->counter_rate > device->report.maximum_rate)
|
|
device->report.maximum_rate = psp->counter_rate;
|
|
}
|
|
}
|
|
}
|
|
sp = &device->report;
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* given two samples, compute the count-rate
|
|
*/
|
|
static double compute_rate(DEVICE* device, SAMPLE* cur, SAMPLE* prv)
|
|
{
|
|
double result = 0.0;
|
|
uInt32 delta_counter;
|
|
if (device->params.direction == COUNT_DOWN)
|
|
delta_counter = prv->counter_value - cur->counter_value;
|
|
else
|
|
delta_counter = cur->counter_value - prv->counter_value;
|
|
double delta_timer = time_diff(&cur->timestamp, &prv->timestamp);
|
|
result = 1.0 * delta_counter / delta_timer;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* given two samples, compute the average rate
|
|
*/
|
|
static double compute_average(DEVICE* device, SAMPLE* cur, SAMPLE* prv)
|
|
{
|
|
double result = 0.0;
|
|
if (cur == prv)
|
|
result = cur->counter_rate;
|
|
else
|
|
result = compute_rate(device, cur, prv);
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
void device_send(DEVICE* device, int n)
|
|
{
|
|
SAMPLE* sp = cur_sample(device);
|
|
BUFFER buffer;
|
|
buffer.length = 0;
|
|
snprintf(buffer.body, sizeof(buffer.body),
|
|
"Time: %s, Count: %10llu, Delta: %6d, Time: %8.6f, Rate: %8.2f, Ave: %8.2f\r\n",
|
|
make_timestamp(&sp->timestamp),
|
|
sp->counter_value,
|
|
sp->count_delta,
|
|
sp->time_delta,
|
|
sp->counter_rate,
|
|
sp->average_rate);
|
|
buffer.length = strlen(buffer.body);
|
|
sock_send(n, &buffer);
|
|
}
|
|
|
|
void device_read(DEVICE* device, int n)
|
|
{
|
|
SAMPLE* sp = cur_sample(device);
|
|
BUFFER buffer;
|
|
buffer.length = 0;
|
|
snprintf(buffer.body, sizeof(buffer.body),
|
|
"READ %c%c%c%c %s %.6f %10llu %8.2f\r\n",
|
|
device->state == device_idle ? 'I' :
|
|
device->state == device_stopped ? 'S' :
|
|
device->state == device_running ? 'R' :
|
|
device->state == device_paused ? 'P' : '?',
|
|
device->terminal_due ? 'T' : ' ',
|
|
device->range_error == 0 ? ' ' : 'R',
|
|
device->range_gated ? 'G' : ' ',
|
|
make_timestamp(&sp->timestamp),
|
|
device->accumulated.tv_sec + .000001 * device->accumulated.tv_usec,
|
|
sp->counter_value,
|
|
sp->counter_rate);
|
|
buffer.length = strlen(buffer.body);
|
|
sock_send(n, &buffer);
|
|
}
|
|
|
|
void device_print(DEVICE* device, FILE* fd)
|
|
{
|
|
SAMPLE* sp = cur_sample(device);
|
|
fprintf(fd, "Time: %s, Count: %10llu, Delta: %6d, Time: %8.6f, Rate: %8.2f, Ave: %8.2f\r\n",
|
|
make_timestamp(&sp->timestamp),
|
|
sp->counter_value,
|
|
sp->count_delta,
|
|
sp->time_delta,
|
|
sp->counter_rate,
|
|
sp->average_rate);
|
|
fflush(fd);
|
|
}
|
|
|
|
/*
|
|
* Finalise the current sample and move on to the next
|
|
*/
|
|
void device_sample(DEVICE* device)
|
|
{
|
|
SAMPLE* psp = cur_sample(device);
|
|
dbg_printf(0, "device_sample: %4d\r\n"
|
|
" polls: %4d\r\n"
|
|
" time: %4s\r\n"
|
|
" counter: %10llu\r\n"
|
|
" count64: %10llu\r\n"
|
|
" c_delta: %d\r\n"
|
|
" t_delta: %6.3f\r\n"
|
|
" rate: %10g\n",
|
|
device->sample_index,
|
|
psp->num_polls,
|
|
make_timestamp(&psp->timestamp),
|
|
psp->counter_value,
|
|
psp->count64,
|
|
psp->count_delta,
|
|
psp->time_delta,
|
|
psp->counter_rate);
|
|
device->sample_timer = device->current_time;
|
|
++device->sample_counter;
|
|
|
|
if (++device->sample_index >= SAMPLE_ARRAY_SZ)
|
|
device->sample_index = 0;
|
|
SAMPLE* sp = cur_sample(device);
|
|
*sp = *psp;
|
|
sp->valid = true;
|
|
sp->num_polls = 0;
|
|
sp->sample_counter = device->sample_counter;
|
|
sp->poll_counter = device->poll_counter;
|
|
}
|
|
|
|
void device_report(DEVICE* device)
|
|
{
|
|
dbg_printf(0, "device_report\n");
|
|
/*
|
|
* Set the time for this report
|
|
*/
|
|
device->report_timer = device->current_time;
|
|
BUFFER buffer;
|
|
SAMPLE* sp;
|
|
sp = &device->report;
|
|
char* str = make_timestamp(&sp->timestamp);
|
|
snprintf(buffer.body, sizeof(buffer.body),
|
|
"%s (%6.3f), %10llu (%8d), %8.2f (%8.2f,%8.2f,%8.2f)\r\n",
|
|
str,
|
|
sp->time_delta,
|
|
sp->counter_value,
|
|
sp->count_delta,
|
|
sp->counter_rate,
|
|
sp->minimum_rate,
|
|
sp->average_rate,
|
|
sp->maximum_rate);
|
|
buffer.length = strlen(buffer.body);
|
|
//fputs(buffer.body, stdout);
|
|
sock_report(&buffer, 1, device);
|
|
snprintf(buffer.body, sizeof(buffer.body),
|
|
"REPORT %s %10llu %8.2f (%8.2f,%8.2f,%8.2f)\r\n",
|
|
str,
|
|
sp->counter_value,
|
|
sp->counter_rate,
|
|
sp->minimum_rate,
|
|
sp->average_rate,
|
|
sp->maximum_rate);
|
|
buffer.length = strlen(buffer.body);
|
|
//fputs(buffer.body, stdout);
|
|
sock_report(&buffer, 2, device);
|
|
}
|
|
|
|
/**
|
|
* Initialise the counter
|
|
*
|
|
* Initialise all of the control data associated with the logical counter.
|
|
*
|
|
* Create a 64-bit physical counter and start it.
|
|
*/
|
|
int device_init(DEVICE** cpp, char* name)
|
|
{
|
|
int error = 0;
|
|
char errBuff[2048]={'\0'};
|
|
SAMPLE* sp = NULL;
|
|
DEVICE* device = (DEVICE*) malloc(sizeof(DEVICE));
|
|
*cpp = device;
|
|
memset(device, 0, sizeof(DEVICE));
|
|
strncpy(device->name, name, sizeof(device->name));
|
|
device->params.poll_period = 1; /* milliseconds between polls */
|
|
device->params.sample_period = 1000; /* polls between sample calcs */
|
|
device->params.report_period = 3; /* samples between reports */
|
|
device->state = device_stopped;
|
|
struct timeval now;
|
|
gettimeofday(&now, NULL);
|
|
device->current_time = now;
|
|
device->previous_time = now;
|
|
device->sample_timer = now;
|
|
device->report_timer = now;
|
|
HWARE_TEST(hware_ctor(name, &device->private_data));
|
|
sp = cur_sample(device);
|
|
sp->timestamp = now;
|
|
sp->counter_value = device->current_count;
|
|
sp->valid = true;
|
|
device_sample(device);
|
|
return 0;
|
|
Error:
|
|
hware_errmsg(errBuff, sizeof(errBuff));
|
|
printf("DAQmx Error: %s\n", errBuff);
|
|
return error;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Start the logical counter
|
|
*
|
|
* Read the value of the physical counter and set the state to running
|
|
*/
|
|
int device_start(DEVICE *device)
|
|
{
|
|
int error = 0;
|
|
char errBuff[2048]={'\0'};
|
|
struct timeval now;
|
|
int value;
|
|
SAMPLE* sp = NULL;
|
|
SAMPLE* psp = NULL;
|
|
PARAMETERS* pp = &device->params;
|
|
/* start the counter object */
|
|
gettimeofday(&now, NULL);
|
|
device->current_time = now;
|
|
device->start_time = device->current_time;
|
|
device->current_count = device->params.initial_count;
|
|
device->accumulated.tv_sec = 0;
|
|
device->accumulated.tv_usec = 0;
|
|
device->poll_counter = 0;
|
|
device->sample_counter = 0;
|
|
device->terminal_due = false;
|
|
device->state = device_running;
|
|
device->previous_time = device->current_time;
|
|
dbg_printf(0, "Setting input line to %d\n", pp->source);
|
|
HWARE_TEST(hware_source(device->private_data, pp->source));
|
|
device->source = pp->source;
|
|
HWARE_TEST(hware_read(device->private_data, &device->count64));
|
|
sp = cur_sample(device);
|
|
sp->timestamp = device->current_time;
|
|
sp->counter_value = device->current_count;
|
|
psp = prv_sample(device, 1);
|
|
psp->timestamp = device->current_time;
|
|
psp->counter_value = device->current_count;
|
|
make_report(device);
|
|
if (pp->output_line == 1)
|
|
value = 1;
|
|
else if (pp->output_line == 2)
|
|
value = 0;
|
|
else
|
|
value = -1;
|
|
dbg_printf(0, "Setting output line to %d\n", value);
|
|
HWARE_TEST(hware_outp(device->private_data, value));
|
|
return error;
|
|
Error:
|
|
device_errmsg(errBuff, sizeof(errBuff));
|
|
printf("DAQmx Error: %s\n", errBuff);
|
|
return error;
|
|
}
|
|
|
|
int device_stop(DEVICE *device)
|
|
{
|
|
int error = 0;
|
|
char errBuff[2048]={'\0'};
|
|
PARAMETERS* pp = &device->params;
|
|
int value;
|
|
device->stop_time = device->current_time;
|
|
device->state = device_stopped;
|
|
if (pp->output_line == 1)
|
|
value = 0;
|
|
else if (pp->output_line == 2)
|
|
value = 1;
|
|
else
|
|
value = -1;
|
|
dbg_printf(0, "Setting output line to %d\n", value);
|
|
HWARE_TEST(hware_outp(device->private_data, value));
|
|
dbg_printf(0, "Setting input line to %d\n", pp->source);
|
|
HWARE_TEST(hware_source(device->private_data, pp->source));
|
|
device->source = pp->source;
|
|
return error;
|
|
Error:
|
|
device_errmsg(errBuff, sizeof(errBuff));
|
|
printf("DAQmx Error: %s\n", errBuff);
|
|
return error;
|
|
}
|
|
|
|
int device_pause(DEVICE *device)
|
|
{
|
|
if (device->state == device_running)
|
|
device->state = device_paused;
|
|
return 0;
|
|
}
|
|
|
|
int device_resume(DEVICE *device)
|
|
{
|
|
if (device->state == device_paused)
|
|
device->state = device_running;
|
|
return 0;
|
|
}
|
|
|
|
int device_command(void* counter, const char* command)
|
|
{
|
|
DEVICE* device = static_cast<DEVICE*>(counter);
|
|
if (strncasecmp(command, "pause", 5) == 0)
|
|
return device_pause(device);
|
|
else if (strncasecmp(command, "continue", 8) == 0)
|
|
return device_resume(device);
|
|
else if (strncasecmp(command, "resume", 6) == 0)
|
|
return device_resume(device);
|
|
else if (strncasecmp(command, "start", 6) == 0)
|
|
return device_start(device);
|
|
else if (strncasecmp(command, "stop", 4) == 0)
|
|
return device_stop(device);
|
|
return 0;
|
|
}
|
|
|
|
static void device_event(DEVICE *device, const char* event)
|
|
{
|
|
BUFFER buffer;
|
|
sprintf(buffer.body, "EVENT %s %s\r\n",
|
|
make_timestamp(&device->current_time),
|
|
event);
|
|
buffer.length = strlen(buffer.body);
|
|
dbg_printf(0, "%s", buffer.body);
|
|
//sock_report(&buffer, 0);
|
|
sock_report(&buffer, 1, device);
|
|
sock_report(&buffer, 2, device);
|
|
}
|
|
|
|
static void device_range_check(DEVICE* device, int mode)
|
|
{
|
|
PARAMETERS* pp = &device->params;
|
|
if (pp->range_check_enable)
|
|
{
|
|
if (pp->range_mode == mode)
|
|
{
|
|
double test;
|
|
SAMPLE* sp = cur_sample(device);
|
|
if (mode == 1)
|
|
test = sp->counter_rate;
|
|
else if (mode == 2)
|
|
test = sp->counter_rate;
|
|
else
|
|
test = device->report.average_rate;
|
|
if (pp->range_low > 0 && pp->range_low > test)
|
|
{
|
|
if (device->range_error != 1)
|
|
device_event(device, "RANGE OUT LOW");
|
|
device->range_error = 1;
|
|
if (pp->range_gate_enable)
|
|
device->range_gated = true;
|
|
else
|
|
device->range_gated = false;
|
|
}
|
|
else if (pp->range_high > 0 && pp->range_high < test)
|
|
{
|
|
if (device->range_error != 2)
|
|
device_event(device, "RANGE OUT HIGH");
|
|
device->range_error = 2;
|
|
if (pp->range_gate_enable)
|
|
device->range_gated = true;
|
|
else
|
|
device->range_gated = false;
|
|
}
|
|
else
|
|
{
|
|
if (device->range_error != 0)
|
|
device_event(device, "RANGE IN");
|
|
device->range_error = 0;
|
|
device->range_gated = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* If range check has been disabled while in error - reset */
|
|
if (device->range_error != 0)
|
|
device_event(device, "RANGE IN");
|
|
device->range_error = 0;
|
|
device->range_gated = false;
|
|
}
|
|
}
|
|
|
|
static void device_test_term(DEVICE* device)
|
|
{
|
|
PARAMETERS* pp = &device->params;
|
|
SAMPLE* sp = cur_sample(device);
|
|
SAMPLE* psp = prv_sample(device, 1);
|
|
|
|
if (!device->terminal_due)
|
|
{
|
|
if (pp->terminal_check_type == 1)
|
|
{
|
|
if (pp->direction == COUNT_DOWN)
|
|
{
|
|
/*
|
|
* decremented to or through terminal
|
|
*/
|
|
// TODO FIXME improve wraparound handling
|
|
if ((sp->counter_value <= pp->terminal_count &&
|
|
psp->counter_value > pp->terminal_count) ||
|
|
(sp->counter_value > psp->counter_value &&
|
|
psp->counter_value > pp->terminal_count))
|
|
{
|
|
device->terminal_due = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* incremented to or through terminal
|
|
*/
|
|
// TODO FIXME improve wraparound handling
|
|
if (
|
|
#if 1
|
|
sp->counter_value >= pp->terminal_count
|
|
#else
|
|
(sp->counter_value >= pp->terminal_count &&
|
|
psp->counter_value < pp->terminal_count) ||
|
|
(sp->counter_value < psp->counter_value &&
|
|
psp->counter_value > pp->terminal_count)
|
|
#endif
|
|
)
|
|
{
|
|
device->terminal_due = true;
|
|
}
|
|
}
|
|
}
|
|
else if (pp->terminal_check_type == 2)
|
|
{
|
|
if ((uint64) device->accumulated.tv_sec >= pp->terminal_count)
|
|
device->terminal_due = true;
|
|
}
|
|
if (device->terminal_due)
|
|
{
|
|
device_event(device, "TERMINAL");
|
|
make_report(device);
|
|
device_stop(device);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* poll the physical counter
|
|
*/
|
|
int device_poll(DEVICE* device)
|
|
{
|
|
PARAMETERS* pp = &device->params;
|
|
char errBuff[2048]={'\0'};
|
|
unsigned long long current_count_local;
|
|
int count_delta_local;
|
|
int error=0;
|
|
SAMPLE* sp = NULL;
|
|
SAMPLE* psp = NULL;
|
|
|
|
#if 0
|
|
dbg_printf(0, "%d:-%s %s %.3f %s %.3f %4d\n",
|
|
idx,
|
|
make_timestamp(&device->current_time),
|
|
make_timestamp(&device->sample_timer),
|
|
device_time_to_next_sample(device),
|
|
make_timestamp(&device->report_timer),
|
|
device_time_to_next_report(device),
|
|
device->sample_index);
|
|
#endif
|
|
/* read the value from the hardware counter to a temp */
|
|
++device->poll_counter;
|
|
HWARE_TEST(hware_read(device->private_data, ¤t_count_local));
|
|
dbg_printf(0, "device_poll = %llu @ %s\n",
|
|
current_count_local,
|
|
make_timestamp(&device->current_time));
|
|
|
|
sp = cur_sample(device);
|
|
psp = prv_sample(device, 1);
|
|
|
|
/* calculate the number since last time and save new value */
|
|
count_delta_local = current_count_local - device->count64;
|
|
device->count64 = current_count_local;
|
|
sp->num_polls += 1;
|
|
/*
|
|
* If the counter is running and not gated increment the count and runtime
|
|
*/
|
|
if (device->state == device_running &&
|
|
!(device->params.range_gate_enable && device->range_gated))
|
|
{
|
|
if (device->params.direction == COUNT_DOWN)
|
|
{
|
|
device->current_count -= count_delta_local;
|
|
}
|
|
else
|
|
{
|
|
device->current_count += count_delta_local;
|
|
}
|
|
/*
|
|
* Add the time difference to the accumulated time
|
|
*/
|
|
device->accumulated.tv_sec += device->current_time.tv_sec - sp->timestamp.tv_sec;
|
|
/* prevent negative tv_usec by borrowing one second in microseconds */
|
|
device->accumulated.tv_usec += 1000000;
|
|
device->accumulated.tv_usec += device->current_time.tv_usec;
|
|
device->accumulated.tv_usec -= sp->timestamp.tv_usec;
|
|
if (device->accumulated.tv_usec >= 1000000)
|
|
{
|
|
/* carry the seconds */
|
|
device->accumulated.tv_sec += device->accumulated.tv_usec / 1000000;
|
|
device->accumulated.tv_usec %= 1000000;
|
|
}
|
|
/* pay back the borrowed second */
|
|
device->accumulated.tv_sec -= 1;
|
|
}
|
|
|
|
/* calculate and check the count-rate between polls */
|
|
sp->count_delta = device->count64 - sp->count64;
|
|
sp->time_delta = time_diff(&device->current_time, &sp->timestamp);
|
|
sp->counter_rate = (double) sp->count_delta / sp->time_delta;
|
|
device_range_check(device, 2); /* poll range check */
|
|
|
|
device->previous_time = device->current_time;
|
|
|
|
/* save counter values in the sample */
|
|
sp->counter_value = device->current_count;
|
|
sp->count64 = device->count64;
|
|
sp->timestamp = device->current_time;
|
|
|
|
/* calculate the count-rate for this sample so far */
|
|
sp->count_delta = sp->count64 - psp->count64;
|
|
sp->time_delta = time_diff(&sp->timestamp, &psp->timestamp);
|
|
sp->counter_rate = (double) sp->count_delta / sp->time_delta;
|
|
|
|
/* test for the occurrence of a terminal event */
|
|
device_test_term(device);
|
|
|
|
/* check if it is time to roll the sample */
|
|
if (device_time_to_next_sample(device) <= 0)
|
|
{
|
|
/* check if it is time to roll the report */
|
|
if (device_time_to_next_report(device) <= 0)
|
|
{
|
|
make_report(device);
|
|
device_range_check(device, 0); /* report range check */
|
|
device_report(device);
|
|
}
|
|
device_range_check(device, 1); /* sample range check */
|
|
device_sample(device);
|
|
}
|
|
|
|
/* set the source line */
|
|
if (device->source != pp->source)
|
|
{
|
|
device->source = pp->source;
|
|
HWARE_TEST(hware_source(device->private_data, device->source));
|
|
}
|
|
|
|
/* set the line filter */
|
|
if (device->filter != pp->filter)
|
|
{
|
|
device->filter = pp->filter;
|
|
HWARE_TEST(hware_filter(device->private_data, device->filter));
|
|
}
|
|
|
|
/* drive the output line */
|
|
if (device->output_line != pp->output_line)
|
|
{
|
|
int value;
|
|
device->output_line = pp->output_line;
|
|
if (pp->output_line == 1)
|
|
{
|
|
if (device->state == device_running || device->state == device_paused)
|
|
value = 1;
|
|
else
|
|
value = 0;
|
|
}
|
|
else if (pp->output_line == 2)
|
|
{
|
|
if (device->state == device_running || device->state == device_paused)
|
|
value = 0;
|
|
else
|
|
value = 1;
|
|
}
|
|
else
|
|
value = -1;
|
|
HWARE_TEST(hware_outp(device->private_data, value));
|
|
}
|
|
return error;
|
|
Error:
|
|
device_errmsg(errBuff, sizeof(errBuff));
|
|
printf("DAQmx Error: %s\n", errBuff);
|
|
return error;
|
|
}
|
|
|
|
void device_term(DEVICE* device)
|
|
{
|
|
if (device->private_data)
|
|
{
|
|
hware_dtor(&device->private_data);
|
|
device->private_data = NULL;
|
|
}
|
|
device->state = device_idle;
|
|
}
|
|
|
|
bool device_fatal(int error)
|
|
{
|
|
return hware_failed(error);
|
|
}
|
|
|
|
void device_errmsg(char* buff, int len)
|
|
{
|
|
hware_errmsg(buff, len);
|
|
}
|
|
|
|
double device_time_to_next_report(DEVICE* device)
|
|
{
|
|
uint64 last_report;
|
|
uint64 timeofday;
|
|
int timeout;
|
|
struct timeval now;
|
|
now = device->current_time;
|
|
last_report = 1000 * (uint64) device->report_timer.tv_sec;
|
|
last_report += (uint64) device->report_timer.tv_usec / 1000;
|
|
timeofday = 1000 * (uint64) now.tv_sec;
|
|
timeofday += (uint64) now.tv_usec / 1000;
|
|
timeout = device->params.poll_period * device->params.sample_period *
|
|
device->params.report_period;
|
|
if ((last_report / timeout) != (timeofday / timeout))
|
|
return 0.0;
|
|
timeout = timeout - timeofday % timeout;
|
|
return 0.001 * timeout;
|
|
}
|
|
|
|
double device_time_to_next_sample(DEVICE* device)
|
|
{
|
|
uint64 last_sample;
|
|
uint64 timeofday;
|
|
int timeout;
|
|
struct timeval now;
|
|
now = device->current_time;
|
|
last_sample = 1000 * (uint64) device->sample_timer.tv_sec;
|
|
last_sample += (uint64) device->sample_timer.tv_usec / 1000;
|
|
timeofday = 1000 * (uint64) now.tv_sec;
|
|
timeofday += (uint64) now.tv_usec / 1000;
|
|
timeout = device->params.poll_period * device->params.sample_period;
|
|
if ((last_sample / timeout) != (timeofday / timeout))
|
|
return 0.0;
|
|
timeout = timeout - timeofday % timeout;
|
|
return 0.001 * timeout;
|
|
}
|