async def main(): # Call the definition of a light bulb, replace the IP address with the one found with kasa discover bulb = SmartBulb("10.0.1.3") # 'await' tells the program to wait till getting a result from the light bulb result = await bulb.turn_on() # Once we receive it, we call print() to show the result in the Terminal print(result)
async def main(): bulb = SmartBulb(KASA_DEVICE_IP) await bulb.update() print(bulb.alias) hue = 0 while (True): await bulb.set_hsv(hue, 100, 100) hue = (hue + int(KASA_HUE_SPEED)) % 360
def get_power_state(self): if self.device_type in [self.PLUG, self.BULB]: device = (SmartPlug(self.ip) if self.device_type in [self.PLUG] else SmartBulb(self.ip)) asyncio.run(device.update()) return device.is_on return False
def get_device(self): if self.device_type in [self.PLUG, self.BULB]: device = (SmartPlug(self.ip) if self.device_type in [self.PLUG] else SmartBulb(self.ip)) asyncio.run(device.update()) return device else: return self
async def gsinfo(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() data = {} data["alias"] = bulb.alias data["model"] = bulb.model data["rssi"] = bulb.rssi data["mac"] = bulb.mac data["trange"] = bulb.valid_temperature_range return {"data" : data}
async def setcolor(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() form = await request.form h,s,v = form['h'],form['s'],form['v'] await bulb.set_hsv(int(h), int(s), int(v)) await bulb.update() return {"ccolor" : bulb.hsv}
async def setbrightness(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() form = await request.form bright = form['bright'] await bulb.set_brightness(int(bright)) await bulb.update() return {"cbrightness" : bulb.brightness}
async def setcolortemp(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() form = await request.form temp = form['temp'] await bulb.set_color_temp(int(temp)) await bulb.update() return {"ctemp" : bulb.color_temp}
async def cli(ctx, host, alias, target, debug, bulb, plug, lightstrip, strip, klap, user, password): """A tool for controlling TP-Link smart home devices.""" # noqa if debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) if ctx.invoked_subcommand == "discover": return if alias is not None and host is None: click.echo(f"Alias is given, using discovery to find host {alias}") host = await find_host_from_alias(alias=alias, target=target) if host: click.echo(f"Found hostname is {host}") else: click.echo(f"No device with name {alias} found") return if password != "" and user == "": click.echo("Using a password requires a username") return if klap or user != "": authentication = Auth(user=user, password=password) else: authentication = None if host is None: click.echo("No host name given, trying discovery..") await ctx.invoke(discover) return else: if not bulb and not plug and not strip and not lightstrip: click.echo("No --strip nor --bulb nor --plug given, discovering..") dev = await Discover.discover_single(host, authentication) elif bulb: dev = SmartBulb(host) elif plug: dev = SmartPlug(host, authentication) elif strip: dev = SmartStrip(host) elif lightstrip: dev = SmartLightStrip(host) else: click.echo( "Unable to detect type, use --strip or --bulb or --plug!") return ctx.obj = dev if ctx.invoked_subcommand is None: await ctx.invoke(state)
async def flip(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() final_state = '' cstate = bulb.is_on if cstate: await bulb.turn_off() final_state = status(not cstate) else: await bulb.turn_on() final_state = status(not cstate) return {"status" : final_state}
async def toggle_bulb(bulb, state): p = SmartBulb(bulb) await p.update() if state == "off": await p.turn_on() elif state == "on": await p.turn_off() elif state == "toggle": if p.is_off: await p.turn_on() elif p.is_on: await p.turn_off() else: print(datetime.now(), "weird, %s is neither on nor off" % bulb)
def set_power_state(self, power): if self.device_type in [self.PLUG, self.BULB]: device = (SmartPlug(self.ip) if self.device_type in [self.PLUG] else SmartBulb(self.ip)) if power: asyncio.run(device.turn_on()) else: asyncio.run(device.turn_off()) asyncio.run(device.update()) elif self.device_type in [self.PI, self.LINUX]: stdin = b'' stdout = b'' stderr = b'' if not power: client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(self.ip, port=22, username=self.username, password=self.password) stdin_model, stdout_model, stderr_model = client.exec_command( 'sudo -S shutdown -h now') stdin_model.write('%s\n' % self.password) stderr_model.flush() # print the results if stdin_model.readable(): stdin = stdin_model.read() if stdout_model.readable(): stdout = stdout_model.read() if stderr_model.readable(): stderr = stderr_model.read() client.close() return (stdin, stdout, stderr) elif self.device_type in [self.ROKU]: roku = Roku(self.ip) roku.select() return (None, None, None)
async def cli(ctx, host, alias, target, debug, bulb, plug, strip): """A cli tool for controlling TP-Link smart home plugs.""" # noqa if debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) if ctx.invoked_subcommand == "discover": return if alias is not None and host is None: click.echo(f"Alias is given, using discovery to find host {alias}") host = await find_host_from_alias(alias=alias, target=target) if host: click.echo(f"Found hostname is {host}") else: click.echo(f"No device with name {alias} found") return if host is None: click.echo("No host name given, trying discovery..") await ctx.invoke(discover) return else: if not bulb and not plug and not strip: click.echo("No --strip nor --bulb nor --plug given, discovering..") dev = await Discover.discover_single(host) elif bulb: dev = SmartBulb(host) elif plug: dev = SmartPlug(host) elif strip: dev = SmartStrip(host) else: click.echo( "Unable to detect type, use --strip or --bulb or --plug!") return ctx.obj = dev if ctx.invoked_subcommand is None: await ctx.invoke(state)
def newdev(self): return SmartBulb(self.host)
async def state(): ip = get_device_ip(bulb_model) print(ip) bulb = SmartBulb(ip) await bulb.update() return {"status" : status(bulb.is_on)}
import asyncio from kasa import SmartBulb bulb = SmartBulb('10.0.2.23') asyncio.run(bulb.update()) SINGLE_CHANGE_DUR = 0.12 from src.controller.VLampController import VLampController vlc = VLampController()
async def ereading(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() reading = bulb.emeter_realtime return {"reading" : reading}
async def hsinfo(): ip = get_device_ip(bulb_model) bulb = SmartBulb(ip) await bulb.update() return {"data" : bulb.hw_info}
import hashlib import struct import pyaudio from picovoice import Picovoice import pigpio import requests import asyncio from kasa import SmartBulb import time gpio = pigpio.pi() gpio.set_mode(27, pigpio.OUTPUT) gpio.set_mode(17, pigpio.OUTPUT) gpio.set_mode(22, pigpio.OUTPUT) lights = SmartBulb('192.168.0.18') colours = { 'black': (0, 0, 0), 'blue': (0, 0, 10), 'green': (0, 10, 0), 'orange': (10, 5, 0), 'pink': (10, 2, 2), 'purple': (10, 0, 10), 'red': (10, 0, 0), 'white': (10, 10, 10), 'yellow': (10, 10, 0), 'warm': (10, 5, 2), 'cold': (8, 8, 10) }
def __init__(self, bulb_one_name, bulb_two_name): bulbs = self.discover_bulbs(bulb_one_name, bulb_two_name) self.bulb1 = SmartBulb(bulbs[0]) self.bulb2 = SmartBulb(bulbs[1])
plug = SmartPlug("192.168.1.x") async def plug_turn_on(): await plug.update() await plug.turn_on() async def plug_turn_off(): await plug.turn_off() ### TPLINK KASA KL130 ### Change the ip addresss accordingly print('Loading smartbulb <--- KL60') bulb = SmartBulb("192.168.2.117") def red_alert_mode(): bulb.turn_on() bulb.hsv = (0, 75, 100) time.sleep(0.7) bulb.turn_off() time.sleep(0.7) bulb.turn_on() time.sleep(0.7) bulb.turn_off() time.sleep(0.7) bulb.turn_on() time.sleep(0.7) bulb.turn_off()