ethercrab-rs / ethercrab Goto Github PK

// was doing this:  implicitely a usize I guess, implying u64
slave.write_sdo(0x1c12, SubIndex::Index(1), 0x1600).await?;
// instead of this: u16
slave.write_sdo(0x1c12, SubIndex::Index(1), 0x1600_u16).await?;

// Only has a `split` method
let client = ClientMaker::new(...);

// Only allows splitting once
let (tx, rx, client) = client.split();

// Or put them in the same thread, at your option
thread::spawn(move || { tx });
thread::spawn(move || { rx });

// App logic with `client` here

struct Groups {
    slow_outputs: SlaveGroup<2, 2>,
    fast_outputs: SlaveGroup<1, 1>,
}

impl SlaveGroupContainer for Groups {
    fn num_groups(&self) -> usize {
        2
    }

    fn group(&mut self, index: usize) -> Option<SlaveGroupRef> {
        match index {
            0 => Some(self.slow_outputs.as_mut_ref()),
            1 => Some(self.fast_outputs.as_mut_ref()),
            _ => None,
        }
    }
}

#[derive(ethercrab::SlaveGroupContainer)]
struct Groups {
    slow_outputs: SlaveGroup<2, 2>,
    fast_outputs: SlaveGroup<1, 1>,
}

let (r1, r2) = smol::future::zip(
    f1(&client),
    f2(&client),
)
.await;

