[WIP] improving shell to get/set values

skarg · skarg · commit 494112f183a0 · 2025-09-09T10:55:29.000-05:00
diff --git a/zephyr/include/bacnet_settings/bacnet_storage.h b/zephyr/include/bacnet_settings/bacnet_storage.h
@@ -44,6 +44,8 @@ int bacnet_storage_handler_commit(void);
 int bacnet_storage_handler_export(int (*cb)(const char *name, const void *value, size_t val_len));
 
 bool bacnet_storage_strtoul(const char *search_name, unsigned long *long_value);
+bool bacnet_storage_strtol(const char *search_name, long *long_value);
+bool bacnet_storage_strtof(const char *search_name, float *float_value);
 
 void bacnet_storage_key_init(BACNET_STORAGE_KEY *key, uint16_t object_type,
 			     uint32_t object_instance, uint32_t property_id, uint32_t array_index);
diff --git a/zephyr/samples/profiles/b-ld/src/main.c b/zephyr/samples/profiles/b-ld/src/main.c
@@ -73,6 +73,14 @@ void BACnet_Lighting_Output_Tracking_Value_Handler(uint32_t object_instance, flo
 static bool Settings_Restore_Callback(BACNET_WRITE_PROPERTY_DATA *wp_data, void *context)
 {
 	(void)context;
+	if (wp_data == NULL) {
+		return false;
+	}
+	if ((wp_data->object_type == OBJECT_DEVICE) &&
+	    (wp_data->object_instance == BACNET_MAX_INSTANCE)) {
+		wp_data->object_instance = Device_Object_Instance_Number();
+	}
+
 	return Device_Write_Property(wp_data);
 }
 
diff --git a/zephyr/subsys/bacnet_settings/bacnet_shell.c b/zephyr/subsys/bacnet_settings/bacnet_shell.c
@@ -1,13 +1,14 @@
 /**
  * @file
- * @brief The BACnet shell commands for debugging and testing
+ * @brief The BACnet shell commands for debugging and testing settings
  * @author Steve Karg <skarg@users.sourceforge.net>
  * @date May 2024
  * @copyright SPDX-License-Identifier: Apache-2.0
  */
 #include <stdlib.h>
 #include <stdint.h>
 #include <errno.h>
+#include <ctype.h>
 #include <zephyr/shell/shell.h>
 #include <bacnet_settings/bacnet_storage.h>
 #include <bacnet/bactext.h>
@@ -25,13 +26,14 @@ static const char Storage_Base_Name[] = CONFIG_BACNET_STORAGE_BASE_NAME;
  */
 static int cmd_key(BACNET_STORAGE_KEY *key, const struct shell *sh, size_t argc, char **argv)
 {
-	uint16_t object_type;
-	uint32_t object_instance;
-	uint32_t property_id = 77;
+	uint16_t object_type = 0;
+	uint32_t object_instance = 0;
+	uint32_t property_id = 75;
 	uint32_t array_index = BACNET_STORAGE_ARRAY_INDEX_NONE;
 	long value = 0;
 	unsigned long unsigned_value = 0;
-	int found_index = 0;
+	int found_index = 0, scan_count = 0;
+	char property_name[80] = {0};
 
 	if (argc < 3) {
 		shell_error(sh, "Usage: %s <object-type> <instance> <property> [value]", argv[0]);
@@ -57,33 +59,30 @@ static int cmd_key(BACNET_STORAGE_KEY *key, const struct shell *sh, size_t argc,
 		return -EINVAL;
 	}
 	object_instance = (uint32_t)unsigned_value;
-	/* property can have @ to denote priority or array */
-	char *at_ptr = strchr(argv[3], '@');
-	if (at_ptr) {
-		if (!bacnet_storage_strtoul(at_ptr + 1, &unsigned_value)) {
-			shell_error(sh, "Invalid array-index: \"%s\"", at_ptr);
+	/* property can have [] to denote priority or array */
+	scan_count = sscanf(argv[3], "%lu[%u]", &unsigned_value, &array_index);
+	if (scan_count < 1) {
+		scan_count = sscanf(argv[3], "%80s[%u]", property_name, &array_index);
+		if (scan_count < 1) {
+			shell_error(sh, "Invalid property: %s.", argv[3]);
 			return -EINVAL;
 		}
-		if (unsigned_value > UINT32_MAX) {
-			shell_error(sh, "Invalid array-index: \"%s\". Must be 0-4294967295.",
-				    at_ptr);
+		if (bactext_property_strtol(property_name, &found_index)) {
+			value = found_index;
+		} else {
+			shell_error(sh, "Invalid property: %s.", property_name);
 			return -EINVAL;
 		}
-		array_index = (uint32_t)unsigned_value;
-		/* null terminate the string at the @ symbol */
-		*at_ptr = 0;
-	}
-	if (bactext_property_strtol(argv[3], &found_index)) {
-		value = found_index;
-	} else {
-		shell_error(sh, "Invalid property: %s.", argv[1]);
-		return -EINVAL;
+		if (value > UINT32_MAX) {
+			shell_error(sh, "Invalid property: %s. Must be 0-4294967295.", argv[3]);
+			return -EINVAL;
+		}
+		unsigned_value = (uint32_t)value;
 	}
-	if (value > UINT32_MAX) {
-		shell_error(sh, "Invalid property: %s. Must be 0-4294967295.", argv[3]);
-		return -EINVAL;
+	if (scan_count < 2) {
+		array_index = BACNET_STORAGE_ARRAY_INDEX_NONE;
 	}
-	property_id = (uint32_t)value;
+	property_id = (uint32_t)unsigned_value;
 	/* setup the storage key */
 	bacnet_storage_key_init(key, object_type, object_instance, property_id, array_index);
 
@@ -102,39 +101,59 @@ static int cmd_value(const struct shell *sh, size_t argc, char **argv)
 	char key_name[BACNET_STORAGE_KEY_SIZE_MAX + 1] = {0};
 	uint8_t data[BACNET_STORAGE_VALUE_SIZE_MAX + 1] = {0};
 	BACNET_STORAGE_KEY key = {0};
-	int rc;
+	int rc, len, data_len;
 	unsigned enumerated_value = 0;
+	unsigned long unsigned_value = 0;
+	float real_value = 0.0f;
+	long signed_value = 0;
+	int scan_count = 0;
+	unsigned object_type = 0;
+	unsigned instance = 0;
 	bool status = false;
-	bool null_value = false;
 	BACNET_APPLICATION_DATA_VALUE value = {0};
 	BACNET_OBJECT_PROPERTY_VALUE object_value = {0};
 	char value_name[80] = {0};
 	char *value_string = NULL;
-	uint8_t value_tag;
-	int len;
 
 	rc = cmd_key(&key, sh, argc, argv);
 	if (rc < 0) {
 		return rc;
 	}
+	/* read the current value which also determines
+	   the tag when setting the value */
+	rc = bacnet_storage_get(&key, data, sizeof(data));
+	if (rc < 0) {
+		shell_error(sh, "Unable to get %s", key_name);
+		return -EINVAL;
+	}
+	data_len = rc;
 	/* convert the key to a string for the shell to print */
 	(void)bacnet_storage_key_encode(key_name, sizeof(key_name), &key);
-	if (argc > 4) {
+	/* check for an assigned tag */
+	if ((argc > 5) && bacnet_storage_strtoul(argv[4], &unsigned_value)) {
+		value.tag = unsigned_value;
+		value_string = argv[5];
+	} else if (argc > 4) {
 		value_string = argv[4];
-		if (property_list_commandable_member(key.object_type, key.property_id)) {
-			/* check for case insensitive NULL string */
-			if (bacnet_strnicmp(value_string, "NULL", 4) == 0) {
-				null_value = true;
-			}
-		}
+	}
+	if (value_string) {
+		len = bacapp_decode_application_data(data, data_len, &value);
 		/* convert the string value into a tagged union value */
-		if (null_value) {
-			value.tag = BACNET_APPLICATION_TAG_NULL;
-			status = true;
-		} else {
-			value_tag = bacapp_known_property_tag(key.object_type, key.property_id);
-			/* check for known property types */
-			if (value_tag == BACNET_APPLICATION_TAG_ENUMERATED) {
+		if (isalpha(value_string[0])) {
+			if (property_list_commandable_member(key.object_type, key.property_id) &&
+			    (bacnet_strnicmp(value_string, "NULL", 4) == 0)) {
+				/* check for case insensitive NULL string */
+				value.tag = BACNET_APPLICATION_TAG_NULL;
+				status = true;
+			} else if (bacnet_stricmp(value_string, "true") == 0) {
+				value.type.Boolean = true;
+				value.tag = BACNET_APPLICATION_TAG_BOOLEAN;
+				status = true;
+			} else if (bacnet_stricmp(value_string, "false") == 0) {
+				value.type.Boolean = false;
+				value.tag = BACNET_APPLICATION_TAG_BOOLEAN;
+				status = true;
+			} else {
 				status = bactext_object_property_strtoul(
 					(BACNET_OBJECT_TYPE)key.object_type,
 					(BACNET_PROPERTY_ID)key.property_id, value_string,
@@ -143,9 +162,63 @@ static int cmd_value(const struct shell *sh, size_t argc, char **argv)
 					value.tag = BACNET_APPLICATION_TAG_ENUMERATED;
 					value.type.Enumerated = (uint32_t)enumerated_value;
 				}
-			} else {
-				status = bacapp_parse_application_data(value_tag, value_string,
-								       &value);
+			}
+		}
+		if (!status) {
+			switch (value.tag) {
+			case BACNET_APPLICATION_TAG_ENUMERATED:
+				if (bacnet_storage_strtoul(value_string, &unsigned_value)) {
+					value.type.Enumerated = (uint32_t)unsigned_value;
+					status = true;
+				}
+				break;
+			case BACNET_APPLICATION_TAG_UNSIGNED_INT:
+				if (bacnet_storage_strtoul(value_string, &unsigned_value)) {
+					value.type.Unsigned_Int = (uint32_t)unsigned_value;
+					status = true;
+				}
+				break;
+			case BACNET_APPLICATION_TAG_SIGNED_INT:
+				if (bacnet_storage_strtol(value_string, &signed_value)) {
+					value.type.Signed_Int = (int32_t)signed_value;
+					status = true;
+				}
+				break;
+			case BACNET_APPLICATION_TAG_REAL:
+				if (bacnet_storage_strtof(value_string, &real_value)) {
+					value.type.Real = (float)real_value;
+					status = true;
+				}
+				break;
+			case BACNET_APPLICATION_TAG_BIT_STRING:
+				status = bitstring_init_ascii(&value.type.Bit_String, value_string);
+				break;
+			case BACNET_APPLICATION_TAG_OCTET_STRING:
+				status = octetstring_init_ascii_hex(&value.type.Octet_String,
+								    value_string);
+				break;
+			case BACNET_APPLICATION_TAG_CHARACTER_STRING:
+				status = characterstring_init_ansi(&value.type.Character_String,
+								   value_string);
+				break;
+			case BACNET_APPLICATION_TAG_DATE:
+				status = datetime_date_init_ascii(&value.type.Date, value_string);
+				break;
+			case BACNET_APPLICATION_TAG_TIME:
+				status = datetime_time_init_ascii(&value.type.Time, value_string);
+				break;
+			case BACNET_APPLICATION_TAG_OBJECT_ID:
+				scan_count =
+					sscanf(value_string, "%4d:%7u", &object_type, &instance);
+				if (scan_count == 2) {
+					value.type.Object_Id.type = (uint16_t)object_type;
+					value.type.Object_Id.instance = instance;
+				} else {
+					status = false;
+				}
+				break;
+			default:
+				break;
 			}
 		}
 		if (status) {
@@ -171,14 +244,9 @@ static int cmd_value(const struct shell *sh, size_t argc, char **argv)
 			return -EINVAL;
 		}
 	} else {
-		rc = bacnet_storage_get(&key, data, sizeof(data));
-		if (rc < 0) {
-			shell_error(sh, "Unable to get %s", key_name);
-			return -EINVAL;
-		}
 		/* convert to printable value */
-		len = bacapp_decode_known_array_property(data, rc, &value, key.object_type,
-							 key.property_id, key.array_index);
+		len = bacapp_decode_known_property(data, rc, &value, key.object_type,
+						   key.property_id);
 		if (len < 0) {
 			shell_error(sh, "Unable to decode value for %s", key_name);
 			return -EINVAL;
@@ -287,13 +355,21 @@ static int cmd_delete(const struct shell *sh, size_t argc, char **argv)
 static int print_storage_data(BACNET_STORAGE_KEY *key, const void *data, size_t data_len,
 			      void *context)
 {
+	char data_string[80] = {0};
+	char hex_string[3] = {0};
+	unsigned i;
 	const struct shell *sh = context;
+
+	for (i = 0; i < data_len && i < ((sizeof(data_string) / 2) - 1); i++) {
+		snprintf(hex_string, sizeof(hex_string), "%02X", ((const uint8_t *)data)[i]);
+		strcat(data_string, hex_string);
+	}
 	if (key->array_index == BACNET_STORAGE_ARRAY_INDEX_NONE) {
-		shell_print(sh, "%s/%u/%u/%u", Storage_Base_Name, key->object_type,
-			    key->object_instance, key->property_id);
+		shell_print(sh, "%s/%u/%u/%u=%s", Storage_Base_Name, key->object_type,
+			    key->object_instance, key->property_id, data_string);
 	} else {
-		shell_print(sh, "%s/%u/%u/%u/%u", Storage_Base_Name, key->object_type,
-			    key->object_instance, key->property_id, key->array_index);
+		shell_print(sh, "%s/%u/%u/%u/%u=%s", Storage_Base_Name, key->object_type,
+			    key->object_instance, key->property_id, key->array_index, data_string);
 	}
 
 	return 0;
@@ -326,9 +402,14 @@ static int cmd_list(const struct shell *sh, size_t argc, char **argv)
 
 SHELL_STATIC_SUBCMD_SET_CREATE(
 	sub_bacnet_settings_cmds, SHELL_CMD(list, NULL, "list BACnet storage strings", cmd_list),
-	SHELL_CMD(value, NULL, "get or set BACnet storage value", cmd_value),
-	SHELL_CMD(string, NULL, "get or set BACnet storage string", cmd_string),
-	SHELL_CMD(delete, NULL, "delete BACnet storage string", cmd_delete), SHELL_SUBCMD_SET_END);
+	SHELL_CMD(value, NULL, "<object type> <object instance> <property id>[array index] [value]",
+		  cmd_value),
+	SHELL_CMD(string, NULL,
+		  "<object type> <object instance> <property id>[array index] [string]",
+		  cmd_string),
+	SHELL_CMD(delete, NULL, "<object type> <object instance> <property id>[array index]",
+		  cmd_delete),
+	SHELL_SUBCMD_SET_END);
 
 SHELL_SUBCMD_ADD((bacnet), settings, &sub_bacnet_settings_cmds, "BACnet settings commands", NULL, 1,
 		 0);
diff --git a/zephyr/subsys/bacnet_settings/bacnet_storage.c b/zephyr/subsys/bacnet_settings/bacnet_storage.c

Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,14 @@ void BACnet_Lighting_Output_Tracking_Value_Handler(uint32_t object_instance, flo`
`73`	`73`	`static bool Settings_Restore_Callback(BACNET_WRITE_PROPERTY_DATA wp_data, void context)`
`74`	`74`	`{`
`75`	`75`	`(void)context;`
	`76`	`+ if (wp_data == NULL) {`
	`77`	`+ return false;`
	`78`	`+ }`
	`79`	`+ if ((wp_data->object_type == OBJECT_DEVICE) &&`
	`80`	`+ (wp_data->object_instance == BACNET_MAX_INSTANCE)) {`
	`81`	`+ wp_data->object_instance = Device_Object_Instance_Number();`
	`82`	`+ }`
	`83`	`+`
`76`	`84`	`return Device_Write_Property(wp_data);`
`77`	`85`	`}`
`78`	`86`