def run(self):
while True:
if self.interface_conn.poll():
received = comm.recv_msg(self.interface_conn).split(" ")
if received[0] == "exit":
self.exit()
if received[0] == "load":
self.load(received[1])
elif received[0] == "unload":
self.unload(True)
elif received[0] == "start":
self.start()
elif received[0] == "stop":
self.stop()
elif received[0] == "send":
self.send(" ".join(received[1:]))
elif received[0] == "monitoring":
self.monitoring(received[1])
if self.started and self.assignment_conn.poll():
received = comm.recv_msg(self.assignment_conn)
comm.send_msg(self.interface_conn, comm.MsgTypes.STATUS,
received)
if self.monitoring_started and self.monitoring_conn.poll():
received = comm.recv_msg(self.monitoring_conn)
comm.send_msg(self.interface_conn, comm.MsgTypes.STATUS,
received)
def run(self, conn):
self.conn = conn
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
motor_driver = motor.Motor(100, 80)
while True:
self.handleMessages()
# TODO: Vision to recognise red circle for mandatory stop?
# TODO self.vision.imageHandler.loadFrameAsset(cv2.imread('../assets/images/cup5.jpg', cv2.IMREAD_COLOR), True) # load camera asset
# TODO self.vision.do_Vision() # do vision here
# Update motor
left_speed, left_polarity, right_speed, right_polarity = motor_driver.update(
self.left_joy_ypos, self.right_joy_ypos)
motor_values = str(int(
round(left_speed))) + "," + str(left_polarity) + "," + str(
int(round(right_speed))) + "," + str(right_polarity)
comm.send_msg(self.conn, comm.MsgTypes.STATUS, motor_values)
# Write to serial
self.serial.write(bytes(motor_values + ";", "utf-8"))
time.sleep(0.1)
def handleMessages(self):
if self.conn.poll():
received = comm.recv_msg(self.conn)
received_split = received.split(" ")
if received_split[0] == "controller":
controller_values = received_split[1].split("-")
print(received_split)
print(controller_values)
# Grab positions
self.left_joy_xpos = int(controller_values[0].split(":")[1])
self.right_joy_xpos = int(controller_values[1].split(":")[1])
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Received")
if received == "Stop":
self.is_stopped = True
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Stopped")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
while self.is_stopped:
received = comm.recv_msg(self.conn)
if received == "Start":
self.is_stopped = False
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
def start(self):
if self.assignment is None:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"Please load an assignment first.")
elif self.started:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"The assignment has already started.")
return
elif self.assignment_conn is not None:
comm.send_msg(self.assignment_conn, comm.MsgTypes.COMMAND, "Start")
while comm.recv_msg(self.assignment_conn,
comm.MsgTypes.REPLY) != "Started":
continue
self.started = True
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
self.assignment.name() + " started.")
else:
parent_conn, child_conn = Pipe()
self.assignment_conn = parent_conn
self.assignment_proc = Process(target=self.assignment.start,
args=(child_conn, ))
self.assignment_proc.start()
while comm.recv_msg(self.assignment_conn,
comm.MsgTypes.REPLY) != "Started":
continue
self.started = True
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
self.assignment.name() + " started.")
def run(self, conn):
global time_to_next_beat
self.conn = conn
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
# Initiate neopixel led strip
self.strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
self.strip.begin()
# Initiate pyaudio and set settings
self.pa = pyaudio.PyAudio()
self.lib = pyaudio.PyAudio()
self.stream = self.pa.open(format=FORMAT,
channels=CHANNELS,
input_device_index=1,
rate=RATE,
input=True,
frames_per_buffer=CHUNK
)
self.stream2 = self.lib.open(format=pyaudio.paFloat32,
channels=CHANNELS,
rate=RATE,
input_device_index=1,
input=True,
output=False,
frames_per_buffer=RATE * 10,
stream_callback=callback)
# start the stream (4)
self.stream.start_stream()
self.stream2.start_stream()
while True:
#self.handleMessages()
try:
capture_time = time.time()
# print("analyzing beat")
audio_data = np.fromstring(self.stream.read(CHUNK, exception_on_overflow=False), dtype=np.int16)
parse_audio(audio_data, self.strip)
capture_time_2 = time.time()
time_to_next_beat -= capture_time_2 - capture_time
# print("time to next beat: ")
# print(time_to_next_beat)
if time_to_next_beat < 0.05 and analyzing != True:
print("beat!")
time_to_next_beat = original_time_to_next_beat
elif analyzing:
{}
print("analyzing beat")
except IOError as e:
print("(%d) Error recording: %s" % e)
def exit(self):
if self.started:
self.stop()
if self.monitoring_conn is not None:
self.monitoring("unload")
if self.assignment is not None:
self.unload(True)
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY, "exit")
sys.exit()
def load(self, assignment):
if self.assignment is not None:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"An assignment has already been loaded.")
return
self.assignment = importlib.import_module("assignments." + assignment +
"." + assignment)
self.assignment.load()
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
assignment + " loaded.")
def run(self, conn):
self.conn = conn
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
# Monitor time at start of dance
start_time = time.time()
# Starting led values
g = 0
r = 255
b = 0
while True:
self.handleMessages()
current_time = time.time()
if current_time - start_time < 5:
print("backward")
ls, lp, rs, rp = self.motor.move_backward(250, True)
elif current_time - start_time < 10:
print("forward")
ls, lp, rs, rp = self.motor.move_forward(100, True)
elif current_time - start_time < 15:
print("forward right")
ls, lp, rs, rp = self.motor.rotate_around_axis(
100, MotorDirections.RIGHT, autoTransform=True)
elif current_time - start_time < 20:
print("forward left")
ls, lp, rs, rp = self.motor.rotate_around_axis(
100, MotorDirections.LEFT, autoTransform=True)
else:
self.motor.update(0, 0)
if current_time - start_time < 25:
break
else:
continue
vals = self.motor.get_motor_values_string(ls, lp, rs, rp)
# if vals is not motor_values:
# print(vals)
motor_values = vals
comm.send_msg(self.conn, comm.MsgTypes.STATUS, motor_values)
# Updates the motor values to Arduino
self.serial.write(bytes(motor_values + ";", "utf-8"))
update_led(self.strip, g, r, b)
time.sleep(0.1)
def run(self):
while True:
self.handleMessages()
sending = ""
for id in range(1, 3):
try:
temp = str(10) # str(self.servos.readTemperature(id))
pos = str(20) # str(self.servos.readPosition(id))
#print("Position: " + pos + ", Temperature: " + temp)
sending += str(id) + ":" + temp + ","
sending += str(id) + ":" + pos
sending += "-"
except self.servos.timeoutError:
comm.send_msg(self.conn, comm.MsgTypes.ERROR,
"Servo not found.")
comm.send_msg(self.conn, comm.MsgTypes.STATUS, sending[:-1])
sleep(0.7)
def run(self, conn):
self.conn = conn
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
while True:
self.handleMessages()
if self.moving:
try:
self.servos.move(1, 100)
self.servos.move(2, 100)
sleep(2)
self.servos.move(1, 1000)
self.servos.move(2, 1000)
sleep(2)
except self.servos.timeoutError:
comm.send_msg(self.conn, comm.MsgTypes.ERROR,
"Servo not found.")
def handleMessages(self):
if self.conn.poll():
received = comm.recv_msg(self.conn)
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Received")
if received == "Stop":
self.is_stopped = True
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Stopped")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
while self.is_stopped:
received = comm.recv_msg(self.conn)
if received == "Start":
self.is_stopped = False
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
def run(self, conn):
self.conn = conn
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
motor_driver = motor.Motor(250, 100)
while True:
self.handleMessages()
# Update motor
left_speed, left_polarity, right_speed, right_polarity = motor_driver.update(
self.left_joy_ypos, self.right_joy_ypos)
motor_values = str(int(
round(left_speed))) + "," + str(left_polarity) + "," + str(
int(round(right_speed))) + "," + str(right_polarity)
comm.send_msg(self.conn, comm.MsgTypes.STATUS, motor_values)
# Write to serial
self.serial.write(bytes(motor_values + ";", "utf-8"))
time.sleep(0.1)
def send(self, msg):
if self.started:
comm.send_msg(self.assignment_conn, comm.MsgTypes.COMMAND, msg)
while comm.recv_msg(self.assignment_conn,
comm.MsgTypes.REPLY) != "Received":
continue
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"Message sent.")
else:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"No assignment is currently running.")
def stop(self):
if self.started:
comm.send_msg(self.assignment_conn, comm.MsgTypes.COMMAND, "Stop")
self.started = False
while comm.recv_msg(self.assignment_conn,
comm.MsgTypes.REPLY) != "Stopped":
continue
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
self.assignment.name() + " stopped.")
return
else:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"No assignment is currently running.")
def unload(self, wait):
if self.assignment is None:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"No assignment has been loaded.")
return
else:
if self.assignment_conn is None:
self.assignment.unload()
else:
comm.send_msg(self.assignment_conn, comm.MsgTypes.COMMAND,
"Unload")
while wait and comm.recv_msg(
self.assignment_conn,
comm.MsgTypes.REPLY) != "Unloaded":
continue
assignment = self.assignment
self.assignment = None
self.started = False
self.assignment_conn = None
self.assignment_proc = None
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"Unloaded " + assignment.name() + ".")
return
def run(self, conn):
self.conn = conn
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
while True:
self.handleMessages()
def monitoring(self, msg):
if self.monitoring_conn is None:
comm.send_msg(
self.interface_conn, comm.MsgTypes.REPLY,
"Monitoring has been unloaded, please restart the application."
)
else:
if msg == "start":
if not self.monitoring_started:
comm.send_msg(self.monitoring_conn, comm.MsgTypes.COMMAND,
"Start")
comm.send_msg(
self.interface_conn, comm.MsgTypes.REPLY,
comm.recv_msg(self.monitoring_conn,
comm.MsgTypes.REPLY))
self.monitoring_started = True
else:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"Monitoring is already running.")
elif msg == "stop":
if self.monitoring_started:
comm.send_msg(self.monitoring_conn, comm.MsgTypes.COMMAND,
"Stop")
comm.send_msg(
self.interface_conn, comm.MsgTypes.REPLY,
comm.recv_msg(self.monitoring_conn,
comm.MsgTypes.REPLY))
self.monitoring_started = False
else:
comm.send_msg(self.interface_conn, comm.MsgTypes.REPLY,
"Monitoring has already been stopped.")
elif msg == "unload":
comm.send_msg(self.monitoring_conn, comm.MsgTypes.COMMAND,
"Unload")
comm.send_msg(
self.interface_conn, comm.MsgTypes.REPLY,
comm.recv_msg(self.monitoring_conn, comm.MsgTypes.REPLY))
self.monitoring_started = False
def handleMessages(self):
if self.conn.poll():
received = comm.recv_msg(self.conn)
received_split = received.split(" ")
if received_split[0] == "controller":
controller_values = received_split[1].split("-")
print(received_split)
print(controller_values)
# Grab positions
self.right_joy_ypos = int(
controller_values[0].split(":")[1].split(",")[0])
self.left_joy_ypos = int(
controller_values[1].split(":")[1].split(",")[0])
self.right_joy_xpos = int(
controller_values[0].split(":")[1].split(",")[1])
self.left_joy_xpos = int(
controller_values[1].split(":")[1].split(",")[1])
# Update motor
left_speed, left_polarity, right_speed, right_polarity = self.motor_driver.update(
self.left_joy_ypos, self.right_joy_ypos)
motor_values = str(int(
round(left_speed))) + "," + str(left_polarity) + "," + str(
int(round(right_speed))) + "," + str(right_polarity)
comm.send_msg(self.conn, comm.MsgTypes.STATUS, motor_values)
# Write to serial
self.serial.write(bytes(motor_values + ";", "utf-8"))
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Received")
if received == "Stop":
self.is_stopped = True
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Stopped")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
while self.is_stopped:
received = comm.recv_msg(self.conn)
if received == "Start":
self.is_stopped = False
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
def handleMessages(self):
if self.conn.poll():
received = comm.recv_msg(self.conn)
received_split = received.split(" ")
if received_split[0] == "controller":
controller_values = ",".join(received_split[1:]) + ";"
print(received_split)
self.serial.write(bytes(controller_values, "utf-8"))
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Received")
if received == "Stop":
self.is_stopped = True
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Stopped")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
elif received == "turn":
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Received")
self.moving = True
while self.is_stopped:
received = comm.recv_msg(self.conn)
if received == "Start":
self.is_stopped = False
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Started")
elif received == "Unload":
self.unload()
comm.send_msg(self.conn, comm.MsgTypes.REPLY, "Unloaded")
sys.exit()
def send(self, command):
comm.send_msg(self.conn, comm.MsgTypes.COMMAND, command)
print(comm.recv_msg(self.conn, comm.MsgTypes.REPLY) + "\n")
def send(self, command):
comm.send_msg(self.conn, comm.MsgTypes.COMMAND, command)
