Changed WhoHas and I-Have to use CharacterString instead of forcing ANSI X34 and C Strings. Affected all demos and ports object name, so I changed the object name function name to make sure it was noticed.

2011-03-24 16:53:02 +00:00
parent 75d88abf77
commit deab12a5e1
74 changed files with 1566 additions and 850 deletions
@@ -45,6 +45,8 @@ AVRDUDE_PORT = usb
 # Source locations
 BACNET_CORE = ../../src
 BACNET_INCLUDE = ../../include
+BACNET_HANDLER = ../../demo/handler
+BACNET_OBJECT = ../../demo/object
 BACNET_DEMO = ../../demo

 # local files for this project
@@ -65,6 +67,7 @@ CSRC = main.c \
 	dlmstp.c \
 	test.c \
 	bacnet.c \
+	bname.c \
 	device.c \
 	ai.c \
 	av.c \
@@ -130,7 +133,7 @@ CORESRC =  \
 #	$(BACNET_CORE)/address.c \

 ## Include Directories
-INCLUDES = -I. -I$(BACNET_INCLUDE)
+INCLUDES = -I. -I$(BACNET_INCLUDE) -I$(BACNET_HANDLER) -I$(BACNET_OBJECT)

 # Source to Object conversion
 COBJ = $(CSRC:%.c=%.o)
@@ -109,17 +109,19 @@ uint32_t Analog_Input_Index_To_Instance(
    return index;
 }

