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

static esp_err_t event_handler(void *ctx, system_event_t *event){    switch(event->event_id) {    case SYSTEM_EVENT_STA_START:        esp_wifi_connect();        break;    case SYSTEM_EVENT_STA_DISCONNECTED:        esp_wifi_connect();        xEventGroupClearBits(tcp_event_group, WIFI_CONNECTED_BIT);        break;    case SYSTEM_EVENT_STA_CONNECTED:        break;    case SYSTEM_EVENT_STA_GOT_IP:    	ESP_LOGI(TAG, "got ip:%s/n",		ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));    	xEventGroupSetBits(tcp_event_group, WIFI_CONNECTED_BIT);        break;    case SYSTEM_EVENT_AP_STACONNECTED:    	ESP_LOGI(TAG, "station:"MACSTR" join,AID=%d/n",		MAC2STR(event->event_info.sta_connected.mac),		event->event_info.sta_connected.aid);    	xEventGroupSetBits(tcp_event_group, WIFI_CONNECTED_BIT);    	break;    case SYSTEM_EVENT_AP_STADISCONNECTED:    	ESP_LOGI(TAG, "station:"MACSTR"leave,AID=%d/n",		MAC2STR(event->event_info.sta_disconnected.mac),		event->event_info.sta_disconnected.aid);    	xEventGroupClearBits(tcp_event_group, WIFI_CONNECTED_BIT);    	break;    default:        break;    }    return ESP_OK;}

