ConfigFociStm

ConfigFociStm is a low-level command that configures the playback parameters of the Foci STM bank. The settings are only written; send ActivatePatternBank to activate them.

API

Rust

ConfigFociStm {
    bank,
    config,
    size,
    num_foci,
    sound_speed,
    loop_behavior,
};

Python

ConfigFociStm(
    bank=bank,
    config=config,
    size=size,
    num_foci=num_foci,
    sound_speed=sound_speed,
    loop_behavior=loop_behavior,
)

C#

new ConfigFociStm(
    bank: bank,
    config: config,
    size: size,
    numFoci: numFoci,
    soundSpeed: soundSpeed,
    loopBehavior: loopBehavior
);

Field	Type	Description
bank	PatternBank	Target bank
config	SamplingConfig	Playback sampling frequency
size	usize	Number of STM samples
num_foci	u8	Number of focal points per sample (the length of ControlPoints::points)
sound_speed	Velocity	Sound speed used for focal point computation
loop_behavior	LoopBehavior	Playback loop count (Infinite / Finite)

The minimum size is 2.

Example

Rust

use std::f32::consts::PI;

use autd3_rs::commands::{
    ActivatePatternBank, Clear, ConfigFociStm, Synchronize, WriteFociBuffer,
};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{Hz, m, mm, s};
use autd3_rs::value::{ControlPoints, LoopBehavior, PatternBank, SamplingConfig, TransitionMode};
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?;

let center = geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm);
let points: Vec<ControlPoints> = (0..200)
    .map(|i| {
        let theta = 2.0 * PI * i as f32 / 200.0;
        ControlPoints::from(center + offset(30.0 * mm * theta.cos(), 30.0 * mm * theta.sin(), 0.0 * mm))
    })
    .collect();

let bank = PatternBank::B0;

let max_len = WriteFociBuffer::max_len(1);
for (i, chunk) in points.chunks(max_len).enumerate() {
    client.send(WriteFociBuffer {
        bank,
        start_index: i * max_len,
        points: chunk,
    }).await?;
}
client.send(ConfigFociStm {
    bank,
    config: SamplingConfig::from_freq(1.0 * Hz * points.len() as f32)?,
    size: points.len(),
    num_foci: 1,
    sound_speed: 340.0 * m / s,
    loop_behavior: LoopBehavior::Infinite,
}).await?;
client.send(ActivatePatternBank {
    bank,
    transition_mode: TransitionMode::Immediate,
}).await?;

Python

import asyncio
import math

from autd3 import Client, TransportOption
from autd3.commands import ActivatePatternBank, Clear, ConfigFociStm, Synchronize, WriteFociBuffer
from autd3.geometry import Autd3, Geometry, offset
from autd3.units import Hz, m, mm, s
from autd3.value import ControlPoints, LoopBehavior, PatternBank, SamplingConfig, TransitionMode


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

        center = geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm)
        points = []
        for i in range(200):
            theta = 2.0 * math.pi * i / 200
            p = center + offset(30.0 * mm * math.cos(theta), 30.0 * mm * math.sin(theta), 0.0 * mm)
            points.append(ControlPoints(p))

        bank = PatternBank.B0

        max_len = WriteFociBuffer.max_len(1)
        for start_index in range(0, len(points), max_len):
            await client.send(
                WriteFociBuffer(
                    bank=bank,
                    start_index=start_index,
                    points=points[start_index : start_index + max_len],
                )
            )
        await client.send(
            ConfigFociStm(
                bank=bank,
                config=SamplingConfig(1.0 * Hz * len(points)),
                size=len(points),
                num_foci=1,
                sound_speed=340.0 * m / s,
                loop_behavior=LoopBehavior.Infinite,
            )
        )
        await client.send(
            ActivatePatternBank(
                bank=bank,
                transition_mode=TransitionMode.Immediate,
            )
        )


asyncio.run(main())

C#

using System;
using System.Linq;
using System.Threading.Tasks;
using AUTD3;
using static AUTD3.Units;

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());

var center = geometry.Center + Offset(0.0f * mm, 0.0f * mm, 150.0f * mm);
var points = Enumerable.Range(0, 200)
    .Select(i => 2.0f * MathF.PI * i / 200)
    .Select(theta => (ControlPoints)(center + Offset(MathF.Cos(theta) * 30.0f * mm, MathF.Sin(theta) * 30.0f * mm, 0.0f * mm)))
    .ToArray();

var bank = PatternBank.B0;

var maxLen = WriteFociBuffer.MaxLen(1);
for (var startIndex = 0; startIndex < points.Length; startIndex += maxLen)
{
    await client.SendAsync(new WriteFociBuffer(
        bank: bank,
        startIndex: (uint)startIndex,
        points: points[startIndex..Math.Min(startIndex + maxLen, points.Length)]
    ));
}
await client.SendAsync(new ConfigFociStm(
    bank: bank,
    config: new SamplingConfig(1.0f * Hz * points.Length),
    size: (uint)points.Length,
    numFoci: 1,
    soundSpeed: 340.0f * m / s,
    loopBehavior: LoopBehavior.Infinite
));
await client.SendAsync(new ActivatePatternBank(
    bank: bank,
    transitionMode: TransitionMode.Immediate
));