単一デバイス

ここでは, 一つのデバイスを駆動する方法について説明する.

事前準備

以下は, 1台のAUTD3デバイスでアレイの中心から150 mm直上に焦点を生成し, 200 Hzの正弦波AMかける例である.

Rust

まずは適当なプロジェクトを作成し, autd3-rsライブラリを依存関係に追加する. 焦点計算やAM変調のために, autd3-rs-patternとautd3-rs-modulationも依存関係に追加する. また, autd3-rs は tokio ランタイム上で動作するので tokio も追加する.

cargo new --bin autd3-sample && cd autd3-sample
cargo add autd3-rs
cargo add autd3-rs-pattern
cargo add autd3-rs-modulation
cargo add tokio --features full

次に, src/main.rsファイルを編集し, 以下のようにする.

use autd3_rs::commands::{Clear, Modulation, Pattern, SetSilencer, Synchronize};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{Hz, m, mm, s};
use autd3_rs::value::{Intensity, SamplingConfig};
use autd3_rs::Client;
use autd3_rs::TransportOption;

#[tokio::main(flavor = "multi_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Define a geometry consisting of a single AUTD3 device.
    let geometry = Geometry::new(vec![Autd3::default()]);

    // Open the client.
    let mut client = Client::open(&geometry, &TransportOption::default()).await?;
    client.send(Clear).await?;
    client.send(Synchronize).await?;
    client.send(SetSilencer::default()).await?;

    // Generate a focus 150 mm above the array center.
    let target = geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm);
    let wavelength = autd3_rs_pattern::wavelength(340.0 * m / s);
    let mut phases = geometry.phase_buffer();
    autd3_rs_pattern::focus(
        &geometry,
        target,
        wavelength,
        &mut phases,
    );
    client.send(Pattern::new(&phases, Intensity::MAX)).await?;

    // Apply a 200 Hz sine-wave AM.
    let sampling_config = SamplingConfig::FREQ_4K;
    let mut modulation = autd3_rs_modulation::modulation_buffer();
    autd3_rs_modulation::sine(
        200 * Hz,
        &autd3_rs_modulation::SineOption::default(),
        sampling_config,
        &mut modulation,
    )?;
    client.send(Modulation::new(sampling_config, &modulation)).await?;

    tokio::signal::ctrl_c().await?;

    client.send(Pattern::new(&geometry.phase_buffer(), Intensity::MIN)).await?;

    Ok(())
}

そして, これを実行する.

cargo run --release

Python

まずは uv で適当なプロジェクトを作成し, autd3ライブラリを追加する. また, 焦点計算のautd3-pattern, AM変調のautd3-modulationも併せて追加する.

uv init autd3-sample && cd autd3-sample
uv add autd3 autd3-pattern autd3-modulation

次に, main.pyファイルを以下のようにする.

import asyncio

import autd3_modulation as modulation
import autd3_pattern as pattern
from autd3 import Client, TransportOption
from autd3.commands import Clear, Modulation, Pattern, SetSilencer, Synchronize
from autd3.geometry import Autd3, Geometry, offset
from autd3.units import Hz, m, mm, s
from autd3.value import Intensity, SamplingConfig



async def main() -> None:
    # Define a geometry consisting of a single AUTD3 device.
    geometry = Geometry([Autd3()])

    # Open the client.
    with await Client.open(
        geometry,
        TransportOption(),
    ) as client:
        await client.send(Clear())
        await client.send(Synchronize())
        await client.send(SetSilencer())

        # Generate a focus 150 mm above the array center.
        target = geometry.center() + offset(0.0 * mm, 0.0 * mm, 150.0 * mm)
        wavelength = pattern.wavelength(340 * m / s)
        phases = geometry.phase_buffer()
        pattern.focus(
            geometry,
            target,
            wavelength,
            phases,
        )
        await client.send(Pattern(phases, Intensity.MAX))

        # Apply a 200 Hz sine-wave AM.
        sampling_config = SamplingConfig.FREQ_4K
        mod_buf = modulation.modulation_buffer()
        modulation.sine(
            200 * Hz,
            modulation.SineOption(),
            sampling_config,
            mod_buf,
        )
        await client.send(Modulation(sampling_config, mod_buf))

        try:
            await asyncio.Event().wait()
        finally:
            await client.send(Pattern(geometry.phase_buffer(), Intensity.MIN))


if __name__ == "__main__":
    asyncio.run(main())

そして, これを実行する.

uv run main.py

C#

まずは適当なディレクトリを作成し, autd3 ライブラリを追加する. また, 焦点計算の AUTD3.Pattern, AM 変調の AUTD3.Modulation も併せて追加する.

dotnet new console -o autd3-sample && cd autd3-sample
dotnet add package AUTD3
dotnet add package AUTD3.Pattern
dotnet add package AUTD3.Modulation

次に, Program.csファイルを以下のようにする.

using System;
using System.Threading;
using System.Threading.Tasks;
using AUTD3;
using static AUTD3.Units;

// Define a geometry consisting of a single AUTD3 device.
var geometry = new Geometry(new[] { new Autd3() });

// Open the client.
using var client = await Client.OpenAsync(
    geometry,
    new TransportOption()
);
await client.SendAsync(new Clear());
await client.SendAsync(new Synchronize());
await client.SendAsync(new SetSilencer());

// Generate a focus 150 mm above the array center.
var target = geometry.Center + Offset(0.0f * mm, 0.0f * mm, 150.0f * mm);
var wavelength = Pattern.Wavelength(340.0f * m / s);
var phases = geometry.PhaseBuffer();
Pattern.Focus(
    geometry,
    target,
    wavelength,
    phases
);
await client.SendAsync(new Pattern(phases, Intensity.Max));

// Apply a 200 Hz sine-wave AM.
var samplingConfig = SamplingConfig.Freq4k;
var modulation = Modulation.ModulationBuffer();
Modulation.Sine(
    200 * Hz,
    new SineOption(),
    samplingConfig,
    modulation
);
await client.SendAsync(new Modulation(samplingConfig, modulation));

using var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    cts.Cancel();
};

try
{
    await Task.Delay(Timeout.InfiniteTimeSpan, cts.Token);
}
catch (OperationCanceledException)
{
}

await client.SendAsync(new Pattern(geometry.PhaseBuffer(), Intensity.Min));

そして, これを実行する.

dotnet run -c Release

Ctrl+C を押すと終了する.