femtoos_source/femtoos_core.c

Go to the documentation of this file.

/*
 * Femto OS v 0.91 - Copyright (C) 2008-2009 Ruud Vlaming
 *
 * This file is part of the Femto OS distribution.
 *
 * 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, version 3 of the License.
 *
 * 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/>.
 *
 * Please note that, due to the GPLv3 license, for application of this
 * work and/or combined work in embedded systems special obligations apply.
 * If these are not to you liking, please know the Femto OS is dual
 * licensed. A commercial license and support are available.
 * See http://www.femtoos.org/ for details.
 */

#include "femtoos_core.h"
#include "femtoos_shared.h"


/* ========================================================================= */
/* FEMTO OS INTERNAL FUNCTIONS  ============================================ */
/* ========================================================================= */

/*
 * Body definitions. All switching methods are called via an assembler
 * redirect, making it possible to switch stack, save context and preserve
 * all registers (including the parameters) while doing so. Without this
 * trick gcc may push the parameter registers or construct a frame pointer
 * first thereby destroying other registers. Notice functions never return,
 * but are not 'noreturn'. They are naked or bikini.
 */

#if (includeTaskDelayFromNow == cfgTrue)
  static void privDelayFromNowBody(Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (includeTaskDelayFromWake == cfgTrue)
  static void privDelayFromWakeBody(Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (includeTaskRecreate == cfgTrue)
  static void privRecreateBody(Tuint08 uiTaskNumber) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (includeTaskRestart == cfgTrue)
  static void privRestartBody(Tuint08 uiRestartMode, Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (includeTaskYield == cfgTrue)
  static void privYieldBody(void) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (includeTaskTerminate == cfgTrue)
  static void privTerminateBody(Tuint08 uiTaskNumber) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (includeTaskSuspend == cfgTrue)
  static void privSuspendBody(Tuint08 uiSuspendMode) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (cfgUseLowPowerSleep == cfgTrue) && (includeTaskSleep == cfgTrue)
  static void privSleepBody(void) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (cfgUseLowPowerSleep == cfgTrue) && (includeTaskSleepAll == cfgTrue)
  static void privSleepAllBody(void) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (cfgUseSynchronization != cfgSyncNon) && (includeTaskWaitForTasks == cfgTrue)
  #if (cfgUseTimeout == cfgTrue)
    static void privWaitForTasksBody(Tuint08 uiSlot, Tuint08 uiNumberOfTasks, Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
  #else
    static void privWaitForTasksBody(Tuint08 uiSlot, Tuint08 uiNumberOfTasks) __attribute__((used)) defSysReduceProEpilogue;
  #endif
#endif

#if (cfgUseSynchronization != cfgSyncNon) && ( (includeTaskQueu == cfgTrue) || (includeTaskMutex == cfgTrue) )
  #if (cfgUseTimeout == cfgTrue)
    #if (cfgUseSynchronization == cfgSyncDoubleBlock)
      static void privSyncRequestBody(Tuint08 uiSlotSlot, Tsint08 siFreeLeftFilling, Tsint08 siFreeRightFilling, Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
    #else
      static void privSyncRequestBody(Tuint08 uiSlotSlot, Tsint08 siFreeRightFilling, Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
    #endif
  #else
    #if (cfgUseSynchronization == cfgSyncDoubleBlock)
      static void privSyncRequestBody(Tuint08 uiSlotSlot, Tsint08 siFreeLeftFilling, Tsint08 siFreeRightFilling) __attribute__((used)) defSysReduceProEpilogue;
    #else
      static void privSyncRequestBody(Tuint08 uiSlotSlot, Tsint08 siFreeRightFilling) __attribute__((used)) defSysReduceProEpilogue;
    #endif
  #endif
#endif

#if (cfgUseSynchronization != cfgSyncNon) && ( (includeTaskQueu == cfgTrue) || (includeTaskMutex == cfgTrue) )
  static void privSyncReleaseBody(Tuint08 uiSlotSlot) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (cfgUseFileSystem  ==  cfgTrue) && (includeTaskFileAccess == cfgTrue)
  #if (cfgUseTimeout == cfgTrue)
    #if (cfgUseFileSystemConcurrentRead == cfgTrue)
      static void privFileOpenBody(Tbool bReadOnly, Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
    #else
      static void privFileOpenBody(Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
    #endif
  #else
    #if (cfgUseFileSystemConcurrentRead == cfgTrue)
      static void privFileOpenBody(Tbool bReadOnly) __attribute__((used)) defSysReduceProEpilogue;
    #else
      static void privFileOpenBody(void) __attribute__((used)) defSysReduceProEpilogue;
    #endif
  #endif
#endif

#if (cfgUseFileSystem  ==  cfgTrue) && (includeTaskFileAccess == cfgTrue)
  static void privFileCloseBody(void) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (cfgUseFileSystem  ==  cfgTrue)
  static void privWaitForFsAccessBody(void) __attribute__((used)) defSysReduceProEpilogue;
#endif

#if (cfgUseEvents == cfgTrue) && (includeTaskWaitForEvents == cfgTrue)
  #if (cfgUseTimeout == cfgTrue)
    static void privWaitForEventBody(Tuint08 uiEvent, Tuint16 uiTicksToWait) __attribute__((used)) defSysReduceProEpilogue;
  #else
    static void privWaitForEventBody(Tuint08 uiEvent) __attribute__((used)) defSysReduceProEpilogue;
  #endif
#endif

#if (defCheckReportingError == cfgTrue)
  #if (cfgCheckAlwaysFatal == cfgTrue)
    static void privShowError(Tuint08 uiMessage, Tuint08 uiCallId, Tuint08 uiInfo) __attribute__ (( noreturn ));
#else
    static void privShowError(Tuint08 uiMessage, Tuint08 uiCallId, Tuint08 uiInfo);
  #endif
#endif

#if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
  static void privCheckOsStackLevel(void);
#endif

#if (cfgCheckWatermarks == cfgTrue) && (cfgSysReuseOsStack == cfgFalse)
  static void privCheckOsStackRegion(void);
#endif

#ifdef portInitContext
  static Taddress privInitContext(Taddress pTaskStart, Taddress pStackTop, Tuint08 uiRegisterCount, Tuint08 uiInterruptStart);
#endif

static TtaskControlBlock * privTcbList(Tuint08 uiTaskNumber) __attribute__ ((pure, noinline));

static Tuint08 privTaskNumber(Tuint08 uiTaskNumber) __attribute__ ((pure, noinline, unused));

#if (cfgCheckTaskStack == cfgTrue) && (StackSafety > 0)
  static void privTestStackRegion(void) __attribute__ (( noinline));
#endif

#if (cfgUseLowPowerSleep == cfgTrue)
  static void privWakeupFromLowPower(void) __attribute__ ((noinline));
#endif

#if (defRegisterUseConstant == cfgFalse)
  static Tuint08 privRegisterCount(Tuint08 uiRegisterUse) __attribute__ ((const));
#endif

/*DISCUSSION
 * Some methods use quite a bit of stack, i.e. they start by saving
 * say 10 registers on the context. This implies not only 10 more bytes
 * of ram use, but also 40 extra flash bytes just to store and retrieve
 * the bytes. This must be weighed against inlining those methods.
 * Less stack, more flash, but maybe not that much more. It really depends
 * which resource is limited.
 * Also that discussion cannot be made per function, since you cannot simply
 * add the stack use. Functions could be inlined if needed by adding
 *  __attribute__ ( ( always_inline ) );
 * to their definitions.
 */

static void privTaskInit(Tuint08 uiTaskNumber, Tuint08 uiInitControl);

static void privEnterOS(Tuint08 uiAction) defSysReduceProEpilogue;

static void privIncrementTick(void);

static Tuint08 privSwitchContext(void);

static Tselect privSelectTask(Tuint08 uiFlipMask, Tuint08 uiLoopStart, Tuint08 uiLoopEnd) __attribute__ (( always_inline ));

#if (cfgUseHierarchicalRoundRobin == cfgTrue)
  static void privMakeTasksRunable(Tuint08 uiFlipMask, Tuint08 uiPriority, Tuint08 uiLoopStart, Tuint08 uiLoopEnd, Tbool bCheckSkip) __attribute__ (( always_inline ));
#else
  static void privMakeTasksRunable(Tuint08 uiFlipMask, Tuint08 uiLoopStart, Tuint08 uiLoopEnd, Tbool bCheckSkip) __attribute__ (( always_inline ));
#endif

#if (cfgUseLowPowerSleep == cfgTrue)
  static void privEnterSleep(Tuint08 uiTickMinDelay);
#endif

static void privEnterIdle(void) defSysReduceProEpilogue;

static void privEnterTask(void) defSysReduceProEpilogue;

#if (cfgUseLoadMonitor == cfgTrue)
  static void privCopyLoad(void);
#endif

#if (cfgCheckWatermarks == cfgTrue) && (cfgCheckTrace == cfgTrue)
  static void privTraceWatermarks(void);
#endif

#if (defUseDelay == cfgTrue)
  static void privWakeupFromDelay(Tuint08 uiTaskNumber, TtaskControlBlock * taskTCB);
#endif

#if (defUseDelay == cfgTrue)
  #if (includeTaskDelayFromWake == cfgTrue)
    #define privDelayCalcFromNow(DT)   privDelayCalc(DT,true)
    #define privDelayCalcFromWake(DT)  privDelayCalc(DT,false)
    static void privDelayCalc(Tuint16 uiDelayTime, Tbool bFromNow) defConditionalInline;
  #else
    static void privDelayCalcFromNow(Tuint16 delayTime) defConditionalInline;
  #endif
#endif

#if (cfgUseSynchronization != cfgSyncNon) && ((cfgUseTaskWatchdog == cfgTrue) || ( includeTaskRecreate == cfgTrue ))
  static void privCleanSlotStack(TtaskExtendedControlBlock * taskTCB);
#endif

#if (cfgUseSynchronization != cfgSyncNon)
  static Tbool privOperateSlotStack(Tuint08 uiControlTaskNumber, Tuint08 uiSlotSlot);
#endif

#if (cfgUseSynchronization != cfgSyncNon) && (defUseQueus == cfgTrue)
  static Tuint08 privGetQueuSize(Tuint08 uiQueuNumber) __attribute__ ((always_inline, const));
#endif


#if (cfgUseSynchronization != cfgSyncNon) || (cfgUseFileSystem == cfgTrue)
  static void privUnblockTask(Tuint08 uiControlTaskNumber);
#endif

#if (cfgUseSynchronization != cfgSyncNon) && (cfgUsePriorityLifting == cfgTrue)
  static void privLiftLocksOnSlot(Tuint08 uiSlot);
#endif

#if (cfgUseSynchronization != cfgSyncNon) && (cfgUsePriorityLifting == cfgTrue)
  static void privRestoreInitialPriority(Tuint08 uiTaskNumber);
#endif

#if (cfgUseSynchronization != cfgSyncNon) && (defUseQueus == cfgTrue)
  static Tuint08 privQueuTest(Tuint08 uiSlot, Tsint08 siFreeFilling);
#endif

#if (cfgUseSynchronization != cfgSyncNon) && ((defUseMutexes == cfgTrue) || (defUseQueus == cfgTrue))
  static void privReleaseSyncBlockingTasks(void) defConditionalInline;
#endif

#if (cfgUseSynchronization != cfgSyncNon) && ((defUseMutexes == cfgTrue) || (defUseQueus == cfgTrue))
  static Tuint08 privFreeLockAbsent(Tuint08 uiSlot);
#endif

#if (cfgUseSynchronization != cfgSyncNon) && (defUseQueus == cfgTrue)
  static Tbool privSizeFitsQueu(Tuint08 uiSlot, Tsint08 siFreeFilling);
#endif

#if (cfgUseFileSystem  ==  cfgTrue)
  static void privReleaseFileBlocks(void);
#endif

#if (cfgUseFileSystem  ==  cfgTrue)
  static Taddress privFileLocation(Tuint08 uiFileNumber, Tuint08 uiOffset);
#endif

#if (cfgUseLowPowerSleep == cfgTrue) && (includeTaskSleepAll == cfgTrue)
  static void privPutAllTasksToSleep(void);
#endif

#if (cfgUseFileSystem  ==  cfgTrue)
  static void privPrepareFileClose(Tuint08 uiTaskNumber);
#endif

#if (cfgUseFileSystem  ==  cfgTrue) && (cfgCheckMethodUse == cfgTrue)
  static void privCheckFileSpecsWriting(Tuint08 uiFileNumber, Tuint08 uiOffset, Tuint08 uiSize, Tuint08 uiCallId);
#endif

#if (cfgUseFileSystem  ==  cfgTrue) && (cfgCheckMethodUse == cfgTrue)
  static void privCheckFileSpecsReading(Tuint08 uiFileNumber, Tuint08 uiOffset, Tuint08 uiSize, Tuint08 uiCallId);
#endif

#if (cfgUseFileSystem  ==  cfgTrue) && ( ((cfgUseFileSystemMaintainFAT == cfgTrue) && (includeTaskFileAppendByte == cfgTrue)) || (cfgCheckMethodUse == cfgTrue) )
  static Tuint08 privFileSpace(Tuint08 uiFileNumber);
#endif

#if (cfgCheckMethodUse == cfgTrue)
  #if (defCapabilitiesFull == cfgFalse)
    static void privCheckCapabilities(Tuint08 uiCallId, Tuint08 uiTaskCaps) __attribute__ ((unused));
  #else
    #define privCheckCapabilities(X,Y)
  #endif
#endif


/* ========================================================================= */
/* FEMTO OS CORE IMPLEMENTATION ============================================ */
/* ========================================================================= */


#if (defCheckReportingError == cfgTrue)

static void privShowError(Tuint08 uiMessage, Tuint08 uiCallId, Tuint08 uiInfo)
{ /* We may arrive here from OS space, isr or task space. In the latter case is important we do
   * not get tick interrupts (only possible when coming from a task), since reporting an error
   * is usually a critical situation. But since we want the user to see the error it is best
   * we stop all interrupts.
   * Note that for tasks this method should not return to the point of calling but invoke a
   * context switch instead. When coming from an isr, we cannot stop that particular isr so
   * we should treat that situation as fatal. Only when coming here from the OS itself, we
   * may return if that was specifically asked for, or we must switch to a new task (usually
   * can a switching method was called from the task). Only when the possibility exists we
   * return to the point of origin we need to keep the stack.
   * The only question remains, how do we decide where the error occurred. On course we
   * can ask the uiOsStatus. If we come from genXXX that is the only way to find out. But,
   * if we come for example from privInitOS, this information has not yet been updated,
   * or if we come from a switching call, we are not really inside OS space, but we are
   * handling a call from the task in OS space. Therefore we have one bit controlling
   * if we should use the uiOsState "as-is" or if we should use the Os State forced.
   *
   * Then, with the resulting state being (idle, isr, task, os)
   *  idle => issue an internal error, this should not happen. TODO: not implemented yet.
   *  isr  => make error fatal, renew stack, never return
   *       => we should not arrive here from a sleeping state.
   *  task => if fatal error, renew stack, never return
   *       => if non-fatal error, renew stack, terminate task, issue a switch-task
   *       => for shared tasks, reset the share state
   *  os   => if fatal error, renew stack, never return
   *       => if non-fatal error return to place from which the call originated.
   * Of course, when cfgCheckAlwaysFatal is activated the error is ... always fatal,
   * so we can ignore this hocus-pocus.
   * A switch task is a context switch without the without the  context-save and os
   * initialization operations.
   *
   * One extra note. Errors reporting an incorrect task number must be fatal since this
   * routine assumes that, when the error is not fatal, the task number represents the
   * failing task.
   */
  privDisableGlobalInterrupts();
  /* Strip the error type information from the message */
  Tuint08 uiBareMessage = (uiMessage & errMessageGetMask);
  /* Errors are traced first, to be sure that tracing is done in case the portError holds the system for ever. */
  privTrace(traceErrorBase | uiBareMessage);
  /* First check if we have fatal errors per default */
  #if (cfgCheckAlwaysFatal == cfgTrue)
    /* If so, the matter is simple. All errors are fatal and we never return. */
    const Tbool bFatal = true;
    const Tbool bReturn = false;
  #else
    /* uiWorkStatus represents the status we will use upon which we decide what to do. */
    Tuint08 uiWorkStatus;
    /* See if we must use the uiOsStatus as a basis (standard) or the given by the uiCallId. */
    if ((uiMessage & errOsStateGetMask) == errOsStateAsIs)
    { /* Extract the upper two bits  containing the status info from the standard status. */
      uiWorkStatus = uiOsStatus & defContextGetMask; }
    else
    { /* Use the StateOs as forced status (i.e. assume we are in the OS state) */
      uiWorkStatus = defContextStateOs; }
    /* We first calculate when we have a fatal error. That is the case is the error in itself is
     * fatal, or if we arrive here from an isr. */
    const Tbool bFatal = (uiBareMessage >= errFatalError) || (uiWorkStatus == defContextStateIsr);
    /* We may normally return only in one special case. Of course the error may not be fatal, and we must come
     * here from the OS itself, (or we must be told we come from the OS itself) */
    const Tbool bReturn = !bFatal && (uiWorkStatus == defContextStateOs);
  #endif
  /* Strip the error type information from the call Id */
  Tuint08 uiBareCallId = (uiCallId & errCallIdGetMask);
  /* If we do not return we reset the stack to prevent stack overflow when handling the error code.
   * We don't need the preserve stack anymore. Note, that we should note have a stack frame present.
   * Pushed variables are not important when we no not return. */
  if (!bReturn) { privSetStack(&xOS.StackOS[OSstackInit]); }
  /* We disable tick interrupts, needed to be deactivated in case we should return. We do that here, after a possible
   * stack transplant since this call may make use of the stack. It must be done before global interrupts are
   * activated again. */
  privDisableTickInterrupts();
  /* Now determine the task number. */
  Tuint08 uiTaskNumber;
  /* Test if we must use the given task number by uiInfo or the current one. This flag is used because
   * from a lot of places its much sorter to set the flag than to calculate the current task number.
   * Do not use the privTaskNumber() method, for we do not want to introduce stack use here. */
  if ((uiMessage & errTaskStateGetMask) == errTaskStateCurrent)
  { /* Deduce the current task number from the Status */
    uiTaskNumber = (uiOsStatus & defTaskNumberGetMask) >> defOsTaskNumberShift;
    /* Reconstruct the uiInfo byte, that will be send to the error method later on */
    uiInfo = (uiInfo & errTaskNumberSetMask) | (uiTaskNumber << errTaskNumberShift); }
  else
  { /* Read the task number from the given byte, probably the current task is not the one giving problems */
    uiTaskNumber = (uiInfo & errTaskNumberGetMask) >> errTaskNumberShift ; }
  /* Now, show the error,  if we had a fatal error it makes no sense to continue operations,
   * so the only thing we can do is show the error again*/
  do { portShowError(uiBareMessage,uiBareCallId,uiInfo); } while (bFatal);
  /* Now, if we return, we must be sure we have enough OS stack space. Since error handling can be
   * stack hungry, let us check that here. This may invoke an other error. But since we know
   * that, if it occurs, it will be fatal, there cannot be a loop. */
  #if (cfgCheckOsStack == cfgTrue)
    privCheckOsStackLevel();
  #endif
  /* In case we had a normal error we want to continue, but since it is reasonable to assume that it
   * may have taken some time, the user has probably stop the timer, if he did not misused the timer
   * to make some leds blink. In any case its best to restart the timer. We have to live with the
   * fact that real time and timer ticks are out of sync anyway. Note that the user may use the timer,
   * but may not activate the interrupt. */
  portSetupTimerInterrupt();
  /* We return from this call with a setup timer, and with tick interrupts disabled. The global interrupts
   * are still disabled. If we have no os protection we must re-enable global interrupts again. */
  #if (cfgIntOsProtected == cfgFalse)
    privEnableGlobalInterrupts();
  #endif
  /* All errors not being fatal at least must stop the current or requested task and put it in error mode.
   * (This cannot be an isr anymore, and all non fatal Os errors are about some task.) */
  TtaskControlBlock * taskTCB = privTcbList(uiTaskNumber);
  /* Note that the task is terminated, but it's locks are not removed, since this is an error
   * condition, it is unclear what the result would be, so that this cannot be compared with
   * a normal terminate, in which case the user can take precautions for released blocks etc. */
  taskTCB->uiTaskStatus = defBaseTerminatedTask;
  /* In case we may have a shared task, we must check if this was one and thus if we must
   * reset the ShareStatus. */
  #if (defUseSharedStack == cfgTrue)
    /* In case all tasks are shared, we know that we must reset. */
    #if (defAllSharedStack == cfgFalse)
      /* If not, we need the initial status of the task */
      #if (defInitialStatusConstant == cfgTrue)
        /* if we are lucky that is a constant. */
        Tuint08 uiInitialStatus = defInitialStatusFixed;
      #else
        /* if not, that must be read from flash. */
        Tuint08 uiInitialStatus = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint08,uiInitialStatus);
      #endif
    /* Test if this task is a shared task.  */
    if ((uiInitialStatus & defInitialSharedGetMask) == defInitialSharePresent)
    #endif
    { /* If so, we must identify this shared task as shared. */
      taskTCB->pcStackLevel = defStackEmpty;
      /* and then we know, since is was running, we must reset the share state. */
      uiOsStatus = ((uiOsStatus & defShareStateSetMask) | defShareStateAbsent);  }
  #endif
  /* If we are at a task, or at some operations within the OS that handle a specific task,
   * we can leave this method by asking for a task switch. This is not a normal return.
   * Note that in this case the AuxRegBit (if used) can be set. Here, that is not a problem
   * for there are no switching interrupts that can take place. */
  if (!bReturn) { privEnterOS(defActionTaskStateSwitch); }
  /* Otherwise we are done, and return to the OS operations that generated the error. */ }

#endif


#if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)

static void privCheckOsStackLevel(void)
{ /* We are going to check if we overflowed the Os Stack. We should only arrive here if we are
   * in OS space, i.e. if we are sure the stack pointer actually should be inside the OS stack. */
  Taddress pStack;
  Tuint16 uiOsStackSize;
  /* Obtain the current stack pointer. */
  privGetStack(pStack);
  /* Calculate the Stacksize, we have to distinguish between the different stack types. Note we
   * assumed the stack pointer points to the byte that will be written next, i.e. the stack pointer
   * is post decrement.  */
  #if (cfgSysStackGrowthUp == cfgTrue)
    uiOsStackSize = ((Tuint16) pStack - (Tuint16) &xOS.StackOS[0]);
  #else
    uiOsStackSize = ((Tuint16) &xOS.StackOS[(StackSizeOS)-1] - (Tuint16) pStack);
  #endif
  /* Now, we do not incorporate the StackSafety parameter into our calculation. That parameter is
   * used for task stacks only. And, besides that, the call to this function, i.e.. privCheckOsStack
   * costs two bytes extra anyway */
  #if (cfgCheckWatermarks == cfgTrue)
    if (uiOsStackMax<uiOsStackSize) uiOsStackMax=uiOsStackSize;
  #endif
  #if (cfgCheckOsStack == cfgTrue)
    if (uiOsStackSize>(StackSizeOS)) { privShowError((fatOsStackOverflowed | errTaskStateNon), callIdSystem ,errNoInfo); }
  #endif
}

#endif


#if (cfgCheckWatermarks == cfgTrue) && (cfgSysReuseOsStack == cfgFalse)

static void privCheckOsStackRegion(void)
{ /* We are going to check which part of the stack space is used. Note, this routine is not capable
   * of detecting a stack overflow. In that case, it will simple see that the whole of the space
   * has been used. */
  Taddress pStack;
  /* Start with the largest detectable stack size. */
  Tuint08 uiOsStackSize = StackSizeOS;
  /* If the whole stack already has been used, there is nothing to check */
  if (uiOsStackMax < uiOsStackSize)
  { /* Calculate the Stack size, we have to distinguish between the different stack types. */
    #if (cfgSysStackGrowthUp == cfgTrue)
      /* Find the beginning of the stack. */
      pStack = &xOS.StackOS[(StackSizeOS)-1];
      /* loop downwards until we find the first used byte, or until we reach a previous boundary whatever comes first. */
      while ((*(pStack--) == defStackInitByte) && ((uiOsStackSize--)>uiOsStackMax));
    #else
      /* Find the beginning of the stack. */
      pStack = &xOS.StackOS[0];
      /* loop upwards until we find the first used byte, or until we reach a previous boundary whatever comes first. */
      while ((*(pStack++) == defStackInitByte) && ((uiOsStackSize--)>uiOsStackMax));
    #endif
    /* Load the new boundary. */
    uiOsStackMax=uiOsStackSize; } }

#endif



#if (cfgCheckMethodUse == cfgTrue) && (defCapabilitiesFull == cfgFalse)

static void privCheckCapabilities(Tuint08 uiCallId, Tuint08 uiTaskCaps)
{ /* Use this function to see if the task is capable of the required functions.
   * The function is not needed if all tasks have full capabilities, for there is nothing
   * to check in that case. Note this function can only check the capabilities of the
   * current function. If we happen to be in isr space (genXXXX functions) the current
   * function has no meaning, and the check is omitted. */
  Tuint08 uiTaskNumber;
  /* The current task has no meaning inside an isr, so there is nothing to check in that case */
  if ((uiOsStatus & defContextGetMask) == defContextStateIsr) { return; }
  /* If no, extract the current task number. */
  uiTaskNumber = (uiOsStatus & defTaskNumberGetMask) >> defOsTaskNumberShift;
  /* Get the capabilities of the task*/
  Tuint08 uiDefinedCaps = portFlashReadByte(Tuint08,uiCapabilities[uiTaskNumber]);
  /* Check if the capabilities match, with ~ all non defined caps turn high, if it matches with a
   * required cap, this is an error. */
  Tuint08 uiViolation = (uiTaskCaps & ~uiDefinedCaps);
  /* Thus if the value equals zero all required capabilities are present, otherwise some are absent. */
  if (uiViolation != 0)
  { /* Determine the highest violation (binary log) */
    Tuint08 uiInfo = 8;
    /* Check if this is the violating bit */
    while ( (uiViolation & 0x80) == 0 )
    { /* If not it could be bit 6, so we decrease the counter one ... */
      uiInfo--;
      /*  and shift the 6th bit to the 7th */
      uiViolation <<= 1; }
    /* Report an error and stop the task if the requested capabilities are absent. The ControlTaskNumber
     * also contains the realm in which we currently are.  */
    privShowError((errInsufficientCapabilities | errTaskStateInfo | errOsStateAsIs), uiCallId, (uiInfo << errInfoNumberShift) | (uiTaskNumber << errTaskNumberShift)); } }

#endif


#ifdef portInitContext

static Taddress privInitContext(Taddress pTaskStart, Taddress pStackTop, Tuint08 uiRegisterCount, Tuint08 uiInterruptStart)
{ /* Arrive here to set up the initial stack. Of course this is machine dependent, but not very
   * strongly. For 8 bits cpu's it is fairly general. Just place the return address, the registers
   * and the status. Here the values are just cleaned. If needed we can add a portInitConext call
   * on the basis of an option. */
  Tuint16 uiStartAddress = (Tuint16) pTaskStart;
  /* At the bottom of the artificial stack the start address of each task is defined. This is a pointer
   * to your Loop code. */
  *(pStackTop--) = (Tuint08) uiStartAddress;
  *(pStackTop--) = (Tuint08) (uiStartAddress >> 8);
  /* If we have a program counter of more than 16 bit, call instructions push three bytes
   * into the stack. We must take that into account. Unfortunately, i believe, gcc is not
   * able to handle pointer larger as 64K words in the current setting. Thus this will
   * effectively be zero, thus although you need something like
   *   *(pStackTop--) = (Tuint08) (pTaskStart >> 16);
   * we will use: */
  #if (defThreeByteAddress == cfgTrue)
    *(pStackTop--) = 0;
  #endif
  /* We rely upon register cleaning done by the Femto OS, or the precleaning done by privTaskInit(). */
  pStackTop -= uiRegisterCount;
  /* The way the status register is setup depends on the state of the interrupts. These can be specified per task
   * or (easier, and shorter) in general. Note that the optimization is not needed in a strict sense, the variable
   * uiInterruptStart constrains the interrupt start information, even if this is constant for all tasks. But, of course,
   * the lower part generates shorter code. */
  #if (defInterruptStartConstant == cfgFalse)
    /* If we specify the CPU status register per task, we need to prepare them per task. uiInterruptStart contains
     * the information about which interrupts must be activated. The other bits of the status register cannot be
     * set individually (there is no need in general) */
    Tuint08 uiInitCPUStatusRegister = defInitCPUStatusRegister | (0 << portInitModeInterruptLoc);
    /* Test if global interrupts must be activated at the start, if so set the specified bit. */
    #if (cfgIntGlobalOnly ==  cfgTrue)
      /* In case we have a mapping from tick interrupts on global interrupts, we require both interrupts
       * to be activated before activating the global interrupt. */
      if ((uiInterruptStart & ((cfgGlobSet | cfgTickSet) & defInitialInterruptGetMask)) == ((cfgGlobSet | cfgTickSet) & defInitialInterruptGetMask)) { uiInitCPUStatusRegister |= (1 << portInitGlobalInterruptLoc); }
    #else
      /* Otherwise we just test the global interrupt setting. */
      if ((uiInterruptStart & (cfgGlobSet & defInitialInterruptGetMask)) != defInitialInterruptAbsent) { uiInitCPUStatusRegister |= (1 << portInitGlobalInterruptLoc); }
    #endif
    /* Test if tick interrupts must be activated at the start, if so set the specified bit. */
    #if (cfgIntTickTrack == cfgTrue)
      if ((uiInterruptStart & (cfgTickSet & defInitialInterruptGetMask)) != defInitialInterruptAbsent) { uiInitCPUStatusRegister |= (1 << portInitTickInterruptLoc); }
    #endif
    /* The status register is put at the end of the stack. (See portSaveContext for the reason why) */
    *(pStackTop--) = uiInitCPUStatusRegister;
  #else
    /* Set up the status register with the initial interrupt states: global set and tick set */
    #if (((defInterruptStartFixed) & cfgGlobSet) == cfgGlobSet) && (((defInterruptStartFixed) & cfgTickSet) == cfgTickSet)
      *(pStackTop--) = defInitCPUStatusRegister | (0 << portInitModeInterruptLoc) | (1 << portInitGlobalInterruptLoc) | (1 << portInitTickInterruptLoc);
    /* Set up the status register with the initial interrupt states: global set and tick clear */
    #elif (((defInterruptStartFixed) & cfgGlobSet) == cfgGlobSet) && (((defInterruptStartFixed) & cfgTickClear) == cfgTickClear)
      #if (cfgIntGlobalOnly == cfgTrue)
        /* In case we have a mapping from tick interrupts on global interrupts, global interrupts cannot be activated if tick interrupts are not activated */
        *(pStackTop--) = defInitCPUStatusRegister | (0 << portInitModeInterruptLoc) | (0 << portInitGlobalInterruptLoc) | (0 << portInitTickInterruptLoc);
      #else
        /* Default situation. */
        *(pStackTop--) = defInitCPUStatusRegister | (0 << portInitModeInterruptLoc) | (1 << portInitGlobalInterruptLoc) | (0 << portInitTickInterruptLoc);
      #endif
    /* Set up the status register with the initial interrupt states: global clear and tick set */
    #elif (((defInterruptStartFixed) & cfgGlobClear) == cfgGlobClear) && (((defInterruptStartFixed) & cfgTickSet) == cfgTickSet)
      *(pStackTop--) = defInitCPUStatusRegister | (0 << portInitModeInterruptLoc) | (0 << portInitGlobalInterruptLoc) | (1 << portInitTickInterruptLoc);
    /* Set up the status register with the initial interrupt states: global clear and tick clear */
    #elif (((defInterruptStartFixed) & cfgGlobClear) == cfgGlobClear) && (((defInterruptStartFixed) & cfgTickClear) == cfgTickClear)
      *(pStackTop--) = defInitCPUStatusRegister | (0 << portInitModeInterruptLoc) | (0 << portInitGlobalInterruptLoc) | (0 << portInitTickInterruptLoc);
    #elif (defNumberOfTasks == 0)
      /* without tasks there is nothing to set. */
    #else
      /* well, we never come here. */
      #error "Parameter 'defInterruptStartFixed' is misspeld or incorrect (You should not arrive here)."
    #endif
  #endif
  /* Done, let the caller know where the stack ended. */
  return pStackTop; }
#endif


static TtaskControlBlock * privTcbList(Tuint08 uiTaskNumber)
{ /* This method may not be called with defCurrentTaskNumber any longer. Unfortunately we
   * cannot check if we violate that, because that may corrupt stack in privInitOs().
   * The location of the task control block is stored in flash, be careful, use the correct
   * instructions to retrieve it. */
  return portFlashReadWord(TtaskControlBlock *,pxTCBlist[uiTaskNumber]); }


static Tuint08 privTaskNumber(Tuint08 uiTaskNumber)
{ /* Check if we are interested in the current task */
  if ((uiTaskNumber & defCurrentTaskMask) == defCurrentTaskNumber)
  { /* If yes, replace the uiTaskNumber with the current task number. */
    uiTaskNumber = (uiOsStatus & defTaskNumberGetMask) >> defOsTaskNumberShift; }
  return uiTaskNumber; }


#if (defRegisterUseConstant == cfgFalse)

static Tuint08 privRegisterCount(Tuint08 uiRegisterUse)
{ /* We want to count the number of register this uiRegisterUse byte represent. Each set bit
   * counts for four registers.  */
  /* uiCount accumulates the number of set bits */
  Tuint08 uiCount = 0;
  /* Loop  through all bits of the uiRegisterUse byte. Start with 'do' for the most optimal compiler result. */
  do
  { /* Increase the counter if the bit is set by four since every bit represents four registers. */
    if ((uiRegisterUse & 0x01) == 0x01) { uiCount+=4; }
    /* Shift to the next bit */
    uiRegisterUse >>= 1; }
  while (uiRegisterUse);
  /* When uiRegisterUse equals zero there are no bits left. We are done. */
  return uiCount; }

#endif


static void privTaskInit(Tuint08 uiTaskNumber, Tuint08 uiInitControl)
{ /* Tasks are initialized in this routine. Note the fields:
   * uxDelay, siQueuLock, uiLoadCollect, uiLoadTotal, uiStackMax, uiRegisterUse
   * are not cleared when we re-initialize the task. Only about uxDelay there could
   * be debate since the would indicate the last wake time. But what is a last wake
   * time in this case. We could set it to the current time, but have not done so.  */
  /* Report that we are initializing this task. */
  privTrace(traceTaskInit | uiTaskNumber);
  TtaskControlBlock * taskTCB = privTcbList(uiTaskNumber);
  /* In case we might return here due to a watchdog bark or a restart or so. some old connections
   * must be closed when present. */
  #if (defReUseTaskInit == cfgTrue)
    /* And if asked for it. */
    if ((uiInitControl & defInitLockGetMask) == defInitLockRelease)
    { /* In case we use synchronization and the watchdog or want to be able to manually restart a task
       * it may be that the task that has to be re-initiated is holding some locks. These must be released properly
       * We need only to release locks on other tasks that are held by this task. Since waits cannot be non-blocking
       * it can safely be ignored here. Hmm, some other task may call restart on a blocking task on wait. So it seems
       * better to always clean when synchronization is used. */
      #if (cfgUseSynchronization != cfgSyncNon)
        /* we only need to check if the task contains a slot. */
        if (uiTaskNumber < defNumberOfTasksWithSlot)
        { /* We may only enter here if the particular task indeed has a slot stack, otherwise there is nothing clean
           * If we made use of priority lifting, we do not need to do anything. We can simply clean the slot stack. */
          privCleanSlotStack((TtaskExtendedControlBlock *) taskTCB );
          /* and any task that may run freely now will be release by the call below. Please note that is not possible
           * that is call releases the present task, since all its slots have been wiped. */
          #if ((defUseMutexes == cfgTrue) || (defUseQueus == cfgTrue))
            privReleaseSyncBlockingTasks();
          #endif
          }
      #endif
      /* At this point we must check if we have some kind of lock in the file system and we need
       * to release this and other tasks. Only include code if this is possible at all. */
      #if (cfgUseFileSystem == cfgTrue)
        /* We can simply try to close a file. If no lock is hold and no blocks are present this method returns
         * without any harm done. Of course it is more overhead, but we assume this part of the code is rarely executed
         * and therefore we do not want to invest the bytes. There are quite a number of situations in which the task
         * can be caught when killed. All these situations are handled by the method. */
        privPrepareFileClose(uiTaskNumber);
      #endif
    }
  #endif
  /* Read the priority the task will start with is contained in the lowest nibble this number, the start state
   * information is contained in the highest nibble. the interrupt state in both. While the handling for the
   * priority is simple, simply replace it or not, depending on the defInitStatusPrio, the start state
   * requires a more complex handling. Globally this routine provides the following services to the caller
   * (1) Load the start state from flash, this is the default action
   * (2) Load the start state from the uiInitControl, use defInitStatusCopyDo
   * (3) Load the start state from the uiInitControl, but allow for a fall back scenario for the default state
   * (4) Make sure that the start state is 'shared' instead of 'running' for shared tasks.
   * Apart from these facilities, it also provide a facility to set the shared state bit in
   * the OS status. If the task was running before, but is not running afterwards, this but must
   * be reset and vice versa.
   * First read the initial status from flash, or use a constant value. */
  #if (defInitialStatusConstant == cfgTrue)
    Tuint08 uiInitialStatus = defInitialStatusFixed;
  #else
    Tuint08 uiInitialStatus = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint08,uiInitialStatus);
  #endif
  /* We can call this with a predefined state or with a default state, in which case we want to restart
   * like we started at the beginning. */
  #if (defUseSharedStack == cfgTrue) || (includeTaskRestart == cfgTrue)
    /* Since the bit pattern of the default start state equals the one of the shared state, and since we
     * know we can never explicitly set the state to be shared from the outside (this is always a modified
     * running state) We must first test if we have a default state. */
    if ((uiInitControl & defInitialStartGetMask) == defRestartDefault )
    { /* We do not need to copy the start information from the uiInitControl if the caller asked for a default
       * If it is not equal, we leave leave the copy bit alone. Most of the time however, there will not
       * be a request for a copy, so this does nothing.*/
       uiInitControl =  (uiInitControl & defInitStatusCopySetMask) | defInitStatusCopyDont; }
  #endif
 /* If we have a suspend request, this will be honored at this place. This may override the previous
  * situation. Tasks cannot ignore a suspend request at this moment. Suspend requests are only possible
  * when genSuspend() is present: */
  #if (includeGenSuspend == cfgTrue)
    /* test if the request has been made */
    if ((taskTCB->defSusField & defSusGetMask) == defSusRequest)
    { /* if so, we must set the StatusCopy and the suspended restart: */
      uiInitControl =  (uiInitControl & (defInitStatusCopySetMask & defInitialStartSetMask)) | (defRestartSuspended | defInitStatusCopyDo);
      /* We do not need to clear the SusRequest separately since that is done below in
       * the clearance of the TaskMonitor. */ }
  #endif
  /* If we were running, and make use of a shared stack, we must inform the OS that we stopped a running
   * shared state (unless we continue to run, but that is not the default, and not possible in this routine)
   * This is however only needed if we are not actively are creating a context .*/
  /* If we make use of shared tasks we must inform the OS about the situation. */
  #if (defUseSharedStack == cfgTrue)
    /* And only if the current task is indeed a shared task */
    #if (defAllSharedStack == cfgFalse)
       /* If all tasks are shared this test is always true, so skip it. */
      if ((uiInitialStatus & defInitialSharedGetMask) == defInitialSharePresent)
    #endif
    { /* Retrieving the uiOsStatus is a costly operation, so lets work via a register
       *  gcc optimization does not recognize this.  */
      Tuint08 uiStatusCopy = uiOsStatus;
       /* If so, we must test if we want to activate a shared task, if so we must create a context (see below) */
      if ((uiInitControl & defInitSharedGetMask) == defInitSharedActive)
      { /* and set the shared bit of the OS status */
        uiStatusCopy = ((uiStatusCopy & defShareStateSetMask) | defShareStateRunning); }
      else
      { /* Task that are not rescheduled right now need no context */
        uiInitControl  = (uiInitControl & defInitContextSetMask) | defInitContextKeep;
        /* Shared tasks that are not scheduled for running may not be in the shared mode,
         * but be put to sleep or be suspended from the outside. The only way to recognize
         * such tasks is at the stack level being zero. Other way around, if the stack
         * level does not equal zero, it must have been running, or been put to sleep/suspend
         * block while running, and is holding the share state. Since we are to passivy this
         * state, we clear the bit.  */
        if (taskTCB->pcStackLevel != defStackEmpty)
        { /* If so, we are stopping the only running shared task, and must inform the OS
           * so it can select a new one. */
          uiStatusCopy = ((uiStatusCopy & defShareStateSetMask) | defShareStateAbsent);
          /* and make sure that the stack is empty so this is recognized */
          taskTCB->pcStackLevel = defStackEmpty; }
        /* This is the place to correct the situation where we have asked for a running state
         * but we are going to get into a shared state, since a shared tasks can only be
         * in the running state when we have a valid context, ie.e  on defInitContextRenew.
         * We need only to check the first bit of the state, since if it is set the second
         * must be set too, or if it is not, it is already in the shared state (what is a
         * defRestartDefault actually. */
        if ((uiInitControl & defBaseStopStateGetMask) == defBaseStopStateGo )
        { /* So we have requested for a defRestartRunning, change it to defRestartShared. */
          uiInitControl = (uiInitControl & defBaseModeSetMask) | defBaseModeShared; } }
        /* Dont forget to put the copy back */
        uiOsStatus = uiStatusCopy; }
    /* If we are putting a task to sleep, and that task happens to be a shared task, the sleep
     * instruction must be interpreted as a restart. However, this is only the case for shared
     * tasks. Therefore we have a special option to indicate this situation, which is only
     * uses for this special case. For regular tasks we want to leave this routine after
     * the specialties for shared tasks have been skipped.
     * Test if we have a low power sleep possibility */
    #if (cfgUseLowPowerSleep == cfgTrue)
      /* If all tasks are shared, we do not test for the defInitialSharePresent thus we also
       * not have an alternative branch. We simply always have to test if we want to leave. */
      #if (defAllSharedStack == cfgFalse)
        /* otherwise we will only perform the test below in case we are certain we have
         * a regular task. */
        else
      #endif
      { /* if we have a regular task, but we wanted to process shared tasks only we are done. */
        if ((uiInitControl & defInitProcessGetMask) == defInitProcessSharedOnly ) { return; } }
    #endif
  #endif
 /* The defInitStatus indicates if we want to prepare a new TaskStatus. This is needed upon first use, as it
  * contains the initial run state, its priority etc. The structure of the information is not identical to
  * the uiTaskStatus. The priority and start state are on the same location, but on the location if the lock bit,
  * the delay bit and the dress bit other information is stored. This must be corrected. For shared tasks, the
  * task starts in the shared mode. Upon first pass thats OK (no shared running, but if a running task is
  * modified to shared extra measures might be needed. In any case, a new or renewed task, is not blocked,
  * delayed of dominant, therefore we set those bits. */
  Tuint08 uiIntialFilteredStatus = (uiInitialStatus & (defBaseBlockStateSetMask & defBaseDelayStateSetMask & defBaseDressSetMask) ) | (defBaseBlockStateFree | defBaseDelayStateWake | defBaseDressDone);
  /* Depending on the fact if we are able to return here we can directly set its initial state, or
   * we must be more careful. In case there is the possibility to return here: */
  #if (defReUseTaskInit == cfgTrue)
    /* See what must be kept from the original status, and what must be read from flash. uiInitControl contains
     * a bit mask for those pieces we want to retain from the original task status. The default is to
     * read everything from flash except for the priority information. The start state may be overwritten
     * later on. */
    if ((uiInitControl & defInitStatusPrioGetMask) == defInitStatusPrioKeep)
    { /* If we indeed must replace the priority, do so in the uiIntialFilteredStatus */
      uiIntialFilteredStatus =  (uiIntialFilteredStatus  & defInitialPrioritySetMask) | (taskTCB->uiTaskStatus & defInitialPriorityGetMask); }
    /* In three situations we may ask for a copy of the start state from the uiInitControl parameter */
    #if (defUseSharedStack == cfgTrue) || (includeTaskRestart == cfgTrue) || ((cfgUseTaskWatchdog == cfgTrue) && (includeGenSuspend == cfgTrue))
      /* If we have a request for copying the start state from the control (this request may be from outside,
       * but is not valid for the a start state being defRestartDefault, in which case the copyDo was cleared
       * above */
      if ((uiInitControl & defInitStatusCopyGetMask) == defInitStatusCopyDo)
      { /* Replace the first start bits by the bits given in the control parameter. */
        uiIntialFilteredStatus = (uiIntialFilteredStatus & defBaseRestartSetMask) | (uiInitControl  & defBaseRestartGetMask); }
    #endif
  #endif
  /* Set the newly prepared  task status. */
  taskTCB->uiTaskStatus = uiIntialFilteredStatus;
  /* Fields uiTaskMonitor is initialized. Usually the init bytes are 0x00. If we
   * have no watchdog and no TaskRestart/TaskRecreate we can only arrive here one time. If the init fields are
   * 0x00 so we may rely upon the cleaning of the .bss section to reset these fields.
   * In other cases however we must explicitly clean/initialize those fields. */
  #if (defUseTaskMonitor == cfgTrue) && ((defReUseTaskInit == cfgTrue) || (defTaskMonitorInit != 0x00))
    taskTCB->uiTaskMonitor = defTaskMonitorInit;
  #endif
  /* Fields uiTasksLevels is initialized. Usually the init bytes are 0x00. If we
   * have no watchdog and no TaskRestart/TaskRecreate we can only arrive here one time. If the init fields are
   * 0x00 so we may rely upon the cleaning of the .bss section to reset these fields.
   * In other cases however we must explicitly clean/initialize those fields. */
  #if (defUseTaskLevels == cfgTrue) && ((defReUseTaskInit == cfgTrue) || (defTaskLevelsInit != 0x00))
    taskTCB->uiTaskLevels = defTaskLevelsInit;
  #endif
  /* If we keep track of the watermarks we renew them when we renew the priority */
  #if (defReUseTaskInit == cfgTrue) && (cfgCheckWatermarks == cfgTrue)
    /* ... Initializing the task may (requested through the call) require resetting those levels. */
    if ((uiInitControl & defInitStatusPrioGetMask) == defInitStatusPrioRenew)
    { /* If so, clean the StackMax level and the use of the registers. */
      taskTCB->uiStackMax = 0;
      taskTCB->uiRegisterUse = 0; }
  #endif
  /* We make a new context if this is a one time call, ... */
  #if (defReUseTaskInit == cfgTrue)
    /* ... or if we specially ask for it ... */
    if ((uiInitControl & defInitContextGetMask) == defInitContextRenew)
  #endif
  { /* Report that we are making the context of this task. */
    privTrace(traceCreateContext);
    /* pcStackOffset is a pointer to the beginning of the stack of this task, it is located in flash. */
    Taddress pcStackOffset = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Taddress,pcStackOffset);
    /* We need the place where the task starts. This is placed on the context as return address. It is located in flash */
    Taddress pTask = portFlashReadWord(Taddress,pxLooplist[uiTaskNumber]);
    /* Register compression requires information on which registers must be saved. Every bit stands for
     * four bits to save. If we make use of Register Compression with variable registers per task we must
     * load the information from flash. otherwise we just may use the constant here.
     * Here we count how may registers will be saved on the stack. For each register one byte will be reserved.
     * If all RegisterUse parameters are equal, we can calculate the number at compile time. */
    #if (defRegisterUseConstant == cfgTrue)
      /* The constant defRegisterCount holds the number of registers used.*/
      Tuint08 uiRegCount = defRegisterCount;
    #else
      /* The register use must be read from flash.  */
      Tuint08 uiRegisterUse = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint08,uiRegisterUse);
      /* We have to calculate the number dynamically */
      Tuint08 uiRegCount = privRegisterCount(uiRegisterUse);
    #endif
    /* We need the StackSize if we must clean the stack before use  */
    #if (defStackClean == cfgTrue)
      /* Get the reserved stack space from flash, or use the constant if all stack sizes are identical Note that, if we
       * don't check, we don;t need the uiStackSize information. It is simply assumed there is enough. */
      #if (defStackSizeConstant == cfgTrue)
        Tstack uiStackSize = defStackSizeFixed;
      #else
        Tstack uiStackSize = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tstack,uiStackSize);
      #endif
    #endif
    /* Clean the stack and set up the context. The method portInitContext makes room the return address.
     * the device status register and all registers used. */
    #if (cfgSysStackGrowthUp == cfgTrue)
      /* First fill the whole stack with the defStackInitByte if needed */
      #if (defStackClean == cfgTrue)
        Taddress pStackTop = pcStackOffset;
        while (uiStackSize--) { *(pStackTop++) = defStackInitByte; }
      #endif
      /* Subsequently define the context. */
      taskTCB->pcStackLevel = (Tstack) ((Tuint16) portInitContext(pTask, pcStackOffset, uiRegCount, uiInitialStatus) - (Tuint16) pcStackOffset);
    #else
      /* First fill the whole stack with the defStackInitByte if needed */
      #if (defStackClean == cfgTrue)
        Taddress pStackTop = pcStackOffset;
        while (uiStackSize--) { *(pStackTop--) = defStackInitByte; }
      #endif
      /* Subsequently define the context. */
      taskTCB->pcStackLevel = (Tstack) ((Tuint16) pcStackOffset - (Tuint16) portInitContext(pTask, pcStackOffset, uiRegCount, uiInitialStatus));
    #endif
  } }


static void privEnterOS(Tuint08 uiAction)
{ /* This is the method to call to start the OS functions. Its is typically called from yield,
   * delay etc, but also from the switching api functions after the completed their task. The
   * action parameter states the intention of the caller. It contains whether or not we should
   * switch the task, and if a tick occurred.
   * Report that we are starting OS specific actions */
  privTrace(traceOsStart);
  /* Now is the time to permanently set the status of the system to OS. */
  uiOsStatus = ((uiOsStatus & defContextSetMask) | defContextStateOs);
  /* First we check if no event has taken place. */
  #if (cfgUseEvents == cfgTrue)
  /* Handling events must take place in an protected environment. */
    #if (cfgIntOsProtected == cfgFalse)
      privDisableGlobalInterrupts();
    #endif
    /* Check if there are any event set */
    if (portEventRegister != defAllEventsReset)
    { /* OK, we have to handle the events and possibly deblock some tasks. If we invert the Event
       * register, we have '1' on all places that must be left alone, and '0' on those places where
       * the bits may be reset. */
      Tuint08 uiInvEvent = ~portEventRegister;
      /* Don't forget to reset the event register */
      portEventRegister = defAllEventsReset;
      /* Loop through all tasks possibly waiting on an event. */
      Tuint08 uiLoopTask;
      for (uiLoopTask=defTaskNumberEventBegin; uiLoopTask<defTaskNumberEventEnd; uiLoopTask++)
      { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
        /* Test if the task is really waiting on events */
        if (loopTCB->uiTaskEvents != defAllEventsReset)
        { /* reset all events that are fired */
          loopTCB->uiTaskEvents &= uiInvEvent;
          /* Check if there are any events left. */
          if (loopTCB->uiTaskEvents == defAllEventsReset)
          { /* If not, unblock this task. */
            privUnblockTask(uiLoopTask | defParaLockStateUnlock | defParaRetStateTrue);
            /* If we have unblocked a task, we make sure we switch tasks asap */
            /* TODO v0.90: If we are returning a full byte, it must not be possible to
             * switch the task since there will be only one return value register. */
            uiAction |=  defActionTaskStateSwitch; } } } }
    /* Done, restore interrupts if needed */
    #if (cfgIntOsProtected == cfgFalse)
      privEnableGlobalInterrupts();
    #endif
  #endif
  /* If we do not want to switch, we are quickly done. Note that time measurement is also
   * skipped, so, we may not skip this to often, often being a full round of the subticktimer.
   * Normally however, this is a one time action, because a regular entry over here due to
   * an interrupt will not skip this section. */
  if ((uiAction & defActionTaskGetMask) == defActionTaskStateSwitch)
  { /* If we make use of a file system we must check if there is a task waiting for a burn lock
           * to finish (this can only be one task at most. */
    #if (cfgUseFileSystem  ==  cfgTrue)
      /* Look if we have a burn lock active, if so there must be a write lock too, so we do not need to check that. */
      if ((uiFsStatus & defFsBurnBlockGetMask) == defFsBurnBlockActive)
      { /* If so we test if the file system is ready for a new byte to be written */
        if (portFSWriteReady())
        { /* Tell we may burn again. In this case we must clean the burn lock in the uiFsStatus, we do so below. */
          privTrace(traceBurnFree);
          /* Check if we are just waiting for a FS release. In this situation there is no task
           * actually writing, but one of the write tasks was somehow terminated, and the system
           * must wait with the release of new tasks until the burn block is gone. */
          if ((uiFsStatus & defFsReadBlockGetMask) == defFsReadBlockReleaseRequest)
          { /* Clear everything in the status register, except a possible request for sleep. */
            uiFsStatus = (uiFsStatus & defFsFreeSetMask) | defFsFree;
            /* There could be other tasks waiting to be released and perform file operations. Always, directly
             * after a task completed its file operations, it must call for a release of new tasks. There is
             * no automatic dispatch mechanism to activate the tasks independently. */
            privReleaseFileBlocks(); }
          else
          { /* We still have to clear the burn lock */
            uiFsStatus = ((uiFsStatus & defFsBurnBlockSetMask) | defFsBurnBlockClear);
            /* In this case we are in a simple file write operation, so extract the task
             * that was waiting for burning.  The Burn lock can not be active if no task is waiting,
             * which is essential since we have no task number indicating a 'free' state. We could check if that
             * task found has a write lock, but that should be the case */
            #if (defUseFsOnMultipleTasks == cfgTrue)
             /* In the case of multiple tasks, the task that is currently writing is in the status */
             Tuint08 uiLockTaskNumber =  (uiFsStatus & defFsWriteNumberGetMask) >> defFsTaskNumberShift;
            #else
             /* otherwise it is a fixed number determined by the preprocessor. */
             Tuint08 uiLockTaskNumber =  defUseFsSingleTaskNumber;
            #endif
            /* we must unblock the task, note that
             * this kind of block (burn block) cannot timeout, and thus the function does not return a value
             * to indicate this, we must leave the return register as it was. Naturally we keep the lock, for
             * there could be more bytes that must be written. It is not possible for a terminated task
             * to arrive here, since the taskKill routine will always try to close a lock on the file. */
            privUnblockTask(uiLockTaskNumber | defParaLockStateKeep | defParaRetStateNon); } } }
    #endif
    /* Well, let us first determine what kind of tick engine
     * we are running on. Since both types require quite a different approach the code is
     * completely separated. */
    #if (cfgUseEquidistantTicks == cfgTrue)
      /* We are running equidistant ticks. Thus the timer interrupt is set to a fixed value and
       * can only be read, but not changed. Also, the timer is of the type interrupt and clear, thereby
       * guaranteeing the most regular tick intervals. But if we are in a full cooperative mode
       * i.e. all tick interrupts masked either by disabling tick interrupts itself, of by disabling
       * global interrupts, we do not see ticks-interrupts any more and have to check manually. */
      #if (cfgIntManualTicks == cfgTrue)
        /* The check method returns true if a timer interrupt was due. The interrupt was also
         * cleaned and therefore we ask for a increase of the tick counter here. */
        if (portCheckTimer()) { uiAction |=  defActionTickStateTick; }
      #endif
      /* If we are checking timing issues or want to keep track of the load of the tasks we
       * must read the value timer. */
      #if ( (cfgCheckTiming == cfgTrue) || (cfgUseLoadMonitor == cfgTrue) )
        Tuint08 uiOsStartTime = portReadTimer();
      #endif
      /* If we want to monitor the load, some calculations are needed. Please note that this facility
       * is only available when cfgIntOsProtected == true. Otherwise there is simply no way get the
       * data to the os, since during this calculation it may be interrupted also. */
      #if (cfgUseLoadMonitor == cfgTrue)
        Tuint08 uiTaskTime;
        /* We want to calculate how much time the last task took. The subbyte contains the
         * last saved value of portReadTimer.*/
        Tuint08 uiSubByte = uxTickCount.SubByte;
        /* It is possible that we had an interrupt since we saved the the subByte. We assume,
         * that in that case uiSubByte>uiOsStartTime. This may not be true if we had a very
         * long interrupt but that cannot be checked. We cannot check one full round of the timer,
         * since we do not want to spend bytes to keep track of that.
         * If, however the timer has an unhandled interrupt, we expect the portReadTimer() function
         * to return a timer value with cfgSysSubTicksPerFullTick added to the actual value. This
         * is 'easy' to implement. */
        if (uiSubByte<=uiOsStartTime)
        /* If we have a very slow timer, we could arrive in the same subtick here, thus the equality
         * should result in the addition of zero subticks instead of cfgSysSubTicksPerFullTick. */
        { uiTaskTime = uiOsStartTime - uiSubByte; }
        /* So here we past the cfgSysSubTicksPerFullTick barrier and must correct for the situation. */
        else
        { uiTaskTime = cfgSysSubTicksPerFullTick - uiSubByte + uiOsStartTime; }
        /* If we have other interrupts at hand, the system may have spend some time there as well. We should
         * correct the uiTaskTime accordingly. Note that we cannot distinguish between different interrupts
         * of succeeding interrupts.  */
        #if (cfgIntUserDefined == cfgTrue)
          /* uiIsrLoadTemp holds the time spend in isr */
          Tuint08 uiIsrTime = uiIsrLoadTemp;
          /* This time however was erroneously incorporated in the task time, so we must correct for that error,
           * again, we assume no multiple tick interrupts in between. The test in between it to make sure the
           * value is indeed deducible, which may not be the case in rare cases */
          if (uiTaskTime > uiIsrTime) { uiTaskTime -= uiIsrTime; }
          /* Add it to the LoadCollect */
          uiIsrLoadCollect += uiIsrTime;
          /* We have read out the value of uiIsrLoadTemp and must reset it for the next interrupt. */
          uiIsrLoadTemp = 0;
        #endif
        /* Which task was running lately? */
        TtaskControlBlock * oldTCB = privTcbList(privTaskNumber(defCurrentTaskNumber));
        /* OK, this was the last task that did run, but ... did it run the very last slice or was it the
         * somewhat longer ago and did the idle time run after that? We can see the difference by looking
         * at uiAction variable. We did run a task (or isr) if we did not run the idle state. If we run the
         * idle state we must have come from privTickYield,  the RunState and running mode. We only count the time if the task is running and the state
         * is still runnable (may be delayed). Of course we miss the time of those tasks which just went
         * blocking. Since there is no other way to find out, we have to accept this (small) error. */
        if ((uiAction & defActionRunGetMask) == defActionRunStateTask)
        { /* The RunState is still set, so indeed the calculated time was due to the running of that task */
          oldTCB->uiLoadCollect += uiTaskTime; }
        else
        { /* Now the last task was the idle task, so add the time to the idle collect. Btw we could
           * also have been sleeping that difference cannot be made. However, it does not matter, since the
           * time from wakeup until now could count for idle as well. The sleep time itself is lost.*/
          uiIdleLoadCollect += uiTaskTime; }
      #endif
      /* Here we arrive at the first instruction when all checks are off. We increment the tick counter
       * if a timer interrupt has taken place. This is indicated the the uiAction parameter. Most times
       * we arrive here it is namely due to a yield of delay or so, and we can skip that step. */
      if ((uiAction & defActionTickStateTick) == defActionTickStateTick) { privIncrementTick(); }
      /* DISCUSSION
       * Sometimes the GCC compiler uses a frame pointer when there is not real need. This costs a lot
       * of flash. With the measure below we try to convince gcc that a particular register is free.
       * This seems portable since it is a request the compiler may ignore.
       * See the explanation at the option for more information. */
      #if (cfgSysFramePointerCounterMeasures == cfgTrue)
        register volatile Tuint08 uiAssignmentStatus asm ("r6");
      #else
        Tuint08 uiAssignmentStatus;
      #endif
      /* The two most important steps of the scheduler are, incrementing the tick counter, and
       * determining which task has to run next. The former is done above, and this action possible
       * waked some tasks, the latter below. The switch context results in a new task to run, or
       * the idle task that may or, or the sleep mode that the device must be put in. */
      uiAssignmentStatus = privSwitchContext();
      /* First, we check if we are put to sleep, which is done in OS space btw. If we are to sleep,
       * we are not allowed to prepare a subbyte for timing measurement, since that variable is used
       * to pass the number of allowable tick blocks to sleep.*/
      #if (cfgUseLowPowerSleep == cfgTrue)
        if ((uiAssignmentStatus & defAssignmentSleep) == defAssignmentSleep)
        { /* We indeed have to go to low power sleep. Enter the sleep mode, we do not return from this call. */
          privEnterSleep(uxTickCount.SubByte); }
      #endif
      /* If we arrive here, we are left with two possibilities, either we go run a task or go to the
       * idle state. First however, we measure how long the OS took, since most tasks of the OS are
       * done by this time. */
      #if ((cfgCheckTiming == cfgTrue) || (cfgUseLoadMonitor == cfgTrue))
        Tuint08 uiOsTime;
        /* Read the timer again. */
        Tuint08 uiOsStopTime = portReadTimer();
        /* From the moment we filled uiOsStartTime until now, that is the time the
         * OS took to run. This may not even be one subtick, so the we must test for equality too. (i.e..
         * both times being equal probably means not even one subtick, contrary to a full round of the
         * subtick timer */
        if (uiOsStartTime <= uiOsStopTime)
        { uiOsTime = uiOsStopTime - uiOsStartTime; }
        else
        { /* Again, in this case the timer interrupt fired, but is not handled yet. Hmmm, I am not
           * even sure id this situation can happen, since this should be a hanging interrupt right?
           * Well anyway, it seems save to leave the calculation in anyway */
          uiOsTime = cfgSysSubTicksPerFullTick - uiOsStartTime + uiOsStopTime; }
        /* If you already used half of the tick here, there is probably not enough time to complete
         *  the following task. Let us calculate that situation. */
        #if (cfgCheckTiming == cfgTrue)
          /* Since this may incidentally happen, and that does not cause problems
           * we calculate the continuous 4 sample average. Depending on how large that number can be
           * we need a 8 or 16 bit variable. */
          #if (cfgSysSubTicksPerFullTick >= 64)
            Tuint16   uiOsLocalTimeAverage = ((Tuint16)uiOsTimeAverage + uiOsTimeAverage + uiOsTimeAverage + uiOsTime + 2);
          #else
            Tuint08   uiOsLocalTimeAverage = (uiOsTimeAverage + uiOsTimeAverage + uiOsTimeAverage + uiOsTime + 2);
          #endif
          /* The average value however should not exceed the a one byte value */
          uiOsTimeAverage = (Tuint08) (uiOsLocalTimeAverage >> 2);
          /* If we have tracing activated, we report the actual timing and the averaged timing.
           * when they are close to the border*/
          #if (cfgCheckTrace == cfgTrue)
            if (uiOsTimeAverage > (3*cfgSysSubTicksPerFullTick/8))
            { privTrace(traceOsTime);
              privTrace(uiOsTime);
              privTrace(uiOsTimeAverage); }
            #endif
          /* If this value exceeds have the tick time, this should be reported. */
          if (uiOsTimeAverage >= (cfgSysSubTicksPerFullTick / 2))
          { /* This is a fatal error since it makes no sense to continue as this issue
             * will rise again and again. */
            privShowError((fatOsTickRateTooHigh | errTaskStateNon), callIdSystem, errNoInfo ); }
        #endif
        #if (cfgUseLoadMonitor == cfgTrue)
          /* Having calculated the time spend in the OS, add it to the Collected times. */
          uiOsLoadCollect += uiOsTime;
          /* In order to make the next time measurement possible save the last value read
           * from the timer in the Subbyte. That will be used to calculate the time spend in
           * a particular task. Of course we make a small error because the next few instructions
           * are not really part of the task. However, the same applies to the instructions
           * after the context save so we assume (hope?) these errors cancel out. */
          uxTickCount.SubByte = uiOsStopTime;
        #endif
      #endif
      /* Now check if we must perform an idle task */
      if ((uiAssignmentStatus & defAssignmentIdle) == defAssignmentIdle)
      { /* if so, call for the EnterIdle, from which we do not return */
        privEnterIdle(); }
      /* Here we are done, the next thing is to enter the privEnterTask, in order to run
       * the task chosen */
    #else
      /* We are running in the true time slice mode. Good choice, now you are sure that no tasks
       * are being starved if more are running full swing in one priority. OK, so far for the
       * advertisements. The timer interrupt is variable in this mode, and reset every time a task,
       * or the os starts. Note that the interrupts may be (and are) irregular. Ticks, however,
       * are on average, in pace with the system clock.  */
      Tuint08 uiTaskTime;
      /* Determining how long the task took is a snap, since the timer was reset just before
       * the task started. And, we must also specify how long we want to wait before the next
       * timer interrupt. Now that does not matter much here, since (tick) interrupts are disabled
       * anyhow. */
      uiTaskTime = portReadAndResetTimer(defSubTicksMax);
      /* We assume the timer did not overflow. This may happen if you choose cfgSysSubTicksPerFullTick
       * too high. But you can easily check this, see below. In this timer model the subbyte collects
       * the subticks, from which the tick counter is driven. */
      uxTickCount.SubByte += uiTaskTime;
      /* If we keep track of the task times, the only thing to do is to add uiTaskTime to the collector */
      #if (cfgUseLoadMonitor == cfgTrue)
        /* If we have other interrupts at hand, the system may have spend some time there as well. We should
         * correct the uiTaskTime accordingly. Note that we cannot distinguish between different interrupts
         * of succeeding interrupts.  */
        #if (cfgIntUserDefined == cfgTrue)
          /* uiIsrLoadTemp holds the time spend in isr */
          Tuint08 uiIsrTime = uiIsrLoadTemp;
          /* This time however was erroneously incorporated in the task time, so we must correct for that error,
           * again, we assume no multiple tick interrupts in between. The test in between it to make sure the
           * value is indeed deducible, which may not be the case in rare cases */
          if (uiTaskTime > uiIsrTime) { uiTaskTime -= uiIsrTime; }
          /* Add it to the LoadCollect */
          uiIsrLoadCollect += uiIsrTime;
          /* We have read out the value of uiIsrLoadTemp and must reset it for the next interrupt. */
          uiIsrLoadTemp = 0;
        #endif
        /* Which task was running lately? */
        TtaskControlBlock * oldTCB = privTcbList(privTaskNumber(defCurrentTaskNumber));
        /* OK, this was the last task that did run, but ... did it run the very last slice or was it the
         * somewhat longer ago and did the idle time run after that? We can see the difference by looking
         * at uiAction variable. We did run a task (or isr) if we did not run the idle state. If we run the
         * idle state we must have come from privTickYield,  the RunState and running mode. We only count the time if the task is running and the state
         * is still runnable (may be delayed). Of course we miss the time of those tasks which just went
         * blocking. Since there is no other way to find out, we have to accept this (small) error. */
        if ((uiAction & defActionRunGetMask) == defActionRunStateTask)
        { /* The RunState is still set, so indeed the calculated time was due to the running of that task */
          oldTCB->uiLoadCollect += uiTaskTime; }
        else
        { /* Now the last task was the idle task, so add the time to the idle collect. Btw we could
           * also have been sleeping that difference cannot be made. However, it does not matter, since the
           * time from wakeup until now could count for idle as well. The sleep time itself is lost.*/
          uiIdleLoadCollect += uiTaskTime; }
      #endif
      /* in this timing model we always call privIncrementTick() since the ticks added to the tick counter
       * are deduced from the value of subbyte */
      privIncrementTick();
      /* DISCUSSION
       * Sometimes the GCC compiler uses a frame pointer when there is not real need. This costs a lot
       * of flash. With the measure below we try to convince gcc that a particular register is free.
       * This seems portable since it is a request the compiler may ignore.
       * See the explanation at the option for more information. */
      #if (cfgSysFramePointerCounterMeasures == cfgTrue)
        register volatile Tuint08 uiAssignmentStatus asm ("r6");
      #else
        Tuint08 uiAssignmentStatus;
      #endif
      /* The two most important steps of the scheduler are, incrementing the tick counter, and
       * determining which task has to run next. The former is done above, and this action possible
       * waked some tasks, the latter below. The switch context results in a new task to run, or
       * the idle task that may or, or the sleep mode that the device must be put in. */
      uiAssignmentStatus = privSwitchContext();
      /* First, we check if we are put to sleep, which is done in OS space btw. If we are to sleep,
       * we are not allowed to prepare a subbyte for time measurement, since that variable is used
       * to pass the number of allowable tick blocks to sleep.*/
      #if (cfgUseLowPowerSleep == cfgTrue)
        if ((uiAssignmentStatus & defAssignmentSleep) == defAssignmentSleep)
        { /* We indeed have to go to low power sleep. Enter the sleep mode, we do not return from this call. */
          privEnterSleep(uxTickCount.SubByte); }
      #endif
      /* If we arrive here, we are left with two possibilities, either we go run a task or go to the
       * idle state, Now check if we must perform an idle task .*/
      if ((uiAssignmentStatus & defAssignmentIdle) == defAssignmentIdle)
      { /* if so, first set the Timer with the right time for the idle task, which at the same time
         * returns the time spend so far in OS */
        Tuint08 uiOsTime = portReadAndResetTimer(TimeSliceIdleTime);
        /* This is of course time spend, so must be added to the tick counter */
        uxTickCount.SubByte += uiOsTime;
        /* If we monitor the load */
        #if (cfgUseLoadMonitor == cfgTrue)
          /* the time spend in OS must be added to the appropriate collector */
          uiOsLoadCollect += uiOsTime;
        #endif
        /* End we may enter the idle task. In this case we do not have the opportunity to check
         * upon the OS time. */
        privEnterIdle(); }
      /* Arriving here means we are going to perform a regular task. So we must prepare the timers
       * for that.*/
      Tuint08 uiTimeSlice;
      /* We have two options. Either we have specified the time slice for each task separately, or
       * we use the one fits all model. */
      #if (defTimeSliceConstant == cfgFalse)
        /* Get the task number we choose to run next */
        Tuint08 uiTaskNumber = privTaskNumber(defCurrentTaskNumber);
        /* Get the value of the time slice from flash */
        uiTimeSlice   = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint08,uiTimeSlice);
      #else
        /* In the standard model, we give all tasks the same value, */
        uiTimeSlice = defTimeSliceFixed;
      #endif
      /* The time has come to determine how long the OS has run, reset the timer and set the new time slice */
      Tuint08 uiOsTime = portReadAndResetTimer(uiTimeSlice);
      /* The time spend in the OS must be added to the extended tick counter */
      uxTickCount.SubByte += uiOsTime;
      /* And, if we monitor the load ... */
      #if (cfgUseLoadMonitor == cfgTrue)
        /* to the collector of the OS load time as well */
        uiOsLoadCollect += uiOsTime;
      #endif
      /* Many things can go wrong with the timing, so the moment has come to check. */
      #if (cfgCheckTiming == cfgTrue)
        /* First, check if the time spend in the OS does not exceed one tick. Although it is not an error in the
         * strictest sense, it can do harm to the collected subticks in the subbyte, which may overflow, since
         * it cannot be cleaned on this point. Since this may incidentally happen, and that does not cause
         * problems we calculate the continuous 4 sample average.  */
        #if (cfgSysSubTicksPerFullTick >= 64)
          Tuint16   uiOsLocalTimeAverage = ((Tuint16)uiOsTimeAverage + uiOsTimeAverage + uiOsTimeAverage + uiOsTime + 2);
        #else
          Tuint08   uiOsLocalTimeAverage = (uiOsTimeAverage + uiOsTimeAverage + uiOsTimeAverage + uiOsTime + 2);
        #endif
        /* The average value however should not exceed the a one byte value */
        uiOsTimeAverage = (Tuint08) (uiOsLocalTimeAverage >> 2);
        /* If we have tracing activated, we report the actual timing and the averaged timing.
         * when they are close to the border*/
        #if (cfgCheckTrace == cfgTrue)
          if (uiOsTimeAverage > (3*cfgSysSubTicksPerFullTick/8))
          { privTrace(traceOsTime);
            privTrace(uiOsTime);
            privTrace(uiOsTimeAverage); }
        #endif
        /* If this value exceeds have the tick time, this should be reported. */
        if (uiOsTimeAverage >= (cfgSysSubTicksPerFullTick / 2))
        { /* This is a fatal error since it makes no sense to continue as this issue
           * will rise again and again. */
          privShowError((fatOsTickRateTooHigh | errTaskStateNon), callIdSystem, errNoInfo ); }
        /* Second, we test if there is enough room for the current time slice, i.e. if the subtick counter will
         * not overflow, even if the task runs its full length. The comparison seams awkward, but makes use
         * of the overflow of the unsigned integers arithmetic. */
        if (((Tuint08)(uiTimeSlice + uxTickCount.SubByte)) < uiTimeSlice)
        { /* if it does not fit report the error, we are in OS space and return automatically.  */
          privShowError((errTaskTakesTooLong | errTaskStateCurrent | errOsStateAsIs), callIdSystem, errCurrentTask  );
          /* We have a problem, since the task is put in error mode we cannot start it any more, that
           * would violate assumptions on running tasks. But we cannot select an other task at this point either.
           * The only senseable thing to do seems like launching the idle task, just for one slice.
           * Of course we must add the subticks already past */
          uxTickCount.SubByte += portReadAndResetTimer(TimeSliceIdleTime);
          /* and start the idle task: */
          privEnterIdle(); }
      #endif
      /* Here we are done, the next thing is to enter the privEnterTask, in order to run
       * the task chosen */
   #endif
  }
  /* make it so */
  privEnterTask(); }


static void privIncrementTick(void)
{ /* This the place where the tick counter is increased. This may be one or more ticks, depending of
   * the timing model in use. */
  #if (cfgUseEquidistantTicks == cfgFalse)
    /* Only in case we have true time slice model, more than one tick may be needed to add. For every
     * tick we fully loop the routine below. This is a little inefficient, but ensures we do not miss
     * a tick in the delay/wake section. If we do, we may miss to reactivate a delay task. */
    while (uxTickCount.SubByte >= cfgSysSubTicksPerFullTick)
  #endif
  { /* In case of true time slicing we use the SubByte to collect all subticks, otherwise there is
     * no need */
    #if (cfgUseEquidistantTicks == cfgFalse)
      uxTickCount.SubByte -= cfgSysSubTicksPerFullTick;
    #endif
    /* Every time we arrive here we must increase the tick counter by one. Or we arrived here because
     * subbyte overflowed the cfgSysSubTicksPerFullTick or we arrived here because we were send here
     * from a tick interrupt. */
    ++uxTickCount.LowByte;
    /* Call the tick hook. Please note that at this point the tick counter is incomplete, */
    #if (callAppTick00 == cfgTrue)
      appTick00();
    #endif

    /* if the low byte overflows ... */
    if (uxTickCount.LowByte == 0 )
    { /* ... Increase the high byte */
      ++uxTickCount.HighByte;
      /* every 256 ticks we must call the tick08 hook */
      #if (callAppTick08 == cfgTrue)
        appTick08();
      #endif
      /* Once ever 256 ticks let us adjust the Os stack watermark */
      #if (cfgCheckWatermarks == cfgTrue) && (cfgSysReuseOsStack == cfgFalse)
        privCheckOsStackRegion();
      #endif
      /* If we have tracing activated we must regularly inform the outside world about
       * the status of the watermarks and registeruse. */
      #if (cfgCheckWatermarks == cfgTrue) && (cfgCheckTrace == cfgTrue)
        if ((uxTickCount.HighByte & 0x03) == 0) { privTraceWatermarks(); }
      #endif
      /* every 256*256 ticks we must call the appTick16 hook */
      #if (callAppTick16 == cfgTrue)
        if (uxTickCount.HighByte == 0) { appTick16(); }
      #endif
      /* On every cross of the low byte boundary, new tasks may have entered the near wake
       * state, thus we must set the corresponding bit. */
      uiOsStatus = ((uiOsStatus & defNearWakeStateSetMask) | defNearWakeStatePresent);
      /* If we make use of the watchdog facility */
      #if (cfgUseTaskWatchdog == cfgTrue)
        /* we test if we already arrived at a watchdog decrease boundary. This test simple passes when
         * the HighByte ends with the number of zeros given by  cfgNumWatchdogDiv */
        if ( (uxTickCount.HighByte & (0xFF >> (8 - cfgNumWatchdogDiv))) == 0)
        { /* if so, now loop trough all tasks who might have a watchdog */
          Tuint08 uiLoopTask;
          for (uiLoopTask=defTaskNumberWatchdogBegin; uiLoopTask<defTaskNumberWatchdogEnd; uiLoopTask++)
          { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
            /* We may only decrease the watchdog state of running tasks, If a task is delayed, suspended
             * or otherwise blocked, it can never feed its watchdog so we should not decrease its counter. */
            if (loopTCB->uiTaskStatus >= defBaseRunningTask)
            { /* Extract the value of the watchdog counter which can only take four states */
              Tuint08 uiWatchdog = loopTCB->defDogField & defDogGetMask;
              /* The value of zero (defDogDead) means we do not use the watchdog, the value one (defDogBark) means
               * it is already barking, so it should not be decreased further rendering it inactive,*/
              if (uiWatchdog > defDogBark)
              { /* so only on higher values, decrease its value, which may result in a barking watchdog */
                loopTCB->defDogField = (loopTCB->defDogField & defDogSetMask) | (uiWatchdog - defDogDec); } } } }
      #endif
      /* If we make use of the load monitor facility */
      #if (cfgUseLoadMonitor == cfgTrue)
        /* we test if we already arrived at a watchdog monitor boundary. This test simple passes when
         * the HighByte ends with the number of zeros given by  cfgNumMonitorDiv, we must
         * copy all values from the collectors to the totals. */
        if ( (uxTickCount.HighByte & (0xFF >> (8 - cfgNumMonitorDiv))) == 0) { privCopyLoad(); }
      #endif
    /* This concludes the activity on the high byte (256 ticks) boundary */
    }
    /* Let us check the OS stack on this place, just to be sure. */
    #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
      privCheckOsStackLevel();
    #endif
    #if (defUseDelay == cfgTrue)
      /* Now we must check if we must wake some delayed tasks, this only is the case when we
       * have near wakes. The mechanism of near wakes is made in order not to have to check all
       * tasks on every tick */
      if ((uiOsStatus & defNearWakeStateGetMask) == defNearWakeStatePresent)
      { Tuint08 uiNearWakeCount = 0;
        Tuint08 uiLoopTask;
        /* we must find out which tasks are near wake, thus we must check all tasks */
        for (uiLoopTask=defTaskNumberDelayBegin; uiLoopTask<defTaskNumberDelayEnd; uiLoopTask++)
        { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
          /* We check if the task is delayed. Note that it need not to be running. If the task was suspended or
           * sleeping while delayed, this delay simply ends, but the task remains suspended/sleeping. The same
           * applies for killed tasks. Tasks that are blocked may have a timeout, so this must be checked as well. */
          if ((loopTCB->uiTaskStatus & defBaseDelayStateGetMask) == defBaseDelayStateDelayed)
          { /* a task from which the high byte does not much is not near wake */
            if (loopTCB->uxDelay.HighByte == uxTickCount.HighByte)
            { /* if it matches, we assume that the task must be waked, since we do not allow so long delays that the
               * end time is, after overflow, just before the current time in the same block. (The need for this has
               * several reasons, one of which is that this allows us to skip ticks within a tick block. It is needed
               * for recovery from low power sleep too. The former facility is not really used right now */
              if (loopTCB->uxDelay.LowByte <= uxTickCount.LowByte)
              { /* We have a winner, we may give a wakeup call, but first we check synchronization */
                privWakeupFromDelay(uiLoopTask,loopTCB); }
              else
              { /* arriving here means the particular task has a wake time in the near future, thus we may
                 * increase the near wake counter. */
                ++uiNearWakeCount; } } } }
        /* If we had no more near wakes we may clear the near wake bit. If we do not do this, it remains set, as
         * it was for certain when arriving here. If we clear the bit will be set again when we enter the
         * next tick block. */
        if (uiNearWakeCount==0) { uiOsStatus = ((uiOsStatus & defNearWakeStateSetMask) | defNearWakeStateAbsent); } }
    #endif
  } }


static Tselect privSelectTask(Tuint08 uiFlipMask, Tuint08 uiLoopStart, Tuint08 uiLoopEnd)
{ Tselect result;
  Tuint08 uiLoopTask;
  /* Since this is on if the deeper calls, we perform an OS stack check here when timing
   * is activted, (without timing activated, it is done inside privTcbList. */
  #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    privCheckOsStackLevel();
  #endif
  /* Tselect contains of (MaxTask,Prio) MaxTask is variable which will hold the task with the highest
   * priority. The Prio is* the important variable. It is set to the highest priority of a non runnable task,
   * the default so to say. If it is not increased, we have no runnable task, thus we must run the idle task.
   * By using this approach we do not need a real idle task, with stack and so. */
  result.MaxStatus = defBaseRunningTask - 1;
  /* Now loop trough all tasks and determine which has the highest priority. Since the
   * priority information is just before the bit 0, which determines the run state, all
   * tasks with equal priority are issued round robin. Tasks with a status below defRunableTask
   * will never be started, they are typically the blocked, delayed suspended, error or
   * sleeping tasks. */
  for (uiLoopTask=uiLoopStart; uiLoopTask<uiLoopEnd; uiLoopTask++)
  { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
    Tuint08 uiCompareStatus = loopTCB->uiTaskStatus ^ uiFlipMask;
    /* The 'smaller sign' is important here, only if the priority exceeds the smallest possible
     * runnable task a replacement must take place. */
    if (result.MaxStatus < uiCompareStatus)
    { /* this is the most important task so far */
      result.MaxTask = uiLoopTask;
      /* and this is its priority */
      result.MaxStatus = uiCompareStatus;  } }
  /* Return the result. Note that MaxTask in not initialized when there where not runnable tasks.  */
  return result; }

#if (cfgUseHierarchicalRoundRobin == cfgTrue)
  static void privMakeTasksRunable(Tuint08 uiFlipMask, Tuint08 uiPriority, Tuint08 uiLoopStart, Tuint08 uiLoopEnd, Tbool bCheckSkip)
#else
  static void privMakeTasksRunable(Tuint08 uiFlipMask, Tuint08 uiLoopStart, Tuint08 uiLoopEnd, Tbool bCheckSkip)
#endif
{ Tuint08 uiLoopTask;
  /* In fact we need only to restore the run state of the current priority. It
   * is however more work to check the priority, and it does not matter that we
   * reset the run states of all lower priorities as well. Since  it could matter in
   * special cases where one particular lower priority task revives higher priority
   * tasks, which, when done, get to the same lower priority task every time,
   * thereby skipping the other lower priority tasks. If this is the case choose
   * for hierarchical round robin. However, we must take care  that only running
   * tasks are handled. For the blocking tasks the dressbit is used for other
   * purposes. */
  for (uiLoopTask=uiLoopStart; uiLoopTask<uiLoopEnd; uiLoopTask++)
  { /* So get the task ... */
    TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
    /* Test if may have a blocking of some kind. */
      /* If so make sure the present task is not blocked. */
      if ((bCheckSkip) || ((loopTCB->uiTaskStatus ^ uiFlipMask) >= defBaseNoBlocksTask))
      { /* ... and set the RunState to Runable If we make use of HierarchicalRoundRobin */
        #if (cfgUseHierarchicalRoundRobin == cfgTrue)
        /* We may only reset those tasks in the requested priority. (Note we test the shifted priority because it
         * is faster on this side and on the callers side.) */
        if ((loopTCB->uiTaskStatus & defBasePrioGetMask) == uiPriority)
        #endif
        { loopTCB->uiTaskStatus = (loopTCB->uiTaskStatus & defBaseDressSetMask) | defBaseDressRunable; } } } }


static Tuint08 privSwitchContext(void)
{ /* We arrive here when we may want to do a context switch. If we do not want to switch, we are
   * always running a task, so that is the default return state. Here we fill in in, so we can
   * modify it to our needs. */
  Tuint08 uiContextResult = defAssignmentTask;
  /* ... determine which task was running */
  #if (cfgUseTaskWatchdog == cfgTrue) ||  (includeTaskProtectSwitchTasks == cfgTrue) || (includeTaskProtectSwitchCritical == cfgTrue)
    Tuint08 uiOldTaskNumber = privTaskNumber(defCurrentTaskNumber);
    TtaskControlBlock * oldTCB = privTcbList(uiOldTaskNumber);
  #endif
  /* DISCUSSION
   * Where to put he watchdog check was a matter of considerable inner debate of mine. Is the
   * privSwitchContext the right place? In any case, we must not do it after we determined
   * what the next task to run will be. We could have done it in the privInitOS, probably it
   * results in smaller code over there. On the other side, we want to keep privInitOS as lean as
   * possible by itself. We could have done it in privSwitchContext since there is no need
   * to check broken tasks after. In any case, a call to privTaskInit eats a lot of stack so
   * we want to do it at a place where the stack is fresh. Anyway i decided that this place
   * is not that bad. */
  /* If we make use of the watchdog ... */
  #if (cfgUseTaskWatchdog == cfgTrue)
    /* check if the watchdog barked (in this way we make sure we only check tasks which
     * actually did run, so at least had a chance to feed the watchdog. A blocking task
     * therefore should not be barking. Exception is, if the task just called for some
     * unavailable slot, and went blocking as last action. Likewise, the task could also be
     * delayed as last action (the task normally is started with bark activated as last
     * action, since bark is only checked upon tasks that have run.)  Furthermore, a
     * terminated task can only issue a bark if it was not stuck but running without
     * watchdog feeding. This situation is extremely rare, but not impossible. Such a
     * task should stay terminated. End of the story, we have to recheck if the task is
     * indeed still running. Test if the task is running and if the watchdog barks. */
    if ( (oldTCB->uiTaskStatus >= defBaseRunningTask) && ((oldTCB->defDogField & defDogGetMask) == defDogBark))
    { /* Report that the watchdog is barking. The task number can be deduced from the following TaskInit report. */
      privTrace(traceWatchdog);
      /* If so get the pointer to the bark code from flash, and call it, if there is something to call.
       * We first call the Bark and reinitialize afterwards in order to process suspend requests,
       * from the bark routine. This further has the advantage that the bark routine may inspect
       * the malicious task, before it is erased. */
      #if (callAppBark == cfgTrue)
        portFlashReadWord(fpBarkTask,pxBarklist[uiOldTaskNumber-defTaskNumberWatchdogBegin])();
      #endif
      /* Re-initialize the task, (but keep its priority). The rest of the state will be restored as if
       * the task was created for the first time. All hold locks will be released, blocking and delays
       * are removed, with out exception. The task could be in block waiting for the burnbock to release.
       * We want to keep the status partially (priority etc) and the watermarks. Shared tasks are put
       * back in the pool of waiting shared tasks. */
      privTaskInit(uiOldTaskNumber,(defInitContextRenew | defInitStatusCopyDont | defInitSharedPassive | defInitStatusPrioKeep | defInitLockRelease | defInitProcessAll));
      /* In case we check timing we must inform the caller that we may have spend considerable time in
       * the watchdog routine. Since this is a one time event (or should be rare at least, is is better
       * if it not triggers an error. */
      #if (cfgCheckTiming == cfgTrue)
        uiContextResult |= defAssignmentWatchdog;
      #endif
    }
  #endif
  /* ... its state to done. If we previously run the idle task, the old task is already
   * done, but that does not matter. Since the dress runnable bit has only the runnable meaning
   * when the state is indeed not blocked (running, may be delayed) we may only set it to
   * done in that case. In blocking situations the bit is used for different purposes.
   * So there tasks must be skipped. We can save some bytes if there is no possibility for
   * blocking states. */
  /* TODO v0.90 Calls on the heap may block also */
  /* If we have shared tasks in our midst, ...  */
  #if (defUseSharedStack == cfgTrue)
    Tselect uiShareSelect;
    /* ... we must check if one of them is actually running. */
    if ((uiOsStatus & defShareStateGetMask) == defShareStateAbsent)
    { /* If this is not the case, we must select a new task from the shared tasks pool. This
       * selection is based on round robin among all shared tasks, where we always select
       * the one with the highest priority. This selection equals the regular task selection
       * scheme, with only the access bit being different. (The bit being zero on shared
       * tasks. By flipping this bit in the selection we get the correct shared task.*/
      uiShareSelect = privSelectTask((defBaseSharedGetMask & ~defBaseSharedTask),defTaskNumberSharedBegin,defTaskNumberSharedEnd);
      /* Now, we must see if there is indeed one that can be scheduled. Note that shared
       * tasks can be delayed as regular tasks, and they are not selected as long as this
       * delay is not over. The MaxStatus contains the states of the selected task with (!)
       * the flipped bit. So it looks like a stated that is able not blocked and not delayed.
       * Therefore compare with the highest state that could not run, if there are unequal,
       * we have a truly runnable state. */
      if (uiShareSelect.MaxStatus != (defBaseRunningTask - 1))
      { /* OK, among the shared tasks we have a winner! This task will be promoted to running
         * later on, get the control block of that task. */
        TtaskControlBlock * shareTCB = privTcbList(uiShareSelect.MaxTask);
        /* But it could be that all shared tasks have completed their round robin, We have
         * to test this and that can be easily seen from the dressing. Only if all shared
         * states are defBaseDressDone, one of them get selected. */
        if ((shareTCB->uiTaskStatus & defBaseDressGetMask) == defBaseDressDone)
        { /* In fact we need only to restore the run state of the shared states of the current
           * priority. We do so if we have cfgUseHierarchicalRoundRobin activated, mostly however
           * it does not matter much, so e save the code. See also the discussion below.
           * We do have to take care that we only reset shared states however */
          #if (cfgUseHierarchicalRoundRobin == cfgTrue)
            privMakeTasksRunable((defBaseSharedGetMask & ~defBaseSharedTask),(shareTCB->uiTaskStatus & defBasePrioGetMask),defTaskNumberSharedBegin,defTaskNumberSharedEnd,(defDenseSharedStack == cfgTrue));
          #else
            privMakeTasksRunable((defBaseSharedGetMask & ~defBaseSharedTask),defTaskNumberSharedBegin,defTaskNumberSharedEnd,(defDenseSharedStack == cfgTrue));
          #endif
        }
        /* Ok, now we must initialize the context for this new state, keeping everything else as is. The
         * initialization in the function taskes also case of activation of the shared state in the uiOsStatus */
        privTaskInit(uiShareSelect.MaxTask, (defRestartRunning | defInitContextRenew | defInitStatusCopyDo | defInitSharedActive | defInitStatusPrioKeep | defInitLockKeep | defInitProcessAll)); } }
  #endif
  /* When all tasks are shared the dominat mode makes no sense. */
  #if ((includeTaskProtectSwitchTasks == cfgTrue) || (includeTaskProtectSwitchCritical == cfgTrue)) && (defAllSharedStack == cfgFalse)
   /* Only if the task has been 'done' we may switch to a new task. Otherwise, we are
    * still running this task. Note that all tasks are set to 'done' even before after start
    * so there must be a special situation when this has been changed to 'runnable'. Tasks that are
    * blocked, sleeping or cannot be continued in any way loose their switch block. Delayed tasks
    * may keep it, but the idle state will be called (technically this is not a switch). So first
    * test if we have indeed a state that does not block and is runnable*/
    if ( (oldTCB->uiTaskStatus & (defBaseNoBlocksGetMask | defBaseDressGetMask)) == (defBaseNoBlocksTask | defBaseDressRunable) )
    { /* If so, see if it is delayed */
      if ((oldTCB->uiTaskStatus & defBaseDelayStateGetMask) == defBaseDelayStateDelayed)
      { /* delayed states go idle, and will persist to do so until the wake up. */
        uiContextResult |= defAssignmentIdle; } }
    else
  #endif
  { /* After we have handle the shared tasks we must see if there are only shared tasks. In that case
     * we do not need to do an other selection, and know which task is selected, namely the only runable
     * one. */
    #if (defAllSharedStack == cfgTrue)
      /* The task to be executed is the one selected by the shares. */
      Tselect uiExecute = uiShareSelect;
    #else
      /* If there are also standard tasks, we must make a new selection about which task to run. */
      Tselect uiExecute = privSelectTask(0x00,0,defNumberOfTasks);
    #endif
    if (uiExecute.MaxStatus == (defBaseRunningTask - 1))
    { /* DISCUSSION
       * If we arrive here, all the tasks are terminated, suspended, sleeping, blocked or delayed.
       * (Thus, you cannot arrive here if there are running tasks, this is important for a correct
       *  understanding of the decisions made below.)
       * The first situation can never recover, the next three cannot recover on their own, thus
       * the delayed tasks are their only hope. Thus we may go to sleep directly, or, when the
       * the minimum delay is long enough, for that time at least. Interrupts can revive
       * locked tasks may do so through the sleep anyway. Note that we disallowed sleep in case
       * of any write-file system activity or coming activity.
       * So see if we allow for low power sleep. If there are no tasks we cannot decide to go to sleep
       * by looking at the tasks. In fact, we should not sleep, maybe the idle loop has something
       * sensible to do, otherwise we just as well switch off the power. */
      #if (cfgUseLowPowerSleep == cfgTrue) && (defNumberOfTasks > 0)
        Tuint08 uiLoopTask;
        /* Set the minimum delay to 255 block ticks, this is the largest value per default. */
        Tuint08 uiMinDelay = defSleepMaximum;
        /* If there is any fs activity we do not need to test any further, so sort this out. If any
         * writing is going on, we may not fall asleep. Reading is permitted (read tasks cannot block
         * because of reading solely, only in combination of an other task writing or an other synchronization
         * primitive). Since we know there are no running tasks when arriving here, we only need to check
         * if there is not write block present.*/
        #if (cfgUseFileSystem  ==  cfgTrue)
          /* If the file system is in write block, there are tasks writing to the FS and we cannot put the
           * system into a sleep mode. If there is a read block, this is no problem by itself.
           * If we have a burn block, there must be a write block too, so we do not need to check
           * for burning separately.*/
          if ((uiFsStatus & defFsWriteBlockGetMask) == defFsWriteBlockActive)
          { /* Setting uiLoopTask to zero blocks failing to sleep in the test below. */
            uiLoopTask = 0; }
          else
        #endif
        { /* Now loop through all tasks to test if a sleep is justified. */
          for (uiLoopTask=0; uiLoopTask<defNumberOfTasks; uiLoopTask++)
          { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
            #if (cfgUseFileSystem  ==  cfgTrue)
              /* Test first if we do not have a FS block, if so, no sleep. For we must first handle any
               * task that is waiting for an opportunity to start writing. Task blocking for reading
               * operations should not hinder falling asleep. However, there cannot be a situation where
               * all tasks are solely blocked on reading. One read block implies an other task blocked
               * on writing. And even if that where possible we should not go to sleep since we cannot
               * store the blocked state. Tasks actually doing reading (but blocked or delayed) are
               * NOT FileBlocked, thus pass here undetected. When some tasks are actually writing
               * we never arrive here. End of the story is that any file block should hinder sleep.
               * The  defBaseDressGetMask is not important. */
              if ( (loopTCB->uiTaskStatus & defBaseFileBlockedGetMask) == defBaseFileBlockedTask ) { break; }
            #endif
            /* We can only arrive here if all tasks (until now) are terminated, suspended, sleeping of syncblocked.
             * (fs blocks are already filtered out). The task could be delayed or syncblocked, the latter with or
             * without delay. We cannot reach this place if there is any task that is able to run.
             * Here three situations are important. No delay, delay with UseLowPowerOnDelay or delay without UseLowPowerOnDelay.
             * First if delayed tasks are not possible then, there is nothing left to do. If we come here, this task
             * cannot hinder going to sleep anymore.
             * In the second situation, where we allow a sleep on (long) delays, we must determine the shortest delay among
             * all, where we only take tasks into account that will be reviving without the help from outside, i.e.
             * standard  delayed tasks, or blocked delayed tasks (not on FS).
             * Third, if we do not allow a sleep on (long) delays, we must determine if we really do not have any delayed
             * tasks, thus  check if there is a delay task, if so, we may not go to sleep. If there is no delayed
             * task, we could only arrive here (idle) if ALL tasks are stopped, suspended, sleeping of syncblocked.
             * Only an external event can revive any of them. We may go to sleep.
             * Note that it does  matter if blocked state is delayed, since a delayed blocked state may revive
             * earlier, but only with help from an other task or from the outside. But it will certainly be revived
             * when its timer expires. We thus must treat is as if it is a normal delayed task.
             * It must however not be a stopped delayed task, since even if the timer expires it will never restart. */
            #if (cfgUseDelay == cfgTrue)
              /* Test if we are in a delayed situation, that is not terminated or sleeping (fs is not possible any more)
               * but may be syncblocked. */
              if ( (loopTCB->uiTaskStatus & (defBaseStopStateGetMask | defBaseModeGetMask | defBaseDelayStateGetMask)) == ( defBaseStopStateGo |  defBaseModeSync | defBaseDelayStateDelayed ) )
                #if (cfgUseLowPowerOnDelay == cfgTrue)
                { /* Second situation, we must determine the delay. We do not care for the low byte, this 256 ticks vanish in
                   * the rounding. One tick block must at least be the delay.  The calculation is correct, even if
                   * loopTCB->uxDelay.HighByte < uxTickCount.HighByte do to the limited size of the type. */
                  Tuint08 uiDelayTime = loopTCB->uxDelay.HighByte - uxTickCount.HighByte;
                  /* If the high bytes are equal, there will be no delay, in fact that task will be waked
                   * [Is this possible at all, it seems not so, cause these tasks should have been waked earlier on ]
                   * Delays as long as 0xFF00 or more are forbidden. */
                  if (uiDelayTime == 0 ) { break; }
                  /* The time the device may be put to sleep is of course one tick block less otherwise, we could
                   * be to late for the task to wake, thus we subtract one. */
                  uiDelayTime--;
                  /* We have an option which specifies a lower bound on the sleep time. Sleep times below that
                   * are not thought to be useful, thus if we find such a time, we might as well wait here */
                  if (uiDelayTime < defSleepThreshold ) { break; }
                  /* We want to keep track of the smallest possible sleep time so far, cause that will be reported
                   * to the portSleep method. */
                  if (uiMinDelay>uiDelayTime) { uiMinDelay = uiDelayTime; } }
                #else
                { /* Third situation, a present delay must prohibit going to sleep. */
                  break; }
                #endif
            #endif
          }
        }
        /* No we must see if we did not break out of the loop. If we did not ... */
        if (uiLoopTask == defNumberOfTasks)
        { /* ... we indeed may go to sleep, the the caller so */
          uiContextResult |= defAssignmentSleep;
          /* and let the portSleep method know what the longest possible sleep time is, for
           * which no tasks will be missed (note the you may sleep longer if you want). The highest
           * value that can emerge from a delay is 0xFE (from 0xFExx) so that we know that a value of
           * defSleepMaximum (0xFF) must mean that no delay was present at all.
           * Now we can use the subbyte to pass this information, since if we are going to sleep, the
           * information will be useless anyway. The tick counter can be corrected manually, but
           * we cannot expect it to be accurate up to the subtick */
           uxTickCount.SubByte = uiMinDelay; }
        else
      #endif
    { /* If you arrive here, then or you did not allow for a sleep mode, or the conditions
       * to go go low power sleep are just not met. This implies running the idle task,
       * we are done, let the caller know. */
      uiContextResult |= defAssignmentIdle; } }
    else
    { /* If you arrive here, then there is a task to be run. There are two possibilities. If all tasks
       * run in the shared mode, then there can only one task be active, so we do not need to select any
       * more, the only task must be the one, otherwise the task was selected in the selection process
       * thereafter. */
      TtaskControlBlock * runTCB = privTcbList(uiExecute.MaxTask);
      /* So test if we only have shared tasks. */
      #if (defAllSharedStack == cfgFalse)
      /* If not, it could be that all tasks in the current priority have already run,
       * so that we selected a task in the state defRunStateDone. If this is the case
       * then we know vice versa that all tasks in that priority have that state,
       * for otherwise it would have been selected due to the higher value of the status byte. */
        if ((runTCB->uiTaskStatus & defBaseDressGetMask) == defBaseDressDone)
        { /* In fact we need only to restore the run state of the shared states of the current
           * priority. We do so if we have cfgUseHierarchicalRoundRobin activated, mostly however
           * it does not matter much, so we save the code.
           * However, we must take care  that only running tasks are handled.
           * For the blocking tasks the dressbit is used for other purposes. This is all handled
           * within the function privMakeTasksRunable. */
          #if (cfgUseHierarchicalRoundRobin == cfgTrue)
            privMakeTasksRunable(0x00,(runTCB->uiTaskStatus & defBasePrioGetMask),0,defNumberOfTasks,((cfgUseSynchronization == cfgSyncNon) && (cfgUseFileSystem  ==  cfgFalse) && (defUseSharedStack == cfgFalse)));
          #else
            privMakeTasksRunable(0x00,0,defNumberOfTasks,((cfgUseSynchronization == cfgSyncNon) && (cfgUseFileSystem  ==  cfgFalse) && (defUseSharedStack == cfgFalse)));
          #endif
        }
      #endif
      /* The state immediately needs to be set to the done state, to prohibit indefinite running, since,
       * when the dress bit is set this indicates a dominant mode. */
      runTCB->uiTaskStatus = (runTCB->uiTaskStatus & defBaseDressSetMask) | defBaseDressDone;
      /* Having selected a new state to run, let us put in the status register. From
       * now on, that is the current task.  */
      uiOsStatus = (uiOsStatus & defTaskNumberSetMask) | (uiExecute.MaxTask << defOsTaskNumberShift);  } }
  /* Tell the caller the result, which may be one of: defAssignmentIdle or defAssignmentSleep or
   * (and that was the default defAssignmentTask) */
  return uiContextResult; }


#if (cfgUseLowPowerSleep == cfgTrue)

static void privEnterSleep(Tuint08 uiTickMinDelay)
{ /* If you arrive here, you obviously wanted the device to go to sleep.
   * Here we make the last preparations before we can do so.
   * The OS stack is not relevant anymore, so to allow for maximal
   * depth on in the portSleep function, we want to reset it. This
   * however cannot be done with interrupts activated, since that
   * would open the possibility of an interrupt on an incomplete
   * stack. Thus the first thing to do is to deactivate the interrupts,
   * which is only necessary if they are active at all */
  #if (cfgIntOsProtected == cfgFalse)
    /* We want timer interrupts
     * disabled during sleep. The latter is the default situation, thus we do not
     * need to change anything to the tick interrupts.
     * If we come here, global interrupts where enabled (no OS protection) thus
     * we must disable them explicitly. Timer interrupts where already disabled in
     * the privInitOs section, thus there is no need to repeat that. */
    privDisableGlobalInterrupts();
  #endif
  /* Let the system know we are about to enter the sleep mode, this information
   * is needed when we wakeup and restore the system state, since we always enter
   * the OS with privInitOS */
  uiOsStatus = ((uiOsStatus & defContextSetMask) | defContextStateSleep);
  /* report we are going to bed */
  privTrace(traceSleepStart);
  /* Now we may reset the stack, no fear for interrupts. */
  privSetStack(&xOS.StackOS[OSstackInit]);
  /* Before we go to sleep, there may be some work to do, if a hook is installed */
  #if (callAppEnterSleep == cfgTrue)
    appEnterSleep();
  #endif
  /* If we wake from sleep, we want to be sure there is no SleepRequest left. We know that we could
   * never arrive here when we where writing, but it could be that the system is in read only mode.
   * This must be preserved. */
  #if (cfgUseFileSystem == cfgTrue)
    uiFsStatus = (uiFsStatus & defFsSleepRequestSetMask) |  defFsSleepRequestClear;
  #endif
  /* This is where it happens. Call (not jump to!) portSleep. This method
   * returns when the sleep is done. Note we enter the portSleep method with
   * global interrupts disabled, and we should return that way. In between the
   * interrupts may be enabled when needed. */
  portSleep(uiTickMinDelay);
  /* After we have slept, there may be some work to do, if a hook is installed */
  #if (callAppEnterSleep == cfgTrue)
    appExitSleep();
  #endif
  /* If we return, make the jump here */
  portJump(privTickYield); }

#endif


static void privEnterIdle(void)
{ /* Arriving here, we want to put the device in idle mode.
   * Here we make the last preparations before we can do so.
   * The OS stack is not relevant anymore, so to allow for maximal
   * depth on in the portIdle function, we want to reset it. This
   * however cannot be done with interrupts activated, since that
   * would open the possibility of an interrupt on an incomplete
   * stack. Thus the first thing to do is to deactivate the interrupts,
   * which is only necessary if they are activated at all.
   * If we have OS protection, the interrupts are already off, and\
   * the timer interrupts are permanently on. If not, we must take
   * care of that. */
  #if (cfgIntOsProtected == cfgFalse)
    privDisableGlobalInterrupts();
  #endif
  /* Timer interrupts are switch on (or must be on) in the idle mode
   * because we must return from idle due to a timer interrupt.
   * however, that is the responsibility of the portIdle implementation
   * Notify the OS that we enter the idle state now. This is needed at
   * return, cause we don't need to save any context then. */
  uiOsStatus = ((uiOsStatus & defContextSetMask) | defContextStateIdle);
  /* Say that we are ready to start the idle task. */
  privTrace(traceIdleStart);
  /* Reset the stack, so we maximal space in portIdle. */
  privSetStack(&xOS.StackOS[OSstackInit]);
  /* Interrupts on of course, otherwise the timer interrupt cannot work, and
   * we are ready with the stack switch. */
  privEnableGlobalInterrupts();
  /* Before we enter the idle state the there may be some work to do */
  #if (callAppEnterIdle == cfgTrue)
    appEnterIdle();
  #endif
  /* Done, we goto (not call!) the portIdle. Thus, we do not return here. ;-) */
  portJump(portIdle); }


#if (defNumberOfTasks == 0)

/* Use an empty method test purposes if there are no tasks defined, we should never come here. */
static void privEnterTask(void) { while(true); }

#else

static void privEnterTask(void)
{ /* Arrive here when a task need to be executed. Here we make the last preparations before
   * we can do so. The OS stack must be changed to the task stack. This however cannot be
   * done with interrupts activated, since that would open the possibility of an interrupt
   * on an incomplete stack. Thus the first thing to do is to deactivate the interrupts,
   * which is only necessary if they are activated at all.
   * Timer interrupts are switch on (or must be on) in the task mode. This however is done
   * inside the portRestore method for its state is dependent on the previous interrupt
   * state of the task. Therefore, we keep (default situation) tick interrupts disabled
   * here. If we have OS protection, the interrupts are already off. If not, we must take
   * care of that. */
  /* Notify the OS that we enter a task state now. This is needed at
   * return, cause we must save the context then. */
  uiOsStatus = ((uiOsStatus & defContextSetMask) | defContextStateTask);
  /* Get the number of the task we are going to run (a call to privTaskNumber takes more bytes) */
  Tuint08 uiTaskNumber = (uiOsStatus & defTaskNumberGetMask) >> defOsTaskNumberShift;
  /* Get the task control block of the current task also */
  TtaskControlBlock * curTCB = privTcbList(uiTaskNumber);
  /* Say that we are ready to start the task, but we do this before we switch to the
   * task itself since we do not know if the privTrace action fits on the task stack. */
  privTrace(traceTaskStart | uiTaskNumber);
  /* If we make use of register compression with constant registers, (remember the facility that saves
   * stack space by saving only those registers you use on the context), we must determine which
   * registers must be used. We need that information to calculate the space these will take
   * on the stack. */
  #if (defRegisterUseConstant == cfgTrue)
    /* ... we can use the constant value */
    Tuint08 uiRegisterUse = defRegisterUseCollect;
  #else
    /* otherwise we must extract it from flash. */
    Tuint08 uiRegisterUse = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint16,uiRegisterUse);
  #endif
  /* We must determine the number of registers used by this task, in oder to calculate the
   * new stack level. Since that may require a function call, we perform that operation first.*/
  #if (cfgCheckTaskStack == cfgTrue)
    #if (defRegisterUseConstant == cfgTrue)
      /* The constant defRegisterCount holds the number of registers used.*/
      Tuint08 uiRegCount = defRegisterCount;
    #else
      /* We have to calculate the number dynamically */
      Tuint08 uiRegCount = privRegisterCount(uiRegisterUse);
    #endif
  #endif
  /* Disable interrupts here, for interrupts make use of the stack, at least for the call. But this
   * is not allowed any more since we are about to fill the background variables.*/
  #if (cfgIntOsProtected == cfgFalse)
    privDisableGlobalInterrupts();
  #endif
  /* Make sure all calls are handled, for after this instruction we start filling the background
   * variables. The stack should not be used any more. I am not 100% sure this is sufficient, but
   * i think i have no other means at my disposal other than assembly, which we cannot use here. */
  portBarrier();
  /* If we make use of register compression with constant registers, we now fill the background
   * variable with the correct value. */
   xOS.pxSave.uiRegisterUse = uiRegisterUse;
  /* If we check the use of registers we may not want to check all registers, even if they are used. Here we may
   * want to check for all tasks the same registers so ...*/
  #if (cfgCheckRegisters == cfgTrue)
    #if (defRegisterCheckConstant == cfgTrue)
      /* ... we can use the constant value */
      xOS.pxSave.uiRegisterCheck = defRegisterCheckCollect;
    #else
      /* otherwise we must extract it from flash. */
      xOS.pxSave.uiRegisterCheck = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint16,uiRegisterCheck);
    #endif
  #elif  (cfgCheckWatermarks == cfgTrue)
    /* If we collect watermarks and do not check the registers, we want to collect this
     * information from all registers, thus */
      xOS.pxSave.uiRegisterCheck = (registersAll);
  #endif
  /* If we do some checks on the use of the task stack (which are done on portSaveContext)
   * we prepare that information here, and put it in the background variables */
  #if (cfgCheckTaskStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    /* Stack size is needed on two occasions */
    #if (defStackSizeConstant == cfgTrue)
      Tstack uiStackSize = defStackSizeFixed;
    #else
      Tstack uiStackSize = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tstack,uiStackSize);
    #endif
  #endif
  /* At saveContext we need to know where the stack starts, but since getting this info
   * may overflow the stack at that time, we get it here and save it on the OS stack which
   * is used as background storage for the task. */
  xOS.pxSave.pcStackOffset = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Taddress,pcStackOffset);
  /* Some methods return a boolean to the application code. This data is put in the
   * correct register by the restoreContext. At this point we prepare it */
  #if (cfgUseSynchronization != cfgSyncNon) && (defUseBoolReturns == cfgTrue)
    /* Put that information in the background variables */
    xOS.pxSave.uiReturn = curTCB->defRetField & defRetGetMask ;
  #endif
  #if (cfgCheckTaskStack == cfgTrue)
    /* Calculate the limit for the stack size. We do that calculation also here, so that,
     * in the portSaveContext, we can do a simple compare. */
    #if (cfgSysStackGrowthUp == cfgTrue)
      /* TODO: cfgSysStackGrowthUp oops, add code */
      xOS.pxSave.pcStackLimit = 0;
    #else
      /* Note that the limit is calculated taking StackSavety into account. Thus, it is an error
       * to pass this limit, although the stack is not yet corrupted at that point. This is
       * intentional, so that we can stop the task rather than experiencing bizarre results,
       * when experimenting with the stack size. The +1 represents the status register.*/
      xOS.pxSave.pcStackLimit = uiRegCount+xOS.pxSave.pcStackOffset+StackSafety-uiStackSize+1;
    #endif
  #endif
  /* Here we will scan the stack for bytes that differ from the initial bye. This indicates the use of
   * the stack also on places where no interrupt is possible (at the context the stack is used heavily,
   * but it may not give the absolute top if tick interrupts are disabled during deep calls. */
  #if (cfgCheckWatermarks == cfgTrue)
    #if (cfgSysStackGrowthUp == cfgTrue)
      /* I don't know, probably the offset point to the first writable byte*/
      Taddress pStack = xOS.pxSave.pcStackOffset + uiStackSize - 1;
      /* We walk downwards */
      while ( (*(pStack--) == defStackInitByte) && (uiStackSize--));
    #else
      /* The watermark measurement starts from the top of the stack (first byte to be read),
       * which is below the stack offset */
      Taddress pStack = xOS.pxSave.pcStackOffset - uiStackSize + 1;
      /* the stack is write, post decrement, thus, when we walk downwards, we must read, pre-increment.
       * We walk maximally the stack size downwards. If we encounter a value which differs from the
       * initial value, we can stop. */
      while ( (*(pStack++) == defStackInitByte) && (uiStackSize--));
      /* The level of bytes used is at least the number of bytes below the boundary found.
       * We assume the stack has not overflown, first it may produce erroneous results in
       * the calculation, and second, watermarking is a technique to detect how much stack space is
       * left, not to detect stack overflow.*/
    #endif
    /* If we happen to find a higher level with this technique opposite to the level found
     * due to context save, there must have been a situation of heavy stack use inside a tick
     * protected region of the code. Good that we noticed it! */
    if ((curTCB->uiStackMax)<(uiStackSize)) { curTCB->uiStackMax = uiStackSize; }
  #endif
 /* Recall the address stack level, and put it in the background variables. Thus this
    * variable gets accessible from the portSave/portContext routines. */
   xOS.pxSave.pcStackLevel = (Taddress) &(curTCB->pcStackLevel);
   /* Now, switch to the task stack */
   #if (cfgSysStackGrowthUp == cfgTrue)
     privSetStack( (Taddress) ((Tuint16) xOS.pxSave.pcStackOffset + (Tuint16) curTCB->pcStackLevel) );
   #else
     privSetStack( (Taddress) ((Tuint16) xOS.pxSave.pcStackOffset - (Tuint16) curTCB->pcStackLevel) );
   #endif
 /* We need not to activate the interrupts right here, since that is done in the
  * portRestoreContext at the end by the 'reti'. Jump to the routine that restores
  * the context for the task at hand. */
  portJump(portRestoreContext); }

