Native BACnet for your devices and applications

#include "CASBACnetStackAdapter.h"

const uint32_t DEVICE_INSTANCE = 389001;
const uint16_t OBJECT_TYPE_ANALOG_INPUT = 0;
const uint16_t OBJECT_TYPE_BINARY_OUTPUT = 4;
const uint16_t OBJECT_TYPE_MULTI_STATE_VALUE = 19;

// The stack calls this when a client reads a REAL property. Answer from your own data.
bool CallbackGetPropertyReal(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) {
	if (propertyIdentifier == BACnetPropertyIdentifier_presentValue && objectType == OBJECT_TYPE_ANALOG_INPUT && objectInstance == 101) {
		*value = 99.6f;
		return true;
	}
	return false;
}

// Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
uint16_t CallbackReceiveMessage(...) {
	return 0; // ...
}
uint16_t CallbackSendMessage(...) {
	return 0; // ...
}
CASBACnetTime CallbackGetSystemTime() {
	return time(NULL);
}

int main() {
	LoadBACnetFunctions();
	BACnetStack_RegisterCallbackReceiveMessageForPort(CallbackReceiveMessage);
	BACnetStack_RegisterCallbackSendMessageForPort(CallbackSendMessage);
	BACnetStack_RegisterCallbackGetSystemTime(CallbackGetSystemTime);
	BACnetStack_RegisterCallbackGetPropertyReal(CallbackGetPropertyReal);

	BACnetStack_AddDevice(DEVICE_INSTANCE);
	BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_ANALOG_INPUT, 101);
	BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_BINARY_OUTPUT, 102);
	BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_MULTI_STATE_VALUE, 103);

	for (;;) {
		BACnetStack_Tick();
	}
}

using System;
using CASBACnetStack;

unsafe class Hello
{
    const uint DeviceInstance = 389001;

    // The stack calls this when a client reads a REAL property. Answer from your own data.
    static bool GetPropertyReal(uint deviceInstance, ushort objectType, uint objectInstance, uint propertyIdentifier, float* value, bool useArrayIndex, uint propertyArrayIndex, uint* errorCode)
    {
        if (propertyIdentifier == (uint)BACnetPropertyIdentifier.presentValue && objectType == CASBACnetStackAdapter.OBJECT_TYPE_ANALOG_INPUT && objectInstance == 101)
        {
            *value = 99.6f;
            return true;
        }
        return false;
    }

    // Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
    static ushort ReceiveMessage(...)
    {
        return 0; // ...
    }
    static ushort SendMessage(...)
    {
        return 0; // ...
    }
    static long GetSystemTime()
    {
        return DateTimeOffset.UtcNow.ToUnixTimeSeconds();
    }

    static void Main()
    {
        // Keep the delegates in fields or variables that live as long as the stack does.
        var receiveMessage = new CASBACnetStackAdapter.FPCallbackReceiveMessageForPort(ReceiveMessage);
        var sendMessage = new CASBACnetStackAdapter.FPCallbackSendMessageForPort(SendMessage);
        var getSystemTime = new CASBACnetStackAdapter.FPCallbackGetSystemTime(GetSystemTime);
        var getPropertyReal = new CASBACnetStackAdapter.FPCallbackGetPropertyReal(GetPropertyReal);
        CASBACnetStackAdapter.BACnetStack_RegisterCallbackReceiveMessageForPort(receiveMessage);
        CASBACnetStackAdapter.BACnetStack_RegisterCallbackSendMessageForPort(sendMessage);
        CASBACnetStackAdapter.BACnetStack_RegisterCallbackGetSystemTime(getSystemTime);
        CASBACnetStackAdapter.BACnetStack_RegisterCallbackGetPropertyReal(getPropertyReal);

        CASBACnetStackAdapter.BACnetStack_AddDevice(DeviceInstance);
        CASBACnetStackAdapter.BACnetStack_AddObject(DeviceInstance, CASBACnetStackAdapter.OBJECT_TYPE_ANALOG_INPUT, 101);
        CASBACnetStackAdapter.BACnetStack_AddObject(DeviceInstance, CASBACnetStackAdapter.OBJECT_TYPE_BINARY_OUTPUT, 102);
        CASBACnetStackAdapter.BACnetStack_AddObject(DeviceInstance, CASBACnetStackAdapter.OBJECT_TYPE_MULTI_STATE_VALUE, 103);

        for (;;)
        {
            CASBACnetStackAdapter.BACnetStack_Tick();
        }
    }
}

