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

static bool wifi_cmd_sta_join(const char* ssid, const char* pass){    int bits = xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, 0, 1, 0);    wifi_config_t wifi_config = { 0 };    strlcpy((char*) wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid));    if (pass) {        strncpy((char*) wifi_config.sta.password, pass, sizeof(wifi_config.sta.password));    }    if (bits & CONNECTED_BIT) {        reconnect = false;        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);        ESP_ERROR_CHECK( esp_wifi_disconnect() );        xEventGroupWaitBits(wifi_event_group, DISCONNECTED_BIT, 0, 1, portTICK_RATE_MS);    }    reconnect = true;    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );    ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );    ESP_ERROR_CHECK( esp_wifi_connect() );    xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, 0, 1, 5000/portTICK_RATE_MS);        return true;}

static uint32_t IRAM_ATTR event_group_wait_bits_wrapper(void *event, uint32_t bits_to_wait_for, int clear_on_exit, int wait_for_all_bits, uint32_t block_time_tick){    if (block_time_tick == OSI_FUNCS_TIME_BLOCKING) {        return (uint32_t)xEventGroupWaitBits(event, bits_to_wait_for, clear_on_exit, wait_for_all_bits, portMAX_DELAY);    } else {        return (uint32_t)xEventGroupWaitBits(event, bits_to_wait_for, clear_on_exit, wait_for_all_bits, block_time_tick);    }}

static void prvTestAbortingEventGroupWait( void ){TickType_t xTimeAtStart;EventGroupHandle_t xEventGroup;EventBits_t xBitsToWaitFor = ( EventBits_t ) 0x01, xReturn;	#if( configSUPPORT_STATIC_ALLOCATION == 1 )	{		static StaticEventGroup_t xEventGroupBuffer;		/* Create the event group.  Statically allocated memory is used so the		creation cannot fail. */		xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );	}	#else	{		xEventGroup = xEventGroupCreate();		configASSERT( xEventGroup );	}	#endif	/* Note the time before the delay so the length of the delay is known. */	xTimeAtStart = xTaskGetTickCount();	/* This first delay should just time out. */	xReturn = xEventGroupWaitBits( xEventGroup, xBitsToWaitFor, pdTRUE, pdTRUE, xMaxBlockTime );	if( xReturn != 0x00 )	{		xErrorOccurred = pdTRUE;	}	prvCheckExpectedTimeIsWithinAnAcceptableMargin( xTimeAtStart, xMaxBlockTime );	/* Note the time before the delay so the length of the delay is known. */	xTimeAtStart = xTaskGetTickCount();	/* This second delay should be aborted by the primary task half way	through. */	xReturn = xEventGroupWaitBits( xEventGroup, xBitsToWaitFor, pdTRUE, pdTRUE, xMaxBlockTime );	if( xReturn != 0x00 )	{		xErrorOccurred = pdTRUE;	}	prvCheckExpectedTimeIsWithinAnAcceptableMargin( xTimeAtStart, xHalfMaxBlockTime );	/* Note the time before the delay so the length of the delay is known. */	xTimeAtStart = xTaskGetTickCount();	/* This third delay should just time out again. */	xReturn = xEventGroupWaitBits( xEventGroup, xBitsToWaitFor, pdTRUE, pdTRUE, xMaxBlockTime );	if( xReturn != 0x00 )	{		xErrorOccurred = pdTRUE;	}	prvCheckExpectedTimeIsWithinAnAcceptableMargin( xTimeAtStart, xMaxBlockTime );	/* Not really necessary in this case, but for completeness. */	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_);}

void meca_fish_sweep_right(int wait, int high){  meca_fish_state_t st = MECA_FISH_SWEEP_RIGHT;  if(high)   {    st = MECA_FISH_SWEEP_HIGH_RIGHT;  }  if(wait)  {    xEventGroupClearBits(busy, 0xFF);  }  if(current_state == st)  {    wait = 0;  }  next_state = st;  if(wait)  {    xEventGroupWaitBits(busy, 0xFF, pdFALSE, pdFALSE, portMAX_DELAY);   }}

static void prvSelectiveBitsTestSlaveFunction( void ){EventBits_t uxPendBits, uxReturned;	/* 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.	This function is called by two different tasks - each of which will use a	different bit.  Check the task handle to see which task the function was	called by. */	if( xTaskGetCurrentTaskHandle() == xSyncTask1 )	{		uxPendBits = ebSELECTIVE_BITS_1;	}	else	{		uxPendBits = ebSELECTIVE_BITS_2;	}	for( ;; )	{		/* Wait until it is time to perform the next cycle of the test.  The		task is unsuspended by the tests implemented in the 		prvSelectiveBitsTestMasterFunction() function. */		vTaskSuspend( NULL );		uxReturned = xEventGroupWaitBits( xEventGroup, uxPendBits, pdTRUE, pdFALSE, portMAX_DELAY );		if( uxReturned == ( EventBits_t ) 0 )		{			break;		}	}}

mcual_i2c_status_t mcual_i2c_transmit(mcual_i2c_id_t id, uint8_t addr, uint8_t * txbuf, uint8_t tx_size, uint8_t * rxbuf, uint8_t rx_size){  (void)rxbuf;  (void)rx_size;  I2C_TypeDef * reg = mcual_i2c_get_register(id);  int i;  addr <<= 1;  xEventGroupClearBits(transfer_done[id], 0xFF);  xQueueReset(tx_queues[id]);  xQueueSend(tx_queues[id], &addr, portMAX_DELAY);  for(i = 0; i < tx_size; i += 1)  {    xQueueSend(tx_queues[id], txbuf + i, portMAX_DELAY);  }  reg->CR2 |= I2C_CR2_ITEVTEN | I2C_CR2_ITERREN;  reg->CR1 = I2C_CR1_START | I2C_CR1_PE;  EventBits_t result = xEventGroupWaitBits(transfer_done[id], 0xFF, pdFALSE, pdFALSE, 1000 / portTICK_PERIOD_MS);  I2C1->CR1 = I2C_CR1_STOP;  if(result & (1 << MCUAL_I2C_SUCCESS))  {    return MCUAL_I2C_SUCCESS;  }  return MCUAL_I2C_FAIL;}

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 );}

