From 7f4f1a731b60971e31c8da56de297b90a22d2173 Mon Sep 17 00:00:00 2001 From: skarg Date: Sat, 14 May 2005 15:36:51 +0000 Subject: [PATCH] adding analog output object --- bacnet-stack/Makefile | 1 + bacnet-stack/ao.c | 417 ++++++++++++++++++++++++++++++++++++++++ bacnet-stack/ao.h | 47 +++++ bacnet-stack/bacdcode.c | 8 + bacnet-stack/bacdcode.h | 3 + bacnet-stack/bacdef.h | 2 + bacnet-stack/device.c | 12 +- bacnet-stack/handlers.c | 60 ++++++ 8 files changed, 547 insertions(+), 3 deletions(-) create mode 100644 bacnet-stack/ao.c create mode 100644 bacnet-stack/ao.h diff --git a/bacnet-stack/Makefile b/bacnet-stack/Makefile index 96e04bee..21fb6c12 100644 --- a/bacnet-stack/Makefile +++ b/bacnet-stack/Makefile @@ -21,6 +21,7 @@ SRCS = ports/linux/main.c \ wp.c \ device.c \ ai.c \ + ao.c \ abort.c \ reject.c \ bacerror.c \ diff --git a/bacnet-stack/ao.c b/bacnet-stack/ao.c new file mode 100644 index 00000000..c185f0d4 --- /dev/null +++ b/bacnet-stack/ao.c @@ -0,0 +1,417 @@ +/************************************************************************** +* +* Copyright (C) 2005 Steve Karg +* +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +* +*********************************************************************/ + +// Analog Output Objects - customize for your use + +#include +#include +#include +#include "bacdef.h" +#include "bacdcode.h" +#include "bacenum.h" +#include "config.h" // the custom stuff +#include "wp.h" + +#define MAX_ANALOG_OUTPUTS 20 + +// we choose to have a NULL level in our system represented by +// a particular value. When the priorities are not in use, they +// will be relinquished (i.e. set to the NULL level). +#define AO_LEVEL_NULL 255 +// When all the priorities are level null, the present value returns +// the Relinquish Default value +#define AO_RELINQUISH_DEFAULT 0 +// Here is our Priority Array. They are supposed to be Real, but +// we don't have that kind of memory, so we will use a single byte +// and load a Real for returning the value when asked. +static uint8_t Analog_Output_Level[MAX_ANALOG_OUTPUTS][BACNET_MAX_PRIORITIES]; + +// we need to have our arrays initialized before answering any calls +static bool Analog_Ouput_Initialized = false; + +void Analog_Output_Init(void) +{ + unsigned i,j; + + if (!Analog_Ouput_Initialized) + { + Analog_Ouput_Initialized = true; + + // initialize all the analog output priority arrays to NULL + for (i = 0; i < MAX_ANALOG_OUTPUTS; i++) + { + for (j = 0; j < BACNET_MAX_PRIORITIES; j++) + { + Analog_Output_Level[i][j] = AO_LEVEL_NULL; + } + } + } + + return; +} + +// we simply have 0-n object instances. Yours might be +// more complex, and then you need validate that the +// given instance exists +bool Analog_Output_Valid_Instance(uint32_t object_instance) +{ + Analog_Output_Init(); + if (object_instance < MAX_ANALOG_OUTPUTS) + return true; + + return false; +} + +// we simply have 0-n object instances. Yours might be +// more complex, and then count how many you have +unsigned Analog_Output_Count(void) +{ + Analog_Output_Init(); + return MAX_ANALOG_OUTPUTS; +} + +// we simply have 0-n object instances. Yours might be +// more complex, and then you need to return the instance +// that correlates to the correct index +uint32_t Analog_Output_Index_To_Instance(unsigned index) +{ + Analog_Output_Init(); + return index; +} + +// we simply have 0-n object instances. Yours might be +// more complex, and then you need to return the index +// that correlates to the correct instance number +unsigned Analog_Output_Instance_To_Index(uint32_t object_instance) +{ + unsigned index = MAX_ANALOG_OUTPUTS; + + Analog_Output_Init(); + if (object_instance < MAX_ANALOG_OUTPUTS) + index = object_instance; + + return index; +} + +static float Analog_Output_Present_Value(uint32_t object_instance) +{ + float value = AO_RELINQUISH_DEFAULT; + unsigned index = 0; + unsigned i = 0; + + Analog_Output_Init(); + index = Analog_Output_Index_To_Instance(object_instance); + if (index < MAX_ANALOG_OUTPUTS) + { + for (i = 0; i < BACNET_MAX_PRIORITIES; i++) + { + if (Analog_Output_Level[index][i] != AO_LEVEL_NULL) + { + value = Analog_Output_Level[index][i]; + break; + } + } + } + + return value; +} + +int Analog_Output_Encode_Property_APDU( + uint8_t *apdu, + uint32_t object_instance, + BACNET_PROPERTY_ID property, + int32_t array_index) +{ + int len = 0; + int apdu_len = 0; // return value + BACNET_BIT_STRING bit_string; + char text_string[32] = {""}; + float value = 1.41421356; + unsigned object_index = 0; + unsigned i = 0; + + Analog_Output_Init(); + switch (property) + { + case PROP_OBJECT_IDENTIFIER: + apdu_len = encode_tagged_object_id(&apdu[0], OBJECT_ANALOG_OUTPUT, + object_instance); + break; + case PROP_OBJECT_NAME: + case PROP_DESCRIPTION: + // note: the object name must be unique in this device + sprintf(text_string,"ANALOG OUTPUT %d",object_instance); + apdu_len = encode_tagged_character_string(&apdu[0], text_string); + break; + case PROP_OBJECT_TYPE: + apdu_len = encode_tagged_enumerated(&apdu[0], OBJECT_ANALOG_OUTPUT); + break; + case PROP_PRESENT_VALUE: + value = Analog_Output_Present_Value(object_instance); + apdu_len = encode_tagged_real(&apdu[0], value); + break; + case PROP_STATUS_FLAGS: + 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_tagged_bitstring(&apdu[0], &bit_string); + break; + case PROP_EVENT_STATE: + apdu_len = encode_tagged_enumerated(&apdu[0],EVENT_STATE_NORMAL); + break; + case PROP_OUT_OF_SERVICE: + apdu_len = encode_tagged_boolean(&apdu[0],false); + break; + case PROP_UNITS: + apdu_len = encode_tagged_enumerated(&apdu[0],UNITS_PERCENT); + break; + case PROP_PRIORITY_ARRAY: + // Array element zero is the number of elements in the array + if (array_index == BACNET_ARRAY_LENGTH_INDEX) + apdu_len = encode_tagged_unsigned(&apdu[0], BACNET_MAX_PRIORITIES); + // 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_Output_Instance_To_Index(object_instance); + for (i = 0; i < BACNET_MAX_PRIORITIES; i++) + { + // FIXME: check it we have room before adding it to APDU + if (Analog_Output_Level[object_index][i] == AO_LEVEL_NULL) + len = encode_tagged_null(&apdu[apdu_len]); + else + { + value = Analog_Output_Level[object_index][array_index]; + len = encode_tagged_real(&apdu[apdu_len], value); + } + // add it if we have room + if ((apdu_len + len) < MAX_APDU) + apdu_len += len; + else + { + // ERROR_CLASS_SERVICES + // ERROR_CODE_NO_SPACE_FOR_OBJECT + apdu_len = 0; + break; + } + } + } + else + { + object_index = Analog_Output_Instance_To_Index(object_instance); + if (array_index <= BACNET_MAX_PRIORITIES) + { + if (Analog_Output_Level[object_index][array_index] == AO_LEVEL_NULL) + len = encode_tagged_null(&apdu[apdu_len]); + else + { + value = Analog_Output_Level[object_index][array_index]; + len = encode_tagged_real(&apdu[apdu_len], value); + } + } + else + { + //ERROR_CLASS_PROPERTY + //ERROR_CODE_INVALID_ARRAY_INDEX + } + } + + break; + case PROP_RELINQUISH_DEFAULT: + value = AO_RELINQUISH_DEFAULT; + apdu_len = encode_tagged_real(&apdu[0], value); + break; + default: + break; + } + + return apdu_len; +} + +// returns true if successful +bool Analog_Output_Write_Property( + BACNET_WRITE_PROPERTY_DATA *wp_data, + BACNET_ERROR_CLASS *error_class, + BACNET_ERROR_CODE *error_code) +{ + bool status = false; // return value + uint8_t *apdu = NULL; + int len = 0; + int tag_len = 0; + int apdu_len = 0; + uint8_t tag_number = 0; + uint32_t len_value_type = 0; + float real_value = 0.0; + unsigned int object_index = 0; + unsigned int priority = 0; + uint8_t level = AO_LEVEL_NULL; + + Analog_Output_Init(); + if (Analog_Output_Valid_Instance(wp_data->object_instance)) + { + *error_class = ERROR_CLASS_OBJECT; + *error_code = ERROR_CODE_UNKNOWN_OBJECT; + return false; + } + + // decode the some of the request + switch (wp_data->object_property) + { + case PROP_PRESENT_VALUE: + apdu = wp_data->property_value; + tag_len = decode_tag_number_and_value(&apdu[0], + &tag_number, &len_value_type); + if (tag_len) + { + if (tag_number == BACNET_APPLICATION_TAG_REAL) + { + len = decode_real(&apdu[tag_len],&real_value); + if (len && (real_value >= 0.0) && (real_value <= 100.0)) + level = real_value; + else + { + *error_class = ERROR_CLASS_PROPERTY; + *error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; + return false; + } + object_index = Analog_Output_Instance_To_Index( + wp_data->object_instance); + apdu_len = tag_len + len; + if (decode_is_closing_tag_number(&apdu[apdu_len], 3)) + { + // decode the optional priority + apdu_len++; + if (apdu_len <= wp_data->property_value_len) + priority = BACNET_MAX_PRIORITIES; + else + { + tag_len = decode_tag_number_and_value(&apdu[0], + &tag_number, &len_value_type); + if (tag_number == 4) + { + apdu_len += tag_len; + len = decode_unsigned(&apdu[len], len_value_type, + &priority); + } + } + priority--; + if (priority < BACNET_MAX_PRIORITIES) + { + Analog_Output_Level[object_index][priority] = level; + status = true; + } + else + { + *error_class = ERROR_CLASS_PROPERTY; + *error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; + return false; + } + } + else + { + *error_class = ERROR_CLASS_PROPERTY; + *error_code = ERROR_CODE_INCONSISTENT_PARAMETERS; + return false; + } + } + else + { + *error_class = ERROR_CLASS_PROPERTY; + *error_code = ERROR_CODE_VALUE_OUT_OF_RANGE; + return false; + } + } + else + { + *error_class = ERROR_CLASS_PROPERTY; + *error_code = ERROR_CODE_INVALID_DATA_TYPE; + return false; + } + break; + default: + *error_class = ERROR_CLASS_PROPERTY; + *error_code = ERROR_CODE_WRITE_ACCESS_DENIED; + break; + } + + return status; +} + + +#ifdef TEST +#include +#include +#include "ctest.h" + +void testAnalogInput(Test * pTest) +{ + uint8_t apdu[MAX_APDU] = { 0 }; + int len = 0; + uint32_t len_value = 0; + uint8_t tag_number = 0; + BACNET_OBJECT_TYPE decoded_type = OBJECT_ANALOG_OUTPUT; + uint32_t decoded_instance = 0; + uint32_t instance = 123; + + + len = Analog_Output_Encode_Property_APDU( + &apdu[0], + instance, + PROP_OBJECT_IDENTIFIER, + BACNET_ARRAY_ALL); + ct_test(pTest, len != 0); + len = decode_tag_number_and_value(&apdu[0], &tag_number, &len_value); + ct_test(pTest, tag_number == BACNET_APPLICATION_TAG_OBJECT_ID); + len = decode_object_id(&apdu[len], + (int *) &decoded_type, &decoded_instance); + ct_test(pTest, decoded_type == OBJECT_ANALOG_OUTPUT); + ct_test(pTest, decoded_instance == instance); + + return; +} + +#ifdef TEST_ANALOG_INPUT +int main(void) +{ + Test *pTest; + bool rc; + + pTest = ct_create("BACnet Analog Input", NULL); + /* individual tests */ + rc = ct_addTestFunction(pTest, testAnalogInput); + assert(rc); + + ct_setStream(pTest, stdout); + ct_run(pTest); + (void) ct_report(pTest); + ct_destroy(pTest); + + return 0; +} +#endif /* TEST_ANALOG_INPUT */ +#endif /* TEST */ + + diff --git a/bacnet-stack/ao.h b/bacnet-stack/ao.h new file mode 100644 index 00000000..c7e6f64c --- /dev/null +++ b/bacnet-stack/ao.h @@ -0,0 +1,47 @@ +/************************************************************************** +* +* Copyright (C) 2005 Steve Karg +* +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +* +*********************************************************************/ +#ifndef AO_H +#define AO_H + +#include +#include +#include "bacdef.h" + +bool Analog_Output_Valid_Instance(uint32_t object_instance); +unsigned Analog_Output_Count(void); +uint32_t Analog_Output_Index_To_Instance(unsigned index); + +int Analog_Output_Encode_Property_APDU( + uint8_t *apdu, + uint32_t object_instance, + BACNET_PROPERTY_ID property, + int32_t array_index); + +#ifdef TEST +#include "ctest.h" +void testAnalogOutput(Test * pTest); +#endif + +#endif diff --git a/bacnet-stack/bacdcode.c b/bacnet-stack/bacdcode.c index 073119fb..272d7e02 100644 --- a/bacnet-stack/bacdcode.c +++ b/bacnet-stack/bacdcode.c @@ -592,6 +592,14 @@ bool decode_boolean(uint32_t len_value) return boolean_value; } +// from clause 20.2.2 Encoding of a Null Value +// and 20.2.1 General Rules for Encoding BACnet Tags +// returns the number of apdu bytes consumed +int encode_tagged_null(uint8_t * apdu) +{ + return encode_tag(&apdu[0], BACNET_APPLICATION_TAG_NULL, false, 0); +} + static uint8_t byte_reverse_bits(uint8_t in_byte) { uint8_t out_byte = 0; diff --git a/bacnet-stack/bacdcode.h b/bacnet-stack/bacdcode.h index 4a6f9e63..6988ad19 100644 --- a/bacnet-stack/bacdcode.h +++ b/bacnet-stack/bacdcode.h @@ -66,6 +66,9 @@ bool decode_is_closing_tag_number(uint8_t * apdu, uint8_t tag_number); // returns true if the tag is context specific and matches bool decode_is_context_tag(uint8_t * apdu, uint8_t tag_number); +// from clause 20.2.2 Encoding of a Null Value +int encode_tagged_null(uint8_t * apdu); + // from clause 20.2.3 Encoding of a Boolean Value int encode_tagged_boolean(uint8_t * apdu, bool boolean_value); bool decode_boolean(uint32_t len_value); diff --git a/bacnet-stack/bacdef.h b/bacnet-stack/bacdef.h index 76b66ab9..9fc74cb0 100644 --- a/bacnet-stack/bacdef.h +++ b/bacnet-stack/bacdef.h @@ -47,6 +47,8 @@ // Array index 0=size of array, n=array element n, MAX=all array elements #define BACNET_ARRAY_LENGTH_INDEX 0 #define BACNET_ARRAY_ALL (~0) +// Priority Array for commandable objects +#define BACNET_MAX_PRIORITIES 16 // embedded systems need fixed name sizes #define MAX_OBJECT_NAME 10 diff --git a/bacnet-stack/device.c b/bacnet-stack/device.c index 9316c1fe..c5ba5b7b 100644 --- a/bacnet-stack/device.c +++ b/bacnet-stack/device.c @@ -30,6 +30,7 @@ #include "bacenum.h" #include "config.h" // the custom stuff #include "ai.h" // object list dependency +#include "ao.h" // object list dependency #include "wp.h" // write property handling static uint32_t Object_Instance_Number = 0; @@ -231,6 +232,7 @@ unsigned Device_Object_List_Count(void) unsigned count = 1; count += Analog_Input_Count(); + count += Analog_Output_Count(); return count; } @@ -260,11 +262,15 @@ bool Device_Object_List_Identifier(unsigned array_index, status = true; } } - - // etc. if (!status) { object_index -= Analog_Input_Count(); + if (object_index < Analog_Output_Count()) + { + *object_type = OBJECT_ANALOG_OUTPUT; + *instance = Analog_Output_Index_To_Instance(object_index); + status = true; + } } return status; @@ -385,7 +391,7 @@ int Device_Encode_Property_APDU( { if (Device_Object_List_Identifier(i,&object_type,&instance)) { - len = encode_tagged_object_id(&apdu[0], object_type, + len = encode_tagged_object_id(&apdu[apdu_len], object_type, instance); apdu_len += len; // assume next one is the same size as this one diff --git a/bacnet-stack/handlers.c b/bacnet-stack/handlers.c index 63d07ad6..91420363 100644 --- a/bacnet-stack/handlers.c +++ b/bacnet-stack/handlers.c @@ -34,6 +34,7 @@ #include "apdu.h" #include "device.h" #include "ai.h" +#include "ao.h" #include "rp.h" #include "wp.h" #include "iam.h" @@ -369,6 +370,55 @@ void ReadPropertyHandler( send = true; } break; + case OBJECT_ANALOG_OUTPUT: + if (Analog_Output_Valid_Instance(object_instance)) + { + len = Analog_Output_Encode_Property_APDU( + &Temp_Buf[0], + object_instance, + object_property, + array_index); + if (len > 0) + { + // encode the APDU portion of the packet + rp_data.object_type = object_type; + rp_data.object_instance = object_instance; + rp_data.object_property = object_property; + rp_data.array_index = array_index; + rp_data.application_data = &Temp_Buf[0]; + rp_data.application_data_len = len; + // FIXME: probably need a length limitation sent with encode + pdu_len += rp_ack_encode_apdu( + &Tx_Buf[pdu_len], + service_data->invoke_id, + &rp_data); + fprintf(stderr,"Sending Read Property Ack!\n"); + send = true; + } + else + { + pdu_len += bacerror_encode_apdu( + &Tx_Buf[pdu_len], + service_data->invoke_id, + SERVICE_CONFIRMED_READ_PROPERTY, + ERROR_CLASS_PROPERTY, + ERROR_CODE_UNKNOWN_PROPERTY); + fprintf(stderr,"Sending Unknown Property Error!\n"); + send = true; + } + } + else + { + pdu_len += bacerror_encode_apdu( + &Tx_Buf[pdu_len], + service_data->invoke_id, + SERVICE_CONFIRMED_READ_PROPERTY, + ERROR_CLASS_OBJECT, + ERROR_CODE_UNKNOWN_OBJECT); + fprintf(stderr,"Sending Unknown Object Error!\n"); + send = true; + } + break; default: pdu_len += bacerror_encode_apdu( &Tx_Buf[pdu_len], @@ -487,6 +537,16 @@ void WritePropertyHandler( fprintf(stderr,"Sending Write Access Error!\n"); send = true; break; + case OBJECT_ANALOG_OUTPUT: + pdu_len += bacerror_encode_apdu( + &Tx_Buf[pdu_len], + service_data->invoke_id, + SERVICE_CONFIRMED_WRITE_PROPERTY, + ERROR_CLASS_PROPERTY, + ERROR_CODE_WRITE_ACCESS_DENIED); + fprintf(stderr,"Sending Write Access Error!\n"); + send = true; + break; default: pdu_len += bacerror_encode_apdu( &Tx_Buf[pdu_len],