import com.chipkin.bacnet.BACnetConstants;
import com.chipkin.bacnet.CASBACnetStackAdapter;
import com.chipkin.bacnet.ICASBACnetStackLibrary;
import com.sun.jna.Pointer;

public class Hello {
    static final int DEVICE_INSTANCE = 389001;
    static final short OBJECT_TYPE_MULTI_STATE_VALUE = 19;

    public static void main(String[] args) throws Exception {
        ICASBACnetStackLibrary stack = new CASBACnetStackAdapter().getLibrary();

        // Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
        // Keep each callback in a variable that lives as long as the stack does, or JNA may free it.
        ICASBACnetStackLibrary.FPCallbackReceiveMessageForPort receiveMessage = new ICASBACnetStackLibrary.FPCallbackReceiveMessageForPort() {
            public short callback(...) {
                return 0; // ...
            }
        };
        ICASBACnetStackLibrary.FPCallbackSendMessageForPort sendMessage = new ICASBACnetStackLibrary.FPCallbackSendMessageForPort() {
            public short callback(...) {
                return 0; // ...
            }
        };
        ICASBACnetStackLibrary.FPCallbackGetSystemTime getSystemTime = new ICASBACnetStackLibrary.FPCallbackGetSystemTime() {
            public long callback() {
                return System.currentTimeMillis() / 1000L;
            }
        };
        // The stack calls this when a client reads a REAL property. Answer from your own data.
        ICASBACnetStackLibrary.FPCallbackGetPropertyReal getPropertyReal = new ICASBACnetStackLibrary.FPCallbackGetPropertyReal() {
            public byte callback(int deviceInstance, short objectType, int objectInstance, int propertyIdentifier, Pointer value, byte useArrayIndex, int propertyArrayIndex, Pointer errorCode) {
                if (propertyIdentifier == ICASBACnetStackLibrary.BACnetPropertyIdentifier.presentValue && objectType == BACnetConstants.OBJECT_TYPE_ANALOG_INPUT && objectInstance == 101) {
                    value.setFloat(0, 99.6f);
                    return 1;
                }
                return 0;
            }
        };
        stack.BACnetStack_RegisterCallbackReceiveMessageForPort(receiveMessage);
        stack.BACnetStack_RegisterCallbackSendMessageForPort(sendMessage);
        stack.BACnetStack_RegisterCallbackGetSystemTime(getSystemTime);
        stack.BACnetStack_RegisterCallbackGetPropertyReal(getPropertyReal);

        stack.BACnetStack_AddDevice(DEVICE_INSTANCE);
        stack.BACnetStack_AddObject(DEVICE_INSTANCE, BACnetConstants.OBJECT_TYPE_ANALOG_INPUT, 101);
        stack.BACnetStack_AddObject(DEVICE_INSTANCE, BACnetConstants.OBJECT_TYPE_BINARY_OUTPUT, 102);
        stack.BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_MULTI_STATE_VALUE, 103);

        for (;;) {
            stack.BACnetStack_Tick();
        }
    }
}

import ctypes
import time
from CASBACnetStackAdapter import libname, bacnet_objectType
import CASBACnetStackAdapterBindings as bacnet

DEVICE_INSTANCE = 389001

bacnet.bind(ctypes.CDLL(libname))


# The stack calls this when a client reads a REAL property. Answer from your own data.
@bacnet.FPCallbackGetPropertyReal
def get_property_real(device_instance, object_type, object_instance, property_identifier, value, use_array_index, property_array_index, error_code):
    if property_identifier == bacnet.BACnetPropertyIdentifier.presentValue and object_type == bacnet_objectType["analogInput"] and object_instance == 101:
        value[0] = 99.6
        return True
    return False


# Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
@bacnet.FPCallbackReceiveMessageForPort
def receive_message(...):
    return 0  # ...


@bacnet.FPCallbackSendMessageForPort
def send_message(...):
    return 0  # ...


@bacnet.FPCallbackGetSystemTime
def get_system_time():
    return int(time.time())


bacnet.BACnetStack_RegisterCallbackReceiveMessageForPort(receive_message)
bacnet.BACnetStack_RegisterCallbackSendMessageForPort(send_message)
bacnet.BACnetStack_RegisterCallbackGetSystemTime(get_system_time)
bacnet.BACnetStack_RegisterCallbackGetPropertyReal(get_property_real)

bacnet.BACnetStack_AddDevice(DEVICE_INSTANCE)
bacnet.BACnetStack_AddObject(DEVICE_INSTANCE, bacnet_objectType["analogInput"], 101)
bacnet.BACnetStack_AddObject(DEVICE_INSTANCE, bacnet_objectType["binaryOutput"], 102)
bacnet.BACnetStack_AddObject(DEVICE_INSTANCE, bacnet_objectType["multiStateValue"], 103)

while True:
    bacnet.BACnetStack_Tick()

const bacnet = require('@chipkin/cas-bacnet-stack');

const DEVICE_INSTANCE = 389001;
const OBJECT_TYPE_ANALOG_INPUT = 0;
const OBJECT_TYPE_BINARY_OUTPUT = 4;
const OBJECT_TYPE_MULTI_STATE_VALUE = 19;

// Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
bacnet.BACnetStack_RegisterCallbackReceiveMessageForPort((...) => {
    return 0; // ...
});
bacnet.BACnetStack_RegisterCallbackSendMessageForPort((...) => {
    return 0; // ...
});
bacnet.BACnetStack_RegisterCallbackGetSystemTime(() => Math.floor(Date.now() / 1000));

// The stack calls this when a client reads a REAL property. Answer from your own data.
bacnet.BACnetStack_RegisterCallbackGetPropertyReal((deviceInstance, objectType, objectInstance, propertyIdentifier, value, useArrayIndex, propertyArrayIndex, errorCode) => {
    if (propertyIdentifier === bacnet.BACnetPropertyIdentifier.presentValue && objectType === OBJECT_TYPE_ANALOG_INPUT && objectInstance === 101) {
        value.writeFloatLE(99.6, 0);
        return true;
    }
    return false;
});

bacnet.BACnetStack_AddDevice(DEVICE_INSTANCE);
bacnet.BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_ANALOG_INPUT, 101);
bacnet.BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_BINARY_OUTPUT, 102);
bacnet.BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_MULTI_STATE_VALUE, 103);

setInterval(() => bacnet.BACnetStack_Tick(), 10);

package main

/*
#include "CASBACnetStackDLL.h"
*/
import "C"

import (
	"time"

	casbacnetstack "github.com/chipkin/cas-bacnet-stack/adapters/golang"
)

const deviceInstance = 389001
const objectTypeAnalogInput = 0
const objectTypeBinaryOutput = 4
const objectTypeMultiStateValue = 19

// The stack calls this when a client reads a REAL property. Answer from your own data.
func getPropertyReal(deviceInstance uint32, objectType uint16, objectInstance uint32, propertyIdentifier uint32, value *float32, useArrayIndex bool, propertyArrayIndex uint32, errorCode *uint32) bool {
	if propertyIdentifier == C.BACnetPropertyIdentifier_presentValue && objectType == objectTypeAnalogInput && objectInstance == 101 {
		*value = 99.6
		return true
	}
	return false
}

// Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
func receiveMessage(...) uint16 {
	return 0 // ...
}

func sendMessage(...) uint16 {
	return 0 // ...
}

func getSystemTime() int64 {
	return time.Now().Unix()
}

