def startup(self):
try:
self.start_data()
self.start_controller()
thread(self.data, (1, ))
thread(self.controll, (1, ))
except:
print("Service Stop")
self.stop()
exit()
def data(self, l):
while self.online:
t = True
try:
conn, addr = self.data_sock.accept()
except:
addr = "closed"
t = False
print("Connected to", addr)
if len(self.data_client) == len(self.data_addr) and t:
i = len(self.data_addr)
self.data_client.append(conn)
self.data_addr.append(addr)
self.data_activ.append(True)
thread(self.client, (i, "data"))
else:
print("Connection lost to", addr)
def expand(mail):
global MAX_INTERNAL_THREADS, error
results = search('mail="%s"' % (mail,))
if len(results) == 0 or results[0]["objectClass"] != "group": return [mail]
members = results[0]["member"]
out = []
ilock = Semaphore(MAX_INTERNAL_THREADS)
for m in members:
if not m.startswith("CN="): exit(1)
ilock.acquire()
thread(_search, (ilock, out, m))
for _ in range(MAX_INTERNAL_THREADS):
if error: break
ilock.acquire()
for _ in range(MAX_INTERNAL_THREADS): ilock.release()
return out
def main(self):
self._cons.append(self._socket)
while True:
rl, xl, wl = select.select(self._cons, [], [])
for sock in rl:
if sock == self._socket:
sock, ip = self._socket.accept()
self._on_connect()
self._cons.append(sock)
elif sock == None:
self._socket.close()
data = sock.recv(self._bytes)
if not data:
self._on_close(sock)
else:
agent = self._get_agent_header(data)
if not agent == "NO_AGENT":
agent_new = self._agent.replace("$MyAgent", agent)
data = data.replace(agent, agent_new)
thread(self._proxy, (sock, ip, data))
else:
thread(self._proxy, (sock, ip, data))
def __init__(self):
#Settings
self.ip = "0.0.0.0"
self.data_port = 499
self.controll_port = 466
self.cache = "./cache/"
self.storage = "./storage/"
self.users = ["admin"]
self.passwds = ["Test123"]
self.BUFFER_SIZE = 4096
self.mode = True
self.context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
self.context.load_cert_chain('./.cert/example.crt',
'./.cert/private.key')
#Clients
self.online = True
self.data_client = []
self.data_addr = []
self.data_activ = []
self.data_sock_d = None
self.controll_client = []
self.controll_addr = []
self.controll_activ = []
self.controll_sock_d = None
self.dic = {}
f = open("./log.lst", "r")
for line in f:
try:
file, date = line.split(";")
self.dic.update({file: date})
except:
pass
thread(self.algo, (1, ))
#startup
self.startup()
def start(self):
self.Start = True
self.init()
thread(self.keyboard_input_handler, ())
thread(self.voice_handler, ())
while self.Start:
self.display.fill(self.GREEN)
if self.keyboard_press == True:
self.display.blit(self.LAYOUT_HAND_DOWN, (0, 0))
else:
self.display.blit(self.LAYOUT_HAND_UP, (0, 0))
#Maybe have more restriction on mStartX and mStartY?
m = self.remap_mousepad(self.x, self.y)
self.display.blit(self.MOUSE,
(m[0] - self.MOUSE.get_width() // 2,
m[1] - self.MOUSE.get_height() // 2))
#this is just a test, i promise!
self.display.blit(self.MOUSE_HAND, (233, 135))
if self.isTalking:
self.display.blit(self.MOUTH_OPEN, (280, 55))
pygame.display.flip()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.stop = False
pygame.quit()
sys.exit(0)
self.clock.tick(60)
sleep(0.05)
R.value(0)
G.value(0)
B.value(0)
sleep(0.05)
def light():
while (1):
if count == 0 or count % 8 == 0:
blink(1, 0, 0)
else:
if count % 8 == 1:
blink(0, 1, 0)
if count % 8 == 2:
blink(0, 0, 1)
if count % 8 == 3:
blink(1, 1, 0)
if count % 8 == 4:
blink(1, 0, 1)
if count % 8 == 5:
blink(0, 1, 1)
if count % 8 == 6:
blink(1, 1, 1)
if count % 8 == 7:
blink(0, 0, 0)
thread(push, ())
thread(light, ())
print(data)
print('sleeping...')
slept = 1
sleep(1)
sleeping += 1
if (sleeping >= data['wakeuptime'] and slept):
while (btn.value() == 1 and data['sleeptime'] == 1):
sound_on_off()
if btn.value() == 0:
sleeping = 0
data['sleeptime'] = 0
posting = 1
#post1()
sleep(0.5)
posting = 0
data['wakeuptime'] = 30
break
sleep(0.5)
#print(1)
thread(printslt, ())
thread(inter, ())
thread(sleep1, ())
thread(led, ())
thread(deepsl, ())
#thread(getandpost,())
#print(2)
#print(3)
for _ in range(MAX_INTERNAL_THREADS):
if error: break
ilock.acquire()
for _ in range(MAX_INTERNAL_THREADS): ilock.release()
return out
mails = sys.argv[1].split(" ")
out = []
def _thread(m):
global out, threadlock
m = expand(m)
out += m
threadlock.release()
for m in mails:
threadlock.acquire()
thread(_thread, (m,))
for _ in range(MAX_THREADS):
if error: break
threadlock.acquire()
for _ in range(MAX_THREADS): threadlock.release()
if not error: print(" ".join(out), end = "", flush = True)
ssh.close()
if error: exit(255)
def webcontrol():
global ledstate
global doorstate
global alarmstate
while True:
# Fetch from server.
# Get data
data = {'door': doorstate, 'buzzer': alarmstate, 'light': alarmstate}
def alarmsys():
control.OBS.value(1)
print('Alarm System Initiated')
while True:
obs = control.LDIO.read()
print(obs)
if obs > 3000:
print('ALERT!')
beep(0.1)
lightcontrol('flash')
else:
lightcontrol('green')
sleep(0.1)
thread(connect, ())
thread(doorcontrol, ())
thread(alarmsys, ())
from _thread import start_new_thread as thread
from time import sleep
browser = "firefox" #Browser with has to be used
r = 5 #Per run number of Views
extra_time = 4 #time that is need by opening a website in secounds
def window(url):
os.system(command + " --new-tab --url "+url)
if len(sys.argv) < 4:
print("Usage: <URL> <clicks> <time in secounds> <proxy>")
print(" Not given")
sys.exit()
if sys.argv[4] == "yes":
command = "proxychains "+browser
thread(os.system,("tor",))
else:
command = browser
time_p = int(sys.argv[3]) + extra_time
for m in range(int(int(sys.argv[2])/r)):
for i in range(r):
t = thread(window, (sys.argv[1],))
sleep(1.5)
sleep(int(time_p))
os.system("pkill "+browser)
sleep(5)
os.system("clear")
print("---------------------------")
print("Clicks: ",str(r*(m+1)))
print("---------------------------")
R.value(0)
G.value(1)
B.value(0)
#thread(start_rgb_red())
button = Pin(5, Pin.IN)
def butt():
button_st = int(button.value())
return button_st
'''
def press_button():
return button.value()
#sleep(0.2)
thread(press_button())
'''
def Force_Button():
while True:
a = button.value()
if a == int(0):
start_rgb_red()
if a == int(1):
start_rgb_green()
#print(a)
data["isDanger"] = "True"
js = json.dumps({"data": data})
r = urequests.post(url=url, data=js, headers=headers)
results = r.json()
print(results)
sleep(1)
print(results)
def getdata():
if station.isconnected():
Result = urequests.get(url).json()
print(Result)
sleep(5)
if Result["isDanger"] == "False":
Bus = PWM(Pin(26), freq=20)
Bus.deinit()
Red.value(0)
def switch():
while True:
print(Switch.value())
print('Still')
sleep(1)
thread(hit, ())
thread(connection, ())
else:
local_hour = GMT0time + 7
sleep(10)
"""
def sent_back():
js = json.dumps({"data":data})
r = urequest.post(url,data=js,headers = headers)
result = r.json()
print(result)
"""
########## Main ##########
WIFICheck()
thread(WIFIMon, ())
#thread(get_local, ())
thread(import_from_web, ())
thread(check_category, ())
thread(switch, ())
while True:
print("GMT :", GMT0time)
#print("local_hour :", local_hour)
print("task :", task)
print("category :", category)
print("time :", time)
print("current times", GMT0time)
print(task_now)
print(dict_from_web)
sleep(3)
#isfreez = ''
#pressed = 'yet'
while not station.isconnected():
station.connect(ssid, pwd)
print('connecting ...')
sleep(1)
if station.isconnected():
print("connected")
getdata = urequests.get(url).json()
print(getdata)
color = getdata['color']
pill = getdata['pill']
#print(color)
#print(pill)
count1 = count2
count2 = getdata['count']
print(count1)
print(count2)
if not (count1 == count2):
print("GOood")
stopRGB = False
thread(Buzzer, [pill])
thread(Press_sta, [])
thread(Rgb, [color])
sleep(1)
startEnt = int(r1['startEnt'])
if status == 'Basic':
R.value(0)
G.value(0)
B.value(0)
r1 = urequests.get(url).json()
status = r1['status']
startEnt = int(r1['startEnt'])
#statHit = int(r1['statHit'])
data = {
'statEnt': statEnt,
'statDetect': statDetect,
'statHit': statHit,
'status': status,
'alertStatus': alertStatus,
'startEnt': startEnt,
'startDetect': startDetect
}
js = json.dumps({'data': data})
r = urequests.post(url, data=js, headers=headers)
results = r.json()
print(results)
sleep(0.5)
thread(isDetect, ())
thread(isEntrance, ())
thread(isHit, ())
thread(ToNetwork, ())
laser()
sleep(0.5)
def mynetwork():
while (1):
url = 'https://exceed.superposition.pknn.dev/data/eight'
data = {"door": statDoor, "buzzer": statBuzzer}
headers = {'content-type': 'application/json'}
while not station.isconnected():
station.connect(ssid, pwd)
print('Connecting ...')
sleep(1)
if station.isconnected():
print('Connected')
js = json.dumps({'data': data})
r = urequests.post(url, data=js, headers=headers)
results = r.json()
print(results)
r = urequests.get(url).json()
print(r)
sleep(1)
thread(door, ())
thread(onofflaser, ())
thread(mynetwork, ())
#thread(onofflight,())
def on_release(key):
'''
dummy function for releasing a key
'''
print('a key has been released')
#server.send(bytes(f'KEY {key}|', 'utf-8'))
def keylog(): #will start once program starts
with Listener(on_press=on_press, on_release=on_release) as listener:
listener.join()
thread(keylog, ())
def main():
'''
connects to the server, constantly recieves its messages
does actions when message is recieved
'''
while True:
try:
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.connect((IP, PORT))
image_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
image_server.connect((IP, IMAGE_PORT))
except:
from machine import Pin,DAC,PWM
from time import sleep
from _thread import start_new_thread as thread
led1 = Pin(5,Pin.OUT)
led2 = Pin(12,Pin.OUT)
def showLed1():
while(1):
led1.value(not led1.value())
sleep(0.5)
def showLed2(delay):
while(1):
led2.value(not led2.value())
sleep(delay)
thread(showLed1,())
thread(showLed2,[0.2])
#print("BPM:",bpm)
return bpm
#-----#
def net():
while (1):
while not station.isconnected():
station.connect(ssid, pwd)
print("Connecting...")
sleep(1)
if station.isconnected():
print("Connected")
js = json.dumps({"data": data})
r = urequests.post(url, data=js, headers=headers)
results = r.json()
print(results)
#print(temp)
#data["temp"] += 1
data["HeartRate"] = heartbeat()
data["Temp"] = temp()
sleep(4)
#net
thread(net, ())
thread(heartbeat, ())
thread(temp, ())
temp = []
# Preprocess
for i, data in enumerate(BPM, 0):
if data[1] == -1:
temp.append([i, 0])
else:
temp.append([i, data[1]])
headers = {'content-type': 'application/json'}
mock_data = {'data': {'heartrate': temp}}
del temp
print('Routine Job Executed')
# data = {'data': user_data}
js = json.dumps(mock_data)
gc.collect()
res = urequests.request('POST',
__ext.BASEURL,
headers=headers,
data=js)
res.close()
if BPM[-1][1] != -1:
print('Reset Time Frame')
BPM = [[n, -1] for n in range(60)]
Flag = False
sleep(0.1)
# Main Execution
thread(connect, ())
thread(h_read, ())
thread(send_data, ())