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

Fixed EOL, indent.

Browse Source
This commit is contained in:
skarg
2009-10-24 17:02:59 +00:00
parent 857d0c185d
commit c04e69da8c
118 changed files with 2633 additions and 2629 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bacnet-stack/demo/dcc/main.c
+2 -4
View File
@@ -117,10 +117,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/epics/main.c
+2 -4
View File
@@ -242,10 +242,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/handler/h_cov.c
+5 -4
View File
@@ -327,8 +327,9 @@ static bool cov_send_request(
value_list[1].next = NULL;
switch (cov_subscription->monitoredObjectIdentifier.type) {
case OBJECT_BINARY_INPUT:
Binary_Input_Encode_Value_List(cov_subscription->
monitoredObjectIdentifier.instance, &value_list[0]);
Binary_Input_Encode_Value_List
(cov_subscription->monitoredObjectIdentifier.instance,
&value_list[0]);
break;
default:
goto COV_FAILED;
@@ -426,8 +427,8 @@ static bool cov_subscribe(
switch (cov_data->monitoredObjectIdentifier.type) {
case OBJECT_BINARY_INPUT:
if (Binary_Input_Valid_Instance(cov_data->
monitoredObjectIdentifier.instance)) {
if (Binary_Input_Valid_Instance
(cov_data->monitoredObjectIdentifier.instance)) {
status =
cov_list_subscribe(src, cov_data, error_class, error_code);
} else {
bacnet-stack/demo/handler/h_dcc.c
+4 -4
View File
@@ -43,12 +43,12 @@ static char My_Password[32] = "filister";
void handler_dcc_password_set(
char *new_password)
{
size_t i = 0; /* loop counter */
size_t i = 0; /* loop counter */
if (new_password) {
for (i = 0; i < (sizeof(My_Password)-1); i++) {
for (i = 0; i < (sizeof(My_Password) - 1); i++) {
My_Password[i] = new_password[i];
My_Password[i+1] = 0;
My_Password[i + 1] = 0;
if (new_password[i] == 0) {
break;
}
bacnet-stack/demo/handler/h_getevent.c
+23 -26
View File
@@ -38,8 +38,7 @@
#include "event.h"
#include "getevent.h"
static get_event_info_function
Get_Event_Info[MAX_BACNET_OBJECT_TYPE];
static get_event_info_function Get_Event_Info[MAX_BACNET_OBJECT_TYPE];
void handler_get_event_information_set(
BACNET_OBJECT_TYPE object_type,
@@ -48,7 +47,7 @@ void handler_get_event_information_set(
if (object_type < MAX_BACNET_OBJECT_TYPE) {
Get_Event_Info[object_type] = pFunction;
}
}
}
void handler_get_event_information(
uint8_t * service_request,
@@ -65,7 +64,7 @@ void handler_get_event_information(
BACNET_ERROR_CODE error_code = ERROR_CODE_UNKNOWN_OBJECT;
BACNET_ADDRESS my_address;
BACNET_OBJECT_ID object_id;
unsigned i = 0, j = 0; /* counter */
unsigned i = 0, j = 0; /* counter */
BACNET_GET_EVENT_INFORMATION_DATA getevent_data;
int valid_event = 0;
@@ -82,15 +81,14 @@ void handler_get_event_information(
service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED,
true);
#if PRINT_ENABLED
fprintf(stderr, "GetEventInformation: "
"Segmented message. Sending Abort!\n");
fprintf(stderr,
"GetEventInformation: " "Segmented message. Sending Abort!\n");
#endif
goto GET_EVENT_ABORT;
}
len = getevent_decode_service_request(
service_request,
service_len,
len =
getevent_decode_service_request(service_request, service_len,
&object_id);
if (len < 0) {
/* bad decoding - send an abort */
@@ -98,17 +96,17 @@ void handler_get_event_information(
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, ABORT_REASON_OTHER, true);
#if PRINT_ENABLED
fprintf(stderr, "GetEventInformation: Bad Encoding. Sending Abort!\n");
fprintf(stderr,
"GetEventInformation: Bad Encoding. Sending Abort!\n");
#endif
goto GET_EVENT_ABORT;
}
/* assume that there is an error */
error = true;
len = getevent_ack_encode_apdu_init(
&Handler_Transmit_Buffer[pdu_len],
sizeof(Handler_Transmit_Buffer) - pdu_len,
service_data->invoke_id);
len =
getevent_ack_encode_apdu_init(&Handler_Transmit_Buffer[pdu_len],
sizeof(Handler_Transmit_Buffer) - pdu_len, service_data->invoke_id);
if (len <= 0) {
error = true;
goto GET_EVENT_ERROR;
@@ -117,11 +115,11 @@ void handler_get_event_information(
for (i = 0; i < MAX_BACNET_OBJECT_TYPE; i++) {
if (Get_Event_Info[i]) {
for (j = 0; j < 0xffff; j++) {
valid_event = Get_Event_Info[i](j, &getevent_data);
valid_event = Get_Event_Info[i] (j, &getevent_data);
if (valid_event > 0) {
len = getevent_ack_encode_apdu_data(
&Handler_Transmit_Buffer[pdu_len],
sizeof(Handler_Transmit_Buffer)-pdu_len,
len =
getevent_ack_encode_apdu_data(&Handler_Transmit_Buffer
[pdu_len], sizeof(Handler_Transmit_Buffer) - pdu_len,
&getevent_data);
if (len <= 0) {
error = true;
@@ -134,10 +132,9 @@ void handler_get_event_information(
}
}
}
len = getevent_ack_encode_apdu_end(
&Handler_Transmit_Buffer[pdu_len],
sizeof(Handler_Transmit_Buffer)-pdu_len,
false);
len =
getevent_ack_encode_apdu_end(&Handler_Transmit_Buffer[pdu_len],
sizeof(Handler_Transmit_Buffer) - pdu_len, false);
if (len <= 0) {
error = true;
goto GET_EVENT_ERROR;
@@ -146,7 +143,7 @@ void handler_get_event_information(
#if PRINT_ENABLED
fprintf(stderr, "GetEventInformation: Sending Ack!\n");
#endif
GET_EVENT_ERROR:
GET_EVENT_ERROR:
if (error) {
if (len == -2) {
/* BACnet APDU too small to fit data, so proper response is Abort */
@@ -155,8 +152,8 @@ GET_EVENT_ERROR:
service_data->invoke_id,
ABORT_REASON_SEGMENTATION_NOT_SUPPORTED, true);
#if PRINT_ENABLED
fprintf(stderr, "GetEventInformation: "
"Reply too big to fit into APDU!\n");
fprintf(stderr,
"GetEventInformation: " "Reply too big to fit into APDU!\n");
#endif
} else {
len =
@@ -168,7 +165,7 @@ GET_EVENT_ERROR:
#endif
}
}
GET_EVENT_ABORT:
GET_EVENT_ABORT:
pdu_len += len;
bytes_sent =
datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0],
bacnet-stack/demo/handler/h_pt.c
+162 -131
View File
@@ -50,99 +50,122 @@
DATABLOCK MyData[MYMAXBLOCK];
uint8_t IOBufferPT[MAX_APDU]; /* Buffer for building response in */
void ProcessPT(BACNET_PRIVATE_TRANSFER_DATA *data)
uint8_t IOBufferPT[MAX_APDU]; /* Buffer for building response in */
void ProcessPT(
BACNET_PRIVATE_TRANSFER_DATA * data)
{
int iLen; /* Index to current location in data */
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
BACNET_CHARACTER_STRING bsTemp;
int iLen; /* Index to current location in data */
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
BACNET_CHARACTER_STRING bsTemp;
iLen = 0;
iLen = 0;
/* Decode the block number */
/* Decode the block number */
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) { /* Bail out early if wrong type */
data->serviceParametersLen = 0; /* and signal unexpected error */
return;
}
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) { /* Bail out early if wrong type */
data->serviceParametersLen = 0; /* and signal unexpected error */
return;
}
iLen += decode_unsigned(&data->serviceParameters[iLen], len_value_type, &ulTemp);
cBlockNumber = (char)ulTemp;
if(cBlockNumber < MY_MAX_BLOCK) {
if(data->serviceNumber == MY_SVC_READ) {
/* Read Response is an unsigned int with 0 for success or a non 0 error code */
/* For a successful read the 0 success code is followed by the block number */
/* and then the block contents which consist of 2 unsigned ints (in 0 to 255 */
/* range as they are really chars) a single precision real and a string which */
/* will be up to 32 chars + a nul */
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
cBlockNumber = (char) ulTemp;
if (cBlockNumber < MY_MAX_BLOCK) {
if (data->serviceNumber == MY_SVC_READ) {
/* Read Response is an unsigned int with 0 for success or a non 0 error code */
/* For a successful read the 0 success code is followed by the block number */
/* and then the block contents which consist of 2 unsigned ints (in 0 to 255 */
/* range as they are really chars) a single precision real and a string which */
/* will be up to 32 chars + a nul */
iLen = 0;
iLen = 0;
iLen += encode_application_unsigned(&IOBufferPT[iLen], MY_ERR_OK); /* Signal success */
iLen += encode_application_unsigned(&IOBufferPT[iLen], cBlockNumber); /* Followed by the block number */
iLen += encode_application_unsigned(&IOBufferPT[iLen], MyData[cBlockNumber].cMyByte1); /* And Then the block contents */
iLen += encode_application_unsigned(&IOBufferPT[iLen], MyData[cBlockNumber].cMyByte2);
iLen += encode_application_real(&IOBufferPT[iLen], MyData[cBlockNumber].fMyReal);
characterstring_init_ansi(&bsTemp, MyData[cBlockNumber].sMyString);
iLen += encode_application_character_string(&IOBufferPT[iLen], &bsTemp);
}
else { /* Write operation */
/* Write block consists of the block number followed by the block contents as */
/* described above for the read operation. The returned result is an unsigned */
/* response which is 0 for success and a non 0 error code otherwise. */
iLen += encode_application_unsigned(&IOBufferPT[iLen], MY_ERR_OK); /* Signal success */
iLen += encode_application_unsigned(&IOBufferPT[iLen], cBlockNumber); /* Followed by the block number */
iLen += encode_application_unsigned(&IOBufferPT[iLen], MyData[cBlockNumber].cMyByte1); /* And Then the block contents */
iLen +=
encode_application_unsigned(&IOBufferPT[iLen],
MyData[cBlockNumber].cMyByte2);
iLen +=
encode_application_real(&IOBufferPT[iLen],
MyData[cBlockNumber].fMyReal);
characterstring_init_ansi(&bsTemp, MyData[cBlockNumber].sMyString);
iLen +=
encode_application_character_string(&IOBufferPT[iLen],
&bsTemp);
} else { /* Write operation */
/* Write block consists of the block number followed by the block contents as */
/* described above for the read operation. The returned result is an unsigned */
/* response which is 0 for success and a non 0 error code otherwise. */
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
data->serviceParametersLen = 0;
return;
}
iLen += decode_unsigned(&data->serviceParameters[iLen], len_value_type, &ulTemp);
MyData[cBlockNumber].cMyByte1 = (char)ulTemp;
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
MyData[cBlockNumber].cMyByte1 = (char) ulTemp;
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
data->serviceParametersLen = 0;
return;
}
iLen += decode_unsigned(&data->serviceParameters[iLen], len_value_type, &ulTemp);
MyData[cBlockNumber].cMyByte2 = (char)ulTemp;
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
MyData[cBlockNumber].cMyByte2 = (char) ulTemp;
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_REAL) {
data->serviceParametersLen = 0;
return;
}
iLen += decode_real(&data->serviceParameters[iLen], &MyData[cBlockNumber].fMyReal);
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_REAL) {
data->serviceParametersLen = 0;
return;
}
iLen +=
decode_real(&data->serviceParameters[iLen],
&MyData[cBlockNumber].fMyReal);
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_CHARACTER_STRING) {
data->serviceParametersLen = 0;
return;
}
decode_character_string(&data->serviceParameters[iLen], len_value_type, &bsTemp);
strncpy(MyData[cBlockNumber].sMyString, characterstring_value(&bsTemp), MY_MAX_STR); /* Only copy as much as we can accept */
MyData[cBlockNumber].sMyString[MY_MAX_STR] = '\0'; /* Make sure it is nul terminated */
iLen = encode_application_unsigned(&IOBufferPT[0], MY_ERR_OK); /* Signal success */
}
}
else {
iLen = encode_application_unsigned(&IOBufferPT[0], MY_ERR_BAD_INDEX); /* Signal bad index */
}
data->serviceParametersLen = iLen;
data->serviceParameters = IOBufferPT;
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_CHARACTER_STRING) {
data->serviceParametersLen = 0;
return;
}
decode_character_string(&data->serviceParameters[iLen],
len_value_type, &bsTemp);
strncpy(MyData[cBlockNumber].sMyString, characterstring_value(&bsTemp), MY_MAX_STR); /* Only copy as much as we can accept */
MyData[cBlockNumber].sMyString[MY_MAX_STR] = '\0'; /* Make sure it is nul terminated */
iLen = encode_application_unsigned(&IOBufferPT[0], MY_ERR_OK); /* Signal success */
}
} else {
iLen = encode_application_unsigned(&IOBufferPT[0], MY_ERR_BAD_INDEX); /* Signal bad index */
}
data->serviceParametersLen = iLen;
data->serviceParameters = IOBufferPT;
}
/*
@@ -162,7 +185,7 @@ void handler_conf_private_trans(
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data)
{
BACNET_PRIVATE_TRANSFER_DATA data;
BACNET_PRIVATE_TRANSFER_DATA data;
int len;
int pdu_len;
bool error;
@@ -180,76 +203,84 @@ void handler_conf_private_trans(
error_code = ERROR_CODE_UNKNOWN_OBJECT;
#if PRINT_ENABLED
fprintf(stderr,"Received Confirmed Private Transfer Request!\n");
fprintf(stderr, "Received Confirmed Private Transfer Request!\n");
#endif
/* encode the NPDU portion of the response packet as it will be needed */
/* no matter what the outcome. */
/* encode the NPDU portion of the response packet as it will be needed */
/* no matter what the outcome. */
datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL);
pdu_len = npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address, &npdu_data);
pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address,
&npdu_data);
if (service_data->segmented_message)
{
len = abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED, true);
if (service_data->segmented_message) {
len =
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED,
true);
#if PRINT_ENABLED
fprintf(stderr,"CPT: Segmented Message. Sending Abort!\n");
fprintf(stderr, "CPT: Segmented Message. Sending Abort!\n");
#endif
goto CPT_ABORT;
}
goto CPT_ABORT;
}
len = ptransfer_decode_service_request(service_request, service_len, &data);
len =
ptransfer_decode_service_request(service_request, service_len, &data);
/* bad decoding - send an abort */
if (len < 0)
{
len = abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, ABORT_REASON_OTHER, true);
if (len < 0) {
len =
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, ABORT_REASON_OTHER, true);
#if PRINT_ENABLED
fprintf(stderr,"CPT: Bad Encoding. Sending Abort!\n");
fprintf(stderr, "CPT: Bad Encoding. Sending Abort!\n");
#endif
goto CPT_ABORT;
}
goto CPT_ABORT;
}
/* Simple example with service number of 0 for read block and 1 for write block */
/* We also only support our own vendor ID. In theory we could support others */
/* for compatability purposes but these interfaces are rarely documented... */
if((data.vendorID == BACNET_VENDOR_ID) && (data.serviceNumber <= MY_SVC_WRITE)){ /* We only try to understand our own IDs and service numbers */
ProcessPT(&data); /* Will either return a result block or an app level status block */
if(data.serviceParametersLen == 0){ /* No respopnse means fatal error */
error = true;
error_class = ERROR_CLASS_SERVICES;
error_code = ERROR_CODE_OTHER;
#if PRINT_ENABLED
fprintf(stderr,"CPT: Error servicing request!\n");
#endif
}
len = ptransfer_ack_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, &data);
}
else /* Not our vendor ID or bad service parameter */
{
error = true;
error_class = ERROR_CLASS_SERVICES;
error_code = ERROR_CODE_OPTIONAL_FUNCTIONALITY_NOT_SUPPORTED;
if ((data.vendorID == BACNET_VENDOR_ID) && (data.serviceNumber <= MY_SVC_WRITE)) { /* We only try to understand our own IDs and service numbers */
ProcessPT(&data); /* Will either return a result block or an app level status block */
if (data.serviceParametersLen == 0) { /* No respopnse means fatal error */
error = true;
error_class = ERROR_CLASS_SERVICES;
error_code = ERROR_CODE_OTHER;
#if PRINT_ENABLED
fprintf(stderr,"CPT: Not our Vendor ID or invalid service code!\n");
fprintf(stderr, "CPT: Error servicing request!\n");
#endif
}
}
len =
ptransfer_ack_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, &data);
} else { /* Not our vendor ID or bad service parameter */
if (error){
len = ptransfer_error_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, error_class, error_code, &data);
}
CPT_ABORT:
pdu_len += len;
bytes_sent = datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
error = true;
error_class = ERROR_CLASS_SERVICES;
error_code = ERROR_CODE_OPTIONAL_FUNCTIONALITY_NOT_SUPPORTED;
#if PRINT_ENABLED
fprintf(stderr, "CPT: Not our Vendor ID or invalid service code!\n");
#endif
}
if (error) {
len =
ptransfer_error_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, error_class, error_code, &data);
}
CPT_ABORT:
pdu_len += len;
bytes_sent =
datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0],
pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0)
{
fprintf(stderr,"Failed to send PDU (%s)!\n",
strerror(errno));
}
if (bytes_sent <= 0) {
fprintf(stderr, "Failed to send PDU (%s)!\n", strerror(errno));
}
#endif
return;
return;
}
bacnet-stack/demo/handler/h_pt_a.c
+112 -97
View File
@@ -48,115 +48,132 @@
extern uint8_t IOBufferPT[300]; /* Somewhere to build the encoded result block for Private Transfers */
void DecodeBlock(char cBlockNum, uint8_t *pData)
void DecodeBlock(
char cBlockNum,
uint8_t * pData)
{
int iLen;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
BACNET_CHARACTER_STRING bsName;
DATABLOCK Response;
int iLen;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
BACNET_CHARACTER_STRING bsName;
DATABLOCK Response;
iLen = 0;
iLen = 0;
if(cBlockNum >= MY_MAX_BLOCK)
return;
if (cBlockNum >= MY_MAX_BLOCK)
return;
tag_len = decode_tag_number_and_value(&pData[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return;
iLen += decode_unsigned(&pData[iLen], len_value_type, &ulTemp);
Response.cMyByte1 = (char)ulTemp;
iLen += decode_unsigned(&pData[iLen], len_value_type, &ulTemp);
Response.cMyByte1 = (char) ulTemp;
tag_len = decode_tag_number_and_value(&pData[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT)
return;
iLen += decode_unsigned(&pData[iLen], len_value_type, &ulTemp);
Response.cMyByte2 = (char)ulTemp;
iLen += decode_unsigned(&pData[iLen], len_value_type, &ulTemp);
Response.cMyByte2 = (char) ulTemp;
tag_len = decode_tag_number_and_value(&pData[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_REAL)
return;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_REAL)
return;
iLen += decode_real(&pData[iLen], &Response.fMyReal);
iLen += decode_real(&pData[iLen], &Response.fMyReal);
tag_len = decode_tag_number_and_value(&pData[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_CHARACTER_STRING)
return;
tag_len =
decode_tag_number_and_value(&pData[iLen], &tag_number,
&len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_CHARACTER_STRING)
return;
iLen += decode_character_string(&pData[iLen], len_value_type, &bsName);
strncpy(Response.sMyString, characterstring_value(&bsName), MY_MAX_STR);
Response.sMyString[MY_MAX_STR] = '\0'; /* Make sure it is nul terminated */
iLen += decode_character_string(&pData[iLen], len_value_type, &bsName);
strncpy(Response.sMyString, characterstring_value(&bsName), MY_MAX_STR);
Response.sMyString[MY_MAX_STR] = '\0'; /* Make sure it is nul terminated */
printf("Private Transfer Read Block Response\n");
printf("Data Block: %d\n", (int)cBlockNum);
printf(" First Byte : %d\n", (int)Response.cMyByte1);
printf(" Second Byte : %d\n", (int)Response.cMyByte2);
printf(" Real : %f\n", Response.fMyReal);
printf(" String : %s\n\n", Response.sMyString);
printf("Private Transfer Read Block Response\n");
printf("Data Block: %d\n", (int) cBlockNum);
printf(" First Byte : %d\n", (int) Response.cMyByte1);
printf(" Second Byte : %d\n", (int) Response.cMyByte2);
printf(" Real : %f\n", Response.fMyReal);
printf(" String : %s\n\n", Response.sMyString);
}
void ProcessPTA(BACNET_PRIVATE_TRANSFER_DATA *data)
void ProcessPTA(
BACNET_PRIVATE_TRANSFER_DATA * data)
{
int iLen; /* Index to current location in data */
uint32_t uiErrorCode;
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
int iLen; /* Index to current location in data */
uint32_t uiErrorCode;
char cBlockNumber;
uint32_t ulTemp;
int tag_len;
uint8_t tag_number;
uint32_t len_value_type;
iLen = 0;
/* Error code is returned for read and write operations */
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
iLen = 0;
/* Error code is returned for read and write operations */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
#if PRINT_ENABLED
printf("CPTA: Bad Encoding!\n");
printf("CPTA: Bad Encoding!\n");
#endif
return;
}
iLen += decode_unsigned(&data->serviceParameters[iLen], len_value_type, &uiErrorCode);
return;
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&uiErrorCode);
if(data->serviceNumber == MY_SVC_READ) { /* Read I/O block so should be full block of data or error */
/* Decode the error type and if necessary block number and then fetch the info */
if (data->serviceNumber == MY_SVC_READ) { /* Read I/O block so should be full block of data or error */
/* Decode the error type and if necessary block number and then fetch the info */
if(uiErrorCode == MY_ERR_OK) {
/* Block Number */
tag_len = decode_tag_number_and_value(&data->serviceParameters[iLen], &tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
if (uiErrorCode == MY_ERR_OK) {
/* Block Number */
tag_len =
decode_tag_number_and_value(&data->serviceParameters[iLen],
&tag_number, &len_value_type);
iLen += tag_len;
if (tag_number != BACNET_APPLICATION_TAG_UNSIGNED_INT) {
#if PRINT_ENABLED
printf("CPTA: Bad Encoding!\n");
printf("CPTA: Bad Encoding!\n");
#endif
return;
}
return;
}
iLen += decode_unsigned(&data->serviceParameters[iLen], len_value_type, &ulTemp);
cBlockNumber = (char)ulTemp;
DecodeBlock(cBlockNumber, &data->serviceParameters[iLen]);
}
else { /* Read error */
printf("Private Transfer read operation returned error code: %u\n", uiErrorCode);
return;
}
}
else { /* Write I/O block - should just be an OK type message */
printf("Private Transfer write operation returned error code: %u\n", uiErrorCode);
}
iLen +=
decode_unsigned(&data->serviceParameters[iLen], len_value_type,
&ulTemp);
cBlockNumber = (char) ulTemp;
DecodeBlock(cBlockNumber, &data->serviceParameters[iLen]);
} else { /* Read error */
printf("Private Transfer read operation returned error code: %u\n",
uiErrorCode);
return;
}
} else { /* Write I/O block - should just be an OK type message */
printf("Private Transfer write operation returned error code: %u\n",
uiErrorCode);
}
}
@@ -183,28 +200,27 @@ void handler_conf_private_trans_ack(
* we were expecting. But this is just to silence some compiler
* warnings from Borland.
*/
src = src;
service_data = service_data;
src = src;
service_data = service_data;
len = 0;
len = 0;
#if PRINT_ENABLED
printf("Received Confirmed Private Transfer Ack!\n");
#endif
len = ptransfer_decode_service_request(service_request, service_len, &data); /* Same decode for ack as for service request! */
if (len < 0)
{
len = ptransfer_decode_service_request(service_request, service_len, &data); /* Same decode for ack as for service request! */
if (len < 0) {
#if PRINT_ENABLED
printf("cpta: Bad Encoding!\n");
printf("cpta: Bad Encoding!\n");
#endif
}
}
ProcessPTA(&data); /* See what to do with the response */
ProcessPTA(&data); /* See what to do with the response */
return;
return;
}
#if 0
@@ -223,4 +239,3 @@ void PTErrorHandler(
Error_Detected = true;
}
#endif
bacnet-stack/demo/handler/h_rp.c
+7 -10
View File
@@ -39,11 +39,9 @@
static uint8_t Temp_Buf[MAX_APDU] = { 0 };
static read_property_function
Read_Property[MAX_BACNET_OBJECT_TYPE];
static read_property_function Read_Property[MAX_BACNET_OBJECT_TYPE];
static object_valid_instance_function
Valid_Instance[MAX_BACNET_OBJECT_TYPE];
static object_valid_instance_function Valid_Instance[MAX_BACNET_OBJECT_TYPE];
void handler_read_property_object_set(
BACNET_OBJECT_TYPE object_type,
@@ -54,7 +52,7 @@ void handler_read_property_object_set(
Read_Property[object_type] = pFunction1;
Valid_Instance[object_type] = pFunction2;
}
}
}
/* Encodes the property APDU and returns the length,
or sets the error, and returns -1 */
@@ -79,11 +77,10 @@ int Encode_Property_APDU(
object_rp = Read_Property[object_type];
object_valid = Valid_Instance[object_type];
}
if (object_rp && object_valid &&
object_valid(object_instance)) {
apdu_len = object_rp(
&apdu[0], object_instance, property,
array_index, error_class, error_code);
if (object_rp && object_valid && object_valid(object_instance)) {
apdu_len =
object_rp(&apdu[0], object_instance, property, array_index,
error_class, error_code);
} else {
*error_class = ERROR_CLASS_OBJECT;
*error_code = ERROR_CODE_UNSUPPORTED_OBJECT_TYPE;
bacnet-stack/demo/handler/h_rpm.c
+12 -15
View File
@@ -41,9 +41,8 @@
static uint8_t Temp_Buf[MAX_APDU] = { 0 };
static rpm_property_lists_function
RPM_Lists[MAX_BACNET_OBJECT_TYPE];
static rpm_property_lists_function RPM_Lists[MAX_BACNET_OBJECT_TYPE];
struct property_list_t {
const int *pList;
unsigned count;
@@ -77,27 +76,25 @@ void handler_read_property_multiple_list_set(
if (object_type < MAX_BACNET_OBJECT_TYPE) {
RPM_Lists[object_type] = pFunction;
}
}
}
/* for a given object type, returns the special property list */
static void RPM_Property_List(
BACNET_OBJECT_TYPE object_type,
struct special_property_list_t *pPropertyList)
{
rpm_property_lists_function object_property_list = NULL;
rpm_property_lists_function object_property_list = NULL;
pPropertyList->Required.pList = NULL;
pPropertyList->Optional.pList = NULL;
pPropertyList->Proprietary.pList = NULL;
if (object_type < MAX_BACNET_OBJECT_TYPE) {
object_property_list = RPM_Lists[object_type];
}
if (object_property_list) {
object_property_list(
&pPropertyList->Required.pList,
&pPropertyList->Optional.pList,
&pPropertyList->Proprietary.pList);
}
if (object_type < MAX_BACNET_OBJECT_TYPE) {
object_property_list = RPM_Lists[object_type];
}
if (object_property_list) {
object_property_list(&pPropertyList->Required.pList,
&pPropertyList->Optional.pList, &pPropertyList->Proprietary.pList);
}
/* fill the count */
if (pPropertyList->Required.pList) {
pPropertyList->Required.count =
bacnet-stack/demo/handler/h_rpm_a.c
+6 -6
View File
@@ -208,8 +208,8 @@ static void PrintReadPropertyMultipleData(
#if PRINT_ENABLED
if (listOfProperties->propertyIdentifier < 512) {
fprintf(stdout, " %s: ",
bactext_property_name(
listOfProperties->propertyIdentifier));
bactext_property_name(listOfProperties->
propertyIdentifier));
} else {
fprintf(stdout, " proprietary %u: ",
listOfProperties->propertyIdentifier);
@@ -250,10 +250,10 @@ static void PrintReadPropertyMultipleData(
#if PRINT_ENABLED
/* AccessError */
fprintf(stdout, "BACnet Error: %s: %s\r\n",
bactext_error_class_name((int) listOfProperties->error.
error_class),
bactext_error_code_name((int) listOfProperties->error.
error_code));
bactext_error_class_name((int) listOfProperties->
error.error_class),
bactext_error_code_name((int) listOfProperties->
error.error_code));
#endif
}
listOfProperties = listOfProperties->next;
bacnet-stack/demo/handler/h_rr.c
+28 -11
View File
@@ -43,21 +43,21 @@ static uint8_t Temp_Buf[MAX_APDU] = { 0 };
or sets the error, and returns -1 */
int Encode_RR_payload(
uint8_t * apdu,
BACNET_READ_RANGE_DATA *pRequest,
BACNET_READ_RANGE_DATA * pRequest,
BACNET_ERROR_CLASS * error_class,
BACNET_ERROR_CODE * error_code)
{
int apdu_len = -1;
/* FIXME: Stub function at the moment which just returns something
* for the sake of testing things out. Need to look at existing objects
* and see how we can do this for real.
*/
pRequest->ItemCount = 6;
bitstring_init(&pRequest->ResultFlags);
bitstring_set_bit(&pRequest->ResultFlags, RESULT_FLAG_FIRST_ITEM, true);
bitstring_set_bit(&pRequest->ResultFlags, RESULT_FLAG_LAST_ITEM, true);
bitstring_set_bit(&pRequest->ResultFlags, RESULT_FLAG_LAST_ITEM, true);
bitstring_set_bit(&pRequest->ResultFlags, RESULT_FLAG_MORE_ITEMS, false);
pRequest->FirstSequence = 0;
@@ -91,10 +91,15 @@ void handler_read_range(
/* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL);
pdu_len = npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address, &npdu_data);
pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address,
&npdu_data);
if (service_data->segmented_message) {
/* we don't support segmentation - send an abort */
len = abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED, true);
len =
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED,
true);
#if PRINT_ENABLED
fprintf(stderr, "RR: Segmented message. Sending Abort!\n");
#endif
@@ -108,7 +113,9 @@ void handler_read_range(
#endif
if (len < 0) {
/* bad decoding - send an abort */
len = abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, ABORT_REASON_OTHER, true);
len =
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, ABORT_REASON_OTHER, true);
#if PRINT_ENABLED
fprintf(stderr, "RR: Bad Encoding. Sending Abort!\n");
#endif
@@ -123,7 +130,9 @@ void handler_read_range(
data.application_data = &Temp_Buf[0];
data.application_data_len = len;
/* FIXME: probably need a length limitation sent with encode */
len = rr_ack_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, &data);
len =
rr_ack_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, &data);
#if PRINT_ENABLED
fprintf(stderr, "RR: Sending Ack!\n");
#endif
@@ -132,12 +141,18 @@ void handler_read_range(
if (error) {
if (len == -2) {
/* BACnet APDU too small to fit data, so proper response is Abort */
len = abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED, true);
len =
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id,
ABORT_REASON_SEGMENTATION_NOT_SUPPORTED, true);
#if PRINT_ENABLED
fprintf(stderr, "RR: Reply too big to fit into APDU!\n");
#endif
} else {
len = bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, SERVICE_CONFIRMED_READ_PROPERTY, error_class, error_code);
len =
bacerror_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, SERVICE_CONFIRMED_READ_PROPERTY,
error_class, error_code);
#if PRINT_ENABLED
fprintf(stderr, "RR: Sending Error!\n");
#endif
@@ -145,7 +160,9 @@ void handler_read_range(
}
RR_ABORT:
pdu_len += len;
bytes_sent = datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
bytes_sent =
datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0],
pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0)
fprintf(stderr, "Failed to send PDU (%s)!\n", strerror(errno));
bacnet-stack/demo/handler/h_rr_a.c
+3 -1
View File
@@ -58,7 +58,9 @@ static void PrintReadRangeData(
/* FIXME: what if application_data_len is bigger than 255? */
/* value? need to loop until all of the len is gone... */
for (;;) {
len = bacapp_decode_application_data(application_data, (uint8_t) application_data_len, &value);
len =
bacapp_decode_application_data(application_data,
(uint8_t) application_data_len, &value);
if (first_value && (len < application_data_len)) {
first_value = false;
#if PRINT_ENABLED
bacnet-stack/demo/handler/h_upt.c
+61 -62
View File
@@ -1,62 +1,61 @@
/**************************************************************************
*
* Copyright (C) 2009 Steve Karg <skarg@users.sourceforge.net>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "config.h"
#include "txbuf.h"
#include "bacdef.h"
#include "bacdcode.h"
#include "apdu.h"
#include "npdu.h"
#include "abort.h"
#include "ptransfer.h"
void handler_unconfirmed_private_transfer(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src)
{
BACNET_PRIVATE_TRANSFER_DATA private_data;
int len = 0;
#if PRINT_ENABLED
fprintf(stderr,"Received Unconfirmed Private Transfer Request!\n");
#endif
(void) src;
len = ptransfer_decode_service_request(
service_request, service_len, &private_data);
if (len >= 0) {
#if PRINT_ENABLED
fprintf(stderr,
"UnconfirmedPrivateTransfer: "
"vendorID=%u serviceNumber=%u\n",
private_data.vendorID, private_data.serviceNumber);
#endif
}
}
/**************************************************************************
*
* Copyright (C) 2009 Steve Karg <skarg@users.sourceforge.net>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "config.h"
#include "txbuf.h"
#include "bacdef.h"
#include "bacdcode.h"
#include "apdu.h"
#include "npdu.h"
#include "abort.h"
#include "ptransfer.h"
void handler_unconfirmed_private_transfer(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src)
{
BACNET_PRIVATE_TRANSFER_DATA private_data;
int len = 0;
#if PRINT_ENABLED
fprintf(stderr, "Received Unconfirmed Private Transfer Request!\n");
#endif
(void) src;
len =
ptransfer_decode_service_request(service_request, service_len,
&private_data);
if (len >= 0) {
#if PRINT_ENABLED
fprintf(stderr,
"UnconfirmedPrivateTransfer: " "vendorID=%u serviceNumber=%u\n",
private_data.vendorID, private_data.serviceNumber);
#endif
}
}
bacnet-stack/demo/handler/h_wp.c
+4 -5
View File
@@ -37,9 +37,8 @@
#include "abort.h"
#include "wp.h"
static write_property_function
Write_Property[MAX_BACNET_OBJECT_TYPE];
static write_property_function Write_Property[MAX_BACNET_OBJECT_TYPE];
void handler_write_property_object_set(
BACNET_OBJECT_TYPE object_type,
write_property_function pFunction)
@@ -47,7 +46,7 @@ void handler_write_property_object_set(
if (object_type < MAX_BACNET_OBJECT_TYPE) {
Write_Property[object_type] = pFunction;
}
}
}
void handler_write_property(
uint8_t * service_request,
@@ -87,7 +86,7 @@ void handler_write_property(
len = wp_decode_service_request(service_request, service_len, &wp_data);
#if PRINT_ENABLED
if (len > 0)
fprintf(stderr,
fprintf(stderr,
"WP: type=%u instance=%u property=%u priority=%u index=%d\n",
wp_data.object_type, wp_data.object_instance,
wp_data.object_property, wp_data.priority, wp_data.array_index);
bacnet-stack/demo/handler/s_cevent.c
+102 -104
View File
@@ -1,104 +1,102 @@
/**************************************************************************
*
* Copyright (C) 2005 Steve Karg <skarg@users.sourceforge.net>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stddef.h>
#include <stdint.h>
#include <errno.h>
#include "event.h"
#include "datalink.h"
#include "tsm.h"
#include "dcc.h"
#include "address.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
/* returns the invoke id, 0=unsuccessful */
uint8_t Send_CEvent_Notify(
uint32_t device_id,
BACNET_EVENT_NOTIFICATION_DATA * data)
{
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
unsigned max_apdu = 0;
bool status = false;
uint8_t invoke_id = 0;
if (!dcc_communication_enabled())
return 0;
/* is the device bound? */
status = address_get_by_device(device_id, &max_apdu, &dest);
/* is there a tsm available? */
if (status)
invoke_id = tsm_next_free_invokeID();
if (invoke_id) {
/* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL);
pdu_len =
npdu_encode_pdu(
&Handler_Transmit_Buffer[0],
&dest, &my_address,
&npdu_data);
/* encode the APDU portion of the packet */
len = cevent_notify_encode_apdu(
&Handler_Transmit_Buffer[pdu_len], invoke_id, data);
pdu_len += len;
/* will it fit in the sender?
note: if there is a bottleneck router in between
us and the destination, we won't know unless
we have a way to check for that and update the
max_apdu in the address binding table. */
if ((unsigned) pdu_len < max_apdu) {
tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
&npdu_data, &Handler_Transmit_Buffer[0],
(uint16_t) pdu_len);
bytes_sent =
datalink_send_pdu(&dest, &npdu_data,
&Handler_Transmit_Buffer[0], pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0) {
fprintf(stderr,
"Failed to Send ConfirmedEventNotification Request (%s)!\n",
strerror(errno));
}
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr,
"Failed to Send ConfirmedEventNotification Request "
"(exceeds destination maximum APDU)!\n");
#endif
}
}
return invoke_id;
}
/**************************************************************************
*
* Copyright (C) 2005 Steve Karg <skarg@users.sourceforge.net>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stddef.h>
#include <stdint.h>
#include <errno.h>
#include "event.h"
#include "datalink.h"
#include "tsm.h"
#include "dcc.h"
#include "address.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
/* returns the invoke id, 0=unsuccessful */
uint8_t Send_CEvent_Notify(
uint32_t device_id,
BACNET_EVENT_NOTIFICATION_DATA * data)
{
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
unsigned max_apdu = 0;
bool status = false;
uint8_t invoke_id = 0;
if (!dcc_communication_enabled())
return 0;
/* is the device bound? */
status = address_get_by_device(device_id, &max_apdu, &dest);
/* is there a tsm available? */
if (status)
invoke_id = tsm_next_free_invokeID();
if (invoke_id) {
/* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL);
pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address,
&npdu_data);
/* encode the APDU portion of the packet */
len =
cevent_notify_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
invoke_id, data);
pdu_len += len;
/* will it fit in the sender?
note: if there is a bottleneck router in between
us and the destination, we won't know unless
we have a way to check for that and update the
max_apdu in the address binding table. */
if ((unsigned) pdu_len < max_apdu) {
tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
&npdu_data, &Handler_Transmit_Buffer[0], (uint16_t) pdu_len);
bytes_sent =
datalink_send_pdu(&dest, &npdu_data,
&Handler_Transmit_Buffer[0], pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0) {
fprintf(stderr,
"Failed to Send ConfirmedEventNotification Request (%s)!\n",
strerror(errno));
}
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr,
"Failed to Send ConfirmedEventNotification Request "
"(exceeds destination maximum APDU)!\n");
#endif
}
}
return invoke_id;
}
bacnet-stack/demo/handler/s_ptransfer.c
+28 -26
View File
@@ -50,10 +50,8 @@ uint8_t Send_Private_Transfer_Request(
uint32_t device_id,
uint16_t vendor_id,
uint32_t service_number,
char block_number,
DATABLOCK *block
)
char block_number,
DATABLOCK * block)
{ /* NULL=optional */
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
@@ -64,9 +62,9 @@ uint8_t Send_Private_Transfer_Request(
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
static uint8_t pt_req_buffer[300]; /* Somewhere to build the request packet */
BACNET_PRIVATE_TRANSFER_DATA pt_block;
BACNET_CHARACTER_STRING bsTemp;
static uint8_t pt_req_buffer[300]; /* Somewhere to build the request packet */
BACNET_PRIVATE_TRANSFER_DATA pt_block;
BACNET_CHARACTER_STRING bsTemp;
/* if we are forbidden to send, don't send! */
if (!dcc_communication_enabled())
@@ -86,28 +84,32 @@ uint8_t Send_Private_Transfer_Request(
&npdu_data);
/* encode the APDU portion of the packet */
pt_block.vendorID = vendor_id;
pt_block.serviceNumber = service_number;
if(service_number == MY_SVC_READ)
{
len += encode_application_unsigned(&pt_req_buffer[len], block_number); /* The block number we want to retrieve */
}
else
{
len += encode_application_unsigned(&pt_req_buffer[len], block_number); /* The block number */
len += encode_application_unsigned(&pt_req_buffer[len], block->cMyByte1); /* And Then the block contents */
len += encode_application_unsigned(&pt_req_buffer[len], block->cMyByte2);
len += encode_application_real(&pt_req_buffer[len], block->fMyReal);
characterstring_init_ansi(&bsTemp, block->sMyString);
len += encode_application_character_string(&pt_req_buffer[len], &bsTemp);
}
pt_block.vendorID = vendor_id;
pt_block.serviceNumber = service_number;
if (service_number == MY_SVC_READ) {
len += encode_application_unsigned(&pt_req_buffer[len], block_number); /* The block number we want to retrieve */
} else {
len += encode_application_unsigned(&pt_req_buffer[len], block_number); /* The block number */
len += encode_application_unsigned(&pt_req_buffer[len], block->cMyByte1); /* And Then the block contents */
len +=
encode_application_unsigned(&pt_req_buffer[len],
block->cMyByte2);
len +=
encode_application_real(&pt_req_buffer[len], block->fMyReal);
characterstring_init_ansi(&bsTemp, block->sMyString);
len +=
encode_application_character_string(&pt_req_buffer[len],
&bsTemp);
}
pt_block.serviceParameters = &pt_req_buffer[0];
pt_block.serviceParametersLen = len;
len = ptransfer_encode_apdu(&Handler_Transmit_Buffer[pdu_len], invoke_id, &pt_block);
pt_block.serviceParameters = &pt_req_buffer[0];
pt_block.serviceParametersLen = len;
len =
ptransfer_encode_apdu(&Handler_Transmit_Buffer[pdu_len], invoke_id,
&pt_block);
pdu_len += len;
/* will it fit in the sender?
/* will it fit in the sender?
note: if there is a bottleneck router in between
us and the destination, we won't know unless
we have a way to check for that and update the
bacnet-stack/demo/handler/s_readrange.c
+18 -10
View File
@@ -67,19 +67,23 @@ uint8_t Send_ReadRange_Request(
/* is there a tsm available? */
if (status)
invoke_id = tsm_next_free_invokeID();
if (invoke_id) {
/* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL);
pdu_len = npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address, &npdu_data);
pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address,
&npdu_data);
/* encode the APDU portion of the packet */
len = rr_encode_apdu(&Handler_Transmit_Buffer[pdu_len], invoke_id, read_access_data);
len =
rr_encode_apdu(&Handler_Transmit_Buffer[pdu_len], invoke_id,
read_access_data);
if (len <= 0) {
return 0;
}
pdu_len += len;
/* is it small enough for the the destination to receive?
note: if there is a bottleneck router in between
@@ -87,18 +91,22 @@ uint8_t Send_ReadRange_Request(
we have a way to check for that and update the
max_apdu in the address binding table. */
if ((unsigned) pdu_len < max_apdu) {
tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest, &npdu_data, &Handler_Transmit_Buffer[0], (uint16_t)pdu_len);
bytes_sent = datalink_send_pdu(&dest, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
&npdu_data, &Handler_Transmit_Buffer[0], (uint16_t) pdu_len);
bytes_sent =
datalink_send_pdu(&dest, &npdu_data,
&Handler_Transmit_Buffer[0], pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0)
fprintf(stderr,
"Failed to Send ReadRange Request (%s)!\n", strerror(errno));
fprintf(stderr, "Failed to Send ReadRange Request (%s)!\n",
strerror(errno));
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr, "Failed to Send ReadRange Request (exceeds destination maximum APDU)!\n");
fprintf(stderr,
"Failed to Send ReadRange Request (exceeds destination maximum APDU)!\n");
#endif
}
}
bacnet-stack/demo/handler/s_upt.c
+76 -76
View File
@@ -1,76 +1,76 @@
/**************************************************************************
*
* Copyright (C) 2009 Steve Karg <skarg@users.sourceforge.net>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stddef.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#include "config.h"
#include "config.h"
#include "txbuf.h"
#include "bacdef.h"
#include "bacdcode.h"
#include "address.h"
#include "tsm.h"
#include "npdu.h"
#include "apdu.h"
#include "device.h"
#include "datalink.h"
#include "dcc.h"
#include "ptransfer.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
void Send_UnconfirmedPrivateTransfer(
BACNET_ADDRESS * dest,
BACNET_PRIVATE_TRANSFER_DATA *private_data)
{
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
if (!dcc_communication_enabled())
return;
/* 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, NULL, &npdu_data);
/* encode the APDU portion of the packet */
len = uptransfer_encode_apdu(
&Handler_Transmit_Buffer[pdu_len],
private_data);
pdu_len += len;
bytes_sent =
datalink_send_pdu(dest, &npdu_data, &Handler_Transmit_Buffer[0],
pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0)
fprintf(stderr,
"Failed to Send UnconfirmedPrivateTransfer Request (%s)!\n",
strerror(errno));
#endif
}
/**************************************************************************
*
* Copyright (C) 2009 Steve Karg <skarg@users.sourceforge.net>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stddef.h>
#include <stdint.h>
#include <errno.h>
#include <string.h>
#include "config.h"
#include "config.h"
#include "txbuf.h"
#include "bacdef.h"
#include "bacdcode.h"
#include "address.h"
#include "tsm.h"
#include "npdu.h"
#include "apdu.h"
#include "device.h"
#include "datalink.h"
#include "dcc.h"
#include "ptransfer.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
void Send_UnconfirmedPrivateTransfer(
BACNET_ADDRESS * dest,
BACNET_PRIVATE_TRANSFER_DATA * private_data)
{
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
if (!dcc_communication_enabled())
return;
/* 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, NULL, &npdu_data);
/* encode the APDU portion of the packet */
len =
uptransfer_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
private_data);
pdu_len += len;
bytes_sent =
datalink_send_pdu(dest, &npdu_data, &Handler_Transmit_Buffer[0],
pdu_len);
#if PRINT_ENABLED
if (bytes_sent <= 0)
fprintf(stderr,
"Failed to Send UnconfirmedPrivateTransfer Request (%s)!\n",
strerror(errno));
#endif
}
bacnet-stack/demo/handler/s_wp.c
+3 -2
View File
@@ -139,8 +139,9 @@ uint8_t Send_Write_Property_Request(
#if PRINT_ENABLED_DEBUG
fprintf(stderr, "WriteProperty service: " "%s tag=%d\n",
(object_value->context_specific ? "context" : "application"),
(int) (object_value->context_specific ? object_value->
context_tag : object_value->tag));
(int) (object_value->
context_specific ? object_value->context_tag : object_value->
tag));
#endif
len = bacapp_encode_data(&application_data[apdu_len], object_value);
if ((len + apdu_len) < MAX_APDU) {
bacnet-stack/demo/iamrouter/main.c
+2 -4
View File
@@ -85,10 +85,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/initrouter/main.c
+2 -4
View File
@@ -207,10 +207,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/mstpcap/main.c
+34 -32
View File
@@ -286,18 +286,15 @@ uint16_t MSTP_Get_Reply(
static char Capture_Filename[32] = "mstp_20090123091200.cap";
static FILE *pFile = NULL; /* stream pointer */
#if defined(_WIN32)
static HANDLE hPipe = NULL; /* pipe handle */
static HANDLE hPipe = NULL; /* pipe handle */
static void named_pipe_create(char *name)
static void named_pipe_create(
char *name)
{
fprintf(stdout, "mstpcap: Creating Named Pipe \"%s\"\n", name);
hPipe = CreateNamedPipe(
name,
PIPE_ACCESS_OUTBOUND,
PIPE_TYPE_MESSAGE | PIPE_WAIT,
1, 65536, 65536,
300,
NULL);
hPipe =
CreateNamedPipe(name, PIPE_ACCESS_OUTBOUND,
PIPE_TYPE_MESSAGE | PIPE_WAIT, 1, 65536, 65536, 300, NULL);
if (hPipe == INVALID_HANDLE_VALUE) {
RS485_Print_Error();
return;
@@ -305,43 +302,48 @@ static void named_pipe_create(char *name)
ConnectNamedPipe(hPipe, NULL);
}
size_t data_write(const void *ptr, size_t size, size_t nitems)
size_t data_write(
const void *ptr,
size_t size,
size_t nitems)
{
DWORD cbWritten = 0;
if (hPipe != INVALID_HANDLE_VALUE) {
(void)WriteFile(
hPipe, /* handle to pipe */
ptr, /* buffer to write from */
size*nitems, /* number of bytes to write */
&cbWritten, /* number of bytes written */
NULL); /* not overlapped I/O */
(void) WriteFile(hPipe, /* handle to pipe */
ptr, /* buffer to write from */
size * nitems, /* number of bytes to write */
&cbWritten, /* number of bytes written */
NULL); /* not overlapped I/O */
}
return fwrite(ptr, size, nitems, pFile);
}
#else
static int FD_Pipe = -1;
static void named_pipe_create(char *name)
static void named_pipe_create(
char *name)
{
int rv = 0;
rv = mkfifo(name, 0666);
if (( rv == -1) && (errno != EEXIST))
{
perror("Error creating named pipe");
exit(1);
}
FD_Pipe = open(name, O_WRONLY);
rv = mkfifo(name, 0666);
if ((rv == -1) && (errno != EEXIST)) {
perror("Error creating named pipe");
exit(1);
}
FD_Pipe = open(name, O_WRONLY);
if (FD_Pipe == -1) {
perror("Error connecting to named pipe");
exit(1);
perror("Error connecting to named pipe");
exit(1);
}
}
size_t data_write(const void *ptr, size_t size, size_t nitems)
size_t data_write(
const void *ptr,
size_t size,
size_t nitems)
{
ssize_t bytes = 0;
if (FD_Pipe != -1) {
bytes = write(FD_Pipe, ptr, size*nitems);
bytes = write(FD_Pipe, ptr, size * nitems);
bytes = bytes;
}
return fwrite(ptr, size, nitems, pFile);
@@ -455,10 +457,10 @@ static BOOL WINAPI CtrlCHandler(
DWORD dwCtrlType)
{
dwCtrlType = dwCtrlType;
if (hPipe) {
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
}
exit(0);
bacnet-stack/demo/object/ai.c
+2 -1
View File
@@ -217,7 +217,8 @@ int Analog_Input_Encode_Property_APDU(
return apdu_len;
}
void Analog_Input_Init(void)
void Analog_Input_Init(
void)
{
}
bacnet-stack/demo/object/ao.c
+2 -2
View File
@@ -433,8 +433,8 @@ bool Analog_Output_Write_Property(
object_index =
Analog_Output_Instance_To_Index(wp_data->object_instance);
status =
Analog_Output_Present_Value_Relinquish(wp_data->
object_instance, wp_data->priority);
Analog_Output_Present_Value_Relinquish
(wp_data->object_instance, wp_data->priority);
if (!status) {
*error_class = ERROR_CLASS_PROPERTY;
*error_code = ERROR_CODE_VALUE_OUT_OF_RANGE;
bacnet-stack/demo/object/bacfile.c
+2 -1
View File
@@ -463,6 +463,7 @@ bool bacfile_write_stream_data(
return found;
}
void bacfile_init(void)
void bacfile_init(
void)
{
}
bacnet-stack/demo/object/bo.c
+2 -2
View File
@@ -364,8 +364,8 @@ bool Binary_Output_Write_Property(
(value.type.Enumerated <= MAX_BINARY_PV)) {
level = (BACNET_BINARY_PV) value.type.Enumerated;
object_index =
Binary_Output_Instance_To_Index(wp_data->
object_instance);
Binary_Output_Instance_To_Index
(wp_data->object_instance);
priority--;
Binary_Output_Level[object_index][priority] = level;
/* Note: you could set the physical output here if we
bacnet-stack/demo/object/bv.c
+2 -2
View File
@@ -345,8 +345,8 @@ bool Binary_Value_Write_Property(
(value.type.Enumerated <= MAX_BINARY_PV)) {
level = (BACNET_BINARY_PV) value.type.Enumerated;
object_index =
Binary_Value_Instance_To_Index(wp_data->
object_instance);
Binary_Value_Instance_To_Index
(wp_data->object_instance);
priority--;
Binary_Value_Level[object_index][priority] = level;
/* Note: you could set the physical output here if we
bacnet-stack/demo/object/device.c
+25 -26
View File
@@ -42,12 +42,10 @@
#include "bacfile.h" /* object list dependency */
#endif
static object_count_function
Object_Count[MAX_BACNET_OBJECT_TYPE];
static object_index_to_instance_function
static object_count_function Object_Count[MAX_BACNET_OBJECT_TYPE];
static object_index_to_instance_function
Object_Index_To_Instance[MAX_BACNET_OBJECT_TYPE];
static object_name_function
Object_Name[MAX_BACNET_OBJECT_TYPE];
static object_name_function Object_Name[MAX_BACNET_OBJECT_TYPE];
void Device_Object_Function_Set(
BACNET_OBJECT_TYPE object_type,
@@ -60,7 +58,7 @@ void Device_Object_Function_Set(
Object_Index_To_Instance[object_type] = index_function;
Object_Name[object_type] = name_function;
}
}
}
/* These three arrays are used by the ReadPropertyMultiple handler */
static const int Device_Properties_Required[] = {
@@ -377,11 +375,11 @@ unsigned Device_Object_List_Count(
void)
{
unsigned count = 1; /* 1 for the device object */
unsigned i = 0; /* loop counter */
unsigned i = 0; /* loop counter */
for (i = 0; i < MAX_BACNET_OBJECT_TYPE; i++) {
if (Object_Count[i]) {
count += Object_Count[i]();
count += Object_Count[i] ();
}
}
@@ -396,18 +394,18 @@ bool Device_Object_List_Identifier(
bool status = false;
unsigned object_index = 0;
unsigned count = 0;
unsigned i = 0; /* loop counter */
unsigned i = 0; /* loop counter */
if (array_index == 0) {
return status;
}
/* device object */
/* device object */
if (array_index == 1) {
*object_type = OBJECT_DEVICE;
*instance = Object_Instance_Number;
status = true;
}
if (!status) {
/* array index starts at 1, and if we are this far,
we are not the device object, so array_index must
@@ -417,10 +415,10 @@ bool Device_Object_List_Identifier(
for (i = 0; i < MAX_BACNET_OBJECT_TYPE; i++) {
if (Object_Count[i] && Object_Index_To_Instance[i]) {
object_index -= count;
count = Object_Count[i]();
count = Object_Count[i] ();
if (object_index < count) {
*object_type = i;
*instance = Object_Index_To_Instance[i](object_index);
*instance = Object_Index_To_Instance[i] (object_index);
status = true;
break;
}
@@ -505,7 +503,7 @@ int Device_Encode_Property_APDU(
int object_type = 0;
uint32_t instance = 0;
unsigned count = 0;
object_instance = object_instance;
switch (property) {
case PROP_OBJECT_IDENTIFIER:
@@ -740,8 +738,8 @@ bool Device_Write_Property(
case PROP_OBJECT_IDENTIFIER:
if (value.tag == BACNET_APPLICATION_TAG_OBJECT_ID) {
if ((value.type.Object_Id.type == OBJECT_DEVICE) &&
(Device_Set_Object_Instance_Number(value.type.Object_Id.
instance))) {
(Device_Set_Object_Instance_Number(value.type.
Object_Id.instance))) {
/* FIXME: we could send an I-Am broadcast to let the world know */
status = true;
} else {
@@ -776,8 +774,8 @@ bool Device_Write_Property(
case PROP_VENDOR_IDENTIFIER:
if (value.tag == BACNET_APPLICATION_TAG_UNSIGNED_INT) {
/* FIXME: bounds check? */
Device_Set_Vendor_Identifier((uint16_t) value.type.
Unsigned_Int);
Device_Set_Vendor_Identifier((uint16_t) value.
type.Unsigned_Int);
status = true;
} else {
*error_class = ERROR_CLASS_PROPERTY;
@@ -787,8 +785,8 @@ bool Device_Write_Property(
case PROP_SYSTEM_STATUS:
if (value.tag == BACNET_APPLICATION_TAG_ENUMERATED) {
/* FIXME: bounds check? */
Device_Set_System_Status((BACNET_DEVICE_STATUS) value.type.
Enumerated);
Device_Set_System_Status((BACNET_DEVICE_STATUS) value.
type.Enumerated);
status = true;
} else {
*error_class = ERROR_CLASS_PROPERTY;
@@ -802,8 +800,8 @@ bool Device_Write_Property(
characterstring_encoding(&value.type.Character_String);
if (encoding == CHARACTER_ANSI_X34) {
status =
Device_Set_Object_Name(characterstring_value(&value.
type.Character_String),
Device_Set_Object_Name(characterstring_value
(&value.type.Character_String),
characterstring_length(&value.type.Character_String));
if (!status) {
*error_class = ERROR_CLASS_PROPERTY;
@@ -822,8 +820,8 @@ bool Device_Write_Property(
case PROP_MAX_INFO_FRAMES:
if (value.tag == BACNET_APPLICATION_TAG_UNSIGNED_INT) {
if (value.type.Unsigned_Int <= 255) {
dlmstp_set_max_info_frames((uint8_t) value.type.
Unsigned_Int);
dlmstp_set_max_info_frames((uint8_t) value.
type.Unsigned_Int);
status = true;
} else {
*error_class = ERROR_CLASS_PROPERTY;
@@ -859,7 +857,8 @@ bool Device_Write_Property(
return status;
}
void Device_Init(void)
void Device_Init(
void)
{
}
bacnet-stack/demo/object/lc.c
+1
View File
@@ -127,6 +127,7 @@ static char *Shed_Level_Descriptions[MAX_SHED_LEVELS] = {
"dim lights 20%",
"dim lights 30%"
};
static float Shed_Level_Values[MAX_SHED_LEVELS] = {
90.0,
80.0,
bacnet-stack/demo/object/lo.c
+6 -6
View File
@@ -551,11 +551,11 @@ bool Lighting_Output_Write_Property(
} else if (value.tag == BACNET_APPLICATION_TAG_NULL) {
level = LIGHTING_LEVEL_NULL;
object_index =
Lighting_Output_Instance_To_Index(wp_data->
object_instance);
Lighting_Output_Instance_To_Index
(wp_data->object_instance);
status =
Lighting_Output_Present_Value_Relinquish(wp_data->
object_instance, wp_data->priority);
Lighting_Output_Present_Value_Relinquish
(wp_data->object_instance, wp_data->priority);
if (wp_data->priority == 6) {
/* Command priority 6 is reserved for use by Minimum On/Off
algorithm and may not be used for other purposes in any
@@ -580,8 +580,8 @@ bool Lighting_Output_Write_Property(
case PROP_OUT_OF_SERVICE:
if (value.tag == BACNET_APPLICATION_TAG_BOOLEAN) {
object_index =
Lighting_Output_Instance_To_Index(wp_data->
object_instance);
Lighting_Output_Instance_To_Index
(wp_data->object_instance);
Lighting_Output_Out_Of_Service[object_index] =
value.type.Boolean;
status = true;
bacnet-stack/demo/object/lsp.c
+4 -4
View File
@@ -317,8 +317,8 @@ bool Life_Safety_Point_Write_Property(
if (value.tag == BACNET_APPLICATION_TAG_ENUMERATED) {
if (value.type.Enumerated <= MAX_LIFE_SAFETY_MODE) {
object_index =
Life_Safety_Point_Instance_To_Index(wp_data->
object_instance);
Life_Safety_Point_Instance_To_Index
(wp_data->object_instance);
Life_Safety_Point_Mode[object_index] =
value.type.Enumerated;
status = true;
@@ -334,8 +334,8 @@ bool Life_Safety_Point_Write_Property(
case PROP_OUT_OF_SERVICE:
if (value.tag == BACNET_APPLICATION_TAG_BOOLEAN) {
object_index =
Life_Safety_Point_Instance_To_Index(wp_data->
object_instance);
Life_Safety_Point_Instance_To_Index
(wp_data->object_instance);
Life_Safety_Point_Out_Of_Service[object_index] =
value.type.Boolean;
status = true;
bacnet-stack/demo/object/ms-input.c
+33 -38
View File
@@ -44,8 +44,7 @@
#define MULTISTATE_NUMBER_OF_STATES (254)
#endif
/* Here is our Present Value */
static uint8_t
Present_Value[MAX_MULTISTATE_INPUTS];
static uint8_t Present_Value[MAX_MULTISTATE_INPUTS];
/* Writable out-of-service allows others to manipulate our Present Value */
static bool Out_Of_Service[MAX_MULTISTATE_INPUTS];
static char Object_Name[MAX_MULTISTATE_INPUTS][64];
@@ -138,7 +137,7 @@ bool Multistate_Input_Valid_Instance(
uint32_t object_instance)
{
unsigned index = 0; /* offset from instance lookup */
index = Multistate_Input_Instance_To_Index(object_instance);
if (index < MAX_MULTISTATE_INPUTS) {
return true;
@@ -167,7 +166,7 @@ bool Multistate_Input_Present_Value_Set(
{
bool status = false;
unsigned index = 0; /* offset from instance lookup */
index = Multistate_Input_Instance_To_Index(object_instance);
if (index < MAX_MULTISTATE_INPUTS) {
if (value < MULTISTATE_NUMBER_OF_STATES) {
@@ -175,7 +174,7 @@ bool Multistate_Input_Present_Value_Set(
status = true;
}
}
return status;
}
@@ -184,7 +183,7 @@ char *Multistate_Input_Description(
{
unsigned index = 0; /* offset from instance lookup */
char *pName = NULL; /* return value */
index = Multistate_Input_Instance_To_Index(object_instance);
if (index < MAX_MULTISTATE_INPUTS) {
pName = Object_Description[index];
@@ -198,8 +197,8 @@ bool Multistate_Input_Description_Set(
char *new_name)
{
unsigned index = 0; /* offset from instance lookup */
size_t i = 0; /* loop counter */
bool status = false; /* return value */
size_t i = 0; /* loop counter */
bool status = false; /* return value */
index = Multistate_Input_Instance_To_Index(object_instance);
if (index < MAX_MULTISTATE_INPUTS) {
@@ -217,7 +216,7 @@ bool Multistate_Input_Description_Set(
}
}
}
return status;
}
@@ -226,7 +225,7 @@ char *Multistate_Input_Name(
{
unsigned index = 0; /* offset from instance lookup */
char *pName = NULL; /* return value */
index = Multistate_Input_Instance_To_Index(object_instance);
if (index < MAX_MULTISTATE_INPUTS) {
pName = Object_Name[index];
@@ -241,9 +240,9 @@ bool Multistate_Input_Name_Set(
char *new_name)
{
unsigned index = 0; /* offset from instance lookup */
size_t i = 0; /* loop counter */
bool status = false; /* return value */
size_t i = 0; /* loop counter */
bool status = false; /* return value */
index = Multistate_Input_Instance_To_Index(object_instance);
if (index < MAX_MULTISTATE_INPUTS) {
status = true;
@@ -271,9 +270,9 @@ char *Multistate_Input_State_Text(
{
unsigned index = 0; /* offset from instance lookup */
char *pName = NULL; /* return value */
index = Multistate_Input_Instance_To_Index(object_instance);
if ((index < MAX_MULTISTATE_INPUTS) &&
if ((index < MAX_MULTISTATE_INPUTS) &&
(state_index < MULTISTATE_NUMBER_OF_STATES)) {
pName = State_Text[index][state_index];
}
@@ -288,11 +287,11 @@ bool Multistate_Input_State_Text_Set(
char *new_name)
{
unsigned index = 0; /* offset from instance lookup */
size_t i = 0; /* loop counter */
bool status = false; /* return value */
size_t i = 0; /* loop counter */
bool status = false; /* return value */
index = Multistate_Input_Instance_To_Index(object_instance);
if ((index < MAX_MULTISTATE_INPUTS) &&
if ((index < MAX_MULTISTATE_INPUTS) &&
(state_index < MULTISTATE_NUMBER_OF_STATES)) {
status = true;
if (new_name) {
@@ -375,8 +374,7 @@ int Multistate_Input_Encode_Property_APDU(
encode_application_enumerated(&apdu[0], EVENT_STATE_NORMAL);
break;
case PROP_OUT_OF_SERVICE:
object_index =
Multistate_Input_Instance_To_Index(object_instance);
object_index = Multistate_Input_Instance_To_Index(object_instance);
state = Out_Of_Service[object_index];
apdu_len = encode_application_boolean(&apdu[0], state);
break;
@@ -388,10 +386,10 @@ int Multistate_Input_Encode_Property_APDU(
case PROP_STATE_TEXT:
if (array_index == 0) {
/* Array element zero is the number of elements in the array */
apdu_len = encode_application_unsigned(&apdu[0],
apdu_len =
encode_application_unsigned(&apdu[0],
MULTISTATE_NUMBER_OF_STATES);
}
else if (array_index == BACNET_ARRAY_ALL) {
} else if (array_index == BACNET_ARRAY_ALL) {
/* if no index was specified, then try to encode the entire list */
/* into one packet. */
object_index =
@@ -400,8 +398,8 @@ int Multistate_Input_Encode_Property_APDU(
characterstring_init_ansi(&char_string,
Multistate_Input_State_Text(object_instance, i));
/* FIXME: this might go beyond MAX_APDU length! */
len = encode_application_character_string(
&apdu[apdu_len],
len =
encode_application_character_string(&apdu[apdu_len],
&char_string);
/* add it if we have room */
if ((apdu_len + len) < MAX_APDU) {
@@ -419,11 +417,10 @@ int Multistate_Input_Encode_Property_APDU(
if (array_index <= MULTISTATE_NUMBER_OF_STATES) {
array_index--;
characterstring_init_ansi(&char_string,
Multistate_Input_State_Text(
object_instance,
Multistate_Input_State_Text(object_instance,
array_index));
apdu_len = encode_application_character_string(
&apdu[0],
apdu_len =
encode_application_character_string(&apdu[0],
&char_string);
} else {
*error_class = ERROR_CLASS_PROPERTY;
@@ -469,9 +466,8 @@ bool Multistate_Input_Write_Property(
case PROP_PRESENT_VALUE:
if (value.tag == BACNET_APPLICATION_TAG_UNSIGNED_INT) {
if (Out_Of_Service[object_index]) {
if (Multistate_Input_Present_Value_Set(
wp_data->object_instance,
value.type.Unsigned_Int)) {
if (Multistate_Input_Present_Value_Set(wp_data->
object_instance, value.type.Unsigned_Int)) {
status = true;
} else {
*error_class = ERROR_CLASS_PROPERTY;
@@ -489,10 +485,9 @@ bool Multistate_Input_Write_Property(
case PROP_OUT_OF_SERVICE:
if (value.tag == BACNET_APPLICATION_TAG_BOOLEAN) {
object_index =
Multistate_Input_Instance_To_Index(wp_data->
object_instance);
Out_Of_Service[object_index] =
value.type.Boolean;
Multistate_Input_Instance_To_Index
(wp_data->object_instance);
Out_Of_Service[object_index] = value.type.Boolean;
status = true;
} else {
*error_class = ERROR_CLASS_PROPERTY;
@@ -560,5 +555,5 @@ int main(
return 0;
}
#endif
#endif
#endif /* TEST */
bacnet-stack/demo/object/mso.c
+6 -6
View File
@@ -364,8 +364,8 @@ bool Multistate_Output_Write_Property(
(value.type.Unsigned_Int <= MULTISTATE_NUMBER_OF_STATES)) {
level = value.type.Unsigned_Int;
object_index =
Multistate_Output_Instance_To_Index(wp_data->
object_instance);
Multistate_Output_Instance_To_Index
(wp_data->object_instance);
priority--;
Multistate_Output_Level[object_index][priority] =
(uint8_t) level;
@@ -388,8 +388,8 @@ bool Multistate_Output_Write_Property(
} else if (value.tag == BACNET_APPLICATION_TAG_NULL) {
level = MULTISTATE_NULL;
object_index =
Multistate_Output_Instance_To_Index(wp_data->
object_instance);
Multistate_Output_Instance_To_Index
(wp_data->object_instance);
priority = wp_data->priority;
if (priority && (priority <= BACNET_MAX_PRIORITY)) {
priority--;
@@ -414,8 +414,8 @@ bool Multistate_Output_Write_Property(
case PROP_OUT_OF_SERVICE:
if (value.tag == BACNET_APPLICATION_TAG_BOOLEAN) {
object_index =
Multistate_Output_Instance_To_Index(wp_data->
object_instance);
Multistate_Output_Instance_To_Index
(wp_data->object_instance);
Multistate_Output_Out_Of_Service[object_index] =
value.type.Boolean;
status = true;
bacnet-stack/demo/ptransfer/main.c
+176 -162
View File
@@ -63,8 +63,8 @@ uint8_t Send_Private_Transfer_Request(
uint32_t device_id,
uint16_t vendor_id,
uint32_t service_number,
char block_number,
DATABLOCK *block);
char block_number,
DATABLOCK * block);
/* buffer used for receive */
@@ -73,7 +73,7 @@ static uint8_t Rx_Buf[MAX_MPDU] = { 0 };
/* global variables used in this file */
static uint32_t Target_Device_Object_Instance = BACNET_MAX_INSTANCE;
static int Target_Mode = 0;
static int Target_Mode = 0;
static BACNET_ADDRESS Target_Address;
static bool Error_Detected = false;
@@ -137,7 +137,7 @@ static void Init_Service_Handlers(
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROPERTY,
handler_read_property);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER,
apdu_set_confirmed_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER,
handler_conf_private_trans);
/* handle the data coming back from confirmed requests */
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_READ_PROPERTY,
@@ -146,7 +146,7 @@ static void Init_Service_Handlers(
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER,
handler_conf_private_trans_ack);
/* handle any errors coming back */
/* handle any errors coming back */
apdu_set_error_handler(SERVICE_CONFIRMED_READ_PROPERTY, MyErrorHandler);
apdu_set_error_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER, MyErrorHandler);
apdu_set_abort_handler(MyAbortHandler);
@@ -169,53 +169,54 @@ int main(
time_t timeout_seconds = 0;
uint8_t invoke_id = 0;
bool found = false;
DATABLOCK NewData;
int iCount = 0;
int iType = 0;
int iKey;
static int iLimit[3] = {7, 11, 7};
DATABLOCK NewData;
int iCount = 0;
int iType = 0;
int iKey;
static int iLimit[3] = { 7, 11, 7 };
if (((argc != 2) && (argc != 3)) || ((argc >= 2) && (strcmp(argv[1], "--help") == 0))) {
printf("%s\n",argv[0]);
if (((argc != 2) && (argc != 3)) || ((argc >= 2) &&
(strcmp(argv[1], "--help") == 0))) {
printf("%s\n", argv[0]);
printf("Usage: %s server local-device-instance\r\n or\r\n"
" %s remote-device-instance\r\n"
, filename_remove_path(argv[0]), filename_remove_path(argv[0]));
" %s remote-device-instance\r\n",
filename_remove_path(argv[0]), filename_remove_path(argv[0]));
if ((argc > 1) && (strcmp(argv[1], "--help") == 0)) {
printf("\r\nServer mode:\r\n\r\n"
"local-device-instance determins the device id of the application\r\n"
"when running as the server end of a test set up.\r\n\r\n"
"Non server:\r\n\r\n"
"Non server:\r\n\r\n"
"remote-device-instance indicates the device id of the server\r\n"
"instance of the application.\r\n"
"The non server application will write a series of blocks to the\r\n"
"server and then retrieve them for display locally\r\n"
"First it writes all 8 blocks plus a 9th which should trigger\r\n"
"an out of range error response. Then it reads all the blocks\r\n"
"including the ninth and finally it repeats the read operation\r\n"
"with some deliberate errors to trigger a nack response\r\n");
"server and then retrieve them for display locally\r\n"
"First it writes all 8 blocks plus a 9th which should trigger\r\n"
"an out of range error response. Then it reads all the blocks\r\n"
"including the ninth and finally it repeats the read operation\r\n"
"with some deliberate errors to trigger a nack response\r\n");
}
return 0;
}
/* decode the command line parameters */
if(_stricmp(argv[1], "server") == 0)
Target_Mode = 1;
else
Target_Mode = 0;
if (_stricmp(argv[1], "server") == 0)
Target_Mode = 1;
else
Target_Mode = 0;
Target_Device_Object_Instance = strtol(argv[1 + Target_Mode], NULL, 0);
if (Target_Device_Object_Instance > BACNET_MAX_INSTANCE) {
if (Target_Device_Object_Instance > BACNET_MAX_INSTANCE) {
fprintf(stderr, "device-instance=%u - it must be less than %u\r\n",
Target_Device_Object_Instance, BACNET_MAX_INSTANCE);
return 1;
}
/* setup my info */
if(Target_Mode)
Device_Set_Object_Instance_Number(Target_Device_Object_Instance);
else
Device_Set_Object_Instance_Number(BACNET_MAX_INSTANCE);
if (Target_Mode)
Device_Set_Object_Instance_Number(Target_Device_Object_Instance);
else
Device_Set_Object_Instance_Number(BACNET_MAX_INSTANCE);
address_init();
Init_Service_Handlers();
dlenv_init();
@@ -223,147 +224,160 @@ int main(
last_seconds = time(NULL);
timeout_seconds = (apdu_timeout() / 1000) * apdu_retries();
if(Target_Mode) {
printf("Entering server mode. press q to quit program\r\n\r\n");
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
if(current_seconds != last_seconds) {
}
if (Target_Mode) {
printf("Entering server mode. press q to quit program\r\n\r\n");
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
if (current_seconds != last_seconds) {
}
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
putchar('.'); /* Just to show that time is passing... */
last_seconds = current_seconds;
tsm_timer_milliseconds(((current_seconds - last_seconds) * 1000));
}
if(_kbhit()) {
iKey = toupper(_getch());
if(iKey == 'Q') {
printf("\r\nExiting program now\r\n");
exit(0);
}
}
}
}
else {
/* try to bind with the device */
found =
address_bind_request(Target_Device_Object_Instance, &max_apdu,
&Target_Address);
if (!found) {
Send_WhoIs(Target_Device_Object_Instance,
Target_Device_Object_Instance);
}
/* loop forever */
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
putchar('.'); /* Just to show that time is passing... */
last_seconds = current_seconds;
tsm_timer_milliseconds(((current_seconds -
last_seconds) * 1000));
}
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds)
tsm_timer_milliseconds(((current_seconds - last_seconds) * 1000));
if (Error_Detected)
break;
/* wait until the device is bound, or timeout and quit */
if(!found)
found = address_bind_request(Target_Device_Object_Instance, &max_apdu, &Target_Address);
if (found)
{
if (invoke_id == 0) { /* Safe to send a new request */
switch(iType) {
case 0: /* Write blocks to server */
NewData.cMyByte1 = iCount;
NewData.cMyByte2 = 255 - iCount;
NewData.fMyReal = (float)iCount;
strcpy(NewData.sMyString, "Test Data - [x]");
NewData.sMyString[13] = 'a' + iCount;
printf("Sending block %d\n", iCount);
invoke_id = Send_Private_Transfer_Request(Target_Device_Object_Instance, BACNET_VENDOR_ID, 1, iCount, &NewData);
break;
if (_kbhit()) {
iKey = toupper(_getch());
if (iKey == 'Q') {
printf("\r\nExiting program now\r\n");
exit(0);
}
}
}
} else {
case 1: /* Read blocks from server */
printf("Requesting block %d\n", iCount);
invoke_id = Send_Private_Transfer_Request(Target_Device_Object_Instance, BACNET_VENDOR_ID, 0, iCount, &NewData);
break;
/* try to bind with the device */
found =
address_bind_request(Target_Device_Object_Instance, &max_apdu,
&Target_Address);
if (!found) {
Send_WhoIs(Target_Device_Object_Instance,
Target_Device_Object_Instance);
}
/* loop forever */
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
case 2: /* Generate some error responses */
switch(iCount) {
case 0: /* Bad service number i.e. 2 */
case 2:
case 4:
case 6:
case 8:
printf("Requesting block %d with bad service number\n", iCount);
invoke_id = Send_Private_Transfer_Request(Target_Device_Object_Instance, BACNET_VENDOR_ID, 2, iCount, &NewData);
break;
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
case 1: /* Bad vendor ID number */
case 3:
case 5:
case 7:
printf("Requesting block %d with invalid Vendor ID\n", iCount);
invoke_id = Send_Private_Transfer_Request(Target_Device_Object_Instance, BACNET_VENDOR_ID + 1, 0, iCount, &NewData);
break;
}
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds)
tsm_timer_milliseconds(((current_seconds -
last_seconds) * 1000));
if (Error_Detected)
break;
/* wait until the device is bound, or timeout and quit */
if (!found)
found =
address_bind_request(Target_Device_Object_Instance,
&max_apdu, &Target_Address);
if (found) {
if (invoke_id == 0) { /* Safe to send a new request */
switch (iType) {
case 0: /* Write blocks to server */
NewData.cMyByte1 = iCount;
NewData.cMyByte2 = 255 - iCount;
NewData.fMyReal = (float) iCount;
strcpy(NewData.sMyString, "Test Data - [x]");
NewData.sMyString[13] = 'a' + iCount;
printf("Sending block %d\n", iCount);
invoke_id =
Send_Private_Transfer_Request
(Target_Device_Object_Instance,
BACNET_VENDOR_ID, 1, iCount, &NewData);
break;
break;
}
}
else if (tsm_invoke_id_free(invoke_id)) {
if(iCount != MY_MAX_BLOCK) {
iCount++;
invoke_id = 0;
}
else {
iType++;
iCount = 0;
invoke_id = 0;
case 1: /* Read blocks from server */
printf("Requesting block %d\n", iCount);
invoke_id =
Send_Private_Transfer_Request
(Target_Device_Object_Instance,
BACNET_VENDOR_ID, 0, iCount, &NewData);
break;
if(iType > 2)
break;
}
}
else if (tsm_invoke_id_failed(invoke_id))
{
fprintf(stderr, "\rError: TSM Timeout!\r\n");
tsm_free_invoke_id(invoke_id);
Error_Detected = true;
/* try again or abort? */
break;
}
}
else
{
/* increment timer - exit if timed out */
elapsed_seconds += (current_seconds - last_seconds);
if (elapsed_seconds > timeout_seconds) {
printf("\rError: APDU Timeout!\r\n");
Error_Detected = true;
break;
}
}
/* keep track of time for next check */
last_seconds = current_seconds;
}
}
case 2: /* Generate some error responses */
switch (iCount) {
case 0: /* Bad service number i.e. 2 */
case 2:
case 4:
case 6:
case 8:
printf
("Requesting block %d with bad service number\n",
iCount);
invoke_id =
Send_Private_Transfer_Request
(Target_Device_Object_Instance,
BACNET_VENDOR_ID, 2, iCount, &NewData);
break;
case 1: /* Bad vendor ID number */
case 3:
case 5:
case 7:
printf
("Requesting block %d with invalid Vendor ID\n",
iCount);
invoke_id =
Send_Private_Transfer_Request
(Target_Device_Object_Instance,
BACNET_VENDOR_ID + 1, 0, iCount,
&NewData);
break;
}
break;
}
} else if (tsm_invoke_id_free(invoke_id)) {
if (iCount != MY_MAX_BLOCK) {
iCount++;
invoke_id = 0;
} else {
iType++;
iCount = 0;
invoke_id = 0;
if (iType > 2)
break;
}
} else if (tsm_invoke_id_failed(invoke_id)) {
fprintf(stderr, "\rError: TSM Timeout!\r\n");
tsm_free_invoke_id(invoke_id);
Error_Detected = true;
/* try again or abort? */
break;
}
} else {
/* increment timer - exit if timed out */
elapsed_seconds += (current_seconds - last_seconds);
if (elapsed_seconds > timeout_seconds) {
printf("\rError: APDU Timeout!\r\n");
Error_Detected = true;
break;
}
}
/* keep track of time for next check */
last_seconds = current_seconds;
}
}
if (Error_Detected)
return 1;
bacnet-stack/demo/readfile/main.c
+2 -4
View File
@@ -176,10 +176,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/readprop/main.c
+2 -4
View File
@@ -113,10 +113,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/readpropm/main.c
+2 -4
View File
@@ -111,10 +111,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/readrange/main.c
+290 -344
View File
@@ -77,8 +77,8 @@ uint8_t Send_Private_Transfer_Request(
uint32_t device_id,
uint16_t vendor_id,
uint32_t service_number,
char block_number,
DATABLOCK *block);
char block_number,
DATABLOCK * block);
/* buffer used for receive */
@@ -87,7 +87,7 @@ static uint8_t Rx_Buf[MAX_MPDU] = { 0 };
/* global variables used in this file */
static uint32_t Target_Device_Object_Instance = BACNET_MAX_INSTANCE;
static int Target_Mode = 0;
static int Target_Mode = 0;
static BACNET_ADDRESS Target_Address;
static bool Error_Detected = false;
@@ -145,145 +145,81 @@ static void Init_Object(
object_index_to_instance_function index_function,
object_name_function name_function)
{
handler_read_property_object_set(
object_type,
rp_function,
handler_read_property_object_set(object_type, rp_function,
object_valid_function);
handler_write_property_object_set(
object_type,
wp_function);
handler_read_property_multiple_list_set(
object_type,
rpm_list_function);
Device_Object_Function_Set(
object_type,
count_function,
index_function,
handler_write_property_object_set(object_type, wp_function);
handler_read_property_multiple_list_set(object_type, rpm_list_function);
Device_Object_Function_Set(object_type, count_function, index_function,
name_function);
}
static void Init_Objects(void)
static void Init_Objects(
void)
{
Device_Init();
Init_Object(
OBJECT_DEVICE,
Device_Property_Lists,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number,
Device_Write_Property,
NULL,
NULL,
NULL);
Init_Object(OBJECT_DEVICE, Device_Property_Lists,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number,
Device_Write_Property, NULL, NULL, NULL);
Analog_Input_Init();
Init_Object(
OBJECT_ANALOG_INPUT,
Analog_Input_Property_Lists,
Analog_Input_Encode_Property_APDU,
Analog_Input_Valid_Instance,
NULL,
Analog_Input_Count,
Analog_Input_Index_To_Instance,
Analog_Input_Name);
Init_Object(OBJECT_ANALOG_INPUT, Analog_Input_Property_Lists,
Analog_Input_Encode_Property_APDU, Analog_Input_Valid_Instance, NULL,
Analog_Input_Count, Analog_Input_Index_To_Instance, Analog_Input_Name);
Analog_Output_Init();
Init_Object(
OBJECT_ANALOG_OUTPUT,
Analog_Output_Property_Lists,
Analog_Output_Encode_Property_APDU,
Analog_Output_Valid_Instance,
Analog_Output_Write_Property,
Analog_Output_Count,
Analog_Output_Index_To_Instance,
Analog_Output_Name);
Init_Object(OBJECT_ANALOG_OUTPUT, Analog_Output_Property_Lists,
Analog_Output_Encode_Property_APDU, Analog_Output_Valid_Instance,
Analog_Output_Write_Property, Analog_Output_Count,
Analog_Output_Index_To_Instance, Analog_Output_Name);
Analog_Value_Init();
Init_Object(
OBJECT_ANALOG_VALUE,
Analog_Value_Property_Lists,
Analog_Value_Encode_Property_APDU,
Analog_Value_Valid_Instance,
Analog_Value_Write_Property,
Analog_Value_Count,
Analog_Value_Index_To_Instance,
Analog_Value_Name);
Init_Object(OBJECT_ANALOG_VALUE, Analog_Value_Property_Lists,
Analog_Value_Encode_Property_APDU, Analog_Value_Valid_Instance,
Analog_Value_Write_Property, Analog_Value_Count,
Analog_Value_Index_To_Instance, Analog_Value_Name);
Binary_Input_Init();
Init_Object(
OBJECT_BINARY_INPUT,
Binary_Input_Property_Lists,
Binary_Input_Encode_Property_APDU,
Binary_Input_Valid_Instance,
NULL,
Binary_Input_Count,
Binary_Input_Index_To_Instance,
Binary_Input_Name);
Init_Object(OBJECT_BINARY_INPUT, Binary_Input_Property_Lists,
Binary_Input_Encode_Property_APDU, Binary_Input_Valid_Instance, NULL,
Binary_Input_Count, Binary_Input_Index_To_Instance, Binary_Input_Name);
Binary_Output_Init();
Init_Object(
OBJECT_BINARY_OUTPUT,
Binary_Output_Property_Lists,
Binary_Output_Encode_Property_APDU,
Binary_Output_Valid_Instance,
Binary_Output_Write_Property,
Binary_Output_Count,
Binary_Output_Index_To_Instance,
Binary_Output_Name);
Init_Object(OBJECT_BINARY_OUTPUT, Binary_Output_Property_Lists,
Binary_Output_Encode_Property_APDU, Binary_Output_Valid_Instance,
Binary_Output_Write_Property, Binary_Output_Count,
Binary_Output_Index_To_Instance, Binary_Output_Name);
Binary_Value_Init();
Init_Object(
OBJECT_BINARY_VALUE,
Binary_Value_Property_Lists,
Binary_Value_Encode_Property_APDU,
Binary_Value_Valid_Instance,
Binary_Value_Write_Property,
Binary_Value_Count,
Binary_Value_Index_To_Instance,
Binary_Value_Name);
Init_Object(OBJECT_BINARY_VALUE, Binary_Value_Property_Lists,
Binary_Value_Encode_Property_APDU, Binary_Value_Valid_Instance,
Binary_Value_Write_Property, Binary_Value_Count,
Binary_Value_Index_To_Instance, Binary_Value_Name);
Life_Safety_Point_Init();
Init_Object(
OBJECT_LIFE_SAFETY_POINT,
Life_Safety_Point_Property_Lists,
Init_Object(OBJECT_LIFE_SAFETY_POINT, Life_Safety_Point_Property_Lists,
Life_Safety_Point_Encode_Property_APDU,
Life_Safety_Point_Valid_Instance,
Life_Safety_Point_Write_Property,
Life_Safety_Point_Count,
Life_Safety_Point_Index_To_Instance,
Life_Safety_Point_Valid_Instance, Life_Safety_Point_Write_Property,
Life_Safety_Point_Count, Life_Safety_Point_Index_To_Instance,
Life_Safety_Point_Name);
Load_Control_Init();
Init_Object(
OBJECT_LOAD_CONTROL,
Load_Control_Property_Lists,
Load_Control_Encode_Property_APDU,
Load_Control_Valid_Instance,
Load_Control_Write_Property,
Load_Control_Count,
Load_Control_Index_To_Instance,
Load_Control_Name);
Init_Object(OBJECT_LOAD_CONTROL, Load_Control_Property_Lists,
Load_Control_Encode_Property_APDU, Load_Control_Valid_Instance,
Load_Control_Write_Property, Load_Control_Count,
Load_Control_Index_To_Instance, Load_Control_Name);
Multistate_Output_Init();
Init_Object(
OBJECT_MULTI_STATE_OUTPUT,
Multistate_Output_Property_Lists,
Init_Object(OBJECT_MULTI_STATE_OUTPUT, Multistate_Output_Property_Lists,
Multistate_Output_Encode_Property_APDU,
Multistate_Output_Valid_Instance,
Multistate_Output_Write_Property,
Multistate_Output_Count,
Multistate_Output_Index_To_Instance,
Multistate_Output_Valid_Instance, Multistate_Output_Write_Property,
Multistate_Output_Count, Multistate_Output_Index_To_Instance,
Multistate_Output_Name);
#if defined(BACFILE)
bacfile_init();
Init_Object(
OBJECT_FILE,
BACfile_Property_Lists,
bacfile_encode_property_apdu,
bacfile_valid_instance,
bacfile_write_property,
bacfile_count,
bacfile_index_to_instance,
Init_Object(OBJECT_FILE, BACfile_Property_Lists,
bacfile_encode_property_apdu, bacfile_valid_instance,
bacfile_write_property, bacfile_count, bacfile_index_to_instance,
bacfile_name);
#endif
}
@@ -305,16 +241,23 @@ static void Init_Service_Handlers(
apdu_set_unrecognized_service_handler_handler
(handler_unrecognized_service);
/* we must implement read property - it's required! */
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROPERTY, handler_read_property);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROP_MULTIPLE, handler_read_property_multiple);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_RANGE, handler_read_range);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER, handler_conf_private_trans);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROPERTY,
handler_read_property);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROP_MULTIPLE,
handler_read_property_multiple);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_RANGE,
handler_read_range);
apdu_set_confirmed_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER,
handler_conf_private_trans);
/* handle the data coming back from confirmed requests */
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_READ_PROPERTY, handler_read_property_ack);
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_READ_RANGE, handler_read_range_ack);
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER, handler_conf_private_trans_ack);
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_READ_PROPERTY,
handler_read_property_ack);
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_READ_RANGE,
handler_read_range_ack);
apdu_set_confirmed_ack_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER,
handler_conf_private_trans_ack);
/* handle any errors coming back */
/* handle any errors coming back */
apdu_set_error_handler(SERVICE_CONFIRMED_READ_PROPERTY, MyErrorHandler);
apdu_set_error_handler(SERVICE_CONFIRMED_PRIVATE_TRANSFER, MyErrorHandler);
apdu_set_abort_handler(MyAbortHandler);
@@ -337,51 +280,52 @@ int main(
time_t timeout_seconds = 0;
uint8_t invoke_id = 0;
bool found = false;
BACNET_READ_RANGE_DATA Request;
int iCount = 0;
int iType = 0;
int iKey;
static int iLimit[3] = {7, 11, 7};
BACNET_READ_RANGE_DATA Request;
int iCount = 0;
int iType = 0;
int iKey;
static int iLimit[3] = { 7, 11, 7 };
if (((argc != 2) && (argc != 3)) || ((argc >= 2) && (strcmp(argv[1], "--help") == 0))) {
printf("%s\n",argv[0]);
if (((argc != 2) && (argc != 3)) || ((argc >= 2) &&
(strcmp(argv[1], "--help") == 0))) {
printf("%s\n", argv[0]);
printf("Usage: %s server local-device-instance\r\n or\r\n"
" %s remote-device-instance\r\n"
"--help gives further information\r\n"
, filename_remove_path(argv[0]), filename_remove_path(argv[0]));
" %s remote-device-instance\r\n"
"--help gives further information\r\n",
filename_remove_path(argv[0]), filename_remove_path(argv[0]));
if ((argc > 1) && (strcmp(argv[1], "--help") == 0)) {
printf("\r\nServer mode:\r\n\r\n"
"<local-device-instance> determins the device id of the application\r\n"
"when running as the server end of a test set up. The Server simply\r\n"
"returns dummy data for each ReadRange request\r\n\r\n"
"Non server:\r\n\r\n"
"Non server:\r\n\r\n"
"<remote-device-instance> indicates the device id of the server\r\n"
"instance of the application.\r\n"
"The non server application will send a series of ReadRange requests to the\r\n"
"server with examples of different range types.\r\n");
"server with examples of different range types.\r\n");
}
return 0;
}
/* decode the command line parameters */
if(_stricmp(argv[1], "server") == 0)
Target_Mode = 1;
else
Target_Mode = 0;
if (_stricmp(argv[1], "server") == 0)
Target_Mode = 1;
else
Target_Mode = 0;
Target_Device_Object_Instance = strtol(argv[1 + Target_Mode], NULL, 0);
if (Target_Device_Object_Instance > BACNET_MAX_INSTANCE) {
if (Target_Device_Object_Instance > BACNET_MAX_INSTANCE) {
fprintf(stderr, "device-instance=%u - it must be less than %u\r\n",
Target_Device_Object_Instance, BACNET_MAX_INSTANCE);
return 1;
}
/* setup my info */
if(Target_Mode)
Device_Set_Object_Instance_Number(Target_Device_Object_Instance);
else
Device_Set_Object_Instance_Number(BACNET_MAX_INSTANCE);
if (Target_Mode)
Device_Set_Object_Instance_Number(Target_Device_Object_Instance);
else
Device_Set_Object_Instance_Number(BACNET_MAX_INSTANCE);
Init_Objects();
address_init();
Init_Service_Handlers();
@@ -390,219 +334,221 @@ int main(
last_seconds = time(NULL);
timeout_seconds = (apdu_timeout() / 1000) * apdu_retries();
if(Target_Mode) {
printf("Entering server mode. press q to quit program\r\n\r\n");
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
if(current_seconds != last_seconds) {
}
if (Target_Mode) {
printf("Entering server mode. press q to quit program\r\n\r\n");
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
if (current_seconds != last_seconds) {
}
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
putchar('.'); /* Just to show that time is passing... */
last_seconds = current_seconds;
tsm_timer_milliseconds(((current_seconds - last_seconds) * 1000));
address_cache_timer(current_seconds - last_seconds);
}
if(_kbhit()) {
iKey = toupper(_getch());
if(iKey == 'Q') {
printf("\r\nExiting program now\r\n");
exit(0);
}
}
}
}
else {
/* try to bind with the device */
found = address_bind_request(Target_Device_Object_Instance, &max_apdu, &Target_Address);
if (!found) {
Send_WhoIs(Target_Device_Object_Instance, Target_Device_Object_Instance);
}
/* loop forever */
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
putchar('.'); /* Just to show that time is passing... */
last_seconds = current_seconds;
tsm_timer_milliseconds(((current_seconds -
last_seconds) * 1000));
address_cache_timer(current_seconds - last_seconds);
}
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
tsm_timer_milliseconds(((current_seconds - last_seconds) * 1000));
address_cache_timer(current_seconds - last_seconds);
}
if (Error_Detected)
break;
/* wait until the device is bound, or timeout and quit */
if(!found)
found = address_bind_request(Target_Device_Object_Instance, &max_apdu, &Target_Address);
if (found) {
if (invoke_id == 0) { /* Safe to send a new request */
switch(iCount) {
case 0:
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 1;
break;
if (_kbhit()) {
iKey = toupper(_getch());
if (iKey == 'Q') {
printf("\r\nExiting program now\r\n");
exit(0);
}
}
}
} else {
case 1:
Request.RequestType = RR_BY_SEQUENCE;
Request.Range.RefSeqNum = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 2;
break;
/* try to bind with the device */
found =
address_bind_request(Target_Device_Object_Instance, &max_apdu,
&Target_Address);
if (!found) {
Send_WhoIs(Target_Device_Object_Instance,
Target_Device_Object_Instance);
}
/* loop forever */
for (;;) {
/* increment timer - exit if timed out */
current_seconds = time(NULL);
case 2:
Request.RequestType = RR_BY_TIME;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 3;
break;
case 3:
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
/* returns 0 bytes on timeout */
pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout);
case 4:
Request.RequestType = RR_BY_SEQUENCE;
Request.Range.RefSeqNum = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
/* process */
if (pdu_len) {
npdu_handler(&src, &Rx_Buf[0], pdu_len);
}
/* at least one second has passed */
if (current_seconds != last_seconds) {
tsm_timer_milliseconds(((current_seconds -
last_seconds) * 1000));
address_cache_timer(current_seconds - last_seconds);
}
if (Error_Detected)
break;
/* wait until the device is bound, or timeout and quit */
if (!found)
found =
address_bind_request(Target_Device_Object_Instance,
&max_apdu, &Target_Address);
if (found) {
if (invoke_id == 0) { /* Safe to send a new request */
switch (iCount) {
case 0:
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 1;
break;
case 5:
Request.RequestType = RR_BY_TIME;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
case 1:
Request.RequestType = RR_BY_SEQUENCE;
Request.Range.RefSeqNum = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 2;
break;
case 6:
Request.RequestType = RR_READ_ALL;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
case 2:
Request.RequestType = RR_BY_TIME;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
case 7:
Request.RequestType = RR_READ_ALL;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 7;
break;
}
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 3;
break;
case 3:
Request.RequestType = RR_BY_POSITION;
Request.Range.RefIndex = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
invoke_id = Send_ReadRange_Request( Target_Device_Object_Instance, &Request);
}
else if (tsm_invoke_id_free(invoke_id)) {
if(iCount != MY_MAX_BLOCK) {
iCount++;
invoke_id = 0;
}
else {
break;
}
}
else if (tsm_invoke_id_failed(invoke_id))
{
fprintf(stderr, "\rError: TSM Timeout!\r\n");
tsm_free_invoke_id(invoke_id);
/* Error_Detected = true; */
/* try again or abort? */
invoke_id = 0; /* Try next operation */
case 4:
Request.RequestType = RR_BY_SEQUENCE;
Request.Range.RefSeqNum = 20;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
case 5:
Request.RequestType = RR_BY_TIME;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
case 6:
Request.RequestType = RR_READ_ALL;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = BACNET_ARRAY_ALL;
break;
case 7:
Request.RequestType = RR_READ_ALL;
Request.Range.RefTime.date.year = 2009;
Request.Range.RefTime.date.month = 9;
Request.Range.RefTime.date.day = 23;
Request.Range.RefTime.date.wday = 0xFF; /* Day of week unspecified */
Request.Range.RefTime.time.hour = 22;
Request.Range.RefTime.time.min = 23;
Request.Range.RefTime.time.sec = 24;
Request.Range.RefTime.time.hundredths = 0;
Request.Count = 30;
Request.object_type = OBJECT_ANALOG_INPUT;
Request.object_instance = 0;
Request.object_property = PROP_PRESENT_VALUE;
Request.array_index = 7;
break;
}
invoke_id =
Send_ReadRange_Request(Target_Device_Object_Instance,
&Request);
} else if (tsm_invoke_id_free(invoke_id)) {
if (iCount != MY_MAX_BLOCK) {
iCount++;
invoke_id = 0;
} else {
break;
}
} else if (tsm_invoke_id_failed(invoke_id)) {
fprintf(stderr, "\rError: TSM Timeout!\r\n");
tsm_free_invoke_id(invoke_id);
/* Error_Detected = true; */
/* try again or abort? */
invoke_id = 0; /* Try next operation */
/* break; */
}
}
else
{
/* increment timer - exit if timed out */
elapsed_seconds += (current_seconds - last_seconds);
if (elapsed_seconds > timeout_seconds) {
printf("\rError: APDU Timeout!\r\n");
/* Error_Detected = true;
break; */
invoke_id = 0;
}
}
/* keep track of time for next check */
last_seconds = current_seconds;
}
}
}
} else {
/* increment timer - exit if timed out */
elapsed_seconds += (current_seconds - last_seconds);
if (elapsed_seconds > timeout_seconds) {
printf("\rError: APDU Timeout!\r\n");
/* Error_Detected = true;
break; */
invoke_id = 0;
}
}
/* keep track of time for next check */
last_seconds = current_seconds;
}
}
if (Error_Detected)
return 1;
bacnet-stack/demo/reinit/main.c
+2 -4
View File
@@ -115,10 +115,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/server/main.c
+46 -110
View File
@@ -75,145 +75,81 @@ static void Init_Object(
object_index_to_instance_function index_function,
object_name_function name_function)
{
handler_read_property_object_set(
object_type,
rp_function,
handler_read_property_object_set(object_type, rp_function,
object_valid_function);
handler_write_property_object_set(
object_type,
wp_function);
handler_read_property_multiple_list_set(
object_type,
rpm_list_function);
Device_Object_Function_Set(
object_type,
count_function,
index_function,
handler_write_property_object_set(object_type, wp_function);
handler_read_property_multiple_list_set(object_type, rpm_list_function);
Device_Object_Function_Set(object_type, count_function, index_function,
name_function);
}
static void Init_Objects(void)
static void Init_Objects(
void)
{
Device_Init();
Init_Object(
OBJECT_DEVICE,
Device_Property_Lists,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number,
Device_Write_Property,
NULL,
NULL,
NULL);
Init_Object(OBJECT_DEVICE, Device_Property_Lists,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number,
Device_Write_Property, NULL, NULL, NULL);
Analog_Input_Init();
Init_Object(
OBJECT_ANALOG_INPUT,
Analog_Input_Property_Lists,
Analog_Input_Encode_Property_APDU,
Analog_Input_Valid_Instance,
NULL,
Analog_Input_Count,
Analog_Input_Index_To_Instance,
Analog_Input_Name);
Init_Object(OBJECT_ANALOG_INPUT, Analog_Input_Property_Lists,
Analog_Input_Encode_Property_APDU, Analog_Input_Valid_Instance, NULL,
Analog_Input_Count, Analog_Input_Index_To_Instance, Analog_Input_Name);
Analog_Output_Init();
Init_Object(
OBJECT_ANALOG_OUTPUT,
Analog_Output_Property_Lists,
Analog_Output_Encode_Property_APDU,
Analog_Output_Valid_Instance,
Analog_Output_Write_Property,
Analog_Output_Count,
Analog_Output_Index_To_Instance,
Analog_Output_Name);
Init_Object(OBJECT_ANALOG_OUTPUT, Analog_Output_Property_Lists,
Analog_Output_Encode_Property_APDU, Analog_Output_Valid_Instance,
Analog_Output_Write_Property, Analog_Output_Count,
Analog_Output_Index_To_Instance, Analog_Output_Name);
Analog_Value_Init();
Init_Object(
OBJECT_ANALOG_VALUE,
Analog_Value_Property_Lists,
Analog_Value_Encode_Property_APDU,
Analog_Value_Valid_Instance,
Analog_Value_Write_Property,
Analog_Value_Count,
Analog_Value_Index_To_Instance,
Analog_Value_Name);
Init_Object(OBJECT_ANALOG_VALUE, Analog_Value_Property_Lists,
Analog_Value_Encode_Property_APDU, Analog_Value_Valid_Instance,
Analog_Value_Write_Property, Analog_Value_Count,
Analog_Value_Index_To_Instance, Analog_Value_Name);
Binary_Input_Init();
Init_Object(
OBJECT_BINARY_INPUT,
Binary_Input_Property_Lists,
Binary_Input_Encode_Property_APDU,
Binary_Input_Valid_Instance,
NULL,
Binary_Input_Count,
Binary_Input_Index_To_Instance,
Binary_Input_Name);
Init_Object(OBJECT_BINARY_INPUT, Binary_Input_Property_Lists,
Binary_Input_Encode_Property_APDU, Binary_Input_Valid_Instance, NULL,
Binary_Input_Count, Binary_Input_Index_To_Instance, Binary_Input_Name);
Binary_Output_Init();
Init_Object(
OBJECT_BINARY_OUTPUT,
Binary_Output_Property_Lists,
Binary_Output_Encode_Property_APDU,
Binary_Output_Valid_Instance,
Binary_Output_Write_Property,
Binary_Output_Count,
Binary_Output_Index_To_Instance,
Binary_Output_Name);
Init_Object(OBJECT_BINARY_OUTPUT, Binary_Output_Property_Lists,
Binary_Output_Encode_Property_APDU, Binary_Output_Valid_Instance,
Binary_Output_Write_Property, Binary_Output_Count,
Binary_Output_Index_To_Instance, Binary_Output_Name);
Binary_Value_Init();
Init_Object(
OBJECT_BINARY_VALUE,
Binary_Value_Property_Lists,
Binary_Value_Encode_Property_APDU,
Binary_Value_Valid_Instance,
Binary_Value_Write_Property,
Binary_Value_Count,
Binary_Value_Index_To_Instance,
Binary_Value_Name);
Init_Object(OBJECT_BINARY_VALUE, Binary_Value_Property_Lists,
Binary_Value_Encode_Property_APDU, Binary_Value_Valid_Instance,
Binary_Value_Write_Property, Binary_Value_Count,
Binary_Value_Index_To_Instance, Binary_Value_Name);
Life_Safety_Point_Init();
Init_Object(
OBJECT_LIFE_SAFETY_POINT,
Life_Safety_Point_Property_Lists,
Init_Object(OBJECT_LIFE_SAFETY_POINT, Life_Safety_Point_Property_Lists,
Life_Safety_Point_Encode_Property_APDU,
Life_Safety_Point_Valid_Instance,
Life_Safety_Point_Write_Property,
Life_Safety_Point_Count,
Life_Safety_Point_Index_To_Instance,
Life_Safety_Point_Valid_Instance, Life_Safety_Point_Write_Property,
Life_Safety_Point_Count, Life_Safety_Point_Index_To_Instance,
Life_Safety_Point_Name);
Load_Control_Init();
Init_Object(
OBJECT_LOAD_CONTROL,
Load_Control_Property_Lists,
Load_Control_Encode_Property_APDU,
Load_Control_Valid_Instance,
Load_Control_Write_Property,
Load_Control_Count,
Load_Control_Index_To_Instance,
Load_Control_Name);
Init_Object(OBJECT_LOAD_CONTROL, Load_Control_Property_Lists,
Load_Control_Encode_Property_APDU, Load_Control_Valid_Instance,
Load_Control_Write_Property, Load_Control_Count,
Load_Control_Index_To_Instance, Load_Control_Name);
Multistate_Output_Init();
Init_Object(
OBJECT_MULTI_STATE_OUTPUT,
Multistate_Output_Property_Lists,
Init_Object(OBJECT_MULTI_STATE_OUTPUT, Multistate_Output_Property_Lists,
Multistate_Output_Encode_Property_APDU,
Multistate_Output_Valid_Instance,
Multistate_Output_Write_Property,
Multistate_Output_Count,
Multistate_Output_Index_To_Instance,
Multistate_Output_Valid_Instance, Multistate_Output_Write_Property,
Multistate_Output_Count, Multistate_Output_Index_To_Instance,
Multistate_Output_Name);
#if defined(BACFILE)
bacfile_init();
Init_Object(
OBJECT_FILE,
BACfile_Property_Lists,
bacfile_encode_property_apdu,
bacfile_valid_instance,
bacfile_write_property,
bacfile_count,
bacfile_index_to_instance,
Init_Object(OBJECT_FILE, BACfile_Property_Lists,
bacfile_encode_property_apdu, bacfile_valid_instance,
bacfile_write_property, bacfile_count, bacfile_index_to_instance,
bacfile_name);
#endif
}
bacnet-stack/demo/timesync/main.c
+2 -4
View File
@@ -87,10 +87,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/ucov/main.c
+2 -4
View File
@@ -54,10 +54,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
bacnet-stack/demo/whohas/main.c
+8 -6
View File
@@ -90,10 +90,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
@@ -111,9 +109,13 @@ static void Init_Service_Handlers(
apdu_set_reject_handler(MyRejectHandler);
}
int main(int argc, char *argv[]) {
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0}; /* address where message came from */
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
time_t elapsed_seconds = 0;
bacnet-stack/demo/whois/main.c
+8 -6
View File
@@ -90,10 +90,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* Note: this applications doesn't need to handle who-is
it is confusing for the user! */
/* set the handler for all the services we don't implement
@@ -159,9 +157,13 @@ static void print_address_cache(
}
}
int main(int argc, char *argv[]) {
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0}; /* address where message came from */
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
time_t total_seconds = 0;
bacnet-stack/demo/whoisrouter/main.c
+14 -9
View File
@@ -170,10 +170,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
@@ -192,14 +190,17 @@ static void Init_Service_Handlers(
}
static void address_parse(BACNET_ADDRESS * dst,
int argc, char *argv[]) {
static void address_parse(
BACNET_ADDRESS * dst,
int argc,
char *argv[])
{
int dnet = 0;
unsigned mac[6];
int count = 0;
int index = 0;
if (argc > 0) {
if (argc > 0) {
count =
sscanf(argv[0], "%x:%x:%x:%x:%x:%x", &mac[0], &mac[1], &mac[2],
&mac[3], &mac[4], &mac[5]);
@@ -240,9 +241,13 @@ static void address_parse(BACNET_ADDRESS * dst,
}
}
int main(int argc, char *argv[]) {
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0}; /* address where message came from */
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
time_t total_seconds = 0;
bacnet-stack/demo/writefile/main.c
+8 -6
View File
@@ -133,10 +133,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
@@ -156,9 +154,13 @@ static void Init_Service_Handlers(
apdu_set_reject_handler(MyRejectHandler);
}
int main(int argc, char *argv[]) {
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0}; /* address where message came from */
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0;
bacnet-stack/demo/writeprop/main.c
+8 -6
View File
@@ -131,10 +131,8 @@ static void Init_Service_Handlers(
void)
{
Device_Init();
handler_read_property_object_set(
OBJECT_DEVICE,
Device_Encode_Property_APDU,
Device_Valid_Object_Instance_Number);
handler_read_property_object_set(OBJECT_DEVICE,
Device_Encode_Property_APDU, Device_Valid_Object_Instance_Number);
/* we need to handle who-is
to support dynamic device binding to us */
apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS, handler_who_is);
@@ -156,9 +154,13 @@ static void Init_Service_Handlers(
apdu_set_reject_handler(MyRejectHandler);
}
int main(int argc, char *argv[]) {
int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = {
0}; /* address where message came from */
0
}; /* address where message came from */
uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0;