SetCpuConfig

SetCpuConfig is a command that changes the settings the CPU firmware uses internally (the failsafe, the watchdog, PTP synchronization parameters, and so on).

Caution

You normally do not need to change anything other than failsafe_timeout and ptp_unlock_failsafe_timeout. Behavior is not guaranteed when any other field is changed from its default.

API

Rust

let config = CpuConfig {
    sync_guard,
    failsafe_timeout,
    ptp_unlock_failsafe_timeout,
    fpga_bus_wait,
    cpu_watchdog_timeout,
    ptp: PtpConfig {
        sync_interval,
        tx_timestamp_timeout,
        delay_resp_timeout,
        holdover,
        lock_samples,
        step_threshold,
        lock_threshold,
        kp_milli,
        ki_milli,
        max_freq_ppb,
        delay_req_syncs,
        path_delay_filter_shift,
        pause_quanta,
        pause_hold_syncs,
        pause_retry,
    },
};
SetCpuConfig::new(config);

Python

config = CpuConfig(
    sync_guard=sync_guard,
    failsafe_timeout=failsafe_timeout,
    ptp_unlock_failsafe_timeout=ptp_unlock_failsafe_timeout,
    fpga_bus_wait=fpga_bus_wait,
    cpu_watchdog_timeout=cpu_watchdog_timeout,
    ptp=PtpConfig(
        sync_interval=sync_interval,
        tx_timestamp_timeout=tx_timestamp_timeout,
        delay_resp_timeout=delay_resp_timeout,
        holdover=holdover,
        lock_samples=lock_samples,
        step_threshold=step_threshold,
        lock_threshold=lock_threshold,
        kp_milli=kp_milli,
        ki_milli=ki_milli,
        max_freq_ppb=max_freq_ppb,
        delay_req_syncs=delay_req_syncs,
        path_delay_filter_shift=path_delay_filter_shift,
        pause_quanta=pause_quanta,
        pause_hold_syncs=pause_hold_syncs,
        pause_retry=pause_retry,
    ),
)
SetCpuConfig(config)

C#

var config = new CpuConfig
{
    SyncGuard = syncGuard,
    FailsafeTimeout = failsafeTimeout,
    PtpUnlockFailsafeTimeout = ptpUnlockFailsafeTimeout,
    FpgaBusWait = fpgaBusWait,
    CpuWatchdogTimeout = cpuWatchdogTimeout,
    Ptp = new PtpConfig
    {
        SyncInterval = syncInterval,
        TxTimestampTimeout = txTimestampTimeout,
        DelayRespTimeout = delayRespTimeout,
        Holdover = holdover,
        LockSamples = lockSamples,
        StepThreshold = stepThreshold,
        LockThreshold = lockThreshold,
        KpMilli = kpMilli,
        KiMilli = kiMilli,
        MaxFreqPpb = maxFreqPpb,
        DelayReqSyncs = delayReqSyncs,
        PathDelayFilterShift = pathDelayFilterShift,
        PauseQuanta = pauseQuanta,
        PauseHoldSyncs = pauseHoldSyncs,
        PauseRetry = pauseRetry,
    },
};
new SetCpuConfig(config);

CpuConfig

Field	Type	Default	Description
sync_guard	Duration	250 μs	Margin for choosing the synchronization start time
failsafe_timeout	Option<Duration>	None	A device stops its output once nothing has arrived from the host for this long (failsafe). None disables the failsafe
ptp_unlock_failsafe_timeout	Option<Duration>	None	A device stops its output once it has been without its PTP lock for this long. None disables it
fpga_bus_wait	FpgaBusWait	Cycles3	Wait cycles of the bus the CPU reads and writes the FPGA through. Cycles2 or Cycles3
cpu_watchdog_timeout	Option<Duration>	1 s	Once the CPU firmware has stopped for this long, the device stops the output. None disables it
ptp	PtpConfig		PTP synchronization parameters

PtpConfig

Field	Type	Default	Description
sync_interval	Duration	8 ms	Interval at which Sync messages are sent
tx_timestamp_timeout	Duration	3 ms	How long to wait for the transmit timestamp of Delay_Req
delay_resp_timeout	Duration	6 ms	How long to wait for Delay_Resp
holdover	Duration	1 s	How long the lock is kept while locked and no Sync arrives
lock_samples	NonZeroU16	64	Number of consecutive samples required to lock
step_threshold	Duration	10 μs	The clock is stepped when the time offset exceeds this
lock_threshold	Duration	100 ns	Samples whose time offset is below this count toward the lock
kp_milli	u32	50	Proportional gain of the servo × 1000
ki_milli	u32	1	Integral gain of the servo × 1000
max_freq_ppb	u32	500,000	Limit of the frequency correction [ppb]. 0 to 2,147,483,647 (the device rejects larger values)
delay_req_syncs	NonZeroU16	32	Interval at which the path delay is measured again once locked (in Sync messages)
path_delay_filter_shift	u8	5	Smoothing factor 1 / 2^n of the path delay. 0 to 16 (the device rejects larger values). 0 disables the smoothing
pause_quanta	Option<NonZeroU16>	48	Length of the PAUSE sent to the host when the link is saturated [512 bit times]. None sends no PAUSE
pause_hold_syncs	u16	64	Number of Sync messages for which a PAUSE keeps being sent on every send after the link was found saturated
pause_retry	Duration	8 ms	How long PAUSE keeps being sent while a Sync cannot be sent out

The settings return to their defaults on Clear and on power cycling. Reopening the client does not reset them.

Example

Rust

use std::time::Duration;

use autd3_rs::commands::{Clear, CpuConfig, SetCpuConfig, Synchronize};
use autd3_rs::geometry::{Autd3, Geometry};
use autd3_rs::Client;
use autd3_rs::udp::TransportOption;

let geometry = Geometry::new(vec![Autd3::default()]);
let option = TransportOption::default();
let mut client = Client::open(&geometry, &option).await?;
client.send(Clear).await?;
client.send(Synchronize).await?;

client.send(SetCpuConfig::new(CpuConfig {
    ptp_unlock_failsafe_timeout: Some(Duration::from_secs(2)),
    ..Default::default()
})).await?;

Python

import asyncio

from autd3 import Client, Duration, TransportOption
from autd3.commands import Clear, CpuConfig, SetCpuConfig, Synchronize
from autd3.geometry import Autd3, Geometry


async def main() -> None:
    geometry = Geometry([Autd3()])
    with await Client.open(geometry, TransportOption()) as client:
        await client.send(Clear())
        await client.send(Synchronize())

        await client.send(SetCpuConfig(CpuConfig(ptp_unlock_failsafe_timeout=Duration.from_secs(2))))


asyncio.run(main())

C#

using System;
using System.Threading.Tasks;
using AUTD3;

var geometry = new Geometry(new[] { new Autd3() });
using var client = await Client.OpenAsync(geometry, new TransportOption());
await client.SendAsync(new Clear());
await client.SendAsync(new Synchronize());

await client.SendAsync(new SetCpuConfig(new CpuConfig { PtpUnlockFailsafeTimeout = TimeSpan.FromSeconds(2) }));