This test shows how to access the rotAXYS compact positioning device via labbCAN Motion Control Library. It demonstrates how to obtain valid device handles and how to perform positioning tasks.
#include <boost/math/constants/constants.hpp>
#include <labbcan/common/Point.h>
#include <labbcan/common/labbcan_test_helpers.h>
#include <usl/core/Thread.h>
#include <usl/core/PollingTimer.h>
#include <log4cplus/logger.h>
#include <diag/diag.h>
using namespace Lcl;
using namespace Usl;
using namespace boost;
#define BOOST_TEST_MODULE capi_rotaxys_test
#include <boost/test/unit_test.hpp>
long Result;
static const int TESTPOINTS = 4;
static const CPoint TestPosTbl[TESTPOINTS] =
{
CPoint(-49.51, -121.49),
CPoint( 49.26, -121.49),
CPoint(-49.51, -58.50),
CPoint( 49.26, -58.50),
};
BOOST_AUTO_TEST_CASE(testCapiOpen)
{
Result =
LCB_Open(
"config/testconfig_qmixsdk", 0);
}
BOOST_AUTO_TEST_CASE(testDeviceNameLookup)
{
BOOST_CHECK_GT(hAxisX, 0);
CHECK_RETURN_CODE(Result);
BOOST_CHECK_GT(hAxisSystem, 0);
CHECK_RETURN_CODE(Result);
BOOST_CHECK_GT(AxisSystemCount, 0);
long i;
for (i = 0; i < AxisSystemCount; ++i)
{
{
continue;
}
if (hAxisSystem == hAxisSystem2)
{
break;
}
}
BOOST_CHECK_LT(i, AxisSystemCount);
BOOST_CHECK_EQUAL(hAxisX, hAxis);
CHECK_RETURN_CODE(Result);
}
BOOST_AUTO_TEST_CASE(testBusStart)
{
Result =
LCB_Log(
"C-API Log Test Message");
}
bool waitAxisHomingAttained(
dev_hdl hAxis, uint32_t TimeoutSeconds)
{
CPollingTimer Timer(TimeoutSeconds * 1000);
do
{
CThread::sleep(100);
}
while ((0 == Result) && !Timer.isExpired());
return (Result > 0);
}
bool waitHomingAttained(
dev_hdl AxisSystem, uint32_t TimeoutSeconds)
{
CPollingTimer Timer(TimeoutSeconds * 1000);
do
{
CThread::sleep(100);
}
while ((0 == Result) && !Timer.isExpired());
return (Result > 0);
}
bool waitAxisTargetReached(
dev_hdl hAxis, uint32_t TimeoutSeconds)
{
CPollingTimer Timer(TimeoutSeconds * 1000);
do
{
CThread::sleep(100);
}
while ((0 == Result) && !Timer.isExpired());
return (Result > 0);
}
bool waitTargetReached(
dev_hdl AxisSystem, uint32_t TimeoutSeconds)
{
CPollingTimer Timer(TimeoutSeconds * 1000);
do
{
CThread::sleep(100);
}
while ((0 == Result) && !Timer.isExpired());
return (Result > 0);
}
BOOST_AUTO_TEST_CASE(testAxisSystemEnable)
{
for (int i = 0; i < 3; ++i)
{
CHECK_RETURN_CODE(Result);
BOOST_CHECK_GT(Result, 0);
}
}
BOOST_AUTO_TEST_CASE(testAxisSystemHoming)
{
bool HomingAttained = waitHomingAttained(hAxisSystem, 10);
BOOST_CHECK_EQUAL(HomingAttained, true);
}
BOOST_AUTO_TEST_CASE(testCoordinateConversion)
{
double PosX;
double PosY;
BOOST_TEST_MESSAGE("PosX: " << PosX << " PosY: " << PosY);
BOOST_CHECK_NE(0, RotationAxis);
CHECK_RETURN_CODE(Result);
BOOST_CHECK_NE(0, RadiusAxis);
CHECK_RETURN_CODE(Result);
double Radius;
double Azimuth;
BOOST_TEST_MESSAGE("Azimuth: " << Azimuth << " Radius: " << Radius);
double JibLength = -18;
double d1 = sqrt(pow(Radius, 2) + pow(JibLength, 2));
double beta = math::constants::pi<double>() / 2 - Azimuth
- atan2(JibLength , Radius);
double x = d1 * sin(beta);
double y = d1 * cos(beta);
BOOST_TEST_MESSAGE("X: " << x << " Y: " << y);
BOOST_CHECK_CLOSE(PosX, x, 0.0001);
BOOST_CHECK_CLOSE(PosY, y, 0.0001);
}
BOOST_AUTO_TEST_CASE(testPositioning)
{
for (int i = 0; i < TESTPOINTS; ++i)
{
const CPoint* Point = &TestPosTbl[i];
bool TargetReached = waitTargetReached(hAxisSystem, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
CHECK_RETURN_CODE(Result);
TargetReached = waitAxisTargetReached(ZAxis, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
double MaxZ;
TargetReached = waitAxisTargetReached(ZAxis, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
}
}
BOOST_AUTO_TEST_CASE(testPositioningSlow)
{
static const double SLOW_SPEED = 0.3;
for (int i = 0; i < TESTPOINTS; ++i)
{
const CPoint* Point = &TestPosTbl[i];
Result =
LCA_MoveToPosXY(hAxisSystem, Point->x(), Point->y(), SLOW_SPEED, 0);
bool TargetReached = waitTargetReached(hAxisSystem, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
CHECK_RETURN_CODE(Result);
TargetReached = waitAxisTargetReached(ZAxis, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
double MaxZ;
TargetReached = waitAxisTargetReached(ZAxis, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
}
}
BOOST_AUTO_TEST_CASE(testSafePositioning)
{
CHECK_RETURN_CODE(Result);
REQUIRE_ERR_NOERR(Result);
if (Result > 0)
{
BOOST_TEST_MESSAGE("Skipping testSafePositioning because it is not supported by simulated devices");
return;
}
CHECK_RETURN_CODE(Result);
CHECK_RETURN_CODE(Result);
bool TargetReached = waitAxisTargetReached(ZAxis, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
double SensorState;
CHECK_RETURN_CODE(Result);
BOOST_REQUIRE_NE(SensorState, 1);
const CPoint* Point = &TestPosTbl[0];
CHECK_RETURN_CODE(Result);
TargetReached = waitTargetReached(hAxisSystem, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
CHECK_RETURN_CODE(Result);
Point = &TestPosTbl[1];
double MaxZ;
TargetReached = waitAxisTargetReached(ZAxis, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
CHECK_RETURN_CODE(Result);
BOOST_CHECK_EQUAL(SensorState, 1);
CHECK_RETURN_CODE(Result);
TargetReached = waitTargetReached(hAxisSystem, 5);
BOOST_CHECK_EQUAL(TargetReached, true);
CHECK_RETURN_CODE(Result);
}
BOOST_AUTO_TEST_CASE(testAxesDisable)
{
CThread::sleep(200);
BOOST_CHECK_GT(AxisCount, 0);
for (int i = 0; i < AxisCount; ++i)
{
CHECK_RETURN_CODE(Result);
BOOST_CHECK_GT(Axis, 0);
BOOST_CHECK_EQUAL(0, Result);
BOOST_CHECK_EQUAL(0, Result);
}
}
BOOST_AUTO_TEST_CASE(testCapiClose)
{
}