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

static void event_handler(void *arg){	SDL_Event event;	char ch;	(void)arg;	tmr_start(&sdl.tmr, 100, event_handler, NULL);	while (SDL_PollEvent(&event)) {		switch (event.type) {		case SDL_KEYDOWN:			switch (event.key.keysym.sym) {			case SDLK_ESCAPE:				if (!sdl.fullscreen)					break;				sdl.fullscreen = false;				sdl_reset();				break;			case SDLK_f:				if (sdl.fullscreen)					break;				sdl.fullscreen = true;				sdl_reset();				break;			default:				ch = event.key.keysym.unicode & 0x7f;				/* Relay key-press to UI subsystem */				if (isprint(ch)) {					tmr_start(&sdl.tmr, KEY_RELEASE_VAL,						  timeout, NULL);					ui_input(ch);				}				break;			}			break;		case SDL_VIDEORESIZE:			handle_resize(event.resize.w, event.resize.h);			break;		case SDL_QUIT:			ui_input('q');			break;		default:			break;		}	}}

static void dns_handler(int err, const struct dnshdr *hdr, struct list *ansl,			struct list *authl, struct list *addl, void *arg){	struct rst *rst = arg;	struct dnsrr *rr;	struct sa srv;	(void)err;	(void)hdr;	(void)authl;	(void)addl;	rr = dns_rrlist_find(ansl, rst->host, DNS_TYPE_A, DNS_CLASS_IN, true);	if (!rr) {		re_printf("rst: unable to resolve: %s/n", rst->host);		tmr_start(&rst->tmr, RETRY_WAIT, reconnect, rst);		return;	}	sa_set_in(&srv, rr->rdata.a.addr, rst->port);	err = tcp_connect(&rst->tc, &srv, estab_handler, recv_handler,			  close_handler, rst);	if (err) {		re_printf("rst: tcp connect error: %m/n", err);		tmr_start(&rst->tmr, RETRY_WAIT, reconnect, rst);		return;	}}

int main(void){    tmr_t test_timer, test_timer_2, test_timer_3;    printf("System abstraction test - POSIX implementation/n");    system_init();    tmr_init(&test_timer, true, test, NULL);    tmr_start(test_timer, 100);    tmr_init(&test_timer_2, true, test_2, NULL);    tmr_start(test_timer_2, 275);    tmr_init(&test_timer_3, false, test_3, NULL);    tmr_start(test_timer_3, 1000);    tmr_stop(test_timer);    tmr_reset(test_timer);    system_start();    tmr_destroy(test_timer);    tmr_destroy(test_timer_2);    tmr_destroy(test_timer_3);    return 0;}

int sipsess_reply_2xx(struct sipsess *sess, const struct sip_msg *msg,		      uint16_t scode, const char *reason, struct mbuf *desc,		      const char *fmt, va_list *ap){	struct sipsess_reply *reply;	struct sip_contact contact;	int err = ENOMEM;	reply = mem_zalloc(sizeof(*reply), destructor);	if (!reply)		goto out;	list_append(&sess->replyl, &reply->le, reply);	reply->seq  = msg->cseq.num;	reply->msg  = mem_ref((void *)msg);	reply->sess = sess;	sip_contact_set(&contact, sess->cuser, &msg->dst, msg->tp);	err = sip_treplyf(&sess->st, &reply->mb, sess->sip,			  msg, true, scode, reason,			  "%H"			  "%v"			  "%s%s%s"			  "Content-Length: %zu/r/n"			  "/r/n"			  "%b",			  sip_contact_print, &contact,			  fmt, ap,			  desc ? "Content-Type: " : "",			  desc ? sess->ctype : "",			  desc ? "/r/n" : "",			  desc ? mbuf_get_left(desc) : (size_t)0,			  desc ? mbuf_buf(desc) : NULL,			  desc ? mbuf_get_left(desc) : (size_t)0);	if (err)		goto out;	tmr_start(&reply->tmr, 64 * SIP_T1, tmr_handler, reply);	tmr_start(&reply->tmrg, SIP_T1, retransmit_handler, reply);	if (!mbuf_get_left(msg->mb) && desc) {		reply->awaiting_answer = true;		sess->awaiting_answer = true;	} out:	if (err) {		sess->st = mem_deref(sess->st);		mem_deref(reply);	}	return err;}

