From 39455da4f08c7e4263cc061c818126ba7680c975 Mon Sep 17 00:00:00 2001 From: cd6 Date: Thu, 14 Feb 2019 15:03:47 +0000 Subject: [PATCH 01/18] Possibly ready to merge --- robot_software/followLineServer.py | 120 +++++++++++++++-------------- 1 file changed, 61 insertions(+), 59 deletions(-) diff --git a/robot_software/followLineServer.py b/robot_software/followLineServer.py index e8a0f03..38ff41f 100644 --- a/robot_software/followLineServer.py +++ b/robot_software/followLineServer.py @@ -3,6 +3,8 @@ import logging from time import sleep, time from threading import Thread +import detectMarking +import control class FollowLine: @@ -13,7 +15,8 @@ class FollowLine: KI = 0 # integral gain lowest DT = 50 # milliseconds - represents change in time since last sensor reading/ - MARKING_NUMBER = 1 # number of consecutive colour readings to detect marking + MARKING_NUMBER = 2 # number of consecutive colour readings to detect marking + MARKING_INTERVAL = 1 # time between marking checks in seconds # Constructor def __init__(self): @@ -23,30 +26,34 @@ def __init__(self): # colour sensors self.csfl = ev3.ColorSensor('in1') # colour sensor front left self.csfr = ev3.ColorSensor('in2') # colour sensor front right - self.csb = ev3.ColorSensor('in3') # colour sensor back + self.csbl = ev3.ColorSensor('in3') # colour sensor back left + self.csbr = ev3.ColorSensor('in4') # colour sensor back right assert self.csfl.connected assert self.csfr.connected - assert self.csb.connected + assert self.csbl.connected + assert self.csbr.connected self.csfl.mode = 'COL-REFLECT' # measure light intensity self.csfr.mode = 'COL-REFLECT' # measure light intensity - self.csb.mode = 'COL-COLOR' # measure colour - + self.csbl.mode = 'COL-COLOR' # measure colour + self.csbr.mode = 'COL-COLOR' # motors self.lm = ev3.LargeMotor('outA') # left motor self.rm = ev3.LargeMotor('outC') # right motor self.cm = ev3.LargeMotor('outD') # centre motor assert self.lm.connected assert self.rm.connected + assert self.cm.connected self.consecutive_colours = 0 # counter for consecutive colour readings + self.number_of_markers = 0 # at which marker it should stop self.runner = None + self.reverse = False def detect_marking(self): - colour = self.csb.value() - print(colour) + colour = self.csbl.value() if colour == 3 or colour == 2: # 3 = green 2 = blue self.consecutive_colours += 1 - print("CONSECUTIVE COLOURS: ", self.consecutive_colours) + #print("CONSECUTIVE COLOURS: ", self.consecutive_colours) if self.consecutive_colours > self.MARKING_NUMBER: return colour else: @@ -63,48 +70,49 @@ def on_line(sensor_value, position): logging.error("onLine: wrong position value for sensor") return False - def correct_trajectory(self, csfl, csfr, lm, rm, number_of_markers): + # limit motor speed to safe values: [-1000, 1000] deg/sec + def limit_speed(self, speed): + if speed > 1000: + return 1000 + if speed < -1000: + return -1000 + return speed + + def correct_trajectory(self, lm, rm, number_of_markers): integral = 0 previous_error = 0 marker_counter = 0 start_time = time() - interval_between_colors = 1 # time between marker checks in seconds while not self.shut_down: - lval = csfl.value() - rval = csfr.value() - error = lval - rval - 10 - logging.info("PID error: ", error) - integral += (error * self.DT) - derivative = (error - previous_error) / self.DT - - # u zero: on target, drive forward - # u positive: too bright, turn right - # u negative: too dark, turn left - # u is torque (See IVR lecture on Control) - u = (self.KP * error) + (self.KI * integral) + (self.KD * derivative) - - # limit u to safe values: [-1000, 1000] deg/sec - # limit u to safe values: [-1000, 1000] deg/sec - if self.MOTOR_SPEED + abs(u) > 1000: # reduce u if speed and torque are too high - if u >= 0: - u = 1000 - self.MOTOR_SPEED - else: - u = self.MOTOR_SPEED - 1000 + if self.reverse: + lval = self.csbr.value() # back right becomes front left + rval = self.csbl.value() + else: + lval = self.csfl.value() + rval = self.csfr.value() + + u, integral, previous_error = control.calculate_torque\ + (self.csfl.value(), self.csfr.value(), self.DT, integral, previous_error) + speed_left = self.limit_speed(self.MOTOR_SPEED + u) + speed_right = self.limit_speed(self.MOTOR_SPEED - u) + # run motors - lm.run_timed(time_sp=self.DT, speed_sp=-(self.MOTOR_SPEED + u)) - rm.run_timed(time_sp=self.DT, speed_sp=-(self.MOTOR_SPEED - u)) + if self.reverse: + lm.run_timed(time_sp=self.DT, speed_sp=self.MOTOR_SPEED - u) + rm.run_timed(time_sp=self.DT, speed_sp=self.MOTOR_SPEED + u) + else: + lm.run_timed(time_sp=self.DT, speed_sp=-(self.MOTOR_SPEED + u)) + rm.run_timed(time_sp=self.DT, speed_sp=-(self.MOTOR_SPEED - u)) sleep(self.DT / 1000) - #print("u {}".format(u)) - #print("lm {}\n".format(lm.speed_sp)) - #print("rm {}".format(rm.speed_sp)) - #print("PID:", lval, rval) - - previous_error = error + # print("u {}".format(u)) + # print("lm {}\n".format(lm.speed_sp)) + # print("rm {}".format(rm.speed_sp)) + # print("PID:", lval, rval) # Check markers - if time() - start_time > interval_between_colors: + if time() - start_time > self.MARKING_INTERVAL: # returns 3 if green, 2 if blue marker_colour = self.detect_marking() if marker_colour == 3: @@ -117,36 +125,30 @@ def correct_trajectory(self, csfl, csfr, lm, rm, number_of_markers): elif marker_colour == 2: # stop on blue marker self.stop() - + def move_sideways(self, cm): while not self.shut_down: cm.run_timed(time_sp=self.DT, speed_sp=300) - def run(self, number_of_markers): - self.correct_trajectory(self.csfl, self.csfr, self.lm, self.rm, number_of_markers) - # while not self.shut_down: - # print(self.csb.value()) + def start(self, number_of_markers): + self.shut_down = False + self.number_of_markers = number_of_markers + if self.number_of_markers == 0: + ev3.Sound.speak("0 number of markers specified").wait() + self.stop() + else: + self.runner = Thread(target=self.run, name='move') + self.runner.start() + + def run(self): + self.correct_trajectory() self.stop() def stop(self): self.shut_down = True self.rm.stop() self.lm.stop() - ev3.Sound.speak("yeet").wait() - - def start(self, number_of_markers): - self.consecutive_colours = 0 - if (self.shut_down): - self.shut_down = False - self.runner = Thread(target=self.run, name='move', args=(number_of_markers,)) - self.runner.start() - else: - self.shut_down = True - self.runner = Thread(target=self.run, name='move', args=(number_of_markers,)) - self.shut_down = False - self.runner.start() - - + ev3.Sound.speak("bruh").wait() # Main function From 110df638915852d1eb53350ecc8ba4168ca614f3 Mon Sep 17 00:00:00 2001 From: cd6 Date: Mon, 25 Mar 2019 21:22:35 +0000 Subject: [PATCH 02/18] Half speed for back wheels --- robot_software/followLine.py | 249 +++++++++++++++++++++++++++++++++++ robot_software/followPath.py | 61 +++++++++ 2 files changed, 310 insertions(+) create mode 100644 robot_software/followLine.py create mode 100644 robot_software/followPath.py diff --git a/robot_software/followLine.py b/robot_software/followLine.py new file mode 100644 index 0000000..13dba56 --- /dev/null +++ b/robot_software/followLine.py @@ -0,0 +1,249 @@ +#! /usr/bin/env python3 +import ev3dev.ev3 as ev3 +from time import sleep, time +import control + + +class FollowLine: + # From https://gist.github.com/CS2098/ecb3a078ed502c6a7d6e8d17dc095b48 + MOTOR_SPEED = 700 + DT = 50 # milliseconds - represents change in time since last sensor reading/ + + + MARKING_NUMBER = 1 # number of consecutive colour readings to detect marking + MARKING_INTERVAL = 1 # time between marking checks in seconds + reverse = False + + BLACK = 1 # black reading from colour sensor in COL-COLOR mode + BLUE = 2 # blue reading from colour sensor in COL-COLOR mode + GREEN = 3 # green reading from colour sensor in COL-COLOR mode + + CORRECTION_TIME = 100 # time in millisecond Bob moves away from blue line to correct sideways movement + SIDEWAYS_SPEED = 700 # how fast Bob moves when moving sideways + + # Constructor + def __init__(self): + self.btn = ev3.Button() + self.shut_down = False + + # colour sensors + self.csfl = ev3.ColorSensor('in1') # colour sensor front left + self.csfr = ev3.ColorSensor('in2') # colour sensor front right + self.csbl = ev3.ColorSensor('in3') # colour sensor back left + self.csbr = ev3.ColorSensor('in4') # colour sensor back right + assert self.csfl.connected + assert self.csfr.connected + assert self.csbl.connected + assert self.csbr.connected + + # motors + self.lm = ev3.LargeMotor('outA') # left motor + self.rm = ev3.LargeMotor('outC') # right motor + self.cm = ev3.LargeMotor('outD') # centre motor + assert self.lm.connected + assert self.rm.connected + assert self.cm.connected + + self.consecutive_colours = 0 # counter for consecutive colour readings + self.ignore_blue = False # when switching from sideways to forwards + self.ignore_green = False # when switching from forwards to sideways + # self.number_of_markers = 0 # at which marker it should stop + + self.start_time = 0 # when robot starts doing a command + self.marker_counter = 0 # how many markers have been passed in current command + + self.reverse = 1 # 1 if Bob is reversing, -1 if not + + def detect_marking(self, colour_left, colour_right, desired_colour): + # print(colour_left, colour_right) + if colour_right == desired_colour and colour_left == desired_colour: + self.consecutive_colours += 1 + print("CONSECUTIVE COLOURS: ", self.consecutive_colours) + if self.consecutive_colours >= self.MARKING_NUMBER: + self.consecutive_colours = 0 + return True + else: + self.consecutive_colours = 0 + return False + + # limit motor speed to safe values: [-1000, 1000] deg/sec + @staticmethod + def limit_speed(speed): + if speed > 1000: + return 1000 + if speed < -1000: + return -1000 + return speed + + # adjust modes of colour sensors depending on the direction of Bob + # COL-REFLECT: measure light intensity + # COL-COLOR: measure colour + def set_cs_modes(self, direction): + if direction == 'forward': + self.csfl.mode = 'COL-REFLECT' + self.csfr.mode = 'COL-REFLECT' + self.csbl.mode = 'COL-COLOR' + self.csbr.mode = 'COL-COLOR' + elif direction == 'backward': + self.csfl.mode = 'COL-COLOR' + self.csfr.mode = 'COL-COLOR' + self.csbl.mode = 'COL-REFLECT' + self.csbr.mode = 'COL-REFLECT' + elif direction == 'left' or direction == 'right': + self.csfl.mode = 'COL-COLOR' + self.csfr.mode = 'COL-COLOR' + self.csbl.mode = 'COL-COLOR' + self.csbr.mode = 'COL-COLOR' + else: + return False # wrong direction command sent + return True + + # increase marker counter when seeing desired colour + def count_markings(self, cs_left, cs_right, desired_colour): + # Wait before checking for colour again + if time() - self.start_time > self.MARKING_INTERVAL: + # marking of desired colour detected + if self.detect_marking(cs_left.value(), cs_right.value(), desired_colour): + self.marker_counter += 1 + ev3.Sound.beep() + self.start_time = time() + return + + # follows a line and corrects trajectory continually + # uses light sensors to follow line and colour sensors to detect markings + def correct_trajectory(self, light_left, light_right, motor_left, motor_right, pid_controller): + # most likely off line, may need to recalibrate numbers later + # time_off_line = self.get_back_on_line(light_left, light_right, time_off_line) + + # Calculate torque using PID control + torque = pid_controller.calculate_torque(light_left.value(), light_right.value()) + # Set the speed of the motors + speed_left = self.limit_speed(self.MOTOR_SPEED + torque) + speed_right = self.limit_speed(self.MOTOR_SPEED - torque) + print('Speed left:', speed_left) + print('Speed right:', speed_right) + + # run motors + motor_left.run_timed(time_sp=self.DT, speed_sp=speed_left * self.reverse) + motor_right.run_timed(time_sp=self.DT, speed_sp=speed_right * self.reverse) + sleep(self.DT / 1000) + + return + + # move forward + def run_forward(self, distance, desired_colour): + self.reverse = -1 + self.start_time = time() + self.marker_counter = 0 + pid_controller = control.Control(self.DT) + + while not self.shut_down: + self.correct_trajectory(self.csfl, self.csfr, self.lm, self.rm, pid_controller) + self.count_markings(self.csbl, self.csbr, desired_colour) + if self.marker_counter >= distance: + return + + # move backward + def run_backward(self, distance, desired_colour): + self.reverse = 1 + self.start_time = time() + self.marker_counter = 0 + pid_controller = control.Control(self.DT) + + while not self.shut_down: + self.correct_trajectory(self.csbr, self.csbl, self.rm, self.lm, pid_controller) + self.count_markings(self.csfr, self.csfl, desired_colour) + if self.marker_counter >= distance: + return + + # move sideways between two blue lines + def run_sideways(self, distance, direction, last_direction): + self.start_time = time() + self.marker_counter = 0 + + while not self.shut_down: + # if a colour sensor is on a blue line, correct position to be between them again + if direction == 'left': + right_speed = self.SIDEWAYS_SPEED/2.0 + left_speed = self.SIDEWAYS_SPEED + else: + right_speed = self.SIDEWAYS_SPEED + left_speed = self.SIDEWAYS_SPEED / 2.0 + if self.detect_marking(self.csbl.value(), self.csbr.value(), self.BLUE): + # back sensors on blue line, so move forward for some time + self.lm.run_timed(time_sp=self.CORRECTION_TIME, speed_sp=-left_speed) + self.rm.run_timed(time_sp=self.CORRECTION_TIME, speed_sp=-right_speed) + sleep(self.CORRECTION_TIME / 1000) + if self.detect_marking(self.csfl.value(), self.csfr.value(), self.BLUE): + # front sensors on blue line, so move backward for some time + + self.lm.run_timed(time_sp=self.CORRECTION_TIME, speed_sp=left_speed) + self.rm.run_timed(time_sp=self.CORRECTION_TIME, speed_sp=right_speed) + sleep(self.CORRECTION_TIME / 1000) + + # colour sensor for marking detection needs to be at front or back dependng on the last direction + if last_direction == 'forward': + cs_left = self.csbr + cs_right = self.csbl + else: + # if last direction is backward, left, or right + cs_left = self.csfr + cs_right = self.csfl + + # move sideways for a bit while counting black markings + if direction == 'left': + self.cm.run_timed(time_sp=self.DT, speed_sp=self.SIDEWAYS_SPEED) + sleep(self.DT / 1000) + self.count_markings(cs_left, cs_left, self.BLACK) + if direction == 'right': + self.cm.run_timed(time_sp=self.DT, speed_sp=-self.SIDEWAYS_SPEED) + sleep(self.DT / 1000) + self.count_markings(cs_right, cs_right, self.BLACK) + + if self.marker_counter >= distance: + return + + # when line is lost oscillate side to side until it is found + def get_back_on_line(self, lval, rval, time_off_line): + if lval > 90 and rval > 70: + if time_off_line == 0: + time_off_line = time() + # if off line for more than a second move side-to-side until line is found + # print(time() - time_off_line) + if time() - time_off_line > 0.5: + correction_speed = 200 + correction_time = 100 + # can change thresholds + while lval > 70 and rval > 50: + self.cm.run_timed(time_sp=correction_time, speed_sp=correction_speed) + correction_speed *= -1 + # increase the time to move in one direction to increased the search radius + correction_time += 100 + sleep(correction_time / 1000) # milliseconds to seconds + lval = self.csfl.value() + rval = self.csfr.value() + time_off_line = 0 + else: + time_off_line = 0 + return time_off_line + + def move_toward_shelf(self): + self.cm.run_timed(time_sp=self.DT*50, speed_sp=-self.SIDEWAYS_SPEED) + sleep(self.DT*50.0/1000.0) + return + + def move_away_from_shelf(self): + + self.cm.run_timed(time_sp=1000, speed_sp=self.SIDEWAYS_SPEED) + sleep(1) + # if self.detect_marking(self.csbl.value(), self.csbl.value(), self.BLACK): + return + + def stop_shelf_movement(self): + self.cm.stop(stop_action='hold') + + def stop(self): + self.shut_down = True + self.rm.stop() + self.lm.stop() + ev3.Sound.speak("whack").wait() diff --git a/robot_software/followPath.py b/robot_software/followPath.py new file mode 100644 index 0000000..a87f9d5 --- /dev/null +++ b/robot_software/followPath.py @@ -0,0 +1,61 @@ +#! /usr/bin/env python3 +import ev3dev.ev3 as ev3 +from followLine import FollowLine +from threading import Thread + + +class FollowPath: + # Follow a path given by the server + BLACK = 1 # black reading from colour sensor in COL-COLOR mode + BLUE = 2 # blue reading from colour sensor in COL-COLOR mode + GREEN = 3 # green reading from colour sensor in COL-COLOR mode + + # Constructor + def __init__(self): + self.shut_down = False + self.runner = None + self.last_direction = '' # saves previous direction Bob moved in + + def go(self, path): + print(path) + line_follower = FollowLine() + for direction, distance in path: + if line_follower.set_cs_modes(direction): + # modes set successfully + # direction move in forwards axis or side axis + if direction == 'forward': + line_follower.run_forward(distance, self.GREEN) + elif direction == 'backward': + line_follower.run_backward(distance, self.GREEN) + elif direction == 'left' or direction == 'right': + if self.last_direction == 'forward': # Bob has to move forward to blue line + line_follower.set_cs_modes('forward') + line_follower.run_forward(1, self.BLUE) + if self.last_direction == 'backward': # Bob has to move backward to blue line + line_follower.set_cs_modes('backward') + line_follower.run_backward(1, self.BLUE) + line_follower.set_cs_modes(direction) + line_follower.run_sideways(distance, direction, self.last_direction) + self.last_direction = direction + else: + # not a valid direction for colour sensors + if direction == 'G': + ev3.Sound.speak("Scoopdidoop").wait() + else: + ev3.Sound.speak("Wrong command given. What does", direction, "mean?").wait() + line_follower.stop() + + + # TODO: possibly move start and stop to FollowPath or move correct trajectory to a separate file instead + def start(self, path): + self.shut_down = False + print(path) + if len(path) == 0: + ev3.Sound.speak("No instructions given").wait() + else: + self.go(path) + +if __name__ == "__main__": + path_follower = FollowPath() + current_path = [('right', 1), ('forward', 1)] + path_follower.start(current_path) From 7d3f4aa1b6f6f4457f1fa5167cd455e568861add Mon Sep 17 00:00:00 2001 From: cd6 Date: Wed, 27 Mar 2019 15:02:53 +0000 Subject: [PATCH 03/18] Code for moving motors on pi but not working --- robot_software/lift.py | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 robot_software/lift.py diff --git a/robot_software/lift.py b/robot_software/lift.py new file mode 100644 index 0000000..9bb8369 --- /dev/null +++ b/robot_software/lift.py @@ -0,0 +1,41 @@ +#! /usr/bin/env python3 +import time +from iotools import IOTools +import sys + +class Lift: + MC_SPEED = 100 + LIFT_TIME = 5 + # use ports 2 and 3 + mc_id_a = 2 + mc_id_b = 3 + + def __init__(self, onRobot): + IO = IOTools(True) + self.mc = IO.motor_control + self.mc.stopMotors() + + def lift(self, direction): + print('lifting {}'.format(direction)) + if direction == 'up': + self.mc.setMotor(self.mc_id_a, -self.MC_SPEED) + self.mc.setMotor(self.mc_id_b, -self.MC_SPEED) + time.sleep(self.LIFT_TIME) + self.mc.stopMotors() + time.sleep(1) + elif direction == 'down': + self.mc.setMotor(self.mc_id_a, self.MC_SPEED) + self.mc.setMotor(self.mc_id_b, self.MC_SPEED) + time.sleep(self.LIFT_TIME/2.0) + self.mc.stopMotors() + time.sleep(1) + + +if __name__ == "__main__": + onRobot = bool(sys.argv.count('-rss')) + lifter = Lift(onRobot) + lifter.lift('up') + time.sleep(lifter.LIFT_TIME+1) + lifter.lift('down') + + From af49bc40b6d9c4f5a8eda5029bb2e5b5dd917d7f Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Thu, 28 Mar 2019 12:59:14 +0000 Subject: [PATCH 04/18] Added lifting to rasp pi scripts --- robot_software/bobTranslation.pyc | Bin 0 -> 564 bytes robot_software/ev3_listener.py | 30 +++++++++++++++------------ robot_software/followPath.pyc | Bin 0 -> 2065 bytes robot_software/rasppi_coordinator.py | 13 +++++++----- robot_software/rasppi_listener.py | 13 ++++++++---- 5 files changed, 34 insertions(+), 22 deletions(-) create mode 100644 robot_software/bobTranslation.pyc create mode 100644 robot_software/followPath.pyc diff --git a/robot_software/bobTranslation.pyc b/robot_software/bobTranslation.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef4239b34718642ccbb7b3469cc99b76cc783cbf GIT binary patch literal 564 zcmb_YOHRWu5S^r@KUx-SP&h$Wr0fww0tpr7M3&65Mxn9}hm=Zfl|XG;>`}&RBPthusC9|xceoD9Lh1PegEF^_2jx7W?fE{@C>lqH6#Eo;>UWs!5~N<-!v9V(pu0~R NBcE$^8b 1023) s= socket.socket(socket.AF_INET, socket.SOCK_STREAM) @@ -33,16 +35,18 @@ #MoveIn() if str_instruction == 'move_in': - - line_follower = FollowLine() - line_follower.move_toward_shelf() + if sys.argv[0] == 1: + line_follower = FollowLine() + line_follower.move_toward_shelf() elif str_instruction == 'move_out': print('inb') - line_follower = FollowLine() - line_follower.move_away_from_shelf() + if sys.argv[0] == 1: + line_follower = FollowLine() + line_follower.move_away_from_shelf() elif str_instruction == 'stop_shelf': - line_follower = FollowLine() - line_follower.stop() + if sys.argv[0] == 1: + line_follower = FollowLine() + line_follower.stop() #stop moving in diff --git a/robot_software/followPath.pyc b/robot_software/followPath.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b8fcc8cb1ad001b538ca625982c20b0f861a371 GIT binary patch literal 2065 zcmcIl+m0JW5Url^c;n438ztl>Bw~2-16q?H9*_{1y&_myXqK?T3L4GMwC%RXJU7nqp78JO&4+*d{vxB*FU0#RG}8;G!3aAlH%!*iUv(1>PP4|C~s08(XT{TL_hV>QFPkbfGP72e!Y%@ z>Ng>d%AzP2C&ub}tckH7MwL$U*QUQu{b-Ghx9*|2Pa!m|0QCd*0W^6)efSUAIlur5 zE7x%P8x)^**ok2~CSbv5&A7{rNA}U&69`YVBueDStiZgI5qKb+h!^)fpKDN7i?qr+ z5$|Gglon3=7Bn}S`y?+H);G}Wl~#KOP|dB?m463nkvgm}mCn2=Z5;?+>vS>b;7uaj z0krOOrz_VTR65s{$tLINBG#WvS@+8wBHu=rW*RepDDZ__?QE1aukFWrLOh zb7L9Om7?lH1qFec1XRT`70?oEz#l9KNWIKtMIbA@tibgDtO$99`;84Fk!%k;VFr1v z&HuUbj4nJYh5;f(;;SjXtfY{4)b9Se-Vv;KAesN&@!E03=!U=x#co7bAUz;4BO=0K zUfvgkO+k395Z`f&#+#IHu#fR=jvFt!nYbkzT5RcN`i$Xk$zov_*GDf7AthtyX*OYw z35^Op@WQjo3`btb?3upD{x;-kR+h8ef3p# zo#R|jb!xxtY(tCD$ZtV_z)9wkX_;#$cEQzw$^usgu<-4HD&qNd z0ZFuS<9uo}{Wj`{Yh+m7gLEH3kcv<__tZ|fr5-45kJOIZ#=DlHVeWCzuIr2UbK6IA z-$JbKnYz$WF2d&($v-26Y}^pq3v0)qHoV$x;Ul#F7e literal 0 HcmV?d00001 diff --git a/robot_software/rasppi_coordinator.py b/robot_software/rasppi_coordinator.py index 074ae5a..092f27b 100644 --- a/robot_software/rasppi_coordinator.py +++ b/robot_software/rasppi_coordinator.py @@ -51,8 +51,11 @@ def listen_to_server(self,username): headers={'username':'merchant_01'} url = 'http://{}:{}/api/warehouse/5c755f58bfcf4c592bfd00a6/orders/{}'.format(self.server_info['ip'],self.server_info['port'],path['job']['id']) update = requests.post(url,headers=headers,json={'status':'READY_TO_COLLECT'}) - print(update.text) - print('done - notified') + while not(json.loads(update.text)['success']): + + time.sleep(5) + update = requests.post(url,headers=headers,json={'status':'READY_TO_COLLECT'}) + print('notified') self.retry_timeout = 1 sleep(5) except KeyboardInterrupt: @@ -68,7 +71,7 @@ def job_handler(self,instruction_set): for instruction in (instruction_set): command = instruction['command'] res = None - if command == "lift" or command == "drop": + if command == "lift": res = self.reliable_send_data(self.rasp_target,str(instruction)) elif command == "grab": res = self.reliable_grab() @@ -145,5 +148,5 @@ def open_and_send(self, target,payload): -#rjr = RobotJobListener(('192.168.105.38',9000),('192.168.105.38',65432),('192.168.105.38',65433)) -#rjr.start_reliable_listener('robot') +rjr = RobotJobListener(('192.168.105.38',9000),('192.168.105.38',65432),('192.168.105.38',65433)) +rjr.start_reliable_listener('robot') diff --git a/robot_software/rasppi_listener.py b/robot_software/rasppi_listener.py index 2671fd5..4d037cc 100644 --- a/robot_software/rasppi_listener.py +++ b/robot_software/rasppi_listener.py @@ -15,15 +15,20 @@ def listen(): print('Connected by', addr) data = conn.recv(1024) - if data == b'grab': + data = data.decode("utf-8") + print(data) + + if data[0] == 'grab': print('grab') - elif data == b'prepare': + elif data[0] == 'prepare': print('prepare_grabber') - elif data == b'wait_for_bump': + elif data[0] == 'wait_for_bump': print('wait for bump') raw_input() print("BUMP!") - + elif data[0] == 'lift': + #trigger lift + print('lifting {}'.format(data[1])) conn.sendall(b'done') conn.close() listen() \ No newline at end of file From bd366bd37e32b7e3005114369312cca640a3adb1 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Thu, 28 Mar 2019 13:03:56 +0000 Subject: [PATCH 05/18] Updated Fake_DB with new shelves --- server/fake_db.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/server/fake_db.json b/server/fake_db.json index 23a4ebb..f7a5257 100755 --- a/server/fake_db.json +++ b/server/fake_db.json @@ -15,7 +15,7 @@ "name": "Appleton Tower Superstore", "image": "data:image/jpeg;base64,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", "location": { "latitude": 55.944592, "longitude": -3.18706 }, - "dimensions": { "x": 5, "y": 6, "z": [0, 0.2, 0.4] }, + "dimensions": { "x": 5, "y": 6, "z": [0, 1] }, "items": [], "merchantId": "5c755f2cbfcf4c592bfd00a5" } From 52a0bcf9ef1e51900e16883e7b958e8687e33b97 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Thu, 28 Mar 2019 14:05:57 +0000 Subject: [PATCH 06/18] Lifting added to path finding and rasp pi script --- .vscode/settings.json | 2 +- robot_software/ev3_listener.py | 12 +----------- robot_software/rasppi_coordinator.py | 16 +++++++++------- robot_software/rasppi_listener.py | 11 +++++------ server/fake_db.json | 2 +- server/robot-pathfinding.js | 13 +++++++------ 6 files changed, 24 insertions(+), 32 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 615aafb..bd53818 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,3 +1,3 @@ { - "python.pythonPath": "/usr/bin/python3" + "python.pythonPath": "/Library/Frameworks/Python.framework/Versions/3.6/bin/python3" } \ No newline at end of file diff --git a/robot_software/ev3_listener.py b/robot_software/ev3_listener.py index 5f42e76..ff171f0 100644 --- a/robot_software/ev3_listener.py +++ b/robot_software/ev3_listener.py @@ -31,8 +31,7 @@ str_instruction = str_instruction.replace('\'', '\"') str_instruction = str_instruction.replace('u\"', '\"') print(str_instruction) - #TODO: fix follow path so that it can move in or make a new function to handle it. - #MoveIn() + if str_instruction == 'move_in': if sys.argv[0] == 1: @@ -47,15 +46,6 @@ if sys.argv[0] == 1: line_follower = FollowLine() line_follower.stop() - #stop moving in - - - #else: - # robot = FollowPath() - # robot.start([extract(json.loads(str_instruction))]) - - - print('done') conn.sendall(b'done') conn.close() diff --git a/robot_software/rasppi_coordinator.py b/robot_software/rasppi_coordinator.py index 092f27b..f2ba1be 100644 --- a/robot_software/rasppi_coordinator.py +++ b/robot_software/rasppi_coordinator.py @@ -45,14 +45,13 @@ def listen_to_server(self,username): path = json.loads(r.text) print(path) if path['success'] != False: - print(path) + if path['job'] != []: self.job_handler(path['job']['instruction_set']) headers={'username':'merchant_01'} url = 'http://{}:{}/api/warehouse/5c755f58bfcf4c592bfd00a6/orders/{}'.format(self.server_info['ip'],self.server_info['port'],path['job']['id']) update = requests.post(url,headers=headers,json={'status':'READY_TO_COLLECT'}) while not(json.loads(update.text)['success']): - time.sleep(5) update = requests.post(url,headers=headers,json={'status':'READY_TO_COLLECT'}) print('notified') @@ -68,17 +67,18 @@ def listen_to_server(self,username): def job_handler(self,instruction_set): # TODO, open this on a new thread i = 0 + for instruction in (instruction_set): + print(instruction) command = instruction['command'] res = None - if command == "lift": - res = self.reliable_send_data(self.rasp_target,str(instruction)) - elif command == "grab": - res = self.reliable_grab() + + if command == "grab": + res = self.reliable_grab(instruction["parameters"]['height']) else: res = self.reliable_send_data(self.ev3_target,str(instruction)) - def reliable_grab(self): + def reliable_grab(self,height): try: global thread_manager thread_manager['bumped'] = False @@ -91,7 +91,9 @@ def reliable_grab(self): print('bump!') thread_manager['bumped'] = True #self.reliable_send_data(self.ev3_target,"stop_shelf") + self.reliable_send_data(self.rasp_target,"lift {}".format(height)) self.reliable_send_data(self.rasp_target,"grab") + self.reliable_send_data(self.rasp_target,"lift 0") self.reliable_send_data(self.ev3_target,"move_out") return except KeyboardInterrupt: diff --git a/robot_software/rasppi_listener.py b/robot_software/rasppi_listener.py index 4d037cc..fd46b39 100644 --- a/robot_software/rasppi_listener.py +++ b/robot_software/rasppi_listener.py @@ -1,5 +1,5 @@ import socket - +import json def listen(): PORT = 65432 # Port to listen on (non-privileged ports are > 1023) @@ -15,9 +15,8 @@ def listen(): print('Connected by', addr) data = conn.recv(1024) - data = data.decode("utf-8") - print(data) - + data = data.decode('utf-8') + data = data.split(' ') if data[0] == 'grab': print('grab') elif data[0] == 'prepare': @@ -27,8 +26,8 @@ def listen(): raw_input() print("BUMP!") elif data[0] == 'lift': - #trigger lift - print('lifting {}'.format(data[1])) + print('lift to {}'.format(data[1])) + conn.sendall(b'done') conn.close() listen() \ No newline at end of file diff --git a/server/fake_db.json b/server/fake_db.json index f7a5257..59c508c 100755 --- a/server/fake_db.json +++ b/server/fake_db.json @@ -79,7 +79,7 @@ "_id": "5c7565eea29bee5b5b8a5426", "name": "Irn Bru (330ml can)", "image": "data:image/jpeg;base64,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", - "position": { "x": 3, "y": 3, "z": 0 }, + "position": { "x": 3, "y": 3, "z": 1 }, "quantity": 1, "unit": null, "price": 0.65, diff --git a/server/robot-pathfinding.js b/server/robot-pathfinding.js index a2efb62..a7e2f8e 100755 --- a/server/robot-pathfinding.js +++ b/server/robot-pathfinding.js @@ -40,11 +40,12 @@ generate_drop_instruction = () => { command: 'drop' } } -generate_grab_instruction = () => { +generate_grab_instruction = (height) => { return { - command: 'grab', - parameters: {} - } + command: 'grab', + parameters: {'height':height} + } + } generate_lift_instruction = (start, end) => { @@ -98,7 +99,7 @@ convert_order_to_job = (order, robot, warehouse_grid) => { var robot_xy = [robot_pos['x'], robot_pos['y'], robot_pos['z']] for (var i = 0; i < item_list.length; i++) { var current_item = item_list[i]['position'] - var item_xy = [current_item['x'], current_item['y'], robot_pos['z']] + var item_xy = [current_item['x'], current_item['y'], current_item['z']] var path = pathfind_to_point(robot_xy, item_xy, warehouse_grid) if (path == [] || path == undefined) { @@ -111,7 +112,7 @@ convert_order_to_job = (order, robot, warehouse_grid) => { if (robot_xy[2] != item_xy[2]) { job['instruction_set'].push(generate_lift_instruction(robot_xy[2], item_xy[2])) } - job['instruction_set'].push(generate_grab_instruction()) + job['instruction_set'].push(generate_grab_instruction(item_xy[2])) // return home for (var p = path.length - 1; p > 0; p--) { job['instruction_set'].push(generate_movement_instruction(path[p], path[p - 1])) From c6ae349b2ea9b835101d4ea81121240294525e4a Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Thu, 28 Mar 2019 15:08:18 +0000 Subject: [PATCH 07/18] Changes to EV3 and Pi once onboard --- robot_software/ev3_listener.py | 84 ++++++++++++++-------------- robot_software/followLine.py | 2 +- robot_software/followPath.py | 7 ++- robot_software/rasppi_coordinator.py | 8 +-- robot_software/rasppi_listener.py | 1 - robot_software/toddler.py | 11 ++-- 6 files changed, 59 insertions(+), 54 deletions(-) diff --git a/robot_software/ev3_listener.py b/robot_software/ev3_listener.py index ff171f0..f3a0e36 100644 --- a/robot_software/ev3_listener.py +++ b/robot_software/ev3_listener.py @@ -1,51 +1,53 @@ #! /usr/bin/env python3 import sys import socket -if sys.argv[0] == 1: - from followPath import FollowPath - from bobTranslation import extract - from followLine import FollowLine - import ev3dev.ev3 as ev3 +from followPath import FollowPath +from bobTranslation import extract +from followLine import FollowLine +import ev3dev.ev3 as ev3 import json # Get local machine name +class EV3Listener: + def __init__(self): + self.path_follower = FollowPath() + def get_instructions(self): + PORT = 65433 # Port to listen on (non-privileged ports are > 1023) -PORT = 65433 # Port to listen on (non-privileged ports are > 1023) + s= socket.socket(socket.AF_INET, socket.SOCK_STREAM) + HOST = socket.gethostbyname(socket.gethostname()) + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + s.bind((HOST, PORT)) + print("Listening on {}:{}".format(HOST,PORT)) + #ev3.Sound.tone([(1000, 250, 0),(1500, 250, 0),(2000, 250, 0)]).wait() + while True: + s.listen(2) + conn, addr = s.accept() + print('Connected by', addr) -s= socket.socket(socket.AF_INET, socket.SOCK_STREAM) -HOST = socket.gethostbyname(socket.gethostname()) -s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) -s.bind((HOST, PORT)) -print("Listening on {}:{}".format(HOST,PORT)) -#ev3.Sound.tone([(1000, 250, 0),(1500, 250, 0),(2000, 250, 0)]).wait() -while True: - s.listen(2) - conn, addr = s.accept() - print('Connected by', addr) + data = conn.recv(1024) + if data: - data = conn.recv(1024) - if data: - - str_instruction = data.decode('utf-8') - str_instruction = str_instruction.replace('\'', '\"') - str_instruction = str_instruction.replace('u\"', '\"') - print(str_instruction) - - - if str_instruction == 'move_in': - if sys.argv[0] == 1: - line_follower = FollowLine() - line_follower.move_toward_shelf() - elif str_instruction == 'move_out': - print('inb') - if sys.argv[0] == 1: - line_follower = FollowLine() - line_follower.move_away_from_shelf() - elif str_instruction == 'stop_shelf': - if sys.argv[0] == 1: - line_follower = FollowLine() - line_follower.stop() - print('done') - conn.sendall(b'done') - conn.close() + str_instruction = data.decode('utf-8') + str_instruction = str_instruction.replace('\'', '\"') + str_instruction = str_instruction.replace('u\"', '\"') + print(str_instruction) + + if str_instruction == 'move_in': + self.path_follower.go('in') + elif str_instruction == 'move_out': + self.path_follower.go('out') + elif str_instruction == 'stop_shelf': + self.path_follower.go('stop') + else: + try: + movement = json.loads(str_instruction) + self.path_follower.go(extract(movement)) + except: + continue + print('done') + conn.sendall(b'done') + conn.close() +ev3 = EV3Listener() +ev3.get_instructions() \ No newline at end of file diff --git a/robot_software/followLine.py b/robot_software/followLine.py index 9adf6a1..84106cd 100644 --- a/robot_software/followLine.py +++ b/robot_software/followLine.py @@ -19,7 +19,7 @@ class FollowLine: GREEN = 3 # green reading from colour sensor in COL-COLOR mode CORRECTION_TIME = 100 # time in millisecond Bob moves away from blue line to correct sideways movement - SIDEWAYS_SPEED = 800 # how fast Bob moves when moving sideways + SIDEWAYS_SPEED = 400 # how fast Bob moves when moving sideways # Constructor def __init__(self): diff --git a/robot_software/followPath.py b/robot_software/followPath.py index d76ca85..d98747d 100644 --- a/robot_software/followPath.py +++ b/robot_software/followPath.py @@ -39,8 +39,13 @@ def go(self, path): self.last_direction = direction else: # not a valid direction for colour sensors - if direction == 'G': + if direction == 'in': ev3.Sound.speak("Scoopdidoop").wait() + line_follower.move_toward_shelf() + elif direction == 'out': + line_follower.move_toward_shelf() + elif direction == 'stop': + line_follower.stop_shelf_movement() else: ev3.Sound.speak("Wrong command given. What does", direction, "mean?").wait() line_follower.stop() diff --git a/robot_software/rasppi_coordinator.py b/robot_software/rasppi_coordinator.py index f2ba1be..e01df4e 100644 --- a/robot_software/rasppi_coordinator.py +++ b/robot_software/rasppi_coordinator.py @@ -8,7 +8,7 @@ from threading import Thread from time import sleep from bobTranslation import extract - +from rasppi_listener import listen thread_manager = {'bumped':False} class RobotJobListener(): @@ -90,7 +90,7 @@ def reliable_grab(self,height): self.reliable_send_data(self.rasp_target,"wait_for_bump") print('bump!') thread_manager['bumped'] = True - #self.reliable_send_data(self.ev3_target,"stop_shelf") + self.reliable_send_data(self.ev3_target,"stop_shelf") self.reliable_send_data(self.rasp_target,"lift {}".format(height)) self.reliable_send_data(self.rasp_target,"grab") self.reliable_send_data(self.rasp_target,"lift 0") @@ -148,7 +148,3 @@ def open_and_send(self, target,payload): print('error') return -1 - - -rjr = RobotJobListener(('192.168.105.38',9000),('192.168.105.38',65432),('192.168.105.38',65433)) -rjr.start_reliable_listener('robot') diff --git a/robot_software/rasppi_listener.py b/robot_software/rasppi_listener.py index fd46b39..375ce11 100644 --- a/robot_software/rasppi_listener.py +++ b/robot_software/rasppi_listener.py @@ -30,4 +30,3 @@ def listen(): conn.sendall(b'done') conn.close() -listen() \ No newline at end of file diff --git a/robot_software/toddler.py b/robot_software/toddler.py index 4ab9791..9d6b692 100644 --- a/robot_software/toddler.py +++ b/robot_software/toddler.py @@ -9,7 +9,6 @@ from grabber import Grabber from rasppi_coordinator import RobotJobListener - class Logger(object): def __init__(self, onRobot): self.useTerminal = not onRobot @@ -65,14 +64,18 @@ def listen(self): print('Connected by', addr) data = conn.recv(1024) - if data == b'grab': + data = data.decode('utf-8') + data = data.split(' ') + if data == 'grab': self.grabber.grab() - elif data == b'prepare': + elif data == 'prepare': self.grabber.prepare_grabber() - elif data == b'wait_for_bump': + elif data == 'wait_for_bump': while(self.getInputs()[0] == 0 or self.getInputs()[1] == 0): print("Wait for bump") print("bump") + elif data[0] == 'lift': + print('lift to {}'.format(data[1])) conn.sendall(b'done') conn.close() except KeyboardInterrupt: From e78aca684cd644ce4dcdce31003c75d3db479f98 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Fri, 29 Mar 2019 11:35:34 +0000 Subject: [PATCH 08/18] Change Ev3 to have single FollowLine object --- robot_software/ev3_listener.py | 2 +- robot_software/followLine.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/robot_software/ev3_listener.py b/robot_software/ev3_listener.py index f3a0e36..34a0eb1 100644 --- a/robot_software/ev3_listener.py +++ b/robot_software/ev3_listener.py @@ -43,7 +43,7 @@ def get_instructions(self): else: try: movement = json.loads(str_instruction) - self.path_follower.go(extract(movement)) + self.path_follower.go(extract(movement)) except: continue print('done') diff --git a/robot_software/followLine.py b/robot_software/followLine.py index c37ac55..06a97d8 100644 --- a/robot_software/followLine.py +++ b/robot_software/followLine.py @@ -19,7 +19,7 @@ class FollowLine: GREEN = 3 # green reading from colour sensor in COL-COLOR mode CORRECTION_TIME = 100 # time in millisecond Bob moves away from blue line to correct sideways movement - SIDEWAYS_SPEED = 400 # how fast Bob moves when moving sideways + SIDEWAYS_SPEED = 600 # how fast Bob moves when moving sideways # Constructor def __init__(self): From f210a6830e2932e14c3b2fb3e62ca65d85ed1059 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Fri, 29 Mar 2019 15:10:24 +0000 Subject: [PATCH 09/18] Updated Schema --- SCHEMA.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/SCHEMA.md b/SCHEMA.md index ba9d491..b03603c 100644 --- a/SCHEMA.md +++ b/SCHEMA.md @@ -31,7 +31,8 @@ Item { "position": Position, "quantity": Double, "unit": String (or null if there is no unit), - "price": Double // In GBP + "price": Double, // In GBP + "size": "tiny", "small", "large" // Tiny - 3 of these can fit in bob, Small - 2 can fit, Large - 1 can fit } Position { From dea5b27ae4f023042c50b352cbcc75259beea246 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Fri, 29 Mar 2019 15:11:33 +0000 Subject: [PATCH 10/18] Updated Fake DB --- server/fake_db.json | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/server/fake_db.json b/server/fake_db.json index 59c508c..eedb947 100755 --- a/server/fake_db.json +++ b/server/fake_db.json @@ -33,7 +33,8 @@ "quantity": 1, "unit": null, "price": 0.25, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" }, { "_id": "5c7565e1a29bee5b5b8a5422", @@ -43,7 +44,8 @@ "quantity": 1, "unit": null, "price": 0.7, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" }, { "_id": "5c7565e4a29bee5b5b8a5423", @@ -53,7 +55,8 @@ "quantity": 1, "unit": null, "price": 2.5, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"large" }, { "_id": "5c7565e6a29bee5b5b8a5424", @@ -63,7 +66,8 @@ "quantity": 1, "unit": "kg", "price": 0.8, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" }, { "_id": "5c7565eca29bee5b5b8a5425", @@ -73,27 +77,30 @@ "quantity": 1, "unit": null, "price": 2.3, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"large" }, { "_id": "5c7565eea29bee5b5b8a5426", "name": "Irn Bru (330ml can)", "image": "data:image/jpeg;base64,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", "position": { "x": 3, "y": 3, "z": 1 }, - "quantity": 1, + "quantity": 5, "unit": null, "price": 0.65, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" }, { "_id": "5c7565f1a29bee5b5b8a5427", "name": "Apple", "image": "data:image/jpeg;base64,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", - "position": { "x": 1, "y": 5, "z": 0 }, - "quantity": 1, + "position": { "x": 1, "y": 5, "z": 1 }, + "quantity": 5, "unit": "kg", "price": 1.35, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" }, { "_id": "5c7565f7a29bee5b5b8a5428", @@ -103,7 +110,8 @@ "quantity": 1, "unit": null, "price": 1.59, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"large" }, { "_id": "5c7567e034f58d5beeb55559", @@ -117,7 +125,8 @@ "quantity": 1, "unit": "kg", "price": 1.1, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" }, { "_id": "5c88f9626b55930017ca2ffa", @@ -131,7 +140,8 @@ "quantity": 1, "unit": null, "price": 0.6, - "warehouseId": "5c755f58bfcf4c592bfd00a6" + "warehouseId": "5c755f58bfcf4c592bfd00a6", + "size":"small" } ], "bob_movement": [{ "_id": "5c73f048ffb612103e1288a8", "moving": false, "markers": 1 }], From 36702c51193ac1cb86f5b22d0ecba5bc9dc06e3a Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Fri, 29 Mar 2019 15:11:39 +0000 Subject: [PATCH 11/18] Updated Pathfinding --- server/robot-pathfinding.js | 90 ++++++++++++++++++++++++++++--------- 1 file changed, 68 insertions(+), 22 deletions(-) diff --git a/server/robot-pathfinding.js b/server/robot-pathfinding.js index a7e2f8e..b115ca0 100755 --- a/server/robot-pathfinding.js +++ b/server/robot-pathfinding.js @@ -45,14 +45,14 @@ generate_grab_instruction = (height) => { command: 'grab', parameters: {'height':height} } - + x } generate_lift_instruction = (start, end) => { return { command: 'lift', parameters: { - height: Math.abs(start - end) + height: end - start } } } @@ -85,41 +85,87 @@ generate_movement_instruction = (start, end) => { } } } -convert_order_to_job = (order, robot, warehouse_grid) => { +package_items_into_groups = (item_list) => { + var sorted_items = {"tiny":[],"small":[],"large":[]} + for(var i = 0; i < item_list.length; i++) { + var item = item_list[i] + for (var j = 0; j < item['quantity']; j++) { + sorted_items[item['size']].push(item) + } + } + var item_groups = [] + item_groups.push(sorted_items.large) + for (var i = 0; i < sorted_items.small.length; i+=2) { + if (i + 1 < sorted_items.small.length) { + console.log("here") + item_groups.push([sorted_items.small[i],sorted_items.small[i+1]]) + } else { + if (sorted_items.tiny.length >= 1) { + item_groups.push([sorted_items.tiny.pop(),sorted_items.small[i]]) + } else { + + item_groups.push([sorted_items.small[i]]) + } + } + } + for (var i = 0; i < sorted_items.tiny.length; i+=3) { + to_push = [sorted_items.tiny[i]] + if (i + 1 < sorted_items.tiny.length) { + to_push.push(sorted_items.tiny[i+1]) + } + if (i + 2 < sorted_items.tiny.length) { + to_push.push(sorted_items.tiny[i+2]) + } + item_groups.push(to_push) + } + console.log(item_groups) + return item_groups +} + convert_order_to_job = (order, robot, warehouse_grid) => { if (order == undefined) { return {} } var robot_pos = robot['location'] - var item_list = order['items'] - + + const item_list = order['items'] + const item_groups = package_items_into_groups(item_list) var job = { id: order['_id'], instruction_set: [] } var robot_xy = [robot_pos['x'], robot_pos['y'], robot_pos['z']] - for (var i = 0; i < item_list.length; i++) { - var current_item = item_list[i]['position'] - var item_xy = [current_item['x'], current_item['y'], current_item['z']] - - var path = pathfind_to_point(robot_xy, item_xy, warehouse_grid) - if (path == [] || path == undefined) { - return {} + const robot_home_xy = [robot['home_x'],robot['home_y']] + // collect item groups + for (var i = 0; i < item_groups.length; i++) { + var current_group = item_groups[i] + var path = [] + for (var j = 0; j < current_group.length; j++) { + var current_item = current_group[j]['position'] + var item_xy = [current_item['x'], current_item['y'], current_item['z']] + + path = pathfind_to_point(robot_xy, item_xy, warehouse_grid) + if (path == [] || path == undefined) { + return {} + } + //go to position and grab + for (var p = 1; p < path.length; p++) { + job['instruction_set'].push(generate_movement_instruction(path[p - 1], path[p])) + } + + + job['instruction_set'].push(generate_grab_instruction(item_xy[2])) + + robot_xy = [item_xy[0],item_xy[1],0] } - //go to position and grab + // return home + path = pathfind_to_point(robot_xy, robot_home_xy, warehouse_grid) for (var p = 1; p < path.length; p++) { job['instruction_set'].push(generate_movement_instruction(path[p - 1], path[p])) } - if (robot_xy[2] != item_xy[2]) { - job['instruction_set'].push(generate_lift_instruction(robot_xy[2], item_xy[2])) - } - job['instruction_set'].push(generate_grab_instruction(item_xy[2])) - // return home - for (var p = path.length - 1; p > 0; p--) { - job['instruction_set'].push(generate_movement_instruction(path[p], path[p - 1])) - } job['instruction_set'].push(generate_drop_instruction()) + robot_xy = [robot_home_xy[0],robot_home_xy[1],0] } - + console.log(job) return job } module.exports.get_robot_path = (order, robot, warehouse) => { From d9d3fd4906c9d9e169ae1d46ab3e2d69ed05a558 Mon Sep 17 00:00:00 2001 From: Oktay Sen Date: Fri, 29 Mar 2019 15:29:45 +0000 Subject: [PATCH 12/18] Added "size" to Item in Android. --- .../main/java/io/github/assis10t/bobandroid/AddToCartDialog.kt | 3 ++- .../src/main/java/io/github/assis10t/bobandroid/pojo/Item.kt | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/android/app/src/main/java/io/github/assis10t/bobandroid/AddToCartDialog.kt b/android/app/src/main/java/io/github/assis10t/bobandroid/AddToCartDialog.kt index 4bb4083..2daa0d3 100644 --- a/android/app/src/main/java/io/github/assis10t/bobandroid/AddToCartDialog.kt +++ b/android/app/src/main/java/io/github/assis10t/bobandroid/AddToCartDialog.kt @@ -56,7 +56,8 @@ class AddToCartDialog(val activity: WarehouseActivity, val item: Item): Dialog(a item.position, Integer.parseInt(quantity.text.toString()).toDouble(), item.unit, - item.price + item.price, + item.size ) addToCart(context, cartItem) activity.refreshItems() diff --git a/android/app/src/main/java/io/github/assis10t/bobandroid/pojo/Item.kt b/android/app/src/main/java/io/github/assis10t/bobandroid/pojo/Item.kt index 565e6cf..cf52959 100644 --- a/android/app/src/main/java/io/github/assis10t/bobandroid/pojo/Item.kt +++ b/android/app/src/main/java/io/github/assis10t/bobandroid/pojo/Item.kt @@ -10,7 +10,8 @@ class Item ( val position: Position? = null, val quantity: Double? = null, val unit: String? = null, - val price: Double = 0.0 + val price: Double = 0.0, + val size: String? = null ) { companion object { fun fromString(str: String) = Gson().fromJson(str, Item::class.java) From 65b1eba7aba8855201d81f64cb1f4e3fd041b331 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Fri, 29 Mar 2019 16:21:55 +0000 Subject: [PATCH 13/18] Further Changes --- server/fake_db.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/server/fake_db.json b/server/fake_db.json index eedb947..90adb04 100755 --- a/server/fake_db.json +++ b/server/fake_db.json @@ -100,7 +100,7 @@ "unit": "kg", "price": 1.35, "warehouseId": "5c755f58bfcf4c592bfd00a6", - "size":"small" + "size":"tiny" }, { "_id": "5c7565f7a29bee5b5b8a5428", From d656df40da3f028f885e5fef78710a919b086233 Mon Sep 17 00:00:00 2001 From: Frederick Bawden Date: Fri, 29 Mar 2019 16:28:17 +0000 Subject: [PATCH 14/18] Bug Fixing and clearing log statements --- server/fake_db.json | 4 ++-- server/robot-pathfinding.js | 13 +++++-------- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/server/fake_db.json b/server/fake_db.json index 90adb04..c126750 100755 --- a/server/fake_db.json +++ b/server/fake_db.json @@ -63,7 +63,7 @@ "name": "Carrot", "image": "data:image/jpeg;base64,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", "position": { "x": 1, "y": 3, "z": 0 }, - "quantity": 1, + "quantity": 5, "unit": "kg", "price": 0.8, "warehouseId": "5c755f58bfcf4c592bfd00a6", @@ -100,7 +100,7 @@ "unit": "kg", "price": 1.35, "warehouseId": "5c755f58bfcf4c592bfd00a6", - "size":"tiny" + "size":"small" }, { "_id": "5c7565f7a29bee5b5b8a5428", diff --git a/server/robot-pathfinding.js b/server/robot-pathfinding.js index b115ca0..4a4ca38 100755 --- a/server/robot-pathfinding.js +++ b/server/robot-pathfinding.js @@ -20,7 +20,6 @@ makeWarehouse = (width, height) => { walkable_grid[s * 2][i] = 1 } } - console.log(walkable_grid) return walkable_grid } @@ -30,9 +29,7 @@ pathfind_to_point = (current_pos, end_pos, warehouse_grid) => { var path = finder.findPath(current_pos[0], current_pos[1], end_pos[0], end_pos[1], pf_grid) path = PF.Util.compressPath(path) - console.log(current_pos) - console.log(end_pos) - console.log(path) + return path } generate_drop_instruction = () => { @@ -94,10 +91,12 @@ package_items_into_groups = (item_list) => { } } var item_groups = [] - item_groups.push(sorted_items.large) + if (item_groups.length > 0) { + item_groups.push(sorted_items.large) + } + for (var i = 0; i < sorted_items.small.length; i+=2) { if (i + 1 < sorted_items.small.length) { - console.log("here") item_groups.push([sorted_items.small[i],sorted_items.small[i+1]]) } else { if (sorted_items.tiny.length >= 1) { @@ -118,7 +117,6 @@ package_items_into_groups = (item_list) => { } item_groups.push(to_push) } - console.log(item_groups) return item_groups } convert_order_to_job = (order, robot, warehouse_grid) => { @@ -165,7 +163,6 @@ package_items_into_groups = (item_list) => { job['instruction_set'].push(generate_drop_instruction()) robot_xy = [robot_home_xy[0],robot_home_xy[1],0] } - console.log(job) return job } module.exports.get_robot_path = (order, robot, warehouse) => { From 6059f489f3ae9263120e80f1cd7a8de29746becf Mon Sep 17 00:00:00 2001 From: Hristiyan Yaprakov Date: Tue, 2 Apr 2019 11:54:53 +0100 Subject: [PATCH 15/18] Add and edit size of item. --- website/assets/sass/style.sass | 5 +++- website/pages/merchant/items/create.vue | 25 +++++++++++++++++++- website/pages/merchant/items/edit/_id.vue | 18 ++++++++++++++ website/pages/merchant/items/index.vue | 6 ++++- website/pages/merchant/warehouses/_id.vue | 6 ++++- website/pages/merchant/warehouses/create.vue | 2 +- 6 files changed, 57 insertions(+), 5 deletions(-) diff --git a/website/assets/sass/style.sass b/website/assets/sass/style.sass index b415b05..25efd1a 100644 --- a/website/assets/sass/style.sass +++ b/website/assets/sass/style.sass @@ -1148,7 +1148,7 @@ footer height: auto display: block padding: 1.2rem 1.5rem - line-height: 1 + line-height: 1.3 font-size: $size-7 &.is-checkbox @@ -1160,6 +1160,9 @@ footer font-size: $size-7 font-weight: normal + i + font-size: inherit + .oh overflow: hidden diff --git a/website/pages/merchant/items/create.vue b/website/pages/merchant/items/create.vue index 830456d..74736ee 100644 --- a/website/pages/merchant/items/create.vue +++ b/website/pages/merchant/items/create.vue @@ -30,6 +30,9 @@
+

