def get_state(self, area, account): if(area=="" or account==""): p.err("get_state was callen with area and or account empty") return -1 try: self.connect() with self.connection.cursor() as cursor: # Create a new record req = "SELECT COUNT(*) FROM area_state WHERE `account` = %s AND `area`=%s" cursor.execute(req, (str(account), str(area)) ) result = cursor.fetchone() #rint(result) if(result["COUNT(*)"] == 1): req = "SELECT `state` FROM `area_state` WHERE `account` = %s AND `area`=%s" cursor.execute(req, (str(account), str(area)) ) result = cursor.fetchone() else: p.rint("get state Count was "+str(result["COUNT(*)"])+"!=1", "d") p.rint(req%(str(account), str(area)), "d") result = -1 except: self.he() result = -1 self.close() return result
def print_all(self): reactivate=0 for p_rule in p.print_out: if(p_rule.shortcut=="r"): if(not(p_rule.state)): p_rule.state=1 reactivate=1 break now=time.localtime()[3]*3600+time.localtime()[4]*60+time.localtime()[5] p.rint("== I'm the rule manager, I have "+str(len(self.data))+" accounts registered at ts: "+str(now)+"==","r") i=1 for a in self.data: if(a.account!=""): p.rint("","r") p.rint("|+ Account "+str(i)+"/"+str(len(self.data)),"r") a.print_account() i+=1 p.rint("","r") p.rint("== End of rule manager output ==","r") #### stop output again if(reactivate): for p_rule in p.print_out: if(p_rule.shortcut=="r"): p_rule.state=0 break
def get_ws_data(self, login): #rint("get data mid:"+mid) try: self.connect() #rint("try:") with self.connection.cursor() as cursor: # Read a single record #rint("get_data gen req:") req = "SELECT COUNT(*) FROM ws WHERE login=%s or email=%s" cursor.execute(req, (str(login), str(login))) result_c = cursor.fetchone() #rint(result) #rint(result) if(result_c["COUNT(*)"] == 1): req = "SELECT pw, account, email, login FROM ws WHERE login=%s or email=%s" #rint(req) cursor.execute(req, (str(login), str(login))) #rint("setting result to ") result = cursor.fetchone() else: result = -1 p.rint("count not 1, it is "+str(result_c["COUNT(*)"]), "d") p.rint(req, "d") #rint(result) except: self.he() result = -2 self.close() return result
def return_to_old(self,ms): if(self.l.o_lifetime>time.time()): p.rint("LIGHT return_to_old, goto backup color cause lifetime is "+str(self.l.o_lifetime-time.time()),"r") self.add_q_entry(time.time(),self.l.o_rd,self.l.o_gd,self.l.o_bd,ms) # first move back to old color as it is still valid self.add_q_entry(self.l.o_lifetime,0,0,0,ms) # remember to turn off at some point else: p.rint("LIGHT return_to_old, goto 0/0/0 lifetime is over","r") self.add_q_entry(time.time(),0,0,0,ms) # return to nothing, as the old color is not valid, turn off
def upload_picture(_con, res): global m2m_mid # rint(str(time.time())+" --> this is upload_file") # if(STEP_DEBUG): # p.rint("Step 5. this is upload_file with "+str(len(_con.msg_q))+" msg in q") if(len(_con.msg_q) > 0): p.rint("skip picture, q full","d") return 1 p.set_last_action("loading img") #if full frame read other file try: if res!="VGA": img = open("/dev/shm/mjpeg/cam_full.jpg", 'rb') else: img = open("/dev/shm/mjpeg/cam_prev.jpg", 'rb') except: img=open("ic_camera_black_48dp.png", 'rb') i = 0 while True: # should realy read it in once, 10MB buffer strng = img.read(_con.max_msg_size-100) if not strng: #rint("could not read") break msg = {} msg["cmd"] = "wf" msg["fn"] = m2m_mid+"_"+str(int(time.time()*100) % 10000)+'.jpg' msg["data"] = base64.b64encode(strng).decode('utf-8') msg["sof"] = 0 if(i == 0): msg["sof"] = 1 msg["eof"] = 0 msg["msg_id"] = i msg["ack"] = 1 #-1 #msg["ts"]=td if(len(strng) != (_con.max_msg_size-100)): msg["eof"] = 1 #rint('sending('+str(i)+') of '+path+'...') msg["td"] = ((time.time(), "send"), (time.time(), "send")) _con.msg_q.append(msg) #if(STEP_DEBUG): # rint("[A "+time.strftime("%H:%M:%S")+"] Step 6 upload appended message") i = i+1 p.set_last_action("loading img done") #rint(str(time.time())+' all messages for '+path+' are in buffer.. i guess') img.close() cam.last_picture_taken_ts = time.time() return 0
def rm_override(self, override): del_list=[] if(override=="*"): self.has_override_detection_on=0 elif(override=="/"): self.has_override_detection_off=0 for r in self.rules: if(r.conn==override): del_list.append(r) for r in del_list: p.rint("[A_ws "+time.strftime("%H:%M:%S")+"] Remove rule " + str(r.id) + "","r") self.rm_rule(r.id)
def upload_picture(): # if(STEP_DEBUG): if(len(msg_q_ws) > 0): p.rint("skip picture, q full","d") return 1 p.set_last_action("loading img") #if full frame read other file try: img = open("/dev/shm/mjpeg/cam_full.jpg", 'rb') except: img=open("ic_camera_black_48dp.png", 'rb') i = 0 while True: # should realy read it in once, 10MB buffer strng = img.read(10000000) if not strng: #rint("could not read") break msg = {} msg["cmd"] = "wf" msg["fn"] = str(int(time.time()*100) % 10000)+'.jpg' msg["data"] = base64.b64encode(strng).decode('utf-8') msg["sof"] = 0 if(i == 0): msg["sof"] = 1 msg["eof"] = 0 msg["msg_id"] = i msg["ack"] = 1 #-1 #msg["ts"]=td if(len(strng) != (10000000)): msg["eof"] = 1 #rint('sending('+str(i)+') of '+path+'...') msg["td"] = ((time.time(), "send"), (time.time(), "send")) for cli in server_ws.clients: msg_q_ws.append((msg,cli)) #if(STEP_DEBUG): # rint("[A "+time.strftime("%H:%M:%S")+"] Step 6 upload appended message") i = i+1 p.set_last_action("loading img done") #rint(str(time.time())+' all messages for '+path+' are in buffer.. i guess') img.close() return 0
def rm_rule(self, id): found=0 for r in self.rules: if(r.id==id): self.rules.remove(r) found=1 break; if(not(found)): for r in self.sub_rules: if(r.id==id): self.sub_rules.remove(r) break; # delete from db if(self.db!=""): self.db.rm_rule(id) if(not(self.db.rm_rule(id)==0)): p.rint("Delete rule "+str(id)+" failed","r")
def __init__(self): self.recv_buffer = "" self.sock = "" self.last_transfer = 0 self.logged_in = 0 # avoiding that we send stuff without being logged in self.hb_out = 0 self.hb_out_ts = 0 self.msg_q = [] self.unacknowledged_msg = [] self.ack_request_ts = 0 # used to save the time when the last message, requesting a ACK was send self.max_msg_size = 10024000 # 10 MB? self.server_ip = "illuminum.de" self.server_port = 9875 if(os.path.isfile(os.path.join(os.path.dirname(os.path.realpath(__file__)),"experimental"))): self.server_port = 9775 p.rint("!!!!!!!!! RUNNING ON EXPERIMENTAL PORT !!!!!!!!!!!","l") self.server_timeout = 15 self.max_outstanding_acks = 2
def run(self,config,gpio): self.alive = True try: # basic config busy=1 p.rint("TRIGGER: thread started","l") if(not(config.with_pir)): p.rint("TRIGGER: configured without PIR","l") while self.alive: # cpu spacing if(busy==0): time.sleep(0.1) busy=0 # try to get the pin state try: # sensor offline if(not(config.with_pir)): gpio_state=4 else: gpio_state=gpio.get(gpio.PIN_PIR) except: p.rint("TRIGGER: Trouble reading GPIO, trying to reconfigure","d") break # set detection on / off if(self.s.state_change_event): self.s.state=-1 #to be refreshed by the part below self.s.state_change_event=0 self.s.last_triggered=0 # make sure the refresh happens fast # react on pin state change if(gpio_state != self.s.state and self.s.last_triggered+self.s.timeout<time.time()): self.s.last_triggered=time.time() self.s.state=gpio_state busy=1 p.rint("TRIGGER Switch to state '"+m2m_state[self.s.state]+"' with detection '"+det_state[self.s.detection]+"'","t") # call everyone who subscribed to our update list for callb in self.s.callback_action: if(not(type(callb) is str)): try: callb("state_change",(self.s.state,self.s.detection)) except: print("TRIGGER callback crashed") # while except: print("TRIGGER CRASHED") self.is_stop = True
def dimm_to(self,r,g,b,ms): p.rint("LIGHT, dimming to "+str(r)+"/"+str(g)+"/"+str(b),"r") # selection is 0-255 based, but it really means 0-100% ######## calculate target value 0-255 (half-log) out of the input value 0-255 (linear) ####### _r=r/2.55 _g=g/2.55 _b=b/2.55 intens=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,27,28,29,30,31,32,33,34,35,36,38,39,40,41,43,44,45,47,48,50,51,53,55,57,58,60,62,64,66,68,70,73,75,77,80,82,85,88,91,93,96,99,103,106,109,113,116,120,124,128,132,136,140,145,150,154,159,164,170,175,181,186,192,198,205,211,218,225,232,239,247,255] _r=int(max(min(len(intens)-1,_r),0)) # just to make sure that we don't take an element outside the array 0-100 _g=int(max(min(len(intens)-1,_g),0)) _b=int(max(min(len(intens)-1,_b),0)) self.l.t_r=intens[_r] # convert percentage to half-logarithmical brightness self.l.t_g=intens[_g] self.l.t_b=intens[_b] ######## calculate target value 0-255 (half-log) out of the input value 0-255 (linear) ####### max_diff=max([abs(self.l.t_g-self.l.c_g),abs(self.l.t_r-self.l.c_r),abs(self.l.t_b-self.l.c_b)]) # find out what color has to do the most steps, this will determine the time between our single steps if(max_diff>0): # just go on, if at least one has to change the color by at least one step self.l.o_rd=self.l.c_rd # save current color as old self.l.o_gd=self.l.c_gd self.l.o_bd=self.l.c_bd self.l.c_rd=r # current target linear 0-255 color in the structure self.l.c_gd=g self.l.c_bd=b self.l.s_t=time.time() # copy the starttime self.l.t_t=self.l.s_t+ms/1000 # set start time as starttime + time to dimm self.l.state=1 # state 1 means dimming self.l.ĺast_ts=0 # last_ts=0 will result in instant execution of the first dimming step in the loop above self.l.ms_step=ms/max_diff # calc the time between the dimming steps as total time / max steps #print("ms:"+str(ms)+" ms_step:"+str(self.l.ms_step)) self.l.s_r = self.l.c_r # set start color as current color self.l.s_g = self.l.c_g self.l.s_b = self.l.c_b p.rint("LIGHT start at "+str(time.time())+" to "+str(self.l.c_r)+"/"+str(self.l.c_g)+"/"+str(self.l.c_b)+" -> "+str(self.l.t_r)+"/"+str(self.l.t_g)+"/"+str(self.l.t_b)+" within "+str(ms),"r")
def print_account(self,m_dict=0): if(m_dict!=1): p.rint("|"+p.bcolors.FAIL+"+ This is account '"+self.account+"' I have "+str(len(self.areas))+" areas:"+p.bcolors.ENDC,"r") else: ret_dict={} i=1 for a in self.areas: if(a.area!=""): if(m_dict!=1): p.rint("|","r") p.rint("||"+p.bcolors.WARNING+"+ Area "+str(i)+"/"+str(len(self.areas))+p.bcolors.ENDC,"r") a.print_rules() else: ret_dict[i]=a.print_rules(dict=1) i+=1 if(m_dict!=1): p.rint("|","r") p.rint("|+ my next timebased trigger event is at '"+str(self.next_ts)+"'","r") else: return ret_dict
def setup(self): if(rpi_support): p.rint("configuring raspberry pins","g") GPIO.setwarnings(False) GPIO.setmode(GPIO.BOARD) self.PIN_PIR = 7 self.PIN_MOVEMENT = 11 self.PIN_DETECTION = 13 self.PIN_USER = 15 self.PIN_CAM = 16 GPIO.setup(self.PIN_PIR, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.PIN_MOVEMENT, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.PIN_DETECTION, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.PIN_USER, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.setup(self.PIN_CAM, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) elif(fsys_support): p.rint("configuring fsys pins","g") # XIO-P0 408 13 # XIO-P1 409 14 # XIO-P2 410 15 # XIO-P3 411 16 # XIO-P4 412 17 # XIO-P5 413 18 # XIO-P6 414 19 # XIO-P7 415 20 self.PIN_PIR = 408 self.PIN_MOVEMENT = 409 self.PIN_DETECTION = 410 self.PIN_USER = 411 self.PIN_CAM = 412 self.fsys_export(self.PIN_PIR) self.fsys_export(self.PIN_MOVEMENT) self.fsys_export(self.PIN_DETECTION) self.fsys_export(self.PIN_USER) self.fsys_export(self.PIN_CAM)
def __init__(self): self.recv_buffer = "" self.sock = "" self.last_transfer = 0 self.logged_in = 0 # avoiding that we send stuff without being logged in self.hb_out = 0 self.hb_out_ts = 0 self.msg_q = [] self.unacknowledged_msg = [] self.ack_request_ts = 0 # used to save the time when the last message, requesting a ACK was send self.max_msg_size = 10024000 # 10 MB? self.server_ip = "illuminum.de" self.server_port = 9875 if (os.path.isfile( os.path.join(os.path.dirname(os.path.realpath(__file__)), "experimental"))): self.server_port = 9775 p.rint("!!!!!!!!! RUNNING ON EXPERIMENTAL PORT !!!!!!!!!!!", "l") self.server_timeout = 15 self.max_outstanding_acks = 2
def start_server (): # context = SSL.Context(SSL.TLSv1_2_METHOD) # context = SSL.Context(SSL.TLSv1_METHOD) # context.use_privatekey_file('startssl.key') # context.use_certificate_file('startssl.cert') # context.use_certificate_chain_file('startssl.cert') s_n = socket.socket() s_n.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s_n.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1) # s = SSL.Connection(context, s_n) s=s_n s.bind(('', PORT)) s.listen(MAX_CLIENTS) # max clients p.rint("[S_wss "+time.strftime("%H:%M:%S")+"] Waiting on wss_clients on Port "+str(PORT),"l") while 1: conn, addr = s.accept() try: #connstream = ssl.wrap_socket(conn, server_side=True, certfile="cert", keyfile="key", ssl_version=ssl.PROTOCOL_TLSv1) # generate new client new_client=ws_clients(conn.getpeername()[1],conn.getpeername()[0]) # port, ip new_client.ws=WebSocket(conn) # append it clients.append(new_client) p.rint("[S_wss "+time.strftime("%H:%M:%S")+"] -> Connection from: "+ str(addr[0])+". Serving "+str(len(clients))+" ws_clients now","l") threading.Thread(target = handle, args = (new_client,addr)).start() # send every subscr for callb in callback_con: callb("connect",new_client) except Exception as n: p.rint("[S_wss "+time.strftime("%H:%M:%S")+"] exception before starting connect thread","d") print(n)
def check_clients(): p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] -> checking clients","r") for cli in clients: if(cli.last_comm>0 and cli.last_comm+cli.comm_timeout<time.time()): p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] disconnecting client as last comm is older than timeout","r") disconnect(cli) p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] -> checking clients done","r")
def set(self,pin,level): if(rpi_support): if(level==0): p.rint("setting pin "+str(pin)+" weak low","g") GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) else: p.rint("setting pin "+str(pin)+" high","g") GPIO.setup(pin, GPIO.OUT) GPIO.output(pin,1) elif(fsys_support and pin>=408 and pin<=415): try: gpiopin = "gpio%s" % (str(pin)) f = open("/sys/class/gpio/"+gpiopin+"/direction","w") f.write("out") f.close() f = open("/sys/class/gpio/"+gpiopin+"/value","w") if(level==0): f.write("0") else: f.write("1") f.close() except: p.warn("failed to write to pin "+str(pin))
def _sendBuffer(self, buff): size = len(buff) tosend = size already_sent = 0 while tosend > 0: try: # i should be able to send a bytearray sent = self.sock.send(buff[already_sent:]) p.rint("send " + str(sent) + " bytes", "w") if sent == 0: raise RuntimeError("socket connection broken") already_sent += sent tosend -= sent except socket.error as e: # if we have full buffers then wait for them to drain and try again if e.errno in [errno.EAGAIN, errno.EWOULDBLOCK]: return buff[already_sent:] else: raise e return None
def _sendBuffer(self, buff): size = len(buff) tosend = size already_sent = 0 while tosend > 0: try: # i should be able to send a bytearray sent = self.sock.send(buff[already_sent:]) p.rint("send "+str(sent)+" bytes","w") if sent == 0: raise RuntimeError("socket connection broken") already_sent += sent tosend -= sent except socket.error as e: # if we have full buffers then wait for them to drain and try again if e.errno in [errno.EAGAIN, errno.EWOULDBLOCK]: return buff[already_sent:] else: raise e return None
def start_server (): context = SSL.Context(SSL.TLSv1_METHOD) # context = SSL.Context(SSL.TLSv1_2_METHOD) context.use_privatekey_file('startssl.key') context.use_certificate_file('startssl.cert') s_n = socket.socket() s_n.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s_n.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1) s = SSL.Connection(context, s_n) s.bind(('', SERVER_PORT)) s.listen(MAX_CONN) # max clients p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] Waiting on m2m_clients on port "+str(SERVER_PORT),"l") while 1: conn, addr = s.accept() #rint(conn.recv(65535)) new_client=m2m_clients(conn) clients.append(new_client) p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] -> Connection from: "+ str(addr[0])+". Serving "+str(len(clients))+" m2m_clients now","l") threading.Thread(target = handle, args = (new_client, addr)).start() # for what ever that might be good for for callb in callback_con: callb("connect",new_client)
def recv_ws_msg_dq_handle(): ret=0 if(len(recv_ws_msg_q)>0): ret=1 recv_msg=recv_ws_msg_q[0] recv_ws_msg_q.remove(recv_msg) data = recv_msg[0] ws = recv_msg[1] try: try: enc=json.loads(data) except: enc="" p.rint("-d--> json decoding failed","d") if(type(enc) is dict): if(enc.get("cmd") == "ping"): msg={} msg["cmd"]="pong" msg_q_ws.append((msg,ws)) elif(enc.get("cmd") == "img"): p.rint("upload pic","d") upload_picture() elif(enc.get("cmd") == "ctrl"): dl=enc.get("dl",0) dr=enc.get("dr",0) pl=enc.get("pl",0) pr=enc.get("pr",0) arduino.digitalWrite(14,dr) # in3, dir righ arduino.setPWM(0,pr) # en3, en right arduino.digitalWrite(13,dl) # in1 dir left arduino.setPWM(9,pl) # en1, left print(str(dl)+"/"+str(dr)+"/"+str(pl)+"/"+str(pr)) else: p.rint("<-- unsopported command received:"+enc.get("cmd"),"l") except: p.err("sys:") p.err(str(sys.exc_info()[0])) p.err(str(sys.exc_info()[1])) p.err(str(repr(traceback.format_tb(sys.exc_info()[2])))) return ret
def start_server(): # context = SSL.Context(SSL.TLSv1_2_METHOD) context = SSL.Context(SSL.TLSv1_METHOD) context.use_privatekey_file('startssl.key') context.use_certificate_file('startssl.cert') context.use_certificate_chain_file('startssl.cert') s_n = socket.socket() s_n.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s_n.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1) s = SSL.Connection(context, s_n) s.bind(('', PORT)) s.listen(MAX_CLIENTS) # max clients p.rint( "[S_wss " + time.strftime("%H:%M:%S") + "] Waiting on wss_clients on Port " + str(PORT), "l") while 1: conn, addr = s.accept() try: #connstream = ssl.wrap_socket(conn, server_side=True, certfile="cert", keyfile="key", ssl_version=ssl.PROTOCOL_TLSv1) # generate new client new_client = ws_clients(conn.getpeername()[1], conn.getpeername()[0]) # port, ip new_client.ws = WebSocket(conn) # append it clients.append(new_client) p.rint( "[S_wss " + time.strftime("%H:%M:%S") + "] -> Connection from: " + str(addr[0]) + ". Serving " + str(len(clients)) + " ws_clients now", "l") threading.Thread(target=handle, args=(new_client, addr)).start() # send every subscr for callb in callback_con: callb("connect", new_client) except Exception as n: p.rint( "[S_wss " + time.strftime("%H:%M:%S") + "] exception before starting connect thread", "d") print(n)
def stop_server(): send_data_all_clients(bytes("shutdown","UTF-8")) p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] -> shutdown","d") os._exit(1)
def parse_incoming_msg(con): global register_mode, m2m_pw, m2m_mid p.set_last_action("start recv") try: data = con.sock.recv(con.max_msg_size) if (len(data) == 0): p.rint("disconnect", "l") client_socket = "" p.set_last_action("disconnected") return -1 p.rint("received " + str(len(data)) + " byte", "v") p.set_last_action("decoding") data_dec = data.decode("UTF-8") #rint("Data received:"+str(data)) except: p.rint('client_socket.recv detected error', "d") return -1 p.set_last_action("start parse") data_dec = con.recv_buffer + data_dec data_array = data_dec.split( '}' ) # might have multiple JSON messages in the buffer or just "{blab}_" for a in range(0, len(data_array) - 1): data_array[a] += '}' # add } again, as it got lost during "split" try: enc = json.loads(data_array[a]) except: p.rint("json decode failed on:" + data_array[a], "l") p.set_last_action("decoding bad") return -2 # bad message, reconnect if (type(enc) is dict): con.last_transfer = time.time() #rint("json decoded msg") #rint(enc) # ack ok packets are always send alone, they carry the cmd to acknowledge, but the reason will be a separate msg if (enc.get("ack_ok", 0) == 1): #rint("this is an ack ok package "+str(len(con.unacknowledged_msg))) if (len(con.unacknowledged_msg) > 0): for ele in con.unacknowledged_msg: if (ele[0] == enc.get("cmd", 0)): # find the right entry con.unacknowledged_msg.remove(ele) if (time.time() - d.last_pic_taken_ts < 15): if (d.estimated_fps == 0): d.estimated_fps = 1 / (time.time() - d.last_pic_taken_ts) else: d.estimated_fps = 0.90 * d.estimated_fps + 0.10 / ( time.time() - d.last_pic_taken_ts) break #rint("comm wait dec at "+str(time.time())+" --> "+str(len(con.unacknowledged_msg))) # recalc timestamp if (len(con.unacknowledged_msg) == 0): con.ack_request_ts = 0 # clear ts else: con.ack_request_ts = con.unacknowledged_msg[0][ 1] # move to latest ts ############## M2M CMD ############# prelogin elif (enc.get("cmd") == "prelogin" and register_mode == 0): p.rint("<-- encryption challange received", "l") #### send login #rint("received challange "+enc.get("challange")) h = hashlib.md5() # hash the login with the challange h.update(str(m2m_pw + enc.get("challange")).encode("UTF-8")) #rint("total to code="+str(pw+enc.get("challange"))) pw_c = h.hexdigest() #rint("result="+pw_c) path = os.path.join( os.path.dirname(os.path.realpath(__file__)), "..", "..", ".git") v_sec = SEC_VERSION #check if there is a user pi try: pwd.getpwnam('pi') v_hash = str( subprocess.Popen( [ "sudo", "-u", "pi", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) except: v_hash = str( subprocess.Popen( [ "sudo", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) p.rint("<-> hash " + str(v_hash), "l") msg = {} msg["mid"] = m2m_mid msg["client_pw"] = pw_c msg["cmd"] = "login" msg["state"] = trigger.r.s.state msg["detection"] = trigger.r.s.detection msg["ts"] = time.strftime("%d.%m.%Y || %H:%M:%S") msg["ack"] = 1 msg["v_sec"] = v_sec msg["v_hash"] = v_hash con.msg_q.append(msg) ############## M2M CMD ############# prelogin elif (enc.get("cmd") == "prelogin" and register_mode == 1): # try to get cam name from raspimjpeg config file alias = "SecretCam" if (os.path.isfile( os.path.join( os.path.dirname(os.path.realpath(__file__)), "../gpucam/annotation.config"))): file = open( os.path.join( os.path.dirname(os.path.realpath(__file__)), "../gpucam/annotation.config"), "r") file_c = file.readlines() for line in file_c: if (line.find("annotation") == 0 and line.find("%04d.%02d.%02d_%02d:%02d:%02d") > 0): alias = line[ len("annotation") + 1:line.find("%04d.%02d.%02d_%02d:%02d:%02d") - 1] break ws_login = input("Please enter your username: "******"Hi " + ws_login + ", please enter your userpassword: "******"UTF-8")) ws_pw_enc = h.hexdigest() h = hashlib.md5() h.update(str(ws_pw_enc + enc.get("challange")).encode("UTF-8")) ws_pw_ch_enc = h.hexdigest() msg = {} msg["mid"] = m2m_mid msg["login"] = ws_login msg["password"] = ws_pw_ch_enc msg["m2m_pw"] = m2m_pw msg["cmd"] = "register" msg["alias"] = alias con.msg_q.append(msg) #rint(msg) ############## M2M CMD ############# login elif (enc.get("cmd") == "login"): if (enc.get("ok") == 1): con.logged_in = 1 r = enc.get("mRed", 0) g = enc.get("mGreen", 0) b = enc.get("mBlue", 0) light.runner.l.d_r = r light.runner.l.d_g = g light.runner.l.d_b = b p.rint("<-- received log-in OK", "l") p.rint( "<-- setting detection to " + str(enc.get("detection")), "l") trigger.set_detection(int(enc.get("detection"))) else: con.logged_in = 0 p.rint("<-- ERROR log-in failed", "l") ############## M2M CMD ############# heartbeat elif (enc.get("cmd") == "m2m_hb"): con.hb_out = 0 p.rint("<-- connection checked OK", "l") ############## M2M CMD ############# set detection elif (enc.get("cmd") == "set_detection"): p.rint( "<-- received request to change detection state to " + str(enc.get("state")), "l") trigger.set_detection(enc.get("state")) ############## M2M CMD ############# write file elif (enc.get("cmd") == "wf"): ignore = 1 ############## M2M CMD ############# set color elif (enc.get("cmd") == "set_color"): # avoid light output message, like to many many commands r = enc.get("r", 0) g = enc.get("g", 0) b = enc.get("b", 0) light.set_color(r, g, b) light.add_q_entry(time.time(), r, g, b, 500) # 4 sec to dimm to warm orange - now ############## M2M CMD ############# set camera intervall elif (enc.get("cmd") == "set_interval"): if (enc.get("interval", 0) == 0): cam.webview_active = 0 gpio.set(gpio.PIN_CAM, 0) p.rint("<-- switching webcam off", "l") else: cam.webview_active = 1 gpio.set(gpio.PIN_CAM, 1) p.rint("<-- switching webcam on", "l") cam.interval = (enc.get("interval", 0)) cam.quality = (enc.get("qual", "HD")) if (enc.get("alarm_while_streaming", "no_alarm") == "alarm"): cam.alarm_while_streaming = 1 else: cam.alarm_while_streaming = 0 ######### SPY MODE ######### if (enc.get("interval", 0) > 0): (r, g, b) = light.runner.get_color() light.set_old_color( r, g, b, time.time() + light.get_delay_off() ) # set the color to which we return as soon as the webfeed is closed light.add_q_entry( time.time(), 0, 255, 0, 1000) # 4 sec to dimm to off - in 10 min from now else: light.add_q_entry( time.time(), -1, -1, -1, 1000) # 4 sec to dimm to off - in 10 min from now ######### SPY MODE ######### ############## M2M CMD ############# register elif (enc.get("cmd") == "register"): if (enc.get("ok", 0) == 1): p.rint("<-- successful registered, sending sign in", "l") register_mode = 0 else: p.rint( "<-- registration was not successful, status: " + str(enc.get("ok")) + ". Starting over", "l") msg = {} msg["mid"] = m2m_mid msg["cmd"] = "prelogin" con.msg_q.append(msg) ############## M2M CMD ############# update parameter elif (enc.get("cmd") == "update_parameter"): p.rint("<-- Received Parameter update from server", "l") if (enc.get("alarm_while_streaming", "no_alarm") == "alarm"): cam.alarm_while_streaming = 1 else: cam.alarm_while_streaming = 0 cam.interval = (enc.get("interval", 0)) cam.quality = (enc.get("qual", "HD")) # save old parameter old_with_cam = config.with_cam old_with_lights = config.with_lights old_with_ext = config.with_ext old_with_pir = config.with_pir # save new parameter config.with_pir = int(enc.get("with_pir", "0")) config.with_lights = int(enc.get("with_lights", "0")) config.with_ext = int(enc.get("with_ext", "0")) config.with_cam = int(enc.get("with_cam", "0")) # re-starting the light and trigger with new parameter, if different if (config.with_lights != old_with_lights): p.rint("=== (re)start light, as configuration has changed", "l") light.restart(config) time.sleep(1) if (config.with_pir != old_with_pir): p.rint( "=== (re)start trigger, as configuration has changed", "l") trigger.restart(config, gpio) ############## M2M CMD ############# get the git version elif (enc.get("cmd") == "get_version"): path = os.path.join( os.path.dirname(os.path.realpath(__file__)), "..", "..", ".git") try: pwd.getpwnam('pi') v_short = str( subprocess.Popen([ "sudo", "-u", "pi", "git", "--git-dir", path, "rev-list", "HEAD", "--count" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() [0].decode()).replace("\n", "") v_hash = str( subprocess.Popen( [ "sudo", "-u", "pi", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) except: v_short = str( subprocess.Popen([ "sudo", "git", "--git-dir", path, "rev-list", "HEAD", "--count" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() [0].decode()).replace("\n", "") v_hash = str( subprocess.Popen( [ "sudo", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) p.rint( "<-> version request received from server, returning " + str(v_hash), "l") msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["v_short"] = v_short msg["v_hash"] = v_hash con.msg_q.append(msg) ############## M2M CMD ############# run a git update elif (enc.get("cmd") == "git_update"): p.rint("<-- update request received from server", "l") # remount root rw rw() path = os.path.join( os.path.dirname(os.path.realpath(__file__)), "..", "..", ".git") # run the update try: pwd.getpwnam('pi') result = subprocess.Popen( ["sudo", "-u", "pi", "git", "pull"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() except: result = subprocess.Popen( ["sudo", "git", "pull"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() ret_res = result[0].decode().replace("\n", "") # get new version try: pwd.getpwnam('pi') v_short = str( subprocess.Popen([ "sudo", "-u", "pi", "git", "--git-dir", path, "rev-list", "HEAD", "--count" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() [0].decode()).replace("\n", "") v_hash = str( subprocess.Popen( [ "sudo", "-u", "pi", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) except: v_short = str( subprocess.Popen([ "sudo" "git", "--git-dir", path, "rev-list", "HEAD", "--count" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() [0].decode()).replace("\n", "") v_hash = str( subprocess.Popen( [ "sudo", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1" ], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["v_short"] = v_short msg["v_hash"] = v_hash msg["cmd_result"] = ret_res con.msg_q.append(msg) ############## M2M CMD ############## run a reboot elif (enc.get("cmd") == "reboot"): con.sock.shutdown() con.sock.close() print("<- ============================") print("<- ======== rebooting =========") print("<- ============================") result = str( subprocess.Popen("reboot", stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() [0].decode()).replace("\n", "") ############## M2M CMD ############# set a pin elif (enc.get("cmd") == "toggle_external_pin"): state = 0 if (str(enc.get("state", 0)) == "1"): state = 1 p.rint("<-- switching external pin to " + str(state), "l") gpio.set(gpio.PIN_USER, state) msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["ok"] = "1" con.msg_q.append(msg) ############## M2M CMD ############## set alias elif (enc.get("cmd") == "set_alias"): alias = enc.get("alias", "-") p.rint("<-- Trying to set a new name: " + str(alias), "l") msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["ok"] = "-1" try: # remount root rw rw() # run update path = os.path.join( os.path.dirname(os.path.realpath(__file__)), "..", "gpucam") if (os.path.isfile(os.path.join(path, "annotation.config"))): file = open(os.path.join(path, "annotation.config"), "w") file.write( "annotation " + alias + " %04d.%02d.%02d_%02d:%02d:%02d \nanno_background false" ) file.close() subprocess.Popen(os.path.join(path, "generate_config.sh"), stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() msg["ok"] = "1" p.rint("--> Setting new alias, ok", "l") except: import sys, traceback print("sys:") print(str(sys.exc_info()[0])) print(str(sys.exc_info()[1])) print(str(repr(traceback.format_tb(sys.exc_info()[2])))) print("--> setting new name failed") con.msg_q.append(msg) ############## M2M CMD ############# this is the monitoring section, if the device is set as a monitor it will receive the state_change from all other m2ms in the same area elif (enc.get("cmd") == "state_change"): ### update the state that we've saved, or add client to list f = 0 for m in w.clients: if (m.mid == enc.get("mid")): m.state = enc.get("state") f = 1 break if (f == 0): w.clients.append( watcher_m2m(mid=enc.get("mid"), state=enc.get("state"))) ### check all states all_state = 0 #0=idle, 1=alert, 2=detection disabled, idle, 3=detection disabled, movement for m in w.clients: if (m.state % 2 == 1): all_state = 1 break if (all_state == 0): #we are convinced that there is no movement anymore if (w.handle_movements_stopped != ""): w.handle_movements_stopped.cancel() if (w.handle_movements_started != ""): w.handle_movements_started.cancel() w.handle_movements_stopped = external.movements_stopped() w.handle_movements_stopped.start() else: # stop callback that would switch off stuff and call the switch on if (w.handle_movements_stopped != ""): w.handle_movements_stopped.cancel() if (w.handle_movements_started != ""): w.handle_movements_started.cancel() w.handle_movements_started = external.movements_started() w.handle_movements_started.start() ############## M2M CMD ############# backup else: p.rint("<-- unsupported command received:" + enc.get("cmd"), "l") #end of "if" # end of "for" if (data_array[len(data_array) - 1] == ""): #if data contained a full message and ended with closing tag, we a$ con.recv_buffer = "" else: # but if we grabbed something like 1.5 messages, we should buffer $ con.recv_buffer = data_array[len(data_array) - 1] #rint("using buffer!") p.set_last_action("recv done") return 0
def connect(con): global register_mode, m2m_mid p.rint("--> connecting to illuminum server ...", "l") p.set_last_action("connecting") context = OpenSSL.SSL.Context(OpenSSL.SSL.TLSv1_METHOD) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) c_socket = OpenSSL.SSL.Connection(context, s) try: c_socket.connect((con.server_ip, con.server_port)) except: p.rint("Could not connect to server", "l") p.rint("retrying in 3 sec", "l") time.sleep(3) return -1 p.rint("<-- connected to server. ", "l") if (register_mode == 0): p.rint("--> Starting log-in process", "l") else: p.rint("--> Begin register process...", "l") p.set_last_action("connecting done") #### prelogin msg = {} msg["mid"] = m2m_mid msg["cmd"] = "prelogin" con.msg_q.append(msg) #int("sending prelogin request") return c_socket
def trigger_handle(event, data): global cam global con global register_mode if (event == "state_change"): _state = data[0] _detection = data[1] #rint("setting in client.py "+str(_state)+" / "+str(_detection)) if (register_mode == 0): p.rint( "Switch to state '" + trigger.m2m_state[_state] + "' with detection '" + trigger.det_state[_detection] + "'", "v") msg = {} msg["cmd"] = event msg["state"] = _state msg["detection"] = _detection ##### delete ALL old status msg, and place the current status in the queue ######### for m in con.msg_q: if (msg["cmd"] == m["cmd"]): con.msg_q.remove(m) # avoid message on alarm if alarm_while_streaming=0 at various conditions send_msg = 1 if (_state > 0 and _detection > 0 and cam.alarm_while_streaming == 0): if (cam.webview_active == 1): # no alarm while streaming send_msg = 0 elif (time.time() - cam.last_picture_taken_ts < 5): # dead - time after streaming, 5 sec send_msg = 0 if (send_msg): # if we have a new status, check the complete queue if we have old unsend stati and remove them first, they aren't valid anymore for msg_i in con.msg_q: if (msg_i["cmd"] == msg["cmd"]): con.msg_q.remove(msg_i) con.msg_q.append(msg) ##### delete ALL old status msg, and place the current status in the queue ######### ##### light dimming ######### # if we change the state of the sensor, we should most likely change the light # clear all old dimming actions light.clear_q() # set new color if (_detection == 0 and _state == 1): # deactive and motion if ( cam.webview_active == 0 ): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time(), light.runner.l.d_r, light.runner.l.d_g, light.runner.l.d_b, 4000) # 4 sec to dimm to default color - now else: (r, g, b) = light.runner.get_color() light.set_old_color( r, g, b, time.time() + light.get_delay_off() ) # set the color to which we return as soon as the webfeed is closed elif (_detection == 0 and _state == 0): # deactive and no motion if ( cam.webview_active == 0 ): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry( time.time() + light.get_delay_off(), 0, 0, 0, 4000) # 4 sec to dimm to off - in 10 min from now else: (r, g, b) = light.runner.get_color() light.set_old_color( r, g, b, time.time() + light.get_delay_off() ) # set the color to which we return as soon as the webfeed is closed #rint("[A "+time.strftime("%H:%M:%S")+"] setting lights off to "+str((datetime.datetime.fromtimestamp(int((time.time()+light.get_delay_off())))).strftime('%y_%m_%d %H:%M:%S'))) elif (_detection == 1 and _state == 1): # alarm, go red, now if ( cam.webview_active == 0 ): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time(), 100, 0, 0, 4000) else: light.set_old_color( 100, 0, 0, time.time() + light.get_delay_off() ) # set the color to which we return as soon as the webfeed is closed elif (_detection == 1 and _state == 0): # off while nobody is there if ( cam.webview_active == 0 ): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time(), 0, 0, 0, 4000) else: (r, g, b) = light.runner.get_color() light.set_old_color( r, g, b, time.time() + light.get_delay_off() ) # set the color to which we return as soon as the webfeed is closed ##### light dimming ######### ##### camera picture upload ######### if (_state > 0 and _detection > 0): # alarm state if (cam.alarm_in_alarm_state == 0): cam.alarm_in_alarm_state = 1 cam.alarm_pictures_remaining = 5 else: # state==0 or detection==0, leave the picture remaining so we can finish uploading all 5 pictures per alarm cam.alarm_in_alarm_state = 0 ##### camera picture upload ######### ##### set the gpio pins ##### g_state = 0 if (_state > 0): g_state = 1 gpio.set(gpio.PIN_MOVEMENT, g_state) g_detection = 0 if (_detection > 0): g_detection = 1 gpio.set(gpio.PIN_DETECTION, g_detection)
def parse_incoming_msg(con): global register_mode, m2m_pw, m2m_mid p.set_last_action("start recv") try: data = con.sock.recv(con.max_msg_size) if(len(data) == 0): p.rint("disconnect","l") client_socket = "" p.set_last_action("disconnected") return -1 p.rint("received "+str(len(data))+" byte", "v") p.set_last_action("decoding") data_dec = data.decode("UTF-8") #rint("Data received:"+str(data)) except: p.rint('client_socket.recv detected error',"d") return -1 p.set_last_action("start parse") data_dec = con.recv_buffer+data_dec data_array = data_dec.split('}') # might have multiple JSON messages in the buffer or just "{blab}_" for a in range(0, len(data_array)-1): data_array[a] += '}' # add } again, as it got lost during "split" try: enc = json.loads(data_array[a]) except: p.rint("json decode failed on:"+data_array[a],"l") p.set_last_action("decoding bad") return -2 # bad message, reconnect if(type(enc) is dict): con.last_transfer = time.time() #rint("json decoded msg") #rint(enc) # ack ok packets are always send alone, they carry the cmd to acknowledge, but the reason will be a separate msg if(enc.get("ack_ok", 0) == 1): #rint("this is an ack ok package "+str(len(con.unacknowledged_msg))) if(len(con.unacknowledged_msg) > 0): for ele in con.unacknowledged_msg: if(ele[0] == enc.get("cmd", 0)): # find the right entry con.unacknowledged_msg.remove(ele) if(time.time()-d.last_pic_taken_ts<15): if(d.estimated_fps==0): d.estimated_fps = 1/(time.time()-d.last_pic_taken_ts) else: d.estimated_fps = 0.90 * d.estimated_fps + 0.10 / (time.time()-d.last_pic_taken_ts) break #rint("comm wait dec at "+str(time.time())+" --> "+str(len(con.unacknowledged_msg))) # recalc timestamp if(len(con.unacknowledged_msg) == 0): con.ack_request_ts = 0 # clear ts else: con.ack_request_ts = con.unacknowledged_msg[0][1] # move to latest ts elif(enc.get("cmd") == "prelogin" and register_mode==0): p.rint("<-- encryption challange received","l") #### send login #rint("received challange "+enc.get("challange")) h = hashlib.md5() # hash the login with the challange h.update(str(m2m_pw+enc.get("challange")).encode("UTF-8")) #rint("total to code="+str(pw+enc.get("challange"))) pw_c = h.hexdigest() #rint("result="+pw_c) path=os.path.join(os.path.dirname(os.path.realpath(__file__)),"..","..",".git") v_sec=SEC_VERSION #check if there is a user pi try: pwd.getpwnam('pi') v_hash=str(subprocess.Popen(["sudo","-u","pi", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) except: v_hash=str(subprocess.Popen(["sudo", "git", "--git-dir", path, "log", "--pretty=format:%h", "-n", "1"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) p.rint("<-> hash "+str(v_hash),"l") msg = {} msg["mid"] = m2m_mid msg["client_pw"] = pw_c msg["cmd"] = "login" msg["state"] = trigger.r.s.state msg["detection"] = trigger.r.s.detection msg["ts"] = time.strftime("%d.%m.%Y || %H:%M:%S") msg["ack"] = 1 msg["v_sec"] = v_sec msg["v_hash"] = v_hash con.msg_q.append(msg) elif(enc.get("cmd") == "prelogin" and register_mode==1): # try to get cam name from raspimjpeg config file alias="SecretCam" if(os.path.isfile(os.path.join(os.path.dirname(os.path.realpath(__file__)),"../gpucam/annotation.config"))): file=open(os.path.join(os.path.dirname(os.path.realpath(__file__)),"../gpucam/annotation.config"),"r") file_c=file.readlines() for line in file_c: if(line.find("annotation")==0 and line.find("%04d.%02d.%02d_%02d:%02d:%02d")>0): alias=line[len("annotation")+1:line.find("%04d.%02d.%02d_%02d:%02d:%02d")-1] break ws_login = input("Please enter your username: "******"Hi "+ws_login+", please enter your userpassword: "******"UTF-8")) ws_pw_enc = h.hexdigest() h = hashlib.md5() h.update(str(ws_pw_enc+enc.get("challange")).encode("UTF-8")) ws_pw_ch_enc = h.hexdigest() msg = {} msg["mid"] = m2m_mid msg["login"] = ws_login msg["password"] = ws_pw_ch_enc msg["m2m_pw"] = m2m_pw msg["cmd"] = "register" msg["alias"] = alias con.msg_q.append(msg) #rint(msg) elif(enc.get("cmd") == "login"): if(enc.get("ok") == 1): con.logged_in = 1 r = enc.get("mRed",0) g = enc.get("mGreen",0) b = enc.get("mBlue",0) light.runner.l.d_r = r light.runner.l.d_g = g light.runner.l.d_b = b p.rint("<-- received log-in OK","l") p.rint("<-- setting detection to "+str(enc.get("detection")),"l") trigger.set_detection(int(enc.get("detection"))) else: con.logged_in = 0 p.rint("<-- ERROR log-in failed","l") elif(enc.get("cmd") == "m2m_hb"): con.hb_out = 0 p.rint("<-- connection checked OK","l") elif(enc.get("cmd") == "set_detection"): p.rint("<-- received request to change detection state to "+str(enc.get("state")),"l") trigger.set_detection(enc.get("state")) elif(enc.get("cmd") == "wf"): ignore = 1 elif(enc.get("cmd") == "set_color"): # avoid light output message, like to many many commands r = enc.get("r", 0) g = enc.get("g", 0) b = enc.get("b", 0) light.set_color(r,g,b) light.add_q_entry(time.time(), r, g, b, 500) # 4 sec to dimm to warm orange - now elif(enc.get("cmd") == "set_interval"): if(enc.get("interval", 0) == 0): cam.webview_active = 0 gpio.set(gpio.PIN_CAM,0) p.rint("<-- switching webcam off","l") else: cam.webview_active = 1 gpio.set(gpio.PIN_CAM,1) p.rint("<-- switching webcam on","l") cam.interval = (enc.get("interval", 0)) cam.quality = (enc.get("qual", "HD")) if(enc.get("alarm_while_streaming","no_alarm")=="alarm"): cam.alarm_while_streaming = 1 else: cam.alarm_while_streaming = 0 ######### SPY MODE ######### if(enc.get("interval",0)>0): (r,g,b) = light.runner.get_color() light.set_old_color(r,g,b,time.time()+light.get_delay_off()) # set the color to which we return as soon as the webfeed is closed light.add_q_entry(time.time(),0,255,0,1000) # 4 sec to dimm to off - in 10 min from now else: light.add_q_entry(time.time(),-1,-1,-1,1000) # 4 sec to dimm to off - in 10 min from now ######### SPY MODE ######### elif(enc.get("cmd") == "register"): if(enc.get("ok",0) == 1): p.rint("<-- successful registered, sending sign in","l") register_mode=0 else: p.rint("<-- registration was not successful, status: "+str(enc.get("ok"))+". Starting over","l") msg = {} msg["mid"] = m2m_mid msg["cmd"] = "prelogin" con.msg_q.append(msg) elif(enc.get("cmd") == "update_parameter"): p.rint("<-- Received Parameter update from server","l") if(enc.get("alarm_while_streaming","no_alarm")=="alarm"): cam.alarm_while_streaming = 1 else: cam.alarm_while_streaming = 0 cam.interval = (enc.get("interval", 0)) cam.quality = (enc.get("qual", "HD")) # save old parameter old_with_cam = config.with_cam old_with_lights = config.with_lights old_with_ext = config.with_ext old_with_pir = config.with_pir # save new parameter config.with_pir = int(enc.get("with_pir", "0")) config.with_lights = int(enc.get("with_lights", "0")) config.with_ext = int(enc.get("with_ext", "0")) config.with_cam = int(enc.get("with_cam", "0")) # re-starting the light and trigger with new parameter, if different if(config.with_lights != old_with_lights): p.rint("=== (re)start light, as configuration has changed","l") light.restart(config) time.sleep(1) if(config.with_pir != old_with_pir): p.rint("=== (re)start trigger, as configuration has changed","l") trigger.restart(config,gpio) # get the git version elif(enc.get("cmd") == "get_version"): path=os.path.join(os.path.dirname(os.path.realpath(__file__)),"..","..",".git") try: pwd.getpwnam('pi') v_short=str(subprocess.Popen(["sudo","-u","pi", "git","--git-dir", path, "rev-list", "HEAD", "--count"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()).replace("\n","") v_hash=str(subprocess.Popen(["sudo","-u","pi", "git","--git-dir", path,"log", "--pretty=format:%h", "-n", "1"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) except: v_short=str(subprocess.Popen(["sudo", "git","--git-dir", path, "rev-list", "HEAD", "--count"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()).replace("\n","") v_hash=str(subprocess.Popen(["sudo", "git","--git-dir", path,"log", "--pretty=format:%h", "-n", "1"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) p.rint("<-> version request received from server, returning "+str(v_hash),"l") msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["v_short"] = v_short msg["v_hash"] = v_hash con.msg_q.append(msg) # run a git update elif(enc.get("cmd") == "git_update"): p.rint("<-- update request received from server","l") # remount root rw rw() path=os.path.join(os.path.dirname(os.path.realpath(__file__)),"..","..",".git") # run the update try: pwd.getpwnam('pi') result=subprocess.Popen(["sudo","-u","pi", "git", "pull"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() except: result=subprocess.Popen(["sudo", "git", "pull"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() ret_res=result[0].decode().replace("\n","") # get new version try: pwd.getpwnam('pi') v_short=str(subprocess.Popen(["sudo","-u","pi", "git","--git-dir", path, "rev-list", "HEAD", "--count"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()).replace("\n","") v_hash=str(subprocess.Popen(["sudo","-u","pi", "git","--git-dir", path,"log", "--pretty=format:%h", "-n", "1"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) except: v_short=str(subprocess.Popen(["sudo" "git","--git-dir", path, "rev-list", "HEAD", "--count"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()).replace("\n","") v_hash=str(subprocess.Popen(["sudo", "git","--git-dir", path,"log", "--pretty=format:%h", "-n", "1"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["v_short"] = v_short msg["v_hash"] = v_hash msg["cmd_result"] = ret_res con.msg_q.append(msg) # run a reboot elif(enc.get("cmd") == "reboot"): con.sock.shutdown() con.sock.close() print("<- ============================") print("<- ======== rebooting =========") print("<- ============================") result=str(subprocess.Popen("reboot",stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()).replace("\n","") # set a pin elif(enc.get("cmd") == "toggle_external_pin"): state = 0 if(str(enc.get("state",0))=="1"): state = 1 p.rint("<-- switching external pin to "+str(state),"l") gpio.set(gpio.PIN_USER,state) msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["ok"] = "1" con.msg_q.append(msg) # set alias elif(enc.get("cmd") == "set_alias"): alias = enc.get("alias","-") p.rint("<-- Trying to set a new name: "+str(alias),"l") msg = {} msg["mid"] = m2m_mid msg["cmd"] = enc.get("cmd") msg["ok"] = "-1" try: # remount root rw rw() # run update path = os.path.join(os.path.dirname(os.path.realpath(__file__)),"..","gpucam") if(os.path.isfile(os.path.join(path,"annotation.config"))): file=open(os.path.join(path,"annotation.config"),"w") file.write("annotation "+alias+" %04d.%02d.%02d_%02d:%02d:%02d \nanno_background false") file.close() subprocess.Popen(os.path.join(path,"generate_config.sh"),stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate() msg["ok"] = "1" p.rint("--> Setting new alias, ok","l") except: import sys, traceback print("sys:") print(str(sys.exc_info()[0])) print(str(sys.exc_info()[1])) print(str(repr(traceback.format_tb(sys.exc_info()[2])))) print("--> setting new name failed") con.msg_q.append(msg) else: p.rint("<-- unsopported command received:"+enc.get("cmd"),"l") #end of "if" # end of "for" if(data_array[len(data_array)-1] == ""): #if data contained a full message and ended with closing tag, we a$ con.recv_buffer = "" else: # but if we grabbed something like 1.5 messages, we should buffer $ con.recv_buffer = data_array[len(data_array)-1] #rint("using buffer!") p.set_last_action("recv done") return 0
def handle(client, addr): t1 = 0 t2 = 0 busy = 1 client.last_comm = time.time() #lock = threading.Lock() while client.alive: try: rList, wList, xList = select([client.ws.sock], [client.ws.sock], [client.ws.sock], 3) except: break if (busy == 0): time.sleep(0.03) busy = 0 ######################## SEND ########################### if (len(wList) > 0): try: t1 = time.time() while client.ws.sendq: busy = 1 opcode, payload = client.ws.sendq.popleft() remaining = client.ws._sendBuffer(payload) if remaining is not None: client.ws.sendq.appendleft((opcode, remaining)) break else: if opcode == CLOSE: for callb in callback_con: callb("disconnect", client) t1 = time.time() - t1 except Exception as n: disconnect(client) ######################## SEND ########################### ####################### RECEIVE ########################## if (len(rList) > 0): busy = 1 lt = "" try: lt = "start _handleData()" t2 = time.time() if (client.ws._handleData() == -1): disconnect(client) while (client.ws.data_ready == True): lt = "Start getMessage()" msg = client.ws.getMessage( ) # getMessage will unset the data_ready flag if no data left if (client.ws.data_ready == True): #print(msg) # <-- prints the received data lt = "Start callb" for callb in callback_msg: callb(msg, client) #client.ws.data_ready=False #client.ws.last_data="" t2 = time.time() - t2 except (SSL.ZeroReturnError, SSL.SysCallError): # regular good SSL disconnect disconnect(client) except ValueError as err: # disconnct while handshake disconnect(client) except Exception as n: print("except while read in server_ws, our status ", end="") print(lt) print("sys:", end="") print(sys.exc_info()[0]) print(sys.exc_info()[1]) print(repr(traceback.format_tb(sys.exc_info()[2]))) print("") disconnect(client) ####################### RECEIVE ########################## ######################## ERROR ########################## if (len(xList) > 0): busy = 1 disconnect(client) ######################## ERROR ########################## ######################## MAINTAINANCE ########################## if (time.time() - client.debug_ts > 1): #if(time.time()-client.debug_ts>10): # print("woohoo its me") # print(t1) # print(t2) client.debug_ts = time.time() ######################## MAINTAINANCE ########################## # end of while 1 p.rint( "[S_wss " + time.strftime("%H:%M:%S") + "] -> Client " + str(client.login) + " closed: " + str(client.ip), "l")
def set_old_color(self,r,g,b,lifetime): p.rint("LIGHT setting old color "+str(r)+"/"+str(g)+"/"+str(b)+" in "+str(lifetime-time.time())+" sec","r") self.l.o_rd=r self.l.o_gd=g self.l.o_bd=b self.l.o_lifetime = lifetime
def add_q_entry(when,r,g,b,duration_ms): p.rint("LIGHT, add_q_entry: setting color "+str(r)+"/"+str(g)+"/"+str(b)+" in "+str(when-time.time())+" sec from now","r") runner.add_q_entry(when,r,g,b,duration_ms)
f_content='class login:\r\n def __init__(self):\r\n self.pw="'+m2m_pw+'"\n self.mid="'+m2m_mid+'"\n' rw() file=open(os.path.join(os.path.dirname(os.path.realpath(__file__)),"login.py"),"w") file.write(f_content) file.close() return (m2m_mid,m2m_pw) ###################### try import login ####################### register_mode=0 if(os.path.isfile(os.path.join(os.path.dirname(os.path.realpath(__file__)),"login.py"))): from login import * l = login() # login m2m_pw=l.pw p.rint("STARTUP, login.py found, password loaded","l") try: p.rint("STARTUP, login.py found, mid loaded","l") m2m_mid = l.mid except: p.rint("STARTUP, login.py without mid loaded, create new one","l") (m2m_mid,m2m_pw) = create_login("", m2m_pw) else: register_mode=1 # first time connection, create a password and send it to the server (m2m_mid,m2m_pw) = create_login("", "") p.rint("STARTUP, no login.py found, running in register mode","l")
def set_detection(self,_detection): self.state_change_event=1 self.detection=_detection p.rint("TRIGGER detection set to "+str(det_state[_detection]),"l")
def print_rules(self,bars=1,account_info=1,print_out=1,formating=1,header=1,dict=0): if(dict): ret_dict={} ret_dict["name"]=self.area ret_dict["rules"]=[] ret_dict["subrules"]=[] header=0 print_out=0 account_info=0 bars=0 formating=0 else: ret="" if(bars): ret+="|||+ " if(account_info): ret+="This is area '"+self.area+"' on account '"+self.account+"'. I have " ret+=str(len(self.rules))+" active rules and "+str(len(self.sub_rules))+" subrules\r\n" i=1 if(bars): ret+="(r)|||+ " if(header): ret+="Rules: <br>(protection activ if at least one is true)\r\n" for r in self.rules: ## marker g=0 if(bars): ret+="(r)||||- " if(self.eval_rule(r.conn,r.arg1,r.arg2,10,1,r.id)>=1): if(formating): ret+="<g>" g=1 else: if(formating): ret+="<r>" ## marker txt=self.explain_rule(r,g,i) if(dict): ret_dict["rules"].append((r.id,r.conn,r.arg1,r.arg2,g)) else: ret+=txt ## marker if(g): if(formating): ret+="</g>\r\n" else: if(formating): ret+="</r>\r\n" ## marker i+=1 if(len(self.rules)==0): if(bars): ret+="(r)||||- " if(formating): ret+="<g>none</g>\r\n" i=1 if(bars): ret+="(r)|||\r\n" ret+="(r)|||+ " if(header): ret+="Sub-Rules:\r\n" for r in self.sub_rules: ## marker g=0 if(bars): ret+="(r)||||- " if(self.eval_rule(r.conn,r.arg1,r.arg2,10,1,r.id)>=1): if(formating): ret+="<g>" g=1 else: if(formating): ret+="<r>" ## marker txt=self.explain_rule(r,g,i) if(dict): ret_dict["subrules"].append((r.id,txt,g)) else: ret+=txt ## marker if(g): if(formating): ret+="</g>" else: if(formating): ret+="</r>" ## marker i+=1 if(dict!=1): if((i-1)<len(self.sub_rules)): ret+="\r\n" if(len(self.sub_rules)==0): if(bars): ret+="(r)||||- " if(formating): ret+="<g>none</g>" if(print_out): p.rint(ret,"r") return 0 if(dict): return ret_dict return ret
def trigger_handle(event, data): global cam global con global register_mode if(event == "state_change"): _state = data[0] _detection = data[1] #rint("setting in client.py "+str(_state)+" / "+str(_detection)) if(register_mode==0): p.rint("Switch to state '"+trigger.m2m_state[_state]+"' with detection '"+trigger.det_state[_detection]+"'","v") msg = {} msg["cmd"] = event msg["state"] = _state msg["detection"] = _detection ##### delete ALL old status msg, and place the current status in the queue ######### for m in con.msg_q: if(msg["cmd"] == m["cmd"]): con.msg_q.remove(m) # avoid message on alarm if alarm_while_streaming=0 at various conditions send_msg=1 if(_state>0 and _detection>0 and cam.alarm_while_streaming==0): if(cam.webview_active==1): # no alarm while streaming send_msg=0 elif(time.time()-cam.last_picture_taken_ts<5): # dead - time after streaming, 5 sec send_msg=0 if(send_msg): # if we have a new status, check the complete queue if we have old unsend stati and remove them first, they aren't valid anymore for msg_i in con.msg_q: if(msg_i["cmd"]==msg["cmd"]): con.msg_q.remove(msg_i) con.msg_q.append(msg) ##### delete ALL old status msg, and place the current status in the queue ######### ##### light dimming ######### # if we change the state of the sensor, we should most likely change the light # clear all old dimming actions if (0): #illumino disabled :( light.clear_q() # set new color if(_detection == 0 and _state == 1): # deactive and motion if(cam.webview_active == 0): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time(), light.runner.l.d_r, light.runner.l.d_g, light.runner.l.d_b, 4000) # 4 sec to dimm to default color - now else: (r,g,b) = light.runner.get_color() light.set_old_color(r,g,b,time.time()+light.get_delay_off()) # set the color to which we return as soon as the webfeed is closed elif(_detection == 0 and _state == 0): # deactive and no motion if(cam.webview_active == 0): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time()+light.get_delay_off(), 0, 0, 0, 4000) # 4 sec to dimm to off - in 10 min from now else: (r,g,b) = light.runner.get_color() light.set_old_color(r,g,b,time.time()+light.get_delay_off()) # set the color to which we return as soon as the webfeed is closed #rint("[A "+time.strftime("%H:%M:%S")+"] setting lights off to "+str((datetime.datetime.fromtimestamp(int((time.time()+light.get_delay_off())))).strftime('%y_%m_%d %H:%M:%S'))) elif(_detection == 1 and _state == 1): # alarm, go red, now if(cam.webview_active == 0): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time(), 100, 0, 0, 4000) else: light.set_old_color(100, 0, 0,time.time()+light.get_delay_off())# set the color to which we return as soon as the webfeed is closed elif(_detection == 1 and _state == 0): # off while nobody is there if(cam.webview_active == 0): # only change color if the webcam is no running to avoid that we switch the light during movement, while the videofeed is running light.add_q_entry(time.time(), 0, 0, 0, 4000) else: (r,g,b) = light.runner.get_color() light.set_old_color(r,g,b,time.time()+light.get_delay_off()) # set the color to which we return as soon as the webfeed is closed ##### light dimming ######### ##### camera picture upload ######### if(_state > 0 and _detection > 0): # alarm state if(cam.alarm_in_alarm_state == 0): cam.alarm_in_alarm_state = 1 cam.alarm_pictures_remaining = 5 else: # state==0 or detection==0, leave the picture remaining so we can finish uploading all 5 pictures per alarm cam.alarm_in_alarm_state = 0 ##### camera picture upload ######### ##### set the gpio pins ##### g_state = 0 if(_state > 0): g_state = 1 gpio.set(gpio.PIN_MOVEMENT,g_state) g_detection = 0 if(_detection > 0): g_detection = 1 gpio.set(gpio.PIN_DETECTION,g_detection)
def handle (client, addr): lock = threading.Lock() busy=1 while 1: try: rList, wList, xList = select([client.conn], [client.conn], [client.conn], 3) except Exception as n: p.warn("S_m2m Select() return an exception for connection "+str(addr)+":"+str(n)) disconnect(client) break if(busy==0): time.sleep(0.03) busy=0 ######################## SEND ########################### if(len(wList)>0): try: if(len(client.sendq)>0): busy=1 payload=client.sendq[0] client.sendq.remove(payload) msg= bytearray() # add payload for d in bytearray(payload): msg.append(d) client.conn.send(msg) p.rint("m2m send "+str(len(msg))+" bytes","w") except Exception as n: print("exception!!!") print(n) disconnect(client) ######################## SEND ########################### ####################### RECEIVE ########################## if(len(rList)>0): busy=1 lt="" try: #print(addr,end="") #print("server_m2m: rList has "+str(len(rList))+" Elements") lt="start _handleData()" res = recv_data(client, MAX_MSG_SIZE) if(res<0): disconnect(client) except Exception as n: print("exception!!!") print(n) print("") print("except, our status ",end="") print(lt,end="") print(" sys:",end="") print(sys.exc_info()[0]) print("") disconnect(client) ####################### RECEIVE ########################## ######################## ERROR ########################## if(len(xList)>0): busy=1 try: print("exception!!!") if client.conn: client.conn.close() try: for callb in callback_con: callb("disconnect",client) except: break; pass try: clients.remove(client) except: break; pass except: pass break; ######################## ERROR ########################## ######################## MAINTAINANCE ########################## if(time.time()-client.debug_ts>1): client.debug_ts=time.time() ######################## MAINTAINANCE ########################## p.rint("[S_m2m "+time.strftime("%H:%M:%S")+"] -> Client closed:"+str(addr),"l")
def run(self,config): self.config = config while(1): p.rint("LIGHT, thread started","l") self.alive = True # Create NeoPixel object with appropriate configuration. if(str(self.config.with_lights) == "1"): p.rint("LIGHT, configured with NEO usage","l") if(self.neo_support and self.neo_loaded!=1): p.rint("LIGHT, neopixel supported, starting","l") strip = Adafruit_NeoPixel(self.neo_LED_COUNT, self.neo_LED_PIN, self.neo_LED_FREQ_HZ, self.neo_LED_DMA, self.neo_LED_INVERT, self.neo_LED_BRIGHTNESS) # Intialize the library (must be called once before other functions). strip.begin() strip.show() self.neo_loaded = 1 # avoid loading it twice elif(self.neo_support): p.rint("LIGHT, neopixel already loaded","l") else: p.rint("LIGHT, ERROR neopixel not supported","l") elif(str(self.config.with_lights) == "2"): p.rint("LIGHT, configured with PWM usage","l") if(self.pwm_support): p.rint("LIGHT, PWM supported, starting","l") wiringpi.wiringPiSetupPhys() wiringpi.pinMode(12,2) else: p.rint("LIGHT, ERROR PWM not supported","l") elif(str(self.config.with_lights) == "3"): p.rint("LIGHT, configured with i2c usage","l") if(self.i2c_support and self.i2c_loaded!=1): p.rint("LIGHT, i2c supported, starting","l") salsa = arduino_bridge.connection() salsa.setup_pwm_output(0) salsa.setup_pwm_output(1) salsa.setup_pwm_output(2) salsa.setup_pwm_output(3) self.i2c_loaded = 1 elif(self.i2c_loaded == 1): p.rint("LIGHT, i2c already loaded","l") else: p.rint("LIGHT, ERROR i2c not supported","l") else: p.rint("LIGHT, started without pwm and neo and i2c","l") p.rint("LIGHT, selection was "+str(self.config.with_lights),"l") while self.alive: ### ------------ check if we have something to do ------------ ### if(len(self.light_dimming_q) > 0): for data in self.light_dimming_q: if(data[0]<=time.time()): light_action=data self.light_dimming_q.remove(data) if(light_action[1]==-1 and light_action[2]==-1 and light_action[3]==-1): self.return_to_old(light_action[4]) else: self.dimm_to(light_action[1],light_action[2],light_action[3],light_action[4]) ### ------------ check if we have something to do ------------ ### if(self.l.state==1): # state= 1 means dimming is active if(time.time()>=self.l.last_ts+self.l.ms_step/1000): # last_ts holds time of last event, ms_step the time between two dimm steps, # if that sum is smaller than NOW - we have work self.l.last_ts=time.time() # refresh last_ts to now differ_r=self.l.s_r-self.l.t_r # caluclate the difference of each color between the start and the end color differ_g=self.l.s_g-self.l.t_g differ_b=self.l.s_b-self.l.t_b differ_time=(self.l.t_t-self.l.s_t) # calulate the total time between the start and end #(this should be the same as the "dimm time" specified by the user) if(differ_time>0): # if the user set instant switch, this time will be 0. avoid division by zero ratio=(time.time()-self.l.s_t)/(self.l.t_t-self.l.s_t) # ratio of the time that has passed, should be 0..1 else: ratio=1 if(ratio<1): # if ratio is below 1 we are still in the middle of the dimming if(LED_DEBUG): print(".", end="") self.l.c_r=int(self.l.s_r-ratio*differ_r) # refresh the r,g,b parts to the current dimm ratio (minus since we did a "self.l.s_r - self.l.t_r") self.l.c_g=int(self.l.s_g-ratio*differ_g) self.l.c_b=int(self.l.s_b-ratio*differ_b) else: # ratio is bigger than one, time has passed, set it to target color self.l.c_r=int(self.l.t_r) self.l.c_g=int(self.l.t_g) self.l.c_b=int(self.l.t_b) self.l.state=0 # stop further dimming if(LED_DEBUG): print("LED stop at "+str(time.time())+" "+str(self.l.c_r)+"/"+str(self.l.c_g)+"/"+str(self.l.c_b)) self.l.c_r=max(min(255,self.l.c_r),0) # avoid that we set a value bigger then 255 or smaller then 0 self.l.c_g=max(min(255,self.l.c_g),0) self.l.c_b=max(min(255,self.l.c_b),0) # neo pixel if(str(self.config.with_lights) == "1" and self.neo_support): for i in range(0,self.neo_LED_COUNT): strip.setPixelColor(i,Color(self.l.c_r,self.l.c_g,self.l.c_b)) # set value strip.show() # neo pixel # pwm controll on pin 12 elif(str(self.config.with_lights) == "2" and self.pwm_support): wiringpi.pwmWrite(12, self.l.c_r*4) # pwm controll on pin 12 # i2c controll elif(str(self.config.with_lights) == "3" and self.i2c_support): try: print(str(self.l.c_b)) salsa.dimmTo(0,int(self.l.c_r/2.55),10) # dimming is in % #R salsa.dimmTo(1,int(self.l.c_g/2.55),10) # dimming is in % #G salsa.dimmTo(2,int(self.l.c_b/2.55),10) # dimming is in % #B salsa.dimmTo(3,int(self.l.c_b/2.55),10) # dimming is in % #B except: print("LIGHT i2c bus transaction crashed") # i2c controll # we can wait here a little while because we know that nothing will happen for us earlier than that anyway time.sleep(0.8*self.l.ms_step/1000) else: time.sleep(0.01) # sleep to avoid 100% cpu # while p.rint("LIGHT, thread stopped","l")
msg["td"] = ((time.time(), "send"), (time.time(), "send")) for cli in server_ws.clients: msg_q_ws.append((msg,cli)) #if(STEP_DEBUG): # rint("[A "+time.strftime("%H:%M:%S")+"] Step 6 upload appended message") i = i+1 p.set_last_action("loading img done") #rint(str(time.time())+' all messages for '+path+' are in buffer.. i guess') img.close() return 0 # end of while #start pin config p.rint("STARTUP, settings pins","l") gpio = u_gpio() gpio.setup() arduino = arduino_bridge.connection() arduino.setup_digital_output(13) #left arduino.setup_digital_output(14) #right arduino.setup_pwm_output(0) # right pwm arduino.setup_pwm_output(9) # left pwm recv_ws_msg_q=[] # incoming recv_ws_con_q=[] # incoming msg_q_ws=[] # outgoing server_ws.subscribe_callback(recv_ws_msg_q_handle,"msg") server_ws.subscribe_callback(recv_ws_con_q_handle,"con")
def handle (client,addr): t1=0 t2=0 busy=1 client.last_comm=time.time() #lock = threading.Lock() while client.alive: try: rList, wList, xList = select([client.ws.sock], [client.ws.sock], [client.ws.sock], 3) except: break; if(busy==0): time.sleep(0.03) busy=0 ######################## SEND ########################### if(len(wList)>0): try: t1=time.time() while client.ws.sendq: busy=1 opcode, payload = client.ws.sendq.popleft() remaining = client.ws._sendBuffer(payload) if remaining is not None: client.ws.sendq.appendleft((opcode, remaining)) break else: if opcode == CLOSE: for callb in callback_con: callb("disconnect",client) t1=time.time()-t1 except Exception as n: disconnect(client) ######################## SEND ########################### ####################### RECEIVE ########################## if(len(rList)>0): busy=1 lt="" try: lt="start _handleData()" t2=time.time() if(client.ws._handleData()==-1): disconnect(client) while(client.ws.data_ready==True): lt="Start getMessage()" msg=client.ws.getMessage() # getMessage will unset the data_ready flag if no data left if(client.ws.data_ready==True): #print(msg) # <-- prints the received data lt="Start callb" for callb in callback_msg: callb(msg,client) #client.ws.data_ready=False #client.ws.last_data="" t2=time.time()-t2 except (SSL.ZeroReturnError, SSL.SysCallError): # regular good SSL disconnect disconnect(client) except ValueError as err: # disconnct while handshake disconnect(client) except Exception as n: print("except while read in server_ws, our status ",end="") print(lt) print("sys:",end="") print(sys.exc_info()[0]) print(sys.exc_info()[1]) print(repr(traceback.format_tb(sys.exc_info()[2]))) print("") disconnect(client) ####################### RECEIVE ########################## ######################## ERROR ########################## if(len(xList)>0): busy=1 disconnect(client) ######################## ERROR ########################## ######################## MAINTAINANCE ########################## if(time.time()-client.debug_ts>1): #if(time.time()-client.debug_ts>10): # print("woohoo its me") # print(t1) # print(t2) client.debug_ts=time.time() ######################## MAINTAINANCE ########################## # end of while 1 p.rint("[S_wss "+time.strftime("%H:%M:%S")+"] -> Client "+str(client.login)+" closed: "+str(client.ip),"l")
"w") file.write(f_content) file.close() return (m2m_mid, m2m_pw) ###################### try import login ####################### register_mode = 0 if (os.path.isfile( os.path.join(os.path.dirname(os.path.realpath(__file__)), "login.py"))): from login import * l = login() # login m2m_pw = l.pw p.rint("STARTUP, login.py found, password loaded", "l") try: p.rint("STARTUP, login.py found, mid loaded", "l") m2m_mid = l.mid except: p.rint("STARTUP, login.py without mid loaded, create new one", "l") (m2m_mid, m2m_pw) = create_login("", m2m_pw) else: register_mode = 1 # first time connection, create a password and send it to the server (m2m_mid, m2m_pw) = create_login("", "") p.rint("STARTUP, no login.py found, running in register mode", "l") ###################### try import login #######################
def print_rules(self, bars=1, account_info=1, print_out=1, formating=1, header=1, dict=0): if (dict): ret_dict = {} ret_dict["name"] = self.area ret_dict["rules"] = [] ret_dict["subrules"] = [] header = 0 print_out = 0 account_info = 0 bars = 0 formating = 0 else: ret = "" if (bars): ret += "|||+ " if (account_info): ret += "This is area '" + self.area + "' on account '" + self.account + "'. I have " ret += str(len(self.rules)) + " active rules and " + str( len(self.sub_rules)) + " subrules\r\n" i = 1 if (bars): ret += "(r)|||+ " if (header): ret += "Rules: <br>(protection activ if at least one is true)\r\n" for r in self.rules: ## marker g = 0 if (bars): ret += "(r)||||- " if (self.eval_rule(r.conn, r.arg1, r.arg2, 10, 1, r.id) >= 1): if (formating): ret += "<g>" g = 1 else: if (formating): ret += "<r>" ## marker txt = self.explain_rule(r, g, i) if (dict): ret_dict["rules"].append((r.id, r.conn, r.arg1, r.arg2, g)) else: ret += txt ## marker if (g): if (formating): ret += "</g>\r\n" else: if (formating): ret += "</r>\r\n" ## marker i += 1 if (len(self.rules) == 0): if (bars): ret += "(r)||||- " if (formating): ret += "<g>none</g>\r\n" i = 1 if (bars): ret += "(r)|||\r\n" ret += "(r)|||+ " if (header): ret += "Sub-Rules:\r\n" for r in self.sub_rules: ## marker g = 0 if (bars): ret += "(r)||||- " if (self.eval_rule(r.conn, r.arg1, r.arg2, 10, 1, r.id) >= 1): if (formating): ret += "<g>" g = 1 else: if (formating): ret += "<r>" ## marker txt = self.explain_rule(r, g, i) if (dict): ret_dict["subrules"].append((r.id, txt, g)) else: ret += txt ## marker if (g): if (formating): ret += "</g>" else: if (formating): ret += "</r>" ## marker i += 1 if (dict != 1): if ((i - 1) < len(self.sub_rules)): ret += "\r\n" if (len(self.sub_rules) == 0): if (bars): ret += "(r)||||- " if (formating): ret += "<g>none</g>" if (print_out): p.rint(ret, "r") return 0 if (dict): return ret_dict return ret
def connect(con): global register_mode, m2m_mid p.rint("--> connecting to illuminum server ...","l") p.set_last_action("connecting") context = OpenSSL.SSL.Context(OpenSSL.SSL.TLSv1_METHOD) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) c_socket = OpenSSL.SSL.Connection(context, s) try: c_socket.connect((con.server_ip, con.server_port)) except: p.rint("Could not connect to server","l") p.rint("retrying in 3 sec","l") time.sleep(3) return -1 p.rint("<-- connected to server. ","l") if(register_mode==0): p.rint("--> Starting log-in process","l") else: p.rint("--> Begin register process...","l") p.set_last_action("connecting done") #### prelogin msg = {} msg["mid"] = m2m_mid msg["cmd"] = "prelogin" con.msg_q.append(msg) #int("sending prelogin request") return c_socket
import time import p import subprocess rpi_support = 0 fsys_support = 0 cpu = str(subprocess.Popen(["cat", "/proc/cpuinfo"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE).communicate()[0].decode()) cpu = "".join(cpu) # check platform to see what we can expect if(cpu.find("Allwinner")>-1): # import fsys for CHIP if posible p.rint("Allwinner CPU found, running fsys mode","g") fsys_support = 1 elif(cpu.find("BCM27")>-1): # import rpi gpio if posible p.rint("Raspberry CPU found, try to import GPIO lib","g") try: import RPi.GPIO as GPIO p.rint("GPIO lib found and loaded","g") rpi_support = 1 except: rpi_support = 0 class u_gpio: def __init__(self): self.PIN_PIR = 1 self.PIN_MOVEMENT = 2
def run(self,config): self.config = config while(1): p.rint("LIGHT, thread started","l") self.alive = True self.config.with_neo=0 self.config.with_pwm=0 self.config.with_i2c=1 # Create NeoPixel object with appropriate configuration. if(self.config.with_neo): p.rint("LIGHT, configured with NEO usage","l") if(self.neo_support and self.neo_loaded!=1): p.rint("LIGHT, neopixel supported, starting","l") strip = Adafruit_NeoPixel(self.neo_LED_COUNT, self.neo_LED_PIN, self.neo_LED_FREQ_HZ, self.neo_LED_DMA, self.neo_LED_INVERT, self.neo_LED_BRIGHTNESS) # Intialize the library (must be called once before other functions). strip.begin() strip.show() self.neo_loaded = 1 # avoid loading it twice elif(self.neo_support): p.rint("LIGHT, neopixel already loaded","l") else: p.rint("LIGHT, ERROR neopixel not supported","l") elif(self.config.with_pwm): p.rint("LIGHT, configured with PWM usage","l") if(self.pwm_support): p.rint("LIGHT, PWM supported, starting","l") wiringpi.wiringPiSetupPhys() wiringpi.pinMode(12,2) else: p.rint("LIGHT, ERROR PWM not supported","l") elif(self.config.with_i2c and self.i2c_loaded!=1): p.rint("LIGHT, configured with i2c usage","l") if(self.i2c_support): p.rint("LIGHT, i2c supported, starting","l") bus = i2c.I2CMaster(1) self.i2c_loaded = 1 else: p.rint("LIGHT, ERROR i2c not supported","l") else: p.rint("LIGHT, started without pwm and neo","l") while self.alive: ### ------------ check if we have something to do ------------ ### if(len(self.light_dimming_q) > 0): for data in self.light_dimming_q: if(data[0]<=time.time()): light_action=data self.light_dimming_q.remove(data) if(light_action[1]==-1 and light_action[2]==-1 and light_action[3]==-1): self.return_to_old(light_action[4]) else: self.dimm_to(light_action[1],light_action[2],light_action[3],light_action[4]) ### ------------ check if we have something to do ------------ ### if(self.l.state==1): # state= 1 means dimming is active if(time.time()>=self.l.last_ts+self.l.ms_step/1000): # last_ts holds time of last event, ms_step the time between two dimm steps, # if that sum is smaller than NOW - we have work self.l.last_ts=time.time() # refresh last_ts to now differ_r=self.l.s_r-self.l.t_r # caluclate the difference of each color between the start and the end color differ_g=self.l.s_g-self.l.t_g differ_b=self.l.s_b-self.l.t_b differ_time=(self.l.t_t-self.l.s_t) # calulate the total time between the start and end #(this should be the same as the "dimm time" specified by the user) if(differ_time>0): # if the user set instant switch, this time will be 0. avoid division by zero ratio=(time.time()-self.l.s_t)/(self.l.t_t-self.l.s_t) # ratio of the time that has passed, should be 0..1 else: ratio=1 if(ratio<1): # if ratio is below 1 we are still in the middle of the dimming if(LED_DEBUG): print(".", end="") self.l.c_r=int(self.l.s_r-ratio*differ_r) # refresh the r,g,b parts to the current dimm ratio (minus since we did a "self.l.s_r - self.l.t_r") self.l.c_g=int(self.l.s_g-ratio*differ_g) self.l.c_b=int(self.l.s_b-ratio*differ_b) else: # ratio is bigger than one, time has passed, set it to target color self.l.c_r=int(self.l.t_r) self.l.c_g=int(self.l.t_g) self.l.c_b=int(self.l.t_b) self.l.state=0 # stop further dimming if(LED_DEBUG): print("LED stop at "+str(time.time())+" "+str(self.l.c_r)+"/"+str(self.l.c_g)+"/"+str(self.l.c_b)) self.l.c_r=max(min(255,self.l.c_r),0) # avoid that we set a value bigger then 255 or smaller then 0 self.l.c_g=max(min(255,self.l.c_g),0) self.l.c_b=max(min(255,self.l.c_b),0) # neo pixel if(self.config.with_neo and self.neo_support): for i in range(0,self.neo_LED_COUNT): strip.setPixelColor(i,Color(self.l.c_r,self.l.c_g,self.l.c_b)) # set value strip.show() # neo pixel # pwm controll on pin 12 elif(self.config.with_pwm and self.pwm_support): wiringpi.pwmWrite(12, self.l.c_r*4) # pwm controll on pin 12 # i2c controll elif(self.config.with_i2c and self.i2c_support): if(1):#try: address = 4 pin_r = 9 pin_g = 6 pin_b = 5 bus.transaction(i2c.writing_bytes(address, 0xCE, pin_r,0x02, self.l.c_r, self.l.c_g, self.l.c_b)) #bus.transaction(i2c.writing_bytes(address, 0xCE, pin_g,0x01, self.l.c_g)) #bus.transaction(i2c.writing_bytes(address, 0xCE, pin_b,0x01, self.l.c_b)) else:#xcept: print("LIGHT i2c bus transaction crashed") # i2c controll # we can wait here a little while because we know that nothing will happen for us earlier than that anyway time.sleep(0.8*self.l.ms_step/1000) else: time.sleep(0.01) # sleep to avoid 100% cpu # while p.rint("LIGHT, thread stopped","l")
def movements_stopped(): p.rint("MOVEMENT, no motion, starting timer","l") return threading.Timer(1,dummy)