void ThreadManager::listen() { while (true) { auto a = milliseconds(threadManagerSleep); sleep_for(a); _commandManager.process(); while (this->_commands->size() > 0) { auto& c = this->_commands->front(); switch (c.commandType) { case CommandType::DESTROY_ALL: this->stop(); return; case CommandType::KILL: _sendKillWindow(); break; case CommandType::PAUSE: this->pause(); break; case CommandType::RESUME: this->resume(); break; default: break; } this->_commands->pop(); } } }
int javiator_port_get_data( javiator_ldat_t *data ) #endif { motor_signals_t signals = { 0, 0, 0, 0, 0 }; int res, attempts = 0; do { res = javiator_port_tick( ); if( res == EAGAIN ) { if( ++attempts > 1000 ) { return( -1 ); } javiator_port_send_motor_signals( &signals ); sleep_for( 1000 ); } else if( res != 0 ) { return( -1 ); } } while( !new_data ); memcpy( data, &javiator_data, sizeof( *data ) ); new_data = 0; return( 0 ); }
/*---------------------------------------------------------------------------*/ int main() { uint8_t i; uint16_t temp; uint16_t rval; uint16_t getDataCounter; init_hardware(); while(1) { /* power up the temperature sensor */ pinMode(A,2,OUTPUT); digitalWrite(A,2,HIGH); /* prepare reading the 1st ADC channel */ init_adc(0x01); _delay_us(750); /* take multiple readings and divide later */ rval = 0; for (i = 0; i < 8; ++i) { temp = read_adc_sleepy(); /* store each sample seperatly */ data_array[(2*i)+2] = temp >> 8; data_array[(2*i)+3] = temp & 0xFF; rval += temp; } rval = rval >> 3; /* Store the averages */ data_array[0] = rval >> 8; data_array[1] = rval & 0xFF; /* reset ADC registers */ ADCSRA = 0x00; ADMUX = 0x00; /* power down the temperature sensor */ digitalWrite(A,2,LOW); pinMode(A,2,INPUT); /* automatically goes to TX mode */ nrf24_send(data_array); /* be wise ... */ sleep_during_transmisson(); /* parameter for this function determines how long does it wait for a message */ check_bootloader_message(10); /* parameter for this function is WDT overflow count */ sleep_for(25); } return 0; }
void executorLoop() { TTimePoint call_end = nanos(); while (started_) { TTimePoint period_start = nanos(); TTimeDelta since_last_call = period_start - call_end; //is this first loop? if (period_count_ > 0) { //when we are doing work, don't let other thread to cause contention std::lock_guard<std::mutex> locker(mutex_); bool result = callback_(since_last_call); if (!result) { started_ = result; } } call_end = nanos(); TTimeDelta elapsed_period = nanos() - period_start; //prevent underflow: https://github.com/Microsoft/AirSim/issues/617 TTimeDelta delay_nanos = period_nanos_ > elapsed_period ? period_nanos_ - elapsed_period : 0; //moving average of how much we are sleeping sleep_time_avg_ = 0.25f * sleep_time_avg_ + 0.75f * delay_nanos; ++period_count_; if (delay_nanos > 0 && started_) sleep_for(delay_nanos); } }
void SoundStream::loop(double volume) { int numQueued = 0; AL(alGetSourcei(source.getId(), AL_BUFFERS_QUEUED, &numQueued)); if (numQueued == 0) { /*fill and queue initial buffers*/ vector<char> data = readSoundData(*file, streamingBufferSize); AL(alBufferData(buffers[0], (info->channels > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16, data.data(), data.size(), info->rate)); data = readSoundData(*file, streamingBufferSize); AL(alBufferData(buffers[1], (info->channels > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16, data.data(), data.size(), info->rate)); AL(alSourceQueueBuffers(source.getId(), 2, buffers)); AL(alSourcef(source.getId(), AL_GAIN, volume)); AL(alSourcePlay(source.getId())); startedPlaying = true; //CHECK(isPlaying()); fails if I unplug/plug the speaker cable...? } else { /*refill processed buffers*/ int numProcessed = 0; AL(alGetSourcei(source.getId(), AL_BUFFERS_PROCESSED, &numProcessed)); while (numProcessed--) { vector<char> data = readSoundData(*file, streamingBufferSize); if (data.size() == 0) break; else { ALuint buffer = 0; AL(alSourceUnqueueBuffers(source.getId(), 1, &buffer)); AL(alBufferData(buffer, (info->channels > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16, data.data(), data.size(), info->rate)); AL(alSourceQueueBuffers(source.getId(), 1, &buffer)); } } } sleep_for(milliseconds(10)); }
static int read_TYPE(const SOCKET sock, TYPE* data, const milliseconds d, std::size_t size = SIZE) { auto end = system_clock::now() + d; char *p = reinterpret_cast<char*>(data); std::size_t total_read = 0; int remaining = size; while (true) { if (system_clock::now() > end) { throw timeout_error("timeout error reading from socket."); } int result = ::recv(sock, p, remaining, 0); if (result == SOCKET_ERROR) { if (WouldSocketBlock()) { sleep_for(SLEEP_MS); continue; } } if (result == 0) { return total_read; } total_read += result; if (total_read < size) { p += result; remaining -= result; continue; } return total_read; } throw socket_error("unknown error reading from socket."); }
TEST_F(TestUpdateable, StopsPromptly) { Start(); // The countdown takes .6 seconds total at 500hz, so it should not finish if // left for .59 seconds - it should finish very quickly when called. sleep_for(.595*s); Stop(); ASSERT_GT(_x, 0); }
int main(void) { void *memory = NULL; mmw_size needed_memory = 0; struct server_state state; struct mmw_server server; struct mmw_config config; memset(&config, 0, sizeof config); config.userdata = &state; config.address = "127.0.0.1"; config.port = 8888; config.connection_max = 4; config.request_buffer_size = 2048; config.io_buffer_size = 8192; config.log = test_log; config.dispatch = dispatch; config.ws_connect = websocket_connect; config.ws_connected = websocket_connected; config.ws_frame = websocket_frame; config.ws_closed = websocket_closed; #if defined(_WIN32) {WORD wsa_version = MAKEWORD(2,2); WSADATA wsa_data; if (WSAStartup(wsa_version, &wsa_data)) { fprintf(stderr, "WSAStartup failed\n"); return 1; }} #endif mmw_server_init(&server, &config, &needed_memory); memory = calloc(needed_memory, 1); mmw_server_start(&server, memory); memset(&state, 0, sizeof state); while (!state.quit) { int i = 0; mmw_server_update(&server); /* Push some test data over websockets */ if (!(state.frame_counter & 0x7f)) { for (i = 0; i < state.conn_count; ++i) { mmw_frame_begin(state.conn[i], MMW_WSOP_TEXT_FRAME); mmw_write(state.conn[i], "Hello world over websockets!\n", 29); mmw_frame_end(state.conn[i]); } } sleep_for(30); ++state.frame_counter; } mmw_server_stop(&server); free(memory); #if defined(_WIN32) WSACleanup(); #endif return 0; }
void ThreadManager::start() { // don't replace to for(auto c : _subjects) for (auto c = _subjects.begin(); c != _subjects.end(); c++) { auto value = *c; _threads.push_back(thread([&value]() { value->start(); })); auto a = milliseconds(threadManagerSleep); sleep_for(a); } }
void task_time() { printf("TIME TASK (ID %d) started.\n",CURRENT_TASK_ID); yield(); while(true) { sem_acquire(&lcd_sem); lcd_cursor(0,0); lcd_printf("Runtime: %d.%d ",millis()/1000, (millis()%1000)/100); sem_release(&lcd_sem); sleep_for(100); } }
bool rclcpp::utilities::sleep_for(const std::chrono::nanoseconds & nanoseconds) { std::chrono::nanoseconds time_left = nanoseconds; { std::unique_lock<std::mutex> lock(::g_interrupt_mutex); auto start = std::chrono::steady_clock::now(); ::g_interrupt_condition_variable.wait_for(lock, nanoseconds); time_left -= std::chrono::steady_clock::now() - start; } if (time_left > std::chrono::nanoseconds::zero() && !g_is_interrupted) { return sleep_for(time_left); } // Return true if the timeout elapsed successfully, otherwise false. return !g_is_interrupted; }
void task_scroller() { printf("SCROLLER TASK (ID %d) started.\n",CURRENT_TASK_ID); yield(); uint8_t mode = 0; while(true) { mode = !mode; for(uint8_t i = 0; i < 16; i++) { sem_acquire(&lcd_sem); lcd_cursor(i,1); lcd_data(mode?0xFF:' '); sem_release(&lcd_sem); sleep_for(20); } } }
/* =============================================================== * * DEMO * * ===============================================================*/ int main(void) { long dt; long started; int running = 1; int status; XWindow xw; struct rawfb_context *rawfb; void *fb = NULL; unsigned char tex_scratch[512 * 512]; /* X11 */ memset(&xw, 0, sizeof xw); xw.dpy = XOpenDisplay(NULL); if (!xw.dpy) die("Could not open a display; perhaps $DISPLAY is not set?"); xw.root = DefaultRootWindow(xw.dpy); xw.screen = XDefaultScreen(xw.dpy); xw.vis = XDefaultVisual(xw.dpy, xw.screen); xw.cmap = XCreateColormap(xw.dpy,xw.root,xw.vis,AllocNone); xw.swa.colormap = xw.cmap; xw.swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPress | ButtonReleaseMask| ButtonMotionMask | Button1MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask| PointerMotionMask | KeymapStateMask | EnterWindowMask | LeaveWindowMask; xw.win = XCreateWindow(xw.dpy, xw.root, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, XDefaultDepth(xw.dpy, xw.screen), InputOutput, xw.vis, CWEventMask | CWColormap, &xw.swa); XStoreName(xw.dpy, xw.win, "X11"); XMapWindow(xw.dpy, xw.win); XGetWindowAttributes(xw.dpy, xw.win, &xw.attr); xw.width = (unsigned int)xw.attr.width; xw.height = (unsigned int)xw.attr.height; /* Framebuffer emulator */ status = nk_xlib_init(xw.dpy, xw.vis, xw.screen, xw.win, xw.width, xw.height, &fb); if (!status || !fb) return 0; /* GUI */ rawfb = nk_rawfb_init(fb, tex_scratch, xw.width, xw.height, xw.width * 4); if (!rawfb) running = 0; #ifdef INCLUDE_STYLE /*set_style(ctx, THEME_WHITE);*/ /*set_style(ctx, THEME_RED);*/ /*set_style(ctx, THEME_BLUE);*/ /*set_style(ctx, THEME_DARK);*/ #endif while (running) { /* Input */ XEvent evt; started = timestamp(); nk_input_begin(&rawfb->ctx); while (XCheckWindowEvent(xw.dpy, xw.win, xw.swa.event_mask, &evt)) { if (XFilterEvent(&evt, xw.win)) continue; nk_xlib_handle_event(xw.dpy, xw.screen, xw.win, &evt, rawfb); } nk_input_end(&rawfb->ctx); /* GUI */ if (nk_begin(&rawfb->ctx, "Demo", nk_rect(50, 50, 200, 200), NK_WINDOW_BORDER|NK_WINDOW_MOVABLE| NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE)) { enum {EASY, HARD}; static int op = EASY; static int property = 20; nk_layout_row_static(&rawfb->ctx, 30, 80, 1); if (nk_button_label(&rawfb->ctx, "button")) fprintf(stdout, "button pressed\n"); nk_layout_row_dynamic(&rawfb->ctx, 30, 2); if (nk_option_label(&rawfb->ctx, "easy", op == EASY)) op = EASY; if (nk_option_label(&rawfb->ctx, "hard", op == HARD)) op = HARD; nk_layout_row_dynamic(&rawfb->ctx, 25, 1); nk_property_int(&rawfb->ctx, "Compression:", 0, &property, 100, 10, 1); } nk_end(&rawfb->ctx); if (nk_window_is_closed(&rawfb->ctx, "Demo")) break; /* -------------- EXAMPLES ---------------- */ #ifdef INCLUDE_CALCULATOR calculator(ctx); #endif #ifdef INCLUDE_OVERVIEW overview(ctx); #endif #ifdef INCLUDE_NODE_EDITOR node_editor(ctx); #endif /* ----------------------------------------- */ /* Draw framebuffer */ nk_rawfb_render(rawfb, nk_rgb(30,30,30), 1); /* Emulate framebuffer */ XClearWindow(xw.dpy, xw.win); nk_xlib_render(xw.win); XFlush(xw.dpy); /* Timing */ dt = timestamp() - started; if (dt < DTIME) sleep_for(DTIME - dt); } nk_rawfb_shutdown(rawfb); nk_xlib_shutdown(); XUnmapWindow(xw.dpy, xw.win); XFreeColormap(xw.dpy, xw.cmap); XDestroyWindow(xw.dpy, xw.win); XCloseDisplay(xw.dpy); return 0; }
void sleep_until(const std::chrono::time_point<Clock,Duration>& sleep_time) { sleep_for(sleep_time-Clock::now()); }
static int ast_try_body_execute( struct ast_try *t, time_t stoptime ) { int i=0; int result=0; ftsh_integer_t loops=0; int interval = ftsh_expmin; int sleeptime; time_t starttime, every; if(t->time_limit) { ftsh_integer_t timeout; if(expr_to_integer(t->time_limit->expr,&timeout,stoptime)) { timeout *= t->time_limit->units; if(stoptime==0) { stoptime = timeout+time(0); } else { stoptime = MIN(stoptime,timeout+time(0)); } } else { return 0; } } if(t->every_limit) { ftsh_integer_t i; if(expr_to_integer(t->every_limit->expr,&i,stoptime)) { every = i*t->every_limit->units; } else { return 0; } } else { every = 0; } if(t->loop_limit) { if(expr_to_integer(t->loop_limit->expr,&loops,stoptime)) { /* no problem */ } else { return 0; } } if(!t->time_limit && ! t->loop_limit) { loops = 1; } while(1) { ftsh_error(FTSH_ERROR_STRUCTURE,t->try_line,"TRY attempt %d",i); starttime = time(0); if(ast_group_execute(t->body,stoptime)) { result = 1; break; } i++; if( stoptime && (time(0) > stoptime) ) { ftsh_error(FTSH_ERROR_FAILURE,t->try_line,"TRY time expired"); result = 0; break; } if(loops && (i>=loops)) { ftsh_error(FTSH_ERROR_FAILURE,t->try_line,"TRY loop limit reached"); result = 0; break; } if(every) { ftsh_error(FTSH_ERROR_STRUCTURE,t->end_line,"TRY restricted to EVERY %s seconds",every); sleeptime = starttime+every-time(0); if(sleeptime<0) sleeptime = 0; ftsh_error(FTSH_ERROR_STRUCTURE,t->end_line,"TRY sleeping for %d seconds",sleeptime); } else { if(ftsh_exprand) { sleeptime = interval*(1 + 1.0*rand()/RAND_MAX); } else { sleeptime = interval; } ftsh_error(FTSH_ERROR_STRUCTURE,t->end_line,"TRY sleeping for %d seconds (base %d)",sleeptime,interval); interval = MIN(interval*ftsh_expfactor,ftsh_expmax); } sleep_for(sleeptime); } return result; }
int main(int argc, char * argv[]) { bool start_tm_valid = false; int k, res, progress, pr, rem, num_done; int err = 0; int ret = 0; int sg_fd = -1; int64_t elapsed_usecs = 0; #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) struct timespec start_tm, end_tm; #elif defined(HAVE_GETTIMEOFDAY) struct timeval start_tm, end_tm; #endif struct loop_res_t loop_res; struct loop_res_t * resp = &loop_res; struct sg_pt_base * ptvp = NULL; struct opts_t opts; struct opts_t * op = &opts; memset(op, 0, sizeof(opts)); memset(resp, 0, sizeof(loop_res)); op->do_number = 1; res = parse_cmd_line(op, argc, argv); if (res) return res; if (op->do_help) { usage_for(op); return 0; } #ifdef DEBUG pr2serr("In DEBUG mode, "); if (op->verbose_given && op->version_given) { pr2serr("but override: '-vV' given, zero verbose and continue\n"); op->verbose_given = false; op->version_given = false; op->verbose = 0; } else if (! op->verbose_given) { pr2serr("set '-vv'\n"); op->verbose = 2; } else pr2serr("keep verbose=%d\n", op->verbose); #else if (op->verbose_given && op->version_given) pr2serr("Not in DEBUG mode, so '-vV' has no special action\n"); #endif if (op->version_given) { pr2serr("Version string: %s\n", version_str); return 0; } if (NULL == op->device_name) { pr2serr("No DEVICE argument given\n"); usage_for(op); return SG_LIB_SYNTAX_ERROR; } if ((sg_fd = sg_cmds_open_device(op->device_name, true /* ro */, op->verbose)) < 0) { pr2serr("%s: error opening file: %s: %s\n", __func__, op->device_name, safe_strerror(-sg_fd)); ret = sg_convert_errno(-sg_fd); goto fini; } ptvp = construct_scsi_pt_obj_with_fd(sg_fd, op->verbose); if ((NULL == ptvp) || ((err = get_scsi_pt_os_err(ptvp)))) { pr2serr("%s: unable to construct pt object\n", __func__); ret = sg_convert_errno(err ? err : ENOMEM); goto fini; } if (op->do_progress) { for (k = 0; k < op->do_number; ++k) { if (k > 0) sleep_for(30); progress = -1; res = sg_ll_test_unit_ready_progress_pt(ptvp, k, &progress, (1 == op->do_number), op->verbose); if (progress < 0) { ret = res; break; } else { pr = (progress * 100) / 65536; rem = ((progress * 100) % 65536) / 656; printf("Progress indication: %d.%02d%% done\n", pr, rem); } } if (op->do_number > 1) printf("Completed %d Test Unit Ready commands\n", ((k < op->do_number) ? k + 1 : k)); } else { /* --progress not given */ #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) if (op->do_time) { start_tm.tv_sec = 0; start_tm.tv_nsec = 0; if (0 == clock_gettime(CLOCK_MONOTONIC, &start_tm)) start_tm_valid = true; else perror("clock_gettime(CLOCK_MONOTONIC)\n"); } #elif defined(HAVE_GETTIMEOFDAY) if (op->do_time) { start_tm.tv_sec = 0; start_tm.tv_usec = 0; gettimeofday(&start_tm, NULL); start_tm_valid = true; } #else start_tm_valid = false; #endif num_done = loop_turs(ptvp, resp, op); if (op->do_time && start_tm_valid) { #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) if (start_tm.tv_sec || start_tm.tv_nsec) { res = clock_gettime(CLOCK_MONOTONIC, &end_tm); if (res < 0) { err = errno; perror("clock_gettime"); if (EINVAL == err) pr2serr("clock_gettime(CLOCK_MONOTONIC) not " "supported\n"); } elapsed_usecs = (end_tm.tv_sec - start_tm.tv_sec) * 1000000; /* Note: (end_tm.tv_nsec - start_tm.tv_nsec) may be negative */ elapsed_usecs += (end_tm.tv_nsec - start_tm.tv_nsec) / 1000; } #elif defined(HAVE_GETTIMEOFDAY) if (start_tm.tv_sec || start_tm.tv_usec) { gettimeofday(&end_tm, NULL); elapsed_usecs = (end_tm.tv_sec - start_tm.tv_sec) * 1000000; elapsed_usecs += (end_tm.tv_usec - start_tm.tv_usec); } #endif if (elapsed_usecs > 0) { int64_t nom = num_done; printf("time to perform commands was %u.%06u secs", (unsigned)(elapsed_usecs / 1000000), (unsigned)(elapsed_usecs % 1000000)); nom *= 1000000; /* scale for integer division */ printf("; %d operations/sec\n", (int)(nom / elapsed_usecs)); } else printf("Recorded 0 or less elapsed microseconds ??\n"); } if (((op->do_number > 1) || (resp->num_errs > 0)) && (! resp->reported)) printf("Completed %d Test Unit Ready commands with %d errors\n", op->do_number, resp->num_errs); if (1 == op->do_number) ret = resp->ret; } fini: if (ptvp) destruct_scsi_pt_obj(ptvp); if (sg_fd >= 0) sg_cmds_close_device(sg_fd); return (ret >= 0) ? ret : SG_LIB_CAT_OTHER; }
int main(int argc, char * argv[]) { int sg_fd, k, res, progress, pr, rem; int num_errs = 0; int reported = 0; int ret = 0; #ifndef SG_LIB_MINGW struct timeval start_tm, end_tm; #endif struct opts_t opts; memset(&opts, 0, sizeof(opts)); opts.do_number = 1; res = process_cl(&opts, argc, argv); if (res) return SG_LIB_SYNTAX_ERROR; if (opts.do_help) { usage_for(&opts); return 0; } if (opts.do_version) { fprintf(stderr, "Version string: %s\n", version_str); return 0; } if (NULL == opts.device_name) { fprintf(stderr, "No DEVICE argument given\n"); usage_for(&opts); return SG_LIB_SYNTAX_ERROR; } if ((sg_fd = sg_cmds_open_device(opts.device_name, 1 /* ro */, opts.do_verbose)) < 0) { fprintf(stderr, "sg_turs: error opening file: %s: %s\n", opts.device_name, safe_strerror(-sg_fd)); return SG_LIB_FILE_ERROR; } if (opts.do_progress) { for (k = 0; k < opts.do_number; ++k) { if (k > 0) sleep_for(30); progress = -1; res = sg_ll_test_unit_ready_progress(sg_fd, k, &progress, ((1 == opts.do_number) ? 1 : 0), opts.do_verbose); if (progress < 0) { ret = res; break; } else { pr = (progress * 100) / 65536; rem = ((progress * 100) % 65536) / 656; printf("Progress indication: %d.%02d%% done\n", pr, rem); } } if (opts.do_number > 1) printf("Completed %d Test Unit Ready commands\n", ((k < opts.do_number) ? k + 1 : k)); } else { #ifndef SG_LIB_MINGW if (opts.do_time) { start_tm.tv_sec = 0; start_tm.tv_usec = 0; gettimeofday(&start_tm, NULL); } #endif for (k = 0; k < opts.do_number; ++k) { /* Might get Unit Attention on first invocation */ res = sg_ll_test_unit_ready(sg_fd, k, (0 == k), opts.do_verbose); if (res) { ++num_errs; ret = res; if ((1 == opts.do_number) && (SG_LIB_CAT_NOT_READY == res)) { printf("device not ready\n"); reported = 1; break; } } } #ifndef SG_LIB_MINGW if ((opts.do_time) && (start_tm.tv_sec || start_tm.tv_usec)) { struct timeval res_tm; double a, b; gettimeofday(&end_tm, NULL); res_tm.tv_sec = end_tm.tv_sec - start_tm.tv_sec; res_tm.tv_usec = end_tm.tv_usec - start_tm.tv_usec; if (res_tm.tv_usec < 0) { --res_tm.tv_sec; res_tm.tv_usec += 1000000; } a = res_tm.tv_sec; a += (0.000001 * res_tm.tv_usec); b = (double)opts.do_number; printf("time to perform commands was %d.%06d secs", (int)res_tm.tv_sec, (int)res_tm.tv_usec); if (a > 0.00001) printf("; %.2f operations/sec\n", b / a); else printf("\n"); } #endif if (((opts.do_number > 1) || (num_errs > 0)) && (! reported)) printf("Completed %d Test Unit Ready commands with %d errors\n", opts.do_number, num_errs); } sg_cmds_close_device(sg_fd); return (ret >= 0) ? ret : SG_LIB_CAT_OTHER; }
TEST_F(TestUpdateable, BasicTest) { Start(); sleep_for(.7*s); Stop(); ASSERT_EQ(_x, 0); }
void SetUp() { sleep_for(.001*s); }
TEST(TimeUtils, TimerAndDelay) { Timer t; t.Start(); sleep_for(.2 * s); ASSERT_NEAR(t.Get().to(s), .2, .01); }
inline void write_bit(unsigned pin, unsigned value, unsigned usec = 0) { digitalWrite(pin, value); sleep_for(usec); }
static void frameWait(float frameStart) { static const float FPS = 60.0f; long wait = ((1.0f / FPS) * 1000) - (glfwGetTime() - frameStart); sleep_for(milliseconds(wait)); }
/* Return 0 on success, else see sg_ll_format_unit() */ static int scsi_format(int fd, int fmtpinfo, int cmplst, int pf_usage, int immed, int dcrt, int pie, int si, int early, int verbose) { int res, need_hdr, progress, verb, fmt_pl_sz, longlist, off; const int SH_FORMAT_HEADER_SZ = 4; const int LO_FORMAT_HEADER_SZ = 8; const char INIT_PATTERN_DESC_SZ = 4; unsigned char fmt_pl[LO_FORMAT_HEADER_SZ + INIT_PATTERN_DESC_SZ]; memset(fmt_pl, 0, sizeof(fmt_pl)); longlist = (pie > 0); off = longlist ? LO_FORMAT_HEADER_SZ : SH_FORMAT_HEADER_SZ; fmt_pl[0] = pf_usage & 0x7; /* protection_field_usage (bits 2-0) */ fmt_pl[1] = (immed ? 0x2 : 0); /* fov=0, [dpry,dcrt,stpf,ip=0] */ if (dcrt) fmt_pl[1] |= 0xa0; /* fov=1, dcrt=1 */ if (si) { fmt_pl[1] |= 0x88; /* fov=1, ip=1 */ fmt_pl[off + 0] = 0x20; /* si=1 in init. pattern desc */ } if (longlist) fmt_pl[3] = (pie & 0xf); /* protection interval exponent */ need_hdr = (immed || cmplst || dcrt || si || (pf_usage > 0) || (pie > 0)); fmt_pl_sz = 0; if (need_hdr) fmt_pl_sz = off + (si ? INIT_PATTERN_DESC_SZ : 0); res = sg_ll_format_unit(fd, fmtpinfo, longlist, need_hdr /*fmtdata*/, cmplst, 0 /* dlist_format */, (immed ? SHORT_TIMEOUT : FORMAT_TIMEOUT), fmt_pl, fmt_pl_sz, 1, verbose); switch (res) { case 0: break; case SG_LIB_CAT_NOT_READY: fprintf(stderr, "Format command, device not ready\n"); break; case SG_LIB_CAT_INVALID_OP: fprintf(stderr, "Format command not supported\n"); break; case SG_LIB_CAT_ILLEGAL_REQ: fprintf(stderr, "Format command, illegal parameter\n"); break; case SG_LIB_CAT_UNIT_ATTENTION: fprintf(stderr, "Format command, unit attention\n"); break; case SG_LIB_CAT_ABORTED_COMMAND: fprintf(stderr, "Format command, aborted command\n"); break; default: fprintf(stderr, "Format command failed\n"); break; } if (res) return res; if (! immed) return 0; printf("\nFormat has started\n"); if (early) { if (immed) printf("Format continuing,\n request sense or " "test unit ready can be used to monitor " "progress\n"); return 0; } verb = (verbose > 1) ? (verbose - 1) : 0; for(;;) { sleep_for(POLL_DURATION_SECS); progress = -1; res = sg_ll_test_unit_ready_progress(fd, 0, &progress, 0, verb); if (progress >= 0) printf("Format in progress, %d%% done\n", (progress * 100) / 65536); else break; } printf("FORMAT Complete\n"); return 0; }
/* =============================================================== * * DEMO * * ===============================================================*/ int main(void) { long dt; long started; int running = 1; XWindow xw; struct nk_context *ctx; /* X11 */ memset(&xw, 0, sizeof xw); xw.dpy = XOpenDisplay(NULL); if (!xw.dpy) die("Could not open a display; perhaps $DISPLAY is not set?"); xw.root = DefaultRootWindow(xw.dpy); xw.screen = XDefaultScreen(xw.dpy); xw.vis = XDefaultVisual(xw.dpy, xw.screen); xw.cmap = XCreateColormap(xw.dpy,xw.root,xw.vis,AllocNone); xw.swa.colormap = xw.cmap; xw.swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPress | ButtonReleaseMask| ButtonMotionMask | Button1MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask| PointerMotionMask | KeymapStateMask; xw.win = XCreateWindow(xw.dpy, xw.root, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, XDefaultDepth(xw.dpy, xw.screen), InputOutput, xw.vis, CWEventMask | CWColormap, &xw.swa); XStoreName(xw.dpy, xw.win, "X11"); XMapWindow(xw.dpy, xw.win); XGetWindowAttributes(xw.dpy, xw.win, &xw.attr); xw.width = (unsigned int)xw.attr.width; xw.height = (unsigned int)xw.attr.height; /* GUI */ xw.font = nk_xfont_create(xw.dpy, "fixed"); ctx = nk_xlib_init(xw.font, xw.dpy, xw.screen, xw.win, xw.width, xw.height); /* style.c */ /*set_style(ctx, THEME_WHITE);*/ /*set_style(ctx, THEME_RED);*/ /*set_style(ctx, THEME_BLUE);*/ /*set_style(ctx, THEME_DARK);*/ while (running) { /* Input */ XEvent evt; started = timestamp(); nk_input_begin(ctx); while (XCheckWindowEvent(xw.dpy, xw.win, xw.swa.event_mask, &evt)){ if (XFilterEvent(&evt, xw.win)) continue; nk_xlib_handle_event(xw.dpy, xw.screen, xw.win, &evt); } nk_input_end(ctx); /* GUI */ {struct nk_panel layout; if (nk_begin(ctx, &layout, "Demo", nk_rect(50, 50, 200, 200), NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE| NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE)) { enum {EASY, HARD}; static int op = EASY; static int property = 20; nk_layout_row_static(ctx, 30, 80, 1); if (nk_button_label(ctx, "button")) fprintf(stdout, "button pressed\n"); nk_layout_row_dynamic(ctx, 30, 2); if (nk_option_label(ctx, "easy", op == EASY)) op = EASY; if (nk_option_label(ctx, "hard", op == HARD)) op = HARD; nk_layout_row_dynamic(ctx, 25, 1); nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1); } nk_end(ctx);} if (nk_window_is_closed(ctx, "Demo")) break; /* -------------- EXAMPLES ---------------- */ /*calculator(ctx);*/ /*overview(ctx);*/ /*node_editor(ctx);*/ /* ----------------------------------------- */ /* Draw */ XClearWindow(xw.dpy, xw.win); nk_xlib_render(xw.win, nk_rgb(30,30,30)); XFlush(xw.dpy); /* Timing */ dt = timestamp() - started; if (dt < DTIME) sleep_for(DTIME - dt); } nk_xfont_del(xw.dpy, xw.font); nk_xlib_shutdown(); XUnmapWindow(xw.dpy, xw.win); XFreeColormap(xw.dpy, xw.cmap); XDestroyWindow(xw.dpy, xw.win); XCloseDisplay(xw.dpy); return 0; }
TEST_F(TestUpdateable, Stop) { Start(); sleep_for(.1*s); Stop(); ASSERT_GT(_x, 0); }
bool CThreadInterrupt::sleep_for(std::chrono::minutes rel_time) { return sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(rel_time)); }
int main(int argc, char *argv[]) { long dt; long started; XWindow xw; struct demo_gui gui; /* Platform */ UNUSED(argc); UNUSED(argv); memset(&xw, 0, sizeof xw); xw.dpy = XOpenDisplay(NULL); xw.root = DefaultRootWindow(xw.dpy); xw.screen = XDefaultScreen(xw.dpy); xw.vis = XDefaultVisual(xw.dpy, xw.screen); xw.cmap = XCreateColormap(xw.dpy,xw.root,xw.vis,AllocNone); xw.swa.colormap = xw.cmap; xw.swa.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPress | ButtonReleaseMask| ButtonMotionMask | Button1MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask| PointerMotionMask; xw.win = XCreateWindow(xw.dpy, xw.root, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, XDefaultDepth(xw.dpy, xw.screen), InputOutput, xw.vis, CWEventMask | CWColormap, &xw.swa); XStoreName(xw.dpy, xw.win, "X11"); XMapWindow(xw.dpy, xw.win); XGetWindowAttributes(xw.dpy, xw.win, &xw.attr); xw.width = (unsigned int)xw.attr.width; xw.height = (unsigned int)xw.attr.height; xw.surf = surface_create(xw.dpy, xw.screen, xw.win, xw.width, xw.height); xw.font = font_create(xw.dpy, "fixed"); /* GUI */ memset(&gui, 0, sizeof gui); zr_command_queue_init_fixed(&gui.queue, calloc(MAX_MEMORY, 1), MAX_MEMORY); gui.font.userdata = zr_handle_ptr(xw.font); gui.font.height = (zr_float)xw.font->height; gui.font.width = font_get_text_width; init_demo(&gui); while (gui.running) { /* Input */ XEvent evt; started = timestamp(); zr_input_begin(&gui.input); while (XCheckWindowEvent(xw.dpy, xw.win, xw.swa.event_mask, &evt)) { if (evt.type == KeyPress) key(&xw, &gui.input, &evt, zr_true); else if (evt.type == KeyRelease) key(&xw, &gui.input, &evt, zr_false); else if (evt.type == ButtonPress) btn(&gui.input, &evt, zr_true); else if (evt.type == ButtonRelease) btn(&gui.input, &evt, zr_false); else if (evt.type == MotionNotify) motion(&gui.input, &evt); else if (evt.type == Expose || evt.type == ConfigureNotify) resize(&xw, xw.surf); } zr_input_end(&gui.input); /* GUI */ run_demo(&gui); /* Draw */ XClearWindow(xw.dpy, xw.win); surface_clear(xw.surf, 0x00646464); draw(xw.surf, &gui.queue); surface_blit(xw.win, xw.surf, xw.width, xw.height); XFlush(xw.dpy); /* Timing */ dt = timestamp() - started; if (dt < DTIME) sleep_for(DTIME - dt); } free(zr_buffer_memory(&gui.queue.buffer)); font_del(xw.dpy, xw.font); surface_del(xw.surf); XUnmapWindow(xw.dpy, xw.win); XFreeColormap(xw.dpy, xw.cmap); XDestroyWindow(xw.dpy, xw.win); XCloseDisplay(xw.dpy); return 0; }