def serialize( global_feedback_dto, fields): # type: (GlobalFeedbackDTO, Optional[List[str]]) -> Dict data = { 'id': global_feedback_dto.id, 'can_led_1_id': Toolbox.denonify(global_feedback_dto.can_led_1.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_1_function': global_feedback_dto.can_led_1.function, 'can_led_2_id': Toolbox.denonify(global_feedback_dto.can_led_2.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_2_function': global_feedback_dto.can_led_2.function, 'can_led_3_id': Toolbox.denonify(global_feedback_dto.can_led_3.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_3_function': global_feedback_dto.can_led_3.function, 'can_led_4_id': Toolbox.denonify(global_feedback_dto.can_led_4.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_4_function': global_feedback_dto.can_led_4.function } return SerializerToolbox.filter_fields(data, fields)
def serialize( thermostat_group_dto, fields): # type: (ThermostatGroupDTO, Optional[List[str]]) -> Dict data = { 'id': thermostat_group_dto.id, 'outside_sensor': Toolbox.denonify(thermostat_group_dto.outside_sensor_id, ThermostatGroupSerializer.BYTE_MAX), 'threshold_temp': Toolbox.denonify(thermostat_group_dto.threshold_temperature, ThermostatGroupSerializer.BYTE_MAX), 'pump_delay': Toolbox.denonify(thermostat_group_dto.pump_delay, ThermostatGroupSerializer.BYTE_MAX) } for mode in ['heating', 'cooling']: for i in range(4): output = 'switch_to_{0}_output_{1}'.format(mode, i) value = 'switch_to_{0}_value_{1}'.format(mode, i) field = 'switch_to_{0}_{1}'.format(mode, i) dto_value = getattr(thermostat_group_dto, field) # type: Optional[Tuple[int, int]] data[output] = Toolbox.denonify( None if dto_value is None else dto_value[0], ThermostatGroupSerializer.BYTE_MAX) data[value] = Toolbox.denonify( None if dto_value is None else dto_value[1], ThermostatGroupSerializer.BYTE_MAX) return SerializerToolbox.filter_fields(data, fields)
def dto_to_orm( thermostat_group_dto, fields): # type: (ThermostatGroupDTO, List[str]) -> EepromModel data = {} # type: Dict[str, Any] for dto_field, orm_field in { 'outside_sensor_id': 'outside_sensor', 'threshold_temperature': 'threshold_temp', 'pump_delay': 'pump_delay' }.items(): if dto_field in fields: data[orm_field] = Toolbox.denonify( getattr(thermostat_group_dto, dto_field), ThermostatGroupMapper.BYTE_MAX) for mode in ['heating', 'cooling']: for i in range(4): output = 'switch_to_{0}_output_{1}'.format(mode, i) value = 'switch_to_{0}_value_{1}'.format(mode, i) field = 'switch_to_{0}_{1}'.format(mode, i) if field in fields: dto_value = getattr( thermostat_group_dto, field) # type: Optional[Tuple[int, int]] data[output] = Toolbox.denonify( None if dto_value is None else dto_value[0], ThermostatGroupMapper.BYTE_MAX) data[value] = Toolbox.denonify( None if dto_value is None else dto_value[1], ThermostatGroupMapper.BYTE_MAX) return GlobalThermostatConfiguration.deserialize(data)
def dto_to_orm(model_type, pump_group_dto): # type: (Type[EepromModel], PumpGroupDTO) -> EepromModel data = {'id': pump_group_dto.id} # type: Dict[str, Any] if 'pump_output_id' in pump_group_dto.loaded_fields: data['output'] = Toolbox.denonify(pump_group_dto.pump_output_id, PumpGroupMapper.BYTE_MAX) if 'valve_output_ids' in pump_group_dto.loaded_fields: data['outputs'] = ','.join(str(output_id) for output_id in pump_group_dto.valve_output_ids) if 'room_id' in pump_group_dto.loaded_fields: data['room'] = Toolbox.denonify(pump_group_dto.room_id, PumpGroupMapper.BYTE_MAX) return model_type.deserialize(data)
def serialize(sensor_dto, fields): # type: (SensorDTO, Optional[List[str]]) -> Dict data = { 'id': sensor_dto.id, 'name': sensor_dto.name, 'offset': Toolbox.denonify(sensor_dto.offset, 0), 'room': Toolbox.denonify(sensor_dto.room, SensorSerializer.BYTE_MAX), 'virtual': sensor_dto.virtual } return SerializerToolbox.filter_fields(data, fields)
def dto_to_orm(shutter_dto): # type: (ShutterDTO) -> EepromModel data = {'id': shutter_dto.id, 'name': shutter_dto.name} for field in ['name']: if field in shutter_dto.loaded_fields: data[field] = getattr(shutter_dto, field) for field in ['timer_up', 'timer_down', 'up_down_config', 'group_1', 'group_2']: if field in shutter_dto.loaded_fields: data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterMapper.BYTE_MAX) for field in ['steps']: if field in shutter_dto.loaded_fields: data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterMapper.WORD_MAX) return ShutterConfiguration.deserialize(data)
def serialize( thermostat_dto, fields): # type: (ThermostatDTO, Optional[List[str]]) -> Dict data = { 'id': thermostat_dto.id, 'name': thermostat_dto.name, 'room': Toolbox.denonify(thermostat_dto.room, ThermostatSerializer.BYTE_MAX), 'setp0': thermostat_dto.setp0, 'setp1': thermostat_dto.setp1, 'setp2': thermostat_dto.setp2, 'setp3': thermostat_dto.setp3, 'setp4': thermostat_dto.setp4, 'setp5': thermostat_dto.setp5, 'sensor': Toolbox.denonify(thermostat_dto.sensor, ThermostatSerializer.BYTE_MAX), 'output0': Toolbox.denonify(thermostat_dto.output0, ThermostatSerializer.BYTE_MAX), 'output1': Toolbox.denonify(thermostat_dto.output1, ThermostatSerializer.BYTE_MAX), 'pid_p': Toolbox.denonify(thermostat_dto.pid_p, ThermostatSerializer.BYTE_MAX), 'pid_i': Toolbox.denonify(thermostat_dto.pid_i, ThermostatSerializer.BYTE_MAX), 'pid_d': Toolbox.denonify(thermostat_dto.pid_d, ThermostatSerializer.BYTE_MAX), 'pid_int': Toolbox.denonify(thermostat_dto.pid_int, ThermostatSerializer.BYTE_MAX), 'permanent_manual': thermostat_dto.permanent_manual } for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) dto_data = getattr(thermostat_dto, field) # type: ThermostatScheduleDTO if dto_data is None: raise RuntimeError( 'Schedules are mandatory in the ThermostatSerializer') data[field] = [ dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1, dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2, dto_data.temp_day_2 ] return SerializerToolbox.filter_fields(data, fields)
def dto_to_orm( model_type, thermostat_dto, fields ): # type: (Type[EepromModel], ThermostatDTO, List[str]) -> EepromModel data = {'id': thermostat_dto.id} # type: Dict[str, Any] for field in ['name', 'permanent_manual' ] + ['setp{0}'.format(i) for i in range(6)]: if field in fields: data[field] = getattr(thermostat_dto, field) for field in [ 'sensor', 'output0', 'output1', 'pid_p', 'pid_i', 'pid_d', 'pid_int', 'room' ]: if field in fields: data[field] = Toolbox.denonify(getattr(thermostat_dto, field), ThermostatMapper.BYTE_MAX) for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) if field not in fields: continue dto_data = getattr(thermostat_dto, field) # type: ThermostatScheduleDTO if dto_data is None: continue data[field] = [ dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1, dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2, dto_data.temp_day_2 ] return model_type.deserialize(data)
def dto_to_orm(output_dto): # type: (OutputDTO) -> EepromModel data = {'id': output_dto.id} for dto_field, data_field in { 'module_type': 'module_type', 'name': 'name', 'output_type': 'type' }.items(): if dto_field in output_dto.loaded_fields: data[data_field] = getattr(output_dto, dto_field) for dto_field, (data_field, default) in { 'timer': ('timer', OutputMapper.WORD_MAX), 'floor': ('floor', OutputMapper.BYTE_MAX), 'lock_bit_id': ('lock_bit_id', OutputMapper.BYTE_MAX) }.items(): if dto_field in output_dto.loaded_fields: data[data_field] = Toolbox.denonify( getattr(output_dto, dto_field), default) for i in range(4): base_field = 'can_led_{0}'.format(i + 1) if base_field in output_dto.loaded_fields: id_field = '{0}_id'.format(base_field) function_field = '{0}_function'.format(base_field) data[id_field] = getattr(output_dto, base_field).id data[function_field] = getattr(output_dto, base_field).function return OutputConfiguration.deserialize(data)
def dto_to_orm(shutter_dto): # type: (ShutterGroupDTO) -> EepromModel data = {'id': shutter_dto.id} for field in ['timer_up', 'timer_down']: if field in shutter_dto.loaded_fields: data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterGroupMapper.BYTE_MAX) return ShutterGroupConfiguration.deserialize(data)
def serialize( shutter_group_dto, fields): # type: (ShutterGroupDTO, Optional[List[str]]) -> Dict data = { 'id': shutter_group_dto.id, 'timer_up': Toolbox.denonify(shutter_group_dto.timer_up, ShutterGroupSerializer.BYTE_MAX), 'timer_down': Toolbox.denonify(shutter_group_dto.timer_down, ShutterGroupSerializer.BYTE_MAX), 'room': Toolbox.denonify(shutter_group_dto.room, ShutterGroupSerializer.BYTE_MAX) } return SerializerToolbox.filter_fields(data, fields)
def serialize(pump_group_dto, fields): # type: (PumpGroupDTO, Optional[List[str]]) -> Dict data = { 'id': pump_group_dto.id, 'output': Toolbox.denonify(pump_group_dto.pump_output_id, PumpGroupSerializer.BYTE_MAX), 'outputs': ','.join( str(output_id) for output_id in pump_group_dto.valve_output_ids), 'room': Toolbox.denonify(pump_group_dto.room_id, PumpGroupSerializer.BYTE_MAX) } return SerializerToolbox.filter_fields(data, fields)
def serialize(room_dto, fields): # type: (RoomDTO, Optional[List[str]]) -> Dict data = { 'id': room_dto.id, 'name': Toolbox.denonify(room_dto.name, ''), 'floor': 255 if room_dto.floor is None else room_dto.floor.id } return SerializerToolbox.filter_fields(data, fields)
def serialize(shutter_dto, fields): # type: (ShutterDTO, Optional[List[str]]) -> Dict data = { 'id': shutter_dto.id, 'name': shutter_dto.name, 'timer_up': Toolbox.denonify(shutter_dto.timer_up, ShutterSerializer.BYTE_MAX), 'timer_down': Toolbox.denonify(shutter_dto.timer_down, ShutterSerializer.BYTE_MAX), 'up_down_config': Toolbox.denonify(shutter_dto.up_down_config, ShutterSerializer.BYTE_MAX), 'group_1': Toolbox.denonify(shutter_dto.group_1, ShutterSerializer.BYTE_MAX), 'group_2': Toolbox.denonify(shutter_dto.group_2, ShutterSerializer.BYTE_MAX), 'room': Toolbox.denonify(shutter_dto.room, ShutterSerializer.BYTE_MAX), 'steps': Toolbox.denonify(shutter_dto.steps, ShutterSerializer.WORD_MAX) } return SerializerToolbox.filter_fields(data, fields)
def set_thermostat_mode(self, thermostat_on, cooling_mode=False, cooling_on=False, automatic=None, setpoint=None): # type: (bool, bool, bool, Optional[bool], Optional[int]) -> None """ Set the mode of the thermostats. """ _ = thermostat_on # Still accept `thermostat_on` for backwards compatibility # Figure out whether the system should be on or off set_on = False if cooling_mode is True and cooling_on is True: set_on = True if cooling_mode is False: # Heating means threshold based thermostat_group = self.load_thermostat_group() outside_sensor = Toolbox.denonify( thermostat_group.outside_sensor_id, 255) current_temperatures = self._master_controller.get_sensors_temperature( )[:32] if len(current_temperatures) < 32: current_temperatures += [None ] * (32 - len(current_temperatures)) if len(current_temperatures) > outside_sensor: current_temperature = current_temperatures[outside_sensor] set_on = thermostat_group.threshold_temperature > current_temperature else: set_on = True # Calculate and set the global mode mode = 0 mode |= (1 if set_on is True else 0) << 7 mode |= 1 << 6 # multi-tenant mode mode |= (1 if cooling_mode else 0) << 4 if automatic is not None: mode |= (1 if automatic else 0) << 3 self._master_controller.set_thermostat_mode(mode) # Caclulate and set the cooling/heating mode cooling_heating_mode = 0 if cooling_mode is True: cooling_heating_mode = 1 if cooling_on is False else 2 self._master_controller.set_thermostat_cooling_heating( cooling_heating_mode) # Then, set manual/auto if automatic is not None: action_number = 1 if automatic is True else 0 self._master_controller.set_thermostat_automatic(action_number) # If manual, set the setpoint if appropriate if automatic is False and setpoint is not None and 3 <= setpoint <= 5: self._master_controller.set_thermostat_all_setpoints(setpoint) self.invalidate_cache(THERMOSTATS) self.increase_interval(THERMOSTATS, interval=2, window=10)
def serialize( pulse_counter_dto, fields): # type: (PulseCounterDTO, Optional[List[str]]) -> Dict data = { 'id': pulse_counter_dto.id, 'name': pulse_counter_dto.name, 'input': Toolbox.denonify(pulse_counter_dto.input_id, PulseCounterSerializer.BYTE_MAX), 'persistent': pulse_counter_dto.persistent, 'room': Toolbox.denonify(pulse_counter_dto.room, PulseCounterSerializer.BYTE_MAX) } return SerializerToolbox.filter_fields(data, fields)
def dto_to_orm( pulse_counter_dto): # type: (PulseCounterDTO) -> EepromModel data = {'id': pulse_counter_dto.id} # type: Dict[str, Any] if 'name' in pulse_counter_dto.loaded_fields: data['name'] = Toolbox.shorten_name(pulse_counter_dto.name) if 'input_id' in pulse_counter_dto.loaded_fields: data['input'] = Toolbox.denonify(pulse_counter_dto.input_id, PulseCounterMapper.BYTE_MAX) return PulseCounterConfiguration.deserialize(data)
def serialize(rtd10_dto, fields): # type: (RTD10DTO, Optional[List[str]]) -> Dict data = {'id': rtd10_dto.id} for field in [ 'temp_setpoint_output', 'ventilation_speed_output', 'ventilation_speed_value', 'mode_output', 'mode_value', 'on_off_output', 'poke_angle_output', 'poke_angle_value', 'room' ]: data[field] = Toolbox.denonify(getattr(rtd10_dto, field), RTD10Serializer.BYTE_MAX) return SerializerToolbox.filter_fields(data, fields)
def serialize(ventilation_dto, fields): # type: (VentilationDTO, Optional[List[str]]) -> Dict[str,Any] data = { 'id': ventilation_dto.id, 'external_id': Toolbox.denonify(ventilation_dto.external_id, ''), 'source': { 'type': ventilation_dto.source.type, 'name': ventilation_dto.source.name }, 'name': Toolbox.denonify(ventilation_dto.name, ''), 'amount_of_levels': Toolbox.denonify(ventilation_dto.amount_of_levels, 0), 'device': { 'vendor': Toolbox.denonify(ventilation_dto.device_vendor, ''), 'type': Toolbox.denonify(ventilation_dto.device_type, '') } } if ventilation_dto.device_serial: data['device'].update({ 'serial': Toolbox.denonify(ventilation_dto.device_serial, '') }) return SerializerToolbox.filter_fields(data, fields)
def serialize(output_dto, fields): # type: (OutputDTO, Optional[List[str]]) -> Dict data = { 'id': output_dto.id, 'module_type': output_dto.module_type, 'name': output_dto.name, 'timer': Toolbox.denonify(output_dto.timer, OutputSerializer.WORD_MAX), 'floor': Toolbox.denonify(output_dto.floor, OutputSerializer.BYTE_MAX), 'type': Toolbox.denonify(output_dto.output_type, OutputSerializer.BYTE_MAX), 'lock_bit_id': Toolbox.denonify(output_dto.lock_bit_id, OutputSerializer.BYTE_MAX), 'can_led_1_id': Toolbox.denonify(output_dto.can_led_1.id, OutputSerializer.BYTE_MAX), 'can_led_1_function': output_dto.can_led_1.function, 'can_led_2_id': Toolbox.denonify(output_dto.can_led_2.id, OutputSerializer.BYTE_MAX), 'can_led_2_function': output_dto.can_led_2.function, 'can_led_3_id': Toolbox.denonify(output_dto.can_led_3.id, OutputSerializer.BYTE_MAX), 'can_led_3_function': output_dto.can_led_3.function, 'can_led_4_id': Toolbox.denonify(output_dto.can_led_4.id, OutputSerializer.BYTE_MAX), 'can_led_4_function': output_dto.can_led_4.function, 'room': Toolbox.denonify(output_dto.room, OutputSerializer.BYTE_MAX) } return SerializerToolbox.filter_fields(data, fields)
def serialize(input_dto, fields): # type: (InputDTO, Optional[List[str]]) -> Dict data = { 'id': input_dto.id, 'module_type': input_dto.module_type, 'name': input_dto.name, 'action': Toolbox.denonify(input_dto.action, InputSerializer.BYTE_MAX), 'basic_actions': ','.join([str(action) for action in input_dto.basic_actions]), 'invert': 0 if input_dto.invert else 255, 'room': Toolbox.denonify(input_dto.room, InputSerializer.BYTE_MAX), 'can': 'C' if input_dto.can else ' ', 'event_enabled': input_dto.event_enabled } return SerializerToolbox.filter_fields(data, fields)
def dto_to_orm( model_type, rtd10_dto, fields ): # type: (Type[EepromModel], RTD10DTO, List[str]) -> EepromModel data = {'id': rtd10_dto.id} for field in [ 'temp_setpoint_output', 'ventilation_speed_output', 'ventilation_speed_value', 'mode_output', 'mode_value', 'on_off_output', 'poke_angle_output', 'poke_angle_value', 'room' ]: if field in fields: data[field] = Toolbox.denonify(getattr(rtd10_dto, field), RTD10Mapper.BYTE_MAX) return model_type.deserialize(data)
def _publish_output_change(self, output_dto): # type: (OutputDTO) -> None event_status = { 'on': output_dto.state.status, 'locked': output_dto.state.locked } if output_dto.module_type in ['d', 'D']: event_status['value'] = output_dto.state.dimmer event_data = { 'id': output_dto.id, 'status': event_status, 'location': { 'room_id': Toolbox.denonify(output_dto.room, 255) } } gateway_event = GatewayEvent(GatewayEvent.Types.OUTPUT_CHANGE, event_data) self._pubsub.publish_gateway_event(PubSub.GatewayTopics.STATE, gateway_event)
def _thermostat_changed(self, thermostat_id, status): # type: (int, Dict[str,Any]) -> None """ Executed by the Thermostat Status tracker when an output changed state """ location = { 'room_id': Toolbox.denonify(self._thermostats_config[thermostat_id].room, 255) } gateway_event = GatewayEvent( GatewayEvent.Types.THERMOSTAT_CHANGE, { 'id': thermostat_id, 'status': { 'preset': status['preset'], 'current_setpoint': status['current_setpoint'], 'actual_temperature': status['actual_temperature'], 'output_0': status['output_0'], 'output_1': status['output_1'] }, 'location': location }) self._pubsub.publish_gateway_event(PubSub.GatewayTopics.STATE, gateway_event)
def dto_to_orm(input_dto): # type: (InputDTO) -> EepromModel data = {'id': input_dto.id} # type: Dict[str, Any] for dto_field, data_field in { 'module_type': 'module_type', 'name': 'name' }.items(): if dto_field in input_dto.loaded_fields: data[data_field] = getattr(input_dto, dto_field) for dto_field, (data_field, default) in { 'action': ('action', InputMapper.BYTE_MAX) }.items(): if dto_field in input_dto.loaded_fields: data[data_field] = Toolbox.denonify( getattr(input_dto, dto_field), default) if 'basic_actions' in input_dto.loaded_fields: data['basic_actions'] = ','.join( [str(action) for action in input_dto.basic_actions]) if 'invert' in input_dto.loaded_fields: data['invert'] = 0 if input_dto.invert else 255 if 'can' in input_dto.loaded_fields: data['can'] = 'C' if input_dto.can else ' ' return InputConfiguration.deserialize(data)
def serialize( thermostat_dto, fields): # type: (ThermostatDTO, Optional[List[str]]) -> Dict data = { 'id': thermostat_dto.id, 'name': thermostat_dto.name, 'room': Toolbox.denonify(thermostat_dto.room, ThermostatSerializer.BYTE_MAX), 'setp0': thermostat_dto.setp0, 'setp1': thermostat_dto.setp1, 'setp2': thermostat_dto.setp2, 'setp3': thermostat_dto.setp3, 'setp4': thermostat_dto.setp4, 'setp5': thermostat_dto.setp5, 'sensor': Toolbox.denonify(thermostat_dto.sensor, ThermostatSerializer.BYTE_MAX), 'output0': Toolbox.denonify(thermostat_dto.output0, ThermostatSerializer.BYTE_MAX), 'output1': Toolbox.denonify(thermostat_dto.output1, ThermostatSerializer.BYTE_MAX), 'pid_p': Toolbox.denonify(thermostat_dto.pid_p, ThermostatSerializer.BYTE_MAX), 'pid_i': Toolbox.denonify(thermostat_dto.pid_i, ThermostatSerializer.BYTE_MAX), 'pid_d': Toolbox.denonify(thermostat_dto.pid_d, ThermostatSerializer.BYTE_MAX), 'pid_int': Toolbox.denonify(thermostat_dto.pid_int, ThermostatSerializer.BYTE_MAX), 'permanent_manual': thermostat_dto.permanent_manual } for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) dto_data = getattr(thermostat_dto, field) # type: ThermostatScheduleDTO if dto_data is None: # TODO: Remove once UI can handle "no schedule" dto_data = ThermostatScheduleDTO(temp_night=16, temp_day_1=20, temp_day_2=20, start_day_1="07:00", end_day_1="09:00", start_day_2="16:00", end_day_2="22:00") data[field] = [ dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1, dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2, dto_data.temp_day_2 ] return SerializerToolbox.filter_fields(data, fields)