void SensorReading(void *pvParams){	uint8 buff[7];	uint8 bfd[15];	// Initialize timer, 1Hz period	TickType_t readFrequency = 1000;	TickType_t wakeUpTime = xTaskGetTickCount();	// Sensor variables	double Bfield[3];	int tmp;	while(1)	{		// Read magnetic field		xEventGroupSetBits(torqueSignalEG, 1<<1);		vTaskDelay(50);		taskENTER_CRITICAL();		/*buff[1] = i2cRegisterRead(4, 20);		buff[2] = i2cRegisterRead(4, 21);		buff[3] = i2cRegisterRead(4, 22);		buff[4] = i2cRegisterRead(4, 23);		buff[5] = i2cRegisterRead(4, 24);		buff[6] = i2cRegisterRead(4, 25);*/		taskEXIT_CRITICAL();		Bfield[0] = ((double)((buff[1]<<8) + buff[2] - 32768))*((double)1.52587890625E-9);//0.00005/32768		Bfield[1] = ((double)((buff[3]<<8) + buff[4] - 32768))*((double)1.52587890625E-9);		Bfield[2] = ((double)((buff[5]<<8) + buff[6] - 32768))*((double)1.52587890625E-9);		/*sprintf(bfd, "%.7f,", Bfield[0]);		sciSend(scilinREG, 10, bfd);		sprintf(bfd, "%.7f,", Bfield[1]);		sciSend(scilinREG, 10, bfd);		sprintf(bfd, "%.7f", Bfield[2]);		sciSend(scilinREG, 10, bfd);		bfd[0] = '/n';		sciSend(scilinREG, 1, bfd);*/		vTaskDelay(50);		xEventGroupSetBits(torqueSignalEG, 1<<2);		// Dispatch read values		xQueueOverwrite(SensorDataQ, Bfield);		vTaskDelayUntil(&wakeUpTime, readFrequency);	}}

esp_err_t event_handler(void *ctx, system_event_t *event){	if (event->event_id == SYSTEM_EVENT_SCAN_DONE) {		xEventGroupSetBits(wifi_event_group, SCAN_DONE_BIT);	}	return ESP_OK;}

void ButtonHandler(){	uint32_t mask=GPIOIntStatus(GPIO_PORTF_BASE,false);	uint8_t value=0;	if(mask & GPIO_PIN_4){		//Boton izquierdo		value= GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4);		if(value==0){			//boton pulsado			// Activa el Timer4A (empezara a funcionar)			TimerEnable(TIMER4_BASE, TIMER_A);			pulsacionLarga=true;		}else{			TimerDisable(TIMER4_BASE,TIMER_A);			if(pulsacionLarga){				xEventGroupSetBits(xEventGroup, PilotoAutomaticoBit);				if((xTaskCreate(PilAuto, (signed portCHAR *)"Piloto Auto", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &PilautTaskHandle) != pdTRUE))				{					while(1);				}			}		}	}	if(mask & GPIO_PIN_0){		//boton derecho		xEventGroupClearBits( xEventGroup, PilotoAutomaticoBit );	}	GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4);}

int commandClearFlash(uint8_t *buffer){	uint8_t state = getProcessStatus();	if( (state == 1) || (state == 3) )		*buffer = 0x0E;	else	{		EventBits_t flags = xEventGroupGetBits(xEventGroup);		if( flags & FLAG_FLASH_CLEARING )		{			*buffer++ = 0x0d; //устройство занято			*buffer = 0x04; //устройство зянято стиранием памяти			return 7;		}		else		{			memset((void*)flashMap, 0xff, sizeof(flashMap));			memset((void*)headerList, 0xff, sizeof(headerList));			countProc = 0;			spiChipErase();			xEventGroupSetBits(xEventGroup, FLAG_FLASH_CLEARING);			//стартуем таймер на 22 сек, после которого state сменим с 4 на 2.			xTimerStart(timerClearFlash, 500);		}	}	return 6;}

static void prvExerciseEventGroupAPI( void ){EventGroupHandle_t xEventGroup;EventBits_t xBits;const EventBits_t xBitsToWaitFor = ( EventBits_t ) 0xff, xBitToClear = ( EventBits_t ) 0x01;	/* Exercise some event group functions. */	xEventGroup = xEventGroupCreate();	configASSERT( xEventGroup );	/* No bits should be set. */	xBits = xEventGroupWaitBits( xEventGroup, xBitsToWaitFor, pdTRUE, pdFALSE, mainDONT_BLOCK );	configASSERT( xBits == ( EventBits_t ) 0 );	/* Set bits and read back to ensure the bits were set. */	xEventGroupSetBits( xEventGroup, xBitsToWaitFor );	xBits = xEventGroupGetBits( xEventGroup );	configASSERT( xBits == xBitsToWaitFor );	/* Clear a bit and read back again using a different API function. */	xEventGroupClearBits( xEventGroup, xBitToClear );	xBits = xEventGroupSync( xEventGroup, 0x00, xBitsToWaitFor, mainDONT_BLOCK );	configASSERT( xBits == ( xBitsToWaitFor & ~xBitToClear ) );	/* Finished with the event group. */	vEventGroupDelete( xEventGroup );}

dispatch_queue::~dispatch_queue(){	BaseType_t status;	// Signal to dispatch threads that it's time to wrap up	quit_ = true;	// We will join each thread to confirm exiting	for (size_t i = 0; i < threads_.size(); ++i) {		eTaskState state;		do {			// Signal wake - check exit flag			xEventGroupSetBits(notify_flags_, DISPATCH_WAKE_EVT);			// Wait until a thread signals exit. Timeout is acceptable.			xEventGroupWaitBits(notify_flags_, DISPATCH_EXIT_EVT, pdTRUE, pdFALSE, 10);			// If it was not thread_[i], that is ok, but we will loop around			// until threads_[i] has exited			state = eTaskGetState(threads_[i].thread);		} while (state != eDeleted);		threads_[i].name.clear();	}	// Cleanup event flags and mutex	vEventGroupDelete(notify_flags_);	vSemaphoreDelete(mutex_);}

static void sc_callback(smartconfig_status_t status, void *pdata){    switch (status) {        case SC_STATUS_WAIT:            ESP_LOGI(TAG, "SC_STATUS_WAIT");            break;        case SC_STATUS_FIND_CHANNEL:            ESP_LOGI(TAG, "SC_STATUS_FINDING_CHANNEL");            break;        case SC_STATUS_GETTING_SSID_PSWD:            ESP_LOGI(TAG, "SC_STATUS_GETTING_SSID_PSWD");            break;        case SC_STATUS_LINK:            ESP_LOGI(TAG, "SC_STATUS_LINK");            wifi_config_t *wifi_config = pdata;            ESP_LOGI(TAG, "SSID:%s", wifi_config->sta.ssid);            ESP_LOGI(TAG, "PASSWORD:%s", wifi_config->sta.password);            ESP_ERROR_CHECK( esp_wifi_disconnect() );            ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, wifi_config) );            ESP_ERROR_CHECK( esp_wifi_connect() );            break;        case SC_STATUS_LINK_OVER:            ESP_LOGI(TAG, "SC_STATUS_LINK_OVER");            if (pdata != NULL) {                uint8_t phone_ip[4] = { 0 };                memcpy(phone_ip, (uint8_t* )pdata, 4);                ESP_LOGI(TAG, "Phone ip: %d.%d.%d.%d/n", phone_ip[0], phone_ip[1], phone_ip[2], phone_ip[3]);            }            xEventGroupSetBits(wifi_event_group, ESPTOUCH_DONE_BIT);            break;        default:            break;    }}

EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ){EventBits_t xReturn;BaseType_t xRunningPrivileged = xPortRaisePrivilege();	xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );	vPortResetPrivilege( xRunningPrivileged );	return xReturn;}

static void prvSanityCheckCreatedEventGroup( EventGroupHandle_t xEventGroup ){EventBits_t xEventBits;const EventBits_t xFirstTestBits = ( EventBits_t ) 0xaa, xSecondTestBits = ( EventBits_t ) 0x55;	/* The event group should not have any bits set yet. */	xEventBits = xEventGroupGetBits( xEventGroup );	if( xEventBits != ( EventBits_t ) 0 )	{		xErrorOccurred = pdTRUE;	}	/* Some some bits, then read them back to check they are as expected. */	xEventGroupSetBits( xEventGroup, xFirstTestBits );	xEventBits = xEventGroupGetBits( xEventGroup );	if( xEventBits != xFirstTestBits )	{		xErrorOccurred = pdTRUE;	}	xEventGroupSetBits( xEventGroup, xSecondTestBits );	xEventBits = xEventGroupGetBits( xEventGroup );	if( xEventBits != ( xFirstTestBits | xSecondTestBits ) )	{		xErrorOccurred = pdTRUE;	}	/* Finally try clearing some bits too and check that operation proceeds as	expected. */	xEventGroupClearBits( xEventGroup, xFirstTestBits );	xEventBits = xEventGroupGetBits( xEventGroup );	if( xEventBits != xSecondTestBits )	{		xErrorOccurred = pdTRUE;	}}

int flag_event_post(flag_event_t *event){	/* Make sure that interrupt flag is set */#if defined(OS_FREERTOS)	xEventGroupSetBits(			*event,			(((uint8_t)1)<< 0));#elif defined(OS_UCOS)	OS_ERR err;	OSFlagPost(event, 1, OS_OPT_POST_FLAG_SET, &err);#endif	return 0;}

void dispatch_queue::dispatch(fp_t&& op){	BaseType_t status = xSemaphoreTakeRecursive(mutex_, portMAX_DELAY);	assert(status == pdTRUE && "Failed to lock mutex!");	q_.push(std::move(op));	status = xSemaphoreGiveRecursive(mutex_);	assert(status == pdTRUE && "Failed to unlock mutex!");	// Notifies threads that new work has been added to the queue	xEventGroupSetBits(notify_flags_, DISPATCH_WAKE_EVT);}

static esp_err_t event_handler(void *ctx, system_event_t *event){    switch(event->event_id) {    case SYSTEM_EVENT_STA_GOT_IP:        xEventGroupClearBits(wifi_event_group, DISCONNECTED_BIT);        xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);        break;    case SYSTEM_EVENT_STA_DISCONNECTED:        if (reconnect) {            ESP_LOGI(TAG, "sta disconnect, reconnect...");            esp_wifi_connect();        } else {            ESP_LOGI(TAG, "sta disconnect");        }        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);        xEventGroupSetBits(wifi_event_group, DISCONNECTED_BIT);        break;    default:        break;    }    return ESP_OK;}

/** * /brief  task1 in FreeRTOS * /details Call vTaskDelayUntil() to execute task1 with a fixed period 1 second. * /param[in] *par */static void task1(void *par){	uint32_t queue_data = 1;	TickType_t xLastExecutionTime;	xLastExecutionTime = xTaskGetTickCount(); /*!< initialize current tick */	while (1) {		//// 1-E: Task2 --> Task1		x.t_t2_t1 = perf_end();		//// 2-S: Task1 --> Int		perf_start();		_arc_aux_write(AUX_IRQ_HINT, SWI_INTNO); /*!< activate soft_interrupt */		//// 5-E: Int --> Task1		x.t_int_t1 = perf_end();		// task delay, to control benchmark run speed		vTaskDelayUntil( &xLastExecutionTime, TASK_DELAY_MS);		// Task 1 acquire mutex first		xSemaphoreTake(mux1_id, portMAX_DELAY);		// Task 1 acquire semaphore first		xSemaphoreTake(sem1_id, portMAX_DELAY);		//// 6-S: Task1 --> Task2		perf_start();		vTaskResume(task2_handle);		//// 8-S: Mutex Release -> Mutex Acquire		perf_start();		// Task 1 release mutex, task 2 acquire it		xSemaphoreGive(mux1_id);		//// 9-S: Sem Post -> Sem Acquire		perf_start();		// Task 1 post sem, task 2 acquire it		xSemaphoreGive(sem1_id);		//// 10-S: Event Write -> Event Read		perf_start();		// Task 1 write event, task 2 read it		xEventGroupSetBits(evt1_cb, EVENT_WAIT_BITS);		//// 11-S: Queue Write -> Queue Read		perf_start();		// Task 1 write queue, task 2 read it		xQueueSend(dtq1_id, (void *)(&queue_data),  portMAX_DELAY);		queue_data ++;	}}

static int exeAioRespDebugPacket(AioDspProtocolPkt *pPacket){    switch(pPacket->DataAndCRC[0])    {    case (u8)RESP_DEB_CID_SAMPLE_SW:{    }break;    case (u8)RESP_DEB_CID_START_VPP:{        xEventGroupSetBits( gpRespDebug->xEventGroup,                             RESP_DEB_PKT_BIT_START_VPP);    }break;    case (u8)RESP_DEB_CID_STOP_VPP:{        gpRespDebug->RespVppResult = (int)((pPacket->DataAndCRC[1] << 24) /                                            | (pPacket->DataAndCRC[2] << 16) /                                            | (pPacket->DataAndCRC[3] << 8) /                                            | pPacket->DataAndCRC[4]);        xEventGroupSetBits( gpRespDebug->xEventGroup,                             RESP_DEB_PKT_BIT_STOP_VPP);    }break;    default:{    }break;    } //End of switch    return 0;}

static esp_err_t event_handler(void *ctx, system_event_t *event){    switch(event->event_id) {    case SYSTEM_EVENT_STA_START:        xTaskCreate(smartconfig_example_task, "smartconfig_example_task", 4096, NULL, 3, NULL);        break;    case SYSTEM_EVENT_STA_GOT_IP:        xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);        break;    case SYSTEM_EVENT_STA_DISCONNECTED:        esp_wifi_connect();        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);        break;    default:        break;    }    return ESP_OK;}

/*FUNCTION********************************************************************** * * Function Name : OSA_EventSet * Description   : Set one or more event flags of an event object. * Return kStatus_OSA_Success if set successfully, kStatus_OSA_Error if failed. * *END**************************************************************************/osa_status_t OSA_EventSet(event_t *pEvent, event_flags_t flagsToSet){    assert(pEvent);    portBASE_TYPE taskToWake = pdFALSE;    if (__get_IPSR())    {        xEventGroupSetBitsFromISR(pEvent->eventHandler, flagsToSet, &taskToWake);        if (pdTRUE == taskToWake)        {            vPortYieldFromISR();        }    }    else    {        xEventGroupSetBits(pEvent->eventHandler, flagsToSet);    }    return kStatus_OSA_Success;}

static int exeAioTempDebugPacket(AioDspProtocolPkt *pPacket){    switch(pPacket->DataAndCRC[0])    {    case (u8)TEMP_DEB_CID_SELFCHECK:{        gpTempDebug->u8SelfcheckResult = pPacket->DataAndCRC[1];        xEventGroupSetBits( gpTempDebug->xEventGroup,                             TEMP_DEB_PKT_BIT_SELFCHECK);    }break;        case (u8)TEMP_DEB_CID_UPLOAD_TYPE:{    }break;        default:{    }break;    } //End of switch    return 0;}

static esp_err_t event_handler(void *ctx, system_event_t *event){    switch(event->event_id) {    case SYSTEM_EVENT_STA_START:        esp_wifi_connect();        break;    case SYSTEM_EVENT_STA_GOT_IP:        xEventGroupSetBits(wifi_event_group, CONNECTED_BIT);        break;    case SYSTEM_EVENT_STA_DISCONNECTED:        /* This is a workaround as ESP32 WiFi libs don't currently           auto-reassociate. */        esp_wifi_connect();        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);        break;    default:        break;    }    return ESP_OK;}

/// Set the specified Signal Flags of an active thread./// /param[in]     thread_id     thread ID obtained by /ref osThreadCreate or /ref osThreadGetId./// /param[in]     signals       specifies the signal flags of the thread that should be set./// /return previous signal flags of the specified thread or 0x80000000 in case of incorrect parameters./// /note MUST REMAIN UNCHANGED: /b osSignalSet shall be consistent in every CMSIS-RTOS.int32_t osSignalSet (osThreadId thread_id, int32_t signals){    EventGroupHandle_t event_handle;    portBASE_TYPE taskWoken = pdFALSE;    portBASE_TYPE xResult;    EventBits_t uxBits_ret=0x80000000;#ifdef CHECK_VALUE_OF_EVENT_GROUP        EventBits_t uxBits;#endif        if (signals & (0xFFFFFFFF << osFeature_Signals)) {        return 0x80000000;    }    event_handle = find_signal_by_thread(thread_id);    if (event_handle) {        if (inHandlerMode()) {            uxBits_ret = xEventGroupGetBitsFromISR(event_handle);            xResult = xEventGroupSetBitsFromISR(                            event_handle,    /* The event group being updated. */                            signals,         /* The bits being set. */                            &taskWoken );            if( xResult != pdFAIL )            {                portYIELD_FROM_ISR(taskWoken);            }        }        else {            uxBits_ret = xEventGroupGetBits(event_handle);#ifdef CHECK_VALUE_OF_EVENT_GROUP                            uxBits = #endif                                    xEventGroupSetBits(                           event_handle,    /* The event group being updated. */                           signals );/* The bits being set. */        }    }    return uxBits_ret;}

/* For internal use only - execute a 'set bits' command that was pended froman interrupt. */void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet ){	( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet );}

EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait ){EventBits_t uxOriginalBitValue, uxReturn;EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;BaseType_t xAlreadyYielded;	configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );	configASSERT( uxBitsToWaitFor != 0 );	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )	{		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );	}	#endif	vTaskSuspendAll();	{		traceEVENT_GROUP_SYNC_START( xEventGroup, uxBitsToSet );		uxOriginalBitValue = pxEventBits->uxEventBits;		( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );		if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )		{			/* All the rendezvous bits are now set - no need to block. */			uxReturn = ( uxOriginalBitValue | uxBitsToSet );			/* Rendezvous always clear the bits.  They will have been cleared			already unless this is the only task in the rendezvous. */			pxEventBits->uxEventBits &= uxBitsToWaitFor;			xTicksToWait = 0;		}		else		{			if( xTicksToWait != ( TickType_t ) 0 )			{				/* Store the bits that the calling task is waiting for in the				task's event list item so the kernel knows when a match is				found.  Then enter the blocked state. */				vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );				/* This assignment is obsolete as uxReturn will get set after				the task unblocks, but some compilers mistakenly generate a				warning about uxReturn being returned without being set if the				assignment is omitted. */				uxReturn = 0;			}			else			{				/* The rendezvous bits were not set, but no block time was				specified - just return the current event bit value. */				uxReturn = pxEventBits->uxEventBits;			}		}	}	xAlreadyYielded = xTaskResumeAll();	if( xTicksToWait != ( TickType_t ) 0 )	{		if( xAlreadyYielded == pdFALSE )		{			portYIELD_WITHIN_API();		}		else		{			mtCOVERAGE_TEST_MARKER();		}		/* The task blocked to wait for its required bits to be set - at this		point either the required bits were set or the block time expired.  If		the required bits were set they will have been stored in the task's		event list item, and they should now be retrieved then cleared. */		uxReturn = uxTaskResetEventItemValue();		if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )		{			/* The task timed out, just return the current event bit value. */			taskENTER_CRITICAL();			{				uxReturn = pxEventBits->uxEventBits;				/* Although the task got here because it timed out before the				bits it was waiting for were set, it is possible that since it				unblocked another task has set the bits.  If this is the case				then it may be required to clear the bits before exiting. */				if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )				{					pxEventBits->uxEventBits &= ~uxBitsToWaitFor;				}				else				{					mtCOVERAGE_TEST_MARKER();				}			}			taskEXIT_CRITICAL();		}		else		{			/* The task unblocked because the bits were set.  Clear the control//.........这里部分代码省略.........

