C++ rt_sem_init函数代码示例

int init_module(void)
{
	rt_sem_init(&notEmpty, 0);
	rt_sem_init(&notFull, 1);
	Clockstatus = stopped;
	return 0;
}

int init_cmdclk(void)
{
	notEmpty = rt_sem_init(nam2num("NOTECL"), 0);
	notFull = rt_sem_init(nam2num("NOTFCL"), 1);
	Clockstatus = stopped;
	return 0;
}

int demo_init(void)
{
    int i;
    rt_thread_t tid;
    rt_err_t result;

    /* 初始化信号量 */
    result = rt_sem_init(&sem_lock , "lock", 1, RT_IPC_FLAG_FIFO);
    if (result != RT_EOK)
        goto _error;
    for (i=0; i<5; i++)
    {
        result = rt_sem_init(&sem[i] , "sem", 0, RT_IPC_FLAG_FIFO);
        if (result != RT_EOK)
            goto _error;
    }


    for (i=0; i<5; i++)
    {
        tid = rt_thread_create(
                       "phd",
                       phd_thread_entry,
                       (void *)i,
                       THREAD_STACK_SIZE, 10, RT_TICK_PER_SECOND*3);
        if(tid != RT_NULL)
            rt_thread_startup(tid);
    }

    return 0;
_error:
    rt_kprintf("init semaphore failed.\n");
    return -1;
}

int init_cmdcrn(void)
{
	notEmpty = rt_sem_init(nam2num("NOTECR"), 0);
	notFull = rt_sem_init(nam2num("NOTFCR"), 1);
	Chronostatus = stoppedInitial;
	buffered = FALSE;
	fiveSeconds = nano2count(FIVE_SECONDS);
	return 0;
}

