uint8_t OSMboxDelete (BRTOS_Mbox **event)
{
OS_SR_SAVE_VAR
BRTOS_Mbox *pont_event;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be delete by interrupt
}
// Enter Critical Section
OSEnterCritical();
pont_event = *event;
pont_event->OSEventAllocated = 0;
pont_event->OSEventPointer = NULL;
pont_event->OSEventWait = 0;
pont_event->OSEventState = NO_MESSAGE;
pont_event->OSEventWaitList=0;
*event = NULL;
// Exit Critical Section
OSExitCritical();
return(DELETE_EVENT_OK);
}
static void BRTOS_TimerTaskSleep(TIMER_CNT next_time_to_wake)
{
OS_SR_SAVE_VAR
ContextType *Task = (ContextType*)&ContextTask[currentTask];
Task->TimeToWait = next_time_to_wake;
OSEnterCritical();
// Put task into delay list
IncludeTaskIntoDelayList();
#if (VERBOSE == 1)
Task->State = SUSPENDED;
Task->SuspendedType = DELAY;
#endif
OSReadyList = OSReadyList & ~(PriorityMask[Task->Priority]);
// Change context
// Return to task when occur delay overflow
ChangeContext();
OSExitCritical();
}
INT8U OSMutexDelete (BRTOS_Mutex **event)
{
OS_SR_SAVE_VAR
BRTOS_Mutex *pont_event;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be delete by interrupt
}
// Enter Critical Section
OSEnterCritical();
pont_event = *event;
pont_event->OSEventAllocated = 0;
pont_event->OSEventState = 0;
pont_event->OSEventOwner = 0;
pont_event->OSMaxPriority = 0;
pont_event->OSOriginalPriority = 0;
pont_event->OSEventWait = 0;
pont_event->OSEventWaitList=0;
*event = NULL;
// Exit Critical Section
OSExitCritical();
return(DELETE_EVENT_OK);
}
INT8U OSMboxCreate (BRTOS_Mbox **event, void *message)
{
OS_SR_SAVE_VAR
INT16S i = 0;
BRTOS_Mbox *pont_event;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be create by interrupt
}
// Enter critical Section
if (currentTask)
OSEnterCritical();
// Verifica se ainda há blocos de controle de eventos disponíveis
for(i=0;i<=BRTOS_MAX_MBOX;i++)
{
if(i >= BRTOS_MAX_MBOX)
{
// Caso não haja mais blocos disponíveis, retorna exceção
// Exit critical Section
if (currentTask)
OSExitCritical();
return(NO_AVAILABLE_EVENT);
}
if(BRTOS_Mbox_Table[i].OSEventAllocated != TRUE)
{
BRTOS_Mbox_Table[i].OSEventAllocated = TRUE;
pont_event = &BRTOS_Mbox_Table[i];
break;
}
}
if (message != NULL)
{
pont_event->OSEventState = AVAILABLE_MESSAGE;
}
else
{
pont_event->OSEventState = NO_MESSAGE;
}
pont_event->OSEventPointer = message;
pont_event->OSEventWait = 0;
pont_event->OSEventWaitList=0;
*event = pont_event;
// Exit critical Section
if (currentTask)
OSExitCritical();
return(ALLOC_EVENT_OK);
}
uint8_t OSBlockPriority(uint8_t iPriority)
{
OS_SR_SAVE_VAR
uint8_t BlockedTask = 0;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be blocked by interrupt
}
// Enter critical Section
if (currentTask)
OSEnterCritical();
// Detects the task priority
BlockedTask = PriorityVector[iPriority];
// Block task with priority iPriority
#if (VERBOSE == 1)
ContextTask[BlockedTask].Blocked = TRUE;
#endif
OSBlockedList = OSBlockedList & ~(PriorityMask[iPriority]);
if (currentTask == BlockedTask)
{
ChangeContext();
}
// Exit critical Section
if (currentTask)
OSExitCritical();
return OK;
}
/**
\fn TIMER_CNT BRTOS_TimerGet (BRTOS_TIMER p)
\brief public function to get remaining time of a soft timer
\param p soft timer
\return timeout value or "0" as error code
*/
TIMER_CNT OSTimerGet (BRTOS_TIMER p)
{
OS_SR_SAVE_VAR
TIMER_CNT timeout;
TIMER_CNT tickcount;
if((p!= NULL) && (p->state == TIMER_RUNNING))
{
if (currentTask)
OSEnterCritical();
tickcount = OSGetCount();
if(p->timeout >= tickcount)
{
timeout = (TIMER_CNT)(p->timeout - tickcount);
}
else
{
timeout = (TIMER_CNT)(TIMER_MAX_COUNTER - tickcount + p->timeout + 1);
}
if (currentTask)
OSExitCritical();
return timeout;
}
return 0; /* "0" null event pointer or timer not running */
}
INT8U OSSemDelete (BRTOS_Sem **event)
{
OS_SR_SAVE_VAR
BRTOS_Sem *pont_event;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be delete by interrupt
}
// Enter Critical Section
OSEnterCritical();
pont_event = *event;
pont_event->OSEventAllocated = 0;
pont_event->OSEventCount = 0;
pont_event->OSEventWait = 0;
pont_event->OSEventWaitList=0;
*event = NULL;
// Exit Critical Section
OSExitCritical();
return(DELETE_EVENT_OK);
}
INT8U OSSemBinaryCreate (INT8U bit, BRTOS_Sem **event)
{
OS_SR_SAVE_VAR
int i=0;
BRTOS_Sem *pont_event;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be create by interrupt
}
// Enter critical Section
if (currentTask)
OSEnterCritical();
// Verifica se ainda há blocos de controle de eventos disponíveis
for(i=0;i<=BRTOS_MAX_SEM;i++)
{
if(i >= BRTOS_MAX_SEM)
{
// Caso não haja mais blocos disponíveis, retorna exceção
// Exit critical Section
if (currentTask)
OSExitCritical();
return(NO_AVAILABLE_EVENT);
}
if(BRTOS_Sem_Table[i].OSEventAllocated != TRUE)
{
BRTOS_Sem_Table[i].OSEventAllocated = TRUE;
pont_event = &BRTOS_Sem_Table[i];
break;
}
}
// Exit Critical
if (bit > 1)
{
pont_event->OSEventCount = TRUE; // Set semaphore bit value
}else
{
pont_event->OSEventCount = FALSE; // Set semaphore bit value
}
pont_event->OSEventWait = 0;
pont_event->Binary = TRUE;
pont_event->OSEventWaitList=0;
*event = pont_event;
// Exit critical Section
if (currentTask)
OSExitCritical();
return(ALLOC_EVENT_OK);
}
/*
This optional function does a "fast" critical region protection and returns
the previous protection level. This function is only called during very short
critical regions. An embedded system which supports ISR-based drivers might
want to implement this function by disabling interrupts. Task-based systems
might want to implement this by using a mutex or disabling tasking. This
function should support recursive calls from the same task or interrupt. In
other words, sys_arch_protect() could be called while already protected. In
that case the return value indicates that it is already protected.
sys_arch_protect() is only required if your port is supporting an operating
system.
*/
sys_prot_t sys_arch_protect(void)
{
OS_SR_SAVE_VAR
// Enter Critical Section
OSEnterCritical();
return CPU_SR;
}
/******************************************************************************
*
* @name Virtual_Com_App
*
* @brief Implements Loopback COM Port
*
* @param None
*
* @return None
*
*****************************************************************************
* Receives data from USB Host and transmits back to the Host
*****************************************************************************/
void cdc_process(void)
{
static uint_8 status = 0;
uint_8 sem_status = 0;
uint_8 size;
OS_SR_SAVE_VAR;
size = g_send_size;
g_send_size = 0;
/*check whether enumeration is complete or not */
if((start_app==TRUE) && (start_transactions==TRUE))
{
OSEnterCritical();
is_message_sent = 1;
OSExitCritical();
status = USB_Class_CDC_Interface_DIC_Send_Data(CONTROLLER_ID, g_curr_send_buf,size);
sem_status = OSSemPend(USB_Sem,500);
if (sem_status != OK)
{
OSEnterCritical();
is_message_sent = 0;
OSExitCritical();
}
if(status != USB_OK)
{
/* Send Data Error Handling Code goes here */
status = 0;
}
}
#if 0
else
{
while(GetStart_transactions() == FALSE)
{
DelayTask(100);
}
}
#endif
}
INT8U OSTimerStop (BRTOS_TIMER p, INT8U del){
OS_SR_SAVE_VAR
BRTOS_TMR_T* list;
INT8U pos_timer = 0;
if(p != NULL)
{
if (currentTask)
OSEnterCritical();
if(p->timeout >= OSGetCount())
{
list = BRTOS_TIMER_VECTOR.current; // remove from current list
}
else
{
list = BRTOS_TIMER_VECTOR.future; // remove from future list
}
/* search timer index */
p->state = TIMER_SEARCH;
for(pos_timer = 1; pos_timer <= list->count; pos_timer++)
{
if(list->timers[pos_timer]->state == TIMER_SEARCH)
{
break;
}
}
p->timeout = 0;
Subir (list->timers, pos_timer); // order it
list->timers[1]=list->timers[list->count]; // remove from current list
list->timers[list->count] = NULL;
list->count--;
Descer (list->timers, 1, list->count); // order it
if(del > 0)
{
p->state = TIMER_NOT_ALLOCATED;
p->func_cb = NULL;
}
else
{
p->state = TIMER_STOPPED;
}
if (currentTask)
OSExitCritical();
return OK;
}
return NULL_EVENT_POINTER;
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
///// Get the current task handle /////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
BRTOS_TH OSGetCurrentTaskHandle(void)
{
OS_SR_SAVE_VAR
BRTOS_TH task_handle;
OSEnterCritical();
task_handle = (BRTOS_TH)currentTask;
OSExitCritical();
return task_handle;
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
///// Get task priority /////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
OS_CPU_TYPE OSGetTaskPriority(BRTOS_TH task_handle)
{
OS_SR_SAVE_VAR
OS_CPU_TYPE task_prio;
OSEnterCritical();
task_prio = (OS_CPU_TYPE)ContextTask[task_handle].Priority;
OSExitCritical();
return task_prio;
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
///// Get the current tick count /////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
INT16U OSGetTickCount(void)
{
OS_SR_SAVE_VAR
INT16U cnt;
OSEnterCritical();
cnt = OSTickCounter;
OSExitCritical();
return cnt;
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
///// Get the current tick count /////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
ostick_t OSGetTickCount(void)
{
OS_SR_SAVE_VAR
ostick_t cnt;
OSEnterCritical();
cnt = OSTickCounter;
OSExitCritical();
return cnt;
}
/**
\fn INT8U BRTOS_TimerStart (BRTOS_TIMER p, TIMER_CNT time_wait)
\brief public function to start or restart a soft timer
\param p soft timer
\param time_wait soft timer expiration time
\return OK success
\return NULL_EVENT_POINTER error code
*/
INT8U OSTimerStart (BRTOS_TIMER p, TIMER_CNT time_wait){
OS_SR_SAVE_VAR
INT32U timeout;
BRTOS_TMR_T* list;
if(p!= NULL && time_wait != 0)
{
if(time_wait> TIMER_MAX_COUNTER) time_wait = TIMER_MAX_COUNTER;
if (currentTask)
OSEnterCritical();
if(time_wait > 0)
{
timeout = (INT32U)((INT32U)OSGetCount() + (INT32U)time_wait);
if (timeout >= TICK_COUNT_OVERFLOW)
{
p->timeout = (TIMER_CNT)(timeout - TICK_COUNT_OVERFLOW);
list = BRTOS_TIMER_VECTOR.future; // add into future list
list->timers[++list->count] = p; // insert in the end
Subir (list->timers, list->count); // order it
}
else
{
p->timeout = (TIMER_CNT)timeout;
list = BRTOS_TIMER_VECTOR.current; // add into current list
list->timers[++list->count] = p; // insert in the end
Subir (list->timers, list->count); // order it
// may need to change wake time of timer task
if(currentTask)
{
if(p->timeout == (list->timers[1])->timeout)
{
ContextTask[BRTOS_TIMER_VECTOR.handling_task].TimeToWait = p->timeout;
}
}
}
p->state = TIMER_RUNNING;
}
if (currentTask)
OSExitCritical();
return OK;
}
return NULL_EVENT_POINTER; /* any error number */
}
void OS_TICK_HANDLER(void)
{
OS_SR_SAVE_VAR
INT8U iPrio = 0;
ContextType *Task = Head;
////////////////////////////////////////////////////
// Put task with delay overflow in the ready list //
////////////////////////////////////////////////////
while(Task != NULL)
{
if (Task->TimeToWait == counter)
{
iPrio = Task->Priority;
#if (NESTING_INT == 1)
OSEnterCritical();
#endif
// Put the task into the ready list
OSReadyList = OSReadyList | (PriorityMask[iPrio]);
#if (VERBOSE == 1)
Task->State = READY;
#endif
Task->TimeToWait = EXIT_BY_TIMEOUT;
#if (NESTING_INT == 1)
OSExitCritical();
#endif
// Remove from delay list
RemoveFromDelayList();
}
Task = Task->Next;
}
//////////////////////////////////////////
// System Load //
//////////////////////////////////////////
#if (COMPUTES_CPU_LOAD == 1)
#if(DEBUG == 1)
if (DutyCnt >= 1024)
{
DutyCnt = 0;
OSDuty = (INT32U)((INT32U)OSDuty + (INT32U)OSDutyTmp);
LastOSDuty = (INT16U)(OSDuty >> 10);
OSDuty = 0;
}else
void SetTxPower(INT8U power_level){
OS_SR_SAVE_VAR;
OSEnterCritical();
currentTxPower = power_level;
iNesting++;
PHYSetLongRAMAddr(RFCTRL3,currentTxPower);
iNesting--;
OSExitCritical();
}
uint8_t OSBlockTask(BRTOS_TH TaskHandle)
{
OS_SR_SAVE_VAR
uint8_t iPriority = 0;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be blocked by interrupt
}
// Enter critical Section
if (currentTask)
OSEnterCritical();
// Checks whether the task is uninstalling itself
if (!TaskHandle){
// If so, verify if the currentTask is valid
if (currentTask){
//If true, currentTask is the task being uninstall
TaskHandle = currentTask;
}else{
// If not, not valid task
// Exit Critical Section
OSExitCritical();
return NOT_VALID_TASK;
}
}
// Determina a prioridade da função
#if (VERBOSE == 1)
ContextTask[TaskHandle].Blocked = TRUE;
#endif
iPriority = ContextTask[TaskHandle].Priority;
OSBlockedList = OSBlockedList & ~(PriorityMask[iPriority]);
if (currentTask == TaskHandle)
{
ChangeContext();
}
// Exit critical Section
if (currentTask)
OSExitCritical();
return OK;
}
/*
* Returns the thread control block for the currently active task. In case
* of an error the functions returns NULL.
*/
sys_tcb_t
*sys_arch_thread_current( void )
{
OS_SR_SAVE_VAR
sys_tcb_t *p = tasks;
sys_thread_t pid = xTaskGetCurrentTaskHandle();
// Enter Critical Section
OSEnterCritical();
while( ( p != NULL ) && ( p->pid != pid ) )
{
p = p->next;
}
// Exit Critical Section
OSExitCritical();
return p;
}
uint8_t OSUnBlockMultipleTask(uint8_t TaskStart, uint8_t TaskNumber)
{
OS_SR_SAVE_VAR
uint8_t iTask = 0;
uint8_t TaskFinish = 0;
uint8_t iPriority = 0;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be blocked by interrupt
}
// Enter critical Section
if (currentTask)
OSEnterCritical();
TaskFinish = (uint8_t)(TaskStart + TaskNumber);
for (iTask = TaskStart; iTask <TaskFinish; iTask++)
{
// Determina a prioridade da função
if (iTask != currentTask)
{
iPriority = ContextTask[iTask].Priority;
#if (VERBOSE == 1)
ContextTask[iTask].Blocked = FALSE;
#endif
OSBlockedList = OSBlockedList | (PriorityMask[iPriority]);
}
}
// check if we have unblocked a higher priority task
if (currentTask)
{
if (!iNesting)
{
ChangeContext();
}
// Exit critical Section
OSExitCritical();
}
return OK;
}
sys_thread_t xTaskGetCurrentTaskHandle( void )
{
OS_SR_SAVE_VAR
sys_thread_t xReturn;
/* A critical section is not required as this is not called from
an interrupt and the current TCB will always be the same for any
individual execution thread. */
// Enter Critical Section
OSEnterCritical();
xReturn = &ContextTask[currentTask];
// Exit Critical Section
OSExitCritical();
return xReturn;
}
/*********************************************************************
* Function: void PHYSetShortRAMAddr(BYTE address, BYTE value)
*
* PreCondition: Communication port to the MRF24J40 initialized
*
* Input: BYTE address is the address of the short RAM address
* that you want to write to. Should use the
* WRITE_ThisAddress definition in the MRF24J40
* include file.
* BYTE value is the value that you want to write to
* that register
*
* Output: None
*
* Side Effects: The register value is changed
*
* Overview: This function writes a value to a short RAM address
********************************************************************/
void PHYSetShortRAMAddr(INT8U address, INT8U value)
{
INT8U data = 0;
INT8U local_address = 0;
OS_SR_SAVE_VAR;
// Enter Critical Section
OSEnterCritical();
data = value;
local_address = address;
PHY_CS_LOW;
SPI_SendChar(local_address);
SPI_SendChar(data);
PHY_CS_HIGH;
// Exit Critical Section
OSExitCritical();
}
/*********************************************************************
* Function: void PHYSetLongRAMAddr(WORD address, BYTE value)
*
* PreCondition: Communication port to the MRF24J40 initialized
*
* Input: WORD address is the address of the LONG RAM address
* that you want to write to
* BYTE value is the value that you want to write to
* that register
*
* Output: None
*
* Side Effects: The register value is changed
*
* Overview: This function writes a value to a LONG RAM address
********************************************************************/
void PHYSetLongRAMAddr(INT16U address, INT8U value)
{
INT8U data = 0;
INT16U local_address = 0;
OS_SR_SAVE_VAR;
// Enter Critical Section
OSEnterCritical();
data = value;
local_address = address;
PHY_CS_LOW;
SPI_SendChar((((INT8U)(local_address>>3))&0b01111111)|0x80);
SPI_SendChar((((INT8U)(local_address<<5))&0b11100000)|0x10);
SPI_SendChar(data);
PHY_CS_HIGH;
// Exit Critical Section
OSExitCritical();
}
uint8_t OSUnBlockPriority(uint8_t iPriority)
{
OS_SR_SAVE_VAR
#if (VERBOSE == 1)
uint8_t BlockedTask = 0;
#endif
// Enter Critical Section
#if (NESTING_INT == 0)
if (!iNesting)
#endif
OSEnterCritical();
// Detects the task priority
#if (VERBOSE == 1)
BlockedTask = PriorityVector[iPriority];
ContextTask[BlockedTask].Blocked = FALSE;
#endif
OSBlockedList = OSBlockedList | (PriorityMask[iPriority]);
// check if we have unblocked a higher priority task
if (currentTask)
{
if (!iNesting)
{
ChangeContext();
}
}
// Exit Critical Section
#if (NESTING_INT == 0)
if (!iNesting)
#endif
OSExitCritical();
return OK;
}
uint8_t OSUnBlockTask(BRTOS_TH TaskHandle)
{
OS_SR_SAVE_VAR
uint8_t iPriority = 0;
// Enter Critical Section
#if (NESTING_INT == 0)
if (!iNesting)
#endif
OSEnterCritical();
#if (VERBOSE == 1)
ContextTask[TaskHandle].Blocked = FALSE;
#endif
// Determina a prioridade da função
iPriority = ContextTask[TaskHandle].Priority;
OSBlockedList = OSBlockedList | (PriorityMask[iPriority]);
// check if we have unblocked a higher priority task
if (currentTask)
{
if (!iNesting)
{
ChangeContext();
}
}
// Exit Critical Section
#if (NESTING_INT == 0)
if (!iNesting)
#endif
OSExitCritical();
return OK;
}
/*********************************************************************
* Function: void PHYSetShortRAMAddr(BYTE address, BYTE value)
*
* PreCondition: Communication port to the MRF24J40 initialized
*
* Input: BYTE address is the address of the short RAM address
* that you want to read from. Should use the
* READ_ThisAddress definition in the MRF24J40
* include file.
*
* Output: BYTE the value read from the specified short register
*
* Side Effects: None
*
* Overview: This function reads a value from a short RAM address
********************************************************************/
INT8U PHYGetShortRAMAddr(INT8U address)
{
INT8U local_address = 0;
INT8U toReturn;
OS_SR_SAVE_VAR;
// Enter Critical Section
OSEnterCritical();
local_address = address;
PHY_CS_LOW;
SPI_SendChar(local_address);
// Sai da condição crítica na função SPIGet
toReturn = SPI_Get();
PHY_CS_HIGH;
// Exit Critical Section
OSExitCritical();
return toReturn;
}
/* private functions */
static void BRTOS_TimerTaskInit(void)
{
OS_SR_SAVE_VAR
INT8U i;
if (currentTask)
OSEnterCritical();
BRTOS_TIMER_VECTOR.current = &BRTOS_TMR_PING;
BRTOS_TIMER_VECTOR.future = &BRTOS_TMR_PONG;
for(i=0;i<BRTOS_MAX_TIMER;i++)
{
BRTOS_TIMER_VECTOR.mem[i].state = TIMER_NOT_USED;
BRTOS_TIMER_VECTOR.mem[i].func_cb = NULL;
BRTOS_TIMER_VECTOR.mem[i].timeout = 0;
}
if (currentTask)
OSExitCritical();
}
uint8_t OSBlockMultipleTask(uint8_t TaskStart, uint8_t TaskNumber)
{
OS_SR_SAVE_VAR
uint8_t iTask = 0;
uint8_t TaskFinish = 0;
uint8_t iPriority = 0;
if (iNesting > 0) { // See if caller is an interrupt
return(IRQ_PEND_ERR); // Can't be blocked by interrupt
}
// Enter critical Section
if (currentTask)
OSEnterCritical();
TaskFinish = (uint8_t)(TaskStart + TaskNumber);
for (iTask = TaskStart; iTask <TaskFinish; iTask++)
{
if (iTask != currentTask)
{
#if (VERBOSE == 1)
ContextTask[iTask].Blocked = TRUE;
#endif
// Determina a prioridade da função
iPriority = ContextTask[iTask].Priority;
OSBlockedList = OSBlockedList & ~(PriorityMask[iPriority]);
}
}
// Exit critical Section
if (currentTask)
OSExitCritical();
return OK;
}
/*********************************************************************
* Function: BYTE PHYGetLongRAMAddr(WORD address)
*
* PreCondition: Communication port to the MRF24J40 initialized
*
* Input: WORD address is the address of the long RAM address
* that you want to read from.
*
* Output: BYTE the value read from the specified Long register
*
* Side Effects: None
*
* Overview: This function reads a value from a long RAM address
********************************************************************/
INT8U PHYGetLongRAMAddr(INT16U address)
{
INT16U local_address = 0;
INT8U toReturn = 0;
OS_SR_SAVE_VAR;
// Enter Critical Section
OSEnterCritical();
local_address = address;
PHY_CS_LOW;
SPI_SendChar(((local_address>>3)&0b01111111)|0x80);
SPI_SendChar(((local_address<<5)&0b11100000));
// Sai da condição crítica na função SPIGet
toReturn = SPI_Get();
PHY_CS_HIGH;
// Exit Critical Section
OSExitCritical();
return toReturn;
}
