C++ create_timer函数代码示例

/*!	Creates the pre-defined user timers for the given team.

	\param team The team whose pre-defined timers shall be created.
	\return \c B_OK, when everything when fine, another error code otherwise.
*/
status_t
user_timer_create_team_timers(Team* team)
{
	// create a real time user timer
	struct sigevent event;
	event.sigev_notify = SIGEV_SIGNAL;
	event.sigev_signo = SIGALRM;

	int32 timerID = create_timer(CLOCK_MONOTONIC, USER_TIMER_REAL_TIME_ID,
		team, NULL, 0, event, NULL, true);
	if (timerID < 0)
		return timerID;

	// create a total CPU time user timer
	event.sigev_notify = SIGEV_SIGNAL;
	event.sigev_signo = SIGPROF;

	timerID = create_timer(CLOCK_PROCESS_CPUTIME_ID,
		USER_TIMER_TEAM_TOTAL_TIME_ID, team, NULL, 0, event, NULL, true);
	if (timerID < 0)
		return timerID;

	// create a user CPU time user timer
	event.sigev_notify = SIGEV_SIGNAL;
	event.sigev_signo = SIGVTALRM;

	timerID = create_timer(CLOCK_PROCESS_USER_CPUTIME_ID,
		USER_TIMER_TEAM_USER_TIME_ID, team, NULL, 0, event, NULL, true);
	if (timerID < 0)
		return timerID;

	return B_OK;
}

static void
reschedule (struct serial *scb)
{
  if (serial_is_async_p (scb))
    {
      int next_state;

      switch (scb->async_state)
	{
	case FD_SCHEDULED:
	  if (scb->bufcnt == 0)
	    next_state = FD_SCHEDULED;
	  else
	    {
	      delete_file_handler (scb->fd);
	      next_state = create_timer (0, push_event, scb);
	    }
	  break;
	case NOTHING_SCHEDULED:
	  if (scb->bufcnt == 0)
	    {
	      add_file_handler (scb->fd, fd_event, scb);
	      next_state = FD_SCHEDULED;
	    }
	  else
	    {
	      next_state = create_timer (0, push_event, scb);
	    }
	  break;
	default: /* TIMER SCHEDULED */
	  if (scb->bufcnt == 0)
	    {
	      delete_timer (scb->async_state);
	      add_file_handler (scb->fd, fd_event, scb);
	      next_state = FD_SCHEDULED;
	    }
	  else
	    next_state = scb->async_state;
	  break;
	}
      if (serial_debug_p (scb))
	{
	  switch (next_state)
	    {
	    case FD_SCHEDULED:
	      if (scb->async_state != FD_SCHEDULED)
		fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
				    scb->fd);
	      break;
	    default: /* TIMER SCHEDULED */
	      if (scb->async_state == FD_SCHEDULED)
		fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
				    scb->fd);
	      break;
	    }
	}
      scb->async_state = next_state;
    }
}

