Merge pull request #129 from strykeforce/log-lights

Increment frame log seq number when lights toggled

Author: jhh

daemon/.idea/cmake.xml

@@ -1,2 +1,2 @@
 set noparent
-filter=-build/include_order,-build/include_subdir,-runtime/references,-build/c++11,-whitespace/indent
+filter=-build/include_order,-build/include_subdir,-runtime/references,-build/c++11,-whitespace/indent,-readability/nolint

daemon/CPPLINT.cfg

@@ -34,27 +34,26 @@ class On : public Camera<inum> {
         std::rethrow_exception(std::current_exception());
       }
     });
-    spdlog::info("Camera<{}{}> on", DEADEYE_UNIT, inum);
+    base::pipeline_runner_.SetLoggingEnabled(true);
+    spdlog::info("Camera<{}> on", CameraId(inum));
   }
 
   void react(CameraOff const&) final {
     Lights<inum>::dispatch(LightsOff());
-    base::pipeline_runner_.Stop();
 
-    // future will not be valid at start-up since pipeline task not started yet
-    if (base::pipeline_future_.valid()) {
-      try {
-        base::pipeline_future_.get();
-      } catch (std::exception const& e) {
-        base::error_ = e.what();
-        base::has_error_ = false;  // don't retrigger in controller
-        base::template transit<camera::Error<inum>>();
-        return;
-      }
-    }
     base::template transit<camera::Off<inum>>();
   }
 
+  void react(LightsOff const&) final {
+    base::pipeline_runner_.SetLoggingEnabled(false);
+    spdlog::debug("Camera<{}> stop logging", CameraId(inum));
+  }
+
+  void react(LightsOn const&) final {
+    base::pipeline_runner_.SetLoggingEnabled(true);
+    spdlog::debug("Camera<{}> start logging", CameraId(inum));
+  }
+
   void exit() final { base::SetStatus(DE_ON, false); }
 };
 
