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()
class FaderWidget(Widget):
box_pos = ListProperty([100, 100])
box_size = ListProperty([60, 800])
color = ListProperty([1, 0.5, 0])
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 on_touch_down(self, touch):
if self.collide_point(*touch.pos):
gain = (touch.pos[1] - self.pos[1]) / self.size[1]
self.osc_client.send_message(b'/send/gain',
[self.source, self.idx, gain])
#print([self.idx, self.source, gain])
def on_touch_move(self, touch):
if self.collide_point(*touch.pos):
gain = (touch.pos[1] - self.pos[1]) / self.size[1]
self.osc_client.send_message(b'/send/gain',
[self.source, self.idx, gain])
#print([self.idx, self.source, gain])
def set_source(self, src):
self.source = src
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 __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 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):
"""
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)
class ClientServerApp(App):
def build(self):
self.service = None
# self.start_service()
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 start_service(self):
if platform == 'android':
service = autoclass(SERVICE_NAME)
mActivity = autoclass(u'org.kivy.android.PythonActivity').mActivity
argument = ''
service.start(mActivity, argument)
self.service = service
elif platform in ('linux', 'linux2', 'macos', 'win'):
from runpy import run_path
from threading import Thread
self.service = Thread(
target=run_path,
args=['src/service.py'],
kwargs={'run_name': '__main__'},
daemon=True
)
self.service.start()
else:
raise NotImplementedError(
"service start not implemented on this platform"
)
def stop_service(self):
if self.service:
self.service.stop()
self.service = None
def send(self, *args):
self.client.send_message(b'/ping', [])
def display_message(self, message):
if self.root:
self.root.ids.label.text += '{}\n'.format(message.decode('utf8'))
def date(self, message):
if self.root:
self.root.ids.date.text = message.decode('utf8')
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 __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 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()
class ClientServerApp(App):
def build(self):
self.service = None
# self.start_service()
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 start_service(self):
if platform == 'android':
service = autoclass(SERVICE_NAME)
mActivity = autoclass(u'org.kivy.android.PythonActivity').mActivity
argument = ''
service.start(mActivity, argument)
self.service = service
elif platform in ('linux', 'linux2', 'macos', 'win'):
from runpy import run_path
from threading import Thread
self.service = Thread(target=run_path,
args=['src/service.py'],
kwargs={'run_name': '__main__'},
daemon=True)
self.service.start()
else:
raise NotImplementedError(
"service start not implemented on this platform")
def stop_service(self):
if self.service:
self.service.stop()
self.service = None
def send(self, *args):
self.client.send_message(b'/ping', [])
def display_message(self, message):
if self.root:
self.root.ids.label.text += '{}\n'.format(message.decode('utf8'))
def date(self, message):
if self.root:
self.root.ids.date.text = message.decode('utf8')
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)
class FaderWidget(Widget):
box_pos = ListProperty([100,100])
box_size = ListProperty([80,400])
color = ListProperty([0.3, 0.3, 0.3])
text = StringProperty('SSS')
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 on_touch_down(self, touch):
if self.collide_point(*touch.pos):
gain = ((touch.pos[1]-self.pos[1]) / self.size[1]) * self.max
self.osc_client.send_message(bytes(self.path,encoding='utf8') , [self.index, gain])
#print([self.idx, self.source, gain])
def on_touch_move(self, touch):
if self.collide_point(*touch.pos):
gain = ((touch.pos[1]-self.pos[1]) / self.size[1]) * self.max
self.osc_client.send_message(bytes(self.path,encoding='utf8'), [self.index, gain])
#print([self.idx, self.source, gain])
def set_source(self,src):
self.source=src
def on_receive(self, *values):
src = values[0]
if src==self.index:
gain = values[1]
# print(gain)
y = self.pos[1] + (gain/self.max) * self.size[1] - (0.5*self.ids.bar.ellipse_size[1])
self.ids.bar.ellipse_pos = [self.pos[0] + (self.size[0]/2) - (self.ids.bar.ellipse_size[0]/2), y] #[self.faders[dest].pos[0],y]
def set_index(self, ind):
self.index = ind;
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_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 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)
class OscAppClient:
"""OSC client that talks to the OscAppServer to update the app process."""
def __init__(self, address, port):
self.address = address
self.port = port
self.osc = OSCClient(address, port)
def send_ping(self):
for i in range(10):
self.osc.send_message(b'/ping', [i])
def send_refresh_balance(self):
self.osc.send_message(b'/refresh_balance', [])
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 __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 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 build(self):
self.display_list = [0]*5
self.file = ""
self.sensor = ""
self.service = None
self.server = OSCThreadServer()
self.server.listen( address=b'localhost',
port=3003,
default=True)
self.server.bind(b'/acc', self.on_message)
self.server.bind(b'/file', self.on_file)
self.server.bind(b'/sensor', self.on_sensor)
self.client = OSCClient(b'localhost', 3001)
self.start_service()
return Accelerometer(App)
def __init__(self, serialport, ip, port, networkinterface, listenport):
# set listening ip to receive OSC messages
self.local_ip = ni.ifaddresses(
args.networkinterface)[ni.AF_INET][0]['addr']
# Set OSC client and server
self.server_osc = OSCThreadServer()
self.sock = self.server_osc.listen(address=self.local_ip,
port=listenport,
default=True)
self.client_osc = OSCClient(ip, port)
# Opening T-Stick serial port
self.tstick_serial_port = serial.Serial(serialport, 115200, dsrdtr=1)
# routing OSC signals
self.server_osc.bind(b'/status', self.resend)
def build(self):
self.service = None
# self.start_service()
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
