WritePatternPhase

WritePatternPhase is a lightweight version of WritePatternBuffer for Patterns whose intensity is shared by every transducer and every Pattern.

API

Rust

WritePatternPhase {
    bank,
    start_index,
    depth,
    intensity,
    patterns,
};

Python

WritePatternPhase(
    bank=bank,
    start_index=start_index,
    depth=depth,
    intensity=intensity,
    patterns=patterns,
)

C#

new WritePatternPhase(
    bank: bank,
    startIndex: startIndex,
    depth: depth,
    intensity: intensity,
    patterns: patterns
);

Field	Type	Description
bank	PatternBank	Destination bank
start_index	usize	Start index for writing within the bank
depth	PhaseDepth	Bit depth of the phase (see below)
intensity	Intensity	Intensity shared by every transducer and Pattern
patterns	&[Vec<Vec<Phase>>]	Sequence of phases to write (1 to depth.max_count() items)

PhaseDepth

Variant	Patterns per frame (max_count())	Description
Bits8	5	Sends the phase at full resolution (8 bit) (default)
Bits4	11	Sends the phase quantized to its upper 4 bits

Example

An example of writing 4 Patterns in a single command with Bits4 and playing them as STM with ConfigPattern + ActivatePatternBank.

Rust

use autd3_rs::commands::{
    ActivatePatternBank, Clear, ConfigPattern, PhaseDepth, Synchronize, WritePatternPhase,
};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{Hz, m, mm, s};
use autd3_rs::value::{Intensity, LoopBehavior, PatternBank, SamplingConfig, TransitionMode};
use autd3_rs::Client;
use autd3_rs::udp::TransportOption;
use autd3_rs_pattern::{focus, wavelength};

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 wavelength = wavelength(340.0 * m / s);
let patterns = [-30.0f32, -10.0, 10.0, 30.0]
    .iter()
    .map(|&x| {
        let mut buffer = geometry.phase_buffer();
        focus(
            &geometry,
            geometry.center() + offset(x * mm, 0.0 * mm, 150.0 * mm),
            wavelength,
            &mut buffer,
        );
        buffer
    })
    .collect::<Vec<_>>();

let bank = PatternBank::B0;

client.send(WritePatternPhase {
    bank,
    start_index: 0,
    depth: PhaseDepth::Bits4,
    intensity: Intensity::MAX,
    patterns: &patterns,
}).await?;
client.send(ConfigPattern {
    bank,
    config: SamplingConfig::from_freq(1.0 * Hz * patterns.len() as f32)?,
    size: patterns.len(),
    loop_behavior: LoopBehavior::Infinite,
}).await?;
client.send(ActivatePatternBank {
    bank,
    transition_mode: TransitionMode::Immediate,
}).await?;

Python

import asyncio

from autd3 import Client, TransportOption
from autd3.commands import ActivatePatternBank, Clear, ConfigPattern, PhaseDepth, Synchronize, WritePatternPhase
from autd3.geometry import Autd3, Geometry, offset
from autd3.units import Hz, m, mm, s
from autd3.value import Intensity, LoopBehavior, PatternBank, SamplingConfig, TransitionMode
from autd3_pattern import focus
from autd3_pattern import wavelength as calc_wavelength


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

        wavelength = calc_wavelength(340 * m / s)
        patterns = []
        for x in (-30.0, -10.0, 10.0, 30.0):
            buffer = geometry.phase_buffer()
            focus(
                geometry,
                geometry.center() + offset(x * mm, 0.0 * mm, 150.0 * mm),
                wavelength,
                buffer,
            )
            patterns.append(buffer)

        bank = PatternBank.B0

        await client.send(
            WritePatternPhase(
                bank=bank,
                start_index=0,
                depth=PhaseDepth.Bits4,
                intensity=Intensity.MAX,
                patterns=patterns,
            )
        )
        await client.send(
            ConfigPattern(
                bank=bank,
                config=SamplingConfig(1.0 * Hz * len(patterns)),
                size=len(patterns),
                loop_behavior=LoopBehavior.Infinite,
            )
        )
        await client.send(
            ActivatePatternBank(
                bank=bank,
                transition_mode=TransitionMode.Immediate,
            )
        )


asyncio.run(main())

C#

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 wavelength = Pattern.Wavelength(340.0f * m / s);
var offsets = new[] { -30.0f, -10.0f, 10.0f, 30.0f };
var patterns = new PhaseBuffer[offsets.Length];
for (var i = 0; i < offsets.Length; i++)
{
    var buffer = geometry.PhaseBuffer();
    Pattern.Focus(
        geometry,
        geometry.Center + Offset(offsets[i] * mm, 0.0f * mm, 150.0f * mm),
        wavelength,
        buffer
    );
    patterns[i] = buffer;
}

var bank = PatternBank.B0;

await client.SendAsync(new WritePatternPhase(
    bank: bank,
    startIndex: 0,
    depth: PhaseDepth.Bits4,
    intensity: Intensity.Max,
    patterns: patterns
));
await client.SendAsync(new ConfigPattern(
    bank: bank,
    config: new SamplingConfig(1.0f * Hz * patterns.Length),
    size: (uint)patterns.Length,
    loopBehavior: LoopBehavior.Infinite
));
await client.SendAsync(new ActivatePatternBank(
    bank: bank,
    transitionMode: TransitionMode.Immediate
));