BACnetClientExample.py

import ctypes
import sys
import time
import socket
from io import BlockingIOError

import keyboard
from CASBACnetStackExampleConstants import *
from CASBACnetStackAdapter import *  # Contains all the Enumerations, and callback prototypes
import pathlib

APPLICATION_VERSION = "0.0.1"
SETTING_BACNET_IP_PORT = 47808
SETTING_CLIENT_DEVICE_INSTANCE = 389002
SETTING_DOWNSTREAM_DEVICE_PORT = SETTING_BACNET_IP_PORT
SETTING_DOWNSTREAM_DEVICE_INSTANCE = 389999
SETTING_DEFAULT_DOWNSTREAM_DEVICE_IP_ADDRESS = "192.168.2.217"

downstreamConnectionString = None
invokeId = None
udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udpSocket.bind(('', SETTING_BACNET_IP_PORT))


def DoUserInput():
    """
    Function checks if the user has hit any key and return false if quit key is hit
    :returns false for quit and true for no key hit
    :return:
    """
    action = keyboard.read_key()
    if not action:
        return True
    if action == "q":
        return False
    elif action == "w":
        ExampleWhoIs()
        pass
    elif action == "r":
        ExampleReadProperty()
        pass
    elif action == "u":
        ExampleWriteProperty()
        pass
    elif action == "c":
        ExampleSubscribeCOV()
        pass
    elif action == "t":
        ExampleConfirmedTextMessage()
        pass
    else:
        print("CAS BACnet Stack Client Example v", APPLICATION_VERSION)
        print ("https://github.com/chipkin/BACnetClientExamplePython2.7")
        print ("Usage: BACnetClient {IPAddress}")
        print ("Example: BACnetClient 192.168.1.127")
        print ("Help")
        print ("- Q - Quit")
        print ("- W - Send WhoIs message")
        print("- R - Send Read property messages")
        print ("- U - Send Write property messages")
        print ("- C - Send Subscribe COV Request")
        print("- T - Send Confirmed Text Message Request")
    return True


def WaitForResponse(timeout=3):
    print ("FYI: Waiting for response")
    expireTime = time.time() + timeout

    while time.time() < expireTime:
        CASBACnetStack.BACnetStack_Loop()


def octetStringCopy(source, destination, length, offset=0):
    for i in range(length):
        destination[int(i + offset)] = int(source[i])


def ExampleWhoIs():
    if not downstreamConnectionString:
        print ("Error: Invalid connection string")
        return

    print("Sending WhoIs with no range. timeout=[3]...")
    ctype_connection_string = ctypes.cast(downstreamConnectionString, ctypes.POINTER(ctypes.c_uint8))
    ctype_connection_string_length = ctypes.c_uint8(6)
    ctype_network_type = ctypes.c_uint8(casbacnetstack_networkType["ip"])
    ctype_broadcast = ctypes.c_bool(True)

    CASBACnetStack.BACnetStack_SendWhoIs(ctype_connection_string, ctype_connection_string_length
                                         , ctype_network_type, ctype_broadcast
                                         ,
                                         ctypes.c_uint16(65535), None, ctypes.c_uint8(0))
    # CASBACnetStack.BACnetStack_SendWhoIs(ctypes.c_uint32(downstreamConnectionString, 6, 0, True, 0, None, 0)
    WaitForResponse()
    print("Sending WhoIs with range, low=[389900], high=[389999] 3 second timeout...")
    CASBACnetStack.BACnetStack_SendWhoIsWithLimits(ctypes.c_uint32(389900), ctypes.c_uint32(389999),
                                                   ctype_connection_string, ctype_connection_string_length,
                                                   ctype_network_type, ctype_broadcast, 0,
                                                   None, 0)
    WaitForResponse()
    print("Sending WhoIs to specific network. network=[15], timeout=[3]")
    CASBACnetStack.BACnetStack_SendWhoIs(downstreamConnectionString, 6, 0, True, 15, None, 0)
    WaitForResponse()
    print("Sending WhoIs to broadcast network. network=[65535], timeout=[3]")
    CASBACnetStack.BACnetStack_SendWhoIs(downstreamConnectionString, 6, 0, True, 65535, None, 0)
    #
    WaitForResponse()


def CallbackGetSystemTime():
    return int(time.time())


