class OscSender(object):
"""
Publishes rePatcher data as OSC.
"""
def __init__(self, ipaddr="127.0.0.1", port=12000, verbose=False):
print("Publishing OSC at %s:%d" % (ipaddr, port))
self.client = UDPClient(ipaddr, port)
self.verbose = verbose
def send_knob(self, knob_num, knob_val):
if self.verbose:
print("knob %d: %f" % (knob_num, knob_val))
builder = OscMessageBuilder(address="/repatcher/knob" + str(knob_num))
builder.add_arg(knob_val)
msg = builder.build()
self.client.send(msg)
def send_patch_bay(self, output_num, values):
if self.verbose:
print("bay %d: %s" % (output_num, str(values)))
builder = OscMessageBuilder(address="/repatcher/output" +
str(output_num))
for v in values:
builder.add_arg(v)
msg = builder.build()
self.client.send(msg)
def adjust_balloons():
global balloon_osc
if not balloon_osc:
balloon_osc = UDPClient('0.0.0.0', 5005)
msg = OscMessageBuilder("/adjust")
balloon_osc.send(msg.build())
logging.info("sent adjustment")
def callback(gpio_id):
client = UDPClient(HOST, PORT)
if GPIO.input(gpio_id) == 0:
msg = OscMessageBuilder('/start').build()
GPIO.output(LED, GPIO.HIGH)
else:
msg = OscMessageBuilder('/stop').build()
GPIO.output(LED, GPIO.LOW)
client.send(msg)
def __init__(self, ip: str = "127.0.0.1", port: int = 3333):
UDPClient.__init__(self, ip, port)
TuioDispatcher.__init__(self)
self._ip = ip
self._port = port
self.is_full_update: bool = False
self._periodic_messages: bool = False
self._intervall: int = 1000
class LeapListener(Leap.Listener):
def on_init(self, controller):
self.osc_client = UDPClient('127.0.0.1', 6448)
def on_frame(self, controller):
frame = controller.frame()
positioning_values = leap_utils.get_raw_tip_positioning_data(frame)
msg = osc_utils.build_osc_message(positioning_values)
self.osc_client.send(msg)
time.sleep(0.05)
def affect_candidate(candidate, osc_msg, amount):
global balloon_osc
if not balloon_osc:
balloon_osc = UDPClient('0.0.0.0', 5005)
osc_callback_msg = pickle.dumps(osc_msg)
msg = OscMessageBuilder("/instruction")
msg.add_arg(candidate)
msg.add_arg(amount)
msg.add_arg(osc_callback_msg)
balloon_osc.send(msg.build())
logging.info("sent instruction %s, %d" % (candidate, amount))
def __init__(self,
scsynth_address=('127.0.0.1', 50000),
message_address=('192.168.2.1', 50001),
recipient_addresses=(
('192.168.2.2', 50001),
('192.168.2.3', 50001),
),
nids_start=10000,
nids_end=40000,
pan=0,
personality_assertiveness=0.10,
personality_moodiness=0.02,
personality_confidence=0.05,
personality_irritability=0.10,
**kwargs
):
super().__init__(**kwargs)
self._client = UDPClient(*scsynth_address)
self._message_server = _MessageServer(message_address, self)
self._message_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._recipient_addresses = recipient_addresses
self._moods = [
Mood(self, SimpleBlipperEngine),
Mood(self, SimpleBlipperEngine),
Mood(self, SimpleBlipperEngine),
Mood(self, SimpleBlipperEngine),
Mood(self, FlitterEngine),
Mood(self, FlitterEngine),
Mood(self, FlitterEngine),
Mood(self, BellsEngine),
]
self.running = False
self.parameter_lock = threading.Lock()
self.manager = manager.SynthManager(self._client,
nids_start=nids_start, nids_end=nids_end, pan=pan)
msg = OscMessageBuilder(address='/d_recv') # send synthdefs to scsynth
msg.add_arg(synthdefs.pisynth1)
self._client.send(msg.build())
self.personality_assertiveness = personality_assertiveness
self.personality_moodiness = personality_moodiness
self.personality_confidence = personality_confidence
self.personality_irritability = personality_irritability
def on_init(self, controller):
self.osc_client = UDPClient('127.0.0.1', 6448)
def __init__(self, ip, port, allow_broadcast=False):
self._udp_client = UDPClient(ip, port, allow_broadcast)
class OscUdpClient:
def __init__(self, ip, port, allow_broadcast=False):
self._udp_client = UDPClient(ip, port, allow_broadcast)
def send(self, content):
self._udp_client.send(content)
def __init__(self, ipaddr="127.0.0.1", port=12000, verbose=False):
print("Publishing OSC at %s:%d" % (ipaddr, port))
self.client = UDPClient(ipaddr, port)
self.verbose = verbose
class Brain(threading.Thread):
def __init__(self,
scsynth_address=('127.0.0.1', 50000),
message_address=('192.168.2.1', 50001),
recipient_addresses=(
('192.168.2.2', 50001),
('192.168.2.3', 50001),
),
nids_start=10000,
nids_end=40000,
pan=0,
personality_assertiveness=0.10,
personality_moodiness=0.02,
personality_confidence=0.05,
personality_irritability=0.10,
**kwargs
):
super().__init__(**kwargs)
self._client = UDPClient(*scsynth_address)
self._message_server = _MessageServer(message_address, self)
self._message_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._recipient_addresses = recipient_addresses
self._moods = [
Mood(self, SimpleBlipperEngine),
Mood(self, SimpleBlipperEngine),
Mood(self, SimpleBlipperEngine),
Mood(self, SimpleBlipperEngine),
Mood(self, FlitterEngine),
Mood(self, FlitterEngine),
Mood(self, FlitterEngine),
Mood(self, BellsEngine),
]
self.running = False
self.parameter_lock = threading.Lock()
self.manager = manager.SynthManager(self._client,
nids_start=nids_start, nids_end=nids_end, pan=pan)
msg = OscMessageBuilder(address='/d_recv') # send synthdefs to scsynth
msg.add_arg(synthdefs.pisynth1)
self._client.send(msg.build())
self.personality_assertiveness = personality_assertiveness
self.personality_moodiness = personality_moodiness
self.personality_confidence = personality_confidence
self.personality_irritability = personality_irritability
def _send_message(self, message):
pickled_message = pickle.dumps(message)
for address in self._recipient_addresses:
self._message_client.sendto(pickled_message, address)
def stop(self):
self.running = False
def run(self):
self.manager.start()
self.current_mood = self._moods.pop(0)
self.current_mood.enter()
self._message_server_thread = threading.Thread(
target=self._message_server.serve_forever)
self._message_server_thread.daemon = True
self._message_server_thread.start()
self.running = True
while self.running:
if random.random() < self.personality_moodiness:
new_mood = random.choice(self._moods)
self._moods.remove(new_mood)
self.current_mood.leave()
new_mood.enter()
self._moods.append(self.current_mood)
self.current_mood = new_mood
print("New mood!")
if random.random() < self.personality_irritability:
print("Perturbed")
self.current_mood.engine.perturb(self.personality_irritability)
if random.random() < self.personality_assertiveness:
print("Sending message")
self._send_message(self.current_mood.create_message())
time.sleep(1.0)
self.current_mood.leave()
self.manager.stop()
import time
import itertools
from leap_python3 import Leap
from leap_python3.Leap import Finger
from pythonosc.osc_message_builder import OscMessageBuilder
from pythonosc.udp_client import UDPClient
HAND = 'left'
FINGERS = [Finger.TYPE_THUMB, Finger.TYPE_INDEX, Finger.TYPE_MIDDLE,
Finger.TYPE_RING, Finger.TYPE_PINKY]
client = UDPClient('127.0.0.1', 6448)
def is_expected_hand(hand):
if HAND.lower() == 'left':
return hand.is_left
if HAND.lower() == 'right':
return hand.is_right
raise ValueError('Unrecognized HAND value: {}'.format(HAND))
def populate_hand_dict_from_fingers(hand_dict, fingers):
for finger in fingers:
if is_expected_hand(finger.hand):
hand_dict[finger.type] = finger.tip_position.to_tuple()
def get_raw_tip_positioning_data(frame):
from pythonosc.udp_client import UDPClient
import RPi.GPIO as GPIO
HOST = '127.0.0.1'
PORT = 7777
SWITCH = 2
LED = 3
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED, GPIO.OUT)
GPIO.output(LED, GPIO.LOW)
GPIO.setup(SWITCH, GPIO.IN)
START = OscMessageBuilder('/jack_capture/tm/start').build()
STOP = OscMessageBuilder('/jack_capture/tm/stop').build()
client = UDPClient(HOST, PORT)
def callback(gpio_id):
if GPIO.input(gpio_id) == 0:
GPIO.output(LED, GPIO.HIGH)
client.send(START)
else:
GPIO.output(LED, GPIO.LOW)
client.send(STOP)
def main():
GPIO.add_event_detect(SWITCH, GPIO.BOTH, callback=callback, bouncetime=100)
while True:
time.sleep(1)
