bacnet-server 0.15.0

BACnet server: APDU dispatch and service handlers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! The synchronous WriteProperty and WritePropertyMultiple handlers end a
//! Channel distribution they can't make, so the Channel is never left
//! IN_PROGRESS (#1151, #1178; Clause 12.53).
//!
//! CH-1 writes AO-1's Present_Value; CH-2 has no members.
use super::*;
use bacnet_objects::analog::AnalogOutputObject;
use bacnet_objects::channel::ChannelObject;
use bacnet_services::common::BACnetPropertyValue;
use bacnet_services::wpm::WriteAccessSpecification;
use bacnet_types::constructed::BACnetDeviceObjectPropertyReference;
use bacnet_types::enums::{EngineeringUnits, WriteStatus};

fn ch(instance: u32) -> ObjectIdentifier {
    ObjectIdentifier::new(ObjectType::CHANNEL, instance).unwrap()
}

fn ao1() -> ObjectIdentifier {
    ObjectIdentifier::new(ObjectType::ANALOG_OUTPUT, 1).unwrap()
}

fn database() -> ObjectDatabase {
    let mut db = ObjectDatabase::new();
    db.add(Box::new(
        AnalogOutputObject::new(1, "AO-1", EngineeringUnits::DEGREES_CELSIUS).unwrap(),
    ))
    .unwrap();
    let mut channel = ChannelObject::new(1, "CH-1", 7).unwrap();
    channel
        .set_members(vec![BACnetDeviceObjectPropertyReference::new_local(
            ao1(),
            PropertyIdentifier::PRESENT_VALUE.to_raw(),
        )])
        .unwrap();
    db.add(Box::new(channel)).unwrap();
    db.add(Box::new(ChannelObject::new(2, "CH-2", 8).unwrap()))
        .unwrap();
    db
}

fn real(value: f32) -> Vec<u8> {
    let mut encoded = BytesMut::new();
    encode_property_value(&mut encoded, &PropertyValue::Real(value)).unwrap();
    encoded.to_vec()
}

fn write_pv(db: &mut ObjectDatabase, instance: u32, value: f32) -> ObjectIdentifier {
    let mut request = BytesMut::new();
    WritePropertyRequest {
        object_identifier: ch(instance),
        property_identifier: PropertyIdentifier::PRESENT_VALUE,
        property_array_index: None,
        property_value: real(value),
        priority: Some(8),
    }
    .encode(&mut request)
    .unwrap();
    handle_write_property(db, &request).unwrap()
}

fn read(db: &ObjectDatabase, oid: ObjectIdentifier, property: PropertyIdentifier) -> PropertyValue {
    db.get(&oid).unwrap().read_property(property, None).unwrap()
}

fn write_status(db: &ObjectDatabase, instance: u32) -> WriteStatus {
    match read(db, ch(instance), PropertyIdentifier::WRITE_STATUS) {
        PropertyValue::Enumerated(raw) => WriteStatus::from_raw(raw),
        other => panic!("Write_Status read {other:?}"),
    }
}

fn ended_unmade(db: &ObjectDatabase) {
    assert_eq!(write_status(db, 1), WriteStatus::FAILED);
    // The member wasn't written.
    assert_eq!(
        db.get(&ao1())
            .unwrap()
            .read_property(PropertyIdentifier::PRIORITY_ARRAY, Some(8))
            .unwrap(),
        PropertyValue::Null
    );
}

#[test]
fn bare_write_property_ends_a_channel_distribution_it_cannot_make() {
    let mut db = database();
    assert_eq!(write_pv(&mut db, 1, 3.0), ch(1));
    assert_eq!(
        read(&db, ch(1), PropertyIdentifier::PRESENT_VALUE),
        PropertyValue::Real(3.0)
    );
    ended_unmade(&db);
    // Nothing is left running, so the next write isn't BUSY.
    write_pv(&mut db, 1, 4.0);
    ended_unmade(&db);
    // A Channel without members starts nothing and stays IDLE.
    write_pv(&mut db, 2, 4.0);
    assert_eq!(write_status(&db, 2), WriteStatus::IDLE);
}

#[test]
fn bare_write_property_multiple_ends_the_distributions_its_writes_started() {
    let mut db = database();
    let mut request = BytesMut::new();
    WritePropertyMultipleRequest {
        list_of_write_access_specs: vec![WriteAccessSpecification {
            object_identifier: ch(1),
            list_of_properties: vec![BACnetPropertyValue {
                property_identifier: PropertyIdentifier::PRESENT_VALUE,
                property_array_index: None,
                value: real(5.0),
                priority: Some(8),
            }],
        }],
    }
    .encode(&mut request)
    .unwrap();
    handle_write_property_multiple(&mut db, &request).unwrap();
    ended_unmade(&db);
    write_pv(&mut db, 1, 6.0);
    ended_unmade(&db);
}