diff --git a/CDB/LOFAR_ConfigDb.json b/CDB/LOFAR_ConfigDb.json
index 5b3617b2aec3485b7eec93235a26fa911b22677d..a092a5a0a8974c478881690832d32b78ee838294 100644
--- a/CDB/LOFAR_ConfigDb.json
+++ b/CDB/LOFAR_ConfigDb.json
@@ -12,108 +12,166 @@
"RCUSCC": {
"PTS/RCUSCC/1": {
"attribute_properties": {
- "ADC_JESD_R": {
+ "RCU_ADC_CML_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
+ ],
"rel_change": [
"-1",
"1"
]
},
- "Attenuator_R": {
- "event_period": [
- "0"
+ "RCU_ADC_JESD_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Attenuator_RW": {
- "event_period": [
- "0"
+ "RCU_ADC_SYNC_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Band_R": {
- "event_period": [
- "0"
+ "RCU_ADC_lock_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Band_RW": {
- "event_period": [
- "0"
+ "RCU_ID_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "CLK_PLL_locked_R": {
- "event_period": [
- "0"
+ "RCU_LED0_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Dither_Frequency_R": {
- "event_period": [
- "0"
+ "RCU_LED0_RW": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
- "format": [
- "%6.8f"
+ "rel_change": [
+ "-1",
+ "1"
+ ]
+ },
+ "RCU_OUT1_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
- "-0.1",
- "0.1"
+ "-1",
+ "1"
]
},
- "Dither_Frequency_RW": {
- "event_period": [
- "0"
+ "RCU_OUT2_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
+ ],
+ "rel_change": [
+ "-1",
+ "1"
+ ]
+ },
+ "RCU_Pwr_dig_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
- "format": [
- "%6.8f"
+ "rel_change": [
+ "-1",
+ "1"
+ ]
+ },
+ "RCU_attenuator_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
- "-0.1",
- "0.1"
+ "-1",
+ "1"
]
},
- "LED_R": {
- "event_period": [
- "0"
+ "RCU_attenuator_RW": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "LED_RW": {
- "event_period": [
- "0"
+ "RCU_band_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Pwr_dig_R": {
- "event_period": [
- "0"
+ "RCU_band_RW": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
+ "RCU_monitor_rate_RW": {
+ "archive_rel_change": [
+ "-1.0",
+ "1.0"
+ ],
+ "rel_change": [
+ "-1.0",
+ "1.0"
+ ]
+ },
+ "RCU_temperature_R": {
+ "archive_rel_change": [
+ "-1.0",
+ "1.0"
+ ],
+ "rel_change": [
+ "-1.0",
+ "1.0"
+ ]
+ },
"State": {
"event_period": [
"0"
@@ -123,20 +181,11 @@
"event_period": [
"0"
]
- },
- "Temperature_R": {
- "event_period": [
- "0"
- ],
- "rel_change": [
- "-0.1",
- "0.1"
- ]
}
},
"properties": {
"OPC_Server_Name": [
- "10.87.6.23"
+ "ltspi.astron.nl"
],
"OPC_Server_Port": [
"4842"
@@ -145,29 +194,47 @@
"5.0"
],
"polled_attr": [
- "pwr_dig_r",
- "1000",
"state",
"1000",
"status",
"1000",
- "temperature_r",
+ "ant_mask_rw",
+ "1000",
+ "rcu_adc_cml_r",
+ "1000",
+ "rcu_adc_jesd_r",
+ "1000",
+ "rcu_adc_lock_r",
+ "1000",
+ "rcu_adc_sync_r",
+ "1000",
+ "rcu_attenuator_r",
+ "1000",
+ "rcu_attenuator_rw",
+ "1000",
+ "rcu_band_r",
+ "1000",
+ "rcu_band_rw",
+ "1000",
+ "rcu_id_r",
+ "1000",
+ "rcu_led0_r",
"1000",
- "attenuator_r",
+ "rcu_led0_rw",
"1000",
- "attenuator_rw",
+ "rcu_mask_rw",
"1000",
- "band_r",
+ "rcu_monitor_rate_rw",
"1000",
- "band_rw",
+ "rcu_out1_r",
"1000",
- "clk_pll_locked_r",
+ "rcu_out2_r",
"1000",
- "led_r",
+ "rcu_pwr_dig_r",
"1000",
- "led_rw",
+ "rcu_temperature_r",
"1000",
- "adc_jesd_r",
+ "rcu_version_r",
"1000"
]
}
diff --git a/CDB/thomas_ConfigDb.json b/CDB/thomas_ConfigDb.json
index f77a8f9a4067ea0f6a1a84cebc4a250f01c32455..2d4870f730e5cf0db5d3ac5953e250155943accd 100644
--- a/CDB/thomas_ConfigDb.json
+++ b/CDB/thomas_ConfigDb.json
@@ -12,108 +12,166 @@
"RCUSCC": {
"PTS/RCUSCC/1": {
"attribute_properties": {
- "ADC_JESD_R": {
+ "RCU_ADC_CML_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
+ ],
"rel_change": [
"-1",
"1"
]
},
- "Attenuator_R": {
- "event_period": [
- "0"
+ "RCU_ADC_JESD_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Attenuator_RW": {
- "event_period": [
- "0"
+ "RCU_ADC_SYNC_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Band_R": {
- "event_period": [
- "0"
+ "RCU_ADC_lock_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Band_RW": {
- "event_period": [
- "0"
+ "RCU_ID_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "CLK_PLL_locked_R": {
- "event_period": [
- "0"
+ "RCU_LED0_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Dither_Frequency_R": {
- "event_period": [
- "0"
+ "RCU_LED0_RW": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
- "format": [
- "%6.8f"
+ "rel_change": [
+ "-1",
+ "1"
+ ]
+ },
+ "RCU_OUT1_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
- "-0.1",
- "0.1"
+ "-1",
+ "1"
]
},
- "Dither_Frequency_RW": {
- "event_period": [
- "0"
+ "RCU_OUT2_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
+ ],
+ "rel_change": [
+ "-1",
+ "1"
+ ]
+ },
+ "RCU_Pwr_dig_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
- "format": [
- "%6.8f"
+ "rel_change": [
+ "-1",
+ "1"
+ ]
+ },
+ "RCU_attenuator_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
- "-0.1",
- "0.1"
+ "-1",
+ "1"
]
},
- "LED_R": {
- "event_period": [
- "0"
+ "RCU_attenuator_RW": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "LED_RW": {
- "event_period": [
- "0"
+ "RCU_band_R": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
- "Pwr_dig_R": {
- "event_period": [
- "0"
+ "RCU_band_RW": {
+ "archive_rel_change": [
+ "-1",
+ "1"
],
"rel_change": [
"-1",
"1"
]
},
+ "RCU_monitor_rate_RW": {
+ "archive_rel_change": [
+ "-1.0",
+ "1.0"
+ ],
+ "rel_change": [
+ "-1.0",
+ "1.0"
+ ]
+ },
+ "RCU_temperature_R": {
+ "archive_rel_change": [
+ "-1.0",
+ "1.0"
+ ],
+ "rel_change": [
+ "-1.0",
+ "1.0"
+ ]
+ },
"State": {
"event_period": [
"0"
@@ -123,15 +181,6 @@
"event_period": [
"0"
]
- },
- "Temperature_R": {
- "event_period": [
- "0"
- ],
- "rel_change": [
- "-0.1",
- "0.1"
- ]
}
},
"properties": {
@@ -139,35 +188,53 @@
"okeanos"
],
"OPC_Server_Port": [
- "50000"
+ "4842"
],
"OPC_Time_Out": [
"5.0"
],
"polled_attr": [
- "pwr_dig_r",
- "1000",
"state",
"1000",
"status",
"1000",
- "temperature_r",
+ "ant_mask_rw",
+ "1000",
+ "rcu_adc_cml_r",
+ "1000",
+ "rcu_adc_jesd_r",
+ "1000",
+ "rcu_adc_lock_r",
+ "1000",
+ "rcu_adc_sync_r",
+ "1000",
+ "rcu_attenuator_r",
+ "1000",
+ "rcu_attenuator_rw",
+ "1000",
+ "rcu_band_r",
+ "1000",
+ "rcu_band_rw",
+ "1000",
+ "rcu_id_r",
+ "1000",
+ "rcu_led0_r",
"1000",
- "attenuator_r",
+ "rcu_led0_rw",
"1000",
- "attenuator_rw",
+ "rcu_mask_rw",
"1000",
- "band_r",
+ "rcu_monitor_rate_rw",
"1000",
- "band_rw",
+ "rcu_out1_r",
"1000",
- "clk_pll_locked_r",
+ "rcu_out2_r",
"1000",
- "led_r",
+ "rcu_pwr_dig_r",
"1000",
- "led_rw",
+ "rcu_temperature_r",
"1000",
- "adc_jesd_r",
+ "rcu_version_r",
"1000"
]
}
diff --git a/RCUSCC/RCUSCC/RCUSCC.py b/RCUSCC/RCUSCC/RCUSCC.py
index eec910de17bde6678de7e4a6dbef8da558f405de..40b816bf303b9e5ead47236e934a47fb1a3e4558 100644
--- a/RCUSCC/RCUSCC/RCUSCC.py
+++ b/RCUSCC/RCUSCC/RCUSCC.py
@@ -89,69 +89,105 @@ class RCUSCC(Device):
# Attributes
# ----------
- Attenuator_R = attribute(
+ RCU_mask_RW = attribute(
+ dtype=('DevBoolean',),
+ max_dim_x=32,
+ access=AttrWriteType.READ_WRITE,
+ )
+
+ Ant_mask_RW = attribute(
+ dtype=(('DevBoolean',),),
+ max_dim_x=3, max_dim_y=32,
+ access=AttrWriteType.READ_WRITE,
+ )
+
+ RCU_attenuator_R = attribute(
dtype=(('DevLong64',),),
- max_dim_x=32, max_dim_y=3,
+ max_dim_x=3, max_dim_y=32,
)
- Attenuator_RW = attribute(
+ RCU_attenuator_RW = attribute(
dtype=(('DevLong64',),),
- max_dim_x=32, max_dim_y=3,
+ max_dim_x=3, max_dim_y=32,
access=AttrWriteType.READ_WRITE,
)
- Band_R = attribute(
+ RCU_band_R = attribute(
dtype=(('DevLong64',),),
- max_dim_x=32, max_dim_y=3,
+ max_dim_x=3, max_dim_y=32,
)
- Band_RW = attribute(
+ RCU_band_RW = attribute(
dtype=(('DevLong64',),),
- max_dim_x=32, max_dim_y=3,
+ max_dim_x=3, max_dim_y=32,
access=AttrWriteType.READ_WRITE,
)
- ADC_JESD_R = attribute(
- dtype=(('DevDouble',),),
- max_dim_x=32, max_dim_y=3,
+ RCU_temperature_R = attribute(
+ dtype=('DevDouble',),
+ max_dim_x=32,
)
- CLK_PLL_locked_R = attribute(
- dtype='DevLong64',
+ RCU_Pwr_dig_R = attribute(
+ dtype=('DevLong64',),
+ max_dim_x=32,
)
-# Dither_Frequency_R = attribute(
-# dtype=(('DevDouble',),),
-# max_dim_x=32, max_dim_y=2,
-# )
-#
-# Dither_Frequency_RW = attribute(
-# dtype=(('DevDouble',),),
-# max_dim_x=32, max_dim_y=2,
-# access=AttrWriteType.READ_WRITE,
-# )
-
- LED_R = attribute(
+ RCU_LED0_R = attribute(
dtype=('DevLong64',),
max_dim_x=32,
)
- LED_RW = attribute(
+ RCU_LED0_RW = attribute(
dtype=('DevLong64',),
max_dim_x=32,
access=AttrWriteType.READ_WRITE,
)
- Pwr_dig_R = attribute(
+ RCU_ADC_lock_R = attribute(
+ dtype=(('DevLong64',),),
+ max_dim_x=3, max_dim_y=32,
+ )
+
+ RCU_ADC_SYNC_R = attribute(
+ dtype=(('DevLong64',),),
+ max_dim_x=3, max_dim_y=32,
+ )
+
+ RCU_ADC_JESD_R = attribute(
+ dtype=(('DevLong64',),),
+ max_dim_x=3, max_dim_y=32,
+ )
+
+ RCU_ADC_CML_R = attribute(
+ dtype=(('DevLong64',),),
+ max_dim_x=3, max_dim_y=32,
+ )
+
+ RCU_OUT1_R = attribute(
+ dtype=(('DevLong64',),),
+ max_dim_x=3, max_dim_y=32,
+ )
+
+ RCU_OUT2_R = attribute(
+ dtype=(('DevLong64',),),
+ max_dim_x=3, max_dim_y=32,
+ )
+
+ RCU_ID_R = attribute(
dtype=('DevLong64',),
max_dim_x=32,
)
- Temperature_R = attribute(
- dtype=('DevDouble',),
+ RCU_version_R = attribute(
+ dtype=('DevString',),
max_dim_x=32,
)
+ RCU_monitor_rate_RW = attribute(
+ dtype='DevDouble',
+ )
+
# ---------------
# General methods
@@ -178,49 +214,51 @@ class RCUSCC(Device):
self.debug_stream("Mapping OPC-UA MP/CP to attributes...")
- # 2020-11-27, thomas
- # TODO
- # Modify as soon as we have a real multi-dimensional array
- self.attribute_mapping["Attenuator_R"] = (self.get_pcc_node("RCUs_Attenuator1_R"), self.get_pcc_node("RCUs_Attenuator2_R"), self.get_pcc_node("RCUs_Attenuator3_R"))
+ self.attribute_mapping["RCU_mask_RW"] = self.get_pcc_node("RCU_mask_RW")
- # 2020-11-27, thomas
- # TODO
- # Modify as soon as we have a real multi-dimensional array
- self.attribute_mapping["Attenuator_RW"] = (self.get_pcc_node("RCUs_Attenuator1_RW"), self.get_pcc_node("RCUs_Attenuator2_RW"), self.get_pcc_node("RCUs_Attenuator3_RW"))
+ self.attribute_mapping["Ant_mask_RW"] = self.get_pcc_node("Ant_mask_RW")
- # 2020-11-27, thomas
- # TODO
- # Modify as soon as we have a real multi-dimensional array
- self.attribute_mapping["Band_R"] = (self.get_pcc_node("RCUs_Band1_R"), self.get_pcc_node("RCUs_Band2_R"), self.get_pcc_node("RCUs_Band3_R"))
+ self.attribute_mapping["RCU_attenuator_R"] = self.get_pcc_node("RCU_attenuator_R")
- # 2020-11-27, thomas
- # TODO
- # Modify as soon as we have a real multi-dimensional array
- self.attribute_mapping["Band_RW"] = (self.get_pcc_node("RCUs_Band1_RW"), self.get_pcc_node("RCUs_Band2_RW"), self.get_pcc_node("RCUs_Band3_RW"))
+ self.attribute_mapping["RCU_attenuator_RW"] = self.get_pcc_node("RCU_attenuator_RW")
- # 2020-11-27, thomas
- # TODO
- # Modify as soon as we have a real multi-dimensional array
- self.attribute_mapping["ADC_JESD_R"] = (self.get_pcc_node("RCUs_ADC1_JESD_R"), self.get_pcc_node("RCUs_ADC2_JESD_R"), self.get_pcc_node("RCUs_ADC3_JESD_R"))
+ self.attribute_mapping["RCU_band_R"] = self.get_pcc_node("RCU_band_R")
+
+ self.attribute_mapping["RCU_band_RW"] = self.get_pcc_node("RCU_band_RW")
+ self.attribute_mapping["RCU_temperature_R"] = self.get_pcc_node("RCU_temperature_R")
- self.attribute_mapping["CLK_PLL_locked_R"] = self.get_pcc_node("CLK_PLL_locked_R")
+ self.attribute_mapping["RCU_Pwr_dig_R"] = self.get_pcc_node("RCU_Pwr_dig_R")
-# self.attribute_mapping["Dither_Frequency_R"] = self.get_pcc_node("RCUs_Dither_Frequency_R")
+ self.attribute_mapping["RCU_LED0_R"] = self.get_pcc_node("RCU_LED0_R")
-# self.attribute_mapping["Dither_Frequency_RW"] = self.get_pcc_node("RCUs_Dither_Frequency_RW")
+ self.attribute_mapping["RCU_LED0_RW"] = self.get_pcc_node("RCU_LED0_RW")
- self.attribute_mapping["LED_R"] = self.get_pcc_node("RCUs_LED0_R")
+ self.attribute_mapping["RCU_ADC_lock_R"] = self.get_pcc_node("RCU_ADC_lock_R")
- self.attribute_mapping["LED_RW"] = self.get_pcc_node("RCUs_LED0_RW")
+ self.attribute_mapping["RCU_ADC_SYNC_R"] = self.get_pcc_node("RCU_ADC_SYNC_R")
- self.attribute_mapping["Pwr_dig_R"] = self.get_pcc_node("RCUs_Pwr_dig_R")
+ self.attribute_mapping["RCU_ADC_CML_R"] = self.get_pcc_node("RCU_ADC_CML_R")
- self.attribute_mapping["Temperature_R"] = self.get_pcc_node("RCUs_Temperature_R")
+ self.attribute_mapping["RCU_ADC_JESD_R"] = self.get_pcc_node("RCU_ADC_JESD_R")
-# self.attribute_mapping["RCU_off"] = self.get_pcc_node("RCUs_RCU_off")
+ self.attribute_mapping["RCU_OUT1_R"] = self.get_pcc_node("RCU_OUT1_R")
-# self.attribute_mapping["RCU_on"] = self.get_pcc_node("RCUs_RCU_on")
+ self.attribute_mapping["RCU_OUT2_R"] = self.get_pcc_node("RCU_OUT2_R")
+
+ self.attribute_mapping["RCU_ID_R"] = self.get_pcc_node("RCU_ID_R")
+
+ self.attribute_mapping["RCU_version_R"] = self.get_pcc_node("RCU_version_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")
+
+ self.function_mapping["RCU_on"] = self.get_pcc_node("RCU_on")
+
+ self.function_mapping["ADC_on"] = self.get_pcc_node("ADC_on")
+
+ self.function_mapping["RCU_update"] = self.get_pcc_node("RCU_update")
self.debug_stream("Mapping OPC-UA MP/CP to attributes done.")
@@ -243,41 +281,69 @@ class RCUSCC(Device):
# Set default values in the RW/R attributes and add them to
# the mapping.
- self._Attenuator_R = ((0,),)
- self.attribute_mapping["Attenuator_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.attribute_mapping["Ant_mask_RW"] = {}
+
+ self._RCU_attenuator_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_attenuator_R"] = {}
+
+ self._RCU_attenuator_RW = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_attenuator_RW"] = {}
+
+ self._RCU_band_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_band_R"] = {}
+
+ self._RCU_band_RW = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_band_RW"] = {}
+
+ self._RCU_temperature_R = numpy.full((32, 3), 0.0)
+ self.attribute_mapping["RCU_temperature_R"] = {}
- self._Attenuator_RW = ((0,),)
- self.attribute_mapping["Attenuator_RW"] = {}
+ self._RCU_Pwr_dig_R = numpy.full(32, 0)
+ self.attribute_mapping["RCU_Pwr_dig_R"] = {}
- self._CLK_PLL_locked_R = 0
- self.attribute_mapping["CLK_PLL_locked_R"] = {}
+ self._RCU_LED0_R = numpy.full(32, 0)
+ self.attribute_mapping["RCU_LED0_R"] = {}
- self._Band_R = ((0,),)
- self.attribute_mapping["Band_R"] = {}
+ self._RCU_LED0_RW = numpy.full(32, 0)
+ self.attribute_mapping["RCU_LED0_RW"] = {}
- self._Band_RW = ((0,),)
- self.attribute_mapping["Band_RW"] = {}
+ self._RCU_ADC_lock_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_ADC_lock_R"] = {}
- self._ADC_JESD_R = ((0,),)
- self.attribute_mapping["ADC_JESD_R"] = {}
+ self._RCU_ADC_SYNC_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_ADC_SYNC_R"] = {}
- self._Dither_Frequency_R = ((0.0,),)
- self.attribute_mapping["Dither_Frequency_R"] = {}
+ self._RCU_ADC_JESD_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_ADC_JESD_R"] = {}
- self._Dither_Frequency_RW = ((0.0,),)
- self.attribute_mapping["Dither_Frequency_RW"] = {}
+ self._RCU_ADC_CML_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_ADC_CML_R"] = {}
- self._LED_R = ((0,),)
- self.attribute_mapping["LED_R"] = {}
+ self._RCU_OUT1_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_OUT1_R"] = {}
- self._LED0_RW = ((0,),)
- self.attribute_mapping["LED_RW"] = {}
+ self._RCU_OUT2_R = numpy.full((32, 3), 0)
+ self.attribute_mapping["RCU_OUT2_R"] = {}
- self._Pwr_dig_R = (0,)
- self.attribute_mapping["Pwr_dig_R"] = {}
+ self._RCU_ID_R = numpy.full(32, 0)
+ self.attribute_mapping["RCU_ID_R"] = {}
- self._Temperature_R = (0.0,)
- self.attribute_mapping["Temperature_R"] = {}
+ self._RCU_version_R = numpy.full(32, "1234567890")
+ self.attribute_mapping["RCU_version_R"] = {}
+
+ self._RCU_monitor_rate_RW = 60.0
+ self.attribute_mapping["RCU_monitor_rate_RW"] = {}
+
+ # Init the dict that contains function to OPC-UA function mappings.
+ self.function_mapping = {}
+ self.function_mapping["RCU_on"] = {}
+ self.function_mapping["RCU_off"] = {}
+ self.function_mapping["ADC_on"] = {}
+ self.function_mapping["RCU_update"] = {}
self.client = opcua.Client("opc.tcp://{}:{}/".format(self.OPC_Server_Name, self.OPC_Server_Port), self.OPC_Time_Out) # timeout in seconds
@@ -301,6 +367,12 @@ class RCUSCC(Device):
# Start keep-alive
self.opcua_connection.start()
+ # Set the masks
+ # TODO
+ # Read default masks from config DB
+ self.write_RCU_mask_RW(self._RCU_mask_RW)
+ self.write_Ant_mask_RW(self._Ant_mask_RW)
+
# Everything went ok -- go standby.
self.set_state(DevState.STANDBY)
@@ -327,120 +399,199 @@ class RCUSCC(Device):
@only_when_on
@fault_on_error
- def read_Attenuator_R(self):
- """Return the Attenuator_R attribute."""
- self._Attenuator_R = numpy.array([self.attribute_mapping["Attenuator_R"][0].get_value(), self.attribute_mapping["Attenuator_R"][1].get_value(), self.attribute_mapping["Attenuator_R"][2].get_value()])
- return self._Attenuator_R
+ def read_RCU_mask_R(self):
+ """Return the RCU_mask_R attribute."""
+ self._RCU_mask_R = numpy.array(self.attribute_mapping["RCU_mask_R"].get_value())
+ return self._RCU_mask_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_mask_RW(self):
+ """Return the RCU_mask_RW attribute."""
+ return self._RCU_mask_RW
@only_when_on
@fault_on_error
- def read_Attenuator_RW(self):
- """Return the Attenuator_R attribute."""
- self._Attenuator_RW = numpy.array([self.attribute_mapping["Attenuator_RW"][0].get_value(), self.attribute_mapping["Attenuator_RW"][1].get_value(), self.attribute_mapping["Attenuator_RW"][2].get_value()])
- return self._Attenuator_RW
+ def write_RCU_mask_RW(self, value):
+ """Set the RCU_mask_RW attribute."""
+ self.attribute_mapping["RCU_mask_RW"].set_value(value.tolist())
+ self._RCU_mask_RW = value
@only_when_on
@fault_on_error
- def write_Attenuator_RW(self, value):
- """Set the Attenuator_RW attribute."""
- self.attribute_mapping["Attenuator_RW"][0].set_value(value[0].tolist())
- self.attribute_mapping["Attenuator_RW"][1].set_value(value[1].tolist())
- self.attribute_mapping["Attenuator_RW"][2].set_value(value[2].tolist())
- self._Attenuator_RW = value
+ def read_Ant_mask_R(self):
+ """Return the Ant_mask_R attribute."""
+ value = numpy.array(self.attribute_mapping["Ant_mask_R"].get_value())
+ self._Ant_mask_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._Ant_mask_R
@only_when_on
@fault_on_error
- def read_Band_R(self):
- """Return the Band_R attribute."""
- self._Band_R = numpy.array([self.attribute_mapping["Band_R"][0].get_value(), self.attribute_mapping["Band_R"][1].get_value(), self.attribute_mapping["Band_R"][2].get_value()])
- return self._Band_R
+ def read_Ant_mask_RW(self):
+ """Return the Ant_mask_RW attribute."""
+ return self._Ant_mask_RW
@only_when_on
@fault_on_error
- def read_Band_RW(self):
- """Return the Band_R attribute."""
- self._Band_RW = numpy.array([self.attribute_mapping["Band_RW"][0].get_value(), self.attribute_mapping["Band_RW"][1].get_value(), self.attribute_mapping["Band_RW"][2].get_value()])
- return self._Band_RW
+ def write_Ant_mask_RW(self, value):
+ """Set the Ant_mask_RW attribute."""
+ v = numpy.concatenate(value)
+ self.attribute_mapping["Ant_mask_RW"].set_value(v.tolist())
+ self._Ant_mask_RW = value
@only_when_on
@fault_on_error
- def write_Band_RW(self, value):
- """Set the Band_RW attribute."""
- self.attribute_mapping["Band_RW"][0].set_value(value[0].tolist())
- self.attribute_mapping["Band_RW"][1].set_value(value[1].tolist())
- self.attribute_mapping["Band_RW"][2].set_value(value[2].tolist())
- self._Band_RW = value
+ def read_RCU_attenuator_R(self):
+ """Return the RCU_attenuator_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_attenuator_R"].get_value())
+ self._RCU_attenuator_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_attenuator_R
@only_when_on
@fault_on_error
- def read_ADC_JESD_R(self):
- """Return the ADC_JESD_R attribute."""
- self._ADC_JESD_R = numpy.array([self.attribute_mapping["ADC_JESD_R"][0].get_value(), self.attribute_mapping["ADC_JESD_R"][1].get_value(), self.attribute_mapping["ADC_JESD_R"][2].get_value()])
- return self._ADC_JESD_R
+ def read_RCU_attenuator_RW(self):
+ """Return the RCU_attenuator_RW attribute."""
+ return self._RCU_attenuator_RW
@only_when_on
@fault_on_error
- def read_Dither_Frequency_R(self):
- """Return the Dither_Frequency_R attribute."""
- self._Dither_Frequency_R = numpy.array([self.attribute_mapping["Dither_Frequency_R"][0].get_value(), self.attribute_mapping["Dither_Frequency_R"][1].get_value()])
- return self._Dither_Frequency_R
+ def write_RCU_attenuator_RW(self, value):
+ """Set the RCU_attenuator_RW attribute."""
+ v = numpy.concatenate(value)
+ self.attribute_mapping["RCU_attenuator_RW"].set_value(v.tolist())
+ self._RCU_attenuator_RW = value
@only_when_on
@fault_on_error
- def read_Dither_Frequency_RW(self):
- """Return the Dither_Frequency_R attribute."""
- self._Dither_Frequency_RW = numpy.array([self.attribute_mapping["Dither_Frequency_RW"][0].get_value(), self.attribute_mapping["Dither_Frequency_RW"][1].get_value()])
- return self._Dither_Frequency_RW
+ def read_RCU_band_R(self):
+ """Return the RCU_band_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_band_R"].get_value())
+ self._RCU_band_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_band_R
@only_when_on
@fault_on_error
- def write_Dither_Frequency_RW(self, value):
- """Set the Dither_Frequency_RW attribute."""
- self.attribute_mapping["Dither_Frequency_RW"][0].set_value(value[0].tolist())
- self.attribute_mapping["Dither_Frequency_RW"][1].set_value(value[1].tolist())
- self._Dither_Frequency_RW = value
+ def read_RCU_band_RW(self):
+ """Return the RCU_band_RW attribute."""
+ return self._RCU_band_RW
@only_when_on
@fault_on_error
- def read_LED_R(self):
- """Return the LED_R attribute."""
- self._LED_R = self.attribute_mapping["LED_R"].get_value()
- return self._LED_R
+ def write_RCU_band_RW(self, value):
+ """Set the RCU_band_RW attribute."""
+ v = numpy.concatenate(value)
+ self.attribute_mapping["RCU_band_RW"].set_value(v.tolist())
+ self._RCU_band_RW = value
@only_when_on
@fault_on_error
- def read_LED_RW(self):
- """Return the LED_RW attribute."""
- self._LED_RW = self.attribute_mapping["LED_RW"].get_value()
- return self._LED_RW
+ def read_RCU_temperature_R(self):
+ """Return the RCU_temperature_R attribute."""
+ self._RCU_temperature_R = numpy.array(self.attribute_mapping["RCU_temperature_R"].get_value())
+ return self._RCU_temperature_R
@only_when_on
@fault_on_error
- def write_LED_RW(self, value):
- """Set the LED_RW attribute."""
- self.attribute_mapping["LED_RW"].set_value(value.tolist())
- self._LED_RW = value
+ def read_RCU_Pwr_dig_R(self):
+ """Return the RCU_Pwr_dig_R attribute."""
+ self._RCU_Pwr_dig_R = numpy.array(self.attribute_mapping["RCU_Pwr_dig_R"].get_value())
+ return self._RCU_Pwr_dig_R
@only_when_on
@fault_on_error
- def read_Pwr_dig_R(self):
- """Return the Pwr_dig_R attribute."""
- self._Pwr_dig_R = self.attribute_mapping["Pwr_dig_R"].get_value()
- return self._Pwr_dig_R
+ def read_RCU_LED0_R(self):
+ """Return the RCU_LED0_R attribute."""
+ self._RCU_LED0_R = numpy.array(self.attribute_mapping["RCU_LED0_R"].get_value())
+ return self._RCU_LED0_R
@only_when_on
@fault_on_error
- def read_Temperature_R(self):
- """Return the Temperature_R attribute."""
- self._Temperature_R = self.attribute_mapping["Temperature_R"].get_value()
- return self._Temperature_R
+ def read_RCU_LED0_RW(self):
+ """Return the RCU_LED0_RW attribute."""
+ return self._RCU_LED0_RW
@only_when_on
@fault_on_error
- def read_CLK_PLL_locked_R(self):
- """Return the CLK_PLL_locked_R attribute."""
- self._CLK_PLL_locked_R = self.attribute_mapping["CLK_PLL_locked_R"].get_value()
- return self._CLK_PLL_locked_R
+ def write_RCU_LED0_RW(self, value):
+ """Set the RCU_LED0_RW attribute."""
+ self.attribute_mapping["RCU_LED0_RW"].set_value(value.tolist())
+ self._RCU_LED0_RW = value
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_ADC_lock_R(self):
+ """Return the RCU_ADC_lock_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_ADC_lock_R"].get_value())
+ self._RCU_ADC_lock_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_ADC_lock_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_ADC_SYNC_R(self):
+ """Return the RCU_ADC_SYNC_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_ADC_SYNC_R"].get_value())
+ self._RCU_ADC_SYNC_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_ADC_SYNC_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_ADC_JESD_R(self):
+ """Return the RCU_ADC_JESD_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_ADC_JESD_R"].get_value())
+ self._RCU_ADC_JESD_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_ADC_JESD_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_ADC_CML_R(self):
+ """Return the RCU_ADC_CML_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_ADC_CML_R"].get_value())
+ self._RCU_ADC_CML_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_ADC_CML_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_OUT1_R(self):
+ """Return the RCU_OUT1_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_OUT1_R"].get_value())
+ self._RCU_OUT1_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_OUT1_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_OUT2_R(self):
+ """Return the RCU_OUT2_R attribute."""
+ value = numpy.array(self.attribute_mapping["RCU_OUT2_R"].get_value())
+ self._RCU_OUT2_R = numpy.array(numpy.split(value, indices_or_sections = 32))
+ return self._RCU_OUT2_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_ID_R(self):
+ """Return the RCU_ID_R attribute."""
+ self._RCU_ID_R = numpy.array(self.attribute_mapping["RCU_ID_R"].get_value())
+ return self._RCU_ID_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_version_R(self):
+ """Return the RCU_version_R attribute."""
+ value = self.attribute_mapping["RCU_version_R"].get_value()
+ self._RCU_version_R = numpy.array(value)
+ return self._RCU_version_R
+
+ @only_when_on
+ @fault_on_error
+ def read_RCU_monitor_rate_RW(self):
+ """Return the RCU_monitor_rate_RW attribute."""
+ return self._RCU_monitor_rate_RW
+
+ @only_when_on
+ @fault_on_error
+ def write_RCU_monitor_rate_RW(self, value):
+ """Set the RCU_monitor_rate_RW attribute."""
+ self.attribute_mapping["RCU_monitor_rate_RW"].set_value(value)
+ self._RCU_monitor_rate_RW = value
# --------
@@ -529,7 +680,7 @@ class RCUSCC(Device):
:return:None
"""
-# self.attribute_mapping["RCU_off"]()
+ self.function_mapping["RCU_off"]()
@command(
)
@@ -539,7 +690,27 @@ class RCUSCC(Device):
:return:None
"""
-# self.attribute_mapping["RCU_on"]()
+ self.function_mapping["RCU_on"]()
+
+ @command(
+ )
+ @DebugIt()
+ def ADC_on(self):
+ """
+
+ :return:None
+ """
+ self.function_mapping["ADC_on"]()
+
+ @command(
+ )
+ @DebugIt()
+ def RCU_update(self):
+ """
+
+ :return:None
+ """
+ self.function_mapping["RCU_update"]()
# ----------