linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add output line drive and partial hardware sync

Browse Source 
r1112 | dcl | 2006-09-07 16:48:08 +1000 (Thu, 07 Sep 2006) | 2 lines
This commit is contained in:
Douglas Clowes
2006-09-07 16:48:08 +10:00
parent f855eea8bf
commit 99ebb2e910
7 changed files with 535 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
site_ansto/hardsup/Monitor/cntr.c
View File

@@ -269,6 +269,8 @@ int cntr_start(COUNTER *cp)
int error = 0;
char errBuff[2048]={'\0'};
struct timeval now;
int value;
PARAMETERS* pp = &cp->params;
/* start the counter object */
gettimeofday(&now, NULL);
cp->current_time = now;
@@ -283,6 +285,14 @@ int cntr_start(COUNTER *cp)
cp->previous_time = cp->current_time;
HCTR_TEST(hctr_read(cp->private_data, &cp->count64));
make_report(cp);
if (pp->output_line == 1)
value = 1;
else if (pp->output_line == 2)
value = 0;
else
value = -1;
dprintf(0, "Setting output line to %d\n", value);
HCTR_TEST(hctr_outp(cp->private_data, value));
return error;
Error:
cntr_errmsg(errBuff, sizeof(errBuff));
@@ -292,9 +302,25 @@ Error:
int cntr_stop(COUNTER *cp)
{
int error = 0;
char errBuff[2048]={'\0'};
PARAMETERS* pp = &cp->params;
int value;
cp->stop_time = cp->current_time;
cp->state = counter_stopped;
return 0;
if (pp->output_line == 1)
value = 0;
else if (pp->output_line == 2)
value = 1;
else
value = -1;
dprintf(0, "Setting output line to %d\n", value);
HCTR_TEST(hctr_outp(cp->private_data, value));
return error;
Error:
cntr_errmsg(errBuff, sizeof(errBuff));
printf("DAQmx Error: %s\n", errBuff);
return error;
}
int cntr_pause(COUNTER *cp)
@@ -434,6 +460,7 @@ static void cntr_test_term(COUNTER* cp)
*/
int cntr_poll(COUNTER* cp)
{
PARAMETERS* pp = &cp->params;
char errBuff[2048]={'\0'};
unsigned long long current_count_local;
int count_delta_local;
@@ -519,6 +546,30 @@ int cntr_poll(COUNTER* cp)
cntr_range_check(cp, 1); /* sample range check */
cntr_sample(cp);
}
/* drive the output line */
if (cp->output_line != pp->output_line)
{
int value;
cp->output_line = pp->output_line;
if (pp->output_line == 1)
{
if (cp->state == counter_running || cp->state == counter_paused)
value = 1;
else
value = 0;
}
else if (pp->output_line == 2)
{
if (cp->state == counter_running || cp->state == counter_paused)
value = 0;
else
value = 1;
}
else
value = -1;
HCTR_TEST(hctr_outp(cp->private_data, value));
}
return error;
Error:
cntr_errmsg(errBuff, sizeof(errBuff));

2
site_ansto/hardsup/Monitor/cntr.h
View File

@@ -91,6 +91,8 @@ typedef struct counter_t
uint64 count64;
/** Control parameters */
PARAMETERS params;
/** active value of parameter output_line */
int output_line;
struct counter_private_t* private_data;
} COUNTER, *pCOUNTER;

13
site_ansto/hardsup/Monitor/display.c
View File