#endif


#if (defUseDelay == cfgTrue)

static void privWakeupFromDelay(Tuint08 uiTaskNumber, TtaskControlBlock * taskTCB)
{ /* Call this if you want to wake up a task due to expiration of the delay timer.
   * That can be or a simple delay, or a task that has a time out on a block.
   * taskTCB must be the tcb that corresponds to the uiTaskNumber. */
   #if ((cfgUseSynchronization != cfgSyncNon) || (cfgUseFileSystem == cfgTrue)) && (cfgUseTimeout == cfgTrue)
     /* If the task was in blocked state, it may be released for its timeout has passed. Note that
      * blocked tasks without a timeout are not delayed, so they never arrive here. The same holds for terminated
      * tasks, so unblocking a terminated task cannot result in a suspended task. Sleeping tasks may still be unblocked.
      * Resuming, this are the possibilities
      * (1) Terminated task: never delayed, should not arrive here.
      * (2) Suspended task: never blocked, cannot pass the test below.
      * (3) Sleeping, may be blocked, is always syncblocked, thus may timeout to free-sleeping
      * (4) FS block: may deblock to free, we must clear the FsFields
      * (5) Sync block: may deblock to free, we must clear the blocking slots
      * (6) Simple delay, just clear the delay.
      * (7) Shared task, may be scheduled for execution, just clear the delay
      * */
      if ((taskTCB->uiTaskStatus & defBaseBlockStateGetMask) == defBaseBlockStateBlocked)
      { /* We can savely assume we only enter this part of the code if the present task indeed
         * has a slotstack. If not, the task could never be blocked. so we dont check. Since
         * privRestoreInitialPriority and privUnblockTask assume such uiTaskSlot is present,
         * they may crash if the fields do not exist. */
        /* If we have priority lifting .. */
        #if (cfgUseSynchronization != cfgSyncNon) && (cfgUsePriorityLifting == cfgTrue)
          /* ... and if we release, its priority may be changed (we don't know for sure) in any case
           * it must be restored. For the moment however we only support priority lifting on sync blocked
           * tasks. Thus we must test if we indeed have syncblocking. We included sleeping in this task
           * for all sleeping tasks must come from syncblocks.*/
          if ((taskTCB->uiTaskStatus & (defBaseModeGetMask | defBaseDressGetMask)) == (defBaseModeSync | defBaseDressSlot))
          { privRestoreInitialPriority(uiTaskNumber); }
        #endif
        /* Release the task by unblocking and unlocking and indicate that it was release by a timeout
         * so the requested lock was not obtained (return false) There is no need to check if other
         * tasks must be released since we remove a blocking task, which cannot have consequences
         * for other blocked/waiting tasks.*/
        privUnblockTask(uiTaskNumber | defParaLockStateUnlock | defParaRetStateFalse); }
      /* The unblocking above also wakes the task so we may skip it here. */
      else
   #endif
   /* wake the task */
   { taskTCB->uiTaskStatus = (taskTCB->uiTaskStatus & defBaseDelayStateSetMask) | defBaseDelayStateWake; } }

