rename files

rims_app/proto/gpio.proto

@@ -38,6 +38,7 @@ message IngressMessage
 
 message EgressMessage
 {
+	// in response to given request_id
 	optional uint32 request_id = 255;
 	oneof data
 	{

rims_app/proto/log.proto

@@ -4,8 +4,6 @@ import "nanopb.proto";
 package log;
 
 // TODO add error
-// TODO change the message layout so that it has the same structure as other messages
-// TODO add message for controlling LogLevel
 
 enum LogLevel {
 	TRACE = 0;
@@ -23,10 +21,7 @@ message LogLevelRequest
 
 message LogLevelResponse
 {
-	oneof data
-	{ // for compatybility
-		LogLevel logLevel = 1;
-	}
+	LogLevel logLevel = 1;
 };
 
 message LogEntry

rims_app/proto/message.proto

@@ -19,8 +19,9 @@ enum Error {
 	UnknownId = 7;
 }
 
-message ErrorMessage{
-Error error = 1;
+message ErrorMessage
+{
+	Error error = 1;
 }
 
 message Message

rims_app/src/ctrl.cpp

@@ -1,7 +1,6 @@
-#include "power_control.hpp"
+#include "ctrl.hpp"
 
 #include "common.hpp"
-#include "ctrl_pb_helpers.hpp"
 #include "log.hpp"
 #include "proto/ctrl.pb.h"
 #include "zephyr.hpp"
@@ -9,11 +8,9 @@
 
 #include <algorithm>
 #include <cassert>
-#include <chrono>
 #include <concepts>
 #include <cstdint>
 #include <expected>
-#include <variant>
 
 namespace rims {
 

rims_app/src/log.cpp

@@ -5,6 +5,7 @@
 #include <thread>
 
 namespace rims {
+
 K_FIFO_DEFINE(klogFifoQueue);
 fifo_queue<log_EgressMessage, 8> logEgressQueue{klogFifoQueue};
 

rims_app/src/log.hpp

@@ -20,7 +20,7 @@ enum class LogLevel : int { //
     Critical = 5
 };
 
-extern fifo_queue<log_IngressMessage, 2> logIngressFifoQueueBuffer;
+extern fifo_queue<log_IngressMessage, 2> logIngressQueue;
 extern fifo_queue<log_EgressMessage, 8>  logEgressQueue;
 
 static LogLevel g_logLevel = LogLevel::Trace;

rims_app/src/main.cpp

@@ -4,9 +4,9 @@
 #include "messenger.hpp"
 #include "operation.hpp"
 #include "placement_unique_ptr.hpp"
-#include "power_control.hpp"
+#include "ctrl.hpp"
 #include "temperature_measurements.hpp"
-#include "thread_analyzer.hpp"
+#include "utilization.hpp"
 #include "uart.hpp"
 #include "zero_cross_detection.hpp"
 

rims_app/src/messenger.cpp

@@ -1,13 +1,14 @@
 #include "messenger.hpp"
 
 #include "error.hpp"
+#include "function.hpp"
 #include "log.hpp"
 #include "message_type_id.hpp"
 #include "operation.hpp"
 
 #include "config.hpp"
 #include "gpio.hpp"
-#include "power_control.hpp"
+#include "ctrl.hpp"
 #include "temperature_measurements.hpp"
 #include "uart.hpp"
 
@@ -125,8 +126,8 @@ inline std::expected<void, pb::error> skip_bytes(pb_istream_t &stream, std::size
     return {};
 }
 
-inline std::expected<void, pb::error>skip_field(pb_istream_t &stream, pb_wire_type_t wire_type){
-    if(not pb_skip_field(&stream, wire_type)){
+inline std::expected<void, pb::error> skip_field(pb_istream_t &stream, pb_wire_type_t wire_type) {
+    if (not pb_skip_field(&stream, wire_type)) {
         return std::unexpected{read_error{}};
     }
     return {};
@@ -391,7 +392,7 @@ struct SubsystemMessages {
     uint32_t                                   subsystem_id;
     std::reference_wrapper<const pb_msgdesc_t> ingress;
     std::reference_wrapper<const pb_msgdesc_t> egress;
-    uint32_t tag;
+    uint32_t                                   tag;
 };
 
 constexpr std::array<SubsystemMessages, 6> subsystems = { //
@@ -442,12 +443,12 @@ std::expected<uint32_t, pb::error> read_varint_field(pb_istream_t &stream, uint3
 
 std::expected<void, Error> MessengerThread::defaultHandler(uint32_t subsystem_id, void *request, WireFormatID id, pb_istream_t &stream, AsyncUART *dev) {
     // pb::decode is a nanopb decode wrapped in c++ expected
-    pb_istream_t peek       = stream; // safe: pb_istream_t is a copyable struct
-    uint64_t     request_id = TRY(read_varint_field(peek, reqtag(subsystem_id)));
+    pb_istream_t peek = stream;
+    // each message contains a 'request_id' fields which can be read here
+    uint64_t request_id = TRY(read_varint_field(peek, reqtag(subsystem_id)));
 
     CHECK(pb::decode(stream, ingress(subsystem_id), request));
     callback_t callback = UartCallback{dev, &egress(subsystem_id), id};
-    // we need to read request_id from decoded message, this field is always of id 1
     putActiveRequest(subsystem_id, request_id, std::move(callback));
 
     return {};
@@ -455,42 +456,27 @@ std::expected<void, Error> MessengerThread::defaultHandler(uint32_t subsystem_id
 
 std::expected<void, Error> MessengerThread::handle_temperatureIngressMsg(WireFormatID id, pb_istream_t &stream, AsyncUART *dev) {
     // try to decode stream, and put it to IngressQueue
-    if (not temperatureIngressQueue.try_produce([&](temperature_IngressMessage &request) {
-            return defaultHandler(temperature_receiver_tag, &request, id, stream, dev);
-        }))
-        return std::unexpected{messenger::request_queue_full{}};
+    if (not temperatureIngressQueue.try_produce([&](temperature_IngressMessage &request) { return defaultHandler(temperature_receiver_tag, &request, id, stream, dev); })) return std::unexpected{messenger::request_queue_full{}};
     return {};
 }
 
 std::expected<void, Error> MessengerThread::handle_ctrlIngressMsg(WireFormatID id, pb_istream_t &stream, AsyncUART *dev) {
-    if (not ctrlIngressQueue.try_produce([&](ctrl_IngressMessage &request) {
-            return defaultHandler(ctrl_receiver_tag, &request, id, stream, dev);
-        }))
-        return std::unexpected{messenger::request_queue_full{}};
+    if (not ctrlIngressQueue.try_produce([&](ctrl_IngressMessage &request) { return defaultHandler(ctrl_receiver_tag, &request, id, stream, dev); })) return std::unexpected{messenger::request_queue_full{}};
     return {};
 }
 
 std::expected<void, Error> MessengerThread::handle_configIngressMsg(WireFormatID id, pb_istream_t &stream, AsyncUART *dev) {
-    if (not configIngressQueue.try_produce([&](config_IngressMessage &request) {
-            return defaultHandler(config_receiver_tag, &request, id, stream, dev);
-        }))
-        return std::unexpected{messenger::request_queue_full{}};
+    if (not configIngressQueue.try_produce([&](config_IngressMessage &request) { return defaultHandler(config_receiver_tag, &request, id, stream, dev); })) return std::unexpected{messenger::request_queue_full{}};
     return {};
 }
 
 std::expected<void, Error> MessengerThread::handle_gpioIngressMsg(WireFormatID id, pb_istream_t &stream, AsyncUART *dev) {
-    if (not gpioIngressQueue.try_produce([&](gpio_IngressMessage &request) {
-            return defaultHandler(gpio_receiver_tag, &request, id, stream, dev);
-        }))
-        return std::unexpected{messenger::request_queue_full{}};
+    if (not gpioIngressQueue.try_produce([&](gpio_IngressMessage &request) { return defaultHandler(gpio_receiver_tag, &request, id, stream, dev); })) return std::unexpected{messenger::request_queue_full{}};
     return {};
 }
 
 std::expected<void, Error> MessengerThread::handle_opIngressMsg(WireFormatID id, pb_istream_t &stream, AsyncUART *dev) {
-    if (not operationIngressQueue.try_produce([&](op_IngressMessage &request) {
-            return defaultHandler(operation_receiver_tag, &request, id, stream, dev);
-        }))
-        return std::unexpected{messenger::request_queue_full{}};
+    if (not operationIngressQueue.try_produce([&](op_IngressMessage &request) { return defaultHandler(operation_receiver_tag, &request, id, stream, dev); })) return std::unexpected{messenger::request_queue_full{}};
     return {};
 }
 

rims_app/src/operation.cpp

@@ -3,12 +3,10 @@
 #include "error.hpp"
 #include "inplace_vector.hpp"
 #include "log.hpp"
-
-#include "power_control.hpp"
+#include "messenger.hpp"
 #include "pid.hpp"
-#include "proto/ctrl.pb.h"
-#include "proto/operation.pb.h"
 #include "zephyr.hpp"
+#include "ctrl.hpp"
 
 #include <algorithm>
 #include <chrono>
@@ -18,7 +16,6 @@
 #include <thread>
 #include <variant>
 
-#include "messenger.hpp"
 namespace rims {
 
 template <typename T>

rims_app/src/utilization.cpp

@@ -1,7 +1,7 @@
-#include "thread_analyzer.hpp"
+#include "utilization.hpp"
 
-#include "log.hpp"
 #include <thread>
+#include "log.hpp"
 
 namespace rims {