コード例 #1
0
    def test_step(self):
        """Test function ``step``."""
        figure(); plot_shape = (1, 3)

        #Test SISO system
        A, B, C, D = self.make_SISO_mats()
        sys = ss(A, B, C, D)
        #print(sys)
        #print("gain:", dcgain(sys))

        subplot2grid(plot_shape, (0, 0))
        t, y = step(sys)
        plot(t, y)

        subplot2grid(plot_shape, (0, 1))
        T = linspace(0, 2, 100)
        X0 = array([1, 1])
        t, y = step(sys, T, X0)
        plot(t, y)

        #Test MIMO system
        A, B, C, D = self.make_MIMO_mats()
        sys = ss(A, B, C, D)

        subplot2grid(plot_shape, (0, 2))
        t, y = step(sys)
        plot(t, y)
コード例 #2
0
    def testStep(self, siso):
        """Test step()"""
        t = np.linspace(0, 1, 10)
        # Test transfer function
        yout, tout = step(siso.tf1, T=t)
        youttrue = np.array([0, 0.0057, 0.0213, 0.0446, 0.0739,
                             0.1075, 0.1443, 0.1832, 0.2235, 0.2642])
        np.testing.assert_array_almost_equal(yout, youttrue, decimal=4)
        np.testing.assert_array_almost_equal(tout, t)

        # Test SISO system with direct feedthrough
        sys = siso.ss1
        youttrue = np.array([9., 17.6457, 24.7072, 30.4855, 35.2234, 39.1165,
                             42.3227, 44.9694, 47.1599, 48.9776])

        yout, tout = step(sys, T=t)
        np.testing.assert_array_almost_equal(yout, youttrue, decimal=4)
        np.testing.assert_array_almost_equal(tout, t)

        # Play with arguments
        yout, tout = step(sys, T=t, X0=0)
        np.testing.assert_array_almost_equal(yout, youttrue, decimal=4)
        np.testing.assert_array_almost_equal(tout, t)

        X0 = np.array([0, 0])
        yout, tout = step(sys, T=t, X0=X0)
        np.testing.assert_array_almost_equal(yout, youttrue, decimal=4)
        np.testing.assert_array_almost_equal(tout, t)

        yout, tout, xout = step(sys, T=t, X0=0, return_x=True)
        np.testing.assert_array_almost_equal(yout, youttrue, decimal=4)
        np.testing.assert_array_almost_equal(tout, t)
コード例 #3
0
    def test_step(self):
        """Test function ``step``."""
        figure()
        plot_shape = (1, 3)

        #Test SISO system
        A, B, C, D = self.make_SISO_mats()
        sys = ss(A, B, C, D)
        #print(sys)
        #print("gain:", dcgain(sys))

        subplot2grid(plot_shape, (0, 0))
        t, y = step(sys)
        plot(t, y)

        subplot2grid(plot_shape, (0, 1))
        T = linspace(0, 2, 100)
        X0 = array([1, 1])
        t, y = step(sys, T, X0)
        plot(t, y)

        #Test MIMO system
        A, B, C, D = self.make_MIMO_mats()
        sys = ss(A, B, C, D)

        subplot2grid(plot_shape, (0, 2))
        t, y = step(sys)
        plot(t, y)
コード例 #4
0
    def test_step(self, SISO_mats, MIMO_mats, mplcleanup):
        """Test function ``step``."""
        figure()
        plot_shape = (1, 3)

        #Test SISO system
        A, B, C, D = SISO_mats
        sys = ss(A, B, C, D)
        #print(sys)
        #print("gain:", dcgain(sys))

        subplot2grid(plot_shape, (0, 0))
        y, t = step(sys)
        plot(t, y)

        subplot2grid(plot_shape, (0, 1))
        T = linspace(0, 2, 100)
        X0 = array([1, 1])
        y, t = step(sys, T, X0)
        plot(t, y)

        # Test output of state vector
        y, t, x = step(sys, return_x=True)

        #Test MIMO system
        A, B, C, D = MIMO_mats
        sys = ss(A, B, C, D)

        subplot2grid(plot_shape, (0, 2))
        y, t = step(sys)
        plot(t, y[:, 0, 0])
コード例 #5
0
ファイル: laba1.py プロジェクト: EvelynCottrell/Lab1
def process_data(num11, den11, num21, den21):
    w11 = ctrl.tf(num11, den11)
    w21 = ctrl.tf(num21, den21)
    print('результат w11={} w21={}'.format(w11, w21))
    TimeLine = []
    for i in range(1, 3000):
        TimeLine.append(i / 1000)
    plt.figure(0, figsize=[7, 6])

    [y11, x11] = ctrl.step(w11, TimeLine)
    [y21, x21] = ctrl.step(w21, TimeLine)
    plt.plot(x11, y11, "r", label='Исходная')
    plt.plot(x21, y21, "b", label='Увеличенная k и уменшенная Т')
    plt.title('Переходная функция звена')
    plt.ylabel('Амплитуда')
    plt.xlabel('Время(с)')
    plt.grid(True)
    plt.show()

    [y11, x11] = ctrl.impulse(w11, TimeLine)
    [y21, x21] = ctrl.impulse(w21, TimeLine)
    plt.plot(x11, y11, "r", label='Исходная')
    plt.plot(x21, y21, "b", label='Увеличенная k и уменшенная Т')
    plt.title('Импульсная функция  звена')
    plt.ylabel('Амплитуда')
    plt.xlabel('Время(с)')
    plt.grid(True)
    plt.show()

    ctrl.mag, ctrl.phase, ctrl.omega = ctrl.bode(w11, w21, dB=False)
    plt.plot()
    plt.show()
    return w11, w21
