Merge pull request #22 from Valar-Systems/feat/space-wow-screens

Spacescope: 5 new screens (DSN Now, deep space, flare, humans, moon)

Author: daniel-frenkel

src/ConfigurationWebServer.cpp

@@ -687,7 +687,7 @@ static const char CONFIG_HTML[] PROGMEM = R"(
                         <input name="space-screens" value='%SPACE_SCREENS%'
                             class="border border-sky-400 bg-gray-900 w-full px-3 py-2 text-lg sm:text-base sm:px-1 sm:py-0">
                     </label>
-                    <span class="text-xs text-sky-600 mt-1">ids: iss, launch, kp, splash, clock. Empty rotates all. Each screen appears only when its feed has data; the clock always shows when nothing else does. (More screens arrive in upcoming firmware.)</span>
+                    <span class="text-xs text-sky-600 mt-1">ids: iss, launch, kp, flare, dsn, deepspace, humans, moon, splash, clock. Empty rotates all. Each screen appears only when its feed has data; the clock and moon always show. (More screens arrive in upcoming firmware.)</span>
                 </fieldset>
 
                 <fieldset class="border border-sky-400 p-3">
@@ -864,7 +864,7 @@ void ConfigurationWebServer::Initialise() {
         const String brightness = prefs.getString("brightness", "255");
         const String spaceScreens = prefs.isKey("space-screens")
             ? prefs.getString("space-screens", "")
-            : String("iss,launch,kp,clock");
+            : String("iss,launch,kp,flare,dsn,deepspace,humans,moon,clock");
 #endif
         prefs.end();
 

src/space/SpaceFeedClient.cpp

@@ -1,19 +1,35 @@
 #include "SpaceFeedClient.h"
 
+#include <time.h>
+
 using space::SpaceFetchRequest;
 using space::SpaceFetchResult;
 
 namespace {
 
 // Default poll intervals (ms).
-constexpr uint32_t ISS_MS    = 5000;      // ~5 s: a smoothly gliding blip (well under wheretheiss' ~1 req/s)
-constexpr uint32_t LAUNCH_MS = 1200000;   // ~20 m: editorial, slow-moving; the T-minus clock ticks locally
-constexpr uint32_t KP_MS     = 720000;    // ~12 m: SWPC Kp is 3-hourly with a recent estimate
+constexpr uint32_t ISS_MS        = 5000;      // ~5 s: a smoothly gliding blip (well under wheretheiss' ~1 req/s)
+constexpr uint32_t LAUNCH_MS     = 1200000;   // ~20 m: editorial, slow-moving; the T-minus clock ticks locally
+constexpr uint32_t KP_MS         = 720000;    // ~12 m: SWPC Kp is 3-hourly with a recent estimate
+constexpr uint32_t DSN_MS        = 30000;     // ~30 s: which dish talks to whom changes slowly
+constexpr uint32_t DEEPSPACE_MS  = 120000;    // ~2 m per target (round-robin); probes move slowly
+constexpr uint32_t FLARE_MS      = 90000;     // ~90 s: GOES X-ray updates ~1 min; flares evolve fast
+constexpr uint32_t HUMANS_MS     = 3600000;   // ~1 h: the crew roster changes rarely
 
 constexpr uint32_t MAX_BACKOFF_MS = 600000; // cap exponential backoff at 10 m
 
 constexpr size_t LAUNCH_RETAIN = 5;       // a few upcoming launches (the screen shows the next)
 constexpr size_t KP_HISTORY     = 24;     // recent Kp samples kept for the gauge sparkline
+constexpr size_t DSN_LINK_CAP   = 12;     // bound the parsed active-link list
+
+// Deep-space probes fetched round-robin from JPL Horizons (one per DeepSpace poll). cmd is the
+// Horizons body code; CENTER=500@399 yields range from Earth. Verified -31 (Voyager 1) live.
+struct DeepTarget { const char* name; const char* cmd; };
+const DeepTarget DEEP_TARGETS[] = {
+    {"Voyager 1", "-31"}, {"Voyager 2", "-32"}, {"New Horizons", "-98"},
+    {"JWST", "-170"}, {"Parker Solar Probe", "-96"},
+};
+constexpr int DEEP_N = (int)(sizeof(DEEP_TARGETS) / sizeof(DEEP_TARGETS[0]));
 
 // A polite UA: some public APIs reject default/empty agents. No key, nothing identifying the user.
 const char* USER_AGENT = "Blipscope-Spacescope/1 (+https://github.com/Valar-Systems/Blipscope)";
@@ -24,6 +40,10 @@ void SpaceFeedClient::Begin()
 {
     if (taskHandle != nullptr) return; // survives config reloads
 
+    // Seed the round-robin deep-space target list with friendly names (distances fill in as polled).
+    deepTargets.resize(DEEP_N);
+    for (int i = 0; i < DEEP_N; ++i) { deepTargets[i].name = DEEP_TARGETS[i].name; deepTargets[i].valid = false; }
+
     reqQueue = xQueueCreate(1, sizeof(SpaceFetchRequest*));
     resQueue = xQueueCreate(1, sizeof(SpaceFetchResult*));
 
@@ -41,9 +61,13 @@ void SpaceFeedClient::Configure(const Config& newCfg)
     if (sc < 1.0f) sc = 1.0f;
     if (sc > 8.0f) sc = 8.0f;
 
-    feeds[F_ISS].intervalMs    = (uint32_t)(ISS_MS * sc);
-    feeds[F_LAUNCH].intervalMs = (uint32_t)(LAUNCH_MS * sc);
-    feeds[F_KP].intervalMs     = (uint32_t)(KP_MS * sc);
+    feeds[F_ISS].intervalMs       = (uint32_t)(ISS_MS * sc);
+    feeds[F_LAUNCH].intervalMs    = (uint32_t)(LAUNCH_MS * sc);
+    feeds[F_KP].intervalMs        = (uint32_t)(KP_MS * sc);
+    feeds[F_DSN].intervalMs       = (uint32_t)(DSN_MS * sc);
+    feeds[F_DEEPSPACE].intervalMs = (uint32_t)(DEEPSPACE_MS * sc);
+    feeds[F_FLARE].intervalMs     = (uint32_t)(FLARE_MS * sc);
+    feeds[F_HUMANS].intervalMs    = (uint32_t)(HUMANS_MS * sc);
 
     // Stage the first poll of each endpoint shortly after (re)config, fanned out by ~400 ms so
     // they don't all hit the single TLS client at once.
@@ -101,7 +125,7 @@ int SpaceFeedClient::PickDueFeed(uint32_t now) const
     return best;
 }
 
-bool SpaceFeedClient::BuildRequest(int feedIdx, SpaceFetchRequest& req) const
+bool SpaceFeedClient::BuildRequest(int feedIdx, SpaceFetchRequest& req)
 {
     req.headers.push_back({"User-Agent", USER_AGENT});
     switch (feedIdx) {
@@ -117,6 +141,47 @@ bool SpaceFeedClient::BuildRequest(int feedIdx, SpaceFetchRequest& req) const
             req.endpoint = space::SpaceEndpoint::Kp;
             req.url = "https://services.swpc.noaa.gov/products/noaa-planetary-k-index.json";
             return true;
+        case F_DSN:
+            req.endpoint = space::SpaceEndpoint::Dsn;
+            req.url = "https://eyes.nasa.gov/dsn/data/dsn.xml";
+            return true;
+        case F_FLARE:
+            req.endpoint = space::SpaceEndpoint::Flare;
+            req.url = "https://services.swpc.noaa.gov/json/goes/primary/xrays-6-hour.json";
+            return true;
+        case F_HUMANS:
+            req.endpoint = space::SpaceEndpoint::Humans;
+            // corquaid GitHub-Pages mirror: fresh + reliable HTTPS (open-notify is stale/flaky).
+            req.url = "https://corquaid.github.io/international-space-station-APIs/JSON/people-in-space.json";
+            return true;
+        case F_DEEPSPACE: {
+            // Needs NTP for the START/STOP date window; skip (re-arm) until the clock is set.
+            const time_t now = time(nullptr);
+            if (now < 1600000000) return false;
+            const time_t tmrw = now + 86400;
+            struct tm a, b;
+            gmtime_r(&now, &a);
+            gmtime_r(&tmrw, &b);
+            char start[12], stop[12];
+            strftime(start, sizeof(start), "%Y-%m-%d", &a);
+            strftime(stop, sizeof(stop), "%Y-%m-%d", &b);
+
+            const DeepTarget& t = DEEP_TARGETS[deepIdx];
+            req.endpoint = space::SpaceEndpoint::DeepSpace;
+            req.targetIdx = deepIdx;
+            // Pre-encoded Horizons query (%27=' %40=@); STEP_SIZE='1' = one interval, no spaces in
+            // the request line. format=json so the existing GetJson de-chunker handles the body.
+            String u = "https://ssd.jpl.nasa.gov/api/horizons.api?format=json";
+            u += "&OBJ_DATA=%27NO%27&MAKE_EPHEM=%27YES%27&EPHEM_TYPE=%27OBSERVER%27";
+            u += "&CENTER=%27500%40399%27&QUANTITIES=%2720%27&STEP_SIZE=%271%27";
+            u += "&COMMAND=%27"; u += t.cmd; u += "%27";
+            u += "&START_TIME=%27"; u += start; u += "%27";
+            u += "&STOP_TIME=%27"; u += stop; u += "%27";
+            req.url = u;
+
+            deepIdx = (deepIdx + 1) % DEEP_N; // advance round-robin for the next poll
+            return true;
+        }
         default:
             return false;
     }
@@ -125,9 +190,13 @@ bool SpaceFeedClient::BuildRequest(int feedIdx, SpaceFetchRequest& req) const
 int SpaceFeedClient::FeedForEndpoint(space::SpaceEndpoint e)
 {
     switch (e) {
-        case space::SpaceEndpoint::Iss:    return F_ISS;
-        case space::SpaceEndpoint::Launch: return F_LAUNCH;
-        case space::SpaceEndpoint::Kp:     return F_KP;
+        case space::SpaceEndpoint::Iss:       return F_ISS;
+        case space::SpaceEndpoint::Launch:    return F_LAUNCH;
+        case space::SpaceEndpoint::Kp:        return F_KP;
+        case space::SpaceEndpoint::Dsn:       return F_DSN;
+        case space::SpaceEndpoint::DeepSpace: return F_DEEPSPACE;
+        case space::SpaceEndpoint::Flare:     return F_FLARE;
+        case space::SpaceEndpoint::Humans:    return F_HUMANS;
     }
     return F_ISS;
 }
@@ -161,6 +230,22 @@ void SpaceFeedClient::ApplyResult(const SpaceFetchResult& res)
         case space::SpaceEndpoint::Kp:
             wx = res.wx;
             break;
+        case space::SpaceEndpoint::Dsn:
+            dsn = res.dsn;
+            break;
+        case space::SpaceEndpoint::DeepSpace:
+            if (res.targetIdx >= 0 && res.targetIdx < (int)deepTargets.size()) {
+                const String nm = deepTargets[res.targetIdx].name; // preserve the friendly name
+                deepTargets[res.targetIdx] = res.deepTarget;
+                deepTargets[res.targetIdx].name = nm;
+            }
+            break;
+        case space::SpaceEndpoint::Flare:
+            flare = res.flare;
+            break;
+        case space::SpaceEndpoint::Humans:
+            crew = res.crew;
+            break;
     }
 
     // One-line confirmation the first time each feed lands (handy for field/serial diagnostics).
@@ -180,6 +265,22 @@ void SpaceFeedClient::ApplyResult(const SpaceFetchResult& res)
             case space::SpaceEndpoint::Kp:
                 Serial.printf("[space] Kp ok: %.2f (%u samples)\n", wx.kp, (unsigned)wx.history.size());
                 break;
+            case space::SpaceEndpoint::Dsn:
+                Serial.printf("[space] DSN ok: %u active links\n", (unsigned)dsn.links.size());
+                break;
+            case space::SpaceEndpoint::DeepSpace:
+                if (res.targetIdx >= 0 && res.targetIdx < (int)deepTargets.size())
+                    Serial.printf("[space] deepspace ok: %s %.2f AU\n",
+                                  deepTargets[res.targetIdx].name.c_str(),
+                                  deepTargets[res.targetIdx].distanceAu);
+                break;
+            case space::SpaceEndpoint::Flare:
+                Serial.printf("[space] flare ok: %s (%.1e W/m2)\n",
+                              space::XrayClass(flare.fluxWm2).c_str(), flare.fluxWm2);
+                break;
+            case space::SpaceEndpoint::Humans:
+                Serial.printf("[space] humans ok: %d in space\n", crew.number);
+                break;
         }
     }
 }
