dali/bacnet_stack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changed BACnetPropertyStates to support more enumerations. Added apdu size checking on decode. Removed BACnetPropertyStates local enumeration. Increased BACnetPropertyStates codec unit test coverage.

Browse Source
This commit is contained in:
Steve Karg
2024-01-05 16:00:42 -06:00
parent bb081d28da
commit ba4b0ca7c6
6 changed files with 980 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bacnet/bacpropstates.c
+499 -173
View File
@@ -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;