コード例 #6
0
    def testStep_mimo(self, mimo):
        """Test step for MIMO system"""
        sys = mimo.ss1
        t = np.linspace(0, 1, 10)
        youttrue = np.array([9., 17.6457, 24.7072, 30.4855, 35.2234, 39.1165,
                             42.3227, 44.9694, 47.1599, 48.9776])

        y_00, _t = step(sys, T=t, input=0, output=0)
        y_11, _t = step(sys, T=t, input=1, output=1)
        np.testing.assert_array_almost_equal(y_00, youttrue, decimal=4)
        np.testing.assert_array_almost_equal(y_11, youttrue, decimal=4)
コード例 #7
0
    def BAGUVIX(GG1, name_gg1, GG2, name_gg2,
                t):  # функция для построения графиков характеристик
        topic = {
            'G1': 'безынерционного звена',
            'G2': 'апериодического звена',
            'G3': 'интегрирующего звена',
            'G4': 'реального диф. звена',
            'G5': 'идеального диф. звена',
        }  # словарь для графика
        if name_gg1 in topic:  # определяем какой именно строим, для графика
            k1 = topic[name_gg1]

        plt.figure(1)  # Вывод графиков в отдельном окне
        y1, t1 = con.step(GG1, t)
        y2, t2 = con.step(GG2, t)
        lines = [y1, y2]
        # plt.subplot(1, 1, 1)  # 1цифра - количество строк в графике, 2 -тьиьтиколичество графиков в строке, 3 -номер графика
        lines[0], lines[1] = plt.plot(t, y1, "r", t, y2, "b")
        plt.legend(lines, ['h(t) для 1', 'h(t) для 2'],
                   loc='best',
                   ncol=2,
                   fontsize=10)
        plt.title('Переходная характеристика' + '\n для ' + k1, fontsize=10)
        plt.ylabel('h')
        plt.xlabel('t, c')
        plt.grid()

        plt.figure(2)
        y2, t2 = con.impulse(GG2, t)
        y1, t1 = con.impulse(GG1, t)
        lines[0], lines[1] = plt.plot(t, y1, "r", t, y2, "b")
        plt.legend(lines, ['w(t) для 1', 'w(t) для 2'],
                   loc='best',
                   ncol=2,
                   fontsize=10)
        plt.title('Импульсная характеристика' + '\n для ' + k1, fontsize=10)
        plt.ylabel('w')
        plt.xlabel('t, c')
        plt.grid()

        plt.figure(3)
        mag1, phase1, omega1 = con.bode(GG1, dB=False)
        # plt.plot()
        plt.title('Частотные характеристики' + "\n для " + k1,
                  fontsize=10,
                  y=2.2)
        mag1, phase1, omega1 = con.bode(GG2, dB=False)
        plt.plot()
        plt.title('Частотные характеристики' + "\n для " + k1,
                  fontsize=10,
                  y=2.2)
        plt.show()
コード例 #8
0
def stepResponse(Ts):
    num = Poly(Ts.as_numer_denom()[0],s).all_coeffs()
    den = Poly(Ts.as_numer_denom()[1],s).all_coeffs()
    tf = matlab.tf(map(float,num),map(float,den))
    y,t = matlab.step(tf)
    plt.plot(t,y)
    plt.title("Step Response")
    plt.grid()
    plt.xlabel("time (s)")
    plt.ylabel("y(t)")
    info = "OS:%f%s"%(round((y.max()/y[-1]-1)*100,2),'%')
    try:
        i10 = next(i for i in range(0,len(y)-1) if y[i]>=y[-1]*.10)
        Tr = round(t[next(i for i in range(i10,len(y)-1) if y[i]>=y[-1]*.90)]-t[i10],2)
    except StopIteration:
        Tr = "unknown"
    try:
        Ts = round(t[next(len(y)-i for i in range(2,len(y)-1) if abs(y[-i]/y[-1])>1.02)]-t[0],2)
    except StopIteration:
        Ts = "unknown"
       
    info += "\nTr: %s"%(Tr)
    info +="\nTs: %s"%(Ts)
    print info
    plt.legend([info],loc=4)
    plt.show()    
