awendt/pyrelacs
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updating output

Browse Source
This commit is contained in:
wendtalexander 2024-09-25 13:37:40 +02:00
parent 1579c947c9
commit deb60fa84c
3 changed files with 89 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
pyrelacs/repros/calbi.py
View File

@ -1,15 +1,18 @@
import ctypes import ctypes
import faulthandler
import time import time
import uldaq import uldaq
from IPython import embed from IPython import embed
from pyrelacs.repros.repos import MccDac
from pyrelacs.repros.attcs3310 import Attenuator
from pyrelacs.util.logging import config_logging
import numpy as np import numpy as np
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
from pyrelacs.repros.mccdac import MccDac
from pyrelacs.util.logging import config_logging
log = config_logging() log = config_logging()
faulthandler.enable()
class Calibration(MccDac): class Calibration(MccDac):
@ -22,7 +25,7 @@ class Calibration(MccDac):
data = AMPLITUDE * np.sin(2 * np.pi * SINFREQ * t) data = AMPLITUDE * np.sin(2 * np.pi * SINFREQ * t)
# sending stimulus # sending stimulus
stim, ao_device = self.write_analog_dac( self.write_analog(
data, [0, 0], SAMPLERATE, ScanOption=uldaq.ScanOption.EXTTRIGGER data, [0, 0], SAMPLERATE, ScanOption=uldaq.ScanOption.EXTTRIGGER
) )
@ -32,19 +35,64 @@ class Calibration(MccDac):
self.diggital_trigger() self.diggital_trigger()
try: try:
ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 15) self.ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 15)
except uldaq.ul_exception.ULException:
log.debug("Operation timed out")
# reset the diggital trigger
self.write_bit(channel=0, bit=0)
time.sleep(1)
self.set_analog_to_zero()
def check_amplitude(self):
# write to ananlog 1
t = np.arange(0, DURATION, 1 / SAMPLERATE)
data = AMPLITUDE * np.sin(2 * np.pi * SINFREQ * t)
# sending stimulus
log.debug(f"{data}, {data.shape}")
embed()
exit()
# self.set_attenuation_level(db_channel1=0.0, db_channel2=0.0)
# self.set_analog_to_zero()
# time.sleep(1)
log.debug(self.ao_device)
self.write_analog(
data,
[1, 1],
SAMPLERATE,
ScanOption=uldaq.ScanOption.EXTTRIGGER,
)
# data_channel_one = self.read_analog(
# [0, 0], DURATION, SAMPLERATE, ScanOption=uldaq.ScanOption.EXTTRIGGER
# )
log.debug(self.ao_device)
time.sleep(1)
self.diggital_trigger()
try:
self.ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 15)
self.write_bit(channel=0, bit=0)
time.sleep(1)
self.set_analog_to_zero()
except uldaq.ul_exception.ULException: except uldaq.ul_exception.ULException:
log.debug("Operation timed out") log.debug("Operation timed out")
# reset the diggital trigger # reset the diggital trigger
self.write_bit(channel=0, bit=0) self.write_bit(channel=0, bit=0)
time.sleep(1) time.sleep(1)
self.set_analog_to_zero() self.set_analog_to_zero()
self.disconnect_dac()
embed()
exit()
if __name__ == "__main__": if __name__ == "__main__":
SAMPLERATE = 40_000.0 SAMPLERATE = 40_000.0
DURATION = 10 DURATION = 5
AMPLITUDE = 1 AMPLITUDE = 1
SINFREQ = 100 SINFREQ = 10
daq_input = Calibration() daq_input = Calibration()
daq_input.run_calibration() # daq_input.check_attenuator()
daq_input.check_amplitude()

83
pyrelacs/repros/mccdac.py
View File

