Using define reg/bit from python (#1344)

* define_bit, define_addr in python. 
* setBit/clearBit takes int or addr

docs/CMakeLists.txt

@@ -11,7 +11,8 @@ add_executable(gendoc src/gendoc.cpp)
 # This is a bit hacky, but better than exposing stuff? 
 target_include_directories(gendoc PRIVATE ${PROJECT_SOURCE_DIR}/slsDetectorSoftware/src)
 target_link_libraries(gendoc PRIVATE
-  slsDetectorShared
+  slsDetectorStatic
+
 )
 set_target_properties(gendoc PROPERTIES 
   RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin

python/slsdet/detector.py

@@ -1814,6 +1814,109 @@ class Detector(CppDetectorApi):
         [Eiger] Address is +0x100 for only left, +0x200 for only right.
         """
         return self._register
+    
+    def define_reg(self, name, addr):
+        """
+        [Ctb] Define a name for a register to be used later with reg.
+
+        Example
+        --------
+
+        d.define_reg('myreg',addr=0x6)
+        """
+        addr = RegisterAddress(addr)
+        self.setRegisterDefinition(name, addr)
+
+
+    def define_bit(self, name, addr, bit):
+        """
+        [Ctb] Define a name for a bit in a register to be used later with setBit/clearBit/getBit
+
+        Example
+        --------
+
+        d.define_bit('mybit',addr=0x6, bit=7)
+        """
+        addr = RegisterAddress(addr)
+        bit = BitAddress(addr, bit)
+        self.setBitDefinition(name, bit)
+
+    def setBit(self, bit_or_addr, number=None):
+        """
+        Set a bit in a register
+        [Ctb] Can use a named bit address
+
+        Example
+        --------
+        d.setBit(0x5, 3)
+        
+        #Ctb
+        d.setBit('mybit')
+
+        myreg = RegisterAddress(0x5)
+        mybit = BitAddress(myreg, 5) 
+        d.setBit(mybit)
+        """
+        #Old usage passing two ints
+        if isinstance(bit_or_addr, int):
+            return super().setBit(bit_or_addr, number)
+
+        #New usage with str or BitAddress
+        if isinstance(bit_or_addr, str):
+            bit_or_addr = self.getBitDefinition(bit_or_addr)
+        return super().setBit(bit_or_addr)
+        
+    def clearBit(self, bit_or_addr, number=None):
+        """
+        Clear a bit in a register
+        [Ctb] Can use a named bit address
+
+        Example
+        --------
+        d.clearBit(0x5, 3)
+        
+        #Ctb
+        d.clearBit('mybit')
+
+        myreg = RegisterAddress(0x5)
+        mybit = BitAddress(myreg, 5) 
+        d.clearBit(mybit)
+        """
+        #Old usage passing two ints
+        if isinstance(bit_or_addr, int):
+            return super().clearBit(bit_or_addr, number)
+
+        #New usage with str or BitAddress
+        if isinstance(bit_or_addr, str):
+            bit_or_addr = self.getBitDefinition(bit_or_addr)
+        return super().clearBit(bit_or_addr)
+
+    @element
+    def getBit(self, bit_or_addr, number=None):
+        """
+        Get a bit from a register
+        [Ctb] Can use a named bit address
+
+        Example
+        --------
+        d.getBit(0x5, 3)
+        
+        #Ctb
+        d.getBit('mybit')
+
+        myreg = RegisterAddress(0x5)
+        mybit = BitAddress(myreg, 5) 
+        d.getBit(mybit)
+        """
+        #Old usage passing two ints
+        if isinstance(bit_or_addr, int):
+            return super().getBit(bit_or_addr, number)
+
+        #New usage with str or BitAddress
+        if isinstance(bit_or_addr, str):
+            bit_or_addr = self.getBitDefinition(bit_or_addr)
+        return super().getBit(bit_or_addr)     
+
 
     @property
     def slowadc(self):

python/slsdet/registers.py

@@ -1,13 +1,28 @@
 # SPDX-License-Identifier: LGPL-3.0-or-other
 # Copyright (C) 2021 Contributors to the SLS Detector Package
+
+from ._slsdet import RegisterValue, RegisterAddress
+from .utils import element
+
 class Register:
     def __init__(self, detector):
         self._detector = detector
 
+    @element
     def __getitem__(self, key):
+        if isinstance(key, str):
+            key = self._detector.getRegisterDefinition(key)
         return self._detector.readRegister(key)
 
     def __setitem__(self, key, value):
+        if isinstance(key, str):
+            key = self._detector.getRegisterDefinition(key)
+        elif isinstance(key, int):
+            key = RegisterAddress(key)
+
+        if isinstance(value, int):
+            value = RegisterValue(value)
+
         self._detector.writeRegister(key, value, False)
 
 class Adc_register:

python/tests/test_utils.py

@@ -198,79 +198,6 @@ def test_make_mac_from_tuple():
     assert make_mac(arg) == (MacAddr("84:a9:aa:24:32:88"),
                              MacAddr("84:a9:3e:24:32:aa"))
 
-def test_make_reg_addr_from_dict():
-    arg = {0: 0, 1: 0x305}
-    res = make_register_address(arg)
-    assert res == {0: RegisterAddress(0x0), 1: RegisterAddress(0x305)}
-    assert res[0].str() == "0x0"
-    assert res[1].str() == "0x305"
-
-
-def test_make_reg_addr_from_str():
-    reg_addr = "0x305"
-    assert make_register_address(reg_addr).str() == reg_addr
-
-
-def test_make_reg_addr_from_list():
-    arg = [0x305, "0x1fff1fff", 0xc34a]
-    assert make_register_address(arg) == [RegisterAddress(a) for a in arg]
-
-
-def test_make_reg_addr_from_tuple():
-    arg = ("0x340")
-    assert make_register_address(arg) == (RegisterAddress(arg))
-
-
-def test_make_reg_val_from_dict():
-    arg = {0: 0, 1: 0x305}
-    res = make_register_value(arg)
-    assert res == {0: RegisterValue(0x0), 1: RegisterValue(0x305)}
-    assert res[0].str() == "0x0"
-    assert res[1].str() == "0x305"
-
-
-def test_make_reg_val_from_str():
-    reg_val = "0x305"
-    assert make_register_value(reg_val).str() == reg_val
-
-
-def test_make_reg_val_from_list():
-    arg = [0x305, "0x1fff1fff", 0xc34a]
-    assert make_register_value(arg) == [RegisterValue(a) for a in arg]
-
-
-def test_make_reg_val_from_tuple():
-    arg = ("0x340")
-    assert make_register_value(arg) == (RegisterValue(arg))
-
-
-def test_make_bit_pos_from_dict():
-    arg = {
-        0: (RegisterAddress(0), 2), 
-        1: (RegisterAddress(0x305), 23)
-    }
-    res = make_bit_position(arg)
-    assert res == {
-        0: BitAddress(RegisterAddress("0x0"), 2), 
-        1: BitAddress(RegisterAddress("0x305"), 23)
-    }
-    assert res[0].str() == "[0x0, 2]"
-    assert res[1].str() == "[0x305, 23]"
-
-
-def test_make_bit_pos_from_list():
-    arg = [
-        (RegisterAddress(0), 2), 
-        (RegisterAddress(0x305), 23)
-    ]
-    expected = [BitAddress(*a) for a in arg]
-    assert make_bit_position(arg) == expected
-
-
-def test_make_bit_pos_from_tuple():
-    arg = (RegisterAddress(0x305), 23)
-    expected = BitAddress(*arg)
-    assert make_bit_position(arg) == expected
 
 
 def test_make_path_from_str():

slsDetectorSoftware/src/Caller.h

@@ -3,7 +3,7 @@
 #include "CmdParser.h"
 #include "HelpDacs.h"
 #include "sls/Detector.h"
-
+#include "sls/bit_utils.h"
 #include <iostream>
 #include <string>
 #include <vector>