main.cpp

// SPDX-License-Identifier: CC0-1.0
// Public-domain example code (CC0) - see LICENSE. The CAS BACnet Stack itself is
// a separate, commercially licensed product and is not covered by CC0.
// =============================================================================
// BACnet Profile Example - B-RTR (BACnet Router) - C++
//
// This example implements the BACnet "B-RTR" (Router) device profile with the
// CAS BACnet Stack. It is the B-ASC (Application Specific Controller) example
// minus DeviceCommunicationControl, plus TWO BACnet/IP Network Port objects on
// two different BACnet networks, and it forwards NPDUs between them (ANSI/ASHRAE
// 135-2024 cl. 6.5 / 6.6, Annex L.7.1). tests/routing_test.py proves it: a
// ReadProperty sent from network 1 to a device on network 2 crosses the
// router, and the ComplexACK comes back with SNET = 2.
//
// A B-RTR is a stand-alone BACnet router: a device that forwards NPDUs between
// two (or more) directly-connected BACnet networks and answers the network-layer
// messages that let other devices discover and use it as a router:
//
//     DS-RP-B    - respond to ReadProperty requests,
//     DS-WP-B    - allow other devices to WriteProperty its objects,
//     DM-DDB-B   - answer Who-Is with I-Am,
//     DM-DOB-B   - answer Who-Has,
//     DM-LM-B    - execute AddListElement / RemoveListElement, here on a Group
//                  object's List_Of_Group_Members,
//     NM-RC-B    - Network Management - Router Configuration: forward NPDUs
//                  between the ports, answer Who-Is-Router-To-Network with
//                  I-Am-Router-To-Network, reject a message for a network it
//                  cannot reach (Reject-Message-To-Network), and announce
//                  I-Am-Router-To-Network / Network-Number-Is at start-up.
//
// TODO.md lists the remaining gaps - all in the stack or in common/, none in the
// unicast forwarding path.
//
// The device keeps the same base objects as B-ASC/B-SA - three read-only sensor
// inputs and three commandable outputs a client drives with WriteProperty - PLUS
// a Group object for DM-LM-B and a SECOND Network Port object, one per side of
// the router:
//
//     Device 389018            "Chipkin Example B-RTR"      (instance configurable with --deviceID)
//     Analog Input  1          "Bronze"       (REAL, degrees Celsius; read-only)
//     Binary Input  1          "Emerald"      (active / inactive; read-only)
//     Multi-State Input 1      "Hot Pink"     (state 1..3; read-only)
//     Analog Output 1          "Chartreuse"   (REAL setpoint; WRITABLE, commandable)
//     Binary Output 1          "Fuchsia"      (active / inactive; WRITABLE, commandable)
//     Multi-State Output 1     "Indigo"       (state 1..3; WRITABLE, commandable)
//     Group 1                  "Olive"        (List_Of_Group_Members edited by
//                                              AddListElement/RemoveListElement)
//     Network Port 1           "Vermilion"    (BACnet/IP port A - network 1)
//     Network Port 2           "Vermilion 2"  (BACnet/IP port B - network 2)
//
// F-MULTIPORT: the two Network Ports each own their own UDP socket, via the
// common/ 2.3.0+ multi-port SetupUDP(port, networkPortInstance) /
// SendIAm(deviceInstance, networkPortInstance) overloads - see
// common/CASExampleHelper.h/.cpp for how the shared transport callbacks
// dispatch on networkPortInstance. This is the FIRST example in the series to
// use more than one Network Port; everything below is written to be a clear
// pattern for a later multi-port example (e.g. B-GW) to copy.
//
// F-ROUTER: BACnetStack_AddRouterPort registers each Network Port's directly
// connected network with the stack's router logic; BACnetStack_SetRouterEnabled
// turns forwarding on. A third, ONE-HOP-AWAY network is configured with
// BACnetStack_AddRouterRoute purely to demonstrate that API - see the
// DEMO_REMOTE_NETWORK comment below for what is and is not verified about it.
//
// Output objects are COMMANDABLE: their Present_Value is driven by a 16-slot
// BACnet Priority_Array, exactly as in B-SA/B-ASC. See GetCommandable() etc.
// below - this part is unchanged from B-ASC.
//
// To be a conformant BACnet device (Protocol_Revision 30) each object must
// expose its full set of REQUIRED properties. Most are generated by the stack
// (Object_Identifier, Object_Type, Status_Flags, Object_List, Protocol_*). A
// Network Port additionally gets Network_Number, Network_Number_Quality,
// BACnet_IP_Mode and MAC_Address from the stack once AddNetworkPortObject is
// called with the right arguments - see the callbacks below for the handful
// this application still has to supply (IP_Address, IP_Subnet_Mask, ...).
//
// Interactive keys (handled by the shared helper): h = help, q = quit,
// up/down = nudge Analog Input 1 by +/-1.1, r = re-send I-Am-Router-To-Network
// on both ports now (common/ 2.4.0+). Command line: --port <n> (Network Port 1 /
// Vermilion), --port2 <n> (Network Port 2 / Vermilion 2, default --port + 1),
// --deviceID <n>.
//
// All the UDP/stack plumbing lives in common/CASExampleHelper so this file can
// stay focused on the BACnet logic.
// =============================================================================

#include "CASExampleHelper.h"
#include "CASBACnetStackExampleConstants.h"
#include "CASBACnetStackAdapter.h" // the CAS BACnet Stack C API (BACnetStack_*); call
                                    // LoadBACnetFunctions() before any BACnetStack_* call -
                                    // see the top of main() below.

#include <stdio.h>
#include <string.h>
#include <string>
#include <errno.h>
#include <stdlib.h>

#if defined(_WIN32)
#include <windows.h> // Sleep()
#else
#include <unistd.h>  // usleep()
#endif

using namespace CASBACnetStackExampleConstants;

// -----------------------------------------------------------------------------
// 1. Example + device configuration
// -----------------------------------------------------------------------------
static const char* APP_NAME = "BACnet B-RTR (Router) Example - C++";
static const char* APP_VERSION = "1.1.0";

// The device instance. BACnet requires this to be configurable, so it defaults
// to 389018 (docs/colour-table.md) and can be overridden with --deviceID.
// CHANGE ALL OF THIS BEFORE YOU SHIP: like DEVICE_NAME above, this instance
// number MUST BE UNIQUE ACROSS THE WHOLE BACNET INTERNETWORK. --deviceID
// already makes it runtime-configurable; a real product still needs a process
// (serial number, commissioning step, ...) for assigning a non-colliding value
// per unit, since the default here is only a placeholder for this example.
static uint32_t g_deviceInstance = 389018;

// ---- Device identity: CHANGE ALL OF THIS BEFORE YOU SHIP --------------------
// Every constant in this block is read by clients and shown to the operator in
// EVERY discovery tool on the network. Left as-is, your product appears on a
// real site announcing itself as a Chipkin demo. None of it is cosmetic.

// Change to YOUR company's vendor ID, assigned free by ASHRAE:
// https://bacnet.org/assigned-vendor-ids/ . Must match VENDOR_NAME below.
static const uint32_t VENDOR_IDENTIFIER = 389;

