def __init__(self, motion, clockwise, speed, time): self.robotcontrol = RobotControl(robot_name="summit") self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 7.0 # This is an estimate time in which the robot will rotate 90 degrees
def __init__(self, motion, clockwise, speed, time): self.RC = RobotControl() self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 7.0
def get_laser_readings(self): output = [] rc = RobotControl() laser = rc.get_laser_full() output.append(laser[719]) output.append(laser[0]) return output
def __init__(self, moveDirection, turnDirection, speed): self.RobotControl = RobotControl() self.moveDirection = moveDirection self.turnDirection = turnDirection self.speed = speed self.timeTurn = 4.80 #Set to get as close to 90 degrees as possible self.left = 0 #Sets leftmost laser value self.middle = 360 #sets middle laser value self.right = 719 #sets rightmost laser value
def __init__(self, motion, clockwise, speed, time): self.robot = RobotControl() self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 2.5 self.turn_speed = speed self.full_laser = self.robot.get_laser_full() self.full_laser2 = self.robot.get_laser_full()
def get_highest_lowest(): from robot_control_class import RobotControl rc = RobotControl() laser_readings = [] laser_readings = rc.get_laser_full() max = 0 low = 1000000000000000000000 for costas in range(0, 720): if laser_readings[costas] > max and laser_readings[costas] != float( "inf"): max = laser_readings[costas] max_pos = costas if laser_readings[costas] < low: min = laser_readings[costas] min_pos = costas return max_pos, min_pos
def get_higest_lowest(): rc = RobotControl() lc1 = rc.get_laser_full() #lc1 = [1,2,3,4,5,float('inf')] lc = [] for x in lc1: if not math.isinf(x): #print (x) lc.append(x) #print (lc) #print (lc1) lw = min(lc) #print(lw) hw = max(lc) return lc1.index(hw), lc1.index(lw) #j = get_higest_lowest() #print (j)
class Project: def __init__(self,speed,time): self.rc=RobotControl() self.motion=None self.speed=speed self.time=time self.d=None def dist(self): return(self.rc.get_laser(360)) def mov(self): distance=self.dist() while True: while (distance>1): self.rc.move_straight() distance=self.dist() print("Current distance from wall : ", distance) self.rc.stop_robot() self.motion=self.where_turn() self.rc.turn(self.motion,self.speed,self.time) print("turning ", self.motion) distance=self.dist() def where_turn(self): self.d=self.rc.get_laser_full() l1=[] l2=[] cnt=len(self.d) i=0 j=cnt/2 while(i<cnt/2): l1.append(self.d[i]) i=i+1 while(j<cnt): l2.append(self.d[j]) j=j+1 v1,v2=self.mean(l1,l2) print("sum of right= ",v1) print("sum of left= ",v2) if(v1>v2): self.d=None return "clockwise" else: self.d=None return "counter-clockwise" def mean(self,x,y): x=np.asarray(x) y=np.asarray(y) m1=np.sum(x) m2=np.sum(y) return [m1,m2]
class MoveRobot: def __init__(self, motion, clockwise, speed, time): self.RC = RobotControl() self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 7.0 def move_straight(self): self.RC.move_straight_time(self.motion, self.speed, self.time_turn) def turn(self): self.RC.turn(self.clockwise, self.speed, self.time_turn) def do_square(self): i = 0 while (i < 4): self.move_straight() self.turn() i = i + 1
def get_highest_lowest(): from robot_control_class import RobotControl rc = RobotControl() lr_list = [] lr_list = rc.get_laser_full() max_val = 0 min_val = 100000000000000000000000 max_pos = 0 min_pos = 0 for item in range(0, 720): if lr_list[item] > max_val and lr_list[item] != float("inf"): max_val = lr_list[item] max_pos = item if lr_list[item] < min_val: min_val = lr_list[item] min_pos = item return max_pos, min_pos
class square: def __init__(self, motion, clockwise, speed, time): self.rc = RobotControl() self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.turn_time = 7 def sq(self): i = 0 while i < 4: self.move_straight() self.turn() i += 1 def move_straight(self): self.rc.move_straight_time(self.motion, self.speed, self.time) def turn(self): self.rc.turn(self.clockwise, self.speed, self.turn_time)
class MoveRobot: def __init__(self, motion, clockwise, speed, time): self.robotcontrol = RobotControl(robot_name="summit") self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 7.0 # This is an estimate time in which the robot will rotate 90 degrees def do_square(self): i = 0 while (i < 4): self.move_straight() self.turn() i+=1 def move_straight(self): self.robotcontrol.move_straight_time(self.motion, self.speed, self.time) def turn(self): self.robotcontrol.turn(self.clockwise, self.speed, self.time_turn)
def get_highest_lowest(): rc = RobotControl() laser = rc.get_laser_full() laser_dict = {} output = [] for i, elem in enumerate(laser): if not math.isinf(elem): laser_dict[i] = elem max_val = max(laser_dict.values()) min_val = min(laser_dict.values()) print(max_val, min_val) for key, val in laser_dict.items( ): # for name, age in dictionary.iteritems(): (for Python 2.x) if val == max_val: output.append(key) break for key, val in laser_dict.items( ): # for name, age in dictionary.iteritems(): (for Python 2.x) if val == min_val: output.append(key) break return output
def main(self): rc = RobotControl() d_left, d_right = self.get_laser_readings() print(d_left, d_right) while True: rc.move_straight() d_left, d_right = self.get_laser_readings() print(d_left, d_right) if (math.isinf(d_left)) and (math.isinf(d_right)): break rc.stop_robot()
class ExamControl: def __init__(self): self.rc = RobotControl() def get_laser_readings(self): self.lf = self.rc.get_laser(719) self.rf = self.rc.get_laser(0) return self.lf, self.rf def main(self): self.l, self.r = self.get_laser_readings() #print (self.l,self.r) while not math.isinf(self.l) or not math.isinf(self.r): self.rc.move_straight() self.l, self.r = self.get_laser_readings() self.rc.stop_robot()
from robot_control_class import RobotControl rc = RobotControl() a = rc.get_laser(360) if a < 1: rc.stop_robot() else: rc.move_straight() print(a)
from robot_control_class import RobotControl rc = RobotControl() l = rc.get_laser_full() print("Position 0: ", l[0]) print("Position 360: ", l[360]) print("Position 719: ", l[719])
from robot_control_class import RobotControl robotcontrol = RobotControl() robotcontrol.turn("counter-clockwise", 0.3, 4) robotcontrol.move_straight_time("forward", 0.3, 6) robotcontrol.turn("counter-clockwise", 0.3, 4) robotcontrol.move_straight_time("forward", 0.3, 7)
#!/usr/bin/env python import sys from robot_control_class import RobotControl rc = RobotControl() all_dist = rc.get_laser_full() min_dist = min(all_dist) while min_dist > 0.3: rc.move_straight() all_dist = rc.get_laser_full() min_dist = min(all_dist) print("The minimal distance to an object is {}".format(min_dist)) rc.stop_robot() print("The final minimal distance is {}".format(min_dist))
from robot_control_class import RobotControl rc = RobotControl() rc.stop_robot() while True: d = rc.get_laser(360) print(d) if (d > 1): rc.move_straight() else: rc.stop_robot() l = rc.get_laser(719) r = rc.get_laser(1) if (l > r): rc.turn("counter-clockwise",4,.399) else: rc.turn("clockwise",4,.399)
from robot_control_class import RobotControl rc = RobotControl() #exercise 4.3 #rc.move_straight_time("forward", 1.0, 5) #rc.turn("clockwise", 190, 7) #exercise 4.4 rc.move_straight_time("forward", 1.0, 2) rc.turn("clockwise", 1.0, 7) rc.move_straight_time("forward", 1.0, 2.2) rc.turn("clockwise", 1.0, 7) rc.move_straight_time("forward", 1.0, 5)
from robot_control_class import RobotControl import time robotcontrol = RobotControl() class MoveRobot: def __init__(self, motion, clockwise, speed, time): self.robot = RobotControl() self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 2.5 self.turn_speed = speed self.full_laser = self.robot.get_laser_full() self.full_laser2 = self.robot.get_laser_full() #Code above initialize the construct and the variable class wich belongs the class MoveROBOT def out_maze(self): corner = 0 maximo = 0 #While loop used to find the labirint exit, by searching the door though the sensor "inf" value #When the door is found then start the door_maze function below this one #The full laser data is get setting the maximp< infinito, so it will always get the data while(maximo < float("inf")): self.full_laser = self.robot.get_laser_full() maximo = 0 #The maximo was set to =0 above to enter in the while loop,but must be update in this loop to achieve a value #bigger than 1 and so the robot contemplate a escape of a wall that it is close it. The code below is useful #to let the robot get free from a "trap", in other words when it be very close to a wall #The block below will turn the robot until if finds the higher distance value, while it is close the wall
#Exercise 3,1 #Arnaldo Jr import time from robot_control_class import RobotControl #importa uma classe robotcontrol = RobotControl() #criando um objeto def robotmove(a): robotcontrol.move_straight() time.sleep(a) robotcontrol.stop_robot() print('Forneca 3 valores entre 0 e 719.') value = [0, 1, 2] value[0] = input('valor 1:') value[1] = input('valor 2:') value[2] = input('valor 3:') print(value) #robotmove(5) laser1 = robotcontrol.get_laser(360) print(laser1)
def sleept(t=5): rc = RobotControl() rc.move_straight() time.sleep(t) rc.stop_robot()
class MoveRobot: def __init__(self, motion, clockwise, speed, time): self.robot = RobotControl() self.motion = motion self.clockwise = clockwise self.speed = speed self.time = time self.time_turn = 2.5 self.turn_speed = speed self.full_laser = self.robot.get_laser_full() self.full_laser2 = self.robot.get_laser_full() #Code above initialize the construct and the variable class wich belongs the class MoveROBOT def out_maze(self): corner = 0 maximo = 0 #While loop used to find the labirint exit, by searching the door though the sensor "inf" value #When the door is found then start the door_maze function below this one #The full laser data is get setting the maximp< infinito, so it will always get the data while(maximo < float("inf")): self.full_laser = self.robot.get_laser_full() maximo = 0 #The maximo was set to =0 above to enter in the while loop,but must be update in this loop to achieve a value #bigger than 1 and so the robot contemplate a escape of a wall that it is close it. The code below is useful #to let the robot get free from a "trap", in other words when it be very close to a wall #The block below will turn the robot until if finds the higher distance value, while it is close the wall while(maximo < 1): #For loop to get the maximum value from the laser scan reading for value in self.full_laser: if value > maximo: maximo = value if(maximo < 1): self.turn() print("Current Maximum laser distace is %f" % maximo) #After getting the maximum value you need to make the robot move in its direction.Turn the robot around #till its frontal laser is the close enough to the maximum value - this is represented in the code by max-1 #and max!=infinite arguments. now its facing the right direction, or at least almost there.The codebelow #will turn the robot around until the FRONT LASER BEAM = 360 find the max distance and get out the turn loop #To be honest the loop would calculate forever the max value because it has 720 beams so each beam should be #compared while turning to give back the biggest value. This is done faster using a tolerance,. This tolerance #is put with maximo - [value] in this case 1 meter, so when the robot beams have a value of max aroun 6 meters #for example it will fast accecpt the distance of 5 meter as the "infinite" distance and get out the turn loop #to start the move_straight loop while(self.robot.get_front_laser() < maximo -1 and maximo != float("inf")): print("Robot frontal laser distance: %f", self.robot.get_front_laser()) self.turn() #The code above is turning the robot until it finds the "first" distance shorter or close to the infinite #distance value, when it arrives in this value (represented by max-1) it will get out the loop and stop #turning. Then the code below enters in action ( to be honest is being compiled in paralell) so if the robot #is not turning mean it is going ahead until find a wall (laser<1), then this programming block will stop_robot # and the previous blocks will work (turn and turn the robot until find again an "almost-infinite" value) #When one of these 3 blocks be reached the function stop_robot will work, avoiding simultaneously confusion #while executing a move while (self.robot.get_front_laser() > 1): self.move_straight() self.stop_robot() def door_maze(self): #Define the region frontal the robot to laser reading, 270 - 470 correspond 45 degrees of range which #the robot will consider to calculate the max distace === infinit #Here the laser scan data will calculate the most distance value = infinit. If not achieve the infinit #value it means that it is near a wall and thus will go to the second loop (to turn and find the next #laser scan data which is "infinite") the counter pass reading all the matrix laser data values, until #get out the loop and then move_straight #Her if the robot frontal (45 degrees cone range: 270:450) is already getting the infinite value, so the robot #will go toward it. The counter +=1 is just to read all the values inside user laser ( the beams 270 to 450). If #any of them calculate an infinite value the robot will go and try get out the maze i_counter = 0 self.full_laser = self.robot.get_laser_full() use_laser = self.full_laser[270:450] for i in use_laser: if i == float("inf"): i_counter += 1 #Just enter in this loop if the door is not find at first #Then the robot starts turn around until its facing the door #The counter is used to define wheter the robot is in the rigth direction or not #In case its not, then the robot will turn again till the criteria is met #If the robot still did not find the infinite value (more distance from a wall), so it will need to turns #because maybe it is turned with its back for the free destination. So the counter will read again the #laser scan front robot range and turn and turn until find the infinite value (more distant from a obstacle) #to get out the loop ( already read all the use_laser matrix values with counter and comapared to find the big one) #and all the beams=90. So it can get out the loop, because found the greatest value and move straight out the maze! while(i_counter < 90): self.turn() self.full_laser = self.robot.get_laser_full() use_laser = self.full_laser[270:450] i_counter = 0 for i in use_laser: if i == float("inf"): i_counter += 1 self.move_straight_time() def move_straight_time(self): self.robot.move_straight_time(self.motion, self.speed, self.time) def move_straight(self): self.robot.move_straight() def turn(self): self.robot.turn(self.clockwise,self.turn_speed,self.time_turn) def stop_robot(self): self.robot.stop_robot()
from robot_control_class import RobotControl robot = RobotControl() def movimento(): global a global b a = "forward" b = "counter-clockwise" movimento() direcao = robot.move_straight_time(a, 0.75, 5) giro = robot.turn(b, 0.45, 10) print ("O robo se deslocou com os seguinte parametros:", direcao ) print ("O robo girou com os seguintes parametros:", giro )
from robot_control_class import RobotControl rc = RobotControl() rc.stop_robot() rc.move_straight_time("forward", 4, 0.15) rc.turn("counter-clockwise", 4, .5) rc.move_straight_time("forward", 4, .5) rc.turn("counter-clockwise", 4, .5) rc.move_straight_time("forward", 10, .2)
R2 = robocontrol.get_laser(0) R2 = limited_decimals(R) if (l == 1): L1 = robocontrol.get_laser(600) L1 = limited_decimals(L1) elif (l == 2): L2 = robocontrol.get_laser(719) L2 = limited_decimals(L) if (r == 1): return L1, F, R1 else: return L2, F, R2 x = time.time() robocontrol = RobotControl() while True: L, F, R = get_laser(1, 1) print("L =", L, "F =", F, "R =", R) if (L < 100 or F < 100 or R < 100): if (((R < 0.6 or L < 0.6) and F > 1.3) or (L < 0.4 or R < 0.4)): robocontrol.stop_robot() if (R < 0.6): print("go left_forward") robocontrol.move_straight_time("backward", 0.3, 3) robocontrol.turn("counter-clockwise", 0.3, 0.5) robocontrol.move_straight() elif (L < 0.6): print("go right_forward") robocontrol.move_straight_time("backward", 0.3, 3)
from robot_control_class import RobotControl rc = RobotControl() laser1 = rc.get_laser(280) print("laser1=", laser1) laser2 = rc.get_laser(420) print("laser2=", laser2) laser3 = rc.get_laser(500) print("laser3=", laser3) #print ("The distance measured is: ", a)
#!/usr/bin/env python import sys from robot_control_class import RobotControl rc = RobotControl() dist = rc.get_laser(0) while dist > 1: rc.move_straight() dist = rc.get_laser(0) print("The distance to a wall is {}".format(dist)) rc.stop_robot() print("The final distance is {}".format(dist))