std::string Utils::get_config_option(std::string _key)
{
std::string value = "";
TiXmlDocument document(getConfigFile(LOCAL_CONFIG).c_str());
if (!document.LoadFile())
{
cError() << "There was an exception in XML parsing.";
cError() << "Parse error: " << document.ErrorDesc();
cError() << " At line " << document.ErrorRow();
return value;
}
TiXmlHandle docHandle(&document);
TiXmlElement *key_node = docHandle.FirstChildElement("calaos:config").FirstChildElement().ToElement();
if (key_node)
{
for(; key_node; key_node = key_node->NextSiblingElement())
{
if (key_node->ValueStr() == "calaos:option" &&
key_node->Attribute("name") &&
key_node->Attribute("name") == _key &&
key_node->Attribute("value"))
{
value = key_node->Attribute("value");
break;
}
}
}
return value;
}
void gposStartupState(void)
{
JausService service;
// Populate Core Service
if(!jausServiceAddCoreServices(gpos->services))
{
cError("gpos: Addition of Core Services FAILED! Switching to FAILURE_STATE\n");
gpos->state = JAUS_FAILURE_STATE;
}
// USER: Add the rest of your component specific service(s) here
service = jausServiceCreate(gpos->address->component);
if(!service)
{
cError("gpos:%d: Creation of JausService FAILED! Switching to FAILURE_STATE\n", __LINE__);
gpos->state = JAUS_FAILURE_STATE;
}
jausServiceAddService(gpos->services, service);
jausServiceAddInputCommand(service, JAUS_QUERY_GLOBAL_POSE, 0xFF);
jausServiceAddOutputCommand(service, JAUS_REPORT_GLOBAL_POSE, 0xFF);
gposMessage = reportGlobalPoseMessageCreate();
gposMessage->source->id = gpos->address->id;
//add support for ReportGlovalPose Service Connections
scManagerAddSupportedMessage(gposNmi, JAUS_REPORT_GLOBAL_POSE);
}
bool Utils::del_config_option(std::string key)
{
TiXmlDocument document(getConfigFile(LOCAL_CONFIG).c_str());
if (!document.LoadFile())
{
cError() << "There was an exception in XML parsing.";
cError() << "Parse error: " << document.ErrorDesc();
cError() << "In file " << getConfigFile(LOCAL_CONFIG) << " At line " << document.ErrorRow();
return false;
}
TiXmlHandle docHandle(&document);
TiXmlElement *key_node = docHandle.FirstChildElement("calaos:config").FirstChildElement().ToElement();
if (key_node)
{
for(; key_node; key_node = key_node->NextSiblingElement())
{
if (key_node->ValueStr() == "calaos:option" &&
key_node->Attribute("name") &&
key_node->Attribute("name") == key)
{
docHandle.FirstChild("calaos:config").Element()->RemoveChild(key_node);
break;
}
}
document.SaveFile();
}
return true;
}
bool Utils::get_config_options(Params &options)
{
TiXmlDocument document(getConfigFile(LOCAL_CONFIG).c_str());
if (!document.LoadFile())
{
cError() << "There was an exception in XML parsing.";
cError() << "Parse error: " << document.ErrorDesc();
cError() << "In file " << getConfigFile(LOCAL_CONFIG) << " At line " << document.ErrorRow();
return false;
}
TiXmlHandle docHandle(&document);
TiXmlElement *key_node = docHandle.FirstChildElement("calaos:config").FirstChildElement().ToElement();
if (key_node)
{
for(; key_node; key_node = key_node->NextSiblingElement())
{
if (key_node->ValueStr() == "calaos:option" &&
key_node->Attribute("name") &&
key_node->Attribute("value"))
{
options.Add(key_node->Attribute("name"), key_node->Attribute("value"));
}
}
}
return true;
}
ijvType *binReadIJV(FILE* fpr)
{
int n, nnz;
if (!fread(&(n), sizeof(int32), 1, fpr))
cError ("error reading n from file\n");
if (!fread(&(nnz), sizeof(int32), 1, fpr))
cError ("error reading nnz from file\n");
ijvType *ijv;
ijv = makeIJV(nnz);
ijv->n = n;
int x;
int i, j;
float v;
if (!fread(ijv->i, sizeof(int32), nnz, fpr))
cError ("error reading i from file\n");
if (!fread(ijv->j, sizeof(int32), nnz, fpr))
cError ("error reading j from file\n");
if (!fread(ijv->v, sizeof(double), nnz, fpr))
cError ("error reading v from file\n");
for (x = 0; x < nnz; x++) {
ijv->i[x] = ijv->i[x]-1;
ijv->j[x] = ijv->j[x]-1;
}
return ijv;
}
// Function: cmptStartup
// Access: Public
// Description: This function allows the abstracted component functionality contained in this file to be started from an external source.
// It must be called first before the component state machine and node manager interaction will begin
// Each call to "cmptStartup" should be followed by one call to the "cmptShutdown" function
int cmptStartup(void)
{
FILE * propertyFile;
pthread_attr_t attr; // Thread attributed for the component threads spawned in this function
if(cmpt->state == JAUS_SHUTDOWN_STATE) // Execute the startup routines only if the component is not running
{
propertyFile = fopen("./config/cmpt.conf", "r");
if(propertyFile)
{
cmptProperties = propertiesCreate();
cmptProperties = propertiesLoad(cmptProperties, propertyFile);
fclose(propertyFile);
}
else
{
cError("cmpt: Cannot find or open properties file\n");
return CMPT_LOAD_CONFIGURATION_ERROR;
}
// Check in to the Node Manager and obtain Instance, Node and Subsystem IDs
cmptNode = jausNodeCreate();
cmptSubsystem = jausSubsystemCreate();
cmptNode->subsystem = cmptSubsystem;
cmpt->node = cmptNode;
cmpt->services = jausServicesCreate();
cmpt->state = JAUS_INITIALIZE_STATE; // Set the state of the JAUS state machine to INITIALIZE
cmptNmi = nodeManagerOpen(cmpt);
if(cmptNmi == NULL)
{
cError("cmpt: Could not open connection to node manager\n");
return CMPT_NODE_MANAGER_OPEN_ERROR;
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
cmptRun = TRUE;
if(pthread_create(&cmptThreadId, &attr, cmptThread, NULL) != 0)
{
cError("cmpt: Could not create cmptThread\n");
cmptShutdown();
pthread_attr_destroy(&attr);
return CMPT_THREAD_CREATE_ERROR;
}
pthread_attr_destroy(&attr);
}
else
{
cError("cmpt: Attempted startup while not shutdown\n");
return CMPT_STARTUP_BEFORE_SHUTDOWN_ERROR;
}
return 0;
}
void Config::LoadConfigRule()
{
std::string file = Utils::getConfigFile(RULES_CONFIG);
if (!Utils::fileExists(file))
{
std::ofstream conf(file.c_str(), std::ofstream::out);
conf << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" << std::endl;
conf << "<calaos:rules xmlns:calaos=\"http://www.calaos.fr\">" << std::endl;
conf << "</calaos:rules>" << std::endl;
conf.close();
}
TiXmlDocument document(file);
if (!document.LoadFile())
{
cError() << "There was a parse error in " << file;
cError() << document.ErrorDesc();
cError() << "In file " << file << " At line " << document.ErrorRow();
exit(-1);
}
TiXmlHandle docHandle(&document);
TiXmlElement *rule_node = docHandle.FirstChildElement("calaos:rules").FirstChildElement().ToElement();
if (!rule_node)
{
cError() << "Error, <calaos:rules> node not found in file " << file;
}
for(; rule_node; rule_node = rule_node->NextSiblingElement())
{
if (rule_node->ValueStr() == "calaos:rule" &&
rule_node->Attribute("name") &&
rule_node->Attribute("type"))
{
std::string name, type;
name = rule_node->Attribute("name");
type = rule_node->Attribute("type");
Rule *rule = new Rule(type, name);
rule->LoadFromXml(rule_node);
ListeRule::Instance().Add(rule);
}
}
cInfo() << "Done. " << ListeRule::Instance().size() << " rules loaded.";
}
cMouse::cMouse( HWND hWnd, bool bExclusive )
{
m_pTarget = NULL;
HRESULT hr;
/**
* Crea el device
*/
hr = Input()->GetDInput()->CreateDevice( GUID_SysMouse, &m_pDevice, NULL );
if( FAILED( hr ))
{
throw cError(L"[cMouse::Init]: No se pudo crear el device!\n");
}
/**
* Setea el formato
*/
hr = m_pDevice->SetDataFormat(&c_dfDIMouse);
if( FAILED( hr ))
{
SafeRelease( m_pDevice );
throw cError(L"[cMouse::Init]: SetDataFormat fallo\n");
}
/**
* Setea el nivel de cooperacion
*/
if( bExclusive )
{
hr = m_pDevice->SetCooperativeLevel( hWnd, DISCL_EXCLUSIVE | DISCL_NOWINKEY | DISCL_FOREGROUND );
}
else
{
hr = m_pDevice->SetCooperativeLevel( hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
}
if( FAILED( hr ))
{
SafeRelease( m_pDevice );
throw cError(L"[cMouse::Init]: SetCooperativeLevel fallo\n");
}
m_lastState.lX = 0;
m_lastState.lY = 0;
m_lastState.lZ = 0;
m_lastState.rgbButtons[0] = 0;
m_lastState.rgbButtons[1] = 0;
m_lastState.rgbButtons[2] = 0;
m_lastState.rgbButtons[3] = 0;
}
void Config::LoadConfigIO()
{
std::string file = Utils::getConfigFile(IO_CONFIG);
if (!Utils::fileExists(file))
{
std::ofstream conf(file.c_str(), std::ofstream::out);
conf << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" << std::endl;
conf << "<calaos:ioconfig xmlns:calaos=\"http://www.calaos.fr\">" << std::endl;
conf << "<calaos:home></calaos:home>" << std::endl;
conf << "</calaos:ioconfig>" << std::endl;
conf.close();
}
TiXmlDocument document(file);
if (!document.LoadFile())
{
cError() << "There was a parse error";
cError() << document.ErrorDesc();
cError() << "In file " << file << " At line " << document.ErrorRow();
exit(-1);
}
TiXmlHandle docHandle(&document);
TiXmlElement *room_node = docHandle.FirstChildElement("calaos:ioconfig").FirstChildElement("calaos:home").FirstChildElement().ToElement();
for(; room_node; room_node = room_node->NextSiblingElement())
{
if (room_node->ValueStr() == "calaos:room" &&
room_node->Attribute("name") &&
room_node->Attribute("type"))
{
std::string name, type;
int hits = 0;
name = room_node->Attribute("name");
type = room_node->Attribute("type");
if (room_node->Attribute("hits"))
room_node->Attribute("hits", &hits);
Room *room = new Room(name, type, hits);
ListeRoom::Instance().Add(room);
room->LoadFromXml(room_node);
}
}
cInfo() << "Done. ";
}
void wdStandbyState(void)
{
if(!gposSc->isActive || !vssSc->isActive || !pdWrenchSc->isActive || !pdStatusSc->isActive || !wdInControl)
{
wd->state = JAUS_EMERGENCY_STATE;
cError( "wd: Switching to EMERGENCY: GposSc: %s, VssSc: %s, PdWrenchSc: %s, PdStatusSc: %s, Rd: %s\n",
gposSc->isActive? "Active" : "Inactive",
vssSc->isActive? "Active" : "Inactive",
pdWrenchSc->isActive? "Active" : "Inactive",
pdStatusSc->isActive? "Active" : "Inactive",
wdInControl? "In Control" : "Not In Control"
);
return;
}
// Setup Vehicle State
vehicleState->desiredSpeedMps = 0;
vehicleState->desiredPhiEffort = 0;
wdExcecuteControl(vehicleState);
if(pd->state == JAUS_READY_STATE)
{
wd->state = JAUS_READY_STATE;
}
}
/*!
* \fn void cConst::ReAlloc(const cDVector& theVectParam, const uint theNumParam)
* \param const cDVector& theVectParam: the constant value is in theVectParam[0]
* \param const uint theNumParam: not used for cConst class
* \details Here, mvConst = theVectParam[0]
*/
void cConst::ReAlloc(const cDVector& theVectParam, const uint theNumParam)
{
if (theVectParam.GetSize() > 0)
mvConst = theVectParam[0] ;
else
throw cError("Size of 'theVectParam' must be > 0") ;
}
/*!
* \fn double cCondMean::Get(uint theNumMean, uint theIndex, uint theNumParam)
* \param uint theNumMean: index of conditional mean
* \param uint theNumParam: index of parameter
*/
double cCondMean::Get(uint theNumMean, uint theIndex, uint theNumParam)
{
if (theNumMean < GetNMean() )
return mvCondMean.at(theNumMean)->Get(theIndex, theNumParam) ;
else
throw cError("cCondMean::Get bad index");
}
/*!
* \fn void cArch::Set(const cDVector& theVectParam, const uint theNumParam)
* \brief fill the parameters vector
* \param const cDVector& theVectParam: the vector of values
* \param const uint theNumParam: =0, mvConst; =1, mvArch
* \details mvArch = theVectParam or mvConst = theVectParam[0]
*/
void cArch::Set(const cDVector& theVectParam, const uint theNumParam)
{ switch (theNumParam)
{ case 0 :
if (theVectParam.GetSize() > 0)
mvConst = theVectParam[0] ;
else
throw cError("cArch::Set - Size of theVectParam must be > 0") ;
break ;
case 1 :
mvArch = theVectParam ;
break ;
default:
throw cError("cArch::Set - theNumParam must be in 0, 1") ;
break ;
}
}
/*!
* \fn void cArch::Set(const double theValue, const uint theIndex, const uint theNumParam)
* \brief fill the parameters vector
* \param const double theValue: the value of the "theIndex" th lag. Default 0.
* \param const uint theIndex: the index.
* \param const uint theNumParam: =0, mvConst, =1, ARCH parameters
* \details mvArch[theIndex] = theValue or mvConst = theValue
*/
void cArch::Set(const double theValue, const uint theIndex, const uint theNumParam)
{ switch (theNumParam)
{ case 0 :
mvConst = theValue ;
break ;
case 1 :
if (theIndex < mvArch.GetSize())
mvArch[theIndex] = theValue ;
else
throw cError("cArch::Set - wrong index") ;
break ;
default:
throw cError("cArch::Set - theNumParam must be in 0, 1") ;
break ;
}
}
/*!
* \fn cAbstCondMean* cCondMean::GetOneMean(uint theIndex) const
* \param uint theIndex: index of component to be returned
* \\details return mvCondMean[theWhateMean]
*/
cAbstCondMean* cCondMean::GetOneMean(uint theIndex) const
{
if (theIndex < GetNMean())
return mvCondMean.at(theIndex) ;
else
throw cError("cCondMean::GetOneMean bad index") ;
}
// Function: cmptShutdown
// Access: Public
// Description: This function allows the abstracted component functionality contained in this file to be stoped from an external source.
// If the component is in the running state, this function will terminate all threads running in this file
// This function will also close the Jms connection to the Node Manager and check out the component from the Node Manager
int cmptShutdown(void)
{
double timeOutSec;
if(cmpt->state != JAUS_SHUTDOWN_STATE) // Execute the shutdown routines only if the component is running
{
cmptRun = FALSE;
timeOutSec = getTimeSeconds() + CMPT_THREAD_TIMEOUT_SEC;
while(cmptThreadRunning)
{
usleep(100000);
if(getTimeSeconds() >= timeOutSec)
{
pthread_cancel(cmptThreadId);
cmptThreadRunning = FALSE;
cError("cmpt: cmptThread Shutdown Improperly\n");
break;
}
}
nodeManagerClose(cmptNmi); // Close Node Manager Connection
jausSubsystemDestroy(cmpt->node->subsystem);
jausNodeDestroy(cmpt->node);
jausServicesDestroy(cmpt->services);
cmpt->state = JAUS_SHUTDOWN_STATE;
propertiesDestroy(cmptProperties);
}
return 0;
}
void cArch::RegArchParamToVector(cDVector& theDestVect, uint theIndex)
{
uint mySize = GetNParam() ;
if (theDestVect.GetSize() < mySize + theIndex)
throw cError("Wrong size") ;
theDestVect[theIndex] = mvConst ;
mvArch.SetSubVectorWithThis(theDestVect, theIndex+1) ;
}
void cArch::VectorToRegArchParam(const cDVector& theSrcVect, uint theIndex)
{
uint mySize = theSrcVect.GetSize() ;
if (GetNParam() + theIndex > mySize)
throw cError("Wrong size") ;
mvConst = theSrcVect[theIndex] ;
mvArch.SetThisWithSubVector(theSrcVect, theIndex+1) ;
}
bool Utils::set_config_option(std::string key, std::string value)
{
TiXmlDocument document(getConfigFile(LOCAL_CONFIG).c_str());
if (!document.LoadFile())
{
cError() << "There was an exception in XML parsing.";
cError() << "Parse error: " << document.ErrorDesc();
cError() << "In file " << getConfigFile(LOCAL_CONFIG) << " At line " << document.ErrorRow();
return false;
}
TiXmlHandle docHandle(&document);
bool found = false;
TiXmlElement *key_node = docHandle.FirstChildElement("calaos:config").FirstChildElement().ToElement();
if (key_node)
{
for(; key_node; key_node = key_node->NextSiblingElement())
{
if (key_node->ValueStr() == "calaos:option" &&
key_node->Attribute("name") &&
key_node->Attribute("name") == key)
{
key_node->SetAttribute("value", value);
found = true;
break;
}
}
//the option was not found, we create it
if (!found)
{
TiXmlElement *element = new TiXmlElement("calaos:option");
element->SetAttribute("name", key);
element->SetAttribute("value", value);
docHandle.FirstChild("calaos:config").ToElement()->LinkEndChild(element);
}
document.SaveFile();
}
return true;
}
/*!
* \fn void cCondMean::SetOneMean(uint theWhatMean, cAbstCondMean* theAbstCondMean)
* \param uint theWhatMean: index of the conditional mean component
* \param cAbstCondMean* theAbstCondMean: conditional mean component to be copied in the mCondMean array.
* \brief *mvCondMean[theWhatMean] = *theAbstCondMean
*/
void cCondMean::SetOneMean(uint theWhatMean, cAbstCondMean& theAbstCondMean)
{
if (theWhatMean >= GetNMean())
throw cError("cCondMean::GetOneMean bad index") ;
else
{
mvCondMean.at(theWhatMean) = theAbstCondMean.PtrCopy();
}
}
// Function: gposProcessMessage
// Access: Private
// Description: This function is responsible for handling incoming JAUS messages from the Node Manager.
// Incoming messages are processed according to message type.
void gposProcessMessage(JausMessage message)
{
QueryGlobalPoseMessage queryGlobalPose;
JausMessage txMessage;
// This block of code is intended to reject commands from non-controlling components
if(gpos->controller.active && message->source->id != gpos->controller.address->id && jausMessageIsRejectableCommand(message) )
{
cError("gpos: Received command message %s from non-controlling component.\n", jausMessageCommandCodeString(message));
jausMessageDestroy(message); // Ignore this message
return;
}
switch(message->commandCode) // Switch the processing algorithm according to the JAUS message type
{
case JAUS_QUERY_GLOBAL_POSE:
queryGlobalPose = queryGlobalPoseMessageFromJausMessage(message);
if(queryGlobalPose)
{
gposMessage->destination->id = queryGlobalPose->source->id;
gposMessage->presenceVector = queryGlobalPose->presenceVector;
gposMessage->sequenceNumber = 0;
gposMessage->scFlag = 0;
txMessage = reportGlobalPoseMessageToJausMessage(gposMessage);
nodeManagerSend(gposNmi, txMessage);
jausMessageDestroy(txMessage);
queryGlobalPoseMessageDestroy(queryGlobalPose);
}
else
{
cError("gpos: Error unpacking %s message.\n", jausMessageCommandCodeString(message));
}
jausMessageDestroy(message);
break;
default:
defaultJausMessageProcessor(message, gposNmi, gpos);
break;
}
}
string CalaosEvent::typeToString(int type)
{
switch (type)
{
case EventInputAdded: return "input_added";
case EventInputDeleted: return "input_deleted";
case EventInputChanged: return "input_changed";
case EventInputPropertyDelete: return "input_prop_deleted";
case EventOutputAdded: return "output_added";
case EventOutputDeleted: return "output_deleted";
case EventOutputChanged: return "output_changed";
case EventOutputPropertyDelete: return "output_prop_deleted";
case EventRoomAdded: return "room_added";
case EventRoomDeleted: return "room_deleted";
case EventRoomChanged: return "room_changed";
case EventRoomPropertyDelete: return "room_prop_deleted";
case EventTimeRangeChanged: return "timerange_changed";
case EventScenarioAdded: return "scenario_added";
case EventScenarioDeleted: return "scenario_deleted";
case EventScenarioChanged: return "scenario_changed";
case EventAudioSongChanged: return "audio_song_changed";
case EventAudioPlaylistAdd: return "playlist_tracks_added";
case EventAudioPlaylistDelete: return "playlist_tracks_deleted";
case EventAudioPlaylistMove: return "playlist_tracks_moved";
case EventAudioPlaylistReload: return "playlist_reload";
case EventAudioPlaylistCleared: return "playlist_cleared";
case EventAudioStatusChanged: return "audio_status_changed";
case EventAudioVolumeChanged: return "audio_volume_changed";
default: break;
}
cError() << "Unkown string for event " << type;
cError() << "Did you forget to add string representation for that event??";
return "unkown";
}
JausBoolean scManagerReceiveServiceConnection(NodeManagerInterface nmi, ServiceConnection requestSc, JausMessage *message)
{
ServiceConnection prevSc;
ServiceConnection sc = nmi->scm->incommingSc;
prevSc = NULL;
while(sc)
{
if(sc->commandCode == requestSc->commandCode && sc->address->id == requestSc->address->id )
{
if(getTimeSeconds() > (sc->lastSentTime + sc->timeoutSec))
{
// Connection has Timed Out
sc->isActive = JAUS_FALSE;
while(sc->queue->size)
{
jausMessageDestroy(queuePop(sc->queue));
}
// Remove Service Connection
if(prevSc)
{
prevSc->nextSc = sc->nextSc;
sc->nextSc = NULL;
}
else
{
nmi->scm->incommingSc = sc->nextSc;
sc->nextSc = NULL;
}
nmi->scm->incommingScCount--;
return JAUS_FALSE;
}
if(sc->queue->size)
{
*message = (JausMessage)queuePop(sc->queue);
return JAUS_TRUE;
}
else
{
return JAUS_FALSE;
}
}
else
{
prevSc = sc;
sc = sc->nextSc;
}
}
cError( "libnodeManager: scManagerServiceConnectionReceive: Requested SC does not exist\n" );
return JAUS_FALSE;
}
void cmptStartupState(void)
{
// Populate Core Service
if(!jausServiceAddCoreServices(cmpt->services))
{
cError("cmpt: Addition of Core Services FAILED! Switching to FAILURE_STATE\n");
cmpt->state = JAUS_FAILURE_STATE;
}
// USER: Add the rest of your component specific service(s) here
// USER: Insert Code Here that is only run once before the component goes to init state
}
void wdReadyState(void)
{
double waypointHeading = 0;
double headingDelta = 0;
if(!gposSc->isActive || !vssSc->isActive || !pdWrenchSc->isActive || !pdStatusSc->isActive || !wdInControl)
{
wd->state = JAUS_EMERGENCY_STATE;
cError( "wd: Switching to EMERGENCY: GposSc: %s, VssSc: %s, PdWrenchSc: %s, PdStatusSc: %s, Rd: %s\n",
gposSc->isActive? "Active" : "Inactive",
vssSc->isActive? "Active" : "Inactive",
pdWrenchSc->isActive? "Active" : "Inactive",
pdStatusSc->isActive? "Active" : "Inactive",
wdInControl? "In Control" : "Not In Control"
);
return;
}
if(pd->state != JAUS_READY_STATE)
{
wd->state = JAUS_STANDBY_STATE;
return;
}
vehicleState->speedMps = wdReportVss? wdReportVss->velocityXMps : 0;
if(currentWaypointIndex < wdWaypoints->elementCount)
{
SetGlobalWaypointMessage tempGlobalWaypoint;
tempGlobalWaypoint = (SetGlobalWaypointMessage) wdWaypoints->elementData[currentWaypointIndex];
waypointHeading = greatCircleCourse(wdReportGpos->latitudeDegrees * RAD_PER_DEG, wdReportGpos->longitudeDegrees * RAD_PER_DEG, tempGlobalWaypoint->latitudeDegrees * RAD_PER_DEG, tempGlobalWaypoint->longitudeDegrees * RAD_PER_DEG);
wdWaypointDistance = greatCircleDistance(wdReportGpos->latitudeDegrees * RAD_PER_DEG, wdReportGpos->longitudeDegrees * RAD_PER_DEG, tempGlobalWaypoint->latitudeDegrees * RAD_PER_DEG, tempGlobalWaypoint->longitudeDegrees * RAD_PER_DEG);
headingDelta = wdAngleSubtract(waypointHeading, wdReportGpos->yawRadians);
//cLog("HeadingDelta: %7.2f\n", headingDelta);
vehicleState->desiredPhiEffort = WHEEL_ROTATION_EFFORT_PER_RAD * headingDelta;
vehicleState->desiredSpeedMps = wdSpeed? wdSpeed->speedMps : 0.0;
//cLog("vehicleState->desiredPhiEffort: %7.2f\n", vehicleState->desiredPhiEffort);
}
else
{
//hang out
vehicleState->desiredSpeedMps = 0;
vehicleState->desiredPhiEffort = 0;
}
wdExcecuteControl(vehicleState);
}
int nodeStartup(void)
{
// USER: Rename cmpt to your individual component
if(cmptStartup())
{
cError("node: cmptStartup failed\n");
nodeShutdown();
return NODE_CMPT_STARTUP_FAILED;
}
return 0;
}
void cAparch::VectorToRegArchParam(const cDVector& theSrcVect, uint theIndex)
{uint mySize = theSrcVect.GetSize(),
myIndex = theIndex ;
if (GetNParam() + theIndex > mySize)
throw cError("Wrong size") ;
mvCste = theSrcVect[myIndex++] ;
mvDelta = theSrcVect[myIndex++] ;
mvArch.SetThisWithSubVector(theSrcVect,myIndex) ;
myIndex += mvArch.GetSize() ;
mvGamma.SetThisWithSubVector(theSrcVect,myIndex) ;
myIndex += mvGamma.GetSize() ;
mvGarch.SetThisWithSubVector(theSrcVect,myIndex) ;
}
cResult clean()
{
std::string op;
utils_docker::pullImage("spotify/docker-gc");
logmsg(kLINFO,"Cleaning.");
CommandLine cl("docker", { "run","--rm","-v","/var/run/docker.sock:/var/run/docker.sock","spotify/docker-gc" });
if (utils::runcommand_stream(cl, kORaw, "", {},NULL) != 0)
return cError("Unable to run spotify/docker-gc to clean docker images.");
logmsg(kLINFO,"Cleaning is complete.");
return kRSuccess;
}
cResult showservices()
{
std::vector<std::string> services;
utils::getAllServices(services);
if (services.size()>0)
{
logmsg(kLINFO,"Installed dServices:");
for (auto const & entry : services)
logmsg(kLINFO," "+entry);
} else
return cError("No dServices are installed.");
return kRSuccess;
}
bool XmasWidget::LoadWidget(std::string, double _x, double _y, std::string _id)
{
std::string witem = "calaos/widget/xmas";
if (!LoadEdje(witem))
{
return false;
}
setLayer(500);
EdjeObject::Show();
clip = evas_object_rectangle_add(evas);
evas_object_show(clip);
edje_object_part_swallow(edje, "widget.swallow", clip);
Resize(1024, 768);
//create some flakes
for (int i = 0;i < MAX_FLAKE;i++)
{
std::string type;
if (i < MAX_FLAKE / 3) type = "flake_small";
else if (i >= MAX_FLAKE / 3 && i < (MAX_FLAKE / 3) * 2) type = "flake_medium";
else type = "flake_large";
EdjeObject *o = new EdjeObject(theme, evas);
if (!o->LoadEdje("calaos/widget/xmas/" + type))
cError() << "Error loading edje group calaos/widget/xmas/" + type;
o->setLayer(500);
evas_object_clip_set(o->getEvasObject(), clip);
Flake *flake = new Flake(o);
int tx = random() % clipw;
int ty = random() % cliph;
flake->Move(tx + clipx, ty + clipy);
flake->Show();
flake->setStart(ecore_time_get() + (double)(random() % (flake->getHeight() * 10)) / (double)flake->getHeight());
if (type == "flake_small") flake->setSpeed(1);
if (type == "flake_medium") flake->setSpeed(2);
if (type == "flake_large") flake->setSpeed(3);
flakes.push_back(flake);
}
return true;
}