예제 #1
0
    def test_dstep(self):

        a = np.asarray([[0.9, 0.1], [-0.2, 0.9]])
        b = np.asarray([[0.4, 0.1, -0.1], [0.0, 0.05, 0.0]])
        c = np.asarray([[0.1, 0.3]])
        d = np.asarray([[0.0, -0.1, 0.0]])
        dt = 0.5

        # Because b.shape[1] == 3, dstep should result in a tuple of three
        # result vectors
        yout_step_truth = (np.asarray([
            0.0, 0.04, 0.052, 0.0404, 0.00956, -0.036324, -0.093318,
            -0.15782348, -0.226628324, -0.2969374948
        ]),
                           np.asarray([
                               -0.1, -0.075, -0.058, -0.04815, -0.04453,
                               -0.0461895, -0.0521812, -0.061588875,
                               -0.073549579, -0.08727047595
                           ]),
                           np.asarray([
                               0.0, -0.01, -0.013, -0.0101, -0.00239, 0.009081,
                               0.0233295, 0.03945587, 0.056657081, 0.0742343737
                           ]))

        tout, yout = dstep((a, b, c, d, dt), n=10)

        assert_equal(len(yout), 3)

        for i in range(0, len(yout)):
            assert_equal(yout[i].shape[0], 10)
            assert_array_almost_equal(yout[i].flatten(), yout_step_truth[i])

        # Check that the other two inputs (tf, zpk) will work as well
        tfin = ([1.0], [1.0, 1.0], 0.5)
        yout_tfstep = np.asarray([0.0, 1.0, 0.0])
        tout, yout = dstep(tfin, n=3)
        assert_equal(len(yout), 1)
        assert_array_almost_equal(yout[0].flatten(), yout_tfstep)

        zpkin = tf2zpk(tfin[0], tfin[1]) + (0.5, )
        tout, yout = dstep(zpkin, n=3)
        assert_equal(len(yout), 1)
        assert_array_almost_equal(yout[0].flatten(), yout_tfstep)

        # Raise an error for continuous-time systems
        system = lti([1], [1, 1])
        assert_raises(AttributeError, dstep, system)
예제 #2
0
    def test_more_step_and_impulse(self):
        lambda1 = 0.5
        lambda2 = 0.75
        a = np.array([[lambda1, 0.0],
                      [0.0, lambda2]])
        b = np.array([[1.0, 0.0],
                      [0.0, 1.0]])
        c = np.array([[1.0, 1.0]])
        d = np.array([[0.0, 0.0]])

        n = 10

        # Check a step response.
        ts, ys = dstep((a, b, c, d, 1), n=n)

        # Create the exact step response.
        stp0 = (1.0 / (1 - lambda1)) * (1.0 - lambda1 ** np.arange(n))
        stp1 = (1.0 / (1 - lambda2)) * (1.0 - lambda2 ** np.arange(n))

        assert_allclose(ys[0][:, 0], stp0)
        assert_allclose(ys[1][:, 0], stp1)

        # Check an impulse response with an initial condition.
        x0 = np.array([1.0, 1.0])
        ti, yi = dimpulse((a, b, c, d, 1), n=n, x0=x0)

        # Create the exact impulse response.
        imp = (np.array([lambda1, lambda2]) **
                            np.arange(-1, n + 1).reshape(-1, 1))
        imp[0, :] = 0.0
        # Analytical solution to impulse response
        y0 = imp[:n, 0] + np.dot(imp[1:n + 1, :], x0)
        y1 = imp[:n, 1] + np.dot(imp[1:n + 1, :], x0)

        assert_allclose(yi[0][:, 0], y0)
        assert_allclose(yi[1][:, 0], y1)

        # Check that dt=0.1, n=3 gives 3 time values.
        system = ([1.0], [1.0, -0.5], 0.1)
        t, (y,) = dstep(system, n=3)
        assert_allclose(t, [0, 0.1, 0.2])
        assert_array_equal(y.T, [[0, 1.0, 1.5]])
        t, (y,) = dimpulse(system, n=3)
        assert_allclose(t, [0, 0.1, 0.2])
        assert_array_equal(y.T, [[0, 1, 0.5]])