コード例 #9
0
ファイル: MainBody.py プロジェクト: wrzesienski/CSE
    def second_var():
        """
        Второй способ релизации метода Зиглера-Никольса
        :return: время западнывания tet, постоянную времени T и коэффициент передачи k
        """
        # получает передаточную функцию объекта управления
        w = SchemeBody().get_scheme_solving()

        t = np.linspace(0, stop=100, num=2000)

        y1, t1 = step(w, t)

        y1 = list(y1)
        max_dif = 0
        # номер элемента в списке, имеющего максимальную разницу с предыдущим
        nmd = 0

        for num, yy in enumerate(y1[1:]):
            if (yy - y1[num]) > max_dif:
                max_dif, nmd = (yy - y1[num]), (num + 1)
                if y1[num - 1] < y1[num] > y1[
                        num + 1]:  # дошли до первого максимума, отбой
                    break

        # находим время запаздывания и постоянную времени через уравенение прямой
        tet = -y1[nmd] / (y1[nmd] - y1[nmd - 1]) * (t[nmd] -
                                                    t[nmd - 1]) + t[nmd]
        T = (y1[-1] - y1[nmd]) / (y1[nmd] -
                                  y1[nmd - 1]) * (t[nmd] - t[nmd - 1]) + t[nmd]

        return tet, T, y1[num]
コード例 #10
0
def plot_Res(t, y, g):
    #%matplotlib qt
    Y, T = mt.step(g, t)
    plt.plot(T, Y)
    plt.plot(t, y)
    plt.grid()
    plt.show()
コード例 #11
0
ファイル: Lab1.py プロジェクト: KondrashovMA/Labs-TAU
def create_Plot(var,name,num, den):
    W=ml.tf(num,den)
    if var!=5:
        #Переходная функция
        plt.figure().canvas.set_window_title(name)
        y,x=ml.step(W,timeVector)
        plt.plot(x,y,"b")
        plt.title('Переходная функция')
        plt.ylabel('Амплитуда, о.е.')
        plt.xlabel('Время, с.')
        plt.grid(True)
        #TimeLine=[]
        #for i in range(0;3000):
        #   TimeLine = [i/1000]
        plt.show()
            #Импульсная функция
        plt.figure().canvas.set_window_title(name)
        y,x=ml.impulse(W,  timeVector)
        plt.plot(x,y,"r")
        plt.title('Импульсная функция')
        plt.ylabel('Амплитуда, о.е.')
        plt.xlabel('Время, с.')
        plt.grid(True)
        plt.show()
    #Диаграмма Боде
    plt.figure().canvas.set_window_title(name)
    mag, phase, omega = ml.bode(W, dB=False)
    plt.plot()
    plt.xlabel('Частота, Гц')
    plt.show()
    return
コード例 #12
0
ファイル: impl.py プロジェクト: AndersonUniversity/aucontrols
def pidplot(num, den, Kp, Ki, Kd, desired_settle=1.):
    '''
    Plot system step response when open loop system is subjected to feedback PID compensation.
    Also plots 2% settling lines, and a vertical line at a desired settling time.
    y, t =pidplot(num,den,Kp,Ki,Kd,desired_settle=1.)
    Parameters:
    :param num: [array-like], coefficients of numerator of open loop transfer function
    :param den: [array-like], coefficients of denominator of open loop transfer function
    :param Kp: [float] Proportional gain
    :param Ki: [float] Integral gain
    :param Kd: [float] Derivative gain
    :param desired_settle: [float] Desired settling time, for tuning PID controllers, default = 1.0
    Returns:
    :return: y: [array-like] time step response
    :return: t: [array-like] time vector
    '''
    numc = [Kd, Kp, Ki]
    denc = [0, 1, 0]

    numcg = convolve(numc, num)
    dencg = convolve(denc, den)

    Gfb = feedback(tf(numcg, dencg), 1)
    y, t = step(Gfb)
    yss = dcgain(Gfb)
    plot(t, y, 'r')
    plot(t, 1.02 * yss * ones(len(t)), 'k--')
    plot(t, 0.98 * yss * ones(len(t)), 'k--')
    plot(desired_settle * ones(15), linspace(0, yss + 0.25, 15), 'b-.')
    xlim(0)
    xlabel('Time [s]')
    ylabel('Magnitude')
    grid()
    show()
    return y, t
コード例 #13
0
    def test_dcgain_2(self):
        """Test function dcgain with different systems"""
        #Create different forms of a SISO system
        A, B, C, D = self.make_SISO_mats()
        num, den = scipy.signal.ss2tf(A, B, C, D)
        # numerator is only a constant here; pick it out to avoid numpy warning
        Z, P, k = scipy.signal.tf2zpk(num[0][-1], den)
        sys_ss = ss(A, B, C, D)

        #Compute the gain with ``dcgain``
        gain_abcd = dcgain(A, B, C, D)
        gain_zpk = dcgain(Z, P, k)
        gain_numden = dcgain(np.squeeze(num), den)
        gain_sys_ss = dcgain(sys_ss)
        # print('gain_abcd:', gain_abcd, 'gain_zpk:', gain_zpk)
        # print('gain_numden:', gain_numden, 'gain_sys_ss:', gain_sys_ss)

        #Compute the gain with a long simulation
        t = linspace(0, 1000, 1000)
        y, _t = step(sys_ss, t)
        gain_sim = y[-1]
        # print('gain_sim:', gain_sim)

        #All gain values must be approximately equal to the known gain
        assert_array_almost_equal(
            [gain_abcd, gain_zpk, gain_numden, gain_sys_ss, gain_sim],
            [0.026948, 0.026948, 0.026948, 0.026948, 0.026948],
            decimal=6)
