Refactoring

Author: ClemensElflein

main.cpp

@@ -45,7 +45,7 @@ void testThreadFunc(void* arg) {
 
 
 int i = 0;
-void gpsUpdated(const xbot::driver::gps::GpsInterface::GpsState &new_state) {
+void gpsUpdated(const xbot::driver::gps::GpsDriver::GpsState &new_state) {
   (void)new_state;
   etl::string<100> lat{};
   etl::format_spec format{};
@@ -125,9 +125,9 @@ int main(void) {
   mower_service.start();
 
   // chThdCreateStatic(testWa, sizeof(testWa), NORMALPRIO, testThreadFunc, NULL);
-  gps.set_state_callback(etl::delegate<void(const xbot::driver::gps::GpsInterface::GpsState &new_state)>::create<gpsUpdated>());
-  gps.set_datum(49.0, 10.0, 150);
-  gps.start_driver(&UARTD6, 921600);
+  gps.SetStateCallback(etl::delegate<void(const xbot::driver::gps::GpsDriver::GpsState &new_state)>::create<gpsUpdated>());
+  gps.SetDatum(49.0, 10.0, 150);
+  gps.StartDriver(&UARTD6, 921600);
 
   // Subscribe to global events and dispatch to our services
   event_listener_t event_listener;

src/drivers/gps/gps_interface.cpp

@@ -9,53 +9,53 @@
 
 #include <cmath>
 
-namespace xbot {
-namespace driver {
-namespace gps {
 
-GpsInterface::GpsInterface() {
+
+namespace xbot::driver::gps {
+
+GpsDriver::GpsDriver() {
   datum_lat_ = datum_long_ = NAN;
 }
-bool GpsInterface::start_driver(UARTDriver *uart, uint32_t baudrate) {
+bool GpsDriver::StartDriver(UARTDriver *uart, uint32_t baudrate) {
   chDbgAssert(stopped_, "don't start the driver twice");
   chDbgAssert(uart != nullptr, "need to provide a driver");
   if(!stopped_) {
     return false;
   }
-  this->uart = uart;
-  uart_config.speed = baudrate;
-  uart_config.context = this;
-  bool uartStarted = uartStart(uart, &uart_config) == MSG_OK;
+  this->uart_ = uart;
+  uart_config_.speed = baudrate;
+  uart_config_.context = this;
+  bool uartStarted = uartStart(uart, &uart_config_) == MSG_OK;
   if(!uartStarted) {
     return false;
   }
 
 
-  uart_config.rxchar_cb = [](UARTDriver* uartp, uint16_t c) {
+  uart_config_.rxchar_cb = [](UARTDriver* uartp, uint16_t c) {
     (void)uartp;
     (void)c;
     static int missing_bytes=0;
     missing_bytes++;
   };
 
-  uart_config.rxend_cb = [](UARTDriver* uartp) {
+  uart_config_.rxend_cb = [](UARTDriver* uartp) {
     (void)uartp;
     static int i = 0;
     i++;
-    GpsInterface* instance = reinterpret_cast<const UARTConfigEx*>(uartp->config)->context;
-    if(!instance->processing_done) {
+    GpsDriver* instance = reinterpret_cast<const UARTConfigEx*>(uartp->config)->context;
+    if(!instance->processing_done_) {
       // This is bad, processing is too slow to keep up with updates!
       // We just read into the same buffer again
-      uint8_t* next_recv_buffer = (instance->processing_buffer == instance->recv_buffer1) ? instance->recv_buffer2 : instance->recv_buffer1;
+      uint8_t* next_recv_buffer = (instance->processing_buffer_ == instance->recv_buffer1_) ? instance->recv_buffer2_ : instance->recv_buffer1_;
       uartStartReceiveI(uartp, RECV_BUFFER_SIZE, next_recv_buffer);
     } else {
       // Swap buffers and read into the next one
       // Get the pointer to the receiving buffer (it's not the processing buffer)
-      uint8_t* next_recv_buffer = instance->processing_buffer;
+      uint8_t* next_recv_buffer = instance->processing_buffer_;
       uartStartReceiveI(uartp, RECV_BUFFER_SIZE, next_recv_buffer);
-      instance->processing_buffer = (instance->processing_buffer == instance->recv_buffer1) ? instance->recv_buffer2 : instance->recv_buffer1;
-      instance->processing_buffer_len = RECV_BUFFER_SIZE;
-      instance->processing_done = false;
+      instance->processing_buffer_ = (instance->processing_buffer_ == instance->recv_buffer1_) ? instance->recv_buffer2_ : instance->recv_buffer1_;
+      instance->processing_buffer_len_ = RECV_BUFFER_SIZE;
+      instance->processing_done_ = false;
       // Signal the processing thread
       if(instance->processing_thread_) {
         chEvtSignalI(instance->processing_thread_, 1);
@@ -66,45 +66,43 @@ bool GpsInterface::start_driver(UARTDriver *uart, uint32_t baudrate) {
 
 
   stopped_ = false;
-  processing_thread_ = chThdCreateStatic(&wa, sizeof(wa), NORMALPRIO, threadHelper, this);
+  processing_thread_ = chThdCreateStatic(&thd_wa_, sizeof(thd_wa_), NORMALPRIO, threadHelper, this);
 
-  uartStartReceive(uart, RECV_BUFFER_SIZE, recv_buffer1);
+  uartStartReceive(uart, RECV_BUFFER_SIZE, recv_buffer1_);
   return true;
 }
 
-void GpsInterface::set_state_callback(const GpsInterface::StateCallback &function) {
-  state_callback = function;
+void GpsDriver::SetStateCallback(const GpsDriver::StateCallback &function) {
+  state_callback_ = function;
 }
-void GpsInterface::set_datum(double datum_lat, double datum_long,
+void GpsDriver::SetDatum(double datum_lat, double datum_long,
                              double datum_height) {
   datum_lat_ = datum_lat;
   datum_long_ = datum_long;
   datum_u_ = datum_height;
 }
 
-bool GpsInterface::send_raw(const void *data, size_t size) {
+bool GpsDriver::send_raw(const void *data, size_t size) {
   // sdWrite(uart, static_cast<const uint8_t*>(data), size);
-  uartSendFullTimeout(uart, &size, data, TIME_INFINITE);
+  uartSendFullTimeout(uart_, &size, data, TIME_INFINITE);
   return true;
 }
 
-void GpsInterface::threadFunc() {
+void GpsDriver::threadFunc() {
   while(!stopped_) {
     // Wait for data to arrive, process and mark as done
     chEvtWaitAny(ALL_EVENTS);
-    process_bytes(processing_buffer, processing_buffer_len);
-    processing_done = true;
+    ProcessBytes(processing_buffer_, processing_buffer_len_);
+    processing_done_ = true;
   }
 }
 
-void GpsInterface::threadHelper(void *instance) {
-  auto *gps_interface = static_cast<GpsInterface *>(instance);
+void GpsDriver::threadHelper(void *instance) {
+  auto *gps_interface = static_cast<GpsDriver *>(instance);
   gps_interface->threadFunc();
 }
 
-void GpsInterface::send_rtcm(const uint8_t *data, size_t size) {
+void GpsDriver::SendRTCM(const uint8_t *data, size_t size) {
   send_raw(data, size);
 }
-}  // namespace gps
-}  // namespace driver
-}  // namespace xbot
+} // namespace xbot::driver::gps

src/drivers/gps/gps_interface.h

@@ -2,22 +2,20 @@
 // Created by clemens on 10.01.23.
 //
 
-#ifndef OPEN_MOWER_ROS_GPS_INTERFACE_H
-#define OPEN_MOWER_ROS_GPS_INTERFACE_H
+#ifndef XBOT_DRIVER_GPS_GPS_INTERFACE_H
+#define XBOT_DRIVER_GPS_GPS_INTERFACE_H
 
 #include <etl/delegate.h>
 
 #include "ch.h"
 #include "hal.h"
 
-namespace xbot {
-namespace driver {
-namespace gps {
-class GpsInterface {
+namespace xbot::driver::gps {
+class GpsDriver {
  public:
-  explicit GpsInterface();
+  explicit GpsDriver();
 
-  virtual ~GpsInterface() = default;
+  virtual ~GpsDriver() = default;
 
   /*
    * The final GPS state we're interested in.
@@ -60,17 +58,15 @@ class GpsInterface {
   typedef etl::delegate<void(const GpsState &new_state)> StateCallback;
 
  public:
-  bool start_driver(UARTDriver *uart, uint32_t baudrate);
-  void set_state_callback(const GpsInterface::StateCallback &function);
+  bool StartDriver(UARTDriver *uart, uint32_t baudrate);
+  void SetStateCallback(const GpsDriver::StateCallback &function);
 
-  void set_datum(double datum_lat, double datum_long, double datum_height);
+  void SetDatum(double datum_lat, double datum_long, double datum_height);
 
-  void send_rtcm(const uint8_t *data, size_t size);
-
-  void read_uart(uint32_t timeout);
+  void SendRTCM(const uint8_t *data, size_t size);
 
  protected:
-  StateCallback state_callback{};
+  StateCallback state_callback_{};
 
   double datum_lat_ = 0, datum_long_ = 0, datum_u_ = 0;
 
@@ -84,38 +80,38 @@ class GpsInterface {
   bool send_raw(const void *data, size_t size);
 
   // Called on serial reconnect
-  virtual void reset_parser_state() = 0;
+  virtual void ResetParserState() = 0;
 
-  virtual size_t process_bytes(const uint8_t *buffer, size_t len) = 0;
+  virtual size_t ProcessBytes(const uint8_t *buffer, size_t len) = 0;
 
  private:
   // Extend the config struct by a pointer to this instance, so that we can access it in callbacks.
-  struct UARTConfigEx : public UARTConfig {
-    GpsInterface *context;
+  struct UARTConfigEx : UARTConfig {
+    GpsDriver *context;
   };
 
   static constexpr size_t RECV_BUFFER_SIZE = 100;
   // Keep two buffers for streaming data while doing processing
-  uint8_t recv_buffer1[RECV_BUFFER_SIZE]{};
-  uint8_t recv_buffer2[RECV_BUFFER_SIZE]{};
+  uint8_t recv_buffer1_[RECV_BUFFER_SIZE]{};
+  uint8_t recv_buffer2_[RECV_BUFFER_SIZE]{};
   // We start by receiving into recv_buffer1, so processing_buffer is the 2 (but empty)
-  uint8_t *volatile processing_buffer = recv_buffer2;
-  volatile size_t processing_buffer_len = 0;
+  uint8_t *volatile processing_buffer_ = recv_buffer2_;
+  volatile size_t processing_buffer_len_ = 0;
 
-  UARTDriver *uart{};
-  UARTConfigEx uart_config{};
+  UARTDriver *uart_{};
+  UARTConfigEx uart_config_{};
 
-  THD_WORKING_AREA(wa, 512){};
+  THD_WORKING_AREA(thd_wa_, 512){};
   thread_t *processing_thread_ = nullptr;
   // This is reset by the receiving ISR and set by the thread to signal if it's safe to process more data.
-  volatile bool processing_done = true;
+  volatile bool processing_done_ = true;
   bool stopped_ = true;
 
   void threadFunc();
 
   static void threadHelper(void *instance);
 };
-}  // namespace gps
-}  // namespace driver
-}  // namespace xbot
-#endif  // OPEN_MOWER_ROS_GPS_INTERFACE_H
+} // namespace xbot::driver::gps
+
+
+#endif  // XBOT_DRIVER_GPS_GPS_INTERFACE_H