def prc_aproximacao(f_atv, f_cine_data, f_stk_context):
"""
realiza o procedimento de aproximação
@param f_atv: pointer to aeronave
@param f_cine_data: dados da cinemática
@param f_stk_context: pointer to stack
"""
# check input
assert f_atv
# 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_aproximacao")
l_log.setLevel(logging.ERROR)
l_log.error(u"<E01: aeronave não ativa.")
# abort procedure
abnd.abort_prc(f_atv)
# 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_aproximacao")
l_log.setLevel(logging.ERROR)
l_log.error(u"<E02: performance não existe.")
# abort procedure
abnd.abort_prc(f_atv)
# cai fora...
return
# pointer to aproximação
l_apx = f_atv.ptr_trf_prc
# aproximação ok ?
if (l_apx is None) or (not l_apx.v_prc_ok):
# logger
l_log = logging.getLogger("prc_aproximacao")
l_log.setLevel(logging.ERROR)
l_log.error(u"<E03: aproximação inexistente. aeronave:[{}/{}].".format(
f_atv.i_trf_id, f_atv.s_trf_ind))
# abort procedure
abnd.abort_prc(f_atv)
# return
return
# variáveis locais
l_brk = None
# fase de preparação dos dados para o procedimento ?
if ldefs.E_FASE_ZERO == f_atv.en_atv_fase:
# 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_apx.lst_apx_brk[0]
# breakpoint ok ?
if (l_brk is None) or (not l_brk.v_brk_ok):
# logger
l_log = logging.getLogger("prc_aproximacao")
l_log.setLevel(logging.ERROR)
l_log.error(
u"<E04: fase zero. apx/breakpoint inexistente. aeronave:[{}/{}]."
.format(f_atv.i_trf_id, f_atv.s_trf_ind))
# abort procedure
abnd.abort_prc(f_atv)
# return
return
# obtém dados do breakpoint
obrk.obtem_brk(f_atv, l_brk, f_cine_data)
# fase de direcionamento aos breakpoints do procedimento ?
elif ldefs.E_FASE_DIRPONTO == f_atv.en_atv_fase:
# interceptou o breakpoint ?
if dp.prc_dir_ponto(f_atv, f_cine_data.f_coord_x_brk,
f_cine_data.f_coord_y_brk, f_cine_data):
# se não houver um procedimento associado, faz uma espera, senão executa o procedimento
f_atv.en_atv_fase = ldefs.E_FASE_ESPERA if f_atv.ptr_atv_brk is not None else ldefs.E_FASE_ASSOCIADO
# fase rumo e altitude ?
elif ldefs.E_FASE_RUMOALT == f_atv.en_atv_fase:
# atingiu a proa e a altitude de demanda estabelecidas ?
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):
# se não houver um procedimento associado, faz uma espera, senão executa o procedimento
f_atv.en_atv_fase = ldefs.E_FASE_ESPERA if f_atv.ptr_atv_brk is not None else ldefs.E_FASE_ASSOCIADO
# fase de espera ? (mantém a aeronave em orbita até alcançar a altitude do breakpoint)
elif ldefs.E_FASE_ESPERA == f_atv.en_atv_fase:
# dados do breakpoint
l_brk = f_atv.ptr_atv_brk
assert l_brk
# NÃO atingiu a altitude do breakpoint ?
if f_atv.f_trf_alt_atu != l_brk.f_brk_alt:
# obtém dados do breakpoint (Espera com altitude de demanda)
obrk.obtem_brk(f_atv, l_brk, f_cine_data)
# empilha o contexto atual devido a mudança na função operacional
f_stk_context.append(
(f_atv.en_trf_fnc_ope, ldefs.E_FASE_ASSOCIADO,
f_atv.ptr_trf_prc, f_atv.ptr_atv_brk, f_cine_data.i_brk_ndx))
# salva a função operacional atual
f_atv.en_trf_fnc_ope_ant = ldefs.E_APROXIMACAO
# estabelece a nova função operacional e a nova fase por não ter atingido a altitude do breakpoint
f_atv.en_trf_fnc_ope = ldefs.E_ESPERA
f_atv.en_atv_fase = ldefs.E_FASE_ZERO
f_atv.ptr_trf_prc = l_apx.ptr_apx_prc_esp
# otherwise, atingiu a altitude do breakpoint...
else:
# estabelece nova velocidade de demanda e sinaliza nova fase
f_atv.f_atv_vel_dem = f_atv.ptr_trf_prf.f_prf_vel_apx
f_atv.en_atv_fase = ldefs.E_FASE_ASSOCIADO
# fase associado ? (identifica se houve encadeamento de outros procedimentos)
elif ldefs.E_FASE_ASSOCIADO == f_atv.en_atv_fase:
# dados do breakpoint
l_brk = f_atv.ptr_atv_brk
assert l_brk
# sinaliza nova fase
f_atv.en_atv_fase = ldefs.E_FASE_BREAKPOINT
# existe procedimento associado (APX, APE, TRJ, ESP...) ao breakpoint ?
if tass.trata_associado(f_atv, l_brk, f_cine_data.i_brk_ndx,
f_stk_context):
# é o último breakpoint da aproximação atual ?
if f_atv.ptr_atv_brk == l_apx.lst_apx_brk[-1]:
f_cine_data.i_brk_ndx -= 1
# já passou por todos os breakpoints ?
elif ldefs.E_FASE_BREAKPOINT == f_atv.en_atv_fase:
# é o último breakpoint da aproximação atual ?
if f_atv.ptr_atv_brk == l_apx.lst_apx_brk[-1]:
# possível ILS ?
if l_apx.ptr_apx_prc_ils is not None:
# ils ok ?
if __obtem_ils(f_atv, l_apx):
# coloca em procedimento de ILS
f_atv.en_trf_fnc_ope = ldefs.E_ILS
f_atv.en_atv_fase = ldefs.E_FASE_ZERO
# otherwise, ils not ok...
else:
# coloca em manual
f_atv.en_trf_fnc_ope = ldefs.E_MANUAL
# pode fazer aproximação perdida caso não esteja em condições para aproximação ?
if l_apx.ptr_apx_prc_ape is not None:
# dados do breakpoint
l_brk = f_atv.ptr_atv_brk
assert l_brk
# está em condição de pouso ?
if (abs(f_atv.f_trf_alt_atu - l_brk.f_brk_alt) <= 0.01) and (
abs(f_atv.f_trf_vel_atu -
f_atv.ptr_trf_prf.f_prf_vel_apx) <= 0.01):
# pouso ok ?
if not __obtem_pouso(f_atv, l_apx):
# coloca em manual
f_atv.en_trf_fnc_ope = ldefs.E_MANUAL
# otherwise, NÃO está em condição de pouso...
else:
# aproximação perdida ok ?
if __obtem_apx_per(f_atv, l_apx):
# prepara para procedimento de aproximação perdida
f_atv.en_trf_fnc_ope = ldefs.E_APXPERDIDA
f_atv.en_atv_fase = ldefs.E_FASE_ZERO
# otherwise, aproximação perdida not ok...
else:
# coloca em manual
f_atv.en_trf_fnc_ope = ldefs.E_MANUAL
# otherwise, NÃO pode fazer aproximação perdida nem ILS, faz pouso forçado...
else:
# pouso ok ?
if not __obtem_pouso(f_atv, l_apx):
# coloca em manual
f_atv.en_trf_fnc_ope = ldefs.E_MANUAL
# 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_apx.lst_apx_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_aproximacao")
l_log.setLevel(logging.ERROR)
l_log.error(
u"<E05: fase breakpoint. apx/breakpoint inexistente. aeronave:[{}/{}]."
.format(f_atv.i_trf_id, f_atv.s_trf_ind))
# abort procedure
abnd.abort_prc(f_atv)
# apx/breakpoint inexistente. cai fora...
return
# obtém dados do breakpoint
obrk.obtem_brk(f_atv, l_brk, f_cine_data)
# otherwise,...
else:
# logger
l_log = logging.getLogger("prc_aproximacao")
l_log.setLevel(logging.ERROR)
l_log.error(
u"<E06: fase da aproximação não identificada. fase:[{}].".format(
ldefs.DCT_FASE[f_atv.en_atv_fase]))
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_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_cine_data.f_afasta = l_esp.f_esp_rumo - 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_atv.f_atv_pro_dem = l_esp.f_esp_rumo
# 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]))
def prc_subida(f_atv, f_cine_data, f_stk_context):
"""
realiza o procedimento de subida após o procedimento de decolagem
@param f_atv: pointer to struct aeronaves
@param f_cine_data: dados da cinemática
@param f_stk_context: pointer to stack
"""
# check input
assert f_atv
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_subida")
l_log.setLevel(logging.ERROR)
l_log.error("<E01: aeronave não ativa.")
# abort procedure
abnd.abort_prc(f_atv)
# aeronave não ativa. cai fora...
return False
# pointer to subida
l_sub = f_atv.ptr_trf_prc
# subida ok ?
if (l_sub is None) or (not l_sub.v_prc_ok):
# logger
l_log = logging.getLogger("prc_subida")
l_log.setLevel(logging.ERROR)
l_log.error("<E02: subida inexistente. aeronave:[{}/{}].".format(
f_atv.i_trf_id, f_atv.s_trf_ind))
# abort procedure
abnd.abort_prc(f_atv)
# subida inexistente. cai fora...
return
# fase de iniciação ?
if ldefs.E_FASE_ZERO == f_atv.en_atv_fase:
# inicia o contador de breakpoints
f_cine_data.i_brk_ndx = 0
# empilha o contexto futuro
f_stk_context.append(
(f_atv.en_trf_fnc_ope, ldefs.E_FASE_SUBIDA, l_sub, None, 0))
# salva a subida
f_cine_data.ptr_sub = l_sub
# obtém o aeródromo e pista da subida
f_cine_data.ptr_aer = l_sub.ptr_sub_aer
f_cine_data.ptr_pis = l_sub.ptr_sub_pis
# carrega o contexto atual
f_atv.ptr_trf_prc = l_sub.ptr_sub_prc_dec
f_atv.en_trf_fnc_ope = ldefs.E_DECOLAGEM
f_atv.en_atv_fase = ldefs.E_FASE_ZERO
# fase subida ?
elif ldefs.E_FASE_SUBIDA == f_atv.en_atv_fase:
# inicia com o número do breakpoint atual
l_brk = f_atv.ptr_atv_brk = l_sub.lst_sub_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_subida")
l_log.setLevel(logging.ERROR)
l_log.error(
"<E03: subida/breakpoint inexistente. aeronave:[{}/{}].".
format(f_atv.i_trf_id, f_atv.s_trf_ind))
# abort procedure
abnd.abort_prc(f_atv)
# subida/breakpoint inexistente. cai fora...
return
# obtém dados do breakpoint da subida
obrk.obtem_brk(f_atv, l_brk, f_cine_data)
# fase direcionamento a ponto ?
elif ldefs.E_FASE_DIRPONTO == f_atv.en_atv_fase:
# chegou ao breakpoint ?
if dp.prc_dir_ponto(f_atv, f_cine_data.f_coord_x_brk,
f_cine_data.f_coord_y_brk, f_cine_data):
# próxima fase
f_atv.en_atv_fase = ldefs.E_FASE_BREAKPOINT
# obtém o breakpoint atual
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_subida")
l_log.setLevel(logging.ERROR)
l_log.error(
"<E04: subida/breakpoint inexistente. aeronave:[{}/{}].".
format(f_atv.i_atv_id, f_atv.s_atv_ind))
# abort procedure
abnd.abort_prc(f_atv)
# subida/breakpoint inexistente. cai fora...
return
# trata o procedimento associado
tass.trata_associado(f_atv, l_brk, f_cine_data.i_brk_ndx,
f_stk_context)
# fase rumo e altitude ?
elif ldefs.E_FASE_RUMOALT == f_atv.en_atv_fase:
# altitude atual(ft) é maior que a altitude máxima da TMA(ft) ?
if (f_atv.f_atv_alt_atu * cdefs.D_CNV_M2FT) > ldefs.D_ALT_MAX_TMA:
# ajusta a velocidade de demanda em função do nível de vôo
f_atv.f_atv_vel_dem = f_atv.f_ptr_prf.f_prf_vel_crz # calcIAS(f_atv.f_ptr_prf.f_prf_vel_crz, f_atv.f_atv_alt_atu, ldefs.D_EXE_VAR_TEMP_ISA)
# proa e a altitude estão estabilizadas ?
if (f_atv.f_atv_pro_atu
== f_atv.f_atv_pro_dem) and (f_atv.f_atv_alt_atu
== f_atv.f_atv_alt_dem):
# nova fase
f_atv.en_atv_fase = ldefs.E_FASE_BREAKPOINT
# trata o procedimento associado
tass.trata_associado(f_atv, l_brk, f_cine_data.i_brk_ndx,
f_stk_context)
# fase breakpoints ?
elif ldefs.E_FASE_BREAKPOINT == f_atv.en_atv_fase:
# é o último breakpoint da subida ?
if f_atv.ptr_atv_brk == l_sub.lst_sub_brk[-1]:
# reseta o flag altitude/velocidade
f_atv.i_atv_change_alt_vel = 0
# restaura pilha, se necessário
tass.restaura_associado(f_atv, f_cine_data, f_stk_context)
# otherwise, NÃO é o último breakpoint da subida...
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_sub.lst_sub_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_subida")
l_log.setLevel(logging.ERROR)
l_log.error(
"<E05: subida/breakpoint inexistente. aeronave:[{}/{}].".
format(f_atv.i_atv_id, f_atv.s_atv_ind))
# abort procedure
abnd.abort_prc(f_atv)
# subida/breakpoint inexistente. cai fora...
return
# obtém dados do breakpoint atual
obrk.obtem_brk(f_atv, l_brk, f_cine_data)
# otherwise, fase não identificada
else:
# logger
l_log = logging.getLogger("prc_subida")
l_log.setLevel(logging.ERROR)
l_log.error("<E06: fase na subida não identificada.")
# abort procedure
abnd.abort_prc(f_atv)