Issue 2 move folders and use deep path include file names to prevent collisions (#4)

* moving folders and files and adjust server demo build * Fix Makefile for apps/server on Linux * fix unit test source file folders * fix datetime convert UTC functions. Add Code::Blocks project for datetime testing * added some ignore extensions * disable parallel make option * fix build for abort, dcc, and epics apps * fix build for dcc, epics, error, and getevent apps. * Fixed building of all apps * fix the ipv4 to ipv6 router app build * Change indent style from Google to Webkit * make pretty to re-format style * removed common Makefile since we already had one and two was too many * remove scripts from root folder that are no longer maintained or used * remove mercurial EOL and ignore files for git repo * remove .vscodeconfig files from repo * tweak clang-format style * clang-format src and apps with tweaked style * added clang-tidy to fix readability if braces in src * result of make tidy for src and apps * fix clang-tidy mangling * Added code::blocks project for BACnet server simulation * added code::blocks linux project for WhoIs app * update text files for EOL * fix EOL in some files * fixed make win32 apps for older gcc * Removed Borland C++ Makefile in apps. Unable to maintain support for Borland C++ compiler. * created codeblocks project for apps/epics for Windows * fixing ports/xplained to work with new data structure. * fix ports/xplained example for Atmel Studio compile * fix ports/stm32f10x example for gcc Makefile compile * fix ports/stm32f10x example for IAR EWARM compile * fix ports/xplained timer callback * fix ports/bdk_atxx_mspt build with subdirs * fix ports/bdk_atxx_mspt build with subdirs * updated git ignore for IAR build artifacts * updated gitignore for non-tracked files and folders * fixed bdk-atxx4-mstp port for Rowley Crossworks project file * fixed bdk-atxx4-mstp port for GCC AVR Makefile * fixed atmega168 port for IAR AVR and GCC AVR Makefile * fixed at91sam7s port for IAR ARM and GCC ARM Makefile * removed unmaintainable DOS, RTOS32, and atmega8 ports. Updated rx62n (untested). * changed arm7 to uip port
2019-12-13 15:19:10 -06:00
parent 8a38dbe2cf
commit d50c190957
912 changed files with 36206 additions and 52502 deletions
@@ -0,0 +1,358 @@
+/*####COPYRIGHTBEGIN####
+ -------------------------------------------
+ Copyright (C) 2013 Steve Karg <skarg@users.sourceforge.net>
+
+ 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 <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "bacnet/lighting.h"
+#include "bacnet/bacdcode.h"
+
+/** @file lighting.c  Manipulate BACnet lighting command values */
+
+/**
+ * Encodes into bytes from the lighting-command structure
+ *
+ * @param apdu - buffer to hold the bytes
+ * @param value - lighting command value to encode
+ *
+ * @return  number of bytes encoded, or 0 if unable to encode.
+ */
+int lighting_command_encode(uint8_t *apdu, BACNET_LIGHTING_COMMAND *data)
+{
+    int apdu_len = 0; /* total length of the apdu, return value */
+    int len = 0; /* total length of the apdu, return value */
+
+    if (apdu) {
+        len = encode_context_enumerated(&apdu[apdu_len], 0, data->operation);
+        apdu_len += len;
+        /* optional target-level */
+        if (data->use_target_level) {
+            len = encode_context_real(&apdu[apdu_len], 1, data->target_level);
+            apdu_len += len;
+        }
+        /* optional ramp-rate */
+        if (data->use_ramp_rate) {
+            len = encode_context_real(&apdu[apdu_len], 2, data->ramp_rate);
+            apdu_len += len;
+        }
+        /* optional step increment */
+        if (data->use_step_increment) {
+            len = encode_context_real(&apdu[apdu_len], 3, data->step_increment);
+            apdu_len += len;
+        }
+        /* optional fade time */
+        if (data->use_fade_time) {
+            len = encode_context_unsigned(&apdu[apdu_len], 4, data->fade_time);
+            apdu_len += len;
+        }
+        /* optional priority */
+        if (data->use_priority) {
+            len = encode_context_unsigned(&apdu[apdu_len], 5, data->priority);
+            apdu_len += len;
+        }
+    }
+
+    return apdu_len;
+}
+
+/**
+ * Encodes into bytes from the lighting-command structure
+ * a context tagged chunk (opening and closing tag)
+ *
+ * @param apdu - buffer to hold the bytes
+ * @param tag_number - tag number to encode this chunk
+ * @param value - lighting command value to encode
+ *
+ * @return  number of bytes encoded, or 0 if unable to encode.
+ */
+int lighting_command_encode_context(
+    uint8_t *apdu, uint8_t tag_number, BACNET_LIGHTING_COMMAND *value)
+{
+    int apdu_len = 0;
+
+    apdu_len += encode_opening_tag(&apdu[apdu_len], tag_number);
+    apdu_len += lighting_command_encode(&apdu[apdu_len], value);
+    apdu_len += encode_closing_tag(&apdu[apdu_len], tag_number);
+
+    return apdu_len;
+}
+
+/**
+ * Decodes from bytes into the lighting-command structure
+ *
+ * @param apdu - buffer to hold the bytes
+ * @param apdu_max_len - number of bytes in the buffer to decode
+ * @param value - lighting command value to place the decoded values
+ *
+ * @return  number of bytes encoded
+ */
+int lighting_command_decode(
+    uint8_t *apdu, unsigned apdu_max_len, BACNET_LIGHTING_COMMAND *data)
+{
+    int len = 0;
+    int apdu_len = 0;
+    uint8_t tag_number = 0;
+    uint32_t len_value_type = 0;
+    uint32_t unsigned_value = 0;
+    float real_value = 0.0;
+
+    apdu_max_len = apdu_max_len;
+    /* check for value pointers */
+    if (apdu_max_len && data) {
+        /* Tag 0: operation */
+        if (!decode_is_context_tag(&apdu[apdu_len], 0)) {
+            return BACNET_STATUS_ERROR;
+        }
+        len = decode_tag_number_and_value(
+            &apdu[apdu_len], &tag_number, &len_value_type);
+        apdu_len += len;
+        len =
+            decode_enumerated(&apdu[apdu_len], len_value_type, &unsigned_value);
+        if (len > 0) {
+            data->operation = unsigned_value;
+        }
+        apdu_len += len;
+        /* Tag 1: target-level - OPTIONAL */
+        if (decode_is_context_tag(&apdu[apdu_len], 1)) {
+            len = decode_tag_number_and_value(
+                &apdu[apdu_len], &tag_number, &len_value_type);
+            apdu_len += len;
+            len = decode_real(&apdu[apdu_len], &real_value);
+            data->target_level = real_value;
+            apdu_len += len;
+            data->use_target_level = true;
+        } else {
+            data->use_target_level = false;
+        }
+        /* Tag 2: ramp-rate - OPTIONAL */
+        if (decode_is_context_tag(&apdu[apdu_len], 2)) {
+            len = decode_tag_number_and_value(
+                &apdu[apdu_len], &tag_number, &len_value_type);
+            apdu_len += len;
+            len = decode_real(&apdu[apdu_len], &real_value);
+            data->ramp_rate = real_value;
+            data->use_ramp_rate = true;
+        } else {
+            data->use_ramp_rate = false;
+        }
+        /* Tag 3: step-increment - OPTIONAL */
+        if (decode_is_context_tag(&apdu[apdu_len], 3)) {
+            len = decode_tag_number_and_value(
+                &apdu[apdu_len], &tag_number, &len_value_type);
+            apdu_len += len;
+            len = decode_real(&apdu[apdu_len], &real_value);
+            data->step_increment = real_value;
+            data->use_step_increment = true;
+        } else {
+            data->use_step_increment = false;
+        }
+        /* Tag 4: fade-time - OPTIONAL */
+        if (decode_is_context_tag(&apdu[apdu_len], 4)) {
+            len = decode_tag_number_and_value(
+                &apdu[apdu_len], &tag_number, &len_value_type);
+            apdu_len += len;
+            len = decode_unsigned(
+                &apdu[apdu_len], len_value_type, &unsigned_value);
+            data->fade_time = unsigned_value;
+            data->use_fade_time = true;
+        } else {
+            data->use_fade_time = false;
+        }
+        /* Tag 5: priority - OPTIONAL */
+        if (decode_is_context_tag(&apdu[apdu_len], 4)) {
+            len = decode_tag_number_and_value(
+                &apdu[apdu_len], &tag_number, &len_value_type);
+            apdu_len += len;
+            len = decode_unsigned(
+                &apdu[apdu_len], len_value_type, &unsigned_value);
+            data->priority = unsigned_value;
+            data->use_priority = true;
+        } else {
+            data->use_priority = false;
+        }
+    }
+
+    return len;
+}
+
+/**
+ * Copies one lighting-command structure to another
+ *
+ * @param dst - lighting command value target
+ * @param src - lighting command value source
+ *
+ * @return  true if copy succeeded
+ */
+bool lighting_command_copy(
+    BACNET_LIGHTING_COMMAND *dst, BACNET_LIGHTING_COMMAND *src)
+{
+    bool status = false;
+
+    if (dst && src) {
+        dst->operation = src->operation;
+        dst->use_target_level = src->use_target_level;
+        dst->use_ramp_rate = src->use_ramp_rate;
+        dst->use_step_increment = src->use_step_increment;
+        dst->use_fade_time = src->use_fade_time;
+        dst->use_priority = src->use_priority;
+        dst->target_level = src->target_level;
+        dst->ramp_rate = src->ramp_rate;
+        dst->step_increment = src->step_increment;
+        dst->fade_time = src->fade_time;
+        dst->priority = src->priority;
+        status = true;
+    }
+
+    return status;
+}
+
+/**
+ * Compare one lighting-command structure to another
+ *
+ * @param dst - lighting command value target
+ * @param src - lighting command value source
+ *
+ * @return  true if lighting-commands are the same for values in-use
+ */
+bool lighting_command_same(
+    BACNET_LIGHTING_COMMAND *dst, BACNET_LIGHTING_COMMAND *src)
+{
+    bool status = false;
+
+    if (dst && src) {
+        if ((dst->operation == src->operation) &&
+            (dst->use_target_level == src->use_target_level) &&
+            (dst->use_ramp_rate == src->use_ramp_rate) &&
+            (dst->use_step_increment == src->use_step_increment) &&
+            (dst->use_fade_time == src->use_fade_time) &&
+            (dst->use_priority == src->use_priority)) {
+            status = true;
+            if ((dst->use_target_level) &&
+                (dst->target_level != src->target_level)) {
+                status = false;
+            }
+            if ((dst->use_ramp_rate) && (dst->ramp_rate != src->ramp_rate)) {
+                status = false;
+            }
+            if ((dst->use_step_increment) &&
+                (dst->step_increment != src->step_increment)) {
+                status = false;
+            }
+            if ((dst->use_fade_time) && (dst->fade_time != src->fade_time)) {
+                status = false;
+            }
+            if ((dst->use_priority) && (dst->priority != src->priority)) {
+                status = false;
+            }
+        }
+    }
+
+    return status;
+}
+
+#ifdef TEST
+#include <assert.h>
+#include <string.h>
+#include "ctest.h"
+
+void testBACnetLightingCommand(Test *pTest, BACNET_LIGHTING_COMMAND *data)
+{
+    bool status = false;
+    BACNET_LIGHTING_COMMAND test_data;
+    int len, apdu_len;
+    uint8_t apdu[MAX_APDU] = { 0 };
+
+    status = lighting_command_copy(&test_data, NULL);
+    ct_test(pTest, status == false);
+    status = lighting_command_copy(NULL, data);
+    ct_test(pTest, status == false);
+    status = lighting_command_copy(&test_data, data);
+    ct_test(pTest, status == true);
+    status = lighting_command_same(&test_data, data);
+    ct_test(pTest, status == true);
+    len = lighting_command_encode(apdu, data);
+    apdu_len = lighting_command_decode(apdu, sizeof(apdu), &test_data);
+    ct_test(pTest, len > 0);
+    ct_test(pTest, apdu_len > 0);
+    status = lighting_command_same(&test_data, data);
+}
+
+void testBACnetLightingCommandAll(Test *pTest)
+{
+    BACNET_LIGHTING_COMMAND data;
+
+    data.operation = BACNET_LIGHTS_NONE;
+    data.use_target_level = false;
+    data.use_ramp_rate = false;
+    data.use_step_increment = false;
+    data.use_fade_time = false;
+    data.use_priority = false;
+    data.target_level = 0.0;
+    data.ramp_rate = 100.0;
+    data.step_increment = 1.0;
+    data.fade_time = 100;
+    data.priority = 1;
+    testBACnetLightingCommand(pTest, &data);
+    data.operation = BACNET_LIGHTS_STOP;
+    data.use_target_level = true;
+    data.use_ramp_rate = true;
+    data.use_step_increment = true;
+    data.use_fade_time = true;
+    data.use_priority = true;
+    testBACnetLightingCommand(pTest, &data);
+}
+
+#ifdef TEST_LIGHTING_COMMAND
+int main(void)
+{
+    Test *pTest;
+    bool rc;
+
+    pTest = ct_create("BACnet Lighting Command", NULL);
+    /* individual tests */
+    rc = ct_addTestFunction(pTest, testBACnetLightingCommandAll);
+    assert(rc);
+
+    ct_setStream(pTest, stdout);
+    ct_run(pTest);
+    (void)ct_report(pTest);
+    ct_destroy(pTest);
+
+    return 0;
+}
+
+#endif
+#endif /* TEST */