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