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)