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

void taphold_tapped(uint8_t index, bool pressed) {    if (index >= TH_EVENTS_COUNT) { return; }    tap_hold_t *th_event = &th_events[index];    if (pressed) {        th_event->timer = timer_read();        th_event->is_pressed = true;    } else if (th_event->is_pressed) {        register_code(th_event->kc_tap);        unregister_code(th_event->kc_tap);        th_event->is_pressed = false;    }}

double Reduce(Arr *a,int w){  double retv=0.0;  if(timer_on){    timer_clear(w);    timer_start(w);  }  retv=(int)(w*CheckVal(a));/* The casting needed for node                                 and array dependent verifcation */  if(timer_on){    timer_stop(w);    fprintf(stderr,"** Reduce time in node %d = %f/n",(w-1),timer_read(w));  }  return retv;}

void _k_task_monitor(struct k_proc *X, uint32_t D){#ifdef CONFIG_TASK_DEBUG	if (!_k_debug_halt)#endif	{		k_monitor_wptr->time = timer_read();		k_monitor_wptr->data1 = X->Ident;		k_monitor_wptr->data2 = D;		if (++K_monitor_wind == k_monitor_capacity) {			K_monitor_wind = 0;			k_monitor_wptr = k_monitor_buff;		} else {			++k_monitor_wptr;		}		if (k_monitor_nrec < k_monitor_capacity) {			k_monitor_nrec++;		}	}	if ((_k_task_switch_callback != NULL) && (D == 0)) {		(_k_task_switch_callback)(X->Ident, timer_read());	}}

void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) {  static uint16_t debouncing_time;  if (changed) {    debouncing = true;    debouncing_time = timer_read();  }  if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {    for (uint8_t i = 0; i < num_rows; i++) {      cooked[i] = raw[i];    }    debouncing = false;  }}

void rgblight_effect_breathing(uint8_t interval) {  static uint8_t pos = 0;  static uint16_t last_timer = 0;  float val;  if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_BREATHING_INTERVALS[interval])) {    return;  }  last_timer = timer_read();  // http://sean.voisen.org/blog/2011/10/breathing-led-with-arduino/  val = (exp(sin((pos/255.0)*M_PI)) - RGBLIGHT_EFFECT_BREATHE_CENTER/M_E)*(RGBLIGHT_EFFECT_BREATHE_MAX/(M_E-1/M_E));  rgblight_sethsv_noeeprom_old(rgblight_config.hue, rgblight_config.sat, val);  pos = (pos + 1) % 256;}

voidmatrix_multiply_cl(pclu_context * pclu, matrix * cc, matrix * aa, matrix * bb){    pclu_program *pgm = pclu_create_program(pclu, "bmmul.cl");    char *log = pclu_program_build_log(pgm);    if (strlen(log) > 0)        printf("Build log:/n%s/n", log);    size_t aa_size = matrix_bytes(aa);    pclu_buffer *aa_buf = pclu_create_buffer(pclu, aa_size);    pclu_write_buffer(aa_buf, aa_size, aa->data);    size_t bb_size = matrix_bytes(bb);    pclu_buffer *bb_buf = pclu_create_buffer(pclu, bb_size);    pclu_write_buffer(bb_buf, bb_size, bb->data);    size_t cc_size = matrix_bytes(cc);    pclu_buffer *cc_buf = pclu_create_buffer(pclu, cc_size);    pclu_write_buffer(cc_buf, cc_size, cc->data);    cl_long nn = SIZE;    cl_long bs = BLOCK_SIZE;        pclu_range range = pclu_range_2d(cc->rows / bs, cc->cols / bs);    timer* tt = timer_alloc();    cl_kernel kernel = pclu_get_kernel(pgm, "bmmul");    pclu_set_arg_buf(kernel, 0, cc_buf);     pclu_set_arg_buf(kernel, 1, aa_buf);     pclu_set_arg_buf(kernel, 2, bb_buf);     printf("nn = %ld = 0x%lx/n", nn, nn);    pclu_set_arg_lit(kernel, 3, nn);    printf("bs = %ld = 0x%lx/n", bs, bs);    pclu_set_arg_lit(kernel, 4, bs);        pclu_call_kernel(pgm, kernel, range);    double kt = timer_read(tt);    timer_free(tt);    printf("Kernel (probably build) took %.04f seconds./n", kt);    pclu_read_buffer(cc_buf, cc_size, cc->data);    pclu_destroy_program(pgm);}

