working code but still WIP refactors in the background

Author: Bvngee

.clang-format

@@ -5,3 +5,4 @@ AllowShortIfStatementsOnASingleLine: Always
 AllowShortBlocksOnASingleLine: Always
 IndentAccessModifiers: false
 AccessModifierOffset: -4
+AlignAfterOpenBracket: BlockIndent # DontAlign

Telemetry-Main/CMakeLists.txt

@@ -15,11 +15,15 @@ add_library(libradio STATIC ../XBeeRadio/libradio/src/radio.cpp)
 target_include_directories(libradio PUBLIC ../XBeeRadio/libradio/src/)
 target_link_libraries(libradio mbed-os)
 
-add_library(BT817Q STATIC ./dash/BT817Q.cpp ./dash/layouts.cpp)
-target_include_directories(BT817Q PUBLIC ./dash)
-target_link_libraries(BT817Q mbed-core-flags)
+add_library(dash STATIC ./dash/BT817Q.cpp ./dash/layouts.cpp)
+target_include_directories(dash PUBLIC ./dash)
+target_link_libraries(dash mbed-core-flags)
+
+add_library(fsdaq STATIC ./fsdaq/file_batch_writer.cpp) # ./fsdaq/can_processor_generated.cpp
+target_include_directories(fsdaq PUBLIC ./fsdaq)
+target_link_libraries(fsdaq mbed-core-flags)
 
 set(CMAKE_CXX_STANDARD 20)
 add_executable(${PROJECT_NAME} main.cpp VehicleStateManager.cpp)
-target_link_libraries(${PROJECT_NAME} mbed-os libradio mbed-storage-sd mbed-storage-fat BT817Q)
+target_link_libraries(${PROJECT_NAME} mbed-os dash fsdaq libradio mbed-storage-sd mbed-storage-fat)
 mbed_set_post_build(${PROJECT_NAME})

Telemetry-Main/fsdaq/can_processor_generated.cpp