NPC* construct_NPC( int _xInMatrix, int _yInMatrix )
{
    NPC* p_temp_npc = (NPC*)malloc( sizeof( NPC ) );

    // load all 12 frames of the pacmen
    p_temp_npc->NPC_up_frames    = (void**)malloc( GC_NPC_frames * sizeof( void* ) );

    p_temp_npc->NPC_right_frames = (void**)malloc( GC_NPC_frames * sizeof( void* ) );

    p_temp_npc->NPC_down_frames  = (void**)malloc( GC_NPC_frames * sizeof( void* ) );

    p_temp_npc->NPC_left_frames  = (void**)malloc( GC_NPC_frames * sizeof( void* ) );

    int i;
    for ( i = 0; i < GC_NPC_frames; i++ )
        p_temp_npc->NPC_up_frames[i] = load_image( GC_pac_man_up_frames[i], GC_block_size, GC_block_size );

    for ( i = 0; i < GC_NPC_frames; i++ )
        p_temp_npc->NPC_right_frames[i] = load_image( GC_pac_man_right_frames[i], GC_block_size, GC_block_size );

    for ( i = 0; i < GC_NPC_frames; i++ )
        p_temp_npc->NPC_down_frames[i] = load_image( GC_pac_man_down_frames[i], GC_block_size, GC_block_size );

    for ( i = 0; i < GC_NPC_frames; i++ )
        p_temp_npc->NPC_left_frames[i] = load_image( GC_pac_man_left_frames[i], GC_block_size, GC_block_size );

    // set the first frame to be active
    p_temp_npc->up_frame_index    = 0;
    p_temp_npc->right_frame_index = 0;
    p_temp_npc->down_frame_index  = 0;
    p_temp_npc->left_frame_index  = 0;

    p_temp_npc->left = _xInMatrix * GC_block_size;

    p_temp_npc->top = _yInMatrix * GC_block_size + GC_y_offset;

    p_temp_npc->direction = rand() % 4;

    p_temp_npc->alive = 1;

    // initalize NPC artificial inteligence
    // p_temp_npc->p_NPC_AI = NPC_random_walk_AI;

    p_temp_npc->walk_timer  = create_timer( GC_NPC_walk_duration );

    p_temp_npc->AI_timer    = create_timer( GC_NPC_AI_delay );

    p_temp_npc->frame_timer = create_timer( GC_NPC_frames_duration );

    return p_temp_npc;
}

void setup() {
        setup_screen();
        player = create_sprite(screen_width()/2, screen_height() - 5, 1, 1, "S");
        player->dy = 0;
        player->dx = 0;
 
        bullet = create_sprite(-1, -1, 1, 1, "*");
        bullet->dy = 0;
        bullet->dx = 0;
 
for (int i = 0; i < 3; i++) {
                alien[i] = create_sprite(4+4*i, 0, 1, 1, "@");
        }
for (int j = 0; j < 4; j++) {
                alien[j+3] = create_sprite(2+4*j, 3, 1, 1, "@");
        }
for (int k = 0; k < 3; k++) {
                alien[k+7] = create_sprite(4+4*k, 6, 1, 1, "@");
        }      
for (int r = 0; r < 10; r++) {
        alien[r]->dx = 0.1;
        alien[r]->dy = 0;
}
 
 
        tim = create_timer(25);
}

void start_scan_sambaserver(int use_sys_timer)
{
	//- Remove all
	smb_srv_info_t *c;
	for (c = smb_srv_info_list; c; c = c->next) {
		Cdbg(DBE, "remove , ip=[%s]\n", c->ip->ptr);
		DLIST_REMOVE(smb_srv_info_list,c);
		free(c);
		c = smb_srv_info_list;
	}
	free(smb_srv_info_list);
	
	init_a_srvInfo();

	g_useSystemTimer = use_sys_timer;
	g_bInitialize = 1;
	
#ifdef _USEMYTIMER
	if(g_useSystemTimer==0){
		Cdbg(DBE, "create timer\n");
		timer_t arp_timer = create_timer(TT_SIGUSR2);
    	install_sighandler(TT_SIGUSR2, on_arpping_timer_handler);
    	set_timer(arp_timer, ARP_TIME_INTERVAL);
	}
#endif
}

