int main(int argc, char **argv) { Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); // robot ArRobot robot; /// our server ArServerBase server; // set up our parser ArArgumentParser parser(&argc, argv); // set up our simple connector ArSimpleConnector simpleConnector(&parser); // set up a gyro ArAnalogGyro gyro(&robot); // load the default arguments parser.loadDefaultArguments(); // parse the command line... fail and print the help if the parsing fails // or if the help was requested if (!simpleConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { simpleConnector.logOptions(); exit(1); } if (!server.loadUserInfo("userServerTest.userInfo")) { printf("Could not load user info, exiting\n"); exit(1); } server.logUsers(); // first open the server up if (!server.open(7272)) { printf("Could not open server port\n"); exit(1); } // sonar, must be added to the robot ArSonarDevice sonarDev; // add the sonar to the robot robot.addRangeDevice(&sonarDev); ArIRs irs; robot.addRangeDevice(&irs); ArBumpers bumpers; robot.addRangeDevice(&bumpers); // a laser in case one is used ArSick sick(361, 180); // add the laser to the robot robot.addRangeDevice(&sick); // attach stuff to the server ArServerInfoRobot serverInfoRobot(&server, &robot); ArServerInfoSensor serverInfoSensor(&server, &robot); ArServerInfoDrawings drawings(&server); drawings.addRobotsRangeDevices(&robot); // ways of moving the robot ArServerModeStop modeStop(&server, &robot); ArServerModeDrive modeDrive(&server, &robot); ArServerModeRatioDrive modeRatioDrive(&server, &robot); ArServerModeWander modeWander(&server, &robot); modeStop.addAsDefaultMode(); modeStop.activate(); // set up the simple commands ArServerHandlerCommands commands(&server); // add the commands for the microcontroller ArServerSimpleComUC uCCommands(&commands, &robot); // add the commands for logging ArServerSimpleComMovementLogging loggingCommands(&commands, &robot); // add the commands for the gyro ArServerSimpleComGyro gyroCommands(&commands, &robot, &gyro); // add the commands to enable and disable safe driving to the simple commands modeDrive.addControlCommands(&commands); // Forward any video if we have some to forward.. this will forward // from SAV or ACTS, you can find both on our website // http://robots.activmedia.com, ACTS is for color tracking and is // charged for but SAV just does software A/V transmitting and is // free to all our customers... just run ACTS or SAV before you // start this program and this class here will forward video from it // to MobileEyes ArHybridForwarderVideo videoForwarder(&server, "localhost", 7070); // make a camera to use in case we have video ArPTZ *camera = NULL; ArServerHandlerCamera *handlerCamera = NULL; // if we have video then set up a camera if (videoForwarder.isForwardingVideo()) { bool invertedCamera = false; camera = new ArVCC4(&robot, invertedCamera, ArVCC4::COMM_UNKNOWN, true, true); camera->init(); handlerCamera = new ArServerHandlerCamera(&server, &robot, camera); } server.logCommandGroups(); server.logCommandGroupsToFile("userServerTest.commandGroups"); // now let it spin off in its own thread server.runAsync(); // set up the robot for connecting if (!simpleConnector.connectRobot(&robot)) { printf("Could not connect to robot... exiting\n"); Aria::shutdown(); return 1; } // set up the laser before handing it to the laser mode simpleConnector.setupLaser(&sick); robot.enableMotors(); // start the robot running, true so that if we lose connection the run stops robot.runAsync(true); sick.runAsync(); // connect the laser if it was requested if (!simpleConnector.connectLaser(&sick)) { printf("Could not connect to laser... exiting\n"); Aria::shutdown(); return 1; } robot.waitForRunExit(); // now exit Aria::shutdown(); exit(0); }
int main(int argc, char **argv) { Aria::init(); ArRobot robot; ArServerBase server; ArArgumentParser parser(&argc, argv); ArSimpleConnector simpleConnector(&parser); ArServerSimpleOpener simpleOpener(&parser); // parse the command line... fail and print the help if the parsing fails // or if help was requested parser.loadDefaultArguments(); if (!simpleConnector.parseArgs() || !simpleOpener.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { simpleConnector.logOptions(); simpleOpener.logOptions(); exit(1); } // Set up where we'll look for files such as config file, user/password file, // etc. char fileDir[1024]; ArUtil::addDirectories(fileDir, sizeof(fileDir), Aria::getDirectory(), "ArNetworking/examples"); // first open the server up if (!simpleOpener.open(&server, fileDir, 240)) { if (simpleOpener.wasUserFileBad()) printf("Error: Bad user/password/permissions file.\n"); else printf("Error: Could not open server port. Use -help to see options.\n"); exit(1); } // Devices ArAnalogGyro gyro(&robot); ArSonarDevice sonarDev; robot.addRangeDevice(&sonarDev); ArIRs irs; robot.addRangeDevice(&irs); ArBumpers bumpers; robot.addRangeDevice(&bumpers); ArSick sick(361, 180); robot.addRangeDevice(&sick); ArServerInfoRobot serverInfoRobot(&server, &robot); ArServerInfoSensor serverInfoSensor(&server, &robot); // This is the service that provides drawing data to the client. ArServerInfoDrawings drawings(&server); // Convenience function that sets up drawings for all the robot's current // range devices (using default shape and color info) drawings.addRobotsRangeDevices(&robot); // Add our custom drawings drawings.addDrawing( // shape: color: size: layer: new ArDrawingData("polyLine", ArColor(255, 0, 0), 2, 49), "exampleDrawing_Home", new ArGlobalFunctor2<ArServerClient*, ArNetPacket*>(&exampleHomeDrawingNetCallback) ); drawings.addDrawing( new ArDrawingData("polyDots", ArColor(0, 255, 0), 250, 48), "exampleDrawing_Dots", new ArGlobalFunctor2<ArServerClient*, ArNetPacket*>(&exampleDotsDrawingNetCallback) ); drawings.addDrawing( new ArDrawingData("polySegments", ArColor(0, 0, 0), 4, 52), "exampleDrawing_XMarksTheSpot", new ArGlobalFunctor2<ArServerClient*, ArNetPacket*>(&exampleXDrawingNetCallback) ); drawings.addDrawing( new ArDrawingData("polyArrows", ArColor(255, 0, 255), 500, 100), "exampleDrawing_Arrows", new ArGlobalFunctor2<ArServerClient*, ArNetPacket*>(&exampleArrowsDrawingNetCallback) ); // modes for moving the robot ArServerModeStop modeStop(&server, &robot); ArServerModeDrive modeDrive(&server, &robot); ArServerModeRatioDrive modeRatioDrive(&server, &robot); ArServerModeWander modeWander(&server, &robot); modeStop.addAsDefaultMode(); modeStop.activate(); // Connect to the robot. if (!simpleConnector.connectRobot(&robot)) { printf("Error: Could not connect to robot... exiting\n"); Aria::shutdown(); return 1; } // set up the laser before handing it to the laser mode simpleConnector.setupLaser(&sick); robot.enableMotors(); // start the robot cycle running in a background thread robot.runAsync(true); // start the laser processing cycle in a background thread sick.runAsync(); // connect the laser if it was requested if (!simpleConnector.connectLaser(&sick)) { printf("Error: Could not connect to laser... exiting\n"); Aria::shutdown(); return 1; } // log whatever we wanted to before the runAsync simpleOpener.checkAndLog(); // run the server thread in the background server.runAsync(); printf("Server is now running...\n"); // Add a key handler mostly that windows can exit by pressing // escape, note that the key handler prevents you from running this program // in the background on Linux. ArKeyHandler *keyHandler; if ((keyHandler = Aria::getKeyHandler()) == NULL) { keyHandler = new ArKeyHandler; Aria::setKeyHandler(keyHandler); robot.lock(); robot.attachKeyHandler(keyHandler); robot.unlock(); printf("To exit, press escape.\n"); } robot.waitForRunExit(); Aria::shutdown(); exit(0); }
int32_t main(int32_t argc, char **argv) { opendlv::core::system::proxy::ProxySick sick(argc, argv); return sick.runModule(); }
int main(int argc, char *argv[]) { // Initialize location of Aria, Arnl and their args. Aria::init(); Arnl::init(); // The robot object ArRobot robot; #ifndef SONARNL // The laser object ArSick sick(181, 361); #endif // Parse them command line arguments. ArArgumentParser parser(&argc, argv); // Set up our simpleConnector ArSimpleConnector simpleConnector(&parser); // Load default arguments for this computer parser.loadDefaultArguments(); // Parse its arguments for the simple connector. simpleConnector.parseArgs(); // sonar, must be added to the robot, for teleop and wander ArSonarDevice sonarDev; // add the sonar to the robot robot.addRangeDevice(&sonarDev); ArMap arMap; #ifndef SONARNL // Initialize the localization ArLocalizationTask locTask(&robot, &sick, &arMap); // Make the path task ArPathPlanningTask pathTask(&robot, &sick, &sonarDev, &arMap); #else // Initialize the localization ArSonarLocalizationTask locTask(&robot, &sonarDev, &arMap); // Make the path task ArPathPlanningTask pathTask(&robot, NULL, &sonarDev, &arMap); #endif // Stop the robot as soon as localization fails. ArFunctor1C<ArPathPlanningTask, int> locaFailed(&pathTask, &ArPathPlanningTask::trackingFailed); locTask.addFailedLocalizationCB(&locaFailed); // Read in param files. Aria::getConfig()->useArgumentParser(&parser); if (!Aria::getConfig()->parseFile(Arnl::getTypicalParamFileName())) { printf("Trouble loading configuration file, exiting\n"); exit(1); } // Warn about unknown params. if (!parser.checkHelpAndWarnUnparsed()) { printf("\nUsage: %s -map mapfilename\n\n", argv[0]); simpleConnector.logOptions(); exit(2); } // Our server ArServerBase server; // First open the server up if (!server.open(7272)) { printf("Could not open server port\n"); exit(1); } // Connect the robot if (!simpleConnector.connectRobot(&robot)) { printf("Could not connect to robot... exiting\n"); Aria::shutdown(); return 1; } robot.com2Bytes(31, 14, 0); robot.com2Bytes(31, 15, 0); ArUtil::sleep(100); robot.com2Bytes(31, 14, 1); robot.com2Bytes(31, 15, 1); robot.enableMotors(); robot.clearDirectMotion(); #ifndef SONARNL // Set up the laser before handing it to the laser mode simpleConnector.setupLaser(&sick); // Add the laser to the robot robot.addRangeDevice(&sick); #endif // Start the robot thread. robot.runAsync(true); #ifndef SONARNL // Start the laser thread. sick.runAsync(); // Connect the laser if (!sick.blockingConnect()) { printf("Couldn't connect to sick, exiting\n"); Aria::shutdown(); return 1; } #endif ArUtil::sleep(300); // If you want to set the number of samples change the line below locTask.setNumSamples(2000); // Localize the robot to home if(locTask.localizeRobotAtHomeBlocking()) { printf("Successfully localized at home.\n"); } else { printf("WARNING: Unable to localize at home position!\n"); } robot.lock(); // attach stuff to the server ArServerInfoRobot serverInfoRobot(&server, &robot); ArServerInfoSensor serverInfoSensor(&server, &robot); ArServerInfoPath serverInfoPath(&server, &robot, &pathTask); ArServerInfoLocalization serverInfoLocalization(&server, &robot, &locTask); #ifndef SONARNL // Set it up to handle maps. ArServerHandlerMap serverMap(&server, &arMap, ArServerHandlerMap::POINTS); #else ArServerHandlerMap serverMap(&server, &arMap, ArServerHandlerMap::LINES); #endif // Set up a service that allows the client to monitor the communication // between the robot and the client. // ArServerHandlerCommMonitor serverCommMonitor(&server); //ArServerModeGoto modeGoto(&server, &robot, &pathTask); //ArServerModeStop modeStop(&server, &robot); //ArServerModeDrive modeDrive(&server, &robot); SimpleTask simpleTask(&robot, &pathTask); robot.unlock(); // Read in param files. Aria::getConfig()->parseFile(Arnl::getTypicalParamFileName()); // Now let it spin off in its own thread server.run(); exit(0); }
static void make_player_info(struct nh_player_info *pi) { int cap, advskills, i; memset(pi, 0, sizeof (struct nh_player_info)); pi->moves = moves; strncpy(pi->plname, u.uplname, sizeof (pi->plname)); pi->align = u.ualign.type; /* This function could be called before the game is fully inited. Test youmonst.data as it is required for near_capacity(). program_state.game_running is no good, as we need this data before game_running is set. TODO: Wow this is hacky. */ if (!youmonst.data) return; API_ENTRY_CHECKPOINT_RETURN_VOID_ON_ERROR(); pi->x = youmonst.mx; pi->y = youmonst.my; pi->z = u.uz.dlevel; if (Upolyd) { strncpy(pi->rank, msgtitlecase(mons[u.umonnum].mname), sizeof (pi->rank)); } else strncpy(pi->rank, rank(), sizeof (pi->rank)); strncpy(pi->rolename, (u.ufemale && urole.name.f) ? urole.name.f : urole.name.m, sizeof (pi->rolename)); strncpy(pi->racename, urace.noun, sizeof (pi->racename)); strncpy(pi->gendername, genders[u.ufemale].adj, sizeof(pi->gendername)); pi->max_rank_sz = mrank_sz; /* abilities */ pi->st = ACURR(A_STR); pi->st_extra = 0; if (pi->st > 118) { pi->st = pi->st - 100; pi->st_extra = 0; } else if (pi->st > 18) { pi->st_extra = pi->st - 18; pi->st = 18; } pi->dx = ACURR(A_DEX); pi->co = ACURR(A_CON); pi->in = ACURR(A_INT); pi->wi = ACURR(A_WIS); pi->ch = ACURR(A_CHA); pi->score = botl_score(); /* hp and energy */ pi->hp = Upolyd ? u.mh : u.uhp; pi->hpmax = Upolyd ? u.mhmax : u.uhpmax; if (pi->hp < 0) pi->hp = 0; pi->en = u.uen; pi->enmax = u.uenmax; pi->ac = find_mac(&youmonst); pi->gold = money_cnt(invent); pi->coinsym = def_oc_syms[COIN_CLASS]; describe_level(pi->level_desc); pi->monnum = u.umonster; pi->cur_monnum = u.umonnum; /* level and exp points */ if (Upolyd) pi->level = mons[u.umonnum].mlevel; else pi->level = youmonst.m_lev; pi->xp = youmonst.exp; cap = near_capacity(); /* check if any skills could be anhanced */ advskills = 0; for (i = 0; i < P_NUM_SKILLS; i++) { if (P_RESTRICTED(i)) continue; if (can_advance(i, FALSE)) advskills++; } pi->can_enhance = advskills > 0; /* add status items for various problems there can be at most 24 items here at any one time or we overflow the buffer */ if (hu_stat[u.uhs]) /* 1 */ strncpy(pi->statusitems[pi->nr_items++], hu_stat[u.uhs], ITEMLEN); if (Confusion) /* 2 */ strncpy(pi->statusitems[pi->nr_items++], "Conf", ITEMLEN); if (sick(&youmonst)) { /* 3 */ if (u.usick_type & SICK_VOMITABLE) strncpy(pi->statusitems[pi->nr_items++], "FoodPois", ITEMLEN); if (u.usick_type & SICK_NONVOMITABLE) strncpy(pi->statusitems[pi->nr_items++], "Ill", ITEMLEN); } if (Blind) /* 4 */ strncpy(pi->statusitems[pi->nr_items++], "Blind", ITEMLEN); if (slippery_fingers(&youmonst)) /* 5 */ strncpy(pi->statusitems[pi->nr_items++], "Greasy", ITEMLEN); if (leg_hurt(&youmonst)) /* 6 */ strncpy(pi->statusitems[pi->nr_items++], "Lame", ITEMLEN); if (stunned(&youmonst)) /* 7 */ strncpy(pi->statusitems[pi->nr_items++], "Stun", ITEMLEN); if (hallucinating(&youmonst)) /* 8 */ strncpy(pi->statusitems[pi->nr_items++], "Hallu", ITEMLEN); if (strangled(&youmonst)) /* 9 */ strncpy(pi->statusitems[pi->nr_items++], "Strangle", ITEMLEN); if (sliming(&youmonst)) /* 10 */ strncpy(pi->statusitems[pi->nr_items++], "Slime", ITEMLEN); if (petrifying(&youmonst)) /* 11 */ strncpy(pi->statusitems[pi->nr_items++], "Petrify", ITEMLEN); if (u.ustuck && !Engulfed && !sticks(youmonst.data)) /* 12 */ strncpy(pi->statusitems[pi->nr_items++], "Held", ITEMLEN); if (enc_stat[cap] ) /* 13 */ strncpy(pi->statusitems[pi->nr_items++], enc_stat[cap], ITEMLEN); if (cancelled(&youmonst)) strncpy(pi->statusitems[pi->nr_items++], "Cancelled", ITEMLEN); if (slow(&youmonst)) strncpy(pi->statusitems[pi->nr_items++], "Slow", ITEMLEN); if (Levitation) /* 14 */ strncpy(pi->statusitems[pi->nr_items++], "Lev", ITEMLEN); else if (Flying) strncpy(pi->statusitems[pi->nr_items++], "Fly", ITEMLEN); if (uwep && is_pick(uwep)) /* 15 (first case) */ strncpy(pi->statusitems[pi->nr_items++], "Dig", ITEMLEN); else if (uwep && is_launcher(uwep)) strncpy(pi->statusitems[pi->nr_items++], "Ranged", ITEMLEN); else if (uwep && (uwep->otyp == CORPSE) && (touch_petrifies(&mons[uwep->corpsenm]))) strncpy(pi->statusitems[pi->nr_items++], "cWielded", ITEMLEN); else if (!uwep) strncpy(pi->statusitems[pi->nr_items++], "Unarmed", ITEMLEN); else if (!is_wep(uwep)) strncpy(pi->statusitems[pi->nr_items++], "NonWeap", ITEMLEN); else { /* strncpy(pi->statusitems[pi->nr_items++], "Melee", ITEMLEN); */ /* Don't show the default Melee status light, as that's the most common case. */ /* 15 (last case) */ } if (u.utrap) /* 16 */ strncpy(pi->statusitems[pi->nr_items++], trap_stat[u.utraptype], ITEMLEN); API_EXIT(); }
/*! * Main function which initializes the localization tasks and pathplanning * tasks. * * @param argc No of command line args. * @param argv Array of command line args. * * @return 1 if successful. */ int main(int argc, char *argv[]) { char* mapname; if(argc<2){ printf("%s\n",USAGE); exit(1); } Aria::init(); Arnl::init(); // The robot object ArRobot robot; #ifndef SONARNL // The laser object ArSick sick(181, 361); #endif // Set up our simpleConnector ArSimpleConnector simpleConnector(&argc, argv); // Parse its arguments simpleConnector.parseArgs(); // Parse them command line arguments. ArArgumentParser parser(&argc, argv); // Sonar, must be added to the robot, for teleop and wander ArSonarDevice sonarDev; // Add the sonar to the robot robot.addRangeDevice(&sonarDev); // Set up the robot for connecting if (!simpleConnector.connectRobot(&robot)) { printf("Could not connect to robot... exiting\n"); Aria::shutdown(); return 1; } robot.enableMotors(); robot.clearDirectMotion(); #ifndef SONARNL // Set up the laser before handing it to the laser mode simpleConnector.setupLaser(&sick); // Add the laser to the robot robot.addRangeDevice(&sick); #endif // Start the robot thread. robot.runAsync(true); #ifndef SONARNL // Start the laser thread. sick.runAsync(); // Connect the laser if (!sick.blockingConnect()) { printf("Couldn't connect to sick, exiting\n"); Aria::shutdown(); return 1; } #endif // // Set up the big holder. // #ifndef SONARNL advancedptr = new Advanced(&robot, &sick, &sonarDev); #else advancedptr = new Advanced(&robot, NULL, &sonarDev); #endif // // Set up the callbacks for localization task. // ArFunctor1C<Advanced, int> failed(advancedptr, &Advanced::trackingFailed); // // Set up the callbacks for pathplanning task. // ArFunctor1C<Advanced, ArPose> goal_done(advancedptr, &Advanced::goalDone); ArFunctor1C<Advanced, ArPose> goal_failed(advancedptr, &Advanced::goalFailed); // Read in config file. Do this before creating the localization // and path planning tasks, so we can override certain config // parameters such as the map file name when we do so. if (!Aria::getConfig()->parseFile(Arnl::getTypicalParamFileName())) { printf("Trouble loading configuration file, exiting\n"); exit(1); } // // Get mapname and initialize localization task and pathplanning tasks. // if((mapname = parser.checkParameterArgument("-map"))){ // // Start the localization thread. Should be done first. // if(!advancedptr->initializeLocalizationTask(mapname)){ printf("Cannot start the localization task thread.\n"); exit(1); }else{ printf("Started the Localization Thread\n"); } // // Get the Aria map from the localization task . // (Alternatively use a ArMap* made separately) // advancedptr->myMap = advancedptr->myLocaTask->getAriaMap(); // // Set up the path plan structure. // Cannot precede localization task setup. // if(!advancedptr->initializePathPlanningTask()){ printf("Cannot set up for path planning task thread.\n"); exit(1); }else{ printf("Started Path Planning Thread\n"); } // // Functors to be used by the Arnl library if the threads // signal failure or success. // advancedptr->myLocaTask->addFailedLocalizationCB(&failed); advancedptr->myPathPlanningTask->addGoalDoneCB(&goal_done); advancedptr->myPathPlanningTask->addGoalFailedCB(&goal_failed); }else{ printf(USAGE); exit(1); } // // Get user input. // interact(); }