Merge branch 'developer' into gotthard2

python/CMakeLists.txt

@@ -32,6 +32,7 @@ set( PYTHON_FILES
     jungfrau.py
     mythen3.py
     registers.py
+    lookup.py
     utils.py
 
 )

python/scripts/basic.py

@@ -4,12 +4,12 @@ import numpy as np
 sys.path.append(os.path.join(os.getcwd(), 'bin'))
 
 from sls_detector import Detector, Mythen3, Eiger, Jungfrau, DetectorDacs, Dac, Ctb
-from sls_detector import dacIndex
+from sls_detector import dacIndex, readoutMode
-
+from sls_detector.lookup import view, find
 
 d = Detector()
 # e = Eiger()
-# c = Ctb()
+c = Ctb()
 # j = Jungfrau()
-m = Mythen3()
+# m = Mythen3()
 

python/sls_detector/__init__.py

@@ -17,6 +17,7 @@ timingMode = _sls_detector.slsDetectorDefs.timingMode
 dacIndex = _sls_detector.slsDetectorDefs.dacIndex
 detectorType = _sls_detector.slsDetectorDefs.detectorType
 detectorSettings = _sls_detector.slsDetectorDefs.detectorSettings
+readoutMode = _sls_detector.slsDetectorDefs.readoutMode
 
 IpAddr = _sls_detector.IpAddr
 MacAddr = _sls_detector.MacAddr

python/sls_detector/ctb.py

@@ -41,81 +41,3 @@ class Ctb(Detector):
     def dacs(self):
         return self._dacs
 
-    @property
-    @element
-    def v_a(self):
-        return self.getDAC(dacIndex.V_POWER_A, True)
-
-    @v_a.setter
-    def v_a(self, value):
-        self.setDAC(dacIndex.V_POWER_A, value, True)
-
-    @property
-    @element
-    def v_b(self):
-        return self.getDAC(dacIndex.V_POWER_B, True)
-
-    @v_b.setter
-    def v_b(self, value):
-        self.setDAC(dacIndex.V_POWER_B, value, True)
-
-    @property
-    @element
-    def v_c(self):
-        return self.getDAC(dacIndex.V_POWER_C, True)
-
-    @v_c.setter
-    def v_c(self, value):
-        self.setDAC(dacIndex.V_POWER_C, value, True)
-
-    @property
-    @element
-    def v_d(self):
-        return self.getDAC(dacIndex.V_POWER_D, True)
-
-    @v_d.setter
-    def v_d(self, value):
-        self.setDAC(dacIndex.V_POWER_D, value, True)
-
-    @property
-    @element
-    def v_io(self):
-        return self.getDAC(dacIndex.V_POWER_IO, True)
-
-    @v_io.setter
-    def v_io(self, value):
-        self.setDAC(dacIndex.V_POWER_IO, value, True)
-
-    @property
-    @element
-    def v_limit(self):
-        return self.getDAC(dacIndex.V_LIMIT, True)
-
-    @v_limit.setter
-    def v_limit(self, value):
-        self.setDAC(dacIndex.V_LIMIT, value, True)
-
-    @property
-    @element
-    def im_a(self):
-        return self.getMeasuredCurrent(dacIndex.I_POWER_A)
-
-    @property
-    @element
-    def im_b(self):
-        return self.getMeasuredCurrent(dacIndex.I_POWER_B)
-
-    @property
-    @element
-    def im_c(self):
-        return self.getMeasuredCurrent(dacIndex.I_POWER_C)
-
-    @property
-    @element
-    def im_d(self):
-        return self.getMeasuredCurrent(dacIndex.I_POWER_D)
-
-    @property
-    @element
-    def im_io(self):
-        return self.getMeasuredCurrent(dacIndex.I_POWER_IO)

python/sls_detector/detector.py

@@ -6,28 +6,13 @@ speedLevel = slsDetectorDefs.speedLevel
 dacIndex = slsDetectorDefs.dacIndex
 
 from .utils import element_if_equal, all_equal, get_set_bits, list_to_bitmask
-from .utils import Geometry, to_geo
+from .utils import Geometry, to_geo, element
 from .registers import Register, Adc_register
 import datetime as dt
 
 from functools import wraps
 from collections import namedtuple
 
-# class Register:
-#     """
-#     Helper class to read and write to registers using a
-#     more Pythonic syntax
-#     """
-#     def __init__(self, detector):
-#         self._detector = detector
-
-#     def __getitem__(self, key):
-#         return self._detector.readRegister(key)
-
-#     def __setitem__(self, key, value):
-#         self._detector.writeRegister(key, value)
-
-
 def freeze(cls):
     cls._frozen = False
 