コード例 #14
0
def step_sys(sys, final_time, setpoint):
    # open-loop system transfer function
    try:
        num, den = model(sys)
    except:
        # for error detection
        print("Err: system in not defined")
        return
    Gs = control.tf(num, den)
    #print(Gs)
    # closed-loop unity-feedback transfer function
    Ts = control.feedback(Gs, 1)

    # simulation time parameters
    initial_time = 0
    nsteps = 40 * final_time   # number of time steps
    t = np.linspace(initial_time, final_time, round(nsteps))
    output, t = matlab.step(Ts, t)
    output = setpoint*output

    # covert numpy arrays to lists
    t = list(t)
    output = list(output)

    # round lists to 6 decimal digits
    ndigits = 6
    t = [round(num, ndigits) for num in t]
    output = [round(num, ndigits) for num in output]

    return t, output
コード例 #15
0
    def assert_systems_behave_equal(self, sys1, sys2):
        '''
        Test if the behavior of two LTI systems is equal. Raises ``AssertionError``
        if the systems are not equal.

        Works only for SISO systems.

        Currently computes dcgain, and computes step response.
        '''
        #gain of both systems must be the same
        assert_array_almost_equal(dcgain(sys1), dcgain(sys2))

        #Results of ``step`` simulation must be the same too
        y1, t1 = step(sys1)
        y2, t2 = step(sys2, t1)
        assert_array_almost_equal(y1, y2)
コード例 #16
0
    def analysis(self, w, block, which):
        nume = [int(n) for n in block.nume_coef]
        if block.deno_coef == []:
            deno = [1]
        else:
            deno = [int(d) for d in block.deno_coef]
        nume.reverse()
        deno.reverse()
        print(nume)
        print(deno)
        system = matlab.tf(nume, deno)

        if which == 'bode':
            matlab.bode(system)
            plt.show()
        elif which == 'rlocus':
            matlab.rlocus(system)
            plt.show()
        elif which == 'nyquist':
            matlab.nyquist(sys)
            plt.show()
        elif which == 'impulse':
            t = np.linspace(0, 3, 1000)
            yout, T = matlab.impulse(system, t)
            plt.plot(T, yout)
            plt.axhline(0, color="b", linestyle="--")
            plt.xlim(0, 3)
            plt.show()
        elif which == 'step':
            t = np.linspace(0, 3, 1000)
            yout, T = matlab.step(system, t)
            plt.plot(T, yout)
            plt.axhline(1, color="b", linestyle="--")
            plt.xlim(0, 3)
            plt.show()
コード例 #17
0
    def assert_systems_behave_equal(self, sys1, sys2):
        '''
        Test if the behavior of two Lti systems is equal. Raises ``AssertionError``
        if the systems are not equal.

        Works only for SISO systems.

        Currently computes dcgain, and computes step response.
        '''
        #gain of both systems must be the same
        assert_array_almost_equal(dcgain(sys1), dcgain(sys2))

        #Results of ``step`` simulation must be the same too
        t, y1 = step(sys1)
        _t, y2 = step(sys2, t)
        assert_array_almost_equal(y1, y2)
コード例 #18
0
    def test_dcgain_2(self):
        """Test function dcgain with different systems"""
        #Create different forms of a SISO system
        A, B, C, D = self.make_SISO_mats()
        Z, P, k = scipy.signal.ss2zpk(A, B, C, D)
        num, den = scipy.signal.ss2tf(A, B, C, D)
        sys_ss = ss(A, B, C, D)

        #Compute the gain with ``dcgain``
        gain_abcd = dcgain(A, B, C, D)
        gain_zpk = dcgain(Z, P, k)
        gain_numden = dcgain(np.squeeze(num), den)
        gain_sys_ss = dcgain(sys_ss)
        print('gain_abcd:', gain_abcd, 'gain_zpk:', gain_zpk)
        print('gain_numden:', gain_numden, 'gain_sys_ss:', gain_sys_ss)

        #Compute the gain with a long simulation
        t = linspace(0, 1000, 1000)
        y, _t = step(sys_ss, t)
        gain_sim = y[-1]
        print('gain_sim:', gain_sim)

        #All gain values must be approximately equal to the known gain
        assert_array_almost_equal([gain_abcd[0,0],   gain_zpk[0,0],
                                   gain_numden[0,0], gain_sys_ss[0,0], gain_sim],
                                  [0.026948, 0.026948, 0.026948, 0.026948,
                                   0.026948],
                                  decimal=6)

        #Test with MIMO system
        A, B, C, D = self.make_MIMO_mats()
        gain_mimo = dcgain(A, B, C, D)
        print('gain_mimo: \n', gain_mimo)
        assert_array_almost_equal(gain_mimo, [[0.026948, 0       ],
                                              [0,        0.026948]], decimal=6)
