gps_pvt 0.1.7 → 0.2.3

data/ext/ninja-scan-light/tool/navigation/RINEX.h

@@ -53,6 +53,7 @@
 #include <limits>
 
 #include "GPS.h"
+#include "SBAS.h"
 
 template <class U = void>
 class RINEX_Reader {
@@ -452,7 +453,6 @@ struct RINEX_NAV {
     FloatT t_oc_sec;
     FloatT t_oe_WN;
     FloatT ura_meter;
-    FloatT SV_health_f;
     FloatT t_ot;  ///< Transmitting time [s]
     FloatT fit_interval_hr;
     FloatT dummy;
@@ -467,7 +467,6 @@ struct RINEX_NAV {
         t_oc_sec(std::fmod(eph.t_oc, 60)),
         t_oe_WN(eph.WN),
         ura_meter(ephemeris_t::URA_meter(eph.URA)),
-        SV_health_f(((eph.SV_health & 0x20) && (eph.SV_health & 0x1F == 0)) ? 1 : eph.SV_health),
         t_ot(0), // TODO
         fit_interval_hr(eph.fit_interval / (60 * 60)),
         dummy(0) {
@@ -485,17 +484,69 @@ struct RINEX_NAV {
        * RINEX Value:   0    Health OK
        * RINEX Value:   1    Health not OK (bits 18-22 not stored)
        * RINEX Value: >32    Health not OK (bits 18-22 stored)
+       * eph.SV_health may have a value greater than 32
        */
-      eph.SV_health = (unsigned int)SV_health_f;
-      if(eph.SV_health > 32){
-        eph.SV_health &= 0x3F; // 0b111111
-      }else if(eph.SV_health > 0){
-        eph.SV_health = 0x20; // 0b100000
-      }
 
       // At least 4 hour validity, then, hours => seconds;
       eph.fit_interval = ((fit_interval_hr < 4) ? 4 : fit_interval_hr) * 60 * 60;
     }
+    static message_t from_qzss(const ephemeris_t &eph_){
+      message_t res(eph_);
+      res.eph.svid -= 192;
+      res.fit_interval_hr = (res.fit_interval_hr) > 2 ? 1 : 0;
+      return res;
+    }
+    ephemeris_t eph_qzss() const {
+      ephemeris_t res(eph);
+      res.svid += 192;
+      res.fit_interval = ((fit_interval_hr > 0) ? 4 : 2) * 60 * 60;
+      return res;
+    }
+  };
+  struct message_sbas_t {
+    typedef typename SBAS_SpaceNode<FloatT>
+        ::SatelliteProperties::Ephemeris eph_t;
+    int svid;
+    std::tm date_tm;
+    int t_year4, t_year2, t_mon12;
+    FloatT t_sec;
+    FloatT a_Gf0, a_Gf1;
+    FloatT t_t; // Transmission time of message (start of the message) in GPS seconds of the week
+    FloatT x_km, dx_km_s, ddx_km_s2;
+    FloatT y_km, dy_km_s, ddy_km_s2;
+    FloatT z_km, dz_km_s, ddz_km_s2;
+    unsigned int health;
+    FloatT URA;
+    unsigned int iodn;
+    message_sbas_t() {}
+    message_sbas_t(const eph_t &eph)
+        : svid((int)eph.svid - 100),
+        date_tm(eph.base_time().c_tm()),
+        t_year4(date_tm.tm_year + 1900),
+        t_year2(date_tm.tm_year % 100),
+        t_mon12(date_tm.tm_mon + 1),
+        t_sec(date_tm.tm_sec),
+        a_Gf0(eph.a_Gf0), a_Gf1(eph.a_Gf1),
+        t_t(eph.t_0), // TODO maybe differ from t_e slightly
+        x_km(1E-3 * eph.x), dx_km_s(1E-3 * eph.dx), ddx_km_s2(1E-3 * eph.ddx),
+        y_km(1E-3 * eph.y), dy_km_s(1E-3 * eph.dy), ddy_km_s2(1E-3 * eph.ddy),
+        z_km(1E-3 * eph.z), dz_km_s(1E-3 * eph.dz), ddz_km_s2(1E-3 * eph.ddz),
+        health(0), URA(eph.URA), iodn(0) {
+    }
+    operator eph_t() const {
+      eph_t eph = {0};
+      eph.svid = (unsigned int)svid + 100;
+      typename space_node_t::gps_time_t t(date_tm);
+      t += (t_sec - date_tm.tm_sec);
+      eph.WN = t.week;
+      eph.t_0 = t.seconds;
+      eph.a_Gf0 = a_Gf0; eph.a_Gf1 = a_Gf1;
+      eph.x = 1E3 * x_km; eph.dx = 1E3 * dx_km_s; eph.ddx = 1E3 * ddx_km_s2;
+      eph.y = 1E3 * y_km; eph.dy = 1E3 * dy_km_s; eph.ddy = 1E3 * ddy_km_s2;
+      eph.z = 1E3 * z_km; eph.dz = 1E3 * dz_km_s; eph.ddz = 1E3 * ddz_km_s2;
+      eph.URA = URA;
+      return eph;
+    }
   };
 };
 
@@ -507,6 +558,7 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
   public:
     typedef typename RINEX_NAV<FloatT>::space_node_t space_node_t;
     typedef typename RINEX_NAV<FloatT>::message_t message_t;
+    typedef typename RINEX_NAV<FloatT>::message_sbas_t message_sbas_t;
     typedef typename space_node_t::Ionospheric_UTC_Parameters iono_utc_t;
 
     static const typename super_t::convert_item_t eph0_v2[10], eph0_v3[10];
@@ -518,9 +570,15 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
     static const typename super_t::convert_item_t eph6_v2[4], eph6_v3[4];
     static const typename super_t::convert_item_t eph7_v2[2], eph7_v3[2];
 
+    static const typename super_t::convert_item_t eph0_sbas_v2[10], eph0_sbas_v3[10];
+    static const typename super_t::convert_item_t eph1_sbas_v2[4], eph1_sbas_v3[4];
+    static const typename super_t::convert_item_t eph2_sbas_v2[4], eph2_sbas_v3[4];
+    static const typename super_t::convert_item_t eph3_sbas_v2[4], eph3_sbas_v3[4];
+
   protected:
     typename super_t::version_type_t::sat_system_t sys_of_msg;
     message_t msg;
+    message_sbas_t msg_sbas;
     
     void seek_next_v2_gps() {
       char buf[256];
@@ -564,10 +622,36 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
       super_t::_has_next = true;
     }
 
+    void seek_next_v2_sbas() {
+      char buf[256];
+
+      for(int i(0); i < 4; i++){
+        if((!super_t::src.good())
+            || super_t::src.getline(buf, sizeof(buf)).fail()){return;}
+        std::string line(buf);
+
+        switch(i){
+          case 0: {
+            super_t::convert(eph0_sbas_v2, line, &msg_sbas);
+            msg_sbas.date_tm.tm_year = msg_sbas.t_year2 + (msg_sbas.t_year2 < 80 ? 100 : 0); // greater than 1980
+            msg_sbas.date_tm.tm_mon = msg_sbas.t_mon12 - 1; // month [0, 11]
+            msg_sbas.date_tm.tm_sec = (int)msg_sbas.t_sec;
+            break;
+          }
+          case 1: super_t::convert(eph1_sbas_v2, line, &msg_sbas); break;
+          case 2: super_t::convert(eph2_sbas_v2, line, &msg_sbas); break;
+          case 3: super_t::convert(eph3_sbas_v2, line, &msg_sbas); break;
+        }
+      }
+      sys_of_msg = super_t::version_type_t::SYS_SBAS;
+      super_t::_has_next = true;
+    }
+
     void seek_next_v2() {
       switch(super_t::version_type.sat_system){
         case super_t::version_type_t::SYS_GPS: seek_next_v2_gps(); return;
         case super_t::version_type_t::SYS_GLONASS: seek_next_v2_glonass(); return;
+        case super_t::version_type_t::SYS_SBAS: seek_next_v2_sbas(); return;
         default: break;
       }
     }
@@ -599,6 +683,35 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
       super_t::_has_next = true;
     }
 
+    template <std::size_t N>
+    void seek_next_v3_sbas(char (&buf)[N]) {
+      super_t::convert(eph0_sbas_v3, std::string(buf), &msg_sbas);
+      msg_sbas.date_tm.tm_year = msg_sbas.t_year4 - 1900; // tm_year base is 1900
+      msg_sbas.date_tm.tm_mon = msg_sbas.t_mon12 - 1; // month [0, 11]
+      msg_sbas.t_sec = msg_sbas.date_tm.tm_sec;
+
+      for(int i(1); i < 4; i++){
+        if((!super_t::src.good())
+            || super_t::src.getline(buf, sizeof(buf)).fail()){return;}
+        std::string line(buf);
+
+        switch(i){
+          case 1: super_t::convert(eph1_sbas_v3, line, &msg_sbas); break;
+          case 2: super_t::convert(eph2_sbas_v3, line, &msg_sbas); break;
+          case 3: super_t::convert(eph3_sbas_v3, line, &msg_sbas); break;
+        }
+      }
+      sys_of_msg = super_t::version_type_t::SYS_SBAS;
+      super_t::_has_next = true;
+    }
+
+    template <std::size_t N>
+    void seek_next_v3_qzss(char (&buf)[N]) {
+      seek_next_v3_gps(buf);
+      if(!super_t::_has_next){return;}
+      sys_of_msg = super_t::version_type_t::SYS_QZSS;
+    }
+
     template <std::size_t N>
     void seek_next_v3_not_implemented(char (&buf)[N], const int &lines) {
       for(int i(1); i < lines; i++){
@@ -619,9 +732,9 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
           case 'G': seek_next_v3_gps(buf); return; // GPS
           case 'E': seek_next_v3_not_implemented(buf, 8); return; // Galileo
           case 'R': seek_next_v3_not_implemented(buf, 4); return; // Glonass
-          case 'J': seek_next_v3_not_implemented(buf, 8); return; // QZSS
+          case 'J': seek_next_v3_qzss(buf); return; // QZSS
           case 'C': seek_next_v3_not_implemented(buf, 8); return; // Beido
-          case 'S': seek_next_v3_not_implemented(buf, 4); return; // SBAS
+          case 'S': seek_next_v3_sbas(buf); return; // SBAS
           case 'T': seek_next_v3_not_implemented(buf, 8); return; // IRNSS
           default: break;
         }
@@ -659,19 +772,19 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
       bool alpha, beta, utc, leap;
       super_t::header_t::const_iterator it;
 
-      if(alpha = ((it = _header.find("ION ALPHA")) != _header.end())){
+      if((alpha = ((it = _header.find("ION ALPHA")) != _header.end()))){
         super_t::convert(iono_alpha_v2, it->second.front(), &iono_utc);
       }
       
-      if(beta = ((it = _header.find("ION BETA")) != _header.end())){
+      if((beta = ((it = _header.find("ION BETA")) != _header.end()))){
         super_t::convert(iono_beta_v2, it->second.front(), &iono_utc);
       }
 
-      if(utc = ((it = _header.find("DELTA-UTC: A0,A1,T,W")) != _header.end())){
+      if((utc = ((it = _header.find("DELTA-UTC: A0,A1,T,W")) != _header.end()))){
         super_t::convert(utc_v2, it->second.front(), &iono_utc);
       }
 
-      if(leap = ((it = _header.find("LEAP SECONDS")) != _header.end())){
+      if((leap = ((it = _header.find("LEAP SECONDS")) != _header.end()))){
         super_t::convert(utc_leap_v2, it->second.front(), &iono_utc);
       }
 
@@ -728,17 +841,25 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
 
     struct space_node_list_t {
       space_node_t *gps;
+      SBAS_SpaceNode<FloatT> *sbas;
+      space_node_t *qzss;
     };
 
     static int read_all(std::istream &in, space_node_list_t &space_nodes = {0}){
-      int res(-1);
       RINEX_NAV_Reader reader(in);
+      if(reader.version_type.file_type != version_type_t::FTYPE_NAVIGATION){
+        return -1;
+      }
       if(space_nodes.gps){
         (reader.version_type.version >= 300)
             ? reader.extract_iono_utc_v3(*space_nodes.gps)
             : reader.extract_iono_utc_v2(*space_nodes.gps);
       }
-      res++;
+      if(space_nodes.qzss && (space_nodes.gps != space_nodes.qzss)
+          && (reader.version_type.version >= 302)){
+        reader.extract_iono_utc_v3(*space_nodes.qzss);
+      }
+      int res(0);
       for(; reader.has_next(); reader.next()){
         switch(reader.sys_of_msg){
           case super_t::version_type_t::SYS_GPS:
@@ -746,6 +867,20 @@ class RINEX_NAV_Reader : public RINEX_Reader<> {
             space_nodes.gps->satellite(reader.msg.eph.svid).register_ephemeris(reader.msg.eph);
             res++;
             break;
+          case super_t::version_type_t::SYS_SBAS: {
+            if(!space_nodes.sbas){break;}
+            typename message_sbas_t::eph_t eph(reader.msg_sbas);
+            space_nodes.sbas->satellite(eph.svid).register_ephemeris(eph);
+            res++;
+            break;
+          }
+          case super_t::version_type_t::SYS_QZSS: {
+            if(!space_nodes.qzss){break;}
+            typename RINEX_NAV<FloatT>::ephemeris_t eph(reader.msg.eph_qzss());
+            space_nodes.qzss->satellite(eph.svid).register_ephemeris(eph);
+            res++;
+            break;
+          }
           default: break;
         }
       }
@@ -1007,6 +1142,9 @@ class RINEX_OBS_Reader : public RINEX_Reader<> {
     RINEX_OBS_Reader(std::istream &in)
         : super_t(in, self_t::modify_header),
           obs_types() {
+      if(super_t::version_type.file_type != version_type_t::FTYPE_OBSERVATION){
+        return;
+      }
       typedef super_t::header_t::const_iterator it_t;
       typedef super_t::header_t::mapped_type::const_iterator it2_t;
       it_t it;
@@ -1190,14 +1328,14 @@ const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>
 template <class FloatT>
 const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph6_v2[] = {
   GEN_E ( 3, 19, 12, message_t, ura_meter),
-  GEN_E (22, 19, 12, message_t, SV_health_f),
+  GEN_E2(22, 19, 12, message_t, eph.SV_health, unsigned int),
   GEN_E (41, 19, 12, message_t, eph.t_GD),
   GEN_E2(60, 19, 12, message_t, eph.iodc, int),
 };
 template <class FloatT>
 const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph6_v3[] = {
   GEN_E ( 4, 19, 12, message_t, ura_meter),
-  GEN_E (23, 19, 12, message_t, SV_health_f),
+  GEN_E2(23, 19, 12, message_t, eph.SV_health, unsigned int),
   GEN_E (42, 19, 12, message_t, eph.t_GD),
   GEN_E2(61, 19, 12, message_t, eph.iodc, int),
 };
@@ -1213,6 +1351,80 @@ const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>
   GEN_E(23, 19, 12, message_t, fit_interval_hr),
 };
 
+
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph0_sbas_v2[] = {
+  GEN_D( 0,  2,     message_sbas_t, svid,            int),
+  GEN_D( 3,  2,     message_sbas_t, t_year2,         int),
+  GEN_D( 6,  2,     message_sbas_t, t_mon12,         int),
+  GEN_D( 9,  2,     message_sbas_t, date_tm.tm_mday, int),
+  GEN_D(12,  2,     message_sbas_t, date_tm.tm_hour, int),
+  GEN_D(15,  2,     message_sbas_t, date_tm.tm_min,  int),
+  GEN_F(17,  5,  1, message_sbas_t, t_sec),
+  GEN_E(22, 19, 12, message_sbas_t, a_Gf0),
+  GEN_E(41, 19, 12, message_sbas_t, a_Gf1),
+  GEN_E(60, 19, 12, message_sbas_t, t_t),
+};
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph0_sbas_v3[] = {
+  GEN_I( 1,  2,     message_sbas_t, svid,            int),
+  GEN_I( 4,  4,     message_sbas_t, t_year4,         int),
+  GEN_I( 9,  2,     message_sbas_t, t_mon12,         int),
+  GEN_I(12,  2,     message_sbas_t, date_tm.tm_mday, int),
+  GEN_I(15,  2,     message_sbas_t, date_tm.tm_hour, int),
+  GEN_I(18,  2,     message_sbas_t, date_tm.tm_min,  int),
+  GEN_I(21,  2,     message_sbas_t, date_tm.tm_sec,  int),
+  GEN_E(23, 19, 12, message_sbas_t, a_Gf0),
+  GEN_E(42, 19, 12, message_sbas_t, a_Gf1),
+  GEN_E(61, 19, 12, message_sbas_t, t_t),
+};
+
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph1_sbas_v2[] = {
+  GEN_E( 3, 19, 12, message_sbas_t, x_km),
+  GEN_E(22, 19, 12, message_sbas_t, dx_km_s),
+  GEN_E(41, 19, 12, message_sbas_t, ddx_km_s2),
+  GEN_E2(60, 19, 12, message_sbas_t, health, unsigned int),
+};
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph1_sbas_v3[] = {
+  GEN_E( 4, 19, 12, message_sbas_t, x_km),
+  GEN_E(23, 19, 12, message_sbas_t, dx_km_s),
+  GEN_E(42, 19, 12, message_sbas_t, ddx_km_s2),
+  GEN_E2(61, 19, 12, message_sbas_t, health, unsigned int),
+};
+
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph2_sbas_v2[] = {
+  GEN_E( 3, 19, 12, message_sbas_t, y_km),
+  GEN_E(22, 19, 12, message_sbas_t, dy_km_s),
+  GEN_E(41, 19, 12, message_sbas_t, ddy_km_s2),
+  GEN_E(60, 19, 12, message_sbas_t, URA),
+};
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph2_sbas_v3[] = {
+  GEN_E( 4, 19, 12, message_sbas_t, y_km),
+  GEN_E(23, 19, 12, message_sbas_t, dy_km_s),
+  GEN_E(42, 19, 12, message_sbas_t, ddy_km_s2),
+  GEN_E(61, 19, 12, message_sbas_t, URA),
+};
+
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph3_sbas_v2[] = {
+  GEN_E( 3, 19, 12, message_sbas_t, z_km),
+  GEN_E(22, 19, 12, message_sbas_t, dz_km_s),
+  GEN_E(41, 19, 12, message_sbas_t, ddz_km_s2),
+  GEN_E2(60, 19, 12, message_sbas_t, iodn, unsigned int),
+};
+template <class FloatT>
+const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::eph3_sbas_v3[] = {
+  GEN_E( 4, 19, 12, message_sbas_t, z_km),
+  GEN_E(23, 19, 12, message_sbas_t, dz_km_s),
+  GEN_E(42, 19, 12, message_sbas_t, ddz_km_s2),
+  GEN_E2(61, 19, 12, message_sbas_t, iodn, unsigned int),
+};
+
+
 template <class FloatT>
 const typename RINEX_NAV_Reader<FloatT>::convert_item_t RINEX_NAV_Reader<FloatT>::iono_alpha_v2[] = {
   GEN_E( 2, 12, 4, iono_utc_t, alpha[0]),
@@ -1511,6 +1723,7 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
   public:
     typedef typename RINEX_NAV<FloatT>::space_node_t space_node_t;
     typedef typename RINEX_NAV<FloatT>::message_t message_t;
+    typedef typename RINEX_NAV<FloatT>::message_sbas_t message_sbas_t;
 
     static const typename super_t::header_item_t default_header[];
     static const int default_header_size;
@@ -1569,7 +1782,7 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
         : super_t(out, default_header, default_header_size) {}
     ~RINEX_NAV_Writer(){}
 
-    self_t &operator<<(const message_t &msg){
+    self_t &dump(const message_t &msg, const bool &is_qzss = false){
       std::stringstream buf;
       switch(super_t::_version_type.version / 100){
         case 2:
@@ -1592,7 +1805,8 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
           for(int i(0); i < 8; ++i){
             std::string s(80, ' ');
             switch(i){
-              case 0: super_t::convert(reader_t::eph0_v3, s, &msg); s[0] = 'G'; break;
+              case 0: super_t::convert(reader_t::eph0_v3, s, &msg);
+                s[0] = is_qzss ? 'J' : 'G'; break;
               case 1: super_t::convert(reader_t::eph1_v3, s, &msg); break;
               case 2: super_t::convert(reader_t::eph2_v3, s, &msg); break;
               case 3: super_t::convert(reader_t::eph3_v3, s, &msg); break;
@@ -1608,6 +1822,40 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
       dist << buf.str();
       return *this;
     }
+    self_t &operator<<(const message_t &msg){
+      return dump(msg);
+    }
+    self_t &operator<<(const message_sbas_t &msg){
+      std::stringstream buf;
+      switch(super_t::_version_type.version / 100){
+        case 2:
+          for(int i(0); i < 8; ++i){
+            std::string s(80, ' ');
+            switch(i){
+              case 0: super_t::convert(reader_t::eph0_sbas_v2, s, &msg); break;
+              case 1: super_t::convert(reader_t::eph1_sbas_v2, s, &msg); break;
+              case 2: super_t::convert(reader_t::eph2_sbas_v2, s, &msg); break;
+              case 3: super_t::convert(reader_t::eph3_sbas_v2, s, &msg); break;
+            }
+            buf << s << std::endl;
+          }
+          break;
+        case 3:
+          for(int i(0); i < 8; ++i){
+            std::string s(80, ' ');
+            switch(i){
+              case 0: super_t::convert(reader_t::eph0_sbas_v3, s, &msg); s[0] = 'S'; break;
+              case 1: super_t::convert(reader_t::eph1_sbas_v3, s, &msg); break;
+              case 2: super_t::convert(reader_t::eph2_sbas_v3, s, &msg); break;
+              case 3: super_t::convert(reader_t::eph3_sbas_v3, s, &msg); break;
+            }
+            buf << s << std::endl;
+          }
+          break;
+      }
+      dist << buf.str();
+      return *this;
+    }
 
   public:
     void set_version(
@@ -1617,15 +1865,22 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
           version, super_t::version_type_t::FTYPE_NAVIGATION, sys));
     }
 
+    struct space_node_list_t {
+      const space_node_t *gps;
+      const SBAS_SpaceNode<FloatT> *sbas;
+      const space_node_t *qzss;
+    };
     int write_all(
-        const typename reader_t::space_node_list_t &space_nodes,
+        const space_node_list_t &space_nodes,
         const int &version = 304){
       int res(-1);
       int systems(0);
       set_version(version, super_t::version_type_t::SYS_UNKNOWN);
-      if(space_nodes.gps && space_nodes.gps->is_valid_iono_utc()){
+      do{
+        if(!space_nodes.gps){break;}
         ++systems;
         set_version(version, super_t::version_type_t::SYS_GPS);
+        if(!space_nodes.gps->is_valid_iono_utc()){break;}
         switch(version / 100){
           case 2:
             if(_header["ION ALPHA"].entries() == 0){iono_alpha(*space_nodes.gps);}
@@ -1640,7 +1895,26 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
             if(_header["LEAP SECONDS"].entries() == 0){leap_seconds(*space_nodes.gps);}
             break;
         }
-      }
+      }while(false);
+      do{
+        if(!space_nodes.sbas){break;}
+        ++systems;
+        set_version(version, super_t::version_type_t::SYS_SBAS);
+      }while(false);
+      do{
+        if((version < 302) || (!space_nodes.qzss)){break;}
+        ++systems;
+        set_version(version, super_t::version_type_t::SYS_QZSS);
+        if(!space_nodes.qzss->is_valid_iono_utc()){break;}
+        switch(version / 100){
+          case 3:
+            if(_header["IONOSPHERIC CORR"].find("GPSA") == _header.end()){iono_alpha(*space_nodes.qzss);}
+            if(_header["IONOSPHERIC CORR"].find("GPSB") == _header.end()){iono_beta(*space_nodes.qzss);}
+            if(_header["TIME SYSTEM CORR"].find("QZUT") == _header.end()){utc_params(*space_nodes.qzss);}
+            if(_header["LEAP SECONDS"].entries() == 0){leap_seconds(*space_nodes.qzss);}
+            break;
+        }
+      }while(false);
       if(systems > 1){
         set_version(version, super_t::version_type_t::SYS_MIXED);
       }
@@ -1650,12 +1924,25 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
       struct {
         RINEX_NAV_Writer &w;
         int &counter;
+        bool gps, qzss;
         void operator()(const typename space_node_t::Satellite::Ephemeris &eph) {
-          w << message_t(eph);
+          if(gps && (eph.svid <= 32)){
+            w << message_t(eph);
+          }else if(qzss && (eph.svid >= 193) && (eph.svid < 202)){
+            w.dump(message_t::from_qzss(eph), true);
+          }else{
+            return;
+          }
+          counter++;
+        }
+        void operator()(const typename message_sbas_t::eph_t &eph) {
+          w << message_sbas_t(eph);
           counter++;
         }
-      } functor = {*this, res};
+      } functor = {*this, res, false, false};
       if(space_nodes.gps){
+        functor.gps = true;
+        if(space_nodes.gps == space_nodes.qzss){functor.qzss = true;}
         for(typename space_node_t::satellites_t::const_iterator
               it(space_nodes.gps->satellites().begin()), it_end(space_nodes.gps->satellites().end());
             it != it_end; ++it){
@@ -1664,16 +1951,37 @@ class RINEX_NAV_Writer : public RINEX_Writer<> {
               space_node_t::Satellite::eph_list_t::EACH_ALL_INVERTED);
         }
       }
+      if(space_nodes.sbas){
+        for(typename SBAS_SpaceNode<FloatT>::satellites_t::const_iterator
+              it(space_nodes.sbas->satellites().begin()),
+              it_end(space_nodes.sbas->satellites().end());
+            it != it_end; ++it){
+          it->second.each_ephemeris(
+              functor,
+              SBAS_SpaceNode<FloatT>::Satellite::eph_list_t::EACH_ALL_INVERTED);
+        }
+      }
+      if((version >= 302) && (!functor.qzss) && (space_nodes.qzss)){
+        functor.qzss = true;
+        functor.gps = false;
+        for(typename space_node_t::satellites_t::const_iterator
+              it(space_nodes.qzss->satellites().begin()), it_end(space_nodes.qzss->satellites().end());
+            it != it_end; ++it){
+          it->second.each_ephemeris(
+              functor,
+              space_node_t::Satellite::eph_list_t::EACH_ALL_INVERTED);
+        }
+      }
       return res;
     }
     static int write_all(
         std::ostream &out,
-        const typename reader_t::space_node_list_t &space_nodes,
+        const space_node_list_t &space_nodes,
         const int &version = 304){
       return RINEX_NAV_Writer(out).write_all(space_nodes, version);
     }
     int write_all(const space_node_t &space_node, const int &version = 304){
-      const typename reader_t::space_node_list_t list = {&const_cast<space_node_t &>(space_node)};
+      space_node_list_t list = {&space_node};
       return write_all(list, version);
     }
     static int write_all(std::ostream &out, const space_node_t &space_node, const int &version = 304){