@@ -191,18 +191,27 @@ void put_form(int n)
add_double(&buffer, "Range Low", "range_low", pp->range_low);
add_double(&buffer, "Range High", "range_high", pp->range_high);
add_select_begin(&buffer, "Range Event", "re_check");
add_option(&buffer, "Disabled", "disabled", pp->range_check_enable == false);
add_option(&buffer, "Enabled", "enabled", pp->range_check_enable == true);
add_option(&buffer, "Disabled", "Disabled", pp->range_check_enable == false);
add_select_end(&buffer);
add_select_begin(&buffer, "Range Gate", "range_gate");
add_option(&buffer, "Disabled", "disabled", pp->range_gate_enable == false);
add_option(&buffer, "Enabled", "enabled", pp->range_gate_enable == true);
add_option(&buffer, "Disabled", "Disabled", pp->range_gate_enable == false);
add_select_end(&buffer);
add_select_begin(&buffer, "Range Mode", "range_mode");
add_option(&buffer, "Report", "0", pp->range_mode == 0);
add_option(&buffer, "Sample", "1", pp->range_mode == 1);
add_option(&buffer, "Poll", "2", pp->range_mode == 2);
add_select_end(&buffer);
add_select_begin(&buffer, "Output Line", "output");
add_option(&buffer, "Disabled", "disabled", pp->output_line == 0);
add_option(&buffer, "Enabled", "enabled", pp->output_line == 1);
add_option(&buffer, "Inverted", "inverted", pp->output_line == 2);
add_select_end(&buffer);
add_select_begin(&buffer, "Sync", "sync");
add_option(&buffer, "Internal", "internal", pp->sync == false);
add_option(&buffer, "External", "external", pp->sync == true);
add_select_end(&buffer);
bp = &buffer.body[buffer.length];
snprintf(bp, sizeof(buffer.body) - buffer.length,
"<tr><td>\r\n"

212
site_ansto/hardsup/Monitor/hctr.c
View File

@@ -1,12 +1,13 @@
#include "hctr.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <NIDAQmx.h>
#define DAQmxErrChk(functionCall) \
if( DAQmxFailed(error=(functionCall)) ) \
goto Error; \
else
do { if( DAQmxFailed(error=(functionCall)) ) \
goto Error; } while(0);
/**
* This structure encapsulates the data that is private to
@@ -21,14 +22,76 @@ typedef struct counter_private_t
uInt32 count32;
/** extended 64-bit counter value */
unsigned long long count64;
/** NIDAQ device number of card */
int device_number;
/** NI counter number on card */
int counter_number;
/** true if using external sync else timer based sampling */
bool sync;
/** sync line number on the card */
int sync_line_number;
/** output line number on the card */
int output_line_number;
/** NIDAQ opaque task handle for digital output */
TaskHandle taskHandle_dout;
} COUNTER_PRIVATE;
typedef struct mapping_t {
int cntr_num;
int sync_num;
int outp_num;
} MAPPING;
MAPPING mapping[8] = {
{ 0, 37, 36 },
{ 1, 33, 32 },
{ 2, 29, 28 },
{ 3, 25, 24 },
{ 4, 21, 20 },
{ 5, 17, 16 },
{ 6, 13, 12 },
{ 7, 9, 8 }
};
int hctr_ctor(const char* device_name, pHCTR* ptr)
{
int error = 0;
bool flag = false;
char text_string[] = "dev1/ctr0";
const char *name;
const char *text;
*ptr = (COUNTER_PRIVATE*) malloc(sizeof(COUNTER_PRIVATE));
memset(*ptr, 0, sizeof(COUNTER_PRIVATE));
name = device_name;
text = text_string;
while (name && *name)
{
if (isspace(*name))
++name;
else if (*name >= '0' && *name <= '7')
{
if (flag)
{
(*ptr)->counter_number = *name - '0';
(*ptr)->sync_line_number = mapping[(*ptr)->counter_number].sync_num;
(*ptr)->output_line_number = mapping[(*ptr)->counter_number].outp_num;
}
else
{
(*ptr)->device_number = *name - '0';
flag = true;
}
}
else if (tolower(*name) != *text)
{
/* TODO error */
break;
}
++name;
++text;
}
/*********************************************/
// Create a DAQmx task to hold the counter
/*********************************************/
@@ -73,6 +136,140 @@ Error:
return error;
}
int make_dout_task(pHCTR ptr)
{
int error = 0;
char port_range[40];
/*********************************************/
// Create a DAQmx task to hold the counter
/*********************************************/
DAQmxErrChk (DAQmxCreateTask("",&ptr->taskHandle_dout));
/*********************************************/
// Create the digital channel within the task
/*********************************************/
snprintf(port_range, sizeof(port_range), "DEV%d/LINE%d",
ptr->device_number, ptr->counter_number);
DAQmxErrChk (DAQmxCreateDOChan(ptr->taskHandle_dout,
port_range,
"",
DAQmx_Val_ChanPerLine));
/*********************************************/
// Start the DAQmx task
/*********************************************/
DAQmxErrChk (DAQmxStartTask(ptr->taskHandle_dout));
Error:
return error;
}
int hctr_outp(pHCTR hctr, int value)
{
int error = 0;
uInt8 data;
if (value < 0) {
if (hctr->taskHandle_dout != 0) {
data = 0;
DAQmxWriteDigitalLines(hctr->taskHandle_dout,
1,
1,
10.0,
DAQmx_Val_GroupByChannel,
&data,
NULL,
NULL);
/*********************************************/
// DAQmx Stop Code
/*********************************************/
DAQmxStopTask(hctr->taskHandle_dout);
DAQmxClearTask(hctr->taskHandle_dout);
hctr->taskHandle_dout = 0;
}
return error;
}
if (hctr->taskHandle_dout == 0)
DAQmxErrChk (make_dout_task(hctr));
if (value > 0)
data = 1;
else
data = 0;
#if 0
DAQmxErrChk (
DAQmxWriteDigitalLines(hctr->taskHandle_dout,
1,
1,
10.0,
DAQmx_Val_GroupByChannel,
&data,
NULL,
NULL));
#else
DAQmxErrChk (
DAQmxWriteDigitalScalarU32(hctr->taskHandle_dout,
1,
10.0,
data,
NULL));
#endif
Error:
return error;
}
void hctr_sync(pHCTR hctr, bool external)
{
int error = 0;
char device_name[40];
if (hctr->sync != external)
{
hctr->sync = external;
/*********************************************/
// DAQmx Stop Code
/*********************************************/
DAQmxStopTask(hctr->taskHandle);
DAQmxClearTask(hctr->taskHandle);
/*********************************************/
// Create a DAQmx task to hold the counter
/*********************************************/
DAQmxErrChk (DAQmxCreateTask("",&hctr->taskHandle));
/*********************************************/
// Create a DAQmx counter within the task
/*********************************************/
hctr->count32 = 0;
snprintf(device_name, sizeof(device_name), "dev%d/ctr%d",
hctr->device_number, hctr->counter_number);
DAQmxErrChk (
DAQmxCreateCICountEdgesChan(hctr->taskHandle,
device_name,
"",
DAQmx_Val_Rising,
hctr->count32,
DAQmx_Val_CountUp));
if (external)
{
char str[40];
snprintf(str, sizeof(str), "dev%d/PFI%d",
hctr->device_number, hctr->sync_line_number);
DAQmxErrChk (
DAQmxCfgSampClkTiming(hctr->taskHandle,
str,
10000,
DAQmx_Val_Rising,
DAQmx_Val_ContSamps,
10000));
}
/*********************************************/
// Start the DAQmx task
/*********************************************/
DAQmxErrChk (DAQmxStartTask(hctr->taskHandle));
}
Error:
return;
}
int hctr_dtor(pHCTR* hctr)
{
if( hctr && *hctr && (*hctr)->taskHandle!=0 )
@@ -84,6 +281,15 @@ int hctr_dtor(pHCTR* hctr)
DAQmxClearTask((*hctr)->taskHandle);
}
(*hctr)->taskHandle = 0;
if( hctr && *hctr && (*hctr)->taskHandle_dout!=0 )
{
/*********************************************/
// DAQmx Stop Code
/*********************************************/
DAQmxStopTask((*hctr)->taskHandle_dout);
DAQmxClearTask((*hctr)->taskHandle_dout);
}
(*hctr)->taskHandle_dout = 0;
free (*hctr);
*hctr = NULL;
return 0;

