/** Main function of server demo.
*
* @see Device_Set_Object_Instance_Number, dlenv_init, Send_I_Am,
* datalink_receive, npdu_handler,
* dcc_timer_seconds, bvlc_maintenance_timer,
* Load_Control_State_Machine_Handler, handler_cov_task,
* tsm_timer_milliseconds
*
* @param argc [in] Arg count.
* @param argv [in] Takes one argument: the Device Instance #.
* @return 0 on success.
*/
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 1; /* milliseconds */
time_t last_seconds = 0;
time_t current_seconds = 0;
uint32_t elapsed_seconds = 0;
uint32_t elapsed_milliseconds = 0;
uint32_t address_binding_tmr = 0;
uint32_t recipient_scan_tmr = 0;
int uci_id = 0;
float val_f, pval_f;
int val_i, pval_i;
struct uci_context *ctx;
time_t chk_mtime = 0;
time_t ucimodtime_bacnet_bi = 0;
time_t ucimodtime_bacnet_av = 0;
time_t ucimodtime_bacnet_ao = 0;
time_t ucimodtime_bacnet_mv = 0;
int uci_idx = 0;
char *section;
char *type;
char *pEnv = NULL;
int rewrite;
pEnv = getenv("UCI_SECTION");
ctx = ucix_init("bacnet_dev");
#if PRINT_ENABLED
if(!ctx)
fprintf(stderr, "Failed to load config file bacnet_dev\n");
#endif
uci_id = ucix_get_option_int(ctx, "bacnet_dev", pEnv, "id", 0);
if (uci_id != 0) {
Device_Set_Object_Instance_Number(uci_id);
} else {
/* allow the device ID to be set */
if (argc > 1)
Device_Set_Object_Instance_Number(strtol(argv[1], NULL, 0));
}
if(ctx)
ucix_cleanup(ctx);
#if PRINT_ENABLED
printf("BACnet Server with uci\n" "BACnet Stack Version %s\n"
"BACnet Device ID: %u\n" "Max APDU: %d\n", BACnet_Version,
Device_Object_Instance_Number(), MAX_APDU);
#endif
/* load any static address bindings to show up
in our device bindings list */
address_init();
Init_Service_Handlers();
dlenv_init();
atexit(datalink_cleanup);
/* configure the timeout values */
last_seconds = time(NULL);
/* broadcast an I-Am on startup */
Send_I_Am(&Handler_Transmit_Buffer[0]);
/* loop forever */
for (;;) {
/* input */
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 */
elapsed_seconds = (uint32_t) (current_seconds - last_seconds);
if (elapsed_seconds) {
last_seconds = current_seconds;
dcc_timer_seconds(elapsed_seconds);
#if defined(BACDL_BIP) && BBMD_ENABLED
bvlc_maintenance_timer(elapsed_seconds);
#endif
dlenv_maintenance_timer(elapsed_seconds);
Load_Control_State_Machine_Handler();
elapsed_milliseconds = elapsed_seconds * 1000;
handler_cov_timer_seconds(elapsed_seconds);
tsm_timer_milliseconds(elapsed_milliseconds);
trend_log_timer(elapsed_seconds);
#if defined(INTRINSIC_REPORTING)
Device_local_reporting();
#endif
}
handler_cov_task();
/* scan cache address */
address_binding_tmr += elapsed_seconds;
if (address_binding_tmr >= 60) {
address_cache_timer(address_binding_tmr);
address_binding_tmr = 0;
}
#if defined(INTRINSIC_REPORTING)
/* try to find addresses of recipients */
recipient_scan_tmr += elapsed_seconds;
if (recipient_scan_tmr >= NC_RESCAN_RECIPIENTS_SECS) {
Notification_Class_find_recipient();
recipient_scan_tmr = 0;
}
#endif
#if false
/* output */
rewrite++;
if (rewrite>10000) {
rewrite=0;
printf("rewrite %i\n", rewrite);
}
/* update Analog Value from uci */
section = "bacnet_av";
type = "av";
chk_mtime = 0;
chk_mtime = check_uci_update(section, ucimodtime_bacnet_av);
if ( rewrite == 0) {
chk_mtime = ucimodtime_bacnet_av;
#if PRINT_ENABLED
printf("rewrite %i\n", rewrite);
#endif
}
if(chk_mtime != 0) {
sleep(1);
ucimodtime_bacnet_av = 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 ) {
#if PRINT_ENABLED
printf("section %s idx %s \n", section, cur->idx);
#endif
val_f = strtof(cur->value,NULL);
uci_idx = atoi(cur->idx);
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("value %s\n",cur->value);
#endif
pval_f = Analog_Value_Present_Value(uci_idx);
if ( val_f != pval_f ) {
Analog_Value_Present_Value_Set(uci_idx,val_f,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);
}
}
ucix_cleanup(ctx);
}
/* update end */
/* update Analog Value from uci */
section = "bacnet_ao";
type = "ao";
chk_mtime = 0;
chk_mtime = check_uci_update(section, ucimodtime_bacnet_ao);
if ( rewrite == 0) {
chk_mtime = ucimodtime_bacnet_ao;
}
if(chk_mtime != 0) {
sleep(1);
ucimodtime_bacnet_ao = 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 ) {
#if PRINT_ENABLED
printf("section %s idx %s \n", section, cur->idx);
#endif
val_f = strtof(cur->value,NULL);
uci_idx = atoi(cur->idx);
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("value %s\n",cur->value);
#endif
pval_f = Analog_Output_Present_Value(uci_idx);
if ( val_f != pval_f ) {
Analog_Output_Present_Value_Set(uci_idx,val_f,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);
}
}
ucix_cleanup(ctx);
}
/* update end */
/* update Multistate Value from uci */
section = "bacnet_mv";
type = "mv";
chk_mtime = 0;
chk_mtime = check_uci_update(section, ucimodtime_bacnet_mv);
if ( rewrite == 0) {
chk_mtime = ucimodtime_bacnet_mv;
}
if(chk_mtime != 1) {
ucimodtime_bacnet_mv = 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 ) {
#if PRINT_ENABLED
printf("section %s idx %s \n", section, cur->idx);
#endif
val_f = strtof(cur->value,NULL);
uci_idx = atoi(cur->idx);
if (val_f || !strcmp(cur->value, "0")) {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("value %s\n",cur->value);
#endif
pval_f = Multistate_Value_Present_Value(uci_idx);
if ( val_f != pval_f ) {
Multistate_Value_Present_Value_Set(uci_idx,val_f,16);
}
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);
}
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);
}
}
ucix_cleanup(ctx);
}
/* update end */
/* update Binary Input from uci */
section = "bacnet_bi";
type = "bi";
chk_mtime = 0;
chk_mtime = check_uci_update(section, ucimodtime_bacnet_bi);
if ( rewrite == 0) {
chk_mtime = ucimodtime_bacnet_bi;
}
if(chk_mtime != 0) {
ucimodtime_bacnet_bi = 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 ) {
#if PRINT_ENABLED
printf("section %s idx %s \n", section, cur->idx);
#endif
if (cur->value) {
#if PRINT_ENABLED
printf("idx %s ",cur->idx);
printf("value %s\n",cur->value);
#endif
val_i = atoi(cur->value);
uci_idx = atoi(cur->idx);
pval_i = Binary_Input_Present_Value(uci_idx);
if ( val_i != pval_i ) {
Binary_Input_Present_Value_Set(uci_idx,val_i,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);
}
}
ucix_cleanup(ctx);
}
/* update end */
#endif
/* blink LEDs, Turn on or off outputs, etc */
}
return 0;
}
/* return apdu len, or -1 on error */
int Analog_Value_Encode_Property_APDU(
uint8_t * apdu,
uint32_t object_instance,
BACNET_PROPERTY_ID property,
int32_t array_index,
BACNET_ERROR_CLASS * error_class,
BACNET_ERROR_CODE * error_code)
{
int len = 0;
int apdu_len = 0; /* return value */
BACNET_BIT_STRING bit_string;
BACNET_CHARACTER_STRING char_string;
float real_value = (float) 1.414;
unsigned object_index = 0;
unsigned i = 0;
bool state = false;
Analog_Value_Init();
switch (property) {
case PROP_OBJECT_IDENTIFIER:
apdu_len =
encode_application_object_id(&apdu[0], OBJECT_ANALOG_VALUE,
object_instance);
break;
case PROP_OBJECT_NAME:
case PROP_DESCRIPTION:
characterstring_init_ansi(&char_string,
Analog_Value_Name(object_instance));
apdu_len =
encode_application_character_string(&apdu[0], &char_string);
break;
case PROP_OBJECT_TYPE:
apdu_len =
encode_application_enumerated(&apdu[0], OBJECT_ANALOG_VALUE);
break;
case PROP_PRESENT_VALUE:
real_value = Analog_Value_Present_Value(object_instance);
apdu_len = encode_application_real(&apdu[0], real_value);
break;
case PROP_STATUS_FLAGS:
bitstring_init(&bit_string);
bitstring_set_bit(&bit_string, STATUS_FLAG_IN_ALARM, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_FAULT, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_OUT_OF_SERVICE, false);
apdu_len = encode_application_bitstring(&apdu[0], &bit_string);
break;
case PROP_EVENT_STATE:
apdu_len =
encode_application_enumerated(&apdu[0], EVENT_STATE_NORMAL);
break;
case PROP_OUT_OF_SERVICE:
#if 0
object_index = Analog_Value_Instance_To_Index(object_instance);
state = Analog_Value_Out_Of_Service[object_index];
#endif
apdu_len = encode_application_boolean(&apdu[0], false);
break;
case PROP_UNITS:
apdu_len = encode_application_enumerated(&apdu[0], UNITS_PERCENT);
break;
#if 0
case PROP_PRIORITY_ARRAY:
/* Array element zero is the number of elements in the array */
if (array_index == 0)
apdu_len =
encode_application_unsigned(&apdu[0], BACNET_MAX_PRIORITY);
/* if no index was specified, then try to encode the entire list */
/* into one packet. */
else if (array_index == BACNET_ARRAY_ALL) {
object_index = Analog_Value_Instance_To_Index(object_instance);
for (i = 0; i < BACNET_MAX_PRIORITY; i++) {
/* FIXME: check if we have room before adding it to APDU */
if (Present_Value[object_index][i] == ANALOG_LEVEL_NULL)
len = encode_application_null(&apdu[apdu_len]);
else {
real_value = Present_Value[object_index][i];
len =
encode_application_real(&apdu[apdu_len],
real_value);
}
/* add it if we have room */
if ((apdu_len + len) < MAX_APDU)
apdu_len += len;
else {
*error_class = ERROR_CLASS_SERVICES;
*error_code = ERROR_CODE_NO_SPACE_FOR_OBJECT;
apdu_len = -1;
break;
}
}
} else {
object_index = Analog_Value_Instance_To_Index(object_instance);
if (array_index <= BACNET_MAX_PRIORITY) {
if (Present_Value[object_index][array_index - 1] ==
ANALOG_LEVEL_NULL)
apdu_len = encode_application_null(&apdu[0]);
else {
real_value =
Present_Value[object_index][array_index - 1];
apdu_len =
encode_application_real(&apdu[0], real_value);
}
} else {
*error_class = ERROR_CLASS_PROPERTY;
*error_code = ERROR_CODE_INVALID_ARRAY_INDEX;
apdu_len = -1;
}
}
break;
case PROP_RELINQUISH_DEFAULT:
real_value = ANALOG_RELINQUISH_DEFAULT;
apdu_len = encode_application_real(&apdu[0], real_value);
break;
#endif
default:
*error_class = ERROR_CLASS_PROPERTY;
*error_code = ERROR_CODE_UNKNOWN_PROPERTY;
apdu_len = -1;
break;
}
return apdu_len;
}
void Analog_Value_Intrinsic_Reporting(
uint32_t object_instance)
{
#if defined(INTRINSIC_REPORTING)
BACNET_EVENT_NOTIFICATION_DATA event_data;
BACNET_CHARACTER_STRING msgText;
ANALOG_VALUE_DESCR *CurrentAV;
unsigned int object_index;
uint8_t FromState = 0;
uint8_t ToState;
float ExceededLimit = 0.0f;
float PresentVal = 0.0f;
bool SendNotify = false;
object_index = Analog_Value_Instance_To_Index(object_instance);
if (object_index < MAX_ANALOG_VALUES)
CurrentAV = &AV_Descr[object_index];
else
return;
/* check limits */
if (!CurrentAV->Limit_Enable)
return; /* limits are not configured */
if (CurrentAV->Ack_notify_data.bSendAckNotify) {
/* clean bSendAckNotify flag */
CurrentAV->Ack_notify_data.bSendAckNotify = false;
/* copy toState */
ToState = CurrentAV->Ack_notify_data.EventState;
#if PRINT_ENABLED
fprintf(stderr, "Send Acknotification for (%s,%d).\n",
bactext_object_type_name(OBJECT_ANALOG_VALUE), object_instance);
#endif /* PRINT_ENABLED */
characterstring_init_ansi(&msgText, "AckNotification");
/* Notify Type */
event_data.notifyType = NOTIFY_ACK_NOTIFICATION;
/* Send EventNotification. */
SendNotify = true;
} else {
/* actual Present_Value */
PresentVal = Analog_Value_Present_Value(object_instance);
FromState = CurrentAV->Event_State;
switch (CurrentAV->Event_State) {
case EVENT_STATE_NORMAL:
/* A TO-OFFNORMAL event is generated under these conditions:
(a) the Present_Value must exceed the High_Limit for a minimum
period of time, specified in the Time_Delay property, and
(b) the HighLimitEnable flag must be set in the Limit_Enable property, and
(c) the TO-OFFNORMAL flag must be set in the Event_Enable property. */
if ((PresentVal > CurrentAV->High_Limit) &&
((CurrentAV->Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) ==
EVENT_HIGH_LIMIT_ENABLE) &&
((CurrentAV->Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) ==
EVENT_ENABLE_TO_OFFNORMAL)) {
if (!CurrentAV->Remaining_Time_Delay)
CurrentAV->Event_State = EVENT_STATE_HIGH_LIMIT;
else
CurrentAV->Remaining_Time_Delay--;
break;
}
/* A TO-OFFNORMAL event is generated under these conditions:
(a) the Present_Value must exceed the Low_Limit plus the Deadband
for a minimum period of time, specified in the Time_Delay property, and
(b) the LowLimitEnable flag must be set in the Limit_Enable property, and
(c) the TO-NORMAL flag must be set in the Event_Enable property. */
if ((PresentVal < CurrentAV->Low_Limit) &&
((CurrentAV->Limit_Enable & EVENT_LOW_LIMIT_ENABLE) ==
EVENT_LOW_LIMIT_ENABLE) &&
((CurrentAV->Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) ==
EVENT_ENABLE_TO_OFFNORMAL)) {
if (!CurrentAV->Remaining_Time_Delay)
CurrentAV->Event_State = EVENT_STATE_LOW_LIMIT;
else
CurrentAV->Remaining_Time_Delay--;
break;
}
/* value of the object is still in the same event state */
CurrentAV->Remaining_Time_Delay = CurrentAV->Time_Delay;
break;
case EVENT_STATE_HIGH_LIMIT:
/* Once exceeded, the Present_Value must fall below the High_Limit minus
the Deadband before a TO-NORMAL event is generated under these conditions:
(a) the Present_Value must fall below the High_Limit minus the Deadband
for a minimum period of time, specified in the Time_Delay property, and
(b) the HighLimitEnable flag must be set in the Limit_Enable property, and
(c) the TO-NORMAL flag must be set in the Event_Enable property. */
if ((PresentVal < CurrentAV->High_Limit - CurrentAV->Deadband)
&& ((CurrentAV->Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) ==
EVENT_HIGH_LIMIT_ENABLE) &&
((CurrentAV->Event_Enable & EVENT_ENABLE_TO_NORMAL) ==
EVENT_ENABLE_TO_NORMAL)) {
if (!CurrentAV->Remaining_Time_Delay)
CurrentAV->Event_State = EVENT_STATE_NORMAL;
else
CurrentAV->Remaining_Time_Delay--;
break;
}
/* value of the object is still in the same event state */
CurrentAV->Remaining_Time_Delay = CurrentAV->Time_Delay;
break;
case EVENT_STATE_LOW_LIMIT:
/* Once the Present_Value has fallen below the Low_Limit,
the Present_Value must exceed the Low_Limit plus the Deadband
before a TO-NORMAL event is generated under these conditions:
(a) the Present_Value must exceed the Low_Limit plus the Deadband
for a minimum period of time, specified in the Time_Delay property, and
(b) the LowLimitEnable flag must be set in the Limit_Enable property, and
(c) the TO-NORMAL flag must be set in the Event_Enable property. */
if ((PresentVal > CurrentAV->Low_Limit + CurrentAV->Deadband)
&& ((CurrentAV->Limit_Enable & EVENT_LOW_LIMIT_ENABLE) ==
EVENT_LOW_LIMIT_ENABLE) &&
((CurrentAV->Event_Enable & EVENT_ENABLE_TO_NORMAL) ==
EVENT_ENABLE_TO_NORMAL)) {
if (!CurrentAV->Remaining_Time_Delay)
CurrentAV->Event_State = EVENT_STATE_NORMAL;
else
CurrentAV->Remaining_Time_Delay--;
break;
}
/* value of the object is still in the same event state */
CurrentAV->Remaining_Time_Delay = CurrentAV->Time_Delay;
break;
default:
return; /* shouldn't happen */
} /* switch (FromState) */
ToState = CurrentAV->Event_State;
if (FromState != ToState) {
/* Event_State has changed.
Need to fill only the basic parameters of this type of event.
Other parameters will be filled in common function. */
switch (ToState) {
case EVENT_STATE_HIGH_LIMIT:
ExceededLimit = CurrentAV->High_Limit;
characterstring_init_ansi(&msgText, "Goes to high limit");
break;
case EVENT_STATE_LOW_LIMIT:
ExceededLimit = CurrentAV->Low_Limit;
characterstring_init_ansi(&msgText, "Goes to low limit");
break;
case EVENT_STATE_NORMAL:
if (FromState == EVENT_STATE_HIGH_LIMIT) {
ExceededLimit = CurrentAV->High_Limit;
characterstring_init_ansi(&msgText,
"Back to normal state from high limit");
} else {
ExceededLimit = CurrentAV->Low_Limit;
characterstring_init_ansi(&msgText,
"Back to normal state from low limit");
}
break;
default:
ExceededLimit = 0;
break;
} /* switch (ToState) */
#if PRINT_ENABLED
fprintf(stderr, "Event_State for (%s,%d) goes from %s to %s.\n",
bactext_object_type_name(OBJECT_ANALOG_VALUE), object_instance,
bactext_event_state_name(FromState),
bactext_event_state_name(ToState));
#endif /* PRINT_ENABLED */
/* Notify Type */
event_data.notifyType = CurrentAV->Notify_Type;
/* Send EventNotification. */
SendNotify = true;
}
}
if (SendNotify) {
/* Event Object Identifier */
event_data.eventObjectIdentifier.type = OBJECT_ANALOG_VALUE;
event_data.eventObjectIdentifier.instance = object_instance;
/* Time Stamp */
event_data.timeStamp.tag = TIME_STAMP_DATETIME;
Device_getCurrentDateTime(&event_data.timeStamp.value.dateTime);
if (event_data.notifyType != NOTIFY_ACK_NOTIFICATION) {
/* fill Event_Time_Stamps */
switch (ToState) {
case EVENT_STATE_HIGH_LIMIT:
case EVENT_STATE_LOW_LIMIT:
CurrentAV->Event_Time_Stamps[TRANSITION_TO_OFFNORMAL] =
event_data.timeStamp.value.dateTime;
break;
case EVENT_STATE_FAULT:
CurrentAV->Event_Time_Stamps[TRANSITION_TO_FAULT] =
event_data.timeStamp.value.dateTime;
break;
case EVENT_STATE_NORMAL:
CurrentAV->Event_Time_Stamps[TRANSITION_TO_NORMAL] =
event_data.timeStamp.value.dateTime;
break;
}
}
/* Notification Class */
event_data.notificationClass = CurrentAV->Notification_Class;
/* Event Type */
event_data.eventType = EVENT_OUT_OF_RANGE;
/* Message Text */
event_data.messageText = &msgText;
/* Notify Type */
/* filled before */
/* From State */
if (event_data.notifyType != NOTIFY_ACK_NOTIFICATION)
event_data.fromState = FromState;
/* To State */
event_data.toState = CurrentAV->Event_State;
/* Event Values */
if (event_data.notifyType != NOTIFY_ACK_NOTIFICATION) {
/* Value that exceeded a limit. */
event_data.notificationParams.outOfRange.exceedingValue =
PresentVal;
/* Status_Flags of the referenced object. */
bitstring_init(&event_data.notificationParams.outOfRange.
statusFlags);
bitstring_set_bit(&event_data.notificationParams.outOfRange.
statusFlags, STATUS_FLAG_IN_ALARM,
CurrentAV->Event_State ? true : false);
bitstring_set_bit(&event_data.notificationParams.outOfRange.
statusFlags, STATUS_FLAG_FAULT, false);
bitstring_set_bit(&event_data.notificationParams.outOfRange.
statusFlags, STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&event_data.notificationParams.outOfRange.
statusFlags, STATUS_FLAG_OUT_OF_SERVICE,
CurrentAV->Out_Of_Service);
/* Deadband used for limit checking. */
event_data.notificationParams.outOfRange.deadband =
CurrentAV->Deadband;
/* Limit that was exceeded. */
event_data.notificationParams.outOfRange.exceededLimit =
ExceededLimit;
}
/* add data from notification class */
Notification_Class_common_reporting_function(&event_data);
/* Ack required */
if ((event_data.notifyType != NOTIFY_ACK_NOTIFICATION) &&
(event_data.ackRequired == true)) {
switch (event_data.toState) {
case EVENT_STATE_OFFNORMAL:
case EVENT_STATE_HIGH_LIMIT:
case EVENT_STATE_LOW_LIMIT:
CurrentAV->Acked_Transitions[TRANSITION_TO_OFFNORMAL].
bIsAcked = false;
CurrentAV->Acked_Transitions[TRANSITION_TO_OFFNORMAL].
Time_Stamp = event_data.timeStamp.value.dateTime;
break;
case EVENT_STATE_FAULT:
CurrentAV->Acked_Transitions[TRANSITION_TO_FAULT].
bIsAcked = false;
CurrentAV->Acked_Transitions[TRANSITION_TO_FAULT].
Time_Stamp = event_data.timeStamp.value.dateTime;
break;
case EVENT_STATE_NORMAL:
CurrentAV->Acked_Transitions[TRANSITION_TO_NORMAL].
bIsAcked = false;
CurrentAV->Acked_Transitions[TRANSITION_TO_NORMAL].
Time_Stamp = event_data.timeStamp.value.dateTime;
break;
}
}
}
#endif /* defined(INTRINSIC_REPORTING) */
}
/* return apdu len, or BACNET_STATUS_ERROR on error */
int Analog_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata)
{
int len = 0;
int apdu_len = 0; /* return value */
BACNET_BIT_STRING bit_string;
BACNET_CHARACTER_STRING char_string;
float real_value = (float) 1.414;
unsigned object_index = 0;
unsigned i = 0;
bool state = false;
uint8_t *apdu = NULL;
ANALOG_VALUE_DESCR *CurrentAV;
if ((rpdata == NULL) || (rpdata->application_data == NULL) ||
(rpdata->application_data_len == 0)) {
return 0;
}
apdu = rpdata->application_data;
object_index = Analog_Value_Instance_To_Index(rpdata->object_instance);
if (object_index < MAX_ANALOG_VALUES)
CurrentAV = &AV_Descr[object_index];
else
return BACNET_STATUS_ERROR;
switch (rpdata->object_property) {
case PROP_OBJECT_IDENTIFIER:
apdu_len =
encode_application_object_id(&apdu[0], OBJECT_ANALOG_VALUE,
rpdata->object_instance);
break;
case PROP_OBJECT_NAME:
case PROP_DESCRIPTION:
Analog_Value_Object_Name(rpdata->object_instance, &char_string);
apdu_len =
encode_application_character_string(&apdu[0], &char_string);
break;
case PROP_OBJECT_TYPE:
apdu_len =
encode_application_enumerated(&apdu[0], OBJECT_ANALOG_VALUE);
break;
case PROP_PRESENT_VALUE:
real_value = Analog_Value_Present_Value(rpdata->object_instance);
apdu_len = encode_application_real(&apdu[0], real_value);
break;
case PROP_STATUS_FLAGS:
bitstring_init(&bit_string);
#if defined(INTRINSIC_REPORTING)
bitstring_set_bit(&bit_string, STATUS_FLAG_IN_ALARM,
CurrentAV->Event_State ? true : false);
#else
bitstring_set_bit(&bit_string, STATUS_FLAG_IN_ALARM, false);
#endif
bitstring_set_bit(&bit_string, STATUS_FLAG_FAULT, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_OUT_OF_SERVICE,
CurrentAV->Out_Of_Service);
apdu_len = encode_application_bitstring(&apdu[0], &bit_string);
break;
case PROP_EVENT_STATE:
#if defined(INTRINSIC_REPORTING)
apdu_len =
encode_application_enumerated(&apdu[0],
CurrentAV->Event_State);
#else
apdu_len =
encode_application_enumerated(&apdu[0], EVENT_STATE_NORMAL);
#endif
break;
case PROP_OUT_OF_SERVICE:
state = CurrentAV->Out_Of_Service;
apdu_len = encode_application_boolean(&apdu[0], state);
break;
case PROP_UNITS:
apdu_len =
encode_application_enumerated(&apdu[0], CurrentAV->Units);
break;
#if defined(INTRINSIC_REPORTING)
case PROP_TIME_DELAY:
apdu_len =
encode_application_unsigned(&apdu[0], CurrentAV->Time_Delay);
break;
case PROP_NOTIFICATION_CLASS:
apdu_len =
encode_application_unsigned(&apdu[0],
CurrentAV->Notification_Class);
break;
case PROP_HIGH_LIMIT:
apdu_len =
encode_application_real(&apdu[0], CurrentAV->High_Limit);
break;
case PROP_LOW_LIMIT:
apdu_len = encode_application_real(&apdu[0], CurrentAV->Low_Limit);
break;
case PROP_DEADBAND:
apdu_len = encode_application_real(&apdu[0], CurrentAV->Deadband);
break;
case PROP_LIMIT_ENABLE:
bitstring_init(&bit_string);
bitstring_set_bit(&bit_string, 0,
(CurrentAV->
Limit_Enable & EVENT_LOW_LIMIT_ENABLE) ? true : false);
bitstring_set_bit(&bit_string, 1,
(CurrentAV->
Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) ? true : false);
apdu_len = encode_application_bitstring(&apdu[0], &bit_string);
break;
case PROP_EVENT_ENABLE:
bitstring_init(&bit_string);
bitstring_set_bit(&bit_string, TRANSITION_TO_OFFNORMAL,
(CurrentAV->
Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) ? true : false);
bitstring_set_bit(&bit_string, TRANSITION_TO_FAULT,
(CurrentAV->
Event_Enable & EVENT_ENABLE_TO_FAULT) ? true : false);
bitstring_set_bit(&bit_string, TRANSITION_TO_NORMAL,
(CurrentAV->
Event_Enable & EVENT_ENABLE_TO_NORMAL) ? true : false);
apdu_len = encode_application_bitstring(&apdu[0], &bit_string);
break;
case PROP_ACKED_TRANSITIONS:
bitstring_init(&bit_string);
bitstring_set_bit(&bit_string, TRANSITION_TO_OFFNORMAL,
CurrentAV->Acked_Transitions[TRANSITION_TO_OFFNORMAL].
bIsAcked);
bitstring_set_bit(&bit_string, TRANSITION_TO_FAULT,
CurrentAV->Acked_Transitions[TRANSITION_TO_FAULT].bIsAcked);
bitstring_set_bit(&bit_string, TRANSITION_TO_NORMAL,
CurrentAV->Acked_Transitions[TRANSITION_TO_NORMAL].bIsAcked);
apdu_len = encode_application_bitstring(&apdu[0], &bit_string);
break;
case PROP_NOTIFY_TYPE:
apdu_len =
encode_application_enumerated(&apdu[0],
CurrentAV->Notify_Type ? NOTIFY_EVENT : NOTIFY_ALARM);
break;
case PROP_EVENT_TIME_STAMPS:
/* Array element zero is the number of elements in the array */
if (rpdata->array_index == 0)
apdu_len =
encode_application_unsigned(&apdu[0],
MAX_BACNET_EVENT_TRANSITION);
/* if no index was specified, then try to encode the entire list */
/* into one packet. */
else if (rpdata->array_index == BACNET_ARRAY_ALL) {
for (i = 0; i < MAX_BACNET_EVENT_TRANSITION; i++) {;
len =
encode_opening_tag(&apdu[apdu_len],
TIME_STAMP_DATETIME);
len +=
encode_application_date(&apdu[apdu_len + len],
&CurrentAV->Event_Time_Stamps[i].date);
len +=
encode_application_time(&apdu[apdu_len + len],
&CurrentAV->Event_Time_Stamps[i].time);
len +=
encode_closing_tag(&apdu[apdu_len + len],
TIME_STAMP_DATETIME);
/* add it if we have room */
if ((apdu_len + len) < MAX_APDU)
apdu_len += len;
else {
rpdata->error_class = ERROR_CLASS_SERVICES;
rpdata->error_code = ERROR_CODE_NO_SPACE_FOR_OBJECT;
apdu_len = BACNET_STATUS_ERROR;
break;
}
}
} else if (rpdata->array_index <= MAX_BACNET_EVENT_TRANSITION) {
apdu_len =
encode_opening_tag(&apdu[apdu_len], TIME_STAMP_DATETIME);
apdu_len +=
encode_application_date(&apdu[apdu_len],
&CurrentAV->Event_Time_Stamps[rpdata->array_index].date);
apdu_len +=
encode_application_time(&apdu[apdu_len],
&CurrentAV->Event_Time_Stamps[rpdata->array_index].time);
apdu_len +=
encode_closing_tag(&apdu[apdu_len], TIME_STAMP_DATETIME);
} else {
rpdata->error_class = ERROR_CLASS_PROPERTY;
rpdata->error_code = ERROR_CODE_INVALID_ARRAY_INDEX;
apdu_len = BACNET_STATUS_ERROR;
}
break;
#endif
default:
rpdata->error_class = ERROR_CLASS_PROPERTY;
rpdata->error_code = ERROR_CODE_UNKNOWN_PROPERTY;
apdu_len = BACNET_STATUS_ERROR;
break;
}
/* only array properties can have array options */
if ((apdu_len >= 0) && (rpdata->object_property != PROP_PRIORITY_ARRAY) &&
(rpdata->object_property != PROP_EVENT_TIME_STAMPS) &&
(rpdata->array_index != BACNET_ARRAY_ALL)) {
rpdata->error_class = ERROR_CLASS_PROPERTY;
rpdata->error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY;
apdu_len = BACNET_STATUS_ERROR;
}
return apdu_len;
}
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;
}
/* return apdu len, or -1 on error */
int Analog_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata)
{
int apdu_len = 0; /* return value */
BACNET_BIT_STRING bit_string;
BACNET_CHARACTER_STRING char_string;
float real_value = (float) 1.414;
#if 0
int len = 0;
unsigned object_index = 0;
unsigned i = 0;
bool state = false;
#endif
uint8_t *apdu = NULL;
if ((rpdata == NULL) || (rpdata->application_data == NULL) ||
(rpdata->application_data_len == 0)) {
return 0;
}
apdu = rpdata->application_data;
switch (rpdata->object_property) {
case PROP_OBJECT_IDENTIFIER:
apdu_len =
encode_application_object_id(&apdu[0], OBJECT_ANALOG_VALUE,
rpdata->object_instance);
break;
case PROP_OBJECT_NAME:
case PROP_DESCRIPTION:
Analog_Value_Object_Name(rpdata->object_instance, &char_string);
apdu_len =
encode_application_character_string(&apdu[0], &char_string);
break;
case PROP_OBJECT_TYPE:
apdu_len =
encode_application_enumerated(&apdu[0], OBJECT_ANALOG_VALUE);
break;
case PROP_PRESENT_VALUE:
real_value = Analog_Value_Present_Value(rpdata->object_instance);
apdu_len = encode_application_real(&apdu[0], real_value);
break;
case PROP_STATUS_FLAGS:
bitstring_init(&bit_string);
bitstring_set_bit(&bit_string, STATUS_FLAG_IN_ALARM, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_FAULT, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_OVERRIDDEN, false);
bitstring_set_bit(&bit_string, STATUS_FLAG_OUT_OF_SERVICE, false);
apdu_len = encode_application_bitstring(&apdu[0], &bit_string);
break;
case PROP_EVENT_STATE:
apdu_len =
encode_application_enumerated(&apdu[0], EVENT_STATE_NORMAL);
break;
case PROP_OUT_OF_SERVICE:
#if 0
object_index =
Analog_Value_Instance_To_Index(rpdata->object_instance);
state = Analog_Value_Out_Of_Service[object_index];
#endif
apdu_len = encode_application_boolean(&apdu[0], false);
break;
case PROP_UNITS:
apdu_len = encode_application_enumerated(&apdu[0], UNITS_PERCENT);
break;
#if 0
case PROP_PRIORITY_ARRAY:
/* Array element zero is the number of elements in the array */
if (rpdata->array_index == 0)
apdu_len =
encode_application_unsigned(&apdu[0], BACNET_MAX_PRIORITY);
/* if no index was specified, then try to encode the entire list */
/* into one packet. */
else if (rpdata->array_index == BACNET_ARRAY_ALL) {
object_index =
Analog_Value_Instance_To_Index(rpdata->object_instance);
for (i = 0; i < BACNET_MAX_PRIORITY; i++) {
/* FIXME: check if we have room before adding it to APDU */
if (Present_Value[object_index][i] == ANALOG_LEVEL_NULL)
len = encode_application_null(&apdu[apdu_len]);
else {
real_value = Present_Value[object_index][i];
len =
encode_application_real(&apdu[apdu_len],
real_value);
}
/* add it if we have room */
if ((apdu_len + len) < MAX_APDU)
apdu_len += len;
else {
rpdata->error_class = ERROR_CLASS_SERVICES;
rpdata->error_code = ERROR_CODE_NO_SPACE_FOR_OBJECT;
apdu_len = BACNET_STATUS_ERROR;
break;
}
}
} else {
object_index = Analog_Value_Instance_To_Index(object_instance);
if (rpdata->array_index <= BACNET_MAX_PRIORITY) {
if (Present_Value[object_index][rpdata->array_index - 1] ==
ANALOG_LEVEL_NULL)
apdu_len = encode_application_null(&apdu[0]);
else {
real_value =
Present_Value[object_index][rpdata->array_index -
1];
apdu_len =
encode_application_real(&apdu[0], real_value);
}
} else {
rpdata->error_class = ERROR_CLASS_PROPERTY;
rpdata->error_code = ERROR_CODE_INVALID_ARRAY_INDEX;
apdu_len = BACNET_STATUS_ERROR;
}
}
break;
case PROP_RELINQUISH_DEFAULT:
real_value = ANALOG_RELINQUISH_DEFAULT;
apdu_len = encode_application_real(&apdu[0], real_value);
break;
#endif
default:
rpdata->error_class = ERROR_CLASS_PROPERTY;
rpdata->error_code = ERROR_CODE_UNKNOWN_PROPERTY;
apdu_len = BACNET_STATUS_ERROR;
break;
}
/* only array properties can have array options */
if ((apdu_len >= 0) &&
#if 0
(rpdata->object_property != PROP_PRIORITY_ARRAY) &&
#endif
(rpdata->array_index != BACNET_ARRAY_ALL)) {
rpdata->error_class = ERROR_CLASS_PROPERTY;
rpdata->error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY;
apdu_len = BACNET_STATUS_ERROR;
}
return apdu_len;
}