예제 #3
0
    def test_more_step_and_impulse(self):
        lambda1 = 0.5
        lambda2 = 0.75
        a = np.array([[lambda1, 0.0],
                      [0.0, lambda2]])
        b = np.array([[1.0, 0.0],
                      [0.0, 1.0]])
        c = np.array([[1.0, 1.0]])
        d = np.array([[0.0, 0.0]])

        n = 10

        # Check a step response.
        ts, ys = dstep((a, b, c, d, 1), n=n)

        # Create the exact step response.
        stp0 = (1.0 / (1 - lambda1)) * (1.0 - lambda1 ** np.arange(n))
        stp1 = (1.0 / (1 - lambda2)) * (1.0 - lambda2 ** np.arange(n))

        assert_allclose(ys[0][:, 0], stp0)
        assert_allclose(ys[1][:, 0], stp1)

        # Check an impulse response with an initial condition.
        x0 = np.array([1.0, 1.0])
        ti, yi = dimpulse((a, b, c, d, 1), n=n, x0=x0)

        # Create the exact impulse response.
        imp = (np.array([lambda1, lambda2]) **
                            np.arange(-1, n + 1).reshape(-1, 1))
        imp[0, :] = 0.0
        # Analytical solution to impulse response
        y0 = imp[:n, 0] + np.dot(imp[1:n + 1, :], x0)
        y1 = imp[:n, 1] + np.dot(imp[1:n + 1, :], x0)

        assert_allclose(yi[0][:, 0], y0)
        assert_allclose(yi[1][:, 0], y1)

        # Check that dt=0.1, n=3 gives 3 time values.
        system = ([1.0], [1.0, -0.5], 0.1)
        t, (y,) = dstep(system, n=3)
        assert_allclose(t, [0, 0.1, 0.2])
        assert_array_equal(y.T, [[0, 1.0, 1.5]])
        t, (y,) = dimpulse(system, n=3)
        assert_allclose(t, [0, 0.1, 0.2])
        assert_array_equal(y.T, [[0, 1, 0.5]])
	def rise_time(self):
		"""Return 90 percent rise time of step response in terms of samples"""
		s = sig.dstep((self.b, self.a, 1))[1][0]
		n = 0
		for ii in range(len(s)):
			if s[ii] > 0.9:
				n = ii
				break
		return n
예제 #5
0
    def test_dstep(self):

        a = np.asarray([[0.9, 0.1], [-0.2, 0.9]])
        b = np.asarray([[0.4, 0.1, -0.1], [0.0, 0.05, 0.0]])
        c = np.asarray([[0.1, 0.3]])
        d = np.asarray([[0.0, -0.1, 0.0]])
        dt = 0.5

        # Because b.shape[1] == 3, dstep should result in a tuple of three
        # result vectors
        yout_step_truth = (np.asarray([0.0, 0.04, 0.052, 0.0404, 0.00956,
                                       -0.036324, -0.093318, -0.15782348,
                                       -0.226628324, -0.2969374948]),
                           np.asarray([-0.1, -0.075, -0.058, -0.04815,
                                       -0.04453, -0.0461895, -0.0521812,
                                       -0.061588875, -0.073549579,
                                       -0.08727047595]),
                           np.asarray([0.0, -0.01, -0.013, -0.0101, -0.00239,
                                       0.009081, 0.0233295, 0.03945587,
                                       0.056657081, 0.0742343737]))

        tout, yout = dstep((a, b, c, d, dt), n=10)

        assert_equal(len(yout), 3)

        for i in range(0, len(yout)):
            assert_equal(yout[i].shape[0], 10)
            assert_array_almost_equal(yout[i].flatten(), yout_step_truth[i])

        # Check that the other two inputs (tf, zpk) will work as well
        tfin = ([1.0], [1.0, 1.0], 0.5)
        yout_tfstep = np.asarray([0.0, 1.0, 0.0])
        tout, yout = dstep(tfin, n=3)
        assert_equal(len(yout), 1)
        assert_array_almost_equal(yout[0].flatten(), yout_tfstep)

        zpkin = tf2zpk(tfin[0], tfin[1]) + (0.5,)
        tout, yout = dstep(zpkin, n=3)
        assert_equal(len(yout), 1)
        assert_array_almost_equal(yout[0].flatten(), yout_tfstep)

        # Raise an error for continuous-time systems
        system = lti([1], [1, 1])
        assert_raises(AttributeError, dstep, system)
def MotorControl():
    J = .01  # kgm**2
    b = .1  # N.m.s
    Ke = .01  # V/rad/sec
    Kt = .01  # N.m/Amp
    R = 1  # Electrical resistance
    L = .5  # Henries
    K = Kt  # or Ke, Ke == Kt here
    # State Space Model
    A = np.matrix([[-b / J, K / J], [-K / L, -R / L]])
    B = np.matrix([[0], [1 / L]])
    C = np.matrix([1, 0])
    D = np.matrix([0])
    dt = .025  # Discrete Sample Time

    ss = sig.StateSpace(A, B, C, D)
    ssd = sig.cont2discrete((A, B, C, D), dt)
    Ad = ssd[0]
    Bd = ssd[1]
    Cd = ssd[2]
    evc, evecc = np.linalg.eig(A)
    evd, evecd = np.linalg.eig(Ad)
    # Create Bode
    #w, mag, phase = sig.bode(ss)
    #plot_SISO(w,mag, "Freq Response Mag vs w")
    #plot_SISO(w, phase, "Freq Response Phase vs w")
    #discrete_time_frequency_repsonse()
    # Transfer Function
    tf = ss.to_tf()
    print(tf)
    t, y = sig.step(ss)
    td, yd = sig.dstep(ssd)
    yd = np.reshape(yd, -1)
    #plot_SISO(t,y)
    #plot_SISO(td, yd)
    #pole_zeros(A, B, C, plot=True)
    #pole_zeros(Ad, Bd, Cd, plot=True)
    T = 10
    N = T / dt
    times = np.arange(0, T, dt)
    U = np.ones(int(N))
    x0 = np.matrix([0, 0]).T
    xr = np.matrix([2.5, 0])
    kp = 15
    kd = 4
    ki = 100
    Q = Cd.T * Cd
    R = np.matrix([.0005])
    discrete_time_response(Ad, Bd, Cd, U, x0, dt, plot=True)
    discrete_time_frequency_repsonse(Ad, Bd, Cd, 20, dt)
    continous_time_frequency_repsonse(A, B, C)
    discrete_pid_response((Ad, Bd, Cd), x0, xr, times, kp, ki, kd)
    sim_dlqr(Ad, Bd, Cd, Q, R, x0, xr, dt, T)
    x = 9
