def get_laser_readings(self):
output = []
rc = RobotControl()
laser = rc.get_laser_full()
output.append(laser[719])
output.append(laser[0])
return output
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]
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)
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
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
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()
#!/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))
#Exercise 2.4
#arnaldo Jr
from robot_control_class import RobotControl #importa uma classe
robotcontrol = RobotControl() #criando um objeto
laser = robotcontrol.get_laser_full()
#laser = [50, 100000, 3]
lower_value = 10000
for value in laser:
#print(value)
if value < lower_value:
lower_value = value
print("The lower_value is: ", lower_value)
from robot_control_class import RobotControl
rc = RobotControl()
test = rc.get_laser_full()
#exercise 3.3
maxVal = 0
for val in test:
if val > maxVal:
maxVal = val
print("farthest distance from wall is = ", maxVal)
from robot_control_class import RobotControl rc = RobotControl() happy_list = [] happy_list = rc.get_laser_full() print(happy_list[0], happy_list[360], happy_list[719])
from robot_control_class import RobotControl
rc = RobotControl()
maximo = 0
maior = rc.get_laser_full()
#maior2 = [20, 40, 90]
for value in maior:
if value > maximo:
maximo = value
print "Max value of laser data:%f " % maximo
from robot_control_class import RobotControl
import math
rc = RobotControl()
laser = rc.get_laser_full()
while laser[360] >= 1:
rc.move_straight()
laser = rc.get_laser_full()
rc.stop_robot()
rc.turn("clockwise", 0.2, 7)
from robot_control_class import RobotControl
rc = RobotControl()
while rc.get_laser(360) > 1:
rc.move_straight()
rc.stop_robot()
rc.rotate(80)
rc.stop_robot()
while rc.get_laser(360) > 1:
rc.move_straight()
rc.stop_robot()
rc.rotate(80)
rc.stop_robot()
while rc.get_laser(360) > 1:
rc.move_straight()
rc.stop_robot()
rc.rotate(-90)
rc.stop_robot()
print(rc.get_laser_full())
rc.move_straight_time("forward", 0.5, 7)
rc.turn("clockwise", 0.2, 2)
rc.move_straight_time("forward", 0.5, 7)
from robot_control_class import RobotControl
rc = RobotControl()
lists=rc.get_laser_full()
print("Position 0: ",lists[0])
print("Position 360: ",lists[360])
print("Position 719: ",lists[719])
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
rc = RobotControl()
readings = []
readings = rc.get_laser_full()
bigger = 0
for metrisi in readings:
if metrisi > bigger:
bigger = metrisi
print("THe higher value is: ", bigger)
