ethercrab 0.7.1

A pure Rust EtherCAT MainDevice supporting std and no_std environments
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
123
124
125
126
127
128
129
130

//! Print SDO Info about the CoE object dictionaries of every device on the bus.
//!
//! Run with e.g.
//!
//! Linux
//!
//! ```bash
//! cargo build --release --example sdo-info
//! # avoid sudo with `sudo setcap cap_net_raw=pe /path/to/sdo-info`
//! RUST_LOG=debug sudo -E ./target/release/sdo-info eth0
//! ```
//!
//! Windows
//!
//! ```ps
//! $env:RUST_LOG="debug" ; cargo run --example ek1100 --release -- '\Device\NPF_{FF0ACEE6-E8CD-48D5-A399-619CD2340465}'
//! ```

use env_logger::Env;
use ethercrab::{
    MainDevice, MainDeviceConfig, ObjectDescriptionListQuery, ObjectDescriptionListQueryCounts,
    PduStorage, Timeouts, error::Error, std::ethercat_now,
};
use std::{sync::Arc, time::Duration};

/// Maximum number of SubDevices that can be stored. This must be a power of 2 greater than 1.
const MAX_SUBDEVICES: usize = 16;
/// Maximum PDU data payload size - set this to the max PDI size or higher.
const MAX_PDU_DATA: usize = PduStorage::element_size(1100);
/// Maximum number of EtherCAT frames that can be in flight at any one time.
const MAX_FRAMES: usize = 16;
/// Maximum total PDI length.
const PDI_LEN: usize = 64;

static PDU_STORAGE: PduStorage<MAX_FRAMES, MAX_PDU_DATA> = PduStorage::new();

fn main() -> Result<(), Error> {
    smol::block_on(async {
        env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();

        let interface = std::env::args()
            .nth(1)
            .expect("Provide network interface as first argument.");

        let (tx, rx, pdu_loop) = PDU_STORAGE.try_split().expect("can only split once");

        let maindevice = Arc::new(MainDevice::new(
            pdu_loop,
            Timeouts {
                wait_loop_delay: Duration::from_millis(2),
                mailbox_response: Duration::from_millis(1000),
                ..Default::default()
            },
            MainDeviceConfig::default(),
        ));

        #[cfg(target_os = "windows")]
        std::thread::spawn(move || {
            ethercrab::std::tx_rx_task_blocking(
                &interface,
                tx,
                rx,
                ethercrab::std::TxRxTaskConfig { spinloop: false },
            )
            .expect("TX/RX task")
        });
        #[cfg(not(target_os = "windows"))]
        smol::spawn(ethercrab::std::tx_rx_task(&interface, tx, rx).expect("spawn TX/RX task"))
            .detach();

        let group = maindevice
            .init_single_group::<MAX_SUBDEVICES, PDI_LEN>(ethercat_now)
            .await
            .expect("Init");

        for subdevice in group.iter(&maindevice) {
            println!("{}:", subdevice.name());
            let object_quantities = subdevice.sdo_info_object_quantities().await?.unwrap_or(
                ObjectDescriptionListQueryCounts {
                    all: 0,
                    rx_pdo_mappable: 0,
                    tx_pdo_mappable: 0,
                    stored_for_device_replacement: 0,
                    startup_parameters: 0,
                },
            );
            println!(
                r#"  object-quantities:
    all: {}
    rx-pdo-mappable: {}
    tx-pdo-mappable: {}
    stored-for-device-replacement: {}
    startup-parameters: {}"#,
                object_quantities.all,
                object_quantities.rx_pdo_mappable,
                object_quantities.tx_pdo_mappable,
                object_quantities.stored_for_device_replacement,
                object_quantities.startup_parameters,
            );

            let addresses = subdevice
                .sdo_info_object_description_list(ObjectDescriptionListQuery::All)
                .await?
                .unwrap_or_default();
            println!("  addresses: {}", address_list(addresses));
        }

        let _group = group.into_init(&maindevice).await.expect("PRE-OP -> INIT");

        log::info!("PRE-OP -> INIT, shutdown complete");

        Ok(())
    })
}

// the string can be as big as 0x1_0000 addresses * 8 char/address.
fn address_list(addresses: heapless::Vec<u16, 0x1_0000>) -> heapless::String<0x8_0000> {
    let mut out = heapless::String::<0x8_0000>::new();
    if addresses.is_empty() {
        out.push_str("[]").unwrap();
        return out;
    }
    out.push('[').expect("longer buffer");
    for address in addresses[..addresses.len() - 1].iter() {
        let _ = out.push_str(&format!("{address:#06x}, "));
    }
    out.push_str(&format!("{:#06x}]", addresses.last().unwrap()))
        .expect("longer buffer");
    out
}