ActivatePatternBank

ActivatePatternBank is a low-level command that activates the Pattern bank to be played.

API

Rust

ActivatePatternBank {
    bank,
    transition_mode,
};

Python

ActivatePatternBank(
    bank=bank,
    transition_mode=transition_mode,
)

C#

new ActivatePatternBank(
    bank: bank,
    transitionMode: transitionMode
);

Field	Type	Description
bank	PatternBank	Destination bank
transition_mode	TransitionMode	Behavior on switching

TransitionMode

Immediate	Immediate
SyncIdx	When the playback index next becomes 0
SysTime { time }	At the specified device time time (SysTime)
Gpio(GpioIn)	Trigger on the specified GPIO input pin
Ext	Extended mode (automatically switches to the next bank when playback within the bank finishes)

Example

Rust

use core::num::NonZeroU16;

use autd3_rs::commands::{
    ActivatePatternBank, Clear, ConfigPattern, Synchronize, 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;
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 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;

client
    .send(WritePatternBuffer::new(bank, 0, &[phases], Intensity::MAX))
    .await?;
client.send(ConfigPattern {
    bank,
    config: SamplingConfig::new(NonZeroU16::MAX),
    size: 1,
    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, Synchronize, WritePatternBuffer
from autd3.geometry import Autd3, Geometry, offset
from autd3.units import m, mm, s
from autd3.value import Intensity, LoopBehavior, PatternBank, SamplingConfig, TransitionMode
from autd3_pattern import focus, wavelength


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

        phases = geometry.phase_buffer()
        focus(
            geometry,
            geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm),
            wavelength(340 * m / s),
            phases,
        )

        bank = PatternBank.B0

        await client.send(
            WritePatternBuffer(
                bank=bank,
                start_index=0,
                patterns=[phases],
                intensities=Intensity.MAX,
            )
        )
        await client.send(
            ConfigPattern(
                bank=bank,
                config=SamplingConfig(0xFFFF),
                size=1,
                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 phases = geometry.PhaseBuffer();
Pattern.Focus(
    geometry,
    geometry.Center + Offset(0.0f * mm, 0.0f * mm, 150.0f * mm),
    Pattern.Wavelength(340.0f * m / s),
    phases
);

var bank = PatternBank.B0;

await client.SendAsync(new WritePatternBuffer(
    bank: bank,
    startIndex: 0,
    patterns: new[] { phases },
    intensities: Intensity.Max
));
await client.SendAsync(new ConfigPattern(
    bank: bank,
    config: new SamplingConfig(ushort.MaxValue),
    size: 1,
    loopBehavior: LoopBehavior.Infinite
));
await client.SendAsync(new ActivatePatternBank(
    bank: bank,
    transitionMode: TransitionMode.Immediate
));