def setUp(self):
self.cal_file="atiiaftt/test/FT18766.cal"
self.bias_readings=[0.265100,-0.017700,-0.038400,-0.042700,-0.189100,0.137300,-3.242300]
self.input_floats=[-3.286300,0.387500,-3.487700,0.404300,-3.934100,0.547400,-3.210600]
self.translation_floats=[0,0,20,45,0,0]
self.output_floats_n=[-4.285730,-908.400635,-928.162720,-0.679282,-1.102992,-1.988170]
self.output_floats_kn=[-0.004286, -0.908401, -0.928163, -0.679282, -1.102992, -1.98817]
self.not_a_unit=ffi.new("char[]","invalid".encode("ascii"))
self.test_sensor=atiiaftt.FTSensor()
def convertToFt(self,voltages):
"""
Wraps c function 'ConvertToFT()'.
The most recent voltages are also stored in self.voltage_vector
The most recent conversion is also stored in self.ft_vector
@param voltages: values read from an ADC connected to a sensor
@type voltages: list of floats
@raises RuntimeError: exception raised if function is called before loading a calibration dataset.
@return: Force-torque values, also stored in self.ft_vector
@rtype: list of floats, format [F.x,F.y,F.z,T.x,T.y,T.z]
"""
self.voltage_vector=voltages
if self.calibration==ffi.NULL:
self.logger.error("Calibration data not loaded.")
raise RuntimeError("Calibration data not loaded.")
cffi_ft_vector=ffi.new("float[]",[0,0,0,0,0,0])
cffi_voltages=ffi.new("float[]",voltages)
lib.ConvertToFT(self.calibration,cffi_voltages,cffi_ft_vector)
self.ft_vector=list(cffi_ft_vector)
return self.ft_vector
def bias(self,voltages):
"""
Wraps c function 'Bias()'
@param voltages: Averaged set of ADC readings from a sensor
@type voltages: list of floats, also stored in self.bias_vector
@raises RuntimeError: exception raised if function is called before loading a calibration dataset.
"""
self.bias_vector=voltages
if self.calibration==ffi.NULL:
self.logger.error("Calibration data not loaded.")
raise RuntimeError("Calibration data not loaded.")
cffi_bias=ffi.new("float[]",voltages)
self.logger.debug("{}".format(cffi_bias))
lib.Bias(self.calibration,cffi_bias)
def createCalibration(self,CalFilePath,index):
"""
Wraps c function 'createCalibration()'.
@param CalFilePath: Path string of calibration file for the sensor
@type CalFilePath: string
@param index: Index value of the requested calibration data.
@type index: int
@raises IOError: exception raised if 'CalFilePath' fails os.path.exists()
@raises IndexError: exception raised if index value not found in calibration file
"""
if not (os.path.exists(CalFilePath)):
self.logger.error("Can't find calibration file: "+CalFilePath)
raise IOError("Calibration file not found.")
cffi_cal_filepath=ffi.new("char[]",CalFilePath.encode("ascii"))
self.calibration=lib.createCalibration(cffi_cal_filepath,index)
if self.calibration==ffi.NULL:
self.logger.error("Index not found in calibration file.")
raise IndexError("Passed calibration index not found.")
def setToolTransform(self,vector,distunits,angleunits):
"""
Wraps c function 'SetToolTransform()'.
@param vector:
@type vector: list of floats
@param distunits:
@type distunits: atiiaftt.FTUnit.DIST_* class member
@param angleunits:
@type angleunits: atiiaftt.FTUnit.ANGLE_* class member
@raises RuntimeError: exception raised if function is called before loading a calibration dataset.
@raises ValueError: exception raised if unknown unit is passed.
"""
cffi_vector=ffi.new("float[]",vector)
ret_val=lib.SetToolTransform(self.calibration,cffi_vector,distunits,angleunits)
if ret_val == 1:
raise RuntimeError("Calibration data not loaded.")
elif ret_val == 2:
raise ValueError("Invalid distance unit.")
elif ret_val == 3:
raise ValueError("Invalid angle unit.")
def cffi_usage_example():
"""
Usage example for atiiaftt cffi library.
Functionally the same as the Sample/ftconvert.c example included with ATIDAQ zip
"""
cal_file = "tests/FT18766.cal"
cal_file_index = 1
cal_file_path = ffi.new(
"char[]",
os.path.join(os.path.dirname(__file__), cal_file).encode("ascii"))
print(ffi.string(cal_file_path))
calibrationData = lib.createCalibration(cal_file_path, cal_file_index)
print(calibrationData)
# print the working calibration matrix (loaded from file, pre-bias)
print("Calibration Matrix Dimensions [{} Channels,{} Axes]".format(
calibrationData.rt.NumChannels, calibrationData.rt.NumAxes))
for ai in range(calibrationData.rt.NumAxes):
print("{}\t".format(ffi.string(calibrationData.AxisNames[ai])), end="")
for ci in range(calibrationData.rt.NumChannels):
print("{}\t".format(calibrationData.rt.working_matrix[ai][ci]),
end="")
print("")
# same values as sample program 'ftconvert'
bias_readings = ffi.new("float[]", [
0.265100, -0.017700, -0.038400, -0.042700, -0.189100, 0.137300,
-3.242300
])
input_floats = ffi.new("float[]", [
-3.286300, 0.387500, -3.487700, 0.404300, -3.934100, 0.547400,
-3.210600
])
translation_floats = ffi.new("float[]", [0, 0, 20, 45, 0, 0])
output_floats = ffi.new("float[]", [0, 0, 0, 0, 0, 0, 0])
translation_dist_unit = ffi.new("char[]", "mm".encode("ascii"))
translation_angle_unit = ffi.new("char[]", "degrees".encode("ascii"))
force_unit_str = ffi.new("char[]", "N".encode("ascii"))
torque_unit_str = ffi.new("char[]", "N-m".encode("ascii"))
lib.SetForceUnits(calibrationData, force_unit_str)
lib.SetTorqueUnits(calibrationData, torque_unit_str)
print("Running tool transform with translation: [", end="")
for i in range(6):
print(translation_floats[i], end="")
if (i < 5):
print(",", end="")
print("]")
lib.SetToolTransform(calibrationData, translation_floats,
translation_dist_unit, translation_angle_unit)
lib.Bias(calibrationData, bias_readings)
lib.ConvertToFT(calibrationData, input_floats, output_floats)
print("Bias reading:")
for i in range(7):
print(bias_readings[i], end='')
if (i < 6):
print(",", end='')
print("")
print("Measurement:")
for i in range(7):
print(input_floats[i], end='')
if (i < 6):
print(",", end='')
print("")
print("Result:")
for i in range(7):
print(output_floats[i], end='')
if (i < 6):
print(",", end='')
print("")
return 0
class FTUnit:
"""
Convenience class holding accepted units for the atiia functions.
Constants declared from 'ftconfig.c'.
"""
FORCE_LB=ffi.new("char[]","lb".encode("ascii"))
"""lb\\0"""
FORCE_KLB=ffi.new("char[]","klb".encode("ascii"))
"""klb\\0"""
FORCE_N=ffi.new("char[]","N".encode("ascii"))
"""N\\0"""
FORCE_KN=ffi.new("char[]","kN".encode("ascii"))
"""kN\\0"""
FORCE_G=ffi.new("char[]","g".encode("ascii"))
"""g\\0"""
FORCE_KG=ffi.new("char[]","kg".encode("ascii"))
"""kg\\0"""
TORQUE_IN_LB=ffi.new("char[]","in-lb".encode("ascii"))
"""in-lb\\0"""
TORQUE_FT_LB=ffi.new("char[]","ft-lb".encode("ascii"))
"""ft-lb\\0"""
TORQUE_N_M=ffi.new("char[]","N-m".encode("ascii"))
"""N-m\\0"""
TORQUE_N_MM=ffi.new("char[]","N-mm".encode("ascii"))
"""N-mm\\0"""
TORQUE_KG_CM=ffi.new("char[]","kg-cm".encode("ascii"))
"""kg-cm\\0"""
DIST_M=ffi.new("char[]","m".encode("ascii"))
"""m\\0"""
DIST_CM=ffi.new("char[]","cm".encode("ascii"))
"""cm\\0"""
DIST_MM=ffi.new("char[]","mm".encode("ascii"))
"""mm\\0"""
DIST_FT=ffi.new("char[]","ft".encode("ascii"))
"""ft\\0"""
ANGLE_DEG=ffi.new("char[]","deg".encode("ascii"))
"""deg\\0"""
ANGLE_RAD=ffi.new("char[]","rad".encode("ascii"))
"""rad\\0"""