如何使用python为简单的正弦波输入生成反向间隙信号？

Question

I am using the below python codes so as to generate the backlash signal for a simple sine wave input.The generated output is not as per the requirement.The output should be similar to that of backlash block used in Simulink.

#Importing libraries 
import matplotlib.pyplot as plt
import numpy as np

#Setting upper limit and lower limit
LL = -0.5
UL = 0.5

#Generating the sine wave
x=np.linspace(0,10,1000)
y=(np.sin(x))

#phase shift of y1 by -pi/2
y1=(np.sin(x-1.571))

# plot original sine
plt.plot(x,y)

#setting the thresholds 
y1[(y1>UL)] = UL
y1[(y1<LL)] = LL

#Initializing at the input
y1[(y==0)]  = 0

y1[(y1>UL)] -= UL
y1[(y1<LL)] -= LL

#Plotting both the waves
plt.plot(x,y)
plt.plot(x,y1)

plt.grid()
plt.show()

Answer 1

I don't think there is a simple vectorized implementation for the backlash process. The k-th output depends on the previous values in a nontrivial way. A concise way to write the process (assuming x is the input array and y is the output array) is

y[k] = min(max(y[k-1], x[k] - h), x[k] + h)

where h is half the deadband.

The following script includes a backlash function that uses a Python for-loop. (The function uses if statements instead of the min and max functions.) It is simple, but it won't be very fast. If high performance is important, you might consider reimplementing the function in Cython or numba .

import numpy as np


def backlash(x, deadband=1.0, initial=0.0):
    """
    Backlash process.

    This function emulates the Backlash block of Simulink
    (https://www.mathworks.com/help/simulink/slref/backlash.html).

    x must be a one-dimensional numpy array (or array-like).
    deadband must be a nonnegative scalar.
    initial must be a scalar.
    """
    halfband = 0.5*deadband

    y = np.empty_like(x, dtype=np.float64)
    current_y = initial

    for k in range(len(x)):
        current_x = x[k]
        xminus = current_x - halfband
        if xminus > current_y:
            current_y = xminus
        else:
            xplus = current_x + halfband
            if xplus < current_y:
                current_y = xplus
        y[k] = current_y

    return y


if __name__ == "__main__":
    import matplotlib.pyplot as plt

    t = np.linspace(0, 10, 500)
    x = np.sin(t)
    deadband = 1
    y = backlash(x, deadband=deadband)

    plt.plot(t, x, label='x(t)')
    plt.plot(t, y, '--', label='backlash(x(t))')
    plt.xlabel('t')

    plt.legend(framealpha=1, shadow=True)
    plt.grid(alpha=0.5)
    plt.show()

Update: I implemented the backlash function as a NumPy gufunc in my ufunclab repository .