add raim_flag to gnss_solution, clarify dgnss_baseline

Author: kovach

include/libswiftnav/dgnss_management.h

@@ -62,6 +62,7 @@ s8 dgnss_iar_get_single_hyp(double *hyp);
 void dgnss_reset_iar(void);
 void dgnss_init_known_baseline(u8 num_sats, sdiff_t *sdiffs, double receiver_ecef[3], double b[3]);
 void dgnss_update_ambiguity_state(ambiguity_state_t *s);
+u8 baseline_flag(s8 ret, bool fixed);
 s8 dgnss_baseline(u8 num_sdiffs, const sdiff_t *sdiffs,
                   const double ref_ecef[3], const ambiguity_state_t *s,
                   u8 *num_used, double b[3],

include/libswiftnav/pvt.h

@@ -77,6 +77,10 @@ typedef struct __attribute__((packed)) {
   u8 valid;
   /* Number of channels used in the soluton. */
   u8 n_used;
+  /* bit 0: raim available?
+   * bit 1: raim repair used?
+   */
+  u8 raim_flag;
 } gnss_solution;
 
 s8 calc_PVT(const u8 n_used,

src/dgnss_management.c

@@ -395,6 +395,23 @@ void dgnss_update_ambiguity_state(ambiguity_state_t *s)
   }
 }
 
