Index: leahi_dialin/fp/modules/valves.py =================================================================== diff -u -redc0210a1d529761e244dfb05ce9267cdbcbeb53 -r1a719e5c0a00853453a57ebd7b01cc6394ebbcc5 --- leahi_dialin/fp/modules/valves.py (.../valves.py) (revision edc0210a1d529761e244dfb05ce9267cdbcbeb53) +++ leahi_dialin/fp/modules/valves.py (.../valves.py) (revision 1a719e5c0a00853453a57ebd7b01cc6394ebbcc5) @@ -32,26 +32,26 @@ @unique -class FPValveStates(DialinEnum): +class ROValveStates(DialinEnum): VALVE_STATE_CLOSED = 0 VALVE_STATE_OPEN = 1 @unique -class FPValveNames(DialinEnum): - M4_VALV = 0 # Valve (M4 VWi) - P39_VALV = 1 # Valve (P39 VROd) - P6_VALV = 2 # Valve (P6 VFF) - P11_VALV = 3 # Valve (P11 VPi) - P33_VALV = 4 # Valve (P33 VCr) - P34_VALV = 5 # Valve (P34 VCb) - P37_VALV = 6 # Valve (P37 VCd) - M7_VALV = 7 # Valve (M7 VFB) - P20_VALV = 8 # Valve (P20 SPP) +class ROValveNames(DialinEnum): + M4_VWI = 0 # Valve (M4 VWi) + P39_VROD = 1 # Valve (P39 VROd) + P6_VFF = 2 # Valve (P6 VFF) + P11_VPI = 3 # Valve (P11 VPi) + P33_VCR = 4 # Valve (P33 VCr) + P34_VCB = 5 # Valve (P34 VCb) + P37_VCD = 6 # Valve (P37 VCd) + M7_VFB = 7 # Valve (M7 VFB) + P20_SPP = 8 # Valve (P20 SPP) -class FPValves(AbstractSubSystem): +class ROValves(AbstractSubSystem): """ - Dialin API sub-class for FP valve related commands. + Dialin API sub-class for RO valve related commands. """ # Valves states publish message field positions @@ -68,29 +68,29 @@ self.can_interface = can_interface self.logger = logger self.valves_sensed_states = OrderedDict() - self.fp_valves_states_timestamp = 0.0 + self.ro_valves_states_timestamp = 0.0 if self.can_interface is not None: - channel_id = DenaliChannels.fp_sync_broadcast_ch_id + channel_id = DenaliChannels.ro_sync_broadcast_ch_id msg_id = MsgIds.MSG_ID_RO_VALVES_STATES_DATA.value self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_valves_sync) self.valve_states_all = 0x0000 - self.m4_valv = {"id": FPValveNames.M4_VALV.value, "state": DEENERGIZED} - self.p39_valv = {"id": FPValveNames.P39_VALV.value, "state": DEENERGIZED} - self.p6_valv = {"id": FPValveNames.P6_VALV.value, "state": DEENERGIZED} - self.p11_valv = {"id": FPValveNames.P11_VALV.value, "state": DEENERGIZED} - self.p33_valv = {"id": FPValveNames.P33_VALV.value, "state": DEENERGIZED} - self.p34_valv = {"id": FPValveNames.P34_VALV.value, "state": DEENERGIZED} - self.p37_valv = {"id": FPValveNames.P37_VALV.value, "state": DEENERGIZED} - self.m7_valv = {"id": FPValveNames.M7_VALV.value, "state": DEENERGIZED} - self.p20_valv = {"id": FPValveNames.P20_VALV.value, "state": DEENERGIZED} + self.m4_vwi_state= {"id": ROValveNames.M4_VWI.value, "state": DEENERGIZED} + self.p39_vrod_state = {"id": ROValveNames.P39_VROD.value, "state": DEENERGIZED} + self.p6_vff_state = {"id": ROValveNames.P6_VFF.value, "state": DEENERGIZED} + self.p11_vpi_state = {"id": ROValveNames.P11_VPI.value, "state": DEENERGIZED} + self.p33_vcr_state = {"id": ROValveNames.P33_VCR.value, "state": DEENERGIZED} + self.p34_vcb_state = {"id": ROValveNames.P34_VCB.value, "state": DEENERGIZED} + self.p37_vcd_state = {"id": ROValveNames.P37_VCD.value, "state": DEENERGIZED} + self.m7_vfb_state = {"id": ROValveNames.M7_VFB.value, "state": DEENERGIZED} + self.p20_spp_state = {"id": ROValveNames.P20_SPP.value, "state": DEENERGIZED} # NOTE: The len function counts the enums with the same number only once. This is not the case in the DG valves # class because each valve must have a unique ID. - self.valve_states_enum = [0 for _ in range(len(FPValveNames))] + self.valve_states_enum = [0 for _ in range(len(ROValveNames))] - for valve in FPValveNames.__members__: + for valve in ROValveNames.__members__: self.valves_sensed_states[valve] = '' def get_valve_states(self): @@ -100,15 +100,15 @@ @return: All valve states """ return [ - self.m4_valv.get("state"), - self.p39_valv.get("state"), - self.p6_valv.get("state"), - self.p11_valv.get("state"), - self.p33_valv.get("state"), - self.p34_valv.get("state"), - self.p37_valv.get("state"), - self.m7_valv.get("state"), - self.p20_valv.get("state") + self.m4_vwi_state.get("state"), + self.p39_vrod_state.get("state"), + self.p6_vff_state.get("state"), + self.p11_vpi_state.get("state"), + self.p33_vcr_state.get("state"), + self.p34_vcb_state.get("state"), + self.p37_vcd_state.get("state"), + self.m7_vfb_state.get("state"), + self.p20_spp_state.get("state") ] @staticmethod @@ -142,55 +142,55 @@ return DEENERGIZED @publish([ - "fp_valves_states_timestamp", + "ro_valves_states_timestamp", "valve_states_all", - "m4_valv", - "p39_valv", - "p6_valv", - "p11_valv", - "p33_valv", - "p34_valv", - "p37_valv", - "m7_valv", - "p20_valv", + "m4_vwi_state", + "p39_vrod_state", + "p6_vff_state", + "p11_vpi_state", + "p33_vcr_state", + "p34_vcb_state", + "p37_vcd_state", + "m7_vfb_state", + "p20_spp_state", "valve_states_enum" ]) def _handler_valves_sync(self, message, timestamp=0.0): """ - Handles published FP valves states message. + Handles published RO valves states message. - @param message: published FP valves states message + @param message: published RO valves states message @return: none """ vst = struct.unpack('H', bytearray(message['message'][self.START_POS_VALVES_STATES:self.END_POS_VALVES_STATES])) self.valve_states_all = vst[0] # Extract each valve state from U16 valves states using bit-masking - self.m4_valv["state"] = self._binary_to_valve_state(vst[0] & 1) - self.p39_valv["state"] = self._binary_to_valve_state(vst[0] & 2) - self.p6_valv["state"] = self._binary_to_valve_state(vst[0] & 4) - self.p11_valv["state"] = self._binary_to_valve_state(vst[0] & 8) - self.p33_valv["state"] = self._binary_to_valve_state(vst[0] & 16) - self.p34_valv["state"] = self._binary_to_valve_state(vst[0] & 32) - self.p37_valv["state"] = self._binary_to_valve_state(vst[0] & 64) - self.m7_valv["state"] = self._binary_to_valve_state(vst[0] & 128) - self.p20_valv["state"] = self._binary_to_valve_state(vst[0] & 256) + self.m4_vwi_state["state"] = self._binary_to_valve_state(vst[0] & 1) + self.p39_vrod_state["state"] = self._binary_to_valve_state(vst[0] & 2) + self.p6_vff_state["state"] = self._binary_to_valve_state(vst[0] & 4) + self.p11_vpi_state["state"] = self._binary_to_valve_state(vst[0] & 8) + self.p33_vcr_state["state"] = self._binary_to_valve_state(vst[0] & 16) + self.p34_vcb_state["state"] = self._binary_to_valve_state(vst[0] & 32) + self.p37_vcd_state["state"] = self._binary_to_valve_state(vst[0] & 64) + self.m7_vfb_state["state"] = self._binary_to_valve_state(vst[0] & 128) + self.p20_spp_state["state"] = self._binary_to_valve_state(vst[0] & 256) start = self.END_POS_VALVES_STATES end = start + 1 for valve_id in self.valves_sensed_states: valve_state_number = struct.unpack('B', bytearray(message['message'][start:end]))[0] - self.valves_sensed_states[valve_id] = FPValveStates(valve_state_number).name + self.valves_sensed_states[valve_id] = ROValveStates(valve_state_number).name start = end end += 1 - self.fp_valves_states_timestamp = timestamp + self.ro_valves_states_timestamp = timestamp def cmd_valve_sensed_state_override(self, valve: int, state: bool, reset: int = NO_RESET) -> int: """ Constructs and sends the valve sensed state override command. Constraints: - Must be logged into FP. + Must be logged into RO. Given valve ID must be one of the valve IDs listed below. @param valve: unsigned int - valve ID @@ -204,7 +204,7 @@ vlv = integer_to_bytearray(valve) payload = rst + ste + vlv - message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_fp_ch_id, + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_ro_ch_id, message_id=MsgIds.MSG_ID_RO_VALVE_SENSED_STATE_OVERRIDE_REQUEST.value, payload=payload) @@ -223,9 +223,9 @@ def cmd_valve_override(self, valve: int, state: int, reset: int = NO_RESET) -> int: """ - Constructs and sends the FP valve state override command. + Constructs and sends the RO valve state override command. Constraints: - Must be logged into FP. + Must be logged into RO. Given valve ID must be one of the valve IDs listed below. @param valve: unsigned int - valve ID @@ -239,7 +239,7 @@ vlv = integer_to_bytearray(valve) payload = rst + ste + vlv - message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_fp_ch_id, + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_ro_ch_id, message_id=MsgIds.MSG_ID_RO_VALVE_CMD_STATE_OVERRIDE_REQUEST.value, payload=payload) @@ -258,10 +258,10 @@ def cmd_valve_broadcast_interval_override(self, ms: int, reset: int = NO_RESET) -> int: """ - Constructs and sends the FP valve state override command. + Constructs and sends the RO valve state override command. Constraints: - Must be logged into FP. - Given interval must be non-zero and a multiple of the FP general task interval (50 ms). + Must be logged into RO. + Given interval must be non-zero and a multiple of the RO general task interval (50 ms). @param ms: unsigned int - broadcast interval (in ms) @param reset: integer - 1 to reset a previous override, 0 to override @@ -276,11 +276,11 @@ ivl = integer_to_bytearray(ms) payload = rst + ivl - message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_fp_ch_id, + message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_ro_ch_id, message_id=MsgIds.MSG_ID_RO_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST.value, payload=payload) - self.logger.debug("override FP valves states publish interval") + self.logger.debug("override RO valves states publish interval") # Send message received_message = self.can_interface.send(message)