• autd3
• autd3-gain-holo
• autd3-modulation-audio-file
• autd3-link-twincat
• autd3-link-simulator
• autd3-link-soem
• autd3-emulator

Can be installed using CMake’s FetchContent.

• autd3
  • Windows: https://github.com/shinolab/autd3-cpp/releases/download/v32.1.0/autd3-v32.1.0-win-x64.zip
  • macOS: https://github.com/shinolab/autd3-cpp/releases/download/v32.1.0/autd3-v32.1.0-macos-aarch64.tar.gz
  • Linux: https://github.com/shinolab/autd3-cpp/releases/download/v32.1.0/autd3-v32.1.0-linux-x64.tar.gz
• autd3-link-soem
  • Windows: https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-win-x64.zip
  • macOS: https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-macos-aarch64.tar.gz
  • Linux: https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-linux-x64.tar.gz

Published on NuGet.

• AUTD3Sharp
• AUTD3Sharp.Link.SOEM

Can be installed via Unity Package Manager. Add the following repositories.

• AUTD3Sharp: https://github.com/shinolab/AUTD3Sharp.git#upm/latest
• AUTD3Sharp.Link.SOEM: https://github.com/shinolab/AUTD3Sharp.Link.SOEM.git#upm/latest

Published on PyPI.

• pyautd3
• pyautd3_link_soem
• pyautd3_emulator

First, create a project and add the autd3 library as a dependency. Also, add the autd3-link-soem library for communication with the device.

cargo new --bin autd3-sample
cd autd3-sample
cargo add autd3
cargo add autd3-link-soem

Next, edit the src/main.rs file as follows. This is the source code for applying AM modulation of $150\mathrm{Hz}$ to a single focal point.

use autd3::prelude::*;
use autd3_link_soem::{SOEMOption, Status, SOEM};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Open controller with SOEM link
    // Here, the AUTD3 device is placed at the origin
    let mut autd = Controller::open(
        [AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        }],
        SOEM::new(
            // The first argument is a callback that is called when error occurs
            |slave, status| {
                eprintln!("slave[{}]: {}", slave, status);
                if status == Status::Lost {
                    // You can also wait for the link to recover, without exitting the process
                    std::process::exit(-1);
                }
            },
            // The second argument is a option of SOEM link.
            SOEMOption::default(),
        ),
    )?;

    // Check firmware version
    // This code assumes that the version is v11.0.0 or v10.0.1
    autd.firmware_version()?.iter().for_each(|firm_info| {
        println!("{}", firm_info);
    });

    // Enable silencer
    // Note that this is enabled by default, so it is not actually necessary
    // To disable, send Silencer::disable()
    autd.send(Silencer::default())?;

    // A focus at 150mm directly above the center of the device
    let g = Focus {
        pos: autd.center() + Vector3::new(0., 0., 150.0 * mm),
        option: FocusOption::default(),
    };

    // 150 Hz sine wave modulation
    let m = Sine {
        freq: 150 * Hz,
        option: SineOption::default(),
    };

    // Send data
    autd.send((m, g))?;

    println!("press enter to quit...");
    let mut _s = String::new();
    std::io::stdin().read_line(&mut _s)?;

    // Close controller
    autd.close()?;

    Ok(())
}

Then, run it.

cargo run --release

Notes for Linux and macOS Users

On Linux and macOS, administrator privileges are required to use SOEM. In that case, run:

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

Installing Dependencies

This tutorial uses CMake, so make sure it is installed.

Creating an AUTD3 Client Program

First, open a terminal and prepare an appropriate directory.

mkdir autd3-sample
cd autd3-sample

Next, create CMakeLists.txt and main.cpp files under autd3-sample.

└─autd3-sample
        CMakeLists.txt
        main.cpp

Next, edit CMakeLists.txt as follows.

cmake_minimum_required(VERSION 3.21)

project(autd3-sample)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24.0") 
  cmake_policy(SET CMP0135 NEW)
endif()

include(FetchContent)
if(WIN32)
  FetchContent_Declare(
    autd3
    URL https://github.com/shinolab/autd3-cpp/releases/download/v30.0.1/autd3-v30.0.1-win-x64.zip
  )
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v30.0.1/autd3-link-soem-v30.0.1-win-x64.zip
  )
elseif(APPLE)
  FetchContent_Declare(
    autd3
    URL https://github.com/shinolab/autd3-cpp/releases/download/v30.0.1/autd3-v30.0.1-macos-aarch64.tar.gz
  )
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v30.0.1/autd3-link-soem-v30.0.1-macos-aarch64.tar.gz
  )
else()
  FetchContent_Declare(
    autd3
    URL https://github.com/shinolab/autd3-cpp/releases/download/v30.0.1/autd3-v30.0.1-linux-x64.tar.gz
  )
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v30.0.1/autd3-link-soem-v30.0.1-linux-x64.tar.gz
  )
endif()
set(USE_SYSTEM_EIGEN OFF)
FetchContent_MakeAvailable(autd3 autd3-link-soem)

add_executable(main main.cpp)

target_link_libraries(main PRIVATE autd3::autd3 autd3::link::soem)

NOTE: In the above example, the dependency library (Eigen3) is automatically downloaded. If Eigen3 is already installed, you can disable the automatic download by turning on USE_SYSTEM_EIGEN and use the installed one.

Also, edit main.cpp as follows. This is the source code for applying AM modulation of $150\mathrm{Hz}$ to a single focal point.

#include <iostream>

#include "autd3.hpp"
#include "autd3_link_soem.hpp"

using namespace autd3;

int main() try {
  auto autd = Controller::open(
      {AUTD3{
          .pos = Point3::origin(),
          .rot = Quaternion::Identity(),
      }},
      link::SOEM(
          [](const uint16_t slave, const link::Status status) {
            std::cout << "slave [" << slave << "]: " << status << std::endl;
            if (status == link::Status::Lost()) exit(-1);
          },
          link::SOEMOption{}));

  const auto firm_version = autd.firmware_version();
  std::copy(firm_version.begin(), firm_version.end(),
            std::ostream_iterator<FirmwareVersion>(std::cout, "\n"));

  autd.send(Silencer{});

  Focus g(autd.center() + Vector3(0, 0, 150), FocusOption{});
  Sine m(150 * Hz, SineOption{});

  autd.send((m, g));

  std::cout << "press enter to finish..." << std::endl;
  std::cin.ignore();

  autd.close();

  return 0;
} catch (std::exception& ex) {
  std::cerr << ex.what() << std::endl;
}

Next, build with CMake.

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release

This will generate an executable file, so run it.

.\Release\main.exe

sudo ./main

Troubleshooting

• There may be build errors if anaconda (miniconda) is activated.
  • In this case, delete the build directory, run conda deactivate, and then run cmake again.

First, open a terminal, create an appropriate project, and add the AUTD3Sharp library.

dotnet new console --name autd3-sample
cd autd3-sample
dotnet add package AUTD3Sharp
dotnet add package AUTD3Sharp.Link.SOEM

Next, edit Program.cs as follows. This is the source code for applying AM modulation of $150\mathrm{Hz}$ to a single focal point.

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;

using var autd = Controller.Open(
    [new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity)],
    new SOEM(
        (slave, status) =>
            {
                Console.Error.WriteLine($"slave [{slave}]: {status}");
                if (status == Status.Lost)
                    Environment.Exit(-1);
            },
        new SOEMOption()
    )
);

var firmList = autd.FirmwareVersion();
foreach (var firm in firmList)
    Console.WriteLine(firm);

autd.Send(new Silencer());

var g = new Focus(
    pos: autd.Center() + new Vector3(0, 0, 150),
    option: new FocusOption()
);
var m = new Sine(
    freq: 150u * Hz,
    option: new SineOption()
);
autd.Send((m, g));

Console.ReadKey(true);

autd.Close();

Then, run it.

dotnet run -c:Release

Notes for Linux and macOS Users

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

sudo dotnet run -c:Release

Installing the pyautd3 Library

First, install the pyautd3 and pyautd3_link_soem libraries via pip.

pip install pyautd3
pip install pyautd3_link_soem

Next, create main.py and edit it as follows. This is the source code for applying AM modulation of $150\mathrm{Hz}$ to a single focal point.

import os

import numpy as np
from pyautd3 import (
    AUTD3,
    Controller,
    Focus,
    FocusOption,
    Hz,
    Silencer,
    Sine,
    SineOption,
)
from pyautd3_link_soem import SOEM, SOEMOption, Status


def err_handler(slave: int, status: Status) -> None:
    print(f"slave [{slave}]: {status}")
    if status == Status.Lost():
        os._exit(-1)


if __name__ == "__main__":
    with Controller.open(
        [AUTD3(pos=[0.0, 0.0, 0.0], rot=[1, 0, 0, 0])],
        SOEM(err_handler=err_handler, option=SOEMOption()),
    ) as autd:
        firmware_version = autd.firmware_version()
        print(
            "\n".join(
                [f"[{i}]: {firm}" for i, firm in enumerate(firmware_version)],
            ),
        )

        autd.send(Silencer())

        g = Focus(
            pos=autd.center() + np.array([0.0, 0.0, 150.0]),
            option=FocusOption(),
        )
        m = Sine(
            freq=150 * Hz,
            option=SineOption(),
        )
        autd.send((m, g))

        _ = input()

        autd.close()

Then, run it.

python main.py

Notes for Linux Users

On Linux, administrator privileges are required to use SOEM. In that case, run:

sudo setcap cap_net_raw,cap_net_admin=eip <your python path>

Then, run main.py.

python main.py

Notes for macOS Users

On macOS, administrator privileges are required to use SOEM. In that case, run:

sudo chmod +r /dev/bpf*

Then, run main.py.

python main.py

use autd3::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let link = autd3::link::Nop::new();
let _ =
Controller::open(
    [
        AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        },
        AUTD3 {
            pos: Point3::new(AUTD3::DEVICE_WIDTH, 0., 0.),
            rot: UnitQuaternion::identity(),
        },
    ],
    link,
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
link::Nop link;
Controller::open({AUTD3{
                      .pos = Point3::origin(),
                      .rot = Quaternion::Identity(),
                  },
                  AUTD3{
                      .pos = Point3(AUTD3::DEVICE_WIDTH, 0, 0),
                      .rot = Quaternion::Identity(),
                  }},
                 std::move(link));
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
var link = new Nop();
Controller.Open([
   new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity),
   new AUTD3(pos: new Point3(AUTD3.DeviceWidth, 0, 0), rot: Quaternion.Identity)
], link)
;

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
link = Nop()
Controller.open(
    [
        AUTD3(pos=[0.0, 0.0, 0.0], rot=[1, 0, 0, 0]),
        AUTD3(pos=[AUTD3.DEVICE_WIDTH, 0.0, 0.0], rot=[1, 0, 0, 0]),
    ],
    link,
)

