added master , cavity and tune device

Author: SafiullahOmar

src/dt4acc/custom_tango/ioc/devices/master_clock_device.py

@@ -95,55 +95,49 @@ def frequency(self, value: float):
     @attribute(
         name="lattice_info/ref_freq",
         dtype=float,
-        access=AttrWriteType.READ_WRITE,
+        access=AttrWriteType.READ,
         label="Lattice reference frequency",
         unit="kHz",
         format="%8.1f",
     )
     def ref_freq(self) -> float:
-        """Reference frequency - equivalent to EPICS lattice_info:ref_freq."""
+        """Reference frequency - equivalent to EPICS lattice_info:ref_freq (READ-ONLY).
+        
+        This value is automatically updated when the main frequency is changed.
+        In EPICS, this is implemented as aIn (analog input - read-only).
+        """
         return self._ref_freq
 
-    @ref_freq.write
-    def ref_freq(self, value: float):
-        """Set reference frequency."""
-        self._ref_freq = float(value)
-        logger.info(f"Updated reference frequency to {value}")
-
     @attribute(
         name="lattice_info/ref_freq/khz/up",
         dtype=int,
-        access=AttrWriteType.READ_WRITE,
+        access=AttrWriteType.READ,
         label="Lattice ref freq integer part",
         unit="kHz",
     )
     def ref_freq_khz_up(self) -> int:
-        """Reference frequency integer part - equivalent to EPICS lattice_info:ref_freq:khz:up."""
+        """Reference frequency integer part - equivalent to EPICS lattice_info:ref_freq:khz:up (READ-ONLY).
+        
+        This value is automatically updated when the main frequency is changed.
+        In EPICS, this is implemented as longIn (long integer input - read-only).
+        """
         return self._ref_freq_khz_up
 
-    @ref_freq_khz_up.write
-    def ref_freq_khz_up(self, value: int):
-        """Set reference frequency integer part."""
-        self._ref_freq_khz_up = int(value)
-        logger.info(f"Updated ref freq integer part to {value}")
-
     @attribute(
         name="lattice_info/ref_freq/khz/frac",
         dtype=int,
-        access=AttrWriteType.READ_WRITE,
+        access=AttrWriteType.READ,
         label="Lattice ref freq fractional part",
         unit="mHz",
     )
     def ref_freq_khz_frac(self) -> int:
-        """Reference frequency fractional part - equivalent to EPICS lattice_info:ref_freq:khz:frac."""
+        """Reference frequency fractional part - equivalent to EPICS lattice_info:ref_freq:khz:frac (READ-ONLY).
+        
+        This value is automatically updated when the main frequency is changed.
+        In EPICS, this is implemented as longIn (long integer input - read-only).
+        """
         return self._ref_freq_khz_frac
 
-    @ref_freq_khz_frac.write
-    def ref_freq_khz_frac(self, value: int):
-        """Set reference frequency fractional part."""
-        self._ref_freq_khz_frac = int(value)
-        logger.info(f"Updated ref freq fractional part to {value}")
-
     @command(dtype_in=None, doc_in="Reset master clock to initial values")
     def reset(self):
         """Reset master clock to initial values."""

src/dt4acc/custom_tango/ioc/devices/tune_device.py

