Silencer

AUTD3 provides a Silencer to reduce noise of the output. The Silencer suppresses sudden changes in the drive signal of the transducers, making it quieter.

• Theory
• Silencer Settings
  • Fixed update rate mode
  • Fixed completion time mode

Theory

For details, refer to the paper by Suzuki et al.¹.

In summary,

• Amplitude-modulated ultrasound generates audible sound.
• When driving ultrasonic transducers, phase changes cause amplitude fluctuations.
  • Therefore, audible noise is generated.
• By linearly interpolating phase changes and gradually changing them, amplitude fluctuations can be suppressed.
  • Therefore, noise can be reduced.
• The finer the interpolation, the smaller the noise.

Silencer Settings

To configure the Silencer, send Silencer.

The Silencer is set to appropriate values by default. To disable the Silencer, send disable.

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

For finer settings, you need to choose between the following two modes:

• Fixed update rate mode
• Fixed completion time mode

By default, it is set to Fixed completion time mode.

Fixed update rate mode

Phase Change in Fixed update rate mode

In this mode, the Silencer linearly interpolates and gradually changes the phase $P$ to reduce noise. In other words, it is almost equivalent to passing the time series data of phase $P$ through a moving average filter. However, it differs in that it considers the periodicity of the phase data.

For example, consider the case where the period $T$ of ultrasound is $T=12$. That is, $P=0$ corresponds to $0\mathrm{rad}$, and $P=12$ corresponds to $2\pi \mathrm{rad}$. Here, suppose the phase changes from $P=2$ to $P=6$ at time $t_s$. In this case, the phase change by the Silencer will be as shown in the following figure.

On the other hand, suppose the phase changes from $P=2$ to $P=10$ at time $t_s$. In this case, the phase change by the Silencer will be as shown in the following figure. This is because $P=-2$ is closer than $P=10$.

In other words, the Silencer updates the phase $P$ as follows for the current $P$ and 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$ represents the update amount per step (step of Silencer). The update frequency is $40\mathrm{kHz}$.

The smaller $\Delta$ is, the smoother the phase change and the more noise is suppressed.

Due to the nature of this implementation, it may behave differently from a moving average filter. One case is when the phase change amount is greater than $\pi$, as shown above, and another case is when the phase changes again in the middle. An example of phase change in the second case is shown below. From the perspective of fidelity to the original time series, the moving average filter is correct, but considering the phase change amount greater than $\pi$ or making $\Delta$ variable (i.e., making the filter length variable) is difficult, so the current implementation is adopted.

Amplitude Change in Fixed update rate mode

Since amplitude fluctuations cause noise, applying the same filter to the intensity parameter $D$ can suppress noise due to AM.

Unlike phase, the intensity parameter $D$ is not periodic, so it is updated as follows for the current $D$ and target value $D_r$: $$D\leftarrow D+\mathrm{sign}(D_r-D)\min (|D_r-D|,\Delta ),$$

Setting Fixed update rate mode

To set Fixed update rate mode, do as follows. The arguments correspond to the aforementioned $\Delta$ (unit is $2\pi /65536$).

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

Fixed completion time mode

In this mode, phase/intensity changes are completed within a fixed time.

Setting Fixed completion time mode

To set Fixed completion time mode, do as follows.

intensity and phase correspond to the completion time of intensity/phase changes, respectively. These must be integer multiples of the ultrasound period ($25\mathrm{us}$).

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

The default values are $1\mathrm{ms}$ for phase changes and $0.25\mathrm{ms}$ for intensity changes. Disabling the Silencer is equivalent to completing phase/intensity changes within the ultrasound period ($25\mathrm{us}$).

In this mode, an error is returned if the phase/intensity changes specified by Modulation, FociSTM, or GainSTM cannot be completed within the time specified by the Silencer. Therefore, the following conditions must be met:

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

If strict_mode is set to false, no error is returned even if these conditions are not met, but it is not recommended.