use autd3::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let link = autd3::link::Nop::new();
let _ =
Controller::open(
    [
        AUTD3 {
            pos: Point3::new(-AUTD3::DEVICE_WIDTH, 0., 0.),
            rot: UnitQuaternion::identity(),
        },
        AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        },
    ],
    link,
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
link::Nop link;
Controller::open(
    {
        AUTD3{
            .pos = Point3(-AUTD3::DEVICE_WIDTH, 0, 0),
            .rot = Quaternion::Identity(),
        },
        AUTD3{
            .pos = Point3::origin(),
            .rot = Quaternion::Identity(),
        },
    },
    std::move(link));
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
var link = new Nop();
Controller.Open([
   new AUTD3(pos: new Point3(-AUTD3.DeviceWidth, 0, 0), rot: Quaternion.Identity),
   new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity)
], link)
;

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
link = Nop()
Controller.open(
    [
        AUTD3(pos=[-AUTD3.DEVICE_WIDTH, 0.0, 0.0], rot=[1, 0, 0, 0]),
        AUTD3(pos=[0.0, 0.0, 0.0], rot=[1, 0, 0, 0]),
    ],
    link,
)

use autd3::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let link = autd3::link::Nop::new();
let _ =
Controller::open(
    [
        AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        },
        AUTD3 {
            pos: Point3::new(0., 0., AUTD3::DEVICE_WIDTH),
            rot: EulerAngle::ZYZ(0. * rad, PI/2.0 * rad, 0. * rad).into(),
        },
    ],
    link,
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
link::Nop link;
Controller::open({AUTD3{
                      .pos = Point3::origin(),
                      .rot = Quaternion::Identity(),
                  },
                  AUTD3{
                      .pos = Point3(0, 0, AUTD3::DEVICE_WIDTH),
                      .rot = EulerAngles::ZYZ(0. * rad, pi / 2.0 * rad,
                                              0. * rad),
                  }},
                 std::move(link));
return 0; }

using System;
using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var link = new Nop();
Controller.Open([
   new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity),
   new AUTD3(
      pos: new Point3(0, 0, AUTD3.DeviceWidth),
      rot: EulerAngles.Zyz(0 * rad, MathF.PI / 2 * rad, 0 * rad))
], link)
;

import numpy as np
from pyautd3 import AUTD3, Controller, EulerAngles, Nop, rad
link = Nop()
Controller.open(
    [
        AUTD3(pos=[0.0, 0.0, 0.0], rot=[1.0, 0.0, 0.0, 0.0]),
        AUTD3(
            pos=[0.0, 0.0, AUTD3.DEVICE_WIDTH],
            rot=EulerAngles.ZYZ(0 * rad, np.pi / 2 * rad, 0 * rad),
        ),
    ],
    link,
)

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let num_dev = autd.num_devices();
let num_tr = autd.num_transducers();
let center = autd.center();
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
const auto num_dev = autd.num_devices();
const auto num_tr = autd.num_transducers();
const auto center = autd.center();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var numDevices = autd.NumDevices();
var numTransducers = autd.NumTransducers();
var center = autd.Center();

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
num_devices = autd.num_devices()
num_transducers = autd.num_transducers()
center = autd.center()

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let dev = &autd[0];
for dev in &autd {
    // do something
}
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
{
auto dev = autd[0];
}
{
for (auto& dev : autd) {
  // do something
}
}
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
{
var dev = autd[0];
}
foreach (var dev in autd)
{
  // do something
}

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
dev = autd[0]
for _dev in autd:
    pass

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let dev = &mut autd[0];
let idx = dev.idx();
dev.enable = false;
dev.sound_speed = 340e3;
dev.set_sound_speed_from_temp(15.);
let wavelength = dev.wavelength();
let wavenumber = dev.wavenumber();
let rotation = dev.rotation();
let x_dir = dev.x_direction();
let y_dir = dev.y_direction();
let axial_dir = dev.axial_direction();
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
auto dev = autd[0];
const auto idx = dev.idx();
const auto enable = dev.enable();
dev.set_enable(false);
const auto sound_speed = dev.sound_speed();
dev.set_sound_speed(340e3);
dev.set_sound_speed_from_temp(15.);
const auto wavelength = dev.wavelength();
const auto wavenumber = dev.wavenumber();
const auto rotation = dev.rotation();
const auto x_dir = dev.x_direction();
const auto y_dir = dev.y_direction();
const auto axial_dir = dev.axial_direction();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var dev = autd[0];
var idx = dev.Idx();
dev.Enable = false;
dev.SoundSpeed = 340e3f;
dev.SetSoundSpeedFromTemp(15);
var wavelength = dev.Wavelength();
var wavenumber = dev.Wavenumber();
var rotation = dev.Rotation();
var xDir = dev.XDirection();
var yDir = dev.YDirection();
var axialDir = dev.AxialDirection();

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
dev = autd[0]
idx = dev.idx()
dev.enable = False
dev.sound_speed = 340e3
dev.set_sound_speed_from_temp(15.0)
wavelength = dev.wavelength()
wavenumber = dev.wavenumber()
rotation = dev.rotation()
x_dir = dev.x_direction()
y_dir = dev.y_direction()
axial_dir = dev.axial_direction()

use autd3::prelude::*;
#[allow(unused_variables)] 
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let tr = &autd[0][0];
for tr in &autd[0] {
    // do something
}
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
{
auto tr = autd[0][0];
}
{
for (auto& tr : autd[0]) {
  // do something
}
}
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
{
var tr = autd[0][0];
}
foreach (var tr in autd[0])
{
  // do something
}

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
tr = autd[0][0]
for _tr in autd[0]:
    pass

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let tr = &autd[0][0];
let idx = tr.idx();
let dev_idx = tr.dev_idx();
let position = tr.position();
Ok(())
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
const auto tr = autd[0][0];
const auto idx = tr.idx();
const auto dev_idx = tr.dev_idx();
const auto position = tr.position();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var tr = autd[0][0];
var trIdx = tr.Idx();
var devIdx = tr.DevIdx();
var position = tr.Position();

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
tr = autd[0][0]
idx = tr.idx()
dev_idx = tr.dev_idx()
position = tr.position()

cargo add autd3-link-twincat

target_link_libraries(<TARGET> PRIVATE autd3::link::twincat)

Included in the main library.

Included in the main library.

Included in the main library.

use autd3_link_twincat::TwinCAT;

fn main() {
let _ = 
TwinCAT::new();
}

#include "autd3/link/twincat.hpp"

int main() {
using namespace autd3;
link::TwinCAT();
return 0; }

using AUTD3Sharp.Link;

new TwinCAT();

from pyautd3.link.twincat import TwinCAT

TwinCAT()

cargo add autd3-link-soem

if(WIN32)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-win-x64.zip
  )
elseif(APPLE)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-macos-aarch64.tar.gz
  )
else()
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-linux-x64.tar.gz
  )
endif()
FetchContent_MakeAvailable(autd3-link-soem)
target_link_libraries(<TARGET> PRIVATE autd3::link::soem)

dotnet add package AUTD3Sharp.Link.SOEM

Add https://github.com/shinolab/AUTD3Sharp.Link.SOEM.git#upm/latest to Unity Package Manager.

pip install pyautd3_link_soem

#[cfg(target_os = "windows")]
use autd3_link_soem::ProcessPriority;
use autd3_link_soem::{Status, SyncMode, ThreadPriority, TimerStrategy, SOEM, SOEMOption};
use std::num::NonZeroUsize;
use std::time::Duration;

fn main() {
let _ = 
SOEM::new(
    |slave, status| {
        eprintln!("slave [{}]: {}", slave, status);
        if status == Status::Lost {
            std::process::exit(-1);
        }
    },
    SOEMOption {
        buf_size: NonZeroUsize::new(32).unwrap(),
        timer_strategy: TimerStrategy::SpinSleep,
        sync_mode: SyncMode::DC,
        ifname: String::new(),
        state_check_interval: Duration::from_millis(100),
        sync0_cycle: Duration::from_millis(1),
        send_cycle: Duration::from_millis(1),
        thread_priority: ThreadPriority::Max,
        #[cfg(target_os = "windows")]
        process_priority: ProcessPriority::High,
        sync_tolerance: Duration::from_micros(1),
        sync_timeout: Duration::from_secs(10),
    },
);
}

#include <iostream>
#include <autd3_link_soem.hpp>

int main() {
using namespace autd3;
link::SOEM(
    [](const uint16_t slave, const link::Status status) {
      std::cout << "slave [" << slave << "]: " << status << std::endl;
      if (status == link::Status::Lost()) {
        exit(-1);
      }
    },
    link::SOEMOption{
        .buf_size = 32,
        .timer_strategy = link::TimerStrategy::SpinSleep,
        .sync_mode = link::SyncMode::DC,
        .ifname = "",
        .state_check_interval = std::chrono::milliseconds(100),
        .sync0_cycle = std::chrono::milliseconds(1),
        .send_cycle = std::chrono::milliseconds(1),
        .thread_priority = link::ThreadPriority::Max(),
        .process_priority = link::ProcessPriority::High,
        .sync_tolerance = std::chrono::microseconds(1),
        .sync_timeout = std::chrono::seconds(10),

    });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;

using AUTD3Sharp.Utils;
new SOEM(
    errHandler: (slave, status) =>
    {
        Console.Error.WriteLine($"slave [{slave}]: {status}");
        if (status == Status.Lost)
            Environment.Exit(-1);
    },
    option: new SOEMOption
    {
        BufSize = 32,
        TimerStrategy = TimerStrategy.SpinSleep,
        SyncMode = SyncMode.DC,
        Ifname = "",
        StateCheckInterval = Duration.FromMillis(100),
        Sync0Cycle = Duration.FromMillis(1),
        SendCycle = Duration.FromMillis(1),
        ThreadPriority = AUTD3Sharp.Link.ThreadPriority.Max,
        ProcessPriority = ProcessPriority.High,
        SyncTolerance = Duration.FromMicros(1),
        SyncTimeout = Duration.FromSecs(10),
    }
);

import os
from pyautd3 import Duration
from pyautd3_link_soem import (
    SOEM,
    ProcessPriority,
    SOEMOption,
    Status,
    SyncMode,
    ThreadPriority,
    TimerStrategy,
)


def err_handler(slave: int, status: Status) -> None:
    print(f"slave [{slave}]: {status}")
    if status == Status.Lost():
        os._exit(-1)


SOEM(
    err_handler=err_handler,
    option=SOEMOption(
        buf_size=32,
        timer_strategy=TimerStrategy.SpinSleep,
        sync_mode=SyncMode.DC,
        ifname="",
        state_check_interval=Duration.from_millis(100),
        sync0_cycle=Duration.from_millis(1),
        send_cycle=Duration.from_millis(1),
        thread_priority=ThreadPriority.Max,
        process_priority=ProcessPriority.High,  # only available on Windows
        sync_tolerance=Duration.from_micros(1),
        sync_timeout=Duration.from_secs(10),
    ),
)

cargo add autd3-link-simulator --features blocking

target_link_libraries(<TARGET> PRIVATE autd3::link::simulator)

Included in the main library.

Included in the main library.

Included in the main library.

use autd3_link_simulator::Simulator;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
Simulator::new("127.0.0.1:8080".parse()?);
Ok(())
}