void
init_video (void)
{
  if (! al_init_image_addon ())
    error (-1, 0, "%s (void): failed to initialize image addon",
            __func__);

  al_set_new_display_flags (al_get_new_display_flags ()
                            | (display_mode < 0 ? ALLEGRO_WINDOWED : ALLEGRO_FULLSCREEN)
                            | ALLEGRO_RESIZABLE
                            | ALLEGRO_GENERATE_EXPOSE_EVENTS);

  display_width = display_width ? display_width : DISPLAY_WIDTH;
  display_height = display_height ? display_height : DISPLAY_HEIGHT;

  if (display_mode >= 0) {
    ALLEGRO_DISPLAY_MODE d;
    get_display_mode (display_mode, &d);
    display_width = d.width;
    display_height = d.height;
    al_set_new_display_refresh_rate (d.refresh_rate);
    al_set_new_display_flags (al_get_new_display_flags ()
                              & ~ALLEGRO_FULLSCREEN_WINDOW);
  }

  al_set_new_display_option (ALLEGRO_SINGLE_BUFFER, 1, ALLEGRO_SUGGEST);

  display = al_create_display (display_width, display_height);
  if (! display) error (-1, 0, "%s (void): failed to initialize display", __func__);

  set_target_backbuffer (display);
  al_set_new_bitmap_flags (ALLEGRO_VIDEO_BITMAP);

  al_set_window_title (display, WINDOW_TITLE);
  icon = load_bitmap (ICON);
  al_set_display_icon (display, icon);

  cutscene = true;
  if (mr.fit_w == 0 && mr.fit_h == 0) {
    mr.fit_w = 2;
    mr.fit_h = 2;
  }
  set_multi_room (1, 1);
  effect_buffer = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
  black_screen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
  uscreen = create_bitmap (CUTSCENE_WIDTH, CUTSCENE_HEIGHT);
  iscreen = create_bitmap (display_width, display_height);
  clear_bitmap (uscreen, TRANSPARENT_COLOR);

  video_timer = create_timer (1.0 / EFFECT_HZ);

  al_init_font_addon ();
  builtin_font = al_create_builtin_font ();
  if (! builtin_font)
    error (-1, 0, "%s (void): cannot create builtin font", __func__);

  if (! al_init_primitives_addon ())
    error (-1, 0, "%s (void): failed to initialize primitives addon",
           __func__);
}

struct callout_handle
timeout(timer_function func, void *cookie, bigtime_t timeout)
{
	struct callout_handle handle;
	handle.timer = create_timer(func, cookie, timeout, B_ONE_SHOT_RELATIVE_TIMER);
	return handle;
}

int main(int argc, char const *argv[])
{
    char err[SOCKET_ERR_LEN];

    pool = buffer_pool_create(100);
    prev_recv = prev_send = 0;
    recv_total = send_total = 0;

    int sfd = tcp_server_serve(err, "localhost", 3456, SOMAXCONN);
    if (sfd < 0) {
        printf("%d %s\n", sfd, err);
        return 0;
    }

    if (set_nonblock(err, sfd) != 0) {
        printf("%s\n", err);
        return 0;
    }

    if (set_tcp_nodelay(err, sfd, 1) != 0) {
        printf("%s\n", err);
        return 0;
    }

    event_loop_t *loop = event_loop_create(100, 10);
    assert(loop != NULL);

    create_timer(loop, 1000, print_info, NULL);
    create_event(loop, sfd, EV_RDABLE, server_accept_cb, NULL);

    event_loop_start(loop);
}

void app_pic_play_timer_reset(void)
{
	if (reset_timer(sp_PicPlayTimer) != 0)
	{
		sp_PicPlayTimer = create_timer(picasa_pic_play_timeout, 5000, NULL, TIMER_ONCE);
	}
}

int main(int argc, char**argv){
	char * evar = getenv("RELY_SRAND_DATA");
	if(evar != NULL) srand(atoi(evar));
	else srand(0);
	
	if(argc <= 3){
		printf("USAGE: scale FACTOR INPUT OUTPUT\n");
		return 1;
	}
	inst_timer GLOBAL_TIMER = create_timer();
	start_timer(&GLOBAL_TIMER);
	double scale_factor = atof(argv[1]);
	char* in_filename = argv[2];
	char * out_filename = argv[3];
	printf("scale by %f: %s -> %s\n", scale_factor, in_filename, out_filename);

    int* src, * transformed;

	size_t sw, sh, dw, dh;
	printf("read from \"%s\" ...\n", in_filename);
	src = read_image(in_filename, &sw, &sh);
	if(src == NULL){
		fprintf(stderr, ">> Failed to read image %s\n", in_filename);
		exit(1);
	}
	transformed = allocate_transform_image(scale_factor, sw, sh, &dw, &dh);
	scale(scale_factor, src, sw, sh, transformed, dw, dh);
	printf("write to \"%s\" ...\n", out_filename);
	write_image(out_filename, transformed, dw, dh);
	free((void *) src);
	free((void *) transformed);
	end_timer(&GLOBAL_TIMER);
	printf("GLOBAL TIME\n");
	print_timer(&GLOBAL_TIMER);
}

