自学教程：C++ timer_elapsed函数代码示例

void fading_led_custom(uint8_t *value){    static uint8_t index = 0;    static uint16_t last = 0;    if (backlight_config.level == 7) {        if (idle_state == 0) {            uint8_t max = value[0];            for (uint8_t i = 1; i < LED_COUNT; i++) {                if (value[i] > max) max = value[i];            }            rgb_set_brightness(max);            if (max == 0) {                idle_last = timer_read();                idle_state = 1;            }        }        if (idle_state == 1) {            if (timer_elapsed(idle_last) > 3000) {                breathing_led_set_index_all(0);                index = 0;                idle_state = 2;            }        }        if (idle_state == 2) {            if (timer_elapsed(last) > 500) {                last = timer_read();                breathing_led_enable_once(index);                index = (index + 1) % 6;            }        }    }}

bool process_record_user(uint16_t keycode, keyrecord_t *record) {	uint8_t layer;  layer = biton32(layer_state);  // get the current layer  //custom layer handling for tri_layer,  switch (keycode) {  case FNKEY:  	if (record->event.pressed) {      key_timer = timer_read();      singular_key = true;    	layer_on(_FUNCTION);  	} else {      if (timer_elapsed(key_timer) < LAYER_TOGGLE_DELAY || !singular_key) {        layer_off(_FUNCTION);      }  	}    update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT);  	return false;  	break;  //SHIFT is handled as LSHIFT in the general case  case SHIFT:  	if (record->event.pressed) {      key_timer = timer_read();      singular_key = true;    	layer_on(_SHIFTED);    	register_code(KC_LSFT);  	} else {    	if (timer_elapsed(key_timer) < LAYER_TOGGLE_DELAY || !singular_key) {        layer_off(_SHIFTED);    	  unregister_code(KC_LSFT);      }    }    update_tri_layer(_FUNCTION, _SHIFTED, _FUNCSHIFT);  	return false;  	break;  //If any other key was pressed during the layer mod hold period,  //then the layer mod was used momentarily, and should block latching  default:    singular_key = false;    break;  }  //FUNCSHIFT has been shifted by the SHIFT handling, some keys need to be excluded  if (layer == _FUNCSHIFT) {  	//F1-F12 should be sent as unshifted keycodes,  	//and ] needs to be unshifted or it is sent as }  	if ( (keycode >= KC_F1 && keycode <= KC_F12)  	   || keycode == KC_RBRC ) {  		if (record->event.pressed) {              unregister_mods(MOD_LSFT);          } else {              register_mods(MOD_LSFT);          }  	}  }  return true;};

void mousekey_task(void){    if (timer_elapsed(last_timer) < (mousekey_repeat ? mk_interval : mk_delay*10))        return;    if (mouse_report.x == 0 && mouse_report.y == 0 && mouse_report.v == 0 && mouse_report.h == 0)        return;    if (mousekey_repeat != UINT8_MAX)        mousekey_repeat++;    if (mouse_report.x > 0) mouse_report.x = move_unit();    if (mouse_report.x < 0) mouse_report.x = move_unit() * -1;    if (mouse_report.y > 0) mouse_report.y = move_unit();    if (mouse_report.y < 0) mouse_report.y = move_unit() * -1;    /* diagonal move [1/sqrt(2) = 0.7] */    if (mouse_report.x && mouse_report.y) {        mouse_report.x *= 0.7;        mouse_report.y *= 0.7;    }    if (timer_elapsed(last_timer) < (mousekey_repeat ? mk_wheel_interval : mk_delay*10))        return;    if (mouse_report.v > 0) mouse_report.v = wheel_unit();    if (mouse_report.v < 0) mouse_report.v = wheel_unit() * -1;    if (mouse_report.h > 0) mouse_report.h = wheel_unit();    if (mouse_report.h < 0) mouse_report.h = wheel_unit() * -1;    mousekey_send();}

bool process_record_user(uint16_t keycode, keyrecord_t *record) {  static uint16_t code_timer;  switch (keycode) {  case KC_MCBR:                                      if(record->event.pressed){      code_timer= timer_read();      SEND_STRING("{");    } else {      if (timer_elapsed(code_timer) > TAPPING_TERM) {        SEND_STRING("}" SS_TAP(X_LEFT));      }     }    return false;    break;  case KC_MBRC:                                      if(record->event.pressed){      code_timer= timer_read();      SEND_STRING("[");    } else {      if (timer_elapsed(code_timer) > TAPPING_TERM) {        SEND_STRING("]" SS_TAP(X_LEFT));      }     }    return false;    break;  case KC_MPRN:                                      if(record->event.pressed){      code_timer= timer_read();      SEND_STRING("(");    } else {      if (timer_elapsed(code_timer) > TAPPING_TERM) {        SEND_STRING(")" SS_TAP(X_LEFT));      }     }    return false;    break;  case KC_MABK:                                      if(record->event.pressed){      code_timer= timer_read();      if (get_mods() & MODS_SHIFT_MASK){        SEND_STRING("<");      } else {        SEND_STRING(",");      }    } else {      if (timer_elapsed(code_timer) > TAPPING_TERM) {        if (get_mods()  & MODS_SHIFT_MASK){          SEND_STRING(">" SS_TAP(X_LEFT));        }      }     }    return false;    break;  }  return true;}

void locinfo_print_time(){    printf("locinfo total:/t/t/t%f/n"           "/tfind_add_str:/t/t/t%f/n"           "/tlocinfo_read:/t/t/t%f/n"           "/tlocinfo_write:/t/t/t%f/n"           ,timer_elapsed(locinfo_timer)           ,timer_elapsed(locinfo_parse_find_add_str_timer)           ,timer_elapsed(locinfo_read_timer)           ,timer_elapsed(locinfo_write_timer)        );}

static voidload_thread (void *seq_no_){  int seq_no = (int) seq_no_;  int sleep_time = TIMER_FREQ * (10 + seq_no);  int spin_time = sleep_time + TIMER_FREQ * THREAD_CNT;  int exit_time = TIMER_FREQ * (THREAD_CNT * 2);  timer_sleep (sleep_time - timer_elapsed (start_time));  while (timer_elapsed (start_time) < spin_time)    continue;  timer_sleep (exit_time - timer_elapsed (start_time));}

const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt){		static uint16_t start;  // MACRODOWN only works in this function      switch(id) {        case 0:		if (record->event.pressed) {		  register_code(KC_RSFT);		} else {		  unregister_code(KC_RSFT);		}		break;	case 1:		if (record->event.pressed) {			start = timer_read();			return MACRO(D(LCTRL), END);		} else {			if (timer_elapsed(start) > 150) {			    return MACRO(U(LCTRL), END);			} else {			    return MACRO(U(LCTRL), D(LGUI), T(V), U(LGUI), END);			}		}		break;	case 2:		if (record->event.pressed) {			start = timer_read();			return MACRO(D(LCTRL),END);		} else {			if (timer_elapsed(start) > 150){				return MACRO(U(LCTRL),END);			} else {				return MACRO(U(LCTRL),D(LGUI),T(C),U(LGUI),END);			}		}		break;	case 3:		if (record->event.pressed) {			start = timer_read();			return MACRO(D(LCTRL),D(LSFT),D(LALT),END);		} else {			if (timer_elapsed(start) > 150){				return MACRO(U(LCTRL),U(LSFT),U(LALT),END);			} else {				return MACRO(U(LCTRL),U(LALT),T(EQL),U(LSFT),END); //cannot use DE_ACUT here, as macro needs KC_ prefix			}		}		break;      }    return MACRO_NONE;};

int main(void){    byte* buffer;    byte* pivots;    size_t i;    comb_init();      buffer = malloc(NUM_COMBS_ITER * COMB_SIZE);    pivots = malloc(NUM_FILES * COMB_SIZE);    for (i = 0; i < NUM_ITERS; i++)    {        printf("/nIteration %d of %d./n/n", i + 1, NUM_ITERS);        printf("Filling combinations buffer...");        timer_reset();        fill_comb_buffer(buffer);        printf(" DONE in %fs./n", timer_elapsed());        printf("Sorting combinations buffer...");        timer_reset();        qsort(buffer, NUM_COMBS_ITER, COMB_SIZE, comb_sum_cmp);        printf(" DONE in %fs./n", timer_elapsed());        if (i == 0)        {            printf("Creating output files...");            create_output_files();            printf(" DONE./n");            printf("Getting and saving pivots...");            get_pivots(pivots, buffer);            save_pivots(pivots);            printf(" DONE./n");        }        printf("Saving sorted combinations buffer...");        timer_reset();        save_comb_buffer(buffer, pivots);        printf(" DONE in %fs./n", timer_elapsed());    }    free(buffer);    free(pivots);    comb_free();    return 0;}

const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt){  // MACRODOWN only works in this function    switch(id) {      	//switch multiplexing for media, short tap for volume up, long press for play/pause        case VOLU:            if (record->event.pressed) {            	key_timer = timer_read(); // if the key is being pressed, we start the timer.          	} else { // this means the key was just released, so we can figure out how long it was pressed for (tap or "held down").            	if (timer_elapsed(key_timer) > LONGPRESS_DELAY) { // LONGPRESS_DELAY being 150ms, the threshhold we pick for counting something as a tap.                  return MACRO(T(MPLY), END);                } else {                  return MACRO(T(VOLU), END);                }          	}          	break;		//switch multiplexing for media, short tap for volume down, long press for next track        case VOLD:            if (record->event.pressed) {            	key_timer = timer_read();          	} else {            	if (timer_elapsed(key_timer) > LONGPRESS_DELAY) {                  return MACRO(T(MNXT), END);                } else {                  return MACRO(T(VOLD), END);                }          	}          	break;        //switch multiplexing for escape, short tap for escape, long press for context menu        case ESCM:            if (record->event.pressed) {            	key_timer = timer_read();          	} else {            	if (timer_elapsed(key_timer) > LONGPRESS_DELAY) {                  return MACRO(T(APP), END);                } else {                  return MACRO(T(ESC), END);                }          	}          	break;        break;    }    return MACRO_NONE;};

int main( int argc, char** argv ){	tick_t start, time;	tick_t tick, freq, res;	printf( "Timer test/n" );	timer_lib_initialize();	res   = 0xFFFFFFFFFFFFFFFFULL;	freq  = timer_ticks_per_second();	start = timer_current();	while( 1 )	{		time = timer_current();		do {			tick = timer_elapsed_ticks( time );		} while( !tick );		if( tick < res )			res = tick;		if( timer_elapsed( start ) > 10.0 )			break;	}	printf( "Resolution: %lfms (%d ticks)/n", 1000.0 * (double)timer_ticks_to_seconds( res ), (int)res );	timer_lib_shutdown();	return 0;}

void matrix_scan_tap_dance () {  if (qk_tap_dance_state.keycode && timer_elapsed (qk_tap_dance_state.timer) > TAPPING_TERM) {    process_tap_dance_action (qk_tap_dance_state.keycode);    reset_tap_dance (&qk_tap_dance_state);  }}

voidtest_mlfqs_block (void) {  int64_t start_time;  struct lock lock;    ASSERT (thread_mlfqs);  msg ("Main thread acquiring lock.");  lock_init (&lock);  lock_acquire (&lock);    msg ("Main thread creating block thread, sleeping 25 seconds...");  thread_create ("block", PRI_DEFAULT, block_thread, &lock);  timer_sleep (25 * TIMER_FREQ);  msg ("Main thread spinning for 5 seconds...");  start_time = timer_ticks ();  while (timer_elapsed (start_time) < 5 * TIMER_FREQ)    continue;  msg ("Main thread releasing lock.");  lock_release (&lock);  msg ("Block thread should have already acquired lock.");}

bool process_leader(uint16_t keycode, keyrecord_t *record) {  // Leader key set-up  if (record->event.pressed) {#ifdef LEADER_PER_KEY_TIMING    leader_time = timer_read();#endif    if (!leading && keycode == KC_LEAD) {      leader_start();      leading = true;#ifndef LEADER_PER_KEY_TIMING      leader_time = timer_read();#endif      leader_time = timer_read();      leader_sequence_size = 0;      leader_sequence[0] = 0;      leader_sequence[1] = 0;      leader_sequence[2] = 0;      leader_sequence[3] = 0;      leader_sequence[4] = 0;      return false;    }    if (leading && timer_elapsed(leader_time) < LEADER_TIMEOUT) {      leader_sequence[leader_sequence_size] = keycode;      leader_sequence_size++;      return false;    }  }  return true;}

void scan_rgblight_fadeout(void) { // Don't effing change this function .... rgblight_sethsv is supppppper intensive    bool litup = false;    for (uint8_t light_index = 0 ; light_index < RGBLED_NUM ; ++light_index ) {        if (lights[light_index].enabled && timer_elapsed(lights[light_index].timer) > 10) {        rgblight_fadeout *light = &lights[light_index];        litup = true;        if (light->life) {            light->life -= 1;            if (biton32(layer_state) == 0) {                sethsv(light->hue + rand() % 0xF, 255, light->life, (LED_TYPE *)&led[light_index]);            }            light->timer = timer_read();        }        else {            if (light->enabled && biton32(layer_state) == 0) {                rgblight_sethsv_default_helper(light_index);            }            litup = light->enabled = false;        }        }    }    if (litup && biton32(layer_state) == 0) {        rgblight_set();    }}

/*! Sleeps for approximately TICKS timer ticks.  Interrupts must    be turned on. */void timer_sleep(int64_t ticks) {    int64_t start = timer_ticks();    ASSERT(intr_get_level() == INTR_ON);    while (timer_elapsed(start) < ticks)         thread_yield();}

/* Sleeps for approximately TICKS timer ticks.  Interrupts must   be turned on. */voidtimer_sleep (int64_t ticks) {  int64_t start = timer_ticks ();  ASSERT (intr_get_level () == INTR_ON);#if 0 /* pj1 */  while (timer_elapsed (start) < ticks)     thread_yield ();#endif#if 1 /* pj1 */  if (ticks <= 0)	  return;  /* add current thread to sleep thread list in order,    * and set its wake up time. Then schedule a new thread.   */  struct thread *cur = thread_current();  enum intr_level old_level;  lock_acquire(&sleep_list_lock);  old_level = intr_disable();  cur->wake_up_ticks = start + ticks;   list_insert_ordered(&sleep_list, &cur->elem, (list_less_func *)cmp_thread_wake_ticks, NULL);  lock_release(&sleep_list_lock);  thread_block();  intr_set_level(old_level);#endif}

voidtest_mlfqs_load_60 (void) {  int i;    ASSERT (thread_mlfqs);  start_time = timer_ticks ();  msg ("Starting %d niced load threads...", THREAD_CNT);  for (i = 0; i < THREAD_CNT; i++)     {      char name[16];      snprintf(name, sizeof name, "load %d", i);      thread_create (name, PRI_DEFAULT, load_thread, NULL);    }  msg ("Starting threads took %d seconds.",       timer_elapsed (start_time) / TIMER_FREQ);  for (i = 0; i < 90; i++)     {      int64_t sleep_until = start_time + TIMER_FREQ * (2 * i + 10);      int load_avg;//printf("LIST NUMBER : %d/n", get_list_size ());      timer_sleep (sleep_until - timer_ticks ());      load_avg = thread_get_load_avg ();      msg ("After %d seconds, load average=%d.%02d.",           i * 2, load_avg / 100, load_avg % 100);    }}

void rgblight_effect_rgbtest(void) {  static uint8_t pos = 0;  static uint16_t last_timer = 0;  static uint8_t maxval = 0;  uint8_t g; uint8_t r; uint8_t b;  if (timer_elapsed(last_timer) < pgm_read_word(&RGBLED_RGBTEST_INTERVALS[0])) {    return;  }  if( maxval == 0 ) {      LED_TYPE tmp_led;      sethsv(0, 255, RGBLIGHT_LIMIT_VAL, &tmp_led);      maxval = tmp_led.r;  }  last_timer = timer_read();  g = r = b = 0;  switch( pos ) {    case 0: r = maxval; break;    case 1: g = maxval; break;    case 2: b = maxval; break;  }  rgblight_setrgb(r, g, b);  pos = (pos + 1) % 3;}

void rgblight_effect_rainbow_swirl(uint8_t interval) {  static uint16_t current_hue = 0;  static uint16_t last_timer = 0;  uint16_t hue;  uint8_t i;  if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_RAINBOW_SWIRL_INTERVALS[interval / 2])) {    return;  }  last_timer = timer_read();  for (i = 0; i < RGBLED_NUM; i++) {    hue = (360 / RGBLED_NUM * i + current_hue) % 360;    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);  }  rgblight_set();  if (interval % 2) {    current_hue = (current_hue + 1) % 360;  } else {    if (current_hue - 1 < 0) {      current_hue = 359;    } else {      current_hue = current_hue - 1;    }  }}

    void    Outro::on_draw()    {        if (m_snd_game_exit != NULL)        {            if (timer_elapsed() > static_cast<unsigned int>(m_snd_game_exit->length_in_ms) + 100)            {                next_state();            }        }        Globals g;        g.render().DrawTile(0,0, g.values().res_w(), g.values().res_h(), m_img_mainmenu);        string text1 = g.snd2txt().text();        string text2 = "";        if (text1.length() >= 25)        {            text2 = text1;            text1.erase(25, string::npos);            text2.erase(0, 25);        }        g.render().DrawText(500, 400, 1.0, 1.0, 1.0, text1);        g.render().DrawText(500, 450, 1.0, 1.0, 1.0, text2);    }

void reset_keyboard(void) {  clear_keyboard();#if defined(MIDI_ENABLE) && defined(MIDI_BASIC)  process_midi_all_notes_off();#endif#ifdef AUDIO_ENABLE  #ifndef NO_MUSIC_MODE    music_all_notes_off();  #endif  uint16_t timer_start = timer_read();  PLAY_SONG(goodbye_song);  shutdown_user();  while(timer_elapsed(timer_start) < 250)    wait_ms(1);  stop_all_notes();#else  shutdown_user();  wait_ms(250);#endif// this is also done later in bootloader.c - not sure if it's neccesary here#ifdef BOOTLOADER_CATERINA  *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific#endif  bootloader_jump();}

int handle_event_stop_going_down(int event, int order_table[N_FLOORS][N_BUTTONS]) {	int next_state = STOP_GOING_DOWN;		switch (event) {			case EMERGENCY_BUTTON:				activate_emergency(order_table);				next_state = EMERGENCY;				break;			case GO_UP:				if(timer_elapsed() > DOOR_DELAY){					close_door();					change_speed(S_STOP, S_UP);					next_state = GOING_UP;				}else{					next_state = STOP_GOING_UP;				}				break;			case GO_DOWN:				if(timer_elapsed() > DOOR_DELAY){					close_door();					change_speed(S_STOP, S_DOWN);					next_state = GOING_DOWN;				}else{					next_state = STOP_GOING_DOWN;				}				break;						case STOP:				if(timer_elapsed() > DOOR_DELAY){					close_door();					next_state = IDLE;				}else{					next_state = STOP_GOING_DOWN;				}				break;						case OBSTRUCTION:				timer_set();				next_state = STOP_GOING_DOWN;				break;					}		return next_state;}

int main(int argc, char *argv[]){	struct timer *timer = timer_new();	sleep(1);	printf("Elapsed: %lu ms/n", timer_elapsed(timer, NULL));	timer_stop(timer);	sleep(1);	printf("Elapsed: %lu ms/n", timer_elapsed(timer, NULL));	timer_continue(timer);	sleep(1);	printf("Elapsed: %lu ms/n", timer_elapsed(timer, NULL));	timer_destroy(&timer);	return 0;}

void matrix_scan_user(void) {  if (runonce && timer_elapsed(my_timer) > 1000) {    runonce = false;    rgblight_sethsv(0x0, 0xff, 0x80);    rgblight_mode(9);    rgblight_enable();  }}

int main(void){    bool suspended = false;#if USB_COUNT_SOF    uint16_t last_timer = timer_read();#endif#if !defined(__AVR_ATmega32__)    CLKPR = 0x80, CLKPR = 0;#endif#ifndef PS2_USE_USART    uart_init(UART_BAUD_RATE);#endif    keyboard_init();    host_set_driver(vusb_driver());    debug("initForUsbConnectivity()/n");    initForUsbConnectivity();    debug("main loop/n");    while (1) {#if USB_COUNT_SOF        if (usbSofCount != 0) {            suspended = false;            usbSofCount = 0;            last_timer = timer_read();        } else {            // Suspend when no SOF in 3ms-10ms(7.1.7.4 Suspending of USB1.1)            if (timer_elapsed(last_timer) > 5) {                suspended = true;/*                uart_putchar('S');                _delay_ms(1);                cli();                set_sleep_mode(SLEEP_MODE_PWR_DOWN);                sleep_enable();                sleep_bod_disable();                sei();                sleep_cpu();                sleep_disable();                _delay_ms(10);                uart_putchar('W');*/            }        }#endif        if (!suspended) {            usbPoll();            // TODO: configuration process is incosistent. it sometime fails.            // To prevent failing to configure NOT scan keyboard during configuration            if (usbConfiguration && usbInterruptIsReady()) {                keyboard_task();            }            vusb_transfer_keyboard();        }    }}

uint8_t matrix_scan(void){	for (uint8_t row = 0; row < MATRIX_ROWS; row++)	{		select_row(row);		_delay_us(15);  // without this wait it will read unstable value. 10? 50?		matrix_row_t cols = read_cols();		if (cols)			LedInfo1_On();		else			LedInfo1_Off();		if (matrix_debouncing[row] != cols)		{			//dprintf("bounce %u/r/n", row);			matrix_debouncing[row] = cols;			debouncing_times[row] = timer_read();			debouncing[row] = true;		}		unselect_rows();	}	for (uint8_t row = 0; row < MATRIX_ROWS; row++)	{		if (debouncing[row])		{			LedInfo2_On();			if (timer_elapsed(debouncing_times[row]) > DEBOUNCE_TIME)			{				//dprintf("bounced %u/r/n", row);				matrix[row] = matrix_debouncing[row];				debouncing[row] = false;				send_row_to_other_side(row, matrix[row]);				mcpu_send_typematrix_row(row, matrix[row]);				animation_typematrix_row(row, matrix[row]);			}		}		else		{			LedInfo2_Off();		}	}	splitbrain_communication_task();#ifdef BACKLIGHT_ENABLE	animate();#endif	return 1;}

static voidload_thread (void *ti_) {  struct thread_info *ti = ti_;  int64_t sleep_time = 5 * TIMER_FREQ;  int64_t spin_time = sleep_time + 30 * TIMER_FREQ;  int64_t last_time = 0;  thread_set_nice (ti->nice);  timer_sleep (sleep_time - timer_elapsed (ti->start_time));  while (timer_elapsed (ti->start_time) < spin_time)     {      int64_t cur_time = timer_ticks ();      if (cur_time != last_time)        ti->tick_count++;      last_time = cur_time;    }}

      /* Sleeps for approximately TICKS timer ticks.  Interrupts must        be turned on. */ void timer_sleep (int64_t ticks) {   int64_t start = timer_ticks ();   printf("Thread Name: %s/n", thread_name ());     ASSERT (intr_get_level () == INTR_ON);      while (timer_elapsed (start) < ticks)           thread_yield ();  }

void matrix_scan_user() {    for (uint8_t index = 0 ; index < TH_EVENTS_COUNT ; ++index ) {        tap_hold_t *th_event = &th_events[index];        if ( th_event->is_pressed && timer_elapsed(th_event->timer) > LONGPRESS_DELAY) {            register_code(th_event->kc_hold);            unregister_code(th_event->kc_hold);            th_event->is_pressed = false;        }    }}

void rgblight_effect_rainbow_mood(uint8_t interval) {  static uint16_t current_hue = 0;  static uint16_t last_timer = 0;  if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_RAINBOW_MOOD_INTERVALS[interval])) {    return;  }  last_timer = timer_read();  rgblight_sethsv_noeeprom_old(current_hue, rgblight_config.sat, rgblight_config.val);  current_hue = (current_hue + 1) % 360;}