void upm_delay_ms(unsigned int time) { if (time <= 0) time = 1; #if defined(UPM_PLATFORM_LINUX) struct timespec delay_time; delay_time.tv_sec = time / 1000; delay_time.tv_nsec = (time % 1000) * 1000000; // here we spin until the delay is complete - detecting signals // and continuing where we left off while (nanosleep(&delay_time, &delay_time) && errno == EINTR) ; // loop #elif defined(UPM_PLATFORM_ZEPHYR) # if KERNEL_VERSION_MAJOR == 1 && KERNEL_VERSION_MINOR >= 6 struct k_timer timer; k_timer_init(&timer, NULL, NULL); k_timer_start(&timer, time, 0); k_timer_status_sync(&timer); # else struct nano_timer timer; void *timer_data[1]; nano_timer_init(&timer, timer_data); nano_timer_start(&timer, MSEC(time) + 1); nano_timer_test(&timer, TICKS_UNLIMITED); # endif #endif }
/* Precalculate all three rows of an image and start the rendering. */ static void start_image(struct mb_display *disp, const struct mb_image *img) { int row, col; for (row = 0; row < DISPLAY_ROWS; row++) { disp->row[row] = 0; for (col = 0; col < DISPLAY_COLS; col++) { if (GET_PIXEL(img, map[row][col].x, map[row][col].y)) { disp->row[row] |= BIT(LED_COL1_GPIO_PIN + col); } } disp->row[row] = ~disp->row[row] & col_mask; disp->row[row] |= BIT(LED_ROW1_GPIO_PIN + row); } disp->cur = 0; if (disp->duration == K_FOREVER) { disp->expiry = K_FOREVER; } else { disp->expiry = k_uptime_get() + disp->duration; } k_timer_start(&disp->timer, K_NO_WAIT, K_MSEC(4)); }
static void telnet_accept(struct net_context *client, struct sockaddr *addr, socklen_t addrlen, int error, void *user_data) { if (error) { LOG_ERR("Error %d", error); goto error; } if (client_cnx) { LOG_WRN("A telnet client is already in."); goto error; } if (net_context_recv(client, telnet_recv, 0, NULL)) { LOG_ERR("Unable to setup reception (family %u)", net_context_get_family(client)); goto error; } LOG_DBG("Telnet client connected (family AF_INET%s)", net_context_get_family(client) == AF_INET ? "" : "6"); orig_printk_hook = __printk_get_hook(); __printk_hook_install(telnet_console_out); client_cnx = client; k_timer_start(&send_timer, TELNET_TIMEOUT, TELNET_TIMEOUT); return; error: net_context_put(client); }
static void gpio_sch_poll_status(void *arg1, void *unused1, void *unused2) { struct device *dev = (struct device *)arg1; const struct gpio_sch_config *info = dev->config->config_info; struct gpio_sch_data *gpio = dev->driver_data; ARG_UNUSED(unused1); ARG_UNUSED(unused2); /* Cleaning up GTS first */ z_write_gts(z_read_gts(info->regs), info->regs); while (gpio->poll) { u32_t status; status = z_read_gts(info->regs); if (!status) { goto loop; } gpio_fire_callbacks(&gpio->callbacks, dev, status); /* It's not documented but writing the same status value * into GTS tells to the controller it got handled. */ z_write_gts(status, info->regs); loop: k_timer_start(&gpio->poll_timer, GPIO_SCH_POLLING_MSEC, 0); k_timer_status_sync(&gpio->poll_timer); } }
void upm_delay(unsigned int time) { if (time <= 0) time = 1; #if defined(UPM_PLATFORM_LINUX) struct timespec delay_time; delay_time.tv_sec = time; delay_time.tv_nsec = 0; // The advantage over sleep(3) here is that it will not use // an alarm signal or handler. // here we spin until the delay is complete - detecting signals // and continuing where we left off while (nanosleep(&delay_time, &delay_time) && errno == EINTR) ; // loop #elif defined(UPM_PLATFORM_ZEPHYR) # if KERNEL_VERSION_MAJOR == 1 && KERNEL_VERSION_MINOR >= 6 struct k_timer timer; k_timer_init(&timer, NULL, NULL); k_timer_start(&timer, time * 1000, 0); k_timer_status_sync(&timer); # else struct nano_timer timer; void *timer_data[1]; nano_timer_init(&timer, timer_data); nano_timer_start(&timer, SECONDS(time) + 1); nano_timer_test(&timer, TICKS_UNLIMITED); # endif #endif }
static void tcp_retry_expired(struct k_timer *timer) { struct net_tcp *tcp = CONTAINER_OF(timer, struct net_tcp, retry_timer); struct net_pkt *pkt; /* Double the retry period for exponential backoff and resent * the first (only the first!) unack'd packet. */ if (!sys_slist_is_empty(&tcp->sent_list)) { tcp->retry_timeout_shift++; if (tcp->retry_timeout_shift > CONFIG_NET_TCP_RETRY_COUNT) { abort_connection(tcp); return; } k_timer_start(&tcp->retry_timer, retry_timeout(tcp), 0); pkt = CONTAINER_OF(sys_slist_peek_head(&tcp->sent_list), struct net_pkt, sent_list); if (net_pkt_sent(pkt)) { do_ref_if_needed(tcp, pkt); net_pkt_set_sent(pkt, false); } net_pkt_set_queued(pkt, true); if (net_tcp_send_pkt(pkt) < 0 && !is_6lo_technology(pkt)) { NET_DBG("[%p] pkt %p send failed", tcp, pkt); net_pkt_unref(pkt); } else { NET_DBG("[%p] sent pkt %p", tcp, pkt); if (IS_ENABLED(CONFIG_NET_STATISTICS_TCP) && !is_6lo_technology(pkt)) { net_stats_update_tcp_seg_rexmit(); } } } else if (IS_ENABLED(CONFIG_NET_TCP_TIME_WAIT)) {
static void telnet_rb_switch(void) { telnet_rb.line_in++; if (telnet_rb.line_in == TELNET_LINES) { telnet_rb.line_in = 0; } telnet_rb.l_bufs[telnet_rb.line_in].len = 0; /* Unfortunately, we don't have enough line buffer, * so we eat the next to be sent. */ if (telnet_rb.line_in == telnet_rb.line_out) { telnet_rb.line_out++; if (telnet_rb.line_out == TELNET_LINES) { telnet_rb.line_out = 0; } } k_timer_start(&send_timer, TELNET_TIMEOUT, TELNET_TIMEOUT); k_sem_give(&send_lock); }