-char *Analog_Input_Name(
-    uint32_t object_instance)
+bool Analog_Input_Object_Name(
+    uint32_t object_instance,
+    BACNET_CHARACTER_STRING *object_name)
 {
    static char text_string[32];        /* okay for single thread */
+    bool status = false;

    if (object_instance < MAX_ANALOG_INPUTS) {
        sprintf(text_string, "AI-%lu", object_instance);
-        return text_string;
+        status = characterstring_init_ansi(object_name, text_string);
    }

-    return NULL;
+    return status;
 }

 float Analog_Input_Present_Value(
@@ -175,19 +175,21 @@ bool Analog_Value_Present_Value_Set(
 }

 /* note: the object name must be unique within this device */
-char *Analog_Value_Name(
-    uint32_t object_instance)
+bool Analog_Value_Object_Name(
+    uint32_t object_instance,
+    BACNET_CHARACTER_STRING *object_name)
 {
    static char text_string[32] = "";   /* okay for single thread */
    unsigned index = 0;
+    bool status = false;

    index = Analog_Value_Instance_To_Index(object_instance);
    if (index < MAX_ANALOG_VALUES) {
        sprintf(text_string, "AV-%lu", object_instance);
-        return text_string;
+        status = characterstring_init_ansi(object_name, text_string);
    }

-    return NULL;
+    return status;
 }

 /* return apdu len, or -1 on error */
@@ -85,10 +85,10 @@ void bacnet_init(
    dlmstp_init(NULL);

    if (!seeprom_version_test()) {
-        /* invalid version data */
+        /* do something when SEEPROM is invalid - i.e. init to defaults */
    }
    /* initialize objects */
-    Device_Init();
+    Device_Init(NULL);

    /* set up our confirmed service unrecognized service handler - required! */
    apdu_set_unrecognized_service_handler_handler
@@ -157,17 +157,19 @@ bool Binary_Input_Present_Value_Set(
    return false;
 }

-char *Binary_Input_Name(
-    uint32_t object_instance)
+bool Binary_Input_Object_Name(
+    uint32_t object_instance,
+    BACNET_CHARACTER_STRING *object_name)
 {
    static char text_string[32];        /* okay for single thread */
+    bool status = false;

    if (object_instance < MAX_BINARY_INPUTS) {
        sprintf(text_string, "BI-%lu", object_instance);
-        return text_string;
+        status = characterstring_init_ansi(object_name, text_string);
    }

-    return NULL;
+    return status;
 }

 /* return apdu length, or -1 on error */
@@ -0,0 +1,275 @@
+/**************************************************************************
+*
+* Copyright (C) 2011 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.
+*
+*********************************************************************/
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include "hardware.h"
+#include "bacdef.h"
+#include "bacdcode.h"
+#include "bacstr.h"
+#include "nvdata.h"
+#include "seeprom.h"
+#include "device.h"
+#include "bname.h"
+
+/* Basic UTF-8 manipulation routines
+  by Jeff Bezanson
+  placed in the public domain Fall 2005 */
+static const char trailingBytesForUTF8[256] = {
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/* based on the valid_utf8 routine from the PCRE library by Philip Hazel
+   length is in bytes, since without knowing whether the string is valid
+   it's hard to know how many characters there are! */
+static int utf8_isvalid(const char *str, int length)
+{
+    const unsigned char *p, *pend = (unsigned char*)str + length;
+    unsigned char c;
+    int ab;
+
+    for (p = (unsigned char*)str; p < pend; p++) {
+        c = *p;
+        /* null in middle of string */
+        if (c == 0) {
+            return 0;
+        }
+        /* ASCII character */
+        if (c < 128) {
+            continue;
+        }
+        if ((c & 0xc0) != 0xc0) {
+            return 0;
+        }
+        ab = trailingBytesForUTF8[c];
+        if (length < ab) {
+            return 0;
+        }
+        length -= ab;
+
+        p++;
+        /* Check top bits in the second byte */
+        if ((*p & 0xc0) != 0x80) {
+            return 0;
+        }
+        /* Check for overlong sequences for each different length */
+        switch (ab) {
+            /* Check for xx00 000x */
+        case 1:
+            if ((c & 0x3e) == 0) return 0;
+            continue;   /* We know there aren't any more bytes to check */
+
+            /* Check for 1110 0000, xx0x xxxx */
+        case 2:
+            if (c == 0xe0 && (*p & 0x20) == 0) return 0;
+            break;
+
+            /* Check for 1111 0000, xx00 xxxx */
+        case 3:
+            if (c == 0xf0 && (*p & 0x30) == 0) return 0;
+            break;
+
+            /* Check for 1111 1000, xx00 0xxx */
+        case 4:
+            if (c == 0xf8 && (*p & 0x38) == 0) return 0;
+            break;
+
+            /* Check for leading 0xfe or 0xff,
+               and then for 1111 1100, xx00 00xx */
+        case 5:
+            if (c == 0xfe || c == 0xff ||
+                (c == 0xfc && (*p & 0x3c) == 0)) return 0;
+            break;
+        }
+
+        /* Check for valid bytes after the 2nd, if any; all must start 10 */
+        while (--ab > 0) {
+            if ((*(++p) & 0xc0) != 0x80) return 0;
+        }
+    }
+
+    return 1;
+}
+
+static bool bacnet_name_isvalid(
+    uint8_t encoding,
+    uint8_t length,
+    char *str)
+{
+    bool valid = false;
+
+    if ((encoding < MAX_CHARACTER_STRING_ENCODING) &&
+        (length <= NV_EEPROM_NAME_SIZE)) {
+        if (encoding == CHARACTER_ANSI_X34) {
+            if (utf8_isvalid(str, length)) {
+                valid = true;
+            }
+        } else {
+            valid = true;
+        }
+    }
+
+    return valid;
+}
+
+bool bacnet_name_set(
+    uint16_t offset,
+    BACNET_CHARACTER_STRING *char_string)
+{
+    uint8_t encoding = 0;
+    uint8_t length = 0;
+    char *str = NULL;
+
+    length = characterstring_length(char_string);
+    encoding = characterstring_encoding(char_string);
+    str = characterstring_value(char_string);
+    if (bacnet_name_isvalid(encoding, length, str)) {
+        seeprom_bytes_write(
+            NV_EEPROM_NAME_LENGTH(offset),
+            &length, 1);
+        seeprom_bytes_write(
+            NV_EEPROM_NAME_ENCODING(offset),
+            &encoding, 1);
+        seeprom_bytes_write(
+            NV_EEPROM_NAME_STRING(offset),
+            (uint8_t *)str,
+            length);
+        return true;
+    }
+
+    return false;
+}
+
+bool bacnet_name_write(
+    uint16_t offset,
+    BACNET_CHARACTER_STRING *char_string,
+    BACNET_ERROR_CLASS *error_class,
+    BACNET_ERROR_CODE *error_code)
+{
+    bool status = false;
+    size_t length = 0;
+    uint8_t encoding = 0;
+
+    length = characterstring_length(char_string);
+
+    if (length < 1) {
+        *error_class = ERROR_CLASS_PROPERTY;
+        *error_code = ERROR_CODE_VALUE_OUT_OF_RANGE;
+    } else if (length <= NV_EEPROM_NAME_SIZE) {
+        encoding = characterstring_encoding(char_string);
+        if (encoding < MAX_CHARACTER_STRING_ENCODING) {
+            if (Device_Valid_Object_Name(char_string, NULL, NULL)) {
+                *error_class = ERROR_CLASS_PROPERTY;
+                *error_code = ERROR_CODE_DUPLICATE_NAME;
+            } else {
+                status = bacnet_name_set(offset, char_string);
+                if (status) {
+                    Device_Inc_Database_Revision();
+                } else {
+                    *error_class = ERROR_CLASS_PROPERTY;
+                    *error_code = ERROR_CODE_VALUE_OUT_OF_RANGE;
+                }
+            }
+        } else {
+            *error_class = ERROR_CLASS_PROPERTY;
+            *error_code = ERROR_CODE_CHARACTER_SET_NOT_SUPPORTED;
+        }
+    } else {
+        *error_class = ERROR_CLASS_PROPERTY;
+        *error_code = ERROR_CODE_NO_SPACE_TO_WRITE_PROPERTY;
+    }
+
+    return status;
+}
+
+/* no required minumum length or duplicate checking */
+bool bacnet_name_write_other(
+    uint16_t offset,
+    BACNET_CHARACTER_STRING *char_string,
+    BACNET_ERROR_CLASS *error_class,
+    BACNET_ERROR_CODE *error_code)
+{
+    bool status = false;
+    size_t length = 0;
+    uint8_t encoding = 0;
+
+    length = characterstring_length(char_string);
+
+    if (length <= NV_EEPROM_NAME_SIZE) {
+        encoding = characterstring_encoding(char_string);
+        if (encoding < MAX_CHARACTER_STRING_ENCODING) {
+            status = bacnet_name_set(offset, char_string);
+            if (!status) {
+                *error_class = ERROR_CLASS_PROPERTY;
+                *error_code = ERROR_CODE_VALUE_OUT_OF_RANGE;
+            }
+        } else {
+            *error_class = ERROR_CLASS_PROPERTY;
+            *error_code = ERROR_CODE_CHARACTER_SET_NOT_SUPPORTED;
+        }
+    } else {
+        *error_class = ERROR_CLASS_PROPERTY;
+        *error_code = ERROR_CODE_NO_SPACE_TO_WRITE_PROPERTY;
+    }
+
+    return status;
+}
+
+void bacnet_name_init(
+    uint16_t offset,
+    BACNET_CHARACTER_STRING *char_string,
+    char *default_string)
+{
+    characterstring_init_ansi(char_string, default_string);
+    (void)bacnet_name_set(offset, char_string);
+}
+
+void bacnet_name(
+    uint16_t offset,
+    BACNET_CHARACTER_STRING *char_string,
+    char *default_string)
+{
+    uint8_t encoding = 0;
+    uint8_t length = 0;
+    char name[NV_EEPROM_NAME_SIZE + 1] = "";
+
+    seeprom_bytes_read(NV_EEPROM_NAME_ENCODING(offset), &encoding, 1);
+    seeprom_bytes_read(NV_EEPROM_NAME_LENGTH(offset), &length, 1);
+    seeprom_bytes_read(NV_EEPROM_NAME_STRING(offset), (uint8_t *) & name,
+        NV_EEPROM_NAME_SIZE);
+    if (bacnet_name_isvalid(length, encoding, name)) {
+        characterstring_init(char_string, encoding, &name[0], length);
+    } else if (default_string) {
+        bacnet_name_init(offset, char_string, default_string);
+    }
+}
@@ -0,0 +1,60 @@
+/**************************************************************************
+*
+* Copyright (C) 2010 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 BACNET_NAME_H
+#define BACNET_NAME_H
+
+#include <stdint.h>
+#include "bacstr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+    bool bacnet_name_set(
+        uint16_t eeprom_offset,
+        BACNET_CHARACTER_STRING *char_string);
+    void bacnet_name_init(
+        uint16_t eeprom_offset,
+        BACNET_CHARACTER_STRING *char_string,
+        char *default_string);
+    void bacnet_name(
+        uint16_t eeprom_offset,
+        BACNET_CHARACTER_STRING *char_string,
+        char *default_string);
+    bool bacnet_name_write(
+        uint16_t offset,
+        BACNET_CHARACTER_STRING *char_string,
+        BACNET_ERROR_CLASS *error_class,
+        BACNET_ERROR_CODE *error_code);
+    /* no required minumum length or duplicate checking */
+    bool bacnet_name_write_other(
+        uint16_t offset,
+        BACNET_CHARACTER_STRING *char_string,
+        BACNET_ERROR_CLASS *error_class,
+        BACNET_ERROR_CODE *error_code);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif
@@ -229,17 +229,19 @@ bool Binary_Output_Out_Of_Service(
 }

 /* note: the object name must be unique within this device */
-char *Binary_Output_Name(
-    uint32_t object_instance)
+bool Binary_Output_Object_Name(
+    uint32_t object_instance,
+    BACNET_CHARACTER_STRING *object_name)
 {
    static char text_string[32];        /* okay for single thread */
+    bool status = false;

    if (object_instance < MAX_BINARY_OUTPUTS) {
        sprintf(text_string, "BO-%lu", object_instance);
-        return text_string;
+        status = characterstring_init_ansi(object_name, text_string);
    }

-    return NULL;
+    return status;
 }

 /* return apdu len, or -1 on error */
@@ -39,6 +39,7 @@
 #include "nvdata.h"
 #include "stack.h"
 #include "handlers.h"
+#include "bname.h"
 /* objects */
 #include "device.h"
 #include "ai.h"
@@ -66,24 +67,24 @@ static struct my_object_functions {
    {
        OBJECT_DEVICE, NULL,    /* don't init - recursive! */
    Device_Count, Device_Index_To_Instance,
-            Device_Valid_Object_Instance_Number, Device_Name,
+            Device_Valid_Object_Instance_Number, Device_Object_Name,
            Device_Read_Property_Local, Device_Write_Property_Local,
            Device_Property_Lists}, {
    OBJECT_ANALOG_INPUT, Analog_Input_Init, Analog_Input_Count,
            Analog_Input_Index_To_Instance, Analog_Input_Valid_Instance,
-            Analog_Input_Name, Analog_Input_Read_Property, NULL,
+            Analog_Input_Object_Name, Analog_Input_Read_Property, NULL,
            Analog_Input_Property_Lists}, {
    OBJECT_ANALOG_VALUE, Analog_Value_Init, Analog_Value_Count,
            Analog_Value_Index_To_Instance, Analog_Value_Valid_Instance,
-            Analog_Value_Name, Analog_Value_Read_Property,
+            Analog_Value_Object_Name, Analog_Value_Read_Property,
            Analog_Value_Write_Property, Analog_Value_Property_Lists}, {
    OBJECT_BINARY_INPUT, Binary_Input_Init, Binary_Input_Count,
            Binary_Input_Index_To_Instance, Binary_Input_Valid_Instance,
-            Binary_Input_Name, Binary_Input_Read_Property, NULL,
+            Binary_Input_Object_Name, Binary_Input_Read_Property, NULL,
            Binary_Input_Property_Lists}, {
    OBJECT_BINARY_OUTPUT, Binary_Output_Init, Binary_Output_Count,
            Binary_Output_Index_To_Instance, Binary_Output_Valid_Instance,
-            Binary_Output_Name, Binary_Output_Read_Property,
+            Binary_Output_Object_Name, Binary_Output_Read_Property,
            Binary_Output_Write_Property, Binary_Output_Property_Lists}, {
    MAX_BACNET_OBJECT_TYPE, NULL, NULL, NULL, NULL, NULL, NULL, NULL}
 };
@@ -94,7 +95,7 @@ static struct my_object_functions {
   into the read-property encoding. */
 static uint32_t Object_Instance_Number;
 static BACNET_DEVICE_STATUS System_Status = STATUS_OPERATIONAL;
-
+static uint32_t Database_Revision;
 static BACNET_REINITIALIZED_STATE Reinitialize_State = BACNET_REINIT_IDLE;

 /* These three arrays are used by the ReadPropertyMultiple handler */
@@ -130,6 +131,9 @@ static const int Device_Properties_Optional[] = {
 };

 static const int Device_Properties_Proprietary[] = {
+    512,
+    513,
+    9600,
    -1
 };

@@ -157,7 +161,6 @@ static int Read_Property_Common(
 {
    int apdu_len = BACNET_STATUS_ERROR;
    BACNET_CHARACTER_STRING char_string;
-    char *pString = "";
    uint8_t *apdu = NULL;

    if ((rpdata->application_data == NULL) ||
@@ -178,9 +181,12 @@ static int Read_Property_Common(
            break;
        case PROP_OBJECT_NAME:
            if (pObject->Object_Name) {
-                pString = pObject->Object_Name(rpdata->object_instance);
+                (void)pObject->Object_Name(
+                    rpdata->object_instance,
+                    &char_string);
+            } else {
+                characterstring_init_ansi(&char_string, "");
            }
-            characterstring_init_ansi(&char_string, pString);
            apdu_len =
                encode_application_character_string(&apdu[0], &char_string);
            break;
@@ -334,38 +340,30 @@ uint32_t Device_Index_To_Instance(
    return Object_Instance_Number;
 }

-char *Device_Name(
-    uint32_t object_instance)
+static char *Device_Name_Default(void)
 {
-    uint8_t encoding = 0;
-    uint8_t length = 0;
-    static char name[NV_EEPROM_DEVICE_NAME_SIZE + 1] = "";
-    char *pName = NULL;
+    static char text_string[32];        /* okay for single thread */
+
+    sprintf(text_string, "DEVICE-%lu", Object_Instance_Number);
+
+    return text_string;
+}
+
+bool Device_Object_Name(
+    uint32_t object_instance,
+    BACNET_CHARACTER_STRING *object_name)
+{
+    bool status = false;

    if (object_instance == Object_Instance_Number) {
-        eeprom_bytes_read(NV_EEPROM_DEVICE_NAME_ENCODING, &encoding, 1);
-        eeprom_bytes_read(NV_EEPROM_DEVICE_NAME_LENGTH, &length, 1);
-        eeprom_bytes_read(NV_EEPROM_DEVICE_NAME_0, (uint8_t *) & name,
-            NV_EEPROM_DEVICE_NAME_SIZE);
-        if ((encoding >= MAX_CHARACTER_STRING_ENCODING) ||
-            (length > NV_EEPROM_DEVICE_NAME_SIZE) || (length < 1)) {
-            encoding = CHARACTER_ANSI_X34;
-            eeprom_bytes_write(NV_EEPROM_DEVICE_NAME_ENCODING, &encoding, 1);
-            sprintf(name, "DEVICE-%lu", Object_Instance_Number);
-            eeprom_bytes_write(NV_EEPROM_DEVICE_NAME_0, (uint8_t *) & name[0],
-                NV_EEPROM_DEVICE_NAME_SIZE);
-            length = strlen(name);
-            eeprom_bytes_write(NV_EEPROM_DEVICE_NAME_LENGTH, &length, 1);
-        }
-        if (length < NV_EEPROM_DEVICE_NAME_SIZE) {
-            name[length] = 0;
-        } else {
-            name[NV_EEPROM_DEVICE_NAME_SIZE] = 0;
-        }
-        pName = &name[0];
+        bacnet_name(
+            NV_EEPROM_DEVICE_NAME,
+            object_name,
+            Device_Name_Default());
+        status = true;
    }

-    return pName;
+    return status;
 }

 bool Device_Reinitialize(
@@ -397,10 +395,14 @@ BACNET_REINITIALIZED_STATE Device_Reinitialized_State(
 }

 void Device_Init(
-    void)
+        object_functions_t * object_table)
 {
    struct my_object_functions *pObject = NULL;

+    /* we don't use the object table passed in
+       since there is extra stuff we don't need in there. */
+    (void)object_table;
+    /* our local object table */
    pObject = &Object_Table[0];
    while (pObject->Object_Type < MAX_BACNET_OBJECT_TYPE) {
        if (pObject->Object_Init) {
@@ -418,7 +420,6 @@ void Device_Init(
            (uint8_t *) & Object_Instance_Number,
            sizeof(Object_Instance_Number));
    }
-    (void) Device_Name(Object_Instance_Number);
 }

 /* methods to manipulate the data */
@@ -488,7 +489,13 @@ BACNET_SEGMENTATION Device_Segmentation_Supported(
 uint32_t Device_Database_Revision(
    void)
 {
-    return 0;
+    return Database_Revision;
+}
+
+void Device_Inc_Database_Revision(
+    void)
+{
+    Database_Revision++;
 }

 /* Since many network clients depend on the object list */
@@ -546,7 +553,7 @@ bool Device_Object_List_Identifier(
 }

 bool Device_Valid_Object_Name(
-    const char *object_name,
+    BACNET_CHARACTER_STRING *object_name1,
    int *object_type,
    uint32_t * object_instance)
 {
@@ -555,14 +562,17 @@ bool Device_Valid_Object_Name(
    uint32_t instance;
    unsigned max_objects = 0, i = 0;
    bool check_id = false;
-    char *name = NULL;
+    BACNET_CHARACTER_STRING object_name2;
+    struct my_object_functions *pObject = NULL;

    max_objects = Device_Object_List_Count();
    for (i = 0; i < max_objects; i++) {
        check_id = Device_Object_List_Identifier(i, &type, &instance);
        if (check_id) {
-            name = Device_Valid_Object_Id(type, instance);
-            if (strcmp(name, object_name) == 0) {
+            pObject = Device_Objects_Find_Functions(type);
+            if ((pObject != NULL) && (pObject->Object_Name != NULL) &&
+                (pObject->Object_Name(instance, &object_name2) &&
+                characterstring_same(object_name1, &object_name2))) {
                found = true;
                if (object_type) {
                    *object_type = type;
@@ -578,20 +588,46 @@ bool Device_Valid_Object_Name(
    return found;
 }

-/* returns the name or NULL if not found */
-char *Device_Valid_Object_Id(
+bool Device_Valid_Object_Id(
    int object_type,
    uint32_t object_instance)
 {
-    char *name = NULL;  /* return value */
+    bool status = false;  /* return value */
    struct my_object_functions *pObject = NULL;

-    pObject = Device_Objects_Find_Functions((BACNET_OBJECT_TYPE) object_type);
-    if ((pObject) && (pObject->Object_Name)) {
-        name = pObject->Object_Name(object_instance);
+    pObject = Device_Objects_Find_Functions(object_type);
+    if ((pObject != NULL) && (pObject->Object_Valid_Instance != NULL)) {
+        status = pObject->Object_Valid_Instance(object_instance);
    }

-    return name;
+    return status;
+}
+
+bool Device_Object_Name_Copy(
+    int object_type,
+    uint32_t object_instance,
+    BACNET_CHARACTER_STRING *object_name)
+{
+    struct my_object_functions *pObject = NULL;
+    bool found = false;
+    int type = 0;
+    uint32_t instance;
+    unsigned max_objects = 0, i = 0;
+    bool check_id = false;
+
+    max_objects = Device_Object_List_Count();
+    for (i = 0; i < max_objects; i++) {
+        check_id = Device_Object_List_Identifier(i, &type, &instance);
+        if (check_id) {
+            pObject = Device_Objects_Find_Functions(type);
+            if ((pObject != NULL) && (pObject->Object_Name != NULL)) {
+                found = pObject->Object_Name(instance, object_name);
+                break;
+            }
+        }
+    }
+
+    return found;
 }

 /* return the length of the apdu encoded or BACNET_STATUS_ERROR for error */
@@ -616,7 +652,18 @@ int Device_Read_Property_Local(
    apdu = rpdata->application_data;
    switch (rpdata->object_property) {
        case PROP_DESCRIPTION:
-            characterstring_init_ansi(&char_string, "BACnet Development Kit");
+            bacnet_name(
+                NV_EEPROM_DEVICE_DESCRIPTION,
+                &char_string,
+                "BACnet Development Kit");
+            apdu_len =
+                encode_application_character_string(&apdu[0], &char_string);
+            break;
+        case PROP_LOCATION:
+            bacnet_name(
+                NV_EEPROM_DEVICE_LOCATION,
+                &char_string,
+                "default location");
            apdu_len =
                encode_application_character_string(&apdu[0], &char_string);
            break;
@@ -672,7 +719,6 @@ int Device_Read_Property_Local(
               not a list of objects that this device can access */
            bitstring_init(&bit_string);
            for (i = 0; i < MAX_ASHRAE_OBJECT_TYPE; i++) {
-                /* FIXME: if ReadProperty used an array of Functions... */
                /* initialize all the object types to not-supported */
                bitstring_set_bit(&bit_string, (uint8_t) i, false);
            }
@@ -858,38 +904,35 @@ bool Device_Write_Property_Local(
            break;
        case PROP_OBJECT_NAME:
            if (value.tag == BACNET_APPLICATION_TAG_CHARACTER_STRING) {
-                size_t length =
-                    characterstring_length(&value.type.Character_String);
-                if (length < 1) {
-                    wp_data->error_class = ERROR_CLASS_PROPERTY;
-                    wp_data->error_code = ERROR_CODE_VALUE_OUT_OF_RANGE;
-                } else if (length < NV_EEPROM_DEVICE_NAME_SIZE) {
-                    uint8_t encoding =
-                        characterstring_encoding(&value.type.Character_String);
-                    if (encoding < MAX_CHARACTER_STRING_ENCODING) {
-                        char *pCharString;
-                        uint8_t small_length;
-                        eeprom_bytes_write(NV_EEPROM_DEVICE_NAME_ENCODING,
-                            &encoding, 1);
-                        small_length = length;
-                        eeprom_bytes_write(NV_EEPROM_DEVICE_NAME_LENGTH,
-                            &small_length, 1);
-                        pCharString =
-                            characterstring_value(&value.type.
-                            Character_String);
-                        eeprom_bytes_write(NV_EEPROM_DEVICE_NAME_0,
-                            (uint8_t *) pCharString, length);
-                        status = true;
-                    } else {
-                        wp_data->error_class = ERROR_CLASS_PROPERTY;
-                        wp_data->error_code =
-                            ERROR_CODE_CHARACTER_SET_NOT_SUPPORTED;
-                    }
-                } else {
-                    wp_data->error_class = ERROR_CLASS_PROPERTY;
-                    wp_data->error_code =
-                        ERROR_CODE_NO_SPACE_TO_WRITE_PROPERTY;
-                }
+                status = bacnet_name_write(
+                    NV_EEPROM_DEVICE_NAME,
+                    &value.type.Character_String,
+                    &wp_data->error_class,
+                    &wp_data->error_code);
+            } else {
+                wp_data->error_class = ERROR_CLASS_PROPERTY;
+                wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE;
+            }
+            break;
+        case PROP_DESCRIPTION:
+            if (value.tag == BACNET_APPLICATION_TAG_CHARACTER_STRING) {
+                status = bacnet_name_write_other(
+                    NV_EEPROM_DEVICE_DESCRIPTION,
+                    &value.type.Character_String,
+                    &wp_data->error_class,
+                    &wp_data->error_code);
+            } else {
+                wp_data->error_class = ERROR_CLASS_PROPERTY;
+                wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE;
+            }
+            break;
+        case PROP_LOCATION:
+            if (value.tag == BACNET_APPLICATION_TAG_CHARACTER_STRING) {
+                status = bacnet_name_write_other(
+                    NV_EEPROM_DEVICE_LOCATION,
+                    &value.type.Character_String,
+                    &wp_data->error_class,
+                    &wp_data->error_code);
            } else {
                wp_data->error_class = ERROR_CLASS_PROPERTY;
                wp_data->error_code = ERROR_CODE_INVALID_DATA_TYPE;
@@ -28,21 +28,8 @@
 #include "seeprom.h"
 #include "eeprom.h"

-/* data version - use to check valid version */
-#define SEEPROM_ID 0xBAC0
-#define SEEPROM_VERSION 0x0001
-
-#define SEEPROM_BYTES_MAX (2*1024)
-
-/* list of SEEPROM addresses */
-/* note to developers: define each byte, 
-   even if they are not used explicitly */
-#define NV_SEEPROM_TYPE_0 0
-#define NV_SEEPROM_TYPE_1 1
-#define NV_SEEPROM_VERSION_0 2
-#define NV_SEEPROM_VERSION_1 3
-/* --- */
-/* define the MAC, BAUD, MAX Master, Device Instance internal 
+/*=============== EEPROM ================*/
+/* define the MAC, BAUD, MAX Master, Device Instance internal
   so that bootloader *could* use them. */
 /* note: MAC could come from DIP switch, or be in non-volatile memory */
 #define NV_EEPROM_MAC 0
@@ -54,49 +41,44 @@
 #define NV_EEPROM_DEVICE_1 4
 #define NV_EEPROM_DEVICE_2 5
 #define NV_EEPROM_DEVICE_3 6
-/* Device Name */
-#define NV_EEPROM_DEVICE_NAME_LENGTH 8
-#define NV_EEPROM_DEVICE_NAME_ENCODING 9
-#define NV_EEPROM_DEVICE_NAME_0 10
-#define NV_EEPROM_DEVICE_NAME_1 11
-#define NV_EEPROM_DEVICE_NAME_2 12
-#define NV_EEPROM_DEVICE_NAME_3 13
-#define NV_EEPROM_DEVICE_NAME_4 14
-#define NV_EEPROM_DEVICE_NAME_5 15
-#define NV_EEPROM_DEVICE_NAME_6 16
-#define NV_EEPROM_DEVICE_NAME_7 17
-#define NV_EEPROM_DEVICE_NAME_8 18
-#define NV_EEPROM_DEVICE_NAME_9 19
-#define NV_EEPROM_DEVICE_NAME_10 20
-#define NV_EEPROM_DEVICE_NAME_11 21
-#define NV_EEPROM_DEVICE_NAME_12 22
-#define NV_EEPROM_DEVICE_NAME_13 23
-#define NV_EEPROM_DEVICE_NAME_14 24
-#define NV_EEPROM_DEVICE_NAME_15 25
-#define NV_EEPROM_DEVICE_NAME_16 26
-#define NV_EEPROM_DEVICE_NAME_17 27
-#define NV_EEPROM_DEVICE_NAME_18 28
-#define NV_EEPROM_DEVICE_NAME_19 29
-#define NV_EEPROM_DEVICE_NAME_20 30
-#define NV_EEPROM_DEVICE_NAME_21 31
-#define NV_EEPROM_DEVICE_NAME_22 32
-#define NV_EEPROM_DEVICE_NAME_23 33
-#define NV_EEPROM_DEVICE_NAME_24 34
-#define NV_EEPROM_DEVICE_NAME_25 35
-#define NV_EEPROM_DEVICE_NAME_26 36
-#define NV_EEPROM_DEVICE_NAME_27 37
-#define NV_EEPROM_DEVICE_NAME_28 38
-#define NV_EEPROM_DEVICE_NAME_29 39
-#define NV_EEPROM_DEVICE_NAME_30 40
-#define NV_EEPROM_DEVICE_NAME_31 41
-#define NV_EEPROM_DEVICE_NAME_SIZE 32
+
+/* EEPROM free space - 7..31 */
+
+/* BACnet Names - 32 bytes of data each */
+#define NV_EEPROM_NAME_LENGTH(n) ((n)+0)
+#define NV_EEPROM_NAME_ENCODING(n) ((n)+1)
+#define NV_EEPROM_NAME_STRING(n) ((n)+2)
+#define NV_EEPROM_NAME_SIZE 30
+#define NV_EEPROM_NAME_OFFSET (1+1+NV_EEPROM_NAME_SIZE)
+/* Device Name - starting offset */
+#define NV_EEPROM_DEVICE_NAME 32
+/* Device Description - starting offset  */
+#define NV_EEPROM_DEVICE_DESCRIPTION \
+    (NV_EEPROM_DEVICE_NAME+NV_EEPROM_NAME_OFFSET)
+/* Device Location - starting offset  */
+#define NV_EEPROM_DEVICE_LOCATION \
+    (NV_EEPROM_DEVICE_DESCRIPTION+NV_EEPROM_NAME_OFFSET)
+
+/* EEPROM free space 128..1024 */

 /*=============== SEEPROM ================*/
-#define NV_SEEPROM_BINARY_OUTPUT_OFFSET 32
-#define NV_SEEPROM_BINARY_OUTPUT_0 10
-#define NV_SEEPROM_BINARY_OUTPUT(n,p) \
-    (NV_SEEPROM_BINARY_OUTPUT_0 + \
-    (NV_SEEPROM_BINARY_OUTPUT_OFFSET * (n)) + (p))
+/* data version - use to check valid version */
+#define SEEPROM_ID 0xBAC0
+#define SEEPROM_VERSION 0x0001
+
+#define SEEPROM_BYTES_MAX (2*1024)
+
+/* list of SEEPROM addresses */
+/* note to developers: define each byte,
+   even if they are not used explicitly */
+#define NV_SEEPROM_TYPE_0 0
+#define NV_SEEPROM_TYPE_1 1
+#define NV_SEEPROM_VERSION_0 2
+#define NV_SEEPROM_VERSION_1 3
+
+/* SEEPROM free space - 4..31 */
+
+#define NV_SEEPROM_BINARY_OUTPUT_0 32
 /* BO properties */
 #define NV_SEEPROM_BO_POLARITY 0
 #define NV_SEEPROM_BO_OUT_OF_SERVICE 1
@@ -116,8 +98,13 @@
 #define NV_SEEPROM_BO_PRIORITY_ARRAY_14 15
 #define NV_SEEPROM_BO_PRIORITY_ARRAY_15 16
 #define NV_SEEPROM_BO_PRIORITY_ARRAY_16 17
+/* formula for paramters */
+#define NV_SEEPROM_BINARY_OUTPUT_SIZE 18
+#define NV_SEEPROM_BINARY_OUTPUT(n,p) \
+    (NV_SEEPROM_BINARY_OUTPUT_0 + \
+    (NV_SEEPROM_BINARY_OUTPUT_SIZE * (n)) + (p))

-
+/* SEEPROM free space - depends on number of BO */

 #ifdef __cplusplus
 extern "C" {