int main(int argc, char** argv)
{
// set up our simpleConnector
ArSimpleConnector simpleConnector(&argc, argv);
// robot
ArRobot robot;
// a key handler so we can do our key handling
ArKeyHandler keyHandler;
ArLog::init(ArLog::StdOut,ArLog::Verbose);
// if there are more arguments left then it means we didn't
// understand an option
if (!simpleConnector.parseArgs() || argc > 1)
{
simpleConnector.logOptions();
keyHandler.restore();
exit(1);
}
// mandatory init
Aria::init();
ArLog::init(ArLog::StdOut, ArLog::Terse, NULL, true);
// let the global aria stuff know about it
Aria::setKeyHandler(&keyHandler);
// toss it on the robot
robot.attachKeyHandler(&keyHandler);
// set up the robot for connecting
if (!simpleConnector.connectRobot(&robot))
{
printf("Could not connect to robot... exiting\n");
Aria::shutdown();
keyHandler.restore();
return 1;
}
// turn on the motors for the velocity response test
robot.comInt(ArCommands::ENABLE, 1);
velTime.setToNow();
// turn off the sonar
robot.comInt(ArCommands::SONAR, 0);
ArGlobalFunctor1<ArRobot *> userTaskCB(&userTask, &robot);
robot.addUserTask("iotest", 100, &userTaskCB);
robot.comInt(ArCommands::IOREQUEST, 1);
requestTime.setToNow();
//start the robot running, true so that if we lose connection the run stops
robot.run(true);
// now exit
Aria::shutdown();
return 0;
}
/*!
* Callback function for the q key.
*/
void
quitCB(void)
{
roundRobinFlag = false;
keyHandler.restore();
advancedptr->shutDown();
}
int main(int argc, char **argv)
{
char* host = "localhost";
if(argc > 1)
host = argv[1];
Aria::init();
ArClientBase client;
ArGlobalFunctor escapeCB(&escape);
ArKeyHandler keyHandler;
Aria::setKeyHandler(&keyHandler);
printf("Connecting to standaloneServerDemo at %s:%d...\n", host, 7272);
if (!client.blockingConnect(host, 7272))
{
printf("Could not connect to server, exiting\n");
exit(1);
}
InputHandler inputHandler(&client, &keyHandler);
OutputHandler outputHandler(&client);
keyHandler.addKeyHandler(ArKeyHandler::ESCAPE, &escapeCB);
client.runAsync();
while (client.getRunningWithLock())
{
keyHandler.checkKeys();
ArUtil::sleep(1);
}
keyHandler.restore();
Aria::shutdown();
return 0;
}
void hardExit(void)
{
ArKeyHandler *keyHandler;
robot->disconnect();
if ((keyHandler = Aria::getKeyHandler()) != NULL)
keyHandler->restore();
else
printf("Could not restore keyboard settings.");
exit(0);
}
int main(int argc, char **argv)
{
bool done;
double distToTravel = 2300;
// whether to use the sim for the laser or not, if you use the sim
// for hte laser, you have to use the sim for the robot too
bool useSim = false;
// the laser
ArSick sick;
// connection
ArDeviceConnection *con;
// Laser connection
ArSerialConnection laserCon;
// robot
ArRobot robot;
// set a default filename
//std::string filename = "c:\\log\\1scans.2d";
std::string filename = "1scans.2d";
// see if we want to use a different filename
//if (argc > 1)
//Lfilename = argv[1];
printf("Logging to file %s\n", filename.c_str());
// start the logger with good values
sick.configureShort(useSim, ArSick::BAUD38400,
ArSick::DEGREES180, ArSick::INCREMENT_HALF);
ArSickLogger logger(&robot, &sick, 300, 25, filename.c_str());
// mandatory init
Aria::init();
// add it to the robot
robot.addRangeDevice(&sick);
//ArAnalogGyro gyro(&robot);
// if we're not using the sim, make a serial connection and set it up
if (!useSim)
{
ArSerialConnection *serCon;
serCon = new ArSerialConnection;
serCon->setPort();
//serCon->setBaud(38400);
con = serCon;
}
// if we are using the sim, set up a tcp connection
else
{
ArTcpConnection *tcpCon;
tcpCon = new ArTcpConnection;
tcpCon->setPort();
con = tcpCon;
}
// set the connection on the robot
robot.setDeviceConnection(con);
// try to connect, if we fail exit
if (!robot.blockingConnect())
{
printf("Could not connect to robot... exiting\n");
Aria::shutdown();
return 1;
}
// set up a key handler so escape exits and attach to the robot
ArKeyHandler keyHandler;
robot.attachKeyHandler(&keyHandler);
// run the robot, true here so that the run will exit if connection lost
robot.runAsync(true);
// if we're not using the sim, set up the port for the laser
if (!useSim)
{
laserCon.setPort(ArUtil::COM3);
sick.setDeviceConnection(&laserCon);
}
// now that we're connected to the robot, connect to the laser
sick.runAsync();
if (!sick.blockingConnect())
{
printf("Could not connect to SICK laser... exiting\n");
robot.disconnect();
Aria::shutdown();
return 1;
}
#ifdef WIN32
// wait until someone pushes the motor button to go
while (1)
{
robot.lock();
if (!robot.isRunning())
exit(0);
if (robot.areMotorsEnabled())
{
robot.unlock();
break;
}
robot.unlock();
ArUtil::sleep(100);
}
#endif
// basically from here on down the robot just cruises around a bit
robot.lock();
// enable the motors, disable amigobot sounds
robot.comInt(ArCommands::ENABLE, 1);
// move a couple meters
robot.setRotVel(3000);
robot.unlock();
ArUtil::sleep(15 * 1000);
robot.lock();
robot.disconnect();
robot.unlock();
keyHandler.restore();
exit(1);
// now exit
return 0;
}
int main(int argc, char **argv)
{
bool done;
double distToTravel = 3000;
int spinTime = 0;
// set up our simpleConnector
ArSimpleConnector simpleConnector(&argc, argv);
// set up a key handler so escape exits and attach to the robot
ArKeyHandler keyHandler;
Aria::init();
robot = new ArRobot;
printf("You can press the escape key to exit this program\n");
// parse its arguments
if (simpleConnector.parseArgs())
{
simpleConnector.logOptions();
exit(1);
}
// if there are more arguments left then it means we didn't
// understand an option
/*
if (argc > 1)
{
simpleConnector.logOptions();
keyHandler.restore();
exit(1);
}
*/
ArGlobalFunctor exitCB(&hardExit);
ArGlobalFunctor printerCB(&printer);
keyHandler.addKeyHandler(ArKeyHandler::ESCAPE, &exitCB);
robot->attachKeyHandler(&keyHandler);
Aria::setKeyHandler(&keyHandler);
// set up the robot for connecting
if (!simpleConnector.connectRobot(robot))
{
printf("Could not connect to robot... exiting\n");
Aria::shutdown();
keyHandler.restore();
return 1;
}
//robot->addUserTask("printer", 50, &printerCB);
// run the robot, true here so that the run will exit if connection lost
robot->runAsync(true);
#ifdef WIN32
// wait until someone pushes the motor button to go
printf("Press the motor button to start the robot moving\n");
while (1)
{
robot->lock();
if (!robot->isRunning())
hardExit();
if (robot->areMotorsEnabled())
{
robot->unlock();
break;
}
robot->unlock();
ArUtil::sleep(100);
}
#endif
ArAnalogGyro *gyro;
if (argc == 1)
{
printf("Gyro\n");
gyro = new ArAnalogGyro(robot);
}
printf("Waiting for inertial to stabilize for 5 seconds.\n");
// wait a bit for the inertial to warm up
ArUtil::sleep(5000);
// basically from here on down the robot just cruises around a bit
robot->lock();
// enable the motors, disable amigobot sounds
robot->comInt(ArCommands::SONAR, 0);
robot->comInt(ArCommands::ENABLE, 1);
robot->setMoveDoneDist(200);
// move a couple meters
printf("Driving out\n");
robot->move(distToTravel);
robot->setHeading(0);
robot->unlock();
do {
ArUtil::sleep(100);
robot->lock();
//robot->setHeading(0);
done = robot->isMoveDone(200);
robot->unlock();
} while (!done);
if (spinTime != 0)
{
printf("Spinning a while\n");
// rotate a few times
robot->lock();
robot->setRotVel(200);
robot->unlock();
ArUtil::sleep(spinTime * 1000);
}
printf("Pointing back\n");
robot->lock();
robot->setHeading(180);
robot->unlock();
do {
ArUtil::sleep(100);
robot->lock();
//robot->setHeading(180);
done = robot->isHeadingDone(5);
robot->unlock();
} while (!done);
printf("Driving back\n");
// move a couple meters
robot->lock();
robot->move(distToTravel);
robot->setHeading(180);
robot->unlock();
do {
ArUtil::sleep(100);
robot->lock();
//robot->setHeading(180);
done = robot->isMoveDone(200);
robot->unlock();
} while (!done);
printf("Pointing back in original direction.\n");
robot->lock();
robot->setHeading(0);
robot->unlock();
do {
ArUtil::sleep(100);
robot->lock();
//robot->setHeading(0);
done = robot->isHeadingDone(5);
robot->unlock();
} while (!done);
robot->lock();
printf("Final heading %.2f\n", robot->getTh());
robot->disconnect();
robot->unlock();
// now exit
Aria::shutdown();
return 0;
}
int main(int argc, char **argv)
{
int key;
ArKeyHandler keyHandler;
Aria::init();
printf("type away... (ESC to quit)\n");
while (1)
{
//keyHandler.checkKeys();
key = keyHandler.getKey();
if(key == -1)
{
ArUtil::sleep(100);
continue;
}
printf("keyHandler.getKey() returned %d.\n", key);
switch (key) {
case ArKeyHandler::UP:
printf("Up\n");
break;
case ArKeyHandler::DOWN:
printf("Down\n");
break;
case ArKeyHandler::LEFT:
printf("Left\n");
break;
case ArKeyHandler::RIGHT:
printf("Right\n");
break;
case ArKeyHandler::ESCAPE:
printf("Escape\n");
printf("Exiting\n");
keyHandler.restore();
exit(0);
case ArKeyHandler::F1:
printf("F1\n");
break;
case ArKeyHandler::F2:
printf("F2\n");
break;
case ArKeyHandler::F3:
printf("F3\n");
break;
case ArKeyHandler::F4:
printf("F4\n");
break;
case ArKeyHandler::F5:
printf("F5\n");
break;
case ArKeyHandler::F6:
printf("F6\n");
break;
case ArKeyHandler::F7:
printf("F7\n");
break;
case ArKeyHandler::F8:
printf("F8\n");
break;
case ArKeyHandler::F9:
printf("F9\n");
break;
case ArKeyHandler::F10:
printf("F10\n");
break;
case ArKeyHandler::F11:
printf("F11\n");
break;
case ArKeyHandler::F12:
printf("F12\n");
break;
case ArKeyHandler::HOME:
printf("HOME\n");
break;
case ArKeyHandler::END:
printf("END\n");
break;
case ArKeyHandler::INSERT:
printf("INSERT\n");
break;
case ArKeyHandler::DEL:
printf("DELETE\n");
break;
case ArKeyHandler::PAGEUP:
printf("PAGEUP\n");
break;
case ArKeyHandler::PAGEDOWN:
printf("PAGEDOWN\n");
break;
case ArKeyHandler::SPACE:
printf("Space\n");
break;
case ArKeyHandler::TAB:
printf("Tab\n");
break;
case ArKeyHandler::ENTER:
printf("Enter\n");
break;
case ArKeyHandler::BACKSPACE:
printf("Backspace\n");
break;
case -1:
ArUtil::sleep(1);
break;
default:
printf("'%c' %d\n", key, key);
break;
}
}
}
int main(int argc, char **argv)
{
double speed = 1000;
double squareSide = 2000;
// whether to use the sim for the laser or not, if you use the sim
// for hte laser, you have to use the sim for the robot too
// robot
robot = new ArRobot;
// the laser
ArSick sick;
// set up our simpleConnector
ArSimpleConnector simpleConnector(&argc, argv);
// set up a key handler so escape exits and attach to the robot
ArKeyHandler keyHandler;
robot->attachKeyHandler(&keyHandler);
// parse its arguments
if (simpleConnector.parseArgs())
{
simpleConnector.logOptions();
keyHandler.restore();
exit(1);
}
// if there are more arguments left then it means we didn't
// understand an option
/*
if (argc > 1)
{
simpleConnector.logOptions();
keyHandler.restore();
exit(1);
}
*/
// set a default filename
//std::string filename = "c:\\log\\1scans.2d";
std::string filename = "1scans.2d";
// see if we want to use a different filename
//if (argc > 1)
//Lfilename = argv[1];
printf("Logging to file %s\n", filename.c_str());
// start the logger with good values
//sick.configureShort(useSim, ArSick::BAUD38400, ArSick::DEGREES180, ArSick::INCREMENT_HALF);
ArSickLogger logger(robot, &sick, 300, 25, filename.c_str());
// mandatory init
Aria::init();
// add it to the robot
robot->addRangeDevice(&sick);
//ArAnalogGyro gyro(robot);
// set up the robot for connecting
if (!simpleConnector.connectRobot(robot))
{
printf("Could not connect to robot->.. exiting\n");
Aria::shutdown();
return 1;
}
robot->setRotVelMax(300);
robot->setRotAccel(300);
robot->setRotDecel(300);
robot->setAbsoluteMaxTransVel(2000);
robot->setTransVelMax(2000);
robot->setTransAccel(500);
robot->setTransDecel(500);
/*
robot->comInt(82, 30); // rotkp
robot->comInt(83, 200); // rotkv
robot->comInt(84, 0); // rotki
robot->comInt(85, 15); // transkp
robot->comInt(86, 450); // transkv
robot->comInt(87, 4); // transki
*/
robot->comInt(82, 30); // rotkp
robot->comInt(83, 200); // rotkv
robot->comInt(84, 0); // rotki
robot->comInt(85, 30); // transkp
robot->comInt(86, 450); // transkv
robot->comInt(87, 4); // transki
// run the robot, true here so that the run will exit if connection lost
robot->runAsync(true);
// set up the laser before handing it to the laser mode
simpleConnector.setupLaser(&sick);
// now that we're connected to the robot, connect to the laser
sick.runAsync();
if (!sick.blockingConnect())
{
printf("Could not connect to SICK laser... exiting\n");
robot->disconnect();
Aria::shutdown();
return 1;
}
robot->lock();
robot->addUserTask("printer", 50, new ArGlobalFunctor(&printer));
robot->unlock();
#ifdef WIN32
// wait until someone pushes the motor button to go
while (1)
{
robot->lock();
if (!robot->isRunning())
exit(0);
if (robot->areMotorsEnabled())
{
robot->unlock();
break;
}
robot->unlock();
ArUtil::sleep(100);
}
#endif
// basically from here on down the robot just cruises around a bit
printf("Starting moving\n");
robot->lock();
// enable the motors, disable amigobot sounds
robot->comInt(ArCommands::ENABLE, 1);
robot->setHeading(0);
robot->setVel(1000);
robot->unlock();
ArUtil::sleep(speed / 500.0 * 1000.0);
printf("Should be up to speed, moving on first side\n");
ArUtil::sleep(squareSide / speed * 1000);
printf("Turning to second side\n");
robot->lock();
robot->setHeading(90);
robot->setVel(speed);
robot->unlock();
ArUtil::sleep(squareSide / speed * 1000);
printf("Turning to third side\n");
robot->lock();
robot->setHeading(180);
robot->setVel(speed);
robot->unlock();
ArUtil::sleep(squareSide / speed * 1000);
printf("Turning to last side\n");
robot->lock();
robot->setHeading(-90);
robot->setVel(speed);
robot->unlock();
ArUtil::sleep(squareSide / speed * 1000);
printf("Pointing back original direction and stopping\n");
robot->lock();
robot->setHeading(0);
robot->setVel(0);
robot->unlock();
ArUtil::sleep(300);
printf("Stopped\n");
sick.lockDevice();
sick.disconnect();
sick.unlockDevice();
robot->lock();
robot->disconnect();
robot->unlock();
// now exit
Aria::shutdown();
return 0;
}
