def __obtem_pouso(f_atv, f_apx): """ obtém o Pouso @param f_atv: pointer to aeronave @param f_apx: pointer to aproximação @return True se encontrou o Pouso, senão False (inexistente) """ # check input assert f_atv assert f_apx # pista de pouso ok ? if (f_apx.ptr_apx_pis is not None) and (f_apx.ptr_apx_pis.v_pst_ok): # ângulo mínimo para o pouso # i_pst_rumo (mlabru) lf_ang = abs(f_atv.f_trf_pro_atu - f_apx.ptr_apx_pis.f_pst_true) # tem condições de fazer pouso direto ? if lf_ang <= 15.: # inicia a nova fase na aproximação f_atv.en_atv_fase = ldefs.E_FASE_APXALINHAR # estabelece a proa a ser atingida (rumo da pista) # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = f_apx.ptr_apx_pis.f_pst_true # inicia a curva pelo menor lado scrv.sentido_curva(f_atv) # pointer do aeródromo f_atv.ptr_atv_aer = f_apx.ptr_apx_aer # pointer da pista f_atv.ptr_atv_pst = f_apx.ptr_apx_pis # coloca em procedimento de pouso f_atv.en_trf_fnc_ope = ldefs.E_POUSO # volta para fase inicial do procedimento de aproximação OU fase inicial do pouso f_atv.en_atv_fase = ldefs.E_FASE_ZERO # retorna sucesso na pesquisa return True # retorna condição de falha na pesquisa return False
def __ckeck_ok(f_atv, f_cine_data): """ verifica condições da aeronave para o direcionamento ao fixo @param f_atv: ponteiro para aeronave @param f_cine_data: ponteiro para pilha """ # logger # M_LOG.info("__ckeck_ok:>>") # check input assert f_atv assert f_cine_data # active flight ? if (not f_atv.v_atv_ok) or (ldefs.E_ATIVA != f_atv.en_trf_est_atv): # logger l_log = logging.getLogger("prc_dir_fixo::__check_ok") l_log.setLevel(logging.ERROR) l_log.error("<E01: aeronave não ativa.") # cai fora... return # aponta para o fixo a ser interceptado e valida ponteiro l_fix = f_atv.ptr_atv_fix_prc # M_LOG.debug("prc_dir_fixo::ptr_atv_fix_prc:[{}/{}].".format(f_atv.ptr_atv_fix_prc.i_fix_id, f_atv.ptr_atv_fix_prc.s_fix_desc)) if (l_fix is None) or (not l_fix.v_fix_ok): # logger l_log = logging.getLogger("prc_dir_fixo::__ckeck_ok") l_log.setLevel(logging.ERROR) l_log.error(u"<E02: fixo inexistente. aeronave:[{}/{}].".format(f_atv.i_trf_id, f_atv.s_trf_ind)) # não encontrou o fixo, força a aeronave abandonar o procedimento abnd.abort_prc(f_atv) # return return # VOR ? if ldefs.E_VOR == l_fix.en_fix_tipo: # calcula raio do cone de tolerância l_fix.f_fix_rcone = f_atv.f_trf_alt_atu * math.tan(math.radians(30)) # otherwise, outro tipo de fixo else: # calcula raio do cone de tolerância l_fix.f_fix_rcone = f_atv.f_trf_alt_atu * math.tan(math.radians(40)) # distância ao fixo <= raio do cone (ver DadosDinâmicos) if f_atv.f_atv_dst_fix <= l_fix.f_fix_rcone: # sinaliza que aeronave atingiu o ponto através raio do cone f_cine_data.v_interceptou_fixo = True # coloca em manual f_atv.en_trf_fnc_ope = ldefs.E_MANUAL # volta a fase de verificar condições f_atv.en_atv_fase = ldefs.E_FASE_ZERO # logger # M_LOG.info(u"__ckeck_ok:<E03: interceptou o fixo.") # return return # calcula distância da aeronave ao fixo (x, y) lf_dst_x = f_cine_data.f_dst_anv_fix_x ** 2 lf_dst_y = f_cine_data.f_dst_anv_fix_y ** 2 # calcula distância do "passo" da aeronave (x, y) lf_dlt_x = f_cine_data.f_delta_x ** 2 lf_dlt_y = f_cine_data.f_delta_y ** 2 # aeronave atingiu fixo ? (distância <= passo da aeronave) if math.sqrt(lf_dst_x + lf_dst_y) <= math.sqrt(lf_dlt_x + lf_dlt_y): # considera que a aeronave atingiu o fixo pelas coordenadas x, y f_cine_data.v_interceptou_fixo = True # coloca em manual f_atv.en_trf_fnc_ope = ldefs.E_MANUAL # volta a fase de verificar condições f_atv.en_atv_fase = ldefs.E_FASE_ZERO # logger # M_LOG.info(u"__ckeck_ok:<E04: interceptou o fixo.") # return return # calcula nova proa de demanda f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(f_cine_data.f_dst_anv_fix_x, f_cine_data.f_dst_anv_fix_y) # calcula sentido de curva pelo menor ângulo scrv.sentido_curva(f_atv) # ajusta a razão de curva da aeronave razc.calc_razao_curva(f_atv, l_fix.f_fix_x, l_fix.f_fix_y, f_cine_data) # nova fase de processamento f_atv.en_atv_fase = ldefs.E_FASE_DIRFIXO
def __cmd_pil_curva(self, f_atv): """ comando de pilotagem de curva """ # check input assert f_atv # obtém o comando de pilotagem atual l_cmd_pil = f_atv.lst_atv_cmd_pil[0] assert l_cmd_pil # obtém o comando operacional len_cmd_ope = l_cmd_pil.en_cmd_ope # comando ainda não está em execução ? if not l_cmd_pil.v_running: # força aeronave a abandonar qualquer procedimento abnd.abort_prc(f_atv) # obtém o primeiro parâmetro (graus) lf_param_1 = l_cmd_pil.f_param_1 # obtém o segundo parâmetro (proa) lf_param_2 = l_cmd_pil.f_param_2 # obtém o terceiro parâmetro (razão) lf_param_3 = l_cmd_pil.f_param_3 # coloca a aeronave em manual f_atv.en_trf_fnc_ope = ldefs.E_MANUAL # curva a direita ? if ldefs.E_CDIR == len_cmd_ope: # graus ? if (lf_param_1 is not None) and (lf_param_1 != 0.): # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = (360. + f_atv.f_trf_pro_atu + lf_param_1) % 360. # proa ? elif lf_param_2 is not None: # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = lf_param_2 % 360. # senão, curva indefinida... !!!REVER!!! else: # proa negativa f_atv.f_atv_pro_dem *= -1 # razão ? if (lf_param_3 is not None) and (lf_param_3 != 0.): # curva direita (razão positiva) f_atv.f_atv_raz_crv = abs(lf_param_3) else: # curva direita (razão positiva) f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) # curva a esquerda ? elif ldefs.E_CESQ == len_cmd_ope: # graus ? if (lf_param_1 is not None) and (lf_param_1 != 0.): # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = (360. + f_atv.f_trf_pro_atu - lf_param_1) % 360. # proa ? elif lf_param_2 is not None: # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = lf_param_2 % 360. # senão, curva indefinida... !!!REVER!!! else: # proa negativa f_atv.f_atv_pro_dem *= -1 # razão ? if (lf_param_3 is not None) and (lf_param_3 != 0.): # curva esquerda (razão negativa) f_atv.f_atv_raz_crv = -abs(lf_param_3) else: # curva esquerda (razão negativa) f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # curva pelo menor ângulo ? elif ldefs.E_CMNR == len_cmd_ope: # graus ? if (lf_param_1 is not None) and (lf_param_1 != 0.): # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = (360. + f_atv.f_trf_pro_atu + lf_param_1) % 360. # proa ? elif lf_param_2 is not None: # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = lf_param_2 % 360. # senão, curva indefinida... !!!REVER!!! else: # proa negativa f_atv.f_atv_pro_dem *= -1 # razão ? if (lf_param_3 is not None) and (lf_param_3 != 0.): # razão de curva f_atv.f_atv_raz_crv = abs(lf_param_3) else: # razão de curva f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) # força a curva pelo menor ângulo scrv.sentido_curva(f_atv) # proa ? elif ldefs.E_PROA == len_cmd_ope: # obtém a proa desejada (demanda) f_atv.f_atv_pro_dem = lf_param_2 # força a curva pelo menor ângulo scrv.sentido_curva(f_atv) # senão,... else: # logger l_log = logging.getLogger("CFlightEngine::__cmd_pil_curva") l_log.setLevel(logging.CRITICAL) l_log.critical( u"<E01: comando operacional ({}) não existe.".format( len_cmd_ope)) # comando em execução l_cmd_pil.v_running = True # atingiu a proa desejada ? if f_atv.f_trf_pro_atu == f_atv.f_atv_pro_dem: # aponta para o próximo comando del f_atv.lst_atv_cmd_pil[0]
def prc_dir_ponto(f_atv, ff_pto_lng, ff_pto_lat, f_cine_data): """ procedimento de direcionamento a ponto @param f_atv: ponteiro para struct aeronaves @param ff_pto_lng: longitude do ponto @param ff_pto_lat: latitude do ponto @param f_cine_data: ponteiro para pilha @return True se aeronave atingiu ponto, senão False """ # logger # M_LOG.info("prc_dir_ponto:>>") # check input assert f_atv assert f_cine_data # active flight ? if (not f_atv.v_atv_ok) or (ldefs.E_ATIVA != f_atv.en_trf_est_atv): # logger l_log = logging.getLogger("prc_dir_ponto") l_log.setLevel(logging.ERROR) l_log.error("<E01: aeronave não ativa.") # abort procedure abnd.abort_prc(f_atv) # cai fora... return None # calcula raio do cone de tolerância lf_pto_rcone = f_atv.f_trf_alt_atu * math.tan(math.radians(10)) # calcula distância da aeronave ao ponto (x, y) f_cine_data.f_dst_anv_pto_x = ff_pto_lng - f_atv.f_trf_x f_cine_data.f_dst_anv_pto_y = ff_pto_lat - f_atv.f_trf_y # calcula distância euclidiana da aeronave ao ponto (linha reta) lf_dst_anv_pto = math.sqrt((f_cine_data.f_dst_anv_pto_x**2) + (f_cine_data.f_dst_anv_pto_y**2)) # calcula distância euclidiana do passo da aeronave (linha reta) lf_passo_anv = math.sqrt((f_cine_data.f_delta_x**2) + (f_cine_data.f_delta_y**2)) # (distância ao ponto <= raio de tolerância) ou (distância ao ponto <= passo da aeronave) ? (aeronave vai ultrapassar o ponto) if (lf_dst_anv_pto <= lf_pto_rcone) or (lf_dst_anv_pto <= lf_passo_anv): # logger # M_LOG.info(u"prc_dir_ponto:<E02: aeronave atingiu o ponto.") # sinaliza que aeronave ATINGIU o ponto return True # calcula nova proa de demanda f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(f_cine_data.f_dst_anv_pto_x, f_cine_data.f_dst_anv_pto_y) # M_LOG.debug("__ckeck_ok:f_atv_pro_dem:[{}]".format(f_atv.f_atv_pro_dem)) # em curva ? if f_atv.f_atv_pro_dem != f_atv.f_trf_pro_atu: # calcula sentido de curva pelo menor ângulo scrv.sentido_curva(f_atv) # faz o bloqueio do ponto próximo razc.calc_razao_curva(f_atv, ff_pto_lng, ff_pto_lat, f_cine_data) # logger # M_LOG.info("prc_dir_ponto:<<") # sinaliza que aeronave ainda NÂO atingiu o ponto return False
def prc_trajetoria(f_atv, f_cine_data, f_stk_context): """ @param f_atv: pointer to struct aeronave @param f_cine_data: kinematics data @param f_stk_context: pointer to stack """ # logger # M_LOG.info("prc_trajetoria:>>") # check input assert f_atv assert f_cine_data assert f_stk_context is not None # active flight ? if (not f_atv.v_atv_ok) or (ldefs.E_ATIVA != f_atv.en_trf_est_atv): # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error(u"prc_trajetoria:<E01: aeronave não ativa.") # cai fora... return # pointer to trajetória l_trj = f_atv.ptr_trf_prc # trajetória ok ? if (l_trj is None) or (not l_trj.v_prc_ok): # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error(u"<E02: trajetória inexistente. aeronave:[{}/{}].".format( f_atv.i_trf_id, f_atv.s_trf_ind)) # trajetória not found, abort procedure abnd.abort_prc(f_atv) # return return # fase de iniciação ? if ldefs.E_FASE_ZERO == f_atv.en_atv_fase: # reseta o flag altitude/velocidade para iniciar uma nova trajetória f_atv.i_atv_change_alt_vel = 0 # inicia o index de breakpoints f_cine_data.i_brk_ndx = 0 # inicia com dados do primeiro breakpoint l_brk = f_atv.ptr_atv_brk = l_trj.lst_trj_brk[0] # breakpoint ok ? if (l_brk is None) or not l_brk.v_brk_ok: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E03: trajetória/breakpoint inexistente. aeronave:[{}/{}] fase:[{}]." .format(f_atv.i_trf_id, f_atv.s_trf_ind, ldefs.DCT_FASE[f_atv.en_atv_fase])) # não encontrou o breakpoint, abort procedure abnd.abort_prc(f_atv) # return return # obtém dados do breakpoint da trajetória obrk.obtem_brk(f_atv, l_brk, f_cine_data) # fase de direção ao ponto ? elif ldefs.E_FASE_DIRPONTO == f_atv.en_atv_fase: # obter dados do breakpoint da trajetória l_brk = f_atv.ptr_atv_brk # breakpoint ok ? if (l_brk is None) or not l_brk.v_brk_ok: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E04: trajetória/breakpoint inexistente. aeronave:[{}/{}] fase:[{}]." .format(f_atv.i_trf_id, f_atv.s_trf_ind, ldefs.DCT_FASE[f_atv.en_atv_fase])) # não encontrou o breakpoint, abort procedure abnd.abort_prc(f_atv) # return return # obtém as coordenadas do ponto a ser bloqueado lf_brk_x = f_cine_data.f_coord_x_brk lf_brk_y = f_cine_data.f_coord_y_brk # M_LOG.debug("prc_trajetoria:stk.f_brk_x:[{}] stk.f_brk_y:[{}]".format(f_cine_data.f_coord_x_brk, f_cine_data.f_coord_y_brk)) '''# tratamento para vôo lateral # foi comandado na pilotagem vôo lateral ? if f_atv.f_atv_dst_vlat > 0.: lf_radial = 0. # calcula a radial if 'D' == f_atv.c_atv_dir_vlat: lf_radial = 180. else: lf_radial = 0. if lf_radial <= 90.: lf_radial = 90. - lf_radial else: lf_radial = 450. - lf_radial # converte para radianos lf_radial = math.radians(lf_radial) # calcula as coordenadas x e y relativo ao fixo lf_brk_x = f_atv.f_atv_dst_vlat * math.cos(lf_radial) lf_brk_y = f_atv.f_atv_dst_vlat * math.sin(lf_radial) # calcula a projeção do ponto a ser deslocado "nnn NM" à direita ou à esquerda lf_brk_x = lf_brk_x + l_brk.f_brk_x lf_brk_y = lf_brk_y + l_brk.f_brk_y ''' # faz o direcionamento ao breakpoint if dp.prc_dir_ponto(f_atv, lf_brk_x, lf_brk_y, f_cine_data): # ao bloquear o breakpoint, tem um procedimento associado ? if not tass.trata_associado(f_atv, l_brk, f_cine_data.i_brk_ndx, f_stk_context): # não tem procedimento associado, muda de fase f_atv.en_atv_fase = ldefs.E_FASE_BREAKPOINT # fase rumo/altitude ? elif ldefs.E_FASE_RUMOALT == f_atv.en_atv_fase: # dados do breakpoint da trajetória l_brk = f_atv.ptr_atv_brk # breakpoint ok ? if (l_brk is None) or not l_brk.v_brk_ok: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E05: trajetória/breakpoint inexistente. aeronave:[{}/{}] fase:[{}]." .format(f_atv.i_trf_id, f_atv.s_trf_ind, ldefs.DCT_FASE[f_atv.en_atv_fase])) # não encontrou o breakpoint, abort procedure abnd.abort_prc(f_atv) # return return # proa e a altitude estão estabilizadas ? if (f_atv.f_trf_pro_atu == f_atv.f_atv_pro_dem) and (f_atv.f_trf_alt_atu == f_atv.f_atv_alt_dem): # não existe procedimento associado ? if not tass.trata_associado(f_atv, f_cine_data.i_brk_ndx, f_stk_context): # muda de fase f_atv.en_atv_fase = ldefs.E_FASE_BREAKPOINT # fase de breakpoint ? elif ldefs.E_FASE_BREAKPOINT == f_atv.en_atv_fase: # é o último breakpoint da trajetoria atual ? if f_atv.ptr_atv_brk == l_trj.lst_trj_brk[-1]: # reset flag altitude/velocidade f_atv.i_atv_change_alt_vel = 0 # não tem dados na pilha ? if not tass.restaura_associado(f_atv, f_cine_data, f_stk_context): # qual a proa que a aeroanve deve seguir após bloquear o último breakpoint ? # trajetória tem proa ? if l_trj.f_trj_proa > 0.: # demanda é a proa da trajetória f_atv.f_atv_pro_dem = l_trj.f_trj_proa # otherwise, trajetória NÃO tem proa... else: # demanda é a proa atual f_atv.f_atv_pro_dem = f_atv.f_trf_pro_atu # força a curva pelo menor lado scrv.sentido_curva(f_atv) # otherwise, tem dados na pilha... else: # o procedimento restaurado NÃO é trajetória ? if ldefs.E_TRAJETORIA != f_atv.en_trf_fnc_ope: # logger # M_LOG.info(u"prc_trajetoria:<E06: procedimento restaurado NÃO é trajetória.") # return return # dados da trajetória anterior l_trj = f_atv.ptr_trf_prc # é o último ponto da trajetoria anterior ? if f_atv.ptr_atv_brk._pNext is None: # bloqueou o último ponto da trajetória anterior, força procedimento manual abnd.abort_prc(f_atv) # qual proa a aeroanve deve seguir após bloquear o último breakpoint ? # trajetória tem proa ? if l_trj.f_trj_proa > 0.: # demanda é a proa da trajetória f_atv.f_atv_pro_dem = l_trj.f_trj_proa # otherwise, trajetória NÃO tem proa... else: # demanda é a proa atual f_atv.f_atv_pro_dem = f_atv.f_trf_pro_atu # força a curva pelo menor lado scrv.sentido_curva(f_atv) # otherwise, não é o último breakpoint da trajetória anterior else: # aponta para o próximo breakpoint da trajetória l_brk = f_atv.ptr_atv_brk = f_atv.ptr_atv_brk._pNext # breakpoint ok ? if (l_brk is None) or not l_brk.v_brk_ok: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E07: trajetória anterior não é último ponto. aeronave:[{}/{}] fase:[{}]." .format(f_atv.i_trf_id, f_atv.s_trf_ind, ldefs.DCT_FASE[f_atv.en_atv_fase])) # não encontrou o breakpoint, abort procedure abnd.abort_prc(f_atv) # return return # obtém dados do breakpoint da trajetória anterior obrk.obtem_brk(f_atv, l_brk, f_cine_data) # otherwise, não é o último breakpoint else: # próximo breakpoint f_cine_data.i_brk_ndx += 1 # aponta para o próximo breakpoint l_brk = f_atv.ptr_atv_brk = l_trj.lst_trj_brk[ f_cine_data.i_brk_ndx] # breakpoint ok ? if (l_brk is None) or not l_brk.v_brk_ok: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E08: trajetória/breakpoint inexistente. aeronave:[{}/{}] fase:[{}]." .format(f_atv.i_trf_id, f_atv.s_trf_ind, ldefs.DCT_FASE[f_atv.en_atv_fase])) # não encontrou o breakpoint, abort procedure abnd.abort_prc(f_atv) # return return # obtém dados do breakpoint atual obrk.obtem_brk(f_atv, l_brk, f_cine_data) # fase de direcionamento a um fixo ? elif ldefs.E_FASE_DIRFIXO == f_atv.en_atv_fase: # reseta o flag altitude/velocidade para iniciar uma nova trajetória f_atv.i_atv_change_alt_vel = 0 # aponta para o breakpoint l_brk = f_atv.ptr_atv_brk # breakpoint ok ? if (l_brk is None) or not l_brk.v_brk_ok: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E09: trajetória/breakpoint inexistente. aeronave:[{}/{}] fase:[{}]." .format(f_atv.i_trf_id, f_atv.s_trf_ind, ldefs.DCT_FASE[f_atv.en_atv_fase])) # não encontrou o breakpoint, abort procedure abnd.abort_prc(f_atv) # return return # obtém dados do breakpoint atual obrk.obtem_brk(f_atv, l_brk, f_cine_data) # otherwise, erro na valor da fase else: # logger l_log = logging.getLogger("prc_trajetoria") l_log.setLevel(logging.ERROR) l_log.error( u"<E10: fase na trajetória não identificada. fase:[{}].".format( ldefs.DCT_FASE[f_atv.en_atv_fase]))
def prc_pouso(f_atv): """ @param f_atv: ponteiro para struct aeronaves """ # globals global M_ui_ang_teta, M_f_dst_eixo, M_f_dst_rampa, M_f_dst_anv_ptq global M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y, M_f_raio_curva # check input assert f_atv # active flight ? if (ldefs.E_ATIVA != f_atv.en_trf_est_atv) or (not f_atv.v_atv_ok): # logger l_log = logging.getLogger("prc_pouso") l_log.setLevel(logging.ERROR) l_log.error("<E01: aeronave não ativa.") # aeronave não ativa. cai fora... return # performance ok ? if (f_atv.ptr_trf_prf is None) or (not f_atv.ptr_trf_prf.v_prf_ok): # logger l_log = logging.getLogger("prc_pouso") l_log.setLevel(logging.ERROR) l_log.error(u"<E02: performance não existe.") # performance não existe. cai fora... return # posição da aeronave (dir/esq) em relação ao eixo da pista len_pos_anv = 0 # pointer to aerodrome l_aer = f_atv.ptr_atv_aer if (l_aer is None) or (not l_aer.v_aer_ok): # logger l_log = logging.getLogger("prc_pouso") l_log.setLevel(logging.ERROR) l_log.error(u"<E03: aeródromo inexistente. aeronave:[{}/{}].".format(f_atv.i_trf_id, f_atv.s_trf_ind)) # aerodrome not found, abort procedure abnd.abort_prc(f_atv) # aeródromo inexistente. cai fora... return # pointer to runway l_pst = f_atv.ptr_atv_pst if (l_pst is None) or (not l_pst.v_pst_ok): # logger l_log = logging.getLogger("prc_pouso") l_log.setLevel(logging.ERROR) l_log.error(u"<E04: pista inexistente. aeronave:[{}/{}].".format(f_atv.i_trf_id, f_atv.s_trf_ind)) # runway not found, abort procedure abnd.abort_prc(f_atv) # pista inexistente. cai fora... return # fases do procedimento de pouso # fase de preparação para o procedimento ? if ldefs.E_FASE_ZERO == f_atv.en_atv_fase: # velocidade de aproximação f_atv.f_atv_vel_dem = f_atv.ptr_trf_prf.f_prf_vel_apx # cdbg.M_DBG.debug("prc_pouso:f_atv.f_atv_vel_dem:[{}]".format(f_atv.f_atv_vel_dem)) # estabiliza a altitude f_atv.f_atv_alt_dem = f_atv.f_trf_alt_atu # cdbg.M_DBG.debug("prc_pouso:f_atv.f_atv_alt_dem:[{}]".format(f_atv.f_atv_alt_dem)) # calcula o raio de curvatura assert abs(f_atv.f_atv_raz_crv) > 0 # cdbg.M_DBG.debug("prc_pouso:f_atv.f_atv_raz_crv:[{}]".format(f_atv.f_atv_raz_crv)) M_f_raio_curva = f_atv.f_trf_vel_atu / abs(math.radians(f_atv.f_atv_raz_crv)) # cdbg.M_DBG.debug("prc_pouso:M_f_raio_curva:[{}]".format(M_f_raio_curva)) # calcula o ponto de toque M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x # cdbg.M_DBG.debug("prc_pouso:M_f_dst_anv_ptq_x:[{}]".format(M_f_dst_anv_ptq_x)) M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # cdbg.M_DBG.debug("prc_pouso:M_f_dst_anv_ptq_y:[{}]".format(M_f_dst_anv_ptq_y)) # posição da aeronave em relação a pista (dir/esq) # i_pst_rumo (mlabru) len_pos_anv = scrv.sent_crv(l_pst.f_pst_true, cpd.calc_proa_demanda(-M_f_dst_anv_ptq_x, -M_f_dst_anv_ptq_y)) # cdbg.M_DBG.debug("prc_pouso:len_pos_anv:[{}]".format(len_pos_anv)) # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # cdbg.M_DBG.debug("prc_pouso:M_ui_ang_teta:[{}]".format(M_ui_ang_teta)) # calcula distância da aeronave ao ponto (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) # cdbg.M_DBG.debug("prc_pouso:M_f_dst_anv_ptq:[{}]".format(M_f_dst_anv_ptq)) # calcula distância do eixo da pista M_f_dst_eixo = abs(M_f_dst_anv_ptq * math.sin(math.radians(M_ui_ang_teta))) # cdbg.M_DBG.debug("prc_pouso:M_f_dst_eixo:[{}]".format(M_f_dst_eixo)) # calcula distância da rampa assert abs(math.tan(math.radians(ldefs.D_DST_RAMPA))) > 0 M_f_dst_rampa = (f_atv.f_trf_alt_atu - l_aer.f_aer_elev) / math.tan(math.radians(ldefs.D_DST_RAMPA)) # cdbg.M_DBG.debug("prc_pouso:M_f_dst_rampa:[{}]".format(M_f_dst_rampa)) # aeronave afastada mais de 2R do eixo da pista ? if M_f_dst_eixo >= (2 * M_f_raio_curva): # aeronave pelo menos (3R + distância na rampa) antes da cabeceira ? if (M_ui_ang_teta < 90.) and (abs(M_f_dst_anv_ptq * math.cos(math.radians(M_ui_ang_teta))) >= ((3 * M_f_raio_curva) + M_f_dst_rampa)): # aeronave a direita da pista ? if ldefs.E_DIREITA == len_pos_anv: # aeronave a direita da pista # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true - 90. if f_atv.f_atv_pro_dem < 0: f_atv.f_atv_pro_dem += 360. # otherwise,... else: # aeronave a esquerda da pista # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true + 90. if f_atv.f_atv_pro_dem >= 360.: f_atv.f_atv_pro_dem -= 360. # calcula sentido de curva pelo menor ângulo scrv.sentido_curva(f_atv) # voa para interceptar eixo da pista f_atv.en_atv_fase = ldefs.E_FASE_EIXO # otherwise,... else: # aeronave após a distância que garante condição de alinhamento # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true + 180. if f_atv.f_atv_pro_dem >= 360.: f_atv.f_atv_pro_dem -= 360. # aeronave a direita da pista ? if ldefs.E_DIREITA == len_pos_anv: # aeronave a direita da pista f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) # otherwise,... else: # aeronave a esquerda da pista f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # define nova fase f_atv.en_atv_fase = ldefs.E_FASE_OPOSTA # otherwise,... else: # aeronave está no eixo da pista ? if abs(M_f_dst_eixo) <= 0.01: # aeronave está no rumo da pista ? # i_pst_rumo (mlabru) if abs(f_atv.f_trf_pro_atu - l_pst.f_pst_true) <= 0.01: # aeronave antes da rampa ? if (M_ui_ang_teta < 90.) and (abs(M_f_dst_anv_ptq * math.cos(math.radians(M_ui_ang_teta))) >= M_f_dst_rampa): # voar até iniciar rampa f_atv.en_atv_fase = ldefs.E_FASE_ALINHAR # otherwise,... else: # aeronave após a rampa # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true - 90. if f_atv.f_atv_pro_dem < 0: f_atv.f_atv_pro_dem += 360. # ajusta razão de curva para esquerda f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # voar até se afastar 2R do eixo f_atv.en_atv_fase = ldefs.E_FASE_AFASTA # otherwise, proas diferentes else: # proa da aeronave oposta a da pista ? # i_pst_rumo (mlabru) if (abs(l_pst.f_pst_true - f_atv.f_trf_pro_atu) - 180.) <= 0.01: # aeronave após a rampa # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true + 90. if f_atv.f_atv_pro_dem >= 360.: f_atv.f_atv_pro_dem -= 360. # ajusta razão de curva para esquerda f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # voar até se afastar 2R do eixo f_atv.en_atv_fase = ldefs.E_FASE_AFASTA # otherwise, distância do eixo menor 2R else: # aeronave a direita da pista ? if ldefs.E_DIREITA == len_pos_anv: # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true + 90. if f_atv.f_atv_pro_dem >= 360.: f_atv.f_atv_pro_dem -= 360. # otherwise, aeronave a esquerda da pista else: # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true - 90. if f_atv.f_atv_pro_dem < 0: f_atv.f_atv_pro_dem += 360. # força a curva pelo menor lado scrv.sentido_curva(f_atv) # voar até se afastar 2R do eixo f_atv.en_atv_fase = ldefs.E_FASE_AFASTA # fase voando até se afastar 2R do eixo da pista ? elif ldefs.E_FASE_AFASTA == f_atv.en_atv_fase: # calcula o raio de curvatura assert abs(f_atv.f_atv_raz_crv) > 0 M_f_raio_curva = f_atv.f_trf_vel_atu / abs(math.radians(f_atv.f_atv_raz_crv)) # calcula o ponto de toque M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # calcula a distância ao ponto de toque (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) # calcula a distância ao eixo M_f_dst_eixo = abs(M_f_dst_anv_ptq * math.sin(math.radians(M_ui_ang_teta))) # aeronave distante pelo menos 2R do eixo da pista ? if M_f_dst_eixo >= (2 * M_f_raio_curva): # volta a fase inicial f_atv.en_atv_fase = ldefs.E_FASE_ZERO # fase voar na proa oposta para poder retornar a pista ? elif ldefs.E_FASE_OPOSTA == f_atv.en_atv_fase: # calcula o raio de curvatura assert abs(f_atv.f_atv_raz_crv) > 0. M_f_raio_curva = f_atv.f_trf_vel_atu / abs(math.radians(f_atv.f_atv_raz_crv)) # calcula o ponto de toque M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # posição da aeronave em relação a pista (direita/esquerda) # i_pst_rumo (mlabru) len_pos_anv = scrv.sent_crv(l_pst.f_pst_true, cpd.calc_proa_demanda(-M_f_dst_anv_ptq_x, -M_f_dst_anv_ptq_y)) # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # distância ao ponto de toque (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) # distância ao eixo da pista M_f_dst_eixo = abs(M_f_dst_anv_ptq * math.sin(math.radians(M_ui_ang_teta))) # distância a rampa assert abs(math.tan(math.radians(ldefs.D_DST_RAMPA))) > 0. M_f_dst_rampa = (f_atv.f_trf_alt_atu - l_aer.f_aer_elev) / math.tan(math.radians(ldefs.D_DST_RAMPA)) # aeronave a 2R do eixo e mais de (M_f_raio_curva + DistRampa) da cabeceira ? if (M_ui_ang_teta < 90.) and ((abs(M_f_dst_anv_ptq) * math.cos(math.radians(M_ui_ang_teta))) >= (M_f_raio_curva + M_f_dst_rampa)): # aeronave a direita da pista ? if ldefs.E_DIREITA == len_pos_anv: # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true - 90. if f_atv.f_atv_pro_dem < 0: f_atv.f_atv_pro_dem += 360. # otherwise, aeronave a esquerda da pista else: # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true + 90. if f_atv.f_atv_pro_dem >= 360.: f_atv.f_atv_pro_dem -= 360. # força a curva pelo menor lado scrv.sentido_curva(f_atv) # voar para interceptar eixo da pista f_atv.en_atv_fase = ldefs.E_FASE_EIXO # fase voando para interceptar eixo da pista ? elif ldefs.E_FASE_EIXO == f_atv.en_atv_fase: # proas iguais ? if abs(f_atv.f_trf_pro_atu - f_atv.f_atv_pro_dem) <= 0.01: # calcula o raio de curvatura assert abs(f_atv.f_atv_raz_crv) > 0 M_f_raio_curva = f_atv.f_trf_vel_atu / abs(math.radians(f_atv.f_atv_raz_crv)) # calcula a distância ao ponto de toque (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # calcula a distância ao ponto de toque (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) # distância da aeronave ao eixo M_f_dst_eixo = abs(M_f_dst_anv_ptq * math.sin(math.radians(M_ui_ang_teta))) # distância da aeronave ao eixo da pista > raio de curvatura ? if M_f_dst_eixo <= M_f_raio_curva: # curva em direção ao rumo da pista # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true # força a curva pelo menor lado scrv.sentido_curva(f_atv) # curva para buscar alinhamento com eixo da pista f_atv.en_atv_fase = ldefs.E_FASE_CURVA # fase curvando para buscar alinhamento inicial com eixo da pista ? elif ldefs.E_FASE_CURVA == f_atv.en_atv_fase: # aeronave alinhada com a pista ? if abs(f_atv.f_trf_pro_atu - f_atv.f_atv_pro_dem) <= 0.01: # calcula a distância ao ponto de toque (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # calcula proa de demanda f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y) # força a curva pelo menor lado scrv.sentido_curva(f_atv) # aeronave mantendo o alinhamento com a pista f_atv.en_atv_fase = ldefs.E_FASE_ALINHAR # fase aeronave mantendo o alinhamento com a pista ? elif ldefs.E_FASE_ALINHAR == f_atv.en_atv_fase: # calcula a distância ao ponto de toque (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # calcula a distância ao ponto de toque (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) if M_ui_ang_teta < 90.: # aeronave antes da cabeceira (considerando dt = 1s) M_f_alt_rampa = M_f_dst_anv_ptq * math.tan(math.radians(ldefs.D_DST_RAMPA)) if ((f_atv.f_trf_alt_atu - l_aer.f_aer_elev) >= M_f_alt_rampa - abs(f_atv.ptr_trf_prf.f_prf_raz_des_apx)) and \ ((f_atv.f_trf_alt_atu - l_aer.f_aer_elev) < M_f_alt_rampa + abs(f_atv.ptr_trf_prf.f_prf_raz_des_apx)): # início da rampa de descida assert abs(M_f_dst_anv_ptq) > 0 # calcula a razão de descida f_atv.f_atv_raz_sub = ((f_atv.f_trf_alt_atu - l_aer.f_aer_elev) * f_atv.f_atv_vel_gnd) / M_f_dst_anv_ptq # altitude de demanda é a elevação do aeródromo f_atv.f_atv_alt_dem = l_aer.f_aer_elev # voa aeronave na rampa f_atv.en_atv_fase = ldefs.E_FASE_RAMPA # aeronave procurando novo alinhamento ? if f_atv.f_trf_pro_atu != f_atv.f_atv_pro_dem: # aeronave procurando novo alinhamento f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y) # força a curva pelo menor lado scrv.sentido_curva(f_atv) # otherwise, teta >= 90. else: # aeronave após a cabeceira # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true + 180. if f_atv.f_atv_pro_dem >= 360.: f_atv.f_atv_pro_dem -= 360. # inicia a razão de curva f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # voa até se afastar 2R do eixo da pista f_atv.en_atv_fase = ldefs.E_FASE_AFASTA # fase aeronave mantendo o alinhamento na aproximação com a pista ? elif ldefs.E_FASE_APXALINHAR == f_atv.en_atv_fase: # calcula o ponto de toque (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # calcula o ponto de toque (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) # aeronave antes da cabeceira (considerando dt = 1s) if M_ui_ang_teta < 90.: # início da rampa de descida assert abs(M_f_dst_anv_ptq) > 0 # calcula a razão de descida f_atv.f_atv_raz_sub = (f_atv.f_trf_alt_atu * f_atv.f_atv_vel_gnd) / M_f_dst_anv_ptq # altitude de demanda é a elevação do aeródromo f_atv.f_atv_alt_dem = l_aer.f_aer_elev # voa aeronave na rampa f_atv.en_atv_fase = ldefs.E_FASE_RAMPA # aeronave procurando novo alinhamento ? if f_atv.f_trf_pro_atu != f_atv.f_atv_pro_dem: # aeronave procurando novo alinhamento f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y) # força a curva pelo menor lado scrv.sentido_curva(f_atv) # fase aeronave na rampa ? elif ldefs.E_FASE_RAMPA == f_atv.en_atv_fase: # inicia a aceleração f_atv.f_atv_acel = 0. # calcula o ponto de toque (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_y - f_atv.f_trf_y # calcula ângulo formado pela aeronave e a pista (teta) # i_pst_rumo (mlabru) M_ui_ang_teta = abs(l_pst.f_pst_true - cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y)) if M_ui_ang_teta > 180.: M_ui_ang_teta = 360. - M_ui_ang_teta # # calcula o ponto de toque (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) # verifica a cabeceira oposta if M_ui_ang_teta >= 90.: # aeronave após cabeceira M_f_dst_anv_ptq_x = l_pst.f_pst_cab_opos_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_cab_opos_y - f_atv.f_trf_y # aeronave procurando novo alinhamento ? if f_atv.f_trf_pro_atu != f_atv.f_atv_pro_dem: # aeronave procurando novo alinhamento f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y) # força a curva pelo menor lado scrv.sentido_curva(f_atv) # aeronave tocou a pista ? if abs(f_atv.f_trf_alt_atu - l_aer.f_aer_elev) <= 0.01: # calcula a distância ao fim da pista (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_cab_opos_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_cab_opos_y - f_atv.f_trf_y # inicia a proa de demanda f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y) # força a curva pelo menor lado scrv.sentido_curva(f_atv) # ajusta a velocidade para pouso f_atv.f_atv_vel_dem = 0. # desaceleração no pouso f_atv.f_atv_acel = 2 * abs(f_atv.ptr_trf_prf.f_prf_raz_max_var_vel) # prepara a aeronave para parada na pista f_atv.en_atv_fase = ldefs.E_FASE_PISTA # fase aeronave pára na pista ? elif ldefs.E_FASE_PISTA == f_atv.en_atv_fase: # calcula a distância da aeronave a cabeceira oposta (componentes x e y) M_f_dst_anv_ptq_x = l_pst.f_pst_cab_opos_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_cab_opos_y - f_atv.f_trf_y # calcula a distância da aeronave a cabeceira oposta (em linha reta) M_f_dst_anv_ptq = math.sqrt((M_f_dst_anv_ptq_x ** 2) + (M_f_dst_anv_ptq_y ** 2)) assert abs(f_atv.f_atv_acel) > 0 # espaço de pista menor que o necessário para frear a aeronave ? if M_f_dst_anv_ptq < (f_atv.f_trf_vel_atu ** 2) / (2 * f_atv.f_atv_acel): # aumenta a frenagem f_atv.f_atv_acel = 4 * abs(f_atv.ptr_trf_prf.f_prf_raz_max_var_vel) # aeronave procurando novo alinhamento ? if f_atv.f_trf_pro_atu != f_atv.f_atv_pro_dem: # chegou ao fim da pista ? if (abs(l_pst.f_pst_cab_opos_x - f_atv.f_trf_x) <= abs(M_f_dst_anv_ptq_x)) and \ (abs(l_pst.f_pst_cab_opos_y - f_atv.f_trf_y) <= abs(M_f_dst_anv_ptq_y)): # ajusta demanda ao rumo da pista # i_pst_rumo (mlabru) f_atv.f_atv_pro_dem = l_pst.f_pst_true # otherwise,... else: # calcula distância ao fim da pista M_f_dst_anv_ptq_x = l_pst.f_pst_cab_opos_x - f_atv.f_trf_x M_f_dst_anv_ptq_y = l_pst.f_pst_cab_opos_y - f_atv.f_trf_y # calcula nova proa de demanda f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(M_f_dst_anv_ptq_x, M_f_dst_anv_ptq_y) # força a curva pelo menor lado scrv.sentido_curva(f_atv) # aeronave parou ? if 0. == f_atv.f_trf_vel_atu: # ajusta os dados da aeronave no solo # f_atv.v_atv_visu = False # f_atv.v_atv_movi = False f_atv.en_trf_fnc_ope = ldefs.E_MANUAL f_atv.en_atv_est_atv = ldefs.E_CANCELADA # otherwise, erro no valor da fase else: # logger l_log = logging.getLogger("prc_pouso") l_log.setLevel(logging.ERROR) l_log.error(u"<E05: fase no pouso não identificada:[{}].".format(ldefs.DCT_FASE[f_atv.en_atv_fase]))
def prc_espera(f_atv, f_cine_data, f_stk_context, ff_delta_t): """ DOCUMENT ME! @param f_atv: pointer para struct aeronaves @param f_cine_data: dados da cinemática @param f_stk_context: pointer para pilha @param ff_delta_t: tempo decorrido desde a última atualização """ # check input assert f_atv assert f_cine_data assert f_stk_context is not None # aeronave ativa ? if (not f_atv.v_atv_ok) or (ldefs.E_ATIVA != f_atv.en_trf_est_atv): # logger l_log = logging.getLogger("prc_espera") l_log.setLevel(logging.ERROR) l_log.error(u"<E01: aeronave não ativa.") # aeronave não ativa. cai fora... return # performance existe ? if (f_atv.ptr_trf_prf is None) or (not f_atv.ptr_trf_prf.v_prf_ok): # logger l_log = logging.getLogger("prc_espera") l_log.setLevel(logging.ERROR) l_log.error(u"<E02: performance não existe.") # performance não existe. cai fora... return # aponta para a espera planejada e valida pointer l_esp = f_atv.ptr_trf_prc if (l_esp is None) or (not l_esp.v_prc_ok): # logger l_log = logging.getLogger("prc_espera::prc_espera") l_log.setLevel(logging.ERROR) l_log.error("<E03: espera inexistente. aeronave:[%d/%s]", f_atv.i_trf_id, f_atv.s_trf_ind) # não encontrou a espera, força a aeronave abandonar o procedimento abnd.abort_prc(f_atv) # espera inexistente. cai fora... return # aeronave abaixo de 14000ft ? if (f_atv.f_trf_alt_atu <= M_14000FT) and (f_atv.f_trf_vel_atu > M_VEL_MAX): # velocidade máxima é de 230KT f_atv.f_atv_vel_dem = M_VEL_MAX # preparação de dados ? if ldefs.E_FASE_ZERO == f_atv.en_atv_fase: # obtém dados do fixo de espera e valida pointer l_fix = l_esp.ptr_esp_fix if (l_fix is None) or (not l_fix.v_fix_ok): # logger l_log = logging.getLogger("prc_espera::prc_espera") l_log.setLevel(logging.ERROR) l_log.error("<E04: fixo da espera inexistente. aeronave:[%d/%s]", f_atv.i_trf_id, f_atv.s_trf_ind) # não encontrou o fixo, força a aeronave abandonar o procedimento abnd.abort_prc(f_atv) # fixo da espera inexistente. cai fora... return # checa condição de cancelamento, caso tenha sido comandado pelo piloto if __check_cancel_espera(f_atv, l_esp): # break return # direciona ao fixo de espera !!!REVER!!! if dp.prc_dir_ponto(f_atv, l_fix.f_fix_x, l_fix.f_fix_y, f_cine_data): # determina qual o setor de entrada na espera f_atv.en_atv_fase = __setor_entrada(f_atv, l_esp) # valida proa para perna de afastamento # f_esp_rumo (mlabru) f_cine_data.f_afasta = l_esp.f_esp_true - 180. # normaliza proa para perna de afastamento if f_cine_data.f_afasta < 0.: f_cine_data.f_afasta += 360. # limita a razão de subida/descida na espera em no máximo 1000FT/MIN !!!REVER!!! if f_atv.f_atv_raz_sub > M_RAZ_SUB: # salva a razão atual f_cine_data.f_raz_sub_des = f_atv.f_atv_raz_sub # limita a razão f_atv.f_atv_raz_sub = M_RAZ_SUB # seguir na perna de aproximação em direção oposta (perna de afastamento) elif ldefs.E_FASE_SETOR1 == f_atv.en_atv_fase: # ajusta a razão de curva em relação ao sentido da espera if ldefs.E_DIREITA == l_esp.en_esp_sentido_curva: # curva pela direita (positivo) f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # senão,... else: # curva pela esquerda (negativo) f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) # inicia dados da espera na pilha f_cine_data.i_setor_ent = 1 f_cine_data.i_bloqueio_fixo = 1 # seguir numa paralela no sentido "oposto" da perna de aproximação f_atv.f_atv_pro_dem = f_cine_data.f_afasta # obtém o tempo limite na perna de aproximação considerando o limite de 14000FT f_cine_data.h_tempo = 90. if (f_atv.f_trf_alt_atu > M_14000FT) else 50. # sinaliza nova fase f_atv.en_atv_fase = ldefs.E_FASE_TEMPO # seguir no rumo perna de afastamento defasado de 30 graus elif ldefs.E_FASE_SETOR2 == f_atv.en_atv_fase: # curva pela direita ? if ldefs.E_DIREITA == l_esp.en_esp_sentido_curva: # calcula a nova proa de demanda f_atv.f_atv_pro_dem = f_cine_data.f_afasta - 30. # normaliza if f_atv.f_atv_pro_dem < 0.: f_atv.f_atv_pro_dem += 360. # senão, curva pela esquerda else: # calcula a nova proa de demanda f_atv.f_atv_pro_dem = f_cine_data.f_afasta + 30. # normaliza if f_atv.f_atv_pro_dem > 360.: f_atv.f_atv_pro_dem -= 360. # razão de curva pelo menor lado scrv.sentido_curva(f_atv) # tempo na defasagem (1 minuto e meio no limite de 14000FT) f_cine_data.h_tempo = 90. if (f_atv.f_trf_alt_atu > M_14000FT) else 60. # sinaliza nova fase f_atv.en_atv_fase = ldefs.E_FASE_TEMPOSETOR # entrada pelo setor 3 elif ldefs.E_FASE_SETOR3 == f_atv.en_atv_fase: # entrada pelo setor 3 f_atv.f_atv_pro_dem = f_cine_data.f_afasta # entra na órbita f_atv.en_atv_fase = ldefs.E_FASE_CRVAFASTA # curva pela esquerda ? if ldefs.E_ESQUERDA == l_esp.en_esp_sentido_curva: # curva pela esquerda (negativa) f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # senão, curva pela direita else: # curva pela direita (positiva) f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) # permanência na perna de aproximação elif ldefs.E_FASE_TEMPO == f_atv.en_atv_fase: # permanece na perna de aproximação ? if f_cine_data.h_tempo > 0.: # decrementa o tempo na perna f_cine_data.h_tempo -= ff_delta_t # senão, estorou o tempo else: # nova fase f_atv.en_atv_fase = ldefs.E_FASE_VOLTA # permanência nos 30 graus do rumo para o setor 2 elif ldefs.E_FASE_TEMPOSETOR == f_atv.en_atv_fase: # permanece nos 30 graus ? if f_cine_data.h_tempo > 0.: # decrementa o tempo na perna f_cine_data.h_tempo -= ff_delta_t # senão, estorou o tempo else: # nova fase f_atv.en_atv_fase = ldefs.E_FASE_VOLTA # fase volta ? elif ldefs.E_FASE_VOLTA == f_atv.en_atv_fase: # acessa dados do fixo de espera e valida parâmetro l_fix = l_esp.ptr_esp_fix if (l_fix is None) or not l_fix.v_fix_ok: # logger l_log = logging.getLogger("prc_espera::prc_espera") l_log.setLevel(logging.ERROR) l_log.error("<E05: fixo da espera inexistente. aeronave: [%d/%s]", f_atv.i_trf_id, f_atv.s_trf_ind) # não encontrou o fixo, força a aeronave abandonar o procedimento abnd.abort_prc(f_atv) # fixo da espera inexistente. caifora... return # calcula distância da aeronave ao ponto (x, y) lf_coord_x = l_fix.f_fix_x - f_atv.f_trf_x lf_coord_y = l_fix.f_fix_y - f_atv.f_trf_y # calcula distância linear da aeronave ao ponto lf_dst_anv_pto = math.sqrt((lf_coord_x**2) + (lf_coord_y**2)) # calcula nova proa de demanda f_atv.f_atv_pro_dem = cpd.calc_proa_demanda(lf_coord_x, lf_coord_y) # calcula novo sentido de curva scrv.sentido_curva(f_atv) # aeronave atingiu o fixo de espera ? (distância ao ponto <= passo da aeronave) if lf_dst_anv_pto <= math.sqrt((f_cine_data.f_delta_x**2) + (f_cine_data.f_delta_y**2)): # checa condição de cancelamento e ajusta a razão if __check_cancel_espera(f_atv, l_esp): # ajusta a razão de subida/descida f_atv.f_atv_raz_sub = f_atv.f_prf_raz_des_crz # break return # função operacional anterior era aproximação ? if ldefs.E_APROXIMACAO == f_atv.en_trf_fnc_ope_ant: # aeronave chegou na altitude do fixo de espera ? if f_atv.f_trf_alt_atu == f_atv.f_atv_alt_dem: # existe algo na pilha ? if len(f_stk_context) > 0: # desempilha o contexto f_atv.en_trf_fnc_ope, f_atv.en_atv_fase, f_atv.ptr_trf_prc, f_atv.ptr_atv_brk, f_cine_data.i_brk_ndx = f_stk_context.pop( ) # velocidade e proa f_atv.f_atv_vel_dem = f_atv.ptr_trf_prf.f_prf_vel_apx # f_esp_rumo (mlabru) f_atv.f_atv_pro_dem = l_esp.f_esp_true # calcula novo sentido de curva scrv.sentido_curva(f_atv) # razão de subida f_atv.f_atv_raz_sub = f_cine_data.f_raz_sub_des # break return # aprumar no rumo da espera (sentido afastamento) f_atv.f_atv_pro_dem = f_cine_data.f_afasta # entrar na órbita f_atv.en_atv_fase = ldefs.E_FASE_CRVAFASTA f_cine_data.i_setor_ent = 0 f_cine_data.i_bloqueio_fixo = 0 # espera a direita ? if ldefs.E_DIREITA == l_esp.en_esp_sentido_curva: if (1 == f_cine_data.i_setor_ent) and ( 1 == f_cine_data.i_bloqueio_fixo): # ajusta a razão de curva f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) else: # ajusta a razão de curva f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) # senão, espera a esquerda else: if (1 == f_cine_data.i_setor_ent) and ( 1 == f_cine_data.i_bloqueio_fixo): # ajusta a razão de curva f_atv.f_atv_raz_crv = abs(f_atv.f_atv_raz_crv) else: # ajusta a razão de curva f_atv.f_atv_raz_crv = -abs(f_atv.f_atv_raz_crv) # fase curva de afastamento ? elif ldefs.E_FASE_CRVAFASTA == f_atv.en_atv_fase: # já aprumou ? if f_atv.f_trf_pro_atu == f_atv.f_atv_pro_dem: # obtém o tempo (limite de 14000FT) f_cine_data.h_tempo = 90. if ( f_atv.f_trf_alt_atu > M_14000FT) else 50. # sinaliza nova fase f_atv.en_atv_fase = ldefs.E_FASE_TEMPO # senão,... else: # logger l_log = logging.getLogger("prc_espera::prc_espera") l_log.setLevel(logging.ERROR) l_log.error("<E06: fase [{}/{}] da espera não identificada.".format( f_atv.en_atv_fase, ldefs.DCT_FASE[f_atv.en_atv_fase]))