adding analog output object

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 \

bacnet-stack/ao.c

@@ -0,0 +1,417 @@
+/**************************************************************************
+*
+* Copyright (C) 2005 Steve Karg <skarg@users.sourceforge.net>
+*
+* 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 <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#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 <assert.h>
+#include <string.h>
+#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 */
+
+

bacnet-stack/ao.h

@@ -0,0 +1,47 @@
+/**************************************************************************
+*
+* Copyright (C) 2005 Steve Karg <skarg@users.sourceforge.net>
+*
+* 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 <stdbool.h>
+#include <stdint.h>
+#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

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;

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);

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

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

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],