Merge remote-tracking branch 'origin/master'

# Conflicts:
#	config/machine_settings/defaults.ini

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

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
+LAPTOP-ST64MEV3: laptop
+germano-neo: st-ten-2

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

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

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

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

config/machine_settings/this.ini

@@ -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

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 $*

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"

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)

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)

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)

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))

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))

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)

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))

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)

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))

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))
+

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))

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

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))

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))

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)

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)

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)

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)

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)

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)

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))
+

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))

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))

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

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)

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))

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))

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

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))

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

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

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))
+

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

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

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))

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)

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

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))

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))

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))

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

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

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))

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))

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

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))

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))

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))

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))

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

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
+

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

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])

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]]

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()

src/requirements.txt

@@ -10,6 +10,7 @@ pillow
 pycoral
 pymodbus
 pyqt5
+pyqt5-tools
 pyserial
 pyserial-asyncio
 requests

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",,,,

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)

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

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
         })

src/ui/count_step_editor/count_step_editor.ui

@@ -6,27 +6,15 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>138</width>
-    <height>68</height>
+    <width>692</width>
+    <height>202</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Count Step Editor</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <property name="leftMargin">
-    <number>0</number>
-   </property>
-   <property name="topMargin">
-    <number>0</number>
-   </property>
-   <property name="rightMargin">
-    <number>0</number>
-   </property>
-   <property name="bottomMargin">
-    <number>0</number>
-   </property>
-   <item row="1" column="0">
+   <item row="0" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="font">
       <font>
@@ -39,6 +27,13 @@
       <string>Lotto</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
+      <item row="1" column="1">
+       <widget class="QSpinBox" name="amount_sb">
+        <property name="maximum">
+         <number>9999</number>
+        </property>
+       </widget>
+      </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label">
         <property name="text">
@@ -46,13 +41,32 @@
         </property>
        </widget>
       </item>
-      <item row="1" column="1">
-       <widget class="QSpinBox" name="amount_sb">
-        <property name="maximum">
-         <number>9999</number>
+     </layout>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="QGroupBox" name="groupBox_6">
+     <property name="font">
+      <font>
+       <pointsize>10</pointsize>
+       <weight>50</weight>
+       <bold>false</bold>
+      </font>
+     </property>
+     <property name="title">
+      <string>Istruzioni operative</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_9">
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_32">
+        <property name="text">
+         <string>Immagine warning</string>
         </property>
        </widget>
       </item>
+      <item row="1" column="1">
+       <widget class="QLineEdit" name="warning_img_le"/>
+      </item>
      </layout>
     </widget>
    </item>

src/ui/leak_step_editor/leak_step_editor.ui

@@ -6,27 +6,15 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>955</width>
-    <height>161</height>
+    <width>1375</width>
+    <height>252</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Leak Step Editor</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
-   <property name="leftMargin">
-    <number>0</number>
-   </property>
-   <property name="topMargin">
-    <number>0</number>
-   </property>
-   <property name="rightMargin">
-    <number>0</number>
-   </property>
-   <property name="bottomMargin">
-    <number>0</number>
-   </property>
-   <item row="1" column="0">
+   <item row="0" column="1" rowspan="2">
     <widget class="QGroupBox" name="groupBox_2">
      <property name="font">
       <font>
@@ -39,13 +27,6 @@
       <string>Pre-Riempimento</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_3">
-      <item row="3" column="1">
-       <widget class="QSpinBox" name="pre_filling_pressure_sb">
-        <property name="maximum">
-         <number>9999</number>
-        </property>
-       </widget>
-      </item>
       <item row="1" column="1">
        <widget class="QSpinBox" name="pre_filling_time_sb">
         <property name="maximum">
@@ -81,10 +62,117 @@
         </property>
        </widget>
       </item>
+      <item row="3" column="1">
+       <widget class="QSpinBox" name="pre_filling_pressure_sb">
+        <property name="maximum">
+         <number>9999</number>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
-   <item row="1" column="2">
+   <item row="0" column="2" rowspan="2">
+    <widget class="QGroupBox" name="groupBox_7">
+     <property name="font">
+      <font>
+       <pointsize>10</pointsize>
+       <weight>50</weight>
+       <bold>false</bold>
+      </font>
+     </property>
+     <property name="title">
+      <string>Riempimento</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_7">
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_14">
+        <property name="text">
+         <string>PR+ Pressione Max</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_8">
+        <property name="text">
+         <string>T1: Riempimento</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="2">
+       <widget class="QLabel" name="label_20">
+        <property name="text">
+         <string>s</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QSpinBox" name="settling_pressure_min_percent_sb">
+        <property name="maximum">
+         <number>150</number>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QSpinBox" name="filling_time_sb">
+        <property name="maximum">
+         <number>9999</number>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_15">
+        <property name="text">
+         <string>PR- Pressione Min</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QSpinBox" name="settling_pressure_max_percent_sb">
+        <property name="maximum">
+         <number>100</number>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="2">
+       <widget class="QLabel" name="label_26">
+        <property name="text">
+         <string>%</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="2">
+       <widget class="QLabel" name="label_27">
+        <property name="text">
+         <string>%</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_13">
+        <property name="text">
+         <string>T2: Assestamento</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QSpinBox" name="settling_time_sb">
+        <property name="maximum">
+         <number>9999</number>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="2">
+       <widget class="QLabel" name="label_25">
+        <property name="text">
+         <string>s</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="0" column="3" rowspan="2">
     <widget class="QGroupBox" name="groupBox_3">
      <property name="font">
       <font>
