Successful meta-log build. Untested

Thank you mpkarpov for the starter code, that is helping plenty

Author: MichaelCyrwus

MIDAS/src/data_logging.h

@@ -41,6 +41,8 @@ class MultipleLogSink : public LogSink {
     };
 
     void write(const uint8_t* data, size_t size) override {};
+
+    void write_meta(const uint8_t* data, size_t size) override {};
 };
 
 template<typename Sink, typename... Sinks>
@@ -61,6 +63,11 @@ class MultipleLogSink<Sink, Sinks...> : public LogSink {
         sinks.write(data, size);
     };
 
+    void write_meta(const uint8_t* data, size_t size) override {
+        sink.write(data, size);
+        sinks.write(data, size);
+    };
+
 private:
     Sink sink;
     MultipleLogSink<Sinks...> sinks;

MIDAS/src/data_logging_meta.cpp

@@ -0,0 +1,32 @@
+#include "data_logging_meta.h"
+#include "log_format.h"
+#include "log_checksum.h"
+
+/*
+
+Queue<MetaLogging::MetaLogEntry> _q;
+
+bool MetaLogging::get_queued(MetaLogEntry* out) { return _q.receive(out); }
+
+void log_event(MetaDataCode event_type, uint32_t timestamp) {
+    MetaLogging::MetaLogEntry entry{event_type, 0, 0};
+    entry.size = sizeof(uint32_t);
+    memcpy(entry.data, &timestamp, entry.size);
+    _q.send(entry);
+}
+
+template <typename T>
+void log_data(MetaDataCode data_type, const T& data) {
+
+    // double check...
+    static_assert(sizeof(T) <= META_LOGGING_MAX_SIZE, "Datatype for log_data too large");
+
+    MetaLogEntry entry{data_type, 0, 0};
+    entry.size = sizeof(T);
+    memcpy(entry.data, &data, entry.size);
+    _q.send(entry);
+
+    
+}
+
+*/

MIDAS/src/data_logging_meta.h

@@ -1,5 +1,8 @@
 #pragma once
-#include "rocket_state.h"
+//#include "rocket_state.h"
+//#include "errors.h"
+
+/*
 
 #define META_LOGGING_MAX_SIZE 64
 
@@ -28,27 +31,12 @@ struct MetaLogging {
         size_t size;
     };
 
-    Queue<MetaLogEntry> _q;
-
-    bool get_queued(MetaLogEntry* out) { return _q.receive(out); }
+    bool get_queued(MetaLogEntry* out);
 
-    void log_event(MetaDataCode event_type, uint32_t timestamp) {
-        MetaLogEntry entry{event_type, 0, 0};
-        entry.size = sizeof(uint32_t);
-        memcpy(entry.data, &timestamp, entry.size);
-        _q.send(entry);
-    }
+    void log_event(MetaDataCode event_type, uint32_t timestamp);
 
     template <typename T>
-    void log_data(MetaDataCode data_type, const T& data) {
-
-        // double check...
-        static_assert(sizeof(T) <= META_LOGGING_MAX_SIZE, "Datatype for log_data too large");
-
-        MetaLogEntry entry{data_type, 0, 0};
-        entry.size = sizeof(T);
-        memcpy(entry.data, &data, entry.size);
-        _q.send(entry);
-    }
-
+    void log_data(MetaDataCode data_type, const T& data);
 };
+
+*/

MIDAS/src/finite-state-machines/fsm.h

@@ -32,7 +32,7 @@ class FSM {
 public:
     FSM() = default;
 
-    FSMState tick_fsm(FSMState& curr_state, StateEstimate state_estimate, CommandFlags& commands);
+    //  FSMState tick_fsm(FSMState& curr_state, StateEstimate state_estimate, CommandFlags& commands);
 
     // Constructor for the metadata
     // Created so that FSMState, StateEstimate, and CommandFlags objects can supercede the mutex lock

MIDAS/src/hardware/SDLog.cpp

@@ -60,6 +60,8 @@ void SDSink::write(const uint8_t* data, size_t size) {
             unflushed_bytes = 0;
         }
     }
