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