#endif


#if (cfgUseLoadMonitor == cfgTrue)

static void privCopyLoad(void)
{ /* Arrive here if we want to monitor the load of all tasks, the Os and the Isr. Every now
   * and then we copy the collected subticks to the totals and clear the collectors. Since
   * this routine is not interrupted, we get an adequate picture of the loads. */
  #if (cfgCheckTrace == cfgTrue)
    /* If we have tracing, first sent to the trace channel load info is comming */
    privTrace(traceLoadInfo);
    /* then send the number of bytes to follow. */
    privTrace(2*(defNumberOfTasks+3));
  #endif
  /* Copy the OS load information into the register total. */
  uiOsLoadTotal = uiOsLoadCollect;
  #if (cfgCheckTrace == cfgTrue)
    /* Send the load of the OS in big endian. */
    privTrace((Tbyte)(uiOsLoadTotal>>8));
    privTrace((Tbyte)(uiOsLoadTotal));
  #endif
  /* Reset the collecting register. */
  uiOsLoadCollect = 0;
  /* Copy the idle load information into the register total. */
  uiIdleLoadTotal = uiIdleLoadCollect;
  #if (cfgCheckTrace == cfgTrue)
    /* Send the load of the idle 'task' in big endian. */
    privTrace((Tbyte)(uiIdleLoadTotal>>8));
    privTrace((Tbyte)(uiIdleLoadTotal));
  #endif
  /* Reset the collecting register. */
  uiIdleLoadCollect = 0;
  /* Only if non empty interrupts we need to copy the isr load. Otherwise, these variables
   * are absent. */
  #if (cfgIntUserDefined == cfgTrue)
    /* Copy the ISR load information into the register total. */
    uiIsrLoadTotal = uiIsrLoadCollect;
    #if (cfgCheckTrace == cfgTrue)
    /* Send the load of the ISR  in big endian. */
      privTrace((Tbyte)(uiIsrLoadTotal>>8));
      privTrace((Tbyte)(uiIsrLoadTotal));
    #endif
    /* Reset the collecting register. */
    uiIsrLoadCollect = 0;
  #else
    #if (cfgCheckTrace == cfgTrue)
      /* We even send if we have no ISR whatsoever, since we want to emit a fixed number of bytes.*/
      privTrace(0);
      privTrace(0);
    #endif
  #endif
  /* Depending on the number of tasks, we move the loads, and send the info. */
  Tuint08 uiLoopTask;
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasks; uiLoopTask++)
  { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
    /* Copy the load information of this task into the register total. */
    loopTCB->uiLoadTotal = loopTCB->uiLoadCollect;
    #if (cfgCheckTrace == cfgTrue)
     /* Send the load of the task  in big endian. */
      privTrace((Tbyte)(loopTCB->uiLoadTotal>>8));
      privTrace((Tbyte)(loopTCB->uiLoadTotal));
    #endif
    /* Reset the collecting register. */
    loopTCB->uiLoadCollect = 0; } }