// This is the device's Object_Name. It MUST BE UNIQUE ACROSS THE WHOLE BACNET
// INTERNETWORK - two devices with the same Object_Name is a spec violation
// that every scan tool renders as two perfectly good objects (see TUTORIAL.md's
// "silent failure" warning for the same failure shape on a per-object level).
// Here it is a COMPILE-TIME CONSTANT, which is fine for a tutorial but not for
// a real product: a real device needs a name that is unique PER UNIT, not per
// firmware build - derive it from a serial number, DIP switches, a config
// file, or a --deviceName command-line argument, not a hardcoded string.
static const char* DEVICE_NAME = "Chipkin Example B-RTR";

// Change to a description of what YOUR device actually is.
static const char* DEVICE_DESCRIPTION =
    "Chipkin CAS BACnet Stack example - B-RTR (Router) profile. Demonstrates "
    "DS-RP-B + DS-WP-B + DM-DDB-B + DM-DOB-B + DM-LM-B + NM-RC-B: a stand-alone "
    "BACnet router forwarding between two BACnet/IP networks (1 and 2), each "
    "with its own Network Port object.";

// Change to YOUR company name - must match VENDOR_IDENTIFIER above.
static const char* VENDOR_NAME = "Chipkin Automation Systems";

// Change to your product's own model designation.
static const char* MODEL_NAME = "CAS BACnet Stack Example - B-RTR";

// Firmware_Revision reflects the underlying CAS BACnet Stack's REAL version,
// built at runtime (once LoadBACnetFunctions() has loaded the stack DLL) from
// BACnetStack_GetAPI{Major,Minor,Patch,Build}Version() - see main() below.
// Application_Software_Version is this example's own version: APP_VERSION above.
static std::string g_firmwareRevision;

// The sensor objects (all instance 1) and their colour names - unchanged from
// B-SA/B-ASC.
static const uint32_t ANALOG_INPUT_INSTANCE = 1;       // "Bronze"
static const uint32_t BINARY_INPUT_INSTANCE = 1;       // "Emerald"
static const uint32_t MULTI_STATE_INPUT_INSTANCE = 1;  // "Hot Pink"
static const uint32_t MULTI_STATE_INPUT_NUMBER_OF_STATES = 3;

// -----------------------------------------------------------------------------
// F-MULTIPORT: TWO Network Port objects, one per routed network.
//
// Both ports share the SAME host network interface (this is one process on one
// box); they are distinguished by UDP PORT NUMBER, not IP address - exactly
// like running two independent BACnet/IP devices on one machine, except the
// stack now treats them as two sides of one router instead of two devices.
// common/CASExampleHelper's SendIAm(deviceInstance, networkPortInstance)
// documents this same assumption (see its "NOTE for multi-port examples").
// -----------------------------------------------------------------------------
static const uint32_t NETWORK_PORT_1_INSTANCE = 1;  // "Vermilion"   - network A
static const uint32_t NETWORK_PORT_2_INSTANCE = 2;  // "Vermilion 2" - network B
static const uint32_t MAX_APDU_LENGTH = 1476;       // BACnet/IP APDU length

// The BACnet network NUMBERS the two ports directly connect (ASHRAE 135 cl.
// 6.2.2 numbers a network, distinct from the Network Port OBJECT instance).
// Configured (not learned), so Network_Number_Quality reports CONFIGURED.
// CHANGE ALL OF THIS BEFORE YOU SHIP: these two placeholder numbers (1, 2)
// must become YOUR site's actual network numbers - they must be unique across
// the whole BACnet internetwork, exactly like the device instance above. A
// wrong or colliding network number breaks routing for every device on it,
// not just this one.
static const uint16_t NETWORK_NUMBER_PORT_1 = 1;
static const uint16_t NETWORK_NUMBER_PORT_2 = 2;

// F-ROUTER: the router-layer "port identifier" BACnetStack_AddRouterPort and
// BACnetStack_AddRouterRoute use, as reported in the Network Port's
// Routing_Table property. This is a DELIBERATELY SEPARATE id space from the
// Network Port OBJECT instance above (see AddRouterPort's own doc comment in
// CASBACnetStackDLL.h) - they happen to share the same small integers here
// (1 <-> Network Port 1, 2 <-> Network Port 2) purely for readability; do not
// assume the stack ties them together.
static const uint8_t ROUTER_PORT_ID_1 = 1;
static const uint8_t ROUTER_PORT_ID_2 = 2;

// BACnetStack_AddRouterPort's networkType is the STACK'S OWN internal
// datalink enum (source/BACnetPacket.h, BACnetPacket::NetworkType: IP=0,
// MSTP=1, SC=2) - NOT the Network Port object's Network_Type property
// (NETWORK_PORT_NETWORK_TYPE_IPV4 = 5, ASHRAE 135's BACnetNetworkType, used
// above with AddNetworkPortObject). Passing the object-level value here fails
// with "unknown network type" - confirmed against the pinned stack while
// building this example. Not (yet) mirrored in
// common/CASBACnetStackExampleConstants.h because it is stack-internal rather
// than a 135 standard enumeration; a later routing example (e.g. B-GW) that
// also needs it should consider promoting it there.
static const uint8_t ROUTER_NETWORK_TYPE_IP = 0;

// DEMONSTRATION ONLY: a network reachable one hop beyond port 2, configured
// with BACnetStack_AddRouterRoute (as opposed to BACnetStack_AddRouterPort,
// which is for a DIRECTLY connected network). Nothing in this example series
// sits on network 3 - no device answers there and no next-hop router is
// configured - so no packet is ever delivered over it. What the wire DOES show:
// the router announces network 3 as reachable through it on network 1, and
// lists it when asked from network 1 (tests/router_discovery_test.py).
static const uint16_t DEMO_REMOTE_NETWORK = 3;

// -----------------------------------------------------------------------------
// DM-LM-B: a Group object whose List_Of_Group_Members a client edits with
// AddListElement / RemoveListElement (ASHRAE 135-2024 cl. 15.1 / 15.2).
//
// The stack holds the list itself (BACnetStack_AddGroupObject / AddGroupMember)
// and executes both services against it, so this application only names the
// object. Not yet in common/CASBACnetStackExampleConstants.h, so defined here
// (values from the stack's BACnetObjectType.h, BACnetPropertyIdentifier.h and
// BACnetServicesSupported.h).
// -----------------------------------------------------------------------------
static const uint16_t OBJECT_TYPE_GROUP = 11;
static const uint32_t PROPERTY_IDENTIFIER_LIST_OF_GROUP_MEMBERS = 53;
static const uint32_t SERVICE_ADD_LIST_ELEMENT = 8;
static const uint32_t SERVICE_REMOVE_LIST_ELEMENT = 9;
static const uint32_t GROUP_INSTANCE = 1;               // "Olive"

// BACnet/IP addressing the Network Port reports. Both ports report the SAME
// host IP/subnet (see the comment above NETWORK_PORT_1_INSTANCE) - only the
// UDP port differs, captured per-port below.
static uint8_t g_ipAddress[4] = { 0, 0, 0, 0 };
static uint8_t g_ipSubnetMask[4] = { 0, 0, 0, 0 };
static uint8_t g_ipDefaultGateway[4] = { 0, 0, 0, 0 };
static uint16_t g_bacnetIpUdpPort1 = 47808; // Network Port 1 / Vermilion
static uint16_t g_bacnetIpUdpPort2 = 47809; // Network Port 2 / Vermilion 2 (default +1)

// Analog Input 1's live present value (degrees Celsius). Starts at 21.5 and is
// nudged by the up/down arrow keys.
static float g_analogInput1Value = 21.5f;

