Turning an audio signal (beeps) to an binary array

Question

I'm new here and unfortunately I have really no knowledge at all about digital signal processing so my apologies if this is rather a stupid question or a duplicate. I have some audio signal which consists of beep tones. I need to figure out how many beep tones it consists of.

I have the following signal:

But if you look closely you'll see that the "beeps" look like this:

After adding an Envelope filter the signal looks like this:

Is there a way to produce an array like this from the last signal?

[0,1,0,1,0,1,0,1,0,1,0,1,0] 

That represents the amount of "beeps". Can someone help me out on how to do this properly?

Answer 1

1. Import the signal into MATLAB

2. Try J.Hussain's Amplitude Shift Keying (ASK) Modulation and Demodulation

Answer 2

It's relatively straightforward to do using librosa:

If your beeps are a known signal, then correlating the beep with the signal and picking peaks works reasonably well:

        audio, fs = librosa.load(file, mono=True)
        beep, _ = librosa.load('beep.wav', sr=fs)
    clicks = []
    correlation = signal.correlate(audio, beep, mode='valid', method='fft')
    correlation /= np.max(np.abs(correlation), axis=0)
    peaks = librosa.util.peak_pick(correlation,
                                   pre_max=512,
                                   post_max=512,
                                   pre_avg=512,
                                   post_avg=512,
                                   delta=0.5,
                                   wait=2048)
    ticks = librosa.samples_to_time(peaks, sr=fs)

    for t in ticks:
        print(f'beep {t:0.3f}')

If your beep isn't a known signal then librosa's note onset detection is an alternative - it's less accurate than the correlation approach but works reasonably well on a signal with clearly defined transitions. If the beeps are at regular intervals then you can use beat tracking:

        audio, fs = librosa.load(file, mono=True)
        onset_env = librosa.onset.onset_strength(y=audio, sr=fs, aggregate=np.median)
        tempo, frames = librosa.beat.beat_track(onset_envelope=onset_env, sr=fs)
        beats = librosa.frames_to_time(frames, sr=fs)
    for beat in beats:
        print(f'beat @ {beat:0.3f}')

If the beeps aren't at regular intervals then use the note onsets:

        audio, fs = librosa.load(file, mono=True)
        onset_env = librosa.onset.onset_strength(y=audio, sr=fs, aggregate=np.median)
        frames = librosa.onset.onset_detect(onset_envelope=onset_env, sr=fs)
        onsets = librosa.frames_to_time(frames, sr=fs)
    for onset in onsets:
        print(f'note onset @ {onset:0.3f}')

```

Answer 3

The act of converting a continuous univariate signal of activation into a discrete set of events is a common sub-problem in Sound Event Detection.

The simplest approach is to select a threshold, and then binarize the sequence with that. Then count the runs of true value as one contiguous event region.

You may want to avoid small gaps in the events, or require that the events are of minimum size, or that they are at least a certain distance apart. This can be done by post processing the binarized signal with morphological operators. A simple version of this is known as hang-over.

Another strategy would be to binarize using hysteresis, using two sets of thresholds. This avoids disruptions when the activations hover around the threshold.

Another way of cleaning up the signal is to apply a Hidden Markov Model.

Answer 4

I would suggest the following:

• find the lowest frequency (fl) in your signal. Its period will define a window length (wl)
• reshape your signal to be N rows and WL columns
• sum horizontally
• if sum is above threshold you will have signal
• from the sum vector build a new signal
• expand it by repeating each value WL times

An example with matlab:

% after finding lowest frequency (FL) with FFT
WL = 1/FL;
N = length(s) \ WL;
total_n = WL*N;
% Calculate the number of zeros to pad
num_zeros_to_pad = max(0, total_elements_required - numel(signal));
% Pad zeros to the signal
padded_signal = padarray(signal, [0, num_zeros_to_pad], 0, 'post');
% Reshape the padded signal
reshaped_signal = reshape(padded_signal, N, WL);
win_sum = sum(reshaped_signal)
bins = win_sum>threshold
% Expand each element
expanded_signal = kron(bins, ones(1, WL));