#endif


#if (cfgCheckWatermarks == cfgTrue) && (cfgCheckTrace == cfgTrue)

static void privTraceWatermarks(void)
{ /* Arrive here too send the water mark and register use information to tracing.
   * First send the byte indicating that Watermarks are coming, then send the
   * number of bytes to follow. */
  privTrace(traceWatermarks);
  privTrace(3*defNumberOfTasks+3);
  /* Send the watermark info of the OS. */
  privTrace(uiOsStackMax);
  /* See if we are using an isr */
  #if (defUseIsrStack == cfgTrue)
    /* Send the watermark of the isr stack, and depending on the size we must send
     * an extra zero. */
    #if ((StackSizeISR) > 0xFF)
      privTrace((Tbyte)(uiIsrStackMax>>8));
    #else
      privTrace(0);
    #endif
    privTrace((Tbyte)(uiIsrStackMax));
  #else
    /* If not send zero's */
    privTrace(0);
    privTrace(0);
  #endif
  /* Depending on the number of tasks, we move the loads. */
  Tuint08 uiLoopTask;
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasks; uiLoopTask++)
  { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
    /* Depending on the size of the Stack we must send a zero byte or extract the first byte */
    #if (defStackSizeExceedsOneByte == cfgTrue)
      privTrace((Tbyte)(loopTCB->uiStackMax>>8));
    #else
      privTrace(0);
    #endif
    privTrace((Tbyte)(loopTCB->uiStackMax));
    /* Send the use of the registers. */
    privTrace((Tbyte)(loopTCB->uiRegisterUse)); } }

