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