コード例 #19
0
def test_dcgain_2():
    """Test function dcgain with different systems"""
    #Create different forms of a SISO system
    A, B, C, D = make_SISO_mats()
    Z, P, k = scipy.signal.ss2zpk(A, B, C, D)
    num, den = scipy.signal.ss2tf(A, B, C, D)
    sys_ss = ss(A, B, C, D)

    #Compute the gain with ``dcgain``
    gain_abcd = dcgain(A, B, C, D)
    gain_zpk = dcgain(Z, P, k)
    gain_numden = dcgain(np.squeeze(num), den)
    gain_sys_ss = dcgain(sys_ss)
    print 'gain_abcd:', gain_abcd, 'gain_zpk:', gain_zpk
    print 'gain_numden:', gain_numden, 'gain_sys_ss:', gain_sys_ss

    #Compute the gain with a long simulation
    t = linspace(0, 1000, 1000)
    _t, y = step(sys_ss, t)
    gain_sim = y[-1]
    print 'gain_sim:', gain_sim

    #All gain values must be approximately equal to the known gain
    assert_array_almost_equal([
        gain_abcd[0, 0], gain_zpk[0, 0], gain_numden[0, 0], gain_sys_ss[0, 0],
        gain_sim
    ], [0.026948, 0.026948, 0.026948, 0.026948, 0.026948],
                              decimal=6)

    #Test with MIMO system
    A, B, C, D = make_MIMO_mats()
    gain_mimo = dcgain(A, B, C, D)
    print 'gain_mimo: \n', gain_mimo
    assert_array_almost_equal(gain_mimo, [[0.026948, 0], [0, 0.026948]],
                              decimal=6)
コード例 #20
0
    def test_dcgain_2(self):
        """Test function dcgain with different systems"""
        #Create different forms of a SISO system
        A, B, C, D = self.make_SISO_mats()
        num, den = scipy.signal.ss2tf(A, B, C, D)
        # numerator is only a constant here; pick it out to avoid numpy warning
        Z, P, k = scipy.signal.tf2zpk(num[0][-1], den)
        sys_ss = ss(A, B, C, D)

        #Compute the gain with ``dcgain``
        gain_abcd = dcgain(A, B, C, D)
        gain_zpk = dcgain(Z, P, k)
        gain_numden = dcgain(np.squeeze(num), den)
        gain_sys_ss = dcgain(sys_ss)
        # print('gain_abcd:', gain_abcd, 'gain_zpk:', gain_zpk)
        # print('gain_numden:', gain_numden, 'gain_sys_ss:', gain_sys_ss)

        #Compute the gain with a long simulation
        t = linspace(0, 1000, 1000)
        y, _t = step(sys_ss, t)
        gain_sim = y[-1]
        # print('gain_sim:', gain_sim)

        #All gain values must be approximately equal to the known gain
        assert_array_almost_equal([gain_abcd[0,0],   gain_zpk[0,0],
                                   gain_numden[0,0], gain_sys_ss[0,0], gain_sim],
                                  [0.026948, 0.026948, 0.026948, 0.026948,
                                   0.026948],
                                  decimal=6)
コード例 #21
0
    def testDcgain(self, siso):
        """Test dcgain() for SISO system"""
        # Create different forms of a SISO system using scipy.signal
        A, B, C, D = siso.ss1.A, siso.ss1.B, siso.ss1.C, siso.ss1.D
        Z, P, k = sp.signal.ss2zpk(A, B, C, D)
        num, den = sp.signal.ss2tf(A, B, C, D)
        sys_ss = siso.ss1

        # Compute the gain with ``dcgain``
        gain_abcd = dcgain(A, B, C, D)
        gain_zpk = dcgain(Z, P, k)
        gain_numden = dcgain(np.squeeze(num), den)
        gain_sys_ss = dcgain(sys_ss)
        # print('\ngain_abcd:', gain_abcd, 'gain_zpk:', gain_zpk)
        # print('gain_numden:', gain_numden, 'gain_sys_ss:', gain_sys_ss)

        # Compute the gain with a long simulation
        t = linspace(0, 1000, 1000)
        y, _t = step(sys_ss, t)
        gain_sim = y[-1]
        # print('gain_sim:', gain_sim)

        # All gain values must be approximately equal to the known gain
        np.testing.assert_array_almost_equal(
            [gain_abcd, gain_zpk, gain_numden, gain_sys_ss, gain_sim],
            [59, 59, 59, 59, 59])
コード例 #22
0
ファイル: ToPlot.py プロジェクト: wrzesienski/CSE
def plot_trans_func(w, toFindT=False, toPlotTrans=False):
    """
    функция находит и возвращает период переходной характеристики
    """
    t = np.linspace(0, stop=100, num=2000)

    y1, t1 = step(w, t)

    t = list(t)

    if toPlotTrans:
        plt.plot(t, y1, "r")
        plt.title('Step Response')
        plt.ylabel('Amplitude  h(t)')
        plt.xlabel('Time(sec)')
        plt.grid(True)
        plt.show()

    if toFindT:
        two_maxes = []

        for num in range(len(y1[1:-1])):
            if y1[num - 1] < y1[num] > y1[num + 1]:
                two_maxes.append(num)
            if len(two_maxes) == 2: break

        return t[two_maxes[1]] - t[two_maxes[0]]