def ExampleReadProperty():
    print ("Sending Read Property. DeviceID=[" + str(SETTING_DOWNSTREAM_DEVICE_INSTANCE) + "], property=[" + str(
        PROPERTY_IDENTIFIER_ALL) + "], timeout=[3]...")
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_ANALOG_INPUT), ctypes.c_uint32(0),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME), ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_ANALOG_OUTPUT),
                                                 ctypes.c_uint32(1),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_ANALOG_VALUE),
                                                 ctypes.c_uint32(2),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_BINARY_INPUT),
                                                 ctypes.c_uint32(3),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_BINARY_OUTPUT),
                                                 ctypes.c_uint32(4),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_BINARY_VALUE),
                                                 ctypes.c_uint32(5),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_DEVICE),
                                                 ctypes.c_uint32(8),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_MULTI_STATE_INPUT),
                                                 ctypes.c_uint32(13),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_MULTI_STATE_OUTPUT),
                                                 ctypes.c_uint32(14),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_MULTI_STATE_VALUE),
                                                 ctypes.c_uint32(19),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_uint32(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_TREND_LOG),
                                                 ctypes.c_uint32(20),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_BITSTRING_VALUE),
                                                 ctypes.c_uint32(39),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_CHARACTERSTRING_VALUE),
                                                 ctypes.c_uint32(40),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_DATE_VALUE),
                                                 ctypes.c_uint32(42),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_INTEGER_VALUE),
                                                 ctypes.c_uint32(45),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_LARGE_ANALOG_VALUE),
                                                 ctypes.c_uint32(46),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_OCTETSTRING_VALUE),
                                                 ctypes.c_uint32(47),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_POSITIVE_INTEGER_VALUE),
                                                 ctypes.c_uint32(48),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_TIME_VALUE),
                                                 ctypes.c_uint32(50),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_NETWORK_PORT),
                                                 ctypes.c_uint32(56),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_OBJECT_NAME),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_MULTI_STATE_VALUE),
                                                 ctypes.c_uint32(19),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_PRESENT_VALUE),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))

    CASBACnetStack.BACnetStack_SendReadProperty(ctypes.cast(invokeId, ctypes.POINTER(ctypes.c_uint8)),
                                                ctypes.cast(downstreamConnectionString, ctypes.POINTER(ctypes.c_uint8)),
                                                ctypes.c_uint8(6),
                                                ctypes.c_uint8(0),
                                                ctypes.c_uint16(0),
                                                ctypes.cast(None, ctypes.POINTER(ctypes.c_uint8)), ctypes.c_uint8(0))
    WaitForResponse()


def ExampleWriteProperty():
    print("Sending Read Property. AnalogValue, INSTANCE=[2], property=[" + str(PROPERTY_IDENTIFIER_PRESENT_VALUE
                                                                               ) + "], timeout=[3]...")
    CASBACnetStack.BACnetStack_BuildReadProperty(ctypes.c_uint16(OBJECT_TYPE_ANALOG_VALUE),
                                                 ctypes.c_uint32(2),
                                                 ctypes.c_uint32(PROPERTY_IDENTIFIER_PRESENT_VALUE),
                                                 ctypes.c_bool(False),
                                                 ctypes.c_uint32(0))
    CASBACnetStack.BACnetStack_SendReadProperty(ctypes.cast(invokeId, ctypes.POINTER(ctypes.c_uint8)),
                                                ctypes.cast(downstreamConnectionString, ctypes.POINTER(ctypes.c_uint8)),
                                                ctypes.c_uint8(6),
                                                ctypes.c_uint8(0),
                                                ctypes.c_uint16(0),
                                                ctypes.cast(None, ctypes.POINTER(ctypes.c_uint8)), ctypes.c_uint8(0))
    WaitForResponse()

    print("Sending WriteProperty to the Present Value of Analog Value 2...")
    CASBACnetStack.BACnetStack_BuildWriteProperty(4, "1.0", 3, OBJECT_TYPE_ANALOG_VALUE, 2,
                                                  PROPERTY_IDENTIFIER_PRESENT_VALUE, False, 0, False,
                                                  16)
    CASBACnetStack.BACnetStack_SendWriteProperty(invokeId, downstreamConnectionString, 6, 0, 0, None, 0)
    WaitForResponse()

    print("Sending Read Property. AnalogValue, INSTANCE=[2], property=[" + str(PROPERTY_IDENTIFIER_PRESENT_VALUE
                                                                               ) + "], timeout=[3]...")
    CASBACnetStack.BACnetStack_BuildReadProperty(OBJECT_TYPE_ANALOG_VALUE, 2, PROPERTY_IDENTIFIER_PRESENT_VALUE, False,
                                                 0)
    CASBACnetStack.BACnetStack_SendReadProperty(invokeId, downstreamConnectionString, 6, 0, 0, None, 0)
    WaitForResponse()


