void vAssertCalled( unsigned long ulLine, const char * const pcFileName ) { /* Parameters are not used. */ ( void ) ulLine; ( void ) pcFileName; taskDISABLE_INTERRUPTS(); #if defined (__WIN32__) __asm volatile( "int $3" ); #endif taskENABLE_INTERRUPTS(); }
void vApplicationMallocFailedHook( void ) { /* vApplicationMallocFailedHook() will only be called if configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h. It is a hook function that will get called if a call to pvPortMalloc() fails. pvPortMalloc() is called internally by the kernel whenever a task, queue, timer or semaphore is created. It is also called by various parts of the demo application. If heap_1.c or heap_2.c are used, then the size of the heap available to pvPortMalloc() is defined by configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize() API function can be used to query the size of free heap space that remains (although it does not provide information on how the remaining heap might be fragmented). */ taskDISABLE_INTERRUPTS(); for( ;; ); }
/*-----------------------------------------------------------*/ void vApplicationStackOverflowHook( xTaskHandle pxTask, signed char *pcTaskName ) { (void)pcTaskName; (void)pxTask; /* Run time stack overflow checking is performed if * configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook * function is called if a stack overflow is detected. */ taskDISABLE_INTERRUPTS(); for (;;) { while (1) { } } }
/* This function is explained in the comments at the top of this file. */ static void prvRegTest1Task( void *pvParameters ) { if( ( ( unsigned long ) pvParameters ) != mainREG_TEST_1_PARAMETER ) { /* The parameter did not contain the expected value. */ for( ;; ) { /* Stop the tick interrupt so its obvious something has gone wrong. */ taskDISABLE_INTERRUPTS(); } } /* This is an asm function that never returns. */ prvRegTest1Implementation(); }
//========================================================================================================= // //========================================================================================================= void vApplicationMallocFailedHook(void) { /* �ڴ����ʧ�ܹ��Ӻ��� FreeRTOS�ں��ڴ��������С���ʱ�������ź�ʱ�����pvPortMalloc() ������ һ��pvPortMalloc() ��������ʧ�ܣ��������ļ�FreeRTOSConfig.h�У� configUSE_MALLOC_FAILED_HOOK����Ϊ1ʱ����øú����� �ú���Ҳ������Ӧ�ó�����á� ���Ӧ�ó����а������ļ�heap_1.c ���� heap_2.c��pvPortMalloc() ��ʹ�õĶѴ�С ���ļ�FreeRTOSConfig.h�е�configTOTAL_HEAP_SIZE���塣 ����API����xPortGetFreeHeapSize()���Է��ؿ��еĶѿռ��С�� */ taskDISABLE_INTERRUPTS();//�������п����ε��ж� for( ;; ); }
/** * @brief If enabled, this hook will be called in case of a stack * overflow. * @param[in] pxTask Task handle. * @param[in] pcTaskName Pointer to task name. */ void vApplicationStackOverflowHook( xTaskHandle pxTask, char *pcTaskName ) { /* This will get called if a stack overflow is detected during the context switch. Set configCHECK_FOR_STACK_OVERFLOWS to 2 to also check for stack problems within nested interrupts, but only do this for debug purposes as it will increase the context switch time. */ (void)pxTask; (void)pcTaskName; taskDISABLE_INTERRUPTS(); /* Write your code here ... */ //for(;;) {} while ( 1 ) { blink( 1, 100 ); } }
void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName ) { ( void ) pcTaskName; ( void ) pxTask; /* Run time stack overflow checking is performed if configCHECK_FOR_STACK_OVERFLOW is defined to 1 or 2. This hook function is called if a stack overflow is detected. Increase the size of the stack allocated to the offending task. Force an assert. */ configASSERT( pxTask == NULL ); taskDISABLE_INTERRUPTS(); for( ;; ); }
void vAssertCalled( void ) { const unsigned long ulLongSleep = 1000UL; volatile uint32_t ulBlockVariable = 0UL; /* Setting ulBlockVariable to a non-zero value in the debugger will allow this function to be exited. */ taskDISABLE_INTERRUPTS(); { while( ulBlockVariable == 0UL ) { Sleep( ulLongSleep ); } } taskENABLE_INTERRUPTS(); }
/*---------------------------------------------------------------------------* * Routine: PlayAudio *---------------------------------------------------------------------------* * Description: * Play a tone for the given length, staying here until done. * Inptus: * TUInt32 aHz -- Tone in Hz * TUInt32 aMS -- Duration of tone *---------------------------------------------------------------------------*/ void PlayAudio(TUInt32 aHz, TUInt32 aMS) { #if OPTION_USE_GPIO_LINES_FOR_AUDIO static HAL_GPIOPort **p_gpio0; TUInt32 n; TUInt32 start = UEZTickCounterGet(); TUInt32 count; HALInterfaceFind("GPIO0", (T_halWorkspace **)&p_gpio0); (*p_gpio0)->SetOutputMode(p_gpio0, (1<<26)); // Wait for the parameters to be ready n = (G_subTickCount*1000/2)/aHz; taskDISABLE_INTERRUPTS(); G_dummyCounter = 0; // Wait for first tick count while ((T1IR&2)==0) {} while (aMS--) { T1IR = 2; while (!(T1IR & 2)) { count = n; while (count--) { G_dummyCounter++; } (*p_gpio0)->Clear(p_gpio0, (1<<26)); count = n; while (count--) { G_dummyCounter++; } (*p_gpio0)->Set(p_gpio0, (1<<26)); } } taskENABLE_INTERRUPTS(); #else if (!G_tg) CalibrateAudioTiming(); //PWMAudio(aHz, (aMS+10)/10, 0); if (G_tg) UEZToneGeneratorPlayTone( G_tg, TONE_GENERATOR_HZ(aHz), aMS); else UEZTaskDelay(aMS); #endif }
void TerminalTask( void *pvParameters ) { terminalQueue = xQueueCreate(TERMINAL_QUEUE_LEN, MAX_CHARS); // Initialize memory (in stack) for message. static unsigned char string[MAX_CHARS]; // Try to receive message, put the task to sleep for at most RXTIMEOUT ticks if queue is empty. for(;;) { if (xQueueReceive(terminalQueue, string, TERMINAL_QUEUE_TIMEOUT)) { taskDISABLE_INTERRUPTS(); USART_puts(USART1, (volatile char*)string); taskENABLE_INTERRUPTS(); } } }
void vAssertCalled( unsigned long ulLine, const char * const pcFileName ) { /* Parameters are not used. */ ( void ) ulLine; ( void ) pcFileName; taskDISABLE_INTERRUPTS(); /* Stop the trace recording. */ if( xTraceRunning == pdTRUE ) { vTraceStop(); prvSaveTraceFile(); } for( ;; ); }
void vAssertCalled(const char *file, const char *line) { char *msg; taskDISABLE_INTERRUPTS(); write_std_out("Assert called ", strlen("Assert called ")); write_std_out(file, strlen(file)); write_std_out(":", 1); write_std_out(line, strlen(line)); write_std_out("\r\n", 2); msg = "In thread "; write_std_out(msg, strlen(msg)); msg = pcTaskGetName(NULL); write_std_out(msg, strlen(msg)); while(1) {;} }
void disable_global_interrupts() { #ifdef USE_FREERTOS taskDISABLE_INTERRUPTS(); #else unsigned int value = 0; ARM_AR_INT_BITS_GET(&value); if (value != old_value) { ARM_AR_INT_BITS_SET(CORTEXR5_CPSR_INTERRUPTS_BITS); old_value = value; } #endif }
static void new_multimeter_sample(const measure_data_t* data) { int channel = ch_generic2internal(data->ch); static portTickType last_update[NUMBER_OF_CHANNELS] = { 0 }; if((last_update[channel] + CONFIG_DISPLAY_MULTIMETER_REFRESH_TIME) < xTaskGetTickCount()) { static char buffer[15]; static const int max_mV = 3300; int mV = (data->data[0]*max_mV)/ADC_MAX; int Line; char ch; last_update[channel] = xTaskGetTickCount(); switch (channel) { case input_channel0: Line = Line3; ch = 'A'; break; case input_channel1: Line = Line4; ch = 'B'; break; default: ipc_watchdog_signal_error(0); return; } sprintf (buffer, "Channel %c: %i.%03i V", ch, mV/1000,mV%1000); xSemaphoreTake(lcdLock, portMAX_DELAY); taskDISABLE_INTERRUPTS(); TIM_ITConfig(TIM2, TIM_IT_Update, DISABLE); GLCD_setTextColor(Black); GLCD_displayStringLn(Line, (unsigned char *) buffer); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); taskENABLE_INTERRUPTS(); xSemaphoreGive(lcdLock); } }
bool LineRecv(unsigned char* pRecvBuf,unsigned long ulLength) { //ASSERT(ulLength>=ITEM_LENGTH); //ASSERT(pRecvBuf != NULL); taskDISABLE_INTERRUPTS(); unsigned char* pLine; portBASE_TYPE ptRet = xQueueReceive(s_QueueLine,&pLine,0); if (ptRet != pdPASS) { taskENABLE_INTERRUPTS(); return false; } memcpy(pRecvBuf, pLine, ITEM_LENGTH); ptRet = xQueueSendToBack(s_QueueBuff,&pLine,0); ASSERT(ptRet == pdPASS); taskENABLE_INTERRUPTS(); return true; }
void vAssertCalled( const char * pcFile, unsigned long ulLine ) { volatile unsigned long ul = 0; ( void ) pcFile; ( void ) ulLine; taskDISABLE_INTERRUPTS(); { /* Set ul to a non-zero value using the debugger to step out of this function. */ while( ul == 0 ) { portNOP(); } } taskENABLE_INTERRUPTS(); }
/*********************************************************************************************************************** * Function Name: R_SCI7_AsyncTransmit * Description : This function sends SCI7 data and waits for the transmit end flag. * Arguments : tx_buf - * transfer buffer pointer * tx_num - * buffer size * Return Value : status - * MD_OK or MD_ARGERROR ***********************************************************************************************************************/ MD_STATUS R_SCI7_AsyncTransmit (uint8_t * const tx_buf, const uint16_t tx_num) { MD_STATUS status = MD_OK; taskDISABLE_INTERRUPTS(); while( 1 ); /* clear the flag before initiating a new transmission */ sci7_txdone = FALSE; /* Send the data using the API */ status = R_SCI7_Serial_Send(tx_buf, tx_num); /* Wait for the transmit end flag */ while (FALSE == sci7_txdone) { /* Wait */ } return (status); }
void prvTaskExtCtrl(void* pvParameters) { while(1) { /* Store value converted from mdps to dps */ xSemaphoreTake(xExtCtrlSem, 0); taskDISABLE_INTERRUPTS(); xExtCtrl.pitch = (xPitchTick - EXTCTRL_TIM_COUNT_MIN) / (EXTCTRL_TIM_COUNT_MAX - EXTCTRL_TIM_COUNT_MIN) * 100; xExtCtrl.roll = (xRollTick - EXTCTRL_TIM_COUNT_MIN) / (EXTCTRL_TIM_COUNT_MAX - EXTCTRL_TIM_COUNT_MIN) * 100; xExtCtrl.yaw = (xYawTick - EXTCTRL_TIM_COUNT_MIN) / (EXTCTRL_TIM_COUNT_MAX - EXTCTRL_TIM_COUNT_MIN) * 100; taskENABLE_INTERRUPTS(); /* Critical section */ xSemaphoreGive(xExtCtrlSem); /* Delay specified period of time */ vTaskDelay(1000 / TASK_EXTCTRL_SAMPLING_RATE / portTICK_PERIOD_MS); } }
/*-----------------------------------------------------------*/ static void prvSetupHardware( void ) { taskDISABLE_INTERRUPTS(); /* Disable the watchdog. */ WDTCTL = WDTPW + WDTHOLD; //halBoardInit(); Board_init(); // Set Vcore to accomodate for max. allowed system speed SetVCore(3); // Use 32.768kHz XTAL as reference LFXT_Start(XT1DRIVE_0); // Set system clock to max (25MHz) Init_FLL_Settle(25000, 762); SFRIFG1 = 0; SFRIE1 |= OFIE; //LFXT_Start( XT1DRIVE_0 ); //hal430SetSystemClock( configCPU_CLOCK_HZ, configLFXT_CLOCK_HZ ); //halButtonsInit( BUTTON_ALL ); Buttons_init(BUTTON_ALL); //halButtonsInterruptEnable( BUTTON_SELECT ); Buttons_interruptEnable(BUTTON_S2); /* Initialise the LCD, but note that the backlight is not used as the library function uses timer A0 to modulate the backlight, and this file defines vApplicationSetupTimerInterrupt() to also use timer A0 to generate the tick interrupt. If the backlight is required, then change either the halLCD library or vApplicationSetupTimerInterrupt() to use a different timer. Timer A1 is used for the run time stats time base6. */ //halLcdInit(); //halLcdSetContrast( 100 ); //halLcdClearScreen(); //halLcdPrintLine( " www.FreeRTOS.org", 0, OVERWRITE_TEXT ); }
//*========================================================= //* READ //*========================================================= //*---------------------------------------------------------------------------- //* \fn AT91F_TWI_Read //* \brief Read n bytes from a slave device //*---------------------------------------------------------------------------- int AT91F_TWI_Read(unsigned int devaddress,unsigned int address,unsigned char *data,int size) { unsigned int SizeReaded; volatile unsigned int status; if( TWI_Semaphore != NULL ) { if( xSemaphoreTake( TWI_Semaphore, ( portTickType ) 2000 ) == pdTRUE ) { SizeReaded = 0; AT91PS_TWI TWI = AT91C_BASE_TWI; TWI_DataPointer = data; TWI_Bytes2Transfere = size; TWI_DeviceAddr = devaddress; if(TWI_Bytes2Transfere>1)TWI_ConitiosTransaction = 1; taskDISABLE_INTERRUPTS(); TWI->TWI_IADR = address; TWI->TWI_MMR = TWI_DeviceAddr | AT91C_TWI_IADRSZ_2_BYTE | AT91C_TWI_MREAD; TWI_TransferStatus = ON_READ_DATA; AT91F_TWI_EnableIt(TWI, AT91C_TWI_TXCOMP | AT91C_TWI_NACK | AT91C_TWI_OVRE | AT91C_TWI_UNRE); TWI->TWI_CR = AT91C_TWI_START | AT91C_TWI_MSEN | AT91C_TWI_STOP ; status = TWI->TWI_SR; taskENABLE_INTERRUPTS(); xQueueReceive( TWI_QUEUE, &( SizeReaded ), ( portTickType ) AT91C_TWI_TMO_VOL(size) ); if( TWI_TransferStatus != FREE) { // SYSTEM_ERROR(TWI_TMO_Error); RESET_TWI(); } ; TWI_TransferStatus = FREE; xSemaphoreGive( TWI_Semaphore ); } else { //SYSTEM_ERROR(TWI_SEM_Error); } } return SizeReaded; }
void vAssertCalled( unsigned long ulLine, const char * const pcFileName ) { static portBASE_TYPE xPrinted = pdFALSE; /* Parameters are not used. */ ( void ) ulLine; ( void ) pcFileName; taskDISABLE_INTERRUPTS(); /* Stop the trace recording. */ if( xPrinted == pdFALSE ) { xPrinted = pdTRUE; if( xTraceRunning == pdTRUE ) { vTraceStop(); prvSaveTraceFile(); } } for( ;; ); }
void vtHandleFatalError(int code,int line,char file[]) { static unsigned int delayCounter = 0; // There are lots of ways you can (and may want to) handle a fatal error // In this implementation, I suspend tasks and then flash the LEDs. Note that the stop may not be // immediate because this task has to be scheduled first for that to happen. In fact, one task might // call this while another tries to get into taskENTER_CRITICAL(); taskDISABLE_INTERRUPTS(); /* LEDs on ports 1 and 2 to output (1). */ // Note that all LED access is through the proper LPC library calls (or my own routines that call them) // Print where error occured for debugging printf("ERROR: code %d on line %d in file %s",code,line,file); vtInitLED(); for (;;) { // Silly delay loop, but we really don't have much choice here w/o interrupts and FreeRTOS... // This won't be okay to do *anywhere* else in your code for (delayCounter=0; delayCounter<10000000; delayCounter++) { } // Turn off half and on half vtLEDOn(0xAA); vtLEDOff(0x55); // Delay again for (delayCounter=0; delayCounter<10000000; delayCounter++) { } // Toggle vtLEDOff(0xAA); vtLEDOn(0x55); // Here is some dumb code to make sure that the three input parameters are not optimized away by the compiler if ((code < -55) && (line < -55) && (file == NULL)) { vtLEDOff(0x0); // We won't get here } // End of dumb code } // We will never get here taskEXIT_CRITICAL(); }
//*========================================================= //* WRITE //*========================================================= //*---------------------------------------------------------------------------- //* \fn AT91F_TWI_Write //* \brief Send n bytes to a slave device //*---------------------------------------------------------------------------- int AT91F_TWI_Write(unsigned int devaddress,unsigned int address,unsigned char *data2send, int size) { unsigned int SizeNotWrited = 0; //--------------------------------------------------------- if( TWI_Semaphore != NULL ) { if( xSemaphoreTake( TWI_Semaphore, ( portTickType ) 2000 ) == pdTRUE ) { TWI_TransferStatus = ON_WRITE_DATA; SizeNotWrited = 0; TWI_DataPointer = data2send; TWI_Bytes2Transfere = size; TWI_DeviceAddr = devaddress; TWI_TransferStatus = ON_WRITE_DATA; taskDISABLE_INTERRUPTS(); AT91C_BASE_TWI->TWI_MMR = ( TWI_DeviceAddr | AT91C_TWI_IADRSZ_2_BYTE ) & ~AT91C_TWI_MREAD; AT91C_BASE_TWI->TWI_IADR = address; AT91C_BASE_TWI->TWI_THR = *(TWI_DataPointer++); AT91F_TWI_EnableIt(AT91C_BASE_TWI,AT91C_TWI_TXRDY | AT91C_TWI_NACK); AT91C_BASE_TWI->TWI_CR = AT91C_TWI_START ; taskENABLE_INTERRUPTS(); xQueueReceive( TWI_QUEUE, &( SizeNotWrited ), ( portTickType ) AT91C_TWI_TMO_VOL(size)); if( TWI_TransferStatus != FREE) { // SYSTEM_ERROR(TWI_TMO_Error); RESET_TWI(); }; TWI_TransferStatus = FREE; xSemaphoreGive( TWI_Semaphore ); } else { //SYSTEM_ERROR(TWI_SEM_Error); } } return SizeNotWrited; }
/** * Called when the system hits a non-recoverable error. Ensure to use * the correct PANIC_CAUSE_* enum to help users inform us of the issue. */ void panic(const enum panic_cause cause) { taskDISABLE_INTERRUPTS(); led_enable(LED_ERROR); for(;;) { led_enable(LED_GPS); led_enable(LED_LOGGER); delay_seconds(FLASH_PAUSE_DELAY_S); led_disable(LED_GPS); led_disable(LED_LOGGER); delay_seconds(FLASH_DELAY_S); for (int c = 0; c < cause; ++c) { led_enable(LED_GPS); led_enable(LED_LOGGER); delay_seconds(FLASH_DELAY_S); led_disable(LED_GPS); led_disable(LED_LOGGER); delay_seconds(FLASH_DELAY_S); } } }
static void ReadParameters(void) // read parameters requested by the user in the NMEA sent. { if((!NMEA.hasCheck()) || NMEA.isChecked() ) { const char *Parm; int8_t Val; Parm = (const char *)NMEA.ParmPtr(0); // [0..15] aircraft-type: 1=glider, 2=towa plane, 3=helicopter, ... if(Parm) { Val=Read_Hex1(Parm[0]); if( (Val>=0) && (Val<16) ) Parameters.setAcftType(Val); } Parm = (const char *)NMEA.ParmPtr(1); // [0..3] addr-type: 1=ICAO, 2=FLARM, 3=OGN if(Parm) { Val=Read_Hex1(Parm[0]); if( (Val>=0) && (Val<4) ) Parameters.setAddrType(Val); } Parm = (const char *)NMEA.ParmPtr(2); // [HHHHHH] Address (ID): 6 hex digits, 24-bit uint32_t Addr; int8_t Len=Read_Hex(Addr, Parm); if( (Len==6) && (Addr<0x01000000) ) Parameters.setAddress(Addr); Parm = (const char *)NMEA.ParmPtr(3); // [0..1] RFM69HW (up to +20dBm) or W (up to +13dBm) if(Parm) { Val=Read_Dec1(Parm[0]); if(Val==0) Parameters.clrTxTypeHW(); else if(Val==1) Parameters.setTxTypeHW(); } Parm = (const char *)NMEA.ParmPtr(4); // [dBm] Tx power int32_t TxPower; Len=Read_SignDec(TxPower, Parm); if( (Len>0) && (TxPower>=(-10)) && (TxPower<=20) ) Parameters.setTxPower(TxPower); Parm = (const char *)NMEA.ParmPtr(5); // [Hz] Tx/Rx frequency correction int32_t FreqCorr; Len=Read_SignDec(FreqCorr, Parm); if( (Len>0) && (FreqCorr>=(-100000)) && (FreqCorr<=100000) ) Parameters.RFchipFreqCorr = (FreqCorr<<8)/15625; taskDISABLE_INTERRUPTS(); // disable all interrupts: Flash can not be read while being erased IWDG_ReloadCounter(); // kick the watch-dog Parameters.WriteToFlash(); // erase and write the parameters into the last page of Flash if(Parameters.ReadFromFlash()<0) Parameters.setDefault(); // read the parameters back: if invalid, set defaults taskENABLE_INTERRUPTS(); // bring back interrupts and the system } PrintParameters(); }
/** * Called when the system hits a non-recoverable error. Ensure to use * the correct PANIC_CAUSE_* enum to help users inform us of the issue. */ void panic(const enum panic_cause cause) { taskDISABLE_INTERRUPTS(); led_device_set_all(false); led_enable(LED_ERROR); for(;;) { led_enable(LED_GPS); led_enable(LED_LOGGER); cpu_device_spin(FLASH_PAUSE_DELAY_MS); led_disable(LED_GPS); led_disable(LED_LOGGER); cpu_device_spin(FLASH_DELAY_MS); for (int c = 0; c < cause - 1; ++c) { led_enable(LED_GPS); led_enable(LED_LOGGER); cpu_device_spin(FLASH_DELAY_MS); led_disable(LED_GPS); led_disable(LED_LOGGER); cpu_device_spin(FLASH_DELAY_MS); } } }
/* FreeRTOS malloc fail hook */ __WEAK__ void vApplicationMallocFailedHook(void) { DEBUGSTR("DIE:ERROR:FreeRTOS: Malloc Failure!\r\n"); taskDISABLE_INTERRUPTS(); for (;; ) {} }
/* vApplicationMallocFailedHook() will only be called if configUSE_MALLOC_FAILED_HOOK is set to 1 in FreeRTOSConfig.h. It is a hook function that will get called if a call to pvPortMalloc() fails. pvPortMalloc() is called internally by the kernel whenever a task, queue, timer or semaphore is created. It is also called by various parts of the demo application. If heap_1.c or heap_2.c are used, then the size of the heap available to pvPortMalloc() is defined by configTOTAL_HEAP_SIZE in FreeRTOSConfig.h, and the xPortGetFreeHeapSize() API function can be used to query the size of free heap space that remains (although it does not provide information on how the remaining heap might be fragmented). */ void vApplicationMallocFailedHook(void) { taskDISABLE_INTERRUPTS(); for(;;); }
void vAssertCalled( void ) { taskDISABLE_INTERRUPTS(); for( ;; ); }
void prvSystemSleep( TickType_t xExpectedIdleTime ) { uint32_t ulSleepTime; eSleepModeStatus eSleepStatus; /* A simple WFI() is executed in any of the cases below: * 1. the system has just booted and the dg_configINITIAL_SLEEP_DELAY_TIME has not yet * passed * 2. the XTAL32K is used as the LP clock, the system has just woke up after clockless * sleep and the LP clock has not yet settled. */ if( !cm_lp_clk_is_avail() ) { __WFI(); // Wait for an interrupt... return; } if (dg_configUSE_LP_CLK == LP_CLK_RCX) { // Update if a previous calibration was running and is finished. if (cm_rcx_calibration_is_on) { if (cm_calibrate_rcx_update()) { return; } } } /* * Calculate the sleep time */ ulSleepTime = pm_conv_ticks_2_prescaled_lpcycles(xExpectedIdleTime); /* Enter a critical section that will not effect interrupts bringing the MCU * out of sleep mode. */ taskDISABLE_INTERRUPTS(); DBG_CONFIGURE_LOW(CMN_TIMING_DEBUG, CMNDBG_CRITICAL_SECTION); DBG_SET_HIGH(CPM_USE_TIMING_DEBUG, CPMDBG_SLEEP_ENTER); /* Ensure it is still ok to enter the sleep mode. */ eSleepStatus = eTaskConfirmSleepModeStatus(); if( eSleepStatus == eAbortSleep ) { DBG_SET_LOW(CPM_USE_TIMING_DEBUG, CPMDBG_SLEEP_ENTER); /* A task has been moved out of the Blocked state since this macro was * executed, or a context switch is being held pending. Do not enter a * sleep state. Restart the tick and exit the critical section. */ taskENABLE_INTERRUPTS(); } else { #if (dg_configIMAGE_SETUP == DEVELOPMENT_MODE) uint32_t primask; #endif if( eSleepStatus == eNoTasksWaitingTimeout ) { /* It is not necessary to configure an interrupt to bring the * microcontroller out of its low power state at a fixed time in the * future. * Enter the low power state. */ pm_sleep_enter( 0 ); } else { /* Configure an interrupt to bring the microcontroller out of its low * power state at the time the kernel next needs to execute. * Enter the low power state. */ pm_sleep_enter( ulSleepTime ); } #if (dg_configIMAGE_SETUP == DEVELOPMENT_MODE) /* If the code stops at this point then the interrupts were enabled while they * shouldn't be so. */ primask = __get_PRIMASK(); ASSERT_WARNING(primask == 1); #endif /* Wake-up! */ pm_system_wake_up(); } }