MStatus liqAttachPrefAttribute::doIt(const MArgList& args) { MStatus status; MArgParser argParser(syntax(), args); MString tempStr; status = argParser.getObjects(objectNames); if (!status) { MGlobal::displayError("error parsing object list"); return MS::kFailure; } worldSpace = false; int flagIndex = args.flagIndex("ws", "worldSpace"); if (flagIndex != MArgList::kInvalidArgIndex) worldSpace = true; exportN = false; flagIndex = args.flagIndex("en", "exportN"); if (flagIndex != MArgList::kInvalidArgIndex) exportN = true; //printf(">> got %d objects to PREF !\n",objectNames.length() ); return redoIt(); }
int main(int argc, char **argv) { Aria::init(); ArRobot robot; ArArgumentParser argParser(&argc, argv); ArSimpleConnector con(&argParser); if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); return 1; } // Create a connection handler object, defined above, then try to connect to the // robot. ConnHandler ch(&robot); con.connectRobot(&robot); robot.runAsync(true); // Sleep for 10 seconds, then request that ArRobot stop its thread. ArLog::log(ArLog::Normal, "Sleeping for 10 seconds..."); ArUtil::sleep(10000); ArLog::log(ArLog::Normal, "...requesting that the robot thread exit, then shutting down ARIA and exiting."); robot.stopRunning(); Aria::shutdown(); return 0; }
void ClientApp::parseArgs(int argc, const char* const* argv) { ArgParser argParser(this); bool result = argParser.parseClientArgs(args(), argc, argv); if (!result || args().m_shouldExit) { m_bye(kExitArgs); } else { // save server address if (!args().m_synergyAddress.empty()) { try { *m_serverAddress = NetworkAddress(args().m_synergyAddress, kDefaultPort); m_serverAddress->resolve(); } catch (XSocketAddress& e) { // allow an address that we can't look up if we're restartable. // we'll try to resolve the address each time we connect to the // server. a bad port will never get better. patch by Brent // Priddy. if (!args().m_restartable || e.getError() == XSocketAddress::kBadPort) { LOG((CLOG_PRINT "%s: %s" BYE, args().m_pname, e.what(), args().m_pname)); m_bye(kExitFailed); } } } } }
int main(int argc, char *argv[]) { //initialize Aria Aria::init(); //handle cmd arguments ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); //create new robot ArRobot robot("blarg"); //connect to the robot ArRobotConnector robotConnector(&argParser, &robot); if(!robotConnector.connectRobot()) ArLog::log(ArLog::Terse, "Could not connect to the robot."); else ArLog::log(ArLog::Terse, "Connection to robot sucessful."); /* Shutdown Aria and exit */ Aria::shutdown(); Aria::exit(0); return 0; }
TEST(ArgParserTests, isArg_missingArgs_returnFalse) { int i = 1; const int argc = 2; const char* argv[argc] = { "stub", "-t" }; ArgParser argParser(NULL); ArgsBase argsBase; argParser.setArgsBase(argsBase); bool result = ArgParser::isArg(i, argc, argv, "-t", NULL, 1); EXPECT_FALSE(result); EXPECT_EQ(true, argsBase.m_shouldExit); }
MStatus liqWriteArchive::doIt(const MArgList& args) { MStatus status; MArgParser argParser(syntax(), args); MString tempStr; status = argParser.getCommandArgument(0, tempStr); if (!status) { MGlobal::displayError("error parsing object name argument"); return MS::kFailure; } objectNames.append(tempStr); status = argParser.getCommandArgument(1, outputFilename); if (!status) { MGlobal::displayError("error parsing rib filename argument"); return MS::kFailure; } outputRootTransform = false; int flagIndex = args.flagIndex("rt", "rootTransform"); if (flagIndex != MArgList::kInvalidArgIndex) { outputRootTransform = true; } outputChildTransforms = true; flagIndex = args.flagIndex("ct", "childTransforms"); if (flagIndex != MArgList::kInvalidArgIndex) { outputChildTransforms = true; } debug = false; flagIndex = args.flagIndex("d", "debug"); if (flagIndex != MArgList::kInvalidArgIndex) { debug = true; } binaryRib = false; flagIndex = args.flagIndex("b", "binary"); if (flagIndex != MArgList::kInvalidArgIndex) { binaryRib = true; } return redoIt(); }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); ArSimpleConnector conn(&argParser); argParser.loadDefaultArguments(); if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); return 1; } // This is a global pointer so the global functions can use it. robot = new ArRobot; // functor for the packet handler ArGlobalRetFunctor1<bool, ArRobotPacket *> getAuxCB(&getAuxPrinter); // add our packet handler as the first one in the list robot->addPacketHandler(&getAuxCB, ArListPos::FIRST); // Connect to the robot if(!conn.connectRobot(robot)) { ArLog::log(ArLog::Terse, "getAuxExample: Error connecting to the robot."); return 2; } ArLog::log(ArLog::Normal, "getAuxExample: Connected to the robot. Sending command to change AUX1 baud rate to 9600..."); robot->comInt(ArCommands::AUX1BAUD, 0); // See robot manual // Send the first GETAUX request robot->comInt(ArCommands::GETAUX, 1); // If you wanted to recieve information from the second aux. serial port, use // the GETAUX2 command instead; but the packet returned will also have a // different type ID. //robot->comInt(ArCommands::GETAUX2, 1); // run the robot until disconnect, then shutdown and exit. robot->run(true); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); // command-line arguments and robots connection ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); ArSimpleConnector con(&argParser); // the robot, but turn state reflection off (so we have no mobility control in // this program) ArRobot robot(NULL, false); // an object for keyboard control, class defined above, this also adds itself as a user task KeyPTU ptu(&robot); // parse command-line arguments (i.e. connection options for simple connector) if(!Aria::parseArgs()) { Aria::logOptions(); return 1; } // connect to the robot if (!con.connectRobot(&robot)) { ArLog::log(ArLog::Terse, "Error connecting to robot!"); Aria::shutdown(); return 1; } // turn off the sonar robot.comInt(ArCommands::SONAR, 0); printf("Press '?' for available commands\r\n"); // run, if we lose connection to the robot, exit robot.run(true); Aria::shutdown(); return 0; }
int main(int argc, char *argv[]) { Aria::init(); ArVideo::init(); ArArgumentParser argParser(&argc, argv); ArServerBase server; ArServerSimpleOpener openServer(&argParser); argParser.loadDefaultArguments(); if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); Aria::exit(-1); } if(!openServer.open(&server)) { std::cout << "error opening ArNetworking server" << std::endl; Aria::exit(5); return 5; } server.runAsync(); std::cout << "ArNetworking server running on port " << server.getTcpPort() << std::endl; /* Set up ArNetworking services */ ArVideoRemoteForwarder forwarder(&server, "localhost", 7070); if(!forwarder.connected()) { std::cout << "ERror connecting to server localhost:7070" << std::endl; Aria::exit(1); } std::cout << "ArNetworking server running on port " << server.getTcpPort() << std::endl; while(true) ArUtil::sleep(10000); Aria::exit(0); return 0; }
void CServerApp::parseArgs(int argc, const char* const* argv) { CArgParser argParser(this); bool result = argParser.parseServerArgs(args(), argc, argv); if (!result || args().m_shouldExit) { m_bye(kExitArgs); } else { if (!args().m_synergyAddress.empty()) { try { *m_synergyAddress = CNetworkAddress(args().m_synergyAddress, kDefaultPort); m_synergyAddress->resolve(); } catch (XSocketAddress& e) { LOG((CLOG_PRINT "%s: %s" BYE, args().m_pname, e.what(), args().m_pname)); m_bye(kExitArgs); } } } }
int main(int argc, char** argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); ArSimpleConnector con(&argParser); ArRobot robot; ArSonarDevice sonar; argParser.loadDefaultArguments(); if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); return 1; } /* - the action group for teleoperation actions: */ teleop = new ArActionGroup(&robot); // don't hit any tables (if the robot has IR table sensors) teleop->addAction(new ArActionLimiterTableSensor, 100); // limiter for close obstacles teleop->addAction(new ArActionLimiterForwards("speed limiter near", 300, 600, 250), 95); // limiter for far away obstacles teleop->addAction(new ArActionLimiterForwards("speed limiter far", 300, 1100, 400), 90); // limiter so we don't bump things backwards teleop->addAction(new ArActionLimiterBackwards, 85); // the joydrive action (drive from joystick) ArActionJoydrive joydriveAct("joydrive", 400, 15); teleop->addAction(&joydriveAct, 50); // the keydrive action (drive from keyboard) teleop->addAction(new ArActionKeydrive, 45); /* - the action group for wander actions: */ wander = new ArActionGroup(&robot); // if we're stalled we want to back up and recover wander->addAction(new ArActionStallRecover, 100); // react to bumpers wander->addAction(new ArActionBumpers, 75); // turn to avoid things closer to us wander->addAction(new ArActionAvoidFront("Avoid Front Near", 225, 0), 50); // turn avoid things further away wander->addAction(new ArActionAvoidFront, 45); // keep moving wander->addAction(new ArActionConstantVelocity("Constant Velocity", 400), 25); /* - use key commands to switch modes, and use keyboard * and joystick as inputs for teleoperation actions. */ // create key handler if Aria does not already have one ArKeyHandler *keyHandler = Aria::getKeyHandler(); if (keyHandler == NULL) { keyHandler = new ArKeyHandler; Aria::setKeyHandler(keyHandler); robot.attachKeyHandler(keyHandler); } // set the callbacks ArGlobalFunctor teleopCB(&teleopMode); ArGlobalFunctor wanderCB(&wanderMode); keyHandler->addKeyHandler('w', &wanderCB); keyHandler->addKeyHandler('W', &wanderCB); keyHandler->addKeyHandler('t', &teleopCB); keyHandler->addKeyHandler('T', &teleopCB); // if we don't have a joystick, let 'em know if (!joydriveAct.joystickInited()) printf("Note: Do not have a joystick, only the arrow keys on the keyboard will work.\n"); // set the joystick so it won't do anything if the button isn't pressed joydriveAct.setStopIfNoButtonPressed(false); /* - connect to the robot, then enter teleoperation mode. */ robot.addRangeDevice(&sonar); if(!con.connectRobot(&robot)) { ArLog::log(ArLog::Terse, "actionGroupExample: Could not connect to the robot."); Aria::shutdown(); return 1; } robot.enableMotors(); teleopMode(); robot.run(true); Aria::shutdown(); return 0; }
int main(int argc, char *argv[]) { NRTSimulator::TCmdArgParser argParser(argc, argv); std::vector<std::shared_ptr<NRTSimulator::TTask>> tasks = NRTSimulator::TTaskFileParser(!argParser.IsCountingUsed()).Parse( argParser.GetTaskSpecFileName()); if (argParser.IsCountingUsed()) { std::cout << "Estimate convert rate for counting task..." << std::endl; NRTSimulator::TCountingTask::EstimateConvertRate(); } std::cout << "Responce time analysis..." << std::endl; NRTSimulator::TRTA rta(tasks); rta.Compute(); for (size_t taskNumber = 0; taskNumber < tasks.size(); ++ taskNumber) { if (rta.CheckIsShedulable(taskNumber)) { std::cout << tasks[taskNumber]->GetName() << ": worst case response time " << rta.GetWorstCaseResponceTime(taskNumber) << std::endl; } else { std::cout << tasks[taskNumber]->GetName() << ": is not schedulable" << std::endl; } } std::cout << "Simulation..." << std::endl; auto start = std::chrono::high_resolution_clock::now() + TASK_OFFSET; auto end = start + std::chrono::seconds(argParser.GetSimulationTime()); std::vector<pthread_t> threads(tasks.size()); std::cout << "Run real time tasks..." << std::endl; for (size_t i = 0; i < tasks.size(); ++i) { tasks[i]->Run(std::chrono::duration_cast<std::chrono::nanoseconds> (start.time_since_epoch()).count(), std::chrono::duration_cast<std::chrono::nanoseconds> (end.time_since_epoch()).count()); } std::cout << "Wait while simulation running..." << std::endl; for (size_t i = 0; i < threads.size(); ++i) { tasks[i]->Join(); std::cout << tasks[i]->GetName() << ": worst case response time " << tasks[i]->GetWorstCaseResponceTime() << std::endl; } if (argParser.IsPlotNeeded()) { std::cout << "Ploting..." << std::endl; for (const auto & task : tasks) { NRTSimulator::TCDFPlot().Plot(task->GetResponceTimes(), task->GetName()); } } std::cout << "Worst case kernel latency: " << rta.EstimateWorstCaseKernellLatency() << std::endl; if (!argParser.GetOutputDirectory().empty()) { std::cout << "Output result in '" << argParser.GetOutputDirectory() << "' directory..." << std::endl; NRTSimulator::TOutput(argParser.GetOutputDirectory()).Write(tasks); } return 0; }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); ArRobot robot; ArSick laser; std::ofstream stream; // for loggin time_t timer; char buffer[120]; //for loggin ArRobotConnector robotConnector(&argParser, &robot); ArLaserConnector laserConnector(&argParser, &robot, &robotConnector); int32_t count = 0; readyLog(stream); if (!robotConnector.connectRobot()) { ArLog::log(ArLog::Terse, "Could not connect to the robot."); if (argParser.checkHelpAndWarnUnparsed()) { // -help not given, just exit. Aria::logOptions(); Aria::exit(1); return 1; } } // Trigger argument parsing if (!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); Aria::exit(1); return 1; } ArKeyHandler keyHandler; Aria::setKeyHandler(&keyHandler); robot.attachKeyHandler(&keyHandler); puts("This program will make the robot wander around. It uses some avoidance\n" "actions if obstacles are detected, otherwise it just has a\n" "constant forward velocity.\n\nPress CTRL-C or Escape to exit."); //ArSonarDevice sonar; //robot.addRangeDevice(&sonar); robot.addRangeDevice(&laser); robot.runAsync(true); // try to connect to laser. if fail, warn but continue, using sonar only if (!laserConnector.connectLasers()) { ArLog::log(ArLog::Normal, "Warning: unable to connect to requested lasers, will wander using robot sonar only."); } double sampleAngle, dist; auto sampleRange = laser.currentReadingPolar(-20, 20, &sampleAngle); auto degreeStr = laser.getDegreesChoicesString(); std::cout << "auto sampleRange = laser.currentReadingPolar(-20, 20, &sampleAngle);" << sampleRange << std::endl; std::cout << "auto degreeStr = laser.getDegreesChoicesString(); : " << degreeStr << std::endl; // turn on the motors, turn off amigobot sounds robot.enableMotors(); //robot.getLaserMap() robot.comInt(ArCommands::SOUNDTOG, 0); // add a set of actions that combine together to effect the wander behavior ArActionStallRecover recover; ArActionBumpers bumpers; ArActionAvoidFront avoidFrontNear("Avoid Front Near", 100, 0); ArActionAvoidFront avoidFrontFar; ArActionConstantVelocity constantVelocity("Constant Velocity", 400); robot.addAction(&recover, 100); robot.addAction(&bumpers, 75); robot.addAction(&avoidFrontNear, 50); robot.addAction(&avoidFrontFar, 49); robot.addAction(&constantVelocity, 25); stream << "IMPORTANT !! == robot.getRobotRadius() : " << robot.getRobotRadius << std::endl; std::string timestamp; while (1) { // // time(&timer); strftime(buffer, 80, " - timestamp : %I:%M:%S", localtime(&timer)); timestamp = buffer; dist = robot.checkRangeDevicesCurrentPolar(-70, 70, &sampleAngle) - robot.getRobotRadius(); stream << count << timestamp << "checkRangeDevicesCurrentPolar(-70, 70, &angle) : " << dist << std::endl; Sleep(500); count++; } // wwill add processor here // wait for robot task loop to end before exiting the program robot.waitForRunExit(); Aria::exit(0); return 0; }
int main(int argc, char *argv[]) { /*path contiendra le repertoire courant lors du lancement du shell (il ne sera plus modifié)*/ char* path = (char*)malloc(max_length * sizeof(char)); getcwd(path, arg_length); /*string contiendra les commandes entrée par l'utilisateur*/ char string[max_length]; /*name contiendra le hostname*/ char* name = (char*)malloc(arg_length * sizeof(char)); /*networkPosition contiendra la position du '.' indiquant une machine réseau dans name*/ char* networkPosition = NULL; /*currentDir contiendra le repertoire courant*/ char* currentDir = (char*)malloc(arg_length * sizeof(char)); /*commandLine contiendra la chaine a affichée avant les commandes*/ char* commandLine = (char*)malloc(max_length * sizeof(char)); /*args contiendra les arguments de la commande entrée*/ char** args = NULL; int i, spaces, exiting = 1; /*on recupere le hostname*/ if(gethostname(name, arg_length) == -1) { fprintf(stdout, "%s%s%s", "gethostname failed : ", strerror(errno), "\n"); return 0; } networkPosition = strchr(name, '.'); /*si name contient un '.' cela indique un nom de la forme machine.reseau, on coupe la partie reseau*/ if(networkPosition) networkPosition = '\0'; /*boucle principale*/ while(exiting) { getcwd(currentDir, arg_length); /*on concatene les différentes parties de l'invite de commande, getlogin() permet de recuperer le login actuel*/ sprintf(commandLine, "%s%s%s%s%s%s", getlogin(), "@", name, ":", currentDir, ">"); fprintf(stdout, commandLine); /*on recupere la commande entrée par l'utilisateur*/ exiting = getString(string, max_length); /*on compte le nombre d'espaces dans la commande*/ spaces = spaceCounter(string); /*on parse les arguments dans args*/ args = argParser(string, spaces); /*on ajoute la commande entrée à history si elle n'est pas vide et est différent de !!*/ if(strcmp(args[0], "\0") && strcmp(args[0], "!!")) addHistory(string, path); /*on appelle la fonction qui execute les commandes*/ if(strcmp(args[0], "\0")) { if(!strcmp(args[0], "exit")) exiting = 0; else if(!strcmp(args[0], "cd")) changeDir(args); else executeCommand(args, spaces, path); } for(i = 0; i < (spaces + 2); i++) { args[i] = NULL; free(args[i]); } free(args); } free(name); free(commandLine); free(currentDir); free(path); return 1; }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); WrapList wrappers; #ifdef FOR_ARIA wrappers.push_back(WrapPair("ArRobotConnector", new ArRobotConnectorWrapper(&argParser))); wrappers.push_back(WrapPair("ArLaserConnector", new ArLaserConnectorWrapper(&argParser))); wrappers.push_back(WrapPair("ArGPSConnector", new ArGPSConnectorWrapper(&argParser))); wrappers.push_back(WrapPair("ArCompassConnector", new ArCompassConnectorWrapper(&argParser))); #endif #ifdef FOR_ARNETWORKING ArServerBase server; wrappers.push_back(WrapPair("ArClientSimpleConnector", new ArClientSimpleConnectorWrapper(&argParser))); wrappers.push_back(WrapPair("ArServerSimpleOpener", new ArServerSimpleOpenerWrapper(&argParser))); wrappers.push_back(WrapPair("ArClientSwitchManager", new ArClientSwitchManagerWrapper(&server, &argParser))); #endif /* Write docs/options/all_options.dox */ // TODO process text to replace HTML characters with entities or formatting // (especially < and >) redirectStdout("docs/options/all_options.dox"); printf("/* This file was automatically generated by utils/genCommandLineOptionDocs.cpp. Do not modify or changes will be lost.*/\n\n"\ "/** @page CommandLineOptions Command Line Option Summary\n\n%s\n\n", EXPLANATION); // TODO process text by turning it into a <dl> or similar: start new <dt> at // beginning of line, add </dt><dd> at first \t, then add </dt> at end. for(WrapList::const_iterator i = wrappers.begin(); i != wrappers.end(); ++i) { printf("@section %s\n\n(See %s for class documentation)\n\n<pre>", (*i).first.c_str(), (*i).first.c_str()); (*i).second->logOptions(); puts("</pre>\n"); fprintf(stderr, "genCommandLineOptionDocs: Added %s to docs/options/all_options.dox\n", (*i).first.c_str()); } puts("*/"); fputs("genCommandLineOptionDocs: Wrote docs/options/all_options.dox\n", stderr); /* Write docs/options/<class> */ for(WrapList::const_iterator i = wrappers.begin(); i != wrappers.end(); ++i) { std::string filename("docs/options/"); filename += (*i).first + "_options"; redirectStdout(filename.c_str()); (*i).second->logOptions(); fprintf(stderr, "genCommandLineOptionDocs: Wrote %s\n", filename.c_str()); } /* Write CommandLineOptions.txt.in */ redirectStdout("CommandLineOptions.txt.in"); #ifdef FOR_ARIA puts("\nARIA $ARIAVERSION\n"); #elif defined(FOR_ARNETWORKING) puts("\nArNetworking $ARIAVERSION\n"); #endif printf("Summary of command line options\n\n%s", EXPLANATION); for(WrapList::const_iterator i = wrappers.begin(); i != wrappers.end(); ++i) { puts(""); puts((*i).first.c_str()); for(std::string::size_type c = 0; c < (*i).first.size(); ++c) fputc('-', stdout); puts(""); (*i).second->logOptions(); } puts("\n"); fputs("genCommandLineOptionDocs: Wrote CommandLineOptions.txt.in\n", stderr); Aria::exit(0); }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); ArRobot robot; ArRobotConnector robotConnector(&argParser, &robot); ArLaserConnector laserConnector(&argParser, &robot, &robotConnector); if(!robotConnector.connectRobot()) { ArLog::log(ArLog::Terse, "Could not connect to the robot."); if(argParser.checkHelpAndWarnUnparsed()) { // -help not given, just exit. Aria::logOptions(); Aria::exit(1); return 1; } } // Trigger argument parsing if (!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); Aria::exit(1); return 1; } ArKeyHandler keyHandler; Aria::setKeyHandler(&keyHandler); robot.attachKeyHandler(&keyHandler); puts("This program will make the robot wander around. It uses some avoidance\n" "actions if obstacles are detected, otherwise it just has a\n" "constant forward velocity.\n\nPress CTRL-C or Escape to exit."); ArSonarDevice sonar; robot.addRangeDevice(&sonar); robot.runAsync(true); // try to connect to laser. if fail, warn but continue, using sonar only if(!laserConnector.connectLasers()) { ArLog::log(ArLog::Normal, "Warning: unable to connect to requested lasers, will wander using robot sonar only."); } // turn on the motors, turn off amigobot sounds robot.enableMotors(); robot.comInt(ArCommands::SOUNDTOG, 0); // add a set of actions that combine together to effect the wander behavior //działa //general structure: robot.addAction (new Name_of_action (parameters), priority); //to find out more about Actions go to ~/catkin_ws/src/rosaria/local/Aria/docs/index.html // if we're stalled we want to back up and recover robot.addAction(new ArActionStallRecover("stall recover", 100,50,100,30), 100); //basic values 225, 50, 150, 45 //when_stop, cycles_to_move, speed, turn' //slow down when near obstacle robot.addAction(new ArActionLimiterForwards("speed limiter near", 200, 200, 200), 95); // basic values 300,600,250 //stop_distance, slow_distance, slow_speed // react to bumpers robot.addAction(new ArActionLimiterBackwards, 75); // turn avoid very close robot.addAction(new ArActionAvoidFront("speed limiter far", 150,450,20), 47); //basic values 450, 200,15 //when_turn, speed, turn' // turn avoid things near robot.addAction(new ArActionAvoidFront("speed limiter far", 300,450,10), 46); //basic values 450, 200,15 //when_turn, speed, turn' // turn avoid things further away robot.addAction(new ArActionAvoidFront("speed limiter far", 800,450,5), 45); //basic values 450, 200,15 //when_turn, speed, turn' //move forward robot.addAction(new ArActionConstantVelocity("Constant Velocity", 500), 25); // wait for robot task loop to end before exiting the program robot.waitForRunExit(); Aria::exit(0); return 0; }
int main(int argc, char **argv) { Aria::init(); ArRobot robot; ArArgumentParser argParser(&argc, argv); ArSimpleConnector connector(&argParser); ArGripper gripper(&robot); ArSonarDevice sonar; robot.addRangeDevice(&sonar); argParser.loadDefaultArguments(); if (!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); Aria::shutdown(); return 1; } if (!connector.connectRobot(&robot)) { ArLog::log(ArLog::Terse, "gripperExample: Could not connect to robot... exiting"); Aria::shutdown(); return 2; } ArLog::log(ArLog::Normal, "gripperExample: Connected to robot."); ArLog::log(ArLog::Normal, "gripperExample: GripperType=%d", gripper.getType()); gripper.logState(); if(gripper.getType() == ArGripper::NOGRIPPER) { ArLog::log(ArLog::Terse, "gripperExample: Error: Robot does not have a gripper. Exiting."); Aria::shutdown(); return -1; } // Teleoperation actions with obstacle-collision avoidance ArActionLimiterTableSensor tableLimit; robot.addAction(&tableLimit, 110); ArActionLimiterForwards limitNearAction("near", 300, 600, 250); robot.addAction(&limitNearAction, 100); ArActionLimiterForwards limitFarAction("far", 300, 1100, 400); robot.addAction(&limitFarAction, 90); ArActionLimiterBackwards limitBackAction; robot.addAction(&limitBackAction, 50); ArActionJoydrive joydriveAction("joydrive", 400, 15); robot.addAction(&joydriveAction, 40); joydriveAction.setStopIfNoButtonPressed(false); ArActionKeydrive keydriveAction; robot.addAction(&keydriveAction, 30); // Handlers to control the gripper and print out info (classes defined above) PrintGripStatus printStatus(&gripper); GripperControlHandler gripControl(&gripper); printStatus.addRobotTask(&robot); gripControl.addKeyHandlers(&robot); // enable motors and run (if we lose connection to the robot, exit) ArLog::log(ArLog::Normal, "You may now operate the robot with arrow keys or joystick. Operate the gripper with the u, d, o, c, and page up/page down keys."); robot.enableMotors(); robot.run(true); Aria::shutdown(); return 0; }
int main(int argc, char** argv) { Aria::init(); ArLog::init(ArLog::StdErr, ArLog::Normal); ArArgumentParser argParser(&argc, argv); ArSimpleConnector connector(&argParser); ArGPSConnector gpsConnector(&argParser); ArRobot robot; ArActionLimiterForwards nearLimitAction("limit near", 300, 600, 250); ArActionLimiterForwards farLimitAction("limit far", 300, 1100, 400); ArActionLimiterBackwards limitBackwardsAction; ArActionJoydrive joydriveAction; ArActionKeydrive keydriveAction; ArSonarDevice sonar; ArSick laser; argParser.loadDefaultArguments(); if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); return -1; } robot.addRangeDevice(&sonar); robot.addRangeDevice(&laser); ArLog::log(ArLog::Normal, "gpsRobotTaskExample: Connecting to robot..."); if(!connector.connectRobot(&robot)) { ArLog::log(ArLog::Terse, "gpsRobotTaskExample: Could not connect to the robot. Exiting."); return -2; } ArLog::log(ArLog::Normal, "gpsRobotTaskExample: Connected to the robot."); // Connect to GPS ArLog::log(ArLog::Normal, "gpsRobotTaskExample: Connecting to GPS, it may take a few seconds..."); ArGPS *gps = gpsConnector.createGPS(); if(!gps || !gps->connect()); { ArLog::log(ArLog::Terse, "gpsRobotTaskExample: Error connecting to GPS device. Try -gpsType, -gpsPort, and/or -gpsBaud command-line arguments. Use -help for help. Exiting."); return -3; } // Create an GPSLogTask which will register a task with the robot. GPSLogTask gpsTask(&robot, gps, joydriveAction.getJoyHandler()->haveJoystick() ? joydriveAction.getJoyHandler() : NULL); // Add actions robot.addAction(&nearLimitAction, 100); robot.addAction(&farLimitAction, 90); robot.addAction(&limitBackwardsAction, 80); robot.addAction(&joydriveAction, 50); robot.addAction(&keydriveAction, 40); // allow keydrive action to drive robot even if joystick button isn't pressed joydriveAction.setStopIfNoButtonPressed(false); // Start the robot running robot.runAsync(true); // Connect to the laser connector.setupLaser(&laser); laser.runAsync(); if(!laser.blockingConnect()) ArLog::log(ArLog::Normal, "gpsRobotTaskExample: Warning, could not connect to SICK laser, will not use it."); robot.lock(); robot.enableMotors(); robot.comInt(47, 1); // enable joystick driving on some robots // Add exit callback to reset/unwrap steering wheels on seekur (critical if the robot doesn't have sliprings); does nothing for other robots Aria::addExitCallback(new ArRetFunctor1C<bool, ArRobot, unsigned char>(&robot, &ArRobot::com, (unsigned char)120)); Aria::addExitCallback(new ArRetFunctor1C<bool, ArRobot, unsigned char>(&robot, &ArRobot::com, (unsigned char)120)); robot.unlock(); ArLog::log(ArLog::Normal, "gpsRobotTaskExample: Running... (drive robot with joystick or arrow keys)"); robot.waitForRunExit(); return 0; }
int main(int argc, char *argv[]) { argParser(argc, argv); return 0; }
int main(int argc, char** argv) { Aria::init(); ArLog::init(ArLog::StdErr, ArLog::Normal); ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); ArSimpleConnector connector(&argParser); ArGPSConnector gpsConnector(&argParser); if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); ArLog::log(ArLog::Terse, "gpsExample options:\n -printTable Print data to standard output in regular columns rather than a refreshing terminal display, and print more digits of precision"); return 1; } // Try connecting to robot ArRobot robot; if(!connector.connectRobot(&robot)) { ArLog::log(ArLog::Terse, "gpsExample: Warning: Could not connect to robot. Will not be able to switch GPS power on, or load GPS options from this robot's parameter file."); } else { ArLog::log(ArLog::Normal, "gpsExample: Connected to robot."); robot.runAsync(true); } // check command line arguments for -printTable bool printTable = argParser.checkArgument("printTable"); // On the Seekur, power to the GPS receiver is switched on by this command. // (A third argument of 0 would turn it off). On other robots this command is // ignored. robot.com2Bytes(116, 6, 1); // Try connecting to a GPS. We pass the robot pointetr to the connector so it // can check the robot parameters for this robot type for default values for // GPS device connection information (receiver type, serial port, etc.) ArLog::log(ArLog::Normal, "gpsExample: Connecting to GPS, it may take a few seconds..."); ArGPS *gps = gpsConnector.createGPS(&robot); if(!gps || !gps->connect()) { ArLog::log(ArLog::Terse, "gpsExample: Error connecting to GPS device. Try -gpsType, -gpsPort, and/or -gpsBaud command-line arguments. Use -help for help."); return -1; } ArLog::log(ArLog::Normal, "gpsExample: Reading data..."); ArTime lastReadTime; if(printTable) gps->printDataLabelsHeader(); while(true) { int r = gps->read(); if(r & ArGPS::ReadError) { ArLog::log(ArLog::Terse, "gpsExample: Warning: error reading GPS data."); ArUtil::sleep(1000); continue; } if(r & ArGPS::ReadUpdated) { if(printTable) { gps->printData(false); printf("\n"); } else { gps->printData(); printf("\r"); } fflush(stdout); ArUtil::sleep(500); lastReadTime.setToNow(); continue; } else { if(lastReadTime.secSince() >= 5) { ArLog::log(ArLog::Terse, "gpsExample: Warning: haven't recieved any data from GPS for more than 5 seconds!"); } ArUtil::sleep(1000); continue; } } return 0; }
int main(int argc, char* argv[]) { Logger::setProcessInformation("Administrador Memoria:"); char buffer[TAM_BUFFER]; ArgumentParser argParser(argc, argv); int idMemoria; if ( argParser.parseArgument(1, idMemoria) == -1 ) { Logger::logMessage(Logger::COMM, "ERROR: parseArgument 1"); exit(-1); } sprintf(buffer, "Administrador Memoria Nº%d:",idMemoria); Logger::setProcessInformation(buffer); Logger::logMessage(Logger::DEBUG, "Administrador creado satisfactoriamente"); try { // Obtengo la cola por la cual recibo la memoria compartida IPC::MsgQueue colaMemoria = IPC::MsgQueue("Cola Memoria"); colaMemoria.getMsgQueue(DIRECTORY_BROKER, ID_TIPO_MEMORIA); // Obtengo la cola por la cual recibo los pedidos por memoria compartida IPC::MsgQueue colaPedidosMemoria = IPC::MsgQueue("Cola Pedidos Memoria"); colaPedidosMemoria.getMsgQueue(DIRECTORY_BROKER, ID_TIPO_PEDIDO_MEMORIA); // Obtengo la memoria compartida contadora IPC::SharedMemory<int> contadoraSharedMemory = IPC::SharedMemory<int>("Contadora Pedidos Sh Mem"); contadoraSharedMemory.getSharedMemory(DIRECTORY_ADM, idMemoria); IPC::Semaphore semaforoContadora = IPC::Semaphore("Semaforo Contadora Pedidos"); semaforoContadora.getSemaphore(DIRECTORY_ADM, idMemoria,1); // Obtengo la memoria compartida con el siguiente broker IPC::SharedMemory<int> siguienteSharedMemory = IPC::SharedMemory<int>("Siguiente Broker Sh Mem"); siguienteSharedMemory.getSharedMemory(DIRECTORY_BROKER, ID_SHMEM_SIGUIENTE); IPC::Semaphore semaforoSiguiente = IPC::Semaphore("Semaforo Siguiente Broker"); semaforoSiguiente.getSemaphore(DIRECTORY_BROKER, ID_SHMEM_SIGUIENTE, 1); char bufferMsgQueue[MSG_BROKER_SIZE]; //char directorioIPC[DIR_FIXED_SIZE]; //int identificadorIPC; int cantidad = 0; while (true) { // Recibo el token con la memoria compartida MsgEntregaMemoriaAdministrador mensajeMemoria; colaMemoria.recv(idMemoria, bufferMsgQueue, MSG_BROKER_SIZE); memcpy(&mensajeMemoria, bufferMsgQueue, sizeof(MsgEntregaMemoriaAdministrador)); // Saco este mensaje porque sino el Log se llena de basura por culpa del Polling // Logger::logMessage(Logger::DEBUG, "Recibe mensaje de ColaMemoria"); semaforoContadora.wait(); contadoraSharedMemory.read(&cantidad); semaforoContadora.signal(); for (int i = 0; i < cantidad; ++i) { // Obtengo un pedido por la memoria MsgPedidoMemoriaAdministrador mensajePedido; colaPedidosMemoria.recv(idMemoria, bufferMsgQueue, MSG_BROKER_SIZE); memcpy(&mensajePedido, bufferMsgQueue, sizeof(MsgPedidoMemoriaAdministrador)); Logger::logMessage(Logger::DEBUG, "Recibe mensaje de ColaPedidoMemoria"); // Envio a la cola del agente que realizo el pedido, la memoria compartida CommPacketWrapper wrapper; wrapper.setDirIPC(DIRECTORY_SEM); wrapper.setIdDirIPC(mensajePedido.idTipoEmisor); //wrapper.setReceiverId(mensajePedido.idReceptor); wrapper.setReceiverId(mensajePedido.idEmisor); //wrapper.setReceiverType(mensajePedido.idTipoEmisor); MsgCanalSalidaBroker msgSalida; wrapper.createPacketReplyShMem(msgSalida, mensajeMemoria.memoria); IPC::MsgQueue colaAgente = IPC::MsgQueue("Cola Agente"); colaAgente.getMsgQueue(DIRECTORY_BROKER, mensajePedido.idTipoEmisor); colaAgente.send(msgSalida); // Espero que el agente devuelva la memoria compartida colaMemoria.recv(idMemoria, bufferMsgQueue, MSG_BROKER_SIZE); memcpy(&mensajeMemoria, bufferMsgQueue, sizeof(MsgEntregaMemoriaAdministrador)); } // WARNING: Agrego un sleep para que si no hay mensajes, no se quede en un busy wait!!! sleep( 5 ); // Le envio la memoria al siguietne broker, por ahora se vuelve a enviar a la cola de entrada del administrador memcpy(bufferMsgQueue, &mensajeMemoria, sizeof(MsgEntregaMemoriaAdministrador)); colaMemoria.send(bufferMsgQueue, MSG_BROKER_SIZE); } } catch (Exception & e) { Logger::logMessage(Logger::ERROR, e.get_error_description()); abort(); } return 0; }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); if (argc < 2 || !Aria::parseArgs() || argParser.checkArgument("-help")) { ArLog::log(ArLog::Terse, "configExample usage: configExample <config file>.\nFor example, \"configExample examples/configExample.cfg\"."); Aria::logOptions(); Aria::shutdown(); return 1; } // Object containing config parameters, and responding to changes: ConfigExample configExample; // Load a config file given on the command line into the global // ArConfig object kept by Aria. Normally ArConfig expects config // files to be in the main ARIA directory (i.e. /usr/local/Aria or // a directory specified by the $ARIA environment variable). char error[512]; const char* filename = argParser.getArg(1); ArConfig* config = Aria::getConfig(); ArLog::log(ArLog::Normal, "configExample: loading configuration file \"%s\"...", filename); if (! config->parseFile(filename, true, false, error, 512) ) { ArLog::log(ArLog::Terse, "configExample: Error loading configuration file \"%s\" %s. Try \"examples/configExample.cfg\".", filename, error); Aria::shutdown(); return -1; } ArLog::log(ArLog::Normal, "configExample: Loaded configuration file \"%s\".", filename); // After changing a config value, you should invoke the callbacks: ArConfigSection* section = config->findSection("Example Section"); if (section) { ArConfigArg* arg = section->findParam("ExampleBoolParameter"); if (arg) { arg->setBool(!arg->getBool()); if (! config->callProcessFileCallBacks(false, error, 512) ) { ArLog::log(ArLog::Terse, "configExample: Error processing modified config: %s.", error); } else { ArLog::log(ArLog::Normal, "configExample: Successfully modified config and invoked callbacks."); } } } // You can save the configuration as well: ArLog::log(ArLog::Normal, "configExample: Saving configuration..."); if(!config->writeFile(filename)) { ArLog::log(ArLog::Terse, "configExample: Error saving configuration to file \"%s\"!", filename); } // end of program. ArLog::log(ArLog::Normal, "configExample: end of program."); Aria::shutdown(); return 0; }
int main(int argc, char* argv[]) { char buffer[TAM_BUFFER]; char bufferSocket[TAM_BUFFER]; ArgumentParser argParser(argc, argv); int idSd = 0; int brokerNumber = 0; if ( argParser.parseArgument(1, idSd) == -1 ) { exit(-1); } if ( argParser.parseArgument(2, brokerNumber) == -1 ) { exit(-1); } sprintf(buffer, "CanalEntradaBrokerAgente N°%d", brokerNumber); Logger::setProcessInformation( buffer ); SocketStream socketAgente(idSd); Logger::logMessage(Logger::COMM, "Canal de Entrada conectado"); elegirDirectorios( brokerNumber ); try { while ( true ) { if (socketAgente.receive(bufferSocket, TAM_BUFFER) != TAM_BUFFER) { Logger::logMessage(Logger::ERROR, "Error al recibir " "mensajes del Agente"); socketAgente.destroy(); abort(); } MsgCanalEntradaBroker mensaje; memcpy(&mensaje, bufferSocket, sizeof(MsgCanalEntradaBroker)); if (mensaje.receiverType == AGENTE) { DireccionamientoMsgAgente dirMsgAgente; memcpy(&dirMsgAgente, mensaje.direccionamiento, sizeof(DireccionamientoMsgAgente)); char buffer[TAM_BUFFER]; sprintf(buffer, "Recibe mensaje de Agente: idTipoReceptor: %d, idReceptor: %ld", dirMsgAgente.idReceiverAgentType, dirMsgAgente.idReceptor); Logger::logMessage(Logger::COMM, buffer); int idBrokerAgente = obtenerNroBrokerDeAgente(dirMsgAgente.idReceiverAgentType, dirMsgAgente.idReceptor); // Safety-check if ( idBrokerAgente == 0 ) { sprintf(buffer, "Agente Tipo N°%d - Id N°%ld: No se encuentra conectado. Abortando.", dirMsgAgente.idReceiverAgentType, dirMsgAgente.idReceptor); Logger::logMessage(Logger::ERROR, buffer); abort(); } if ( idBrokerAgente == brokerNumber ) { IPC::MsgQueue colaAgente("colaAgente"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, dirMsgAgente.idReceiverAgentType); colaAgente.send(mensaje.msg); } else { sprintf(buffer, "por enviar al broker %d: idTipoReceptor: %d, idReceptor: %ld", idBrokerAgente, dirMsgAgente.idReceiverAgentType, dirMsgAgente.idReceptor); Logger::logMessage(Logger::COMM, buffer); MsgCanalEntradaBrokerBroker msgEntrada; msgEntrada.tipoMensaje = AGENTE_AGENTE; memcpy(msgEntrada.msg, &mensaje, sizeof(MsgCanalEntradaBroker)); MsgCanalSalidaBrokerBroker msgSalida; msgSalida.mtype = idBrokerAgente; memcpy(&msgSalida.msg, &msgEntrada, sizeof(MsgCanalEntradaBrokerBroker)); IPC::MsgQueue colaCanalSalidaBrokerBroker("colaCanalSalidaBrokerBroker"); colaCanalSalidaBrokerBroker.getMsgQueue(C_DIRECTORY_BROKER, ID_MSG_QUEUE_CSBB); colaCanalSalidaBrokerBroker.send(msgSalida); } } else if (mensaje.receiverType == ADMINISTRADOR_MEMORIA) { DireccionamientoMsgAdministrador dirMsgAdm; memcpy(&dirMsgAdm, mensaje.direccionamiento, sizeof(DireccionamientoMsgAdministrador)); IPC::MsgQueue colaAdministrador("colaAdministrador"); colaAdministrador.getMsgQueue(C_DIRECTORY_BROKER, dirMsgAdm.idMsgAdmType); if (dirMsgAdm.idMsgAdmType == ID_TIPO_PEDIDO_MEMORIA) { Logger::logMessage(Logger::COMM, "Pedido memoria"); IPC::SharedMemory<int> contadoraSharedMemory = IPC::SharedMemory<int>("Contadora Pedidos Sh Mem"); contadoraSharedMemory.getSharedMemory(C_DIRECTORY_ADM, dirMsgAdm.idMemory); IPC::Semaphore semaforoContadora = IPC::Semaphore("Semaforo Contadora Pedidos"); semaforoContadora.getSemaphore(C_DIRECTORY_ADM, dirMsgAdm.idMemory, 1); semaforoContadora.wait(); int cantidad; contadoraSharedMemory.read(&cantidad); cantidad++; contadoraSharedMemory.write(&cantidad); semaforoContadora.signal(); } else { Logger::logMessage(Logger::COMM, "Devuelvo memoria"); } colaAdministrador.send(mensaje.msg); } else if (mensaje.receiverType == BROKER) { Logger::logMessage(Logger::ERROR, "Flujo inválido"); // TODO } else { Logger::logMessage(Logger::ERROR, "mensaje mal formado - el receiverType no es valido"); } } } catch (Exception & e) { Logger::logMessage(Logger::ERROR, e.get_error_description()); abort(); } socketAgente.destroy(); Logger::logMessage(Logger::COMM, "Se destruye el canal."); return 0; }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); ArSimpleConnector con(&argParser); ArRobot robot; // the connection handler from above ConnHandler ch(&robot); if(!Aria::parseArgs()) { Aria::logOptions(); Aria::shutdown(); return 1; } if(!con.connectRobot(&robot)) { ArLog::log(ArLog::Normal, "directMotionExample: Could not connect to the robot. Exiting."); return 1; } ArLog::log(ArLog::Normal, "directMotionExample: Connected."); // Run the robot processing cycle in its own thread. Note that after starting this // thread, we must lock and unlock the ArRobot object before and after // accessing it. robot.runAsync(false); // Send the robot a series of motion commands directly, sleeping for a // few seconds afterwards to give the robot time to execute them. printf("directMotionExample: Setting rot velocity to 100 deg/sec then sleeping 3 seconds\n"); robot.lock(); robot.setRotVel(100); robot.unlock(); ArUtil::sleep(3*1000); printf("Stopping\n"); robot.lock(); robot.setRotVel(0); robot.unlock(); ArUtil::sleep(200); printf("directMotionExample: Telling the robot to go 300 mm on left wheel and 100 mm on right wheel for 5 seconds\n"); robot.lock(); robot.setVel2(300, 100); robot.unlock(); ArTime start; start.setToNow(); while (1) { robot.lock(); if (start.mSecSince() > 5000) { robot.unlock(); break; } robot.unlock(); ArUtil::sleep(50); } printf("directMotionExample: Telling the robot to move forwards one meter, then sleeping 5 seconds\n"); robot.lock(); robot.move(1000); robot.unlock(); start.setToNow(); while (1) { robot.lock(); if (robot.isMoveDone()) { printf("directMotionExample: Finished distance\n"); robot.unlock(); break; } if (start.mSecSince() > 5000) { printf("directMotionExample: Distance timed out\n"); robot.unlock(); break; } robot.unlock(); ArUtil::sleep(50); } printf("directMotionExample: Telling the robot to move backwards one meter, then sleeping 5 seconds\n"); robot.lock(); robot.move(-1000); robot.unlock(); start.setToNow(); while (1) { robot.lock(); if (robot.isMoveDone()) { printf("directMotionExample: Finished distance\n"); robot.unlock(); break; } if (start.mSecSince() > 10000) { printf("directMotionExample: Distance timed out\n"); robot.unlock(); break; } robot.unlock(); ArUtil::sleep(50); } printf("directMotionExample: Telling the robot to turn to 180, then sleeping 4 seconds\n"); robot.lock(); robot.setHeading(180); robot.unlock(); start.setToNow(); while (1) { robot.lock(); if (robot.isHeadingDone(5)) { printf("directMotionExample: Finished turn\n"); robot.unlock(); break; } if (start.mSecSince() > 5000) { printf("directMotionExample: Turn timed out\n"); robot.unlock(); break; } robot.unlock(); ArUtil::sleep(100); } printf("directMotionExample: Telling the robot to turn to 90, then sleeping 2 seconds\n"); robot.lock(); robot.setHeading(90); robot.unlock(); start.setToNow(); while (1) { robot.lock(); if (robot.isHeadingDone(5)) { printf("directMotionExample: Finished turn\n"); robot.unlock(); break; } if (start.mSecSince() > 5000) { printf("directMotionExample: turn timed out\n"); robot.unlock(); break; } robot.unlock(); ArUtil::sleep(100); } printf("directMotionExample: Setting vel2 to 200 mm/sec on both wheels, then sleeping 3 seconds\n"); robot.lock(); robot.setVel2(200, 200); robot.unlock(); ArUtil::sleep(3000); printf("directMotionExample: Stopping the robot, then sleeping for 2 seconds\n"); robot.lock(); robot.stop(); robot.unlock(); ArUtil::sleep(2000); printf("directMotionExample: Setting velocity to 200 mm/sec then sleeping 3 seconds\n"); robot.lock(); robot.setVel(200); robot.unlock(); ArUtil::sleep(3000); printf("directMotionExample: Stopping the robot, then sleeping for 2 seconds\n"); robot.lock(); robot.stop(); robot.unlock(); ArUtil::sleep(2000); printf("directMotionExample: Setting vel2 with 0 on left wheel, 200 mm/sec on right, then sleeping 5 seconds\n"); robot.lock(); robot.setVel2(0, 200); robot.unlock(); ArUtil::sleep(5000); printf("directMotionExample: Telling the robot to rotate at 50 deg/sec then sleeping 5 seconds\n"); robot.lock(); robot.setRotVel(50); robot.unlock(); ArUtil::sleep(5000); printf("directMotionExample: Telling the robot to rotate at -50 deg/sec then sleeping 5 seconds\n"); robot.lock(); robot.setRotVel(-50); robot.unlock(); ArUtil::sleep(5000); printf("directMotionExample: Setting vel2 with 0 on both wheels, then sleeping 3 seconds\n"); robot.lock(); robot.setVel2(0, 0); robot.unlock(); ArUtil::sleep(3000); printf("directMotionExample: Now having the robot change heading by -125 degrees, then sleeping for 6 seconds\n"); robot.lock(); robot.setDeltaHeading(-125); robot.unlock(); ArUtil::sleep(6000); printf("directMotionExample: Now having the robot change heading by 45 degrees, then sleeping for 6 seconds\n"); robot.lock(); robot.setDeltaHeading(45); robot.unlock(); ArUtil::sleep(6000); printf("directMotionExample: Setting vel2 with 200 on left wheel, 0 on right wheel, then sleeping 5 seconds\n"); robot.lock(); robot.setVel2(200, 0); robot.unlock(); ArUtil::sleep(5000); printf("directMotionExample: Done, shutting down Aria and exiting.\n"); Aria::shutdown(); return 0; }
int main(int argc, char* argv[]) { Logger::setProcessInformation("CanalEntradaAgente:"); char buffer[TAM_BUFFER]; char bufferSocket[TAM_BUFFER]; ArgumentParser argParser(argc, argv); long idAgente = 0; int idTipoAgente = 0; int idBroker = 0; if ( argParser.parseArgument(1, idAgente) == -1 ) { Logger::logMessage(Logger::COMM, "ERROR: parseArgument 1"); exit(-1); } if ( argParser.parseArgument(2, idTipoAgente) == -1 ) { Logger::logMessage(Logger::COMM, "ERROR: parseArgument 2"); exit(-1); } if ( argParser.parseArgument(3, idBroker) == -1 ) { Logger::logMessage(Logger::COMM, "ERROR: parseArgument 3"); exit(-1); } ServersManager serversManager; // FIXME: Por el momento, hago que todos los agentes se conecten al broker N°1 SocketStream::SocketStreamPtr socketBroker( serversManager.connectToBrokerServer("ServidorCanalSalidaBrokerAgente", idBroker) ); assert( socketBroker.get() ); // Se envían los datos del agente por el socket al CanalSalidaBroker std::stringstream ss; ss << idAgente << " "; ss << idTipoAgente; memcpy(bufferSocket, ss.str().c_str(), sizeof(int) + sizeof(long)); sprintf(buffer, "Se envían los datos del agente: %ld - %d", idAgente, idTipoAgente); Logger::logMessage(Logger::COMM, buffer); if ( socketBroker->send(bufferSocket, TAM_BUFFER) != TAM_BUFFER ) { Logger::logMessage(Logger::ERROR, "Error al enviar el id del agente"); socketBroker->destroy(); abort(); } try { IPC::MsgQueue colaAgente; while( true ) { if ( socketBroker->receive(bufferSocket, TAM_BUFFER) != TAM_BUFFER ) { Logger::logMessage(Logger::ERROR, "Error al recibir mensajes del broker"); socketBroker->destroy(); abort(); } MsgCanalEntradaAgente mensaje; memcpy(&mensaje, bufferSocket, sizeof(MsgCanalEntradaAgente)); /*msg_pedido_t pedido; memcpy(&pedido, mensaje.msg.msg, sizeof(msg_pedido_t)); sprintf(buffer, "MsgPedidoT: %d - %d", pedido.tipo, pedido.pedido.tipoProducto); Logger::logMessage(Logger::IMPORTANT, buffer);*/ sprintf(buffer, "directorioIPC: %s, idIPC: %d, mtype del mensaje a enviar %ld", mensaje.directorioIPC, mensaje.idIPC, mensaje.msg.mtype); Logger::logMessage(Logger::COMM, buffer); colaAgente = obtenerColaAgente(mensaje.directorioIPC, mensaje.idIPC); //char buffer[TAM_BUFFER]; //sprintf(buffer, "Recibe mensaje de Broker: mtype siguiente: %ld, ", mensaje.msg.mtype, ) //Logger::logMessage(Logger::COMM, buffer); colaAgente.send(mensaje.msg); } } catch (Exception & e) { Logger::logMessage(Logger::ERROR, e.get_error_description()); abort(); } return 0; }
int main(int argc, char* argv[]) { try { ArgumentParser argParser(argc, argv); int brokerNumber = 0; // Se recibe por parámetro que Broker se está inicializando if (argc != 2) { Logger::logMessage(Logger::ERROR, "Cantidad de parámetros inválidos"); exit( -1 ); } if (argParser.parseArgument(1, brokerNumber) == -1) { Logger::logMessage(Logger::ERROR, "Argumento inválido"); exit( -1 ); } elegirDirectorios( brokerNumber ); Logger::getInstance().setProcessInformation("TerminatorBrokers:"); std::auto_ptr<IConfigFileParser> cfg( new ConfigFileParser( COMM_OBJECTS_CONFIG_FILE )); cfg->parse(); // Se crea una cola por cada Agente IPC::MsgQueue colaAgente; colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_CLIENTE); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola cliente destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_VENDEDOR); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola vendedor destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_AP); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola AlmacenDePiezas destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_AGV); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola AGV destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT5_AGV); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot5AGV destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT5_CINTA); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot5Cinta destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT11); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot11 destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT12); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot12 destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT14); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot14 destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT16_CINTA); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot16Cinta destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_ROBOT16_DESPACHO); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Robot16Despacho destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_DESPACHO); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Despacho destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_MEMORIA); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Memorias destruida"); colaAgente.getMsgQueue(C_DIRECTORY_BROKER, ID_TIPO_PEDIDO_MEMORIA); colaAgente.destroy(); Logger::logMessage(Logger::COMM, "Cola Pedidos Memorias destruida"); std::list<int> shMemListId = cfg->getParamIntList( "shMem" ); while ( not shMemListId.empty() ) { // Obtengo la memoria compartida contadora IPC::SharedMemory<int> contadoraSharedMemory("Contadora Pedidos ShMem"); contadoraSharedMemory.getSharedMemory(C_DIRECTORY_ADM, shMemListId.front()); contadoraSharedMemory.destroy(); Logger::logMessage(Logger::COMM, "shMemContadoraPedidos destruida"); IPC::Semaphore semaforoContadora("Semaforo Contadora Pedidos"); semaforoContadora.getSemaphore(C_DIRECTORY_ADM, shMemListId.front(), 1); semaforoContadora.destroy(); Logger::logMessage(Logger::COMM, "Semaforo Contadora Pedidos destruida"); shMemListId.pop_front(); } // Cola para que los procesos del Broker se comuniquen con el canal de salida // hacia otro Broker IPC::MsgQueue colaCanalSalidaBrokerBroker; colaCanalSalidaBrokerBroker.getMsgQueue(C_DIRECTORY_BROKER, ID_MSG_QUEUE_CSBB); colaCanalSalidaBrokerBroker.destroy(); Logger::logMessage(Logger::COMM, "cola CanalSalidaBrokerBroker destruida"); // Obtengo la cola por la cual recibo los mensajes del algoritmo Lider IPC::MsgQueue colaLider = IPC::MsgQueue("Cola Lider"); colaLider.getMsgQueue(C_DIRECTORY_BROKER, ID_ALGORITMO_LIDER); colaLider.destroy(); Logger::logMessage(Logger::COMM, "cola Lider destruida"); // Creación de las memorias compartidas que poseen información sobre agentes // conectados IPC::Semaphore semMutexShMemInfoAgentes; semMutexShMemInfoAgentes.getSemaphore(C_DIRECTORY_INFO_AGENTES, ID_INFO_AGENTES, AMOUNT_AGENTS); semMutexShMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "sem InfoAgentes destruído"); IPC::SharedMemory<DataInfoAgentes> shMemInfoAgentes; shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_CLIENTE); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Cliente destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_VENDEDOR); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Vendedor destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_AP); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-AP destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_AGV); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-AGV destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT5_CINTA); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot5_Cinta destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT5_AGV); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot5_AGV destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT11); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot11 destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT12); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot12 destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT14); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot14 destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT16_CINTA); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot16_Cinta destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_ROBOT16_DESPACHO); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Robot16_Despacho destruída"); shMemInfoAgentes.getSharedMemory(C_DIRECTORY_INFO_AGENTES, ID_TIPO_DESPACHO); shMemInfoAgentes.destroy(); Logger::logMessage(Logger::COMM, "shMem InfoAgentes-Despacho destruída"); /* Matriz para identificar qué brokers pertenecen a cada grupo de ShMem. */ IPC::SharedMemory<InformacionGrupoShMemBrokers> shMemInfoGruposShMemBrokers; shMemInfoGruposShMemBrokers.getSharedMemory(C_DIRECTORY_ADM, ID_IPC_INFO_GRUPOS_BROKERS); shMemInfoGruposShMemBrokers.destroy(); Logger::logMessage(Logger::COMM, "shMem InforGruposBrokers creada."); IPC::Semaphore semInfoGruposShMemBrokers; semInfoGruposShMemBrokers.getSemaphore(C_DIRECTORY_ADM, ID_IPC_INFO_GRUPOS_BROKERS, 1); semInfoGruposShMemBrokers.destroy(); Logger::logMessage(Logger::COMM, "sem InforGruposBrokers creado."); // Semaforo de bloqueo de los algoritmo de lider std::list<int> sharedMemoryListIds = cfg->getParamIntList("shMem"); int listSize = sharedMemoryListIds.size(); IPC::Semaphore semaforoLider = IPC::Semaphore("Semaforo Bloqueo Lider"); semaforoLider.getSemaphore(C_DIRECTORY_BROKER, ID_ALGORITMO_LIDER, listSize); semaforoLider.destroy(); ServersManager serversManager; serversManager.killServers( brokerNumber ); } catch (Exception & e) { Logger::logMessage(Logger::ERROR, e.get_error_description()); } return 0; }
int main(int argc, char* argv[]) { Logger::setProcessInformation("Algoritmo Lider:"); char buffer[TAM_BUFFER]; ArgumentParser argParser(argc, argv); int idBroker; int idGrupo; if (argParser.parseArgument(1, idGrupo) == -1) { Logger::logMessage(Logger::COMM, "ERROR: parseArgument 1"); exit(-1); } if (argParser.parseArgument(2, idBroker) == -1) { Logger::logMessage(Logger::COMM, "ERROR: parseArgument 2"); exit(-1); } sprintf(buffer, "Algoritmo Lider Nº%d - Broker N°%d:", idGrupo, idBroker); Logger::setProcessInformation(buffer); Logger::logMessage(Logger::DEBUG, "Iniciado satisfactoriamente"); elegirDirectorios( idBroker ); // Semaforo de bloqueo de los algoritmo de lider std::auto_ptr<IConfigFileParser> cfg( new ConfigFileParser(COMM_OBJECTS_CONFIG_FILE) ); cfg->parse(); std::list<int> sharedMemoryListIds = cfg->getParamIntList("shMem"); int listSize = sharedMemoryListIds.size(); IPC::Semaphore semaforoLider = IPC::Semaphore("Semaforo Bloqueo Lider"); semaforoLider.getSemaphore(C_DIRECTORY_BROKER, ID_ALGORITMO_LIDER, listSize); // Obtengo la cola por la cual recibo los mensajes del algoritmo IPC::MsgQueue colaLider = IPC::MsgQueue("Cola Lider"); colaLider.getMsgQueue(C_DIRECTORY_BROKER, ID_ALGORITMO_LIDER); try { while (true) { // Me bloqueo esperando que deba iniciar el algoritmo MsgAlgoritmoLider msgAlgoritmo; /*char bufferMsgQueue[MSG_BROKER_SIZE]; colaLider.recv(idGrupo, bufferMsgQueue, MSG_BROKER_SIZE); memcpy(&msgAlgoritmo, bufferMsgQueue, sizeof (MsgAlgoritmoLider)); if (msgAlgoritmo.status != INICIAR) { // Para desbloquear el algoritmo del lider el primer mensage debe ser de INICIAR Logger::logMessage(Logger::ERROR, "Se esta intentando iniciar el algoritmo del lider con un mensaqe invalido."); abort(); }*/ semaforoLider.wait(idGrupo-ID_PRIMER_GRUPO_SHMEM); sprintf(buffer, "Se inicia el algoritmo"); Logger::logMessage(Logger::DEBUG, buffer); int lider = 0; bool hayLider = false; // Lo primero que hago es enviar mi id msgAlgoritmo.status = DESCONOCIDO; msgAlgoritmo.uid = idBroker; msgAlgoritmo.mtype = idGrupo; int idBrokerSiguiente = obtenerSiguiente(idBroker, idGrupo); if (idBrokerSiguiente == idBroker) { // No hay otros brokers en el anillo, soy el lider hayLider = true; lider = idBroker; iniciarMemoria(idGrupo); } else { enviarMensajeAlSiguiente(msgAlgoritmo,idBroker,idGrupo); } while (!hayLider) { char bufferMsgQueue[MSG_BROKER_SIZE]; // Espero un mensaje del broker anterior colaLider.recv(idGrupo, bufferMsgQueue, MSG_BROKER_SIZE); memcpy(&msgAlgoritmo, bufferMsgQueue, sizeof (MsgAlgoritmoLider)); if (msgAlgoritmo.status == DESCONOCIDO) { if (msgAlgoritmo.uid == idBroker) { // Me llego un mensaje con mi uid, por lo tanto soy el lider. msgAlgoritmo.status = LIDER; msgAlgoritmo.uid = idBroker; // Envio un mensaje indicando que soy el lider enviarMensajeAlSiguiente(msgAlgoritmo, idBroker, idGrupo); iniciarMemoria(idGrupo); lider = idBroker; hayLider = true; } else if (msgAlgoritmo.uid > idBroker) { // Me llego un mensaje con un uid mayor, por lo tanto lo debo reenviar enviarMensajeAlSiguiente(msgAlgoritmo, idBroker, idGrupo); } else { // Me llego un mensajes con un uid menor, por lo tanto se ignora el mensaje } } else if (msgAlgoritmo.status == LIDER) { // Marcar en una memoria compartida quien es el nuevo lider. lider = msgAlgoritmo.uid; idBrokerSiguiente = obtenerSiguiente(idBroker, idGrupo); if (msgAlgoritmo.uid != idBrokerSiguiente) { // Si el siguiente broker es el lider, no hace falta mandarle un mensaje enviarMensajeAlSiguiente(msgAlgoritmo, idBroker, idGrupo); } hayLider = true; } } sprintf(buffer, "Se encontro lider para el grupo %d: %d", idGrupo, lider); Logger::logMessage(Logger::DEBUG, buffer); } } catch (Exception & e) { Logger::logMessage(Logger::ERROR, e.get_error_description()); } return 0; }
int main(int argc, char* argv[]) { osmscout::CmdLineParser argParser("PerformanceTest", argc,argv); Arguments args; osmscout::DatabaseParameter databaseParameter; argParser.AddOption(osmscout::CmdLineFlag([&args](const bool& value) { args.help=value; }), std::vector<std::string>{"h","help"}, "Display help", true); argParser.AddOption(osmscout::CmdLineFlag([&args](const bool& value) { args.debug=value; }), "debug", "Enable debug output", false); argParser.AddOption(osmscout::CmdLineUIntOption([&args](const unsigned int& value) { args.startZoom=osmscout::MagnificationLevel(value); }), "start-zoom", "Start zoom, default: " + std::to_string(args.startZoom.Get()), false); argParser.AddOption(osmscout::CmdLineUIntOption([&args](const unsigned int& value) { args.endZoom=osmscout::MagnificationLevel(value); }), "end-zoom", "End zoom, default: " + std::to_string(args.endZoom.Get()), false); argParser.AddOption(osmscout::CmdLineUIntOption([&args](const unsigned int& value) { args.tileDimension=std::make_tuple(value, std::get<1>(args.tileDimension)); }), "tile-width", "Tile width, default: " + std::to_string(std::get<0>(args.tileDimension)), false); argParser.AddOption(osmscout::CmdLineUIntOption([&args](const unsigned int& value) { args.tileDimension=std::make_tuple(std::get<0>(args.tileDimension), value); }), "tile-height", "Tile height, default: " + std::to_string(std::get<1>(args.tileDimension)), false); argParser.AddOption(osmscout::CmdLineStringOption([&args](const std::string& value) { args.driver = value; }), "driver", "Rendering driver (cairo|Qt|ag|opengl|noop|none), default: " + args.driver, false); argParser.AddOption(osmscout::CmdLineDoubleOption([&args](const double& value) { if (value > 0) { args.dpi = value; } else { std::cerr << "DPI can't be negative or zero" << std::endl; } }), "dpi", "Rendering DPI, default: " + std::to_string(args.dpi), false); argParser.AddOption(osmscout::CmdLineUIntOption([&args](const unsigned int& value) { args.drawRepeat = value; }), "draw-repeat", "Repeat every draw call, default: " + std::to_string(args.drawRepeat), false); argParser.AddOption(osmscout::CmdLineUIntOption([&args](const unsigned int& value) { args.loadRepeat = value; }), "load-repeat", "Repeat every load call, default: " + std::to_string(args.loadRepeat), false); argParser.AddOption(osmscout::CmdLineFlag([&args](const bool& value) { args.flushCache=value; }), "flush-cache", "Flush data caches after each data load, default: " + std::to_string(args.flushCache), false); argParser.AddOption(osmscout::CmdLineFlag([&args](const bool& value) { args.flushDiskCache=value; }), "flush-disk", "Flush system disk caches after each data load, default: " + std::to_string(args.flushDiskCache) + " (It work just on Linux with admin rights.)", false); argParser.AddOption(osmscout::CmdLineUIntOption([&databaseParameter](const unsigned int& value) { databaseParameter.SetNodeDataCacheSize(value); }), "cache-nodes", "Cache size for nodes, default: " + std::to_string(databaseParameter.GetNodeDataCacheSize()), false); argParser.AddOption(osmscout::CmdLineUIntOption([&databaseParameter](const unsigned int& value) { databaseParameter.SetWayDataCacheSize(value); }), "cache-ways", "Cache size for ways, default: " + std::to_string(databaseParameter.GetWayDataCacheSize()), false); argParser.AddOption(osmscout::CmdLineUIntOption([&databaseParameter](const unsigned int& value) { databaseParameter.SetAreaDataCacheSize(value); }), "cache-areas", "Cache size for areas, default: " + std::to_string(databaseParameter.GetAreaDataCacheSize()), false); #if defined(HAVE_LIB_GPERFTOOLS) argParser.AddOption(osmscout::CmdLineStringOption([&args](const std::string& value) { args.heapProfilePrefix = value; args.heapProfile = !args.heapProfilePrefix.empty(); }), "heap-profile", "GPerf heap profile prefix, profiler is disabled by default", false); #endif argParser.AddPositional(osmscout::CmdLineStringOption([&args](const std::string& value) { args.databaseDirectory=value; }), "databaseDir", "Database directory"); argParser.AddPositional(osmscout::CmdLineStringOption([&args](const std::string& value) { args.style=value; }), "stylesheet", "Map stylesheet"); argParser.AddPositional(osmscout::CmdLineGeoCoordOption([&args](const osmscout::GeoCoord& coord) { args.coordTopLeft = coord; }), "lat_top lon_left", "Bounding box top-left coordinate"); argParser.AddPositional(osmscout::CmdLineGeoCoordOption([&args](const osmscout::GeoCoord& coord) { args.coordBottomRight = coord; }), "lat_bottom lon_right", "Bounding box bottom-right coordinate"); osmscout::CmdLineParseResult argResult=argParser.Parse(); if (argResult.HasError()) { std::cerr << "ERROR: " << argResult.GetErrorDescription() << std::endl; std::cout << argParser.GetHelp() << std::endl; return 1; } else if (args.help) { std::cout << argParser.GetHelp() << std::endl; return 0; } osmscout::log.Debug(args.debug); //databaseParameter.SetDebugPerformance(true); osmscout::DatabaseRef database=std::make_shared<osmscout::Database>(databaseParameter); osmscout::MapServiceRef mapService=std::make_shared<osmscout::MapService>(database); if (!database->Open(args.databaseDirectory)) { std::cerr << "Cannot open database" << std::endl; return 1; } osmscout::StyleConfigRef styleConfig=std::make_shared<osmscout::StyleConfig>(database->GetTypeConfig()); if (!styleConfig->Load(args.style)) { std::cerr << "Cannot open style" << std::endl; return 1; } PerformanceTestBackendPtr backendPtr = PrepareBackend(argc, argv, args, styleConfig); if (!backendPtr){ return 1; } #if defined(HAVE_LIB_GPERFTOOLS) if (args.heapProfile){ HeapProfilerStart(args.heapProfilePrefix.c_str()); } #endif osmscout::TileProjection projection; osmscout::MapParameter drawParameter; osmscout::AreaSearchParameter searchParameter; std::list<LevelStats> statistics; // TODO: Use some way to find a valid font on the system (Agg display a ton of messages otherwise) drawParameter.SetFontName("/usr/share/fonts/TTF/DejaVuSans.ttf"); searchParameter.SetUseMultithreading(true); for (osmscout::MagnificationLevel level=osmscout::MagnificationLevel(std::min(args.startZoom,args.endZoom)); level<=osmscout::MagnificationLevel(std::max(args.startZoom,args.endZoom)); level++) { LevelStats stats(level.Get()); osmscout::Magnification magnification(level); osmscout::OSMTileId tileA(osmscout::OSMTileId::GetOSMTile(magnification, osmscout::GeoCoord(args.LatBottom(),args.LonLeft()))); osmscout::OSMTileId tileB(osmscout::OSMTileId::GetOSMTile(magnification, osmscout::GeoCoord(args.LatTop(),args.LonRight()))); osmscout::OSMTileIdBox tileArea(tileA,tileB); std::cout << "----------" << std::endl; std::cout << "Drawing level " << level << ", " << tileArea.GetCount() << " tiles " << tileArea.GetDisplayText() << std::endl; size_t current=1; size_t tileCount=tileArea.GetCount(); size_t delta=tileCount/20; if (delta==0) { delta=1; } for (const auto& tile : tileArea) { osmscout::MapData data; osmscout::OSMTileIdBox tileBox(osmscout::OSMTileId(tile.GetX()-1,tile.GetY()-1), osmscout::OSMTileId(tile.GetX()+1,tile.GetY()+1)); osmscout::GeoBox boundingBox; if ((current % delta)==0) { std::cout << current*100/tileCount << "% " << current; if (stats.tileCount>0) { std::cout << " " << stats.dbTotalTime/stats.tileCount; std::cout << " " << stats.drawTotalTime/stats.tileCount; } std::cout << std::endl; } projection.Set(tile, magnification, args.dpi, args.TileWidth(), args.TileHeight()); projection.GetDimensions(boundingBox); projection.SetLinearInterpolationUsage(level.Get() >= 10); for (size_t i=0; i<args.loadRepeat; i++) { data.nodes.clear(); data.ways.clear(); data.areas.clear(); osmscout::StopClock dbTimer; osmscout::GeoBox dataBoundingBox(tileBox.GetBoundingBox(magnification)); std::list<osmscout::TileRef> tiles; // set cache size almost unlimited, // for better estimate of peak memory usage by tile loading mapService->SetCacheSize(10000000); mapService->LookupTiles(magnification, dataBoundingBox, tiles); mapService->LoadMissingTileData(searchParameter, *styleConfig, tiles); mapService->AddTileDataToMapData(tiles, data); #if defined(HAVE_LIB_GPERFTOOLS) if (args.heapProfile) { std::ostringstream buff; buff << "load-" << level << "-" << tile.GetX() << "-" << tile.GetY(); HeapProfilerDump(buff.str().c_str()); } struct mallinfo alloc_info = tc_mallinfo(); #else #if defined(HAVE_MALLINFO) struct mallinfo alloc_info = mallinfo(); #endif #endif #if defined(HAVE_MALLINFO) || defined(HAVE_LIB_GPERFTOOLS) std::cout << "memory usage: " << formatAlloc(alloc_info.uordblks) << std::endl; stats.allocMax = std::max(stats.allocMax, (double) alloc_info.uordblks); stats.allocSum = stats.allocSum + (double) alloc_info.uordblks; #endif // set cache size back to default mapService->SetCacheSize(25); dbTimer.Stop(); double dbTime = dbTimer.GetMilliseconds(); stats.dbMinTime = std::min(stats.dbMinTime, dbTime); stats.dbMaxTime = std::max(stats.dbMaxTime, dbTime); stats.dbTotalTime += dbTime; if (args.flushCache) { tiles.clear(); // following flush method removes only tiles with use_count() == 1 mapService->FlushTileCache(); // simplest way howto flush database caches is close it and open again database->Close(); if (!database->Open(args.databaseDirectory)) { std::cerr << "Cannot open database" << std::endl; return 1; } } if (args.flushDiskCache) { // Linux specific if (osmscout::ExistsInFilesystem("/proc/sys/vm/drop_caches")){ osmscout::FileWriter f; try { f.Open("/proc/sys/vm/drop_caches"); f.Write(std::string("3")); f.Close(); }catch(const osmscout::IOException &e){ std::cerr << "Can't flush disk cache: " << e.what() << std::endl; } }else{ std::cerr << "Can't flush disk cache, \"/proc/sys/vm/drop_caches\" file don't exists" << std::endl; } } } stats.nodeCount+=data.nodes.size(); stats.wayCount+=data.ways.size(); stats.areaCount+=data.areas.size(); stats.tileCount++; for (size_t i=0; i<args.drawRepeat; i++) { osmscout::StopClock drawTimer; backendPtr->DrawMap(projection, drawParameter, data); drawTimer.Stop(); double drawTime = drawTimer.GetMilliseconds(); stats.drawMinTime = std::min(stats.drawMinTime, drawTime); stats.drawMaxTime = std::max(stats.drawMaxTime, drawTime); stats.drawTotalTime += drawTime; } current++; } statistics.push_back(stats); } #if defined(HAVE_LIB_GPERFTOOLS) if (args.heapProfile){ HeapProfilerStop(); } #endif std::cout << "==========" << std::endl; for (const auto& stats : statistics) { std::cout << "Level: " << stats.level << std::endl; std::cout << "Tiles: " << stats.tileCount << " (load " << args.loadRepeat << "x, drawn " << args.drawRepeat << "x)" << std::endl; #if defined(HAVE_MALLINFO) || defined(HAVE_LIB_GPERFTOOLS) std::cout << " Used memory: "; std::cout << "max: " << formatAlloc(stats.allocMax) << " "; std::cout << "avg: " << formatAlloc(stats.allocSum / (stats.tileCount * args.loadRepeat)) << std::endl; #endif std::cout << " Tot. data : "; std::cout << "nodes: " << stats.nodeCount << " "; std::cout << "way: " << stats.wayCount << " "; std::cout << "areas: " << stats.areaCount << std::endl; if (stats.tileCount>0) { std::cout << " Avg. data : "; std::cout << "nodes: " << stats.nodeCount/stats.tileCount << " "; std::cout << "way: " << stats.wayCount/stats.tileCount << " "; std::cout << "areas: " << stats.areaCount/stats.tileCount << std::endl; } std::cout << " DB : "; std::cout << "total: " << stats.dbTotalTime << " "; std::cout << "min: " << stats.dbMinTime << " "; if (stats.tileCount>0) { std::cout << "avg: " << stats.dbTotalTime/(stats.tileCount * args.loadRepeat) << " "; } std::cout << "max: " << stats.dbMaxTime << " " << std::endl; std::cout << " Map : "; std::cout << "total: " << stats.drawTotalTime << " "; std::cout << "min: " << stats.drawMinTime << " "; if (stats.tileCount>0) { std::cout << "avg: " << stats.drawTotalTime/(stats.tileCount * args.drawRepeat) << " "; } std::cout << "max: " << stats.drawMaxTime << std::endl; } database->Close(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArArgumentParser argParser(&argc, argv); argParser.loadDefaultArguments(); ArRobot robot; ArRobotConnector robotConnector(&argParser, &robot); ArLaserConnector laserConnector(&argParser, &robot, &robotConnector); // Always try to connect to the first laser: argParser.addDefaultArgument("-connectLaser"); if(!robotConnector.connectRobot()) { ArLog::log(ArLog::Terse, "Could not connect to the robot."); if(argParser.checkHelpAndWarnUnparsed()) { // -help not given, just exit. Aria::logOptions(); Aria::exit(1); } } // Trigger argument parsing if (!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); Aria::exit(1); } ArKeyHandler keyHandler; Aria::setKeyHandler(&keyHandler); robot.attachKeyHandler(&keyHandler); puts("This program will make the robot wander around. It uses some avoidance\n" "actions if obstacles are detected, otherwise it just has a\n" "constant forward velocity.\n\nPress CTRL-C or Escape to exit."); ArSonarDevice sonar; robot.addRangeDevice(&sonar); robot.runAsync(true); // try to connect to laser. if fail, warn but continue, using sonar only if(!laserConnector.connectLasers()) { ArLog::log(ArLog::Normal, "Warning: unable to connect to requested lasers, will wander using robot sonar only."); } // turn on the motors, turn off amigobot sounds robot.enableMotors(); robot.comInt(ArCommands::SOUNDTOG, 0); // add a set of actions that combine together to effect the wander behavior ArActionStallRecover recover; ArActionBumpers bumpers; ArActionAvoidFront avoidFrontNear("Avoid Front Near", 225, 0); ArActionAvoidFront avoidFrontFar; ArActionConstantVelocity constantVelocity("Constant Velocity", 400); robot.addAction(&recover, 100); robot.addAction(&bumpers, 75); robot.addAction(&avoidFrontNear, 50); robot.addAction(&avoidFrontFar, 49); robot.addAction(&constantVelocity, 25); // wait for robot task loop to end before exiting the program robot.waitForRunExit(); Aria::exit(0); }
int main(int argc, char* argv[]) { ArgumentParser argParser(argc, argv); char buffer[TAM_BUFFER]; char bufferSocket[TAM_BUFFER]; int socketDescriptor = 0; int brokerNumber = 0; int remoteBrokerId = 0; if ( argParser.parseArgument(1, socketDescriptor) == -1 ) { Logger::logMessage(Logger::ERROR, "ERROR: Parse Argument 1."); exit(-1); } if ( argParser.parseArgument(2, brokerNumber) == -1 ) { Logger::logMessage(Logger::ERROR, "ERROR: Parse Argument 2."); exit(-1); } if ( argc == 4 && socketDescriptor == 0 ) { if ( argParser.parseArgument(3, remoteBrokerId) == -1 ) { Logger::logMessage(Logger::ERROR, "ERROR: Parse Argument 3."); exit(-1); } } elegirDirectorios( brokerNumber ); sprintf(buffer, "CanalSalidaBrokerBroker N°%d - N°%d:", brokerNumber, remoteBrokerId); Logger::setProcessInformation(buffer); SocketStream* socketBroker = NULL; if ( socketDescriptor == 0 ) { sprintf(buffer, "Creando conexión con Broker N°%d", remoteBrokerId); Logger::logMessage(Logger::DEBUG, buffer); // El proceso no fue creado por un servidor, debe conectarse al // mismo ServersManager serversManager; socketBroker = serversManager.connectToBrokerServer( "ServidorCanalEntradaBrokerBroker", remoteBrokerId); if ( socketBroker == NULL ) { abort(); } // Envía al otro extremo del canal su número de Broker memcpy(bufferSocket, &brokerNumber, sizeof(int)); if ( socketBroker->send(bufferSocket, TAM_BUFFER) != TAM_BUFFER ) { Logger::logMessage(Logger::ERROR, "Error al envíar brokerNumber por el Socket"); socketBroker->destroy(); abort(); } } else { // El proceso fue creado por un servidor SocketStream aux( socketDescriptor ); socketBroker = &aux; // Recibe el número de Broker con el cual se conectó if ( socketBroker->receive(bufferSocket, TAM_BUFFER) != TAM_BUFFER ) { Logger::logMessage(Logger::ERROR, "Error al recibir brokerNumber por el Socket"); socketBroker->destroy(); abort(); } memcpy(& remoteBrokerId, bufferSocket, sizeof(int)); } sprintf(buffer, "CanalSalidaBrokerBroker N°%d - N°%d:", brokerNumber, remoteBrokerId); Logger::setProcessInformation(buffer); Logger::logMessage(Logger::COMM, "Conexión realizada correctamente"); try { IPC::MsgQueue colaCanalSalida("ColaCanalSalida"); colaCanalSalida.getMsgQueue(C_DIRECTORY_BROKER, ID_MSG_QUEUE_CSBB); while ( true ) { MsgCanalSalidaBrokerBroker mensaje; colaCanalSalida.recv(remoteBrokerId, mensaje); Logger::logMessage(Logger::COMM, "Recibe mensaje, procede a enviarlo"); memcpy(bufferSocket, &mensaje.msg, sizeof(MsgCanalEntradaBrokerBroker)); if ( socketBroker->send(bufferSocket, TAM_BUFFER) != TAM_BUFFER ) { Logger::logMessage(Logger::ERROR, "Error al enviar mensaje a Broker"); socketBroker->destroy(); abort(); } } } catch( Exception & e) { Logger::logMessage(Logger::ERROR, e.get_error_description()); socketBroker->destroy(); if (socketDescriptor == 0) { delete socketBroker; } abort(); } Logger::logMessage(Logger::COMM, "Destruyendo canal"); socketBroker->destroy(); if (socketDescriptor == 0) { delete socketBroker; } return 0; }