const char *rn42_gets(uint16_t timeout){    static char s[24];    uint16_t t = timer_read();    uint8_t i = 0;    int16_t c;    while (i < 23 && timer_elapsed(t) < timeout) {        if ((c = rn42_getc()) != -1) {            if ((char)c == '/r') continue;            if ((char)c == '/n') break;            s[i++] = c;        }    }    s[i] = '/0';    return s;}

void rgblight_effect_christmas(void) {  static uint16_t current_offset = 0;  static uint16_t last_timer = 0;  uint16_t hue;  uint8_t i;  if (timer_elapsed(last_timer) < RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL) {    return;  }  last_timer = timer_read();  current_offset = (current_offset + 1) % 2;  for (i = 0; i < RGBLED_NUM; i++) {    hue = 0 + ((i/RGBLIGHT_EFFECT_CHRISTMAS_STEP + current_offset) % 2) * 120;    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);  }  rgblight_set();}

void rgblight_effect_christmas(void) {  static uint16_t current_offset = 0;  static uint16_t last_timer = 0;  uint16_t hue;  uint8_t i;  if (timer_elapsed(last_timer) < 1000) {    return;  }  last_timer = timer_read();  current_offset = (current_offset + 1) % 2;  for (i = 0; i < RGBLED_NUM; i++) {    hue = 0 + ((RGBLED_NUM * (i + current_offset)) % 2) * 80;    sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);  }  rgblight_set();}

/* * Do keyboard routine jobs: scan mantrix, light LEDs, ... * This is repeatedly called as fast as possible. */void keyboard_task(void){    static matrix_col_t matrix_prev[MATRIX_COLS];#ifdef MATRIX_HAS_GHOST    static matrix_col_t matrix_ghost[MATRIX_COLS];#endif    static uint8_t led_status = 0;    matrix_col_t matrix_col = 0;    matrix_col_t matrix_change = 0;    matrix_scan();    for (uint8_t c = 0; c < MATRIX_COLS; c++) {        matrix_col = matrix_get_col(c);        matrix_change = matrix_col ^ matrix_prev[c];        if (matrix_change) {#ifdef MATRIX_HAS_GHOST            if (has_ghost_in_col(c)) {                /* Keep track of whether ghosted status has changed for                 * debugging. But don't update matrix_prev until un-ghosted, or                 * the last key would be lost.                 */                if (debug_matrix && matrix_ghost[c] != matrix_col) {                    matrix_print();                }                matrix_ghost[c] = matrix_col;                continue;            }            matrix_ghost[c] = matrix_col;#endif            if (debug_matrix) matrix_print();            for (uint8_t r = 0; r < MATRIX_ROWS; r++) {                if (matrix_change & ((matrix_col_t)1<<r)) {                    keyevent_t e = (keyevent_t){                        .key = (keypos_t){ .row = r, .col = c },                        .pressed = (matrix_col & ((matrix_col_t)1<<r)),                        .time = (timer_read() | 1) /* time should not be 0 */                    };                    action_exec(e);                    hook_matrix_change(e);                    // record a processed key                    matrix_prev[c] ^= ((matrix_col_t)1<<r);                    // process a key per task call                    goto MATRIX_LOOP_END;                }            }        }    }

void rgblight_effect_knight(uint8_t interval) {  static uint16_t last_timer = 0;  if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_KNIGHT_INTERVALS[interval])) {    return;  }  last_timer = timer_read();  static int8_t low_bound = 0;  static int8_t high_bound = RGBLIGHT_EFFECT_KNIGHT_LENGTH - 1;  static int8_t increment = 1;  uint8_t i, cur;  // Set all the LEDs to 0  for (i = 0; i < RGBLED_NUM; i++) {    led[i].r = 0;    led[i].g = 0;    led[i].b = 0;  }  // Determine which LEDs should be lit up  for (i = 0; i < RGBLIGHT_EFFECT_KNIGHT_LED_NUM; i++) {    cur = (i + RGBLIGHT_EFFECT_KNIGHT_OFFSET) % RGBLED_NUM;    if (i >= low_bound && i <= high_bound) {      sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[cur]);    } else {      if (i == RGBLIGHT_FLED1 || i == RGBLIGHT_FLED2) {          fled_hs[0].hue = fled_hs[1].hue = 0;          fled_hs[0].sat = fled_hs[1].sat = 0;      }              led[cur].r = 0;      led[cur].g = 0;      led[cur].b = 0;    }  }  rgblight_set();  // Move from low_bound to high_bound changing the direction we increment each  // time a boundary is hit.  low_bound += increment;  high_bound += increment;  if (high_bound <= 0 || low_bound >= RGBLIGHT_EFFECT_KNIGHT_LED_NUM - 1) {    increment = -increment;  }}

