Modulation

Modulation is a command that sends AM waveform data (&[u8]) to the device.

API

Rust

Modulation::new(config, &data);

Modulation::with_bank(bank, config, &data);

Modulation {
    bank,
    config,
    data: &data,
    loop_behavior,
    transition_mode,
};

Modulation::new sets the destination bank to ModulationBank::B0, the loop to Infinite, and the transition to Immediate. To write to another bank, use Modulation::with_bank(bank, config, data). To also change the loop count or transition timing, construct it by specifying the fields directly.

Python

Modulation(config, data)

Modulation(
    bank=bank,
    config=config,
    data=data,
    loop_behavior=loop_behavior,
    transition_mode=transition_mode,
)

Modulation sets the destination bank to ModulationBank.B0, the loop to Infinite, and the transition to Immediate by default. To specify another bank, loop count, or transition timing, pass the bank / loop_behavior / transition_mode arguments.

C#

new Modulation(config, data);

new Modulation(bank, config, data);

new Modulation(
    bank: bank,
    config: config,
    data: data,
    loopBehavior: loopBehavior,
    transitionMode: transitionMode
);

new Modulation(config, data) sets the destination bank to ModulationBank.B0, the loop to Infinite, and the transition to Immediate. To write to another bank, use new Modulation(bank, config, data). To also change the loop count or transition timing, pass the loopBehavior / transitionMode arguments.

Field	Type	Default	Description
bank	ModulationBank	ModulationBank::B0	Bank to write to / play back
config	SamplingConfig	—	Playback sampling frequency
data	&[u8]	—	AM waveform sample sequence (at least 2 samples)
loop_behavior	LoopBehavior	LoopBehavior::Infinite	Playback loop count
transition_mode	TransitionMode	TransitionMode::Immediate	Transition behavior on bank switching

config is specified with SamplingConfig. data is written to a buffer allocated by modulation_buffer(). For the behavior of loop_behavior / transition_mode, see ChangeModulationBank.

Several helper functions are provided for computing modulation.

Equivalent Low-Level Commands

Modulation is equivalent to the three commands WriteModulationBuffer + ConfigModulation + ChangeModulationBank. When the data fits in a single frame it is fused and sent as one frame; otherwise it expands into the three commands above. The following is equivalent to Modulation { bank, config, data, loop_behavior, transition_mode }

Rust

WriteModulationBuffer {
    bank,
    offset: 0,
    data: &data,
};
ConfigModulation {
    bank,
    config,
    size: data.len(),
    loop_behavior,
};
ChangeModulationBank {
    bank,
    transition_mode,
};

Python

WriteModulationBuffer(
    bank=bank,
    offset=0,
    data=data,
)
ConfigModulation(
    bank=bank,
    config=config,
    size=len(data),
    loop_behavior=loop_behavior,
)
ChangeModulationBank(
    bank=bank,
    transition_mode=transition_mode,
)

C#

new WriteModulationBuffer(
    bank: bank,
    offset: 0,
    data: data
);
new ConfigModulation(
    bank: bank,
    config: config,
    size: (uint)data.Length,
    loopBehavior: loopBehavior
);
new ChangeModulationBank(
    bank: bank,
    transitionMode: transitionMode
);

Example

Rust

use autd3_rs::commands::Modulation;
use autd3_rs::geometry::{Autd3, Geometry};
use autd3_rs::units::Hz;
use autd3_rs::value::SamplingConfig;
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 mut builder = client.datagram_builder();
builder.push(Modulation::new(SamplingConfig::FREQ_4K, &data));
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 Modulation
from autd3.geometry import Autd3, Geometry
from autd3.units import Hz
from autd3.value import SamplingConfig
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)

    builder = client.datagram_builder()
    builder.push(Modulation(SamplingConfig.FREQ_4K, data))
    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 builder = client.DatagramBuilder();
builder.Push(new Modulation(SamplingConfig.Freq4k, data));
var frames = builder.Build();
foreach (var frame in frames)
{
    await client.SendCheckedAsync(frame);
}

await client.CloseAsync();