static void close_handler(int err, const struct sip_msg *msg,			  const struct sipevent_substate *substate, void *arg){	struct presence *pres = arg;	uint32_t wait;	pres->sub = mem_deref(pres->sub);	info("presence: subscriber closed <%r>: ",	     &contact_addr(pres->contact)->auri);	if (substate) {		info("%s", sipevent_reason_name(substate->reason));		wait = wait_term(substate);	}	else if (msg) {		info("%u %r", msg->scode, &msg->reason);		wait = wait_fail(++pres->failc);	}	else {		info("%m", err);		wait = wait_fail(++pres->failc);	}	info("; will retry in %u secs (failc=%u)/n", wait, pres->failc);	tmr_start(&pres->tmr, wait * 1000, tmr_handler, pres);	contact_set_presence(pres->contact, PRESENCE_UNKNOWN);}

/* Incoming data from TURN-server */static void data_handler(struct allocation *alloc, const struct sa *src,			 struct mbuf *mb){	int err;	if (!alloc->ok) {		re_fprintf(stderr, "allocation not ready"			   " -- ignore %zu bytes from %J/n",			   mbuf_get_left(mb), src);		return;	}	if (!sa_cmp(src, &alloc->peer, SA_ALL)) {		re_printf("updating peer address:  %J  -->  %J/n",			  &alloc->peer, src);		alloc->peer = *src;		if (!alloc->turn_ind)			turnc_add_chan(alloc->turnc, src, NULL, NULL);		tmr_start(&alloc->tmr_ping, PING_INTERVAL,			  tmr_ping_handler, alloc);	}	err = receiver_recv(&alloc->recv, src, mb);	if (err) {		re_fprintf(stderr, "corrupt packet coming from %J (%m)/n",			   src, err);	}}

