Single Device

This section explains how to drive a single device.

Installing the required software

This tutorial uses echocat. If you are on Windows, install Npcap in “WinPcap API-compatible Mode”.

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. Also add the autd3-rs-link-echocat library, which handles communication with the device. An asynchronous runtime is also required, so add tokio as well.

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

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

use autd3_rs::commands::{Modulation, Pattern, SetSilencer};
use autd3_rs::geometry::{Autd3, Geometry, offset};
use autd3_rs::units::{Hz, m, mm, s};
use autd3_rs::value::SamplingConfig;
use autd3_rs::{Client, ClientConfig};
use autd3_rs_link_echocat::EchocatLinkOption;

#[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 over an echocat link.
    let client = Client::open(
        &geometry,
        EchocatLinkOption::default(),
        ClientConfig::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 patterns = geometry.pattern_buffer();
    autd3_rs_pattern::focus(
        &geometry,
        target,
        wavelength,
        &autd3_rs_pattern::FocusOption::default(),
        &mut patterns,
    );

    // Apply a 200 Hz sine-wave AM.
    let mut modulation = autd3_rs_modulation::modulation_buffer();
    autd3_rs_modulation::sine(
        200 * Hz,
        &autd3_rs_modulation::SineOption {
            sampling_config: SamplingConfig::FREQ_4K,
            ..Default::default()
        },
        &mut modulation,
    )?;

    let mut builder = client.datagram_builder();
    builder
        .push(SetSilencer::default())
        .push(Pattern::new(&patterns))
        .push(Modulation::new(SamplingConfig::FREQ_4K, &modulation));
    let frames = builder.build()?;
    for frame in &frames {
        client.send_checked(frame).await?;
    }

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

    client.stop().await?;
    client.close().await?;

    Ok(())
}

Then, run it.

cargo run --release

On Linux and macOS, administrator privileges may be required to use echocat. In that case, use:

cargo build --release && sudo ./target/release/autd3_sample

Python

First, create an appropriate directory, prepare a virtual environment, and add the autd3 library. Also add autd3-link-echocat for communication with the device, autd3-pattern for focus computation, and autd3-modulation for AM modulation.

mkdir autd3-sample && cd autd3-sample
python3 -m venv .venv
source .venv/bin/activate
pip install autd3 autd3-pattern autd3-modulation autd3-link-echocat

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

import asyncio

import numpy as np

import autd3_link_echocat as echocat
import autd3_modulation as modulation
import autd3_pattern as pattern
from autd3 import Client, ClientConfig
from autd3.commands import Modulation, Pattern, SetSilencer
from autd3.geometry import Autd3, Geometry
from autd3.units import Hz, m, s
from autd3.value import SamplingConfig



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

    # Open the client over an echocat link.
    client = await Client.open(
        geometry,
        echocat.EchocatLinkOption(),
        ClientConfig(),
    )

    # Generate a focus 150 mm above the array center.
    target = geometry.center() + np.array([0.0, 0.0, 150.0])
    wavelength = pattern.wavelength(340 * m / s)
    patterns = geometry.pattern_buffer()
    pattern.focus(
        geometry,
        target,
        wavelength,
        pattern.FocusOption(),
        patterns,
    )

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

    builder = client.datagram_builder()
    builder.push(SetSilencer())
    builder.push(Pattern(patterns))
    builder.push(Modulation(SamplingConfig.FREQ_4K, mod_buf))
    for frame in builder.build():
        await client.send_checked(frame)

    try:
        await asyncio.Event().wait()
    finally:
        await client.stop()
        await client.close()


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

Then, run it.

python3 main.py

On Linux and macOS, administrator privileges may be required to use echocat. In that case, use:

sudo .venv/bin/python3 main.py

C#

First, create an appropriate directory and add the autd3 library. Also add AUTD3.Link.Echocat for communication with the device, 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
dotnet add package AUTD3.Link.Echocat

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

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

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

// Open the client over an echocat link.
var client = await Client.OpenAsync(
    geometry,
    new EchocatLinkOption(),
    new ClientConfig()
);

// Generate a focus 150 mm above the array center.
var target = geometry.Center + new Vector3(0.0f, 0.0f, 150.0f);
var wavelength = Pattern.Wavelength(340.0f * m / s);
var patterns = geometry.PatternBuffer();
Pattern.Focus(
    geometry,
    target,
    wavelength,
    new FocusOption(),
    patterns
);

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

var builder = client.DatagramBuilder();
builder.Push(new SetSilencer());
builder.Push(new Pattern(patterns));
builder.Push(new Modulation(SamplingConfig.Freq4k, modulation));
var frames = builder.Build();
foreach (var frame in frames)
{
    await client.SendCheckedAsync(frame);
}

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

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

Then, run it.

dotnet run -c Release

On Linux and macOS, administrator privileges may be required to use echocat.