// The commandable OUTPUT objects (all instance 1) and their colour names -
// unchanged from B-SA/B-ASC.
static const uint32_t ANALOG_OUTPUT_INSTANCE = 1;        // "Chartreuse"
static const uint32_t BINARY_OUTPUT_INSTANCE = 1;        // "Fuchsia"
static const uint32_t MULTI_STATE_OUTPUT_INSTANCE = 1;   // "Indigo"
static const uint32_t MULTI_STATE_OUTPUT_NUMBER_OF_STATES = 3;
static const uint32_t BACNET_PRIORITY_ARRAY_SIZE = 16;

struct Commandable {
    bool isSet[16];
    double value[16];
    double relinquishDefault;
};

static Commandable g_analogOutput = { { false }, { 0 }, 20.0 };
static Commandable g_binaryOutput = { { false }, { 0 }, 0.0 };
static Commandable g_multiStateOutput = { { false }, { 0 }, 1.0 };

static uint8_t EffectivePriority(uint8_t priority) {
    return (priority >= 1 && priority <= BACNET_PRIORITY_ARRAY_SIZE) ? priority : 16;
}

static void CommandWrite(Commandable* c, uint8_t priority, double value) {
    const uint8_t p = EffectivePriority(priority);
    c->isSet[p - 1] = true;
    c->value[p - 1] = value;
}

static void CommandRelinquish(Commandable* c, uint8_t priority) {
    const uint8_t p = EffectivePriority(priority);
    c->isSet[p - 1] = false;
}

static Commandable* GetCommandable(uint16_t objectType, uint32_t objectInstance) {
    if (objectType == OBJECT_TYPE_ANALOG_OUTPUT && objectInstance == ANALOG_OUTPUT_INSTANCE) {
        return &g_analogOutput;
    }
    if (objectType == OBJECT_TYPE_BINARY_OUTPUT && objectInstance == BINARY_OUTPUT_INSTANCE) {
        return &g_binaryOutput;
    }
    if (objectType == OBJECT_TYPE_MULTI_STATE_OUTPUT && objectInstance == MULTI_STATE_OUTPUT_INSTANCE) {
        return &g_multiStateOutput;
    }
    return NULL;
}

static bool ReadPrioritySlot(const Commandable* c, uint32_t propertyIdentifier,
                             bool useArrayIndex, uint32_t propertyArrayIndex,
                             bool* slotIsSet, double* slotValue) {
    if (propertyIdentifier != PROPERTY_IDENTIFIER_PRIORITY_ARRAY || !useArrayIndex ||
        propertyArrayIndex < 1 || propertyArrayIndex > BACNET_PRIORITY_ARRAY_SIZE) {
        return false;
    }
    *slotIsSet = c->isSet[propertyArrayIndex - 1];
    *slotValue = c->value[propertyArrayIndex - 1];
    return true;
}

// -----------------------------------------------------------------------------
// 2. Property "get" callbacks - see B-ASC's main.cpp for the full essay on the
// errorCode out-parameter and the decline-and-fabricate fallback; the same
// rules apply here unchanged. The only NEW material below is serving TWO
// Network Port objects instead of one.
// -----------------------------------------------------------------------------

bool GetPropertyReal(const uint32_t deviceInstance, const uint16_t objectType,
                     const uint32_t objectInstance, const uint32_t propertyIdentifier,
                     float* value, const bool useArrayIndex,
                     const uint32_t propertyArrayIndex, uint32_t* errorCode) {
    (void)errorCode;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    if (objectType == OBJECT_TYPE_ANALOG_INPUT &&
        objectInstance == ANALOG_INPUT_INSTANCE &&
        propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
        *value = g_analogInput1Value;
        return true;
    }
    const Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && objectType == OBJECT_TYPE_ANALOG_OUTPUT) {
        bool slotIsSet = false;
        double slotValue = 0.0;
        if (ReadPrioritySlot(c, propertyIdentifier, useArrayIndex, propertyArrayIndex,
                             &slotIsSet, &slotValue)) {
            if (!slotIsSet) {
                return false;
            }
            *value = (float)slotValue;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_RELINQUISH_DEFAULT) {
            *value = (float)c->relinquishDefault;
            return true;
        }
    }
    return false;
}

bool GetPropertyEnumerated(const uint32_t deviceInstance, const uint16_t objectType,
                           const uint32_t objectInstance, const uint32_t propertyIdentifier,
                           uint32_t* value, const bool useArrayIndex,
                           const uint32_t propertyArrayIndex, uint32_t* errorCode) {
    (void)errorCode;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    if (objectType == OBJECT_TYPE_BINARY_INPUT &&
        objectInstance == BINARY_INPUT_INSTANCE) {
        if (propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
            *value = 0; // inactive - the series-wide starting value
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_POLARITY) {
            *value = POLARITY_NORMAL;
            return true;
        }
    }
    const Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && objectType == OBJECT_TYPE_BINARY_OUTPUT) {
        bool slotIsSet = false;
        double slotValue = 0.0;
        if (ReadPrioritySlot(c, propertyIdentifier, useArrayIndex, propertyArrayIndex,
                             &slotIsSet, &slotValue)) {
            if (!slotIsSet) {
                return false;
            }
            *value = (uint32_t)slotValue;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_RELINQUISH_DEFAULT) {
            *value = (uint32_t)c->relinquishDefault;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_POLARITY) {
            *value = POLARITY_NORMAL;
            return true;
        }
    }
    if (propertyIdentifier == PROPERTY_IDENTIFIER_UNITS &&
        ((objectType == OBJECT_TYPE_ANALOG_INPUT && objectInstance == ANALOG_INPUT_INSTANCE) ||
         (objectType == OBJECT_TYPE_ANALOG_OUTPUT && objectInstance == ANALOG_OUTPUT_INSTANCE))) {
        *value = ENGINEERING_UNITS_DEGREES_CELSIUS;
        return true;
    }
    // BACnet_IP_Mode: NORMAL on BOTH Network Ports - neither is a foreign
    // device or a BBMD. Checking objectType only (not instance) serves every
    // Network Port this device has, present or future.
    if (objectType == OBJECT_TYPE_NETWORK_PORT &&
        propertyIdentifier == PROPERTY_IDENTIFIER_BACNET_IP_MODE) {
        *value = BACNET_IP_MODE_NORMAL;
        return true;
    }
    return false;
}

