/**
* All of the area coverage algorithms just check if they have reached close
* enough to their destination. If so, they generate a new destination.
*/
int
gams::algorithms::area_coverage::BaseAreaCoverage::plan(void)
{
if (platform_ && *platform_->get_platform_status()->movement_available)
{
pose::Position loc = platform_->get_location();
pose::Position next_loc(platform_->get_frame(),
next_position_.longitude(), next_position_.latitude(),
next_position_.altitude());
double dist = loc.distance_to(next_loc);
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_DETAILED,
"gams::algorithms::area_coverage::BaseAreaCoverage::plan:" \
" distance between points is %f(need %f accuracy)\n",
dist, platform_->get_accuracy());
if (loc.approximately_equal(next_loc, platform_->get_accuracy()))
{
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_DETAILED,
"gams::algorithms::area_coverage::BaseAreaCoverage::plan:" \
" generating new position\n");
generate_new_position();
}
}
return 0;
}
/// Evaluates the node and its children. This does not prune any of
/// the expression tree, and is much faster than the prune function
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallToHostDirs::evaluate (
const madara::knowledge::KnowledgeUpdateSettings & settings)
{
knowledge::KnowledgeRecord return_value;
if (nodes_.size () == 1)
{
std::string statement (nodes_[0]->evaluate (settings).to_string ());
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"System call to_host_dirs is returning the proper directory structure "
"of %s.\n", statement.c_str ());
return madara::utility::clean_dir_name (statement);
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_EMERGENCY,
"KARL COMPILE ERROR: System call to_host_dirs requires 1 argument,"
"e.g., #to_host_dirs ('files/file.txt') will convert to files\file.txt"
" on Windows\n");
}
return return_value;
}
void madara::threads::Threader::run(
const std::string name, BaseThread* thread, bool paused)
{
if (name != "" && thread != 0)
{
std::unique_ptr<WorkerThread> worker(
new WorkerThread(name, thread, control_, data_));
if (paused)
thread->paused = 1;
if (debug_)
worker->debug_ = 1;
(threads_[name] = std::move(worker))->run();
}
else if (thread != 0 && name == "")
{
delete thread;
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_ERROR,
"Threader::run: named thread has an empty name. Deleting new thread.");
throw exceptions::ThreadException(
"Threader::run: named thread has an empty name. Deleting new thread.");
}
else
{
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_ERROR,
"Threader::run: named thread has an empty name.");
throw exceptions::ThreadException(
"Threader::run: named thread has an empty name.");
}
}
/// Evaluates the node and its children. This does not prune any of
/// the expression tree, and is much faster than the prune function
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallToDoubles::evaluate(
const madara::knowledge::KnowledgeUpdateSettings& settings)
{
if (nodes_.size() > 0)
{
madara_logger_ptr_log(logger_, logger::LOG_MINOR,
"System call to_doubles is converting an argument\n");
return knowledge::KnowledgeRecord(
nodes_[0]->evaluate(settings).to_doubles());
}
else
{
madara_logger_ptr_log(logger_, logger::LOG_ERROR,
"madara::expression::SystemCallToDoubles: "
"KARL RUNTIME ERROR:"
"System call to_doubles requires an argument\n");
throw exceptions::KarlException(
"madara::expression::SystemCallToDoubles: "
"KARL RUNTIME ERROR: "
"System call to_doubles requires an argument\n");
}
return knowledge::KnowledgeRecord();
}
void WorkerThread::run(void)
{
try
{
me_ = std::thread(&WorkerThread::svc, this);
#ifndef _WIN32
try_pthread_setname_np(me_.native_handle(), name_.substr(0, 15).c_str());
#endif
std::ostringstream os;
os << std::this_thread::get_id() << " spawned " << me_.get_id()
<< std::endl;
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
"WorkerThread::WorkerThread(%s):"
" thread started %s\n",
name_.c_str(), os.str().c_str());
}
catch (const std::exception& e)
{
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
"WorkerThread::WorkerThread(%s):"
" failed to create thread: %s\n",
name_.c_str(), e.what());
throw;
}
}
/// Evaluates the node and its children. This does not prune any of
/// the expression tree, and is much faster than the prune function
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallFragment::evaluate (
const madara::knowledge::KnowledgeUpdateSettings & settings)
{
knowledge::KnowledgeRecord return_value;
if (nodes_.size () == 3)
{
// grab the first and last ranges
unsigned int first =
(unsigned int) nodes_[1]->evaluate (settings).to_integer ();
unsigned int last =
(unsigned int) nodes_[2]->evaluate (settings).to_integer ();
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"System call fragment is returning segment [%d-%d].\n",
first, last);
return nodes_[0]->evaluate (settings).fragment (first, last);
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_EMERGENCY,
"KARL RUNTIME ERROR: System call fragment"
" requires three arguments, e.g."
" #fragment ('hello world', 0, 4) will return 'hello'\n");
}
return return_value;
}
platforms::BasePlatform *
platforms::PlatformFactoryRepository::create (
const std::string & type,
const madara::knowledge::KnowledgeMap & args)
{
madara_logger_ptr_log (gams::loggers::global_logger.get (),
gams::loggers::LOG_MINOR,
"gams::platforms::PlatformFactoryRepository::create(" \
"%s,...)\n", type.c_str ());
BasePlatform * result (0);
if (type != "")
{
FactoryMap::iterator it = factory_map_.find (type);
if (it != factory_map_.end ())
{
result = it->second->create (args, knowledge_, sensors_, platforms_,
self_);
}
else
{
madara_logger_ptr_log (gams::loggers::global_logger.get (),
gams::loggers::LOG_ALWAYS,
"gams::platforms::PlatformFactoryRepository::create:" \
" could not find \"%s\" platform.\n", type.c_str ());
}
}
return result;
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord
madara::expression::CompositeLessThanEqualNode::prune(bool& can_change)
{
bool left_child_can_change = false;
bool right_child_can_change = false;
madara::knowledge::KnowledgeRecord left_value;
madara::knowledge::KnowledgeRecord right_value;
if (this->left_)
{
left_value = this->left_->prune(left_child_can_change);
if (!left_child_can_change && dynamic_cast<LeafNode*>(left_) == 0)
{
delete this->left_;
this->left_ = new LeafNode(*(this->logger_), left_value);
}
}
else
{
madara_logger_ptr_log(logger_, logger::LOG_ERROR,
"madara::expression::CompositeLessThanEqualNode: "
"KARL COMPILE ERROR: Less-than-equal-to has no left expression\n");
throw exceptions::KarlException(
"madara::expression::CompositeLessThanEqualNode: "
"KARL COMPILE ERROR: "
"Node has no right expression\n");
}
if (this->right_)
{
right_value = this->right_->prune(right_child_can_change);
if (!right_child_can_change && dynamic_cast<LeafNode*>(right_) == 0)
{
delete this->right_;
this->right_ = new LeafNode(*(this->logger_), right_value);
}
}
else
{
madara_logger_ptr_log(logger_, logger::LOG_ERROR,
"madara::expression::CompositeLessThanEqualNode: "
"KARL COMPILE ERROR: Less-than-equal-to has no right expression\n");
throw exceptions::KarlException(
"madara::expression::CompositeLessThanEqualNode: "
"KARL COMPILE ERROR: "
"Node has no right expression\n");
}
can_change = left_child_can_change || right_child_can_change;
return knowledge::KnowledgeRecord(left_value <= right_value);
}
/// Evaluates the node and its children. This does not prune any of
/// the expression tree, and is much faster than the prune function
madara::knowledge::KnowledgeRecord
madara::expression::VariableDecrementNode::evaluate (
const madara::knowledge::KnowledgeUpdateSettings & settings)
{
madara::knowledge::KnowledgeRecord rhs;
if (rhs_)
rhs = rhs_->evaluate (settings);
else
rhs = value_;
if (var_)
{
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"CompositeAssignmentNode::evaluate: "
"Attempting to set variable %s to %s.\n",
var_->expand_key ().c_str (),
rhs.to_string ().c_str ());
knowledge::KnowledgeRecord result (var_->evaluate (settings) - rhs);
var_->set (result, settings);
return result;
}
else if (array_)
{
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"CompositeAssignmentNode::evaluate: "
"Attempting to set index of var %s to %s.\n",
array_->expand_key ().c_str (),
rhs.to_string ().c_str ());
knowledge::KnowledgeRecord result (array_->evaluate (settings) - rhs);
array_->set (result, settings);
return result;
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"CompositeAssignmentNode::evaluate: "
"left hand side was neither a variable nor an array reference. "
"Check your expression for errors.\n",
array_->expand_key ().c_str (),
rhs.to_string ().c_str ());
}
// return the value
return rhs;
}
madara::knowledge::containers::NativeDoubleVector::~NativeDoubleVector ()
{
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::destructor called on %s\n",
this->name_.c_str ());
}
int
madara::knowledge::containers::NativeDoubleVector::set (
size_t index,
type value,
const KnowledgeUpdateSettings & settings)
{
int result = -1;
if (context_)
{
ContextGuard context_guard (*context_);
MADARA_GUARD_TYPE guard (mutex_);
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::set: %s: setting element [%d] "
"to %f with custom settings\n",
this->name_.c_str (),
(int)index, value);
result = context_->set_index (vector_, index, value, settings);
}
return result;
}
int
gams::algorithms::Move::execute (void)
{
int result (OK);
bool is_finished = status_.finished == 1;
if (platform_ && *platform_->get_platform_status ()->movement_available
&& !is_finished)
{
madara_logger_ptr_log (gams::loggers::global_logger.get (),
gams::loggers::LOG_MAJOR,
"Move::execute:" \
" calling platform->move(\"%s\")\n",
locations_[move_index_].to_string ().c_str ());
// allow GPSPosition to do the conversion for lat/lon
utility::GPSPosition next = locations_[move_index_];
platform_->move (next);
}
else if (is_finished)
{
result |= FINISHED;
}
return result;
}
void
gams::groups::GroupTransient::sync(void)
{
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_MAJOR,
"gams::groups::GroupTransient:sync" \
" syncing with %s source\n", prefix_.c_str());
if (knowledge_ && prefix_ != "")
{
knowledge::ContextGuard guard(*knowledge_);
// sync with map is always expensive. Sync and clear
members_.sync_keys();
fast_members_.clear();
// get the new list of keys
std::vector <std::string> keys;
members_.keys(keys);
// add the keys with values to the AgentMap fast_members_
for (size_t i = 0; i < keys.size(); ++i)
{
const std::string key = keys[i];
if (members_[key].to_integer() != 0)
{
fast_members_[key] = members_[key].to_integer();
}
}
}
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord madara::expression::CompositeNotNode::prune(
bool& can_change)
{
bool right_child_can_change = false;
madara::knowledge::KnowledgeRecord right_value;
if (this->right_)
{
right_value = this->right_->prune(right_child_can_change);
if (!right_child_can_change && dynamic_cast<LeafNode*>(right_) == 0)
{
delete this->right_;
this->right_ = new LeafNode(*(this->logger_), right_value);
}
}
else
{
madara_logger_ptr_log(logger_, logger::LOG_ERROR,
"madara::expression::CompositeNotNode: "
"KARL COMPILE ERROR: "
"Logical-not has no right expression\n");
throw exceptions::KarlException("madara::expression::CompositeNotNode: "
"KARL COMPILE ERROR: "
"Node has no right expression\n");
}
can_change = right_child_can_change;
return knowledge::KnowledgeRecord(!right_value);
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallFragment::prune (bool & can_change)
{
// user can always change a function, and we have no control over
// what it does. Consequently, a function node cannot be pruned out
// under any situation
can_change = true;
madara::knowledge::KnowledgeRecord result;
for (ComponentNodes::iterator i = nodes_.begin (); i != nodes_.end ();
++i)
{
bool arg_can_change = false;
result = (*i)->prune (arg_can_change);
if (!arg_can_change && dynamic_cast <LeafNode *> (*i) == 0)
{
delete *i;
*i = new LeafNode (*(this->logger_), result);
}
}
if (nodes_.size () != 3)
{
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"KARL COMPILE ERROR: System call fragment"
" requires three arguments, e.g."
" #fragment ('hello world', 0, 4) will return 'hello'\n");
}
return result;
}
/// Evaluates the node and its children. This does not prune any of
/// the expression tree, and is much faster than the prune function
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallRandDouble::evaluate (
const madara::knowledge::KnowledgeUpdateSettings & settings)
{
double floor (0.0), ceiling (1.0);
bool update_srand = true;
if (nodes_.size () > 0)
{
floor = nodes_[0]->evaluate (settings).to_double ();
if (nodes_.size () > 1)
{
ceiling = nodes_[1]->evaluate (settings).to_double ();
if (nodes_.size () > 2)
{
update_srand = bool (nodes_[2]->evaluate (settings).to_integer ());
}
}
}
madara_logger_ptr_log (logger_, logger::LOG_MINOR,
"System call rand_double called with %f, %f, %d\n",
floor, ceiling, update_srand);
return utility::rand_double (floor, ceiling, update_srand);
}
void
madara::knowledge::containers::NativeDoubleVector::set_name (
const std::string & var_name,
ThreadSafeContext & knowledge, int size)
{
if (context_ != &knowledge || name_ != var_name)
{
context_ = &knowledge;
ContextGuard context_guard (*context_);
MADARA_GUARD_TYPE guard (mutex_);
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::set_name: setting name to %s\n",
var_name.c_str ());
name_ = var_name;
vector_ = knowledge.get_ref (var_name, settings_);
if (size > 0)
resize (size_t (size));
}
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallRandDouble::prune (bool & can_change)
{
can_change = true;
madara::knowledge::KnowledgeRecord result;
for (ComponentNodes::iterator i = nodes_.begin (); i != nodes_.end ();
++i)
{
bool arg_can_change = false;
result = (*i)->prune (arg_can_change);
if (!arg_can_change && dynamic_cast <LeafNode *> (*i) == 0)
{
delete *i;
*i = new LeafNode (*(this->logger_), result);
}
}
if (nodes_.size () > 3)
{
madara_logger_ptr_log (logger_, logger::LOG_EMERGENCY,
"KARL COMPILE ERROR: System call rand_double"
" can have up to three arguments, 1) floor, "
"2) ceiling and 3) whether to set the random seed\n");
}
return result;
}
gams::algorithms::BaseAlgorithm *
gams::algorithms::NullAlgorithmFactory::create (
const madara::knowledge::KnowledgeMap & /*args*/,
madara::knowledge::KnowledgeBase * knowledge,
platforms::BasePlatform * platform,
variables::Sensors * sensors,
variables::Self * self,
variables::Agents * /*agents*/)
{
BaseAlgorithm * result (0);
if (knowledge && sensors && platform && self)
{
result = new NullAlgorithm (knowledge, platform, sensors, self);
}
if (result == 0)
{
madara_logger_ptr_log (gams::loggers::global_logger.get (),
gams::loggers::LOG_MAJOR,
"gams::algorithms::NullAlgorithmFactory::create:" \
" unknown error creating Null algorithm\n");
}
return result;
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord
madara::expression::CompositePreincrementNode::prune (bool & can_change)
{
bool right_child_can_change = false;
madara::knowledge::KnowledgeRecord right_value;
if (this->right_)
{
right_value = this->right_->prune (right_child_can_change);
if (!right_child_can_change && dynamic_cast <LeafNode *> (right_) == 0)
{
delete this->right_;
this->right_ = new LeafNode (*(this->logger_), right_value);
}
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_EMERGENCY,
"KARL COMPILE ERROR: Preincrement has no right expression\n");
exit (-1);
}
can_change = right_child_can_change;
return ++right_value;
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord
madara::expression::SystemCallToHostDirs::prune (bool & can_change)
{
// user can always change a function, and we have no control over
// what it does. Consequently, a function node cannot be pruned out
// under any situation
can_change = true;
madara::knowledge::KnowledgeRecord result;
if (nodes_.size () == 1)
{
bool arg_can_change = false;
result = nodes_[0]->prune (arg_can_change);
if (!arg_can_change && dynamic_cast <LeafNode *> (nodes_[0]) == 0)
{
delete nodes_[0];
nodes_[0] = new LeafNode (*(this->logger_), result);
}
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_EMERGENCY,
"KARL COMPILE ERROR: System call to_host_dirs requires 1 argument,"
"e.g., #to_host_dirs ('files/file.txt') will convert to files\file.txt"
" on Windows\n");
}
return result;
}
madara::knowledge::containers::NativeDoubleVectorStaged::
NativeDoubleVectorStaged(const KnowledgeUpdateSettings& settings)
: BaseContainer("", settings), context_(0), has_changed_(false)
{
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
"NativeDoubleVectorStaged::constructor: new object\n");
}
int
gams::platforms::OscJoystickPlatform::orient(const pose::Orientation & target,
const pose::OrientationBounds &bounds)
{
// update variables
BasePlatform::orient(target, bounds);
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_TRACE,
"gams::platforms::OscJoystickPlatform::orient:" \
" %s: requested target \"%f,%f,%f\"\n",
self_->agent.prefix.c_str(), target.rx(), target.ry(), target.rz());
// convert from input reference frame to vrep reference frame, if necessary
pose::Orientation new_target(get_frame(), target);
last_orient_ = new_target;
utility::OscUdp::OscMap values;
std::vector<double> yaw_velocity;
yaw_velocity.push_back(0);
values[yaw_velocity_prefix_] = yaw_velocity;
osc_.send(values);
// we're not changing orientation. this has to be done for move alg to work
return PLATFORM_ARRIVED;
}
void
madara::knowledge::containers::NativeDoubleVector::transfer_to (
NativeDoubleVector & other)
{
if (context_ && other.context_)
{
ContextGuard context_guard (*context_);
ContextGuard other_context_guard (*other.context_);
MADARA_GUARD_TYPE guard (mutex_);
MADARA_GUARD_TYPE guard2 (other.mutex_);
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::transfer_to: %s transfering to %s\n",
this->name_.c_str (),
other.name_.c_str ());
size_t other_size = other.size ();
size_t this_size = this->size ();
if (this_size > 0)
{
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MINOR,
"NativeDoubleVector::transfer_to: %s has elements\n",
this->name_.c_str ());
size_t size = other_size + this_size;
other.resize ((int)size);
knowledge::KnowledgeRecord rhs (other.context_->get (other.vector_));
knowledge::KnowledgeRecord lhs (context_->get (vector_));
rhs.set_index (size - 1, lhs.retrieve_index (this_size - 1).to_double ());
for (size_t i = 0, j = other_size; i < this_size - 1; ++i, ++j)
{
rhs.set_index (other_size, lhs.retrieve_index (i).to_double ());
}
other.context_->set (other.vector_, rhs, other.settings_);
this->resize (0);
}
}
}
madara::knowledge::containers::BaseContainer*
madara::knowledge::containers::NativeDoubleVectorStaged::clone(void) const
{
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
"NativeDoubleVectorStaged::clone: cloning %s\n", this->name_.c_str());
return new NativeDoubleVectorStaged(*this);
}
madara::knowledge::containers::NativeDoubleVectorStaged::
NativeDoubleVectorStaged(const NativeDoubleVectorStaged& rhs)
: BaseContainer(rhs), context_(rhs.context_), vector_(rhs.vector_)
{
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
"NativeDoubleVectorStaged::copy constructor called on %s\n",
rhs.name_.c_str());
}
/// Prune the tree of unnecessary nodes.
/// Returns evaluation of the node and sets can_change appropriately.
/// if this node can be changed, that means it shouldn't be pruned.
madara::knowledge::KnowledgeRecord
madara::expression::CompositeGreaterThanEqualNode::prune (bool & can_change)
{
bool left_child_can_change = false;
bool right_child_can_change = false;
madara::knowledge::KnowledgeRecord left_value;
madara::knowledge::KnowledgeRecord right_value;
if (this->left_)
{
left_value = this->left_->prune (left_child_can_change);
if (!left_child_can_change && dynamic_cast <LeafNode *> (left_) == 0)
{
delete this->left_;
this->left_ = new LeafNode (*(this->logger_), left_value);
}
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_DETAILED,
"KARL COMPILE ERROR: Greater-than-equal-to has no left expression\n");
exit (-1);
}
if (this->right_)
{
right_value = this->right_->prune (right_child_can_change);
if (!right_child_can_change && dynamic_cast <LeafNode *> (right_) == 0)
{
delete this->right_;
this->right_ = new LeafNode (*(this->logger_), right_value);
}
}
else
{
madara_logger_ptr_log (logger_, logger::LOG_DETAILED,
"KARL COMPILE ERROR: Greater-than-equal-to has no right expression\n");
exit (-1);
}
can_change = left_child_can_change || right_child_can_change;
return knowledge::KnowledgeRecord::Integer (left_value >= right_value);
}
void
madara::knowledge::containers::NativeDoubleVector::modify (void)
{
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::modify called\n");
ContextGuard context_guard (*context_);
if (context_ && name_ != "")
{
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::modify: context is valid. Marking %s.\n",
this->name_.c_str ());
context_->mark_modified (vector_);
}
}
/**
* Initializes thread with MADARA context
* @param context context for querying current program state
**/
virtual void init(madara::knowledge::KnowledgeBase & knowledge)
{
data_ = knowledge;
xyz_velocity_.set_name(".xyz_velocity", data_, 3);
std::string handle = knowledge.get(".osc.local.handle").to_string();
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_ALWAYS,
"SenseThread::init: " \
"%s: attempting to open handle %s\n",
knowledge.get(".prefix").to_string().c_str(),
handle.c_str());
if (handle != "")
{
bool result = joystick_.open_handle(handle);
if (result)
{
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_ALWAYS,
"SenseThread::init: " \
"%s: SUCCESS: mapped to joystick %s\n",
knowledge.get(".prefix").to_string().c_str(),
handle.c_str());
}
else
{
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_ALWAYS,
"SenseThread::init: " \
"%s: FAIL: cannot map to joystick %s\n",
knowledge.get(".prefix").to_string().c_str(),
handle.c_str());
}
}
inverted_y_ = knowledge.get(".osc.local.inverted_y").is_true();
inverted_z_ = knowledge.get(".osc.local.inverted_z").is_true();
flip_xy_ = knowledge.get(".osc.local.flip_xy").is_true();
}
madara::knowledge::KnowledgeRecord
madara::knowledge::containers::NativeDoubleVector::to_record (
void) const
{
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::to_record: %s: retrieving record\n",
this->name_.c_str ());
return context_->get (this->vector_, settings_);
}