WritePatternBuffer

WritePatternBuffer is a low-level command that writes a Pattern (the phase and intensity of each transducer) to the specified bank and index. On the wire the phases are sent first, followed by the intensities, and the device CPU interleaves them per transducer when writing the FPGA memory.

API

Rust

WritePatternBuffer::new(bank, index, phases, intensities);

Python

WritePatternBuffer(
    bank=bank,
    index=index,
    phases=phases,
    intensities=intensities,
)

C#

new WritePatternBuffer(
    bank: bank,
    index: index,
    phases: phases,
    intensities: intensities
);

Field	Type	Description
bank	PatternBank	Destination bank
index	u16	Destination index for writing within the bank
phases	&[Vec<Phase>]	Per-device phases
intensities	PatternIntensity	Intensity (a uniform Intensity, or a per-device &[Vec<Intensity>] buffer)

Example

Multiple low-level commands are sent together in a single datagram. The following is an example of playing a single Pattern via WritePatternBuffer → ConfigPattern → ChangePatternBank (equivalent to the high-level Pattern).

Rust

use core::num::NonZeroU16;

use autd3_rs::commands::{ChangePatternBank, ConfigPattern, WritePatternBuffer};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{m, mm, s};
use autd3_rs::value::{Intensity, LoopBehavior, PatternBank, SamplingConfig, TransitionMode};
use autd3_rs::{Client, ClientConfig};
use autd3_rs_link_nop::Nop;
use autd3_rs_pattern::{focus, wavelength};

let geometry = Geometry::new(vec![Autd3::default()]);
let client = Client::open(&geometry, Nop, ClientConfig::default()).await?;

let mut phases = geometry.phase_buffer();
focus(
    &geometry,
    geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm),
    wavelength(340.0 * m / s),
    &mut phases,
);

let bank = PatternBank::B0;

let mut builder = client.datagram_builder();
builder.push(WritePatternBuffer::new(bank, 0, &phases, Intensity::MAX));
builder.push(ConfigPattern {
    bank,
    config: SamplingConfig::new(NonZeroU16::MAX),
    size: 1,
    loop_behavior: LoopBehavior::Infinite,
});
builder.push(ChangePatternBank {
    bank,
    transition_mode: TransitionMode::Immediate,
});
let frames = builder.build()?;
for frame in &frames {
    client.send_checked(frame).await?;
}

client.close().await?;

Python

import asyncio

import numpy as np

from autd3 import Client, ClientConfig
from autd3.commands import ChangePatternBank, ConfigPattern, WritePatternBuffer
from autd3.geometry import Autd3, Geometry
from autd3.units import m, s
from autd3.value import Intensity, LoopBehavior, PatternBank, SamplingConfig, TransitionMode
from autd3_link_nop import Nop
from autd3_pattern import focus, wavelength


async def main() -> None:
    geometry = Geometry([Autd3([0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0])])
    async with await Client.open(geometry, Nop(), ClientConfig()) as client:
        phases = geometry.phase_buffer()
        focus(
            geometry,
            geometry.center() + np.array([0.0, 0.0, 150.0]),
            wavelength(340 * m / s),
            phases,
        )

        bank = PatternBank.B0

        builder = client.datagram_builder()
        builder.push(
            WritePatternBuffer(
                bank=bank,
                index=0,
                phases=phases,
                intensities=Intensity.MAX,
            )
        )
        builder.push(
            ConfigPattern(
                bank=bank,
                config=SamplingConfig(0xFFFF),
                size=1,
                loop_behavior=LoopBehavior.Infinite,
            )
        )
        builder.push(
            ChangePatternBank(
                bank=bank,
                transition_mode=TransitionMode.Immediate,
            )
        )
        frames = builder.build()
        for frame in frames:
            await client.send_checked(frame)


asyncio.run(main())

C#

using System.Numerics;
using System.Threading.Tasks;
using AUTD3;
using AUTD3.Link;
using Nop = AUTD3.Link.Nop;
using static AUTD3.Units;

var geometry = new Geometry(new[] { new Autd3(Vector3.Zero) });
await using var client = await Client.OpenAsync(geometry, new Nop(), new ClientConfig());

var phases = geometry.PhaseBuffer();
Pattern.Focus(
    geometry,
    geometry.Center + new Vector3(0.0f, 0.0f, 150.0f),
    Pattern.Wavelength(340.0f * m / s),
    phases
);

var bank = PatternBank.B0;

var builder = client.DatagramBuilder();
builder.Push(new WritePatternBuffer(
    bank: bank,
    index: 0,
    phases: phases,
    intensities: Intensity.Max
));
builder.Push(new ConfigPattern(
    bank: bank,
    config: new SamplingConfig(ushort.MaxValue),
    size: 1,
    loopBehavior: LoopBehavior.Infinite
));
builder.Push(new ChangePatternBank(
    bank: bank,
    transitionMode: TransitionMode.Immediate
));
var frames = builder.Build();
foreach (var frame in frames)
{
    await client.SendCheckedAsync(frame);
}