ydejonghe@UBUNTU:~/ethercat/ethercrab$ sudo RUST_LOG=debug target/debug/examples/ec400
[2023-03-14T13:55:29Z INFO  ec400] Starting SDO demo...
[2023-03-14T13:55:29Z DEBUG ethercrab::slave] Slave 0x1000 name R88D-1SN04H-ECT
[2023-03-14T13:55:29Z DEBUG ethercrab::client] Configuring topology/distributed clocks
[2023-03-14T13:55:29Z DEBUG ethercrab::dc] Slave 0x1000 R88D-1SN04H-ECT has DC
[2023-03-14T13:55:29Z DEBUG ethercrab::dc] --> Times 39335733 (2139694680) 2179030413 (0) 0 (1819436374) 1819436374
[2023-03-14T13:55:29Z DEBUG ethercrab::dc] --> Propagation time None ns, child delay 0 ns
[2023-03-14T13:55:29Z DEBUG ethercrab::dc] Distributed clock config complete
[2023-03-14T13:55:29Z DEBUG ethercrab::dc] Performing static drift compensation using slave 0x1000 R88D-1SN04H-ECT as reference. This can take some time...
[2023-03-14T13:55:31Z DEBUG ethercrab::dc] Static drift compensation complete
[2023-03-14T13:55:31Z DEBUG ethercrab::slave_group::configurator] Going to configure group, starting PDI offset 0x000000
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] Discovered sync managers:
    [
        SyncManager {
            start_addr: 0x1800,
            length: 0x0100,
            control: Control {
                operation_mode: Mailbox,
                direction: MasterWrite,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: MailboxWrite,
        },
        SyncManager {
            start_addr: 0x1c00,
            length: 0x0100,
            control: Control {
                operation_mode: Mailbox,
                direction: MasterRead,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: MailboxRead,
        },
        SyncManager {
            start_addr: 0x1100,
            length: 0x000c,
            control: Control {
                operation_mode: Normal,
                direction: MasterWrite,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: true,
            },
            enable: ENABLE,
            usage_type: ProcessDataWrite,
        },
        SyncManager {
            start_addr: 0x1200,
            length: 0x001c,
            control: Control {
                operation_mode: Normal,
                direction: MasterRead,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: ProcessDataRead,
        },
    ]
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 SM0: start 0x1800, size 0x0100 (256), direction MasterWrite, mode Mailbox, enabled
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 SM1: start 0x1c00, size 0x0100 (256), direction MasterRead, mode Mailbox, enabled
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::slave_client] Set state Pre-Operational for slave address 0x1000
[2023-03-14T13:55:31Z INFO  ec400] Found "R88D-1SN04H-ECT\0\0\0\0\0"
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] Discovered sync managers:
    [
        SyncManager {
            start_addr: 0x1800,
            length: 0x0100,
            control: Control {
                operation_mode: Mailbox,
                direction: MasterWrite,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: MailboxWrite,
        },
        SyncManager {
            start_addr: 0x1c00,
            length: 0x0100,
            control: Control {
                operation_mode: Mailbox,
                direction: MasterRead,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: MailboxRead,
        },
        SyncManager {
            start_addr: 0x1100,
            length: 0x000c,
            control: Control {
                operation_mode: Normal,
                direction: MasterWrite,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: true,
            },
            enable: ENABLE,
            usage_type: ProcessDataWrite,
        },
        SyncManager {
            start_addr: 0x1200,
            length: 0x001c,
            control: Control {
                operation_mode: Normal,
                direction: MasterRead,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: ProcessDataRead,
        },
    ]
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] Discovered FMMUs:
    [
        Outputs,
        Inputs,
        SyncManagerStatus,
        Unused,
    ]
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] FMMU mappings: []
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 has CoE: true
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] Discovered PDOs:
    [
        Pdo {
            index: 0x1b01,
            num_entries: 9,
            sync_manager: 3,
            dc_sync: 0,
            name_string_idx: 3,
            flags: PDO_DEFAULT | PDO_FIXED_CONTENT,
            entries: [
                PdoEntry {
                    index: 0x603f,
                    sub_index: 0,
                    name_string_idx: 4,
                    data_type: U16,
                    data_length_bits: 16,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x6041,
                    sub_index: 0,
                    name_string_idx: 5,
                    data_type: U16,
                    data_length_bits: 16,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x6064,
                    sub_index: 0,
                    name_string_idx: 6,
                    data_type: I32,
                    data_length_bits: 32,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x6077,
                    sub_index: 0,
                    name_string_idx: 7,
                    data_type: I16,
                    data_length_bits: 16,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60f4,
                    sub_index: 0,
                    name_string_idx: 8,
                    data_type: I32,
                    data_length_bits: 32,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60b9,
                    sub_index: 0,
                    name_string_idx: 9,
                    data_type: U16,
                    data_length_bits: 16,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60ba,
                    sub_index: 0,
                    name_string_idx: 10,
                    data_type: I32,
                    data_length_bits: 32,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60bc,
                    sub_index: 0,
                    name_string_idx: 11,
                    data_type: I32,
                    data_length_bits: 32,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60fd,
                    sub_index: 0,
                    name_string_idx: 12,
                    data_type: U32,
                    data_length_bits: 32,
                    flags: 0,
                },
            ],
        },
    ]
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 SM3: start 0x1200, size 0x001c (28), direction MasterRead, mode Normal, enabled
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 FMMU1: logical start 0x00000000:0, size 28, logical end bit 7, physical start 0x1200:0, RO, enabled
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 PDI inputs: PdiSegment { bytes: 0..28, bit_len: 224 } (28 bytes), outputs: PdiSegment { bytes: 0..0, bit_len: 0 } (0 bytes)
[2023-03-14T13:55:31Z DEBUG ethercrab::slave_group::configurator] Slave mailboxes configured and init hooks called
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] Discovered sync managers:
    [
        SyncManager {
            start_addr: 0x1800,
            length: 0x0100,
            control: Control {
                operation_mode: Mailbox,
                direction: MasterWrite,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: MailboxWrite,
        },
        SyncManager {
            start_addr: 0x1c00,
            length: 0x0100,
            control: Control {
                operation_mode: Mailbox,
                direction: MasterRead,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: MailboxRead,
        },
        SyncManager {
            start_addr: 0x1100,
            length: 0x000c,
            control: Control {
                operation_mode: Normal,
                direction: MasterWrite,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: true,
            },
            enable: ENABLE,
            usage_type: ProcessDataWrite,
        },
        SyncManager {
            start_addr: 0x1200,
            length: 0x001c,
            control: Control {
                operation_mode: Normal,
                direction: MasterRead,
                ecat_event_enable: false,
                dls_user_event_enable: true,
                watchdog_enable: false,
            },
            enable: ENABLE,
            usage_type: ProcessDataRead,
        },
    ]
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] Discovered FMMUs:
    [
        Outputs,
        Inputs,
        SyncManagerStatus,
        Unused,
    ]
[2023-03-14T13:55:31Z DEBUG ethercrab::eeprom] FMMU mappings: []
[2023-03-14T13:55:31Z DEBUG ethercrab::slave::configurator] Slave 0x1000 has CoE: true
[2023-03-14T13:55:32Z DEBUG ethercrab::eeprom] Discovered PDOs:
    [
        Pdo {
            index: 0x1701,
            num_entries: 4,
            sync_manager: 2,
            dc_sync: 0,
            name_string_idx: 13,
            flags: PDO_DEFAULT | PDO_FIXED_CONTENT,
            entries: [
                PdoEntry {
                    index: 0x6040,
                    sub_index: 0,
                    name_string_idx: 14,
                    data_type: U16,
                    data_length_bits: 16,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x607a,
                    sub_index: 0,
                    name_string_idx: 15,
                    data_type: I32,
                    data_length_bits: 32,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60b8,
                    sub_index: 0,
                    name_string_idx: 16,
                    data_type: U16,
                    data_length_bits: 16,
                    flags: 0,
                },
                PdoEntry {
                    index: 0x60fe,
                    sub_index: 1,
                    name_string_idx: 17,
                    data_type: U32,
                    data_length_bits: 32,
                    flags: 0,
                },
            ],
        },
    ]
[2023-03-14T13:55:32Z DEBUG ethercrab::slave::configurator] Slave 0x1000 SM2: start 0x1100, size 0x000c (12), direction MasterWrite, mode Normal, enabled
[2023-03-14T13:55:32Z DEBUG ethercrab::slave::configurator] Slave 0x1000 FMMU0: logical start 0x0000001c:0, size 12, logical end bit 7, physical start 0x1100:0, W, enabled
[2023-03-14T13:55:32Z DEBUG ethercrab::slave::configurator] Slave 0x1000 PDI inputs: PdiSegment { bytes: 0..28, bit_len: 224 } (28 bytes), outputs: PdiSegment { bytes: 28..40, bit_len: 96 } (12 bytes)
[2023-03-14T13:55:32Z DEBUG ethercrab::slave::slave_client] Set state Safe-Operational for slave address 0x1000
[2023-03-14T13:55:32Z DEBUG ethercrab::slave_group::configurator] Slave FMMUs configured for group. Able to move to SAFE-OP
[2023-03-14T13:55:32Z DEBUG ethercrab::slave_group::configurator] Group PDI length: start 0, 40 total bytes (28 input bytes)
[2023-03-14T13:55:32Z DEBUG ethercrab::client] After group #0 offset: PdiOffset { start_address: 40, start_bit: 0 }
[2023-03-14T13:55:32Z DEBUG ethercrab::client] Total PDI 40 bytes
[2023-03-14T13:55:32Z INFO  ec400] Slaves moved to OP state
[2023-03-14T13:55:32Z INFO  ec400] Group has 1 slaves
[2023-03-14T13:55:32Z INFO  ec400] -> Slave 4096 R88D-1SN04H-ECT inputs: 28 bytes, outputs: 12 bytes
[2023-03-14T13:55:32Z INFO  ec400] Cycle time: 2 ms
[2023-03-14T13:55:32Z DEBUG ethercrab::ds402] Edge READY_TO_SWITCH_ON | SWITCHED_ON | WARNING | STO | REMOTE | TARGET_REACHED | INTERNAL_LIMIT | OP_SPECIFIC_1 | OP_SPECIFIC_2 | MAN_SPECIFIC_1 | MAN_SPECIFIC_2

<2min>

thread 'main' panicked at 'TX/RX: Pdu(InvalidFrameState)', examples/ec400.rs:188:36
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

use async_io::Timer;
use ethercrab::{
    ds402::{Ds402, Ds402Sm},
    error::Error,
    std::tx_rx_task,
    Client, PduLoop, PduStorage, SlaveGroup, SlaveState, SubIndex, Timeouts,
};
use futures_lite::StreamExt;
use smol::LocalExecutor;
use std::{
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc,
    },
    time::Duration,
};

