def raw_command(dev: miio.ChuangmiPlug, cmd, parameters):
"""Run a raw command."""
params = [] # type: Any
if parameters:
params = ast.literal_eval(parameters)
click.echo("Sending cmd %s with params %s" % (cmd, params))
click.echo(dev.raw_command(cmd, params))
def status(dev: miio.ChuangmiPlug):
"""Returns the state information."""
res = dev.status()
if not res:
return # bail out
click.echo(click.style("Power: %s" % res.power, bold=True))
click.echo("Temperature: %s" % res.temperature)
class SmartPlug:
def __init__(self):
self.ip = get_ip(settings["mac"])
self.plug = ChuangmiPlug(self.ip, settings["token"])
def on(self):
self.plug.on()
def off(self):
self.plug.off()
def status(self):
return self.plug.status()
def isAlive(self):
try:
s = self.status()
return True
except:
return False
def isOn(self):
return self.plug.status().is_on
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the switch from config."""
from miio import Device, DeviceException
if DATA_KEY not in hass.data:
hass.data[DATA_KEY] = {}
host = config.get(CONF_HOST)
name = config.get(CONF_NAME)
token = config.get(CONF_TOKEN)
model = config.get(CONF_MODEL)
_LOGGER.info("Initializing with host %s (token %s...)", host, token[:5])
devices = []
unique_id = None
if model is None:
try:
miio_device = Device(host, token)
device_info = miio_device.info()
model = device_info.model
unique_id = "{}-{}".format(model, device_info.mac_address)
_LOGGER.info("%s %s %s detected", model,
device_info.firmware_version,
device_info.hardware_version)
except DeviceException:
raise PlatformNotReady
if model in ['chuangmi.plug.v1', 'chuangmi.plug.v3']:
from miio import ChuangmiPlug
plug = ChuangmiPlug(host, token, model=model)
# The device has two switchable channels (mains and a USB port).
# A switch device per channel will be created.
for channel_usb in [True, False]:
device = ChuangMiPlugSwitch(name, plug, model, unique_id,
channel_usb)
devices.append(device)
hass.data[DATA_KEY][host] = device
elif model in ['qmi.powerstrip.v1', 'zimi.powerstrip.v2']:
from miio import PowerStrip
plug = PowerStrip(host, token, model=model)
device = XiaomiPowerStripSwitch(name, plug, model, unique_id)
devices.append(device)
hass.data[DATA_KEY][host] = device
elif model in ['chuangmi.plug.m1', 'chuangmi.plug.v2']:
from miio import ChuangmiPlug
plug = ChuangmiPlug(host, token, model=model)
device = XiaomiPlugGenericSwitch(name, plug, model, unique_id)
devices.append(device)
hass.data[DATA_KEY][host] = device
else:
_LOGGER.error(
'Unsupported device found! Please create an issue at '
'https://github.com/rytilahti/python-miio/issues '
'and provide the following data: %s', model)
return False
async_add_entities(devices, update_before_add=True)
async def async_service_handler(service):
"""Map services to methods on XiaomiPlugGenericSwitch."""
method = SERVICE_TO_METHOD.get(service.service)
params = {
key: value
for key, value in service.data.items() if key != ATTR_ENTITY_ID
}
entity_ids = service.data.get(ATTR_ENTITY_ID)
if entity_ids:
devices = [
device for device in hass.data[DATA_KEY].values()
if device.entity_id in entity_ids
]
else:
devices = hass.data[DATA_KEY].values()
update_tasks = []
for device in devices:
if not hasattr(device, method['method']):
continue
await getattr(device, method['method'])(**params)
update_tasks.append(device.async_update_ha_state(True))
if update_tasks:
await asyncio.wait(update_tasks, loop=hass.loop)
for plug_service in SERVICE_TO_METHOD:
schema = SERVICE_TO_METHOD[plug_service].get('schema', SERVICE_SCHEMA)
hass.services.async_register(DOMAIN,
plug_service,
async_service_handler,
schema=schema)
async def async_setup_other_entry(hass, config_entry, async_add_entities):
"""Set up the other type switch from a config entry."""
entities = []
host = config_entry.data[CONF_HOST]
token = config_entry.data[CONF_TOKEN]
name = config_entry.title
model = config_entry.data[CONF_MODEL]
unique_id = config_entry.unique_id
if config_entry.data[CONF_FLOW_TYPE] == CONF_GATEWAY:
gateway = hass.data[DOMAIN][config_entry.entry_id][CONF_GATEWAY]
# Gateway sub devices
sub_devices = gateway.devices
coordinator = hass.data[DOMAIN][config_entry.entry_id][KEY_COORDINATOR]
for sub_device in sub_devices.values():
if sub_device.device_type != "Switch":
continue
switch_variables = set(sub_device.status) & set(GATEWAY_SWITCH_VARS)
if switch_variables:
entities.extend(
[
XiaomiGatewaySwitch(
coordinator, sub_device, config_entry, variable
)
for variable in switch_variables
]
)
if config_entry.data[CONF_FLOW_TYPE] == CONF_DEVICE or (
config_entry.data[CONF_FLOW_TYPE] == CONF_GATEWAY
and model == "lumi.acpartner.v3"
):
if DATA_KEY not in hass.data:
hass.data[DATA_KEY] = {}
_LOGGER.debug("Initializing with host %s (token %s...)", host, token[:5])
if model in ["chuangmi.plug.v1", "chuangmi.plug.v3", "chuangmi.plug.hmi208"]:
plug = ChuangmiPlug(host, token, model=model)
# The device has two switchable channels (mains and a USB port).
# A switch device per channel will be created.
for channel_usb in (True, False):
if channel_usb:
unique_id_ch = f"{unique_id}-USB"
else:
unique_id_ch = f"{unique_id}-mains"
device = ChuangMiPlugSwitch(
name, plug, config_entry, unique_id_ch, channel_usb
)
entities.append(device)
hass.data[DATA_KEY][host] = device
elif model in ["qmi.powerstrip.v1", "zimi.powerstrip.v2"]:
plug = PowerStrip(host, token, model=model)
device = XiaomiPowerStripSwitch(name, plug, config_entry, unique_id)
entities.append(device)
hass.data[DATA_KEY][host] = device
elif model in [
"chuangmi.plug.m1",
"chuangmi.plug.m3",
"chuangmi.plug.v2",
"chuangmi.plug.hmi205",
"chuangmi.plug.hmi206",
]:
plug = ChuangmiPlug(host, token, model=model)
device = XiaomiPlugGenericSwitch(name, plug, config_entry, unique_id)
entities.append(device)
hass.data[DATA_KEY][host] = device
elif model in ["lumi.acpartner.v3"]:
plug = AirConditioningCompanionV3(host, token)
device = XiaomiAirConditioningCompanionSwitch(
name, plug, config_entry, unique_id
)
entities.append(device)
hass.data[DATA_KEY][host] = device
else:
_LOGGER.error(
"Unsupported device found! Please create an issue at "
"https://github.com/rytilahti/python-miio/issues "
"and provide the following data: %s",
model,
)
async def async_service_handler(service):
"""Map services to methods on XiaomiPlugGenericSwitch."""
method = SERVICE_TO_METHOD.get(service.service)
params = {
key: value
for key, value in service.data.items()
if key != ATTR_ENTITY_ID
}
entity_ids = service.data.get(ATTR_ENTITY_ID)
if entity_ids:
devices = [
device
for device in hass.data[DATA_KEY].values()
if device.entity_id in entity_ids
]
else:
devices = hass.data[DATA_KEY].values()
update_tasks = []
for device in devices:
if not hasattr(device, method["method"]):
continue
await getattr(device, method["method"])(**params)
update_tasks.append(device.async_update_ha_state(True))
if update_tasks:
await asyncio.wait(update_tasks)
for plug_service, method in SERVICE_TO_METHOD.items():
schema = method.get("schema", SERVICE_SCHEMA)
hass.services.async_register(
DOMAIN, plug_service, async_service_handler, schema=schema
)
async_add_entities(entities)
import os
from miio import ChuangmiPlug
import logging
ip = os.environ['OGONKI_IP']
token = os.environ['OGONKI_TOKEN']
plug = ChuangmiPlug(ip=ip, token=token, debug=True)
def query(capability_type, instance):
if capability_type == "devices.capabilities.on_off":
return plug.status().power
def action(capability_type, instance, value, relative):
if capability_type == "devices.capabilities.on_off":
if value:
plug.on()
else:
plug.off()
return "DONE"
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the switch from config."""
if DATA_KEY not in hass.data:
hass.data[DATA_KEY] = {}
host = config[CONF_HOST]
token = config[CONF_TOKEN]
name = config[CONF_NAME]
model = config.get(CONF_MODEL)
_LOGGER.info("Initializing with host %s (token %s...)", host, token[:5])
devices = []
unique_id = None
if model is None:
try:
miio_device = Device(host, token)
device_info = await hass.async_add_executor_job(miio_device.info)
model = device_info.model
unique_id = f"{model}-{device_info.mac_address}"
_LOGGER.info(
"%s %s %s detected",
model,
device_info.firmware_version,
device_info.hardware_version,
)
except DeviceException as ex:
raise PlatformNotReady from ex
if model in [
"chuangmi.plug.v1", "chuangmi.plug.v3", "chuangmi.plug.hmi208"
]:
plug = ChuangmiPlug(host, token, model=model)
# The device has two switchable channels (mains and a USB port).
# A switch device per channel will be created.
for channel_usb in [True, False]:
device = ChuangMiPlugSwitch(name, plug, model, unique_id,
channel_usb)
devices.append(device)
hass.data[DATA_KEY][host] = device
elif model in ["qmi.powerstrip.v1", "zimi.powerstrip.v2"]:
plug = PowerStrip(host, token, model=model)
device = XiaomiPowerStripSwitch(name, plug, model, unique_id)
devices.append(device)
hass.data[DATA_KEY][host] = device
elif model in [
"chuangmi.plug.m1",
"chuangmi.plug.m3",
"chuangmi.plug.v2",
"chuangmi.plug.hmi205",
"chuangmi.plug.hmi206",
]:
plug = ChuangmiPlug(host, token, model=model)
device = XiaomiPlugGenericSwitch(name, plug, model, unique_id)
devices.append(device)
hass.data[DATA_KEY][host] = device
elif model in ["lumi.acpartner.v3"]:
plug = AirConditioningCompanionV3(host, token)
device = XiaomiAirConditioningCompanionSwitch(name, plug, model,
unique_id)
devices.append(device)
hass.data[DATA_KEY][host] = device
else:
_LOGGER.error(
"Unsupported device found! Please create an issue at "
"https://github.com/rytilahti/python-miio/issues "
"and provide the following data: %s",
model,
)
return False
async_add_entities(devices, update_before_add=True)
async def async_service_handler(service):
"""Map services to methods on XiaomiPlugGenericSwitch."""
method = SERVICE_TO_METHOD.get(service.service)
params = {
key: value
for key, value in service.data.items() if key != ATTR_ENTITY_ID
}
entity_ids = service.data.get(ATTR_ENTITY_ID)
if entity_ids:
devices = [
device for device in hass.data[DATA_KEY].values()
if device.entity_id in entity_ids
]
else:
devices = hass.data[DATA_KEY].values()
update_tasks = []
for device in devices:
if not hasattr(device, method["method"]):
continue
await getattr(device, method["method"])(**params)
update_tasks.append(device.async_update_ha_state(True))
if update_tasks:
await asyncio.wait(update_tasks)
for plug_service in SERVICE_TO_METHOD:
schema = SERVICE_TO_METHOD[plug_service].get("schema", SERVICE_SCHEMA)
hass.services.async_register(DOMAIN,
plug_service,
async_service_handler,
schema=schema)
def off(dev: miio.ChuangmiPlug):
"""Power off."""
click.echo("Power off: %s" % dev.off())
def on(dev: miio.ChuangmiPlug):
"""Power on."""
click.echo("Power on: %s" % dev.on())
sqlite_insert = """INSERT INTO 'timelog'
('stamp', 'temp', 'hum', 'plug', 'heater')
VALUES (?, ?, ?, ?, ?);"""
data_tuple = (cur_time, temp_inp, hum_inp, plug_status, heater_status)
cursor.execute(sqlite_insert, data_tuple)
sqlite_con.commit()
except sqlite3.Error as error:
print("Error while working with sqlite", error)
sensor = Adafruit_DHT.DHT22
# plug
ip_pl = '192.168.1.2'
token_pl = 'e1ef4f9f97aaf257f54270adf2d998f3'
plug = ChuangmiPlug(ip_pl, token_pl, model="chuangmi.plug.m3")
# print(plug.status().is_on)
# heater
ip_h = '192.168.1.26'
token_h = "9881554e0c43a4f45a28823adf3d0825"
heater = ChuangmiPlug(ip_h, token_h, model="chuangmi.plug.m3")
# print(heater.status().is_on)
while True:
try:
status1 = plug.status().is_on
except:
status1 = None
# status1 = responseformat(status1)
import time from miio import ChuangmiPlug # plug ip = '192.168.1.2' token = 'e1ef4f9f97aaf257f54270adf2d998f3' plug = ChuangmiPlug(ip, token, model="chuangmi.plug.m3") print(plug.status().is_on) plug.on() print(plug.status().is_on) time.sleep(5) plug.off() print(plug.status().is_on) # heater ip = '192.168.1.26' token = "9881554e0c43a4f45a28823adf3d0825" plug = ChuangmiPlug(ip, token, model="chuangmi.plug.m3") print(plug.status().is_on) plug.on() print(plug.status().is_on) time.sleep(5) plug.off() print(plug.status().is_on)
def __init__(self):
self.ip = get_ip(settings["mac"])
self.plug = ChuangmiPlug(self.ip, settings["token"])