void app_tr_cas_osd_roll_timer_check(void)
{
	if (FALSE == s_bOsdRollEnable)
	{
		return;	
	}
	
	GxCore_SemWait(s_semNotifyRoll);
	
	if (s_rollingInfo.period > 0)
	{
		printf("[app_tr_cas_osd_roll_timer_check]Create Roll(%ds) Timer>>>+++.\n",\
			  		s_rollingInfo.period);

		if (s_rollingInfo.timer_handle)
		{
			remove_timer(s_rollingInfo.timer_handle);
			s_rollingInfo.timer_handle = NULL;
		}
		
		s_rollingInfo.timer_handle = create_timer(tr_cas_timer_roll,\
			   									  s_rollingInfo.period*1000,\
			   			   						  NULL, TIMER_ONCE);
	}
	
	GxCore_SemPost(s_semNotifyRoll);
	return;
}

/**
 * \callgraph
 *\brief 	Initialize the blocks of flash memory used for reading/writing.
 *\details	Uses Nordic's pstorage software abstraction/API to cleanly access flash when the SoftDevice (for BLE)
 *		is also running.
 */
void ladybug_flash_init() {
  SEGGER_RTT_WriteString(0,"==> IN ladybug_flash_init\n");
  pstorage_module_param_t pstorage_param;   //Used when registering with pstorage
  pstorage_handle_t	  handle;	    //used to access the chunk-o-flash requested when registering
  //First thing is to initialize pstorage
  uint32_t err_code = pstorage_init();
  //if initialization was not successful, the error routine will be called and the code won't proceed.
  APP_ERROR_CHECK(err_code);
  //Next is to register amount of flash needed.  The smallest amount that can be requested is 16 bytes.  I'm requesting
  //32 bytes because this is the number of bytes needed for plant_info. Two blocks are used...one for plant info and one for hydro values.  I must make a
  //block request for the larger amount of bytes
  pstorage_param.block_size = BLOCK_SIZE;
  //request three blocks - one will be for pH, one for plant_info, and one for device name
  pstorage_param.block_count = 3;
  //assign a callback so know when a command has finished.
  pstorage_param.cb = ladybug_flash_handler;
  err_code = pstorage_register(&pstorage_param, &handle);
  APP_ERROR_CHECK(err_code);
  //Then get the handles to the blocks of flash
  pstorage_block_identifier_get(&handle, 0, &m_block_calibration_store_handle);
  pstorage_block_identifier_get(&handle,1,&m_block_plantInfo_store_handle);
  pstorage_block_identifier_get(&handle,2,&m_block_device_name_store_handle);
  // Create the timer.  This will be called before a Flash activity is requested to avoid forever hanging.
  create_timer();

}

/*
 * Program timer to remove referral cache entry after TTL
 * If the timer was already programed, it reprogram it with the new time to expiry
 */
void program_referral_expiry_timer(lispd_referral_cache_entry *referral_entry)
{
    if (referral_entry->expiry_ddt_cache_timer == NULL){
        referral_entry->expiry_ddt_cache_timer = create_timer(DDT_EXPIRE_MAP_REFERRAL);
    }
    start_timer(referral_entry->expiry_ddt_cache_timer, referral_entry->ttl*60, referral_expiry, (void *)referral_entry);
}

void setup_score(Game* game) {
	if (NULL != game) {
		game->score = 0;
		game->over = false;
		game->timer = create_timer(INTERVAL);
	}
}

void app_picasa_feeds_update_timer_reset(void)
{
	if (reset_timer(sp_PicasaFeedsUpdateTimer) != 0)
	{
		sp_PicasaFeedsUpdateTimer = create_timer(picasa_feeds_update_timer_timeout, 1000, NULL, TIMER_ONCE);
	}
}