void rtp_send_start(rtp_send_ctx* ctx) {#if __APPLE__    tmr_start(&ctx->tmr, 10, rtp_send_func(ctx->fmt), ctx);#else    ajitter_set_handler(ctx->record_jitter,  rtp_send_func(ctx->fmt), ctx);#endif}

void tmr_test(void){    // Create a timer object    tmr_t tmr;    // Initialise PIO    BIT_SET_HI(PORT_LED_O, BIT_LED_O);    BIT_SET_HI(DDR_LED_O,  BIT_LED_O);    // Initialise module    pit_init();    // Enable global interrupts    sei();    // Start timer with a 1s timeout    tmr_start(&tmr, TMR_MS_TO_TICKS(1000));    for(;;)    {        // Wait until timer has expired        while(!tmr_has_expired(&tmr))        {            ;        }        // Restart timer        tmr_restart(&tmr);        // Toggle LED        LED_TOGGLE();    }}

void state_find_track_control_logic() {				if (state_find_track_data.not_first_run == false){		status.system.start_line=false;		state_find_track_data.not_first_run = true;		task_t system_state = {.data.command = STATE_COMMAND, .data.timestamp=0, .data.value=STATE_IDLE};		add_task(&system_state);		set_m_forward();		l_motor.rpm = 100;		r_motor.rpm = 100;		state_find_track_data.exp = false;		tmr_start(&state_timer,STATE_FIND_TRACK_SENSOR_BLACKOUT_INTERVAL); 	}		if (state_find_track_data.exp == true || tmr_exp(&state_timer)){		state_find_track_data.exp = true;		read_switches();		uint8_t sensor_value = led.array;		if ((sensor_value & 0x3f)!= 0x3f)		{			state_find_track_data.exp=false;			state_find_track_go_a_bit_more_control_data.not_first_run=false;			set_state(state_find_track_go_a_bit_more_control_logic);		}		return;		}}

static void tcp_estab_handler(void *arg){	struct tcpconn *tc = arg;	struct le *le = list_head(&tc->ql);	int err = 0;	DEBUG_INFO("connection (%J) established/n", &tc->srv);	while (le) {		struct dns_query *q = le->data;		le = le->next;		q->mb.pos = 0;		err = tcp_send(tc->conn, &q->mb);		if (err)			break;		DEBUG_INFO("tcp send %J/n", &tc->srv);	}	if (err) {		tcpconn_close(tc, err);		return;	}	tmr_start(&tc->tmr, tc->dnsc->conf.idle_timeout,		  tcpconn_timeout_handler, tc);	tc->connected = true;}

static int audio_loop_alloc(struct audio_loop **alp,			    uint32_t srate, uint32_t ch){	struct audio_loop *al;	int err;	al = mem_zalloc(sizeof(*al), auloop_destructor);	if (!al)		return ENOMEM;	tmr_start(&al->tmr, 100, tmr_handler, al);	err = auloop_reset(al, srate, ch);	if (err)		goto out;	al->started = true; out:	if (err)		mem_deref(al);	else		*alp = al;	return err;}

static int alloc(struct vidisp_st **stp, const struct vidisp *vd,		 struct vidisp_prm *prm, const char *dev,		 vidisp_resize_h *resizeh, void *arg){	struct vidisp_st *st;	int err = 0;	/* Not used by SDL */	(void)dev;	(void)resizeh;	(void)arg;	if (!stp || !vd)		return EINVAL;	st = mem_zalloc(sizeof(*st), destructor);	if (!st)		return ENOMEM;	st->vd = vd;	st->fullscreen = prm ? prm->fullscreen : false;	tmr_start(&st->tmr, 100, event_handler, st);	if (err)		mem_deref(st);	else		*stp = st;	return err;}

static int module_init(void){    list_init(&mwil);    tmr_start(&tmr, 10, tmr_handler, 0);    return 0;}

static int req_connect(struct http_req *req){	int err = EINVAL;	while (req->srvc > 0) {		--req->srvc;		tmr_cancel(&req->tmr);		req->sc = mem_deref(req->sc);		req->tc = mem_deref(req->tc);		req->mb = mem_deref(req->mb);		err = tcp_connect(&req->tc, &req->srvv[req->srvc],				  estab_handler, recv_handler, close_handler,				  req);		if (err)			continue;#ifdef USE_TLS		if (req->secure) {			err = tls_start_tcp(&req->sc, req->tls, req->tc, 0);			if (err) {				req->tc = mem_deref(req->tc);				continue;			}		}#endif		tmr_start(&req->tmr, CONN_TIMEOUT, timeout_handler, req);		break;	}	return err;}

static void tmr_handler(void *arg){	struct audio_loop *al = arg;	tmr_start(&al->tmr, 100, tmr_handler, al);	print_stats(al);}

static void media_event(struct tcmedia* media, enum media_e event, int earg, void*arg){    struct tcsipcall*call = arg;    switch(event) {    case MEDIA_ICE_OK:	call->cstate |= CSTATE_ICE;	switch(call->cdir) {	case CALL_OUT:            tcsipcall_send(call);	    break;	case CALL_IN:	    if((call->cstate&CSTATE_IN_RING)==0) {		tcsipcall_control(call, CALL_ACCEPT);	    }	    break;	}        break;    case MEDIA_KA_WARN:        re_printf("no sound for %d secs/n", earg);        break;    case MEDIA_KA_FAIL:        tmr_start(&call->tmr, 100, (tmr_h*)tcsipcall_hangup, call);        break;    }}

/** * Scheduling Checks * * @param icem    ICE Media object * * @return 0 if success, otherwise errorcode */int icem_conncheck_start(struct icem *icem){	int err;	if (!icem)		return EINVAL;	if (ICE_MODE_FULL != icem->lmode)		return EINVAL;	err = icem_checklist_form(icem);	if (err)		return err;	icem->state = ICE_CHECKLIST_RUNNING;	icem_printf(icem, "starting connectivity checks"		    " with %u candidate pairs/n",		    list_count(&icem->checkl));	/* add some delay, to wait for call to be 'established' */	tmr_start(&icem->tmr_pace, 10, pace_timeout, icem);	return 0;}

void metric_init(struct metric *metric){	if (!metric)		return;	tmr_start(&metric->tmr, 100, tmr_handler, metric);}

static int module_init(void){	list_init(&mwil);	tmr_start(&tmr, 1, tmr_handler, 0);	return uag_event_register(ua_event_handler, NULL);}

/* _____PUBLIC FUNCTIONS_____________________________________________________ */int main(void){    // Create a timer object    tmr_t tmr;    // Initialise modules    led_init();    systmr_init();    // Initialise timer to expire once a second    tmr_start(&tmr, TMR_TICKS_PER_SEC);    for(;;)    {        // Wait until timer has expired        while(!tmr_has_expired(&tmr))        {            ;        }        // Reset timer        tmr_reset(&tmr);        // Toggle LED pin        led_toggle();    }}

int  sip_keepalive_udp(struct sip_keepalive *ka, struct sip *sip,		       struct udp_sock *us, const struct sa *paddr,		       uint32_t interval){	struct sip_udpconn *uc;	if (!ka || !sip || !us || !paddr)		return EINVAL;	uc = udpconn_find(sip, us, paddr);	if (!uc) {		uc = mem_zalloc(sizeof(*uc), destructor);		if (!uc)			return ENOMEM;		hash_append(sip->ht_udpconn, sa_hash(paddr, SA_ALL),			    &uc->he, uc);		uc->paddr = *paddr;		uc->stun  = mem_ref(sip->stun);		uc->us    = mem_ref(us);		uc->ka_interval = interval ? interval : UDP_KEEPALIVE_INTVAL;		/* learn mapped address immediately */		tmr_start(&uc->tmr_ka, 0, udpconn_keepalive_handler, uc);	}	list_append(&uc->kal, &ka->le, ka);	return 0;}

static void retransmit_handler(void *arg){	struct sip_ctrans *ct = arg;	uint32_t timeout;	int err;	ct->txc++;	switch (ct->state) {	case TRYING:		timeout = MIN(SIP_T1<<ct->txc, SIP_T2);		break;	case CALLING:		timeout = SIP_T1<<ct->txc;		break;	case PROCEEDING:		timeout = SIP_T2;		break;	default:		return;	}	tmr_start(&ct->tmre, timeout, retransmit_handler, ct);	err = sip_transp_send(&ct->qent, ct->sip, NULL, ct->tp, &ct->dst,			      ct->mb, transport_handler, ct);	if (err) {		terminate(ct, err);		mem_deref(ct);	}}

static void abort_call(struct menc_sess *sess){	if (!sess->err) {		sess->err = EPIPE;		tmr_start(&sess->abort_timer, 0, abort_timer_h, sess);	}}

/// Start or restart a timer./// /param[in]     timer_id      timer ID obtained by /ref osTimerCreate./// /param[in]     millisec      /ref CMSIS_RTOS_TimeOutValue "time delay" value of the timer./// /return status code that indicates the execution status of the function./// /note MUST REMAIN UNCHANGED: /b osTimerStart shall be consistent in every CMSIS-RTOS.osStatus osTimerStart (osTimerId timer_id, uint32_t millisec){	if (port_isr_inside())		return osErrorISR;	tmr_start(timer_id, millisec*MSEC, timer_id->period ? millisec*MSEC : 0, timer_id->state);	return osOK;}

static void refresh_timer(struct turnc *turnc){	const uint32_t t = turnc->lifetime*1000*3/4;	DEBUG_INFO("Start refresh timer.. %u seconds/n", t/1000);	tmr_start(&turnc->tmr, t, timeout, turnc);}

int sip_ctrans_request(struct sip_ctrans **ctp, struct sip *sip,		       enum sip_transp tp, const struct sa *dst, char *met,		       char *branch, struct mbuf *mb,		       sip_resp_h *resph, void *arg){	struct sip_ctrans *ct;	int err;	if (!sip || !dst || !met || !branch || !mb)		return EINVAL;	ct = mem_zalloc(sizeof(*ct), destructor);	if (!ct)		return ENOMEM;	hash_append(sip->ht_ctrans, hash_joaat_str(branch), &ct->he, ct);	ct->invite = !strcmp(met, "INVITE");	ct->branch = mem_ref(branch);	ct->met    = mem_ref(met);	ct->mb     = mem_ref(mb);	ct->dst    = *dst;	ct->tp     = tp;	ct->sip    = sip;	ct->state  = ct->invite ? CALLING : TRYING;	ct->resph  = resph ? resph : dummy_handler;	ct->arg    = arg;	err = sip_transp_send(&ct->qent, sip, NULL, tp, dst, mb,			      transport_handler, ct);	if (err)		goto out;	tmr_start(&ct->tmr, 64 * SIP_T1, tmr_handler, ct);	if (!sip_transp_reliable(ct->tp))		tmr_start(&ct->tmre, SIP_T1, retransmit_handler, ct); out:	if (err)		mem_deref(ct);	else if (ctp)		*ctp = ct;	return err;}

static void mqueue_handler(int id, void *data, void *arg){	struct ui_st *st = arg;	(void)data;	tmr_start(&st->tmr, RELEASE_VAL, timeout, st);	report_key(st, id);}

void tmr_delay(uint16_t delay_ms){    tmr_start(delay_ms);    while(!tmr_has_expired())    {        ;    }}

static void timeout_tx(void *arg){	struct audio *a = arg;	tmr_start(&a->tx.u.tmr, 5, timeout_tx, a);	poll_aubuf_tx(a);}

int stream_start(struct stream *s){	if (!s)		return EINVAL;	tmr_start(&s->tmr_stats, 1, tmr_stats_handler, s);	return 0;}