#[cfg(target_os = "windows")]
// ASRock NIC
// const INTERFACE: &str = "TODO";
// // USB NIC
// const INTERFACE: &str = "\\Device\\NPF_{DCEDC919-0A20-47A2-9788-FC57D0169EDB}";
// Lenovo USB-C NIC
const INTERFACE: &str = "\\Device\\NPF_{CC0908D5-3CB8-46D6-B8A2-575D0578008D}";
// Silver USB NIC
// const INTERFACE: &str = "\\Device\\NPF_{CC0908D5-3CB8-46D6-B8A2-575D0578008D}";
#[cfg(not(target_os = "windows"))]
const INTERFACE: &str = "eno1";

const MAX_SLAVES: usize = 16;
const MAX_PDU_DATA: usize = 1100;
const MAX_FRAMES: usize = 16;
const PDI_LEN: usize = 256;

static PDU_STORAGE: PduStorage<MAX_FRAMES, MAX_PDU_DATA> = PduStorage::new();
static PDU_LOOP: PduLoop = PduLoop::new(PDU_STORAGE.as_ref());

async fn main_inner(ex: &LocalExecutor<'static>) -> Result<(), Error> {
    log::info!("Starting SDO demo...");

    let client = Arc::new(Client::new(&PDU_LOOP, Timeouts::default()));

    ex.spawn(tx_rx_task(INTERFACE, &client).unwrap()).detach();

    let running = Arc::new(AtomicBool::new(true));
    let r = running.clone();

    ctrlc::set_handler(move || {
        r.store(false, Ordering::SeqCst);
    })
    .expect("Error setting Ctrl-C handler");

    // let num_slaves = client.num_slaves();

    let groups = SlaveGroup::<MAX_SLAVES, PDI_LEN>::new(|slave| {
        Box::pin(async {
            // --- Reads ---

            // // Name
            // dbg!(slave
            //     .read_sdo::<heapless::String<64>>(0x1008, SdoAccess::Index(0))
            //     .await
            //     .unwrap());

            // // Software version. For AKD, this should equal "M_01-20-00-003"
            // dbg!(slave
            //     .read_sdo::<heapless::String<64>>(0x100a, SdoAccess::Index(0))
            //     .await
            //     .unwrap());

            // --- Writes ---

            log::info!("Found {:?}", slave.name());

//             if slave.name() == "R88D-1SN04H-ECT\0\0\0\0\0" {
			if slave.name() == "ZeroErr Driver" {
				log::info!("  using it");
                // CSV described a bit better in section 7.6.2.2 Related Objects of the manual
                slave.write_sdo(0x1600, SubIndex::Index(0), 0u8).await?;
                // Control word, u16
                // NOTE: The lower word specifies the field length
                slave
                    .write_sdo(0x1600, SubIndex::Index(1), 0x6040_0010u32)
                    .await?;
                // Target velocity, i32
                slave
                    .write_sdo(0x1600, SubIndex::Index(2), 0x60ff_0020u32)
                    .await?;
                slave.write_sdo(0x1600, SubIndex::Index(0), 2u8).await?;

                slave.write_sdo(0x1a00, SubIndex::Index(0), 0u8).await?;
                // Status word, u16
                slave
                    .write_sdo(0x1a00, SubIndex::Index(1), 0x6041_0010u32)
                    .await?;
                // Actual position, i32
                slave
                    .write_sdo(0x1a00, SubIndex::Index(2), 0x6064_0020u32)
                    .await?;
                // Actual velocity, i32
                slave
                    .write_sdo(0x1a00, SubIndex::Index(3), 0x606c_0020u32)
                    .await?;
                slave.write_sdo(0x1a00, SubIndex::Index(0), 0x03u8).await?;

               // commented to avoid too big frame issue
//                 slave.write_sdo(0x1c12, SubIndex::Index(0), 0u8).await?;
//                 slave.write_sdo(0x1c12, SubIndex::Index(1), 0x1600).await?;
//                 slave.write_sdo(0x1c12, SubIndex::Index(0), 1u8).await?;
// 
//                 slave.write_sdo(0x1c13, SubIndex::Index(0), 0u8).await?;
//                 slave.write_sdo(0x1c13, SubIndex::Index(1), 0x1a00).await?;
//                 slave.write_sdo(0x1c13, SubIndex::Index(0), 1u8).await?;

                // Opmode - Cyclic Synchronous Position
                // slave.write_sdo(0x6060, SubIndex::Index(0), 0x08).await?;
                // Opmode - Cyclic Synchronous Velocity
                slave.write_sdo(0x6060, SubIndex::Index(0), 0x09u8).await?;
            }

            Ok(())
        })
    });

    let group = client
        .init::<16, _>(groups, |groups, slave| groups.push(slave))
        .await
        .expect("Init");

    client
        .request_slave_state(SlaveState::Op)
        .await
        .expect("OP");

    log::info!("Slaves moved to OP state");

    log::info!("Group has {} slaves", group.len());

    for slave in group.slaves() {
        let (i, o) = slave.io();

        log::info!(
            "-> Slave {} {} inputs: {} bytes, outputs: {} bytes",
            slave.configured_address,
            slave.name,
            i.len(),
            o.len(),
        );
    }

    // Run twice to prime PDI
    group.tx_rx(&client).await.expect("TX/RX");

    let cycle_time = {
        let slave = group.slave(0).unwrap();

        let base = slave
            .read_sdo::<u8>(&client, 0x60c2, SubIndex::Index(1))
            .await?;
        let x10 = slave
            .read_sdo::<i8>(&client, 0x60c2, SubIndex::Index(2))
            .await?;

        let base = f32::from(base);
        let x10 = 10.0f32.powi(i32::from(x10));

        let cycle_time_ms = (base * x10) * 1000.0;

        Duration::from_millis(unsafe { cycle_time_ms.round().to_int_unchecked() })
    };

    log::info!("Cycle time: {} ms", cycle_time.as_millis());

    // AKD will error with F706 if cycle time is not 2ms or less
    let mut cyclic_interval = Timer::interval(cycle_time);

    let slave = group.slave(0).expect("No servo!");
    let mut servo = Ds402Sm::new(Ds402::new(slave).expect("Failed to gather DS402"));

    let mut velocity: i32 = 0;

    // let mut slave = group.slave(0, &client).unwrap();

    let accel = 300;

    while let Some(_) = cyclic_interval.next().await {
        group.tx_rx(&client).await.expect("TX/RX");

        if servo.tick() {
            // // Opmode - Cyclic Synchronous Position
            // servo
            //     .sm
            //     .context()
            //     .slave
            //     .write_sdo(&client, 0x6060, SubIndex::Index(0), 0x08u8)
            //     .await?;

            let status = servo.status_word();
            let (i, o) = servo.slave().io();

            let (pos, vel) = {
                let pos = i32::from_le_bytes(i[2..=5].try_into().unwrap());
                let vel = i32::from_le_bytes(i[6..=9].try_into().unwrap());

                (pos, vel)
            };

            println!(
                "Position: {pos}, velocity: {vel}, status: {status:?} | {:?}",
                o
            );

            let pos_cmd = &mut o[2..=5];

            pos_cmd.copy_from_slice(&velocity.to_le_bytes());

            if running.load(Ordering::SeqCst) {
                if vel < 200_000 {
                    velocity += accel;
                }
            } else if vel > 0 {
                velocity -= accel;
            } else {
                break;
            }
        }
    }

    log::info!("Servo stopped, shutting drive down");

    while let Some(_) = cyclic_interval.next().await {
        group.tx_rx(&client).await.expect("TX/RX");

        if servo.tick_shutdown() {
            break;
        }

        let status = servo.status_word();
        let (i, o) = servo.slave().io();

        let (pos, vel) = {
            let pos = i32::from_le_bytes(i[2..=5].try_into().unwrap());
            let vel = i32::from_le_bytes(i[6..=9].try_into().unwrap());

            (pos, vel)
        };

        println!(
            "Position: {pos}, velocity: {vel}, status: {status:?} | {:?}",
            o
        );
    }

    Ok(())
}

