/* worker线程入口 */ static void worker_entry(void* parameter) { rt_bool_t result; rt_uint32_t index, setchar; rt_uint8_t data_buffer[BUFFER_ITEM]; setchar = 0x21; while (1) { /* 构造数据 */ for(index = 0; index < BUFFER_ITEM; index++) { data_buffer[index] = setchar; if (++setchar == 0x7f) setchar = 0x21; } /* 持有信号量 */ rt_sem_take(sem, RT_WAITING_FOREVER); /* 把数据放到环形buffer中 */ result = rb_put(&working_rb, &data_buffer[0], BUFFER_ITEM); /* 释放信号量 */ rt_sem_release(sem); /* 放入成功,做一个10 OS Tick的休眠 */ rt_thread_delay(10); } }
/* ethernet buffer */ void eth_tx_thread_entry(void* parameter) { struct eth_tx_msg* msg; while (1) { if (rt_mb_recv(ð_tx_thread_mb, (rt_uint32_t*)&msg, RT_WAITING_FOREVER) == RT_EOK) { struct eth_device* enetif; RT_ASSERT(msg->netif != RT_NULL); RT_ASSERT(msg->buf != RT_NULL); enetif = (struct eth_device*)msg->netif->state; if (enetif != RT_NULL) { /* call driver's interface */ if (enetif->eth_tx(&(enetif->parent), msg->buf) != RT_EOK) { rt_kprintf("transmit eth packet failed\n"); } } /* send ack */ rt_sem_release(&(enetif->tx_ack)); } } }
void tf_open(char *name) { FRESULT res; int len; char buffer[512]; rt_kprintf("\r\ntf_open enter;"); rt_sem_take( &sem_dataflash, RT_TICK_PER_SECOND * FLASH_SEM_DELAY ); sprintf(buffer,"%s",name); res = f_open(&file, buffer, FA_READ | FA_WRITE); rt_kprintf("\r\n f_open = %d",res); if(res == 0) { rt_kprintf("\r\n %s=",buffer); while(1) { memset(buffer,0,sizeof(buffer)); res = f_read(&file,buffer,sizeof(buffer),&len); if(res || len == 0) { break; } rt_kprintf("%s",buffer); } rt_kprintf("\r\n"); f_close(&file); } rt_sem_release(&sem_dataflash); }
void *rt_page_alloc(rt_size_t npages) { struct rt_page_head *b, *n; struct rt_page_head **prev; if(npages == 0) return RT_NULL; /* lock heap */ rt_sem_take(&heap_sem, RT_WAITING_FOREVER); for (prev = &rt_page_list; (b = *prev) != RT_NULL; prev = &(b->next)) { if (b->page > npages) { /* splite pages */ n = b + npages; n->next = b->next; n->page = b->page - npages; *prev = n; break; } if (b->page == npages) { /* this node fit, remove this node */ *prev = b->next; break; } } /* unlock heap */ rt_sem_release(&heap_sem); return b; }
/*********************************************************** * Function: * Description: * Input: * Input: * Output: * Return: * Others: ***********************************************************/ static void rt_thread_entry_sd_test( void* parameter ) { FRESULT res; char tempbuf[64]; rt_sem_take( &sem_dataflash, RT_TICK_PER_SECOND * FLASH_SEM_DELAY ); SPI_Configuration(); res = SD_Init(); if(0 == res) { rt_kprintf("\r\n SD CARD INIT OK!"); memset(tempbuf,0,sizeof(tempbuf)); SD_GetCID(tempbuf); rt_kprintf("\r\n CID="); printf_hex_data(tempbuf, 16); SD_GetCSD(tempbuf); rt_kprintf("\r\n SID="); printf_hex_data(tempbuf, 16); rt_kprintf("\r\n SD 容量=%d",SD_GetCapacity()); } else { rt_kprintf("\r\n SD CARD INIT ERR = %d",res); } if(0 == f_mount(MMC, &fs)) { rt_kprintf("\r\n f_mount SD OK!"); } rt_sem_release(&sem_dataflash); while( 1 ) { rt_thread_delay( RT_TICK_PER_SECOND / 20 ); } }
/* transmit packet. */ rt_err_t rt_stm32_eth_tx( rt_device_t dev, struct pbuf* p) { rt_err_t ret; struct pbuf *q; uint32_t l = 0; u8 *buffer ; if (( ret = rt_sem_take(&tx_wait, netifGUARD_BLOCK_TIME) ) == RT_EOK) { buffer = (u8 *)(DMATxDescToSet->Buffer1Addr); for(q = p; q != NULL; q = q->next) { //show_frame(q); rt_memcpy((u8_t*)&buffer[l], q->payload, q->len); l = l + q->len; } if( ETH_Prepare_Transmit_Descriptors(l) == ETH_ERROR ) rt_kprintf("Tx Error\n"); //rt_sem_release(xTxSemaphore); rt_sem_release(&tx_wait); //rt_kprintf("Tx packet, len = %d\n", l); } else { rt_kprintf("Tx Timeout\n"); return ret; } /* Return SUCCESS */ return RT_EOK; }
void DMA1_Channel7_IRQHandler(void) { if (DMA_GetITStatus(DMAx_RX_FLAG_TCIF) != RESET) { rt_interrupt_enter(); DMA_Cmd(DMAx_RX_CHANNEL, DISABLE); DMA_ClearITPendingBit(DMAx_RX_FLAG_TCIF); I2C_GenerateSTOP(I2Cx, ENABLE); rt_sem_release(&DMA_RX_Sem); rt_interrupt_leave(); } else { DMA_ClearITPendingBit(DMAx_RX_FLAG_TEIF); rt_kprintf("DMA RX ERROR!\nSR1=0x%04x\nSR1=0x%04x\nDR=0x%04x\nCCR=0x%04x\nCR1=0x%04x\nCR2=0x%04x\n", I2Cx->SR1, I2Cx->SR2, I2Cx->DR, I2Cx->CCR, I2Cx->CR1, I2Cx->CR2); } }
static rt_err_t uart485_3_rx_ind(rt_device_t dev, rt_size_t size) { rt_sem_release(&uart485_3_rx_msg_sem); // rt_kprintf("**%s(), len:%u\n", __FUNCTION__, size); return RT_EOK; }
/* * 获取电压、电流波形采样数据, 每个点是4字节的有符号数据, 以网络序存储 * * 当返回值为SIE_OK时,非空指针指向的内存区域存储了返回值 */ enum sinkinfo_error_e get_sinkinfo_sample_data(int em_no, enum sinkinfo_cmd_e cmd, void *data_buf, int len) { enum sinkinfo_error_e ret = SIE_OK; if (len < SINK_INFO_PX_SAMPLE_BUF_SIZE) { printf_syn("func:%s, buf too small(%d)\n", __FUNCTION__, len); return SIE_BUF2SMALL; } // ret = rt_sem_take(&px_sample_data_sem, RT_WAITING_FOREVER); ret = rt_sem_take(&sinkinfo_sem, RT_WAITING_FOREVER); if (RT_EOK != ret) { printf_syn("take px_sample_data_sem fail(%d)\n", ret); return SIE_FAIL; } switch (cmd) { /* 以下命令返回数据量较大,大约(40*3+4)字节 */ case SIC_GET_PAV_SAMPLE_DATA: /* a相电压波形采样值 */ // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pa_vi_sample[0], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pa_vi_sample[0], len); break; case SIC_GET_PBV_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pb_vi_sample[0], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pb_vi_sample[0], len); break; case SIC_GET_PCV_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pc_vi_sample[0], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pc_vi_sample[0], len); break; case SIC_GET_PAI_SAMPLE_DATA: /* a相电流波形采样值 */ // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pa_vi_sample[1], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pa_vi_sample[1], len); break; case SIC_GET_PBI_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pb_vi_sample[1], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pb_vi_sample[1], len); break; case SIC_GET_PCI_SAMPLE_DATA: // conv_3bsinged_to_4bsinged(data_buf, len, sinkinfo_all_em[0].px_vi_sample.pc_vi_sample[1], SINK_INFO_PX_SAMPLE_BUF_SIZE); rt_memcpy(data_buf, sinkinfo_all_em[em_no].px_vi_sample.pc_vi_sample[1], len); break; default: ret = SIE_INVALID_CMD; printf_syn("func:%s, invalid cmd\n", __FUNCTION__); break; } // rt_sem_release(&px_sample_data_sem); rt_sem_release(&sinkinfo_sem); return ret; }
int si_get_item_in_wl_data(char *sn, union sinkinfo_ptc_ctc_st *item, rt_tick_t *time_stamp) { rt_err_t sem_ret; struct sinkinfo_wl_data_item_st *p; int ret = SUCC; if (NULL==sn || NULL==item || NULL==time_stamp) { printf_syn("func:%s(), param is NULL\n", __FUNCTION__); return FAIL; } sem_ret = rt_sem_take(&sink_wl_data_sem, RT_WAITING_FOREVER); if (RT_EOK != sem_ret) { printf_syn("take sink_wl_data_sem fail(%d)\n", ret); return FAIL; } p = si_lookup_item_in_wl_data(sn); if (NULL == p) { ret = FAIL; } else { rt_memcpy(item, &p->item, sizeof(*item)); *time_stamp = p->time_stamp; } rt_sem_release(&sink_wl_data_sem); return ret; }
static void tcpip_init_done_callback(void *arg) { rt_device_t device; struct eth_device *ethif; struct ip_addr ipaddr, netmask, gw; struct rt_list_node* node; struct rt_object* object; struct rt_object_information *information; extern struct rt_object_information rt_object_container[]; LWIP_ASSERT("invalid arg.\n",arg); IP4_ADDR(&gw, 0,0,0,0); IP4_ADDR(&ipaddr, 0,0,0,0); IP4_ADDR(&netmask, 0,0,0,0); /* enter critical */ rt_enter_critical(); /* for each network interfaces */ information = &rt_object_container[RT_Object_Class_Device]; for (node = information->object_list.next; node != &(information->object_list); node = node->next) { object = rt_list_entry(node, struct rt_object, list); device = (rt_device_t) object; if (device->type == RT_Device_Class_NetIf) { ethif = (struct eth_device*)device; /* leave critical */ rt_exit_critical(); netif_add(ethif->netif, &ipaddr, &netmask, &gw, ethif, netif_device_init, tcpip_input); if (netif_default == NULL) netif_set_default(ethif->netif); #if LWIP_DHCP dhcp_start(ethif->netif); #else netif_set_up(ethif->netif); #endif #ifdef LWIP_NETIF_LINK_CALLBACK netif_set_link_up(ethif->netif); #endif /* enter critical */ rt_enter_critical(); } } /* leave critical */ rt_exit_critical(); rt_sem_release((rt_sem_t)arg); }
rt_err_t usart_rx_indicate(rt_device_t dev, rt_size_t size) { while(size--) { rt_sem_release(&rx_sem); } return RT_EOK; }
void tc_done(rt_uint8_t stat) { _tc_stat |= stat; _tc_stat &= ~TC_STAT_RUNNING; /* release semaphore */ rt_sem_release(&_tc_sem); }
void pthread_exit (void* value) { _pthread_data_t* ptd; _pthread_cleanup_t* cleanup; extern _pthread_key_data_t _thread_keys[PTHREAD_KEY_MAX]; ptd = _pthread_get_data(rt_thread_self()); rt_enter_critical(); /* disable cancel */ ptd->cancelstate = PTHREAD_CANCEL_DISABLE; /* set return value */ ptd->return_value = value; rt_exit_critical(); /* invoke pushed cleanup */ while (ptd->cleanup != RT_NULL) { cleanup = ptd->cleanup; ptd->cleanup = cleanup->next; cleanup->cleanup_func(cleanup->parameter); /* release this cleanup function */ rt_free(cleanup); } /* destruct thread local key */ if (ptd->tls != RT_NULL) { void* data; rt_uint32_t index; for (index = 0; index < PTHREAD_KEY_MAX; index ++) { if (_thread_keys[index].is_used) { data = ptd->tls[index]; if (data) _thread_keys[index].destructor(data); } } /* release tls area */ rt_free(ptd->tls); ptd->tls = RT_NULL; } if (ptd->attr.detachstate == PTHREAD_CREATE_JOINABLE) { /* release the joinable pthread */ rt_sem_release(ptd->joinable_sem); } /* detach thread */ rt_thread_detach(ptd->tid); /* reschedule thread */ rt_schedule(); }
int pthread_rwlock_destroy (pthread_rwlock_t *rwlock) { int result; if (!rwlock) return EINVAL; if (rwlock->attr == -1) return 0; /* rwlock is not initialized */ if ( (result = pthread_mutex_lock(&rwlock->rw_mutex)) != 0) return(result); if (rwlock->rw_refcount != 0 || rwlock->rw_nwaitreaders != 0 || rwlock->rw_nwaitwriters != 0) { result = EBUSY; return(EBUSY); } else { /* check whether busy */ result = rt_sem_trytake(&(rwlock->rw_condreaders.sem)); if (result == RT_EOK) { result = rt_sem_trytake(&(rwlock->rw_condwriters.sem)); if (result == RT_EOK) { rt_sem_release(&(rwlock->rw_condreaders.sem)); rt_sem_release(&(rwlock->rw_condwriters.sem)); pthread_cond_destroy(&rwlock->rw_condreaders); pthread_cond_destroy(&rwlock->rw_condwriters); } else { rt_sem_release(&(rwlock->rw_condreaders.sem)); result = EBUSY; } } else result = EBUSY; } pthread_mutex_unlock(&rwlock->rw_mutex); if (result == 0) pthread_mutex_destroy(&rwlock->rw_mutex); return result; }
void rt_soft_timer_tick_increase(void) { timer_ex_cnt ++; if (timer_ex_cnt >= (RT_TICK_PER_SECOND / RT_TIMER_TICK_PER_SECOND)) { timer_ex_cnt = 0; rt_sem_release(&timer_sem); } }
static rt_err_t rs485_rx_ind(rt_device_t dev, rt_size_t size) { RT_ASSERT(uart1_dev_my != RT_NULL); /* release semaphore to let thread rx data */ rt_sem_release(&uart1_dev_my->rx_sem); return RT_EOK; }
static rt_err_t finsh_rx_ind(rt_device_t dev, rt_size_t size) { RT_ASSERT(shell != RT_NULL); /* release semaphore to let finsh thread rx data */ rt_sem_release(&shell->rx_sem); return RT_EOK; }
static void worker_thread_entry(void* parameter) { rt_thread_delay(10); while (1) { rt_sem_release(sem); rt_thread_delay(5); } }
void print_sink_data(void) { int i, j, k; struct sinkinfo_wl_data_item_st *p; rt_err_t ret; char title[DEV_SN_BUF_STRING_WITH_NUL_LEN_MAX+4]; if (NULL == sink_wl_collect_data) { printf_syn("func:%s(), sink_wl_collect_data is NULL\n", __FUNCTION__); return; } ret = rt_sem_take(&sink_wl_data_sem, RT_WAITING_FOREVER); if (RT_EOK != ret) { printf_syn("take sink_wl_data_sem fail(%d)\n", ret); return; } p = sink_wl_collect_data; #if 0 rt_strncpy(title, p->pt_ct_sn, sizeof(title)); i = rt_strlen(p->pt_ct_sn); title[i++] = ' '; title[i++] = 'p'; title[i++] = 'a'; j = i - 1; title[i++] = '-'; title[i++] = '\0'; #endif for (k=0; k<SINKINFO_WL_DATA_ITEM_MAX_NO; ++k) { if ('\0' != p->pt_ct_sn[0]) { rt_strncpy(title, p->pt_ct_sn, sizeof(title)); i = rt_strlen(p->pt_ct_sn); title[i++] = ' '; title[i++] = 'p'; title[i++] = 'a'; j = i - 1; title[i++] = '-'; title[i++] = '\0'; printf_syn("index %4d:\n", k); print_pt_ct_st_info(title, &p->item.ptc_data.pt_pa); title[j] = 'b'; print_pt_ct_st_info(title, &p->item.ptc_data.pt_pb); title[j] = 'c'; print_pt_ct_st_info(title, &p->item.ptc_data.pt_pc); } ++p; } rt_sem_release(&sink_wl_data_sem); return; }
/***************************************************************************//** * @brief * Draw a horizontal line with specified color * * @details * * @note * * @param[in] c * Pointer to color * * @param[in] x1 * Horizontal start position * * @param[in] x2 * Horizontal end position * * @param[in] y * Vertical position ******************************************************************************/ static void oled_drawHLine(rtgui_color_t *c, int x1, int x2, int y) { rt_err_t ret; rt_uint8_t color[MINISTM32_OLED_WIDTH], data[3]; rt_uint32_t i; if ((x1 >= MINISTM32_OLED_WIDTH) || (y >= MINISTM32_OLED_HEIGHT)) { return; } if (x2 >= MINISTM32_OLED_WIDTH) { x2 = MINISTM32_OLED_WIDTH - 1; } if (rt_hw_interrupt_check()) { ret = rt_sem_take(&oled_lock, RT_WAITING_NO); } else { ret = rt_sem_take(&oled_lock, RT_WAITING_FOREVER); } if (ret != RT_EOK) { return; } // Set column address data[0] = 0x21; data[1] = x1; data[2] = x2; oled_writeLongCmd(data, 3); // Set page address data[0] = 0x22; data[1] = y / 8; data[2] = y / 8; oled_writeLongCmd(data, 3); oled_readData(color, x2 - x1 + 1); for (i = 0; i < x2 - x1; i++) { color[i] &= ~(1 << (y % 8)); } if (*(rt_uint8_t *)c) { for (i = 0; i < x2 - x1; i++) { color[i] |= 1 << (y % 8); } } oled_writeData(color, x2 - x1 + 1); rt_sem_release(&oled_lock); }
/** * This function will release the previously allocated memory block by * rt_malloc. The released memory block is taken back to system heap. * * @param rmem the address of memory which will be released */ void rt_free(void *rmem) { struct heap_mem *mem; RT_DEBUG_NOT_IN_INTERRUPT; if (rmem == RT_NULL) return; RT_ASSERT((((rt_uint32_t)rmem) & (RT_ALIGN_SIZE-1)) == 0); RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr && (rt_uint8_t *)rmem < (rt_uint8_t *)heap_end); RT_OBJECT_HOOK_CALL(rt_free_hook, (rmem)); if ((rt_uint8_t *)rmem < (rt_uint8_t *)heap_ptr || (rt_uint8_t *)rmem >= (rt_uint8_t *)heap_end) { RT_DEBUG_LOG(RT_DEBUG_MEM, ("illegal memory\n")); return; } /* Get the corresponding struct heap_mem ... */ mem = (struct heap_mem *)((rt_uint8_t *)rmem - SIZEOF_STRUCT_MEM); RT_DEBUG_LOG(RT_DEBUG_MEM, ("release memory 0x%x, size: %d\n", (rt_uint32_t)rmem, (rt_uint32_t)(mem->next - ((rt_uint8_t *)mem - heap_ptr)))); /* protect the heap from concurrent access */ rt_sem_take(&heap_sem, RT_WAITING_FOREVER); /* ... which has to be in a used state ... */ RT_ASSERT(mem->used); RT_ASSERT(mem->magic == HEAP_MAGIC); /* ... and is now unused. */ mem->used = 0; mem->magic = 0; if (mem < lfree) { /* the newly freed struct is now the lowest */ lfree = mem; } #ifdef RT_MEM_STATS used_mem -= (mem->next - ((rt_uint8_t*)mem - heap_ptr)); #endif /* finally, see if prev or next are free also */ plug_holes(mem); rt_sem_release(&heap_sem); }
/* transmit packet. */ rt_err_t lpc17xx_emac_tx( rt_device_t dev, struct pbuf* p) { rt_uint32_t Index, IndexNext; struct pbuf *q; rt_uint8_t *ptr; /* calculate next index */ IndexNext = LPC_EMAC->TxProduceIndex + 1; if(IndexNext > LPC_EMAC->TxDescriptorNumber) IndexNext = 0; /* check whether block is full */ while (IndexNext == LPC_EMAC->TxConsumeIndex) { rt_err_t result; rt_uint32_t recved; /* there is no block yet, wait a flag */ result = rt_event_recv(&tx_event, 0x01, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved); RT_ASSERT(result == RT_EOK); } /* lock EMAC device */ rt_sem_take(&sem_lock, RT_WAITING_FOREVER); /* get produce index */ Index = LPC_EMAC->TxProduceIndex; /* calculate next index */ IndexNext = LPC_EMAC->TxProduceIndex + 1; if(IndexNext > LPC_EMAC->TxDescriptorNumber) IndexNext = 0; /* copy data to tx buffer */ q = p; ptr = (rt_uint8_t*)TX_BUF(Index); while (q) { memcpy(ptr, q->payload, q->len); ptr += q->len; q = q->next; } TX_DESC_CTRL(Index) &= ~0x7ff; TX_DESC_CTRL(Index) |= (p->tot_len - 1) & 0x7ff; /* change index to the next */ LPC_EMAC->TxProduceIndex = IndexNext; /* unlock EMAC device */ rt_sem_release(&sem_lock); return RT_EOK; }
/// Release a Semaphore osStatus osSemaphoreRelease(osSemaphoreId semaphore_id) { rt_err_t result; result = rt_sem_release(semaphore_id); if (result == RT_EOK) return osOK; else return osErrorOS; }
/********************************************************************************* *函数名称:void gps_fact_set( void ) *功能描述:格式化GPS定位数据存储区域 *输 入:none *输 出:none *返 回 值:none *作 者:白养民 *创建日期:2013-12-01 *--------------------------------------------------------------------------------- *修 改 人: *修改日期: *修改描述: *********************************************************************************/ void gps_fact_set(void) { u32 TempAddress; rt_sem_take( &sem_dataflash, RT_TICK_PER_SECOND * FLASH_SEM_DELAY ); for( TempAddress = ADDR_DF_POSTREPORT_START; TempAddress < ADDR_DF_POSTREPORT_END; ) { sst25_erase_4k( TempAddress ); TempAddress += 4096; } rt_sem_release( &sem_dataflash ); }
void put_forks(int i) { /* 进入临界区*/ rt_sem_take(&sem_lock, RT_WAITING_FOREVER); phd_state[i] = THINKING; test(LEFT_PHD(i)); test(RIGHT_PHD(i)); /* 退出临界区*/ rt_sem_release(&sem_lock); }
static rt_size_t telnet_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size) { rt_size_t result; /* read from rx ring buffer */ rt_sem_take(telnet->rx_ringbuffer_lock, RT_WAITING_FOREVER); result = rb_get(&(telnet->rx_ringbuffer), buffer, size); rt_sem_release(telnet->rx_ringbuffer_lock); return result; }
/** * @brief status handler */ void StateHandler(void) { // gStatusFlag = TRUE; // 保证信号量最多就为1,是一个二值信号量 if (sSemSystemTime.value == 0) { rt_sem_release(&sSemSystemTime); } }
/* * This function will release the previously allocated memory page * by rt_malloc_page. * * @param page_ptr the page address to be released. * @param npages the number of page shall be released. * * @note this function is used for RT-Thread Application Module */ void rt_free_page(void *page_ptr, rt_size_t npages) { rt_page_free(page_ptr, npages); /* update memory usage */ #ifdef RT_MEM_STATS rt_sem_take(&heap_sem, RT_WAITING_FOREVER); used_mem -= npages * RT_MM_PAGE_SIZE; rt_sem_release(&heap_sem); #endif }
void test(int i) { if (phd_state[i] == HUNGRY && phd_state[LEFT_PHD(i)] != EATING && phd_state[RIGHT_PHD(i)] != EATING) { phd_state[i] = EATING; /* 可以得到叉子,故发布信号量 */ rt_sem_release(&sem[i]); } }