@@ -0,0 +1,103 @@
+import numpy as np
+from tango import AttrWriteType, DevState
+from tango.server import Device, attribute, command
+
+from ....core.utils.logger import get_logger
+
+logger = get_logger()
+
+
+class TuneDevice(Device):
+    """Tango device for managing tune parameters.
+    
+    This device matches the EPICS tune PV structure exactly, providing the same
+    functionality as the EPICS SoftIOC implementation.
+    
+    Tune devices manage the betatron tune values for x and y planes and a counter.
+    
+    EPICS PVs:
+        - TUNECC:x (analog output, precision 9)
+        - TUNECC:y (analog output, precision 9)
+        - TUNECC:count (long output)
+    """
+
+    def init_device(self):
+        """Initialize the device with default values matching EPICS tune PV setup."""
+        Device.init_device(self)
+        self.set_state(DevState.ON)
+        
+        # Initialize tune data matching EPICS initialize_tune_pvs()
+        self._tune_x = 0.0
+        self._tune_y = 0.0
+        self._count = 0
+        
+        logger.info("TuneDevice initialized successfully")
+
+    @attribute(
+        name="TUNECC/x",
+        dtype=float,
+        access=AttrWriteType.READ_WRITE,
+        label="Tune X",
+        format="%12.9f",
+    )
+    def tune_x(self) -> float:
+        """Tune value for X plane - equivalent to EPICS TUNECC:x."""
+        return self._tune_x
+
+    @tune_x.write
+    def tune_x(self, value: float):
+        """Set tune X value."""
+        self._tune_x = float(value)
+        logger.info(f"Updated tune X to {value}")
+
+    @attribute(
+        name="TUNECC/y",
+        dtype=float,
+        access=AttrWriteType.READ_WRITE,
+        label="Tune Y",
+        format="%12.9f",
+    )
+    def tune_y(self) -> float:
+        """Tune value for Y plane - equivalent to EPICS TUNECC:y."""
+        return self._tune_y
+
+    @tune_y.write
+    def tune_y(self, value: float):
+        """Set tune Y value."""
+        self._tune_y = float(value)
+        logger.info(f"Updated tune Y to {value}")
+
+    @attribute(
+        name="TUNECC/count",
+        dtype=int,
+        access=AttrWriteType.READ_WRITE,
+        label="Tune count",
+    )
+    def count(self) -> int:
+        """Tune count - equivalent to EPICS TUNECC:count."""
+        return self._count
+
+    @count.write
+    def count(self, value: int):
+        """Set tune count."""
+        self._count = int(value)
+        logger.info(f"Updated tune count to {value}")
+
+    @command(dtype_in=None, doc_in="Reset tune values to defaults")
+    def reset(self):
+        """Reset tune values to defaults."""
+        self._tune_x = 0.0
+        self._tune_y = 0.0
+        self._count = 0
+        logger.info("Tune device reset to default values")
+        return "Tune device reset to default values"
+
+    @command(dtype_in=None, doc_in="Get tune information")
+    def get_tune_info(self):
+        """Get tune information."""
+        return {
+            "tune_x": self._tune_x,
+            "tune_y": self._tune_y,
+            "count": self._count
+        }
+

src/dt4acc/custom_tango/tango_device_setup.py

@@ -27,6 +27,7 @@
 from dt4acc.custom_tango.ioc.devices.cavity_device import CavityDevice
 from dt4acc.custom_tango.ioc.devices.master_clock_device import MasterClockDevice
 from dt4acc.custom_tango.ioc.devices.other_pvs_device import OtherPVsDevice
+from dt4acc.custom_tango.ioc.devices.tune_device import TuneDevice
 
 logger = get_logger()
 
@@ -216,6 +217,17 @@ def register_all_devices(server_name="SimpleTangoServer", instance_name="test"):
             except Exception as e:
                 logger.info(f"  ⚠️ Cavity device {device_name} already registered: {e}")
 
+        # Register Tune device (dedicated device for tune measurements)
+        db_device_info = DbDevInfo()
+        db_device_info._class = "TuneDevice"
+        db_device_info.server = f"{server_name}/{instance_name}"
+        db_device_info.name = f"{server_name}/{instance_name}/tune_device"
+        try:
+            db.add_device(db_device_info)
+            logger.info("  ✅ Registered Tune device")
+        except Exception as e:
+            logger.info(f"  ⚠️ Tune device already registered: {e}")
+        
         logger.info("✅ All devices registered successfully")
         print("✅ All devices registered successfully")
 
@@ -247,6 +259,7 @@ def get_all_device_classes():
             CavityDevice,  # Dedicated device for cavity management
             MasterClockDevice,  # Dedicated device for master clock management
             OtherPVsDevice,  # Dedicated device for other PVs (dummy, current)
+            TuneDevice,  # Dedicated device for tune measurements
         ])
 
         logger.info(f"✅ Collected {len(device_classes)} device classes")