@ -1,6 +1,7 @@
from ctypes import Array, c_double from ctypes import Array, c_double
import time import time
from typing import Union from typing import Union
from IPython import embed from IPython import embed
import numpy.typing as npt import numpy.typing as npt
import uldaq import uldaq
@ -25,6 +26,10 @@ class MccDac:
self.dio_device = self.daq_device.get_dio_device() self.dio_device = self.daq_device.get_dio_device()
log.debug("Connected") log.debug("Connected")
# log.debug("Activate Attenuator")
# self.set_attenuation_level(db_channel1=0.0, db_channel2=0.0)
# self.set_analog_to_zero()
def connect_dac(self): def connect_dac(self):
devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB) devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
log.debug(f"Found daq devices {len(devices)}, connecting to the first one") log.debug(f"Found daq devices {len(devices)}, connecting to the first one")
@ -38,7 +43,7 @@ class MccDac:
self.dio_device = self.daq_device.get_dio_device() self.dio_device = self.daq_device.get_dio_device()
log.debug("Connected") log.debug("Connected")
def read_analog_daq( def read_analog(
self, self,
channels: list[int], channels: list[int],
duration: int, duration: int,
@ -72,7 +77,7 @@ class MccDac:
return data_analog_input return data_analog_input
def write_analog_dac( def write_analog(
self, self,
data: Union[list, npt.NDArray], data: Union[list, npt.NDArray],
channels: list[int], channels: list[int],
@ -80,45 +85,16 @@ class MccDac:
Range: uldaq.Range = uldaq.Range.BIP10VOLTS, Range: uldaq.Range = uldaq.Range.BIP10VOLTS,
ScanOption: uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO, ScanOption: uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO,
AOutScanFlag: uldaq.AOutScanFlag = uldaq.AOutScanFlag.DEFAULT, AOutScanFlag: uldaq.AOutScanFlag = uldaq.AOutScanFlag.DEFAULT,
) -> None: ):
"""
Parameters
----------
data : Union[list, npt.NDArray]
channels : list[int]
duration : int
samplerate : float
AiInputMode : uldaq.AiInputMode
Range : uldaq.Range
ScanOption : uldaq.ScanOption
AInScanFlag : uldaq.AOutScanFlag
Returns
-------
Array[c_double]
ao_device
"""
assert len(channels) == 2, log.error("You can only provide two channels [0, 1]") assert len(channels) == 2, log.error("You can only provide two channels [0, 1]")
if channels[0] != channels[1]: log.debug(f"{len(data)}, {type(data)}")
buffer_len_channels = 2
else:
buffer_len_channels = 1
buffer = c_double * (len(data) * buffer_len_channels) buffer = c_double * len(data)
data_analog_output = buffer(*data) data_analog_output = buffer(*data)
log.debug(f"Created C_double data {data_analog_output}") log.debug(f"Created C_double data {data_analog_output}")
log.info(self.ao_device)
try: try:
err = self.ao_device.a_out_scan( err = self.ao_device.a_out_scan(
channels[0], channels[0],
@ -130,6 +106,8 @@ class MccDac:
AOutScanFlag, AOutScanFlag,
data_analog_output, data_analog_output,
) )
# self.diggital_trigger()
# self.ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 11)
except Exception as e: except Exception as e:
print(f"{e}") print(f"{e}")
self.set_analog_to_zero() self.set_analog_to_zero()
@ -152,15 +130,17 @@ class MccDac:
log.error("disconnection dac") log.error("disconnection dac")
self.disconnect_dac() self.disconnect_dac()
def diggital_trigger(self) -> None: def diggital_trigger(self, channel: int = 0) -> None:
if self.read_bit(channel=1): bit_channel = self.read_bit(channel)
self.write_bit(channel=0, bit=0) if not bit_channel:
time.time_ns() self.write_bit(channel, 1)
self.write_bit(channel=0, bit=1)
else: else:
self.write_bit(channel=0, bit=1) self.write_bit(channel, 0)
time.time_ns()
self.write_bit(channel, 1)
def write_bit(self, channel: int = 0, bit: int = 1) -> None: def write_bit(self, channel: int = 0, bit: int = 1) -> None:
log.debug(self.dio_device)
self.dio_device.d_config_bit( self.dio_device.d_config_bit(
uldaq.DigitalPortType.AUXPORT, channel, uldaq.DigitalDirection.OUTPUT uldaq.DigitalPortType.AUXPORT, channel, uldaq.DigitalDirection.OUTPUT
) )
@ -169,6 +149,7 @@ class MccDac:
) )
def read_bit(self, channel: int = 0): def read_bit(self, channel: int = 0):
log.debug(self.dio_device)
bit = self.dio_device.d_bit_in(uldaq.DigitalPortType.AUXPORT, channel) bit = self.dio_device.d_bit_in(uldaq.DigitalPortType.AUXPORT, channel)
return bit return bit
@ -216,6 +197,11 @@ class MccDac:
mutepin : 7 mutepin : 7
zcenpin : -1 zcenpin : -1
""" """
SAMPLERATE = 40_000.0
DURATION = 5
AMPLITUDE = 1
SINFREQ = 1
t = np.arange(0, DURATION, 1 / SAMPLERATE) t = np.arange(0, DURATION, 1 / SAMPLERATE)
data = AMPLITUDE * np.sin(2 * np.pi * SINFREQ * t) data = AMPLITUDE * np.sin(2 * np.pi * SINFREQ * t)
data_channels = np.concatenate((data, data)) data_channels = np.concatenate((data, data))
@ -231,7 +217,7 @@ class MccDac:
else: else:
self.set_attenuation_level(db_value, db_value) self.set_attenuation_level(db_value, db_value)
self.write_analog_dac( self.write_analog(
data_channels, data_channels,
[0, 1], [0, 1],
SAMPLERATE, SAMPLERATE,
@ -307,14 +293,3 @@ class MccDac:
def deactivate_attenuator(self): def deactivate_attenuator(self):
# mute should be enabled for starting calibration # mute should be enabled for starting calibration
self.write_bit(channel=7, bit=0) self.write_bit(channel=7, bit=0)
if __name__ == "__main__":
SAMPLERATE = 40_000.0
DURATION = 5
AMPLITUDE = 1
SINFREQ = 1
att = MccDac()
# att.set_attenuation_level(db_channel1=5, db_channel2=5)
att.check_attenuator()

17
pyrelacs/repros/output.py
View File

@ -2,7 +2,7 @@ import ctypes
import uldaq import uldaq
from IPython import embed from IPython import embed
from pyrelacs.repros.repos import MccDac from pyrelacs.repros.mccdac import MccDac
from pyrelacs.util.logging import config_logging from pyrelacs.util.logging import config_logging
import numpy as np import numpy as np
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
@ -13,22 +13,13 @@ log = config_logging()
class Output_daq(MccDac): class Output_daq(MccDac):
def __init__(self) -> None: def __init__(self) -> None:
super().__init__() super().__init__()
# devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
# self.daq_device = uldaq.DaqDevice(devices[0])
# self.daq_device.connect()
def write_daq(self): def write_daq(self):
log.debug("running repro") log.debug("running repro")
time = np.arange(0, 10, 1 / 30_000.0) time = np.arange(0, 10, 1 / 30_000.0)
data = 2 * np.sin(2 * np.pi * 1 * time) data = 1 * np.sin(2 * np.pi * 1 * time)
self.send_analog_dac( self.write_analog(data, [0, 0], 30_000, ScanOption=uldaq.ScanOption.EXTTRIGGER)
data, [0, 0], 30_000, ScanOption=uldaq.ScanOption.EXTTRIGGER self.diggital_trigger()
)
def trigger(self):
self.digital_trigger(1)
self.daq_device.disconnect()
self.daq_device.release()
if __name__ == "__main__": if __name__ == "__main__":