int PvUniversalParam::plSetParam( PvUniversalParamValue& aValueOut )
{
rs_bool pvRet;
switch (mType)
{
case TYPE_INT8:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.int8_val );
break;
case TYPE_UNS8:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.uns8_val );
break;
case TYPE_INT16:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.int16_val );
break;
case TYPE_UNS16:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.uns16_val );
break;
case TYPE_INT32:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.int32_val );
break;
case TYPE_ENUM:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.enum_val );
break;
case TYPE_BOOLEAN:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.rs_bool_val );
break;
case TYPE_UNS32:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.uns32_val );
break;
case TYPE_FLT64:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.flt64_val );
break;
#ifdef TYPE_INT64
case TYPE_INT64:
pvRet = pl_set_param( mCamera->Handle(), mId, &aValueOut.long64_val );
break;
#endif
default:
mCamera->LogCamError(__LINE__, "PvUniversalParam::plSetParam() type not supported");
pvRet = PV_FAIL;
break;
}
if (pvRet != PV_OK)
return DEVICE_ERR;
return DEVICE_OK;
}
// set numeric parameter value
rs_bool pvcam_set_numeric(int16 hcam, uns32 param_id, double param_value) {
// declarations
rs_bool success = 0; // flag for successful execution
double param_min; // minimum parameter value
double param_max; // maximum parameter value
double param_inc; // parameter increment
int8 int8_value; // signed byte
uns8 uns8_value; // unsigned byte
int16 int16_value; // signed word
uns16 uns16_value; // unsigned word
int32 int32_value; // signed dword
uns32 uns32_value; // unsigned dword
flt64 flt64_value; // double
rs_bool bool_value; // boolean
// obtain min, max & increment for numeric types
// enumerated parameter limits given in ATTR_COUNT
if (attr_type == TYPE_ENUM) {
param_min = 0.0;
param_inc = 1.0;
param_max = (double) attr_count - param_inc;
}
else if (!pvcam_param_value(hcam, param_id, ATTR_MIN, attr_type, ¶m_min)) {
return(0);
}
else if (!pvcam_param_value(hcam, param_id, ATTR_MAX, attr_type, ¶m_max)) {
return(0);
}
else if (!pvcam_param_value(hcam, param_id, ATTR_INCREMENT, attr_type, ¶m_inc)) {
return(0);
}
// check for valid parameter value
if (param_value < param_min) {
pvcam_error(hcam, "Parameter value exceeds minimum value allowed");
return(0);
}
else if (param_value > param_max) {
pvcam_error(hcam, "Parameter value exceeds maximum value allowed");
return(0);
}
else if (param_inc > 0.0) {
if (fmod((param_value - param_min), param_inc) > 0.0) {
pvcam_error(hcam, "Parameter value not integer multiple of increment");
return(0);
}
}
// recast parameter value and save to appropriate storage variable
// set parameter value with appropriate storage variable
switch (attr_type) {
case TYPE_INT8:
int8_value = (int8) param_value;
success = pl_set_param(hcam, param_id, (void *) &int8_value);
break;
case TYPE_UNS8:
uns8_value = (uns8) param_value;
success = pl_set_param(hcam, param_id, (void *) &uns8_value);
break;
case TYPE_INT16:
int16_value = (int16) param_value;
success = pl_set_param(hcam, param_id, (void *) &int16_value);
break;
case TYPE_UNS16:
uns16_value = (uns16) param_value;
success = pl_set_param(hcam, param_id, (void *) &uns16_value);
break;
case TYPE_INT32:
int32_value = (int32) param_value;
success = pl_set_param(hcam, param_id, (void *) &int32_value);
break;
case TYPE_UNS32:
case TYPE_ENUM:
uns32_value = (uns32) param_value;
success = pl_set_param(hcam, param_id, (void *) &uns32_value);
break;
case TYPE_FLT64:
flt64_value = (flt64) param_value;
success = pl_set_param(hcam, param_id, (void *) &flt64_value);
break;
case TYPE_BOOLEAN:
bool_value = (rs_bool)param_value;
success = pl_set_param(hcam, param_id, (void *) &bool_value);
break;
default:
pvcam_error(hcam, "Invalid data type for setting numeric parameter value");
break;
}
// return value of successful execution flag
return(success);
}
/*****************************************************************************
*
* SetLongParam_PvCam
*
* Description ::
* This routine sets a parameter in PvCam, it takes care of data type for
* the user, by taking a long from the user.
*
*-----------------------------------------------------------------------------
*/
bool SetLongParam_PvCam
( int16 handle,
uns32 pvcam_cmd,
long value
)
{
bool status = false;
union {
double dtmp;
uns8 ubytetmp;
int16 stmp;
uns16 ustmp;
int32 ltmp;
uns32 ultmp;
uns32 etmp;
boolean btmp;
int8 bytetmp;
} temp; /* temp variable for values, which can be any data type. */
bool avail; /* PvCam available variable. */
uns16 DataType; /* PvCam data type variable. */
uns16 access; /* PvCam access variable. */
bool fcn_status; /* status of function. */
uns32 count; /* number of values in variable */
fcn_status = (bool)pl_get_param( handle, pvcam_cmd, ATTR_AVAIL, (void*)&temp );
avail = (bool)temp.btmp;
if (fcn_status && avail)
{
pl_get_param( handle, pvcam_cmd, ATTR_TYPE,
(void*)&DataType );
pl_get_param( handle, pvcam_cmd, ATTR_COUNT,
(void*)&count);
pl_get_param( handle, pvcam_cmd, ATTR_ACCESS,
(void*)&access );
/* Make sure this is a valid parameter to set. */
if (access == ACC_READ_WRITE)
{
status = true;
switch (DataType)
{
case TYPE_INT8 : /* signed char */
temp.bytetmp = (char) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.bytetmp);
break;
case TYPE_UNS8 : /* unsigned char */
temp.ubytetmp = (unsigned char) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.ubytetmp);
break;
case TYPE_INT16 : /* short */
temp.stmp = (short) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.stmp);
break;
case TYPE_UNS16 : /* unsigned short */
temp.ustmp = (unsigned short) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.ustmp);
break;
case TYPE_INT32 : /* long */
temp.ltmp = (long) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.ltmp);
break;
case TYPE_UNS32 : /* unsigned long */
temp.ultmp = (unsigned long) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.ultmp);
break;
case TYPE_FLT64 : /* double */
temp.dtmp = (double) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.dtmp);
break;
case TYPE_BOOLEAN : /* Boolean value */
temp.btmp = (boolean) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.btmp);
break;
case TYPE_ENUM : /* Can be treat as unsigned long */
temp.ultmp = (unsigned long) value;
pl_set_param(handle, pvcam_cmd, (void *)&temp.ultmp);
break;
default:
/* ptrs not supported yet. */
case TYPE_VOID_PTR : /* ptr to void */
case TYPE_VOID_PTR_PTR :/* void ptr to a ptr. */
case TYPE_CHAR_PTR : /* char */
status = false;
break;
}
}
}
return(status);
} /* end SetLongParam_PvCam */