uint8  memorymap_registers_read(uint32 Addr){	switch (Addr&0x1fff)	{	case 0x00:	case 0x01:	case 0x02:	case 0x03: return(gpu_read(Addr));	case 0x20: return(controls_read(Addr));	case 0x21: return(io_read(Addr));	case 0x23:	case 0x24: return(timer_read(Addr));	}	uint8 data = memorymap_regs[Addr&0x1fff]; //	iprintf("regs: reading 0x%.2x from 0x%.4x/n", data, Addr);	return(data);}

static int timer_set_next_event(unsigned long delta,				struct clock_event_device *dev){	unsigned long flags, next;	local_irq_save(flags);	/* clear pending interrupt status and enable */	__raw_writel(0x01, TIMERS_VIRT_BASE + TMR_ICR(0));	__raw_writel(0x01, TIMERS_VIRT_BASE + TMR_IER(0));	next = timer_read() + delta;	__raw_writel(next, TIMERS_VIRT_BASE + TMR_TN_MM(0, 0));	local_irq_restore(flags);	return 0;}

const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt){  switch (id)  {  case F_PASTE:    if (record->event.pressed)    {      register_code(KC_LCTL);      register_code(KC_V);      unregister_code(KC_V);      unregister_code(KC_LCTL);    }    break;  case RGB_ANI:    if (record->event.pressed)    {      rgb_timer = timer_read();    }    else    {      if (timer_elapsed(rgb_timer) > 300)      {        rgblight_mode(1);      }      else      {        rgblight_step();      }    }  case CF_EPRM:    if (record->event.pressed)    {      eeconfig_init();    }    return false;    break;  case CF_VERS:    if (record->event.pressed)    {      SEND_STRING(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);    }    return false;    break;  }  return MACRO_NONE;};