예제 #7
0
    def step_response(self, n=100):
        """
        Calculates the step response of the filter (n steps, default = 100)
        """
        step = []
        for number in range(0, n):
            step.append(1)

        _times, step_resp = signal.dstep((self.b, self.a, 1), n=n)
        step_response = step_resp[0].flatten()
        return step, step_response
예제 #8
0
def addFilter(b, a, sampling_freq, name=""):
    w, h = signal.freqz(b, a, fs=sampling_freq)
    t, y = signal.dstep((b, a, 1.0 / fs))
    w_gd, gd = signal.group_delay((b, a))

    frequencies.append(w)
    amplitudes.append(h)
    times.append(t)
    step_responses.append(y)
    group_delays.append(gd)
    names.append(name)
예제 #9
0
파일: iir.py 프로젝트: 3ll3d00d/beqdesigner
 def get_step_response(self, dt=None, n=None):
     '''
     Converts the 2nd order section to a transfer function (b, a) and then computes the SR of the discrete time
     system.
     :param dt: the time delta.
     :param n: the no of samples to output, defaults to 1s.
     :return: t, y
     '''
     t, y = signal.dstep(signal.dlti(*signal.sos2tf(np.array(self.get_sos())),
                                     dt=1 / self.fs if dt is None else dt),
                          n=self.fs if n is None else n)
     return t, y
예제 #10
0
def plot_the_thing(T):
    # reset the current figure
    plt.figure()

    # create two arrays using T as a base for an exponential function
    num = np.array([10 - 10 * np.exp(-T)])
    den = np.array([1, 10 - 11 * np.exp(-T)])

    # turn the two arrays above into a transfer function
    dtf = sig.dlti(num, den)
    # generate axes for plot
    t, y = sig.dstep((dtf), n=1000)

    # generate values for lower circle plot
    tCirc = np.linspace(0, 2 * np.pi, 100)
    xCirc = np.cos(tCirc)
    yCirc = np.sin(tCirc)

    # obtain the roots of the function to determine the poles
    poleLocation = np.roots(den)
    # style the indicators for the pole
    colorIndicator = "b"
    markerIndicator = "o"

    # restyle the pole locator if outside the unit circle
    if np.abs(poleLocation) > 1:
        colorIndicator = "r"
        markerIndicator = "x"
    # tell user location of pole in the terminal
    print("pole location", poleLocation)

    # get axes objects to draw the two plots to
    f, xarr = plt.subplots(2)

    # plot the upper graph showing the output function
    xarr[0].set_title("T = %s" % T)
    xarr[0].plot(t, y[:][0])
    # plot the lower graph showing the pole relative to the unit circle
    xarr[1].plot(1, 0, c="g", marker="o")
    xarr[1].plot(xCirc, yCirc)
    xarr[1].scatter(poleLocation, 0, c=colorIndicator, marker=markerIndicator)
    xarr[1].set_xlabel("pole magnitude is %s" % poleLocation)
    xarr[1].set_xlim([-2, 2])

    # return the figure object to save images of plots
    return f
예제 #11
0
    def discrete_siso_step_response(self, n_tc=7):

        if self.is_siso() is False:
            raise ValueError('This function is for SISO systems.')

        if self.is_delta() is False and self.is_shift() is False:
            raise ValueError('This function is for discrete time systems.')

        if self.is_delta() is True:
            sys = self.delta2shift()
        else:
            sys = self

        mat_a, mat_b, mat_c, mat_d = sys.cofs
        tc = sys.time_constant()
        n = round(n_tc * tc / sys.dt)
        t, y = signal.dstep((mat_a, mat_b, mat_c, mat_d, sys.dt), n=n)
        return t, np.squeeze(y)
def step_response(sys,sysd,Ts): #Draw the step response for the continuous-time and discrete-time systems
    sysnum = asarray(sys.num)[0][0]
    sysden = asarray(sys.den)[0][0]
    sysdnum = asarray(sysd.num)[0][0]
    sysdden = asarray(sysd.den)[0][0]
    x = arange(0,100,0.1)
    syslti = signal.lti(sysnum,sysden)
    sysdlti = signal.lti(sysdnum,sysdden)
    t,s = signal.step(syslti,T=x)
    t2,s2 = signal.dstep((sysdnum,sysdden,Ts),t=x)
    ax = plt.subplot(3,2,4)
    plt.plot(t, s,color='blue',label='Continuous-time')
    plt.plot(t2, s2[0],color='red',label='Discrete-time')
    plt.title('Step response')
    plt.xlabel('Time [sec]')
    plt.ylabel('Amplitude')
    plt.tight_layout(w_pad = 3.0)
    plt.show()