@@ -187,107 +275,7 @@
      </layout>
     </widget>
    </item>
-   <item row="1" column="1">
-    <widget class="QGroupBox" name="groupBox_7">
-     <property name="font">
-      <font>
-       <pointsize>10</pointsize>
-       <weight>50</weight>
-       <bold>false</bold>
-      </font>
-     </property>
-     <property name="title">
-      <string>Riempimento</string>
-     </property>
-     <layout class="QGridLayout" name="gridLayout_7">
-      <item row="2" column="0">
-       <widget class="QLabel" name="label_14">
-        <property name="text">
-         <string>PR+ Pressione Max</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="0">
-       <widget class="QLabel" name="label_8">
-        <property name="text">
-         <string>T1: Riempimento</string>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="2">
-       <widget class="QLabel" name="label_20">
-        <property name="text">
-         <string>s</string>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="1">
-       <widget class="QSpinBox" name="settling_pressure_min_percent_sb">
-        <property name="maximum">
-         <number>150</number>
-        </property>
-       </widget>
-      </item>
-      <item row="0" column="1">
-       <widget class="QSpinBox" name="filling_time_sb">
-        <property name="maximum">
-         <number>9999</number>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="0">
-       <widget class="QLabel" name="label_15">
-        <property name="text">
-         <string>PR- Pressione Min</string>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="1">
-       <widget class="QSpinBox" name="settling_pressure_max_percent_sb">
-        <property name="maximum">
-         <number>100</number>
-        </property>
-       </widget>
-      </item>
-      <item row="2" column="2">
-       <widget class="QLabel" name="label_26">
-        <property name="text">
-         <string>%</string>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="2">
-       <widget class="QLabel" name="label_27">
-        <property name="text">
-         <string>%</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
-       <widget class="QLabel" name="label_13">
-        <property name="text">
-         <string>T2: Assestamento</string>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="1">
-       <widget class="QSpinBox" name="settling_time_sb">
-        <property name="maximum">
-         <number>9999</number>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="2">
-       <widget class="QLabel" name="label_25">
-        <property name="text">
-         <string>s</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item row="1" column="3">
+   <item row="0" column="4" rowspan="2">
     <widget class="QGroupBox" name="groupBox_4">
      <property name="font">
       <font>
@@ -345,6 +333,42 @@
      </layout>
     </widget>
    </item>
+   <item row="0" column="0" rowspan="2">
+    <widget class="QGroupBox" name="groupBox_5">
+     <property name="font">
+      <font>
+       <pointsize>10</pointsize>
+       <weight>50</weight>
+       <bold>false</bold>
+      </font>
+     </property>
+     <property name="title">
+      <string>Elettrovalvole</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_8">
+      <item row="1" column="1">
+       <widget class="QSpinBox" name="relay_config_sb">
+        <property name="maximumSize">
+         <size>
+          <width>50</width>
+          <height>16777215</height>
+         </size>
+        </property>
+        <property name="maximum">
+         <number>9999</number>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_29">
+        <property name="text">
+         <string>Configurazione relè</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
   </layout>
  </widget>
  <resources/>

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:

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,

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())

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"

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"),
         }

src/ui/test_warning_img/__init__.py

@@ -0,0 +1 @@
+from .test_warning_img import Test_Warning_Img

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()

src/ui/test_warning_img/test_warning_img.ui

@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Test_Warning_Img</class>
+ <widget class="QWidget" name="Test_Warning_Img">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>839</width>
+    <height>746</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Test Count End</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item row="0" column="0">
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="font">
+      <font>
+       <pointsize>20</pointsize>
+       <weight>75</weight>
+       <bold>true</bold>
+      </font>
+     </property>
+     <property name="title">
+      <string>Istruzione operativa</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="3" column="0" colspan="2">
+       <widget class="QPushButton" name="continue_b">
+        <property name="font">
+         <font>
+          <pointsize>20</pointsize>
+          <weight>75</weight>
+          <bold>true</bold>
+         </font>
+        </property>
+        <property name="styleSheet">
+         <string notr="true">background-color:rgb(85, 255, 127);</string>
+        </property>
+        <property name="text">
+         <string>ok</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="img_l">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>800</width>
+          <height>600</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>Immagine istruzione</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item row="13" column="0">
+    <widget class="QPushButton" name="override_b">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>FORZA ACCETTAZIONE</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <tabstops>
+  <tabstop>override_b</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>