bool GetPropertyUnsignedInteger(const uint32_t deviceInstance, const uint16_t objectType,
                                const uint32_t objectInstance, const uint32_t propertyIdentifier,
                                uint32_t* value, const bool useArrayIndex,
                                const uint32_t propertyArrayIndex, uint32_t* errorCode) {
    (void)errorCode;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    if (objectType == OBJECT_TYPE_MULTI_STATE_INPUT &&
        objectInstance == MULTI_STATE_INPUT_INSTANCE) {
        if (propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
            *value = 1;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_NUMBER_OF_STATES) {
            *value = MULTI_STATE_INPUT_NUMBER_OF_STATES;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_STATE_TEXT &&
            useArrayIndex && propertyArrayIndex == 0) {
            *value = MULTI_STATE_INPUT_NUMBER_OF_STATES;
            return true;
        }
    }
    if (objectType == OBJECT_TYPE_DEVICE && objectInstance == g_deviceInstance &&
        propertyIdentifier == PROPERTY_IDENTIFIER_VENDOR_IDENTIFIER) {
        *value = VENDOR_IDENTIFIER;
        return true;
    }
    // Network Port properties that are the SAME for both ports (APDU_Length,
    // Reference_Port) vs the ONE that differs (BACnet_IP_UDP_Port).
    if (objectType == OBJECT_TYPE_NETWORK_PORT &&
        (objectInstance == NETWORK_PORT_1_INSTANCE || objectInstance == NETWORK_PORT_2_INSTANCE)) {
        if (propertyIdentifier == PROPERTY_IDENTIFIER_APDU_LENGTH) {
            *value = MAX_APDU_LENGTH;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_REFERENCE_PORT) {
            *value = NETWORK_PORT_REFERENCE_PORT_NONE;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_BACNET_IP_UDP_PORT) {
            *value = (objectInstance == NETWORK_PORT_1_INSTANCE) ? g_bacnetIpUdpPort1 : g_bacnetIpUdpPort2;
            return true;
        }
    }
    const Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && objectType == OBJECT_TYPE_MULTI_STATE_OUTPUT) {
        bool slotIsSet = false;
        double slotValue = 0.0;
        if (ReadPrioritySlot(c, propertyIdentifier, useArrayIndex, propertyArrayIndex,
                             &slotIsSet, &slotValue)) {
            if (!slotIsSet) {
                return false;
            }
            *value = (uint32_t)slotValue;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_RELINQUISH_DEFAULT) {
            *value = (uint32_t)c->relinquishDefault;
            return true;
        }
        if (propertyIdentifier == PROPERTY_IDENTIFIER_NUMBER_OF_STATES) {
            *value = MULTI_STATE_OUTPUT_NUMBER_OF_STATES;
            return true;
        }
    }
    return false;
}

bool GetPropertyBool(const uint32_t deviceInstance, const uint16_t objectType,
                     const uint32_t objectInstance, const uint32_t propertyIdentifier,
                     bool* value, const bool useArrayIndex,
                     const uint32_t propertyArrayIndex, uint32_t* errorCode) {
    (void)errorCode;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    const Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && propertyIdentifier == PROPERTY_IDENTIFIER_PRIORITY_ARRAY &&
        useArrayIndex && propertyArrayIndex >= 1 &&
        propertyArrayIndex <= BACNET_PRIORITY_ARRAY_SIZE) {
        *value = !c->isSet[propertyArrayIndex - 1];
        return true;
    }
    // Out_Of_Service: false for every input/output object AND for BOTH Network
    // Ports (objectType-only check, so it covers every Network Port instance).
    if (propertyIdentifier == PROPERTY_IDENTIFIER_OUT_OF_SERVICE &&
        (objectType == OBJECT_TYPE_ANALOG_INPUT ||
         objectType == OBJECT_TYPE_BINARY_INPUT ||
         objectType == OBJECT_TYPE_MULTI_STATE_INPUT ||
         objectType == OBJECT_TYPE_ANALOG_OUTPUT ||
         objectType == OBJECT_TYPE_BINARY_OUTPUT ||
         objectType == OBJECT_TYPE_MULTI_STATE_OUTPUT ||
         objectType == OBJECT_TYPE_NETWORK_PORT)) {
        *value = false;
        return true;
    }
    return false;
}

// OCTET STRING - BOTH Network Ports report the SAME host IP/subnet/gateway
// (see the comment above NETWORK_PORT_1_INSTANCE): one host interface, two
// UDP ports simulating two BACnet/IP networks.
bool GetPropertyOctetString(const uint32_t deviceInstance, const uint16_t objectType,
                            const uint32_t objectInstance, const uint32_t propertyIdentifier,
                            uint8_t* value, uint32_t* valueElementCount,
                            const uint32_t maxElementCount, const bool useArrayIndex,
                            const uint32_t propertyArrayIndex, uint32_t* errorCode) {
    (void)useArrayIndex;
    (void)propertyArrayIndex;
    (void)errorCode;
    if (deviceInstance != g_deviceInstance ||
        objectType != OBJECT_TYPE_NETWORK_PORT ||
        (objectInstance != NETWORK_PORT_1_INSTANCE && objectInstance != NETWORK_PORT_2_INSTANCE) ||
        maxElementCount < 4) {
        return false;
    }
    const uint8_t* source = NULL;
    switch (propertyIdentifier) {
        case PROPERTY_IDENTIFIER_IP_ADDRESS:         source = g_ipAddress; break;
        case PROPERTY_IDENTIFIER_IP_SUBNET_MASK:     source = g_ipSubnetMask; break;
        case PROPERTY_IDENTIFIER_IP_DEFAULT_GATEWAY: source = g_ipDefaultGateway; break;
        default: return false;
    }
    memcpy(value, source, 4);
    *valueElementCount = 4;
    return true;
}

static bool ReturnCharacterString(const char* text, char* value,
                                  uint32_t* valueElementCount,
                                  const uint32_t maxElementCount,
                                  uint8_t* encodingType) {
    uint32_t length = (uint32_t)strlen(text);
    if (length > maxElementCount) {
        length = maxElementCount;
    }
    memcpy(value, text, length);
    *valueElementCount = length;
    *encodingType = CHARACTER_STRING_ENCODING_UTF8;
    return true;
}

