snap7-cli 0.1.0

CLI tool for communicating with Siemens S7 PLCs — read/write data blocks, watch tags, upload blocks, query SZL
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

//! OPC-UA Subscription Demo
//!
//! Connects to the gateway_demo OPC-UA server and subscribes to Temperature,
//! Humidity, and Pressure variables.  Prints every value change notification.
//!
//! Usage:
//!   cargo run --features opcua --bin opcua_subscriber [-- [ENDPOINT]]
//!
//! Defaults to opc.tcp://127.0.0.1:4840/gateway.

use opcua::client::{ClientBuilder, DataChangeCallback, IdentityToken, MonitoredItem};
use opcua::types::{
    DataValue, EndpointDescription, MessageSecurityMode, MonitoredItemCreateRequest, NodeId,
    TimestampsToReturn, UserTokenPolicy,
};
use std::time::Duration;

#[tokio::main]
async fn main() {
    let endpoint_url = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "opc.tcp://127.0.0.1:4840/gateway".to_string());

    println!("=== OPC-UA Subscription Demo ===");
    println!("Connecting to: {endpoint_url}");
    println!();

    let mut client = ClientBuilder::new()
        .application_name("snap7-opcua-subscriber")
        .application_uri("urn:snap7-opcua-subscriber")
        .trust_server_certs(true)
        .session_retry_limit(3)
        .client()
        .expect("failed to build OPC-UA client");

    let endpoint: EndpointDescription = (
        endpoint_url.as_str(),
        "None",
        MessageSecurityMode::None,
        UserTokenPolicy::anonymous(),
    )
        .into();

    let (session, event_loop) = client
        .connect_to_matching_endpoint(endpoint, IdentityToken::Anonymous)
        .await
        .expect("failed to connect to OPC-UA server");

    let handle = event_loop.spawn();

    println!("Waiting for session...");
    session.wait_for_connection().await;
    println!("Connected!\n");

    // Subscribe at 1 s interval — gateway polls PLC every 500 ms
    let sub_id = session
        .create_subscription(
            Duration::from_secs(1),
            10,   // max_notifications_per_publish
            30,   // lifetime_count
            0,    // max_keep_alive_count (server chooses)
            0,    // priority
            true, // publishing_enabled
            DataChangeCallback::new(|value: DataValue, item: &MonitoredItem| {
                let node_name = item.item_to_monitor().node_id.to_string();
                // Extract the string identifier for a cleaner name
                let name = node_name
                    .split("s=")
                    .nth(1)
                    .unwrap_or(&node_name)
                    .trim_end_matches('"');
                match value.value {
                    Some(v) => println!("[notification] {name:<15} = {v:?}"),
                    None => {
                        let status = value
                            .status
                            .map(|s| format!("{s:?}"))
                            .unwrap_or_else(|| "unknown".into());
                        println!("[notification] {name:<15} = <no value, status={status}>");
                    }
                }
            }),
        )
        .await
        .expect("failed to create subscription");

    println!("Subscription {sub_id} created. Monitoring:");

    // Monitor Temperature, Humidity, Pressure (all in namespace 2 as string IDs)
    let node_names = ["Temperature", "Humidity", "Pressure"];
    let items: Vec<MonitoredItemCreateRequest> = node_names
        .iter()
        .map(|name| {
            println!("  ns=2;s={name}");
            NodeId::new(2, *name).into()
        })
        .collect();

    println!();

    let results = session
        .create_monitored_items(sub_id, TimestampsToReturn::Both, items)
        .await
        .expect("failed to create monitored items");

    for (name, result) in node_names.iter().zip(results.iter()) {
        if result.result.status_code.is_good() {
            println!("  ✓ {name} monitored (id={})", result.result.monitored_item_id);
        } else {
            eprintln!("  ✗ {name} failed: {:?}", result.result.status_code);
        }
    }

    println!("\nListening for changes (Ctrl-C to stop)...\n");

    tokio::select! {
        _ = handle => println!("Session closed by server."),
        _ = tokio::signal::ctrl_c() => println!("\nStopping."),
    }
}