#endif


#if (defUseDelay == cfgTrue)

#if (includeTaskDelayFromWake == cfgTrue)
  static void privDelayCalc(Tuint16 uiDelayTime, Tbool bFromNow)
#else
  static void privDelayCalcFromNow(Tuint16 uiDelayTime)
#endif
{ /* This is the delay core code. Several routines make use of it. Arrive here if you need to
   * to set the delay variables of the task control block. */
  #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    /* This is one of the places in the current design of the Femto OS that is somewhat deeper.
     * Thus it makes sense to check the OS stack here. */
    privCheckOsStackLevel();
  #endif
  TtaskControlBlock * curTCB = privTcbList(privTaskNumber(defCurrentTaskNumber));
  /* There are two different forms of delay. The time measured form the current value of the
   * tick counter or from the last value of activation. The latter is stored in the delay
   * variables. If we have no need for DelayFromWake we exclude the section. */
  #if (includeTaskDelayFromWake == cfgTrue)
    if (bFromNow)
  #else
    if (true)
  #endif
  { /* Here the new time is calculated form the current time. */
    /* Now calculate the new Delaytime. This is a 16 bit operation. Note that the uiDelaytime
     * parameter represents the requested delay time whereas the uiDelayTime field in the
     * task control block represents the wakeup time of the particular task due to delay. */
    uiDelayTime += uxTickCount.Full; }
  else
  { /* Here the new time is calculated from the last wake time. */
    #if (cfgCheckTiming == cfgTrue)
      /* We can assume we do not want to set a new wake time that is in he past, although it
       * is not an error in absolute sense. However, we no code that protects in this case
       * it being interpreted as a long delay. Therefore we report an error. */
      Tuint16 uiMinDelay = (uxTickCount.Full - curTCB->uxDelay.Full) ;
      if (uiDelayTime < uiMinDelay)
        /* Unfortunately we do not know which method called the function, so we cannot issue the
         * correct callID with certainty. Since the method declaration is already complicated enough
         * we issue a IdSystem error here. We do know however that it must be the current task
         * causing the problems, and that we are in pseuso task-space, thus we may switch at error. */
      { privShowError((errTaskDelayTooShort | errTaskStateCurrent | errOsStateAsIs), callIdSystem, errCurrentTask ); }
    #endif
    uiDelayTime += curTCB->uxDelay.Full; }
  /* We have a new wake time, so place it in the appropriate fields. */
  curTCB->uxDelay.Full =  uiDelayTime ;
  /* It may be that this task is in the near wake, in which all tasks are that are in the
   * same tick block as the current time. We must check this and set the near wake bit if
   * needed. */
  if (curTCB->uxDelay.HighByte ==  uxTickCount.HighByte )
  { uiOsStatus = ((uiOsStatus & defNearWakeStateSetMask) | defNearWakeStatePresent); }
  /* Update the task status of the task, say that the current task is delayed. If we want to
   * allow for delays below the minimum, we must add code here to check and keep the state
   * from being delayed. However we assume that this situation is normally not what you
   * want, because the task can be 'far behind'. We cannot get here for terminated tasks. */
  curTCB->uiTaskStatus = (curTCB->uiTaskStatus & defBaseDelayStateSetMask) | defBaseDelayStateDelayed; }

