Monitor functions
A monitor function causes interrupts to be disabled during execution of the function. At function entry, the status register is saved and interrupts are disabled. At function exit, the original status register is restored, and thereby the interrupt status that existed before the function call is also restored.
To define a monitor function, you can use the __monitor keyword. For more information, see __monitor.
Tip
Avoid using the __monitor keyword on large functions, since the interrupt will otherwise be turned off for too long.
Example of implementing a semaphore in C
In the following example, a binary semaphore—that is, a mutex—is implemented using one static variable and two monitor functions. A monitor function works like a critical region, that is no interrupt can occur and the process itself cannot be swapped out. A semaphore can be locked by one process, and is used for preventing processes from simultaneously using resources that can only be used by one process at a time, for example a USART. The __monitor keyword assures that the lock operation is atomic; in other words it cannot be interrupted.
/* This is the lock-variable. When non-zero, someone owns it. */
static volatile unsigned int sTheLock = 0;
/* Function to test whether the lock is open, and if so take it.
* Returns 1 on success and 0 on failure.
*/
__monitor int TryGetLock(void)
{
if (sTheLock == 0)
{
/* Success, nobody has the lock. */
sTheLock = 1;
return 1;
}
else
{
/* Failure, someone else has the lock. */
return 0;
}
}
/* Function to unlock the lock.
* It is only callable by one that has the lock.
*/
__monitor void ReleaseLock(void)
{
sTheLock = 0;
}
/* Function to take the lock. It will wait until it gets it. */
void GetLock(void)
{
while (!TryGetLock())
{
/* Normally, a sleep instruction is used here. */
}
}
/* An example of using the semaphore. */
void MyProgram(void)
{
GetLock();
/* Do something here. */
ReleaseLock();
}
Example of implementing a semaphore in C++
In C++, it is common to implement small methods with the intention that they should be inlined. However, the compiler does not support inlining of functions and methods that are declared using the __monitor keyword.
In the following example in C++, an auto object is used for controlling the monitor block, which uses intrinsic functions instead of the __monitor keyword.
#include <intrinsics.h>
// Class for controlling critical blocks.
class Mutex
{
public:
Mutex()
{
// Get hold of current interrupt state.
mState = __get_interrupt_state();
// Disable all interrupts.
__disable_interrupt();
}
~Mutex()
{
// Restore the interrupt state.
__set_interrupt_state(mState);
}
private:
__istate_t mState;
};
class Tick
{
public:
// Function to read the tick count safely.
static long GetTick()
{
long t;
// Enter a critical block.
{
Mutex m; // Interrupts are disabled while m is in scope.
// Get the tick count safely,
t = smTickCount;
}
// and return it.
return t;
}
private:
static volatile long smTickCount;
};
volatile long Tick::smTickCount = 0;
extern void DoStuff();
void MyMain()
{
static long nextStop = 100;
if (Tick::GetTick() >= nextStop)
{
nextStop += 100;
DoStuff();
}
}