ConfigModulation

ConfigModulation is a low-level command that configures the playback parameters of the Modulation bank.

API

Rust

ConfigModulation {
    bank,
    config,
    size,
    loop_behavior,
};

Python

ConfigModulation(
    bank=bank,
    config=config,
    size=size,
    loop_behavior=loop_behavior,
)

C#

new ConfigModulation(
    bank: bank,
    config: config,
    size: size,
    loopBehavior: loopBehavior
);

Field	Type	Description
bank	ModulationBank	Target bank
config	SamplingConfig	Playback sampling frequency
size	usize	Number of samples
loop_behavior	LoopBehavior	Playback loop count (Infinite / Finite)

The minimum size is 2. To emit a constant modulation, repeat the same value twice.

For the timing at which loop_behavior and the transition take effect see ChangeModulationBank.

Example

ConfigModulation is used within the flow of writing the waveform with WriteModulationBuffer and then switching playback with ChangeModulationBank.

Rust

use autd3_rs::commands::{ChangeModulationBank, ConfigModulation, WriteModulationBuffer};
use autd3_rs::geometry::{Autd3, Geometry};
use autd3_rs::units::Hz;
use autd3_rs::value::{LoopBehavior, ModulationBank, SamplingConfig, TransitionMode};
use autd3_rs::{Client, ClientConfig};
use autd3_rs_link_nop::Nop;
use autd3_rs_modulation::{SineOption, modulation_buffer, sine};

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

let mut data = modulation_buffer();
sine(150 * Hz, &SineOption::default(), &mut data)?;

let bank = ModulationBank::B0;

let mut builder = client.datagram_builder();
builder.push(WriteModulationBuffer {
    bank,
    offset: 0,
    data: &data,
});
builder.push(ConfigModulation {
    bank,
    config: SamplingConfig::FREQ_4K,
    size: data.len(),
    loop_behavior: LoopBehavior::Infinite,
});
builder.push(ChangeModulationBank {
    bank,
    transition_mode: TransitionMode::Immediate,
});
let frames = builder.build()?;
for frame in &frames {
    client.send_checked(frame).await?;
}

client.close().await?;

Python

import asyncio

from autd3 import Client, ClientConfig
from autd3.commands import ChangeModulationBank, ConfigModulation, WriteModulationBuffer
from autd3.geometry import Autd3, Geometry
from autd3.units import Hz
from autd3.value import LoopBehavior, ModulationBank, SamplingConfig, TransitionMode
from autd3_link_nop import Nop
from autd3_modulation import SineOption, modulation_buffer, sine


async def main() -> None:
    geometry = Geometry([Autd3([0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0])])
    client = await Client.open(geometry, Nop(), ClientConfig())

    data = modulation_buffer()
    sine(150.0 * Hz, SineOption(), data)

    bank = ModulationBank.B0

    builder = client.datagram_builder()
    builder.push(
        WriteModulationBuffer(
            bank=bank,
            offset=0,
            data=data,
        )
    )
    builder.push(
        ConfigModulation(
            bank=bank,
            config=SamplingConfig.FREQ_4K,
            size=len(data),
            loop_behavior=LoopBehavior.Infinite,
        )
    )
    builder.push(
        ChangeModulationBank(
            bank=bank,
            transition_mode=TransitionMode.Immediate,
        )
    )
    frames = builder.build()
    for frame in frames:
        await client.send_checked(frame)

    await client.close()


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) });
var client = await Client.OpenAsync(geometry, new Nop(), new ClientConfig());

var data = Modulation.ModulationBuffer();
Modulation.Sine(150 * Hz, new SineOption(), data);

var bank = ModulationBank.B0;

var builder = client.DatagramBuilder();
builder.Push(new WriteModulationBuffer(
    bank: bank,
    offset: 0,
    data: data
));
builder.Push(new ConfigModulation(
    bank: bank,
    config: SamplingConfig.Freq4k,
    size: (uint)data.Length,
    loopBehavior: LoopBehavior.Infinite
));
builder.Push(new ChangeModulationBank(
    bank: bank,
    transitionMode: TransitionMode.Immediate
));
var frames = builder.Build();
foreach (var frame in frames)
{
    await client.SendCheckedAsync(frame);
}

await client.CloseAsync();