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