예제 #13
0
def parse(z, p, k):
    b, a = zpk2tf(z, p, k)
    global plot_cnt
    subplot(2, 6, plot_cnt)
    title("Sistem " + str(plot_cnt))
    plot(real(z), imag(z), 'o')
    plot(real(p), imag(p), 'x')
    plot(circ_x, circ_y, '--')
    axis([-1.5, 1.5, -1.5, 1.5])
    axis("equal")
    grid()
    t, y = dstep((b, a, 1))

    subplot(2, 6, plot_cnt + 6)
    plot(t, y[0])
    grid()

    plot_cnt += 1
예제 #14
0
def plot_time(analog_system, discrete_system, response='step', num_samples=100, sample_rate=48e3, plot_error=False):

    n = np.arange(num_samples)
    t = n/sample_rate
    fig, ax1 = plt.subplots()

    if response == 'impulse':
        ta, ya = signal.impulse2(analog_system, T=t)
        _, yd = signal.dimpulse((*discrete_system,1/sample_rate), t=t)
        ax1.set_title('Resposta ao impulso')

    elif response == 'step':
        ta, ya = signal.step2(analog_system, T=t)
        _, yd = signal.dstep((*discrete_system,1/sample_rate), t=t)
        ax1.set_title('Resposta ao degrau')

    elif response == 'ramp':
        ramp_factor = 1
        ta = np.arange(int(num_samples*ramp_factor))/(ramp_factor*sample_rate)
        print(ta.shape)
        ta, ya, xa = signal.lsim2(analog_system, U=ta, T=ta, printmessg=True)

        _, yd = signal.dlsim((*discrete_system,1/sample_rate), u=t, t=t, x0=None)
        ax1.set_title('Resposta a rampa')


    ax1.plot(ta*sample_rate,ya,'b')
    ax1.plot(n,np.ravel(yd),'k.')
    ax1.set_ylabel('Amplitude', color='b')
    ax1.set_xlabel('Amostras')
    ax1.grid(True)
    ax1.legend(['Analógico', 'Discreto'])

    if plot_error:
        ax2 = ax1.twinx()
        ax2.plot(n, np.abs(ya-np.ravel(yd)), 'r')
        ax2.set_ylabel('Erro', color='r')
        ax2.axis('tight')
예제 #15
0
for T in Tx:  # Making a for loop. Iterator is T. and we are going to loop through Tx. (5 numbers between 0 and 0.22)
    #Notice the indent to designate the forloops code block
    num = np.array(
        [10 - 10 * np.exp(-T)]
    )  # Calling the numpy library. Asking for the function Array. We want to make an array.
    # So we are building an array which will be 5 numbers because we are using T to loop through Tx
    # num stands for numerator

    den = np.array([1, 10 - 11 * np.exp(-T)])  # making a tuple

    dtf = sig.dlti(
        num, den
    )  # some discrete time linear time invariant system base class. Like a multi dimensional array.

    t, y = sig.dstep(
        (dtf), n=1000
    )  # dstep returns a tuple. Returns two things. We store the discription of dtf in a tuple.
    # So it is a 1D array, and the step response of the system

    tCirc = np.linspace(
        0, 2 * np.pi,
        100)  # making 100 evenly spaced number between 0 to 2*3.14

    xCirc = np.cos(
        tCirc
    )  # Using Numpy, asking for the cosign function, giving it the 100 numbers we just made.

    yCirc = np.sin(tCirc)  # Same thing as xCirc but for the y direction.

    poleLocation = np.roots(den)  # Finding what makes the denominator zero.
	def step(self, dt=1):
		"""Return discrete step response of filter"""
		return sig.dstep((self.b, self.a, dt))
예제 #17
0
# at the end of the for loop
i = 0
# Here be a for loop with its weird not c like syntax
for T in Tx:
    # set num to be an array using numpy and populate that array
    # with the expression that is given in the brackets
    num = np.array([10 - 10 * np.exp(-T)])
    # den to be an array using numpy and populate that array
    # with the expression that is given in the brackets
    den = np.array([1, 10 - 11 * np.exp(-T)])

    # set dtf to be a line that gets made using the two expression given
    # in the lines above
    dtf = sig.dlti(num, den)
    # this defines the timestep used in the graphs
    t, y = sig.dstep((dtf), n=1000)

    # define tCirc as a line that creates a circle
    tCirc = np.linspace(0, 2 * np.pi, 100)
    # create the x components of the circle
    xCirc = np.cos(tCirc)
    # create the y components of the circle
    yCirc = np.sin(tCirc)

    # poleLocation is being assigned to the roots of the
    # equation that was defined for den
    poleLocation = np.roots(den)
    # Set colorIndicator to be blue
    colorIndicator = "b"
    # Set markerIndicator to be the letter o
    markerIndicator = "o"
예제 #18
0
n1 = Cc.shape[1]
n_in = Bc.shape[1]

## Make A Augmented Model
Ae = np.eye(n1+m1,n1+m1)
Ae[0:n1,0:n1] = Ac
Ae[n1:n1+m1,0:n1] = np.matmul(Cc,Ac)

## Make B Augmented Model
Be = np.zeros(((n1+m1),n_in))
Be[0:n1,:] = Bc
Be[n1:n1+m1,:] = np.matmul(Cc,Bc)
print(Be)

## Make B Augmented Model
Ce = np.zeros((m1,n1+m1))
Ce[:,n1:n1+m1] = np.eye(m1,m1)
print(Ce)

sys = signal.StateSpace(Ac,Bc,Cc,Dc,dt=1)
AugSys = signal.StateSpace(Ae, Be, Ce, dt = 1)