@@ -774,6 +759,22 @@ class Detector(CppDetectorApi):
     CTB stuff 
     """
 
+    @property
+    def runclk(self):
+        return element_if_equal(self.getRUNClock())
+
+    @runclk.setter
+    def runclk(self, freq):
+        self.setRUNClock(freq)
+
+    @property
+    def romode(self):
+        return element_if_equal(self.getReadoutMode())
+
+    @romode.setter
+    def romode(self, mode):
+        self.setReadoutMode(mode)
+
     @property
     def asamples(self):
         return element_if_equal(self.getNumberOfAnalogSamples())
@@ -839,9 +840,249 @@ class Detector(CppDetectorApi):
         return element_if_equal(self.getMaxADCPhaseShift())
 
     @property
-    def maxclkphaseshift(self):
+    def adcphase(self):
-        return element_if_equal(self.getMaxClockPhaseShift())
+        return element_if_equal(self.getADCPhase())
+    
+    @adcphase.setter
+    def adcphase(self, value):
+        self.setADCPhase(value)
 
     @property
-    def adcphase(self):
+    def adcpipeline(self):
-        return element_if_equal()
+        return element_if_equal(self.getADCPipeline())
+
+    @adcpipeline.setter
+    def adcpipeline(self, value):
+        self.setADCPipeline(value)
+
+    @property
+    def adcclk(self):
+        return element_if_equal(self.getADCClock())
+
+    @adcclk.setter
+    def adcclk(self, value):
+        self.setADCClock(value)
+
+    @property
+    def syncclk(self):
+        return element_if_equal(self.getSYNCClock())
+    
+    @property
+    def pattern(self):
+        #TODO! Clean fix
+        print("Set only")
+        return 0
+
+    @property
+    def patclkctrl(self):
+        return element_if_equal(self.getPatternClockControl())
+
+    @patclkctrl.setter
+    def patclkctrl(self, mask):
+        self.setPatternClockControl(mask)
+
+    # patioctrl
+    @property
+    def patioctrl(self):
+        return element_if_equal(self.getPatternIOControl())
+
+    @patioctrl.setter
+    def patioctrl(self, mask):
+        self.setPatternIOControl(mask)
+
+    @property
+    def patlimits(self):
+        return element_if_equal(self.getPatternLoopAddresses(-1))
+
+    @patlimits.setter
+    def patlimits(self, lim):
+        self.setPatternLoopAddresses(-1, lim[0], lim[1])
+
+    @property
+    def patmask(self):
+        return element_if_equal(self.getPatternMask())
+
+    @patmask.setter
+    def patmask(self, mask):
+        self.setPatternMask(mask)
+
+    @pattern.setter
+    def pattern(self, fname):
+        self.setPattern(fname)
+
+    @property
+    def patwait0(self):
+        return element_if_equal(self.getPatternWaitAddr(0))
+
+    @patwait0.setter
+    def patwait0(self, addr):
+        self.setPatternWaitAddr(0, addr)
+
+    @property
+    def patwait1(self):
+        return element_if_equal(self.getPatternWaitAddr(1))
+
+    @patwait1.setter
+    def patwait1(self, addr):
+        self.setPatternWaitAddr(1, addr)
+
+    @property
+    def patwait2(self):
+        return element_if_equal(self.getPatternWaitAddr(2))
+
+    @patwait2.setter
+    def patwait2(self, addr):
+        self.setPatternWaitAddr(2, addr)
+
+    @property
+    def patwaittime0(self):
+        return element_if_equal(self.getPatternWaitTime(0))
+
+    @patwaittime0.setter
+    def patwaittime0(self, nclk):
+        self.setPatternWaitTime(0, nclk)
+
+    @property
+    def patwaittime1(self):
+        return element_if_equal(self.getPatternWaitTime(1))
+
+    @patwaittime1.setter
+    def patwaittime1(self, nclk):
+        self.setPatternWaitTime(1, nclk)
+
+    @property
+    def patwaittime2(self):
+        return element_if_equal(self.getPatternWaitTime(2))
+
+    @patwaittime2.setter
+    def patwaittime2(self, nclk):
+        self.setPatternWaitTime(2, nclk)
+
+
+    @property
+    def patloop0(self):
+        return element_if_equal(self.getPatternLoopAddresses(0))
+
+    @patloop0.setter
+    def patloop0(self, addr):
+        self.setPatternLoopAddresses(0, addr[0], addr[1])
+
+    @property
+    def patloop1(self):
+        return element_if_equal(self.getPatternLoopAddresses(1))
+
+    @patloop1.setter
+    def patloop1(self, addr):
+        self.setPatternLoopAddresses(1, addr[0], addr[1])
+
+    @property
+    def patloop2(self):
+        return element_if_equal(self.getPatternLoopAddresses(2))
+
+    @patloop2.setter
+    def patloop2(self, addr):
+        self.setPatternLoopAddresses(2, addr[0], addr[1])
+
+    @property
+    def patnloop0(self):
+        return element_if_equal(self.getPatternLoopCycles(0))
+
+    @patnloop0.setter
+    def patnloop0(self, n):
+        self.setPatternLoopCycles(0, n)
+
+    @property
+    def patnloop1(self):
+        return element_if_equal(self.getPatternLoopCycles(1))
+
+    @patnloop1.setter
+    def patnloop1(self, n):
+        self.setPatternLoopCycles(1, n)
+
+    @property
+    def patnloop2(self):
+        return element_if_equal(self.getPatternLoopCycles(2))
+
+    @patnloop2.setter
+    def patnloop2(self, n):
+        self.setPatternLoopCycles(2, n)
+
+
+    @property
+    @element
+    def v_a(self):
+        return self.getDAC(dacIndex.V_POWER_A, True)
+
+    @v_a.setter
+    def v_a(self, value):
+        self.setDAC(dacIndex.V_POWER_A, value, True)
+
+    @property
+    @element
+    def v_b(self):
+        return self.getDAC(dacIndex.V_POWER_B, True)
+
+    @v_b.setter
+    def v_b(self, value):
+        self.setDAC(dacIndex.V_POWER_B, value, True)
+
+    @property
+    @element
+    def v_c(self):
+        return self.getDAC(dacIndex.V_POWER_C, True)
+
+    @v_c.setter
+    def v_c(self, value):
+        self.setDAC(dacIndex.V_POWER_C, value, True)
+
+    @property
+    @element
+    def v_d(self):
+        return self.getDAC(dacIndex.V_POWER_D, True)
+
+    @v_d.setter
+    def v_d(self, value):
+        self.setDAC(dacIndex.V_POWER_D, value, True)
+
+    @property
+    @element
+    def v_io(self):
+        return self.getDAC(dacIndex.V_POWER_IO, True)
+
+    @v_io.setter
+    def v_io(self, value):
+        self.setDAC(dacIndex.V_POWER_IO, value, True)
+
+    @property
+    @element
+    def v_limit(self):
+        return self.getDAC(dacIndex.V_LIMIT, True)
+
+    @v_limit.setter
+    def v_limit(self, value):
+        self.setDAC(dacIndex.V_LIMIT, value, True)
+
+    @property
+    @element
+    def im_a(self):
+        return self.getMeasuredCurrent(dacIndex.I_POWER_A)
+
+    @property
+    @element
+    def im_b(self):
+        return self.getMeasuredCurrent(dacIndex.I_POWER_B)
+
+    @property
+    @element
+    def im_c(self):
+        return self.getMeasuredCurrent(dacIndex.I_POWER_C)
+
+    @property
+    @element
+    def im_d(self):
+        return self.getMeasuredCurrent(dacIndex.I_POWER_D)
+
+    @property
+    @element
+    def im_io(self):
+        return self.getMeasuredCurrent(dacIndex.I_POWER_IO)

python/sls_detector/lookup.py

@@ -0,0 +1,9 @@
+from .detector import Detector
+
+def view(name):
+    names =  find(name)
+    for n in names:
+        print(n)
+
+def find(name):
+    return [n for n in dir(Detector) if name in n]

python/sls_detector/utils.py

@@ -2,10 +2,13 @@
 Utility functions that are useful for testing and troubleshooting
 but not directly used in controlling the detector
 """
+
+
 from collections import namedtuple
 import _sls_detector #C++ lib
 import functools
 
+
 Geometry = namedtuple('Geometry', ['x', 'y'])
 
 def get_set_bits(mask):
@@ -65,3 +68,4 @@ def eiger_register_to_time(register):
     clocks = register >> 3
     exponent = register & 0b111
     return clocks*10**exponent / 100e6
+

slsDetectorSoftware/src/slsDetector.cpp

@@ -1793,6 +1793,7 @@ std::string slsDetector::setReceiverHostname(const std::string &receiverIP) {
 
         case MYTHEN3:
             sendNumberofCounterstoReceiver(getCounterMask());
+            setDynamicRange(shm()->dynamicRange);
             break;
 
         default:

slsSupportLib/include/sls_detector_defs.h

@@ -211,6 +211,8 @@ class slsDetectorDefs {
     struct xy {
         int x{0};
         int y{0};
+        xy() = default;
+        xy(int x, int y):x(x),y(y){};
     };
 #endif