pythonsignal-processingtelecommunication

Do you have some advices about signal processing on binary time series?

I have a binary time series with some ASK modulated signals in different frequencies inside of it.

Let's say it's something like this: x = [0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0, ...]

What's matter to me is having all the '1' and '0' in an interval of 4 samples or more, but sometimes the '0' and '1' change places like this: x1 = [0,0,0,1,1,1,1,1] when it had to be x2 = [0,0,0,0,1,1,1,1]

And there's also some noise as spikes as seen in n1 = [0,0,0,0,0,0,1,1,0,0,0,0,0] when it should be only zeros.

I've already tried moving average and it introduced a lag to the signal that was't good for my application.

Do you have some advices about signal processing on binary time series?

Solution

  • The following code finds the indices of all continuous sequences with the length smaller than 4 (min_cont_length). It also gives you the lengths of the problematic sectors, so you can decide how to handle them.

    import numpy as np

def find_index_of_err(signal, min_cont_length = 4):
    # pad sides to detect problems at the edges
    signal = np.concatenate(([1-signal[0]],signal,[1-signal[-1]]))
    # calculate differences from 1 element to the next
    delta = np.concatenate(([0], np.diff(signal, 1)))
    # detect discontinuities
    discontinuity = np.where(delta!=0)[0]
    # select discontinuities with matching length (< min_cont_length)
    err_idx = discontinuity[:-1][np.diff(discontinuity) < min_cont_length] - 1
    # get also the size of the gap
    err_val = np.diff(discontinuity)[np.argwhere(np.diff(discontinuity) < min_cont_length).flatten()]
    return err_idx, err_val

# some test signals
signals = np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]])

for sig in signals:
    index, value = find_index_of_err(sig)
    print(sig, index, value)

# Output:
# [1 0 0 0 0 0 0 0 0 0 0] [0] [1]
# [0 0 1 0 0 0 0 0 0 0 0] [0 2] [2 1]
# [0 0 0 0 1 0 0 0 0 0 0] [4] [1]
# [0 0 0 0 0 0 1 1 0 0 0] [6 8] [2 3]
# [0 0 0 0 0 0 1 1 1 1 1] [] []