bacnet-client 0.12.0

BACnet async client: TSM, segmentation, discovery, and service APIs
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

use super::*;

use bacnet_encoding::apdu::{decode_apdu, SimpleAck};
use bacnet_services::alarm_event::AcknowledgeAlarmRequest;
use bacnet_transport::loopback::LoopbackTransport;
use bacnet_types::enums::{EventState, ObjectType};
use bacnet_types::primitives::{BACnetTimeStamp, Date, ObjectIdentifier, Time};

fn time(hour: u8) -> BACnetTimeStamp {
    BACnetTimeStamp::Time(Time {
        hour,
        minute: 2,
        second: 3,
        hundredths: 4,
    })
}

fn date_time(day: u8) -> BACnetTimeStamp {
    BACnetTimeStamp::DateTime {
        date: Date {
            year: 126,
            month: 9,
            day,
            day_of_week: 3,
        },
        time: Time {
            hour: 5,
            minute: 6,
            second: 7,
            hundredths: 8,
        },
    }
}

#[tokio::test]
async fn canonical_acknowledge_alarm_preserves_every_caller_supplied_field() {
    let client_mac = vec![0x01];
    let remote_mac = vec![0x02];
    let (client_transport, remote_transport) =
        LoopbackTransport::pair(client_mac, remote_mac.clone());
    let mut remote_network = NetworkLayer::new(remote_transport);
    let mut remote_rx = remote_network.start().await.unwrap();
    let mut client = BACnetClient::generic_builder()
        .transport(client_transport)
        .build()
        .await
        .unwrap();

    let requests = vec![
        AcknowledgeAlarmRequest {
            acknowledging_process_identifier: 11,
            event_object_identifier: ObjectIdentifier::new(ObjectType::ANALOG_INPUT, 1).unwrap(),
            event_state_acknowledged: EventState::HIGH_LIMIT,
            timestamp: BACnetTimeStamp::SequenceNumber(101),
            acknowledgment_source: "sequence-to-time".into(),
            time_of_acknowledgment: time(9),
        },
        AcknowledgeAlarmRequest {
            acknowledging_process_identifier: 22,
            event_object_identifier: ObjectIdentifier::new(ObjectType::ANALOG_OUTPUT, 2).unwrap(),
            event_state_acknowledged: EventState::FAULT,
            timestamp: time(10),
            acknowledgment_source: "time-to-date-time".into(),
            time_of_acknowledgment: date_time(2),
        },
        AcknowledgeAlarmRequest {
            acknowledging_process_identifier: 33,
            event_object_identifier: ObjectIdentifier::new(ObjectType::EVENT_ENROLLMENT, 3)
                .unwrap(),
            event_state_acknowledged: EventState::NORMAL,
            timestamp: date_time(3),
            acknowledgment_source: "date-time-to-sequence".into(),
            time_of_acknowledgment: BACnetTimeStamp::SequenceNumber(303),
        },
    ];
    let expected = requests.clone();

    let responder = tokio::spawn(async move {
        for expected_request in expected {
            let received = timeout(Duration::from_secs(1), remote_rx.recv())
                .await
                .expect("remote timed out")
                .expect("remote channel closed");
            let Apdu::ConfirmedRequest(request) = decode_apdu(received.apdu).unwrap() else {
                panic!("expected ConfirmedRequest");
            };
            assert_eq!(
                request.service_choice,
                ConfirmedServiceChoice::ACKNOWLEDGE_ALARM
            );
            assert_eq!(
                AcknowledgeAlarmRequest::decode(&request.service_request).unwrap(),
                expected_request
            );

            let mut ack = BytesMut::new();
            encode_apdu(
                &mut ack,
                &Apdu::SimpleAck(SimpleAck {
                    invoke_id: request.invoke_id,
                    service_choice: request.service_choice,
                }),
            )
            .unwrap();
            remote_network
                .send_apdu(&ack, &received.source_mac, false, NetworkPriority::NORMAL)
                .await
                .unwrap();
        }
        remote_network.stop().await.unwrap();
    });

    for request in &requests {
        client
            .acknowledge_alarm_request(&remote_mac, request)
            .await
            .unwrap();
    }

    responder.await.unwrap();
    client.stop().await.unwrap();
}