@@ -15,7 +15,8 @@ void CANProcessor::process_message() {
         break;
 
     case SME_RPDO_Throttle_Demand:
-        uint16_t raw_SME_THROTL_TorqueDemand;
+        uint16_t raw_SME_THROTL_TorqueDemand = 0;
+        raw_SME_THROTL_TorqueDemand |= msg.data[0] & 0x07f;
 
         uint16_t raw_SME_THROTL_MaxSpeed;
 

Telemetry-Main/fsdaq/file_batch_writer.cpp

@@ -1,28 +1,20 @@
 #include "encoder_generated.hpp"
+#include "file_batch_writer.hpp"
 
 namespace fsdaq {
 
-class FileBatchWriter {
-public:
-    FileBatchWriter(FILE *file)
+    FileBatchWriter::FileBatchWriter(FILE *file)
         : curr_batch(std::make_unique<DataBatch>()), fp(file) {}
 
-    void append_row(DataRow next_row) {
+    void FileBatchWriter::append_row(DataRow& next_row) {
+        // printf("setRow()\n");
         curr_batch->setRow(next_row, row_idx);
 
         row_idx++;
         if (row_idx == ROWS_PER_BATCH) {
-            write_fsdaq_batch(curr_batch.get(), fp);
+            write_fsdaq_batch(curr_batch.get(), this->fp);
             row_idx = 0;
         }
     }
 
-private:
-    std::unique_ptr<DataBatch> curr_batch;
-
-    int row_idx = 0;
-
-    FILE *fp;
-};
-
 } // namespace fsdaq

Telemetry-Main/fsdaq/file_batch_writer.hpp

@@ -8,7 +8,7 @@ class FileBatchWriter {
 public:
     FileBatchWriter(FILE *file);
 
-    void append_row(DataRow next_row);
+    void append_row(DataRow& next_row);
 
 private:
     std::unique_ptr<DataBatch> curr_batch;

Telemetry-Main/main.cpp

@@ -1,11 +1,10 @@
-#include "BT817Q.hpp"
 #include "FATFileSystem.h"
 #include "SDBlockDevice.h"
 #include "Ticker.h"
 #include "VehicleStateManager.hpp"
+#include "dash/layouts.h"
 #include "fsdaq/encoder_generated.hpp"
-#include "fsdaq/writer.hpp"
-#include "layouts.h"
+#include "fsdaq/file_batch_writer.hpp"
 #include "radio.hpp"
 #include <stdbool.h>
 #include <string>
@@ -43,7 +42,8 @@ SDBlockDevice sd{
 FATFileSystem fs{"sd"};
 
 FILE *sd_fp;
-fsdaq::FileBatchWriter data_writer{sd_fp};
+// fsdaq::FileBatchWriter data_writer{sd_fp};
+fsdaq::DataRow current_row{};
 
 Layouts eve(PC_12, PC_11, PC_10, PD_2, PB_7, PC_13, EvePresets::CFA800480E3);
 
@@ -125,8 +125,7 @@ void update_dash() {
     const VehicleState vsm_state = vsm.getState();
     uint8_t max_temp = 0;
 
-    for (auto [TEMPS_CELL0, TEMPS_CELL1, TEMPS_CELL2, TEMPS_CELL3, TEMPS_CELL4,
-               TEMPS_CELL5] : vsm_state.accSegTemps) {
+    for (auto [TEMPS_CELL0, TEMPS_CELL1, TEMPS_CELL2, TEMPS_CELL3, TEMPS_CELL4, TEMPS_CELL5] : vsm_state.accSegTemps) {
         max_temp =
             max(TEMPS_CELL0,
                 max(TEMPS_CELL1,
@@ -171,55 +170,49 @@ void update_dash() {
     // eve.drawStandardLayout2(params);
 
     eve.drawLayout3(
-        Faults{false,
-               static_cast<bool>(!vsm_state.accStatus.PRECHARGE_DONE),
-               static_cast<bool>(!vsm_state.accStatus.SHUTDOWN_STATE)},
-        static_cast<float>(vsm_state.accPower.PACK_VOLTAGE / 100.0), max_temp,
-        vsm_state.smeTemp.CONTROLLER_TEMP, vsm_state.smeTemp.MOTOR_TEMP,
+        Faults{false, static_cast<bool>(!vsm_state.accStatus.PRECHARGE_DONE), static_cast<bool>(!vsm_state.accStatus.SHUTDOWN_STATE)},
+        static_cast<float>(vsm_state.accPower.PACK_VOLTAGE / 100.0),
+        max_temp,
+        vsm_state.smeTemp.CONTROLLER_TEMP,
+        vsm_state.smeTemp.MOTOR_TEMP,
         vsm_state.accPower.SOC,
         static_cast<float>(vsm_state.pdbPowerA.GLV_VOLTAGE),
-        static_cast<bool>(vsm_state.etcStatus.RTD), n);
+        static_cast<bool>(vsm_state.etcStatus.RTD),
+        n
+    );
 }
 
-// void update_data() {
-//
-// };
-
 int main() {
-    mbed_can.attach([]() { queue.call(&process_can) }, interface::can::RxIrq);
-
     printf("Hello world\n");
 
+    ThisThread::sleep_for(500ms);
+
     // Initializing Dash
-    if (ENABLE_DASH) init_dash();
+    if (ENABLE_DASH) { init_dash(); update_dash(); }
 
     // Initializing SD card
     if (ENABLE_SD) init_sd();
 
-    // int radio_temp = radio.get_temp();
-    // if (radio_temp >= 70 || radio_temp <= 10) {
-    //     printf("Radio temperature returned an unrealistic value.
-    //     Disabling.\n"); state.radio_on = false;
-    // }
-
-    // int x = 0;
-    // Timer t;
-    // t.start();
-    // auto p = Layouts::StandardLayoutParams{.faults= Faults{}, .soc = 3};
-    // //for testing
+    fsdaq::FileBatchWriter data_writer{sd_fp};
 
     // event_queue.call_every(RADIO_UPDATE_HZ, &update_radio())
+
     if (ENABLE_SD) {
         // TODO::::
-        queue.call_every(SD_UPDATE_HZ, []() { data_writer.append_row(current_row) });
+        queue.call_every(SD_UPDATE_HZ, [&data_writer]() { data_writer.append_row(current_row); });
+
+        // mbed_can.attach(
+        //     []() { queue.call([]() { data_writer.append_row(current_row); }); },
+        //     interface::can::RxIrq
+        // );
     }
     if (ENABLE_DASH) {
         queue.call_every(DASH_UPDATE_HZ, &update_dash);
     }
     Timer t;
     t.start();
     queue.call_every(1ms, [&t]() {
-        printf("%fms\n", t.elapsed_time().count() / 1000.0f);
+        // printf("%fms\n", t.elapsed_time().count() / 1000.0f);
         t.reset();
         vsm.update();
         const VehicleState state = vsm.getState();
@@ -520,6 +513,5 @@ int main() {
         // current_row.SMPC_SER_FIRMWARE_VER
     });
     queue.call_every(100ms, []() { n++; });
-    queue.call()
-        queue.dispatch_forever();
+    queue.dispatch_forever();
 }

Telemetry-Main/scripts/dbc_to_cpp.py

@@ -136,49 +136,50 @@ def generate_encoder_hpp(db: cantools.db.Database, rows_per_batch: int = 80):
     out_file.close()
     template_file.close()
 
-def generate_can_processor_hpp(db: cantools.db.Database):
-    out_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.hpp", "w")
-    template_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.hpp.in", "r")
-    template = template_file.read()
-
-    can_message_ids = []
-    for msg in db.messages:
-        can_message_ids.append(" "*4 + f"{msg.name} = {hex(msg.frame_id)},")
-
-    template = template.replace("@MESSAGE_IDS@", "\n".join(can_message_ids))
-
-    out_file.write(template)
-    out_file.close()
-    template_file.close()
-
-def generate_can_processor_cpp(db: cantools.db.Database):
-    out_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.cpp", "w")
-    template_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.cpp.in", "r")
-    template = template_file.read()
-
-    can_message_processing = []
-    for msg in db.messages:
-        msg_processing_lines = [" "*4 + f"case {msg.name}:"]
-        for signal in msg.signals:
-            if signal.is_float:
-                raise ValueError("can't handle float signals yet!")
-            # msg_processing_lines.append(" "*8 + f"current_row->{signal.name} = 100;")
-            raw_buf_type = f"{signal.is_signed and "" or "u"}int{8 * math.ceil(signal.length / 8)}_t"
-            byte_offset = signal.start / 8
-            bit_offset_in_byte = signal.start % 8
-            # underlying_bytes = 
-            last_byte_idx = math.ceil(signal.length / 8)
-            msg_processing_lines.append(" "*8 + f"{raw_buf_type} raw_{signal.name};");
-
-            msg_processing_lines.append("");
-        msg_processing_lines.append(" "*8 + "break;")
-        can_message_processing.append("\n".join(msg_processing_lines))
-
-    template = template.replace("@CAN_MESSAGE_PROCESSING@", "\n\n".join(can_message_processing))
-
-    out_file.write(template)
-    out_file.close()
-    template_file.close()
+# def generate_can_processor_hpp(db: cantools.db.Database):
+#     out_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.hpp", "w")
+#     template_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.hpp.in", "r")
+#     template = template_file.read()
+#
+#     can_message_ids = []
+#     for msg in db.messages:
+#         can_message_ids.append(" "*4 + f"{msg.name} = {hex(msg.frame_id)},")
+#
+#     template = template.replace("@MESSAGE_IDS@", "\n".join(can_message_ids))
+#
+#     out_file.write(template)
+#     out_file.close()
+#     template_file.close()
+
+# def generate_can_processor_cpp(db: cantools.db.Database):
+#     out_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.cpp", "w")
+#     template_file = open(Path(__file__).parent.parent / "fsdaq" / "can_processor_generated.cpp.in", "r")
+#     template = template_file.read()
+#
+#     can_message_processing = []
+#     for msg in db.messages:
+#         msg_processing_lines = [" "*4 + f"case {msg.name}:"]
+#         for signal in msg.signals:
+#             if signal.is_float:
+#                 raise ValueError("can't handle float signals yet!")
+#             # msg_processing_lines.append(" "*8 + f"current_row->{signal.name} = 100;")
+#             raw_buf_type = f"{signal.is_signed and "" or "u"}int{8 * math.ceil(signal.length / 8)}_t"
+#             byte_offset = math.floor(signal.start / 8)
+#             end_byte_offset = math.floor(signal.start + signal.length / 8)
+#             bit_offset_in_byte = signal.start % 8
+#             # underlying_bytes = 
+#             last_byte_idx = math.ceil(signal.length / 8)
+#             msg_processing_lines.append(" "*8 + f"{raw_buf_type} raw_{signal.name};");
+#
+#             msg_processing_lines.append("");
+#         msg_processing_lines.append(" "*8 + "break;")
+#         can_message_processing.append("\n".join(msg_processing_lines))
+#
+#     template = template.replace("@CAN_MESSAGE_PROCESSING@", "\n\n".join(can_message_processing))
+#
+#     out_file.write(template)
+#     out_file.close()
+#     template_file.close()
 
 
 
@@ -189,17 +190,9 @@ def generate_can_processor_cpp(db: cantools.db.Database):
     db = cantools.db.Database()
     db.add_dbc_file("../CANbus.dbc")
 
-
-    # for k, v in signal_to_datatype.items():
-    #     v = str(v).removeprefix("(DataType(")
-    #     v = v.removesuffix("),)")
-    #     print("{:33s} {}".format(k, v))
-
-    # n = 50
-    # generate_nanoarrow_code({k: signal_to_datatype[k] for k in list(signal_to_datatype)[:n]}, 8)
     generate_encoder_hpp(db, rows_per_batch=80)
-    generate_can_processor_hpp(db)
-    generate_can_processor_cpp(db)
+    # generate_can_processor_hpp(db)
+    # generate_can_processor_cpp(db)