コード例 #23
0
ファイル: lab3.py プロジェクト: darkdigger/lab3python
def grafic_stepw(f, name):
    y1, x1 = cm.step(f, TimeLine)
    plt.plot(x1, y1, "b")
    plt.title('Переходная функция {}'.format(name))
    plt.ylabel('Амплитудное значение')
    plt.xlabel('Время(c)')
    plt.grid(True, linewidth=1, alpha=0.5)
    plt.show()
コード例 #24
0
def degrau(G):
    y1,t1 = co.step(co.feedback(G,1))
    plt.figure()
    plt.plot(t1,y1)
    plt.title("Step")
    plt.xlabel("Tempo[s]")
    plt.ylabel("Amplitude")
    plt.grid()
    print( co.stepinfo(co.feedback(G,1)))
コード例 #25
0
ファイル: disk.py プロジェクト: hustjinghu/pycontrol-gui
def residuals(p, y, t):
    [k,alpha] = p
    print(k, type(k))
    alpha = p[1]
    print(alpha, type(alpha))
    g = tf(k,[1,alpha,0])
    Y,T = mt.step(g,t)
    err=y-Y
    return err
コード例 #26
0
def pereh(W, t):
    plt.figure(1)  # Вывод графиков в отдельном окне
    y1, t = con.step(W, t)
    lines = [y1]
    lines[0] = plt.plot(t, y1, "r")
    plt.legend(lines[0], ['h(t) для 1'], loc='best', fontsize=10)
    plt.title('Переходная характеристика', fontsize=10)
    plt.ylabel('h')
    plt.xlabel('t, c')
    plt.grid()
    plt.show()
コード例 #27
0
    def get_trans_func(self):

        print(self.w)

        y1, t1 = step(self.w, self.t)
        plt.plot(self.t, y1, "r")
        plt.title('Step Response')
        plt.ylabel('Amplitude  h(t)')
        plt.xlabel('Time(sec)')
        plt.grid(True)
        plt.show()

        return
コード例 #28
0
    def step_response(self):

        if self._verbose:
            print("[PID Design] Calculating PID gains")
        pid_tf, closedLoop_tf = self.pid_design()

        end_time = 5  # [s]
        npts = int(old_div(end_time, self._dt)) + 1
        T = np.linspace(0, end_time, npts)
        yout, T = cnt.step(closedLoop_tf, T)

        u, _, _ = cnt.lsim(pid_tf, 1 - yout, T)

        return T, u, yout
コード例 #29
0
def action_pid(sys, final_time, setpoint, Kp, Ki, Kd):
    # open-loop system transfer function
    try:
        num, den = model(sys)
    except:
        # for error detection
        print("Err: system in not defined")
        return
    Gs = control.tf(num, den)
    s = matlab.tf('s')
    Ds = Kp + Ki/s + Kd*s

    # closed-loop unity-feedback transfer function
    Ts = control.feedback(Ds*Gs, 1)

    # simulation time parameters
    initial_time = 0
    nsteps = 40 * int(final_time)   # number of time steps
    t = np.linspace(initial_time, final_time, round(nsteps))

    output, t = matlab.step(Ts, t)
    output = setpoint*output

    # calculate list of error
    setpoint_arr = setpoint * np.ones(nsteps)
    err = setpoint_arr - output
    action = []
    sum = 0
    for i in range(len(err)):
        if i == 0:

            action.append(Kp*err[i] + Kd*(err[i]-0)/t[1])
        else:
            sum += t[1]*(err[i]+err[i-1])/2
            action.append(Kp*err[i] + Kd*(err[i]-err[i - 1])/t[1] + Ki * sum)

    # round lists to 6 decimal digits
    ndigits = 6
    t = [round(num, ndigits) for num in t]
    action = [round(num, ndigits) for num in action]

    # calculate maximum control action
    max_action = max(action)
    min_action = min(action)
    return t, action, min_action, max_action
コード例 #30
0
def action_zpk(sys, final_time, setpoint, z, p, k):
    # open-loop system transfer function
    try:
        num, den = model(sys)
    except:
        # for error detection
        print("Err: system in not defined")
        return
    Gs = control.tf(num, den)
    z = np.array([z])
    p = np.array([p])
    num, den = matlab.zpk2tf(z, p, k)
    Ds = matlab.tf(num, den)
    # closed-loop unity-feedback transfer function
    Ts = control.feedback(Ds*Gs, 1)

    # simulation time parameters
    initial_time = 0
    nsteps = 40 * int(final_time)   # number of time steps
    t = np.linspace(initial_time, final_time, round(nsteps))

    output, t = matlab.step(Ts, t)
    output = setpoint*output

    # calculate list of error
    setpoint_arr = setpoint * np.ones(nsteps)
    err = setpoint_arr - output

    # calculate control action
    action = matlab.lsim(Ds, err, t)

    # covert numpy arrays to lists
    t = list(t)
    action = list(action[0])

    # round lists to 6 decimal digits
    ndigits = 6
    t = [round(num, ndigits) for num in t]
    action = [round(num, ndigits) for num in action]

    # calculate maximum control action
    max_action = max(action)
    min_action = min(action)
    return t, action, min_action, max_action
