def allSwitchesOff():
dehumid = SmartPlug(plugs['Fan'])
dehumid.turn_off()
fan = SmartPlug(plugs['Dehumidifier'])
fan.turn_off()
return 'Hi!'
def command(message):
msgList = message.split('_')
if(msgList[0] == "wifiplug"):
try:
if('add' in msgList[1]):
addNewPlug(int(msgList[2]))
return
id = int(msgList[1]) - 1
print ips[id]
if(msgList[2] == "on"):
plug = SmartPlug(ips[id])
print("Current state: %s" % plug.state)
plug.state = "ON"
return
if(msgList[2] == "off"):
plug = SmartPlug(ips[id])
print("Current state: %s" % plug.state)
plug.state = "OFF"
return
except ValueError:
logging.warning('Invalid command: Incorrect id format')
return
except Exception as e:
logging.warning(e)
return
def changeSmartPlug(self, deviceName, state, command=False):
# Logic for handling sibling devices and turning the current device on or off through a smart plug.
siblingDevice = acChanger.getActuators().get(deviceName).get("siblingDevice")
if state == "ON":
# Logic for substituting sibling devices when the current device has too many consecutive uses
device = acChanger.checkCount(deviceName, siblingDevice, command)
else:
device = deviceName
# If the device is substituted and is on the breadboard,function for handling breadboard devices is called.
if self._actuators.get(device).get("type") != "SmartPlug":
return acChanger.changeBreadBoard(device, state)
else:
# Changing the smart plug state.
try:
if state == "ON":
SmartPlug(self._actuators.get(
device).get("device")).turn_on()
self._actuators.get(device)["ON"] = True
else:
SmartPlug(self._actuators.get(
device).get("device")).turn_off()
self._actuators.get(device)["ON"] = False
return True
except:
return False
def get_static_devices(config_data) -> SmartDevices:
"""Get statically defined devices in the config."""
_LOGGER.debug("Getting static devices")
lights = []
switches = []
for type_ in (CONF_LIGHT, CONF_SWITCH, CONF_STRIP, CONF_DIMMER):
for entry in config_data[type_]:
host = entry["host"]
try:
if type_ == CONF_LIGHT:
lights.append(SmartBulb(host))
elif type_ == CONF_SWITCH:
switches.append(SmartPlug(host))
elif type_ == CONF_STRIP:
for plug in SmartStrip(host).plugs.values():
switches.append(plug)
# Dimmers need to be defined as smart plugs to work correctly.
elif type_ == CONF_DIMMER:
lights.append(SmartPlug(host))
except SmartDeviceException as sde:
_LOGGER.error(
"Failed to setup device %s due to %s; not retrying", host, sde
)
return SmartDevices(lights, switches)
def get_plugs(plugip, plugnames, named_flag):
try:
for dev in Discover.discover():
plugobj = SmartPlug(dev)
plugip[plugobj.alias] = dev
if named_flag is False:
plugnames.append(plugobj.alias)
else:
pass
except:
plugip = {}
plugnames = []
send_twilio_msg('Warning - plug discovery failed')
traceback.print_exc()
return [plugip, plugnames]
def ping_plug(ip_addr):
try:
plug = SmartPlug(ip_addr)
plug.get_sysinfo()
logger.info("Plug %s is up and running!", ip_addr)
except SmartDeviceException:
logger.error("Failed to connect to the plug with IP %s", ip_addr)
def set_plug(name, state, plugdict, plugip, plugnames):
# TODO Not currently used! Trying to encapsulate state call & error checking to pull it out of main
# This is a mess! Need to consolidate get_plugs and probably put everything in a big dict to pass across fxns
# name is the name of the room / plug
# state is the desired state ('ON' or 'OFF')
named_flag = True
plugips = plugip
try:
plugdict[name].state = state
except:
plugips = get_plugs(plugips, plugnames, named_flag)[0]
try:
plugdict[name] = SmartPlug(plugips[name])
except:
print("Communication error in ", name)
return
def cli(ctx, ip, debug, bulb, plug):
"""A cli tool for controlling TP-Link smart home plugs."""
if debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
if ctx.invoked_subcommand == "discover":
return
if ip is None:
click.echo("No IP given, trying discovery..")
ctx.invoke(discover)
return
elif ip is not None:
if not bulb and not plug:
click.echo("No --bulb nor --plug given, discovering..")
devs = ctx.invoke(discover, discover_only=True)
for discovered_ip, discovered_dev in devs:
if discovered_ip == ip:
dev = discovered_dev
break
elif bulb:
dev = SmartBulb(ip)
elif plug:
dev = SmartPlug(ip)
else:
click.echo("Unable to detect type, use --bulb or --plug!")
return
ctx.obj = dev
if ctx.invoked_subcommand is None:
ctx.invoke(state)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the TPLink switch platform."""
from pyHS100 import SmartPlug
host = config.get(CONF_HOST)
name = config.get(CONF_NAME)
add_devices([SmartPlugSwitch(SmartPlug(host), name)], True)
def status(self):
try:
settings.plugins.lights[self.room]
except Exception:
return
try:
self.isOpen(9999)
except Exception:
return
type = settings.plugins.lights[self.room]['type']
if type == 'plug':
emoji = ':electric_plug:'
tplinklight = SmartPlug(
settings.plugins.lights[self.room]['ipaddr'])
else:
emoji = ':bulb:'
type = 'light'
tplinklight = SmartBulb(
settings.plugins.lights[self.room]['ipaddr'])
if eval(os.environ['DEBUG']):
debug = "[{}] ".format(device_name)
else:
debug = ""
room_name = self.room.capitalize()
if room_name.endswith('s'):
room_name = room_name[:-1] + "'" + room_name[-1:]
if tplinklight.state == "OFF":
chat.post("{} {}{} {} is off.".format(emoji, debug, room_name,
type))
else:
chat.post("{} {}{} {} is on.".format(emoji, debug, room_name,
type))
def dev(request):
file = request.param
ip = request.config.getoption("--ip")
if ip:
d = Discover.discover_single(ip)
print(d.model)
if d.model in file:
return d
return
with open(file) as f:
sysinfo = json.load(f)
model = basename(file)
params = {
"host": "123.123.123.123",
"protocol": FakeTransportProtocol(sysinfo),
"cache_ttl": 0,
}
if "LB" in model or "KL" in model:
p = SmartBulb(**params)
elif "HS300" in model:
p = SmartStrip(**params)
elif "HS" in model:
p = SmartPlug(**params)
else:
raise Exception("No tests for %s" % model)
yield p
def cli(ctx, ip, host, debug, bulb, plug):
"""A cli tool for controlling TP-Link smart home plugs."""
if debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
if ctx.invoked_subcommand == "discover":
return
if ip is not None and host is None:
host = ip
if host is None:
click.echo("No host name given, trying discovery..")
ctx.invoke(discover)
return
else:
if not bulb and not plug:
click.echo("No --bulb nor --plug given, discovering..")
dev = Discover.discover_single(host)
elif bulb:
dev = SmartBulb(host)
elif plug:
dev = SmartPlug(host)
else:
click.echo("Unable to detect type, use --bulb or --plug!")
return
ctx.obj = dev
if ctx.invoked_subcommand is None:
ctx.invoke(state)
def cancel_temp():
auth = request.args.get('auth')
if auth == "cabin":
time_now = datetime.now(gmt)
string_time = time_now.strftime("%d/%m/%y %H:%M:%S")
plug_log = open("/d1/cabin_log.txt", "a")
plug = SmartPlug("192.168.1.144")
temp = read_temp()
plug_status_file = open("/d1/webserver/reaching_optimum.txt", "r")
cabin_plug_status = plug_status_file.read()
plug_status_file.close()
if cabin_plug_status == "1":
GPIO.output(17, GPIO.LOW)
GPIO.output(27, GPIO.LOW)
plug_log.write(
string_time +
" /cancel-temp heating cancelled, current temperature is: " +
str(temp) + "\n")
plug_log.close()
plug_status_file = open("/d1/webserver/reaching_optimum.txt", "w")
plug.turn_off()
plug_status_file.write("0")
plug_status_file.close()
return jsonify({"message": "Heating cancelled.", "status": "ok"})
else:
plug_log.write(string_time +
" /cancel-temp plug not on, temperature is: " +
str(temp) + "\n")
plug_log.close()
return jsonify({
"message": "Plug is not on so unable to cancel heating.",
"status": "error"
})
else:
return jsonify({"message": "unauthorised", "status": "error"})
def main():
"""
Print the water level and temperature every second
:return:
"""
# create the spi bus
spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
# create the cs (chip select)
cs = digitalio.DigitalInOut(board.D22)
# create the mcp object
mcp = MCP.MCP3008(spi, cs)
# create an analog input channel on pin 0
water_level_sensor = AnalogIn(mcp, MCP.P0)
# create temperature sensor
temp_sensor = W1ThermSensor()
pump = SmartPlug(PUMP_IP)
heater = SmartPlug(HEATER_IP)
while True:
temperature = temp_sensor.get_temperature()
print(
f"The temperature is {temperature} C, {celsius_to_fahrenheit(temperature)} F"
)
print(f"ADC Voltage: {round(water_level_sensor.voltage, 2)}V")
water_level = get_water_level_inches(water_level_sensor.voltage)
print(f"Water Level: {water_level} inches")
print("\n")
if temperature < HEATER_CUTOFF_CELSIUS:
print("Turning heater on")
heater.turn_on()
else:
print("Turning heater off")
heater.turn_off()
if water_level < PUMP_CUTOFF_INCHES:
print("Turning pump on")
pump.turn_on()
else:
print("Turning pump off")
pump.turn_off()
time.sleep(1)
def __init__(self, name, ip):
self.name = name
self.ip = ip
print(name, ip, type(ip), len(ip))
self.plug = SmartPlug(ip)
self.logger = GetLogger('hs100')
self.logger.info("Link to an HS100 at {0} with name {1}.".format(
ip, name))
def tplink_consumption(ip):
plug = SmartPlug(ip)
# read meter information und parse JSON
pluginfo = json.loads(str(json.dumps(plug.get_emeter_realtime())))
# filter for total power consumption
consumption = pluginfo['total']
# return consumption
return consumption
def _device_for_type(host, type_):
dev = None
if type_ == CONF_LIGHT:
dev = SmartBulb(host)
elif type_ == CONF_SWITCH:
dev = SmartPlug(host)
return dev
def camerac1():
plug = SmartPlug("Insert IP Address here")
print("Current state: %s" % plug.state)
if (plug.state == 'ON'):
plug.turn_off()
else:
plug.turn_on()
return jsonify(data)
def __init__(self, id: str, alias: str, host: str) -> None:
Plug.__init__(self, id, alias, host, DeviceBrand.tp_link)
self.native_api = SmartPlug(host)
_LOGGER.debug(
"Initializing tp-link smartplug: %s",
self.host,
)
async def test_configuring_devices_from_multiple_sources(hass):
"""Test static and discover devices are not duplicated."""
with patch(
"homeassistant.components.tplink.common.Discover.discover"
) as discover, patch(
"homeassistant.components.tplink.common.SmartDevice._query_helper"
), patch(
"homeassistant.config_entries.ConfigEntries.async_forward_entry_setup"
):
discover_device_fail = SmartPlug("123.123.123.123")
discover_device_fail.get_sysinfo = MagicMock(
side_effect=SmartDeviceException())
discover.return_value = {
"123.123.123.1": SmartBulb("123.123.123.1"),
"123.123.123.2": SmartPlug("123.123.123.2"),
"123.123.123.3": SmartBulb("123.123.123.3"),
"123.123.123.4": SmartPlug("123.123.123.4"),
"123.123.123.123": discover_device_fail,
"123.123.123.124": UnknownSmartDevice("123.123.123.124"),
}
await async_setup_component(
hass,
tplink.DOMAIN,
{
tplink.DOMAIN: {
CONF_LIGHT: [{
CONF_HOST: "123.123.123.1"
}],
CONF_SWITCH: [{
CONF_HOST: "123.123.123.2"
}],
CONF_DIMMER: [{
CONF_HOST: "123.123.123.22"
}],
}
},
)
await hass.async_block_till_done()
assert len(discover.mock_calls) == 1
assert len(hass.data[tplink.DOMAIN][CONF_LIGHT]) == 3
assert len(hass.data[tplink.DOMAIN][CONF_SWITCH]) == 2
def get_static_devices(config_data) -> SmartDevices:
"""Get statically defined devices in the config."""
_LOGGER.debug("Getting static devices")
lights = []
switches = []
for type_ in [CONF_LIGHT, CONF_SWITCH, CONF_DIMMER]:
for entry in config_data[type_]:
host = entry["host"]
if type_ == CONF_LIGHT:
lights.append(SmartBulb(host))
elif type_ == CONF_SWITCH:
switches.append(SmartPlug(host))
# Dimmers need to be defined as smart plugs to work correctly.
elif type_ == CONF_DIMMER:
lights.append(SmartPlug(host))
return SmartDevices(lights, switches)
def setDeviceStatus(self, postmsg):
setDeviceStatusResult = True
ip = self.get_variable("ip")
port = self.get_variable("port")
p = SmartPlug(ip)
if postmsg['status'] == 'ON':
p.turn_on()
if postmsg['status'] == 'OFF':
p.turn_off()
def __init__(self,
host: str,
protocol: 'TPLinkSmartHomeProtocol' = None) -> None:
SmartPlug.__init__(self, host, protocol)
self.emeter_type = "emeter"
self.plugs = {}
children = self.sys_info["children"]
self.num_children = len(children)
for plug in range(self.num_children):
self.plugs[plug] = SmartPlug(host, protocol,
context=children[plug]["id"])
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Initialise pyLB100 SmartBulb."""
from pyHS100 import SmartBulb
from pyHS100 import SmartPlug
host = config.get(CONF_HOST)
name = config.get(CONF_NAME)
device_type = config.get(CONF_DEVICE_TYPE)
if device_type == "dimmer":
add_entities([TPLinkSmartDimmer(SmartPlug(host), name)], True)
else:
add_entities([TPLinkSmartBulb(SmartBulb(host), name)], True)
def tplink_hash(ip):
plug = SmartPlug(ip)
# read hw information und parse JSON
pluginfo = json.loads(str(json.dumps(plug.hw_info)))
# hash
plughash = hashlib.sha1()
# hash hw id
plughash.update(pluginfo['hwId'].encode())
# build hash for ETH
hash_s = "0x" + plughash.hexdigest() + "862ba9e16088902221101976"
# return hash
return hash_s
class Socket:
def __init__(self,name):
self.plug_mappings = {'A': 'Fan', 'B' : 'Music', 'C':'Lights'}
self.selected_appliance = '';
print("\n\n\nCREATING PLUG\n\n\n") # Showing that when a gesture is picked up being able to see that it works
dev_ip = None
for dev in ds.discover().values():
if dev.alias.lower() == name: # <--- need the hard code the name of the plug to find IP
dev_ip = dev.host
break
#checking if we are finding the IP address
self.plug = SmartPlug(dev_ip)
def __init__(
self, host: str, protocol: TPLinkSmartHomeProtocol = None, cache_ttl: int = 3
) -> None:
SmartPlug.__init__(self, host=host, protocol=protocol, cache_ttl=cache_ttl)
self.emeter_type = "emeter"
self._device_type = DeviceType.Strip
self.plugs = {}
children = self.sys_info["children"]
self.num_children = len(children)
for plug in range(self.num_children):
self.plugs[plug] = SmartPlug(
host, protocol, context=children[plug]["id"], cache_ttl=cache_ttl
)
def __init__(self, ip):
self.plug = SmartPlug(ip)
self.name = self.plug.alias
while True:
self.today = datetime.date.today()
try:
self.write(self.read())
except Exception as e:
print("Current Stats Exception: {}".format(e))
time.sleep(1)
def getDeviceStatus(self):
ip = self.get_variable("ip")
port = self.get_variable("port")
p = SmartPlug(ip)
emeter_info = p.get_emeter_realtime()
self.set_variable('status', str(p.state))
try:
self.set_variable('current', str(emeter_info['current']))
self.set_variable('voltage', str(emeter_info['voltage']))
self.set_variable('power', str(emeter_info['power']))
except:
print("no energy measument modul")
self.printDeviceStatus()
async def test_is_dimmable(hass):
"""Test that is_dimmable switches are correctly added as lights."""
with patch("pyHS100.Discover.discover") as discover, patch(
"homeassistant.components.tplink.light.async_setup_entry",
return_value=mock_coro(True),
) as setup, patch("pyHS100.SmartDevice._query_helper"), patch(
"pyHS100.SmartPlug.is_dimmable", True):
dimmable_switch = SmartPlug("123.123.123.123")
discover.return_value = {"host": dimmable_switch}
await async_setup_component(hass, tplink.DOMAIN, {tplink.DOMAIN: {}})
await hass.async_block_till_done()
assert len(discover.mock_calls) == 1
assert len(setup.mock_calls) == 1
assert len(hass.data[tplink.DOMAIN][CONF_LIGHT]) == 1
assert not hass.data[tplink.DOMAIN][CONF_SWITCH]