@@ -198,6 +299,7 @@ void SpaceFeedClient::RunWorker()
 
         SpaceFetchResult* res = new SpaceFetchResult();
         res->endpoint = req->endpoint;
+        res->targetIdx = req->targetIdx;
         Fetch(http, *req, *res);
         delete req;
 
@@ -208,6 +310,15 @@ void SpaceFeedClient::RunWorker()
 void SpaceFeedClient::Fetch(HttpRequestManager& http,
                             const SpaceFetchRequest& req, SpaceFetchResult& res)
 {
+    // DSN is XML over a Content-Length response: fetch as (yielding) text and scan it.
+    if (req.endpoint == space::SpaceEndpoint::Dsn) {
+        const HttpResult r = http.Get(req.url, req.params, req.headers);
+        if (!r.success || r.statusCode < 200 || r.statusCode >= 300) { res.ok = false; return; }
+        space::ParseDsn(r.response, res.dsn, DSN_LINK_CAP);
+        res.ok = true; // a successful fetch is valid even with zero active links
+        return;
+    }
+
     JsonDocument doc;
     const HttpResult r = http.GetJson(req.url, doc, req.params, req.headers);
     if (!r.success || r.statusCode < 200 || r.statusCode >= 300) {
@@ -228,5 +339,29 @@ void SpaceFeedClient::Fetch(HttpRequestManager& http,
             // SWPC serves a bare JSON array (of {time_tag, Kp, ...} objects), not an object root.
             res.ok = space::ParseKp(doc.as<JsonArrayConst>(), res.wx, KP_HISTORY);
             break;
+        case space::SpaceEndpoint::DeepSpace: {
+            // Horizons format=json wraps the OBSERVER table text in "result"; scan its $$SOE line.
+            const char* result = doc["result"] | "";
+            double au = 0, dd = 0;
+            if (space::ParseHorizonsRange(String(result), au, dd)) {
+                res.deepTarget.distanceAu = au;
+                res.deepTarget.speedKms = dd < 0 ? -dd : dd;
+                res.deepTarget.receding = dd >= 0;
+                res.deepTarget.valid = true;
+                res.ok = true;
+            } else {
+                res.ok = false;
+            }
+            break;
+        }
+        case space::SpaceEndpoint::Flare:
+            // SWPC GOES X-ray: a bare JSON array of {time_tag, flux, energy} objects.
+            res.ok = space::ParseFlare(doc.as<JsonArrayConst>(), res.flare);
+            break;
+        case space::SpaceEndpoint::Humans:
+            res.ok = space::ParseCrew(doc.as<JsonObjectConst>(), res.crew, 16);
+            break;
+        case space::SpaceEndpoint::Dsn:
+            break; // handled above
     }
 }

src/space/SpaceFeedClient.h

@@ -43,9 +43,13 @@ class SpaceFeedClient {
     const space::IssState& Iss() const { return iss; }
     const std::vector<space::Launch>& Launches() const { return launches; }
     const space::SpaceWx& Wx() const { return wx; }
+    const space::DsnState& Dsn() const { return dsn; }
+    const std::vector<space::DeepSpaceTarget>& DeepTargets() const { return deepTargets; }
+    const space::Flare& Flare() const { return flare; }
+    const space::Crew& Crew() const { return crew; }
 
 private:
-    enum FeedIdx : uint8_t { F_ISS, F_LAUNCH, F_KP, F_COUNT };
+    enum FeedIdx : uint8_t { F_ISS, F_LAUNCH, F_KP, F_DSN, F_DEEPSPACE, F_FLARE, F_HUMANS, F_COUNT };
     struct Feed {
         uint32_t intervalMs = 0;
         uint32_t nextDueMs = 0;
@@ -60,6 +64,11 @@ class SpaceFeedClient {
     space::IssState iss;
     std::vector<space::Launch> launches;
     space::SpaceWx wx;
+    space::DsnState dsn;
+    std::vector<space::DeepSpaceTarget> deepTargets; // one per tracked probe, sized in Begin()
+    int deepIdx = 0;                                 // DeepSpace round-robin cursor (one target per poll)
+    space::Flare flare;
+    space::Crew crew;
 
     bool firstLogged[F_COUNT] = {}; // log a one-line summary the first time each feed lands
 
@@ -75,7 +84,7 @@ class SpaceFeedClient {
                       const space::SpaceFetchRequest& req, space::SpaceFetchResult& res);
 
     int PickDueFeed(uint32_t now) const;               // most-overdue ready feed, or -1
-    bool BuildRequest(int feedIdx, space::SpaceFetchRequest& req) const;
+    bool BuildRequest(int feedIdx, space::SpaceFetchRequest& req); // non-const: advances deepIdx
     void ApplyResult(const space::SpaceFetchResult& res);
     static int FeedForEndpoint(space::SpaceEndpoint e);
 };