@@ -67,7 +66,21 @@ class Off : public Camera<inum> {
 
   void entry() final {
     base::SetStatus(DE_OFF, true);
-    spdlog::info("Camera<{}{}> off", DEADEYE_UNIT, inum);
+    base::pipeline_runner_.SetLoggingEnabled(false);
+    base::pipeline_runner_.Stop();
+
+    // future will not be valid at start-up since pipeline task not started yet
+    if (base::pipeline_future_.valid()) {
+      try {
+        base::pipeline_future_.get();
+      } catch (std::exception const& e) {
+        base::error_ = e.what();
+        base::has_error_ = false;  // don't re-trigger in controller
+        base::template transit<camera::Error<inum>>();
+        return;
+      }
+    }
+    spdlog::info("Camera<{}> off", CameraId(inum));
   }
 
   void react(CameraOn const&) final {
@@ -88,20 +101,20 @@ class Error : public Camera<inum> {
   void entry() final {
     base::SetStatus(DE_ERROR, true);
     Lights<inum>::dispatch(LightsOff());
-    spdlog::error("Camera<{}{}> error: {}", DEADEYE_UNIT, inum, base::error_);
+    spdlog::error("Camera<{}> error: {}", CameraId(inum), base::error_);
   }
 
   void react(CameraOn const&) final {
     base::SetStatus(DE_ON, false);
-    spdlog::warn("Camera<{}{}> attempting to turn on camera in error state: {}",
-                 DEADEYE_UNIT, inum, base::error_);
+    spdlog::warn("Camera<{}> attempting to turn on camera in error state: {}",
+                 CameraId(inum), base::error_);
   }
 
   void react(CameraOff const&) final {
     base::SetStatus(DE_OFF, false);
     spdlog::warn(
         "Camera<{}{}> attempting to turn off camera in error state: {}",
-        DEADEYE_UNIT, inum, base::error_);
+        CameraId(inum), base::error_);
   }
 
   void exit() final { base::SetStatus(DE_ERROR, false); }

daemon/src/hardware/camera.cpp

@@ -17,6 +17,7 @@
 #include "config/capture_config.h"
 #include "config/pipeline_config.h"
 #include "config/stream_config.h"
+#include "events.h"
 #include "pipeline/runner.h"
 
 namespace deadeye {
@@ -26,21 +27,6 @@ class Pipeline;
 template <class T>
 using owner [[maybe_unused]] = T;
 
-// ---------------------------------------------------------------------------
-// Events
-//
-struct CameraOn : tinyfsm::Event {};
-struct CameraOff : tinyfsm::Event {};
-struct ConfigCapture : tinyfsm::Event {
-  CaptureConfig config;
-};
-struct ConfigPipeline : tinyfsm::Event {
-  PipelineConfig config;
-};
-struct ConfigStream : tinyfsm::Event {
-  StreamConfig config;
-};
-
 // ---------------------------------------------------------------------------
 // Camera FSM
 //
@@ -69,6 +55,8 @@ class Camera : public tinyfsm::Fsm<Camera<inum>> {
 
   [[maybe_unused]] virtual void react(CameraOn const&) {}
   [[maybe_unused]] virtual void react(CameraOff const&) {}
+  [[maybe_unused]] virtual void react(LightsOn const&) {}
+  [[maybe_unused]] virtual void react(LightsOff const&) {}
   [[maybe_unused]] virtual void react(ConfigCapture const& c) {
     Camera<inum>::pipeline_runner_.Configure(c.config);
   }
@@ -97,7 +85,7 @@ class Camera : public tinyfsm::Fsm<Camera<inum>> {
 
 // state variable definitions
 template <int inum>
-Runner Camera<inum>::pipeline_runner_;
+Runner Camera<inum>::pipeline_runner_;  // NOLINT(cert-err58-cpp)
 
 template <int inum>
 std::future<void> Camera<inum>::pipeline_future_;

daemon/src/hardware/camera.h

@@ -0,0 +1,28 @@
+// Copyright (c) 2022 Stryke Force FRC 2767
+#pragma once
+
+#include <tinyfsm.hpp>
+
+#include "config/capture_config.h"
+#include "config/pipeline_config.h"
+#include "config/stream_config.h"
+
+namespace deadeye {
+struct CameraOn : tinyfsm::Event {};
+struct CameraOff : tinyfsm::Event {};
+
+struct LightsOn : tinyfsm::Event {};
+struct LightsOff : tinyfsm::Event {};
+struct LightsBlink : tinyfsm::Event {};
+
+struct ConfigCapture : tinyfsm::Event {
+  CaptureConfig config;
+};
+struct ConfigPipeline : tinyfsm::Event {
+  PipelineConfig config;
+};
+struct ConfigStream : tinyfsm::Event {
+  StreamConfig config;
+};
+
+}  // namespace deadeye

daemon/src/hardware/events.h

@@ -8,6 +8,8 @@
 #include <thread>
 #include <tinyfsm.hpp>
 
+#include "camera.h"
+
 namespace {
 using namespace std::literals::  // NOLINT(build/namespaces_literals)
     chrono_literals;
@@ -29,7 +31,7 @@ class On : public Lights<inum> {
 
   void entry() override {
     base::SetStatus(DE_ON, true);
-    spdlog::info("Lights<{}{}> on", DEADEYE_UNIT, inum);
+    spdlog::info("Lights<{}> on", CameraId(inum));
     base::led_.On();
     base::on_ = true;
   }
@@ -39,6 +41,7 @@ class On : public Lights<inum> {
   }
 
   void react(LightsOff const&) override {
+    Camera<inum>::dispatch(LightsOff());
     base::template transit<lights::Off<inum>>();
   }
 
@@ -55,18 +58,18 @@ class Blinking : public Lights<inum> {
     base::cancel_task_ = false;
     base::task_future_ = std::async(std::launch::async, [] {
       while (true) {
-        spdlog::trace("Lights<{}{}> on", DEADEYE_UNIT, inum);
+        spdlog::trace("Lights<{}> on", CameraId(inum));
         base::led_.On();
         std::this_thread::sleep_for(kBlinkPeriod);
         if (base::cancel_task_.load()) break;
 
-        spdlog::trace("Lights<{}{}> off", DEADEYE_UNIT, inum);
+        spdlog::trace("Lights<{}> off", CameraId(inum));
         base::led_.Off();
         std::this_thread::sleep_for(kBlinkPeriod);
         if (base::cancel_task_.load()) break;
       }
     });
-    spdlog::info("Lights<{}{}> blink", DEADEYE_UNIT, inum);
+    spdlog::info("Lights<{}> blink", CameraId(inum));
   }
 
 #pragma clang diagnostic push
@@ -77,8 +80,8 @@ class Blinking : public Lights<inum> {
       try {
         base::task_future_.get();
       } catch (std::exception const& e) {
-        spdlog::error("Lights<{}{}> error while cancelling blink: {}",
-                      DEADEYE_UNIT, inum, e.what());
+        spdlog::error("Lights<{}> error while cancelling blink: {}",
+                      CameraId(inum), e.what());
       }
     }
   }
@@ -103,12 +106,13 @@ class Off : public Lights<inum> {
 
   void entry() override {
     base::SetStatus(DE_OFF, true);
-    spdlog::info("Lights<{}{}> off", DEADEYE_UNIT, inum);
+    spdlog::info("Lights<{}> off", CameraId(inum));
     base::led_.Off();
     base::on_ = false;
   }
 
   void react(LightsOn const&) override {
+    Camera<inum>::dispatch(LightsOn());
     base::template transit<lights::On<inum>>();
   }
 

daemon/src/hardware/lights.cpp

@@ -12,15 +12,10 @@
 #include <tinyfsm.hpp>
 
 #include "config.h"
+#include "events.h"
 #include "led_drive.h"
 
 namespace deadeye {
-// ---------------------------------------------------------------------------
-// Events
-//
-struct LightsOn : tinyfsm::Event {};
-struct LightsOff : tinyfsm::Event {};
-struct LightsBlink : tinyfsm::Event {};
 
 // ---------------------------------------------------------------------------
 // Lights FSM

daemon/src/hardware/lights.h

@@ -41,6 +41,7 @@ class FrameLogger {
   }
 
   void Run() {
+    cancel_ = false;
     future_ = std::async(std::launch::async, &logger::FrameLoggerBase::Run,
                          logger_.get());
     spdlog::debug("Logger::Run starting async logging task");
@@ -54,7 +55,7 @@ class FrameLogger {
 
   void Stop() {
     cancel_ = true;
-    future_.wait();
+    if (future_.valid()) future_.wait();
     spdlog::debug("Logger::Stop stopped async logging task");
   }
 

daemon/src/log/frame_logger.h

@@ -6,7 +6,6 @@
 #include <sys/stat.h>
 
 #include <string>
-#include <utility>
 
 using ::deadeye::logger::FrameLoggerBase;
 
@@ -16,20 +15,26 @@ FrameLoggerBase::FrameLoggerBase(const int inum, const FrameLogConfig& config,
                                  std::atomic<bool>& cancel)
     : id_{CameraId(inum)},
       enabled_{config.fps > 0 && CheckMount(config) && CheckDir(config)},
+      state_{state},
       queue_(queue),
       cancel_{cancel},
       client_logger_{inum} {
-  template_ =
-      fmt::format("{}/{}/{}-{{}}.jpg", config.path, id_, state.sequence++);
+  base_template_ =
+      fmt::format("{}/{}/{{:04d}}-{{{{:04d}}}}.jpg", config.path, id_);
+  spdlog::debug("FrameLoggerBase<{}>: base_template_ = {}", id_,
+                base_template_);
 }
 
 void FrameLoggerBase::Run() {
-  client_logger_.Info(
-      fmt::format("FrameLogger<{}>: first log {}", id_, GetFrameImagePath(1)));
+  seq_template_ = fmt::format(base_template_, state_.sequence++);
+  spdlog::debug("FrameLoggerBase<{}>: seq_template_ = {}", id_, seq_template_);
+
+  client_logger_.Info(fmt::format("FrameLoggerBase<{}>: first log {}", id_,
+                                  GetFrameImagePath(1)));
 
   RunLoop();
 
-  client_logger_.Info(fmt::format("FrameLogger<{}>: last log {}", id_,
+  client_logger_.Info(fmt::format("FrameLoggerBase<{}>: last log {}", id_,
                                   GetFrameImagePath(frame_count_ - 1)));
 }
 

daemon/src/log/frame_logger_base.cpp

@@ -39,15 +39,17 @@ class FrameLoggerBase {
   virtual ~FrameLoggerBase() = default;
 
   inline std::string GetFrameImagePath(int frame_count) {
-    return fmt::format(template_, frame_count);
+    return fmt::format(seq_template_, frame_count);
   }
 
   void Run();
 
  protected:
   std::string id_;
   bool enabled_;
-  std::string template_;
+  FrameLoggerState& state_;
+  std::string base_template_;
+  std::string seq_template_;
   int frame_count_{1};
   std::atomic<bool>& cancel_;
   FrameLoggerQueue& queue_;