def ExampleSubscribeCOV():
    timeToLive = 60 * 5
    analogValueProcessIdentifier = 0
    analogInputProcessIdentifier = 1
    print("Sending Subscribe COV Request. Analog Input, INSTANCE=[0], timeToLive = " + str(timeToLive) +
          ", processIdentifier = " + str(analogValueProcessIdentifier))
    CASBACnetStack.BACnetStack_SendSubscribeCOV(invokeId, analogInputProcessIdentifier, OBJECT_TYPE_ANALOG_INPUT, 0,
                                                False, timeToLive,
                                                downstreamConnectionString, 6, 0, 0, None, 0)
    WaitForResponse()

    print("Sending Subscribe COV Request. Analog Value, INSTANCE=[2], timeToLive = " + str(timeToLive) +
          ", processIdentifier = " + str(analogInputProcessIdentifier))
    CASBACnetStack.BACnetStack_SendSubscribeCOV(invokeId, analogValueProcessIdentifier, OBJECT_TYPE_ANALOG_VALUE, 2,
                                                False, timeToLive,
                                                downstreamConnectionString, 6, 0, 0, None, 0)

    WaitForResponse()


def ExampleConfirmedTextMessage():
    useMessageClass = True
    messageClassUnsigned = 5
    messageClassString = ""
    messagePriority = 0
    message = "Hello from the Python client example"

    print("Sending Confirmed Text Message")
    CASBACnetStack.BACnetStack_SendConfirmedTextMessage(invokeId, SETTING_CLIENT_DEVICE_INSTANCE, useMessageClass,
                                                        messageClassUnsigned,
                                                        messageClassString, len(messageClassString), messagePriority,
                                                        message, len(message),
                                                        downstreamConnectionString, 6, 0, 0, None, 0);

    WaitForResponse()


def CallbackReceiveMessage(message, maxMessageLength, receivedConnectionString, maxConnectionStringLength,
                           receivedConnectionStringLength,
                           networkType):
    try:
        data, addr = udpSocket.recvfrom(maxMessageLength)
        print("FYI: Number of bytes received: " + str(len(data)) + " ip address: " + str(addr[0]) + " Port: " + str(
            addr[1]))

        receivedConnectionString = generateAddressString(ip_address=addr[0], port=addr[1])

        receivedConnectionStringLength[0] = 6

        # Convert the received data to a format that CAS BACnet Stack can process.

        for i in range(len(data)):
            message[i] = ord(data[i])

        # Set the network type
        networkType[0] = ctypes.c_uint8(NETWORK_TYPE_IP)
        return len(data)
    except BlockingIOError:
        # No message, We are not waiting for a incoming message so our socket returns a BlockingIOError. This is normal.
        return 0

    # Catch all
    return 0


def CallbackSendMessage(message, messageLength, connectionString, connectionStringLength, networkType, broadcast):
    # Currently we are only supporting IP
    if networkType != casbacnetstack_networkType["ip"]:
        print("Error: Unsupported network type. networkType:", networkType)
        return 0

    # Extract the Connection String from CAS BACnet Stack into an IP address and port.
    udpPort = connectionString[4] * 256 + connectionString[5]
    if broadcast:
        # Use broadcast IP address
        # Set Ip address to broadcast address
        # Enable broadcasting mode
        udpSocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
        ipAddress = '<broadcast>'
    else:
        ipAddress = str(connectionString[0]) + "." + str(connectionString[1]) + "." + str(
            connectionString[2]) + "." + str(connectionString[3])

    # Extract the message from CAS BACnet Stack to a bytearray
    data = bytearray(messageLength)
    for i in range(len(data)):
        data[i] = message[i]

    # Send the message
    udpSocket.sendto(data, (ipAddress, udpPort))
    print ("FYI: Size of bytes sent: " + str(messageLength))

    return messageLength