コード例 #31
0
def intergalnaya_Otsenka(W):
    a = 0
    b = 100
    n = 1000
    h = (b - a) / n
    t = np.linspace(a, b, num=n)
    y, x = con.step(W, t)  # х-время ПП
    func = 0
    x0 = x[0]
    y0 = y[0]
    # нахождение площади методом трапеций
    for i in range(0, len(x), 1):
        xi = x[i]
        y1 = y[i]
        func += abs(1 * (xi - x0) - 0.5 * (y1 + y0) * (xi - x0))
        x0 = xi
        y0 = y1
    # print(func)
    print("Интегральная оценка за ", b, " c = ", func)
コード例 #32
0
ファイル: Problem4.py プロジェクト: kwint/Robot_Control_B
def control(s, Y, D):
    end = 10
    G = 1 / (3 * s * (s + 1))
    F = (3 * s * (s + 1))

    KP, KD, KI = 16, 7, 4

    H_pd = (KP + KD * s)
    H_pid = (KP + KD * s + KI / s)

    PD = cm.feedback((KP + KD * s) * G, 1)  # PD controller
    PID = cm.feedback((KP + KD * s + KI / s) * G, 1)  # PID controller
    PD_FF = cm.tf([1], [1])
    PID_FF = cm.tf([1], [1])  # PID controller

    D_PD = (G) / (1 + (KP + KD * s) * (G))
    D_PID = (G) / (1 + (KP + KD * s + KI / s) * (G))

    # Now, according to the Example, we calculate the response of
    # the closed loop system to a step input of size 10:
    out_PD, t = cm.step(Y * PD, np.linspace(0, end, 200))
    out_PID, t = cm.step(Y * PID, np.linspace(0, end, 200))
    out_PD_FF, t = cm.step(Y * PD_FF, np.linspace(0, end, 200))
    out_PID_FF, t = cm.step(Y * PID_FF, np.linspace(0, end, 200))

    out_PD_D, t = cm.step(-D * D_PD, np.linspace(0, end, 200))
    out_PID_D, t = cm.step(-D * D_PID, np.linspace(0, end, 200))

    theta_PD = out_PD + out_PD_D
    theta_PID = out_PID + out_PID_D
    theta_PD_FF = out_PD_FF + out_PD_D
    theta_PID_FF = out_PID_FF + out_PID_D

    y_out, t = cm.step(Y, np.linspace(0, end, 200))

    plt.plot(t, theta_PD, lw=2, label="PD")
    plt.plot(t, theta_PID, lw=2, label="PID")
    if D != 0:
        plt.plot(t, theta_PD_FF, lw=2, label="PD_FF")
        plt.plot(t, theta_PID_FF, lw=2, label="PID_FF")

    plt.plot(t, y_out, lw=1, label="Reference")
    plt.xlabel('Time')
    plt.ylabel('Position')
    plt.legend()
コード例 #33
0
def step_zpk(sys, final_time, setpoint, z, p, k):
    # open-loop system transfer function
    try:
        num, den = model(sys)
    except:
        # for error detection
        print("Err: system in not defined")
        return
    Gs = control.tf(num, den)

    # define compensator transfer function
    # convert zero and pole to numpy arrays
    z = np.array([z])
    p = np.array([p])
    num, den = matlab.zpk2tf(z, p, k)
    Ds = matlab.tf(num, den)

    # Compensated open-loop transfer function
    DsGs = Ds*Gs

    # closed-loop unity-feedback transfer function
    Ts = control.feedback(DsGs, 1)

    # simulation time parameters
    initial_time = 0
    nsteps = 40 * final_time   # number of time steps
    t = np.linspace(initial_time, final_time, round(nsteps))
    output, t = matlab.step(Ts, t)
    output = setpoint*output

    # covert numpy arrays to lists
    t = list(t)
    output = list(output)

    # round lists to 6 decimal digits
    ndigits = 6
    t = [round(num, ndigits) for num in t]
    output = [round(num, ndigits) for num in output]

    return t, output
