#include "cameraconfig.h"
#include <mil.h>
#include "mil3dcam_sickrangerc.h"
#include "sickcamera_rangerc.h"
#if !USE_REAL_CAMERA
MIL_INT CreateCamera(icon::RangerC**)
{
return SICK_CAMERA_OK;
}
MIL_INT InitCamera(icon::RangerC*)
{
return SICK_CAMERA_OK;
}
MIL_INT FillParams(icon::RangerC*,
RangerParams* pConvParams,
const std::string&,
const char*)
{
pConvParams->MeasurementMode = RANGER_HOR_THR_MODE;
pConvParams->RangeStreamOffset = 0;
pConvParams->IntensityStreamOffset = NO_INTENSITY_INFORMATION;
pConvParams->RangeSizeBit = 16;
pConvParams->IntensitySizeBit = NO_INTENSITY_INFORMATION;
pConvParams->ImageROISizeX = 1536;
pConvParams->ImageROISizeY = 512;
pConvParams->MeasROISizeX = 1536;
pConvParams->MeasROISizeY = 512;
pConvParams->ProfileDataSizeByte = 3072;
pConvParams->FlipY = 1;
pConvParams->FixedPoint = 1;
pConvParams->ROIOffsetX = 0;
pConvParams->ROIOffsetY = 0;
pConvParams->CycleTimeMicroseconds = 5000;
return SICK_CAMERA_OK;
}
MIL_INT SwitchCameraMode(icon::RangerC*, const std::string&)
{
return SICK_CAMERA_OK;
}
void CloseDown(icon::RangerC*)
{
}
#else
#if M_MIL_USE_64BIT
#error iCon library is not supported under 64 bits platforms.
#else
#ifdef _MSC_VER
#if _MSC_VER >= 1400
#ifdef NDEBUG
#pragma comment(lib, "icon_vc80")
#else
#pragma comment(lib, "icon_vc80d")
#endif
#elif _MSC_VER >= 1310
#ifdef NDEBUG
#pragma comment(lib, "icon_vc71")
#else
#pragma comment(lib, "icon_vc71d")
#endif
#else
#error Unsupported Visual Studio version for iCon library.
#endif
#else
#error Unsupported compiler for iCon library.
#endif
#endif
#include "icon_api.h"
#include "rangerc.h"
#include "dataformat.h"
using namespace std;
using namespace icon;
#define CAMERA_COM_PORT_SPEED 115200
#define CAMERA_PROTOCOL_TIMEOUT 15000
static const string BasePath = "<ROOT><CAMERA name='" CAMERA_NAME "'>";
static const string ImageConfigPath =
BasePath + "<CONFIGURATION name='" IMAGE_MODE_NAME "'>";
static const string ImageCompPath =
ImageConfigPath + "<COMPONENT name='" IMAGE_COMP_NAME "'>";
static const string MeasConfigPath =
BasePath + "<CONFIGURATION name='" MEASUREMENT_MODE_NAME "'>";
static const string NumberOfColumnsName = "number of columns";
static const string NumberOfRowsName = "number of rows";
static const string RangeAxisName = "range axis";
static const string SubPixelingName = "sub pixeling";
static const string RowStepSizeName = "row step size";
static const string NumberOfThrsName = "number of thrs";
static const string OutputSelectName = "output select";
static const string AcquistionDirectionName = "acquistion direction";
static const string StartColumnName = "start column";
static const string StartRowName = "start row";
static const string CycleTimeName = "cycle time";
static const string HorThrValueType = "HorThr";
static const string HorMaxValueType = "HorMax";
static const string Hi3DValueType = "Hi3D";
static const string ByteTypeName = "BYTE";
static const string WordTypeName = "WORD";
static const char* const XSumSubCompName = "XSum";
static const char* const SumSubCompName = "Sum";
static const char* const RangeSubCompName = "Range";
static const char* const IntensitySubCompName = "Intensity";
MIL_INT StopCamera(RangerC* pCam);
MIL_INT SwitchCameraMode(RangerC* pCam, const string& rModeName, bool CallStart);
MIL_INT GetCameraDataFormat(RangerC* pCam, DataFormat* pDataFormat);
MIL_INT GetCameraMilIntParam(RangerC* pCam,
const string& rPath,
const string& rParamName,
MIL_INT* pIntValue);
#define DO_CALL_START true
#define DO_NOT_CALL_START false
MIL_INT CreateCamera(RangerC** ppCam)
{
*ppCam = NULL;
Camera* pGeneric = createCamera(RangerC::cameraType, "MyCamera");
if(pGeneric == NULL || pGeneric->getCameraType() != RangerC::cameraType)
{
delete pGeneric;
return SICK_CAMERA_NOT_OK;
}
*ppCam = static_cast<RangerC*>(pGeneric);
return SICK_CAMERA_OK;
}
MIL_INT InitCamera(RangerC* pCam)
{
int Ret;
Ret = pCam->setComParameters(CAMERA_COM_PORT, CAMERA_COM_PORT_SPEED);
if (Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
Ret = pCam->setProtocolTimeout(CAMERA_PROTOCOL_TIMEOUT);
if (Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
Ret = pCam->init();
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
return SICK_CAMERA_OK;
}
MIL_INT FillParams(RangerC* pCam,
RangerParams* pConvParams,
const string& rParamFilename,
const char* pMeasCompName)
{
MIL_INT Ret;
int Ret2;
const string MeasCompPath =
MeasConfigPath + "<COMPONENT name='" + pMeasCompName + "'>";
Ret = StopCamera(pCam);
if(Ret != SICK_CAMERA_OK)
return Ret;
Ret2 = pCam->fileLoadParameters(rParamFilename);
if(Ret2 != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
MIL_INT ImageROIOffsetX, ImageROIOffsetY;
Ret = GetCameraMilIntParam(pCam, ImageConfigPath, StartColumnName, &ImageROIOffsetX);
if (Ret != SICK_CAMERA_OK)
return Ret;
Ret = GetCameraMilIntParam(pCam, ImageCompPath, StartRowName, &ImageROIOffsetY);
if (Ret != SICK_CAMERA_OK)
return Ret;
Ret = GetCameraMilIntParam(pCam, ImageConfigPath, NumberOfColumnsName,
&pConvParams->ImageROISizeX);
if (Ret != SICK_CAMERA_OK)
return Ret;
Ret = GetCameraMilIntParam(pCam, ImageCompPath, NumberOfRowsName,
&pConvParams->ImageROISizeY);
if (Ret != SICK_CAMERA_OK)
return Ret;
Ret = SwitchCameraMode(pCam, MEASUREMENT_MODE_NAME, DO_NOT_CALL_START);
if (Ret != SICK_CAMERA_OK)
return Ret;
DataFormat CameraMeasFormat;
Ret = GetCameraDataFormat(pCam, &CameraMeasFormat);
if (Ret != SICK_CAMERA_OK)
return Ret;
if (CameraMeasFormat.getConfigType() != DataFormat::Linescan_T)
return SICK_CAMERA_NOT_OK;
pConvParams->ProfileDataSizeByte = CameraMeasFormat.dataSize();
const Component* pMeasComponent = CameraMeasFormat.getNamedComponent(pMeasCompName);
if (pMeasComponent == NULL)
return SICK_CAMERA_NOT_OK;
MIL_INT MeasStreamOffset = CameraMeasFormat.getComponentOffset(pMeasCompName);
string MeasValueTypeString = pMeasComponent->getValueType();
if (MeasValueTypeString == HorThrValueType)
pConvParams->MeasurementMode = RANGER_HOR_THR_MODE;
else if (MeasValueTypeString == HorMaxValueType)
pConvParams->MeasurementMode = RANGER_HOR_MAX_MODE;
else if (MeasValueTypeString == Hi3DValueType)
pConvParams->MeasurementMode = M_RANGER_Hi3D_MODE;
else
return SICK_CAMERA_NOT_OK;
Ret = GetCameraMilIntParam(pCam, MeasConfigPath, CycleTimeName,
&pConvParams->CycleTimeMicroseconds);
if (Ret != SICK_CAMERA_OK)
return Ret;
Ret = GetCameraMilIntParam(pCam, MeasConfigPath, NumberOfColumnsName,
&pConvParams->MeasROISizeX);
if (Ret != SICK_CAMERA_OK)
return Ret;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, NumberOfRowsName,
&pConvParams->MeasROISizeY);
if (Ret != SICK_CAMERA_OK)
return Ret;
MIL_INT MeasROIOffsetX;
Ret = GetCameraMilIntParam(pCam, MeasConfigPath, StartColumnName, &MeasROIOffsetX);
if (Ret != SICK_CAMERA_OK)
return Ret;
MIL_INT MeasROIOffsetY;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, StartRowName, &MeasROIOffsetY);
if (Ret != SICK_CAMERA_OK)
return Ret;
pConvParams->ROIOffsetX = (ImageROIOffsetX + pConvParams->ImageROISizeX) -
(MeasROIOffsetX + pConvParams->MeasROISizeX );
pConvParams->ROIOffsetY = MeasROIOffsetY - ImageROIOffsetY;
if (pConvParams->MeasurementMode == RANGER_HOR_THR_MODE)
{
pConvParams->RangeStreamOffset = MeasStreamOffset +
pMeasComponent->getSubComponentOffset(RangeSubCompName);
pConvParams->IntensityStreamOffset = NO_INTENSITY_INFORMATION;
pConvParams->IntensitySizeBit = NO_INTENSITY_INFORMATION;
if ( pConvParams->RangeStreamOffset == DataFormat::E_BAD_NAME )
return SICK_CAMERA_NOT_OK;
MIL_INT RowStepSizeValue;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, RowStepSizeName, &RowStepSizeValue);
if (Ret != SICK_CAMERA_OK)
return Ret;
if (RowStepSizeValue != 1)
return SICK_CAMERA_NOT_OK;
MIL_INT NumberOfThrsValue;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, NumberOfThrsName, &NumberOfThrsValue);
if (Ret != SICK_CAMERA_OK)
return Ret;
MIL_INT OutputSelectValue;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, OutputSelectName, &OutputSelectValue);
if (Ret != SICK_CAMERA_OK)
return Ret;
switch(NumberOfThrsValue)
{
case 1:
pConvParams->FixedPoint = 1;
break;
case 2:
switch(OutputSelectValue)
{
case 1:
case 2:
case 3:
pConvParams->FixedPoint = 1;
break;
case 0:
case 4:
pConvParams->FixedPoint = 2;
break;
case 10:
return SICK_CAMERA_NOT_OK;
default:
return SICK_CAMERA_NOT_OK;
}
break;
default:
return SICK_CAMERA_NOT_OK;
}
const SubComponent* pRangeSubComponent =
pMeasComponent->getNamedSubComponent(RangeSubCompName);
if (pRangeSubComponent == NULL)
return SICK_CAMERA_NOT_OK;
string RangeSizeBitString = pRangeSubComponent->getValueType();
if (RangeSizeBitString == ByteTypeName)
pConvParams->RangeSizeBit = 8;
else if (RangeSizeBitString == WordTypeName)
pConvParams->RangeSizeBit = 16;
else
return SICK_CAMERA_NOT_OK;
MIL_INT RangeAxisValue;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, RangeAxisName, &RangeAxisValue);
if (Ret != SICK_CAMERA_OK)
return Ret;
if (RangeAxisValue != 0 && RangeAxisValue != 1)
return SICK_CAMERA_NOT_OK;
MIL_INT AcquistionDirectionValue;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, AcquistionDirectionName,
&AcquistionDirectionValue);
if (Ret != SICK_CAMERA_OK)
return Ret;
if (AcquistionDirectionValue != 0 && AcquistionDirectionValue != 1)
return SICK_CAMERA_NOT_OK;
if (AcquistionDirectionValue == RangeAxisValue)
pConvParams->FlipY = DO_FLIP_Y_AXIS;
else
pConvParams->FlipY = DO_NOT_FLIP_Y_AXIS;
if ( pConvParams->RangeSizeBit == 16 &&
RangeAxisValue == 0 &&
pConvParams->MeasROISizeY != 512 )
return SICK_CAMERA_NOT_OK;
}
else if (pConvParams->MeasurementMode == RANGER_HOR_MAX_MODE)
{
pConvParams->RangeStreamOffset = MeasStreamOffset +
pMeasComponent->getSubComponentOffset(RangeSubCompName);
pConvParams->IntensityStreamOffset = MeasStreamOffset +
pMeasComponent->getSubComponentOffset(IntensitySubCompName);
pConvParams->IntensitySizeBit = 8;
if ( pConvParams->RangeStreamOffset == DataFormat::E_BAD_NAME ||
pConvParams->IntensityStreamOffset == DataFormat::E_BAD_NAME )
return SICK_CAMERA_NOT_OK;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, SubPixelingName,
&pConvParams->FixedPoint);
if (Ret != SICK_CAMERA_OK)
return Ret;
if (pConvParams->FixedPoint != 0)
return SICK_CAMERA_NOT_OK;
const SubComponent* pRangeSubComponent =
pMeasComponent->getNamedSubComponent(RangeSubCompName);
if (pRangeSubComponent == NULL)
return SICK_CAMERA_NOT_OK;
string RangeSizeBitString = pRangeSubComponent->getValueType();
if (RangeSizeBitString == ByteTypeName)
pConvParams->RangeSizeBit = 8;
else if (RangeSizeBitString == WordTypeName)
pConvParams->RangeSizeBit = 16;
else
return SICK_CAMERA_NOT_OK;
pConvParams->FlipY = DO_FLIP_Y_AXIS;
if ( pConvParams->RangeSizeBit == 16 &&
pConvParams->MeasROISizeY != 512 )
return SICK_CAMERA_NOT_OK;
}
else if (pConvParams->MeasurementMode == M_RANGER_Hi3D_MODE)
{
pConvParams->RangeStreamOffset = MeasStreamOffset +
pMeasComponent->getSubComponentOffset(XSumSubCompName);
pConvParams->IntensityStreamOffset = MeasStreamOffset +
pMeasComponent->getSubComponentOffset( SumSubCompName);
pConvParams->IntensitySizeBit = 16;
if ( pConvParams->RangeStreamOffset == DataFormat::E_BAD_NAME ||
pConvParams->IntensityStreamOffset == DataFormat::E_BAD_NAME )
return SICK_CAMERA_NOT_OK;
pConvParams->FixedPoint = RANGER_C55_DEFAULT_FIXED_POINT;
pConvParams->RangeSizeBit = 16;
MIL_INT RangeAxisValue;
Ret = GetCameraMilIntParam(pCam, MeasCompPath, RangeAxisName, &RangeAxisValue);
if (Ret != SICK_CAMERA_OK)
return Ret;
if (RangeAxisValue == 0)
pConvParams->FlipY = DO_FLIP_Y_AXIS;
else if (RangeAxisValue == 1)
pConvParams->FlipY = DO_NOT_FLIP_Y_AXIS;
else
return SICK_CAMERA_NOT_OK;
}
return SICK_CAMERA_OK;
}
MIL_INT SwitchCameraMode(RangerC* pCam, const string& rModeName)
{
return SwitchCameraMode(pCam, rModeName, DO_CALL_START);
}
void CloseDown(RangerC* pCam)
{
if(pCam != NULL)
{
pCam->close();
delete pCam;
}
closeApi();
}
MIL_INT StopCamera(RangerC* pCam)
{
int Ret, Status;
Ret = pCam->checkCamStatus(Status);
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
if(Status != RangerC::Stopped)
{
Ret = pCam->stop();
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
}
return SICK_CAMERA_OK;
}
MIL_INT SwitchCameraMode(RangerC* pCam, const string& rModeName, bool CallStart)
{
int Ret;
MIL_INT Ret2;
Ret2 = StopCamera(pCam);
if(Ret2 != SICK_CAMERA_OK)
return Ret2;
Ret = pCam->setActiveConfiguration(rModeName);
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
if (CallStart)
{
Ret = pCam->start();
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
}
return SICK_CAMERA_OK;
}
MIL_INT GetCameraDataFormat(RangerC* pCam, DataFormat* pDataFormat)
{
int Ret;
string DataFormatString;
Ret = pCam->getDataFormat("", DataFormatString);
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
Ret = pDataFormat->init(DataFormatString.c_str());
if(Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
return SICK_CAMERA_OK;
}
MIL_INT GetCameraMilIntParam(RangerC* pCam,
const string& rPath,
const string& rParamName,
MIL_INT* pIntValue)
{
string ParamValueString;
int Ret = pCam->getParameterValue(rPath, rParamName, ParamValueString);
if (Ret != Camera::E_ALL_OK)
return SICK_CAMERA_NOT_OK;
*pIntValue = atol( ParamValueString.c_str() );
return SICK_CAMERA_OK;
}
#endif