def generateAddressString(ip_address, port):
    addressString = (ctypes.c_uint8 * 6)()
    octetStringCopy(ip_address.split("."), addressString, 4)
    addressString[4] = int(port / 256)
    addressString[5] = port % 256
    return addressString


def main(arguments):
    print ("CAS BACnet Stack Client Example v" + str(APPLICATION_VERSION) + ".")
    print("https://github.com/chipkin/BACnetClientExamplePython2.7")

    # Print the version information
    print("FYI: CAS BACnet Stack version: " + str(CASBACnetStack.BACnetStack_GetAPIMajorVersion()) + "." +
          str(CASBACnetStack.BACnetStack_GetAPIMinorVersion()) +
          "." + str(CASBACnetStack.BACnetStack_GetAPIPatchVersion()) + "." +
          str(CASBACnetStack.BACnetStack_GetAPIBuildVersion()))
    print("FYI: CAS BACnet Stack python adapter version:" + str(casbacnetstack_adapter_version))

    downstream_Device_ip_address = SETTING_DEFAULT_DOWNSTREAM_DEVICE_IP_ADDRESS
    if len(arguments) >= 1:
        downstream_Device_ip_address = arguments[0]
        print("FYI: Using " + str(downstream_Device_ip_address) + " for the downstream device IP address")

    print("FYI: Registering the callback Functions with the CAS BACnet Stack")
    # ---------------------------------------------------------------------------

    # Note:
    # Make sure you keep references to CFUNCTYPE() objects as long as they are used from C code.
    # ctypes doesn't, and if you don"t, they may be garbage collected, crashing your program when
    # a callback is made
    #
    # Because of garbage collection, the pyCallback**** functions need to stay in scope.
    pyCallbackReceiveMessage = fpCallbackReceiveMessage(CallbackReceiveMessage)
    CASBACnetStack.BACnetStack_RegisterCallbackReceiveMessage(pyCallbackReceiveMessage)
    pyCallbackSendMessage = fpCallbackSendMessage(CallbackSendMessage)
    CASBACnetStack.BACnetStack_RegisterCallbackSendMessage(pyCallbackSendMessage)
    pyCallbackGetSystemTime = fpCallbackGetSystemTime(CallbackGetSystemTime)
    CASBACnetStack.BACnetStack_RegisterCallbackGetSystemTime(pyCallbackGetSystemTime)

    print("Setting up client device. device.instance=[" + str(SETTING_CLIENT_DEVICE_INSTANCE) + "]")
    if not CASBACnetStack.BACnetStack_AddDevice(SETTING_CLIENT_DEVICE_INSTANCE):
        print("Failed to add Device.")
        return False

    print("Created Device.")
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_I_AM, True)
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_I_HAVE, True)
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_WHO_IS, True)
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_WHO_HAS, True)
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_READ_PROPERTY_MULTIPLE, True)
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_WRITE_PROPERTY, True)
    CASBACnetStack.BACnetStack_SetServiceEnabled(SETTING_CLIENT_DEVICE_INSTANCE, SERVICE_WRITE_PROPERTY_MULTIPLE, True)

    print("Generated the connection string for the downstream device. ")

    global downstreamConnectionString
    downstreamConnectionString = generateAddressString(ip_address=downstream_Device_ip_address,
                                                       port=SETTING_DOWNSTREAM_DEVICE_PORT)

    print ("FYI: Entering main loop...")
    while True:
        # CASBACnetStack.BACnetStack_Loop()
        print ("FYI: Waiting for command...")
        if not DoUserInput():
            break
        # Call Sleep to give some time back to the system
        time.sleep(0)


if __name__ == "__main__":
    # Load the shared library into ctypes
    libpath = pathlib.Path().absolute() / libname
    print("FYI: Library path: ", libpath)
    try:
        CASBACnetStack = ctypes.CDLL(str(libpath), mode=ctypes.RTLD_GLOBAL)
    except WindowsError:
        print("Error: Could not find CAS BACnet Stack DLL")
        exit()

    args = sys.argv[1:]
    main(arguments=args)