+ X and Y specify the row and column respectively and Z specifies which shelf the product will be on. +

+ + + + + +
+
+
@@ -134,6 +155,7 @@ export default { }, quantity: null, unit: null, + size: 'tiny', price: null } }, @@ -177,6 +199,7 @@ export default { position: this.position, quantity: this.quantity, unit: this.unit, + size: this.size, price: this.price, }, { headers: { diff --git a/website/pages/merchant/items/edit/_id.vue b/website/pages/merchant/items/edit/_id.vue index b20ba7c..5696fd7 100644 --- a/website/pages/merchant/items/edit/_id.vue +++ b/website/pages/merchant/items/edit/_id.vue @@ -84,6 +84,24 @@
+
+
+ +

+ Tiny - 3 of these can fit in the robots basket, Small - 2 can fit, Large - 1 can fit. +

+ +
+
diff --git a/website/pages/merchant/items/index.vue b/website/pages/merchant/items/index.vue index ce36ecd..966ab6b 100644 --- a/website/pages/merchant/items/index.vue +++ b/website/pages/merchant/items/index.vue @@ -43,6 +43,7 @@ Quantity Unit Price + Size Edit items Delete items @@ -64,7 +65,10 @@ {{ item.quantity }} - {{ item.unit }} + {{ item.unit ? item.unit : '-' }} + + + {{ item.size }} {{ item.price }} GBP diff --git a/website/pages/merchant/warehouses/_id.vue b/website/pages/merchant/warehouses/_id.vue index bd91d3f..7610897 100644 --- a/website/pages/merchant/warehouses/_id.vue +++ b/website/pages/merchant/warehouses/_id.vue @@ -117,6 +117,7 @@ Position Quantity Unit + Size Price Edit items Delete items @@ -139,7 +140,10 @@ {{ item.quantity }} - {{ item.unit }} + {{ item.unit ? item.unit : '-' }} + + + {{ item.size }} {{ item.price }} GBP diff --git a/website/pages/merchant/warehouses/create.vue b/website/pages/merchant/warehouses/create.vue index eb004e7..f47a324 100644 --- a/website/pages/merchant/warehouses/create.vue +++ b/website/pages/merchant/warehouses/create.vue @@ -38,7 +38,7 @@

- Enter the dimensions of the warehouse. X and Y values are the amount of rows and columns that the warehouse phisically has for the robot. + Enter the dimensions of the warehouse. X and Y values are the amount of rows and columns that the warehouse physically has for the robot.

From 6eec09037247d0415257a599dab4b7993e3c04f7 Mon Sep 17 00:00:00 2001 From: Hristiyan Yaprakov Date: Tue, 2 Apr 2019 14:57:59 +0100 Subject: [PATCH 16/18] Localise MDI --- website/nuxt.config.js | 7 ++++--- website/package-lock.json | 18 ++++++++++++++++++ website/package.json | 2 ++ 3 files changed, 24 insertions(+), 3 deletions(-) diff --git a/website/nuxt.config.js b/website/nuxt.config.js index 3704d6a..89d1c34 100644 --- a/website/nuxt.config.js +++ b/website/nuxt.config.js @@ -16,8 +16,8 @@ module.exports = { ], link: [ { rel: 'icon', type: 'image/x-icon', href: '/favicon.ico' }, - { rel: 'stylesheet', type: 'text/css', href: '//cdn.materialdesignicons.com/2.0.46/css/materialdesignicons.min.css' }, - { rel: 'stylesheet', type: 'text/css', href: 'https://fonts.googleapis.com/css?family=Raleway&Open+Sans' } + // { rel: 'stylesheet', type: 'text/css', href: '//cdn.materialdesignicons.com/2.0.46/css/materialdesignicons.min.css' }, + // { rel: 'stylesheet', type: 'text/css', href: 'https://fonts.googleapis.com/css?family=Raleway&Open+Sans' } ] }, @@ -34,7 +34,8 @@ module.exports = { ** Global CSS */ css: [ - '@/assets/sass/style.sass' + '@/assets/sass/style.sass', + '@/node_modules/@mdi/font/css/materialdesignicons.min.css', ], /* diff --git a/website/package-lock.json b/website/package-lock.json index da0c44d..f72e2c0 100644 --- a/website/package-lock.json +++ b/website/package-lock.json @@ -974,6 +974,11 @@ "resolved": "https://registry.npmjs.org/@firebase/webchannel-wrapper/-/webchannel-wrapper-0.2.12.tgz", "integrity": "sha512-1QWhGGu03NjPYk45w5muLq6a43Fhvd5+LGZrPydXLs7/FgQHqW6aSKmJClTwBHP1rynLSLLA7+9E/35cur6g/g==" }, + "@mdi/font": { + "version": "3.5.95", + "resolved": "https://registry.npmjs.org/@mdi/font/-/font-3.5.95.tgz", + "integrity": "sha512-WHSJ0TJ70qkn+EPsW9w22pQU+kjEnRZlfN4N7xsFFmKa6VhpdQcwTWqj9PDH3oq6Be2p0IW/VDURJvPWDnBAUw==" + }, "@nuxt/babel-preset-app": { "version": "2.4.2", "resolved": "https://registry.npmjs.org/@nuxt/babel-preset-app/-/babel-preset-app-2.4.2.tgz", @@ -7402,6 +7407,11 @@ "object-visit": "^1.0.0" } }, + "material-design-icons": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/material-design-icons/-/material-design-icons-3.0.1.tgz", + "integrity": "sha1-mnHEh0chjrylHlGmbaaCA4zct78=" + }, "md5.js": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", @@ -8024,6 +8034,14 @@ "@nuxt/webpack": "2.4.2" } }, + "nuxt-material-design-icons": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/nuxt-material-design-icons/-/nuxt-material-design-icons-1.0.4.tgz", + "integrity": "sha512-1DwI3n7zLIMO+dV87JUSohhF6yFtIXyzBZ15YLQYSDEQWFBpo/3k1excO1dooaaGVJFS4ObnOCreiy4Xov4t/A==", + "requires": { + "material-design-icons": "^3.0.1" + } + }, "nwsapi": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.1.0.tgz", diff --git a/website/package.json b/website/package.json index 670c670..2a266fc 100644 --- a/website/package.json +++ b/website/package.json @@ -12,6 +12,7 @@ "test": "jest" }, "dependencies": { + "@mdi/font": "^3.5.95", "@nuxtjs/axios": "^5.3.6", "@nuxtjs/bulma": "^1.2.1", "axios": "^0.18.0", @@ -20,6 +21,7 @@ "firebase": "^5.8.2", "node-sass": "^4.11.0", "nuxt": "^2.3.4", + "nuxt-material-design-icons": "^1.0.4", "sass-loader": "^7.1.0", "vue-cookies": "^1.5.12", "vue-headroom": "^0.9.0", From 9c342368073227bb14f511c34dbd0bab91c5483f Mon Sep 17 00:00:00 2001 From: Hristiyan Yaprakov Date: Thu, 4 Apr 2019 13:21:27 +0100 Subject: [PATCH 17/18] User testing fixes --- website/pages/merchant/items/create.vue | 23 ++++++----- website/pages/merchant/items/edit/_id.vue | 2 +- website/pages/merchant/warehouses/create.vue | 42 +++++++++++++------- 3 files changed, 42 insertions(+), 25 deletions(-) diff --git a/website/pages/merchant/items/create.vue b/website/pages/merchant/items/create.vue index 74736ee..1f494f9 100644 --- a/website/pages/merchant/items/create.vue +++ b/website/pages/merchant/items/create.vue @@ -16,7 +16,7 @@
- +
@@ -43,7 +43,7 @@
@@ -56,7 +56,7 @@
@@ -69,7 +69,7 @@
@@ -78,12 +78,15 @@
- +
+

+ kg, lbs, litres, etc... or blank. +

@@ -107,7 +110,7 @@
- +
@@ -146,17 +149,17 @@ export default { warehouseId: this.$nuxt._route.params.id, warehouse: {}, - name: null, + name: "", image: null, position: { x: 0, y: 0, z: 0, }, - quantity: null, + quantity: "", unit: null, size: 'tiny', - price: null + price: "" } }, methods: { @@ -222,7 +225,7 @@ export default { }, computed: { can_submit: function () { - return this.name && this.quantity && this.price + return this.name.toString().length > 0 && this.quantity.toString().length > 0 && this.price.toString().length > 0 } }, mounted: function () { diff --git a/website/pages/merchant/items/edit/_id.vue b/website/pages/merchant/items/edit/_id.vue index 5696fd7..8688a1f 100644 --- a/website/pages/merchant/items/edit/_id.vue +++ b/website/pages/merchant/items/edit/_id.vue @@ -3,7 +3,7 @@

- Add item + Edit item

diff --git a/website/pages/merchant/warehouses/create.vue b/website/pages/merchant/warehouses/create.vue index f47a324..30916c1 100644 --- a/website/pages/merchant/warehouses/create.vue +++ b/website/pages/merchant/warehouses/create.vue @@ -12,7 +12,7 @@
- +
@@ -42,22 +42,33 @@

- +
- +

The Z values are the amount of shelfs and their respected heights from the robot's perspective. (Include bottom shelf as 0.0)

- + class="is-flex align-center mb10"> + + + + + + +
Add a shelf @@ -95,15 +106,15 @@ export default { }, data: function () { return { - name: null, + name: "", image: null, location: { - latitude: null, - longitude: null + latitude: "", + longitude: "" }, dimensions: { - x: null, - y: null, + x: "", + y: "", z: [ 0.0 ] @@ -114,6 +125,9 @@ export default { addShelf: function () { this.dimensions.z.push(this.dimensions.z[this.dimensions.z.length - 1]) }, + deleteShelf: function (i) { + this.dimensions.z.splice(i, 1) + }, uploadFile: function (event) { let file = event.target.files[0] this.createImage(file); @@ -158,7 +172,7 @@ export default { }, computed: { can_submit: function () { - return this.name && this.location.latitude && this.location.longitude && this.dimensions.x && this.dimensions.y + return this.name.toString().length > 0 && this.dimensions.x.toString().length > 0 && this.dimensions.y.toString().length > 0 } } }; From 3301f232029024a797c10fd9dc87459bb5a6b762 Mon Sep 17 00:00:00 2001 From: Oktay Sen Date: Thu, 4 Apr 2019 13:41:42 +0100 Subject: [PATCH 18/18] Removed file that was supposed to not exist. --- robot_software/rasppi_listener.py | 32 ------------------------------- 1 file changed, 32 deletions(-) delete mode 100644 robot_software/rasppi_listener.py diff --git a/robot_software/rasppi_listener.py b/robot_software/rasppi_listener.py deleted file mode 100644 index 375ce11..0000000 --- a/robot_software/rasppi_listener.py +++ /dev/null @@ -1,32 +0,0 @@ -import socket -import json - -def listen(): - PORT = 65432 # Port to listen on (non-privileged ports are > 1023) - - s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - HOST = socket.gethostbyname(socket.gethostname()) - s.bind((HOST, PORT)) - print("Listening on {}:{}".format(HOST,PORT)) - while True: - s.listen(1) - conn, addr = s.accept() - - print('Connected by', addr) - - data = conn.recv(1024) - data = data.decode('utf-8') - data = data.split(' ') - if data[0] == 'grab': - print('grab') - elif data[0] == 'prepare': - print('prepare_grabber') - elif data[0] == 'wait_for_bump': - print('wait for bump') - raw_input() - print("BUMP!") - elif data[0] == 'lift': - print('lift to {}'.format(data[1])) - - conn.sendall(b'done') - conn.close()