Silencer

AUTD3 has a silencer to mute the output. The silencer suppresses the rapid change in the drive signal of the transducer and mutes the output.

Theory

The silencer is based on the paper by Suzuki et al.¹.

As a rough outline,

• Amplitude modulation of ultrasound produces audible sound.
• When driving an ultrasound transducer, phase changes cause amplitude fluctuations.
  • Therefore, audible noise is generated.
• Amplitude fluctuations can be suppressed by linearly interpolating phase changes and changing them stepwise.
  • Therefore, noise can be reduced by doing fine interpolation.
• The silencer is a method to reduce noise by doing fine interpolation.

Silencer Config

To configure the silencer, send Silencer to the controller.

The silencer is enabled by default. To disable the silencer, send Silencer::disable.

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() {
let config = Silencer::default();
let config = Silencer::disable();
}

#include<autd3.hpp>
int main() {
{
const auto config = autd3::Silencer();
}
{
const auto config = autd3::Silencer::disable();
}
return 0; }

using AUTD3Sharp;
{
var config = new Silencer();
}
{
var config = Silencer.Disable();
}

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

To configure the silencer more finely, you need to choose from the following two modes.

• Fixed update rate mode
• Fixed completion time mode

The default is fixed completion time mode.

Fixed update rate mode

Phase change by Silencer in Fixed update rate mode

Silencer changes the phase $P$ linearly and stepwise to mute the output. In other words, it is almost equivalent to passing the phase $P$ time series data through a (simple) moving average filter. However, it differs in that it takes into account the fact that the phase data is periodic.

For example, consider the case where the period $T$ of the ultrasound is $T=12$. In other words, $P=0$ corresponds to $0\mathrm{rad}$ and $P=12$ corresponds to $2\pi \mathrm{rad}$. Here, suppose that the phase changes from $P=2$ to $P=6$ at time $t_s$. The phase change by Silencer is as follows.

On the other hand, suppose that the phase changes from $P=2$ to $P=10$ at time $t_s$. The phase change by Silencer is as follows. This is because $P=-2$ is closer to $P=2$ than $P=10$ in terms of the phase.

That is, Silencer updates the phase $P$ as follows for the current $P$ and the target value $P_r$. $$P\leftarrow \{\begin{array}{ll}P+\mathrm{sign}(P_r-P)\min (|P_r-P|,\Delta )& \text{if }|P_r-P|\le T/2\\ P-\mathrm{sign}(P_r-P)\min (|P_r-P|,\Delta )& \text{(otherwise)}\end{array}.$$ Where $\Delta$ is the update amount per step (step of Silencer). And the update frequency is $40\mathrm{kHz}$.

Small $\Delta$ makes the phase change smoother and reduces noise.

According to this implementation, the behavior is different from the moving average filter. One is when the phase change amount shown above is larger than $\pi$, and the other is when the phase changes again in the middle. Examples of phase changes at this time are shown below.

intensity change by Silencer in Fixed update rate mode

intensity modulation of ultrasound produces audible sound. So, AM noise can be reduced by applying a filter to the intensity parameter $D$.

Unlike the phase, the intensity parameter $D$ is not periodic with respect to the period $T$. Therefore, the intensity parameter $D$ is updated as follows for the current $D$ and the target value $D_r$. $$D\leftarrow D+\mathrm{sign}(D_r-D)\min (|D_r-D|,\Delta ),$$

Configure fixed update rate mode

To configure the fixed update rate mode, do as follows. The arguments correspond to $\Delta$ described above.

use std::num::NonZeroU16;
use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let config = Silencer::new(
    FixedUpdateRate {
        intensity: NonZeroU16::new(1).unwrap(),
        phase: NonZeroU16::new(1).unwrap(),
    }
);
Ok(())
}

#include<autd3.hpp>
int main() {
const auto config =
    autd3::Silencer{autd3::FixedUpdateRate{.intensity = 1, .phase = 1}};
return 0; }

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

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

Fixed completion time mode

In fixed completion time mode, change of phase/intensity is completed in a fixed duration.

Configure fixed completion time mode

To configure the fixed completion time mode, do as follows.

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() {
let config = Silencer::new(
    FixedCompletionTime {
        intensity: std::time::Duration::from_micros(250),
        phase: std::time::Duration::from_micros(250),
    }
);
}

#include<chrono>
#include<autd3.hpp>
int main() {
const auto config = autd3::Silencer{
    autd3::FixedCompletionTime{.intensity = std::chrono::microseconds(250),
                               .phase = std::chrono::microseconds(250)}};
return 0; }

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

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

The default values are $1\mathrm{ms}$ for phase change and $0.25\mathrm{ms}$ for intensity change.

In this mode, an error is returned if the phase/intensity change of Modulation, FociSTM, or GainSTM cannot be completed in the time specified by Silencer. That is, the following conditions must be satisfied.

• Silencer's intensity change completion time $\le$ sampling period of Modulation
• Silencer's intensity change completion time $\le$ sampling period of FociSTM/GainSTM
• Silencer's phase change completion time $\le$ sampling period of FociSTM/GainSTM

If you set strict_mode to false, you can ignore these restrictions, but it's not recommended.

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let config = Silencer::default().with_strict_mode(false);
Ok(())
}

#include<autd3.hpp>
int main() {
const auto config = autd3::Silencer().with_strict_mode(false);
return 0; }

using AUTD3Sharp;
var config = new Silencer().WithStrictMode(false);

from pyautd3 import Silencer
config = Silencer().with_strict_mode(False)