fn main() -> Result<(), Error> {
    env_logger::init();
    let local_ex = LocalExecutor::new();

    futures_lite::future::block_on(local_ex.run(main_inner(&local_ex))).unwrap();

    Ok(())
}

let whatever= slave
    .sdo_read::<heapless::String<128>>(0x10e2, 0x01)
    .await
    .map(|s| s.to_string())?;

/// an instance of this refers to some data in a datagram
struct Field<T: PduData> {
  pub byte: usize,   // start byte offset in the datagram
  pub bit: u8,    // start bit offset in the start byte
  pub bitlen: usize,  // bit length of the value after the start byte
}

/// an instance of this refers to an SDO item or subitem
struct Sdo<T: PduData> {
  pub index: u16,
  pub sub: u8,
}

impl Field<T> {
  fn get(&self, data: &[u8]) -> T
  fn set(&self, data: &mut [u8], value: T)
}

impl Sdo<T> {
  async fn get(&self, slave: &SlaveRef) -> Result<T> 
  async fn set(&self, slave: &SlaveRef, value: T) -> Result<()>
}

impl [u8] {
  fn get(&self, key: &Field<T>) -> T
  fn set(&mut self, key: &Field<T>, value: T)
}

impl Slave {
  async fn get(&self, sdo: &Sdo<T>) -> Result<T>
  async fn set(&self, sdo: &Sdo<T>, value: T) -> Result<()>
}