# print(sys)
# print(AugSys)

import matplotlib.pyplot as plt
t,result = signal.dstep(sys)
# print(result)
plt.plot(t,result[0])
plt.show()
    # x_0 = np.zeros(A.shape[0])
    # 0.01745 is degree in radians. this is psi here
    # x_0 = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0.01745])
    x_0 = np.array([0., 0., 0., 0., 0., 0., 0.01745, 0.01745, 0.01745])
    # x_0 = np.array([0., 0., 0., 0., 0., 0., 0., 0.01745, 0.])

    newA = A - np.matmul(B, K)
    newB = np.matmul(B, K)
    newC = np.identity(newA.shape[0])
    newD = np.zeros(newB.shape)

    new_sys = signal.dlti(newA, newB, newC, newD, dt=0.1)

    # step the new response, from t0 = 0 to tf = 2s
    sim = signal.dstep(new_sys, x0=x_0, n=21)
    times = np.linspace(0, 2, 21)

    # build plots
    philist = []
    thetalist = []
    psilist = []
    for i in range(len(sim[1][0])):
        philist.append(sim[1][0][i][-3])
        thetalist.append(sim[1][0][i][-2])
        psilist.append(sim[1][0][i][-1])

    # plot the responses for the sim
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=times, y=philist, mode='lines', name='phi'))
    fig.add_trace(go.Scatter(x=times, y=thetalist, mode='lines', name='theta'))
예제 #20
0
 def test_step_invariant(self, sys, sample_time, samples_number):
     time = np.arange(samples_number) * sample_time
     _, yout_cont = step2(sys, T=time, **self.tolerances)
     _, yout_disc = dstep(c2d(sys, sample_time, method='zoh'), n=len(time))
     assert_allclose(yout_cont.ravel(), yout_disc[0].ravel())
ax1.set_ylabel('Amplitude P D2 [dB]', color='b')
ax1.set_xlabel('Frequency [Hz]')

ax2.semilogx(w / (np.pi), phase, 'r')
ax2.set_ylabel('Phase', color='r')
ax2.set_xlabel('Frequency [Hz]')

plt.tight_layout()
plt.show()

print("Resultado sistema: ")
print(closed_loop)

### Desde aca hago pruebas temporales
t = np.linspace(0, 0.01, num=2000)
tout, yout = dstep([closed_loop.num, closed_loop.den, td], t=t)
yout1 = np.transpose(yout)
yout0 = yout1[0]
yout = yout0[:tout.size]

fig, ax = plt.subplots()
ax.set_title(
    'Respuesta escalon de la función transferencia luego del PID realimentado')
ax.set_ylabel('Corriente')
ax.set_xlabel('Tiempo [s]')
ax.grid()
ax.stem(tout, yout)

plt.tight_layout()
plt.show()
예제 #22
0
    ax2.semilogx(w / (2 * np.pi), phase_zoh, 'y')
    ax2.set_ylabel('Phase', color='g')
    ax2.set_xlabel('Frequency [Hz]')

    plt.tight_layout()
    plt.show()

#############################################
# Verifico Respuesta Escalon Planta Digital #
#############################################
tiempo_de_simulacion = 3.0
t = np.linspace(0,
                tiempo_de_simulacion,
                num=(tiempo_de_simulacion * Fsampling))
tout, yout_zoh = dstep([planta_dig_zoh.num, planta_dig_zoh.den, td], t=t)
yout1 = np.transpose(yout_zoh)
yout0 = yout1[0]
yout_zoh = yout0[:tout.size]

if Escalon_Planta_Digital == True:
    fig, ax = plt.subplots()
    ax.set_title('Step Planta Digital ZOH Yellow')
    ax.set_ylabel('Salida Planta')
    ax.set_xlabel('Tiempo [s]')
    ax.grid()
    ax.plot(tout, yout_zoh, 'y')

    plt.tight_layout()
    plt.show()
예제 #23
0
plt.grid()
plt.savefig("bode.svg")
plt.show()

# Plot the impulse response
t, y_sma = dimpulse((b_sma, a_sma, 1 / f_s), n=2 * N)
t, y_ema = dimpulse((b_ema, a_ema, 1 / f_s), n=2 * N)
#plt.suptitle('Impulse Response')
plt.plot(t, y_sma[0], 'o-', color=col1, label='SMA')
plt.plot(t, y_ema[0], 'o-', color=col2, label='EMA')
plt.xlabel('Time \n (seconds)')
plt.ylabel('Output')
plt.xlim(-1 / f_s, 2 * N / f_s)
plt.legend()
plt.grid()
plt.show()

# Plot the step response
t, y_sma = dstep((b_sma, a_sma, 1 / f_s), n=2 * N)
t, y_ema = dstep((b_ema, a_ema, 1 / f_s), n=2 * N)
#plt.suptitle('Step Response')
plt.plot(t, y_sma[0], 'o-', color=col1, label='SMA')
plt.plot(t, y_ema[0], 'o-', color=col2, label='EMA')
plt.xlabel('Time \n (seconds)')
plt.ylabel('Output')
plt.xlim(-1 / f_s, 2 * N / f_s)
plt.legend()
plt.grid()
plt.savefig("step.svg")
plt.show()
	def overshoot(self):
		"""Return overshoot as decimal"""
		s = sig.dstep((self.b, self.a, 1))[1][0]
		m = max(s)
		return round(float(m - 1), 3)