#endif



#if (cfgUseSynchronization == cfgSyncSingleSlot) && ((cfgUseTaskWatchdog == cfgTrue) || ( includeTaskRecreate == cfgTrue ))

static void privCleanSlotStack(TtaskExtendedControlBlock * taskTCB)
{ taskTCB->uiTaskSlot = defSlotRightFree; }

#endif


#if ((cfgUseSynchronization == cfgSyncSingleBlock) || (cfgUseSynchronization == cfgSyncDoubleBlock)) && ((cfgUseTaskWatchdog == cfgTrue) || ( includeTaskRecreate == cfgTrue ))

static void privCleanSlotStack(TtaskExtendedControlBlock * taskTCB)
{ Tuint08 * pTaskSlot = (Tuint08 *) &taskTCB->uiTaskSlot;
  /* We need to know the total size of the stack. Note that the number of
   * slots is the double of the depth. */
  #if (defSlotDepthConstant == cfgTrue)
    /* It may be a constant and than we use that */
    Tuint08 uiSDC = defSlotDepthCollect;
  #else
   /* Or it may be stored in flash*/
    Tuint08 uiSDC = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiControlTaskNumber & defTaskNumberGetMask],Tuint08,uiSlotDepth);
  #endif
  Tuint08 uiLoopSlot;
  for (uiLoopSlot=0; uiLoopSlot<uiSDC; uiLoopSlot++) { *pTaskSlot++ = defSlotFree;  } }

#endif

#if (cfgUseSynchronization == cfgSyncSingleSlot)

static Tbool privOperateSlotStack(Tuint08 uiControlTaskNumber, Tuint08 uiSlotSlot)
{ /* Use this method to add remove one slot in the slot stack, or to search a slot.
   * This implementation can handle one slot only, and should be selected in case
   * you use only one slot and no nesting is required. The size is thus known.
   * The search is the default. The search can be decorated with search free only
   * or blocks only. Per default any match is valid. If we add a slot, it will always
   * be put at the first position. The slot that was at that position will be placed
   * elsewhere. This is to ensure that, if the task blocks, we know the blocking
   * slot is in the first position. */
  TtaskExtendedControlBlock * taskTCB = (TtaskExtendedControlBlock *) privTcbList(uiControlTaskNumber & defTaskNumberGetMask);
  /* Just to be sure */
  #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    privCheckOsStackLevel();
  #endif
  /* Now we must handle all cases separately. In one special case we want only to
   * clean the stack, it is easy, done below. The clean case is special. */
  /* Load the value of the slot (left four bits are unused.) */
  Tuint08 uiVal = taskTCB->uiTaskSlot;
  /* Searching to see if the slot stack is free of Mutexes and Queues is need only in the
   * case we must restore the priority after lifting. */
  #if (cfgUsePriorityLifting == cfgTrue)
    /* We check if we want to see if the slot numbers representing Queues and Mutexes are absent */
    if ((uiControlTaskNumber & defSlotOperateSQMMask) == defSlotOperateQMAbsent)
    {  /* Test if slot represents a Queue or Mutex, if so return false, return true otherwise */
        return ((uiVal < defNumberQueuBegin) || (uiVal >= defNumberMutexEnd)); }
  #endif
  /* We need the result of the equality of the requested slot and the stored slot more
   * often, so store this in a separate variable. Also, this is the default result value */
  Tbool uiValIsSlot = (uiVal == uiSlotSlot);
  /* From this place on we will test the different situations. Please note that the default
   * result is return the value of uiValIsSlot. Thus if this is wat we want to return, we do
   * not need to do anything. */
  /* Test if we were looking for free slots only */
  if ((uiControlTaskNumber & defSlotOperateSFreeMask) == defSlotOperateSearchFree)
  { /* If we where, and the task was blocking, we must return false, since there
     * cannot be a matching slot. If the task was free we need to return the result
     * of uiValIsSlot, which is default. */
    if ((taskTCB->uiTaskStatus & defSlotLoopBlockMask) == defSlotLoopBlockBlocked) return false;  }
  /* Test if we want to add a slot */
  if ((uiControlTaskNumber & defSlotOperateIncreaseMask) == defSlotOperateIncreaseAction)
  { /* If we make use of method checking, this slot should not be used at this moment */
    #if (cfgCheckMethodUse == cfgTrue)
      /* Test if it is*/
      if (uiVal != defSlotRightFree)
      /* If so return an error. Since we are potentially not stopping the current task, we want to return after the error. */
      { privShowError((errSlotIncreaseFail | errTaskStateInfo | errOsStateForce), callIdSystem, ((uiSlotSlot << errInfoNumberShift) | ((uiControlTaskNumber & defTaskNumberGetMask) << errTaskNumberShift)) ); }
    #endif
    /* Report the locks */
    #if (cfgCheckTrace == cfgTrue)
      /* First we report which task is currently running */
      privTrace(traceSlotLock | (uiControlTaskNumber & defTaskNumberGetMask) );
      /* Subsequently report the lock. */
      privTrace(uiSlotSlot);
    #endif
    /* Set the new slot*/
    taskTCB->uiTaskSlot = uiSlotSlot;
    /* and what we return is not of importance. */ }
  /* Test if we want to remove a slot */
  if ((uiControlTaskNumber & defSlotOperateDecreaseMask) == defSlotOperateDecreaseAction)
  { /* Test if the slot matches. Now this is only needed if we make use of method checking, since it
     * is considered an error to remove a non existing slot.  */
    #if (cfgCheckMethodUse == cfgTrue)
      /* If it does not match */
      if (!uiValIsSlot)
      /* report the error. Since we are potentially not stopping the current task, we want to return after the error.  */
      { privShowError((errSlotDecreaseFail | errTaskStateInfo | errOsStateForce), callIdSystem, ((uiSlotSlot << errInfoNumberShift) | ((uiControlTaskNumber & defTaskNumberGetMask) << errTaskNumberShift)) ); }
    #endif
    /* Report the unlocks */
    #if (cfgCheckTrace == cfgTrue)
      /* First we report which task is currently running */
      privTrace(traceSlotUnlock | (uiControlTaskNumber & defTaskNumberGetMask) );
      /* Subsequently report the lock */
      privTrace(uiSlotSlot);
    #endif
    /* Remove the slot, even if it does not match, cause we may asume it does. */
    { taskTCB->uiTaskSlot = defSlotRightFree; }
    /* We return with false, since this condition may only return true if an other slot of the same number
     * is present on the stack. This cannot be the case however, since there is only one slot present. */
    return false; }
  /* In all remaining cases we where just searching, and since there is only one slot a simple test is enough. */
 return uiValIsSlot; }

#endif


#if (cfgUseSynchronization != cfgSyncNon) && (defUseQueus == cfgTrue)

