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); apdu_set_reject_handler(MyRejectHandler);
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0; 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; return invoke_id;
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0; 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> * Copyright (C) 2009 Steve Karg <skarg@users.sourceforge.net>
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the * a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, * without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to * distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to * permit persons to whom the Software is furnished to do so, subject to
* the following conditions: * the following conditions:
* *
* The above copyright notice and this permission notice shall be included * The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software. * in all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* *
*********************************************************************/ *********************************************************************/
/* environment variables used for the command line tools */ /* environment variables used for the command line tools */
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "config.h" #include "config.h"
#include "bacdef.h" #include "bacdef.h"
#include "apdu.h" #include "apdu.h"
#include "datalink.h" #include "datalink.h"
#include "handlers.h" #include "handlers.h"
#include "client.h" #include "client.h"
void dlenv_init( void dlenv_init(
void) void)
{ {
char *pEnv = NULL; char *pEnv = NULL;
#if defined(BACDL_BIP) && BBMD_ENABLED #if defined(BACDL_BIP) && BBMD_ENABLED
long bbmd_port = 0xBAC0; long bbmd_port = 0xBAC0;
long bbmd_address = 0; long bbmd_address = 0;
long bbmd_timetolive_seconds = 60000; long bbmd_timetolive_seconds = 60000;
#endif #endif
#if defined(BACDL_ALL) #if defined(BACDL_ALL)
pEnv = getenv("BACNET_DATALINK"); pEnv = getenv("BACNET_DATALINK");
if (pEnv) { if (pEnv) {
datalink_set(pEnv)); datalink_set(pEnv));
} else { } else {
datalink_set(NULL); datalink_set(NULL);
} }
#endif #endif
#if defined(BACDL_BIP) #if defined(BACDL_BIP)
pEnv = getenv("BACNET_IP_PORT"); pEnv = getenv("BACNET_IP_PORT");
if (pEnv) { if (pEnv) {
bip_set_port(strtol(pEnv, NULL, 0)); bip_set_port(strtol(pEnv, NULL, 0));
} else { } else {
bip_set_port(0xBAC0); bip_set_port(0xBAC0);
} }
#elif defined(BACDL_MSTP) #elif defined(BACDL_MSTP)
pEnv = getenv("BACNET_MAX_INFO_FRAMES"); pEnv = getenv("BACNET_MAX_INFO_FRAMES");
if (pEnv) { if (pEnv) {
dlmstp_set_max_info_frames(strtol(pEnv, NULL, 0)); dlmstp_set_max_info_frames(strtol(pEnv, NULL, 0));
} else { } else {
dlmstp_set_max_info_frames(1); dlmstp_set_max_info_frames(1);
} }
pEnv = getenv("BACNET_MAX_MASTER"); pEnv = getenv("BACNET_MAX_MASTER");
if (pEnv) { if (pEnv) {
dlmstp_set_max_master(strtol(pEnv, NULL, 0)); dlmstp_set_max_master(strtol(pEnv, NULL, 0));
} else { } else {
dlmstp_set_max_master(127); dlmstp_set_max_master(127);
} }
pEnv = getenv("BACNET_MSTP_BAUD"); pEnv = getenv("BACNET_MSTP_BAUD");
if (pEnv) { if (pEnv) {
dlmstp_set_baud_rate(strtol(pEnv, NULL, 0)); dlmstp_set_baud_rate(strtol(pEnv, NULL, 0));
} else { } else {
dlmstp_set_baud_rate(38400); dlmstp_set_baud_rate(38400);
} }
pEnv = getenv("BACNET_MSTP_MAC"); pEnv = getenv("BACNET_MSTP_MAC");
if (pEnv) { if (pEnv) {
dlmstp_set_mac_address(strtol(pEnv, NULL, 0)); dlmstp_set_mac_address(strtol(pEnv, NULL, 0));
} else { } else {
dlmstp_set_mac_address(127); dlmstp_set_mac_address(127);
} }
#endif #endif
pEnv = getenv("BACNET_APDU_TIMEOUT"); pEnv = getenv("BACNET_APDU_TIMEOUT");
if (pEnv) { if (pEnv) {
apdu_timeout_set(strtol(pEnv, NULL, 0)); apdu_timeout_set(strtol(pEnv, NULL, 0));
fprintf(stderr, "BACNET_APDU_TIMEOUT=%s\r\n", pEnv); fprintf(stderr, "BACNET_APDU_TIMEOUT=%s\r\n", pEnv);
} else { } else {
#if defined(BACDL_MSTP) #if defined(BACDL_MSTP)
apdu_timeout_set(60000); apdu_timeout_set(60000);
#endif #endif
} }
if (!datalink_init(getenv("BACNET_IFACE"))) { if (!datalink_init(getenv("BACNET_IFACE"))) {
exit(1); exit(1);
} }
#if defined(BACDL_BIP) && BBMD_ENABLED #if defined(BACDL_BIP) && BBMD_ENABLED
pEnv = getenv("BACNET_BBMD_PORT"); pEnv = getenv("BACNET_BBMD_PORT");
if (pEnv) { if (pEnv) {
bbmd_port = strtol(pEnv, NULL, 0); bbmd_port = strtol(pEnv, NULL, 0);
if (bbmd_port > 0xFFFF) { if (bbmd_port > 0xFFFF) {
bbmd_port = 0xBAC0; bbmd_port = 0xBAC0;
} }
} }
pEnv = getenv("BACNET_BBMD_TIMETOLIVE"); pEnv = getenv("BACNET_BBMD_TIMETOLIVE");
if (pEnv) { if (pEnv) {
bbmd_timetolive_seconds = strtol(pEnv, NULL, 0); bbmd_timetolive_seconds = strtol(pEnv, NULL, 0);
if (bbmd_timetolive_seconds > 0xFFFF) { if (bbmd_timetolive_seconds > 0xFFFF) {
bbmd_timetolive_seconds = 0xFFFF; bbmd_timetolive_seconds = 0xFFFF;
} }
} }
pEnv = getenv("BACNET_BBMD_ADDRESS"); pEnv = getenv("BACNET_BBMD_ADDRESS");
if (pEnv) { if (pEnv) {
bbmd_address = bip_getaddrbyname(pEnv); bbmd_address = bip_getaddrbyname(pEnv);
if (bbmd_address) { if (bbmd_address) {
struct in_addr addr; struct in_addr addr;
addr.s_addr = bbmd_address; addr.s_addr = bbmd_address;
fprintf(stderr, fprintf(stderr,
"Registering with BBMD at %s:%ld for %ld seconds\n", "Registering with BBMD at %s:%ld for %ld seconds\n",
inet_ntoa(addr), bbmd_port, bbmd_timetolive_seconds); inet_ntoa(addr), bbmd_port, bbmd_timetolive_seconds);
bvlc_register_with_bbmd(bbmd_address, bbmd_port, bvlc_register_with_bbmd(bbmd_address, bbmd_port,
bbmd_timetolive_seconds); bbmd_timetolive_seconds);
} }
} }
#endif #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> * Copyright (C) 2005 Steve Karg <skarg@users.sourceforge.net>
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the * a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, * without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to * distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to * permit persons to whom the Software is furnished to do so, subject to
* the following conditions: * the following conditions:
* *
* The above copyright notice and this permission notice shall be included * The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software. * in all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* *
*********************************************************************/ *********************************************************************/
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include "config.h" #include "config.h"
#include "txbuf.h" #include "txbuf.h"
#include "bacdef.h" #include "bacdef.h"
#include "bacdcode.h" #include "bacdcode.h"
#include "apdu.h" #include "apdu.h"
#include "npdu.h" #include "npdu.h"
#include "abort.h" #include "abort.h"
#include "alarm_ack.h" #include "alarm_ack.h"
#include "handlers.h" #include "handlers.h"
void handler_alarm_ack( void handler_alarm_ack(
uint8_t * service_request, uint8_t * service_request,
uint16_t service_len, uint16_t service_len,
BACNET_ADDRESS * src, BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data) BACNET_CONFIRMED_SERVICE_DATA * service_data)
{ {
BACNET_ALARM_ACK_DATA data; BACNET_ALARM_ACK_DATA data;
int len = 0; int len = 0;
int pdu_len = 0; int pdu_len = 0;
BACNET_NPDU_DATA npdu_data; BACNET_NPDU_DATA npdu_data;
int bytes_sent = 0; int bytes_sent = 0;
BACNET_ADDRESS my_address; BACNET_ADDRESS my_address;
/* encode the NPDU portion of the packet */ /* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address); datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL); npdu_encode_npdu_data(&npdu_data, false, MESSAGE_PRIORITY_NORMAL);
pdu_len = pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address, npdu_encode_pdu(&Handler_Transmit_Buffer[0], src, &my_address,
&npdu_data); &npdu_data);
if (service_data->segmented_message) { if (service_data->segmented_message) {
/* we don't support segmentation - send an abort */ /* we don't support segmentation - send an abort */
len = len =
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED, service_data->invoke_id, ABORT_REASON_SEGMENTATION_NOT_SUPPORTED,
true); true);
#if PRINT_ENABLED #if PRINT_ENABLED
fprintf(stderr, "Alarm Ack: Segmented message. Sending Abort!\n"); fprintf(stderr, "Alarm Ack: Segmented message. Sending Abort!\n");
#endif #endif
goto AA_ABORT; goto AA_ABORT;
} }
len = alarm_ack_decode_service_request(service_request, service_len, &data); len =
#if PRINT_ENABLED alarm_ack_decode_service_request(service_request, service_len, &data);
if (len <= 0) #if PRINT_ENABLED
fprintf(stderr, "Alarm Ack: Unable to decode Request!\n"); if (len <= 0)
#endif fprintf(stderr, "Alarm Ack: Unable to decode Request!\n");
if (len < 0) { #endif
/* bad decoding - send an abort */ if (len < 0) {
len = /* bad decoding - send an abort */
abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len], len =
service_data->invoke_id, ABORT_REASON_OTHER, true); abort_encode_apdu(&Handler_Transmit_Buffer[pdu_len],
#if PRINT_ENABLED service_data->invoke_id, ABORT_REASON_OTHER, true);
fprintf(stderr, "Alarm Ack: Bad Encoding. Sending Abort!\n"); #if PRINT_ENABLED
#endif fprintf(stderr, "Alarm Ack: Bad Encoding. Sending Abort!\n");
goto AA_ABORT; #endif
} goto AA_ABORT;
}
/*
** Process Life Safety Operation Here /*
*/ ** Process Life Safety Operation Here
#if PRINT_ENABLED */
fprintf(stderr, #if PRINT_ENABLED
"Alarm Ack Operation: Received acknowledge for object id %d from %s for process id %d for object %id\n", fprintf(stderr,
data.eventObjectIdentifier.instance, "Alarm Ack Operation: Received acknowledge for object id %d from %s for process id %d for object %id\n",
data.ackSource.value, data.eventObjectIdentifier.instance, data.ackSource.value,
data.ackProcessIdentifier, data.ackProcessIdentifier, data.eventObjectIdentifier.instance);
data.eventObjectIdentifier.instance); #endif
#endif
len =
len = encode_simple_ack(&Handler_Transmit_Buffer[pdu_len],
encode_simple_ack(&Handler_Transmit_Buffer[pdu_len], service_data->invoke_id, SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM);
service_data->invoke_id, SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM); #if PRINT_ENABLED
#if PRINT_ENABLED fprintf(stderr, "Alarm Acknowledge: " "Sending Simple Ack!\n");
fprintf(stderr, "Alarm Acknowledge: " "Sending Simple Ack!\n"); #endif
#endif
AA_ABORT:
AA_ABORT: pdu_len += len;
pdu_len += len; bytes_sent =
bytes_sent = datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0],
datalink_send_pdu(src, &npdu_data, &Handler_Transmit_Buffer[0], pdu_len);
pdu_len); #if PRINT_ENABLED
#if PRINT_ENABLED if (bytes_sent <= 0)
if (bytes_sent <= 0) fprintf(stderr, "Alarm Acknowledge: " "Failed to send PDU (%s)!\n",
fprintf(stderr, "Alarm Acknowledge: " "Failed to send PDU (%s)!\n", strerror(errno));
strerror(errno)); #endif
#endif
return;
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> * Copyright (C) 2009 John Minack <minack@users.sourceforge.net>
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the * a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, * without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to * distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to * permit persons to whom the Software is furnished to do so, subject to
* the following conditions: * the following conditions:
* *
* The above copyright notice and this permission notice shall be included * The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software. * in all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* *
*********************************************************************/ *********************************************************************/
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
#include "config.h" #include "config.h"
#include "config.h" #include "config.h"
#include "txbuf.h" #include "txbuf.h"
#include "bacdef.h" #include "bacdef.h"
#include "bacdcode.h" #include "bacdcode.h"
#include "address.h" #include "address.h"
#include "tsm.h" #include "tsm.h"
#include "npdu.h" #include "npdu.h"
#include "apdu.h" #include "apdu.h"
#include "device.h" #include "device.h"
#include "datalink.h" #include "datalink.h"
#include "dcc.h" #include "dcc.h"
#include "whois.h" #include "whois.h"
/* some demo stuff needed */ /* some demo stuff needed */
#include "handlers.h" #include "handlers.h"
#include "txbuf.h" #include "txbuf.h"
#include "alarm_ack.h" #include "alarm_ack.h"
/* returns the invoke ID for confirmed request, or zero on failure */ /* returns the invoke ID for confirmed request, or zero on failure */
uint8_t Send_Alarm_Acknowledgement( uint8_t Send_Alarm_Acknowledgement(
uint32_t device_id, uint32_t device_id,
BACNET_ALARM_ACK_DATA *data) BACNET_ALARM_ACK_DATA * data)
{ {
BACNET_ADDRESS dest; BACNET_ADDRESS dest;
BACNET_ADDRESS my_address; BACNET_ADDRESS my_address;
unsigned max_apdu = 0; unsigned max_apdu = 0;
uint8_t invoke_id = 0; uint8_t invoke_id = 0;
bool status = false; bool status = false;
int len = 0; int len = 0;
int pdu_len = 0; int pdu_len = 0;
int bytes_sent = 0; int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data; BACNET_NPDU_DATA npdu_data;
if (!dcc_communication_enabled()) if (!dcc_communication_enabled())
return 0; return 0;
/* is the device bound? */ /* is the device bound? */
status = address_get_by_device(device_id, &max_apdu, &dest); status = address_get_by_device(device_id, &max_apdu, &dest);
/* is there a tsm available? */ /* is there a tsm available? */
if (status) if (status)
invoke_id = tsm_next_free_invokeID(); invoke_id = tsm_next_free_invokeID();
if (invoke_id) { if (invoke_id) {
/* encode the NPDU portion of the packet */ /* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address); datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL); npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL);
pdu_len = pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address, npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address,
&npdu_data); &npdu_data);
len = len =
alarm_ack_encode_apdu(&Handler_Transmit_Buffer[pdu_len], invoke_id, alarm_ack_encode_apdu(&Handler_Transmit_Buffer[pdu_len], invoke_id,
data); data);
pdu_len += len; pdu_len += len;
/* will it fit in the sender? /* will it fit in the sender?
note: if there is a bottleneck router in between note: if there is a bottleneck router in between
us and the destination, we won't know unless us and the destination, we won't know unless
we have a way to check for that and update the we have a way to check for that and update the
max_apdu in the address binding table. */ max_apdu in the address binding table. */
if ((unsigned) pdu_len < max_apdu) { if ((unsigned) pdu_len < max_apdu) {
tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest, tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
&npdu_data, &Handler_Transmit_Buffer[0], (uint16_t) pdu_len); &npdu_data, &Handler_Transmit_Buffer[0], (uint16_t) pdu_len);
bytes_sent = bytes_sent =
datalink_send_pdu(&dest, &npdu_data, datalink_send_pdu(&dest, &npdu_data,
&Handler_Transmit_Buffer[0], pdu_len); &Handler_Transmit_Buffer[0], pdu_len);
#if PRINT_ENABLED #if PRINT_ENABLED
if (bytes_sent <= 0) if (bytes_sent <= 0)
fprintf(stderr, "Failed to Send Alarm Ack Request (%s)!\n", fprintf(stderr, "Failed to Send Alarm Ack Request (%s)!\n",
strerror(errno)); strerror(errno));
#endif #endif
} else { } else {
tsm_free_invoke_id(invoke_id); tsm_free_invoke_id(invoke_id);
invoke_id = 0; invoke_id = 0;
#if PRINT_ENABLED #if PRINT_ENABLED
fprintf(stderr, fprintf(stderr,
"Failed to Send Alarm Ack Request " "Failed to Send Alarm Ack Request "
"(exceeds destination maximum APDU)!\n"); "(exceeds destination maximum APDU)!\n");
#endif #endif
} }
} }
return invoke_id; 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> * Copyright (C) 2009 John Minack <minack@users.sourceforge.net>
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the * a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, * without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to * distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to * permit persons to whom the Software is furnished to do so, subject to
* the following conditions: * the following conditions:
* *
* The above copyright notice and this permission notice shall be included * The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software. * in all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* *
*********************************************************************/ *********************************************************************/
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
#include "config.h" #include "config.h"
#include "config.h" #include "config.h"
#include "txbuf.h" #include "txbuf.h"
#include "bacdef.h" #include "bacdef.h"
#include "bacdcode.h" #include "bacdcode.h"
#include "address.h" #include "address.h"
#include "tsm.h" #include "tsm.h"
#include "npdu.h" #include "npdu.h"
#include "apdu.h" #include "apdu.h"
#include "device.h" #include "device.h"
#include "datalink.h" #include "datalink.h"
#include "dcc.h" #include "dcc.h"
#include "whois.h" #include "whois.h"
/* some demo stuff needed */ /* some demo stuff needed */
#include "handlers.h" #include "handlers.h"
#include "txbuf.h" #include "txbuf.h"
#include "lso.h" #include "lso.h"
/* returns the invoke ID for confirmed request, or zero on failure */ /* returns the invoke ID for confirmed request, or zero on failure */
uint8_t Send_Life_Safety_Operation_Data( uint8_t Send_Life_Safety_Operation_Data(
uint32_t device_id, uint32_t device_id,
BACNET_LSO_DATA *data) BACNET_LSO_DATA * data)
{ {
BACNET_ADDRESS dest; BACNET_ADDRESS dest;
BACNET_ADDRESS my_address; BACNET_ADDRESS my_address;
unsigned max_apdu = 0; unsigned max_apdu = 0;
uint8_t invoke_id = 0; uint8_t invoke_id = 0;
bool status = false; bool status = false;
int len = 0; int len = 0;
int pdu_len = 0; int pdu_len = 0;
int bytes_sent = 0; int bytes_sent = 0;
BACNET_NPDU_DATA npdu_data; BACNET_NPDU_DATA npdu_data;
if (!dcc_communication_enabled()) if (!dcc_communication_enabled())
return 0; return 0;
/* is the device bound? */ /* is the device bound? */
status = address_get_by_device(device_id, &max_apdu, &dest); status = address_get_by_device(device_id, &max_apdu, &dest);
/* is there a tsm available? */ /* is there a tsm available? */
if (status) if (status)
invoke_id = tsm_next_free_invokeID(); invoke_id = tsm_next_free_invokeID();
if (invoke_id) { if (invoke_id) {
/* encode the NPDU portion of the packet */ /* encode the NPDU portion of the packet */
datalink_get_my_address(&my_address); datalink_get_my_address(&my_address);
npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL); npdu_encode_npdu_data(&npdu_data, true, MESSAGE_PRIORITY_NORMAL);
pdu_len = pdu_len =
npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address, npdu_encode_pdu(&Handler_Transmit_Buffer[0], &dest, &my_address,
&npdu_data); &npdu_data);
len = len =
lso_encode_adpu(&Handler_Transmit_Buffer[pdu_len], invoke_id, lso_encode_adpu(&Handler_Transmit_Buffer[pdu_len], invoke_id,
data); data);
pdu_len += len; pdu_len += len;
/* will it fit in the sender? /* will it fit in the sender?
note: if there is a bottleneck router in between note: if there is a bottleneck router in between
us and the destination, we won't know unless us and the destination, we won't know unless
we have a way to check for that and update the we have a way to check for that and update the
max_apdu in the address binding table. */ max_apdu in the address binding table. */
if ((unsigned) pdu_len < max_apdu) { if ((unsigned) pdu_len < max_apdu) {
tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest, tsm_set_confirmed_unsegmented_transaction(invoke_id, &dest,
&npdu_data, &Handler_Transmit_Buffer[0], (uint16_t) pdu_len); &npdu_data, &Handler_Transmit_Buffer[0], (uint16_t) pdu_len);
bytes_sent = bytes_sent =
datalink_send_pdu(&dest, &npdu_data, datalink_send_pdu(&dest, &npdu_data,
&Handler_Transmit_Buffer[0], pdu_len); &Handler_Transmit_Buffer[0], pdu_len);
#if PRINT_ENABLED #if PRINT_ENABLED
if (bytes_sent <= 0) if (bytes_sent <= 0)
fprintf(stderr, "Failed to Send Life Safe Op Request (%s)!\n", fprintf(stderr, "Failed to Send Life Safe Op Request (%s)!\n",
strerror(errno)); strerror(errno));
#endif #endif
} else { } else {
tsm_free_invoke_id(invoke_id); tsm_free_invoke_id(invoke_id);
invoke_id = 0; invoke_id = 0;
#if PRINT_ENABLED #if PRINT_ENABLED
fprintf(stderr, fprintf(stderr,
"Failed to Send Life Safe Op Request " "Failed to Send Life Safe Op Request "
"(exceeds destination maximum APDU)!\n"); "(exceeds destination maximum APDU)!\n");
#endif #endif
} }
} }
return invoke_id; 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); apdu_set_reject_handler(MyRejectHandler);
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
unsigned arg_count = 0; unsigned arg_count = 0;
if (argc < 2) { if (argc < 2) {
printf("Usage: %s DNET [DNET] [DNET] [...]\r\n", printf("Usage: %s DNET [DNET] [DNET] [...]\r\n",
filename_remove_path(argv[0])); filename_remove_path(argv[0]));
return 0; return 0;
} }
if (( if ((argc > 1) && (strcmp(argv[1], "--help") == 0)) {
argc > 1) && (
strcmp(argv[1],
"--help") == 0)) {
printf("Send BACnet I-Am-Router-To-Network message for \r\n" printf("Send BACnet I-Am-Router-To-Network message for \r\n"
"one or more networks.\r\n" "\r\nDNET:\r\n" "one or more networks.\r\n" "\r\nDNET:\r\n"
"BACnet destination network number 0-65534\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); apdu_set_reject_handler(MyRejectHandler);
} }
static void address_parse(BACNET_ADDRESS * dst, static void address_parse(
int argc, char *argv[]) { BACNET_ADDRESS * dst,
int argc,
char *argv[])
{
unsigned mac[6]; unsigned mac[6];
unsigned port; unsigned port;
int count = 0; int count = 0;
int index = 0; int index = 0;
if (argc > 0) { if (argc > 0) {
count = count =
sscanf(argv[0], "%u.%u.%u.%u:%u", &mac[0], &mac[1], &mac[2], sscanf(argv[0], "%u.%u.%u.%u:%u", &mac[0], &mac[1], &mac[2],
&mac[3], &port); &mac[3], &port);
@@ -239,8 +242,7 @@ static void address_parse(BACNET_ADDRESS * dst,
for (index = 0; index < 4; index++) { for (index = 0; index < 4; index++) {
dst->mac[index] = mac[index]; dst->mac[index] = mac[index];
} }
encode_unsigned16(&dst->mac[4], encode_unsigned16(&dst->mac[4], port);
port);
} else { } else {
count = count =
sscanf(argv[0], "%x:%x:%x:%x:%x:%x", &mac[0], &mac[1], &mac[2], 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 = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
time_t total_seconds = 0; 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); apdu_set_reject_handler(MyRejectHandler);
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0; 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); apdu_set_reject_handler(MyRejectHandler);
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0; 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); apdu_set_reject_handler(MyRejectHandler);
} }
void cleanup(void) { void cleanup(
void)
{
BACNET_READ_ACCESS_DATA *rpm_object; BACNET_READ_ACCESS_DATA *rpm_object;
BACNET_READ_ACCESS_DATA *old_rpm_object; BACNET_READ_ACCESS_DATA *old_rpm_object;
BACNET_PROPERTY_REFERENCE *rpm_property; BACNET_PROPERTY_REFERENCE *rpm_property;
BACNET_PROPERTY_REFERENCE *old_rpm_property; BACNET_PROPERTY_REFERENCE *old_rpm_property;
rpm_object = Read_Access_Data; rpm_object = Read_Access_Data;
old_rpm_object = rpm_object; old_rpm_object = rpm_object;
while (rpm_object) { while (rpm_object) {
rpm_property = rpm_object->listOfProperties; rpm_property = rpm_object->listOfProperties;
while (rpm_property) { while (rpm_property) {
old_rpm_property = rpm_property; old_rpm_property = rpm_property;
rpm_property = rpm_property->next; rpm_property = rpm_property->next;
free(old_rpm_property); free(old_rpm_property);
} old_rpm_object = rpm_object; }
old_rpm_object = rpm_object;
rpm_object = rpm_object->next; rpm_object = rpm_object->next;
free(old_rpm_object); free(old_rpm_object);
} }
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0; unsigned max_apdu = 0;
@@ -165,7 +172,8 @@ int main(int argc, char *argv[]) {
uint8_t invoke_id = 0; uint8_t invoke_id = 0;
bool found = false; bool found = false;
uint8_t buffer[MAX_PDU] = { uint8_t buffer[MAX_PDU] = {
0}; 0
};
BACNET_READ_ACCESS_DATA *rpm_object; BACNET_READ_ACCESS_DATA *rpm_object;
BACNET_PROPERTY_REFERENCE *rpm_property; 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); apdu_set_reject_handler(MyRejectHandler);
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
unsigned max_apdu = 0; unsigned max_apdu = 0;
bacnet-stack/demo/server/main.c
+6 -2
View File
@@ -98,9 +98,13 @@ static void cleanup(
datalink_cleanup(); datalink_cleanup();
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 1000; /* milliseconds */ unsigned timeout = 1000; /* milliseconds */
time_t last_seconds = 0; 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); apdu_set_reject_handler(MyRejectHandler);
} }
int main(int argc, char *argv[]) { int main(
int argc,
char *argv[])
{
BACNET_ADDRESS src = { BACNET_ADDRESS src = {
0}; /* address where message came from */ 0
}; /* address where message came from */
uint16_t pdu_len = 0; uint16_t pdu_len = 0;
unsigned timeout = 100; /* milliseconds */ unsigned timeout = 100; /* milliseconds */
time_t elapsed_seconds = 0; 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])); filename_remove_path(argv[0]), filename_remove_path(argv[0]));
return 0; return 0;
} }
/* decode the command line parameters */ cov_data. /* decode the command line parameters */
subscriberProcessIdentifier = strtol(argv[1], NULL, 0); cov_data.subscriberProcessIdentifier = strtol(argv[1], NULL, 0);
cov_data.initiatingDeviceIdentifier = strtol(argv[2], NULL, 0); cov_data.initiatingDeviceIdentifier = strtol(argv[2], NULL, 0);
cov_data.monitoredObjectIdentifier.type = strtol(argv[3], NULL, 0); cov_data.monitoredObjectIdentifier.type = strtol(argv[3], NULL, 0);
cov_data.monitoredObjectIdentifier.instance = strtol(argv[4], 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) #if defined(BACDL_MSTP)
apdu_timeout_set(60000); apdu_timeout_set(60000);
#endif #endif
} }
if (!datalink_init(getenv("BACNET_IFACE"))) { if (!datalink_init(getenv("BACNET_IFACE"))) {
exit(1); exit(1);
} }
bacnet-stack/include/alarm_ack.h
+89 -92
View File
@@ -1,92 +1,89 @@
/*####COPYRIGHTBEGIN#### /*####COPYRIGHTBEGIN####
------------------------------------------- -------------------------------------------
Copyright (C) 2009 John Minack Copyright (C) 2009 John Minack
This program is free software; you can redistribute it and/or This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2 as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version. of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to: along with this program; if not, write to:
The Free Software Foundation, Inc. The Free Software Foundation, Inc.
59 Temple Place - Suite 330 59 Temple Place - Suite 330
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
As a special exception, if other files instantiate templates or As a special exception, if other files instantiate templates or
use macros or inline functions from this file, or you compile use macros or inline functions from this file, or you compile
this file and link it with other works to produce a work based 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 on this file, this file does not by itself cause the resulting
work to be covered by the GNU General Public License. However work to be covered by the GNU General Public License. However
the source code for this file must still be made available in the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License. accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public based on this file might be covered by the GNU General Public
License. License.
------------------------------------------- -------------------------------------------
####COPYRIGHTEND####*/ ####COPYRIGHTEND####*/
#ifndef ALARM_ACK_H_ #ifndef ALARM_ACK_H_
#define ALARM_ACK_H_ #define ALARM_ACK_H_
#include "bacenum.h" #include "bacenum.h"
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include "bacapp.h" #include "bacapp.h"
#include "timestamp.h" #include "timestamp.h"
typedef struct { typedef struct {
uint32_t ackProcessIdentifier; uint32_t ackProcessIdentifier;
BACNET_OBJECT_ID eventObjectIdentifier; BACNET_OBJECT_ID eventObjectIdentifier;
BACNET_EVENT_TYPE eventTypeAcked; BACNET_EVENT_TYPE eventTypeAcked;
BACNET_TIMESTAMP eventTimeStamp; BACNET_TIMESTAMP eventTimeStamp;
BACNET_CHARACTER_STRING ackSource; BACNET_CHARACTER_STRING ackSource;
BACNET_TIMESTAMP ackTimeStamp; BACNET_TIMESTAMP ackTimeStamp;
} BACNET_ALARM_ACK_DATA; } BACNET_ALARM_ACK_DATA;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/*************************************************** /***************************************************
** **
** Creates a Alarm Acknowledge APDU ** Creates a Alarm Acknowledge APDU
** **
****************************************************/ ****************************************************/
int alarm_ack_encode_apdu( int alarm_ack_encode_apdu(
uint8_t * apdu, uint8_t * apdu,
uint8_t invoke_id, uint8_t invoke_id,
BACNET_ALARM_ACK_DATA * data); BACNET_ALARM_ACK_DATA * data);
/*************************************************** /***************************************************
** **
** Encodes the service data part of Alarm Acknowledge ** Encodes the service data part of Alarm Acknowledge
** **
****************************************************/ ****************************************************/
int alarm_ack_encode_service_request( int alarm_ack_encode_service_request(
uint8_t * apdu, uint8_t * apdu,
BACNET_ALARM_ACK_DATA * data); BACNET_ALARM_ACK_DATA * data);
/*************************************************** /***************************************************
** **
** Decodes the service data part of Alarm Acknowledge ** Decodes the service data part of Alarm Acknowledge
** **
****************************************************/ ****************************************************/
int alarm_ack_decode_service_request( int alarm_ack_decode_service_request(
uint8_t * apdu, uint8_t * apdu,
unsigned apdu_len, unsigned apdu_len,
BACNET_ALARM_ACK_DATA * data); BACNET_ALARM_ACK_DATA * data);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif /* ALARM_ACK_H_ */ #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( void Send_Initialize_Routing_Table_Ack(
BACNET_ROUTER_PORT * router_port_list); BACNET_ROUTER_PORT * router_port_list);
uint8_t Send_Life_Safety_Operation_Data( uint8_t Send_Life_Safety_Operation_Data(
uint32_t device_id, uint32_t device_id,
BACNET_LSO_DATA *data); BACNET_LSO_DATA * data);
uint8_t Send_Alarm_Acknowledgement( uint8_t Send_Alarm_Acknowledgement(
uint32_t device_id, uint32_t device_id,
BACNET_ALARM_ACK_DATA *data); 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> * Copyright (C) 2009 Steve Karg <skarg@users.sourceforge.net>
* *
* Permission is hereby granted, free of charge, to any person obtaining * Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the * a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including * "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish, * without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to * distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to * permit persons to whom the Software is furnished to do so, subject to
* the following conditions: * the following conditions:
* *
* The above copyright notice and this permission notice shall be included * The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software. * in all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* *
*********************************************************************/ *********************************************************************/
#ifndef DLENV_H #ifndef DLENV_H
#define DLENV_H #define DLENV_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
void dlenv_init( void dlenv_init(
void); void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */
#endif #endif
bacnet-stack/include/handlers.h
+5 -5
View File
@@ -176,11 +176,11 @@ extern "C" {
BACNET_ADDRESS * src, BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data); BACNET_CONFIRMED_SERVICE_DATA * service_data);
void handler_alarm_ack( void handler_alarm_ack(
uint8_t * service_request, uint8_t * service_request,
uint16_t service_len, uint16_t service_len,
BACNET_ADDRESS * src, BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_DATA * service_data); BACNET_CONFIRMED_SERVICE_DATA * service_data);
#ifdef __cplusplus #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. */ _SET_LOCK_BITS(recchar()); /* Read and set lock bits. */
sendchar('\r'); /* Send OK back. */ sendchar('\r'); /* Send OK back. */
} }
#if defined(_GET_LOCK_BITS) #if defined(_GET_LOCK_BITS)
/* Read lock bits. */ /* Read lock bits. */
else if (val == 'r') { else if (val == 'r') {
bacnet-stack/src/alarm_ack.c
+275 -233
View File
@@ -1,233 +1,275 @@
/*####COPYRIGHTBEGIN#### /*####COPYRIGHTBEGIN####
------------------------------------------- -------------------------------------------
Copyright (C) 2009 John Minack Copyright (C) 2009 John Minack
This program is free software; you can redistribute it and/or This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2 as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version. of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to: along with this program; if not, write to:
The Free Software Foundation, Inc. The Free Software Foundation, Inc.
59 Temple Place - Suite 330 59 Temple Place - Suite 330
Boston, MA 02111-1307, USA. Boston, MA 02111-1307, USA.
As a special exception, if other files instantiate templates or As a special exception, if other files instantiate templates or
use macros or inline functions from this file, or you compile use macros or inline functions from this file, or you compile
this file and link it with other works to produce a work based 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 on this file, this file does not by itself cause the resulting
work to be covered by the GNU General Public License. However work to be covered by the GNU General Public License. However
the source code for this file must still be made available in the source code for this file must still be made available in
accordance with section (3) of the GNU General Public License. accordance with section (3) of the GNU General Public License.
This exception does not invalidate any other reasons why a work This exception does not invalidate any other reasons why a work
based on this file might be covered by the GNU General Public based on this file might be covered by the GNU General Public
License. License.
------------------------------------------- -------------------------------------------
####COPYRIGHTEND####*/ ####COPYRIGHTEND####*/
#include "alarm_ack.h" #include "alarm_ack.h"
/*************************************************** /***************************************************
** **
** Creates an Unconfirmed Event Notification APDU ** Creates an Unconfirmed Event Notification APDU
** **
****************************************************/ ****************************************************/
int alarm_ack_encode_apdu( int alarm_ack_encode_apdu(
uint8_t * apdu, uint8_t * apdu,
uint8_t invoke_id, uint8_t invoke_id,
BACNET_ALARM_ACK_DATA * data) BACNET_ALARM_ACK_DATA * data)
{ {
int len = 0; /* length of each encoding */ int len = 0; /* length of each encoding */
int apdu_len = 0; /* total length of the apdu, return value */ int apdu_len = 0; /* total length of the apdu, return value */
if (apdu) { if (apdu) {
apdu[0] = PDU_TYPE_CONFIRMED_SERVICE_REQUEST; apdu[0] = PDU_TYPE_CONFIRMED_SERVICE_REQUEST;
apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU); apdu[1] = encode_max_segs_max_apdu(0, MAX_APDU);
apdu[2] = invoke_id; apdu[2] = invoke_id;
apdu[3] = SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM; /* service choice */ apdu[3] = SERVICE_CONFIRMED_ACKNOWLEDGE_ALARM; /* service choice */
apdu_len = 4; apdu_len = 4;
len = alarm_ack_encode_service_request(&apdu[apdu_len], data); len = alarm_ack_encode_service_request(&apdu[apdu_len], data);
apdu_len += len; apdu_len += len;
} }
return apdu_len; return apdu_len;
} }
/*************************************************** /***************************************************
** **
** Encodes the service data part of Event Notification ** Encodes the service data part of Event Notification
** **
****************************************************/ ****************************************************/
int alarm_ack_encode_service_request( int alarm_ack_encode_service_request(
uint8_t * apdu, uint8_t * apdu,
BACNET_ALARM_ACK_DATA * data) BACNET_ALARM_ACK_DATA * data)
{ {
int len = 0; /* length of each encoding */ int len = 0; /* length of each encoding */
int apdu_len = 0; /* total length of the apdu, return value */ int apdu_len = 0; /* total length of the apdu, return value */
if (apdu) { if (apdu) {
len = encode_context_unsigned(&apdu[apdu_len], 0, data->ackProcessIdentifier); len =
apdu_len += len; encode_context_unsigned(&apdu[apdu_len], 0,
data->ackProcessIdentifier);
len = encode_context_object_id(&apdu[apdu_len], 1, data->eventObjectIdentifier.type, data->eventObjectIdentifier.instance); apdu_len += len;
apdu_len += len;
len =
len = encode_context_enumerated(&apdu[apdu_len], 2, data->eventTypeAcked); encode_context_object_id(&apdu[apdu_len], 1,
apdu_len += len; data->eventObjectIdentifier.type,
data->eventObjectIdentifier.instance);
len = bacapp_encode_context_timestamp(&apdu[apdu_len], 3, &data->eventTimeStamp); apdu_len += len;
apdu_len += len;
len =
len = encode_context_character_string(&apdu[apdu_len], 4, &data->ackSource); encode_context_enumerated(&apdu[apdu_len], 2,
apdu_len += len; data->eventTypeAcked);
apdu_len += len;
len = bacapp_encode_context_timestamp(&apdu[apdu_len], 5, &data->ackTimeStamp);
apdu_len += len; len =
} bacapp_encode_context_timestamp(&apdu[apdu_len], 3,
&data->eventTimeStamp);
return apdu_len; apdu_len += len;
}
len =
encode_context_character_string(&apdu[apdu_len], 4,
/*************************************************** &data->ackSource);
** apdu_len += len;
** Decodes the service data part of Event Notification
** len =
****************************************************/ bacapp_encode_context_timestamp(&apdu[apdu_len], 5,
int alarm_ack_decode_service_request( &data->ackTimeStamp);
uint8_t * apdu, apdu_len += len;
unsigned apdu_len, }
BACNET_ALARM_ACK_DATA * data)
{ return apdu_len;
int len = 0; }
int section_len;
if (-1 == (section_len = /***************************************************
decode_context_unsigned(&apdu[len], 0, &data->ackProcessIdentifier))) { **
return -1; ** Decodes the service data part of Event Notification
} **
len += section_len; ****************************************************/
int alarm_ack_decode_service_request(
if (-1 == (section_len = uint8_t * apdu,
decode_context_object_id(&apdu[len], 1, &data->eventObjectIdentifier.type, &data->eventObjectIdentifier.instance))) { unsigned apdu_len,
return -1; BACNET_ALARM_ACK_DATA * data)
} {
len += section_len; int len = 0;
int section_len;
if (-1 == (section_len =
decode_context_enumerated(&apdu[len], 2, (int*)&data->eventTypeAcked))) { if (-1 == (section_len =
return -1; decode_context_unsigned(&apdu[len], 0,
} &data->ackProcessIdentifier))) {
len += section_len; return -1;
}
if (-1 == (section_len = len += section_len;
bacapp_decode_context_timestamp(&apdu[len], 3, &data->eventTimeStamp))) {
return -1; if (-1 == (section_len =
} decode_context_object_id(&apdu[len], 1,
len += section_len; &data->eventObjectIdentifier.type,
&data->eventObjectIdentifier.instance))) {
if (-1 == (section_len = return -1;
decode_context_character_string(&apdu[len], 4, &data->ackSource))) { }
return -1; len += section_len;
}
len += section_len; if (-1 == (section_len =
decode_context_enumerated(&apdu[len], 2,
if (-1 == (section_len = (int *) &data->eventTypeAcked))) {
bacapp_decode_context_timestamp(&apdu[len], 5, &data->ackTimeStamp))) { return -1;
return -1; }
} len += section_len;
len += section_len;
if (-1 == (section_len =
return len; bacapp_decode_context_timestamp(&apdu[len], 3,
} &data->eventTimeStamp))) {
return -1;
#ifdef TEST }
len += section_len;
#include <assert.h>
#include <string.h> if (-1 == (section_len =
#include "ctest.h" decode_context_character_string(&apdu[len], 4,
&data->ackSource))) {
return -1;
void testAlarmAck( }
Test * pTest) len += section_len;
{
BACNET_ALARM_ACK_DATA testAlarmAckIn; if (-1 == (section_len =
BACNET_ALARM_ACK_DATA testAlarmAckOut; bacapp_decode_context_timestamp(&apdu[len], 5,
&data->ackTimeStamp))) {
uint8_t buffer[MAX_APDU]; return -1;
int inLen; }
int outLen; len += section_len;
testAlarmAckIn.ackProcessIdentifier = 0x1234; return len;
characterstring_init_ansi(&testAlarmAckIn.ackSource, "This is a test"); }
testAlarmAckIn.ackTimeStamp.tag = TIME_STAMP_SEQUENCE;
testAlarmAckIn.ackTimeStamp.value.sequenceNum = 0x4331; #ifdef TEST
testAlarmAckIn.eventObjectIdentifier.instance = 567;
testAlarmAckIn.eventObjectIdentifier.type = OBJECT_DEVICE; #include <assert.h>
testAlarmAckIn.eventTimeStamp.tag = TIME_STAMP_TIME; #include <string.h>
testAlarmAckIn.eventTimeStamp.value.time.hour = 10; #include "ctest.h"
testAlarmAckIn.eventTimeStamp.value.time.min = 11;
testAlarmAckIn.eventTimeStamp.value.time.sec = 12;
testAlarmAckIn.eventTimeStamp.value.time.hundredths = 14; void testAlarmAck(
testAlarmAckIn.eventTypeAcked = EVENT_CHANGE_OF_LIFE_SAFETY; Test * pTest)
{
memset(&testAlarmAckOut, 0, sizeof(testAlarmAckOut)); BACNET_ALARM_ACK_DATA testAlarmAckIn;
BACNET_ALARM_ACK_DATA testAlarmAckOut;
inLen = alarm_ack_encode_service_request(buffer, &testAlarmAckIn); uint8_t buffer[MAX_APDU];
outLen = alarm_ack_decode_service_request(buffer, inLen, &testAlarmAckOut); int inLen;
int outLen;
ct_test(pTest, inLen == outLen);
testAlarmAckIn.ackProcessIdentifier = 0x1234;
ct_test(pTest, testAlarmAckIn.ackProcessIdentifier == testAlarmAckOut.ackProcessIdentifier); characterstring_init_ansi(&testAlarmAckIn.ackSource, "This is a test");
testAlarmAckIn.ackTimeStamp.tag = TIME_STAMP_SEQUENCE;
ct_test(pTest, testAlarmAckIn.ackTimeStamp.tag == testAlarmAckOut.ackTimeStamp.tag); testAlarmAckIn.ackTimeStamp.value.sequenceNum = 0x4331;
ct_test(pTest, testAlarmAckIn.ackTimeStamp.value.sequenceNum == testAlarmAckOut.ackTimeStamp.value.sequenceNum); testAlarmAckIn.eventObjectIdentifier.instance = 567;
testAlarmAckIn.eventObjectIdentifier.type = OBJECT_DEVICE;
ct_test(pTest, testAlarmAckIn.ackProcessIdentifier == testAlarmAckOut.ackProcessIdentifier); testAlarmAckIn.eventTimeStamp.tag = TIME_STAMP_TIME;
testAlarmAckIn.eventTimeStamp.value.time.hour = 10;
ct_test(pTest, testAlarmAckIn.eventObjectIdentifier.instance == testAlarmAckOut.eventObjectIdentifier.instance); testAlarmAckIn.eventTimeStamp.value.time.min = 11;
ct_test(pTest, testAlarmAckIn.eventObjectIdentifier.type == testAlarmAckOut.eventObjectIdentifier.type); testAlarmAckIn.eventTimeStamp.value.time.sec = 12;
testAlarmAckIn.eventTimeStamp.value.time.hundredths = 14;
ct_test(pTest, testAlarmAckIn.eventTimeStamp.tag == testAlarmAckOut.eventTimeStamp.tag); testAlarmAckIn.eventTypeAcked = EVENT_CHANGE_OF_LIFE_SAFETY;
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); memset(&testAlarmAckOut, 0, sizeof(testAlarmAckOut));
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);
inLen = alarm_ack_encode_service_request(buffer, &testAlarmAckIn);
ct_test(pTest, testAlarmAckIn.eventTypeAcked == testAlarmAckOut.eventTypeAcked); outLen = alarm_ack_decode_service_request(buffer, inLen, &testAlarmAckOut);
} ct_test(pTest, inLen == outLen);
ct_test(pTest,
#ifdef TEST_ALARM_ACK testAlarmAckIn.ackProcessIdentifier ==
int main( testAlarmAckOut.ackProcessIdentifier);
void)
{ ct_test(pTest,
Test *pTest; testAlarmAckIn.ackTimeStamp.tag == testAlarmAckOut.ackTimeStamp.tag);
bool rc; ct_test(pTest,
testAlarmAckIn.ackTimeStamp.value.sequenceNum ==
pTest = ct_create("BACnet Alarm Ack", NULL); testAlarmAckOut.ackTimeStamp.value.sequenceNum);
/* individual tests */
rc = ct_addTestFunction(pTest, testAlarmAck); ct_test(pTest,
assert(rc); testAlarmAckIn.ackProcessIdentifier ==
testAlarmAckOut.ackProcessIdentifier);
ct_setStream(pTest, stdout);
ct_run(pTest); ct_test(pTest,
(void) ct_report(pTest); testAlarmAckIn.eventObjectIdentifier.instance ==
ct_destroy(pTest); testAlarmAckOut.eventObjectIdentifier.instance);
ct_test(pTest,
return 0; testAlarmAckIn.eventObjectIdentifier.type ==
} testAlarmAckOut.eventObjectIdentifier.type);
#endif /* TEST_ALARM_ACK */ ct_test(pTest,
#endif /* TEST */ 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 */