self.set_attributes(priority, address, rtr)
self.dark = (0x01 & data[0])
self.light = (0x02 & data[0])
self.motion1 = (0x04 & data[0])
self.light_motion1 = (0x08 & data[0])
self.motion2 = (0x10 & data[0])
self.light_motion2 = (0x20 & data[0])
self.low_temp_alarm = (0x40 & data[0])
self.high_temp_alarm = (0x80 & data[0])
self.light_value = (data[1] << 8) + data[2]
def data_to_binary(self):
"""
:return: bytes
"""
raise NotImplementedError
velbus.register_command(COMMAND_CODE, ModuleStatusMessage)
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMB8PBU')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMB6PBN')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMB2PBN')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMB6PBB')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMBGP1')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMBGP2')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMBGP4')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMBGP0')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMBGPOD')
velbus.register_command(COMMAND_CODE, ModuleStatusMessage2, 'VMB7IN')
velbus.register_command(COMMAND_CODE, ModuleStatusPirMessage, 'VMBIRO')
received by: VMB6IN
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.leds = []
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 1)
self.set_attributes(priority, address, rtr)
self.leds = self.byte_to_channels(data[0])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channels_to_byte(self.leds)
])
velbus.register_command(COMMAND_CODE, SlowBlinkingLedMessage)
class ReceiveBufferFullMessage(velbus.Message):
"""
send by:
received by: VMB1USB
"""
def set_defaults(self, address):
if address is not None:
self.set_address(address)
self.set_high_priority()
self.set_no_rtr()
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
self.needs_high_priority(priority)
self.needs_no_rtr(rtr)
self.needs_no_data(data)
self.set_attributes(priority, address, rtr)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE])
velbus.register_command(COMMAND_CODE, ReceiveBufferFullMessage)
self.max = 0
def populate(self, priority, address, rtr, data):
"""
data bytes (high + low)
1 + 2 = current temp
3 + 4 = min temp
5 + 6 = max temp
:return: None
"""
assert isinstance(data, bytes)
self.needs_no_rtr(rtr)
self.needs_data(data, 6)
self.set_attributes(priority, address, rtr)
self.cur = (((data[0] << 8) | data[1]) / 32) * 0.0625
self.min = (((data[2] << 8) | data[3]) / 32) * 0.0625
self.max = (((data[4] << 8) | data[5]) / 32) * 0.0625
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['cur'] = self.cur
json_dict['min'] = self.min
json_dict['max'] = self.max
return json.dumps(json_dict)
velbus.register_command(COMMAND_CODE, SensorTemperatureMessage)
def __init__(self, address=None):
velbus.Message.__init__(self)
self.channel = 0
self.name = ""
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 7)
self.set_attributes(priority, address, rtr)
channels = self.byte_to_channels(data[0])
self.needs_one_channel(channels)
self.channel = channels[0]
self.name = "".join([chr(x) for x in data[1:]])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE,
self.channels_to_byte([self.channel])]) + bytes(
self.name, 'utf-8')
velbus.register_command(COMMAND_CODE, ChannelNamePart2Message)
class ClearLedMessage(velbus.Message):
"""
send by: VMB4RYLD
received by: VMB6IN, VMB4RYLD
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.clear_leds = []
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 1)
self.set_attributes(priority, address, rtr)
self.clear_leds = self.byte_to_channels(data[0])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, self.channels_to_byte(self.clear_leds)])
velbus.register_command(COMMAND_CODE, ClearLedMessage)
"""
send by:
received by: VMB4RYLD
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
self.needs_no_rtr(rtr)
self.set_attributes(priority, address, rtr)
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
return json.dumps(json_dict)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, 0xaa])
velbus.register_command(COMMAND_CODE, TempSetHeatingMessage)
self.set_firmware_priority()
self.set_no_rtr()
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_firmware_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 6)
self.set_attributes(priority, address, rtr)
self.module_type = data[0]
prefix = bytes([0, 0])
(self.current_serial, ) = struct.unpack('>L',
prefix + data[1] + data[2])
self.module_address = data[3]
(self.new_serial, ) = struct.unpack('>L', prefix + data[4] + data[5])
def data_to_binary(self):
"""
:return: bytes
"""
return chr(COMMAND_CODE) + chr(self.module_type) + \
struct.pack('>L', self.current_serial)[2:] + \
chr(self.module_address) + \
struct.pack('>L', self.new_serial)[2:]
velbus.register_command(COMMAND_CODE, WriteModuleAddressAndSerialNumberMessage)
"""
:author: Thomas Delaet <*****@*****.**>
"""
import velbus
COMMAND_CODE = 0xcb
class MemoryDumpRequestMessage(velbus.Message):
"""
send by:
received by: VMB6IN, VMB4RYLD
"""
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_no_data(data)
self.set_attributes(priority, address, rtr)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE])
velbus.register_command(COMMAND_CODE, MemoryDumpRequestMessage)
self.target_temp = data[4] / 2
self.sleep_timer = (data[5] << 8) + data[6]
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['local_control'] = self.local_control
json_dict['status_mode'] = DSTATUS[self.status_mode]
json_dict['auto_send'] = self.auto_send
json_dict['mode'] = DMODE[self.mode]
json_dict['cool'] = self.cool
json_dict['heater'] = self.heater
json_dict['boost'] = self.boost
json_dict['pump'] = self.pump
json_dict['cool'] = self.cool
json_dict['alarm1'] = self.alarm1
json_dict['alarm2'] = self.alarm2
json_dict['alarm3'] = self.alarm3
json_dict['alarm4'] = self.alarm4
json_dict['current_temp'] = self.current_temp
json_dict['target_temp'] = self.target_temp
json_dict['sleep_timer'] = self.sleep_timer
print(json_dict)
return json.dumps(json_dict)
velbus.register_command(COMMAND_CODE, TempSensorStatusMessage)
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
#self.needs_data(data, 6)
self.set_attributes(priority, address, rtr)
self.module_type = data[0]
self.sub_address_1 = data[3]
self.sub_address_2 = data[4]
self.sub_address_3 = data[5]
self.sub_address_4 = data[6]
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['sub_1'] = self.sub_address_1
json_dict['sub_2'] = self.sub_address_2
json_dict['sub_3'] = self.sub_address_3
json_dict['sub_4'] = self.sub_address_4
return json.dumps(json_dict)
velbus.register_command(COMMAND_CODE, ModuleSubTypeMessage, 'VMBGP1')
velbus.register_command(COMMAND_CODE, ModuleSubTypeMessage, 'VMBGP2')
velbus.register_command(COMMAND_CODE, ModuleSubTypeMessage, 'VMBGP4')
velbus.register_command(COMMAND_CODE, ModuleSubTypeMessage, 'VMBGP0')
velbus.register_command(COMMAND_CODE, ModuleSubTypeMessage, 'VMBGPOD')
assert isinstance(data, bytes)
self.logger.debug(
"Populating message: priority %s, address: %s, channels: %s",
str(priority), str(address), str(data))
self.needs_high_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 1)
self.set_attributes(priority, address, rtr)
self.logger.debug("Setting relay channels to %s",
str(self.byte_to_channels(data)))
self.relay_channels = self.byte_to_channels(data)
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['channels'] = self.relay_channels
return json.dumps(json_dict)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes(
[COMMAND_CODE,
self.channels_to_byte(self.relay_channels)])
velbus.register_command(COMMAND_CODE, SwitchRelayOnMessage)
def is_on(self):
"""
:return: bool
"""
return self.status == RELAY_ON
def is_off(self):
"""
:return: bool
"""
return self.status == RELAY_OFF
def has_interval_timer_on(self):
"""
:return: bool
"""
return self.status == INTERVAL_TIMER_ON
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channels_to_byte([self.channel]), self.disable_inhibit_forced,
self.status, self.led_status
]) + struct.pack('>L', self.delay_time)[-3:]
velbus.register_command(COMMAND_CODE, RelayStatusMessage)
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 4)
self.set_attributes(priority, address, rtr)
self.closed = self.byte_to_channels(data[0])
self.led_on = self.byte_to_channels(data[1])
self.led_slow_blinking = self.byte_to_channels(data[2])
self.led_fast_blinking = self.byte_to_channels(data[3])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channels_to_byte(self.closed),
self.channels_to_byte(self.led_on),
self.channels_to_byte(self.led_slow_blinking),
self.channels_to_byte(self.led_fast_blinking)
])
velbus.register_command(COMMAND_CODE, ModuleStatusMessage)
def set_defaults(self, address):
if address is not None:
self.set_address(address)
self.set_high_priority()
self.set_no_rtr()
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_high_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 4)
self.set_attributes(priority, address, rtr)
self.relay_channels = self.byte_to_channels(data)
(self.delay_time, ) = struct.unpack('>L', bytes([0]) + data[1:])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channels_to_byte(self.relay_channels)]) + \
struct.pack('>L', self.delay_time)[-3:]
velbus.register_command(COMMAND_CODE, StartRelayTimerMessage)
self.pulses = (data[0] >> 2) * 100
self.counter = (data[1] << 24) + (data[2] << 16) + (
data[3] << 8) + data[4]
self.kwh = float(float(self.counter) / self.pulses)
self.delay = (data[5] << 8) + data[6]
self.watt = float((1000 * 1000 * 3600) / (self.delay * self.pulses))
if self.watt < 55:
self.watt = 0
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['pulses'] = self.pulses
json_dict['counter'] = self.counter
json_dict['kwh'] = self.kwh
json_dict['delay'] = self.delay
json_dict['watt'] = self.watt
json_dict['channel'] = self.channel
return json.dumps(json_dict)
def get_channels(self):
"""
:return: list
"""
return self.channel
velbus.register_command(COMMAND_CODE, CounterStatusMessage, 'VMB7IN')
class SetLedMessage(velbus.Message):
"""
send by: VMB4RYLD
received by: VMB6IN
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.leds = []
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 1)
self.set_attributes(priority, address, rtr)
self.leds = self.byte_to_channels(data[0])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, self.channels_to_byte(self.leds)])
velbus.register_command(COMMAND_CODE, SetLedMessage)
self.led_slow_blinking = []
self.led_fast_blinking = []
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 3)
self.set_attributes(priority, address, rtr)
self.led_on = self.byte_to_channels(data[0])
self.led_slow_blinking = self.byte_to_channels(data[1])
self.led_fast_blinking = self.byte_to_channels(data[2])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channels_to_byte(self.led_on),
self.channels_to_byte(self.led_slow_blinking),
self.channels_to_byte(self.led_fast_blinking)
])
velbus.register_command(COMMAND_CODE, UpdateLedStatusMessage)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 7)
self.set_attributes(priority, address, rtr)
self.channel = data[0]
self.name = "".join([chr(x) for x in data[1:]])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channel,
]) + bytes(self.name, 'utf-8')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message)
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMBGP1')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMBGP2')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMBGP4')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMBGP0')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMBGPOD')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMB1BL')
velbus.register_command(COMMAND_CODE, ChannelNamePart1Message2, 'VMB2BL')
class ChannelNameRequestMessage(velbus.Message):
"""
send by:
received by: VMB6IN, VMB4RYLD
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.channels = []
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 1)
self.set_attributes(priority, address, rtr)
self.channels = self.byte_to_channels(data[0])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, self.channels_to_byte(self.channels)])
velbus.register_command(COMMAND_CODE, ChannelNameRequestMessage)
self.needs_valid_channel(self.channel, 2)
self.logger.debug("Setting channel to %s",
str(self.byte_to_channel(data[0])))
(self.delay_time, ) = struct.unpack('>L', bytes([0]) + data[1:])
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['channel'] = self.channel
json_dict['delay_time'] = self.delay_time
return json.dumps(json_dict)
def set_defaults(self, address):
if address is not None:
self.set_address(address)
self.set_high_priority()
self.set_no_rtr()
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE,
self.channels_to_byte([self.channel])]) + struct.pack(
'>L', self.delay_time)[-3:]
velbus.register_command(COMMAND_CODE, CoverUpMessage)
class VeryFastBlinkingLedMessage(velbus.Message):
"""
send by: VMB4RYLD
received by: VMB6IN
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.leds = []
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 1)
self.set_attributes(priority, address, rtr)
self.leds = self.byte_to_channels(data[0])
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, self.channels_to_byte(self.leds)])
velbus.register_command(COMMAND_CODE, VeryFastBlinkingLedMessage)
received by: VMB4RYLD
"""
def __init__(self, address=None, sleep=0):
velbus.Message.__init__(self)
self.sleep = sleep
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
self.needs_no_rtr(rtr)
self.set_attributes(priority, address, rtr)
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['sleep_time'] = self.sleep
return json.dumps(json_dict)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, 0x00, 0x00])
velbus.register_command(COMMAND_CODE, SwitchToDayMessage)
received by: VMB4RYLD
"""
def __init__(self, address=None, sleep=0):
velbus.Message.__init__(self)
self.sleep = sleep
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
self.needs_no_rtr(rtr)
self.set_attributes(priority, address, rtr)
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['sleep_time'] = self.sleep
return json.dumps(json_dict)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, 0x00, 0x00])
velbus.register_command(COMMAND_CODE, SwitchToComfortMessage)
"""
:author: Thomas Delaet <*****@*****.**>
"""
import velbus
COMMAND_CODE = 0x0e
class InterfaceStatusRequestMessage(velbus.Message):
"""
send by: VMB1USB
received by:
"""
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_no_data(data)
self.set_attributes(priority, address, rtr)
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE])
velbus.register_command(COMMAND_CODE, InterfaceStatusRequestMessage)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 4)
self.set_attributes(priority, address, rtr)
self.module_type = data[0]
(self.serial, ) = struct.unpack('>L', bytes([0, 0, data[1], data[2]]))
self.memory_map_version = data[3]
if len(data) > 4:
self.build_year = data[4]
self.build_week = data[5]
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE, self.module_type,
self.channels_to_byte(self.led_on),
self.channels_to_byte(self.led_slow_blinking),
self.channels_to_byte(self.led_fast_blinking), self.build_year,
self.build_week
])
velbus.register_command(COMMAND_CODE, ModuleTypeMessage)
(self.delay_time, ) = struct.unpack('>L', bytes([0]) + data[1:])
def to_json(self):
"""
:return: str
"""
json_dict = self.to_json_basic()
json_dict['channel'] = self.channel
json_dict['delay_time'] = self.delay_time
return json.dumps(json_dict)
def set_defaults(self, address):
if address is not None:
self.set_address(address)
self.set_high_priority()
self.set_no_rtr()
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE,
self.channels_to_byte([self.channel])]) + struct.pack(
'>L', self.delay_time)[-3:]
velbus.register_command(COMMAND_CODE, CoverUpMessage2, 'VMB1BL')
velbus.register_command(COMMAND_CODE, CoverUpMessage2, 'VMB2BL')
velbus.register_command(COMMAND_CODE, CoverUpMessage, 'VMB1BLE')
velbus.register_command(COMMAND_CODE, CoverUpMessage, 'VMB2BLE')
def is_up(self):
"""
:return: bool
"""
return self.status == BLIND_UP
def is_down(self):
"""
:return: bool
"""
return self.status == BLIND_OFF
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([
COMMAND_CODE,
self.channels_to_byte([self.channel]),
self.timeout,
self.status,
self.led_status,
self.blind_position,
self.locked_inhibit_forced,
self.alarm_auto_mode_selection
])
velbus.register_command(COMMAND_CODE, BlindStatusMessage)
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.high_address = 0x00
self.low_address = 0x00
self.data = ""
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 6)
self.set_attributes(priority, address, rtr)
self.high_address = data[0]
self.low_address = data[1]
self.data = data[2:]
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, self.high_address, self.low_address] +
self.data)
velbus.register_command(COMMAND_CODE, WriteMemoryBlockMessage)
"""
send by:
received by: VMB4RYLD
"""
def __init__(self, address=None):
velbus.Message.__init__(self)
self.high_address = 0x00
self.low_address = 0x00
self.set_defaults(address)
def populate(self, priority, address, rtr, data):
"""
:return: None
"""
assert isinstance(data, bytes)
self.needs_low_priority(priority)
self.needs_no_rtr(rtr)
self.needs_data(data, 2)
self.set_attributes(priority, address, rtr)
self.low_address = data[1]
self.high_address = data[0]
def data_to_binary(self):
"""
:return: bytes
"""
return bytes([COMMAND_CODE, self.high_address, self.low_address])
velbus.register_command(COMMAND_CODE, ReadDataBlockFromMemoryMessage)
