cimport numpy as _numpy
import numpy as _numpy
-cimport _comedi_h
-cimport _comedilib_h
-import _error
-import constant as _constant
-import utility as _utility
+from pycomedi cimport _comedi_h
+from pycomedi cimport _comedilib_h
+from . import _error
+from . import constant as _constant
+from . import utility as _utility
-cdef void _python_to_charp(char **charp, object obj, object encoding):
+cdef void _python_to_charp(
+ char **charp, object obj, object encoding) except *:
"""Convert a Python string into a `char *`.
Cython automatically converts string or byte array to a `char *`
charp[0] = ret
cdef void _setup_comedi_polynomial_t(
- _comedilib_h.comedi_polynomial_t *p, coefficients, expansion_origin):
+ _comedilib_h.comedi_polynomial_t *p, coefficients, expansion_origin
+ ) except *:
"""Setup the `comedi_polynomial_t` at `p`
* `coefficients` is an iterable containing polynomial coefficients
1.0
>>> c.get_to_physical_coefficients()
array([ 1., 2., 3.])
+
+ For some soft-calibrated boards, there is no from_physical
+ conversion polynomial.
+
+ >>> c = CalibratedConverter(
+ ... from_physical_error=Exception('no conversion polynomial'))
+ >>> c.from_physical(1.0)
+ Traceback (most recent call last):
+ ...
+ Exception: no conversion polynomial
+
+ However, even with the error, you can extract dummy coefficients.
+
+ >>> c.get_from_physical_expansion_origin()
+ 0.0
+ >>> c.get_from_physical_coefficients()
+ array([ 0.])
"""
+ def __cinit__(self):
+ self._from_physical_error = None
+
def __init__(self, to_physical_coefficients=None,
to_physical_expansion_origin=0,
from_physical_coefficients=None,
- from_physical_expansion_origin=0):
+ from_physical_expansion_origin=0,
+ from_physical_error=None):
if to_physical_coefficients:
_setup_comedi_polynomial_t(
&self._to_physical, to_physical_coefficients,
_setup_comedi_polynomial_t(
&self._from_physical, from_physical_coefficients,
from_physical_expansion_origin)
+ self._from_physical_error = from_physical_error
cdef _str_poly(self, _comedilib_h.comedi_polynomial_t polynomial):
return '{coefficients:%s origin:%s}' % (
_constant.CONVERSION_DIRECTION.to_physical)
cpdef from_physical(self, data):
+ if self._from_physical_error is not None:
+ raise self._from_physical_error
return _convert(&self._from_physical, data,
_constant.CONVERSION_DIRECTION.from_physical)
"""
def __cinit__(self):
self.setting = NULL
+ self.subdevice = None
def __init__(self, subdevice):
super(CalibrationSetting, self).__init__()
self.setting.arefs[i] = x
for i in range(length, _comedilib_h.CS_MAX_AREFS_LENGTH):
self.setting.arefs[i] = 0
+ self.setting.num_arefs = length
arefs = property(fget=_arefs_get, fset=_arefs_set)
def _caldacs_get(self):
c.caldac = &self.setting.caldacs[i]
ret.append(c)
return ret
+ cdef _caldacs_set_single(self, index, Caldac caldac):
+ self.setting.caldacs[index] = caldac.caldac[0]
def _caldacs_set(self, value):
assert self.setting is not NULL, 'load setting first'
if self.setting.caldacs is not NULL:
for i,x in enumerate(value):
if i >= length:
raise ValueError((i, length))
- self.setting.caldacs[i] = x
+ self._caldacs_set_single(i, x)
caldacs = property(fget=_caldacs_get, fset=_caldacs_set)
def _soft_calibration_get(self):
"""
def __cinit__(self):
self.calibration = NULL
+ self.device = None
def __init__(self, device):
super(Calibration, self).__init__()
return None
ret = []
for i in range(self.calibration.num_settings):
- s = CalibrationSetting(
+ s = <CalibrationSetting> CalibrationSetting(
subdevice=self.device.subdevice(
index=self.calibration.settings[i].subdevice))
s.setting = &self.calibration.settings[i]