static void uart2_unpack_task(void *pvParameters){    int rLen = 0;    DmaUartProtocolPacket rxPacket;    EventBits_t uxBits;    const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;        /* Just to stop compiler warnings. */    ( void ) pvParameters;    udprintf("/r/n[TEST] uart2_unpack_task running...");    for (;;)    {        rLen = 0;        uxBits = xEventGroupWaitBits(                    xUart2RxEventGroup, // The event group being tested.                    UART_DMA_RX_COMPLETE_EVENT_BIT /                    | UART_DMA_RX_INCOMPLETE_EVENT_BIT,	// The bits within the event group to wait for.                    pdTRUE,         // BIT_COMPLETE and BIT_TIMEOUT should be cleared before returning.                    pdFALSE,        // Don't wait for both bits, either bit will do.                    xTicksToWait ); // Wait a maximum of 100ms for either bit to be set.        memset(&rxPacket, 0x00, sizeof(DmaUartProtocolPacket));        if( ( uxBits & UART_DMA_RX_COMPLETE_EVENT_BIT ) != 0 )        {            rLen = Uart2Read((char *)&rxPacket, sizeof(DmaUartProtocolPacket));            if (rLen > 0)            {                test_uart2_rx_count += rLen;            }            TEST_UART2_INFO("Uart2Read COMPLETE rLen=%d",rLen);        }        else if( ( uxBits & UART_DMA_RX_INCOMPLETE_EVENT_BIT ) != 0 )        {            rLen = Uart2Read((char *)&rxPacket, sizeof(DmaUartProtocolPacket));            if (rLen > 0)            {                test_uart2_rx_count += rLen;            }            TEST_UART2_INFO("Uart2Read INCOMPLETE rLen=%d",rLen);        }        else        {        }        if (rLen <= 0) continue;                if ((DMA_UART_START_HEADER_TAG == rxPacket.StartHeader ) /            && (DMA_UART_END_HEADER_TAG == rxPacket.EndHeader)  /            && (DMA_UART_PACKET_PARITY_OK == rxPacket.ParityTag))        {            TEST_UART2_INFO("PKT_ID=0X%02X, Data=%s",rxPacket.ID ,rxPacket.Data);        }        else        {            TEST_UART2_INFO("PKT ERROR");        }    }}

static void prvSyncTask( void *pvParameters ){EventBits_t uxSynchronisationBit, uxReturned;	/* A few tests that check the behaviour when two tasks are blocked on 	various different bits within an event group are performed before this task	enters its infinite loop to carry out its main demo function. */	prvSelectiveBitsTestSlaveFunction();	/* The bit to use to indicate this task is at the synchronisation point is	passed in as the task parameter. */	uxSynchronisationBit = ( EventBits_t ) pvParameters;	for( ;; )	{		/* Now this task takes part in a task synchronisation - sometimes known 		as a 'rendezvous'.  Its execution pattern is controlled by the 'test 		master' task, which is responsible for taking this task out of the 		Suspended state when it is time to test the synchronisation behaviour.  		See: http://www.freertos.org/xEventGroupSync.html. */		vTaskSuspend( NULL );		/* Set the bit that indicates this task is at the synchronisation		point.  The first time this is done the 'test master' task has a lower		priority than this task so this task will get to the sync point before		the set bits task. */		uxReturned = xEventGroupSync( xEventGroup,	/* The event group used for the synchronisation. */									uxSynchronisationBit, /* The bit to set in the event group to indicate this task is at the sync point. */									ebALL_SYNC_BITS,/* The bits to wait for - these bits are set by the other tasks taking part in the sync. */									portMAX_DELAY );/* The maximum time to wait for the sync condition to be met before giving up. */		/* A max delay was used, so this task should only exit the above		function call when the sync condition is met.  Check this is the 		case. */		configASSERT( ( uxReturned & ebALL_SYNC_BITS ) == ebALL_SYNC_BITS );		/* Remove compiler warning if configASSERT() is not defined. */		( void ) uxReturned;		/* Wait until the 'test master' task unsuspends this task again. */		vTaskSuspend( NULL );		/* Set the bit that indicates this task is at the synchronisation		point again.  This time the 'test master' task has a higher priority 		than this task so will get to the sync point before this task. */		uxReturned = xEventGroupSync( xEventGroup, uxSynchronisationBit, ebALL_SYNC_BITS, portMAX_DELAY );		/* Again a max delay was used, so this task should only exit the above		function call when the sync condition is met.  Check this is the 		case. */		configASSERT( ( uxReturned & ebALL_SYNC_BITS ) == ebALL_SYNC_BITS );		/* Block on the event group again.  This time the event group is going		to be deleted while this task is blocked on it so it is expected that 0 		be returned. */		uxReturned = xEventGroupWaitBits( xEventGroup, ebALL_SYNC_BITS, pdFALSE, pdTRUE, portMAX_DELAY );		configASSERT( uxReturned == 0 );	}}

/** * /brief Graph task * * This task runs in the background to draw a pseudo-random graph to a dedicated * display buffer. If the user selects a different screen than the graph, it * will continue to update even though it is not visible until the graph screen * is selected again. * * /param params Parameters for the task. (Not used.) */static void graph_task(void *params){	gfx_coord_t x, y, old_y;	uint8_t current_value;	EventBits_t event_bits;	const TickType_t ticks_to_wait = 10 / portTICK_PERIOD_MS;	x = 0;	current_value = graph_noise;	for(;;) {		/* Wait a maximum of 10ms for either bit 0 or bit 1 to be set within		    the event group.  Not clear the bits before exiting. */		event_bits = xEventGroupWaitBits(				event_group,   /* The event group being tested. */				EVENT_DISPLAY_INIT | EVENT_DISPLAY_GRAPH, /* The bits within the event group to wait for. */				pdFALSE,        /* Bit should not be cleared before returning. */				pdFALSE,       /* Don't wait for both bits, either bit will do. */				ticks_to_wait);/* Wait a maximum of 10ms for either bit to be set. */		if((event_bits & EVENT_DISPLAY_INIT) ||				(event_bits & EVENT_DISPLAY_GRAPH)) {			oled1_set_led_state(&oled1, OLED1_LED1_ID, true);			// Compute new noise sample and value of current graph sample			graph_noise = (graph_noise * 173) + 1;			current_value = ((uint16_t)graph_noise + current_value) / 2;			xSemaphoreTake(display_mutex, portMAX_DELAY);			// Scale graph value so it fits within the canvas			y = CANVAS_GRAPH_Y_OFFSET					+ ((uint16_t)CANVAS_HEIGHT * current_value) / 256;			// Clear previous graph point..			gfx_mono_draw_vertical_line(x, CANVAS_GRAPH_Y_OFFSET, CANVAS_HEIGHT,					GFX_PIXEL_CLR);			// ..and draw a continuous graph using lines			if (x == 0) {				gfx_mono_draw_pixel(x, y, GFX_PIXEL_SET);			} else {				gfx_mono_draw_line(x - 1, old_y, x, y, GFX_PIXEL_SET);			}			xSemaphoreGive(display_mutex);			old_y = y;			if (++x >= CANVAS_WIDTH) {				x = 0;			}			oled1_set_led_state(&oled1, OLED1_LED1_ID, false);		}		vTaskDelay(GRAPH_TASK_DELAY);	}}

EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait ){EventBits_t xReturn;BaseType_t xRunningPrivileged = xPortRaisePrivilege();	xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );	vPortResetPrivilege( xRunningPrivileged );	return xReturn;}

static void scan_task(void *pvParameters){	while(1) {		xEventGroupWaitBits(wifi_event_group, SCAN_DONE_BIT, false, true, portMAX_DELAY);        ESP_LOGI(TAG, "WIFI scan doen");		xEventGroupClearBits(wifi_event_group, SCAN_DONE_BIT);		uint16_t apCount = 0;		esp_wifi_scan_get_ap_num(&apCount);		printf("Number of access points found: %d/n", apCount);		if (apCount == 0) {			ESP_LOGI(TAG, "Nothing AP found");			return;		}		wifi_ap_record_t *list = (wifi_ap_record_t *)malloc(sizeof(wifi_ap_record_t) * apCount);		ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&apCount, list));		int i;		printf("======================================================================/n");		printf("             SSID             |    RSSI    |           AUTH           /n");		printf("======================================================================/n");		for (i=0; i<apCount; i++) {			char *authmode;			switch(list[i].authmode) {			case WIFI_AUTH_OPEN:               authmode = "WIFI_AUTH_OPEN";               break;            case WIFI_AUTH_WEP:               authmode = "WIFI_AUTH_WEP";               break;                       case WIFI_AUTH_WPA_PSK:               authmode = "WIFI_AUTH_WPA_PSK";               break;                       case WIFI_AUTH_WPA2_PSK:               authmode = "WIFI_AUTH_WPA2_PSK";               break;                       case WIFI_AUTH_WPA_WPA2_PSK:               authmode = "WIFI_AUTH_WPA_WPA2_PSK";               break;            default:               authmode = "Unknown";               break;			}			printf("%26.26s    |    % 4d    |    %22.22s/n",list[i].ssid, list[i].rssi, authmode);		}		free(list);		printf("/n/n");		// scan again		vTaskDelay(2000 / portTICK_PERIOD_MS);		//The true parameter cause the function to block until the scan is done.		ESP_ERROR_CHECK(esp_wifi_scan_start(&scanConf, true));	}}

/** * /brief About task * * This task prints a short text about the demo, with a simple zooming * animation. * * /param params Parameters for the task. (Not used.) */static void about_task(void *params){	char c;	gfx_coord_t x, y;	uint8_t i, shift;	EventBits_t event_bits;	const TickType_t ticks_to_wait = 10 / portTICK_PERIOD_MS;	const uint8_t max_shift = 8;	shift = 1;	for (;;) {		/* Wait a maximum of 10ms for either bit 3 to be set within		    the event group.  Not clear the bits before exiting. */		event_bits = xEventGroupWaitBits(				event_group,   /* The event group being tested. */				EVENT_DISPLAY_ABOUT, /* The bits within the event group to wait for. */				pdFALSE,        /* Bit should not be cleared before returning. */				pdFALSE,       /* Don't wait for both bits, either bit will do. */				ticks_to_wait);/* Wait a maximum of 10ms for either bit to be set. */		if(event_bits & EVENT_DISPLAY_ABOUT) {			oled1_set_led_state(&oled1, OLED1_LED2_ID, true);			xSemaphoreTake(display_mutex, portMAX_DELAY);			// Print the about text in an expanding area			for (i = 0; i < (sizeof(about_text) - 1); i++) {				c = about_text[i];				x = (((i % TERMINAL_COLUMNS) * SYSFONT_WIDTH) * shift						+ (CANVAS_WIDTH / 2) * (max_shift - shift))						/ max_shift;				y = (((i / TERMINAL_COLUMNS) * SYSFONT_HEIGHT) * shift						+ (CANVAS_HEIGHT / 2) * (max_shift - shift))						/ max_shift;				gfx_mono_draw_char(c, x, y, &sysfont);			}			xSemaphoreGive(display_mutex);			oled1_set_led_state(&oled1, OLED1_LED2_ID, false);			// Repeat task until we're displaying the text in full size			if (shift < max_shift) {				shift++;				vTaskDelay(ABOUT_TASK_DELAY);			} else {				shift = 0;				xEventGroupClearBits(event_group, EVENT_DISPLAY_ABOUT);			}		}	}}

static void prvCDCGetChar( void ){    const TickType_t xTransferCompleteDelay = pdMS_TO_TICKS( 750UL );    if( ulBytesAvailable == 0 ) {        /* Wait for a transfer to complete. */        xEventGroupWaitBits(	xCDCEventBits,                                cmdRX_COMPLETE_BIT, /* The bit to wait for. */                                pdTRUE, /* Clear the bit before exiting the function. */                                pdFALSE, /* Only need to wait for one bit anyway. */                                xTransferCompleteDelay ); /* The maximum time to wait for the event. */    }}

int meca_fish_is_catch(void){  xEventGroupClearBits(busy, 0xFF);  next_state = MECA_FISH_CHECK;  xEventGroupWaitBits(busy, 0xFF, pdFALSE, pdFALSE, portMAX_DELAY); #ifdef AUSBEE_SIM  return ((rand() % 3) == 0);#else  return ir_value > 300;#endif}

static portTASK_FUNCTION( vnRFTask, pvParameters ){TickType_t xRate, xLastTime;BaseType_t	Event_Status = 0;	/* The parameters are not used. */	( void ) pvParameters;	nRF_SPI_IO_Init();	xRate = 10;	/* We need to initialise xLastFlashTime prior to the first call to 	vTaskDelayUntil(). */	xLastTime = xTaskGetTickCount();	for(;;)	{		if (xEventGruop == NULL)		{			xEventGruop = xEventGroupCreate();			continue;		}		Event_Status = xEventGroupWaitBits(xEventGruop, Key_State_Down, pdTRUE, pdFALSE, (TickType_t)1000);		if (Event_Status & Key_State_Down)		{			nRF_Buf.datatype = DataType_Key;			nRF_Buf.data[0] = Get_Key_Status();		}		if (Event_Status&Key_State_Down)		{			if (nRF_Start_Tx() == nRF_TX_OK)			{				BSP_LED_Toggle(LED2);				if (nRF_Start_Rx() == nRF_RX_OK)				{					BSP_LED_Toggle(LED3);				}			}			Event_Status = 0;		}				memset(&nRF_Buf, 0, sizeof(nRF_Tx_DataType));		//vTaskDelayUntil( &xLastTime, xRate );	}} /*lint !e715 !e818 !e830 Function definition must be standard for task creation. */

void smartconfig_example_task(void * parm){    EventBits_t uxBits;    ESP_ERROR_CHECK( esp_smartconfig_set_type(SC_TYPE_ESPTOUCH) );    ESP_ERROR_CHECK( esp_smartconfig_start(sc_callback) );    while (1) {        uxBits = xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT | ESPTOUCH_DONE_BIT, true, false, portMAX_DELAY);         if(uxBits & CONNECTED_BIT) {            ESP_LOGI(TAG, "WiFi Connected to ap");        }        if(uxBits & ESPTOUCH_DONE_BIT) {            ESP_LOGI(TAG, "smartconfig over");            esp_smartconfig_stop();            vTaskDelete(NULL);        }    }}

void dispatch_queue::dispatch_thread_handler(void){	BaseType_t status = xSemaphoreTakeRecursive(mutex_, portMAX_DELAY);	assert(status == pdTRUE && "Failed to lock mutex!");	do {		//after wait, we own the lock		if(!quit_ && q_.size())		{			auto op = std::move(q_.front());			q_.pop();			//unlock now that we're done messing with the queue			status = xSemaphoreGiveRecursive(mutex_);			assert(status == pdTRUE && "Failed to unlock mutex!");			op();			status = xSemaphoreTakeRecursive(mutex_, portMAX_DELAY);			assert(status == pdTRUE && "Failed to lock mutex!");		}		else if(!quit_)		{			status = xSemaphoreGiveRecursive(mutex_);			assert(status == pdTRUE && "Failed to unlock mutex!");			// Wait for new work - clear flags on exit			xEventGroupWaitBits(notify_flags_, DISPATCH_WAKE_EVT, pdTRUE, pdFALSE, portMAX_DELAY);			status = xSemaphoreTakeRecursive(mutex_, portMAX_DELAY);			assert(status == pdTRUE && "Failed to lock mutex!");		}	} while (!quit_);	// We were holding the mutex after we woke up	status = xSemaphoreGiveRecursive(mutex_);	assert(status == pdTRUE && "Failed to unlock mutex!");	// Set a signal to indicate a thread exited	status = xEventGroupSetBits(notify_flags_, DISPATCH_EXIT_EVT);	assert(status == pdTRUE && "Failed to set event flags!");	// Delete the current thread	vTaskDelete(NULL);}

static void prvCDCSend( const char *pcData, size_t xDataLength ){    const TickType_t xTransferCompleteDelay = pdMS_TO_TICKS( 500UL );    ( void ) pcData;    ( void ) xDataLength;    if( xDataLength > 0 ) {        if( CDCDSerialDriver_Write( ( void * ) pcData, xDataLength, ( TransferCallback ) prvCDCDataTransmittedCallback, 0 ) == USBD_STATUS_SUCCESS ) {            /* Wait for the transfer to complete. */            xEventGroupWaitBits(	xCDCEventBits,                                    cmdTX_COMPLETE_BIT, /* The bit to wait for. */                                    pdTRUE, /* Clear the bit before exiting the function. */                                    pdFALSE, /* Only need to wait for one bit anyway. */                                    xTransferCompleteDelay ); /* The maximum time to wait for the event. */        }    }}

void main_loop(void* arg){    (void)arg;    // timeout of 500ms    const TickType_t xTicksToWait = 500 / portTICK_PERIOD_MS;    while(1) {        EventBits_t uxBits = xEventGroupWaitBits(g_pot_event_group, (POT_PORT1_BIT | POT_PORT2_BIT), pdTRUE, pdFALSE, xTicksToWait);//        xEventGroupClearBits(g_pot_event_group, (POT_PORT1_BIT | POT_PORT2_BIT));        // if not timeout, change the state        if (uxBits != 0) {//            gpio_set_level(GPIO_NUM_5, 0);//            gpio_set_level(GPIO_NUM_21, 1);//            ets_delay_us(50);            gpio_set_level(GPIO_NUM_21, 0);            ets_delay_us(223);            ets_delay_us(g_joy_state.joy1_potx);            gpio_set_level(GPIO_NUM_21, 1);//            gpio_set_level(GPIO_NUM_5, 1);//            ets_delay_us(50);//            gpio_set_level(GPIO_NUM_21, 0);//            gpio_set_level(GPIO_NUM_5, 0);//            const TickType_t xDelay = 100 / portTICK_PERIOD_MS;//            vTaskDelay(xDelay);        } else {            // timeout            gpio_set_level(GPIO_NUM_21, 0);        }//        taskYIELD();    }}

void meca_fish_walk(int wait){  if(wait)  {    xEventGroupClearBits(busy, 0xFF);  }  if(current_state == MECA_FISH_WALK)  {    wait = 0;  }  next_state = MECA_FISH_WALK;  if(wait)  {    xEventGroupWaitBits(busy, 0xFF, pdFALSE, pdFALSE, portMAX_DELAY);   }}

int flag_event_wait(flag_event_t *event){#if defined(OS_FREERTOS)	EventBits_t uxBits;	uxBits = xEventGroupWaitBits(*event,			((uint32_t)1) << 0,			pdTRUE,			pdFALSE,			portMAX_DELAY);	if(uxBits & (((uint32_t)1) << 0))		return 1;	return 0;#elif defined(OS_UCOS)	OS_ERR err;	OS_FLAGS flags;	flags = OSFlagPend(event, 1, 0, OS_OPT_PEND_FLAG_SET_ANY, 0, &err);	if((err == OS_ERR_NONE) && (flags & ((OS_FLAGS)1) == 1)) return 1;	return 0;#endif}

void meca_fish_prepare(int wait){  if(wait)  {    xEventGroupClearBits(busy, 0xFF);  }  if(current_state == MECA_FISH_PREPARE)  {    wait = 0;  }  next_state = MECA_FISH_PREPARE;  if(wait)  {    xEventGroupWaitBits(busy, 0xFF, pdFALSE, pdFALSE, portMAX_DELAY);   }}

void meca_fish_swim_right(int wait){  if(wait)  {    xEventGroupClearBits(busy, 0xFF);  }  if(current_state == MECA_FISH_SWIM_RIGHT)  {    wait = 0;  }  next_state = MECA_FISH_SWIM_RIGHT;  if(wait)  {    xEventGroupWaitBits(busy, 0xFF, pdFALSE, pdFALSE, portMAX_DELAY);   }}

/**  * @brief 软件触发中断，进入中断发送数据  * @param  None  * retval   None  */uint8_t nRF_Start_Tx(void){	BaseType_t uxBits;	const TickType_t xTicksToWait = 5;		// Time Out 3ms	uint8_t RetValue = 0;		// Entry TX Mode to Send Data	nRF_TX_Mode();		/*!< Select the nRF: Chip Select low */	nRF_CSN_LOW();		nRF_SPI_IO_WriteReg(nRF_FLUSH_TX, 0x00);	nRF_SPI_IO_WriteData(nRF_WR_TX_PLOAD, (uint8_t *)&nRF_Buf, nRF_TX_PLOAD_WIDTH);		/*!< Deselect the nRF: Start Send */	nRF_CSN_HIGH();	uxBits = xEventGroupWaitBits(xEventGruop, nRF_State_TX_OK|nRF_State_TX_MAX, pdTRUE, pdFALSE, xTicksToWait);	if (uxBits & nRF_State_TX_OK)	{		nRF_RX_Mode();		RetValue = nRF_TX_OK;	}	else if ( uxBits & nRF_State_TX_MAX)	{		nRF_CSN_LOW();		nRF_SPI_IO_WriteReg(nRF_FLUSH_TX, 0xFF);		nRF_CSN_HIGH();		RetValue = nRF_MAX_TX;	}	else	{		nRF_CSN_LOW();		nRF_SPI_IO_WriteReg(nRF_FLUSH_TX, 0xFF);		nRF_CSN_HIGH();		RetValue = nRF_TIMEOUT;	}		return RetValue;}

/// Wait for one or more Signal Flags to become signaled for the current /b RUNNING thread./// /param[in]     signals       wait until all specified signal flags set or 0 for any single signal flag./// /param[in]     millisec      timeout value or 0 in case of no time-out./// /return event flag information or error code./// /note MUST REMAIN UNCHANGED: /b osSignalWait shall be consistent in every CMSIS-RTOS.osEvent osSignalWait (int32_t signals, uint32_t millisec){    TaskHandle_t thread_id;    EventGroupHandle_t event_handle;    EventBits_t uxBits=0x80000000;    osEvent   ret;    uint32_t wait_ticks;    if (signals & (0xFFFFFFFF << osFeature_Signals)) {        ret.status = osErrorValue;        ret.value.signals = 0;        return ret;    }        thread_id = xTaskGetCurrentTaskHandle();    event_handle = find_signal_by_thread(thread_id);    if (event_handle) {        if (signals == 0) {            // if signals is 0, then wait any signal            signals = (1 << osFeature_Signals) - 1;        }        wait_ticks = millisec_to_ticks(millisec);        uxBits = xEventGroupWaitBits(                        event_handle,   /* The event group being tested. */                        signals, /* The bits within the event group to wait for. */                        pdTRUE,        /* the signals should be cleared before returning. */                        pdFALSE,       /* Don't wait for both bits, either bit will do. */                        wait_ticks );/* Wait for either bit to be set. */        if (uxBits == 0) {            ret.status = millisec ? osEventTimeout : osOK;            ret.value.signals = 0;        }        else {            ret.status = osEventSignal;            ret.value.signals = uxBits;        }    }        return ret;}