自学教程：C++ xTaskGetSchedulerState函数代码示例

int CharDev::printf(const char *format, ...){    if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState()) {        xSemaphoreTake(mPrintfSemaphore, portMAX_DELAY);    }        int len = 0;        va_list args;        va_start(args, format);        do {            va_list args_copy;            va_copy(args_copy, args);            len = vsnprintf(mpPrintfMem, mPrintfMemSize, format, args_copy);            va_end(args_copy);            if (len >= mPrintfMemSize) {                const int align = 16;                mPrintfMemSize = (align + ((len/align) * align));                /* TO DO :                 * Do not know why realloc() doesn't work.  It is a combination of C++ class                 * use combined with va_args and realloc itself.  It seems to work in vector                 * and str classes though.                 */                if (0) {                    if (mpPrintfMem) {                        free(mpPrintfMem);                    }                    mpPrintfMem = (char*) malloc(mPrintfMemSize);                }                else {                    mpPrintfMem = (char*) realloc(mpPrintfMem, mPrintfMemSize);                }            }            else {                break;            }        } while (mpPrintfMem);        va_end(args);        this->put(mpPrintfMem);    if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState()) {        xSemaphoreGive(mPrintfSemaphore);    }    return len;}

bool UartDev::putChar(char out, unsigned int timeout){    /* If OS not running, just send data using polling and return */    if (taskSCHEDULER_RUNNING != xTaskGetSchedulerState()) {        mpUARTRegBase->THR = out;        while(! (mpUARTRegBase->LSR & (1 << 6)));        return true;    }    /* FreeRTOS running, so send to queue and if queue is full, return false */    if(! xQueueSend(mTxQueue, &out, timeout)) {        return false;    }    /* If transmitter is not busy, send out the oldest char from the queue,     * and let the transmitter empty interrupt empty out the queue thereafter.     */    const int uart_tx_is_idle = (1 << 6);    if (mpUARTRegBase->LSR & uart_tx_is_idle)    {        if (xQueueReceive(mTxQueue, &out, 0)) {            mpUARTRegBase->THR = out;        }    }    return true;}

