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

Added encode/decode for Time_Synchronization_Recipients.

Browse Source 
Added Send_TimeSync_Remote() which can use specific destination address.
Added function prototypes for time sync master in the handlers.
This commit is contained in:
skarg
2013-02-20 23:54:11 +00:00
parent 209f9e82a2
commit 1c5d399a38
5 changed files with 350 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bacnet-stack/demo/handler/s_ts.c
+14 -6
View File
@@ -45,13 +45,13 @@
/** @file s_ts.c Send TimeSync requests. */
void Send_TimeSync(
void Send_TimeSync_Remote(
BACNET_ADDRESS * dest,
BACNET_DATE * bdate,
BACNET_TIME * btime)
{
int len = 0;
int pdu_len = 0;
BACNET_ADDRESS dest;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
BACNET_ADDRESS my_address;
@@ -59,13 +59,11 @@ void Send_TimeSync(
if (!dcc_communication_enabled())
return;
/* we could use unicast or broadcast */
datalink_get_broadcast_address(&dest);
datalink_get_my_address(&my_address);
/* encode the NPDU portion of the packet */
npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL);
pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address,
npdu_encode_pdu(&Handler_Transmit_Buffer[0], dest, &my_address,
&npdu_data);
/* encode the APDU portion of the packet */
@@ -74,7 +72,7 @@ void Send_TimeSync(
pdu_len += len;
/* send it out the datalink */
bytes_sent =
datalink_send_pdu(&dest, &npdu_data, &Handler_Transmit_Buffer[0],
datalink_send_pdu(dest, &npdu_data, &Handler_Transmit_Buffer[0],
pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0)
@@ -83,6 +81,16 @@ void Send_TimeSync(
#endif
}
void Send_TimeSync(
BACNET_DATE * bdate,
BACNET_TIME * btime)
{
BACNET_ADDRESS dest;
datalink_get_broadcast_address(&dest);
Send_TimeSync_Remote(&dest, bdate, btime);
}
void Send_TimeSyncUTC(
BACNET_DATE * bdate,
BACNET_TIME * btime)
bacnet-stack/include/client.h
+4
View File
@@ -168,6 +168,10 @@ extern "C" {
void Send_TimeSync(
BACNET_DATE * bdate,
BACNET_TIME * btime);
void Send_TimeSync_Remote(
BACNET_ADDRESS * dest,
BACNET_DATE * bdate,
BACNET_TIME * btime);
void Send_TimeSyncUTC(
BACNET_DATE * bdate,
BACNET_TIME * btime);
bacnet-stack/include/handlers.h
+13 -1
View File
@@ -176,15 +176,27 @@ extern "C" {
uint16_t service_len,
BACNET_ADDRESS * src);
/* time synchronization handlers */
void handler_timesync(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
void handler_timesync_utc(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src);
/* time sync master features */
int handler_timesync_encode_recipients(
uint8_t * apdu,
int max_apdu);
void handler_timesync_task(void);
void handler_timesync_init(void);
bool handler_timesync_recipient_write(
BACNET_WRITE_PROPERTY_DATA * wp_data);
bool handler_timesync_interval_set(uint32_t minutes);
bool handler_timesync_recipient_address_set(
unsigned index,
BACNET_ADDRESS *address);
void handler_read_property_multiple(
uint8_t * service_request,
bacnet-stack/include/timesync.h
+26
View File
@@ -28,6 +28,23 @@
#include <stdbool.h>
#include "bacdef.h"
struct BACnet_Recipient_List;
typedef struct BACnet_Recipient_List {
/*
BACnetRecipient ::= CHOICE {
device [0] BACnetObjectIdentifier,
address [1] BACnetAddress
}
*/
uint8_t tag;
union {
BACNET_OBJECT_ID device;
BACNET_ADDRESS address;
} type;
/* simple linked list */
struct BACnet_Recipient_List *next;
} BACNET_RECIPIENT_LIST;
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
@@ -63,6 +80,15 @@ extern "C" {
BACNET_DATE * my_date,
BACNET_TIME * my_time);
int timesync_encode_timesync_recipients(
uint8_t * apdu,
unsigned max_apdu,
BACNET_RECIPIENT_LIST *recipient);
int timesync_decode_timesync_recipients(
uint8_t * apdu,
unsigned apdu_len,
BACNET_RECIPIENT_LIST *recipient);
#ifdef TEST
#include "ctest.h"
void testTimeSync(
bacnet-stack/src/timesync.c
+293
View File
@@ -113,11 +113,304 @@ int timesync_decode_service_request(
return len;
}
/** Handle a request to encode the list of timesync recipients.
*
* Invoked by a request to read the Device object's
* PROP_TIME_SYNCHRONIZATION_RECIPIENTS.
* Loops through the list of timesync recipients, and, for each one,
* adds its data to the APDU.
*
* BACnetRecipient ::= CHOICE {
* device [0] BACnetObjectIdentifier,
* address [1] BACnetAddress
* }
*
* BACnetAddress ::= SEQUENCE {
* network-number Unsigned16, -- A value of 0 indicates the local network
* mac-address OCTET STRING -- A string of length 0 indicates a broadcast
* }
*
* @param apdu [out] Buffer in which the APDU contents are built.
* @param max_apdu [in] Max length of the APDU buffer.
* @param recipient [in] BACNET_RECIPIENT_LIST type linked list of recipients.
*
* @return How many bytes were encoded in the buffer, or
* BACNET_STATUS_ABORT if the response would not fit within the buffer.
*/
int timesync_encode_timesync_recipients(
uint8_t * apdu,
unsigned max_apdu,
BACNET_RECIPIENT_LIST *recipient)
{
int len = 0;
int apdu_len = 0;
BACNET_OCTET_STRING octet_string;
BACNET_RECIPIENT_LIST *pRecipient;
pRecipient = recipient;
while (pRecipient != NULL) {
if (pRecipient->tag == 0) {
if (max_apdu >= (1+4)) {
/* CHOICE - device [0] BACnetObjectIdentifier */
len = encode_context_object_id(&apdu[apdu_len], 0,
pRecipient->type.device.type,
pRecipient->type.device.instance);
apdu_len += len;
} else {
return BACNET_STATUS_ABORT;
}
} else if (pRecipient->tag == 1) {
if (pRecipient->type.address.net) {
len = 1 + 3 + 2 + pRecipient->type.address.net + 1;
} else {
len = 1 + 3 + 2 + pRecipient->type.address.mac_len + 1;
}
if (max_apdu >= len) {
/* CHOICE - address [1] BACnetAddress - opening */
len = encode_opening_tag(&apdu[apdu_len], 1);
apdu_len += len;
/* network-number Unsigned16, */
/* -- A value of 0 indicates the local network */
len =
encode_application_unsigned(&apdu[apdu_len],
pRecipient->type.address.net);
apdu_len += len;
/* mac-address OCTET STRING */
/* -- A string of length 0 indicates a broadcast */
if (pRecipient->type.address.net == BACNET_BROADCAST_NETWORK) {
octetstring_init(&octet_string, NULL, 0);
} else if (pRecipient->type.address.net) {
octetstring_init(&octet_string,
&pRecipient->type.address.adr[0],
pRecipient->type.address.len);
} else {
octetstring_init(&octet_string,
&pRecipient->type.address.mac[0],
pRecipient->type.address.mac_len);
}
len = encode_application_octet_string(&apdu[apdu_len],
&octet_string);
apdu_len += len;
/* CHOICE - address [1] BACnetAddress - closing */
len = encode_closing_tag(&apdu[apdu_len], 1);
apdu_len += len;
} else {
/* not a valid tag - don't encode this one */
}
}
pRecipient = pRecipient->next;
}
return apdu_len;
}
/** Handle a request to decode a list of timesync recipients.
*
* Invoked by a request to write the Device object's
* PROP_TIME_SYNCHRONIZATION_RECIPIENTS.
* Loops through the list of timesync recipients, and, for each one,
* adds its data from the APDU.
*
* BACnetRecipient ::= CHOICE {
* device [0] BACnetObjectIdentifier,
* address [1] BACnetAddress
* }
*
* BACnetAddress ::= SEQUENCE {
* network-number Unsigned16, -- A value of 0 indicates the local network
* mac-address OCTET STRING -- A string of length 0 indicates a broadcast
* }
*
* @param apdu [in] Buffer in which the APDU contents are read
* @param max_apdu [in] length of the APDU buffer.
* @param recipient [out] BACNET_RECIPIENT_LIST type linked list of recipients.
*
* @return How many bytes were decoded from the buffer, or
* BACNET_STATUS_ABORT if there was a problem decoding the buffer
*/
int timesync_decode_timesync_recipients(
uint8_t * apdu,
unsigned max_apdu,
BACNET_RECIPIENT_LIST *recipient)
{
int len = 0;
int apdu_len = 0;
int tag_len = 0;
uint8_t tag_number = 0;
uint32_t len_value_type = 0;
uint32_t unsigned_value = 0;
BACNET_OCTET_STRING octet_string;
BACNET_RECIPIENT_LIST *pRecipient;
pRecipient = recipient;
while (pRecipient != NULL) {
/* device [0] BACnetObjectIdentifier */
if (decode_is_context_tag(&apdu[apdu_len], 0)) {
pRecipient->tag = 0;
len = decode_context_object_id(&apdu[apdu_len], 0,
&pRecipient->type.device.type,
&pRecipient->type.device.instance);
if (len < 0) {
return BACNET_STATUS_ABORT;
}
apdu_len += len;
} else if (decode_is_context_tag(&apdu[apdu_len], 1)) {
apdu_len += 1;
pRecipient->tag = 1;
/* network-number Unsigned16 */
tag_len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
return BACNET_STATUS_ABORT;
}
len = decode_unsigned(&apdu[apdu_len], len_value_type, &unsigned_value);
pRecipient->type.address.net = unsigned_value;
apdu_len += len;
/* mac-address OCTET STRING */
tag_len =
decode_tag_number_and_value(&apdu[apdu_len], &tag_number,
&len_value_type);
apdu_len += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_OCTET_STRING) {
return BACNET_STATUS_ABORT;
}
len = decode_octet_string(&apdu[0], len_value_type,
&octet_string);
apdu_len += len;
if (octetstring_length(&octet_string) == 0) {
/* -- A string of length 0 indicates a broadcast */
} else if (pRecipient->type.address.net) {
pRecipient->type.address.len =
octetstring_copy_value(
&pRecipient->type.address.adr[0],
sizeof(pRecipient->type.address.adr),
&octet_string);
} else {
pRecipient->type.address.mac_len =
octetstring_copy_value(
&pRecipient->type.address.mac[0],
sizeof(pRecipient->type.address.mac),
&octet_string);
}
} else {
return BACNET_STATUS_ABORT;
}
pRecipient = pRecipient->next;
}
return apdu_len;
}
#ifdef TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testTimeSyncRecipientData(
Test * pTest,
BACNET_RECIPIENT_LIST *recipient1,
BACNET_RECIPIENT_LIST *recipient2)
{
unsigned i = 0;
if (recipient1 && recipient2) {
ct_test(pTest, recipient1->tag == recipient2->tag);
if (recipient1->tag == 0) {
ct_test(pTest,
recipient1->type.device.type ==
recipient2->type.device.type);
ct_test(pTest,
recipient1->type.device.instance ==
recipient2->type.device.instance);
} else if (recipient1->tag == 1) {
ct_test(pTest,
recipient1->type.address.net ==
recipient2->type.address.net);
if (recipient1->type.address.net == BACNET_BROADCAST_NETWORK) {
ct_test(pTest,
recipient1->type.address.mac_len ==
recipient2->type.address.mac_len);
} else if (recipient1->type.address.net) {
ct_test(pTest,
recipient1->type.address.len ==
recipient2->type.address.len);
for (i = 0; i < recipient1->type.address.len; i++) {
ct_test(pTest,
recipient1->type.address.adr[i] ==
recipient2->type.address.adr[i]);
}
} else {
ct_test(pTest,
recipient1->type.address.mac_len ==
recipient2->type.address.mac_len);
for (i = 0; i < recipient1->type.address.mac_len; i++) {
ct_test(pTest,
recipient1->type.address.mac[i] ==
recipient2->type.address.mac[i]);
}
}
} else {
ct_test(pTest, recipient1->tag <= 1);
}
}
}
void testTimeSyncRecipient(
Test * pTest)
{
uint8_t apdu[480] = { 0 };
int len = 0;
BACNET_RECIPIENT_LIST recipient[4];
BACNET_RECIPIENT_LIST test_recipient[4];
/* link the recipient list */
recipient[0].next = &recipient[1];
recipient[1].next = &recipient[2];
recipient[2].next = &recipient[3];
recipient[3].next = NULL;
/* link the test recipient list */
test_recipient[0].next = &test_recipient[1];
test_recipient[1].next = &test_recipient[2];
test_recipient[2].next = &test_recipient[3];
test_recipient[3].next = NULL;
/* load the test data - device */
recipient[0].tag = 0;
recipient[0].type.device.type = OBJECT_DEVICE;
recipient[0].type.device.instance = 1234;
/* load the test data - address */
/* network = broadcast */
recipient[1].tag = 1;
recipient[1].type.address.net = BACNET_BROADCAST_NETWORK;
recipient[2].type.address.mac_len = 0;
/* network = non-zero */
recipient[1].tag = 1;
recipient[2].type.address.net = 4201;
recipient[2].type.address.adr[0] = 127;
recipient[2].type.address.len = 1;
/* network = zero */
recipient[2].type.address.net = 0;
recipient[2].type.address.mac[0] = 10;
recipient[2].type.address.mac[1] = 1;
recipient[2].type.address.mac[2] = 0;
recipient[2].type.address.mac[3] = 86;
recipient[2].type.address.mac[4] = 0xBA;
recipient[2].type.address.mac[5] = 0xC1;
recipient[2].type.address.mac_len = 6;
/* perform positive test */
len = timesync_encode_timesync_recipients(&apdu[0],
sizeof(apdu), &recipient[0]);
ct_test(pTest, len != BACNET_STATUS_ABORT);
ct_test(pTest, len > 0);
len = timesync_decode_timesync_recipients(&apdu[0],
sizeof(apdu), &test_recipient[0]);
ct_test(pTest, len != BACNET_STATUS_ABORT);
ct_test(pTest, len > 0);
testTimeSyncRecipientData(pTest, &recipient[0], &test_recipient[0]);
}
int timesync_decode_apdu_service(
uint8_t * apdu,
BACNET_UNCONFIRMED_SERVICE service,