def __init__(self, port, bind_collection={}, **kwargs):
# super(SocketP2P, self).__init__(**kwargs)
self._port = port
self._bind_collection = bind_collection
self._bind_collection.update({
'/probe': self._probe,
'/found': self._found,
'/hided': self._hided_host,
'/get_conf': self._send_conf,
'/conf': self._got_conf,
'/new_device': self._new_device,
'/delete_device': self._delete_device
})
for event in SocketP2P.__events__:
self._callback_collec[event] = [getattr(self, event)]
sock = socket.socket(AF_INET, SOCK_DGRAM)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.settimeout(1)
self._scan_client = OSCClient(address='255.255.255.255',
port=self._port,
sock=sock,
encoding='utf8')
self.create_server()
def __init__(self, cam_num, ip, port, coordinates):
print("cam initialized")
self.x1, self.y1, self.x2, self.y2 = coordinates
self.osc = OSCClient(ip, port)
self.range_filter = 'HSV'
self.capture = False
self.lock = threading.Lock()
self.camera = cv2.VideoCapture(cam_num)
ret, image = self.camera.read()
if (not ret):
print("cam error!")
pass
self.width, self.height = self.x2 - self.x1, self.y2 - self.y1
#Markers
self.flip = False
self.m1 = [44, 99, 0, 84, 255, 255]
self.m2 = [0, 174, 0, 6, 255, 255]
self.m3 = [108, 44, 0, 137, 255, 255]
self.m4 = [0, 174, 0, 6, 255, 255]
self.items1 = [[0, 0]] #queue1
self.items2 = [[0, 0]] #queue2
self.seq1 = 2500 #sequence number1
self.seq2 = 1 #sequence number2
self.flag1, self.flag2 = False, False
def test_oscclient():
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
acc = []
def success(*values):
acc.append(values[0])
osc.bind(b'/success', success, sock)
client = OSCClient('localhost', port)
timeout = time() + 5
while len(acc) < 50:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_message(b'/success', [1])
while len(acc) < 100:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_bundle([(b'/success', [i]) for i in range(10)])
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 coord_callback(event, *args):
# send event data to event address and app port,
# this will be received by screens' coordinator
Logger.info('control SEND>: event msg: ' + str(event))
# osc.sendMsg(OSCConfig.event_addr, dataArray=[str(event),], port=OSCConfig.app_port)
osc = OSCClient("127.0.0.1", OSCConfig.app_port)
osc.send_message(bytes(OSCConfig.event_addr, "ascii"), [str(event),])
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 setup_service():
Logger.info('service: setup_service')
setup_logger('mi')
# add this dir to module search path
app_dir = os.path.join(mi2app_utils.get_files_dir(), "app")
sys.path.append(os.path.join(app_dir, 'service'))
Logger.info('service: sys path added: ' + str(sys.path))
# setup control and listen to osc signal
control = Control()
Logger.info('service: control created' + repr(control))
osc = OSCThreadServer()
osc.listen(port=OSCConfig.service_port, default=True)
# def dummy_callback(msg, *args):
# Logger.info('service: dummy callback: ' + str(msg))
# osc.bind(OSCID, dummy_callback, OSCConfig.control_addr)
osc.bind(bytes(OSCConfig.control_addr, "ascii"), control.osc_callback)
# Logger.info('service: osc setup, id: ' + OSCID)
Logger.info('service: osc setup')
gps_provider = GpsListener(on_gps)
gps_provider.start()
osc_client = OSCClient("127.0.0.1", OSCConfig.service_port)
osc_client.send_message(bytes(OSCConfig.control_addr, "ascii"), ['service ready',])
Logger.info('service SEND>: service ready msg sent')
while True:
# osc.readQueue(thread_id=OSCID)
time.sleep(.5)
def __init__(self, host, port):
# fix for https://github.com/repl-electric/sonic-pi.el/issues/19#issuecomment-345222832
self.prefix = b'@osc_server||=SonicPi::OSC::UDPServer.new(4559,use_decoder_cache:true) #__nosave__\n'
self.client_name = b'SONIC_PI_TOOL_PY'
self.host = host
self.port = port
self.client = OSCClient(host, port)
def __init__(self):
self.tzero = time()
self.step_total = 0 # Nombre total de step
self.t = -1 # Suivi du nombre de step dans la cycle
self.cycle_number = 0 # Suivi du nombre de cycle
self.t_cycle = 0
self.x_threshold = 8 # 2.4
self.t_limit = 2000
self.my_reward_total = 0
self.reward_old = 0
# Valeur maxi de teta_dot
self.VMAX = 1
high = np.array([
np.finfo(np.float32).max,
np.finfo(np.float32).max,
np.finfo(np.float32).max,
np.finfo(np.float32).max,
np.finfo(np.float32).max])
# Action Continue dans [-1, 1]
self.action_space = spaces.Box(-1.0, 1.0, shape=(1,))
self.observation_space = spaces.Box(-high, high)
self.seed()
self.viewer = None
self.state = None
self.osc_server_init()
self.state_updated = 0
self.client = OSCClient(b'localhost', 3001)
self.info = [[], [], [], []]
self.log_file = "./log/log-" + strftime("%Y%m%d-%H%M%S") + ".txt"
def __init__(self):
#address = "127.0.0.1"
#port = 8000
address = '0.0.0.0'
port = 8000
self.osc = OSCClient(address, port)
self.window_name = 'Control'
def __init__(self):
"""
Create a client connection to QLab
"""
self.client = OSCClient('127.0.0.1', 53000, encoding='utf8')
self.server = Listener('127.0.0.1', 53001)
self.wpid = self.get_wpid()
self.encoding = 'utf8'
def __init__(self, ind, addr, port, **kwargs):
self.source = 0
self.idx = ind
self.osc_client = OSCClient(addr, port)
super(FaderWidget, self).__init__(**kwargs)
def send(self, host, port, addr, args=()):
logger.debug('[OscServer.send host={} port={}] {} {}'.format(host,port,addr,args))
# for debugging only, really
if self.capture_sends:
self.capture_sends(host, port, addr, args)
return
client = OSCClient(host, port)
client.send_message(bytes(addr, 'utf-8'), args)
def blemote_poll():
global auto_port_out, auto_udp_out, stored, upd_cnt, blem_cnt
pref = bpy.context.preferences.addons['AddRoutes'].preferences
if pref.blemote_autoconf:
udp_out = auto_udp_out
port_out = auto_port_out
else:
udp_out = pref.blemote_udp_out
port_out = pref.blemote_port_out
try:
osc = OSCClient(udp_out, port_out, encoding='utf8')
osc.send_message("/pong", [upd_cnt])
except:
return 1
current = g_vars.addroutes_blemote
if blem_cnt != upd_cnt:
addr = str.encode('/BLEMOTE_ROUTES')
osc.send_message(addr, [str.encode('START')])
for p_rnk, item in g_vars.addroutes_blemote.items():
dico = item[2]
n = item[1]
val = dico['min']
bl_item = item[0]
index = bl_item.array
try:
if bl_item.is_str2eval is False:
#print(dico['trigger'])
if bl_item.is_array:
val = getattr(dico['trigger']['ref'],
dico['trigger']['prop'])[index]
else:
val = getattr(dico['trigger']['ref'],
dico['trigger']['prop'])
except:
pass
to_send = [
p_rnk, n, dico['min'], dico['max'], dico['step'],
dico['category'], val
]
osc.send_message(addr, to_send)
osc.send_message(addr, ['STOP'])
#print('BLEMOTE ROUTES UPDATE')
if current != stored:
upd_cnt += 1
stored = dict(current)
return 2
def onCameraClick(self, *args):
address = "0.0.0.0"
port = 8888
osc = OSCClient(address, port)
for i in range(10):
print(" SENDING OSC", i)
osc.send_message(b'/address', [i])
self.start_service()
def __init__(self, ip, port):
""" ip = "192.168.1.101"
ip = b'localhost'
"""
self.ip = ip
self.port = port
# Pour l'enregistrement d'un json à la fin de la capture
self.all_data = []
self.client = OSCClient(self.ip, self.port)
def thread_target(msg):
# wait for service ready event
self._service_ready.wait()
# Update OSC
osc = OSCClient("127.0.0.1", OSCConfig.service_port)
osc.send_message(bytes(OSCConfig.control_addr, "ascii"), [
str(msg),
])
# osc = OSCThreadServer()
# osc.send_message(OSCConfig.control_addr, values=[str(msg), ], *osc.getaddress(), port=OSCConfig.service_port)
Logger.info('coordinator SEND>: control msg: ' + msg)
def init_osc(self):
self.server = OSCThreadServer()
self.server.listen('localhost', port=3001, default=True)
self.server.timeout = 0.001
self.server.bind(b'/activity', self.on_activity)
self.server.bind(b'/stop', self.on_stop)
self.server.bind(b'/sensor_enable', self.on_sensor_enable)
self.server.bind(b'/frequency', self.on_frequency)
self.server.bind(b'/save_npz', self.on_save_npz)
self.client = OSCClient(b'localhost', 3003)
def __init__(self):
self.sensor = "Recherche d'un capteur ..."
# a, b, c, activity, num, tempo
self.display_list = [0, 0, 0, -2, 0, 1, 0]
self.histo = []
self.server = OSCThreadServer()
self.server.listen(address=b'localhost', port=3003, default=True)
self.server.bind(b'/acc', self.on_acc)
self.server.bind(b'/sensor', self.on_sensor)
self.client = OSCClient(b'localhost', 3001)
self.t_init = 0
def init_osc(self):
"""Le serveur peut envoyer
mais impossible d'avoir 2 serveurs sur le même port.
"""
self.server = OSCThreadServer()
self.server.listen('localhost', port=3001, default=True)
# Les callbacks du serveur
self.server.bind(b'/activity', self.on_activity)
self.server.bind(b'/stop', self.on_stop)
self.server.bind(b'/sensor_enable', self.on_sensor_enable)
# Un simple client
self.client = OSCClient(b'localhost', 3003)
def __init__(self, path, addr, port, **kwargs):
self.index = 0
self.min = 0
self.max = 10
self.path = path
self.source = 0
self.osc_client = OSCClient(addr, port)
super(FaderWidget, self).__init__(**kwargs)
def __init__(self):
address = "127.0.0.1"
port = 8008
self.osc = OSCClient(address, port)
self.text = ""
import settings
import cooked_files_handler
self.settings = settings.Settings()
self.songs_models = cooked_files_handler.CookedFilesHandler(
self.settings)
self.songs_models.prepare_songs_models_paths()
def __init__(self):
self.sensor = "\nRecherche d'un capteur ..."
# a, b, c, activity, num, tempo
self.display_list = [0, 0, 0, 0, 0, 1, 0]
# Conservation de tout l'historique
self.histo_xyz = []
self.server = OSCThreadServer()
self.server.listen(address=b'localhost', port=3003, default=True)
self.server.bind(b'/acc', self.on_acc)
self.server.bind(b'/sensor', self.on_sensor)
self.server.bind(b'/offset', self.on_offset)
self.client = OSCClient(b'localhost', 3001)
self.t_init = None
def send(data):
"""# N° body à la fin
msg.append(bodyId)
# Heure de capture
self.all_data.append([msg, time()])
self.client.send_message(b'/points', msg)
"""
client = OSCClient(b'localhost', 8003)
for points in data:
points = points[0]
client.send_message(b'/points', points)
print(points)
sleep(0.1)
def get_osc_client(to_app):
socket_index = 0 if to_app else 1
socket_options = _get_osc_socket_options(socket_index=socket_index)
socket_family = socket_options.pop("family")
sock = socket.socket(
socket.AF_UNIX if socket_family == "unix" else socket.AF_INET,
socket.SOCK_DGRAM)
socket_options["sock"] = sock
client = OSCClient(encoding="utf8", **socket_options)
return client
def osc_frame_upd(scn):
# kludge to avoid error while changing scene
if g_vars.scene is not scn:
return
# send osc events
bcw = bpy.context.window_manager
osc = OSCClient(bcw.addroutes_osc_udp_out, bcw.addroutes_osc_port_out, encoding='utf8')
if bcw.addroutes_osc_out_enable is True:
for bl_item, item in g_vars.addroutes_osc_out:
# getting current value
if bl_item.is_str2eval:
g_vars.evalprop(bl_item.str2eval, bl_item.withctx)
prop = g_vars.eval_prop
ref = g_vars.eval_ref
else:
ref = item['ref']
prop = item['prop']
# apply func
func = item['func']
try:
if bl_item.is_array:
if bl_item.use_array is False:
val = getattr(ref, prop)[bl_item.array]
val2 = [func(bl_item, item, val)]
else:
val = getattr(ref, prop)
val2 = list(func(bl_item, item, val))
else:
val = getattr(ref, prop)
val2 = [func(bl_item, item, val)]
# the value has changed
if val2 != item['val']:
item['val'] = val2
# for multi routes
val3 = val2.copy()
if bl_item.is_multi:
val3.insert(0, item['idx'])
addr = str.encode(item['address'])
osc.send_message(addr, val3)
except:
print("Error while sending, improper OSC route #", item["n"], 'category :', bl_item.category)
break
def __init__(self):
print("Init de MyCartPoleEnv ...............")
self.seed()
self.state = None
self.steps_beyond_done = None
# Le serveur pour recevoir
# #self.server = None
self.osc_server_init()
# Un simple client pour l'envoi
self.client = OSCClient(b'localhost', 3001)
self.state_updated = 0
self.set_spaces()
def build(self):
self.service = None
self.server = server = OSCThreadServer()
server.listen(
address=b'localhost',
port=3002,
default=True,
)
server.bind(b'/message', self.display_message)
server.bind(b'/date', self.date)
self.client = OSCClient(b'localhost', 3000)
self.root = Builder.load_string(KV)
return self.root
def on_start(self, **args):
"stuff"
self.current_screen = 'connect'
self.osc_server = server = OSCThreadServer()
self.osc_server.listen(address='0.0.0.0', port=PORT, default=True)
server.bind(b'/found', callback=self.found)
server.bind(b'/conf', callback=self.conf)
sock = socket(AF_INET, SOCK_DGRAM)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.settimeout(1)
self.scan_client = OSCClient(
address='255.255.255.255',
port=PEER_PORT,
sock=sock,
)
def main_test():
gl.setLogicTicRate(120)
gl.all_obj = get_all_objects()
gl.empty = gl.all_obj["Empty"]
gl.pendulum = gl.all_obj["pendulum"]
gl.cube = gl.all_obj["Cube"]
gl.num = 0
gl.reset = 0
gl.num_reset = 0
gl.action = 0
gl.server = None
gl.send = 0
gl.client = OSCClient(b'localhost', 3003)