C++ rt_sem_release函数代码示例

/* 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(&eth_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;
}