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

Added basic timer object, internal state machine, and unit tests (#1123)

Browse Source 
* Added basic timer object, internal state machine, and unit tests

* Added BACnetTimerStateChangeValue encode, decode, parse, print, and diff with unit tests

* Changed handler of add/remove list element to check if the property is a BACnetLIST

* Added BACnetLIST utility for handling WriteProperty to a list.

* Fixed outlier ReadProperty object handlers to return zero when the RP parameter is NULL.
This commit is contained in:
Steve Karg
2025-11-05 15:11:45 -06:00
committed by GitHub
parent 17259b37f3
commit 4dd13cf199
126 changed files with 5509 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bacnet/bacapp.c
+77 -3
View File
@@ -37,6 +37,7 @@
#include "bacnet/calendar_entry.h"
#include "bacnet/special_event.h"
#include "bacnet/channel_value.h"
#include "bacnet/timer_value.h"
#include "bacnet/basic/sys/platform.h"
#if defined(BACAPP_SCALE)
@@ -528,6 +529,18 @@ int bacapp_encode_application_data(
apdu, &value->type.Channel_Value);
break;
#endif
#if defined(BACAPP_TIMER_VALUE)
case BACNET_APPLICATION_TAG_TIMER_VALUE:
/* BACnetTimerStateChangeValue */
apdu_len = bacnet_timer_value_type_encode(
apdu, &value->type.Timer_Value);
break;
#endif
#if defined(BACAPP_NO_VALUE)
case BACNET_APPLICATION_TAG_NO_VALUE:
apdu_len = bacnet_timer_value_no_value_encode(apdu);
break;
#endif
#if defined(BACAPP_LOG_RECORD)
case BACNET_APPLICATION_TAG_LOG_RECORD:
/* BACnetLogRecord */
@@ -1347,7 +1360,8 @@ int bacapp_known_property_tag(
case PROP_SC_PRIMARY_HUB_CONNECTION_STATUS:
case PROP_SC_FAILOVER_HUB_CONNECTION_STATUS:
return BACNET_APPLICATION_TAG_SC_HUB_CONNECTION_STATUS;
case PROP_STATE_CHANGE_VALUES:
return BACNET_APPLICATION_TAG_TIMER_VALUE;
default:
return -1;
}
@@ -1660,6 +1674,13 @@ int bacapp_decode_application_tag_value(
apdu, apdu_size, &value->type.Channel_Value);
break;
#endif
#if defined(BACAPP_TIMER_VALUE)
case BACNET_APPLICATION_TAG_TIMER_VALUE:
/* BACnetTimerStateChangeValue */
apdu_len = bacnet_timer_value_decode(
apdu, apdu_size, &value->type.Timer_Value);
break;
#endif
#if defined(BACAPP_LOG_RECORD)
case BACNET_APPLICATION_TAG_LOG_RECORD:
/* BACnetLogRecord */
@@ -2440,6 +2461,22 @@ static int bacapp_snprintf_enumerated(
ret_val = bacapp_snprintf(
str, str_len, "%s", bactext_protocol_level_name(value));
break;
case PROP_EVENT_TYPE:
ret_val = bacapp_snprintf(
str, str_len, "%s", bactext_event_type_name(value));
break;
case PROP_NOTIFY_TYPE:
ret_val = bacapp_snprintf(
str, str_len, "%s", bactext_notify_type_name(value));
break;
case PROP_TIMER_STATE:
ret_val = bacapp_snprintf(
str, str_len, "%s", bactext_timer_state_name(value));
break;
case PROP_LAST_STATE_CHANGE:
ret_val = bacapp_snprintf(
str, str_len, "%s", bactext_timer_transition_name(value));
break;
default:
ret_val =
bacapp_snprintf(str, str_len, "%lu", (unsigned long)value);
@@ -3981,6 +4018,17 @@ int bacapp_snprintf_value(
str, str_len, &value->type.Channel_Value);
break;
#endif
#if defined(BACAPP_TIMER_VALUE)
case BACNET_APPLICATION_TAG_TIMER_VALUE:
ret_val = bacnet_timer_value_to_ascii(
&value->type.Timer_Value, str, str_len);
break;
#endif
#if defined(BACAPP_NO_VALUE)
case BACNET_APPLICATION_TAG_NO_VALUE:
ret_val = bacnet_timer_value_no_value_to_ascii(str, str_len);
break;
#endif
#if defined(BACAPP_LOG_RECORD)
case BACNET_APPLICATION_TAG_LOG_RECORD:
ret_val = bacapp_snprintf_log_record(
@@ -4762,15 +4810,28 @@ bool bacapp_parse_application_data(
#endif
#if defined(BACAPP_ACCESS_RULE)
case BACNET_APPLICATION_TAG_ACCESS_RULE:
bacnet_access_rule_from_ascii(&value->type.Access_Rule, argv);
status = bacnet_access_rule_from_ascii(
&value->type.Access_Rule, argv);
break;
#endif
#if defined(BACAPP_CHANNEL_VALUE)
case BACNET_APPLICATION_TAG_CHANNEL_VALUE:
bacnet_channel_value_from_ascii(
status = bacnet_channel_value_from_ascii(
&value->type.Channel_Value, argv);
break;
#endif
#if defined(BACAPP_TIMER_VALUE)
case BACNET_APPLICATION_TAG_TIMER_VALUE:
status = bacnet_timer_value_from_ascii(
&value->type.Timer_Value, argv);
break;
#endif
#if defined(BACAPP_NO_VALUE)
case BACNET_APPLICATION_TAG_NO_VALUE:
status =
bacnet_timer_value_no_value_from_ascii(&value->tag, argv);
break;
#endif
#if defined(BACAPP_LOG_RECORD)
case BACNET_APPLICATION_TAG_LOG_RECORD:
status = bacnet_log_record_datum_from_ascii(
@@ -5484,6 +5545,19 @@ bool bacapp_same_value(
&test_value->type.Channel_Value);
break;
#endif
#if defined(BACAPP_TIMER_VALUE)
case BACNET_APPLICATION_TAG_TIMER_VALUE:
status = bacnet_timer_value_same(
&value->type.Timer_Value, &test_value->type.Timer_Value);
break;
#endif
#if defined(BACAPP_NO_VALUE)
case BACNET_APPLICATION_TAG_NO_VALUE:
if (value->tag == test_value->tag) {
status = true;
}
break;
#endif
#if defined(BACAPP_LOG_RECORD)
case BACNET_APPLICATION_TAG_LOG_RECORD:
status = bacnet_log_record_same(
src/bacnet/bacapp.h
+10 -1
View File
@@ -30,6 +30,7 @@
#include "bacnet/calendar_entry.h"
#include "bacnet/special_event.h"
#include "bacnet/channel_value.h"
#include "bacnet/timer_value.h"
#include "bacnet/secure_connect.h"
#ifndef BACAPP_PRINT_ENABLED
@@ -67,7 +68,12 @@ typedef struct BACnet_Application_Data_Value {
uint8_t context_tag; /* only used for context specific data */
uint8_t tag; /* application tag data type */
union {
/* NULL - not needed as it is encoded in the tag alone */
#if defined(BACAPP_NULL)
/* no value needed because it is encoded in the tag alone */
#endif
#if defined(BACAPP_NO_VALUE)
/* no value needed because it is encoded in the tag alone */
#endif
#if defined(BACAPP_BOOLEAN)
bool Boolean;
#endif
@@ -170,6 +176,9 @@ typedef struct BACnet_Application_Data_Value {
#if defined(BACAPP_CHANNEL_VALUE)
BACNET_CHANNEL_VALUE Channel_Value;
#endif
#if defined(BACAPP_TIMER_VALUE)
BACNET_TIMER_STATE_CHANGE_VALUE Timer_Value;
#endif
#if defined(BACAPP_LOG_RECORD)
BACNET_LOG_RECORD Log_Record;
#endif
src/bacnet/bacdcode.c
+268 -1
View File
@@ -1426,6 +1426,44 @@ int bacnet_null_application_decode(const uint8_t *apdu, uint32_t apdu_size)
return apdu_len;
}
/**
* @brief Decode the Null Value when context encoded
* From clause 20.2.2 Encoding of a Null Value
* and 20.2.1 General Rules for Encoding BACnet Tags
*
* @param apdu - buffer to hold the bytes
* @param apdu_size - number of bytes in the buffer to decode
* @param tag_value - context tag number expected
*
* @return number of bytes decoded, zero if tag mismatch,
* or #BACNET_STATUS_ERROR (-1) if malformed
*/
int bacnet_null_context_decode(
const uint8_t *apdu, uint32_t apdu_size, uint8_t tag_value)
{
int apdu_len = BACNET_STATUS_ERROR;
int len = 0;
BACNET_TAG tag = { 0 };
if (apdu_size == 0) {
return 0;
}
len = bacnet_tag_decode(apdu, apdu_size, &tag);
if (len > 0) {
if (tag.context && (tag.number == tag_value)) {
if (tag.len_value_type == 0) {
apdu_len = len;
} else {
apdu_len = BACNET_STATUS_ERROR;
}
} else {
apdu_len = 0;
}
}
return apdu_len;
}
/**
* @brief Reverse the bits of the given byte.
*
@@ -4819,6 +4857,157 @@ int decode_context_date(
return len;
}
/**
* @brief Encode a context tagged BACnetTimerStateChangeValue
* with a constructed value type
* @param apdu buffer to be encoded, or NULL for length
* @param tag_value - context tag number to encapsulate the value
* @param value The value to be encoded.
* @return the number of apdu bytes encoded
*/
int bacnet_constructed_value_context_encode(
uint8_t *apdu,
uint8_t tag_value,
const BACNET_CONSTRUCTED_VALUE_TYPE *value)
{
int len = 0;
int apdu_len = 0;
if (value) {
len = encode_opening_tag(apdu, tag_value);
apdu_len += len;
if (apdu) {
apdu += len;
}
len = value->data_len;
if (apdu) {
memcpy(apdu, value->data, len);
}
apdu_len += len;
if (apdu) {
apdu += len;
}
len = encode_closing_tag(apdu, tag_value);
apdu_len += len;
}
return apdu_len;
}
/**
* @brief Decodes a constructed value type of a given length
* @param apdu - the APDU buffer to decode
* @param apdu_size - number of bytes in the buffer to decode
* @param len_value - number of bytes in the constructed value data
* @param value - the value where the decoded data is copied into,
* or NULL for getting the length
* @return number of bytes decoded (0..N), or BACNET_STATUS_ERROR on error
*/
int bacnet_constructed_value_decode(
const uint8_t *apdu,
uint32_t apdu_size,
uint32_t len_value,
BACNET_CONSTRUCTED_VALUE_TYPE *value)
{
if (len_value <= apdu_size) {
if (value) {
value->data_len = len_value;
memcpy(value->data, apdu, len_value);
}
} else {
return BACNET_STATUS_ERROR;
}
return (int)len_value;
}
/**
* @brief Decodes a context tagged constructed value type
* @param apdu - the APDU buffer
* @param apdu_size - the APDU buffer size
* @param tag_value - context tag number expected
* @param value - the value where the decoded data is copied into
* @return length of the APDU buffer decoded, or BACNET_STATUS_ERROR
*/
int bacnet_constructed_value_context_decode(
const uint8_t *apdu,
uint32_t apdu_size,
uint8_t tag_number,
BACNET_CONSTRUCTED_VALUE_TYPE *value)
{
int apdu_len = 0;
int len, len_value;
if (!bacnet_is_opening_tag_number(
&apdu[apdu_len], apdu_size - apdu_len, tag_number, &len)) {
return BACNET_STATUS_ERROR;
}
/* find the matching closing tag to learn the length*/
len_value =
bacnet_enclosed_data_length(&apdu[apdu_len], apdu_size - apdu_len);
/* now update apdu_len with the opening tag length */
apdu_len += len;
/* constructed value */
len = bacnet_constructed_value_decode(
&apdu[apdu_len], apdu_size - apdu_len, len_value, NULL);
if (len < 0) {
return BACNET_STATUS_ERROR;
}
if (value) {
if (len <= sizeof(value->data)) {
len = bacnet_constructed_value_decode(
&apdu[apdu_len], apdu_size - apdu_len, len_value, value);
} else {
return BACNET_STATUS_ERROR;
}
}
apdu_len += len;
if (!bacnet_is_closing_tag_number(
&apdu[apdu_len], apdu_size - apdu_len, tag_number, &len)) {
return BACNET_STATUS_ERROR;
}
apdu_len += len;
return apdu_len;
}
/**
* @brief Compare two constructed values
* @param value1 - the first value to compare
* @param value2 - the second value to compare
* @return true if value1 is the same as value2 up to the length of the data
*/
bool bacnet_constructed_value_same(
const BACNET_CONSTRUCTED_VALUE_TYPE *value1,
const BACNET_CONSTRUCTED_VALUE_TYPE *value2)
{
if (value1->data_len != value2->data_len) {
return false;
}
if (value1->data_len > sizeof(value1->data)) {
return false;
}
if (memcmp(value1->data, value2->data, value1->data_len) == 0) {
return true;
}
return false;
}
/**
* @brief Copy one constructed value to another
* @param dest - the destination value
* @param src - the source value to copy to the destination
* @return true if the value is copied from src to dst
*/
bool bacnet_constructed_value_copy(
BACNET_CONSTRUCTED_VALUE_TYPE *dest,
const BACNET_CONSTRUCTED_VALUE_TYPE *src)
{
memcpy(dest, src, sizeof(BACNET_CONSTRUCTED_VALUE_TYPE));
return true;
}
/**
* Encode a simple ACK and returns the number of apdu bytes consumed.
*
@@ -4917,7 +5106,7 @@ int bacnet_array_encode(
* @param array_index [in] array index to be decoded
* 0 for the array size
* 1 to n for individual array members
* BACNET_ARRAY_ALL for the full array to be read.
* BACNET_ARRAY_ALL for the full array to be written.
* @param decode_function [in] function to decode one property array element and
* determine the length
* @param write_function [in] function to write one property array element with
@@ -4992,3 +5181,81 @@ BACNET_ERROR_CODE bacnet_array_write(
return error_code;
}
/**
* @brief Decode a BACnetList property value and call a function for each
* element
* @param object_instance [in] BACnet network port object instance number
* @param array_index [in] array index to be decoded
* 0 for the list size - not permitted for a list
* 1 to n for individual array members - not permitted for a list
* BACNET_ARRAY_ALL for the full list to be written
* @param decode_function [in] function to decode one property list element and
* determine the length
* @param add_function [in] function to add one property list element with
* the encoded value
* @param max_elements [in] number of elements in the list
* @param apdu [out] Buffer in which the APDU contents are built.
* @param max_apdu [in] Max length of the APDU buffer.
* @return BACNET_ERROR_CODE value
*/
BACNET_ERROR_CODE bacnet_list_write(
uint32_t object_instance,
BACNET_ARRAY_INDEX array_index,
bacnet_array_property_element_decode_function decode_function,
bacnet_list_property_element_add_function add_function,
BACNET_UNSIGNED_INTEGER array_size,
uint8_t *apdu,
size_t apdu_size)
{
int len = 0;
BACNET_ERROR_CODE error_code = ERROR_CODE_SUCCESS;
size_t apdu_len;
BACNET_ARRAY_INDEX count = 0;
if (array_index == BACNET_ARRAY_ALL) {
/* verify all elements will fit in the BACnetLIST */
apdu_len = 0;
while (apdu_len < apdu_size) {
len = decode_function(
object_instance, &apdu[apdu_len], apdu_size - apdu_len);
if (len > 0) {
apdu_len += len;
count++;
} else if (len == 0) {
/* end of list - it fits! */
break;
} else {
/* bad decode */
error_code = ERROR_CODE_ABORT_OTHER;
}
}
if (error_code == ERROR_CODE_SUCCESS) {
if (count > array_size) {
/* maybe? what about duplicates? */
error_code = ERROR_CODE_NO_SPACE_TO_WRITE_PROPERTY;
}
}
if (error_code == ERROR_CODE_SUCCESS) {
/* empty the list */
(void)add_function(object_instance, NULL, 0);
/* add each unique element */
apdu_len = 0;
while (apdu_len < apdu_size) {
len = decode_function(
object_instance, &apdu[apdu_len], apdu_size - apdu_len);
error_code =
add_function(object_instance, &apdu[apdu_len], len);
if (error_code != ERROR_CODE_SUCCESS) {
break;
}
apdu_len += len;
}
}
} else {
/* array-index was specified */
error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY;
}
return error_code;
}
src/bacnet/bacdcode.h
+59
View File
@@ -57,6 +57,26 @@ typedef BACNET_ERROR_CODE (*bacnet_array_property_element_write_function)(
uint8_t *application_data,
size_t application_data_len);
/**
* @brief Add a unique element to a BACnetLIST property
* @param object_instance [in] BACnet network port object instance number
* @param application_data [in] encoded element value
* @param application_data_len [in] The size of the encoded element value
* @return BACNET_ERROR_CODE value
*/
typedef BACNET_ERROR_CODE (*bacnet_list_property_element_add_function)(
uint32_t object_instance,
uint8_t *application_data,
size_t application_data_len);
#ifndef BACNET_CONSTRUCTED_VALUE_SIZE
#define BACNET_CONSTRUCTED_VALUE_SIZE MAX_APDU
#endif
typedef struct BACnet_Constructed_Value_Type {
uint8_t data[BACNET_CONSTRUCTED_VALUE_SIZE];
uint16_t data_len;
} BACNET_CONSTRUCTED_VALUE_TYPE;
typedef struct BACnetTag {
uint8_t number;
bool application : 1;
@@ -164,6 +184,9 @@ BACNET_STACK_EXPORT
int encode_context_null(uint8_t *apdu, uint8_t tag_number);
BACNET_STACK_EXPORT
int bacnet_null_application_decode(const uint8_t *apdu, uint32_t apdu_size);
BACNET_STACK_EXPORT
int bacnet_null_context_decode(
const uint8_t *apdu, uint32_t apdu_size, uint8_t tag_value);
/* from clause 20.2.3 Encoding of a Boolean Value */
BACNET_STACK_EXPORT
@@ -618,6 +641,32 @@ int bacnet_date_context_decode(
uint8_t tag_value,
BACNET_DATE *value);
BACNET_STACK_EXPORT
int bacnet_constructed_value_context_encode(
uint8_t *apdu,
uint8_t tag_value,
const BACNET_CONSTRUCTED_VALUE_TYPE *value);
BACNET_STACK_EXPORT
int bacnet_constructed_value_decode(
const uint8_t *apdu,
uint32_t apdu_size,
uint32_t len_value,
BACNET_CONSTRUCTED_VALUE_TYPE *value);
BACNET_STACK_EXPORT
int bacnet_constructed_value_context_decode(
const uint8_t *apdu,
uint32_t apdu_size,
uint8_t tag_value,
BACNET_CONSTRUCTED_VALUE_TYPE *value);
BACNET_STACK_EXPORT
bool bacnet_constructed_value_same(
const BACNET_CONSTRUCTED_VALUE_TYPE *value1,
const BACNET_CONSTRUCTED_VALUE_TYPE *value2);
BACNET_STACK_EXPORT
bool bacnet_constructed_value_copy(
BACNET_CONSTRUCTED_VALUE_TYPE *dest,
const BACNET_CONSTRUCTED_VALUE_TYPE *src);
/* from clause 20.1.2.4 max-segments-accepted */
/* and clause 20.1.2.5 max-APDU-length-accepted */
/* returns the encoded octet */
@@ -651,6 +700,16 @@ BACNET_ERROR_CODE bacnet_array_write(
uint8_t *apdu,
size_t apdu_size);
BACNET_STACK_EXPORT
BACNET_ERROR_CODE bacnet_list_write(
uint32_t object_instance,
BACNET_ARRAY_INDEX array_index,
bacnet_array_property_element_decode_function decode_function,
bacnet_list_property_element_add_function add_function,
BACNET_UNSIGNED_INTEGER max_elements,
uint8_t *apdu,
size_t apdu_size);
/* from clause 20.2.1.2 Tag Number */
/* true if extended tag numbering is used */
#define IS_EXTENDED_TAG_NUMBER(x) (((x) & 0xF0) == 0xF0)
src/bacnet/bacenum.h
+9 -2
View File
@@ -1683,7 +1683,13 @@ typedef enum {
/* BACnetChannelValue */
BACNET_APPLICATION_TAG_CHANNEL_VALUE,
/* BACnetLogRecord */
BACNET_APPLICATION_TAG_LOG_RECORD
BACNET_APPLICATION_TAG_LOG_RECORD,
/* BACnetTimerStateChangeValue */
BACNET_APPLICATION_TAG_TIMER_VALUE,
/* no-value - context tagged null */
BACNET_APPLICATION_TAG_NO_VALUE,
/* ABSTRACT-SYNTAX - constructed value */
BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX
} BACNET_APPLICATION_TAG;
/* note: these are not the real values, */
@@ -2966,7 +2972,8 @@ typedef enum BACnetTimerTransition {
TIMER_TRANSITION_RUNNING_TO_EXPIRED = 4,
TIMER_TRANSITION_FORCED_TO_EXPIRED = 5,
TIMER_TRANSITION_EXPIRED_TO_IDLE = 6,
TIMER_TRANSITION_EXPIRED_TO_RUNNING = 7
TIMER_TRANSITION_EXPIRED_TO_RUNNING = 7,
TIMER_TRANSITION_MAX = 8
} BACNET_TIMER_TRANSITION;
typedef enum BACnetEscalatorFault {
src/bacnet/bactext.c
+48 -2
View File
@@ -177,6 +177,9 @@ INDTEXT_DATA bacnet_application_tag_names[] = {
{ BACNET_APPLICATION_TAG_SHED_LEVEL, "BACnetShedLevel" },
{ BACNET_APPLICATION_TAG_ACCESS_RULE, "BACnetAccessRule" },
{ BACNET_APPLICATION_TAG_CHANNEL_VALUE, "BACnetChannelValue" },
{ BACNET_APPLICATION_TAG_LOG_RECORD, "BACnetLogRecord" },
{ BACNET_APPLICATION_TAG_NO_VALUE, "BACnetNoValue" },
{ BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX, "ABSTRACT-SYNTAX" },
{ 0, NULL }
};
@@ -225,7 +228,7 @@ INDTEXT_DATA bacnet_object_type_names[] = {
{ OBJECT_LOAD_CONTROL, "load-control" },
{ OBJECT_STRUCTURED_VIEW, "structured-view" },
{ OBJECT_ACCESS_DOOR, "access-door" },
{ OBJECT_LIGHTING_OUTPUT, "lighting-output" },
{ OBJECT_TIMER, "timer" },
{ OBJECT_ACCESS_CREDENTIAL, "access-credential" },
{ OBJECT_ACCESS_POINT, "access-point" },
{ OBJECT_ACCESS_RIGHTS, "access-rights" },
@@ -297,7 +300,7 @@ INDTEXT_DATA bacnet_object_type_names_capitalized[] = {
{ OBJECT_LOAD_CONTROL, "Load Control" },
{ OBJECT_STRUCTURED_VIEW, "Structured View" },
{ OBJECT_ACCESS_DOOR, "Access Door" },
{ OBJECT_LIGHTING_OUTPUT, "Lighting Output" },
{ OBJECT_TIMER, "Timer" },
{ OBJECT_ACCESS_CREDENTIAL, "Access Credential" },
{ OBJECT_ACCESS_POINT, "Access Point" },
{ OBJECT_ACCESS_RIGHTS, "Access Rights" },
@@ -2686,6 +2689,7 @@ const char *bactext_program_request_name(unsigned index)
}
INDTEXT_DATA bactext_program_state_names[] = {
/* BACnetProgramState enumerations */
{ PROGRAM_STATE_IDLE, "idle" },
{ PROGRAM_STATE_LOADING, "loading" },
{ PROGRAM_STATE_RUNNING, "running" },
@@ -2702,6 +2706,7 @@ const char *bactext_program_state_name(unsigned index)
}
INDTEXT_DATA bactext_program_error_names[] = {
/* BACnetProgramError enumerations */
{ PROGRAM_ERROR_NORMAL, "normal" },
{ PROGRAM_ERROR_LOAD_FAILED, "load-failed" },
{ PROGRAM_ERROR_INTERNAL, "internal" },
@@ -2722,6 +2727,39 @@ const char *bactext_program_error_name(unsigned index)
}
}
INDTEXT_DATA bactext_timer_state_names[] = {
/* BACnetTimerState enumerations */
{ TIMER_STATE_IDLE, "idle" },
{ TIMER_STATE_RUNNING, "running" },
{ TIMER_STATE_EXPIRED, "expired" },
{ 0, NULL }
};
const char *bactext_timer_state_name(unsigned index)
{
return indtext_by_index_default(
bactext_timer_state_names, index, ASHRAE_Reserved_String);
}
INDTEXT_DATA bactext_timer_transition_names[] = {
/* BACnetTimerTransition enumerations */
{ TIMER_TRANSITION_NONE, "none" },
{ TIMER_TRANSITION_IDLE_TO_RUNNING, "idle-to-running" },
{ TIMER_TRANSITION_RUNNING_TO_IDLE, "running-to-idle" },
{ TIMER_TRANSITION_RUNNING_TO_RUNNING, "running-to-running" },
{ TIMER_TRANSITION_RUNNING_TO_EXPIRED, "running-to-expired" },
{ TIMER_TRANSITION_FORCED_TO_EXPIRED, "forced-to-expired" },
{ TIMER_TRANSITION_EXPIRED_TO_IDLE, "expired-to-idle" },
{ TIMER_TRANSITION_EXPIRED_TO_RUNNING, "expired-to-running" },
{ 0, NULL }
};
const char *bactext_timer_transition_name(unsigned index)
{
return indtext_by_index_default(
bactext_timer_transition_names, index, ASHRAE_Reserved_String);
}
/**
* @brief For a given enumerated object property string,
* find the enumeration value
@@ -2861,6 +2899,14 @@ bool bactext_object_property_strtoul(
status = bactext_strtoul_index(
bacnet_notify_type_names, search_name, found_index);
break;
case PROP_TIMER_STATE:
status = bactext_strtoul_index(
bactext_timer_state_names, search_name, found_index);
break;
case PROP_LAST_STATE_CHANGE:
status = bactext_strtoul_index(
bactext_timer_transition_names, search_name, found_index);
break;
default:
status = bactext_strtoul(search_name, found_index);
break;
src/bacnet/bactext.h
+5
View File
@@ -200,6 +200,11 @@ const char *bactext_program_state_name(unsigned index);
BACNET_STACK_EXPORT
const char *bactext_program_error_name(unsigned index);
BACNET_STACK_EXPORT
const char *bactext_timer_transition_name(unsigned index);
BACNET_STACK_EXPORT
const char *bactext_timer_state_name(unsigned index);
BACNET_STACK_EXPORT
bool bactext_strtoul(const char *search_name, unsigned *found_index);
BACNET_STACK_EXPORT
src/bacnet/basic/object/bo.c
+1 -1
View File
@@ -1032,7 +1032,7 @@ int Binary_Output_Read_Property(BACNET_READ_PROPERTY_DATA *rpdata)
uint8_t *apdu = NULL;
int apdu_size = 0;
if ((rpdata->application_data == NULL) ||
if ((rpdata == NULL) || (rpdata->application_data == NULL) ||
(rpdata->application_data_len == 0)) {
return 0;
}
src/bacnet/basic/object/client/device-client.c
+3
View File
@@ -1216,6 +1216,9 @@ int Device_Read_Property(BACNET_READ_PROPERTY_DATA *rpdata)
struct special_property_list_t property_list;
#endif
if (!rpdata) {
return 0;
}
/* initialize the default return values */
rpdata->error_class = ERROR_CLASS_OBJECT;
rpdata->error_code = ERROR_CODE_UNKNOWN_OBJECT;
src/bacnet/basic/object/device.c
+9
View File
@@ -58,6 +58,7 @@
#include "bacnet/basic/object/osv.h"
#include "bacnet/basic/object/piv.h"
#include "bacnet/basic/object/time_value.h"
#include "bacnet/basic/object/timer.h"
#include "bacnet/basic/object/channel.h"
#include "bacnet/basic/object/lo.h"
#include "bacnet/basic/object/blo.h"
@@ -207,6 +208,14 @@ static object_functions_t My_Object_Table[] = {
NULL /* COV */, NULL /* COV Clear */, NULL /* Intrinsic Reporting */,
NULL /* Add_List_Element */, NULL /* Remove_List_Element */,
NULL /* Create */, NULL /* Delete */, NULL /* Timer */ },
{ OBJECT_TIMER, Timer_Init, Timer_Count,
Timer_Index_To_Instance, Timer_Valid_Instance,
Timer_Object_Name, Timer_Read_Property,
Timer_Write_Property, Timer_Property_Lists,
NULL /* ReadRangeInfo */, NULL /* Iterator */, NULL /* Value_Lists */,
NULL /* COV */, NULL /* COV Clear */, NULL /* Intrinsic Reporting */,
Timer_Add_List_Element, Timer_Remove_List_Element,
Timer_Create, Timer_Delete, Timer_Task },
{ OBJECT_INTEGER_VALUE, Integer_Value_Init, Integer_Value_Count,
Integer_Value_Index_To_Instance, Integer_Value_Valid_Instance,
Integer_Value_Object_Name, Integer_Value_Read_Property,
src/bacnet/basic/object/nc.c
+12 -4
View File
@@ -803,11 +803,15 @@ int Notification_Class_Add_List_Element(BACNET_LIST_ELEMENT_DATA *list_element)
return BACNET_STATUS_ABORT;
}
if (list_element->object_property != PROP_RECIPIENT_LIST) {
list_element->error_class = ERROR_CLASS_SERVICES;
list_element->error_code = ERROR_CODE_PROPERTY_IS_NOT_A_LIST;
/* The specified property is currently not modifiable
by the requester.*/
list_element->error_class = ERROR_CLASS_PROPERTY;
list_element->error_code = ERROR_CODE_WRITE_ACCESS_DENIED;
return BACNET_STATUS_ERROR;
}
if (list_element->array_index != BACNET_ARRAY_ALL) {
/* An array index is provided but the property is
not a BACnetARRAY of BACnetLIST.*/
list_element->error_class = ERROR_CLASS_PROPERTY;
list_element->error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY;
return BACNET_STATUS_ERROR;
@@ -963,11 +967,15 @@ int Notification_Class_Remove_List_Element(
return BACNET_STATUS_ABORT;
}
if (list_element->object_property != PROP_RECIPIENT_LIST) {
list_element->error_class = ERROR_CLASS_SERVICES;
list_element->error_code = ERROR_CODE_PROPERTY_IS_NOT_A_LIST;
/* The specified property is currently not modifiable
by the requester.*/
list_element->error_class = ERROR_CLASS_PROPERTY;
list_element->error_code = ERROR_CODE_WRITE_ACCESS_DENIED;
return BACNET_STATUS_ERROR;
}
if (list_element->array_index != BACNET_ARRAY_ALL) {
/* An array index is provided but the property is
not a BACnetARRAY of BACnetLIST.*/
list_element->error_class = ERROR_CLASS_PROPERTY;
list_element->error_code = ERROR_CODE_PROPERTY_IS_NOT_AN_ARRAY;
return BACNET_STATUS_ERROR;
src/bacnet/basic/object/timer.c
+2278
View File
File diff suppressed because it is too large Load Diff
src/bacnet/basic/object/timer.h
+189
View File
@@ -0,0 +1,189 @@
/**
* @file
* @brief API for Timer object type
* @author Steve Karg <skarg@users.sourceforge.net>
* @date October 2025
* @copyright SPDX-License-Identifier: MIT
*/
#ifndef BACNET_BASIC_OBJECT_TIMER_H
#define BACNET_BASIC_OBJECT_TIMER_H
#include <stdbool.h>
#include <stdint.h>
/* BACnet Stack defines - first */
#include "bacnet/bacdef.h"
/* BACnet Stack API */
#include "bacnet/bacerror.h"
#include "bacnet/timer_value.h"
#include "bacnet/wp.h"
#include "bacnet/rp.h"
#include "bacnet/list_element.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Timer_Property_Lists(
const int **pRequired, const int **pOptional, const int **pProprietary);
BACNET_STACK_EXPORT
bool Timer_Valid_Instance(uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Timer_Count(void);
BACNET_STACK_EXPORT
uint32_t Timer_Index_To_Instance(unsigned index);
BACNET_STACK_EXPORT
unsigned Timer_Instance_To_Index(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Object_Name(
uint32_t object_instance, BACNET_CHARACTER_STRING *object_name);
BACNET_STACK_EXPORT
bool Timer_Name_Set(uint32_t object_instance, const char *new_name);
BACNET_STACK_EXPORT
const char *Timer_Name_ASCII(uint32_t object_instance);
BACNET_STACK_EXPORT
int Timer_Read_Property(BACNET_READ_PROPERTY_DATA *rpdata);
BACNET_STACK_EXPORT
bool Timer_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data);
BACNET_STACK_EXPORT
bool Timer_Description(
uint32_t object_instance, BACNET_CHARACTER_STRING *description);
BACNET_STACK_EXPORT
bool Timer_Description_Set(uint32_t instance, const char *new_name);
BACNET_STACK_EXPORT
const char *Timer_Description_ANSI(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Out_Of_Service(uint32_t instance);
BACNET_STACK_EXPORT
void Timer_Out_Of_Service_Set(uint32_t instance, bool oos_flag);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Timer_Reliability(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Reliability_Set(uint32_t object_instance, BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
uint32_t Timer_Present_Value(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Present_Value_Set(uint32_t object_instance, uint32_t value);
BACNET_STACK_EXPORT
BACNET_TIMER_STATE Timer_State(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_State_Set(uint32_t object_instance, BACNET_TIMER_STATE value);
BACNET_STACK_EXPORT
BACNET_TIMER_TRANSITION Timer_Last_State_Change(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Running(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Running_Set(uint32_t object_instance, bool running);
BACNET_STACK_EXPORT
bool Timer_Update_Time(uint32_t object_instance, BACNET_DATE_TIME *bdatetime);
BACNET_STACK_EXPORT
bool Timer_Update_Time_Set(
uint32_t object_instance, BACNET_DATE_TIME *bdatetime);
BACNET_STACK_EXPORT
bool Timer_Expiration_Time(
uint32_t object_instance, BACNET_DATE_TIME *bdatetime);
BACNET_STACK_EXPORT
uint32_t Timer_Initial_Timeout(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Initial_Timeout_Set(uint32_t object_instance, uint32_t value);
BACNET_STACK_EXPORT
uint32_t Timer_Default_Timeout(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Default_Timeout_Set(uint32_t object_instance, uint32_t value);
BACNET_STACK_EXPORT
uint32_t Timer_Min_Pres_Value(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Min_Pres_Value_Set(uint32_t object_instance, uint32_t value);
BACNET_STACK_EXPORT
uint32_t Timer_Max_Pres_Value(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Max_Pres_Value_Set(uint32_t object_instance, uint32_t value);
BACNET_STACK_EXPORT
uint32_t Timer_Resolution(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Resolution_Set(uint32_t object_instance, uint32_t value);
BACNET_STACK_EXPORT
uint8_t Timer_Priority_For_Writing(uint8_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Priority_For_Writing_Set(uint32_t object_instance, uint8_t value);
BACNET_STACK_EXPORT
unsigned Timer_Reference_List_Member_Capacity(uint32_t object_instance);
BACNET_STACK_EXPORT
BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *Timer_Reference_List_Member_Element(
uint32_t object_instance, unsigned list_index);
BACNET_STACK_EXPORT
bool Timer_Reference_List_Member_Element_Set(
uint32_t object_instance,
unsigned index,
const BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pMember);
BACNET_STACK_EXPORT
bool Timer_Reference_List_Member_Element_Add(
uint32_t object_instance,
const BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pNewMember);
BACNET_STACK_EXPORT
bool Timer_Reference_List_Member_Element_Remove(
uint32_t object_instance,
const BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pRemoveMember);
BACNET_STACK_EXPORT
unsigned Timer_Reference_List_Member_Element_Count(uint32_t object_instance);
BACNET_STACK_EXPORT
BACNET_TIMER_STATE_CHANGE_VALUE *Timer_State_Change_Value(
uint32_t object_instance, BACNET_TIMER_TRANSITION transition);
BACNET_STACK_EXPORT
bool Timer_State_Change_Value_Set(
uint32_t object_instance,
BACNET_TIMER_TRANSITION transition,
BACNET_TIMER_STATE_CHANGE_VALUE *value);
BACNET_STACK_EXPORT
void Timer_Task(uint32_t object_instance, uint16_t milliseconds);
BACNET_STACK_EXPORT
void Timer_Write_Property_Internal_Callback_Set(write_property_function cb);
BACNET_STACK_EXPORT
int Timer_Add_List_Element(BACNET_LIST_ELEMENT_DATA *list_element);
BACNET_STACK_EXPORT
int Timer_Remove_List_Element(BACNET_LIST_ELEMENT_DATA *list_element);
BACNET_STACK_EXPORT
uint32_t Timer_Create(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Timer_Delete(uint32_t object_instance);
BACNET_STACK_EXPORT
void Timer_Cleanup(void);
BACNET_STACK_EXPORT
void Timer_Init(void);
/* API for the program requests
note: return value is 0 for success, non-zero for failure
*/
BACNET_STACK_EXPORT
void *Timer_Context_Get(uint32_t object_instance);
BACNET_STACK_EXPORT
void Timer_Context_Set(uint32_t object_instance, void *context);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
src/bacnet/basic/server/bacnet_device.c
+45 -4
View File
@@ -53,6 +53,7 @@
#include "bacnet/basic/object/csv.h"
#include "bacnet/basic/object/iv.h"
#include "bacnet/basic/object/time_value.h"
#include "bacnet/basic/object/timer.h"
#include "bacnet/basic/object/channel.h"
#include "bacnet/basic/object/program.h"
#include "bacnet/basic/object/lo.h"
@@ -129,6 +130,7 @@
defined(CONFIG_BACNET_BASIC_OBJECT_FILE) || \
defined(CONFIG_BACNET_BASIC_OBJECT_STRUCTURED_VIEW) || \
defined(CONFIG_BACNET_BASIC_OBJECT_BITSTRING_VALUE) || \
defined(CONFIG_BACNET_BASIC_OBJECT_TIMER) || \
defined(CONFIG_BACNET_BASIC_OBJECT_PROGRAM) || \
defined(CONFIG_BACNET_BASIC_OBJECT_CHARACTERSTRING_VALUE))
#define CONFIG_BACNET_BASIC_OBJECT_ALL
@@ -158,6 +160,7 @@
#define CONFIG_BACNET_BASIC_OBJECT_FILE
#define CONFIG_BACNET_BASIC_OBJECT_STRUCTURED_VIEW
#define CONFIG_BACNET_BASIC_OBJECT_BITSTRING_VALUE
#define CONFIG_BACNET_BASIC_OBJECT_TIMER
#define CONFIG_BACNET_BASIC_OBJECT_PROGRAM
#define CONFIG_BACNET_BASIC_OBJECT_CHARACTERSTRING_VALUE
#endif
@@ -185,6 +188,10 @@
#undef CONFIG_BACNET_BASIC_OBJECT_NETWORK_PORT
#warning "Network Port is configured, but BACnet Protocol Revision < 17"
#endif
#ifdef CONFIG_BACNET_BASIC_OBJECT_TIMER
#undef CONFIG_BACNET_BASIC_OBJECT_TIMER
#warning "Timer is configured, but BACnet Protocol Revision < 17"
#endif
#endif
#if (BACNET_PROTOCOL_REVISION < 24)
@@ -750,6 +757,28 @@ static object_functions_t My_Object_Table[] = {
CharacterString_Value_Delete,
NULL /* Timer */ },
#endif
#if defined(CONFIG_BACNET_BASIC_OBJECT_TIMER)
{ OBJECT_TIMER,
Timer_Init,
Timer_Count,
Timer_Index_To_Instance,
Timer_Valid_Instance,
Timer_Object_Name,
Timer_Read_Property,
Timer_Write_Property,
Timer_Property_Lists,
NULL /* ReadRangeInfo */,
NULL /* Iterator */,
NULL /* Value_Lists */,
NULL /* COV */,
NULL /* COV Clear */,
NULL /* Intrinsic Reporting */,
Timer_Add_List_Element,
Timer_Remove_List_Element,
Timer_Create,
Timer_Delete,
Timer_Task },
#endif
#if defined(CONFIG_BACNET_BASIC_OBJECT_PROGRAM)
{ OBJECT_BITSTRING_VALUE,
Program_Init,
@@ -1783,8 +1812,16 @@ uint32_t Device_Interval_Offset(void)
}
#endif
/* return the length of the apdu encoded or BACNET_STATUS_ERROR for error or
BACNET_STATUS_ABORT for abort message */
/**
* ReadProperty handler for this object. For the given ReadProperty
* data, the application_data is loaded or the error flags are set.
*
* @param rpdata - BACNET_READ_PROPERTY_DATA data, including
* requested data and space for the reply, or error response.
*
* @return number of APDU bytes in the response, zero if no data, or
* BACNET_STATUS_ERROR on error.
*/
int Device_Read_Property_Local(BACNET_READ_PROPERTY_DATA *rpdata)
{
int apdu_len = 0; /* return value */
@@ -2007,7 +2044,8 @@ int Device_Read_Property_Local(BACNET_READ_PROPERTY_DATA *rpdata)
* @param pObject - object table
* @param rpdata [in,out] Structure with the requested Object & Property info
* on entry, and APDU message on return.
* @return The length of the APDU on success, else BACNET_STATUS_ERROR
* @return number of APDU bytes in the response, zero if no data, or
* BACNET_STATUS_ERROR on error.
*/
static int Read_Property_Common(
const struct object_functions *pObject, BACNET_READ_PROPERTY_DATA *rpdata)
@@ -2019,7 +2057,7 @@ static int Read_Property_Common(
struct special_property_list_t property_list;
#endif
if ((rpdata->application_data == NULL) ||
if ((rpdata == NULL) || (rpdata->application_data == NULL) ||
(rpdata->application_data_len == 0)) {
return 0;
}
@@ -2061,6 +2099,9 @@ int Device_Read_Property(BACNET_READ_PROPERTY_DATA *rpdata)
int apdu_len = BACNET_STATUS_ERROR;
struct object_functions *pObject = NULL;
if (!rpdata) {
return 0;
}
/* initialize the default return values */
rpdata->error_class = ERROR_CLASS_OBJECT;
rpdata->error_code = ERROR_CODE_UNKNOWN_OBJECT;
src/bacnet/basic/service/h_list_element.c
+35 -20
View File
@@ -52,7 +52,7 @@ void handler_add_list_element(
BACNET_LIST_ELEMENT_DATA list_element = { 0 };
BACNET_NPDU_DATA npdu_data;
BACNET_ADDRESS my_address;
int len = 0;
int len = 0, err = 0;
bool status = true;
int pdu_len = 0;
int bytes_sent = 0;
@@ -102,7 +102,15 @@ void handler_add_list_element(
status = false;
}
if (status) {
if (Device_Add_List_Element(&list_element) >= 0) {
if (!property_list_bacnet_list_member(
list_element.object_type, list_element.object_property)) {
list_element.error_class = ERROR_CLASS_SERVICES;
list_element.error_code = ERROR_CODE_PROPERTY_IS_NOT_A_LIST;
err = BACNET_STATUS_ERROR;
} else {
err = Device_Add_List_Element(&list_element);
}
if (err == BACNET_STATUS_OK) {
len = encode_simple_ack(
&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id,
SERVICE_CONFIRMED_ADD_LIST_ELEMENT);
@@ -153,7 +161,7 @@ void handler_remove_list_element(
BACNET_LIST_ELEMENT_DATA list_element = { 0 };
BACNET_NPDU_DATA npdu_data;
BACNET_ADDRESS my_address;
int len = 0;
int len = 0, err = BACNET_STATUS_OK;
bool status = true;
int pdu_len = 0;
int bytes_sent = 0;
@@ -192,28 +200,35 @@ void handler_remove_list_element(
(long)list_element.array_index);
} else {
debug_print("RemoveListElement: Unable to decode request!\n");
/* bad decoding or something we didn't understand - send an abort */
err = BACNET_STATUS_ABORT;
}
/* bad decoding or something we didn't understand - send an abort */
if (len <= 0) {
if (len > 0) {
if (!property_list_bacnet_list_member(
list_element.object_type, list_element.object_property)) {
list_element.error_class = ERROR_CLASS_SERVICES;
list_element.error_code = ERROR_CODE_PROPERTY_IS_NOT_A_LIST;
err = BACNET_STATUS_ERROR;
} else {
err = Device_Remove_List_Element(&list_element);
}
}
if (err == BACNET_STATUS_OK) {
len = encode_simple_ack(
&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id,
SERVICE_CONFIRMED_REMOVE_LIST_ELEMENT);
debug_print("RemoveListElement: Sending Simple Ack!\n");
} else if (err == BACNET_STATUS_ABORT) {
len = abort_encode_apdu(
&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id,
ABORT_REASON_OTHER, true);
debug_print("RemoveListElement: Bad Encoding. Sending Abort!\n");
status = false;
}
if (status) {
if (Device_Remove_List_Element(&list_element) >= 0) {
len = encode_simple_ack(
&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id,
SERVICE_CONFIRMED_REMOVE_LIST_ELEMENT);
debug_print("RemoveListElement: Sending Simple Ack!\n");
} else {
len = bacerror_encode_apdu(
&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id,
SERVICE_CONFIRMED_REMOVE_LIST_ELEMENT,
list_element.error_class, list_element.error_code);
debug_print("RemoveListElement: Sending Error!\n");
}
} else {
len = bacerror_encode_apdu(
&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id,
SERVICE_CONFIRMED_REMOVE_LIST_ELEMENT, list_element.error_class,
list_element.error_code);
debug_print("RemoveListElement: Sending Error!\n");
}
}
/* Send PDU */
src/bacnet/config.h
+6
View File
@@ -244,6 +244,8 @@
defined(BACAPP_SHED_LEVEL) || \
defined(BACAPP_ACCESS_RULE) || \
defined(BACAPP_CHANNEL_VALUE) || \
defined(BACAPP_TIMER_VALUE) || \
defined(BACAPP_NO_VALUE) || \
defined(BACAPP_LOG_RECORD) || \
defined(BACAPP_SECURE_CONNECT) || \
defined(BACAPP_TYPES_EXTRA))
@@ -294,6 +296,8 @@
#define BACAPP_SHED_LEVEL
#define BACAPP_ACCESS_RULE
#define BACAPP_CHANNEL_VALUE
#define BACAPP_TIMER_VALUE
#define BACAPP_NO_VALUE
#define BACAPP_LOG_RECORD
#define BACAPP_SECURE_CONNECT
#endif
@@ -321,6 +325,8 @@
defined(BACAPP_SHED_LEVEL) || \
defined(BACAPP_ACCESS_RULE) || \
defined(BACAPP_CHANNEL_VALUE) || \
defined(BACAPP_TIMER_VALUE) || \
defined(BACAPP_NO_VALUE) || \
defined(BACAPP_LOG_RECORD)
#define BACAPP_COMPLEX_TYPES
#endif
src/bacnet/datetime.c
+75 -4
View File
@@ -613,13 +613,12 @@ void datetime_add_minutes(BACNET_DATE_TIME *bdatetime, int32_t minutes)
uint32_t bdatetime_days = 0;
int32_t days = 0;
/* convert bdatetime to seconds and days */
/* convert bdatetime to minutes and days */
bdatetime_minutes =
datetime_hms_to_seconds_since_midnight(
bdatetime->time.hour, bdatetime->time.min, bdatetime->time.sec) /
60;
bdatetime_days = datetime_days_since_epoch(&bdatetime->date);
/* more minutes than in a day? */
days = minutes / (24 * 60);
bdatetime_days += days;
@@ -645,14 +644,86 @@ void datetime_add_minutes(BACNET_DATE_TIME *bdatetime, int32_t minutes)
bdatetime_days += days;
bdatetime_minutes -= (days * 24 * 60);
}
/* convert bdatetime from seconds and days */
/* convert bdatetime from minutes and days */
datetime_hms_from_seconds_since_midnight(
bdatetime_minutes * 60, &bdatetime->time.hour, &bdatetime->time.min,
NULL);
datetime_days_since_epoch_into_date(bdatetime_days, &bdatetime->date);
}
/**
* @brief Add or subtract seconds to a BACnet DateTime structure
* @param bdatetime [in] the starting date and time
* @param seconds [in] number of seconds to add or subtract from the time
*/
void datetime_add_seconds(BACNET_DATE_TIME *bdatetime, int32_t seconds)
{
uint32_t bdatetime_seconds = 0;
uint32_t bdatetime_days = 0;
int32_t days = 0;
/* convert bdatetime to seconds and days */
bdatetime_seconds = datetime_hms_to_seconds_since_midnight(
bdatetime->time.hour, bdatetime->time.min, bdatetime->time.sec);
bdatetime_days = datetime_days_since_epoch(&bdatetime->date);
/* more minutes than in a day? */
days = seconds / (24 * 60 * 60);
bdatetime_days += days;
seconds -= (days * 24 * 60 * 60);
/* less seconds - previous day? */
if (seconds < 0) {
/* convert to positive for easier math */
seconds *= -1;
if ((uint32_t)seconds > bdatetime_seconds) {
/* previous day */
bdatetime_days -= 1;
bdatetime_seconds += ((24 * 60 * 60) - seconds);
} else {
bdatetime_seconds -= seconds;
days = bdatetime_seconds / (24 * 60 * 60);
bdatetime_days += days;
bdatetime_seconds -= (days * 24 * 60 * 60);
}
} else {
/* more days than current datetime? */
bdatetime_seconds += seconds;
days = bdatetime_seconds / (24 * 60 * 60);
bdatetime_days += days;
bdatetime_seconds -= (days * 24 * 60 * 60);
}
/* convert bdatetime from seconds and days */
datetime_hms_from_seconds_since_midnight(
bdatetime_seconds, &bdatetime->time.hour, &bdatetime->time.min,
&bdatetime->time.sec);
datetime_days_since_epoch_into_date(bdatetime_days, &bdatetime->date);
}
/**
* @brief Add milliseconds to a BACnet DateTime structure
* @param bdatetime [in] the starting date and time
* @param milliseconds [in] number of milliseconds to add to the date and time
*/
void datetime_add_milliseconds(
BACNET_DATE_TIME *bdatetime, int32_t milliseconds)
{
uint32_t bdatetime_hundredths = 0;
int32_t hundredths = 0;
int32_t seconds = 0;
/* convert to seconds */
seconds = milliseconds / 1000;
hundredths = (milliseconds - (seconds * 1000)) / 10;
bdatetime_hundredths = bdatetime->time.hundredths;
bdatetime_hundredths += hundredths;
if (bdatetime_hundredths >= 100) {
/* adjust the seconds if hundredths overflow */
seconds++;
bdatetime_hundredths -= 100;
}
datetime_add_seconds(bdatetime, seconds);
bdatetime->time.hundredths = bdatetime_hundredths;
}
/**
* @brief Calculates the number of seconds since epoch from datetime
* @param bdatetime [in] the starting date and time
src/bacnet/datetime.h
+6 -1
View File
@@ -185,9 +185,14 @@ void datetime_copy_time(BACNET_TIME *dest, const BACNET_TIME *src);
BACNET_STACK_EXPORT
void datetime_copy(BACNET_DATE_TIME *dest, const BACNET_DATE_TIME *src);
/* utility add or subtract minutes function */
/* utility add or subtract time function */
BACNET_STACK_EXPORT
void datetime_add_minutes(BACNET_DATE_TIME *bdatetime, int32_t minutes);
BACNET_STACK_EXPORT
void datetime_add_seconds(BACNET_DATE_TIME *bdatetime, int32_t seconds);
BACNET_STACK_EXPORT
void datetime_add_milliseconds(
BACNET_DATE_TIME *bdatetime, int32_t milliseconds);
BACNET_STACK_EXPORT
bacnet_time_t datetime_seconds_since_epoch(const BACNET_DATE_TIME *bdatetime);
src/bacnet/proplist.c
+5 -4
View File
@@ -408,7 +408,8 @@ const int *property_list_bacnet_array(void)
bool property_list_bacnet_array_member(
BACNET_OBJECT_TYPE object_type, BACNET_PROPERTY_ID object_property)
{
/* exceptions where property is an BACnetARRAY only in specific objects */
/* exceptions where a property is an BACnetARRAY or a BACnetLIST
only in specific object types */
switch (object_type) {
case OBJECT_GLOBAL_GROUP:
switch (object_property) {
@@ -459,6 +460,7 @@ static const int Properties_BACnetLIST[] = {
PROP_UTC_TIME_SYNCHRONIZATION_RECIPIENTS,
PROP_ACTIVE_COV_MULTIPLE_SUBSCRIPTIONS,
PROP_LIST_OF_GROUP_MEMBERS,
PROP_LIST_OF_OBJECT_PROPERTY_REFERENCES,
PROP_ACCEPTED_MODES,
PROP_LIFE_SAFETY_ALARM_VALUES,
PROP_ALARM_VALUES,
@@ -524,11 +526,10 @@ bool property_list_bacnet_list_member(
break;
}
break;
case OBJECT_SCHEDULE:
case OBJECT_TIMER:
case OBJECT_CHANNEL:
switch (object_property) {
case PROP_LIST_OF_OBJECT_PROPERTY_REFERENCES:
return true;
return false;
default:
break;
}
src/bacnet/timer_value.c
+904
View File
@@ -0,0 +1,904 @@
/**
* @file
* @brief BACnetTimerStateChangeValue data type encoding and decoding
* @author Steve Karg <skarg@users.sourceforge.net>
* @date October 2025
* @copyright SPDX-License-Identifier: GPL-2.0-or-later WITH GCC-exception-2.0
*/
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <float.h>
/* BACnet Stack defines - first */
#include "bacnet/bacdef.h"
/* BACnet Stack API */
#include "bacnet/bacdcode.h"
#include "bacnet/bacstr.h"
#include "bacnet/bacint.h"
#include "bacnet/bacreal.h"
#include "bacnet/timer_value.h"
/**
* @brief Encode a context tagged BACnetTimerStateChangeValue with no-value type
* @param apdu buffer to be encoded, or NULL for length
* @param tag_number - context tag number to be encoded
* @param value The value to be encoded.
* @return the number of apdu bytes encoded
*/
int bacnet_timer_value_no_value_encode(uint8_t *apdu)
{
int len = 0;
int apdu_len = 0;
const uint8_t tag_number = 0;
/* no-value[0] Null */
len = encode_opening_tag(apdu, tag_number);
apdu_len += len;
if (apdu) {
apdu += len;
}
len = encode_application_null(apdu);
apdu_len += len;
if (apdu) {
apdu += len;
}
len = encode_closing_tag(apdu, tag_number);
apdu_len += len;
return apdu_len;
}
/**
* @brief Decodes a context tagged BACnetTimerStateChangeValue with
* no-value type
* @param apdu - the APDU buffer
* @param apdu_size - the APDU buffer size
* @return length of the APDU buffer decoded, or BACNET_STATUS_ERROR
*/
int bacnet_timer_value_no_value_decode(const uint8_t *apdu, uint32_t apdu_size)
{
int apdu_len = 0;
int len;
const uint8_t tag_number = 0;
/* no-value[0] Null */
if (!bacnet_is_opening_tag_number(
&apdu[apdu_len], apdu_size - apdu_len, tag_number, &len)) {
return BACNET_STATUS_ERROR;
}
apdu_len += len;
len = bacnet_null_application_decode(&apdu[apdu_len], apdu_size - apdu_len);
if (len < 0) {
return BACNET_STATUS_ERROR;
}
apdu_len += len;
if (!bacnet_is_closing_tag_number(
&apdu[apdu_len], apdu_size - apdu_len, tag_number, &len)) {
return BACNET_STATUS_ERROR;
}
apdu_len += len;
return apdu_len;
}
/**
* @brief Print a no-value to a string for EPICS
* @param str - destination string, or NULL for length only
* @param str_len - length of the destination string, or 0 for length only
* @return number of characters written
*/
int bacnet_timer_value_no_value_to_ascii(char *str, size_t str_len)
{
return snprintf(str, str_len, "no-value");
}
/**
* @brief Parse a string into a application tag value
* @param tag [out] The application tag value if found
* @param argv [in] The string to parse
* @return true on success, else false
*/
bool bacnet_timer_value_no_value_from_ascii(uint8_t *tag, const char *argv)
{
bool status = false;
if (bacnet_stricmp(argv, "no-value") == 0) {
if (tag) {
*tag = BACNET_APPLICATION_TAG_NO_VALUE;
}
status = true;
}
return status;
}
/**
* @brief Encode a given BACnetTimerStateChangeValue
* @param apdu - APDU buffer for storing the encoded data, or NULL for length
* @param value - BACNET_TIMER_STATE_CHANGE_VALUE value
* @return number of bytes in the APDU
*/
int bacnet_timer_value_type_encode(
uint8_t *apdu, const BACNET_TIMER_STATE_CHANGE_VALUE *value)
{
int apdu_len = 0;
if (!value) {
return 0;
}
switch (value->tag) {
case BACNET_APPLICATION_TAG_NULL:
apdu_len = encode_application_null(apdu);
break;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
case BACNET_APPLICATION_TAG_BOOLEAN:
apdu_len = encode_application_boolean(apdu, value->type.Boolean);
break;
#endif
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
case BACNET_APPLICATION_TAG_UNSIGNED_INT:
apdu_len =
encode_application_unsigned(apdu, value->type.Unsigned_Int);
break;
#endif
#if defined(BACNET_TIMER_VALUE_SIGNED)
case BACNET_APPLICATION_TAG_SIGNED_INT:
apdu_len = encode_application_signed(apdu, value->type.Signed_Int);
break;
#endif
#if defined(BACNET_TIMER_VALUE_REAL)
case BACNET_APPLICATION_TAG_REAL:
apdu_len = encode_application_real(apdu, value->type.Real);
break;
#endif
#if defined(BACNET_TIMER_VALUE_DOUBLE)
case BACNET_APPLICATION_TAG_DOUBLE:
apdu_len = encode_application_double(apdu, value->type.Double);
break;
#endif
#if defined(BACNET_TIMER_VALUE_OCTET_STRING)
case BACNET_APPLICATION_TAG_OCTET_STRING:
apdu_len = encode_application_octet_string(
apdu, &value->type.Octet_String);
break;
#endif
#if defined(BACNET_TIMER_VALUE_CHARACTER_STRING)
case BACNET_APPLICATION_TAG_CHARACTER_STRING:
apdu_len = encode_application_character_string(
apdu, &value->type.Character_String);
break;
#endif
#if defined(BACNET_TIMER_VALUE_BIT_STRING)
case BACNET_APPLICATION_TAG_BIT_STRING:
apdu_len =
encode_application_bitstring(apdu, &value->type.Bit_String);
break;
#endif
#if defined(BACNET_TIMER_VALUE_ENUMERATED)
case BACNET_APPLICATION_TAG_ENUMERATED:
apdu_len =
encode_application_enumerated(apdu, value->type.Enumerated);
break;
#endif
#if defined(BACNET_TIMER_VALUE_DATE)
case BACNET_APPLICATION_TAG_DATE:
apdu_len = encode_application_date(apdu, &value->type.Date);
break;
#endif
#if defined(BACNET_TIMER_VALUE_TIME)
case BACNET_APPLICATION_TAG_TIME:
apdu_len = encode_application_time(apdu, &value->type.Time);
break;
#endif
#if defined(BACNET_TIMER_VALUE_OBJECT_ID)
case BACNET_APPLICATION_TAG_OBJECT_ID:
apdu_len = encode_application_object_id(
apdu, (int)value->type.Object_Id.type,
value->type.Object_Id.instance);
break;
#endif
#if defined(BACNET_TIMER_VALUE_NO_VALUE)
case BACNET_APPLICATION_TAG_NO_VALUE:
/* no-value[0] Null */
apdu_len = bacnet_timer_value_no_value_encode(apdu);
break;
#endif
#if defined(BACNET_TIMER_VALUE_CONSTRUCTED_VALUE)
case BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX:
/* constructed-value[1] ABSTRACT-SYNTAX.&Type */
apdu_len = bacnet_constructed_value_context_encode(
apdu, 1, &value->type.Constructed_Value);
break;
#endif
#if defined(BACNET_TIMER_VALUE_DATETIME)
case BACNET_APPLICATION_TAG_DATETIME:
/* datetime[2] BACnetDateTime */
apdu_len =
bacapp_encode_context_datetime(apdu, 2, &value->type.Date_Time);
break;
#endif
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
case BACNET_APPLICATION_TAG_LIGHTING_COMMAND:
apdu_len = lighting_command_encode_context(
apdu, 3, &value->type.Lighting_Command);
break;
#endif
default:
break;
}
return apdu_len;
}
/**
* @brief Decode a BACnetTimerStateChangeValue
* @param apdu - the APDU buffer
* @param apdu_size - the APDU buffer size
* @param tag_data_type - application tag type expected
* @param len_value_type - the length or value type of the tag value content.
* @param value - the value where the decoded data is copied into
* @return length of the APDU buffer decoded, or BACNET_STATUS_ERROR
*/
int bacnet_timer_value_type_decode(
const uint8_t *apdu,
size_t apdu_size,
uint8_t tag_data_type,
uint32_t len_value_type,
BACNET_TIMER_STATE_CHANGE_VALUE *value)
{
int len = 0;
if (!apdu) {
return BACNET_STATUS_ERROR;
}
if (!value) {
return BACNET_STATUS_ERROR;
}
switch (tag_data_type) {
case BACNET_APPLICATION_TAG_NULL:
/* nothing else to do */
break;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
case BACNET_APPLICATION_TAG_BOOLEAN:
value->type.Boolean = decode_boolean(len_value_type);
len = 0;
break;
#endif
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
case BACNET_APPLICATION_TAG_UNSIGNED_INT:
len = bacnet_unsigned_decode(
apdu, apdu_size, len_value_type, &value->type.Unsigned_Int);
break;
#endif
#if defined(BACNET_TIMER_VALUE_SIGNED)
case BACNET_APPLICATION_TAG_SIGNED_INT:
len = bacnet_signed_decode(
apdu, apdu_size, len_value_type, &value->type.Signed_Int);
break;
#endif
#if defined(BACNET_TIMER_VALUE_REAL)
case BACNET_APPLICATION_TAG_REAL:
len = bacnet_real_decode(
apdu, apdu_size, len_value_type, &(value->type.Real));
break;
#endif
#if defined(BACNET_TIMER_VALUE_DOUBLE)
case BACNET_APPLICATION_TAG_DOUBLE:
len = bacnet_double_decode(
apdu, apdu_size, len_value_type, &(value->type.Double));
break;
#endif
#if defined(BACNET_TIMER_VALUE_OCTET_STRING)
case BACNET_APPLICATION_TAG_OCTET_STRING:
len = bacnet_octet_string_decode(
apdu, apdu_size, len_value_type, &value->type.Octet_String);
break;
#endif
#if defined(BACNET_TIMER_VALUE_CHARACTER_STRING)
case BACNET_APPLICATION_TAG_CHARACTER_STRING:
len = bacnet_character_string_decode(
apdu, apdu_size, len_value_type, &value->type.Character_String);
break;
#endif
#if defined(BACNET_TIMER_VALUE_BIT_STRING)
case BACNET_APPLICATION_TAG_BIT_STRING:
len = bacnet_bitstring_decode(
apdu, apdu_size, len_value_type, &value->type.Bit_String);
break;
#endif
#if defined(BACNET_TIMER_VALUE_ENUMERATED)
case BACNET_APPLICATION_TAG_ENUMERATED:
len = bacnet_enumerated_decode(
apdu, apdu_size, len_value_type, &value->type.Enumerated);
break;
#endif
#if defined(BACNET_TIMER_VALUE_DATE)
case BACNET_APPLICATION_TAG_DATE:
len = bacnet_date_decode(
apdu, apdu_size, len_value_type, &value->type.Date);
break;
#endif
#if defined(BACNET_TIMER_VALUE_TIME)
case BACNET_APPLICATION_TAG_TIME:
len = bacnet_time_decode(
apdu, apdu_size, len_value_type, &value->type.Time);
break;
#endif
#if defined(BACNET_TIMER_VALUE_OBJECT_ID)
case BACNET_APPLICATION_TAG_OBJECT_ID:
len = bacnet_object_id_decode(
apdu, apdu_size, len_value_type, &value->type.Object_Id.type,
&value->type.Object_Id.instance);
break;
#endif
default:
len = BACNET_STATUS_ERROR;
break;
}
if ((len == 0) && (tag_data_type != BACNET_APPLICATION_TAG_NULL) &&
(tag_data_type != BACNET_APPLICATION_TAG_BOOLEAN) &&
(tag_data_type != BACNET_APPLICATION_TAG_OCTET_STRING)) {
/* indicate that we were not able to decode the value */
len = BACNET_STATUS_ERROR;
}
if (len != BACNET_STATUS_ERROR) {
value->tag = tag_data_type;
}
return len;
}
/**
* @brief Encode a given BACnetTimerStateChangeValue
* @param apdu - APDU buffer for storing the encoded data, or NULL for length
* @param apdu_size - size of the APDU buffer
* @param value - BACNET_TIMER_STATE_CHANGE_VALUE value
* @return number of bytes in the APDU, or BACNET_STATUS_ERROR
*/
int bacnet_timer_value_encode(
uint8_t *apdu,
size_t apdu_size,
const BACNET_TIMER_STATE_CHANGE_VALUE *value)
{
size_t apdu_len = 0; /* total length of the apdu, return value */
apdu_len = bacnet_timer_value_type_encode(NULL, value);
if (apdu_len > apdu_size) {
apdu_len = 0;
} else {
apdu_len = bacnet_timer_value_type_encode(apdu, value);
}
return apdu_len;
}
/**
* @brief Decode a given BACnetTimerStateChangeValue
* @param apdu - APDU buffer for decoding
* @param apdu_size - Count of valid bytes in the buffer
* @param value - BACNET_TIMER_STATE_CHANGE_VALUE value to store the decoded
* data
* @return number of bytes decoded or BACNET_STATUS_ERROR on error
*/
int bacnet_timer_value_decode(
const uint8_t *apdu,
size_t apdu_size,
BACNET_TIMER_STATE_CHANGE_VALUE *value)
{
int len = 0, tag_len = 0;
int apdu_len = 0;
BACNET_TAG tag = { 0 };
if (!apdu) {
return BACNET_STATUS_ERROR;
}
if (!value) {
return BACNET_STATUS_ERROR;
}
tag_len = bacnet_tag_decode(&apdu[apdu_len], apdu_size - apdu_len, &tag);
if (tag_len > 0) {
apdu_len += tag_len;
if (tag.application) {
len = bacnet_timer_value_type_decode(
&apdu[apdu_len], apdu_size - apdu_len, tag.number,
tag.len_value_type, value);
if (len >= 0) {
apdu_len += len;
} else {
return BACNET_STATUS_ERROR;
}
} else if (tag.opening) {
switch (tag.number) {
case 0:
/* no-value[0] Null */
value->tag = BACNET_APPLICATION_TAG_NO_VALUE;
if (tag.len_value_type == 0) {
len = tag_len;
} else {
return BACNET_STATUS_ERROR;
}
break;
case 1:
/* constructed-value[1] ABSTRACT-SYNTAX.&Type */
value->tag = BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX;
#if defined(BACNET_TIMER_VALUE_CONSTRUCTED_VALUE)
len = bacnet_enclosed_data_length(apdu, apdu_size);
len = bacnet_constructed_value_decode(
&apdu[apdu_len], apdu_size - apdu_len, len,
&value->type.Constructed_Value);
#endif
break;
case 2:
/* datetime[2] BACnetDateTime */
value->tag = BACNET_APPLICATION_TAG_DATETIME;
#if defined(BACNET_TIMER_VALUE_DATETIME)
len = bacnet_datetime_decode(
&apdu[apdu_len], apdu_size - apdu_len,
&value->type.Date_Time);
#endif
break;
case 3:
/* lighting-command[3] BACnetLightingCommand */
value->tag = BACNET_APPLICATION_TAG_LIGHTING_COMMAND;
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
len = lighting_command_decode(
&apdu[apdu_len], apdu_size - apdu_len,
&value->type.Lighting_Command);
#endif
break;
default:
return BACNET_STATUS_ERROR;
}
if (len > 0) {
apdu_len += len;
if (bacnet_is_closing_tag_number(
&apdu[apdu_len], apdu_size - apdu_len, tag.number,
&len)) {
apdu_len += len;
} else {
return BACNET_STATUS_ERROR;
}
} else {
return BACNET_STATUS_ERROR;
}
} else {
return BACNET_STATUS_ERROR;
}
} else {
return BACNET_STATUS_ERROR;
}
return apdu_len;
}
/**
* @brief Compare two BACnetTimerStateChangeValue values
* @param value1 [in] The first BACnetTimerStateChangeValue value
* @param value2 [in] The second BACnetTimerStateChangeValue value
* @return True if the values are the same, else False
*/
bool bacnet_timer_value_same(
const BACNET_TIMER_STATE_CHANGE_VALUE *value1,
const BACNET_TIMER_STATE_CHANGE_VALUE *value2)
{
if (value1->tag != value2->tag) {
return false;
}
switch (value1->tag) {
case BACNET_APPLICATION_TAG_NULL:
return true;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
case BACNET_APPLICATION_TAG_BOOLEAN:
return value1->type.Boolean == value2->type.Boolean;
#endif
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
case BACNET_APPLICATION_TAG_UNSIGNED_INT:
return value1->type.Unsigned_Int == value2->type.Unsigned_Int;
#endif
#if defined(BACNET_TIMER_VALUE_SIGNED)
case BACNET_APPLICATION_TAG_SIGNED_INT:
return value1->type.Signed_Int == value2->type.Signed_Int;
#endif
#if defined(BACNET_TIMER_VALUE_REAL)
case BACNET_APPLICATION_TAG_REAL:
return !islessgreater(value1->type.Real, value2->type.Real);
#endif
#if defined(BACNET_TIMER_VALUE_DOUBLE)
case BACNET_APPLICATION_TAG_DOUBLE:
return !islessgreater(value1->type.Double, value2->type.Double);
#endif
#if defined(BACNET_TIMER_VALUE_OCTET_STRING)
case BACNET_APPLICATION_TAG_OCTET_STRING:
return octetstring_value_same(
&value1->type.Octet_String, &value2->type.Octet_String);
#endif
#if defined(BACNET_TIMER_VALUE_CHARACTER_STRING)
case BACNET_APPLICATION_TAG_CHARACTER_STRING:
return characterstring_same(
&value1->type.Character_String, &value2->type.Character_String);
#endif
#if defined(BACNET_TIMER_VALUE_BIT_STRING)
case BACNET_APPLICATION_TAG_BIT_STRING:
return bitstring_same(
&value1->type.Bit_String, &value2->type.Bit_String);
#endif
#if defined(BACNET_TIMER_VALUE_ENUMERATED)
case BACNET_APPLICATION_TAG_ENUMERATED:
return value1->type.Enumerated == value2->type.Enumerated;
#endif
#if defined(BACNET_TIMER_VALUE_DATE)
case BACNET_APPLICATION_TAG_DATE:
if (datetime_compare_date(&value1->type.Date, &value2->type.Date) ==
0) {
return true;
}
return false;
#endif
#if defined(BACNET_TIMER_VALUE_TIME)
case BACNET_APPLICATION_TAG_TIME:
if (datetime_compare_time(&value1->type.Time, &value2->type.Time) ==
0) {
return true;
}
return false;
#endif
#if defined(BACNET_TIMER_VALUE_OBJECT_ID)
case BACNET_APPLICATION_TAG_OBJECT_ID:
return bacnet_object_id_same(
value1->type.Object_Id.type, value1->type.Object_Id.instance,
value2->type.Object_Id.type, value2->type.Object_Id.instance);
#endif
#if defined(BACNET_TIMER_VALUE_DATETIME)
case BACNET_APPLICATION_TAG_DATETIME:
return (
datetime_compare(
&value1->type.Date_Time, &value2->type.Date_Time) == 0);
#endif
#if defined(BACNET_TIMER_VALUE_CONSTRUCTED_VALUE)
case BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX:
return bacnet_constructed_value_same(
&value1->type.Constructed_Value,
&value2->type.Constructed_Value);
#endif
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
case BACNET_APPLICATION_TAG_LIGHTING_COMMAND:
return lighting_command_same(
&value1->type.Lighting_Command, &value2->type.Lighting_Command);
#endif
default:
break;
}
return true;
}
/**
* @brief Copy a BACnetTimerStateChangeValue to another
* @param value1 [in] The first BACnetTimerStateChangeValue value
* @param value2 [in] The second BACnetTimerStateChangeValue value
* @return true if the value was copied, else false
*/
bool bacnet_timer_value_copy(
BACNET_TIMER_STATE_CHANGE_VALUE *dest,
const BACNET_TIMER_STATE_CHANGE_VALUE *src)
{
if (!dest || !src) {
return false;
}
dest->tag = src->tag;
switch (src->tag) {
case BACNET_APPLICATION_TAG_NULL:
case BACNET_APPLICATION_TAG_NO_VALUE:
return true;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
case BACNET_APPLICATION_TAG_BOOLEAN:
dest->type.Boolean = src->type.Boolean;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
case BACNET_APPLICATION_TAG_UNSIGNED_INT:
dest->type.Unsigned_Int = src->type.Unsigned_Int;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_SIGNED)
case BACNET_APPLICATION_TAG_SIGNED_INT:
dest->type.Signed_Int = src->type.Signed_Int;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_REAL)
case BACNET_APPLICATION_TAG_REAL:
dest->type.Real = src->type.Real;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_DOUBLE)
case BACNET_APPLICATION_TAG_DOUBLE:
dest->type.Double = src->type.Double;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_OCTET_STRING)
case BACNET_APPLICATION_TAG_OCTET_STRING:
return octetstring_copy(
&dest->type.Octet_String, &src->type.Octet_String);
#endif
#if defined(BACNET_TIMER_VALUE_CHARACTER_STRING)
case BACNET_APPLICATION_TAG_CHARACTER_STRING:
return characterstring_copy(
&dest->type.Character_String, &src->type.Character_String);
#endif
#if defined(BACNET_TIMER_VALUE_BIT_STRING)
case BACNET_APPLICATION_TAG_BIT_STRING:
return bitstring_copy(
&dest->type.Bit_String, &src->type.Bit_String);
#endif
#if defined(BACNET_TIMER_VALUE_ENUMERATED)
case BACNET_APPLICATION_TAG_ENUMERATED:
dest->type.Enumerated = src->type.Enumerated;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_DATE)
case BACNET_APPLICATION_TAG_DATE:
datetime_copy_date(&dest->type.Date, &src->type.Date);
return true;
#endif
#if defined(BACNET_TIMER_VALUE_TIME)
case BACNET_APPLICATION_TAG_TIME:
datetime_copy_time(&dest->type.Time, &src->type.Time);
return true;
#endif
#if defined(BACNET_TIMER_VALUE_OBJECT_ID)
case BACNET_APPLICATION_TAG_OBJECT_ID:
dest->type.Object_Id.type = src->type.Object_Id.type;
dest->type.Object_Id.instance = src->type.Object_Id.instance;
return true;
#endif
#if defined(BACNET_TIMER_VALUE_DATETIME)
case BACNET_APPLICATION_TAG_DATETIME:
datetime_copy(&dest->type.Date_Time, &src->type.Date_Time);
return true;
#endif
#if defined(BACNET_TIMER_VALUE_CONSTRUCTED_VALUE)
case BACNET_APPLICATION_TAG_ABSTRACT_SYNTAX:
return bacnet_constructed_value_copy(
&dest->type.Constructed_Value, &src->type.Constructed_Value);
#endif
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
case BACNET_APPLICATION_TAG_LIGHTING_COMMAND:
return lighting_command_copy(
&dest->type.Lighting_Command, &src->type.Lighting_Command);
#endif
default:
break;
}
return false;
}
/**
* @brief Parse a string into a BACnetTimerStateChangeValue structure
* @param value [out] The BACnetTimerStateChangeValue value
* @param argv [in] The string to parse
* @return true on success, else false
*/
bool bacnet_timer_value_from_ascii(
BACNET_TIMER_STATE_CHANGE_VALUE *value, const char *argv)
{
bool status = false;
int count;
unsigned long unsigned_value;
long signed_value;
float single_value;
double double_value;
const char *negative;
const char *decimal_point;
const char *lighting_command;
const char *real_string;
const char *double_string;
if (!value || !argv) {
return false;
}
if (!status) {
if (bacnet_stricmp(argv, "null") == 0) {
value->tag = BACNET_APPLICATION_TAG_NULL;
status = true;
}
}
if (!status) {
status = bacnet_timer_value_no_value_from_ascii(&value->tag, argv);
}
if (!status) {
if (bacnet_stricmp(argv, "true") == 0) {
value->tag = BACNET_APPLICATION_TAG_BOOLEAN;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
value->type.Boolean = true;
#endif
status = true;
}
}
if (!status) {
if (bacnet_stricmp(argv, "false") == 0) {
value->tag = BACNET_APPLICATION_TAG_BOOLEAN;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
value->type.Boolean = false;
#endif
status = true;
}
}
if (!status) {
lighting_command = strchr(argv, 'L');
if (!lighting_command) {
lighting_command = strchr(argv, 'l');
}
if (lighting_command) {
value->tag = BACNET_APPLICATION_TAG_LIGHTING_COMMAND;
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
status = lighting_command_from_ascii(
&value->type.Lighting_Command, argv + 1);
#endif
}
}
if (!status) {
real_string = strchr(argv, 'F');
if (!real_string) {
real_string = strchr(argv, 'f');
}
if (real_string) {
value->tag = BACNET_APPLICATION_TAG_REAL;
count = sscanf(argv + 1, "%f", &single_value);
if (count == 1) {
#if defined(BACNET_TIMER_VALUE_REAL)
value->type.Real = single_value;
#endif
status = true;
}
}
}
if (!status) {
double_string = strchr(argv, 'D');
if (!double_string) {
double_string = strchr(argv, 'd');
}
if (double_string) {
count = sscanf(argv + 1, "%lf", &double_value);
if (count == 1) {
value->tag = BACNET_APPLICATION_TAG_DOUBLE;
#if defined(BACNET_TIMER_VALUE_DOUBLE)
value->type.Double = double_value;
#endif
status = true;
}
}
}
if (!status) {
decimal_point = strchr(argv, '.');
if (decimal_point) {
count = sscanf(argv, "%lf", &double_value);
if (count == 1) {
if (isgreaterequal(double_value, -FLT_MAX) &&
islessequal(double_value, FLT_MAX)) {
value->tag = BACNET_APPLICATION_TAG_REAL;
#if defined(BACNET_TIMER_VALUE_REAL)
value->type.Real = (float)double_value;
#endif
} else {
value->tag = BACNET_APPLICATION_TAG_DOUBLE;
#if defined(BACNET_TIMER_VALUE_DOUBLE)
value->type.Double = double_value;
#endif
}
status = true;
}
}
}
if (!status) {
negative = strchr(argv, '-');
if (negative) {
count = sscanf(argv, "%ld", &signed_value);
if (count == 1) {
value->tag = BACNET_APPLICATION_TAG_SIGNED_INT;
#if defined(BACNET_TIMER_VALUE_SIGNED)
value->type.Signed_Int = signed_value;
#endif
status = true;
}
}
}
if (!status) {
count = sscanf(argv, "%lu", &unsigned_value);
if (count == 1) {
value->tag = BACNET_APPLICATION_TAG_UNSIGNED_INT;
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
value->type.Unsigned_Int = unsigned_value;
#endif
status = true;
}
}
return status;
}
/**
* @brief Produce a string from a BACnetTimerStateChangeValue structure
* @param value [in] The BACnetTimerStateChangeValue value
* @param str [out] The string to produce, NULL to get length only
* @param str_size [in] The size of the string buffer
* @return length of the produced string
*/
int bacnet_timer_value_to_ascii(
const BACNET_TIMER_STATE_CHANGE_VALUE *value, char *str, size_t str_size)
{
int str_len = 0;
if (!value) {
return 0;
}
switch (value->tag) {
case BACNET_APPLICATION_TAG_NULL:
str_len = snprintf(str, str_size, "null");
break;
case BACNET_APPLICATION_TAG_NO_VALUE:
str_len = bacnet_timer_value_no_value_to_ascii(str, str_size);
break;
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
case BACNET_APPLICATION_TAG_BOOLEAN:
if (value->type.Boolean) {
str_len = snprintf(str, str_size, "true");
} else {
str_len = snprintf(str, str_size, "false");
}
break;
#endif
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
case BACNET_APPLICATION_TAG_UNSIGNED_INT:
str_len = snprintf(
str, str_size, "%lu", (unsigned long)value->type.Unsigned_Int);
break;
#endif
#if defined(BACNET_TIMER_VALUE_SIGNED)
case BACNET_APPLICATION_TAG_SIGNED_INT:
str_len =
snprintf(str, str_size, "%ld", (long)value->type.Signed_Int);
break;
#endif
#if defined(BACNET_TIMER_VALUE_REAL)
case BACNET_APPLICATION_TAG_REAL:
str_len = snprintf(str, str_size, "%f", (double)value->type.Real);
break;
#endif
#if defined(BACNET_TIMER_VALUE_DOUBLE)
case BACNET_APPLICATION_TAG_DOUBLE:
str_len = snprintf(str, str_size, "%f", value->type.Double);
break;
#endif
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
case BACNET_APPLICATION_TAG_LIGHTING_COMMAND:
str_len = lighting_command_to_ascii(
&value->type.Lighting_Command, str, str_size);
break;
#endif
default:
break;
}
return str_len;
}
/**
* @brief Convert an array of BACnetTimerStateChangeValue to linked list
* @param array pointer to element zero of the array
* @param size number of elements in the array
*/
void bacnet_timer_value_link_array(
BACNET_TIMER_STATE_CHANGE_VALUE *array, size_t size)
{
size_t i = 0;
for (i = 0; i < size; i++) {
if (i > 0) {
array[i - 1].next = &array[i];
}
array[i].next = NULL;
}
}
src/bacnet/timer_value.h
+180
View File
@@ -0,0 +1,180 @@
/**
* @file
* @brief BACnetTimerStateChangeValue data type encoding and decoding API
* @author Steve Karg <skarg@users.sourceforge.net>
* @date October 2025
* @copyright SPDX-License-Identifier: MIT
*/
#ifndef BACNET_TIMER_VALUE_H
#define BACNET_TIMER_VALUE_H
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
/* BACnet Stack defines - first */
#include "bacnet/bacdef.h"
#include "bacnet/bacstr.h"
#include "bacnet/bacdcode.h"
#include "bacnet/bacint.h"
#include "bacnet/datetime.h"
#include "bacnet/lighting.h"
/* BACNET_TIMER_STATE_CHANGE_VALUE decodes WriteProperty service requests
Define the datatypes that your application supports */
#if !(/* check for any defines, and if none, use NUMERIC */ \
defined(BACNET_TIMER_VALUE_NUMERIC) || \
defined(BACNET_TIMER_VALUE_ALL) || defined(BACNET_TIMER_VALUE_NULL) || \
defined(BACNET_TIMER_VALUE_BOOLEAN) || \
defined(BACNET_TIMER_VALUE_UNSIGNED) || \
defined(BACNET_TIMER_VALUE_SIGNED) || \
defined(BACNET_TIMER_VALUE_REAL) || \
defined(BACNET_TIMER_VALUE_DOUBLE) || \
defined(BACNET_TIMER_VALUE_OCTET_STRING) || \
defined(BACNET_TIMER_VALUE_CHARACTER_STRING) || \
defined(BACNET_TIMER_VALUE_BIT_STRING) || \
defined(BACNET_TIMER_VALUE_ENUMERATED) || \
defined(BACNET_TIMER_VALUE_DATE) || defined(BACNET_TIMER_VALUE_TIME) || \
defined(BACNET_TIMER_VALUE_OBJECT_ID) || \
defined(BACNET_TIMER_VALUE_NO_VALUE) || \
defined(BACNET_TIMER_VALUE_CONSTRUCTED_VALUE) || \
defined(BACNET_TIMER_VALUE_DATETIME) || \
defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND))
#define BACNET_TIMER_VALUE_NUMERIC
#elif defined(BACNET_TIMER_VALUE_ALL)
#define BACNET_TIMER_VALUE_NUMERIC
#define BACNET_TIMER_VALUE_OCTET_STRING
#define BACNET_TIMER_VALUE_CHARACTER_STRING
#define BACNET_TIMER_VALUE_BIT_STRING
#define BACNET_TIMER_VALUE_DATE
#define BACNET_TIMER_VALUE_TIME
#define BACNET_TIMER_VALUE_OBJECT_ID
#define BACNET_TIMER_VALUE_DATETIME
#define BACNET_TIMER_VALUE_CONSTRUCTED_VALUE
#define BACNET_TIMER_VALUE_LIGHTING_COMMAND
#endif
#if defined(BACNET_TIMER_VALUE_NUMERIC)
#define BACNET_TIMER_VALUE_NULL
#define BACNET_TIMER_VALUE_BOOLEAN
#define BACNET_TIMER_VALUE_UNSIGNED
#define BACNET_TIMER_VALUE_SIGNED
#define BACNET_TIMER_VALUE_REAL
#define BACNET_TIMER_VALUE_DOUBLE
#define BACNET_TIMER_VALUE_ENUMERATED
#define BACNET_TIMER_VALUE_NO_VALUE
#endif
typedef struct BACnet_Timer_State_Change_Value_T {
uint8_t tag;
union {
/* null - no type value needed. It is encoded in the tag alone. */
/* no-value - no type value needed. It is encoded in the tag alone. */
#if defined(BACNET_TIMER_VALUE_BOOLEAN)
bool Boolean;
#endif
#if defined(BACNET_TIMER_VALUE_UNSIGNED)
BACNET_UNSIGNED_INTEGER Unsigned_Int;
#endif
#if defined(BACNET_TIMER_VALUE_SIGNED)
int32_t Signed_Int;
#endif
#if defined(BACNET_TIMER_VALUE_REAL)
float Real;
#endif
#if defined(BACNET_TIMER_VALUE_DOUBLE)
double Double;
#endif
#if defined(BACNET_TIMER_VALUE_OCTET_STRING)
BACNET_OCTET_STRING Octet_String;
#endif
#if defined(BACNET_TIMER_VALUE_CHARACTER_STRING)
BACNET_CHARACTER_STRING Character_String;
#endif
#if defined(BACNET_TIMER_VALUE_BIT_STRING)
BACNET_BIT_STRING Bit_String;
#endif
#if defined(BACNET_TIMER_VALUE_ENUMERATED)
uint32_t Enumerated;
#endif
#if defined(BACNET_TIMER_VALUE_DATE)
BACNET_DATE Date;
#endif
#if defined(BACNET_TIMER_VALUE_TIME)
BACNET_TIME Time;
#endif
#if defined(BACNET_TIMER_VALUE_OBJECT_ID)
BACNET_OBJECT_ID Object_Id;
#endif
#if defined(BACNET_TIMER_VALUE_DATETIME)
BACNET_DATE_TIME Date_Time;
#endif
#if defined(BACNET_TIMER_VALUE_CONSTRUCTED_VALUE)
BACNET_CONSTRUCTED_VALUE_TYPE Constructed_Value;
#endif
#if defined(BACNET_TIMER_VALUE_LIGHTING_COMMAND)
BACNET_LIGHTING_COMMAND Lighting_Command;
#endif
} type;
/* simple linked list if needed */
struct BACnet_Timer_State_Change_Value_T *next;
} BACNET_TIMER_STATE_CHANGE_VALUE;
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
int bacnet_timer_value_no_value_encode(uint8_t *apdu);
BACNET_STACK_EXPORT
int bacnet_timer_value_no_value_decode(const uint8_t *apdu, uint32_t apdu_size);
BACNET_STACK_EXPORT
int bacnet_timer_value_no_value_to_ascii(char *str, size_t str_len);
BACNET_STACK_EXPORT
bool bacnet_timer_value_no_value_from_ascii(uint8_t *tag, const char *argv);
BACNET_STACK_EXPORT
int bacnet_timer_value_type_encode(
uint8_t *apdu, const BACNET_TIMER_STATE_CHANGE_VALUE *value);
BACNET_STACK_EXPORT
int bacnet_timer_value_type_decode(
const uint8_t *apdu,
size_t apdu_size,
uint8_t tag_data_type,
uint32_t len_value_type,
BACNET_TIMER_STATE_CHANGE_VALUE *value);
BACNET_STACK_EXPORT
int bacnet_timer_value_decode(
const uint8_t *apdu,
size_t apdu_len,
BACNET_TIMER_STATE_CHANGE_VALUE *value);
BACNET_STACK_EXPORT
int bacnet_timer_value_encode(
uint8_t *apdu,
size_t apdu_size,
const BACNET_TIMER_STATE_CHANGE_VALUE *value);
BACNET_STACK_EXPORT
bool bacnet_timer_value_from_ascii(
BACNET_TIMER_STATE_CHANGE_VALUE *value, const char *argv);
BACNET_STACK_EXPORT
int bacnet_timer_value_to_ascii(
const BACNET_TIMER_STATE_CHANGE_VALUE *value, char *str, size_t str_len);
BACNET_STACK_EXPORT
bool bacnet_timer_value_copy(
BACNET_TIMER_STATE_CHANGE_VALUE *dest,
const BACNET_TIMER_STATE_CHANGE_VALUE *src);
BACNET_STACK_EXPORT
bool bacnet_timer_value_same(
const BACNET_TIMER_STATE_CHANGE_VALUE *value1,
const BACNET_TIMER_STATE_CHANGE_VALUE *value2);
BACNET_STACK_EXPORT
void bacnet_timer_value_link_array(
BACNET_TIMER_STATE_CHANGE_VALUE *array, size_t size);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
src/bacnet/timestamp.c
-2
View File
@@ -13,8 +13,6 @@
#include "bacnet/datetime.h"
#include "bacnet/timestamp.h"
/** @file timestamp.c Encode/Decode BACnet Timestamps */
/** Set the sequence number in a timestamp structure.
*
* @param dest Pointer to the destination time stamp structure.