예제 #25
0
# OpenLoop_sim = OpenLoop.simplify()

System_sim = system.simplify(
)  # Esta función me permite ver como queda acomodada la función transferencia de H*Gp

print(System_sim)
# print (OpenLoop_sim)

zeroes = [0]
poles = [-0.308035714285714]

#paso H(z) con potencias positivas b0 zn b1 zn-1, etc; a0 zn a1 zn-1
b = np.array([Kt, 0])
a = np.array([1, Kt * 0.022])
zplane(b, a)

#respuesta escalon
t = np.arange(0, 100, 1)
tout, yout = signal.dstep([b, a, 1], t=t)
yout1 = np.transpose(yout)
yout0 = yout1[0]
yout = yout0[:tout.size]

plt.figure(1)
plt.clf()
plt.title('digital Step Response')

# print (yout)
plt.stem(tout, yout)
plt.show()
예제 #26
0
print "\nxfer f'n's DC gain"
print control.matlab.dcgain(T_ideal)


#T_ideal_tf = (num, den, T_ideal.dt)#control.tf(T_ideal.num, T_ideal.den, T_ideal.dt)
#T_ideal_tf = control.matlab.tf(T_ideal)

T = np.linspace(0, 500, 1000)


#T, y = control.matlab.step(T_ideal, T = np.linspace(0, 100, 500), input=0, output=0)#, T=None, input=0, output=0)

dsys = (num, den, Ts)
print "Dsys:"
print dsys
T, y = dstep(dsys, t=T)#, T=None, input=0, output=0)



plt.figure(1)
plt.plot(T, y[0])
plt.show()