/** Main loop. */static voidmain_loop (void){    main_timer[3] = timer_read ();    /* Compute absolute position. */    aux_pos_update ();    main_timer[4] = timer_read ();    /* Compute trajectory. */    aux_traj_update ();    /* Prepare control system. */    cs_update_prepare ();    main_timer[5] = timer_read ();    /* Wait for next cycle. */    timer_wait ();    /* Encoder update. */    encoder_update ();    main_timer[0] = timer_read ();    /* Control system update. */    cs_update ();    main_timer[1] = timer_read ();    /* Pwm setup. */    output_update ();    main_timer[2] = timer_read ();    /* Sequences. */    seq_update (&seq_aux[0], &cs_aux[0].state);    seq_update (&seq_aux[1], &cs_aux[1].state);    /* Stats. */    if (main_sequence_ack	&& (seq_aux[0].ack != seq_aux[0].finish	    || seq_aux[1].ack != seq_aux[1].finish)	&& !--main_sequence_ack_cpt)      {	//XXX here	proto_send2b ('A', seq_aux[0].finish, seq_aux[1].finish);	main_sequence_ack_cpt = main_sequence_ack;      }    if (main_stat_counter && !--main_stat_counter_cpt)      {	proto_send2w ('C', encoder_aux[0].cur, encoder_aux[1].cur);	main_stat_counter_cpt = main_stat_counter;      }    if (main_stat_aux_pos && !--main_stat_aux_pos_cpt)      {	proto_send2w ('Y', aux[0].pos, aux[1].pos);	main_stat_aux_pos_cpt = main_stat_aux_pos;      }    if (main_stat_speed && !--main_stat_speed_cpt)      {	proto_send2w ('S', cs_aux[0].speed.cur_f >> 8,		      cs_aux[1].speed.cur_f >> 8);	main_stat_speed_cpt = main_stat_speed;      }

void reset_keyboard(void) {  clear_keyboard();#if defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_ENABLE_BASIC))  music_all_notes_off();  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  wait_ms(250);#endif#ifdef CATERINA_BOOTLOADER  *(uint16_t *)0x0800 = 0x7777; // these two are a-star-specific#endif  bootloader_jump();}

int timer_init(tim_t dev, unsigned int ticks_per_us, void (*callback)(int)){    (void)ticks_per_us;    DEBUG("%s/n", __func__);    if (dev >= TIMER_NUMOF) {        return -1;    }    /* initialize time delta */    time_null = 0;    time_null = timer_read(0);    timer_irq_disable(dev);    _callback = callback;    timer_irq_enable(dev);    return 0;}

void start_animation(){    dprintf("start_animation/n");    if (animation.is_running || animation.is_suspended)        return;    if (animation.animationStart)        animation.animationStart();    animation.is_running = true;    animation.is_suspended = false;    animation.loop_timer = timer_read();    animation.duration_timer = timer_read32();    last_key_pressed_timestamp = timer_read32();    show_animaiton_info(current_animation);}

void snake_settings(){	uint8_t difficulty;		while(1){						difficulty = slider_right_read();				if(timer_read(TIMER_3) > 1000){						oled_clear_screen();			oled_put_string(0*8, 0, "Set difficulty");			oled_put_string(0, 1, "Difficulty:%u", difficulty);			oled_put_string(0, 3, "Walls");			if(no_walls){				oled_put_string(7*8,3,"OFF");			}			else{				oled_put_string(7*8,3,"ON");			}						oled_write_screen();			if(button_right_read()){				if(no_walls){					no_walls = 0;				}				else{					no_walls = 1;				}			}						timer_reset(TIMER_3);		}				if(button_left_read()){			if(difficulty < 1){				s_difficulty = 1;			}			s_difficulty = difficulty / 4;			return;		}	}}

void animate(){    if (!animation.is_running || animation.animationLoop == 0)        return;    if (timer_elapsed(animation.loop_timer) < animation.delay_in_ms)        return;    if (suspend_animation_on_idle && timer_elapsed32(last_key_pressed_timestamp) > ANIMATION_SUSPEND_TIMEOUT)        return;	/*	if (animation.duration_in_ms > 0 && timer_elapsed32(animation.duration_timer) > animation.duration_in_ms)	{		stop_animation();		return;	}	*/#ifdef DEBUG_ANIMATION_SPEED    if (loop_count)    {        loop_count--;        elapsed_ms = timer_read32();    }    else    {        loop_count = 10;        duration_ms /= 10;        dprintf("avg: %lu/n", duration_ms);        duration_ms = 0;        elapsed_ms = timer_read32();    }#endif    animation.loop_timer = timer_read();    animation.animationLoop();#ifdef DEBUG_ANIMATION_SPEED    duration_ms += timer_elapsed32(elapsed_ms);    // dprintf("el: %u/n", duration_ms);#endif}

void rgblight_effect_snake(uint8_t interval) {  static uint8_t pos = 0;  static uint16_t last_timer = 0;  uint8_t i, j;  int8_t k;  int8_t increment = 1;  if (interval % 2) {    increment = -1;  }  if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_SNAKE_INTERVALS[interval / 2])) {    return;  }  last_timer = timer_read();    fled_hs[0].hue = fled_hs[1].hue = 0;  fled_hs[0].sat = fled_hs[1].sat = 0;    for (i = 0; i < RGBLED_NUM; i++) {    led[i].r = 0;    led[i].g = 0;    led[i].b = 0;    for (j = 0; j < RGBLIGHT_EFFECT_SNAKE_LENGTH; j++) {      k = pos + j * increment;      if (k < 0) {        k = k + RGBLED_NUM;      }      if (i == k) {        sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), (LED_TYPE *)&led[i]);      }    }  }  rgblight_set();  if (increment == 1) {    if (pos - 1 < 0) {      pos = RGBLED_NUM - 1;    } else {      pos -= 1;    }  } else {    pos = (pos + 1) % RGBLED_NUM;  }}