static BaseType_t prvSelectiveBitsTestMasterFunction( void ){BaseType_t xError = pdFALSE;EventBits_t uxBit;	/* Used in a test that blocks two tasks on various different bits within an 	event group - then sets each bit in turn and checks that the correct tasks 	unblock at the correct times.  The two other tasks (xSyncTask1 and 	xSyncTask2) call prvSelectiveBitsTestSlaveFunction() to perform their parts in	this test.	Both other tasks should start in the suspended state. */	if( eTaskGetState( xSyncTask1 ) != eSuspended )	{		xError = pdTRUE;	}	if( eTaskGetState( xSyncTask2 ) != eSuspended )	{		xError = pdTRUE;	}	/* Test each bit in the byte individually. */	for( uxBit = 0x01; uxBit < 0x100; uxBit <<= 1 )	{		/* Resume both tasks. */		vTaskResume( xSyncTask1 );		vTaskResume( xSyncTask2 );		/* Now both tasks should be blocked on the event group. */		if( eTaskGetState( xSyncTask1 ) != eBlocked )		{			xError = pdTRUE;		}		if( eTaskGetState( xSyncTask2 ) != eBlocked )		{			xError = pdTRUE;		}		/* Set one bit. */		xEventGroupSetBits( xEventGroup, uxBit );		/* Is the bit set in the first set of selective bits?  If so the first		sync task should have unblocked and returned to the suspended state. */		if( ( uxBit & ebSELECTIVE_BITS_1 ) == 0 )		{			/* Task should not have unblocked. */			if( eTaskGetState( xSyncTask1 ) != eBlocked )			{				xError = pdTRUE;			}		}		else		{			/* Task should have unblocked and returned to the suspended state. */			if( eTaskGetState( xSyncTask1 ) != eSuspended )			{				xError = pdTRUE;			}		}		/* Same checks for the second sync task. */		if( ( uxBit & ebSELECTIVE_BITS_2 ) == 0 )		{			/* Task should not have unblocked. */			if( eTaskGetState( xSyncTask2 ) != eBlocked )			{				xError = pdTRUE;			}		}		else		{			/* Task should have unblocked and returned to the suspended state. */			if( eTaskGetState( xSyncTask2 ) != eSuspended )			{				xError = pdTRUE;			}		}	}	/* Ensure both tasks are blocked on the event group again, then delete the	event group so the other tasks leave this portion of the test. */	vTaskResume( xSyncTask1 );	vTaskResume( xSyncTask2 );	/* Deleting the event group is the signal that the two other tasks should	leave the prvSelectiveBitsTestSlaveFunction() function and continue to the main	part of their functionality. */	vEventGroupDelete( xEventGroup );	return xError;}