19
site_ansto/hardsup/Monitor/hctr.h
View File

@@ -38,6 +38,25 @@ int hctr_ctor(const char* device_name, pHCTR* ptr);
*/
int hctr_read(pHCTR hctr, unsigned long long* value);
/**
* Enables external sync on designated (up/down) line
*
* \param hctr pointer to opaque private data structure
* \param value to be written to the associated line
* < 0 disconnect
* = 0 logic low
* > 0 logic high
*/
int hctr_outp(pHCTR hctr, int value);
/**
* Enables external sync on designated (up/down) line
*
* \param hctr pointer to opaque private data structure
* \param external true for external sync, false for internal
*/
void hctr_sync(pHCTR hctr, bool external);
/**
* Destroy the 64-bit counter
*

298
site_ansto/hardsup/Monitor/params.c
View File

@@ -15,6 +15,8 @@
#define CMD_RE_CHECK 10
#define CMD_RANGE_GATE 11
#define CMD_RANGE_MODE 12
#define CMD_OUTPUT 13
#define CMD_SYNC 14
#define TXT_DIRECTION "DIRECTION"
#define TXT_SCAN "SCAN"
@@ -28,6 +30,8 @@
#define TXT_RE_CHECK "RE_CHECK"
#define TXT_RANGE_GATE "RANGE_GATE"
#define TXT_RANGE_MODE "RANGE_MODE"
#define TXT_OUTPUT "OUTPUT"
#define TXT_SYNC "SYNC"
static struct param_command_t {
int cmd;
@@ -45,18 +49,30 @@ static struct param_command_t {
{CMD_RE_CHECK, TXT_RE_CHECK},
{CMD_RANGE_GATE, TXT_RANGE_GATE},
{CMD_RANGE_MODE, TXT_RANGE_MODE},
{CMD_OUTPUT, TXT_OUTPUT},
{CMD_SYNC, TXT_SYNC},
{0, NULL}
};
#define NUM_CMDS (sizeof(param_command)/sizeof(param_command[0]))
static int name_to_command(char* name)
{
int i;
for (i = 0; i < NUM_CMDS; ++i) {
if (param_command[i].txt == NULL)
return -1;
if (strcasecmp(name, param_command[i].txt) == 0)
return param_command[i].cmd;
}
return -1;
}
bool param_set(pPARAMETERS pp, char* name, char* value)
{
bool result = false;
switch (name[0])
{
case 'd':
case 'D':
if (strcasecmp(name, TXT_DIRECTION) == 0)
switch (name_to_command(name))
{
case CMD_DIRECTION:
result = true;
dprintf(0, "Direction=%s", pp->direction ? "Down" : "Up");
if (strcasecmp(value, "down") == 0)
@@ -64,22 +80,27 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
else
pp->direction = COUNT_UP;
dprintf(0, "=>%s\n", pp->direction ? "Down" : "Up");
}
break;
case 'i':
case 'I':
if (strcasecmp(name, TXT_INITIAL) == 0)
{
case CMD_INITIAL:
result = true;
dprintf(0, "Initial=%llu", pp->initial_count);
pp->initial_count = strtoull(value, NULL, 10);
dprintf(0, "=>%llu\n", pp->initial_count);
}
break;
case 'r':
case 'R':
if (strcasecmp(name, TXT_REPORT) == 0)
{
case CMD_OUTPUT:
result = true;
dprintf(0, "Direction=%s", pp->output_line == 2 ? "Inverted":
pp->output_line == 1 ? "Enabled" : "Disabled");
if (strcasecmp(value, "enabled") == 0)
pp->output_line = 1;
else if (strcasecmp(value, "inverted") == 0)
pp->output_line = 2;
else
pp->output_line = 0;
dprintf(0, "=>%s\n", pp->output_line == 2 ? "Inverted":
pp->output_line == 1 ? "Enabled" : "Disabled");
break;
case CMD_REPORT:
result = true;
dprintf(0, "Report=%d", pp->report_period);
pp->report_period = strtol(value, NULL, 10);
@@ -88,9 +109,8 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
else if (pp->report_period > 1000)
pp->report_period = 1000;
dprintf(0, "=>%d\n", pp->report_period);
}
else if (strcasecmp(name, TXT_RANGE_MODE) == 0)
{
break;
case CMD_RANGE_MODE:
result = true;
dprintf(0, "range_mode=%d", pp->range_mode);
pp->range_mode = strtol(value, NULL, 10);
@@ -99,9 +119,8 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
else if (pp->range_mode > 2)
pp->range_mode = 0;
dprintf(0, "=>%d\n", pp->range_mode);
}
else if (strcasecmp(name, TXT_RANGE_GATE) == 0)
{
break;
case CMD_RANGE_GATE:
result = true;
dprintf(0, "range_gate=%s",
pp->range_gate_enable ? "Enabled" : "Disabled");
@@ -111,9 +130,8 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
pp->range_gate_enable = false;
dprintf(0, "=>%s\n",
pp->range_gate_enable ? "Enabled" : "Disabled");
}
else if (strcasecmp(name, TXT_RE_CHECK) == 0)
{
break;
case CMD_RE_CHECK:
result = true;
dprintf(0, "RE_Check=%s",
pp->range_check_enable ? "Enabled" : "Disabled");
@@ -123,30 +141,24 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
pp->range_check_enable = false;
dprintf(0, "=>%s\n",
pp->range_check_enable ? "Enabled" : "Disabled");
}
else if (strcasecmp(name, TXT_RANGE_HIGH) == 0)
{
break;
case CMD_RANGE_HIGH:
result = true;
dprintf(0, "RangeHigh=%g", pp->range_high);
pp->range_high = strtod(value, NULL);
if (pp->range_high < 0.0)
pp->range_high = 0.0;
dprintf(0, "=>%g\n", pp->range_high);
}
else if (strcasecmp(name, TXT_RANGE_LOW) == 0)
{
break;
case CMD_RANGE_LOW:
result = true;
dprintf(0, "RangeLow=%g", pp->range_low);
pp->range_low = strtod(value, NULL);
if (pp->range_low < 0.0)
pp->range_low = 0.0;
dprintf(0, "=>%g\n", pp->range_low);
}
break;
case 's':
case 'S':
if (strcasecmp(name, TXT_SCAN) == 0)
{
case CMD_SCAN:
result = true;
dprintf(0, "Scan=%d", pp->poll_period);
pp->poll_period = strtol(value, NULL, 10);
@@ -155,9 +167,8 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
else if (pp->poll_period > 1000)
pp->poll_period = 1000;
dprintf(0, "=>%d\n", pp->poll_period);
}
else if (strcasecmp(name, TXT_SAMPLE) == 0)
{
break;
case CMD_SAMPLE:
result = true;
dprintf(0, "Sample=%d", pp->sample_period);
pp->sample_period = strtol(value, NULL, 10);
@@ -166,19 +177,23 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
else if (pp->sample_period > 1000)
pp->sample_period = 1000;
dprintf(0, "=>%d\n", pp->sample_period);
}
break;
case 't':
case 'T':
if (strcasecmp(name, TXT_TERMINAL) == 0)
{
case CMD_SYNC:
result = true;
dprintf(0, "Sync=%s", pp->sync ? "External" : "Internal");
if (strcasecmp(value, "external") == 0)
pp->sync = true;
else
pp->sync = false;
dprintf(0, "=>%s\n", pp->sync ? "External" : "Internal");
break;
case CMD_TERMINAL:
result = true;
dprintf(0, "Sample=%llu", pp->terminal_count);
pp->terminal_count = strtoull(value, NULL, 10);
dprintf(0, "=>%llu\n", pp->terminal_count);
}
else if (strcasecmp(name, TXT_TE_CHECK) == 0)
{
break;
case CMD_TE_CHECK:
result = true;
dprintf(0, "TE_Check=%s",
pp->terminal_check_type == 0 ? "None" :
@@ -194,7 +209,6 @@ bool param_set(pPARAMETERS pp, char* name, char* value)
pp->terminal_check_type == 0 ? "None" :
pp->terminal_check_type == 1 ? "Counter" :
pp->terminal_check_type == 2 ? "Timer" : "Unknown");
}
break;
default:
dprintf(0, "Unknown Parameter: \"%s\" = \"%s\"\n", name, value);
@@ -257,10 +271,90 @@ bool param_get_cmd(pPARAMETERS pp, char* cmd, int n)
}
name[len] = '\0';
switch (name[0])
switch (name_to_command(name))
{
case 'a':
case 'A':
case CMD_DIRECTION:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->direction ? "Down" : "Up");
break;
case CMD_INITIAL:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%llu", name,
pp->initial_count);
break;
case CMD_OUTPUT:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->output_line == 2 ? "Inverted":
pp->output_line == 1 ? "Enabled" : "Disabled");
break;
case CMD_REPORT:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->report_period);
break;
case CMD_RANGE_GATE:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->range_gate_enable ? "Enabled" : "Disabled");
break;
case CMD_RE_CHECK:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->range_check_enable ? "Enabled" : "Disabled");
break;
case CMD_RANGE_MODE:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->range_mode);
break;
case CMD_RANGE_HIGH:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%g", name,
pp->range_high);
break;
case CMD_RANGE_LOW:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%g", name,
pp->range_low);
break;
case CMD_SCAN:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->poll_period);
break;
case CMD_SAMPLE:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->sample_period);
break;
case CMD_TERMINAL:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%llu", name,
pp->terminal_count);
break;
case CMD_TE_CHECK:
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->terminal_check_type == 0 ? "None" :
pp->terminal_check_type == 1 ? "Counter" :
pp->terminal_check_type == 2 ? "Timer" : "Unknown");
break;
default:
if (strcasecmp(name, "ALL") == 0)
{
int i;
@@ -269,109 +363,7 @@ bool param_get_cmd(pPARAMETERS pp, char* cmd, int n)
strcpy(buffer.body, "OK");
result = true;
}
break;
case 'd':
case 'D':
if (strcasecmp(name, TXT_DIRECTION) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->direction ? "Down" : "Up");
}
break;
case 'i':
case 'I':
if (strcasecmp(name, TXT_INITIAL) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%llu", name,
pp->initial_count);
}
break;
case 'r':
case 'R':
if (strcasecmp(name, TXT_REPORT) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->report_period);
}
else if (strcasecmp(name, TXT_RANGE_GATE) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->range_gate_enable ? "Enabled" : "Disabled");
}
else if (strcasecmp(name, TXT_RE_CHECK) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->range_check_enable ? "Enabled" : "Disabled");
}
else if (strcasecmp(name, TXT_RANGE_MODE) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->range_mode);
}
else if (strcasecmp(name, TXT_RANGE_HIGH) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%g", name,
pp->range_high);
}
else if (strcasecmp(name, TXT_RANGE_LOW) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%g", name,
pp->range_low);
}
break;
case 's':
case 'S':
if (strcasecmp(name, TXT_SCAN) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->poll_period);
}
else if (strcasecmp(name, TXT_SAMPLE) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%d", name,
pp->sample_period);
}
break;
case 't':
case 'T':
if (strcasecmp(name, TXT_TERMINAL) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%llu", name,
pp->terminal_count);
}
else if (strcasecmp(name, TXT_TE_CHECK) == 0)
{
result = true;
snprintf(buffer.body, sizeof(buffer.body),
"GET %s=%s", name,
pp->terminal_check_type == 0 ? "None" :
pp->terminal_check_type == 1 ? "Counter" :
pp->terminal_check_type == 2 ? "Timer" : "Unknown");
}
break;
default:
else
dprintf(0, "Unknown GET Parameter: \"%s\"\n", name);
break;
}

4
site_ansto/hardsup/Monitor/params.h
View File

@@ -35,6 +35,10 @@ typedef struct parameter_t
bool range_gate_enable;
/** mode = 0:report, 1:sample, 2:poll */
int range_mode;
/** output = 0:disabled, 1:enabled, 2:inverted */
int output_line;
/** hardware_sync false:internal, true:external */
bool sync;
} PARAMETERS, *pPARAMETERS;