def refresh_topology(self):
time.sleep(0.01)
self.logger.debug('Starting topology refresh')
try:
self.connect()
cube = MaxCube(self.__max_cube_connection)
#TODO report cube values to the broker
# self.__messageQ.put(self.prepare_output('cube', 'free_mem_slots', cube.free_mem_slots))
# self.__messageQ.put(self.prepare_output('cube', 'duty_cycle', cube.duty_cycle))
for device in cube.devices:
device_id = self.update_device(device)
if device.type in (MAX_THERMOSTAT, MAX_THERMOSTAT_PLUS, MAX_WALL_THERMOSTAT) \
and self.enable_sanity_check \
and (device_id in self.desired_temperatures) \
and (self.desired_temperatures[device_id] != device.target_temperature):
try:
self.logger.info(
"Correcting temperature for device :%s (%s/%s) from:%s to:%s"
% (device_id, device.room_name, device.name,
device.target_temperature,
self.desired_temperatures[device_id]))
cube.set_target_temperature(
device, self.desired_temperatures[device_id])
self.logger.info("Command result:%s" %
cube.command_result)
if cube.command_success:
self.__messageQ.put(
self.prepare_output(
device_id, 'target_temperature',
self.topology[device_id]
['target_temperature']))
self.__messageQ.put(
self.prepare_output('cube', 'free_mem_slots',
cube.free_mem_slots))
self.__messageQ.put(
self.prepare_output(''
'cube', 'duty_cycle',
cube.duty_cycle))
self.cube_duty_cycle = cube.duty_cycle
self.cube_duty_cycle_reset = time.time()
except Exception as e:
self.logger.error("Set error:%s" % (format(e)))
except Exception as e:
self.logger.error(format(e))
self.logger.debug('Finished topology refresh')
if self.update_timer_elapsed():
self.mqtt_last_refresh = time.time()
self.dump_topology()
return (True)
def onCommand(self, Unit, Command, Level, Hue):
# Update commands for thermostats
if Devices[Unit].Type == 242 and Devices[Unit].sValue != str(Level):
Domoticz.Log("Setpoint changed for " + Devices[Unit].Name + ". New setpoint: " + str(Level))
try:
cube = MaxCube(MaxCubeConnection(Parameters["Address"], int(Parameters["Port"])))
except:
Domoticz.Error("Error connecting to Cube. Other running MAX! programs may block the communication!")
return
for EQ3device in cube.devices:
if Devices[Unit].DeviceID == EQ3device.rf_address:
cube.set_target_temperature(EQ3device, Level)
Devices[Unit].Update(nValue=0, sValue=str(Level))
Devices[Unit].Refresh()
# Update commands for mode switches
if Devices[Unit].Type == 244 and Devices[Unit].SubType == 62 and Devices[Unit].sValue != str(Level):
if Level == 00:
mode = 0
mode_text = "Auto"
elif Level == 10:
mode = 1
mode_text = "Manual"
elif Level == 20:
mode = 2
mode_text = "Vacation"
elif Level == 30:
mode = 3
mode_text = "Boost"
Domoticz.Log("Mode changed for " + Devices[Unit].Name + ". New mode: " + mode_text)
try:
cube = MaxCube(MaxCubeConnection(Parameters["Address"], int(Parameters["Port"])))
except:
Domoticz.Error("Error connecting to Cube. Other running MAX! programs may block the communication!")
return
for EQ3device in cube.devices:
if Devices[Unit].DeviceID == EQ3device.rf_address:
cube.set_mode(EQ3device, mode)
Devices[Unit].Update(nValue=0, sValue=str(Level))
Devices[Unit].Refresh()
from maxcube.cube import MaxCube
from maxcube.connection import MaxCubeConnection
cube = MaxCube(MaxCubeConnection('192.168.0.20', 62910))
for device in cube.devices:
print(device.name)
print(device.actual_temperature)
print(device.target_temperature)
cube.set_target_temperature(device, 18)
class MaxcubeMQTT:
class CubeCtrl(object):
'''
Wat gaan we doen:
- haal kamers (naam, id) op
- haal thermostaat per kamer op (naam, actual_temperature, target_temperature, valve_position)
-
- target temp
'''
cube = None
def __init__(self):
self.cube = MaxCube(MaxCubeConnection('192.168.1.186', 62910))
print "rooms:"
for room in self.cube.get_rooms():
print "%s (%d)" % (room.name, room.id)
def get_info(self):
room = self.cube.room_by_id(1)
print("Room(1): " + room.name)
for device in self.cube.devices_by_room(room):
self.get_device_info(device)
def set_temperature(self, room_id=1, temp=10.5):
room = self.cube.room_by_id(1)
for device in self.cube.devices_by_room(room):
print(device)
if self.cube.is_wallthermostat(device) or self.cube.is_thermostat(device):
print("Setting temp to %s" % str(temp))
self.cube.set_target_temperature(device, temp)
else:
print("No Thermostat")
def set_device_mode(self, device):
print(device)
if self.cube.is_wallthermostat(device):
print("Setting mode")
self.cube.set_mode(device, MAX_DEVICE_MODE_MANUAL)
else:
print("No Wall Thermostat")
def get_device_info(self, device):
print("Device: " + device.name)
if device.type == MAX_THERMOSTAT:
type = "MAX_THERMOSTAT"
elif device.type == MAX_THERMOSTAT_PLUS:
type = "MAX_THERMOSTAT_PLUS"
elif device.type == MAX_WINDOW_SHUTTER:
type = "MAX_WINDOW_SHUTTER"
elif device.type == MAX_WALL_THERMOSTAT:
type = "MAX_WALL_THERMOSTAT"
print("Type: " + type)
print("RF: " + device.rf_address)
print("Room ID:" + str(device.room_id))
print("Room: " + self.cube.room_by_id(device.room_id).name)
print("Name: " + device.name)
print("Serial: " + device.serial)
if device.type == MAX_THERMOSTAT:
print("MaxSetP:" + str(device.max_temperature))
print("MinSetP:" + str(device.min_temperature))
if device.mode == MAX_DEVICE_MODE_AUTOMATIC:
mode = "AUTO"
elif device.mode == MAX_DEVICE_MODE_MANUAL:
mode = "MANUAL"
print("Mode: " + mode)
print("Valve: " + str(device.valve_position))
print("Actual: " + str(device.actual_temperature))
print("Target: " + str(device.target_temperature))
if device.type == MAX_WALL_THERMOSTAT:
print("MaxSetP:" + str(device.max_temperature))
print("MinSetP:" + str(device.min_temperature))
if device.mode == MAX_DEVICE_MODE_AUTOMATIC:
mode = "AUTO"
elif device.mode == MAX_DEVICE_MODE_MANUAL:
mode = "MANUAL"
print("Mode: " + mode)
print("Actual: " + str(device.actual_temperature))
print("Target: " + str(device.target_temperature))
if device.type == MAX_WINDOW_SHUTTER:
print("IsOpen: " + str(device.is_open))
print("")
class TestMaxCubeExtended(unittest.TestCase):
""" Test the Max! Cube. """
def setUp(self):
self.cube = MaxCube(MaxCubeConnectionMock(INIT_RESPONSE_2))
def test_init(self):
self.assertEqual('015d2a', self.cube.rf_address)
self.assertEqual('Cube', self.cube.name)
self.assertEqual('01.13', self.cube.firmware_version)
self.assertEqual(3, len(self.cube.devices))
def test_parse_response(self):
self.cube.parse_response(INIT_RESPONSE_2)
self.assertEqual('015d2a', self.cube.rf_address)
self.assertEqual('Cube', self.cube.name)
self.assertEqual('01.13', self.cube.firmware_version)
self.assertEqual(3, len(self.cube.devices))
def test_parse_c_message_thermostat(self):
device = self.cube.devices[0]
self.assertEqual(21.5, device.comfort_temperature)
self.assertEqual(16.5, device.eco_temperature)
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(30.5, device.max_temperature)
device = self.cube.devices[1]
self.assertEqual(21.5, device.comfort_temperature)
self.assertEqual(16.5, device.eco_temperature)
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(30.5, device.max_temperature)
device = self.cube.devices[2]
self.assertEqual(1, device.initialized)
def test_parse_h_message(self):
self.cube.parse_h_message(
'H:KEQ0566338,0b6444,0113,00000000,335b04d2,33,32,0f0c1d,101c,03,0000'
)
self.assertEqual('0b6444', self.cube.rf_address)
self.assertEqual('01.13', self.cube.firmware_version)
def test_parse_m_message(self):
self.cube.parse_m_message(
'M:00,01,VgIEAQdLaXRjaGVuBrxTAgZMaXZpbmcGvFoDCFNsZWVwaW5nCKuCBARXb3JrBrxcBAEGvF'
'NLRVEwMzM2MTA4B0tpdGNoZW4BAQa8WktFUTAzMzYxMDAGTGl2aW5nAgEIq4JLRVEwMzM1NjYyCFNs'
'ZWVwaW5nAwEGvFxLRVEwMzM2MTA0BFdvcmsEAQ==')
self.assertEqual('0E2EBA', self.cube.devices[0].rf_address)
self.assertEqual('Thermostat', self.cube.devices[0].name)
self.assertEqual(MAX_THERMOSTAT, self.cube.devices[0].type)
self.assertEqual('KEQ1086437', self.cube.devices[0].serial)
self.assertEqual(1, self.cube.devices[0].room_id)
self.assertEqual('0A0881', self.cube.devices[1].rf_address)
self.assertEqual('Wandthermostat', self.cube.devices[1].name)
self.assertEqual(MAX_WALL_THERMOSTAT, self.cube.devices[1].type)
self.assertEqual('KEQ0655743', self.cube.devices[1].serial)
self.assertEqual(2, self.cube.devices[1].room_id)
self.assertEqual('0CA2B2', self.cube.devices[2].rf_address)
self.assertEqual('Fensterkontakt', self.cube.devices[2].name)
self.assertEqual(MAX_WINDOW_SHUTTER, self.cube.devices[2].type)
self.assertEqual('KEQ0839778', self.cube.devices[2].serial)
self.assertEqual(1, self.cube.devices[3].room_id)
self.assertEqual('Badezimmer', self.cube.rooms[0].name)
self.assertEqual(1, self.cube.rooms[0].id)
self.assertEqual('Wohnzimmer', self.cube.rooms[1].name)
self.assertEqual(2, self.cube.rooms[1].id)
def test_parse_l_message(self):
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertEqual(None, device.actual_temperature)
self.assertEqual(8.0, device.target_temperature)
device = self.cube.devices[1]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertEqual(22.9, device.actual_temperature)
self.assertEqual(8.0, device.target_temperature)
device = self.cube.devices[2]
self.assertEqual(False, device.is_open)
def test_resolve_device_mode(self):
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC,
self.cube.resolve_device_mode(24))
self.assertEqual(MAX_DEVICE_MODE_MANUAL,
self.cube.resolve_device_mode(25))
def test_is_thermostat(self):
device = MaxDevice()
device.type = MAX_CUBE
self.assertEqual(False, device.is_thermostat())
device.type = MAX_THERMOSTAT
self.assertEqual(True, device.is_thermostat())
device.type = MAX_THERMOSTAT_PLUS
self.assertEqual(True, device.is_thermostat())
device.type = MAX_WALL_THERMOSTAT
self.assertEqual(False, device.is_thermostat())
device.type = MAX_WINDOW_SHUTTER
self.assertEqual(False, device.is_thermostat())
def test_is_wall_thermostat(self):
device = MaxDevice()
device.type = MAX_CUBE
self.assertEqual(False, device.is_wallthermostat())
device.type = MAX_THERMOSTAT
self.assertEqual(False, device.is_wallthermostat())
device.type = MAX_THERMOSTAT_PLUS
self.assertEqual(False, device.is_wallthermostat())
device.type = MAX_WALL_THERMOSTAT
self.assertEqual(True, device.is_wallthermostat())
device.type = MAX_WINDOW_SHUTTER
self.assertEqual(False, device.is_wallthermostat())
def test_is_window_shutter(self):
device = MaxDevice()
device.type = MAX_CUBE
self.assertEqual(False, device.is_windowshutter())
device.type = MAX_THERMOSTAT
self.assertEqual(False, device.is_windowshutter())
device.type = MAX_THERMOSTAT_PLUS
self.assertEqual(False, device.is_windowshutter())
device.type = MAX_WALL_THERMOSTAT
self.assertEqual(False, device.is_windowshutter())
device.type = MAX_WINDOW_SHUTTER
self.assertEqual(True, device.is_windowshutter())
def test_set_target_temperature_thermostat(self):
self.cube.set_target_temperature(self.cube.devices[0], 24.5)
self.assertEqual('s:AARAAAAADi66ATE=\r\n',
self.cube.connection.command)
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
def test_set_target_temperature_windowshutter(self):
self.cube.set_target_temperature(self.cube.devices[2], 24.5)
self.assertEqual(None, self.cube.connection.command)
def test_set_mode_thermostat(self):
self.cube.set_mode(self.cube.devices[0], MAX_DEVICE_MODE_MANUAL)
self.assertEqual('s:AARAAAAADi66AVA=\r\n',
self.cube.connection.command)
self.assertEqual(MAX_DEVICE_MODE_MANUAL, self.cube.devices[0].mode)
def test_set_mode_windowshutter(self):
self.cube.set_mode(self.cube.devices[2], 24.5)
self.assertEqual(None, self.cube.connection.command)
def test_set_temperature_mode_thermostat(self):
self.cube.set_temperature_mode(self.cube.devices[2], 24.5,
MAX_DEVICE_MODE_BOOST)
self.assertEqual(None, self.cube.connection.command)
def test_get_devices(self):
devices = self.cube.get_devices()
self.assertEqual(3, len(devices))
def test_device_by_rf(self):
device = self.cube.device_by_rf('0CA2B2')
self.assertEqual('0CA2B2', device.rf_address)
self.assertEqual('Fensterkontakt', device.name)
self.assertEqual(MAX_WINDOW_SHUTTER, device.type)
self.assertEqual('KEQ0839778', device.serial)
self.assertEqual(1, device.room_id)
def test_device_by_rf_negative(self):
device = self.cube.device_by_rf('DEADBEEF')
self.assertEqual(None, device)
def test_devices_by_room(self):
room = MaxRoom()
room.id = 1
devices = self.cube.devices_by_room(room)
self.assertEqual(2, len(devices))
def test_devices_by_room_negative(self):
room = MaxRoom()
room.id = 3
devices = self.cube.devices_by_room(room)
self.assertEqual(0, len(devices))
def test_get_rooms(self):
rooms = self.cube.get_rooms()
self.assertEqual('Badezimmer', rooms[0].name)
self.assertEqual(1, rooms[0].id)
self.assertEqual('Wohnzimmer', rooms[1].name)
self.assertEqual(2, rooms[1].id)
def test_room_by_id(self):
room = self.cube.room_by_id(1)
self.assertEqual('Badezimmer', room.name)
self.assertEqual(1, room.id)
def test_room_by_id_negative(self):
room = self.cube.room_by_id(3)
self.assertEqual(None, room)
def test_set_programme(self):
self.cube.set_programme(self.cube.devices[0], "saturday",
[{
'temp': 20.5,
'until': '13:30'
}, {
'temp': 18,
'until': '24:00'
}])
self.assertEqual('s:AAAQAAAADi66AQBSokkgAAAAAAA=\r\n',
self.cube.connection.command)
def test_set_programme_already_existing_does_nothing(self):
result = self.cube.set_programme(self.cube.devices[0], 'saturday',
INIT_PROGRAMME_1['saturday'])
self.assertEqual(result, None)
self.assertEqual(self.cube.connection.command, None)
def test_get_device_as_dict(self):
device = self.cube.devices[0]
result = device.to_dict()
self.assertEqual(result['name'], 'Thermostat')
self.assertEqual(result['comfort_temperature'], 21.5)
self.assertEqual(result['programme']['monday'], [{
'until': '05:30',
'temp': 8
}, {
'until': '06:30',
'temp': 21
}, {
'until': '23:55',
'temp': 8
}, {
'until': '24:00',
'temp': 8
}])
class TestMaxCube(unittest.TestCase):
""" Test the Max! Cube. """
def setUp(self):
self.cube = MaxCube(MaxCubeConnectionMock(INIT_RESPONSE_1))
def test_init(self):
self.assertEqual('0b6475', self.cube.rf_address)
self.assertEqual('Cube', self.cube.name)
self.assertEqual('01.13', self.cube.firmware_version)
self.assertEqual(4, len(self.cube.devices))
def test_parse_response(self):
self.cube.parse_response(INIT_RESPONSE_1)
self.assertEqual('0b6475', self.cube.rf_address)
self.assertEqual('Cube', self.cube.name)
self.assertEqual('01.13', self.cube.firmware_version)
self.assertEqual(4, len(self.cube.devices))
def test_parse_c_message(self):
self.cube.parse_c_message(
'C:0b6475,7QtkdQATAf9LRVEwNTY2MzM4AAsABEAAAAAAAAAAAP///////////////////////////'
'wsABEAAAAAAAAAAQf///////////////////////////2h0dHA6Ly93d3cubWF4LXBvcnRhbC5lbHY'
'uZGU6ODAvY3ViZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENFVAAACgADAAAOEEN'
'FU1QAAwACAAAcIA==')
device = self.cube.devices[0]
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(25.0, device.max_temperature)
def test_parse_h_message(self):
self.cube.parse_h_message(
'H:KEQ0566338,0b6444,0113,00000000,335b04d2,33,32,0f0c1d,101c,03,0000'
)
self.assertEqual('0b6444', self.cube.rf_address)
self.assertEqual('01.13', self.cube.firmware_version)
def test_parse_m_message(self):
self.cube.parse_m_message(
'M:00,01,VgIEAQdLaXRjaGVuBrxTAgZMaXZpbmcGvFoDCFNsZWVwaW5nCKuCBARXb3JrBrxcBAEGvF'
'NLRVEwMzM2MTA4B0tpdGNoZW4BAQa8WktFUTAzMzYxMDAGTGl2aW5nAgEIq4JLRVEwMzM1NjYyCFNs'
'ZWVwaW5nAwEGvFxLRVEwMzM2MTA0BFdvcmsEAQ==')
self.assertEqual('06BC53', self.cube.devices[0].rf_address)
self.assertEqual('Kitchen', self.cube.devices[0].name)
self.assertEqual('06BC5A', self.cube.devices[1].rf_address)
self.assertEqual('Living', self.cube.devices[1].name)
self.assertEqual('08AB82', self.cube.devices[2].rf_address)
self.assertEqual('Sleeping', self.cube.devices[2].name)
self.assertEqual('06BC5C', self.cube.devices[3].rf_address)
self.assertEqual('Work', self.cube.devices[3].name)
def test_parse_l_message(self):
self.cube.parse_l_message(
'L:Cwa8U/ESGAAiAAAACwa8WgkSGAAiAAAACwa8XAkSGAUiAAAACwirggMSGAUiAAAA'
)
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertEqual(23.6, device.actual_temperature)
self.assertEqual(17.0, device.target_temperature)
self.cube.parse_l_message(
'L:Cwa8U/ESGQkhALMACwa8WgkSGQAhAMAACwa8XAkSGQUhALIACwirggMSGQUhAAAA'
)
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_MANUAL, device.mode)
self.assertEqual(17.9, device.actual_temperature)
self.assertEqual(16.5, device.target_temperature)
def test_resolve_device_mode(self):
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC,
self.cube.resolve_device_mode(24))
self.assertEqual(MAX_DEVICE_MODE_MANUAL,
self.cube.resolve_device_mode(25))
def test_is_thermostat(self):
device = MaxDevice()
device.type = MAX_CUBE
self.assertEqual(False, device.is_thermostat())
device.type = MAX_THERMOSTAT
self.assertEqual(True, device.is_thermostat())
device.type = MAX_THERMOSTAT_PLUS
self.assertEqual(True, device.is_thermostat())
def test_set_target_temperature(self):
self.cube.set_target_temperature(self.cube.devices[0], 24.5)
self.assertEqual('s:AARAAAAABrxTATE=\r\n',
self.cube.connection.command)
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
self.cube.set_target_temperature(self.cube.devices[0], 24.6)
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
class TestMaxCube(TestCase):
""" Test the Max! Cube. """
def init(self, ClassMock, responses):
self.commander = ClassMock.return_value
self.commander.update.return_value = responses
self.cube = MaxCube("host", 1234, now=lambda: datetime(2012, 10, 22, 5, 30))
self.commander.update.assert_called_once()
self.commander.update.reset_mock()
self.commander.send_radio_msg.return_value = True
def test_init(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.assertEqual("KEQ0566338", self.cube.serial)
self.assertEqual("0b6475", self.cube.rf_address)
self.assertEqual("Cube", self.cube.name)
self.assertEqual("01.13", self.cube.firmware_version)
self.assertEqual(4, len(self.cube.devices))
device = self.cube.devices[0]
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(25.0, device.max_temperature)
self.assertEqual("06BC53", device.rf_address)
self.assertEqual("Kitchen", device.name)
self.assertEqual("06BC5A", self.cube.devices[1].rf_address)
self.assertEqual("Living", self.cube.devices[1].name)
self.assertEqual("08AB82", self.cube.devices[2].rf_address)
self.assertEqual("Sleeping", self.cube.devices[2].name)
self.assertEqual("06BC5C", self.cube.devices[3].rf_address)
self.assertEqual("Work", self.cube.devices[3].name)
def __update(self, responses: List[Message]):
self.commander.update.return_value = responses
self.cube.update()
self.commander.update.assert_called_once()
def test_parse_auto_l_message(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.__update([LAST_STATE_MSG])
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertEqual(23.6, device.actual_temperature)
self.assertEqual(17.0, device.target_temperature)
def test_parse_manual_l_message(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.__update(
[
Message.decode(
b"L:Cwa8U/ESGQkhALMACwa8WgkSGQAhAMAACwa8XAkSGQUhALIACwirggMSGQUhAAAA"
)
]
)
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_MANUAL, device.mode)
self.assertEqual(17.9, device.actual_temperature)
self.assertEqual(16.5, device.target_temperature)
def test_disconnect(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.cube.disconnect()
self.commander.disconnect.assert_called_once()
def test_use_persistent_connection(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.commander.use_persistent_connection = True
self.assertTrue(self.cube.use_persistent_connection)
self.cube.use_persistent_connection = False
self.assertFalse(self.commander.use_persistent_connection)
def test_is_thermostat(self, _):
device = MaxDevice()
device.type = MAX_CUBE
self.assertFalse(device.is_thermostat())
device.type = MAX_THERMOSTAT
self.assertTrue(device.is_thermostat())
device.type = MAX_THERMOSTAT_PLUS
self.assertTrue(device.is_thermostat())
device.type = MAX_WALL_THERMOSTAT
self.assertFalse(device.is_thermostat())
device.type = MAX_WINDOW_SHUTTER
self.assertFalse(device.is_thermostat())
def test_is_wall_thermostat(self, _):
device = MaxDevice()
device.type = MAX_CUBE
self.assertFalse(device.is_wallthermostat())
device.type = MAX_THERMOSTAT
self.assertFalse(device.is_wallthermostat())
device.type = MAX_THERMOSTAT_PLUS
self.assertFalse(device.is_wallthermostat())
device.type = MAX_WALL_THERMOSTAT
self.assertTrue(device.is_wallthermostat())
device.type = MAX_WINDOW_SHUTTER
self.assertFalse(device.is_wallthermostat())
def test_is_window_shutter(self, _):
device = MaxDevice()
device.type = MAX_CUBE
self.assertFalse(device.is_windowshutter())
device.type = MAX_THERMOSTAT
self.assertFalse(device.is_windowshutter())
device.type = MAX_THERMOSTAT_PLUS
self.assertFalse(device.is_windowshutter())
device.type = MAX_WALL_THERMOSTAT
self.assertFalse(device.is_windowshutter())
device.type = MAX_WINDOW_SHUTTER
self.assertTrue(device.is_windowshutter())
def test_set_target_temperature(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.assertTrue(self.cube.set_target_temperature(self.cube.devices[0], 24.5))
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
self.commander.send_radio_msg.assert_called_once()
self.commander.send_radio_msg.assert_called_with("00044000000006BC530131")
def test_do_not_update_if_set_target_temperature_fails(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.commander.send_radio_msg.return_value = False
self.assertFalse(self.cube.set_target_temperature(self.cube.devices[0], 24.5))
self.assertEqual(21, self.cube.devices[0].target_temperature)
self.commander.send_radio_msg.assert_called_once()
self.commander.send_radio_msg.assert_called_with("00044000000006BC530131")
def test_set_target_temperature_should_round_temperature(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
self.cube.set_target_temperature(self.cube.devices[0], 24.6)
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
self.commander.send_radio_msg.assert_called_once()
self.commander.send_radio_msg.assert_called_with("00044000000006BC530131")
def test_set_target_temperature_is_ignored_by_windowshutter(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
self.cube.set_target_temperature(self.cube.devices[2], 24.5)
self.commander.send_radio_msg.assert_not_called()
def test_set_mode_thermostat(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_1)
device = self.cube.devices[0]
self.assertEqual(21.0, device.target_temperature)
self.cube.set_mode(device, MAX_DEVICE_MODE_MANUAL)
self.assertEqual(MAX_DEVICE_MODE_MANUAL, device.mode)
self.commander.send_radio_msg.assert_called_once()
self.commander.send_radio_msg.assert_called_with("00044000000006BC53016A")
def test_init_2(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
self.assertEqual("JEQ0341267", self.cube.serial)
self.assertEqual("015d2a", self.cube.rf_address)
self.assertEqual("Cube", self.cube.name)
self.assertEqual("01.13", self.cube.firmware_version)
self.assertEqual(3, len(self.cube.devices))
device = self.cube.devices[0]
self.assertEqual(21.5, device.comfort_temperature)
self.assertEqual(16.5, device.eco_temperature)
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(30.5, device.max_temperature)
device = self.cube.devices[1]
self.assertEqual(21.5, device.comfort_temperature)
self.assertEqual(16.5, device.eco_temperature)
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(30.5, device.max_temperature)
device = self.cube.devices[2]
self.assertEqual(1, device.initialized)
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertIsNone(device.actual_temperature)
self.assertEqual(8.0, device.target_temperature)
device = self.cube.devices[1]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertEqual(22.9, device.actual_temperature)
self.assertEqual(8.0, device.target_temperature)
device = self.cube.devices[2]
self.assertFalse(device.is_open)
self.assertTrue(device.battery == MAX_DEVICE_BATTERY_LOW)
def test_parse_m_message(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
self.__update(
[
Message.decode(
b"M:00,01,VgIEAQdLaXRjaGVuBrxTAgZMaXZpbmcGvFoDCFNsZWVwaW5nCKuCBARXb3JrBrxcBAEGvF"
b"NLRVEwMzM2MTA4B0tpdGNoZW4BAQa8WktFUTAzMzYxMDAGTGl2aW5nAgEIq4JLRVEwMzM1NjYyCFNs"
b"ZWVwaW5nAwEGvFxLRVEwMzM2MTA0BFdvcmsEAQ=="
),
INIT_RESPONSE_2[-1],
]
)
self.assertEqual("0E2EBA", self.cube.devices[0].rf_address)
self.assertEqual("Thermostat", self.cube.devices[0].name)
self.assertEqual(MAX_THERMOSTAT, self.cube.devices[0].type)
self.assertEqual("KEQ1086437", self.cube.devices[0].serial)
self.assertEqual(1, self.cube.devices[0].room_id)
self.assertEqual("0A0881", self.cube.devices[1].rf_address)
self.assertEqual("Wandthermostat", self.cube.devices[1].name)
self.assertEqual(MAX_WALL_THERMOSTAT, self.cube.devices[1].type)
self.assertEqual("KEQ0655743", self.cube.devices[1].serial)
self.assertEqual(2, self.cube.devices[1].room_id)
self.assertEqual("0CA2B2", self.cube.devices[2].rf_address)
self.assertEqual("Fensterkontakt", self.cube.devices[2].name)
self.assertEqual(MAX_WINDOW_SHUTTER, self.cube.devices[2].type)
self.assertEqual("KEQ0839778", self.cube.devices[2].serial)
self.assertEqual(1, self.cube.devices[2].room_id)
self.assertEqual("Kitchen", self.cube.rooms[0].name)
self.assertEqual(1, self.cube.rooms[0].id)
self.assertEqual("Living", self.cube.rooms[1].name)
self.assertEqual(2, self.cube.rooms[1].id)
def test_get_devices(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
devices = self.cube.get_devices()
self.assertEqual(3, len(devices))
def test_device_by_rf(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
device = self.cube.device_by_rf("0CA2B2")
self.assertEqual("0CA2B2", device.rf_address)
self.assertEqual("Fensterkontakt", device.name)
self.assertEqual(MAX_WINDOW_SHUTTER, device.type)
self.assertEqual("KEQ0839778", device.serial)
self.assertEqual(1, device.room_id)
def test_device_by_rf_negative(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
device = self.cube.device_by_rf("DEADBEEF")
self.assertIsNone(device)
def test_devices_by_room(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
room = MaxRoom()
room.id = 1
devices = self.cube.devices_by_room(room)
self.assertEqual(2, len(devices))
def test_devices_by_room_negative(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
room = MaxRoom()
room.id = 3
devices = self.cube.devices_by_room(room)
self.assertEqual(0, len(devices))
def test_get_rooms(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
rooms = self.cube.get_rooms()
self.assertEqual("Badezimmer", rooms[0].name)
self.assertEqual(1, rooms[0].id)
self.assertEqual("Wohnzimmer", rooms[1].name)
self.assertEqual(2, rooms[1].id)
def test_room_by_id(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
room = self.cube.room_by_id(1)
self.assertEqual("Badezimmer", room.name)
self.assertEqual(1, room.id)
def test_room_by_id_negative(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
room = self.cube.room_by_id(3)
self.assertIsNone(room)
def test_set_programme(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
self.commander.send_radio_msg.return_value = True
result = self.cube.set_programme(
self.cube.devices[0],
"saturday",
[{"temp": 20.5, "until": "13:30"}, {"temp": 18, "until": "24:00"}],
)
self.assertTrue(result)
self.commander.send_radio_msg.assert_called_once()
self.commander.send_radio_msg.assert_called_with(
"0000100000000E2EBA010052A249200000000000"
)
def test_set_programme_already_existing_does_nothing(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
result = self.cube.set_programme(
self.cube.devices[0], "saturday", INIT_PROGRAMME_1["saturday"]
)
self.assertIsNone(result)
self.commander.send_radio_msg.assert_not_called()
def test_get_device_as_dict(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
device = self.cube.devices[0]
result = device.to_dict()
self.assertEqual(result["name"], "Thermostat")
self.assertEqual(result["comfort_temperature"], 21.5)
self.assertEqual(
result["programme"]["monday"],
[
{"until": "05:30", "temp": 8},
{"until": "06:30", "temp": 21},
{"until": "23:55", "temp": 8},
{"until": "24:00", "temp": 8},
],
)
def test_set_auto_mode_read_temp_from_program(self, ClassMock):
self.init(ClassMock, INIT_RESPONSE_2)
device = self.cube.devices[0]
self.assertEqual(8.0, device.target_temperature)
self.cube.set_mode(device, MAX_DEVICE_MODE_AUTOMATIC)
self.assertEqual(21.0, device.target_temperature)
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.commander.send_radio_msg.assert_called_once()
self.commander.send_radio_msg.assert_called_with("0004400000000E2EBA0100")
class TestMaxCube(unittest.TestCase):
""" Test the Max! Cube. """
def setUp(self):
self.cube = MaxCube(MaxCubeConnectionMock())
def test_init(self):
self.assertEqual('0b6475', self.cube.rf_address)
self.assertEqual('Cube', self.cube.name)
self.assertEqual('01.13', self.cube.firmware_version)
self.assertEqual(4, len(self.cube.devices))
def test_parse_response(self):
self.cube.parse_response(INIT_RESPONSE)
self.assertEqual('0b6475', self.cube.rf_address)
self.assertEqual('Cube', self.cube.name)
self.assertEqual('01.13', self.cube.firmware_version)
self.assertEqual(4, len(self.cube.devices))
def test_parse_c_message(self):
self.cube.parse_c_message('C:0b6475,7QtkdQATAf9LRVEwNTY2MzM4AAsABEAAAAAAAAAAAP///////////////////////////'
'wsABEAAAAAAAAAAQf///////////////////////////2h0dHA6Ly93d3cubWF4LXBvcnRhbC5lbHY'
'uZGU6ODAvY3ViZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENFVAAACgADAAAOEEN'
'FU1QAAwACAAAcIA==')
device = self.cube.devices[0]
self.assertEqual(4.5, device.min_temperature)
self.assertEqual(25.0, device.max_temperature)
def test_parse_h_message(self):
self.cube.parse_h_message('H:KEQ0566338,0b6444,0113,00000000,335b04d2,33,32,0f0c1d,101c,03,0000')
self.assertEqual('0b6444', self.cube.rf_address)
self.assertEqual('01.13', self.cube.firmware_version)
def test_parse_m_message(self):
self.cube.parse_m_message('M:00,01,VgIEAQdLaXRjaGVuBrxTAgZMaXZpbmcGvFoDCFNsZWVwaW5nCKuCBARXb3JrBrxcBAEGvF'
'NLRVEwMzM2MTA4B0tpdGNoZW4BAQa8WktFUTAzMzYxMDAGTGl2aW5nAgEIq4JLRVEwMzM1NjYyCFNs'
'ZWVwaW5nAwEGvFxLRVEwMzM2MTA0BFdvcmsEAQ==')
self.assertEqual('6BC53', self.cube.devices[0].rf_address)
self.assertEqual('Kitchen', self.cube.devices[0].name)
self.assertEqual('6BC5A', self.cube.devices[1].rf_address)
self.assertEqual('Living', self.cube.devices[1].name)
self.assertEqual('8AB82', self.cube.devices[2].rf_address)
self.assertEqual('Sleeping', self.cube.devices[2].name)
self.assertEqual('6BC5C', self.cube.devices[3].rf_address)
self.assertEqual('Work', self.cube.devices[3].name)
def test_parse_l_message(self):
self.cube.parse_l_message('L:Cwa8U/ESGAAiAAAACwa8WgkSGAAiAAAACwa8XAkSGAUiAAAACwirggMSGAUiAAAA')
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, device.mode)
self.assertEqual(23.6, device.actual_temperature)
self.assertEqual(17.0, device.target_temperature)
self.cube.parse_l_message('L:Cwa8U/ESGQkhALMACwa8WgkSGQAhAMAACwa8XAkSGQUhALIACwirggMSGQUhAAAA')
device = self.cube.devices[0]
self.assertEqual(MAX_DEVICE_MODE_MANUAL, device.mode)
self.assertEqual(17.9, device.actual_temperature)
self.assertEqual(16.5, device.target_temperature)
def test_resolve_device_mode(self):
self.assertEqual(MAX_DEVICE_MODE_AUTOMATIC, self.cube.resolve_device_mode(24))
self.assertEqual(MAX_DEVICE_MODE_MANUAL, self.cube.resolve_device_mode(25))
def test_is_thermostat(self):
device = MaxDevice()
device.type = MAX_CUBE
self.assertEqual(False, self.cube.is_thermostat(device))
device.type = MAX_THERMOSTAT
self.assertEqual(True, self.cube.is_thermostat(device))
device.type = MAX_THERMOSTAT_PLUS
self.assertEqual(True, self.cube.is_thermostat(device))
def test_set_target_temperature(self):
self.cube.set_target_temperature(self.cube.devices[0], 24.5)
self.assertEqual('s:AARAAAAABrxTATE=\r\n', self.cube.connection.command)
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
self.cube.set_target_temperature(self.cube.devices[0], 24.6)
self.assertEqual(24.5, self.cube.devices[0].target_temperature)
y = date[0:4]
m = date[5:7]
d = date[8:10]
h = date[11:13]
mm = date[14:16]
s = date[17:]
date_conv = datetime(int(y), int(m), int(d), int(h), int(mm), int(s),
0)
age = datetime.today() - date_conv
print(' Comparing D:' + str(domoticz_props[search_name + '-Stat'][2]) +
' to T:' + str(device.target_temperature) +
'. Domoticz device was updated : ' +
str(int(age.total_seconds())) + 's ago')
if float(domoticz_props[search_name + '-Stat'][2]) != float(
device.target_temperature):
if int(age.total_seconds()) > interval * 60:
#updating domoticz device
print('Updating domoticz device: ' + search_name +
'-Stat, sending value: ' +
str(device.target_temperature))
url = "http://" + DOMOTICZ_IP + ":" + DOMOTICZ_PORT + "/json.htm?type=command¶m=udevice&idx=" + domoticz_props[
search_name + '-Stat'][0] + "&nvalue=0&svalue=" + str(
device.target_temperature)
response = urllib.urlopen(url)
else:
#updating termostat
print('Updating termostat: ' + device.name + ' with value: ' +
domoticz_props[search_name + '-Stat'][2])
cube.set_target_temperature(
device, float(domoticz_props[search_name + '-Stat'][2]))