int init_module(void)
{
	rt_sem_init(&notEmpty, 0);
	rt_sem_init(&notFull, 1);
	Chronostatus = stoppedInitial;
	buffered = FALSE;
	fiveSeconds = nano2count(FIVE_SECONDS);
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Init all ipc objects.
static void ipcs_init(void)
{
	unsigned short dummy,max_interval;
	getFrameSplit(&max_interval,&dummy);
    rt_mutex_init(&setup_data_buf_mutex,"musb",RT_IPC_FLAG_FIFO);
    rt_sem_init(&rx_sem,"semrx",0,RT_IPC_FLAG_FIFO);
    rt_sem_init(&tx1_sem,"semtx0",1,RT_IPC_FLAG_FIFO);
    rt_sem_init(&tx2_sem,"semtx1",1,RT_IPC_FLAG_FIFO);
    rt_timer_init(&max_interval_timer,"rx_tmr",rx_interval_timeout,
        RT_NULL,max_interval/1000*RT_TICK_PER_SECOND,RT_TIMER_FLAG_ONE_SHOT);
}

/*
 * initialization task
 */
static void start_task_code(int notused)
{
	int i;
	char buf[9];
	buf[8] = 0;
  /* create the sync semaphore */
	rt_sem_init(&sync_sem, 0);
  /* create the priority-test semaphore */
	rt_sem_init(&prio_sem, 0);
  /* pass the semaphore to the first task */
	rt_sem_signal(&sems[0]);
  /* wait for each task to send the sync semaphore */
	for (i = 0; i < NUM_TASKS; ++i) {
		rt_sem_wait(&sync_sem);
	}
	rt_printk(sync_str);
  /* post the priority-test semaphore -- the tasks should then run */
  /* in priority order */
	for (i = 0; i < NUM_TASKS; ++i) {
		rt_sem_signal(&prio_sem);
	}
	rt_printk("\n");
	for (i = 0; i < NUM_TASKS; ++i) {
		rt_sem_wait(&sync_sem);
	}
	rt_printk(sync_str);

  /* now, test message queues */
	TAKE_PRINT; 
	rt_printk("testing message queues\n");
	GIVE_PRINT;
	for (i = 0; i < NUM_TASKS; ++i) {
		if (rt_mbx_send(&mbx_in, strs[i], 8)) {
			rt_printk("rt_mbx_send() failed\n");
		}
	}
	for (i = 0; i < NUM_TASKS; ++i) {
		rt_mbx_receive(&mbx_out, buf, 8);
		TAKE_PRINT; 
		rt_printk("\nreceived from mbx_out: %s", buf); 
		GIVE_PRINT;
	}
	rt_printk("\n");
	for (i = 0; i < NUM_TASKS; ++i) {
		rt_sem_signal(&sync_sem);
	}
	TAKE_PRINT; 
	rt_printk("\ninit task complete\n"); 
	GIVE_PRINT;

  /* nothing more for this task to do */
}

int rt_application_init()
{
	rt_thread_t thread_h;
	rt_err_t result;

	/* init system data cfg table */
	init_syscfgdata_tbl();

	rt_sem_init(&print_sem, "prtsem", 1, RT_IPC_FLAG_PRIO);
#if RT_USING_FILESYSTEM
	rt_sem_init(&spiflash_sem, "sfsem", 1, RT_IPC_FLAG_PRIO);
#endif
#if (ADE7880_SPIFLASH_SHARE_SPI || ADE7880_SI4432_SHARE_SPI)
	rt_sem_init(&spi_sem_share_by_ade7880, "spi3sem", 1, RT_IPC_FLAG_PRIO);
#endif

#if RT_USING_ADE7880 || RT_USING_SI4432_MAC
	rt_event_init(& isr_event_set, "isr_eve", RT_IPC_FLAG_PRIO);
#endif

#if (RT_USING_RS485_BUS && !TEST_485)
	init_sys_485();
#endif

	RT_APPS_INIT_DEBUG(("func:%s(), will init rt_sys_misc_entry\n", __FUNCTION__));
	/* init led thread */
	result = rt_thread_init(&misc_thread, "misc", rt_sys_misc_entry,
			RT_NULL, (rt_uint8_t*)&misc_stack[0], sizeof(misc_stack), 0x19, 5);
	if (result == RT_EOK)
		rt_thread_startup(&misc_thread);

#if RT_USING_ADE7880 || RT_USING_SI4432_MAC
	thread_h = rt_thread_create("isr_e", rt_isr_event_entry, RT_NULL, 512, ISR_EVENT_THREAD_PRIORITY, 10);
	if (thread_h != RT_NULL)
		rt_thread_startup(thread_h);
#endif

#if (RT_THREAD_PRIORITY_MAX == 32)
	thread_h = rt_thread_create("init", rt_init_thread_entry, RT_NULL, 2048, 8, 20);
#else
	thread_h = rt_thread_create("init", rt_init_thread_entry, RT_NULL, 2048, 80, 20);
#endif
	if (thread_h != RT_NULL)
		rt_thread_startup(thread_h);

	RT_APPS_INIT_DEBUG(("func:%s(), base thread initial over\n", __FUNCTION__));

	return 0;
}

int rt_application_init()
{
    int i;
    rt_thread_t tid;
    rt_thread_t init_thread;
    rt_err_t result;

    /* 初始化信号量 */
    result = rt_sem_init(&sem_lock , "lock", 1, RT_IPC_FLAG_FIFO);
    if (result != RT_EOK)
        goto _error;
    for (i=0; i<5; i++)
    {
        result = rt_sem_init(&sem[i] , "sem", 0, RT_IPC_FLAG_FIFO);
        if (result != RT_EOK)
            goto _error;
    }

#if (RT_THREAD_PRIORITY_MAX == 32)
    init_thread = rt_thread_create("init",
                                   rt_init_thread_entry, RT_NULL,
                                   2048, 8, 20);
#else
    init_thread = rt_thread_create("init",
                                   rt_init_thread_entry, RT_NULL,
                                   2048, 80, 20);
#endif

    if (init_thread != RT_NULL)
        rt_thread_startup(init_thread);

    for (i=0; i<5; i++)
    {
        tid = rt_thread_create(
                       "phd",
                       phd_thread_entry,
                       (void *)i,
                       THREAD_STACK_SIZE, 10, RT_TICK_PER_SECOND*3);
        if(tid != RT_NULL)
            rt_thread_startup(tid);
    }

    return 0;
_error:
    rt_kprintf("init semaphore failed.\n");
    return -1;

}

int lpc_emac_hw_init(void)
{
    rt_event_init(&tx_event, "tx_event", RT_IPC_FLAG_FIFO);
    rt_sem_init(&sem_lock, "eth_lock", 1, RT_IPC_FLAG_FIFO);

    /* set autonegotiation mode */
    lpc_emac_device.phy_mode = EMAC_PHY_AUTO;

    // OUI 00-60-37 NXP Semiconductors
    lpc_emac_device.dev_addr[0] = 0x00;
    lpc_emac_device.dev_addr[1] = 0x60;
    lpc_emac_device.dev_addr[2] = 0x37;
    /* set mac address: (only for test) */
    lpc_emac_device.dev_addr[3] = 0x12;
    lpc_emac_device.dev_addr[4] = 0x34;
    lpc_emac_device.dev_addr[5] = 0x56;

    lpc_emac_device.parent.parent.init      = lpc_emac_init;
    lpc_emac_device.parent.parent.open      = lpc_emac_open;
    lpc_emac_device.parent.parent.close     = lpc_emac_close;
    lpc_emac_device.parent.parent.read      = lpc_emac_read;
    lpc_emac_device.parent.parent.write     = lpc_emac_write;
    lpc_emac_device.parent.parent.control   = lpc_emac_control;
    lpc_emac_device.parent.parent.user_data = RT_NULL;

    lpc_emac_device.parent.eth_rx           = lpc_emac_rx;
    lpc_emac_device.parent.eth_tx           = lpc_emac_tx;

    eth_device_init(&(lpc_emac_device.parent), "e0");
    return 0;
}

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
{
    rt_err_t result;
    char cond_name[RT_NAME_MAX];
    static rt_uint16_t cond_num = 0;

    /* parameter check */
    if (cond == RT_NULL)
        return EINVAL;
    if ((attr != RT_NULL) && (*attr != PTHREAD_PROCESS_PRIVATE))
        return EINVAL;

    rt_snprintf(cond_name, sizeof(cond_name), "cond%02d", cond_num++);

	if (attr == RT_NULL) /* use default value */
		cond->attr = PTHREAD_PROCESS_PRIVATE;
	else 
	    cond->attr = *attr;

    result = rt_sem_init(&cond->sem, cond_name, 0, RT_IPC_FLAG_FIFO);
    if (result != RT_EOK)
        return EINVAL;

    /* detach the object from system object container */
    rt_object_detach(&(cond->sem.parent.parent));

    return 0;
}

int main(void)
{
  RT_TASK *task;
  RTIME now;
  int cnt=0;

  // make main thread LXRT soft realtime
  task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF);
  mlockall(MCL_CURRENT | MCL_FUTURE);

  // start realtime timer and scheduler
  //rt_set_oneshot_mode();
  rt_set_periodic_mode();
  start_rt_timer(0);

  now = rt_get_time() + 10*PERIOD;
  rt_task_make_periodic(task, now, PERIOD);

  printf("Init mutex and cond.\n");
  mutex = rt_sem_init(nam2num("MUTEX"), 1);

  if (mutex==0)
    printf("Error init mutex\n");

  cond = rt_cond_init(nam2num("CONDITION"));

  if (cond==0)
    printf("Error init cond\n");

  thread0 = rt_thread_create(fun0, NULL, 10000);
  //thread1 = rt_thread_create(fun1, NULL, 20000);

  //rt_sleep(PERIOD);

  while (cnt < THRESHOLD) {
    rt_task_wait_period();
    rt_printk("main: Hello World %d!\n",cnt);
    rt_sem_wait(mutex); //now the mutex should have value 0

    if (instance_cnt==0) {
      rt_sem_signal(mutex); //now the mutex should have vaule 1
      rt_printk("worker thread busy!\n");
    } else {
      instance_cnt++;
      rt_cond_signal(cond);
      rt_sem_signal(mutex); //now the mutex should have vaule 1
      rt_printk("signaling worker thread to start!\n");
    }

    cnt++;
  }

  // wait for end of program
  printf("TYPE <ENTER> TO TERMINATE\n");
  getchar();

  // cleanup
  stop_rt_timer();
  return 0;
}

