added thread names

Author: ClemensElflein

cfg/chconf.h

@@ -658,6 +658,7 @@ extern volatile uint32_t last_idle_tick;
 #if !defined(CH_DBG_ENABLE_STACK_CHECK)
 #ifdef DEBUG_BUILD
 #define CH_DBG_ENABLE_STACK_CHECK           TRUE
+#define PORT_ENABLE_GUARD_PAGES TRUE
 #else
 #ifdef RELEASE_BUILD
 #define CH_DBG_ENABLE_STACK_CHECK           FALSE

ext/xbot_framework

@@ -30,6 +30,8 @@ XBOT_THREAD_TYPEDEF io_thread_{};
 
 fd_set socket_set;
 
+static const char* IO_THD_NAME = "xbot-io";
+
 using namespace xbot::service;
 
 void runIo(void* arg) {
@@ -106,7 +108,7 @@ bool Io::start() {
     return false;
   }
   return thread::initialize(&io_thread_, runIo, nullptr, &waIoThread,
-                            sizeof(waIoThread));
+                            sizeof(waIoThread), IO_THD_NAME);
 }
 
 }  // namespace xbot::service

portable/Io.cpp

@@ -5,9 +5,10 @@ using namespace xbot::service::thread;
 
 bool xbot::service::thread::initialize(ThreadPtr thread,
                                        void (*threadfunc)(void*), void* arg,
-                                       void* stackbuf, size_t buflen) {
+                                       void* stackbuf, size_t buflen, const char* name) {
   // Create a multicast sender thread
   *thread = chThdCreateStatic(stackbuf, buflen, NORMALPRIO, threadfunc, arg);
+  (*thread)->name = name;
   return true;
 }
 

portable/thread.cpp

@@ -13,9 +13,9 @@
 
 #include "chprintf.h"
 #include "lwip/sockets.h"
