void service_delete(struct service_t * service) { if (service) { if (service->lparser) lua_close(service->lparser); if (service->timer) timer_destroy(service->timer); FREE(service); } }
/// test few results known as good static void test_t1(void **state) { (void) state; // unused ptr_exp2 = 0; tv_exp1.tv_sec = 0; tv_exp1.tv_usec = 0; tv_exp2.tv_sec = 0; tv_exp2.tv_usec = 0; timer_t *timer = timer_create(); assert_non_null(timer); assert_true(timer_register(timer, callback1, (void *)1000)); tv_exp1.tv_usec = 1; timer_tick(timer, false, 1); timer_cancel(timer, callback1, (void *)1000); assert_true(timer_register(timer, callback1, (void *)1000)); assert_false(timer_register(timer, callback1, (void *)1000)); assert_true(timer_register(timer, callback2, (void *)0x100)); assert_true(timer_register(timer, callback2, (void *)0x200)); timer_cancel(timer, callback1, (void *)1000); timer_cancel(timer, callback1, (void *)1000); tv_exp1.tv_usec = -1; tv_exp2.tv_usec = 3; timer_tick(timer, false, 2); assert_int_equal(ptr_exp2, 0x300); timer_destroy(timer); }
void program_scheduler_destroy(ProgramScheduler *program_scheduler) { program_scheduler_shutdown(program_scheduler); if (program_scheduler->last_spawned_process != NULL) { object_remove_internal_reference(&program_scheduler->last_spawned_process->base); } if (program_scheduler->message != NULL) { string_unlock_and_release(program_scheduler->message); } timer_destroy(&program_scheduler->timer); string_unlock_and_release(program_scheduler->dev_null_file_name); free(program_scheduler->log_directory); if (program_scheduler->absolute_stderr_file_name != NULL) { string_unlock_and_release(program_scheduler->absolute_stderr_file_name); } if (program_scheduler->absolute_stdout_file_name != NULL) { string_unlock_and_release(program_scheduler->absolute_stdout_file_name); } if (program_scheduler->absolute_stdin_file_name != NULL) { string_unlock_and_release(program_scheduler->absolute_stdin_file_name); } if (program_scheduler->absolute_working_directory != NULL) { string_unlock_and_release(program_scheduler->absolute_working_directory); } }
static int detach(void *client_data, int idx) { connect_info_t *connect_info = (connect_info_t *) client_data; if (connect_info->timer_id != -1) timer_destroy(connect_info->timer_id); // sockbuf_detach_filter(idx, &net_connect_filter, NULL); free(connect_info); return(0); }
/* testet, ob der Computer schnell genug für das Atomfeld ist */ gboolean afield_benchmark(GtkWidget *darea, AtomField *af, gdouble max_t) { MyTimer *timer; gulong i; timer = timer_new(1.0); for (i = 0; i < af->number; i++) { if (timer_elapsed(timer) > max_t) { timer_destroy(timer); return FALSE; } afield_draw_atom(darea, af, i); } timer_destroy(timer); return TRUE; }
static int dcc_recv_connect(void *client_data, int idx, const char *peer_ip, int peer_port) { dcc_send_t *send = client_data; /* send->connect_time holds our connect timer if there was one */ if (send->timer_id >= 0) timer_destroy(send->timer_id); timer_get_now_sec(&send->connect_time); sockbuf_on_connect(idx, DCC_FILTER_LEVEL, peer_ip, peer_port); return(0); }
void game_destroy(Game* game) { timer_destroy(game->timer); scene_destroy(game->scene); SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Destroy Vertex Arrays.\n"); glDeleteVertexArrays(1, &game->vao_id); SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Destroy GL context.\n"); glcontext_destroy(game->gl); window_destroy(game->window); free(game); }
int main() { bool auto_reload = true; task_t task1; create_timer(&tt, "name", 500, auto_reload, NULL, (task_routine_t)handle_sig); system_init(); task_create(&task1, task, NULL, NULL, 0, 0); system_start(); timer_destroy(tt); return 0; }
int main(int argc, char *argv[]) { struct timer *timer = timer_new(); sleep(1); printf("Elapsed: %lu ms\n", timer_elapsed(timer, NULL)); timer_stop(timer); sleep(1); printf("Elapsed: %lu ms\n", timer_elapsed(timer, NULL)); timer_continue(timer); sleep(1); printf("Elapsed: %lu ms\n", timer_elapsed(timer, NULL)); timer_destroy(&timer); return 0; }
void timers_remove(uint8_t pos) { if(selected==pos){ selected=-1; } if(selected>pos){ selected--; } if(timer_getDirection(timers[pos])==TIMER_DIRECTION_UP){ count->stopwatch--; }else{ count->timer--; } timer_destroy(timers[pos]); for(uint8_t i=pos;i<timers_count();i++){ timers[i]=timers[i+1]; } timers_updateNearest(); }
static int dcc_recv_delete(void *client_data, int idx) { dcc_send_t *send = client_data; dcc_send_t *prev, *ptr; if (send->timer_id != -1) timer_destroy(send->timer_id); if (send->fd != -1) close(send->fd); if (send->fname) free(send->fname); if (send->nick) free(send->nick); if (send->ip) free(send->ip); prev = NULL; for (ptr = dcc_recv_head; ptr; ptr = ptr->next) { if (ptr == send) break; prev = ptr; } if (prev) prev->next = send->next; else dcc_recv_head = send->next; free(send); return(0); }
void udelay(int us) { u8 heap[0x10]; u32 msg; s32 mqueue = -1; s32 timer = -1; mqueue = mqueue_create(heap, 1); if(mqueue < 0) goto out; timer = timer_create(us, 0, mqueue, 0xbabababa); if(timer < 0) goto out; mqueue_recv(mqueue, &msg, 0); out: if(timer > 0) timer_destroy(timer); if(mqueue > 0) mqueue_destroy(mqueue); }
static int dcc_listen_delete(event_owner_t *owner, void *client_data) { dcc_listen_t *listen = client_data; /* If the timer is still going, kill it. */ if (listen->timer_id != -1) { timer_destroy(listen->timer_id); listen->timer_id = -1; } /* If we're still waiting for the connection to come in, then send * an error to the associated client sock. */ if (sockbuf_isvalid(listen->client)) { if (listen->timeout) { sockbuf_on_eof(listen->client, SOCKBUF_LEVEL_INTERNAL, -1, "DCC timed out"); } else { sockbuf_on_eof(listen->client, SOCKBUF_LEVEL_INTERNAL, -2, "DCC listening socket unexpectedly closed"); } } free(listen); return(0); }
void storage_load(){ APP_LOG(APP_LOG_LEVEL_INFO,"storage_load()"); if(!persist_exists(STORAGE_KEY_VERSION)){ APP_LOG(APP_LOG_LEVEL_WARNING,"no version"); return; } if(persist_read_int(STORAGE_KEY_VERSION)!=STORAGE_VERSION){ APP_LOG(APP_LOG_LEVEL_WARNING,"wrong version"); return; } if(!persist_exists(STORAGE_KEY_COUNT)){ APP_LOG(APP_LOG_LEVEL_ERROR,"no count"); return; } uint8_t storage_count=(uint8_t)persist_read_int(STORAGE_KEY_COUNT); APP_LOG(APP_LOG_LEVEL_INFO,"storage count: %d",storage_count); Timer* timer; int result; for(uint8_t i=0;i<storage_count;i++){ if(!persist_exists(STORAGE_KEY_DATA+i)){ APP_LOG(APP_LOG_LEVEL_ERROR,"missing timer %d in storage %d",i,STORAGE_KEY_DATA+i); continue; } timer=timer_create(); result=persist_read_data(STORAGE_KEY_DATA+i,timer,sizeof(Timer)); if(result<0){ APP_LOG(APP_LOG_LEVEL_ERROR,"read error timer %d in storage %d",i,STORAGE_KEY_DATA+i); timer_destroy(timer); continue; } timers_add(timer); APP_LOG(APP_LOG_LEVEL_INFO,"loaded timer %d",i); } APP_LOG(APP_LOG_LEVEL_INFO,"loaded"); }
int main(int argc, char *argv[]) { bcm2835_init(); timer_init(); tlc_init(); printf("got back!\n"); fflush (stdout); for (int i=0; i<16; i++) tlc_set_duty_cycle(i, 4095); //tlc_pack_send_buffer(); //tlc_update_gpio(); // sleep(15); usleep(5000); // for (int i=0; i<16; i++) // tlc_set_duty_cycle(i, 2048); tlc_set_duty_cycle(15, 2048); usleep(5000); printf("Run successful\n"); tlc_destroy(); timer_destroy(); bcm2835_close(); return 0; }
void gt_release() { lock_delete(gT->mLock); timer_destroy(gT->mTimer); free(gT); }
// destructor CE_Network_Loading::~CE_Network_Loading() { timer_destroy(t_settle); }
// main program int main (int argc, char **argv) { // command-line options int verbose = 1; int ppm_error = 0; int gain = 0; unsigned int nfft = 64; float offset = -65.0f; float scale = 5.0f; float fft_rate = 10.0f; float rx_resamp_rate; float bandwidth = 800e3f; unsigned int logsize = 4096; char filename[256] = "rtl_asgram.dat"; int r, n_read; uint32_t frequency = 100000000; uint32_t samp_rate = DEFAULT_SAMPLE_RATE; uint32_t out_block_size = DEFAULT_BUF_LENGTH; uint8_t *buffer; int dev_index = 0; int dev_given = 0; struct sigaction sigact; normalizer_t *norm; // int d; while ((d = getopt(argc,argv,"hf:b:B:G:n:p:s:o:r:L:F:")) != EOF) { switch (d) { case 'h': usage(); return 0; case 'f': frequency = atof(optarg); break; case 'b': bandwidth = atof(optarg); break; case 'B': out_block_size = (uint32_t)atof(optarg); break; case 'G': gain = (int)(atof(optarg) * 10); break; case 'n': nfft = atoi(optarg); break; case 'o': offset = atof(optarg); break; case 'p': ppm_error = atoi(optarg); break; case 's': samp_rate = (uint32_t)atofs(optarg); break; case 'r': fft_rate = atof(optarg); break; case 'L': logsize = atoi(optarg); break; case 'F': strncpy(filename,optarg,255); break; case 'd': dev_index = verbose_device_search(optarg); dev_given = 1; break; default: usage(); return 1; } } // validate parameters if (fft_rate <= 0.0f || fft_rate > 100.0f) { fprintf(stderr,"error: %s, fft rate must be in (0, 100) Hz\n", argv[0]); exit(1); } if (!dev_given) { dev_index = verbose_device_search("0"); } if (dev_index < 0) { exit(1); } r = rtlsdr_open(&dev, (uint32_t)dev_index); if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); } sigact.sa_handler = sighandler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = 0; sigaction(SIGINT, &sigact, NULL); sigaction(SIGTERM, &sigact, NULL); sigaction(SIGQUIT, &sigact, NULL); sigaction(SIGPIPE, &sigact, NULL); /* Set the sample rate */ verbose_set_sample_rate(dev, samp_rate); /* Set the frequency */ verbose_set_frequency(dev, frequency); if (0 == gain) { /* Enable automatic gain */ verbose_auto_gain(dev); } else { /* Enable manual gain */ gain = nearest_gain(dev, gain); verbose_gain_set(dev, gain); } verbose_ppm_set(dev, ppm_error); rx_resamp_rate = bandwidth/samp_rate; printf("frequency : %10.4f [MHz]\n", frequency*1e-6f); printf("bandwidth : %10.4f [kHz]\n", bandwidth*1e-3f); printf("sample rate : %10.4f kHz = %10.4f kHz * %8.6f\n", samp_rate * 1e-3f, bandwidth * 1e-3f, 1.0f / rx_resamp_rate); printf("verbosity : %s\n", (verbose?"enabled":"disabled")); unsigned int i; // add arbitrary resampling component msresamp_crcf resamp = msresamp_crcf_create(rx_resamp_rate, 60.0f); assert(resamp); // create buffer for sample logging windowcf log = windowcf_create(logsize); // create ASCII spectrogram object float maxval; float maxfreq; char ascii[nfft+1]; ascii[nfft] = '\0'; // append null character to end of string asgram q = asgram_create(nfft); asgram_set_scale(q, offset, scale); // assemble footer unsigned int footer_len = nfft + 16; char footer[footer_len+1]; for (i=0; i<footer_len; i++) footer[i] = ' '; footer[1] = '['; footer[nfft/2 + 3] = '+'; footer[nfft + 4] = ']'; sprintf(&footer[nfft+6], "%8.3f MHz", frequency*1e-6f); unsigned int msdelay = 1000 / fft_rate; // create/initialize Hamming window float w[nfft]; for (i=0; i<nfft; i++) w[i] = hamming(i,nfft); //allocate recv buffer buffer = malloc(out_block_size * sizeof(uint8_t)); assert(buffer); // create buffer for arbitrary resamper output int b_len = ((int)(out_block_size * rx_resamp_rate) + 64) >> 1; complex float buffer_resamp[b_len]; debug("resamp_buffer_len: %d", b_len); // timer to control asgram output timer t1 = timer_create(); timer_tic(t1); norm = normalizer_create(); verbose_reset_buffer(dev); while (!do_exit) { // grab data from device r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read); if (r < 0) { fprintf(stderr, "WARNING: sync read failed.\n"); break; } if ((bytes_to_read > 0) && (bytes_to_read < (uint32_t)n_read)) { n_read = bytes_to_read; do_exit = 1; } // push data through arbitrary resampler and give to frame synchronizer // TODO : apply bandwidth-dependent gain for (i=0; i<n_read/2; i++) { // grab sample from usrp buffer complex float rtlsdr_sample = normalizer_normalize(norm, *((uint16_t*)buffer+i)); // push through resampler (one at a time) unsigned int nw; msresamp_crcf_execute(resamp, &rtlsdr_sample, 1, buffer_resamp, &nw); // push resulting samples into asgram object asgram_push(q, buffer_resamp, nw); // write samples to log windowcf_write(log, buffer_resamp, nw); } if ((uint32_t)n_read < out_block_size) { fprintf(stderr, "Short read, samples lost, exiting!\n"); break; } if (bytes_to_read > 0) bytes_to_read -= n_read; if (timer_toc(t1) > msdelay*1e-3f) { // reset timer timer_tic(t1); // run the spectrogram asgram_execute(q, ascii, &maxval, &maxfreq); // print the spectrogram printf(" > %s < pk%5.1fdB [%5.2f]\n", ascii, maxval, maxfreq); printf("%s\r", footer); fflush(stdout); } } // try to write samples to file FILE * fid = fopen(filename,"w"); if (fid != NULL) { // write header fprintf(fid, "# %s : auto-generated file\n", filename); fprintf(fid, "#\n"); fprintf(fid, "# num_samples : %u\n", logsize); fprintf(fid, "# frequency : %12.8f MHz\n", frequency*1e-6f); fprintf(fid, "# bandwidth : %12.8f kHz\n", bandwidth*1e-3f); // save results to file complex float * rc; // read pointer windowcf_read(log, &rc); for (i=0; i<logsize; i++) fprintf(fid, "%12.4e %12.4e\n", crealf(rc[i]), cimagf(rc[i])); // close it up fclose(fid); printf("results written to '%s'\n", filename); } else { fprintf(stderr,"error: %s, could not open '%s' for writing\n", argv[0], filename); } // destroy objects normalizer_destroy(&norm); msresamp_crcf_destroy(resamp); windowcf_destroy(log); asgram_destroy(q); timer_destroy(t1); rtlsdr_close(dev); free (buffer); return 0; }