+/** Formats flag bits for sbp.
+ *  bit positions:
+ *  -`0`: fixed mode?
+ *  -`3`: RAIM available?
+ *  -`4`: RAIM repair used?
+ *
+ *  \param ret return code from baseline()
+ *  \param fixed 1 for fixed, 0 for float
+ *  \return formatted flag value
+ */
+u8 baseline_flag(s8 ret, bool fixed)
+{
+  return (ret == 1) << 4  /* RAIM repair? */
+       | (ret != 2) << 3  /* RAIM available? */
+       | fixed;           /* Fixed mode? */
+}
+
 /** Finds the baseline using low latency sdiffs.
  * The low latency sdiffs are not guaranteed to match up with either the
  * amb_test's or the float sdiffs, and thus care must be taken to transform them
@@ -410,37 +427,43 @@ void dgnss_update_ambiguity_state(ambiguity_state_t *s)
  * \param b           Output baseline.
  * \param disable_raim Flag to turn off raim checks/repair.
  * \param raim_threshold raim check threshold
- * \return  1 if we are using an IAR resolved baseline.
- *          2 if we are using a float baseline.
- *         -1 if we can't give a baseline.
+ * \return positive value: SBP baseline msg flags
+ *         negative value: baseline error code
  */
 s8 dgnss_baseline(u8 num_sdiffs, const sdiff_t *sdiffs,
                   const double ref_ecef[3], const ambiguity_state_t *s,
                   u8 *num_used, double b[3],
                   bool disable_raim, double raim_threshold)
 {
-  s8 ret = baseline(num_sdiffs, sdiffs, ref_ecef, &s->fixed_ambs, num_used, b,
+  s8 ret;
+
+  /* Try IAR resolved baseline */
+  ret = baseline(num_sdiffs, sdiffs, ref_ecef, &s->fixed_ambs, num_used, b,
                     disable_raim, raim_threshold);
   if (ret >= 0) {
-    if (ret == 1) /* TODO: Export this rather than just printing */
+    if (ret == 1)
       log_warn("dgnss_baseline: Fixed baseline RAIM repair");
     log_debug("fixed solution");
     DEBUG_EXIT();
-    return 1;
+    return baseline_flag(ret, true);
   }
+
   /* We weren't able to get an IAR resolved baseline, check if we can get a
    * float baseline. */
-  if ((ret = baseline(num_sdiffs, sdiffs, ref_ecef, &s->float_ambs, num_used, b,
-                      disable_raim, raim_threshold))
-        >= 0) {
-    if (ret == 1) /* TODO: Export this rather than just printing */
+  ret = baseline(num_sdiffs, sdiffs, ref_ecef, &s->float_ambs, num_used, b,
+                 disable_raim, raim_threshold);
+  if (ret >= 0) {
+    if (ret == 1)
       log_warn("dgnss_baseline: Float baseline RAIM repair");
     log_debug("float solution");
     DEBUG_EXIT();
-    return 2;
+    return baseline_flag(ret, false);
   }
   log_debug("no baseline solution");
   DEBUG_EXIT();
+
+  /* Must be negative! */
+  assert(ret < 0);
   return ret;
 }
 

src/pvt.c

@@ -536,17 +536,26 @@ s8 calc_PVT(const u8 n_used,
   soln->n_used = n_used; // Keep track of number of working channels
 
   u8 removed_prn = -1;
-  s8 raim_flag = pvt_solve_raim(rx_state, n_used, nav_meas, disable_raim,
-                                H, &removed_prn, 0);
+  s8 code = pvt_solve_raim(rx_state, n_used, nav_meas, disable_raim,
+                           H, &removed_prn, 0);
 
-  if (raim_flag < 0) {
+  if (code < 0) {
     /* Didn't converge or least squares integrity check failed. */
-    return raim_flag - 3;
+    return code - 3;
   }
 
+  soln->raim_flag = 0;
+
   /* Initial solution failed, but repair was successful. */
-  if (raim_flag == 1) {
+  if (code == 1) {
     soln->n_used--;
+    soln->raim_flag = (1 << 1) | 1; /* 11 */
+  } else if (code == 2) {
+    soln->raim_flag = 0; /* 00 */
+  } else if (code == 0) {
+    soln->raim_flag = 1; /* 01 */
+  } else {
+    log_error("Invalid pvt_solve_raim return code: %d\n", code);
   }
 
   /* Compute various dilution of precision metrics. */
@@ -597,6 +606,6 @@ s8 calc_PVT(const u8 n_used,
 
   soln->valid = 1;
 
-  return raim_flag;
+  return code;
 }
 

tests/check_dgnss_management.c

@@ -212,7 +212,8 @@ START_TEST(test_dgnss_baseline_1)
   s.fixed_ambs.n = 0;
   s8 valid = dgnss_baseline(num_sdiffs, sdiffs, ref_ecef, &s, &num_used, b,
     false, DEFAULT_RAIM_THRESHOLD);
-  fail_unless(valid == 2);
+  /* baseline_flag(initial solution ok, float mode) */
+  fail_unless(valid == baseline_flag(0, false));
   fail_unless(num_used == 5);
   fail_unless(within_epsilon(b[0], -0.742242));
   fail_unless(within_epsilon(b[1], -0.492905));
@@ -222,7 +223,8 @@ START_TEST(test_dgnss_baseline_1)
   s.fixed_ambs.n = 4;
   valid = dgnss_baseline(num_sdiffs, sdiffs, ref_ecef, &s, &num_used, b,
     false, DEFAULT_RAIM_THRESHOLD);
-  fail_unless(valid == 1);
+  /* baseline_flag(initial solution ok, fixed mode) */
+  fail_unless(valid == baseline_flag(0, true));
   fail_unless(num_used == 5);
   fail_unless(within_epsilon(b[0], -0.417486));
   fail_unless(within_epsilon(b[1], -0.358386));

tests/check_pvt.c

@@ -86,6 +86,8 @@ START_TEST(test_pvt_repair)
   s8 code = calc_PVT(n_used, nms, false, &soln, &dops);
   fail_unless(code == 1,
     "Return code should be 1 (pvt repair). Saw: %d\n", code);
+  fail_unless(soln.raim_flag == 3,
+    "raim_flag should be 11, saw: %d\n", soln.raim_flag);
   fail_unless(soln.n_used == n_used - 1,
     "PVT solver failed to repair solution.");
 }
@@ -104,6 +106,8 @@ START_TEST(test_disable_pvt_raim)
   s8 code = calc_PVT(n_used, nms, true, &soln, &dops);
   fail_unless(code == 2,
     "Return code should be 2 (raim not used). Saw: %d\n", code);
+  fail_unless(soln.raim_flag == 0,
+    "raim_flag should be 00, saw: %d\n", soln.raim_flag);
   fail_unless(soln.valid == 1,
     "Solution should be valid!");
 }