Skip to content
Snippets Groups Projects
Commit 8355e764 authored by Thomas Juerges's avatar Thomas Juerges
Browse files

Refactor for Paulus' pypcc2 version with arrays

parent f2633184
No related branches found
No related tags found
1 merge request!2Refactor for Paulus' pypcc2 version with arrays
Show whitespace changes
Inline Side-by-side
CDB/LOFAR_ConfigDb.json
+ 80
− 71
View file @ 8355e764
......@@ -12,125 +12,116 @@
"RCUSCC": {
"PTS/RCUSCC/1": {
"attribute_properties": {
"ADC_JESD_R": {
"RCU_ADC_CML_R": {
"rel_change": [
"-1",
"1"
]
},
"Attenuator_R": {
"event_period": [
"0"
],
"RCU_ADC_JESD_R": {
"rel_change": [
"-1",
"1"
]
},
"Attenuator_RW": {
"event_period": [
"0"
],
"RCU_ADC_SYNC_R": {
"rel_change": [
"-1",
"1"
]
},
"Band_R": {
"event_period": [
"0"
],
"RCU_ADC_lock_R": {
"rel_change": [
"-1",
"1"
]
},
"Band_RW": {
"event_period": [
"0"
],
"RCU_ID_R": {
"rel_change": [
"-1",
"1"
]
},
"CLK_PLL_locked_R": {
"event_period": [
"0"
],
"RCU_LED0_R": {
"rel_change": [
"-1",
"1"
]
},
"Dither_Frequency_R": {
"event_period": [
"0"
],
"format": [
"%6.8f"
],
"RCU_LED0_RW": {
"rel_change": [
"-0.1",
"0.1"
"-1",
"1"
]
},
"Dither_Frequency_RW": {
"event_period": [
"0"
],
"format": [
"%6.8f"
],
"RCU_OUT1_R": {
"rel_change": [
"-0.1",
"0.1"
"-1",
"1"
]
},
"LED_R": {
"event_period": [
"0"
],
"RCU_OUT2_R": {
"rel_change": [
"-1",
"1"
]
},
"LED_RW": {
"event_period": [
"0"
],
"RCU_Pwr_dig_R": {
"rel_change": [
"-1",
"1"
]
},
"Pwr_dig_R": {
"event_period": [
"0"
],
"RCU_attenuator_R": {
"rel_change": [
"-1",
"1"
]
},
"State": {
"event_period": [
"0"
"RCU_attenuator_RW": {
"rel_change": [
"-1",
"1"
]
},
"Status": {
"RCU_band_R": {
"rel_change": [
"-1",
"1"
]
},
"RCU_band_RW": {
"rel_change": [
"-1",
"1"
]
},
"RCU_monitor_rate": {
"rel_change": [
"-1",
"1"
]
},
"RCU_temperature_R": {
"rel_change": [
"-1",
"1"
]
},
"RCU_version_R": {
"rel_change": [
"-1",
"1"
]
},
"State": {
"event_period": [
"0"
]
},
"Temperature_R": {
"Status": {
"event_period": [
"0"
],
"rel_change": [
"-0.1",
"0.1"
]
}
},
......@@ -145,29 +136,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",
"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"
]
}
......
CDB/thomas_ConfigDb.json
+ 81
− 72
View file @ 8355e764
......@@ -12,125 +12,116 @@
"RCUSCC": {
"PTS/RCUSCC/1": {
"attribute_properties": {
"ADC_JESD_R": {
"RCU_ADC_CML_R": {
"rel_change": [
"-1",
"1"
]
},
"Attenuator_R": {
"event_period": [
"0"
],
"RCU_ADC_JESD_R": {
"rel_change": [
"-1",
"1"
]
},
"Attenuator_RW": {
"event_period": [
"0"
],
"RCU_ADC_SYNC_R": {
"rel_change": [
"-1",
"1"
]
},
"Band_R": {
"event_period": [
"0"
],
"RCU_ADC_lock_R": {
"rel_change": [
"-1",
"1"
]
},
"Band_RW": {
"event_period": [
"0"
],
"RCU_ID_R": {
"rel_change": [
"-1",
"1"
]
},
"CLK_PLL_locked_R": {
"event_period": [
"0"
],
"RCU_LED0_R": {
"rel_change": [
"-1",
"1"
]
},
"Dither_Frequency_R": {
"event_period": [
"0"
],
"format": [
"%6.8f"
],
"RCU_LED0_RW": {
"rel_change": [
"-0.1",
"0.1"
"-1",
"1"
]
},
"Dither_Frequency_RW": {
"event_period": [
"0"
],
"format": [
"%6.8f"
],
"RCU_OUT1_R": {
"rel_change": [
"-0.1",
"0.1"
"-1",
"1"
]
},
"LED_R": {
"event_period": [
"0"
],
"RCU_OUT2_R": {
"rel_change": [
"-1",
"1"
]
},
"LED_RW": {
"event_period": [
"0"
],
"RCU_Pwr_dig_R": {
"rel_change": [
"-1",
"1"
]
},
"Pwr_dig_R": {
"event_period": [
"0"
],
"RCU_attenuator_R": {
"rel_change": [
"-1",
"1"
]
},
"State": {
"event_period": [
"0"
"RCU_attenuator_RW": {
"rel_change": [
"-1",
"1"
]
},
"Status": {
"RCU_band_R": {
"rel_change": [
"-1",
"1"
]
},
"RCU_band_RW": {
"rel_change": [
"-1",
"1"
]
},
"RCU_monitor_rate": {
"rel_change": [
"-1",
"1"
]
},
"RCU_temperature_R": {
"rel_change": [
"-1",
"1"
]
},
"RCU_version_R": {
"rel_change": [
"-1",
"1"
]
},
"State": {
"event_period": [
"0"
]
},
"Temperature_R": {
"Status": {
"event_period": [
"0"
],
"rel_change": [
"-0.1",
"0.1"
]
}
},
......@@ -139,35 +130,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",
"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"
]
}
......
RCUSCC/RCUSCC/RCUSCC.py
+ 301
− 150
View file @ 8355e764
......@@ -70,67 +70,103 @@ 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=32, max_dim_y=3,
access=AttrWriteType.READ_WRITE,
)
RCU_attenuator_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
Attenuator_RW = attribute(
RCU_attenuator_RW = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
access=AttrWriteType.READ_WRITE,
)
Band_R = attribute(
RCU_band_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
Band_RW = attribute(
RCU_band_RW = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
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=32, max_dim_y=3,
)
RCU_ADC_SYNC_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
RCU_ADC_JESD_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
RCU_ADC_CML_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
RCU_OUT1_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
RCU_OUT2_R = attribute(
dtype=(('DevLong64',),),
max_dim_x=32, max_dim_y=3,
)
RCU_ID_R = attribute(
dtype=('DevLong64',),
max_dim_x=32,
)
Temperature_R = attribute(
dtype=('DevDouble',),
max_dim_x=32,
RCU_version_R = attribute(
dtype=(('DevUChar',),),
max_dim_x=32, max_dim_y=8,
)
RCU_monitor_rate = attribute(
dtype='DevULong64',
)
......@@ -159,49 +195,49 @@ 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")
self.attribute_mapping["Ant_mask_RW"] = self.get_pcc_node("Ant_mask_RW")
self.attribute_mapping["RCU_attenuator_R"] = self.get_pcc_node("RCU_attenuator_R")
self.attribute_mapping["RCU_attenuator_RW"] = self.get_pcc_node("RCU_attenuator_RW")
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["RCU_Pwr_dig_R"] = self.get_pcc_node("RCU_Pwr_dig_R")
# 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["RCU_LED0_R"] = self.get_pcc_node("RCU_LED0_R")
# 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_LED0_RW"] = self.get_pcc_node("RCU_LED0_RW")
# 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_ADC_lock_R"] = self.get_pcc_node("RCU_ADC_lock_R")
# 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_ADC_SYNC_R"] = self.get_pcc_node("RCU_ADC_SYNC_R")
self.attribute_mapping["RCU_ADC_CML_R"] = self.get_pcc_node("RCU_ADC_CML_R")
self.attribute_mapping["CLK_PLL_locked_R"] = self.get_pcc_node("CLK_PLL_locked_R")
self.attribute_mapping["RCU_ADC_JESD_R"] = self.get_pcc_node("RCU_ADC_JESD_R")
# self.attribute_mapping["Dither_Frequency_R"] = self.get_pcc_node("RCUs_Dither_Frequency_R")
self.attribute_mapping["RCU_OUT1_R"] = self.get_pcc_node("RCU_OUT1_R")
# self.attribute_mapping["Dither_Frequency_RW"] = self.get_pcc_node("RCUs_Dither_Frequency_RW")
self.attribute_mapping["RCU_OUT2_R"] = self.get_pcc_node("RCU_OUT2_R")
self.attribute_mapping["LED_R"] = self.get_pcc_node("RCUs_LED0_R")
self.attribute_mapping["RCU_ID_R"] = self.get_pcc_node("RCU_ID_R")
self.attribute_mapping["LED_RW"] = self.get_pcc_node("RCUs_LED0_RW")
self.attribute_mapping["RCU_version_R"] = self.get_pcc_node("RCU_version_R")
self.attribute_mapping["Pwr_dig_R"] = self.get_pcc_node("RCUs_Pwr_dig_R")
self.attribute_mapping["RCU_monitor_rate"] = self.get_pcc_node("RCU_monitor_rate")
self.attribute_mapping["Temperature_R"] = self.get_pcc_node("RCUs_Temperature_R")
self.function_mapping["RCU_off"] = self.get_pcc_node("RCU_off")
# self.attribute_mapping["RCU_off"] = self.get_pcc_node("RCUs_RCU_off")
self.function_mapping["RCU_on"] = self.get_pcc_node("RCU_on")
# self.attribute_mapping["RCU_on"] = self.get_pcc_node("RCUs_RCU_on")
self.function_mapping["ADC_on"] = self.get_pcc_node("ADC_on")
self.debug_stream("Mapping OPC-UA MP/CP to attributes done.")
......@@ -219,41 +255,68 @@ 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 = ((0,),)
self.attribute_mapping["RCU_mask_RW"] = {}
self._Attenuator_RW = ((0,),)
self.attribute_mapping["Attenuator_RW"] = {}
self._Ant_mask_RW = ((0,),)
self.attribute_mapping["Ant_mask_RW"] = {}
self._CLK_PLL_locked_R = 0
self.attribute_mapping["CLK_PLL_locked_R"] = {}
self._RCU_attenuator_R = ((0,),)
self.attribute_mapping["RCU_attenuator_R"] = {}
self._Band_R = ((0,),)
self.attribute_mapping["Band_R"] = {}
self._RCU_attenuator_RW = ((0,),)
self.attribute_mapping["RCU_attenuator_RW"] = {}
self._Band_RW = ((0,),)
self.attribute_mapping["Band_RW"] = {}
self._RCU_band_R = ((0,),)
self.attribute_mapping["RCU_band_R"] = {}
self._ADC_JESD_R = ((0,),)
self.attribute_mapping["ADC_JESD_R"] = {}
self._RCU_band_RW = ((0,),)
self.attribute_mapping["RCU_band_RW"] = {}
self._Dither_Frequency_R = ((0.0,),)
self.attribute_mapping["Dither_Frequency_R"] = {}
self._RCU_temperature_R = (0.0,)
self.attribute_mapping["RCU_temperature_R"] = {}
self._Dither_Frequency_RW = ((0.0,),)
self.attribute_mapping["Dither_Frequency_RW"] = {}
self._RCU_Pwr_dig_R = (0,)
self.attribute_mapping["RCU_Pwr_dig_R"] = {}
self._LED_R = ((0,),)
self.attribute_mapping["LED_R"] = {}
self._RCU_LED0_R = ((0,),)
self.attribute_mapping["RCU_LED0_R"] = {}
self._LED0_RW = ((0,),)
self.attribute_mapping["LED_RW"] = {}
self._RCU_LED0_RW = ((0,),)
self.attribute_mapping["RCU_LED0_RW"] = {}
self._Pwr_dig_R = (0,)
self.attribute_mapping["Pwr_dig_R"] = {}
self._RCU_ADC_lock_R = ((0,),)
self.attribute_mapping["RCU_ADC_lock_R"] = {}
self._Temperature_R = (0.0,)
self.attribute_mapping["Temperature_R"] = {}
self._RCU_ADC_SYNC_R = ((0,),)
self.attribute_mapping["RCU_ADC_SYNC_R"] = {}
self._RCU_ADC_JESD_R = ((0,),)
self.attribute_mapping["RCU_ADC_JESD_R"] = {}
self._RCU_ADC_CML_R = ((0,),)
self.attribute_mapping["RCU_ADC_CML_R"] = {}
self._RCU_OUT1_R = ((0,),)
self.attribute_mapping["RCU_OUT1_R"] = {}
self._RCU_OUT2_R = ((0,),)
self.attribute_mapping["RCU_OUT2_R"] = {}
self._RCU_ID_R = ((0,),)
self.attribute_mapping["RCU_ID_R"] = {}
self._RCU_version_R = ((0,),)
self.attribute_mapping["RCU_version_R"] = {}
self._RCU_monitor_rate = 0.0
self.attribute_mapping["RCU_monitor_rate"] = {}
# 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.client = opcua.Client("opc.tcp://{}:{}/".format(self.OPC_Server_Name, self.OPC_Server_Port), self.OPC_Time_Out) # timeout in seconds
......@@ -310,120 +373,198 @@ 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.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.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.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 = 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 = 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 = 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.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.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.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.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 = self.attribute_mapping["RCU_OUT1_R"].get_value()
self._RCU_OUT1_R = 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 = self.attribute_mapping["RCU_OUT2_R"].get_value()
self._RCU_OUT2_R = 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 = 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."""
self._RCU_version_R = self.attribute_mapping["RCU_version_R"].get_value()
return self._RCU_version_R
@only_when_on
@fault_on_error
def read_RCU_monitor_rate(self):
"""Return the RCU_monitor_rate attribute."""
return self._RCU_monitor_rate
@only_when_on
@fault_on_error
def write_RCU_monitor_rate(self, value):
"""Set the RCU_monitor_rate attribute."""
self.attribute_mapping["RCU_monitor_rate"].set_value(value)
self._RCU_monitor_rate = value
# --------
......@@ -480,7 +621,7 @@ class RCUSCC(Device):
:return:None
"""
# self.attribute_mapping["RCU_off"]()
self.function_mapping["RCU_off"]()
@command(
)
......@@ -490,7 +631,17 @@ 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"]()
# ----------
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment