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

Ran the fixup, indent, and comment scripts to standardize the source code.

Browse Source
This commit is contained in:
skarg
2009-05-24 01:49:21 +00:00
parent 8e670ef3f9
commit 7032168ff5
22 changed files with 963 additions and 886 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bacnet-stack/demo/dcc/main.c
+6 -2
View File
@@ -142,9 +142,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/epics/main.c
+6 -2
View File
@@ -311,9 +311,13 @@ static uint8_t Read_Properties(
return invoke_id;
}
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/handler/dlenv.c
+131 -131
View File
@@ -1,131 +1,131 @@
/**************************************************************************
*
* 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.
*
*********************************************************************/
/* environment variables used for the command line tools */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "bacdef.h"
#include "apdu.h"
#include "datalink.h"
#include "handlers.h"
#include "client.h"
void dlenv_init(
void)
{
char *pEnv = NULL;
#if defined(BACDL_BIP) && BBMD_ENABLED
long bbmd_port = 0xBAC0;
long bbmd_address = 0;
long bbmd_timetolive_seconds = 60000;
#endif
#if defined(BACDL_ALL)
pEnv = getenv("BACNET_DATALINK");
if (pEnv) {
datalink_set(pEnv));
} else {
datalink_set(NULL);
}
#endif
#if defined(BACDL_BIP)
pEnv = getenv("BACNET_IP_PORT");
if (pEnv) {
bip_set_port(strtol(pEnv, NULL, 0));
} else {
bip_set_port(0xBAC0);
}
#elif defined(BACDL_MSTP)
pEnv = getenv("BACNET_MAX_INFO_FRAMES");
if (pEnv) {
dlmstp_set_max_info_frames(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_max_info_frames(1);
}
pEnv = getenv("BACNET_MAX_MASTER");
if (pEnv) {
dlmstp_set_max_master(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_max_master(127);
}
pEnv = getenv("BACNET_MSTP_BAUD");
if (pEnv) {
dlmstp_set_baud_rate(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_baud_rate(38400);
}
pEnv = getenv("BACNET_MSTP_MAC");
if (pEnv) {
dlmstp_set_mac_address(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_mac_address(127);
}
#endif
pEnv = getenv("BACNET_APDU_TIMEOUT");
if (pEnv) {
apdu_timeout_set(strtol(pEnv, NULL, 0));
fprintf(stderr, "BACNET_APDU_TIMEOUT=%s\r\n", pEnv);
} else {
#if defined(BACDL_MSTP)
apdu_timeout_set(60000);
#endif
}
if (!datalink_init(getenv("BACNET_IFACE"))) {
exit(1);
}
#if defined(BACDL_BIP) && BBMD_ENABLED
pEnv = getenv("BACNET_BBMD_PORT");
if (pEnv) {
bbmd_port = strtol(pEnv, NULL, 0);
if (bbmd_port > 0xFFFF) {
bbmd_port = 0xBAC0;
}
}
pEnv = getenv("BACNET_BBMD_TIMETOLIVE");
if (pEnv) {
bbmd_timetolive_seconds = strtol(pEnv, NULL, 0);
if (bbmd_timetolive_seconds > 0xFFFF) {
bbmd_timetolive_seconds = 0xFFFF;
}
}
pEnv = getenv("BACNET_BBMD_ADDRESS");
if (pEnv) {
bbmd_address = bip_getaddrbyname(pEnv);
if (bbmd_address) {
struct in_addr addr;
addr.s_addr = bbmd_address;
fprintf(stderr,
"Registering with BBMD at %s:%ld for %ld seconds\n",
inet_ntoa(addr), bbmd_port, bbmd_timetolive_seconds);
bvlc_register_with_bbmd(bbmd_address, bbmd_port,
bbmd_timetolive_seconds);
}
}
#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.
*
*********************************************************************/
/* environment variables used for the command line tools */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#include "bacdef.h"
#include "apdu.h"
#include "datalink.h"
#include "handlers.h"
#include "client.h"
void dlenv_init(
void)
{
char *pEnv = NULL;
#if defined(BACDL_BIP) && BBMD_ENABLED
long bbmd_port = 0xBAC0;
long bbmd_address = 0;
long bbmd_timetolive_seconds = 60000;
#endif
#if defined(BACDL_ALL)
pEnv = getenv("BACNET_DATALINK");
if (pEnv) {
datalink_set(pEnv));
} else {
datalink_set(NULL);
}
#endif
#if defined(BACDL_BIP)
pEnv = getenv("BACNET_IP_PORT");
if (pEnv) {
bip_set_port(strtol(pEnv, NULL, 0));
} else {
bip_set_port(0xBAC0);
}
#elif defined(BACDL_MSTP)
pEnv = getenv("BACNET_MAX_INFO_FRAMES");
if (pEnv) {
dlmstp_set_max_info_frames(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_max_info_frames(1);
}
pEnv = getenv("BACNET_MAX_MASTER");
if (pEnv) {
dlmstp_set_max_master(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_max_master(127);
}
pEnv = getenv("BACNET_MSTP_BAUD");
if (pEnv) {
dlmstp_set_baud_rate(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_baud_rate(38400);
}
pEnv = getenv("BACNET_MSTP_MAC");
if (pEnv) {
dlmstp_set_mac_address(strtol(pEnv, NULL, 0));
} else {
dlmstp_set_mac_address(127);
}
#endif
pEnv = getenv("BACNET_APDU_TIMEOUT");
if (pEnv) {
apdu_timeout_set(strtol(pEnv, NULL, 0));
fprintf(stderr, "BACNET_APDU_TIMEOUT=%s\r\n", pEnv);
} else {
#if defined(BACDL_MSTP)
apdu_timeout_set(60000);
#endif
}
if (!datalink_init(getenv("BACNET_IFACE"))) {
exit(1);
}
#if defined(BACDL_BIP) && BBMD_ENABLED
pEnv = getenv("BACNET_BBMD_PORT");
if (pEnv) {
bbmd_port = strtol(pEnv, NULL, 0);
if (bbmd_port > 0xFFFF) {
bbmd_port = 0xBAC0;
}
}
pEnv = getenv("BACNET_BBMD_TIMETOLIVE");
if (pEnv) {
bbmd_timetolive_seconds = strtol(pEnv, NULL, 0);
if (bbmd_timetolive_seconds > 0xFFFF) {
bbmd_timetolive_seconds = 0xFFFF;
}
}
pEnv = getenv("BACNET_BBMD_ADDRESS");
if (pEnv) {
bbmd_address = bip_getaddrbyname(pEnv);
if (bbmd_address) {
struct in_addr addr;
addr.s_addr = bbmd_address;
fprintf(stderr,
"Registering with BBMD at %s:%ld for %ld seconds\n",
inet_ntoa(addr), bbmd_port, bbmd_timetolive_seconds);
bvlc_register_with_bbmd(bbmd_address, bbmd_port,
bbmd_timetolive_seconds);
}
}
#endif
}
bacnet-stack/demo/handler/h_alarm_ack.c
+117 -118
View File
@@ -1,118 +1,117 @@
/**************************************************************************
*
* 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 <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 "alarm_ack.h"
#include "handlers.h"
void handler_alarm_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data)
{
BACNET_ALARM_ACK_DATA data;
int len = 0;
int pdu_len = 0;
BACNET_NPDU_DATA npdu_data;
int bytes_sent = 0;
BACNET_ADDRESS my_address;
/* 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);
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);
#if PRINT_ENABLED
fprintf(stderr, "Alarm Ack: Segmented message. Sending Abort!\n");
#endif
goto AA_ABORT;
}
len = alarm_ack_decode_service_request(service_request, service_len, &data);
#if PRINT_ENABLED
if (len <= 0)
fprintf(stderr, "Alarm Ack: Unable to decode Request!\n");
#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);
#if PRINT_ENABLED
fprintf(stderr, "Alarm Ack: Bad Encoding. Sending Abort!\n");
#endif
goto AA_ABORT;
}
/*
** Process Life Safety Operation Here
*/
#if PRINT_ENABLED
fprintf(stderr,
"Alarm Ack Operation: Received acknowledge for object id %d from %s for process id %d for object %id\n",
data.eventObjectIdentifier.instance,
data.ackSource.value,
data.ackProcessIdentifier,
data.eventObjectIdentifier.instance);
#endif
len =
encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM);
#if PRINT_ENABLED
fprintf(stderr, "Alarm Acknowledge: " "Sending Simple Ack!\n");
#endif
AA_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, "Alarm Acknowledge: " "Failed to send PDU (%s)!\n",
strerror(errno));
#endif
return;
}
/**************************************************************************
*
* 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 <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 "alarm_ack.h"
#include "handlers.h"
void handler_alarm_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data)
{
BACNET_ALARM_ACK_DATA data;
int len = 0;
int pdu_len = 0;
BACNET_NPDU_DATA npdu_data;
int bytes_sent = 0;
BACNET_ADDRESS my_address;
/* 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);
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);
#if PRINT_ENABLED
fprintf(stderr, "Alarm Ack: Segmented message. Sending Abort!\n");
#endif
goto AA_ABORT;
}
len =
alarm_ack_decode_service_request(service_request, service_len, &data);
#if PRINT_ENABLED
if (len <= 0)
fprintf(stderr, "Alarm Ack: Unable to decode Request!\n");
#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);
#if PRINT_ENABLED
fprintf(stderr, "Alarm Ack: Bad Encoding. Sending Abort!\n");
#endif
goto AA_ABORT;
}
/*
** Process Life Safety Operation Here
*/
#if PRINT_ENABLED
fprintf(stderr,
"Alarm Ack Operation: Received acknowledge for object id %d from %s for process id %d for object %id\n",
data.eventObjectIdentifier.instance, data.ackSource.value,
data.ackProcessIdentifier, data.eventObjectIdentifier.instance);
#endif
len =
encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM);
#if PRINT_ENABLED
fprintf(stderr, "Alarm Acknowledge: " "Sending Simple Ack!\n");
#endif
AA_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, "Alarm Acknowledge: " "Failed to send PDU (%s)!\n",
strerror(errno));
#endif
return;
}
bacnet-stack/demo/handler/s_ack_alarm.c
+111 -112
View File
@@ -1,112 +1,111 @@
/**************************************************************************
*
* Copyright (C) 2009 John Minack <minack@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 "whois.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
#include "alarm_ack.h"
/* returns the invoke ID for confirmed request, or zero on failure */
uint8_t Send_Alarm_Acknowledgement(
uint32_t device_id,
BACNET_ALARM_ACK_DATA *data)
{
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
unsigned max_apdu = 0;
uint8_t invoke_id = 0;
bool status = false;
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
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);
len =
alarm_ack_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 Alarm Ack Request (%s)!\n",
strerror(errno));
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr,
"Failed to Send Alarm Ack Request "
"(exceeds destination maximum APDU)!\n");
#endif
}
}
return invoke_id;
}
/**************************************************************************
*
* Copyright (C) 2009 John Minack <minack@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 "whois.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
#include "alarm_ack.h"
/* returns the invoke ID for confirmed request, or zero on failure */
uint8_t Send_Alarm_Acknowledgement(
uint32_t device_id,
BACNET_ALARM_ACK_DATA * data)
{
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
unsigned max_apdu = 0;
uint8_t invoke_id = 0;
bool status = false;
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
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);
len =
alarm_ack_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 Alarm Ack Request (%s)!\n",
strerror(errno));
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr,
"Failed to Send Alarm Ack Request "
"(exceeds destination maximum APDU)!\n");
#endif
}
}
return invoke_id;
}
bacnet-stack/demo/handler/s_lso.c
+111 -112
View File
@@ -1,112 +1,111 @@
/**************************************************************************
*
* Copyright (C) 2009 John Minack <minack@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 "whois.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
#include "lso.h"
/* returns the invoke ID for confirmed request, or zero on failure */
uint8_t Send_Life_Safety_Operation_Data(
uint32_t device_id,
BACNET_LSO_DATA *data)
{
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
unsigned max_apdu = 0;
uint8_t invoke_id = 0;
bool status = false;
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
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);
len =
lso_encode_adpu(&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 Life Safe Op Request (%s)!\n",
strerror(errno));
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr,
"Failed to Send Life Safe Op Request "
"(exceeds destination maximum APDU)!\n");
#endif
}
}
return invoke_id;
}
/**************************************************************************
*
* Copyright (C) 2009 John Minack <minack@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 "whois.h"
/* some demo stuff needed */
#include "handlers.h"
#include "txbuf.h"
#include "lso.h"
/* returns the invoke ID for confirmed request, or zero on failure */
uint8_t Send_Life_Safety_Operation_Data(
uint32_t device_id,
BACNET_LSO_DATA * data)
{
BACNET_ADDRESS dest;
BACNET_ADDRESS my_address;
unsigned max_apdu = 0;
uint8_t invoke_id = 0;
bool status = false;
int len = 0;
int pdu_len = 0;
int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data;
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);
len =
lso_encode_adpu(&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 Life Safe Op Request (%s)!\n",
strerror(errno));
#endif
} else {
tsm_free_invoke_id(invoke_id);
invoke_id = 0;
#if PRINT_ENABLED
fprintf(stderr,
"Failed to Send Life Safe Op Request "
"(exceeds destination maximum APDU)!\n");
#endif
}
}
return invoke_id;
}
bacnet-stack/demo/iamrouter/main.c
+6 -6
View File
@@ -101,18 +101,18 @@ static void Init_Service_Handlers(
apdu_set_reject_handler(MyRejectHandler);
}
int main(int argc, char *argv[]) {
int main(
int argc,
char *argv[])
{
unsigned arg_count = 0;
if (argc < 2) {
if (argc < 2) {
printf("Usage: %s DNET [DNET] [DNET] [...]\r\n",
filename_remove_path(argv[0]));
return 0;
}
if ((
argc > 1) && (
strcmp(argv[1],
"--help") == 0)) {
if ((argc > 1) && (strcmp(argv[1], "--help") == 0)) {
printf("Send BACnet I-Am-Router-To-Network message for \r\n"
"one or more networks.\r\n" "\r\nDNET:\r\n"
"BACnet destination network number 0-65534\r\n"
bacnet-stack/demo/initrouter/main.c
+13 -7
View File
@@ -223,14 +223,17 @@ static void Init_Service_Handlers(
apdu_set_reject_handler(MyRejectHandler);
}
static void address_parse(BACNET_ADDRESS * dst,
int argc, char *argv[]) {
static void address_parse(
BACNET_ADDRESS * dst,
int argc,
char *argv[])
{
unsigned mac[6];
unsigned port;
int count = 0;
int index = 0;
if (argc > 0) {
if (argc > 0) {
count =
sscanf(argv[0], "%u.%u.%u.%u:%u", &mac[0], &mac[1], &mac[2],
&mac[3], &port);
@@ -239,8 +242,7 @@ static void address_parse(BACNET_ADDRESS * dst,
for (index = 0; index < 4; index++) {
dst->mac[index] = mac[index];
}
encode_unsigned16(&dst->mac[4],
port);
encode_unsigned16(&dst->mac[4], port);
} else {
count =
sscanf(argv[0], "%x:%x:%x:%x:%x:%x", &mac[0], &mac[1], &mac[2],
@@ -262,9 +264,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/readfile/main.c
+6 -2
View File
@@ -197,9 +197,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/readprop/main.c
+6 -2
View File
@@ -133,9 +133,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/readpropm/main.c
+16 -8
View File
@@ -131,29 +131,36 @@ static void Init_Service_Handlers(
apdu_set_reject_handler(MyRejectHandler);
}
void cleanup(void) {
void cleanup(
void)
{
BACNET_READ_ACCESS_DATA *rpm_object;
BACNET_READ_ACCESS_DATA *old_rpm_object;
BACNET_PROPERTY_REFERENCE *rpm_property;
BACNET_PROPERTY_REFERENCE *old_rpm_property;
rpm_object = Read_Access_Data;
old_rpm_object = rpm_object;
while (rpm_object) {
rpm_object = Read_Access_Data;
old_rpm_object = rpm_object;
while (rpm_object) {
rpm_property = rpm_object->listOfProperties;
while (rpm_property) {
old_rpm_property = rpm_property;
rpm_property = rpm_property->next;
free(old_rpm_property);
} old_rpm_object = rpm_object;
}
old_rpm_object = rpm_object;
rpm_object = rpm_object->next;
free(old_rpm_object);
}
}
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;
@@ -165,7 +172,8 @@ int main(int argc, char *argv[]) {
uint8_t invoke_id = 0;
bool found = false;
uint8_t buffer[MAX_PDU] = {
0};
0
};
BACNET_READ_ACCESS_DATA *rpm_object;
BACNET_PROPERTY_REFERENCE *rpm_property;
bacnet-stack/demo/reinit/main.c
+6 -2
View File
@@ -137,9 +137,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/server/main.c
+6 -2
View File
@@ -98,9 +98,13 @@ static void cleanup(
datalink_cleanup();
}
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 = 1000; /* milliseconds */
time_t last_seconds = 0;
bacnet-stack/demo/timesync/main.c
+6 -2
View File
@@ -106,9 +106,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/ucov/main.c
+2 -2
View File
@@ -222,8 +222,8 @@ int main(int argc, char *argv[]) {
filename_remove_path(argv[0]), filename_remove_path(argv[0]));
return 0;
}
/* decode the command line parameters */ cov_data.
subscriberProcessIdentifier = strtol(argv[1], NULL, 0);
/* decode the command line parameters */
cov_data.subscriberProcessIdentifier = strtol(argv[1], NULL, 0);
cov_data.initiatingDeviceIdentifier = strtol(argv[2], NULL, 0);
cov_data.monitoredObjectIdentifier.type = strtol(argv[3], NULL, 0);
cov_data.monitoredObjectIdentifier.instance = strtol(argv[4], NULL, 0);
bacnet-stack/demo/writefile/main.c
+1 -1
View File
@@ -210,7 +210,7 @@ static void Init_DataLink(
#if defined(BACDL_MSTP)
apdu_timeout_set(60000);
#endif
}
}
if (!datalink_init(getenv("BACNET_IFACE"))) {
exit(1);
}
bacnet-stack/include/alarm_ack.h
+89 -92
View File
@@ -1,92 +1,89 @@
/*####COPYRIGHTBEGIN####
-------------------------------------------
Copyright (C) 2009 John Minack
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
The Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA.
As a special exception, if other files instantiate templates or
use macros or inline functions from this file, or you compile
this file and link it with other works to produce a work based
on this file, this file does not by itself cause the resulting
work to be covered by the GNU General Public License. However
the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public
License.
-------------------------------------------
####COPYRIGHTEND####*/
#ifndef ALARM_ACK_H_
#define ALARM_ACK_H_
#include "bacenum.h"
#include <stdint.h>
#include <stdbool.h>
#include "bacapp.h"
#include "timestamp.h"
typedef struct {
uint32_t ackProcessIdentifier;
BACNET_OBJECT_ID eventObjectIdentifier;
BACNET_EVENT_TYPE eventTypeAcked;
BACNET_TIMESTAMP eventTimeStamp;
BACNET_CHARACTER_STRING ackSource;
BACNET_TIMESTAMP ackTimeStamp;
} BACNET_ALARM_ACK_DATA;
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/***************************************************
**
** Creates a Alarm Acknowledge APDU
**
****************************************************/
int alarm_ack_encode_apdu(
uint8_t * apdu,
uint8_t invoke_id,
BACNET_ALARM_ACK_DATA * data);
/***************************************************
**
** Encodes the service data part of Alarm Acknowledge
**
****************************************************/
int alarm_ack_encode_service_request(
uint8_t * apdu,
BACNET_ALARM_ACK_DATA * data);
/***************************************************
**
** Decodes the service data part of Alarm Acknowledge
**
****************************************************/
int alarm_ack_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_ALARM_ACK_DATA * data);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* ALARM_ACK_H_ */
/*####COPYRIGHTBEGIN####
-------------------------------------------
Copyright (C) 2009 John Minack
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
The Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA.
As a special exception, if other files instantiate templates or
use macros or inline functions from this file, or you compile
this file and link it with other works to produce a work based
on this file, this file does not by itself cause the resulting
work to be covered by the GNU General Public License. However
the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public
License.
-------------------------------------------
####COPYRIGHTEND####*/
#ifndef ALARM_ACK_H_
#define ALARM_ACK_H_
#include "bacenum.h"
#include <stdint.h>
#include <stdbool.h>
#include "bacapp.h"
#include "timestamp.h"
typedef struct {
uint32_t ackProcessIdentifier;
BACNET_OBJECT_ID eventObjectIdentifier;
BACNET_EVENT_TYPE eventTypeAcked;
BACNET_TIMESTAMP eventTimeStamp;
BACNET_CHARACTER_STRING ackSource;
BACNET_TIMESTAMP ackTimeStamp;
} BACNET_ALARM_ACK_DATA;
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/***************************************************
**
** Creates a Alarm Acknowledge APDU
**
****************************************************/
int alarm_ack_encode_apdu(
uint8_t * apdu,
uint8_t invoke_id,
BACNET_ALARM_ACK_DATA * data);
/***************************************************
**
** Encodes the service data part of Alarm Acknowledge
**
****************************************************/
int alarm_ack_encode_service_request(
uint8_t * apdu,
BACNET_ALARM_ACK_DATA * data);
/***************************************************
**
** Decodes the service data part of Alarm Acknowledge
**
****************************************************/
int alarm_ack_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_ALARM_ACK_DATA * data);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* ALARM_ACK_H_ */
bacnet-stack/include/client.h
+6 -6
View File
@@ -150,12 +150,12 @@ extern "C" {
void Send_Initialize_Routing_Table_Ack(
BACNET_ROUTER_PORT * router_port_list);
uint8_t Send_Life_Safety_Operation_Data(
uint32_t device_id,
BACNET_LSO_DATA *data);
uint8_t Send_Alarm_Acknowledgement(
uint32_t device_id,
BACNET_ALARM_ACK_DATA *data);
uint8_t Send_Life_Safety_Operation_Data(
uint32_t device_id,
BACNET_LSO_DATA * data);
uint8_t Send_Alarm_Acknowledgement(
uint32_t device_id,
BACNET_ALARM_ACK_DATA * data);
bacnet-stack/include/dlenv.h
+38 -38
View File
@@ -1,38 +1,38 @@
/**************************************************************************
*
* 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.
*
*********************************************************************/
#ifndef DLENV_H
#define DLENV_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
void dlenv_init(
void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#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.
*
*********************************************************************/
#ifndef DLENV_H
#define DLENV_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
void dlenv_init(
void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
bacnet-stack/include/handlers.h
+5 -5
View File
@@ -176,11 +176,11 @@ extern "C" {
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
void handler_alarm_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
void handler_alarm_ack(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data);
#ifdef __cplusplus
bacnet-stack/ports/bdk-atxx4-mstp/bootloader/main.c
-1
View File
@@ -241,7 +241,6 @@ int main(
_SET_LOCK_BITS(recchar()); /* Read and set lock bits. */
sendchar('\r'); /* Send OK back. */
}
#if defined(_GET_LOCK_BITS)
/* Read lock bits. */
else if (val == 'r') {
bacnet-stack/src/alarm_ack.c
+275 -233
View File
@@ -1,233 +1,275 @@
/*####COPYRIGHTBEGIN####
-------------------------------------------
Copyright (C) 2009 John Minack
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
The Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA.
As a special exception, if other files instantiate templates or
use macros or inline functions from this file, or you compile
this file and link it with other works to produce a work based
on this file, this file does not by itself cause the resulting
work to be covered by the GNU General Public License. However
the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public
License.
-------------------------------------------
####COPYRIGHTEND####*/
#include "alarm_ack.h"
/***************************************************
**
** Creates an Unconfirmed Event Notification APDU
**
****************************************************/
int alarm_ack_encode_apdu(
uint8_t * apdu,
uint8_t invoke_id,
BACNET_ALARM_ACK_DATA * data)
{
int len = 0; /* length of each encoding */
int apdu_len = 0; /* total length of the apdu, return value */
if (apdu) {
apdu[0] = PDU_TYPE_CONFIRMED_SERVICE_REQUEST;
apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU);
apdu[2] = invoke_id;
apdu[3] = SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM; /* service choice */
apdu_len = 4;
len = alarm_ack_encode_service_request(&apdu[apdu_len], data);
apdu_len += len;
}
return apdu_len;
}
/***************************************************
**
** Encodes the service data part of Event Notification
**
****************************************************/
int alarm_ack_encode_service_request(
uint8_t * apdu,
BACNET_ALARM_ACK_DATA * data)
{
int len = 0; /* length of each encoding */
int apdu_len = 0; /* total length of the apdu, return value */
if (apdu) {
len = encode_context_unsigned(&apdu[apdu_len], 0, data->ackProcessIdentifier);
apdu_len += len;
len = encode_context_object_id(&apdu[apdu_len], 1, data->eventObjectIdentifier.type, data->eventObjectIdentifier.instance);
apdu_len += len;
len = encode_context_enumerated(&apdu[apdu_len], 2, data->eventTypeAcked);
apdu_len += len;
len = bacapp_encode_context_timestamp(&apdu[apdu_len], 3, &data->eventTimeStamp);
apdu_len += len;
len = encode_context_character_string(&apdu[apdu_len], 4, &data->ackSource);
apdu_len += len;
len = bacapp_encode_context_timestamp(&apdu[apdu_len], 5, &data->ackTimeStamp);
apdu_len += len;
}
return apdu_len;
}
/***************************************************
**
** Decodes the service data part of Event Notification
**
****************************************************/
int alarm_ack_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_ALARM_ACK_DATA * data)
{
int len = 0;
int section_len;
if (-1 == (section_len =
decode_context_unsigned(&apdu[len], 0, &data->ackProcessIdentifier))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
decode_context_object_id(&apdu[len], 1, &data->eventObjectIdentifier.type, &data->eventObjectIdentifier.instance))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
decode_context_enumerated(&apdu[len], 2, (int*)&data->eventTypeAcked))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
bacapp_decode_context_timestamp(&apdu[len], 3, &data->eventTimeStamp))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
decode_context_character_string(&apdu[len], 4, &data->ackSource))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
bacapp_decode_context_timestamp(&apdu[len], 5, &data->ackTimeStamp))) {
return -1;
}
len += section_len;
return len;
}
#ifdef TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testAlarmAck(
Test * pTest)
{
BACNET_ALARM_ACK_DATA testAlarmAckIn;
BACNET_ALARM_ACK_DATA testAlarmAckOut;
uint8_t buffer[MAX_APDU];
int inLen;
int outLen;
testAlarmAckIn.ackProcessIdentifier = 0x1234;
characterstring_init_ansi(&testAlarmAckIn.ackSource, "This is a test");
testAlarmAckIn.ackTimeStamp.tag = TIME_STAMP_SEQUENCE;
testAlarmAckIn.ackTimeStamp.value.sequenceNum = 0x4331;
testAlarmAckIn.eventObjectIdentifier.instance = 567;
testAlarmAckIn.eventObjectIdentifier.type = OBJECT_DEVICE;
testAlarmAckIn.eventTimeStamp.tag = TIME_STAMP_TIME;
testAlarmAckIn.eventTimeStamp.value.time.hour = 10;
testAlarmAckIn.eventTimeStamp.value.time.min = 11;
testAlarmAckIn.eventTimeStamp.value.time.sec = 12;
testAlarmAckIn.eventTimeStamp.value.time.hundredths = 14;
testAlarmAckIn.eventTypeAcked = EVENT_CHANGE_OF_LIFE_SAFETY;
memset(&testAlarmAckOut, 0, sizeof(testAlarmAckOut));
inLen = alarm_ack_encode_service_request(buffer, &testAlarmAckIn);
outLen = alarm_ack_decode_service_request(buffer, inLen, &testAlarmAckOut);
ct_test(pTest, inLen == outLen);
ct_test(pTest, testAlarmAckIn.ackProcessIdentifier == testAlarmAckOut.ackProcessIdentifier);
ct_test(pTest, testAlarmAckIn.ackTimeStamp.tag == testAlarmAckOut.ackTimeStamp.tag);
ct_test(pTest, testAlarmAckIn.ackTimeStamp.value.sequenceNum == testAlarmAckOut.ackTimeStamp.value.sequenceNum);
ct_test(pTest, testAlarmAckIn.ackProcessIdentifier == testAlarmAckOut.ackProcessIdentifier);
ct_test(pTest, testAlarmAckIn.eventObjectIdentifier.instance == testAlarmAckOut.eventObjectIdentifier.instance);
ct_test(pTest, testAlarmAckIn.eventObjectIdentifier.type == testAlarmAckOut.eventObjectIdentifier.type);
ct_test(pTest, testAlarmAckIn.eventTimeStamp.tag == testAlarmAckOut.eventTimeStamp.tag);
ct_test(pTest, testAlarmAckIn.eventTimeStamp.value.time.hour == testAlarmAckOut.eventTimeStamp.value.time.hour);
ct_test(pTest, testAlarmAckIn.eventTimeStamp.value.time.min == testAlarmAckOut.eventTimeStamp.value.time.min);
ct_test(pTest, testAlarmAckIn.eventTimeStamp.value.time.sec == testAlarmAckOut.eventTimeStamp.value.time.sec);
ct_test(pTest, testAlarmAckIn.eventTimeStamp.value.time.hundredths == testAlarmAckOut.eventTimeStamp.value.time.hundredths);
ct_test(pTest, testAlarmAckIn.eventTypeAcked == testAlarmAckOut.eventTypeAcked);
}
#ifdef TEST_ALARM_ACK
int main(
void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Alarm Ack", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testAlarmAck);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void) ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_ALARM_ACK */
#endif /* TEST */
/*####COPYRIGHTBEGIN####
-------------------------------------------
Copyright (C) 2009 John Minack
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
The Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA.
As a special exception, if other files instantiate templates or
use macros or inline functions from this file, or you compile
this file and link it with other works to produce a work based
on this file, this file does not by itself cause the resulting
work to be covered by the GNU General Public License. However
the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public
License.
-------------------------------------------
####COPYRIGHTEND####*/
#include "alarm_ack.h"
/***************************************************
**
** Creates an Unconfirmed Event Notification APDU
**
****************************************************/
int alarm_ack_encode_apdu(
uint8_t * apdu,
uint8_t invoke_id,
BACNET_ALARM_ACK_DATA * data)
{
int len = 0; /* length of each encoding */
int apdu_len = 0; /* total length of the apdu, return value */
if (apdu) {
apdu[0] = PDU_TYPE_CONFIRMED_SERVICE_REQUEST;
apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU);
apdu[2] = invoke_id;
apdu[3] = SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM; /* service choice */
apdu_len = 4;
len = alarm_ack_encode_service_request(&apdu[apdu_len], data);
apdu_len += len;
}
return apdu_len;
}
/***************************************************
**
** Encodes the service data part of Event Notification
**
****************************************************/
int alarm_ack_encode_service_request(
uint8_t * apdu,
BACNET_ALARM_ACK_DATA * data)
{
int len = 0; /* length of each encoding */
int apdu_len = 0; /* total length of the apdu, return value */
if (apdu) {
len =
encode_context_unsigned(&apdu[apdu_len], 0,
data->ackProcessIdentifier);
apdu_len += len;
len =
encode_context_object_id(&apdu[apdu_len], 1,
data->eventObjectIdentifier.type,
data->eventObjectIdentifier.instance);
apdu_len += len;
len =
encode_context_enumerated(&apdu[apdu_len], 2,
data->eventTypeAcked);
apdu_len += len;
len =
bacapp_encode_context_timestamp(&apdu[apdu_len], 3,
&data->eventTimeStamp);
apdu_len += len;
len =
encode_context_character_string(&apdu[apdu_len], 4,
&data->ackSource);
apdu_len += len;
len =
bacapp_encode_context_timestamp(&apdu[apdu_len], 5,
&data->ackTimeStamp);
apdu_len += len;
}
return apdu_len;
}
/***************************************************
**
** Decodes the service data part of Event Notification
**
****************************************************/
int alarm_ack_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_ALARM_ACK_DATA * data)
{
int len = 0;
int section_len;
if (-1 == (section_len =
decode_context_unsigned(&apdu[len], 0,
&data->ackProcessIdentifier))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
decode_context_object_id(&apdu[len], 1,
&data->eventObjectIdentifier.type,
&data->eventObjectIdentifier.instance))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
decode_context_enumerated(&apdu[len], 2,
(int *) &data->eventTypeAcked))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
bacapp_decode_context_timestamp(&apdu[len], 3,
&data->eventTimeStamp))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
decode_context_character_string(&apdu[len], 4,
&data->ackSource))) {
return -1;
}
len += section_len;
if (-1 == (section_len =
bacapp_decode_context_timestamp(&apdu[len], 5,
&data->ackTimeStamp))) {
return -1;
}
len += section_len;
return len;
}
#ifdef TEST
#include <assert.h>
#include <string.h>
#include "ctest.h"
void testAlarmAck(
Test * pTest)
{
BACNET_ALARM_ACK_DATA testAlarmAckIn;
BACNET_ALARM_ACK_DATA testAlarmAckOut;
uint8_t buffer[MAX_APDU];
int inLen;
int outLen;
testAlarmAckIn.ackProcessIdentifier = 0x1234;
characterstring_init_ansi(&testAlarmAckIn.ackSource, "This is a test");
testAlarmAckIn.ackTimeStamp.tag = TIME_STAMP_SEQUENCE;
testAlarmAckIn.ackTimeStamp.value.sequenceNum = 0x4331;
testAlarmAckIn.eventObjectIdentifier.instance = 567;
testAlarmAckIn.eventObjectIdentifier.type = OBJECT_DEVICE;
testAlarmAckIn.eventTimeStamp.tag = TIME_STAMP_TIME;
testAlarmAckIn.eventTimeStamp.value.time.hour = 10;
testAlarmAckIn.eventTimeStamp.value.time.min = 11;
testAlarmAckIn.eventTimeStamp.value.time.sec = 12;
testAlarmAckIn.eventTimeStamp.value.time.hundredths = 14;
testAlarmAckIn.eventTypeAcked = EVENT_CHANGE_OF_LIFE_SAFETY;
memset(&testAlarmAckOut, 0, sizeof(testAlarmAckOut));
inLen = alarm_ack_encode_service_request(buffer, &testAlarmAckIn);
outLen = alarm_ack_decode_service_request(buffer, inLen, &testAlarmAckOut);
ct_test(pTest, inLen == outLen);
ct_test(pTest,
testAlarmAckIn.ackProcessIdentifier ==
testAlarmAckOut.ackProcessIdentifier);
ct_test(pTest,
testAlarmAckIn.ackTimeStamp.tag == testAlarmAckOut.ackTimeStamp.tag);
ct_test(pTest,
testAlarmAckIn.ackTimeStamp.value.sequenceNum ==
testAlarmAckOut.ackTimeStamp.value.sequenceNum);
ct_test(pTest,
testAlarmAckIn.ackProcessIdentifier ==
testAlarmAckOut.ackProcessIdentifier);
ct_test(pTest,
testAlarmAckIn.eventObjectIdentifier.instance ==
testAlarmAckOut.eventObjectIdentifier.instance);
ct_test(pTest,
testAlarmAckIn.eventObjectIdentifier.type ==
testAlarmAckOut.eventObjectIdentifier.type);
ct_test(pTest,
testAlarmAckIn.eventTimeStamp.tag ==
testAlarmAckOut.eventTimeStamp.tag);
ct_test(pTest,
testAlarmAckIn.eventTimeStamp.value.time.hour ==
testAlarmAckOut.eventTimeStamp.value.time.hour);
ct_test(pTest,
testAlarmAckIn.eventTimeStamp.value.time.min ==
testAlarmAckOut.eventTimeStamp.value.time.min);
ct_test(pTest,
testAlarmAckIn.eventTimeStamp.value.time.sec ==
testAlarmAckOut.eventTimeStamp.value.time.sec);
ct_test(pTest,
testAlarmAckIn.eventTimeStamp.value.time.hundredths ==
testAlarmAckOut.eventTimeStamp.value.time.hundredths);
ct_test(pTest,
testAlarmAckIn.eventTypeAcked == testAlarmAckOut.eventTypeAcked);
}
#ifdef TEST_ALARM_ACK
int main(
void)
{
Test *pTest;
bool rc;
pTest = ct_create("BACnet Alarm Ack", NULL);
/* individual tests */
rc = ct_addTestFunction(pTest, testAlarmAck);
assert(rc);
ct_setStream(pTest, stdout);
ct_run(pTest);
(void) ct_report(pTest);
ct_destroy(pTest);
return 0;
}
#endif /* TEST_ALARM_ACK */
#endif /* TEST */