Esempio n. 1
0
 def gen_u_swept_sine(self,amp=10,fmax=7,fmin=0,tspan=20,\
                      dt=0.01,deadtime=0.2):
     u_ss,t = control_utils.create_swept_sine_signal(fmax=fmax, \
                                                     fmin=fmin, \
                                                     tspan=tspan, \
                                                     dt=dt, \
                                                     deadtime=deadtime)
     u_ss *= amp
     u_int = u_ss.astype(int)
     return u_int
def gen_input_vect(T=2.0, case='sys_check', dt=1.0/500, input_params={'amp':100}):
    t = arange(0,T,dt)
    u = zeros_like(t)
    amp = input_params['amp']
    
    if case == 'sys_check':
        u[10:50] = amp
        u[-90:-50] = -amp

    elif case in ['step','step_input']:
        ind_on = int(input_params['t_on']/dt)
        u[ind_on:] = amp


    elif case == 'finite_width_pulse':
        ind_on = int(input_params['t_on']/dt)
        ind_off = int(input_params['t_off']/dt)
        u[ind_on:ind_off] = amp


    elif case == 'swept_sine':
        import control_utils
        t_span = T
        fmax = input_params['fmax']
        fmin = input_params['fmin']
        deadtime = input_params['deadtime']
        
        u, t = control_utils.create_swept_sine_signal(fmax=fmax, fmin=fmin, \
                                                      tspan=t_span, dt=dt, \
                                                      deadtime=deadtime)
        u *= amp

    elif case == 'return_to_zero':
        #really do nothing, but this is a valid case
        u = zeros_like(t)
    else:
        raise ValueError, "I don't know what to do with case %s" % case
        
    return u
    ## dt = 1.0/500
    ## JVC_model_dict['g'] = g
    ## JVC_model_dict['p'] = p
    ## JVC_model_dict['dt'] = dt
    ## JVC_model_dict['t_beam'] = t_m
    from JVC_params import JVC_model_dict

    myparser = DTTMM_xml_parser("test.xml")
    myparser.convert(JVC_model_dict)

    # dt = 1.0/1000
    dt = 1.0 / 500.0

    import control_utils

    u, t = control_utils.create_swept_sine_signal(20, tspan=10.0, dt=1.0 / 500, deadtime=1.0)

    mysys = DTTMM.DT_TMM_System_from_XML_four_states(
        myparser.elemlist, sensors=myparser.sensor_list, actuators=myparser.act_list, dt=dt
    )

    N = len(u)
    ol_v = numpy.zeros(N)
    ol_v[10:20] = 125.0
    mysys.init_sim(N)

    input_signal = u
    for i, u_i in enumerate(input_signal):
        if i > 0:
            mysys.run_sim_one_step(i, [u_i], int_case=1)
Esempio n. 4
0
 def build_u(self, t):
     self.u, t2 = control_utils.create_swept_sine_signal(fmax=self.fmax, \
                                                         fmin=self.fmin, \
                                                         t=t, \
                                                         deadtime=self.deadtime)
     return self.u
    #df_path = 'PSoC_data/OL_pulse_test_sys_check_SLFR_RTP_OL_Test_uend=0.txt'
    df_path = 'PSoC_data/step_response_kp_1_amp_200.txt'
    import txt_data_processing
    df = txt_data_processing.Data_File(df_path)
    
    input_case = 2

    filename = 'sim_data.txt'
    if input_case == 1:
        t = df.t
        u = df.u
        filename = 'sim_step_response.txt'
    elif input_case == 2:
        import control_utils
        u, t = control_utils.create_swept_sine_signal(fmax=20.0, fmin=0.0, \
                                                      tspan=10.0, dt=1.0/500, \
                                                      deadtime=0.5)
        filename = 'sim_swept_sine.txt'
        
    input_block = sim_sys.get_block('input')
    input_block.set_u(u)
    #t = arange(0,7,0.002)
    ## swept_sine = sim_sys.get_block('swept_sine')
    ## u, t = swept_sine.build_u_and_t()
    N = len(t)
    dt = t[1]-t[0]
    sim_sys.prep_for_sim(N, t, dt)

    sim_sys.sort_blocks()
    sim_sys.Run_Simulation()
    dttmm_sys = sim_sys.get_block('SFLR')