void drawing(ArNetPacket *packet) { int numDrawings; int i; char name[512]; char shape[512]; long primary, size, layer, secondary; unsigned long refresh; numDrawings = packet->bufToByte4(); ArLog::log(ArLog::Normal, "There are %d drawings", numDrawings); for (i = 0; i < numDrawings; i++) { packet->bufToStr(name, sizeof(name)); packet->bufToStr(shape, sizeof(shape)); primary = packet->bufToByte4(); size = packet->bufToByte4(); layer = packet->bufToByte4(); refresh = packet->bufToByte4(); secondary = packet->bufToByte4(); ArLog::log(ArLog::Normal, "name %-20s shape %-20s", name, shape); ArLog::log(ArLog::Normal, "\tprimary %08x size %2d layer %2d refresh %4u secondary %08x", primary, size, layer, refresh, secondary); client.addHandler(name, &drawingDataCB); client.request(name, refresh); } }
bool PtzCameraExample::init() { // If the server has the "getCameraList" request, then it's using // ArServerHandlerCameraCollection, and migth have multiple PTZs/cameras each with // its own set of requests. So send a "getCameraList" request, and when its // reply is received, the handler will send "getCameraInfo" requests for each. // If the server does not have "getCameraList", it only has one PTZ camera, just // send "getCameraInfo". The handler for that will send various control // commands. // If the server does not have "getCameraInfo", then it doesn't provide any // access to PTZ cameras. if(myClient->dataExists("getCameraList")) { ArLog::log(ArLog::Normal, "Server may have multiple cameras. Requesting list."); myClient->addHandler("getCameraList", &myCameraListReplyFunc); myClient->requestOnce("getCameraList"); } else if(myClient->dataExists("getCameraInfo")) { ArLog::log(ArLog::Normal, "Server does not support multiple cameras. Requesting info for its camera."); ArClientHandlerCamera *camClient = new ArClientHandlerCamera(myClient, ""); camClient->requestUpdates(100); mutex.lock(); myCameras.insert(camClient); mutex.unlock(); } else { ArLog::log(ArLog::Terse, "Error, server does not have any camera control requests. (Was the server run with video features enabled or video forwarding active?)"); return false; } return true; }
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 InputHandler::space(void) { ArNetPacket packet; packet.doubleToBuf(0.00001); myClient->requestOnce("setVel", &packet); myClient->requestOnce("deltaHeading", &packet); }
int main(int argc, char **argv) { ros::init(argc, argv, "ariaClientDriverNode"); //ROS Initialization Aria::init(); //Aria Initialization ArClientBase client; //setup client ArArgumentParser parser(&argc, argv); //command line argument handler ArClientSimpleConnector clientConnector(&parser); //connect to Arserver parser.loadDefaultArguments(); if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } printf("Connected to server.\n"); client.setRobotName(client.getHost()); // include server name in log messages ArKeyHandler keyHandler; Aria::setKeyHandler(&keyHandler); ArGlobalFunctor escapeCB(&escape); keyHandler.addKeyHandler(ArKeyHandler::ESCAPE, &escapeCB); client.runAsync(); if(!client.dataExists("ratioDrive") ) printf("Warning: server does not have ratioDrive command, can not use drive commands!\n"); else printf("Keys are:\nUP: Forward\nDOWN: Backward\nLEFT: Turn Left\nRIGHT: Turn Right\n"); printf("s: Enable safe drive mode (if supported).\nu: Disable safe drive mode (if supported).\nl: list all data requests on server\n\nDrive commands use 'ratioDrive'.\nt: logs the network tracking tersely\nv: logs the network tracking verbosely\nr: resets the network tracking\n\n"); AriaClientDriver ariaClientDriver(&client,&keyHandler,""); //while (ros::ok() && client.getRunningWithLock()) //the main loop while (client.getRunningWithLock()) //the main loop { keyHandler.checkKeys(); //addthis if teleop from node required ariaClientDriver.controlloop(); //Input output handling callback threads implemented in ariaClientDriver Class ArUtil::sleep(100); //noneed } client.disconnect(); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArClientBase client; ArArgumentParser parser(&argc, argv); /* This will be used to connect our client to the server. * It will get the hostname from the -host command line argument: */ ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); /* Check for -host, -help, ARIA arguments, and unhandled arguments: */ if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); Aria::exit(0); } /* Connect our client object to the remote server: */ if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); Aria::exit(1); } printf("Connected to server.\n"); client.setRobotName(client.getHost()); // include server name in log messages client.runAsync(); ArClientHandlerRobotUpdate updates(&client); updates.requestUpdates(); while (client.getRunningWithLock()) { updates.lock(); printf("Mode:%s Status:%s Pos:%.0f,%.0f,%.0f Vel:%.0f,%.0f,%.0f Bat:%.1f \r", updates.getMode(), updates.getStatus(), updates.getX(), updates.getY(), updates.getTh(), updates.getVel(), updates.getLatVel(), updates.getRotVel(), updates.getVoltage() ); updates.unlock(); ArUtil::sleep(1000); } /* The client stopped running, due to disconnection from the server, general * Aria shutdown, or some other reason. */ client.disconnect(); Aria::exit(0); return 0; }
int main(int argc, char **argv) { Aria::init(); ArLog::init(ArLog::StdOut, ArLog::Normal); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } client.setRobotName(client.getHost()); // include server hostname in log messages client.runAsync(); ArUtil::sleep(500); client.logDataList(); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArClientBase client; std::string host; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); /* Check for -help, and unhandled arguments: */ if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } /* Connect our client object to the remote server: */ if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server rejected connection, exiting\n"); else printf("Could not connect to server, exiting\n"); exit(1); } client.addHandler("getCameraModeListCam1", new ArGlobalFunctor1<ArNetPacket *>(&getCameraModeList)); client.requestOnce("getCameraModeListCam1"); ArNetPacket sending; // This does the look at goal mode sending.empty(); sending.strToBuf("lookAtGoal"); client.requestOnce("setCameraModeCam1", &sending); // This does the look at point mode (at 0 0); sending.empty(); sending.strToBuf("lookAtPoint"); sending.byte4ToBuf(1157); sending.byte4ToBuf(-15786); client.requestOnce("setCameraModeCam1", &sending); while (Aria::getRunning() && client.isConnected()) { client.loopOnce(); ArUtil::sleep(1000); } Aria::shutdown(); return 0; };
/** Stop the robot */ JNIEXPORT jint JNICALL Java_com_adept_arandroid_ArjRobot_stop (JNIEnv *env, jobject obj) { debugPrint("Stopping robot"); myClient.requestOnce("stop"); return 1; }
bool ArNetCameraRequest::requestPanTiltAbs(double pan, double tilt) { empty(); byte2ToBuf((ArTypes::Byte2)(pan * 1000.0)); byte2ToBuf((ArTypes::Byte2)(tilt * 1000.0)); finalizePacket(); return myClient->requestOnce(myAbsReqName.c_str(), this); }
ArClientHandlerCamera(ArClientBase *client, const char *cameraName) : name(cameraName), myClient(client), request(client, cameraName) , myCameraInfoReplyFunc(this, &ArClientHandlerCamera::handleCameraInfoReply), myCameraDataReplyFunc(this, &ArClientHandlerCamera::handleCameraDataReply) { myClient->addHandler((std::string("getCameraInfo")+name).c_str(), &myCameraInfoReplyFunc); myClient->addHandler((std::string("getCameraData")+name).c_str(), &myCameraDataReplyFunc); }
int main(int argc, char **argv) { std::string hostname; Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); if (argc == 1) hostname = "localhost"; else hostname = argv[1]; if (!client.blockingConnect(hostname.c_str(), 7272)) { printf("Could not connect to server, exiting\n"); exit(1); } /* ArGlobalFunctor1<ArNetPacket *> getDirListingCB(&getDirListing); client.addHandler("getDirListing", &getDirListingCB); //client.requestOnceWithString("getDirListing", ""); ArGlobalFunctor1<ArNetPacket *> getFileCB(&netGetFile); client.addHandler("getFile", &getFileCB); client.requestOnceWithString("getFile", "all.bob"); ArGlobalFunctor1<ArNetPacket *> netPutFileCB(&netPutFile); client.addHandler("putFile", &netPutFileCB); putFile("doxygen.conf", "ArGH/DoxYGEN"); */ ArGlobalFunctor1<ArNetPacket *> deleteFileCB(&netDeleteFile); client.addHandler("deleteFile", &deleteFileCB); client.requestOnceWithString("deleteFile", "1/all.bob"); client.runAsync(); while (client.getRunningWithLock()) { ArUtil::sleep(1); } Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArLog::init(ArLog::StdOut, ArLog::Normal); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } ArGlobalFunctor1<ArNetPacket *> getModeDataListCB(&getModeDataList); ArGlobalFunctor1<ArNetPacket *> getModeInfoCB(&getModeInfo); client.addHandler("getModeDataList", &getModeDataListCB); client.requestOnce("getModeDataList"); client.addHandler("getModeInfo", &getModeInfoCB); client.request("getModeInfo", -1); client.runAsync(); while (client.getRunningWithLock()) { ArUtil::sleep(1); //printf("%d ms since last data\n", client.getLastPacketReceived().mSecSince()); } Aria::shutdown(); return 0; }
/** Go to a named goal */ JNIEXPORT jint JNICALL Java_com_adept_arandroid_ArjRobot_gotoGoal (JNIEnv *env, jobject obj, jstring goal) { const char *cGoal = env->GetStringUTFChars(goal, 0); debugPrintS("Sending to goal ", cGoal); myOutputHandler->setGoal(cGoal); ArUtil::sleep(100); myClient.requestOnceWithString("gotoGoal", cGoal); debugPrint("On its way"); //env->ReleaseStringUTFChars(goal, cGoal); }
void drawingData(ArNetPacket *packet) { int x, y; int numReadings; int i; numReadings = packet->bufToByte4(); if (numReadings == 0) { printf("No readings for sensor %s\n", client.getName(packet)); } printf("Readings for %s:", client.getName(packet)); for (i = 0; i < numReadings; i++) { x = packet->bufToByte4(); y = packet->bufToByte4(); printf(" (%d %d)", x, y); } printf("\n\n"); }
/** Initialize the robot connection */ JNIEXPORT jint JNICALL Java_com_adept_arandroid_ArjRobot_initialize (JNIEnv *env, jobject obj, jstring host, jint port) { // Get the host ip address const char *cHost = env->GetStringUTFChars(host, 0); // Try to connect Aria::init(); ArLog::setFunctor(new ArGlobalFunctor1<const char*>(ariaLogDebugPrint)); debugPrintS("Connecting to ", cHost); if (!myClient.blockingConnect(cHost, port, true, NULL, NULL, NULL)) { debugPrint("Error connecting"); return -1; } debugPrint("Connected"); // Run the client connection in a different thread myClient.runAsync(); // Download the map, maybe move this to it's own function later debugPrint("getting map"); myClient.requestOnce("getMapBinary"); // Create the OutputHandler myOutputHandler = new OutputHandler(&myClient); /* Block until the connection is closed. We will use this time to get * status update information at a regular rate. */ myShutdown = false; while (myClient.getRunningWithLock() && !myShutdown) { ArUtil::sleep(100); myServerStatus = myOutputHandler->getServerStatus(); myOutputHandler->getRobotStatus(myRobotStatus); } debugPrint("Shutting down Aria"); myClient.disconnect(); Aria::shutdown(); return 0; }
void InputHandler::sendInput(void) { /* This method is called by the main function to send a ratioDrive * request with our current velocity values. If the server does * not support the ratioDrive request, then we abort now: */ if(!myClient->dataExists("ratioDrive")) return; /* Construct a ratioDrive request packet. It consists * of three doubles: translation ratio, rotation ratio, and an overall scaling * factor. */ ArNetPacket packet; packet.doubleToBuf(myTransRatio); packet.doubleToBuf(myRotRatio); packet.doubleToBuf(50); // use half of the robot's maximum. packet.doubleToBuf(myLatRatio); if (myPrinting) printf("Sending\n"); myClient->requestOnce("ratioDrive", &packet); myTransRatio = 0; myRotRatio = 0; myLatRatio = 0; }
void InputHandler::safeDrive() { /* Construct a request packet. The data is a single byte, with value * 1 to enable safe drive, 0 to disable. */ ArNetPacket p; p.byteToBuf(1); /* Send the packet as a single request: */ if(myPrinting) printf("Sending setSafeDrive 1.\n"); myClient->requestOnce("setSafeDrive",&p); if(myPrinting) printf("\nSent enable safe drive.\n"); }
void InputHandler::unsafeDrive() { /* Construct a request packet. The data is a single byte, with value * 1 to enable safe drive, 0 to disable. */ ArNetPacket p; p.byteToBuf(0); /* Send the packet as a single request: */ if(myPrinting) printf("Sending setSafeDrive 0.\n"); myClient->requestOnce("setSafeDrive",&p); if(myPrinting) printf("\nSent disable safe drive command. Your robot WILL run over things if you're not careful.\n"); }
int main(int argc, char **argv) { ArGlobalFunctor1<ArNetPacket *> getMapNameCB(handleGetMapName); ArGlobalFunctor1<ArNetPacket *> getMapCB(handleGetMap); Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); /* Check for -help, and unhandled arguments: */ if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); exit(0); } /* Connect our client object to the remote server: */ if (!clientConnector.connectClient(&client)) { exit(1); } client.addHandler("getMap", &getMapCB); client.addHandler("getMapName", &getMapNameCB); client.requestOnce("getMapName"); start.setToNow(); client.requestOnce("getMap"); client.run(); }
int main(int argc, char **argv) { std::string hostname; ArGlobalFunctor1<ArNetPacket *> drawingCB(&drawing); Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); /* Check for -help, and unhandled arguments: */ if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); exit(0); } /* Connect our client object to the remote server: */ if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } printf("Connected to server.\n"); client.addHandler("listDrawings", &drawingCB); client.requestOnce("listDrawings"); client.runAsync(); while (client.getRunningWithLock()) { ArUtil::sleep(1); //printf("%d ms since last data\n", client.getLastPacketReceived().mSecSince()); } Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } if (parser.getArgc() < 4 || parser.getArgc() > 6) { printf("usage: %s <x> <y> <th> <optional:xyspread> <optional:thspread>", argv[0]); exit(1); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } client.runAsync(); ArNetPacket sending; // put in the arguments (you can see what they are from doing -lcl on clientDemo) sending.byte4ToBuf(atoi(parser.getArg(1))); sending.byte4ToBuf(atoi(parser.getArg(2))); sending.byte4ToBuf(atoi(parser.getArg(3))); if (parser.getArgc() > 4) sending.uByte4ToBuf(atoi(parser.getArg(4))); if (parser.getArgc() > 5) sending.uByte4ToBuf(atoi(parser.getArg(5))); // send the packet client.requestOnce("localizeToPose", &sending); // you have to give the client some time to send the command ArUtil::sleep(500); Aria::shutdown(); return 0; }
void PtzCameraExample::run() { enum { MinPan, MaxPan, Center1, MinTilt, MaxTilt, Center2} stage; stage = MinPan; while(myClient->isConnected()) { mutex.lock(); for(std::set<ArClientHandlerCamera*>::const_iterator i = myCameras.begin(); i != myCameras.end(); ++i) { ArClientHandlerCamera* c = (*i); c->lock(); switch(stage) { case MinPan: c->request.requestPanTiltAbs(c->minPan, 0); stage = MaxPan; break; case MaxPan: c->request.requestPanTiltAbs(c->maxPan, 0); stage = Center1; break; case Center1: c->request.requestPanTiltAbs(0, 0); stage = MinTilt; break; case MinTilt: c->request.requestPanTiltAbs(0, c->minTilt); stage = MaxTilt; break; case MaxTilt: c->request.requestPanTiltAbs(0, c->maxTilt); stage = Center2; break; case Center2: c->request.requestPanTiltAbs(0, 0); stage = MinPan; } c->unlock(); } mutex.unlock(); ArUtil::sleep(3000); } }
int main(int argc, char **argv) { Aria::init(); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } printf("Connected to server.\n"); /* Create a key handler and also tell Aria about it */ ArKeyHandler keyHandler; Aria::setKeyHandler(&keyHandler); /* Global escape-key handler to shut everythnig down */ ArGlobalFunctor escapeCB(&escape); keyHandler.addKeyHandler(ArKeyHandler::ESCAPE, &escapeCB); client.runAsync(); while (client.getRunningWithLock()) { keyHandler.checkKeys(); ArUtil::sleep(100); } Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } client.runAsync(); ArNetPacket sending; // We have to tell it what section we're sending sending.strToBuf("Section"); // The map is in the files section sending.strToBuf("Files"); // The parameter name sending.strToBuf("Map"); // The value of the parameter sending.strToBuf("entire2.map"); // you could put in however many of these you want... client.requestOnce("setConfig", &sending); // you have to give the client some time to send the command ArUtil::sleep(500); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } client.runAsync(); ArNetPacket sending; // We have to tell it what route we want to patrol sending.strToBuf("hallways"); // tell it how much many times we want to patrol (<= 0 == forever) sending.byte4ToBuf(0); client.requestOnce("patrolRouteCount", &sending); // note that there's also another call (patrol) that just has it always // patrol forever but this gives you more options and is only // slightly more complicated (just give it that byte4) // you have to give the client some time to send the command ArUtil::sleep(500); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArClientBase client; std::string host; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); /* Check for -help, and unhandled arguments: */ if (!clientConnector.parseArgs() || !parser.checkHelpAndWarnUnparsed()) { clientConnector.logOptions(); exit(0); } /* Connect our client object to the remote server: */ if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server rejected connection, exiting\n"); else printf("Could not connect to server, exiting\n"); exit(1); } client.requestOnce("reloadConfig"); ArTime start; start.setToNow(); while (Aria::getRunning() && client.isConnected()) { client.loopOnce(); ArUtil::sleep(ArMath::random() % 10000); client.requestOnce("reloadConfig"); } Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); return 1; } if (!clientConnector.connectClient(&client)) { if(client.wasRejected()) ArLog::log(ArLog::Terse, "Error, server '%s' rejected connection. Exiting.", client.getHost()); else ArLog::log(ArLog::Terse, "Error, could not connect to server '%s'. Exiting.", client.getHost()); return 2; } client.setRobotName(client.getHost()); // include server hostname in log messages client.runAsync(); PtzCameraExample example(&client); if(!example.init()) return 1; example.run(); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { Aria::init(); ArGlobalFunctor1<ArNetPacket *> clientListHandlerCB(&clientListHandler); ArGlobalFunctor1<ArNetPacket *> clientAddedHandlerCB(&clientAddedHandler); ArGlobalFunctor1<ArNetPacket *> clientRemovedHandlerCB(&clientRemovedHandler); ArNetPacket packet; ArClientBase client; ArArgumentParser parser(&argc, argv); ArClientSimpleConnector clientConnector(&parser); parser.loadDefaultArguments(); if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed()) { Aria::logOptions(); exit(0); } if (!clientConnector.connectClient(&client)) { if (client.wasRejected()) printf("Server '%s' rejected connection, exiting\n", client.getHost()); else printf("Could not connect to server '%s', exiting\n", client.getHost()); exit(1); } printf("Connected to server.\n"); client.addHandler("clientList", &clientListHandlerCB); client.requestOnce("clientList"); client.addHandler("clientRemoved", &clientRemovedHandlerCB); client.request("clientRemoved", -1); client.addHandler("clientAdded", &clientAddedHandlerCB); client.request("clientAdded", -1); client.run(); Aria::shutdown(); return 0; }
int main(int argc, char **argv) { ArClientBase client; ArGlobalFunctor1<ArNetPacket *> testCB(&test); Aria::init(); //ArLog::init(ArLog::StdOut, ArLog::Verbose); ArTime startTime; startTime.setToNow(); if (!client.blockingConnect("localhost", 7273)) { printf("Could not connect to server, exiting\n"); exit(1); } printf("Took %ld msec to connect\n", startTime.mSecSince()); client.runAsync(); client.lock(); client.addHandler("test", &testCB); client.addHandler("test2", &testCB); client.addHandler("test3", &testCB); client.logDataList(); client.requestOnce("test"); client.request("test2", 100); client.request("test3", -1); client.unlock(); ArUtil::sleep(1000); printf("Changing speed\n"); client.lock(); client.request("test2", 300); client.unlock(); ArUtil::sleep(1000); client.lock(); client.requestStop("test2"); client.unlock(); ArUtil::sleep(1000); client.lock(); client.disconnect(); client.unlock(); ArUtil::sleep(50); exit(0); }