#include "autd3/link/simulator.hpp"

int main() {
using namespace autd3;
link::Simulator("127.0.0.1:8080");
return 0; }

using System.Net;
using AUTD3Sharp.Link;

new Simulator(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8080));

from pyautd3.link.simulator import Simulator

Simulator("127.0.0.1:8080")

cargo add autd3-link-twincat --features remote

target_link_libraries(<TARGET> PRIVATE autd3::link::twincat)

Included in the main library.

Included in the main library.

Included in the main library.

use autd3_link_twincat::remote::{RemoteTwinCAT, RemoteTwinCATOption};

fn main() {
let _ = 
RemoteTwinCAT::new("172.16.99.111.1.1", RemoteTwinCATOption {
    server_ip: "172.16.99.104".to_string(),
    client_ams_net_id: "172.16.99.62.1.1".to_string(),
});
}

#include "autd3/link/twincat.hpp"

int main() {
using namespace autd3;
link::RemoteTwinCAT("172.16.99.111.1.1",
                    link::RemoteTwinCATOption{
                        .server_ip = "172.16.99.104",
                        .client_ams_net_id = "172.16.99.62.1.1"});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;

new RemoteTwinCAT(
        serverAmsNetId: "172.16.99.111.1.1",
        option: new RemoteTwinCATOption
        {
                ServerIp = "172.16.99.104",
                ClientAmsNetId = "172.16.99.62.1.1"
        }
);

from pyautd3.link.twincat import RemoteTwinCAT, RemoteTwinCATOption

RemoteTwinCAT(
    server_ams_net_id="172.16.99.111.1.1",
    option=RemoteTwinCATOption(
        server_ip="172.16.99.104",
        client_ams_net_id="172.16.99.62.1.1",
    ),
)

cargo add autd3-link-soem --features "remote blocking"

if(WIN32)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-win-x64.zip
  )
elseif(APPLE)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-macos-aarch64.tar.gz
  )
else()
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.1.0/autd3-link-soem-v32.1.0-linux-x64.tar.gz
  )
endif()
FetchContent_MakeAvailable(autd3-link-soem)
target_link_libraries(<TARGET> PRIVATE autd3::link::soem)

dotnet add package AUTD3Sharp.Link.SOEM

Add https://github.com/shinolab/AUTD3Sharp.Link.SOEM.git#upm/latest to Unity Package Manager.

pip install pyautd3_link_soem

use autd3_link_soem::RemoteSOEM;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
RemoteSOEM::new("172.16.99.104:8080".parse()?);
Ok(())
}

#include <autd3_link_soem.hpp>

int main() {
using namespace autd3;
link::RemoteSOEM("172.16.99.104:8080");
return 0; }

using System.Net;
using AUTD3Sharp.Link;

new RemoteSOEM(new IPEndPoint(IPAddress.Parse("172.16.99.104"), 8080))
;

from pyautd3_link_soem import RemoteSOEM

RemoteSOEM("172.16.99.104:8080")

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
autd.send(ReadsFPGAState::new(|_dev| true))?;

let info = autd.fpga_state()?;
Ok(())
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
autd.send(ReadsFPGAState([](const auto&) { return true; }));

const auto info = autd.fpga_state();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
autd.Send(new ReadsFPGAState(_ => true));

var info = autd.FPGAState();

from pyautd3 import Controller, AUTD3, ReadsFPGAState
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
autd.send(ReadsFPGAState(lambda _: True))

info = autd.fpga_state()

use autd3::prelude::*;
use autd3::gain::IntoBoxedGain;

use std::collections::HashMap;
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut autd = Controller::open(
        [AUTD3::default(), AUTD3::default()],
        autd3::link::Nop::new(),
    )?;
    let x = 0.;
    let y = 0.;
    let z = 0.;
