Пример #1
0
int
main(int argc, char **argv)
{
  LibLogger::init();
  Logger* logger = new ConsoleLogger();

  signal(SIGINT, signal_handler);

  LocalBlackBoard *lbb = new LocalBlackBoard(BLACKBOARD_MEMSIZE);

  BlackBoard* bb = lbb;


  Opi*         own;
  vector<Opi*> foreign;
  Opi*         output;

  try {
    cout << "Opening interfaces.. " << flush;
    own = bb->open_for_writing<Opi>("OmniBall");
    for (int i = 1; i <= 5; i++) {
      stringstream stream;
      stream << "WM Ball ";
      stream << i;
      string id = stream.str();
      Opi* opi = bb->open_for_writing<Opi>(id.c_str());
      foreign.push_back(opi);
    }
    output = bb->open_for_reading<Opi>("WM Ball");
    cout << "done" << endl;
  } catch (Exception &e) {
    cout << "failed! Aborting" << endl;
    e.print_trace();
    exit(1);
  }

  test1(logger, bb, own, foreign, output);
  test2(logger, bb, own, foreign, output);
  test3(logger, bb, own, foreign, output);

  cout << "Closing interfaces.. " << flush;
  bb->close(own);
  for (vector<Opi*>::iterator it = foreign.begin();
       it != foreign.end(); ++it) {
    Opi* opi = *it;
    bb->close(opi);
  }
  cout << "done" << endl;

  cout << "Deleting blackboard.. " << flush;
  delete bb;
  cout << "done" << endl;
  cout << "Finalizing logger.. " << flush;
  LibLogger::finalize();
  cout << "done" << endl;
}
Пример #2
0
int main(int argc, char** argv) {
	//initialization and calibration of new blackBoard
	BlackBoard* blackBoard = new BlackBoard();
	blackBoard->Init();
	PathFinder* allRed = new PathFinderAllRed(blackBoard);
	PathFinder* maxSquare = new PathFinderMaxSquare(blackBoard);
	PathFinder* fitLine = new PathFinderFitLine(blackBoard);

	blackBoard->desktopDrawer->setPathFinder(allRed);

	cout << "Ovladanie:\n";
	cout << "ESC     quit\n";
	cout << "c       clear desktop\n";
	cout << "1       PathFinderAllRed\n";
	cout << "2       PathFinderMaxSquare\n";
	cout << "3       PathFinderFitLine\n";

	//update desktop view
	bool run = 1;
	while (blackBoard->update() && run) {
		char c = cvWaitKey(33);
		switch(c){
			case 27:
				run = 0;
				break; //ESC
			case 'c':
				blackBoard->desktopDrawer->clear();
				break;
			case '1':
				blackBoard->desktopDrawer->setPathFinder(allRed);
				break;
			case '2':
				blackBoard->desktopDrawer->setPathFinder(maxSquare);
				break;
			case '3':
				blackBoard->desktopDrawer->setPathFinder(fitLine);
				break;
		}
	}
	delete blackBoard;
	delete allRed;
	delete maxSquare;
	delete fitLine;

	return 0;
}
Пример #3
0
void
try_localize(const std::string &host, unsigned short int port, std::string &interface_id,
             std::string frame,
             double translation[3], double rotation[4], double covariance[36])
{
  FawkesNetworkClient *c = new FawkesNetworkClient(host.c_str(), port);
  c->connect();

	if (frame == "") {
		NetworkConfiguration *netconf = NULL;
		try {
			netconf = new NetworkConfiguration(c);
			frame = netconf->get_string("/frames/fixed");
		} catch (Exception &e) {
			printf("WARNING: no frame set and failed to get frame from remote.\n");
			e.print_trace();
		}
		delete netconf;
	}

  BlackBoard *bb = new RemoteBlackBoard(c);
  LocalizationInterface *loc_if =
    bb->open_for_reading<LocalizationInterface>(interface_id.c_str());

  if (! loc_if->has_writer()) {
    bb->close(loc_if);
    delete bb;
    throw Exception("No writer for interface %s, aborting",
		    loc_if->uid());
  }

  LocalizationInterface::SetInitialPoseMessage *ipm =
    new LocalizationInterface::SetInitialPoseMessage();
  ipm->set_frame(frame.c_str());
  ipm->set_translation(translation);
  ipm->set_rotation(rotation);
  ipm->set_covariance(covariance);
  loc_if->msgq_enqueue(ipm);

  // allow for some time so message is actually sent
  usleep(500000);

  bb->close(loc_if);
  delete bb;
  delete c;
}
Пример #4
0
int
main(int argc, char **argv)
{
  LibLogger::init();
  Thread::init_main();

  //RemoteBlackBoard *bb = new RemoteBlackBoard("localhost", 1910);
  BlackBoard *bb = new LocalBlackBoard(BLACKBOARD_MEMSIZE);

  QaBBEventListener qabbel;

  TestInterface *ti_writer_1;
  TestInterface *ti_writer_2;
  TestInterface *ti_writer_3;
  TestInterface *ti_writer_4;
  TestInterface *ti_writer_5;
  TestInterface *ti_writer_6;

  TestInterface *ti_reader_1;
  TestInterface *ti_reader_2;

  try {
    cout << "Opening interfaces.. (SomeID *)" << endl;
    ti_writer_1 = bb->open_for_writing<TestInterface>("SomeID 1");
    ti_reader_1 = bb->open_for_reading<TestInterface>("SomeID 1");
    ti_writer_2 = bb->open_for_writing<TestInterface>("SomeID 2");
    ti_reader_2 = bb->open_for_reading<TestInterface>("SomeID reader 1");

    qabbel.add_interface(ti_writer_1);
    qabbel.add_interface(ti_writer_2);
    qabbel.add_interface(ti_reader_2);
    bb->register_listener(&qabbel, BlackBoard::BBIL_FLAG_ALL);
    bb->register_observer(&qabbel, BlackBoard::BBIO_FLAG_ALL);

    cout << "Opening interfaces.. (SomeID 3, should NOT trigger BBIO)" << endl;
    ti_writer_3 = bb->open_for_writing<TestInterface>("SomeID 3");
    cout << "Opening interfaces.. (AnotherID *, SHOULD trigger BBIO)" << endl;
    ti_writer_4 = bb->open_for_writing<TestInterface>("AnotherID 1");
    ti_writer_5 = bb->open_for_writing<TestInterface>("AnotherID 2");
    ti_writer_6 = bb->open_for_writing<TestInterface>("AnotherID 3");
    cout << "success" << endl;
  } catch (Exception &e) {
    cout << "failed! Aborting" << endl;
    e.print_trace();
    exit(1);
  }

  usleep(100000);

  std::list<TestInterface *> readers = bb->open_multiple_for_reading<TestInterface>();
  usleep(100000);
  for (std::list<TestInterface *>::iterator i = readers.begin(); i != readers.end(); ++i) {
    printf("Opened reader for interface %s of type %s\n", (*i)->id(), (*i)->type());
    bb->close(*i);
  }

  usleep(100000);

  const char* pattern = "AnotherID *";
  readers = bb->open_multiple_for_reading<TestInterface>(pattern);
  printf("Found %zu interfaces with pattern \"%s\"\n", readers.size(), pattern);
  for (std::list<TestInterface *>::iterator i = readers.begin(); i != readers.end(); ++i) {
    printf("Opened reader for interface %s of type %s\n", (*i)->id(), (*i)->type());
    bb->close(*i);
  }

  usleep(100000);

  printf("Sending a message to test message received event\n");
  TestInterface::SetTestIntMessage *m = new TestInterface::SetTestIntMessage(27);
  unsigned int msg_id = ti_reader_1->msgq_enqueue(m);
  printf("Message ID = %u, enqueued messages: %u\n", msg_id, ti_writer_1->msgq_size());
  
  printf("Removing writer 1. No BBIL output should appear\n");
  bb->close(ti_writer_1);

  bb->unregister_listener(&qabbel);
  usleep(100000);

  printf("Removing other writers. No warning should appear.\n");
  bb->close(ti_writer_2);
  bb->close(ti_writer_3);
  bb->close(ti_writer_4);
  bb->close(ti_writer_5);
  bb->close(ti_writer_6);

  bb->close(ti_reader_1);
  bb->close(ti_reader_2);

  usleep(100000);

  delete bb;
  Thread::destroy_main();
  LibLogger::finalize();
}
Пример #5
0
int
main(int argc, char **argv)
{
	signal(SIGINT, signal_handler);

	LocalBlackBoard *lbb = new LocalBlackBoard(BLACKBOARD_MEMSIZE);

	BlackBoard *bb = lbb;

	TestInterface *ti_writer;
	TestInterface *ti_reader;

	try {
		cout << "Opening interfaces.. " << flush;
		ti_writer = bb->open_for_writing<TestInterface>("SomeID");
		ti_reader = bb->open_for_reading<TestInterface>("SomeID");
		cout << "success, "
		     << "writer hash=" << ti_writer->hash_printable()
		     << "  reader hash=" << ti_reader->hash_printable() << endl;
	} catch (Exception &e) {
		cout << "failed! Aborting" << endl;
		e.print_trace();
		exit(1);
	}

	cout << endl
	     << endl
	     << "Running data tests ==================================================" << endl;

	cout << "Writing initial value (" << TestInterface::TEST_CONSTANT << ") into interface as TestInt"
	     << endl;
	ti_writer->set_test_int(TestInterface::TEST_CONSTANT);
	try {
		ti_writer->write();
	} catch (InterfaceWriteDeniedException &e) {
		cout << "BUG: caught write denied exception" << endl;
		e.print_trace();
	}

	cout << "Reading value from reader interface.. " << flush;
	ti_reader->read();
	int val = ti_reader->test_int();
	if (val == TestInterface::TEST_CONSTANT) {
		cout << " success, value is " << ti_reader->test_int() << " as expected" << endl;
	} else {
		cout << " failure, value is " << ti_reader->test_int() << ", expected "
		     << TestInterface::TEST_CONSTANT << endl;
	}

	cout << "Resizing buffer.. " << flush;
	try {
		ti_reader->resize_buffers(1);
		ti_reader->copy_private_to_buffer(0);
	} catch (Exception &e) {
		cout << "ERROR: Resizing failed, exception follows" << endl;
		e.print_trace();
		throw;
	}

	cout << "Testing buffers, use Ctrl-C to interrupt" << endl
	     << "If you do not see any output everything is fine" << endl;
	while (!quit) {
		//cout << "Writing value " << expval
		// << " into interface as TestInt" << endl;
		ti_writer->set_test_int(ti_writer->test_int() + 1);
		try {
			ti_writer->write();
		} catch (InterfaceWriteDeniedException &e) {
			cout << "BUG: caught write denied exception" << endl;
			e.print_trace();
		}

		//cout << "Reading value from reader interface.. " << flush;
		ti_reader->read();
		int rval = ti_reader->test_int();
		int wval = ti_writer->test_int();

		ti_reader->read_from_buffer(0);
		int bval = ti_reader->test_int();

		if (rval != wval) {
			cout << " failure, reader value is " << rval << ", writer has " << wval << endl;
		}

		if (rval != bval + 1) {
			cout << " failure, reader value is " << rval << ", buffer has " << bval << endl;
		}

		// could to copy_shared as well, but that is a little less predictable in
		// the case of concurrent writers, hence we want people to copy and paste
		// this version.
		ti_reader->read();
		ti_reader->copy_private_to_buffer(0);

		usleep(10);
	}

	cout << "Tests done" << endl;

	bb->close(ti_reader);
	bb->close(ti_writer);

	delete bb;
}
Пример #6
0
int
main(int argc, char **argv)
{
  signal(SIGINT, signal_handler);

  LocalBlackBoard *llbb = new LocalBlackBoard(BLACKBOARD_MEMSIZE);
  BlackBoard *lbb = llbb;

  FawkesNetworkServerThread  *fns = new FawkesNetworkServerThread(1910);
  fns->start();

  llbb->start_nethandler(fns);

  BlackBoard *rbb = new RemoteBlackBoard("localhost", 1910);

  InterfaceInfoList *infl = rbb->list_all();
  for (InterfaceInfoList::iterator i = infl->begin(); i != infl->end(); ++i) {
    const unsigned char *hash = (*i).hash();
    char phash[__INTERFACE_HASH_SIZE * 2 + 1];
    memset(phash, 0, sizeof(phash));
    for (unsigned int j = 0; j < __INTERFACE_HASH_SIZE; ++j) {
      sprintf(&phash[j * 2], "%02x", hash[j]);
    }
    printf("%s::%s (%s), w:%i  r:%u  s:%u\n",
	   (*i).type(), (*i).id(), phash, (*i).has_writer(),
	   (*i).num_readers(), (*i).serial());
  }
  delete infl;

  //TestInterface *ti_writer;
  TestInterface *ti_reader;
  TestInterface *ti_writer;
  try {
    cout << "Opening interfaces.. " << flush;
    ti_writer = rbb->open_for_writing<TestInterface>("SomeID");
    ti_reader = rbb->open_for_reading<TestInterface>("SomeID");
    cout << "success, "
	 << "writer hash=" << ti_writer->hash_printable()
	 << "  reader hash=" << ti_reader->hash_printable()
	 << endl;
  } catch (Exception &e) {
    cout << "failed! Aborting" << endl;
    e.print_trace();
    exit(1);
  }

  try {
    cout << "Trying to open second writer.. " << flush;
    TestInterface *ti_writer_two;
    ti_writer_two = rbb->open_for_writing<TestInterface>("SomeID");
    cout << "BUG: Detection of second writer did NOT work!" << endl;
    exit(2);
  } catch (BlackBoardWriterActiveException &e) {
    cout << "exception caught as expected, detected and prevented second writer!" << endl;
  }

  try {
    cout << "Trying to open third writer.. " << flush;
    TestInterface *ti_writer_three;
    ti_writer_three = rbb->open_for_writing<TestInterface>("AnotherID");
    cout << "No exception as expected, different ID ok!" << endl;
    rbb->close(ti_writer_three);
  } catch (BlackBoardWriterActiveException &e) {
    cout << "BUG: Third writer with different ID detected as another writer!" << endl;
    exit(3);
  }

  cout << endl << endl
       << "Running data tests ==================================================" << endl;

  cout << "Writing initial value ("
       << TestInterface::TEST_CONSTANT << ") into interface as TestInt" << endl;
  ti_writer->set_test_int( TestInterface::TEST_CONSTANT );
  try {
    ti_writer->write();
  } catch (InterfaceWriteDeniedException &e) {
    cout << "BUG: caught write denied exception" << endl;
    e.print_trace();
  }

  cout << "Giving some time to have value processed" << endl;
  usleep(100000);

  cout << "Reading value from reader interface.. " << flush;
  ti_reader->read();
  int val = ti_reader->test_int();
  if ( val == TestInterface::TEST_CONSTANT ) {
    cout << " success, value is " << ti_reader->test_int() << " as expected" << endl;
  } else {
    cout << " failure, value is " << ti_reader->test_int() << ", expected "
	 << TestInterface::TEST_CONSTANT << endl;
  }

  cout << "Closing interfaces.. " << flush;
  try {
    rbb->close(ti_reader);
    rbb->close(ti_writer);
    cout << "done" << endl;
  } catch (Exception &e) {
    cout << "failed" << endl;
    e.print_trace();
  }

  cout << endl << endl << "Starting MESSAGING tests" << endl 
       << "Press Ctrl-C to continue with next test" << endl << endl;

  ti_writer = lbb->open_for_writing<TestInterface>("Messaging");
  ti_reader = rbb->open_for_reading<TestInterface>("Messaging");

  printf("Writer serial: %u  shifted: %u\n", ti_writer->serial(), ti_writer->serial() << 16);
  printf("Reader serial: %u  shifted: %u\n", ti_reader->serial(), ti_reader->serial() << 16);

  test_messaging(ti_reader, ti_writer);

  rbb->close(ti_reader);
  lbb->close(ti_writer);

  cout << endl << endl << "Starting MESSAGING tests, doing repeater scenario" << endl 
       << "Press Ctrl-C to continue with next test" << endl << endl;
  quit = false;

  delete rbb;

  LocalBlackBoard *repllbb = new LocalBlackBoard(BLACKBOARD_MEMSIZE);

  FawkesNetworkServerThread  *repfns = new FawkesNetworkServerThread(1911);
  repfns->start();

  repllbb->start_nethandler(repfns);

  BlackBoard *rep_rbb = new RemoteBlackBoard("localhost", 1911);
  rbb = new RemoteBlackBoard("localhost", 1911);

  TestInterface *rep_reader;
  TestInterface *rep_writer;

  ti_writer = rbb->open_for_writing<TestInterface>("Messaging");
  ti_reader = lbb->open_for_reading<TestInterface>("Messaging");

  rep_reader = rep_rbb->open_for_reading<TestInterface>("Messaging");
  rep_writer = lbb->open_for_writing<TestInterface>("Messaging");

  printf("Writer serial: %u  shifted: %u\n", ti_writer->serial(), ti_writer->serial() << 16);
  printf("Reader serial: %u  shifted: %u\n", ti_reader->serial(), ti_reader->serial() << 16);

  SyncInterfaceListener *sil = new SyncInterfaceListener(rep_reader, rep_writer, rep_rbb, lbb);

  test_messaging(ti_reader, ti_writer);

  delete sil;
  lbb->close(ti_reader);
  rbb->close(ti_writer);
  rep_rbb->close(rep_reader);
  lbb->close(rep_writer);
  delete repllbb;
  delete rep_rbb;

  cout << "Tests done" << endl;

  delete rbb;
  delete llbb;
  delete fns;
}