ComediAnalogIOSoftCal::~ComediAnalogIOSoftCal()
{
Logger(Debug, "ComediAnalogIOSoftCal::~ComediAnalogIOSoftCal()\n");
comedi_cleanup_calibration(m_calibration);
delete m_calibrationFile;
closeDevice();
}
void writeCalibrationSet(const CalibrationSet &calibration, const std::string &driverName,
const std::string &boardName, const std::string &filePath)
{
comedi_calibration_t *c_cal = static_cast<comedi_calibration_t *>(malloc(sizeof(comedi_calibration_t)));
if(c_cal == 0) throw std::runtime_error("writeCalibrationSet: malloc failed\n");
memset(c_cal, 0, sizeof(comedi_calibration_t));
c_cal->driver_name = static_cast<char*>(malloc(driverName.size() + 1));
strcpy(c_cal->driver_name, driverName.c_str());
c_cal->board_name = static_cast<char*>(malloc(boardName.size() + 1));
strcpy(c_cal->board_name, boardName.c_str());
CalibrationSet::const_iterator it;
for(it = calibration.begin(); it != calibration.end(); ++it)
{
const SubdeviceCalibration &subdeviceCalibration = it->second;
std::map<std::pair<unsigned, unsigned>, Polynomial>::const_iterator jt;
for(jt = it->second.polynomials().begin(); jt != it->second.polynomials().end(); ++jt)
{
comedi_calibration_setting_t *setting = sc_alloc_calibration_setting(c_cal);
setting->subdevice = it->first;
unsigned channel = jt->first.first;
if(channel != SubdeviceCalibration::allChannels)
{
sc_push_channel(setting, channel);
}
unsigned range = jt->first.second;
if(range != SubdeviceCalibration::allRanges)
{
sc_push_range(setting, range);
}
const Polynomial &polynomial = jt->second;
comedi_polynomial_t *comediPolynomial = static_cast<comedi_polynomial_t*>(malloc(sizeof(comedi_polynomial_t)));
assert(comediPolynomial);
comediPolynomial->expansion_origin = polynomial.expansionOrigin;
comediPolynomial->order = polynomial.order();
unsigned i;
for(i = 0; i < polynomial.coefficients.size(); ++i)
{
assert(i < COMEDI_MAX_NUM_POLYNOMIAL_COEFFICIENTS);
comediPolynomial->coefficients[i] = polynomial.coefficients.at(i);
}
if(subdeviceCalibration.toPhys())
{
setting->soft_calibration.to_phys = comediPolynomial;
}else
{
setting->soft_calibration.from_phys = comediPolynomial;
}
}
}
int retval = write_calibration_file(filePath.c_str(), c_cal);
comedi_cleanup_calibration(c_cal);
if(retval)
{
std::ostringstream message;
message << __FUNCTION__ << ": write_calibration_file() failed.";
throw std::runtime_error(message.str());
}
}
/**
* facq_comedi_misc_get_polynomial:
* @dev: A comedi_t device.
* @subindex: The subdevice index.
* @chanlist: A #FacqChanlist object.
* @err: A #GError.
*
* The functions makes some magic to obtain a per channel,
* comedi_polynomial_t array. Each polynomial can be used
* to convert from comedi data to physical samples.
* See <function>comedi_to_physical()</function> for more
* info.
*
* Returns: An array of comedi_polynomial_t members. Free it
* when it's no longer needed. %NULL in case of error.
* The array length equals the number of I/O Channels in the
* chanlist.
*/
comedi_polynomial_t *facq_comedi_misc_get_polynomial(comedi_t *dev,guint subindex,const FacqChanlist *chanlist,GError **err)
{
guint subd_flags = 0;
guint i = 0, chan = 0, range = 0, aref = 0, iochans_n = 0;
guint chanspec = 0;
gchar *cal_filename = NULL;
comedi_calibration_t *cc = NULL;
GError *local_err = NULL;
comedi_polynomial_t *p = NULL;
g_return_val_if_fail(FACQ_IS_CHANLIST(chanlist),NULL);
iochans_n = facq_chanlist_get_io_chans_n(chanlist);
if(iochans_n < 1){
g_set_error_literal(&local_err,FACQ_COMEDI_MISC_ERROR,
FACQ_COMEDI_MISC_ERROR_FAILED,
"Chanlist is empty");
goto error;
}
cal_filename = comedi_get_default_calibration_path(dev);
if(!cal_filename){
g_set_error_literal(&local_err,FACQ_COMEDI_MISC_ERROR,
FACQ_COMEDI_MISC_ERROR_FAILED,
comedi_strerror(comedi_errno()));
goto error;
}
cc = comedi_parse_calibration_file(cal_filename);
if(!cc){
g_set_error_literal(&local_err,FACQ_COMEDI_MISC_ERROR,
FACQ_COMEDI_MISC_ERROR_FAILED,
comedi_strerror(comedi_errno()));
goto error;
}
g_free(cal_filename);
subd_flags = comedi_get_subdevice_flags(dev,subindex);
if(subd_flags < 0){
g_set_error_literal(&local_err,FACQ_COMEDI_MISC_ERROR,
FACQ_COMEDI_MISC_ERROR_FAILED,
comedi_strerror(comedi_errno()));
goto error;
}
for(i = 0;i < iochans_n;i++){
chanspec = facq_chanlist_get_io_chanspec(chanlist,i);
facq_chanlist_chanspec_to_src_values(chanspec,
&chan,
&range,
&aref,
NULL);
if( comedi_apply_parsed_calibration(dev,subindex,
chan,
range,
aref,
cc) < 0){
g_set_error_literal(&local_err,FACQ_COMEDI_MISC_ERROR,
FACQ_COMEDI_MISC_ERROR_FAILED,
comedi_strerror(comedi_errno()));
goto error;
}
}
if(subd_flags & SDF_SOFT_CALIBRATED){
p = facq_comedi_misc_get_polynomial_soft(dev,
subindex,
chanlist,
cc,
&local_err);
comedi_cleanup_calibration(cc);
}
else {
comedi_cleanup_calibration(cc);
p = facq_comedi_misc_get_polynomial_hard(dev,
subindex,
chanlist,
&local_err);
}
if(!p)
goto error;
return p;
error:
if(cal_filename)
g_free(cal_filename);
if(cc)
comedi_cleanup_calibration(cc);
if(local_err)
g_propagate_error(err,local_err);
return NULL;
}
int DaqDevice::DAQcalibration(int subdev,int channel,int range_idx)
{
int retval;
int flags;
comedi_calibration_t* parsed_calibration;
comedi_polynomial_t* converter;
comedi_conversion_direction options;
if (COMEDI_AN_IN_SUB == subdev)
{
converter = &_converter_an_input[channel];
options = COMEDI_TO_PHYSICAL;
}
else if (COMEDI_AN_OUT_SUB == subdev)
{
converter = &_converter_an_output[channel];
options = COMEDI_FROM_PHYSICAL;
}
else
return COMEDI_ERROR;
flags = comedi_get_subdevice_flags(_dev, subdev);
if(flags < 0)
{
return COMEDI_ERROR;
}
if(flags & SDF_SOFT_CALIBRATED) /* board uses software calibration */
{
char *calibration_file_path = comedi_get_default_calibration_path(_dev);
/* parse a calibration file which was produced by the
comedi_soft_calibrate program */
parsed_calibration = comedi_parse_calibration_file(calibration_file_path);
if(parsed_calibration == NULL)
{
return COMEDI_ERROR;
}
/* get the comedi_polynomial_t for the subdevice/channel/range
we are interested in */
retval = comedi_get_softcal_converter(subdev, channel, range_idx,
options, parsed_calibration, converter);
comedi_cleanup_calibration(parsed_calibration);
if(retval < 0)
{
return COMEDI_ERROR;
}
}else /* board uses hardware calibration */
{
retval = comedi_get_hardcal_converter(_dev, subdev, channel, range_idx,
options, converter);
if(retval < 0)
{
return COMEDI_ERROR;
}
}
return COMEDI_OK;
}
