//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "undercarriage_ctrl");
// construct nodeClass
NodeClass nodeClass;
// specify looprate of control-cycle
ros::Rate loop_rate(50); // Hz
while(nodeClass.n.ok())
{
// process Callbacks (get new pltf-cmd's and check for EMStop)
ros::spinOnce();
// request Update of Undercarriage Configuration
nodeClass.GetJointState();
// calculate forward kinematics and update Odometry
nodeClass.UpdateOdometry();
// perform one control step, calculate inverse kinematics
// and publish updated joint cmd's (if no EMStop occurred)
nodeClass.CalcCtrlStep();
// -> let node sleep for the rest of the cycle
loop_rate.sleep();
}
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "base_drive_chain");
NodeClass nodeClass;
// specify looprate of control-cycle
ros::Rate loop_rate(100); // Hz
while(nodeClass.n.ok())
{
//Read-out of CAN buffer is only necessary during read-out of Elmo Recorder
if( nodeClass.m_bReadoutElmo ) {
if(nodeClass.m_bisInitialized) nodeClass.m_CanCtrlPltf->evalCanBuffer();
if(nodeClass.m_CanCtrlPltf->ElmoRecordings(100, 0, "") == 0) {
nodeClass.m_bReadoutElmo = false;
ROS_INFO("CPU consuming evalCanBuffer used for ElmoReadout deactivated");
}
}
nodeClass.publish_JointStates();
loop_rate.sleep();
ros::spinOnce();
}
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "cob3_platform");
NodeClass nodeClass;
// main loop
ros::Rate loop_rate(25); // Hz
while(nodeClass.n.ok())
{
nodeClass.current_time = ros::Time::now();
// publish Odometry
nodeClass.updateOdometry();
// update velocity of platform
nodeClass.updateCmdVel();
ros::spinOnce();
loop_rate.sleep();
}
// ros::spin();
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "base_drive_chain");
NodeClass nodeClass;
// specify looprate of control-cycle
int rate;
nodeClass.n.getParam("cycleRate", rate);
ROS_INFO("set can querry rate to %i hz", rate);
ros::Rate loop_rate(rate); // Hz
nodeClass.last = ros::Time::now();
nodeClass.now = ros::Time::now();
if(nodeClass.autoInit)
{
nodeClass.can_init();
}
while(nodeClass.n.ok())
{
nodeClass.publish_JointStates();
nodeClass.sendVelCan();
loop_rate.sleep();
ros::spinOnce();
nodeClass.now = ros::Time::now();
if(nodeClass.m_bisInitialized) nodeClass.m_CanCtrlPltf->timeStep( (nodeClass.now - nodeClass.last).toSec() );
nodeClass.last = nodeClass.now;
}
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "powercube_chain");
// create nodeClass
NodeClass nodeClass;
// main loop
ros::Rate loop_rate(5); // Hz
while(nodeClass.n.ok())
{
// publish JointState
nodeClass.publishJointState();
// read parameter
std::string operationMode;
nodeClass.n.getParam("OperationMode", operationMode);
ROS_INFO("running with OperationMode [%s]", operationMode.c_str());
// sleep and waiting for messages, callbacks
ros::spinOnce();
loop_rate.sleep();
}
// ros::spin();
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "sick_s300");
NodeClass nodeClass;
ScannerSickS300 SickS300;
//char *pcPort = new char();
// const char pcPort[] = "/dev/ttyUSB1"; //TODO replace with parameter port
// const char pcPort[] = nodeClass.port;
// int iBaudRate = 500000;
int iBaudRate = nodeClass.baud;
int iScanId = nodeClass.scan_id;
bool bOpenScan = false, bRecScan = false;
bool firstTry = true;
std::vector<double> vdDistM, vdAngRAD, vdIntensAU;
while (!bOpenScan)
{
ROS_INFO("Opening scanner... (port:%s)",nodeClass.port.c_str());
bOpenScan = SickS300.open(nodeClass.port.c_str(), iBaudRate, iScanId);
// check, if it is the first try to open scanner
if(!bOpenScan)
{
ROS_ERROR("...scanner not available on port %s. Will retry every second.",nodeClass.port.c_str());
firstTry = false;
}
sleep(1); // wait for scann to get ready if successfull, or wait befor retrying
}
ROS_INFO("...scanner opened successfully on port %s",nodeClass.port.c_str());
// main loop
ros::Rate loop_rate(5); // Hz
while(nodeClass.nodeHandle.ok())
{
// read scan
ROS_DEBUG("Reading scanner...");
bRecScan = SickS300.getScan(vdDistM, vdAngRAD, vdIntensAU);
ROS_DEBUG("...read %d points from scanner successfully",vdDistM.size());
// publish LaserScan
if(bRecScan)
{
ROS_DEBUG("...publishing LaserScan message");
nodeClass.publishLaserScan(vdDistM, vdAngRAD, vdIntensAU);
}
else
{
ROS_WARN("...no Scan available");
}
// sleep and waiting for messages, callbacks
ros::spinOnce();
loop_rate.sleep();
}
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "cob_relayboard_node");
NodeClass node;
if(node.init() != 0) return 1;
ros::Rate r(20); //Cycle-Rate: Frequency of publishing EMStopStates
while(node.n.ok())
{
node.sendEmergencyStopStates();
ros::spinOnce();
r.sleep();
}
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "drive_identification_node");
NodeClass node;
if(node.init() == 1) return 1;
node.simpleDriveTest(argc, argv);
/*
while(node.n.ok())
{
ros::spinOnce();
}
*/
// ros::spin();
return 0;
}
//#######################
//#### main programm ####
int main(int argc, char** argv)
{
// initialize ROS, spezify name of node
ros::init(argc, argv, "undercarriage_ctrl");
// construct nodeClass
NodeClass nodeClass;
// automatically do initializing of controller, because it's not directly depending any hardware components
if( nodeClass.is_initialized_bool_ = nodeClass.InitCtrl() ) {
nodeClass.last_time_ = ros::Time::now();
ROS_INFO("Undercarriage control successfully initialized.");
} else
ROS_WARN("Undercarriage control initialization failed! Try manually.");
// specify looprate of control-cycle
ros::Rate loop_rate(50); // Hz
while(nodeClass.n.ok())
{
// process Callbacks (get new pltf-cmd's and check for EMStop)
ros::spinOnce();
// request Update of Undercarriage Configuration
nodeClass.GetJointState();
// calculate forward kinematics and update Odometry
nodeClass.UpdateOdometry();
// perform one control step, calculate inverse kinematics
// and publish updated joint cmd's (if no EMStop occurred)
nodeClass.CalcCtrlStep();
// -> let node sleep for the rest of the cycle
loop_rate.sleep();
}
return 0;
}