/// in a declaration file
let operation_mode = Sdo::<u16> {index: 0x6040, sub: 0};
let position = Sdo::<i32> {index: 0x6064, sub: 0};
/// in user code
operation_mode.set(slave, OperationMode::SynchronousPosition as u16).await?;
let p = position.get(slave);

struct ConfigurablePdo {
  index: u16,  // sdo address
  num: u8, // number of sdo subitems that can be mapped
}

// helper to init a sync manager mapping, compute and increment mapped fields offsets
struct SyncMapping {...}
impl SyncMapping {
  fn push(&mut self, sdo: &ConfigurablePdo) -> PdoMapping
  fn finish(&mut self)
}
// helper to init a pdo mapping, compute and increment mapped fields offsets
struct PdoMapping {...}
impl PdoMapping {
  // produce a Field pointing to where the sdo subitem will be in the received/transmitted datagram, so the user can use it to easily get/set the value in the datagram
  fn push(&mut self, sdo: &Sdo<T>) -> Field<T>
  fn finish(&mut self)
}

// in declaration file
let profile = { // some big nested struct of helpers and Sdo<T> ...
		mode: Sdo::<u16> {index: 0x6060, sub: 0},
		current: ProfileCurrent {
			status: Sdo::<u16> {index: 0x6041, sub: 0},
			error: Sdo::<u16> {index: 0x603f, sub: 0},
			position: Sdo::<i32> {index: 0x6064, sub: 0},
			velocity: Sdo::<i32> {index: 0x606c, sub: 0},
			force: Sdo::<i16> {index: 0x6077, sub: 0},
			},
		target: ProfileTarget {
			control: Sdo::<u16> {index: 0x6040, sub: 0},
			position: Sdo::<i32> {index: 0x607a, sub: 0},
			velocity: Sdo::<i32> {index: 0x60ff, sub: 0},
			force: Sdo::<i16> {index: 0x6071, sub: 0},
			},
		period: ProfilePeriod {
			digits: Sdo::<u8> {index: 0x60c2, sub: 1},
			exponent: Sdo::<i8> {index: 0x60c2, sub: 2},
			},
		pdo: [
			ConfigurablePdo {index: 0x1600, num: 3},
			ConfigurablePdo {index: 0x1a00, num: 3},
			],
		rx: SyncManager {index: 0x1c12, num: 3},
		tx: SyncManager {index: 0x1c13, num: 3},
  };

// in pre-op mode
let mapping = slave.mapping(profile.tx).await?;     // start configuring sync manager mapping
let pdo = mapping.push(&profile.pdo[0]).await?;    // add a PDO and start configure it
current_status = pdo.push(&profile.current.status).await?;   // set next (first) object to status SDO
current_position = pdo.count(&profile.current.position).await?;   // assume next (second) object is position SDO
pdo.finish().await?;
mapping.finish().await?;

// in op mode
let (i, o) = slave.io();    // i and o are actually datagrams, respectively &[u8] and &mut [u8]
let status = current_status.get(i);
let pos = current_position.get(i);
target_position.set(o, pos+some_increment);

let config = {/* data defining the mapping to set */}
let mut offsets = {/* data containing the pdo entries offsets deduced from mapping */}
let groups = SlaveGroup::<MAX_SLAVES, PDI_LEN>::new(|slave| {
    Box::pin(async {
        // use config to write the correct SDOS
        something(config, slave)
        // compute the corresponding offsets
        offsets = something(config, slave)
});
// use offsets to extract entries from the process data