static bool initialize(uint32_t *timer_period) { log_info("initialise: started"); // Get the address this core's DTCM data starts at from SRAM address_t address = data_specification_get_data_address(); // Read the header if (!data_specification_read_header(address)) { return false; } // Get the timing details and set up the simulation interface if (!simulation_initialise( data_specification_get_region(0, address), APPLICATION_NAME_HASH, timer_period, &simulation_ticks, &infinite_run, SDP, DMA)) { return false; } // Get the parameters read_parameters(data_specification_get_region(1, address)); log_info("initialise: completed successfully"); return true; }
static bool initialize(uint32_t *timer_period) { log_info("initialize: started"); // Get the address this core's DTCM data starts at from SRAM address_t address = data_specification_get_data_address(); // Read the header if (!data_specification_read_header(address)) { return false; } // Get the timing details if (!simulation_read_timing_details( data_specification_get_region(0, address), APPLICATION_MAGIC_NUMBER, timer_period, &simulation_ticks)) { return false; } // Get the parameters if (!read_parameters(data_specification_get_region(1, address))) { return false; } log_info("initialize: completed successfully"); return true; }
int main(int argc, char *argv[]) { char *conffile = NULL; int request_kill = 0, show_message = 0; if (!read_parameters(argc, argv, &conffile, &request_kill, &show_message)) { print_usage(argv[0]); return 1; } /* read the config file; conffile = NULL means use the default. */ if (!read_config(conffile)) return 1; /* error reading the config file */ setup_defaults(); if (request_kill) { kill_server(); return 0; } if (show_message) { signal_message(); return 0; } setup_signals(); /* Init files and directories. * Start logging last, so that the log is only created if startup succeeds. */ if (!init_workdir() || !init_database() || !check_database() || !begin_logging()) return 1; if (!settings.nodaemon) { if (daemon(0, 0) == -1) { settings.nodaemon = TRUE; log_msg("could not detach from terminal: %s", strerror(errno)); return 1; } if (!create_pidfile()) return 1; } /* give this process and its children their own process group id for kill() */ setpgid(0, 0); report_startup(); runserver(); /* shutdown */ remove_pidfile(); end_logging(); close_database(); remove_unix_socket(); free_config(); return 0; }
carmen_camera_image_t *carmen_camera_start(int argc, char **argv) { carmen_camera_image_t *image; read_parameters(argc, argv); carmen_warn("Opening camera\n"); camera_fd = open(camera_dev, O_RDONLY | O_NOCTTY); if (camera_fd < 0) carmen_die_syserror("Could not open %s as camera device", camera_dev); check_camera_type(); setup_camera(); image = (carmen_camera_image_t *)calloc(1, sizeof(carmen_camera_image_t)); image->width = image_width; image->height = image_height; image->bytes_per_pixel = 3; image->image_size = image->width*image->height*image->bytes_per_pixel; image->is_new = 0; image->timestamp = 0; image->image = (char *)calloc(image->image_size, sizeof(char)); carmen_test_alloc(image->image); memset(image->image, 0, image->image_size*sizeof(char)); return image; }
int main(int argc, char **argv) { /* Read command line arguments */ read_command_line(argc,argv); /* Read Parameters from parameter file */ read_parameters(); /* read box from file header */ if (box_from_header) read_box(infilename); /* Initialize cell data structures */ init_cells(); /* Read coordinates and displacement */ read_displacement(infilename); /* Calculate strain tensor */ calc_strain(); /* Output strain tensor */ write_data(); return 0; }
int main(int argc, char **argv) { const Pvoid_t params = read_parameters(); test_param(params, "test1", "1,2,3"); test_param(params, "one two three", "dim\ndam\n"); test_param(params, "dummy", "value"); msg("All parameters ok!"); const char DVAL[] = "dkey"; p_entry *dkey = dxmalloc(sizeof(p_entry) + sizeof(DVAL)); dkey->len = sizeof(DVAL) - 1; memcpy(dkey->data, DVAL, dkey->len); int i = 0; p_entry *key = NULL; p_entry *val = NULL; while (read_kv(&key, &val)){ msg("Got key <%s> val <%s>", key->data, val->data); if (!key->len) key = dkey; write_num_prefix(3); write_kv(key, val); write_kv(key, val); write_kv(key, val); ++i; } msg("%d key-value pairs read ok", i); return 0; }
int main(int argc, char *argv[]) { int gps_nr = 0; SerialDevice dev; carmen_gps_gpgga_message gpgga; carmen_gps_gprmc_message gprmc; carmen_erase_structure(&gpgga, sizeof(carmen_gps_gpgga_message) ); carmen_erase_structure(&gprmc, sizeof(carmen_gps_gprmc_message) ); gpgga.host = carmen_get_host(); gprmc.host = carmen_get_host(); DEVICE_init_params( &dev ); carmen_ipc_initialize( argc, argv ); ipc_initialize_messages(); read_parameters( &dev, argc, argv ); carmen_extern_gpgga_ptr = &gpgga; carmen_extern_gpgga_ptr->nr = gps_nr; carmen_extern_gprmc_ptr = &gprmc; carmen_extern_gprmc_ptr->nr = gps_nr; fprintf( stderr, "INFO: ************************\n" ); fprintf( stderr, "INFO: ********* GPS ********\n" ); fprintf( stderr, "INFO: ************************\n" ); fprintf( stderr, "INFO: open device: %s\n", dev.ttyport ); if (DEVICE_connect_port( &dev )<0) { fprintf( stderr, "ERROR: can't open device !!!\n\n" ); exit(1); } else { fprintf( stderr, "INFO: done\n" ); } while(TRUE) { if ( DEVICE_bytes_waiting( dev.fd )>10 ) { if (DEVICE_read_data( dev )) { gpgga.timestamp = carmen_get_time(); gprmc.timestamp = carmen_get_time(); ipc_publish_position(); } usleep(100000); } else { carmen_ipc_sleep(0.25); //IPC_listen(0); //usleep(250000); } } return(0); }
int main( int argc, char *argv[] ) { //Individual halos struct halo *halos; halos = (struct halo *)calloc( MAXHALOS, sizeof( struct halo ) ); //Halo pairs struct pair *pairs; pairs = (struct pair *)calloc( MAXPAIRS, sizeof( struct pair ) ); //Isolated halo pairs struct pair *isopair; isopair = (struct pair *)calloc( MAXIPAIR, sizeof( struct pair ) ); int i,j; int k, l; char filename[NMAX1]; float p[NMAX1]; struct region regions[NMAX2][NMAX2][NMAX2]; int index[NMAX1][3]; FILE *script; printf( "\n\n************************ HALO PAIR FINDER ***********************\n" ); //Load Configuration----------------------------------------------------------------------- read_parameters( p, "parameters.conf" ); //Load Processed input datafile------------------------------------------------------------ //Input Filename sprintf( filename, "%s", argv[1] ); p[NDAT] = data_in( halos, filename, p[NAXE] ); //Neighborhood Construction---------------------------------------------------------------- make_regions( regions, halos, p[NDAT], p[NAXE], p[LBOX], index ); printf( " * Datafile of halos has been sorted in octant regions!\n" ); printf( " * Neighborhood construction done!\n" ); //Halo Pair construction------------------------------------------------------------------- pair_finder( halos, pairs, isopair, regions, index, p ); printf( " * Halo pairs have been found!\n" ); printf( " * %d Halos in Mass Range Found!\n", (int)p[HRMAS] ); //Saving Halo Pairs General Sample -------------------------------------------------------- data_pair_out( pairs, halos, "Pairs.dat", p[PAIR] ); printf( " * %d General Halo Pairs Found!\tData in 'Pairs.dat'\n", (int)p[PAIR] ); //Saving Halo Pairs Isolated Sample -------------------------------------------------------- data_pair_out( isopair, halos, "IsoPairs.dat", p[ISOPAIR] ); printf( " * %d Isolated Halo Pairs Found!\tData in 'IsoPairs.dat'\n", (int)p[ISOPAIR] ); return 0; }
int carmen_hokuyo_start(int argc, char **argv) { /* initialize laser messages */ ipc_initialize_messages(); /* get laser parameters */ set_default_parameters(&hokuyo); read_parameters(argc, argv); printf("starting device\n"); hokuyo_start(&hokuyo); return 0; }
int main(int argc, char *argv[]) { blind_t my_bp; blind_t* bp = &my_bp; solver_t* sp = &(bp->solver); log_init(LOG_MSG); fits_use_error_system(); if (argc == 2 && strcmp(argv[1], "-s") == 0) { log_set_level(LOG_NONE); fprintf(stderr, "premptive silence\n"); } // Read input settings until "run" is encountered; repeat. for (;;) { tic(); blind_init(bp); // must be in this order because init_parameters handily zeros out sp solver_set_default_values(sp); if (read_parameters(bp)) { solver_cleanup(sp); blind_cleanup(bp); break; } if (!blind_parameters_are_sane(bp, sp)) { exit(-1); } if (blind_is_run_obsolete(bp, sp)) { goto clean; } blind_log_run_parameters(bp); blind_run(bp); toc(); if (bp->hit_total_timelimit) break; if (bp->hit_total_cpulimit) break; clean: solver_cleanup(sp); blind_cleanup(bp); } return 0; }
void get_parameters(struct parameters *params) { int file_error; if (params->rank == 0) file_error = read_parameters(params); int mpi_error = MPI_Bcast(&file_error, 1, MPI_INT, 0, MPI_COMM_WORLD); if (mpi_error) fatal_error("in get_parameters for MPI_Bcast"); if (file_error) fatal_error("in read_parameters: unable to read setup file"); distribute_parameters(params); }
void Energy::initiate() { FILE * reporter = fopen("out.txt","w"); // write out to out file writeDescription(reporter); are_coefficients_set = false; // read parameters from file read_parameters(); return; }
Carmen_Thread::Carmen_Thread(int argc, char **argv) { this->argc = argc; this->argv = argv; if(singleton == NULL) { singleton = this; } carmen_ipc_initialize(argc, argv); carmen_param_check_version(argv[0]); read_parameters(argc, argv); declare_messages(); register_meta_types(); }
Energy::Energy(FILE * reporter, vector<Soup *> proteins_in, vector<Soup *> ligands_in):Method(reporter) { /*** write out to out file **/ writeDescription(reporter); /*** do A and B have equal lengths? ***/ if(proteins.size() != ligands.size()) { cout << "WARNING: An equal amount of protein and ligand structures must be given to the energy function!\n"; return; } are_coefficients_set = false; /*** copy structures and read in setup ***/ proteins = proteins_in;ligands = ligands_in; read_parameters(); /*** set parameters ***/ // Generalparameters prepA(rep,proteins); // Generalparameters prepB(rep,ligands); simple_parameters.prepare(proteins); simple_parameters.prepare(ligands); /*** set targets ***/ generate_target_vector(); test(); if(mode == "train") train(); /*** write out matrices for octave ***/ Matrix_IO M(rep); M.open("binding.m"); M.write_matrix("A", A); M.write_vector("b",b); M.update_lists(names,A,b); M.write_string_vector("Names",names); M.close(); if(are_coefficients_set) stream_results(); }
void MSC::initiate() { FILE * reporter = fopen("out.txt","w"); //resultsFile = fopen(res.c_str(),"w"); // write out to out file writeDescription(reporter); coefficients_are_set = 0; // read parameters from file read_parameters(); }
int main(int argc, char **argv) { carmen_ipc_initialize(argc, argv); carmen_param_check_version(argv[0]); read_parameters(argc, argv, &car_config); carmen_localize_ackerman_subscribe_globalpos_message(&globalpos, NULL, CARMEN_SUBSCRIBE_LATEST); carmen_ipc_addPeriodicTimer(0.1, (TIMER_HANDLER_TYPE) build_points_vector_handler, NULL); carmen_ipc_dispatch(); return 0; }
int main(int argc, char **argv) { /* Connect to IPC Server */ carmen_ipc_initialize(argc, argv); /* Check the param server version */ carmen_param_check_version(argv[0]); /* Initialize vector of readings laser */ /* Initialize vector of static points */ /* Initialize all the relevant parameters */ read_parameters(argc, argv); /* Register shutdown cleaner handler */ signal(SIGINT, shutdown_module); /* Define messages that your module publishes */ carmen_moving_objects_point_clouds_define_messages(); /* Subscribe to sensor and filter messages */ carmen_localize_ackerman_subscribe_globalpos_message(NULL, (carmen_handler_t) localize_ackerman_handler, CARMEN_SUBSCRIBE_LATEST); carmen_velodyne_subscribe_partial_scan_message(NULL, (carmen_handler_t) velodyne_partial_scan_message_handler, CARMEN_SUBSCRIBE_LATEST); carmen_stereo_velodyne_subscribe_scan_message(8, NULL, (carmen_handler_t)velodyne_variable_scan_message_handler, CARMEN_SUBSCRIBE_LATEST); // carmen_localize_ackerman_subscribe_globalpos_message(NULL, // (carmen_handler_t) localize_ackerman_handler, CARMEN_SUBSCRIBE_LATEST); carmen_map_server_subscribe_offline_map(NULL, (carmen_handler_t) carmen_map_server_offline_map_message_handler, CARMEN_SUBSCRIBE_LATEST); carmen_ipc_dispatch(); return (0); }
int main(int argc, char **argv) { int tablesize; int n,i,j,k,l; /* Read command line arguments */ read_command_line(argc,argv); /* Read Parameters from parameter file */ read_parameters(); tablesize = slots*ntypes*ntypes*ntypes*ntypes*sizeof(real); histogram = (real *) malloc(tablesize); if (NULL==histogram) error("Cannot allocate memory for histograms."); hist_dim.n = slots; hist_dim.i = ntypes; hist_dim.j = ntypes; hist_dim.k = ntypes; hist_dim.l = ntypes; for (n=0; n<slots; ++n) for (i=0; i<ntypes; ++i) for (j=0; j<ntypes; ++j) for (k=0; k<ntypes; ++k) for (l=0; l<ntypes; ++l) *PTR_5D_V(histogram,n,i,j,k,l,hist_dim) = 0.0; r2_cut = SQR(r_max); /* read box from file header */ if (box_from_header) read_box(infilename); /* Initialize cell data structures */ init_cells(); /* Read atoms */ read_atoms(infilename); /* Calculate the torsion angles */ calc_angles(); /* Output results */ write_data(); return 0; }
int main(int argc, char *argv[]) { int CONTINUE,WINNER,HUMAN,COMPUTER; if(argc!=4) { fprintf(stderr,"Usage: mnkgame <row> <col> <k>\n"); return 1; } if(!read_parameters(argv)) return 1; if(!setup_game(M,N,K)) { fprintf(stderr,"Error: the board is too big!\n"); return 1; } COMPUTER=1; HUMAN=2; setup_player(M,N,K); printf("Computer Player ready\n"); mypause(); CONTINUE=N*M; WINNER=DRAW; while(CONTINUE>0) { if(read_move(PLAYER1,HUMAN)) { WINNER=PLAYER1; CONTINUE=0; } if(--CONTINUE>0) { if(read_move(PLAYER2,HUMAN)) { WINNER=PLAYER2; CONTINUE=0; } --CONTINUE; } } system("cls"); print_board(); end_game(WINNER,HUMAN); free_player(); free_game(); return 0; }
int test_main() { char fake[200]; char** fakes; int num; int i; read_parameters("i3-proxy.xml"); read_string_par("/parameters/proxy/server_proxy_trigger/server_proxy[@name='sp1']",fake,1); printf("%s\n",fake); fakes = read_strings_par("/parameters/proxy/public_triggers/trigger",&num); printf("Num: %d\n",num); for(i=0;i<num;i++) printf("%s\n",fakes[i]); return 0; }
int main(int argc, char **argv) { carmen_ipc_initialize(argc, argv); carmen_param_check_version(argv[0]); signal(SIGINT, shutdown_module); read_parameters(argc, argv); carmen_visual_tracker_define_messages(); carmen_visual_tracker_subscribe_messages(); carmen_ipc_dispatch(); return (0); }
int main( int argc, char **argv ) { if ( argc < 2 ) { print_help(); exit(1); } else { read_parameters(argc,argv); } // initialize random number generator rnd = new Random((unsigned) time(&t)); // initialize and read instance from file graph = new UndirectedGraph(i_file); GreedyHeuristic gho(graph); for (int i = cardb; i <= carde; i++) { cardinality = i; if ((cardinality == cardb) || (cardinality == carde) || ((cardinality % cardmod) == 0)) { Timer timer; UndirectedGraph* greedyTree = new UndirectedGraph(); if (type == "edge_based") { gho.getGreedyHeuristicResult(greedyTree,cardinality,ls); } else { if (type == "vertex_based") { gho.getVertexBasedGreedyHeuristicResult(greedyTree,cardinality,ls); } } printf("%d\t%f\t%f\n",cardinality,greedyTree->weight(),timer.elapsed_time(Timer::VIRTUAL)); delete(greedyTree); } } delete(graph); delete rnd; }
int main(int argc, char **argv) { double command_tv = 0.0, command_rv = 0.0; char c; int quit = 0; double f_timestamp; carmen_ipc_initialize(argc, argv); carmen_param_check_version(argv[0]); // Initialize keybord, joystick and IPC carmen_initialize_keyboard(); if (carmen_initialize_joystick(&joystick) >= 0) no_joystick = 0; read_parameters(argc, argv); signal(SIGINT, sig_handler); f_timestamp = carmen_get_time(); while(quit>=0) { carmen_ipc_sleep(0.05); if(!no_joystick && carmen_get_joystick_state(&joystick) >= 0) { carmen_joystick_control(&joystick, max_tv, max_rv, &command_tv, &command_rv); carmen_robot_velocity_command(command_tv, command_rv); f_timestamp = carmen_get_time(); } else if(carmen_read_char(&c)) { quit = carmen_keyboard_control(c, max_tv, max_rv, &command_tv, &command_rv); carmen_robot_velocity_command(command_tv, command_rv); f_timestamp = carmen_get_time(); } else if(carmen_get_time() - f_timestamp > 0.5) { carmen_robot_velocity_command(command_tv, command_rv); f_timestamp = carmen_get_time(); } } sig_handler(SIGINT); return 0; }
int main(int argc, char** argv) { signal(SIGINT, shutdown_module); carmen_ipc_initialize(argc, argv); carmen_param_check_version(argv[0]); initialize_structures(); read_parameters(argc, argv, car_config); initialize_ipc(); subscribe_to_relevant_messages(); carmen_ipc_dispatch(); return 0; }
/******************** Functions under design will be moved to .h file*********** void read_parameters(par,); // FIXME void initialize_parameters(par); void read_data(par); // FIXME doulbe do_dedispersion(**input, **resFlf, **resDMT); //FIXME ****************************************************************/ int main() { Parameter par; char parameterFileNm[1024]; double **inputDataPool, **resultFltBank,**resultDM_Time; // 2D arrays double *freqArray, *timeArray, *DMArray; double *DMarray; double DMstep; //test varible double fsBsBn; fsBsBn = 1.0/pow(2,14)*4096.0; printf("reading parameter files\n"); /* Read parameter file*/ sprintf(parameterFileNm, "dedispersionPar.dat"); read_parameters(&par,parameterFileNm); /* Initalize config and check parameters setting */ if(par.poolClumN <= par.resFltClumN || par.poolRowN <= par.resFltRowN) { printf("data pool's column or row should bigger than result's column or\ row.\n"); exit(1); // FIXME std error output }
// ============================================================== int main(int argc, char** argv) // ============================================================== { read_parameters(argc,argv); if (argc-1>num_of_opts) AR = alignment_reader(argv[num_of_opts+1]); else AR = alignment_reader(stdin); alignment_reader::iterator a_it = AR.begin(); alignment_reader::iterator a_fragrep = AR.end(); alignment_reader::iterator a_end = AR.end(); for (; a_it!=a_end; ++a_it) { if (a_it->first=="FRAGREP" || a_it->first=="#=FRAGREP") { block_line = a_it->second; a_fragrep = a_it; } } if (a_fragrep==a_end) { std::cout<<"No block defining sequence found.\n"; return 0; } block_line = a_fragrep->second; AR.erase(a_fragrep); clean_sequences(); GC_ratio = get_GC_ratio(); scan_block_line(); if (!make_matrices) write_pattern(); else { write_matrix_pattern(); //write_eps_output(); } }
int main(int argc, char **argv) { /* Connect to IPC Server */ carmen_ipc_initialize(argc, argv); /* Check the param server version */ carmen_param_check_version(argv[0]); /* Register shutdown cleaner handler */ signal(SIGINT, shutdown_module); /* Read application specific parameters (Optional) */ read_parameters(argc, argv); //Initialize relevant variables parking_assistant_initialize(); carmen_subscribe_to_relevant_messages(); /* Define published messages by your module */ carmen_parking_assistant_define_messages(); /* carmen_behavior_selector_state_message state; state.goal_source = CARMEN_BEHAVIOR_SELECTOR_USER_GOAL; state.algorithm = CARMEN_BEHAVIOR_SELECTOR_A_STAR; state.state = BEHAVIOR_SELECTOR_PARKING; state.parking_algorithm = CARMEN_BEHAVIOR_SELECTOR_A_STAR; state.following_lane_algorithm = CARMEN_BEHAVIOR_SELECTOR_RRT; state.timestamp = carmen_get_time(); state.host = carmen_get_host(); publish_carmen_selector_state_message(&state); */ /* Loop forever waiting for messages */ carmen_ipc_dispatch(); carmen_ipc_disconnect(); return 0; }
double carmen_librlpid_compute_effort(double current_curvature, double desired_curvature, double delta_t) { static bool first_time = true; static rl_data data; if(first_time) { data.params = read_parameters("rlpid_params.txt"); data.pv = initializate_variables(&data); // Step 1 first_time = false; }else // So começa a rodar a partir da segunda iteração { calculate_error_old(desired_curvature, current_curvature, &data); // Step 6 ==> CALCULA ERRO update_neetwork_hidden_unit_phi_future(&data);// ==> UPDATE PHI data.future_critic_value = update_critic_value_future(&data); //Step 7 ==> UPDATE V calculate_td_error(&data); //Step 8 ==> CALCULA ERRO TD load_variables(&data); weights_update(&data); //Step 9 ==> UPDATE PESOS center_vector_update(&data); //Step 10 ==> UPDATE CENTRO width_scalar_update(&data); //Step 10 ==> UPDATE WIDTH SCALAR } //imprime_os_pesos_agora++; load_variables(&data); calculate_error_old(desired_curvature, current_curvature, &data); // Step 2 ==> CALCULA ERRO external_reinforcement_signal(&data); //Step 3 ==> RECOMPENSA update_neetwork_hidden_unit_phi(&data);// ==> UPDATE PHI update_recomended_pid_output(&data); //Step 4 ==> UPDATE K` data.variables.critic_value = update_critic_value_output(&data); //Step 4 ==> UPDATE V update_pid_params(&data); //Step 5 ==> UPDATE K update_plant_input_u(current_curvature, desired_curvature, delta_t, &data); //Step 5 ==> UPDATE U store_variables(&data); printf("u%lf e %f kp %f ki %f kd %f\n", data.variables.U[0], data.variables.error[0], data.variables.pid_params[0], data.variables.pid_params[1], data.variables.pid_params[2]); return data.variables.U[0];//carmen_clamp(-100.0, (U[0]), 100.0); }
int main(int argc, char **argv) { unsigned long mtCount; /* initialize carmen */ //carmen_randomize(&argc, &argv); carmen_ipc_initialize(argc, argv); carmen_param_check_version(argv[0]); mode = 6; settings = 2; const char* pName = NULL; read_parameters(argc, argv); pName = dev; packet = new xsens::Packet((unsigned short) mtCount, cmt3.isXm()); /* Initializing Xsens */ initializeXsens(cmt3, mode, settings, mtCount, (char*)pName); /* Setup exit handler */ signal(SIGINT, shutdown_xsens); /* register localize related messages */ // register_ipc_messages(); carmen_xsens_define_messages(); while(1){ getDataFromXsens(cmt3, packet, mode, settings, g_data); publish_xsens_global(g_data, /*mode,*/ settings); sleep(0.1); } /* Loop forever */ carmen_ipc_dispatch(); return 0; }
void read_input_files(int argc, char** argv) { // only root process reads input files if (g_mpi.myid == 0) { read_parameters(argc, argv); read_pot_table(g_files.startpot); read_config(g_files.config); printf("Global energy weight: %f\n", g_param.eweight); #if defined(STRESS) printf("Global stress weight: %f\n", g_param.sweight); #endif // STRESS /* initialize additional force variables and parameters */ init_force_common(0); init_force(0); g_mpi.init_done = 1; init_rng(g_param.rng_seed); } }