The System Layer is the most fundamental part of the RT kernel, it lies just above the port layers and provides a series of important services:

• Initialization.
• Abnormal Termination.
• Interrupts Handling.
• Critical Sections.
• Power Management.
• Realtime Counter.

This service handles the system initialization:

The RT kernel is always initialized as follow:

#include "ch.h"
 
void main(void) {
 
  /*
   * System initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active. Interrupts are enabled on chSysInit() exit.
   */
  chSysInit();
  .
  .
  .
}

Note that the main() function is not meant to return, the system would stop.

This service handles the system panic stop, a reason can be provided for post mortem inspection or logging:

A panic is usually used in response of a unexpected non-recoverable condition.

#include "ch.h"
 
void main(void) {
 
  .
  .
  .
  chSysHalt("unexpected condition #12");
}

This service offers ISR abstraction and IRQ handling functions.

ISRs can be written in an architecture/compiler independent form, myISR is the name of the interrupt vector function. Note that there is an ISR declaration macro and two macros that mark the beginning and the end of the ISR, all the RTOS-specific code is hidden within the macros.

CH_IRQ_HANDLER(myISR) {
  CH_IRQ_PROLOGUE();
 
  /* ISR code.*/
  ...;
 
  CH_IRQ_EPILOGUE();
}

Interrupts that are not meant to interact with the Kernel can be written using this lighter form. No OS-related overhead is added to the ISR code path:

CH_FAST_IRQ_HANDLER(myISR) {
 
  /* Fast ISR code.*/
  ...;
 
}

This service handles critical sections in various flavors:

• Non reentrant Thread-level critical sections.
• Non reentrant ISR-level critical sections.
• Reentrant “universal” critical sections.

THD_FUNCTION(myThread, arg) {
 
  /* Thread code.*/
  ...;
 
  /* Entering a critical section.*/
  chSysLock();
 
  /* Protected code.*/
  ...;
 
  /* Leaving the critical section.*/
  chSysUnlock();
 
  /* More thread code.*/
  ...;
}

CH_IRQ_HANDLER(myISR) {
  CH_IRQ_PROLOGUE();
 
  /* ISR code.*/
  ...;
 
  /* Entering a critical section.*/
  chSysLockFromISR();
 
  /* Protected code.*/
  ...;
 
  /* Leaving the critical section.*/
  chSysUnlockFromISR();
 
  /* More ISR code.*/
  ...;
 
  CH_IRQ_EPILOGUE();
}

/*
 * This function can be called from within or outside critical sections and
 * either in thread or ISR context.
 */
void myFunc(void) {
 
  /* Protected or unprotected code.*/
  ...;
 
  /* Conditionally entering a critical section.*/
  syssts_t sts = chSysGetStatusAndLockX();
 
  /* Protected code.*/
  ...;
 
  /* Conditionally leaving the critical section.*/
  chSysRestoreStatusX(sts);
 
  /* Protected or unprotected code.*/
  ...;
}

The kernel does not handle power management directly however there are features meant to allow the implementation of any kind of power management in response of important kernel actions. Another important power-related feature is the Tickless Mode that will be discussed in the Virtual Timers chapter.

Examples are not provided for the above hooks because any implementation would be necessarily architecture-dependent.

The realtime counter is an optional RT kernel feature. It is present only if the underlying architecture supports the required feature: a very fast counter driver increased by the system clock. The realtime counter is used for:

• Accurate time delays.
• Short loops with timeout.

This is a common need when dealing with HW devices, it is often required to do something after a small amount of time. Such delays cannot be reliably implemented as software loops. An interesting thing is that the function can be preempted and the ISRs/threads execution is accounted as part of the delays not as an added extra delay improving accuracy.

void start_conversion(void) {
 
  /* Activate peripheral.*/
  ADC->CR1 |= ADC_CR1_ACTIVE;
 
  /* Wait at least 12uS before the ADC can be used.*/
  chSysPolledDelayX(US2RTC(SYSCLK, 12));
 
  /* Starts the conversion.*/
  ADC->CR1 |= ADC_CR_START;
}

Another common need is to have an escape way for software loops:

void wait_conversion(void) {
 
  /* Wait the ADC to complete the operation, after 10mS a failure
     is assumed.*/
  rtcnt_t start = chSysGetRealtimeCounterX();
  rtcnt_t end  = start + MS2RTC(10);
  do {
    if ((ADC->SR & ADC_SR_DONE) != 0)
      return;
  } while (chSysIsCounterWithinX(chSysGetRealtimeCounterX(), start, end));
 
  /* This is unexpected, probably an ADC failure.*/
  chSysHalt("ADC failure");
}