From c37aa9ea90e1320f0c2994169dece62aa428c86e Mon Sep 17 00:00:00 2001 From: k001a Date: Sat, 23 Jul 2011 17:18:25 +0000 Subject: [PATCH] After acknowledgment an alarm is sent AckNotification. --- bacnet-stack/demo/object/ai.c | 361 ++++++++++++++++++--------------- bacnet-stack/demo/object/ai.h | 2 + bacnet-stack/demo/object/av.c | 372 +++++++++++++++++++--------------- bacnet-stack/demo/object/av.h | 2 + bacnet-stack/demo/object/nc.h | 11 +- 5 files changed, 425 insertions(+), 323 deletions(-) diff --git a/bacnet-stack/demo/object/ai.c b/bacnet-stack/demo/object/ai.c index 0e733922..4f592d7e 100644 --- a/bacnet-stack/demo/object/ai.c +++ b/bacnet-stack/demo/object/ai.c @@ -633,10 +633,11 @@ void Analog_Input_Intrinsic_Reporting(uint32_t object_instance) BACNET_CHARACTER_STRING msgText; ANALOG_INPUT_DESCR *CurrentAI; unsigned int object_index; - uint8_t FromState; + uint8_t FromState = 0; uint8_t ToState; - float ExceededLimit; - float PresentVal; + float ExceededLimit = 0.0f; + float PresentVal = 0.0f; + bool SendNotify = false; object_index = Analog_Input_Instance_To_Index(object_instance); @@ -649,141 +650,175 @@ void Analog_Input_Intrinsic_Reporting(uint32_t object_instance) if (!CurrentAI->Limit_Enable) return; /* limits are not configured */ - /* actual Present_Value */ - PresentVal = Analog_Input_Present_Value(object_instance); - FromState = CurrentAI->Event_State; - switch (CurrentAI->Event_State) + + if (CurrentAI->Ack_notify_data.bSendAckNotify) { + /* clean bSendAckNotify flag */ + CurrentAI->Ack_notify_data.bSendAckNotify = false; + /* copy toState */ + ToState = CurrentAI->Ack_notify_data.EventState; + +#if PRINT_ENABLED + fprintf(stderr, "Send Acknotification for (%s,%d).\n", + bactext_object_type_name(OBJECT_ANALOG_INPUT), + object_instance); +#endif /* PRINT_ENABLED */ + + characterstring_init_ansi(&msgText, "AckNotification"); + + /* Notify Type */ + event_data.notifyType = NOTIFY_ACK_NOTIFICATION; + + /* Send EventNotification. */ + SendNotify = true; + } + else { - 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 > CurrentAI->High_Limit) && - ((CurrentAI->Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) == EVENT_HIGH_LIMIT_ENABLE) && - ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) == EVENT_ENABLE_TO_OFFNORMAL)) - { - if(!CurrentAI->Remaining_Time_Delay) - CurrentAI->Event_State = EVENT_STATE_HIGH_LIMIT; - else - CurrentAI->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 < CurrentAI->Low_Limit) && - ((CurrentAI->Limit_Enable & EVENT_LOW_LIMIT_ENABLE) == EVENT_LOW_LIMIT_ENABLE) && - ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) == EVENT_ENABLE_TO_OFFNORMAL)) - { - if(!CurrentAI->Remaining_Time_Delay) - CurrentAI->Event_State = EVENT_STATE_LOW_LIMIT; - else - CurrentAI->Remaining_Time_Delay--; - break; - } - /* value of the object is still in the same event state */ - CurrentAI->Remaining_Time_Delay = CurrentAI->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 < CurrentAI->High_Limit - CurrentAI->Deadband) && - ((CurrentAI->Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) == EVENT_HIGH_LIMIT_ENABLE) && - ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_NORMAL) == EVENT_ENABLE_TO_NORMAL)) - { - if(!CurrentAI->Remaining_Time_Delay) - CurrentAI->Event_State = EVENT_STATE_NORMAL; - else - CurrentAI->Remaining_Time_Delay--; - break; - } - /* value of the object is still in the same event state */ - CurrentAI->Remaining_Time_Delay = CurrentAI->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 > CurrentAI->Low_Limit + CurrentAI->Deadband) && - ((CurrentAI->Limit_Enable & EVENT_LOW_LIMIT_ENABLE) == EVENT_LOW_LIMIT_ENABLE) && - ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_NORMAL) == EVENT_ENABLE_TO_NORMAL)) - { - if(!CurrentAI->Remaining_Time_Delay) - CurrentAI->Event_State = EVENT_STATE_NORMAL; - else - CurrentAI->Remaining_Time_Delay--; - break; - } - /* value of the object is still in the same event state */ - CurrentAI->Remaining_Time_Delay = CurrentAI->Time_Delay; - break; - - default: - return; /* shouldn't happen */ - } /* switch (FromState) */ - - ToState = CurrentAI->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) + /* actual Present_Value */ + PresentVal = Analog_Input_Present_Value(object_instance); + FromState = CurrentAI->Event_State; + switch (CurrentAI->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 > CurrentAI->High_Limit) && + ((CurrentAI->Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) == EVENT_HIGH_LIMIT_ENABLE) && + ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) == EVENT_ENABLE_TO_OFFNORMAL)) + { + if(!CurrentAI->Remaining_Time_Delay) + CurrentAI->Event_State = EVENT_STATE_HIGH_LIMIT; + else + CurrentAI->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 < CurrentAI->Low_Limit) && + ((CurrentAI->Limit_Enable & EVENT_LOW_LIMIT_ENABLE) == EVENT_LOW_LIMIT_ENABLE) && + ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_OFFNORMAL) == EVENT_ENABLE_TO_OFFNORMAL)) + { + if(!CurrentAI->Remaining_Time_Delay) + CurrentAI->Event_State = EVENT_STATE_LOW_LIMIT; + else + CurrentAI->Remaining_Time_Delay--; + break; + } + /* value of the object is still in the same event state */ + CurrentAI->Remaining_Time_Delay = CurrentAI->Time_Delay; + break; + case EVENT_STATE_HIGH_LIMIT: - ExceededLimit = CurrentAI->High_Limit; - characterstring_init_ansi(&msgText, - "Goes to 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 < CurrentAI->High_Limit - CurrentAI->Deadband) && + ((CurrentAI->Limit_Enable & EVENT_HIGH_LIMIT_ENABLE) == EVENT_HIGH_LIMIT_ENABLE) && + ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_NORMAL) == EVENT_ENABLE_TO_NORMAL)) + { + if(!CurrentAI->Remaining_Time_Delay) + CurrentAI->Event_State = EVENT_STATE_NORMAL; + else + CurrentAI->Remaining_Time_Delay--; + break; + } + /* value of the object is still in the same event state */ + CurrentAI->Remaining_Time_Delay = CurrentAI->Time_Delay; break; case EVENT_STATE_LOW_LIMIT: - ExceededLimit = CurrentAI->Low_Limit; - characterstring_init_ansi(&msgText, - "Goes to low limit"); - break; - - case EVENT_STATE_NORMAL: - if(FromState == EVENT_STATE_HIGH_LIMIT) { - ExceededLimit = CurrentAI->High_Limit; - characterstring_init_ansi(&msgText, - "Back to normal state from high limit"); - } - else { - ExceededLimit = CurrentAI->Low_Limit; - characterstring_init_ansi(&msgText, - "Back to normal state from 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 > CurrentAI->Low_Limit + CurrentAI->Deadband) && + ((CurrentAI->Limit_Enable & EVENT_LOW_LIMIT_ENABLE) == EVENT_LOW_LIMIT_ENABLE) && + ((CurrentAI->Event_Enable & EVENT_ENABLE_TO_NORMAL) == EVENT_ENABLE_TO_NORMAL)) + { + if(!CurrentAI->Remaining_Time_Delay) + CurrentAI->Event_State = EVENT_STATE_NORMAL; + else + CurrentAI->Remaining_Time_Delay--; + break; } + /* value of the object is still in the same event state */ + CurrentAI->Remaining_Time_Delay = CurrentAI->Time_Delay; break; default: - ExceededLimit = 0; - break; - } /* switch (ToState) */ + return; /* shouldn't happen */ + } /* switch (FromState) */ + + ToState = CurrentAI->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 = CurrentAI->High_Limit; + characterstring_init_ansi(&msgText, + "Goes to high limit"); + break; + + case EVENT_STATE_LOW_LIMIT: + ExceededLimit = CurrentAI->Low_Limit; + characterstring_init_ansi(&msgText, + "Goes to low limit"); + break; + + case EVENT_STATE_NORMAL: + if(FromState == EVENT_STATE_HIGH_LIMIT) { + ExceededLimit = CurrentAI->High_Limit; + characterstring_init_ansi(&msgText, + "Back to normal state from high limit"); + } + else { + ExceededLimit = CurrentAI->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 (Analog-Input,%d) goes from %s to %s.\n", - object_instance, bactext_event_state_name(FromState), - bactext_event_state_name(ToState)); + fprintf(stderr, "Event_State for (%s,%d) goes from %s to %s.\n", + bactext_object_type_name(OBJECT_ANALOG_INPUT), + object_instance, bactext_event_state_name(FromState), + bactext_event_state_name(ToState)); +#endif /* PRINT_ENABLED */ -#endif /* PRINT_ENABLED) */ + /* Notify Type */ + event_data.notifyType = CurrentAI->Notify_Type; + /* Send EventNotification. */ + SendNotify = true; + } + } + + + if (SendNotify) + { /* Event Object Identifier */ event_data.eventObjectIdentifier.type = OBJECT_ANALOG_INPUT; event_data.eventObjectIdentifier.instance = object_instance; @@ -791,24 +826,27 @@ void Analog_Input_Intrinsic_Reporting(uint32_t object_instance) /* Time Stamp */ event_data.timeStamp.tag = TIME_STAMP_DATETIME; Device_getCurrentDateTime(&event_data.timeStamp.value.dateTime); - /* fill Event_Time_Stamps */ - switch (ToState) - { - case EVENT_STATE_HIGH_LIMIT: - case EVENT_STATE_LOW_LIMIT: - CurrentAI->Event_Time_Stamps[TRANSITION_TO_OFFNORMAL] = - event_data.timeStamp.value.dateTime; - break; - case EVENT_STATE_FAULT: - CurrentAI->Event_Time_Stamps[TRANSITION_TO_FAULT] = - event_data.timeStamp.value.dateTime; - break; + if (event_data.notifyType != NOTIFY_ACK_NOTIFICATION) { + /* fill Event_Time_Stamps */ + switch (ToState) + { + case EVENT_STATE_HIGH_LIMIT: + case EVENT_STATE_LOW_LIMIT: + CurrentAI->Event_Time_Stamps[TRANSITION_TO_OFFNORMAL] = + event_data.timeStamp.value.dateTime; + break; - case EVENT_STATE_NORMAL: - CurrentAI->Event_Time_Stamps[TRANSITION_TO_NORMAL] = - event_data.timeStamp.value.dateTime; - break; + case EVENT_STATE_FAULT: + CurrentAI->Event_Time_Stamps[TRANSITION_TO_FAULT] = + event_data.timeStamp.value.dateTime; + break; + + case EVENT_STATE_NORMAL: + CurrentAI->Event_Time_Stamps[TRANSITION_TO_NORMAL] = + event_data.timeStamp.value.dateTime; + break; + } } /* Notification Class */ @@ -821,36 +859,41 @@ void Analog_Input_Intrinsic_Reporting(uint32_t object_instance) event_data.messageText = &msgText; /* Notify Type */ - event_data.notifyType = CurrentAI->Notify_Type; + /* filled before */ /* From State */ - event_data.fromState = FromState; + if (event_data.notifyType != NOTIFY_ACK_NOTIFICATION) + event_data.fromState = FromState; /* To State */ - event_data.toState = CurrentAI->Event_State; + event_data.toState = CurrentAI->Event_State; /* Event Values */ - event_data.notificationParams.outOfRange.exceedingValue = PresentVal; - - bitstring_init(&event_data.notificationParams.outOfRange.statusFlags); - bitstring_set_bit(&event_data.notificationParams.outOfRange.statusFlags, - STATUS_FLAG_IN_ALARM, CurrentAI->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, CurrentAI->Out_Of_Service); - - event_data.notificationParams.outOfRange.deadband = CurrentAI->Deadband; - - event_data.notificationParams.outOfRange.exceededLimit = ExceededLimit; + 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, CurrentAI->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, CurrentAI->Out_Of_Service); + /* Deadband used for limit checking. */ + event_data.notificationParams.outOfRange.deadband = CurrentAI->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.ackRequired == true) + if ((event_data.notifyType != NOTIFY_ACK_NOTIFICATION) && + (event_data.ackRequired == true)) { switch (event_data.toState) { diff --git a/bacnet-stack/demo/object/ai.h b/bacnet-stack/demo/object/ai.h index cbbb2f0d..92eda9d5 100644 --- a/bacnet-stack/demo/object/ai.h +++ b/bacnet-stack/demo/object/ai.h @@ -56,6 +56,8 @@ extern "C" { BACNET_DATE_TIME Event_Time_Stamps[MAX_BACNET_EVENT_TRANSITION]; /* time to generate event notification */ uint32_t Remaining_Time_Delay; + /* AckNotification informations */ + ACK_NOTIFICATION Ack_notify_data; #endif } ANALOG_INPUT_DESCR; diff --git a/bacnet-stack/demo/object/av.c b/bacnet-stack/demo/object/av.c index 77375144..f156f923 100644 --- a/bacnet-stack/demo/object/av.c +++ b/bacnet-stack/demo/object/av.c @@ -744,10 +744,11 @@ void Analog_Value_Intrinsic_Reporting(uint32_t object_instance) BACNET_CHARACTER_STRING msgText; ANALOG_VALUE_DESCR *CurrentAV; unsigned int object_index; - uint8_t FromState; + uint8_t FromState = 0; uint8_t ToState; - float ExceededLimit; - float PresentVal; + float ExceededLimit = 0.0f; + float PresentVal = 0.0f; + bool SendNotify = false; object_index = Analog_Value_Instance_To_Index(object_instance); @@ -760,141 +761,175 @@ void Analog_Value_Intrinsic_Reporting(uint32_t object_instance) if (!CurrentAV->Limit_Enable) return; /* limits are not configured */ - /* actual Present_Value */ - PresentVal = Analog_Value_Present_Value(object_instance); - FromState = CurrentAV->Event_State; - switch (CurrentAV->Event_State) + + 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 { - 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) + /* 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: - ExceededLimit = CurrentAV->High_Limit; - characterstring_init_ansi(&msgText, - "Goes to 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: - 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"); + /* 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: - ExceededLimit = 0; - break; - } /* switch (ToState) */ + 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 (Analog-Value,%d) goes from %s to %s.\n", - object_instance, bactext_event_state_name(FromState), - bactext_event_state_name(ToState)); - + 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; @@ -902,24 +937,27 @@ void Analog_Value_Intrinsic_Reporting(uint32_t object_instance) /* Time Stamp */ event_data.timeStamp.tag = TIME_STAMP_DATETIME; Device_getCurrentDateTime(&event_data.timeStamp.value.dateTime); - /* 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; + 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_NORMAL: - CurrentAV->Event_Time_Stamps[TRANSITION_TO_NORMAL] = - 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 */ @@ -932,36 +970,41 @@ void Analog_Value_Intrinsic_Reporting(uint32_t object_instance) event_data.messageText = &msgText; /* Notify Type */ - event_data.notifyType = CurrentAV->Notify_Type; + /* filled before */ /* From State */ - event_data.fromState = FromState; + if (event_data.notifyType != NOTIFY_ACK_NOTIFICATION) + event_data.fromState = FromState; /* To State */ - event_data.toState = CurrentAV->Event_State; + event_data.toState = CurrentAV->Event_State; /* Event Values */ - event_data.notificationParams.outOfRange.exceedingValue = PresentVal; - - 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); - - event_data.notificationParams.outOfRange.deadband = CurrentAV->Deadband; - - event_data.notificationParams.outOfRange.exceededLimit = ExceededLimit; + 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.ackRequired == true) + if ((event_data.notifyType != NOTIFY_ACK_NOTIFICATION) && + (event_data.ackRequired == true)) { switch (event_data.toState) { @@ -1088,7 +1131,7 @@ int Analog_Value_Alarm_Ack(BACNET_ALARM_ACK_DATA * alarmack_data, return -1; } - /* FIXME: Send ack notification */ + /* Clean transitions flag. */ CurrentAV->Acked_Transitions[TRANSITION_TO_OFFNORMAL].bIsAcked = true; } else { @@ -1110,7 +1153,7 @@ int Analog_Value_Alarm_Ack(BACNET_ALARM_ACK_DATA * alarmack_data, return -1; } - /* FIXME: Send ack notification */ + /* Clean transitions flag. */ CurrentAV->Acked_Transitions[TRANSITION_TO_FAULT].bIsAcked = true; } else { @@ -1132,7 +1175,7 @@ int Analog_Value_Alarm_Ack(BACNET_ALARM_ACK_DATA * alarmack_data, return -1; } - /* FIXME: Send ack notification */ + /* Clean transitions flag. */ CurrentAV->Acked_Transitions[TRANSITION_TO_NORMAL].bIsAcked = true; } else { @@ -1145,6 +1188,11 @@ int Analog_Value_Alarm_Ack(BACNET_ALARM_ACK_DATA * alarmack_data, return -2; } + /* Need to send AckNotification. */ + CurrentAV->Ack_notify_data.bSendAckNotify = true; + CurrentAV->Ack_notify_data.EventState = alarmack_data->eventStateAcked; + + /* Return OK */ return 1; } #endif /* defined(INTRINSIC_REPORTING) */ diff --git a/bacnet-stack/demo/object/av.h b/bacnet-stack/demo/object/av.h index 2823c359..325bffea 100644 --- a/bacnet-stack/demo/object/av.h +++ b/bacnet-stack/demo/object/av.h @@ -60,6 +60,8 @@ extern "C" { BACNET_DATE_TIME Event_Time_Stamps[MAX_BACNET_EVENT_TRANSITION]; /* time to generate event notification */ uint32_t Remaining_Time_Delay; + /* AckNotification informations */ + ACK_NOTIFICATION Ack_notify_data; #endif } ANALOG_VALUE_DESCR; diff --git a/bacnet-stack/demo/object/nc.h b/bacnet-stack/demo/object/nc.h index 324d5c58..fe5f15cc 100644 --- a/bacnet-stack/demo/object/nc.h +++ b/bacnet-stack/demo/object/nc.h @@ -61,7 +61,6 @@ typedef struct BACnet_Recipient { } BACNET_RECIPIENT; - /* BACnetDestination structure */ typedef struct BACnet_Destination { uint8_t ValidDays; @@ -72,6 +71,7 @@ typedef struct BACnet_Destination { uint8_t Transitions; bool ConfirmedNotify; } BACNET_DESTINATION; + /* Structure containing configuration for a Notification Class */ typedef struct Notification_Class_info { @@ -86,8 +86,15 @@ typedef struct Acked_info { bool bIsAcked; /* true when transitions is acked */ BACNET_DATE_TIME Time_Stamp;/* time stamp of when a alarm was generated */ } ACKED_INFO; + + +/* Information needed to send AckNotification */ +typedef struct Ack_Notification { + bool bSendAckNotify; /* true if need to send AckNotification */ + uint8_t EventState; +} ACK_NOTIFICATION; - + void Notification_Class_Property_Lists( const int **pRequired,