bug cant read digio line with d_in_scan

pyrelacs/repros/calbi.py

@@ -19,16 +19,21 @@ class Calibration(Repos):
         time = np.arange(0, DURATION, 1 / SAMPLERATE)
         data = AMPLITUDE * np.sin(2 * np.pi * SINFREQ * time)
         # sending stimulus
+
         stim, ao_device = self.send_analog_dac(
             data, [0, 0], SAMPLERATE, ScanOption=uldaq.ScanOption.EXTTRIGGER
         )
-        read_data = self.read_analog_daq(
+        # read_data = self.read_analog_daq(
-            [0, 1], DURATION, SAMPLERATE, ScanOption=uldaq.ScanOption.EXTTRIGGER
+        #     [0, 1], DURATION, SAMPLERATE, ScanOption=uldaq.ScanOption.EXTTRIGGER
-        )
+        # )
+        data = self.read_digitalio([0, 0], DURATION, SAMPLERATE)
         self.digital_trigger()
         ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, -1)
         self.digital_trigger(data=0)
+
         self.disconnect_dac()
+        self.connect_dac()
+        self.set_analog_to_zero()
         embed()
         exit()
 
@@ -36,7 +41,7 @@ class Calibration(Repos):
 if __name__ == "__main__":
     SAMPLERATE = 40_000.0
     DURATION = 5
-    AMPLITUDE = 3
+    AMPLITUDE = 1
     SINFREQ = 1
     daq_input = Calibration()
     daq_input.run_calibration()

pyrelacs/repros/repos.py

@@ -19,6 +19,22 @@ class Repos:
             exit(1)
         self.daq_device = uldaq.DaqDevice(devices[0])
         self.daq_device.connect()
+        self.ai_device = self.daq_device.get_ai_device()
+        self.ao_device = self.daq_device.get_ao_device()
+        self.dio_device = self.daq_device.get_dio_device()
+        log.debug("Connected")
+
+    def connect_dac(self):
+        devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
+        log.debug(f"Found daq devices {len(devices)}, connecting to the first one")
+        if len(devices) == 0:
+            log.error("Did not found daq devices, please connect one")
+            exit(1)
+        self.daq_device = uldaq.DaqDevice(devices[0])
+        self.daq_device.connect()
+        self.ai_device = self.daq_device.get_ai_device()
+        self.ao_device = self.daq_device.get_ao_device()
+        self.dio_device = self.daq_device.get_dio_device()
         log.debug("Connected")
 
     def read_analog_daq(
@@ -37,11 +53,10 @@ class Repos:
             channel_len = len(channels)
         assert len(channels) == 2, log.error("Please provide a list with two ints")
 
-        ai_device = self.daq_device.get_ai_device()
         buffer_len = np.shape(np.arange(0, duration, 1 / samplerate))[0]
         data_analog_input = uldaq.create_float_buffer(channel_len, buffer_len)
 
-        er = ai_device.a_in_scan(
+        er = self.ai_device.a_in_scan(
             channels[0],
             channels[1],
             AiInputMode,
@@ -97,10 +112,8 @@ class Repos:
         data_analog_output = buffer(*data)
 
         log.debug(f"Created C_double data {data_analog_output}")
-        ao_device = self.daq_device.get_ao_device()
-        ao_info = ao_device.get_info()
 
-        err = ao_device.a_out_scan(
+        err = self.ao_device.a_out_scan(
             channels[0],
             channels[1],
             Range,
@@ -113,25 +126,65 @@ class Repos:
         log.info(f"The actual scan rate was {err}")
         # ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 11)
 
-        return data_analog_output, ao_device
+        return data_analog_output, self.ao_device
 
-    def digital_trigger(self, portn: int = 0, data: int = 1) -> None:
+    def set_analog_to_zero(self, channels: list[int] = [0, 1]):
+        err = self.ao_device.a_out_list(
+            channels[0],
+            channels[1],
+            [
+                uldaq.Range.BIP10VOLTS,
+                uldaq.Range.BIP10VOLTS,
+            ],
+            uldaq.AOutListFlag.DEFAULT,
+            [0, 0],
+        )
+
+    def digital_trigger(self, channel: int = 0, data: int = 1) -> None:
         log.info(f"{self.daq_device}")
-        dio_device = self.daq_device.get_dio_device()
 
-        dio_device.d_config_bit(
+        self.dio_device.d_config_bit(
-            uldaq.DigitalPortType.AUXPORT, portn, uldaq.DigitalDirection.OUTPUT
+            uldaq.DigitalPortType.AUXPORT, channel, uldaq.DigitalDirection.OUTPUT
+        )
+
+        self.dio_device.d_bit_out(
+            uldaq.DigitalPortType.AUXPORT, bit_number=channel, data=data
         )
 
-        dio_device.d_bit_out(uldaq.DigitalPortType.AUXPORT, bit_number=portn, data=data)
+    def read_digitalio(
+        self,
+        channels: list[int],
+        duration,
+        samplerate,
+        ScanOptions: uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO,
+        DInScanFlag: uldaq.DInScanFlag = uldaq.DInScanFlag.DEFAULT,
+    ):
+        if channels[0] == channels[1]:
+            channel_len = 1
+        else:
+            channel_len = len(channels)
+
+        buffer_len = np.shape(np.arange(0, duration, 1 / samplerate))[0]
+        data_digital_input = uldaq.create_int_buffer(channel_len, buffer_len)
+
+        self.dio_device.d_config_port(
+            uldaq.DigitalPortType.AUXPORT, uldaq.DigitalDirection.INPUT
+        )
+        scan_rate = self.dio_device.d_in_scan(
+            uldaq.DigitalPortType.AUXPORT0,
+            uldaq.DigitalPortType.AUXPORT0,
+            len(data_digital_input),
+            samplerate,
+            ScanOptions,
+            DInScanFlag,
+            data_digital_input,
+        )
+        return data_digital_input
 
     def disconnect_dac(self):
         self.daq_device.disconnect()
         self.daq_device.release()
 
-    def clean_up():
-        pass
-
     def run_repo(self) -> None:
         pass