static Tuint08 privGetQueuSize(Tuint08 uiQueuNumber)
{ /* Used to read the size of a particular queue from flash or to return the
   * constant if all sizes are equal. */
   Tuint08 uiResult;
   /* So first determine if they are equal */
  #if (defQueuSizeConstant == cfgTrue)
    /* Fixed sizes, return the constant.  */
    uiResult = defQueuSizeFixed;
  #else
    /* Otherwise we must look it up from a table in flash. */
    uiResult = portFlashReadWord(Tuint08,uiQueuSize[uiQueuNumber]);
 #endif
 /* Done, return the size of the queue. */
 return uiResult; }

#endif



#if (cfgUseSynchronization == cfgSyncSingleBlock) || (cfgUseSynchronization == cfgSyncDoubleBlock)

static Tbool privOperateSlotStack(Tuint08 uiControlTaskNumber, Tuint08 uiSlotSlot)
{ /* Use this method to add remove slots in the slot stack, or to search a slot.
   * The latter is the default. The search can be decorated with search free only
   * or blocks only. Per default any match is valid. If we add a slot, it will always
   * be put at the first position. The slot that was at that position will be placed
   * elsewhere. This is to ensure that, if the task blocks, we know the blocking
   * slot is in the first position. Two slots can be added simultaneously, they always
   * take the first bytes. */
  /* The default reaction is false, but this is only needed if we have double slots, since
   * then it is sometimes handy to have a default reaction. Normally you should not enter
   * this method with the free slot. */
  TtaskExtendedControlBlock * taskTCB = (TtaskExtendedControlBlock *) privTcbList(uiControlTaskNumber & defTaskNumberGetMask);
  /* Just to be sure */
  #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    privCheckOsStackLevel();
  #endif
  /* pTaskSlot holds the pointer to the first two slots in the stack. The rest
   * of the stack is outside the TaskControlBlock. */
  Tuint08 * pTaskSlot = (Tuint08 *) &taskTCB->uiTaskSlot;
  /* We need to know the total size of the stack. Note that the number of
   * slots is the double of the depth. */
  #if (defSlotDepthConstant == cfgTrue)
    /* It may be a constant and than we use that */
    Tuint08 uiSDC = defSlotDepthCollect;
  #else
   /* Or it may be stored in flash*/
    Tuint08 uiSDC = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiControlTaskNumber & defTaskNumberGetMask],Tuint08,uiSlotDepth);
  #endif
  Tuint08 uiLoopSlot;
  /* This variable is needed to hold some slots later on. */
  Tuint08 uiVal;
  /* Searching to see if the slotstack is free of Mutexes and Queues is need only in the
   * case we must restore the priority after lifting. */
  #if (cfgUsePriorityLifting == cfgTrue)
    /* We check if we want to see if the slot numbers representing Queues and Mutexes are absent */
    if ((uiControlTaskNumber & defSlotOperateSQMMask) == defSlotOperateQMAbsent)
    { /* Loop through all the slots */
      for (uiLoopSlot=0; uiLoopSlot<uiSDC; uiLoopSlot++)
      { /* Get the first to slots (technically the left slot in the zeroth slot can never be
         * a wait, but checking does not harm either.*/
        uiVal = *pTaskSlot++;
        /* Extract the left slot */
        Tuint08 uiLeftSlot  = (uiVal & defSlotLeftGetMask) >> defSlotLeftShift;
        /* Test if it represents a Queue or Mutex, if so return false */
        if ((uiLeftSlot  >= defNumberQueuBegin) && (uiLeftSlot  < defNumberMutexEnd)) { return false;}
        /* Extract the right slot */
        Tuint08 uiRightSlot = (uiVal & defSlotRightGetMask) >> defSlotRightShift;
        /* Test if it represents a Queue or Mutex, if so return false */
        if ((uiRightSlot >= defNumberQueuBegin) && (uiRightSlot < defNumberMutexEnd)) { return false;} }
      /* If we did no encounter any Queues ore Mutexes, the stack is empty or contains only Waits, in that
       * case we may return true. */
      return true; }
  #endif
  /* uiLoopControl will contains two bits of information. One to indicate that is
   * the task is free or blocked. And the second (set further below) to indicate if
   * the operation is to handle all slots. The latter is the default  */
  Tuint08 uiLoopControl = (taskTCB->uiTaskStatus & defSlotLoopBlockMask);
  /* If we are still here we did not search Waits only. Now if we are not searching
   * free slots only eigther or increase the stack (i.e. we search all or we decrease the stack,  we must make
   * sure the loop below does not skip the first two slots in the search loop below. so override
   * the blocked state form the task to enforce checking the first byte.  */
  if (((uiControlTaskNumber & defSlotOperateSFreeMask) != defSlotOperateSearchFree) && ((uiControlTaskNumber & defSlotOperateIncreaseMask) != defSlotOperateIncreaseAction))
  { uiLoopControl = defSlotLoopBlockNon; }
  /* The loop below contains two parts, a test for each slot position and an action. The default
   * is to test agains the given slot, and to replace the found value with the freeSlot (0x00)
   * Since searching can only be at one slot at a time, we know uiSlotSlot has first four bits zero */
  Tuint08 uiTest = uiSlotSlot;
  Tuint08 uiFill = defSlotRightFree;
  /* Load the value of the fist two slots. */
  uiVal = *pTaskSlot;
  /* However in case we want to add a slot, we must look for a free slot and substitute the
   * value that was placed first, which in his turn must contain the new value. Thus */
  if ((uiControlTaskNumber & defSlotOperateIncreaseMask) == defSlotOperateIncreaseAction)
  {/* Place the new slot at the first position, thereby leaving a possible second position in tact */
    #if (cfgUseSynchronization == cfgSyncDoubleBlock)
      /* In this case the whole byte is reserved for the new lock, which may contain two slots. */
      *pTaskSlot = uiSlotSlot;
    #else
      /* In this case the left nibble can contain a free lock which must be preserved, and uiSlotSlot can only
       * contain one slot */
      *pTaskSlot = (uiVal & defSlotRightSetMask) | uiSlotSlot;
    #endif
    /* Report the locks */
    #if (cfgCheckTrace == cfgTrue)
      /* First we report which task is currently running */
      privTrace(traceSlotLock | (uiControlTaskNumber & defTaskNumberGetMask) );
      /* Report the slots */
      privTrace(uiSlotSlot);
    #endif
     /* and from now on we look for empty slots */
    uiTest = defSlotRightFree;
    /* Which must be filled with the value that was on the first place before. */
    #if (cfgUseSynchronization == cfgSyncDoubleBlock)
      /* For a double block both slots may need replacement */
      uiFill = uiVal;
    #else
      /* For a single block only the right nibble is interesting, the left may contain a free lock */
      uiFill = (uiVal & defSlotRightGetMask);
    #endif
    /* If that slot was empty before, it makes no sense to continue (although it cannot harm)
     * and we are done. */
    if (uiFill == defSlotFree) return false;
    /* If we do continue we may not test the first nibble/byte since that is what we just filled, and we do
     * not want to risk a double block. so we simulate a block. */
    uiLoopControl = defSlotLoopBlockBlocked; }
  /* If we do not want to add a slot, we are about to remove one, or search for one. In case
   * we do not want to remove one, we search for one, and indicate so in the uiLoopControl variable.
   * This is to make sure we leave when found, before we substitute a value. */
  else if ((uiControlTaskNumber & defSlotOperateDecreaseMask) != defSlotOperateDecreaseAction)
  { uiLoopControl |= defSlotLoopSearchActive; }
  /* If we are decreasing, maybe we must inform the outside world we are doing so */
  #if (cfgCheckTrace == cfgTrue)
    else
    { /* Here we are decreasing, which we want to report the unlocks, first we report which task is currently running */
      privTrace(traceSlotUnlock | (uiControlTaskNumber & defTaskNumberGetMask) );
      /* Report the slot(s) */
      privTrace(uiSlotSlot); }
  #endif
  /* Start looping at the beginning or skip the first byte depending on the situation of the uiLoopControl. */
  if ((uiLoopControl & defSlotLoopBlockMask) == defSlotLoopBlockNon)
  { uiLoopSlot = 0; }
  else
  { /* We must distinguish the double and single block situations */
    #if (cfgUseSynchronization == cfgSyncDoubleBlock)
      /* In this case we need to skip the first full byte, which contains the new slots */
      uiLoopSlot = 2;
      pTaskSlot++;
    #else
      /* In this case we need to skip only the first nibble, which contains the new slot */
      uiLoopSlot = 1;
    #endif
  }
  /* Now run through all slots, double the number because we check left and right nibble with the same code */
  while (uiLoopSlot<2*uiSDC)
  { uiVal = *pTaskSlot;
     /* At odd passes we check the other nibble (slot) */
    if ((uiLoopSlot & 0x01) == 0x01) { portSwapNibbles(uiVal); }
    /* Test if the right slot fulfills the test, and if so, test also if we may test this slot. The latter may
     * not be the case for the very first slot, when we are only searching for free slots and this task is blocking. */
    if ((uiVal & defSlotRightGetMask) == uiTest )
    { /* So we found a match on the right slot. If we were only searching, we may leave with the message we found a hit. */
      if ((uiLoopControl & defSlotLoopSearchMask) == defSlotLoopSearchActive) return true;
      /* If we were replacing (for increase or decrease), do so now */
      #if (cfgUseSynchronization == cfgSyncDoubleBlock)
        /* We simply slide in the new value on the right, if the values ware swapped before
         * that does not matter */
        *pTaskSlot = (uiVal & defSlotRightSetMask) | (uiFill & defSlotRightGetMask);
      #else
        /* Calculate the new value for the slot stack */
        Tuint08 uiNewVal = (uiVal & defSlotRightSetMask) | uiFill;
        /* here we must be careful since the sequence of nibbles on the bottom of the slot stack
         * does matter, so we must restore if we corrupted it */
        if ((uiLoopSlot & 0x01) == 0x01) { portSwapNibbles(uiNewVal); }
        /* Now it is safe to store. */
        *pTaskSlot = uiNewVal;
      #endif
      /* If we are decreasing, it is interesting to know if there is a second slot with the same number,
       * so we continue otherwise */
      if ((uiControlTaskNumber & defSlotOperateIncreaseMask) == defSlotOperateIncreaseAction)
      { /* If there can be a second slot */
        #if (cfgUseSynchronization == cfgSyncDoubleBlock)
          /* We move to the second slot */
          uiFill >>= 4;
          /* there may be no second slot to paste  */
          if (uiFill == defSlotFree) { return false; }
        #else
          /* If not we are done, the return value is of no importance */
          return false;
        #endif
      }
      else
      { /* we are decreasing, so turn the operation into a search */
        uiLoopControl |= defSlotLoopSearchActive; } }
     /* Only at odd passes we check go to the next byte in the stack */
    if ((uiLoopSlot & 0x01) == 0x01) { pTaskSlot++;  }
    uiLoopSlot++; }
  /* If we found nothing, return false. If we were not searching but increasing we should not arrive here,
   * for it indicates we could not add the slot. If we where decreasing arriving here means the there was no
   * slot with the given number that could be removed. If this is an error depends on the caller. */
  #if (cfgCheckMethodUse == cfgTrue)
    /* Test if we arrived here while increasing, if so we could not add the slot for the stack is full.
     * Since we are potentially not stopping the current task, we want to return after the error. */
    if ((uiControlTaskNumber & defSlotOperateIncreaseMask) == defSlotOperateIncreaseAction)
    { privShowError((errSlotIncreaseFail | errTaskStateInfo | errOsStateForce), callIdSystem, ((uiSlotSlot << errInfoNumberShift) | ((uiControlTaskNumber & defTaskNumberGetMask) << errTaskNumberShift)) ); }
    /* Test if we arrived here while decreasing and did not yet succeed in doing so. If so the slot
     * was not present and this is considered an error. If we where decreasing and searching, we did
     * not find a second slot so we should return false, this is normal operation */
    if ( ((uiControlTaskNumber & defSlotOperateDecreaseMask) == defSlotOperateDecreaseAction) &&
         ((uiLoopControl & defSlotLoopSearchMask) != defSlotLoopSearchActive) )
    { /* Since we are potentially not stopping the current task, we want to return after the error. */
      privShowError((errSlotDecreaseFail | errTaskStateInfo | errOsStateForce), callIdSystem, ((uiSlotSlot << errInfoNumberShift) | ((uiControlTaskNumber & defTaskNumberGetMask) << errTaskNumberShift)) ); }
  #endif
  return false; }

#endif

#if (cfgUseSynchronization != cfgSyncNon) && ((defUseMutexes == cfgTrue) || (defUseQueus == cfgTrue))

static Tuint08 privFreeLockAbsent(Tuint08 uiSlot)
{ /* This method is used to see if a particular slot is occupied by an other task as a free lock.
   * Thus it returns true when the slot is totally unused, returns true when it is only used
   * as blocking slots or if you call it with the free Slot. Note that it returns false if the
   * slot has been used in a task as free, even if that task was later blocked. */
  /* Just to be sure */
  #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    privCheckOsStackLevel();
  #endif
  if (uiSlot != defSlotFree)
  { Tuint08 uiLoopTask;
    /* Run trough all tasks that use slots */
    for (uiLoopTask=0; uiLoopTask<defNumberOfTasksWithSlot; uiLoopTask++)
    { /* Search for the use of this slots as free slots in de the slotstack. privOperateSlotStack returns
       * true if the slot is reported free in this task. If so we may stop here, if not we must continue
       * to search. */
      if ( privOperateSlotStack((uiLoopTask | defSlotOperateSearchFree ), uiSlot ) ) { return false; }  } }
  /* If we have not found any free use of the slot, the slot is not used as such. */
  return true; }

#endif


#if (cfgUseSynchronization != cfgSyncNon) || (cfgUseFileSystem == cfgTrue) || (cfgUseEvents == cfgTrue)

static void privUnblockTask(Tuint08 uiControlTaskNumber)
{ /* This method unlocks / unblocks a task for you, depending on the bits in uiControlTaskNumber.
   * It can handle fs blocks and syncblocks. Only call this on blocking tasks, since it will
   * always perform a deblock, there is no test if the task is indeed blocked. Terminated and
   * suspended tasks are ignored. It may NOT be called on shared tasks. */
  TtaskExtendedControlBlock * taskTCB = (TtaskExtendedControlBlock *) privTcbList(uiControlTaskNumber & defTaskNumberGetMask);
  /* Just to be sure */
  #if (cfgCheckOsStack == cfgTrue) || (cfgCheckWatermarks == cfgTrue)
    privCheckOsStackLevel();
  #endif
    /* Check if the task is not terminated or suspended, since they may not be unlocked, for all the
   * other types (sleeping included) there is no problem  */
  if (taskTCB->uiTaskStatus >= defBaseSleepingTask)
  { /* First we see if the caller wanted to unlock the task too. */
    if ((uiControlTaskNumber & defParaLockMask) == defParaLockStateUnlock)
    {
      #if (cfgUseSynchronization != cfgSyncNon)
        if ((taskTCB->uiTaskStatus & defBaseModeGetMask) == defBaseModeSync)
        { /* If we make use of events, the test above also passes for event unlocks, thus we
           * must explicitly test in that case that we do not have an event unlock. This could
           * lead to the erasure of free slots. */
          #if (cfgUseEvents == cfgTrue)
            if ((taskTCB->uiTaskStatus & defBaseDressGetMask) == defBaseDressSlot)
          #endif
          { /* Unlocking means setting the lowest slot number to zero, the 'free lock'. Note we assume that
             * slot is the correct one, for we came from a blocking situation. */
            #if (cfgCheckTrace == cfgTrue)
              /* First we report which task is currently running */
              privTrace(traceSlotUnlock | (uiControlTaskNumber & defTaskNumberGetMask) );
              /* Report the slots */
              privTrace(taskTCB->uiTaskSlot);
            #endif
          /* Clean the lock, depending on the type  */
            #if (cfgUseSynchronization == cfgSyncSingleSlot)
              /* We may clean all of it, since the left nibble is not used */
              taskTCB->uiTaskSlot = defSlotFree;
            #elif (cfgUseSynchronization == cfgSyncSingleBlock)
              /* We must be careful for the left nibble may contain a free lock */
              taskTCB->uiTaskSlot = (taskTCB->uiTaskSlot & defSlotRightSetMask) | defSlotRightFree;
            #elif (cfgUseSynchronization == cfgSyncDoubleBlock)
              /* We must be sure to clean all blocking slots. */
              taskTCB->uiTaskSlot = defSlotFree;
            #else
              #error "You should not arrive here."
            #endif
        } }
      #endif
      #if (cfgUseFileSystem == cfgTrue)
        /* Check if the task is locked on the file system. (Note: shared tasks will pass this
         * test, therefore it may not be called on shared tasks.) */
        if ((taskTCB->uiTaskStatus & defBaseModeGetMask) == defBaseModeAccess)
        { /* If so, we clean the read/write modes. Clean the locks, if present. Note we only do so
           * when requested to unlock. This is the case in for example when a delay occurs. */
          #if (defUseFsField == cfgTrue)
            taskTCB->defFsField = (taskTCB->defFsField & (defFsReadSetMask & defFsWriteSetMask)) | (defFsReadClear | defFsWriteClear);
          #endif
        }
      #endif
      /* The last situation, namely, the Events, do not need standard unlocking operations, for we can
       * only arrive here if the uiTaskEvents has already be cleared. The only exception being in case
       * of timeouts. Also, there is no harm in cleaning the TaskEvent if we come from an unlock due
       * to a slot locking. Since if the task was blocking on a slot, it could not have been blocking on
       * an event to happen. In that case the TaskEvent variable should already be cleared. Thus */
      #if (cfgUseEvents == cfgTrue) && (cfgUseTimeout == cfgTrue)
        taskTCB->uiTaskEvents = defAllEventsReset;
      #endif
    }
    privTrace(traceTaskRelease | (uiControlTaskNumber & defTaskNumberGetMask) );
    /* ... if so, unblock the task and also remove a possible timeout. If we forget this, the task will
     * turn into a delayed state. This is needed since we also unblock tasks which are not the current ones.
     * A sleeping state may be deblocked and delay-waked, but must stay sleeping. Shared tasks are not allowed. */
    taskTCB->uiTaskStatus = (taskTCB->uiTaskStatus & (defBaseModeSetMask & defBaseBlockStateSetMask & defBaseDelayStateSetMask & defBaseDressSetMask)) | (defBaseModeSync | defBaseBlockStateFree | defBaseDelayStateWake | defBaseDressDone);
    /* If we must return a value, this can only be the case after an unblock of course. Without an unblock, there
     * is no task to return something to. */
    #if (defUseBoolReturns == cfgTrue)
      /* The return value is stored in the defRetField, and consists of two bits, one for true/false, one to
       * indicate if there is something to return. */
      taskTCB->defRetField = (taskTCB->defRetField & defRetSetMask) | ((uiControlTaskNumber & defParaRetMask) >> defParaRetToRetShift);
    #endif
   /* If we want to keep track of accurate wake times, and we have release a task, we must copy the current
    * time to the delay fields, since this is the place where the time of last activation is kept.*/
    #if (defUseDelay == cfgTrue) && (cfgUseCorrectWakeupTimes == cfgTrue)
      taskTCB->uxDelay.Full = uxTickCount.Full;
    #endif
  } }

#endif


#if (cfgUseSynchronization != cfgSyncNon) && (cfgUsePriorityLifting == cfgTrue)

static void privLiftLocksOnSlot(Tuint08 uiSlot)
{ /* Arrive here when you need to increase the priorities of several tasks in a slot
   * of a task about to be blocked. By increasing those priorities to the level of
   * the blocking slot, these tasks have a chance to finish, and not keep the current
   * blocking task for ever. Note that we do not level all priorities in one slot,
   * since due to the fact that tasks may be blocked on two slots simultaneously this
   * would be a very costly to sort out. This mechanism tries to keep it simple.*/
  TtaskControlBlock * curTCB = privTcbList(privTaskNumber(defCurrentTaskNumber));
  /* Get the priority of the current task. Note we do not need to shift the
   * priority since we will only compare priorities among each other, we do not
   * need the exact value. */
  Tuint08 uiCurTaskPriority = curTCB->uiTaskStatus & defBasePrioGetMask;
  Tuint08 uiLoopTask;
  TtaskControlBlock * loopTCB;
  /* Run through all task possible having a slot. */
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasksWithSlot; uiLoopTask++)
  { loopTCB = privTcbList(uiLoopTask);
    /* Test if the task indeed holds the slot. We do not distinguish between blocked and
     * locked only. Solely possessing the lock is enough to rise its priority. Sometimes
     * this may imply we rise tasks without a real need, but it would be to costly to
     * analyze on which slot the blocking takes place. */
    if (privOperateSlotStack((uiLoopTask | defSlotOperateSearchDefault), uiSlot))
    { /* Get the priority of the looped task, again, don't shift */
      Tuint08 uiLoopTaskPriority = loopTCB->uiTaskStatus & defBasePrioGetMask;
      /* Compare which is larger */
      if (uiCurTaskPriority>uiLoopTaskPriority)
      { /* and if the priotity of the current task (which will be blocked and thus inactivates
         * was larger, lift the priority of the other task to that of the current task. The
         * present priority gets lost.  */
        loopTCB->uiTaskStatus = (loopTCB->uiTaskStatus & defBasePrioSetMask) | uiCurTaskPriority; } } } }

#endif


#if (cfgUseSynchronization != cfgSyncNon) && (cfgUsePriorityLifting == cfgTrue)

static void privRestoreInitialPriority(Tuint08 uiTaskNumber)
{ /* Arrive here if we need to restore the priority of a lifted task. The priority
   * is reset to the original value that is stored in flash. First we test if the
   * task does not hold any Queue's or Mutexes any more. */
 if ( privOperateSlotStack((uiTaskNumber | defSlotOperateQMAbsent ), defSlotFree ) )
 { /* If so it now makes sense to restore the priority. */
   TtaskControlBlock * taskTCB = privTcbList(uiTaskNumber);
   /* Read the initial priority from flash, or use the constant */
   #if (defInitialStatusConstant == cfgTrue)
     Tuint08 uiInitialStatus = defInitialStatusFixed;
   #else
     Tuint08 uiInitialStatus = portFlashReadStruc(TtaskDefinitionBlock,pxTDBlist[uiTaskNumber],Tuint08,uiInitialStatus);
   #endif
   /* Restore its value. */
   taskTCB->uiTaskStatus = (taskTCB->uiTaskStatus & defBasePrioSetMask) | (uiInitialStatus & defBasePrioGetMask); } }

