def do_GET(self):
#logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
#logging.info("GET request Path: %s\n", str(self.path))
self._set_response()
#self.wfile.write("GET request for {}".format(self.path).encode('utf-8'))
if self.path == "/":
self.wfile.write(
"Commands available to send to {} / {} / type: 0x{}: <br /><br />"
.format(broadlinkconfig.host, broadlinkconfig.mac,
format(broadlinkconfig.type, '02x')).encode('utf-8'))
for command in irconfig.commands:
self.wfile.write("<a href=/{}>{}</a><br />".format(
command, command).encode('utf-8'))
else:
#self.wfile.write("command:".encode('utf-8'))
command = self.path.replace('/', '')
#type = 0x2737
#host = "192.168.1.1"
#mac = bytearray.fromhex("abcdef")
dev = broadlink.gendevice(broadlinkconfig.type,
(broadlinkconfig.host, 80),
bytearray.fromhex(broadlinkconfig.mac))
dev.auth()
payload = get_command_data(command, 1)
dev.send_data(payload)
self.wfile.write(
"command <b>{}</b> send<br />".format(command).encode('utf-8'))
self.wfile.write(
"<br /><a href=/>Return to index</a>".encode('utf-8'))
self.wfile.write("<br /><br />end of document".encode('utf-8'))
def _learn_new_IR_command(self, values, type_id, did):
""" Devices.xml Callback Method to learn a new command. """
dev = indigo.devices[did]
# If an address was provided, use it, otherwise, get it from the props.
addr = values.get("address",
dev.pluginProps.get("address", "127.0.0.1"))
model = values.get("model", dev.pluginProps.get("model", "0x2712"))
cat = values.get("category", dev.pluginProps.get("category", "IR"))
values['rawCommand'] = "- learn failed -"
try:
# Magic.
bl_device = broadlink.gendevice(int(model, 0), (addr, 80),
"000000000000")
bl_device.auth()
bl_device.enter_learning()
except Exception as err:
indigo.server.log(
u"{0}, Error connecting to {1} ({2}): {3}".format(
MODELS[cat][model], dev.name, addr, err),
isError=True)
return values
timeout = int(indigo.activePlugin.pluginPrefs.get("timeout", 8))
data = None
while data is None and timeout > 0:
time.sleep(1)
timeout -= 1
data = bl_device.check_data()
if data:
values['rawCommand'] = ''.join(
format(x, '02x') for x in bytearray(data))
return values
def update_device_states(self, dev):
""" Used to update a single device's state(s).
Currently only captures on/off power state.
"""
addr = dev.pluginProps.get("address", "")
model = dev.pluginProps.get("model", "0x2712")
cat = dev.pluginProps.get("category", "SP")
try:
# This device is not supported in the python-broadlink library, so spoof it as another device.
# TODO: Remove this when https://github.com/mjg59/python-broadlink/issues/142 has a solution.
rmodel = model
model = "0x2711" if model == "0x7547" else model
# Magic.
bl_device = broadlink.gendevice(int(model, 0), (addr, 80),
"000000000000")
bl_device.timeout = indigo.activePlugin.pluginPrefs.get(
"timeout", 8)
bl_device.auth()
state = bl_device.check_power()
except Exception as err:
dev.setErrorStateOnServer(u"Comm Error: {}".format(err))
indigo.server.log(
u"{0}, Error connecting to {1} ({2}): {3}".format(
MODELS[cat][rmodel], dev.name, addr, err),
isError=True)
else:
if dev.pluginProps.get("logActions", True):
indigo.server.log(u"Updated \"{0}\" on:{1} -> on:{2}".format(
dev.name, dev.states["onOffState"], state))
dev.updateStateOnServer("onOffState", state)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""装载实体."""
host = config['host']
mac = bytearray.fromhex(config['mac'])
dev = broadlink.gendevice(type, (host, 80), mac)
o = Rmmin3(hass, dev)
add_devices([o])
def gen_device(self, dev_data):
dev_type, host, mac = dev_data["type"], dev_data["host"], bytearray.fromhex(
dev_data["mac"])
dev = broadlink.gendevice(int(dev_type, 0), (host, 80), mac)
if not dev.auth():
raise falcon.HTTPBadRequest("device auth failed.")
return dev
def __init__(self, device_name: str, devtype: int, host: str, mac: str):
self.name = device_name
self.device = broadlink.gendevice(devtype, (host, 80), mac)
self.device.auth()
log.debug(
f'Created device \'{device_name}\' with details 0x{devtype:02x} {host} {mac}'
)
def main():
""" Send a command. """
device = broadlink.gendevice(int(DEVICE_ID, 0), (DEVICE_IP, 80),
"000000000000")
print("Sending command to {}".format(DEVICE_IP))
device.auth()
data = bytearray.fromhex(''.join(IR_COMMAND))
device.send_data(data)
def initDevice(dtype, host, mac):
dtypeTmp = dtype
if dtypeTmp == '0x6539':
dtypeTmp = '0x610F'
_dtype = int(dtypeTmp, 0)
_host = host
_mac = bytearray.fromhex(mac)
return broadlink.gendevice(_dtype, (_host, 80), _mac)
def __init__(self, args):
if not broadlink:
raise Exception("broadlink module not available")
devtype, host, mac = args.split(":")
devtype = int(devtype, 0)
mac = bytearray.fromhex(mac)
self.dev = broadlink.gendevice(devtype, (host, 80), mac)
self.dev.auth()
def main():
""" Send a command. """
rm_pro_dev = broadlink.gendevice(int(RM_PRO_PLUS_DEV, 0), (DEVICE_IP, 80),
"000000000000")
print "sending command to " + DEVICE_IP
rm_pro_dev.auth()
data = bytearray.fromhex(''.join(IR_COMMAND))
rm_pro_dev.send_data(data)
def br_init(): global BROADLINK DEVICE = y[config]["device"] HOST = y[config]["RMhost"] MACR = y[config]["macreverse"] mac = bytearray.fromhex(MACR) BROADLINK = broadlink.gendevice(DEVICE, (HOST, 80), mac) BROADLINK.auth() return
def select_device(ip, mac, port='80', type_='10039'):
host = (ip, int(port))
type_ = hex(int(type_))
type_ = int(type_, 16)
if not isinstance(mac, bytearray):
mac = bytearray.fromhex(mac)
device = broadlink.gendevice(type_, host, mac)
return device
async def async_setup(self):
"""Set up the device and related entities."""
config = self.config
api = blk.gendevice(
config.data[CONF_TYPE],
(config.data[CONF_HOST], DEFAULT_PORT),
bytes.fromhex(config.data[CONF_MAC]),
name=config.title,
)
api.timeout = config.data[CONF_TIMEOUT]
self.api = api
try:
await self.hass.async_add_executor_job(api.auth)
except AuthenticationError:
await self._async_handle_auth_error()
return False
except (NetworkTimeoutError, OSError) as err:
raise ConfigEntryNotReady from err
except BroadlinkException as err:
_LOGGER.error(
"Failed to authenticate to the device at %s: %s", api.host[0], err
)
return False
self.authorized = True
update_manager = get_update_manager(self)
coordinator = update_manager.coordinator
await coordinator.async_refresh()
if not coordinator.last_update_success:
raise ConfigEntryNotReady()
self.update_manager = update_manager
self.hass.data[DOMAIN].devices[config.entry_id] = self
self.reset_jobs.append(config.add_update_listener(self.async_update))
try:
self.fw_version = await self.hass.async_add_executor_job(api.get_fwversion)
except (BroadlinkException, OSError):
pass
# Forward entry setup to related domains.
tasks = (
self.hass.config_entries.async_forward_entry_setup(config, domain)
for domain in get_domains(self.api.type)
)
for entry_setup in tasks:
self.hass.async_create_task(entry_setup)
return True
async def async_step_reauth(self, data):
"""Reauthenticate to the device."""
device = blk.gendevice(
data[CONF_TYPE],
(data[CONF_HOST], DEFAULT_PORT),
bytes.fromhex(data[CONF_MAC]),
name=data[CONF_NAME],
)
device.timeout = data[CONF_TIMEOUT]
await self.async_set_device(device)
return await self.async_step_reset()
def get_devices(self):
if len(self.config['devices']) == 0:
return broadlink.discover(timeout=self.get('lookup_timeout', 5))
ds = []
for d in self.config['devices']:
mac = bytearray.fromhex(d['mac'].replace(':', ' '))
dev = broadlink.gendevice(host=(d['host'], 80),
mac=mac,
devtype=0x4EAD)
ds.append(dev)
return ds
def get_rmmini_info(rmmini_id):
# DBのデータからホスト情報を作成
rmmini_info = db.session.query(Rmmini).filter(
Rmmini.id == rmmini_id).first()
device = broadlink.gendevice(rmmini_info.devtype, (rmmini_info.host, 80),
bytearray.fromhex(rmmini_info.mac_address))
db.session.close()
if device.auth():
return device
else:
return False
def Connect_Broadlink():
host = request.args.get('host')
type = int(request.args.get('type'), 16)
mac = bytearray.fromhex(request.args.get('mac'))
print("host, type, mac:", host, type, mac)
dev = broadlink.gendevice(type, (host, 80), mac)
print("We have a device")
dev.auth()
print('dev=', dev)
return dev
async def async_step_reauth(self, entry_data: Mapping[str,
Any]) -> FlowResult:
"""Reauthenticate to the device."""
device = blk.gendevice(
entry_data[CONF_TYPE],
(entry_data[CONF_HOST], DEFAULT_PORT),
bytes.fromhex(entry_data[CONF_MAC]),
name=entry_data[CONF_NAME],
)
device.timeout = entry_data[CONF_TIMEOUT]
await self.async_set_device(device)
return await self.async_step_reset()
def command():
dtype = int(request.args.get('type'), 0)
host = request.args.get('host')
mac = bytearray.fromhex(request.args.get('mac'))
dev = broadlink.gendevice(dtype, (host, 80), mac)
command = request.args.get('command')
dev.auth()
try:
dev.send_data(bytearray.fromhex(''.join(command)))
return jsonify('{"data":"","success":1,"message":"Command sent successfully"}')
except:
return jsonify('{"data":"","success":0,"message":"Error occurred while Sending command!"}')
def sweep():
global _continu_to_sweep
global _rf_sweep_message
global _rf_sweep_status
_continu_to_sweep=False
_rf_sweep_message=''
_rf_sweep_status=False
dtype = int(request.args.get('type'), 0)
host = request.args.get('host')
mac = bytearray.fromhex(request.args.get('mac'))
dev = broadlink.gendevice(dtype, (host, 80), mac)
dev.auth()
dev.sweep_frequency()
_rf_sweep_message = "Learning RF Frequency, press and hold the button to learn..."
start = time.time()
while time.time() - start < TIMEOUT:
time.sleep(1)
if dev.check_frequency():
break
else:
_rf_sweep_message = "RF Frequency not found!"
dev.cancel_sweep_frequency()
return jsonify('{"data":"RF Frequency not found!","success":0}')
_rf_sweep_message = "Found RF Frequency - 1 of 2!"
time.sleep(1)
_rf_sweep_message = "You can now let go of the button"
_rf_sweep_status=True
while _continu_to_sweep == False:
_rf_sweep_message = "Click The Continue button"
_rf_sweep_message = "To complete learning, single press the button you want to learn"
_rf_sweep_status=False
dev.find_rf_packet()
start = time.time()
while time.time() - start < TIMEOUT:
time.sleep(1)
try:
data = dev.check_data()
except (ReadError, StorageError):
continue
else:
break
else:
_rf_sweep_message = "No Data Found"
return jsonify('{"data":"No Data Found"}')
_rf_sweep_message = "Found RF Frequency - 2 of 2!"
learned = ''.join(format(x, '02x') for x in bytearray(data))
_rf_sweep_message = "RF Scan Completed Successfully"
time.sleep(1)
return jsonify('{"data":"' + learned + '"}')
def actionControlDevice(self, action, dev):
""" Callback Method to Control a SP Device. """
if action.deviceAction in [
indigo.kUniversalAction.RequestStatus,
indigo.kUniversalAction.EnergyUpdate
]:
self.update_device_states(dev)
addr = dev.pluginProps.get("address", "")
model = dev.pluginProps.get("model", "0x2711")
cat = dev.pluginProps.get("category", "SP")
try:
# This device is not supported in the python-broadlink library, so spoof it as another device.
# TODO: Remove this when https://github.com/mjg59/python-broadlink/issues/142 has a solution.
rmodel = model
model = "0x2711" if model == "0x7547" else model
# Magic.
bl_device = broadlink.gendevice(int(model, 0), (addr, 80),
"000000000000")
bl_device.auth()
except Exception as err:
indigo.server.log(
u"{0}, Error connecting to {1} ({2}): {3}".format(
MODELS[cat][rmodel], dev.name, addr, err),
isError=True)
return
control_device = False
if action.deviceAction == indigo.kDeviceAction.TurnOn:
power_state, reply, control_device = True, "On", True
elif action.deviceAction == indigo.kDeviceAction.TurnOff:
power_state, reply, control_device = False, "Off", True
elif action.deviceAction == indigo.kDeviceAction.Toggle:
# Get current state from device before toggling.
power_state = not bl_device.check_power()
reply = "On" if power_state else "Off"
control_device = True
elif action.deviceAction == indigo.kDeviceAction.AllLightsOff:
if dev.pluginProps.get("supportsAllLights", False):
power_state, reply, control_device = False, "Off", True
elif action.deviceAction == indigo.kDeviceAction.AllLightsOn:
if dev.pluginProps.get("supportsAllLights", False):
power_state, reply, control_device = True, "On", True
elif action.deviceAction == indigo.kDeviceAction.AllOff:
if dev.pluginProps.get("supportsAllOff", False):
power_state, reply, control_device = False, "Off", True
if control_device:
bl_device.set_power(power_state)
dev.updateStateOnServer("onOffState", power_state)
if dev.pluginProps.get("logActions", True):
indigo.server.log(u"Sent \"{0}\" {1}".format(dev.name, reply))
def update_relays_devices(self, addrs, devs):
""" Updates Indigo with current SP and SC devices' states. Called from set_all_device_states() """
for (addr, model, cat) in addrs:
# This device is not supported in the python-broadlink library, so spoof it as another device.
# TODO: Remove this when https://github.com/mjg59/python-broadlink/issues/142 has a solution.
rmodel = model
model = "0x2711" if model == "0x7547" else model
bl_device = broadlink.gendevice(int(model, 0), (addr, 80),
"000000000000")
bl_device.timeout = indigo.activePlugin.pluginPrefs.get(
"timeout", 8)
energy = 0.0
try:
# Magic.
bl_device.auth()
state = bl_device.check_power()
try:
energy = bl_device.get_energy()
except AttributeError:
energy = 0.0
except Exception as err:
for dev in devs:
# Update all the sub devices that failed to get queried.
if (dev.pluginProps["address"],
dev.pluginProps["model"]) == (addr, model):
dev.setErrorStateOnServer(
u"Comm Error: {} -> {}".format(addr, err))
if indigo.activePlugin.pluginPrefs.get(
"logUpdateErrors", True):
indigo.server.log(
u"{0}, Error communicating with {1} ({2}): {3}"
.format(MODELS[cat][rmodel], dev.name, addr,
err),
isError=True)
else:
# Match this address back to the device(s) and update the state(s).
for dev in devs:
if (dev.pluginProps["address"],
dev.pluginProps["model"]) == (addr, model):
dev.updateStateOnServer("onOffState", state)
if "curEnergyLevel" in dev.states:
dev.updateStateOnServer("curEnergyLevel", energy)
if (dev.states["onOffState"] != state
and dev.pluginProps.get("logChanges", True)):
reply = "On" if state else "Off"
indigo.server.log(
u"Device \"{}\" turned {}".format(
dev.name, reply))
def sendIrCode(self, hermes, intent_message, code, subappliance=None):
house_rooms = self.extractHouseRooms(intent_message)
appliances = self.extractAppliances(intent_message)
global allAppliances
global allRooms
if len(house_rooms) == 0:
house_rooms.append(self.defaultRoom)
if len(appliances) == 0:
appliances.append(self.defaultAppliance)
for appliance in appliances:
for room in house_rooms:
if appliance not in allAppliances:
hermes.publish_start_session_notification(
intent_message.site_id, "Cet appareil nexiste pas", "")
return False
print "[Room]: " + room
print "[Appliance]: " + appliance
cmd = "./remotes/" + room + "/" + appliance + "/"
if subappliance != None:
cmd = cmd + subappliance + "/"
cmd = cmd + code
if not os.path.isfile(cmd):
hermes.publish_start_session_notification(
intent_message.site_id, "Cet appareil nexiste pas", "")
return False
contents = Path(cmd).read_text()
data = bytearray.fromhex(''.join(contents))
dev = broadlink.gendevice(0x2737, (allRooms[room]["ip"], 80),
allRooms[room]["mac"])
dev.auth()
dev.send_data(data)
return True
async def async_setup(self):
"""Set up the device and related entities."""
config = self.config
api = blk.gendevice(
config.data[CONF_TYPE],
(config.data[CONF_HOST], DEFAULT_PORT),
bytes.fromhex(config.data[CONF_MAC]),
name=config.title,
)
api.timeout = config.data[CONF_TIMEOUT]
self.api = api
try:
self.fw_version = await self.opp.async_add_executor_job(
self._auth_fetch_firmware)
except AuthenticationError:
await self._async_handle_auth_error()
return False
except (NetworkTimeoutError, OSError) as err:
raise ConfigEntryNotReady from err
except BroadlinkException as err:
_LOGGER.error("Failed to authenticate to the device at %s: %s",
api.host[0], err)
return False
self.authorized = True
update_manager = get_update_manager(self)
coordinator = update_manager.coordinator
await coordinator.async_config_entry_first_refresh()
self.update_manager = update_manager
self.opp.data[DOMAIN].devices[config.entry_id] = self
self.reset_jobs.append(config.add_update_listener(self.async_update))
# Forward entry setup to related domains.
self.opp.config_entries.async_setup_platforms(
config, get_domains(self.api.type))
return True
def main():
""" Read a command. """
rm_pro_dev = broadlink.gendevice(int(RM_PRO_PLUS_DEV, 0), (DEVICE_IP, 80),
"000000000000")
print "reading command from " + DEVICE_IP
rm_pro_dev.auth()
rm_pro_dev.enter_learning()
data = None
print "Learning..."
timeout = 30
while (data is None) and (timeout > 0):
time.sleep(1)
timeout -= 1
data = rm_pro_dev.check_data()
if data:
print ''.join(format(x, '02x') for x in bytearray(data))
def learnir():
dtype = int(request.args.get('type'), 0)
host = request.args.get('host')
mac = bytearray.fromhex(request.args.get('mac'))
dev = broadlink.gendevice(dtype, (host, 80), mac)
dev.auth()
dev.enter_learning()
start = time.time()
while time.time() - start < TIMEOUT:
time.sleep(1)
try:
data = dev.check_data()
except (ReadError, StorageError):
continue
else:
break
else:
return jsonify('{"data":"","success":0,"message":"No Data Recived"}')
learned = ''.join(format(x, '02x') for x in bytearray(data))
return jsonify('{"data":"' + learned + '","success":1,"message":"IR Data Recived"}')
def main():
""" Read a command from an RM/RM2/RM3/RMmini. """
device = broadlink.gendevice(int(DEVICE_ID, 0), (DEVICE_IP, 80),
"000000000000")
print("reading command from {}".format(DEVICE_IP))
device.auth()
device.enter_learning()
data = None
print("Learning... (push a button)")
timeout = 30
while (data is None) and (timeout > 0):
time.sleep(1)
timeout -= 1
data = device.check_data()
if data:
print("Captured command!")
print("".join(format(x, "02x") for x in bytearray(data)))
def on_message(client, userdata, msg):
now = datetime.datetime.now()
logging.info(" {} {} {}".format(now.strftime("%Y-%m-%d %H:%M:%S.%f"),
msg.topic, msg.payload))
if msg.topic == TOPIC_POWER:
if msg.payload in (b"true", "true"):
print("ON")
daikin_message.power = Power.ON
else:
print("OFF")
daikin_message.power = Power.OFF
if msg.topic == TOPIC_TEMPERATURE:
daikin_message.temperature = int(msg.payload)
daikin_message.recreate_blocks()
logging.info("mensaje <{}>".format(daikin_message))
client = Daikin()
durations = client.message_to_durations(daikin_message)
bl = utils.durations_to_broadlink(durations)
dev = broadlink.gendevice(BROADLINK_DEVICE_TYPE, (BROADLINK_HOST, 80),
BROADLINK_MAC)
dev.auth()
dev.send_data(bl)
def connect_broadlink(self):
"""
Connect to the known Broadlink device and Authenticate.
device = gendevice(devtype, host, mac, name=name, cloud=cloud)
devtype = 0x27a9 = (rm, "RM pro+", "Broadlink") <-- from broadlink.__init__.py
host = 192.168.2.15 (DHCP reservation), port 80
mac = 78:0f:77:63:5a:25 Convert to bytes = b'x\x0fwcZ%'
"""
d = broadlink.gendevice(0x27a9, ('192.168.2.16', 80),
b'x\x0fwcZ%',
name='Apt',
cloud=False)
try:
result = d.auth()
self.setDriver('GV0', 1)
LOGGER.info(
'Successful Connection and Authentication to Broadlink @ 192.168.2.16.'
)
except:
self.setDriver('GV0', 0)
LOGGER.info('Unable to connect to Broadlink @ 192.168.2.16.')
return d if result else None
def main():
""" Read Device State. """
device = broadlink.gendevice(int(DEVICE_ID, 0), (DEVICE_IP, 80),
"000000000000")
print("Checking State: {}".format(DEVICE_IP))
# Not sure why this fails on python 3.7
device.auth()
state = device.check_power()
print("Current State: {}".format(state))
try:
energy = device.get_energy()
print("Energy State: {}".format(energy))
except ValueError:
# May not support energy metering.
pass
print("Turning device off.")
device.set_power(False)
print("Sleeping 5 seconds.")
time.sleep(5)
print("Turning device on.")
device.set_power(True)
