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; }