diff --git a/src/bacnet/bacdcode.c b/src/bacnet/bacdcode.c index 2f0c63b0..274659ff 100644 --- a/src/bacnet/bacdcode.c +++ b/src/bacnet/bacdcode.c @@ -498,7 +498,9 @@ int bacnet_tag_decode(uint8_t *apdu, uint32_t apdu_size, BACNET_TAG *tag) bool closing_tag = false; uint32_t len_value_type = 0; - len = bacnet_tag_number_decode(&apdu[0], apdu_size, &tag_number); + if (apdu && (apdu_size > 0)) { + len = bacnet_tag_number_decode(&apdu[0], apdu_size, &tag_number); + } if (len > 0) { if (IS_EXTENDED_VALUE(apdu[0])) { if (apdu_size > len) { @@ -1121,11 +1123,7 @@ int bacnet_boolean_context_decode( apdu_len = len; if (apdu_len < apdu_size) { if (boolean_value) { - if (apdu[apdu_len]) { - *boolean_value = true; - } else { - *boolean_value = false; - } + *boolean_value = decode_context_boolean(&apdu[apdu_len]); } apdu_len++; } else { diff --git a/src/bacnet/bacenum.h b/src/bacnet/bacenum.h index e3d56a48..6a1f4e36 100644 --- a/src/bacnet/bacenum.h +++ b/src/bacnet/bacenum.h @@ -1036,7 +1036,46 @@ typedef enum { PROP_STATE_ZONE_OCCUPANCY_STATE = 31, PROP_STATE_ACCESS_CRED_DISABLE_REASON = 32, PROP_STATE_ACCESS_CRED_DISABLE = 33, - PROP_STATE_AUTHENTICATION_STATUS = 34 + PROP_STATE_AUTHENTICATION_STATUS = 34, + PROP_STATE_BACKUP_STATE = 36, + PROP_STATE_WRITE_STATUS = 37, + PROP_STATE_LIGHTING_IN_PROGRESS = 38, + PROP_STATE_LIGHTING_OPERATION = 39, + PROP_STATE_LIGHTING_TRANSITION = 40, + PROP_STATE_INTEGER_VALUE = 41, + PROP_STATE_BINARY_LIGHTING_VALUE = 42, + PROP_STATE_TIMER_STATE = 43, + PROP_STATE_TIMER_TRANSITION = 44, + PROP_STATE_BACNET_IP_MODE = 45, + PROP_STATE_NETWORK_PORT_COMMAND = 46, + PROP_STATE_NETWORK_TYPE = 47, + PROP_STATE_NETWORK_NUMBER_QUALITY = 48, + PROP_STATE_ESCALATOR_OPERATION_DIRECTION = 49, + PROP_STATE_ESCALATOR_FAULT = 50, + PROP_STATE_ESCALATOR_MODE = 51, + PROP_STATE_LIFT_CAR_DIRECTION = 52, + PROP_STATE_LIFT_CAR_DOOR_COMMAND = 53, + PROP_STATE_LIFT_CAR_DRIVE_STATUS = 54, + PROP_STATE_LIFT_CAR_MODE = 55, + PROP_STATE_LIFT_GROUP_MODE = 56, + PROP_STATE_LIFT_FAULT = 57, + PROP_STATE_PROTOCOL_LEVEL = 58, + PROP_STATE_AUDIT_LEVEL = 59, + PROP_STATE_AUDIT_OPERATION = 60, + PROP_STATE_EXTENDED_VALUE = 63, + PROP_STATE_EXAMPLE_ONE = 256, + PROP_STATE_EXAMPLE_TWO = 257, + /* Tag values greater than 254 are not encoded as ASN context tags. + In these cases, the tag value is multiplied + by 100000 and is added to the enumeration value + and the sum is encoded using context tag 63, + the extended-value choice.*/ + + /* Tag values 0-63 are reserved for definition by ASHRAE. + Tag values of 64-254 may be used by others to + accommodate vendor specific properties that have discrete + or enumerated values, subject to the constraints + described in Clause 23.*/ } BACNET_PROPERTY_STATES; typedef enum { @@ -2059,6 +2098,20 @@ typedef enum BACnetLightingTransition { BACNET_LIGHTING_TRANSITION_PROPRIETARY_LAST = 255 } BACNET_LIGHTING_TRANSITION; +typedef enum BACnetBinaryLightingPV { + BINARY_LIGHTING_PV_OFF = 0, + BINARY_LIGHTING_PV_ON = 1, + BINARY_LIGHTING_PV_WARN = 2, + BINARY_LIGHTING_PV_WARN_OFF = 3, + BINARY_LIGHTING_PV_WARN_RELINQUISH = 4, + BINARY_LIGHTING_PV_STOP = 5, + /* -- 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. */ + BINARY_LIGHTING_PV_PROPRIETARY_MIN = 64, + BINARY_LIGHTING_PV_PROPRIETARY_MAX = 255 +} BACNET_BINARY_LIGHTING_PV; + typedef enum BACnetColorOperation { BACNET_COLOR_OPERATION_NONE = 0, BACNET_COLOR_OPERATION_FADE_TO_COLOR = 1, @@ -2252,7 +2305,7 @@ typedef enum { } BACNET_ACCESS_PASSBACK_MODE; /* Access Zone Occupancy State */ -typedef enum { +typedef enum BACnetAccessZoneOccupancyState { ACCESS_ZONE_OCCUPANCY_STATE_NORMAL = 0, ACCESS_ZONE_OCCUPANCY_STATE_BELOW_LOWER_LIMIT = 1, ACCESS_ZONE_OCCUPANCY_STATE_AT_LOWER_LIMIT = 2, @@ -2260,6 +2313,11 @@ typedef enum { ACCESS_ZONE_OCCUPANCY_STATE_ABOVE_UPPER_LIMIT = 4, ACCESS_ZONE_OCCUPANCY_STATE_DISABLED = 5, ACCESS_ZONE_OCCUPANCY_STATE_NOT_SUPPORTED = 6 + /* 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_ZONE_OCCUPANCY_STATE_PROPRIETARY_MIN = 64, + ACCESS_ZONE_OCCUPANCY_STATE_PROPRIETARY_MAX = 65535 } BACNET_ACCESS_ZONE_OCCUPANCY_STATE; /* Access User Type */ @@ -2520,4 +2578,210 @@ typedef enum BACnetIPMode_T { BACNET_IP_MODE_BBMD = 2 } BACNET_IP_MODE; +typedef enum BACnetBackupState { + BACKUP_STATE_IDLE = 0, + BACKUP_STATE_PREPARING_FOR_BACKUP = 1, + BACKUP_STATE_PREPARING_FOR_RESTORE = 2, + BACKUP_STATE_PERFORMING_A_BACKUP = 3, + BACKUP_STATE_PERFORMING_A_RESTORE = 4, + BACKUP_STATE_BACKUP_FAILURE = 5, + BACKUP_STATE_RESTORE_FAILURE = 6 +} BACNET_BACKUP_STATE; + +typedef enum BACnetTimerState { + TIMER_STATE_IDLE = 0, + TIMER_STATE_RUNNING = 1, + TIMER_STATE_EXPIRED = 2 +} BACNET_TIMER_STATE; + +typedef enum BACnetTimerTransition { + TIMER_TRANSITION_NONE = 0, + TIMER_TRANSITION_IDLE_TO_RUNNING = 1, + TIMER_TRANSITION_RUNNING_TO_IDLE = 2, + TIMER_TRANSITION_RUNNING_TO_RUNNING = 3, + TIMER_TRANSITION_RUNNING_TO_EXPIRED = 4, + TIMER_TRANSITION_FORCED_TO_EXPIRED = 5, + TIMER_TRANSITION_EXPIRED_TO_IDLE = 6, + TIMER_TRANSITION_EXPIRED_TO_RUNNING = 7 +} BACNET_TIMER_TRANSITION; + +typedef enum BACnetEscalatorFault { + ESCALATOR_FAULT_CONTROLLER_FAULT = 0, + ESCALATOR_FAULT_DRIVE_AND_MOTOR_FAULT = 1, + ESCALATOR_FAULT_MECHANICAL_COMPONENT_FAULT = 2, + ESCALATOR_FAULT_OVERSPEED_FAULT = 3, + ESCALATOR_FAULT_POWER_SUPPLY_FAULT = 4, + ESCALATOR_FAULT_SAFETY_DEVICE_FAULT = 5, + ESCALATOR_FAULT_CONTROLLER_SUPPLY_FAULT = 6, + ESCALATOR_FAULT_DRIVE_TEMPERATURE_EXCEEDED = 7, + ESCALATOR_FAULT_COMB_PLATE_FAULT = 8, + /* 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. */ + ESCALATOR_FAULT_PROPRIETARY_MIN = 1024, + ESCALATOR_FAULT_PROPRIETARY_MAX = 65535 +} BACNET_ESCALATOR_FAULT; + +typedef enum BACnetEscalatorMode { + ESCALATOR_MODE_UNKNOWN = 0, + ESCALATOR_MODE_STOP = 1, + ESCALATOR_MODE_UP = 2, + ESCALATOR_MODE_DOWN = 3, + ESCALATOR_MODE_INSPECTION = 4, + ESCALATOR_MODE_OUT_OF_SERVICE = 5, + /* 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. */ + ESCALATOR_MODE_PROPRIETARY_MIN = 1024, + ESCALATOR_MODE_PROPRIETARY_MAX = 65535 +} BACNET_ESCALATOR_MODE; + +typedef enum BACnetEscalatorOperationDirection { + ESCALATOR_OPERATION_DIRECTION_UNKNOWN = 0, + ESCALATOR_OPERATION_DIRECTION_STOPPED = 1, + ESCALATOR_OPERATION_DIRECTION_UP_RATED_SPEED = 2, + ESCALATOR_OPERATION_DIRECTION_UP_REDUCED_SPEED = 3, + ESCALATOR_OPERATION_DIRECTION_DOWN_RATED_SPEED = 4, + ESCALATOR_OPERATION_DIRECTION_DOWN_REDUCED_SPEED = 5, + /* 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. */ + ESCALATOR_OPERATION_DIRECTION_PROPRIETARY_MIN = 1024, + ESCALATOR_OPERATION_DIRECTION_PROPRIETARY_MAX = 65535 +} BACNET_ESCALATOR_OPERATION_DIRECTION; + +typedef enum BACnetLiftCarDirection { + LIFT_CAR_DIRECTION_UNKNOWN = 0, + LIFT_CAR_DIRECTION_NONE = 1, + LIFT_CAR_DIRECTION_STOPPED = 2, + LIFT_CAR_DIRECTION_UP = 3, + LIFT_CAR_DIRECTION_DOWN = 4, + LIFT_CAR_DIRECTION_UP_AND_DOWN = 5, + /* 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. */ + LIFT_CAR_DIRECTION_PROPRIETARY_MIN = 1024, + LIFT_CAR_DIRECTION_PROPRIETARY_MAX = 65535 +} BACNET_LIFT_CAR_DIRECTION; + +typedef enum BACnetLiftCarDoorCommand { + LIFT_CAR_DOOR_COMMAND_NONE = 0, + LIFT_CAR_DOOR_COMMAND_OPEN = 1, + LIFT_CAR_DOOR_COMMAND_CLOSE = 2 +} BACNET_LIFT_CAR_DOOR_COMMAND; + +typedef enum BACnetLiftCarDriveStatus { + LIFT_CAR_DRIVE_STATUS_UNKNOWN = 0, + LIFT_CAR_DRIVE_STATUS_STATIONARY = 1, + LIFT_CAR_DRIVE_STATUS_BRAKING = 2, + LIFT_CAR_DRIVE_STATUS_ACCELERATE = 3, + LIFT_CAR_DRIVE_STATUS_DECELERATE = 4, + LIFT_CAR_DRIVE_STATUS_RATED_SPEED = 5, + LIFT_CAR_DRIVE_STATUS_SINGLE_FLOOR_JUMP = 6, + LIFT_CAR_DRIVE_STATUS_TWO_FLOOR_JUMP = 7, + LIFT_CAR_DRIVE_STATUS_THREE_FLOOR_JUMP = 8, + LIFT_CAR_DRIVE_STATUS_MULTI_FLOOR_JUMP = 9, + /* 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. */ + LIFT_CAR_DRIVE_STATUS_PROPRIETARY_MIN = 1024, + LIFT_CAR_DRIVE_STATUS_PROPRIETARY_MAX = 65535 +} BACNET_LIFT_CAR_DRIVE_STATUS; + +typedef enum BACnetLiftCarMode { + LIFT_CAR_MODE_UNKNOWN = 0, + LIFT_CAR_MODE_NORMAL = 1, /* in service */ + LIFT_CAR_MODE_VIP = 2, + LIFT_CAR_MODE_HOMING = 3, + LIFT_CAR_MODE_PARKING = 4, + LIFT_CAR_MODE_ATTENDANT_CONTROL = 5, + LIFT_CAR_MODE_FIREFIGHTER_CONTROL = 6, + LIFT_CAR_MODE_EMERGENCY_POWER = 7, + LIFT_CAR_MODE_INSPECTION = 8, + LIFT_CAR_MODE_CABINET_RECALL = 9, + LIFT_CAR_MODE_EARTHQUAKE_OPERATION = 10, + LIFT_CAR_MODE_FIRE_OPERATION = 11, + LIFT_CAR_MODE_OUT_OF_SERVICE = 12, + LIFT_CAR_MODE_OCCUPANT_EVACUATION = 13, + /* 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. */ + LIFT_CAR_MODE_PROPRIETARY_MIN = 1024, + LIFT_CAR_MODE_PROPRIETARY_MAX = 65535 +} BACNET_LIFT_CAR_MODE; + +typedef enum BACnetLiftFault { + LIFT_FAULT_CONTROLLER_FAULT = 0, + LIFT_FAULT_DRIVE_AND_MOTOR_FAULT = 1, + LIFT_FAULT_GOVERNOR_AND_SAFETY_GEAR_FAULT = 2, + LIFT_FAULT_LIFT_SHAFT_DEVICE_FAULT = 3, + LIFT_FAULT_POWER_SUPPLY_FAULT = 4, + LIFT_FAULT_SAFETY_INTERLOCK_FAULT = 5, + LIFT_FAULT_DOOR_CLOSING_FAULT = 6, + LIFT_FAULT_DOOR_OPENING_FAULT = 7, + LIFT_FAULT_CAR_STOPPED_OUTSIDE_LANDING_ZONE = 8, + LIFT_FAULT_CALL_BUTTON_STUCK = 9, + LIFT_FAULT_START_FAILURE = 10, + LIFT_FAULT_CONTROLLER_SUPPLY_FAULT = 11, + LIFT_FAULT_SELF_TEST_FAILURE = 12, + LIFT_FAULT_RUNTIME_LIMIT_EXCEEDED = 13, + LIFT_FAULT_POSITION_LOST = 14, + LIFT_FAULT_DRIVE_TEMPERATURE_EXCEEDED = 15, + LIFT_FAULT_LOAD_MEASUREMENT_FAULT = 16, + /* 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. */ + LIFT_FAULT_PROPRIETARY_MIN = 1024, + LIFT_FAULT_PROPRIETARY_MAX = 65535 +} BACNET_LIFT_FAULT; + +typedef enum BACnetLiftGroupMode { + LIFT_GROUP_MODE_UNKNOWN = 0, + LIFT_GROUP_MODE_NORMAL = 1, + LIFT_GROUP_MODE_DOWN_PEAK = 2, + LIFT_GROUP_MODE_TWO_WAY = 3, + LIFT_GROUP_MODE_FOUR_WAY = 4, + LIFT_GROUP_MODE_EMERGENCY_POWER = 5, + LIFT_GROUP_MODE_UP_PEAK = 6 +} BACNET_LIFT_GROUP_MODE; + +typedef enum BACnetAuditLevel { + AUDIT_LEVEL_NONE = 0, + AUDIT_LEVEL_AUDIT_ALL = 1, + AUDIT_LEVEL_AUDIT_CONFIG = 2, + AUDIT_LEVEL_DEFAULT = 3, + /* 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. */ + AUDIT_LEVEL_PROPRIETARY_MIN = 128, + AUDIT_LEVEL_PROPRIETARY_MAX = 255 +} BACNET_AUDIT_LEVEL; + +typedef enum BACnetAuditOperation { + AUDIT_OPERATION_READ = 0, + AUDIT_OPERATION_WRITE = 1, + AUDIT_OPERATION_CREATE = 2, + AUDIT_OPERATION_DELETE = 3, + AUDIT_OPERATION_LIFE_SAFETY = 4, + AUDIT_OPERATION_ACKNOWLEDGE_ALARM = 5, + AUDIT_OPERATION_DEVICE_DISABLE_COMM = 6, + AUDIT_OPERATION_DEVICE_ENABLE_COMM = 7, + AUDIT_OPERATION_DEVICE_RESET = 8, + AUDIT_OPERATION_DEVICE_BACKUP = 9, + AUDIT_OPERATION_DEVICE_RESTORE = 10, + AUDIT_OPERATION_SUBSCRIPTION = 11, + AUDIT_OPERATION_NOTIFICATION = 12, + AUDIT_OPERATION_AUDITING_FAILURE = 13, + AUDIT_OPERATION_NETWORK_CHANGES = 14, + AUDIT_OPERATION_GENERAL = 15, + /* 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. + + The enumerated values match the bit positions in + BACnetAuditOperationFlags. */ + AUDIT_OPERATION_PROPRIETARY_MIN = 32, + AUDIT_OPERATION_PROPRIETARY_MAX = 63 +} BACNET_AUDIT_OPERATION; + #endif /* end of BACENUM_H */ diff --git a/src/bacnet/bacpropstates.c b/src/bacnet/bacpropstates.c index 71375780..c681049f 100644 --- a/src/bacnet/bacpropstates.c +++ b/src/bacnet/bacpropstates.c @@ -39,149 +39,295 @@ /** @file bacpropstates.c Encode/Decode BACnet Application Property States */ +/** + * @brief Decodes BACnetPropertyState from bytes into a data structure + * + * BACnetPropertyStates ::= CHOICE { + * -- This production represents the possible datatypes for properties that + * -- have discrete or enumerated values. The choice shall be consistent with + * -- the datatype of the property referenced in the Event Enrollment Object. + * boolean-value [0] BOOLEAN, + * binary-value [1] BACnetBinaryPV, + * ... + * extended-value [63] Unsigned32, + * -- example-one [256] BACnetExampleTypeOne, + * -- example-two [257] BACnetExampleTypeTwo, + * ... + * } + * -- Tag values greater than 254 are not encoded as ASN context tags. + * -- In these cases, the tag value is multiplied by 100000 and is added + * -- to the enumeration value and the sum is encoded using context tag 63, + * -- the extended-value choice. + * -- Tag values 0-63 are reserved for definition by ASHRAE. + * -- Tag values of 64-254 may be used by others to + * -- accommodate vendor specific properties that have discrete + * -- or enumerated values, subject to the constraints + * -- described in Clause 23. + * + * @param apdu - buffer of data to be decoded + * @param apdu_size - number of bytes in the buffer + * @param value - decoded value, if decoded + * + * @return number of bytes decoded, or #BACNET_STATUS_ERROR (-1) if malformed + */ +int bacapp_property_state_decode( + uint8_t *apdu, uint32_t apdu_size, BACNET_PROPERTY_STATE *value) +{ + BACNET_TAG tag = { 0 }; + uint32_t enum_value = 0; + int32_t integer_value = 0; + int apdu_len = 0; + int len = 0; + + len = bacnet_tag_decode(apdu, apdu_size, &tag); + if (len <= 0) { + return BACNET_STATUS_ERROR; + } + if (!tag.context) { + return BACNET_STATUS_ERROR; + } + apdu_len += len; + if (value) { + value->tag = (BACNET_PROPERTY_STATES)tag.number; + } + if (tag.number == PROP_STATE_BOOLEAN_VALUE) { + if (tag.len_value_type != 1) { + return BACNET_STATUS_ERROR; + } + if (value) { + value->state.booleanValue = decode_context_boolean(&apdu[apdu_len]); + apdu_len++; + } + } else if (tag.number == PROP_STATE_INTEGER_VALUE) { + len = bacnet_signed_decode(&apdu[apdu_len], apdu_size - apdu_len, + tag.len_value_type, &integer_value); + if (len <= 0) { + return BACNET_STATUS_ERROR; + } + apdu_len += len; + if (value) { + value->state.integerValue = integer_value; + } + } else { + len = bacnet_enumerated_decode(&apdu[apdu_len], apdu_size - apdu_len, + tag.len_value_type, &enum_value); + if (len <= 0) { + return BACNET_STATUS_ERROR; + } + apdu_len += len; + if (!value) { + return apdu_len; + } + switch (value->tag) { + case PROP_STATE_BINARY_VALUE: + value->state.binaryValue = (BACNET_BINARY_PV)enum_value; + break; + case PROP_STATE_EVENT_TYPE: + value->state.eventType = (BACNET_EVENT_TYPE)enum_value; + break; + case PROP_STATE_POLARITY: + value->state.polarity = (BACNET_POLARITY)enum_value; + break; + case PROP_STATE_PROGRAM_CHANGE: + value->state.programChange = (BACNET_PROGRAM_REQUEST)enum_value; + break; + case PROP_STATE_PROGRAM_STATE: + value->state.programState = (BACNET_PROGRAM_STATE)enum_value; + break; + case PROP_STATE_REASON_FOR_HALT: + value->state.programError = (BACNET_PROGRAM_ERROR)enum_value; + break; + case PROP_STATE_RELIABILITY: + value->state.reliability = (BACNET_RELIABILITY)enum_value; + break; + case PROP_STATE_EVENT_STATE: + value->state.state = (BACNET_EVENT_STATE)enum_value; + break; + case PROP_STATE_SYSTEM_STATUS: + value->state.systemStatus = (BACNET_DEVICE_STATUS)enum_value; + break; + case PROP_STATE_UNITS: + value->state.units = (BACNET_ENGINEERING_UNITS)enum_value; + break; + case PROP_STATE_UNSIGNED_VALUE: + value->state.unsignedValue = + (BACNET_UNSIGNED_INTEGER)enum_value; + break; + case PROP_STATE_LIFE_SAFETY_MODE: + value->state.lifeSafetyMode = + (BACNET_LIFE_SAFETY_MODE)enum_value; + break; + case PROP_STATE_LIFE_SAFETY_STATE: + value->state.lifeSafetyState = + (BACNET_LIFE_SAFETY_STATE)enum_value; + break; + case PROP_STATE_RESTART_REASON: + value->state.restartReason = (BACNET_RESTART_REASON)enum_value; + break; + case PROP_STATE_DOOR_ALARM_STATE: + value->state.doorAlarmState = + (BACNET_DOOR_ALARM_STATE)enum_value; + break; + case PROP_STATE_ACTION: + value->state.action = (BACNET_ACTION)enum_value; + break; + case PROP_STATE_DOOR_SECURED_STATUS: + value->state.doorSecuredStatus = + (BACNET_DOOR_SECURED_STATUS)enum_value; + break; + case PROP_STATE_DOOR_STATUS: + value->state.doorStatus = (BACNET_DOOR_STATUS)enum_value; + break; + case PROP_STATE_DOOR_VALUE: + value->state.doorValue = (BACNET_DOOR_VALUE)enum_value; + break; + case PROP_STATE_FILE_ACCESS_METHOD: + value->state.fileAccessMethod = + (BACNET_FILE_ACCESS_METHOD)enum_value; + break; + case PROP_STATE_LOCK_STATUS: + value->state.lockStatus = (BACNET_LOCK_STATUS)enum_value; + break; + case PROP_STATE_LIFE_SAFETY_OPERATION: + value->state.lifeSafetyOperation = + (BACNET_LIFE_SAFETY_OPERATION)enum_value; + break; + case PROP_STATE_MAINTENANCE: + value->state.maintenance = (BACNET_MAINTENANCE)enum_value; + break; + case PROP_STATE_NODE_TYPE: + value->state.nodeType = (BACNET_NODE_TYPE)enum_value; + break; + case PROP_STATE_NOTIFY_TYPE: + value->state.notifyType = (BACNET_NOTIFY_TYPE)enum_value; + break; + case PROP_STATE_SECURITY_LEVEL: + value->state.securityLevel = (BACNET_SECURITY_LEVEL)enum_value; + break; + case PROP_STATE_SHED_STATE: + value->state.shedState = (BACNET_SHED_STATE)enum_value; + break; + case PROP_STATE_SILENCED_STATE: + value->state.silencedState = (BACNET_SILENCED_STATE)enum_value; + break; + case PROP_STATE_ACCESS_EVENT: + value->state.accessEvent = (BACNET_ACCESS_EVENT)enum_value; + break; + case PROP_STATE_ZONE_OCCUPANCY_STATE: + value->state.zoneOccupancyState = + (BACNET_ACCESS_ZONE_OCCUPANCY_STATE)enum_value; + break; + case PROP_STATE_ACCESS_CRED_DISABLE_REASON: + value->state.accessCredDisableReason = + (BACNET_ACCESS_CREDENTIAL_DISABLE_REASON)enum_value; + break; + case PROP_STATE_ACCESS_CRED_DISABLE: + value->state.accessCredDisable = + (BACNET_ACCESS_CREDENTIAL_DISABLE)enum_value; + break; + case PROP_STATE_AUTHENTICATION_STATUS: + value->state.authenticationStatus = + (BACNET_AUTHENTICATION_STATUS)enum_value; + break; + case PROP_STATE_BACKUP_STATE: + value->state.backupState = (BACNET_BACKUP_STATE)enum_value; + break; + case PROP_STATE_WRITE_STATUS: + value->state.writeStatus = (BACNET_WRITE_STATUS)enum_value; + break; + case PROP_STATE_LIGHTING_IN_PROGRESS: + value->state.lightingInProgress = + (BACNET_LIGHTING_IN_PROGRESS)enum_value; + break; + case PROP_STATE_LIGHTING_OPERATION: + value->state.lightingOperation = + (BACNET_LIGHTING_OPERATION)enum_value; + break; + case PROP_STATE_LIGHTING_TRANSITION: + value->state.lightingTransition = + (BACNET_LIGHTING_TRANSITION)enum_value; + break; + case PROP_STATE_BINARY_LIGHTING_VALUE: + value->state.binaryLightingValue = + (BACNET_BINARY_LIGHTING_PV)enum_value; + break; + case PROP_STATE_TIMER_STATE: + value->state.timerState = (BACNET_TIMER_STATE)enum_value; + break; + case PROP_STATE_TIMER_TRANSITION: + value->state.timerTransition = + (BACNET_TIMER_TRANSITION)enum_value; + break; + case PROP_STATE_BACNET_IP_MODE: + value->state.bacnetIPMode = (BACNET_IP_MODE)enum_value; + break; + case PROP_STATE_NETWORK_PORT_COMMAND: + value->state.networkPortCommand = + (BACNET_PORT_COMMAND)enum_value; + break; + case PROP_STATE_NETWORK_TYPE: + value->state.networkType = (BACNET_PORT_TYPE)enum_value; + break; + case PROP_STATE_NETWORK_NUMBER_QUALITY: + value->state.networkNumberQuality = + (BACNET_PORT_QUALITY)enum_value; + break; + case PROP_STATE_ESCALATOR_OPERATION_DIRECTION: + value->state.escalatorOperationDirection = + (BACNET_ESCALATOR_OPERATION_DIRECTION)enum_value; + break; + case PROP_STATE_ESCALATOR_FAULT: + value->state.escalatorFault = + (BACNET_ESCALATOR_FAULT)enum_value; + break; + case PROP_STATE_ESCALATOR_MODE: + value->state.escalatorMode = (BACNET_ESCALATOR_MODE)enum_value; + break; + case PROP_STATE_LIFT_CAR_DIRECTION: + value->state.liftCarDirection = + (BACNET_LIFT_CAR_DIRECTION)enum_value; + break; + case PROP_STATE_LIFT_CAR_DOOR_COMMAND: + value->state.liftCarDoorCommand = + (BACNET_LIFT_CAR_DOOR_COMMAND)enum_value; + break; + case PROP_STATE_LIFT_CAR_DRIVE_STATUS: + value->state.liftCarDriveStatus = + (BACNET_LIFT_CAR_DRIVE_STATUS)enum_value; + break; + case PROP_STATE_LIFT_CAR_MODE: + value->state.liftCarMode = (BACNET_LIFT_CAR_MODE)enum_value; + break; + case PROP_STATE_LIFT_GROUP_MODE: + value->state.liftGroupMode = (BACNET_LIFT_GROUP_MODE)enum_value; + break; + case PROP_STATE_LIFT_FAULT: + value->state.liftFault = (BACNET_LIFT_FAULT)enum_value; + break; + case PROP_STATE_PROTOCOL_LEVEL: + value->state.protocolLevel = (BACNET_PROTOCOL_LEVEL)enum_value; + break; + case PROP_STATE_AUDIT_LEVEL: + value->state.auditLevel = (BACNET_AUDIT_LEVEL)enum_value; + break; + case PROP_STATE_AUDIT_OPERATION: + value->state.auditOperation = + (BACNET_AUDIT_OPERATION)enum_value; + break; + case PROP_STATE_EXTENDED_VALUE: + value->state.extendedValue = enum_value; + break; + default: + break; + } + } + + return apdu_len; +} + int bacapp_decode_property_state(uint8_t *apdu, BACNET_PROPERTY_STATE *value) { - int len = 0; - uint32_t len_value_type; - int section_length; - uint32_t enumValue; - uint8_t tagnum; - - section_length = - decode_tag_number_and_value(&apdu[len], &tagnum, &len_value_type); - - if (-1 == section_length) { - return -1; - } - value->tag = (BACNET_PROPERTY_STATE_TYPE)tagnum; - len += section_length; - switch (value->tag) { - case BOOLEAN_VALUE: - value->state.booleanValue = decode_boolean(len_value_type); - break; - - case BINARY_VALUE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.binaryValue = (BACNET_BINARY_PV)enumValue; - break; - - case EVENT_TYPE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.eventType = (BACNET_EVENT_TYPE)enumValue; - break; - - case POLARITY: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.polarity = (BACNET_POLARITY)enumValue; - break; - - case PROGRAM_CHANGE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.programChange = (BACNET_PROGRAM_REQUEST)enumValue; - break; - - case PROGRAM_STATE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.programState = (BACNET_PROGRAM_STATE)enumValue; - break; - - case REASON_FOR_HALT: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.programError = (BACNET_PROGRAM_ERROR)enumValue; - break; - - case RELIABILITY: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.reliability = (BACNET_RELIABILITY)enumValue; - break; - - case STATE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.state = (BACNET_EVENT_STATE)enumValue; - break; - - case SYSTEM_STATUS: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.systemStatus = (BACNET_DEVICE_STATUS)enumValue; - break; - - case UNITS: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.units = (BACNET_ENGINEERING_UNITS)enumValue; - break; - - case UNSIGNED_VALUE: - if (-1 == - (section_length = decode_unsigned(&apdu[len], len_value_type, - &value->state.unsignedValue))) { - return -1; - } - break; - - case LIFE_SAFETY_MODE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.lifeSafetyMode = (BACNET_LIFE_SAFETY_MODE)enumValue; - break; - - case LIFE_SAFETY_STATE: - if (-1 == - (section_length = decode_enumerated( - &apdu[len], len_value_type, &enumValue))) { - return -1; - } - value->state.lifeSafetyState = (BACNET_LIFE_SAFETY_STATE)enumValue; - break; - - default: - return -1; - } - len += section_length; - - return len; + return bacapp_property_state_decode(apdu, MAX_APDU, value); } int bacapp_decode_context_property_state( @@ -222,74 +368,254 @@ int bacapp_encode_property_state(uint8_t *apdu, BACNET_PROPERTY_STATE *value) if (value) { switch (value->tag) { - case BOOLEAN_VALUE: + case PROP_STATE_BOOLEAN_VALUE: len = encode_context_boolean( - apdu, 0, value->state.booleanValue); + apdu, value->tag, value->state.booleanValue); break; - case BINARY_VALUE: + case PROP_STATE_BINARY_VALUE: len = encode_context_enumerated( - apdu, 1, value->state.binaryValue); + apdu, value->tag, value->state.binaryValue); break; - case EVENT_TYPE: + case PROP_STATE_EVENT_TYPE: len = encode_context_enumerated( - apdu, 2, value->state.eventType); + apdu, value->tag, value->state.eventType); break; - case POLARITY: + case PROP_STATE_POLARITY: len = encode_context_enumerated( - apdu, 3, value->state.polarity); + apdu, value->tag, value->state.polarity); break; - case PROGRAM_CHANGE: + case PROP_STATE_PROGRAM_CHANGE: len = encode_context_enumerated( - apdu, 4, value->state.programChange); + apdu, value->tag, value->state.programChange); break; - case PROGRAM_STATE: + case PROP_STATE_PROGRAM_STATE: len = encode_context_enumerated( - apdu, 5, value->state.programState); + apdu, value->tag, value->state.programState); break; - case REASON_FOR_HALT: + case PROP_STATE_REASON_FOR_HALT: len = encode_context_enumerated( - apdu, 6, value->state.programError); + apdu, value->tag, value->state.programError); break; - case RELIABILITY: + case PROP_STATE_RELIABILITY: len = encode_context_enumerated( - apdu, 7, value->state.reliability); + apdu, value->tag, value->state.reliability); break; - case STATE: - len = - encode_context_enumerated(apdu, 8, value->state.state); - break; - - case SYSTEM_STATUS: + case PROP_STATE_EVENT_STATE: len = encode_context_enumerated( - apdu, 9, value->state.systemStatus); + apdu, value->tag, value->state.state); break; - case UNITS: - len = - encode_context_enumerated(apdu, 10, value->state.units); + case PROP_STATE_SYSTEM_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.systemStatus); break; - case UNSIGNED_VALUE: + case PROP_STATE_UNITS: + len = encode_context_enumerated( + apdu, value->tag, value->state.units); + break; + + case PROP_STATE_UNSIGNED_VALUE: len = encode_context_unsigned( - apdu, 11, value->state.unsignedValue); + apdu, value->tag, value->state.unsignedValue); break; - case LIFE_SAFETY_MODE: + case PROP_STATE_LIFE_SAFETY_MODE: len = encode_context_enumerated( - apdu, 12, value->state.lifeSafetyMode); + apdu, value->tag, value->state.lifeSafetyMode); break; - case LIFE_SAFETY_STATE: + case PROP_STATE_LIFE_SAFETY_STATE: len = encode_context_enumerated( - apdu, 13, value->state.lifeSafetyState); + apdu, value->tag, value->state.lifeSafetyState); + break; + case PROP_STATE_RESTART_REASON: + len = encode_context_enumerated( + apdu, value->tag, value->state.restartReason); + break; + case PROP_STATE_DOOR_ALARM_STATE: + len = encode_context_enumerated( + apdu, value->tag, value->state.doorAlarmState); + break; + case PROP_STATE_ACTION: + len = encode_context_enumerated( + apdu, value->tag, value->state.action); + break; + case PROP_STATE_DOOR_SECURED_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.doorSecuredStatus); + break; + case PROP_STATE_DOOR_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.doorStatus); + break; + case PROP_STATE_DOOR_VALUE: + len = encode_context_enumerated( + apdu, value->tag, value->state.doorValue); + break; + case PROP_STATE_FILE_ACCESS_METHOD: + len = encode_context_enumerated( + apdu, value->tag, value->state.fileAccessMethod); + break; + case PROP_STATE_LOCK_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.lockStatus); + break; + case PROP_STATE_LIFE_SAFETY_OPERATION: + len = encode_context_enumerated( + apdu, value->tag, value->state.lifeSafetyOperation); + break; + case PROP_STATE_MAINTENANCE: + len = encode_context_enumerated( + apdu, value->tag, value->state.maintenance); + break; + case PROP_STATE_NODE_TYPE: + len = encode_context_enumerated( + apdu, value->tag, value->state.nodeType); + break; + case PROP_STATE_NOTIFY_TYPE: + len = encode_context_enumerated( + apdu, value->tag, value->state.notifyType); + break; + case PROP_STATE_SECURITY_LEVEL: + len = encode_context_enumerated( + apdu, value->tag, value->state.securityLevel); + break; + case PROP_STATE_SHED_STATE: + len = encode_context_enumerated( + apdu, value->tag, value->state.shedState); + break; + case PROP_STATE_SILENCED_STATE: + len = encode_context_enumerated( + apdu, value->tag, value->state.silencedState); + break; + case PROP_STATE_ACCESS_EVENT: + len = encode_context_enumerated( + apdu, value->tag, value->state.accessEvent); + break; + case PROP_STATE_ZONE_OCCUPANCY_STATE: + len = encode_context_enumerated( + apdu, value->tag, value->state.zoneOccupancyState); + break; + case PROP_STATE_ACCESS_CRED_DISABLE_REASON: + len = encode_context_enumerated( + apdu, value->tag, value->state.accessCredDisableReason); + break; + case PROP_STATE_ACCESS_CRED_DISABLE: + len = encode_context_enumerated( + apdu, value->tag, value->state.accessCredDisable); + break; + case PROP_STATE_AUTHENTICATION_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.authenticationStatus); + break; + case PROP_STATE_BACKUP_STATE: + len = encode_context_enumerated( + apdu, value->tag, value->state.backupState); + break; + case PROP_STATE_WRITE_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.writeStatus); + break; + case PROP_STATE_LIGHTING_IN_PROGRESS: + len = encode_context_enumerated( + apdu, value->tag, value->state.lightingInProgress); + break; + case PROP_STATE_LIGHTING_OPERATION: + len = encode_context_enumerated( + apdu, value->tag, value->state.lightingOperation); + break; + case PROP_STATE_LIGHTING_TRANSITION: + len = encode_context_enumerated( + apdu, value->tag, value->state.lightingTransition); + break; + case PROP_STATE_INTEGER_VALUE: + len = encode_context_signed( + apdu, value->tag, value->state.integerValue); + break; + case PROP_STATE_BINARY_LIGHTING_VALUE: + len = encode_context_enumerated( + apdu, value->tag, value->state.binaryLightingValue); + break; + case PROP_STATE_TIMER_STATE: + len = encode_context_enumerated( + apdu, value->tag, value->state.timerState); + break; + case PROP_STATE_TIMER_TRANSITION: + len = encode_context_enumerated( + apdu, value->tag, value->state.timerTransition); + break; + case PROP_STATE_BACNET_IP_MODE: + len = encode_context_enumerated( + apdu, value->tag, value->state.bacnetIPMode); + break; + case PROP_STATE_NETWORK_PORT_COMMAND: + len = encode_context_enumerated( + apdu, value->tag, value->state.networkPortCommand); + break; + case PROP_STATE_NETWORK_TYPE: + len = encode_context_enumerated( + apdu, value->tag, value->state.networkType); + break; + case PROP_STATE_NETWORK_NUMBER_QUALITY: + len = encode_context_enumerated( + apdu, value->tag, value->state.networkNumberQuality); + break; + case PROP_STATE_ESCALATOR_OPERATION_DIRECTION: + len = encode_context_enumerated( + apdu, value->tag, value->state.escalatorOperationDirection); + break; + case PROP_STATE_ESCALATOR_FAULT: + len = encode_context_enumerated( + apdu, value->tag, value->state.escalatorFault); + break; + case PROP_STATE_ESCALATOR_MODE: + len = encode_context_enumerated( + apdu, value->tag, value->state.escalatorMode); + break; + case PROP_STATE_LIFT_CAR_DIRECTION: + len = encode_context_enumerated( + apdu, value->tag, value->state.liftCarDirection); + break; + case PROP_STATE_LIFT_CAR_DOOR_COMMAND: + len = encode_context_enumerated( + apdu, value->tag, value->state.liftCarDoorCommand); + break; + case PROP_STATE_LIFT_CAR_DRIVE_STATUS: + len = encode_context_enumerated( + apdu, value->tag, value->state.liftCarDriveStatus); + break; + case PROP_STATE_LIFT_CAR_MODE: + len = encode_context_enumerated( + apdu, value->tag, value->state.liftCarMode); + break; + case PROP_STATE_LIFT_GROUP_MODE: + len = encode_context_enumerated( + apdu, value->tag, value->state.liftGroupMode); + break; + case PROP_STATE_LIFT_FAULT: + len = encode_context_enumerated( + apdu, value->tag, value->state.liftFault); + break; + case PROP_STATE_PROTOCOL_LEVEL: + len = encode_context_enumerated( + apdu, value->tag, value->state.protocolLevel); + break; + case PROP_STATE_AUDIT_LEVEL: + len = encode_context_enumerated( + apdu, value->tag, value->state.auditLevel); + break; + case PROP_STATE_AUDIT_OPERATION: + len = encode_context_enumerated( + apdu, value->tag, value->state.auditOperation); break; default: break; diff --git a/src/bacnet/bacpropstates.h b/src/bacnet/bacpropstates.h index 1f70b0b8..545eefcf 100644 --- a/src/bacnet/bacpropstates.h +++ b/src/bacnet/bacpropstates.h @@ -31,25 +31,8 @@ #include "bacnet/bacapp.h" #include "bacnet/timestamp.h" -typedef enum { - BOOLEAN_VALUE, - BINARY_VALUE, - EVENT_TYPE, - POLARITY, - PROGRAM_CHANGE, - PROGRAM_STATE, - REASON_FOR_HALT, - RELIABILITY, - STATE, - SYSTEM_STATUS, - UNITS, - UNSIGNED_VALUE, - LIFE_SAFETY_MODE, - LIFE_SAFETY_STATE -} BACNET_PROPERTY_STATE_TYPE; - typedef struct { - BACNET_PROPERTY_STATE_TYPE tag; + BACNET_PROPERTY_STATES tag; union { bool booleanValue; BACNET_BINARY_PV binaryValue; @@ -65,6 +48,52 @@ typedef struct { BACNET_UNSIGNED_INTEGER unsignedValue; BACNET_LIFE_SAFETY_MODE lifeSafetyMode; BACNET_LIFE_SAFETY_STATE lifeSafetyState; + BACNET_RESTART_REASON restartReason; + BACNET_DOOR_ALARM_STATE doorAlarmState; + BACNET_ACTION action; + BACNET_DOOR_SECURED_STATUS doorSecuredStatus; + BACNET_DOOR_STATUS doorStatus; + BACNET_DOOR_VALUE doorValue; + BACNET_FILE_ACCESS_METHOD fileAccessMethod; + BACNET_LOCK_STATUS lockStatus; + BACNET_LIFE_SAFETY_OPERATION lifeSafetyOperation; + BACNET_MAINTENANCE maintenance; + BACNET_NODE_TYPE nodeType; + BACNET_NOTIFY_TYPE notifyType; + BACNET_SECURITY_LEVEL securityLevel; + BACNET_SHED_STATE shedState; + BACNET_SILENCED_STATE silencedState; + BACNET_ACCESS_EVENT accessEvent; + BACNET_ACCESS_ZONE_OCCUPANCY_STATE zoneOccupancyState; + BACNET_ACCESS_CREDENTIAL_DISABLE_REASON accessCredDisableReason; + BACNET_ACCESS_CREDENTIAL_DISABLE accessCredDisable; + BACNET_AUTHENTICATION_STATUS authenticationStatus; + BACNET_BACKUP_STATE backupState; + BACNET_WRITE_STATUS writeStatus; + BACNET_LIGHTING_IN_PROGRESS lightingInProgress; + BACNET_LIGHTING_OPERATION lightingOperation; + BACNET_LIGHTING_TRANSITION lightingTransition; + int32_t integerValue; + BACNET_BINARY_LIGHTING_PV binaryLightingValue; + BACNET_TIMER_STATE timerState; + BACNET_TIMER_TRANSITION timerTransition; + BACNET_IP_MODE bacnetIPMode; + BACNET_PORT_COMMAND networkPortCommand; + BACNET_PORT_TYPE networkType; + BACNET_PORT_QUALITY networkNumberQuality; + BACNET_ESCALATOR_OPERATION_DIRECTION escalatorOperationDirection; + BACNET_ESCALATOR_FAULT escalatorFault; + BACNET_ESCALATOR_MODE escalatorMode; + BACNET_LIFT_CAR_DIRECTION liftCarDirection; + BACNET_LIFT_CAR_DOOR_COMMAND liftCarDoorCommand; + BACNET_LIFT_CAR_DRIVE_STATUS liftCarDriveStatus; + BACNET_LIFT_CAR_MODE liftCarMode; + BACNET_LIFT_GROUP_MODE liftGroupMode; + BACNET_LIFT_FAULT liftFault; + BACNET_PROTOCOL_LEVEL protocolLevel; + BACNET_AUDIT_LEVEL auditLevel; + BACNET_AUDIT_OPERATION auditOperation; + uint32_t extendedValue; } state; } BACNET_PROPERTY_STATE; @@ -72,6 +101,12 @@ typedef struct { extern "C" { #endif /* __cplusplus */ + BACNET_STACK_EXPORT + int bacapp_property_state_decode( + uint8_t *apdu, + uint32_t apdu_size, + BACNET_PROPERTY_STATE *value); + BACNET_STACK_EXPORT int bacapp_decode_property_state( uint8_t * apdu, diff --git a/test/bacnet/bacpropstates/src/main.c b/test/bacnet/bacpropstates/src/main.c index 9241d65c..9cbf20ba 100644 --- a/test/bacnet/bacpropstates/src/main.c +++ b/test/bacnet/bacpropstates/src/main.c @@ -25,118 +25,189 @@ ZTEST(bacpropstates_tests, testPropStates) void testPropStates(void) #endif { - BACNET_PROPERTY_STATE inData; - BACNET_PROPERTY_STATE outData; - uint8_t appMsg[MAX_APDU]; - int inLen; - int outLen; + BACNET_PROPERTY_STATE data = { 0 }; + BACNET_PROPERTY_STATE test_data = { 0 }; + uint8_t apdu[MAX_APDU] = { 0 }; + int apdu_len = 0; + int test_len = 0; - inData.tag = BOOLEAN_VALUE; - inData.state.booleanValue = true; + /*************************************************/ + data.tag = PROP_STATE_BOOLEAN_VALUE; + data.state.booleanValue = true; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal( + test_len, apdu_len, "apdu_len=%d test_len=%d", apdu_len, test_len); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.booleanValue, test_data.state.booleanValue, NULL); - inLen = bacapp_encode_property_state(appMsg, &inData); + /*************************************************/ + data.tag = PROP_STATE_BINARY_VALUE; + data.state.binaryValue = BINARY_ACTIVE; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.binaryValue, test_data.state.binaryValue, NULL); - memset(&outData, 0, sizeof(outData)); + /*************************************************/ + data.tag = PROP_STATE_EVENT_TYPE; + data.state.eventType = EVENT_BUFFER_READY; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.eventType, test_data.state.eventType, NULL); - outLen = bacapp_decode_property_state(appMsg, &outData); + /*************************************************/ + data.tag = PROP_STATE_POLARITY; + data.state.polarity = POLARITY_REVERSE; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.polarity, test_data.state.polarity, NULL); - zassert_equal(outLen, inLen, NULL); - zassert_equal(inData.tag, outData.tag, NULL); - zassert_equal(inData.state.booleanValue, outData.state.booleanValue, NULL); + /*************************************************/ + data.tag = PROP_STATE_PROGRAM_CHANGE; + data.state.programChange = PROGRAM_REQUEST_RESTART; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal( + data.state.programChange, test_data.state.programChange, NULL); - /**************** - ***************** - ****************/ - inData.tag = BINARY_VALUE; - inData.state.binaryValue = BINARY_ACTIVE; + /*************************************************/ + data.tag = PROP_STATE_PROGRAM_STATE; + data.state.programState = PROGRAM_STATE_HALTED; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.programState, test_data.state.programState, NULL); - inLen = bacapp_encode_property_state(appMsg, &inData); + /*************************************************/ + data.tag = PROP_STATE_REASON_FOR_HALT; + data.state.programError = PROGRAM_ERROR_LOAD_FAILED; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.programError, test_data.state.programError, NULL); - memset(&outData, 0, sizeof(outData)); + /*************************************************/ + data.tag = PROP_STATE_RELIABILITY; + data.state.reliability = RELIABILITY_COMMUNICATION_FAILURE; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.reliability, test_data.state.reliability, NULL); - outLen = bacapp_decode_property_state(appMsg, &outData); + /*************************************************/ + data.tag = PROP_STATE_EVENT_STATE; + data.state.state = EVENT_STATE_FAULT; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.state, test_data.state.state, NULL); - zassert_equal(outLen, inLen, NULL); - zassert_equal(inData.tag, outData.tag, NULL); - zassert_equal(inData.state.binaryValue, outData.state.binaryValue, NULL); + /*************************************************/ + data.tag = PROP_STATE_SYSTEM_STATUS; + data.state.systemStatus = STATUS_OPERATIONAL_READ_ONLY; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.systemStatus, test_data.state.systemStatus, NULL); - /**************** - ***************** - ****************/ - inData.tag = EVENT_TYPE; - inData.state.eventType = EVENT_BUFFER_READY; + /*************************************************/ + data.tag = PROP_STATE_UNITS; + data.state.units = UNITS_BARS; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal(data.state.units, test_data.state.units, NULL); - inLen = bacapp_encode_property_state(appMsg, &inData); + /*************************************************/ + data.tag = PROP_STATE_UNSIGNED_VALUE; + data.state.unsignedValue = 0xdeadbeef; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal( + data.state.unsignedValue, test_data.state.unsignedValue, NULL); - memset(&outData, 0, sizeof(outData)); + /*************************************************/ + data.tag = PROP_STATE_LIFE_SAFETY_MODE; + data.state.lifeSafetyMode = LIFE_SAFETY_MODE_ON; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal( + data.state.lifeSafetyMode, test_data.state.lifeSafetyMode, NULL); - outLen = bacapp_decode_property_state(appMsg, &outData); + /*************************************************/ + data.tag = PROP_STATE_LIFE_SAFETY_STATE; + data.state.lifeSafetyState = LIFE_SAFETY_STATE_ABNORMAL; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal( + data.state.lifeSafetyState, test_data.state.lifeSafetyState, NULL); - zassert_equal(outLen, inLen, NULL); - zassert_equal(inData.tag, outData.tag, NULL); - zassert_equal(inData.state.eventType, outData.state.eventType, NULL); + /*************************************************/ + data.tag = PROP_STATE_RESTART_REASON; + data.state.restartReason = RESTART_REASON_COLDSTART; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal( + data.state.restartReason, test_data.state.restartReason, NULL); - /**************** - ***************** - ****************/ - inData.tag = POLARITY; - inData.state.polarity = POLARITY_REVERSE; - - inLen = bacapp_encode_property_state(appMsg, &inData); - - memset(&outData, 0, sizeof(outData)); - - outLen = bacapp_decode_property_state(appMsg, &outData); - - zassert_equal(outLen, inLen, NULL); - zassert_equal(inData.tag, outData.tag, NULL); - zassert_equal(inData.state.polarity, outData.state.polarity, NULL); - - /**************** - ***************** - ****************/ - inData.tag = PROGRAM_CHANGE; - inData.state.programChange = PROGRAM_REQUEST_RESTART; - - inLen = bacapp_encode_property_state(appMsg, &inData); - - memset(&outData, 0, sizeof(outData)); - - outLen = bacapp_decode_property_state(appMsg, &outData); - - zassert_equal(outLen, inLen, NULL); - zassert_equal(inData.tag, outData.tag, NULL); - zassert_equal(inData.state.programChange, outData.state.programChange, NULL); - - /**************** - ***************** - ****************/ - inData.tag = UNSIGNED_VALUE; - inData.state.unsignedValue = 0xdeadbeef; - - inLen = bacapp_encode_property_state(appMsg, &inData); - - memset(&outData, 0, sizeof(outData)); - - outLen = bacapp_decode_property_state(appMsg, &outData); - - zassert_equal(outLen, inLen, NULL); - zassert_equal(inData.tag, outData.tag, NULL); - zassert_equal(inData.state.unsignedValue, outData.state.unsignedValue, NULL); + /*************************************************/ + data.tag = PROP_STATE_DOOR_ALARM_STATE; + data.state.doorAlarmState = DOOR_ALARM_STATE_ALARM; + apdu_len = bacapp_encode_property_state(apdu, &data); + memset(&test_data, 0, sizeof(test_data)); + test_len = bacapp_decode_property_state(apdu, &test_data); + zassert_equal(test_len, apdu_len, NULL); + zassert_equal(data.tag, test_data.tag, NULL); + zassert_equal( + data.state.doorAlarmState, test_data.state.doorAlarmState, NULL); } /** * @} */ - #if defined(CONFIG_ZTEST_NEW_API) ZTEST_SUITE(bacpropstates_tests, NULL, NULL, NULL, NULL, NULL); #else void test_main(void) { - ztest_test_suite(bacpropstates_tests, - ztest_unit_test(testPropStates) - ); + ztest_test_suite(bacpropstates_tests, ztest_unit_test(testPropStates)); ztest_run_test_suite(bacpropstates_tests); } diff --git a/test/bacnet/event/src/main.c b/test/bacnet/event/src/main.c index e7a95eb8..93ca06ee 100644 --- a/test/bacnet/event/src/main.c +++ b/test/bacnet/event/src/main.c @@ -127,7 +127,7 @@ static void testEventEventState(void) data.toState = EVENT_STATE_OFFNORMAL; data.eventType = EVENT_CHANGE_OF_STATE; - data.notificationParams.changeOfState.newState.tag = UNITS; + data.notificationParams.changeOfState.newState.tag = PROP_STATE_UNITS; data.notificationParams.changeOfState.newState.state.units = UNITS_SQUARE_METERS;