+
+    return;
 }
 
 void SDSink::write_meta(const uint8_t* data, size_t size) {
@@ -68,4 +70,6 @@ void SDSink::write_meta(const uint8_t* data, size_t size) {
     file.write(data, size);
     file.write('\n');
     file.flush(); // Meta writes are infrequent, so flushing is OK.
+
+    return;
 }

MIDAS/src/hardware/main.cpp

@@ -14,7 +14,7 @@
  */
 
 // #ifdef IS_SUSTAINER
-// MultipleLogSink<EMMCSink> sinks;
+//MultipleLogSink<EMMCSink> sinks;
 MultipleLogSink<SDSink> sinks;
 // #else
 // MultipleLogSink<> sinks;

MIDAS/src/rocket_state.h

@@ -6,10 +6,6 @@
 #include "hal.h"
 #include "Buffer.h"
 
-// temprary macro
-// originally declared in data_loggng_meta.h
-#define META_LOGGING_MAX_SIZE 64
-
 /** 
  * @brief The RocketState struct stores everything that is needed by more than one system/thread of the Rocket.
  *
@@ -176,36 +172,35 @@ enum MetaDataCode {
 };
 
 struct MetaLogging {
-    private:
-    struct MetaLogEntry {
-        MetaDataCode log_type;
-        char data[64];
-        size_t size;
-    };
-
-    Queue<MetaLogEntry> _q;
-
     public:
-    bool get_queued(MetaLogEntry* out) { return _q.receive(out); }
-
-    void log_event(MetaDataCode event_type, uint32_t timestamp) {
-        MetaLogEntry entry{event_type, 0, 0};
-        entry.size = sizeof(uint32_t);
-        memcpy(entry.data, &timestamp, entry.size);
-        _q.send(entry);
-    }
-
-    template <typename T>
-    void log_data(MetaDataCode data_type, const T& data) {
-
-        // double check...
-        static_assert(sizeof(T) <= META_LOGGING_MAX_SIZE, "Datatype for log_data too large");
-
-        MetaLogEntry entry{data_type, 0, 0};
-        entry.size = sizeof(T);
-        memcpy(entry.data, &data, entry.size);
-        _q.send(entry);
-    }
+        struct MetaLogEntry {
+            MetaDataCode log_type;
+            size_t size;
+            char data[META_LOGGING_MAX_SIZE];
+        };
+
+        Queue<MetaLogEntry> _q;
+
+        bool get_queued(MetaLogEntry* out) { return _q.receive(out); }
+
+        void log_event(MetaDataCode event_type, uint32_t timestamp) {
+            MetaLogEntry entry{event_type, 0, 0};
+            entry.size = sizeof(uint32_t);
+            memcpy(entry.data, &timestamp, entry.size);
+            _q.send(entry);
+        }
+
+        template <typename T>
+        void log_data(MetaDataCode data_type, const T& data) {
+
+            // double check...
+            static_assert(sizeof(T) <= META_LOGGING_MAX_SIZE, "Datatype for log_data too large");
+
+            MetaLogEntry entry{data_type, 0, 0};
+            entry.size = sizeof(T);
+            memcpy(entry.data, &data, entry.size);
+            _q.send(entry);
+        }
 };
 
 /**

MIDAS/src/systems.cpp

@@ -28,8 +28,9 @@ DECLARE_THREAD(logger, RocketSystems* arg) {
         arg->rocket_data.log_latency.tick();
         meta_delay_ctr++;
 
+        MetaLogging::MetaLogEntry entry;
+
         if (meta_delay_ctr >= 100) {
-            MetaLogging::MetaLogEntry entry;
             if(arg->meta_logging.get_queued(&entry)) {
                 uint8_t buf[72];
                 size_t total_size = sizeof(MetaDataCode) + entry.size;
@@ -201,7 +202,7 @@ DECLARE_THREAD(fsm, RocketSystems* arg) {
         CommandFlags& telemetry_commands = arg->rocket_data.command_flags;
         double current_time = pdTICKS_TO_MS(xTaskGetTickCount());
 
-        FSMState next_state = fsm.tick_fsm(current_state, state_estimate, telemetry_commands);
+        FSMState next_state = fsm.tick_fsm(arg->rocket_data);
 
         arg->rocket_data.fsm_state.update(next_state);
         if(current_state != next_state) {fsm_transitioned_to(next_state, current_state, arg, current_time);}