1024 lines
23 KiB
C++
1024 lines
23 KiB
C++
|
||
/************************************************************/
|
||
/* NAME: zjk */
|
||
/* ORGN: MIT */
|
||
/* FILE: TaskManger.cpp */
|
||
/* DATE: */
|
||
/************************************************************/
|
||
//TODO: 增加故障处理
|
||
#include <list>
|
||
#include <iterator>
|
||
#include "MBUtils.h"
|
||
#include "TaskManger.h"
|
||
|
||
using namespace std;
|
||
|
||
#define DEBUG
|
||
|
||
|
||
//---------------------------------------------------------
|
||
// Constructor
|
||
|
||
TaskManger::TaskManger()
|
||
{
|
||
|
||
cout << "Task Manger process staring ... " << endl;
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Destructor
|
||
|
||
TaskManger::~TaskManger()
|
||
{
|
||
Notify("RUN","false");
|
||
Notify("MOOS_MANUAL_OVERRIDE","true");
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Procedure: OnNewMail
|
||
|
||
bool TaskManger::OnNewMail(MOOSMSG_LIST &NewMail)
|
||
{
|
||
AppCastingMOOSApp::OnNewMail(NewMail);
|
||
MOOSMSG_LIST::iterator p;
|
||
for(p=NewMail.begin(); p!=NewMail.end(); p++)
|
||
{
|
||
CMOOSMsg &msg = *p;
|
||
string msg_name = msg.GetName();
|
||
string msg_str = msg.GetString();
|
||
double msg_dval = msg.GetDouble();
|
||
bool msg_bval = msg.GetBinaryData();
|
||
// cout << msg_name + ": " << msg_str << endl;
|
||
if(msg_name == MSG_ENDFLAG)
|
||
{
|
||
if(msg_str == "true")
|
||
current_node_complete = true;
|
||
else
|
||
current_node_complete = false;
|
||
}
|
||
|
||
if(msg_name == MSG_WPTFLAG)
|
||
{
|
||
if(msg_str == "true")
|
||
current_pol_complete = true;
|
||
else
|
||
current_pol_complete = false;
|
||
clearHelmFlag();
|
||
}
|
||
|
||
if(msg_name == MSG_FALUT)
|
||
{
|
||
state = FAULT;
|
||
faultMsg = msg_str;
|
||
if(faultMsg == "AltitudeOut")
|
||
faultNumber = 4;
|
||
else if(faultMsg == "DepthOut")
|
||
faultNumber = 1;
|
||
else if(faultMsg == "RegionOut")
|
||
faultNumber = 2;
|
||
else if(faultMsg == "TimeOut")
|
||
faultNumber = 2;
|
||
else
|
||
faultNumber = 99;
|
||
}
|
||
|
||
//CONFIG 状态和手动清除任务故障的功能
|
||
if(msg_name == MSG_SENDSAFTRULES && msg_str == "true")
|
||
{
|
||
state = CONFIG;
|
||
st = 40;
|
||
}
|
||
if(msg_name == MSG_CLEARFAULT)
|
||
{
|
||
st = 39;
|
||
state = FAULT;
|
||
}
|
||
|
||
if(msg_name == MSG_IN_SSM)
|
||
{
|
||
Json::Value j;
|
||
Json::Reader a;
|
||
a.parse(msg_str,j);
|
||
RepList["FormSSM"] = j;
|
||
if(j["action"].asString() == "start")
|
||
{
|
||
taskName = j["taskName"].asString();
|
||
state = RUN;
|
||
cout << "Task Manager Status is Run!!!" << endl;
|
||
start = true;
|
||
st = 10;
|
||
}
|
||
else if (j["action"].asString() == "stop")
|
||
{
|
||
taskName = "";
|
||
state = UNRUN;
|
||
cout << "Task Manager Status is UnRun!!!" << endl;
|
||
st = 20;
|
||
}
|
||
else
|
||
{
|
||
RepList["RunWaring"] = "form SSM have unhandle action : " + j["action"].asString();
|
||
}
|
||
}
|
||
|
||
if(msg_name == MSG_IN_MAN)
|
||
{
|
||
if(msg_str == "true")
|
||
state = MANUAL;
|
||
else
|
||
state = UNRUN;
|
||
}
|
||
|
||
if((msg_name == MSG_FH_LEV2) || (msg_name == MSG_FH_LEV3))
|
||
{
|
||
Json::Value j;
|
||
Json::Reader a;
|
||
a.parse(msg_str,j);
|
||
int fault_level = j["FaultLevel"].asInt();
|
||
if(fault_level != 0)
|
||
{
|
||
state = FAULT;
|
||
faultNumber = 1111;
|
||
}
|
||
}
|
||
|
||
}
|
||
return(true);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Procedure: OnConnectToServer
|
||
|
||
bool TaskManger::OnConnectToServer()
|
||
{
|
||
Notify(MSG_ENDFLAG,"false");
|
||
Notify(MSG_WPTFLAG,"false");
|
||
// Notify(MSG_START,"false");
|
||
Notify(MSG_RUN,"false");
|
||
RegisterVariables();
|
||
InitConfig();
|
||
return(true);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Procedure: Iterate()
|
||
bool TaskManger::Iterate()
|
||
{
|
||
// happens AppTick times per second
|
||
AppCastingMOOSApp::Iterate();
|
||
switch (state)
|
||
{
|
||
case RUN: //状态0～10
|
||
{
|
||
switch(st)
|
||
{
|
||
case 0://发送任务开始、超时和第一个节点
|
||
{
|
||
|
||
//1. send first node
|
||
current_node = getNode(nodeList);
|
||
if(current_node == "")
|
||
st = 9;
|
||
else
|
||
{
|
||
sendNode(current_node, nodeList);
|
||
st = 1;
|
||
}
|
||
//2. send start
|
||
taskStart();
|
||
current_node_complete = false;
|
||
current_pol_complete = false;
|
||
break;
|
||
}
|
||
case 1://等待节点完成信息
|
||
{
|
||
if(current_node_complete || current_pol_complete)
|
||
{
|
||
cout << "Current WayPoint Node complete!" << endl;
|
||
if(current_node == "")
|
||
st = 9;
|
||
else
|
||
st = 2;
|
||
}
|
||
break;
|
||
}
|
||
case 2://读取当前节点信息
|
||
{
|
||
current_node = getNode(nodeList);
|
||
if(current_node != "")
|
||
st = 3;
|
||
else
|
||
st = 1;
|
||
break;
|
||
}
|
||
case 3://发送任务节点
|
||
{
|
||
sendNode(current_node, nodeList);
|
||
current_node_complete = false;
|
||
current_pol_complete = false;
|
||
st = 1;
|
||
break;
|
||
}
|
||
case 9://task complete
|
||
{
|
||
taskFinish();
|
||
st = 10;
|
||
start = false;
|
||
break;
|
||
}
|
||
case 10://等待任务开始
|
||
{
|
||
if(start)
|
||
st = 11;
|
||
break;
|
||
}
|
||
case 11://读取任务文件
|
||
{
|
||
faultMsg = "";
|
||
readTask = readTaskFile(taskName);
|
||
if( readTask != 0)
|
||
{
|
||
state = FAULT;
|
||
faultNumber = 10 + readTask;
|
||
st =30;
|
||
faultMsg = "TaskFileError : " + intToString(readTask);
|
||
}
|
||
st = 0;
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
st = 10;
|
||
//cout << "State reset ..." << endl;
|
||
//taskFinish();
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case UNRUN: //状态20～29
|
||
{
|
||
switch(st)
|
||
{
|
||
case 20://进入UNRUN，初始化状态变量
|
||
{
|
||
current_node_complete = false;
|
||
current_pol_complete = false;
|
||
current_node="";
|
||
start = false;
|
||
Notify(MSG_ENDFLAG,"false");
|
||
Notify(MSG_WPTFLAG,"false");
|
||
// Notify(MSG_START,"false");
|
||
Notify(MSG_RUN,"false");
|
||
Notify("MOOS_MANUAL_OVERRIDE","true");
|
||
cout << "Wating task start......" << endl;
|
||
st = 21;
|
||
break;
|
||
}
|
||
case 21://等待任务开始
|
||
{
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
st = 20;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case FAULT: //状态30～39
|
||
{
|
||
switch(st)
|
||
{
|
||
case 30: //判断故障信息
|
||
{
|
||
if(faultNumber>0 && faultNumber<10)
|
||
st = 31;
|
||
else if(faultNumber>10 && faultNumber<20)
|
||
st = 32;
|
||
else if(faultNumber == 1111)
|
||
st = 33;
|
||
else
|
||
st = 38;
|
||
break;
|
||
}
|
||
case 31: //任务错误
|
||
{
|
||
postFaultNumber(faultNumber);
|
||
state = UNRUN;
|
||
break;
|
||
}
|
||
case 32: //任务文本错误
|
||
{
|
||
postFaultNumber(faultNumber);
|
||
state = UNRUN;
|
||
break;
|
||
}
|
||
case 33: //外部故障
|
||
{
|
||
state = UNRUN;
|
||
break;
|
||
}
|
||
case 38: //未知故障
|
||
{
|
||
postFaultNumber(99);
|
||
break;
|
||
}
|
||
case 39: // 清除任务故障
|
||
{
|
||
FaultFlagClear();
|
||
faultNumber = 0;
|
||
state = UNRUN;
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
st = 30;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case CONFIG: //状态40～49
|
||
{
|
||
switch (st)
|
||
{
|
||
case 40: //配置安全规则
|
||
{
|
||
readSafetyRules("a");
|
||
setSafetyRules(maxTime, maxDepth, minAltitude, safePolygon);
|
||
// setMaxDepth(maxDepth);
|
||
setMaxDepth("2");
|
||
st = 49;
|
||
break;
|
||
}
|
||
case 41: //路径参数配置
|
||
{
|
||
readWayConfig("a");
|
||
setWayConfig(lead,lead_damper,capture_line,capture_radius,slip_radius);
|
||
st = 49;
|
||
//setWayConfig();
|
||
}
|
||
case 49: //等待
|
||
{
|
||
state = UNRUN;
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
st = 49;
|
||
break;
|
||
}
|
||
}
|
||
|
||
break;
|
||
}
|
||
case MANUAL: // 手操状态
|
||
{
|
||
switch (st)
|
||
{
|
||
case 50: // 清除变量
|
||
current_node_complete = false;
|
||
current_pol_complete = false;
|
||
current_node="";
|
||
start = false;
|
||
Notify(MSG_ENDFLAG,"false");
|
||
Notify(MSG_WPTFLAG,"false");
|
||
Notify(MSG_RUN,"false");
|
||
Notify("MOOS_MANUAL_OVERRIDE","true");
|
||
cout << "Wating task start......" << endl;
|
||
st = 51;
|
||
break;
|
||
case 51: // 等待
|
||
break;
|
||
default:
|
||
st = 50;
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
st = 30;
|
||
break;
|
||
}
|
||
}
|
||
postReportToSSM();
|
||
AppCastingMOOSApp::PostReport();
|
||
return(true);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Procedure: OnStartUp()
|
||
// happens before connection is open
|
||
|
||
bool TaskManger::OnStartUp()
|
||
{
|
||
AppCastingMOOSApp::OnStartUp();
|
||
list<string> sParams;
|
||
if(m_MissionReader.GetConfiguration(GetAppName(), sParams))
|
||
{
|
||
list<string>::iterator p;
|
||
for(p=sParams.begin(); p!=sParams.end(); p++) {
|
||
string original_line = *p;
|
||
string line = *p;
|
||
string param = stripBlankEnds(toupper(biteString(line, '=')));
|
||
string value = stripBlankEnds(line);
|
||
|
||
if(param == "PLANCONFIGPATH")
|
||
{
|
||
planConfigPath = value;
|
||
RepList["CueenPath"] = planConfigPath;
|
||
}
|
||
}
|
||
}
|
||
if(planConfigPath == "")
|
||
reportConfigWarning("NO TASK FILE PATH");
|
||
// readTaskFile("a");
|
||
RegisterVariables();
|
||
return(true);
|
||
}
|
||
|
||
//---------------------------------------------------------
|
||
// Procedure: RegisterVariables
|
||
/**
|
||
* @description:
|
||
* @param {double} depth
|
||
* @return {*}
|
||
*/
|
||
bool TaskManger::setMaxDepth(string depth)
|
||
{
|
||
string msgContent = "";
|
||
msgContent = "max_depth=";
|
||
msgContent += depth;
|
||
Notify(UPDATE_MAXDEP, msgContent);
|
||
cout << "set max depth is " + depth << "m!" << endl;
|
||
return true;
|
||
}
|
||
bool TaskManger::setWayPol(string polygon, string speed, string depth)
|
||
{
|
||
string msgContent="";
|
||
if(polygon=="#")
|
||
{
|
||
msgContent = "speed=";
|
||
msgContent += speed;
|
||
Notify(UPDATE_SPD, msgContent);
|
||
|
||
msgContent = "depth=" + depth;
|
||
Notify(UPDATE_DEP, msgContent);
|
||
}
|
||
else
|
||
{
|
||
msgContent = "polygon=";
|
||
msgContent += polygon;
|
||
msgContent += "#";
|
||
msgContent += "speed=";
|
||
msgContent += speed;
|
||
Notify(UPDATE_WPT, msgContent);
|
||
|
||
//使用模版参数生成一个新的行为r
|
||
Notify(UPDATE_WPT,"name=way_track");
|
||
// msgContent = "polygon=";
|
||
// msgContent += polygon;
|
||
// msgContent += "#";
|
||
Notify(UPDATE_WPT, msgContent);
|
||
msgContent = "speed=";
|
||
msgContent += speed;
|
||
Notify(UPDATE_SPD, msgContent);
|
||
|
||
msgContent = "depth=" + depth;
|
||
Notify(UPDATE_DEP, msgContent);
|
||
};
|
||
return true;
|
||
}
|
||
/**
|
||
* @description:
|
||
* @param {string} wpt
|
||
* @return {*}
|
||
*/
|
||
bool TaskManger::setWpt(std::string wpt, string speed, string depth)
|
||
{
|
||
string msgContent="";
|
||
|
||
msgContent += "points=";
|
||
msgContent += wpt;
|
||
msgContent += "#";
|
||
msgContent += "speed=";
|
||
msgContent += speed;
|
||
// msgContent += "#";
|
||
Notify(UPDATE_WPT,msgContent);
|
||
Notify(UPDATE_WPT,"name=way_topoint");
|
||
|
||
|
||
msgContent = "depth=" + depth;
|
||
Notify(UPDATE_DEP, msgContent);
|
||
|
||
msgContent = "speed=";
|
||
msgContent += speed;
|
||
Notify(UPDATE_SPD, msgContent);
|
||
|
||
|
||
cout << "MSG is : " << msgContent + "#depth=" << depth << endl;
|
||
// Notify("WPT_UPDATE", wpt);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @description:
|
||
* @param {double} speed
|
||
* @return {*}
|
||
*/
|
||
bool TaskManger::setSpeed(double speed)
|
||
{
|
||
Notify("SPEED_UPDATE", speed);
|
||
return true;
|
||
}
|
||
|
||
bool TaskManger::setTaskTimer(string timeCount)
|
||
{
|
||
cout << "Set task timer is " << timeCount << "seconds!" << endl;
|
||
string msgContent="";
|
||
msgContent += "name=taskTimer";
|
||
msgContent += "#";
|
||
msgContent += "duration=";
|
||
msgContent += timeCount;
|
||
Notify(UPDATE_TIMER,msgContent);
|
||
}
|
||
|
||
bool TaskManger::setSafetyRules(string maxTime, string maxDepth, string minAltitude, string polygon)
|
||
{
|
||
string msgContent="";
|
||
msgContent += "max_time=";
|
||
msgContent += maxTime;
|
||
msgContent += "#";
|
||
msgContent += "max_depth=";
|
||
msgContent += maxDepth;
|
||
msgContent += "#";
|
||
msgContent += "min_altitude=";
|
||
msgContent += minAltitude;
|
||
msgContent += "#";
|
||
msgContent += "polygon=";
|
||
msgContent += polygon;
|
||
|
||
cout << " The Op_Region parm is : " << msgContent << endl;
|
||
Notify(UPDATE_OPREGION, msgContent);
|
||
return true;
|
||
}
|
||
bool TaskManger::setWayConfig(string lead, string lead_damper, string capture_line, string capture_radius,string slip_radius)
|
||
{
|
||
string msgContent="";
|
||
|
||
msgContent = "lead=";
|
||
msgContent += lead;
|
||
msgContent += "#";
|
||
msgContent += "lead_damper=";
|
||
msgContent += lead_damper;
|
||
msgContent += "#";
|
||
msgContent += "capture_line=";
|
||
msgContent += capture_line;
|
||
msgContent += "#";
|
||
msgContent += "capture_radius=";
|
||
msgContent += capture_radius;
|
||
msgContent += "#";
|
||
msgContent += "slip_radius=";
|
||
msgContent += slip_radius;
|
||
|
||
Notify(UPDATE_WPT, msgContent);
|
||
cout << "Config waypoint parm is :" << msgContent << endl;
|
||
}
|
||
|
||
/**
|
||
* @description:
|
||
* @return {*}
|
||
*/
|
||
void TaskManger::RegisterVariables()
|
||
{
|
||
AppCastingMOOSApp::RegisterVariables();
|
||
Register(MSG_ENDFLAG, 0);
|
||
// Register(MSG_START, 0);
|
||
Register(MSG_WPTFLAG,0);
|
||
Register(MSG_SENDSAFTRULES,0);
|
||
Register(MSG_FALUT,0);
|
||
Register(MSG_CLEARFAULT,0);
|
||
Register(MSG_IN_SSM,0);
|
||
Register(MSG_IN_MAN,0);
|
||
|
||
Register(MSG_FH_LEV2,0);
|
||
Register(MSG_FH_LEV3,0);
|
||
}
|
||
/**
|
||
* @description: read task File to nodeList
|
||
* @param {string} fileName
|
||
* @return {*} 0 if true else >0
|
||
*/
|
||
int TaskManger::readTaskFile(string taskName)
|
||
{
|
||
int faultNubmer = 0;
|
||
if(!nodeList.empty())
|
||
nodeList.clear();
|
||
ifstream ifs;
|
||
ifs.open(planConfigPath, ios::in);
|
||
Json::Reader taskConfigureReader;
|
||
Json::Value inputJsonValue;
|
||
Json::Value currentTask;
|
||
taskConfigureReader.parse(ifs, inputJsonValue);
|
||
ifs.close();
|
||
int taskCount = inputJsonValue.size();
|
||
taskList = inputJsonValue.getMemberNames();
|
||
taskCount = inputJsonValue.size();
|
||
//part1 ： 判断是否存在这个任务
|
||
if (!inputJsonValue.isMember(taskName))
|
||
{
|
||
RepList["Task in File"] = "False";
|
||
return faultNubmer=1;
|
||
}
|
||
else
|
||
{
|
||
//part2 : 读取任务
|
||
string node="";
|
||
currentTask = inputJsonValue[taskName];
|
||
if(currentTask["taskName"].asString() != taskName)
|
||
return faultNubmer=2;
|
||
|
||
double currentTask_maxTime = currentTask["duration"].asDouble();
|
||
double repeat = currentTask["repeat"].asDouble();
|
||
|
||
if(!currentTask["points"].isArray())
|
||
return faultNubmer=3;
|
||
|
||
Json::Value currentTask_Points = currentTask["points"];
|
||
int ps_cnt = currentTask_Points.size();
|
||
for(int i=0; i<ps_cnt; i++)
|
||
{
|
||
string node_name = currentTask_Points[i]["name"].asString();
|
||
string node_x = currentTask_Points[i]["north"].asString();
|
||
string node_y = currentTask_Points[i]["east"].asString();
|
||
string node_depth = currentTask_Points[i]["depth"].asString();
|
||
string node_speed = currentTask_Points[i]["speed"].asString();
|
||
string node_type = currentTask_Points[i]["type"].asString();
|
||
|
||
if(node_type == "point")
|
||
node_type = "@1";
|
||
else if(node_type == "track")
|
||
node_type = "@2";
|
||
else
|
||
return faultNubmer=4;
|
||
node = node_type;
|
||
node += ",";
|
||
node += node_x;
|
||
node += ",";
|
||
node += node_y;
|
||
node += ",";
|
||
node += node_depth;
|
||
node += ",";
|
||
node += node_speed;
|
||
node += ",";
|
||
node += node_name;
|
||
nodeList.push_back(node);
|
||
}
|
||
}
|
||
auto i = nodeList.begin();
|
||
cout << "-------current task node--------" << endl;
|
||
while (i != nodeList.end())
|
||
{
|
||
cout << *i << endl;
|
||
i++;
|
||
}
|
||
cout << "--------------------------------" << endl;
|
||
return 0;
|
||
}
|
||
|
||
int TaskManger::readSafetyRules(string fileName)
|
||
{
|
||
maxDepth = "30";
|
||
maxTime = "1000";
|
||
safePolygon = "pts={-80,-00:-30,-175:150,-100:95,25}";
|
||
return 0;
|
||
}
|
||
|
||
int TaskManger::readWayConfig(string filename)
|
||
{
|
||
lead = "8";
|
||
lead_damper = "1";
|
||
lead_to_start = "false";
|
||
capture_line = "true";
|
||
capture_radius = "5";
|
||
slip_radius = "15";
|
||
efficiency_measure = "all";
|
||
}
|
||
|
||
/**
|
||
* @description: get Depth form
|
||
* @param {string} node
|
||
* @return {*}
|
||
*/
|
||
string TaskManger::getDepth(string node)
|
||
{
|
||
string depth;
|
||
if(getWord(node, 3, depth))
|
||
{
|
||
// cout << "Current Node Depth is " << depth <<endl;
|
||
return depth;
|
||
}
|
||
else
|
||
cout << "Warming: read Depth Parm Filed" << endl;
|
||
return depth;
|
||
}
|
||
/**
|
||
* @description:
|
||
* @param {string} node
|
||
* @return {*}
|
||
*/
|
||
string TaskManger::getSpeed(string node)
|
||
{
|
||
string speed;
|
||
if(getWord(node, 4, speed))
|
||
{
|
||
// cout << "Current Node Speed is " << speed <<endl;
|
||
return speed;
|
||
}
|
||
else
|
||
cout << "Warming: read Speed Parm Filed" << endl;
|
||
// getWord(node, 3, depth);
|
||
return speed;
|
||
}
|
||
/**
|
||
* @description:
|
||
* @param {string} node
|
||
* @return {*}
|
||
*/
|
||
string TaskManger::getWayPoint(string node)
|
||
{
|
||
string x,y;
|
||
bool fr;
|
||
fr = getWord(node, 1, x);
|
||
fr &= getWord(node, 2, y);
|
||
if(fr)
|
||
{
|
||
// cout << "Current WayPoint is: " << x << "," << y << endl;
|
||
return x+","+y;
|
||
}
|
||
else
|
||
cout << "Warming: read WayPoint Parm Filed" << endl;
|
||
}
|
||
|
||
string TaskManger::getWayPolygon(const list<string> nodeList)
|
||
{
|
||
auto i = nodeList.begin();
|
||
string polygon="";
|
||
TaskType t;
|
||
while(i != nodeList.end())
|
||
{
|
||
if(getTaskTpye(*i)==WAYPOLYGON)
|
||
{
|
||
polygon += getWayPoint(*i);
|
||
polygon += ":";
|
||
}
|
||
else
|
||
break;
|
||
i++;
|
||
}
|
||
if(polygon.size()>1)
|
||
polygon.erase(polygon.end()-1);
|
||
// cout << "Current way polygon is: " << polygon << endl;
|
||
return polygon;
|
||
}
|
||
/**
|
||
* @description:
|
||
* @param {string} node
|
||
* @return {*}
|
||
*/
|
||
TaskType TaskManger::getTaskTpye(string node)
|
||
{
|
||
string type;
|
||
TaskType nodetype;
|
||
if(getWord(node, 0, type))
|
||
{
|
||
// cout << "Current task type is: " << type << endl;
|
||
// return type;
|
||
if(type=="@1")
|
||
return nodetype=WAYPOINTS;
|
||
else if(type=="@2")
|
||
return nodetype=WAYPOLYGON;
|
||
else if(type=="@3")
|
||
return nodetype=CONSTHEADING;
|
||
else
|
||
return nodetype=NOTYPE;
|
||
}
|
||
else
|
||
cout << "Warming: read type of task Parm Filed" << endl;
|
||
}
|
||
/**
|
||
* @description:
|
||
* @param {string} str
|
||
* @param {int} c
|
||
* @return {*}
|
||
*/
|
||
bool TaskManger::getWord(const string str, int ct, string &word)
|
||
{
|
||
string cword;
|
||
int count=0;
|
||
for(auto c:str)
|
||
{
|
||
if(c==',')
|
||
{
|
||
if(count==ct)
|
||
{
|
||
word = cword;
|
||
return true;
|
||
}
|
||
cword="";
|
||
count++;
|
||
}
|
||
else
|
||
cword += c;
|
||
}
|
||
word = cword;
|
||
if(ct==0)
|
||
return true;
|
||
else
|
||
return false;
|
||
}
|
||
|
||
string TaskManger::getNode(list<string> &nodelist)
|
||
{
|
||
string current_node;
|
||
if(!nodelist.empty())
|
||
{
|
||
cout << "The remaining number of nodes is: " << nodelist.size() << endl;
|
||
current_node = nodelist.front();
|
||
nodelist.pop_front();
|
||
cout << "Current Node is " << current_node << endl;
|
||
}
|
||
else
|
||
current_node="";
|
||
return current_node;
|
||
}
|
||
|
||
string TaskManger::getTimeCount()
|
||
{
|
||
return "1000";
|
||
}
|
||
|
||
string TaskManger::getMaxDepth()
|
||
{
|
||
return "20";
|
||
}
|
||
string TaskManger::getNodeName(const string node)
|
||
{
|
||
string name="";
|
||
if(getWord(node, 5, name))
|
||
{
|
||
return name;
|
||
}
|
||
else
|
||
cout << "Warming: read Speed Parm Filed" << endl;
|
||
// getWord(node, 3, depth);
|
||
return name;
|
||
}
|
||
bool TaskManger::sendNode(const string current_node, list<string> &nodeList)
|
||
{
|
||
// cout << "Current WayPoint Node complete" << endl;
|
||
string node_pol;
|
||
nodeType = getTaskTpye(current_node);
|
||
switch(nodeType)
|
||
{
|
||
case WAYPOINTS:
|
||
{
|
||
node_wpt = getWayPoint(current_node);
|
||
node_depth = getDepth(current_node);
|
||
node_speed = getSpeed(current_node);
|
||
setWpt(node_wpt, node_speed, node_depth);
|
||
current_node_complete = false;
|
||
break;
|
||
}
|
||
case WAYPOLYGON:
|
||
{
|
||
node_depth = getDepth(current_node);
|
||
node_speed = getSpeed(current_node);
|
||
if (current_pol_complete && !current_node_complete) //wayflag发布但是endflag没有发布时代表不是首个节点，不发布路径信息
|
||
{
|
||
node_pol = "#";
|
||
}
|
||
else //if(current_pol_complete && current_node_complete)
|
||
{
|
||
nodeList.push_front(current_node);
|
||
node_pol = getWayPolygon(nodeList);
|
||
nodeList.pop_front();
|
||
}
|
||
setWayPol(node_pol, node_speed, node_depth);
|
||
cout << "MSG is :Pol=" + node_pol + "#speed=" + node_speed + "#depth=" + node_depth<< endl;
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
current_node_complete = false;
|
||
current_pol_complete = false;
|
||
|
||
return true;
|
||
}
|
||
|
||
void TaskManger::FaultFlagClear()
|
||
{
|
||
faultNumber = 0;
|
||
if(faultMsg == "AltitudeOut")
|
||
Notify(UPDATE_RESETFAULT,"altittude");
|
||
else if(faultMsg == "DepthOut")
|
||
Notify(UPDATE_RESETFAULT,"depth");
|
||
else if(faultMsg == "RegionOut")
|
||
Notify(UPDATE_RESETFAULT,"poly");
|
||
else if(faultMsg == "TimeOut")
|
||
Notify(UPDATE_RESETFAULT,"time");
|
||
else
|
||
cout << "Can not Clear Unknow Fault Flag!!!" << endl;
|
||
cout << "Clear Fault : " + faultMsg << endl;
|
||
}
|
||
|
||
bool TaskManger::buildReport()
|
||
{
|
||
switch (state)
|
||
{
|
||
case UNRUN:
|
||
{
|
||
m_msgs << "$Task Manager Status$:" << "UNRUN" << endl;
|
||
m_msgs << "$Idel Task Number$:" << taskCount << endl;
|
||
break;
|
||
}
|
||
case RUN:
|
||
{
|
||
m_msgs << "$Task Manager Status$:" << "RUN" << endl;
|
||
m_msgs << "$Current Task Point$ :" << current_node << endl;
|
||
m_msgs << "Currnet Task List :" << endl;
|
||
for(string i : nodeList)
|
||
m_msgs << " : " << i << endl;
|
||
break;
|
||
}
|
||
case FAULT:
|
||
{
|
||
m_msgs << "$Task Manager Status$:" << "FAULT" << endl;
|
||
break;
|
||
}
|
||
|
||
default:
|
||
break;
|
||
}
|
||
m_msgs << "=========================================================" << endl;
|
||
RepList["Current Node"] = current_node;
|
||
RepList["remaining number of nodes"] = (int)nodeList.size()+1;
|
||
string rep = Json::writeString(RepJsBuilder, RepList);
|
||
m_msgs << rep << endl;
|
||
return true;
|
||
}
|
||
|
||
inline void TaskManger::taskStart()
|
||
{
|
||
Notify("RUN","true");
|
||
Notify("MOOS_MANUAL_OVERRIDE","false");
|
||
}
|
||
inline void TaskManger::taskFinish()
|
||
{
|
||
current_node="";
|
||
Notify("RUN","false");
|
||
state = UNRUN;
|
||
cout << "The task node is all complete!!!" << endl;
|
||
Notify("MOOS_MANUAL_OVERRIDE","true");
|
||
}
|
||
inline void TaskManger::InitConfig()
|
||
{
|
||
Notify(MSG_ENDFLAG,"false");
|
||
Notify(MSG_WPTFLAG,"false");
|
||
// Notify(MSG_START,"false");
|
||
Notify(MSG_RUN,"false");
|
||
//
|
||
readSafetyRules("q");
|
||
setSafetyRules(maxTime, maxDepth, minAltitude, safePolygon);
|
||
readWayConfig("a");
|
||
setWayConfig(lead,lead_damper,capture_line,capture_radius,slip_radius);
|
||
}
|
||
|
||
void TaskManger::postReportToSSM()
|
||
{
|
||
string s_msg;
|
||
Json::Value msg;
|
||
msg["state"] = state;
|
||
msg["taskName"] = taskName;
|
||
msg["destName"] = getNodeName(current_node);
|
||
msg["errorCode"] = faultNumber;
|
||
// msg["progess"] =
|
||
// msg["eta"] =
|
||
RepList["toSSM"] = msg;
|
||
s_msg = Json::writeString(RepJsBuilder,msg);
|
||
Notify(MSG_TO_SSM, s_msg);
|
||
}
|
||
//1:超深
|
||
//2.超时
|
||
//3.超出区域
|
||
//4.低于最小高度
|
||
//11:任务文本
|
||
//99.未知故障
|
||
void TaskManger::postFaultNumber(int n)
|
||
{
|
||
Notify(MSG_TO_FH,n);
|
||
} |