コード例 #34
0
ファイル: ToAnalyze.py プロジェクト: wrzesienski/CSE
def do_direct_method(w):
    """
    definition for analyzing regulator quality by step responce.
    parameters in research:
    - regulation time
    - hesistation
    - overshoot
    - degree of attenuation
    :return: keys for handle changing regulator quality
    """
    def get_degree(ideal, actual):
        """
        функция оценивает полученное значение по пятибальной шкале
        :param ideal: идеальное значение
        :param actual: реальное значение
        :return: оценка
        """
        mas = [0, 1, 1.2, 1.4, 1.6, 1.8, 2]
        for i in range(len(mas) - 1):
            if mas[i] * ideal <= actual < mas[i + 1] * ideal:
                return len(mas) - 2 - i
            elif actual > mas[-1] * ideal:
                return 0

    t = np.linspace(0, stop=100, num=2000)

    counter = regulation_time = t_vr_reg = integral_mean = 0

    y1, t1 = step(w, t)

    y1 = list(y1)
    max_y = max(y1)
    last_y = y1[-1]
    """перерегулирование и его оценка"""
    overshoot = (max_y - last_y) / last_y
    key_per = get_degree(27, overshoot)
    """величина и время достижения первого максимума и их оценка"""
    key_vel_max = get_degree(1.1, max(y1))
    key_vr_max = get_degree(1, t[y1.index(max(y1))])

    two_maxes = []

    for num in range(len(y1[1:-1])):
        if y1[num - 1] < y1[num] > y1[num + 1]:
            two_maxes.append(y1[num])
        if len(two_maxes) == 10: break
    """степень затухания и ее оценка"""
    if len(two_maxes) <= 1:
        key_deg = 5.0
    else:
        degree_of_attenuation = (1 - two_maxes[1] / two_maxes[0]) * 100
        if degree_of_attenuation <= 0:
            key_deg = -1
        else:
            key_deg = get_degree(1 / 6.6, 1 / degree_of_attenuation)

    for i in range(len(y1)):
        if 0.95 * last_y < y1[i] < 1.05 * last_y:
            """
            counter - счетчик входящих в диапазон установившегося значения точек
            устраняет вероятность ошибки попадания условия в нулевой промежуток колебательной
            функции
            """
            counter += 1
            if counter == 20:  # функция внутри диапазона, удовл. достаточности уст. режима.
                regulation_time = t[i]
                # номер нахождения в массиве t значения времени регулирования
                t_vr_reg = i
                break
        else:  # функция еще не в установившемся значении
            counter = 0
    """оценка времени регулирования"""
    key_reg = get_degree(15, regulation_time)
    """оценка показателя колебательности"""
    if len(two_maxes) <= 1:
        key_koleb = 5.0
    else:
        koleb = two_maxes[1] / two_maxes[0] * 100
        key_koleb = get_degree(1.19, koleb)
    """интеграл и его оценка"""
    for i in range(0, t_vr_reg):
        integral_mean = integral_mean + abs(y1[t_vr_reg] - y1[i]) * t[1]
    key_int = get_degree(0.3, integral_mean)

    # проверка системы на устойчивость
    poles, zeros = pzmap(w, Plot=False)
    if not is_sustainable(poles):
        return [-100]

    return [
        key_koleb, key_reg, key_per, key_deg, key_vel_max, key_vr_max, key_int
    ]
コード例 #35
0
#print_c2d_matlablike(syst_fake_dis)

# Python:
# zero order hold by default
# 4.96670866519e-05 z 4.93370716897e-05
# -----------------------
#  z^2 1.0 z^2 -1.97990166083 z 0.980198673307
# 
# Sample time: 0.01 seconds
# Discrete-time transfer function.

# MATLAB:
# [output,t]=step(syst_fake_dis)
### OLD scipy.signal.step way!
###output, t = step(syst_fake_dis[0][0], syst_fake_dis[1])# ,T=200) # MATLAB calculates the T size automatically based on black magic different than python one, see [MATLAB]/toolbox/shared/controllib/engine/@DynamicSystem/step.m:
output, t = step(syst_fake_dis)
# MATLAB:
# plot(output)
plot(output[0])
show()

# out_len = len(output)
out_len = len(output[0])
print "out_len is:"
print out_len
print "output is:"
print output[0]
# input=1:650;
# input(:)=1;
input_ = np.ones(out_len)
# [num,den]=stmcb(output,input,0,2)
コード例 #36
0
8., 0., 0., 0.; \
0., 4., 0., 0.; \
0., 0., 1., 0.')
B = np.matrix('2.; 0.; 0.; 0.')
C = np.matrix('0.5, 0.6875, 0.7031, 0.5')
D = np.matrix('0.')

# The full system
fsys = StateSpace(A,B,C,D)
# The reduced system, truncating the order by 1
ord = 3
rsys = msimp.balred(fsys,ord, method = 'truncate')

# Comparison of the step responses of the full and reduced systems
plt.figure(1)
y, t = mt.step(fsys)
yr, tr = mt.step(rsys)
plt.plot(t.T, y.T)
plt.plot(tr.T, yr.T)

# Repeat balanced reduction, now with 100-dimensional random state space
sysrand = mt.rss(100, 1, 1)
rsysrand = msimp.balred(sysrand,10,method ='truncate')

# Comparison of the impulse responses of the full and reduced random systems
plt.figure(2)
yrand, trand = mt.impulse(sysrand)
yrandr, trandr = mt.impulse(rsysrand)
plt.plot(trand.T, yrand.T, trandr.T, yrandr.T) 

コード例 #37
0
ファイル: jet_book_1.py プロジェクト: zaqwes8811/my-courses
	def plot_sys(sys):
		ys, ts = step(sys)
		plot(ts, ys)