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(config, data, bank=bank)

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 write to another bank, use Modulation(config, data, bank=bank). To also change the loop count or transition timing, pass the 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 ActivateModulationBank.

Several helper functions are provided for computing modulation.

Equivalent Low-Level Commands

Modulation is equivalent to the three commands WriteModulationBuffer + ConfigModulation + ActivateModulationBank. The following is equivalent to Modulation { bank, config, data, loop_behavior, transition_mode }

Rust

for (i, chunk) in data.chunks(WriteModulationBuffer::MAX_LEN).enumerate() {
    WriteModulationBuffer {
        bank,
        offset: i * WriteModulationBuffer::MAX_LEN,
        data: chunk,
    };
}
ConfigModulation {
    bank,
    config,
    size: data.len(),
    loop_behavior,
};
ActivateModulationBank {
    bank,
    transition_mode,
};

Python

samples = data.to_numpy()
for offset in range(0, len(samples), WriteModulationBuffer.MAX_LEN):
    WriteModulationBuffer(
        bank=bank,
        offset=offset,
        data=ModulationBuffer.from_array(samples[offset : offset + WriteModulationBuffer.MAX_LEN]),
    )
ConfigModulation(
    bank=bank,
    config=config,
    size=len(data),
    loop_behavior=loop_behavior,
)
ActivateModulationBank(
    bank=bank,
    transition_mode=transition_mode,
)

C#

var samples = data.ToArray();
for (var offset = 0; offset < samples.Length; offset += WriteModulationBuffer.MaxLen)
{
    using var chunk = ModulationBuffer.FromBytes(samples[offset..Math.Min(offset + WriteModulationBuffer.MaxLen, samples.Length)]);
    new WriteModulationBuffer(
        bank: bank,
        offset: (uint)offset,
        data: chunk
    );
}
new ConfigModulation(
    bank: bank,
    config: config,
    size: (uint)data.Length,
    loopBehavior: loopBehavior
);
new ActivateModulationBank(
    bank: bank,
    transitionMode: transitionMode
);

Example

Rust

use autd3_rs::commands::{Clear, Modulation, Synchronize};
use autd3_rs::geometry::{Autd3, Geometry};
use autd3_rs::units::Hz;
use autd3_rs::value::SamplingConfig;
use autd3_rs::Client;
use autd3_rs::udp::TransportOption;
use autd3_rs_modulation::{SineOption, modulation_buffer, sine};

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 config = SamplingConfig::FREQ_4K;
let mut data = modulation_buffer();
sine(150 * Hz, &SineOption::default(), config, &mut data)?;

client.send(Modulation::new(config, &data)).await?;

Python

import asyncio

from autd3 import Client, TransportOption
from autd3.commands import Clear, Modulation, Synchronize
from autd3.geometry import Autd3, Geometry
from autd3.units import Hz
from autd3.value import SamplingConfig
from autd3_modulation import SineOption, modulation_buffer, sine


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

        config = SamplingConfig.FREQ_4K
        data = modulation_buffer()
        sine(150 * Hz, SineOption(), config, data)

        await client.send(Modulation(config, data))


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 config = SamplingConfig.Freq4k;
var data = Modulation.ModulationBuffer();
Modulation.Sine(150 * Hz, new SineOption(), config, data);

await client.SendAsync(new Modulation(config, data));