#create implemented model
#hz_actual = tf([tau_gain_fp, 0], [1, -tau_gain_fp*tau_fp], Ts)
#create PID with no derivative filter
#ctrl_actual = pid(kp_fp, ki_fp, kd_fp, 0, Ts)
"""
T_actual = control.matlab.feedback(ctrl_actual*delay*hz_actual, 1)
예제 #27
0
def plot_dtlti_analysis(z, p, k, fs=1, Nf=2**10, Nt=2**5):
    """Plot linear, time-invariant, discrete-time system.

    Impulse, step, frequency response (level/phase/group delay) and z-plane
    of transfer function H(z) given as zeros/poles/gain description

    Note that we use fs only for the frequency responses

    """
    # still hard coded, TBD:
    # figure size
    # group_delay discontinuities and automatic ylim, yticks is not
    # useful sometimes

    plt.figure(figsize=(9, 9), tight_layout=True)

    mu = np.arange(Nf)
    df = fs / Nf
    dW = 2 * np.pi / Nf
    f = mu * df  # frequency vector [0...fs)
    W = mu * dW  # digital angular frequency [0...2pi)

    sys = signal.dlti(z, p, k, dt=True)
    sys_ba = signal.TransferFunction(sys)
    b = sys_ba.num  # we need coeff b,a for group_delay()
    a = sys_ba.den

    [W, H] = signal.dlti.freqresp(sys, W)
    [W, gd] = signal.group_delay((b, a), w=W)  # gd in samples
    h = signal.dimpulse(sys, n=Nt)
    he = signal.dstep(sys, n=Nt)

    # plot frequency response: level
    ax1 = plt.subplot(3, 2, 1)
    ax1t = ax1.twiny()

    ax1.grid(True, color='lavender', which='major')
    # plotted below grid :-(
    # ax1t.grid(True, color='mistyrose', which='minor')

    ax1.plot(W / (2 * np.pi), 20 * np.log10(np.abs(H)), color='C0', lw=2)
    ax1.set_xscale('linear')
    ax1.set_xlim([0, 1])
    ax1.tick_params(axis='x', labelcolor='C0')
    ax1.set_xlabel(r'$\frac{\Omega}{2\pi} = \frac{f}{f_s}$', color='C0')
    ax1.set_xticks(np.arange(11) / 10)
    ax1.set_ylabel('level in dB   or   20 lg|H| / dB', color='k')
    ax1.set_axisbelow(True)

    ax1t.plot(f, 20 * np.log10(np.abs(H)), color='C3', lw=2)
    ax1t.set_xscale('log')
    ax1t.set_xlim([f[1], f[-1]])
    ax1t.tick_params(axis='x', labelcolor='C3')
    ax1t.set_xlabel('frequency in Hz   or   f / Hz for $f_s$ = ' +
                    '{0:5.2f}'.format(fs) + ' Hz',
                    color='C3')
    ax1t.set_axisbelow(True)

    # plot impulse response
    ax2 = plt.subplot(3, 2, 2)
    ax2.stem(np.squeeze(h[0]),
             np.squeeze(h[1]),
             use_line_collection=True,
             linefmt='C0:',
             markerfmt='C0o',
             basefmt='C0:')
    ax2.xaxis.set_major_locator(MaxNLocator(integer=True))
    ax2.grid(True)
    ax2.set_xlabel(r'$k$')
    ax2.set_ylabel(r'impulse response $h[k]$')

    # plot frequency response: phase
    ax3 = plt.subplot(3, 2, 3)
    ax3.plot(W, np.unwrap(np.angle(H)))
    ax3.set_xlabel(
        r'digital angular frequency in radian   or   $\Omega$ / rad')
    ax3.set_ylabel(r'phase in radian   or $\angle$ H / rad')
    ax3.set_xlim([0, 2 * np.pi])
    ax3.set_xticks(np.arange(9) * np.pi / 4)
    ax3.set_xticklabels([
        r'0', r'$\pi/4$', r'$\pi/2$', r'$3/4\pi$', r'$\pi$', r'$5/4\pi$',
        r'$3/2\pi$', r'$7/4\pi$', r'$2\pi$'
    ])
    # ax3.set_ylim([-180, +180])
    # ax3.set_yticks(np.arange(-180, +180+45, 45))
    ax3.grid(True)

    # plot step response
    ax4 = plt.subplot(3, 2, 4)
    ax4.stem(np.squeeze(he[0]),
             np.squeeze(he[1]),
             use_line_collection=True,
             linefmt='C0:',
             markerfmt='C0o',
             basefmt='C0:')
    ax4.xaxis.set_major_locator(MaxNLocator(integer=True))
    ax4.grid(True)
    ax4.set_xlabel(r'$k$')
    ax4.set_ylabel(r'step response $h_\epsilon[k]$')

    # plot frequency response: group delay
    ax5 = plt.subplot(3, 2, 5)
    ax5.plot(W / np.pi, gd / fs)
    ax5.set_xscale('linear')
    ax5.set_xlim([0, 2])
    ax5.set_xlabel(r'$\frac{\Omega}{\pi}$')
    ax5.set_ylabel(r'group delay in seconds   or   $\tau_\mathrm{GD}$ / s')
    ax5.grid(True, which='both')

    # zplane
    ax6 = plt.subplot(3, 2, 6)
    plot_zplane(sys.zeros, sys.poles, sys.gain)  # see function above
예제 #28
0
파일: filtro.py 프로젝트: micros-g1/TP3
delay = 446e-6
D = int(delay / (1 / fs))

# constantes filtro
Aa = 70
fp = 1.2e3
fa = 2 * fp
N = 25
# N, beta = sgn.kaiserord(Aa, (fa-fp)/(fs/2))
taps = sgn.firwin(N, fp / (fs / 2), window=("chebwin", 55))

gen_filter_coeffs(taps, N)
# taps = sgn.firwin(N, fp/(fs/2), window='hann')
# print(taps)
sistema = sgn.dlti(taps, [1] + [0 for i in range(len(taps) - 1)])
tout, step = sgn.dstep(sistema)

step = step[0]
step = [step[i][0] for i in range(len(step))]
plt.plot(tout, step)
plt.show()

# for tap in taps:
# 	print('{0:.30e}'.format(tap))
w, h = sgn.freqz(taps, worN=8000)
plt.plot((w / np.pi) * (fs / 2), 20 * np.log10(np.absolute(h)), linewidth=2)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Gain')
plt.title('Frequency Response')
# plt.ylim(-0.05, 1.05)
plt.grid(True)
########################################
# Poles and Zeros on the Digital Plant #
########################################
if Poles_Zeros_Digital_Plant == True:
    plot_argand(filter_dig_zoh)

    
##############################
# Step Response verification #
##############################
simulation_time = 0.1
t = np.linspace(0, simulation_time, num=(simulation_time*Fsampling))


if Step_Digital_Plant == True:
    tout, yout_zoh = dstep([filter_dig_zoh.num, filter_dig_zoh.den, td], t=t)
    yout1 = np.transpose(yout_zoh)
    yout0 = yout1[0]
    yout_zoh = yout0[:tout.size]

    fig, ax = plt.subplots()
    ax.set_title('Step Filter Digital ZOH')
    ax.set_ylabel('Plant Voltage')
    ax.set_xlabel('Time [s]')
    ax.grid()

    ax.plot(tout, yout_zoh, 'y')
    # ax.set_ylim(ymin=-20, ymax=100)

    plt.tight_layout()
    plt.show()
예제 #30
0
Ts = 1. / 25000
#sysd = signal.cont2discrete ((num, den), Ts)
#w1, h1 = signal.freqz(sysd)

numd, dend, dt = signal.cont2discrete((num, den), Ts)
numd1 = numd[0, :]
w1, h1 = signal.freqz(numd1, dend, worN=None, whole=0, plot=None)

plt.figure(3)
plt.clf()
plt.plot(w1, 20 * np.log10(abs(h1)), 'b')
plt.ylabel('Amplitude [dB]', color='b')
plt.xlabel('Frequency [rad/sample]')
plt.show()

#u = np.ones(1000)
#t_in = np.arange(0, 1000)

#t_out, y = dlsim(sysd, u, t=t_in)

#tout, yout = signal.dstep((numd1, dend, Ts), x0=None, t=None, n=None)
tout, yout = signal.dstep((numd1, dend, Ts), x0=None, t=None, n=25)
#split del tuple
y_out = yout[0]

plt.figure(4)
plt.clf()
plt.plot(tout, y_out)
plt.show()
예제 #31
0
print T.shape
#print T

#print "this is 't'"
#print t
#print "this is s"
#print s

# recalculate t and s to get smooth plot
#t, s = step(tf, T )
t, s = step(tf, T=linspace(0, 5, 100))
#t, s = step(tf, T)
dsys = (dnum, dden, 1 / 50.0)
print "dsys type:"
print type(dsys)
dt, ds = dstep(dsys)

print "ds:"
print ds

print "ds type:"

print type(ds)

ds_yvals = np.array(ds[0][0:, 0])

#print "continuous time values:"
#print t.shape
#print t

print "discrete time values:"
예제 #32
0
### Desde aca sistema Digital
### Convierto Forward Euler
Fsampling = 1500
Tsampling = 1 / Fsampling
num_d1, den_d1, td = cont2discrete((planta.num, planta.den),
                                   Tsampling,
                                   method='euler')

#normalizo con dlti
planta_d1 = dlti(num_d1, den_d1)
print('Planta Digital sys 1')
print(str(planta_d1.num), '/(', str(planta_d1.den), ')')

#respuesta escalon
t = np.arange(0, 0.1, td)
tout, yout = dstep([planta_d1.num, planta_d1.den, td], t=t)
yout1 = np.transpose(yout)
yout0 = yout1[0]
yout = yout0[:tout.size]

plt.figure(1)
plt.clf()
plt.title('digital Step Response')

plt.stem(tout, yout)
plt.show()

###otro mas ajustado, agrega zero en 1 y compensa ganancia
num_d2 = [0.091, 0.091]
den_d2 = [1, -0.8861]
예제 #33
0
ax1.semilogx(w_euler / (np.pi), mag_euler, 'r')
ax1.set_title('Planta digital Tustin blue; Euler red')
ax1.set_ylabel('Amplitude P D2 [dB]', color='b')
ax1.set_xlabel('Frequency [Hz]')
ax1.set_ylim([-20, 20])

ax2.semilogx(w_tustin / (np.pi), phase_tustin, 'b')
ax2.semilogx(w_euler / (np.pi), phase_euler, 'r')
ax2.set_ylabel('Phase', color='r')
ax2.set_xlabel('Frequency [Hz]')

plt.tight_layout()
plt.show()

t = np.linspace(0, 0.1, num=2000)
tout_t, yout_t = dstep([planta_dig_tustin.num, planta_dig_tustin.den, td], t=t)
tout_e, yout_e = dstep([planta_dig_euler.num, planta_dig_euler.den, td], t=t)
yout1 = np.transpose(yout_t)
yout0 = yout1[0]
yout_t = yout0[:tout_t.size]
yout1 = np.transpose(yout_e)
yout0 = yout1[0]
yout_e = yout0[:tout_e.size]

fig, ax = plt.subplots()
ax.set_title('Respuesta escalon de la planta digital')
ax.set_ylabel('Corriente')
ax.set_xlabel('Tiempo [s]')
ax.grid()
ax.stem(tout_t, yout_t)
ax.stem(tout_e, yout_e, '-.')
예제 #34
0
 def test_step_invariant(self, sys, sample_time, samples_number):
     time = np.arange(samples_number) * sample_time
     _, yout_cont = step2(sys, T=time, **self.tolerances)
     _, yout_disc = dstep(c2d(sys, sample_time, method='zoh'), n=len(time))
     assert_allclose(yout_cont.ravel(), yout_disc[0].ravel())
예제 #35
0
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 24 08:40:22 2021

@author: cns59
"""
import numpy as np
from scipy import signal 
import matplotlib.pyplot as plt