int SDCardSendCommand(uint8_t command, uint32_t param, uint8_t crc, void* buffer, size_t recvSize) {	Chip_GPIO_SetPinState(LPC_GPIO, 0, 2, !Chip_GPIO_GetPinState(LPC_GPIO, 0, 2));	if (xTaskGetSchedulerState() == taskSCHEDULER_RUNNING)		xSemaphoreTake(xMutexSDCard, portMAX_DELAY);	int result = SDCARD_ERROR_GENERIC;	int wait = SDCARD_SPI_MAX_WAIT;	int i;	uint8_t read = 0;	uint8_t* data = (uint8_t*) buffer;	command += 0x40;	SDCardSetSS();	for (i = 0; i < SDCARD_IDLE_PRE_WAIT_ATTEMPTS; i++) {		if (spi_transceive_byte(SDCARD_SPI_DEVICE, 0xff) == 0xff) break;	}	result = SDCARD_ERROR_TRANSMIT_INTERRUPTED;	CommandBuffer[0] = command;	CommandBuffer[1] = param >> 24;	CommandBuffer[2] = param >> 16;	CommandBuffer[3] = param >> 8;	CommandBuffer[4] = param;	CommandBuffer[5] = (crc_crc7(CommandBuffer, 5) << 1) | 1;	spi_transceive(SDCARD_SPI_DEVICE, CommandBuffer, 6);	for (i = 0; i < 6; i++) {		if (CommandBuffer[i] != 0xff) {//			MSS_GPIO_set_output(MSS_GPIO_27, 0);			__asm volatile ("nop");//			MSS_GPIO_set_output(MSS_GPIO_27, 1);			goto fail;		}	}

/** * /brief      Initialize the managed memory module * /author     Adam Dunkels * *             This function initializes the managed memory module and *             should be called before any other function from the *             module. * */intmmem_init(void){	/* Only execute the initalisation before the scheduler was started.	 * So there exists only one thread and	 * no locking is needed for the initialisation	 */	configASSERT(xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED);	/* cancle, if initialisation was already done */	if(mutex != NULL) {		return -1;	}	/* Do not use an recursive mutex,	 * because mmem_check() will not work vital then.	 */	mutex = xSemaphoreCreateMutex();	if(mutex == NULL) {		return -2;	}	list_init(mmemlist);	avail_memory = MMEM_SIZE;	return 0;}

/*------------------------------------------------------------------------------ * MSS_I2C_wait_complete() * See "mss_i2c.h" for details of how to use this function. */mss_i2c_status_t MSS_I2C_wait_complete(    mss_i2c_instance_t * this_i2c){    ASSERT( (this_i2c == &g_mss_i2c0) || (this_i2c == &g_mss_i2c1) );#ifdef USE_OLD_I2C_POLLING_CODE    while ( this_i2c->status == MSS_I2C_IN_PROGRESS ) {        /* Wait for transaction to compltete.*/        ;    }#else    configASSERT( ( this_i2c->xI2CCompleteSemaphore ) );    if( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED ) {        while ( this_i2c->status == MSS_I2C_IN_PROGRESS ) {            /* Wait for transaction to compltete.*/            ;        }    } else {        xSemaphoreTake( this_i2c->xI2CCompleteSemaphore, portMAX_DELAY );    }#endif    return this_i2c->status;}

void wireless_service(void){    /*     * If FreeRTOS is running, then a task should be calling us, so we can block on     * the nordic activity semaphore.     *     * There are three cases of block time :     *  1 - If nordic interrupt signal is still pending, then we haven't read     *      all Nordic FIFO, so we don't block on semaphore at all.     *  2 - There are pending packets that need either ACK or retry, so we     *      block just for one tick to carry out mesh logic.     *  3 - No RX and no TX, so block until either a packet is sent, or until     *      we receive a packet; both cases will give the semaphore.     */    if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState()) {        if (!nordic_intr_signal()) {            const TickType_t blockTime = mesh_get_pnd_pkt_count() ? 1 : portMAX_DELAY;            xSemaphoreTake(g_nrf_activity_sem, blockTime);        }        mesh_service();    }    /* A timer ISR is calling us, so we can't use FreeRTOS API, hence we poll */    else {        if (nordic_intr_signal() || mesh_get_pnd_pkt_count() > 0) {            mesh_service();        }    }}

/**  * @brief  This function handles SysTick Handler.  * @param  None  * @retval None  */void SysTick_Handler(void){  if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)  {    xPortSysTickHandler();  }}

char I2C_Base::writeReg(char deviceAddress, char registerAddress, char value){    if(mDisableOperation) {        return 0;    }    // If scheduler not running , perform polling transaction    if(taskSCHEDULER_RUNNING != xTaskGetSchedulerState())    {        NVIC_DisableIRQ(mIRQ);        {            i2cKickOffTransfer(i2cWrite, deviceAddress, registerAddress, &value, 1);            do {                // Wait until SI flag is set, then call i2cStateMachine()                while(! (mpI2CRegs->I2CONSET & (1 << 3)) )                {                    ;                }            }while (writeComplete != i2cStateMachine());        }        NVIC_EnableIRQ(mIRQ);        return true;    }    // Wait for I2C Access, and just return, I2C Lock will be given by ISR()    xSemaphoreTake(mI2CMutex, portMAX_DELAY);    i2cKickOffTransfer(i2cWrite, deviceAddress, registerAddress, &value, 1);    return 0;}

/* If FreeRTOS is not running, then we rely on RIT service to call this function, * otherwise we rely on FreeRTOS tick hook to provide system timer */static void hl_periodic_service(void){    sys_watchdog_feed();    /* If FreeRTOS is running, user should use a dedicated task to call mesh service,     * so we will not call it if freertos is running     */    if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState()) {        g_system_uptime_ms += MS_PER_TICK();        /* We don't need RIT if FreeRTOS is running */        if (sys_rit_running()) {            sys_rit_disable();            /* The timer value so far may be an odd number, and if MS_PER_TICK() is not 1             * then we may increment it like 12, 22, 32, etc. so round this number once.             */            g_system_uptime_ms = (g_system_uptime_ms / 10) * 10;        }    }    else {        g_system_uptime_ms += g_time_per_rit_isr_ms;        wireless_service();        /**         * Small hack to support interrupts if FreeRTOS is not running :         * FreeRTOS API resets our base priority register, then all         * interrupts higher priority than IP_SYSCALL will not get locked out.         *   @see more notes at isr_priorities.h.  @see IP_SYSCALL         */        __set_BASEPRI(0);    }}

extern "C" void __malloc_unlock ( struct _reent *_r ){	if (xTaskGetSchedulerState() == taskSCHEDULER_RUNNING)		// don't release mutex if scheduler not started or suspended	{		mallocMutex.Release();	}}

unsigned char prvTraceIsSchedulerSuspended(void){    /* Assumed to be available in FreeRTOS. According to the FreeRTOS docs, 	INCLUDE_xTaskGetSchedulerState or configUSE_TIMERS must be set to 1 in	FreeRTOSConfig.h for this function to be available. */	return xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED;}

char isFreeRtosRunning(){    if (!critialRegionSemaphore) {        critialRegionSemaphore = xSemaphoreCreateMutex();    }    return (taskSCHEDULER_RUNNING == xTaskGetSchedulerState());}

void ff_rel_grant (	_SYNC_t sobj	/* Sync object to be signaled */){    if(taskSCHEDULER_RUNNING == xTaskGetSchedulerState())    {        xSemaphoreGive(sobj);	/* FreeRTOS */    }}

void __env_unlock ( struct _reent *_r ){#if OS_THREAD_SAFE_NEWLIB	if (!xTaskGetSchedulerState())		return;	  	xSemaphoreGiveRecursive(alt_envsem);#endif /* OS_THREAD_SAFE_NEWLIB */}

/**  * @brief  This function handles SysTick Handler.  * @param  None  * @retval None  */void SysTick_Handler (void){  HAL_IncTick();  if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)  {    xPortSysTickHandler();  }  Toggle_Leds();}

void osResumeAllTasks(void){   //Make sure the operating system is running   if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)   {      //Resume all tasks      xTaskResumeAll();   }}

void osSuspendAllTasks(void){   //Make sure the operating system is running   if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)   {      //Suspend all tasks      vTaskSuspendAll();   }}

	BaseType_t MPU_xTaskGetSchedulerState( void )	{	BaseType_t xReturn;	BaseType_t xRunningPrivileged = xPortRaisePrivilege();		xReturn = xTaskGetSchedulerState();		vPortResetPrivilege( xRunningPrivileged );		return xReturn;	}

BaseType_t MPU_xTaskGetSchedulerState( void ){    BaseType_t xReturn;    BaseType_t xRunningPrivileged = prvRaisePrivilege();    xReturn = xTaskGetSchedulerState();    portRESET_PRIVILEGE( xRunningPrivileged );    return xReturn;}

	portBASE_TYPE MPU_xTaskGetSchedulerState( void )	{	portBASE_TYPE xReturn;    portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();		xReturn = xTaskGetSchedulerState();        portRESET_PRIVILEGE( xRunningPrivileged );		return xReturn;	}

/**  * @brief  This function handles SysTick Handler.  * @param  None  * @retval None  */void SysTick_Handler(void){	HAL_IncTick();	if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)	{		xPortSysTickHandler();	}	// HAL_SYSTICK_IRQHandler();	systick_count++;}

bool UartDev::flush(void){    if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState()) {        while (getTxQueueSize() > 0) {            vTaskDelay(1);        }    }    return true;}

/********************************************************************* * *       _cbSendTaskList()**  Function description*    This function is part of the link between FreeRTOS and SYSVIEW.*    Called from SystemView when asked by the host, it uses SYSVIEW*    functions to send the entire task list to the host.*/static void _cbSendTaskList(void) {  TaskStatus_t*         pxTaskStatusArray;  UBaseType_t           uxArraySize;  UBaseType_t           x;  char                  cStatus;#if INCLUDE_xTaskGetIdleTaskHandle  TaskHandle_t          hIdle;  hIdle = xTaskGetIdleTaskHandle();#endif  /* Take a snapshot of the number of tasks in case it changes while this  function is executing. */  uxArraySize = uxTaskGetNumberOfTasks();  /* Allocate an array index for each task. */  pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );  if( pxTaskStatusArray != NULL ) {    /* Generate the (binary) data. */    uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, NULL );#if INCLUDE_xTaskGetIdleTaskHandle    /* only get Idle task handle if scheduler has been started */    if (xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED) {      hIdle = xTaskGetIdleTaskHandle();    } else {      hIdle = NULL;    }#endif        /* Create a human readable table from the binary data. */    for( x = 0; x < uxArraySize; x++ ) {      uint8_t* pStack;#if INCLUDE_pxTaskGetStackStart      pStack = pxTaskGetStackStart(pxTaskStatusArray[x].xHandle);#else      pStack = (uint8_t*)0;#endif#if INCLUDE_xTaskGetIdleTaskHandle      if (pxTaskStatusArray[x].xHandle != hIdle) {        SYSVIEW_SendTaskInfo((unsigned)pxTaskStatusArray[x].xHandle, pxTaskStatusArray[x].pcTaskName, pxTaskStatusArray[x].uxCurrentPriority, (unsigned int)pStack, 0);      }#else      if (memcmp(pxTaskStatusArray[x].pcTaskName, "IDLE", 5) != 0) {        SYSVIEW_SendTaskInfo((unsigned)pxTaskStatusArray[x].xHandle, pxTaskStatusArray[x].pcTaskName, pxTaskStatusArray[x].uxCurrentPriority, (unsigned int)pStack, 0);      }#endif    }    /* Free the array again. */    vPortFree( pxTaskStatusArray );  }}

 void log(String text) {     // ToDo: Add other debug outputs     if (xTaskGetSchedulerState() == taskSCHEDULER_RUNNING) {         if (xSemaphoreTake(serialPortMutex, ( TickType_t ) 10) == pdTRUE ) {             DEBUG_SERIAL.println(text);         }         xSemaphoreGive(serialPortMutex);     } else {         DEBUG_SERIAL.println(text);     } }

void SysTick_Handler(void){    //-- FreeRTOS 
C++ xTaskIncrementTick函数代码示例
C++ xTaskGetCurrentTaskHandle函数代码示例