/core/src/aos_thread.c - Annotate - AMiRo-OS - Research for Cognitive Interaction

amiro-os / core / src / aos_thread.c @ e03a021e

History | View | Annotate | Download (5.038 KB)

-            e545e620
+/*
 AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
-a83
+Copyright (C) 2016..2020  Thomas Schöpping et al.
-            e545e620
+            Thomas Schöpping
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-ca3
+/**
  * @file    aos_thread.c
  * @brief   Thread code.
+ *
  * @addtogroup aos_threads
  * @{
  */
-ba8a
+#include <amiroos.h>
-            f3ac1c96
+/******************************************************************************/
 /* LOCAL DEFINITIONS                                                          */
 /******************************************************************************/
 /******************************************************************************/
 /* EXPORTED VARIABLES                                                         */
 /******************************************************************************/
 /******************************************************************************/
 /* LOCAL TYPES                                                                */
 /******************************************************************************/
 /******************************************************************************/
 /* LOCAL VARIABLES                                                            */
 /******************************************************************************/
 /******************************************************************************/
 /* LOCAL FUNCTIONS                                                            */
 /******************************************************************************/
 /******************************************************************************/
 /* EXPORTED FUNCTIONS                                                         */
 /******************************************************************************/
-            e545e620
+            Thomas Schöpping
 /**
  * @brief   Lets the calling thread sleep until the specifide system uptime.
+ *
  * @param[in] t     Deadline until the thread will sleep.
  */
-            d180e1ba
+void aosThdSleepUntilS(const aos_timestamp_t t)
-            e545e620
+            Thomas Schöpping
   aos_timestamp_t uptime;
   // get the current system uptime
   aosSysGetUptimeX(&uptime);
   // while the remaining time is too long, it must be split into multiple sleeps
-            d180e1ba
+  while ( (t > uptime) && ((t - uptime) > AOS_THD_MAX_SLEEP_US) ) {
-e5f7648
+    chThdSleepS(chTimeUS2I(AOS_THD_MAX_SLEEP_US));
-            e545e620
+    aosSysGetUptimeX(&uptime);
+  }
   // sleep the remaining time
-            d180e1ba
+  if (t > uptime) {
     sysinterval_t rest = chTimeUS2I(t - uptime);
-            e545e620
+    if (rest > TIME_IMMEDIATE) {
       chThdSleepS(rest);
+    }
+  }
   return;
+}
-ca3
+            Marc Rothmann
-c9e9b9d
+#if ((AMIROOS_CFG_DBG == true) && (CH_DBG_FILL_THREADS == TRUE)) || defined(__DOXYGEN__)
-            aed3754b
+/**
  * @brief   Calculate the peak stack utilization for a specific thread so far in bytes.
+ *
  * @param[in] thread    Thread to calculate the stack utilization for.
+ *
  * @return  Absolute peak stack utilization in bytes.
  */
 size_t aosThdGetStackPeakUtilization(thread_t* thread)
+{
   aosDbgCheck(thread != NULL);
-            e5742249
+  // iterator through the stack
   // note: since the stack is filled from top to bottom, the loop searches for the first irregular byte from the bottom (stack end).
   for (uint8_t* ptr = (uint8_t*)thread->wabase; ptr < (uint8_t*)thread->wabase + aosThdGetStacksize(thread); ++ptr) {
     if (*ptr != CH_DBG_STACK_FILL_VALUE) {
       return aosThdGetStacksize(thread) - (size_t)(--ptr - (uint8_t*)thread->wabase);
+    }
-            aed3754b
+            Thomas Schöpping
-            e5742249
+  return 0;
-            aed3754b
+            Thomas Schöpping
-c9e9b9d
+#endif /* (AMIROOS_CFG_DBG == true) && (CH_DBG_FILL_THREADS == TRUE) */
-            aed3754b
+            Thomas Schöpping
-            e03a021e
+#if ((CH_CFG_USE_REGISTRY == TRUE) || (CH_CFG_USE_THREADHIERARCHY == TRUE)) || defined(__DOXYGEN__)
 /**
  * @brief   Retrieve the first/root thread in the system.
+ *
  * @return  Pointer to the first/root thread.
  */
 thread_t* aosThreadGetFirst(void)
+{
 #if (CH_CFG_USE_REGISTRY == TRUE)
   return chRegFirstThread();
 #elif (CH_CFG_USE_THREADHIERARCHY == TRUE)
   thread_t* tp = chThdGetSelfX();
   while (tp->parent) {
     tp = tp->parent;
+  }
   return tp;
 #endif
+}
 /**
  * @brief   Retrieve the next thread in the system.
+ *
  * @param[in] thread  Current thread to retrieve the 'successor' to.
+ *
  * @return  Pointer to the next thread, or NULL if there are no further threads.
  */
 thread_t* aosThreadGetNext(thread_t* thread)
+{
   aosDbgCheck(thread != NULL);
 #if (CH_CFG_USE_REGISTRY == TRUE)
   return chRegNextThread(thread);
 #elif (CH_CFG_USE_THREADHIERARCHY == TRUE)
   if (thread->children != NULL) {
     return thread->children;
   } else {
     while (thread != NULL && thread->sibling == NULL) {
       thread = thread->parent;
+    }
     return (thread != NULL) ? thread->sibling : NULL;
+  }
 #endif
+}
 #endif /* (CH_CFG_USE_REGISTRY == TRUE) || (CH_CFG_USE_THREADHIERARCHY == TRUE) */
-ca3
+/** @} */