-static char boardAdvertisementBuffer[1000];
-static char boardAdvertisementRequestBuffer[1000];
-static THD_WORKING_AREA(waServiceDiscovery, 500);
+static char boardAdvertisementBuffer[100];
+static char boardAdvertisementRequestBuffer[100];
+static THD_WORKING_AREA(waServiceDiscovery, 512);
 
 static void multicast_sender_thread(void *p) {
   (void)p;
@@ -92,6 +92,9 @@ void InitBootloaderServiceDiscovery() {
              "BOARD_ADVERTISEMENT:xcore-boot;application-mode");
 
   // Create a multicast sender thread
-  chThdCreateStatic(waServiceDiscovery, sizeof(waServiceDiscovery), NORMALPRIO,
+  thread_t* threadPointer = chThdCreateStatic(waServiceDiscovery, sizeof(waServiceDiscovery), NORMALPRIO,
                     multicast_sender_thread, NULL);
+#ifdef USE_SEGGER_SYSTEMVIEW
+  threadPointer->name = "Boot SD";
+#endif
 }

src/boot_service_discovery.c

@@ -9,8 +9,6 @@
 
 #include <cmath>
 
-
-
 namespace xbot::driver::gps {
 
 GpsDriver::GpsDriver() {
@@ -19,54 +17,49 @@ GpsDriver::GpsDriver() {
 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_) {
+  if (!stopped_) {
     return false;
   }
   this->uart_ = uart;
   uart_config_.speed = baudrate;
   uart_config_.context = this;
   bool uartStarted = uartStart(uart, &uart_config_) == MSG_OK;
-  if(!uartStarted) {
+  if (!uartStarted) {
     return false;
   }
 
-
-  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++;
-    GpsDriver* 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_ =
+          (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_) {
+      if (instance->processing_thread_) {
         chEvtSignalI(instance->processing_thread_, 1);
       }
     }
   };
 
-
-
   stopped_ = false;
   processing_thread_ = chThdCreateStatic(&thd_wa_, sizeof(thd_wa_), NORMALPRIO, threadHelper, this);
+#ifdef USE_SEGGER_SYSTEMVIEW
+  processing_thread_->name = "GpsDriver";
+#endif
 
   uartStartReceive(uart, RECV_BUFFER_SIZE, recv_buffer1_);
   return true;
@@ -75,8 +68,7 @@ bool GpsDriver::StartDriver(UARTDriver *uart, uint32_t baudrate) {
 void GpsDriver::SetStateCallback(const GpsDriver::StateCallback &function) {
   state_callback_ = function;
 }
-void GpsDriver::SetDatum(double datum_lat, double datum_long,
-                             double datum_height) {
+void GpsDriver::SetDatum(double datum_lat, double datum_long, double datum_height) {
   datum_lat_ = datum_lat;
   datum_long_ = datum_long;
   datum_u_ = datum_height;
@@ -89,10 +81,39 @@ bool GpsDriver::send_raw(const void *data, size_t size) {
 }
 
 void GpsDriver::threadFunc() {
-  while(!stopped_) {
-    // Wait for data to arrive, process and mark as done
-    chEvtWaitAny(ALL_EVENTS);
-    ProcessBytes(processing_buffer_, processing_buffer_len_);
+  while (!stopped_) {
+    // Wait for data to arrive
+    bool timeout = chEvtWaitAnyTimeout(ALL_EVENTS, TIME_MS2I(RECV_TIMEOUT_MILLIS)) == 0;
+    if (timeout) {
+      // If timeout, we take the buffer and restart the reception
+      // Else, the ISR has already prepared the buffer for us
+      // Lock the core to prevent the RX interrupt from firing
+      chSysLock();
+      // Check, that processing_done_ is still true
+      // (in case ISR happened between the timeout and now, this will be set to false by ISR)
+      if (processing_done_) {
+        // Stop reception and get the partial received length
+        size_t not_received_len = uartStopReceiveI(uart_);
+        if (not_received_len != UART_ERR_NOT_ACTIVE) {
+          // Uart was still receiving, so the buffer length is not complete
+          processing_buffer_len_ = RECV_BUFFER_SIZE - not_received_len;
+        } else {
+          // Uart was not active.
+          // This should not happen, but could during debug when pausing the chip
+          // we ignore this buffer, but carry on as usual
+          processing_buffer_len_ = 0;
+        }
+        uint8_t *next_recv_buffer = processing_buffer_;
+        uartStartReceiveI(uart_, RECV_BUFFER_SIZE, next_recv_buffer);
+        processing_buffer_ = (processing_buffer_ == recv_buffer1_) ? recv_buffer2_ : recv_buffer1_;
+        processing_done_ = false;
+      }
+      // allow ISR again
+      chSysUnlock();
+    }
+    if (processing_buffer_len_ > 0) {
+      ProcessBytes(processing_buffer_, processing_buffer_len_);
+    }
     processing_done_ = true;
   }
 }
@@ -105,4 +126,4 @@ void GpsDriver::threadHelper(void *instance) {
 void GpsDriver::SendRTCM(const uint8_t *data, size_t size) {
   send_raw(data, size);
 }
-} // namespace xbot::driver::gps
+}  // namespace xbot::driver::gps

src/drivers/gps/gps_interface.cpp

@@ -90,7 +90,9 @@ class GpsDriver {
     GpsDriver *context;
   };
 
-  static constexpr size_t RECV_BUFFER_SIZE = 100;
+  static constexpr size_t RECV_BUFFER_SIZE = 512;
+  // 10Hz timeout for reception
+  static constexpr uint32_t RECV_TIMEOUT_MILLIS = 100;
   // Keep two buffers for streaming data while doing processing
   uint8_t recv_buffer1_[RECV_BUFFER_SIZE]{};
   uint8_t recv_buffer2_[RECV_BUFFER_SIZE]{};
@@ -101,7 +103,7 @@ class GpsDriver {
   UARTDriver *uart_{};
   UARTConfigEx uart_config_{};
 
-  THD_WORKING_AREA(thd_wa_, 512){};
+  THD_WORKING_AREA(thd_wa_, 1024){};
   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;
@@ -111,7 +113,6 @@ class GpsDriver {
 
   static void threadHelper(void *instance);
 };
-} // namespace xbot::driver::gps
-
+}  // namespace xbot::driver::gps
 
 #endif  // XBOT_DRIVER_GPS_GPS_INTERFACE_H