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

Export symbols in order to support shared libraries (#54)

Browse Source 
* Add BAC_ROUTING compile definition

* Reorder cmake

* Fix OpenSSL support: support both 1.0 and 1.1t pus

* Explicitly export symbols, hidden by default

* Build shared libraries on travis using cmake

* Learn Makefile about static library

* Fix build using mingw with cmake

* Do not cleanup twice or after potential free
This commit is contained in:
Anonymous Maarten
2020-03-06 22:42:03 +01:00
committed by GitHub
parent bb5fafc06a
commit 4a916468c6
174 changed files with 2200 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bacnet/basic/bbmd6/h_bbmd6.h
+6
View File
@@ -33,6 +33,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacdef.h"
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/datalink/bvlc6.h"
#ifdef __cplusplus
@@ -40,19 +41,24 @@ extern "C" {
#endif /* __cplusplus */
/* user application function prototypes */
BACNET_STACK_EXPORT
int bvlc6_handler(
BACNET_IP6_ADDRESS *addr,
BACNET_ADDRESS * src,
uint8_t * npdu,
uint16_t npdu_len);
BACNET_STACK_EXPORT
int bvlc6_register_with_bbmd(
BACNET_IP6_ADDRESS *bbmd_addr,
uint32_t vmac_src,
uint16_t time_to_live_seconds);
BACNET_STACK_EXPORT
uint16_t bvlc6_get_last_result(
void);
BACNET_STACK_EXPORT
uint8_t bvlc6_get_function_code(
void);
BACNET_STACK_EXPORT
void bvlc6_init(void);
src/bacnet/basic/bbmd6/vmac.h
+11
View File
@@ -8,6 +8,7 @@
#include <stdint.h>
#include <stdbool.h>
#include "bacnet/bacnet_stack_exports.h"
/* define the max MAC as big as IPv6 + port number */
#define VMAC_MAC_MAX 18
@@ -26,22 +27,32 @@ struct vmac_data {
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
unsigned int VMAC_Count(void);
BACNET_STACK_EXPORT
struct vmac_data *VMAC_Find_By_Key(uint32_t device_id);
BACNET_STACK_EXPORT
bool VMAC_Find_By_Data(struct vmac_data *vmac, uint32_t *device_id);
BACNET_STACK_EXPORT
bool VMAC_Add(uint32_t device_id, struct vmac_data *pVMAC);
BACNET_STACK_EXPORT
bool VMAC_Delete(uint32_t device_id);
BACNET_STACK_EXPORT
bool VMAC_Different(
struct vmac_data *vmac1,
struct vmac_data *vmac2);
BACNET_STACK_EXPORT
bool VMAC_Match(
struct vmac_data *vmac1,
struct vmac_data *vmac2);
BACNET_STACK_EXPORT
void VMAC_Cleanup(void);
BACNET_STACK_EXPORT
void VMAC_Init(void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testVMAC(
Test * pTest);
#endif
src/bacnet/basic/binding/address.h
+22
View File
@@ -27,6 +27,7 @@
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/readrange.h"
@@ -34,31 +35,38 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void address_init(
void);
BACNET_STACK_EXPORT
void address_init_partial(
void);
BACNET_STACK_EXPORT
void address_add(
uint32_t device_id,
unsigned max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void address_remove_device(
uint32_t device_id);
BACNET_STACK_EXPORT
bool address_get_by_device(
uint32_t device_id,
unsigned *max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
bool address_get_by_index(
unsigned index,
uint32_t * device_id,
unsigned *max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
bool address_device_get_by_index(
unsigned index,
uint32_t * device_id,
@@ -66,59 +74,73 @@ extern "C" {
unsigned *max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
bool address_get_device_id(
BACNET_ADDRESS * src,
uint32_t * device_id);
BACNET_STACK_EXPORT
unsigned address_count(
void);
BACNET_STACK_EXPORT
bool address_match(
BACNET_ADDRESS * dest,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
bool address_bind_request(
uint32_t device_id,
unsigned *max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
bool address_device_bind_request(
uint32_t device_id,
uint32_t * device_ttl,
unsigned *max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void address_add_binding(
uint32_t device_id,
unsigned max_apdu,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
int address_list_encode(
uint8_t * apdu,
unsigned apdu_len);
BACNET_STACK_EXPORT
int rr_address_list_encode(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
void address_set_device_TTL(
uint32_t device_id,
uint32_t TimeOut,
bool StaticFlag);
BACNET_STACK_EXPORT
void address_cache_timer(
uint16_t uSeconds);
BACNET_STACK_EXPORT
void address_mac_init(
BACNET_MAC_ADDRESS *mac,
uint8_t *adr,
uint8_t len);
BACNET_STACK_EXPORT
bool address_mac_from_ascii(
BACNET_MAC_ADDRESS *mac,
char *arg);
BACNET_STACK_EXPORT
void address_protected_entry_index_set(uint32_t top_protected_entry_index);
BACNET_STACK_EXPORT
void address_own_device_id_set(uint32_t own_id);
#ifdef __cplusplus
src/bacnet/basic/npdu/h_npdu.h
+7
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -41,25 +42,31 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void npdu_handler(
BACNET_ADDRESS * src,
uint8_t * pdu,
uint16_t pdu_len);
BACNET_STACK_EXPORT
void npdu_handler_cleanup(void);
BACNET_STACK_EXPORT
void npdu_handler_init(
uint16_t bip_net,
uint16_t mstp_net);
BACNET_STACK_EXPORT
void npdu_router_handler(
uint16_t snet,
BACNET_ADDRESS * src,
uint8_t * pdu,
uint16_t pdu_len);
BACNET_STACK_EXPORT
int npdu_router_send_pdu(
uint16_t dnet,
BACNET_ADDRESS * dest,
BACNET_NPDU_DATA * npdu_data,
uint8_t * pdu,
unsigned int pdu_len);
BACNET_STACK_EXPORT
void npdu_router_get_my_address(
uint16_t dnet,
BACNET_ADDRESS * my_address);
src/bacnet/basic/npdu/h_routed_npdu.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void routing_npdu_handler(
BACNET_ADDRESS * src,
int *DNET_list,
src/bacnet/basic/npdu/s_router.h
+8
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,27 +42,34 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void npdu_encode_npdu_network(
BACNET_NPDU_DATA *npdu_data,
BACNET_NETWORK_MESSAGE_TYPE network_message_type,
bool data_expecting_reply,
BACNET_MESSAGE_PRIORITY priority);
BACNET_STACK_EXPORT
int Send_Network_Layer_Message(
BACNET_NETWORK_MESSAGE_TYPE network_message_type,
BACNET_ADDRESS * dst,
int *iArgs);
BACNET_STACK_EXPORT
void Send_Who_Is_Router_To_Network(
BACNET_ADDRESS * dst,
int dnet);
BACNET_STACK_EXPORT
void Send_I_Am_Router_To_Network(
const int DNET_list[]);
BACNET_STACK_EXPORT
void Send_Reject_Message_To_Network(
BACNET_ADDRESS * dst,
uint8_t reject_reason,
int dnet);
BACNET_STACK_EXPORT
void Send_Initialize_Routing_Table(
BACNET_ADDRESS * dst,
const int DNET_list[]);
BACNET_STACK_EXPORT
void Send_Initialize_Routing_Table_Ack(
BACNET_ADDRESS * dst,
const int DNET_list[]);
src/bacnet/basic/object/acc.h
+23
View File
@@ -3,6 +3,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacint.h"
#include "bacnet/rp.h"
@@ -11,64 +12,86 @@
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Accumulator_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Accumulator_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Accumulator_Count(
void);
BACNET_STACK_EXPORT
uint32_t Accumulator_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Accumulator_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Accumulator_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
char *Accumulator_Name(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Accumulator_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Accumulator_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Accumulator_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
bool Accumulator_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Accumulator_Units_Set(
uint32_t instance,
uint16_t units);
BACNET_STACK_EXPORT
uint16_t Accumulator_Units(
uint32_t instance);
BACNET_STACK_EXPORT
int Accumulator_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Accumulator_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
BACNET_UNSIGNED_INTEGER Accumulator_Present_Value(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Accumulator_Present_Value_Set(
uint32_t object_instance,
BACNET_UNSIGNED_INTEGER value);
BACNET_STACK_EXPORT
BACNET_UNSIGNED_INTEGER Accumulator_Max_Pres_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Accumulator_Max_Pres_Value_Set(
uint32_t object_instance,
BACNET_UNSIGNED_INTEGER value);
BACNET_STACK_EXPORT
int32_t Accumulator_Scale_Integer(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Accumulator_Scale_Integer_Set(uint32_t object_instance, int32_t);
BACNET_STACK_EXPORT
void Accumulator_Init(
void);
src/bacnet/basic/object/access_credential.h
+16
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/datetime.h"
@@ -75,45 +76,60 @@ extern "C" {
assigned_access_rights[MAX_ASSIGNED_ACCESS_RIGHTS];
} ACCESS_CREDENTIAL_DESCR;
BACNET_STACK_EXPORT
void Access_Credential_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Access_Credential_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Access_Credential_Count(
void);
BACNET_STACK_EXPORT
uint32_t Access_Credential_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Access_Credential_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Credential_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Credential_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Access_Credential_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
int Access_Credential_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Access_Credential_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Access_Credential_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Credential_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Access_Credential_Cleanup(
void);
BACNET_STACK_EXPORT
void Access_Credential_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAccessCredential(
Test * pTest);
#endif
src/bacnet/basic/object/access_door.h
+29
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -57,82 +58,110 @@ extern "C" {
BACNET_DOOR_ALARM_STATE door_alarm_state;
} ACCESS_DOOR_DESCR;
BACNET_STACK_EXPORT
void Access_Door_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Access_Door_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Access_Door_Count(
void);
BACNET_STACK_EXPORT
uint32_t Access_Door_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Access_Door_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Door_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
BACNET_DOOR_VALUE Access_Door_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Access_Door_Present_Value_Priority(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Door_Present_Value_Set(
uint32_t object_instance,
BACNET_DOOR_VALUE value,
unsigned priority);
BACNET_STACK_EXPORT
bool Access_Door_Present_Value_Relinquish(
uint32_t object_instance,
unsigned priority);
BACNET_STACK_EXPORT
BACNET_DOOR_VALUE Access_Door_Relinquish_Default(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Door_Relinquish_Default_Set(
uint32_t object_instance,
float value);
BACNET_STACK_EXPORT
bool Access_Door_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Access_Door_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Door_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
bool Access_Door_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Access_Door_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Access_Door_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Door_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
bool Access_Door_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Access_Door_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
int Access_Door_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Access_Door_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Access_Door_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Door_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Access_Door_Cleanup(
void);
BACNET_STACK_EXPORT
void Access_Door_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAccessDoor(
Test * pTest);
#endif
src/bacnet/basic/object/access_point.h
+17
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/timestamp.h"
@@ -64,52 +65,68 @@ extern "C" {
uint8_t priority_for_writing;
} ACCESS_POINT_DESCR;
BACNET_STACK_EXPORT
void Access_Point_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Access_Point_Valid_Instance(
uint32_t object_instance);
unsigned Access_Point_Count(
void);
BACNET_STACK_EXPORT
uint32_t Access_Point_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Access_Point_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Point_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Point_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Access_Point_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
bool Access_Point_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Access_Point_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
int Access_Point_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Access_Point_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Access_Point_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Point_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Access_Point_Cleanup(
void);
BACNET_STACK_EXPORT
void Access_Point_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAccessPoint(
Test * pTest);
#endif
src/bacnet/basic/object/access_rights.h
+15
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/bacdevobjpropref.h"
@@ -62,44 +63,58 @@ extern "C" {
positive_access_rules[MAX_POSITIVE_ACCESS_RIGHTS_RULES];
} ACCESS_RIGHTS_DESCR;
BACNET_STACK_EXPORT
void Access_Rights_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Access_Rights_Valid_Instance(
uint32_t object_instance);
unsigned Access_Rights_Count(
void);
BACNET_STACK_EXPORT
uint32_t Access_Rights_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Access_Rights_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Rights_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Rights_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Access_Rights_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
int Access_Rights_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Access_Rights_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Access_Rights_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Rights_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Access_Rights_Cleanup(
void);
BACNET_STACK_EXPORT
void Access_Rights_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAccessRights(
Test * pTest);
#endif
src/bacnet/basic/object/access_user.h
+15
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/bacdevobjpropref.h"
@@ -55,44 +56,58 @@ extern "C" {
credentials[MAX_ACCESS_USER_CREDENTIALS_COUNT];
} ACCESS_USER_DESCR;
BACNET_STACK_EXPORT
void Access_User_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Access_User_Valid_Instance(
uint32_t object_instance);
unsigned Access_User_Count(
void);
BACNET_STACK_EXPORT
uint32_t Access_User_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Access_User_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_User_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_User_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Access_User_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
int Access_User_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Access_User_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Access_User_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_User_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Access_User_Cleanup(
void);
BACNET_STACK_EXPORT
void Access_User_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAccessUser(
Test * pTest);
#endif
src/bacnet/basic/object/access_zone.h
+17
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/bacdevobjpropref.h"
@@ -63,50 +64,66 @@ extern "C" {
exit_points[MAX_ACCESS_ZONE_EXIT_POINTS];
} ACCESS_ZONE_DESCR;
BACNET_STACK_EXPORT
void Access_Zone_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Access_Zone_Valid_Instance(
uint32_t object_instance);
unsigned Access_Zone_Count(
void);
BACNET_STACK_EXPORT
uint32_t Access_Zone_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Access_Zone_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Zone_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Access_Zone_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Access_Zone_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
bool Access_Zone_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Access_Zone_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
int Access_Zone_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Access_Zone_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Access_Zone_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Access_Zone_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Access_Zone_Cleanup(
void);
BACNET_STACK_EXPORT
void Access_Zone_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAccessZone(
Test * pTest);
#endif
src/bacnet/basic/object/ai.h
+32
View File
@@ -28,6 +28,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/rp.h"
#include "bacnet/wp.h"
@@ -69,101 +70,132 @@ extern "C" {
#endif
} ANALOG_INPUT_DESCR;
BACNET_STACK_EXPORT
void Analog_Input_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Analog_Input_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Analog_Input_Count(
void);
BACNET_STACK_EXPORT
uint32_t Analog_Input_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Analog_Input_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Input_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Input_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Analog_Input_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Analog_Input_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Input_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
bool Analog_Input_Units_Set(
uint32_t instance,
uint16_t units);
BACNET_STACK_EXPORT
uint16_t Analog_Input_Units(
uint32_t instance);
BACNET_STACK_EXPORT
int Analog_Input_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Analog_Input_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
float Analog_Input_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Analog_Input_Present_Value_Set(
uint32_t object_instance,
float value);
BACNET_STACK_EXPORT
bool Analog_Input_Out_Of_Service(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Analog_Input_Out_Of_Service_Set(
uint32_t object_instance,
bool oos_flag);
BACNET_STACK_EXPORT
bool Analog_Input_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Input_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Input_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
float Analog_Input_COV_Increment(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Input_COV_Increment_Set(
uint32_t instance,
float value);
/* note: header of Intrinsic_Reporting function is required
even when INTRINSIC_REPORTING is not defined */
BACNET_STACK_EXPORT
void Analog_Input_Intrinsic_Reporting(
uint32_t object_instance);
#if defined(INTRINSIC_REPORTING)
BACNET_STACK_EXPORT
int Analog_Input_Event_Information(
unsigned index,
BACNET_GET_EVENT_INFORMATION_DATA * getevent_data);
BACNET_STACK_EXPORT
int Analog_Input_Alarm_Ack(
BACNET_ALARM_ACK_DATA * alarmack_data,
BACNET_ERROR_CODE * error_code);
BACNET_STACK_EXPORT
int Analog_Input_Alarm_Summary(
unsigned index,
BACNET_GET_ALARM_SUMMARY_DATA * getalarm_data);
#endif
BACNET_STACK_EXPORT
bool Analog_Input_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Input_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Analog_Input_Cleanup(
void);
BACNET_STACK_EXPORT
void Analog_Input_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAnalogInput(
Test * pTest);
#endif
src/bacnet/basic/object/ao.h
+35
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,99 +37,133 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Analog_Output_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Analog_Output_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Analog_Output_Count(
void);
BACNET_STACK_EXPORT
uint32_t Analog_Output_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Analog_Output_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Output_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
float Analog_Output_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Analog_Output_Present_Value_Priority(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Output_Present_Value_Set(
uint32_t object_instance,
float value,
unsigned priority);
BACNET_STACK_EXPORT
bool Analog_Output_Present_Value_Relinquish(
uint32_t object_instance,
unsigned priority);
BACNET_STACK_EXPORT
float Analog_Output_Relinquish_Default(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Output_Relinquish_Default_Set(
uint32_t object_instance,
float value);
BACNET_STACK_EXPORT
bool Analog_Output_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Output_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Output_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
float Analog_Output_COV_Increment(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Output_COV_Increment_Set(
uint32_t instance,
float value);
BACNET_STACK_EXPORT
bool Analog_Output_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Analog_Output_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Analog_Output_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Output_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Analog_Output_Reliability(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Output_Reliability_Set(
uint32_t object_instance,
BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
bool Analog_Output_Units_Set(
uint32_t instance,
uint16_t units);
BACNET_STACK_EXPORT
uint16_t Analog_Output_Units(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Output_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Output_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
int Analog_Output_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Analog_Output_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Analog_Output_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Output_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Analog_Output_Cleanup(
void);
BACNET_STACK_EXPORT
void Analog_Output_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAnalogOutput(
Test * pTest);
#endif
src/bacnet/basic/object/av.h
+34
View File
@@ -28,6 +28,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/wp.h"
@@ -70,106 +71,139 @@ extern "C" {
} ANALOG_VALUE_DESCR;
BACNET_STACK_EXPORT
void Analog_Value_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Analog_Value_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Analog_Value_Count(
void);
BACNET_STACK_EXPORT
uint32_t Analog_Value_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Analog_Value_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Value_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Analog_Value_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
int Analog_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Analog_Value_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Analog_Value_Present_Value_Set(
uint32_t object_instance,
float value,
uint8_t priority);
BACNET_STACK_EXPORT
float Analog_Value_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Value_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Value_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Value_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
float Analog_Value_COV_Increment(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Value_COV_Increment_Set(
uint32_t instance,
float value);
BACNET_STACK_EXPORT
char *Analog_Value_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Value_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Analog_Value_Reliability(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Value_Reliability_Set(
uint32_t object_instance,
BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
uint16_t Analog_Value_Units(
uint32_t instance);
BACNET_STACK_EXPORT
bool Analog_Value_Units_Set(
uint32_t instance,
uint16_t unit);
BACNET_STACK_EXPORT
bool Analog_Value_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Analog_Value_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
/* note: header of Intrinsic_Reporting function is required
even when INTRINSIC_REPORTING is not defined */
BACNET_STACK_EXPORT
void Analog_Value_Intrinsic_Reporting(
uint32_t object_instance);
#if defined(INTRINSIC_REPORTING)
BACNET_STACK_EXPORT
int Analog_Value_Event_Information(
unsigned index,
BACNET_GET_EVENT_INFORMATION_DATA * getevent_data);
BACNET_STACK_EXPORT
int Analog_Value_Alarm_Ack(
BACNET_ALARM_ACK_DATA * alarmack_data,
BACNET_ERROR_CODE * error_code);
BACNET_STACK_EXPORT
int Analog_Value_Alarm_Summary(
unsigned index,
BACNET_GET_ALARM_SUMMARY_DATA * getalarm_data);
#endif
BACNET_STACK_EXPORT
bool Analog_Value_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Analog_Value_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Analog_Value_Cleanup(
void);
BACNET_STACK_EXPORT
void Analog_Value_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testAnalog_Value(
Test * pTest);
#endif
src/bacnet/basic/object/bacfile.h
+19
View File
@@ -36,6 +36,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -48,21 +49,28 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void BACfile_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool bacfile_object_name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool bacfile_valid_instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
uint32_t bacfile_count(
void);
BACNET_STACK_EXPORT
uint32_t bacfile_index_to_instance(
unsigned find_index);
BACNET_STACK_EXPORT
unsigned bacfile_instance_to_index(
uint32_t instance);
BACNET_STACK_EXPORT
uint32_t bacfile_instance(
char *filename);
/* this is one way to match up the invoke ID with */
@@ -70,35 +78,46 @@ extern "C" {
/* Another way would be to store the */
/* invokeID and file instance in a list or table */
/* when the request was sent */
BACNET_STACK_EXPORT
uint32_t bacfile_instance_from_tsm(
uint8_t invokeID);
/* handler ACK helper */
BACNET_STACK_EXPORT
bool bacfile_read_stream_data(
BACNET_ATOMIC_READ_FILE_DATA * data);
BACNET_STACK_EXPORT
bool bacfile_read_ack_stream_data(
uint32_t instance,
BACNET_ATOMIC_READ_FILE_DATA * data);
BACNET_STACK_EXPORT
bool bacfile_write_stream_data(
BACNET_ATOMIC_WRITE_FILE_DATA * data);
BACNET_STACK_EXPORT
bool bacfile_read_record_data(
BACNET_ATOMIC_READ_FILE_DATA * data);
BACNET_STACK_EXPORT
bool bacfile_read_ack_record_data(
uint32_t instance,
BACNET_ATOMIC_READ_FILE_DATA * data);
BACNET_STACK_EXPORT
bool bacfile_write_record_data(
BACNET_ATOMIC_WRITE_FILE_DATA * data);
BACNET_STACK_EXPORT
void bacfile_init(
void);
BACNET_STACK_EXPORT
uint32_t bacfile_file_size(
uint32_t instance);
/* handling for read property service */
BACNET_STACK_EXPORT
int bacfile_read_property(
BACNET_READ_PROPERTY_DATA * rpdata);
/* handling for write property service */
BACNET_STACK_EXPORT
bool bacfile_write_property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
src/bacnet/basic/object/bi.h
+33
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/cov.h"
#include "bacnet/rp.h"
@@ -36,95 +37,127 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Binary_Input_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Binary_Input_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Binary_Input_Count(
void);
BACNET_STACK_EXPORT
uint32_t Binary_Input_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Binary_Input_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Input_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Input_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Binary_Input_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_BINARY_PV Binary_Input_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Input_Present_Value_Set(
uint32_t object_instance,
BACNET_BINARY_PV value);
BACNET_STACK_EXPORT
char *Binary_Input_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Input_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Binary_Input_Reliability(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Input_Reliability_Set(
uint32_t object_instance,
BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
char *Binary_Input_Inactive_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Input_Inactive_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Input_Active_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Input_Active_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_POLARITY Binary_Input_Polarity(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Input_Polarity_Set(
uint32_t object_instance,
BACNET_POLARITY polarity);
BACNET_STACK_EXPORT
bool Binary_Input_Out_Of_Service(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Binary_Input_Out_Of_Service_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
bool Binary_Input_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
bool Binary_Input_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Binary_Input_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
int Binary_Input_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Binary_Input_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Binary_Input_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Input_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Binary_Input_Cleanup(
void);
BACNET_STACK_EXPORT
void Binary_Input_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testBinaryInput(
Test * pTest);
#endif
src/bacnet/basic/object/bo.h
+35
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,101 +37,135 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Binary_Output_Init(
void);
BACNET_STACK_EXPORT
void Binary_Output_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Binary_Output_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Binary_Output_Count(
void);
BACNET_STACK_EXPORT
uint32_t Binary_Output_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Binary_Output_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Binary_Output_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Output_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Output_Inactive_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Inactive_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Output_Active_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Active_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_BINARY_PV Binary_Output_Present_Value(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Present_Value_Set(
uint32_t instance,
BACNET_BINARY_PV binary_value,
unsigned priority);
BACNET_STACK_EXPORT
bool Binary_Output_Present_Value_Relinquish(
uint32_t instance,
unsigned priority);
BACNET_STACK_EXPORT
unsigned Binary_Output_Present_Value_Priority(
uint32_t object_instance);
BACNET_STACK_EXPORT
BACNET_POLARITY Binary_Output_Polarity(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Output_Polarity_Set(
uint32_t object_instance,
BACNET_POLARITY polarity);
BACNET_STACK_EXPORT
bool Binary_Output_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Binary_Output_Out_Of_Service_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
BACNET_BINARY_PV Binary_Output_Relinquish_Default(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Output_Relinquish_Default_Set(
uint32_t object_instance,
BACNET_BINARY_PV value);
BACNET_STACK_EXPORT
bool Binary_Output_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
bool Binary_Output_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Binary_Output_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
int Binary_Output_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Binary_Output_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Binary_Output_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Output_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Binary_Output_Cleanup(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testBinaryOutput(
Test * pTest);
#endif
src/bacnet/basic/object/bv.h
+39
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,112 +37,150 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Binary_Value_Init(
void);
BACNET_STACK_EXPORT
void Binary_Value_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Binary_Value_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Binary_Value_Count(
void);
BACNET_STACK_EXPORT
uint32_t Binary_Value_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Binary_Value_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Value_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Binary_Value_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Value_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Binary_Value_Reliability(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Value_Reliability_Set(
uint32_t object_instance,
BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
char *Binary_Value_Inactive_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Inactive_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Value_Active_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Active_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
int Binary_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Binary_Value_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Binary_Value_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
bool Binary_Value_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Binary_Value_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
BACNET_BINARY_PV Binary_Value_Present_Value(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Present_Value_Set(
uint32_t instance,
BACNET_BINARY_PV value);
BACNET_STACK_EXPORT
bool Binary_Value_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Binary_Value_Out_Of_Service_Set(
uint32_t instance,
bool value);
BACNET_STACK_EXPORT
char *Binary_Value_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Description_Set(
uint32_t object_instance,
char *text_string);
BACNET_STACK_EXPORT
char *Binary_Value_Inactive_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Inactive_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
char *Binary_Value_Active_Text(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Active_Text_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_POLARITY Binary_Value_Polarity(
uint32_t instance);
BACNET_STACK_EXPORT
bool Binary_Value_Polarity_Set(
uint32_t object_instance,
BACNET_POLARITY polarity);
BACNET_STACK_EXPORT
bool Binary_Value_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Binary_Value_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Binary_Value_Cleanup(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testBinary_Value(
Test * pTest);
#endif
src/bacnet/basic/object/channel.h
+31
View File
@@ -36,6 +36,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/rp.h"
#include "bacnet/wp.h"
@@ -124,76 +125,106 @@ extern "C" {
struct BACnet_Channel_Value_t *next;
} BACNET_CHANNEL_VALUE;
BACNET_STACK_EXPORT
void Channel_Property_Lists(const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Channel_Valid_Instance(uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Channel_Count(void);
BACNET_STACK_EXPORT
uint32_t Channel_Index_To_Instance(unsigned index);
BACNET_STACK_EXPORT
unsigned Channel_Instance_To_Index(uint32_t instance);
BACNET_STACK_EXPORT
bool Channel_Object_Instance_Add(uint32_t instance);
BACNET_STACK_EXPORT
bool Channel_Object_Name(uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Channel_Name_Set(uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
int Channel_Read_Property(BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Channel_Write_Property(BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
BACNET_CHANNEL_VALUE * Channel_Present_Value(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Channel_Present_Value_Set(
BACNET_WRITE_PROPERTY_DATA * wp_data,
BACNET_APPLICATION_DATA_VALUE * value);
BACNET_STACK_EXPORT
bool Channel_Out_Of_Service(uint32_t object_instance);
BACNET_STACK_EXPORT
void Channel_Out_Of_Service_Set(uint32_t object_instance,
bool oos_flag);
BACNET_STACK_EXPORT
unsigned Channel_Last_Priority(uint32_t object_instance);
BACNET_STACK_EXPORT
BACNET_WRITE_STATUS Channel_Write_Status(uint32_t object_instance);
uint16_t Channel_Number(uint32_t object_instance);
BACNET_STACK_EXPORT
bool Channel_Number_Set(uint32_t object_instance, uint16_t value);
BACNET_STACK_EXPORT
unsigned Channel_Reference_List_Member_Count(uint32_t object_instance);
BACNET_STACK_EXPORT
BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *
Channel_Reference_List_Member_Element(uint32_t object_instance,
unsigned element);
BACNET_STACK_EXPORT
bool Channel_Reference_List_Member_Element_Set(uint32_t object_instance,
unsigned array_index,
BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pMemberSrc);
BACNET_STACK_EXPORT
unsigned Channel_Reference_List_Member_Element_Add(uint32_t object_instance,
BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pMemberSrc);
BACNET_STACK_EXPORT
unsigned Channel_Reference_List_Member_Local_Add(
uint32_t object_instance,
BACNET_OBJECT_TYPE type,
uint32_t instance,
BACNET_PROPERTY_ID propertyIdentifier,
uint32_t arrayIndex);
BACNET_STACK_EXPORT
uint16_t Channel_Control_Groups_Element(
uint32_t object_instance,
int32_t array_index);
BACNET_STACK_EXPORT
bool Channel_Control_Groups_Element_Set(
uint32_t object_instance,
int32_t array_index,
uint16_t value);
BACNET_STACK_EXPORT
bool Channel_Value_Copy(BACNET_CHANNEL_VALUE * cvalue,
BACNET_APPLICATION_DATA_VALUE * value);
BACNET_STACK_EXPORT
int Channel_Value_Encode(uint8_t *apdu, int apdu_max,
BACNET_CHANNEL_VALUE * value);
BACNET_STACK_EXPORT
int Channel_Coerce_Data_Encode(
uint8_t * apdu,
unsigned max_apdu,
BACNET_APPLICATION_DATA_VALUE * value,
BACNET_APPLICATION_TAG tag);
BACNET_STACK_EXPORT
bool Channel_Write_Member_Value(
BACNET_WRITE_PROPERTY_DATA * wp_data,
BACNET_APPLICATION_DATA_VALUE * value);
BACNET_STACK_EXPORT
void Channel_Init(void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testChannelObject(Test * pTest);
#endif
src/bacnet/basic/object/command.h
+26
View File
@@ -44,6 +44,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/rp.h"
#include "bacnet/wp.h"
@@ -90,81 +91,106 @@ extern "C" {
BACNET_ACTION_LIST Action[MAX_COMMAND_ACTIONS];
} COMMAND_DESCR;
BACNET_STACK_EXPORT
void Command_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Command_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Command_Count(
void);
BACNET_STACK_EXPORT
uint32_t Command_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Command_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Command_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Command_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Command_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Command_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Command_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
int Command_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Command_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
uint32_t Command_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Command_Present_Value_Set(
uint32_t object_instance,
uint32_t value);
BACNET_STACK_EXPORT
bool Command_In_Process(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Command_In_Process_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
bool Command_All_Writes_Successful(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Command_All_Writes_Successful_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
bool Command_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Command_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Command_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
float Command_COV_Increment(
uint32_t instance);
BACNET_STACK_EXPORT
void Command_COV_Increment_Set(
uint32_t instance,
float value);
/* note: header of Intrinsic_Reporting function is required
even when INTRINSIC_REPORTING is not defined */
BACNET_STACK_EXPORT
void Command_Intrinsic_Reporting(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Command_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testCommand(
Test * pTest);
#endif
src/bacnet/basic/object/credential_data_input.h
+18
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/timestamp.h"
@@ -60,52 +61,69 @@ extern "C" {
BACNET_TIMESTAMP timestamp;
} CREDENTIAL_DATA_INPUT_DESCR;
BACNET_STACK_EXPORT
void Credential_Data_Input_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Credential_Data_Input_Count(
void);
BACNET_STACK_EXPORT
uint32_t Credential_Data_Input_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Credential_Data_Input_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Credential_Data_Input_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
int Credential_Data_Input_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Credential_Data_Input_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Credential_Data_Input_Cleanup(
void);
BACNET_STACK_EXPORT
void Credential_Data_Input_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testCredentialDataInput(
Test * pTest);
#endif
src/bacnet/basic/object/csv.h
+17
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,55 +37,71 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void CharacterString_Value_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool CharacterString_Value_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned CharacterString_Value_Count(
void);
BACNET_STACK_EXPORT
uint32_t CharacterString_Value_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned CharacterString_Value_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
int CharacterString_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool CharacterString_Value_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
/* optional API */
BACNET_STACK_EXPORT
bool CharacterString_Value_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool CharacterString_Value_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool CharacterString_Value_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
bool CharacterString_Value_Present_Value(
uint32_t object_instance,
BACNET_CHARACTER_STRING * value);
BACNET_STACK_EXPORT
bool CharacterString_Value_Present_Value_Set(
uint32_t object_instance,
BACNET_CHARACTER_STRING * value);
BACNET_STACK_EXPORT
bool CharacterString_Value_Description_Set(
uint32_t object_instance,
char *text_string);
BACNET_STACK_EXPORT
bool CharacterString_Value_Out_Of_Service(
uint32_t object_instance);
BACNET_STACK_EXPORT
void CharacterString_Value_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testCharacterStringValue(
Test * pTest);
#endif
src/bacnet/basic/object/device.h
+77
View File
@@ -31,6 +31,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/wp.h"
@@ -221,164 +222,223 @@ typedef struct devObj_s {
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Device_Init(
object_functions_t * object_table);
BACNET_STACK_EXPORT
bool Device_Reinitialize(
BACNET_REINITIALIZE_DEVICE_DATA * rd_data);
BACNET_STACK_EXPORT
bool Device_Reinitialize_State_Set(BACNET_REINITIALIZED_STATE state);
BACNET_STACK_EXPORT
BACNET_REINITIALIZED_STATE Device_Reinitialized_State(
void);
BACNET_STACK_EXPORT
rr_info_function Device_Objects_RR_Info(
BACNET_OBJECT_TYPE object_type);
BACNET_STACK_EXPORT
void Device_getCurrentDateTime(
BACNET_DATE_TIME * DateTime);
BACNET_STACK_EXPORT
int32_t Device_UTC_Offset(void);
BACNET_STACK_EXPORT
void Device_UTC_Offset_Set(int16_t offset);
BACNET_STACK_EXPORT
bool Device_Daylight_Savings_Status(void);
bool Device_Align_Intervals(void);
BACNET_STACK_EXPORT
bool Device_Align_Intervals_Set(bool flag);
BACNET_STACK_EXPORT
uint32_t Device_Time_Sync_Interval(void);
BACNET_STACK_EXPORT
bool Device_Time_Sync_Interval_Set(uint32_t value);
BACNET_STACK_EXPORT
uint32_t Device_Interval_Offset(void);
BACNET_STACK_EXPORT
bool Device_Interval_Offset_Set(uint32_t value);
BACNET_STACK_EXPORT
void Device_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
void Device_Objects_Property_List(
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance,
struct special_property_list_t *pPropertyList);
/* functions to support COV */
BACNET_STACK_EXPORT
bool Device_Encode_Value_List(
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
bool Device_Value_List_Supported(
BACNET_OBJECT_TYPE object_type);
BACNET_STACK_EXPORT
bool Device_COV(
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance);
BACNET_STACK_EXPORT
void Device_COV_Clear(
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance);
BACNET_STACK_EXPORT
uint32_t Device_Object_Instance_Number(
void);
BACNET_STACK_EXPORT
bool Device_Set_Object_Instance_Number(
uint32_t object_id);
BACNET_STACK_EXPORT
bool Device_Valid_Object_Instance_Number(
uint32_t object_id);
BACNET_STACK_EXPORT
unsigned Device_Object_List_Count(
void);
BACNET_STACK_EXPORT
bool Device_Object_List_Identifier(
uint32_t array_index,
BACNET_OBJECT_TYPE *object_type,
uint32_t * instance);
BACNET_STACK_EXPORT
unsigned Device_Count(
void);
BACNET_STACK_EXPORT
uint32_t Device_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
bool Device_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Device_Set_Object_Name(
BACNET_CHARACTER_STRING * object_name);
/* Copy a child object name, given its ID. */
BACNET_STACK_EXPORT
bool Device_Object_Name_Copy(
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Device_Object_Name_ANSI_Init(const char * object_name);
BACNET_STACK_EXPORT
char * Device_Object_Name_ANSI(void);
BACNET_STACK_EXPORT
BACNET_DEVICE_STATUS Device_System_Status(
void);
BACNET_STACK_EXPORT
int Device_Set_System_Status(
BACNET_DEVICE_STATUS status,
bool local);
BACNET_STACK_EXPORT
const char *Device_Vendor_Name(
void);
BACNET_STACK_EXPORT
uint16_t Device_Vendor_Identifier(
void);
BACNET_STACK_EXPORT
void Device_Set_Vendor_Identifier(
uint16_t vendor_id);
BACNET_STACK_EXPORT
const char *Device_Model_Name(
void);
BACNET_STACK_EXPORT
bool Device_Set_Model_Name(
const char *name,
size_t length);
BACNET_STACK_EXPORT
const char *Device_Firmware_Revision(
void);
BACNET_STACK_EXPORT
const char *Device_Application_Software_Version(
void);
BACNET_STACK_EXPORT
bool Device_Set_Application_Software_Version(
const char *name,
size_t length);
BACNET_STACK_EXPORT
const char *Device_Description(
void);
BACNET_STACK_EXPORT
bool Device_Set_Description(
const char *name,
size_t length);
BACNET_STACK_EXPORT
const char *Device_Location(
void);
BACNET_STACK_EXPORT
bool Device_Set_Location(
const char *name,
size_t length);
/* some stack-centric constant values - no set methods */
BACNET_STACK_EXPORT
uint8_t Device_Protocol_Version(
void);
BACNET_STACK_EXPORT
uint8_t Device_Protocol_Revision(
void);
BACNET_STACK_EXPORT
BACNET_SEGMENTATION Device_Segmentation_Supported(
void);
BACNET_STACK_EXPORT
uint32_t Device_Database_Revision(
void);
BACNET_STACK_EXPORT
void Device_Set_Database_Revision(
uint32_t revision);
BACNET_STACK_EXPORT
void Device_Inc_Database_Revision(
void);
BACNET_STACK_EXPORT
bool Device_Valid_Object_Name(
BACNET_CHARACTER_STRING * object_name,
BACNET_OBJECT_TYPE *object_type,
uint32_t * object_instance);
BACNET_STACK_EXPORT
bool Device_Valid_Object_Id(
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance);
BACNET_STACK_EXPORT
int Device_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Device_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool DeviceGetRRInfo(
BACNET_READ_RANGE_DATA * pRequest, /* Info on the request */
RR_PROP_INFO * pInfo); /* Where to put the information */
BACNET_STACK_EXPORT
int Device_Read_Property_Local(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Device_Write_Property_Local(
BACNET_WRITE_PROPERTY_DATA * wp_data);
#if defined(INTRINSIC_REPORTING)
BACNET_STACK_EXPORT
void Device_local_reporting(
void);
#endif
@@ -387,53 +447,70 @@ extern "C" {
* Enable by defining BAC_ROUTING in config.h and including gw_device.c
* in the build (lib/Makefile).
*/
BACNET_STACK_EXPORT
void Routing_Device_Init(
uint32_t first_object_instance);
BACNET_STACK_EXPORT
uint16_t Add_Routed_Device(
uint32_t Object_Instance,
BACNET_CHARACTER_STRING * Object_Name,
const char *Description);
BACNET_STACK_EXPORT
DEVICE_OBJECT_DATA *Get_Routed_Device_Object(
int idx);
BACNET_STACK_EXPORT
BACNET_ADDRESS *Get_Routed_Device_Address(
int idx);
BACNET_STACK_EXPORT
void routed_get_my_address(
BACNET_ADDRESS * my_address);
BACNET_STACK_EXPORT
bool Routed_Device_Address_Lookup(
int idx,
uint8_t address_len,
uint8_t * mac_adress);
BACNET_STACK_EXPORT
bool Routed_Device_GetNext(
BACNET_ADDRESS * dest,
int *DNET_list,
int *cursor);
BACNET_STACK_EXPORT
bool Routed_Device_Is_Valid_Network(
uint16_t dest_net,
int *DNET_list);
BACNET_STACK_EXPORT
uint32_t Routed_Device_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
bool Routed_Device_Valid_Object_Instance_Number(
uint32_t object_id);
BACNET_STACK_EXPORT
bool Routed_Device_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
uint32_t Routed_Device_Object_Instance_Number(
void);
BACNET_STACK_EXPORT
bool Routed_Device_Set_Object_Instance_Number(
uint32_t object_id);
BACNET_STACK_EXPORT
bool Routed_Device_Set_Object_Name(
uint8_t encoding,
const char *value,
size_t length);
BACNET_STACK_EXPORT
bool Routed_Device_Set_Description(
const char *name,
size_t length);
BACNET_STACK_EXPORT
void Routed_Device_Inc_Database_Revision(
void);
BACNET_STACK_EXPORT
int Routed_Device_Service_Approval(
BACNET_CONFIRMED_SERVICE service,
int service_argument,
src/bacnet/basic/object/iv.h
+24
View File
@@ -35,6 +35,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/wp.h"
@@ -44,72 +45,95 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Integer_Value_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Integer_Value_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Integer_Value_Count(
void);
BACNET_STACK_EXPORT
uint32_t Integer_Value_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Integer_Value_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Integer_Value_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
int Integer_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Integer_Value_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Integer_Value_Present_Value_Set(
uint32_t object_instance,
int32_t value,
uint8_t priority);
BACNET_STACK_EXPORT
int32_t Integer_Value_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Integer_Value_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Integer_Value_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Integer_Value_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
float Integer_Value_COV_Increment(
uint32_t instance);
BACNET_STACK_EXPORT
void Integer_Value_COV_Increment_Set(
uint32_t instance,
float value);
BACNET_STACK_EXPORT
char *Integer_Value_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Integer_Value_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
uint16_t Integer_Value_Units(
uint32_t instance);
BACNET_STACK_EXPORT
bool Integer_Value_Units_Set(
uint32_t instance,
uint16_t unit);
BACNET_STACK_EXPORT
bool Integer_Value_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Integer_Value_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
void Integer_Value_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testInteger_Value(
Test * pTest);
#endif
src/bacnet/basic/object/lc.h
+13
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,39 +37,51 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Load_Control_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
void Load_Control_State_Machine_Handler(
void);
BACNET_STACK_EXPORT
bool Load_Control_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Load_Control_Count(
void);
BACNET_STACK_EXPORT
uint32_t Load_Control_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Load_Control_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Load_Control_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
void Load_Control_Init(
void);
BACNET_STACK_EXPORT
void Load_Control_State_Machine(
int object_index);
BACNET_STACK_EXPORT
int Load_Control_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Load_Control_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testLoadControl(
Test * pTest);
#endif
src/bacnet/basic/object/lo.h
+48
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,141 +37,188 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Lighting_Output_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Lighting_Output_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Lighting_Output_Count(
void);
BACNET_STACK_EXPORT
uint32_t Lighting_Output_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Lighting_Output_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
float Lighting_Output_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Lighting_Output_Present_Value_Priority(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Present_Value_Set(
uint32_t object_instance,
float value,
unsigned priority);
BACNET_STACK_EXPORT
bool Lighting_Output_Present_Value_Relinquish(
uint32_t object_instance,
unsigned priority);
BACNET_STACK_EXPORT
float Lighting_Output_Relinquish_Default(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Relinquish_Default_Set(
uint32_t object_instance,
float value);
BACNET_STACK_EXPORT
bool Lighting_Output_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Lighting_Output_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
float Lighting_Output_COV_Increment(
uint32_t instance);
BACNET_STACK_EXPORT
void Lighting_Output_COV_Increment_Set(
uint32_t instance,
float value);
BACNET_STACK_EXPORT
bool Lighting_Output_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Lighting_Output_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Lighting_Output_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
bool Lighting_Output_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Lighting_Output_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
bool Lighting_Output_Lighting_Command_Set(
uint32_t object_instance,
BACNET_LIGHTING_COMMAND *value);
BACNET_STACK_EXPORT
bool Lighting_Output_Lighting_Command(
uint32_t object_instance,
BACNET_LIGHTING_COMMAND *value);
BACNET_STACK_EXPORT
BACNET_LIGHTING_IN_PROGRESS Lighting_Output_In_Progress(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_In_Progress_Set(
uint32_t object_instance,
BACNET_LIGHTING_IN_PROGRESS in_progress);
BACNET_STACK_EXPORT
float Lighting_Output_Tracking_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Tracking_Value_Set(
uint32_t object_instance,
float value);
BACNET_STACK_EXPORT
bool Lighting_Output_Blink_Warn_Enable(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Blink_Warn_Enable_Set(
uint32_t object_instance,
bool enable);
BACNET_STACK_EXPORT
uint32_t Lighting_Output_Egress_Time(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Egress_Time_Set(
uint32_t object_instance,
uint32_t seconds);
BACNET_STACK_EXPORT
bool Lighting_Output_Egress_Active(
uint32_t object_instance);
BACNET_STACK_EXPORT
uint32_t Lighting_Output_Default_Fade_Time(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Default_Fade_Time_Set(
uint32_t object_instance,
uint32_t milliseconds);
BACNET_STACK_EXPORT
float Lighting_Output_Default_Ramp_Rate(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Default_Ramp_Rate_Set(
uint32_t object_instance,
float percent_per_second);
BACNET_STACK_EXPORT
float Lighting_Output_Default_Step_Increment(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Default_Step_Increment_Set(
uint32_t object_instance,
float step_increment);
BACNET_STACK_EXPORT
unsigned Lighting_Output_Default_Priority(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Lighting_Output_Default_Priority_Set(
uint32_t object_instance,
unsigned priority);
BACNET_STACK_EXPORT
void Lighting_Output_Timer(
uint16_t milliseconds);
BACNET_STACK_EXPORT
void Lighting_Output_Init(
void);
BACNET_STACK_EXPORT
int Lighting_Output_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Lighting_Output_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testLightingOutput(
Test * pTest);
#endif
src/bacnet/basic/object/lsp.h
+11
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,32 +37,42 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Life_Safety_Point_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Life_Safety_Point_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Life_Safety_Point_Count(
void);
BACNET_STACK_EXPORT
uint32_t Life_Safety_Point_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Life_Safety_Point_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Life_Safety_Point_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
void Life_Safety_Point_Init(
void);
BACNET_STACK_EXPORT
int Life_Safety_Point_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Life_Safety_Point_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testLifeSafetyPoint(
Test * pTest);
#endif
src/bacnet/basic/object/ms-input.h
+30
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,93 +37,122 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Multistate_Input_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Multistate_Input_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Multistate_Input_Count(
void);
BACNET_STACK_EXPORT
uint32_t Multistate_Input_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Multistate_Input_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
int Multistate_Input_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Multistate_Input_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
/* optional API */
BACNET_STACK_EXPORT
bool Multistate_Input_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Input_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Multistate_Input_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
uint32_t Multistate_Input_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Multistate_Input_Present_Value_Set(
uint32_t object_instance,
uint32_t value);
BACNET_STACK_EXPORT
bool Multistate_Input_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Multistate_Input_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Input_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
bool Multistate_Input_Out_Of_Service(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Multistate_Input_Out_Of_Service_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
char *Multistate_Input_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Input_Description_Set(
uint32_t object_instance,
char *text_string);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Multistate_Input_Reliability(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Multistate_Input_Reliability_Set(
uint32_t object_instance,
BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
bool Multistate_Input_State_Text_Set(
uint32_t object_instance,
uint32_t state_index,
char *new_name);
BACNET_STACK_EXPORT
bool Multistate_Input_Max_States_Set(
uint32_t instance,
uint32_t max_states_requested);
BACNET_STACK_EXPORT
char *Multistate_Input_State_Text(
uint32_t object_instance,
uint32_t state_index);
BACNET_STACK_EXPORT
bool Multistate_Input_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Multistate_Input_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Multistate_Input_Cleanup(
void);
BACNET_STACK_EXPORT
void Multistate_Input_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testMultistateInput(
Test * pTest);
#endif
src/bacnet/basic/object/mso.h
+24
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,69 +37,91 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Multistate_Output_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Multistate_Output_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Multistate_Output_Count(
void);
BACNET_STACK_EXPORT
uint32_t Multistate_Output_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Multistate_Output_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Multistate_Output_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
void Multistate_Output_Init(
void);
BACNET_STACK_EXPORT
int Multistate_Output_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Multistate_Output_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
bool Multistate_Output_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Multistate_Output_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Output_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
uint32_t Multistate_Output_Present_Value(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Output_Present_Value_Set(
uint32_t instance,
unsigned value,
unsigned priority);
BACNET_STACK_EXPORT
bool Multistate_Output_Present_Value_Relinquish(
uint32_t instance,
unsigned priority);
BACNET_STACK_EXPORT
bool Multistate_Output_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
void Multistate_Output_Out_Of_Service_Set(
uint32_t instance,
bool value);
BACNET_STACK_EXPORT
char *Multistate_Output_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Output_Description_Set(
uint32_t object_instance,
char *text_string);
BACNET_STACK_EXPORT
bool Multistate_Output_State_Text_Set(
uint32_t object_instance,
uint32_t state_index,
char *new_name);
BACNET_STACK_EXPORT
bool Multistate_Output_Max_States_Set(
uint32_t instance,
uint32_t max_states_requested);
BACNET_STACK_EXPORT
char *Multistate_Output_State_Text(
uint32_t object_instance,
uint32_t state_index);
@@ -106,6 +129,7 @@ extern "C" {
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testMultistateOutput(
Test * pTest);
#endif
src/bacnet/basic/object/msv.h
+24
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/rp.h"
@@ -36,23 +37,30 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Multistate_Value_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Multistate_Value_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Multistate_Value_Count(
void);
BACNET_STACK_EXPORT
uint32_t Multistate_Value_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Multistate_Value_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
int Multistate_Value_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Multistate_Value_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
@@ -60,56 +68,72 @@ extern "C" {
bool Multistate_Value_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Value_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Multistate_Value_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
uint32_t Multistate_Value_Present_Value(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Multistate_Value_Present_Value_Set(
uint32_t object_instance,
uint32_t value);
BACNET_STACK_EXPORT
bool Multistate_Value_Change_Of_Value(
uint32_t instance);
BACNET_STACK_EXPORT
void Multistate_Value_Change_Of_Value_Clear(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Value_Encode_Value_List(
uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
bool Multistate_Value_Out_Of_Service(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Multistate_Value_Out_Of_Service_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
char *Multistate_Value_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Multistate_Value_Description_Set(
uint32_t object_instance,
char *text_string);
BACNET_STACK_EXPORT
bool Multistate_Value_State_Text_Set(
uint32_t object_instance,
uint32_t state_index,
char *new_name);
BACNET_STACK_EXPORT
bool Multistate_Value_Max_States_Set(
uint32_t instance,
uint32_t max_states_requested);
BACNET_STACK_EXPORT
char *Multistate_Value_State_Text(
uint32_t object_instance,
uint32_t state_index);
BACNET_STACK_EXPORT
void Multistate_Value_Init(
void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testMultistateValue(
Test * pTest);
#endif
src/bacnet/basic/object/nc.h
+12
View File
@@ -25,6 +25,7 @@
#ifndef NC_H
#define NC_H
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/event.h"
@@ -97,39 +98,50 @@ BACnetRecipient ::= CHOICE {
BACNET_STACK_EXPORT
void Notification_Class_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
void Notification_Class_Init(
void);
bool Notification_Class_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Notification_Class_Count(
void);
BACNET_STACK_EXPORT
uint32_t Notification_Class_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Notification_Class_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Notification_Class_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
int Notification_Class_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Notification_Class_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
void Notification_Class_Get_Priorities(
uint32_t Object_Instance,
uint32_t * pPriorityArray);
BACNET_STACK_EXPORT
void Notification_Class_common_reporting_function(
BACNET_EVENT_NOTIFICATION_DATA * event_data);
BACNET_STACK_EXPORT
void Notification_Class_find_recipient(
void);
#endif /* defined(INTRINSIC_REPORTING) */
src/bacnet/basic/object/netport.h
+81
View File
@@ -36,6 +36,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -46,263 +47,343 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Network_Port_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
void Network_Port_Property_List(
uint32_t object_instance,
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Network_Port_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
bool Network_Port_Name_Set(
uint32_t object_instance,
char *new_name);
BACNET_STACK_EXPORT
char *Network_Port_Description(
uint32_t instance);
BACNET_STACK_EXPORT
bool Network_Port_Description_Set(
uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
BACNET_RELIABILITY Network_Port_Reliability(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Reliability_Set(
uint32_t object_instance,
BACNET_RELIABILITY value);
BACNET_STACK_EXPORT
bool Network_Port_Out_Of_Service(
uint32_t instance);
BACNET_STACK_EXPORT
bool Network_Port_Out_Of_Service_Set(
uint32_t instance,
bool oos_flag);
BACNET_STACK_EXPORT
uint8_t Network_Port_Type(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Type_Set(
uint32_t object_instance,
uint8_t value);
BACNET_STACK_EXPORT
uint16_t Network_Port_Network_Number(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Network_Number_Set(
uint32_t object_instance,
uint16_t value);
BACNET_STACK_EXPORT
BACNET_PORT_QUALITY Network_Port_Quality(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Quality_Set(
uint32_t object_instance,
BACNET_PORT_QUALITY value);
BACNET_STACK_EXPORT
bool Network_Port_MAC_Address(
uint32_t object_instance,
BACNET_OCTET_STRING *mac_address);
BACNET_STACK_EXPORT
bool Network_Port_MAC_Address_Set(
uint32_t object_instance,
uint8_t *mac_src,
uint8_t mac_len);
BACNET_STACK_EXPORT
uint16_t Network_Port_APDU_Length(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_APDU_Length_Set(
uint32_t object_instance,
uint16_t value);
BACNET_STACK_EXPORT
uint8_t Network_Port_MSTP_Max_Master(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_MSTP_Max_Master_Set(
uint32_t object_instance,
uint8_t value);
BACNET_STACK_EXPORT
uint8_t Network_Port_MSTP_Max_Info_Frames(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_MSTP_Max_Info_Frames_Set(
uint32_t object_instance,
uint8_t value);
BACNET_STACK_EXPORT
float Network_Port_Link_Speed(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Link_Speed_Set(
uint32_t object_instance,
float value);
BACNET_STACK_EXPORT
bool Network_Port_IP_Address(
uint32_t object_instance,
BACNET_OCTET_STRING *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IP_Address_Get(
uint32_t object_instance,
uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
BACNET_STACK_EXPORT
bool Network_Port_IP_Address_Set(
uint32_t object_instance,
uint8_t a, uint8_t b, uint8_t c, uint8_t d);
BACNET_STACK_EXPORT
uint8_t Network_Port_IP_Subnet_Prefix(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_IP_Subnet_Prefix_Set(
uint32_t object_instance,
uint8_t value);
BACNET_STACK_EXPORT
bool Network_Port_IP_Subnet(
uint32_t object_instance,
BACNET_OCTET_STRING *subnet_mask);
BACNET_STACK_EXPORT
bool Network_Port_IP_Subnet_Get(
uint32_t object_instance,
uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
BACNET_STACK_EXPORT
bool Network_Port_IP_Subnet_Set(
uint32_t object_instance,
uint8_t a, uint8_t b, uint8_t c, uint8_t d);
BACNET_STACK_EXPORT
bool Network_Port_IP_Gateway(
uint32_t object_instance,
BACNET_OCTET_STRING *subnet_mask);
BACNET_STACK_EXPORT
bool Network_Port_IP_Gateway_Get(
uint32_t object_instance,
uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
BACNET_STACK_EXPORT
bool Network_Port_IP_Gateway_Set(
uint32_t object_instance,
uint8_t a, uint8_t b, uint8_t c, uint8_t d);
BACNET_STACK_EXPORT
bool Network_Port_IP_DNS_Server(
uint32_t object_instance,
unsigned index,
BACNET_OCTET_STRING *subnet_mask);
BACNET_STACK_EXPORT
bool Network_Port_IP_DNS_Server_Get(
uint32_t object_instance,
unsigned index,
uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
BACNET_STACK_EXPORT
bool Network_Port_IP_DNS_Server_Set(
uint32_t object_instance,
unsigned index,
uint8_t a, uint8_t b, uint8_t c, uint8_t d);
BACNET_STACK_EXPORT
uint16_t Network_Port_BIP_Port(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_BIP_Port_Set(
uint32_t object_instance,
uint16_t value);
BACNET_STACK_EXPORT
BACNET_IP_MODE Network_Port_BIP_Mode(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_BIP_Mode_Set(
uint32_t object_instance,
BACNET_IP_MODE value);
BACNET_STACK_EXPORT
bool Network_Port_BBMD_Accept_FD_Registrations(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_BBMD_Accept_FD_Registrations_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
BACNET_IP_MODE Network_Port_BIP6_Mode(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_BIP6_Mode_Set(
uint32_t object_instance,
BACNET_IP_MODE value);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Address(
uint32_t object_instance,
BACNET_OCTET_STRING *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Address_Set(
uint32_t object_instance,
uint8_t *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Multicast_Address(
uint32_t object_instance,
BACNET_OCTET_STRING *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Multicast_Address_Set(
uint32_t object_instance,
uint8_t *ip_address);
BACNET_STACK_EXPORT
uint8_t Network_Port_IPv6_Subnet_Prefix(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Subnet_Prefix_Set(
uint32_t object_instance,
uint8_t value);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Gateway(
uint32_t object_instance,
BACNET_OCTET_STRING *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Gateway_Set(
uint32_t object_instance,
uint8_t *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_DNS_Server(
uint32_t object_instance,
unsigned dns_index,
BACNET_OCTET_STRING *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_DNS_Server_Set(
uint32_t object_instance,
unsigned dns_index,
uint8_t *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_DHCP_Server(
uint32_t object_instance,
BACNET_OCTET_STRING *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_DHCP_Server_Set(
uint32_t object_instance,
uint8_t *ip_address);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Zone_Index(
uint32_t object_instance,
BACNET_CHARACTER_STRING *zone_index);
BACNET_STACK_EXPORT
bool Network_Port_IPv6_Gateway_Zone_Index_Set(
uint32_t object_instance,
char *zone_index);
BACNET_STACK_EXPORT
uint16_t Network_Port_BIP6_Port(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_BIP6_Port_Set(
uint32_t object_instance,
uint16_t value);
BACNET_STACK_EXPORT
bool Network_Port_Changes_Pending(
uint32_t instance);
BACNET_STACK_EXPORT
bool Network_Port_Changes_Pending_Set(
uint32_t instance,
bool flag);
BACNET_STACK_EXPORT
bool Network_Port_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Network_Port_Count(
void);
BACNET_STACK_EXPORT
uint32_t Network_Port_Index_To_Instance(
unsigned find_index);
BACNET_STACK_EXPORT
unsigned Network_Port_Instance_To_Index(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Object_Instance_Number_Set(
unsigned index,
uint32_t object_instance);
BACNET_STACK_EXPORT
int Network_Port_Read_Range_BDT(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
int Network_Port_Read_Range_FDT(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
bool Network_Port_Read_Range(
BACNET_READ_RANGE_DATA * pRequest,
RR_PROP_INFO * pInfo);
BACNET_STACK_EXPORT
bool Network_Port_Create(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Network_Port_Delete(
uint32_t object_instance);
BACNET_STACK_EXPORT
void Network_Port_Cleanup(
void);
BACNET_STACK_EXPORT
void Network_Port_Init(
void);
/* handling for read property service */
BACNET_STACK_EXPORT
int Network_Port_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
/* handling for write property service */
BACNET_STACK_EXPORT
bool Network_Port_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
src/bacnet/basic/object/osv.h
+21
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/wp.h"
@@ -43,49 +44,69 @@ extern "C" {
} OCTETSTRING_VALUE_DESCR;
BACNET_STACK_EXPORT
void OctetString_Value_Property_Lists(const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool OctetString_Value_Valid_Instance(uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned OctetString_Value_Count(void);
BACNET_STACK_EXPORT
uint32_t OctetString_Value_Index_To_Instance(unsigned index);
BACNET_STACK_EXPORT
unsigned OctetString_Value_Instance_To_Index(uint32_t object_instance);
BACNET_STACK_EXPORT
bool OctetString_Value_Object_Name(uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
int OctetString_Value_Read_Property(BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool OctetString_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *
wp_data);
BACNET_STACK_EXPORT
bool OctetString_Value_Present_Value_Set(uint32_t object_instance,
BACNET_OCTET_STRING * value,
uint8_t priority);
BACNET_STACK_EXPORT
BACNET_OCTET_STRING *OctetString_Value_Present_Value(uint32_t
object_instance);
BACNET_STACK_EXPORT
bool OctetString_Value_Change_Of_Value(uint32_t instance);
BACNET_STACK_EXPORT
void OctetString_Value_Change_Of_Value_Clear(uint32_t instance);
BACNET_STACK_EXPORT
bool OctetString_Value_Encode_Value_List(uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
char *OctetString_Value_Description(uint32_t instance);
BACNET_STACK_EXPORT
bool OctetString_Value_Description_Set(uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
bool OctetString_Value_Out_Of_Service(uint32_t instance);
BACNET_STACK_EXPORT
void OctetString_Value_Out_Of_Service_Set(uint32_t instance,
bool oos_flag);
/* note: header of Intrinsic_Reporting function is required
even when INTRINSIC_REPORTING is not defined */
BACNET_STACK_EXPORT
void OctetString_Value_Intrinsic_Reporting(uint32_t object_instance);
BACNET_STACK_EXPORT
void OctetString_Value_Init(void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testOctetString_Value(Test * pTest);
#endif
src/bacnet/basic/object/piv.h
+20
View File
@@ -27,6 +27,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacerror.h"
#include "bacnet/wp.h"
@@ -43,49 +44,68 @@ extern "C" {
} POSITIVEINTEGER_VALUE_DESCR;
BACNET_STACK_EXPORT
void PositiveInteger_Value_Property_Lists(const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Valid_Instance(uint32_t object_instance);
unsigned PositiveInteger_Value_Count(void);
BACNET_STACK_EXPORT
uint32_t PositiveInteger_Value_Index_To_Instance(unsigned index);
BACNET_STACK_EXPORT
unsigned PositiveInteger_Value_Instance_To_Index(uint32_t object_instance);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Object_Name(uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
int PositiveInteger_Value_Read_Property(BACNET_READ_PROPERTY_DATA *
rpdata);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *
wp_data);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Present_Value_Set(uint32_t object_instance,
uint32_t value,
uint8_t priority);
BACNET_STACK_EXPORT
uint32_t PositiveInteger_Value_Present_Value(uint32_t object_instance);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Change_Of_Value(uint32_t instance);
BACNET_STACK_EXPORT
void PositiveInteger_Value_Change_Of_Value_Clear(uint32_t instance);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Encode_Value_List(uint32_t object_instance,
BACNET_PROPERTY_VALUE * value_list);
BACNET_STACK_EXPORT
char *PositiveInteger_Value_Description(uint32_t instance);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Description_Set(uint32_t instance,
char *new_name);
BACNET_STACK_EXPORT
bool PositiveInteger_Value_Out_Of_Service(uint32_t instance);
BACNET_STACK_EXPORT
void PositiveInteger_Value_Out_Of_Service_Set(uint32_t instance,
bool oos_flag);
/* note: header of Intrinsic_Reporting function is required
even when INTRINSIC_REPORTING is not defined */
BACNET_STACK_EXPORT
void PositiveInteger_Value_Intrinsic_Reporting(uint32_t object_instance);
BACNET_STACK_EXPORT
void PositiveInteger_Value_Init(void);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testPositiveInteger_Value(Test * pTest);
#endif
src/bacnet/basic/object/schedule.h
+14
View File
@@ -28,6 +28,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacapp.h"
#include "bacnet/datetime.h"
@@ -71,33 +72,46 @@ extern "C" {
bool Out_Of_Service;
} SCHEDULE_DESCR;
BACNET_STACK_EXPORT
void Schedule_Property_Lists(const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Schedule_Valid_Instance(uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Schedule_Count(void);
BACNET_STACK_EXPORT
uint32_t Schedule_Index_To_Instance(unsigned index);
BACNET_STACK_EXPORT
unsigned Schedule_Instance_To_Index(uint32_t instance);
BACNET_STACK_EXPORT
void Schedule_Init(void);
BACNET_STACK_EXPORT
void Schedule_Out_Of_Service_Set(
uint32_t object_instance,
bool value);
BACNET_STACK_EXPORT
bool Schedule_Out_Of_Service(
uint32_t object_instance);
BACNET_STACK_EXPORT
bool Schedule_Object_Name(uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
int Schedule_Read_Property(BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Schedule_Write_Property(BACNET_WRITE_PROPERTY_DATA * wp_data);
/* utility functions for calculating current Present Value
* if Exception Schedule is to be added, these functions must take that into account */
BACNET_STACK_EXPORT
bool Schedule_In_Effective_Period(SCHEDULE_DESCR * desc,
BACNET_DATE * date);
BACNET_STACK_EXPORT
void Schedule_Recalculate_PV(SCHEDULE_DESCR * desc,
BACNET_WEEKDAY wday,
BACNET_TIME * time);
src/bacnet/basic/object/trendlog.h
+22
View File
@@ -28,6 +28,7 @@
#include <stdbool.h>
#include <stdint.h>
#include <time.h> /* for time_t */
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/cov.h"
#include "bacnet/rp.h"
@@ -123,74 +124,95 @@ extern "C" {
#define TL_TYPE_ANY 10 /* We don't support this particular can of worms! */
BACNET_STACK_EXPORT
void Trend_Log_Property_Lists(
const int **pRequired,
const int **pOptional,
const int **pProprietary);
BACNET_STACK_EXPORT
bool Trend_Log_Valid_Instance(
uint32_t object_instance);
BACNET_STACK_EXPORT
unsigned Trend_Log_Count(
void);
BACNET_STACK_EXPORT
uint32_t Trend_Log_Index_To_Instance(
unsigned index);
BACNET_STACK_EXPORT
unsigned Trend_Log_Instance_To_Index(
uint32_t instance);
BACNET_STACK_EXPORT
bool Trend_Log_Object_Instance_Add(
uint32_t instance);
BACNET_STACK_EXPORT
bool Trend_Log_Object_Name(
uint32_t object_instance,
BACNET_CHARACTER_STRING * object_name);
BACNET_STACK_EXPORT
int Trend_Log_Read_Property(
BACNET_READ_PROPERTY_DATA * rpdata);
BACNET_STACK_EXPORT
bool Trend_Log_Write_Property(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
void Trend_Log_Init(
void);
BACNET_STACK_EXPORT
void TL_Insert_Status_Rec(
int iLog,
BACNET_LOG_STATUS eStatus,
bool bState);
BACNET_STACK_EXPORT
bool TL_Is_Enabled(
int iLog);
BACNET_STACK_EXPORT
time_t TL_BAC_Time_To_Local(
BACNET_DATE_TIME * SourceTime);
BACNET_STACK_EXPORT
void TL_Local_Time_To_BAC(
BACNET_DATE_TIME * DestTime,
time_t SourceTime);
BACNET_STACK_EXPORT
int TL_encode_entry(
uint8_t * apdu,
int iLog,
int iEntry);
BACNET_STACK_EXPORT
int TL_encode_by_position(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
int TL_encode_by_sequence(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
int TL_encode_by_time(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
bool TrendLogGetRRInfo(
BACNET_READ_RANGE_DATA * pRequest, /* Info on the request */
RR_PROP_INFO * pInfo); /* Where to put the information */
BACNET_STACK_EXPORT
int rr_trend_log_encode(
uint8_t * apdu,
BACNET_READ_RANGE_DATA * pRequest);
BACNET_STACK_EXPORT
void trend_log_timer(
uint16_t uSeconds);
src/bacnet/basic/service/h_alarm_ack.h
+3
View File
@@ -30,6 +30,7 @@
#include <stdint.h>
#include <stdbool.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -39,12 +40,14 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_alarm_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
BACNET_STACK_EXPORT
void handler_alarm_ack_set(
BACNET_OBJECT_TYPE object_type,
alarm_ack_function pFunction);
src/bacnet/basic/service/h_apdu.h
+17
View File
@@ -30,6 +30,7 @@
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -110,49 +111,60 @@ extern "C" {
uint8_t invoke_id,
uint8_t reject_reason);
BACNET_STACK_EXPORT
void apdu_set_confirmed_ack_handler(
BACNET_CONFIRMED_SERVICE service_choice,
confirmed_ack_function pFunction);
BACNET_STACK_EXPORT
void apdu_set_confirmed_simple_ack_handler(
BACNET_CONFIRMED_SERVICE service_choice,
confirmed_simple_ack_function pFunction);
/* configure reject for confirmed services that are not supported */
BACNET_STACK_EXPORT
void apdu_set_unrecognized_service_handler_handler(
confirmed_function pFunction);
BACNET_STACK_EXPORT
void apdu_set_confirmed_handler(
BACNET_CONFIRMED_SERVICE service_choice,
confirmed_function pFunction);
BACNET_STACK_EXPORT
void apdu_set_unconfirmed_handler(
BACNET_UNCONFIRMED_SERVICE service_choice,
unconfirmed_function pFunction);
/* returns true if the service is supported by a handler */
BACNET_STACK_EXPORT
bool apdu_service_supported(
BACNET_SERVICES_SUPPORTED service_supported);
/* Function to translate a SERVICE_SUPPORTED_ enum to its SERVICE_CONFIRMED_
* or SERVICE_UNCONFIRMED_ index.
*/
BACNET_STACK_EXPORT
bool apdu_service_supported_to_index(
BACNET_SERVICES_SUPPORTED service_supported,
size_t * index,
bool * bIsConfirmed);
BACNET_STACK_EXPORT
void apdu_set_error_handler(
BACNET_CONFIRMED_SERVICE service_choice,
error_function pFunction);
BACNET_STACK_EXPORT
void apdu_set_abort_handler(
abort_function pFunction);
BACNET_STACK_EXPORT
void apdu_set_reject_handler(
reject_function pFunction);
BACNET_STACK_EXPORT
uint16_t apdu_decode_confirmed_service_request(
uint8_t * apdu, /* APDU data */
uint16_t apdu_len,
@@ -161,15 +173,20 @@ extern "C" {
uint8_t ** service_request,
uint16_t * service_request_len);
BACNET_STACK_EXPORT
uint16_t apdu_timeout(
void);
BACNET_STACK_EXPORT
void apdu_timeout_set(
uint16_t value);
BACNET_STACK_EXPORT
uint8_t apdu_retries(
void);
BACNET_STACK_EXPORT
void apdu_retries_set(
uint8_t value);
BACNET_STACK_EXPORT
void apdu_handler(
BACNET_ADDRESS * src, /* source address */
uint8_t * apdu, /* APDU data */
src/bacnet/basic/service/h_arf.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_atomic_read_file(uint8_t* service_request, uint16_t service_len,
BACNET_ADDRESS* src,
BACNET_CONFIRMED_SERVICE_DATA* service_data);
src/bacnet/basic/service/h_arf_a.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_atomic_read_file_ack(
uint8_t* service_request, uint16_t service_len, BACNET_ADDRESS* src,
BACNET_CONFIRMED_SERVICE_ACK_DATA* service_data);
src/bacnet/basic/service/h_awf.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_atomic_write_file(uint8_t* service_request, uint16_t service_len,
BACNET_ADDRESS* src,
BACNET_CONFIRMED_SERVICE_DATA* service_data);
src/bacnet/basic/service/h_ccov.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_ccov_notification(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_cov.h
+7
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,19 +41,25 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_cov_subscribe(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
BACNET_STACK_EXPORT
bool handler_cov_fsm(
void);
BACNET_STACK_EXPORT
void handler_cov_task(
void);
BACNET_STACK_EXPORT
void handler_cov_timer_seconds(
uint32_t elapsed_seconds);
BACNET_STACK_EXPORT
void handler_cov_init(
void);
BACNET_STACK_EXPORT
int handler_cov_encode_subscriptions(
uint8_t * apdu,
int max_apdu);
src/bacnet/basic/service/h_dcc.h
+4
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,13 +41,16 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_device_communication_control(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
BACNET_STACK_EXPORT
void handler_dcc_password_set(
char *new_password);
BACNET_STACK_EXPORT
char *handler_dcc_password(void);
#ifdef __cplusplus
src/bacnet/basic/service/h_gas_a.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void get_alarm_summary_ack_handler(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_get_alarm_sum.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -41,10 +42,12 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_get_alarm_summary_set(
BACNET_OBJECT_TYPE object_type,
get_alarm_summary_function pFunction);
BACNET_STACK_EXPORT
void handler_get_alarm_summary(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_getevent.h
+4
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -42,16 +43,19 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_get_event_information_set(
BACNET_OBJECT_TYPE object_type,
get_event_info_function pFunction);
BACNET_STACK_EXPORT
void handler_get_event_information(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
BACNET_STACK_EXPORT
void ge_ack_print_data(BACNET_GET_EVENT_INFORMATION_DATA* data,
uint32_t device_id);
src/bacnet/basic/service/h_getevent_a.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void get_event_ack_handler(
uint8_t *service_request,
uint16_t service_len,
src/bacnet/basic/service/h_iam.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,11 +41,13 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_i_am_add(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void handler_i_am_bind(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_ihave.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_i_have(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_lso.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_lso(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_noserv.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_unrecognized_service(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_rd.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_reinitialize_device(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_rp.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_read_property(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_rp_a.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -41,11 +42,13 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_read_property_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data);
BACNET_STACK_EXPORT
void rp_ack_print_data(
BACNET_READ_PROPERTY_DATA * data);
src/bacnet/basic/service/h_rpm.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_read_property_multiple(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_rpm_a.h
+4
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -41,15 +42,18 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_read_property_multiple_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data);
BACNET_STACK_EXPORT
int rpm_ack_decode_service_request(
uint8_t * apdu,
int apdu_len,
BACNET_READ_ACCESS_DATA * read_access_data);
BACNET_STACK_EXPORT
void rpm_ack_print_data(
BACNET_READ_ACCESS_DATA * rpm_data);
src/bacnet/basic/service/h_rr.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_read_range(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_rr_a.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_read_range_ack(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_ts.h
+13
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -43,28 +44,40 @@ extern "C" {
#endif /* __cplusplus */
/* time synchronization handlers */
BACNET_STACK_EXPORT
void handler_timesync(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void handler_timesync_utc(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
/* time sync master features */
BACNET_STACK_EXPORT
int handler_timesync_encode_recipients(
uint8_t * apdu,
int max_apdu);
BACNET_STACK_EXPORT
void handler_timesync_task(BACNET_DATE_TIME *bdatetime);
BACNET_STACK_EXPORT
void handler_timesync_init(void);
BACNET_STACK_EXPORT
bool handler_timesync_recipient_write(
BACNET_WRITE_PROPERTY_DATA * wp_data);
BACNET_STACK_EXPORT
uint32_t handler_timesync_interval(void);
BACNET_STACK_EXPORT
bool handler_timesync_interval_set(uint32_t minutes);
BACNET_STACK_EXPORT
uint32_t handler_timesync_interval_offset(void);
BACNET_STACK_EXPORT
bool handler_timesync_interval_offset_set(uint32_t minutes);
bool handler_timesync_interval_align(void);
BACNET_STACK_EXPORT
bool handler_timesync_interval_align_set(bool flag);
BACNET_STACK_EXPORT
bool handler_timesync_recipient_address_set(
unsigned index,
BACNET_ADDRESS * address);
src/bacnet/basic/service/h_ucov.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_ucov_notification(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_upt.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -41,10 +42,12 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_unconfirmed_private_transfer(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void private_transfer_print_data(
BACNET_PRIVATE_TRANSFER_DATA *private_data);
src/bacnet/basic/service/h_whohas.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,11 +41,13 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_who_has(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void handler_who_has_for_routing(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_whois.h
+5
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
#include "bacnet/apdu.h"
@@ -40,21 +41,25 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_who_is(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void handler_who_is_unicast(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void handler_who_is_bcast_for_routing(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
BACNET_STACK_EXPORT
void handler_who_is_unicast_for_routing(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/h_wp.h
+4
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,12 +42,14 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_write_property(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
BACNET_STACK_EXPORT
bool WPValidateString(
BACNET_APPLICATION_DATA_VALUE * pValue,
int iMaxLen,
@@ -54,6 +57,7 @@ extern "C" {
BACNET_ERROR_CLASS * pErrorClass,
BACNET_ERROR_CODE * pErrorCode);
BACNET_STACK_EXPORT
bool WPValidateArgType(
BACNET_APPLICATION_DATA_VALUE * pValue,
uint8_t ucExpectedType,
src/bacnet/basic/service/h_wpm.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void handler_write_property_multiple(
uint8_t * service_request,
uint16_t service_len,
src/bacnet/basic/service/s_abort.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
int Send_Abort_To_Network(
uint8_t * buffer,
BACNET_ADDRESS *dest,
@@ -49,6 +51,7 @@ extern "C" {
BACNET_ABORT_REASON reason,
bool server);
BACNET_STACK_EXPORT
int abort_encode_pdu(
uint8_t * buffer,
BACNET_ADDRESS * dest,
src/bacnet/basic/service/s_ack_alarm.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Alarm_Acknowledgement(uint32_t device_id,
BACNET_ALARM_ACK_DATA* data);
src/bacnet/basic/service/s_arfs.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Atomic_Read_File_Stream(uint32_t device_id, uint32_t file_instance,
int fileStartPosition,
unsigned requestedOctetCount);
src/bacnet/basic/service/s_awfs.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Atomic_Write_File_Stream(uint32_t device_id,
uint32_t file_instance,
int fileStartPosition,
src/bacnet/basic/service/s_cevent.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_CEvent_Notify(uint32_t device_id,
BACNET_EVENT_NOTIFICATION_DATA* data);
src/bacnet/basic/service/s_cov.h
+4
View File
@@ -33,6 +33,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -43,16 +44,19 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
int Send_UCOV_Notify(
uint8_t * buffer,
unsigned buffer_len,
BACNET_COV_DATA * cov_data);
BACNET_STACK_EXPORT
int ucov_notify_encode_pdu(
uint8_t * buffer,
unsigned buffer_len,
BACNET_ADDRESS * dest,
BACNET_NPDU_DATA * npdu_data,
BACNET_COV_DATA * cov_data);
BACNET_STACK_EXPORT
uint8_t Send_COV_Subscribe(
uint32_t device_id,
BACNET_SUBSCRIBE_COV_DATA * cov_data);
src/bacnet/basic/service/s_dcc.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Device_Communication_Control_Request(
uint32_t device_id, uint16_t timeDuration,
BACNET_COMMUNICATION_ENABLE_DISABLE state, char *password);
src/bacnet/basic/service/s_error.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
int Send_Error_To_Network(
uint8_t * buffer,
BACNET_ADDRESS *dest,
@@ -49,6 +51,7 @@ extern "C" {
BACNET_ERROR_CLASS error_class,
BACNET_ERROR_CODE error_code);
BACNET_STACK_EXPORT
int error_encode_pdu(
uint8_t * buffer,
BACNET_ADDRESS * dest,
src/bacnet/basic/service/s_get_alarm_sum.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,7 +42,9 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Get_Alarm_Summary_Address(BACNET_ADDRESS *dest, uint16_t max_apdu);
BACNET_STACK_EXPORT
uint8_t Send_Get_Alarm_Summary(uint32_t device_id);
#ifdef __cplusplus
src/bacnet/basic/service/s_get_event.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,9 +42,11 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Get_Event_Information_Address(
BACNET_ADDRESS *dest, uint16_t max_apdu,
BACNET_OBJECT_ID *lastReceivedObjectIdentifier);
BACNET_STACK_EXPORT
uint8_t Send_Get_Event_Information(
uint32_t device_id, BACNET_OBJECT_ID *lastReceivedObjectIdentifier);
src/bacnet/basic/service/s_getevent.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,8 +42,10 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_GetEvent(BACNET_ADDRESS* target_address,
BACNET_OBJECT_ID* lastReceivedObjectIdentifier);
BACNET_STACK_EXPORT
uint8_t Send_GetEvent_Global(void);
#ifdef __cplusplus
src/bacnet/basic/service/s_iam.h
+6
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/apdu.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
@@ -42,14 +43,19 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Send_I_Am_To_Network(BACNET_ADDRESS* target_address, uint32_t device_id,
unsigned int max_apdu, int segmentation,
uint16_t vendor_id);
BACNET_STACK_EXPORT
int iam_encode_pdu(uint8_t* buffer, BACNET_ADDRESS* dest,
BACNET_NPDU_DATA* npdu_data);
BACNET_STACK_EXPORT
void Send_I_Am(uint8_t* buffer);
BACNET_STACK_EXPORT
int iam_unicast_encode_pdu(uint8_t* buffer, BACNET_ADDRESS* src,
BACNET_ADDRESS* dest, BACNET_NPDU_DATA* npdu_data);
BACNET_STACK_EXPORT
void Send_I_Am_Unicast(uint8_t* buffer, BACNET_ADDRESS* src);
#ifdef __cplusplus
src/bacnet/basic/service/s_ihave.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Send_I_Have(
uint32_t device_id,
BACNET_OBJECT_TYPE object_type,
src/bacnet/basic/service/s_lso.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Life_Safety_Operation_Data(uint32_t device_id,
BACNET_LSO_DATA* data);
src/bacnet/basic/service/s_rd.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Reinitialize_Device_Request(uint32_t device_id,
BACNET_REINITIALIZED_STATE state,
char *password);
src/bacnet/basic/service/s_readrange.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_ReadRange_Request(uint32_t device_id,
BACNET_READ_RANGE_DATA* read_access_data);
src/bacnet/basic/service/s_rp.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Read_Property_Request_Address(
BACNET_ADDRESS * dest,
uint16_t max_apdu,
@@ -48,6 +50,7 @@ extern "C" {
uint32_t object_instance,
BACNET_PROPERTY_ID object_property,
uint32_t array_index);
BACNET_STACK_EXPORT
uint8_t Send_Read_Property_Request(
uint32_t device_id, /* destination device */
BACNET_OBJECT_TYPE object_type,
src/bacnet/basic/service/s_rpm.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Read_Property_Multiple_Request(
uint8_t * pdu,
size_t max_pdu,
src/bacnet/basic/service/s_ts.h
+7
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,21 +42,27 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Send_TimeSync(
BACNET_DATE * bdate,
BACNET_TIME * btime);
BACNET_STACK_EXPORT
void Send_TimeSync_Remote(
BACNET_ADDRESS * dest,
BACNET_DATE * bdate,
BACNET_TIME * btime);
BACNET_STACK_EXPORT
void Send_TimeSyncUTC(
BACNET_DATE * bdate,
BACNET_TIME * btime);
BACNET_STACK_EXPORT
void Send_TimeSyncUTC_Remote(
BACNET_ADDRESS * dest,
BACNET_DATE * bdate,
BACNET_TIME * btime);
BACNET_STACK_EXPORT
void Send_TimeSyncUTC_Device(void);
BACNET_STACK_EXPORT
void Send_TimeSync_Device(void);
#ifdef __cplusplus
src/bacnet/basic/service/s_uevent.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
int Send_UEvent_Notify(
uint8_t * buffer,
BACNET_EVENT_NOTIFICATION_DATA * data,
src/bacnet/basic/service/s_upt.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
int Send_UnconfirmedPrivateTransfer(BACNET_ADDRESS* dest,
BACNET_PRIVATE_TRANSFER_DATA* private_data);
src/bacnet/basic/service/s_whohas.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,10 +42,12 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Send_WhoHas_Name(
int32_t low_limit,
int32_t high_limit,
const char *object_name);
BACNET_STACK_EXPORT
void Send_WhoHas_Object(int32_t low_limit, int32_t high_limit,
BACNET_OBJECT_TYPE object_type,
uint32_t object_instance);
src/bacnet/basic/service/s_whois.h
+6
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,19 +42,24 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void Send_WhoIs(
int32_t low_limit,
int32_t high_limit);
BACNET_STACK_EXPORT
void Send_WhoIs_Global(
int32_t low_limit,
int32_t high_limit);
BACNET_STACK_EXPORT
void Send_WhoIs_Local(
int32_t low_limit,
int32_t high_limit);
BACNET_STACK_EXPORT
void Send_WhoIs_Remote(
BACNET_ADDRESS * target_address,
int32_t low_limit,
int32_t high_limit);
BACNET_STACK_EXPORT
void Send_WhoIs_To_Network(BACNET_ADDRESS* target_address, int32_t low_limit,
int32_t high_limit);
src/bacnet/basic/service/s_wp.h
+3
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Write_Property_Request(
uint32_t device_id, /* destination device */
BACNET_OBJECT_TYPE object_type,
@@ -49,6 +51,7 @@ extern "C" {
BACNET_APPLICATION_DATA_VALUE * object_value,
uint8_t priority,
uint32_t array_index);
BACNET_STACK_EXPORT
uint8_t Send_Write_Property_Request_Data(
uint32_t device_id,
BACNET_OBJECT_TYPE object_type,
src/bacnet/basic/service/s_wpm.h
+2
View File
@@ -32,6 +32,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacapp.h"
#include "bacnet/bacdef.h"
#include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
uint8_t Send_Write_Property_Multiple_Request(
uint8_t * pdu,
size_t max_pdu,
src/bacnet/basic/sys/bigend.h
+3
View File
@@ -24,6 +24,8 @@
#ifndef BIGEND_H
#define BIGEND_H
#include "bacnet/bacnet_stack_exports.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
@@ -44,6 +46,7 @@ extern "C" {
/* x[2] = 0x03 */
/* x[3] = 0x04 */
BACNET_STACK_EXPORT
int big_endian(
void);
src/bacnet/basic/sys/debug.h
+2
View File
@@ -27,6 +27,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include "bacnet/bacnet_stack_exports.h"
#include "bacnet/bacdef.h"
#ifndef DEBUG_ENABLED
@@ -37,6 +38,7 @@
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void debug_printf(
const char *format,
...);
src/bacnet/basic/sys/fifo.h
+13
View File
@@ -8,6 +8,7 @@
#include <stdint.h>
#include <stdbool.h>
#include "bacnet/bacnet_stack_exports.h"
/**
* FIFO data structure
@@ -31,43 +32,54 @@ typedef struct fifo_buffer_t FIFO_BUFFER;
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
unsigned FIFO_Count(
FIFO_BUFFER const *b);
BACNET_STACK_EXPORT
bool FIFO_Full(
FIFO_BUFFER const *b);
BACNET_STACK_EXPORT
bool FIFO_Available(
FIFO_BUFFER const *b,
unsigned count);
BACNET_STACK_EXPORT
bool FIFO_Empty(
FIFO_BUFFER const *b);
BACNET_STACK_EXPORT
uint8_t FIFO_Peek(
FIFO_BUFFER const *b);
BACNET_STACK_EXPORT
uint8_t FIFO_Get(
FIFO_BUFFER * b);
BACNET_STACK_EXPORT
unsigned FIFO_Pull(
FIFO_BUFFER * b,
uint8_t * data_bytes,
unsigned length);
BACNET_STACK_EXPORT
bool FIFO_Put(
FIFO_BUFFER * b,
uint8_t data_byte);
BACNET_STACK_EXPORT
bool FIFO_Add(
FIFO_BUFFER * b,
uint8_t * data_bytes,
unsigned count);
BACNET_STACK_EXPORT
void FIFO_Flush(
FIFO_BUFFER * b);
/* note: buffer_len must be a power of two */
BACNET_STACK_EXPORT
void FIFO_Init(
FIFO_BUFFER * b,
volatile uint8_t * buffer,
@@ -75,6 +87,7 @@ extern "C" {
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testFIFOBuffer(
Test * pTest);
#endif
src/bacnet/basic/sys/filename.h
+3
View File
@@ -24,10 +24,13 @@
#ifndef FILENAME_H
#define FILENAME_H
#include "bacnet/bacnet_stack_exports.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
char *filename_remove_path(
const char *filename_in);
src/bacnet/basic/sys/keylist.h
+14
View File
@@ -24,6 +24,7 @@
#ifndef KEYLIST_H
#define KEYLIST_H
#include "bacnet/bacnet_stack_exports.h"
#include "key.h"
/* This is a key sorted linked list data library that */
@@ -48,68 +49,81 @@ extern "C" {
#endif /* __cplusplus */
/* returns head of the list or NULL on failure. */
BACNET_STACK_EXPORT
OS_Keylist Keylist_Create(
void);
/* delete specified list */
/* note: you should pop all the nodes off the list first. */
BACNET_STACK_EXPORT
void Keylist_Delete(
OS_Keylist list);
/* inserts a node into its sorted position */
/* returns the index where it was added */
BACNET_STACK_EXPORT
int Keylist_Data_Add(
OS_Keylist list,
KEY key,
void *data);
/* deletes a node specified by its key */
BACNET_STACK_EXPORT
/* returns the data from the node */
void *Keylist_Data_Delete(
OS_Keylist list,
KEY key);
/* deletes a node specified by its index */
BACNET_STACK_EXPORT
/* returns the data from the node */
void *Keylist_Data_Delete_By_Index(
OS_Keylist list,
int index);
/* returns the data from last node, and removes it from the list */
BACNET_STACK_EXPORT
void *Keylist_Data_Pop(
OS_Keylist list);
/* returns the data from the node specified by key */
BACNET_STACK_EXPORT
void *Keylist_Data(
OS_Keylist list,
KEY key);
/* returns the index from the node specified by key */
BACNET_STACK_EXPORT
int Keylist_Index(
OS_Keylist list,
KEY key);
/* returns the data specified by key */
BACNET_STACK_EXPORT
void *Keylist_Data_Index(
OS_Keylist list,
int index);
/* return the key at the given index */
BACNET_STACK_EXPORT
KEY Keylist_Key(
OS_Keylist list,
int index);
/* returns the next empty key from the list */
BACNET_STACK_EXPORT
KEY Keylist_Next_Empty_Key(
OS_Keylist list,
KEY key);
/* returns the number of items in the list */
BACNET_STACK_EXPORT
int Keylist_Count(
OS_Keylist list);
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testKeyList(
Test * pTest);
#endif
src/bacnet/basic/sys/mstimer.h
+11
View File
@@ -20,6 +20,8 @@
#ifndef MSTIMER_H_
#define MSTIMER_H_
#include "bacnet/bacnet_stack_exports.h"
/**
* A timer.
*
@@ -46,18 +48,27 @@ struct mstimer_callback_data_t {
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
void mstimer_set(struct mstimer *t, unsigned long interval);
BACNET_STACK_EXPORT
void mstimer_reset(struct mstimer *t);
BACNET_STACK_EXPORT
void mstimer_restart(struct mstimer *t);
BACNET_STACK_EXPORT
int mstimer_expired(struct mstimer *t);
BACNET_STACK_EXPORT
unsigned long mstimer_remaining(struct mstimer *t);
BACNET_STACK_EXPORT
unsigned long mstimer_interval(struct mstimer *t);
/* HAL implementation */
BACNET_STACK_EXPORT
unsigned long mstimer_now(void);
BACNET_STACK_EXPORT
void mstimer_callback(
struct mstimer_callback_data_t *cb,
mstimer_callback_function callback,
unsigned long milliseconds);
BACNET_STACK_EXPORT
void mstimer_init(void);
#ifdef __cplusplus
src/bacnet/basic/sys/ringbuf.h
+18
View File
@@ -11,6 +11,7 @@
#include <stdint.h>
#include <stdbool.h>
#include "bacnet/bacnet_stack_exports.h"
/**
* ring buffer power of two alignment macro
@@ -53,30 +54,43 @@ typedef struct ring_buffer_t RING_BUFFER;
extern "C" {
#endif /* __cplusplus */
BACNET_STACK_EXPORT
unsigned Ringbuf_Count(RING_BUFFER const *b);
BACNET_STACK_EXPORT
unsigned Ringbuf_Depth(RING_BUFFER const *b);
BACNET_STACK_EXPORT
unsigned Ringbuf_Depth_Reset(RING_BUFFER *b);
BACNET_STACK_EXPORT
unsigned Ringbuf_Size(RING_BUFFER const *b);
BACNET_STACK_EXPORT
bool Ringbuf_Full(RING_BUFFER const *b);
BACNET_STACK_EXPORT
bool Ringbuf_Empty(RING_BUFFER const *b);
/* tail */
BACNET_STACK_EXPORT
volatile uint8_t *Ringbuf_Peek(RING_BUFFER const *b);
bool Ringbuf_Pop(RING_BUFFER * b,
uint8_t * data_element);
BACNET_STACK_EXPORT
bool Ringbuf_Pop_Element(RING_BUFFER * b,
uint8_t * this_element,
uint8_t * data_element);
BACNET_STACK_EXPORT
bool Ringbuf_Put_Front(RING_BUFFER * b,
uint8_t * data_element);
/* head */
BACNET_STACK_EXPORT
bool Ringbuf_Put(RING_BUFFER * b,
uint8_t * data_element);
/* pair of functions to use head memory directly */
BACNET_STACK_EXPORT
volatile uint8_t *Ringbuf_Data_Peek(RING_BUFFER * b);
volatile uint8_t *Ringbuf_Peek_Next(RING_BUFFER const *b,
uint8_t * data_element);
BACNET_STACK_EXPORT
bool Ringbuf_Data_Put(RING_BUFFER * b, volatile uint8_t *data_element);
/* Note: element_count must be a power of two */
BACNET_STACK_EXPORT
bool Ringbuf_Init(RING_BUFFER * b,
volatile uint8_t * buffer,
unsigned element_size,
@@ -84,9 +98,13 @@ extern "C" {
#ifdef TEST
#include "ctest.h"
BACNET_STACK_EXPORT
void testRingBufPowerOfTwo(Test * pTest);
BACNET_STACK_EXPORT
void testRingBufSizeSmall(Test * pTest);
BACNET_STACK_EXPORT
void testRingBufSizeLarge(Test * pTest);
BACNET_STACK_EXPORT
void testRingBufSizeInvalid(Test * pTest);
#endif

Some files were not shown because too many files have changed in this diff Show More