class PlugHandler(object):
def __init__(self):
self.plug = SmartPlug(plug_devices['living_room'])
def switch_on(self):
try:
if self.plug.state == 'OFF':
self.plug.turn_on()
return 'switched on.'
else:
return 'already Switched on.'
except Exception as e:
print e
return 'Try Again.'
def switch_off(self):
try:
if self.plug.state == 'ON':
self.plug.turn_off()
return 'switched off.'
else:
return 'already Switched off.'
except Exception as e:
print e
return 'Try Again.'
def allSwitchesOn():
dehumid = SmartPlug(plugs['Fan'])
dehumid.turn_on()
fan = SmartPlug(plugs['Dehumidifier'])
fan.turn_on()
return 'Hi!'
class HS100():
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 state(self):
return self.plug.state
def turn_on(self):
self.plug.turn_on()
self.logger.info("Turn on {0} (HS100).".format(self.name))
def turn_off(self):
self.plug.turn_off()
self.logger.info("Turn off {0} (HS100).".format(self.name))
def switch(self):
if self.state() == SmartPlug.SWITCH_STATE_OFF:
self.plug.turn_on()
else:
self.plug.turn_off()
self.logger.info("Switch {0} (HS100) to {1}.".format(
self.name, self.state()))
class Fan:
FAN_OFF_DELAY = 500.0
def __init__(self, fan_ip, logger):
self.logger = logger
self.state = False
self.changing = False
self.fan_ip = fan_ip
self.plug = SmartPlug(self.fan_ip)
def fan_off(self):
try:
self.plug.turn_off()
self.logger.info("Turned fan off")
except Exception:
self.logger.warning("Outlet is down")
self.changing = False
def should_be(self, heat):
if heat == HEAT_ON:
try:
if self.plug.is_off:
self.plug.turn_on()
self.logger.info("Turned fan on")
except Exception:
self.logger.warning("Outlet is down")
self.state = True
try:
if heat == HEAT_OFF and self.plug.is_on and self.changing is False:
self.logger.info("Turning fan off")
self.changing = True
Timer(self.FAN_OFF_DELAY, self.fan_off).start()
except Exception:
self.logger.warning("Outlet is down")
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 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()
class DigitalDevice(RaspberiumDevice):
def __init__(self, address):
super().__init__()
self.digitalOutputDevice = SmartPlug(address)
def on(self):
self.digitalOutputDevice.turn_on()
self.digitalOutputDevice.led = True
def off(self):
self.digitalOutputDevice.turn_off()
self.digitalOutputDevice.led = False
class TplinkPlug(Plug):
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,
)
# self.initialize()
def get_sysinfo(self) -> Dict:
"""Retrieve system information.
:return: sysinfo
:rtype dict
:raises SmartDeviceException: on error
"""
return self.native_api.sys_info
@property
def is_off(self) -> bool:
"""Return True if device is off.
:return: True if device is off, False otherwise.
:rtype: bool
"""
return self.native_api.is_off
def turn_on(self) -> None:
"""Turn device on."""
return self.native_api.turn_on()
def turn_off(self) -> None:
"""Turn device off."""
return self.native_api.turn_off()
@property
def is_on(self) -> bool:
"""Return if the device is on.
:return: True if the device is on, False otherwise.
:rtype: bool
:return:
"""
try:
return self.native_api.is_on
except:
return None
@property
def state_information(self) -> Dict[str, Any]:
"""Return device-type specific, end-user friendly state information.
:return: dict with state information.
:rtype: dict
"""
return self.native_api.state_information
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)
class TPLinkDevice():
def __init__(self):
self.light_Plug = SmartPlug("192.168.43.236")
time.sleep(1.2)
self.fan_Plug = SmartPlug("192.168.43.37")
self.logger = None
self.log_manager = None
def set_log_manager(self, log_manager, logger):
self.log_manager = log_manager
self.logger = logger
def turn_on_off(self, device):
if device == 'Lights': # Change gesture sequence to default value
if self.light_Plug.state == "OFF":
self.light_Plug.turn_on()
else:
self.light_Plug.turn_off()
self.log_manager.set_gesture_sequence_link(
"Lights", True, self.light_Plug.state.lower(),
datetime.utcnow())
self.logger.log_device_state_change("Lights", True,
self.light_Plug.state.lower(),
datetime.utcnow())
elif device == 'Smart Plug': # Change gesture sequence to default value
if self.fan_Plug.state == "OFF":
self.fan_Plug.turn_on()
else:
self.fan_Plug.turn_off()
self.log_manager.set_gesture_sequence_link(
"Smart Plug", True, self.light_Plug.state.lower(),
datetime.utcnow())
self.logger.log_device_state_change("Smart Plug", True,
self.light_Plug.state.lower(),
datetime.utcnow())
else:
self.log_manager.set_gesture_sequence_link(device, False, "off",
datetime.utcnow())
self.logger.log_device_state_change(device, False, "off",
datetime.utcnow())
@staticmethod
def check_status(smart_plug):
return smart_plug.state
def set_plug(plug_ip, value):
"""
Sets the plug at the given ip to the given value.
Returns true iff the plug had a state change.
"""
plug = SmartPlug(plug_ip)
print("found plug on ip %s: %s" % (plug_ip, plug.alias))
state = plug.state
print("current plug state: " + str(state))
if value and not plug.is_on:
print("turning on fan")
plug.turn_on()
return True
elif not value and plug.is_on:
print("turning off fan")
plug.turn_off()
return True
else:
print("plug is already in correct state")
return False
def update(self, request, pk=None):
plug = self.get_object()
serializer = PlugsSerializer(plug, data=request.data, partial=True)
if serializer.is_valid():
try:
smplug = SmartPlug(request.data['ip'])
if (request.data['state'] == '1'
or request.data['state'] == True):
print("test")
smplug.turn_on()
else:
print("test2")
smplug.turn_off()
print(serializer.save())
except:
return Response({'error': 'Une erreur s\'est produite'})
return Response({'status': 'state set'})
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class Main(App):
def __init__(self, name, device, context):
App.__init__(self, name, device, context)
self.plug = SmartPlug(self.device_fields['ip'])
@action
def get_state(self):
return self.plug.state
@action
def turn_on(self):
self.plug.turn_on()
@action
def turn_off(self):
self.plug.turn_off()
@action
def on_since(self):
return self.plug.on_since
def shutdown(self):
return
def set_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()
if temp < 20:
GPIO.output(17, GPIO.HIGH)
GPIO.output(27, GPIO.HIGH)
plug_log.write(
string_time +
" /set-temp temperature set to reach optimum, current temperature is: "
+ str(temp) + "\n")
plug_log.close()
plug_status_file = open("/d1/webserver/reaching_optimum.txt", "w")
plug.turn_on()
plug_status_file.write("1")
plug_status_file.close()
return jsonify({
"message":
"Plug turned on, will turn off when 20C is reached.",
"status": "ok"
})
else:
plug_log.write(string_time +
" /set-temp not activating as temperature is: " +
str(temp) + "\n")
plug_log.close()
return jsonify({
"message": "Temperature is already at optimum temperature.",
"status": "error"
})
else:
return jsonify({"message": "unauthorised", "status": "error"})
class Main(App):
def __init__(self, name=None, device=None):
App.__init__(self, name, device)
self.plug = SmartPlug(self.get_device().ip)
@action
def get_state(self):
return self.plug.state
@action
def turn_on(self):
self.plug.turn_on()
@action
def turn_off(self):
self.plug.turn_off()
@action
def on_since(self):
return self.plug.on_since
def shutdown(self):
print("SmartPlug Shutting Down")
return
def dehumidSwitchOn():
plug = SmartPlug(plugs['Dehumidifier'])
plug.turn_on()
return 'Hi!'
#24hrs/15min = 96, so break the loop every day
while i < 96:
i = i + 1
f.write(
str(beg_twilight.hour - 5) + ":" + str(beg_twilight.minute) +
", " + str(sunrise.hour - 5) + ":" + str(sunrise.minute) + ", " +
str(sunset.hour - 5) + ":" + str(sunset.minute) + ", " +
str(end_twilight.hour - 5) + ":" + str(end_twilight.minute) +
", " + str(datetime.datetime.now().hour) + ":" +
str(datetime.datetime.now().minute))
if on:
if datetime.datetime.now().hour in range(sunset.hour - 5,
end_twilight.hour - 5):
if datetime.datetime.now().minute in evening_minutes:
f.write(", Turning plug off")
plug.turn_off()
on = False
else:
if datetime.datetime.now().hour in range(beg_twilight.hour - 5,
sunrise.hour - 5):
if datetime.datetime.now().minute in morning_minutes:
print(", Turning plug on")
plug.turn_on()
on = True
f.write("\n")
f.flush()
os.fsync(f)
time.sleep(900)
def cyclePower(rigName):
if rigName in POWER_SWITCH_IP_DICT:
plug = SmartPlug(POWER_SWITCH_IP_DICT[rigName])
plug.turn_off()
sleep(2)
plug.turn_on()
((x, y), radius) = cv2.minEnclosingCircle(c)
(rx, ry, rw, rh) = cv2.boundingRect(c)
# convert floating point values to integers
(x, y, radius) = [int(v) for v in (x, y, radius)]
# only process motion contours above the specified size
if radius >= conf["min_radius"]:
detectedMotion = True
break
# motion detected, start sending frames over
if detectedMotion:
send_time = timenow
try:
light_plug.turn_on()
print("Turning light on")
except Exception:
pass
# check to see if we're displaying the frame to our screen
if conf["display"]:
# display the frame and grab keypresses
cv2.imshow("Frame", frame)
key = cv2.waitKey(1) & 0xFF
# if the `q` key was pressed, break from the loop
if key == ord("q"):
break
# stop the video stream
def tpPlugOn(self, ip):
plug = SmartPlug(ip)
plug.turn_on()
class Fan:
"""Turn on my fan!"""
def __init__(self, bot):
self.bot = bot
self.plug = SmartPlug(
"192.168.0.175") #Change to the IP of your fan's Smart Plug.
self.fan_enabled = True
def toggle_plug(self):
if self.plug.is_off:
self.plug.turn_on()
else:
self.plug.turn_off()
@commands.group(pass_context=True)
async def fan(self, ctx):
"""Manage your fan"""
if ctx.invoked_subcommand is None:
await send_cmd_help(ctx)
@fan.command(pass_context=True)
async def on(self, ctx):
"""Turn it on!"""
if not self.fan_enabled and not checks.is_owner_check(ctx):
await self.bot.say("The fan's state currently cannot be changed.")
return
if self.plug.is_on:
await self.bot.say("The fan is already on!")
else:
self.toggle_plug()
await self.bot.say("The fan is now on!")
@fan.command(pass_context=True)
async def off(self, ctx):
"""Turn it off!"""
if not self.fan_enabled and not checks.is_owner_check(ctx):
await self.bot.say("The fan's state currently cannot be changed.")
return
if self.plug.is_off:
await self.bot.say("The fan is already off!")
else:
self.toggle_plug()
await self.bot.say("The fan is now off!")
@fan.command(pass_context=True)
async def toggle(self, ctx):
"""Toggle its state!"""
if not self.fan_enabled and not checks.is_owner_check(ctx):
await self.bot.say("The fan's state currently cannot be changed.")
return
self.toggle_plug()
await self.bot.say("The fan is now {}!".format(self.plug.state.lower())
)
@fan.command(pass_context=True)
async def status(self, ctx):
"""Check the fan's state."""
await self.bot.say("The fan is currently {}.".format(
self.plug.state.lower()))
@fan.command()
@checks.is_owner()
async def enable(self):
"""Enable use of the fan by anyone."""
self.fan_enabled = True
await self.bot.say("Fan powers enabled!")
@fan.command()
@checks.is_owner()
async def disable(self):
"""Disable use of the fan by anyone but yourself."""
self.fan_enabled = False
await self.bot.say("Fan powers disabled!")
class TestSmartPlug(TestCase):
# these schemas should go to the mainlib as
# they can be useful when adding support for new features/devices
# as well as to check that faked devices are operating properly.
sysinfo_schema = Schema({
'active_mode': check_mode,
'alias': basestring,
'dev_name': basestring,
'deviceId': basestring,
'feature': basestring,
'fwId': basestring,
'hwId': basestring,
'hw_ver': basestring,
'icon_hash': basestring,
'latitude': All(float, Range(min=-90, max=90)),
'led_off': check_int_bool,
'longitude': All(float, Range(min=-180, max=180)),
'mac': check_mac,
'model': basestring,
'oemId': basestring,
'on_time': int,
'relay_state': int,
'rssi': All(int, Range(max=0)),
'sw_ver': basestring,
'type': basestring,
'updating': check_int_bool,
})
current_consumption_schema = Schema({
'voltage': All(float, Range(min=0, max=300)),
'power': All(float, Range(min=0)),
'total': All(float, Range(min=0)),
'current': All(float, Range(min=0)),
})
tz_schema = Schema({
'zone_str': basestring,
'dst_offset': int,
'index': All(int, Range(min=0)),
'tz_str': basestring,
})
def setUp(self):
self.plug = SmartPlug(PLUG_IP,
protocol=FakeTransportProtocol(sysinfo_hs110))
def tearDown(self):
self.plug = None
def test_initialize(self):
self.assertIsNotNone(self.plug.sys_info)
self.sysinfo_schema(self.plug.sys_info)
def test_initialize_invalid_connection(self):
plug = SmartPlug('127.0.0.1',
protocol=FakeTransportProtocol(sysinfo_hs110,
invalid=True))
with self.assertRaises(SmartPlugException):
plug.sys_info['model']
def test_query_helper(self):
with self.assertRaises(SmartPlugException):
self.plug._query_helper("test", "testcmd", {})
# TODO check for unwrapping?
@skipIf(SKIP_STATE_TESTS, "SKIP_STATE_TESTS is True, skipping")
def test_state(self):
def set_invalid(x):
self.plug.state = x
set_invalid_int = partial(set_invalid, 1234)
self.assertRaises(ValueError, set_invalid_int)
set_invalid_str = partial(set_invalid, "1234")
self.assertRaises(ValueError, set_invalid_str)
set_invalid_bool = partial(set_invalid, True)
self.assertRaises(ValueError, set_invalid_bool)
orig_state = self.plug.state
if orig_state == SmartPlug.SWITCH_STATE_OFF:
self.plug.state = "ON"
self.assertTrue(self.plug.state == SmartPlug.SWITCH_STATE_ON)
self.plug.state = "OFF"
self.assertTrue(self.plug.state == SmartPlug.SWITCH_STATE_OFF)
elif orig_state == SmartPlug.SWITCH_STATE_ON:
self.plug.state = "OFF"
self.assertTrue(self.plug.state == SmartPlug.SWITCH_STATE_OFF)
self.plug.state = "ON"
self.assertTrue(self.plug.state == SmartPlug.SWITCH_STATE_ON)
elif orig_state == SmartPlug.SWITCH_STATE_UNKNOWN:
self.fail("can't test for unknown state")
def test_get_sysinfo(self):
# initialize checks for this already, but just to be sure
self.sysinfo_schema(self.plug.get_sysinfo())
@skipIf(SKIP_STATE_TESTS, "SKIP_STATE_TESTS is True, skipping")
def test_turns_and_isses(self):
orig_state = self.plug.is_on
if orig_state:
self.plug.turn_off()
self.assertFalse(self.plug.is_on)
self.assertTrue(self.plug.is_off)
self.plug.turn_on()
self.assertTrue(self.plug.is_on)
else:
self.plug.turn_on()
self.assertFalse(self.plug.is_off)
self.assertTrue(self.plug.is_on)
self.plug.turn_off()
self.assertTrue(self.plug.is_off)
def test_has_emeter(self):
# a not so nice way for checking for emeter availability..
if "110" in self.plug.sys_info["model"]:
self.assertTrue(self.plug.has_emeter)
else:
self.assertFalse(self.plug.has_emeter)
def test_get_emeter_realtime(self):
self.current_consumption_schema((self.plug.get_emeter_realtime()))
def test_get_emeter_daily(self):
self.assertEqual(self.plug.get_emeter_daily(year=1900, month=1), {})
k, v = self.plug.get_emeter_daily().popitem()
self.assertTrue(isinstance(k, int))
self.assertTrue(isinstance(v, float))
def test_get_emeter_monthly(self):
self.assertEqual(self.plug.get_emeter_monthly(year=1900), {})
d = self.plug.get_emeter_monthly()
k, v = d.popitem()
self.assertTrue(isinstance(k, int))
self.assertTrue(isinstance(v, float))
@skip("not clearing your stats..")
def test_erase_emeter_stats(self):
self.fail()
def test_current_consumption(self):
x = self.plug.current_consumption()
self.assertTrue(isinstance(x, float))
self.assertTrue(x >= 0.0)
def test_identify(self):
ident = self.plug.identify()
self.assertTrue(isinstance(ident, tuple))
self.assertTrue(len(ident) == 3)
def test_alias(self):
test_alias = "TEST1234"
original = self.plug.alias
self.assertTrue(isinstance(original, basestring))
self.plug.alias = test_alias
self.assertEqual(self.plug.alias, test_alias)
self.plug.alias = original
self.assertEqual(self.plug.alias, original)
def test_led(self):
original = self.plug.led
self.plug.led = False
self.assertFalse(self.plug.led)
self.plug.led = True
self.assertTrue(self.plug.led)
self.plug.led = original
def test_icon(self):
self.assertEqual(set(self.plug.icon.keys()), {'icon', 'hash'})
def test_time(self):
self.assertTrue(isinstance(self.plug.time, datetime.datetime))
# TODO check setting?
def test_timezone(self):
self.tz_schema(self.plug.timezone)
def test_hw_info(self):
self.sysinfo_schema(self.plug.hw_info)
def test_on_since(self):
self.assertTrue(isinstance(self.plug.on_since, datetime.datetime))
def test_location(self):
self.sysinfo_schema(self.plug.location)
def test_rssi(self):
self.sysinfo_schema({'rssi': self.plug.rssi}) # wrapping for vol
def test_mac(self):
self.sysinfo_schema({'mac': self.plug.mac}) # wrapping for val
def main():
if __name__ == '__main__':
args = docopt("""
cog_test.
A python test program for Cognitive System interview.
The program requires Openwrt, Wireless adapter(Configured as AP), and
TP-Link Smartplug.
The program use Openwrt's tool "iw" to detect wireless device connection
and parse its MAC address. If the MAC address matches the program input
argument, the program will turn on the SmartPlug. If the target MAC
address left the AP, the program will turn off the SmartPlug.
Limitation: Script will only run on OpenWrt with only one smartPlug
being connected to the AP.
This script also only beent tested with one HS105.
Caveat: "iw event -f" displays multiple message when STA is disconnected
Therefore, the output of this program reflects the behavior from
"iw event -f"
Usage:
cog_test.py [options] <mac_address>
Options:
-h --help Show this screen.
""")
# Register signal
signal.signal(signal.SIGINT, sig_term_handler)
usr_mac = args['<mac_address>'].lower()
# Check input argument
if check_mac(usr_mac):
raise ValueError("Input Error (MAC Address)")
# Check OS & Distro
if bool(is_os_valid()):
pass
else:
raise RunTimeError("Script must be run on OpenWrt")
# Get Wireless Dev
dev_name = get_wireless_dev()
if dev_name is None:
raise RuntimeError(r"Wireless not up or not configured" r" as AP")
# Initialize plug object
plug_ip = get_plug_ip()
if plug_ip is None:
raise RuntimeError("Smartplug is not detected")
else:
plug = SmartPlug(plug_ip)
# Using "iw" pipe result if STA is being added or deleted
GLOBAL_PROC = subprocess.Popen(["iw", "event", "-f"],\
stdin = subprocess.PIPE,\
stdout =subprocess.PIPE)
# Regex for iw output and for MAC address
iwRegx = re.compile(r'(\bnew\b)|(\bdel\b)|'
r'((([a-fA-F\d]){2}:){5}'
r'(([a-fA-F\d]){2}))')
# Check if the desired MAC has already been connected
if bool(is_mac_exist(usr_mac, dev_name)):
plug.turn_on()
else:
plug.turn_off()
print("Script is ready! Waiting for", usr_mac, "action!")
# Main running loop
while True:
output = GLOBAL_PROC.stdout.readline()
m = iwRegx.findall(output.decode('utf-8'))
if m:
for i in m[0]:
if i:
act = i
mac = m[1][2]
if mac == usr_mac:
if act == "new":
print(usr_mac, "has connected")
plug.turn_on()
elif act == "del":
print(usr_mac, "has disconnected")
plug.turn_off()
else:
pass
def plugTurnOn(name):
plug = SmartPlug(deviceList[name])
plug.turn_on()
def fanSwitchOn():
plug = SmartPlug(plugs['Fan'])
plug.turn_on()
return 'Hi!'
def get(self, request, format=None):
sensors = {}
plugs = {}
response = {}
response['sensors'] = {}
for sensor in Sensors.objects.all():
if env("DEBUG") == True:
sensors[sensor.name] = {"Temperature": "21", "Humidity": "56"}
else:
sensors[sensor.name] = requests.get('http://' + sensor.ip +
'/data').json()
logsSensors = LogsSensors()
logsSensors.temperature = sensors[sensor.name].get('Temperature')
logsSensors.humidity = sensors[sensor.name].get('Humidity')
logsSensors.sensor = sensor
logsSensors.save()
logsPlugs = LogsPlugs()
plugs = Plugs.objects.all().filter(room_id=sensor.room.id)
BoolInterval = False
for ti in TimeInterval.objects.all().filter(
room_id=sensor.room.id):
if (isInTimeInterval(ti.startingTime, ti.endingTime)):
BoolInterval = True
presenceBool = True if sensors[sensor.name].get(
'Presence'
) == "1" else False #isPresent('iphone-de-sebastien.local')
logPresence = LogsPresence()
if presenceBool:
logPresence.presence = 1
logPresence.save()
print("Presence:" + str(presenceBool))
condition = (
isSetupTrue("ForceStop") != True and presenceBool
and BoolInterval == False
) or (((not presenceBool) or BoolInterval)
and int(sensors[sensor.name]['Temperature']) < int(
Setup.objects.get(name__iexact="MinTemperature").value))
print("condition1: " +
str((isSetupTrue("ForceStop") != True and presenceBool
and BoolInterval == False)))
print("__")
print("condition2 : " + str((
(not presenceBool) or BoolInterval
) and int(sensors[sensor.name]['Temperature']) < int(
Setup.objects.get(name__iexact="MinTemperature").value)))
if condition:
if presenceBool and (BoolInterval == False):
askedTemperature = Setup.objects.get(
name__iexact="Temperature").value
else:
askedTemperature = Setup.objects.get(
name__iexact="MinTemperature").value
print(askedTemperature)
#print(sensors[sensor.name]['Temperature'])
if int(sensors[sensor.name]
['Temperature']) < int(askedTemperature) + 1:
response['success'] = True
response['sensors'][sensor.name] = {'state': "on"}
logsPlugs.value = 1
for plug in plugs:
if (condition == True):
print("ON " + plug.ip)
plug.state = True
smplug = SmartPlug(plug.ip)
smplug.turn_on()
elif int(sensors[sensor.name]
['Temperature']) >= int(askedTemperature) - 1:
response['success'] = True
response['sensors'][sensor.name] = {'state': "off"}
logsPlugs.value = 0
for plug in plugs:
print("Off " + plug.ip)
plug.state = False
smplug = SmartPlug(plug.ip)
smplug.turn_off()
else:
logsPlugs.value = 0
else:
logsPlugs.value = 0
for plug in plugs:
smplug = SmartPlug(plug.ip)
plug.state = False
smplug.turn_off()
logsPlugs.save()
plug.save()
return JsonResponse(response)