#endif


#if (cfgUseSynchronization != cfgSyncNon) && (defUseQueus == cfgTrue)

/* The queue mechanism allows for several tasks writing and reading bytes. The OS
 * locks all tasks not able at that moment to write or read the required quantity of bytes.
 * Ah, and take care, the queues (and locks for that matter) are numbers from 1 and
 * onwards. Thus, slot 0 is forbidden, since it indicates a free slot. But queue's
 * are stored in arrays, thus slot 1 corresponds to queue 0 etc. Therefore you see
 * [uiSlot-1] everywhere. */

/* DISCUSSION
 * Except in the beginning, the Read (pointer) and Write (pointer) are never equal.
 * This is because otherwise you could not see the difference between a
 * full and an empty queue. This would imply that one byte is effectively lost,
 * for it could never be retrieved. Such a waste! We must solve this
 * by storing one bit of information that differentiates between a full and an
 * empty queue, when Read and Write are equal. But where?
 * It seems reasonable to limit the size of queue's to 127 bytes. Now we have
 * two extra bits available (upper bits of Read/Write storage). Second advantage
 * is that we can address the whole queue, from the queue Requests. What we don't
 * know at this moment if this will cost a lot of code.
 * Now, we decided to reserve a bit to indicate that the queue is full, is
 * it handy to use the other for indicating an empty queue? Well, it may be,
 * but, since queue's are empty at startup, we want to indicate the bit
 * empty by zero. Hmmm, that implies a lot of code. It may be shorter to
 * just ask for Read==Write and !full. Ok let us see what happens.
 * Now we keep the write pointers in uiQueuWrite[] and the read pointers in
 * uiQueuRead[]. The write operation is write-post-decrement, and the read
 * operation likewise. The pointers wrap when they hit the bottom of the queue.
 * Thus we write/read downwards, the wrapping is easier detected that way.
 */


static Tuint08 privQueuTest(Tuint08 uiSlot, Tsint08 siFreeFilling)
{ /* If we want to know the size of a queue use this function, or if we
   * want to test if a certain number of bytes will fit.  We use negative numbers
   * for writing, and positive numbers for reading. */
  /* The size information of the queue is in flash, note the shift from slot numbers
   * to queue array numbering. */
  Tuint08 uiSize = privGetQueuSize(uiSlot-1);
  /* Parameter FreeFilling zero is miss-used to request the size of the queue. */
  if (siFreeFilling==0) { return uiSize; }
  /* The information about the write and read positions are stored in two arrays, the
   * uiQueuWrite and the uiQueuRead. Obtain the write pointer. That pointer points to
   * the location that has to be written. */
  Tuint08 uiWrite = uiQueuWrite[uiSlot-1];
  /* Extract the full bit. We assume it has been set and managed correctly, although it
   * only has a meaning when uiWrite==uiRead, for this is the only situation where we
   * have ambiguity. */
  Tbool bFull = (uiWrite & defQueuFillingGetMask) == defQueuFillingStateFull;
  /* If the queue is full ... */
  if (bFull)
  { if (siFreeFilling>0)
    { /* we can read as many bytes from the queue as it is long, */
      return uiSize; }
    else
    { /* but we cannot write anything anymore to it. */
      return 0; } }
  /* In other cases we must calculate the number, extract the read pointer.  */
  Tuint08 uiRead = uiQueuRead[uiSlot-1];
  /* Now calculate how many readable characters there are. The situation that the queue
   * might be full was already resolved, so in the calculation below it is assumed the
   * queue is not full, i.e. uiWrite==uiRead implies it is empty. Make sure the calculation
   * never produced negative numbers. */
  Tuint08 uiReadable  = uiWrite<=uiRead ? uiRead - uiWrite : uiSize - (uiWrite - uiRead);
  /* Every byte that is not readable, must be writable. */
  Tuint08 uiWriteable = uiSize - uiReadable;
  /* Now decide what to return, for positive siFreeFilling we asks for the readable characters,
   * for negative for the writable. */
  if (siFreeFilling>0)
  { return uiReadable; }
  else
  { return uiWriteable; } }

#endif


#if (cfgUseSynchronization != cfgSyncNon) && (defUseWaits == cfgTrue)

static void privReleaseWait(Tuint08 uiSlot)
{ /* This is called if we want to clean all locks in the tasks blocked by a wait. Cannot be
   * called to clean up Queues or Mutexes. */
  Tuint08 uiLoopTask;
  /* Loop trough all tasks. */
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasksWithSlot; uiLoopTask++)
  { TtaskExtendedControlBlock * loopTCB = (TtaskExtendedControlBlock *) privTcbList(uiLoopTask);
     /* Check if the task holds a blocking slot with the given number. The slot can never be left,
      * since waits cannot be be blocked in pairs. Furthermore, the task must be blocking, wait slots
      * are never solely locked. */
     if ((loopTCB->uiTaskSlot & defSlotRightGetMask) == uiSlot)
     { /* If the slot matches unblock and unlock the task */
       privUnblockTask(uiLoopTask | defParaLockStateUnlock | defParaRetStateTrue); } } }

#endif


#if (cfgUseSynchronization != cfgSyncNon) && (defUseQueus == cfgTrue)

static Tbool privSizeFitsQueu(Tuint08 uiSlot, Tsint08 siFreeFilling)
{ /* Call this if you need to test if a queue on a slot may fit the filling condition. First
   * test if we indeed have a queue, otherwise there is noting to test. */
  if ((uiSlot  >= defNumberQueuBegin) || (uiSlot  < defNumberQueuEnd ))
  { Tuint08 uiTest;
    /* Now we test the siFreeFilling. This method returns the number of bytes that can read from / written to
     * the queue, depending on the sign of siFreeFilling. If siFreeFilling==0 it returns the queue size (which
     * value we do not need here) The number returned is always positive. */
    uiTest = privQueuTest(uiSlot,siFreeFilling);
    /* If we want to read we may enter if we want to read not more bytes as are available */
    if (siFreeFilling>0) { return ( ((Tuint08) siFreeFilling) <= uiTest); }
    /* If we want to read we may enter if we want to read not more bytes as are available */
    if (siFreeFilling<0) { return ( ((Tuint08) (-siFreeFilling)) <= uiTest); } }
  /* The default is true, i.e. you get the lock and it remains in effect if the siFreeFilling == 0 or
   * we have no queue at all. */
  return true; }

#endif


#if ((cfgUseSynchronization != cfgSyncNon) && ((defUseMutexes == cfgTrue) || (defUseQueus == cfgTrue))) && 0

static void privReleaseSyncBlockingTasks(void)
{ /* Arrive here if you have just completed putting sum data on the queue, or used a Mutex
   * and are done and have released your own lock. Or call it when the task is
   * initilialized or terminated. It runs through all tasks, and unblocks (not unlock)
   * the first task that meets the conditions. This may not be the one with the highest
   * priority. It does not operate on waitblocks (since they cannot, and should not,
   * be released like this) */
  Tuint08 uiLoopTask;
  /* Run through all tasks possibly having a slot. */
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasksWithSlot; uiLoopTask++)
  { TtaskExtendedControlBlock * loopTCB = (TtaskExtendedControlBlock *) privTcbList(uiLoopTask);
    /* First check it this is a blocking task (a non blocking task does not need to
     * be released) Furthermore, it must be a task that is able to run, otherwise way
     * may release a task which is for instance suspended, and that will hold the lock
     * for ever. */
     if ((loopTCB->uiTaskStatus & ( defBaseStopStateGetMask | defBaseModeGetMask | defBaseBlockStateGetMask | defBaseDressGetMask))  == (defBaseStopStateGo | defBaseModeSync | defBaseBlockStateBlocked | defBaseDressSlot) )
     { /* If yes, extract on which slots this task is blocking */
       Tuint08 uiRightSlot = (loopTCB->uiTaskSlot & defSlotRightGetMask) >> defSlotRightShift;
       /* Now we must test if this is not a wait-slot */
       #if (defUseWaits == cfgTrue)
         if (uiRightSlot < defNumberWaitBegin)
       #endif
       { /* If we arive here we are dealing with a queue of mutex. Now, depending on if we are working
          * with doublelocks, we may need the left slot too. Waits and mutex/queues can never mix, so we
          * do not need to worry */
         #if (cfgUseSynchronization == cfgSyncDoubleBlock)
           Tuint08 uiLeftSlot  = (loopTCB->uiTaskSlot & defSlotLeftGetMask) >> defSlotLeftShift;
           /* Now we must test if these slots are unlocked on some other task */
           if (privFreeLockAbsent(uiLeftSlot) && privFreeLockAbsent(uiRightSlot))
           { /* If not, we must test if the filling conditions on this task are fulfilled
              * by the queue. If it is a mutex, privSizeFitsQueu returns true per default. If
              * we do not have queues at all testing is not needed. */
            #if (defUseQueus == cfgTrue)
              if (privSizeFitsQueu(uiLeftSlot,loopTCB->siQueuLeftLock) && privSizeFitsQueu(uiRightSlot,loopTCB->siQueuRightLock))
            #endif
        #else
           /* Now we must test if these slots are unlocked on some other task */
           if (privFreeLockAbsent(uiRightSlot))
           { /* If not, we must test if the filling conditions on this task are fulfilled
              * by the queue. If it is a mutex, privSizeFitsQueu returns true per default. If
              * we do not have queues at all testing is not needed. */
            #if (defUseQueus == cfgTrue)
              if (privSizeFitsQueu(uiRightSlot,loopTCB->siQueuRightLock))
            #endif
        #endif
          { /* This task seems to fulfill all requirements to be released. Make it so. */
            privUnblockTask(uiLoopTask | defParaLockStateKeep | defParaRetStateTrue); } } } } } }


#endif


#if ((cfgUseSynchronization != cfgSyncNon) && ((defUseMutexes == cfgTrue) || (defUseQueus == cfgTrue)))

static void privReleaseSyncBlockingTasks(void)
{ /* Arrive here if you have just completed putting sum data on the queue, or used a Mutex
   * and are done and have released your own lock. Or call it when the task is
   * initialized or terminated. It runs through all tasks, and unblocks (not unlock)
   * the first task with the highest priority that meets the conditions. When having
   * equal priority tasks with a timeout prevail above those without.
   * It does not operate on wait blocks (since they cannot, and should not,
   * be released like this) */
  /* Variable to run through all tasks. */
  Tuint08 uiLoopTask;
  #if (cfgUsePrioritizedRelease == cfgTrue)
    /* Variable store the most likely candidate so far. */
    Tuint08 uiSelectedTask;
    /* Variable store the modified priority of the most likely candidate so far. */
    Tuint08 uiSelectedLevel = 0;
  #endif
  /* Run through all tasks possibly having a slot. */
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasksWithSlot; uiLoopTask++)
  { TtaskExtendedControlBlock * loopTCB = (TtaskExtendedControlBlock *) privTcbList(uiLoopTask);
    /* First check it this is a blocking task (a non blocking task does not need to
     * be released) Furthermore, it must be a task that is able to run, otherwise way
     * may release a task which is for instance suspended, and that will hold the lock
     * for ever. */
     if ((loopTCB->uiTaskStatus & ( defBaseStopStateGetMask | defBaseModeGetMask | defBaseBlockStateGetMask | defBaseDressGetMask))  == (defBaseStopStateGo | defBaseModeSync | defBaseBlockStateBlocked | defBaseDressSlot) )
     { /* If yes, extract on which slots this task is blocking */
       Tuint08 uiRightSlot = (loopTCB->uiTaskSlot & defSlotRightGetMask) >> defSlotRightShift;
       /* Now we must test if this is not a wait-slot */
       #if (defUseWaits == cfgTrue)
         if (uiRightSlot < defNumberWaitBegin)
       #endif
       { /* If we arive here we are dealing with a queue of mutex. Now, depending on if we are working
          * with doublelocks, we may need the left slot too. Waits and mutex/queues can never mix, so we
          * do not need to worry */
         #if (cfgUseSynchronization == cfgSyncDoubleBlock)
           Tuint08 uiLeftSlot  = (loopTCB->uiTaskSlot & defSlotLeftGetMask) >> defSlotLeftShift;
           /* Now we must test if these slots are unlocked on some other task */
           if (privFreeLockAbsent(uiLeftSlot) && privFreeLockAbsent(uiRightSlot))
           { /* If not, we must test if the filling conditions on this task are fulfilled
              * by the queue. If it is a mutex, privSizeFitsQueu returns true per default. If
              * we do not have queues at all testing is not needed. */
            #if (defUseQueus == cfgTrue)
              if (privSizeFitsQueu(uiLeftSlot,loopTCB->siQueuLeftLock) && privSizeFitsQueu(uiRightSlot,loopTCB->siQueuRightLock))
            #endif
        #else
           /* Now we must test if these slots are unlocked on some other task */
           if (privFreeLockAbsent(uiRightSlot))
           { /* If not, we must test if the filling conditions on this task are fulfilled
              * by the queue. If it is a mutex, privSizeFitsQueu returns true per default. If
              * we do not have queues at all testing is not needed. */
            #if (defUseQueus == cfgTrue)
              if (privSizeFitsQueu(uiRightSlot,loopTCB->siQueuRightLock))
            #endif
        #endif
          { /* This task seems to fulfill all requirements to be released. */
            #if (cfgUsePrioritizedRelease == cfgTrue)
              /* See if it is a candidate.
               * By swapping the nibbles we get the priority before the delay status so that we compare
               * first on priority and subsequently on delay. (the other bits of the pattern 110dppp1
               * are fixed */
              Tuint08 uiCandidateLevel = loopTCB->uiTaskStatus;
              portSwapNibbles(uiCandidateLevel);
              /* So the candidate level is of the form ppp1110d. If we do not have a selected level yet,
               * or the new task is higher */
              if (uiSelectedLevel < uiCandidateLevel)
              { /* Copy the new level for further comparison. */
                uiSelectedLevel = uiCandidateLevel;
                /* Copy the task number for unblocking at the end. */
                uiSelectedTask = uiLoopTask; }
            #else
              /* unblock the task. */
              privUnblockTask(uiLoopTask | defParaLockStateKeep | defParaRetStateTrue);
              /* we are done. Quickly terminate this loop by increasing the loop task number.
               * (do NOT use return here, costs 28 bytes extra! */
              uiLoopTask = defCurrentTaskNumber;
            #endif
          } } } } }
  #if (cfgUsePrioritizedRelease == cfgTrue)
    if (uiSelectedLevel != 0) { privUnblockTask(uiSelectedTask | defParaLockStateKeep | defParaRetStateTrue); }
  #endif
  }

#endif


#if (cfgUseLowPowerSleep == cfgTrue) && (includeTaskSleepAll == cfgTrue)

static void privPutAllTasksToSleep(void)
{ /* Call this if you want to put all tasks to sleep. It will put all running and
   * blocked, delayed tasks to sleep. If will check if files system operations
   * are busy, or if tasks are waiting for fs operations. Those tasks may run
   * until the fs actvities are over, and are subsequently put to sleep. It will
   * leave suspended and terminated tasks alone. */
  Tuint08 uiLoopTask;
  /* Run through all tasks. */
  for (uiLoopTask=0; uiLoopTask<defNumberOfTasks; uiLoopTask++)
  { TtaskControlBlock * loopTCB = privTcbList(uiLoopTask);
    /* Putting a task to sleep, we do not want to revive a suspended task via the
     * sleep. An already sleeping task requires no attention. Thus we must check if
     * the task we put to sleep was indeed running. */
    if ((loopTCB->uiTaskStatus & defBaseStopStateGetMask) == defBaseStopStateGo )
    { /* Putting a task blocked on the fs to sleep may lead to a crash at wakeup,
       * so putting these tasks to sleep must be postponed until later. In that case
       * we will return here. The reason is we have no way to specially store the kind of
       * block in a sleepstate, so at wakeup we cannot correctly reconstruct the state.
       * It is no problem if the task is actually reading from the file system
       * for such a task is not blocked, but writing files cannot be put
       * to sleep. First of all, this may lead to data loss, but, second, a sleep
       * instruction cannot be effectuated when a burnlock is active. Thus we must
       * check if any task is writing. If there are writing tasks, all tasks that
       * want to read are readblocked, but if there are no writing tasks, readers
       * cannot be blocked, for they are released immediately after the writing
       * has finished. Thus we come to the conclusion there is no real need to store
       * a read-block-sleeping state. */
      #if (cfgUseFileSystem == cfgTrue)
        /* Thus we exclude all those tasks from sleeping if the fs writeblock is activated
         * which are in read or write mode. (We cannot test for writeblock itself, since
         * there is always one task actually writing and not blocking. */
        if ( ((uiFsStatus & defFsWriteBlockGetMask) == defFsWriteBlockClear) ||
           ((loopTCB->defFsField & (defFsReadGetMask | defFsWriteGetMask)) == (defFsReadClear | defFsWriteClear)) )
      #endif
      /* Change the status to sleeping */
      { loopTCB->uiTaskStatus = (loopTCB->uiTaskStatus & defBaseSleepingSetMask) | defBaseSleepingTask; } } } }

#endif


#if (cfgUseFileSystem  ==  cfgTrue)

static void privReleaseFileBlocks(void)
{ /* Call this method after you are done with file operations on a task and new tasks
   * may be given the opportunity to be released. Usually this is after a fileClose on
   * a file write operation, or after all reads are finished. */
  /* First check if we have more task on the file system. If not, we can only arrive
   * here if the current (and only!) task has completed read or write operations and
   * closes the access to the file system. Now, since there are no other tasks that
   * may want access we have little to do. */
  #if (defUseFsOnMultipleTasks == cfgTrue)
    /* It seems we have. We have to see in which state the file system is
     * Check if we have a write lock. When we have a write lock there must be at least
     * one task actually writing, so it makes no sense to release anything. When we don't
     * have a write lock we may have a read lock (i.e. there are tasks actually reading, but
     * we still search for tasks that may want to write. If we find these, we should not
     * accept new reads, until the tasks wanting to write has had the opportunity to do so. */
    if ((uiFsStatus & defFsWriteBlockGetMask) == defFsWriteBlockClear)
    { /* It seems we don't have a write task, so loop through all tasks and search
       * for write blocks. We only search in those tasks making use of the file system. */
      Tuint08 uiLoopTask;
      for (uiLoopTask=defTaskNumberFileSystemBegin; uiLoopTask<defTaskNumberFileSystemEnd; uiLoopTask++)
      { /* Now we must check if this is indeed a task with a file block (it could be an other kind of block) and if this
         * block is in the write mode. */
        if ((privTcbList(uiLoopTask)->uiTaskStatus & (defBaseFileBlockedGetMask | defBaseDressGetMask)) == (defBaseFileBlockedTask | defBaseDressWrite))
        { /* All right, this task is waiting for an opportunity to write to the file system.
           * There are two possibilities, or we can directly deblock to a lock, or we must issue
           * a write request. In both cases we must activate the write block in the file system
           * status (If there is already a read block present, this write block works as a local
           * flag signaling that a task is waiting for write access. Note we can never arrive here
           * in the other situation where both read and write block are activated, namely a writing
           * task waiting for file close. */
          uiFsStatus = (uiFsStatus & defFsWriteBlockSetMask) | defFsWriteBlockActive;
          /* If there is not single-write-multiple-read synchronizer active, read blocks are not
           * possible (we read under the write lock, this is always permitted. */
          #if (cfgUseFileSystemConcurrentRead == cfgTrue)
            /* Now, if the read block is set we are done, cause the write request is already set,
             * nothing more can be done. In case it is not set, we may appoint access to the current
             * task, and give it write access. */
            if (((uiFsStatus & defFsReadBlockGetMask) == defFsReadBlockClear))
          #endif
          { /* Here we must activate the task for writing, which implies that its task number is put into
             * the first nibble of the FsStatus. Furthermore, we clear the burn lock (it should already be
             * cleared btw). */
            uiFsStatus = ((uiFsStatus & (defFsBurnBlockSetMask & defFsWriteNumberSetMask)) | (defFsBurnBlockClear | (uiLoopTask << defFsTaskNumberShift) ) );
            /* The task was already blocked (we tested that, and besides, every task is blocked at
             * file-open per default). So we must unblock, but keep the lock. */
            privUnblockTask(uiLoopTask | defParaLockStateKeep | defParaRetStateTrue); }
          break; } } }
    /* If we have simultaneous read possibility we must do some more research. */
    #if (cfgUseFileSystemConcurrentRead == cfgTrue)
      /* It may seem strange, but we start again by looking at the WriteBlokc bit in the
       * FS status. If the bit is set, there are two possibilities. First, the read bit is
       * still cleared, so there is write action, and no further action with respect to reading
       * is needed. If the read bit is set also, it must be been set before we entered this method,
       * and the write bit must be interpreted as write request. In that case no new read tasks
       * may be activated. Same result, nothing to do. */
      if ((uiFsStatus & defFsWriteBlockGetMask) == defFsWriteBlockClear)
      { /* No write bit, thus there is room for a new read task. Run through all tasks. */
        Tuint08 uiLoopTask;
        for (uiLoopTask=defTaskNumberFileSystemBegin; uiLoopTask<defTaskNumberFileSystemEnd; uiLoopTask++)
        { /* Now we must check if this is indeed a task with a file block (it could be an other kind of block) and if this
           * block is in the read mode. */
          if ((privTcbList(uiLoopTask)->uiTaskStatus & (defBaseFileBlockedGetMask | defBaseDressGetMask)) == (defBaseFileBlockedTask | defBaseDressRead))
          { /* This task want to perform a read action. This is certainly possible, without further restrictions
             * since reading may be done in parallel. */
            uiFsStatus