/**************************************************************************
* Description: handles recurring task
* Returns: none
* Notes: none
**************************************************************************/
static void bacnet_test_task(void)
{
static unsigned index = 0;
uint32_t instance;
float float_value;
uint16_t adc_value;
instance = Analog_Input_Index_To_Instance(index);
if (!Analog_Input_Out_Of_Service(instance)) {
adc_value = adc_result_12bit(index);
float_value = adc_value;
float_value /= 4095;
Analog_Input_Present_Value_Set(instance, float_value);
}
index++;
if (index >= MAX_ANALOG_INPUTS) {
index = 0;
}
}
static time_t uci_Update(
time_t ucimodtime,
BACNET_OBJECT_TYPE update_object_type,
int ucirewrite
)
{
char *section;
char *type;
time_t chk_mtime = 0;
struct uci_context *ctx;
int uci_idx;
/* update Value from uci */
section = NULL;
type = NULL;
if (false) {
section = NULL;
type = NULL;
#if defined(AI)
} else if (update_object_type == OBJECT_ANALOG_INPUT) {
section = "bacnet_ai";
type = "ai";
#endif
#if defined(AO)
} else if (update_object_type == OBJECT_ANALOG_OUTPUT) {
section = "bacnet_ao";
type = "ao";
#endif
#if defined(AV)
} else if (update_object_type == OBJECT_ANALOG_VALUE) {
section = "bacnet_av";
type = "av";
#endif
#if defined(BI)
} else if (update_object_type == OBJECT_BINARY_INPUT) {
section = "bacnet_bi";
type = "bi";
#endif
#if defined(BO)
} else if (update_object_type == OBJECT_BINARY_OUTPUT) {
section = "bacnet_bo";
type = "bo";
#endif
#if defined(BV)
} else if (update_object_type == OBJECT_BINARY_VALUE) {
section = "bacnet_bv";
type = "bv";
#endif
#if defined(MI)
} else if (update_object_type == OBJECT_MULTI_STATE_INPUT) {
section = "bacnet_mi";
type = "mi";
#endif
#if defined(MO)
} else if (update_object_type == OBJECT_MULTI_STATE_OUTPUT) {
section = "bacnet_mo";
type = "mo";
#endif
#if defined(MSV)
} else if (update_object_type == OBJECT_MULTI_STATE_VALUE) {
section = "bacnet_mv";
type = "mv";
#endif
} else {
return 0;
}
if ( ucirewrite == 0) {
chk_mtime = ucimodtime;
#if PRINT_ENABLED
printf("rewrite type: %s\n", type);
#endif
} else {
chk_mtime = check_uci_update(section, ucimodtime);
}
if(chk_mtime != 0) {
sleep(1);
ucimodtime = chk_mtime;
#if PRINT_ENABLED
printf("Config changed, reloading %s\n",section);
#endif
ctx = ucix_init(section);
struct uci_itr_ctx itr;
value_tuple_t *cur;
itr.list = NULL;
itr.section = section;
itr.ctx = ctx;
ucix_for_each_section_type(ctx, section, type,
(void *)load_value, &itr);
for( cur = itr.list; cur; cur = cur->next ) {
uci_idx = atoi(cur->idx);
#if PRINT_ENABLED
printf("section %s idx %i \n", section, uci_idx);
#endif
if (false) {
}
/* update Analog Input from uci */
#if defined(AI)
else if (update_object_type == OBJECT_ANALOG_INPUT) {
float ai_val, ai_pval;
ai_val = strtof(cur->value,NULL);
ai_pval = Analog_Input_Present_Value(uci_idx);
if ( ai_val != ai_pval ) {
Analog_Input_Present_Value_Set(uci_idx,ai_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Analog_Input_Out_Of_Service(uci_idx))
Analog_Input_Out_Of_Service_Set(uci_idx,0);
if (Analog_Input_Reliability(uci_idx))
Analog_Input_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Analog_Input_Out_Of_Service_Set(uci_idx,1);
Analog_Input_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Analog Output from uci */
#if defined(AO)
else if (update_object_type == OBJECT_ANALOG_OUTPUT) {
float ao_val, ao_pval;
ao_val = strtof(cur->value,NULL);
ao_pval = Analog_Output_Present_Value(uci_idx);
if ( ao_val != ao_pval ) {
Analog_Output_Present_Value_Set(uci_idx,ao_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Analog_Output_Out_Of_Service(uci_idx))
Analog_Output_Out_Of_Service_Set(uci_idx,0);
if (Analog_Output_Reliability(uci_idx))
Analog_Output_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Analog_Output_Out_Of_Service_Set(uci_idx,1);
Analog_Output_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Analog Value from uci */
#if defined(AV)
else if (update_object_type == OBJECT_ANALOG_VALUE) {
float av_val, av_pval;
av_val = strtof(cur->value,NULL);
av_pval = Analog_Value_Present_Value(uci_idx);
if ( av_val != av_pval ) {
Analog_Value_Present_Value_Set(uci_idx,av_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Analog_Value_Out_Of_Service(uci_idx))
Analog_Value_Out_Of_Service_Set(uci_idx,0);
if (Analog_Value_Reliability(uci_idx))
Analog_Value_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Analog_Value_Out_Of_Service_Set(uci_idx,1);
Analog_Value_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Binary Input from uci */
#if defined(BI)
else if (update_object_type == OBJECT_BINARY_INPUT) {
int bi_val, bi_pval;
bi_val = atoi(cur->value);
bi_pval = Binary_Input_Present_Value(uci_idx);
if ( bi_val != bi_pval ) {
Binary_Input_Present_Value_Set(uci_idx,bi_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Binary_Input_Out_Of_Service(uci_idx))
Binary_Input_Out_Of_Service_Set(uci_idx,0);
if (Binary_Input_Reliability(uci_idx))
Binary_Input_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Binary_Input_Out_Of_Service_Set(uci_idx,1);
Binary_Input_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Binary Output from uci */
#if defined(BO)
else if (update_object_type == OBJECT_BINARY_OUTPUT) {
int bo_val, bo_pval;
bo_val = atoi(cur->value);
bo_pval = Binary_Output_Present_Value(uci_idx);
if ( bo_val != bo_pval ) {
Binary_Output_Present_Value_Set(uci_idx,bo_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Binary_Output_Out_Of_Service(uci_idx))
Binary_Output_Out_Of_Service_Set(uci_idx,0);
if (Binary_Output_Reliability(uci_idx))
Binary_Output_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Binary_Output_Out_Of_Service_Set(uci_idx,1);
Binary_Output_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Binary Value from uci */
#if defined(BV)
else if (update_object_type == OBJECT_BINARY_VALUE) {
int bv_val, bv_pval;
bv_val = atoi(cur->value);
bv_pval = Binary_Value_Present_Value(uci_idx);
if ( bv_val != bv_pval ) {
Binary_Value_Present_Value_Set(uci_idx,bv_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Binary_Value_Out_Of_Service(uci_idx))
Binary_Value_Out_Of_Service_Set(uci_idx,0);
if (Binary_Value_Reliability(uci_idx))
Binary_Value_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Binary_Value_Out_Of_Service_Set(uci_idx,1);
Binary_Value_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Multistate Input from uci */
#if defined(MSI)
else if (update_object_type == OBJECT_MULTI_STATE_INPUT) {
int msi_val, msi_pval;
msi_val = atoi(cur->value);
msi_pval = Multistate_Input_Present_Value(uci_idx);
if ( msi_val != msi_pval ) {
Multistate_Input_Present_Value_Set(uci_idx,msi_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Multistate_Input_Out_Of_Service(uci_idx))
Multistate_Input_Out_Of_Service_Set(uci_idx,0);
if (Multistate_Input_Reliability(uci_idx))
Multistate_Input_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Multistate_Input_Out_Of_Service_Set(uci_idx,1);
Multistate_Input_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Multistate Output from uci */
#if defined(MSO)
else if (update_object_type == OBJECT_MULTI_STATE_OUTPUT) {
int mso_val, mso_pval;
mso_val = atoi(cur->value);
mso_pval = Multistate_Output_Present_Value(uci_idx);
if ( mso_val != mso_pval ) {
Multistate_Output_Present_Value_Set(uci_idx,mso_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Multistate_Output_Out_Of_Service(uci_idx))
Multistate_Output_Out_Of_Service_Set(uci_idx,0);
if (Multistate_Output_Reliability(uci_idx))
Multistate_Output_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Multistate_Output_Out_Of_Service_Set(uci_idx,1);
Multistate_Output_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
/* update Multistate Value from uci */
#if defined(MSV)
else if (update_object_type == OBJECT_MULTI_STATE_VALUE) {
int msv_val, msv_pval;
msv_val = atoi(cur->value);
msv_pval = Multistate_Value_Present_Value(uci_idx);
if ( msv_val != msv_pval ) {
Multistate_Value_Present_Value_Set(uci_idx,msv_val,16);
}
if (cur->Out_Of_Service == 0) {
if (Multistate_Value_Out_Of_Service(uci_idx))
Multistate_Value_Out_Of_Service_Set(uci_idx,0);
if (Multistate_Value_Reliability(uci_idx))
Multistate_Value_Reliability_Set(uci_idx,
RELIABILITY_NO_FAULT_DETECTED);
} else {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("Out_Of_Service\n");
#endif
Multistate_Value_Out_Of_Service_Set(uci_idx,1);
Multistate_Value_Reliability_Set(uci_idx,
RELIABILITY_COMMUNICATION_FAILURE);
}
}
#endif
}
ucix_cleanup(ctx);
}
/* update end */
return ucimodtime;
}
/* returns true if successful */
bool Analog_Input_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data)
{
bool status = false; /* return value */
int len = 0;
BACNET_APPLICATION_DATA_VALUE value;
/* decode the some of the request */
len =
bacapp_decode_application_data(wp_data->application_data,
wp_data->application_data_len, &value);
/* FIXME: len < application_data_len: more data? */
if (len < 0) {
/* error while decoding - a value larger than we can handle */
wp_data->error_class = ERROR_CLASS_PROPERTY;
wp_data->error_code = ERROR_CODE_VALUE_OUT_OF_RANGE;
return false;
}
/* only array properties can have array options */
if ((wp_data->object_property != PROP_EVENT_TIME_STAMPS) &&
(wp_data->array_index != BACNET_ARRAY_ALL)) {
wp_data->error_class = ERROR_CLASS_PROPERTY;
wp_data->error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY;
return false;
}
switch ((int) wp_data->object_property) {
case PROP_PRESENT_VALUE:
status = WPValidateArgType(&value, BACNET_APPLICATION_TAG_REAL,
&wp_data->error_class, &wp_data->error_code);
if (status) {
if (Analog_Input_Out_Of_Service(wp_data->object_instance)) {
Analog_Input_Present_Value_Set(wp_data->object_instance,
value.type.Real);
} else {
wp_data->error_class = ERROR_CLASS_PROPERTY;
wp_data->error_code = ERROR_CODE_WRITE_ACCESS_DENIED;
status = false;
}
}
break;
case PROP_OUT_OF_SERVICE:
status =
WPValidateArgType(&value, BACNET_APPLICATION_TAG_BOOLEAN,
&wp_data->error_class, &wp_data->error_code);
if (status) {
Analog_Input_Out_Of_Service_Set(
wp_data->object_instance,
value.type.Boolean);
}
break;
case PROP_UNITS:
status =
WPValidateArgType(&value, BACNET_APPLICATION_TAG_ENUMERATED,
&wp_data->error_class, &wp_data->error_code);
if (status) {
Analog_Input_Out_Of_Service_Set(
wp_data->object_instance,
value.type.Enumerated);
}
break;
case PROP_OBJECT_IDENTIFIER:
case PROP_OBJECT_NAME:
case PROP_OBJECT_TYPE:
case PROP_STATUS_FLAGS:
case PROP_EVENT_STATE:
wp_data->error_class = ERROR_CLASS_PROPERTY;
wp_data->error_code = ERROR_CODE_WRITE_ACCESS_DENIED;
break;
default:
wp_data->error_class = ERROR_CLASS_PROPERTY;
wp_data->error_code = ERROR_CODE_UNKNOWN_PROPERTY;
break;
}
return status;
}
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0;
time_t elapsed_seconds = 0;
time_t last_seconds = 0;
time_t current_seconds = 0;
time_t timeout_seconds = 0;
uint8_t invoke_id = 0;
bool found = false;
BACNET_READ_RANGE_DATA Request;
int iCount = 0;
int iType = 0;
int iKey;
int iSecondsRun = 0;
if (((argc != 2) && (argc != 3)) || ((argc >= 2) &&
(strcmp(argv[1], "--help") == 0))) {
printf("%s\n", argv[0]);
printf("Usage: %s server local-device-instance\r\n or\r\n"
" %s remote-device-instance\r\n"
"--help gives further information\r\n",
filename_remove_path(argv[0]), filename_remove_path(argv[0]));
if ((argc > 1) && (strcmp(argv[1], "--help") == 0)) {
printf("\r\nServer mode:\r\n\r\n"
"<local-device-instance> determins the device id of the application\r\n"
"when running as the server end of a test set up. The Server simply\r\n"
"returns dummy data for each ReadRange request\r\n\r\n"
"Non server:\r\n\r\n"
"<remote-device-instance> indicates the device id of the server\r\n"
"instance of the application.\r\n"
"The non server application will send a series of ReadRange requests to the\r\n"
"server with examples of different range types.\r\n");
}
return 0;
}
/* decode the command line parameters */
if (_stricmp(argv[1], "server") == 0)
Target_Mode = 1;
else
Target_Mode = 0;
Target_Device_Object_Instance = strtol(argv[1 + Target_Mode], NULL, 0);
if (Target_Device_Object_Instance > BACNET_MAX_INSTANCE) {
fprintf(stderr, "device-instance=%u - it must be less than %u\r\n",
Target_Device_Object_Instance, BACNET_MAX_INSTANCE);
return 1;
}
/* setup my info */
if (Target_Mode)
Device_Set_Object_Instance_Number(Target_Device_Object_Instance);
else
Device_Set_Object_Instance_Number(BACNET_MAX_INSTANCE);
Init_Objects();
address_init();
Init_Service_Handlers();
dlenv_init();
atexit(datalink_cleanup);
/* configure the timeout values */
last_seconds = time(NULL);
timeout_seconds = (apdu_timeout() / 1000) * apdu_retries();
if (Target_Mode) {
#if defined(WIN32) || defined(__BORLANDC__)
printf("Entering server mode. press q to quit program\r\n\r\n");
#else
printf("Entering server mode.\r\n\r\n");
#endif
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
putchar('.'); /* Just to show that time is passing... */
tsm_timer_milliseconds(((current_seconds -
last_seconds) * 1000));
address_cache_timer(current_seconds - last_seconds);
trend_log_timer(current_seconds - last_seconds);
last_seconds = current_seconds;
/* Change the analog input PVs for testing purposes */
for (iCount = 0; iCount < Analog_Input_Count(); iCount++) {
Analog_Input_Present_Value_Set(iCount,
iSecondsRun * (iCount + 1));
}
iSecondsRun++;
}
#if defined(WIN32) || defined(__BORLANDC__)
if (_kbhit()) {
iKey = toupper(_getch());
if (iKey == 'Q') {
printf("\r\nExiting program now\r\n");
exit(0);
}
}
#endif
}
} else {
/* try to bind with the device */
found =
address_bind_request(Target_Device_Object_Instance, &max_apdu,
&Target_Address);
if (!found) {
Send_WhoIs(Target_Device_Object_Instance,
Target_Device_Object_Instance);
}
/* loop forever */
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
tsm_timer_milliseconds(((current_seconds -
last_seconds) * 1000));
address_cache_timer(current_seconds - last_seconds);
trend_log_timer(current_seconds - last_seconds);
last_seconds = current_seconds;
}
if (Error_Detected)
break;
/* wait until the device is bound, or timeout and quit */
if (!found)
found =
address_bind_request(Target_Device_Object_Instance,
&max_apdu, &Target_Address);
if (found) {
if (invoke_id == 0) { /* Safe to send a new request */
switch (iCount) {
case 0: /* Pass - should read up to 1st 10 */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 1;
Request.Count = 10;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 1: /* Pass - should read entries 2 and 3 */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefSeqNum = 3;
Request.Count = -2;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 2: /* Fail - By Time not supported */
Request.RequestType = RR_BY_TIME;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF;
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 10;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 3: /* Fail - array not supported */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 1;
Request.Count = 10;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 1;
break;
case 4: /* Fail - By Sequence not supported */
Request.RequestType = RR_BY_SEQUENCE;
Request.Range.RefSeqNum = 1;
Request.Count = 10;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 5: /* Fail Bytime not supported and array not supported */
Request.RequestType = RR_BY_TIME;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 10;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 1;
break;
case 6: /* Pass - should try to return all entries */
Request.RequestType = RR_READ_ALL;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 7: /* Fail - array not supported */
Request.RequestType = RR_READ_ALL;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 1;
break;
case 8: /* Pass - should read 1st 1 */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 1;
Request.Count = 1;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 9: /* Pass - should read 1st 2 */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 1;
Request.Count = 2;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 10: /* Pass - should read 2nd and 3rd */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 2;
Request.Count = 2;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
case 11: /* Pass - should read 2nd up to 11th */
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 2;
Request.Count = 10;
Request.object_type = OBJECT_DEVICE;
Request.object_instance =
Target_Device_Object_Instance;
Request.object_property =
PROP_DEVICE_ADDRESS_BINDING;
Request.array_index = 0;
break;
}
invoke_id =
Send_ReadRange_Request(Target_Device_Object_Instance,
&Request);
} else if (tsm_invoke_id_free(invoke_id)) {
if (iCount != 11) {
iCount++;
invoke_id = 0;
} else {
break;
}
} else if (tsm_invoke_id_failed(invoke_id)) {
fprintf(stderr, "\rError: TSM Timeout!\r\n");
tsm_free_invoke_id(invoke_id);
/* Error_Detected = true; */
/* try again or abort? */
invoke_id = 0; /* Try next operation */
/* break; */
}
} else {
/* increment timer - exit if timed out */
elapsed_seconds += (current_seconds - last_seconds);
if (elapsed_seconds > timeout_seconds) {
printf("\rError: APDU Timeout!\r\n");
/* Error_Detected = true;
break; */
invoke_id = 0;
}
}
/* keep track of time for next check */
last_seconds = current_seconds;
}
}
if (Error_Detected)
return 1;
return 0;
}