M=48

Kd=?
Kp=?
Ki=?

num=[?, ?, ? ]
den=[1.0, 0.7, 0.1475, 0.0088]

drobot=signal.cont2discrete((num, den),0.05)

t, y = signal.dstep(drobot,n=50)
plt.step(t, np.squeeze(y))
plt.grid()
plt.xlabel('n [samples]')
plt.ylabel('Amplitude')



예제 #36
0
ax1.semilogx(w / (2 * pi) * Fsampling, 20 * np.log10(abs(h)), 'b')
ax1.set_ylabel('Amplitude [dB]', color='b')
ax1.set_xlabel('Frequency [Hz]')

angles = np.unwrap(np.angle(h))
ax2.semilogx(w / (2 * pi) * Fsampling, angles * 180 / pi, 'b-', linewidth="1")
ax2.set_title('Angle')

plt.tight_layout()
plt.show()

### Ahora voy a probar la respuesta escalon del sistema digital
tfinal = 0.01
num = tfinal * Fsampling
t = np.linspace(0, tfinal, num=num)
tout, yout = dstep(planta_d, t=t)

yout1 = np.transpose(yout)
yout0 = yout1[0]
yout = yout0[:tout.size]

fig, ax = plt.subplots()
ax.set_title('Respuesta escalon de la planta d2')
ax.set_ylabel('Corriente')
ax.set_xlabel('Tiempo [s]')
ax.grid()
ax.stem(tout, yout, 'b-')

plt.tight_layout()
plt.show()
예제 #37
0
from scipy import signal
import matplotlib.pyplot as plt

butter = signal.dlti(*signal.butter(3, 0.5))
t, y = signal.dstep(butter, n=25)
plt.step(t, np.squeeze(y))
plt.grid()
plt.xlabel('n [samples]')
plt.ylabel('Amplitude')