diff --git a/config/instruction_images/generic/Img-01.png b/config/instruction_images/generic/Img-01.png new file mode 100644 index 0000000..668f01b Binary files /dev/null and b/config/instruction_images/generic/Img-01.png differ diff --git a/config/instruction_images/generic/Img-02.png b/config/instruction_images/generic/Img-02.png new file mode 100644 index 0000000..51b98f8 Binary files /dev/null and b/config/instruction_images/generic/Img-02.png differ diff --git a/config/instruction_images/generic/Img-03.png b/config/instruction_images/generic/Img-03.png new file mode 100644 index 0000000..de74f5a Binary files /dev/null and b/config/instruction_images/generic/Img-03.png differ diff --git a/config/instruction_images/generic/Img-04.png b/config/instruction_images/generic/Img-04.png new file mode 100644 index 0000000..a71cca1 Binary files /dev/null and b/config/instruction_images/generic/Img-04.png differ diff --git a/config/instruction_images/generic/Img-05.png b/config/instruction_images/generic/Img-05.png new file mode 100644 index 0000000..6d1999d Binary files /dev/null and b/config/instruction_images/generic/Img-05.png differ diff --git a/config/machine_settings/defaults.ini b/config/machine_settings/defaults.ini index a12b7d0..59501ec 100644 --- a/config/machine_settings/defaults.ini +++ b/config/machine_settings/defaults.ini @@ -13,6 +13,7 @@ galaxy_camera: absent ; uvc_camera: present ; vision_saver: present ; vision: present +digital_io: absent [galaxy_camera] horizontal_resolution: 2448 @@ -69,7 +70,8 @@ status_pin: 0 [multicomp] ; port: ? baudrate: 115200 -cable_resistance: 0.8 +cable_resistance: 0.75 +4wire: disabled [neo_pixels] ; port: ? @@ -104,6 +106,8 @@ r nominale: 1000000000 tolleranza_resistenza_pos: 10 tolleranza_resistenza_neg: 5 prova_tenuta_abilitata: x +config_elettrovalvole: 0 +warning_img: tempo_pre_riempimento: 0 pressione_pre_riempimento: 1000 tempo_riempimento: 10 diff --git a/config/machine_settings/hostnames.ini b/config/machine_settings/hostnames.ini index c5a2c96..4963953 100644 --- a/config/machine_settings/hostnames.ini +++ b/config/machine_settings/hostnames.ini @@ -6,4 +6,5 @@ ST-TEN-1: st-ten-1 ST-TEN-2: st-ten-2 stten3: st-ten-3 this: this -LAPTOP-ST64MEV3: laptop \ No newline at end of file +LAPTOP-ST64MEV3: laptop +germano-neo: st-ten-2 \ No newline at end of file diff --git a/config/machine_settings/st-ten-2.ini b/config/machine_settings/st-ten-2.ini index df7db02..8639302 100644 --- a/config/machine_settings/st-ten-2.ini +++ b/config/machine_settings/st-ten-2.ini @@ -13,6 +13,7 @@ port: COM6 [multicomp] port: COM10 +4wire: enabled [recipe] recipe_name_field: cod finito cliente diff --git a/config/machine_settings/st-ten-4.ini b/config/machine_settings/st-ten-4.ini new file mode 100644 index 0000000..ee2b749 --- /dev/null +++ b/config/machine_settings/st-ten-4.ini @@ -0,0 +1,31 @@ +[machine] +description = ST-TEN-4 - TERMOFORMATURA MAPPANO + +[hardware_config] +archive_synchronizer: present +; galaxy_camera: present +uvc_camera: present +label_printer: present +neo_pixels: present +remote_api: absent +tecna_t3: present +vision_saver: absent +vision: absent +screwdriver: present + +[tecna_t3] +port: COM4 +model: t3l + +[neo_pixels] +port: COM5 + +[recipe] +recipe_name_field: codice_ricetta +part_number_field: codice_prodotto +label_template_field: modello_etichetta +description_field: descrizione + +[label_printer] +platform: windows +printer: zd420 diff --git a/config/machine_settings/st-ten-5.ini b/config/machine_settings/st-ten-5.ini new file mode 100644 index 0000000..4642967 --- /dev/null +++ b/config/machine_settings/st-ten-5.ini @@ -0,0 +1,35 @@ +[machine] +description = ST-TEN-5 IVECO DAILY ELETTRICO + +[hardware_config] +archive_synchronizer: present +; galaxy_camera: present +uvc_camera: present +label_printer: present +neo_pixels: present +remote_api: absent +tecna_t3: present +vision_saver: absent +vision: absent +screwdriver: present +digital_io: present + +[tecna_t3] +port: COM4 +model: t3l + +[neo_pixels] +port: COM5 + +[recipe] +recipe_name_field: codice_ricetta +part_number_field: codice_prodotto +label_template_field: modello_etichetta +description_field: descrizione + +[label_printer] +platform: windows +printer: zd420 + +[digital_io] +id: USB-5862,BID#0 \ No newline at end of file diff --git a/config/machine_settings/st-ten-6.ini b/config/machine_settings/st-ten-6.ini new file mode 100644 index 0000000..779eaa4 --- /dev/null +++ b/config/machine_settings/st-ten-6.ini @@ -0,0 +1,35 @@ +[machine] +description = ST-TEN-6 DOPPIA PROVA PRESSIONE 6/20 BAR + +[hardware_config] +archive_synchronizer: present +; galaxy_camera: present +uvc_camera: present +label_printer: present +neo_pixels: present +remote_api: absent +tecna_t3: present +vision_saver: absent +vision: absent +screwdriver: present +digital_io: present + +[tecna_t3] +port: COM4 +model: t3l + +[neo_pixels] +port: COM5 + +[recipe] +recipe_name_field: codice_ricetta +part_number_field: codice_prodotto +label_template_field: modello_etichetta +description_field: descrizione + +[label_printer] +platform: windows +printer: zd420 + +[digital_io] +id: USB-5860,BID#0 \ No newline at end of file diff --git a/config/machine_settings/this.ini b/config/machine_settings/this.ini deleted file mode 100644 index d930d56..0000000 --- a/config/machine_settings/this.ini +++ /dev/null @@ -1,33 +0,0 @@ -[machine] -description = ~~~~~~~~~~ THIS ~~~~~~~~~~ - -[hardware_config] -archive_synchronizer: present -galaxy_camera: present -label_printer: present -multicomp: present -neo_pixels: present -remote_api: present -screwdriver: present -tecna_t3: present -uvc_camera: present -vision_saver: present -vision: present - -[tecna_t3] -model: t3l -port: /dev/ttyUSB0 -saver: present -saver_label_template: 6 -saver_print_on_fail: yes -saver_label_count: 1 - -[multicomp] -port: /dev/ttyACM0 - -[neo_pixels] -port: /dev/ttyACM1 - -[archive_synchronizer] -poll_time: 6 -hold_time: 1 diff --git a/designer.sh b/designer.sh index ffc2be7..4e7c252 100755 --- a/designer.sh +++ b/designer.sh @@ -1,6 +1,7 @@ #!/bin/bash -x cd "$(dirname "$0")" -#source "./venv/bin/activate" || source "./venv/Scripts/activate" || : +source "./venv/bin/activate" || source "./venv/Scripts/activate" || : #python3 -m pip install --upgrade qt5-tools -#"$(python3 -c "import sys; print(sys.path[-1])")/qt5_applications/Qt/bin/designer" $* -$(pwd)/venv/lib/python3.9/site-packages/qt5_applications/Qt/bin/designer $* +"$(python3 -c "import sys; print(sys.path[-1])")/qt5_applications/Qt/bin/designer" $* +#$(pwd)/venv/lib/python3.9/site-packages/qt5_applications/Qt/bin/designer $* +#$(pwd)/venv/lib/python3.8/site-packages/qt5_applications/Qt/bin/designer $* diff --git a/init.sh b/init.sh index 1378d63..fc9221d 100755 --- a/init.sh +++ b/init.sh @@ -4,6 +4,7 @@ here="$(realpath "$(dirname "$0")")" cd "$here" echo "---------- initialize venv ----------" +sudo apt-get install python3-venv lsof "./venv/bin/python" | awk 'NR > 1 {print $2}' | xargs kill || : lsof "./venv/Scripts/activate" | awk 'NR > 1 {print $2}' | xargs kill || : python="python" diff --git a/src/components/Automation/BDaq/AiChannel.py b/src/components/Automation/BDaq/AiChannel.py new file mode 100644 index 0000000..b3ba0f5 --- /dev/null +++ b/src/components/Automation/BDaq/AiChannel.py @@ -0,0 +1,9 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.AnalogInputChannel import AnalogInputChannel + + +class AiChannel(AnalogInputChannel): + def __init__(self, nativeChannelObj): + super(AiChannel, self).__init__(nativeChannelObj) diff --git a/src/components/Automation/BDaq/AiCtrlBase.py b/src/components/Automation/BDaq/AiCtrlBase.py new file mode 100644 index 0000000..8a41415 --- /dev/null +++ b/src/components/Automation/BDaq/AiCtrlBase.py @@ -0,0 +1,34 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.BDaqApi import TAiCtrlBase, TArray +from Automation.BDaq.AiFeatures import AiFeatures +from Automation.BDaq.AiChannel import AiChannel + + +class AiCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(AiCtrlBase, self).__init__(scenario, devInfo) + self._ai_features = None + self._ai_channels = [] + + @property + def features(self): + if self._ai_features is None: + self._ai_features = AiFeatures(TAiCtrlBase.getFeatures(self._obj)) + return self._ai_features + + @property + def channels(self): + if not self._ai_channels: + count = self.features.channelCountMax + nativeArray = TAiCtrlBase.getChannels(self._obj) + for i in range(count): + aiChannObj = AiChannel(TArray.getItem(nativeArray, i)) + self._ai_channels.append(aiChannObj) + return self._ai_channels + + @property + def channelCount(self): + return TAiCtrlBase.getChannelCount(self._obj) diff --git a/src/components/Automation/BDaq/AiFeatures.py b/src/components/Automation/BDaq/AiFeatures.py new file mode 100644 index 0000000..11cbb57 --- /dev/null +++ b/src/components/Automation/BDaq/AiFeatures.py @@ -0,0 +1,215 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAiFeatures, TArray +from Automation.BDaq import Utils +from Automation.BDaq import MathInterval + + +class AiFeatures(object): + def __init__(self, nativeFeature): + self._ai_feature = nativeFeature + + # ADC features + @property + def resolution(self): + return TAiFeatures.getResolution(self._ai_feature) + + @property + def dataSize(self): + return TAiFeatures.getDataSize(self._ai_feature) + + @property + def dataMask(self): + return TAiFeatures.getDataMask(self._ai_feature) + + @property + def timestampResolution(self): + return TAiFeatures.getTimestampResolution(self._ai_feature) + + # channel features + @property + def channelCountMax(self): + return TAiFeatures.getChannelCountMax(self._ai_feature) + + @property + def channelType(self): + value = TAiFeatures.getChannelType(self._ai_feature) + return Utils.toAiChannelType(value) + + @property + def overallValueRange(self): + ret = TAiFeatures.getOverallValueRange(self._ai_feature) + return True if ret else False + + @property + def valueRanges(self): + nativeArr = TAiFeatures.getValueRanges(self._ai_feature) + return TArray.ToValueRange(nativeArr, True) + + @property + def burnoutReturnTypes(self): + nativeArr = TAiFeatures.getBurnoutReturnTypes(self._ai_feature) + return TArray.ToBurnoutRetType(nativeArr, True) + + @property + def connectionTypes(self): + nativeArr = TAiFeatures.getConnectionTypes(self._ai_feature) + return TArray.ToAiSignalType(nativeArr, True) + + @property + def overallConnection(self): + value = TAiFeatures.getOverallConnection(self._ai_feature) + return True if value else False + + @property + def couplingTypes(self): + nativeArr = TAiFeatures.getCouplingTypes(self._ai_feature) + return TArray.ToCouplingType(nativeArr, True) + + @property + def iepeTypes(self): + nativeArr = TAiFeatures.getIepeTypes(self._ai_feature) + return TArray.ToIepeType(nativeArr, True) + + @property + def impedanceTypes(self): + nativeArr = TAiFeatures.getImpedanceTypes(self._ai_feature) + return TArray.ToImpedanceType(nativeArr, True) + + @property + def filterTypes(self): + nativeArr = TAiFeatures.getFilterTypes(self._ai_feature) + return TArray.ToFilterType(nativeArr, True) + + @property + def filterCutoffFreqRange(self): + x = MathInterval() + TAiFeatures.getFilterCutoffFreqRange(self._ai_feature, ctypes.pointer(x)) + return x + + @property + def filterCutoffFreq1Range(self): + x = MathInterval() + TAiFeatures.getFilterCutoffFreq1Range(self._ai_feature, ctypes.pointer(x)) + return x + + # cjc featues + @property + def thermoSupported(self): + value = TAiFeatures.getThermoSupported(self._ai_feature) + return True if value else False + + @property + def cjcChannels(self): + nativeArr = TAiFeatures.getCjcChannels(self._ai_feature) + return TArray.ToInt32(nativeArr, True) + + # buffered ai -> basic features + @property + def bufferedAiSupported(self): + value = TAiFeatures.getBufferedAiSupported(self._ai_feature) + return True if value else False + + @property + def samplingMethod(self): + ret = TAiFeatures.getSamplingMethod(self._ai_feature) + return Utils.toSamplingMethod(ret) + + @property + def channelStartBase(self): + return TAiFeatures.getChannelStartBase(self._ai_feature) + + @property + def channelCountBase(self): + return TAiFeatures.getChannelCountBase(self._ai_feature) + + # buffered ai -> conversion clock features + @property + def convertClockSources(self): + nativeArr = TAiFeatures.getConvertClockSources(self._ai_feature) + return TArray.ToSignalDrop(nativeArr, True) + + @property + def convertClockRange(self): + x = MathInterval() + TAiFeatures.getConvertClockRange(self._ai_feature, ctypes.pointer(x)) + return x + + # buffered ai -> burst scan + @property + def burnstScanSupported(self): + value = TAiFeatures.getBurstScanSupported(self._ai_feature) + return True if value else False + + @property + def scanClockSources(self): + nativeArr = TAiFeatures.getScanClockSources(self._ai_feature) + return TArray.ToSignalDrop(nativeArr, True) + + @property + def scanClockRange(self): + x = MathInterval() + TAiFeatures.getScanClockRange(self._ai_feature, ctypes.pointer(x)) + return x + + @property + def scanCountMax(self): + return TAiFeatures.getScanCountMax(self._ai_feature) + + # buffered ai->trigger features + @property + def triggerCount(self): + return TAiFeatures.getTriggerCount(self._ai_feature) + + @property + def retriggerable(self): + value = TAiFeatures.getRetriggerable(self._ai_feature) + return True if value else False + + @property + def triggerFilterTypes(self): + nativeArr = TAiFeatures.getTriggerFilterTypes(self._ai_feature, 0) + return TArray.ToFilterType(nativeArr, True) + + @property + def triggerFilterCutoffFreq(self): + x = MathInterval() + TAiFeatures.getTriggerFilterCutoffFreqRange(self._ai_feature, 0, ctypes.byref(x)) + return x + + # trigger 0 + @property + def triggerSupported(self): + return self.triggerCount != 0 + + # trigger 1 + @property + def trigger1Supported(self): + return self.triggerCount > 1 + + # buffered ai->trigger0/1/../x features + def getTriggerActions(self, trigger = 0): + nativeArray = TAiFeatures.getTriggerActions(self._ai_feature, trigger) + return TArray.ToTriggerAction(nativeArray, True) + + def getTriggerDelayRange(self, trigger = 0): + x = MathInterval() + TAiFeatures.getTriggerDelayRange(self._ai_feature, trigger, ctypes.byref(x)) + return x + + def getTriggerSources(self, trigger = 0): + nativeArray = TAiFeatures.getTriggerSources(self._ai_feature, trigger) + return TArray.ToSignalDrop(nativeArray, True) + + def getTriggerSourceVrg(self, trigger = 0): + native = TAiFeatures.getTriggerSourceVrg(self._ai_feature, trigger) + return Utils.toValueRange(native) + + def getTriggerHysteresisIndexMax(self, trigger = 0): + return TAiFeatures.getTriggerHysteresisIndexMax(self._ai_feature, trigger) + + def getTriggerHysteresisIndexStep(self, trigger = 0): + return TAiFeatures.getTriggerHysteresisIndexStep(self._ai_feature, trigger) diff --git a/src/components/Automation/BDaq/AnalogInputChannel.py b/src/components/Automation/BDaq/AnalogInputChannel.py new file mode 100644 index 0000000..060ae93 --- /dev/null +++ b/src/components/Automation/BDaq/AnalogInputChannel.py @@ -0,0 +1,208 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAiChannel, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import * + + +class AnalogInputChannel(object): + def __init__(self, ai_channel_obj): + self._ai_channel_obj = ai_channel_obj + + @property + def channel(self): + return TAiChannel.getChannel(self._ai_channel_obj) + + @property + def logicalNumber(self): + return TAiChannel.getLogicalNumber(self._ai_channel_obj) + + @property + def valueRange(self): + value = TAiChannel.getValueRange(self._ai_channel_obj) + return Utils.toValueRange(value) + + @valueRange.setter + def valueRange(self, value): + if not isinstance(value, ValueRange): + raise TypeError('a ValueRange is required') + ret = ErrorCode.lookup(TAiChannel.setValueRange(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set valueRange is failed, the error code is 0x%X' % (ret.value)) + + @property + def signalType(self): + value = TAiChannel.getSignalType(self._ai_channel_obj) + return Utils.toAiSignalType(value) + + @signalType.setter + def signalType(self, value): + if not isinstance(value, AiSignalType): + raise TypeError('a AiSignalType is required') + ret = ErrorCode.lookup(TAiChannel.setSignalType(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set signalType is failed, the error code is 0x%X' % (ret.value)) + + @property + def burnoutRetType(self): + value = TAiChannel.getBurnoutRetType(self._ai_channel_obj) + return Utils.toBurnoutRetType(value) + + @burnoutRetType.setter + def burnoutRetType(self, value): + if not isinstance(value, BurnoutRetType): + raise TypeError('a BurnoutRetType is required') + ret = ErrorCode.lookup(TAiChannel.setBurnoutRetType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set burnoutRetType is failed, the error code is 0x%X' % (ret.value)) + + @property + def burnoutRetValue(self): + value = TAiChannel.getBurnoutRetValue(self._ai_channel_obj) + return value + + @burnoutRetValue.setter + def burnoutRetValue(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAiChannel.setBurnoutRetValue(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set burnoutRetValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def burnShortRetValue(self): + return TAiChannel.getBurnShortRetValue(self._ai_channel_obj) + + @burnShortRetValue.setter + def burnShortRetValue(self, value): + if not isinstance(value, (float, int)): + raise TypeError("a float is required") + ret = ErrorCode.lookup(TAiChannel.setBurnShortRetValue(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set burnShortRetValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterType(self): + value = TAiChannel.getFilterType(self._ai_channel_obj) + return Utils.toFilterType(value) + + @filterType.setter + def filterType(self, value): + if not isinstance(value, FilterType): + raise TypeError('a FilterType is requires') + ret = ErrorCode.lookup(TAiChannel.setFilterType(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set filterType is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterCutoffFreq(self): + value = TAiChannel.getFilterCutoffFreq(self._ai_channel_obj) + return value + + @filterCutoffFreq.setter + def filterCutoffFreq(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAiChannel.setFilterCutoffFreq(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set filterCutoffFreq is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterCutoffFreq1(self): + value = TAiChannel.getFilterCutoffFreq1(self._ai_channel_obj) + return value + + @filterCutoffFreq1.setter + def filterCutoffFreq1(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAiChannel.setFilterCutoffFreq1(self._ai_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set filterCutoffFreq1 is failed, the error code is 0x%X' % (ret.value)) + + @property + def couplingType(self): + value = TAiChannel.getCouplingType(self._ai_channel_obj) + return Utils.toCouplingType(value) + + @couplingType.setter + def couplingType(self, value): + if not isinstance(value, CouplingType): + raise TypeError('a CouplingType is required') + ret = ErrorCode.lookup(TAiChannel.setCouplingType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set couplingType is failed, the error code is 0x%X' % (ret.value)) + + @property + def iepeType(self): + value = TAiChannel.getIepeType(self._ai_channel_obj) + return Utils.toIepeType(value) + + @iepeType.setter + def iepeType(self, value): + if not isinstance(value, IepeType): + raise TypeError('a IepeType is required') + ret = ErrorCode.lookup(TAiChannel.setIepeType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set iepeType is failed, the error code is 0x%X' % (ret.value)) + + @property + def impedanceType(self): + value = TAiChannel.getImpedanceType(self._ai_channel_obj) + return Utils.toImpedanceType(value) + + @impedanceType.setter + def impedanceType(self, value): + if not isinstance(value, ImpedanceType): + raise TypeError('a ImpedanceType is required') + ret = ErrorCode.lookup(TAiChannel.setImpedanceType(self._ai_channel_obj, int(value))) + if BioFailed(ret): + raise ValueError('set impedanceType is failed, the error code is 0x%X' % (ret.value)) + + @property + def sensorDescription(self): + desc = ctypes.create_unicode_buffer(1024) + pSize = (ctypes.c_int * 1)(1024) + err = TAiChannel.getSensorDescription(self._ai_channel_obj, pSize, desc) + if err == int(ErrorCode.ErrorBufferTooSmall.value): + desc = ctypes.create_unicode_buffer(pSize[0]) + err = TAiChannel.getSensorDescription(self._ai_channel_obj, pSize, desc) + + return ErrorCode.lookup(err), desc.value.encode() + + @sensorDescription.setter + def sensorDescription(self, value): + ret = ErrorCode.lookup(TAiChannel.setSensorDescription(self._ai_channel_obj, len(value), value)) + if BioFailed(ret): + raise ValueError('set sensorDescription is failed, the error code is 0x%X' % (ret.value)) + + @property + def scaleTable(self): + pSize = (c_int32 * 1)(32) + buffer = (MapFuncPiece * 32)() + ret = ErrorCode.lookup(TAiChannel.getScaleTable(self._ai_channel_obj, pSize, buffer)) + if ret == ErrorCode.ErrorBufferTooSmall: + buffer = (MapFuncPiece * pSize[0])() + ret = ErrorCode.lookup(TAiChannel.getScaleTable(self._ai_channel_obj, pSize, buffer)) + + if BioFailed(ret): + raise ValueError('get scaletable is failed, the error code is 0x%X' % (ret.value)) + return None + else: + data = [] + for i in range(pSize[0]): + data.append(buffer[i]) + return data + + @scaleTable.setter + def scaleTable(self, table): + size = len(table) + dataArra = (MapFuncPiece * size)() + for i in range(size): + dataArra[i] = table[i] + ret = ErrorCode.lookup(TAiChannel.setScaleTable(self._ai_channel_obj, size, dataArra)) + if BioFailed(ret): + raise ValueError('set scaleTable is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/AnalogOutputChannel.py b/src/components/Automation/BDaq/AnalogOutputChannel.py new file mode 100644 index 0000000..37d3c47 --- /dev/null +++ b/src/components/Automation/BDaq/AnalogOutputChannel.py @@ -0,0 +1,82 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAoChannel, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import * + + +class AnalogOutputChannel(object): + def __init__(self, ao_channel_obj): + self._ao_channel_obj = ao_channel_obj + + @property + def channel(self): + return TAoChannel.getChannel(self._ao_channel_obj) + + @property + def valueRange(self): + return Utils.toValueRange(TAoChannel.getValueRange(self._ao_channel_obj)) + + @valueRange.setter + def valueRange(self, value): + if not isinstance(value, ValueRange): + raise TypeError('a ValueRange is required') + ret = ErrorCode.lookup(TAoChannel.setValueRange(self._ao_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set valueRange is failed, the error code is 0x%X' % (ret.value)) + + @property + def extRefBipolar(self): + return TAoChannel.getExtRefBipolar(self._ao_channel_obj) + + @extRefBipolar.setter + def extRefBipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoChannel.setExtRefBipolar(self._ao_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set extRefBipolar is failed, the error code is 0x%X' % (ret.value)) + + @property + def extRefUnipolar(self): + return TAoChannel.getExtRefUnipolar(self._ao_channel_obj) + + @extRefUnipolar.setter + def extRefUnipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoChannel.setExtRefUnipolar(self._ao_channel_obj, value)) + if BioFailed(ret): + raise ValueError('set extRefUnipolar is failed, the error code is 0x%X' % (ret.value)) + + + @property + def scaleTable(self): + pSize = (ctypes.c_int * 1)(32) + buffer = (MapFuncPiece * 32)() + ret = ErrorCode.lookup(TAoChannel.getScaleTable(self._ao_channel_obj, pSize, buffer)) + if ret == ErrorCode.ErrorBufferTooSmall: + buffer = (MapFuncPiece * pSize[0])() + ret = ErrorCode.lookup(TAoChannel.getScaleTable(self._ao_channel_obj, pSize, buffer)) + + if BioFailed(ret): + raise ValueError('get scaletable is failed, the error code is 0x%X' % (ret.value)) + return None + else: + data = [] + for i in range(pSize[0]): + data.append(buffer[i]) + return data + + @scaleTable.setter + def scaleTable(self, table): + size = len(table) + dataArra = (MapFuncPiece * size)() + for i in range(size): + dataArra[i] = table[i] + ret = ErrorCode.lookup(TAoChannel.setScaleTable(self._ao_channel_obj, size, dataArra)) + if BioFailed(ret): + raise ValueError('set scaletable is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/AoChannel.py b/src/components/Automation/BDaq/AoChannel.py new file mode 100644 index 0000000..64dfaf2 --- /dev/null +++ b/src/components/Automation/BDaq/AoChannel.py @@ -0,0 +1,10 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.AnalogOutputChannel import AnalogOutputChannel + + +class AoChannel(AnalogOutputChannel): + def __init__(self, nativeChannelObj): + super(AoChannel, self).__init__(nativeChannelObj) diff --git a/src/components/Automation/BDaq/AoCtrlBase.py b/src/components/Automation/BDaq/AoCtrlBase.py new file mode 100644 index 0000000..c8ee19e --- /dev/null +++ b/src/components/Automation/BDaq/AoCtrlBase.py @@ -0,0 +1,58 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.BDaqApi import TAoCtrlBase, TArray, BioFailed +from Automation.BDaq.AoFeatures import AoFeatures +from Automation.BDaq.AoChannel import AoChannel +from Automation.BDaq import ErrorCode + + +class AoCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(AoCtrlBase, self).__init__(scenario, devInfo) + self._ao_features = None + self._ao_channels = [] + + @property + def features(self): + if self._ao_features is None: + self._ao_features = AoFeatures(TAoCtrlBase.getFeatures(self._obj)) + return self._ao_features + + @property + def channels(self): + if not self._ao_channels: + count = self.features.channelCountMax + nativeChannArr = TAoCtrlBase.getChannels(self._obj) + for i in range(count): + self._ao_channels.append(AoChannel(TArray.getItem(nativeChannArr, i))) + return self._ao_channels + + @property + def channelCount(self): + return self.features.channelCountMax + + @property + def extRefValueForUnipolar(self): + return TAoCtrlBase.getExtRefValueForUnipolar(self._obj) + + @extRefValueForUnipolar.setter + def extRefValueForUnipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoCtrlBase.setExtRefValueForUnipolar(self._obj, value)) + if BioFailed(ret): + raise ValueError('set extRefValueForUnipolar is failed, the error code is 0x%X' % (ret.value)) + + @property + def extRefValueForBipolar(self): + return TAoCtrlBase.getExtRefValueForBipolar(self._obj) + + @extRefValueForBipolar.setter + def extRefValueForBipolar(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TAoCtrlBase.setExtRefValueForBipolar(self._obj, value)) + if BioFailed(ret): + raise ValueError('set extRefValueForBipolar is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/AoFeatures.py b/src/components/Automation/BDaq/AoFeatures.py new file mode 100644 index 0000000..6669918 --- /dev/null +++ b/src/components/Automation/BDaq/AoFeatures.py @@ -0,0 +1,112 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TAoFeatures +from Automation.BDaq.BDaqApi import TArray +from Automation.BDaq import MathInterval +from Automation.BDaq import Utils + + +class AoFeatures(object): + def __init__(self, nativeFeatures): + self._ao_feature = nativeFeatures + + # DAC features + @property + def resolution(self): + return TAoFeatures.getResolution(self._ao_feature) + + @property + def dataSize(self): + return TAoFeatures.getDataSize(self._ao_feature) + + @property + def dataMask(self): + return TAoFeatures.getDataMask(self._ao_feature) + + # channel features + @property + def channelCountMax(self): + return TAoFeatures.getChannelCountMax(self._ao_feature) + + @property + def valueRanges(self): + nativeArray = TAoFeatures.getValueRanges(self._ao_feature) + return TArray.ToValueRange(nativeArray, True) + + @property + def externalRefAntiPolar(self): + ret = TAoFeatures.getExternalRefAntiPolar(self._ao_feature) + return True if ret else False + + @property + def externalRefRange(self): + x = MathInterval() + TAoFeatures.getExternalRefRange(self._ao_feature, ctypes.pointer(x)) + return x + + # buffered ao->basic features + @property + def bufferedAoSupported(self): + ret = TAoFeatures.getBufferedAoSupported(self._ao_feature) + return True if ret else False + + @property + def samplingMethod(self): + ret = TAoFeatures.getSamplingMethod(self._ao_feature) + return Utils.toSamplingMethod(ret) + + @property + def channelStartBase(self): + return TAoFeatures.getChannelStartBase(self._ao_feature) + + @property + def channelCountBase(self): + return TAoFeatures.getChannelCountBase(self._ao_feature) + + # buffered ao->conversion clock features + @property + def convertClockSources(self): + nativeArray = TAoFeatures.getConvertClockSources(self._ao_feature) + return TArray.ToSignalDrop(nativeArray, True) + + @property + def convertClockRange(self): + x = MathInterval() + TAoFeatures.getConvertClockRange(self._ao_feature, ctypes.pointer(x)) + return x + + # buffered ao->trigger features + @property + def triggerCount(self): + return TAoFeatures.getTriggerCount(self._ao_feature) + + @property + def retriggerable(self): + value = TAoFeatures.getRetriggerable(self._ao_feature) + return True if value else False + + # trigger 0 + @property + def triggerSupported(self): + return self.triggerCount != 0 + + # trigger 1 + @property + def trigger1Supported(self): + return self.triggerCount > 1 + + def getTriggerActions(self, trigger = 0): + nativeArray = TAoFeatures.getTriggerActions(self._ao_feature, trigger) + return TArray.ToTriggerAction(nativeArray, True) + + def getTriggerDelayRange(self, trigger = 0): + x = MathInterval() + TAoFeatures.getTriggerDelayRange(self._ao_feature, trigger, ctypes.byref(x)) + return x + + def getTriggerSources(self, trigger = 0): + nativeArray = TAoFeatures.getTriggerSources(self._ao_feature, trigger) + return TArray.ToSignalDrop(nativeArray, True) \ No newline at end of file diff --git a/src/components/Automation/BDaq/BDaqApi.py b/src/components/Automation/BDaq/BDaqApi.py new file mode 100644 index 0000000..8a07693 --- /dev/null +++ b/src/components/Automation/BDaq/BDaqApi.py @@ -0,0 +1,2749 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import platform +from ctypes import * +from Automation.BDaq import * +from Automation.BDaq import Utils + +if platform.architecture()[0] == '32bit': + c_uint64 = c_uint32 + + +if platform.system().lower() == 'windows': + dll = windll.LoadLibrary(r"biodaq") +else: + dll = cdll.LoadLibrary(r"libbiodaq.so") + + +def AdxEnumToString(enumName, enumValue, enumStrLen): + pStr = create_unicode_buffer(enumStrLen, "\0") + dll.AdxEnumToString.argtypes = [c_wchar_p, c_uint32, c_uint32, c_wchar_p] + dll.AdxEnumToString.restype = c_int32 + dll.AdxEnumToString(enumName, enumValue, enumStrLen, pStr) + enumStrBuffer = pStr.value + pStr = None + return enumStrBuffer + + +def AdxGetValueRangeInformation(valueRangeArg, sizeofDesc, pDescription, pMathIntervalRange, pValueUnit): + dll.AdxGetValueRangeInformation.argtypes = [c_uint32, c_uint32, c_wchar_p, POINTER(MathInterval), POINTER(pValueUnit)] + dll.AdxGetValueRangeInformation.restype = c_uint32 + + ret = dll.AdxGetValueRangeInformation(valueRangeArg, sizeofDesc, pDescription, pMathIntervalRange, pValueUnit) + return ret + + +def BioFailed(ret): + if isinstance(ret, ErrorCode): + ret = ret.value + if c_ulong(ret).value >= c_ulong(0xC0000000).value: + return True + return False + + +class TArray(object): + + @staticmethod + def ToInt32(TArrayObj, autoFree): + if TArrayObj == 0 or TArray.getLength(TArrayObj) == 0: + return None + count = TArray.getLength(TArrayObj) + arr = [] + for i in range(count): + item = TArray.getItem(TArrayObj, i) + int_obj = cast(item, POINTER(c_int32)).contents + arr.append(int_obj.value) + + if autoFree: + TArray.dispose(TArrayObj) + return arr + + @staticmethod + def ToInt64(TArrayObj, autoFree): + if TArrayObj == 0 or TArray.getLength(TArrayObj) == 0: + return None + count = TArray.getLength(TArrayObj) + arr = [] + for i in range(count): + item = TArray.getItem(TArrayObj, i) + int64_obj = cast(item, POINTER(c_int64)).contents + arr.append(int64_obj.value) + + if autoFree: + TArray.dispose(TArrayObj) + return arr + + @staticmethod + def ToByte(TArrayObj, autoFree): + if TArrayObj == 0 or TArray.getLength(TArrayObj) == 0: + return None + count = TArray.getLength(TArrayObj) + arr = [] + for i in range(count): + item = TArray.getItem(TArrayObj, i) + byte_obj = cast(item, POINTER(c_byte)).contents + arr.append(byte_obj.value) + + if autoFree: + TArray.dispose(TArrayObj) + return arr + + @staticmethod + def dispose(TArrayObj): + dll.TArray_Dispose.argtypes = [c_uint64] + dll.TArray_Dispose(TArrayObj) + + @staticmethod + def getLength(TArrayObj): + dll.TArray_getLength.argtypes = [c_uint64] + dll.TArray_getLength.restype = c_int32 + return dll.TArray_getLength(TArrayObj) + + @staticmethod + def getItem(TArrayObj, index): + dll.TArray_getItem.argtypes = [c_uint64, c_int32] + dll.TArray_getItem.restype = c_uint64 + return dll.TArray_getItem(TArrayObj, index) + + @staticmethod + def toDeviceTreeNode(nativeArr, autoFree=True): + count = TArray.getLength(nativeArr) + DeviceTreeNodeList = [] + for i in range(count): + item = TArray.getItem(nativeArr, i) + deviceTreeNodeObjSave = DeviceTreeNode() + deviceTreeNodeObj = cast(item, POINTER(DeviceTreeNode)).contents + + deviceTreeNodeObjSave.DevicIntEnumber = deviceTreeNodeObj.DevicIntEnumber + deviceTreeNodeObjSave.Description = deviceTreeNodeObj.Description + for j in range(8): + deviceTreeNodeObjSave.ModulesIndex[j] = deviceTreeNodeObj.ModulesIndex[j] + + DeviceTreeNodeList.append(deviceTreeNodeObjSave) + del deviceTreeNodeObj + if autoFree: + TArray.dispose(nativeArr) + return DeviceTreeNodeList + + @staticmethod + def ToEnum(nptr, autoFree, enumName, convert): + if nptr == 0: + return None + count = TArray.getLength(nptr) + data_list = [] + for i in range(count): + item = TArray.getItem(nptr, i) + enumValue = cast(item, POINTER(c_int)).contents.value + # cast to enum + enumObj = convert(enumValue) + data_list.append(enumObj) + if autoFree: + TArray.dispose(nptr) + return data_list + + @staticmethod + def ToTerminalBoard(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, TerminalBoard, Utils.toTerminalBoard) + + @staticmethod + def ToEventId(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, EventId, Utils.toEventId) + + @staticmethod + def toAccessMode(nativeArr, autoFree=True): + return TArray.ToEnum(nativeArr, autoFree, AccessMode, Utils.toAccessMode) + + @staticmethod + def ToValueRange(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ValueRange, Utils.toValueRange) + + @staticmethod + def ToAiSignalType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, AiSignalType, Utils.toAiSignalType) + + @staticmethod + def ToBurnoutRetType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, BurnoutRetType, Utils.toBurnoutRetType) + + @staticmethod + def ToFilterType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, FilterType, Utils.toFilterType) + + @staticmethod + def ToSignalDrop(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, SignalDrop, Utils.toSignalDrop) + + @staticmethod + def ToActiveSignal(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ActiveSignal, Utils.toActiveSignal) + + @staticmethod + def ToActiveSignal(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ActiveSignal, Utils.toActiveSignal) + + @staticmethod + def ToTriggerAction(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, TriggerAction, Utils.toTriggerAction) + + @staticmethod + def ToCounterCapability(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CounterCapability, Utils.toCounterCapability) + + @staticmethod + def ToSignalPolarity(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, SignalPolarity, Utils.toSignalPolarity) + + @staticmethod + def ToOutSignalType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, OutSignalType, Utils.toOutSignaleType) + + @staticmethod + def ToFreqMeasureMethod(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, FreqMeasureMethod, Utils.toFreqMeasureMethod) + + @staticmethod + def ToCounterCascadeGroup(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CounterCascadeGroup, Utils.toCounterCascadeGroup) + + @staticmethod + def ToCountingType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CountingType, Utils.toCountingType) + + @staticmethod + def ToCouplingType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, CouplingType, Utils.toCouplingType) + + @staticmethod + def ToIepeType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, IepeType, Utils.toIepeType) + + @staticmethod + def ToImpedanceType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, ImpedanceType, Utils.toImpedanceType) + + @staticmethod + def ToDoCircuitType(nativeArr, autoFree): + return TArray.ToEnum(nativeArr, autoFree, DoCircuitType, Utils.toDoCircuitType) + + +class TScanChannel(object): + @staticmethod + def getChannelStart(obj): + dll.TScanChannel_getChannelStart.restype = c_int32 + dll.TScanChannel_getChannelStart.argtypes = [c_uint64] + return dll.TScanChannel_getChannelStart(obj) + + @staticmethod + def setChannelStart(obj, value): + dll.TScanChannel_setChannelStart.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setChannelStart(obj, value) + + @staticmethod + def getChannelCount(obj): + dll.TScanChannel_getChannelCount.restype = c_int32 + dll.TScanChannel_getChannelCount.argtypes = [c_uint64] + return dll.TScanChannel_getChannelCount(obj) + + @staticmethod + def setChannelCount(obj, value): + dll.TScanChannel_setChannelCount.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setChannelCount(obj, value) + + @staticmethod + def getIntervalCount(obj): + dll.TScanChannel_getIntervalCount.restype = c_int32 + dll.TScanChannel_getIntervalCount.argtypes = [c_uint64] + return dll.TScanChannel_getIntervalCount(obj) + + @staticmethod + def setIntervalCount(obj, value): + dll.TScanChannel_setIntervalCount.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setIntervalCount(obj, value) + + @staticmethod + def getSamples(obj): + dll.TScanChannel_getSamples.restype = c_int32 + dll.TScanChannel_getSamples.argtypes = [c_uint64] + return dll.TScanChannel_getSamples(obj) + + @staticmethod + def setSamples(obj, value): + dll.TScanChannel_setSamples.argtypes = [c_uint64, c_int32] + return dll.TScanChannel_setSamples(obj, value) + + +class TConvertClock(object): + @staticmethod + def getSource(obj): + dll.TConvertClock_getSource.argtypes = [c_uint64] + return dll.TConvertClock_getSource(obj) + + @staticmethod + def setSource(obj, value): + dll.TConvertClock_setSource.argtypes = [c_uint64, c_int32] + return dll.TConvertClock_setSource(obj, value) + + @staticmethod + def getRate(obj): + dll.TConvertClock_getRate.restype = c_double + dll.TConvertClock_getRate.argtypes = [c_uint64] + return dll.TConvertClock_getRate(obj) + + @staticmethod + def setRate(obj, value): + dll.TConvertClock_setRate.argtypes = [c_uint64, c_double] + return dll.TConvertClock_setRate(obj, c_double(value)) + + +class TTrigger(object): + @staticmethod + def getSource(obj): + dll.TTrigger_getSource.argtypes = [c_uint64] + dll.TTrigger_getSource.restype = c_int32 + return dll.TTrigger_getSource(obj) + + @staticmethod + def setSource(obj, value): + dll.TTrigger_setSource.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setSource(obj, value) + + @staticmethod + def getEdge(obj): + dll.TTrigger_getEdge.argtypes = [c_uint64] + dll.TTrigger_getEdge.restype = c_int32 + return dll.TTrigger_getEdge(obj) + + @staticmethod + def setEdge(obj, value): + dll.TTrigger_setEdge.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setEdge(obj, value) + + @staticmethod + def getLevel(obj): + dll.TTrigger_getLevel.argtypes = [c_uint64] + dll.TTrigger_getLevel.restype = c_double + return dll.TTrigger_getLevel(obj) + + @staticmethod + def setLevel(obj, value): + dll.TTrigger_setLevel.argtypes = [c_uint64, c_double] + return dll.TTrigger_setLevel(obj, c_double(value)) + + @staticmethod + def getAction(obj): + dll.TTrigger_getAction.argtypes = [c_uint64] + dll.TTrigger_getAction.restype = c_int32 + return dll.TTrigger_getAction(obj) + + @staticmethod + def setAction(obj, value): + dll.TTrigger_setAction.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setAction(obj, value) + + @staticmethod + def getDelayCount(obj): + dll.TTrigger_getDelayCount.argtypes = [c_uint64] + dll.TTrigger_getDelayCount.restype = c_int32 + return dll.TTrigger_getDelayCount(obj) + + @staticmethod + def setDelayCount(obj, value): + dll.TTrigger_setDelayCount.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setDelayCount(obj, value) + + @staticmethod + def getHysteresisIndex(obj): + dll.TTrigger_getHysteresisIndex.argtypes = [c_uint64] + dll.TTrigger_getHysteresisIndex.restype = c_double + return dll.TTrigger_getHysteresisIndex(obj) + + @staticmethod + def setHysteresisIndex(obj, value): + dll.TTrigger_setHysteresisIndex.argtypes = [c_uint64, c_double] + return dll.TTrigger_setHysteresisIndex(obj, c_double(value)) + + @staticmethod + def getFilterType(obj): + dll.TTrigger_getFilterType.argtypes = [c_uint64] + dll.TTrigger_getFilterType.restype = c_int32 + return dll.TTrigger_getFilterType(obj) + + @staticmethod + def setFilterType(obj, value): + dll.TTrigger_setFilterType.argtypes = [c_uint64, c_int32] + return dll.TTrigger_setFilterType(obj, value) + + @staticmethod + def getFilterCutoffFreq(obj): + dll.TTrigger_getFilterCutoffFreq.argtypes = [c_uint64] + dll.TTrigger_getFilterCutoffFreq.restype = c_double + return dll.TTrigger_getFilterCutoffFreq(obj) + + @staticmethod + def setFilterCutoffFreq(obj, value): + dll.TTrigger_setFilterCutoffFreq.argtypes = [c_uint64, c_double] + return dll.TTrigger_setFilterCutoffFreq(obj, c_double(value)) + + +class TConversion(object): + @staticmethod + def getClockSource(obj): + dll.TConversion_getClockSource.argtypes = [c_uint64] + return dll.TConversion_getClockSource(obj) + + @staticmethod + def setClockSource(obj, value): + dll.TConversion_setClockSource.argtypes = [c_uint64, c_int32] + return dll.TConversion_setClockSource(obj, value) + + @staticmethod + def getClockRate(obj): + dll.TConversion_getClockRate.restype = c_double + dll.TConversion_getClockRate.argtypes = [c_uint64] + return dll.TConversion_getClockRate(obj) + + @staticmethod + def setClockRate(obj, value): + dll.TConversion_setClockRate.argtypes = [c_uint64, c_double] + return dll.TConversion_setClockRate(obj, c_double(value)) + + @staticmethod + def getChannelStart(obj): + dll.TConversion_getChannelStart.restype = c_int32 + dll.TConversion_getChannelStart.argtypes = [c_uint64] + return dll.TConversion_getChannelStart(obj) + + @staticmethod + def setChannelStart(obj, value): + dll.TConversion_setChannelStart.argtypes = [c_uint64, c_int32] + return dll.TConversion_setChannelStart(obj, value) + + @staticmethod + def getChannelCount(obj): + dll.TConversion_getChannelCount.restype = c_int32 + dll.TConversion_getChannelCount.argtypes = [c_uint64] + return dll.TConversion_getChannelCount(obj) + + @staticmethod + def setChannelCount(obj, value): + dll.TConversion_setChannelCount.argtypes = [c_uint64, c_int32] + return dll.TConversion_setChannelCount(obj, value) + + @staticmethod + def getChannelMap(obj, count, chMap): + dll.TConversion_getChannelMap.argtypes = [c_uint64, c_int32, POINTER(c_byte)] # need attention + return dll.TConversion_getChannelMap(obj, count, chMap) + + @staticmethod + def setChannelMap(obj, count, chMap): + dll.TConversion_setChannelMap.argtypes = [c_uint64, c_int32, POINTER(c_byte)] # need attention + return dll.TConversion_setChannelMap(obj, count, chMap) + + +class TRecord(object): + @staticmethod + def getSectionLength(obj): + dll.TRecord_getSectionLength.restype = c_int32 + dll.TRecord_getSectionLength.argtypes = [c_uint64] + return dll.TRecord_getSectionLength(obj) + + @staticmethod + def setSectionLength(obj, value): + dll.TRecord_setSectionLength.argtypes = [c_uint64, c_int32] + return dll.TRecord_setSectionLength(obj, value) + + @staticmethod + def getSectionCount(obj): + dll.TRecord_getSectionCount.argtypes = [c_uint64] + return dll.TRecord_getSectionCount(obj) + + @staticmethod + def setSectionCount(obj, value): + dll.TRecord_setSectionCount.argtypes = [c_uint64, c_int32] + return dll.TRecord_setSectionCount(obj, value) + + @staticmethod + def getCycles(obj): + dll.TRecord_getCycles.restype = c_int32 + dll.TRecord_getCycles.argtypes = [c_uint64] + return dll.TRecord_getCycles(obj) + + @staticmethod + def setCycles(obj, value): + dll.TRecord_setCycles.argtypes = [c_uint64, c_int32] + return dll.TRecord_setCycles(obj, value) + + +class TNosFltChannel(object): + @staticmethod + def getChannel(obj): + dll.TNosFltChannel_getChannel.argtypes = [c_uint64] + return dll.TNosFltChannel_getChannel(obj) + + @staticmethod + def getEnabled(obj): + dll.TNosFltChannel_getEnabled.restype = c_int8 + dll.TNosFltChannel_getEnabled.argtypes = [c_uint64] + return dll.TNosFltChannel_getEnabled(obj) + + @staticmethod + def setEnabled(obj, value): + dll.TNosFltChannel_setEnabled.argtypes = [c_uint64, c_int8] + return dll.TNosFltChannel_setEnabled(obj, value) + + +class TDeviceCtrl(object): + @staticmethod + def Refresh(dev_obj): + dll.TDeviceCtrl_Refresh.argtypes = [c_void_p] + return dll.TDeviceCtrl_Refresh(dev_obj) + + @staticmethod + def ReadRegister(dev_obj, space, offset, length, data_arr): + dll.TDeviceCtrl_ReadRegister.argtypes = [c_void_p, c_int32, c_int32, c_int32, c_void_p] # need attention + return dll.TDeviceCtrl_ReadRegister(dev_obj, space, offset, length, data_arr) + + @staticmethod + def WriteRegister(dev_obj, space, offset, length, data_arr): + dll.TDeviceCtrl_WriteRegister.argtypes = [c_void_p, c_int32, c_int32, c_int32, c_void_p] # need attention] + return dll.TDeviceCtrl_WriteRegister(dev_obj, space, offset, length, data_arr) + + @staticmethod + def ReadPrivateRegion(dev_obj, signature, length, data_arr): + dll.TDeviceCtrl_ReadPrivateRegion.argtypes = [c_void_p, c_int32, c_int32, POINTER(c_uint8)] # need attention] + return dll.TDeviceCtrl_ReadPrivateRegion(dev_obj, signature, length, data_arr) + + @staticmethod + def WritePrivateRegion(dev_obj, signature, length, data_arr): + dll.TDeviceCtrl_WritePrivateRegion.argtypes = [c_void_p, c_int32, c_int32, POINTER(c_uint8)] # need attention]] + return dll.TDeviceCtrl_WritePrivateRegion(dev_obj, signature, length, data_arr) + + @staticmethod + def SynchronizeTimebase(dev_obj): + dll.TDeviceCtrl_SynchronizeTimebase.argtypes = [c_void_p] + return dll.TDeviceCtrl_SynchronizeTimebase(dev_obj) + + @staticmethod + def CalculateAbsoluteTime(dev_obj, relativeTime): + dll.TDeviceCtrl_CalculateAbsoluteTime.restype = c_double + dll.TDeviceCtrl_CalculateAbsoluteTime.argtypes = [c_void_p, c_double] + return dll.TDeviceCtrl_CalculateAbsoluteTime(dev_obj, c_double(relativeTime)) + + @staticmethod + def getDeviceNumber(dev_obj): + dll.TDeviceCtrl_getDeviceNumber.restype = c_int32 + dll.TDeviceCtrl_getDeviceNumber.argtypes = [c_void_p] + return dll.TDeviceCtrl_getDeviceNumber(dev_obj) + + @staticmethod + def getDescription(dev_obj, length, descr): + dll.TDeviceCtrl_getDescription.argtypes = [c_void_p, c_int32, c_wchar_p] # need attention + return dll.TDeviceCtrl_getDescription(dev_obj, length, descr) + + @staticmethod + def setDescription(dev_obj, length, descr): + dll.TDeviceCtrl_setDescription.argtypes = [c_void_p, c_int32, c_wchar_p] # need attention] + return dll.TDeviceCtrl_setDescription(dev_obj, length, descr) + + @staticmethod + def getAccessMode(dev_obj): + dll.TDeviceCtrl_getAccessMode.argtypes = [c_void_p] + return dll.TDeviceCtrl_getAccessMode(dev_obj) + + @staticmethod + def getProductId(dev_obj): + dll.TDeviceCtrl_getProductId.argtypes = [c_void_p] + return dll.TDeviceCtrl_getProductId(dev_obj) + + @staticmethod + def getBoardId(dev_obj): + dll.TDeviceCtrl_getBoardId.restype = c_int32 + dll.TDeviceCtrl_getBoardId.argtypes = [c_void_p] + return dll.TDeviceCtrl_getBoardId(dev_obj) + + @staticmethod + def setBoardId(dev_obj, value): + dll.TDeviceCtrl_setBoardId.argtypes = [c_void_p, c_int32] + return dll.TDeviceCtrl_setBoardId(dev_obj, value) + + @staticmethod + def getBoardVersion(dev_obj, length, version): + dll.TDeviceCtrl_getBoardVersion.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getBoardVersion(dev_obj, length, version) + + @staticmethod + def getDriverVersion(dev_obj, length, version): + dll.TDeviceCtrl_getDriverVersion.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getDriverVersion(dev_obj, length, version) + + @staticmethod + def getDllVersion(dev_obj, length, version): + dll.TDeviceCtrl_getDllVersion.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getDllVersion(dev_obj, length, version) + + @staticmethod + def getLocation(dev_obj, length, location): + dll.TDeviceCtrl_getLocation.argtypes = [c_void_p, c_int32, c_wchar_p] + return dll.TDeviceCtrl_getLocation(dev_obj, length, location) + + @staticmethod + def getPrivateRegionLength(dev_obj): + dll.TDeviceCtrl_getPrivateRegionLength.restype = c_int32 + dll.TDeviceCtrl_getPrivateRegionLength.argtypes = [c_void_p] + return dll.TDeviceCtrl_getPrivateRegionLength(dev_obj) + + @staticmethod + def getHotResetPreventable(dev_obj): + dll.TDeviceCtrl_getHotResetPreventable.restype = c_int32 + dll.TDeviceCtrl_getHotResetPreventable.argtypes = [c_void_p] + return dll.TDeviceCtrl_getHotResetPreventable(dev_obj) + + @staticmethod + def getBaseAddresses(dev_obj): + dll.TDeviceCtrl_getBaseAddresses.argtypes = [c_void_p] + dll.TDeviceCtrl_getBaseAddresses.restype = c_uint64 + return dll.TDeviceCtrl_getBaseAddresses(dev_obj) + + @staticmethod + def getInterrupts(dev_obj): + dll.TDeviceCtrl_getInterrupts.argtypes = [c_void_p] + dll.TDeviceCtrl_getInterrupts.restype = c_uint64 + return dll.TDeviceCtrl_getInterrupts(dev_obj) + + @staticmethod + def getSupportedTerminalBoard(dev_obj): + dll.TDeviceCtrl_getSupportedTerminalBoard.argtypes = [c_void_p] + dll.TDeviceCtrl_getSupportedTerminalBoard.restype = c_uint64 + return dll.TDeviceCtrl_getSupportedTerminalBoard(dev_obj) + + @staticmethod + def getSupportedEvents(dev_obj): + dll.TDeviceCtrl_getSupportedEvents.argtypes = [c_void_p] + dll.TDeviceCtrl_getSupportedEvents.restype = c_uint64 + return dll.TDeviceCtrl_getSupportedEvents(dev_obj) + + @staticmethod + def getSupportedScenarios(dev_obj): + dll.TDeviceCtrl_getSupportedScenarios.restype = c_int32 + dll.TDeviceCtrl_getSupportedScenarios.argtypes = [c_void_p] + return dll.TDeviceCtrl_getSupportedScenarios(dev_obj) + + @staticmethod + def getTerminalBoard(dev_obj): + dll.TDeviceCtrl_getTerminalBoard.argtypes = [c_void_p] + return dll.TDeviceCtrl_getTerminalBoard(dev_obj) + + @staticmethod + def setTerminalBoard(dev_obj, value): + dll.TDeviceCtrl_setTerminalBoard.argtypes = [c_void_p, c_int32] + return dll.TDeviceCtrl_setTerminalBoard(dev_obj, value) + + @staticmethod + def setLocateEnabled(dev_obj, value): + dll.TDeviceCtrl_setLocateEnabled.argtypes = [c_void_p, c_int32] + return dll.TDeviceCtrl_setLocateEnabled(dev_obj, value) + + @staticmethod + def getInstalledDevices(): + dll.TDeviceCtrl_getInstalledDevices.restype = c_uint64 + return dll.TDeviceCtrl_getInstalledDevices() + + @staticmethod + def getHwSpecific(dev_obj, name, pSize, dataArr): + dll.TDeviceCtrl_getHwSpecific.argtypes = [c_void_p, c_wchar_p, POINTER(c_int32), c_void_p] + return dll.TDeviceCtrl_getHwSpecific(dev_obj, name, pSize, dataArr) + + @staticmethod + def setHwSpecific(dev_obj, name, size, dataArr): + dll.TDeviceCtrl_setHwSpecific.argtypes = [c_void_p, c_wchar_p, c_int32, c_void_p] + return dll.TDeviceCtrl_setHwSpecific(dev_obj, name, size, dataArr) + + +class TDaqCtrlBase(object): + @staticmethod + def addEventHandler(obj, eventId, eventProc, userParam): + dll.TDaqCtrlBase_addEventHandler.argtypes = [c_uint64] + dll.TDaqCtrlBase_addEventHandler(obj, eventId, eventProc, userParam) # after add types + + @staticmethod + def removeEventHandler(obj, eventId, eventProc, userParam): + dll.TDaqCtrlBase_removeEventHandler.argtypes = [c_uint64] + dll.TDaqCtrlBase_removeEventHandler(obj, eventId, eventProc, userParam) # after add types + + @staticmethod + def cleanup(obj): + dll.TDaqCtrlBase_Cleanup.argtypes = [c_uint64] + dll.TDaqCtrlBase_Cleanup(obj) + + @staticmethod + def dispose(obj): + dll.TDaqCtrlBase_Dispose.argtypes = [c_uint64] + dll.TDaqCtrlBase_Dispose(obj) + + @staticmethod + def getSelectedDevice(obj, devInfo): + dll.TDaqCtrlBase_getSelectedDevice.argtypes = [c_uint64, POINTER(DeviceInformation)] + return dll.TDaqCtrlBase_getSelectedDevice(obj, byref(devInfo)) + + @staticmethod + def setSelectedDevice(obj, devInfo): + dll.TDaqCtrlBase_setSelectedDevice.argtypes = [c_uint64, POINTER(DeviceInformation)] + return dll.TDaqCtrlBase_setSelectedDevice(obj, byref(devInfo)) + + @staticmethod + def getState(obj): + dll.TDaqCtrlBase_getState.argtypes = [c_uint64] + return dll.TDaqCtrlBase_getState(obj) + + @staticmethod + def getDevice(obj): + dll.TDaqCtrlBase_getDevice.argtypes = [c_uint64] + dll.TDaqCtrlBase_getDevice.restype = c_void_p + return dll.TDaqCtrlBase_getDevice(obj) + + @staticmethod + def getSupportedDevices(obj): + dll.TDaqCtrlBase_getSupportedDevices.argtypes = [c_uint64] + dll.TDaqCtrlBase_getSupportedDevices.restype = c_uint64 + return dll.TDaqCtrlBase_getSupportedDevices(obj) + + @staticmethod + def getSupportedModes(obj): + dll.TDaqCtrlBase_getSupportedModes.argtypes = [c_uint64] + dll.TDaqCtrlBase_getSupportedModes.restype = c_uint64 + return dll.TDaqCtrlBase_getSupportedModes(obj) + + @staticmethod + def Create(scenario): + dll.TDaqCtrlBase_Create.argtypes = [c_int32] + dll.TDaqCtrlBase_Create.restype = c_uint64 + return dll.TDaqCtrlBase_Create(scenario) + + @staticmethod + def getModule(obj): + dll.TDaqCtrlBase_getModule.argtypes = [c_uint64] + dll.TDaqCtrlBase_getModule.restype = c_void_p + return dll.TDaqCtrlBase_getModule(obj) + + @staticmethod + def LoadProfile(obj, profile): + dll.TDaqCtrlBase_LoadProfile.argtypes = [c_uint64, c_wchar_p] + return dll.TDaqCtrlBase_LoadProfile(obj, profile) + + +class TAoCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TAoCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TAoCtrlBase_getFeatures.restype = c_uint64 + return dll.TAoCtrlBase_getFeatures(obj) + + @staticmethod + def getChannels(obj): + dll.TAoCtrlBase_getChannels.argtypes = [c_uint64] + dll.TAoCtrlBase_getChannels.restype = c_uint64 + return dll.TAoCtrlBase_getChannels(obj) + + @staticmethod + def getChannelCount(obj): + dll.TAoCtrlBase_getChannelCount.restype = c_int32 + dll.TAoCtrlBase_getChannelCount.argtypes = [c_uint64] + return dll.TAoCtrlBase_getChannelCount(obj) + + @staticmethod + def getExtRefValueForUnipolar(obj): + dll.TAoCtrlBase_getExtRefValueForUnipolar.restype = c_double + dll.TAoCtrlBase_getExtRefValueForUnipolar.argtypes = [c_uint64] + return dll.TAoCtrlBase_getExtRefValueForUnipolar(obj) + + @staticmethod + def setExtRefValueForUnipolar(obj, value): + dll.TAoCtrlBase_setExtRefValueForUnipolar.argtypes = [c_uint64, c_double] + return dll.TAoCtrlBase_setExtRefValueForUnipolar(obj, c_double(value)) + + @staticmethod + def getExtRefValueForBipolar(obj): + dll.TAoCtrlBase_getExtRefValueForBipolar.restype = c_double + dll.TAoCtrlBase_getExtRefValueForBipolar.argtypes = [c_uint64] + return dll.TAoCtrlBase_getExtRefValueForBipolar(obj) + + @staticmethod + def setExtRefValueForBipolar(obj, value): + dll.TAoCtrlBase_setExtRefValueForBipolar.argtypes = [c_uint64, c_double] + return dll.TAoCtrlBase_setExtRefValueForBipolar(obj, c_double(value)) + + +class TInstantAoCtrl(object): + @staticmethod + def writeAny(obj, chStart, chCount, dataRaw, dataScaled): + dll.TInstantAoCtrl_WriteAny.argtypes = [c_uint64, c_int32, c_int32, c_void_p, POINTER(c_double)] + return dll.TInstantAoCtrl_WriteAny(obj, chStart, chCount, dataRaw, dataScaled) + + +class TAoFeatures(object): + # DAC features + @staticmethod + def getResolution(aoFeatureObj): + dll.TAoFeatures_getResolution.restype = c_int32 + dll.TAoFeatures_getResolution.argtypes = [c_uint64] + return dll.TAoFeatures_getResolution(aoFeatureObj) + + @staticmethod + def getDataSize(aoFeatureObj): + dll.TAoFeatures_getDataSize.restype = c_int32 + dll.TAoFeatures_getDataSize.argtypes = [c_uint64] + return dll.TAoFeatures_getDataSize(aoFeatureObj) + + @staticmethod + def getDataMask(aoFeatureObj): + dll.TAoFeatures_getDataMask.restype = c_int32 + dll.TAoFeatures_getDataMask.argtypes = [c_uint64] + return dll.TAoFeatures_getDataMask(aoFeatureObj) + + # channel features + @staticmethod + def getChannelCountMax(aoFeatureObj): + dll.TAoFeatures_getChannelCountMax.restype = c_int32 + dll.TAoFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TAoFeatures_getChannelCountMax(aoFeatureObj) + + @staticmethod + def getValueRanges(aoFeatureObj): + dll.TAoFeatures_getValueRanges.argtypes = [c_uint64] + dll.TAoFeatures_getValueRanges.restype = c_uint64 + return dll.TAoFeatures_getValueRanges(aoFeatureObj) + + @staticmethod + def getExternalRefAntiPolar(aoFeatureObj): + dll.TAoFeatures_getExternalRefAntiPolar.restype = c_int8 + dll.TAoFeatures_getExternalRefAntiPolar.argtypes = [c_uint64] + return dll.TAoFeatures_getExternalRefAntiPolar(aoFeatureObj) + + @staticmethod + def getExternalRefRange(aoFeatureObj, mathIntervalObj): + dll.TAoFeatures_getExternalRefRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAoFeatures_getExternalRefRange(aoFeatureObj, mathIntervalObj) + + # buffered ao->basic features + @staticmethod + def getBufferedAoSupported(aoFeatureObj): + dll.TAoFeatures_getBufferedAoSupported.restype = c_int8 + dll.TAoFeatures_getBufferedAoSupported.argtypes = [c_uint64] + return dll.TAoFeatures_getBufferedAoSupported(aoFeatureObj) + + @staticmethod + def getSamplingMethod(aoFeatureObj): + dll.TAoFeatures_getSamplingMethod.argtypes = [c_uint64] + return dll.TAoFeatures_getSamplingMethod(aoFeatureObj) + + @staticmethod + def getChannelStartBase(aoFeatureObj): + dll.TAoFeatures_getChannelStartBase.restype = c_int32 + dll.TAoFeatures_getChannelStartBase.argtypes = [c_uint64] + return dll.TAoFeatures_getChannelStartBase(aoFeatureObj) + + @staticmethod + def getChannelCountBase(aoFeatureObj): + dll.TAoFeatures_getChannelCountBase.restype = c_int32 + dll.TAoFeatures_getChannelCountBase.argtypes = [c_uint64] + return dll.TAoFeatures_getChannelCountBase(aoFeatureObj) + + # buffered ao->conversion clock features + @staticmethod + def getConvertClockSources(aoFeatureObj): + dll.TAoFeatures_getConvertClockSources.argtypes = [c_uint64] + dll.TAoFeatures_getConvertClockSources.restype = c_uint64 + return dll.TAoFeatures_getConvertClockSources(aoFeatureObj) + + @staticmethod + def getConvertClockRange(aoFeatureObj, mathInterval): + dll.TAoFeatures_getConvertClockRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAoFeatures_getConvertClockRange(aoFeatureObj, mathInterval) + + # buffered ao->trigger features + @staticmethod + def getTriggerCount(aoFeatureObj): + dll.TAoFeatures_getTriggerCount.restype = c_int32 + dll.TAoFeatures_getTriggerCount.argtypes = [c_uint64] + return dll.TAoFeatures_getTriggerCount(aoFeatureObj) + + @staticmethod + def getRetriggerable(aoFeatureObj): + dll.TAoFeatures_getRetriggerable.restype = c_int8 + dll.TAoFeatures_getRetriggerable.argtypes = [c_uint64] + return dll.TAoFeatures_getRetriggerable(aoFeatureObj) + + # buffered ao->trigger0/1/.../x features + @staticmethod + def getTriggerSources(aoFeatureObj, trigger): + dll.TAoFeatures_getTriggerSources.argtypes = [c_uint64, c_int32] + dll.TAoFeatures_getTriggerSources.restype = c_uint64 + return dll.TAoFeatures_getTriggerSources(aoFeatureObj, trigger) + + @staticmethod + def getTriggerActions(aoFeatureObj, trigger): + dll.TAoFeatures_getTriggerActions.argtypes = [c_uint64, c_int32] + dll.TAoFeatures_getTriggerActions.restype = c_uint64 + return dll.TAoFeatures_getTriggerActions(aoFeatureObj, trigger) + + @staticmethod + def getTriggerDelayRange(aoFeatureObj, trigger, mathIntervalX): + dll.TAoFeatures_getTriggerDelayRange.argtypes = [c_uint64, c_int32, POINTER(MathInterval)] + return dll.TAoFeatures_getTriggerDelayRange(aoFeatureObj, trigger, mathIntervalX) + + +class TAoChannel(object): + @staticmethod + def getChannel(aoChannelObj): + dll.TAoChannel_getChannel.restype = c_int32 + dll.TAoChannel_getChannel.argtypes = [c_uint64] + return dll.TAoChannel_getChannel(aoChannelObj) + + @staticmethod + def getValueRange(aoChannelObj): + dll.TAoChannel_getValueRange.argtypes = [c_uint64] + return dll.TAoChannel_getValueRange(aoChannelObj) + + @staticmethod + def setValueRange(aoChannelObj, valueRange): + dll.TAoChannel_setValueRange.argtypes = [c_uint64, c_int32] + return dll.TAoChannel_setValueRange(aoChannelObj, valueRange) + + @staticmethod + def getExtRefBipolar(aoChannelObj): + dll.TAoChannel_getExtRefBipolar.restype = c_double + dll.TAoChannel_getExtRefBipolar.argtypes = [c_uint64] + return dll.TAoChannel_getExtRefBipolar(aoChannelObj) + + @staticmethod + def setExtRefBipolar(aoChannelObj, value): + dll.TAoChannel_setExtRefBipolar.argtypes = [c_uint64, c_double] + return dll.TAoChannel_setExtRefBipolar(aoChannelObj, c_double(value)) + + @staticmethod + def getExtRefUnipolar(aoChannelObj): + dll.TAoChannel_getExtRefUnipolar.restype = c_double + dll.TAoChannel_getExtRefUnipolar.argtypes = [c_uint64] + return dll.TAoChannel_getExtRefUnipolar(aoChannelObj) + + @staticmethod + def setExtRefUnipolar(aoChannelObj, value): + dll.TAoChannel_setExtRefUnipolar.argtypes = [c_uint64, c_double] + return dll.TAoChannel_setExtRefUnipolar(aoChannelObj, c_double(value)) + + # new: scale table + @staticmethod + def getScaleTable(aoChannelObj, pSize, mapFuncPieceTable): + dll.TAoChannel_getScaleTable.argtypes = [c_uint64, POINTER(c_int32), POINTER(MapFuncPiece)] + return dll.TAoChannel_getScaleTable(aoChannelObj, pSize, mapFuncPieceTable) + + @staticmethod + def setScaleTable(aoChannelObj, size, mapFuncPieceTable): + dll.TAoChannel_setScaleTable.argtypes = [c_uint64, c_int32, POINTER(MapFuncPiece)] + return dll.TAoChannel_setScaleTable(aoChannelObj, size, mapFuncPieceTable) + + +class TAiCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TAiCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TAiCtrlBase_getFeatures.restype = c_uint64 + return dll.TAiCtrlBase_getFeatures(obj) + + @staticmethod + def getChannels(obj): + dll.TAiCtrlBase_getChannels.restype = c_uint64 + dll.TAiCtrlBase_getChannels.argtypes = [c_uint64] + return dll.TAiCtrlBase_getChannels(obj) + + @staticmethod + def getChannelCount(obj): + dll.TAiCtrlBase_getChannelCount.restype = c_int32 + dll.TAiCtrlBase_getChannelCount.argtypes = [c_uint64] + return dll.TAiCtrlBase_getChannelCount(obj) + + +class TWaveformAiCtrl(object): + @staticmethod + def Prepare(obj): + dll.TWaveformAiCtrl_Prepare.argtypes = [c_uint64] + return dll.TWaveformAiCtrl_Prepare(obj) + + @staticmethod + def Start(obj): + dll.TWaveformAiCtrl_Start.argtypes = [c_uint64] + return dll.TWaveformAiCtrl_Start(obj) + + @staticmethod + def Stop(obj): + dll.TWaveformAiCtrl_Stop.argtypes = [c_uint64] + return dll.TWaveformAiCtrl_Stop(obj) + + @staticmethod + def GetData(obj, dt, count, buffer, timeout, returned, startTime, markCount, makrBuf): + dll.TWaveformAiCtrl_GetData.argtypes = [c_uint64, c_int32, c_int32, c_void_p, c_int32, POINTER(c_int32), POINTER(c_double), POINTER(c_int32), POINTER(DataMark)] + return dll.TWaveformAiCtrl_GetData(obj, dt, count, buffer, timeout, returned, startTime, markCount, makrBuf) + + @staticmethod + def getConversion(obj): + dll.TWaveformAiCtrl_getConversion.argtypes = [c_uint64] + dll.TWaveformAiCtrl_getConversion.restype = c_uint64 + return dll.TWaveformAiCtrl_getConversion(obj) + + @staticmethod + def getRecord(obj): + dll.TWaveformAiCtrl_getRecord.argtypes = [c_uint64] + dll.TWaveformAiCtrl_getRecord.restype = c_uint64 + return dll.TWaveformAiCtrl_getRecord(obj) + + @staticmethod + def getTrigger(obj, trigIdx): + dll.TWaveformAiCtrl_getTrigger.argtypes = [c_uint64, c_int32] + dll.TWaveformAiCtrl_getTrigger.restype = c_uint64 + return dll.TWaveformAiCtrl_getTrigger(obj, trigIdx) + + +class TBufferedAoCtrl(object): + @staticmethod + def getScanChannel(obj): + dll.TBufferedAoCtrl_getScanChannel.argtypes = [c_uint64] + dll.TBufferedAoCtrl_getScanChannel.restype = c_uint64 + return dll.TBufferedAoCtrl_getScanChannel(obj) + + @staticmethod + def getConvertClock(obj): + dll.TBufferedAoCtrl_getConvertClock.argtypes = [c_uint64] + dll.TBufferedAoCtrl_getConvertClock.restype = c_uint64 + return dll.TBufferedAoCtrl_getConvertClock(obj) + + @staticmethod + def getTrigger(obj, trigIdx): + dll.TBufferedAoCtrl_getTrigger.argtypes = [c_uint64, c_int32] + dll.TBufferedAoCtrl_getTrigger.restype = c_uint64 + return dll.TBufferedAoCtrl_getTrigger(obj, trigIdx) + + @staticmethod + def getStreaming(obj): + dll.TBufferedAoCtrl_getStreaming.argtypes = [c_uint64] + dll.TBufferedAoCtrl_getStreaming.restype = c_int8 + return dll.TBufferedAoCtrl_getStreaming(obj) + + @staticmethod + def setStreaming(obj, value): + dll.TBufferedAoCtrl_setStreaming.argtypes = [c_uint64, c_int8] + return dll.TBufferedAoCtrl_setStreaming(obj, value) + + @staticmethod + def Prepare(obj): + dll.TBufferedAoCtrl_Prepare.argtypes = [c_uint64] + return dll.TBufferedAoCtrl_Prepare(obj) + + @staticmethod + def RunOnce(obj): + dll.TBufferedAoCtrl_RunOnce.argtypes = [c_uint64] + return dll.TBufferedAoCtrl_RunOnce(obj) + + @staticmethod + def Start(obj): + dll.TBufferedAoCtrl_Start.argtypes = [c_uint64] + return dll.TBufferedAoCtrl_Start(obj) + + @staticmethod + def Stop(obj, value): + dll.TBufferedAoCtrl_Stop.argtypes = [c_uint64, c_int32] + return dll.TBufferedAoCtrl_Stop(obj, value) + + @staticmethod + def SetData(obj, dt, count, buffer): + dll.TBufferedAoCtrl_SetData.argtypes = [c_uint64, c_int32, c_int32, c_void_p] + return dll.TBufferedAoCtrl_SetData(obj, dt, count, buffer) + + +class TInstantAiCtrl(object): + @staticmethod + def getCjc(obj): + dll.TInstantAiCtrl_getCjc.argtypes = [c_uint64] + dll.TInstantAiCtrl_getCjc.restype = c_uint64 + return dll.TInstantAiCtrl_getCjc(obj) + + @staticmethod + def getAutoConvertClockRate(obj): + dll.TInstantAiCtrl_getAutoConvertClockRate.restype = c_double + dll.TInstantAiCtrl_getAutoConvertClockRate.argtypes = [c_uint64] + return dll.TInstantAiCtrl_getAutoConvertClockRate(obj) + + @staticmethod + def setAutoConvertClockRate(obj, value): + dll.TInstantAiCtrl_setAutoConvertClockRate.argtypes = [c_uint64, c_double] + return dll.TInstantAiCtrl_setAutoConvertClockRate(obj, c_double(value)) + + @staticmethod + def getAutoConvertChannelStart(obj): + dll.TInstantAiCtrl_getAutoConvertChannelStart.argtypes = [c_uint64] + return dll.TInstantAiCtrl_getAutoConvertChannelStart(obj) + + @staticmethod + def setAutoConvertChannelStart(obj, intValue): + dll.TInstantAiCtrl_setAutoConvertChannelStart.argtypes = [c_uint64, c_int32] + return dll.TInstantAiCtrl_setAutoConvertChannelStart(obj, intValue) + + @staticmethod + def getAutoConvertChannelCount(obj): + dll.TInstantAiCtrl_getAutoConvertChannelCount.argtypes = [c_uint64] + return dll.TInstantAiCtrl_getAutoConvertChannelCount(obj) + + @staticmethod + def setAutoConvertChannelCount(obj, intValue): + dll.TInstantAiCtrl_setAutoConvertChannelCount.argtypes = [c_uint64, c_int32] + return dll.TInstantAiCtrl_setAutoConvertChannelCount(obj, intValue) + + @staticmethod + def readAny(obj, chStart, chCount, dataRaw, dataScaled): + dll.TInstantAiCtrl_ReadAny.restype = c_uint32 + dll.TInstantAiCtrl_ReadAny.argtypes = [c_uint64, c_int32, c_int32, c_void_p, POINTER(c_double)] + return dll.TInstantAiCtrl_ReadAny(obj, chStart, chCount, dataRaw, dataScaled) + + +class TCjcSetting(object): + @staticmethod + def getChannel(cjcSetObj): + dll.TCjcSetting_getChannel.restype = c_int32 + dll.TCjcSetting_getChannel.argtypes = [c_uint64] + return dll.TCjcSetting_getChannel(cjcSetObj) + + @staticmethod + def setChannel(cjcSetObj, intCh): + dll.TCjcSetting_setChannel.argtypes = [c_uint64, c_int32] + return dll.TCjcSetting_setChannel(cjcSetObj, intCh) + + @staticmethod + def getValue(cjcSetObj): + dll.TCjcSetting_getValue.restype = c_double + dll.TCjcSetting_getValue.argtypes = [c_uint64] + return dll.TCjcSetting_getValue(cjcSetObj) + + @staticmethod + def setValue(cjcSetObj, value): + dll.TCjcSetting_setValue.argtypes = [c_uint64, c_double] + return dll.TCjcSetting_setValue(cjcSetObj, c_double(value)) + + @staticmethod + def getUpdateFreq(cjcSetObj): + dll.TCjcSetting_getUpdateFreq.restype = c_double + dll.TCjcSetting_getUpdateFreq.argtypes = [c_uint64] + return dll.TCjcSetting_getUpdateFreq(cjcSetObj) + + @staticmethod + def setUpdateFreq(cjcSetObj, value): + dll.TCjcSetting_setUpdateFreq.argtypes = [c_uint64, c_double] + return dll.TCjcSetting_setUpdateFreq(cjcSetObj, c_double(value)) + + +class TAiFeatures(object): + # ADC features + @staticmethod + def getResolution(aiFeatureObj): + dll.TAiFeatures_getResolution.restype = c_int32 + dll.TAiFeatures_getResolution.argtypes = [c_uint64] + return dll.TAiFeatures_getResolution(aiFeatureObj) + + @staticmethod + def getDataSize(aiFeatureObj): + dll.TAiFeatures_getDataSize.restype = c_int32 + dll.TAiFeatures_getDataSize.argtypes = [c_uint64] + return dll.TAiFeatures_getDataSize(aiFeatureObj) + + @staticmethod + def getDataMask(aiFeatureObj): + dll.TAiFeatures_getDataMask.restype = c_int32 + dll.TAiFeatures_getDataMask.argtypes = [c_uint64] + return dll.TAiFeatures_getDataMask(aiFeatureObj) + + # new: timestamp resolution + @staticmethod + def getTimestampResolution(aiFeatureObj): + dll.TAiFeatures_getTimestampResolution.restype = c_double + dll.TAiFeatures_getTimestampResolution.argtypes = [c_uint64] + return dll.TAiFeatures_getTimestampResolution(aiFeatureObj) + + # channel features + @staticmethod + def getChannelCountMax(aiFeatureObj): + dll.TAiFeatures_getChannelCountMax.restype = c_int32 + dll.TAiFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelCountMax(aiFeatureObj) + + @staticmethod + def getChannelType(aiFeatureObj): + dll.TAiFeatures_getChannelType.restype = c_int + dll.TAiFeatures_getChannelType.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelType(aiFeatureObj) + + @staticmethod + def getOverallValueRange(aiFeatureObj): + dll.TAiFeatures_getOverallValueRange.restype = c_int8 + dll.TAiFeatures_getOverallValueRange.argtypes = [c_uint64] + return dll.TAiFeatures_getOverallValueRange(aiFeatureObj) + + @staticmethod + def getValueRanges(aiFeatureObj): + dll.TAiFeatures_getValueRanges.argtypes = [c_uint64] + dll.TAiFeatures_getValueRanges.restype = c_uint64 + return dll.TAiFeatures_getValueRanges(aiFeatureObj) + + @staticmethod + def getBurnoutReturnTypes(aiFeatureObj): + dll.TAiFeatures_getBurnoutReturnTypes.argtypes = [c_uint64] + dll.TAiFeatures_getBurnoutReturnTypes.restype = c_uint64 + return dll.TAiFeatures_getBurnoutReturnTypes(aiFeatureObj) + + @staticmethod + def getConnectionTypes(aiFeatureObj): + dll.TAiFeatures_getConnectionTypes.argtypes = [c_uint64] + dll.TAiFeatures_getConnectionTypes.restype = c_uint64 + return dll.TAiFeatures_getConnectionTypes(aiFeatureObj) + + @staticmethod + def getOverallConnection(aiFeatureObj): + dll.TAiFeatures_getOverallConnection.restype = c_int8 + dll.TAiFeatures_getOverallConnection.argtypes = [c_uint64] + return dll.TAiFeatures_getOverallConnection(aiFeatureObj) + + # filter + @staticmethod + def getFilterTypes(aiFeatureObj): + dll.TAiFeatures_getFilterTypes.argtypes = [c_uint64] + dll.TAiFeatures_getFilterTypes.restype = c_uint64 + return dll.TAiFeatures_getFilterTypes(aiFeatureObj) + + @staticmethod + def getFilterCutoffFreqRange(aiFeaturesObj, mathIntervalVal): + dll.TAiFeatures_getFilterCutoffFreqRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getFilterCutoffFreqRange(aiFeaturesObj, mathIntervalVal) + + @staticmethod + def getFilterCutoffFreq1Range(aiFeaturesObj, mathIntervalVal): + dll.TAiFeatures_getFilterCutoffFreq1Range.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getFilterCutoffFreq1Range(aiFeaturesObj, mathIntervalVal) + + # CJC features + @staticmethod + def getThermoSupported(aiFeaturesObj): + dll.TAiFeatures_getThermoSupported.restype = c_int8 + dll.TAiFeatures_getThermoSupported.argtypes = [c_uint64] + return dll.TAiFeatures_getThermoSupported(aiFeaturesObj) + + @staticmethod + def getCjcChannels(aiFeaturesObj): + dll.TAiFeatures_getCjcChannels.argtypes = [c_uint64] + dll.TAiFeatures_getCjcChannels.restype = c_uint64 + return dll.TAiFeatures_getCjcChannels(aiFeaturesObj) + + # buffered ai -> basic features + @staticmethod + def getBufferedAiSupported(aiFeaturesObj): + dll.TAiFeatures_getBufferedAiSupported.restype = c_int8 + dll.TAiFeatures_getBufferedAiSupported.argtypes = [c_uint64] + return dll.TAiFeatures_getBufferedAiSupported(aiFeaturesObj) + + @staticmethod + def getSamplingMethod(aiFeaturesObj): + dll.TAiFeatures_getSamplingMethod.restype = c_int + dll.TAiFeatures_getSamplingMethod.argtypes = [c_uint64] + return dll.TAiFeatures_getSamplingMethod(aiFeaturesObj) + + @staticmethod + def getChannelStartBase(aiFeaturesObj): + dll.TAiFeatures_getChannelStartBase.restype = c_int32 + dll.TAiFeatures_getChannelStartBase.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelStartBase(aiFeaturesObj) + + @staticmethod + def getChannelCountBase(aiFeaturesObj): + dll.TAiFeatures_getChannelCountBase.restype = c_int32 + dll.TAiFeatures_getChannelCountBase.argtypes = [c_uint64] + return dll.TAiFeatures_getChannelCountBase(aiFeaturesObj) + + # buffered ai->conversion clock features + @staticmethod + def getConvertClockSources(aiFeaturesObj): + dll.TAiFeatures_getConvertClockSources.argtypes = [c_uint64] + dll.TAiFeatures_getConvertClockSources.restype = c_uint64 + return dll.TAiFeatures_getConvertClockSources(aiFeaturesObj) + + @staticmethod + def getConvertClockRange(aiFeaturesObj, mathIntervalValue): + dll.TAiFeatures_getConvertClockRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getConvertClockRange(aiFeaturesObj, mathIntervalValue) + + # buffered ai->burst scan + @staticmethod + def getBurstScanSupported(aiFeaturesObj): + dll.TAiFeatures_getBurstScanSupported.restype = c_int8 + dll.TAiFeatures_getBurstScanSupported.argtypes = [c_uint64] + return dll.TAiFeatures_getBurstScanSupported(aiFeaturesObj) + + @staticmethod + def getScanClockSources(aiFeaturesObj): + dll.TAiFeatures_getScanClockSources.argtypes = [c_uint64] + dll.TAiFeatures_getScanClockSources.restype = c_uint64 + return dll.TAiFeatures_getScanClockSources(aiFeaturesObj) + + @staticmethod + def getScanClockRange(aiFeaturesObj, mathIntervalValue): + dll.TAiFeatures_getScanClockRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TAiFeatures_getScanClockRange(aiFeaturesObj, mathIntervalValue) + + @staticmethod + def getScanCountMax(aiFeaturesObj): + dll.TAiFeatures_getScanCountMax.restype = c_int32 + dll.TAiFeatures_getScanCountMax.argtypes = [c_uint64] + return dll.TAiFeatures_getScanCountMax(aiFeaturesObj) + + # buffered ai->trigger features + @staticmethod + def getRetriggerable(aiFeaturesObj): + dll.TAiFeatures_getRetriggerable.restype = c_int8 + dll.TAiFeatures_getRetriggerable.argtypes = [c_uint64] + return dll.TAiFeatures_getRetriggerable(aiFeaturesObj) + + @staticmethod + def getTriggerCount(aiFeaturesObj): + dll.TAiFeatures_getTriggerCount.restype = c_int32 + dll.TAiFeatures_getTriggerCount.argtypes = [c_uint64] + return dll.TAiFeatures_getTriggerCount(aiFeaturesObj) + + @staticmethod + def getTriggerFilterTypes(aiFeaturesObj, reserved): + dll.TAiFeatures_getTriggerFilterTypes.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerFilterTypes.restype = c_uint64 + return dll.TAiFeatures_getTriggerFilterTypes(aiFeaturesObj, reserved) + + @staticmethod + def getTriggerFilterCutoffFreqRange(aiFeaturesObj, reserved, mathIntervalValue): + dll.TAiFeatures_getTriggerFilterCutoffFreqRange.argtypes = [c_uint64, c_int32, POINTER(MathInterval)] + return dll.TAiFeatures_getTriggerFilterCutoffFreqRange(aiFeaturesObj, reserved, mathIntervalValue) + + # buffered ai->trigger0/1/.../x features + @staticmethod + def getTriggerActions(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerActions.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerActions.restype = c_uint64 + return dll.TAiFeatures_getTriggerActions(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerDelayRange(aiFeaturesObj, trigger, mathIntervalX): + dll.TAiFeatures_getTriggerDelayRange.argtypes = [c_uint64, c_int32, POINTER(MathInterval)] + return dll.TAiFeatures_getTriggerDelayRange(aiFeaturesObj, trigger, mathIntervalX) + + @staticmethod + def getTriggerSources(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerSources.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerSources.restype = c_uint64 + return dll.TAiFeatures_getTriggerSources(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerSourceVrg(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerSourceVrg.argtypes = [c_uint64, c_int32] + return dll.TAiFeatures_getTriggerSourceVrg(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerHysteresisIndexMax(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerHysteresisIndexMax.argtypes = [c_uint64, c_int32] + dll.TAiFeatures_getTriggerHysteresisIndexMax.restype = c_double + return dll.TAiFeatures_getTriggerHysteresisIndexMax(aiFeaturesObj, trigger) + + @staticmethod + def getTriggerHysteresisIndexStep(aiFeaturesObj, trigger): + dll.TAiFeatures_getTriggerHysteresisIndexStep.argtypes = [c_uint64, c_int32] + return dll.TAiFeatures_getTriggerHysteresisIndexStep(aiFeaturesObj, trigger) + + # new coupling & IEPE & Impedance + @staticmethod + def getCouplingTypes(aiFeaturesObj): + dll.TAiFeatures_getCouplingTypes.argtypes = [c_uint64] + dll.TAiFeatures_getCouplingTypes.restype = c_uint64 + return dll.TAiFeatures_getCouplingTypes(aiFeaturesObj) + + @staticmethod + def getIepeTypes(aiFeaturesObj): + dll.TAiFeatures_getIepeTypes.argtypes = [c_uint64] + dll.TAiFeatures_getIepeTypes.restype = c_uint64 + return dll.TAiFeatures_getIepeTypes(aiFeaturesObj) + + @staticmethod + def getImpedanceTypes(aiFeaturesObj): + dll.TAiFeatures_getImpedanceTypes.argtypes = [c_uint64] + dll.TAiFeatures_getImpedanceTypes.restype = c_uint64 + return dll.TAiFeatures_getImpedanceTypes(aiFeaturesObj) + + # new: sensor features + @staticmethod + def getMeasureTypes(aiFeaturesObj): + dll.TAiFeatures_getMeasureTypes.argtypes = [c_uint64] + dll.TAiFeatures_getMeasureTypes.restype = c_uint64 + return dll.TAiFeatures_getMeasureTypes(aiFeaturesObj) + + @staticmethod + def getBridgeResistances(aiFeaturesObj): + dll.TAiFeatures_getBridgeResistances.argtypes = [c_uint64] + dll.TAiFeatures_getBridgeResistances.restype = c_uint64 + return dll.TAiFeatures_getBridgeResistances(aiFeaturesObj) + + @staticmethod + def getExcitingVoltageRange(aiFeaturesObj): + dll.TAiFeatures_getExcitingVoltageRange.argtypes = [c_uint64] + return dll.TAiFeatures_getExcitingVoltageRange(aiFeaturesObj) + + +class TAiChannel(object): + @staticmethod + def getChannel(aiChannObj): + dll.TAiChannel_getChannel.restype = c_int32 + dll.TAiChannel_getChannel.argtypes = [c_uint64] + return dll.TAiChannel_getChannel(aiChannObj) + + @staticmethod + def getLogicalNumber(aiChannObj): + dll.TAiChannel_getLogicalNumber.restype = c_int32 + dll.TAiChannel_getLogicalNumber.argtypes = [c_uint64] + return dll.TAiChannel_getLogicalNumber(aiChannObj) + + @staticmethod + def getValueRange(aiChannObj): + dll.TAiChannel_getValueRange.restype = c_int + dll.TAiChannel_getValueRange.argtypes = [c_uint64] + return dll.TAiChannel_getValueRange(aiChannObj) + + @staticmethod + def setValueRange(aiChannObj, valueRangeValue): + dll.TAiChannel_setValueRange.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setValueRange(aiChannObj, valueRangeValue) + + @staticmethod + def getSignalType(aiChannObj): + dll.TAiChannel_getSignalType.restype = c_int + dll.TAiChannel_getSignalType.argtypes = [c_uint64] + return dll.TAiChannel_getSignalType(aiChannObj) + + @staticmethod + def setSignalType(aiChannObj, aiSignalTypeValue): + dll.TAiChannel_setSignalType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setSignalType(aiChannObj, aiSignalTypeValue) + + @staticmethod + def getBurnoutRetType(aiChannObj): + dll.TAiChannel_getBurnoutRetType.restype = c_int + dll.TAiChannel_getBurnoutRetType.argtypes = [c_uint64] + return dll.TAiChannel_getBurnoutRetType(aiChannObj) + + @staticmethod + def setBurnoutRetType(aiChannObj, burnoutRetTypeValue): + dll.TAiChannel_setBurnoutRetType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setBurnoutRetType(aiChannObj, burnoutRetTypeValue) + + @staticmethod + def getBurnoutRetValue(aiChannObj): + dll.TAiChannel_getBurnoutRetValue.restype = c_double + dll.TAiChannel_getBurnoutRetValue.argtypes = [c_uint64] + return dll.TAiChannel_getBurnoutRetValue(aiChannObj) + + @staticmethod + def setBurnoutRetValue(aiChannObj, value): + dll.TAiChannel_setBurnoutRetValue.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setBurnoutRetValue(aiChannObj, c_double(value)) + + @staticmethod + def getBurnShortRetValue(aiChannObj): + dll.TAiChannel_getBurnShortRetValue.restype = c_double + dll.TAiChannel_getBurnShortRetValue.argtypes = [c_uint64] + return dll.TAiChannel_getBurnShortRetValue(aiChannObj) + + @staticmethod + def setBurnShortRetValue(aiChannObj, value): + dll.TAiChannel_setBurnShortRetValue.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setBurnShortRetValue(aiChannObj, c_double(value)) + + @staticmethod + def getFilterType(aiChannObj): + dll.TAiChannel_getFilterType.restype = c_int + dll.TAiChannel_getFilterType.argtypes = [c_uint64] + return dll.TAiChannel_getFilterType(aiChannObj) + + @staticmethod + def setFilterType(aiChannObj, filterTypeValue): + dll.TAiChannel_setFilterType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setFilterType(aiChannObj, filterTypeValue) + + @staticmethod + def getFilterCutoffFreq(aiChannObj): + dll.TAiChannel_getFilterCutoffFreq.restype = c_double + dll.TAiChannel_getFilterCutoffFreq.argtypes = [c_uint64] + return dll.TAiChannel_getFilterCutoffFreq(aiChannObj) + + @staticmethod + def setFilterCutoffFreq(aiChannObj, value): + dll.TAiChannel_setFilterCutoffFreq.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setFilterCutoffFreq(aiChannObj, c_double(value)) + + @staticmethod + def getFilterCutoffFreq1(aiChannObj): + dll.TAiChannel_getFilterCutoffFreq1.restype = c_double + dll.TAiChannel_getFilterCutoffFreq1.argtypes = [c_uint64] + return dll.TAiChannel_getFilterCutoffFreq1(aiChannObj) + + @staticmethod + def setFilterCutoffFreq1(aiChannObj, value): + dll.TAiChannel_setFilterCutoffFreq1.argtypes = [c_uint64, c_double] + return dll.TAiChannel_setFilterCutoffFreq1(aiChannObj, c_double(value)) + + # new: Coupling & IEPE & Impedance + @staticmethod + def getCouplingType(aiChannObj): + dll.TAiChannel_getCouplingType.restype = c_int + dll.TAiChannel_getCouplingType.argtypes = [c_uint64] + return dll.TAiChannel_getCouplingType(aiChannObj) + + @staticmethod + def setCouplingType(aiChannObj, couplingTypeValue): + dll.TAiChannel_setCouplingType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setCouplingType(aiChannObj, couplingTypeValue) + + @staticmethod + def getIepeType(aiChannObj): + dll.TAiChannel_getIepeType.restype = c_int + dll.TAiChannel_getIepeType.argtypes = [c_uint64] + return dll.TAiChannel_getIepeType(aiChannObj) + + @staticmethod + def setIepeType(aiChannObj, iepeTypeValue): + dll.TAiChannel_setIepeType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setIepeType(aiChannObj, iepeTypeValue) + + @staticmethod + def getImpedanceType(aiChannObj): + dll.TAiChannel_getImpedanceType.restype = c_int + dll.TAiChannel_getImpedanceType.argtypes = [c_uint64] + return dll.TAiChannel_getImpedanceType(aiChannObj) + + @staticmethod + def setImpedanceType(aiChannObj, impedanceTypeValue): + dll.TAiChannel_setImpedanceType.argtypes = [c_uint64, c_int32] + return dll.TAiChannel_setImpedanceType(aiChannObj, impedanceTypeValue) + + # new: Sensor Scaling + @staticmethod + def getSensorDescription(aiChannObj, pSize, wDescArr): + dll.TAiChannel_getSensorDescription.argtypes = [c_uint64, POINTER(c_int32), c_wchar_p] + return dll.TAiChannel_getSensorDescription(aiChannObj, pSize, wDescArr) + + @staticmethod + def setSensorDescription(aiChannObj, size, wDescArr): + dll.TAiChannel_setSensorDescription.argtypes = [c_uint64, c_int32, c_wchar_p] + return dll.TAiChannel_setSensorDescription(aiChannObj, size, wDescArr) + + # new: scale table + @staticmethod + def getScaleTable(aiChannObj, pSize, mapFuncPieceTable): + dll.TAiChannel_getScaleTable.argtypes = [c_uint64, POINTER(c_int32), POINTER(MapFuncPiece)] + return dll.TAiChannel_getScaleTable(aiChannObj, pSize, mapFuncPieceTable) + + @staticmethod + def setScaleTable(aiChannObj, size, mapFuncPieceTable): + dll.TAiChannel_setScaleTable.argtypes = [c_uint64, c_int32, POINTER(MapFuncPiece)] + return dll.TAiChannel_setScaleTable(aiChannObj, size, mapFuncPieceTable) + + +################################################## +# DIO部分 +################################################## +class TDioCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TDioCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TDioCtrlBase_getFeatures.restype = c_uint64 + return dll.TDioCtrlBase_getFeatures(obj) + + @staticmethod + def getPortCount(obj): + dll.TDioCtrlBase_getPortCount.restype = c_int32 + dll.TDioCtrlBase_getPortCount.argtypes = [c_uint64] + return dll.TDioCtrlBase_getPortCount(obj) + + @staticmethod + def getPorts(obj): + dll.TDioCtrlBase_getPorts.argtypes = [c_uint64] + dll.TDioCtrlBase_getPorts.restype = c_uint64 + return dll.TDioCtrlBase_getPorts(obj) + + +class TInstantDoCtrl(object): + @staticmethod + def writeAny(obj, startPort, portCount, dataArray): + dll.TInstantDoCtrl_WriteAny.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDoCtrl_WriteAny(obj, startPort, portCount, dataArray) + + @staticmethod + def readAny(obj, startPort, portCount, dataArray): + dll.TInstantDoCtrl_ReadAny.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDoCtrl_ReadAny(obj, startPort, portCount, dataArray) + + @staticmethod + def writeBit(obj, port, bit, data): + dll.TInstantDoCtrl_WriteBit.argtypes = [c_uint64, c_int32, c_int32, c_uint8] + return dll.TInstantDoCtrl_WriteBit(obj, port, bit, data) + + @staticmethod + def readBit(obj, port, bit, data): + dll.TInstantDoCtrl_ReadBit.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDoCtrl_ReadBit(obj, port, bit, byref(data)) + + +class TInstantDiCtrl(object): + @staticmethod + def readAny(obj, portStart, portCount, dataArray): + dll.TInstantDiCtrl_ReadAny.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDiCtrl_ReadAny(obj, portStart, portCount, dataArray) + + @staticmethod + def readBit(obj, port, bit, data): + dll.TInstantDiCtrl_ReadBit.argtypes = [c_uint64, c_int32, c_int32, POINTER(c_uint8)] + return dll.TInstantDiCtrl_ReadBit(obj, port, bit, data) + + @staticmethod + def snapStart(obj): + dll.TInstantDiCtrl_SnapStart.argtypes = [c_uint64] + return dll.TInstantDiCtrl_SnapStart(obj) + + @staticmethod + def snapStop(obj): + dll.TInstantDiCtrl_SnapStop.argtypes = [c_uint64] + return dll.TInstantDiCtrl_SnapStop(obj) + + @staticmethod + def getNoiseFilterBlockTime(obj): + dll.TInstantDiCtrl_getNoiseFilterBlockTime.restype = c_double + dll.TInstantDiCtrl_getNoiseFilterBlockTime.argtypes = [c_uint64] + return dll.TInstantDiCtrl_getNoiseFilterBlockTime(obj) + + @staticmethod + def setNoiseFilterBlockTime(obj, value): + dll.TInstantDiCtrl_setNoiseFilterBlockTime.argtypes = [c_uint64, c_double] + return dll.TInstantDiCtrl_setNoiseFilterBlockTime(obj, c_double(value)) + + @staticmethod + def getNoiseFilter(obj): + dll.TInstantDiCtrl_getNoiseFilter.argtypes = [c_uint64] + dll.TInstantDiCtrl_getNoiseFilter.restype = c_uint64 + return dll.TInstantDiCtrl_getNoiseFilter(obj) + + @staticmethod + def getDiintChannels(obj): + dll.TInstantDiCtrl_getDiintChannels.argtypes = [c_uint64] + dll.TInstantDiCtrl_getDiintChannels.restype = c_uint64 + return dll.TInstantDiCtrl_getDiintChannels(obj) + + @staticmethod + def getDiCosintPorts(obj): + dll.TInstantDiCtrl_getDiCosintPorts.argtypes = [c_uint64] + dll.TInstantDiCtrl_getDiCosintPorts.restype = c_uint64 + return dll.TInstantDiCtrl_getDiCosintPorts(obj) + + @staticmethod + def getDiPmintPorts(obj): + dll.TInstantDiCtrl_getDiPmintPorts.argtypes = [c_uint64] + dll.TInstantDiCtrl_getDiPmintPorts.restype = c_uint64 + return dll.TInstantDiCtrl_getDiPmintPorts(obj) + + +class TDioPort(object): + @staticmethod + def getPort(obj): + dll.TDioPort_getPort.restype = c_int32 + dll.TDioPort_getPort.argtypes = [c_uint64] + return dll.TDioPort_getPort(obj) + + @staticmethod + def getDirection(obj): + dll.TDioPort_getDirection.argtypes = [c_uint64] + return dll.TDioPort_getDirection(obj) + + @staticmethod + def setDirection(obj, value): + dll.TDioPort_setDirection.argtypes = [c_uint64, c_int32] + return dll.TDioPort_setDirection(obj, value) + + @staticmethod + def getDiInversePort(obj): + dll.TDioPort_getDiInversePort.restype = c_uint8 + dll.TDioPort_getDiInversePort.argtypes = [c_uint64] + return dll.TDioPort_getDiInversePort(obj) + + @staticmethod + def setDiInversePort(obj, value): + dll.TDioPort_setDiInversePort.argtypes = [c_uint64, c_uint8] + return dll.TDioPort_setDiInversePort(obj, value) + + @staticmethod + def getDiOpenState(obj): + dll.TDioPort_getDiOpenState.restype = c_uint8 + dll.TDioPort_getDiOpenState.argtypes = [c_uint64] + return dll.TDioPort_getDiOpenState(obj) + + @staticmethod + def setDiOpenState(obj, value): + dll.TDioPort_setDiOpenState.argtypes = [c_uint64, c_uint8] + return dll.TDioPort_setDiOpenState(obj, value) + + @staticmethod + def getDoPresetValue(obj): + dll.TDioPort_getDoPresetValue.restype = c_uint8 + dll.TDioPort_getDoPresetValue.argtypes = [c_uint64] + return dll.TDioPort_getDoPresetValue(obj) + + @staticmethod + def setDoPresetValue(obj, value): + dll.TDioPort_setDoPresetValue.argtypes = [c_uint64, c_uint8] + return dll.TDioPort_setDoPresetValue(obj, value) + + @staticmethod + def getDoCircuitType(obj): + dll.TDioPort_getDoCircuitType.argtypes = [c_uint64] + return dll.TDioPort_getDoCircuitType(obj) + + @staticmethod + def setDoCircuitType(obj, value): + dll.TDioPort_setDoCircuitType.argtypes = [c_uint64, c_int32] + return dll.TDioPort_setDoCircuitType(obj, value) + + +class TDiintChannel(object): + @staticmethod + def getChannel(diIntChanObj): + dll.TDiintChannel_getChannel.restype = c_int32 + dll.TDiintChannel_getChannel.argtypes = [c_uint64] + return dll.TDiintChannel_getChannel(diIntChanObj) + + @staticmethod + def getEnabled(diIntChanObj): + dll.TDiintChannel_getEnabled.restype = c_int8 + dll.TDiintChannel_getEnabled.argtypes = [c_uint64] + return dll.TDiintChannel_getEnabled(diIntChanObj) + + @staticmethod + def setEnabled(diIntChanObj, value): + dll.TDiintChannel_setEnabled.argtypes = [c_uint64, c_int8] + return dll.TDiintChannel_setEnabled(diIntChanObj, value) + + @staticmethod + def getGated(diIntChanObj): + dll.TDiintChannel_getGated.restype = c_int8 + dll.TDiintChannel_getGated.argtypes = [c_uint64] + return dll.TDiintChannel_getGated(diIntChanObj) + + @staticmethod + def setGated(diIntChanObj, value): + dll.TDiintChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TDiintChannel_setGated(diIntChanObj, value) + + @staticmethod + def getTrigEdge(diIntChanObj): + dll.TDiintChannel_getTrigEdge.argtypes = [c_uint64] + return dll.TDiintChannel_getTrigEdge(diIntChanObj) + + @staticmethod + def setTrigEdge(diIntChanObj, value): + dll.TDiintChannel_setTrigEdge.argtypes = [c_uint64, c_int32] + return dll.TDiintChannel_setTrigEdge(diIntChanObj, value) + + +class TDiCosintPort(object): + @staticmethod + def getPort(obj): + dll.TDiCosintPort_getPort.restype = c_int32 + dll.TDiCosintPort_getPort.argtypes = [c_uint64] + return dll.TDiCosintPort_getPort(obj) + + @staticmethod + def getMask(obj): + dll.TDiCosintPort_getMask.restype = c_byte + dll.TDiCosintPort_getMask.argtypes = [c_uint64] + return dll.TDiCosintPort_getMask(obj) + + @staticmethod + def setMask(obj, value): + dll.TDiCosintPort_setMask.argtypes = [c_uint64, c_uint8] + return dll.TDiCosintPort_setMask(obj, value) + + +class TDiPmintPort(object): + @staticmethod + def getPort(obj): + dll.TDiPmintPort_getPort.restype = c_int32 + dll.TDiPmintPort_getPort.argtypes = [c_uint64] + return dll.TDiPmintPort_getPort(obj) + + @staticmethod + def getMask(obj): + dll.TDiPmintPort_getMask.restype = c_uint8 + dll.TDiPmintPort_getMask.argtypes = [c_uint64] + return dll.TDiPmintPort_getMask(obj) + + @staticmethod + def setMask(obj, value): + dll.TDiPmintPort_setMask.argtypes = [c_uint64, c_uint8] + return dll.TDiPmintPort_setMask(obj, value) + + @staticmethod + def getPattern(obj): + dll.TDiPmintPort_getPattern.restype = c_uint8 + dll.TDiPmintPort_getPattern.argtypes = [c_uint64] + return dll.TDiPmintPort_getPattern(obj) + + @staticmethod + def setPattern(obj, value): + dll.TDiPmintPort_setPattern.argtypes = [c_uint64, c_uint8] + return dll.TDiPmintPort_setPattern(obj, value) + + +class TDioFeatures(object): + @staticmethod + def getPortProgrammable(obj): + dll.TDioFeatures_getPortProgrammable.restype = c_int8 + dll.TDioFeatures_getPortProgrammable.argtypes = [c_uint64] + return dll.TDioFeatures_getPortProgrammable(obj) + + @staticmethod + def getChannelCountMax(obj): + dll.TDioFeatures_getChannelCountMax.restype = c_int32 + dll.TDioFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TDioFeatures_getChannelCountMax(obj) + + @staticmethod + def getPortCount(obj): + dll.TDioFeatures_getPortCount.restype = c_int32 + dll.TDioFeatures_getPortCount.argtypes = [c_uint64] + return dll.TDioFeatures_getPortCount(obj) + + @staticmethod + def getPortsType(obj): + dll.TDioFeatures_getPortsType.argtypes = [c_uint64] + dll.TDioFeatures_getPortsType.restype = c_uint64 + return dll.TDioFeatures_getPortsType(obj) + + @staticmethod + def getDiSupported(obj): + dll.TDioFeatures_getDiSupported.restype = c_int8 + dll.TDioFeatures_getDiSupported.argtypes = [c_uint64] + return dll.TDioFeatures_getDiSupported(obj) + + @staticmethod + def getDoSupported(obj): + dll.TDioFeatures_getDoSupported.restype = c_int8 + dll.TDioFeatures_getDoSupported.argtypes = [c_uint64] + return dll.TDioFeatures_getDoSupported(obj) + + @staticmethod + def getDiDataMask(obj): + dll.TDioFeatures_getDiDataMask.argtypes = [c_uint64] + dll.TDioFeatures_getDiDataMask.restype = c_uint64 + return dll.TDioFeatures_getDiDataMask(obj) + + @staticmethod + def getDiNoiseFilterSupported(obj): + dll.TDioFeatures_getDiNoiseFilterSupported.restype = c_int8 + dll.TDioFeatures_getDiNoiseFilterSupported.argtypes = [c_uint64] + return dll.TDioFeatures_getDiNoiseFilterSupported(obj) + + @staticmethod + def getDiNoiseFilterOfChannels(obj): + dll.TDioFeatures_getDiNoiseFilterOfChannels.argtypes = [c_uint64] + dll.TDioFeatures_getDiNoiseFilterOfChannels.restype = c_uint64 + return dll.TDioFeatures_getDiNoiseFilterOfChannels(obj) + + @staticmethod + def getDiNoiseFilterBlockTimeRange(obj, mathIntervalValue): + dll.TDioFeatures_getDiNoiseFilterBlockTimeRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TDioFeatures_getDiNoiseFilterBlockTimeRange(obj, mathIntervalValue) + + @staticmethod + def getDoDataMask(obj): + dll.TDioFeatures_getDoDataMask.argtypes = [c_uint64] + return dll.TDioFeatures_getDoDataMask(obj) + + @staticmethod + def getDoFreezeSignalSources(obj): + dll.TDioFeatures_getDoFreezeSignalSources.argtypes = [c_uint64] + return dll.TDioFeatures_getDoFreezeSignalSources(obj) + + @staticmethod + def getDoReflectWdtFeedIntervalRange(obj, mathInterValValue): + dll.TDioFeatures_getDoReflectWdtFeedIntervalRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TDioFeatures_getDoReflectWdtFeedIntervalRange(obj, mathInterValValue) + + @staticmethod + def getDoPresetValueDepository(obj): + dll.TDioFeatures_getDoPresetValueDepository.argtypes = [c_uint64] + return dll.TDioFeatures_getDoPresetValueDepository(obj) + + @staticmethod + def getDoCircuitSelectableTypes(obj): + dll.TDioFeatures_getDoCircuitSelectableTypes.argtypes = [c_uint64] + return dll.TDioFeatures_getDoCircuitSelectableTypes(obj) + + +class TCounterIndexer(object): + @staticmethod + def getLength(obj): + dll.TCounterIndexer_getLength.restype = c_int32 + dll.TCounterIndexer_getLength.argtypes = [c_uint64] + return dll.TCounterIndexer_getLength(obj) + + @staticmethod + def getItem(obj, index): + dll.TCounterIndexer_getItem.argtypes = [c_uint64, c_int32] + dll.TCounterIndexer_getItem.restype = c_uint64 + return dll.TCounterIndexer_getItem(obj, index) + + @staticmethod + def dispose(obj): + dll.TCounterIndexer_Dispose.argtypes = [c_uint64] + dll.TCounterIndexer_Dispose(obj) + + +class TCntrFeatures(object): + @staticmethod + def getChannelCountMax(obj): + dll.TCntrFeatures_getChannelCountMax.restype = c_int32 + dll.TCntrFeatures_getChannelCountMax.argtypes = [c_uint64] + return dll.TCntrFeatures_getChannelCountMax(obj) + + @staticmethod + def getResolution(obj): + dll.TCntrFeatures_getResolution.restype = c_int32 + dll.TCntrFeatures_getResolution.argtypes = [c_uint64] + return dll.TCntrFeatures_getResolution(obj) + + @staticmethod + def getDataSize(obj): + dll.TCntrFeatures_getDataSize.restype = c_int32 + dll.TCntrFeatures_getDataSize.argtypes = [c_uint64] + return dll.TCntrFeatures_getDataSize(obj) + + @staticmethod + def getCapabilities(obj): + dll.TCntrFeatures_getCapabilities.argtypes = [c_uint64] + dll.TCntrFeatures_getCapabilities.restype = c_uint64 + return dll.TCntrFeatures_getCapabilities(obj) + + # noise filter features + @staticmethod + def getNoiseFilterSupported(obj): + dll.TCntrFeatures_getNoiseFilterSupported.restype = c_int8 + dll.TCntrFeatures_getNoiseFilterSupported.argtypes = [c_uint64] + return dll.TCntrFeatures_getNoiseFilterSupported(obj) + + @staticmethod + def getNoiseFilterOfChannels(obj): + dll.TCntrFeatures_getNoiseFilterOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getNoiseFilterOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getNoiseFilterOfChannels(obj) + + @staticmethod + def getNoiseFilterBlockTimeRange(obj, x): + dll.TCntrFeatures_getNoiseFilterBlockTimeRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getNoiseFilterBlockTimeRange(obj, byref(x)) + + # event counting features + @staticmethod + def getEcClockSources(obj): + dll.TCntrFeatures_getEcClockSources.argtypes = [c_uint64] + dll.TCntrFeatures_getEcClockSources.restype = c_uint64 + return dll.TCntrFeatures_getEcClockSources(obj) + + @staticmethod + def getEcClockPolarities(obj): + dll.TCntrFeatures_getEcClockPolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getEcClockPolarities.restype = c_uint64 + return dll.TCntrFeatures_getEcClockPolarities(obj) + + @staticmethod + def getEcGatePolarities(obj): + dll.TCntrFeatures_getEcGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getEcGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getEcGatePolarities(obj) + + @staticmethod + def getEcGateControlOfChannels(obj): + dll.TCntrFeatures_getEcGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getEcGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getEcGateControlOfChannels(obj) + + # frequency measurement features + @staticmethod + def getFmMethods(obj): + dll.TCntrFeatures_getFmMethods.argtypes = [c_uint64] + dll.TCntrFeatures_getFmMethods.restype = c_uint64 + return dll.TCntrFeatures_getFmMethods(obj) + + # one-shot features + @staticmethod + def getOsClockSources(obj): + dll.TCntrFeatures_getOsClockSources.argtypes = [c_uint64] + dll.TCntrFeatures_getOsClockSources.restype = c_uint64 + return dll.TCntrFeatures_getOsClockSources(obj) + + @staticmethod + def getOsClockPolarities(obj): + dll.TCntrFeatures_getOsClockPolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getOsClockPolarities.restype = c_uint64 + return dll.TCntrFeatures_getOsClockPolarities(obj) + + @staticmethod + def getOsGateSources(obj): + dll.TCntrFeatures_getOsGateSources.argtypes = [c_uint64] + dll.TCntrFeatures_getOsGateSources.restype = c_uint64 + return dll.TCntrFeatures_getOsGateSources(obj) + + @staticmethod + def getOsGatePolarities(obj): + dll.TCntrFeatures_getOsGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getOsGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getOsGatePolarities(obj) + + @staticmethod + def getOsOutSignals(obj): + dll.TCntrFeatures_getOsOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getOsOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getOsOutSignals(obj) + + @staticmethod + def getOsDelayCountRange(obj, x): + dll.TCntrFeatures_getOsDelayCountRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getOsDelayCountRange(obj, byref(x)) + + # Timer/pulse features + @staticmethod + def getTmrGateControlOfChannels(obj): + dll.TCntrFeatures_getTmrGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getTmrGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getTmrGateControlOfChannels(obj) + + @staticmethod + def getTmrGatePolarities(obj): + dll.TCntrFeatures_getTmrGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getTmrGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getTmrGatePolarities(obj) + + @staticmethod + def getTmrOutSignals(obj): + dll.TCntrFeatures_getTmrOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getTmrOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getTmrOutSignals(obj) + + @staticmethod + def getTmrFrequencyRange(obj, x): + dll.TCntrFeatures_getTmrFrequencyRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getTmrFrequencyRange(obj, byref(x)) + + # pulse width measurement features + @staticmethod + def getPiCascadeGroup(obj): + dll.TCntrFeatures_getPiCascadeGroup.argtypes = [c_uint64] + dll.TCntrFeatures_getPiCascadeGroup.restype = c_uint64 + return dll.TCntrFeatures_getPiCascadeGroup(obj) + + # pulse width modulation features + @staticmethod + def getPoGateControlOfChannels(obj): + dll.TCntrFeatures_getPoGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getPoGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getPoGateControlOfChannels(obj) + + @staticmethod + def getPoGatePolarities(obj): + dll.TCntrFeatures_getPoGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getPoGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getPoGatePolarities(obj) + + @staticmethod + def getPoOutSignals(obj): + dll.TCntrFeatures_getPoOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getPoOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getPoOutSignals(obj) + + @staticmethod + def getPoHiPeriodRange(obj, x): + dll.TCntrFeatures_getPoHiPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getPoHiPeriodRange(obj, byref(x)) + + @staticmethod + def getPoLoPeriodRange(obj, x): + dll.TCntrFeatures_getPoLoPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getPoLoPeriodRange(obj, byref(x)) + + @staticmethod + def getPoOutCountRange(obj, x): + dll.TCntrFeatures_getPoOutCountRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getPoOutCountRange(obj, byref(x)) + + # Up-down counter features + @staticmethod + def getUdCountingTypes(obj): + dll.TCntrFeatures_getUdCountingTypes.argtypes = [c_uint64] + dll.TCntrFeatures_getUdCountingTypes.restype = c_uint64 + return dll.TCntrFeatures_getUdCountingTypes(obj) + + @staticmethod + def getUdInitialValues(obj): + dll.TCntrFeatures_getUdInitialValues.argtypes = [c_uint64] + dll.TCntrFeatures_getUdInitialValues.restype = c_uint64 + return dll.TCntrFeatures_getUdInitialValues(obj) + + @staticmethod + def getUdSnapEventSources(obj): + dll.TCntrFeatures_getUdSnapEventSources.argtypes = [c_uint64] + dll.TCntrFeatures_getUdSnapEventSources.restype = c_uint64 + return dll.TCntrFeatures_getUdSnapEventSources(obj) + + # new: measurement timeout range + @staticmethod + def getMeasurementTimeoutRange(obj, x): + dll.TCntrFeatures_getMeasurementTimeoutRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getMeasurementTimeoutRange(obj, byref(x)) + + @staticmethod + def getUdValueResetTimes(obj, x): + dll.TCntrFeatures_getUdValueResetTimes.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getUdValueResetTimes(obj, byref(x)) + + # Counter continue comparing: outputting pulse settings + @staticmethod + def getCcpGateControlOfChannels(obj): + dll.TCntrFeatures_getCcpGateControlOfChannels.argtypes = [c_uint64] + dll.TCntrFeatures_getCcpGateControlOfChannels.restype = c_uint64 + return dll.TCntrFeatures_getCcpGateControlOfChannels(obj) + + @staticmethod + def getCcpGatePolarities(obj): + dll.TCntrFeatures_getCcpGatePolarities.argtypes = [c_uint64] + dll.TCntrFeatures_getCcpGatePolarities.restype = c_uint64 + return dll.TCntrFeatures_getCcpGatePolarities(obj) + + @staticmethod + def getCcpOutSignals(obj): + dll.TCntrFeatures_getCcpOutSignals.argtypes = [c_uint64] + dll.TCntrFeatures_getCcpOutSignals.restype = c_uint64 + return dll.TCntrFeatures_getCcpOutSignals(obj) + + @staticmethod + def getCcpHiPeriodRange(obj, x): + dll.TCntrFeatures_getCcpHiPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getCcpHiPeriodRange(obj, byref(x)) + + @staticmethod + def getCcpLoPeriodRange(obj, x): + dll.TCntrFeatures_getCcpLoPeriodRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getCcpLoPeriodRange(obj, byref(x)) + + @staticmethod + def getCcpOutCountRange(obj, x): + dll.TCntrFeatures_getCcpOutCountRange.argtypes = [c_uint64, POINTER(MathInterval)] + return dll.TCntrFeatures_getCcpOutCountRange(obj, byref(x)) + + +class TCntrCtrlBase(object): + @staticmethod + def getFeatures(obj): + dll.TCntrCtrlBase_getFeatures.argtypes = [c_uint64] + dll.TCntrCtrlBase_getFeatures.restype = c_uint64 + return dll.TCntrCtrlBase_getFeatures(obj) + + @staticmethod + def getChannelStart(obj): + dll.TCntrCtrlBase_getChannelStart.restype = c_int32 + dll.TCntrCtrlBase_getChannelStart.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getChannelStart(obj) + + @staticmethod + def setChannelStart(obj, value): + dll.TCntrCtrlBase_setChannelStart.argtypes = [c_uint64, c_int32] + return dll.TCntrCtrlBase_setChannelStart(obj, value) + + @staticmethod + def getChannelCount(obj): + dll.TCntrCtrlBase_getChannelCount.restype = c_int32 + dll.TCntrCtrlBase_getChannelCount.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getChannelCount(obj) + + @staticmethod + def setChannelCount(obj, value): + dll.TCntrCtrlBase_setChannelCount.argtypes = [c_uint64, c_int32] + return dll.TCntrCtrlBase_setChannelCount(obj, value) + + @staticmethod + def getEnabled(obj): + dll.TCntrCtrlBase_getEnabled.restype = c_int8 + dll.TCntrCtrlBase_getEnabled.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getEnabled(obj) + + @staticmethod + def setEnabled(obj, value): + dll.TCntrCtrlBase_setEnabled.argtypes = [c_uint64, c_int8] + return dll.TCntrCtrlBase_setEnabled(obj, value) + + @staticmethod + def getRunning(obj): + dll.TCntrCtrlBase_getRunning.restype = c_int8 + dll.TCntrCtrlBase_getRunning.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getRunning(obj) + + @staticmethod + def getNoiseFilterBlockTime(obj): + dll.TCntrCtrlBase_getNoiseFilterBlockTime.restype = c_double + dll.TCntrCtrlBase_getNoiseFilterBlockTime.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getNoiseFilterBlockTime(obj) + + @staticmethod + def setNoiseFilterBlockTime(obj, value): + dll.TCntrCtrlBase_setNoiseFilterBlockTime.argtypes = [c_uint64, c_double] + return dll.TCntrCtrlBase_setNoiseFilterBlockTime(obj, c_double(value)) + + @staticmethod + def getNoiseFilter(obj): + dll.TCntrCtrlBase_getNoiseFilter.argtypes = [c_uint64] + dll.TCntrCtrlBase_getNoiseFilter.restype = c_uint64 + return dll.TCntrCtrlBase_getNoiseFilter(obj) + + @staticmethod + def getMeasurementTimeout(obj): + dll.TCntrCtrlBase_getMeasurementTimeout.restype = c_double + dll.TCntrCtrlBase_getMeasurementTimeout.argtypes = [c_uint64] + return dll.TCntrCtrlBase_getMeasurementTimeout(obj) + + @staticmethod + def setMeasurementTimeout(obj, value): + dll.TCntrCtrlBase_setMeasurementTimeout.argtypes = [c_uint64, c_double] + return dll.TCntrCtrlBase_setMeasurementTimeout(obj, c_double(value)) + + +class TEcChannel(object): + @staticmethod + def getChannel(obj): + dll.TEcChannel_getChannel.restype = c_int32 + dll.TEcChannel_getChannel.argtypes = [c_uint64] + return dll.TEcChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TEcChannel_getNoiseFiltered.restype = c_int8 + dll.TEcChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TEcChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TEcChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TEcChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getClockSource(obj): + dll.TEcChannel_getClockSource.argtypes = [c_uint64] + return dll.TEcChannel_getClockSource(obj) + + @staticmethod + def setClockSource(obj, value): + dll.TEcChannel_setClockSource.argtypes = [c_uint64, c_int32] + return dll.TEcChannel_setClockSource(obj, value) + + @staticmethod + def getClockPolarity(obj): + dll.TEcChannel_getClockPolarity.argtypes = [c_uint64] + return dll.TEcChannel_getClockPolarity(obj) + + @staticmethod + def setClockPolarity(obj, value): + dll.TEcChannel_setClockPolarity.argtypes = [c_uint64, c_int32] + return dll.TEcChannel_setClockPolarity(obj, value) + + @staticmethod + def getGatePolarity(obj): + dll.TEcChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TEcChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TEcChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TEcChannel_setGatePolarity(obj, value) + + @staticmethod + def getGated(obj): + dll.TEcChannel_getGated.restype = c_int8 + dll.TEcChannel_getGated.argtypes = [c_uint64] + return dll.TEcChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TEcChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TEcChannel_setGated(obj, value) + + +class TEventCounterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TEventCounterCtrl_getChannels.argtypes = [c_uint64] + dll.TEventCounterCtrl_getChannels.restype = c_uint64 + return dll.TEventCounterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, buffer): + dll.TEventCounterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(c_int32)] + return dll.TEventCounterCtrl_Read(obj, count, buffer) + + +class TFmChannel(object): + @staticmethod + def getChannel(obj): + dll.TFmChannel_getChannel.restype = c_int32 + dll.TFmChannel_getChannel.argtypes = [c_uint64] + return dll.TFmChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TFmChannel_getNoiseFiltered.restype = c_int8 + dll.TFmChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TFmChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TFmChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TFmChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getFmMethod(obj): + dll.TFmChannel_getFmMethod.argtypes = [c_uint64] + return dll.TFmChannel_getFmMethod(obj) + + @staticmethod + def setFmMethod(obj, value): + dll.TFmChannel_setFmMethod.argtypes = [c_uint64, c_int32] + return dll.TFmChannel_setFmMethod(obj, value) + + @staticmethod + def getCollectionPeriod(obj): + dll.TFmChannel_getCollectionPeriod.restype = c_double + dll.TFmChannel_getCollectionPeriod.argtypes = [c_uint64] + return dll.TFmChannel_getCollectionPeriod(obj) + + @staticmethod + def setCollectionPeriod(obj, value): + dll.TFmChannel_setCollectionPeriod.argtypes = [c_uint64, c_double] + return dll.TFmChannel_setCollectionPeriod(obj, c_double(value)) + + +class TFreqMeterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TFreqMeterCtrl_getChannels.argtypes = [c_uint64] + dll.TFreqMeterCtrl_getChannels.restype = c_uint64 + return dll.TFreqMeterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, data): + dll.TFreqMeterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(c_double)] + return dll.TFreqMeterCtrl_Read(obj, count, data) + + +class TPiChannel(object): + @staticmethod + def getChannel(obj): + dll.TPiChannel_getChannel.restype = c_int32 + dll.TPiChannel_getChannel.argtypes = [c_uint64] + return dll.TPiChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TPiChannel_getNoiseFiltered.restype = c_int8 + dll.TPiChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TPiChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TPiChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TPiChannel_setNoiseFiltered(obj, value) + + +class TPwMeterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TPwMeterCtrl_getChannels.argtypes = [c_uint64] + dll.TPwMeterCtrl_getChannels.restype = c_uint64 + return dll.TPwMeterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, buffer): + dll.TPwMeterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(PulseWidth)] + return dll.TPwMeterCtrl_Read(obj, count, buffer) + + +class TPoChannel(object): + @staticmethod + def getChannel(obj): + dll.TPoChannel_getChannel.restype = c_int32 + dll.TPoChannel_getChannel.argtypes = [c_uint64] + return dll.TPoChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TPoChannel_getNoiseFiltered.restype = c_int8 + dll.TPoChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TPoChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TPoChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TPoChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getPulseWidth(obj, pulseWidth): + dll.TPoChannel_getPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TPoChannel_getPulseWidth(obj, byref(pulseWidth)) + + @staticmethod + def setPulseWidth(obj, pulseWidthValue): + dll.TPoChannel_setPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TPoChannel_setPulseWidth(obj, byref(pulseWidthValue)) + + @staticmethod + def getGatePolarity(obj): + dll.TPoChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TPoChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, signPolarValue): + dll.TPoChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TPoChannel_setGatePolarity(obj, signPolarValue) + + @staticmethod + def getGated(obj): + dll.TPoChannel_getGated.restupe = c_int8 + dll.TPoChannel_getGated.argtypes = [c_uint64] + return dll.TPoChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TPoChannel_setGated.argtypes = [c_uint64] + return dll.TPoChannel_setGated(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TPoChannel_getOutSignal.argtypes = [c_uint64] + return dll.TPoChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, outSignTypeValue): + dll.TPoChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TPoChannel_setOutSignal(obj, outSignTypeValue) + + @staticmethod + def getOutCount(obj): + dll.TPoChannel_getOutCount.restype = c_int32 + dll.TPoChannel_getOutCount.argtypes = [c_uint64] + return dll.TPoChannel_getOutCount(obj) + + @staticmethod + def setOutCount(obj, value): + dll.TPoChannel_setOutCount.argtypes = [c_uint64, c_int32] + return dll.TPoChannel_setOutCount(obj, value) + + +class TPwModulatorCtrl(object): + @staticmethod + def getChannels(obj): + dll.TPwModulatorCtrl_getChannels.argtypes = [c_uint64] + dll.TPwModulatorCtrl_getChannels.restype = c_uint64 + return dll.TPwModulatorCtrl_getChannels(obj) + +class TOsChannel(object): + @staticmethod + def getChannel(obj): + dll.TOsChannel_getChannel.restype = c_int32 + dll.TOsChannel_getChannel.argtypes = [c_uint64] + return dll.TOsChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TOsChannel_getNoiseFiltered.restype = c_int8 + dll.TOsChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TOsChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TOsChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TOsChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getDelayCount(obj): + dll.TOsChannel_getDelayCount.restype = c_int32 + dll.TOsChannel_getDelayCount.argtypes = [c_uint64] + return dll.TOsChannel_getDelayCount(obj) + + @staticmethod + def setDelayCount(obj, value): + dll.TOsChannel_setDelayCount.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setDelayCount(obj, value) + + @staticmethod + def getClockSource(obj): + dll.TOsChannel_getClockSource.argtypes = [c_uint64] + return dll.TOsChannel_getClockSource(obj) + + @staticmethod + def setClockSource(obj, value): + dll.TOsChannel_setClockSource.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setClockSource(obj, value) + + @staticmethod + def getClockPolarity(obj): + dll.TOsChannel_getClockPolarity.argtypes = [c_uint64] + return dll.TOsChannel_getClockPolarity(obj) + + @staticmethod + def setClockPolarity(obj, value): + dll.TOsChannel_setClockPolarity.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setClockPolarity(obj, value) + + @staticmethod + def getGateSource(obj): + dll.TOsChannel_getGateSource.argtypes = [c_uint64] + return dll.TOsChannel_getGateSource(obj) + + @staticmethod + def setGateSource(obj, value): + dll.TOsChannel_setGateSource.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setGateSource(obj, value) + + @staticmethod + def getGatePolarity(obj): + dll.TOsChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TOsChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TOsChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setGatePolarity(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TOsChannel_getOutSignal.argtypes = [c_uint64] + return dll.TOsChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, value): + dll.TOsChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TOsChannel_setOutSignal(obj, value) + + +class TOneShotCtrl(object): + @staticmethod + def getChannels(obj): + dll.TOneShotCtrl_getChannels.argtypes = [c_uint64] + dll.TOneShotCtrl_getChannels.restype = c_uint64 + return dll.TOneShotCtrl_getChannels(obj) + + +class TTmrChannel(object): + @staticmethod + def getChannel(obj): + dll.TTmrChannel_getChannel.restype = c_int32 + dll.TTmrChannel_getChannel.argtypes = [c_uint64] + return dll.TTmrChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TTmrChannel_getNoiseFiltered.restype = c_int8 + dll.TTmrChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TTmrChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TTmrChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TTmrChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getFrequency(obj): + dll.TTmrChannel_getFrequency.restype = c_double + dll.TTmrChannel_getFrequency.argtypes = [c_uint64] + return dll.TTmrChannel_getFrequency(obj) + + @staticmethod + def setFrequency(obj, value): + dll.TTmrChannel_setFrequency.argtypes = [c_uint64, c_double] + return dll.TTmrChannel_setFrequency(obj, c_double(value)) + + @staticmethod + def getGatePolarity(obj): + dll.TTmrChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TTmrChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TTmrChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TTmrChannel_setGatePolarity(obj, value) + + @staticmethod + def getGated(obj): + dll.TTmrChannel_getGated.restype = c_int8 + dll.TTmrChannel_getGated.argtypes = [c_uint64] + return dll.TTmrChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TTmrChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TTmrChannel_setGated(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TTmrChannel_getOutSignal.argtypes = [c_uint64] + return dll.TTmrChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, value): + dll.TTmrChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TTmrChannel_setOutSignal(obj, value) + + +class TTimerPulseCtrl(object): + @staticmethod + def getChannels(obj): + dll.TTimerPulseCtrl_getChannels.argtypes = [c_uint64] + dll.TTimerPulseCtrl_getChannels.restype = c_uint64 + return dll.TTimerPulseCtrl_getChannels(obj) + + +class TUdChannel(object): + @staticmethod + def getChannel(obj): + dll.TUdChannel_getChannel.restype = c_int32 + dll.TUdChannel_getChannel.argtypes = [c_uint64] + return dll.TUdChannel_getChannel(obj) + + @staticmethod + def getNoiseFiltered(obj): + dll.TUdChannel_getNoiseFiltered.restype = c_int8 + dll.TUdChannel_getNoiseFiltered.argtypes = [c_uint64] + return dll.TUdChannel_getNoiseFiltered(obj) + + @staticmethod + def setNoiseFiltered(obj, value): + dll.TUdChannel_setNoiseFiltered.argtypes = [c_uint64, c_int8] + return dll.TUdChannel_setNoiseFiltered(obj, value) + + @staticmethod + def getCountingType(obj): + dll.TUdChannel_getCountingType.argtypes = [c_uint64] + return dll.TUdChannel_getCountingType(obj) + + @staticmethod + def setCountingType(obj, value): + dll.TUdChannel_setCountingType.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setCountingType(obj, value) + + @staticmethod + def getInitialValue(obj): + dll.TUdChannel_getInitialValue.restype = c_int32 + dll.TUdChannel_getInitialValue.argtypes = [c_uint64] + return dll.TUdChannel_getInitialValue(obj) + + @staticmethod + def setInitialValue(obj, value): + dll.TUdChannel_setInitialValue.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setInitialValue(obj, value) + + @staticmethod + def getResetTimesByIndex(obj): + dll.TUdChannel_getResetTimesByIndex.restype = c_int32 + dll.TUdChannel_getResetTimesByIndex.argtypes = [c_uint64] + return dll.TUdChannel_getResetTimesByIndex(obj) + + @staticmethod + def setResetTimesByIndex(obj, value): + dll.TUdChannel_setResetTimesByIndex.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setResetTimesByIndex(obj, value) + + @staticmethod + def getPulseWidth(obj, width): + dll.TUdChannel_getPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TUdChannel_getPulseWidth(obj, byref(width)) + + @staticmethod + def setPulseWidth(obj, width): + dll.TUdChannel_setPulseWidth.restype = c_uint32 + dll.TUdChannel_setPulseWidth.argtypes = [c_uint64, POINTER(PulseWidth)] + return dll.TUdChannel_setPulseWidth(obj, byref(width)) + + @staticmethod + def getGated(obj): + dll.TUdChannel_getGated.restype = c_int8 + dll.TUdChannel_getGated.argtypes = [c_uint64] + return dll.TUdChannel_getGated(obj) + + @staticmethod + def setGated(obj, value): + dll.TUdChannel_setGated.argtypes = [c_uint64, c_int8] + return dll.TUdChannel_setGated(obj, value) + + @staticmethod + def getGatePolarity(obj): + dll.TUdChannel_getGatePolarity.argtypes = [c_uint64] + return dll.TUdChannel_getGatePolarity(obj) + + @staticmethod + def setGatePolarity(obj, value): + dll.TUdChannel_setGatePolarity.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setGatePolarity(obj, value) + + @staticmethod + def getOutSignal(obj): + dll.TUdChannel_getOutSignal.argtypes = [c_uint64] + return dll.TUdChannel_getOutSignal(obj) + + @staticmethod + def setOutSignal(obj, value): + dll.TUdChannel_setOutSignal.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setOutSignal(obj, value) + + @staticmethod + def getOutCount(obj): + dll.TUdChannel_getOutCount.restype = c_int32 + dll.TUdChannel_getOutCount.argtypes = [c_uint64] + return dll.TUdChannel_getOutCount(obj) + + @staticmethod + def setOutCount(obj, value): + dll.TUdChannel_setOutCount.argtypes = [c_uint64, c_int32] + return dll.TUdChannel_setOutCount(obj, value) + + +class TUdCounterCtrl(object): + @staticmethod + def getChannels(obj): + dll.TUdCounterCtrl_getChannels.argtypes = [c_uint64] + dll.TUdCounterCtrl_getChannels.restype = c_uint64 + return dll.TUdCounterCtrl_getChannels(obj) + + @staticmethod + def Read(obj, count, buffer): + dll.TUdCounterCtrl_Read.argtypes = [c_uint64, c_int32, POINTER(c_int32)] + return dll.TUdCounterCtrl_Read(obj, count, buffer) + + @staticmethod + def ValueReset(obj): + dll.TUdCounterCtrl_ValueReset.argtypes = [c_uint64] + return dll.TUdCounterCtrl_ValueReset(obj) + + + + + + diff --git a/src/components/Automation/BDaq/BufferedAoCtrl.py b/src/components/Automation/BDaq/BufferedAoCtrl.py new file mode 100644 index 0000000..b623ae1 --- /dev/null +++ b/src/components/Automation/BDaq/BufferedAoCtrl.py @@ -0,0 +1,84 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq.AoCtrlBase import AoCtrlBase +from Automation.BDaq import Scenario, ErrorCode, MAX_TRIG_COUNT +from Automation.BDaq.ScanChannel import ScanChannel +from Automation.BDaq.ConvertClock import ConvertClock +from Automation.BDaq.BDaqApi import TBufferedAoCtrl, BioFailed +from Automation.BDaq.Trigger import Trigger + + +class BufferedAoCtrl(AoCtrlBase): + def __init__(self, devInfo = None): + super(BufferedAoCtrl, self).__init__(Scenario.SceBufferedAo, devInfo) + self._scanChannObj = None + self._cnvtClockObj = None + self._triggers = [] + + # property + @property + def scanChannel(self): + if self._scanChannObj is None: + self._scanChannObj = ScanChannel(TBufferedAoCtrl.getScanChannel(self._obj)) + return self._scanChannObj + + @property + def convertClock(self): + if self._cnvtClockObj is None: + self._cnvtClockObj = ConvertClock(TBufferedAoCtrl.getConvertClock(self._obj)) + return self._cnvtClockObj + + @property + def streaming(self): + if self.features.bufferedAoSupported: + return TBufferedAoCtrl.getStreaming(self._obj) + + @streaming.setter + def streaming(self, value): + if self.features.bufferedAoSupported: + ret = ErrorCode.lookup(TBufferedAoCtrl.setStreaming(self._obj, value)) + if BioFailed(ret): + raise ValueError('set streaming is failed, the error code is 0x%X' % (ret.value)) + + @property + def trigger(self): + if not self._triggers: + self._triggers = [None] * MAX_TRIG_COUNT + + for i in range(self.features.triggerCount): + self._triggers[i] = Trigger(TBufferedAoCtrl.getTrigger(self._obj, i)) + return self._triggers + + # method + def prepare(self): + return ErrorCode.lookup(TBufferedAoCtrl.Prepare(self._obj)) + + def runOnce(self): + return ErrorCode.lookup(TBufferedAoCtrl.RunOnce(self._obj)) + + def start(self): + return ErrorCode.lookup(TBufferedAoCtrl.Start(self._obj)) + + def stop(self, value): + return ErrorCode.lookup(TBufferedAoCtrl.Stop(self._obj, value)) + + def setDataF64(self, count, scaledData): + doubleArray = (c_double * count)() + for i in range(count): + doubleArray[i] = scaledData[i] + return ErrorCode.lookup(TBufferedAoCtrl.SetData(self._obj, 8, count, doubleArray)) + + def setDataI32(self, count, rawData): + intArray = (c_int32 * count)() + for i in range(count): + intArray[i] = rawData[i] + return ErrorCode.lookup(TBufferedAoCtrl.SetData(self._obj, 4, count, intArray)) + + def setDatai16(self, count, rawData): + shortArray = (c_int16 * count)() + for i in range(count): + shortArray[i] = rawData[i] + return ErrorCode.lookup(TBufferedAoCtrl.SetData(self._obj, 2, count, shortArray)) diff --git a/src/components/Automation/BDaq/CjcSetting.py b/src/components/Automation/BDaq/CjcSetting.py new file mode 100644 index 0000000..fc1404b --- /dev/null +++ b/src/components/Automation/BDaq/CjcSetting.py @@ -0,0 +1,48 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.BDaqApi import TCjcSetting, BioFailed +from Automation.BDaq import ErrorCode + + +class CjcSetting(object): + def __init__(self, nativeCjcSetting): + self._cjcObj = nativeCjcSetting + + @property + def channel(self): + return TCjcSetting.getChannel(self._cjcObj) + + @channel.setter + def channel(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TCjcSetting.setChannel(self._cjcObj, value)) + if BioFailed(ret): + raise ValueError('set channel is failed, the error code is 0x%X' % (ret.value)) + + @property + def value(self): + return TCjcSetting.getValue(self._cjcObj) + + @value.setter + def value(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCjcSetting.setValue(self._cjcObj, value)) + if BioFailed(ret): + raise ValueError('set value is failed, the error code is 0x%X' % (ret.value)) + + @property + def updateFrequency(self): + return TCjcSetting.getUpdateFreq(self._cjcObj) + + @updateFrequency.setter + def updateFrequency(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCjcSetting.setUpdateFreq(self._cjcObj, value)) + if BioFailed(ret): + raise ValueError('set updateFrequency is failed, the error code is 0x%X' % (ret.value)) + diff --git a/src/components/Automation/BDaq/CntrCtrlBase.py b/src/components/Automation/BDaq/CntrCtrlBase.py new file mode 100644 index 0000000..5758ff6 --- /dev/null +++ b/src/components/Automation/BDaq/CntrCtrlBase.py @@ -0,0 +1,95 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.CntrFeatures import CntrFeatures +from Automation.BDaq.BDaqApi import TCntrCtrlBase, BioFailed +from Automation.BDaq.NosFltChannel import NosFltChannel +from Automation.BDaq import ErrorCode + + +class CntrCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(CntrCtrlBase, self).__init__(scenario, devInfo) + self._cntr_features = None + + @property + def features(self): + if self._cntr_features is None: + self._cntr_features = CntrFeatures(TCntrCtrlBase.getFeatures(self._obj)) + return self._cntr_features + + @property + def channelStart(self): + return TCntrCtrlBase.getChannelStart(self._obj) + + @channelStart.setter + def channelStart(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setChannelStart(self._obj, value)) + if BioFailed(ret): + raise ValueError('set channelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelCount(self): + return TCntrCtrlBase.getChannelCount(self._obj) + + @channelCount.setter + def channelCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setChannelCount(self._obj, value)) + if BioFailed(ret): + raise ValueError('set channelCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def enabled(self): + value = TCntrCtrlBase.getEnabled(self._obj) + return value != 0 + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + # value = 1 if value else 0 + ret = ErrorCode.lookup(TCntrCtrlBase.setEnabled(self._obj, value)) + if BioFailed(ret): + raise ValueError('set enabled is failed, the error code is 0x%X' % (ret.value)) + + @property + def running(self): + value = TCntrCtrlBase.getRunning(self._obj) + return True if value else False + + @property + def noiseFilterBlockTime(self): + return TCntrCtrlBase.getNoiseFilterBlockTime(self._obj) + + @noiseFilterBlockTime.setter + def noiseFilterBlockTime(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setNoiseFilterBlockTime(self._obj, value)) + if BioFailed(ret): + raise ValueError('set noiseFilterBlockTime is failed, the error code is 0x%X' % (ret.value)) + + @property + def noiseFilter(self): + if not self.features.noiseFilterSupported: + return None + nativeObj = TCntrCtrlBase.getNoiseFilter(self._obj) + return NosFltChannel(nativeObj) + + @property + def measurementTimeout(self): + return TCntrCtrlBase.getMeasurementTimeout(self._obj) + + @measurementTimeout.setter + def measurementTimeout(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TCntrCtrlBase.setMeasurementTimeout(self._obj, value)) + if BioFailed(ret): + raise ValueError('set measurementTimeout is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/CntrFeatures.py b/src/components/Automation/BDaq/CntrFeatures.py new file mode 100644 index 0000000..71def47 --- /dev/null +++ b/src/components/Automation/BDaq/CntrFeatures.py @@ -0,0 +1,231 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TCntrFeatures, TArray +from Automation.BDaq.CounterCapabilityIndexer import CounterCapabilityIndexer +from Automation.BDaq.CounterClockSourceIndexer import CounterClockSourceIndexer +from Automation.BDaq.CounterGateSourceIndexer import CounterGateSourceIndexer +from Automation.BDaq import MathInterval + + +class CntrFeatures(object): + def __init__(self, native_cntr_features): + self._native_cntr_features = native_cntr_features + + # Channel features + @property + def channelCountMax(self): + return TCntrFeatures.getChannelCountMax(self._native_cntr_features) + + @property + def resolution(self): + return TCntrFeatures.getResolution(self._native_cntr_features) + + @property + def dataSize(self): + return TCntrFeatures.getDataSize(self._native_cntr_features) + + @property + def capabilities(self): + return CounterCapabilityIndexer(TCntrFeatures.getCapabilities(self._native_cntr_features)) + + # noise filter features + @property + def noiseFilterSupported(self): + value = TCntrFeatures.getNoiseFilterSupported(self._native_cntr_features) + return True if value else False + + @property + def noiseFilterOfChannels(self): + nativeArray = TCntrFeatures.getNoiseFilterOfChannels(self._native_cntr_features) + return TArray.ToByte(nativeArray, True) + + @property + def noiseFilterBlockTimeRange(self): + x = MathInterval() + TCntrFeatures.getNoiseFilterBlockTimeRange(self._native_cntr_features, x) + return x + + # event counting features + @property + def ecClockSources(self): + clockObj = TCntrFeatures.getEcClockSources(self._native_cntr_features) + return CounterClockSourceIndexer(clockObj) + + @property + def ecClockPolarities(self): + nativeArray = TCntrFeatures.getEcClockPolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def ecGatePolarities(self): + nativeArray = TCntrFeatures.getEcGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def ecGateControlOfChannels(self): + nativeArray = TCntrFeatures.getEcGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + # frequency measurement features + @property + def fmMethods(self): + nativeArray = TCntrFeatures.getFmMethods(self._native_cntr_features) + return TArray.ToFreqMeasureMethod(nativeArray, True) + + # one-shot features + @property + def osClockSources(self): + clockObj = TCntrFeatures.getOsClockSources(self._native_cntr_features) + return CounterClockSourceIndexer(clockObj) + + @property + def osClockPolarities(self): + nativeArray = TCntrFeatures.getOsClockPolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def osGateSources(self): + clockObj = TCntrFeatures.getOsGateSources(self._native_cntr_features) + return CounterGateSourceIndexer(clockObj) + + @property + def osGatePolarities(self): + nativeArray = TCntrFeatures.getOsGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def osOutSignals(self): + nativeArray = TCntrFeatures.getOsOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def osDelayCountRange(self): + x = MathInterval() + TCntrFeatures.getOsDelayCountRange(self._native_cntr_features, x) + return x + + # Timer/pulse features + @property + def tmrGateControlOfChannels(self): + nativeArray = TCntrFeatures.getTmrGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def tmrGatePolarities(self): + nativeArray = TCntrFeatures.getTmrGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def tmrOutSignals(self): + nativeArray = TCntrFeatures.getTmrOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def tmrFrequencyRange(self): + x = MathInterval() + TCntrFeatures.getTmrFrequencyRange(self._native_cntr_features, x) + return x + + # pulse width measurement features + @property + def piCascadeGroup(self): + nativeArray = TCntrFeatures.getPiCascadeGroup(self._native_cntr_features) + return TArray.ToCounterCascadeGroup(nativeArray, True) + + # pulse width modulation features + @property + def poGateControlOfChannels(self): + nativeArray = TCntrFeatures.getPoGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def poGatePolarities(self): + nativeArray = TCntrFeatures.getPoGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def poOutSignals(self): + nativeArray = TCntrFeatures.getPoOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def poHiPeriodRange(self): + x = MathInterval() + TCntrFeatures.getPoHiPeriodRange(self._native_cntr_features, x) + return x + + @property + def poLoPeriodRange(self): + x = MathInterval() + TCntrFeatures.getPoLoPeriodRange(self._native_cntr_features, x) + return x + + @property + def poOutCountRange(self): + x = MathInterval() + TCntrFeatures.getPoOutCountRange(self._native_cntr_features, x) + return x + + # Up-down counter features + @property + def udCountingTypes(self): + nativeArray = TCntrFeatures.getUdCountingTypes(self._native_cntr_features) + return TArray.ToCountingType(nativeArray, True) + + @property + def udInitialValues(self): + nativeArray = TCntrFeatures.getUdInitialValues(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def udSnapEventSources(self): + nativeArray = TCntrFeatures.getUdSnapEventSources(self._native_cntr_features) + return TArray.ToEventId(nativeArray, True) + + # new: measurement timeout range + @property + def measurementTimeoutRange(self): + x = MathInterval() + TCntrFeatures.getMeasurementTimeoutRange(self._native_cntr_features, x) + return x + + @property + def udValueResetTimes(self): + x = MathInterval() + TCntrFeatures.getUdValueResetTimes(self._native_cntr_features, x) + return x + + # Counter continue comparing: outputting pulse settings + @property + def ccpGateControlOfChannels(self): + nativeArray = TCntrFeatures.getCcpGateControlOfChannels(self._native_cntr_features) + return TArray.ToInt32(nativeArray, True) + + @property + def ccpGatePolarities(self): + nativeArray = TCntrFeatures.getCcpGatePolarities(self._native_cntr_features) + return TArray.ToSignalPolarity(nativeArray, True) + + @property + def ccpOutSignals(self): + nativeArray = TCntrFeatures.getCcpOutSignals(self._native_cntr_features) + return TArray.ToOutSignalType(nativeArray, True) + + @property + def ccpHiPeriodRange(self): + x = MathInterval() + TCntrFeatures.getCcpHiPeriodRange(self._native_cntr_features, x) + return x + + @property + def ccpLoPeriodRange(self): + x = MathInterval() + TCntrFeatures.getCcpLoPeriodRange(self._native_cntr_features, x) + return x + + @property + def ccpOutCountRange(self): + x = MathInterval() + TCntrFeatures.getCcpOutCountRange(self._native_cntr_features, x) + return x diff --git a/src/components/Automation/BDaq/Conversion.py b/src/components/Automation/BDaq/Conversion.py new file mode 100644 index 0000000..72f463e --- /dev/null +++ b/src/components/Automation/BDaq/Conversion.py @@ -0,0 +1,83 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_byte +from Automation.BDaq.BDaqApi import TConversion, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode, SignalDrop + + +class Conversion(object): + def __init__(self, nativeConvObj, chanCount): + self._nativeConvObj = nativeConvObj + self._chanCount = chanCount + + @property + def clockSource(self): + ret = TConversion.getClockSource(self._nativeConvObj) + return Utils.toSignalDrop(ret) + + @clockSource.setter + def clockSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TConversion.setClockSource(self._nativeConvObj, value)) + if BioFailed(ret): + raise ValueError('set clockSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockRate(self): + return TConversion.getClockRate(self._nativeConvObj) + + @clockRate.setter + def clockRate(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TConversion.setClockRate(self._nativeConvObj, value)) + if BioFailed(ret): + raise ValueError('set clockRate is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelStart(self): + return TConversion.getChannelStart(self._nativeConvObj) + + @channelStart.setter + def channelStart(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TConversion.setChannelStart(self._nativeConvObj, int(value))) + if BioFailed(ret): + raise ValueError('set channelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelCount(self): + return TConversion.getChannelCount(self._nativeConvObj) + + @channelCount.setter + def channelCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TConversion.setChannelCount(self._nativeConvObj, value)) + if BioFailed(ret): + raise ValueError('set channelCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelMap(self): + data = [] + dataArr = (c_byte * self._chanCount)() + TConversion.getChannelMap(self._nativeConvObj, self._chanCount, dataArr) + for i in range(self._chanCount): + data.append(dataArr[i]) + return data + + @channelMap.setter + def channelMap(self, value): + if not isinstance(value, list): + raise TypeError('a list is required') + dataLen = len(value) + dataArr = (c_byte * dataLen)() + for i, data in enumerate(value): + dataArr[i] = data + ret = ErrorCode.lookup(TConversion.setChannelMap(self._nativeConvObj, dataLen, dataArr)) + if BioFailed(ret): + raise ValueError('set channelMap is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/ConvertClock.py b/src/components/Automation/BDaq/ConvertClock.py new file mode 100644 index 0000000..17abba6 --- /dev/null +++ b/src/components/Automation/BDaq/ConvertClock.py @@ -0,0 +1,36 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TConvertClock, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode, SignalDrop + + +class ConvertClock(object): + def __init__(self, nativeCnrtClkObj): + self._nativeCnrtClkObj = nativeCnrtClkObj + + @property + def source(self): + ret = TConvertClock.getSource(self._nativeCnrtClkObj) + return Utils.toSignalDrop(ret) + + @source.setter + def source(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TConvertClock.setSource(self._nativeCnrtClkObj, value)) + if BioFailed(ret): + raise ValueError('set source is failed, the error code is 0x%X' % (ret.value)) + + @property + def rate(self): + return TConvertClock.getRate(self._nativeCnrtClkObj) + + @rate.setter + def rate(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TConvertClock.setRate(self._nativeCnrtClkObj, value)) + if BioFailed(ret): + raise ValueError('set rate is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/CounterCapabilityIndexer.py b/src/components/Automation/BDaq/CounterCapabilityIndexer.py new file mode 100644 index 0000000..8cd3852 --- /dev/null +++ b/src/components/Automation/BDaq/CounterCapabilityIndexer.py @@ -0,0 +1,11 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CounterIndexer import CounterIndexer +from Automation.BDaq import CounterCapability +from Automation.BDaq import Utils + + +class CounterCapabilityIndexer(CounterIndexer): + def __init__(self, nativeIndexer): + super(CounterCapabilityIndexer, self).__init__(nativeIndexer, CounterCapability, Utils.toCounterCapability) diff --git a/src/components/Automation/BDaq/CounterClockSourceIndexer.py b/src/components/Automation/BDaq/CounterClockSourceIndexer.py new file mode 100644 index 0000000..2863285 --- /dev/null +++ b/src/components/Automation/BDaq/CounterClockSourceIndexer.py @@ -0,0 +1,11 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CounterIndexer import CounterIndexer +from Automation.BDaq import SignalDrop +from Automation.BDaq import Utils + + +class CounterClockSourceIndexer(CounterIndexer): + def __init__(self, nativeIndexer): + super(CounterClockSourceIndexer, self).__init__(nativeIndexer, SignalDrop, Utils.toSignalDrop) diff --git a/src/components/Automation/BDaq/CounterGateSourceIndexer.py b/src/components/Automation/BDaq/CounterGateSourceIndexer.py new file mode 100644 index 0000000..eb6e44d --- /dev/null +++ b/src/components/Automation/BDaq/CounterGateSourceIndexer.py @@ -0,0 +1,11 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CounterIndexer import CounterIndexer +from Automation.BDaq import SignalDrop +from Automation.BDaq import Utils + + +class CounterGateSourceIndexer(CounterIndexer): + def __init__(self, nativeIndexer): + super(CounterGateSourceIndexer, self).__init__(nativeIndexer, SignalDrop, Utils.toSignalDrop) diff --git a/src/components/Automation/BDaq/CounterIndexer.py b/src/components/Automation/BDaq/CounterIndexer.py new file mode 100644 index 0000000..382c84a --- /dev/null +++ b/src/components/Automation/BDaq/CounterIndexer.py @@ -0,0 +1,19 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TCounterIndexer, TArray + + +class CounterIndexer(object): + def __init__(self, nativeIndex, clazz, convert): + self._nativeIndex = nativeIndex + self._clazz = clazz + self._convert = convert + + @property + def length(self): + return TCounterIndexer.getLength(self._nativeIndex) + + def getItem(self, channel): + nativeArray = TCounterIndexer.getItem(self._nativeIndex, channel) + return TArray.ToEnum(nativeArray, True, self._clazz, self._convert) diff --git a/src/components/Automation/BDaq/DaqCtrlBase.py b/src/components/Automation/BDaq/DaqCtrlBase.py new file mode 100644 index 0000000..6b42915 --- /dev/null +++ b/src/components/Automation/BDaq/DaqCtrlBase.py @@ -0,0 +1,86 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import ErrorCode +from Automation.BDaq.BDaqApi import TDaqCtrlBase, TArray, BioFailed +from Automation.BDaq import DeviceInformation, ControlState +from Automation.BDaq.DeviceCtrl import DeviceCtrl +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode + + +class DaqCtrlBase(object): + def __init__(self, scenario, devInfo): + self._deviceCtrl = None + self._obj = self.create(scenario) + + if devInfo is not None: + self.selectedDevice = devInfo + + @property + def initialized(self): + return self.state != ControlState.Uninited + + def cleanup(self): + TDaqCtrlBase.cleanup(self._obj) + + def dispose(self): + TDaqCtrlBase.dispose(self._obj) + + @property + def selectedDevice(self): + devInfo = DeviceInformation() + TDaqCtrlBase.getSelectedDevice(self._obj, devInfo) + return devInfo + + @selectedDevice.setter + def selectedDevice(self, devInfo): + if not isinstance(devInfo, (DeviceInformation, int, str)): + raise TypeError('The parameter value is not supported.') + + if isinstance(devInfo, str): + ret = ErrorCode.lookup(TDaqCtrlBase.setSelectedDevice(self._obj, DeviceInformation(Description=devInfo))) + elif isinstance(devInfo, int): + ret = ErrorCode.lookup(TDaqCtrlBase.setSelectedDevice(self._obj, DeviceInformation(Description=u'', DeviceNumber=devInfo))) + else: + ret = ErrorCode.lookup(TDaqCtrlBase.setSelectedDevice(self._obj, devInfo)) + + if BioFailed(ret): + raise ValueError('The device is not opened, and the error code is 0x%X' % (ret.value)) + + @property + def state(self): + ret = TDaqCtrlBase.getState(self._obj) + return Utils.toControlState(ret) + + @property + def device(self): + if self._deviceCtrl is None: + self._deviceCtrl = DeviceCtrl(TDaqCtrlBase.getDevice(self._obj)) + return self._deviceCtrl + + @property + def supportedDevices(self): + nativeArray = TDaqCtrlBase.getSupportedDevices(self._obj) + deviceTreeNodeArr = TArray.toDeviceTreeNode(nativeArray) + return deviceTreeNodeArr + + @property + def supportedModes(self): + nativeArray = TDaqCtrlBase.getSupportedModes(self._obj) + accessModeList = TArray.toAccessMode(nativeArray) + return accessModeList + + @property + def module(self): + return TDaqCtrlBase.getModule(self._obj) + + def create(self, scenario): + return TDaqCtrlBase.Create(scenario.value) + + def __set_loadProfile(self, profile): + ret = ErrorCode.lookup(TDaqCtrlBase.LoadProfile(self._obj, profile)) + if BioFailed(ret): + raise ValueError('set loadProfile is failed, the error code is 0x%X' % (ret.value)) + + loadProfile = property(None, __set_loadProfile) diff --git a/src/components/Automation/BDaq/DeviceCtrl.py b/src/components/Automation/BDaq/DeviceCtrl.py new file mode 100644 index 0000000..75700d1 --- /dev/null +++ b/src/components/Automation/BDaq/DeviceCtrl.py @@ -0,0 +1,203 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int32, c_byte, c_uint8 +from ctypes import create_unicode_buffer +from ctypes import pointer + +from Automation.BDaq.BDaqApi import TArray, TerminalBoard +from Automation.BDaq.BDaqApi import TDeviceCtrl, BioFailed +from Automation.BDaq import ErrorCode +from Automation.BDaq import Utils + + +class DeviceCtrl(object): + def __init__(self, nativeDev): + self._nativeDev = nativeDev + + # method + def refresh(self): + return ErrorCode.lookup(TDeviceCtrl.Refresh(self._nativeDev)) + + def readRegister(self, space, offset, length): + dataArr = (c_byte * length)() + data = [] + ret = TDeviceCtrl.ReadRegister(self._nativeDev, space, offset, length, dataArr) + if not BioFailed(ret): + for i in range(length): + data.append(dataArr[i]) + return ErrorCode.lookup(ret), data + + def writeRegister(self, space, offset, length, data): + if not isinstance(data, list): + raise TypeError('a list is required') + if length != len(data): + raise ValueError('Length mismatch: length:%d, len(data):%d' % (length, len(data))) + dataArr = (c_byte * length)() + for i in range(length): + dataArr[i] = data[i] + ret = TDeviceCtrl.WriteRegister(self._nativeDev, space, offset, length, dataArr) + return ErrorCode.lookup(ret) + + def readPrivateRegion(self, signature, length): + dataArr = (c_uint8 * length)() + data = [] + + ret = TDeviceCtrl.ReadPrivateRegion(self._nativeDev, signature, length, dataArr) + if not BioFailed(ret): + for i in range(length): + data.append(dataArr[i]) + return ErrorCode.lookup(ret), data + + def writePrivateRegion(self, signature, length, data): + if not isinstance(data, list): + raise TypeError('a list is required') + + if length != len(data): + raise ValueError('Length mismatch: length:%d, len(data):%d' % (length, len(data))) + + dataArr = (c_uint8 * length)() + for i in range(length): + dataArr[i] = data[i] + + ret = TDeviceCtrl.WritePrivateRegion(self._nativeDev, signature, length, dataArr) + return ErrorCode.lookup(ret) + + def synchronizeTimeBase(self): + return ErrorCode.lookup(TDeviceCtrl.SynchronizeTimebase(self._nativeDev)) + + def calculateAbsoluteTime(self, relativeTime): + if not isinstance(relativeTime, float): + raise TypeError('a float is required') + return TDeviceCtrl.CalculateAbsoluteTime(self._nativeDev, relativeTime) + + # properties + @property + def deviceNumber(self): + return TDeviceCtrl.getDeviceNumber(self._nativeDev) + + @property + def description(self): + descr = create_unicode_buffer(256) + TDeviceCtrl.getDescription(self._nativeDev, 256, descr) + + return descr.value.encode() + + @description.setter + def description(self, desc): + ret = ErrorCode.lookup(TDeviceCtrl.setDescription(self._nativeDev, len(desc), desc)) + if BioFailed(ret): + raise ValueError('set description is failed, the error code is 0x%X' % (ret.value)) + + @property + def accessMode(self): + return Utils.toAccessMode(TDeviceCtrl.getAccessMode(self._nativeDev)) + + @property + def productId(self): + return Utils.toProductId(TDeviceCtrl.getProductId(self._nativeDev)) + + @property + def boardId(self): + return TDeviceCtrl.getBoardId(self._nativeDev) + + @boardId.setter + def boardId(self, value): + ret = ErrorCode.lookup(TDeviceCtrl.setBoardId(self._nativeDev, value)) + if BioFailed(ret): + raise ValueError('set boardId is failed, the error code is 0x%X' % (ret.value)) + + @property + def boardVersion(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getBoardVersion(self._nativeDev, 256, version) + return version.value.encode() + + @property + def driverVersion(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getDriverVersion(self._nativeDev, 256, version) + return version.value.encode() + + @property + def dllVersion(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getDllVersion(self._nativeDev, 256, version) + return version.value.encode() + + @property + def location(self): + version = create_unicode_buffer(256) + TDeviceCtrl.getLocation(self._nativeDev, 256, version) + return version.value.encode() + + @property + def privateRegionLength(self): + return TDeviceCtrl.getPrivateRegionLength(self._nativeDev) + + @property + def hotResetPreventable(self): + return TDeviceCtrl.getHotResetPreventable(self._nativeDev) + + @property + def baseAddresses(self): + nativeArray = TDeviceCtrl.getBaseAddresses(self._nativeDev) + return TArray.ToInt64(nativeArray, True) + + @property + def interrupts(self): + nativeArray = TDeviceCtrl.getInterrupts(self._nativeDev) + return TArray.ToInt32(nativeArray, True) + + @property + def supportedTerminalBoard(self): + nativeArray = TDeviceCtrl.getSupportedTerminalBoard(self._nativeDev) + return TArray.ToTerminalBoard(nativeArray, True) + + @property + def supportedEvents(self): + nativeArray = TDeviceCtrl.getSupportedEvents(self._nativeDev) + return TArray.ToEventId(nativeArray, True) + + @property + def supportedScenarios(self): + return TDeviceCtrl.getSupportedScenarios(self._nativeDev) + + @property + def terminalBoard(self): + return Utils.toTerminalBoard(TDeviceCtrl.getTerminalBoard(self._nativeDev)) + + @terminalBoard.setter + def terminalBoard(self, value): + if not isinstance(value, TerminalBoard): + raise TypeError("a TerminalBoard is required") + ret = ErrorCode.lookup(TDeviceCtrl.setTerminalBoard(self._nativeDev, value)) + if BioFailed(ret): + raise ValueError('set terminalBoard is failed, the error code is 0x%X' % (ret.value)) + + def setLocateEnabled(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + return ErrorCode.lookup(TDeviceCtrl.setLocateEnabled(self._nativeDev, value)) + + @property + def installedDevices(self): + nativeArray = TDeviceCtrl.getInstalledDevices() + arr = TArray.toDeviceTreeNode(nativeArray, True) + return arr + + def getHwSpecific(self, name): + dataArr = (c_int32 * 1)() + size = c_int32(4) + pSize = pointer(size) + data = None + ret = ErrorCode.lookup(TDeviceCtrl.getHwSpecific(self._nativeDev, name, pSize, dataArr)) + if ret == ErrorCode.Success: + data = dataArr[0] + return ret, data + + def setHwSpecific(self, name, data): + dataArr = (c_int32 * 1)() + dataArr[0] = data + ret = TDeviceCtrl.setHwSpecific(self._nativeDev, name, 4, dataArr) + return ErrorCode.lookup(ret) diff --git a/src/components/Automation/BDaq/DiCosintPort.py b/src/components/Automation/BDaq/DiCosintPort.py new file mode 100644 index 0000000..30e4f24 --- /dev/null +++ b/src/components/Automation/BDaq/DiCosintPort.py @@ -0,0 +1,27 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.BDaqApi import TDiCosintPort, BioFailed +from Automation.BDaq import ErrorCode + + +class DiCosintPort(object): + def __init__(self, nativeDiCosintPortObj): + self._nativeDiCosintPortObj = nativeDiCosintPortObj + + @property + def port(self): + return TDiCosintPort.getPort(self._nativeDiCosintPortObj) + + # The channels in the port that enabled change of state interrupt + @property + def mask(self): + return TDiCosintPort.getMask(self._nativeDiCosintPortObj) + + @mask.setter + def mask(self, value): + ret = ErrorCode.lookup(TDiCosintPort.setMask(self._nativeDiCosintPortObj, value & 0xff)) + if BioFailed(ret): + raise ValueError('set mask is failed, the error code is 0x%X' % (ret.value)) + diff --git a/src/components/Automation/BDaq/DiPmintPort.py b/src/components/Automation/BDaq/DiPmintPort.py new file mode 100644 index 0000000..e8733fd --- /dev/null +++ b/src/components/Automation/BDaq/DiPmintPort.py @@ -0,0 +1,38 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDiPmintPort +from Automation.BDaq import ErrorCode + + +class DiPmintPort(object): + def __init__(self, nativeDiPmPortObj): + self._nativeDiPmPortObj = nativeDiPmPortObj + + @property + def port(self): + return TDiPmintPort.getPort(self._nativeDiPmPortObj) + + @property + def mask(self): + return TDiPmintPort.getMask(self._nativeDiPmPortObj) + + @mask.setter + def mask(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDiPmintPort.setMask(self._nativeDiPmPortObj, value & 0xff)) + if BioFailed(ret): + raise ValueError('set mask is failed, the error code is 0x%X' % (ret.value)) + + @property + def pattern(self): + return TDiPmintPort.getPattern(self._nativeDiPmPortObj) + + @pattern.setter + def pattern(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDiPmintPort.setPattern(self._nativeDiPmPortObj, value & 0xff)) + if BioFailed(ret): + raise ValueError('set pattern is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/DiintChannel.py b/src/components/Automation/BDaq/DiintChannel.py new file mode 100644 index 0000000..7388023 --- /dev/null +++ b/src/components/Automation/BDaq/DiintChannel.py @@ -0,0 +1,53 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDiintChannel, BioFailed +from Automation.BDaq import ErrorCode, ActiveSignal +from Automation.BDaq import Utils + + +class DiintChannel(object): + def __init__(self, diIntChan): + self._diIntChan = diIntChan + + @property + def channel(self): + return TDiintChannel.getChannel(self._diIntChan) + + @property + def enabled(self): + value = TDiintChannel.getEnabled(self._diIntChan) + return True if value else False + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TDiintChannel.setEnabled(self._diIntChan, value)) + if BioFailed(ret): + raise ValueError('set enabled is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TDiintChannel.getGated(self._diIntChan) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TDiintChannel.setGated(self._diIntChan, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def trigEdge(self): + return Utils.toActiveSignal(TDiintChannel.getTrigEdge(self._diIntChan)) + + @trigEdge.setter + def trigEdge(self, value): + if not isinstance(value, ActiveSignal): + raise TypeError('a ActiveSignal is required') + ret = ErrorCode.lookup(TDiintChannel.setTrigEdge(self._diIntChan, value)) + if BioFailed(ret): + raise ValueError('set trigEdge is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/DioCtrlBase.py b/src/components/Automation/BDaq/DioCtrlBase.py new file mode 100644 index 0000000..de79cff --- /dev/null +++ b/src/components/Automation/BDaq/DioCtrlBase.py @@ -0,0 +1,35 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDioCtrlBase, TArray +from Automation.BDaq.DaqCtrlBase import DaqCtrlBase +from Automation.BDaq.DioFeatures import DioFeatures +from Automation.BDaq.DioPort import DioPort + + +class DioCtrlBase(DaqCtrlBase): + def __init__(self, scenario, devInfo): + super(DioCtrlBase, self).__init__(scenario, devInfo) + self._dio_features = None + self._dio_ports = list() + + @property + def features(self): + if self._dio_features is None: + self._dio_features = DioFeatures(TDioCtrlBase.getFeatures(self._obj)) + return self._dio_features + + @property + def portCount(self): + return self.features.portCount + + @property + def ports(self): + if not self._dio_ports: + nativeArray = TDioCtrlBase.getPorts(self._obj) + count = self.portCount + for i in range(count): + dioPortObj = DioPort(TArray.getItem(nativeArray, i)) + self._dio_ports.append(dioPortObj) + + return self._dio_ports diff --git a/src/components/Automation/BDaq/DioFeatures.py b/src/components/Automation/BDaq/DioFeatures.py new file mode 100644 index 0000000..2504e57 --- /dev/null +++ b/src/components/Automation/BDaq/DioFeatures.py @@ -0,0 +1,90 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +import ctypes + +from Automation.BDaq.BDaqApi import TArray +from Automation.BDaq.BDaqApi import TDioFeatures +from Automation.BDaq import MathInterval +from Automation.BDaq import Utils + + +class DioFeatures(object): + def __init__(self, nativeFeatures): + self._dio_features = nativeFeatures + + # common + @property + def portProgrammable(self): + ret = TDioFeatures.getPortProgrammable(self._dio_features) + return True if ret else False + + @property + def channelCountMax(self): + return TDioFeatures.getChannelCountMax(self._dio_features) + + @property + def portCount(self): + return TDioFeatures.getPortCount(self._dio_features) + + @property + def portsType(self): + nativeArr = TDioFeatures.getPortsType(self._dio_features) + return TArray.ToByte(nativeArr, True) + + @property + def diSupported(self): + ret = TDioFeatures.getDiSupported(self._dio_features) + return True if ret else False + + @property + def doSupported(self): + ret = TDioFeatures.getDoSupported(self._dio_features) + return True if ret else False + + @property + def diDataMask(self): + nativeArray = TDioFeatures.getDiDataMask(self._dio_features) + return TArray.ToByte(nativeArray, True) + + @property + def diNoiseFilterSupported(self): + ret = TDioFeatures.getDiNoiseFilterSupported(self._dio_features) + return True if ret else False + + @property + def diNoiseFilterOfChannels(self): + nativeArray = TDioFeatures.getDiNoiseFilterOfChannels(self._dio_features) + return TArray.ToByte(nativeArray, True) + + @property + def diNoiseFilterBlockTimeRange(self): + x = MathInterval() + TDioFeatures.getDiNoiseFilterBlockTimeRange(self._dio_features, ctypes.pointer(x)) + return x + + @property + def doDataMask(self): + nativeArray = TDioFeatures.getDoDataMask(self._dio_features) + return TArray.ToByte(nativeArray, True) + + @property + def doFreezeSignalSources(self): + nativeArray = TDioFeatures.getDoFreezeSignalSources(self._dio_features) + return TArray.ToSignalDrop(nativeArray, True) + + @property + def reflectWdtFeedIntervalRange(self): + x = MathInterval() + TDioFeatures.getDoReflectWdtFeedIntervalRange(self._dio_features, ctypes.pointer(x)) + return x + + @property + def doPresetValueDepository(self): + ret = TDioFeatures.getDoPresetValueDepository(self._dio_features) + return Utils.toDepository(ret) + + @property + def doCircuitSelectableTypes(self): + nativeArray = TDioFeatures.getDoCircuitSelectableTypes(self._dio_features) + return TArray.ToDoCircuitType(nativeArray, True) diff --git a/src/components/Automation/BDaq/DioPort.py b/src/components/Automation/BDaq/DioPort.py new file mode 100644 index 0000000..163b50d --- /dev/null +++ b/src/components/Automation/BDaq/DioPort.py @@ -0,0 +1,75 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TDioPort, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import ErrorCode, DioPortDir, DoCircuitType + + +class DioPort(object): + def __init__(self, nativePort): + self._nativePort = nativePort + + @property + def port(self): + return TDioPort.getPort(self._nativePort) + + @property + def direction(self): + return Utils.toDioPortDir(TDioPort.getDirection(self._nativePort)) + + @direction.setter + def direction(self, value): + if not isinstance(value, DioPortDir): + raise TypeError('a DioPortDir is required') + ret = ErrorCode.lookup(TDioPort.setDirection(self._nativePort, value)) + if BioFailed(ret): + raise ValueError('set direction is failed, the error code is 0x%X' % (ret.value)) + + @property + def diInversePort(self): + return TDioPort.getDiInversePort(self._nativePort) + + @diInversePort.setter + def diInversePort(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDioPort.setDiInversePort(self._nativePort, value & 0xff)) + if BioFailed(ret): + raise ValueError('set diInversePort is failed, the error code is 0x%X' % (ret.value)) + + @property + def diOpenState(self): + return TDioPort.getDiOpenState(self._nativePort) + + @diOpenState.setter + def diOpenState(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDioPort.setDiOpenState(self._nativePort, value & 0xff)) + if BioFailed(ret): + raise ValueError('set diOpenState is failed, the error code is 0x%X' % (ret.value)) + + @property + def doPresetValue(self): + return TDioPort.getDoPresetValue(self._nativePort) + + @doPresetValue.setter + def doPresetValue(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TDioPort.setDoPresetValue(self._nativePort, value & 0xff)) + if BioFailed(ret): + raise ValueError('set doPresetValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def doCircuitType(self): + return Utils.toDoCircuitType(TDioPort.getDoCircuitType(self._nativePort)) + + @doCircuitType.setter + def doCircuitType(self, value): + if not isinstance(value, DoCircuitType): + raise TypeError('a DoCircuitType is required') + ret = ErrorCode.lookup(TDioPort.setDoCircuitType(self._nativePort, value)) + if BioFailed(ret): + raise ValueError('set doCircuitType is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/EcChannel.py b/src/components/Automation/BDaq/EcChannel.py new file mode 100644 index 0000000..993d5ee --- /dev/null +++ b/src/components/Automation/BDaq/EcChannel.py @@ -0,0 +1,77 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TEcChannel, BioFailed +from Automation.BDaq import ErrorCode, SignalPolarity, SignalDrop +from Automation.BDaq import Utils + + +class EcChannel(object): + def __init__(self, nativeEcChanObj): + self._nativeEcChanObj = nativeEcChanObj + + @property + def channel(self): + return TEcChannel.getChannel(self._nativeEcChanObj) + + @property + def noiseFiltered(self): + value = TEcChannel.getNoiseFiltered(self._nativeEcChanObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TEcChannel.setNoiseFiltered(self._nativeEcChanObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockSource(self): + return Utils.toSignalDrop(TEcChannel.getClockSource(self._nativeEcChanObj)) + + @clockSource.setter + def clockSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TEcChannel.setClockSource(self._nativeEcChanObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockPolarity(self): + return Utils.toSignalPolarity(TEcChannel.getClockPolarity(self._nativeEcChanObj)) + + @clockPolarity.setter + def clockPolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError("a SignalPolarity is required") + ret = ErrorCode.lookup(TEcChannel.setClockPolarity(self._nativeEcChanObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockPolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + return Utils.toSignalPolarity(TEcChannel.getGatePolarity(self._nativeEcChanObj)) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError("a SignalePolarity is required") + ret = ErrorCode.lookup(TEcChannel.setGatePolarity(self._nativeEcChanObj, value.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TEcChannel.getGated(self._nativeEcChanObj) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TEcChannel.setGated(self._nativeEcChanObj, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/EventCounterCtrl.py b/src/components/Automation/BDaq/EventCounterCtrl.py new file mode 100644 index 0000000..edb7d77 --- /dev/null +++ b/src/components/Automation/BDaq/EventCounterCtrl.py @@ -0,0 +1,33 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.EcChannel import EcChannel +from Automation.BDaq.BDaqApi import TArray, TEventCounterCtrl + + +class EventCounterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(EventCounterCtrl, self).__init__(Scenario.SceEventCounter, devInfo) + self._ec_channels = [] + + @property + def channels(self): + if not self._ec_channels: + count = self.features.channelCountMax + nativeArr = TEventCounterCtrl.getChannels(self._obj) + for i in range(count): + ecChannObj = EcChannel(TArray.getItem(nativeArr, i)) + self._ec_channels.append(ecChannObj) + return self._ec_channels + + def read(self, count = 1): + dataArr = (c_int * count)() + data = [] + ret = ErrorCode.lookup(TEventCounterCtrl.Read(self._obj, count, dataArr)) + for i in range(count): + data.append(dataArr[i]) + return ret, data diff --git a/src/components/Automation/BDaq/FmChannel.py b/src/components/Automation/BDaq/FmChannel.py new file mode 100644 index 0000000..bdd8402 --- /dev/null +++ b/src/components/Automation/BDaq/FmChannel.py @@ -0,0 +1,53 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TFmChannel, BioFailed +from Automation.BDaq import ErrorCode, FreqMeasureMethod +from Automation.BDaq import Utils + + +class FmChannel(object): + def __init__(self, nativeFmChanObj): + self._nativeFmChanObj = nativeFmChanObj + + @property + def channel(self): + return TFmChannel.getChannel(self._nativeFmChanObj) + + @property + def noiseFiltered(self): + value = TFmChannel.getNoiseFiltered(self._nativeFmChanObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TFmChannel.setNoiseFiltered(self._nativeFmChanObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def fmMethod(self): + value = TFmChannel.getFmMethod(self._nativeFmChanObj) + return Utils.toFreqMeasureMethod(value) + + @fmMethod.setter + def fmMethod(self, value): + if not isinstance(value, FreqMeasureMethod): + raise TypeError("a FreqMeasureMethod is required") + ret = ErrorCode.lookup(TFmChannel.setFmMethod(self._nativeFmChanObj, value)) + if BioFailed(ret): + raise ValueError('set fmMethod is failed, the error code is 0x%X' % (ret.value)) + + @property + def collectionPeriod(self): + return TFmChannel.getCollectionPeriod(self._nativeFmChanObj) + + @collectionPeriod.setter + def collectionPeriod(self, value): + if not isinstance(value, (float, int)): + raise TypeError("a float is required") + ret = ErrorCode.lookup(TFmChannel.setCollectionPeriod(self._nativeFmChanObj, value)) + if BioFailed(ret): + raise ValueError('set collectionPeriod is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/FreqMeterCtrl.py b/src/components/Automation/BDaq/FreqMeterCtrl.py new file mode 100644 index 0000000..a5c605c --- /dev/null +++ b/src/components/Automation/BDaq/FreqMeterCtrl.py @@ -0,0 +1,34 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_double + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.FmChannel import FmChannel +from Automation.BDaq.BDaqApi import TArray, TFreqMeterCtrl + + +class FreqMeterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(FreqMeterCtrl, self).__init__(Scenario.SceFreqMeter, devInfo) + self._fm_channls = [] + + @property + def channels(self): + if not self._fm_channls: + count = self.features.channelCountMax + nativeArr = TFreqMeterCtrl.getChannels(self._obj) + for i in range(count): + fmChannObj = FmChannel(TArray.getItem(nativeArr, i)) + self._fm_channls.append(fmChannObj) + return self._fm_channls + + def read(self, count = 1): + dataArr = (c_double * count)() + data = [] + ret = ErrorCode.lookup(TFreqMeterCtrl.Read(self._obj, count, dataArr)) + + for i in range(count): + data.append(dataArr[i]) + return ret, data diff --git a/src/components/Automation/BDaq/InstantAiCtrl.py b/src/components/Automation/BDaq/InstantAiCtrl.py new file mode 100644 index 0000000..3eb9123 --- /dev/null +++ b/src/components/Automation/BDaq/InstantAiCtrl.py @@ -0,0 +1,105 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.BDaqApi import TInstantAiCtrl, BioFailed +from Automation.BDaq.AiCtrlBase import AiCtrlBase +from Automation.BDaq.CjcSetting import CjcSetting + + +class InstantAiCtrl(AiCtrlBase): + def __init__(self, devInfo = None): + super(InstantAiCtrl, self).__init__(Scenario.SceInstantAi, devInfo) + self._cjc = None + + @property + def cjc(self): + if self._cjc is None: + self._cjc = CjcSetting(TInstantAiCtrl.getCjc(self._obj)) + return self._cjc + + @property + def autoConvertClockRate(self): + return TInstantAiCtrl.getAutoConvertClockRate(self._obj) + + @autoConvertClockRate.setter + def autoConvertClockRate(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TInstantAiCtrl.setAutoConvertClockRate(self._obj, value)) + if BioFailed(ret): + raise ValueError('set autoConvertClockRate is failed, the error code is 0x%X' % (ret.value)) + + @property + def autoConvertChannelStart(self): + return TInstantAiCtrl.getAutoConvertChannelStart(self._obj) + + @autoConvertChannelStart.setter + def autoConvertChannelStart(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TInstantAiCtrl.setAutoConvertChannelStart(self._obj, value)) + if BioFailed(ret): + raise ValueError('set autoConvertChannelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def autoConvertChannelCount(self): + return TInstantAiCtrl.getAutoConvertChannelCount(self._obj) + + @autoConvertChannelCount.setter + def autoConvertChannelCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TInstantAiCtrl.setAutoConvertChannelCount(self._obj, value)) + if BioFailed(ret): + raise ValueError('set autoConvertChannelCount is failed, the error code is 0x%X' % (ret.value)) + + def readDataF64(self, chStart, chCount): + if not isinstance(chStart, int): + raise TypeError("a int is required") + if not isinstance(chCount, int): + raise TypeError("a int is required") + + scaledArray = (c_double * chCount)() + dataScaled = [] + ret = ErrorCode.lookup(TInstantAiCtrl.readAny(self._obj, chStart, chCount, None, scaledArray)) + if BioFailed(ret): + return ret, dataScaled + + for i in range(chCount): + dataScaled.append(scaledArray[i]) + return ret, dataScaled + + def readDataI32(self, chStart, chCount): + if not isinstance(chStart, int): + raise TypeError("a int is required") + if not isinstance(chCount, int): + raise TypeError("a int is required") + + rawArray = (c_int32 * chCount)() + dataRaw = [] + ret = ErrorCode.lookup(TInstantAiCtrl.readAny(self._obj, chStart, chCount, rawArray, None)) + if BioFailed(ret): + return ret, dataRaw + + for i in range(chCount): + dataRaw.append(rawArray[i]) + return ret, dataRaw + + def readDataI16(self, chStart, chCount): + if not isinstance(chStart, int): + raise TypeError("a int is required") + if not isinstance(chCount, int): + raise TypeError("a int is required") + + rawArray = (c_int16 * chCount)() + dataRaw = [] + ret = ErrorCode.lookup(TInstantAiCtrl.readAny(self._obj, chStart, chCount, rawArray, None)) + if BioFailed(ret): + return ret, dataRaw + + for i in range(chCount): + dataRaw.append(rawArray[i]) + return ret, dataRaw diff --git a/src/components/Automation/BDaq/InstantAoCtrl.py b/src/components/Automation/BDaq/InstantAoCtrl.py new file mode 100644 index 0000000..3714a74 --- /dev/null +++ b/src/components/Automation/BDaq/InstantAoCtrl.py @@ -0,0 +1,21 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.BDaqApi import TInstantAoCtrl +from Automation.BDaq.AoCtrlBase import AoCtrlBase + + +class InstantAoCtrl(AoCtrlBase): + def __init__(self, devInfo = None): + super(InstantAoCtrl, self).__init__(Scenario.SceInstantAo, devInfo) + + def writeAny(self, chStart, chCount, dataRaw, dataScaled): + doubleArray = (c_double * chCount)() + for i in range(chCount): + doubleArray[i] = dataScaled[i] + + return ErrorCode.lookup(TInstantAoCtrl.writeAny(self._obj, chStart, chCount, dataRaw, doubleArray)) + diff --git a/src/components/Automation/BDaq/InstantDiCtrl.py b/src/components/Automation/BDaq/InstantDiCtrl.py new file mode 100644 index 0000000..66f5589 --- /dev/null +++ b/src/components/Automation/BDaq/InstantDiCtrl.py @@ -0,0 +1,87 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.DioCtrlBase import DioCtrlBase +from Automation.BDaq.BDaqApi import TInstantDiCtrl, TArray, BioFailed +from Automation.BDaq.DiintChannel import DiintChannel +from Automation.BDaq.NosFltChannel import NosFltChannel +from Automation.BDaq.DiPmintPort import DiPmintPort +from Automation.BDaq.DiCosintPort import DiCosintPort + + +class InstantDiCtrl(DioCtrlBase): + def __init__(self, devInfo = None): + super(InstantDiCtrl, self).__init__(Scenario.SceInstantDi, devInfo) + self._nosFltChans = [] + self._intChans = [] + self._cosPorts = [] + self._pmPorts = [] + + @property + def noiseFilterBlockTime(self): + return TInstantDiCtrl.getNoiseFilterBlockTime(self._obj) + + @noiseFilterBlockTime.setter + def noiseFilterBlockTime(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TInstantDiCtrl.setNoiseFilterBlockTime(self._obj, value)) + if BioFailed(ret): + raise ValueError('set noiseFilterBlockTime is failed, the error code is 0x%X' % (ret.value)) + + @property + def noiseFilter(self): + if not self._nosFltChans: + nativeArr = TInstantDiCtrl.getNoiseFilter(self._obj) + count = TArray.getLength(nativeArr) + for i in range(count): + nosFltChannObj = NosFltChannel(TArray.getItem(nativeArr, i)) + self._nosFltChans.append(nosFltChannObj) + return self._nosFltChans + + @property + def diIntChannels(self): + if not self._intChans: + nativeArray = TInstantDiCtrl.getDiintChannels(self._obj) + count = TArray.getLength(nativeArray) + for i in range(count): + diintChannObj = DiintChannel(TArray.getItem(nativeArray, i)) + self._intChans.append(diintChannObj) + return self._intChans + + @property + def diCosintPorts(self): + if not self._cosPorts: + nativeArray = TInstantDiCtrl.getDiCosintPorts(self._obj) + count = TArray.getLength(nativeArray) + for i in range(count): + cosPortsObj = DiCosintPort(TArray.getItem(nativeArray, i)) + self._cosPorts.append(cosPortsObj) + return self._cosPorts + + @property + def diPmintPorts(self): + if not self._pmPorts: + nativeArray = TInstantDiCtrl.getDiPmintPorts(self._obj) + count = TArray.getLength(nativeArray) + for i in range(count): + pmPortsObj = DiPmintPort(TArray.getItem(nativeArray, i)) + self._pmPorts.append(pmPortsObj) + return self._pmPorts + + def readAny(self, portStart, portCount): + dataArray = (c_uint8 * portCount)() + data = [] + ret = TInstantDiCtrl.readAny(self._obj, portStart, portCount, dataArray) + for i in range(portCount): + data.append(dataArray[i]) + return ErrorCode.lookup(ret), data + + def readBit(self, port, bit): + dataArray = (c_uint8 * 1)() + ret = TInstantDiCtrl.readBit(self._obj, port, bit, dataArray) + data = dataArray[0] + return ErrorCode.lookup(ret), data diff --git a/src/components/Automation/BDaq/InstantDoCtrl.py b/src/components/Automation/BDaq/InstantDoCtrl.py new file mode 100644 index 0000000..e4e92d5 --- /dev/null +++ b/src/components/Automation/BDaq/InstantDoCtrl.py @@ -0,0 +1,38 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import * + +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.BDaqApi import TInstantDoCtrl +from Automation.BDaq.DioCtrlBase import DioCtrlBase + + +class InstantDoCtrl(DioCtrlBase): + def __init__(self, devInfo = None): + super(InstantDoCtrl, self).__init__(Scenario.SceInstantDo, devInfo) + + def writeAny(self, portStart, portCount, data): + dataArray = (c_uint8 * portCount)() + for i in range(portCount): + dataArray[i] = data[i] + ret = TInstantDoCtrl.writeAny(self._obj, portStart, portCount, dataArray) + return ErrorCode.lookup(ret) + + def writeBit(self, port, bit, data): + ret = TInstantDoCtrl.writeBit(self._obj, port, bit, data) + return ErrorCode.lookup(ret) + + def readAny(self, portStart, portCount): + dataArray = (c_uint8 * portCount)() + data = [] + ret = TInstantDoCtrl.readAny(self._obj, portStart, portCount, dataArray) + for i in range(portCount): + data.append(dataArray[i]) + return ErrorCode.lookup(ret), data + + def readBit(self, port, bit): + dataArray = (c_uint8 * 1)() + ret = TInstantDoCtrl.readBit(self._obj, port, bit, dataArray) + data = dataArray[0] + return ErrorCode.lookup(ret), data diff --git a/src/components/Automation/BDaq/NoiseFilterChannel.py b/src/components/Automation/BDaq/NoiseFilterChannel.py new file mode 100644 index 0000000..0de98c2 --- /dev/null +++ b/src/components/Automation/BDaq/NoiseFilterChannel.py @@ -0,0 +1,27 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TNosFltChannel, BioFailed +from Automation.BDaq import ErrorCode + + +class NoiseFilterChannel(object): + def __init__(self, native_nos_flt_chann_obj): + self._native_nos_flt_chann_obj = native_nos_flt_chann_obj + + @property + def channel(self): + return TNosFltChannel.getChannel(self._native_nos_flt_chann_obj) + + @property + def enabled(self): + ret = TNosFltChannel.getEnabled(self._native_nos_flt_chann_obj) + return True if ret else False + + @enabled.setter + def enabled(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TNosFltChannel.setEnabled(self._native_nos_flt_chann_obj, value)) + if BioFailed(ret): + raise ValueError('set enabled is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/NosFltChannel.py b/src/components/Automation/BDaq/NosFltChannel.py new file mode 100644 index 0000000..98a698d --- /dev/null +++ b/src/components/Automation/BDaq/NosFltChannel.py @@ -0,0 +1,9 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.NoiseFilterChannel import NoiseFilterChannel + + +class NosFltChannel(NoiseFilterChannel): + def __init__(self, nativeNoiseFilterChannObj): + super(NosFltChannel, self).__init__(nativeNoiseFilterChannObj) diff --git a/src/components/Automation/BDaq/OneShotCtrl.py b/src/components/Automation/BDaq/OneShotCtrl.py new file mode 100644 index 0000000..50742d5 --- /dev/null +++ b/src/components/Automation/BDaq/OneShotCtrl.py @@ -0,0 +1,24 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import Scenario +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq.OsChannel import OsChannel +from Automation.BDaq.BDaqApi import TArray, TOneShotCtrl + + +class OneShotCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(OneShotCtrl, self).__init__(Scenario.SceOneShot, devInfo) + self._os_channels = [] + + @property + def channels(self): + if not self._os_channels: + count = self.features.channelCountMax + nativeArr = TOneShotCtrl.getChannels(self._obj) + + for i in range(count): + poChannObj = OsChannel(TArray.getItem(nativeArr, i)) + self._os_channels.append(poChannObj) + return self._os_channels diff --git a/src/components/Automation/BDaq/OsChannel.py b/src/components/Automation/BDaq/OsChannel.py new file mode 100644 index 0000000..21397a8 --- /dev/null +++ b/src/components/Automation/BDaq/OsChannel.py @@ -0,0 +1,103 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TOsChannel, BioFailed +from Automation.BDaq import ErrorCode, SignalPolarity, OutSignalType +from Automation.BDaq import Utils, SignalDrop + + +class OsChannel(object): + def __init__(self, nativeOsObj): + self._nativeOsObj = nativeOsObj + + @property + def channel(self): + return TOsChannel.getChannel(self._nativeOsObj) + + @property + def noiseFiltered(self): + value = TOsChannel.getNoiseFiltered(self._nativeOsObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TOsChannel.setNoiseFiltered(self._nativeOsObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def delayCount(self): + return TOsChannel.getDelayCount(self._nativeOsObj) + + @delayCount.setter + def delayCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TOsChannel.setDelayCount(self._nativeOsObj, value)) + if BioFailed(ret): + raise ValueError('set delayCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockSource(self): + return Utils.toSignalDrop(TOsChannel.getClockSource(self._nativeOsObj)) + + @clockSource.setter + def clockSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TOsChannel.setClockSource(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def clockPolarity(self): + value = TOsChannel.getClockPolarity(self._nativeOsObj) + return Utils.toSignalPolarity(value) + + @clockPolarity.setter + def clockPolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TOsChannel.setClockPolarity(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set clockPolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gateSource(self): + return Utils.toSignalDrop(TOsChannel.getGateSource(self._nativeOsObj)) + + @gateSource.setter + def gateSource(self, value): + if not isinstance(value, SignalDrop): + raise TypeError('a SignalDrop is required') + ret = ErrorCode.lookup(TOsChannel.setGateSource(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set gateSource is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + value = TOsChannel.getGatePolarity(self._nativeOsObj) + return Utils.toSignalPolarity(value) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TOsChannel.setGatePolarity(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + value = TOsChannel.getOutSignal(self._nativeOsObj) + return Utils.toOutSignaleType(value) + + @outSignal.setter + def outSignal(self, value): + if not isinstance(value, OutSignalType): + raise TypeError("a OutSignalType is required") + ret = ErrorCode.lookup(TOsChannel.setOutSignal(self._nativeOsObj, value.value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/PiChannel.py b/src/components/Automation/BDaq/PiChannel.py new file mode 100644 index 0000000..bb2c749 --- /dev/null +++ b/src/components/Automation/BDaq/PiChannel.py @@ -0,0 +1,27 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TPiChannel, BioFailed +from Automation.BDaq import ErrorCode + + +class PiChannel(object): + def __init__(self, nativePiChanObj): + self._nativePiChanObj = nativePiChanObj + + @property + def channel(self): + return TPiChannel.getChannel(self._nativePiChanObj) + + @property + def noiseFiltered(self): + value = TPiChannel.getNoiseFiltered(self._nativePiChanObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TPiChannel.setNoiseFiltered(self._nativePiChanObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/PoChannel.py b/src/components/Automation/BDaq/PoChannel.py new file mode 100644 index 0000000..2af8102 --- /dev/null +++ b/src/components/Automation/BDaq/PoChannel.py @@ -0,0 +1,93 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq import PulseWidth, ErrorCode, SignalPolarity, OutSignalType +from Automation.BDaq.BDaqApi import TPoChannel, BioFailed +from Automation.BDaq import Utils + + +class PoChannel(object): + def __init__(self, nativePoChannObj): + self._nativePoChannObj = nativePoChannObj + + @property + def channel(self): + return TPoChannel.getChannel(self._nativePoChannObj) + + @property + def noiseFiltered(self): + value = TPoChannel.getNoiseFiltered(self._nativePoChannObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + + ret = ErrorCode.lookup(TPoChannel.setNoiseFiltered(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def pulseWidth(self): + value = PulseWidth() + TPoChannel.getPulseWidth(self._nativePoChannObj, value) + return value + + @pulseWidth.setter + def pulseWidth(self, value): + if not isinstance(value, PulseWidth): + raise TypeError("a PulseWidth is required") + ret = ErrorCode.lookup(TPoChannel.setPulseWidth(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set pulseWidth is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + return Utils.toSignalPolarity(TPoChannel.getGatePolarity(self._nativePoChannObj)) + + @gatePolarity.setter + def gatePolarity(self, varValue): + if not isinstance(varValue, SignalPolarity): + raise TypeError("a SignalPolarity is required") + ret = ErrorCode.lookup(TPoChannel.setGatePolarity(self._nativePoChannObj, varValue.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TPoChannel.getGated(self._nativePoChannObj) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TPoChannel.setGated(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + return Utils.toOutSignaleType(TPoChannel.getOutSignal(self._nativePoChannObj)) + + @outSignal.setter + def outSignal(self, varValue): + if not isinstance(varValue, OutSignalType): + raise TypeError('a OutSignalType is required') + ret = ErrorCode.lookup(TPoChannel.setOutSignal(self._nativePoChannObj, varValue.value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) + + @property + def outCount(self): + return TPoChannel.getOutCount(self._nativePoChannObj) + + @outCount.setter + def outCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TPoChannel.setOutCount(self._nativePoChannObj, value)) + if BioFailed(ret): + raise ValueError('set outCount is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/PwMeterCtrl.py b/src/components/Automation/BDaq/PwMeterCtrl.py new file mode 100644 index 0000000..69f5442 --- /dev/null +++ b/src/components/Automation/BDaq/PwMeterCtrl.py @@ -0,0 +1,32 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, PulseWidth, ErrorCode +from Automation.BDaq.BDaqApi import TArray, TPwMeterCtrl +from Automation.BDaq.PiChannel import PiChannel + + +class PwMeterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(PwMeterCtrl, self).__init__(Scenario.ScePwMeter, devInfo) + self._pi_channesl = [] + + @property + def channels(self): + if not self._pi_channesl: + count = self.features.channelCountMax + nativeArr = TPwMeterCtrl.getChannels(self._obj) + for i in range(count): + piChanObj = PiChannel(TArray.getItem(nativeArr, i)) + self._pi_channesl.append(piChanObj) + return self._pi_channesl + + def read(self, count = 1): + pulseWidthArr = (PulseWidth * count)() + ret = ErrorCode.lookup(TPwMeterCtrl.Read(self._obj, count, pulseWidthArr)) + data = [] + if ret == ErrorCode.Success: + for i in range(count): + data.append(pulseWidthArr[i]) + return ret, data diff --git a/src/components/Automation/BDaq/PwModulatorCtrl.py b/src/components/Automation/BDaq/PwModulatorCtrl.py new file mode 100644 index 0000000..ddbc0ed --- /dev/null +++ b/src/components/Automation/BDaq/PwModulatorCtrl.py @@ -0,0 +1,22 @@ + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario +from Automation.BDaq.PoChannel import PoChannel +from Automation.BDaq.BDaqApi import TArray, TPwModulatorCtrl + + +class PwModulatorCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(PwModulatorCtrl, self).__init__(Scenario.ScePwModulator, devInfo) + self._po_channels = [] + + @property + def channels(self): + if not self._po_channels: + count = self.features.channelCountMax + nativeArr = TPwModulatorCtrl.getChannels(self._obj) + + for i in range(count): + poChannObj = PoChannel(TArray.getItem(nativeArr, i)) + self._po_channels.append(poChannObj) + return self._po_channels diff --git a/src/components/Automation/BDaq/Record.py b/src/components/Automation/BDaq/Record.py new file mode 100644 index 0000000..4a8156a --- /dev/null +++ b/src/components/Automation/BDaq/Record.py @@ -0,0 +1,46 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TRecord, BioFailed +from Automation.BDaq import ErrorCode + + +class Record(object): + def __init__(self, nativeRecordObj): + self._nativeRecordObj = nativeRecordObj + + @property + def sectionLength(self): + return TRecord.getSectionLength(self._nativeRecordObj) + + @sectionLength.setter + def sectionLength(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TRecord.setSectionLength(self._nativeRecordObj, value)) + if BioFailed(ret): + raise ValueError('set sectionLength is failed, the error code is 0x%X' % (ret.value)) + + @property + def sectionCount(self): + return TRecord.getSectionCount(self._nativeRecordObj) + + @sectionCount.setter + def sectionCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TRecord.setSectionCount(self._nativeRecordObj, value)) + if BioFailed(ret): + raise ValueError('set sectionCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def cycles(self): + return TRecord.getCycles(self._nativeRecordObj) + + @cycles.setter + def cycles(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TRecord.setCycles(self._nativeRecordObj, value)) + if BioFailed(ret): + raise ValueError('set cycles is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/ScanChannel.py b/src/components/Automation/BDaq/ScanChannel.py new file mode 100644 index 0000000..6a8cc28 --- /dev/null +++ b/src/components/Automation/BDaq/ScanChannel.py @@ -0,0 +1,58 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import ErrorCode +from Automation.BDaq.BDaqApi import TScanChannel, BioFailed + + +class ScanChannel(object): + def __init__(self, nativeScanChanObj): + self._nativeScanChanObj = nativeScanChanObj + + @property + def channelStart(self): + return TScanChannel.getChannelStart(self._nativeScanChanObj) + + @channelStart.setter + def channelStart(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setChannelStart(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set channelStart is failed, the error code is 0x%X' % (ret.value)) + + @property + def channelCount(self): + return TScanChannel.getChannelCount(self._nativeScanChanObj) + + @channelCount.setter + def channelCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setChannelCount(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set channelCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def samples(self): + return TScanChannel.getSamples(self._nativeScanChanObj) + + @samples.setter + def samples(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setSamples(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set samples is failed, the error code is 0x%X' % (ret.value)) + + @property + def intervalCount(self): + return TScanChannel.getIntervalCount(self._nativeScanChanObj) + + @intervalCount.setter + def intervalCount(self, value): + if not isinstance(value, int): + raise TypeError("a int is required") + ret = ErrorCode.lookup(TScanChannel.setIntervalCount(self._nativeScanChanObj, value)) + if BioFailed(ret): + raise ValueError('set intervalCount is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/TimerPulseCtrl.py b/src/components/Automation/BDaq/TimerPulseCtrl.py new file mode 100644 index 0000000..de94f6a --- /dev/null +++ b/src/components/Automation/BDaq/TimerPulseCtrl.py @@ -0,0 +1,24 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import Scenario +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq.TmrChannel import TmrChannel +from Automation.BDaq.BDaqApi import TArray, TTimerPulseCtrl + + +class TimerPulseCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(TimerPulseCtrl, self).__init__(Scenario.SceTimerPulse, devInfo) + self._tmr_channels = [] + + @property + def channels(self): + if not self._tmr_channels: + count = self.features.channelCountMax + nativeArr = TTimerPulseCtrl.getChannels(self._obj) + + for i in range(count): + tmrChannObj = TmrChannel(TArray.getItem(nativeArr, i)) + self._tmr_channels.append(tmrChannObj) + return self._tmr_channels diff --git a/src/components/Automation/BDaq/TmrChannel.py b/src/components/Automation/BDaq/TmrChannel.py new file mode 100644 index 0000000..3f9d232 --- /dev/null +++ b/src/components/Automation/BDaq/TmrChannel.py @@ -0,0 +1,79 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TTmrChannel, BioFailed +from Automation.BDaq import ErrorCode, SignalPolarity, OutSignalType +from Automation.BDaq import Utils + + +class TmrChannel(object): + def __init__(self, nativeTmrObj): + self._nativeTmrObj = nativeTmrObj + + @property + def channel(self): + return TTmrChannel.getChannel(self._nativeTmrObj) + + @property + def noiseFiltered(self): + value = TTmrChannel.getNoiseFiltered(self._nativeTmrObj) + return True if value else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TTmrChannel.setNoiseFiltered(self._nativeTmrObj, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def frequency(self): + return TTmrChannel.getFrequency(self._nativeTmrObj) + + @frequency.setter + def frequency(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTmrChannel.setFrequency(self._nativeTmrObj, value)) + if BioFailed(ret): + raise ValueError('set frequency is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + value = TTmrChannel.getGatePolarity(self._nativeTmrObj) + return Utils.toSignalPolarity(value) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TTmrChannel.setGatePolarity(self._nativeTmrObj, value.value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def gated(self): + value = TTmrChannel.getGated(self._nativeTmrObj) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TTmrChannel.setGated(self._nativeTmrObj, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + value = TTmrChannel.getOutSignal(self._nativeTmrObj) + return Utils.toOutSignaleType(value) + + @outSignal.setter + def outSignal(self, value): + if not isinstance(value, OutSignalType): + raise TypeError("a OutSignalType is required") + ret = ErrorCode.lookup(TTmrChannel.setOutSignal(self._nativeTmrObj, value.value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/Trigger.py b/src/components/Automation/BDaq/Trigger.py new file mode 100644 index 0000000..a01514e --- /dev/null +++ b/src/components/Automation/BDaq/Trigger.py @@ -0,0 +1,112 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq.BDaqApi import TTrigger, BioFailed +from Automation.BDaq import Utils +from Automation.BDaq import SignalDrop, ErrorCode, ActiveSignal, TriggerAction, FilterType + + +class Trigger(object): + def __init__(self, nativeTrigObj): + self._nativeTrigObj = nativeTrigObj + + @property + def source(self): + value = TTrigger.getSource(self._nativeTrigObj) + return Utils.toSignalDrop(value) + + @source.setter + def source(self, value): + if not isinstance(value, SignalDrop): + raise TypeError("a SignalDrop is required") + ret = ErrorCode.lookup(TTrigger.setSource(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set source is failed, the error code is 0x%X' % (ret.value)) + + @property + def edge(self): + value = TTrigger.getEdge(self._nativeTrigObj) + return Utils.toActiveSignal(value) + + @edge.setter + def edge(self, value): + if not isinstance(value, ActiveSignal): + raise TypeError('a ActiveSignal is required') + ret = ErrorCode.lookup(TTrigger.setEdge(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set edge is failed, the error code is 0x%X' % (ret.value)) + + @property + def level(self): + value = TTrigger.getLevel(self._nativeTrigObj) + return value + + @level.setter + def level(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTrigger.setLevel(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set level is failed, the error code is 0x%X' % (ret.value)) + + @property + def action(self): + value = TTrigger.getAction(self._nativeTrigObj) + return Utils.toTriggerAction(value) + + @action.setter + def action(self, value): + if not isinstance(value, TriggerAction): + raise TypeError('a TriggerAction is required') + ret = ErrorCode.lookup(TTrigger.setAction(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set action is failed, the error code is 0x%X' % (ret.value)) + + @property + def delayCount(self): + return TTrigger.getDelayCount(self._nativeTrigObj) + + @delayCount.setter + def delayCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is requires') + ret = ErrorCode.lookup(TTrigger.setDelayCount(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set delayCount is failed, the error code is 0x%X' % (ret.value)) + + @property + def hysteresisIndex(self): + return TTrigger.getHysteresisIndex(self._nativeTrigObj) + + @hysteresisIndex.setter + def hysteresisIndex(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTrigger.setHysteresisIndex(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set hysteresisIndex is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterType(self): + value = TTrigger.getFilterType(self._nativeTrigObj) + return Utils.toFilterType(value) + + @filterType.setter + def filterType(self, value): + if not isinstance(value, FilterType): + raise TypeError('a FilterType is required') + ret = ErrorCode.lookup(TTrigger.setFilterType(self._nativeTrigObj, value.value)) + if BioFailed(ret): + raise ValueError('set filterType is failed, the error code is 0x%X' % (ret.value)) + + @property + def filterCutoffFreq(self): + return TTrigger.getFilterCutoffFreq(self._nativeTrigObj) + + @filterCutoffFreq.setter + def filterCutoffFreq(self, value): + if not isinstance(value, (float, int)): + raise TypeError('a float is required') + ret = ErrorCode.lookup(TTrigger.setFilterCutoffFreq(self._nativeTrigObj, value)) + if BioFailed(ret): + raise ValueError('set filterCutoffFreq is failed, the error code is 0x%X' % (ret.value)) \ No newline at end of file diff --git a/src/components/Automation/BDaq/UdChannel.py b/src/components/Automation/BDaq/UdChannel.py new file mode 100644 index 0000000..c579516 --- /dev/null +++ b/src/components/Automation/BDaq/UdChannel.py @@ -0,0 +1,132 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + + +from Automation.BDaq.BDaqApi import TUdChannel, BioFailed +from Automation.BDaq import ErrorCode, PulseWidth, CountingType, SignalPolarity, OutSignalType +from Automation.BDaq import Utils + + +class UdChannel(object): + def __init__(self, nativeUdChann): + self._nativeUdChann = nativeUdChann + + @property + def channel(self): + return TUdChannel.getChannel(self._nativeUdChann) + + @property + def noiseFiltered(self): + ret = TUdChannel.getNoiseFiltered(self._nativeUdChann) + return True if ret else False + + @noiseFiltered.setter + def noiseFiltered(self, value): + if not isinstance(value, bool): + raise TypeError("a bool is required") + ret = ErrorCode.lookup(TUdChannel.setNoiseFiltered(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set noiseFiltered is failed, the error code is 0x%X' % (ret.value)) + + @property + def countingType(self): + value = TUdChannel.getCountingType(self._nativeUdChann) + return Utils.toCountingType(value) + + @countingType.setter + def countingType(self, value): + if not isinstance(value, CountingType): + raise TypeError('a CountingType is required') + ret = ErrorCode.lookup(TUdChannel.setCountingType(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set countingType is failed, the error code is 0x%X' % (ret.value)) + + @property + def initialValue(self): + return TUdChannel.getInitialValue(self._nativeUdChann) + + @initialValue.setter + def initialValue(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TUdChannel.setInitialValue(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set initialValue is failed, the error code is 0x%X' % (ret.value)) + + @property + def resetTimesByIndex(self): + return TUdChannel.getResetTimesByIndex(self._nativeUdChann) + + @resetTimesByIndex.setter + def resetTimesByIndex(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TUdChannel.setResetTimesByIndex(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set resetTimesByIndex is failed, the error code is 0x%X' % (ret.value)) + + @property + def pulseWidth(self): + x = PulseWidth() + TUdChannel.getPulseWidth(self._nativeUdChann, x) + return x + + @pulseWidth.setter + def pulseWidth(self, value): + if not isinstance(value, PulseWidth): + raise TypeError('a PulseWidth is required') + ret = ErrorCode.lookup(TUdChannel.setPulseWidth(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set pulseWidth is failed, the error code is 0x%X' % (ret.value)) + + + @property + def gated(self): + value = TUdChannel.getGated(self._nativeUdChann) + return True if value else False + + @gated.setter + def gated(self, value): + if not isinstance(value, bool): + raise TypeError('a bool is required') + ret = ErrorCode.lookup(TUdChannel.setGated(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set gated is failed, the error code is 0x%X' % (ret.value)) + + @property + def gatePolarity(self): + value = TUdChannel.getGatePolarity(self._nativeUdChann) + return Utils.toSignalPolarity(value) + + @gatePolarity.setter + def gatePolarity(self, value): + if not isinstance(value, SignalPolarity): + raise TypeError('a SignalPolarity is required') + ret = ErrorCode.lookup(TUdChannel.setGatePolarity(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set gatePolarity is failed, the error code is 0x%X' % (ret.value)) + + @property + def outSignal(self): + value = TUdChannel.getOutSignal(self._nativeUdChann) + return Utils.toOutSignaleType(value) + + @outSignal.setter + def outSignal(self, value): + if not isinstance(value, OutSignalType): + raise TypeError('a OutSignalType is required') + ret = ErrorCode.lookup(TUdChannel.setOutSignal(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set outSignal is failed, the error code is 0x%X' % (ret.value)) + + @property + def outCount(self): + return TUdChannel.getOutCount(self._nativeUdChann) + + @outCount.setter + def outCount(self, value): + if not isinstance(value, int): + raise TypeError('a int is required') + ret = ErrorCode.lookup(TUdChannel.setOutCount(self._nativeUdChann, value)) + if BioFailed(ret): + raise ValueError('set outCount is failed, the error code is 0x%X' % (ret.value)) diff --git a/src/components/Automation/BDaq/UdCounterCtrl.py b/src/components/Automation/BDaq/UdCounterCtrl.py new file mode 100644 index 0000000..579867f --- /dev/null +++ b/src/components/Automation/BDaq/UdCounterCtrl.py @@ -0,0 +1,37 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int + +from Automation.BDaq.CntrCtrlBase import CntrCtrlBase +from Automation.BDaq import Scenario, ErrorCode +from Automation.BDaq.UdChannel import UdChannel +from Automation.BDaq.BDaqApi import TArray, TUdCounterCtrl + + +class UdCounterCtrl(CntrCtrlBase): + def __init__(self, devInfo = None): + super(UdCounterCtrl, self).__init__(Scenario.SceUdCounter, devInfo) + self._ud_channels = [] + + @property + def channels(self): + if not self._ud_channels: + count = self.features.channelCountMax + nativeArr = TUdCounterCtrl.getChannels(self._obj) + + for i in range(count): + udChannObj = UdChannel(TArray.getItem(nativeArr, i)) + self._ud_channels.append(udChannObj) + return self._ud_channels + + def read(self, count = 1): + dataArr = (c_int * count)() + data = [] + ret = TUdCounterCtrl.Read(self._obj, count, dataArr) + for i in range(count): + data.append(dataArr[i]) + return ErrorCode.lookup(ret), data + + def valueReset(self): + return ErrorCode.lookup(TUdCounterCtrl.ValueReset(self._obj)) diff --git a/src/components/Automation/BDaq/Utils.py b/src/components/Automation/BDaq/Utils.py new file mode 100644 index 0000000..e3135c5 --- /dev/null +++ b/src/components/Automation/BDaq/Utils.py @@ -0,0 +1,203 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from Automation.BDaq import * + + +def CreateArray(DataType, DataNum): + dataArray = (DataType * DataNum)() + return dataArray + +def toAccessMode(value): + value = int(value) + for x in AccessMode: + if x.value == value: + return x + return AccessMode.ModeRead + +def toControlState(value): + value = int(value) + for x in ControlState: + if x.value == value: + return x + return ControlState.Uninited + +def toProductId(value): + value = int(value) + for x in ProductId: + if x.value == value: + return x + return ProductId.BD_UNKNOWN + +def toTerminalBoard(value): + value = int(value) + for x in TerminalBoard: + if x.value == value: + return x + + return TerminalBoard.WiringBoard + +def toDepository(value): + value = int(value) + for x in Depository: + if x.value == value: + return x + return Depository.DepositoryNone + +def toAiChannelType(value): + value = int(value) + for x in AiChannelType: + if x.value == value: + return x + return AiChannelType.AllSingleEnded + +def toAiSignalType(value): + value = int(value) + for x in AiSignalType: + if x.value == value: + return x + return AiSignalType.PseudoDifferential + +def toValueRange(value): + value = int(value) + for x in ValueRange: + if x.value == value: + return x + return ValueRange.V_OMIT + +def toSamplingMethod(value): + value = int(value) + return SamplingMethod.EqualTimeSwitch if value == SamplingMethod.EqualTimeSwitch.value else SamplingMethod.Simultaneous + +def toFilterType(value): + value = int(value) + for x in FilterType: + if x.value == value: + return x + return FilterType.FilterNone + +def toBurnoutRetType(value): + value = int(value) + for x in BurnoutRetType: + if x.value == value: + return x + return BurnoutRetType.Current + +def toSignalDrop(value): + value = int(value) + + for x in SignalDrop: + if x.value == value: + return x + return SignalDrop.SignalNone + +def toSignalPolarity(value): + value = int(value) + + for x in SignalPolarity: + if x.value == value: + return x + return SignalPolarity.Negative + +def toTriggerAction(value): + value = int(value) + + for x in TriggerAction: + if x.value == value: + return x + return TriggerAction.ActionNone + +def toActiveSignal(value): + value = int(value) + + for x in ActiveSignal: + if x.value == value: + return x + return ActiveSignal.ActiveNone + +def toDioPortDir(value): + value = int(value) + for x in DioPortDir: + if x.value == value: + return x + return DioPortDir.Input + +def toDoCircuitType(value): + value = int(value) + + for x in DoCircuitType: + if x.value == value: + return x + return DoCircuitType.TTL + +def toEventId(value): + value = int(value) + + for x in EventId: + if x.value == value: + return x + return EventId.EvtPropertyChanged + +def toCounterCapability(value): + value = int(value) + + for x in CounterCapability: + if x.value == value: + return x + return CounterCapability.Primary + +def toCounterCascadeGroup(value): + value = int(value) + + for x in CounterCascadeGroup: + if x.value == value: + return x + return CounterCascadeGroup.GroupNone + +def toFreqMeasureMethod(value): + value = int(value) + + for x in FreqMeasureMethod: + if x.value == value: + return x + return FreqMeasureMethod.AutoAdaptive + +def toCountingType(value): + value = int(value) + for x in CountingType: + if x.value == value: + return x + return CountingType.CountingNone + +def toOutSignaleType(value): + value = int(value) + + for x in OutSignalType: + if x.value == value: + return x + return OutSignalType.SignalOutNone + +def toCouplingType(value): + value = int(value) + + for x in CouplingType: + if x.value == value: + return x + + return CouplingType.ACCoupling + +def toIepeType(value): + value = int(value) + + for x in IepeType: + if x.value == value: + return x + return IepeType.IEPENone + +def toImpedanceType(value): + value = int(value) + + for x in ImpedanceType: + if x.value == value: + return x + return ImpedanceType.Ipd1Momh diff --git a/src/components/Automation/BDaq/WaveformAiCtrl.py b/src/components/Automation/BDaq/WaveformAiCtrl.py new file mode 100644 index 0000000..cb974af --- /dev/null +++ b/src/components/Automation/BDaq/WaveformAiCtrl.py @@ -0,0 +1,95 @@ +#!/usr/bin/python +# -*- coding:utf-8 -*- + +from ctypes import c_int32, c_int16, c_double, byref, c_int + +from Automation.BDaq.AiCtrlBase import AiCtrlBase +from Automation.BDaq import Scenario, DataMark, ErrorCode, MAX_TRIG_COUNT +from Automation.BDaq.Conversion import Conversion +from Automation.BDaq.Record import Record +from Automation.BDaq.BDaqApi import TWaveformAiCtrl +from Automation.BDaq.Trigger import Trigger + + +class WaveformAiCtrl(AiCtrlBase): + def __init__(self, devInfo = None): + super(WaveformAiCtrl, self).__init__(Scenario.SceWaveformAi, devInfo) + self._conversion = None + self._record = None + self._triggers = [] + + @property + def conversion(self): + if self._conversion is None: + nativeConver = TWaveformAiCtrl.getConversion(self._obj) + self._conversion = Conversion(nativeConver, self.features.channelCountMax) + return self._conversion + + @property + def record(self): + if self._record is None: + nativeRecord = TWaveformAiCtrl.getRecord(self._obj) + self._record = Record(nativeRecord) + return self._record + + @property + def trigger(self): + if not self._triggers: + self._triggers = [None] * MAX_TRIG_COUNT + + for i in range(self.features.triggerCount): + self._triggers[i] = Trigger(TWaveformAiCtrl.getTrigger(self._obj, i)) + return self._triggers + + def prepare(self): + ret = TWaveformAiCtrl.Prepare(self._obj) + return ErrorCode.lookup(ret) + + def start(self): + ret = TWaveformAiCtrl.Start(self._obj) + return ErrorCode.lookup(ret) + + def stop(self): + return ErrorCode.lookup(TWaveformAiCtrl.Stop(self._obj)) + + def getDataI16(self, count, timeout = 0, startTime = None, markCount = None): + dataArr = (c_int16 * count)() + return self.__getData(2, count, dataArr, timeout, startTime, markCount) + + def getDataI32(self, count, timeout = 0, startTime = None, markCount = None): + dataArr = (c_int32 * count)() + return self.__getData(4, count, dataArr, timeout, startTime, markCount) + + def getDataF64(self, count, timeout = 0, startTime = None, markCount = None): + dataArr = (c_double * count)() + return self.__getData(8, count, dataArr, timeout, startTime, markCount) + + def __getData(self, dt, count, dataArr, timeout, startTime, markCount): + returned = (c_int * 1)() + dataBuf = [] + startTimeClock = startTime + if startTime is not None: + startTimeClock = (c_double * 1)() + + markBufTmp = None + markCountTmp = None + if markCount is not None and isinstance(markCount, int): + markBufTmp = (DataMark * markCount)() + markCountTmp = (c_int32 * 1)() + + ret = TWaveformAiCtrl.GetData(self._obj, dt, count, dataArr, timeout, returned, startTimeClock, markCountTmp, + markBufTmp) + + for i in range(returned[0]): + dataBuf.append(dataArr[i]) + + startTimeClock = None if startTimeClock is None else startTimeClock[0] + markCountTmp = None if markCount is None else markCountTmp[0] + if markCount is None: + markBuf = None + else: + markBuf = [] + for i in range(markCountTmp): + markBuf.append(markBufTmp[i]) + return ErrorCode.lookup(ret), returned[0], dataBuf, startTimeClock, markCountTmp, markBuf + diff --git a/src/components/Automation/BDaq/__init__.py b/src/components/Automation/BDaq/__init__.py new file mode 100644 index 0000000..b0703fd --- /dev/null +++ b/src/components/Automation/BDaq/__init__.py @@ -0,0 +1,2427 @@ +import sys +if sys.version_info[:3] < (3,4): + sys.path.append('../3rd_party') +from enum import Enum, IntEnum +from ctypes import Structure, c_int32, c_double, c_int64, c_wchar +from ctypes import c_uint8 + + +DAQ_NAVI_VER = 0x400 + +MAX_DEVICE_DESC_LEN = 64 +MAX_VRG_DESC_LEN = 256 +MAX_SIG_DROP_DESC_LEN = 256 + +MAX_AI_CH_COUNT = 128 +MAX_AO_CH_COUNT = 128 +MAX_DIO_PORT_COUNT = 32 +MAX_CNTR_CH_COUNT = 8 +MAX_TRIG_COUNT = 4 +MAX_DIO_TRIG_COUNT = 2 + + +class TerminalBoard(IntEnum): + WiringBoard = 0 + PCLD8710 = 1 + PCLD789 = 2 + PCLD8115 = 3 + + +class ModuleType(IntEnum): + DaqGroup = 1 + DaqDevice = 2 + DaqAi = 3 + DaqAo = 4 + DaqDio = 5 + DaqCounter = 6 + DaqCali = 7 + DaqAny = -1 + + +class AccessMode(IntEnum): + ModeRead = 0 + ModeWrite = 1 + ModeWriteWithReset = 2 + ModeWriteShared = 3 + + +class Depository(IntEnum): + DepositoryNone = 0 + DepositoryOnSystem = 1 + DepositoryOnDevice = 2 + + +class MathIntervalType(IntEnum): + # Right boundary definition, define the maximum value state, use the bit 0,1 + RightOpenSet = 0x0, # No maximum value limitation. + RightClosedBoundary = 0x1, # The maximum value is included. + RightOpenBoundary = 0x2, # The maximum value is not included. + + # Left boundary definition, define the minimum value state, used the bit 2, 3 + LeftOpenSet = 0x0, # No minimum value limitation. + LeftClosedBoundary = 0x4, # The minimum value is included. + LeftOpenBoundary = 0x8, # The minimum value is not included + + # The signality expression + Boundless = 0x0, # Boundless set. (LeftOpenSet | RightOpenSet) + + # The combination notation + LOSROS = 0x0, # (LeftOpenSet | RightOpenSet), algebra notation: (un-limit, max) + LOSRCB = 0x1, # (LeftOpenSet | RightClosedBoundary), algebra notation: (un-limit, max ] + LOSROB = 0x2, # (LeftOpenSet | RightOpenBoundary), algebra notation: (un-limit, max) + + LCBROS = 0x4, # (LeftClosedBoundary | RightOpenSet), algebra notation: [min, un-limit) + LCBRCB = 0x5, # (LeftClosedBoundary | RightClosedBoundary), algebra notation: [ min, right ] + LCBROB = 0x6, # (LeftClosedBoundary | RightOpenBoundary), algebra notation: [ min, right) + + LOBROS = 0x8, # (LeftOpenBoundary | RightOpenSet), algebra notation: (min, un-limit) + LOBRCB = 0x9, # (LeftOpenBoundary | RightClosedBoundary), algebra notation: (min, right ] + LOBROB = 0xA, # (LeftOpenBoundary | RightOpenBoundary), algebra notation: (min, right) + + +class AiChannelType(IntEnum): + AllSingleEnded = 0 + AllDifferential = 1 + AllSeDiffAdj = 2 + MixedSeDiffAdj = 3 + + +class AiSignalType(IntEnum): + SingleEnded = 0 + Differential = 1 + PseudoDifferential = 2 + + +class CouplingType(IntEnum): + DCCoupling = 0 + ACCoupling = 1 + + +class ImpedanceType(IntEnum): + Ipd1Momh = 0 + Ipd50omh = 1 + + +class IepeType(IntEnum): + IEPENone = 0 + IEPE4mA = 1 + IEPE10mA = 2 + IEPE2mA = 3 + + +class FilterType(IntEnum): + FilterNone = 0 + LowPass = 1 + HighPass = 2 + BandPass = 3 + BandStop = 4 + + +class DioPortType(IntEnum): + PortDi = 0 # the port number references to a DI port + PortDo = 1 # the port number references to a DO port + PortDio = 2 # the port number references to a DI port and a DO port + Port8255A = 3 # the port number references to a PPI port A mode DIO port. + Port8255C = 4 # the port number references to a PPI port C mode DIO port. + PortIndvdlDio = 5 # the port number references to a port whose each channel can be configured as in or out. + + +class DioPortDir(IntEnum): + Input = 0x00 + LoutHin = 0x0F + LinHout = 0xF0 + Output = 0xFF + + +class DoCircuitType(IntEnum): + TTL = 0 + Sink = 1 + Source = 2 + Relay = 3 + + +class SamplingMethod(IntEnum): + EqualTimeSwitch = 0 + Simultaneous = 1 + + +class TemperatureDegree(IntEnum): + Celsius = 0 + Fahrenheit = 1 + Rankine = 2 + Kelvin = 3 + + +class BurnoutRetType(IntEnum): + Current = 0 + ParticularValue = 1 + UpLimit = 2 + LowLimit = 3 + LastCorrectValue = 4 + + +class ValueUnit(IntEnum): + Kilovolt = 0 # KV + Volt = 1 # V + Millivolt = 2 # mV + Microvolt = 3 # uV + Kiloampere = 4 # KA + Ampere = 5 # A + Milliampere = 6 # mA + Microampere = 7 # uA + CelsiusUnit = 8 # Celsius + + +class ValueRange(IntEnum): + V_OMIT = -1 # Unknown when get, ignored when set + V_Neg15To15 = 0 # +/- 15 V + V_Neg10To10 = 1 # +/- 10 V + V_Neg5To5 = 2 # +/- 5 V + V_Neg2pt5To2pt5 = 3 # +/- 2.5 V + V_Neg1pt25To1pt25 = 4 # +/- 1.25 V + V_Neg1To1 = 5 # +/- 1 V + + V_0To15 = 6 # 0~15 V + V_0To10 = 7 # 0~10 V + V_0To5 = 8 # 0~5 V + V_0To2pt5 = 9 # 0~2.5 V + V_0To1pt25 = 10 # 0~1.25 V + V_0To1 = 11 # 0~1 V + + mV_Neg625To625 = 12 # +/- 625mV + mV_Neg500To500 = 13 # +/- 500 mV + mV_Neg312pt5To312pt5 = 14 # +/- 312.5 mV + mV_Neg200To200 = 15 # +/- 200 mV + mV_Neg150To150 = 16 # +/- 150 mV + mV_Neg100To100 = 17 # +/- 100 mV + mV_Neg50To50 = 18 # +/- 50 mV + mV_Neg30To30 = 19 # +/- 30 mV + mV_Neg20To20 = 20 # +/- 20 mV + mV_Neg15To15 = 21 # +/- 15 mV + mV_Neg10To10 = 22 # +/- 10 mV + mV_Neg5To5 = 23 # +/- 5 mV + + mV_0To625 = 24 # 0 ~ 625 mV + mV_0To500 = 25 # 0 ~ 500 mV + mV_0To150 = 26 # 0 ~ 150 mV + mV_0To100 = 27 # 0 ~ 100 mV + mV_0To50 = 28 # 0 ~ 50 mV + mV_0To20 = 29 # 0 ~ 20 mV + mV_0To15 = 30 # 0 ~ 15 mV + mV_0To10 = 31 # 0 ~ 10 mV + + mA_Neg20To20 = 32 # +/- 20mA + mA_0To20 = 33 # 0 ~ 20 mA + mA_4To20 = 34 # 4 ~ 20 mA + mA_0To24 = 35 # 0 ~ 24 mA + + # For USB4702_4704 + V_Neg2To2 = 36 # +/- 2 V + V_Neg4To4 = 37 # +/- 4 V + V_Neg20To20 = 38 # +/- 20 V + + Jtype_0To760C = 0x8000 # T/C J type 0~760 'C + Ktype_0To1370C = 0x8001 # T/C K type 0~1370 'C + Ttype_Neg100To400C = 0x8002 # T/C T type -100~400 'C + Etype_0To1000C = 0x8003 # T/C E type 0~1000 'C + Rtype_500To1750C = 0x8004 # T/C R type 500~1750 'C + Stype_500To1750C = 0x8005 # T/C S type 500~1750 'C + Btype_500To1800C = 0x8006 # T/C B type 500~1800 'C + + Pt392_Neg50To150 = 0x8007 # Pt392 -50~150 'C + Pt385_Neg200To200 = 0x8008 # Pt385 -200~200 'C + Pt385_0To400 = 0x8009 # Pt385 0~400 'C + Pt385_Neg50To150 = 0x800a # Pt385 -50~150 'C + Pt385_Neg100To100 = 0x800b # Pt385 -100~100 'C + Pt385_0To100 = 0x800c # Pt385 0~100 'C + Pt385_0To200 = 0x800d # Pt385 0~200 'C + Pt385_0To600 = 0x800e # Pt385 0~600 'C + Pt392_Neg100To100 = 0x800f # Pt392 -100~100 'C + Pt392_0To100 = 0x8010 # Pt392 0~100 'C + Pt392_0To200 = 0x8011 # Pt392 0~200 'C + Pt392_0To600 = 0x8012 # Pt392 0~600 'C + Pt392_0To400 = 0x8013 # Pt392 0~400 'C + Pt392_Neg200To200 = 0x8014 # Pt392 -200~200 'C + Pt1000_Neg40To160 = 0x8015 # Pt1000 -40~160 'C + + Balcon500_Neg30To120 = 0x8016 # Balcon500 -30~120 'C + + Ni518_Neg80To100 = 0x8017 # Ni518 -80~100 'C + Ni518_0To100 = 0x8018 # Ni518 0~100 'C + Ni508_0To100 = 0x8019 # Ni508 0~100 'C + Ni508_Neg50To200 = 0x801a # Ni508 -50~200 'C + + Thermistor_3K_0To100 = 0x801b # Thermistor 3K 0~100 'C + Thermistor_10K_0To100 = 0x801c # Thermistor 10K 0~100 'C + + Jtype_Neg210To1200C = 0x801d # T/C J type -210~1200 'C + Ktype_Neg270To1372C = 0x801e # T/C K type -270~1372 'C + Ttype_Neg270To400C = 0x801f # T/C T type -270~400 'C + Etype_Neg270To1000C = 0x8020 # T/C E type -270~1000 'C + Rtype_Neg50To1768C = 0x8021 # T/C R type -50~1768 'C + Stype_Neg50To1768C = 0x8022 # T/C S type -50~1768 'C + Btype_40To1820C = 0x8023 # T/C B type 40~1820 'C + + Jtype_Neg210To870C = 0x8024 # T/C J type -210~870 'C + Rtype_0To1768C = 0x8025 # T/C R type 0~1768 'C + Stype_0To1768C = 0x8026 # T/C S type 0~1768 'C + Ttype_Neg20To135C = 0x8027 # T/C T type -20~135 'C + + V_0To30 = 0x8028 # 0 ~ 30 V + A_0To3 = 0x8029 # 0 ~ 3 A + + Pt100_Neg50To150 = 0x802a # Pt100 -50~150 'C + Pt100_Neg200To200 = 0x802b # Pt100 -200~200 'C + Pt100_0To100 = 0x802c # Pt100 0~100 'C + Pt100_0To200 = 0x802d # Pt100 0~200 'C + Pt100_0To400 = 0x802e # Pt100 0~400 'C + Btype_300To1820C = 0x802f # T/C B type 300~1820 'C + + V_Neg12pt5To12pt5 = 0x8030 # +/- 12.5 V + + # 0xC000 ~ 0xF000 : user customized value range type + UserCustomizedVrgStart = 0xC000 + UserCustomizedVrgEnd = 0xF000 + + # AO external reference type + V_ExternalRefBipolar = 0xF001 # External reference voltage unipolar + V_ExternalRefUnipolar = 0xF002 # External reference voltage bipolar + + +class SignalPolarity(IntEnum): + Negative = 0 + Positive = 1 + + +class CountingType(IntEnum): + CountingNone = 0 + DownCount = 1 # counter value decreases on each clock + UpCount = 2 # counter value increases on each clock + PulseDirection = 3 # counting direction is determined by two signals, one is clock, the other is direction signal + TwoPulse = 4 # counting direction is determined by two signals, one is up-counting signal, the other is down-counting signal + AbPhaseX1 = 5 # AB phase, 1x rate up/down counting + AbPhaseX2 = 6 # AB phase, 2x rate up/down counting + AbPhaseX4 = 7 # AB phase, 4x rate up/down counting + + +class OutSignalType(IntEnum): + SignalOutNone = 0 # no output or output is 'disabled' + ChipDefined = 1 # hardware chip defined + NegChipDefined = 2 # hardware chip defined, negative logical + PositivePulse = 3 # a low-to-high pulse + NegativePulse = 4 # a high-to-low pulse + ToggledFromLow = 5 # the level toggled from low to high + ToggledFromHigh = 6 # the level toggled from high to low + + +class CounterCapability(IntEnum): + Primary = 1 + InstantEventCount = 2 + OneShot = 3 + TimerPulse = 4 + InstantFreqMeter = 5 + InstantPwmIn = 6 + InstantPwmOut = 7 + UpDownCount = 8 + BufferedEventCount = 9 + BufferedPwmIn = 10 + BufferedPwmOut = 11 + BufferedUpDownCount = 12 + InstantEdgeSeparation = 13 + + +class CounterOperationMode(IntEnum): + C8254_M0 = 0 # 8254 mode 0, interrupt on terminal count + C8254_M1 = 1 # 8254 mode 1, hardware retriggerable one-shot + C8254_M2 = 2 # 8254 mode 2, rate generator + C8254_M3 = 3 # 8254 mode 3, square save mode + C8254_M4 = 4 # 8254 mode 4, software triggered strobe + C8254_M5 = 5 # 8254 mode 5, hardware triggered strobe + + C1780_MA = 6 # Mode A level & pulse out, Software-Triggered without Hardware Gating + C1780_MB = 7 # Mode B level & pulse out, Software-Triggered with Level Gating, = 8254_M0 + C1780_MC = 8 # Mode C level & pulse out, Hardware-triggered strobe level + C1780_MD = 9 # Mode D level & Pulse out, Rate generate with no hardware gating + C1780_ME = 10 # Mode E level & pulse out, Rate generator with level Gating + C1780_MF = 11 # Mode F level & pulse out, Non-retriggerable One-shot (Pulse type = 8254_M1) + C1780_MG = 12 # Mode G level & pulse out, Software-triggered delayed pulse one-shot + C1780_MH = 13 # Mode H level & pulse out, Software-triggered delayed pulse one-shot with hardware gating + C1780_MI = 14 # Mode I level & pulse out, Hardware-triggered delay pulse strobe + C1780_MJ = 15 # Mode J level & pulse out, Variable Duty Cycle Rate Generator with No Hardware Gating + C1780_MK = 16 # Mode K level & pulse out, Variable Duty Cycle Rate Generator with Level Gating + C1780_ML = 17 # Mode L level & pulse out, Hardware-Triggered Delayed Pulse One-Shot + C1780_MO = 18 # Mode O level & pulse out, Hardware-Triggered Strobe with Edge Disarm + C1780_MR = 19 # Mode R level & pulse out, Non-Retriggerbale One-Shot with Edge Disarm + C1780_MU = 20 # Mode U level & pulse out, Hardware-Triggered Delayed Pulse Strobe with Edge Disarm + C1780_MX = 21 # Mode X level & pulse out, Hardware-Triggered Delayed Pulse One-Shot with Edge Disarm + + +class CounterValueRegister(IntEnum): + CntLoad = 0 + CntPreset = 0 + CntHold = 1 + CntOverCompare = 2 + CntUnderCompare = 3 + + +class CounterCascadeGroup(IntEnum): + GroupNone = 0 # no cascade + Cnt0Cnt1 = 1 # Counter 0 as first, counter 1 as second. + Cnt2Cnt3 = 2 # Counter 2 as first, counter 3 as second + Cnt4Cnt5 = 3 # Counter 4 as first, counter 5 as second + Cnt6Cnt7 = 4 # Counter 6 as first, counter 7 as second + + +class FreqMeasureMethod(IntEnum): + AutoAdaptive = 0 # Intelligently select the measurement method according to the input signal. + CountingPulseBySysTime = 1 # Using system timing clock to calculate the frequency + CountingPulseByDevTime = 2 # Using the device timing clock to calculate the frequency + PeriodInverse = 3 # Calculate the frequency from the period of the signal + + +class ActiveSignal(IntEnum): + ActiveNone = 0 + RisingEdge = 1 + FallingEdge = 2 + BothEdge = 3 + HighLevel = 4 + LowLevel = 5 + + +class TriggerAction(IntEnum): + ActionNone = 0 # No action to take even if the trigger condition is satisfied + DelayToStart = 1 # Begin to start after the specified time is elapsed if the trigger condition is satisfied + DelayToStop = 2 # Stop execution after the specified time is elapsed if the trigger condition is satisfied + Mark = 3 # Generate a mark data + + +class SignalPosition(IntEnum): + InternalSig = 0 + OnConnector = 1 + OnAmsi = 2 + + +class SignalDrop(IntEnum): + SignalNone = 0 # No connection + + # Internal signal connector + SigInternalClock = 1 # Device built-in clock, If the device has several built-in clock, this represent the highest freq one. + SigInternal1KHz = 2 # Device built-in clock, 1KHz + SigInternal10KHz = 3 # Device built-in clock, 10KHz + SigInternal100KHz = 4 # Device built-in clock, 100KHz + SigInternal1MHz = 5 # Device built-in clock, 1MHz + SigInternal10MHz = 6 # Device built-in clock, 10MHz + SigInternal20MHz = 7 # Device built-in clock, 20MHz + SigInternal30MHz = 8 # Device built-in clock, 30MHz + SigInternal40MHz = 9 # Device built-in clock, 40MHz + SigInternal50MHz = 10 # Device built-in clock, 50MHz + SigInternal60MHz = 11 # Device built-in clock, 60MHz + + SigDiPatternMatch = 12 # When DI pattern match occurred + SigDiStatusChange = 13 # When DI status change occurred + + # Function pin on connector + SigExtAnaClock = 14 # Analog clock pin of connector + SigExtAnaScanClock = 15 # scan clock pin of connector + SigExtAnaTrigger = 16 # external analog trigger pin of connector + SigExtAnaTrigger0 = 16, # external analog trigger pin of connector 0 + SigExtDigClock = 17 # digital clock pin of connector + SigExtDigTrigger0 = 18 # external digital trigger 0 pin(or DI start trigger pin) of connector + SigExtDigTrigger1 = 19 # external digital trigger 1 pin(or DI stop trigger pin) of connector + SigExtDigTrigger2 = 20 # external digital trigger 2 pin(or DO start trigger pin) of connector + SigExtDigTrigger3 = 21 # external digital trigger 3 pin(or DO stop trigger pin) of connector + SigCHFrzDo = 22 # Channel freeze DO ports pin + + # Signal source or target on the connector + # AI channel pins + SigAi0 = 23 + SigAi1 = 24 + SigAi2 = 25 + SigAi3 = 26 + SigAi4 = 27 + SigAi5 = 28 + SigAi6 = 29 + SigAi7 = 30 + SigAi8 = 31 + SigAi9 = 32 + SigAi10 = 33 + SigAi11 = 34 + SigAi12 = 35 + SigAi13 = 36 + SigAi14 = 37 + SigAi15 = 38 + SigAi16 = 39 + SigAi17 = 40 + SigAi18 = 41 + SigAi19 = 42 + SigAi20 = 43 + SigAi21 = 44 + SigAi22 = 45 + SigAi23 = 46 + SigAi24 = 47 + SigAi25 = 48 + SigAi26 = 49 + SigAi27 = 50 + SigAi28 = 51 + SigAi29 = 52 + SigAi30 = 53 + SigAi31 = 54 + SigAi32 = 55 + SigAi33 = 56 + SigAi34 = 57 + SigAi35 = 58 + SigAi36 = 59 + SigAi37 = 60 + SigAi38 = 61 + SigAi39 = 62 + SigAi40 = 63 + SigAi41 = 64 + SigAi42 = 65 + SigAi43 = 66 + SigAi44 = 67 + SigAi45 = 68 + SigAi46 = 69 + SigAi47 = 70, + SigAi48 = 71 + SigAi49 = 72 + SigAi50 = 73 + SigAi51 = 74 + SigAi52 = 75 + SigAi53 = 76 + SigAi54 = 77 + SigAi55 = 78 + SigAi56 = 79 + SigAi57 = 80 + SigAi58 = 81 + SigAi59 = 82 + SigAi60 = 83 + SigAi61 = 84 + SigAi62 = 85 + SigAi63 = 86 + + # AO channel pins + SigAo0 = 87 + SigAo1 = 88 + SigAo2 = 89 + SigAo3 = 90 + SigAo4 = 91 + SigAo5 = 92 + SigAo6 = 93 + SigAo7 = 94 + SigAo8 = 95 + SigAo9 = 96 + SigAo10 = 97 + SigAo11 = 98 + SigAo12 = 99 + SigAo13 = 100 + SigAo14 = 101 + SigAo15 = 102 + SigAo16 = 103 + SigAo17 = 104 + SigAo18 = 105 + SigAo19 = 106 + SigAo20 = 107 + SigAo21 = 108 + SigAo22 = 109 + SigAo23 = 110 + SigAo24 = 111 + SigAo25 = 112 + SigAo26 = 113 + SigAo27 = 114 + SigAo28 = 115 + SigAo29 = 116 + SigAo30 = 117 + SigAo31 = 118 + + # DI pins + SigDi0 = 119 + SigDi1 = 120 + SigDi2 = 121 + SigDi3 = 122 + SigDi4 = 123 + SigDi5 = 124 + SigDi6 = 125 + SigDi7 = 126 + SigDi8 = 127 + SigDi9 = 128 + SigDi10 = 129 + SigDi11 = 130 + SigDi12 = 131 + SigDi13 = 132 + SigDi14 = 133 + SigDi15 = 134 + SigDi16 = 135 + SigDi17 = 136 + SigDi18 = 137 + SigDi19 = 138 + SigDi20 = 139 + SigDi21 = 140 + SigDi22 = 141 + SigDi23 = 142 + SigDi24 = 143 + SigDi25 = 144 + SigDi26 = 145 + SigDi27 = 146 + SigDi28 = 147 + SigDi29 = 148 + SigDi30 = 149 + SigDi31 = 150 + SigDi32 = 151 + SigDi33 = 152 + SigDi34 = 153 + SigDi35 = 154 + SigDi36 = 155 + SigDi37 = 156 + SigDi38 = 157 + SigDi39 = 158 + SigDi40 = 159 + SigDi41 = 160 + SigDi42 = 161 + SigDi43 = 162 + SigDi44 = 163 + SigDi45 = 164 + SigDi46 = 165 + SigDi47 = 166 + SigDi48 = 167 + SigDi49 = 168 + SigDi50 = 169 + SigDi51 = 170 + SigDi52 = 171 + SigDi53 = 172 + SigDi54 = 173 + SigDi55 = 174 + SigDi56 = 175 + SigDi57 = 176 + SigDi58 = 177 + SigDi59 = 178 + SigDi60 = 179 + SigDi61 = 180 + SigDi62 = 181 + SigDi63 = 182 + SigDi64 = 183 + SigDi65 = 184 + SigDi66 = 185 + SigDi67 = 186 + SigDi68 = 187 + SigDi69 = 188 + SigDi70 = 189 + SigDi71 = 190 + SigDi72 = 191 + SigDi73 = 192 + SigDi74 = 193 + SigDi75 = 194 + SigDi76 = 195 + SigDi77 = 196 + SigDi78 = 197 + SigDi79 = 198 + SigDi80 = 199 + SigDi81 = 200 + SigDi82 = 201 + SigDi83 = 202 + SigDi84 = 203 + SigDi85 = 204 + SigDi86 = 205 + SigDi87 = 206 + SigDi88 = 207 + SigDi89 = 208 + SigDi90 = 209 + SigDi91 = 210 + SigDi92 = 211 + SigDi93 = 212 + SigDi94 = 213 + SigDi95 = 214 + SigDi96 = 215 + SigDi97 = 216 + SigDi98 = 217 + SigDi99 = 218 + SigDi100 = 219 + SigDi101 = 220 + SigDi102 = 221 + SigDi103 = 222 + SigDi104 = 223 + SigDi105 = 224 + SigDi106 = 225 + SigDi107 = 226 + SigDi108 = 227 + SigDi109 = 228 + SigDi110 = 229 + SigDi111 = 230 + SigDi112 = 231 + SigDi113 = 232 + SigDi114 = 233 + SigDi115 = 234 + SigDi116 = 235 + SigDi117 = 236 + SigDi118 = 237 + SigDi119 = 238 + SigDi120 = 239 + SigDi121 = 240 + SigDi122 = 241 + SigDi123 = 242 + SigDi124 = 243 + SigDi125 = 244 + SigDi126 = 245 + SigDi127 = 246 + SigDi128 = 247 + SigDi129 = 248 + SigDi130 = 249 + SigDi131 = 250 + SigDi132 = 251 + SigDi133 = 252 + SigDi134 = 253 + SigDi135 = 254 + SigDi136 = 255 + SigDi137 = 256 + SigDi138 = 257 + SigDi139 = 258 + SigDi140 = 259 + SigDi141 = 260 + SigDi142 = 261 + SigDi143 = 262 + SigDi144 = 263 + SigDi145 = 264 + SigDi146 = 265 + SigDi147 = 266 + SigDi148 = 267 + SigDi149 = 268 + SigDi150 = 269 + SigDi151 = 270 + SigDi152 = 271 + SigDi153 = 272 + SigDi154 = 273 + SigDi155 = 274 + SigDi156 = 275 + SigDi157 = 276 + SigDi158 = 277 + SigDi159 = 278 + SigDi160 = 279 + SigDi161 = 280 + SigDi162 = 281 + SigDi163 = 282 + SigDi164 = 283 + SigDi165 = 284 + SigDi166 = 285 + SigDi167 = 286 + SigDi168 = 287 + SigDi169 = 288 + SigDi170 = 289 + SigDi171 = 290 + SigDi172 = 291 + SigDi173 = 292 + SigDi174 = 293 + SigDi175 = 294 + SigDi176 = 295 + SigDi177 = 296 + SigDi178 = 297 + SigDi179 = 298 + SigDi180 = 299 + SigDi181 = 300 + SigDi182 = 301 + SigDi183 = 302 + SigDi184 = 303 + SigDi185 = 304 + SigDi186 = 305 + SigDi187 = 306 + SigDi188 = 307 + SigDi189 = 308 + SigDi190 = 309 + SigDi191 = 310 + SigDi192 = 311 + SigDi193 = 312 + SigDi194 = 313 + SigDi195 = 314 + SigDi196 = 315 + SigDi197 = 316 + SigDi198 = 317 + SigDi199 = 318 + SigDi200 = 319 + SigDi201 = 320 + SigDi202 = 321 + SigDi203 = 322 + SigDi204 = 323 + SigDi205 = 324 + SigDi206 = 325 + SigDi207 = 326 + SigDi208 = 327 + SigDi209 = 328 + SigDi210 = 329 + SigDi211 = 330 + SigDi212 = 331 + SigDi213 = 332 + SigDi214 = 333 + SigDi215 = 334 + SigDi216 = 335 + SigDi217 = 336 + SigDi218 = 337 + SigDi219 = 338 + SigDi220 = 339 + SigDi221 = 340 + SigDi222 = 341 + SigDi223 = 342 + SigDi224 = 343 + SigDi225 = 344 + SigDi226 = 345 + SigDi227 = 346 + SigDi228 = 347 + SigDi229 = 348 + SigDi230 = 349 + SigDi231 = 350 + SigDi232 = 351 + SigDi233 = 352 + SigDi234 = 353 + SigDi235 = 354 + SigDi236 = 355 + SigDi237 = 356 + SigDi238 = 357 + SigDi239 = 358 + SigDi240 = 359 + SigDi241 = 360 + SigDi242 = 361 + SigDi243 = 362 + SigDi244 = 363 + SigDi245 = 364 + SigDi246 = 365 + SigDi247 = 366 + SigDi248 = 367 + SigDi249 = 368 + SigDi250 = 369 + SigDi251 = 370 + SigDi252 = 371 + SigDi253 = 372 + SigDi254 = 373 + SigDi255 = 374 + + # DIO pins + SigDio0 = 375 + SigDio1 = 376 + SigDio2 = 377 + SigDio3 = 378 + SigDio4 = 379 + SigDio5 = 380 + SigDio6 = 381 + SigDio7 = 382 + SigDio8 = 383 + SigDio9 = 384 + SigDio10 = 385 + SigDio11 = 386 + SigDio12 = 387 + SigDio13 = 388 + SigDio14 = 389 + SigDio15 = 390 + SigDio16 = 391 + SigDio17 = 392 + SigDio18 = 393 + SigDio19 = 394 + SigDio20 = 395 + SigDio21 = 396 + SigDio22 = 397 + SigDio23 = 398 + SigDio24 = 399 + SigDio25 = 400 + SigDio26 = 401 + SigDio27 = 402 + SigDio28 = 403 + SigDio29 = 404 + SigDio30 = 405 + SigDio31 = 406 + SigDio32 = 407 + SigDio33 = 408 + SigDio34 = 409 + SigDio35 = 410 + SigDio36 = 411 + SigDio37 = 412 + SigDio38 = 413 + SigDio39 = 414 + SigDio40 = 415 + SigDio41 = 416 + SigDio42 = 417 + SigDio43 = 418 + SigDio44 = 419 + SigDio45 = 420 + SigDio46 = 421 + SigDio47 = 422 + SigDio48 = 423 + SigDio49 = 424 + SigDio50 = 425 + SigDio51 = 426 + SigDio52 = 427 + SigDio53 = 428 + SigDio54 = 429 + SigDio55 = 430 + SigDio56 = 431 + SigDio57 = 432 + SigDio58 = 433 + SigDio59 = 434 + SigDio60 = 435 + SigDio61 = 436 + SigDio62 = 437 + SigDio63 = 438 + SigDio64 = 439 + SigDio65 = 440 + SigDio66 = 441 + SigDio67 = 442 + SigDio68 = 443 + SigDio69 = 444 + SigDio70 = 445 + SigDio71 = 446 + SigDio72 = 447 + SigDio73 = 448 + SigDio74 = 449 + SigDio75 = 450 + SigDio76 = 451 + SigDio77 = 452 + SigDio78 = 453 + SigDio79 = 454 + SigDio80 = 455 + SigDio81 = 456 + SigDio82 = 457 + SigDio83 = 458 + SigDio84 = 459 + SigDio85 = 460 + SigDio86 = 461 + SigDio87 = 462 + SigDio88 = 463 + SigDio89 = 464 + SigDio90 = 465 + SigDio91 = 466 + SigDio92 = 467 + SigDio93 = 468 + SigDio94 = 469 + SigDio95 = 470 + SigDio96 = 471 + SigDio97 = 472 + SigDio98 = 473 + SigDio99 = 474 + SigDio100 = 475 + SigDio101 = 476 + SigDio102 = 477 + SigDio103 = 478 + SigDio104 = 479 + SigDio105 = 480 + SigDio106 = 481 + SigDio107 = 482 + SigDio108 = 483 + SigDio109 = 484 + SigDio110 = 485 + SigDio111 = 486 + SigDio112 = 487 + SigDio113 = 488 + SigDio114 = 489 + SigDio115 = 490 + SigDio116 = 491 + SigDio117 = 492 + SigDio118 = 493 + SigDio119 = 494 + SigDio120 = 495 + SigDio121 = 496 + SigDio122 = 497 + SigDio123 = 498 + SigDio124 = 499 + SigDio125 = 500 + SigDio126 = 501 + SigDio127 = 502 + SigDio128 = 503 + SigDio129 = 504 + SigDio130 = 505 + SigDio131 = 506 + SigDio132 = 507 + SigDio133 = 508 + SigDio134 = 509 + SigDio135 = 510 + SigDio136 = 511 + SigDio137 = 512 + SigDio138 = 513 + SigDio139 = 514 + SigDio140 = 515 + SigDio141 = 516 + SigDio142 = 517 + SigDio143 = 518 + SigDio144 = 519 + SigDio145 = 520 + SigDio146 = 521 + SigDio147 = 522 + SigDio148 = 523 + SigDio149 = 524 + SigDio150 = 525 + SigDio151 = 526 + SigDio152 = 527 + SigDio153 = 528 + SigDio154 = 529 + SigDio155 = 530 + SigDio156 = 531 + SigDio157 = 532 + SigDio158 = 533 + SigDio159 = 534 + SigDio160 = 535 + SigDio161 = 536 + SigDio162 = 537 + SigDio163 = 538 + SigDio164 = 539 + SigDio165 = 540 + SigDio166 = 541 + SigDio167 = 542 + SigDio168 = 543 + SigDio169 = 544 + SigDio170 = 545 + SigDio171 = 546 + SigDio172 = 547 + SigDio173 = 548 + SigDio174 = 549 + SigDio175 = 550 + SigDio176 = 551 + SigDio177 = 552 + SigDio178 = 553 + SigDio179 = 554 + SigDio180 = 555 + SigDio181 = 556 + SigDio182 = 557 + SigDio183 = 558 + SigDio184 = 559 + SigDio185 = 560 + SigDio186 = 561 + SigDio187 = 562 + SigDio188 = 563 + SigDio189 = 564 + SigDio190 = 565 + SigDio191 = 566 + SigDio192 = 567 + SigDio193 = 568 + SigDio194 = 569 + SigDio195 = 570 + SigDio196 = 571 + SigDio197 = 572 + SigDio198 = 573 + SigDio199 = 574 + SigDio200 = 575 + SigDio201 = 576 + SigDio202 = 577 + SigDio203 = 578 + SigDio204 = 579 + SigDio205 = 580 + SigDio206 = 581 + SigDio207 = 582 + SigDio208 = 583 + SigDio209 = 584 + SigDio210 = 585 + SigDio211 = 586 + SigDio212 = 587 + SigDio213 = 588 + SigDio214 = 589 + SigDio215 = 590 + SigDio216 = 591 + SigDio217 = 592 + SigDio218 = 593 + SigDio219 = 594 + SigDio220 = 595 + SigDio221 = 596 + SigDio222 = 597 + SigDio223 = 598 + SigDio224 = 599 + SigDio225 = 600 + SigDio226 = 601 + SigDio227 = 602 + SigDio228 = 603 + SigDio229 = 604 + SigDio230 = 605 + SigDio231 = 606 + SigDio232 = 607 + SigDio233 = 608 + SigDio234 = 609 + SigDio235 = 610 + SigDio236 = 611 + SigDio237 = 612 + SigDio238 = 613 + SigDio239 = 614 + SigDio240 = 615 + SigDio241 = 616 + SigDio242 = 617 + SigDio243 = 618 + SigDio244 = 619 + SigDio245 = 620 + SigDio246 = 621 + SigDio247 = 622 + SigDio248 = 623 + SigDio249 = 624 + SigDio250 = 625 + SigDio251 = 626 + SigDio252 = 627 + SigDio253 = 628 + SigDio254 = 629 + SigDio255 = 630 + + # Counter clock pins + SigCntClk0 = 631 + SigCntClk1 = 632 + SigCntClk2 = 633 + SigCntClk3 = 634 + SigCntClk4 = 635 + SigCntClk5 = 636 + SigCntClk6 = 637 + SigCntClk7 = 638 + + # counter gate pins + SigCntGate0 = 639 + SigCntGate1 = 640 + SigCntGate2 = 641 + SigCntGate3 = 642 + SigCntGate4 = 643 + SigCntGate5 = 644 + SigCntGate6 = 645 + SigCntGate7 = 646 + + # counter out pins + SigCntOut0 = 647 + SigCntOut1 = 648 + SigCntOut2 = 649 + SigCntOut3 = 650 + SigCntOut4 = 651 + SigCntOut5 = 652 + SigCntOut6 = 653 + SigCntOut7 = 654 + + # counter frequency out pins + SigCntFout0 = 655 + SigCntFout1 = 656 + SigCntFout2 = 657 + SigCntFout3 = 658 + SigCntFout4 = 659 + SigCntFout5 = 660 + SigCntFout6 = 661 + SigCntFout7 = 662 + + # AMSI pins + SigAmsiPin0 = 663 + SigAmsiPin1 = 664 + SigAmsiPin2 = 665 + SigAmsiPin3 = 666 + SigAmsiPin4 = 667 + SigAmsiPin5 = 668 + SigAmsiPin6 = 669 + SigAmsiPin7 = 670 + SigAmsiPin8 = 671 + SigAmsiPin9 = 672 + SigAmsiPin10 = 673 + SigAmsiPin11 = 674 + SigAmsiPin12 = 675 + SigAmsiPin13 = 676 + SigAmsiPin14 = 677 + SigAmsiPin15 = 678 + SigAmsiPin16 = 679 + SigAmsiPin17 = 680 + SigAmsiPin18 = 681 + SigAmsiPin19 = 682 + + # new clocks + SigInternal2Hz = 683 # Device built-in clock, 2Hz + SigInternal20Hz = 684 # Device built-in clock, 20Hz + SigInternal200Hz = 685 # Device built-in clock, 200KHz + SigInternal2KHz = 686 # Device built-in clock, 2KHz + SigInternal20KHz = 687 # Device built-in clock, 20KHz + SigInternal200KHz = 688 # Device built-in clock, 200KHz + SigInternal2MHz = 689 # Device built-in clock, 2MHz + + # New Function pin on connector + SigExtAnaTrigger1 = 690 # external analog trigger pin of connector 1 + + # Reference clock + SigExtDigRefClock = 691 # digital clock pin of connector + SigInternal100MHz = 692 + SigAiConvClock = 693 + + # digital trigger from master after ADC latency + SigExtDigTrgAdcLatency = 694 + SigExtDigTrg0AdcLatency = SigExtDigTrgAdcLatency, + SigExtDigTrg1AdcLatency = 695 + + # digital trigger from master/MSDI pin after ADC latency + SigMDSITrg0 = 696 + SigMDSITrg1 = 697 + + SigMDSITrg0AdcLatency = 698 + SigMDSITrg1AdcLatency = 699 + + # reference clock source from master/MDSI pin + SigMDSIRefClock = 700 + SigMDSIClock = 701 + + # clock source & trigger for Master/Slave module + # internal clock x, as a master module + SigIntClock0 = 702 + SigIntClock1 = 703 + SigIntClock2 = 704 + SigIntClock3 = 705 + + # clock from internal clock x, as a slave module + SigIntClk0Slv = 706 + SigIntClk1Slv = 707 + SigIntClk2Slv = 708 + SigIntClk3Slv = 709 + + # Trigger x from trigger pin, as a slave module + SigExtDigTrg0Slv = 710 + SigExtDigTrg1Slv = 711 + SigExtDigTrg2Slv = 712 + SigExtDigTrg3Slv = 713 + + +class EventId(IntEnum): + EvtDeviceRemoved = 0 # The device was removed from system + EvtDeviceReconnected = 1 # The device is reconnected + EvtPropertyChanged = 2 # Some properties of the device were changed + # ----------------------------------------------------------------- + # AI events + # ----------------------------------------------------------------- + EvtBufferedAiDataReady = 3 + EvtBufferedAiOverrun = 4 + EvtBufferedAiCacheOverflow = 5 + EvtBufferedAiStopped = 6 + + # ----------------------------------------------------------------- + # AO event IDs + # ----------------------------------------------------------------- + EvtBufferedAoDataTransmitted = 7 + EvtBufferedAoUnderrun = 8 + EvtBufferedAoCacheEmptied = 9 + EvtBufferedAoTransStopped = 10 + EvtBufferedAoStopped = 11 + + # ----------------------------------------------------------------- + # DIO event IDs + # ----------------------------------------------------------------- + EvtDiInterrupt = 12 + EvtDiintChannel000 = EvtDiInterrupt + EvtDiintChannel001 = 13 + EvtDiintChannel002 = 14 + EvtDiintChannel003 = 15 + EvtDiintChannel004 = 16 + EvtDiintChannel005 = 17 + EvtDiintChannel006 = 18 + EvtDiintChannel007 = 19 + EvtDiintChannel008 = 20 + EvtDiintChannel009 = 21 + EvtDiintChannel010 = 22 + EvtDiintChannel011 = 23 + EvtDiintChannel012 = 24 + EvtDiintChannel013 = 25 + EvtDiintChannel014 = 26 + EvtDiintChannel015 = 27 + EvtDiintChannel016 = 28 + EvtDiintChannel017 = 29 + EvtDiintChannel018 = 30 + EvtDiintChannel019 = 31 + EvtDiintChannel020 = 32 + EvtDiintChannel021 = 33 + EvtDiintChannel022 = 34 + EvtDiintChannel023 = 35 + EvtDiintChannel024 = 36 + EvtDiintChannel025 = 37 + EvtDiintChannel026 = 38 + EvtDiintChannel027 = 39 + EvtDiintChannel028 = 40 + EvtDiintChannel029 = 41 + EvtDiintChannel030 = 42 + EvtDiintChannel031 = 43 + EvtDiintChannel032 = 44 + EvtDiintChannel033 = 45 + EvtDiintChannel034 = 46 + EvtDiintChannel035 = 47 + EvtDiintChannel036 = 48 + EvtDiintChannel037 = 49 + EvtDiintChannel038 = 50 + EvtDiintChannel039 = 51 + EvtDiintChannel040 = 52 + EvtDiintChannel041 = 53 + EvtDiintChannel042 = 54 + EvtDiintChannel043 = 55 + EvtDiintChannel044 = 56 + EvtDiintChannel045 = 57 + EvtDiintChannel046 = 58 + EvtDiintChannel047 = 59 + EvtDiintChannel048 = 60 + EvtDiintChannel049 = 61 + EvtDiintChannel050 = 62 + EvtDiintChannel051 = 63 + EvtDiintChannel052 = 64 + EvtDiintChannel053 = 65 + EvtDiintChannel054 = 66 + EvtDiintChannel055 = 67 + EvtDiintChannel056 = 68 + EvtDiintChannel057 = 69 + EvtDiintChannel058 = 70 + EvtDiintChannel059 = 71 + EvtDiintChannel060 = 72 + EvtDiintChannel061 = 73 + EvtDiintChannel062 = 74 + EvtDiintChannel063 = 75 + EvtDiintChannel064 = 76 + EvtDiintChannel065 = 77 + EvtDiintChannel066 = 78 + EvtDiintChannel067 = 79 + EvtDiintChannel068 = 80 + EvtDiintChannel069 = 81 + EvtDiintChannel070 = 82 + EvtDiintChannel071 = 83 + EvtDiintChannel072 = 84 + EvtDiintChannel073 = 85 + EvtDiintChannel074 = 86 + EvtDiintChannel075 = 87 + EvtDiintChannel076 = 88 + EvtDiintChannel077 = 89 + EvtDiintChannel078 = 90 + EvtDiintChannel079 = 91 + EvtDiintChannel080 = 92 + EvtDiintChannel081 = 93 + EvtDiintChannel082 = 94 + EvtDiintChannel083 = 95 + EvtDiintChannel084 = 96 + EvtDiintChannel085 = 97 + EvtDiintChannel086 = 98 + EvtDiintChannel087 = 99 + EvtDiintChannel088 = 100 + EvtDiintChannel089 = 101 + EvtDiintChannel090 = 102 + EvtDiintChannel091 = 103 + EvtDiintChannel092 = 104 + EvtDiintChannel093 = 105 + EvtDiintChannel094 = 106 + EvtDiintChannel095 = 107 + EvtDiintChannel096 = 108 + EvtDiintChannel097 = 109 + EvtDiintChannel098 = 110 + EvtDiintChannel099 = 111 + EvtDiintChannel100 = 112 + EvtDiintChannel101 = 113 + EvtDiintChannel102 = 114 + EvtDiintChannel103 = 115 + EvtDiintChannel104 = 116 + EvtDiintChannel105 = 117 + EvtDiintChannel106 = 118 + EvtDiintChannel107 = 119 + EvtDiintChannel108 = 120 + EvtDiintChannel109 = 121 + EvtDiintChannel110 = 122 + EvtDiintChannel111 = 123 + EvtDiintChannel112 = 124 + EvtDiintChannel113 = 125 + EvtDiintChannel114 = 126 + EvtDiintChannel115 = 127 + EvtDiintChannel116 = 128 + EvtDiintChannel117 = 129 + EvtDiintChannel118 = 130 + EvtDiintChannel119 = 131 + EvtDiintChannel120 = 132 + EvtDiintChannel121 = 133 + EvtDiintChannel122 = 134 + EvtDiintChannel123 = 135 + EvtDiintChannel124 = 136 + EvtDiintChannel125 = 137 + EvtDiintChannel126 = 138 + EvtDiintChannel127 = 139 + EvtDiintChannel128 = 140 + EvtDiintChannel129 = 141 + EvtDiintChannel130 = 142 + EvtDiintChannel131 = 143 + EvtDiintChannel132 = 144 + EvtDiintChannel133 = 145 + EvtDiintChannel134 = 146 + EvtDiintChannel135 = 147 + EvtDiintChannel136 = 148 + EvtDiintChannel137 = 149 + EvtDiintChannel138 = 150 + EvtDiintChannel139 = 151 + EvtDiintChannel140 = 152 + EvtDiintChannel141 = 153 + EvtDiintChannel142 = 154 + EvtDiintChannel143 = 155 + EvtDiintChannel144 = 156 + EvtDiintChannel145 = 157 + EvtDiintChannel146 = 158 + EvtDiintChannel147 = 159 + EvtDiintChannel148 = 160 + EvtDiintChannel149 = 161 + EvtDiintChannel150 = 162 + EvtDiintChannel151 = 163 + EvtDiintChannel152 = 164 + EvtDiintChannel153 = 165 + EvtDiintChannel154 = 166 + EvtDiintChannel155 = 167 + EvtDiintChannel156 = 168 + EvtDiintChannel157 = 169 + EvtDiintChannel158 = 170 + EvtDiintChannel159 = 171 + EvtDiintChannel160 = 172 + EvtDiintChannel161 = 173 + EvtDiintChannel162 = 174 + EvtDiintChannel163 = 175 + EvtDiintChannel164 = 176 + EvtDiintChannel165 = 177 + EvtDiintChannel166 = 178 + EvtDiintChannel167 = 179 + EvtDiintChannel168 = 180 + EvtDiintChannel169 = 181 + EvtDiintChannel170 = 182 + EvtDiintChannel171 = 183 + EvtDiintChannel172 = 184 + EvtDiintChannel173 = 185 + EvtDiintChannel174 = 186 + EvtDiintChannel175 = 187 + EvtDiintChannel176 = 188 + EvtDiintChannel177 = 189 + EvtDiintChannel178 = 190 + EvtDiintChannel179 = 191 + EvtDiintChannel180 = 192 + EvtDiintChannel181 = 193 + EvtDiintChannel182 = 194 + EvtDiintChannel183 = 195 + EvtDiintChannel184 = 196 + EvtDiintChannel185 = 197 + EvtDiintChannel186 = 198 + EvtDiintChannel187 = 199 + EvtDiintChannel188 = 200 + EvtDiintChannel189 = 201 + EvtDiintChannel190 = 202 + EvtDiintChannel191 = 203 + EvtDiintChannel192 = 204 + EvtDiintChannel193 = 205 + EvtDiintChannel194 = 206 + EvtDiintChannel195 = 207 + EvtDiintChannel196 = 208 + EvtDiintChannel197 = 209 + EvtDiintChannel198 = 210 + EvtDiintChannel199 = 211 + EvtDiintChannel200 = 212 + EvtDiintChannel201 = 213 + EvtDiintChannel202 = 214 + EvtDiintChannel203 = 215 + EvtDiintChannel204 = 216 + EvtDiintChannel205 = 217 + EvtDiintChannel206 = 218 + EvtDiintChannel207 = 219 + EvtDiintChannel208 = 220 + EvtDiintChannel209 = 221 + EvtDiintChannel210 = 222 + EvtDiintChannel211 = 223 + EvtDiintChannel212 = 224 + EvtDiintChannel213 = 225 + EvtDiintChannel214 = 226 + EvtDiintChannel215 = 227 + EvtDiintChannel216 = 228 + EvtDiintChannel217 = 229 + EvtDiintChannel218 = 230 + EvtDiintChannel219 = 231 + EvtDiintChannel220 = 232 + EvtDiintChannel221 = 233 + EvtDiintChannel222 = 234 + EvtDiintChannel223 = 235 + EvtDiintChannel224 = 236 + EvtDiintChannel225 = 237 + EvtDiintChannel226 = 238 + EvtDiintChannel227 = 239 + EvtDiintChannel228 = 240 + EvtDiintChannel229 = 241 + EvtDiintChannel230 = 242 + EvtDiintChannel231 = 243 + EvtDiintChannel232 = 244 + EvtDiintChannel233 = 245 + EvtDiintChannel234 = 246 + EvtDiintChannel235 = 247 + EvtDiintChannel236 = 248 + EvtDiintChannel237 = 249 + EvtDiintChannel238 = 250 + EvtDiintChannel239 = 251 + EvtDiintChannel240 = 252 + EvtDiintChannel241 = 253 + EvtDiintChannel242 = 254 + EvtDiintChannel243 = 255 + EvtDiintChannel244 = 256 + EvtDiintChannel245 = 257 + EvtDiintChannel246 = 258 + EvtDiintChannel247 = 259 + EvtDiintChannel248 = 260 + EvtDiintChannel249 = 261 + EvtDiintChannel250 = 262 + EvtDiintChannel251 = 263 + EvtDiintChannel252 = 264 + EvtDiintChannel253 = 265 + EvtDiintChannel254 = 266 + EvtDiintChannel255 = 267 + + EvtDiStatusChange = 268 + EvtDiCosintPort000 = EvtDiStatusChange + EvtDiCosintPort001 = 269 + EvtDiCosintPort002 = 270 + EvtDiCosintPort003 = 271 + EvtDiCosintPort004 = 272 + EvtDiCosintPort005 = 273 + EvtDiCosintPort006 = 274 + EvtDiCosintPort007 = 275 + EvtDiCosintPort008 = 276 + EvtDiCosintPort009 = 277 + EvtDiCosintPort010 = 278 + EvtDiCosintPort011 = 279 + EvtDiCosintPort012 = 280 + EvtDiCosintPort013 = 281 + EvtDiCosintPort014 = 282 + EvtDiCosintPort015 = 283 + EvtDiCosintPort016 = 284 + EvtDiCosintPort017 = 285 + EvtDiCosintPort018 = 286 + EvtDiCosintPort019 = 287 + EvtDiCosintPort020 = 288 + EvtDiCosintPort021 = 289 + EvtDiCosintPort022 = 290 + EvtDiCosintPort023 = 291 + EvtDiCosintPort024 = 292 + EvtDiCosintPort025 = 293 + EvtDiCosintPort026 = 294 + EvtDiCosintPort027 = 295 + EvtDiCosintPort028 = 296 + EvtDiCosintPort029 = 297 + EvtDiCosintPort030 = 298 + EvtDiCosintPort031 = 299 + + EvtDiPatternMatch = 300 + EvtDiPmintPort000 = EvtDiPatternMatch + EvtDiPmintPort001 = 301 + EvtDiPmintPort002 = 302 + EvtDiPmintPort003 = 303 + EvtDiPmintPort004 = 304 + EvtDiPmintPort005 = 305 + EvtDiPmintPort006 = 306 + EvtDiPmintPort007 = 307 + EvtDiPmintPort008 = 308 + EvtDiPmintPort009 = 309 + EvtDiPmintPort010 = 310 + EvtDiPmintPort011 = 311 + EvtDiPmintPort012 = 312 + EvtDiPmintPort013 = 313 + EvtDiPmintPort014 = 314 + EvtDiPmintPort015 = 315 + EvtDiPmintPort016 = 316 + EvtDiPmintPort017 = 317 + EvtDiPmintPort018 = 318 + EvtDiPmintPort019 = 319 + EvtDiPmintPort020 = 320 + EvtDiPmintPort021 = 321 + EvtDiPmintPort022 = 322 + EvtDiPmintPort023 = 323 + EvtDiPmintPort024 = 324 + EvtDiPmintPort025 = 325 + EvtDiPmintPort026 = 326 + EvtDiPmintPort027 = 327 + EvtDiPmintPort028 = 328 + EvtDiPmintPort029 = 329 + EvtDiPmintPort030 = 330 + EvtDiPmintPort031 = 331 + + EvtBufferedDiDataReady = 332 + EvtBufferedDiOverrun = 333 + EvtBufferedDiCacheOverflow = 334 + EvtBufferedDiStopped = 335 + + EvtBufferedDoDataTransmitted = 336 + EvtBufferedDoUnderrun = 337 + EvtBufferedDoCacheEmptied = 338 + EvtBufferedDoTransStopped = 339 + EvtBufferedDoStopped = 340 + + EvtReflectWdtOccured = 341 + + # ----------------------------------------------------------------- + # Counter/Timer event IDs + # ----------------------------------------------------------------- + EvtCntTerminalCount0 = 342 + EvtCntTerminalCount1 = 343 + EvtCntTerminalCount2 = 344 + EvtCntTerminalCount3 = 345 + EvtCntTerminalCount4 = 346 + EvtCntTerminalCount5 = 347 + EvtCntTerminalCount6 = 348 + EvtCntTerminalCount7 = 349 + + EvtCntOverCompare0 = 350 + EvtCntOverCompare1 = 351 + EvtCntOverCompare2 = 352 + EvtCntOverCompare3 = 353 + EvtCntOverCompare4 = 354 + EvtCntOverCompare5 = 355 + EvtCntOverCompare6 = 356 + EvtCntOverCompare7 = 357 + + EvtCntUnderCompare0 = 358 + EvtCntUnderCompare1 = 359 + EvtCntUnderCompare2 = 360 + EvtCntUnderCompare3 = 361 + EvtCntUnderCompare4 = 362 + EvtCntUnderCompare5 = 363 + EvtCntUnderCompare6 = 364 + EvtCntUnderCompare7 = 365 + + EvtCntEcOverCompare0 = 366 + EvtCntEcOverCompare1 = 367 + EvtCntEcOverCompare2 = 368 + EvtCntEcOverCompare3 = 369 + EvtCntEcOverCompare4 = 370 + EvtCntEcOverCompare5 = 371 + EvtCntEcOverCompare6 = 372 + EvtCntEcOverCompare7 = 373 + + EvtCntEcUnderCompare0 = 374 + EvtCntEcUnderCompare1 = 375 + EvtCntEcUnderCompare2 = 376 + EvtCntEcUnderCompare3 = 377 + EvtCntEcUnderCompare4 = 378 + EvtCntEcUnderCompare5 = 379 + EvtCntEcUnderCompare6 = 380 + EvtCntEcUnderCompare7 = 381 + + EvtCntOneShot0 = 382 + EvtCntOneShot1 = 383 + EvtCntOneShot2 = 384 + EvtCntOneShot3 = 385 + EvtCntOneShot4 = 386 + EvtCntOneShot5 = 387 + EvtCntOneShot6 = 388 + EvtCntOneShot7 = 389 + + EvtCntTimer0 = 390 + EvtCntTimer1 = 391 + EvtCntTimer2 = 392 + EvtCntTimer3 = 393 + EvtCntTimer4 = 394 + EvtCntTimer5 = 395 + EvtCntTimer6 = 396 + EvtCntTimer7 = 397 + + EvtCntPwmInOverflow0 = 398 + EvtCntPwmInOverflow1 = 399 + EvtCntPwmInOverflow2 = 400 + EvtCntPwmInOverflow3 = 401 + EvtCntPwmInOverflow4 = 402 + EvtCntPwmInOverflow5 = 403 + EvtCntPwmInOverflow6 = 404 + EvtCntPwmInOverflow7 = 405 + + EvtUdIndex0 = 406 + EvtUdIndex1 = 407 + EvtUdIndex2 = 408 + EvtUdIndex3 = 409 + EvtUdIndex4 = 410 + EvtUdIndex5 = 411 + EvtUdIndex6 = 412 + EvtUdIndex7 = 413 + + EvtCntPatternMatch0 = 414 + EvtCntPatternMatch1 = 415 + EvtCntPatternMatch2 = 416 + EvtCntPatternMatch3 = 417 + EvtCntPatternMatch4 = 418 + EvtCntPatternMatch5 = 419 + EvtCntPatternMatch6 = 420 + EvtCntPatternMatch7 = 421 + + EvtCntCompareTableEnd0 = 422 + EvtCntCompareTableEnd1 = 423 + EvtCntCompareTableEnd2 = 424 + EvtCntCompareTableEnd3 = 425 + EvtCntCompareTableEnd4 = 426 + EvtCntCompareTableEnd5 = 427 + EvtCntCompareTableEnd6 = 428 + EvtCntCompareTableEnd7 = 429 + + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + # v1.1: new event of AI + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx# + EvtBufferedAiBurnOut = 430 + EvtBufferedAiTimeStampOverrun = 431 + EvtBufferedAiTimeStampCacheOverflow = 432 + EvtBufferedAiMarkOverrun = 433 + EvtBufferedAiConvStopped = 434 # Reserved for later using + + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + # v1.2: new event of Buffered Counter + # ##xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + EvtCiDataReady = 435 + EvtCiDataReady0 = EvtCiDataReady + EvtCiDataReady1 = 436 + EvtCiDataReady2 = 437 + EvtCiDataReady3 = 438 + EvtCiDataReady4 = 439 + EvtCiDataReady5 = 440 + EvtCiDataReady6 = 441 + EvtCiDataReady7 = 442 + + EvtCiOverrun = 443 + EvtCiOverrun0 = EvtCiOverrun + EvtCiOverrun1 = 444 + EvtCiOverrun2 = 445 + EvtCiOverrun3 = 446 + EvtCiOverrun4 = 447 + EvtCiOverrun5 = 448 + EvtCiOverrun6 = 449 + EvtCiOverrun7 = 450 + + EvtCiCacheOverflow = 451 + EvtCiCacheOverflow0 = EvtCiCacheOverflow + EvtCiCacheOverflow1 = 452 + EvtCiCacheOverflow2 = 453 + EvtCiCacheOverflow3 = 454 + EvtCiCacheOverflow4 = 455 + EvtCiCacheOverflow5 = 456 + EvtCiCacheOverflow6 = 457 + EvtCiCacheOverflow7 = 458 + + EvtCoDataTransmitted = 459 + EvtCoDataTransmitted0 = EvtCoDataTransmitted + EvtCoDataTransmitted1 = 460 + EvtCoDataTransmitted2 = 461 + EvtCoDataTransmitted3 = 462 + EvtCoDataTransmitted4 = 463 + EvtCoDataTransmitted5 = 464 + EvtCoDataTransmitted6 = 465 + EvtCoDataTransmitted7 = 466 + + EvtCoUnderrun = 467 + EvtCoUnderrun0 = EvtCoUnderrun + EvtCoUnderrun1 = 468 + EvtCoUnderrun2 = 469 + EvtCoUnderrun3 = 470 + EvtCoUnderrun4 = 471 + EvtCoUnderrun5 = 472 + EvtCoUnderrun6 = 473 + EvtCoUnderrun7 = 474 + + EvtCoCacheEmptied = 475 + EvtCoCacheEmptied0 = EvtCoCacheEmptied + EvtCoCacheEmptied1 = 476 + EvtCoCacheEmptied2 = 477 + EvtCoCacheEmptied3 = 478 + EvtCoCacheEmptied4 = 479 + EvtCoCacheEmptied5 = 480 + EvtCoCacheEmptied6 = 481 + EvtCoCacheEmptied7 = 482 + + EvtCoTransStopped = 483 + EvtCoTransStopped0 = EvtCoTransStopped + EvtCoTransStopped1 = 484 + EvtCoTransStopped2 = 485 + EvtCoTransStopped3 = 486 + EvtCoTransStopped4 = 487 + EvtCoTransStopped5 = 488 + EvtCoTransStopped6 = 489 + EvtCoTransStopped7 = 490 + + EvtCntrStopped = 491 + EvtCntrStopped0 = EvtCntrStopped + EvtCntrStopped1 = 492 + EvtCntrStopped2 = 493 + EvtCntrStopped3 = 494 + EvtCntrStopped4 = 495 + EvtCntrStopped5 = 496 + EvtCntrStopped6 = 497 + EvtCntrStopped7 = 498 + + +class ErrorCode(Enum): + # + # The operation is completed successfully. + # + Success = 0 + + # ************************************************************************ + # warning + # ************************************************************************ + # + # The interrupt resource is not available. + # + WarningIntrNotAvailable = 0xA0000000 + + # + # The parameter is out of the range. + # + WarningParamOutOfRange = 0xA0000001 + + # + # The property value is out of range. + # + WarningPropValueOutOfRange = 0xA0000002 + + # + # The property value is not supported. + # + WarningPropValueNotSpted = 0xA0000003 + + # + # The property value conflicts with the current state. + # + WarningPropValueConflict = 0xA0000004 + + # + # The value range of all channels in a group should be same, + # such as 4~20mA of PCI-1724. + # + WarningVrgOfGroupNotSame = 0xA0000005 + + # + # Some properties of a property set are failed to be written into device. + # + # + WarningPropPartialFailed = 0xA0000006 + + # + # The operation had been stopped. + # + # + WarningFuncStopped = 0xA0000007 + + # + # The operation is time-out. + # + # + WarningFuncTimeout = 0xA0000008 + + # + # The cache is over-run. + # + # + WarningCacheOverflow = 0xA0000009 + + # + # The channel is burn-out. + # + # + WarningBurnout = 0xA000000A + + # + # The current data record is end. + # + # + WarningRecordEnd = 0xA000000B + + # + # The specified profile is not valid. + # + # + WarningProfileNotValid = 0xA000000C + + # *********************************************************************** + # error + # *********************************************************************** + # + # The handle is NULL or its type doesn't match the required operation. + # + ErrorHandleNotValid = 0xE0000000 + + # + # The parameter value is out of range. + # + ErrorParamOutOfRange = 0xE0000001 + + # + # The parameter value is not supported. + # + ErrorParamNotSpted = 0xE0000002 + + # + # The parameter value format is not the expected. + # + ErrorParamFmtUnexpted = 0xE0000003 + + # + # Not enough memory is available to complete the operation. + # + ErrorMemoryNotEnough = 0xE0000004 + + # + # The data buffer is null. + # + ErrorBufferIsNull = 0xE0000005 + + # + # The data buffer is too small for the operation. + # + ErrorBufferTooSmall = 0xE0000006 + + # + # The data length exceeded the limitation. + # + ErrorDataLenExceedLimit = 0xE0000007 + + # + # The required function is not supported. + # + ErrorFuncNotSpted = 0xE0000008 + + # + # The required event is not supported. + # + ErrorEventNotSpted = 0xE0000009 + + # + # The required property is not supported. + # + ErrorPropNotSpted = 0xE000000A + + # + # The required property is read-only. + # + ErrorPropReadOnly = 0xE000000B + + # + # The specified property value conflicts with the current state. + # + ErrorPropValueConflict = 0xE000000C + + # + # The specified property value is out of range. + # + ErrorPropValueOutOfRange = 0xE000000D + + # + # The specified property value is not supported. + # + ErrorPropValueNotSpted = 0xE000000E + + # + # The handle hasn't own the privilege of the operation the user wanted. + # + ErrorPrivilegeNotHeld = 0xE000000F + + # + # The required privilege is not available because someone else had own it. + # + ErrorPrivilegeNotAvailable = 0xE0000010 + + # + # The driver of specified device was not found. + # + ErrorDriverNotFound = 0xE0000011 + + # + # The driver version of the specified device mismatched. + # + ErrorDriverVerMismatch = 0xE0000012 + + # + # The loaded driver count exceeded the limitation. + # + ErrorDriverCountExceedLimit = 0xE0000013 + + # + # The device is not opened. + # + ErrorDeviceNotOpened = 0xE0000014 + + # + # The required device does not exist. + # + ErrorDeviceNotExist = 0xE0000015 + + # + # The required device is unrecognized by driver. + # + ErrorDeviceUnrecognized = 0xE0000016 + + # + # The configuration data of the specified device is lost or unavailable. + # + ErrorConfigDataLost = 0xE0000017 + + # + # The function is not initialized and can't be started. + # + ErrorFuncNotInited = 0xE0000018 + + # + # The function is busy. + # + ErrorFuncBusy = 0xE0000019 + + # + # The interrupt resource is not available. + # + ErrorIntrNotAvailable = 0xE000001A + + # + # The DMA channel is not available. + # + ErrorDmaNotAvailable = 0xE000001B + + # + # Time out when reading/writing the device. + # + ErrorDeviceIoTimeOut = 0xE000001C + + # + # The given signature does not match with the device current one. + # + ErrorSignatureNotMatch = 0xE000001D + + # + # The function cannot be executed while the buffered AI is running. + # + ErrorFuncConflictWithBfdAi = 0xE000001E + + # + # The value range is not available in single-ended mode. + # + ErrorVrgNotAvailableInSeMode = 0xE000001F + + # + # The value range is not available in 50omh input impedance mode.. + # + ErrorVrgNotAvailableIn50ohmMode = 0xE0000020 + + # + # The coupling type is not available in 50omh input impedance mode.. + # + ErrorCouplingNotAvailableIn50ohmMode = 0xE0000021 + + # + # The coupling type is not available in IEPE mode. + # + ErrorCouplingNotAvailableInIEPEMode = 0xE0000022 + + # + # The Communication is failed when reading/writing the device. + # + ErrorDeviceCommunicationFailed = 0xE0000023 + + # + # The device's 'fix number' conflicted with other device's + # + ErrorFixNumberConflict = 0xE0000024 + + # + # The Trigger source conflicted with other trigger configuration + # + ErrorTrigSrcConflict = 0xE0000025 + + # + # All properties of a property set are failed to be written into device. + # + ErrorPropAllFailed = 0xE0000026 + + # + # Undefined error + # + ErrorUndefined = 0xE000FFFF + + @staticmethod + def lookup(value): + value = value & 0xFFFFFFFF + for code in ErrorCode: + if value == code.value: + return code + return ErrorCode.ErrorUndefined + + # def toInt(self): + # return self.value + # + # def toString(self): + # return AdxEnumToString("ErrorCode", self.value, 256) + + +class ProductId(IntEnum): + BD_DEMO = 0x00 # demo board + BD_PCL818 = 0x05 # PCL-818 board + BD_PCL818H = 0x11 # PCL-818H + BD_PCL818L = 0x21 # PCL-818L + BD_PCL818HG = 0x22 # PCL-818HG + BD_PCL818HD = 0x2b # PCL-818HD + BD_PCM3718 = 0x37 # PCM-3718 + BD_PCM3724 = 0x38 # PCM-3724 + BD_PCM3730 = 0x5a # PCM-3730 + BD_PCI1750 = 0x5e # PCI-1750 + BD_PCI1751 = 0x5f # PCI-1751 + BD_PCI1710 = 0x60 # PCI-1710 + BD_PCI1712 = 0x61 # PCI-1712 + BD_PCI1710HG = 0x67 # PCI-1710HG + BD_PCI1711 = 0x73 # PCI-1711 + BD_PCI1711L = 0x75 # PCI-1711L + BD_PCI1713 = 0x68 # PCI-1713 + BD_PCI1753 = 0x69 # PCI-1753 + BD_PCI1760 = 0x6a # PCI-1760 + BD_PCI1720 = 0x6b # PCI-1720 + BD_PCM3718H = 0x6d # PCM-3718H + BD_PCM3718HG = 0x6e # PCM-3718HG + BD_PCI1716 = 0x74 # PCI-1716 + BD_PCI1731 = 0x75 # PCI-1731 + BD_PCI1754 = 0x7b # PCI-1754 + BD_PCI1752 = 0x7c # PCI-1752 + BD_PCI1756 = 0x7d # PCI-1756 + BD_PCM3725 = 0x7f # PCM-3725 + BD_PCI1762 = 0x80 # PCI-1762 + BD_PCI1721 = 0x81 # PCI-1721 + BD_PCI1761 = 0x82 # PCI-1761 + BD_PCI1723 = 0x83 # PCI-1723 + BD_PCI1730 = 0x87 # PCI-1730 + BD_PCI1733 = 0x88 # PCI-1733 + BD_PCI1734 = 0x89 # PCI-1734 + BD_PCI1710L = 0x90 # PCI-1710L + BD_PCI1710HGL = 0x91 # PCI-1710HGL + BD_PCM3712 = 0x93 # PCM-3712 + BD_PCM3723 = 0x94 # PCM-3723 + BD_PCI1780 = 0x95 # PCI-1780 + BD_MIC3756 = 0x96 # MIC-3756 + BD_PCI1755 = 0x97 # PCI-1755 + BD_PCI1714 = 0x98 # PCI-1714 + BD_PCI1757 = 0x99 # PCI-1757 + BD_MIC3716 = 0x9A # MIC-3716 + BD_MIC3761 = 0x9B # MIC-3761 + BD_MIC3753 = 0x9C # MIC-3753 + BD_MIC3780 = 0x9D # MIC-3780 + BD_PCI1724 = 0x9E # PCI-1724 + BD_PCI1758UDI = 0xA3 # PCI-1758UDI + BD_PCI1758UDO = 0xA4 # PCI-1758UDO + BD_PCI1747 = 0xA5 # PCI-1747 + BD_PCM3780 = 0xA6 # PCM-3780 + BD_MIC3747 = 0xA7 # MIC-3747 + BD_PCI1758UDIO = 0xA8 # PCI-1758UDIO + BD_PCI1712L = 0xA9 # PCI-1712L + BD_PCI1763UP = 0xAC # PCI-1763UP + BD_PCI1736UP = 0xAD # PCI-1736UP + BD_PCI1714UL = 0xAE # PCI-1714UL + BD_MIC3714 = 0xAF # MIC-3714 + BD_PCM3718HO = 0xB1 # PCM-3718HO + BD_PCI1741U = 0xB3 # PCI-1741U + BD_MIC3723 = 0xB4 # MIC-3723 + BD_PCI1718HDU = 0xB5 # PCI-1718HDU + BD_MIC3758DIO = 0xB6 # MIC-3758DIO + BD_PCI1727U = 0xB7 # PCI-1727U + BD_PCI1718HGU = 0xB8 # PCI-1718HGU + BD_PCI1715U = 0xB9 # PCI-1715U + BD_PCI1716L = 0xBA # PCI-1716L + BD_PCI1735U = 0xBB # PCI-1735U + BD_USB4711 = 0xBC # USB4711 + BD_PCI1737U = 0xBD # PCI-1737U + BD_PCI1739U = 0xBE # PCI-1739U + BD_PCI1742U = 0xC0 # PCI-1742U + BD_USB4718 = 0xC6 # USB-4718 + BD_MIC3755 = 0xC7 # MIC3755 + BD_USB4761 = 0xC8 # USB4761 + BD_PCI1784 = 0XCC # PCI-1784 + BD_USB4716 = 0xCD # USB4716 + BD_PCI1752U = 0xCE # PCI-1752U + BD_PCI1752USO = 0xCF # PCI-1752USO + BD_USB4751 = 0xD0 # USB4751 + BD_USB4751L = 0xD1 # USB4751L + BD_USB4750 = 0xD2 # USB4750 + BD_MIC3713 = 0xD3 # MIC-3713 + BD_USB4711A = 0xD8 # USB4711A + BD_PCM3753P = 0xD9 # PCM3753P + BD_PCM3784 = 0xDA # PCM3784 + BD_PCM3761I = 0xDB # PCM-3761I + BD_MIC3751 = 0xDC # MIC-3751 + BD_PCM3730I = 0xDD # PCM-3730I + BD_PCM3813I = 0xE0 # PCM-3813I + BD_PCIE1744 = 0xE1 # PCIE-1744 + BD_PCI1730U = 0xE2 # PCI-1730U + BD_PCI1760U = 0xE3 # PCI-1760U + BD_MIC3720 = 0xE4 # MIC-3720 + BD_PCM3810I = 0xE9 # PCM-3810I + BD_USB4702 = 0xEA # USB4702 + BD_USB4704 = 0xEB # USB4704 + BD_PCM3810I_HG = 0xEC # PCM-3810I_HG + BD_PCI1713U = 0xED # PCI-1713U + + # !!!BioDAQ only Product ID starts from here!!! + BD_PCI1706U = 0x800 + BD_PCI1706MSU = 0x801 + BD_PCI1706UL = 0x802 + BD_PCIE1752 = 0x803 + BD_PCIE1754 = 0x804 + BD_PCIE1756 = 0x805 + BD_MIC1911 = 0x806 + BD_MIC3750 = 0x807 + BD_MIC3711 = 0x808 + BD_PCIE1730 = 0x809 + BD_PCI1710_ECU = 0x80A + BD_PCI1720_ECU = 0x80B + BD_PCIE1760 = 0x80C + BD_PCIE1751 = 0x80D + BD_ECUP1706 = 0x80E + BD_PCIE1753 = 0x80F + BD_PCIE1810 = 0x810 + BD_ECUP1702L = 0x811 + BD_PCIE1816 = 0x812 + BD_PCM27D24DI = 0x813 + BD_PCIE1816H = 0x814 + BD_PCIE1840 = 0x815 + BD_PCL725 = 0x816 + BD_PCI176E = 0x817 + BD_PCIE1802 = 0x818 + BD_AIISE730 = 0x819 + BD_PCIE1812 = 0x81A + BD_MIC1810 = 0x81B + BD_PCIE1802L = 0x81C + BD_PCIE1813 = 0x81D + BD_PCIE1840L = 0x81E + BD_PCIE1730H = 0x81F + BD_PCIE1756H = 0x820 + BD_PCIERXM01 = 0x821 # PCIe-RXM01 + BD_MIC1816 = 0x822 + BD_USB5830 = 0x823 + BD_USB5850 = 0x824 + BD_USB5860 = 0x825 + BD_VPX1172 = 0x826 + BD_USB5855 = 0x827 + BD_USB5856 = 0x828 + BD_USB5862 = 0x829 + BD_PCIE1840T = 0x82A + BD_AudioCard = 0x82B + BD_AIIS1750 = 0x82C + BD_PCIE1840HL = 0x82D + BD_PCIE1765 = 0x82E + BD_PCIE1761H = 0x82F + BD_PCIE1762H = 0x830 + BD_PCIE1884 = 0x831 + BD_PCIE1758DIO = 0x832 + BD_PCIE1758DI = 0x833 + BD_PCIE1758DO = 0x834 + + # + BD_USB5817 = 0x835 + BD_USB5801 = 0x836 + BD_PCM2731 = 0x837 + BD_MOS1110 = 0x838 + BD_PCIE1750UH = 0x839 + BD_PCIE1750U = 0x83A + BD_USB5820 = 0x83B + + # + BD_THK1710R = 0x83C + BD_PCIE1803 = 0x83D + BD_PCIE1824 = 0x83E + BD_PCIE1805 = 0x83F + + # + BD_MIOE1747 = 0x840 + BD_ECUP1710 = 0x841 + BD_PCIE1824L = 0x842 + + # + BD_PCIE1763AH = 0x843 + BD_PCIE1763DH = 0x844 + + # + BD_MIC1816B = 0x845 + + # + BD_SUSIGPIO = 0x846 + + # + BD_MIC1810B = 0x847 + + # iDAQ series + BD_IDAQ731 = 0x848 + BD_IDAQ763D = 0x849 + BD_IDAQ817 = 0x84A + BD_IDAQ821 = 0x84B + + # + BD_EAPIGPIO = 0x84C + + # iDAQ series + BD_IDAQ841 = 0x84D + BD_IDAQ801 = 0x84E + + # WISE-5000 starts from here + BD_WISE5051 = 0x901 + BD_WISE5056 = 0x902 + BD_WISE5056SO = 0x903 + BD_WISE5015 = 0x904 + BD_WISE5017 = 0x905 + BD_WISE5018 = 0x906 + BD_WISE5024 = 0x907 + BD_WISE5080 = 0x908 + BD_WISE5074 = 0x909 + BD_WISE5001 = 0x90A + BD_WISE5052 = 0x90B + BD_WISE5057 = 0x90C + BD_WISE5057SO = 0x90D + BD_WISE5017C = 0x90E + BD_WISE5017V = 0x90F + BD_WISE5079 = 0x910 + + BD_AMAX5051 = 0x911 + BD_AMAX5056 = 0x912 + BD_AMAX5056SO = 0x913 + BD_AMAX5015 = 0x914 + BD_AMAX5017 = 0x915 + BD_AMAX5018 = 0x916 + BD_AMAX5024 = 0x917 + BD_AMAX5080 = 0x918 + BD_AMAX5074 = 0x919 + BD_AMAX5001 = 0x91A + BD_AMAX5052 = 0x91B + BD_AMAX5057 = 0x91C + BD_AMAX5057SO = 0x91D + BD_AMAX5017C = 0x91E + BD_AMAX5017V = 0x91F + BD_AMAX5079 = 0x920 + + # Unknown productId + BD_UNKNOWN = -1 + + +class ControlState(IntEnum): + Idle = 0 + Ready = 1 + Running = 2 + Stopped = 3 + Uninited = -1 + + +class Scenario(IntEnum): + SceInstantAi = 1 << 0 + SceBufferedAi = 1 << 1 + SceWaveformAi = 1 << 2 + SceInstantAo = 1 << 3 + SceBufferedAo = 1 << 4 + SceInstantDi = 1 << 5 + SceInstantDo = 1 << 6 + SceEventCounter = 1 << 7 + SceFreqMeter = 1 << 8 + SceOneShot = 1 << 9 + SceTimerPulse = 1 << 10 + ScePwMeter = 1 << 11 + ScePwModulator = 1 << 12 + SceUdCounter = 1 << 13 + SceBufferedEventCounter = 1 << 14 + SceBufferedPwMeter = 1 << 15 + SceBufferedPwModulator = 1 << 16 + SceBufferedUdCounter = 1 << 17 + SceEdgeSeparation = 1 << 18 + SceBufferedDi = 1 << 19 + SceBufferedDo = 1 << 20 + SceCalibration = 1 << 21 + + +class MathInterval(Structure): + _fields_ = [ + ('Type', c_int32), + ('Min', c_double), + ('Max', c_double) + ] + + +class MapFuncPiece(Structure): + _fields_ = [ + ("Size", c_int32), # the size of structure + ("Degree", c_int32), # the polynomial degree + ("UpperLimit", c_double), # the upper limit for this scaling polynomial + ("Coef", c_double * 2) # variable length array for the coefficient of polynomial, in increasing degree + ] + + +class DataMark(Structure): + _fields_ = [ + ("DataIndex", c_int64), + ("SrcId", c_int32), + ("_reserved_", c_int32) + ] + + +class DeviceInformation(Structure): + _fields_ = [ + ("DeviceNumber", c_int32), + ("DeviceMode", c_int32), # AccessMode + ("ModuleIndex", c_int32), + ("Description", c_wchar * MAX_DEVICE_DESC_LEN) + ] + + def __init__(self, Description='', DeviceNumber=-1, DeviceMode=AccessMode.ModeWrite, ModuleIndex=0): + self.DeviceNumber = DeviceNumber + self.DeviceMode = DeviceMode + self.ModuleIndex = ModuleIndex + self.Description = Description + + +class DeviceTreeNode(Structure): + _fields_ = [ + ("DevicIntEnumber", c_int32), + ("ModulesIndex", c_int32 * 8), + ("Description", c_wchar * MAX_DEVICE_DESC_LEN) + ] + + +class DeviceEventArgs(Structure): + _fields_ = [ + ("Id", c_int32) # EventId + ] + + +class BfdAiEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32), + ("MarkCount", c_int32) + ] + + +class BfdAoEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32) + ] + + +class DiSnapEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("SrcNum", c_int32), + ("Length", c_int32), + ("PortData", c_uint8 * MAX_DIO_PORT_COUNT) + ] + + +class BfdDiEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32), + ("MarkCount", c_int32) + ] + + +class BfdDoEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Offset", c_int32), + ("Count", c_int32) + ] + + +class CntrEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Channel", c_int32) + ] + + +class UdCntrEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Length", c_int32), + ("Data", c_int32 * MAX_CNTR_CH_COUNT) + ] + + +class BfdCntrEventArgs(Structure): + _fields_ = [ + ("Id", c_int32), # EventId + ("Channel", c_int32), + ("Offset", c_int32), + ("Count", c_int32) + ] + + +class PulseWidth(Structure): + _fields_ = [ + ("HiPeriod", c_double), + ("LoPeriod", c_double) + ] + diff --git a/src/components/Automation/__init__.py b/src/components/Automation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/components/component.py b/src/components/component.py index 12b2392..55d9e85 100644 --- a/src/components/component.py +++ b/src/components/component.py @@ -140,7 +140,8 @@ class Component(QObject): self._set_requestors.connect(self._do_set_requestors) self._set_period.connect(self._do_set_period) if self.config is not None: - self.config.updated.connect(self.reconfigure) + if self.config.updated is not None: + self.config.updated.connect(self.reconfigure) self._do_reconfigure() self._init_periodic() self._started = True diff --git a/src/components/multicomp_730424.py b/src/components/multicomp_730424.py index f49538c..291dabd 100644 --- a/src/components/multicomp_730424.py +++ b/src/components/multicomp_730424.py @@ -40,7 +40,10 @@ class Multicomp730424(Component): self.write("FUNC1 \"RES\"") self.write("RATE F") self.write("AUTO 0") - self.write("CONF:RES 500") + if self.config[self.name]["4wire"] is "enabled": + self.write("CONF:FRES 500") + else: + self.write("CONF:RES 500") def set_resistance_scale(self, resistance=None): if resistance is None: @@ -79,6 +82,7 @@ class Multicomp730424(Component): self.write(command) info[value_name] = self.read() if isinstance(info["measure"], float) and info["measure"] < 1e9: - info["measure"] -= self.cable_resistance + if self.config[self.name]["4wire"] is not "enabled": + info["measure"] -= self.cable_resistance self.log.debug(str(info)) super()._get([info]) diff --git a/src/components/usb_586x.py b/src/components/usb_586x.py new file mode 100644 index 0000000..bcc0fb8 --- /dev/null +++ b/src/components/usb_586x.py @@ -0,0 +1,183 @@ +import ctypes +import sys +import platform +import time +from enum import Enum + +from PyQt5.QtCore import QMutex, Qt, QTimer, pyqtSlot + +from .component import Component + +if "--sim-io" not in sys.argv: + win = platform.system() == "Windows" + + if win: + from Automation.BDaq import * + from Automation.BDaq.InstantDoCtrl import InstantDoCtrl + from Automation.BDaq.InstantDiCtrl import InstantDiCtrl + from Automation.BDaq.BDaqApi import AdxEnumToString, BioFailed + pass + else: + libbiodaq = ctypes.CDLL("/opt/advantech/libs/libbiodaq.so") +else: + import lib.dummies.libbiodaq as libbiodaq + + +class USB_586x(Component): + class DeviceInformation(ctypes.Structure): + _fields_ = [ + ('DeviceNumber', ctypes.c_uint32), + ('DeviceMode', ctypes.c_uint32), + ('ModuleIndex', ctypes.c_uint32), + ('Description', ctypes.c_wchar_p) + ] + + def __init__(self, config): + super().__init__(config) + self.mutex = QMutex() + # DEVICE INFORMATION + self.id=config.id + if "5860" in self.id: + self.type = "5860" + self.in_size = 1 + self.out_size = 1 + if "5862" in self.id: + self.type = "5862" + self.in_size = 2 + self.out_size = 2 + self.info = self.DeviceInformation() + self.info.Description = config.id + + # self.info.DeviceNumber = -1 + self.info.DeviceMode = 1 + self.info.ModuleIndex = 0 + # DIGITAL INPUTS CLASS + if win: + self.di_ctrl = InstantDiCtrl(self.info.Description) + self.do_ctrl = InstantDoCtrl(self.info.Description) + self.di_read = self.di_ctrl.readAny + self.do_write_bit = self.do_ctrl.writeBit + self.buffer = ctypes.create_string_buffer(5) + else: + self.di_create = libbiodaq.AdxInstantDiCtrlCreate + self.di_create.restype = ctypes.c_void_p + self.di_setSelectedDevice = libbiodaq.InstantDiCtrl_setSelectedDevice + self.di_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] + self.di_setSelectedDevice.restype = ctypes.c_uint32 + # DIGITAL INPUTS READ FUNCTION + self.di_read = libbiodaq.InstantDiCtrl_ReadAny + self.di_read.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char_p] + self.di_read.restype = ctypes.c_int32 + # DIGITAL OUTPUTS CLASS + self.do_create = libbiodaq.AdxInstantDoCtrlCreate + self.do_create.restype = ctypes.c_void_p + # SET SELECTED DEVICE + self.do_setSelectedDevice = libbiodaq.InstantDoCtrl_setSelectedDevice + self.do_setSelectedDevice.argtypes = [ctypes.c_void_p, ctypes.POINTER(self.DeviceInformation)] + self.do_setSelectedDevice.restype = ctypes.c_uint32 + # get ports + self.get_ports = libbiodaq.InstantDoCtrl_getPortDirection + self.get_ports.argtypes = [ctypes.c_void_p] + self.get_ports.restype = ctypes.POINTER(ctypes.c_void_p) + # DIGITAL OUTPUTS WRITE FUNCTION + self.do_write_bit = libbiodaq.InstantDoCtrl_WriteBit + self.do_write_bit.argtypes = [ctypes.c_void_p, ctypes.c_int32, ctypes.c_int32, ctypes.c_char] + self.do_write_bit.restype = ctypes.c_int32 + self.buffer = ctypes.create_string_buffer(5) + # INIT OBJECTS + self.di_ctrl = self.di_create() + self.do_ctrl = self.do_create() + self.di_init_status = self.di_setSelectedDevice(self.di_ctrl, ctypes.byref(self.info)) + self.do_init_status = self.do_setSelectedDevice(self.do_ctrl, ctypes.byref(self.info)) + + # SET ALL RELAYS OFF + for bit in range(0, self.out_size*8): + self.set_bit(int(bit/8), bit%8, False) + + self.state_delay = 1 + self.last_get = None + self.state_count = None + self.last_out = None + + @pyqtSlot() + def start(self): + # ACQUISITION TIMER + self.timer = QTimer() + self.timer.setTimerType(Qt.PreciseTimer) + self.timer.setInterval(int(1000 / 20)) + self.timer.timeout.connect(self._get) + self.timer.start() + super().start() + + # Read data for buffer + @pyqtSlot() + def _get(self): + get = self.get() + # print(self.last_get) + if self.state_count is None or self.last_get is None: + self.last_out = get + self.state_count = [[1 for bit in byte] for byte in get] + else: + for byte_n, byte in enumerate(get): + for bit_n, bit in enumerate(byte): + if bit == self.last_get[byte_n][bit_n]: + self.state_count[byte_n][bit_n] += 1 + else: + self.state_count[byte_n][bit_n] = 1 + if self.state_count[byte_n][bit_n] > self.state_delay: + self.last_out[byte_n][bit_n] = bit + self.last_get = get + self.update.emit([time.time(), self.last_out]) + + masks = [1 << n for n in range(8)] + + def get_all(self): + return self.get() + + # Read 1 input byte + def get(self): + self.mutex.lock() + read = [] + if win: + ret = self.di_read(0, self.in_size) + if ret[0] == ErrorCode.Success: + self.buffer = ret[1] + for byte_num in range(len(self.buffer)): + byte = self.buffer[byte_num] + read.append([bool(byte & m) for m in self.masks]) + + else: + self.buffer = None + else: + self.di_read(self.di_ctrl, 0, 1, self.buffer) + + for byte_num in range(len(self.buffer)): + byte = int.from_bytes(self.buffer[byte_num], "little") + read.append([bool(byte & m) for m in self.masks]) + + self.mutex.unlock() + return read + + # Read data bit + def get_bit(self, byte, bit): + return self.get()[byte][bit] + + # Send data byte + def set(self, start_byte, val): + for byte, v in enumerate(val, start=start_byte): + for bit, bv in enumerate([bool(v & m) for m in self.masks]): + self.set_bit(byte, bit, bv) + + # Write single bit + def set_bit(self, byte, bit, val): + self.mutex.lock() + # print("set", byte, bit, not val, flush=True) + if win: + self.do_write_bit(byte, bit, int(val)) + else: + self.do_write_bit(self.do_ctrl, byte, bit, int(val)) + self.mutex.unlock() + + # val from buffer channel + def vfbc(self, buffer, channel): + return buffer[channel[0]][channel[1]] diff --git a/src/main.py b/src/main.py index 9cb7b16..0afd009 100644 --- a/src/main.py +++ b/src/main.py @@ -79,6 +79,7 @@ try: try: # READ CONFIG self.config = ConfigReader() + self.config["autotest_done"]=False # INIT COMPONENT self.components_specs = { "archive_synchronizer": {"c": ArchiveSynchronizer}, @@ -142,9 +143,6 @@ try: self.main_window.archive_a.triggered.connect(lambda checked, self=weakref.ref(self): self().main_window.open_dialog(Archive(hide_cloud_image="vision_saver" not in self().components))) if "--archive" in sys.argv: self.main_window.archive_a.trigger() - # self.main_window.autotests_archive_a.triggered.connect(lambda checked, self=weakref.ref(self): self().main_window.open_dialog(Autotests_Archive())) - # if "--autotests-archive" in sys.argv: - # self.main_window.autotests_archive_a.trigger() self.main_window.about_a.triggered.connect(lambda checked, self=weakref.ref(self): self().main_window.open_dialog(About())) if "--about" in sys.argv: self.main_window.about_a.trigger() diff --git a/src/requirements.txt b/src/requirements.txt index ac8abdf..f0b698e 100644 --- a/src/requirements.txt +++ b/src/requirements.txt @@ -10,6 +10,7 @@ pillow pycoral pymodbus pyqt5 +pyqt5-tools pyserial pyserial-asyncio requests diff --git a/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv new file mode 100644 index 0000000..a684d47 --- /dev/null +++ b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv @@ -0,0 +1,200 @@ +"N°","AGGIORNATO COD VOLPIANO (UT)","AGGIORNATO COD VOLPIANO (MANU)","AGGIORNATO ST VOLPIANO (GRAZIA)","Cliente","Cod FInito cliente","Cod Finito R5","Cod Semilavorato Costampato","Cod Semilavorato raccordato e cablato","Cod. ContoLavoro OLD","Tubo","Mat","L[mm]","diam[mm]","Racc. 1","Or. 1","Racc. 2","Or. 2","CE su racc.1","Connettore elettrico","W-lock","connettore","tolleranza_resistenza_pos","tolleranza_resistenza_neg","tolleranza_resistenza","tempo_assestamento","codice_a_barre","verifica_codice_a_barre_abilitata","Etichetta","etichetta interoperazionale","Immagine_warning","T alim","Serie","Volumi","Lotti di produzione","Adattatori +RS0633 e/o RS0634","NOTE","R nominale","T tolleranza disegno +/-","MIN: Potenza 30 W/m","MAX: Potenza a 15 W/m","Valore medio misurato Resistenza semilav","Note1","Note2","Aggiornata Tolleranza" +162,"x","x","x","TEREX",36000,"ND","R55510","R55510/1","36000/CL","TGAI15EL","EPDM",600,"4x13","9,49","0°","9,49","90°","CE0101","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55510/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,4 Ω",20%,"6,0","13,7","8,5",,,01/12/2022 +163,"x","x","x","TEREX",36342,"ND","R55482","R55482/1","36342/CL","TGAI15EL","EPDM",3000,"4x13","7,89","0°","7,89","90°","CE0101","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,30,"R55482/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,4 Ω",25%,"1,5","3,1","2,9",,"Fare test con cavi accorciati",01/12/2022 +164,"x",,,"TEREX",36343,"ND","R55483","R55483/1","36343/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0060","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,30,"R55483/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,5 Ω",20%,"1,5","3,1",,,, +121,"x","x","x","Stauffer Diesel",59867,"ND","R55511","R55511/1","59867/CL","TGAI15EL","EPDM",1250,"4x13","6,30","90°","7,89","90°","CE0088","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R55511/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,4 Ω",20%,"3,3","7,1","4,3",,,14/11/2022 +122,"x","x","x","Stauffer Diesel",59868,"ND","R55593","R55593/1","59868/CL","TGAI15EL","EPDM",2450,"4x13","7,89","90°","7,89","90°","CE0088","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,30,"R55593/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,7 Ω",20%,"1,8","3,8","2,7",,,01/12/2022 +12,"x","x","x","Merlo",117342,"ND","R52370","R52370/1","117342/CL","026/02EL","PA12",3000,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R52370/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.000 pz/anno,,,,"3,1 Ω",20%,"1,5","3,1",3,"Modificare valore disegno","Fare test con cavi accorciati",14/11/2022 +13,"x","x","x","Merlo",117343,"ND","R52371","R52371/1","117343/CL","026/02EL","PA12",3500,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R52371/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"3,3 Ω",20%,"1,3","2,7","3,3","Modificare valore disegno","Fare test con cavi accorciati",14/11/2022 +14,"x","x","x","Merlo",117344,"ND","R52372","R52372/1","117344/CL","026/02EL","PA12",1400,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R52372/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"5,6 Ω",20%,"3,0","6,4","5,3","Modificare valore disegno",,14/11/2022 +15,"x","x","x","Merlo",117345,"ND","R52619","R52619/1","117345/CL","026/02EL","PA12",2650,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R52619/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"2,9 Ω",20%,"1,7","3,5","2,7","Modificare valore disegno",,14/11/2022 +16,"x","x","x","Merlo",117346,"ND","R52620","R52620/1","117346/CL","026/02EL","PA12",1500,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R52620/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.300 pz/anno,,,,"5,8 Ω",20%,"2,8","6,0","5,4","Modificare valore disegno",,29/11/2022 +17,"x","x","x","Merlo",117347,"ND","R52368","R52368/1","117347/CL","026/02EL","PA12",1400,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R52368/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",4.000 pz/anno,,,,"5,7 Ω",20%,"3,0","6,4","5,2","Modificare valore disegno",,14/11/2022 +18,"x","x","x","Merlo",117536,"ND","R53214","R53214/1","117536/CL","026/02EL","PA12",860,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53214/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",150 pz/anno,,,,"6,9 Ω",20%,"4,5","10,0","6,9","Modificare valore disegno",,29/11/2022 +19,"x","x","x","Merlo",117537,"ND","R53213","R53213/1","117537/CL","026/02EL","PA12",860,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53213/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",150 pz/anno,,,,"6,9 Ω",20%,"4,5","10,0","6,9","Modificare valore disegno",,29/11/2022 +24,"x","x","x","Merlo",124938,"ND","R53919","R53919/1","124938/CL","026/02EL","PA12",1100,"6X13","9,49","0°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R53919/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",800 pz/anno,,,,"10,3 Ω",10%,"5,2","11,2","10,3","Modificare valore disegno",,29/11/2022 +25,"x","x","x","Merlo",124939,"ND","R53920","R53920/1","124939/CL","026/02EL","PA12",1200,"6X13","7,89","0°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R53920/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",800 pz/anno,,,,"8,8 Ω",10%,"4,8","10,3","8,7","Modificare valore disegno",,29/11/2022 +59,"x",,,"Merlo",125637,"ND","R54674","R54674/1","125637/CL","TGAI16EL","EPDM",2600,"3X13","6,30","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,30,"R54674/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",200 pz/anno,,,,"2,9 Ω",20%,"1,7","3,6",,,, +98,"x","x","x","Hattat",1034955,"ND","R55194","R55194/1","---","026/02EL","PA12",1470,"6X13","9,49",90,"7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55194/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.500 pz/anno,,,,"5,5 Ω",10%,"3,9","8,3",,,, +99,"x","x","x","Hattat",1034956,"ND","R55195","R55195/1","---","026/02EL","PA12",1320,"6X13","9,49",90,"9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55195/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.500 pz/anno,,,,"5,0 Ω",20%,"4,3","9,2",,,, +100,"x",,,"Hattat",1034957,"ND","R55196","R55196/1","---","TGAI15EL","EPDM",649,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,20,"R55196/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.500 pz/anno,,,,"10,3 Ω",10%,"7,7","17,4",,,, +101,"x","x","x","Hattat",1034982,"ND","R55209","R55209/1","---","TGAI15EL","EPDM",1400,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55209/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",2.000 pz/anno,,,,"7,4 Ω",20%,"4,1","8,7",,,,07/12/2022 +169,"x","x","x","Hattat",1035154,"ND","R55711","R55711/1","---","TGAI15EL","EPDM",1848,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55711/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",1.000 pz/anno,,,,"3,5 Ω",20%,"3,2","6,7",,,, +170,"x","x","x","Hattat",1035165,"ND","R55712","R55712/1","---","026/02EL","PA12",498,"6X13","9,49",90,"9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55712/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",1.000 pz/anno,,,,"9,0 Ω",10%,"9,4","21,9",,,, +171,"x","x","x","Hattat",1035166,"ND","R55713","R55713/1","---","026/02EL","PA12",573,"6X13","9,49",90,"7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55713/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"SI",1.000 pz/anno,,,,"10,0 Ω",10%,"8,5","19,4",,,, +182,"x","x","x","Andreoli",2032061,"R54487","R55782","R55782/1 ","---","026/02EL","PA12",1624,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55782/1 -{N11}","x","ETA013L.prn","ETACL.prn","Img-02",14 V,"PRT",,,"X","Da completare con adattatori RS0633 (2x), montati","4,5 Ω",20%,"3,3","7,0",,,, +183,"x","x","x","Andreoli",2032062,"R54488","R55783","R55783/1 ","---","026/02EL","PA12",1378,"6x13","7,89","0°","6,30","0°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55783/1 -{N11}","x","ETA013L.prn","ETACL.prn","Img-05",14 V,"PRT",,,"X","Da completare con adattatore RS0633 (1x), montato","6,7 Ω",10%,"3,8","8,2",,,, +108,"x",,,"Andreoli",2032075,"R54799","R55768","R55768/1","---","026/02EL","PA12",656,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55768/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02",14 V,"PRT",,,"X","Da completare con adattatori RS0633 (2x), montati","11,1 Ω",10%,"7,1","16,1",,,, +109,"x","x","x","Andreoli",2032076,"R54800","R55176","R55176/1","---","TGAI15EL","EPDM",1500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55176/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05",14 V,"PRT",,,"X","Da completare con adattatore RS0633 (1x), montato","5,2 Ω",20%,"3,6","7,6",,"modificare valore res disegno",, +146,"x","x","x","Tiffin",5073279,"ND","R55138","R55138/1","5073279/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",25,25,25,30,"R55138/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,5 Ω",25%,"1,5","3,1",,,,14/11/2022 +147,"x","x","x","Tiffin",5073280,"ND","R55139","R55139/1","5073280/CL","TGAI15EL","EPDM",2000,"4x13","7,89","90°","6,30","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55139/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"3,4 Ω",20%,"2,2","4,6",,,, +148,"x","x","x","Tiffin",5073281,"ND","R55140","R55140/1","5073281/CL","TGAI15EL","EPDM",2500,"4x13","7,89","90°","6,30","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R55140/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,1 Ω",20%,"1,8","3,7",,,, +149,"x","x","x","Tiffin",5073282,"ND","R55141","R55141/1","5073282/CL","TGAI15EL","EPDM",1000,"4x13","9,49","90°","9,49","0°","CE0084","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R55141/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"7,2 Ω",20%,"4,0","8,7",,,,14/11/2022 +150,"x","x","x","Tiffin",5073283,"ND","R55142","R55142/1","5073283/CL","TGAI15EL","EPDM",3000,"4x13","9,49","0°","7,89","90°","CE0085","DEUTSCH DT: DT04-2P-C015","W2PB","SCR4",20,20,20,30,"R55142/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,4 Ω",20%,"1,5","3,1","2,6",,,01/12/2022 +151,"x","x","x","Tiffin",5073284,"ND","R55143","R55143/1","5073284/CL","TGAI15EL","EPDM",2000,"4x13","9,49","0°","7,89","90°","CE0084","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R55143/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"3,3 Ω",20%,"2,2","4,6",,,, +157,"x",,,"Capacity truck",10005328,"ND","R55463","R55463/1","10005328/CL","TGAI15EL","EPDM",1650,"4x13","9,49","0°","9,49","0°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55463/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,4 Ω",20%,"2,6","5,5",,,, +158,"x",,,"Capacity truck",10006716,"ND","R55465","R55465/1","10006716/CL","TGAI15EL","EPDM",1650,"4x13","9,49","0°","9,49","90°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55465/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,5 Ω",20%,"2,6","5,5",,,, +159,"x","x","x","Capacity truck",10006719,"ND","R55467","R55467/1","10006719/CL","TGAI15EL","EPDM",1500,"4x13","9,49","90°","9,49","0°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55467/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,1 Ω",20%,"2,8","6,0","3,8",,,01/12/2022 +160,"x","x","x","Capacity truck",10006721,"ND","R55468","R55468/1","10006721/CL","TGAI15EL","EPDM",1400,"4x13","9,49","90°","7,89","0°","CE0083","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R55468/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,1 Ω",20%,"3,0","6,4",,,, +1,"x","x",,"Vanhool",11519588,"ND","R52373","R52373/1","11519588/CL","026/02EL","PA12",4600,"6X13","9,49","90°","9,49","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R52373/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,9 Ω",10%,"4,0","8,2",,,, +2,"x","x",,"Vanhool",11519589,"ND","R52374","R52374/1","11519589/CL","026/02EL","PA12",4600,"6X13","9,49","90°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R52374/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,9 Ω",10%,"4,0","8,2",,,, +3,"x","x",,"Vanhool",11519590,"ND","R52375","R52375/1","11519590/CL","026/02EL","PA12",2700,"6X13","7,89","90°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R52375/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,4 Ω",10%,"6,6","13,7",,,, +184,"x",,,"Vanhool",11650477,"ND","R55393","R55393/1","11650477/CL","TGAI15EL","EPDM",4650,"4x13","7,89","0°","7,89","90°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,40,"R55393/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,5 Ω",10%,"4,0","8,1",,,, +125,"x","x","x","ENC",18020001,"ND","R55484","R55484/1","18020001/CL","TGAI15EL","EPDM",1150,"4x13","9,49","0°","9,49","90°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",10,10,10,20,"R55484/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,6 Ω",10%,"14,2","30,7","14,6","Modificare valore disegno",,11/11/2022 +126,"x","x","x","ENC",18020002,"ND","R55485","R55485/1","18020002/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R55485/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,7 Ω",20%,"6,0","12,4","9,3","Modificare valore disegno",,11/11/2022 +127,"x","x","x","ENC",18020003,"ND","R55486","R55486/1","18020003/CL","TGAI15EL","EPDM",3000,"4x13","7,89","0°","7,89","90°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R55486/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,5 Ω",20%,"6,0","12,4","9,5","Modificare valore disegno",,11/11/2022 +56,"x","x","x","Irum",21003808,"ND","R54783","R54783/1","21.003808/CL","TGAI15EL","EPDM",1500,"4x13","7,89","0°","6,30","90°","CE0077/3","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",20,20,20,20,"R54783/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.000 pz/anno,,,,"5,2 Ω",20%,"2,8","6,0",,,,11/11/2022 +57,"x","x","x","Irum",21003809,"ND","R54785","R54785/1","21003809/CL","026/02EL","PA12",1000,"6X13","9,49","90°","9,49","0°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",15,15,15,10,"R54785/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.000 pz/anno,,,,"7,7 Ω",15%,"4,0","8,7","7,3",,,01/12/2022 +58,"x","x","x","Irum",21003810,"ND","R54784","R54784/1","21.003810/CL","026/02EL","PA12",1000,"6X13","7,89","90°","9,49","0°","CE0077/2","DEUTSCH DT: DT04-2P-C015","W2PB","SCR4",15,15,15,10,"R54784/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",2.000 pz/anno,,,,"7,7 Ω",15%,"4,0","8,7","7,1",,,01/12/2022 +139,"x",,,"Prinoth",28026891,"ND","R52972","R52972/1","28026891/CL","TGAI15EL","EPDM",2986,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52972/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,5 Ω",10%,"6,0","12,4",,,, +140,"x",,,"Prinoth",28026892,"ND","R52973","R52973/1","28026892/CL","TGAI15EL","EPDM",3177,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52973/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"10,1 Ω",10%,"5,7","11,7",,,, +141,"x",,,"Prinoth",28026894,"ND","R52975","R52975/1","28026894/CL","TGAI15EL","EPDM",2386,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52975/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,7 Ω",10%,"7,4","15,4",,,, +142,"x","x","x","Prinoth",28026895,"ND","R52976","R52976/1","28026895/CL","TGAI15EL","EPDM",2867,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52976/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,1 Ω",10%,"6,3","12,9",,,, +143,"x",,,"Prinoth",28026896,"ND","R52977","R52977/1","28026896/CL","TGAI15EL","EPDM",2166,"4x13","6,30","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52977/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,0 Ω",10%,"8,1","16,9",,,, +144,"x",,,"Prinoth",28026897,"ND","R52978","R52978/1","28026897/CL","TGAI15EL","EPDM",2216,"4x13","6,30","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,30,"R52978/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,4 Ω",10%,"7,9","16,6",,,, +145,"x",,,"Prinoth",28026898,"ND","R52979","R52979/1","28026898/CL","TGAI15EL","EPDM",4697,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,40,"R52979/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,3 Ω",10%,"3,9","8,0",,,, +110,"x","x","x","Prinoth",28054860,"ND","R54345","R54345/1","28054860/CL","TGAI15EL","EPDM",1850,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,20,"R54345/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",150 pz/anno,,,,"15,7 Ω",10%,"9,4","19,7","14,6",,,01/12/2022 +111,"x","x","x","Prinoth",28054871,"ND","R54346","R54346/1","28054871/CL","TGAI15EL","EPDM",2200,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",15,15,15,30,"R54346/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",150 pz/anno,,,,"14,7 Ω",15%,"8,0","16,7","13,3",,,01/12/2022 +128,"x","x","x","Antonio Carraro",46628004,"ND","R54689","R54689/1","46628004/CL","026/02EL","PA12",800,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54689/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,8 Ω",10%,"4,8","10,7",,,,14/11/2022 +129,"x","x","x","Antonio Carraro",46628005,"ND","R54690","R54690/1","46628005/CL","TGAI15EL","EPDM",800,"4x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",15,15,15,20,"R54690/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,2 Ω",15%,"4,8","10,7",,,,14/11/2022 +130,"x","x","x","Antonio Carraro",46628006,"ND","R54691","R54691/1","46628006/CL","TGAI15EL","EPDM",550,"4x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54691/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,1 Ω",20%,"6,4","14,8",,,,14/11/2022 +186,"x",,,"Antonio Carraro",46628007,"ND","R55258","R55258/1","46628007/CL","026/02EL","PA12",550,"6x13","9,49","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55258/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,4 Ω",10%,"6,4","14,8",,,, +187,"x",,,"Antonio Carraro",46628008,"ND","R55260","R55260/1","46628008/CL","026/02EL","PA12",600,"6x13","9,49","0°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55260/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"10,0 Ω",10%,"6,0","13,7",,,, +188,"x",,,"Antonio Carraro",46628009,"ND","R55262","R55262/1","46628009/CL","026/02EL","PA12",1470,"6x13","7,89","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55262/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,4 Ω",10%,"2,9","6,1",,,, +195,"x",,,"Manitou",52607933,"ND","R53253","R53253/1","52607933/CL","026/02EL","PA12",3300,"6X13","9,49","90°","7,89","90°","CE0046","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53253/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,9 Ω",10%,"1,4","2,8",,,, +196,"x",,,"Manitou",52607935,"ND","R53251","R53251/1","52607935/CL","026/02EL","PA12",3300,"6X13","9,49","90°","9,49","90°","CE0046","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53251/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,9 Ω",10%,"1,4","2,8",,,, +197,"x",,,"Manitou",52607941,"ND","R53252","R53252/1","52607941/CL","026/02EL","PA12",2340,"6X13","7,89","90°","7,89","0°","CE0046","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53252/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,1 Ω",10%,"1,9","3,9",,,, +45,"x",,,"Manitou",53003548,"ND","R54907","R54907/1","53003548/CL","026/02EL","PA12",2270,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54907/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,3 Ω",20%,"1,9","4,1",,,, +4,"x","x",,"Manitou",53020608,"ND","R52399","R52399/1","53020608/CL","026/02EL","PA12",3650,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52399/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"6,3 Ω",10%,"5,0","10,2",6,,, +5,"x","x",,"Manitou",53020610,"ND","R52400","R52400/1","53020610/CL","026/02EL","PA12",2680,"6X13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52400/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"8,7 Ω",10%,"6,7","13,8","8,7","Modificare valore disegno",, +6,"x","x",,"Manitou",53020612,"ND","R52401","R52401/1","53020612/CL","026/02EL","PA12",970,"6X13","9,49","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52401/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"13,0 Ω",10%,"12,0 *","35,9","12,6",,, +7,"x","x",,"Manitou",53027246,"ND","R52452","R52452/1","53027246/CL","026/02EL","PA12",1150,"6X13","9,49","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52452/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,9 Ω",10%,"14,2","30,7","14,9","Modificare valore disegno",, +8,"x","x",,"Manitou",53027247,"ND","R52453","R52453/1","53027247/CL","026/02EL","PA12",2750,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52453/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"9,0 Ω",10%,"6,5","13,5",9,"Modificare valore disegno",, +9,"x","x",,"Manitou",53027248,"ND","R52454","R52454/1","53027248/CL","026/02EL","PA12",1900,"6X13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52454/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"11,7 Ω",10%,"9,1","19,2","11,7","Modificare valore disegno",, +10,"x","x",,"Manitou",53027252,"ND","R52510","R52510/1","53027252/CL","026/02EL-S","PA12",750,"6X13","6,30","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52510/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"20,6 Ω",10%,"20,2","45,2",,,, +11,"x","x",,"Manitou",53027253,"ND","R52511","R52511/1","53027253/CL","026/02EL","PA12",1960,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52511/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"14,2 Ω",10%,"8,9","18,6",,,, +60,"x","x","x","FPT",5802933678,"ND","R54292","R54292/1","5802933678/CL","026/02EL","PA12",2000,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54292/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,6 Ω",20%,"2,2","4,6",4,,,01/12/2022 +61,"x","x","x","FPT",5802933689,"ND","R54294","R54294/1","5802933689/CL","026/02EL","PA12",3000,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R54294/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,6 Ω",25%,"1,5","3,1","3,1",,"Fare test con cavi accorciati",01/12/2022 +64,"X","x","x","FPT",5802933697,"ND","R54296","R54296/1","5802933697/CL","026/02EL","PA12",2000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54296/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,6 Ω",20%,"2,2","4,6","4,2",,,01/12/2022 +65,"x","x","x","FPT",5802933700,"ND","R54298","R54298/1","5802933700/CL","026/02EL","PA12",3000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R54298/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,6 Ω",25%,"1,5","3,1","3,1",,"Fare test con cavi accorciati",01/12/2022 +48,"x","x","x","FPT",5802933703,"ND","R54300","R54300/1","5802933703/CL","TGAI15EL","EPDM",2000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,20,"R54300/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"3,4 Ω",25%,"2,2","4,6","3,7",,,01/12/2022 +47,"x","x","x","FPT",5802933707,"ND","R54302","R54302/1","5802933707/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,30,"R54302/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,5 Ω",20%,"1,5","3,1",,,, +85,"x","x","x","FPT",5802938582,"ND","R54532","R54532/1","5802938582/CL","026/02EL-S","PA12",500,"6x13","9,49","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54532/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,3 Ω",10%,"6,9","16,0","7,2",,,01/12/2022 +62,"x","x","x","FPT",5802969802,"ND","R54526","R54526/1","5802969802/CL","026/02EL","PA12",1000,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54526/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,8 Ω",10%,"4,0","8,7","7,8",,,01/12/2022 +46,"x","x","x","FPT",5802969810,"ND","R54528","R54528/1","5802969810/CL","TGAI15EL","EPDM",1000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54528/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,3 Ω",20%,"4,0","8,7","6,4",,,13/12/2022 +63,"x","x","x","FPT",5802969811,"ND","R54530","R54530/1","5802969811/CL","026/02EL","PA12",1000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54530/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,8 Ω",10%,"4,0","8,7","7,4",,,01/12/2022 +86,"x","x","x","FPT",5802970303,"ND","R54534","R54534/1","5802970303/CL","026/02EL-S","PA12",500,"6x13","9,49","0°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",14,14,14,10,"R54534/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"7,3 Ω",14%,"6,9","16,0","7,3",,"Aggiornata tolleranza fino a 6,3 come a disegno = potenza 36W/m", +97,"x","x","x","Bimotor"," BR5PLH1000","R54276/C4","R55717","R55717/1","R54276/C4/CL","TGAI15EL","EPDM",1000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55717/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati ","7,5 Ω",20%,"5,1","11,0",,,,11/11/2022 +113,"x","x","x","Otokar","13H30-32252-P4","R55677","R55603","R55603/1","13H30-32252-AA/CL","026/02EL-S","PA12",800,"6x13","9,49","90°","7,89","90°","CE0110","AMP SUPERSEAL 1.5 SERIES: 282080-1",,"SCR12",12,12,12,10,"R55603/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",250 pz/anno,,,,"21,7 Ω",12%,"19,2","42,7",,,,14/11/2022 +114,"x","x","x","Otokar","13H30-32254-P4","R55678","R55605","R55605/1","13H30-32254-AA/CL","TGAI16EL","EPDM",1800,"3x13","6,30","0°","6,30","0°","CE0110","AMP SUPERSEAL 1.5 SERIES: 282080-1",,"SCR12",20,20,20,20,"R55605/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT","250 pz/anno",,,,"15,4 Ω",20%,"9,6","20,2",,,, +115,"x","x","x","Otokar","13M26-32254-P4","R55679","R55608","R55608/1","13M26-32254-AA/CL","TGAI16EL","EPDM",2300,"3x13","6,30","0°","6,30","0°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R55608/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",250 pz/anno,,,,"11,3 Ω",20%,"7,7","16,0",,,, +116,"x","x","x","Otokar","13M65-32254-P4","R55680","R55609","R55609/1","13M65-32254-AA/CL","026/02EL","PA12",3000,"6x13","7,89","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,10,"R55609/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",500 pz/anno,,,,"8,4 Ω",20%,"6,0","12,4",,,, +112,"x","x","x","Otokar","13R00-32254-P4","R55676","R55602","R55602/1","13R00-32254-AA/CL","026/02EL","PA12",1200,"6x13","7,89","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",10,10,10,10,"R55602/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",1.000 pz/anno,,,,"17,6 Ω",10%,"13,7","29,5","17,6","Modificare valore disegno",, +119,"x","x","x","Otokar","13R50-32252-P4","R55683","R55612","R55612/1","13R50-32252-AA/CL","026/02EL-S","PA12",800,"6x13","9,49","90°","9,49","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",12,12,12,10,"R55612/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"21,7 Ω",12%,"19,2","42,7",,,,14/11/2022 +120,"x","x","x","Otokar","13R50-32254-P4","R55684","R55613","R55613/1","13R50-32254-AA/CL","026/02EL","PA12",2200,"6x13","7,89","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",10,10,10,10,"R55613/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"11,8 Ω",10%,"8,0","16,7",,,, +66,"x","x","x","CRANE CARRIER","145-3810","ND","R54445","R54445/1","145-3810/CL","TGAI15EL","EPDM",3200,"4x13","9,49","0°","7,89","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R54445/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"2,6 Ω",20%,"1,4","2,9","2,5",,,01/12/2022 +67,"x","x","x","CRANE CARRIER","145-3811","ND","R54446","R54446/1","145-3811/CL","TGAI15EL","EPDM",540,"4x13","9,49","0°","9,49","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54446/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"8,7 Ω",20%,"6,5","15,0","7,2",,,14/11/2022 +68,"x","x","x","CRANE CARRIER","145-3812","ND","R54447","R54447/1","145-3812/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R54447/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"2,5 Ω",20%,"1,5","3,1",,,, +69,"x","x","x","CRANE CARRIER","145-3813","ND","R54448","R54448/1","145-3813/CL","TGAI15EL","EPDM",2500,"4x13","9,49","0°","7,89","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,30,"R54448/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"2,1 Ω",20%,"1,8","3,7",2,,,01/12/2022 +70,"x","x","x","CRANE CARRIER","145-3814","ND","R54449","R54449/1","145-3814/CL","TGAI15EL","EPDM",1000,"4x13","9,49","0°","9,49","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54449/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"7,2 Ω",20%,"4,0","8,7","6,2",,,01/12/2022 +71,"x","x","x","CRANE CARRIER","145-3815","ND","R54450","R54450/1","145-3815/CL","TGAI15EL","EPDM",2000,"4x13","7,89","90°","6,30","90°","CE0055","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54450/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"3,4 Ω",20%,"2,2","4,6",,,, +72,"x","x","x","CRANE CARRIER","145-3830","ND","R54878","R54878/1","145-3830/CL","TGAI15EL","EPDM",500,"4x13","9,49","90°","9,49","0°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",20,20,20,20,"R54878/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"8,2 Ω",20%,"6,9","16,0","6,8",,"Da verificare",01/12/2022 +73,"x",,,"CRANE CARRIER","145-3831","ND","R54879","R54879/1","145-3831/CL","TGAI15EL","EPDM",500,"4x13","9,49","90°","7,89","0°","CE0078","Delphi/Weather-pack WPT-2 12015792",,"SCR10",10,10,10,20,"R54879/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",500 pz/anno,,,,"8,2 Ω",10%,"6,9","16,0",,,, +117,"x","x","x","Otokar","16N60-32252-P4","R55681","R55610","R55610/1","16N60-32252-AA/CL","026/02EL","PA12",2000,"6x13","9,49","90°","9,49","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,10,"R55610/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"14,4 Ω",20%,"8,7","18,3",,,, +118,"x","x","x","Otokar","16N60-32254-P4","R55682","R55611","R55611/1","16N60-32254-AA/CL","026/02EL","PA12",1700,"6x13","7,89","0°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,10,"R55611/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",750 pz/anno,,,,"15,7 Ω",20%,"10,1","21,3",,,, +26,"x",,,"Venieri","180.3.827","ND","R54095","R54095/1","180.3.827/CL","026/02EL","PA12",860,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",10,10,10,10,"R54095/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"6,9 Ω",10%,"4,5","10,0",,,, +27,"x",,,"Venieri","180.3.828","ND","R53928","R53928/1","180.3.828/CL","026/02EL","PA12",2650,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53928/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,3 Ω",20%,"1,7","3,5",,,, +28,"x",,,"Venieri","180.3.829","ND","R53929","R53929/1","180.3.829/CL","026/02EL","PA12",2650,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R53929/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"2,3 Ω",20%,"1,7","3,5",,,, +38,"x","x","x","Venieri","180.3.830","ND","R55660","R55660/1","180.3.830/CL","026/02EL","PA12",1000,"6X13","7,89","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R55660/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"7,0 Ω",10%,"4,0","8,7",,,,14/11/2022 +39,"x","x","x","Venieri","180.3.831","ND","R55661","R55661/1","180.3.831/CL","026/02EL","PA12",1000,"6X13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",10,10,10,10,"R55661/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"7,0 Ω",10%,"4,0","8,7",,,,14/11/2022 +198,"x",,,"Venieri","180.3.832","ND","R54140","R54140/1","180.3.832/CL","026/02EL","PA12",4000,"6X13","7,89","90°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R54140/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"3,1 Ω",20%,"1,1","2,3",,,, +105,"x",,,"Venieri","180.3.837","ND","R54788","R54788/1","180.3.837/CL","026/02EL-S","PA12",1000,"6X13","7,89","90°","9,49","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R54788/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",30 pz/anno,,,,"26,1 Ω",10%,"16,0","34,9",,,, +106,"x",,,"Venieri","180.3.838","ND","R54789","R54789/1","180.3.838/CL","026/02EL-S","PA12",1000,"6X13","9,49","90°","9,49","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R54789/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",30 pz/anno,,,,"26,1 Ω",10%,"16,0","34,9",,,, +107,"x",,,"Venieri","180.3.839","ND","R54790","R54790/1","180.3.839/CL","026/02EL","PA12",4000,"6X13","7,89","90°","7,89","90°","CE0065","HDSCS: 4-1418483-1",,"SCR9",20,20,20,10,"R54790/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",30 pz/anno,,,,"6,9 Ω",20%,"4,6","9,4",,,, +52,"x",,,"Merlo","19PU012_639","ND","R55202","R55202/1","ND","026/02EL","PA12",2450,"6X13","7,89","0°","7,89","90°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R55202/1-{N11}","x","ETA013L.prn","ETACL.prn","",14 V,"PRT",,,,,"4,3 Ω",20%,"2,5","5,3",,,, +74,"x","x","x","INDIANA PHOENIX","465-012","ND","R55146","R55146/1","465-012/CL","TGAI15EL","EPDM",1500,"4x13","9,49","90°","9,49","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,20,"R55146/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",330 pz/anno,,,,"5,1 Ω",20%,"2,8","6,0","4,5",,,01/12/2022 +75,"x","x","x","INDIANA PHOENIX","465-013","ND","R55147","R55147/1","465-013/CL","TGAI15EL","EPDM",2500,"4x13","7,89","90°","6,30","90°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55147/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",330 pz/anno,,,,"2,1 Ω",20%,"1,8","3,7",2,,,01/12/2022 +76,"x","x","x","INDIANA PHOENIX","465-014","ND","R55151","R55151/1","465-014/CL","TGAI15EL","EPDM",3000,"4x13","7,89","0°","7,89","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55151/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",330 pz/anno,,,,"2,4 Ω",20%,"1,5","3,1","2,3",,,01/12/2022 +165,"x","x","x","INDIANA PHOENIX","465-018","R55749","R55561","R55561/1","---","TGAI15EL","EPDM",1500,"4x13","6,30","0°","6,30","90°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,20,"R55561/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,,"5,2 Ω",20%,"2,8","6,0","4,4","Modificare valore disegno","Da verificare su pezzi campionatura in consegna il 25/11/22",01/12/2022 +166,"x","x","x","INDIANA PHOENIX","465-019","R55750","R55673","R55673/1","---","TGAI15EL","EPDM",3200,"4x13","9,49","0°","7,89","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55673/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,,"2,6 Ω",20%,"1,4","2,9","Da verificare su pezzi campionatura in consegna il 25/11/22",,, +167,"x","x","x","INDIANA PHOENIX","465-021","R55751","R55666","R55666/1","---","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55666/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,,"2,5 Ω",20%,"1,5","3,1","Da verificare su pezzi campionatura in consegna il 25/11/22",,, +168,"x","x","x","INDIANA PHOENIX","465-022","R55753","R55752","R55752/1","---","TGAI15EL","EPDM",3400,"4x13","9,49","0°","7,89","0°","CE0086","Delphi/Weather-pack WPT-2 12010973",,"SCR11",20,20,20,30,"R55752/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",1.200 pz/anno,400,,"Rifilo ridotto a 50mm per parte","2,7 Ω",20%,"1,4","2,7","Da verificare su pezzi campionatura in consegna il 25/11/22",,, +154,"x","x","x","BCS","580B1783","ND","R55626","R55626/1","580B1783/CL","026/02EL","PA12",550,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55626/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,7 Ω",10%,"6,4","14,8",,,, +155,"x","x","x","BCS","580B1784","ND","R55627","R55627/1","580B1784/CL","026/02EL","PA12",500,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55627/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"9,0 Ω",10%,"6,9","16,0",,,, +192,"x",,,"BCS","580B1809","ND","R55504","R55504/1","580B1809/CL","026/02EL-S","PA12",355,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55504/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"12,0 Ω",10%,"8,6","21,1",,,, +193,"x",,,"BCS","580B1810","ND","R55505","R55505/1","580B1810/CL","026/02EL-S","PA12",385,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55505/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"12,6 Ω",10%,"8,2","19,8",,,, +194,"x",,,"BCS","580B1811","ND","R55506","R55506/1","580B1811/CL","TGAI15EL","EPDM",2017,"4x13","7,89","90°","6,30","0°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,30,"R55506/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","3,7 Ω",20%,"2,2","4,5",,,, +156,"x","x","x","BCS","580B2270","ND","R55628","R55628/1","580B2270/CL","TGAI15EL","EPDM",1538,"4x13","7,89","90°","6,30","0°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55628/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,2 Ω",20%,"2,8","5,9",,,, +189,"x",,,"Argo Tractors","6619812A1","R55754","R55757","R55757/1","---","026/02EL","PA12",1532,"6X13","7,89","90°","7,89","90°","CE0077/3","DEUTSCH DT: DT04-2P-C015","W2PC","SCR5",10,10,10,10,"R55757/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",30 pz/anno,,,,"4,6 Ω",10%,"2,8","5,9",,,, +190,"x",,,"Argo Tractors","6619813A1","R55755","R55758","R55758/1","---","026/02EL-S","PA12",370,"6X13","9,49","90°","7,89","90°","CE0077/1","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",10,10,10,10,"R55758/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",30 pz/anno,,,,"12,7 Ω",10%,"8,4","20,4",,,, +191,"x",,,"Argo Tractors","6619814A1","R55756","R55759","R55759/1","---","026/02EL-S","PA12",473,"6X13","9,49","90°","9,49","90°","CE0077/2","DEUTSCH DT: DT04-2P-C015","W2PB","SCR4",10,10,10,10,"R55759/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",30 pz/anno,,,,"14,5 Ω",10%,"7,1","16,8",,,, +29,"x","x","x","Argo Tractors","6671546A3","ND","R54313","R54313/1","6671546A3/CL","026/02EL","PA12",855,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54313/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",900 pz/anno,,,,"10,3 Ω",10%,"4,5","10,1",,,, +30,"x","x","x","Argo Tractors","6671547A3","ND","R54314","R54314/1","6671547A3/CL","026/02EL","PA12",800,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54314/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",900 pz/anno,,,,"8,1 Ω",10%,"4,8","10,7","8,3",,,14/11/2022 +31,"x","x","x","Argo Tractors","6671549A3","ND","R54315","R54315/1","6671549A3/CL","026/02EL","PA12",1025,"6X13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54315/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",900 pz/anno,,,,"8,0 Ω",10%,"3,9","8,5",,,,14/11/2022 +35,"x","x","x","Argo Tractors","6688903A2","ND","R53645","R53645/1","6688903A2/CL","026/02EL-S","PA12",380,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53645/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"12,4 Ω",10%,"8,3","20,0","12,1",,,11/11/2022 +37,"x","x","x","Argo Tractors","6688904A2","ND","R53643","R53643/1","6688904A2/CL","026/02EL","PA12",469,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R53643/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"8,0 Ω",10%,"7,2","16,9","8,4",,,14/11/2022 +36,"x","x","x","Argo Tractors","6688905A1","ND","R53644","R53644/1","6688905A1/CL","TGAI15EL","EPDM",1858,"4X13","7,89","0°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R53644/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"3,1 Ω",20%,"2,3","4,9","3,4",,,14/01/2022 +40,"x","x","x","Argo Tractors","6691394A3","ND","R54335","R54335/1","6691394A3/CL","026/02EL","PA12",1020,"6X13","7,89","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54335/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"7,8 Ω",10%,"3,9","8,6",,,,29/11/2022 +41,"x","x","x","Argo Tractors","6693686A3","ND","R54336","R54336/1","6693686A1/CL","026/02EL","PA12",2375,"6X13","9,49","0°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54336/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"3,3 Ω",20%,"1,9","3,9","3,7",,,01/12/2022 +42,"x","x","x","Argo Tractors","6693687A3","ND","R54337","R54337/1","6693687A3/CL","026/02EL","PA12",2520,"6X13","9,49","0°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",30,30,30,10,"R54337/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",1.500 pz/anno,,,,"3,0 Ω",30%,"1,8","3,7","3,6",,"Fare test con cavi accorciati",01/12/2022 +32,"x","x","x","Argo Tractors","6703587A","ND","R54020","R54020/1","6703587A/CL","026/02EL","PA12",515,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54020/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"8,4 Ω",20%,"6,7","15,6",,,,01/12/2022 +33,"x","x","x","Argo Tractors","6703588A","ND","R54021","R54021/1","6703588A/CL","026/02EL","PA12",595,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R54021/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"9,4 Ω",20%,"6,0","13,8",,,,01/12/2022 +34,"x","x","x","Argo Tractors","6703589A","ND","R54026","R54026/1","6703589A/CL","TGAI15EL","EPDM",1528,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54026/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",700 pz/anno,,,,"3,9 Ω",20%,"2,8","5,9","4,4",,,14/11/2022 +43,"x","x","x","Argo Tractors","6703994A1","ND","R54732","R54732/1","6703994A1/CL","TGAI15EL","EPDM",1800,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54732/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",400 pz/anno,,,,"4,4 Ω",20%,"2,4","5,1","4,3",,,01/12/2022 +178,"x",,,"Argo Tractors","6721854A1","R55741","R55559","R55559/1","---","026/02EL","PA12",555,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55559/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"9,3 Ω",20%,"6,4","14,7",,,, +185,"x","x","x","Argo Tractors","6721865A1","R55785","R55560","R55560/1","---","026/02EL","PA12",775,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55560/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",50 pz/anno,,,,"7,6 Ω",20%,"4,9","11,0",,,, +134,"x","x","x","Deutz","ACC95887051","R55207","R55734","R55734/1","R55207/CL","026/02EL-S","PA12",788,"6x13","9,49","0°","7,89","90°","CE0129","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55734/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"20,9 Ω",10%,"19,4","43,2",,,, +135,"x",,,"Deutz","ACC95887053","R55208","R55735","R55735/1","---","026/02EL-S","PA12",786,"6x13","9,49","0°","9,49","90°","CE0129","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55735/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"20,9 Ω",10%,"19,5","43,3",,,, +136,"x","x","x","Deutz","ACC95887080","R55500","R55736","R55736/1","R55500/CL","026/02EL","PA12",950,"6x13","9,49","90°","7,89","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R55736/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,5 Ω",20%,"4,2","9,1",,,, +137,"x","x","x","Deutz","ACC95887081","R55501","R55737","R55737/1","R55501/CL","026/02EL","PA12",965,"6x13","9,49","90°","9,49","90°","CE0029","HDSCS: 2-1418483-1",,"SCR7",20,20,20,10,"R55737/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"5,5 Ω",20%,"4,1","9,0",,,, +138,"x","x","x","Deutz","ACC95887082","R55502","R55738","R55738/1","R55502/CL","026/02EL","PA12",2250,"6x13","7,89","90°","7,89","0°","CE0028","HDSCS: 1-1418483-1",,"SCR6",20,20,20,10,"R55738/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"2,9 Ω",20%,"2,0","4,1",3,,,01/12/2022 +94,"x","x",,"Bimotor","BR5BLH1000","R54259/C4","R55725","R55725/1","R54259/C4/CL","026/02EL","PA12",1000,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55725/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633, montati ","5,9 Ω",20%,"5,1","11,0",,,, +93,"x","x",,"Bimotor","BR5BLH1500","R54257","R55724","R55724/1","R54257/CL","026/02EL","PA12",1500,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55724/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","4,2 Ω",20%,"3,6","7,6",,,, +92,"x","x",,"Bimotor","BR5BLH2500","R54259/C2","R55723","R55723/1","R54259/C2/CL","026/02EL","PA12",2500,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55723/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","3,0 Ω",20%,"2,3","4,7",,,, +124,"x","x","x","Bimotor","BR5BLH345","R54384","R52727","R52727/1","R54384/CL","026/02EL-S","PA12",345,"6X13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R52727/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","11,7 Ω",10%,"11,1","27,3",,,,11/11/2022 +91,"x","x","x","Bimotor","BR5BLH3500","R54259","R55722","R55722/1","R54259/CL","026/02EL","PA12",3500,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55722/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-02","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (2x), montati","3,7 Ω",20%,"1,6","3,4","3,8",,"Accorciare rifilo",29/11/2022 +96,"x","x","x","Bimotor","BR5PLH1500","R54276/C3","R55716","R55716/1","R54276/C3/CL","TGAI15EL","EPDM",1500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55716/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati ","5,2 Ω",20%,"3,6","7,6",,"modificare valore res disegno",,11/11/2022 +95,"x","x","x","Bimotor","BR5PLH2500","R54276/C2","R55715","R55715/1","R54276/C2/CL","TGAI15EL","EPDM",2500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,30,"R55715/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati ","2,8 Ω",25%,"2,3","4,7",,,,11/11/2022 +44,"x","x","x","Bimotor","BR5PLH3000","R54276","R55714","R55714/1","R54276/CL","TGAI15EL","EPDM",3000,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,30,"R55714/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05","13,5 V","SI",,,"X","Da completare con adattatori RS0633 (1x), montati","2,5 Ω",20%,"1,9","3,9",,,, +90,"x","x","x","Bimotor","BR5SLH1000","R54258/C4","R55721","R55721/1","R54258/C4/CL","026/02EL","PA12",1000,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55721/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","5,9 Ω",20%,"5,1","11,0",,,,14/11/2022 +89,"x","x",,"Bimotor","BR5SLH1500","R54256","R55720","R55720/1","R54256/CL","026/02EL","PA12",1500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55720/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","4,2 Ω",20%,"3,6","7,6",,,, +88,"x","x","x","Bimotor","BR5SLH2500","R54258/C2","R55719","R55719/1","R54258/C2/CL","026/02EL","PA12",2500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R55719/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","3,0 Ω",25%,"2,3","4,7",,,,14/11/2022 +123,"x","x","x","Bimotor","BR5SLH345","R54383","R55726","R55726/1","R54383/CL","026/02EL-S","PA12",345,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55726/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634 (2x), montati","11,7 Ω",10%,"11,1","27,3",,,,11/11/2022 +87,"x","x","x","Bimotor","BR5SLH3500","R54258","R55718","R55718/1","R54258/CL","026/02EL","PA12",3500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",25,25,25,10,"R55718/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01","13,5 V","SI",,,"X","Da completare con adattatori RS0634, montati ","3,0 Ω",25%,"1,6","3,4",,,, +53,"x",,,"Sutphen","CHF-6156","ND","R54951","R54951/1","CHF-6156/CL","TGAI15EL","EPDM",1054,"4X13","9,49","0°","9,49","90°","CE0081","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,20,"R54951/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",275 pz/anno,,,,"5,0 Ω",20%,"3,8","8,3",,,, +54,"x",,,"Sutphen","CHF-6157","ND","R54952","R54952/1","CHF-6157/CL","TGAI15EL","EPDM",2680,"4X13","7,89","90°","6,30","90°","CE0081","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R54952/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",275 pz/anno,,,,"2,2 Ω",20%,"1,7","3,5",,,, +55,"x",,,"Sutphen","CHF-6158","ND","R54953","R54953/1","CHF-6158/CL","TGAI15EL","EPDM",2680,"4X13","7,89","0°","7,89","90°","CE0081","DEUTSCH DT: DT04-2P-C015","W2PA","SCR3",20,20,20,30,"R54953/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",275 pz/anno,,,,"2,2 Ω",20%,"1,7","3,5",,,, +179,"x","x","x","Eminox","M0856","R55742","R55733","R55733/1","---","026/02EL","PA12",3000,"6X13","7,89","90°","7,89","90°","CE0130","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R55733/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",50 pz/anno,,,,"10,5 Ω",10%,"6,0","12,4",,,, +180,"x","x","x","Eminox","M0887","R55744","R55743","R55743/1","---","026/02EL-S","PA12",800,"6X13","7,89","0°","9,49","90°","CE0130","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R55743/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",50 pz/anno,,,,"21,2 Ω",10%,"19,2","42,7",,,, +181,"x","x","x","Eminox","M0888","R55746","R55745","R55745/1","---","026/02EL-S","PA12",800,"6X13","9,49","0°","9,49","90°","CE0130","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",10,10,10,10,"R55745/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",50 pz/anno,,,,"21,2 Ω",10%,"19,2","42,7",,,, +152,"x","x","x","Kaha","R53293","R53293","R53292","R53292/1","R53293/CL","026/02EL","PA12",5000,"6x13","7,89","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R53292/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"4,3 Ω",20%,"3,7","7,5",,,, +172,"x",,,"New Sorema","R53958","R53958","R53957","R53957/1","---","026/02EL","PA12",4500,"6X13","9,49","0°","9,49","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53957/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","6,1 Ω",20%,"4,1","8,3",,,, +173,"x",,,"New Sorema","R53960","R53960","R53959","R53959/1","---","026/02EL","PA12",4500,"6X13","9,49","0°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53959/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","6,1 Ω",20%,"4,1","8,3",,,, +174,"x",,,"New Sorema","R53962","R53962","R53961","R53961/1","---","026/02EL","PA12",5500,"6X13","9,49","0°","9,49","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53961/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","4,6 Ω",20%,"3,4","6,9",,,, +175,"x",,,"New Sorema","R53964","R53964","R53963","R53963/1","---","026/02EL","PA12",5500,"6X13","9,49","0°","7,89","0°","CE0017","AMP SUPERSEAL 1.5 SERIES: 282104-1",,"SCR1",20,20,20,10,"R53963/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,"Con guaina GA0049, GA0018, NAV003","4,6 Ω",20%,"3,4","6,9",,,, +49,"x","x","x","Avoni","R54815","R54815","R54814","R54814/1","R54815/CL","026/02EL-S","PA12",380,"6X13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54814/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-03",12 V,"SI",,,"X","Da completare con adattatori RS0634 (1x) RS0633 (1x), montati","12,4 Ω",10%,"8,3","20,0","12,4",,,01/12/2022 +50,"x",,,"Avoni","R54817","R54817","R54816","R54816/1","R54817/CL","026/02EL-S","PA12",380,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54816/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"SI",,,"X","Da completare con adattatori RS0634 (2x), montati","12,4 Ω",10%,"8,3","20,0",,,, +51,"x",,,"Avoni","R54819","R54819","R54818","R54818/1","R54819/CL","TGAI15EL","EPDM",1200,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R54818/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05",12 V,"SI",,,"X","Da completare con adattatori RS0633 (1x), montati","4,3 Ω",20%,"3,4","7,4",,,, +78,"x",,,"Avoni","R54824","R54824","R54823","R54823/1","---","026/02EL","PA12",500,"6x13","9,49","90°","7,89","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54823/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-03",12 V,"PRT",,,"X","Da completare con adattatori RS0634 (1x) RS0633 (1x), montati","9,0 Ω",10%,"6,9","16,0",,,, +79,"x",,,"Avoni","R54826","R54826","R54825","R54825/1","---","026/02EL","PA12",500,"6x13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R54825/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"PRT",,,"X","Da completare con adattatori RS0634 (2x), montati","9,0 Ω",10%,"6,9","16,0",,,, +80,"x",,,"Avoni","R54828","R54828","R54827","R54827/1","---","TGAI15EL","EPDM",500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,20,"R54827/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-05",12 V,"PRT",,,"X","Da completare con adattatori RS0633 (1x), montati","8,5 Ω",10%,"6,9","16,0",,,, +81,"x",,,"Deutz","R54841","R54841","R55770","R55770/1","---","026/02EL","PA12",2025,"6x13","7,89","90°","7,89","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55770/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"10,9 Ω",10%,"8,6","18,1",,,, +82,"x",,,"Deutz","R54842","R54842","R55771","R55771/1","R54842/CL","026/02EL","PA12",1525,"6x13","7,89","90°","7,89","90°","CE0065","HDSCS: 4-1418483-1",,"SCR9",10,10,10,10,"R55771/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",50 pz/anno,,,,"14,0 Ω",10%,"11,1","23,6",,,, +176,"x",,,"New Sorema","R54860","R54860","R55764","R55764/1","R54860/CL","026/02EL","PA12","4028,5","6X13","9,49","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",20,20,20,10,"R55764/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"6,9 Ω",20%,"4,5","9,3",,,, +177,"x",,,"New Sorema","R54861","R54861","R55765","R55765/1","R54861/CL","026/02EL","PA12","4028,5","6X13","7,89","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",20,20,20,10,"R55765/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"6,9 Ω",20%,"4,5","9,3",,,, +102,"x","x","x","Himoinsa","R54915","R54915","R55685","R55685/1","R54915/CL","026/02EL","PA12",915,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55685/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"PRT",,,"X","Da completare con adattatori RS0634 (1x), montati ","7,2 Ω",10%,"4,3","9,5",,,, +103,"x","x","x","Himoinsa","R54916","R54916","R55686","R55686/1","R54916/CL","TGAI15EL","EPDM",1965,"4X13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55686/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"PRT",,,,,"4,4 Ω",20%,"2,2","4,6","4,5",,,11/11/2022 +83,"x",,,"Deutz","R55144","R55144","R55772","R55772/1","R55144/CL","026/02EL","PA12",2025,"6x13","9,49","90°","7,89","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55772/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",50 pz/anno,,,,"10,9 Ω",10%,"8,6","18,1",,,, +84,"x",,,"Deutz","R55145","R55145","R55773","R55773/1","R55145/CL","026/02EL","PA12",2025,"6x13","9,49","90°","9,49","90°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55773/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",50 pz/anno,,,,"10,9 Ω",10%,"8,6","18,1",,,, +77,"x",,,"Avoni","R55177","R55177","R55176","R55176/1","---","TGAI15EL","EPDM",1500,"4x13","7,89","90°","6,30","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,20,"R55176/1-{N11}","x","ETA013L.prn","ETACL.prn","",12 V,"SI",,,,,"5,2 Ω",20%,"2,8","6,0",,,, +104,"x","x","x","Himoinsa","R55192","R55192","R55687","R55687/1","R55192/CL","026/02EL","PA12",850,"6X13","9,49","90°","9,49","90°","CE0025","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",10,10,10,10,"R55687/1-{N11}","x","ETA013L.prn","ETACL.prn","Img-01",12 V,"PRT",,,"X","Da completare con adattatori RS0634, montati","10,2 Ω",10%,"4,6","10,1",,,, +131,"x",,,"Deutz","R55204","R55204","R55774","R55774/1","R55204/CL","026/02EL","PA12",1537,"6x13","7,89","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55774/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"14,3 Ω",10%,"11,1","23,5",,,, +132,"x",,,"Deutz","R55205","R55205","R55775","R55775/1","R55205/CL","026/02EL","PA12",1537,"6x13","9,49","90°","9,49","0°","CE0064","HDSCS: 3-1418483-1",,"SCR8",10,10,10,10,"R55775/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"14,3 Ω",10%,"11,1","23,5",,,, +133,"x",,,"Deutz","R55206","R55206","R55776","R55776/1","---","026/02EL","PA12",3058,"6x13","7,89","0°","7,89","0°","CE0065","HDSCS: 4-1418483-1",,"SCR9",10,10,10,10,"R55776/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"PRT",,,,,"7,2 Ω",10%,"5,9","12,2",,,, +153,"x",,,"Kaha","R55320","R55320","R55769","R55769/1","R55320/CL","026/02EL","PA12",3000,"6x13","7,89","0°","6,30","90°","CE0077/N","DEUTSCH DT: DT04-2P-C015","W2P","SCR2",20,20,20,10,"R55769/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"7,4 Ω",20%,"6,0","12,4",,,, +161,"x","x","x","Euromach","TUB0500400","R54235","R55747","R55747/1","R54235/CL","026/02EL","PA12",2300,"6x13","7,89","0°","7,89","90°","CE0053","HDSCS: 4-1418483-1",,"SCR9",10,10,10,10,"R55747/1-{N11}","x","ETA013L.prn","ETACL.prn","",24 V,"SI",,,,,"8,1 Ω",10%,"7,7","16,0",,,, +20,,,,"Argo Tractors",,,,"R53861",,"TGAI15EL","EPDM",850,"4x13","7,89","90°","6,30","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"6,4 Ω",,"4,6","10,1",,,, +21,,,,"Argo Tractors",,,,"R53847",,"TGAI15EL","EPDM",2050,"4x13","7,89","90°","6,30","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"3,5 Ω",,"2,1","4,5",,,, +22,,,,"Argo Tractors",,,,"R53848",,"026/02EL","PA12",500,"6X13","9,49","90°","9,49","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"9,0 Ω",,"6,9","16,0",,,, +23,,,,"Argo Tractors",,,,"R53849",,"026/02EL","PA12",550,"6X13","9,49","90°","7,89","90°","CE0025",,,,,,,,,,,,,12 V,,,,,,"9,7 Ω",,"6,4","14,8",,,, diff --git a/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.xlsx b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.xlsx new file mode 100644 index 0000000..0907249 Binary files /dev/null and b/src/test/csv_import/Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.xlsx differ diff --git a/src/test/csv_import/test.py b/src/test/csv_import/test.py new file mode 100644 index 0000000..cf35294 --- /dev/null +++ b/src/test/csv_import/test.py @@ -0,0 +1,12 @@ +import csv +import itertools + +# DOES NOT WORK +def lower_first(iterator): + return itertools.chain([next(iterator).lower()], iterator) + +with open("Tabella Tubi riscaldati - COMPLETA rev19_29-12-2022.csv", 'rU') as datafile: + csvDict = csv.DictReader(lower_first(datafile)) + for ucrow in csvDict: + row = dict((k.lower(), v) for k, v in ucrow.items()) # WORKS + print(row) \ No newline at end of file diff --git a/src/test/test_usb586x.py b/src/test/test_usb586x.py new file mode 100644 index 0000000..283c54a --- /dev/null +++ b/src/test/test_usb586x.py @@ -0,0 +1,32 @@ +import sys +import time + +from src.components.usb_586x import USB_586x + +class config: + id = None + updated= None + +if "--5862" in sys.argv: + config.id = "USB-5860,BID#0" + out_size = 16 +else: + config.id = "USB-5860,BID#0" + out_size = 8 + +digital_io = USB_586x(config) +digital_io.start() + +out_num = 0 +while True: + out_bit = out_num % 8 + out_byte = int(out_num/8) + res = digital_io.set_bit(out_byte, out_bit, 1) + time.sleep(0.5) + res2 = digital_io.set_bit(out_byte, out_bit, 0) + input_data = digital_io.get() + print("in:{} out:{}".format(bytes(input_data[0]), out_num)) + time.sleep(0.5) + out_num += 1 + if out_num == out_size: + out_num = 0 \ No newline at end of file diff --git a/src/ui/count_step_editor/count_step_editor.py b/src/ui/count_step_editor/count_step_editor.py index d2410c3..f82bd21 100644 --- a/src/ui/count_step_editor/count_step_editor.py +++ b/src/ui/count_step_editor/count_step_editor.py @@ -6,4 +6,5 @@ class Count_Step_Editor(Editor): super().__init__(action=action, cell_widget=cell_widget) self.spec.update({ "amount": self.amount_sb, + "warning_img": self.warning_img_le }) diff --git a/src/ui/count_step_editor/count_step_editor.ui b/src/ui/count_step_editor/count_step_editor.ui index d78feb4..755b7c4 100644 --- a/src/ui/count_step_editor/count_step_editor.ui +++ b/src/ui/count_step_editor/count_step_editor.ui @@ -6,27 +6,15 @@ 0 0 - 138 - 68 + 692 + 202 Count Step Editor - - 0 - - - 0 - - - 0 - - - 0 - - + @@ -39,6 +27,13 @@ Lotto + + + + 9999 + + + @@ -46,13 +41,32 @@ - - - - 9999 + + + + + + + + 10 + 50 + false + + + + Istruzioni operative + + + + + + Immagine warning + + + diff --git a/src/ui/imgs/assembly_1.jpg b/src/ui/imgs/assembly_1.jpg deleted file mode 100755 index 2c8777a..0000000 Binary files a/src/ui/imgs/assembly_1.jpg and /dev/null differ diff --git a/src/ui/imgs/autotest_nok.png b/src/ui/imgs/autotest_nok.png deleted file mode 100755 index 86bf190..0000000 Binary files a/src/ui/imgs/autotest_nok.png and /dev/null differ diff --git a/src/ui/imgs/autotest_ok.png b/src/ui/imgs/autotest_ok.png deleted file mode 100755 index 4681a06..0000000 Binary files a/src/ui/imgs/autotest_ok.png and /dev/null differ diff --git a/src/ui/leak_step_editor/leak_step_editor.ui b/src/ui/leak_step_editor/leak_step_editor.ui index beb78ae..ab4b360 100644 --- a/src/ui/leak_step_editor/leak_step_editor.ui +++ b/src/ui/leak_step_editor/leak_step_editor.ui @@ -6,27 +6,15 @@ 0 0 - 955 - 161 + 1375 + 252 Leak Step Editor - - 0 - - - 0 - - - 0 - - - 0 - - + @@ -39,13 +27,6 @@ Pre-Riempimento - - - - 9999 - - - @@ -81,10 +62,117 @@ + + + + 9999 + + + - + + + + + 10 + 50 + false + + + + Riempimento + + + + + + PR+ Pressione Max + + + + + + + T1: Riempimento + + + + + + + s + + + + + + + 150 + + + + + + + 9999 + + + + + + + PR- Pressione Min + + + + + + + 100 + + + + + + + % + + + + + + + % + + + + + + + T2: Assestamento + + + + + + + 9999 + + + + + + + s + + + + + + + @@ -187,107 +275,7 @@ - - - - - 10 - 50 - false - - - - Riempimento - - - - - - PR+ Pressione Max - - - - - - - T1: Riempimento - - - - - - - s - - - - - - - 150 - - - - - - - 9999 - - - - - - - PR- Pressione Min - - - - - - - 100 - - - - - - - % - - - - - - - % - - - - - - - T2: Assestamento - - - - - - - 9999 - - - - - - - s - - - - - - - + @@ -345,6 +333,42 @@ + + + + + 10 + 50 + false + + + + Elettrovalvole + + + + + + + 50 + 16777215 + + + + 9999 + + + + + + + Configurazione relè + + + + + + diff --git a/src/ui/recipe_selection/recipe_selection.py b/src/ui/recipe_selection/recipe_selection.py index 203dbe0..480fa09 100755 --- a/src/ui/recipe_selection/recipe_selection.py +++ b/src/ui/recipe_selection/recipe_selection.py @@ -1,5 +1,6 @@ import csv import itertools +import locale import os import re import sys @@ -172,13 +173,25 @@ class Recipe_Selection(Widget): global noner defaults = self.config.get("recipes_defaults", noner) barcode_serial_field = self.config.get("recipe", {}).get("barcode_serial_field", "codice_a_barre").strip() - rcsv = row.get("r nominale", defaults["r nominale"]).replace(" ", "").replace(",", ".").replace("Ω", "").replace("?", "") + decsep= locale.localeconv()["decimal_point"] + rcsv = row.get("r nominale", defaults["r nominale"]).replace(" ", "").replace(",", decsep).replace("Ω", "").replace("?", "") if rcsv == "": rcsv = "999" + trp=row.get("tolleranza_resistenza_pos", defaults["tolleranza_resistenza_pos"]) + if trp == "": + trp = defaults["tolleranza_resistenza_pos"] + trn=row.get("tolleranza_resistenza_neg", defaults["tolleranza_resistenza_neg"]) + if trn == "": + trn = defaults["tolleranza_resistenza_neg"] + tass=row.get("tempo_assestamento", defaults["tempo_assestamento"]) + if tass == "": + tass = defaults["tempo_assestamento"] + wimg=row.get("immagine_warning", "") print_template_field = self.config.get("recipe", {}).get("label_template_field", "modello_etichetta").strip() return { "count": { "amount": row.get("dimensione_lotto", defaults["dimensione_lotto"]), + "warning_img": wimg, }, "connector": { "connector": row.get("connettore", defaults["connettore"]), @@ -189,8 +202,8 @@ class Recipe_Selection(Widget): "resistance": { "scale": float(row.get("scala_resistenza", defaults["scala_resistenza"])), "expected": float(rcsv), - "tolerance_pos": float(row.get("tolleranza_resistenza_pos", defaults["tolleranza_resistenza_pos"])), - "tolerance_neg": float(row.get("tolleranza_resistenza_neg", defaults["tolleranza_resistenza_neg"])), + "tolerance_pos": float(trp), + "tolerance_neg": float(trn), }, "screws": { "quantity": row.get("viti", defaults["viti"]) @@ -199,7 +212,7 @@ class Recipe_Selection(Widget): "pre_filling_time": int(row.get("tempo_pre_riempimento", defaults["tempo_pre_riempimento"])), "pre_filling_pressure": int(row.get("pressione_pre_riempimento", defaults["pressione_pre_riempimento"])), "filling_time": int(row.get("tempo_riempimento", defaults["tempo_riempimento"])), - "settling_time": int(row.get("tempo_assestamento", defaults["tempo_assestamento"])), + "settling_time": int(tass), "settling_pressure_min_percent": int(row.get("percentuale_minima_pressione_assestamento", defaults["percentuale_minima_pressione_assestamento"])), "settling_pressure_max_percent": int(row.get("percentuale_massima_pressione_assestamento", defaults["percentuale_massima_pressione_assestamento"])), "test_time": int(row.get("tempo_di_test", defaults["tempo_di_test"])), @@ -251,13 +264,12 @@ class Recipe_Selection(Widget): description_field = self.config.get("recipe", {}).get("description_field", "descrizione").strip() barcode_enable_field = self.config.get("recipe", {}).get("barcode_enable_field", "verifica_codice_a_barre_abilitata").strip() - def lower_first(iterator): - return itertools.chain([next(iterator).lower()], iterator) with open(csv_path, "r") as f: - reader = csv.DictReader(lower_first(f)) + reader = csv.DictReader(f) count = 0 - for row in reader: + for ucrow in reader: + row= dict((k.lower(), v) for k, v in ucrow.items()) recipe_name = row.get(recipe_name_field, defaults["codice_ricetta"]) steps_specs = self.read_steps(row, defaults=defaults) try: diff --git a/src/ui/test/test.py b/src/ui/test/test.py index b0f8dad..13432a5 100755 --- a/src/ui/test/test.py +++ b/src/ui/test/test.py @@ -16,6 +16,7 @@ from ui.test_barcodes import Test_Barcodes from ui.test_connector import Test_Connector from ui.test_count import Test_Count from ui.test_count_end import Test_Count_End +from ui.test_warning_img import Test_Warning_Img from ui.test_fail import Test_Fail from ui.test_leak import Test_Leak from ui.test_resistance import Test_Resistance @@ -74,6 +75,7 @@ class Test(Widget): "barcodes": Test_Assembly(img_path=self.select_step_img("scan"), text=u"LEGGERE IL BARCODE DEL PEZZO DA COLLAUDARE", widget=Test_Barcodes()), "connector": Test_Assembly(img_path=self.select_step_img("scan"), text=u"COLLEGARE IL CONNETTORE INDICATO AL PEZZO E LEGGERE IL SUO BARCODE", widget=Test_Connector(run_once=True)), "count": Test_Assembly(img_path=None, text=u"INSERIRE IL NUMERO DI PEZZI ATTESI PER IL LOTTO", widget=Test_Count(components=self.components, recipe=self.recipe, step=self.step, pieces=self.pieces, run_once=True)), + "warning_img": Test_Assembly(img_path=None, text=u"ATTENZIONE - PER QUESTO CODICE ESEGUIRE LE OPERAZIONI INDICATE IN FIGURA", widget=Test_Warning_Img(components=self.components, recipe=self.recipe, step=self.step)), "count_end": Test_Assembly(img_path=None, text=u"LOTTO TERMINATO, PREMERE CONTINUA PERCOMINCIARNE UNO NUOVO", widget=Test_Count_End(components=self.components, recipe=self.recipe, step=self.step, pieces=self.pieces)), "done": Test_Assembly(img_path=self.select_step_img("success"), text=u"COLLAUDO COMPLETATO", widget=None), "emergency": Test_Assembly(img_path=self.select_step_img("reset_emergency"), text=u"EMERGENZA INTERVENUTA - RIPRISTINARE PULSANTE E SELEZIONARE \"RESET EMERGENZA\" DAL MEN\u00d9 \"STRUMENTI\"", widget=None), @@ -96,7 +98,8 @@ class Test(Widget): self.autotest_cycle_steps = None if "--no-autotest" not in sys.argv: self.autotest_period = 12 * 60 * 60 * 1000 - self.request_autotest("init") + if not self.config["autotest_done"]: + self.request_autotest("init") else: self.autotest_period = None # INIT TEST DATA @@ -223,6 +226,7 @@ class Test(Widget): self.autotesting = False self.autotesting_reason = None self.cycle_index = -1 + self.config["autotest_done"] = True if not self.autotesting: if len(self.cycle_steps): # goto next step in cycle_steps @@ -284,6 +288,9 @@ class Test(Widget): continue if step.type == "count": count_found = True + if step.spec["warning_img"]: + steps.insert(i,Steps(type="warning_img", spec={"warning_img":step.spec["warning_img"]})) + skip.add(i + 1) if step.type == "resistance": steps.insert(i + 1, Steps(type="resistance", spec={ "scale": 500, diff --git a/src/ui/test_leak/test_leak.py b/src/ui/test_leak/test_leak.py index c783554..1ec9244 100644 --- a/src/ui/test_leak/test_leak.py +++ b/src/ui/test_leak/test_leak.py @@ -5,7 +5,7 @@ from ui.test_test import Test_Test class Test_Leak(Test_Test): - def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=False): + def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=True): super().__init__(components=components, recipe=recipe, step=step, pieces=pieces, run_once=run_once, reset_on_start=reset_on_start, enable_override=enable_override) self.start_b.clicked.connect(lambda checked, self=weakref.ref(self): self().components["tecna_t3"].start_test()) self.stop_b.clicked.connect(lambda checked, self=weakref.ref(self): self().components["tecna_t3"].stop_test()) diff --git a/src/ui/test_resistance/test_resistance.py b/src/ui/test_resistance/test_resistance.py index 13a58e0..88f2d53 100644 --- a/src/ui/test_resistance/test_resistance.py +++ b/src/ui/test_resistance/test_resistance.py @@ -5,7 +5,7 @@ from ui.test_test import Test_Test class Test_Resistance(Test_Test): - def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=False): + def __init__(self, components=None, recipe=None, step=None, pieces=None, run_once=False, reset_on_start=True, enable_override=True): super().__init__(components=components, recipe=recipe, step=step, pieces=pieces, run_once=run_once, reset_on_start=reset_on_start, enable_override=enable_override) self.ok_counter_limit = 3 @@ -133,7 +133,7 @@ class Test_Resistance(Test_Test): i = ok p = ok if i is None and r != 1e9: - i = False + i = "wait" if p is None: if r == 1e9: p = "warning" diff --git a/src/ui/test_test/test_test.py b/src/ui/test_test/test_test.py index 5fba40d..34413bd 100644 --- a/src/ui/test_test/test_test.py +++ b/src/ui/test_test/test_test.py @@ -57,6 +57,7 @@ class Test_Test(Widget): True: QPixmap("src/ui/imgs/success.png"), "": QPixmap("src/ui/imgs/neo.ico"), "warning": QPixmap("src/ui/imgs/warning.png"), + "wait": QPixmap("src/ui/imgs/wait.png"), False: QPixmap("src/ui/imgs/fail.png"), None: QPixmap("src/ui/imgs/wait.png"), } diff --git a/src/ui/test_warning_img/__init__.py b/src/ui/test_warning_img/__init__.py new file mode 100644 index 0000000..1366494 --- /dev/null +++ b/src/ui/test_warning_img/__init__.py @@ -0,0 +1 @@ +from .test_warning_img import Test_Warning_Img diff --git a/src/ui/test_warning_img/test_warning_img.py b/src/ui/test_warning_img/test_warning_img.py new file mode 100644 index 0000000..498e191 --- /dev/null +++ b/src/ui/test_warning_img/test_warning_img.py @@ -0,0 +1,33 @@ +import sys +import weakref + +from PyQt5.QtCore import Qt + +from lib.helpers import timing +from PyQt5.QtCore import QTimer +from PyQt5.QtGui import QKeySequence, QPixmap +from PyQt5.QtWidgets import QShortcut +from ui.test_test import Test_Test + + +class Test_Warning_Img(Test_Test): + def __init__(self, components=None, recipe=None, step=None, run_once=False, reset_on_start=False, enable_override=False,bench_name="generic"): + super().__init__(components=components, recipe=recipe, step=step, run_once=run_once, reset_on_start=reset_on_start, enable_override=enable_override) + self.bench_name = bench_name + + def start(self, recipe=None, step=None, pieces=None): + show = super().start(recipe=recipe, step=step) + + if step is not None: + img_path=f"config/instruction_images/{self.bench_name}/{step.spec['warning_img']}.png" + self.continue_b.clicked.connect(lambda checked, self=weakref.ref(self): self().ok.emit(None)) + self.img = QPixmap(str(img_path)) + self.img_l.setPixmap(self.img) + + return show + + # def stop(self): + # super().stop() + + def reset(self): + super().reset() diff --git a/src/ui/test_warning_img/test_warning_img.ui b/src/ui/test_warning_img/test_warning_img.ui new file mode 100644 index 0000000..bd12770 --- /dev/null +++ b/src/ui/test_warning_img/test_warning_img.ui @@ -0,0 +1,110 @@ + + + Test_Warning_Img + + + + 0 + 0 + 839 + 746 + + + + Test Count End + + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + 0 + 0 + + + + + 20 + 75 + true + + + + Istruzione operativa + + + + + + + 20 + 75 + true + + + + background-color:rgb(85, 255, 127); + + + ok + + + + + + + + 0 + 0 + + + + + 800 + 600 + + + + Immagine istruzione + + + Qt::AlignCenter + + + + + + + + + + + 0 + 0 + + + + FORZA ACCETTAZIONE + + + + + + + override_b + + + +