bool GetPropertyCharString(const uint32_t deviceInstance, const uint16_t objectType,
                           const uint32_t objectInstance, const uint32_t propertyIdentifier,
                           char* value, uint32_t* valueElementCount,
                           const uint32_t maxElementCount, uint8_t* encodingType,
                           const bool useArrayIndex, const uint32_t propertyArrayIndex,
                           uint32_t* errorCode) {
    if (deviceInstance != g_deviceInstance) {
        return false;
    }

    if (objectType == OBJECT_TYPE_MULTI_STATE_INPUT &&
        objectInstance == MULTI_STATE_INPUT_INSTANCE &&
        propertyIdentifier == PROPERTY_IDENTIFIER_STATE_TEXT && useArrayIndex) {
        static const char* const stateText[] = { "On", "Off", "Auto" };
        if (propertyArrayIndex >= 1 && propertyArrayIndex <= MULTI_STATE_INPUT_NUMBER_OF_STATES) {
            return ReturnCharacterString(stateText[propertyArrayIndex - 1], value,
                                         valueElementCount, maxElementCount, encodingType);
        }
        *errorCode = ERROR_CODE_INVALID_ARRAY_INDEX;
        return false;
    }

    if (propertyIdentifier == PROPERTY_IDENTIFIER_OBJECT_NAME) {
        if (objectType == OBJECT_TYPE_DEVICE && objectInstance == g_deviceInstance) {
            return ReturnCharacterString(DEVICE_NAME, value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_ANALOG_INPUT && objectInstance == ANALOG_INPUT_INSTANCE) {
            return ReturnCharacterString("Bronze", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_BINARY_INPUT && objectInstance == BINARY_INPUT_INSTANCE) {
            return ReturnCharacterString("Emerald", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_MULTI_STATE_INPUT && objectInstance == MULTI_STATE_INPUT_INSTANCE) {
            return ReturnCharacterString("Hot Pink", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_ANALOG_OUTPUT && objectInstance == ANALOG_OUTPUT_INSTANCE) {
            return ReturnCharacterString("Chartreuse", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_BINARY_OUTPUT && objectInstance == BINARY_OUTPUT_INSTANCE) {
            return ReturnCharacterString("Fuchsia", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_MULTI_STATE_OUTPUT && objectInstance == MULTI_STATE_OUTPUT_INSTANCE) {
            return ReturnCharacterString("Indigo", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_NETWORK_PORT && objectInstance == NETWORK_PORT_1_INSTANCE) {
            return ReturnCharacterString("Vermilion", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_NETWORK_PORT && objectInstance == NETWORK_PORT_2_INSTANCE) {
            return ReturnCharacterString("Vermilion 2", value, valueElementCount, maxElementCount, encodingType);
        }
        if (objectType == OBJECT_TYPE_GROUP && objectInstance == GROUP_INSTANCE) {
            return ReturnCharacterString("Olive", value, valueElementCount, maxElementCount, encodingType);
        }
    }

    if (objectType == OBJECT_TYPE_DEVICE && objectInstance == g_deviceInstance) {
        switch (propertyIdentifier) {
            case PROPERTY_IDENTIFIER_DESCRIPTION:
                return ReturnCharacterString(DEVICE_DESCRIPTION, value, valueElementCount, maxElementCount, encodingType);
            case PROPERTY_IDENTIFIER_VENDOR_NAME:
                return ReturnCharacterString(VENDOR_NAME, value, valueElementCount, maxElementCount, encodingType);
            case PROPERTY_IDENTIFIER_MODEL_NAME:
                return ReturnCharacterString(MODEL_NAME, value, valueElementCount, maxElementCount, encodingType);
            case PROPERTY_IDENTIFIER_FIRMWARE_REVISION:
                return ReturnCharacterString(g_firmwareRevision.c_str(), value, valueElementCount, maxElementCount, encodingType);
            case PROPERTY_IDENTIFIER_APPLICATION_SOFTWARE_VERSION:
                return ReturnCharacterString(APP_VERSION, value, valueElementCount, maxElementCount, encodingType);
            default:
                break;
        }
    }

    return false;
}

// -----------------------------------------------------------------------------
// 2b. Property "set" callbacks - DS-WP-B (identical to B-SA/B-ASC).
// -----------------------------------------------------------------------------

bool SetPropertyReal(const uint32_t deviceInstance, const uint16_t objectType,
                     const uint32_t objectInstance, const uint32_t propertyIdentifier,
                     const float value, const bool useArrayIndex,
                     const uint32_t propertyArrayIndex, const uint8_t priority,
                     uint32_t* errorCode) {
    (void)useArrayIndex;
    (void)propertyArrayIndex;
    (void)errorCode;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && objectType == OBJECT_TYPE_ANALOG_OUTPUT &&
        propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
        CommandWrite(c, priority, (double)value);
        printf("WriteProperty: Analog Output %u (Chartreuse) <- %.2f @ priority %u\n",
               objectInstance, value, EffectivePriority(priority));
        return true;
    }
    return false;
}

bool SetPropertyEnumerated(const uint32_t deviceInstance, const uint16_t objectType,
                           const uint32_t objectInstance, const uint32_t propertyIdentifier,
                           const uint32_t value, const bool useArrayIndex,
                           const uint32_t propertyArrayIndex, const uint8_t priority,
                           uint32_t* errorCode) {
    (void)useArrayIndex;
    (void)propertyArrayIndex;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && objectType == OBJECT_TYPE_BINARY_OUTPUT &&
        propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
        if (value > 1) {
            *errorCode = ERROR_CODE_VALUE_OUT_OF_RANGE;
            return false;
        }
        CommandWrite(c, priority, (double)value);
        printf("WriteProperty: Binary Output %u (Fuchsia) <- %s @ priority %u\n",
               objectInstance, value ? "active" : "inactive", EffectivePriority(priority));
        return true;
    }
    return false;
}

bool SetPropertyUnsignedInteger(const uint32_t deviceInstance, const uint16_t objectType,
                                const uint32_t objectInstance, const uint32_t propertyIdentifier,
                                const uint32_t value, const bool useArrayIndex,
                                const uint32_t propertyArrayIndex, const uint8_t priority,
                                uint32_t* errorCode) {
    (void)useArrayIndex;
    (void)propertyArrayIndex;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && objectType == OBJECT_TYPE_MULTI_STATE_OUTPUT &&
        propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
        if (value < 1 || value > MULTI_STATE_OUTPUT_NUMBER_OF_STATES) {
            *errorCode = ERROR_CODE_VALUE_OUT_OF_RANGE;
            return false;
        }
        CommandWrite(c, priority, (double)value);
        printf("WriteProperty: Multi-State Output %u (Indigo) <- state %u @ priority %u\n",
               objectInstance, value, EffectivePriority(priority));
        return true;
    }
    return false;
}

bool SetPropertyNull(const uint32_t deviceInstance, const uint16_t objectType,
                     const uint32_t objectInstance, const uint32_t propertyIdentifier,
                     const bool useArrayIndex, const uint32_t propertyArrayIndex,
                     const uint8_t priority, uint32_t* errorCode) {
    (void)useArrayIndex;
    (void)propertyArrayIndex;
    (void)errorCode;
    if (deviceInstance != g_deviceInstance) {
        return false;
    }
    Commandable* c = GetCommandable(objectType, objectInstance);
    if (c != NULL && propertyIdentifier == PROPERTY_IDENTIFIER_PRESENT_VALUE) {
        CommandRelinquish(c, priority);
        printf("WriteProperty: relinquished %s %u @ priority %u\n",
               objectType == OBJECT_TYPE_ANALOG_OUTPUT ? "Analog Output" :
               objectType == OBJECT_TYPE_BINARY_OUTPUT ? "Binary Output" :
               "Multi-State Output",
               objectInstance, EffectivePriority(priority));
        return true;
    }
    return false;
}

// -----------------------------------------------------------------------------
// 2c. Router helpers (F-ROUTER)
//
// SendIAmRouterToNetwork/SendWhoIsRouterToNetwork/SendNetworkNumberIs all take
// a DESTINATION connection string (who to send TO), not a source. Broadcasting
// on one of our own ports means "the local subnet broadcast of THAT port's
// network" - the same address CASExampleHelper::SendIAm computes internally,
// rebuilt here because main.cpp does not have access to that private helper.
// -----------------------------------------------------------------------------
static void BuildLocalBroadcastConnectionString(uint16_t port, uint8_t connectionString[6]) {
    uint8_t bcast[4] = { 255, 255, 255, 255 };
    uint8_t ip[4], mask[4];
    if (CASExampleHelper::GetLocalIPv4(ip, mask)) {
        bcast[0] = (uint8_t)(ip[0] | ~mask[0]);
        bcast[1] = (uint8_t)(ip[1] | ~mask[1]);
        bcast[2] = (uint8_t)(ip[2] | ~mask[2]);
        bcast[3] = (uint8_t)(ip[3] | ~mask[3]);
    }
    connectionString[0] = bcast[0];
    connectionString[1] = bcast[1];
    connectionString[2] = bcast[2];
    connectionString[3] = bcast[3];
    connectionString[4] = (uint8_t)((port >> 8) & 0xFF);
    connectionString[5] = (uint8_t)(port & 0xFF);
}

// Broadcast I-Am-Router-To-Network on BOTH ports. Each port announces the
// networks reachable THROUGH this router from that port - "each accessible
// network except the networks reachable via the network on which the
// broadcast is being made" (ASHRAE 135-2024 cl. 6.6.2):
//
//     on Network Port 1: network 2 and network 3 (3 is one hop beyond port 2)
//     on Network Port 2: network 1
//
// So the lists are passed explicitly. Passing networkNumbers = NULL, count = 0
// instead announces every port's directly-connected network on BOTH ports
// (see BACnetStack_SendIAmRouterToNetwork's doc comment) - which would tell
// network 1 that network 1 is reachable through this router. Called whenever
// the 'r' key is pressed (the stack sends the start-up one itself).
static void AnnounceRouterToBothNetworks() {
    const uint16_t reachableFromPort1[] = { NETWORK_NUMBER_PORT_2, DEMO_REMOTE_NETWORK };
    uint8_t cs1[6];
    BuildLocalBroadcastConnectionString(g_bacnetIpUdpPort1, cs1);
    const bool ok1 = BACnetStack_SendIAmRouterToNetwork(
        reachableFromPort1, (uint32_t)(sizeof(reachableFromPort1) / sizeof(reachableFromPort1[0])),
        cs1, 6, NETWORK_PORT_1_INSTANCE, true, 0, NULL, 0);

    const uint16_t reachableFromPort2[] = { NETWORK_NUMBER_PORT_1 };
    uint8_t cs2[6];
    BuildLocalBroadcastConnectionString(g_bacnetIpUdpPort2, cs2);
    const bool ok2 = BACnetStack_SendIAmRouterToNetwork(
        reachableFromPort2, (uint32_t)(sizeof(reachableFromPort2) / sizeof(reachableFromPort2[0])),
        cs2, 6, NETWORK_PORT_2_INSTANCE, true, 0, NULL, 0);

    printf("FYI: I-Am-Router-To-Network broadcast on Network Port 1 (Vermilion): %s; "
           "on Network Port 2 (Vermilion 2): %s\n",
           ok1 ? "sent" : "FAILED", ok2 ? "sent" : "FAILED");
}

// -----------------------------------------------------------------------------
// 3. main()
// -----------------------------------------------------------------------------
int main(int argc, char** argv) {
    setvbuf(stdout, NULL, _IONBF, 0);

    if (!LoadBACnetFunctions()) {
        fprintf(stderr, "Error: failed to load the CAS BACnet Stack: %s\n",
                CASBACnetStackAdapter_LastError());
        return 1;
    }

    {
        char buf[32];
        snprintf(buf, sizeof(buf), "%u.%u.%u.%u",
                 BACnetStack_GetAPIMajorVersion(), BACnetStack_GetAPIMinorVersion(),
                 BACnetStack_GetAPIPatchVersion(), BACnetStack_GetAPIBuildVersion());
        g_firmwareRevision = buf;
    }

    if (CASExampleHelper::HandleHelpAndVersionArgs(argc, argv, APP_NAME, APP_VERSION)) {
        return 0;
    }
    // --port sets Network Port 1 (Vermilion); --port2 sets Network Port 2
    // (Vermilion 2), defaulting to --port + 1 so the example runs out of the
    // box with two DIFFERENT UDP ports and no extra flags. ParsePortArg (the
    // shared helper) only knows the one "--port" flag, so --port2 is parsed
    // locally with the same validation rule.
    const uint16_t port1 = CASExampleHelper::ParsePortArg(argc, argv, 47808);
    uint16_t port2 = (uint16_t)(port1 + 1);
    for (int i = 1; i + 1 < argc; ++i) {
        if (strcmp(argv[i], "--port2") == 0) {
            char* end = NULL;
            errno = 0;
            const long p = strtol(argv[i + 1], &end, 10);
            if (errno == 0 && end != argv[i + 1] && *end == '\0' && p > 0 && p <= 65535) {
                port2 = (uint16_t)p;
            } else {
                printf("Warning: ignoring invalid --port2 \"%s\" (want 1..65535); using %u.\n",
                       argv[i + 1], (unsigned)port2);
            }
        }
    }
    if (port2 == port1) {
        fprintf(stderr, "Error: --port2 (%u) must differ from --port (%u) - they are two "
                        "separate BACnet/IP networks on this router.\n",
                (unsigned)port2, (unsigned)port1);
        return 1;
    }
    g_deviceInstance = CASExampleHelper::ParseDeviceIdArg(argc, argv, g_deviceInstance);
    CASExampleHelper::PrintVersion(APP_NAME, APP_VERSION);

    // --- Bind BOTH BACnet/IP sockets (F-MULTIPORT) --------------------------
    // SetNetworkPortInstance first, so the single-argument SetupUDP(port1) and
    // (later) SendIAm(deviceInstance) act on Network Port 1 by default; port 2
    // is bound with the explicit two-argument overload.
    CASExampleHelper::SetNetworkPortInstance(NETWORK_PORT_1_INSTANCE);
    if (!CASExampleHelper::SetupUDP(port1)) {
        return 1;
    }
    if (!CASExampleHelper::SetupUDP(port2, NETWORK_PORT_2_INSTANCE)) {
        return 1;
    }
    g_bacnetIpUdpPort1 = port1;
    g_bacnetIpUdpPort2 = port2;
    if (!CASExampleHelper::GetLocalIPv4(g_ipAddress, g_ipSubnetMask)) {
        printf("FYI: could not read a local IPv4 address; both Network Ports will report "
               "IP_Address 0.0.0.0.\n");
    }

    // --- Register callbacks -------------------------------------------------
    // One set of transport/time callbacks serves BOTH ports - common/ 2.3.0+
    // dispatches on networkPortInstance internally (see CASExampleHelper.cpp).
    CASExampleHelper::RegisterCommonCallbacks();
    BACnetStack_RegisterCallbackGetPropertyReal(GetPropertyReal);
    BACnetStack_RegisterCallbackGetPropertyEnumerated(GetPropertyEnumerated);
    BACnetStack_RegisterCallbackGetPropertyUnsignedInteger(GetPropertyUnsignedInteger);
    BACnetStack_RegisterCallbackGetPropertyCharacterString(GetPropertyCharString);
    BACnetStack_RegisterCallbackGetPropertyBool(GetPropertyBool);
    BACnetStack_RegisterCallbackGetPropertyOctetString(GetPropertyOctetString);
    BACnetStack_RegisterCallbackSetPropertyReal(SetPropertyReal);
    BACnetStack_RegisterCallbackSetPropertyEnumerated(SetPropertyEnumerated);
    BACnetStack_RegisterCallbackSetPropertyUnsignedInteger(SetPropertyUnsignedInteger);
    BACnetStack_RegisterCallbackSetPropertyNull(SetPropertyNull);
    // NOTE: no DeviceCommunicationControl callback - this profile (unlike
    // B-ASC, its seed) does not include DM-DCC-B.

    // --- Create the device --------------------------------------------------
    if (!BACnetStack_AddDevice(g_deviceInstance)) {
        printf("Error: Failed to add the Device %u.\n", g_deviceInstance);
        return 1;
    }

    // DS-RP-B, DS-WP-B: ReadProperty, WriteProperty.
    if (!BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_READ_PROPERTY, true)) {
        printf("Error: Failed to enable the ReadProperty service.\n");
        return 1;
    }
    if (!BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_WRITE_PROPERTY, true)) {
        printf("Error: Failed to enable the WriteProperty service.\n");
        return 1;
    }
    // DM-DDB-B, DM-DOB-B: answer Who-Is with I-Am and Who-Has with I-Have.
    // NM-RC-B's network-layer messages (Who-Is-Router-To-Network,
    // I-Am-Router-To-Network, Network-Number-Is) are NOT gated by
    // SetServiceEnabled - they are enabled purely by BACnetStack_AddRouterPort
    // + BACnetStack_SetRouterEnabled below.
    if (!BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_WHO_IS, true) ||
        !BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_I_AM, true) ||
        !BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_WHO_HAS, true) ||
        !BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_I_HAVE, true)) {
        printf("Error: Failed to enable the discovery services (Who-Is/I-Am, Who-Has/I-Have).\n");
        return 1;
    }
    // DM-LM-B: AddListElement and RemoveListElement, executed by the stack
    // against the Group object's List_Of_Group_Members (added below).
    if (!BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_ADD_LIST_ELEMENT, true) ||
        !BACnetStack_SetServiceEnabled(g_deviceInstance, SERVICE_REMOVE_LIST_ELEMENT, true)) {
        printf("Error: Failed to enable AddListElement/RemoveListElement.\n");
        return 1;
    }

    // --- Add the read-only sensor objects -----------------------------------
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_ANALOG_INPUT, ANALOG_INPUT_INSTANCE)) {
        printf("Error: Failed to add Analog Input %u (Bronze).\n", ANALOG_INPUT_INSTANCE);
        return 1;
    }
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_BINARY_INPUT, BINARY_INPUT_INSTANCE)) {
        printf("Error: Failed to add Binary Input %u (Emerald).\n", BINARY_INPUT_INSTANCE);
        return 1;
    }
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_MULTI_STATE_INPUT, MULTI_STATE_INPUT_INSTANCE)) {
        printf("Error: Failed to add Multi-State Input %u (Hot Pink).\n", MULTI_STATE_INPUT_INSTANCE);
        return 1;
    }

    // --- Add the commandable OUTPUT objects ----------------------------------
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_ANALOG_OUTPUT, ANALOG_OUTPUT_INSTANCE)) {
        printf("Error: Failed to add Analog Output %u (Chartreuse).\n", ANALOG_OUTPUT_INSTANCE);
        return 1;
    }
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_BINARY_OUTPUT, BINARY_OUTPUT_INSTANCE)) {
        printf("Error: Failed to add Binary Output %u (Fuchsia).\n", BINARY_OUTPUT_INSTANCE);
        return 1;
    }
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_MULTI_STATE_OUTPUT, MULTI_STATE_OUTPUT_INSTANCE)) {
        printf("Error: Failed to add Multi-State Output %u (Indigo).\n", MULTI_STATE_OUTPUT_INSTANCE);
        return 1;
    }

    // --- Add the Group object (DM-LM-B) -------------------------------------
    // AddObject creates it; AddGroupObject hands its List_Of_Group_Members to
    // the stack, which then serves the list, builds the Group's Present_Value
    // from it (one ReadAccessResult per member), and executes AddListElement /
    // RemoveListElement on it. It starts with one member - Analog Input 1's
    // Present_Value - so a client sees a non-empty list before editing it.
    if (!BACnetStack_AddObject(g_deviceInstance, OBJECT_TYPE_GROUP, GROUP_INSTANCE) ||
        !BACnetStack_AddGroupObject(g_deviceInstance, GROUP_INSTANCE)) {
        printf("Error: Failed to add Group %u (Olive).\n", GROUP_INSTANCE);
        return 1;
    }
    if (!BACnetStack_AddGroupMember(g_deviceInstance, GROUP_INSTANCE,
                                    OBJECT_TYPE_ANALOG_INPUT, ANALOG_INPUT_INSTANCE,
                                    PROPERTY_IDENTIFIER_PRESENT_VALUE, false, 0)) {
        printf("Error: Failed to add Analog Input %u to Group %u (Olive).\n",
               ANALOG_INPUT_INSTANCE, GROUP_INSTANCE);
        return 1;
    }
    // A stack-held list is read-only to BACnet clients until it is made
    // writable: without this, AddListElement / RemoveListElement are refused
    // with PROPERTY / WRITE_ACCESS_DENIED (ASHRAE 135-2024 cl. 15.1.1.3.1).
    if (!BACnetStack_SetPropertyWritable(g_deviceInstance, OBJECT_TYPE_GROUP, GROUP_INSTANCE,
                                         PROPERTY_IDENTIFIER_LIST_OF_GROUP_MEMBERS, true)) {
        printf("Error: Failed to make List_Of_Group_Members writable on Group %u (Olive).\n",
               GROUP_INSTANCE);
        return 1;
    }

    // --- Add BOTH Network Port objects (F-MULTIPORT) -------------------------
    // Each one is BACNET_APPLICATION level, so it gets a Network_Number and
    // Network_Number_Quality; we pass CONFIGURED, since a router locally
    // configures the number of each network it joins rather than learning it.
    if (!BACnetStack_AddNetworkPortObject(
            g_deviceInstance, NETWORK_PORT_1_INSTANCE,
            NETWORK_PORT_NETWORK_TYPE_IPV4,
            NETWORK_PORT_PROTOCOL_LEVEL_BACNET_APPLICATION,
            NETWORK_NUMBER_PORT_1,
            NETWORK_NUMBER_QUALITY_CONFIGURED,
            NETWORK_PORT_REFERENCE_PORT_NONE)) {
        printf("Error: Failed to add Network Port 1 (Vermilion).\n");
        return 1;
    }
    if (!BACnetStack_AddNetworkPortObject(
            g_deviceInstance, NETWORK_PORT_2_INSTANCE,
            NETWORK_PORT_NETWORK_TYPE_IPV4,
            NETWORK_PORT_PROTOCOL_LEVEL_BACNET_APPLICATION,
            NETWORK_NUMBER_PORT_2,
            NETWORK_NUMBER_QUALITY_CONFIGURED,
            NETWORK_PORT_REFERENCE_PORT_NONE)) {
        printf("Error: Failed to add Network Port 2 (Vermilion 2).\n");
        return 1;
    }

    // --- Enable the OPTIONAL properties we choose to expose ------------------
    if (!BACnetStack_SetPropertyEnabled(g_deviceInstance, OBJECT_TYPE_DEVICE,
                                        g_deviceInstance, PROPERTY_IDENTIFIER_DESCRIPTION, true)) {
        printf("Error: Failed to enable Description on the Device object.\n");
        return 1;
    }
    if (!BACnetStack_SetPropertyEnabled(g_deviceInstance, OBJECT_TYPE_MULTI_STATE_INPUT,
                                        MULTI_STATE_INPUT_INSTANCE, PROPERTY_IDENTIFIER_STATE_TEXT, true)) {
        printf("Error: Failed to enable State_Text on Multi-State Input 1 (Hot Pink).\n");
        return 1;
    }
    // Routing_Table (cl. 12.56.62, "the table of first hop routers to remote
    // networks reachable through this port") needs nothing from this
    // application: while routing is enabled (SetRouterEnabled below) the stack
    // enables it on every Network Port and fills it, per port, from the routes
    // configured below. Network Port 1 has no router beyond it, so its table is
    // empty; Network Port 2 lists network 3, the demonstration route. A directly
    // connected network is never listed. tests/routing_table_test.py reads both.

    // --- Make the output objects commandable --------------------------------
    struct CommandableObject { uint16_t type; uint32_t instance; };
    const CommandableObject outputs[] = {
        { OBJECT_TYPE_ANALOG_OUTPUT,      ANALOG_OUTPUT_INSTANCE },
        { OBJECT_TYPE_BINARY_OUTPUT,      BINARY_OUTPUT_INSTANCE },
        { OBJECT_TYPE_MULTI_STATE_OUTPUT, MULTI_STATE_OUTPUT_INSTANCE },
    };
    for (size_t i = 0; i < sizeof(outputs) / sizeof(outputs[0]); ++i) {
        if (!BACnetStack_SetPropertyEnabled(g_deviceInstance, outputs[i].type, outputs[i].instance,
                                            PROPERTY_IDENTIFIER_PRIORITY_ARRAY, true) ||
            !BACnetStack_SetPropertyEnabled(g_deviceInstance, outputs[i].type, outputs[i].instance,
                                            PROPERTY_IDENTIFIER_RELINQUISH_DEFAULT, true) ||
            !BACnetStack_SetPropertyWritable(g_deviceInstance, outputs[i].type, outputs[i].instance,
                                             PROPERTY_IDENTIFIER_PRESENT_VALUE, true)) {
            printf("Error: Failed to make object type %u instance %u commandable.\n",
                   outputs[i].type, outputs[i].instance);
            return 1;
        }
    }

    // --- F-ROUTER: configure and enable physical routing ---------------------
    // AddRouterPort registers each DIRECTLY connected network (one call per
    // Network Port that participates - see its doc comment: "two or more
    // ports make the device a router").
    if (!BACnetStack_AddRouterPort(g_deviceInstance, ROUTER_PORT_ID_1,
                                   NETWORK_NUMBER_PORT_1, ROUTER_NETWORK_TYPE_IP)) {
        printf("Error: Failed to register router port 1 (network %u, Vermilion).\n",
               (unsigned)NETWORK_NUMBER_PORT_1);
        return 1;
    }
    if (!BACnetStack_AddRouterPort(g_deviceInstance, ROUTER_PORT_ID_2,
                                   NETWORK_NUMBER_PORT_2, ROUTER_NETWORK_TYPE_IP)) {
        printf("Error: Failed to register router port 2 (network %u, Vermilion 2).\n",
               (unsigned)NETWORK_NUMBER_PORT_2);
        return 1;
    }
    // AddRouterRoute: a static route to DEMO_REMOTE_NETWORK, one hop beyond
    // port 2, with no next-hop MAC configured (NULL/0 - "the relay falls back
    // to the egress link broadcast" per the doc comment). DEMONSTRATION ONLY:
    // see the DEMO_REMOTE_NETWORK comment above - nothing answers on this
    // network in this example series, so the route is announced to network 1
    // but never carries a delivered packet.
    if (!BACnetStack_AddRouterRoute(g_deviceInstance, DEMO_REMOTE_NETWORK,
                                    ROUTER_PORT_ID_2, NULL, 0)) {
        printf("Error: Failed to configure the demonstration route to network %u.\n",
               (unsigned)DEMO_REMOTE_NETWORK);
        return 1;
    }
    // Routing is opt-in even with ports configured (SetRouterEnabled's doc
    // comment: "configuring ports alone does not start forwarding").
    if (!BACnetStack_SetRouterEnabled(g_deviceInstance, true)) {
        printf("Error: Failed to enable routing. (Built without STACK_OPTION_ROUTER_PHYSICAL?)\n");
        return 1;
    }

    // Who-Is is answered automatically on both ports (DM-DDB-B). Broadcast an
    // unsolicited I-Am (cl. 16.10) on EACH network this device is directly
    // reachable from.
    CASExampleHelper::SendIAm(g_deviceInstance, NETWORK_PORT_1_INSTANCE);
    CASExampleHelper::SendIAm(g_deviceInstance, NETWORK_PORT_2_INSTANCE);

    // NM-RC-B: the router start-up sequence per cl. 6.6.2. The stack itself
    // broadcasts I-Am-Router-To-Network on each port on the first Tick, with
    // the per-port network list (it excludes the networks reached through the
    // port it announces on), so main.cpp does not send one at start-up - only
    // on the 'r' key (AnnounceRouterToBothNetworks). The stack hands that
    // announcement to common/'s send callback with no connection string,
    // which common/ (3.2.0 and later) sends to the port's local broadcast address (before
    // 3.2.0 it was dropped and main.cpp had to send its own).
    //
    // What the stack does not send by itself: each network's own number
    // (Network-Number-Is) and a probe of each network for any OTHER router
    // already present (Who-Is-Router-To-Network, unrestricted query). No other
    // router is expected to answer in this example.
    {
        uint8_t cs1[6], cs2[6];
        BuildLocalBroadcastConnectionString(g_bacnetIpUdpPort1, cs1);
        BuildLocalBroadcastConnectionString(g_bacnetIpUdpPort2, cs2);
        BACnetStack_SendNetworkNumberIs(NETWORK_NUMBER_PORT_1, NETWORK_NUMBER_QUALITY_CONFIGURED,
                                        cs1, 6, NETWORK_PORT_1_INSTANCE, true, 0, NULL, 0);
        BACnetStack_SendNetworkNumberIs(NETWORK_NUMBER_PORT_2, NETWORK_NUMBER_QUALITY_CONFIGURED,
                                        cs2, 6, NETWORK_PORT_2_INSTANCE, true, 0, NULL, 0);
        BACnetStack_SendWhoIsRouterToNetwork(0, false, cs1, 6, NETWORK_PORT_1_INSTANCE, true, 0, NULL, 0);
        BACnetStack_SendWhoIsRouterToNetwork(0, false, cs2, 6, NETWORK_PORT_2_INSTANCE, true, 0, NULL, 0);
    }

    printf("FYI: Device %u (\"%s\") ready. Vendor ID %u. Routing network %u (Vermilion, UDP %u) "
           "<-> network %u (Vermilion 2, UDP %u). Press 'h' for help.\n",
           g_deviceInstance, DEVICE_NAME, VENDOR_IDENTIFIER,
           (unsigned)NETWORK_NUMBER_PORT_1, (unsigned)g_bacnetIpUdpPort1,
           (unsigned)NETWORK_NUMBER_PORT_2, (unsigned)g_bacnetIpUdpPort2);

    // --- Run the stack ------------------------------------------------------
    bool running = true;
    while (running) {
        BACnetStack_Tick();

        switch (CASExampleHelper::PollKey()) {
            case CASExampleHelper::KeyCommand::Help:
                CASExampleHelper::PrintHelp(APP_NAME, APP_VERSION);
                break;
            case CASExampleHelper::KeyCommand::Quit:
                running = false;
                break;
            case CASExampleHelper::KeyCommand::ArrowUp:
                g_analogInput1Value += 1.1f;
                printf("Analog Input 1 (Bronze) = %.1f C\n", g_analogInput1Value);
                break;
            case CASExampleHelper::KeyCommand::ArrowDown:
                g_analogInput1Value -= 1.1f;
                printf("Analog Input 1 (Bronze) = %.1f C\n", g_analogInput1Value);
                break;
            case CASExampleHelper::KeyCommand::RouterAnnounce:
                AnnounceRouterToBothNetworks();
                break;
            case CASExampleHelper::KeyCommand::None:
            default:
                break;
        }

#if defined(_WIN32)
        Sleep(1);
#else
        usleep(1000);
#endif
    }

    CASExampleHelper::RestoreInput();
    CASExampleHelper::ShutdownUDP();
    return 0;
}