WriteFociBuffer

WriteFociBuffer is a low-level command that writes a focal point sequence for Foci STM into a bank.

API

Rust

WriteFociBuffer {
    bank,
    start_index,
    points,
};

Python

WriteFociBuffer(
    bank=bank,
    start_index=start_index,
    points=points,
)

C#

new WriteFociBuffer(
    bank: bank,
    startIndex: startIndex,
    points: points
);

Field	Type	Description
bank	PatternBank	Destination bank
start_index	usize	Start index for writing within the bank
points	&[ControlPoints]	Sequence of focal point samples

ControlPoints is one sample holding a sequence of focal points (ControlPoint) and an amplitude. Every sample must have the same number of foci. For details see FociStm.

WriteFociBuffer writes only what fits in one frame. The limit (in ControlPoints) depends on the number of foci and is given by WriteFociBuffer::max_len(num_foci); exceeding it is an error when sending.

Example

An example of playing a focal point sequence as Foci STM via WriteFociBuffer → ConfigFociStm → ActivatePatternBank (equivalent to the high-level FociStm). The 200 points do not fit in one frame, so they are written in pieces.

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