/* Callback for the timeout */static void cb(void *arg){    unsigned int now_tut = READ_TUT();    unsigned int now_ref = timer_read(TIM_REF_DEV);    if (arg == NULL) {        print_str("cb: Warning! arg = NULL/n");        return;    }    test_ctx_t *ctx = arg;    if (ctx->ref_state == NULL) {        print_str("cb: Warning! ref_state = NULL/n");        return;    }    if (ctx->int_state == NULL) {        print_str("cb: Warning! int_state = NULL/n");        return;    }    /* Update running stats */    /* When setting a timer with a timeout of X ticks, we expect the     * duration between the set and the callback, dT, to be at least     * X * time_per_tick.     * In order to ensure that dT <= X * time_per_tick, the timer read value     * will actually have incremented (X + 1) times during that period,     * because the set can occur asynchrously anywhere between timer     * increments. Therefore, in this test, we consider (X + 1) to be the     * expected timer_read value at the point the callback is called.     */    /* Check that reference timer did not overflow during the test */    if ((now_ref + 0x4000u) >= ctx->target_ref) {        int32_t diff = now_ref - ctx->target_ref - 1 - overhead_target;        matstat_add(ctx->ref_state, diff);    }    /* Update timer_read statistics only when timer_read has not overflowed     * since the timer was set */    if ((now_tut + 0x4000u) >= ctx->target_tut) {        int32_t diff = now_tut - ctx->target_tut - 1 - overhead_read;        matstat_add(ctx->int_state, diff);    }    mutex_unlock(&mtx_cb);}

voidmatrix_multiply_cl(pclu_context * pclu, matrix * cc, matrix * aa, matrix * bb){    pclu_program *pgm = pclu_create_program(pclu, "fmma.cl");    char *log = pclu_program_build_log(pgm);    if (strlen(log) > 0)        printf("Build log:/n%s/n", log);    size_t aa_size = matrix_bytes(aa);    pclu_buffer *aa_buf = pclu_create_buffer(pclu, aa_size);    pclu_write_buffer(aa_buf, aa_size, aa->data);    size_t bb_size = matrix_bytes(bb);    pclu_buffer *bb_buf = pclu_create_buffer(pclu, bb_size);    pclu_write_buffer(bb_buf, bb_size, bb->data);    size_t cc_size = matrix_bytes(cc);    pclu_buffer *cc_buf = pclu_create_buffer(pclu, cc_size);    pclu_write_buffer(cc_buf, cc_size, cc->data);    pclu_range range = pclu_range_2d(cc->rows, cc->cols);    cl_long nn = SIZE;    cl_long spin = SPIN;    timer* tt = timer_alloc();    pclu_call_kernel(pgm, "fmma", range, 5, buf_arg(cc_buf), buf_arg(aa_buf),                     buf_arg(bb_buf), lit_arg(nn), lit_arg(spin));    double kt = timer_read(tt);    timer_free(tt);    printf("Kernel took %.04f seconds./n", kt);    pclu_read_buffer(cc_buf, cc_size, cc->data);    printf("alpha/n");    pclu_destroy_program(pgm);    printf("beta/n");}

void rgblight_effect_alternating(void){  static uint16_t last_timer = 0;  static uint16_t pos = 0;  if (timer_elapsed(last_timer) < 500) {    return;  }  last_timer = timer_read();  for(int i = 0; i<RGBLED_NUM; i++){      if(i<RGBLED_NUM/2 && pos){          sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);      }else if (i>=RGBLED_NUM/2 && !pos){          sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);      }else{          sethsv(rgblight_config.hue, rgblight_config.sat, 0, (LED_TYPE *)&led[i]);      }  }  rgblight_set();  pos = (pos + 1) % 2;}

