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