def test_server_different_port(): # server, will be tested: server_3000 = OSCThreadServer(encoding='utf8') sock_3000 = server_3000.listen(address='0.0.0.0', port=3000, default=True) server_3000.bind(b'/callback_3000', callback_3000) # clients sending to different ports, used to test the server: client_3000 = OSCClient(address='localhost', port=3000, encoding='utf8') # server sends message to himself, should work: server_3000.send_message(b'/callback_3000', ["a"], ip_address='localhost', port=3000) sleep(0.05) # client sends message to server, will be received properly: client_3000.send_message(b'/callback_3000', ["b"]) sleep(0.05) # sever sends message on different port, might crash the server on windows: server_3000.send_message(b'/callback_3000', ["nobody is going to receive this"], ip_address='localhost', port=3001) sleep(0.05) # client sends message to server again. if server is dead, message will not be received: client_3000.send_message(b'/callback_3000', ["c"]) sleep(0.1) # give time to finish transmissions # if 'c' is missing in the received checklist, the server thread crashed and could not recieve the last message from the client: assert checklist == ['a', 'b', 'c'] server_3000.stop() # clean up
def receive_values_from_max(ip, port): while (1): osc = OSCThreadServer() sock = osc.listen(address=ip, port=port, default=True) #osc.bind(b'/crowd-accel',acceleration_data) osc.bind(b'/crowd-pos', positional_data) sleep(1) osc.stop() return True
def receive_values_from_max(ip, port): while (1): osc = OSCThreadServer() sock = osc.listen(address=ip, port=port, default=True) osc.bind(b'/density', printer) osc.bind(b'/cluster', printer) osc.bind(b"/mob_speed", printer) sleep(1000) osc.stop() return True
def test_getaddress(): osc = OSCThreadServer() sock = osc.listen() assert osc.getaddress(sock)[0] == '127.0.0.1' with pytest.raises(RuntimeError): osc.getaddress() sock2 = osc.listen(default=True) assert osc.getaddress(sock2)[0] == '127.0.0.1' osc.stop(sock)
def test_stop_default(): osc = OSCThreadServer() osc.listen(default=True) assert len(osc.sockets) == 1 osc.stop() assert len(osc.sockets) == 0
def test_stop_unknown(): osc = OSCThreadServer() with pytest.raises(RuntimeError): osc.stop(socket.socket())
def test_listen(): osc = OSCThreadServer() sock = osc.listen() osc.stop(sock)
class OBSRemote: def __init__(self, osc_port, osc_client_host, osc_client_port, host, port, password=''): self.client = obsws(host, port, password) self.register_callbacks() self.osc = OSCThreadServer( encoding='utf8', advanced_matching=True, ) self.socket = None self.osc_client_host = osc_client_host self.osc_client_port = osc_client_port self.osc_port = osc_port self.volume_changed = False self.levels = [0, 0] self.scenes = [] def start(self): self.client.connect() self.socket = self.osc.listen(address='0.0.0.0', port=self.osc_port, default=True) self.update_audio_sources() self.update_audio_levels() self.update_scenes() self.update_mute_status() self.register_osc_addresses() self.client.call(requests.SetHeartbeat(True)) def stop(self): self.client.disconnect() self.osc.stop() self.socket = None def register_callbacks(self): self.client.register(self.scene_changed, event=events.SwitchScenes) self.client.register(self.mute_changed, event=events.SourceMuteStateChanged) self.client.register(self.update_scenes, event=events.ScenesChanged) self.client.register(self.update_scenes, event=events.SceneCollectionChanged) self.client.register(self.update_audio_sources, event=events.SourceRenamed) self.client.register(self.update_audio_levels, event=events.SourceVolumeChanged) self.client.register(self.status_update, event=events.Heartbeat) def register_osc_addresses(self): @self.osc.address('/scene/?/?', get_address=True) def scene_cb(address, values): if values < 1.0: return scene_id = int(address.split(b'/')[-1]) - 1 if scene_id < len(self.scenes): self.osc.answer(address, [1.0]) self.client.call( requests.SetCurrentScene(self.scenes[scene_id])) @self.osc.address('/mic') def mic_cb(values): self.osc.answer('/mic', [values]) self.client.call( requests.SetMute(self.audio_sources['mic'], values < 1.0)) @self.osc.address('/audio') def audio_cb(values): self.osc.answer('/audio', [values]) self.client.call( requests.SetMute(self.audio_sources['desktop'], values < 1.0)) @self.osc.address('/cam') def cam_cb(values): self.osc.answer('/cam', [values]) self.client.call( requests.SetSceneItemProperties('Webcam', visible=values > 0.0)) self.client.call( requests.SetSceneItemProperties('Overlay: Webcam', visible=values > 0.0)) @self.osc.address('/audio_level/?', get_address=True) def audio_level_cb(address, values): slider_id = int(address.split(b'/')[-1]) - 1 self.levels[slider_id] = values self.volume_changed = True @self.osc.address('/rec') def rec_cb(values): if values > 0.0: self.client.call(requests.StartRecording()) else: self.client.call(requests.StopRecording()) self.osc.answer('/rec', [values]) @self.osc.address('/stream') def stream_cb(values): if values > 0.0: self.client.call(requests.StartStreaming()) else: self.client.call(requests.StopStreaming()) self.osc.answer('/stream', [values]) def mute_changed(self, event): name = event.getSourceName() muted = event.getMuted() if name == self.audio_sources['mic']: self._send_osc('/mic', 1.0 if muted is False else 0.0) if name == self.audio_sources['desktop']: self._send_osc('/audio', 1.0 if muted is False else 0.0) def scene_changed(self, event): name = event.getSceneName() for idx, scene_name in enumerate(self.scenes): if name == scene_name: self._send_osc('/scene/1/{}'.format(idx + 1), 1.0) self.update_mute_status(sources=event.getSources()) def status_update(self, event: events.Heartbeat): streaming = event.getStreaming() recording = event.getRecording() try: stream_time = timedelta(seconds=event.getTotalStreamTime()) except KeyError: stream_time = 0 try: rec_time = timedelta(seconds=event.getTotalRecordTime()) except KeyError: rec_time = 0 self._send_osc('/stream', 1.0 if streaming else 0.0) self._send_osc('/rec', 1.0 if recording else 0.0) self._send_osc('/stream_time', str(stream_time)) self._send_osc('/rec_time', str(rec_time)) def update_mute_status(self, sources=None): if sources is None: sources = self.client.call(requests.GetCurrentScene()).getSources() webcam_found = False for source in sources: if source['name'] in ['Webcam', 'Overlay: Webcam']: webcam_found = True self._send_osc('/cam', 1.0 if source['render'] else 0.0) if not webcam_found: self._send_osc('/cam', 0.0) def update_scenes(self, *args): if len(args) > 0: self.scenes = [ s['name'] for s in args[0].getScenes() if not s['name'].lower().startswith('overlay:') ] else: self.scenes = [ s['name'] for s in self.client.call(requests.GetSceneList()).getScenes() if not s['name'].lower().startswith('overlay:') ] for idx in range(0, 8): try: name = self.scenes[idx] except IndexError: name = '' self._send_osc('/scene_label_{}'.format(idx), name) self.update_mute_status() def update_audio_sources(self, *args): sources = self.client.call(requests.GetSpecialSources()) self.audio_sources = { "mic": sources.getMic1(), "desktop": sources.getDesktop1() } def update_audio_levels(self, *args): if len(args) > 0: event = args[0] name = event.getSourceName() volume = None if isinstance(event, events.SourceVolumeChanged): volume = event.getVolume() muted = None if isinstance(event, events.SourceMuteStateChanged): muted = event.getMuted() if name == self.audio_sources['mic']: if volume is not None: self._send_osc('/audio_level/1', volume) self.levels[0] = volume if muted is not None: self._send_osc('/mic', 1.0 if not muted else 0.0) elif name == self.audio_sources['desktop']: if volume is not None: self._send_osc('/audio_level/2', volume) if muted is not None: self._send_osc('/audio', 1.0 if not muted else 0.0) else: desktop = self.client.call( requests.GetVolume(self.audio_sources['desktop'])) mic = self.client.call( requests.GetVolume(self.audio_sources['mic'])) self._send_osc('/audio_level/2', desktop.getVolume()) self.levels[1] = desktop.getVolume() self._send_osc('/audio', 1.0 if not desktop.getMuted() else 0.0) self._send_osc('/audio_level/1', mic.getVolume()) self.levels[0] = mic.getVolume() self._send_osc('/mic', 1.0 if not mic.getMuted() else 0.0) def _send_osc(self, address, value): self.osc.send_message(address, [value], self.osc_client_host, self.osc_client_port) def tick(self): if self.volume_changed: self.volume_changed = False self.client.call( requests.SetVolume( list(self.audio_sources.values())[0], self.levels[0])) self.client.call( requests.SetVolume( list(self.audio_sources.values())[1], self.levels[1]))
def main(): global pauser pauser = False warnings.filterwarnings("ignore") logging.disable(logging.CRITICAL) tf_session = tf.Session() K.set_session(tf_session) #Connection Initialization print("Creating Connections") #Connecting to max #Max client: Receive from Max try: max_client = udp_client.SimpleUDPClient(opt.maxip, opt.maxport) print("UDP Client connection to Max established") except: print( "UDP Client connection to Max failed. Will not be able to send from Max." ) print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) #Max server: Listen to Max try: osc = OSCThreadServer() try: max_server = osc.listen(address=opt.chatip, port=opt.chatport, default=True) print("OSC Server initialized to listen to Max") osc.bind(b"/chat", chat_callback) osc.bind(b"/command", command_callback) osc.bind(b"/kill", kill_switch) ##########sddrd to test Vishal######################### osc.bind(b"/stop", stop_resume_operation) except: print("Tag is not in exceptable format") ##########sddrd to test Vishal######################### except: print( "OSC Server initialization failed. Will not be able to listen to Max" ) print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ################# Connecting to Camera 1 ##################### try: cam1_socket = socket.socket() cam1_socket.connect((opt.camip1, opt.camport1)) print("Connection to Camera 1 established") except: print("Unable to connect to Camera 1") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ############### Connecting to Camera 2 ####################### try: cam2_socket = socket.socket() cam2_socket.connect((opt.camip2, opt.camport2)) print("Connection to Camera 2 established") except: print("Unable to connect to Camera 2") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ########### Chatbot Generator ##################### try: chatbot = Chatbot(tf_session) univEncoder = UnivEncoder(tf_session, chatbot.intents) print("Initialized chatbot dialogue system") except: print("Unable to initialize chatbot dialogue system. Exiting.") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) exit() #################### Code for Haiku Poem Generation ####################### # try: # haiku_bot = Haiku_Bot(tf_session) # output_dir = Path('models/poem_generator/trained_models') # Get the parameters used for creating the model # latent_dim, n_tokens, max_line_length, tokenizer = joblib.load(output_dir / 'metadata.pkl') # # Create the new placeholder model # training_model, lstm, lines, inputs, outputs = create_training_model(latent_dim, n_tokens) # # Load the specified weights # training_model.load_weights(output_dir / 'poem_generator_weights.hdf5') # haiku_bot = Generator(lstm, lines, tf_session, tokenizer, n_tokens, max_line_length) # print("Initialized chatbot poem generator.") # except: # print("Unable to initialize chatbot poem generator.") # print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], # sys.exc_info()[1], # sys.exc_info()[2].tb_lineno)) #Waiting for max command to start chatbot command = "stopped" # while command != "chat": # while max_response.empty(): # stopped = True # max_request = max_response.get() # command = max_request['command'] print(time.time()) print("Starting chatbot for the first time") while command != "kill": users = False faces_count = 0 chat_start = True returning_user = False ask_user_name = True while command != "pause" and command != "new" and command != "kill": try: if ask_user_name: ask_user_name = False try: os.mkdir("users") except: users = True ## Creating a txt file and storing all the sentence ## global file ## kk code to open and close history file start ## file = open("history.txt", "w+") file.close() ## kk code to open and close history file end ## #TODO: There is no kill switch check or command check. Need to implement it. first_sentence = "Hello world!" max_client.send_message(chat_tag, first_sentence) history(first_sentence) # time.sleep(chat_speed_slow) while max_response.empty(): waiting_for_user = True user_response = max_response.get() history(user_response['intent']) ## kk code start## chat = "Hello! My name is Odo. I see {0} players. What are your names?".format( players) max_client.send_message(chat_tag, chat) while max_response.empty(): waiting_for_user = True history(chat) try: while max_response.empty(): waiting_for_user = True for __ in range(players): user_response = max_response.get() print(user_response) #TODO: We might need to validate the names players_names.append(user_response['intent']) history(user_response['intent']) except excep as e: print(e) ######### Making directory for each user, commented for now start- kkk ########## # dir_name = ''.join(e for e in user_name if e.isalnum()) # dir_name = dir_name.capitalize() # try: # os.mkdir("users/"+dir_name) # except: # returning_user = True ######### Making directory for each user, commented for now end- kkk ########## ## Greeting all the users ## for name in players_names: print("inside for loop") chat = "Hi " + name + ", nice to meet you" max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) while max_response.empty(): waiting_for_user = True chat = "Where do you come from?" max_client.send_message(chat_tag, chat) history(chat) while max_response.empty(): waiting_for_user = True user_response = max_response.get() #TODO: We might need to validate the cities user_location = user_response['intent'] history(user_location) #Monologue # chat = "Nice to meet you. I am from very far away. I live here. Here on stage. I can’t leave the stage. This is my body. Do you see me?" # max_client.send_message(chat_tag, chat) # time.sleep(chat_speed) ######### Get user emotion, commenting for now start - kkk ############## try: camera_message = "send_emotion" cam1_socket.send(camera_message.encode('utf-8')) emotion1 = cam1_socket.recv(1024).decode('utf-8') emotion1 = json.loads(emotion1) user_emotion1 = emotion1['emotion'] total_faces1 = emotion1['total_faces'] time1 = emotion1['time'] cam2_socket.send(camera_message.encode('utf-8')) emotion2 = cam2_socket.recv(1024).decode('utf-8') emotion2 = json.loads(emotion2) user_emotion2 = emotion2['emotion'] total_faces2 = emotion2['total_faces'] time2 = emotion2['time'] except: print('Error: {}. {}, line: {}'.format( sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) # chat = 'It seems you are ' + user_emotion1 # max_client.send_message(chat_tag, chat) # time.sleep(chat_speed) ######### Get user emotion, commenting for now end - kkk ############## # chat = 'Nice to meet you ' + user_name # max_client.send_message(chat_tag, chat) # history(chat) # time.sleep(chat_speed) chat = 'I am from very far away.' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'I live here.' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'Here on the stage' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'I cannot leave the stage. This is my body.' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) chat = 'Do you see me?' max_client.send_message(chat_tag, chat) history(chat) time.sleep(chat_speed) #TODO: Add kill switch check and command check try: while max_response.empty(): waiting_for_user = True user_response = max_response.get() history(user_response['intent']) user_chat = user_response['intent'] intent = univEncoder.match_intent(user_chat, chatbot.story_progress) if (intent == 'bye'): chat = 'It was nice talking to you.' max_client.send_message(chat_tag, chat) history(chat) command = 'kill' file.close() elif (intent == 'no_matching_intent'): # chat = 'I am sorry. I did not get you. Try saying something else.' chat = "Sorry I didnt get you, try saying something else" # chat = univEncoder.chat_eliza(user_chat) # print("Response from Eliza \n {0}".format(chat)) max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) # elif(intent == 'GIVE_POETRY'): # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### elif "transition" in intent: next_story = intent.split("_")[2] chatbot.change_story(next_story) univEncoder.set_intent(chatbot.intents) l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[ intent].weight chat = chatbot.intents[intent].responses[randrange( l)] max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # else: # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### else: l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[ intent].weight chat = chatbot.intents[intent].responses[randrange( l)] max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # else: # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### except: print('Error: {}. {}, line: {}'.format( sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) chat = 'I am sorry. I did not get you. Try saying something else.' max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### except KeyboardInterrupt: print("Closing all active connections") command = "kill" try: camera_message = "stop_camera" try: cam1_socket.send(camera_message.encode('utf-8')) cam1_socket.close() print("Connection to Camera 1 closed") except: print("unable to close camera 1") try: cam2_socket.send(camera_message.encode('utf-8')) cam2_socket.close() print("Connection to Camera 2 closed") except: print("unable to close camera 2") try: osc.stop() print("Connection to Max closed") except: print("unable to close connectoin to Max") except: print('unable to close connections')
class Midihost(threading.Thread): def __init__(self, command_q): super(Midihost, self).__init__() self.command_q = command_q self.stoprequest = threading.Event() self.osc = None def send_message(self, received_message): print received_message self.outputport.send(received_message) def stop(self): self.outputport.close() self.osc.stop() def connect_output(self): while True: try: self.outputport = mido.open_output() outputs = mido.get_output_names() if Config.MIDIOUT: out = [ s for s in outputs if Config.MIDIOUT.lower() in s.lower() ] if out: self.outputport = mido.open_output(out[0]) print "Midi output device connected: " + out[0] break else: raise EnvironmentError except EnvironmentError: self.outputport.close() print "MIDIOUT not found: " + Config.MIDIOUT print "Please connect midi device" time.sleep(3) def callback(self, path, values=None): print "osc: " + path + " : " + str(values) message = None command = path.split('/')[1] if command == "control_change": splitted = str(values).split('.') value = int(splitted[0]) message = mido.Message('control_change', channel=Config.MIDICHANNEL - 1, control=int(path.split('/')[2]), value=value) if command == "program_change": message = mido.Message('program_change', channel=Config.MIDICHANNEL - 1, program=int(values)) if command == "control_change_slider": message = mido.Message('control_change', channel=Config.MIDICHANNEL - 1, control=int(path.split('/')[2]), value=int(values)) if command == "quit": self.command_q.put("KILLSIGNAL") if command == "reboot": self.command_q.put("REBOOTSIGNAL") if command == "restart": self.stop() Config.restart(__file__) if command == "scroll_preset_up": self.callback("/control_change/71", "1.0") self.callback("/control_change/50", values) if command == "scroll_preset_down": self.callback("/control_change/71", "1.0") self.callback("/control_change/49", values) if message: self.send_message(message) def run(self): self.osc = OSCThreadServer(default_handler=self.callback) self.osc.listen(address='0.0.0.0', port=8000, default=True) self.connect_output() while not self.stoprequest.isSet(): try: message = self.command_q.get(True, 0.05) if str(message) == "KILLSIGNAL": Config.shutdown() elif str(message) == "REBOOTSIGNAL": Config.reboot() else: self.send_message(message) except Queue.Empty: continue self.osc.stop() def join(self, timeout=None): super(Midihost, self).join(timeout)
class riot_osc(): '''classe principale pour le controle du drone par le capteur''' #NOTTODO : fonction atterissage; #TODO : si tous les modes (surtout avec multiranger en même temps - si thread parallel -> probleme?) #todo : orientation fonctionne (lag visible (- une seconde ~250ms)), altitude: pbs pas trop deterministe # vitesses max évitement #bien modifiée en paramètres mais evolution dynamique bizarre, tests multi-ranger pas faits. #cnotrol manuel fonctionne avec clavier directionnel + u et d pour altitude (plutot reactif (comme orientaiton voir moins)) def __init__(self, multiranger, motion_commander, cf = None, to_alt = 0.5, graph = False): self.osc = OSCThreadServer() #les valeurs d'angle renvoyée par la centrale gyroscopique sur les 3 axes self.euler_x = 0 self.euler_y = 0 self.euler_z = 0 #les angles renvoyés lors du signal précedent self.ante_x = 0 self.ante_z = 0 self.ante_y = 0 #la valeur d'angle de la commande pour faire tourner le drone self.angle = 0 #compte le nombre de fois où la différence entre la valeur d'angle recu et la valeur précédente, #pour éviter de surcharger le drone de commande self.count = 0 #booléen renseignant sur l'état du drone : en vol ou non self.keep_flying = True #altitude du drone self.z = to_alt #vitesse d'évitement initiale du drone self.velocity = 0.5 #initialisation des valeurs d'angle sur x et z au commencement du programme self.orig_x = 0 self.orig_z = 0 #variables propres au drones self.cf = cf self.multiranger = multiranger self.motion_commander = motion_commander #variable indiquant si le programme doit commencer à compter (ou pas) le nombre #de valeur d'angle non nul self.flag = False self.sock = 0 #Initialisation du thread_multirange #ATTENTION A DES POSSIBLES PROBLEMES, LE DRONE EST SUREMENT UNE RESSOURCE CRITIQUE self.thread_multirange = Thread(target = self.multirange_push) self.thread_multirange.start() def set_orig(self, *args, axes = "all"): #fonction lancée au début du programme qui récupère les valeurs initiales du capteur pour définir une origine pour la suite if axes == "all" or axes == "x": self.orig_x = self._normalize__(args[18],0) if axes == "all" or axes == "z": self.orig_z = self._normalize__(args[20],0) self.osc.unbind(b'/0/raw',self.set_orig) self.osc.bind(b'/0/raw',self.callback) def _normalize__(self, value, orig): #fonction qui prend en paramètre une valeur renvoyé par le capteur et l'origine définit au lancement #qui normalise cette valeur entre 0 et 360 value = round(value) if value < 0: value = 360 + value value -= orig if value < 0 : value += 360 return value def callback(self, *args): #fonction principale de callback liée au capteur self.euler_z = self._normalize__(args[20], self.orig_z) try: self.euler_y = round(args[19]) except: self.euler_y = -90 #print(self.euler_x, self.euler_y, self.euler_z) if abs(self.euler_z) <= 10 and abs(self.euler_y) <= 10: #appel de la fonction de contrôle de l'orientation self.callback_x(*args) elif abs(self.euler_z - 90) <= 10 and abs(self.euler_y) <= 10: #appel de la fonction d'atterrissage self.landing() elif abs(self.euler_z - 270) <= 10 and abs(self.euler_y) <= 10: #appel de la fonction de contrôle de la vitesse d'évitement self.set_velocity(*args) elif abs(self.euler_z - 180) <= 15 and abs(self.euler_y) <= 12: #appel de la fonction de vol stationaire self.idle() elif abs(self.euler_y - 90) <= 10: #appel de la fonction de contrôle de l'altitude self.callback_z(*args) elif abs(self.euler_y + 90) <= 20: #appel de la fonctoin pour controler manuellement le drone self.manual_control() else: pass def landing(self): #fonction d'atterrisage, besoin de valider par appui sur espace print("appuyer sur espace quelque seconde pour atterrir et ensuite arrêter le drone") if keyboard.is_pressed("space"): self.keep_flying = False print("Atterrissage...") def idle(self): #fonction de vol stationnaire print("idle...") pass def set_velocity(self, *args): #fonction pour modifier la vitesse d'évitement du multiranger self.euler_x = self._normalize__(args[18],self.orig_x) angle = self.euler_x - self.ante_x if abs(angle) >= 180 : n_angle = angle % 180 angle = n_angle if angle > 0 else -n_angle if angle != 0 : delta = angle/360 if delta <= self.velocity: self.velocity += delta print("La vitesse d'évitement est maintenant de = ", self.velocity, " m/s. ", angle) self.ante_x = self.euler_x def callback_z(self, *args): #fonction de contrôle de l'altitude self.euler_x = self._normalize__(args[18],self.orig_x) angle = self.euler_x - self.ante_x if abs(angle) >= 180 : n_angle = angle % 180 angle = n_angle if angle > 0 else -n_angle if angle != 0: self.flag = True self.angle += angle else: if self.flag : self.count += 1 if self.count == 10: if self.cf != None : if abs(self.angle) > 0: if self.angle <= 0: self.motion_commander.down(abs(self.angle)/360,0.5) self.z -= abs(self.angle)/360 if self.z < 0.15: self.keep_flying = False else: self.motion_commander.up(self.angle/720,0.5) self.z += abs(self.angle)/360 self.count = 0 self.angle = 0 self.flag = False self.ante_x = self.euler_x def callback_x(self, *args): #fonction de contrôle de l'orientation (lacet) self.euler_x = self._normalize__(args[18],self.orig_x) angle = self.euler_x - self.ante_x if abs(angle) >= 180 : n_angle = angle % 180 angle = n_angle if angle > 0 else -n_angle if angle != 0: self.flag = True self.angle += angle else: if self.flag : self.count += 1 if self.count == 10: if self.cf != None : if abs(self.angle) > 0: if self.angle >= 0: self.motion_commander.turn_left(abs(self.angle), 180) else: self.motion_commander.turn_right(abs(self.angle), 180) self.count = 0 self.angle = 0 self.flag = False self.ante_x = self.euler_x def manual_control(self): #fonction de contrôle manuel du drone velocity_x = 0 velocity_y = 0 velocity_z = 0 VELOCITY = 0.5 if keyboard.is_pressed("up"): velocity_x += VELOCITY if keyboard.is_pressed("down"): velocity_x -= VELOCITY if keyboard.is_pressed("left"): velocity_y -= VELOCITY if keyboard.is_pressed("right"): velocity_y += VELOCITY if keyboard.is_pressed("u"): velocity_z += VELOCITY if keyboard.is_pressed("d"): velocity_z -= VELOCITY self.motion_commander.start_linear_motion(velocity_x, velocity_y, velocity_z) print("velocity_x = ", velocity_x, " velocity_y = ", velocity_y, " velocity_z = ", velocity_z) def sock_connect(self): #fonction qui établit la connection avec le capteur au lancement self.sock = self.osc.listen(address='0.0.0.0', port=8000, default=True) def run(self): #fonction principale qui établit la position d'origine puis lie la fonction de callback au capteur #et lance une boucle infinie tant que la fonction d'aterrrissage n'est pas lancée try: self.sock_connect() self.osc.bind(b'/0/raw',self.set_orig) print(self.keep_flying) while self.keep_flying: sleep(0.05) except KeyboardInterrupt: self.osc.stop_all() print('stopped all for keyboard interupt') self.thread_multirange.join() def stop(self): #fonction qui libère le capteur à la fin du programme self.osc.stop(self.sock) print("Stopped OCS") def multirange_push(self): #fonction appelée par le thread du multiranger qui permet de la faire tourner en concurrence avec les fonctions #de contrôle de l'orientation et autre def is_close(range): MIN_DISTANCE = 0.2 # m if range is None: return False else: return range < MIN_DISTANCE while self.keep_flying: velocity_x = 0 velocity_y = 0 if is_close(self.multiranger.front): velocity_x -= self.velocity if is_close(self.multiranger.back): velocity_x += self.velocity if is_close(self.multiranger.left): velocity_y -= self.velocity if is_close(self.multiranger.right): velocity_y += self.velocity if is_close(self.multiranger.up): self.keep_flying = False self.motion_commander.start_linear_motion( velocity_x, velocity_y, 0) sleep(0.1)
from oscpy.server import OSCThreadServer from time import sleep print("Starting") def callback(*values): print("got values: {}".format(values)) osc = OSCThreadServer() sock = osc.listen(address='127.0.0.1', port=8000, default=True) osc.bind(b'/hello/world', callback, sock) sleep(5000) osc.stop()
class station(): """ Main object to manage a station All configuration parameter are token from DB For now is possible to manage one board a time and only one transport for each You have to specify the station and the board to use. If not specified the passive transport will be selected by hard coded predefined priority: * bluetooth (hight) * serial (medium) * tcpip (low) For active transport only MQTT will be taken in account for publish (no AMQP) """ def __init__(self, slug=None, username=None, boardslug=None, picklefile="saveddata-service.pickle", trip=None, gps=plyergps(), transport_name=None, logfunc=jsonrpc.log_stdout): ''' do all startup operations ''' print("INITIALIZE rmap station") self.picklefile = picklefile self.anavarlist = [] self.datavarlist = [] self.bluetooth = None self.mqtt_status = _('Connect Status: disconnected') self.rpcin_message = b"" self.log = logfunc self.now = None self.anavarlist = [] self.datavarlist = [] self.trip = False self.slug = "BT_fixed" self.boardslug = "BT_fixed" # Exception: The intent ACTION_ACL_DISCONNECTED doesnt exist #self.br=BroadcastReceiver(self.on_broadcast,actions=["acl_disconnected"]) #self.br.start() self.gps = gps try: if os.path.isfile(self.picklefile): with open(self.picklefile, "rb") as file: self.anavarlist = pickle.load(file) self.datavarlist = pickle.load(file) self.trip = pickle.load(file) self.slug = pickle.load(file) self.boardslug = pickle.load(file) else: print("file ", self.picklefile, " do not exist") except: print("ERROR loading saved data") self.anavarlist = [] self.datavarlist = [] self.trip = False self.slug = "BT_fixed" self.boardslug = "BT_fixed" if trip is not None: self.trip = trip if slug is not None: self.slug = slug if boardslug is not None: self.boardslug = boardslug try: print("get information for station:", self.slug) if username is None: mystation = StationMetadata.objects.filter(slug=self.slug)[0] else: mystation = StationMetadata.objects.get( slug=self.slug, ident__username=username) except ObjectDoesNotExist: print("not existent station in db: do nothing!") #raise SystemExit(0) raise Rmapdonotexist("not existent station in db") if not mystation.active: print("Warning: disactivated station!") self.lon = mystation.lon self.lat = mystation.lat self.mqtt_ident = str(mystation.ident) self.prefix = mystation.mqttrootpath self.maintprefix = mystation.mqttmaintpath self.network = mystation.network self.transport_name = None self.transport = None self.active = mystation.active for cdata in mystation.stationconstantdata_set.all(): print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> constant data: ", cdata.btable) if not cdata.active: continue print("found a good constant data") self.anavarlist.append({ "coord": { "lat": self.lat, "lon": self.lon }, "anavar": { cdata.btable: { "v": cdata.value } } }) self.drivers = [] print("get info for BOARD:", self.boardslug) for board in mystation.board_set.all().filter(slug=self.boardslug): print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configure board: ", board.name) if not board.active: continue print("found a good base board") try: if (board.transportmqtt.active): print("MQTT Transport", board.transportmqtt) self.mqtt_sampletime = board.transportmqtt.mqttsampletime self.mqtt_host = board.transportmqtt.mqttserver self.mqtt_user = board.transportmqtt.mqttuser self.mqtt_password = board.transportmqtt.mqttpassword except ObjectDoesNotExist: print("transport mqtt not present") self.mqtt_sampletime = None self.mqtt_host = None self.mqtt_user = None self.mqtt_password = None #raise SystemExit(0) try: if (board.transporttcpip.active): print("TCPIP Transport", board.transporttcpip) self.tcpip_name = board.transporttcpip.name self.transport_name = "tcpip" except ObjectDoesNotExist: print("transport tcpip not present") self.tcpip_name = None # raise SystemExit(0) try: if (board.transportserial.active): print("Serial Transport", board.transportserial) self.serial_device = board.transportserial.device self.serial_baudrate = board.transportserial.baudrate self.transport_name = "serial" except ObjectDoesNotExist: print("transport serial not present") self.serial_device = None self.serial_baudrate = None # raise SystemExit(0) try: if (board.transportbluetooth.active): print("Bluetooth Transport", board.transportbluetooth) self.bluetooth_name = board.transportbluetooth.name self.transport_name = "bluetooth" except ObjectDoesNotExist: print("transport bluetooth not present") self.bluetooth_name = None #raise SystemExit(0) if not transport_name is None: self.transport_name = transport_name for sensor in board.sensor_set.all(): if not sensor.active: continue #name,i2cbus,address,timerange,level #TODO sensor.type ?? self.drivers.append({ "driver": sensor.driver, "type": sensor.type.type, "i2cbus": sensor.i2cbus, "address": sensor.address, "node": sensor.node, "timerange": sensor.timerange, "level": sensor.level }) def ismobile(self): return self.network == "mobile" def display(self): print("station: >>>>>>>>") print("lon:", self.lon) print("lat:", self.lat) print("mqtt ident:", self.mqtt_ident) print("prefix:", self.prefix) print("maintprefix", self.maintprefix) print("network:", self.network) print("board: >>>>>>>>") try: print("sampletime:", self.mqtt_sampletime) except: pass try: print("host:", self.mqtt_host) except: pass try: print("user:"******"password:"******"") print("transport:", self.transport_name) except: pass if self.transport_name == "bluetooth": print("bluetooth_name:", self.bluetooth_name) if self.transport_name == "serial": print("serial_device:", self.serial_device) print("serial_baudrate:", self.serial_baudrate) if self.transport_name == "tcpip": print("tcpip_name:", self.tcpip_name) print(">>>> sensors:") print(self.drivers) def rpcin(self, message): """ Get a message from osc channel """ print("station RPC: {}".format(message)) print(message) self.rpcin_message = message def rpcout(self, message): """ Send a message to osc channel """ send_message(b'/rpc', [ message, ], ip_address='localhost', port=3001, safer=True) def on_stop(self): ''' called on application stop Here you can save data if needed ''' print(">>>>>>>>> called on application stop") try: self.stoptransport() print("transport stopped") except: print("stop transport failed") # this seems required by android >= 5 if self.bluetooth: self.bluetooth.close() self.stopmqtt() print("mqtt stopped") self.gps.stop() print("gps stopped") #self.br.stop() print("start save common parameters") with open(self.picklefile, "wb") as file: pickle.dump(self.anavarlist, file) pickle.dump(self.datavarlist, file) pickle.dump(self.trip, file) pickle.dump(self.slug, file) pickle.dump(self.boardslug, file) print("end save common parameters") def on_pause(self): ''' called on application pause Here you can save data if needed ''' print(">>>>>>>>> called on application pause") self.on_stop() return True def on_resume(self): ''' called on appication resume Here you can check if any data needs replacing (usually nothing) ''' print(">>>>>>>>> called on appication resume") #self.br.start() try: if os.path.isfile(self.picklefile): with open(self.picklefile, "rb") as file: self.anavarlist = pickle.load(file) self.datavarlist = pickle.load(file) self.trip = pickle.load(file) self.slug = pickle.load(file) self.boardslug = pickle.load(file) else: print("file ", self.picklefile, " do not exist") except: print("ERROR loading saved data") self.anavarlist = [] self.datavarlist = [] self.trip = False self.slug = "BT_fixed" self.boardslug = "BT_fixed" def configurestation(self, board_slug=None, username=None): """ configure the board with those steps: * reset configuration * configure board * save configuration """ try: self.starttransport() if board_slug is None: board_slug = self.boardslug if username is None: username = self.username print("configstation:", self.slug, board_slug, board_slug, username) rmap_core.configstation(station_slug=self.slug, board_slug=board_slug, transport=self.transport, logfunc=self.log, username=username) except Exception as e: print("error in configure:") print(e) raise finally: self.stoptransport() def sensorssetup(self): """ Setup of all sensors. This should be done at startup """ self.sensors = [] for driver in self.drivers: try: print("driver: ", driver) if driver["driver"] == "JRPC": print("found JRPC driver; setup for bridged RPC") sd = SensorDriver.factory(driver["driver"], transport=self.transport) # change transport ! sd.setup(driver="I2C", node=driver["node"], type=driver["type"], address=driver["address"]) elif driver["driver"] == "RF24": print("found RF24 driver; setup for bridged RPC") sd = SensorDriver.factory("JRPC", transport=self.transport) # change transport ! sd.setup(driver=driver["driver"], node=driver["node"], type=driver["type"], address=driver["address"]) else: sd = SensorDriver.factory(driver["driver"], type=driver["type"]) sd.setup(i2cbus=driver["i2cbus"], address=driver["address"]) self.sensors.append({ "driver": sd, "timerange": driver["timerange"], "level": driver["level"] }) except: print("error in setup; sensor disabled:",\ " driver=",driver["driver"],\ " node=",driver["node"],\ " type=",driver["type"],\ " address=",driver["address"]) raise Exception("sensors setup", 1) def getdata(self, trip=None, now=None): """ get data for all sensors with those steps: * prepare sensors * wait for samples are ready * get samples return False if the transport never works (used to reconnect bluetooth) """ print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>getdata") if trip is None: trip = self.trip if trip and not self.ismobile(): print("trip with fix station: do nothing") return True, {} if not trip and self.ismobile(): print("not on trip with mobile station: do nothing") return True, {} if trip and self.gps.gpsfix: self.lat = self.gps.lat self.lon = self.gps.lon #self.anavar["B07030"]={"v": self.gps.height} # add #self.anavar={"B07030":{"v": self.gps.height}} # overwrite self.anavarlist.append({ "coord": { "lat": self.lat, "lon": self.lon }, "anavar": { "B07030": { "v": self.gps.height } } }) elif trip: print("we have lost gps during a trip") return True, {} dt = 0 connected = False if now is None: now = datetime.utcnow().replace(microsecond=0) for sensor in self.sensors: print("prepare: ", sensor) try: dt = max(sensor["driver"].prepare(), dt) connected = True except Exception as e: print(e) print("ERROR executing prepare rpc") traceback.print_exc() print("sleep ms:", dt) time.sleep(dt / 1000.) #message="" datavars = [] for sensor in self.sensors: try: for btable, value in sensor["driver"].get().items(): datavar = {btable: {"t": now, "v": value}} datavars.append(datavar) self.datavarlist.append({"coord":{"lat":self.lat,"lon":self.lon},"timerange":sensor["timerange"],\ "level":sensor["level"],"datavar":datavar}) # stringa ="" # for btable,data in datavar.iteritems(): # stringa += btable+": "+ data["t"].strftime("%d/%m/%y %H:%M:%S")+" -> "+str(data["v"])+"\n" # message=stringa except Exception as e: print(e) print("ERROR executing getJson rpc") traceback.print_exc() return connected, datavars # def on_broadcast(self,context,intent): # # print "BLUETOOTH disconnected" # # extras=intent.getExtras() # device= extras.get("device") # # print "BLUETOOTH received:",device def startmqtt(self): ''' begin mqtt connection and publish constat station data ''' print(">>>>>>> startmqtt") #config = self.config if self.lat is None or self.lon is None: print("you have to set LAT and LON") self.mqtt_status = _( 'Connect Status: ERROR, you have to define a location !') return self.stopmqtt() self.mqtt_status = _('Connect Status: connecting') try: self.rmap = rmapmqtt(ident=self.mqtt_ident, lon=self.lon, lat=self.lat, network=self.network, host=self.mqtt_host, username=self.mqtt_user, password=self.mqtt_password, prefix=self.prefix, maintprefix=self.maintprefix, logfunc=self.log) self.rmap.loop_start() except: pass def publishmqtt(self): ''' publish data on mqtt server ''' # here we generate randon data to test only #----------------------------------------------------------- # timerange="254,0,0" # dati istantanei # level="105,2,-,-" # livello fittizio 2 # # value=random.randint(25315,30000) # tempertaure in cent K # datavar={"B12101": # { # "t": datetime.utcnow(), # "v": value, # "a": { # "B33194": "90", # attributi di qualita' del dato # "B33195": "85" # } # }} #----------------------------------------------------------- #print "queue ana :",self.anavarlist #print "queue data:",self.datavarlist try: if self.rmap.connected: newanavarlist = [] for item in self.anavarlist: print("try to publish", item) try: self.rmap.ana(item["anavar"], lon=item["coord"]["lon"], lat=item["coord"]["lat"]) except: newdatavarlist.append(item) self.mqtt_status = _( 'Connect Status: ERROR on Publish') self.anavarlist = newanavarlist newdatavarlist = [] for item in self.datavarlist: print("try to publish", item) try: self.rmap.data(item["timerange"], item["level"], item["datavar"], lon=item["coord"]["lon"], lat=item["coord"]["lat"], prefix=item.get("prefix", None)) self.mqtt_status = _('Connect Status: Published') print("pubblicato", item["datavar"]) except: newdatavarlist.append(item) self.mqtt_status = _( 'Connect Status: ERROR on Publish') self.datavarlist = newdatavarlist else: self.mqtt_status = _( 'Connect Status: ERROR on Publish, not connected') except: self.mqtt_status = _('Connect Status: ERROR on Publish') def stopmqtt(self): ''' disconnect from mqtt server ''' try: #if self.rmap.connected: self.rmap.disconnect() except: pass try: self.rmap.loop_stop() except: pass #force status and messages because we do not wait ACK self.connected = False self.mqtt_status = _('Connect Status: disconnected') #@mainthread def publishmqtt_loop(self, *args): ''' call this to publish data ''' if self.rmap.connected: print("mqtt connected") else: #print "mqtt reconnect" #try: # self.rmap.mqttc.reconnect() #except: # print "error on reconnect" print("try to restart mqtt") self.startmqtt() if self.rmap.connected: self.mqtt_status = _('Connect Status: OK connected') else: self.mqtt_status = _('Connect Status: disconnected') self.publishmqtt() return True def getdata_loop(self, trip=None): ''' This function manage jsonrpc. With bluetooth transport manage reconnection ''' if self.transport_name == "bluetooth": if self.bluetooth.bluetooth is None: print("Bluetooth try to reconnect") self.transport = self.bluetooth.connect() if self.transport is None: print("bluetooth disabled") return True else: try: self.sensorssetup() except: print("sensorssetup failed") connected, datavars = self.getdata(trip, self.now) if not connected and self.transport_name == "bluetooth": self.bluetooth.close() self.transport = self.bluetooth.connect() try: self.sensorssetup() except: print("sensorssetup failed") return datavars def loop(self, *args): ''' This function manage jsonrpc and mqtt messages. ''' print("call in loop") self.getdata_loop() self.publishmqtt_loop() return True def starttransport(self): """ start transport """ print(">>>>>>> start transport ", self.transport_name) if self.transport_name == "bluetooth": print("start bluetooth") self.bluetooth = androbluetooth(name=self.bluetooth_name, logfunc=self.log) self.transport = self.bluetooth.connect() if self.transport_name == "tcpip": print("start tcpip") self.transport = jsonrpc.TransportTcpIp(addr=(self.tcpip_name, 1000), timeout=3, logfunc=self.log) if self.transport_name == "serial": print("start serial") self.transport = jsonrpc.TransportSERIAL( port=self.serial_device, baudrate=self.serial_baudrate, logfunc=self.log) if self.transport_name == "mqtt": print("start mqtt") self.transport = jsonrpc.TransportMQTT(user=self.mqtt_user, password=self.mqtt_password, host=self.mqtt_host, logfunc=self.log) if self.transport is None: raise Exception("start transport", 1) def stoptransport(self): """ stop transport """ try: if not self.transport is None: self.transport.close() except: print("ERROR closing transport") raise Exception("stop transport", 1) def boot(self, configurestation=False): print("background boot station") #### osc IPC #### #osc.init() self.osc = OSCThreadServer() sock = self.osc.listen(port=3000, default=True) self.osc.bind(b'/rpc', self.rpcin) #force trip for mobile station in background self.trip = self.ismobile() try: self.starttransport() except: print("start transport failed") notok = True while notok: try: if configurestation: self.configurestation() try: self.sensorssetup() except: print("sensorssetup failed") if self.trip: self.gps.start() self.startmqtt() notok = False except: print("Error booting station") time.sleep(5) if self.rpcin_message == b"stop": print("received stop message from rpc") self.on_stop() print("send stopped message to rpc") self.rpcout(b"stopped") raise SystemExit(0) #time.sleep(60) # wait for kill from father if self.transport_name == "bluetooth": self.bluetooth.close() self.transport = self.bluetooth.connect() try: self.sensorssetup() except: print("sensorssetup failed") print("background end boot") def loopforever(self): # wait until a "even" datetime and set nexttime now = datetime.utcnow() print("now:", now) nexttime = now + timedelta(seconds=self.mqtt_sampletime) nextsec = int( nexttime.second / self.mqtt_sampletime) * self.mqtt_sampletime nexttime = nexttime.replace(second=nextsec, microsecond=0) print("nexttime:", nexttime) waitsec = (max((nexttime - datetime.utcnow()), timedelta())).total_seconds() print("wait for:", waitsec) time.sleep(waitsec) print("now:", datetime.utcnow()) self.now = nexttime #self.rmap.loop(timeout=waitsec) # TODO # enable STOP SERVICE DURING SLEEP while True: try: #override "even" datetime with more precise but "odd" datetime #self.now=datetime.utcnow() #print "now:",self.now self.loop() print("backgroud loop") message = self.mqtt_status title = "Rmap last status" if self.transport_name == "bluetooth": title = self.bluetooth.bluetooth_status print("notification title:") print(title) print("notification message:") print(message) do_notify(message, title) except Exception as e: print(e) print("ERROR in main loop!") traceback.print_exc() print("now:", datetime.utcnow()) nexttime = nexttime + timedelta(seconds=self.mqtt_sampletime) self.sleep_and_check_stop(nexttime) self.now = nexttime def sleep_and_check_stop(self, nexttime): waitsec = (max((nexttime - datetime.utcnow()), timedelta())).total_seconds() print("wait for:", waitsec) #time.sleep(waitsec) stop = False while (datetime.utcnow() < nexttime): if self.rpcin_message == b"stop": stop = True break time.sleep(.5) if self.rpcin_message == b"stop": stop = True if (not stop): print("continue on loop") return print("start shutdown background process") try: self.on_stop() except: print("error on_stop") print("retuned from on_stop") print("RPC send stoppped") self.rpcout(b"stopped") print("background exit") try: self.osc.stop() print("osc stopped") except: pass raise SystemExit(0) #time.sleep(s30) def exit(self, *args): try: self.on_stop() except: print("error on_stop") raise SystemExit(0)
def main(): global pauser global command global haiku_bot global max_client global cam1_socket global cam2_socket global chatbot pauser = False command = "pause" warnings.filterwarnings("ignore") logging.disable(logging.CRITICAL) tf_session = tf.Session() K.set_session(tf_session) bye_list = ['bye', 'see you', 'tada', 'chao'] #Connection Initialization print("Creating Connections") #Connecting to max try: max_client = udp_client.SimpleUDPClient(opt.maxip, opt.maxport) print("UDP Client connection to Max established") except KeyboardInterrupt: print("Keyboard Interrupted at UDP connection") except: print("UDP Client connection to Max failed. Will not be able to send from Max.") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ################# Connecting to Camera 1 ##################### if(opt.test==False): try: cam1_socket = socket.socket() cam1_socket.connect((opt.camip1, opt.camport1)) print("Connection to Camera 1 established") except KeyboardInterrupt: print("Keyboard Interrupted at Camera 1 connection") except: print("Unable to connect to Camera 1") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ############### Connecting to Camera 2 ####################### try: cam2_socket = socket.socket() cam2_socket.connect((opt.camip2, opt.camport2)) print("Connection to Camera 2 established") except KeyboardInterrupt: print("Keyboard Interrupted at Camera 2 connection") except: print("Unable to connect to Camera 2") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) #Max server: Listen to Max ''' try: osc = OSCThreadServer() try: max_server = osc.listen(address=opt.chatip, port=opt.chatport, default=True) print("OSC Server initialized to listen to Max") osc.bind(b"/chat", chat_callback) osc.bind(b"/command", command_callback) osc.bind(b"/kill", kill_switch) ##########sddrd to test Vishal######################### osc.bind(b"/stop", stop_resume_operation) ######Vishal######################### osc.bind(b"/emotions", get_cached_emotion) except: print("Tag is not in exceptable format") ##########sddrd to test Vishal######################### except: print("OSC Server initialization failed. Will not be able to listen to Max") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno))''' #Max server: Listen to Max try: osc = OSCThreadServer() try: max_server = osc.listen(address=opt.chatip, port=opt.chatport, default=True) print("OSC Server initialized to listen to Max") osc.bind(b"/chat", chat_callback) osc.bind(b"/command", command_callback) osc.bind(b"/kill", kill_switch) ##########sddrd to test Vishal######################### osc.bind(b"/stop", stop_resume_operation) ## kk code for start osc.bind(b"/start", start_chat) osc.bind(b"/haiku", haiku_generator) osc.bind(b"/names", send_names) osc.bind(b"/emotions", get_cached_emotion) osc.bind(b"/jump", jump_story) except Exception as e: print(e) print("Tag is not in exceptable format") ##########sddrd to test Vishal######################### except KeyboardInterrupt: print("Keyboard Interrupted at OSC Communication") except: print("OSC Server initialization failed. Will not be able to listen to Max") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) ########### Chatbot Generator ##################### # haiku_intialiser(tf_session) try: chatbot = Chatbot(tf_session, story_progress=opt.jump) univEncoder = UnivEncoder(tf_session, chatbot.intents) print("Initialized chatbot dialogue system") except KeyboardInterrupt: print("Keyboard Interrupted at Chatbot") exit() except: print("Unable to initialize chatbot dialogue system. Exiting.") print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) exit() #Waiting for max command to start chatbot # command = "stopped" # while command != "chat": # while max_response.empty(): # stopped = True # max_request = max_response.get() # command = max_request['command'] # if() print(time.time()) print("Starting chatbot for the first time") max_client.send_message(start_tag, "ready") while command != "kill": users = False faces_count = 0 chat_start = True returning_user = False ask_user_name = True while command != "pause" and command != "new" and command !="kill": try: if ask_user_name: ask_user_name = False try: os.mkdir("users") except: users = True ## Creating a txt file and storing all the sentence ## global file ## kk code to open and close history file start ## file = open("history.txt", "w+") file.close() ## kk code to open and close history file end ## #TODO: There is no kill switch check or command check. Need to implement it. first_sentence = "Hello! - - - You can text to me with your phone - - - I see a visitor in red, how are you ?" max_client.send_message(chat_tag, first_sentence) history(first_sentence) # time.sleep(chat_speed_slow) while max_response.empty(): waiting_for_user = True user_response = max_response.get() history(user_response['intent']) # players_names = ["dummy1", "dummy2", "dummy3", "dummy4", "dummy5"] ## kk code start## if(opt.jump==0): chat = "Thank you! I see five visitors. What is your name, visitor one in red ?" #.format(players) max_client.send_message(chat_tag, chat) while max_response.empty(): waiting_for_user = True history(chat) print("players names ", players_names) # try: greetings = ["Hi ", "Welcome ", "Hello ", "Its my pleasure ", "Hello "] user_colors = [". visitor two in green ?", ". visitor three in blue ?", ". visitor four in orange ?", ". visitor five in yellow ?", ""] i = 0 while max_response.empty(): waiting_for_user = True for __ in range(players): user_response = max_response.get() name = user_response['intent'] history(name) players_names.append(name) chat = greetings[i] + name.strip('""') + ". - - - " + user_colors[i] max_client.send_message(chat_tag, chat) history(chat) i+=1 # except: # print("ran into exception ") print("players names ", players_names) # user_response = max_response.get() #TODO: We might need to validate the cities # user_location = user_response['intent'] # history(user_location) ############## Sending name ################## names = str(players_names).strip('""') names = names.strip('[]') names = names.replace('""', " ") names = names.replace("\'", " ") names = names.replace(",", " ") names = names.replace('"', " ") # print(names) max_client.send_message(names_tag, names) #Monologue chat = "Nice to meet you all. - - - I lihve here. - - - Here on stage. I can’t leave the stage." max_client.send_message(chat_tag, chat) time.sleep(chat_speed) pauser = True print("value of pauser", pauser) max_client.send_message(stop_tag, 'PAUSE') # while pauser: # waiting_for_user = True # chat = 'Where do you lihve, {0} ? - - - Do you live on stage like me - - - or do you lihve in a house, {0} ?'.format(players_names[3].strip('""')) # max_client.send_message(chat_tag, chat) # history(chat) ## commenting code end try: while max_response.empty(): waiting_for_user = True user_response = max_response.get() history(user_response['intent']) user_chat = user_response['intent'] print("user input", user_chat) if(user_chat.strip('""') in bye_list): chat = 'It was nice talking to you.' max_client.send_message(chat_tag, chat) history(chat) command = 'kill' file.close() break intent = univEncoder.match_intent(user_chat,chatbot.story_progress) print("intent name", intent) # print("weight", chatbot.progress) # print(chatbot.intents[intent].dynamic) if(intent == 'no_matching_intent'): chat = "hmm - - I dont understand {0} , can you please say something different".format(user_chat) # chat = univEncoder.chat_eliza(user_chat) # print("Response from Eliza \n {0}".format(chat)) max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now end - kkk ##### elif "transition" in intent: print("inside change transition logic") store_progress = chatbot.story_progress print("progress value", store_progress) # story_transition() next_story = intent.split("_")[2] print("next story", next_story) chatbot.change_story(next_story) univEncoder.set_intent(chatbot.intents) l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[intent].weight chat = chatbot.intents[intent].responses[randrange(l)] chat = check_response(chat) max_client.send_message(chat_tag, chat) history(chat) elif "main" in intent: print("inside change main logic") chatbot.change_story("see_me", store_progress+6) # print(chatbot.intents) univEncoder.set_intent(chatbot.intents) l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[intent].weight chat = chatbot.intents[intent].responses[randrange(l)] chat = check_response(chat) max_client.send_message(chat_tag, chat) history(chat) elif "happiness" in intent: print("inside last intent logic") # chatbot.change_story("see_me", store_progress+6) # print(chatbot.intents) # univEncoder.set_intent(chatbot.intents) l = len(chatbot.intents[intent].responses) if l > 0: chatbot.story_progress = chatbot.intents[intent].weight chat = chatbot.intents[intent].responses[randrange(l)] chat = check_response(chat) max_client.send_message(chat_tag, chat) max_client.send_message(stop_tag, "END") history(chat) command = "kill" else: l = len(chatbot.intents[intent].responses) if l > 0: if(intent=="learning"): print("inside color intent") user_color = user_response['intent'] print(user_color) try: user_rgb = [round(ele, 3) for ele in Color(user_color.strip('"')).rgb] # user_rgb = [int(i)*255 for i in user_rgb] user_rgb = str(user_rgb).strip('[]') user_rgb = user_rgb.replace(",", "") # print(user_rgb.rgb) print(user_rgb) history(str(user_rgb)) history(chat) chatbot.story_progress = chatbot.intents[intent].weight chat = chatbot.intents[intent].responses[randrange(l)] chat = check_response(chat) max_client.send_message(chat_tag, chat) max_client.send_message(rgb_tag, str(user_rgb)) except: max_client.send_message(chat_tag, "I dont understand this color, please try something else") else: chatbot.story_progress = chatbot.intents[intent].weight chat = chatbot.intents[intent].responses[randrange(l)] chat = check_response(chat) max_client.send_message(chat_tag, chat) history(chat) except KeyboardInterrupt: print("Closing all active connections") command = "kill" except: print('Error: {}. {}, line: {}'.format(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2].tb_lineno)) chat = "hmm, I dont know what {0} is, can you please say something different".format(user_response['intent']) max_client.send_message(chat_tag, chat) history(chat) ##### Haiku poems, Disabling for now start - kkk ##### # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # poem = haiku_bot.generate_haiku([3, 5, 3], temperature=.3, first_char='cold') # line1 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[0]) # line2 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[1]) # line3 = re.sub(r"[^a-zA-Z0-9]+", ' ', poem[2]) # chat = line1 + line2 + line3 # max_client.send_message(chat_tag, chat) ##### Haiku poems, Disabling for now end - kkk ##### except KeyboardInterrupt: print("Closing all active connections") command = "kill" try: try: cam1_socket.send(camera_message.encode('utf-8')) cam1_socket.close() print("Connection to Camera 1 closed") except: print("unable to close camera 1") try: cam2_socket.send(camera_message.encode('utf-8')) cam2_socket.close() print("Connection to Camera 2 closed") except: print("unable to close camera 2") try: osc.stop() print("Connection to Max closed") except: print("unable to close connectoin to Max") except: print('unable to close connections')
def main(ip_address, port, path): osc = OSCThreadServer(encoding="utf8") osc.listen(address=ip_address, port=int(port), default=True) osc.bind(path, onReceiveMessageCallback) sleep(1000) osc.stop()
class OSC_OT_OSCPyServer(OSC_OT_OSCServer): bl_idname = "nodeosc.oscpy_operator" bl_label = "OSCMainThread" _timer = None count = 0 ##################################### # CUSTOMIZEABLE FUNCTIONS: inputServer = "" #for the receiving socket outputServer = "" #for the sending socket # setup the sending server def setupInputServer(self, context, envars): self.dispatcher = dispatcher.Dispatcher() # setup the receiving server def setupOutputServer(self, context, envars): #For sending self.outputServer = OSCClient(envars.udp_out, envars.port_out) self.outputServer.send_message(b'/NodeOSC', [b'Python server started up']) print("OSCPy Server sended test message to " + envars.udp_out + " on port " + str(envars.port_out)) def sendingOSC(self, context, event): oscMessage = {} # gather all the ouput bound osc messages make_osc_messages(bpy.context.scene.NodeOSC_outputs, oscMessage) # and send them for key, args in oscMessage.items(): values = [] if isinstance(args, (tuple, list)): for argum in args: if type(argum) == str: argum = bytes(argum, encoding='utf-8') values.append(argum) else: if type(args) == str: args = bytes(args, encoding='utf-8') values.append(args) self.outputServer.send_message(bytes(key, encoding='utf-8'), values) # add method def addMethod(self, address, data): pass #already set during creation of inputserver # add default method def addDefaultMethod(self): pass #already set during creation of inputserver # start receiving def startupInputServer(self, context, envars): print("Create OscPy Thread...") # creating a blocking UDP Server # Each message will be handled sequentially on the same thread. self.inputServer = OSCThreadServer(encoding='utf8', default_handler=OSC_callback_oscpy) sock = self.inputServer.listen(address=envars.udp_in, port=envars.port_in, default=True) print("... server started on ", envars.port_in) # stop receiving def shutDownInputServer(self, context, envars): print("OSCPy Server is shutting down...") self.inputServer.stop() # Stop default socket print(" stopping all sockets...") self.inputServer.stop_all() # Stop all sockets print(" terminating server...") self.inputServer.terminate_server() # Request the handler thread to stop looping self.inputServer.join_server() # Wait for the handler thread to finish pending tasks and exit print("... OSCPy Server is shutdown")
euler_y = args[19] euler_z = args[20] euler_bonus = args[21] euler_x = args[20] euler_x = round(euler_x) if euler_x < 0: euler_x = 360 + euler_x angle = euler_x - list[0] angle2 = math.atan2(2*(quat_x*quat_w + quat_y*quat_z), 1-2*(quat_z**2+quat_w**2)) print(euler_x) list[0] = euler_x print("testing OSC in python") osc = OSCThreadServer() try : sock = osc.listen(address='0.0.0.0', port=8000, default=True) osc.bind(b'/0/raw', OSCcallback) sleep(25) osc.stop(sock) print('stopped OSC') except KeyboardInterrupt: osc.stop_all() print('stopped all for keyboard interupt')