Single Device

This section explains how to drive a single device.

Preparation

The following is an example that generates a focal point 150 mm directly above the center of the array with a single AUTD3 device and applies a 200 Hz sine-wave AM.

Rust

First, create an appropriate project and add the autd3-rs library as a dependency. For focus computation and AM modulation, also add autd3-rs-pattern and autd3-rs-modulation. autd3-rs runs on the tokio runtime, so also add 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

Next, edit the src/main.rs file to look like the following.

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(())
}

Then, run it.

cargo run --release

Python

First, create an appropriate project with uv and add the autd3 library. Also add autd3-pattern for focus computation and autd3-modulation for AM modulation.

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

Next, make the main.py file look like the following.

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())

Then, run it.

uv run main.py

C#

First, create an appropriate directory and add the autd3 library. Also add AUTD3.Pattern for focus computation and AUTD3.Modulation for AM modulation.

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

Next, make the Program.cs file look like the following.

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));

Then, run it.

dotnet run -c Release

Press Ctrl+C to exit.