static esp_err_t event_handler(void *ctx, system_event_t *event) { switch (event->event_id) { case SYSTEM_EVENT_STA_START: esp_wifi_connect(); ESP_LOGI(TAG, "SYSTEM_EVENT_STA_START"); break; case SYSTEM_EVENT_STA_CONNECTED: /* enable ipv6 */ tcpip_adapter_create_ip6_linklocal(TCPIP_ADAPTER_IF_STA); break; case SYSTEM_EVENT_STA_GOT_IP: xEventGroupSetBits(wifi_event_group, IPV4_GOTIP_BIT); ESP_LOGI(TAG, "SYSTEM_EVENT_STA_GOT_IP"); 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, IPV4_GOTIP_BIT); xEventGroupClearBits(wifi_event_group, IPV6_GOTIP_BIT); break; case SYSTEM_EVENT_AP_STA_GOT_IP6: xEventGroupSetBits(wifi_event_group, IPV6_GOTIP_BIT); ESP_LOGI(TAG, "SYSTEM_EVENT_STA_GOT_IP6"); char *ip6 = ip6addr_ntoa(&event->event_info.got_ip6.ip6_info.ip); ESP_LOGI(TAG, "IPv6: %s", ip6); default: break; } return ESP_OK; }
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; } }
static bool _start_network_event_task(){ if(!_network_event_group){ _network_event_group = xEventGroupCreate(); if(!_network_event_group){ log_e("Network Event Group Create Failed!"); return false; } xEventGroupSetBits(_network_event_group, WIFI_DNS_IDLE_BIT); } if(!_network_event_queue){ _network_event_queue = xQueueCreate(32, sizeof(system_event_t *)); if(!_network_event_queue){ log_e("Network Event Queue Create Failed!"); return false; } } if(!_network_event_task_handle){ xTaskCreatePinnedToCore(_network_event_task, "network_event", 4096, NULL, ESP_TASKD_EVENT_PRIO - 1, &_network_event_task_handle, ARDUINO_RUNNING_CORE); if(!_network_event_task_handle){ log_e("Network Event Task Start Failed!"); return false; } } return esp_event_loop_init(&_network_event_cb, NULL) == ESP_OK; }
/** * DNS callback * @param name * @param ipaddr * @param callback_arg */ static void wifi_dns_found_callback(const char *name, const ip_addr_t *ipaddr, void *callback_arg) { if(ipaddr) { (*reinterpret_cast<IPAddress*>(callback_arg)) = ipaddr->u_addr.ip4.addr; } xEventGroupSetBits(_network_event_group, WIFI_DNS_DONE_BIT); }
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; }
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 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 wifi_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: esp_wifi_connect(); xEventGroupClearBits(wifi_event_group, CONNECTED_BIT); break; default: break; } return ESP_OK; }
static esp_err_t eth_event_handler(void *ctx, system_event_t *event) { switch (event->event_id) { case SYSTEM_EVENT_ETH_START: started = true; break; case SYSTEM_EVENT_ETH_GOT_IP: memset(&ip, 0, sizeof(tcpip_adapter_ip_info_t)); ESP_ERROR_CHECK(tcpip_adapter_get_ip_info(ESP_IF_ETH, &ip)); xEventGroupSetBits(eth_event_group, GOTIP_BIT); break; case SYSTEM_EVENT_ETH_STOP: xEventGroupClearBits(eth_event_group, GOTIP_BIT); started = false; default: break; } return ESP_OK; }
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; }
/*FUNCTION********************************************************************** * * Function Name : OSA_EventSet * Description : Set one or more event flags of an event object. * Return : osaStatus_Success if set successfully, osaStatus_Error if failed. * *END**************************************************************************/ osaStatus_t OSA_EventSet(osaEventId_t eventId, osaEventFlags_t flagsToSet) { #if osNumberOfEvents osEventStruct_t* pEventStruct; portBASE_TYPE taskToWake = pdFALSE; if(osObjectIsAllocated(&osEventInfo, eventId) == FALSE) { return osaStatus_Error; } pEventStruct = (osEventStruct_t*)eventId; if(pEventStruct->event.eventHandler == NULL) { return osaStatus_Error; } if (__get_IPSR()) { if (pdPASS != xEventGroupSetBitsFromISR(pEventStruct->event.eventHandler, (event_flags_t)flagsToSet, &taskToWake)) { panic(0,(uint32_t)OSA_EventSet,0,0); return osaStatus_Error; } if (pdTRUE == taskToWake) { portYIELD_FROM_ISR(taskToWake); } } else { xEventGroupSetBits(pEventStruct->event.eventHandler, (event_flags_t)flagsToSet); } return osaStatus_Success; #else (void)eventId; (void)flagsToSet; return osaStatus_Error; #endif }
/* For internal use only - execute a 'set bits' command that was pended from an 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 bits before returning the value. */ uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES; } } traceEVENT_GROUP_SYNC_END( xEventGroup, uxReturn ); return uxReturn; }
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; }