void receive(_TIMER *self) {	timer_setPeriod(&timer5, 50e-3);	timer_start(&timer5);	led_toggle(&led1);	overflowing = 0;	while(pin_read(&D[12]) == 0){		if (timer_flag(&timer5) != 0){			led_toggle(&led3);			overflowFlag += 1;			overflowing = 1;			break;		}	}	if (overflowing == 0) {		overflowFlag = 0;	}	readTime = timer_read(&timer5);	led_toggle(&led2);	timer_stop(&timer5);}

void spinner_step (void){  static int value;  static int step;  static const unsigned char rgch[]    = { '|', '/', '-', '//', '|', '/', '-', '//' } ;  unsigned v = timer_delta (0, timer_read ());  if (hook_spinner)    hook_spinner (v);  v = v/128;  if (v == value)    return;  value = v;  putchar ('/r');  putchar (rgch[step]);  step = (step + 1)%8;}

void matrix_render(struct CharacterMatrix *matrix) {  last_flush = timer_read();  iota_gfx_on();#if DEBUG_TO_SCREEN  ++displaying;#endif  // Move to the home position  send_cmd3(PageAddr, 0, MatrixRows - 1);  send_cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1);  if (i2c_start_write(SSD1306_ADDRESS)) {    goto done;  }  if (i2c_master_write(0x40)) {    // Data mode    goto done;  }  for (uint8_t row = 0; row < MatrixRows; ++row) {    for (uint8_t col = 0; col < MatrixCols; ++col) {      const uint8_t *glyph = font + (matrix->display[row][col] * FontWidth);      for (uint8_t glyphCol = 0; glyphCol < FontWidth; ++glyphCol) {        uint8_t colBits = pgm_read_byte(glyph + glyphCol);        i2c_master_write(colBits);      }      // 1 column of space between chars (it's not included in the glyph)      //i2c_master_write(0);    }  }  matrix->dirty = false;done:  i2c_master_stop();#if DEBUG_TO_SCREEN  --displaying;#endif}

int main(int argc, char** argv){	int i, j, k = 1;	parse_opt( argc, argv );	for( i = 0; i < NDIM; i++ )	{		for( j = 0; j < NDIM; j++ )		{			a[i][j] = k;			b[i][j] = k;			k++;		}	}	timer_start(1);	mat_mul( c, a, b );	timer_stop(1);	printf("Time elapsed : %lf sec/n", timer_read(1));	if( validation )		check_mat_mul( c, a, b );	if( print_matrix )	{		printf("MATRIX A: /n");		print_mat(a);		printf("MATRIX B: /n");		print_mat(b);		printf("MATRIX C: /n");		print_mat(c);	}	return 0;}

void platform_test_tick_cycles(){	/* Initialize the timer */	const int load_value = 1000;	int mhz_top, mhz_bot, temp;	unsigned long timer_base =		timer_secondary_base(PLATFORM_TIMER0_VBASE);	int cyccnt;	/* Make sure timer is disabled */	timer_stop(timer_base);	/* Load the timer with ticks value */	timer_load(load_value, timer_base);	/* One shot, 32 bits, no irqs */	timer_init_oneshot(timer_base);	/* Start the timer */	timer_start(timer_base);	/* Start counter */	perfmon_reset_start_cyccnt();	/* Wait until 0 */	while (timer_read(timer_base) != 0)		;	cyccnt = perfmon_read_cyccnt();	/* Fixed-point accuracy on bottom digit */	temp = cyccnt * 64 * 10 / load_value;	mhz_top = temp / 10;	mhz_bot = temp - mhz_top * 10;	//printk("Perfmon: %u cycles/%dMhz/n",	//       cyccnt * 64, timer_load);	printk("%s: %d.%d MHz CPU speed measured by timer REFCLK at 1MHz/n",	       __KERNELNAME__, mhz_top, mhz_bot);}

void matrix_scan_user(void) {	// We abuse this for early sending of key	// Key repeat only on QWER/SYMB layers	if (cMode != QWERTY || !inChord) return;	// Check timers#ifndef NO_REPEAT	if (repEngaged && timer_elapsed(repTimer) > REP_DELAY) {		// Process Key for report		processChord(false);		// Send report to host		send_keyboard_report();		clear_keyboard();		repTimer = timer_read();	}	if (!repEngaged && timer_elapsed(repTimer) > REP_INIT_DELAY) {		repEngaged = true;	}#endif};