From 4924a57cccfaaac7ab6fe7e17f3181f329939abd Mon Sep 17 00:00:00 2001 From: Steve Karg Date: Sat, 24 Jan 2026 16:11:25 -0600 Subject: [PATCH] Add enumeration text lookup for BACnet types (#1209) * Added enumeration text lookup for BACnetAuthenticationStatus, BACnetAuthorizationMode, BACnetAccessCredentialDisable, BACnetAccessCredentialDisableReason, BACnetAccessUserType, BACnetAccessZoneOccupancyState, BACnetWriteStatus, BACnetIPMode, BACnetDoorValue, BACnetMaintenance, BACnetEscalatorFault, BACnetEscalatorMode, BACnetEscalatorOperationDirection, BACnetBackupState, BACnetSecurityLevel, BACnetLiftCarDirection, BACnetLiftCarDoorCommand, BACnetLiftCarDriveStatus, BACnetLiftCarMode, BACnetLiftFault, BACnetLiftGroupMode, BACnetAuditLevel, BACnetAuditOperation, BACnetSCHubConnectorState, BACnetSCConnectionState, BACnetNodeRelationship, BACnetAction, BACnetFileAccessMethod, BACnetLockStatus, BACnetDoorAlarmState, BACnetDoorStatus, BACnetDoorSecuredStatus, and BACnetAccessEvent. * Created BINARY_PV_MAX with the same semantic meaning as one more than the last valid enumeration, and deprecated MAX_BINARY_PV usage in the examples. * Reduced code size by using bactext_property_states_strtoul() instead of individual API for each enumations. --- CHANGELOG.md | 15 +- src/bacnet/bacapp.c | 152 +- src/bacnet/bacenum.h | 179 +- src/bacnet/bactext.c | 1767 +++++++++++++---- src/bacnet/bactext.h | 241 ++- src/bacnet/basic/object/bi.c | 6 +- src/bacnet/basic/object/bo.c | 4 +- src/bacnet/basic/object/bv.c | 6 +- src/bacnet/credential_authentication_factor.c | 2 +- test/CMakeLists.txt | 1 + test/bacnet/bactext/CMakeLists.txt | 50 + test/bacnet/bactext/src/main.c | 1347 +++++++++++++ 12 files changed, 3345 insertions(+), 425 deletions(-) create mode 100644 test/bacnet/bactext/CMakeLists.txt create mode 100644 test/bacnet/bactext/src/main.c diff --git a/CHANGELOG.md b/CHANGELOG.md index 9db9d344..41c28c12 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,7 +12,7 @@ The git repositories are hosted at the following sites: * https://bacnet.sourceforge.net/ * https://github.com/bacnet-stack/bacnet-stack/ -## [Unreleased] - 2026-01-15 +## [Unreleased] - 2026-01-22 ### Security @@ -32,6 +32,19 @@ The git repositories are hosted at the following sites: ### Added +* Added enumeration text lookup for BACnetAuthenticationStatus, + BACnetAuthorizationMode, BACnetAccessCredentialDisable, + BACnetAccessCredentialDisableReason, BACnetAccessUserType, + BACnetAccessZoneOccupancyState, BACnetWriteStatus, BACnetIPMode, + BACnetDoorValue, BACnetMaintenance, BACnetEscalatorFault, + BACnetEscalatorMode, BACnetEscalatorOperationDirection, + BACnetBackupState, BACnetSecurityLevel, BACnetLiftCarDirection, + BACnetLiftCarDoorCommand, BACnetLiftCarDriveStatus, BACnetLiftCarMode, + BACnetLiftFault, BACnetLiftGroupMode, BACnetAuditLevel, BACnetAuditOperation, + BACnetSCHubConnectorState, BACnetSCConnectionState, BACnetNodeRelationship, + BACnetAction, BACnetFileAccessMethod, BACnetLockStatus, + BACnetDoorAlarmState, BACnetDoorStatus, BACnetDoorSecuredStatus, + and BACnetAccessEvent. (#1209) * Added a new API for writable property lists across all the basic example object types, preparing for the introduction of a Writable_Property_List property in every object in a future BACnet standard revision. diff --git a/src/bacnet/bacapp.c b/src/bacnet/bacapp.c index 5588b8cb..d73746f1 100644 --- a/src/bacnet/bacapp.c +++ b/src/bacnet/bacapp.c @@ -2233,6 +2233,7 @@ static int bacapp_snprintf_enumerated( break; case PROP_PRESENT_VALUE: case PROP_RELINQUISH_DEFAULT: + case PROP_FEEDBACK_VALUE: switch (object_type) { case OBJECT_BINARY_INPUT: case OBJECT_BINARY_OUTPUT: @@ -2246,6 +2247,10 @@ static int bacapp_snprintf_enumerated( str, str_len, "%s", bactext_binary_lighting_pv_name(value)); break; + case OBJECT_ACCESS_DOOR: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_door_value_name(value)); + break; default: ret_val = bacapp_snprintf( str, str_len, "%lu", (unsigned long)value); @@ -2265,9 +2270,20 @@ static int bacapp_snprintf_enumerated( str, str_len, "%s", bactext_segmentation_name(value)); break; case PROP_NODE_TYPE: + case PROP_SUBORDINATE_NODE_TYPES: ret_val = bacapp_snprintf( str, str_len, "%s", bactext_node_type_name(value)); break; + case PROP_SUBORDINATE_RELATIONSHIPS: + case PROP_DEFAULT_SUBORDINATE_RELATIONSHIP: + if (bactext_node_relationship_name_proprietary((unsigned)value)) { + ret_val = bacapp_snprintf( + str, str_len, "proprietary-%lu", (unsigned long)value); + } else { + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_node_relationship_name(value)); + } + break; case PROP_TRANSITION: ret_val = bacapp_snprintf( str, str_len, "%s", bactext_lighting_transition(value)); @@ -2298,6 +2314,8 @@ static int bacapp_snprintf_enumerated( bactext_life_safety_state_name(value)); break; default: + ret_val = bacapp_snprintf( + str, str_len, "%lu", (unsigned long)value); break; } break; @@ -2341,6 +2359,125 @@ static int bacapp_snprintf_enumerated( ret_val = bacapp_snprintf( str, str_len, "%s", bactext_timer_transition_name(value)); break; + case PROP_ACTION: + ret_val = + bacapp_snprintf(str, str_len, "%s", bactext_action_name(value)); + break; + case PROP_FILE_ACCESS_METHOD: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_file_access_method_name(value)); + break; + case PROP_LOCK_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_lock_status_name(value)); + break; + case PROP_DOOR_ALARM_STATE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_door_alarm_state_name(value)); + break; + case PROP_DOOR_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_door_status_name(value)); + break; + case PROP_SECURED_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_door_secured_status_name(value)); + break; + case PROP_ACCESS_EVENT: + case PROP_LAST_ACCESS_EVENT: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_access_event_name(value)); + break; + case PROP_AUTHENTICATION_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_authentication_status_name(value)); + break; + case PROP_AUTHORIZATION_MODE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_authorization_mode_name(value)); + break; + case PROP_CREDENTIAL_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_binary_present_value_name(value)); + break; + case PROP_CREDENTIAL_DISABLE: + ret_val = bacapp_snprintf( + str, str_len, "%s", + bactext_access_credential_disable_name(value)); + break; + case PROP_REASON_FOR_DISABLE: + ret_val = bacapp_snprintf( + str, str_len, "%s", + bactext_access_credential_disable_reason_name(value)); + break; + case PROP_USER_TYPE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_access_user_type_name(value)); + break; + case PROP_OCCUPANCY_STATE: + ret_val = bacapp_snprintf( + str, str_len, "%s", + bactext_access_zone_occupancy_state_name(value)); + break; + case PROP_SILENCED: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_silenced_state_name(value)); + break; + case PROP_WRITE_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_write_status_name(value)); + break; + case PROP_BACNET_IP_MODE: + case PROP_BACNET_IPV6_MODE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_ip_mode_name(value)); + break; + case PROP_SC_HUB_CONNECTOR_STATE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_sc_hub_connector_state_name(value)); + break; + case PROP_MAINTENANCE_REQUIRED: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_maintenance_name(value)); + break; + case PROP_FAULT_SIGNALS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_escalator_fault_name(value)); + break; + case PROP_OPERATION_DIRECTION: + ret_val = bacapp_snprintf( + str, str_len, "%s", + bactext_escalator_operation_direction_name(value)); + break; + case PROP_BACKUP_AND_RESTORE_STATE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_backup_state_name(value)); + break; + case PROP_BASE_DEVICE_SECURITY_POLICY: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_security_level_name(value)); + break; + case PROP_GROUP_MODE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_lift_group_mode_name(value)); + break; + case PROP_CAR_MODE: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_lift_car_mode_name(value)); + break; + case PROP_CAR_DRIVE_STATUS: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_lift_car_drive_status_name(value)); + break; + case PROP_CAR_DOOR_COMMAND: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_lift_car_door_command_name(value)); + break; + case PROP_CAR_ASSIGNED_DIRECTION: + case PROP_CAR_MOVING_DIRECTION: + ret_val = bacapp_snprintf( + str, str_len, "%s", bactext_lift_car_direction_name(value)); + break; default: ret_val = bacapp_snprintf(str, str_len, "%lu", (unsigned long)value); @@ -2902,9 +3039,8 @@ static int bacapp_snprintf_channel_value( break; case BACNET_APPLICATION_TAG_ENUMERATED: #if defined(CHANNEL_ENUMERATED) - ret_val = bacapp_snprintf_enumerated( - str, str_len, OBJECT_COMMAND, PROP_ACTION, - value->type.Enumerated); + ret_val = bacapp_snprintf( + str, str_len, "%lu", (unsigned long)value->type.Enumerated); #endif break; case BACNET_APPLICATION_TAG_LIGHTING_COMMAND: @@ -3385,9 +3521,8 @@ static int bacapp_snprintf_primitive_data_value( #endif #if defined(BACAPP_ENUMERATED) case BACNET_APPLICATION_TAG_ENUMERATED: - ret_val = bacapp_snprintf_enumerated( - str, str_len, OBJECT_COMMAND, PROP_ACTION, - value->type.Enumerated); + ret_val = bacapp_snprintf( + str, str_len, "%lu", (unsigned long)value->type.Enumerated); break; #endif case BACNET_APPLICATION_TAG_EMPTYLIST: @@ -3527,9 +3662,8 @@ static int bacapp_snprintf_action_property_value( #endif #if defined(BACACTION_ENUMERATED) case BACNET_APPLICATION_TAG_ENUMERATED: - ret_val = bacapp_snprintf_enumerated( - str, str_len, OBJECT_COMMAND, PROP_ACTION, - value->type.Enumerated); + ret_val = bacapp_snprintf( + str, str_len, "%lu", (unsigned long)value->type.Enumerated); break; #endif case BACNET_APPLICATION_TAG_EMPTYLIST: diff --git a/src/bacnet/bacenum.h b/src/bacnet/bacenum.h index bc4c1cb0..dc95f2d1 100644 --- a/src/bacnet/bacenum.h +++ b/src/bacnet/bacenum.h @@ -607,14 +607,16 @@ typedef enum BACnetBinaryPV { MIN_BINARY_PV = 0, /* for validating incoming values */ BINARY_INACTIVE = 0, BINARY_ACTIVE = 1, - MAX_BINARY_PV = 1, /* for validating incoming values */ + MAX_BINARY_PV = 1, /* deprecated */ + BINARY_PV_MAX = 2, /* for validating incoming values */ BINARY_NULL = 255 /* our homemade way of storing this info */ } BACNET_BINARY_PV; typedef enum { - ACTION_BINARY_PV, - ACTION_UNSIGNED, - ACTION_FLOAT + ACTION_BINARY_PV = 0, + ACTION_UNSIGNED = 1, + ACTION_FLOAT = 2, + ACTION_VALUE_MAX = 3 } BACNET_ACTION_VALUE_TYPE; typedef enum BACnetEventState { @@ -1311,13 +1313,14 @@ typedef enum BACnetEventType { EVENT_FLOATING_LIMIT = 4, EVENT_OUT_OF_RANGE = 5, EVENT_COMPLEX_EVENT_TYPE = 6, /* -- see comment below */ - /* event-buffer-ready (7), -- context tag 7 is deprecated */ + EVENT_RESERVED_7 = 7, /* -- context tag 7 is deprecated */ EVENT_CHANGE_OF_LIFE_SAFETY = 8, EVENT_EXTENDED = 9, EVENT_BUFFER_READY = 10, EVENT_UNSIGNED_RANGE = 11, /* -- context tag 12 is reserved for future addenda since it conflicts with event-values[12] OPTIONAL */ + EVENT_RESERVED_12 = 12, EVENT_ACCESS_EVENT = 13, EVENT_DOUBLE_OUT_OF_RANGE = 14, EVENT_SIGNED_OUT_OF_RANGE = 15, @@ -1341,7 +1344,8 @@ typedef enum BACnetEventType { typedef enum BACnetFileAccessMethod { FILE_RECORD_ACCESS = 0, FILE_STREAM_ACCESS = 1, - FILE_RECORD_AND_STREAM_ACCESS = 2 + FILE_RECORD_AND_STREAM_ACCESS = 2, + BACNET_FILE_ACCESS_METHOD_MAX = 3 } BACNET_FILE_ACCESS_METHOD; typedef enum BACnetLifeSafetyMode { @@ -1388,6 +1392,8 @@ typedef enum BACnetLifeSafetyOperation { LIFE_SAFETY_OP_UNSILENCE = 7, LIFE_SAFETY_OP_UNSILENCE_AUDIBLE = 8, LIFE_SAFETY_OP_UNSILENCE_VISUAL = 9, + LIFE_SAFETY_OP_RESERVED_MIN = 10, + LIFE_SAFETY_OP_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. */ /* Enumerated values 64-65535 may be used by others subject to */ /* procedures and constraints described in Clause 23. */ @@ -1451,6 +1457,8 @@ typedef enum BACnetSilencedState { SILENCED_STATE_AUDIBLE_SILENCED = 1, SILENCED_STATE_VISIBLE_SILENCED = 2, SILENCED_STATE_ALL_SILENCED = 3, + SILENCED_STATE_RESERVED_MIN = 4, + SILENCED_STATE_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. */ /* Enumerated values 64-65535 may be used by others subject to */ /* procedures and constraints described in Clause 23. */ @@ -1466,6 +1474,8 @@ typedef enum BACnetMaintenance { MAINTENANCE_PERIODIC_TEST = 1, MAINTENANCE_NEED_SERVICE_OPERATIONAL = 2, MAINTENANCE_NEED_SERVICE_INOPERATIVE = 3, + MAINTENANCE_RESERVED_MIN = 4, + MAINTENANCE_RESERVED_MAX = 255, /* Enumerated values 0-255 are reserved for definition by ASHRAE. */ /* Enumerated values 256-65535 may be used by others subject to */ /* procedures and constraints described in Clause 23. */ @@ -1696,7 +1706,9 @@ typedef enum { /* no-value - context tagged null */ BACNET_APPLICATION_TAG_NO_VALUE, /* ABSTRACT-SYNTAX - constructed value */ - BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX + BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX, + /* == mark the end of this list == */ + BACNET_APPLICATION_TAG_EXTENDED_MAX } BACNET_APPLICATION_TAG; /* note: these are not the real values, */ @@ -1882,7 +1894,8 @@ typedef enum BACnetLogStatus { typedef enum BACnetLoggingType { LOGGING_TYPE_POLLED = 0, LOGGING_TYPE_COV = 1, - LOGGING_TYPE_TRIGGERED = 2 + LOGGING_TYPE_TRIGGERED = 2, + BACNET_LOGGING_TYPE_MAX = 3 } BACNET_LOGGING_TYPE; typedef enum BACnetLogDatum { @@ -2344,7 +2357,8 @@ typedef enum BACnetNodeType { BACNET_NODE_MEMBER = 18, BACNET_NODE_PROTOCOL = 19, BACNET_NODE_ROOM = 20, - BACNET_NODE_ZONE = 21 + BACNET_NODE_ZONE = 21, + BACNET_NODE_TYPE_MAX = 22 } BACNET_NODE_TYPE; typedef enum BACnetRelationship { @@ -2391,13 +2405,15 @@ typedef enum BACnetShedState { BACNET_SHED_INACTIVE = 0, BACNET_SHED_REQUEST_PENDING = 1, BACNET_SHED_COMPLIANT = 2, - BACNET_SHED_NON_COMPLIANT = 3 + BACNET_SHED_NON_COMPLIANT = 3, + BACNET_SHED_STATE_MAX = 4 } BACNET_SHED_STATE; typedef enum BACnetShedLevelType { - BACNET_SHED_TYPE_PERCENT, /* Unsigned */ - BACNET_SHED_TYPE_LEVEL, /* Unsigned */ - BACNET_SHED_TYPE_AMOUNT /* REAL */ + BACNET_SHED_TYPE_PERCENT = 0, /* Unsigned */ + BACNET_SHED_TYPE_LEVEL = 1, /* Unsigned */ + BACNET_SHED_TYPE_AMOUNT = 2, /* REAL */ + BACNET_SHED_LEVEL_TYPE_MAX = 3 } BACNET_SHED_LEVEL_TYPE; typedef enum BACnetLightingOperation { @@ -2530,17 +2546,22 @@ typedef enum BACnetDoorAlarmState { DOOR_ALARM_STATE_DOOR_FAULT = 5, DOOR_ALARM_STATE_LOCK_DOWN = 6, DOOR_ALARM_STATE_FREE_ACCESS = 7, - DOOR_ALARM_STATE_EGRESS_OPEN = 8 + DOOR_ALARM_STATE_EGRESS_OPEN = 8, + DOOR_ALARM_STATE_RESERVED_MIN = 9, + DOOR_ALARM_STATE_RESERVED_MAX = 255, /* Enumerated values 0-255 are reserved for definition by ASHRAE. Enumerated values 256-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ + DOOR_ALARM_STATE_PROPRIETARY_MIN = 256, + DOOR_ALARM_STATE_PROPRIETARY_MAX = 65535 } BACNET_DOOR_ALARM_STATE; /* Door Secured Status */ typedef enum BACnetDoorSecuredStatus { DOOR_SECURED_STATUS_SECURED = 0, DOOR_SECURED_STATUS_UNSECURED = 1, - DOOR_SECURED_STATUS_UNKNOWN = 2 + DOOR_SECURED_STATUS_UNKNOWN = 2, + DOOR_SECURED_STATUS_MAX = 3 } BACNET_DOOR_SECURED_STATUS; /* Door Status */ @@ -2554,10 +2575,14 @@ typedef enum BACnetDoorStatus { DOOR_STATUS_CLOSING = 6, DOOR_STATUS_OPENING = 7, DOOR_STATUS_SAFETY_LOCKED = 8, - DOOR_STATUS_LIMITED_OPENED = 9 + DOOR_STATUS_LIMITED_OPENED = 9, + DOOR_STATUS_RESERVED_MIN = 10, + DOOR_STATUS_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ + DOOR_STATUS_PROPRIETARY_MIN = 1024, + DOOR_STATUS_PROPRIETARY_MAX = 65535 } BACNET_DOOR_STATUS; /* Door Value */ @@ -2565,7 +2590,8 @@ typedef enum BACnetDoorValue { DOOR_VALUE_LOCK = 0, DOOR_VALUE_UNLOCK = 1, DOOR_VALUE_PULSE_UNLOCK = 2, - DOOR_VALUE_EXTENDED_PULSE_UNLOCK = 3 + DOOR_VALUE_EXTENDED_PULSE_UNLOCK = 3, + DOOR_VALUE_MAX = 4 } BACNET_DOOR_VALUE; /* Lock Status */ @@ -2574,7 +2600,8 @@ typedef enum BACnetLockStatus { LOCK_STATUS_UNLOCKED = 1, LOCK_STATUS_LOCK_FAULT = 2, LOCK_STATUS_UNUSED = 3, - LOCK_STATUS_UNKNOWN = 4 + LOCK_STATUS_UNKNOWN = 4, + BACNET_LOCK_STATUS_MAX = 5 } BACNET_LOCK_STATUS; /* Access Event */ @@ -2633,6 +2660,8 @@ typedef enum BACnetAccessEvent { ACCESS_EVENT_DENIED_VERIFICATION_FAILED = 162, ACCESS_EVENT_DENIED_VERIFICATION_TIMEOUT = 163, ACCESS_EVENT_DENIED_OTHER = 164, + ACCESS_EVENT_RESERVED_MIN = 165, + ACCESS_EVENT_RESERVED_MAX = 511, /* Enumerated values 0-511 are reserved for definition by ASHRAE. Enumerated values 512-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -2649,7 +2678,8 @@ typedef enum BACnetAuthenticationStatus { AUTHENTICATION_STATUS_WAITING_FOR_AUTHENTICATION_FACTOR = 3, AUTHENTICATION_STATUS_WAITING_FOR_ACCOMPANIMENT = 4, AUTHENTICATION_STATUS_WAITING_FOR_VERIFICATION = 5, - AUTHENTICATION_STATUS_IN_PROGRESS = 6 + AUTHENTICATION_STATUS_IN_PROGRESS = 6, + AUTHENTICATION_STATUS_MAX = 7 } BACNET_AUTHENTICATION_STATUS; /* Authorization Mode */ @@ -2659,10 +2689,14 @@ typedef enum BACnetAuthorizationMode { AUTHORIZATION_MODE_DENY_ALL = 2, AUTHORIZATION_MODE_VERIFICATION_REQUIRED = 3, AUTHORIZATION_MODE_AUTHORIZATION_DELAYED = 4, - AUTHORIZATION_MODE_NONE = 5 + AUTHORIZATION_MODE_NONE = 5, + AUTHORIZATION_MODE_RESERVED_MIN = 6, + AUTHORIZATION_MODE_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ + AUTHORIZATION_MODE_PROPRIETARY_MIN = 64, + AUTHORIZATION_MODE_PROPRIETARY_MAX = 65535 } BACNET_AUTHORIZATION_MODE; /* Access Passback Mode */ @@ -2681,6 +2715,8 @@ typedef enum BACnetAccessZoneOccupancyState { ACCESS_ZONE_OCCUPANCY_STATE_ABOVE_UPPER_LIMIT = 4, ACCESS_ZONE_OCCUPANCY_STATE_DISABLED = 5, ACCESS_ZONE_OCCUPANCY_STATE_NOT_SUPPORTED = 6, + ACCESS_ZONE_OCCUPANCY_STATE_RESERVED_MIN = 7, + ACCESS_ZONE_OCCUPANCY_STATE_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -2692,11 +2728,14 @@ typedef enum BACnetAccessZoneOccupancyState { typedef enum BACnetAccessUserType { ACCESS_USER_TYPE_ASSET = 0, ACCESS_USER_TYPE_GROUP = 1, - ACCESS_USER_TYPE_PERSON = 2 + ACCESS_USER_TYPE_PERSON = 2, + ACCESS_USER_TYPE_RESERVED_MIN = 3, + ACCESS_USER_TYPE_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-65535 may be used by others subject to - the procedures and constraints described --- in Clause 23. */ + the procedures and constraints described in Clause 23. */ + ACCESS_USER_TYPE_PROPRIETARY_MIN = 64, + ACCESS_USER_TYPE_PROPRIETARY_MAX = 65535 } BACNET_ACCESS_USER_TYPE; /* Access Authentication Factor Disable */ @@ -2707,10 +2746,13 @@ typedef enum BACnetAccessAuthenticationFactorDisable { ACCESS_AUTHENTICATION_FACTOR_DISABLE_DISABLED_STOLEN = 3, ACCESS_AUTHENTICATION_FACTOR_DISABLE_DISABLED_DAMAGED = 4, ACCESS_AUTHENTICATION_FACTOR_DISABLE_DISABLED_DESTROYED = 5, - ACCESS_AUTHENTICATION_FACTOR_DISABLE_MAX = 6 + ACCESS_AUTHENTICATION_FACTOR_DISABLE_RESERVED_MIN = 6, + ACCESS_AUTHENTICATION_FACTOR_DISABLE_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ + ACCESS_AUTHENTICATION_FACTOR_DISABLE_PROPRIETARY_MIN = 64, + ACCESS_AUTHENTICATION_FACTOR_DISABLE_PROPRIETARY_MAX = 65535 } BACNET_ACCESS_AUTHENTICATION_FACTOR_DISABLE; /* Authorization Exemption */ @@ -2721,10 +2763,14 @@ typedef enum BACnetAuthorizationExemption { AUTHORIZATION_EXEMPTION_LOCKOUT = 3, AUTHORIZATION_EXEMPTION_DENY = 4, AUTHORIZATION_EXEMPTION_VERIFICATION = 5, - AUTHORIZATION_EXEMPTION_AUTHORIZATION_DELAY = 6 + AUTHORIZATION_EXEMPTION_AUTHORIZATION_DELAY = 6, + AUTHORIZATION_EXEMPTION_RESERVED_MIN = 7, + AUTHORIZATION_EXEMPTION_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-255 may be used by others subject to the procedures and constraints described in Clause 23. */ + AUTHORIZATION_EXEMPTION_PROPRIETARY_MIN = 64, + AUTHORIZATION_EXEMPTION_PROPRIETARY_MAX = 255 } BACNET_AUTHORIZATION_EXEMPTION; /* The Network Reject Reasons for NETWORK_MESSAGE_REJECT_MESSAGE_TO_NETWORK */ @@ -2744,7 +2790,8 @@ typedef enum BACnetWriteStatus { BACNET_WRITE_STATUS_IDLE = 0, BACNET_WRITE_STATUS_IN_PROGRESS = 1, BACNET_WRITE_STATUS_SUCCESSFUL = 2, - BACNET_WRITE_STATUS_FAILED = 3 + BACNET_WRITE_STATUS_FAILED = 3, + BACNET_WRITE_STATUS_MAX = 4 } BACNET_WRITE_STATUS; typedef enum BACnetNetworkType { @@ -2785,7 +2832,8 @@ typedef enum BACnetNetworkNumberQuality { PORT_QUALITY_UNKNOWN = 0, PORT_QUALITY_LEARNED = 1, PORT_QUALITY_LEARNED_CONFIGURED = 2, - PORT_QUALITY_CONFIGURED = 3 + PORT_QUALITY_CONFIGURED = 3, + PORT_QUALITY_MAX = 4 } BACNET_PORT_QUALITY; typedef enum BACnetNetworkPortCommand { @@ -2810,30 +2858,31 @@ typedef enum BACnetNetworkPortCommand { PORT_COMMAND_MAX = 255 } BACNET_PORT_COMMAND; -typedef enum { +typedef enum BACnetSecurityLevel { BACNET_SECURITY_LEVEL_INCAPABLE = 0, BACNET_SECURITY_LEVEL_PLAIN = 1, BACNET_SECURITY_LEVEL_SIGNED = 2, BACNET_SECURITY_LEVEL_ENCRYPTED = 3, BACNET_SECURITY_LEVEL_SIGNED_END_TO_END = 4, - BACNET_SECURITY_LEVEL_ENCRYPTED_END_TO_END = 5 + BACNET_SECURITY_LEVEL_ENCRYPTED_END_TO_END = 5, + BACNET_SECURITY_LEVEL_MAX = 6 } BACNET_SECURITY_LEVEL; -typedef enum { +typedef enum BACnetSecurityPolicy { BACNET_SECURITY_POLICY_PLAIN_NOT_TRUSTED = 0, BACNET_SECURITY_POLICY_PLAIN_TRUSTED = 1, BACNET_SECURITY_POLICY_SIGNED_TRUSTED = 2, BACNET_SECURITY_POLICY_ENCRYPTED_TRUSTED = 3 } BACNET_SECURITY_POLICY; -typedef enum { +typedef enum BACnetKeyIdentifierAlgorithm { KIA_AES_MD5 = 0, KIA_AES_SHA256 = 1, /* 2-255 reserved */ KIA_MAX_KEY_IDENTIFIER_ALGORITHM = 255 } BACNET_KEY_IDENTIFIER_ALGORITHM; -typedef enum { +typedef enum BACnetKeyIdentifierKeyNumber { KIKN_NOT_USED = 0, KIKN_DEVICE_MASTER = 1, KIKN_DISTRIBUTION = 2, @@ -2846,7 +2895,7 @@ typedef enum { KIKN_MAX_KEY_IDENTIFIER_KEY_NUMBER = 255 } BACNET_KEY_IDENTIFIER_KEY_NUMBER; -typedef enum { +typedef enum BACnetSecurityResponseCode { SEC_RESP_SUCCESS = 0, SEC_RESP_ACCESS_DENIED = 1, SEC_RESP_BAD_DESTINATION_ADDRESS = 2, @@ -2877,13 +2926,16 @@ typedef enum { typedef enum BACnetAccessCredentialDisable { ACCESS_CREDENTIAL_DISABLE_NONE = 0, - ACCESS_CREDENTIAL_DISABLE = 1, + ACCESS_CREDENTIAL_DISABLE_DISABLE = 1, ACCESS_CREDENTIAL_DISABLE_MANUAL = 2, ACCESS_CREDENTIAL_DISABLE_LOCKOUT = 3, - ACCESS_CREDENTIAL_DISABLE_MAX = 4 + ACCESS_CREDENTIAL_DISABLE_RESERVED_MIN = 4, + ACCESS_CREDENTIAL_DISABLE_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ + ACCESS_CREDENTIAL_DISABLE_PROPRIETARY_MIN = 64, + ACCESS_CREDENTIAL_DISABLE_PROPRIETARY_MAX = 65535 } BACNET_ACCESS_CREDENTIAL_DISABLE; typedef enum BACnetAccessCredentialDisableReason { @@ -2897,13 +2949,16 @@ typedef enum BACnetAccessCredentialDisableReason { CREDENTIAL_DISABLED_MAX_USES = 7, CREDENTIAL_DISABLED_INACTIVITY = 8, CREDENTIAL_DISABLED_MANUAL = 9, - CREDENTIAL_DISABLED_MAX = 10 + CREDENTIAL_DISABLED_RESERVED_MIN = 10, + CREDENTIAL_DISABLED_RESERVED_MAX = 63, /* Enumerated values 0-63 are reserved for definition by ASHRAE. Enumerated values 64-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ + CREDENTIAL_DISABLED_PROPRIETARY_MIN = 64, + CREDENTIAL_DISABLED_PROPRIETARY_MAX = 65535 } BACNET_ACCESS_CREDENTIAL_DISABLE_REASON; -typedef enum { +typedef enum BACnetAuthenticationDisableReason { AUTHENTICATION_NONE = 0, AUTHENTICATION_DISABLED = 1, AUTHENTICATION_DISABLED_LOST = 2, @@ -2949,13 +3004,15 @@ typedef enum BACnetProtocolLevel_T { BACNET_PROTOCOL_LEVEL_PHYSICAL = 0, BACNET_PROTOCOL_LEVEL_PROTOCOL = 1, BACNET_PROTOCOL_LEVEL_BACNET_APPLICATION = 2, - BACNET_PROTOCOL_LEVEL_NON_BACNET_APPLICATION = 3 + BACNET_PROTOCOL_LEVEL_NON_BACNET_APPLICATION = 3, + BACNET_PROTOCOL_LEVEL_MAX = 4 } BACNET_PROTOCOL_LEVEL; typedef enum BACnetIPMode_T { BACNET_IP_MODE_NORMAL = 0, BACNET_IP_MODE_FOREIGN = 1, - BACNET_IP_MODE_BBMD = 2 + BACNET_IP_MODE_BBMD = 2, + BACNET_IP_MODE_MAX = 3 } BACNET_IP_MODE; typedef enum BACnetBackupState { @@ -2965,7 +3022,8 @@ typedef enum BACnetBackupState { BACKUP_STATE_PERFORMING_A_BACKUP = 3, BACKUP_STATE_PERFORMING_A_RESTORE = 4, BACKUP_STATE_BACKUP_FAILURE = 5, - BACKUP_STATE_RESTORE_FAILURE = 6 + BACKUP_STATE_RESTORE_FAILURE = 6, + BACKUP_STATE_MAX = 7 } BACNET_BACKUP_STATE; typedef enum BACnetTimerState { @@ -2997,6 +3055,8 @@ typedef enum BACnetEscalatorFault { ESCALATOR_FAULT_CONTROLLER_SUPPLY_FAULT = 6, ESCALATOR_FAULT_DRIVE_TEMPERATURE_EXCEEDED = 7, ESCALATOR_FAULT_COMB_PLATE_FAULT = 8, + ESCALATOR_FAULT_RESERVED_MIN = 9, + ESCALATOR_FAULT_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3011,6 +3071,8 @@ typedef enum BACnetEscalatorMode { ESCALATOR_MODE_DOWN = 3, ESCALATOR_MODE_INSPECTION = 4, ESCALATOR_MODE_OUT_OF_SERVICE = 5, + ESCALATOR_MODE_RESERVED_MIN = 6, + ESCALATOR_MODE_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3025,6 +3087,8 @@ typedef enum BACnetEscalatorOperationDirection { ESCALATOR_OPERATION_DIRECTION_UP_REDUCED_SPEED = 3, ESCALATOR_OPERATION_DIRECTION_DOWN_RATED_SPEED = 4, ESCALATOR_OPERATION_DIRECTION_DOWN_REDUCED_SPEED = 5, + ESCALATOR_OPERATION_DIRECTION_RESERVED_MIN = 6, + ESCALATOR_OPERATION_DIRECTION_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3039,6 +3103,8 @@ typedef enum BACnetLiftCarDirection { LIFT_CAR_DIRECTION_UP = 3, LIFT_CAR_DIRECTION_DOWN = 4, LIFT_CAR_DIRECTION_UP_AND_DOWN = 5, + LIFT_CAR_DIRECTION_RESERVED_MIN = 6, + LIFT_CAR_DIRECTION_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3049,7 +3115,8 @@ typedef enum BACnetLiftCarDirection { typedef enum BACnetLiftCarDoorCommand { LIFT_CAR_DOOR_COMMAND_NONE = 0, LIFT_CAR_DOOR_COMMAND_OPEN = 1, - LIFT_CAR_DOOR_COMMAND_CLOSE = 2 + LIFT_CAR_DOOR_COMMAND_CLOSE = 2, + LIFT_CAR_DOOR_COMMAND_MAX = 3 } BACNET_LIFT_CAR_DOOR_COMMAND; typedef enum BACnetLiftCarDriveStatus { @@ -3063,6 +3130,8 @@ typedef enum BACnetLiftCarDriveStatus { LIFT_CAR_DRIVE_STATUS_TWO_FLOOR_JUMP = 7, LIFT_CAR_DRIVE_STATUS_THREE_FLOOR_JUMP = 8, LIFT_CAR_DRIVE_STATUS_MULTI_FLOOR_JUMP = 9, + LIFT_CAR_DRIVE_STATUS_RESERVED_MIN = 10, + LIFT_CAR_DRIVE_STATUS_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3085,6 +3154,8 @@ typedef enum BACnetLiftCarMode { LIFT_CAR_MODE_FIRE_OPERATION = 11, LIFT_CAR_MODE_OUT_OF_SERVICE = 12, LIFT_CAR_MODE_OCCUPANT_EVACUATION = 13, + LIFT_CAR_MODE_RESERVED_MIN = 14, + LIFT_CAR_MODE_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3110,6 +3181,8 @@ typedef enum BACnetLiftFault { LIFT_FAULT_POSITION_LOST = 14, LIFT_FAULT_DRIVE_TEMPERATURE_EXCEEDED = 15, LIFT_FAULT_LOAD_MEASUREMENT_FAULT = 16, + LIFT_FAULT_RESERVED_MIN = 17, + LIFT_FAULT_RESERVED_MAX = 1023, /* Enumerated values 0-1023 are reserved for definition by ASHRAE. Enumerated values 1024-65535 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3124,7 +3197,8 @@ typedef enum BACnetLiftGroupMode { LIFT_GROUP_MODE_TWO_WAY = 3, LIFT_GROUP_MODE_FOUR_WAY = 4, LIFT_GROUP_MODE_EMERGENCY_POWER = 5, - LIFT_GROUP_MODE_UP_PEAK = 6 + LIFT_GROUP_MODE_UP_PEAK = 6, + LIFT_GROUP_MODE_MAX = 7 } BACNET_LIFT_GROUP_MODE; typedef enum BACnetAuditLevel { @@ -3132,6 +3206,8 @@ typedef enum BACnetAuditLevel { AUDIT_LEVEL_AUDIT_ALL = 1, AUDIT_LEVEL_AUDIT_CONFIG = 2, AUDIT_LEVEL_DEFAULT = 3, + AUDIT_LEVEL_RESERVED_MIN = 4, + AUDIT_LEVEL_RESERVED_MAX = 127, /* Enumerated values 0-127 are reserved for definition by ASHRAE. Enumerated values 128-255 may be used by others subject to the procedures and constraints described in Clause 23. */ @@ -3156,6 +3232,8 @@ typedef enum BACnetAuditOperation { AUDIT_OPERATION_AUDITING_FAILURE = 13, AUDIT_OPERATION_NETWORK_CHANGES = 14, AUDIT_OPERATION_GENERAL = 15, + AUDIT_OPERATION_RESERVED_MIN = 16, + AUDIT_OPERATION_RESERVED_MAX = 31, /* Enumerated values 0-31 are reserved for definition by ASHRAE. Enumerated values 32-63 may be used by others subject to the procedures and constraints described in Clause 23. @@ -3186,7 +3264,8 @@ typedef enum BACnetSCConnectionState { typedef enum BACnetAuthenticationDecision { BACNET_AUTHENTICATION_DECISION_ALLOW_MATCH = 0, BACNET_AUTHENTICATION_DECISION_DENY_MISMATCH = 1, - BACNET_AUTHENTICATION_DECISION_DENY_NON_RELAY = 2 + BACNET_AUTHENTICATION_DECISION_DENY_NON_RELAY = 2, + BACNET_AUTHENTICATION_DECISION_MAX = 3 } BACNET_AUTHENTICATION_DECISION; typedef enum BACnetAuthorizationPosture { @@ -3194,7 +3273,8 @@ typedef enum BACnetAuthorizationPosture { BACNET_AUTHORIZATION_POSTURE_PROPRIETARY = 1, BACNET_AUTHORIZATION_POSTURE_CONFIGURED = 2, BACNET_AUTHORIZATION_POSTURE_MISCONFIGURED_PARTIAL = 3, - BACNET_AUTHORIZATION_POSTURE_MISCONFIGURED_TOTAL = 4 + BACNET_AUTHORIZATION_POSTURE_MISCONFIGURED_TOTAL = 4, + BACNET_AUTHORIZATION_POSTURE_MAX = 5 } BACNET_AUTHORIZATION_POSTURE; typedef enum BACnetFaultType { @@ -3205,7 +3285,8 @@ typedef enum BACnetFaultType { BACNET_FAULT_TYPE_STATE = 4, BACNET_FAULT_TYPE_STATUS_FLAGS = 5, BACNET_FAULT_TYPE_OUT_OF_RANGE = 6, - BACNET_FAULT_TYPE_LISTED = 7 + BACNET_FAULT_TYPE_LISTED = 7, + BACNET_FAULT_TYPE_MAX = 8 } BACNET_FAULT_TYPE; typedef enum BACnetPriorityFilter { @@ -3225,19 +3306,21 @@ typedef enum BACnetPriorityFilter { BACNET_PRIORITY_FILTER_PRIORITY_14 = 13, BACNET_PRIORITY_FILTER_PRIORITY_15 = 14, BACNET_PRIORITY_FILTER_PRIORITY_16 = 15, - BACNET_PRIORITY_FILTER_PRIORITY_MAX = 16 + BACNET_PRIORITY_FILTER_MAX = 16 } BACNET_PRIORITY_FILTER; typedef enum BACnetResultFlags { RESULT_FLAG_FIRST_ITEM = 0, RESULT_FLAG_LAST_ITEM = 1, - RESULT_FLAG_MORE_ITEMS = 2 + RESULT_FLAG_MORE_ITEMS = 2, + BACNET_RESULT_FLAGS_MAX = 3 } BACNET_RESULT_FLAGS; typedef enum BACnetSuccessFilter { BACNET_SUCCESS_FILTER_ALL = 0, BACNET_SUCCESS_FILTER_SUCCESS_ONLY = 1, - BACNET_SUCCESS_FILTER_FAILURES_ONLY = 2 + BACNET_SUCCESS_FILTER_FAILURES_ONLY = 2, + BACNET_SUCCESS_FILTER_MAX = 3 } BACNET_SUCCESS_FILTER; #endif /* end of BACENUM_H */ diff --git a/src/bacnet/bactext.c b/src/bacnet/bactext.c index 8ac36ca2..0986a016 100644 --- a/src/bacnet/bactext.c +++ b/src/bacnet/bactext.c @@ -64,14 +64,15 @@ INDTEXT_DATA bacnet_confirmed_service_names[] = { { SERVICE_CONFIRMED_COV_NOTIFICATION_MULTIPLE, "ConfirmedCOVNotificationMultiple" }, { SERVICE_CONFIRMED_AUDIT_NOTIFICATION, "ConfirmedAuditNotification" }, - { SERVICE_CONFIRMED_AUTH_REQUEST, "ConfirmedAuthRequest" }, + { SERVICE_CONFIRMED_AUDIT_LOG_QUERY, "AuditLogQuery" }, + { SERVICE_CONFIRMED_AUTH_REQUEST, "AuthRequest" }, { 0, NULL } }; const char *bactext_confirmed_service_name(uint32_t index) { - return indtext_by_index_default( - bacnet_confirmed_service_names, index, ASHRAE_Reserved_String); + return bactext_confirmed_service_name_default( + index, ASHRAE_Reserved_String); } const char *bactext_confirmed_service_name_default( @@ -81,6 +82,13 @@ const char *bactext_confirmed_service_name_default( bacnet_confirmed_service_names, index, default_string); } +bool bactext_confirmed_service_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_confirmed_service_names, search_name, found_index); +} + INDTEXT_DATA bacnet_unconfirmed_service_names[] = { { SERVICE_UNCONFIRMED_I_AM, "I-Am" }, { SERVICE_UNCONFIRMED_I_HAVE, "I-Have" }, @@ -103,8 +111,8 @@ INDTEXT_DATA bacnet_unconfirmed_service_names[] = { const char *bactext_unconfirmed_service_name(uint32_t index) { - return indtext_by_index_default( - bacnet_unconfirmed_service_names, index, ASHRAE_Reserved_String); + return bactext_unconfirmed_service_name_default( + index, ASHRAE_Reserved_String); } const char *bactext_unconfirmed_service_name_default( @@ -114,6 +122,13 @@ const char *bactext_unconfirmed_service_name_default( bacnet_unconfirmed_service_names, index, default_string); } +bool bactext_unconfirmed_service_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_unconfirmed_service_names, search_name, found_index); +} + INDTEXT_DATA bacnet_application_tag_names[] = { { BACNET_APPLICATION_TAG_NULL, "Null" }, { BACNET_APPLICATION_TAG_BOOLEAN, "Boolean" }, @@ -181,9 +196,15 @@ INDTEXT_DATA bacnet_application_tag_names[] = { }; const char *bactext_application_tag_name(uint32_t index) +{ + return bactext_application_tag_name_default(index, ASHRAE_Reserved_String); +} + +const char * +bactext_application_tag_name_default(uint32_t index, const char *default_string) { return indtext_by_index_default( - bacnet_application_tag_names, index, ASHRAE_Reserved_String); + bacnet_application_tag_names, index, default_string); } bool bactext_application_tag_index( @@ -193,6 +214,29 @@ bool bactext_application_tag_index( bacnet_application_tag_names, search_name, found_index); } +INDTEXT_DATA bacnet_character_string_encoding_names[] = { + { CHARACTER_ANSI_X34, "ANSI X3.4" }, + { CHARACTER_MS_DBCS, "IBM/Microsoft DBCS" }, + { CHARACTER_JISC_6226, "JIS C 6226" }, + { CHARACTER_UCS4, "ISO 10646 (UCS-4)" }, + { CHARACTER_UCS2, "ISO 10646 (UCS-2)" }, + { CHARACTER_ISO8859, "ISO 8859" }, + { 0, NULL } +}; + +const char *bactext_character_string_encoding_name(uint32_t index) +{ + return indtext_by_index_default( + bacnet_character_string_encoding_names, index, ASHRAE_Reserved_String); +} + +bool bactext_character_string_encoding_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_character_string_encoding_names, search_name, found_index); +} + INDTEXT_DATA bacnet_object_type_names[] = { { OBJECT_ANALOG_INPUT, "analog-input" }, { OBJECT_ANALOG_OUTPUT, "analog-output" }, @@ -265,6 +309,32 @@ INDTEXT_DATA bacnet_object_type_names[] = { { 0, NULL } }; +const char *bactext_object_type_name(uint32_t index) +{ + return indtext_by_index_split_default( + bacnet_object_type_names, index, OBJECT_PROPRIETARY_MIN, + ASHRAE_Reserved_String, Vendor_Proprietary_String); +} + +const char * +bactext_object_type_name_default(uint32_t index, const char *default_string) +{ + return indtext_by_index_default( + bacnet_object_type_names, index, default_string); +} + +bool bactext_object_type_index(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_object_type_names, search_name, found_index); +} + +bool bactext_object_type_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_object_type_names, search_name, found_index); +} + INDTEXT_DATA bacnet_object_type_names_capitalized[] = { { OBJECT_ANALOG_INPUT, "Analog Input" }, { OBJECT_ANALOG_OUTPUT, "Analog Output" }, @@ -337,20 +407,6 @@ INDTEXT_DATA bacnet_object_type_names_capitalized[] = { { 0, NULL } }; -const char *bactext_object_type_name(uint32_t index) -{ - return indtext_by_index_split_default( - bacnet_object_type_names, index, OBJECT_PROPRIETARY_MIN, - ASHRAE_Reserved_String, Vendor_Proprietary_String); -} - -const char * -bactext_object_type_name_default(uint32_t index, const char *default_string) -{ - return indtext_by_index_default( - bacnet_object_type_names, index, default_string); -} - const char *bactext_object_type_name_capitalized(uint32_t index) { return indtext_by_index_split_default( @@ -365,16 +421,11 @@ const char *bactext_object_type_name_capitalized_default( bacnet_object_type_names_capitalized, index, default_string); } -bool bactext_object_type_index(const char *search_name, uint32_t *found_index) -{ - return indtext_by_istring( - bacnet_object_type_names, search_name, found_index); -} - -bool bactext_object_type_strtol(const char *search_name, uint32_t *found_index) +bool bactext_object_type_name_capitalized_strtol( + const char *search_name, uint32_t *found_index) { return bactext_string_to_uint32_index( - bacnet_object_type_names, search_name, found_index); + bacnet_object_type_names_capitalized, search_name, found_index); } INDTEXT_DATA bacnet_property_names[] = { @@ -678,12 +729,13 @@ INDTEXT_DATA bacnet_property_names[] = { { PROP_TRANSACTION_NOTIFICATION_CLASS, "transaction-notification-class" }, { PROP_USER_EXTERNAL_IDENTIFIER, "user-external-identifier" }, { PROP_USER_INFORMATION_REFERENCE, "user-information-reference" }, - { PROP_USER_INFORMATION_REFERENCE, "user-information-reference" }, { PROP_USER_NAME, "user-name" }, { PROP_USER_TYPE, "user-type" }, { PROP_USES_REMAINING, "uses-remaining" }, { PROP_ZONE_FROM, "zone-from" }, { PROP_ZONE_TO, "zone-to" }, + { PROP_ACCESS_EVENT_TAG, "access-event-tag" }, + { PROP_GLOBAL_IDENTIFIER, "global-identifier" }, { PROP_VERIFICATION_TIME, "verification-time" }, { PROP_BASE_DEVICE_SECURITY_POLICY, "base-device-security-policy" }, { PROP_DISTRIBUTION_KEY_REVISION, "distribution-key-revision" }, @@ -747,12 +799,12 @@ INDTEXT_DATA bacnet_property_names[] = { { PROP_POWER, "power" }, { PROP_TRANSITION, "transition" }, { PROP_EGRESS_ACTIVE, "egress-active" }, - { PROP_INTERFACE_VALUE, "inteface-value" }, + { PROP_INTERFACE_VALUE, "interface-value" }, { PROP_FAULT_HIGH_LIMIT, "fault-high-limit" }, { PROP_FAULT_LOW_LIMIT, "fault-low-limit" }, { PROP_LOW_DIFF_LIMIT, "low-diff-limit" }, { PROP_STRIKE_COUNT, "strike-count" }, - { PROP_TIME_OF_STRIKE_COUNT_RESET, "strike-count" }, + { PROP_TIME_OF_STRIKE_COUNT_RESET, "time-of-strike-count-reset" }, { PROP_DEFAULT_TIMEOUT, "default-timeout" }, { PROP_INITIAL_TIMEOUT, "initial-timeout" }, { PROP_LAST_STATE_CHANGE, "last-state-change" }, @@ -1499,6 +1551,13 @@ bactext_reject_reason_name_default(uint32_t index, const char *default_string) bacnet_reject_reason_names, index, default_string); } +bool bactext_reject_reason_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_reject_reason_names, search_name, found_index); +} + INDTEXT_DATA bacnet_abort_reason_names[] = { { ABORT_REASON_OTHER, "Other" }, { ABORT_REASON_BUFFER_OVERFLOW, "Buffer Overflow" }, @@ -1532,6 +1591,12 @@ bactext_abort_reason_name_default(uint32_t index, const char *default_string) bacnet_abort_reason_names, index, default_string); } +bool bactext_abort_reason_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_abort_reason_names, search_name, found_index); +} + INDTEXT_DATA bacnet_error_class_names[] = { { ERROR_CLASS_DEVICE, "device" }, { ERROR_CLASS_OBJECT, "object" }, @@ -1558,6 +1623,12 @@ bactext_error_class_name_default(uint32_t index, const char *default_string) bacnet_error_class_names, index, default_string); } +bool bactext_error_class_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_error_class_names, search_name, found_index); +} + INDTEXT_DATA bacnet_error_code_names[] = { { ERROR_CODE_OTHER, "other" }, { ERROR_CODE_AUTHENTICATION_FAILED, "authentication-failed" }, @@ -1658,7 +1729,6 @@ INDTEXT_DATA bacnet_error_code_names[] = { { ERROR_CODE_LIST_ELEMENT_NOT_FOUND, "list-element-not-found" }, { ERROR_CODE_BUSY, "busy" }, { ERROR_CODE_COMMUNICATION_DISABLED, "communication-disabled" }, - { ERROR_CODE_COMMUNICATION_DISABLED, "access-denied" }, { ERROR_CODE_SUCCESS, "success" }, { ERROR_CODE_ACCESS_DENIED, "access-denied" }, { ERROR_CODE_BAD_DESTINATION_ADDRESS, "bad-destination-address" }, @@ -1842,6 +1912,12 @@ bactext_error_code_name_default(uint32_t index, const char *default_string) bacnet_error_code_names, index, default_string); } +bool bactext_error_code_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_error_code_names, search_name, found_index); +} + INDTEXT_DATA bacnet_month_names[] = { { 1, "January" }, { 2, "February" }, { 3, "March" }, { 4, "April" }, { 5, "May" }, { 6, "June" }, @@ -1863,6 +1939,12 @@ bactext_month_name_default(uint32_t index, const char *default_string) return indtext_by_index_default(bacnet_month_names, index, default_string); } +bool bactext_month_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_month_names, search_name, found_index); +} + INDTEXT_DATA bacnet_week_of_month_names[] = { { 1, "days numbered 1-7" }, { 2, "days numbered 8-14" }, { 3, "days numbered 15-21" }, { 4, "days numbered 22-28" }, @@ -1872,8 +1954,7 @@ INDTEXT_DATA bacnet_week_of_month_names[] = { const char *bactext_week_of_month_name(uint32_t index) { - return indtext_by_index_default( - bacnet_week_of_month_names, index, ASHRAE_Reserved_String); + return bactext_week_of_month_name_default(index, ASHRAE_Reserved_String); } const char * @@ -1883,6 +1964,13 @@ bactext_week_of_month_name_default(uint32_t index, const char *default_string) bacnet_week_of_month_names, index, default_string); } +bool bactext_week_of_month_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_week_of_month_names, search_name, found_index); +} + /* note: different than DaysOfWeek bit string where 0=monday */ INDTEXT_DATA bacnet_day_of_week_names[] = { { 1, "Monday" }, { 2, "Tuesday" }, @@ -1894,8 +1982,7 @@ INDTEXT_DATA bacnet_day_of_week_names[] = { const char *bactext_day_of_week_name(uint32_t index) { - return indtext_by_index_default( - bacnet_day_of_week_names, index, ASHRAE_Reserved_String); + return bactext_day_of_week_name_default(index, ASHRAE_Reserved_String); } const char * @@ -1905,6 +1992,12 @@ bactext_day_of_week_name_default(uint32_t index, const char *default_string) bacnet_day_of_week_names, index, default_string); } +bool bactext_day_of_week_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_day_of_week_names, search_name, found_index); +} + /* note: different than DayOfWeek bit string where 1=monday */ INDTEXT_DATA bacnet_days_of_week_names[] = { { BACNET_DAYS_OF_WEEK_MONDAY, "Monday" }, @@ -1919,13 +2012,19 @@ INDTEXT_DATA bacnet_days_of_week_names[] = { const char *bactext_days_of_week_name(uint32_t index) { - return indtext_by_index_default( - bacnet_days_of_week_names, index, ASHRAE_Reserved_String); + return bactext_days_of_week_name_default(index, ASHRAE_Reserved_String); } -bool bactext_days_of_week_index(const char *search_name, uint32_t *found_index) +const char * +bactext_days_of_week_name_default(uint32_t index, const char *default_string) { - return indtext_by_istring( + return indtext_by_index_default( + bacnet_days_of_week_names, index, default_string); +} + +bool bactext_days_of_week_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( bacnet_days_of_week_names, search_name, found_index); } @@ -1938,9 +2037,15 @@ INDTEXT_DATA bacnet_notify_type_names[] = { }; const char *bactext_notify_type_name(uint32_t index) +{ + return bactext_notify_type_name_default(index, ASHRAE_Reserved_String); +} + +const char * +bactext_notify_type_name_default(uint32_t index, const char *default_string) { return indtext_by_index_default( - bacnet_notify_type_names, index, ASHRAE_Reserved_String); + bacnet_notify_type_names, index, default_string); } bool bactext_notify_type_index(const char *search_name, uint32_t *found_index) @@ -1964,14 +2069,20 @@ INDTEXT_DATA bacnet_event_transition_names[] = { const char *bactext_event_transition_name(uint32_t index) { - return indtext_by_index_default( - bacnet_event_transition_names, index, ASHRAE_Reserved_String); + return bactext_event_transition_name_default(index, ASHRAE_Reserved_String); } -bool bactext_event_transition_index( +const char *bactext_event_transition_name_default( + uint32_t index, const char *default_string) +{ + return indtext_by_index_default( + bacnet_event_transition_names, index, default_string); +} + +bool bactext_event_transition_strtol( const char *search_name, uint32_t *found_index) { - return indtext_by_istring( + return bactext_string_to_uint32_index( bacnet_event_transition_names, search_name, found_index); } @@ -2010,14 +2121,17 @@ INDTEXT_DATA bacnet_event_type_names[] = { { EVENT_COMMAND_FAILURE, "command-failure" }, { EVENT_FLOATING_LIMIT, "floating-limit" }, { EVENT_OUT_OF_RANGE, "out-of-range" }, + { EVENT_COMPLEX_EVENT_TYPE, "complex-event-type" }, + { EVENT_RESERVED_7, "reserved-7" }, { EVENT_CHANGE_OF_LIFE_SAFETY, "change-of-life-safety" }, { EVENT_EXTENDED, "extended" }, { EVENT_BUFFER_READY, "buffer-ready" }, - { EVENT_UNSIGNED_RANGE, "uint32_t-range" }, + { EVENT_UNSIGNED_RANGE, "unsigned-range" }, + { EVENT_RESERVED_12, "reserved-12" }, { EVENT_ACCESS_EVENT, "access-event" }, { EVENT_DOUBLE_OUT_OF_RANGE, "double-out-of-range" }, { EVENT_SIGNED_OUT_OF_RANGE, "signed-out-of-range" }, - { EVENT_UNSIGNED_OUT_OF_RANGE, "uint32_t-out-of-range" }, + { EVENT_UNSIGNED_OUT_OF_RANGE, "unsigned-out-of-range" }, { EVENT_CHANGE_OF_CHARACTERSTRING, "change-of-characterstring" }, { EVENT_CHANGE_OF_STATUS_FLAGS, "change-of-status-flags" }, { EVENT_CHANGE_OF_RELIABILITY, "change-of-reliability" }, @@ -2047,7 +2161,10 @@ bool bactext_event_type_strtol(const char *search_name, uint32_t *found_index) } INDTEXT_DATA bacnet_binary_present_value_names[] = { - { BINARY_INACTIVE, "inactive" }, { BINARY_ACTIVE, "active" }, { 0, NULL } + /* list of each index and associated unique name */ + { BINARY_INACTIVE, "inactive" }, + { BINARY_ACTIVE, "active" }, + { 0, NULL } }; const char *bactext_binary_present_value_name(uint32_t index) @@ -2063,9 +2180,12 @@ bool bactext_binary_present_value_index( bacnet_binary_present_value_names, search_name, found_index); } -INDTEXT_DATA bacnet_binary_polarity_names[] = { { POLARITY_NORMAL, "normal" }, - { POLARITY_REVERSE, "reverse" }, - { 0, NULL } }; +INDTEXT_DATA bacnet_binary_polarity_names[] = { + /* list of each index and associated unique name */ + { POLARITY_NORMAL, "normal" }, + { POLARITY_REVERSE, "reverse" }, + { 0, NULL } +}; const char *bactext_binary_polarity_name(uint32_t index) { @@ -2085,6 +2205,7 @@ INDTEXT_DATA bacnet_reliability_names[] = { { RELIABILITY_PROCESS_ERROR, "process-error" }, { RELIABILITY_MULTI_STATE_FAULT, "mult-state-fault" }, { RELIABILITY_CONFIGURATION_ERROR, "configuration-error" }, + { RELIABILITY_RESERVED_11, "reserved-11" }, { RELIABILITY_COMMUNICATION_FAILURE, "communication-failure" }, { RELIABILITY_MEMBER_FAULT, "member-fault" }, { RELIABILITY_MONITORED_OBJECT_FAULT, "monitored-object-fault" }, @@ -2178,6 +2299,77 @@ const char *bactext_node_type_name(uint32_t index) bacnet_node_type_names, index, ASHRAE_Reserved_String); } +INDTEXT_DATA bacnet_node_relationship_names[] = { + { BACNET_RELATIONSHIP_UNKNOWN, "unknown" }, + { BACNET_RELATIONSHIP_DEFAULT, "default" }, + { BACNET_RELATIONSHIP_CONTAINS, "contains" }, + { BACNET_RELATIONSHIP_CONTAINED_BY, "contained-by" }, + { BACNET_RELATIONSHIP_USES, "uses" }, + { BACNET_RELATIONSHIP_USED_BY, "used-by" }, + { BACNET_RELATIONSHIP_COMMANDS, "commands" }, + { BACNET_RELATIONSHIP_COMMANDED_BY, "commanded-by" }, + { BACNET_RELATIONSHIP_ADJUSTS, "adjusts" }, + { BACNET_RELATIONSHIP_ADJUSTED_BY, "adjusted-by" }, + { BACNET_RELATIONSHIP_INGRESS, "ingress" }, + { BACNET_RELATIONSHIP_EGRESS, "egress" }, + { BACNET_RELATIONSHIP_SUPPLIES_AIR, "supplies-air" }, + { BACNET_RELATIONSHIP_RECEIVES_AIR, "receives-air" }, + { BACNET_RELATIONSHIP_SUPPLIES_HOT_AIR, "supplies-hot-air" }, + { BACNET_RELATIONSHIP_RECEIVES_HOT_AIR, "receives-hot-air" }, + { BACNET_RELATIONSHIP_SUPPLIES_COOL_AIR, "supplies-cool-air" }, + { BACNET_RELATIONSHIP_RECEIVES_COOL_AIR, "receives-cool-air" }, + { BACNET_RELATIONSHIP_SUPPLIES_POWER, "supplies-power" }, + { BACNET_RELATIONSHIP_RECEIVES_POWER, "receives-power" }, + { BACNET_RELATIONSHIP_SUPPLIES_GAS, "supplies-gas" }, + { BACNET_RELATIONSHIP_RECEIVES_GAS, "receives-gas" }, + { BACNET_RELATIONSHIP_SUPPLIES_WATER, "supplies-water" }, + { BACNET_RELATIONSHIP_RECEIVES_WATER, "receives-water" }, + { BACNET_RELATIONSHIP_SUPPLIES_HOT_WATER, "supplies-hot-water" }, + { BACNET_RELATIONSHIP_RECEIVES_HOT_WATER, "receives-hot-water" }, + { BACNET_RELATIONSHIP_SUPPLIES_COOL_WATER, "supplies-cool-water" }, + { BACNET_RELATIONSHIP_RECEIVES_COOL_WATER, "receives-cool-water" }, + { BACNET_RELATIONSHIP_SUPPLIES_STEAM, "supplies-steam" }, + { BACNET_RELATIONSHIP_RECEIVES_STEAM, "receives-steam" }, + { 0, NULL } +}; + +const char *bactext_node_relationship_name(uint32_t index) +{ + return indtext_by_index_default( + bacnet_node_relationship_names, index, ASHRAE_Reserved_String); +} + +bool bactext_node_relationship_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_node_relationship_names, search_name, found_index); +} + +bool bactext_node_relationship_name_proprietary(uint32_t index) +{ + bool status = false; + + if ((index >= BACNET_RELATIONSHIP_PROPRIETARY_MIN) && + (index <= BACNET_RELATIONSHIP_PROPRIETARY_MAX)) { + status = true; + } + + return status; +} + +bool bactext_node_relationship_name_reserved(uint32_t index) +{ + bool status = false; + + if ((index >= BACNET_RELATIONSHIP_RESERVED_MIN) && + (index <= BACNET_RELATIONSHIP_RESERVED_MAX)) { + status = true; + } + + return status; +} + INDTEXT_DATA network_layer_msg_names[] = { { NETWORK_MESSAGE_WHO_IS_ROUTER_TO_NETWORK, "Who-Is-Router-To-Network" }, { NETWORK_MESSAGE_I_AM_ROUTER_TO_NETWORK, "I-Am-Router-To-Network" }, @@ -2189,15 +2381,24 @@ INDTEXT_DATA network_layer_msg_names[] = { "Router-Available-To-Network" }, { NETWORK_MESSAGE_INIT_RT_TABLE, "Initialize-Routing-Table" }, { NETWORK_MESSAGE_INIT_RT_TABLE_ACK, "Initialize-Routing-Table-Ack" }, - { NETWORK_MESSAGE_ESTABLISH_CONNECTION_TO_NETWORK, - "Est-Conn-Ntwk" }, /* Terse since unused */ + { NETWORK_MESSAGE_ESTABLISH_CONNECTION_TO_NETWORK, "Est-Conn-Ntwk" }, { NETWORK_MESSAGE_DISCONNECT_CONNECTION_TO_NETWORK, "Dsc-Conn-Ntwk" }, + { NETWORK_MESSAGE_CHALLENGE_REQUEST, "Challenge-Request" }, + { NETWORK_MESSAGE_SECURITY_PAYLOAD, "Security-Payload" }, + { NETWORK_MESSAGE_SECURITY_RESPONSE, "Security-Response" }, + { NETWORK_MESSAGE_REQUEST_KEY_UPDATE, "Request-Key-Update" }, + { NETWORK_MESSAGE_UPDATE_KEY_SET, "Update-Key-Set" }, + { NETWORK_MESSAGE_UPDATE_DISTRIBUTION_KEY, "Update-Distribution-Key" }, + { NETWORK_MESSAGE_REQUEST_MASTER_KEY, "Request-Master-Key" }, + { NETWORK_MESSAGE_SET_MASTER_KEY, "Set-Master-Key" }, + { NETWORK_MESSAGE_WHAT_IS_NETWORK_NUMBER, "What-Is-Network-Number" }, + { NETWORK_MESSAGE_NETWORK_NUMBER_IS, "Network-Number-Is" }, { 0, NULL } }; const char *bactext_network_layer_msg_name(uint32_t index) { - if (index <= 0x7F) { + if (index <= NETWORK_MESSAGE_ASHRAE_RESERVED_MAX) { return indtext_by_index_default( network_layer_msg_names, index, ASHRAE_Reserved_String); } else if (index < NETWORK_MESSAGE_INVALID) { @@ -2207,6 +2408,13 @@ const char *bactext_network_layer_msg_name(uint32_t index) } } +bool bactext_network_layer_msg_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + network_layer_msg_names, search_name, found_index); +} + INDTEXT_DATA bactext_life_safety_mode_names[] = { { LIFE_SAFETY_MODE_OFF, "off" }, { LIFE_SAFETY_MODE_ON, "on" }, @@ -2284,7 +2492,7 @@ INDTEXT_DATA bactext_life_safety_state_names[] = { { LIFE_SAFETY_STATE_TEST_ALARM, "test-alarm" }, { LIFE_SAFETY_STATE_TEST_ACTIVE, "test-active" }, { LIFE_SAFETY_STATE_TEST_FAULT, "test-fault" }, - { LIFE_SAFETY_STATE_TEST_FAULT_ALARM, "fault-alarm" }, + { LIFE_SAFETY_STATE_TEST_FAULT_ALARM, "test-fault-alarm" }, { LIFE_SAFETY_STATE_HOLDUP, "holdupt" }, { LIFE_SAFETY_STATE_DURESS, "duress" }, { LIFE_SAFETY_STATE_TAMPER_ALARM, "tamper-alarm" }, @@ -2466,6 +2674,13 @@ const char *bactext_color_operation_name(uint32_t index) bacnet_color_operation_names, index, ASHRAE_Reserved_String); } +bool bactext_color_operation_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_color_operation_names, search_name, found_index); +} + INDTEXT_DATA bacnet_device_communications_names[] = { { COMMUNICATION_ENABLE, "enabled" }, { COMMUNICATION_DISABLE, "disabled" }, @@ -2479,6 +2694,13 @@ const char *bactext_device_communications_name(uint32_t index) bacnet_device_communications_names, index, ASHRAE_Reserved_String); } +bool bactext_device_communications_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_device_communications_names, search_name, found_index); +} + INDTEXT_DATA bacnet_shed_state_names[] = { { BACNET_SHED_INACTIVE, "shed-inactive" }, { BACNET_SHED_REQUEST_PENDING, "shed-request-pending" }, @@ -2506,6 +2728,13 @@ const char *bactext_shed_level_type_name(uint32_t index) bacnet_shed_level_type_names, index, ASHRAE_Reserved_String); } +bool bactext_shed_level_type_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_shed_level_type_names, search_name, found_index); +} + INDTEXT_DATA bacnet_log_datum_names[] = { { BACNET_LOG_DATUM_STATUS, "status" }, { BACNET_LOG_DATUM_BOOLEAN, "boolean" }, @@ -2527,6 +2756,12 @@ const char *bactext_log_datum_name(uint32_t index) bacnet_log_datum_names, index, ASHRAE_Reserved_String); } +bool bactext_log_datum_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_log_datum_names, search_name, found_index); +} + INDTEXT_DATA bactext_restart_reason_names[] = { { RESTART_REASON_UNKNOWN, "unknown" }, { RESTART_REASON_COLDSTART, "coldstart" }, @@ -2649,6 +2884,13 @@ const char *bactext_authentication_decision_name(uint32_t index) bactext_authentication_decision_names, index, ASHRAE_Reserved_String); } +bool bactext_authentication_decision_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_authentication_decision_names, search_name, found_index); +} + INDTEXT_DATA bactext_authorization_posture_names[] = { { BACNET_AUTHORIZATION_POSTURE_OPEN, "open" }, { BACNET_AUTHORIZATION_POSTURE_PROPRIETARY, "proprietary" }, @@ -2665,6 +2907,13 @@ const char *bactext_authorization_posture_name(uint32_t index) bactext_authorization_posture_names, index, ASHRAE_Reserved_String); } +bool bactext_authorization_posture_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_authorization_posture_names, search_name, found_index); +} + INDTEXT_DATA bactext_fault_type_names[] = { { BACNET_FAULT_TYPE_NONE, "none" }, { BACNET_FAULT_TYPE_CHARACTERSTRING, "characterstring" }, @@ -2683,6 +2932,12 @@ const char *bactext_fault_type_name(uint32_t index) bactext_fault_type_names, index, ASHRAE_Reserved_String); } +bool bactext_fault_type_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_fault_type_names, search_name, found_index); +} + INDTEXT_DATA bacnet_priority_filter_names[] = { { BACNET_PRIORITY_FILTER_MANUAL_LIFE_SAFETY, "manual-life-safety" }, { BACNET_PRIORITY_FILTER_AUTOMATIC_LIFE_SAFETY, "automatic-life-safety" }, @@ -2704,12 +2959,19 @@ INDTEXT_DATA bacnet_priority_filter_names[] = { { 0, NULL } }; -const char *bacnet_priority_filter_name(uint32_t index) +const char *bactext_priority_filter_name(uint32_t index) { return indtext_by_index_default( bacnet_priority_filter_names, index, ASHRAE_Reserved_String); } +bool bactext_priority_filter_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bacnet_priority_filter_names, search_name, found_index); +} + INDTEXT_DATA bactext_result_flags_names[] = { { RESULT_FLAG_FIRST_ITEM, "first-item" }, { RESULT_FLAG_LAST_ITEM, "last-item" }, @@ -2723,6 +2985,12 @@ const char *bactext_result_flags_name(uint32_t index) bactext_result_flags_names, index, ASHRAE_Reserved_String); } +bool bactext_result_flags_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_result_flags_names, search_name, found_index); +} + INDTEXT_DATA bactext_success_filter_names[] = { { BACNET_SUCCESS_FILTER_ALL, "all" }, { BACNET_SUCCESS_FILTER_SUCCESS_ONLY, "success-only" }, @@ -2736,6 +3004,13 @@ const char *bactext_success_filter_name(uint32_t index) bactext_success_filter_names, index, ASHRAE_Reserved_String); } +bool bactext_success_filter_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_success_filter_names, search_name, found_index); +} + INDTEXT_DATA bactext_logging_type_names[] = { /* BACnetLoggingType enumerations */ { LOGGING_TYPE_POLLED, "polled" }, @@ -2750,6 +3025,12 @@ const char *bactext_logging_type_name(uint32_t index) bactext_logging_type_names, index, ASHRAE_Reserved_String); } +bool bactext_logging_type_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_logging_type_names, search_name, found_index); +} + INDTEXT_DATA bactext_program_request_names[] = { { PROGRAM_REQUEST_READY, "ready" }, { PROGRAM_REQUEST_LOAD, "load" }, @@ -2848,169 +3129,1027 @@ const char *bactext_boolean_value_name(uint32_t index) bactext_boolean_value_names, index, ASHRAE_Reserved_String); } +INDTEXT_DATA bactext_action_names[] = { + /* BACnetAction enumerations */ + { ACTION_DIRECT, "direct" }, + { ACTION_REVERSE, "reverse" }, + { 0, NULL } +}; + +const char *bactext_action_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_action_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_file_access_method_names[] = { + /* BACnetFileAccessMethod enumerations */ + { FILE_RECORD_ACCESS, "record-access" }, + { FILE_STREAM_ACCESS, "stream-access" }, + { FILE_RECORD_AND_STREAM_ACCESS, "record-and-stream-access" }, + { 0, NULL } +}; + +const char *bactext_file_access_method_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_file_access_method_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lock_status_names[] = { + /* BACnetLockStatus enumerations */ + { LOCK_STATUS_LOCKED, "locked" }, + { LOCK_STATUS_UNLOCKED, "unlocked" }, + { LOCK_STATUS_LOCK_FAULT, "lock-fault" }, + { LOCK_STATUS_UNUSED, "unused" }, + { LOCK_STATUS_UNKNOWN, "unknown" }, + { 0, NULL } +}; + +const char *bactext_lock_status_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lock_status_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_door_alarm_state_names[] = { + /* BACnetDoorAlarmState enumerations */ + { DOOR_ALARM_STATE_NORMAL, "normal" }, + { DOOR_ALARM_STATE_ALARM, "alarm" }, + { DOOR_ALARM_STATE_DOOR_OPEN_TOO_LONG, "door-open-too-long" }, + { DOOR_ALARM_STATE_FORCED_OPEN, "forced-open" }, + { DOOR_ALARM_STATE_TAMPER, "tamper" }, + { DOOR_ALARM_STATE_DOOR_FAULT, "door-fault" }, + { DOOR_ALARM_STATE_LOCK_DOWN, "lock-down" }, + { DOOR_ALARM_STATE_FREE_ACCESS, "free-access" }, + { DOOR_ALARM_STATE_EGRESS_OPEN, "egress-open" }, + { 0, NULL } +}; + +const char *bactext_door_alarm_state_name(uint32_t index) +{ + /* Enumerated values 0-255 are reserved for definition by ASHRAE. + Enumerated values 256-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_door_alarm_state_names, index, 256, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_door_status_names[] = { + /* BACnetDoorStatus enumerations */ + { DOOR_STATUS_CLOSED, "closed" }, + { DOOR_STATUS_OPENED, "opened" }, + { DOOR_STATUS_UNKNOWN, "unknown" }, + { DOOR_STATUS_DOOR_FAULT, "door-fault" }, + { DOOR_STATUS_UNUSED, "unused" }, + { DOOR_STATUS_NONE, "none" }, + { DOOR_STATUS_CLOSING, "closing" }, + { DOOR_STATUS_OPENING, "opening" }, + { DOOR_STATUS_SAFETY_LOCKED, "safety-locked" }, + { DOOR_STATUS_LIMITED_OPENED, "limited-opened" }, + { 0, NULL } +}; + +const char *bactext_door_status_name(uint32_t index) +{ + /* Enumerated values 0-1023 are reserved for definition by ASHRAE. + Enumerated values 1024-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_door_status_names, index, 1024, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_door_secured_status_names[] = { + /* BACnetDoorSecuredStatus enumerations */ + { DOOR_SECURED_STATUS_SECURED, "secured" }, + { DOOR_SECURED_STATUS_UNSECURED, "unsecured" }, + { DOOR_SECURED_STATUS_UNKNOWN, "unknown" }, + { 0, NULL } +}; + +const char *bactext_door_secured_status_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_door_secured_status_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_access_event_names[] = { + /* BACnetAccessEvent enumerations */ + { ACCESS_EVENT_NONE, "none" }, + { ACCESS_EVENT_GRANTED, "granted" }, + { ACCESS_EVENT_MUSTER, "muster" }, + { ACCESS_EVENT_PASSBACK_DETECTED, "passback-detected" }, + { ACCESS_EVENT_DURESS, "duress" }, + { ACCESS_EVENT_TRACE, "trace" }, + { ACCESS_EVENT_LOCKOUT_MAX_ATTEMPTS, "lockout-max-attempts" }, + { ACCESS_EVENT_LOCKOUT_OTHER, "lockout-other" }, + { ACCESS_EVENT_LOCKOUT_RELINQUISHED, "lockout-relinquished" }, + { ACCESS_EVENT_LOCKED_BY_HIGHER_AUTHORITY, "locked-by-higher-authority" }, + { ACCESS_EVENT_OUT_OF_SERVICE, "out-of-service" }, + { ACCESS_EVENT_OUT_OF_SERVICE_RELINQUISHED, "out-of-service-relinquished" }, + { ACCESS_EVENT_ACCOMPANIMENT_BY, "accompaniment-by" }, + { ACCESS_EVENT_AUTHENTICATION_FACTOR_READ, "authentication-factor-read" }, + { ACCESS_EVENT_AUTHORIZATION_DELAYED, "authorization-delayed" }, + { ACCESS_EVENT_VERIFICATION_REQUIRED, "verification-required" }, + /* values over 128 indicate that access is denied */ + { ACCESS_EVENT_DENIED_DENY_ALL, "denied-deny-all" }, + { ACCESS_EVENT_DENIED_UNKNOWN_CREDENTIAL, "denied-unknown-credential" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_UNAVAILABLE, + "denied-authentication-unavailable" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_TIMEOUT, + "denied-authentication-factor-timeout" }, + { ACCESS_EVENT_DENIED_INCORRECT_AUTHENTICATION_FACTOR, + "denied-incorrect-authentication-factor" }, + { ACCESS_EVENT_DENIED_ZONE_NO_ACCESS_RIGHTS, + "denied-zone-no-access-rights" }, + { ACCESS_EVENT_DENIED_POINT_NO_ACCESS_RIGHTS, + "denied-point-no-access-rights" }, + { ACCESS_EVENT_DENIED_NO_ACCESS_RIGHTS, "denied-no-access-rights" }, + { ACCESS_EVENT_DENIED_OUT_OF_TIME_RANGE, "denied-out-of-time-range" }, + { ACCESS_EVENT_DENIED_THREAT_LEVEL, "denied-threat-level" }, + { ACCESS_EVENT_DENIED_PASSBACK, "denied-passback" }, + { ACCESS_EVENT_DENIED_UNEXPECTED_LOCATION_USAGE, + "denied-unexpected-location-usage" }, + { ACCESS_EVENT_DENIED_MAX_ATTEMPTS, "denied-max-attempts" }, + { ACCESS_EVENT_DENIED_LOWER_OCCUPANCY_LIMIT, + "denied-lower-occupancy-limit" }, + { ACCESS_EVENT_DENIED_UPPER_OCCUPANCY_LIMIT, + "denied-upper-occupancy-limit" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_LOST, + "denied-authentication-factor-lost" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_STOLEN, + "denied-authentication-factor-stolen" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_DAMAGED, + "denied-authentication-factor-damaged" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_DESTROYED, + "denied-authentication-factor-destroyed" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_DISABLED, + "denied-authentication-factor-disabled" }, + { ACCESS_EVENT_DENIED_AUTHENTICATION_FACTOR_ERROR, + "denied-authentication-factor-error" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_UNASSIGNED, + "denied-credential-unassigned" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_NOT_PROVISIONED, + "denied-credential-not-provisioned" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_NOT_YET_ACTIVE, + "denied-credential-not-yet-active" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_EXPIRED, "denied-credential-expired" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_MANUAL_DISABLE, + "denied-credential-manual-disable" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_LOCKOUT, "denied-credential-lockout" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_MAX_DAYS, "denied-credential-max-days" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_MAX_USES, "denied-credential-max-uses" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_INACTIVITY, + "denied-credential-inactivity" }, + { ACCESS_EVENT_DENIED_CREDENTIAL_DISABLED, "denied-credential-disabled" }, + { ACCESS_EVENT_DENIED_NO_ACCOMPANIMENT, "denied-no-accompaniment" }, + { ACCESS_EVENT_DENIED_INCORRECT_ACCOMPANIMENT, + "denied-incorrect-accompaniment" }, + { ACCESS_EVENT_DENIED_LOCKOUT, "denied-lockout" }, + { ACCESS_EVENT_DENIED_VERIFICATION_FAILED, "denied-verification-failed" }, + { ACCESS_EVENT_DENIED_VERIFICATION_TIMEOUT, "denied-verification-timeout" }, + { ACCESS_EVENT_DENIED_OTHER, "denied-other" }, + { 0, NULL } +}; + +const char *bactext_access_event_name(uint32_t index) +{ + /* Enumerated values 0-511 are reserved for definition by ASHRAE. + Enumerated values 512-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_access_event_names, index, ACCESS_EVENT_PROPRIETARY_MIN, + ASHRAE_Reserved_String, Vendor_Proprietary_String); +} + +const char * +bactext_access_event_name_default(uint32_t index, const char *default_string) +{ + return indtext_by_index_default( + bactext_access_event_names, index, default_string); +} + +INDTEXT_DATA bactext_authentication_status_names[] = { + /* BACnetAuthenticationStatus enumerations */ + { AUTHENTICATION_STATUS_NOT_READY, "not-ready" }, + { AUTHENTICATION_STATUS_READY, "ready" }, + { AUTHENTICATION_STATUS_DISABLED, "disabled" }, + { AUTHENTICATION_STATUS_WAITING_FOR_AUTHENTICATION_FACTOR, + "waiting-for-authentication-factor" }, + { AUTHENTICATION_STATUS_WAITING_FOR_ACCOMPANIMENT, + "waiting-for-accompaniment" }, + { AUTHENTICATION_STATUS_WAITING_FOR_VERIFICATION, + "waiting-for-verification" }, + { AUTHENTICATION_STATUS_IN_PROGRESS, "in-progress" }, + { 0, NULL } +}; + +const char *bactext_authentication_status_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_authentication_status_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_authorization_mode_names[] = { + /* BACnetAuthorizationMode enumerations */ + { AUTHORIZATION_MODE_AUTHORIZE, "authorize" }, + { AUTHORIZATION_MODE_GRANT_ACTIVE, "grant-active" }, + { AUTHORIZATION_MODE_DENY_ALL, "deny-all" }, + { AUTHORIZATION_MODE_VERIFICATION_REQUIRED, "verification-required" }, + { AUTHORIZATION_MODE_AUTHORIZATION_DELAYED, "authorization-delayed" }, + { AUTHORIZATION_MODE_NONE, "none" }, + { 0, NULL } +}; + +const char *bactext_authorization_mode_name(uint32_t index) +{ + /* Enumerated values 0-63 are reserved for definition by ASHRAE. + Enumerated values 64-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_authorization_mode_names, index, 64, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +bool bactext_authorization_mode_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_authorization_mode_names, search_name, found_index); +} + +INDTEXT_DATA bactext_access_credential_disable_names[] = { + /* BACnetAccessCredentialDisable enumerations */ + { ACCESS_CREDENTIAL_DISABLE_NONE, "none" }, + { ACCESS_CREDENTIAL_DISABLE_DISABLE, "disable" }, + { ACCESS_CREDENTIAL_DISABLE_MANUAL, "disable-manual" }, + { ACCESS_CREDENTIAL_DISABLE_LOCKOUT, "disable-lockout" }, + { 0, NULL } +}; + +const char *bactext_access_credential_disable_name(uint32_t index) +{ + /* Enumerated values 0-63 are reserved for definition by ASHRAE. + Enumerated values 64-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_access_credential_disable_names, index, + ACCESS_CREDENTIAL_DISABLE_PROPRIETARY_MIN, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_access_credential_disable_reason_names[] = { + /* BACnetAccessCredentialDisableReason enumerations */ + { CREDENTIAL_DISABLED, "none" }, + { CREDENTIAL_DISABLED_NEEDS_PROVISIONING, "needs-provisioning" }, + { CREDENTIAL_DISABLED_UNASSIGNED, "unassigned" }, + { CREDENTIAL_DISABLED_NOT_YET_ACTIVE, "not-yet-active" }, + { CREDENTIAL_DISABLED_EXPIRED, "expired" }, + { CREDENTIAL_DISABLED_LOCKOUT, "lockout" }, + { CREDENTIAL_DISABLED_MAX_DAYS, "max-days" }, + { CREDENTIAL_DISABLED_MAX_USES, "max-uses" }, + { CREDENTIAL_DISABLED_INACTIVITY, "inactivity" }, + { CREDENTIAL_DISABLED_MANUAL, "manual" }, + { 0, NULL } +}; + +const char *bactext_access_credential_disable_reason_name(uint32_t index) +{ + /* Enumerated values 0-63 are reserved for definition by ASHRAE. + Enumerated values 64-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_access_credential_disable_reason_names, index, + CREDENTIAL_DISABLED_PROPRIETARY_MIN, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_access_user_type_names[] = { + /* BACnetAccessUserType enumerations */ + { ACCESS_USER_TYPE_ASSET, "asset" }, + { ACCESS_USER_TYPE_GROUP, "group" }, + { ACCESS_USER_TYPE_PERSON, "person" }, + { 0, NULL } +}; + +const char *bactext_access_user_type_name(uint32_t index) +{ + /* Enumerated values 0-63 are reserved for definition by ASHRAE. + Enumerated values 64-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_access_user_type_names, index, 64, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +bool bactext_access_user_type_strtol( + const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_access_user_type_names, search_name, found_index); +} + +INDTEXT_DATA bactext_access_zone_occupancy_state_names[] = { + /* BACnetAccessZoneOccupancyState enumerations */ + { ACCESS_ZONE_OCCUPANCY_STATE_NORMAL, "normal" }, + { ACCESS_ZONE_OCCUPANCY_STATE_BELOW_LOWER_LIMIT, "below-lower-limit" }, + { ACCESS_ZONE_OCCUPANCY_STATE_AT_LOWER_LIMIT, "at-lower-limit" }, + { ACCESS_ZONE_OCCUPANCY_STATE_AT_UPPER_LIMIT, "at-upper-limit" }, + { ACCESS_ZONE_OCCUPANCY_STATE_ABOVE_UPPER_LIMIT, "above-upper-limit" }, + { ACCESS_ZONE_OCCUPANCY_STATE_DISABLED, "disabled" }, + { ACCESS_ZONE_OCCUPANCY_STATE_NOT_SUPPORTED, "not-supported" }, + { 0, NULL } +}; + +const char *bactext_access_zone_occupancy_state_name(uint32_t index) +{ + /* Enumerated values 0-63 are reserved for definition by ASHRAE. + Enumerated values 64-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_access_zone_occupancy_state_names, index, 64, + ASHRAE_Reserved_String, Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_write_status_names[] = { + /* BACnetWriteStatus enumerations */ + { BACNET_WRITE_STATUS_IDLE, "idle" }, + { BACNET_WRITE_STATUS_IN_PROGRESS, "in-progress" }, + { BACNET_WRITE_STATUS_SUCCESSFUL, "successful" }, + { BACNET_WRITE_STATUS_FAILED, "failed" }, + { 0, NULL } +}; + +const char *bactext_write_status_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_write_status_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_ip_mode_names[] = { + /* BACnetIPMode enumerations */ + { BACNET_IP_MODE_NORMAL, "normal" }, + { BACNET_IP_MODE_FOREIGN, "foreign" }, + { BACNET_IP_MODE_BBMD, "bbmd" }, + { 0, NULL } +}; + +const char *bactext_ip_mode_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_ip_mode_names, index, ASHRAE_Reserved_String); +} + +bool bactext_ip_mode_strtol(const char *search_name, uint32_t *found_index) +{ + return bactext_string_to_uint32_index( + bactext_ip_mode_names, search_name, found_index); +} + +INDTEXT_DATA bactext_door_value_names[] = { + /* BACnetDoorValue enumerations */ + { DOOR_VALUE_LOCK, "lock" }, + { DOOR_VALUE_UNLOCK, "unlock" }, + { DOOR_VALUE_PULSE_UNLOCK, "pulse-unlock" }, + { DOOR_VALUE_EXTENDED_PULSE_UNLOCK, "extended-pulse-unlock" }, + { 0, NULL } +}; + +const char *bactext_door_value_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_door_value_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_maintenance_names[] = { + /* BACnetMaintenance enumerations */ + { MAINTENANCE_NONE, "none" }, + { MAINTENANCE_PERIODIC_TEST, "periodic-test" }, + { MAINTENANCE_NEED_SERVICE_OPERATIONAL, "need-service-operational" }, + { MAINTENANCE_NEED_SERVICE_INOPERATIVE, "need-service-inoperative" }, + { 0, NULL } +}; + +const char *bactext_maintenance_name(uint32_t index) +{ + /* Enumerated values 0-255 are reserved for definition by ASHRAE. */ + /* Enumerated values 256-65535 may be used by others subject to */ + /* procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_maintenance_names, index, MAINTENANCE_PROPRIETARY_MIN, + ASHRAE_Reserved_String, Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_escalator_fault_names[] = { + /* BACnetEscalatorFault enumerations */ + { ESCALATOR_FAULT_CONTROLLER_FAULT, "controller-fault" }, + { ESCALATOR_FAULT_DRIVE_AND_MOTOR_FAULT, "drive-and-motor-fault" }, + { ESCALATOR_FAULT_MECHANICAL_COMPONENT_FAULT, + "mechanical-component-fault" }, + { ESCALATOR_FAULT_OVERSPEED_FAULT, "overspeed-fault" }, + { ESCALATOR_FAULT_POWER_SUPPLY_FAULT, "power-supply-fault" }, + { ESCALATOR_FAULT_SAFETY_DEVICE_FAULT, "safety-device-fault" }, + { ESCALATOR_FAULT_CONTROLLER_SUPPLY_FAULT, "controller-supply-fault" }, + { ESCALATOR_FAULT_DRIVE_TEMPERATURE_EXCEEDED, + "drive-temperature-exceeded" }, + { ESCALATOR_FAULT_COMB_PLATE_FAULT, "comb-plate-fault" }, + { 0, NULL } +}; + +const char *bactext_escalator_fault_name(uint32_t index) +{ + /* Enumerated values 0-1023 are reserved for definition by ASHRAE. + Enumerated values 1024-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_escalator_fault_names, index, ESCALATOR_FAULT_PROPRIETARY_MIN, + ASHRAE_Reserved_String, Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_escalator_mode_names[] = { + /* BACnetEscalatorMode enumerations */ + { ESCALATOR_MODE_UNKNOWN, "unknown" }, + { ESCALATOR_MODE_STOP, "stop" }, + { ESCALATOR_MODE_UP, "up" }, + { ESCALATOR_MODE_DOWN, "down" }, + { ESCALATOR_MODE_INSPECTION, "inspection" }, + { ESCALATOR_MODE_OUT_OF_SERVICE, "out-of-service" }, + { 0, NULL } +}; + +const char *bactext_escalator_mode_name(uint32_t index) +{ + /* Enumerated values 0-1023 are reserved for definition by ASHRAE. + Enumerated values 1024-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_escalator_mode_names, index, ESCALATOR_MODE_PROPRIETARY_MIN, + ASHRAE_Reserved_String, Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_escalator_operation_direction_names[] = { + /* BACnetEscalatorOperationDirection enumerations */ + { ESCALATOR_OPERATION_DIRECTION_UNKNOWN, "unknown" }, + { ESCALATOR_OPERATION_DIRECTION_STOPPED, "stopped" }, + { ESCALATOR_OPERATION_DIRECTION_UP_RATED_SPEED, "up-rated-speed" }, + { ESCALATOR_OPERATION_DIRECTION_UP_REDUCED_SPEED, "up-reduced-speed" }, + { ESCALATOR_OPERATION_DIRECTION_DOWN_RATED_SPEED, "down-rated-speed" }, + { ESCALATOR_OPERATION_DIRECTION_DOWN_REDUCED_SPEED, "down-reduced-speed" }, + { 0, NULL } +}; +const char *bactext_escalator_operation_direction_name(uint32_t index) +{ + /* Enumerated values 0-1023 are reserved for definition by ASHRAE. + Enumerated values 1024-65535 may be used by others subject to + the procedures and constraints described in Clause 23. */ + return indtext_by_index_split_default( + bactext_escalator_operation_direction_names, index, + ESCALATOR_OPERATION_DIRECTION_PROPRIETARY_MIN, ASHRAE_Reserved_String, + Vendor_Proprietary_String); +} + +INDTEXT_DATA bactext_backup_state_names[] = { + /* BACnetBackupState enumerations */ + { BACKUP_STATE_IDLE, "idle" }, + { BACKUP_STATE_PREPARING_FOR_BACKUP, "preparing-for-backup" }, + { BACKUP_STATE_PREPARING_FOR_RESTORE, "preparing-for-restore" }, + { BACKUP_STATE_PERFORMING_A_BACKUP, "performing-a-backup" }, + { BACKUP_STATE_PERFORMING_A_RESTORE, "performing-a-restore" }, + { BACKUP_STATE_BACKUP_FAILURE, "backup-failure" }, + { BACKUP_STATE_RESTORE_FAILURE, "restore-failure" }, + { 0, NULL } +}; + +const char *bactext_backup_state_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_backup_state_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_security_level_names[] = { + /* BACnetSecurityLevel enumerations */ + { BACNET_SECURITY_LEVEL_INCAPABLE, "incapable" }, + { BACNET_SECURITY_LEVEL_PLAIN, "plain" }, + { BACNET_SECURITY_LEVEL_SIGNED, "signed" }, + { BACNET_SECURITY_LEVEL_ENCRYPTED, "encrypted" }, + { BACNET_SECURITY_LEVEL_SIGNED_END_TO_END, "signed-end-to-end" }, + { BACNET_SECURITY_LEVEL_ENCRYPTED_END_TO_END, "encrypted-end-to-end" }, + { 0, NULL } +}; + +const char *bactext_security_level_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_security_level_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lift_car_direction_names[] = { + /* BACnetLiftCarDirection enumerations */ + { LIFT_CAR_DIRECTION_UNKNOWN, "unknown" }, + { LIFT_CAR_DIRECTION_NONE, "none" }, + { LIFT_CAR_DIRECTION_STOPPED, "stopped" }, + { LIFT_CAR_DIRECTION_UP, "up" }, + { LIFT_CAR_DIRECTION_DOWN, "down" }, + { LIFT_CAR_DIRECTION_UP_AND_DOWN, "up-and-down" }, + { 0, NULL } +}; + +const char *bactext_lift_car_direction_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lift_car_direction_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lift_car_door_command_names[] = { + /* BACnetLiftCarDoorCommand enumerations */ + { LIFT_CAR_DOOR_COMMAND_NONE, "none" }, + { LIFT_CAR_DOOR_COMMAND_OPEN, "open" }, + { LIFT_CAR_DOOR_COMMAND_CLOSE, "close" }, + { 0, NULL } +}; + +const char *bactext_lift_car_door_command_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lift_car_door_command_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lift_car_drive_status_names[] = { + /* BACnetLiftCarDriveStatus enumerations */ + { LIFT_CAR_DRIVE_STATUS_UNKNOWN, "unknown" }, + { LIFT_CAR_DRIVE_STATUS_STATIONARY, "stationary" }, + { LIFT_CAR_DRIVE_STATUS_BRAKING, "braking" }, + { LIFT_CAR_DRIVE_STATUS_ACCELERATE, "accelerate" }, + { LIFT_CAR_DRIVE_STATUS_DECELERATE, "decelerate" }, + { LIFT_CAR_DRIVE_STATUS_RATED_SPEED, "rated-speed" }, + { LIFT_CAR_DRIVE_STATUS_SINGLE_FLOOR_JUMP, "single-floor-jump" }, + { LIFT_CAR_DRIVE_STATUS_TWO_FLOOR_JUMP, "two-floor-jump" }, + { LIFT_CAR_DRIVE_STATUS_THREE_FLOOR_JUMP, "three-floor-jump" }, + { LIFT_CAR_DRIVE_STATUS_MULTI_FLOOR_JUMP, "multi-floor-jump" }, + { 0, NULL } +}; + +const char *bactext_lift_car_drive_status_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lift_car_drive_status_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lift_car_mode_names[] = { + /* BACnetLiftCarMode enumerations */ + { LIFT_CAR_MODE_UNKNOWN, "unknown" }, + { LIFT_CAR_MODE_NORMAL, "normal" }, + { LIFT_CAR_MODE_VIP, "vip" }, + { LIFT_CAR_MODE_HOMING, "homing" }, + { LIFT_CAR_MODE_PARKING, "parking" }, + { LIFT_CAR_MODE_ATTENDANT_CONTROL, "attendant-control" }, + { LIFT_CAR_MODE_FIREFIGHTER_CONTROL, "firefighter-control" }, + { LIFT_CAR_MODE_EMERGENCY_POWER, "emergency-power" }, + { LIFT_CAR_MODE_INSPECTION, "inspection" }, + { LIFT_CAR_MODE_CABINET_RECALL, "cabinet-recall" }, + { LIFT_CAR_MODE_EARTHQUAKE_OPERATION, "earthquake-operation" }, + { LIFT_CAR_MODE_FIRE_OPERATION, "fire-operation" }, + { LIFT_CAR_MODE_OUT_OF_SERVICE, "out-of-service" }, + { LIFT_CAR_MODE_OCCUPANT_EVACUATION, "occupant-evacuation" }, + { 0, NULL } +}; + +const char *bactext_lift_car_mode_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lift_car_mode_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lift_fault_names[] = { + /* BACnetLiftFault enumerations */ + { LIFT_FAULT_CONTROLLER_FAULT, "controller-fault" }, + { LIFT_FAULT_DRIVE_AND_MOTOR_FAULT, "drive-and-motor-fault" }, + { LIFT_FAULT_GOVERNOR_AND_SAFETY_GEAR_FAULT, + "governor-and-safety-gear-fault" }, + { LIFT_FAULT_LIFT_SHAFT_DEVICE_FAULT, "lift-shaft-device-fault" }, + { LIFT_FAULT_POWER_SUPPLY_FAULT, "power-supply-fault" }, + { LIFT_FAULT_SAFETY_INTERLOCK_FAULT, "safety-interlock-fault" }, + { LIFT_FAULT_DOOR_CLOSING_FAULT, "door-closing-fault" }, + { LIFT_FAULT_DOOR_OPENING_FAULT, "door-opening-fault" }, + { LIFT_FAULT_CAR_STOPPED_OUTSIDE_LANDING_ZONE, + "car-stopped-outside-landing-zone" }, + { LIFT_FAULT_CALL_BUTTON_STUCK, "call-button-stuck" }, + { LIFT_FAULT_START_FAILURE, "start-failure" }, + { LIFT_FAULT_CONTROLLER_SUPPLY_FAULT, "controller-supply-fault" }, + { LIFT_FAULT_SELF_TEST_FAILURE, "self-test-failure" }, + { LIFT_FAULT_RUNTIME_LIMIT_EXCEEDED, "runtime-limit-exceeded" }, + { LIFT_FAULT_POSITION_LOST, "position-lost" }, + { LIFT_FAULT_DRIVE_TEMPERATURE_EXCEEDED, "drive-temperature-exceeded" }, + { LIFT_FAULT_LOAD_MEASUREMENT_FAULT, "load-measurement-fault" }, + { 0, NULL } +}; + +const char *bactext_lift_fault_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lift_fault_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_lift_group_mode_names[] = { + /* BACnetLiftGroupMode enumerations */ + { LIFT_GROUP_MODE_UNKNOWN, "unknown" }, + { LIFT_GROUP_MODE_NORMAL, "normal" }, + { LIFT_GROUP_MODE_DOWN_PEAK, "down-peak" }, + { LIFT_GROUP_MODE_TWO_WAY, "two-way" }, + { LIFT_GROUP_MODE_FOUR_WAY, "four-way" }, + { LIFT_GROUP_MODE_EMERGENCY_POWER, "emergency-power" }, + { LIFT_GROUP_MODE_UP_PEAK, "up-peak" }, + { 0, NULL } +}; + +const char *bactext_lift_group_mode_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_lift_group_mode_names, index, ASHRAE_Reserved_String); +} + +static INDTEXT_DATA bactext_audit_level_names[] = { + /* BACnetAuditLevel enumerations */ + { AUDIT_LEVEL_NONE, "none" }, + { AUDIT_LEVEL_AUDIT_ALL, "audit-all" }, + { AUDIT_LEVEL_AUDIT_CONFIG, "audit-config" }, + { AUDIT_LEVEL_DEFAULT, "default" }, + { 0, NULL } +}; + +const char *bactext_audit_level_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_audit_level_names, index, ASHRAE_Reserved_String); +} + +static INDTEXT_DATA bactext_audit_operation_names[] = { + /* BACnetAuditOperation enumerations */ + { AUDIT_OPERATION_READ, "read" }, + { AUDIT_OPERATION_WRITE, "write" }, + { AUDIT_OPERATION_CREATE, "create" }, + { AUDIT_OPERATION_DELETE, "delete" }, + { AUDIT_OPERATION_LIFE_SAFETY, "life-safety" }, + { AUDIT_OPERATION_ACKNOWLEDGE_ALARM, "acknowledge-alarm" }, + { AUDIT_OPERATION_DEVICE_DISABLE_COMM, "device-disable-comm" }, + { AUDIT_OPERATION_DEVICE_ENABLE_COMM, "device-enable-comm" }, + { AUDIT_OPERATION_DEVICE_RESET, "device-reset" }, + { AUDIT_OPERATION_DEVICE_BACKUP, "device-backup" }, + { AUDIT_OPERATION_DEVICE_RESTORE, "device-restore" }, + { AUDIT_OPERATION_SUBSCRIPTION, "subscription" }, + { AUDIT_OPERATION_NOTIFICATION, "notification" }, + { AUDIT_OPERATION_AUDITING_FAILURE, "auditing-failure" }, + { AUDIT_OPERATION_NETWORK_CHANGES, "network-changes" }, + { AUDIT_OPERATION_GENERAL, "general" }, + { 0, NULL } +}; + +const char *bactext_audit_operation_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_audit_operation_names, index, ASHRAE_Reserved_String); +} + +INDTEXT_DATA bactext_sc_hub_connector_state_names[] = { + /* BACnetSCHubConnectorState enumerations */ + { BACNET_SC_HUB_CONNECTOR_STATE_NO_HUB_CONNECTION, "no-hub-connection" }, + { BACNET_SC_HUB_CONNECTOR_STATE_CONNECTED_TO_PRIMARY, + "connected-to-primary" }, + { BACNET_SC_HUB_CONNECTOR_STATE_CONNECTED_TO_FAILOVER, + "connected-to-failover" }, + { 0, NULL } +}; + +const char *bactext_sc_hub_connector_state_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_sc_hub_connector_state_names, index, ASHRAE_Reserved_String); +} + +static INDTEXT_DATA bactext_sc_connection_state_names[] = { + /* BACnetSCConnectionState enumerations */ + { BACNET_SC_CONNECTION_STATE_NOT_CONNECTED, "not-connected" }, + { BACNET_SC_CONNECTION_STATE_CONNECTED, "connected" }, + { BACNET_SC_CONNECTION_STATE_DISCONNECTED_WITH_ERRORS, + "disconnected-with-errors" }, + { BACNET_SC_CONNECTION_STATE_FAILED_TO_CONNECT, "failed-to-connect" }, + { 0, NULL } +}; + +const char *bactext_sc_connection_state_name(uint32_t index) +{ + return indtext_by_index_default( + bactext_sc_connection_state_names, index, ASHRAE_Reserved_String); +} + +/* === property and text-list pairs === */ +typedef const struct { + const uint32_t index; + INDTEXT_DATA *data_list; +} INDTEXT_PROPERTY_DATA; + +INDTEXT_PROPERTY_DATA bactext_property_states_data[] = { + { PROP_STATE_BOOLEAN_VALUE, bactext_boolean_value_names }, + { PROP_STATE_BINARY_VALUE, bacnet_binary_present_value_names }, + { PROP_STATE_EVENT_TYPE, bacnet_event_type_names }, + { PROP_STATE_POLARITY, bacnet_binary_polarity_names }, + { PROP_STATE_PROGRAM_CHANGE, bactext_program_request_names }, + { PROP_STATE_PROGRAM_STATE, bactext_program_state_names }, + { PROP_STATE_REASON_FOR_HALT, bactext_program_error_names }, + { PROP_STATE_RELIABILITY, bacnet_reliability_names }, + { PROP_STATE_EVENT_STATE, bacnet_event_state_names }, + { PROP_STATE_SYSTEM_STATUS, bacnet_device_status_names }, + { PROP_STATE_UNITS, bacnet_engineering_unit_names }, + { PROP_STATE_LIFE_SAFETY_MODE, bactext_life_safety_mode_names }, + { PROP_STATE_LIFE_SAFETY_STATE, bactext_life_safety_state_names }, + { PROP_STATE_RESTART_REASON, bactext_restart_reason_names }, + { PROP_STATE_LIFE_SAFETY_OPERATION, bactext_life_safety_operation_names }, + { PROP_STATE_NODE_TYPE, bacnet_node_type_names }, + { PROP_STATE_NOTIFY_TYPE, bacnet_notify_type_names }, + { PROP_STATE_SHED_STATE, bacnet_shed_state_names }, + { PROP_STATE_SILENCED_STATE, bactext_silenced_state_names }, + { PROP_STATE_LIGHTING_IN_PROGRESS, bacnet_lighting_in_progress_names }, + { PROP_STATE_LIGHTING_OPERATION, bacnet_lighting_operation_names }, + { PROP_STATE_LIGHTING_TRANSITION, bacnet_lighting_transition_names }, + { PROP_STATE_BINARY_LIGHTING_VALUE, bacnet_binary_lighting_pv_names }, + { PROP_STATE_TIMER_STATE, bactext_timer_state_names }, + { PROP_STATE_TIMER_TRANSITION, bactext_timer_transition_names }, + { PROP_STATE_NETWORK_PORT_COMMAND, bactext_network_port_command_names }, + { PROP_STATE_NETWORK_TYPE, bactext_network_port_type_names }, + { PROP_STATE_NETWORK_NUMBER_QUALITY, bactext_network_number_quality_names }, + { PROP_STATE_PROTOCOL_LEVEL, bactext_protocol_level_names }, + { PROP_STATE_ACTION, bactext_action_names }, + { PROP_STATE_FILE_ACCESS_METHOD, bactext_file_access_method_names }, + { PROP_STATE_LOCK_STATUS, bactext_lock_status_names }, + { PROP_STATE_DOOR_ALARM_STATE, bactext_door_alarm_state_names }, + { PROP_STATE_DOOR_STATUS, bactext_door_status_names }, + { PROP_STATE_DOOR_SECURED_STATUS, bactext_door_secured_status_names }, + { PROP_STATE_ACCESS_EVENT, bactext_access_event_names }, + { PROP_STATE_AUTHENTICATION_STATUS, bactext_authentication_status_names }, + { PROP_STATE_ACCESS_CRED_DISABLE, bactext_access_credential_disable_names }, + { PROP_STATE_ACCESS_CRED_DISABLE_REASON, + bactext_access_credential_disable_reason_names }, + { PROP_STATE_ZONE_OCCUPANCY_STATE, + bactext_access_zone_occupancy_state_names }, + { PROP_STATE_DOOR_VALUE, bactext_door_value_names }, + { PROP_STATE_MAINTENANCE, bactext_maintenance_names }, + { PROP_STATE_SECURITY_LEVEL, bactext_security_level_names }, + { PROP_STATE_BACKUP_STATE, bactext_backup_state_names }, + { PROP_STATE_WRITE_STATUS, bactext_write_status_names }, + { PROP_STATE_BACNET_IP_MODE, bactext_ip_mode_names }, + { PROP_STATE_ESCALATOR_OPERATION_DIRECTION, + bactext_escalator_operation_direction_names }, + { PROP_STATE_ESCALATOR_FAULT, bactext_escalator_fault_names }, + { PROP_STATE_ESCALATOR_MODE, bactext_escalator_mode_names }, + { PROP_STATE_LIFT_CAR_DIRECTION, bactext_lift_car_direction_names }, + { PROP_STATE_LIFT_CAR_DOOR_COMMAND, bactext_lift_car_door_command_names }, + { PROP_STATE_LIFT_CAR_DRIVE_STATUS, bactext_lift_car_drive_status_names }, + { PROP_STATE_LIFT_CAR_MODE, bactext_lift_car_mode_names }, + { PROP_STATE_LIFT_GROUP_MODE, bactext_lift_group_mode_names }, + { PROP_STATE_LIFT_FAULT, bactext_lift_fault_names }, + { PROP_STATE_AUDIT_LEVEL, bactext_audit_level_names }, + { PROP_STATE_AUDIT_OPERATION, bactext_audit_operation_names }, + { PROP_STATE_SC_HUB_CONNECTOR_STATE, bactext_sc_hub_connector_state_names }, + { PROP_STATE_SC_CONNECTION_STATE, bactext_sc_connection_state_names }, + /* use default handler for numeric types */ + { PROP_STATE_INTEGER_VALUE, NULL /* default */ }, + { PROP_STATE_EXTENDED_VALUE, NULL /* default */ }, + { PROP_STATE_UNSIGNED_VALUE, NULL /* default */ }, + { 0, NULL } +}; + bool bactext_property_states_strtoul( BACNET_PROPERTY_STATES property_state, const char *search_name, uint32_t *found_index) { bool status = false; + INDTEXT_PROPERTY_DATA *list; - switch (property_state) { - case PROP_STATE_BOOLEAN_VALUE: + list = bactext_property_states_data; + while (list->data_list != NULL) { + if (list->index == property_state) { status = bactext_string_to_uint32_index( - bactext_boolean_value_names, search_name, found_index); - break; - case PROP_STATE_BINARY_VALUE: - status = bactext_string_to_uint32_index( - bacnet_binary_present_value_names, search_name, found_index); - break; - case PROP_STATE_EVENT_TYPE: - status = bactext_string_to_uint32_index( - bacnet_event_type_names, search_name, found_index); - break; - case PROP_STATE_POLARITY: - status = bactext_string_to_uint32_index( - bacnet_binary_polarity_names, search_name, found_index); - break; - case PROP_STATE_PROGRAM_CHANGE: - status = bactext_string_to_uint32_index( - bactext_program_request_names, search_name, found_index); - break; - case PROP_STATE_PROGRAM_STATE: - status = bactext_string_to_uint32_index( - bactext_program_state_names, search_name, found_index); - break; - case PROP_STATE_REASON_FOR_HALT: - status = bactext_string_to_uint32_index( - bactext_program_error_names, search_name, found_index); - break; - case PROP_STATE_RELIABILITY: - status = bactext_string_to_uint32_index( - bacnet_reliability_names, search_name, found_index); - break; - case PROP_STATE_EVENT_STATE: - status = bactext_string_to_uint32_index( - bacnet_event_state_names, search_name, found_index); - break; - case PROP_STATE_SYSTEM_STATUS: - status = bactext_string_to_uint32_index( - bacnet_device_status_names, search_name, found_index); - break; - case PROP_STATE_UNITS: - status = bactext_string_to_uint32_index( - bacnet_engineering_unit_names, search_name, found_index); - break; - case PROP_STATE_LIFE_SAFETY_MODE: - status = bactext_string_to_uint32_index( - bactext_life_safety_mode_names, search_name, found_index); - break; - case PROP_STATE_LIFE_SAFETY_STATE: - status = bactext_string_to_uint32_index( - bactext_life_safety_state_names, search_name, found_index); - break; - case PROP_STATE_RESTART_REASON: - status = bactext_string_to_uint32_index( - bactext_restart_reason_names, search_name, found_index); - break; - case PROP_STATE_LIFE_SAFETY_OPERATION: - status = bactext_string_to_uint32_index( - bactext_life_safety_operation_names, search_name, found_index); - break; - case PROP_STATE_NODE_TYPE: - status = bactext_string_to_uint32_index( - bacnet_node_type_names, search_name, found_index); - break; - case PROP_STATE_NOTIFY_TYPE: - status = bactext_string_to_uint32_index( - bacnet_notify_type_names, search_name, found_index); - break; - case PROP_STATE_SHED_STATE: - status = bactext_string_to_uint32_index( - bacnet_shed_state_names, search_name, found_index); - break; - case PROP_STATE_SILENCED_STATE: - status = bactext_string_to_uint32_index( - bactext_silenced_state_names, search_name, found_index); - break; - case PROP_STATE_LIGHTING_IN_PROGRESS: - status = bactext_string_to_uint32_index( - bacnet_lighting_in_progress_names, search_name, found_index); - break; - case PROP_STATE_LIGHTING_OPERATION: - status = bactext_string_to_uint32_index( - bacnet_lighting_operation_names, search_name, found_index); - break; - case PROP_STATE_LIGHTING_TRANSITION: - status = bactext_string_to_uint32_index( - bacnet_lighting_transition_names, search_name, found_index); - break; - case PROP_STATE_BINARY_LIGHTING_VALUE: - status = bactext_string_to_uint32_index( - bacnet_binary_lighting_pv_names, search_name, found_index); - break; - case PROP_STATE_TIMER_STATE: - status = bactext_string_to_uint32_index( - bactext_timer_state_names, search_name, found_index); - break; - case PROP_STATE_TIMER_TRANSITION: - status = bactext_string_to_uint32_index( - bactext_timer_transition_names, search_name, found_index); - break; - case PROP_STATE_NETWORK_PORT_COMMAND: - status = bactext_string_to_uint32_index( - bactext_network_port_command_names, search_name, found_index); - break; - case PROP_STATE_NETWORK_TYPE: - status = bactext_string_to_uint32_index( - bactext_network_port_type_names, search_name, found_index); - break; - case PROP_STATE_NETWORK_NUMBER_QUALITY: - status = bactext_string_to_uint32_index( - bactext_network_number_quality_names, search_name, found_index); - break; - case PROP_STATE_PROTOCOL_LEVEL: - status = bactext_string_to_uint32_index( - bactext_protocol_level_names, search_name, found_index); - break; - case PROP_STATE_ACTION: - case PROP_STATE_DOOR_SECURED_STATUS: - case PROP_STATE_DOOR_STATUS: - case PROP_STATE_DOOR_VALUE: - case PROP_STATE_FILE_ACCESS_METHOD: - case PROP_STATE_LOCK_STATUS: - case PROP_STATE_MAINTENANCE: - case PROP_STATE_SECURITY_LEVEL: - case PROP_STATE_ACCESS_EVENT: - case PROP_STATE_ZONE_OCCUPANCY_STATE: - case PROP_STATE_ACCESS_CRED_DISABLE_REASON: - case PROP_STATE_ACCESS_CRED_DISABLE: - case PROP_STATE_AUTHENTICATION_STATUS: - case PROP_STATE_BACKUP_STATE: - case PROP_STATE_WRITE_STATUS: - case PROP_STATE_INTEGER_VALUE: - case PROP_STATE_BACNET_IP_MODE: - case PROP_STATE_ESCALATOR_OPERATION_DIRECTION: - case PROP_STATE_ESCALATOR_FAULT: - case PROP_STATE_ESCALATOR_MODE: - case PROP_STATE_LIFT_CAR_DIRECTION: - case PROP_STATE_LIFT_CAR_DOOR_COMMAND: - case PROP_STATE_LIFT_CAR_DRIVE_STATUS: - case PROP_STATE_LIFT_CAR_MODE: - case PROP_STATE_LIFT_GROUP_MODE: - case PROP_STATE_LIFT_FAULT: - case PROP_STATE_AUDIT_LEVEL: - case PROP_STATE_AUDIT_OPERATION: - case PROP_STATE_EXTENDED_VALUE: - case PROP_STATE_DOOR_ALARM_STATE: - case PROP_STATE_UNSIGNED_VALUE: - default: - status = bacnet_string_to_uint32(search_name, found_index); + list->data_list, search_name, found_index); break; + } + list++; + } + if (!status) { + /* not found - convert the text to a number */ + status = bacnet_string_to_uint32(search_name, found_index); } return status; } +const char *bactext_property_states_name( + BACNET_PROPERTY_STATES property_state, + uint32_t index, + const char *default_string) +{ + const char *name = NULL; + INDTEXT_PROPERTY_DATA *list; + list = bactext_property_states_data; + while (list->data_list != NULL) { + if (list->index == property_state) { + if (list->data_list != NULL) { + name = indtext_by_index_default( + list->data_list, index, default_string); + } + break; + } + list++; + } + if (!name) { + name = default_string; + } + return name; +} + +INDTEXT_PROPERTY_DATA bactext_object_property_data[] = { + { PROP_PROPERTY_LIST, bacnet_property_names }, + { PROP_OBJECT_TYPE, bacnet_object_type_names }, + { PROP_EVENT_STATE, bacnet_event_state_names }, + { PROP_UNITS, bacnet_engineering_unit_names }, + { PROP_CONTROLLED_VARIABLE_UNITS, bacnet_engineering_unit_names }, + { PROP_DERIVATIVE_CONSTANT_UNITS, bacnet_engineering_unit_names }, + { PROP_INTEGRAL_CONSTANT_UNITS, bacnet_engineering_unit_names }, + { PROP_PROPORTIONAL_CONSTANT_UNITS, bacnet_engineering_unit_names }, + { PROP_OUTPUT_UNITS, bacnet_engineering_unit_names }, + { PROP_CAR_LOAD_UNITS, bacnet_engineering_unit_names }, + { PROP_POLARITY, bacnet_binary_polarity_names }, + { PROP_RELIABILITY, bacnet_reliability_names }, + { PROP_SYSTEM_STATUS, bacnet_device_status_names }, + { PROP_SEGMENTATION_SUPPORTED, bacnet_segmentation_names }, + { PROP_NODE_TYPE, bacnet_node_type_names }, + { PROP_SUBORDINATE_NODE_TYPES, bacnet_node_type_names }, + { PROP_SUBORDINATE_RELATIONSHIPS, bacnet_node_relationship_names }, + { PROP_TRANSITION, bacnet_lighting_transition_names }, + { PROP_IN_PROGRESS, bacnet_lighting_in_progress_names }, + { PROP_LOGGING_TYPE, bactext_logging_type_names }, + { PROP_MODE, bactext_life_safety_mode_names }, + { PROP_ACCEPTED_MODES, bactext_life_safety_mode_names }, + { PROP_OPERATION_EXPECTED, bactext_life_safety_operation_names }, + { PROP_PROGRAM_CHANGE, bactext_program_request_names }, + { PROP_PROGRAM_STATE, bactext_program_state_names }, + { PROP_REASON_FOR_HALT, bactext_program_error_names }, + { PROP_NETWORK_NUMBER_QUALITY, bactext_network_number_quality_names }, + { PROP_NETWORK_TYPE, bactext_network_port_type_names }, + { PROP_PROTOCOL_LEVEL, bactext_protocol_level_names }, + { PROP_EVENT_TYPE, bacnet_event_type_names }, + { PROP_NOTIFY_TYPE, bacnet_notify_type_names }, + { PROP_TIMER_STATE, bactext_timer_state_names }, + { PROP_LAST_STATE_CHANGE, bactext_timer_transition_names }, + { PROP_ACTION, bactext_action_names }, + { PROP_FILE_ACCESS_METHOD, bactext_file_access_method_names }, + { PROP_LOCK_STATUS, bactext_lock_status_names }, + { PROP_DOOR_ALARM_STATE, bactext_door_alarm_state_names }, + { PROP_DOOR_STATUS, bactext_door_status_names }, + { PROP_SECURED_STATUS, bactext_door_secured_status_names }, + { PROP_ACCESS_EVENT, bactext_access_event_names }, + { PROP_LAST_ACCESS_EVENT, bactext_access_event_names }, + { PROP_AUTHENTICATION_STATUS, bactext_authentication_status_names }, + { PROP_AUTHORIZATION_MODE, bactext_authorization_mode_names }, + { PROP_CREDENTIAL_STATUS, bacnet_binary_present_value_names }, + { PROP_CREDENTIAL_DISABLE, bactext_access_credential_disable_names }, + { PROP_REASON_FOR_DISABLE, bactext_access_credential_disable_reason_names }, + { PROP_USER_TYPE, bactext_access_user_type_names }, + { PROP_OCCUPANCY_STATE, bactext_access_zone_occupancy_state_names }, + { PROP_SILENCED, bactext_silenced_state_names }, + { PROP_WRITE_STATUS, bactext_write_status_names }, + { PROP_BACNET_IP_MODE, bactext_ip_mode_names }, + { PROP_BACNET_IPV6_MODE, bactext_ip_mode_names }, + { PROP_DEFAULT_SUBORDINATE_RELATIONSHIP, bacnet_node_relationship_names }, + { PROP_MAINTENANCE_REQUIRED, bactext_maintenance_names }, + { PROP_ESCALATOR_MODE, bactext_escalator_mode_names }, + { PROP_OPERATION_DIRECTION, bactext_escalator_operation_direction_names }, + { PROP_BACKUP_AND_RESTORE_STATE, bactext_backup_state_names }, + { PROP_BASE_DEVICE_SECURITY_POLICY, bactext_security_level_names }, + { PROP_GROUP_MODE, bactext_lift_group_mode_names }, + { PROP_CAR_MODE, bactext_lift_car_mode_names }, + { PROP_CAR_DRIVE_STATUS, bactext_lift_car_drive_status_names }, + { PROP_CAR_DOOR_COMMAND, bactext_lift_car_door_command_names }, + { PROP_CAR_ASSIGNED_DIRECTION, bactext_lift_car_direction_names }, + { PROP_CAR_MOVING_DIRECTION, bactext_lift_car_direction_names }, + { PROP_AUDIT_LEVEL, bactext_audit_level_names }, + { PROP_SC_HUB_CONNECTOR_STATE, bactext_sc_hub_connector_state_names }, + /* handle different enumerations for the same property */ + { PROP_PRESENT_VALUE, NULL /* handled in function */ }, + { PROP_RELINQUISH_DEFAULT, NULL /* handled in function */ }, + { PROP_TRACKING_VALUE, NULL /* handled in function */ }, + { PROP_FEEDBACK_VALUE, NULL /* handled in function */ }, + { PROP_FAULT_SIGNALS, NULL /* handled in function */ }, + { 0, NULL } +}; + +/** + * @brief Get the name of an enumerated object property returning + * a default string if not found + * @param object_type - object type identifier + * @param property - object property identifier + * @param index - index within the property enumeration + * @param default_string - string to return if no name is found + * @return name of the property or default_string if not found + */ +const char *bactext_object_property_name( + BACNET_OBJECT_TYPE object_type, + BACNET_PROPERTY_ID object_property, + uint32_t index, + const char *default_string) +{ + const char *name = NULL; + INDTEXT_PROPERTY_DATA *list; + + list = bactext_object_property_data; + while (list->data_list != NULL) { + if (list->index == object_property) { + name = indtext_by_index_default( + list->data_list, index, default_string); + break; + } + list++; + } + if (!name) { + switch (object_property) { + case PROP_PRESENT_VALUE: + case PROP_RELINQUISH_DEFAULT: + switch (object_type) { + case OBJECT_BINARY_INPUT: + case OBJECT_BINARY_OUTPUT: + case OBJECT_BINARY_VALUE: + name = indtext_by_index_default( + bacnet_binary_present_value_names, index, + default_string); + break; + case OBJECT_BINARY_LIGHTING_OUTPUT: + name = indtext_by_index_default( + bacnet_binary_lighting_pv_names, index, + default_string); + break; + case OBJECT_ACCESS_DOOR: + name = indtext_by_index_default( + bactext_door_value_names, index, default_string); + break; + default: + break; + } + break; + case PROP_TRACKING_VALUE: + switch (object_type) { + case OBJECT_LIFE_SAFETY_POINT: + case OBJECT_LIFE_SAFETY_ZONE: + name = indtext_by_index_default( + bactext_life_safety_state_names, index, + default_string); + break; + default: + break; + } + break; + case PROP_FEEDBACK_VALUE: + switch (object_type) { + case OBJECT_BINARY_LIGHTING_OUTPUT: + name = indtext_by_index_default( + bacnet_binary_lighting_pv_names, index, + default_string); + break; + case OBJECT_BINARY_OUTPUT: + name = indtext_by_index_default( + bacnet_binary_present_value_names, index, + default_string); + break; + default: + break; + } + break; + case PROP_FAULT_SIGNALS: + switch (object_type) { + case OBJECT_ESCALATOR: + name = indtext_by_index_default( + bactext_escalator_fault_names, index, + default_string); + break; + case OBJECT_LIFT: + name = indtext_by_index_default( + bactext_lift_fault_names, index, default_string); + break; + default: + break; + } + default: + break; + } + } + if (!name) { + name = default_string; + } + + return name; +} + /** * @brief For a given enumerated object property string, * find the enumeration value @@ -3028,145 +4167,91 @@ bool bactext_object_property_strtoul( uint32_t *found_index) { bool status = false; + INDTEXT_PROPERTY_DATA *list; - switch (object_property) { - case PROP_PROPERTY_LIST: + list = bactext_object_property_data; + while (list->data_list != NULL) { + if (list->index == object_property) { status = bactext_string_to_uint32_index( - bacnet_property_names, search_name, found_index); - break; - case PROP_OBJECT_TYPE: - status = bactext_string_to_uint32_index( - bacnet_object_type_names, search_name, found_index); - break; - case PROP_EVENT_STATE: - status = bactext_string_to_uint32_index( - bacnet_event_state_names, search_name, found_index); - break; - case PROP_UNITS: - case PROP_CONTROLLED_VARIABLE_UNITS: - case PROP_DERIVATIVE_CONSTANT_UNITS: - case PROP_INTEGRAL_CONSTANT_UNITS: - case PROP_PROPORTIONAL_CONSTANT_UNITS: - case PROP_OUTPUT_UNITS: - case PROP_CAR_LOAD_UNITS: - status = bactext_string_to_uint32_index( - bacnet_engineering_unit_names, search_name, found_index); - break; - case PROP_POLARITY: - status = bactext_string_to_uint32_index( - bacnet_binary_polarity_names, search_name, found_index); - break; - case PROP_PRESENT_VALUE: - case PROP_RELINQUISH_DEFAULT: - switch (object_type) { - case OBJECT_BINARY_INPUT: - case OBJECT_BINARY_OUTPUT: - case OBJECT_BINARY_VALUE: - status = bactext_string_to_uint32_index( - bacnet_binary_present_value_names, search_name, - found_index); - break; - case OBJECT_BINARY_LIGHTING_OUTPUT: - status = bactext_string_to_uint32_index( - bacnet_binary_lighting_pv_names, search_name, - found_index); - break; - default: - break; - } - break; - case PROP_RELIABILITY: - status = bactext_string_to_uint32_index( - bacnet_reliability_names, search_name, found_index); - break; - case PROP_SYSTEM_STATUS: - status = bactext_string_to_uint32_index( - bacnet_device_status_names, search_name, found_index); - break; - case PROP_SEGMENTATION_SUPPORTED: - status = bactext_string_to_uint32_index( - bacnet_segmentation_names, search_name, found_index); - break; - case PROP_NODE_TYPE: - status = bactext_string_to_uint32_index( - bacnet_node_type_names, search_name, found_index); - break; - case PROP_TRANSITION: - status = bactext_string_to_uint32_index( - bacnet_lighting_transition_names, search_name, found_index); - break; - case PROP_IN_PROGRESS: - status = bactext_string_to_uint32_index( - bacnet_lighting_in_progress_names, search_name, found_index); - break; - case PROP_LOGGING_TYPE: - status = bactext_string_to_uint32_index( - bactext_logging_type_names, search_name, found_index); - break; - case PROP_MODE: - case PROP_ACCEPTED_MODES: - status = bactext_string_to_uint32_index( - bactext_life_safety_mode_names, search_name, found_index); - break; - case PROP_OPERATION_EXPECTED: - status = bactext_string_to_uint32_index( - bactext_life_safety_operation_names, search_name, found_index); - break; - case PROP_TRACKING_VALUE: - switch (object_type) { - case OBJECT_LIFE_SAFETY_POINT: - case OBJECT_LIFE_SAFETY_ZONE: - status = bactext_string_to_uint32_index( - bactext_life_safety_state_names, search_name, - found_index); - break; - default: - break; - } - break; - case PROP_PROGRAM_CHANGE: - status = bactext_string_to_uint32_index( - bactext_program_request_names, search_name, found_index); - break; - case PROP_PROGRAM_STATE: - status = bactext_string_to_uint32_index( - bactext_program_state_names, search_name, found_index); - break; - case PROP_REASON_FOR_HALT: - status = bactext_string_to_uint32_index( - bactext_program_error_names, search_name, found_index); - break; - case PROP_NETWORK_NUMBER_QUALITY: - status = bactext_string_to_uint32_index( - bactext_network_number_quality_names, search_name, found_index); - break; - case PROP_NETWORK_TYPE: - status = bactext_string_to_uint32_index( - bactext_network_port_type_names, search_name, found_index); - break; - case PROP_PROTOCOL_LEVEL: - status = bactext_string_to_uint32_index( - bactext_protocol_level_names, search_name, found_index); - break; - case PROP_EVENT_TYPE: - status = bactext_string_to_uint32_index( - bacnet_event_type_names, search_name, found_index); - break; - case PROP_NOTIFY_TYPE: - status = bactext_string_to_uint32_index( - bacnet_notify_type_names, search_name, found_index); - break; - case PROP_TIMER_STATE: - status = bactext_string_to_uint32_index( - bactext_timer_state_names, search_name, found_index); - break; - case PROP_LAST_STATE_CHANGE: - status = bactext_string_to_uint32_index( - bactext_timer_transition_names, search_name, found_index); - break; - default: - status = bacnet_string_to_uint32(search_name, found_index); + list->data_list, search_name, found_index); break; + } + list++; + } + if (!status) { + switch (object_property) { + case PROP_PRESENT_VALUE: + case PROP_RELINQUISH_DEFAULT: + switch (object_type) { + case OBJECT_BINARY_INPUT: + case OBJECT_BINARY_OUTPUT: + case OBJECT_BINARY_VALUE: + status = bactext_string_to_uint32_index( + bacnet_binary_present_value_names, search_name, + found_index); + break; + case OBJECT_BINARY_LIGHTING_OUTPUT: + status = bactext_string_to_uint32_index( + bacnet_binary_lighting_pv_names, search_name, + found_index); + break; + case OBJECT_ACCESS_DOOR: + status = bactext_string_to_uint32_index( + bactext_door_value_names, search_name, found_index); + break; + default: + break; + } + break; + case PROP_TRACKING_VALUE: + switch (object_type) { + case OBJECT_LIFE_SAFETY_POINT: + case OBJECT_LIFE_SAFETY_ZONE: + status = bactext_string_to_uint32_index( + bactext_life_safety_state_names, search_name, + found_index); + break; + default: + break; + } + break; + case PROP_FEEDBACK_VALUE: + switch (object_type) { + case OBJECT_BINARY_LIGHTING_OUTPUT: + status = bactext_string_to_uint32_index( + bacnet_binary_lighting_pv_names, search_name, + found_index); + break; + case OBJECT_BINARY_OUTPUT: + status = bactext_string_to_uint32_index( + bacnet_binary_present_value_names, search_name, + found_index); + break; + default: + break; + } + break; + case PROP_FAULT_SIGNALS: + switch (object_type) { + case OBJECT_ESCALATOR: + status = bactext_string_to_uint32_index( + bactext_escalator_fault_names, search_name, + found_index); + break; + case OBJECT_LIFT: + status = bactext_string_to_uint32_index( + bactext_lift_fault_names, search_name, found_index); + break; + default: + break; + } + default: + break; + } + } + if (!status) { + /* not found - convert the text to a number */ + status = bacnet_string_to_uint32(search_name, found_index); } return status; diff --git a/src/bacnet/bactext.h b/src/bacnet/bactext.h index 2f5851bf..81de0408 100644 --- a/src/bacnet/bactext.h +++ b/src/bacnet/bactext.h @@ -30,40 +30,60 @@ BACNET_STACK_EXPORT const char *bactext_confirmed_service_name_default( uint32_t index, const char *default_string); BACNET_STACK_EXPORT +bool bactext_confirmed_service_strtol( + const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT const char *bactext_unconfirmed_service_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_unconfirmed_service_name_default( uint32_t index, const char *default_string); BACNET_STACK_EXPORT +bool bactext_unconfirmed_service_strtol( + const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT const char *bactext_application_tag_name(uint32_t index); BACNET_STACK_EXPORT +const char *bactext_application_tag_name_default( + uint32_t index, const char *default_string); +BACNET_STACK_EXPORT bool bactext_application_tag_index( const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_object_type_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_object_type_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_object_type_index(const char *search_name, uint32_t *found_index); +BACNET_STACK_EXPORT +bool bactext_object_type_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_object_type_name_capitalized(uint32_t index); BACNET_STACK_EXPORT const char *bactext_object_type_name_capitalized_default( uint32_t index, const char *default_string); BACNET_STACK_EXPORT -bool bactext_object_type_index(const char *search_name, uint32_t *found_index); -BACNET_STACK_EXPORT -bool bactext_object_type_strtol(const char *search_name, uint32_t *found_index); +bool bactext_object_type_name_capitalized_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT bool bactext_property_name_proprietary(uint32_t index); BACNET_STACK_EXPORT const char *bactext_property_name(uint32_t index); BACNET_STACK_EXPORT +uint32_t bactext_property_id(const char *name); +BACNET_STACK_EXPORT const char * bactext_property_name_default(uint32_t index, const char *default_string); BACNET_STACK_EXPORT bool bactext_property_index(const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT bool bactext_property_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT bool bactext_engineering_unit_name_proprietary(uint32_t index); BACNET_STACK_EXPORT @@ -74,90 +94,150 @@ const char *bactext_engineering_unit_name_default( BACNET_STACK_EXPORT bool bactext_engineering_unit_index( const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_reject_reason_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_reject_reason_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_reject_reason_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_abort_reason_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_abort_reason_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_abort_reason_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_error_class_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_error_class_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_error_class_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_error_code_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_error_code_name_default(uint32_t index, const char *default_string); BACNET_STACK_EXPORT -uint32_t bactext_property_id(const char *name); +bool bactext_error_code_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_month_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_month_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_month_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_week_of_month_name(uint32_t index); BACNET_STACK_EXPORT const char * bactext_week_of_month_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_week_of_month_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_day_of_week_name(uint32_t index); +BACNET_STACK_EXPORT +const char * +bactext_day_of_week_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_day_of_week_strtol(const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_days_of_week_name(uint32_t index); +BACNET_STACK_EXPORT +const char * +bactext_days_of_week_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_days_of_week_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_notify_type_name(uint32_t index); BACNET_STACK_EXPORT +const char * +bactext_notify_type_name_default(uint32_t index, const char *default_string); +BACNET_STACK_EXPORT bool bactext_notify_type_index(const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT bool bactext_notify_type_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_event_state_name(uint32_t index); BACNET_STACK_EXPORT bool bactext_event_state_index(const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT bool bactext_event_state_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_event_type_name(uint32_t index); BACNET_STACK_EXPORT bool bactext_event_type_index(const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT bool bactext_event_type_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_binary_present_value_name(uint32_t index); BACNET_STACK_EXPORT -const char *bactext_binary_polarity_name(uint32_t index); -BACNET_STACK_EXPORT bool bactext_binary_present_value_index( const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_binary_polarity_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_reliability_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_device_status_name(uint32_t index); + BACNET_STACK_EXPORT const char *bactext_segmentation_name(uint32_t index); BACNET_STACK_EXPORT bool bactext_segmentation_index(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_node_type_name(uint32_t index); + BACNET_STACK_EXPORT -const char *bactext_character_string_encoding_name(uint32_t index); +const char *bactext_node_relationship_name(uint32_t index); BACNET_STACK_EXPORT -const char *bactext_event_transition_name(uint32_t index); +bool bactext_node_relationship_name_proprietary(uint32_t index); BACNET_STACK_EXPORT -bool bactext_event_transition_index( +bool bactext_node_relationship_name_reserved(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_node_relationship_strtol( const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT -const char *bactext_days_of_week_name(uint32_t index); +const char *bactext_character_string_encoding_name(uint32_t index); BACNET_STACK_EXPORT -bool bactext_days_of_week_index(const char *search_name, uint32_t *found_index); +bool bactext_character_string_encoding_strtol( + const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_event_transition_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_event_transition_name_default( + uint32_t index, const char *default_string); +BACNET_STACK_EXPORT +bool bactext_event_transition_strtol( + const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_network_layer_msg_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_network_layer_msg_strtol( + const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_life_safety_mode_name(uint32_t index); @@ -170,42 +250,49 @@ const char *bactext_silenced_state_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_device_communications_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_device_communications_strtol( + const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_lighting_operation_name(uint32_t index); - BACNET_STACK_EXPORT bool bactext_lighting_operation_strtol( const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_binary_lighting_pv_name(uint32_t index); - BACNET_STACK_EXPORT bool bactext_binary_lighting_pv_names_strtol( const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_lighting_in_progress(uint32_t index); - BACNET_STACK_EXPORT const char *bactext_lighting_transition(uint32_t index); BACNET_STACK_EXPORT const char *bactext_color_operation_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_color_operation_strtol( + const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_shed_state_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_shed_level_type_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_shed_level_type_strtol( + const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_log_datum_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_log_datum_strtol(const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_restart_reason_name(uint32_t index); - BACNET_STACK_EXPORT const char *bactext_network_port_type_name(uint32_t index); BACNET_STACK_EXPORT @@ -217,18 +304,44 @@ const char *bactext_network_port_command_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_authentication_decision_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_authentication_decision_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_authorization_posture_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_authorization_posture_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_fault_type_name(uint32_t index); BACNET_STACK_EXPORT -const char *bacnet_priority_filter_name(uint32_t index); +bool bactext_fault_type_strtol(const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT -const char *bactext_success_filter_name(uint32_t index); +const char *bactext_priority_filter_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_priority_filter_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_result_flags_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_result_flags_strtol( + const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_success_filter_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_success_filter_strtol( + const char *search_name, uint32_t *found_index); + BACNET_STACK_EXPORT const char *bactext_logging_type_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_logging_type_strtol( + const char *search_name, uint32_t *found_index); BACNET_STACK_EXPORT const char *bactext_program_request_name(uint32_t index); @@ -244,14 +357,108 @@ const char *bactext_timer_state_name(uint32_t index); BACNET_STACK_EXPORT const char *bactext_boolean_value_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_action_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_file_access_method_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lock_status_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_door_alarm_state_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_door_status_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_door_secured_status_name(uint32_t index); + +BACNET_STACK_EXPORT +const char *bactext_access_event_name(uint32_t index); +BACNET_STACK_EXPORT +const char * +bactext_access_event_name_default(uint32_t index, const char *default_string); + +BACNET_STACK_EXPORT +const char *bactext_authentication_status_name(uint32_t index); + +BACNET_STACK_EXPORT +const char *bactext_authorization_mode_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_authorization_mode_strtol( + const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_access_credential_disable_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_access_credential_disable_reason_name(uint32_t index); + +BACNET_STACK_EXPORT +const char *bactext_access_user_type_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_access_user_type_strtol( + const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_access_zone_occupancy_state_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_write_status_name(uint32_t index); + +BACNET_STACK_EXPORT +const char *bactext_ip_mode_name(uint32_t index); +BACNET_STACK_EXPORT +bool bactext_ip_mode_strtol(const char *search_name, uint32_t *found_index); + +BACNET_STACK_EXPORT +const char *bactext_door_value_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_maintenance_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_escalator_fault_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_escalator_mode_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_escalator_operation_direction_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_backup_state_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_security_level_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lift_car_direction_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lift_car_door_command_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lift_car_drive_status_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lift_car_mode_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lift_fault_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_lift_group_mode_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_audit_level_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_audit_operation_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_sc_hub_connector_state_name(uint32_t index); +BACNET_STACK_EXPORT +const char *bactext_sc_connection_state_name(uint32_t index); BACNET_STACK_EXPORT bool bactext_property_states_strtoul( BACNET_PROPERTY_STATES object_property, const char *search_name, uint32_t *found_index); +BACNET_STACK_EXPORT +const char *bactext_property_states_name( + BACNET_PROPERTY_STATES property_state, + uint32_t index, + const char *default_string); BACNET_STACK_EXPORT +const char *bactext_object_property_name( + BACNET_OBJECT_TYPE object_type, + BACNET_PROPERTY_ID object_property, + uint32_t index, + const char *default_string); +BACNET_STACK_EXPORT bool bactext_object_property_strtoul( BACNET_OBJECT_TYPE object_type, BACNET_PROPERTY_ID object_property, diff --git a/src/bacnet/basic/object/bi.c b/src/bacnet/basic/object/bi.c index 6557f254..deef5595 100644 --- a/src/bacnet/basic/object/bi.c +++ b/src/bacnet/basic/object/bi.c @@ -531,7 +531,7 @@ bool Binary_Input_Present_Value_Set( pObject = Binary_Input_Object(object_instance); if (pObject) { - if (value <= MAX_BINARY_PV) { + if (value < BINARY_PV_MAX) { /* de-polarize */ if (Binary_Polarity(pObject->Polarity) != POLARITY_NORMAL) { if (value == BINARY_INACTIVE) { @@ -571,7 +571,7 @@ static bool Binary_Input_Present_Value_Write( pObject = Binary_Input_Object(object_instance); if (pObject) { - if (value <= MAX_BINARY_PV) { + if (value < BINARY_PV_MAX) { if (pObject->Write_Enabled) { old_value = Binary_Present_Value(pObject->Present_Value); Binary_Input_Present_Value_COV_Detect(pObject, value); @@ -1193,7 +1193,7 @@ bool Binary_Input_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data) status = write_property_type_valid( wp_data, &value, BACNET_APPLICATION_TAG_ENUMERATED); if (status) { - if (value.type.Enumerated <= MAX_BINARY_PV) { + if (value.type.Enumerated < BINARY_PV_MAX) { Binary_Input_Alarm_Value_Set( wp_data->object_instance, (BACNET_BINARY_PV)value.type.Enumerated); diff --git a/src/bacnet/basic/object/bo.c b/src/bacnet/basic/object/bo.c index f6ed6d20..23657fe9 100644 --- a/src/bacnet/basic/object/bo.c +++ b/src/bacnet/basic/object/bo.c @@ -325,7 +325,7 @@ bool Binary_Output_Present_Value_Set( (priority != 6 /* reserved */)) { priority--; old_value = Object_Present_Value(pObject); - if (binary_value <= MAX_BINARY_PV) { + if (binary_value < BINARY_PV_MAX) { BIT_SET(pObject->Priority_Active_Bits, priority); if (binary_value == BINARY_ACTIVE) { BIT_SET(pObject->Priority_Array, priority); @@ -448,7 +448,7 @@ static bool Binary_Output_Present_Value_Write( pObject = Keylist_Data(Object_List, object_instance); if (pObject) { if ((priority >= 1) && (priority <= BACNET_MAX_PRIORITY) && - (value <= MAX_BINARY_PV)) { + (value < BINARY_PV_MAX)) { if (priority != 6) { old_value = Object_Present_Value(pObject); Binary_Output_Present_Value_Set( diff --git a/src/bacnet/basic/object/bv.c b/src/bacnet/basic/object/bv.c index 7b65afab..4b120824 100644 --- a/src/bacnet/basic/object/bv.c +++ b/src/bacnet/basic/object/bv.c @@ -490,7 +490,7 @@ bool Binary_Value_Present_Value_Set( pObject = Binary_Value_Object(object_instance); if (pObject) { - if (value <= MAX_BINARY_PV) { + if (value < BINARY_PV_MAX) { Binary_Value_Present_Value_COV_Detect(pObject, value); pObject->Present_Value = Binary_Present_Value_Boolean(value); status = true; @@ -522,7 +522,7 @@ static bool Binary_Value_Present_Value_Write( pObject = Binary_Value_Object(object_instance); if (pObject) { - if (value <= MAX_BINARY_PV) { + if (value < BINARY_PV_MAX) { if (pObject->Write_Enabled) { old_value = Binary_Present_Value(pObject->Present_Value); Binary_Value_Present_Value_COV_Detect(pObject, value); @@ -1096,7 +1096,7 @@ bool Binary_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data) status = write_property_type_valid( wp_data, &value, BACNET_APPLICATION_TAG_ENUMERATED); if (status) { - if (value.type.Enumerated <= MAX_BINARY_PV) { + if (value.type.Enumerated < BINARY_PV_MAX) { Binary_Value_Alarm_Value_Set( wp_data->object_instance, (BACNET_BINARY_PV)value.type.Enumerated); diff --git a/src/bacnet/credential_authentication_factor.c b/src/bacnet/credential_authentication_factor.c index ab8e6993..686de618 100644 --- a/src/bacnet/credential_authentication_factor.c +++ b/src/bacnet/credential_authentication_factor.c @@ -66,7 +66,7 @@ int bacapp_decode_credential_authentication_factor( len = decode_context_enumerated(&apdu[apdu_len], 0, &disable); if (len < 0) { return -1; - } else if (disable < ACCESS_AUTHENTICATION_FACTOR_DISABLE_MAX) { + } else if (disable < UINT16_MAX) { apdu_len += len; factor->disable = (BACNET_ACCESS_AUTHENTICATION_FACTOR_DISABLE)disable; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index b252aaac..99537e07 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -96,6 +96,7 @@ list(APPEND testdirs bacnet/bacpropstates bacnet/bacreal bacnet/bacstr + bacnet/bactext bacnet/bactimevalue bacnet/channel_value bacnet/cov diff --git a/test/bacnet/bactext/CMakeLists.txt b/test/bacnet/bactext/CMakeLists.txt new file mode 100644 index 00000000..ccb962b6 --- /dev/null +++ b/test/bacnet/bactext/CMakeLists.txt @@ -0,0 +1,50 @@ +# SPDX-License-Identifier: MIT + +cmake_minimum_required(VERSION 3.10 FATAL_ERROR) + +get_filename_component(basename ${CMAKE_CURRENT_SOURCE_DIR} NAME) +project(test_${basename} + VERSION 1.0.0 + LANGUAGES C) + + +string(REGEX REPLACE + "/test/bacnet/[a-zA-Z_/-]*$" + "/src" + SRC_DIR + ${CMAKE_CURRENT_SOURCE_DIR}) +string(REGEX REPLACE + "/test/bacnet/[a-zA-Z_/-]*$" + "/test" + TST_DIR + ${CMAKE_CURRENT_SOURCE_DIR}) +set(ZTST_DIR "${TST_DIR}/ztest/src") + +add_compile_definitions( + BIG_ENDIAN=0 + CONFIG_ZTEST=1 + BACNET_PROPERTY_LISTS=1 + ) + +include_directories( + ${SRC_DIR} + ${TST_DIR}/ztest/include + ) + +add_executable(${PROJECT_NAME} + # File(s) under test + ${SRC_DIR}/bacnet/bactext.c + # Support files and stubs (pathname alphabetical) + ${SRC_DIR}/bacnet/bacdcode.c + ${SRC_DIR}/bacnet/bacint.c + ${SRC_DIR}/bacnet/bacreal.c + ${SRC_DIR}/bacnet/bacstr.c + ${SRC_DIR}/bacnet/indtext.c + ${SRC_DIR}/bacnet/basic/sys/bigend.c + ${SRC_DIR}/bacnet/property.c + ${SRC_DIR}/bacnet/proplist.c + # Test and test library files + ./src/main.c + ${ZTST_DIR}/ztest_mock.c + ${ZTST_DIR}/ztest.c + ) diff --git a/test/bacnet/bactext/src/main.c b/test/bacnet/bactext/src/main.c new file mode 100644 index 00000000..9f3f5d34 --- /dev/null +++ b/test/bacnet/bactext/src/main.c @@ -0,0 +1,1347 @@ +/** + * @file + * @brief test BACnet Text utility API + * @author Steve Karg + * @date 2026 + * @copyright SPDX-License-Identifier: MIT + */ +#include +#include +#include + +/** + * @addtogroup bacnet_tests + * @{ + */ + +/** + * @brief Test + */ +#if defined(CONFIG_ZTEST_NEW_API) +ZTEST(bactext_tests, testBacText) +#else +static void testBacText(void) +#endif +{ + uint32_t i, j, k; + const char *pString; + char ascii_number[64] = ""; + uint32_t index, found_index; + bool status; + unsigned count; + BACNET_PROPERTY_ID property; + + /* BACnet_Confirmed_Service_Choice */ + for (i = 0; i < MAX_BACNET_CONFIRMED_SERVICE; i++) { + pString = bactext_confirmed_service_name(i); + if (pString) { + status = bactext_confirmed_service_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + + /* BACnet_Unconfirmed_Service_Choice */ + for (i = 0; i < MAX_BACNET_UNCONFIRMED_SERVICE; i++) { + pString = bactext_unconfirmed_service_name(i); + if (pString) { + status = bactext_unconfirmed_service_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + + /* BACNET_APPLICATION_TAG */ + for (i = 0; i < BACNET_APPLICATION_TAG_EXTENDED_MAX; i++) { + pString = bactext_application_tag_name(i); + if (pString) { + if (i == MAX_BACNET_APPLICATION_TAG) { + /* skip no-value */ + continue; + } + status = bactext_application_tag_index(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACNET_CHARACTER_STRING_ENCODING */ + for (i = 0; i < MAX_CHARACTER_STRING_ENCODING; i++) { + pString = bactext_character_string_encoding_name(i); + if (pString) { + status = bactext_character_string_encoding_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetObjectType */ + for (i = 0; i < BACNET_OBJECT_TYPE_RESERVED_MIN; i++) { + pString = bactext_object_type_name(i); + if (pString) { + status = bactext_object_type_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + status = bactext_object_type_index(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + status = bactext_object_property_strtoul( + (BACNET_OBJECT_TYPE)i, PROP_OBJECT_TYPE, pString, &found_index); + zassert_true(status, "i=%u", i); + zassert_equal( + index, found_index, "index=%u found_index=%u", index, + found_index); + } + pString = bactext_object_type_name_default(i, NULL); + zassert_not_null(pString, "i=%u", i); + pString = bactext_object_type_name_capitalized_default(i, NULL); + zassert_not_null(pString, "i=%u", i); + pString = bactext_object_type_name_capitalized(i); + zassert_not_null(pString, "i=%u", i); + if (pString) { + status = + bactext_object_type_name_capitalized_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetObjectType and BACnetPropertyIdentifier */ + for (i = 0; i < OBJECT_PROPRIETARY_MIN; i++) { + count = property_list_special_count((BACNET_OBJECT_TYPE)i, PROP_ALL); + /* BACnetPropertyIdentifier for each object type */ + for (j = 0; j < count; j++) { + property = property_list_special_property( + (BACNET_OBJECT_TYPE)i, PROP_ALL, j); + pString = bactext_property_name(property); + if (pString) { + status = bactext_property_index(pString, &index); + zassert_true( + status, "object=%s(%u) property=%s(%u)", + bactext_object_type_name(i), i, pString, property); + zassert_equal( + index, property, "index=%u property=%u", index, property); + /* BACnetPropertyIdentifier enumeration values for specific + * object type and property */ + for (k = 0; k < UINT16_MAX; k++) { + pString = bactext_object_property_name( + (BACNET_OBJECT_TYPE)i, property, k, NULL); + if (!pString) { + break; + } + status = bactext_object_property_strtoul( + i, property, pString, &found_index); + zassert_true( + status, "%s i=%u property=%u k=%u", pString, i, + property, k); + zassert_equal( + k, found_index, "%s index=%u found_index=%u", pString, + k, found_index); + } + } + pString = bactext_property_name_default(property, NULL); + zassert_not_null( + pString, "object=%s(%u) property=%s(%u)", + bactext_object_type_name(i), i, pString, property); + index = bactext_property_id(pString); + zassert_equal( + index, property, "index=%u property=%u", index, property); + status = bactext_property_strtol(pString, &found_index); + zassert_true(status, "i=%u", i); + zassert_equal( + index, found_index, "index=%u found_index=%u", index, + found_index); + } + } + /* non-existant property of the device object */ + pString = bactext_object_property_name( + OBJECT_DEVICE, PROP_FAULT_SIGNALS, 0, NULL); + zassert_false(pString, NULL); + pString = bactext_property_name(PROP_PROPRIETARY_RANGE_MIN); + zassert_not_null(pString, NULL); + + /* BACnetPropertyStates */ + for (k = 0; k < PROP_STATE_PROPRIETARY_MIN; k++) { + snprintf(ascii_number, sizeof(ascii_number), "%u", k); + status = bactext_property_states_strtoul( + (BACNET_PROPERTY_STATES)k, ascii_number, &index); + zassert_true(status, "k=%u", k); + zassert_equal(index, k, "index=%u k=%u", index, k); + /* BACnetPropertyStates enumeration values */ + for (i = 0; i < 255; i++) { + pString = bactext_property_states_name( + (BACNET_PROPERTY_STATES)k, i, NULL); + if (!pString) { + break; + } + status = bactext_property_states_strtoul( + (BACNET_PROPERTY_STATES)k, pString, &found_index); + zassert_true(status, "%s k=%u i=%u", pString, k, i); + zassert_equal( + i, found_index, "state=%u[%u]=%s ==>[%u]", k, i, pString, + found_index); + } + } + /* BACnetEngineeringUnits */ + for (i = 0; i < UNITS_RESERVED_RANGE_MAX; i++) { + pString = bactext_engineering_unit_name(i); + if (pString) { + status = bactext_engineering_unit_index(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + pString = bactext_engineering_unit_name_default(i, NULL); + zassert_not_null(pString, "i=%u", i); + } + pString = bactext_engineering_unit_name(UNITS_PROPRIETARY_RANGE_MIN); + zassert_not_null(pString, NULL); + pString = bactext_engineering_unit_name(UNITS_PROPRIETARY_RANGE_MAX); + zassert_not_null(pString, NULL); + pString = bactext_engineering_unit_name(UNITS_PROPRIETARY_RANGE_MIN2); + zassert_not_null(pString, NULL); + pString = bactext_engineering_unit_name(UNITS_PROPRIETARY_RANGE_MAX2); + zassert_not_null(pString, NULL); + pString = bactext_engineering_unit_name(UNITS_PROPRIETARY_RANGE_MAX2 + 1); + zassert_not_null(pString, NULL); + /* BACNET_REJECT_REASON */ + for (i = 0; i < MAX_BACNET_REJECT_REASON; i++) { + pString = bactext_reject_reason_name(i); + if (pString) { + status = bactext_reject_reason_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + pString = bactext_reject_reason_name_default(i, NULL); + zassert_not_null(pString, "i=%u", i); + } + /* BACNET_ABORT_REASON */ + for (i = 0; i < MAX_BACNET_ABORT_REASON; i++) { + pString = bactext_abort_reason_name(i); + if (pString) { + status = bactext_abort_reason_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + pString = bactext_abort_reason_name_default(i, NULL); + zassert_not_null(pString, "i=%u", i); + } + /* BACNET_ERROR_CLASS */ + for (i = 0; i < MAX_BACNET_ERROR_CLASS; i++) { + pString = bactext_error_class_name(i); + if (pString) { + status = bactext_error_class_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + pString = bactext_error_class_name_default(i, NULL); + zassert_not_null(pString, "i=%u", i); + } + /* BACNET_ERROR_CODE */ + for (i = 0; i < ERROR_CODE_RESERVED_MAX; i++) { + pString = bactext_error_code_name_default(i, NULL); + if (pString) { + pString = bactext_error_code_name(i); + status = bactext_error_code_strtol(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u %s", index, i, pString); + } else { + printf("No error code name for %u\n", i); + } + } + /* Month value (1-12) */ + for (i = 0; i <= 255; i++) { + pString = bactext_month_name_default(i, NULL); + if (pString) { + pString = bactext_month_name(i); + status = bactext_month_strtol(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u %s", index, i, pString); + } + } + /* Week of month value (1-6) */ + for (i = 0; i <= 255; i++) { + pString = bactext_week_of_month_name_default(i, NULL); + if (pString) { + pString = bactext_week_of_month_name(i); + status = bactext_week_of_month_strtol(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u %s", index, i, pString); + } + } + /* Day of week value (1-7) */ + for (i = 0; i <= 255; i++) { + pString = bactext_day_of_week_name_default(i, NULL); + if (pString) { + pString = bactext_day_of_week_name(i); + status = bactext_day_of_week_strtol(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u %s", index, i, pString); + } + } + /* BACnetDaysOfWeek */ + for (i = 0; i < 8; i++) { + pString = bactext_days_of_week_name_default(i, NULL); + if (pString) { + pString = bactext_days_of_week_name(i); + status = bactext_days_of_week_strtol(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u %s", index, i, pString); + } + } + /* BACnetNotifyType */ + for (i = 0; i < NOTIFY_MAX; i++) { + pString = bactext_notify_type_name_default(i, NULL); + if (pString) { + pString = bactext_notify_type_name(i); + status = bactext_notify_type_index(pString, &found_index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal( + i, found_index, "i=%u found_index=%u", i, found_index); + status = bactext_notify_type_strtol(pString, &found_index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal( + i, found_index, "i=%u found_index=%u", i, found_index); + } + } + /* BACnetEventTransitionBits */ + for (i = 0; i < MAX_BACNET_EVENT_TRANSITION; i++) { + pString = bactext_event_transition_name(i); + if (pString) { + status = bactext_event_transition_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetEventState */ + for (i = 0; i < EVENT_STATE_MAX; i++) { + pString = bactext_event_state_name(i); + zassert_not_null(pString, "i=%u", i); + status = bactext_event_state_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + status = bactext_event_state_index(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + /* BACnetEventType */ + for (i = 0; i <= EVENT_CHANGE_OF_TIMER; i++) { + pString = bactext_event_type_name(i); + zassert_not_null(pString, "i=%u", i); + status = bactext_event_type_strtol(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + status = bactext_event_type_index(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + /* BACnetBinaryPV */ + for (i = 0; i < BINARY_PV_MAX; i++) { + pString = bactext_binary_present_value_name(i); + zassert_not_null(pString, "i=%u", i); + status = bactext_binary_present_value_index(pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + /* BACnetPolarity */ + for (i = 0; i < MAX_POLARITY; i++) { + pString = bactext_binary_polarity_name(i); + zassert_not_null(pString, "i=%u", i); + status = bactext_property_states_strtoul( + PROP_STATE_POLARITY, pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + /* BACnetReliability */ + for (i = 0; i < RELIABILITY_RESERVED_MIN; i++) { + pString = bactext_reliability_name(i); + zassert_not_null(pString, "i=%u", i); + status = bactext_property_states_strtoul( + PROP_STATE_RELIABILITY, pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + /* BACnetDeviceStatus */ + for (i = 0; i < MAX_DEVICE_STATUS; i++) { + pString = bactext_device_status_name(i); + zassert_not_null(pString, "i=%u", i); + status = bactext_property_states_strtoul( + PROP_STATE_SYSTEM_STATUS, pString, &index); + zassert_true(status, "i=%u %s", i, pString); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + /* BACnetSegmentation */ + for (i = 0; i < MAX_BACNET_SEGMENTATION; i++) { + pString = bactext_segmentation_name(i); + if (pString) { + status = bactext_segmentation_index(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetNodeType */ + for (i = 0; i < BACNET_NODE_TYPE_MAX; i++) { + pString = bactext_node_type_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_NODE_TYPE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetRelationship */ + for (i = 0; i < BACNET_RELATIONSHIP_RESERVED_MIN; i++) { + pString = bactext_node_relationship_name(i); + if (pString) { + status = bactext_node_relationship_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + status = bactext_node_relationship_name_proprietary(i); + zassert_false(status, "i=%u", i); + status = bactext_node_relationship_name_reserved(i); + zassert_false(status, "i=%u", i); + } + status = bactext_node_relationship_name_proprietary( + BACNET_RELATIONSHIP_PROPRIETARY_MIN); + zassert_true(status, NULL); + status = bactext_node_relationship_name_reserved( + BACNET_RELATIONSHIP_RESERVED_MIN); + zassert_true(status, NULL); + /* BACNET_NETWORK_MESSAGE_TYPE */ + for (i = 0; i < NETWORK_MESSAGE_ASHRAE_RESERVED_MIN; i++) { + pString = bactext_network_layer_msg_name(i); + if (pString) { + status = bactext_network_layer_msg_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = + bactext_network_layer_msg_name(NETWORK_MESSAGE_ASHRAE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_network_layer_msg_name(NETWORK_MESSAGE_INVALID - 1); + zassert_not_null(pString, NULL); + pString = bactext_network_layer_msg_name(NETWORK_MESSAGE_INVALID); + zassert_not_null(pString, NULL); + /* BACnetLifeSafetyMode */ + for (i = 0; i < LIFE_SAFETY_MODE_RESERVED_MIN; i++) { + pString = bactext_life_safety_mode_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFE_SAFETY_MODE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_life_safety_mode_name(LIFE_SAFETY_MODE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_life_safety_mode_name(LIFE_SAFETY_MODE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_life_safety_mode_name(LIFE_SAFETY_MODE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_life_safety_mode_name(LIFE_SAFETY_MODE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLifeSafetyOperation */ + for (i = 0; i < LIFE_SAFETY_OP_RESERVED_MIN; i++) { + pString = bactext_life_safety_operation_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFE_SAFETY_OPERATION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_life_safety_operation_name(LIFE_SAFETY_OP_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_life_safety_operation_name(LIFE_SAFETY_OP_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = + bactext_life_safety_operation_name(LIFE_SAFETY_OP_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_life_safety_operation_name(LIFE_SAFETY_OP_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLifeSafetyState */ + for (i = 0; i < LIFE_SAFETY_STATE_RESERVED_MIN; i++) { + pString = bactext_life_safety_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFE_SAFETY_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_life_safety_state_name(LIFE_SAFETY_STATE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_life_safety_state_name(LIFE_SAFETY_STATE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_life_safety_state_name(LIFE_SAFETY_STATE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_life_safety_state_name(LIFE_SAFETY_STATE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetSilencedState */ + for (i = 0; i < SILENCED_STATE_RESERVED_MIN; i++) { + pString = bactext_silenced_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_SILENCED_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_silenced_state_name(SILENCED_STATE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_silenced_state_name(SILENCED_STATE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_silenced_state_name(SILENCED_STATE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_silenced_state_name(SILENCED_STATE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLightingInProgress */ + for (i = 0; i < MAX_BACNET_LIGHTING_IN_PROGRESS; i++) { + pString = bactext_lighting_in_progress(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIGHTING_IN_PROGRESS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_lighting_in_progress(MAX_BACNET_LIGHTING_IN_PROGRESS); + zassert_not_null(pString, NULL); + /* BACnetLightingTransition */ + for (i = 0; i < BACNET_LIGHTING_TRANSITION_RESERVED_MIN; i++) { + pString = bactext_lighting_transition(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIGHTING_TRANSITION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = + bactext_lighting_transition(BACNET_LIGHTING_TRANSITION_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_lighting_transition(BACNET_LIGHTING_TRANSITION_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = + bactext_lighting_transition(BACNET_LIGHTING_TRANSITION_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lighting_transition( + BACNET_LIGHTING_TRANSITION_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLightingOperation */ + for (i = 0; i < BACNET_LIGHTS_RESERVED_MIN; i++) { + pString = bactext_lighting_operation_name(i); + if (pString) { + status = bactext_lighting_operation_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_lighting_operation_name(BACNET_LIGHTS_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lighting_operation_name(BACNET_LIGHTS_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_lighting_operation_name(BACNET_LIGHTS_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_lighting_operation_name(BACNET_LIGHTS_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetBinaryLightingPV */ + for (i = 0; i < BINARY_LIGHTING_PV_MAX; i++) { + pString = bactext_binary_lighting_pv_name(i); + if (pString) { + status = bactext_binary_lighting_pv_names_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_binary_lighting_pv_name(BINARY_LIGHTING_PV_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_binary_lighting_pv_name(BINARY_LIGHTING_PV_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = + bactext_binary_lighting_pv_name(BINARY_LIGHTING_PV_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_binary_lighting_pv_name(BINARY_LIGHTING_PV_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetColorOperation */ + for (i = 0; i < BACNET_COLOR_OPERATION_MAX; i++) { + pString = bactext_color_operation_name(i); + if (pString) { + status = bactext_color_operation_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_color_operation_name(BACNET_COLOR_OPERATION_MAX); + zassert_not_null(pString, NULL); + /* DeviceCommunicationControl-Request enable-disable */ + for (i = 0; i < MAX_BACNET_COMMUNICATION_ENABLE_DISABLE; i++) { + pString = bactext_device_communications_name(i); + if (pString) { + status = bactext_device_communications_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_device_communications_name( + MAX_BACNET_COMMUNICATION_ENABLE_DISABLE); + zassert_not_null(pString, NULL); + /* BACnetShedState */ + for (i = 0; i < BACNET_SHED_STATE_MAX; i++) { + pString = bactext_shed_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_SHED_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetLogDatum */ + for (i = 0; i < BACNET_LOG_DATUM_MAX; i++) { + pString = bactext_log_datum_name(i); + if (pString) { + status = bactext_log_datum_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetRestartReason */ + for (i = 0; i < RESTART_REASON_RESERVED_MIN; i++) { + pString = bactext_restart_reason_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_RESTART_REASON, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_restart_reason_name(RESTART_REASON_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_restart_reason_name(RESTART_REASON_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_restart_reason_name(RESTART_REASON_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_restart_reason_name(RESTART_REASON_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetShedState */ + for (i = 0; i < BACNET_SHED_STATE_MAX; i++) { + pString = bactext_shed_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_SHED_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetShedLevelType */ + for (i = 0; i < BACNET_SHED_LEVEL_TYPE_MAX; i++) { + pString = bactext_shed_level_type_name(i); + if (pString) { + status = bactext_shed_level_type_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetNetworkType */ + for (i = 0; i < PORT_TYPE_RESERVED_MIN; i++) { + pString = bactext_network_port_type_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_NETWORK_TYPE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_network_port_type_name(PORT_TYPE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_network_port_type_name(PORT_TYPE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_network_port_type_name(PORT_TYPE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_network_port_type_name(PORT_TYPE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetNetworkNumberQuality */ + for (i = 0; i < PORT_QUALITY_MAX; i++) { + pString = bactext_network_number_quality_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_NETWORK_NUMBER_QUALITY, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetProtocolLevel */ + for (i = 0; i < BACNET_PROTOCOL_LEVEL_MAX; i++) { + pString = bactext_protocol_level_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_PROTOCOL_LEVEL, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetNetworkPortCommand */ + for (i = 0; i < PORT_COMMAND_RESERVED_MIN; i++) { + pString = bactext_network_port_command_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_NETWORK_PORT_COMMAND, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_network_port_command_name(PORT_COMMAND_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_network_port_command_name(PORT_COMMAND_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_network_port_command_name(PORT_COMMAND_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_network_port_command_name(PORT_COMMAND_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetAuthenticationDecision */ + for (i = 0; i < BACNET_AUTHENTICATION_DECISION_MAX; i++) { + pString = bactext_authentication_decision_name(i); + if (pString) { + status = bactext_authentication_decision_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetAuthorizationPosture */ + for (i = 0; i < BACNET_AUTHORIZATION_POSTURE_MAX; i++) { + pString = bactext_authorization_posture_name(i); + if (pString) { + status = bactext_authorization_posture_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetFaultType */ + for (i = 0; i < BACNET_FAULT_TYPE_MAX; i++) { + pString = bactext_fault_type_name(i); + if (pString) { + status = bactext_fault_type_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetPriorityFilter */ + for (i = 0; i < BACNET_PRIORITY_FILTER_MAX; i++) { + pString = bactext_priority_filter_name(i); + if (pString) { + status = bactext_priority_filter_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetResultFlags */ + for (i = 0; i < BACNET_RESULT_FLAGS_MAX; i++) { + pString = bactext_result_flags_name(i); + if (pString) { + status = bactext_result_flags_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetSuccessFilter */ + for (i = 0; i < BACNET_SUCCESS_FILTER_MAX; i++) { + pString = bactext_success_filter_name(i); + if (pString) { + status = bactext_success_filter_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetLoggingType */ + for (i = 0; i < BACNET_LOGGING_TYPE_MAX; i++) { + pString = bactext_logging_type_name(i); + if (pString) { + status = bactext_logging_type_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetProgramRequest */ + for (i = 0; i < PROGRAM_REQUEST_MAX; i++) { + pString = bactext_program_request_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_PROGRAM_CHANGE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetProgramState */ + for (i = 0; i < PROGRAM_STATE_MAX; i++) { + pString = bactext_program_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_PROGRAM_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetProgramError */ + for (i = 0; i < PROGRAM_ERROR_RESERVED_MIN; i++) { + pString = bactext_program_error_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_REASON_FOR_HALT, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_program_error_name(PROGRAM_ERROR_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_program_error_name(PROGRAM_ERROR_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_program_error_name(PROGRAM_ERROR_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_program_error_name(PROGRAM_ERROR_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetTimerState */ + for (i = 0; i < TIMER_STATE_MAX; i++) { + pString = bactext_timer_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_TIMER_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetTimerTransition */ + for (i = 0; i < TIMER_TRANSITION_MAX; i++) { + pString = bactext_timer_transition_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_TIMER_TRANSITION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetBooleanValue */ + for (i = 0; i < 2; i++) { + pString = bactext_boolean_value_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_BOOLEAN_VALUE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetAction */ + for (i = 0; i < BACNET_ACTION_MAX; i++) { + pString = bactext_action_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ACTION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetFileAccessMethod */ + for (i = 0; i < BACNET_FILE_ACCESS_METHOD_MAX; i++) { + pString = bactext_file_access_method_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_FILE_ACCESS_METHOD, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetLockStatus */ + for (i = 0; i < BACNET_LOCK_STATUS_MAX; i++) { + pString = bactext_lock_status_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LOCK_STATUS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetDoorAlarmState */ + for (i = 0; i < DOOR_ALARM_STATE_RESERVED_MIN; i++) { + pString = bactext_door_alarm_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_DOOR_ALARM_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_door_alarm_state_name(DOOR_ALARM_STATE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_door_alarm_state_name(DOOR_ALARM_STATE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_door_alarm_state_name(DOOR_ALARM_STATE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_door_alarm_state_name(DOOR_ALARM_STATE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetDoorStatus */ + for (i = 0; i < DOOR_STATUS_RESERVED_MIN; i++) { + pString = bactext_door_status_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_DOOR_STATUS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_door_status_name(DOOR_STATUS_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_door_status_name(DOOR_STATUS_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_door_status_name(DOOR_STATUS_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_door_status_name(DOOR_STATUS_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetDoorSecuredStatus */ + for (i = 0; i < DOOR_SECURED_STATUS_MAX; i++) { + pString = bactext_door_secured_status_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_DOOR_SECURED_STATUS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetAccessEvent */ + for (i = 0; i < ACCESS_EVENT_RESERVED_MIN; i++) { + pString = bactext_access_event_name_default(i, NULL); + if (pString) { + pString = bactext_access_event_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ACCESS_EVENT, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + } + pString = + bactext_access_event_name_default(ACCESS_EVENT_RESERVED_MAX, NULL); + zassert_false(pString, NULL); + pString = + bactext_access_event_name_default(ACCESS_EVENT_PROPRIETARY_MIN, NULL); + zassert_false(pString, NULL); + pString = + bactext_access_event_name_default(ACCESS_EVENT_PROPRIETARY_MAX, NULL); + zassert_false(pString, NULL); + pString = bactext_access_event_name_default( + ACCESS_EVENT_PROPRIETARY_MAX + 1, NULL); + zassert_false(pString, NULL); + /* BACnetAuthenticationStatus */ + for (i = 0; i < AUTHENTICATION_STATUS_MAX; i++) { + pString = bactext_authentication_status_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_AUTHENTICATION_STATUS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetAuthorizationMode */ + for (i = 0; i < AUTHORIZATION_MODE_RESERVED_MIN; i++) { + pString = bactext_authorization_mode_name(i); + if (pString) { + status = bactext_authorization_mode_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetAccessCredentialDisable */ + for (i = 0; i < ACCESS_CREDENTIAL_DISABLE_RESERVED_MIN; i++) { + pString = bactext_access_credential_disable_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ACCESS_CRED_DISABLE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_access_credential_disable_name( + ACCESS_CREDENTIAL_DISABLE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_credential_disable_name( + ACCESS_CREDENTIAL_DISABLE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_access_credential_disable_name( + ACCESS_CREDENTIAL_DISABLE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_credential_disable_name( + ACCESS_CREDENTIAL_DISABLE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetAccessCredentialDisableReason */ + for (i = 0; i < CREDENTIAL_DISABLED_RESERVED_MIN; i++) { + pString = bactext_access_credential_disable_reason_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ACCESS_CRED_DISABLE_REASON, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_access_credential_disable_reason_name( + CREDENTIAL_DISABLED_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_credential_disable_reason_name( + CREDENTIAL_DISABLED_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_access_credential_disable_reason_name( + CREDENTIAL_DISABLED_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_credential_disable_reason_name( + CREDENTIAL_DISABLED_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetAccessUserType */ + for (i = 0; i < ACCESS_USER_TYPE_RESERVED_MIN; i++) { + pString = bactext_access_user_type_name(i); + if (pString) { + status = bactext_access_user_type_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_access_user_type_name(ACCESS_USER_TYPE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_user_type_name(ACCESS_USER_TYPE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_access_user_type_name(ACCESS_USER_TYPE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_access_user_type_name(ACCESS_USER_TYPE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetAccessZoneOccupancyState */ + for (i = 0; i < ACCESS_ZONE_OCCUPANCY_STATE_RESERVED_MIN; i++) { + pString = bactext_access_zone_occupancy_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ZONE_OCCUPANCY_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_access_zone_occupancy_state_name( + ACCESS_ZONE_OCCUPANCY_STATE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_zone_occupancy_state_name( + ACCESS_ZONE_OCCUPANCY_STATE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_access_zone_occupancy_state_name( + ACCESS_ZONE_OCCUPANCY_STATE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_access_zone_occupancy_state_name( + ACCESS_ZONE_OCCUPANCY_STATE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetWriteStatus */ + for (i = 0; i < BACNET_WRITE_STATUS_MAX; i++) { + pString = bactext_write_status_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_WRITE_STATUS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetIPMode */ + for (i = 0; i < BACNET_IP_MODE_MAX; i++) { + pString = bactext_ip_mode_name(i); + if (pString) { + status = bactext_ip_mode_strtol(pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetDoorValue */ + for (i = 0; i < DOOR_VALUE_MAX; i++) { + pString = bactext_door_value_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_DOOR_VALUE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetMaintenance */ + for (i = 0; i < MAINTENANCE_RESERVED_MIN; i++) { + pString = bactext_maintenance_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_MAINTENANCE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_maintenance_name(MAINTENANCE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_maintenance_name(MAINTENANCE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_maintenance_name(MAINTENANCE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_maintenance_name(MAINTENANCE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetEscalatorFault */ + for (i = 0; i < ESCALATOR_FAULT_RESERVED_MIN; i++) { + pString = bactext_escalator_fault_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ESCALATOR_FAULT, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetEscalatorMode */ + for (i = 0; i < ESCALATOR_MODE_RESERVED_MIN; i++) { + pString = bactext_escalator_mode_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ESCALATOR_MODE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_escalator_mode_name(ESCALATOR_MODE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_escalator_mode_name(ESCALATOR_MODE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_escalator_mode_name(ESCALATOR_MODE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_escalator_mode_name(ESCALATOR_MODE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetEscalatorOperationDirection */ + for (i = 0; i < ESCALATOR_OPERATION_DIRECTION_RESERVED_MIN; i++) { + pString = bactext_escalator_operation_direction_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_ESCALATOR_OPERATION_DIRECTION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_escalator_operation_direction_name( + ESCALATOR_OPERATION_DIRECTION_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_escalator_operation_direction_name( + ESCALATOR_OPERATION_DIRECTION_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_escalator_operation_direction_name( + ESCALATOR_OPERATION_DIRECTION_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_escalator_operation_direction_name( + ESCALATOR_OPERATION_DIRECTION_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetBackupState */ + for (i = 0; i < BACKUP_STATE_MAX; i++) { + pString = bactext_backup_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_BACKUP_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetSecurityLevel */ + for (i = 0; i < BACNET_SECURITY_LEVEL_MAX; i++) { + pString = bactext_security_level_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_SECURITY_LEVEL, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetLiftCarDirection */ + for (i = 0; i < LIFT_CAR_DIRECTION_RESERVED_MIN; i++) { + pString = bactext_lift_car_direction_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFT_CAR_DIRECTION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_lift_car_direction_name(LIFT_CAR_DIRECTION_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_lift_car_direction_name(LIFT_CAR_DIRECTION_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = + bactext_lift_car_direction_name(LIFT_CAR_DIRECTION_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = + bactext_lift_car_direction_name(LIFT_CAR_DIRECTION_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLiftCarDoorCommand */ + for (i = 0; i < LIFT_CAR_DOOR_COMMAND_MAX; i++) { + pString = bactext_lift_car_door_command_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFT_CAR_DOOR_COMMAND, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetLiftCarDriveStatus */ + for (i = 0; i < LIFT_CAR_DRIVE_STATUS_RESERVED_MIN; i++) { + pString = bactext_lift_car_drive_status_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFT_CAR_DRIVE_STATUS, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = + bactext_lift_car_drive_status_name(LIFT_CAR_DRIVE_STATUS_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lift_car_drive_status_name( + LIFT_CAR_DRIVE_STATUS_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_lift_car_drive_status_name( + LIFT_CAR_DRIVE_STATUS_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lift_car_drive_status_name( + LIFT_CAR_DRIVE_STATUS_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLiftCarMode */ + for (i = 0; i < LIFT_CAR_MODE_RESERVED_MIN; i++) { + pString = bactext_lift_car_mode_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFT_CAR_MODE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_lift_car_mode_name(LIFT_CAR_MODE_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lift_car_mode_name(LIFT_CAR_MODE_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_lift_car_mode_name(LIFT_CAR_MODE_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lift_car_mode_name(LIFT_CAR_MODE_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLiftFault */ + for (i = 0; i < LIFT_FAULT_RESERVED_MIN; i++) { + pString = bactext_lift_fault_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFT_FAULT, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_lift_fault_name(LIFT_FAULT_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lift_fault_name(LIFT_FAULT_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_lift_fault_name(LIFT_FAULT_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_lift_fault_name(LIFT_FAULT_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetLiftGroupMode */ + for (i = 0; i < LIFT_GROUP_MODE_MAX; i++) { + pString = bactext_lift_group_mode_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_LIFT_GROUP_MODE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetAuditLevel */ + for (i = 0; i < AUDIT_LEVEL_RESERVED_MIN; i++) { + pString = bactext_audit_level_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_AUDIT_LEVEL, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_audit_level_name(AUDIT_LEVEL_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_audit_level_name(AUDIT_LEVEL_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_audit_level_name(AUDIT_LEVEL_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_audit_level_name(AUDIT_LEVEL_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetAuditOperation */ + for (i = 0; i < AUDIT_OPERATION_RESERVED_MIN; i++) { + pString = bactext_audit_operation_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_AUDIT_OPERATION, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + pString = bactext_audit_operation_name(AUDIT_OPERATION_RESERVED_MAX); + zassert_not_null(pString, NULL); + pString = bactext_audit_operation_name(AUDIT_OPERATION_PROPRIETARY_MIN); + zassert_not_null(pString, NULL); + pString = bactext_audit_operation_name(AUDIT_OPERATION_PROPRIETARY_MAX); + zassert_not_null(pString, NULL); + pString = bactext_audit_operation_name(AUDIT_OPERATION_PROPRIETARY_MAX + 1); + zassert_not_null(pString, NULL); + /* BACnetSCHubConnectorState */ + for (i = 0; i < BACNET_SC_HUB_CONNECTOR_STATE_MAX; i++) { + pString = bactext_sc_hub_connector_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_SC_HUB_CONNECTOR_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + /* BACnetSCConnectionState */ + for (i = 0; i < BACNET_SC_CONNECTION_STATE_MAX; i++) { + pString = bactext_sc_connection_state_name(i); + if (pString) { + status = bactext_property_states_strtoul( + PROP_STATE_SC_CONNECTION_STATE, pString, &index); + zassert_true(status, "i=%u", i); + zassert_equal(index, i, "index=%u i=%u", index, i); + } + } + status = bactext_object_property_strtoul( + OBJECT_DEVICE, PROP_PRESENT_VALUE, "8", &found_index); + zassert_true(status, NULL); + zassert_equal(found_index, 8, NULL); + status = bactext_object_property_strtoul( + OBJECT_DEVICE, PROP_TRACKING_VALUE, "7", &found_index); + zassert_true(status, NULL); + zassert_equal(found_index, 7, NULL); + status = bactext_object_property_strtoul( + OBJECT_DEVICE, PROP_FEEDBACK_VALUE, "6", &found_index); + zassert_true(status, NULL); + zassert_equal(found_index, 6, NULL); + status = bactext_object_property_strtoul( + OBJECT_DEVICE, PROP_FAULT_SIGNALS, "5", &found_index); + zassert_true(status, NULL); + zassert_equal(found_index, 5, NULL); +} +/*/** + * @brief + * + */ + +#if defined(CONFIG_ZTEST_NEW_API) +ZTEST_SUITE(bactext_tests, NULL, NULL, NULL, NULL, NULL); +#else +void test_main(void) +{ + ztest_test_suite(bactext_tests, ztest_unit_test(testBacText)); + + ztest_run_test_suite(bactext_tests); +} +#endif