void pcap_netif_hw_init(void)
{
	rt_sem_init(&sem_lock, "eth_lock", 1, RT_IPC_FLAG_FIFO);

	pcap_netif_device.dev_addr[0] = 0x00;
	pcap_netif_device.dev_addr[1] = 0x60;
	pcap_netif_device.dev_addr[2] = 0x37;
	/* set mac address: (only for test) */
	pcap_netif_device.dev_addr[3] = 0x12;
	pcap_netif_device.dev_addr[4] = 0x34;
	pcap_netif_device.dev_addr[5] = 0x56;

	pcap_netif_device.parent.parent.init		= pcap_netif_init;
	pcap_netif_device.parent.parent.open		= pcap_netif_open;
	pcap_netif_device.parent.parent.close		= pcap_netif_close;
	pcap_netif_device.parent.parent.read		= pcap_netif_read;
	pcap_netif_device.parent.parent.write		= pcap_netif_write;
	pcap_netif_device.parent.parent.control	    = pcap_netif_control;
	pcap_netif_device.parent.parent.user_data	= RT_NULL;

	pcap_netif_device.parent.eth_rx			= pcap_netif_rx;
	pcap_netif_device.parent.eth_tx			= pcap_netif_tx;

	eth_device_init(&(pcap_netif_device.parent), "e0");
}

    int rtos_sem_init(rt_sem_t* m, int value )
    {
        CHK_LXRT_CALL();
		// store the pointer in m->opaque...
        m->sem = rt_sem_init( rt_get_name(0) , value);
        return m->sem == 0 ? -1 : 0;
    }

void finsh_lua(struct para *parameters)
{
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);

    rt_sem_init(&(dev4lua.sem), "luasem", 0, 0);

    /* save old rx_indicate */
    rx_indicate = dev4lua.device->rx_indicate;

    /* set new rx_indicate */
    rt_device_set_rx_indicate(dev4lua.device, lua_rx_ind);

    {
	    int argc = parameters->argc;
	    char **argv = parameters->argv;
	    /*
	    rt_kprintf("argc =%d, argv[1] =%d\n", argc, argv[1]);
	    while(1);
	    */
	    /* run lua interpreter */
	    lua_main(argc, argv);
    }
    if (parameters->argc > 1)
	    rt_free(parameters->argv[1]);
    rt_free(parameters);

    /* recover old rx_indicate */
    rt_device_set_rx_indicate(dev4lua.device, rx_indicate);
}