func main() {
	casbacnetstack.CallbackReceiveMessageForPort = receiveMessage
	casbacnetstack.CallbackSendMessageForPort = sendMessage
	casbacnetstack.CallbackGetSystemTime = getSystemTime
	casbacnetstack.CallbackGetPropertyReal = getPropertyReal
	casbacnetstack.RegisterBACnetStackCallbacks()

	C.BACnetStack_AddDevice(deviceInstance)
	C.BACnetStack_AddObject(deviceInstance, objectTypeAnalogInput, 101)
	C.BACnetStack_AddObject(deviceInstance, objectTypeBinaryOutput, 102)
	C.BACnetStack_AddObject(deviceInstance, objectTypeMultiStateValue, 103)

	for {
		C.BACnetStack_Tick()
		time.Sleep(10 * time.Millisecond)
	}
}

use cas_bacnet_stack_adapters::*;
use std::time::{SystemTime, UNIX_EPOCH};

const DEVICE_INSTANCE: u32 = 389001;
const OBJECT_TYPE_ANALOG_INPUT: u16 = 0;
const OBJECT_TYPE_BINARY_OUTPUT: u16 = 4;
const OBJECT_TYPE_MULTI_STATE_VALUE: u16 = 19;

// The stack calls this when a client reads a REAL property. Answer from your own data.
extern "C" fn get_property_real(_device_instance: u32, object_type: u16, object_instance: u32, property_identifier: u32, value: *mut f32, _use_array_index: bool, _property_array_index: u32, _error_code: *mut u32) -> bool {
    if property_identifier == BACnetPropertyIdentifier::presentValue && object_type == OBJECT_TYPE_ANALOG_INPUT && object_instance == 101 {
        unsafe { *value = 99.6 };
        return true;
    }
    false
}

// Your transport: copy one received UDP datagram into the buffer, or return 0 when none is waiting.
extern "C" fn receive_message(...) -> u16 {
    0 // ...
}
extern "C" fn send_message(...) -> u16 {
    0 // ...
}
extern "C" fn get_system_time() -> i64 {
    SystemTime::now().duration_since(UNIX_EPOCH).map(|elapsed| elapsed.as_secs() as i64).unwrap_or(0)
}

fn main() -> BACnetResult<()> {
    load()?;
    BACnetStack_RegisterCallbackReceiveMessageForPort(Some(receive_message))?;
    BACnetStack_RegisterCallbackSendMessageForPort(Some(send_message))?;
    BACnetStack_RegisterCallbackGetSystemTime(Some(get_system_time))?;
    BACnetStack_RegisterCallbackGetPropertyReal(Some(get_property_real))?;

    BACnetStack_AddDevice(DEVICE_INSTANCE)?;
    BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_ANALOG_INPUT, 101)?;
    BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_BINARY_OUTPUT, 102)?;
    BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_MULTI_STATE_VALUE, 103)?;

    loop {
        BACnetStack_Tick()?;
    }
}

#include "cas_bacnet_zephyr.h"
#include "CASBACnetStackAdapter.h"

const uint32_t DEVICE_INSTANCE = 389001;
const uint16_t OBJECT_TYPE_ANALOG_INPUT = 0;

// The stack calls this when a client reads a REAL property. Answer from your own data.
bool CallbackGetPropertyReal(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) {
	if (propertyIdentifier == BACnetPropertyIdentifier_presentValue && objectType == OBJECT_TYPE_ANALOG_INPUT && objectInstance == 101) {
		*value = 99.6f;
		return true;
	}
	return false;
}

// Register the callback, add the device and its objects, then open the data link.
static bool Setup() {
	BACnetStack_RegisterCallbackGetPropertyReal(CallbackGetPropertyReal);
	BACnetStack_AddDevice(DEVICE_INSTANCE);
	BACnetStack_AddObject(DEVICE_INSTANCE, OBJECT_TYPE_ANALOG_INPUT, 101);

	// MS/TP over a UART with an RS-485 driver-enable pin, described in the devicetree.
	const cbz::mstp::Settings mstp = { 10, 38400, 127, 1 };
	return cbz::mstp::Open(1, mstp); // or, for BACnet/IP over Zephyr sockets: cbz::bip::Open(1, 47808)
}

int main() {
	cbz::Start(Setup, NULL);
	return 0;
}