autd.group_send(
    |dev| match dev.idx() {
        0 => Some("focus"),
        1 => Some("null"),
        _ => None,
    },
    HashMap::from([
        (
            "focus",
            Focus {
                pos: Point3::new(x, y, z),
                option: Default::default(),
            }
            .into_boxed(),
        ),
        ("null", Null {}.into_boxed()),
    ]),
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
autd.group_send(
    [](const Device& dev) -> std::optional<const char*> {
      if (dev.idx() == 0) {
        return "null";
      } else if (dev.idx() == 1) {
        return "focus";
      } else {
        return std::nullopt;
      }
    },
    std::unordered_map<const char*, std::shared_ptr<driver::Datagram>>{
        {"focus",
         std::make_shared<Focus>(Focus(Point3(x, y, z), FocusOption{}))},
        {"null", std::make_shared<Null>()}});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Modulation;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
autd.GroupSend(dev =>
    {
        return dev.Idx() switch
        {
            0 => "null",
            1 => "focus",
            _ => null
        };
    },
    new GroupDictionary {
        { "null", new Null() },
        { "focus", new Focus(pos: new Point3(x, y, z), option: new FocusOption()) }
    }
);

from pyautd3 import AUTD3, Controller, Device
from pyautd3.gain import Focus, FocusOption, Null
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
x = 0.0
y = 0.0
z = 0.0
def key_map(dev: Device) -> str | None:
    if dev.idx == 0:
        return "null"
    if dev.idx == 1:
        return "focus"
    return None


autd.group_send(
    key_map=key_map,
    data_map={"null": Null(), "focus": Focus(pos=[x, y, z], option=FocusOption())},
)

use std::time::Duration;
use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let mut sender = autd.sender(SenderOption {
    send_interval: Duration::from_millis(1),
    receive_interval: Duration::from_millis(1),
    timeout: None,
    parallel: ParallelMode::Auto,
    sleeper: SpinSleeper::default(),
});
let d = Null {};
sender.send(d)?;
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd = Controller::open({AUTD3{}}, link::Nop{});
auto sender = autd.sender(SenderOption{
    .send_interval = std::chrono::milliseconds(1),
    .receive_interval = std::chrono::milliseconds(1),
    .timeout = std::nullopt,
    .parallel = ParallelMode::Auto,
    .sleeper = SpinSleeper(),
});
const Null d;
sender.send(d);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var sender = autd.Sender(
    new SenderOption
    {
        SendInterval = Duration.FromMillis(1),
        ReceiveInterval = Duration.FromMillis(1),
        Timeout = null,
        Parallel = ParallelMode.Auto,
        Sleeper = new SpinSleeper()
    }
);
var d = new Null();
sender.Send(d);

from pyautd3 import AUTD3, Controller, Duration, Null, SenderOption, SpinSleeper, ParallelMode
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
sender = autd.sender(
    SenderOption(
        send_interval=Duration.from_millis(1),
        receive_interval=Duration.from_millis(1),
        timeout=None,
        parallel=ParallelMode.Auto,
        sleeper=SpinSleeper(),
    )
)
d = Null()
sender.send(d)

use autd3::prelude::*;
fn main() {
let _ = 
Null {};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Null{};
return 0; }

using AUTD3Sharp.Gain;
new Null();

from pyautd3 import Null
Null()

use autd3::prelude::*;
fn main() {
let x = 0.;
let y = 0.;
let z = 0.;
let _ = 
Focus {
    pos: Point3::new(x, y, z),
    option: FocusOption {
        intensity: EmitIntensity::MAX,
        phase_offset: Phase::ZERO,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
Focus(Point3(x, y, z),
      FocusOption{
          .intensity = std::numeric_limits<EmitIntensity>::max(),
          .phase_offset = Phase::zero(),
      });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
new Focus(
    pos: new Point3(x, y, z),
    option: new FocusOption
    {
        Intensity = EmitIntensity.Max,
        PhaseOffset = Phase.Zero
    }
);

from pyautd3 import EmitIntensity, Focus, FocusOption, Phase

x = 1.0
y = 0.0
z = 0.0
Focus(
    pos=[x, y, z],
    option=FocusOption(
        intensity=EmitIntensity.MAX,
        phase_offset=Phase.ZERO,
    ),
)

use autd3::prelude::*;
fn main() {
let x = 0.;
let y = 0.;
let z = 0.;
let nx = 0.;
let ny = 0.;
let nz = 0.;
let theta = 0. * rad;
let _ = 
Bessel {
    pos: Point3::new(x, y, z),
    dir: UnitVector3::new_normalize(Vector3::new(nx, ny, nz)),
    theta,
    option: BesselOption {
        intensity: EmitIntensity::MAX,
        phase_offset: Phase::ZERO,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
const auto nx = 0.0;
const auto ny = 0.0;
const auto nz = 1.0;
const auto theta = 0.0;
Bessel(Point3(x, y, z), Vector3(nx, ny, nz), theta* rad,
       BesselOption{
           .intensity = std::numeric_limits<EmitIntensity>::max(),
           .phase_offset = Phase::zero(),
       });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
using static AUTD3Sharp.Units;
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
var nx = 0.0f;
var ny = 0.0f;
var nz = 1.0f;
var theta = 0.0f;
new Bessel(
    pos: new Point3(x, y, z),
    dir: new Vector3(nx, ny, nz),
    theta: theta * rad,
    option: new BesselOption
    {
        Intensity = EmitIntensity.Max,
        PhaseOffset = Phase.Zero
    }
);

from pyautd3 import Bessel, BesselOption, EmitIntensity, Phase, rad

x = 0.0
y = 0.0
z = 0.0
nx = 1.0
ny = 0.0
nz = 0.0
theta = 0.0
Bessel(
    pos=[x, y, z],
    direction=[nx, ny, nz],
    theta=theta * rad,
    option=BesselOption(
        intensity=EmitIntensity.MAX,
        phase_offset=Phase.ZERO,
    ),
)

use autd3::prelude::*;
fn main() {
let nx = 0.;
let ny = 0.;
let nz = 0.;
let _ = 
Plane {
    dir: UnitVector3::new_normalize(Vector3::new(nx, ny, nz)),
    option: PlaneOption {
        intensity: EmitIntensity::MAX,
        phase_offset: Phase::ZERO,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
const auto nx = 0.0;
const auto ny = 0.0;
const auto nz = 1.0;
Plane(Vector3(nx, ny, nz),
      PlaneOption{
          .intensity = std::numeric_limits<EmitIntensity>::max(),
          .phase_offset = Phase::zero(),
      });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
var nx = 0.0f;
var ny = 0.0f;
var nz = 1.0f;
new Plane(
    dir: new Vector3(nx, ny, nz),
    option: new PlaneOption
    {
        Intensity = EmitIntensity.Max,
        PhaseOffset = Phase.Zero
    }
);

from pyautd3 import EmitIntensity, Phase, Plane, PlaneOption
nx = 1.0
ny = 0.0
nz = 0.0
Plane(
    direction=[nx, ny, nz],
    option=PlaneOption(
        intensity=EmitIntensity.MAX,
        phase_offset=Phase.ZERO,
    ),
)

use autd3::prelude::*;
fn main() {
let _ = 
Uniform {
    intensity: EmitIntensity::MAX, 
    phase: Phase::ZERO,
};
}

#include<autd3.hpp>
#include <limits>
int main() {
using namespace autd3;
Uniform(std::numeric_limits<EmitIntensity>::max(), Phase::zero());
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Gain;
new Uniform(
    intensity: EmitIntensity.Max,
    phase: Phase.Zero
);

from pyautd3 import EmitIntensity, Phase, Uniform
Uniform(intensity=EmitIntensity.MAX, phase=Phase.ZERO)

use autd3::gain::Custom;
use autd3::prelude::*;

fn main() {
let _ =
Custom::new(|_dev| {
    |_tr| Drive {
        phase: Phase::ZERO,
        intensity: EmitIntensity::MIN,
    }
});
}

#include<autd3.hpp>
#include <autd3/gain/custom.hpp>

int main() {
using namespace autd3;
gain::Custom([](const auto& dev) {
  return [](const auto& tr) {
    return Drive(Phase::zero(), std::numeric_limits<EmitIntensity>::min());
  };
});
return 0; }

using System;
using AUTD3Sharp;
using AUTD3Sharp.Gain;
using static AUTD3Sharp.Units;

new Custom(dev => tr => new Drive(Phase.Zero, EmitIntensity.Min));

from pyautd3 import Drive, EmitIntensity, Phase
from pyautd3.gain import Custom

Custom(lambda _dev: lambda _tr: Drive(phase=Phase.ZERO, intensity=EmitIntensity.MIN))

use autd3::gain::IntoBoxedGain;
use autd3::prelude::*;
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let x = 0.;
let y = 0.;
let z = 0.;
let _ =
Group {
    key_map: |_dev| {
        |tr| match tr.idx() {
            0..=100 => Some("null"),
            _ => Some("focus"),
        }
    },
    gain_map: HashMap::from([
        ("null", Null {}.into_boxed()),
        (
            "focus",
            Focus {
                pos: Point3::new(x, y, z),
                option: Default::default(),
            }
            .into_boxed(),
        ),
    ]),
};
Ok(())
}

#include<optional>
#include<autd3.hpp>
int main() {
using namespace autd3;
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
Group(
    [](const auto& dev) {
      return [](const auto& tr) -> std::optional<const char*> {
        if (tr.idx() <= 100) return "null";
        return "focus";
      };
    },
    std::unordered_map<const char*, std::shared_ptr<Gain>>{
        {"focus", std::make_shared<Focus>(Point3(x, y, z), FocusOption{})},
        {"null", std::make_shared<Null>()}});
return 0; }

using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Driver.Datagram;
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
new Group(
    keyMap: dev => tr => tr.Idx() <= 100 ? "null" : "focus",
    gainMap: new Dictionary<object, IGain> {
        { "null", new Null() },
        { "focus", new Focus(pos: new Point3(x, y, z), option: new FocusOption()) }
    }
);

from pyautd3 import Focus, FocusOption, Group, Null
x = 1.0
y = 0.0
z = 0.0
Group(
    key_map=lambda _: lambda tr: "null" if tr.idx() <= 100 else "focus",
    gain_map={"null": Null(), "focus": Focus(pos=[x, y, z], option=FocusOption())},
)

cargo add autd3-gain-holo

target_link_libraries(<TARGET> PRIVATE autd3::gain::holo)

Included in the main library.

Included in the main library.

Included in the main library.

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, Naive, NaiveOption};
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
Naive {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: NaiveOption {
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::Naive(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::NaiveOption{
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new Naive(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new NaiveOption
    {
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import Naive, EmissionConstraint, NaiveOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
Naive(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=NaiveOption(
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, GS, GSOption};
use std::num::NonZeroUsize;
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
GS {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: GSOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::GS(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::GSOption{
        .repeat = 100,
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new GS(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new GSOption
    {
        Repeat = 100,
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import GS, EmissionConstraint, GSOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
GS(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=GSOption(
        repeat=100,
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, GSPAT, GSPATOption};
use std::num::NonZeroUsize;
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
GSPAT {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: GSPATOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::GSPAT(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::GSPATOption{
        .repeat = 100,
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new GSPAT(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new GSPATOption
    {
        Repeat = 100,
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import GSPAT, EmissionConstraint, GSPATOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
GSPAT(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=GSPATOption(
        repeat=100,
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, LM, LMOption};
use std::num::NonZeroUsize;
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
LM {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: LMOption {
        eps_1: 1e-8,
        eps_2: 1e-8,
        tau: 1e-3,
        k_max: NonZeroUsize::new(5).unwrap(),
        initial: vec![],
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::LM(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::LMOption{
        .eps_1 = 1e-8,
        .eps_2 = 1e-8,
        .tau = 1e-3,
        .k_max = 5,
        .initial = {},
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new LM(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new LMOption
    {
        Eps1 = 1e-8f,
        Eps2 = 1e-8f,
        Tau = 1e-3f,
        KMax = 5,
        Initial = [],
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import LM, EmissionConstraint, LMOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
LM(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=LMOption(
        eps_1=1e-8,
        eps_2=1e-8,
        tau=1e-3,
        k_max=5,
        initial = None,
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, Pa, Greedy, GreedyOption, Sphere};
use std::num::NonZeroU8;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let _ = 
Greedy::<Sphere> {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: GreedyOption {
        phase_div: NonZeroU8::new(16).unwrap(),
        constraint: EmissionConstraint::Uniform(EmitIntensity::MAX),
        ..Default::default()
    },
};
}

#include <autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
auto g = gain::holo::Greedy(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::GreedyOption{
        .phase_div = 16,
        .constraint = gain::holo::EmissionConstraint::Uniform(
            std::numeric_limits<EmitIntensity>::max())});
  return 0;
}

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
new Greedy(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new GreedyOption
    {
        PhaseDiv = 16,
        EmissionConstraint = EmissionConstraint.Uniform(EmitIntensity.Max),
    }
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import Greedy, EmissionConstraint, GreedyOption, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
Greedy(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=GreedyOption(
        phase_div=16,
        constraint=EmissionConstraint.Uniform(EmitIntensity.MAX),
    ),
)

use autd3::prelude::*;
use autd3::gain::Cache;

fn main() {
let _ = 
Cache::new(Null::new());
}

#include<autd3.hpp>
#include <autd3/gain/cache.hpp>

int main() {
using namespace autd3;
gain::Cache(Null{});
return 0; }

using AUTD3Sharp.Gain;

new Cache(new Null());

from pyautd3 import Null
from pyautd3.gain import Cache

Cache(Null())

use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let stm = FociSTM {
    foci: vec![Point3::origin(), Point3::origin()],
    config: 1.0 * Hz,
};
dbg!(stm.sampling_config()?.freq()?); // -> 2Hz
Ok(())
}

#include<iostream>
#include<autd3.hpp>
int main() {
using namespace autd3;
FociSTM stm(
    std::vector{
        Point3::origin(),
        Point3::origin(),
    },
    1.0f * Hz);
std::cout << stm.sampling_config().freq() << std::endl;  // -> 2Hz
                                                         return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var stm = new FociSTM(foci: [Point3.Origin, Point3.Origin], config: 1.0f * Hz);
Console.WriteLine(stm.SamplingConfig().Freq()); // -> 2 Hz

import numpy as np
from pyautd3 import FociSTM, Hz
stm = FociSTM(
    foci=[np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, 0.0])],
    config=1.0 * Hz,
)
print(stm.sampling_config().freq())  # -> 2Hz

use autd3::prelude::*;
fn main() {
let start = Point3::origin();
let end = Point3::origin();
let center = Point3::origin();
let radius = 30.0 * mm;
let num_points = 50;
let n = Vector3::z_axis();
let intensity = EmitIntensity::MAX;
let _ = 
FociSTM {
    foci: Line {
        start,
        end,
        num_points,
        intensity,
    },
    config: 1.0 * Hz,
};

let _ = 
FociSTM {
    foci: Circle {
        center,
        radius,
        num_points,
        n, // normal vector to the plane where the circle is drawn
        intensity,
    },
    config: 1.0 * Hz,
};
}

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
FociSTM {
    foci: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            center + p
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<Point3> foci;
std::ranges::copy(iota(0) | take(points_num) | transform([&](auto i) {
                    const auto theta = 2.0f * pi * static_cast<float>(i) /
                                       static_cast<float>(points_num);
                    Point3 p = center + radius * Vector3(std::cos(theta),
                                                         std::sin(theta), 0);
                    return p;
                  }),
                  std::back_inserter(foci));
FociSTM(foci, 1.0f * Hz);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new FociSTM(
    foci: Enumerable.Range(0, pointNum).Select(i =>
    {
        var theta = 2.0f * MathF.PI * i / pointNum;
        return center + radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0);
    }),
    config: 1.0f * Hz
);

import numpy as np
from pyautd3 import FociSTM, Hz
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
FociSTM(
    foci=(
        center + radius * np.array([np.cos(theta), np.sin(theta), 0])
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
)

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
FociSTM {
    foci: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            ControlPoints {
                points: [
                    ControlPoint {
                        point: center + p,
                        phase_offset: Phase::ZERO,
                    },
                    ControlPoint {
                        point: center - p,
                        phase_offset: Phase::ZERO,
                    },
                ],
                intensity: EmitIntensity::MAX,
            }
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<ControlPoints<2>> foci;
std::ranges::copy(
    iota(0) | take(points_num) | transform([&](auto i) {
      const auto theta =
          2.0f * pi * static_cast<float>(i) / static_cast<float>(points_num);
      Vector3 p = radius * Vector3(std::cos(theta), std::sin(theta), 0);
      return ControlPoints<2>{
          .points = std::array{ControlPoint{.point = center + p,
                                            .phase_offset = Phase::zero()},
                               ControlPoint{.point = center - p,
                                            .phase_offset = Phase::zero()}},
          .intensity = std::numeric_limits<EmitIntensity>::max()};
    }),
    std::back_inserter(foci));
FociSTM stm(foci, 1.0f * Hz);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new FociSTM(
    foci: Enumerable.Range(0, pointNum).Select(i =>
        {
            var theta = 2.0f * MathF.PI * i / pointNum;
            var p = radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0);
            return new ControlPoints(
                points: [
                    new ControlPoint { Point = center + p, PhaseOffset = Phase.Zero},
                    new ControlPoint { Point = center - p, PhaseOffset = Phase.Zero}
                ],
                intensity: EmitIntensity.Max
            );
        }),
    config: 1.0f * Hz
);

import numpy as np
from pyautd3 import ControlPoint, ControlPoints, EmitIntensity, FociSTM, Hz, Phase
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
FociSTM(
    foci=(
        ControlPoints(
            points=[
                ControlPoint(
                    point=center + radius * np.array([np.cos(theta), np.sin(theta), 0]),
                    phase_offset=Phase.ZERO,
                ),
                ControlPoint(
                    point=center - radius * np.array([np.cos(theta), np.sin(theta), 0]),
                    phase_offset=Phase.ZERO,
                ),
            ],
            intensity=EmitIntensity.MAX,
        )
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
)

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
GainSTM {
    gains: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            Focus {
                pos: center + p,
                option: FocusOption::default(),
            }
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
    option: GainSTMOption {
        mode: GainSTMMode::PhaseIntensityFull,
    },
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<Focus> gains;
std::ranges::copy(iota(0) | take(points_num) | transform([&](auto i) {
                    const auto theta = 2.0f * pi * static_cast<float>(i) /
                                       static_cast<float>(points_num);
                    return Focus(center + radius * Vector3(std::cos(theta),
                                                           std::sin(theta), 0),
                                 FocusOption{});
                  }),
                  std::back_inserter(gains));
GainSTM(gains, 1.0f * Hz,
        GainSTMOption{.mode = GainSTMMode::PhaseIntensityFull});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new GainSTM(
    gains: Enumerable.Range(0, pointNum).Select(i =>
    {
        var theta = 2.0f * MathF.PI * i / pointNum;
        return new Focus(
            pos: center + radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0),
            option: new FocusOption()
        );
    }),
    config: 1.0f * Hz,
    option: new GainSTMOption
    {
        Mode = GainSTMMode.PhaseIntensityFull
    }
);

import numpy as np
from pyautd3 import Focus, FocusOption, GainSTM, GainSTMMode, GainSTMOption, Hz
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
GainSTM(
    gains=(
        Focus(
            pos=center + radius * np.array([np.cos(theta), np.sin(theta), 0]),
            option=FocusOption(),
        )
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
    option=GainSTMOption(
        mode=GainSTMMode.PhaseIntensityFull,
    ),
)

use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let m = Sine {
    freq: 150 * Hz,
    option: SineOption::default(),
};
dbg!(m.sampling_config().freq()?); // -> 4kHz
    Ok(())
}

#include<iostream>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
const auto m = Sine(150 * Hz, SineOption{});
std::cout << m.sampling_config().freq() << std::endl;  // -> 4kHz
                                                       return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
var m = new Sine(freq: 150u * Hz, option: new SineOption());
Console.WriteLine(m.SamplingConfig().Freq()); // -> 4kHz

from pyautd3 import Hz
from pyautd3.modulation import Sine, SineOption
m = Sine(freq=150 * Hz, option=SineOption())
print(m.sampling_config().freq())  # -> 4kHz

use autd3::prelude::*;
fn main() {
let _ = 
Static { intensity: 0xFF };
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Static(0xFF);
return 0; }

using AUTD3Sharp.Modulation;
new Static(intensity: 0xFF);

from pyautd3 import Static
Static(intensity=0xFF)

use autd3::prelude::*;
fn main() {
let _ = 
Sine {
    freq: 150 * Hz,
    option: SineOption {
        intensity: u8::MAX,
        offset: 0x80,
        phase: 0. * rad,
        clamp: false,
        sampling_config: SamplingConfig::FREQ_4K,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Sine(150 * Hz, SineOption{
                   .intensity = 0xFF,
                   .offset = 0x80,
                   .phase = 0.0f * rad,
                   .clamp = false,
                   .sampling_config = SamplingConfig::freq_4k(),
               });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Sine(
    freq: 150u * Hz,
    option: new SineOption
    {
        Intensity = 0xFF,
        Offset = 0x80,
        Phase = 0f * rad,
        Clamp = false,
        SamplingConfig = SamplingConfig.Freq4K
    }
);

from pyautd3 import Hz, SamplingConfig, Sine, SineOption, rad
Sine(
    freq=150 * Hz,
    option=SineOption(
        intensity=0xFF,
        offset=0x80,
        phase=0.0 * rad,
        clamp=False,
        sampling_config=SamplingConfig.FREQ_4K,
    ),
)

use autd3::prelude::*;
fn main() {
    let _ = 
Sine {
    freq: 150. * Hz,
    option: SineOption::default(),
}
.into_nearest();
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Sine(150.0f * Hz, SineOption{}).into_nearest();
return 0; }

using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Sine(freq: 150.0f * Hz, option: new SineOption()).IntoNearest();

from pyautd3 import Hz, Sine, SineOption
Sine(freq=150.0 * Hz, option=SineOption()).into_nearest()

use autd3::modulation::{Fourier, FourierOption};
use autd3::prelude::*;

fn main() {
let _ = 
Fourier {
    components: vec![
        Sine {
            freq: 100 * Hz,
            option: Default::default(),
        },
        Sine {
            freq: 150 * Hz,
            option: Default::default(),
        },
    ],
    option: FourierOption {
        scale_factor: None,
        clamp: false,
        offset: 0x00,
    },
};
}

#include<autd3.hpp>
#include <autd3/modulation/fourier.hpp>

int main() {
using namespace autd3;
modulation::Fourier({Sine(100 * Hz, SineOption{}),
                     Sine(150 * Hz, SineOption{})},
                    modulation::FourierOption{
                        .scale_factor = std::nullopt,
                        .clamp = false,
                        .offset = 0x00,
                    });

return 0; }

using AUTD3Sharp.Modulation;

using static AUTD3Sharp.Units;
new Fourier(
    components: [
        new Sine(freq: 100u * Hz, option: new SineOption()),
        new Sine(freq: 150u * Hz, option: new SineOption())
    ],
    option: new FourierOption
    {
        ScaleFactor = null,
        Clamp = false,
        Offset = 0x00
    }
);

from pyautd3 import Hz, Sine, SineOption
from pyautd3.modulation import Fourier, FourierOption

Fourier(
    components=[
        Sine(freq=100 * Hz, option=SineOption()),
        Sine(freq=150 * Hz, option=SineOption()),
    ],
    option=FourierOption(
        scale_factor=None,
        clamp=False,
        offset=0x00,
    ),
)

use autd3::prelude::*;
fn main() {
let _ = 
Square {
    freq: 150 * Hz,
    option: SquareOption {
        low: u8::MIN,
        high: u8::MAX,
        duty: 0.5,
        sampling_config: SamplingConfig::FREQ_4K,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Square(150 * Hz, SquareOption{
                     .low = 0x00,
                     .high = 0xFF,
                     .duty = 0.5f,
                     .sampling_config = SamplingConfig::freq_4k(),
                 });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Square(
    freq: 150u * Hz,
    option: new SquareOption
    {
        Low = 0x00,
        High = 0xFF,
        Duty = 0.5f,
        SamplingConfig = SamplingConfig.Freq4K
    }
);

from pyautd3 import Hz, SamplingConfig, Square, SquareOption
Square(
    freq=150 * Hz,
    option=SquareOption(
        low=0x00,
        high=0xFF,
        duty=0.5,
        sampling_config=SamplingConfig.FREQ_4K,
    ),
)

use autd3::prelude::*;
fn main() {
let _ = 
Square {
    freq: 150.0 * Hz,
    option: Default::default(),
}
.into_nearest();
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Square(150.0f * Hz, SquareOption{}).into_nearest();
return 0; }

using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Square(freq: 150.0f * Hz, option: new SquareOption()).IntoNearest();

from pyautd3 import Hz, Square, SquareOption
Square(freq=150.0 * Hz, option=SquareOption()).into_nearest()

cargo add autd3-modulation-audio-file

target_link_libraries(<TARGET> PRIVATE autd3::modulation::audio_file)

Included in the main library.

Included in the main library.

Included in the main library.

use autd3_modulation_audio_file::Wav;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
Wav::new("path/to/foo.wav")?;
Ok(())
}

#include<autd3.hpp>
#include "autd3/modulation/audio_file.hpp"

int main() {
using namespace autd3;
modulation::audio_file::Wav("path/to/foo.wav");
return 0; }

using AUTD3Sharp.Modulation.AudioFile;

new Wav(path: "path/to/foo.wav");

import pathlib
from pyautd3.modulation.audio_file import Wav

Wav(path=pathlib.Path("path/to/foo.wav"))

cargo add autd3-modulation-audio-file

target_link_libraries(<TARGET> PRIVATE autd3::modulation::audio_file)

Included in the main library.

Included in the main library.

Included in the main library.

use autd3::prelude::*;
use autd3_modulation_audio_file::{Csv, CsvOption};

fn main() {
let _ = 
Csv {
    path: "path/to/foo.csv",
    sampling_config: 4000.0 * Hz,
    option: CsvOption { delimiter: b',' },
};
}

#include<autd3.hpp>
#include "autd3/modulation/audio_file.hpp"

int main() {
using namespace autd3;
const auto path = "path/to/foo.csv";
modulation::audio_file::Csv(path, 4000.0f * Hz,
                            modulation::audio_file::CsvOption{
                                .delimiter = ',',
                            });
return 0; }

using AUTD3Sharp.Modulation.AudioFile;

using static AUTD3Sharp.Units;
new Csv(
    path: "path/to/foo.csv",
    samplingConfig: 4000f * Hz,
    option: new CsvOption
    {
        Delimiter = ',',
    }
);

import pathlib
from pyautd3 import Hz
from pyautd3.modulation.audio_file import Csv, CsvOption

Csv(
    path=pathlib.Path("path/to/foo.csv"),
    sampling_config=4000.0 * Hz,
    option=CsvOption(
        delimiter=",",
    ),
)

use autd3::modulation::Custom;

use autd3::prelude::*;
fn main() {
let _ = 
Custom {
    buffer: vec![0xFF, 0x00],
    sampling_config: 4.0 * kHz,
};
}

#include<vector>
#include<autd3.hpp>
#include <autd3/modulation/custom.hpp>

int main() {
using namespace autd3;
modulation::Custom(std::vector<uint8_t>{0xFF, 0x00}, 4000.0f * Hz);
return 0; }

using AUTD3Sharp;
using static AUTD3Sharp.Units;
using AUTD3Sharp.Modulation;

new Custom(
    buffer: [0xFF, 0x00],
    samplingConfig: 4000f * Hz
);

from pyautd3 import Hz
import numpy as np
from pyautd3.modulation import Custom

Custom(
    buffer=np.array([0xFF, 0x00]),
    sampling_config=4000.0 * Hz,
)

use autd3::prelude::*;
use autd3::modulation::Cache;

fn main() {
let _ = 
Cache::new(Static::default());
}

#include<autd3.hpp>
#include <autd3/modulation/cache.hpp>

int main() {
using namespace autd3;
modulation::Cache(Static{});
return 0; }

using AUTD3Sharp.Modulation;

new Cache(new Static());

from pyautd3 import Static
from pyautd3.modulation import Cache

Cache(Static())

use autd3::prelude::*;
use autd3::modulation::RadiationPressure;
 
fn main() {
let _ = 
RadiationPressure {
    target: Sine {
        freq: 150 * Hz,
        option: Default::default(),
    },
};
}

#include<autd3.hpp>
#include <autd3/modulation/radiation_pressure.hpp>

int main() {
using namespace autd3;
modulation::RadiationPressure(Sine(150 * Hz, SineOption{}));
return 0; }

using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;

new RadiationPressure(target: new Sine(freq: 150u * Hz, option: new SineOption()));

from pyautd3 import Hz, Sine, SineOption
from pyautd3.modulation import RadiationPressure

RadiationPressure(target=Sine(freq=150 * Hz, option=SineOption()))

use autd3::prelude::*;
use autd3::modulation::Fir;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
Fir {
    target: Sine {
        freq: 150. * Hz,
        option: SineOption {
            sampling_config: SamplingConfig::new(20.0 * kHz),
            ..Default::default()
        },
    },
    coef: vec![
        -0.000009, -0.000013, -0.000016, -0.000021, -0.000025, -0.000030, -0.000036,
        -0.000042, -0.000049, -0.000056, -0.000064, -0.000072, -0.000080, -0.000088,
        -0.000096, -0.000105, -0.000113, -0.000120, -0.000128, -0.000134, -0.000139,
        -0.000143, -0.000146, -0.000146, -0.000145, -0.000141, -0.000135, -0.000124,
        -0.000111, -0.000093, -0.000071, -0.000044, -0.000012, 0.000026, 0.000071,
        0.000122, 0.000180, 0.000247, 0.000321, 0.000405, 0.000497, 0.000599, 0.000712,
        0.000835, 0.000968, 0.001113, 0.001270, 0.001439, 0.001619, 0.001812, 0.002018,
        0.002236, 0.002467, 0.002711, 0.002968, 0.003237, 0.003518, 0.003812, 0.004118,
        0.004435, 0.004764, 0.005103, 0.005452, 0.005811, 0.006178, 0.006554, 0.006937,
        0.007326, 0.007720, 0.008119, 0.008521, 0.008925, 0.009331, 0.009737, 0.010141,
        0.010543, 0.010941, 0.011335, 0.011722, 0.012101, 0.012472, 0.012833, 0.013183,
        0.013520, 0.013843, 0.014152, 0.014445, 0.014720, 0.014978, 0.015217, 0.015435,
        0.015633, 0.015810, 0.015964, 0.016096, 0.016204, 0.016289, 0.016350, 0.016386,
        0.016399, 0.016386, 0.016350, 0.016289, 0.016204, 0.016096, 0.015964, 0.015810,
        0.015633, 0.015435, 0.015217, 0.014978, 0.014720, 0.014445, 0.014152, 0.013843,
        0.013520, 0.013183, 0.012833, 0.012472, 0.012101, 0.011722, 0.011335, 0.010941,
        0.010543, 0.010141, 0.009737, 0.009331, 0.008925, 0.008521, 0.008119, 0.007720,
        0.007326, 0.006937, 0.006554, 0.006178, 0.005811, 0.005452, 0.005103, 0.004764,
        0.004435, 0.004118, 0.003812, 0.003518, 0.003237, 0.002968, 0.002711, 0.002467,
        0.002236, 0.002018, 0.001812, 0.001619, 0.001439, 0.001270, 0.001113, 0.000968,
        0.000835, 0.000712, 0.000599, 0.000497, 0.000405, 0.000321, 0.000247, 0.000180,
        0.000122, 0.000071, 0.000026, -0.000012, -0.000044, -0.000071, -0.000093,
        -0.000111, -0.000124, -0.000135, -0.000141, -0.000145, -0.000146, -0.000146,
        -0.000143, -0.000139, -0.000134, -0.000128, -0.000120, -0.000113, -0.000105,
        -0.000096, -0.000088, -0.000080, -0.000072, -0.000064, -0.000056, -0.000049,
        -0.000042, -0.000036, -0.000030, -0.000025, -0.000021, -0.000016, -0.000013,
        -0.000009,
    ],
};
Ok(())
}

#include<autd3.hpp>
#include <autd3/modulation/fir.hpp>

int main() {
using namespace autd3;
modulation::Fir(
    Sine(150 * Hz,
         SineOption{
             .sampling_config = SamplingConfig(20.0f * kHz),
         }),
    std::vector{
        -0.000009f, -0.000013f, -0.000016f, -0.000021f, -0.000025f, -0.000030f,
        -0.000036f, -0.000042f, -0.000049f, -0.000056f, -0.000064f, -0.000072f,
        -0.000080f, -0.000088f, -0.000096f, -0.000105f, -0.000113f, -0.000120f,
        -0.000128f, -0.000134f, -0.000139f, -0.000143f, -0.000146f, -0.000146f,
        -0.000145f, -0.000141f, -0.000135f, -0.000124f, -0.000111f, -0.000093f,
        -0.000071f, -0.000044f, -0.000012f, 0.000026f,  0.000071f,  0.000122f,
        0.000180f,  0.000247f,  0.000321f,  0.000405f,  0.000497f,  0.000599f,
        0.000712f,  0.000835f,  0.000968f,  0.001113f,  0.001270f,  0.001439f,
        0.001619f,  0.001812f,  0.002018f,  0.002236f,  0.002467f,  0.002711f,
        0.002968f,  0.003237f,  0.003518f,  0.003812f,  0.004118f,  0.004435f,
        0.004764f,  0.005103f,  0.005452f,  0.005811f,  0.006178f,  0.006554f,
        0.006937f,  0.007326f,  0.007720f,  0.008119f,  0.008521f,  0.008925f,
        0.009331f,  0.009737f,  0.010141f,  0.010543f,  0.010941f,  0.011335f,
        0.011722f,  0.012101f,  0.012472f,  0.012833f,  0.013183f,  0.013520f,
        0.013843f,  0.014152f,  0.014445f,  0.014720f,  0.014978f,  0.015217f,
        0.015435f,  0.015633f,  0.015810f,  0.015964f,  0.016096f,  0.016204f,
        0.016289f,  0.016350f,  0.016386f,  0.016399f,  0.016386f,  0.016350f,
        0.016289f,  0.016204f,  0.016096f,  0.015964f,  0.015810f,  0.015633f,
        0.015435f,  0.015217f,  0.014978f,  0.014720f,  0.014445f,  0.014152f,
        0.013843f,  0.013520f,  0.013183f,  0.012833f,  0.012472f,  0.012101f,
        0.011722f,  0.011335f,  0.010941f,  0.010543f,  0.010141f,  0.009737f,
        0.009331f,  0.008925f,  0.008521f,  0.008119f,  0.007720f,  0.007326f,
        0.006937f,  0.006554f,  0.006178f,  0.005811f,  0.005452f,  0.005103f,
        0.004764f,  0.004435f,  0.004118f,  0.003812f,  0.003518f,  0.003237f,
        0.002968f,  0.002711f,  0.002467f,  0.002236f,  0.002018f,  0.001812f,
        0.001619f,  0.001439f,  0.001270f,  0.001113f,  0.000968f,  0.000835f,
        0.000712f,  0.000599f,  0.000497f,  0.000405f,  0.000321f,  0.000247f,
        0.000180f,  0.000122f,  0.000071f,  0.000026f,  -0.000012f, -0.000044f,
        -0.000071f, -0.000093f, -0.000111f, -0.000124f, -0.000135f, -0.000141f,
        -0.000145f, -0.000146f, -0.000146f, -0.000143f, -0.000139f, -0.000134f,
        -0.000128f, -0.000120f, -0.000113f, -0.000105f, -0.000096f, -0.000088f,
        -0.000080f, -0.000072f, -0.000064f, -0.000056f, -0.000049f, -0.000042f,
        -0.000036f, -0.000030f, -0.000025f, -0.000021f, -0.000016f, -0.000013f,
        -0.000009f});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;

new Fir(
    target: new Sine(freq: 150u * Hz, option: new SineOption
    {
        SamplingConfig = new SamplingConfig(20f * kHz)
    }),
    coef: [-0.000009f, -0.000013f, -0.000016f, -0.000021f, -0.000025f,
            -0.000030f, -0.000036f, -0.000042f, -0.000049f, -0.000056f,
            -0.000064f, -0.000072f, -0.000080f, -0.000088f, -0.000096f,
            -0.000105f, -0.000113f, -0.000120f, -0.000128f, -0.000134f,
            -0.000139f, -0.000143f, -0.000146f, -0.000146f, -0.000145f,
            -0.000141f, -0.000135f, -0.000124f, -0.000111f, -0.000093f,
            -0.000071f, -0.000044f, -0.000012f, 0.000026f,  0.000071f,
            0.000122f,  0.000180f,  0.000247f,  0.000321f,  0.000405f,
            0.000497f,  0.000599f,  0.000712f,  0.000835f,  0.000968f,
            0.001113f,  0.001270f,  0.001439f,  0.001619f,  0.001812f,
            0.002018f,  0.002236f,  0.002467f,  0.002711f,  0.002968f,
            0.003237f,  0.003518f,  0.003812f,  0.004118f,  0.004435f,
            0.004764f,  0.005103f,  0.005452f,  0.005811f,  0.006178f,
            0.006554f,  0.006937f,  0.007326f,  0.007720f,  0.008119f,
            0.008521f,  0.008925f,  0.009331f,  0.009737f,  0.010141f,
            0.010543f,  0.010941f,  0.011335f,  0.011722f,  0.012101f,
            0.012472f,  0.012833f,  0.013183f,  0.013520f,  0.013843f,
            0.014152f,  0.014445f,  0.014720f,  0.014978f,  0.015217f,
            0.015435f,  0.015633f,  0.015810f,  0.015964f,  0.016096f,
            0.016204f,  0.016289f,  0.016350f,  0.016386f,  0.016399f,
            0.016386f,  0.016350f,  0.016289f,  0.016204f,  0.016096f,
            0.015964f,  0.015810f,  0.015633f,  0.015435f,  0.015217f,
            0.014978f,  0.014720f,  0.014445f,  0.014152f,  0.013843f,
            0.013520f,  0.013183f,  0.012833f,  0.012472f,  0.012101f,
            0.011722f,  0.011335f,  0.010941f,  0.010543f,  0.010141f,
            0.009737f,  0.009331f,  0.008925f,  0.008521f,  0.008119f,
            0.007720f,  0.007326f,  0.006937f,  0.006554f,  0.006178f,
            0.005811f,  0.005452f,  0.005103f,  0.004764f,  0.004435f,
            0.004118f,  0.003812f,  0.003518f,  0.003237f,  0.002968f,
            0.002711f,  0.002467f,  0.002236f,  0.002018f,  0.001812f,
            0.001619f,  0.001439f,  0.001270f,  0.001113f,  0.000968f,
            0.000835f,  0.000712f,  0.000599f,  0.000497f,  0.000405f,
            0.000321f,  0.000247f,  0.000180f,  0.000122f,  0.000071f,
            0.000026f,  -0.000012f, -0.000044f, -0.000071f, -0.000093f,
            -0.000111f, -0.000124f, -0.000135f, -0.000141f, -0.000145f,
            -0.000146f, -0.000146f, -0.000143f, -0.000139f, -0.000134f,
            -0.000128f, -0.000120f, -0.000113f, -0.000105f, -0.000096f,
            -0.000088f, -0.000080f, -0.000072f, -0.000064f, -0.000056f,
            -0.000049f, -0.000042f, -0.000036f, -0.000030f, -0.000025f,
            -0.000021f, -0.000016f, -0.000013f, -0.000009f]
);

from pyautd3 import Hz, Sine, SineOption, kHz, SamplingConfig
from pyautd3.modulation import Fir

Fir(
    target=Sine(
        freq=150 * Hz,
        option=SineOption(
            sampling_config=SamplingConfig(20.0 * kHz),
        ),
    ),
    coef=[
        -0.000009, -0.000013, -0.000016, -0.000021, -0.000025, -0.000030, -0.000036,
        -0.000042, -0.000049, -0.000056, -0.000064, -0.000072, -0.000080, -0.000088,
        -0.000096, -0.000105, -0.000113, -0.000120, -0.000128, -0.000134, -0.000139,
        -0.000143, -0.000146, -0.000146, -0.000145, -0.000141, -0.000135, -0.000124,
        -0.000111, -0.000093, -0.000071, -0.000044, -0.000012, 0.000026, 0.000071,
        0.000122, 0.000180, 0.000247, 0.000321, 0.000405, 0.000497, 0.000599, 0.000712,
        0.000835, 0.000968, 0.001113, 0.001270, 0.001439, 0.001619, 0.001812, 0.002018,
        0.002236, 0.002467, 0.002711, 0.002968, 0.003237, 0.003518, 0.003812, 0.004118,
        0.004435, 0.004764, 0.005103, 0.005452, 0.005811, 0.006178, 0.006554, 0.006937,
        0.007326, 0.007720, 0.008119, 0.008521, 0.008925, 0.009331, 0.009737, 0.010141,
        0.010543, 0.010941, 0.011335, 0.011722, 0.012101, 0.012472, 0.012833, 0.013183,
        0.013520, 0.013843, 0.014152, 0.014445, 0.014720, 0.014978, 0.015217, 0.015435,
        0.015633, 0.015810, 0.015964, 0.016096, 0.016204, 0.016289, 0.016350, 0.016386,
        0.016399, 0.016386, 0.016350, 0.016289, 0.016204, 0.016096, 0.015964, 0.015810,
        0.015633, 0.015435, 0.015217, 0.014978, 0.014720, 0.014445, 0.014152, 0.013843,
        0.013520, 0.013183, 0.012833, 0.012472, 0.012101, 0.011722, 0.011335, 0.010941,
        0.010543, 0.010141, 0.009737, 0.009331, 0.008925, 0.008521, 0.008119, 0.007720,
        0.007326, 0.006937, 0.006554, 0.006178, 0.005811, 0.005452, 0.005103, 0.004764,
        0.004435, 0.004118, 0.003812, 0.003518, 0.003237, 0.002968, 0.002711, 0.002467,
        0.002236, 0.002018, 0.001812, 0.001619, 0.001439, 0.001270, 0.001113, 0.000968,
        0.000835, 0.000712, 0.000599, 0.000497, 0.000405, 0.000321, 0.000247, 0.000180,
        0.000122, 0.000071, 0.000026, -0.000012, -0.000044, -0.000071, -0.000093,
        -0.000111, -0.000124, -0.000135, -0.000141, -0.000145, -0.000146, -0.000146,
        -0.000143, -0.000139, -0.000134, -0.000128, -0.000120, -0.000113, -0.000105,
        -0.000096, -0.000088, -0.000080, -0.000072, -0.000064, -0.000056, -0.000049,
        -0.000042, -0.000036, -0.000030, -0.000025, -0.000021, -0.000016, -0.000013,
        -0.000009,
    ],
)

use std::num::NonZeroU16;
use std::time::Duration;
use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
SamplingConfig::new(NonZeroU16::new(10).unwrap());
// or
let _ = 
SamplingConfig::new(4000.0 * Hz);
// or
let _ = 
SamplingConfig::new(Duration::from_micros(250));
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
SamplingConfig(10);
// or
SamplingConfig(4000.0f * Hz);
// or
SamplingConfig(std::chrono::microseconds(250));
return 0; }

using AUTD3Sharp;
using static AUTD3Sharp.Units;
new SamplingConfig(10);
// or
new SamplingConfig(4000f * Hz);
// or
new SamplingConfig(Duration.FromMicros(250));

from pyautd3 import Duration, Hz, SamplingConfig
SamplingConfig(10)
# or
SamplingConfig(4000.0 * Hz)
# or
SamplingConfig(Duration.from_micros(250))

use std::time::Duration;
use autd3::prelude::*;
fn main() {
let _ = 
SamplingConfig::new(4000.0 * Hz).into_nearest();
// or
let _ = 
SamplingConfig::new(Duration::from_micros(250)).into_nearest();
}

#include<autd3.hpp>
#include<chrono>
int main() {
using namespace autd3;
const auto s =
SamplingConfig(4000.0f * Hz).into_nearest();
// or
const auto sp =
SamplingConfig(std::chrono::microseconds(250)).into_nearest();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new SamplingConfig(4000.0f * Hz).IntoNearest();
// or
new SamplingConfig(Duration.FromMicros(250)).IntoNearest();

from pyautd3 import Duration, Hz, SamplingConfig
SamplingConfig(4000.0 * Hz).into_nearest()
# or
SamplingConfig(Duration.from_micros(250)).into_nearest()

use autd3::prelude::*;
fn main() {
let _ = 
WithSegment {
    inner: Static::default(),
    segment: Segment::S1,
    transition_mode: Some(TransitionMode::Immediate),
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
WithSegment(Static{}, Segment::S1, TransitionMode::Immediate());
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
new WithSegment(
    inner: new Static(),
    segment: Segment.S1,
    transitionMode: TransitionMode.Immediate
);

from pyautd3 import Segment, Static, TransitionMode, WithSegment
WithSegment(
    inner=Static(),
    segment=Segment.S1,
    transition_mode=TransitionMode.Immediate,
)

use autd3::prelude::*;
fn main() {
SwapSegment::Modulation(Segment::S1, TransitionMode::Immediate);
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
SwapSegment::Modulation(Segment::S1, TransitionMode::Immediate());
return 0; }

using AUTD3Sharp;
SwapSegment.Modulation(Segment.S1, TransitionMode.Immediate);

from pyautd3 import Segment, SwapSegment, TransitionMode
SwapSegment.Modulation(Segment.S1, TransitionMode.Immediate)

use std::num::NonZeroU16;
use autd3::prelude::*;
fn main() {
let _ = 
WithLoopBehavior {
    inner: Static::default(),
    loop_behavior: LoopBehavior::Infinite,
    segment: Segment::S1,
    transition_mode: Some(TransitionMode::Immediate),
};

let _ = 
WithLoopBehavior {
    inner: Static::default(),
    loop_behavior: LoopBehavior::Finite(NonZeroU16::new(1).unwrap()),
    segment: Segment::S1,
    transition_mode: Some(TransitionMode::SyncIdx),
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;

WithLoopBehavior(Static{}, LoopBehavior::Infinite(), Segment::S1,
                 TransitionMode::Immediate());

WithLoopBehavior(Static{}, LoopBehavior::Finite(1), Segment::S1,
                 TransitionMode::SyncIdx());
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
new WithLoopBehavior(
    inner: new Static(),
    loopBehavior: LoopBehavior.Infinite,
    segment: Segment.S1,
    transitionMode: TransitionMode.Immediate
);

new WithLoopBehavior(
    inner: new Static(),
    loopBehavior: LoopBehavior.Finite(1),
    segment: Segment.S1,
    transitionMode: TransitionMode.SyncIdx
);

from pyautd3 import Segment, Static, TransitionMode, LoopBehavior, WithLoopBehavior
WithLoopBehavior(
    inner=Static(),
    loop_behavior=LoopBehavior.Infinite,
    segment=Segment.S1,
    transition_mode=TransitionMode.Immediate,
)

WithLoopBehavior(
    inner=Static(),
    loop_behavior=LoopBehavior.Finite(1),
    segment=Segment.S1,
    transition_mode=TransitionMode.SyncIdx,
)

use autd3::prelude::*;
fn main() {
let _ = 
Silencer::default();
let _ = 
Silencer::disable();
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Silencer();
Silencer::disable();
return 0; }

using AUTD3Sharp;
new Silencer();
Silencer.Disable();

from pyautd3 import Silencer
Silencer()
Silencer.disable()

use autd3::prelude::*;
use std::num::NonZeroU16;
fn main() {
let _ = 
Silencer {
    config: FixedUpdateRate {
        intensity: NonZeroU16::MIN,
        phase: NonZeroU16::MIN,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Silencer{FixedUpdateRate{.intensity = 1, .phase = 1}};
return 0; }

using AUTD3Sharp;
new Silencer(
    config: new FixedUpdateRate
    {
        Intensity = 1,
        Phase = 1
    }
);

from pyautd3 import Silencer, FixedUpdateRate
Silencer(
    config=FixedUpdateRate(
        intensity=1,
        phase=1,
    ),
)

use autd3::prelude::*;
use std::time::Duration;
fn main() {
let _ = 
Silencer {
    config: FixedCompletionTime {
        intensity: Duration::from_micros(250),
        phase: Duration::from_micros(250),
        strict_mode: true,
    },
};
}

#include<chrono>
#include<autd3.hpp>
int main() {
using namespace autd3;
Silencer{FixedCompletionTime{.intensity = std::chrono::microseconds(250),
                             .phase = std::chrono::microseconds(250),
                             .strict_mode = true}};
return 0; }

using AUTD3Sharp;
new Silencer(
    config: new FixedCompletionTime
    {
        Intensity = Duration.FromMicros(250),
        Phase = Duration.FromMicros(250),
        StrictMode = true
    }
);

from pyautd3 import Duration, FixedCompletionTime, Silencer
Silencer(
    config=FixedCompletionTime(
        intensity=Duration.from_micros(250),
        phase=Duration.from_micros(250),
        strict_mode=True,
    ),
)

use autd3::prelude::*;
fn main() {
let _ =
PhaseCorrection::new(|_dev| |_tr| Phase::ZERO);
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
PhaseCorrection([](const auto&) {
  return [](const auto&) { return Phase::zero(); };
});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
new PhaseCorrection(_dev => _tr => Phase.Zero);

from pyautd3 import Phase, PhaseCorrection
PhaseCorrection(lambda _dev: lambda _tr: Phase.ZERO)

use autd3::prelude::*;
fn main() {
let _ =
PulseWidthEncoder::new(|_dev| |i| PulseWidth::from_duty(i.0 as f32 / 510.0).unwrap());
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
#include<vector>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
PulseWidthEncoder([](const auto& dev) {
  return [](const auto i) {
    return PulseWidth::from_duty(static_cast<float>(i.value()) / 510.0f);
  };
});
return 0; }

using AUTD3Sharp;
new PulseWidthEncoder(_dev => i => PulseWidth.FromDuty((float)i.Item1 / 510.0f));

from pyautd3 import PulseWidthEncoder, PulseWidth
PulseWidthEncoder(lambda _dev: lambda i: PulseWidth.from_duty(i.value / 510.0))

use autd3::prelude::*;
fn main() {
let _ =
GPIOOutputs::new(|_dev, gpio| {
    if gpio == GPIOOut::O0 {
        GPIOOutputType::BaseSignal
    } else {
        GPIOOutputType::None
    }
});
}

#include<autd3.hpp>
int main() {
using namespace autd3;
GPIOOutputs([](const auto& dev, const auto& gpio) {
  return gpio == GPIOOut::O0 ? GPIOOutputType::BaseSignal
                             : GPIOOutputType::None;
});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
new GPIOOutputs(
    (dev, gpio) => gpio == GPIOOut.O0 ? GPIOOutputType.BaseSignal : GPIOOutputType.None
);

from pyautd3 import GPIOOutputs, GPIOOutputType, GPIOOut
GPIOOutputs(
    lambda _dev, gpio: (
        GPIOOutputType.BaseSignal if gpio == GPIOOut.O0 else GPIOOutputType.NONE
    ),
)

use autd3::prelude::*;
fn main() {
let _ =
ForceFan::new(|_dev| true);
}

#include<autd3.hpp>
int main() {
using namespace autd3;
ForceFan([](const auto&) { return true; });
return 0; }

using AUTD3Sharp;
new ForceFan(_ => true);

from pyautd3 import ForceFan
ForceFan(lambda _: True)

cargo add autd3-emulator

pip install pyautd3_emulator

use autd3::prelude::*;
use autd3_emulator::*;

fn main() {
let emulator = Emulator::new([AUTD3::default()]);
let df = emulator.transducer_table();
dbg!(df);
}

from pyautd3 import AUTD3
from pyautd3_emulator import Emulator

with Emulator([AUTD3()]) as emulator:
    df = emulator.transducer_table()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let record = emulator.record(|autd| {
    autd.send(Silencer::default())?;
    autd.send((
        Sine {
            freq: 200 * Hz,
            option: Default::default(),
        },
        Uniform {
            intensity: EmitIntensity::MAX,
            phase: Phase::ZERO,
        },
    ))?;
    autd.tick(Duration::from_millis(10))?;
    Ok(())
})?;
let df = record.phase();
dbg!(df);

let df = record.pulse_width();
dbg!(df);
Ok(())
}

from pyautd3 import (
    AUTD3,
    Duration,
    EmitIntensity,
    Hz,
    Phase,
    Silencer,
    Sine,
    SineOption,
    Uniform,
)
from pyautd3_emulator import Emulator, Recorder

with Emulator([AUTD3()]) as emulator:

    def f(autd: Recorder) -> None:
        autd.send(Silencer())
        autd.send(
            (
                Sine(freq=200.0 * Hz, option=SineOption()),
                Uniform(intensity=EmitIntensity.MAX, phase=Phase.ZERO),
            ),
        )
        autd.tick(Duration.from_millis(10))

    record = emulator.record(f)

    df = record.phase()
    print(df)

    df = record.pulse_width()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Uniform {
            intensity: EmitIntensity::MAX,
            phase: Phase(0x40),
        },
    ))?;
    autd.tick(Duration::from_millis(1))?;
    Ok(())
})?;

let df = record.output_voltage();
dbg!(df);
    Ok(())
}

from pyautd3 import AUTD3, Duration, EmitIntensity, Phase, Silencer, Static, Uniform
from pyautd3_emulator import Emulator, Recorder

with Emulator([AUTD3()]) as emulator:

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Uniform(phase=Phase(0x40), intensity=EmitIntensity.MAX)))
        autd.tick(Duration.from_millis(1))

    record = emulator.record(f)

    df = record.output_voltage()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Uniform {
            intensity: EmitIntensity::MAX,
            phase: Phase(0x40),
        },
    ))?;
    autd.tick(Duration::from_millis(1))?;
    Ok(())
})?;

let df = record.output_ultrasound();
dbg!(df);
    Ok(())
}

from pyautd3 import AUTD3, Duration, EmitIntensity, Phase, Silencer, Static, Uniform
from pyautd3_emulator import Emulator, Recorder

with Emulator([AUTD3()]) as emulator:

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Uniform(phase=Phase(0x40), intensity=EmitIntensity.MAX)))
        autd.tick(Duration.from_millis(1))

    record = emulator.record(f)

    df = record.output_ultrasound()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let focus = emulator.center() + Vector3::new(0., 0., 150. * mm);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Focus {
            pos: focus,
            option: Default::default(),
        },
    ))?;
    autd.tick(Duration::from_millis(1))?;
    Ok(())
})?;

let mut sound_field = record.sound_field(
    RangeXY {
        x: focus.x - 20.0..=focus.x + 20.0,
        y: focus.y - 20.0..=focus.y + 20.0,
        z: focus.z,
        resolution: 1.,
    },
    InstantRecordOption {
        sound_speed: 340e3 * mm,
        time_step: Duration::from_micros(1),
        print_progress: true,
        memory_limits_hint_mb: 128,
        gpu: true,
    },
)?;

let df = sound_field.observe_points();
dbg!(df);

let df = sound_field
    .skip(Duration::from_micros(500))?
    .next(Duration::from_micros(500))?;
dbg!(df);
    Ok(())
}

NOTE: The gpu option is only available if the gpu feature is enabled.

import numpy as np
from pyautd3 import AUTD3, Focus, FocusOption, Silencer, Static, Duration
from pyautd3_emulator import Emulator, RangeXYZ, Recorder, InstantRecordOption

with Emulator([AUTD3()]) as emulator:
    focus = emulator.center() + np.array([0.0, 0.0, 150.0])

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Focus(pos=focus, option=FocusOption())))
        autd.tick(Duration.from_millis(1))

    record = emulator.record(f)

    sound_field = record.sound_field(
        RangeXYZ(
            x=(focus[0] - 20.0, focus[0] + 20.0),
            y=(focus[1] - 20.0, focus[1] + 20.0),
            z=(focus[2], focus[2]),
            resolution=1.0,
        ),
        InstantRecordOption(
            sound_speed=340e3,
            time_step=Duration.from_micros(1),
            print_progress=True,
            memory_limits_hint_mb=128,
            gpu=True,
        ),
    )

    df = sound_field.observe_points()
    print(df)

    df = sound_field.skip(Duration.from_micros(500)).next(
        Duration.from_micros(500),
    )
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let focus = emulator.center() + Vector3::new(0., 0., 150. * mm);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Focus {
            pos: focus,
            option: Default::default(),
        },
    ))?;
    autd.tick(Duration::from_micros(25))?;
    Ok(())
})?;

let mut sound_field = record.sound_field(
    RangeXY {
        x: focus.x - 20.0..=focus.x + 20.0,
        y: focus.y - 20.0..=focus.y + 20.0,
        z: focus.z,
        resolution: 1.,
    },
    RmsRecordOption {
        sound_speed: 340e3 * mm,
        print_progress: true,
        gpu: true,
    },
)?;

let df = sound_field.observe_points();
dbg!(df);

let df = sound_field.next(Duration::from_micros(25))?;
dbg!(df);
    Ok(())
}

NOTE: The gpu option is only available if the gpu feature is enabled.

import numpy as np
from pyautd3 import AUTD3, Duration, Focus, FocusOption, Silencer, Static
from pyautd3_emulator import Emulator, RangeXYZ, Recorder, RmsRecordOption

with Emulator([AUTD3()]) as emulator:
    focus = emulator.center() + np.array([0.0, 0.0, 150.0])

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Focus(pos=focus, option=FocusOption())))
        autd.tick(Duration.from_micros(25))

    record = emulator.record(f)

    sound_field = record.sound_field(
        RangeXYZ(
            x=(focus[0] - 20.0, focus[0] + 20.0),
            y=(focus[1] - 20.0, focus[1] + 20.0),
            z=(focus[2], focus[2]),
            resolution=1.0,
        ),
        RmsRecordOption(
            sound_speed=340e3,
            print_progress=True,
            gpu=False,
        ),
    )

    df = sound_field.observe_points()
    print(df)

    df = sound_field.next(Duration.from_micros(25))
    print(df)

Since tracing is used for logging, you can enable log output as follows.

tracing_subscriber::fmt()
    .with_max_level(tracing::Level::INFO)
    .init();

You can enable log output by setting the RUST_LOG environment variable to autd3=<LEVEL> and calling tracing_init.

You can specify one of the following for <LEVEL>. The lower you go, the more detailed the log output.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

#include <stdlib.h>

#ifdef WIN32
_putenv_s("RUST_LOG", "autd3=INFO");
#else
setenv("RUST_LOG", "autd3=INFO", false);
#endif

autd3::tracing_init();

You can enable log output by setting the RUST_LOG environment variable to autd3=<LEVEL> and calling Tracing.Init.

You can specify one of the following for <LEVEL>. The lower you go, the more detailed the log output.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

System.Environment.SetEnvironmentVariable("RUST_LOG", "autd3=INFO");

AUTD3Sharp.Tracing.Init();

In Unity, you can enable log output by specifying the path to the log file as an argument to Tracing.Init.

System.Environment.SetEnvironmentVariable("RUST_LOG", "autd3=INFO");

AUTD3Sharp.Tracing.Init("<path to log file>");

Also, if you are using AUTD3Sharp.Link.SOEM, enable SOEM logging first.

AUTD3Sharp.Link.SOEM.Tracing.Init("<path to log file>");
AUTD3Sharp.Tracing.Init("<path to log file>");

You can enable log output by setting the RUST_LOG environment variable to autd3=<LEVEL> and calling tracing_init.

You can specify one of the following for <LEVEL>. The lower you go, the more detailed the log output.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

from pyautd3 import tracing_init

os.environ["RUST_LOG"] = "autd3=INFO"

tracing_init()