int main(void) { xtimer_t timer; timer.callback = time_evt; timer.arg = (void *)sched_active_thread; uint32_t last = xtimer_now_usec(); puts("\nTest setting thread flags from (x)timer callback"); printf("You should see the message '+++ timeout XX +++' printed to the \n" "screen %i times, once every %lu milliseconds\n\n", REPEAT, (TIMEOUT / US_PER_MS)); for (int i = 1; i <= REPEAT; i++) { xtimer_set(&timer, TIMEOUT); thread_flags_wait_any(0x1); printf("+++ timeout %2i +++\n", i); } /* we consider the test successful, if the runtime was above 500ms */ uint32_t runtime = xtimer_now_usec() - last; if (runtime > RUNTIME) { puts("Test finished: SUCCESS\n"); } else { puts("Test finished: FAILED\n"); } return 0; }
static void run_client(int max_cnt) { printf("client (pid=%" PRIkernel_pid "): start\n", thread_getpid()); handle = ndn_app_create(); if (handle == NULL) { printf("client (pid=%" PRIkernel_pid "): cannot create app handle\n", thread_getpid()); return; } max_count = max_cnt; count = 0; begin = xtimer_now_usec(); if (send_interest() == NDN_APP_ERROR) { printf("client (pid=%" PRIkernel_pid "): cannot send interest" " (%"PRIu32")\n", handle->id, count); ndn_app_destroy(handle); return; } ndn_app_run(handle); ndn_app_destroy(handle); }
int main(void) { puts("[START] event test application.\n"); event_queue_t queue = { .waiter = (thread_t *)sched_active_thread }; printf("posting 0x%08x\n", (unsigned)&event); event_post(&queue, &event); printf("posting 0x%08x\n", (unsigned)&event2); event_post(&queue, &event2); printf("canceling 0x%08x\n", (unsigned)&event2); event_cancel(&queue, &event2); printf("posting custom event\n"); event_post(&queue, (event_t *)&custom_event); event_timeout_t event_timeout; printf("posting timed callback with timeout 1sec\n"); event_timeout_init(&event_timeout, &queue, (event_t *)&event_callback); before = xtimer_now_usec(); event_timeout_set(&event_timeout, 100000LU); printf("launching event queue\n"); event_loop(&queue); return 0; }
int main(void) { #if defined(MAIN_THREAD_PIN) gpio_t main_pin = MAIN_THREAD_PIN; gpio_init(main_pin, GPIO_OUT); #endif #if defined(WORKER_THREAD_PIN_1) && defined(WORKER_THREAD_PIN_2) timer_arg_t sleep_timer1 = { TEST_SLEEP_TIME_1, WORKER_THREAD_PIN_1 }; timer_arg_t sleep_timer2 = { TEST_SLEEP_TIME_2, WORKER_THREAD_PIN_2 }; #else uint32_t sleep_timer1 = TEST_SLEEP_TIME_1; uint32_t sleep_timer2 = TEST_SLEEP_TIME_2; #endif LOG_DEBUG("[INIT]\n"); thread_create(stack_timer1, TEST_TIMER_STACKSIZE, 2, THREAD_CREATE_STACKTEST, timer_func, &sleep_timer1, "timer1"); thread_create(stack_timer2, TEST_TIMER_STACKSIZE, 3, THREAD_CREATE_STACKTEST, timer_func, &sleep_timer2, "timer2"); uint32_t now = 0; uint32_t start = xtimer_now_usec(); uint32_t until = start + (TEST_TIME_S * US_PER_SEC); uint32_t interval = TEST_INTERVAL_MS * US_PER_MS; xtimer_ticks32_t last_wakeup = xtimer_now(); puts("[START]"); while ((now = xtimer_now_usec()) < until) { unsigned percent = (100 * (now - start)) / (until - start); #if defined(MAIN_THREAD_PIN) gpio_set(main_pin); #endif xtimer_periodic_wakeup(&last_wakeup, interval); #if defined(MAIN_THREAD_PIN) gpio_clear(main_pin); #endif printf("Testing (%3u%%)\n", percent); } puts("Testing (100%)"); puts("[SUCCESS]"); return 0; }
static void _set_timer(xtimer_t *timer, uint32_t offset_ms) { uint64_t offset_us = (uint64_t)offset_ms * US_PER_MS; DEBUG("evtimer: now=%" PRIu32 " us setting xtimer to %" PRIu32 ":%" PRIu32 " us\n", xtimer_now_usec(), (uint32_t)(offset_us >> 32), (uint32_t)(offset_us)); xtimer_set64(timer, offset_us); }
static void timed_callback(void *arg) { order++; assert(order == 3); assert(arg == event_callback.arg); uint32_t now = xtimer_now_usec(); assert((now - before >= 100000LU)); printf("triggered timed callback with arg 0x%08x after %" PRIu32 "us\n", (unsigned)arg, now - before); printf("[SUCCESS]\n"); }
/* * Main request handler: generates response PDU in the provided buffer. * * Caller must finish the PDU and send it. * * return length of response pdu, or < 0 if can't handle */ static size_t _handle_req(coap_pkt_t *pdu, uint8_t *buf, size_t len, sock_udp_ep_t *remote) { coap_resource_t *resource; gcoap_listener_t *listener; sock_udp_ep_t *observer = NULL; gcoap_observe_memo_t *memo = NULL; gcoap_observe_memo_t *resource_memo = NULL; _find_resource(pdu, &resource, &listener); if (resource == NULL) { return gcoap_response(pdu, buf, len, COAP_CODE_PATH_NOT_FOUND); } else { /* used below to ensure a memo not already recorded for the resource */ _find_obs_memo_resource(&resource_memo, resource); } if (coap_get_observe(pdu) == COAP_OBS_REGISTER) { int empty_slot = _find_obs_memo(&memo, remote, pdu); /* record observe memo */ if (memo == NULL) { if (empty_slot >= 0 && resource_memo == NULL) { int obs_slot = _find_observer(&observer, remote); /* cache new observer */ if (observer == NULL) { if (obs_slot >= 0) { observer = &_coap_state.observers[obs_slot]; memcpy(observer, remote, sizeof(sock_udp_ep_t)); } else { DEBUG("gcoap: can't register observer\n"); } } if (observer != NULL) { memo = &_coap_state.observe_memos[empty_slot]; } } if (memo == NULL) { coap_clear_observe(pdu); DEBUG("gcoap: can't register observe memo\n"); } } if (memo != NULL) { memo->observer = observer; memo->resource = resource; memo->token_len = coap_get_token_len(pdu); if (memo->token_len) { memcpy(&memo->token[0], pdu->token, memo->token_len); } DEBUG("gcoap: Registered observer for: %s\n", memo->resource->path); /* generate initial notification value */ uint32_t now = xtimer_now_usec(); pdu->observe_value = (now >> GCOAP_OBS_TICK_EXPONENT) & 0xFFFFFF; }
void _update_lifetime(void) { uint32_t now = xtimer_now_usec(); uint16_t now_sec = now / SEC_IN_USEC; gnrc_rpl_parent_t *parent; gnrc_rpl_instance_t *inst; for (uint8_t i = 0; i < GNRC_RPL_PARENTS_NUMOF; ++i) { parent = &gnrc_rpl_parents[i]; if (parent->state != 0) { if ((int32_t)(parent->lifetime - now_sec) <= GNRC_RPL_LIFETIME_UPDATE_STEP) { gnrc_rpl_dodag_t *dodag = parent->dodag; gnrc_rpl_parent_remove(parent); gnrc_rpl_parent_update(dodag, NULL); continue; } else if ((int32_t)(parent->lifetime - now_sec) <= (GNRC_RPL_LIFETIME_UPDATE_STEP * 2)) { gnrc_rpl_send_DIS(parent->dodag->instance, &parent->addr); } } } for (int i = 0; i < GNRC_RPL_INSTANCES_NUMOF; ++i) { inst = &gnrc_rpl_instances[i]; if (inst->state != 0) { if ((inst->cleanup > 0) && (inst->dodag.parents == NULL) && (inst->dodag.my_rank == GNRC_RPL_INFINITE_RANK)) { inst->cleanup -= GNRC_RPL_LIFETIME_UPDATE_STEP; if (inst->cleanup <= 0) { /* no parents - delete this instance and DODAG */ gnrc_rpl_instance_remove(inst); continue; } } if (inst->dodag.dao_time > GNRC_RPL_LIFETIME_UPDATE_STEP) { inst->dodag.dao_time -= GNRC_RPL_LIFETIME_UPDATE_STEP; } else { _dao_handle_send(&inst->dodag); } } } #ifdef MODULE_GNRC_RPL_P2P gnrc_rpl_p2p_update(); #endif xtimer_set_msg(&_lt_timer, _lt_time, &_lt_msg, gnrc_rpl_pid); }
int main(void) { puts("START"); kernel_pid_t pid = thread_create(stack, sizeof(stack), THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST, _thread, NULL, "second_thread"); thread_t *thread = (thread_t*) thread_get(pid); _set(thread, 0x1); _set(thread, 0x64); _set(thread, 0x1); _set(thread, 0x8); _set(thread, 0x2); _set(thread, 0x4); while(!done) {}; puts("main: setting 100ms timeout..."); xtimer_t t; uint32_t before = xtimer_now_usec(); xtimer_set_timeout_flag(&t, TIMEOUT); thread_flags_wait_any(THREAD_FLAG_TIMEOUT); uint32_t diff = xtimer_now_usec() - before; printf("main: timeout triggered. time passed: %uus\n", (unsigned)diff); if (diff < (TIMEOUT + THRESHOLD)) { puts("SUCCESS"); return 0; } puts("FAILURE"); return 1; }
static int check_and_read(const void *dev, phydat_t *res, int16_t *val, uint8_t unit) { uint32_t now = xtimer_now_usec(); if ((now - last) > DHT_SAUL_HOLD_TIME) { dht_read((const dht_t *)dev, &temp, &hum); last = now; } res->val[0] = *val; memset(&res->val[1], 0, 2 * sizeof(int16_t)); res->unit = unit; res->scale = -1; return 1; }
static int on_data(ndn_block_t* interest, ndn_block_t* data) { (void)interest; (void)data; /* ndn_block_t name; int r = ndn_data_get_name(data, &name); assert(r == 0); printf("client (pid=%" PRIkernel_pid "): data received, name=", handle->id); ndn_name_print(&name); putchar('\n'); ndn_block_t content; r = ndn_data_get_content(data, &content); assert(r == 0); assert(content.len == 6); printf("client (pid=%" PRIkernel_pid "): content=%02X%02X%02X%02X\n", handle->id, *(content.buf + 2), *(content.buf + 3), *(content.buf + 4), *(content.buf + 5)); r = ndn_data_verify_signature(data, ecc_key_pub, sizeof(ecc_key_pub)); if (r != 0) printf("client (pid=%" PRIkernel_pid "): fail to verify signature\n", handle->id); else printf("client (pid=%" PRIkernel_pid "): signature valid\n", handle->id); */ if (++count != max_count) { if (send_interest() == NDN_APP_ERROR) { printf("client (pid=%" PRIkernel_pid "): cannot send interest" " (%"PRIu32")\n", handle->id, count); ndn_app_destroy(handle); return NDN_APP_ERROR; } } else { uint32_t end = xtimer_now_usec(); printf("client (pid=%"PRIkernel_pid"): total time = %"PRIu32 ", average = %"PRIu32"\n", handle->id, end - begin, (end-begin) / max_count); return NDN_APP_STOP; } return NDN_APP_CONTINUE; }
void emcute_run(uint16_t port, const char *id) { assert(strlen(id) < EMCUTE_ID_MAXLEN); sock_udp_ep_t local = SOCK_IPV6_EP_ANY; sock_udp_ep_t remote; local.port = port; cli_id = id; timer.callback = time_evt; timer.arg = NULL; mutex_init(&txlock); if (sock_udp_create(&sock, &local, NULL, 0) < 0) { LOG_ERROR("[emcute] unable to open UDP socket on port %i\n", (int)port); return; } uint32_t start = xtimer_now_usec(); uint32_t t_out = (EMCUTE_KEEPALIVE * US_PER_SEC); while (1) { ssize_t len = sock_udp_recv(&sock, rbuf, sizeof(rbuf), t_out, &remote); if ((len < 0) && (len != -ETIMEDOUT)) { LOG_ERROR("[emcute] error while receiving UDP packet\n"); return; } if (len >= 2) { /* handle the packet */ uint16_t pkt_len; /* catch invalid length field */ if ((len == 2) && (rbuf[0] == 0x01)) { continue; } /* parse length field */ size_t pos = get_len(rbuf, &pkt_len); /* verify length to prevent overflows */ if (((size_t)pkt_len > (size_t)len) || (pos >= (size_t)len)) { continue; } /* get packet type */ uint8_t type = rbuf[pos]; switch (type) { case CONNACK: on_ack(type, 0, 2, 0); break; case WILLTOPICREQ: on_ack(type, 0, 0, 0); break; case WILLMSGREQ: on_ack(type, 0, 0, 0); break; case REGACK: on_ack(type, 4, 6, 2); break; case PUBLISH: on_publish((size_t)pkt_len, pos); break; case PUBACK: on_ack(type, 4, 6, 0); break; case SUBACK: on_ack(type, 5, 7, 3); break; case UNSUBACK: on_ack(type, 2, 0, 0); break; case PINGREQ: on_pingreq(&remote); break; case PINGRESP: on_pingresp(); break; case DISCONNECT: on_disconnect(); break; case WILLTOPICRESP: on_ack(type, 0, 0, 0); break; case WILLMSGRESP: on_ack(type, 0, 0, 0); break; default: LOG_DEBUG("[emcute] received unexpected type [%s]\n", emcute_type_str(type)); } } uint32_t now = xtimer_now_usec(); if ((now - start) >= (EMCUTE_KEEPALIVE * US_PER_SEC)) { send_ping(); start = now; t_out = (EMCUTE_KEEPALIVE * US_PER_SEC); } else { t_out = (EMCUTE_KEEPALIVE * US_PER_SEC) - (now - start); } } }
clock_time_t hal_getSec(void) { return (clock_time_t)xtimer_now_usec() / US_PER_SEC; }
clock_time_t hal_getTick(void) { return (clock_time_t)xtimer_now_usec(); }
/* * Main request handler: generates response PDU in the provided buffer. * * Caller must finish the PDU and send it. * * return length of response pdu, or < 0 if can't handle */ static size_t _handle_req(coap_pkt_t *pdu, uint8_t *buf, size_t len, sock_udp_ep_t *remote) { coap_resource_t *resource = NULL; gcoap_listener_t *listener = NULL; sock_udp_ep_t *observer = NULL; gcoap_observe_memo_t *memo = NULL; gcoap_observe_memo_t *resource_memo = NULL; switch (_find_resource(pdu, &resource, &listener)) { case GCOAP_RESOURCE_WRONG_METHOD: return gcoap_response(pdu, buf, len, COAP_CODE_METHOD_NOT_ALLOWED); case GCOAP_RESOURCE_NO_PATH: return gcoap_response(pdu, buf, len, COAP_CODE_PATH_NOT_FOUND); case GCOAP_RESOURCE_FOUND: _find_obs_memo_resource(&resource_memo, resource); break; } if (coap_get_observe(pdu) == COAP_OBS_REGISTER) { int empty_slot = _find_obs_memo(&memo, remote, pdu); /* record observe memo */ if (memo == NULL) { if ((resource_memo != NULL) && _endpoints_equal(remote, resource_memo->observer)) { /* observer re-registering with new token */ memo = resource_memo; observer = resource_memo->observer; } else if ((empty_slot >= 0) && (resource_memo == NULL)) { int obs_slot = _find_observer(&observer, remote); /* cache new observer */ if (observer == NULL) { if (obs_slot >= 0) { observer = &_coap_state.observers[obs_slot]; memcpy(observer, remote, sizeof(sock_udp_ep_t)); } else { DEBUG("gcoap: can't register observer\n"); } } if (observer != NULL) { memo = &_coap_state.observe_memos[empty_slot]; } } if (memo == NULL) { coap_clear_observe(pdu); DEBUG("gcoap: can't register observe memo\n"); } } if (memo != NULL) { memo->observer = observer; memo->resource = resource; memo->token_len = coap_get_token_len(pdu); if (memo->token_len) { memcpy(&memo->token[0], pdu->token, memo->token_len); } DEBUG("gcoap: Registered observer for: %s\n", memo->resource->path); /* generate initial notification value */ uint32_t now = xtimer_now_usec(); pdu->observe_value = (now >> GCOAP_OBS_TICK_EXPONENT) & 0xFFFFFF; }