Parte A: Módulo ppp.c

Funcionalidade e Fluxo Principal

Implementa o algoritmo PPP (Posicionamento de Ponto Preciso) usando observações de fase e pesudodistância GNSS. O processo principal inclui:

1. Atualização temporal dos estados
2. Construção das equações de observação
3. Atualização do filtro de Kalman
4. Resolução de ambiguidade de fase

Funções Principais

void calcular_posicao_ppp(estado_rtk *solucao, const dado_obs *observacoes, 
                         int total_obs, const navegacao *dados_nav)
{
  // Inicializa vetor de estados
  // Calcula posições e correções de relógio satelital
  // Filtra satélites em eclipse
  // Executa iterações de ajuste
}

int calcular_residuos(int iteracao, const dado_obs *observacoes, int total_obs,
                     const double *pos_satelite, const double *correcao_tempo,
                     const double *variancia_erro, const int *status_svh,
                     const navegacao *dados_nav, const double *estados,
                     estado_rtk *solucao, double *residuos,
                     double *matriz_projeto, double *covariancia)
{
  // Modelo geométrico: dist = √(Δx² + Δy² + Δz²)
  // Equação de fase: ϕ = λN + dist + c(δt_rec - δt_sat) + T + I + ε
}

Modelos de Correção

void correcao_mare_solida(const double *pos_sol, const double *pos_lua,
                         const double *pos_receptor, const double *mat_rot,
                         double tempo_sideral, int opcoes, double *deslocamento)
{
  // Modelo de marés sólidas:
  // u = K₂[H₂(1.5cos²θ - 0.5) - 3L₂a²] + K₃[H₃(...)]
}

double modelo_tropo_preciso(epoch_t tempo, const double *posicao,
                           const double *azimute_elevacao,
                           const opcoes_processamento *config,
                           const double *estados, double *gradiente,
                           double *incerteza)
{
  // T = m_h(θ)ZHD + m_w(θ)(ZWD + G_n cotθ cosα + G_e cotθ sinα)
}

Princípios Matemáticos

Atualização do Filtro de Kalman:

1. Predição: x̂ₖ|ₖ₋₁ = Φₖ₋₁xₖ₋₁ Pₖ|ₖ₋₁ = Φₖ₋₁Pₖ₋₁Φₖ₋₁ᵀ + Qₖ₋₁
2. Correção: Kₖ = Pₖ|ₖ₋₁Hₖᵀ(HₖPₖ|ₖ₋₁Hₖᵀ + Rₖ)⁻¹ x̂ₖ = x̂ₖ|ₖ₋₁ + Kₖ(zₖ - Hₖx̂ₖ|ₖ₋₁) Pₖ = (I - KₖHₖ)Pₖ|ₖ₋₁

Modelo Saastamoinen:
ZHD = 0.002277 × P / (1 - 0.00266 × cos(2φ) - 0.00028 × H)

Parte B: Módulo ppp_ar.c

Resolução de Ambiguidade

Processo de fixação de ambiguidadse inteiras:

1. Pré-processamento de combinações lineares
2. Fixagem de ambiguidades de banda larga
3. Fixagem de ambiguidades de banda estreita
4. Atualização de estados

Funções-Chave

double comprimento_onda_comb(int coef_i, int coef_j, int coef_k)
{
  return VELOCIDADE_LUZ / (coef_i * FREQ_L1 + 
                          coef_j * FREQ_L2 + 
                          coef_k * FREQ_L5);
}

double avaliar_confianca(int candidato, float estimativa, float desvio)
{
  double diferenca = fabs(estimativa - candidato);
  double soma_prob = 0.0;
  for(int i = 1; i <= 7; i++) {
    soma_prob += erfc((i - diferenca)/(sqrt(2)*desvio)) -
                erfc((i + diferenca)/(sqrt(2)*desvio));
  }
  return soma_prob;
}

Métodos de Fixação

void fixar_ambiguidade_arred(estado_rtk *solucao, int sat1, int sat2,
                            const int *amb_wide, int total)
{
  // Aproximação por arredondamento
  for(int i = 0; i < total; i++) {
    double valor_float = solucao->x[IDX_AMB + i];
    int valor_fixo = (int)round(valor_float);
    // Atualiza estados e covariância
  }
}

void fixar_ambiguidade_ils(estado_rtk *solucao, int sat1, int sat2,
                          const int *amb_wide, int total)
{
  // Minimização quadrática inteira:
  // minₙ∈ℤ ||D⁻¹(B_float - n)||²
  // Validação por teste de razão
}

Combinações de Frequência

Banda Larga:
λ_WL = c / (f₁ - f₂) ≈ 0.86m

Banda Estreita:
λ_NL = c / (f₁ + f₂) ≈ 0.11m