Remove MPs that were removed by Paulus

PCC/PCC/PCC.py

@@ -87,10 +87,6 @@ class PCC(Device):
     # Attributes
     # ----------
 
-    RCU_state_R = attribute(
-        dtype = (numpy.str),
-    )
-
     RCU_mask_RW = attribute(
         dtype=(numpy.bool_,),
         max_dim_x=32,
@@ -99,29 +95,29 @@ class PCC(Device):
 
     Ant_mask_RW = attribute(
         dtype=((numpy.bool_,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
         access=AttrWriteType.READ_WRITE,
     )
 
     RCU_attenuator_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_attenuator_RW = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
         access=AttrWriteType.READ_WRITE,
     )
 
     RCU_band_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_band_RW = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
         access=AttrWriteType.READ_WRITE,
     )
 
@@ -148,32 +144,32 @@ class PCC(Device):
 
     RCU_ADC_lock_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_ADC_SYNC_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_ADC_JESD_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_ADC_CML_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_OUT1_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_OUT2_R = attribute(
         dtype=((numpy.int64,),),
-        max_dim_x=3, max_dim_y=32,
+        max_dim_x=32, max_dim_y=3,
     )
 
     RCU_ID_R = attribute(
@@ -197,18 +193,6 @@ class PCC(Device):
         access=AttrWriteType.READ_WRITE,
     )
 
-    # See https://git.astron.nl/lofar2.0/pypcc/-/issues/6
-    HBA_element_led_R = attribute(
-        dtype=((numpy.int64,),),
-        max_dim_x = 96, max_dim_y = 32,
-    )
-
-    # See https://git.astron.nl/lofar2.0/pypcc/-/issues/6
-    HBA_element_led_RW = attribute(
-        dtype=((numpy.int64,),),
-        max_dim_x = 96, max_dim_y = 32,
-        access=AttrWriteType.READ_WRITE,
-    )
     HBA_element_pwr_R = attribute(
         dtype=((numpy.int64,),),
         max_dim_x = 96, max_dim_y = 32,
@@ -220,11 +204,6 @@ class PCC(Device):
         access=AttrWriteType.READ_WRITE,
     )
 
-    uC_ID_R = attribute(
-        dtype=(numpy.int64,),
-        max_dim_x=32,
-    )
-
     RCU_monitor_rate_RW = attribute(
         dtype=numpy.float_,
         access=AttrWriteType.READ_WRITE,
@@ -254,8 +233,6 @@ class PCC(Device):
 
         self.debug_stream("Mapping OPC-UA MP/CP to attributes...")
 
-        self.attribute_mapping["RCU_state_R"] = self.get_pcc_node("RCU_state_R")
-
         self.attribute_mapping["RCU_mask_RW"] = self.get_pcc_node("RCU_mask_RW")
 
         self.attribute_mapping["Ant_mask_RW"] = self.get_pcc_node("Ant_mask_RW")
@@ -296,16 +273,10 @@ class PCC(Device):
 
         self.attribute_mapping["HBA_element_beamformer_delays_RW"] = self.get_pcc_node("HBA_element_beamformer_delays_RW")
 
-        self.attribute_mapping["HBA_element_led_R"] = self.get_pcc_node("HBA_element_led_R")
-
-        self.attribute_mapping["HBA_element_led_RW"] = self.get_pcc_node("HBA_element_led_RW")
-
         self.attribute_mapping["HBA_element_pwr_R"] = self.get_pcc_node("HBA_element_pwr_R")
 
         self.attribute_mapping["HBA_element_pwr_RW"] = self.get_pcc_node("HBA_element_pwr_RW")
 
-        self.attribute_mapping["uC_ID_R"] = self.get_pcc_node("uC_ID  _R")
-
         self.attribute_mapping["RCU_monitor_rate_RW"] = self.get_pcc_node("RCU_monitor_rate_RW")
 
         self.function_mapping["RCU_off"] = self.get_pcc_node("RCU_off")
@@ -343,28 +314,25 @@ class PCC(Device):
 
         # Set default values in the RW/R attributes and add them to
         # the mapping.
-        self._RCU_state_R = ""
-        self.attribute_mapping["RCU_state_R"] = {}
-
         self._RCU_mask_RW = numpy.full(32, False)
         self.attribute_mapping["RCU_mask_RW"] = {}
 
-        self._Ant_mask_RW = numpy.full((32, 3), False)
+        self._Ant_mask_RW = numpy.full((3, 32), False)
         self.attribute_mapping["Ant_mask_RW"] = {}
 
-        self._RCU_attenuator_R = numpy.full((32, 3), 0)
+        self._RCU_attenuator_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_attenuator_R"] = {}
 
-        self._RCU_attenuator_RW = numpy.full((32, 3), 0)
+        self._RCU_attenuator_RW = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_attenuator_RW"] = {}
 
-        self._RCU_band_R = numpy.full((32, 3), 0)
+        self._RCU_band_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_band_R"] = {}
 
-        self._RCU_band_RW = numpy.full((32, 3), 0)
+        self._RCU_band_RW = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_band_RW"] = {}
 
-        self._RCU_temperature_R = numpy.full((32, 3), 0.0)
+        self._RCU_temperature_R = numpy.full((3, 32), 0.0)
         self.attribute_mapping["RCU_temperature_R"] = {}
 
         self._RCU_Pwr_dig_R = numpy.full(32, 0)
@@ -376,22 +344,22 @@ class PCC(Device):
         self._RCU_LED0_RW = numpy.full(32, 0)
         self.attribute_mapping["RCU_LED0_RW"] = {}
 
-        self._RCU_ADC_lock_R = numpy.full((32, 3), 0)
+        self._RCU_ADC_lock_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_ADC_lock_R"] = {}
 
-        self._RCU_ADC_SYNC_R = numpy.full((32, 3), 0)
+        self._RCU_ADC_SYNC_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_ADC_SYNC_R"] = {}
 
-        self._RCU_ADC_JESD_R = numpy.full((32, 3), 0)
+        self._RCU_ADC_JESD_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_ADC_JESD_R"] = {}
 
-        self._RCU_ADC_CML_R = numpy.full((32, 3), 0)
+        self._RCU_ADC_CML_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_ADC_CML_R"] = {}
 
-        self._RCU_OUT1_R = numpy.full((32, 3), 0)
+        self._RCU_OUT1_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_OUT1_R"] = {}
 
-        self._RCU_OUT2_R = numpy.full((32, 3), 0)
+        self._RCU_OUT2_R = numpy.full((3, 32), 0)
         self.attribute_mapping["RCU_OUT2_R"] = {}
 
         self._RCU_ID_R = numpy.full(32, 0)
@@ -400,27 +368,18 @@ class PCC(Device):
         self._RCU_version_R = numpy.full(32, "1234567890")
         self.attribute_mapping["RCU_version_R"] = {}
 
-        self._HBA_element_beamformer_delays_R = numpy.full((32, 96), 0)
+        self._HBA_element_beamformer_delays_R = numpy.full((96, 32), 0)
         self.attribute_mapping["HBA_element_beamformer_delays_R"] = {}
 
-        self._HBA_element_beamformer_delays_RW = numpy.full((32, 96), 0)
+        self._HBA_element_beamformer_delays_RW = numpy.full((96, 32), 0)
         self.attribute_mapping["HBA_element_beamformer_delays_RW"] = {}
 
-        self._HBA_element_led_R = numpy.full((32, 96), 0)
-        self.attribute_mapping["HBA_element_led_R"] = {}
-
-        self._HBA_element_led_RW = numpy.full((32, 96), 0)
-        self.attribute_mapping["HBA_element_led_RW"] = {}
-
-        self._HBA_element_pwr_R = numpy.full((32, 96), 0)
+        self._HBA_element_pwr_R = numpy.full((96, 32), 0)
         self.attribute_mapping["HBA_element_pwr_R"] = {}
 
-        self._HBA_element_pwr_RW = numpy.full((32, 96), 0)
+        self._HBA_element_pwr_RW = numpy.full((96, 32), 0)
         self.attribute_mapping["HBA_element_pwr_RW"] = {}
 
-        self._uC_ID_R = numpy.full(32, 0)
-        self.attribute_mapping["uC_ID_R"] = {}
-
         self._RCU_monitor_rate_RW = 30.0
         self.attribute_mapping["RCU_monitor_rate_RW"] = {}
 
@@ -491,13 +450,6 @@ class PCC(Device):
     # ------------------
     # Attributes methods
     # ------------------
-    @only_when_on
-    @fault_on_error
-    def read_RCU_state_R(self):
-        """Return the RCU_state_R attribute."""
-        self._RCU_state_R = self.attribute_mapping["RCU_state_R"].get_value()
-        return self._RCU_state_R
-
     @only_when_on
     @fault_on_error
     def read_RCU_mask_R(self):
@@ -702,27 +654,6 @@ class PCC(Device):
         self.attribute_mapping["HBA_element_beamformer_delays_RW"].set_value(value.flatten().tolist())
         self._HBA_element_beamformer_delays_RW = value
 
-    @only_when_on
-    @fault_on_error
-    def read_HBA_element_led_R(self):
-        """Return the HBA_element_led_R attribute."""
-        value = numpy.array(self.attribute_mapping["HBA_element_led_R"].get_value())
-        self._HBA_element_element_led_R = numpy.array(numpy.split(value, indices_or_sections = 32))
-        return self._HBA_element_led_R
-
-    @only_when_on
-    @fault_on_error
-    def read_HBA_element_led_RW(self):
-        """Return the HBA_element_led_RW attribute."""
-        return self._HBA_element_led_RW
-
-    @only_when_on
-    @fault_on_error
-    def write_HBA_element_led_RW(self, value):
-        """Set the HBA_element_led_RW attribute."""
-        self.attribute_mapping["HBA_element_led_RW"].set_value(value.flatten().tolist())
-        self._HBA_element_led_RW = value
-
     @only_when_on
     @fault_on_error
     def read_HBA_element_pwr_R(self):
@@ -744,26 +675,6 @@ class PCC(Device):
         self.attribute_mapping["HBA_element_pwr_RW"].set_value(value.flatten().tolist())
         self._HBA_element_pwr_RW = value
 
-    @only_when_on
-    @fault_on_error
-    def read_uC_ID_R(self):
-        """Return the uC_ID_R attribute."""
-        self._uC_ID_R = numpy.array(self.attribute_mapping["uC_ID_R"].get_value())
-        return self._uC_ID_R
-
-    @only_when_on
-    @fault_on_error
-    def read_uC_ID_RW(self):
-        """Return the uC_ID_RW attribute."""
-        return self._uC_ID_RW
-
-    @only_when_on
-    @fault_on_error
-    def write_uC_ID_RW(self, value):
-        """Set the uC_ID_RW attribute."""
-        self.attribute_mapping["uC_ID_RW"].set_value(value.tolist())
-        self._uC_ID_RW = value
-
     @only_when_on
     @fault_on_error
     def read_RCU_monitor_rate_RW(self):