wip

python/tests/test_det_api.py

@@ -406,8 +406,9 @@ def test_v_limit(session_simulator, request):
 
         # save previous value
         prev_val = d.getVoltageLimit()
-        from slsdet import dacIndex
+        from slsdet import dacIndex, powerIndex
         prev_dac_val = d.getDAC(dacIndex.DAC_0, False)
+        prev_power_dac_val = d.getPowerDAC(powerIndex.V_POWER_A)
 
         with pytest.raises(Exception):
             d.v_limit = (1200, 'mV') #mV unit not supported, should be 'no unit'
@@ -418,6 +419,7 @@ def test_v_limit(session_simulator, request):
         d.v_limit = 0
         assert d.v_limit == 0
         d.setDAC(dacIndex.DAC_0, 1200, True, [0])
+        d.setPowerDAC(powerIndex.V_POWER_A, 1200)
 
         d.v_limit = 1500
         assert d.v_limit == 1500
@@ -425,8 +427,12 @@ def test_v_limit(session_simulator, request):
         with pytest.raises(Exception):
             d.setDAC(dacIndex.DAC_0, 1501, True, [0])
 
+        with pytest.raises(Exception):
+            d.setPowerDAC(powerIndex.V_POWER_A, 1501)
+
         # restore previous value
         d.setVoltageLimit(prev_val)
+        d.setPowerDAC(powerIndex.V_POWER_A, prev_power_dac_val)
         for i in range(len(d)):
             d.setDAC(dacIndex.DAC_0, prev_dac_val[i], False, [i])
 
@@ -462,6 +468,67 @@ def test_v_abcd(session_simulator, request):
 
     Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
 
+
+
+@pytest.mark.detectorintegration
+def test_powers(session_simulator, request):
+    """Test powers."""
+    det_type, num_interfaces, num_mods, d = session_simulator
+    assert d is not None
+
+    if det_type in ['ctb', 'xilinx_ctb']:
+
+        # save previous value
+        from slsdet import powerIndex
+        prev_val_dac = d.getPowerDAC(powerIndex.V_POWER_A)
+        prev_val = d.isPowerEnabled(powerIndex.V_POWER_A)
+
+        invalid_assignments = [
+            (d.powers, "random", True), # set random power
+            (d.powers.VA, "random", True), # set random attribute of power
+            (d.powers.VA, "dac", "-100"),
+            (d.powers.VA, "dac", "-1"),
+            (d.powers.VA, "dac", "4096")
+        ]
+
+        for obj, attr, value in invalid_assignments:
+            with pytest.raises(Exception):
+                setattr(obj, attr, value)
+
+        with pytest.raises(Exception):
+            d.powers.VCHIP.dac
+
+
+        d.powers
+        d.powers.VA.dac = 1200
+        assert d.powers.VA.dac == 1200
+
+        d.powers.VA.enable = True
+        assert d.powers.VA.enable == True
+
+        d.setPowerEnabled([powerIndex.V_POWER_B, powerIndex.V_POWER_C], True)
+        assert d.powers.VB.enable == True
+        assert d.powers.VC.enable == True
+
+        d.powers.VA.dac = 1500
+        assert d.powers.VA.dac == 1500
+
+        d.powers._powernames[1] = "v_named_b"
+        assert d.powers.v_named_b.enable == True
+
+        # restore previous value
+        d.setPowerDAC(powerIndex.V_POWER_A, prev_val_dac)
+        d.setPowerEnabled(powerIndex.V_POWER_A, prev_val)
+    else:
+        with pytest.raises(Exception) as exc_info:
+            d.v_limit
+        assert "not implemented" in str(exc_info.value)
+
+    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
+
+
+
+
 '''
 @pytest.mark.detectorintegration
 def test_dac(session_simulator, request):

slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp

@@ -626,9 +626,6 @@ TEST_CASE("powerdac", "[.detectorintegration][dacs]") {
                 auto prev_val = det.getPowerDAC(indices[iPower]);
                 auto prev_val_power = det.isPowerEnabled(indices[iPower]);
 
-                // turn them off to be able to set the power dacs without issue
-                det.setPowerEnabled(std::vector{indices[iPower]}, false);
-
                 // this is the first command touching power dacs, should not be
                 // -100
                 REQUIRE(prev_val != -100);
@@ -912,6 +909,7 @@ TEST_CASE("v_limit", "[.detectorintegration]") {
         det_type == defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getVoltageLimit();
         auto prev_dac_val = det.getDAC(defs::DAC_0, false);
+        auto prev_power_dac_val  = det.getPowerDAC(defs::V_POWER_A);
 
         REQUIRE_THROWS(caller.call("v_limit", {"1200", "mV"}, -1, PUT));
         REQUIRE_THROWS(caller.call("v_limit", {"-100"}, -1, PUT));
@@ -922,14 +920,17 @@ TEST_CASE("v_limit", "[.detectorintegration]") {
             caller.call("v_limit", {}, -1, GET, oss2);
             REQUIRE(oss2.str() == "v_limit 0\n");
             REQUIRE_NOTHROW(caller.call("dac", {"0", "1200", "mV"}, -1, PUT));
+            REQUIRE_NOTHROW(caller.call("powerdac", {"v_a", "1200"}, -1, PUT));
         }
         {
             std::ostringstream oss;
             caller.call("v_limit", {"1500"}, -1, PUT, oss);
             REQUIRE(oss.str() == "v_limit 1500\n");
             REQUIRE_THROWS(caller.call("dac", {"0", "1501", "mV"}, -1, PUT));
+            REQUIRE_THROWS(caller.call("powerdac", {"v_a", "1501"}, -1, PUT));
         }
         det.setVoltageLimit(prev_val);
+        det.setPowerDAC(defs::V_POWER_A, prev_power_dac_val);
         for (int i = 0; i != det.size(); ++i) {
             det.setDAC(defs::DAC_0, prev_dac_val[i], false, {i});
         }